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