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