projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fix typo
[deliverable/binutils-gdb.git] / bfd / elf64-sparc.c
CommitLineData
252b5132
RH		 1/* SPARC-specific support for 64-bit ELF
2 Copyright (C) 1993, 95, 96, 97, 98, 1999 Free Software Foundation, Inc.
3
4This file is part of BFD, the Binary File Descriptor library.
5
6This program is free software; you can redistribute it and/or modify
7it under the terms of the GNU General Public License as published by
8the Free Software Foundation; either version 2 of the License, or
9(at your option) any later version.
10
11This program is distributed in the hope that it will be useful,
12but WITHOUT ANY WARRANTY; without even the implied warranty of
13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14GNU General Public License for more details.
15
16You should have received a copy of the GNU General Public License
17along with this program; if not, write to the Free Software
18Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
19
20#include "bfd.h"
21#include "sysdep.h"
22#include "libbfd.h"
23#include "elf-bfd.h"
24
25/* This is defined if one wants to build upward compatible binaries
26 with the original sparc64-elf toolchain. The support is kept in for
27 now but is turned off by default. dje 970930 */
28/*#define SPARC64_OLD_RELOCS*/
29
30#include "elf/sparc.h"
31
32/* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
33#define MINUS_ONE (~ (bfd_vma) 0)
34
587ff49e
RH		 35static struct bfd_link_hash_table * sparc64_elf_bfd_link_hash_table_create
36 PARAMS((bfd *));
252b5132
RH		 37static reloc_howto_type *sparc64_elf_reloc_type_lookup
38 PARAMS ((bfd *, bfd_reloc_code_real_type));
39static void sparc64_elf_info_to_howto
40 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
41
42static void sparc64_elf_build_plt
43 PARAMS((bfd *, unsigned char *, int));
44static bfd_vma sparc64_elf_plt_entry_offset
45 PARAMS((int));
46static bfd_vma sparc64_elf_plt_ptr_offset
47 PARAMS((int, int));
48
49static boolean sparc64_elf_check_relocs
50 PARAMS((bfd *, struct bfd_link_info *, asection *sec,
51 const Elf_Internal_Rela *));
52static boolean sparc64_elf_adjust_dynamic_symbol
53 PARAMS((struct bfd_link_info *, struct elf_link_hash_entry *));
54static boolean sparc64_elf_size_dynamic_sections
55 PARAMS((bfd *, struct bfd_link_info *));
587ff49e
RH		 56static int sparc64_elf_get_symbol_type
57 PARAMS (( Elf_Internal_Sym *, int));
58static boolean sparc64_elf_add_symbol_hook
59 PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Sym *,
60 const char **, flagword *, asection **, bfd_vma *));
61static void sparc64_elf_symbol_processing
62 PARAMS ((bfd *, asymbol *));
252b5132
RH		 63
64static boolean sparc64_elf_merge_private_bfd_data
65 PARAMS ((bfd *, bfd *));
66
67static boolean sparc64_elf_relocate_section
68 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
69 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
70static boolean sparc64_elf_object_p PARAMS ((bfd *));
f65054f7
RH		 71static long sparc64_elf_get_reloc_upper_bound PARAMS ((bfd *, asection *));
72static long sparc64_elf_get_dynamic_reloc_upper_bound PARAMS ((bfd *));
73static boolean sparc64_elf_slurp_one_reloc_table
74 PARAMS ((bfd *, asection *, Elf_Internal_Shdr *, asymbol **, boolean));
75static boolean sparc64_elf_slurp_reloc_table
76 PARAMS ((bfd *, asection *, asymbol **, boolean));
77static long sparc64_elf_canonicalize_dynamic_reloc
78 PARAMS ((bfd *, arelent **, asymbol **));
79static void sparc64_elf_write_relocs PARAMS ((bfd *, asection *, PTR));
252b5132
RH		 80\f
81/* The relocation "howto" table. */
82
83static bfd_reloc_status_type sparc_elf_notsup_reloc
84 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
85static bfd_reloc_status_type sparc_elf_wdisp16_reloc
86 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
87static bfd_reloc_status_type sparc_elf_hix22_reloc
88 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
89static bfd_reloc_status_type sparc_elf_lox10_reloc
90 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
91
92static reloc_howto_type sparc64_elf_howto_table[] =
93{
94 HOWTO(R_SPARC_NONE, 0,0, 0,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", false,0,0x00000000,true),
95 HOWTO(R_SPARC_8, 0,0, 8,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_8", false,0,0x000000ff,true),
96 HOWTO(R_SPARC_16, 0,1,16,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_16", false,0,0x0000ffff,true),
97 HOWTO(R_SPARC_32, 0,2,32,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_32", false,0,0xffffffff,true),
98 HOWTO(R_SPARC_DISP8, 0,0, 8,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP8", false,0,0x000000ff,true),
99 HOWTO(R_SPARC_DISP16, 0,1,16,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP16", false,0,0x0000ffff,true),
100 HOWTO(R_SPARC_DISP32, 0,2,32,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP32", false,0,0x00ffffff,true),
101 HOWTO(R_SPARC_WDISP30, 2,2,30,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP30", false,0,0x3fffffff,true),
102 HOWTO(R_SPARC_WDISP22, 2,2,22,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP22", false,0,0x003fffff,true),
103 HOWTO(R_SPARC_HI22, 10,2,22,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_HI22", false,0,0x003fffff,true),
104 HOWTO(R_SPARC_22, 0,2,22,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_22", false,0,0x003fffff,true),
105 HOWTO(R_SPARC_13, 0,2,13,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_13", false,0,0x00001fff,true),
106 HOWTO(R_SPARC_LO10, 0,2,10,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_LO10", false,0,0x000003ff,true),
107 HOWTO(R_SPARC_GOT10, 0,2,10,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOT10", false,0,0x000003ff,true),
108 HOWTO(R_SPARC_GOT13, 0,2,13,false,0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_GOT13", false,0,0x00001fff,true),
109 HOWTO(R_SPARC_GOT22, 10,2,22,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOT22", false,0,0x003fffff,true),
110 HOWTO(R_SPARC_PC10, 0,2,10,true, 0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_PC10", false,0,0x000003ff,true),
111 HOWTO(R_SPARC_PC22, 10,2,22,true, 0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_PC22", false,0,0x003fffff,true),
112 HOWTO(R_SPARC_WPLT30, 2,2,30,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WPLT30", false,0,0x3fffffff,true),
113 HOWTO(R_SPARC_COPY, 0,0,00,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_COPY", false,0,0x00000000,true),
114 HOWTO(R_SPARC_GLOB_DAT, 0,0,00,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GLOB_DAT",false,0,0x00000000,true),
115 HOWTO(R_SPARC_JMP_SLOT, 0,0,00,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_JMP_SLOT",false,0,0x00000000,true),
116 HOWTO(R_SPARC_RELATIVE, 0,0,00,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_RELATIVE",false,0,0x00000000,true),
117 HOWTO(R_SPARC_UA32, 0,0,00,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_UA32", false,0,0x00000000,true),
118#ifndef SPARC64_OLD_RELOCS
119 /* These aren't implemented yet. */
120 HOWTO(R_SPARC_PLT32, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PLT32", false,0,0x00000000,true),
121 HOWTO(R_SPARC_HIPLT22, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_HIPLT22", false,0,0x00000000,true),
122 HOWTO(R_SPARC_LOPLT10, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_LOPLT10", false,0,0x00000000,true),
123 HOWTO(R_SPARC_PCPLT32, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PCPLT32", false,0,0x00000000,true),
124 HOWTO(R_SPARC_PCPLT22, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PCPLT22", false,0,0x00000000,true),
125 HOWTO(R_SPARC_PCPLT10, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PCPLT10", false,0,0x00000000,true),
126#endif
127 HOWTO(R_SPARC_10, 0,2,10,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_10", false,0,0x000003ff,true),
128 HOWTO(R_SPARC_11, 0,2,11,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_11", false,0,0x000007ff,true),
129 HOWTO(R_SPARC_64, 0,4,64,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_64", false,0,MINUS_ONE, true),
130 HOWTO(R_SPARC_OLO10, 0,2,13,false,0,complain_overflow_signed, sparc_elf_notsup_reloc, "R_SPARC_OLO10", false,0,0x00001fff,true),
131 HOWTO(R_SPARC_HH22, 42,2,22,false,0,complain_overflow_unsigned,bfd_elf_generic_reloc, "R_SPARC_HH22", false,0,0x003fffff,true),
132 HOWTO(R_SPARC_HM10, 32,2,10,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_HM10", false,0,0x000003ff,true),
133 HOWTO(R_SPARC_LM22, 10,2,22,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_LM22", false,0,0x003fffff,true),
134 HOWTO(R_SPARC_PC_HH22, 42,2,22,true, 0,complain_overflow_unsigned,bfd_elf_generic_reloc, "R_SPARC_PC_HH22", false,0,0x003fffff,true),
135 HOWTO(R_SPARC_PC_HM10, 32,2,10,true, 0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_PC_HM10", false,0,0x000003ff,true),
136 HOWTO(R_SPARC_PC_LM22, 10,2,22,true, 0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_PC_LM22", false,0,0x003fffff,true),
137 HOWTO(R_SPARC_WDISP16, 2,2,16,true, 0,complain_overflow_signed, sparc_elf_wdisp16_reloc,"R_SPARC_WDISP16", false,0,0x00000000,true),
138 HOWTO(R_SPARC_WDISP19, 2,2,19,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP19", false,0,0x0007ffff,true),
139 HOWTO(R_SPARC_UNUSED_42, 0,0, 0,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_UNUSED_42",false,0,0x00000000,true),
140 HOWTO(R_SPARC_7, 0,2, 7,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_7", false,0,0x0000007f,true),
141 HOWTO(R_SPARC_5, 0,2, 5,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_5", false,0,0x0000001f,true),
142 HOWTO(R_SPARC_6, 0,2, 6,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_6", false,0,0x0000003f,true),
143 HOWTO(R_SPARC_DISP64, 0,4,64,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP64", false,0,MINUS_ONE, true),
144 HOWTO(R_SPARC_PLT64, 0,4,64,false,0,complain_overflow_bitfield,sparc_elf_notsup_reloc, "R_SPARC_PLT64", false,0,MINUS_ONE, false),
145 HOWTO(R_SPARC_HIX22, 0,4, 0,false,0,complain_overflow_bitfield,sparc_elf_hix22_reloc, "R_SPARC_HIX22", false,0,MINUS_ONE, false),
146 HOWTO(R_SPARC_LOX10, 0,4, 0,false,0,complain_overflow_dont, sparc_elf_lox10_reloc, "R_SPARC_LOX10", false,0,MINUS_ONE, false),
147 HOWTO(R_SPARC_H44, 22,2,22,false,0,complain_overflow_unsigned,bfd_elf_generic_reloc, "R_SPARC_H44", false,0,0x003fffff,false),
148 HOWTO(R_SPARC_M44, 12,2,10,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_M44", false,0,0x000003ff,false),
149 HOWTO(R_SPARC_L44, 0,2,13,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_L44", false,0,0x00000fff,false),
150 HOWTO(R_SPARC_REGISTER, 0,4, 0,false,0,complain_overflow_bitfield,sparc_elf_notsup_reloc, "R_SPARC_REGISTER",false,0,MINUS_ONE, false),
151 HOWTO(R_SPARC_UA64, 0,4,64,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA64", false,0,MINUS_ONE, true),
152 HOWTO(R_SPARC_UA16, 0,1,16,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA16", false,0,0x0000ffff,true)
153};
154
155struct elf_reloc_map {
156 bfd_reloc_code_real_type bfd_reloc_val;
157 unsigned char elf_reloc_val;
158};
159
160static CONST struct elf_reloc_map sparc_reloc_map[] =
161{
162 { BFD_RELOC_NONE, R_SPARC_NONE, },
163 { BFD_RELOC_16, R_SPARC_16, },
164 { BFD_RELOC_8, R_SPARC_8 },
165 { BFD_RELOC_8_PCREL, R_SPARC_DISP8 },
166 { BFD_RELOC_CTOR, R_SPARC_64 },
167 { BFD_RELOC_32, R_SPARC_32 },
168 { BFD_RELOC_32_PCREL, R_SPARC_DISP32 },
169 { BFD_RELOC_HI22, R_SPARC_HI22 },
170 { BFD_RELOC_LO10, R_SPARC_LO10, },
171 { BFD_RELOC_32_PCREL_S2, R_SPARC_WDISP30 },
172 { BFD_RELOC_SPARC22, R_SPARC_22 },
173 { BFD_RELOC_SPARC13, R_SPARC_13 },
174 { BFD_RELOC_SPARC_GOT10, R_SPARC_GOT10 },
175 { BFD_RELOC_SPARC_GOT13, R_SPARC_GOT13 },
176 { BFD_RELOC_SPARC_GOT22, R_SPARC_GOT22 },
177 { BFD_RELOC_SPARC_PC10, R_SPARC_PC10 },
178 { BFD_RELOC_SPARC_PC22, R_SPARC_PC22 },
179 { BFD_RELOC_SPARC_WPLT30, R_SPARC_WPLT30 },
180 { BFD_RELOC_SPARC_COPY, R_SPARC_COPY },
181 { BFD_RELOC_SPARC_GLOB_DAT, R_SPARC_GLOB_DAT },
182 { BFD_RELOC_SPARC_JMP_SLOT, R_SPARC_JMP_SLOT },
183 { BFD_RELOC_SPARC_RELATIVE, R_SPARC_RELATIVE },
184 { BFD_RELOC_SPARC_WDISP22, R_SPARC_WDISP22 },
185 /* ??? Doesn't dwarf use this? */
186/*{ BFD_RELOC_SPARC_UA32, R_SPARC_UA32 }, not used?? */
187 {BFD_RELOC_SPARC_10, R_SPARC_10},
188 {BFD_RELOC_SPARC_11, R_SPARC_11},
189 {BFD_RELOC_SPARC_64, R_SPARC_64},
190 {BFD_RELOC_SPARC_OLO10, R_SPARC_OLO10},
191 {BFD_RELOC_SPARC_HH22, R_SPARC_HH22},
192 {BFD_RELOC_SPARC_HM10, R_SPARC_HM10},
193 {BFD_RELOC_SPARC_LM22, R_SPARC_LM22},
194 {BFD_RELOC_SPARC_PC_HH22, R_SPARC_PC_HH22},
195 {BFD_RELOC_SPARC_PC_HM10, R_SPARC_PC_HM10},
196 {BFD_RELOC_SPARC_PC_LM22, R_SPARC_PC_LM22},
197 {BFD_RELOC_SPARC_WDISP16, R_SPARC_WDISP16},
198 {BFD_RELOC_SPARC_WDISP19, R_SPARC_WDISP19},
199 {BFD_RELOC_SPARC_7, R_SPARC_7},
200 {BFD_RELOC_SPARC_5, R_SPARC_5},
201 {BFD_RELOC_SPARC_6, R_SPARC_6},
202 {BFD_RELOC_SPARC_DISP64, R_SPARC_DISP64},
203 {BFD_RELOC_SPARC_PLT64, R_SPARC_PLT64},
204 {BFD_RELOC_SPARC_HIX22, R_SPARC_HIX22},
205 {BFD_RELOC_SPARC_LOX10, R_SPARC_LOX10},
206 {BFD_RELOC_SPARC_H44, R_SPARC_H44},
207 {BFD_RELOC_SPARC_M44, R_SPARC_M44},
208 {BFD_RELOC_SPARC_L44, R_SPARC_L44},
209 {BFD_RELOC_SPARC_REGISTER, R_SPARC_REGISTER}
210};
211
212static reloc_howto_type *
213sparc64_elf_reloc_type_lookup (abfd, code)
214 bfd *abfd;
215 bfd_reloc_code_real_type code;
216{
217 unsigned int i;
218 for (i = 0; i < sizeof (sparc_reloc_map) / sizeof (struct elf_reloc_map); i++)
219 {
220 if (sparc_reloc_map[i].bfd_reloc_val == code)
221 return &sparc64_elf_howto_table[(int) sparc_reloc_map[i].elf_reloc_val];
222 }
223 return 0;
224}
225
226static void
227sparc64_elf_info_to_howto (abfd, cache_ptr, dst)
228 bfd *abfd;
229 arelent *cache_ptr;
230 Elf64_Internal_Rela *dst;
231{
f65054f7
RH		 232 BFD_ASSERT (ELF64_R_TYPE_ID (dst->r_info) < (unsigned int) R_SPARC_max_std);
233 cache_ptr->howto = &sparc64_elf_howto_table[ELF64_R_TYPE_ID (dst->r_info)];
234}
235\f
236/* Due to the way how we handle R_SPARC_OLO10, each entry in a SHT_RELA
237 section can represent up to two relocs, we must tell the user to allocate
238 more space. */
239
240static long
241sparc64_elf_get_reloc_upper_bound (abfd, sec)
242 bfd *abfd;
243 asection *sec;
244{
245 return (sec->reloc_count * 2 + 1) * sizeof (arelent *);
246}
247
248static long
249sparc64_elf_get_dynamic_reloc_upper_bound (abfd)
250 bfd *abfd;
251{
252 return _bfd_elf_get_dynamic_reloc_upper_bound (abfd) * 2;
253}
254
255/* Read relocations for ASECT from REL_HDR. There are RELOC_COUNT of
256 them. We cannot use generic elf routines for this, because R_SPARC_OLO10
257 has secondary addend in ELF64_R_TYPE_DATA. We handle it as two relocations
258 for the same location, R_SPARC_LO10 and R_SPARC_13. */
259
260static boolean
261sparc64_elf_slurp_one_reloc_table (abfd, asect, rel_hdr, symbols, dynamic)
262 bfd *abfd;
263 asection *asect;
264 Elf_Internal_Shdr *rel_hdr;
265 asymbol **symbols;
266 boolean dynamic;
267{
268 struct elf_backend_data * const ebd = get_elf_backend_data (abfd);
269 PTR allocated = NULL;
270 bfd_byte *native_relocs;
271 arelent *relent;
272 unsigned int i;
273 int entsize;
274 bfd_size_type count;
275 arelent *relents;
276
277 allocated = (PTR) bfd_malloc ((size_t) rel_hdr->sh_size);
278 if (allocated == NULL)
279 goto error_return;
280
281 if (bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0
282 || (bfd_read (allocated, 1, rel_hdr->sh_size, abfd)
283 != rel_hdr->sh_size))
284 goto error_return;
285
286 native_relocs = (bfd_byte *) allocated;
287
288 relents = asect->relocation + asect->reloc_count;
289
290 entsize = rel_hdr->sh_entsize;
291 BFD_ASSERT (entsize == sizeof (Elf64_External_Rela));
292
293 count = rel_hdr->sh_size / entsize;
294
295 for (i = 0, relent = relents; i < count;
296 i++, relent++, native_relocs += entsize)
297 {
298 Elf_Internal_Rela rela;
299
300 bfd_elf64_swap_reloca_in (abfd, (Elf64_External_Rela *) native_relocs, &rela);
301
302 /* The address of an ELF reloc is section relative for an object
303 file, and absolute for an executable file or shared library.
304 The address of a normal BFD reloc is always section relative,
305 and the address of a dynamic reloc is absolute.. */
306 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0 || dynamic)
307 relent->address = rela.r_offset;
308 else
309 relent->address = rela.r_offset - asect->vma;
310
311 if (ELF64_R_SYM (rela.r_info) == 0)
312 relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
313 else
314 {
315 asymbol **ps, *s;
316
317 ps = symbols + ELF64_R_SYM (rela.r_info) - 1;
318 s = *ps;
319
320 /* Canonicalize ELF section symbols. FIXME: Why? */
321 if ((s->flags & BSF_SECTION_SYM) == 0)
322 relent->sym_ptr_ptr = ps;
323 else
324 relent->sym_ptr_ptr = s->section->symbol_ptr_ptr;
325 }
326
327 relent->addend = rela.r_addend;
328
329 BFD_ASSERT (ELF64_R_TYPE_ID (rela.r_info) < (unsigned int) R_SPARC_max_std);
330 if (ELF64_R_TYPE_ID (rela.r_info) == R_SPARC_OLO10)
331 {
332 relent->howto = &sparc64_elf_howto_table[R_SPARC_LO10];
333 relent[1].address = relent->address;
334 relent++;
335 relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
336 relent->addend = ELF64_R_TYPE_DATA (rela.r_info);
337 relent->howto = &sparc64_elf_howto_table[R_SPARC_13];
338 }
339 else
340 relent->howto = &sparc64_elf_howto_table[ELF64_R_TYPE_ID (rela.r_info)];
341 }
342
343 asect->reloc_count += relent - relents;
344
345 if (allocated != NULL)
346 free (allocated);
347
348 return true;
349
350 error_return:
351 if (allocated != NULL)
352 free (allocated);
353 return false;
354}
355
356/* Read in and swap the external relocs. */
357
358static boolean
359sparc64_elf_slurp_reloc_table (abfd, asect, symbols, dynamic)
360 bfd *abfd;
361 asection *asect;
362 asymbol **symbols;
363 boolean dynamic;
364{
365 struct bfd_elf_section_data * const d = elf_section_data (asect);
366 Elf_Internal_Shdr *rel_hdr;
367 Elf_Internal_Shdr *rel_hdr2;
368
369 if (asect->relocation != NULL)
370 return true;
371
372 if (! dynamic)
373 {
374 if ((asect->flags & SEC_RELOC) == 0
375 || asect->reloc_count == 0)
376 return true;
377
378 rel_hdr = &d->rel_hdr;
379 rel_hdr2 = d->rel_hdr2;
380
381 BFD_ASSERT (asect->rel_filepos == rel_hdr->sh_offset
382 || (rel_hdr2 && asect->rel_filepos == rel_hdr2->sh_offset));
383 }
384 else
385 {
386 /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
387 case because relocations against this section may use the
388 dynamic symbol table, and in that case bfd_section_from_shdr
389 in elf.c does not update the RELOC_COUNT. */
390 if (asect->_raw_size == 0)
391 return true;
392
393 rel_hdr = &d->this_hdr;
394 asect->reloc_count = rel_hdr->sh_size / rel_hdr->sh_entsize;
395 rel_hdr2 = NULL;
396 }
397
398 asect->relocation = ((arelent *)
399 bfd_alloc (abfd,
400 asect->reloc_count * 2 * sizeof (arelent)));
401 if (asect->relocation == NULL)
402 return false;
403
404 /* The sparc64_elf_slurp_one_reloc_table routine increments reloc_count. */
405 asect->reloc_count = 0;
406
407 if (!sparc64_elf_slurp_one_reloc_table (abfd, asect, rel_hdr, symbols,
408 dynamic))
409 return false;
410
411 if (rel_hdr2
412 && !sparc64_elf_slurp_one_reloc_table (abfd, asect, rel_hdr2, symbols,
413 dynamic))
414 return false;
415
416 return true;
417}
418
419/* Canonicalize the dynamic relocation entries. Note that we return
420 the dynamic relocations as a single block, although they are
421 actually associated with particular sections; the interface, which
422 was designed for SunOS style shared libraries, expects that there
423 is only one set of dynamic relocs. Any section that was actually
424 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
425 the dynamic symbol table, is considered to be a dynamic reloc
426 section. */
427
428static long
429sparc64_elf_canonicalize_dynamic_reloc (abfd, storage, syms)
430 bfd *abfd;
431 arelent **storage;
432 asymbol **syms;
433{
434 asection *s;
435 long ret;
436
437 if (elf_dynsymtab (abfd) == 0)
438 {
439 bfd_set_error (bfd_error_invalid_operation);
440 return -1;
441 }
442
443 ret = 0;
444 for (s = abfd->sections; s != NULL; s = s->next)
445 {
446 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
447 && (elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
448 {
449 arelent *p;
450 long count, i;
451
452 if (! sparc64_elf_slurp_reloc_table (abfd, s, syms, true))
453 return -1;
454 count = s->reloc_count;
455 p = s->relocation;
456 for (i = 0; i < count; i++)
457 *storage++ = p++;
458 ret += count;
459 }
460 }
461
462 *storage = NULL;
463
464 return ret;
465}
466
467/* Write out the relocs. */
468
469static void
470sparc64_elf_write_relocs (abfd, sec, data)
471 bfd *abfd;
472 asection *sec;
473 PTR data;
474{
475 boolean *failedp = (boolean *) data;
476 Elf_Internal_Shdr *rela_hdr;
477 Elf64_External_Rela *outbound_relocas;
478 unsigned int idx, count;
479 asymbol *last_sym = 0;
480 int last_sym_idx = 0;
481
482 /* If we have already failed, don't do anything. */
483 if (*failedp)
484 return;
485
486 if ((sec->flags & SEC_RELOC) == 0)
487 return;
488
489 /* The linker backend writes the relocs out itself, and sets the
490 reloc_count field to zero to inhibit writing them here. Also,
491 sometimes the SEC_RELOC flag gets set even when there aren't any
492 relocs. */
493 if (sec->reloc_count == 0)
494 return;
495
496 /* We can combine two relocs that refer to the same address
497 into R_SPARC_OLO10 if first one is R_SPARC_LO10 and the
498 latter is R_SPARC_13 with no associated symbol. */
499 count = 0;
500 for (idx = 0; idx < sec->reloc_count; idx++)
501 {
502 bfd_vma addr;
503 unsigned int i;
504
505 ++count;
506
507 addr = sec->orelocation[idx]->address;
508 if (sec->orelocation[idx]->howto->type == R_SPARC_LO10
509 && idx < sec->reloc_count - 1)
510 {
511 arelent *r = sec->orelocation[idx + 1];
512
513 if (r->howto->type == R_SPARC_13
514 && r->address == addr
515 && bfd_is_abs_section ((*r->sym_ptr_ptr)->section)
516 && (*r->sym_ptr_ptr)->value == 0)
517 ++idx;
518 }
519 }
520
521 rela_hdr = &elf_section_data (sec)->rel_hdr;
522
523 rela_hdr->sh_size = rela_hdr->sh_entsize * count;
524 rela_hdr->contents = (PTR) bfd_alloc (abfd, rela_hdr->sh_size);
525 if (rela_hdr->contents == NULL)
526 {
527 *failedp = true;
528 return;
529 }
530
531 /* Figure out whether the relocations are RELA or REL relocations. */
532 if (rela_hdr->sh_type != SHT_RELA)
533 abort ();
534
535 /* orelocation has the data, reloc_count has the count... */
536 outbound_relocas = (Elf64_External_Rela *) rela_hdr->contents;
537
538 for (idx = 0; idx < sec->reloc_count; idx++)
539 {
540 Elf_Internal_Rela dst_rela;
541 Elf64_External_Rela *src_rela;
542 arelent *ptr;
543 asymbol *sym;
544 int n;
545
546 ptr = sec->orelocation[idx];
547 src_rela = outbound_relocas + idx;
548
549 /* The address of an ELF reloc is section relative for an object
550 file, and absolute for an executable file or shared library.
551 The address of a BFD reloc is always section relative. */
552 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
553 dst_rela.r_offset = ptr->address;
554 else
555 dst_rela.r_offset = ptr->address + sec->vma;
556
557 sym = *ptr->sym_ptr_ptr;
558 if (sym == last_sym)
559 n = last_sym_idx;
560 else if (bfd_is_abs_section (sym->section) && sym->value == 0)
561 n = STN_UNDEF;
562 else
563 {
564 last_sym = sym;
565 n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
566 if (n < 0)
567 {
568 *failedp = true;
569 return;
570 }
571 last_sym_idx = n;
572 }
573
574 if ((*ptr->sym_ptr_ptr)->the_bfd != NULL
575 && (*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
576 && ! _bfd_elf_validate_reloc (abfd, ptr))
577 {
578 *failedp = true;
579 return;
580 }
581
582 if (ptr->howto->type == R_SPARC_LO10
583 && idx < sec->reloc_count - 1)
584 {
585 arelent *r = sec->orelocation[idx + 1];
586
587 if (r->howto->type == R_SPARC_13
588 && r->address == ptr->address
589 && bfd_is_abs_section ((*r->sym_ptr_ptr)->section)
590 && (*r->sym_ptr_ptr)->value == 0)
591 {
592 idx++;
593 dst_rela.r_info
594 = ELF64_R_INFO (n, ELF64_R_TYPE_INFO (r->addend,
595 R_SPARC_OLO10));
596 }
597 else
598 dst_rela.r_info = ELF64_R_INFO (n, R_SPARC_LO10);
599 }
600 else
601 dst_rela.r_info = ELF64_R_INFO (n, ptr->howto->type);
602
603 dst_rela.r_addend = ptr->addend;
604 bfd_elf64_swap_reloca_out (abfd, &dst_rela, src_rela);
605 }
252b5132 606}
587ff49e
RH		 607\f
608/* Sparc64 ELF linker hash table. */
609
610struct sparc64_elf_app_reg
611{
612 unsigned char bind;
613 unsigned short shndx;
614 bfd *abfd;
615 char *name;
616};
617
618struct sparc64_elf_link_hash_table
619{
620 struct elf_link_hash_table root;
621
622 struct sparc64_elf_app_reg app_regs [4];
623};
624
625/* Get the Sparc64 ELF linker hash table from a link_info structure. */
626
627#define sparc64_elf_hash_table(p) \
628 ((struct sparc64_elf_link_hash_table *) ((p)->hash))
629
630/* Create a Sparc64 ELF linker hash table. */
631
632static struct bfd_link_hash_table *
633sparc64_elf_bfd_link_hash_table_create (abfd)
634 bfd *abfd;
635{
636 struct sparc64_elf_link_hash_table *ret;
637
638 ret = ((struct sparc64_elf_link_hash_table *)
639 bfd_zalloc (abfd, sizeof (struct sparc64_elf_link_hash_table)));
640 if (ret == (struct sparc64_elf_link_hash_table *) NULL)
641 return NULL;
642
643 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
644 _bfd_elf_link_hash_newfunc))
645 {
646 bfd_release (abfd, ret);
647 return NULL;
648 }
649
650 return &ret->root.root;
651}
652
252b5132
RH		 653\f
654/* Utility for performing the standard initial work of an instruction
655 relocation.
656 *PRELOCATION will contain the relocated item.
657 *PINSN will contain the instruction from the input stream.
658 If the result is `bfd_reloc_other' the caller can continue with
659 performing the relocation. Otherwise it must stop and return the
660 value to its caller. */
661
662static bfd_reloc_status_type
663init_insn_reloc (abfd,
664 reloc_entry,
665 symbol,
666 data,
667 input_section,
668 output_bfd,
669 prelocation,
670 pinsn)
671 bfd *abfd;
672 arelent *reloc_entry;
673 asymbol *symbol;
674 PTR data;
675 asection *input_section;
676 bfd *output_bfd;
677 bfd_vma *prelocation;
678 bfd_vma *pinsn;
679{
680 bfd_vma relocation;
681 reloc_howto_type *howto = reloc_entry->howto;
682
683 if (output_bfd != (bfd *) NULL
684 && (symbol->flags & BSF_SECTION_SYM) == 0
685 && (! howto->partial_inplace
686 || reloc_entry->addend == 0))
687 {
688 reloc_entry->address += input_section->output_offset;
689 return bfd_reloc_ok;
690 }
691
692 /* This works because partial_inplace == false. */
693 if (output_bfd != NULL)
694 return bfd_reloc_continue;
695
696 if (reloc_entry->address > input_section->_cooked_size)
697 return bfd_reloc_outofrange;
698
699 relocation = (symbol->value
700 + symbol->section->output_section->vma
701 + symbol->section->output_offset);
702 relocation += reloc_entry->addend;
703 if (howto->pc_relative)
704 {
705 relocation -= (input_section->output_section->vma
706 + input_section->output_offset);
707 relocation -= reloc_entry->address;
708 }
709
710 *prelocation = relocation;
711 *pinsn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
712 return bfd_reloc_other;
713}
714
715/* For unsupported relocs. */
716
717static bfd_reloc_status_type
718sparc_elf_notsup_reloc (abfd,
719 reloc_entry,
720 symbol,
721 data,
722 input_section,
723 output_bfd,
724 error_message)
725 bfd *abfd;
726 arelent *reloc_entry;
727 asymbol *symbol;
728 PTR data;
729 asection *input_section;
730 bfd *output_bfd;
731 char **error_message;
732{
733 return bfd_reloc_notsupported;
734}
735
736/* Handle the WDISP16 reloc. */
737
738static bfd_reloc_status_type
739sparc_elf_wdisp16_reloc (abfd, reloc_entry, symbol, data, input_section,
740 output_bfd, error_message)
741 bfd *abfd;
742 arelent *reloc_entry;
743 asymbol *symbol;
744 PTR data;
745 asection *input_section;
746 bfd *output_bfd;
747 char **error_message;
748{
749 bfd_vma relocation;
750 bfd_vma insn;
751 bfd_reloc_status_type status;
752
753 status = init_insn_reloc (abfd, reloc_entry, symbol, data,
754 input_section, output_bfd, &relocation, &insn);
755 if (status != bfd_reloc_other)
756 return status;
757
758 insn = (insn & ~0x303fff) | ((((relocation >> 2) & 0xc000) << 6)
759 | ((relocation >> 2) & 0x3fff));
760 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
761
762 if ((bfd_signed_vma) relocation < - 0x40000
763 || (bfd_signed_vma) relocation > 0x3ffff)
764 return bfd_reloc_overflow;
765 else
766 return bfd_reloc_ok;
767}
768
769/* Handle the HIX22 reloc. */
770
771static bfd_reloc_status_type
772sparc_elf_hix22_reloc (abfd,
773 reloc_entry,
774 symbol,
775 data,
776 input_section,
777 output_bfd,
778 error_message)
779 bfd *abfd;
780 arelent *reloc_entry;
781 asymbol *symbol;
782 PTR data;
783 asection *input_section;
784 bfd *output_bfd;
785 char **error_message;
786{
787 bfd_vma relocation;
788 bfd_vma insn;
789 bfd_reloc_status_type status;
790
791 status = init_insn_reloc (abfd, reloc_entry, symbol, data,
792 input_section, output_bfd, &relocation, &insn);
793 if (status != bfd_reloc_other)
794 return status;
795
796 relocation ^= MINUS_ONE;
797 insn = (insn & ~0x3fffff) | ((relocation >> 10) & 0x3fffff);
798 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
799
800 if ((relocation & ~ (bfd_vma) 0xffffffff) != 0)
801 return bfd_reloc_overflow;
802 else
803 return bfd_reloc_ok;
804}
805
806/* Handle the LOX10 reloc. */
807
808static bfd_reloc_status_type
809sparc_elf_lox10_reloc (abfd,
810 reloc_entry,
811 symbol,
812 data,
813 input_section,
814 output_bfd,
815 error_message)
816 bfd *abfd;
817 arelent *reloc_entry;
818 asymbol *symbol;
819 PTR data;
820 asection *input_section;
821 bfd *output_bfd;
822 char **error_message;
823{
824 bfd_vma relocation;
825 bfd_vma insn;
826 bfd_reloc_status_type status;
827
828 status = init_insn_reloc (abfd, reloc_entry, symbol, data,
829 input_section, output_bfd, &relocation, &insn);
830 if (status != bfd_reloc_other)
831 return status;
832
833 insn = (insn & ~0x1fff) | 0x1c00 | (relocation & 0x3ff);
834 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
835
836 return bfd_reloc_ok;
837}
838\f
839/* PLT/GOT stuff */
840
841/* Both the headers and the entries are icache aligned. */
842#define PLT_ENTRY_SIZE 32
843#define PLT_HEADER_SIZE (4 * PLT_ENTRY_SIZE)
844#define LARGE_PLT_THRESHOLD 32768
845#define GOT_RESERVED_ENTRIES 1
846
847#define ELF_DYNAMIC_INTERPRETER "/usr/lib/sparcv9/ld.so.1"
848
849
850/* Fill in the .plt section. */
851
852static void
853sparc64_elf_build_plt (output_bfd, contents, nentries)
854 bfd *output_bfd;
855 unsigned char *contents;
856 int nentries;
857{
858 const unsigned int nop = 0x01000000;
859 int i, j;
860
861 /* The first four entries are reserved, and are initially undefined.
862 We fill them with `illtrap 0' to force ld.so to do something. */
863
864 for (i = 0; i < PLT_HEADER_SIZE/4; ++i)
865 bfd_put_32 (output_bfd, 0, contents+i*4);
866
867 /* The first 32768 entries are close enough to plt1 to get there via
868 a straight branch. */
869
870 for (i = 4; i < LARGE_PLT_THRESHOLD && i < nentries; ++i)
871 {
872 unsigned char *entry = contents + i * PLT_ENTRY_SIZE;
873 unsigned int sethi, ba;
874
875 /* sethi (. - plt0), %g1 */
876 sethi = 0x03000000 | (i * PLT_ENTRY_SIZE);
877
a11c78e7
RH		 878 /* ba,a,pt %xcc, plt1 */
879 ba = 0x30680000 | (((contents+PLT_ENTRY_SIZE) - (entry+4)) / 4 & 0x7ffff);
252b5132
RH		 880
881 bfd_put_32 (output_bfd, sethi, entry);
882 bfd_put_32 (output_bfd, ba, entry+4);
883 bfd_put_32 (output_bfd, nop, entry+8);
884 bfd_put_32 (output_bfd, nop, entry+12);
885 bfd_put_32 (output_bfd, nop, entry+16);
886 bfd_put_32 (output_bfd, nop, entry+20);
887 bfd_put_32 (output_bfd, nop, entry+24);
888 bfd_put_32 (output_bfd, nop, entry+28);
889 }
890
891 /* Now the tricky bit. Entries 32768 and higher are grouped in blocks of
892 160: 160 entries and 160 pointers. This is to separate code from data,
893 which is much friendlier on the cache. */
894
895 for (; i < nentries; i += 160)
896 {
897 int block = (i + 160 <= nentries ? 160 : nentries - i);
898 for (j = 0; j < block; ++j)
899 {
900 unsigned char *entry, *ptr;
901 unsigned int ldx;
902
903 entry = contents + i*PLT_ENTRY_SIZE + j*4*6;
904 ptr = contents + i*PLT_ENTRY_SIZE + block*4*6 + j*8;
905
906 /* ldx [%o7 + ptr - entry+4], %g1 */
907 ldx = 0xc25be000 | ((ptr - entry+4) & 0x1fff);
908
909 bfd_put_32 (output_bfd, 0x8a10000f, entry); /* mov %o7,%g5 */
910 bfd_put_32 (output_bfd, 0x40000002, entry+4); /* call .+8 */
911 bfd_put_32 (output_bfd, nop, entry+8); /* nop */
912 bfd_put_32 (output_bfd, ldx, entry+12); /* ldx [%o7+P],%g1 */
913 bfd_put_32 (output_bfd, 0x83c3c001, entry+16); /* jmpl %o7+%g1,%g1 */
914 bfd_put_32 (output_bfd, 0x9e100005, entry+20); /* mov %g5,%o7 */
915
a11c78e7 916 bfd_put_64 (output_bfd, contents - (entry+4), ptr);
252b5132
RH		 917 }
918 }
919}
920
921/* Return the offset of a particular plt entry within the .plt section. */
922
923static bfd_vma
924sparc64_elf_plt_entry_offset (index)
925 int index;
926{
927 int block, ofs;
928
929 if (index < LARGE_PLT_THRESHOLD)
930 return index * PLT_ENTRY_SIZE;
931
932 /* See above for details. */
933
934 block = (index - LARGE_PLT_THRESHOLD) / 160;
935 ofs = (index - LARGE_PLT_THRESHOLD) % 160;
936
937 return ((bfd_vma)(LARGE_PLT_THRESHOLD + block*160) * PLT_ENTRY_SIZE
938 + ofs * 6*4);
939}
940
941static bfd_vma
942sparc64_elf_plt_ptr_offset (index, max)
943 int index, max;
944{
945 int block, ofs, last;
946
947 BFD_ASSERT(index >= LARGE_PLT_THRESHOLD);
948
949 /* See above for details. */
950
a11c78e7
RH		 951 block = (((index - LARGE_PLT_THRESHOLD) / 160) * 160)
952 + LARGE_PLT_THRESHOLD;
953 ofs = index - block;
954 if (block + 160 > max)
955 last = (max - LARGE_PLT_THRESHOLD) % 160;
956 else
957 last = 160;
252b5132 958
a11c78e7 959 return (block * PLT_ENTRY_SIZE
252b5132
RH		 960 + last * 6*4
961 + ofs * 8);
962}
963
964
965\f
966/* Look through the relocs for a section during the first phase, and
967 allocate space in the global offset table or procedure linkage
968 table. */
969
970static boolean
971sparc64_elf_check_relocs (abfd, info, sec, relocs)
972 bfd *abfd;
973 struct bfd_link_info *info;
974 asection *sec;
975 const Elf_Internal_Rela *relocs;
976{
977 bfd *dynobj;
978 Elf_Internal_Shdr *symtab_hdr;
979 struct elf_link_hash_entry **sym_hashes;
980 bfd_vma *local_got_offsets;
981 const Elf_Internal_Rela *rel;
982 const Elf_Internal_Rela *rel_end;
983 asection *sgot;
984 asection *srelgot;
985 asection *sreloc;
986
987 if (info->relocateable || !(sec->flags & SEC_ALLOC))
988 return true;
989
990 dynobj = elf_hash_table (info)->dynobj;
991 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
992 sym_hashes = elf_sym_hashes (abfd);
993 local_got_offsets = elf_local_got_offsets (abfd);
994
995 sgot = NULL;
996 srelgot = NULL;
997 sreloc = NULL;
998
999 rel_end = relocs + sec->reloc_count;
1000 for (rel = relocs; rel < rel_end; rel++)
1001 {
1002 unsigned long r_symndx;
1003 struct elf_link_hash_entry *h;
1004
1005 r_symndx = ELF64_R_SYM (rel->r_info);
1006 if (r_symndx < symtab_hdr->sh_info)
1007 h = NULL;
1008 else
1009 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1010
f65054f7 1011 switch (ELF64_R_TYPE_ID (rel->r_info))
252b5132
RH		 1012 {
1013 case R_SPARC_GOT10:
1014 case R_SPARC_GOT13:
1015 case R_SPARC_GOT22:
1016 /* This symbol requires a global offset table entry. */
1017
1018 if (dynobj == NULL)
1019 {
1020 /* Create the .got section. */
1021 elf_hash_table (info)->dynobj = dynobj = abfd;
1022 if (! _bfd_elf_create_got_section (dynobj, info))
1023 return false;
1024 }
1025
1026 if (sgot == NULL)
1027 {
1028 sgot = bfd_get_section_by_name (dynobj, ".got");
1029 BFD_ASSERT (sgot != NULL);
1030 }
1031
1032 if (srelgot == NULL && (h != NULL || info->shared))
1033 {
1034 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1035 if (srelgot == NULL)
1036 {
1037 srelgot = bfd_make_section (dynobj, ".rela.got");
1038 if (srelgot == NULL
1039 || ! bfd_set_section_flags (dynobj, srelgot,
1040 (SEC_ALLOC
1041 | SEC_LOAD
1042 | SEC_HAS_CONTENTS
1043 | SEC_IN_MEMORY
1044 | SEC_LINKER_CREATED
1045 | SEC_READONLY))
1046 || ! bfd_set_section_alignment (dynobj, srelgot, 3))
1047 return false;
1048 }
1049 }
1050
1051 if (h != NULL)
1052 {
1053 if (h->got.offset != (bfd_vma) -1)
1054 {
1055 /* We have already allocated space in the .got. */
1056 break;
1057 }
1058 h->got.offset = sgot->_raw_size;
1059
1060 /* Make sure this symbol is output as a dynamic symbol. */
1061 if (h->dynindx == -1)
1062 {
1063 if (! bfd_elf64_link_record_dynamic_symbol (info, h))
1064 return false;
1065 }
1066
1067 srelgot->_raw_size += sizeof (Elf64_External_Rela);
1068 }
1069 else
1070 {
1071 /* This is a global offset table entry for a local
1072 symbol. */
1073 if (local_got_offsets == NULL)
1074 {
1075 size_t size;
1076 register unsigned int i;
1077
1078 size = symtab_hdr->sh_info * sizeof (bfd_vma);
1079 local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
1080 if (local_got_offsets == NULL)
1081 return false;
1082 elf_local_got_offsets (abfd) = local_got_offsets;
1083 for (i = 0; i < symtab_hdr->sh_info; i++)
1084 local_got_offsets[i] = (bfd_vma) -1;
1085 }
1086 if (local_got_offsets[r_symndx] != (bfd_vma) -1)
1087 {
1088 /* We have already allocated space in the .got. */
1089 break;
1090 }
1091 local_got_offsets[r_symndx] = sgot->_raw_size;
1092
1093 if (info->shared)
1094 {
1095 /* If we are generating a shared object, we need to
1096 output a R_SPARC_RELATIVE reloc so that the
1097 dynamic linker can adjust this GOT entry. */
1098 srelgot->_raw_size += sizeof (Elf64_External_Rela);
1099 }
1100 }
1101
1102 sgot->_raw_size += 8;
1103
1104#if 0
1105 /* Doesn't work for 64-bit -fPIC, since sethi/or builds
1106 unsigned numbers. If we permit ourselves to modify
1107 code so we get sethi/xor, this could work.
1108 Question: do we consider conditionally re-enabling
1109 this for -fpic, once we know about object code models? */
1110 /* If the .got section is more than 0x1000 bytes, we add
1111 0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13
1112 bit relocations have a greater chance of working. */
1113 if (sgot->_raw_size >= 0x1000
1114 && elf_hash_table (info)->hgot->root.u.def.value == 0)
1115 elf_hash_table (info)->hgot->root.u.def.value = 0x1000;
1116#endif
1117
1118 break;
1119
1120 case R_SPARC_WPLT30:
1121 case R_SPARC_PLT32:
1122 case R_SPARC_HIPLT22:
1123 case R_SPARC_LOPLT10:
1124 case R_SPARC_PCPLT32:
1125 case R_SPARC_PCPLT22:
1126 case R_SPARC_PCPLT10:
1127 case R_SPARC_PLT64:
1128 /* This symbol requires a procedure linkage table entry. We
1129 actually build the entry in adjust_dynamic_symbol,
1130 because this might be a case of linking PIC code without
1131 linking in any dynamic objects, in which case we don't
1132 need to generate a procedure linkage table after all. */
1133
1134 if (h == NULL)
1135 {
1136 /* It does not make sense to have a procedure linkage
1137 table entry for a local symbol. */
1138 bfd_set_error (bfd_error_bad_value);
1139 return false;
1140 }
1141
1142 /* Make sure this symbol is output as a dynamic symbol. */
1143 if (h->dynindx == -1)
1144 {
1145 if (! bfd_elf64_link_record_dynamic_symbol (info, h))
1146 return false;
1147 }
1148
1149 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
1150 break;
1151
1152 case R_SPARC_PC10:
1153 case R_SPARC_PC22:
1154 case R_SPARC_PC_HH22:
1155 case R_SPARC_PC_HM10:
1156 case R_SPARC_PC_LM22:
1157 if (h != NULL
1158 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1159 break;
1160 /* Fall through. */
1161 case R_SPARC_DISP8:
1162 case R_SPARC_DISP16:
1163 case R_SPARC_DISP32:
1164 case R_SPARC_DISP64:
1165 case R_SPARC_WDISP30:
1166 case R_SPARC_WDISP22:
1167 case R_SPARC_WDISP19:
1168 case R_SPARC_WDISP16:
1169 if (h == NULL)
1170 break;
1171 /* Fall through. */
1172 case R_SPARC_8:
1173 case R_SPARC_16:
1174 case R_SPARC_32:
1175 case R_SPARC_HI22:
1176 case R_SPARC_22:
1177 case R_SPARC_13:
1178 case R_SPARC_LO10:
1179 case R_SPARC_UA32:
1180 case R_SPARC_10:
1181 case R_SPARC_11:
1182 case R_SPARC_64:
1183 case R_SPARC_OLO10:
1184 case R_SPARC_HH22:
1185 case R_SPARC_HM10:
1186 case R_SPARC_LM22:
1187 case R_SPARC_7:
1188 case R_SPARC_5:
1189 case R_SPARC_6:
1190 case R_SPARC_HIX22:
1191 case R_SPARC_LOX10:
1192 case R_SPARC_H44:
1193 case R_SPARC_M44:
1194 case R_SPARC_L44:
1195 case R_SPARC_UA64:
1196 case R_SPARC_UA16:
1197 /* When creating a shared object, we must copy these relocs
1198 into the output file. We create a reloc section in
1199 dynobj and make room for the reloc.
1200
1201 But don't do this for debugging sections -- this shows up
1202 with DWARF2 -- first because they are not loaded, and
1203 second because DWARF sez the debug info is not to be
1204 biased by the load address. */
1205 if (info->shared && (sec->flags & SEC_ALLOC))
1206 {
1207 if (sreloc == NULL)
1208 {
1209 const char *name;
1210
1211 name = (bfd_elf_string_from_elf_section
1212 (abfd,
1213 elf_elfheader (abfd)->e_shstrndx,
1214 elf_section_data (sec)->rel_hdr.sh_name));
1215 if (name == NULL)
1216 return false;
1217
1218 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
1219 && strcmp (bfd_get_section_name (abfd, sec),
1220 name + 5) == 0);
1221
1222 sreloc = bfd_get_section_by_name (dynobj, name);
1223 if (sreloc == NULL)
1224 {
1225 flagword flags;
1226
1227 sreloc = bfd_make_section (dynobj, name);
1228 flags = (SEC_HAS_CONTENTS | SEC_READONLY
1229 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1230 if ((sec->flags & SEC_ALLOC) != 0)
1231 flags |= SEC_ALLOC | SEC_LOAD;
1232 if (sreloc == NULL
1233 || ! bfd_set_section_flags (dynobj, sreloc, flags)
1234 || ! bfd_set_section_alignment (dynobj, sreloc, 3))
1235 return false;
1236 }
1237 }
1238
1239 sreloc->_raw_size += sizeof (Elf64_External_Rela);
1240 }
1241 break;
1242
1243 case R_SPARC_REGISTER:
1244 /* Nothing to do. */
1245 break;
1246
1247 default:
1248 (*_bfd_error_handler)(_("%s: check_relocs: unhandled reloc type %d"),
1249 bfd_get_filename(abfd),
f65054f7 1250 ELF64_R_TYPE_ID (rel->r_info));
252b5132
RH		 1251 return false;
1252 }
1253 }
1254
1255 return true;
1256}
1257
587ff49e
RH		 1258/* Hook called by the linker routine which adds symbols from an object
1259 file. We use it for STT_REGISTER symbols. */
1260
1261static boolean
1262sparc64_elf_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
1263 bfd *abfd;
1264 struct bfd_link_info *info;
1265 const Elf_Internal_Sym *sym;
1266 const char **namep;
1267 flagword *flagsp;
1268 asection **secp;
1269 bfd_vma *valp;
1270{
1271 static char *stt_types[] = { "NOTYPE", "OBJECT", "FUNCTION" };
1272
1273 if (ELF_ST_TYPE (sym->st_info) == STT_REGISTER)
1274 {
1275 int reg;
1276 struct sparc64_elf_app_reg *p;
1277
1278 reg = (int)sym->st_value;
1279 switch (reg & ~1)
1280 {
1281 case 2: reg -= 2; break;
1282 case 6: reg -= 4; break;
1283 default:
1284 (*_bfd_error_handler)
1285 (_("%s: Only registers %%g[2367] can be declared using STT_REGISTER"),
1286 bfd_get_filename (abfd));
1287 return false;
1288 }
1289
1290 if (info->hash->creator != abfd->xvec
1291 || (abfd->flags & DYNAMIC) != 0)
1292 {
1293 /* STT_REGISTER only works when linking an elf64_sparc object.
1294 If STT_REGISTER comes from a dynamic object, don't put it into
1295 the output bfd. The dynamic linker will recheck it. */
1296 *namep = NULL;
1297 return true;
1298 }
1299
1300 p = sparc64_elf_hash_table(info)->app_regs + reg;
1301
1302 if (p->name != NULL && strcmp (p->name, *namep))
1303 {
1304 (*_bfd_error_handler)
1305 (_("Register %%g%d used incompatibly: "
1306 "previously declared in %s to %s, in %s redefined to %s"),
1307 (int)sym->st_value,
1308 bfd_get_filename (p->abfd), *p->name ? p->name : "#scratch",
1309 bfd_get_filename (abfd), **namep ? *namep : "#scratch");
1310 return false;
1311 }
1312
1313 if (p->name == NULL)
1314 {
1315 if (**namep)
1316 {
1317 struct elf_link_hash_entry *h;
1318
1319 h = (struct elf_link_hash_entry *)
1320 bfd_link_hash_lookup (info->hash, *namep, false, false, false);
1321
1322 if (h != NULL)
1323 {
1324 unsigned char type = h->type;
1325
1326 if (type > STT_FUNC) type = 0;
1327 (*_bfd_error_handler)
1328 (_("Symbol `%s' has differing types: "
1329 "previously %s, REGISTER in %s"),
1330 *namep, stt_types [type], bfd_get_filename (abfd));
1331 return false;
1332 }
1333
1334 p->name = bfd_hash_allocate (&info->hash->table,
1335 strlen (*namep) + 1);
1336 if (!p->name)
1337 return false;
1338
1339 strcpy (p->name, *namep);
1340 }
1341 else
1342 p->name = "";
1343 p->bind = ELF_ST_BIND (sym->st_info);
1344 p->abfd = abfd;
1345 p->shndx = sym->st_shndx;
1346 }
1347 else
1348 {
1349 if (p->bind == STB_WEAK
1350 && ELF_ST_BIND (sym->st_info) == STB_GLOBAL)
1351 {
1352 p->bind = STB_GLOBAL;
1353 p->abfd = abfd;
1354 }
1355 }
1356 *namep = NULL;
1357 return true;
1358 }
1359 else if (! *namep || ! **namep)
1360 return true;
1361 else
1362 {
1363 int i;
1364 struct sparc64_elf_app_reg *p;
1365
1366 p = sparc64_elf_hash_table(info)->app_regs;
1367 for (i = 0; i < 4; i++, p++)
1368 if (p->name != NULL && ! strcmp (p->name, *namep))
1369 {
1370 unsigned char type = ELF_ST_TYPE (sym->st_info);
1371
1372 if (type > STT_FUNC) type = 0;
1373 (*_bfd_error_handler)
1374 (_("Symbol `%s' has differing types: "
1375 "REGISTER in %s, %s in %s"),
1376 *namep, bfd_get_filename (p->abfd), stt_types [type],
1377 bfd_get_filename (abfd));
1378 return false;
1379 }
1380 }
1381 return true;
1382}
1383
1384/* This function takes care of emiting STT_REGISTER symbols
1385 which we cannot easily keep in the symbol hash table. */
1386
1387static boolean
1388sparc64_elf_output_arch_syms (output_bfd, info, finfo, func)
1389 bfd *output_bfd;
1390 struct bfd_link_info *info;
1391 PTR finfo;
1392 boolean (*func) PARAMS ((PTR, const char *,
1393 Elf_Internal_Sym *, asection *));
1394{
1395 int reg;
1396 struct sparc64_elf_app_reg *app_regs =
1397 sparc64_elf_hash_table(info)->app_regs;
1398 Elf_Internal_Sym sym;
1399
1400 /* We arranged in size_dynamic_sections to put the STT_REGISTER entries
1401 at the end of the dynlocal list, so they came at the end of the local
1402 symbols in the symtab. Except that they aren't STB_LOCAL, so we need
1403 to back up symtab->sh_info. */
1404 if (elf_hash_table (info)->dynlocal)
1405 {
1406 struct elf_link_local_dynamic_entry *e;
1407
1408 for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
1409 if (e->input_indx == -1)
1410 break;
1411 if (e)
1412 {
1413 elf_section_data (dynsymsec->output_section)->this_hdr.sh_info
1414 = e->dynindx;
1415 }
1416 }
1417
1418 if (info->strip == strip_all)
1419 return true;
1420
1421 for (reg = 0; reg < 4; reg++)
1422 if (app_regs [reg].name != NULL)
1423 {
1424 if (info->strip == strip_some
1425 && bfd_hash_lookup (info->keep_hash,
1426 app_regs [reg].name,
1427 false, false) == NULL)
1428 continue;
1429
1430 sym.st_value = reg < 2 ? reg + 2 : reg + 4;
1431 sym.st_size = 0;
1432 sym.st_other = 0;
1433 sym.st_info = ELF_ST_INFO (app_regs [reg].bind, STT_REGISTER);
1434 sym.st_shndx = app_regs [reg].shndx;
1435 if (! (*func) (finfo, app_regs [reg].name, &sym,
1436 sym.st_shndx == SHN_ABS
1437 ? bfd_abs_section_ptr : bfd_und_section_ptr))
1438 return false;
1439 }
1440
1441 return true;
1442}
1443
1444static int
1445sparc64_elf_get_symbol_type (elf_sym, type)
1446 Elf_Internal_Sym * elf_sym;
1447 int type;
1448{
1449 if (ELF_ST_TYPE (elf_sym->st_info) == STT_REGISTER)
1450 return STT_REGISTER;
1451 else
1452 return type;
1453}
1454
1455/* A STB_GLOBAL,STT_REGISTER symbol should be BSF_GLOBAL
1456 even in SHN_UNDEF section. */
1457
1458static void
1459sparc64_elf_symbol_processing (abfd, asym)
1460 bfd *abfd;
1461 asymbol *asym;
1462{
1463 elf_symbol_type *elfsym;
1464
1465 elfsym = (elf_symbol_type *) asym;
1466 if (elfsym->internal_elf_sym.st_info
1467 == ELF_ST_INFO (STB_GLOBAL, STT_REGISTER))
1468 {
1469 asym->flags |= BSF_GLOBAL;
1470 }
1471}
1472
252b5132
RH		 1473/* Adjust a symbol defined by a dynamic object and referenced by a
1474 regular object. The current definition is in some section of the
1475 dynamic object, but we're not including those sections. We have to
1476 change the definition to something the rest of the link can
1477 understand. */
1478
1479static boolean
1480sparc64_elf_adjust_dynamic_symbol (info, h)
1481 struct bfd_link_info *info;
1482 struct elf_link_hash_entry *h;
1483{
1484 bfd *dynobj;
1485 asection *s;
1486 unsigned int power_of_two;
1487
1488 dynobj = elf_hash_table (info)->dynobj;
1489
1490 /* Make sure we know what is going on here. */
1491 BFD_ASSERT (dynobj != NULL
1492 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
1493 || h->weakdef != NULL
1494 || ((h->elf_link_hash_flags
1495 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1496 && (h->elf_link_hash_flags
1497 & ELF_LINK_HASH_REF_REGULAR) != 0
1498 && (h->elf_link_hash_flags
1499 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
1500
1501 /* If this is a function, put it in the procedure linkage table. We
1502 will fill in the contents of the procedure linkage table later
1503 (although we could actually do it here). The STT_NOTYPE
1504 condition is a hack specifically for the Oracle libraries
1505 delivered for Solaris; for some inexplicable reason, they define
1506 some of their functions as STT_NOTYPE when they really should be
1507 STT_FUNC. */
1508 if (h->type == STT_FUNC
1509 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0
1510 || (h->type == STT_NOTYPE
1511 && (h->root.type == bfd_link_hash_defined
1512 || h->root.type == bfd_link_hash_defweak)
1513 && (h->root.u.def.section->flags & SEC_CODE) != 0))
1514 {
1515 if (! elf_hash_table (info)->dynamic_sections_created)
1516 {
1517 /* This case can occur if we saw a WPLT30 reloc in an input
1518 file, but none of the input files were dynamic objects.
1519 In such a case, we don't actually need to build a
1520 procedure linkage table, and we can just do a WDISP30
1521 reloc instead. */
1522 BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
1523 return true;
1524 }
1525
1526 s = bfd_get_section_by_name (dynobj, ".plt");
1527 BFD_ASSERT (s != NULL);
1528
1529 /* The first four bit in .plt is reserved. */
1530 if (s->_raw_size == 0)
1531 s->_raw_size = PLT_HEADER_SIZE;
1532
1533 /* If this symbol is not defined in a regular file, and we are
1534 not generating a shared library, then set the symbol to this
1535 location in the .plt. This is required to make function
1536 pointers compare as equal between the normal executable and
1537 the shared library. */
1538 if (! info->shared
1539 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1540 {
1541 h->root.u.def.section = s;
1542 h->root.u.def.value = s->_raw_size;
1543 }
1544
1545 /* To simplify matters later, just store the plt index here. */
1546 h->plt.offset = s->_raw_size / PLT_ENTRY_SIZE;
1547
1548 /* Make room for this entry. */
1549 s->_raw_size += PLT_ENTRY_SIZE;
1550
1551 /* We also need to make an entry in the .rela.plt section. */
1552
1553 s = bfd_get_section_by_name (dynobj, ".rela.plt");
1554 BFD_ASSERT (s != NULL);
1555
1556 /* The first plt entries are reserved, and the relocations must
1557 pair up exactly. */
1558 if (s->_raw_size == 0)
1559 s->_raw_size += (PLT_HEADER_SIZE/PLT_ENTRY_SIZE
1560 * sizeof (Elf64_External_Rela));
1561
1562 s->_raw_size += sizeof (Elf64_External_Rela);
1563
1564 /* The procedure linkage table size is bounded by the magnitude
1565 of the offset we can describe in the entry. */
1566 if (s->_raw_size >= (bfd_vma)1 << 32)
1567 {
1568 bfd_set_error (bfd_error_bad_value);
1569 return false;
1570 }
1571
1572 return true;
1573 }
1574
1575 /* If this is a weak symbol, and there is a real definition, the
1576 processor independent code will have arranged for us to see the
1577 real definition first, and we can just use the same value. */
1578 if (h->weakdef != NULL)
1579 {
1580 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
1581 || h->weakdef->root.type == bfd_link_hash_defweak);
1582 h->root.u.def.section = h->weakdef->root.u.def.section;
1583 h->root.u.def.value = h->weakdef->root.u.def.value;
1584 return true;
1585 }
1586
1587 /* This is a reference to a symbol defined by a dynamic object which
1588 is not a function. */
1589
1590 /* If we are creating a shared library, we must presume that the
1591 only references to the symbol are via the global offset table.
1592 For such cases we need not do anything here; the relocations will
1593 be handled correctly by relocate_section. */
1594 if (info->shared)
1595 return true;
1596
1597 /* We must allocate the symbol in our .dynbss section, which will
1598 become part of the .bss section of the executable. There will be
1599 an entry for this symbol in the .dynsym section. The dynamic
1600 object will contain position independent code, so all references
1601 from the dynamic object to this symbol will go through the global
1602 offset table. The dynamic linker will use the .dynsym entry to
1603 determine the address it must put in the global offset table, so
1604 both the dynamic object and the regular object will refer to the
1605 same memory location for the variable. */
1606
1607 s = bfd_get_section_by_name (dynobj, ".dynbss");
1608 BFD_ASSERT (s != NULL);
1609
1610 /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker
1611 to copy the initial value out of the dynamic object and into the
1612 runtime process image. We need to remember the offset into the
1613 .rel.bss section we are going to use. */
1614 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1615 {
1616 asection *srel;
1617
1618 srel = bfd_get_section_by_name (dynobj, ".rela.bss");
1619 BFD_ASSERT (srel != NULL);
1620 srel->_raw_size += sizeof (Elf64_External_Rela);
1621 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
1622 }
1623
1624 /* We need to figure out the alignment required for this symbol. I
1625 have no idea how ELF linkers handle this. 16-bytes is the size
1626 of the largest type that requires hard alignment -- long double. */
1627 power_of_two = bfd_log2 (h->size);
1628 if (power_of_two > 4)
1629 power_of_two = 4;
1630
1631 /* Apply the required alignment. */
1632 s->_raw_size = BFD_ALIGN (s->_raw_size,
1633 (bfd_size_type) (1 << power_of_two));
1634 if (power_of_two > bfd_get_section_alignment (dynobj, s))
1635 {
1636 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
1637 return false;
1638 }
1639
1640 /* Define the symbol as being at this point in the section. */
1641 h->root.u.def.section = s;
1642 h->root.u.def.value = s->_raw_size;
1643
1644 /* Increment the section size to make room for the symbol. */
1645 s->_raw_size += h->size;
1646
1647 return true;
1648}
1649
1650/* Set the sizes of the dynamic sections. */
1651
1652static boolean
1653sparc64_elf_size_dynamic_sections (output_bfd, info)
1654 bfd *output_bfd;
1655 struct bfd_link_info *info;
1656{
1657 bfd *dynobj;
1658 asection *s;
1659 boolean reltext;
1660 boolean relplt;
1661
1662 dynobj = elf_hash_table (info)->dynobj;
1663 BFD_ASSERT (dynobj != NULL);
1664
1665 if (elf_hash_table (info)->dynamic_sections_created)
1666 {
1667 /* Set the contents of the .interp section to the interpreter. */
1668 if (! info->shared)
1669 {
1670 s = bfd_get_section_by_name (dynobj, ".interp");
1671 BFD_ASSERT (s != NULL);
1672 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
1673 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1674 }
1675 }
1676 else
1677 {
1678 /* We may have created entries in the .rela.got section.
1679 However, if we are not creating the dynamic sections, we will
1680 not actually use these entries. Reset the size of .rela.got,
1681 which will cause it to get stripped from the output file
1682 below. */
1683 s = bfd_get_section_by_name (dynobj, ".rela.got");
1684 if (s != NULL)
1685 s->_raw_size = 0;
1686 }
1687
1688 /* The check_relocs and adjust_dynamic_symbol entry points have
1689 determined the sizes of the various dynamic sections. Allocate
1690 memory for them. */
1691 reltext = false;
1692 relplt = false;
1693 for (s = dynobj->sections; s != NULL; s = s->next)
1694 {
1695 const char *name;
1696 boolean strip;
1697
1698 if ((s->flags & SEC_LINKER_CREATED) == 0)
1699 continue;
1700
1701 /* It's OK to base decisions on the section name, because none
1702 of the dynobj section names depend upon the input files. */
1703 name = bfd_get_section_name (dynobj, s);
1704
1705 strip = false;
1706
1707 if (strncmp (name, ".rela", 5) == 0)
1708 {
1709 if (s->_raw_size == 0)
1710 {
1711 /* If we don't need this section, strip it from the
1712 output file. This is to handle .rela.bss and
1713 .rel.plt. We must create it in
1714 create_dynamic_sections, because it must be created
1715 before the linker maps input sections to output
1716 sections. The linker does that before
1717 adjust_dynamic_symbol is called, and it is that
1718 function which decides whether anything needs to go
1719 into these sections. */
1720 strip = true;
1721 }
1722 else
1723 {
1724 const char *outname;
1725 asection *target;
1726
1727 /* If this relocation section applies to a read only
1728 section, then we probably need a DT_TEXTREL entry. */
1729 outname = bfd_get_section_name (output_bfd,
1730 s->output_section);
1731 target = bfd_get_section_by_name (output_bfd, outname + 5);
1732 if (target != NULL
1733 && (target->flags & SEC_READONLY) != 0)
1734 reltext = true;
1735
1736 if (strcmp (name, ".rela.plt") == 0)
1737 relplt = true;
1738
1739 /* We use the reloc_count field as a counter if we need
1740 to copy relocs into the output file. */
1741 s->reloc_count = 0;
1742 }
1743 }
1744 else if (strcmp (name, ".plt") != 0
1745 && strncmp (name, ".got", 4) != 0)
1746 {
1747 /* It's not one of our sections, so don't allocate space. */
1748 continue;
1749 }
1750
1751 if (strip)
1752 {
1753 _bfd_strip_section_from_output (s);
1754 continue;
1755 }
1756
1757 /* Allocate memory for the section contents. Zero the memory
1758 for the benefit of .rela.plt, which has 4 unused entries
1759 at the beginning, and we don't want garbage. */
1760 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
1761 if (s->contents == NULL && s->_raw_size != 0)
1762 return false;
1763 }
1764
1765 if (elf_hash_table (info)->dynamic_sections_created)
1766 {
1767 /* Add some entries to the .dynamic section. We fill in the
1768 values later, in sparc64_elf_finish_dynamic_sections, but we
1769 must add the entries now so that we get the correct size for
1770 the .dynamic section. The DT_DEBUG entry is filled in by the
1771 dynamic linker and used by the debugger. */
587ff49e
RH		 1772 int reg;
1773 struct sparc64_elf_app_reg * app_regs;
1774 struct bfd_strtab_hash *dynstr;
1775 struct elf_link_hash_table *eht = elf_hash_table (info);
1776
252b5132
RH		 1777 if (! info->shared)
1778 {
1779 if (! bfd_elf64_add_dynamic_entry (info, DT_DEBUG, 0))
1780 return false;
1781 }
1782
1783 if (relplt)
1784 {
1785 if (! bfd_elf64_add_dynamic_entry (info, DT_PLTGOT, 0)
1786 || ! bfd_elf64_add_dynamic_entry (info, DT_PLTRELSZ, 0)
1787 || ! bfd_elf64_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
d6bcbdc1 1788 || ! bfd_elf64_add_dynamic_entry (info, DT_JMPREL, 0))
252b5132
RH		 1789 return false;
1790 }
1791
1792 if (! bfd_elf64_add_dynamic_entry (info, DT_RELA, 0)
1793 || ! bfd_elf64_add_dynamic_entry (info, DT_RELASZ, 0)
1794 || ! bfd_elf64_add_dynamic_entry (info, DT_RELAENT,
1795 sizeof (Elf64_External_Rela)))
1796 return false;
1797
1798 if (reltext)
1799 {
1800 if (! bfd_elf64_add_dynamic_entry (info, DT_TEXTREL, 0))
1801 return false;
1802 }
587ff49e
RH		 1803
1804 /* Add dynamic STT_REGISTER symbols and corresponding DT_SPARC_REGISTER
1805 entries if needed. */
1806 app_regs = sparc64_elf_hash_table (info)->app_regs;
1807 dynstr = eht->dynstr;
1808
1809 for (reg = 0; reg < 4; reg++)
1810 if (app_regs [reg].name != NULL)
1811 {
1812 struct elf_link_local_dynamic_entry *entry, *e;
1813
1814 if (! bfd_elf64_add_dynamic_entry (info, DT_SPARC_REGISTER, 0))
1815 return false;
1816
1817 entry = (struct elf_link_local_dynamic_entry *)
1818 bfd_hash_allocate (&info->hash->table, sizeof (*entry));
1819 if (entry == NULL)
1820 return false;
1821
1822 /* We cheat here a little bit: the symbol will not be local, so we
1823 put it at the end of the dynlocal linked list. We will fix it
1824 later on, as we have to fix other fields anyway. */
1825 entry->isym.st_value = reg < 2 ? reg + 2 : reg + 4;
1826 entry->isym.st_size = 0;
1827 if (*app_regs [reg].name != '\0')
1828 entry->isym.st_name
1829 = _bfd_stringtab_add (dynstr, app_regs[reg].name, true, false);
1830 else
1831 entry->isym.st_name = 0;
1832 entry->isym.st_other = 0;
1833 entry->isym.st_info = ELF_ST_INFO (app_regs [reg].bind,
1834 STT_REGISTER);
1835 entry->isym.st_shndx = app_regs [reg].shndx;
1836 entry->next = NULL;
1837 entry->input_bfd = output_bfd;
1838 entry->input_indx = -1;
1839
1840 if (eht->dynlocal == NULL)
1841 eht->dynlocal = entry;
1842 else
1843 {
1844 for (e = eht->dynlocal; e->next; e = e->next)
1845 ;
1846 e->next = entry;
1847 }
1848 eht->dynsymcount++;
1849 }
252b5132
RH		 1850 }
1851
252b5132
RH		 1852 return true;
1853}
252b5132
RH		 1854\f
1855/* Relocate a SPARC64 ELF section. */
1856
1857static boolean
1858sparc64_elf_relocate_section (output_bfd, info, input_bfd, input_section,
1859 contents, relocs, local_syms, local_sections)
1860 bfd *output_bfd;
1861 struct bfd_link_info *info;
1862 bfd *input_bfd;
1863 asection *input_section;
1864 bfd_byte *contents;
1865 Elf_Internal_Rela *relocs;
1866 Elf_Internal_Sym *local_syms;
1867 asection **local_sections;
1868{
1869 bfd *dynobj;
1870 Elf_Internal_Shdr *symtab_hdr;
1871 struct elf_link_hash_entry **sym_hashes;
1872 bfd_vma *local_got_offsets;
1873 bfd_vma got_base;
1874 asection *sgot;
1875 asection *splt;
1876 asection *sreloc;
1877 Elf_Internal_Rela *rel;
1878 Elf_Internal_Rela *relend;
1879
1880 dynobj = elf_hash_table (info)->dynobj;
1881 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1882 sym_hashes = elf_sym_hashes (input_bfd);
1883 local_got_offsets = elf_local_got_offsets (input_bfd);
1884
1885 if (elf_hash_table(info)->hgot == NULL)
1886 got_base = 0;
1887 else
1888 got_base = elf_hash_table (info)->hgot->root.u.def.value;
1889
1890 sgot = splt = sreloc = NULL;
1891
1892 rel = relocs;
1893 relend = relocs + input_section->reloc_count;
1894 for (; rel < relend; rel++)
1895 {
1896 int r_type;
1897 reloc_howto_type *howto;
1898 long r_symndx;
1899 struct elf_link_hash_entry *h;
1900 Elf_Internal_Sym *sym;
1901 asection *sec;
1902 bfd_vma relocation;
1903 bfd_reloc_status_type r;
1904
f65054f7 1905 r_type = ELF64_R_TYPE_ID (rel->r_info);
60dac299 1906 if (r_type < 0 || r_type >= (int) R_SPARC_max_std)
252b5132
RH		 1907 {
1908 bfd_set_error (bfd_error_bad_value);
1909 return false;
1910 }
1911 howto = sparc64_elf_howto_table + r_type;
1912
1913 r_symndx = ELF64_R_SYM (rel->r_info);
1914
1915 if (info->relocateable)
1916 {
1917 /* This is a relocateable link. We don't have to change
1918 anything, unless the reloc is against a section symbol,
1919 in which case we have to adjust according to where the
1920 section symbol winds up in the output section. */
1921 if (r_symndx < symtab_hdr->sh_info)
1922 {
1923 sym = local_syms + r_symndx;
1924 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1925 {
1926 sec = local_sections[r_symndx];
1927 rel->r_addend += sec->output_offset + sym->st_value;
1928 }
1929 }
1930
1931 continue;
1932 }
1933
1934 /* This is a final link. */
1935 h = NULL;
1936 sym = NULL;
1937 sec = NULL;
1938 if (r_symndx < symtab_hdr->sh_info)
1939 {
1940 sym = local_syms + r_symndx;
1941 sec = local_sections[r_symndx];
1942 relocation = (sec->output_section->vma
1943 + sec->output_offset
1944 + sym->st_value);
1945 }
1946 else
1947 {
1948 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1949 while (h->root.type == bfd_link_hash_indirect
1950 || h->root.type == bfd_link_hash_warning)
1951 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1952 if (h->root.type == bfd_link_hash_defined
1953 || h->root.type == bfd_link_hash_defweak)
1954 {
1955 boolean skip_it = false;
1956 sec = h->root.u.def.section;
1957
1958 switch (r_type)
1959 {
1960 case R_SPARC_WPLT30:
1961 case R_SPARC_PLT32:
1962 case R_SPARC_HIPLT22:
1963 case R_SPARC_LOPLT10:
1964 case R_SPARC_PCPLT32:
1965 case R_SPARC_PCPLT22:
1966 case R_SPARC_PCPLT10:
1967 case R_SPARC_PLT64:
1968 if (h->plt.offset != (bfd_vma) -1)
1969 skip_it = true;
1970 break;
1971
1972 case R_SPARC_GOT10:
1973 case R_SPARC_GOT13:
1974 case R_SPARC_GOT22:
1975 if (elf_hash_table(info)->dynamic_sections_created
1976 && (!info->shared
1977 || (!info->symbolic && h->dynindx != -1)
1978 || !(h->elf_link_hash_flags
1979 & ELF_LINK_HASH_DEF_REGULAR)))
1980 skip_it = true;
1981 break;
1982
1983 case R_SPARC_PC10:
1984 case R_SPARC_PC22:
1985 case R_SPARC_PC_HH22:
1986 case R_SPARC_PC_HM10:
1987 case R_SPARC_PC_LM22:
1988 if (!strcmp(h->root.root.string, "_GLOBAL_OFFSET_TABLE_"))
1989 break;
1990 /* FALLTHRU */
1991
1992 case R_SPARC_8:
1993 case R_SPARC_16:
1994 case R_SPARC_32:
1995 case R_SPARC_DISP8:
1996 case R_SPARC_DISP16:
1997 case R_SPARC_DISP32:
1998 case R_SPARC_WDISP30:
1999 case R_SPARC_WDISP22:
2000 case R_SPARC_HI22:
2001 case R_SPARC_22:
2002 case R_SPARC_13:
2003 case R_SPARC_LO10:
2004 case R_SPARC_UA32:
2005 case R_SPARC_10:
2006 case R_SPARC_11:
2007 case R_SPARC_64:
2008 case R_SPARC_OLO10:
2009 case R_SPARC_HH22:
2010 case R_SPARC_HM10:
2011 case R_SPARC_LM22:
2012 case R_SPARC_WDISP19:
2013 case R_SPARC_WDISP16:
2014 case R_SPARC_7:
2015 case R_SPARC_5:
2016 case R_SPARC_6:
2017 case R_SPARC_DISP64:
2018 case R_SPARC_HIX22:
2019 case R_SPARC_LOX10:
2020 case R_SPARC_H44:
2021 case R_SPARC_M44:
2022 case R_SPARC_L44:
2023 case R_SPARC_UA64:
2024 case R_SPARC_UA16:
2025 if (info->shared
2026 && ((!info->symbolic && h->dynindx != -1)
2027 || !(h->elf_link_hash_flags
2028 & ELF_LINK_HASH_DEF_REGULAR)))
2029 skip_it = true;
2030 break;
2031 }
2032
2033 if (skip_it)
2034 {
2035 /* In these cases, we don't need the relocation
2036 value. We check specially because in some
2037 obscure cases sec->output_section will be NULL. */
2038 relocation = 0;
2039 }
2040 else
2041 {
2042 relocation = (h->root.u.def.value
2043 + sec->output_section->vma
2044 + sec->output_offset);
2045 }
2046 }
2047 else if (h->root.type == bfd_link_hash_undefweak)
2048 relocation = 0;
2049 else if (info->shared && !info->symbolic && !info->no_undefined)
2050 relocation = 0;
2051 else
2052 {
2053 if (! ((*info->callbacks->undefined_symbol)
2054 (info, h->root.root.string, input_bfd,
2055 input_section, rel->r_offset)))
2056 return false;
2057 relocation = 0;
2058 }
2059 }
2060
2061 /* When generating a shared object, these relocations are copied
2062 into the output file to be resolved at run time. */
2063 if (info->shared && (input_section->flags & SEC_ALLOC))
2064 {
2065 switch (r_type)
2066 {
2067 case R_SPARC_PC10:
2068 case R_SPARC_PC22:
2069 case R_SPARC_PC_HH22:
2070 case R_SPARC_PC_HM10:
2071 case R_SPARC_PC_LM22:
2072 if (h != NULL
2073 && !strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_"))
2074 break;
2075 /* Fall through. */
2076 case R_SPARC_DISP8:
2077 case R_SPARC_DISP16:
2078 case R_SPARC_DISP32:
2079 case R_SPARC_WDISP30:
2080 case R_SPARC_WDISP22:
2081 case R_SPARC_WDISP19:
2082 case R_SPARC_WDISP16:
2083 case R_SPARC_DISP64:
2084 if (h == NULL)
2085 break;
2086 /* Fall through. */
2087 case R_SPARC_8:
2088 case R_SPARC_16:
2089 case R_SPARC_32:
2090 case R_SPARC_HI22:
2091 case R_SPARC_22:
2092 case R_SPARC_13:
2093 case R_SPARC_LO10:
2094 case R_SPARC_UA32:
2095 case R_SPARC_10:
2096 case R_SPARC_11:
2097 case R_SPARC_64:
2098 case R_SPARC_OLO10:
2099 case R_SPARC_HH22:
2100 case R_SPARC_HM10:
2101 case R_SPARC_LM22:
2102 case R_SPARC_7:
2103 case R_SPARC_5:
2104 case R_SPARC_6:
2105 case R_SPARC_HIX22:
2106 case R_SPARC_LOX10:
2107 case R_SPARC_H44:
2108 case R_SPARC_M44:
2109 case R_SPARC_L44:
2110 case R_SPARC_UA64:
2111 case R_SPARC_UA16:
2112 {
2113 Elf_Internal_Rela outrel;
2114 boolean skip;
2115
2116 if (sreloc == NULL)
2117 {
2118 const char *name =
2119 (bfd_elf_string_from_elf_section
2120 (input_bfd,
2121 elf_elfheader (input_bfd)->e_shstrndx,
2122 elf_section_data (input_section)->rel_hdr.sh_name));
2123
2124 if (name == NULL)
2125 return false;
2126
2127 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
2128 && strcmp (bfd_get_section_name(input_bfd,
2129 input_section),
2130 name + 5) == 0);
2131
2132 sreloc = bfd_get_section_by_name (dynobj, name);
2133 BFD_ASSERT (sreloc != NULL);
2134 }
2135
2136 skip = false;
2137
2138 if (elf_section_data (input_section)->stab_info == NULL)
2139 outrel.r_offset = rel->r_offset;
2140 else
2141 {
2142 bfd_vma off;
2143
2144 off = (_bfd_stab_section_offset
2145 (output_bfd, &elf_hash_table (info)->stab_info,
2146 input_section,
2147 &elf_section_data (input_section)->stab_info,
2148 rel->r_offset));
2149 if (off == MINUS_ONE)
2150 skip = true;
2151 outrel.r_offset = off;
2152 }
2153
2154 outrel.r_offset += (input_section->output_section->vma
2155 + input_section->output_offset);
2156
2157 /* Optimize unaligned reloc usage now that we know where
2158 it finally resides. */
2159 switch (r_type)
2160 {
2161 case R_SPARC_16:
2162 if (outrel.r_offset & 1) r_type = R_SPARC_UA16;
2163 break;
2164 case R_SPARC_UA16:
2165 if (!(outrel.r_offset & 1)) r_type = R_SPARC_16;
2166 break;
2167 case R_SPARC_32:
2168 if (outrel.r_offset & 3) r_type = R_SPARC_UA32;
2169 break;
2170 case R_SPARC_UA32:
2171 if (!(outrel.r_offset & 3)) r_type = R_SPARC_32;
2172 break;
2173 case R_SPARC_64:
2174 if (outrel.r_offset & 7) r_type = R_SPARC_UA64;
2175 break;
2176 case R_SPARC_UA64:
2177 if (!(outrel.r_offset & 7)) r_type = R_SPARC_64;
2178 break;
2179 }
2180
2181 if (skip)
2182 memset (&outrel, 0, sizeof outrel);
2183 /* h->dynindx may be -1 if the symbol was marked to
2184 become local. */
2185 else if (h != NULL
2186 && ((! info->symbolic && h->dynindx != -1)
2187 || (h->elf_link_hash_flags
2188 & ELF_LINK_HASH_DEF_REGULAR) == 0))
2189 {
2190 BFD_ASSERT (h->dynindx != -1);
f65054f7
RH		 2191 outrel.r_info
2192 = ELF64_R_INFO (h->dynindx,
2193 ELF64_R_TYPE_INFO (
2194 ELF64_R_TYPE_DATA (rel->r_info),
2195 r_type));
252b5132
RH		 2196 outrel.r_addend = rel->r_addend;
2197 }
2198 else
2199 {
2200 if (r_type == R_SPARC_64)
2201 {
2202 outrel.r_info = ELF64_R_INFO (0, R_SPARC_RELATIVE);
2203 outrel.r_addend = relocation + rel->r_addend;
2204 }
2205 else
2206 {
2207 long indx;
2208
2209 if (h == NULL)
2210 sec = local_sections[r_symndx];
2211 else
2212 {
2213 BFD_ASSERT (h->root.type == bfd_link_hash_defined
2214 || (h->root.type
2215 == bfd_link_hash_defweak));
2216 sec = h->root.u.def.section;
2217 }
2218 if (sec != NULL && bfd_is_abs_section (sec))
2219 indx = 0;
2220 else if (sec == NULL || sec->owner == NULL)
2221 {
2222 bfd_set_error (bfd_error_bad_value);
2223 return false;
2224 }
2225 else
2226 {
2227 asection *osec;
2228
2229 osec = sec->output_section;
2230 indx = elf_section_data (osec)->dynindx;
2231
2232 /* FIXME: we really should be able to link non-pic
2233 shared libraries. */
2234 if (indx == 0)
2235 {
2236 BFD_FAIL ();
2237 (*_bfd_error_handler)
2238 (_("%s: probably compiled without -fPIC?"),
2239 bfd_get_filename (input_bfd));
2240 bfd_set_error (bfd_error_bad_value);
2241 return false;
2242 }
2243 }
2244
f65054f7
RH		 2245 outrel.r_info
2246 = ELF64_R_INFO (indx,
2247 ELF64_R_TYPE_INFO (
2248 ELF64_R_TYPE_DATA (rel->r_info),
2249 r_type));
252b5132
RH		 2250
2251 /* For non-RELATIVE dynamic relocations, we keep the
2252 same symbol, and so generally the same addend. But
2253 we do need to adjust those relocations referencing
2254 sections. */
2255 outrel.r_addend = rel->r_addend;
2256 if (r_symndx < symtab_hdr->sh_info
2257 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2258 outrel.r_addend += sec->output_offset+sym->st_value;
2259 }
2260 }
2261
2262 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
2263 (((Elf64_External_Rela *)
2264 sreloc->contents)
2265 + sreloc->reloc_count));
2266 ++sreloc->reloc_count;
2267
2268 /* This reloc will be computed at runtime, so there's no
2269 need to do anything now, unless this is a RELATIVE
2270 reloc in an unallocated section. */
2271 if (skip
2272 || (input_section->flags & SEC_ALLOC) != 0
f65054f7 2273 || ELF64_R_TYPE_ID (outrel.r_info) != R_SPARC_RELATIVE)
252b5132
RH		 2274 continue;
2275 }
2276 break;
2277 }
2278 }
2279
2280 switch (r_type)
2281 {
2282 case R_SPARC_GOT10:
2283 case R_SPARC_GOT13:
2284 case R_SPARC_GOT22:
2285 /* Relocation is to the entry for this symbol in the global
2286 offset table. */
2287 if (sgot == NULL)
2288 {
2289 sgot = bfd_get_section_by_name (dynobj, ".got");
2290 BFD_ASSERT (sgot != NULL);
2291 }
2292
2293 if (h != NULL)
2294 {
2295 bfd_vma off = h->got.offset;
2296 BFD_ASSERT (off != (bfd_vma) -1);
2297
2298 if (! elf_hash_table (info)->dynamic_sections_created
2299 || (info->shared
2300 && (info->symbolic || h->dynindx == -1)
2301 && (h->elf_link_hash_flags
2302 & ELF_LINK_HASH_DEF_REGULAR)))
2303 {
2304 /* This is actually a static link, or it is a -Bsymbolic
2305 link and the symbol is defined locally, or the symbol
2306 was forced to be local because of a version file. We
2307 must initialize this entry in the global offset table.
2308 Since the offset must always be a multiple of 8, we
2309 use the least significant bit to record whether we
2310 have initialized it already.
2311
2312 When doing a dynamic link, we create a .rela.got
2313 relocation entry to initialize the value. This is
2314 done in the finish_dynamic_symbol routine. */
2315
2316 if ((off & 1) != 0)
2317 off &= ~1;
2318 else
2319 {
2320 bfd_put_64 (output_bfd, relocation,
2321 sgot->contents + off);
2322 h->got.offset |= 1;
2323 }
2324 }
2325 relocation = sgot->output_offset + off - got_base;
2326 }
2327 else
2328 {
2329 bfd_vma off;
2330
2331 BFD_ASSERT (local_got_offsets != NULL);
2332 off = local_got_offsets[r_symndx];
2333 BFD_ASSERT (off != (bfd_vma) -1);
2334
2335 /* The offset must always be a multiple of 8. We use
2336 the least significant bit to record whether we have
2337 already processed this entry. */
2338 if ((off & 1) != 0)
2339 off &= ~1;
2340 else
2341 {
2342 bfd_put_64 (output_bfd, relocation, sgot->contents + off);
2343 local_got_offsets[r_symndx] |= 1;
2344
2345 if (info->shared)
2346 {
2347 asection *srelgot;
2348 Elf_Internal_Rela outrel;
2349
2350 /* We need to generate a R_SPARC_RELATIVE reloc
2351 for the dynamic linker. */
2352 srelgot = bfd_get_section_by_name(dynobj, ".rela.got");
2353 BFD_ASSERT (srelgot != NULL);
2354
2355 outrel.r_offset = (sgot->output_section->vma
2356 + sgot->output_offset
2357 + off);
2358 outrel.r_info = ELF64_R_INFO (0, R_SPARC_RELATIVE);
2359 outrel.r_addend = relocation;
2360 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
2361 (((Elf64_External_Rela *)
2362 srelgot->contents)
2363 + srelgot->reloc_count));
2364 ++srelgot->reloc_count;
2365 }
2366 }
2367 relocation = sgot->output_offset + off - got_base;
2368 }
2369 goto do_default;
2370
2371 case R_SPARC_WPLT30:
2372 case R_SPARC_PLT32:
2373 case R_SPARC_HIPLT22:
2374 case R_SPARC_LOPLT10:
2375 case R_SPARC_PCPLT32:
2376 case R_SPARC_PCPLT22:
2377 case R_SPARC_PCPLT10:
2378 case R_SPARC_PLT64:
2379 /* Relocation is to the entry for this symbol in the
2380 procedure linkage table. */
2381 BFD_ASSERT (h != NULL);
2382
2383 if (h->plt.offset == (bfd_vma) -1)
2384 {
2385 /* We didn't make a PLT entry for this symbol. This
2386 happens when statically linking PIC code, or when
2387 using -Bsymbolic. */
2388 goto do_default;
2389 }
2390
2391 if (splt == NULL)
2392 {
2393 splt = bfd_get_section_by_name (dynobj, ".plt");
2394 BFD_ASSERT (splt != NULL);
2395 }
2396
2397 relocation = (splt->output_section->vma
2398 + splt->output_offset
2399 + sparc64_elf_plt_entry_offset (h->plt.offset));
2400 goto do_default;
2401
2402 case R_SPARC_OLO10:
2403 {
2404 bfd_vma x;
2405
2406 relocation += rel->r_addend;
2407 relocation = (relocation & 0x3ff) + ELF64_R_TYPE_DATA (rel->r_info);
2408
2409 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2410 x = (x & ~0x1fff) | (relocation & 0x1fff);
2411 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2412
2413 r = bfd_check_overflow (howto->complain_on_overflow,
2414 howto->bitsize, howto->rightshift,
2415 bfd_arch_bits_per_address (input_bfd),
2416 relocation);
2417 }
2418 break;
2419
2420 case R_SPARC_WDISP16:
2421 {
2422 bfd_vma x;
2423
2424 relocation += rel->r_addend;
2425 /* Adjust for pc-relative-ness. */
2426 relocation -= (input_section->output_section->vma
2427 + input_section->output_offset);
2428 relocation -= rel->r_offset;
2429
2430 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2431 x = (x & ~0x303fff) | ((((relocation >> 2) & 0xc000) << 6)
2432 | ((relocation >> 2) & 0x3fff));
2433 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2434
2435 r = bfd_check_overflow (howto->complain_on_overflow,
2436 howto->bitsize, howto->rightshift,
2437 bfd_arch_bits_per_address (input_bfd),
2438 relocation);
2439 }
2440 break;
2441
2442 case R_SPARC_HIX22:
2443 {
2444 bfd_vma x;
2445
2446 relocation += rel->r_addend;
2447 relocation = relocation ^ MINUS_ONE;
2448
2449 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2450 x = (x & ~0x3fffff) | ((relocation >> 10) & 0x3fffff);
2451 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2452
2453 r = bfd_check_overflow (howto->complain_on_overflow,
2454 howto->bitsize, howto->rightshift,
2455 bfd_arch_bits_per_address (input_bfd),
2456 relocation);
2457 }
2458 break;
2459
2460 case R_SPARC_LOX10:
2461 {
2462 bfd_vma x;
2463
2464 relocation += rel->r_addend;
2465 relocation = (relocation & 0x3ff) | 0x1c00;
2466
2467 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2468 x = (x & ~0x1fff) | relocation;
2469 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2470
2471 r = bfd_reloc_ok;
2472 }
2473 break;
2474
2475 default:
2476 do_default:
2477 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2478 contents, rel->r_offset,
2479 relocation, rel->r_addend);
2480 break;
2481 }
2482
2483 switch (r)
2484 {
2485 case bfd_reloc_ok:
2486 break;
2487
2488 default:
2489 case bfd_reloc_outofrange:
2490 abort ();
2491
2492 case bfd_reloc_overflow:
2493 {
2494 const char *name;
2495
2496 if (h != NULL)
2497 {
2498 if (h->root.type == bfd_link_hash_undefweak
2499 && howto->pc_relative)
2500 {
2501 /* Assume this is a call protected by other code that
2502 detect the symbol is undefined. If this is the case,
2503 we can safely ignore the overflow. If not, the
2504 program is hosed anyway, and a little warning isn't
2505 going to help. */
2506 break;
2507 }
2508
2509 name = h->root.root.string;
2510 }
2511 else
2512 {
2513 name = (bfd_elf_string_from_elf_section
2514 (input_bfd,
2515 symtab_hdr->sh_link,
2516 sym->st_name));
2517 if (name == NULL)
2518 return false;
2519 if (*name == '\0')
2520 name = bfd_section_name (input_bfd, sec);
2521 }
2522 if (! ((*info->callbacks->reloc_overflow)
2523 (info, name, howto->name, (bfd_vma) 0,
2524 input_bfd, input_section, rel->r_offset)))
2525 return false;
2526 }
2527 break;
2528 }
2529 }
2530
2531 return true;
2532}
2533
2534/* Finish up dynamic symbol handling. We set the contents of various
2535 dynamic sections here. */
2536
2537static boolean
2538sparc64_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
2539 bfd *output_bfd;
2540 struct bfd_link_info *info;
2541 struct elf_link_hash_entry *h;
2542 Elf_Internal_Sym *sym;
2543{
2544 bfd *dynobj;
2545
2546 dynobj = elf_hash_table (info)->dynobj;
2547
2548 if (h->plt.offset != (bfd_vma) -1)
2549 {
2550 asection *splt;
2551 asection *srela;
2552 Elf_Internal_Rela rela;
2553
2554 /* This symbol has an entry in the PLT. Set it up. */
2555
2556 BFD_ASSERT (h->dynindx != -1);
2557
2558 splt = bfd_get_section_by_name (dynobj, ".plt");
2559 srela = bfd_get_section_by_name (dynobj, ".rela.plt");
2560 BFD_ASSERT (splt != NULL && srela != NULL);
2561
2562 /* Fill in the entry in the .rela.plt section. */
2563
2564 if (h->plt.offset < LARGE_PLT_THRESHOLD)
2565 {
2566 rela.r_offset = sparc64_elf_plt_entry_offset (h->plt.offset);
2567 rela.r_addend = 0;
2568 }
2569 else
2570 {
2571 int max = splt->_raw_size / PLT_ENTRY_SIZE;
2572 rela.r_offset = sparc64_elf_plt_ptr_offset (h->plt.offset, max);
a11c78e7
RH		 2573 rela.r_addend = -(sparc64_elf_plt_entry_offset (h->plt.offset) + 4)
2574 -(splt->output_section->vma + splt->output_offset);
252b5132
RH		 2575 }
2576 rela.r_offset += (splt->output_section->vma + splt->output_offset);
2577 rela.r_info = ELF64_R_INFO (h->dynindx, R_SPARC_JMP_SLOT);
2578
2579 bfd_elf64_swap_reloca_out (output_bfd, &rela,
2580 ((Elf64_External_Rela *) srela->contents
2581 + h->plt.offset));
2582
2583 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2584 {
2585 /* Mark the symbol as undefined, rather than as defined in
2586 the .plt section. Leave the value alone. */
2587 sym->st_shndx = SHN_UNDEF;
2588 }
2589 }
2590
2591 if (h->got.offset != (bfd_vma) -1)
2592 {
2593 asection *sgot;
2594 asection *srela;
2595 Elf_Internal_Rela rela;
2596
2597 /* This symbol has an entry in the GOT. Set it up. */
2598
2599 sgot = bfd_get_section_by_name (dynobj, ".got");
2600 srela = bfd_get_section_by_name (dynobj, ".rela.got");
2601 BFD_ASSERT (sgot != NULL && srela != NULL);
2602
2603 rela.r_offset = (sgot->output_section->vma
2604 + sgot->output_offset
2605 + (h->got.offset &~ 1));
2606
2607 /* If this is a -Bsymbolic link, and the symbol is defined
2608 locally, we just want to emit a RELATIVE reloc. Likewise if
2609 the symbol was forced to be local because of a version file.
2610 The entry in the global offset table will already have been
2611 initialized in the relocate_section function. */
2612 if (info->shared
2613 && (info->symbolic || h->dynindx == -1)
2614 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
2615 {
2616 asection *sec = h->root.u.def.section;
2617 rela.r_info = ELF64_R_INFO (0, R_SPARC_RELATIVE);
2618 rela.r_addend = (h->root.u.def.value
2619 + sec->output_section->vma
2620 + sec->output_offset);
2621 }
2622 else
2623 {
2624 bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
2625 rela.r_info = ELF64_R_INFO (h->dynindx, R_SPARC_GLOB_DAT);
2626 rela.r_addend = 0;
2627 }
2628
2629 bfd_elf64_swap_reloca_out (output_bfd, &rela,
2630 ((Elf64_External_Rela *) srela->contents
2631 + srela->reloc_count));
2632 ++srela->reloc_count;
2633 }
2634
2635 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
2636 {
2637 asection *s;
2638 Elf_Internal_Rela rela;
2639
2640 /* This symbols needs a copy reloc. Set it up. */
2641
2642 BFD_ASSERT (h->dynindx != -1);
2643
2644 s = bfd_get_section_by_name (h->root.u.def.section->owner,
2645 ".rela.bss");
2646 BFD_ASSERT (s != NULL);
2647
2648 rela.r_offset = (h->root.u.def.value
2649 + h->root.u.def.section->output_section->vma
2650 + h->root.u.def.section->output_offset);
2651 rela.r_info = ELF64_R_INFO (h->dynindx, R_SPARC_COPY);
2652 rela.r_addend = 0;
2653 bfd_elf64_swap_reloca_out (output_bfd, &rela,
2654 ((Elf64_External_Rela *) s->contents
2655 + s->reloc_count));
2656 ++s->reloc_count;
2657 }
2658
2659 /* Mark some specially defined symbols as absolute. */
2660 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2661 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
2662 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
2663 sym->st_shndx = SHN_ABS;
2664
2665 return true;
2666}
2667
2668/* Finish up the dynamic sections. */
2669
2670static boolean
2671sparc64_elf_finish_dynamic_sections (output_bfd, info)
2672 bfd *output_bfd;
2673 struct bfd_link_info *info;
2674{
2675 bfd *dynobj;
587ff49e 2676 int stt_regidx = -1;
252b5132
RH		 2677 asection *sdyn;
2678 asection *sgot;
2679
2680 dynobj = elf_hash_table (info)->dynobj;
2681
2682 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2683
2684 if (elf_hash_table (info)->dynamic_sections_created)
2685 {
2686 asection *splt;
2687 Elf64_External_Dyn *dyncon, *dynconend;
2688
2689 splt = bfd_get_section_by_name (dynobj, ".plt");
2690 BFD_ASSERT (splt != NULL && sdyn != NULL);
2691
2692 dyncon = (Elf64_External_Dyn *) sdyn->contents;
2693 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
2694 for (; dyncon < dynconend; dyncon++)
2695 {
2696 Elf_Internal_Dyn dyn;
2697 const char *name;
2698 boolean size;
2699
2700 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
2701
2702 switch (dyn.d_tag)
2703 {
2704 case DT_PLTGOT: name = ".plt"; size = false; break;
2705 case DT_PLTRELSZ: name = ".rela.plt"; size = true; break;
2706 case DT_JMPREL: name = ".rela.plt"; size = false; break;
587ff49e
RH		 2707 case DT_SPARC_REGISTER:
2708 if (stt_regidx == -1)
2709 {
2710 stt_regidx =
2711 _bfd_elf_link_lookup_local_dynindx (info, output_bfd, -1);
2712 if (stt_regidx == -1)
2713 return false;
2714 }
2715 dyn.d_un.d_val = stt_regidx++;
2716 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2717 /* fallthrough */
252b5132
RH		 2718 default: name = NULL; size = false; break;
2719 }
2720
2721 if (name != NULL)
2722 {
2723 asection *s;
2724
2725 s = bfd_get_section_by_name (output_bfd, name);
2726 if (s == NULL)
2727 dyn.d_un.d_val = 0;
2728 else
2729 {
2730 if (! size)
2731 dyn.d_un.d_ptr = s->vma;
2732 else
2733 {
2734 if (s->_cooked_size != 0)
2735 dyn.d_un.d_val = s->_cooked_size;
2736 else
2737 dyn.d_un.d_val = s->_raw_size;
2738 }
2739 }
2740 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2741 }
2742 }
2743
2744 /* Initialize the contents of the .plt section. */
2745 if (splt->_raw_size > 0)
2746 {
2747 sparc64_elf_build_plt(output_bfd, splt->contents,
2748 splt->_raw_size / PLT_ENTRY_SIZE);
2749 }
2750
2751 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
2752 PLT_ENTRY_SIZE;
2753 }
2754
2755 /* Set the first entry in the global offset table to the address of
2756 the dynamic section. */
2757 sgot = bfd_get_section_by_name (dynobj, ".got");
2758 BFD_ASSERT (sgot != NULL);
2759 if (sgot->_raw_size > 0)
2760 {
2761 if (sdyn == NULL)
2762 bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents);
2763 else
2764 bfd_put_64 (output_bfd,
2765 sdyn->output_section->vma + sdyn->output_offset,
2766 sgot->contents);
2767 }
2768
2769 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 8;
2770
252b5132
RH		 2771 return true;
2772}
2773\f
2774/* Functions for dealing with the e_flags field. */
2775
2776/* Merge backend specific data from an object file to the output
2777 object file when linking. */
2778
2779static boolean
2780sparc64_elf_merge_private_bfd_data (ibfd, obfd)
2781 bfd *ibfd;
2782 bfd *obfd;
2783{
2784 boolean error;
2785 flagword new_flags, old_flags;
2786 int new_mm, old_mm;
2787
2788 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2789 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2790 return true;
2791
2792 new_flags = elf_elfheader (ibfd)->e_flags;
2793 old_flags = elf_elfheader (obfd)->e_flags;
2794
2795 if (!elf_flags_init (obfd)) /* First call, no flags set */
2796 {
2797 elf_flags_init (obfd) = true;
2798 elf_elfheader (obfd)->e_flags = new_flags;
2799 }
2800
2801 else if (new_flags == old_flags) /* Compatible flags are ok */
2802 ;
2803
2804 else /* Incompatible flags */
2805 {
2806 error = false;
2807
2808 old_flags |= (new_flags & (EF_SPARC_SUN_US1|EF_SPARC_HAL_R1));
2809 new_flags |= (old_flags & (EF_SPARC_SUN_US1|EF_SPARC_HAL_R1));
2810 if ((old_flags & (EF_SPARC_SUN_US1|EF_SPARC_HAL_R1)) ==
2811 (EF_SPARC_SUN_US1|EF_SPARC_HAL_R1))
2812 {
2813 error = true;
2814 (*_bfd_error_handler)
2815 (_("%s: linking UltraSPARC specific with HAL specific code"),
2816 bfd_get_filename (ibfd));
2817 }
2818
2819 /* Choose the most restrictive memory ordering */
2820 old_mm = (old_flags & EF_SPARCV9_MM);
2821 new_mm = (new_flags & EF_SPARCV9_MM);
2822 old_flags &= ~EF_SPARCV9_MM;
2823 new_flags &= ~EF_SPARCV9_MM;
2824 if (new_mm < old_mm) old_mm = new_mm;
2825 old_flags |= old_mm;
2826 new_flags |= old_mm;
2827
2828 /* Warn about any other mismatches */
2829 if (new_flags != old_flags)
2830 {
2831 error = true;
2832 (*_bfd_error_handler)
2833 (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
2834 bfd_get_filename (ibfd), (long)new_flags, (long)old_flags);
2835 }
2836
2837 elf_elfheader (obfd)->e_flags = old_flags;
2838
2839 if (error)
2840 {
2841 bfd_set_error (bfd_error_bad_value);
2842 return false;
2843 }
2844 }
2845 return true;
2846}
587ff49e
RH		 2847\f
2848/* Print a STT_REGISTER symbol to file FILE. */
252b5132 2849
587ff49e
RH		 2850static const char *
2851sparc64_elf_print_symbol_all (abfd, filep, symbol)
2852 bfd *abfd;
2853 PTR filep;
2854 asymbol *symbol;
2855{
2856 FILE *file = (FILE *) filep;
2857 int reg, type;
2858
2859 if (ELF_ST_TYPE (((elf_symbol_type *) symbol)->internal_elf_sym.st_info)
2860 != STT_REGISTER)
2861 return NULL;
2862
2863 reg = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value;
2864 type = symbol->flags;
2865 fprintf (file, "REG_%c%c%11s%c%c R", "GOLI" [reg / 8], '0' + (reg & 7), "",
2866 ((type & BSF_LOCAL)
2867 ? (type & BSF_GLOBAL) ? '!' : 'l'
2868 : (type & BSF_GLOBAL) ? 'g' : ' '),
2869 (type & BSF_WEAK) ? 'w' : ' ');
2870 if (symbol->name == NULL || symbol->name [0] == '\0')
2871 return "#scratch";
2872 else
2873 return symbol->name;
2874}
252b5132
RH		 2875\f
2876/* Set the right machine number for a SPARC64 ELF file. */
2877
2878static boolean
2879sparc64_elf_object_p (abfd)
2880 bfd *abfd;
2881{
2882 unsigned long mach = bfd_mach_sparc_v9;
2883
2884 if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
2885 mach = bfd_mach_sparc_v9a;
2886 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, mach);
2887}
2888
f65054f7
RH		 2889/* Relocations in the 64 bit SPARC ELF ABI are more complex than in
2890 standard ELF, because R_SPARC_OLO10 has secondary addend in
2891 ELF64_R_TYPE_DATA field. This structure is used to redirect the
2892 relocation handling routines. */
2893
2894const struct elf_size_info sparc64_elf_size_info =
2895{
2896 sizeof (Elf64_External_Ehdr),
2897 sizeof (Elf64_External_Phdr),
2898 sizeof (Elf64_External_Shdr),
2899 sizeof (Elf64_External_Rel),
2900 sizeof (Elf64_External_Rela),
2901 sizeof (Elf64_External_Sym),
2902 sizeof (Elf64_External_Dyn),
2903 sizeof (Elf_External_Note),
a11c78e7 2904 4, /* hash-table entry size */
f65054f7
RH		 2905 /* internal relocations per external relocations.
2906 For link purposes we use just 1 internal per
2907 1 external, for assembly and slurp symbol table
2908 we use 2. */
2909 1,
2910 64, /* arch_size */
2911 8, /* file_align */
2912 ELFCLASS64,
2913 EV_CURRENT,
2914 bfd_elf64_write_out_phdrs,
2915 bfd_elf64_write_shdrs_and_ehdr,
2916 sparc64_elf_write_relocs,
2917 bfd_elf64_swap_symbol_out,
2918 sparc64_elf_slurp_reloc_table,
2919 bfd_elf64_slurp_symbol_table,
2920 bfd_elf64_swap_dyn_in,
2921 bfd_elf64_swap_dyn_out,
2922 NULL,
2923 NULL,
2924 NULL,
2925 NULL
2926};
2927
252b5132
RH		 2928#define TARGET_BIG_SYM bfd_elf64_sparc_vec
2929#define TARGET_BIG_NAME "elf64-sparc"
2930#define ELF_ARCH bfd_arch_sparc
2931#define ELF_MAXPAGESIZE 0x100000
2932
2933/* This is the official ABI value. */
2934#define ELF_MACHINE_CODE EM_SPARCV9
2935
2936/* This is the value that we used before the ABI was released. */
2937#define ELF_MACHINE_ALT1 EM_OLD_SPARCV9
2938
587ff49e
RH		 2939#define bfd_elf64_bfd_link_hash_table_create \
2940 sparc64_elf_bfd_link_hash_table_create
2941
252b5132
RH		 2942#define elf_info_to_howto \
2943 sparc64_elf_info_to_howto
f65054f7
RH		 2944#define bfd_elf64_get_reloc_upper_bound \
2945 sparc64_elf_get_reloc_upper_bound
2946#define bfd_elf64_get_dynamic_reloc_upper_bound \
2947 sparc64_elf_get_dynamic_reloc_upper_bound
2948#define bfd_elf64_canonicalize_dynamic_reloc \
2949 sparc64_elf_canonicalize_dynamic_reloc
252b5132
RH		 2950#define bfd_elf64_bfd_reloc_type_lookup \
2951 sparc64_elf_reloc_type_lookup
2952
2953#define elf_backend_create_dynamic_sections \
2954 _bfd_elf_create_dynamic_sections
587ff49e
RH		 2955#define elf_backend_add_symbol_hook \
2956 sparc64_elf_add_symbol_hook
2957#define elf_backend_get_symbol_type \
2958 sparc64_elf_get_symbol_type
2959#define elf_backend_symbol_processing \
2960 sparc64_elf_symbol_processing
252b5132
RH		 2961#define elf_backend_check_relocs \
2962 sparc64_elf_check_relocs
2963#define elf_backend_adjust_dynamic_symbol \
2964 sparc64_elf_adjust_dynamic_symbol
2965#define elf_backend_size_dynamic_sections \
2966 sparc64_elf_size_dynamic_sections
2967#define elf_backend_relocate_section \
2968 sparc64_elf_relocate_section
2969#define elf_backend_finish_dynamic_symbol \
2970 sparc64_elf_finish_dynamic_symbol
2971#define elf_backend_finish_dynamic_sections \
2972 sparc64_elf_finish_dynamic_sections
587ff49e
RH		 2973#define elf_backend_print_symbol_all \
2974 sparc64_elf_print_symbol_all
2975#define elf_backend_output_arch_syms \
2976 sparc64_elf_output_arch_syms
252b5132
RH		 2977
2978#define bfd_elf64_bfd_merge_private_bfd_data \
2979 sparc64_elf_merge_private_bfd_data
2980
f65054f7
RH		 2981#define elf_backend_size_info \
2982 sparc64_elf_size_info
252b5132
RH		 2983#define elf_backend_object_p \
2984 sparc64_elf_object_p
2985
2986#define elf_backend_want_got_plt 0
2987#define elf_backend_plt_readonly 0
2988#define elf_backend_want_plt_sym 1
2989
2990/* Section 5.2.4 of the ABI specifies a 256-byte boundary for the table. */
2991#define elf_backend_plt_alignment 8
2992
2993#define elf_backend_got_header_size 8
2994#define elf_backend_plt_header_size PLT_HEADER_SIZE
2995
2996#include "elf64-target.h"
GDB Binutils - Deliverables
This page took 0.139891 seconds and 4 git commands to generate.