]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - bfd/elf64-sparc.c
daily update
[thirdparty/binutils-gdb.git] / bfd / elf64-sparc.c
CommitLineData
252b5132 1/* SPARC-specific support for 64-bit ELF
4b95cf5c 2 Copyright (C) 1993-2014 Free Software Foundation, Inc.
252b5132 3
ae9a127f 4 This file is part of BFD, the Binary File Descriptor library.
252b5132 5
ae9a127f
NC
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
cd123cb7 8 the Free Software Foundation; either version 3 of the License, or
ae9a127f 9 (at your option) any later version.
252b5132 10
ae9a127f
NC
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
252b5132 15
ae9a127f
NC
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
cd123cb7
NC
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
252b5132 20
252b5132 21#include "sysdep.h"
3db64b00 22#include "bfd.h"
252b5132
RH
23#include "libbfd.h"
24#include "elf-bfd.h"
252b5132 25#include "elf/sparc.h"
40937810 26#include "opcode/sparc.h"
22b75d0a 27#include "elfxx-sparc.h"
252b5132
RH
28
29/* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
30#define MINUS_ONE (~ (bfd_vma) 0)
31
f65054f7
RH
32/* Due to the way how we handle R_SPARC_OLO10, each entry in a SHT_RELA
33 section can represent up to two relocs, we must tell the user to allocate
34 more space. */
435b1e90 35
f65054f7 36static long
22b75d0a 37elf64_sparc_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED, asection *sec)
f65054f7
RH
38{
39 return (sec->reloc_count * 2 + 1) * sizeof (arelent *);
40}
41
42static long
22b75d0a 43elf64_sparc_get_dynamic_reloc_upper_bound (bfd *abfd)
f65054f7
RH
44{
45 return _bfd_elf_get_dynamic_reloc_upper_bound (abfd) * 2;
46}
47
435b1e90 48/* Read relocations for ASECT from REL_HDR. There are RELOC_COUNT of
f65054f7
RH
49 them. We cannot use generic elf routines for this, because R_SPARC_OLO10
50 has secondary addend in ELF64_R_TYPE_DATA. We handle it as two relocations
51 for the same location, R_SPARC_LO10 and R_SPARC_13. */
52
b34976b6 53static bfd_boolean
22b75d0a
DM
54elf64_sparc_slurp_one_reloc_table (bfd *abfd, asection *asect,
55 Elf_Internal_Shdr *rel_hdr,
56 asymbol **symbols, bfd_boolean dynamic)
f65054f7 57{
2c3fc389 58 void * allocated = NULL;
f65054f7
RH
59 bfd_byte *native_relocs;
60 arelent *relent;
61 unsigned int i;
62 int entsize;
63 bfd_size_type count;
64 arelent *relents;
65
2c3fc389 66 allocated = bfd_malloc (rel_hdr->sh_size);
f65054f7
RH
67 if (allocated == NULL)
68 goto error_return;
69
70 if (bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0
dc810e39 71 || bfd_bread (allocated, rel_hdr->sh_size, abfd) != rel_hdr->sh_size)
f65054f7
RH
72 goto error_return;
73
74 native_relocs = (bfd_byte *) allocated;
75
3e1d7f19 76 relents = asect->relocation + canon_reloc_count (asect);
f65054f7
RH
77
78 entsize = rel_hdr->sh_entsize;
79 BFD_ASSERT (entsize == sizeof (Elf64_External_Rela));
435b1e90 80
f65054f7
RH
81 count = rel_hdr->sh_size / entsize;
82
83 for (i = 0, relent = relents; i < count;
84 i++, relent++, native_relocs += entsize)
85 {
86 Elf_Internal_Rela rela;
22b75d0a 87 unsigned int r_type;
f65054f7 88
947216bf 89 bfd_elf64_swap_reloca_in (abfd, native_relocs, &rela);
f65054f7
RH
90
91 /* The address of an ELF reloc is section relative for an object
92 file, and absolute for an executable file or shared library.
93 The address of a normal BFD reloc is always section relative,
94 and the address of a dynamic reloc is absolute.. */
95 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0 || dynamic)
96 relent->address = rela.r_offset;
97 else
98 relent->address = rela.r_offset - asect->vma;
99
cf35638d 100 if (ELF64_R_SYM (rela.r_info) == STN_UNDEF)
f65054f7
RH
101 relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
102 else
103 {
104 asymbol **ps, *s;
105
106 ps = symbols + ELF64_R_SYM (rela.r_info) - 1;
107 s = *ps;
108
109 /* Canonicalize ELF section symbols. FIXME: Why? */
110 if ((s->flags & BSF_SECTION_SYM) == 0)
111 relent->sym_ptr_ptr = ps;
112 else
113 relent->sym_ptr_ptr = s->section->symbol_ptr_ptr;
114 }
115
116 relent->addend = rela.r_addend;
117
22b75d0a
DM
118 r_type = ELF64_R_TYPE_ID (rela.r_info);
119 if (r_type == R_SPARC_OLO10)
f65054f7 120 {
22b75d0a 121 relent->howto = _bfd_sparc_elf_info_to_howto_ptr (R_SPARC_LO10);
f65054f7
RH
122 relent[1].address = relent->address;
123 relent++;
124 relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
125 relent->addend = ELF64_R_TYPE_DATA (rela.r_info);
22b75d0a 126 relent->howto = _bfd_sparc_elf_info_to_howto_ptr (R_SPARC_13);
f65054f7
RH
127 }
128 else
22b75d0a 129 relent->howto = _bfd_sparc_elf_info_to_howto_ptr (r_type);
f65054f7
RH
130 }
131
3e1d7f19 132 canon_reloc_count (asect) += relent - relents;
f65054f7
RH
133
134 if (allocated != NULL)
135 free (allocated);
136
b34976b6 137 return TRUE;
f65054f7
RH
138
139 error_return:
140 if (allocated != NULL)
141 free (allocated);
b34976b6 142 return FALSE;
f65054f7
RH
143}
144
145/* Read in and swap the external relocs. */
146
b34976b6 147static bfd_boolean
22b75d0a
DM
148elf64_sparc_slurp_reloc_table (bfd *abfd, asection *asect,
149 asymbol **symbols, bfd_boolean dynamic)
f65054f7
RH
150{
151 struct bfd_elf_section_data * const d = elf_section_data (asect);
152 Elf_Internal_Shdr *rel_hdr;
153 Elf_Internal_Shdr *rel_hdr2;
dc810e39 154 bfd_size_type amt;
f65054f7
RH
155
156 if (asect->relocation != NULL)
b34976b6 157 return TRUE;
f65054f7
RH
158
159 if (! dynamic)
160 {
161 if ((asect->flags & SEC_RELOC) == 0
162 || asect->reloc_count == 0)
b34976b6 163 return TRUE;
f65054f7 164
d4730f92
BS
165 rel_hdr = d->rel.hdr;
166 rel_hdr2 = d->rela.hdr;
f65054f7 167
d4730f92 168 BFD_ASSERT ((rel_hdr && asect->rel_filepos == rel_hdr->sh_offset)
f65054f7
RH
169 || (rel_hdr2 && asect->rel_filepos == rel_hdr2->sh_offset));
170 }
171 else
172 {
173 /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
174 case because relocations against this section may use the
175 dynamic symbol table, and in that case bfd_section_from_shdr
176 in elf.c does not update the RELOC_COUNT. */
eea6121a 177 if (asect->size == 0)
b34976b6 178 return TRUE;
f65054f7
RH
179
180 rel_hdr = &d->this_hdr;
d9bc7a44 181 asect->reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
f65054f7
RH
182 rel_hdr2 = NULL;
183 }
184
dc810e39
AM
185 amt = asect->reloc_count;
186 amt *= 2 * sizeof (arelent);
187 asect->relocation = (arelent *) bfd_alloc (abfd, amt);
f65054f7 188 if (asect->relocation == NULL)
b34976b6 189 return FALSE;
f65054f7 190
22b75d0a 191 /* The elf64_sparc_slurp_one_reloc_table routine increments
3e1d7f19
JJ
192 canon_reloc_count. */
193 canon_reloc_count (asect) = 0;
435b1e90 194
d4730f92
BS
195 if (rel_hdr
196 && !elf64_sparc_slurp_one_reloc_table (abfd, asect, rel_hdr, symbols,
197 dynamic))
b34976b6 198 return FALSE;
435b1e90
KH
199
200 if (rel_hdr2
22b75d0a 201 && !elf64_sparc_slurp_one_reloc_table (abfd, asect, rel_hdr2, symbols,
f65054f7 202 dynamic))
b34976b6 203 return FALSE;
f65054f7 204
b34976b6 205 return TRUE;
f65054f7
RH
206}
207
3e1d7f19
JJ
208/* Canonicalize the relocs. */
209
210static long
22b75d0a
DM
211elf64_sparc_canonicalize_reloc (bfd *abfd, sec_ptr section,
212 arelent **relptr, asymbol **symbols)
3e1d7f19
JJ
213{
214 arelent *tblptr;
215 unsigned int i;
9c5bfbb7 216 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3e1d7f19
JJ
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
f65054f7
RH
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
240static long
22b75d0a
DM
241elf64_sparc_canonicalize_dynamic_reloc (bfd *abfd, arelent **storage,
242 asymbol **syms)
f65054f7
RH
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
22b75d0a 262 if (! elf64_sparc_slurp_reloc_table (abfd, s, syms, TRUE))
f65054f7 263 return -1;
3e1d7f19 264 count = canon_reloc_count (s);
f65054f7
RH
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
279static void
2c3fc389 280elf64_sparc_write_relocs (bfd *abfd, asection *sec, void * data)
f65054f7 281{
b34976b6 282 bfd_boolean *failedp = (bfd_boolean *) data;
f65054f7 283 Elf_Internal_Shdr *rela_hdr;
22b75d0a 284 bfd_vma addr_offset;
37fb6db1 285 Elf64_External_Rela *outbound_relocas, *src_rela;
f65054f7
RH
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;
f65054f7
RH
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
d4730f92 328 rela_hdr = elf_section_data (sec)->rela.hdr;
f65054f7
RH
329
330 rela_hdr->sh_size = rela_hdr->sh_entsize * count;
2c3fc389 331 rela_hdr->contents = bfd_alloc (abfd, rela_hdr->sh_size);
f65054f7
RH
332 if (rela_hdr->contents == NULL)
333 {
b34976b6 334 *failedp = TRUE;
f65054f7
RH
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
22b75d0a
DM
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
435b1e90 349 /* orelocation has the data, reloc_count has the count... */
f65054f7 350 outbound_relocas = (Elf64_External_Rela *) rela_hdr->contents;
37fb6db1 351 src_rela = outbound_relocas;
f65054f7
RH
352
353 for (idx = 0; idx < sec->reloc_count; idx++)
354 {
355 Elf_Internal_Rela dst_rela;
f65054f7
RH
356 arelent *ptr;
357 asymbol *sym;
358 int n;
359
360 ptr = sec->orelocation[idx];
f65054f7
RH
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 {
b34976b6 372 *failedp = TRUE;
f65054f7
RH
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 {
b34976b6 382 *failedp = TRUE;
f65054f7
RH
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
22b75d0a 407 dst_rela.r_offset = ptr->address + addr_offset;
f65054f7 408 dst_rela.r_addend = ptr->addend;
22b75d0a 409
947216bf 410 bfd_elf64_swap_reloca_out (abfd, &dst_rela, (bfd_byte *) src_rela);
37fb6db1 411 ++src_rela;
f65054f7 412 }
252b5132 413}
587ff49e 414\f
22b75d0a
DM
415/* Hook called by the linker routine which adds symbols from an object
416 file. We use it for STT_REGISTER symbols. */
40937810 417
22b75d0a
DM
418static bfd_boolean
419elf64_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)
40937810 424{
22b75d0a 425 static const char *const stt_types[] = { "NOTYPE", "OBJECT", "FUNCTION" };
40937810 426
c16153ae 427 if ((abfd->flags & DYNAMIC) == 0
f64b2e8d
NC
428 && (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC
429 || ELF_ST_BIND (sym->st_info) == STB_GNU_UNIQUE))
430 elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
d0c9aeb3 431
22b75d0a
DM
432 if (ELF_ST_TYPE (sym->st_info) == STT_REGISTER)
433 {
434 int reg;
435 struct _bfd_sparc_elf_app_reg *p;
40937810 436
22b75d0a
DM
437 reg = (int)sym->st_value;
438 switch (reg & ~1)
439 {
440 case 2: reg -= 2; break;
441 case 6: reg -= 4; break;
442 default:
443 (*_bfd_error_handler)
444 (_("%B: Only registers %%g[2367] can be declared using STT_REGISTER"),
445 abfd);
446 return FALSE;
447 }
40937810 448
f13a99db 449 if (info->output_bfd->xvec != abfd->xvec
22b75d0a
DM
450 || (abfd->flags & DYNAMIC) != 0)
451 {
452 /* STT_REGISTER only works when linking an elf64_sparc object.
453 If STT_REGISTER comes from a dynamic object, don't put it into
454 the output bfd. The dynamic linker will recheck it. */
455 *namep = NULL;
456 return TRUE;
457 }
40937810 458
22b75d0a 459 p = _bfd_sparc_elf_hash_table(info)->app_regs + reg;
40937810 460
22b75d0a
DM
461 if (p->name != NULL && strcmp (p->name, *namep))
462 {
463 (*_bfd_error_handler)
464 (_("Register %%g%d used incompatibly: %s in %B, previously %s in %B"),
465 abfd, p->abfd, (int) sym->st_value,
466 **namep ? *namep : "#scratch",
467 *p->name ? p->name : "#scratch");
468 return FALSE;
469 }
40937810 470
22b75d0a
DM
471 if (p->name == NULL)
472 {
473 if (**namep)
474 {
475 struct elf_link_hash_entry *h;
40937810 476
22b75d0a
DM
477 h = (struct elf_link_hash_entry *)
478 bfd_link_hash_lookup (info->hash, *namep, FALSE, FALSE, FALSE);
40937810 479
22b75d0a
DM
480 if (h != NULL)
481 {
482 unsigned char type = h->type;
40937810 483
22b75d0a
DM
484 if (type > STT_FUNC)
485 type = 0;
486 (*_bfd_error_handler)
487 (_("Symbol `%s' has differing types: REGISTER in %B, previously %s in %B"),
488 abfd, p->abfd, *namep, stt_types[type]);
489 return FALSE;
490 }
40937810 491
22b75d0a
DM
492 p->name = bfd_hash_allocate (&info->hash->table,
493 strlen (*namep) + 1);
494 if (!p->name)
495 return FALSE;
40937810 496
22b75d0a
DM
497 strcpy (p->name, *namep);
498 }
499 else
500 p->name = "";
501 p->bind = ELF_ST_BIND (sym->st_info);
502 p->abfd = abfd;
503 p->shndx = sym->st_shndx;
504 }
505 else
506 {
507 if (p->bind == STB_WEAK
508 && ELF_ST_BIND (sym->st_info) == STB_GLOBAL)
509 {
510 p->bind = STB_GLOBAL;
511 p->abfd = abfd;
512 }
513 }
514 *namep = NULL;
515 return TRUE;
516 }
517 else if (*namep && **namep
f13a99db 518 && info->output_bfd->xvec == abfd->xvec)
22b75d0a
DM
519 {
520 int i;
521 struct _bfd_sparc_elf_app_reg *p;
40937810 522
22b75d0a
DM
523 p = _bfd_sparc_elf_hash_table(info)->app_regs;
524 for (i = 0; i < 4; i++, p++)
525 if (p->name != NULL && ! strcmp (p->name, *namep))
526 {
527 unsigned char type = ELF_ST_TYPE (sym->st_info);
40937810 528
22b75d0a
DM
529 if (type > STT_FUNC)
530 type = 0;
531 (*_bfd_error_handler)
532 (_("Symbol `%s' has differing types: %s in %B, previously REGISTER in %B"),
533 abfd, p->abfd, *namep, stt_types[type]);
534 return FALSE;
535 }
536 }
40937810
JJ
537 return TRUE;
538}
539
22b75d0a
DM
540/* This function takes care of emitting STT_REGISTER symbols
541 which we cannot easily keep in the symbol hash table. */
587ff49e 542
22b75d0a
DM
543static bfd_boolean
544elf64_sparc_output_arch_syms (bfd *output_bfd ATTRIBUTE_UNUSED,
545 struct bfd_link_info *info,
2c3fc389
NC
546 void * flaginfo,
547 int (*func) (void *, const char *,
6e0b88f1
AM
548 Elf_Internal_Sym *,
549 asection *,
550 struct elf_link_hash_entry *))
587ff49e 551{
22b75d0a
DM
552 int reg;
553 struct _bfd_sparc_elf_app_reg *app_regs =
554 _bfd_sparc_elf_hash_table(info)->app_regs;
555 Elf_Internal_Sym sym;
40937810 556
22b75d0a
DM
557 /* We arranged in size_dynamic_sections to put the STT_REGISTER entries
558 at the end of the dynlocal list, so they came at the end of the local
559 symbols in the symtab. Except that they aren't STB_LOCAL, so we need
560 to back up symtab->sh_info. */
561 if (elf_hash_table (info)->dynlocal)
562 {
563 bfd * dynobj = elf_hash_table (info)->dynobj;
3d4d4302 564 asection *dynsymsec = bfd_get_linker_section (dynobj, ".dynsym");
22b75d0a 565 struct elf_link_local_dynamic_entry *e;
40937810 566
22b75d0a
DM
567 for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
568 if (e->input_indx == -1)
569 break;
570 if (e)
571 {
572 elf_section_data (dynsymsec->output_section)->this_hdr.sh_info
573 = e->dynindx;
574 }
575 }
a51a7930 576
22b75d0a
DM
577 if (info->strip == strip_all)
578 return TRUE;
587ff49e 579
22b75d0a
DM
580 for (reg = 0; reg < 4; reg++)
581 if (app_regs [reg].name != NULL)
582 {
583 if (info->strip == strip_some
584 && bfd_hash_lookup (info->keep_hash,
585 app_regs [reg].name,
586 FALSE, FALSE) == NULL)
587 continue;
587ff49e 588
22b75d0a
DM
589 sym.st_value = reg < 2 ? reg + 2 : reg + 4;
590 sym.st_size = 0;
591 sym.st_other = 0;
592 sym.st_info = ELF_ST_INFO (app_regs [reg].bind, STT_REGISTER);
593 sym.st_shndx = app_regs [reg].shndx;
35fc36a8 594 sym.st_target_internal = 0;
57402f1e 595 if ((*func) (flaginfo, app_regs [reg].name, &sym,
6e0b88f1
AM
596 sym.st_shndx == SHN_ABS
597 ? bfd_abs_section_ptr : bfd_und_section_ptr,
598 NULL) != 1)
22b75d0a
DM
599 return FALSE;
600 }
435b1e90 601
22b75d0a
DM
602 return TRUE;
603}
40937810 604
22b75d0a
DM
605static int
606elf64_sparc_get_symbol_type (Elf_Internal_Sym *elf_sym, int type)
40937810 607{
22b75d0a
DM
608 if (ELF_ST_TYPE (elf_sym->st_info) == STT_REGISTER)
609 return STT_REGISTER;
610 else
611 return type;
40937810
JJ
612}
613
22b75d0a
DM
614/* A STB_GLOBAL,STT_REGISTER symbol should be BSF_GLOBAL
615 even in SHN_UNDEF section. */
587ff49e 616
22b75d0a
DM
617static void
618elf64_sparc_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED, asymbol *asym)
587ff49e 619{
22b75d0a 620 elf_symbol_type *elfsym;
587ff49e 621
22b75d0a
DM
622 elfsym = (elf_symbol_type *) asym;
623 if (elfsym->internal_elf_sym.st_info
624 == ELF_ST_INFO (STB_GLOBAL, STT_REGISTER))
587ff49e 625 {
22b75d0a 626 asym->flags |= BSF_GLOBAL;
587ff49e 627 }
587ff49e 628}
a51a7930 629
22b75d0a
DM
630\f
631/* Functions for dealing with the e_flags field. */
a51a7930 632
22b75d0a
DM
633/* Merge backend specific data from an object file to the output
634 object file when linking. */
a51a7930
EB
635
636static bfd_boolean
22b75d0a 637elf64_sparc_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
a51a7930 638{
22b75d0a
DM
639 bfd_boolean error;
640 flagword new_flags, old_flags;
641 int new_mm, old_mm;
40937810 642
22b75d0a
DM
643 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
644 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
645 return TRUE;
40937810 646
22b75d0a
DM
647 new_flags = elf_elfheader (ibfd)->e_flags;
648 old_flags = elf_elfheader (obfd)->e_flags;
40937810 649
22b75d0a
DM
650 if (!elf_flags_init (obfd)) /* First call, no flags set */
651 {
652 elf_flags_init (obfd) = TRUE;
653 elf_elfheader (obfd)->e_flags = new_flags;
654 }
40937810 655
22b75d0a
DM
656 else if (new_flags == old_flags) /* Compatible flags are ok */
657 ;
40937810 658
22b75d0a 659 else /* Incompatible flags */
40937810 660 {
22b75d0a 661 error = FALSE;
40937810 662
22b75d0a
DM
663#define EF_SPARC_ISA_EXTENSIONS \
664 (EF_SPARC_SUN_US1 | EF_SPARC_SUN_US3 | EF_SPARC_HAL_R1)
19f7b010 665
37fb6db1
ILT
666 if ((ibfd->flags & DYNAMIC) != 0)
667 {
668 /* We don't want dynamic objects memory ordering and
669 architecture to have any role. That's what dynamic linker
670 should do. */
19f7b010 671 new_flags &= ~(EF_SPARCV9_MM | EF_SPARC_ISA_EXTENSIONS);
6c08d697 672 new_flags |= (old_flags
19f7b010 673 & (EF_SPARCV9_MM | EF_SPARC_ISA_EXTENSIONS));
37fb6db1
ILT
674 }
675 else
676 {
677 /* Choose the highest architecture requirements. */
19f7b010
JJ
678 old_flags |= (new_flags & EF_SPARC_ISA_EXTENSIONS);
679 new_flags |= (old_flags & EF_SPARC_ISA_EXTENSIONS);
680 if ((old_flags & (EF_SPARC_SUN_US1 | EF_SPARC_SUN_US3))
681 && (old_flags & EF_SPARC_HAL_R1))
37fb6db1 682 {
b34976b6 683 error = TRUE;
37fb6db1 684 (*_bfd_error_handler)
d003868e
AM
685 (_("%B: linking UltraSPARC specific with HAL specific code"),
686 ibfd);
37fb6db1
ILT
687 }
688 /* Choose the most restrictive memory ordering. */
689 old_mm = (old_flags & EF_SPARCV9_MM);
690 new_mm = (new_flags & EF_SPARCV9_MM);
691 old_flags &= ~EF_SPARCV9_MM;
692 new_flags &= ~EF_SPARCV9_MM;
693 if (new_mm < old_mm)
694 old_mm = new_mm;
695 old_flags |= old_mm;
696 new_flags |= old_mm;
697 }
252b5132
RH
698
699 /* Warn about any other mismatches */
700 if (new_flags != old_flags)
701 {
b34976b6 702 error = TRUE;
252b5132 703 (*_bfd_error_handler)
d003868e
AM
704 (_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
705 ibfd, (long) new_flags, (long) old_flags);
252b5132
RH
706 }
707
708 elf_elfheader (obfd)->e_flags = old_flags;
709
710 if (error)
711 {
712 bfd_set_error (bfd_error_bad_value);
b34976b6 713 return FALSE;
252b5132
RH
714 }
715 }
9e8c70f9 716 return _bfd_sparc_elf_merge_private_bfd_data (ibfd, obfd);
252b5132 717}
0594c12d
AM
718
719/* MARCO: Set the correct entry size for the .stab section. */
720
b34976b6 721static bfd_boolean
22b75d0a
DM
722elf64_sparc_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
723 Elf_Internal_Shdr *hdr ATTRIBUTE_UNUSED,
724 asection *sec)
0594c12d
AM
725{
726 const char *name;
727
728 name = bfd_get_section_name (abfd, sec);
729
730 if (strcmp (name, ".stab") == 0)
731 {
732 /* Even in the 64bit case the stab entries are only 12 bytes long. */
733 elf_section_data (sec)->this_hdr.sh_entsize = 12;
734 }
b34976b6
AM
735
736 return TRUE;
0594c12d 737}
587ff49e
RH
738\f
739/* Print a STT_REGISTER symbol to file FILE. */
252b5132 740
587ff49e 741static const char *
2c3fc389 742elf64_sparc_print_symbol_all (bfd *abfd ATTRIBUTE_UNUSED, void * filep,
22b75d0a 743 asymbol *symbol)
587ff49e
RH
744{
745 FILE *file = (FILE *) filep;
746 int reg, type;
435b1e90 747
587ff49e
RH
748 if (ELF_ST_TYPE (((elf_symbol_type *) symbol)->internal_elf_sym.st_info)
749 != STT_REGISTER)
750 return NULL;
751
752 reg = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value;
753 type = symbol->flags;
754 fprintf (file, "REG_%c%c%11s%c%c R", "GOLI" [reg / 8], '0' + (reg & 7), "",
755 ((type & BSF_LOCAL)
756 ? (type & BSF_GLOBAL) ? '!' : 'l'
99c79b2e
AJ
757 : (type & BSF_GLOBAL) ? 'g' : ' '),
758 (type & BSF_WEAK) ? 'w' : ' ');
587ff49e
RH
759 if (symbol->name == NULL || symbol->name [0] == '\0')
760 return "#scratch";
761 else
762 return symbol->name;
763}
252b5132 764\f
40937810 765static enum elf_reloc_type_class
7e612e98
AM
766elf64_sparc_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
767 const asection *rel_sec ATTRIBUTE_UNUSED,
768 const Elf_Internal_Rela *rela)
40937810
JJ
769{
770 switch ((int) ELF64_R_TYPE (rela->r_info))
771 {
772 case R_SPARC_RELATIVE:
773 return reloc_class_relative;
774 case R_SPARC_JMP_SLOT:
775 return reloc_class_plt;
776 case R_SPARC_COPY:
777 return reloc_class_copy;
778 default:
779 return reloc_class_normal;
780 }
781}
782
f65054f7
RH
783/* Relocations in the 64 bit SPARC ELF ABI are more complex than in
784 standard ELF, because R_SPARC_OLO10 has secondary addend in
785 ELF64_R_TYPE_DATA field. This structure is used to redirect the
786 relocation handling routines. */
787
22b75d0a 788const struct elf_size_info elf64_sparc_size_info =
f65054f7
RH
789{
790 sizeof (Elf64_External_Ehdr),
791 sizeof (Elf64_External_Phdr),
792 sizeof (Elf64_External_Shdr),
793 sizeof (Elf64_External_Rel),
794 sizeof (Elf64_External_Rela),
795 sizeof (Elf64_External_Sym),
796 sizeof (Elf64_External_Dyn),
797 sizeof (Elf_External_Note),
ae9a127f
NC
798 4, /* hash-table entry size. */
799 /* Internal relocations per external relocations.
f65054f7
RH
800 For link purposes we use just 1 internal per
801 1 external, for assembly and slurp symbol table
435b1e90 802 we use 2. */
f65054f7 803 1,
ae9a127f 804 64, /* arch_size. */
45d6a902 805 3, /* log_file_align. */
f65054f7
RH
806 ELFCLASS64,
807 EV_CURRENT,
808 bfd_elf64_write_out_phdrs,
809 bfd_elf64_write_shdrs_and_ehdr,
1489a3a0 810 bfd_elf64_checksum_contents,
22b75d0a 811 elf64_sparc_write_relocs,
73ff0d56 812 bfd_elf64_swap_symbol_in,
f65054f7 813 bfd_elf64_swap_symbol_out,
22b75d0a 814 elf64_sparc_slurp_reloc_table,
f65054f7
RH
815 bfd_elf64_slurp_symbol_table,
816 bfd_elf64_swap_dyn_in,
817 bfd_elf64_swap_dyn_out,
947216bf
AM
818 bfd_elf64_swap_reloc_in,
819 bfd_elf64_swap_reloc_out,
820 bfd_elf64_swap_reloca_in,
821 bfd_elf64_swap_reloca_out
f65054f7
RH
822};
823
252b5132
RH
824#define TARGET_BIG_SYM bfd_elf64_sparc_vec
825#define TARGET_BIG_NAME "elf64-sparc"
826#define ELF_ARCH bfd_arch_sparc
827#define ELF_MAXPAGESIZE 0x100000
24718e3b 828#define ELF_COMMONPAGESIZE 0x2000
252b5132
RH
829
830/* This is the official ABI value. */
831#define ELF_MACHINE_CODE EM_SPARCV9
832
833/* This is the value that we used before the ABI was released. */
834#define ELF_MACHINE_ALT1 EM_OLD_SPARCV9
835
22b75d0a
DM
836#define elf_backend_reloc_type_class \
837 elf64_sparc_reloc_type_class
f65054f7 838#define bfd_elf64_get_reloc_upper_bound \
22b75d0a 839 elf64_sparc_get_reloc_upper_bound
f65054f7 840#define bfd_elf64_get_dynamic_reloc_upper_bound \
22b75d0a 841 elf64_sparc_get_dynamic_reloc_upper_bound
3e1d7f19 842#define bfd_elf64_canonicalize_reloc \
22b75d0a 843 elf64_sparc_canonicalize_reloc
f65054f7 844#define bfd_elf64_canonicalize_dynamic_reloc \
22b75d0a
DM
845 elf64_sparc_canonicalize_dynamic_reloc
846#define elf_backend_add_symbol_hook \
847 elf64_sparc_add_symbol_hook
848#define elf_backend_get_symbol_type \
849 elf64_sparc_get_symbol_type
850#define elf_backend_symbol_processing \
851 elf64_sparc_symbol_processing
852#define elf_backend_print_symbol_all \
853 elf64_sparc_print_symbol_all
854#define elf_backend_output_arch_syms \
855 elf64_sparc_output_arch_syms
856#define bfd_elf64_bfd_merge_private_bfd_data \
857 elf64_sparc_merge_private_bfd_data
858#define elf_backend_fake_sections \
859 elf64_sparc_fake_sections
860#define elf_backend_size_info \
861 elf64_sparc_size_info
862
863#define elf_backend_plt_sym_val \
864 _bfd_sparc_elf_plt_sym_val
865#define bfd_elf64_bfd_link_hash_table_create \
866 _bfd_sparc_elf_link_hash_table_create
d0c9aeb3
DM
867#define bfd_elf64_bfd_link_hash_table_free \
868 _bfd_sparc_elf_link_hash_table_free
22b75d0a
DM
869#define elf_info_to_howto \
870 _bfd_sparc_elf_info_to_howto
871#define elf_backend_copy_indirect_symbol \
872 _bfd_sparc_elf_copy_indirect_symbol
252b5132 873#define bfd_elf64_bfd_reloc_type_lookup \
22b75d0a 874 _bfd_sparc_elf_reloc_type_lookup
157090f7
AM
875#define bfd_elf64_bfd_reloc_name_lookup \
876 _bfd_sparc_elf_reloc_name_lookup
f7775d95 877#define bfd_elf64_bfd_relax_section \
22b75d0a 878 _bfd_sparc_elf_relax_section
f0abc2a1 879#define bfd_elf64_new_section_hook \
22b75d0a 880 _bfd_sparc_elf_new_section_hook
252b5132
RH
881
882#define elf_backend_create_dynamic_sections \
22b75d0a 883 _bfd_sparc_elf_create_dynamic_sections
13285a1b
AM
884#define elf_backend_relocs_compatible \
885 _bfd_elf_relocs_compatible
252b5132 886#define elf_backend_check_relocs \
22b75d0a 887 _bfd_sparc_elf_check_relocs
252b5132 888#define elf_backend_adjust_dynamic_symbol \
22b75d0a 889 _bfd_sparc_elf_adjust_dynamic_symbol
151e5294 890#define elf_backend_omit_section_dynsym \
22b75d0a 891 _bfd_sparc_elf_omit_section_dynsym
252b5132 892#define elf_backend_size_dynamic_sections \
22b75d0a 893 _bfd_sparc_elf_size_dynamic_sections
252b5132 894#define elf_backend_relocate_section \
22b75d0a 895 _bfd_sparc_elf_relocate_section
252b5132 896#define elf_backend_finish_dynamic_symbol \
22b75d0a 897 _bfd_sparc_elf_finish_dynamic_symbol
252b5132 898#define elf_backend_finish_dynamic_sections \
22b75d0a 899 _bfd_sparc_elf_finish_dynamic_sections
252b5132 900
40937810 901#define bfd_elf64_mkobject \
22b75d0a 902 _bfd_sparc_elf_mkobject
252b5132 903#define elf_backend_object_p \
22b75d0a 904 _bfd_sparc_elf_object_p
40937810 905#define elf_backend_gc_mark_hook \
22b75d0a 906 _bfd_sparc_elf_gc_mark_hook
40937810 907#define elf_backend_gc_sweep_hook \
22b75d0a 908 _bfd_sparc_elf_gc_sweep_hook
74541ad4
AM
909#define elf_backend_init_index_section \
910 _bfd_elf_init_1_index_section
252b5132 911
40937810
JJ
912#define elf_backend_can_gc_sections 1
913#define elf_backend_can_refcount 1
252b5132
RH
914#define elf_backend_want_got_plt 0
915#define elf_backend_plt_readonly 0
916#define elf_backend_want_plt_sym 1
40937810 917#define elf_backend_got_header_size 8
f0fe0e16 918#define elf_backend_rela_normal 1
252b5132
RH
919
920/* Section 5.2.4 of the ABI specifies a 256-byte boundary for the table. */
921#define elf_backend_plt_alignment 8
922
252b5132 923#include "elf64-target.h"
71a75f6f
MF
924
925/* FreeBSD support */
926#undef TARGET_BIG_SYM
927#define TARGET_BIG_SYM bfd_elf64_sparc_freebsd_vec
928#undef TARGET_BIG_NAME
929#define TARGET_BIG_NAME "elf64-sparc-freebsd"
d1036acb
L
930#undef ELF_OSABI
931#define ELF_OSABI ELFOSABI_FREEBSD
71a75f6f 932
71a75f6f
MF
933#undef elf64_bed
934#define elf64_bed elf64_sparc_fbsd_bed
935
936#include "elf64-target.h"
937
1360ba76
RO
938/* Solaris 2. */
939
940#undef TARGET_BIG_SYM
941#define TARGET_BIG_SYM bfd_elf64_sparc_sol2_vec
942#undef TARGET_BIG_NAME
943#define TARGET_BIG_NAME "elf64-sparc-sol2"
944
945/* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
946 objects won't be recognized. */
947#undef ELF_OSABI
948
949#undef elf64_bed
950#define elf64_bed elf64_sparc_sol2_bed
951
952/* The 64-bit static TLS arena size is rounded to the nearest 16-byte
953 boundary. */
954#undef elf_backend_static_tls_alignment
955#define elf_backend_static_tls_alignment 16
956
957#include "elf64-target.h"