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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.18.50/] [bfd/] [elf64-sparc.c] - Blame information for rev 156

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 38 julius
/* SPARC-specific support for 64-bit ELF
2
   Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3
   2003, 2004, 2005, 2007, 2008 Free Software Foundation, Inc.
4
 
5
   This file is part of BFD, the Binary File Descriptor library.
6
 
7
   This program is free software; you can redistribute it and/or modify
8
   it under the terms of the GNU General Public License as published by
9
   the Free Software Foundation; either version 3 of the License, or
10
   (at your option) any later version.
11
 
12
   This program is distributed in the hope that it will be useful,
13
   but WITHOUT ANY WARRANTY; without even the implied warranty of
14
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
   GNU General Public License for more details.
16
 
17
   You should have received a copy of the GNU General Public License
18
   along with this program; if not, write to the Free Software
19
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20
   MA 02110-1301, USA.  */
21
 
22
#include "sysdep.h"
23
#include "bfd.h"
24
#include "libbfd.h"
25
#include "elf-bfd.h"
26
#include "elf/sparc.h"
27
#include "opcode/sparc.h"
28
#include "elfxx-sparc.h"
29
 
30
/* In case we're on a 32-bit machine, construct a 64-bit "-1" value.  */
31
#define MINUS_ONE (~ (bfd_vma) 0)
32
 
33
/* Due to the way how we handle R_SPARC_OLO10, each entry in a SHT_RELA
34
   section can represent up to two relocs, we must tell the user to allocate
35
   more space.  */
36
 
37
static long
38
elf64_sparc_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED, asection *sec)
39
{
40
  return (sec->reloc_count * 2 + 1) * sizeof (arelent *);
41
}
42
 
43
static long
44
elf64_sparc_get_dynamic_reloc_upper_bound (bfd *abfd)
45
{
46
  return _bfd_elf_get_dynamic_reloc_upper_bound (abfd) * 2;
47
}
48
 
49
/* Read  relocations for ASECT from REL_HDR.  There are RELOC_COUNT of
50
   them.  We cannot use generic elf routines for this,  because R_SPARC_OLO10
51
   has secondary addend in ELF64_R_TYPE_DATA.  We handle it as two relocations
52
   for the same location,  R_SPARC_LO10 and R_SPARC_13.  */
53
 
54
static bfd_boolean
55
elf64_sparc_slurp_one_reloc_table (bfd *abfd, asection *asect,
56
                                   Elf_Internal_Shdr *rel_hdr,
57
                                   asymbol **symbols, bfd_boolean dynamic)
58
{
59
  PTR allocated = NULL;
60
  bfd_byte *native_relocs;
61
  arelent *relent;
62
  unsigned int i;
63
  int entsize;
64
  bfd_size_type count;
65
  arelent *relents;
66
 
67
  allocated = (PTR) bfd_malloc (rel_hdr->sh_size);
68
  if (allocated == NULL)
69
    goto error_return;
70
 
71
  if (bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0
72
      || bfd_bread (allocated, rel_hdr->sh_size, abfd) != rel_hdr->sh_size)
73
    goto error_return;
74
 
75
  native_relocs = (bfd_byte *) allocated;
76
 
77
  relents = asect->relocation + canon_reloc_count (asect);
78
 
79
  entsize = rel_hdr->sh_entsize;
80
  BFD_ASSERT (entsize == sizeof (Elf64_External_Rela));
81
 
82
  count = rel_hdr->sh_size / entsize;
83
 
84
  for (i = 0, relent = relents; i < count;
85
       i++, relent++, native_relocs += entsize)
86
    {
87
      Elf_Internal_Rela rela;
88
      unsigned int r_type;
89
 
90
      bfd_elf64_swap_reloca_in (abfd, native_relocs, &rela);
91
 
92
      /* The address of an ELF reloc is section relative for an object
93
         file, and absolute for an executable file or shared library.
94
         The address of a normal BFD reloc is always section relative,
95
         and the address of a dynamic reloc is absolute..  */
96
      if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0 || dynamic)
97
        relent->address = rela.r_offset;
98
      else
99
        relent->address = rela.r_offset - asect->vma;
100
 
101
      if (ELF64_R_SYM (rela.r_info) == 0)
102
        relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
103
      else
104
        {
105
          asymbol **ps, *s;
106
 
107
          ps = symbols + ELF64_R_SYM (rela.r_info) - 1;
108
          s = *ps;
109
 
110
          /* Canonicalize ELF section symbols.  FIXME: Why?  */
111
          if ((s->flags & BSF_SECTION_SYM) == 0)
112
            relent->sym_ptr_ptr = ps;
113
          else
114
            relent->sym_ptr_ptr = s->section->symbol_ptr_ptr;
115
        }
116
 
117
      relent->addend = rela.r_addend;
118
 
119
      r_type = ELF64_R_TYPE_ID (rela.r_info);
120
      if (r_type == R_SPARC_OLO10)
121
        {
122
          relent->howto = _bfd_sparc_elf_info_to_howto_ptr (R_SPARC_LO10);
123
          relent[1].address = relent->address;
124
          relent++;
125
          relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
126
          relent->addend = ELF64_R_TYPE_DATA (rela.r_info);
127
          relent->howto = _bfd_sparc_elf_info_to_howto_ptr (R_SPARC_13);
128
        }
129
      else
130
        relent->howto = _bfd_sparc_elf_info_to_howto_ptr (r_type);
131
    }
132
 
133
  canon_reloc_count (asect) += relent - relents;
134
 
135
  if (allocated != NULL)
136
    free (allocated);
137
 
138
  return TRUE;
139
 
140
 error_return:
141
  if (allocated != NULL)
142
    free (allocated);
143
  return FALSE;
144
}
145
 
146
/* Read in and swap the external relocs.  */
147
 
148
static bfd_boolean
149
elf64_sparc_slurp_reloc_table (bfd *abfd, asection *asect,
150
                               asymbol **symbols, bfd_boolean dynamic)
151
{
152
  struct bfd_elf_section_data * const d = elf_section_data (asect);
153
  Elf_Internal_Shdr *rel_hdr;
154
  Elf_Internal_Shdr *rel_hdr2;
155
  bfd_size_type amt;
156
 
157
  if (asect->relocation != NULL)
158
    return TRUE;
159
 
160
  if (! dynamic)
161
    {
162
      if ((asect->flags & SEC_RELOC) == 0
163
          || asect->reloc_count == 0)
164
        return TRUE;
165
 
166
      rel_hdr = &d->rel_hdr;
167
      rel_hdr2 = d->rel_hdr2;
168
 
169
      BFD_ASSERT (asect->rel_filepos == rel_hdr->sh_offset
170
                  || (rel_hdr2 && asect->rel_filepos == rel_hdr2->sh_offset));
171
    }
172
  else
173
    {
174
      /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
175
         case because relocations against this section may use the
176
         dynamic symbol table, and in that case bfd_section_from_shdr
177
         in elf.c does not update the RELOC_COUNT.  */
178
      if (asect->size == 0)
179
        return TRUE;
180
 
181
      rel_hdr = &d->this_hdr;
182
      asect->reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
183
      rel_hdr2 = NULL;
184
    }
185
 
186
  amt = asect->reloc_count;
187
  amt *= 2 * sizeof (arelent);
188
  asect->relocation = (arelent *) bfd_alloc (abfd, amt);
189
  if (asect->relocation == NULL)
190
    return FALSE;
191
 
192
  /* The elf64_sparc_slurp_one_reloc_table routine increments
193
     canon_reloc_count.  */
194
  canon_reloc_count (asect) = 0;
195
 
196
  if (!elf64_sparc_slurp_one_reloc_table (abfd, asect, rel_hdr, symbols,
197
                                          dynamic))
198
    return FALSE;
199
 
200
  if (rel_hdr2
201
      && !elf64_sparc_slurp_one_reloc_table (abfd, asect, rel_hdr2, symbols,
202
                                             dynamic))
203
    return FALSE;
204
 
205
  return TRUE;
206
}
207
 
208
/* Canonicalize the relocs.  */
209
 
210
static long
211
elf64_sparc_canonicalize_reloc (bfd *abfd, sec_ptr section,
212
                                arelent **relptr, asymbol **symbols)
213
{
214
  arelent *tblptr;
215
  unsigned int i;
216
  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
217
 
218
  if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE))
219
    return -1;
220
 
221
  tblptr = section->relocation;
222
  for (i = 0; i < canon_reloc_count (section); i++)
223
    *relptr++ = tblptr++;
224
 
225
  *relptr = NULL;
226
 
227
  return canon_reloc_count (section);
228
}
229
 
230
 
231
/* Canonicalize the dynamic relocation entries.  Note that we return
232
   the dynamic relocations as a single block, although they are
233
   actually associated with particular sections; the interface, which
234
   was designed for SunOS style shared libraries, expects that there
235
   is only one set of dynamic relocs.  Any section that was actually
236
   installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
237
   the dynamic symbol table, is considered to be a dynamic reloc
238
   section.  */
239
 
240
static long
241
elf64_sparc_canonicalize_dynamic_reloc (bfd *abfd, arelent **storage,
242
                                        asymbol **syms)
243
{
244
  asection *s;
245
  long ret;
246
 
247
  if (elf_dynsymtab (abfd) == 0)
248
    {
249
      bfd_set_error (bfd_error_invalid_operation);
250
      return -1;
251
    }
252
 
253
  ret = 0;
254
  for (s = abfd->sections; s != NULL; s = s->next)
255
    {
256
      if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
257
          && (elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
258
        {
259
          arelent *p;
260
          long count, i;
261
 
262
          if (! elf64_sparc_slurp_reloc_table (abfd, s, syms, TRUE))
263
            return -1;
264
          count = canon_reloc_count (s);
265
          p = s->relocation;
266
          for (i = 0; i < count; i++)
267
            *storage++ = p++;
268
          ret += count;
269
        }
270
    }
271
 
272
  *storage = NULL;
273
 
274
  return ret;
275
}
276
 
277
/* Write out the relocs.  */
278
 
279
static void
280
elf64_sparc_write_relocs (bfd *abfd, asection *sec, PTR data)
281
{
282
  bfd_boolean *failedp = (bfd_boolean *) data;
283
  Elf_Internal_Shdr *rela_hdr;
284
  bfd_vma addr_offset;
285
  Elf64_External_Rela *outbound_relocas, *src_rela;
286
  unsigned int idx, count;
287
  asymbol *last_sym = 0;
288
  int last_sym_idx = 0;
289
 
290
  /* If we have already failed, don't do anything.  */
291
  if (*failedp)
292
    return;
293
 
294
  if ((sec->flags & SEC_RELOC) == 0)
295
    return;
296
 
297
  /* The linker backend writes the relocs out itself, and sets the
298
     reloc_count field to zero to inhibit writing them here.  Also,
299
     sometimes the SEC_RELOC flag gets set even when there aren't any
300
     relocs.  */
301
  if (sec->reloc_count == 0)
302
    return;
303
 
304
  /* We can combine two relocs that refer to the same address
305
     into R_SPARC_OLO10 if first one is R_SPARC_LO10 and the
306
     latter is R_SPARC_13 with no associated symbol.  */
307
  count = 0;
308
  for (idx = 0; idx < sec->reloc_count; idx++)
309
    {
310
      bfd_vma addr;
311
 
312
      ++count;
313
 
314
      addr = sec->orelocation[idx]->address;
315
      if (sec->orelocation[idx]->howto->type == R_SPARC_LO10
316
          && idx < sec->reloc_count - 1)
317
        {
318
          arelent *r = sec->orelocation[idx + 1];
319
 
320
          if (r->howto->type == R_SPARC_13
321
              && r->address == addr
322
              && bfd_is_abs_section ((*r->sym_ptr_ptr)->section)
323
              && (*r->sym_ptr_ptr)->value == 0)
324
            ++idx;
325
        }
326
    }
327
 
328
  rela_hdr = &elf_section_data (sec)->rel_hdr;
329
 
330
  rela_hdr->sh_size = rela_hdr->sh_entsize * count;
331
  rela_hdr->contents = (PTR) bfd_alloc (abfd, rela_hdr->sh_size);
332
  if (rela_hdr->contents == NULL)
333
    {
334
      *failedp = TRUE;
335
      return;
336
    }
337
 
338
  /* Figure out whether the relocations are RELA or REL relocations.  */
339
  if (rela_hdr->sh_type != SHT_RELA)
340
    abort ();
341
 
342
  /* The address of an ELF reloc is section relative for an object
343
     file, and absolute for an executable file or shared library.
344
     The address of a BFD reloc is always section relative.  */
345
  addr_offset = 0;
346
  if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
347
    addr_offset = sec->vma;
348
 
349
  /* orelocation has the data, reloc_count has the count...  */
350
  outbound_relocas = (Elf64_External_Rela *) rela_hdr->contents;
351
  src_rela = outbound_relocas;
352
 
353
  for (idx = 0; idx < sec->reloc_count; idx++)
354
    {
355
      Elf_Internal_Rela dst_rela;
356
      arelent *ptr;
357
      asymbol *sym;
358
      int n;
359
 
360
      ptr = sec->orelocation[idx];
361
      sym = *ptr->sym_ptr_ptr;
362
      if (sym == last_sym)
363
        n = last_sym_idx;
364
      else if (bfd_is_abs_section (sym->section) && sym->value == 0)
365
        n = STN_UNDEF;
366
      else
367
        {
368
          last_sym = sym;
369
          n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
370
          if (n < 0)
371
            {
372
              *failedp = TRUE;
373
              return;
374
            }
375
          last_sym_idx = n;
376
        }
377
 
378
      if ((*ptr->sym_ptr_ptr)->the_bfd != NULL
379
          && (*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
380
          && ! _bfd_elf_validate_reloc (abfd, ptr))
381
        {
382
          *failedp = TRUE;
383
          return;
384
        }
385
 
386
      if (ptr->howto->type == R_SPARC_LO10
387
          && idx < sec->reloc_count - 1)
388
        {
389
          arelent *r = sec->orelocation[idx + 1];
390
 
391
          if (r->howto->type == R_SPARC_13
392
              && r->address == ptr->address
393
              && bfd_is_abs_section ((*r->sym_ptr_ptr)->section)
394
              && (*r->sym_ptr_ptr)->value == 0)
395
            {
396
              idx++;
397
              dst_rela.r_info
398
                = ELF64_R_INFO (n, ELF64_R_TYPE_INFO (r->addend,
399
                                                      R_SPARC_OLO10));
400
            }
401
          else
402
            dst_rela.r_info = ELF64_R_INFO (n, R_SPARC_LO10);
403
        }
404
      else
405
        dst_rela.r_info = ELF64_R_INFO (n, ptr->howto->type);
406
 
407
      dst_rela.r_offset = ptr->address + addr_offset;
408
      dst_rela.r_addend = ptr->addend;
409
 
410
      bfd_elf64_swap_reloca_out (abfd, &dst_rela, (bfd_byte *) src_rela);
411
      ++src_rela;
412
    }
413
}
414
 
415
/* Hook called by the linker routine which adds symbols from an object
416
   file.  We use it for STT_REGISTER symbols.  */
417
 
418
static bfd_boolean
419
elf64_sparc_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
420
                             Elf_Internal_Sym *sym, const char **namep,
421
                             flagword *flagsp ATTRIBUTE_UNUSED,
422
                             asection **secp ATTRIBUTE_UNUSED,
423
                             bfd_vma *valp ATTRIBUTE_UNUSED)
424
{
425
  static const char *const stt_types[] = { "NOTYPE", "OBJECT", "FUNCTION" };
426
 
427
  if (ELF_ST_TYPE (sym->st_info) == STT_REGISTER)
428
    {
429
      int reg;
430
      struct _bfd_sparc_elf_app_reg *p;
431
 
432
      reg = (int)sym->st_value;
433
      switch (reg & ~1)
434
        {
435
        case 2: reg -= 2; break;
436
        case 6: reg -= 4; break;
437
        default:
438
          (*_bfd_error_handler)
439
            (_("%B: Only registers %%g[2367] can be declared using STT_REGISTER"),
440
             abfd);
441
          return FALSE;
442
        }
443
 
444
      if (info->output_bfd->xvec != abfd->xvec
445
          || (abfd->flags & DYNAMIC) != 0)
446
        {
447
          /* STT_REGISTER only works when linking an elf64_sparc object.
448
             If STT_REGISTER comes from a dynamic object, don't put it into
449
             the output bfd.  The dynamic linker will recheck it.  */
450
          *namep = NULL;
451
          return TRUE;
452
        }
453
 
454
      p = _bfd_sparc_elf_hash_table(info)->app_regs + reg;
455
 
456
      if (p->name != NULL && strcmp (p->name, *namep))
457
        {
458
          (*_bfd_error_handler)
459
            (_("Register %%g%d used incompatibly: %s in %B, previously %s in %B"),
460
             abfd, p->abfd, (int) sym->st_value,
461
             **namep ? *namep : "#scratch",
462
             *p->name ? p->name : "#scratch");
463
          return FALSE;
464
        }
465
 
466
      if (p->name == NULL)
467
        {
468
          if (**namep)
469
            {
470
              struct elf_link_hash_entry *h;
471
 
472
              h = (struct elf_link_hash_entry *)
473
                bfd_link_hash_lookup (info->hash, *namep, FALSE, FALSE, FALSE);
474
 
475
              if (h != NULL)
476
                {
477
                  unsigned char type = h->type;
478
 
479
                  if (type > STT_FUNC)
480
                    type = 0;
481
                  (*_bfd_error_handler)
482
                    (_("Symbol `%s' has differing types: REGISTER in %B, previously %s in %B"),
483
                     abfd, p->abfd, *namep, stt_types[type]);
484
                  return FALSE;
485
                }
486
 
487
              p->name = bfd_hash_allocate (&info->hash->table,
488
                                           strlen (*namep) + 1);
489
              if (!p->name)
490
                return FALSE;
491
 
492
              strcpy (p->name, *namep);
493
            }
494
          else
495
            p->name = "";
496
          p->bind = ELF_ST_BIND (sym->st_info);
497
          p->abfd = abfd;
498
          p->shndx = sym->st_shndx;
499
        }
500
      else
501
        {
502
          if (p->bind == STB_WEAK
503
              && ELF_ST_BIND (sym->st_info) == STB_GLOBAL)
504
            {
505
              p->bind = STB_GLOBAL;
506
              p->abfd = abfd;
507
            }
508
        }
509
      *namep = NULL;
510
      return TRUE;
511
    }
512
  else if (*namep && **namep
513
           && info->output_bfd->xvec == abfd->xvec)
514
    {
515
      int i;
516
      struct _bfd_sparc_elf_app_reg *p;
517
 
518
      p = _bfd_sparc_elf_hash_table(info)->app_regs;
519
      for (i = 0; i < 4; i++, p++)
520
        if (p->name != NULL && ! strcmp (p->name, *namep))
521
          {
522
            unsigned char type = ELF_ST_TYPE (sym->st_info);
523
 
524
            if (type > STT_FUNC)
525
              type = 0;
526
            (*_bfd_error_handler)
527
              (_("Symbol `%s' has differing types: %s in %B, previously REGISTER in %B"),
528
               abfd, p->abfd, *namep, stt_types[type]);
529
            return FALSE;
530
          }
531
    }
532
  return TRUE;
533
}
534
 
535
/* This function takes care of emitting STT_REGISTER symbols
536
   which we cannot easily keep in the symbol hash table.  */
537
 
538
static bfd_boolean
539
elf64_sparc_output_arch_syms (bfd *output_bfd ATTRIBUTE_UNUSED,
540
                              struct bfd_link_info *info,
541
                              PTR finfo, bfd_boolean (*func) (PTR, const char *,
542
                                                              Elf_Internal_Sym *,
543
                                                              asection *,
544
                                                              struct elf_link_hash_entry *))
545
{
546
  int reg;
547
  struct _bfd_sparc_elf_app_reg *app_regs =
548
    _bfd_sparc_elf_hash_table(info)->app_regs;
549
  Elf_Internal_Sym sym;
550
 
551
  /* We arranged in size_dynamic_sections to put the STT_REGISTER entries
552
     at the end of the dynlocal list, so they came at the end of the local
553
     symbols in the symtab.  Except that they aren't STB_LOCAL, so we need
554
     to back up symtab->sh_info.  */
555
  if (elf_hash_table (info)->dynlocal)
556
    {
557
      bfd * dynobj = elf_hash_table (info)->dynobj;
558
      asection *dynsymsec = bfd_get_section_by_name (dynobj, ".dynsym");
559
      struct elf_link_local_dynamic_entry *e;
560
 
561
      for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
562
        if (e->input_indx == -1)
563
          break;
564
      if (e)
565
        {
566
          elf_section_data (dynsymsec->output_section)->this_hdr.sh_info
567
            = e->dynindx;
568
        }
569
    }
570
 
571
  if (info->strip == strip_all)
572
    return TRUE;
573
 
574
  for (reg = 0; reg < 4; reg++)
575
    if (app_regs [reg].name != NULL)
576
      {
577
        if (info->strip == strip_some
578
            && bfd_hash_lookup (info->keep_hash,
579
                                app_regs [reg].name,
580
                                FALSE, FALSE) == NULL)
581
          continue;
582
 
583
        sym.st_value = reg < 2 ? reg + 2 : reg + 4;
584
        sym.st_size = 0;
585
        sym.st_other = 0;
586
        sym.st_info = ELF_ST_INFO (app_regs [reg].bind, STT_REGISTER);
587
        sym.st_shndx = app_regs [reg].shndx;
588
        if (! (*func) (finfo, app_regs [reg].name, &sym,
589
                       sym.st_shndx == SHN_ABS
590
                         ? bfd_abs_section_ptr : bfd_und_section_ptr,
591
                       NULL))
592
          return FALSE;
593
      }
594
 
595
  return TRUE;
596
}
597
 
598
static int
599
elf64_sparc_get_symbol_type (Elf_Internal_Sym *elf_sym, int type)
600
{
601
  if (ELF_ST_TYPE (elf_sym->st_info) == STT_REGISTER)
602
    return STT_REGISTER;
603
  else
604
    return type;
605
}
606
 
607
/* A STB_GLOBAL,STT_REGISTER symbol should be BSF_GLOBAL
608
   even in SHN_UNDEF section.  */
609
 
610
static void
611
elf64_sparc_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED, asymbol *asym)
612
{
613
  elf_symbol_type *elfsym;
614
 
615
  elfsym = (elf_symbol_type *) asym;
616
  if (elfsym->internal_elf_sym.st_info
617
      == ELF_ST_INFO (STB_GLOBAL, STT_REGISTER))
618
    {
619
      asym->flags |= BSF_GLOBAL;
620
    }
621
}
622
 
623
 
624
/* Functions for dealing with the e_flags field.  */
625
 
626
/* Merge backend specific data from an object file to the output
627
   object file when linking.  */
628
 
629
static bfd_boolean
630
elf64_sparc_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
631
{
632
  bfd_boolean error;
633
  flagword new_flags, old_flags;
634
  int new_mm, old_mm;
635
 
636
  if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
637
      || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
638
    return TRUE;
639
 
640
  new_flags = elf_elfheader (ibfd)->e_flags;
641
  old_flags = elf_elfheader (obfd)->e_flags;
642
 
643
  if (!elf_flags_init (obfd))   /* First call, no flags set */
644
    {
645
      elf_flags_init (obfd) = TRUE;
646
      elf_elfheader (obfd)->e_flags = new_flags;
647
    }
648
 
649
  else if (new_flags == old_flags)      /* Compatible flags are ok */
650
    ;
651
 
652
  else                                  /* Incompatible flags */
653
    {
654
      error = FALSE;
655
 
656
#define EF_SPARC_ISA_EXTENSIONS \
657
  (EF_SPARC_SUN_US1 | EF_SPARC_SUN_US3 | EF_SPARC_HAL_R1)
658
 
659
      if ((ibfd->flags & DYNAMIC) != 0)
660
        {
661
          /* We don't want dynamic objects memory ordering and
662
             architecture to have any role. That's what dynamic linker
663
             should do.  */
664
          new_flags &= ~(EF_SPARCV9_MM | EF_SPARC_ISA_EXTENSIONS);
665
          new_flags |= (old_flags
666
                        & (EF_SPARCV9_MM | EF_SPARC_ISA_EXTENSIONS));
667
        }
668
      else
669
        {
670
          /* Choose the highest architecture requirements.  */
671
          old_flags |= (new_flags & EF_SPARC_ISA_EXTENSIONS);
672
          new_flags |= (old_flags & EF_SPARC_ISA_EXTENSIONS);
673
          if ((old_flags & (EF_SPARC_SUN_US1 | EF_SPARC_SUN_US3))
674
              && (old_flags & EF_SPARC_HAL_R1))
675
            {
676
              error = TRUE;
677
              (*_bfd_error_handler)
678
                (_("%B: linking UltraSPARC specific with HAL specific code"),
679
                 ibfd);
680
            }
681
          /* Choose the most restrictive memory ordering.  */
682
          old_mm = (old_flags & EF_SPARCV9_MM);
683
          new_mm = (new_flags & EF_SPARCV9_MM);
684
          old_flags &= ~EF_SPARCV9_MM;
685
          new_flags &= ~EF_SPARCV9_MM;
686
          if (new_mm < old_mm)
687
            old_mm = new_mm;
688
          old_flags |= old_mm;
689
          new_flags |= old_mm;
690
        }
691
 
692
      /* Warn about any other mismatches */
693
      if (new_flags != old_flags)
694
        {
695
          error = TRUE;
696
          (*_bfd_error_handler)
697
            (_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
698
             ibfd, (long) new_flags, (long) old_flags);
699
        }
700
 
701
      elf_elfheader (obfd)->e_flags = old_flags;
702
 
703
      if (error)
704
        {
705
          bfd_set_error (bfd_error_bad_value);
706
          return FALSE;
707
        }
708
    }
709
  return TRUE;
710
}
711
 
712
/* MARCO: Set the correct entry size for the .stab section.  */
713
 
714
static bfd_boolean
715
elf64_sparc_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
716
                           Elf_Internal_Shdr *hdr ATTRIBUTE_UNUSED,
717
                           asection *sec)
718
{
719
  const char *name;
720
 
721
  name = bfd_get_section_name (abfd, sec);
722
 
723
  if (strcmp (name, ".stab") == 0)
724
    {
725
      /* Even in the 64bit case the stab entries are only 12 bytes long.  */
726
      elf_section_data (sec)->this_hdr.sh_entsize = 12;
727
    }
728
 
729
  return TRUE;
730
}
731
 
732
/* Print a STT_REGISTER symbol to file FILE.  */
733
 
734
static const char *
735
elf64_sparc_print_symbol_all (bfd *abfd ATTRIBUTE_UNUSED, PTR filep,
736
                              asymbol *symbol)
737
{
738
  FILE *file = (FILE *) filep;
739
  int reg, type;
740
 
741
  if (ELF_ST_TYPE (((elf_symbol_type *) symbol)->internal_elf_sym.st_info)
742
      != STT_REGISTER)
743
    return NULL;
744
 
745
  reg = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value;
746
  type = symbol->flags;
747
  fprintf (file, "REG_%c%c%11s%c%c    R", "GOLI" [reg / 8], '0' + (reg & 7), "",
748
                 ((type & BSF_LOCAL)
749
                  ? (type & BSF_GLOBAL) ? '!' : 'l'
750
                  : (type & BSF_GLOBAL) ? 'g' : ' '),
751
                 (type & BSF_WEAK) ? 'w' : ' ');
752
  if (symbol->name == NULL || symbol->name [0] == '\0')
753
    return "#scratch";
754
  else
755
    return symbol->name;
756
}
757
 
758
static enum elf_reloc_type_class
759
elf64_sparc_reloc_type_class (const Elf_Internal_Rela *rela)
760
{
761
  switch ((int) ELF64_R_TYPE (rela->r_info))
762
    {
763
    case R_SPARC_RELATIVE:
764
      return reloc_class_relative;
765
    case R_SPARC_JMP_SLOT:
766
      return reloc_class_plt;
767
    case R_SPARC_COPY:
768
      return reloc_class_copy;
769
    default:
770
      return reloc_class_normal;
771
    }
772
}
773
 
774
/* Relocations in the 64 bit SPARC ELF ABI are more complex than in
775
   standard ELF, because R_SPARC_OLO10 has secondary addend in
776
   ELF64_R_TYPE_DATA field.  This structure is used to redirect the
777
   relocation handling routines.  */
778
 
779
const struct elf_size_info elf64_sparc_size_info =
780
{
781
  sizeof (Elf64_External_Ehdr),
782
  sizeof (Elf64_External_Phdr),
783
  sizeof (Elf64_External_Shdr),
784
  sizeof (Elf64_External_Rel),
785
  sizeof (Elf64_External_Rela),
786
  sizeof (Elf64_External_Sym),
787
  sizeof (Elf64_External_Dyn),
788
  sizeof (Elf_External_Note),
789
  4,            /* hash-table entry size.  */
790
  /* Internal relocations per external relocations.
791
     For link purposes we use just 1 internal per
792
     1 external, for assembly and slurp symbol table
793
     we use 2.  */
794
  1,
795
  64,           /* arch_size.  */
796
  3,            /* log_file_align.  */
797
  ELFCLASS64,
798
  EV_CURRENT,
799
  bfd_elf64_write_out_phdrs,
800
  bfd_elf64_write_shdrs_and_ehdr,
801
  bfd_elf64_checksum_contents,
802
  elf64_sparc_write_relocs,
803
  bfd_elf64_swap_symbol_in,
804
  bfd_elf64_swap_symbol_out,
805
  elf64_sparc_slurp_reloc_table,
806
  bfd_elf64_slurp_symbol_table,
807
  bfd_elf64_swap_dyn_in,
808
  bfd_elf64_swap_dyn_out,
809
  bfd_elf64_swap_reloc_in,
810
  bfd_elf64_swap_reloc_out,
811
  bfd_elf64_swap_reloca_in,
812
  bfd_elf64_swap_reloca_out
813
};
814
 
815
#define TARGET_BIG_SYM  bfd_elf64_sparc_vec
816
#define TARGET_BIG_NAME "elf64-sparc"
817
#define ELF_ARCH        bfd_arch_sparc
818
#define ELF_MAXPAGESIZE 0x100000
819
#define ELF_COMMONPAGESIZE 0x2000
820
 
821
/* This is the official ABI value.  */
822
#define ELF_MACHINE_CODE EM_SPARCV9
823
 
824
/* This is the value that we used before the ABI was released.  */
825
#define ELF_MACHINE_ALT1 EM_OLD_SPARCV9
826
 
827
#define elf_backend_reloc_type_class \
828
  elf64_sparc_reloc_type_class
829
#define bfd_elf64_get_reloc_upper_bound \
830
  elf64_sparc_get_reloc_upper_bound
831
#define bfd_elf64_get_dynamic_reloc_upper_bound \
832
  elf64_sparc_get_dynamic_reloc_upper_bound
833
#define bfd_elf64_canonicalize_reloc \
834
  elf64_sparc_canonicalize_reloc
835
#define bfd_elf64_canonicalize_dynamic_reloc \
836
  elf64_sparc_canonicalize_dynamic_reloc
837
#define elf_backend_add_symbol_hook \
838
  elf64_sparc_add_symbol_hook
839
#define elf_backend_get_symbol_type \
840
  elf64_sparc_get_symbol_type
841
#define elf_backend_symbol_processing \
842
  elf64_sparc_symbol_processing
843
#define elf_backend_print_symbol_all \
844
  elf64_sparc_print_symbol_all
845
#define elf_backend_output_arch_syms \
846
  elf64_sparc_output_arch_syms
847
#define bfd_elf64_bfd_merge_private_bfd_data \
848
  elf64_sparc_merge_private_bfd_data
849
#define elf_backend_fake_sections \
850
  elf64_sparc_fake_sections
851
#define elf_backend_size_info \
852
  elf64_sparc_size_info
853
 
854
#define elf_backend_plt_sym_val \
855
  _bfd_sparc_elf_plt_sym_val
856
#define bfd_elf64_bfd_link_hash_table_create \
857
  _bfd_sparc_elf_link_hash_table_create
858
#define elf_info_to_howto \
859
  _bfd_sparc_elf_info_to_howto
860
#define elf_backend_copy_indirect_symbol \
861
  _bfd_sparc_elf_copy_indirect_symbol
862
#define bfd_elf64_bfd_reloc_type_lookup \
863
  _bfd_sparc_elf_reloc_type_lookup
864
#define bfd_elf64_bfd_reloc_name_lookup \
865
  _bfd_sparc_elf_reloc_name_lookup
866
#define bfd_elf64_bfd_relax_section \
867
  _bfd_sparc_elf_relax_section
868
#define bfd_elf64_new_section_hook \
869
  _bfd_sparc_elf_new_section_hook
870
 
871
#define elf_backend_create_dynamic_sections \
872
  _bfd_sparc_elf_create_dynamic_sections
873
#define elf_backend_relocs_compatible \
874
  _bfd_elf_relocs_compatible
875
#define elf_backend_check_relocs \
876
  _bfd_sparc_elf_check_relocs
877
#define elf_backend_adjust_dynamic_symbol \
878
  _bfd_sparc_elf_adjust_dynamic_symbol
879
#define elf_backend_omit_section_dynsym \
880
  _bfd_sparc_elf_omit_section_dynsym
881
#define elf_backend_size_dynamic_sections \
882
  _bfd_sparc_elf_size_dynamic_sections
883
#define elf_backend_relocate_section \
884
  _bfd_sparc_elf_relocate_section
885
#define elf_backend_finish_dynamic_symbol \
886
  _bfd_sparc_elf_finish_dynamic_symbol
887
#define elf_backend_finish_dynamic_sections \
888
  _bfd_sparc_elf_finish_dynamic_sections
889
 
890
#define bfd_elf64_mkobject \
891
  _bfd_sparc_elf_mkobject
892
#define elf_backend_object_p \
893
  _bfd_sparc_elf_object_p
894
#define elf_backend_gc_mark_hook \
895
  _bfd_sparc_elf_gc_mark_hook
896
#define elf_backend_gc_sweep_hook \
897
  _bfd_sparc_elf_gc_sweep_hook
898
#define elf_backend_init_index_section \
899
  _bfd_elf_init_1_index_section
900
 
901
#define elf_backend_can_gc_sections 1
902
#define elf_backend_can_refcount 1
903
#define elf_backend_want_got_plt 0
904
#define elf_backend_plt_readonly 0
905
#define elf_backend_want_plt_sym 1
906
#define elf_backend_got_header_size 8
907
#define elf_backend_rela_normal 1
908
 
909
/* Section 5.2.4 of the ABI specifies a 256-byte boundary for the table.  */
910
#define elf_backend_plt_alignment 8
911
 
912
#include "elf64-target.h"
913
 
914
/* FreeBSD support */
915
#undef  TARGET_BIG_SYM
916
#define TARGET_BIG_SYM bfd_elf64_sparc_freebsd_vec
917
#undef  TARGET_BIG_NAME
918
#define TARGET_BIG_NAME "elf64-sparc-freebsd"
919
#undef  ELF_OSABI
920
#define ELF_OSABI ELFOSABI_FREEBSD
921
 
922
#undef  elf_backend_post_process_headers
923
#define elf_backend_post_process_headers        _bfd_elf_set_osabi
924
#undef  elf64_bed
925
#define elf64_bed                               elf64_sparc_fbsd_bed
926
 
927
#include "elf64-target.h"
928
 

powered by: WebSVN 2.1.0

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