?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
°
[binutils.git] / bfd / elf64-sparc.c
blobdef6bce6762f5f5f73e787b9d7034420be95e909
1 /* SPARC-specific support for 64-bit ELF
2 Copyright (C) 1993, 95, 96, 97, 98, 1999 Free Software Foundation, Inc.
3
4 This file is part of BFD, the Binary File Descriptor library.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, 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
35 static reloc_howto_type *sparc64_elf_reloc_type_lookup
36 PARAMS ((bfd *, bfd_reloc_code_real_type));
37 static void sparc64_elf_info_to_howto
38 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
39
40 static void sparc64_elf_build_plt
41 PARAMS((bfd *, unsigned char *, int));
42 static bfd_vma sparc64_elf_plt_entry_offset
43 PARAMS((int));
44 static bfd_vma sparc64_elf_plt_ptr_offset
45 PARAMS((int, int));
46
47 static boolean sparc64_elf_check_relocs
48 PARAMS((bfd *, struct bfd_link_info *, asection *sec,
49 const Elf_Internal_Rela *));
50 static boolean sparc64_elf_adjust_dynamic_symbol
51 PARAMS((struct bfd_link_info *, struct elf_link_hash_entry *));
52 static boolean sparc64_elf_size_dynamic_sections
53 PARAMS((bfd *, struct bfd_link_info *));
54 static boolean sparc64_elf_adjust_dynindx
55 PARAMS((struct elf_link_hash_entry *, PTR));
56
57 static boolean sparc64_elf_merge_private_bfd_data
58 PARAMS ((bfd *, bfd *));
59
60 static boolean sparc64_elf_relocate_section
61 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
62 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
63 static boolean sparc64_elf_object_p PARAMS ((bfd *));
64 \f
65 /* The relocation "howto" table. */
66
67 static bfd_reloc_status_type sparc_elf_notsup_reloc
68 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
69 static bfd_reloc_status_type sparc_elf_wdisp16_reloc
70 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
71 static bfd_reloc_status_type sparc_elf_hix22_reloc
72 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
73 static bfd_reloc_status_type sparc_elf_lox10_reloc
74 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
75
76 static reloc_howto_type sparc64_elf_howto_table[] =
77 {
78 HOWTO(R_SPARC_NONE, 0,0, 0,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", false,0,0x00000000,true),
79 HOWTO(R_SPARC_8, 0,0, 8,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_8", false,0,0x000000ff,true),
80 HOWTO(R_SPARC_16, 0,1,16,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_16", false,0,0x0000ffff,true),
81 HOWTO(R_SPARC_32, 0,2,32,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_32", false,0,0xffffffff,true),
82 HOWTO(R_SPARC_DISP8, 0,0, 8,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP8", false,0,0x000000ff,true),
83 HOWTO(R_SPARC_DISP16, 0,1,16,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP16", false,0,0x0000ffff,true),
84 HOWTO(R_SPARC_DISP32, 0,2,32,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP32", false,0,0x00ffffff,true),
85 HOWTO(R_SPARC_WDISP30, 2,2,30,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP30", false,0,0x3fffffff,true),
86 HOWTO(R_SPARC_WDISP22, 2,2,22,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP22", false,0,0x003fffff,true),
87 HOWTO(R_SPARC_HI22, 10,2,22,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_HI22", false,0,0x003fffff,true),
88 HOWTO(R_SPARC_22, 0,2,22,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_22", false,0,0x003fffff,true),
89 HOWTO(R_SPARC_13, 0,2,13,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_13", false,0,0x00001fff,true),
90 HOWTO(R_SPARC_LO10, 0,2,10,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_LO10", false,0,0x000003ff,true),
91 HOWTO(R_SPARC_GOT10, 0,2,10,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOT10", false,0,0x000003ff,true),
92 HOWTO(R_SPARC_GOT13, 0,2,13,false,0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_GOT13", false,0,0x00001fff,true),
93 HOWTO(R_SPARC_GOT22, 10,2,22,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOT22", false,0,0x003fffff,true),
94 HOWTO(R_SPARC_PC10, 0,2,10,true, 0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_PC10", false,0,0x000003ff,true),
95 HOWTO(R_SPARC_PC22, 10,2,22,true, 0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_PC22", false,0,0x003fffff,true),
96 HOWTO(R_SPARC_WPLT30, 2,2,30,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WPLT30", false,0,0x3fffffff,true),
97 HOWTO(R_SPARC_COPY, 0,0,00,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_COPY", false,0,0x00000000,true),
98 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),
99 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),
100 HOWTO(R_SPARC_RELATIVE, 0,0,00,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_RELATIVE",false,0,0x00000000,true),
101 HOWTO(R_SPARC_UA32, 0,0,00,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_UA32", false,0,0x00000000,true),
102 #ifndef SPARC64_OLD_RELOCS
103 /* These aren't implemented yet. */
104 HOWTO(R_SPARC_PLT32, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PLT32", false,0,0x00000000,true),
105 HOWTO(R_SPARC_HIPLT22, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_HIPLT22", false,0,0x00000000,true),
106 HOWTO(R_SPARC_LOPLT10, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_LOPLT10", false,0,0x00000000,true),
107 HOWTO(R_SPARC_PCPLT32, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PCPLT32", false,0,0x00000000,true),
108 HOWTO(R_SPARC_PCPLT22, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PCPLT22", false,0,0x00000000,true),
109 HOWTO(R_SPARC_PCPLT10, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PCPLT10", false,0,0x00000000,true),
110 #endif
111 HOWTO(R_SPARC_10, 0,2,10,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_10", false,0,0x000003ff,true),
112 HOWTO(R_SPARC_11, 0,2,11,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_11", false,0,0x000007ff,true),
113 HOWTO(R_SPARC_64, 0,4,64,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_64", false,0,MINUS_ONE, true),
114 HOWTO(R_SPARC_OLO10, 0,2,13,false,0,complain_overflow_signed, sparc_elf_notsup_reloc, "R_SPARC_OLO10", false,0,0x00001fff,true),
115 HOWTO(R_SPARC_HH22, 42,2,22,false,0,complain_overflow_unsigned,bfd_elf_generic_reloc, "R_SPARC_HH22", false,0,0x003fffff,true),
116 HOWTO(R_SPARC_HM10, 32,2,10,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_HM10", false,0,0x000003ff,true),
117 HOWTO(R_SPARC_LM22, 10,2,22,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_LM22", false,0,0x003fffff,true),
118 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),
119 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),
120 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),
121 HOWTO(R_SPARC_WDISP16, 2,2,16,true, 0,complain_overflow_signed, sparc_elf_wdisp16_reloc,"R_SPARC_WDISP16", false,0,0x00000000,true),
122 HOWTO(R_SPARC_WDISP19, 2,2,19,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP19", false,0,0x0007ffff,true),
123 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),
124 HOWTO(R_SPARC_7, 0,2, 7,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_7", false,0,0x0000007f,true),
125 HOWTO(R_SPARC_5, 0,2, 5,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_5", false,0,0x0000001f,true),
126 HOWTO(R_SPARC_6, 0,2, 6,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_6", false,0,0x0000003f,true),
127 HOWTO(R_SPARC_DISP64, 0,4,64,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP64", false,0,MINUS_ONE, true),
128 HOWTO(R_SPARC_PLT64, 0,4,64,false,0,complain_overflow_bitfield,sparc_elf_notsup_reloc, "R_SPARC_PLT64", false,0,MINUS_ONE, false),
129 HOWTO(R_SPARC_HIX22, 0,4, 0,false,0,complain_overflow_bitfield,sparc_elf_hix22_reloc, "R_SPARC_HIX22", false,0,MINUS_ONE, false),
130 HOWTO(R_SPARC_LOX10, 0,4, 0,false,0,complain_overflow_dont, sparc_elf_lox10_reloc, "R_SPARC_LOX10", false,0,MINUS_ONE, false),
131 HOWTO(R_SPARC_H44, 22,2,22,false,0,complain_overflow_unsigned,bfd_elf_generic_reloc, "R_SPARC_H44", false,0,0x003fffff,false),
132 HOWTO(R_SPARC_M44, 12,2,10,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_M44", false,0,0x000003ff,false),
133 HOWTO(R_SPARC_L44, 0,2,13,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_L44", false,0,0x00000fff,false),
134 HOWTO(R_SPARC_REGISTER, 0,4, 0,false,0,complain_overflow_bitfield,sparc_elf_notsup_reloc, "R_SPARC_REGISTER",false,0,MINUS_ONE, false),
135 HOWTO(R_SPARC_UA64, 0,4,64,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA64", false,0,MINUS_ONE, true),
136 HOWTO(R_SPARC_UA16, 0,1,16,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA16", false,0,0x0000ffff,true)
137 };
138
139 struct elf_reloc_map {
140 bfd_reloc_code_real_type bfd_reloc_val;
141 unsigned char elf_reloc_val;
142 };
143
144 static CONST struct elf_reloc_map sparc_reloc_map[] =
145 {
146 { BFD_RELOC_NONE, R_SPARC_NONE, },
147 { BFD_RELOC_16, R_SPARC_16, },
148 { BFD_RELOC_8, R_SPARC_8 },
149 { BFD_RELOC_8_PCREL, R_SPARC_DISP8 },
150 { BFD_RELOC_CTOR, R_SPARC_64 },
151 { BFD_RELOC_32, R_SPARC_32 },
152 { BFD_RELOC_32_PCREL, R_SPARC_DISP32 },
153 { BFD_RELOC_HI22, R_SPARC_HI22 },
154 { BFD_RELOC_LO10, R_SPARC_LO10, },
155 { BFD_RELOC_32_PCREL_S2, R_SPARC_WDISP30 },
156 { BFD_RELOC_SPARC22, R_SPARC_22 },
157 { BFD_RELOC_SPARC13, R_SPARC_13 },
158 { BFD_RELOC_SPARC_GOT10, R_SPARC_GOT10 },
159 { BFD_RELOC_SPARC_GOT13, R_SPARC_GOT13 },
160 { BFD_RELOC_SPARC_GOT22, R_SPARC_GOT22 },
161 { BFD_RELOC_SPARC_PC10, R_SPARC_PC10 },
162 { BFD_RELOC_SPARC_PC22, R_SPARC_PC22 },
163 { BFD_RELOC_SPARC_WPLT30, R_SPARC_WPLT30 },
164 { BFD_RELOC_SPARC_COPY, R_SPARC_COPY },
165 { BFD_RELOC_SPARC_GLOB_DAT, R_SPARC_GLOB_DAT },
166 { BFD_RELOC_SPARC_JMP_SLOT, R_SPARC_JMP_SLOT },
167 { BFD_RELOC_SPARC_RELATIVE, R_SPARC_RELATIVE },
168 { BFD_RELOC_SPARC_WDISP22, R_SPARC_WDISP22 },
169 /* ??? Doesn't dwarf use this? */
170 /*{ BFD_RELOC_SPARC_UA32, R_SPARC_UA32 }, not used?? */
171 {BFD_RELOC_SPARC_10, R_SPARC_10},
172 {BFD_RELOC_SPARC_11, R_SPARC_11},
173 {BFD_RELOC_SPARC_64, R_SPARC_64},
174 {BFD_RELOC_SPARC_OLO10, R_SPARC_OLO10},
175 {BFD_RELOC_SPARC_HH22, R_SPARC_HH22},
176 {BFD_RELOC_SPARC_HM10, R_SPARC_HM10},
177 {BFD_RELOC_SPARC_LM22, R_SPARC_LM22},
178 {BFD_RELOC_SPARC_PC_HH22, R_SPARC_PC_HH22},
179 {BFD_RELOC_SPARC_PC_HM10, R_SPARC_PC_HM10},
180 {BFD_RELOC_SPARC_PC_LM22, R_SPARC_PC_LM22},
181 {BFD_RELOC_SPARC_WDISP16, R_SPARC_WDISP16},
182 {BFD_RELOC_SPARC_WDISP19, R_SPARC_WDISP19},
183 {BFD_RELOC_SPARC_7, R_SPARC_7},
184 {BFD_RELOC_SPARC_5, R_SPARC_5},
185 {BFD_RELOC_SPARC_6, R_SPARC_6},
186 {BFD_RELOC_SPARC_DISP64, R_SPARC_DISP64},
187 {BFD_RELOC_SPARC_PLT64, R_SPARC_PLT64},
188 {BFD_RELOC_SPARC_HIX22, R_SPARC_HIX22},
189 {BFD_RELOC_SPARC_LOX10, R_SPARC_LOX10},
190 {BFD_RELOC_SPARC_H44, R_SPARC_H44},
191 {BFD_RELOC_SPARC_M44, R_SPARC_M44},
192 {BFD_RELOC_SPARC_L44, R_SPARC_L44},
193 {BFD_RELOC_SPARC_REGISTER, R_SPARC_REGISTER}
194 };
195
196 static reloc_howto_type *
197 sparc64_elf_reloc_type_lookup (abfd, code)
198 bfd *abfd;
199 bfd_reloc_code_real_type code;
200 {
201 unsigned int i;
202 for (i = 0; i < sizeof (sparc_reloc_map) / sizeof (struct elf_reloc_map); i++)
203 {
204 if (sparc_reloc_map[i].bfd_reloc_val == code)
205 return &sparc64_elf_howto_table[(int) sparc_reloc_map[i].elf_reloc_val];
206 }
207 return 0;
208 }
209
210 static void
211 sparc64_elf_info_to_howto (abfd, cache_ptr, dst)
212 bfd *abfd;
213 arelent *cache_ptr;
214 Elf64_Internal_Rela *dst;
215 {
216 BFD_ASSERT (ELF64_R_TYPE (dst->r_info) < (unsigned int) R_SPARC_max_std);
217 cache_ptr->howto = &sparc64_elf_howto_table[ELF64_R_TYPE (dst->r_info)];
218 }
219 \f
220 /* Utility for performing the standard initial work of an instruction
221 relocation.
222 *PRELOCATION will contain the relocated item.
223 *PINSN will contain the instruction from the input stream.
224 If the result is `bfd_reloc_other' the caller can continue with
225 performing the relocation. Otherwise it must stop and return the
226 value to its caller. */
227
228 static bfd_reloc_status_type
229 init_insn_reloc (abfd,
230 reloc_entry,
231 symbol,
232 data,
233 input_section,
234 output_bfd,
235 prelocation,
236 pinsn)
237 bfd *abfd;
238 arelent *reloc_entry;
239 asymbol *symbol;
240 PTR data;
241 asection *input_section;
242 bfd *output_bfd;
243 bfd_vma *prelocation;
244 bfd_vma *pinsn;
245 {
246 bfd_vma relocation;
247 reloc_howto_type *howto = reloc_entry->howto;
248
249 if (output_bfd != (bfd *) NULL
250 && (symbol->flags & BSF_SECTION_SYM) == 0
251 && (! howto->partial_inplace
252 || reloc_entry->addend == 0))
253 {
254 reloc_entry->address += input_section->output_offset;
255 return bfd_reloc_ok;
256 }
257
258 /* This works because partial_inplace == false. */
259 if (output_bfd != NULL)
260 return bfd_reloc_continue;
261
262 if (reloc_entry->address > input_section->_cooked_size)
263 return bfd_reloc_outofrange;
264
265 relocation = (symbol->value
266 + symbol->section->output_section->vma
267 + symbol->section->output_offset);
268 relocation += reloc_entry->addend;
269 if (howto->pc_relative)
270 {
271 relocation -= (input_section->output_section->vma
272 + input_section->output_offset);
273 relocation -= reloc_entry->address;
274 }
275
276 *prelocation = relocation;
277 *pinsn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
278 return bfd_reloc_other;
279 }
280
281 /* For unsupported relocs. */
282
283 static bfd_reloc_status_type
284 sparc_elf_notsup_reloc (abfd,
285 reloc_entry,
286 symbol,
287 data,
288 input_section,
289 output_bfd,
290 error_message)
291 bfd *abfd;
292 arelent *reloc_entry;
293 asymbol *symbol;
294 PTR data;
295 asection *input_section;
296 bfd *output_bfd;
297 char **error_message;
298 {
299 return bfd_reloc_notsupported;
300 }
301
302 /* Handle the WDISP16 reloc. */
303
304 static bfd_reloc_status_type
305 sparc_elf_wdisp16_reloc (abfd, reloc_entry, symbol, data, input_section,
306 output_bfd, error_message)
307 bfd *abfd;
308 arelent *reloc_entry;
309 asymbol *symbol;
310 PTR data;
311 asection *input_section;
312 bfd *output_bfd;
313 char **error_message;
314 {
315 bfd_vma relocation;
316 bfd_vma insn;
317 bfd_reloc_status_type status;
318
319 status = init_insn_reloc (abfd, reloc_entry, symbol, data,
320 input_section, output_bfd, &relocation, &insn);
321 if (status != bfd_reloc_other)
322 return status;
323
324 insn = (insn & ~0x303fff) | ((((relocation >> 2) & 0xc000) << 6)
325 | ((relocation >> 2) & 0x3fff));
326 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
327
328 if ((bfd_signed_vma) relocation < - 0x40000
329 || (bfd_signed_vma) relocation > 0x3ffff)
330 return bfd_reloc_overflow;
331 else
332 return bfd_reloc_ok;
333 }
334
335 /* Handle the HIX22 reloc. */
336
337 static bfd_reloc_status_type
338 sparc_elf_hix22_reloc (abfd,
339 reloc_entry,
340 symbol,
341 data,
342 input_section,
343 output_bfd,
344 error_message)
345 bfd *abfd;
346 arelent *reloc_entry;
347 asymbol *symbol;
348 PTR data;
349 asection *input_section;
350 bfd *output_bfd;
351 char **error_message;
352 {
353 bfd_vma relocation;
354 bfd_vma insn;
355 bfd_reloc_status_type status;
356
357 status = init_insn_reloc (abfd, reloc_entry, symbol, data,
358 input_section, output_bfd, &relocation, &insn);
359 if (status != bfd_reloc_other)
360 return status;
361
362 relocation ^= MINUS_ONE;
363 insn = (insn & ~0x3fffff) | ((relocation >> 10) & 0x3fffff);
364 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
365
366 if ((relocation & ~ (bfd_vma) 0xffffffff) != 0)
367 return bfd_reloc_overflow;
368 else
369 return bfd_reloc_ok;
370 }
371
372 /* Handle the LOX10 reloc. */
373
374 static bfd_reloc_status_type
375 sparc_elf_lox10_reloc (abfd,
376 reloc_entry,
377 symbol,
378 data,
379 input_section,
380 output_bfd,
381 error_message)
382 bfd *abfd;
383 arelent *reloc_entry;
384 asymbol *symbol;
385 PTR data;
386 asection *input_section;
387 bfd *output_bfd;
388 char **error_message;
389 {
390 bfd_vma relocation;
391 bfd_vma insn;
392 bfd_reloc_status_type status;
393
394 status = init_insn_reloc (abfd, reloc_entry, symbol, data,
395 input_section, output_bfd, &relocation, &insn);
396 if (status != bfd_reloc_other)
397 return status;
398
399 insn = (insn & ~0x1fff) | 0x1c00 | (relocation & 0x3ff);
400 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
401
402 return bfd_reloc_ok;
403 }
404 \f
405 /* PLT/GOT stuff */
406
407 /* Both the headers and the entries are icache aligned. */
408 #define PLT_ENTRY_SIZE 32
409 #define PLT_HEADER_SIZE (4 * PLT_ENTRY_SIZE)
410 #define LARGE_PLT_THRESHOLD 32768
411 #define GOT_RESERVED_ENTRIES 1
412
413 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/sparcv9/ld.so.1"
414
415
416 /* Fill in the .plt section. */
417
418 static void
419 sparc64_elf_build_plt (output_bfd, contents, nentries)
420 bfd *output_bfd;
421 unsigned char *contents;
422 int nentries;
423 {
424 const unsigned int nop = 0x01000000;
425 int i, j;
426
427 /* The first four entries are reserved, and are initially undefined.
428 We fill them with `illtrap 0' to force ld.so to do something. */
429
430 for (i = 0; i < PLT_HEADER_SIZE/4; ++i)
431 bfd_put_32 (output_bfd, 0, contents+i*4);
432
433 /* The first 32768 entries are close enough to plt1 to get there via
434 a straight branch. */
435
436 for (i = 4; i < LARGE_PLT_THRESHOLD && i < nentries; ++i)
437 {
438 unsigned char *entry = contents + i * PLT_ENTRY_SIZE;
439 unsigned int sethi, ba;
440
441 /* sethi (. - plt0), %g1 */
442 sethi = 0x03000000 | (i * PLT_ENTRY_SIZE);
443
444 /* ba,a,pt %icc, plt1 */
445 ba = 0x30480000 | (((contents+PLT_ENTRY_SIZE) - (entry+4)) / 4 & 0x7ffff);
446
447 bfd_put_32 (output_bfd, sethi, entry);
448 bfd_put_32 (output_bfd, ba, entry+4);
449 bfd_put_32 (output_bfd, nop, entry+8);
450 bfd_put_32 (output_bfd, nop, entry+12);
451 bfd_put_32 (output_bfd, nop, entry+16);
452 bfd_put_32 (output_bfd, nop, entry+20);
453 bfd_put_32 (output_bfd, nop, entry+24);
454 bfd_put_32 (output_bfd, nop, entry+28);
455 }
456
457 /* Now the tricky bit. Entries 32768 and higher are grouped in blocks of
458 160: 160 entries and 160 pointers. This is to separate code from data,
459 which is much friendlier on the cache. */
460
461 for (; i < nentries; i += 160)
462 {
463 int block = (i + 160 <= nentries ? 160 : nentries - i);
464 for (j = 0; j < block; ++j)
465 {
466 unsigned char *entry, *ptr;
467 unsigned int ldx;
468
469 entry = contents + i*PLT_ENTRY_SIZE + j*4*6;
470 ptr = contents + i*PLT_ENTRY_SIZE + block*4*6 + j*8;
471
472 /* ldx [%o7 + ptr - entry+4], %g1 */
473 ldx = 0xc25be000 | ((ptr - entry+4) & 0x1fff);
474
475 bfd_put_32 (output_bfd, 0x8a10000f, entry); /* mov %o7,%g5 */
476 bfd_put_32 (output_bfd, 0x40000002, entry+4); /* call .+8 */
477 bfd_put_32 (output_bfd, nop, entry+8); /* nop */
478 bfd_put_32 (output_bfd, ldx, entry+12); /* ldx [%o7+P],%g1 */
479 bfd_put_32 (output_bfd, 0x83c3c001, entry+16); /* jmpl %o7+%g1,%g1 */
480 bfd_put_32 (output_bfd, 0x9e100005, entry+20); /* mov %g5,%o7 */
481
482 bfd_put_64 (output_bfd, contents - entry+4, ptr);
483 }
484 }
485 }
486
487 /* Return the offset of a particular plt entry within the .plt section. */
488
489 static bfd_vma
490 sparc64_elf_plt_entry_offset (index)
491 int index;
492 {
493 int block, ofs;
494
495 if (index < LARGE_PLT_THRESHOLD)
496 return index * PLT_ENTRY_SIZE;
497
498 /* See above for details. */
499
500 block = (index - LARGE_PLT_THRESHOLD) / 160;
501 ofs = (index - LARGE_PLT_THRESHOLD) % 160;
502
503 return ((bfd_vma)(LARGE_PLT_THRESHOLD + block*160) * PLT_ENTRY_SIZE
504 + ofs * 6*4);
505 }
506
507 static bfd_vma
508 sparc64_elf_plt_ptr_offset (index, max)
509 int index, max;
510 {
511 int block, ofs, last;
512
513 BFD_ASSERT(index >= LARGE_PLT_THRESHOLD);
514
515 /* See above for details. */
516
517 block = (index - LARGE_PLT_THRESHOLD) / 160;
518 ofs = (index - LARGE_PLT_THRESHOLD) % 160;
519 last = (max - LARGE_PLT_THRESHOLD) % 160;
520
521 return ((LARGE_PLT_THRESHOLD + block*160) * PLT_ENTRY_SIZE
522 + last * 6*4
523 + ofs * 8);
524 }
525
526
527 \f
528 /* Look through the relocs for a section during the first phase, and
529 allocate space in the global offset table or procedure linkage
530 table. */
531
532 static boolean
533 sparc64_elf_check_relocs (abfd, info, sec, relocs)
534 bfd *abfd;
535 struct bfd_link_info *info;
536 asection *sec;
537 const Elf_Internal_Rela *relocs;
538 {
539 bfd *dynobj;
540 Elf_Internal_Shdr *symtab_hdr;
541 struct elf_link_hash_entry **sym_hashes;
542 bfd_vma *local_got_offsets;
543 const Elf_Internal_Rela *rel;
544 const Elf_Internal_Rela *rel_end;
545 asection *sgot;
546 asection *srelgot;
547 asection *sreloc;
548
549 if (info->relocateable || !(sec->flags & SEC_ALLOC))
550 return true;
551
552 dynobj = elf_hash_table (info)->dynobj;
553 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
554 sym_hashes = elf_sym_hashes (abfd);
555 local_got_offsets = elf_local_got_offsets (abfd);
556
557 sgot = NULL;
558 srelgot = NULL;
559 sreloc = NULL;
560
561 rel_end = relocs + sec->reloc_count;
562 for (rel = relocs; rel < rel_end; rel++)
563 {
564 unsigned long r_symndx;
565 struct elf_link_hash_entry *h;
566
567 r_symndx = ELF64_R_SYM (rel->r_info);
568 if (r_symndx < symtab_hdr->sh_info)
569 h = NULL;
570 else
571 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
572
573 switch (ELF64_R_TYPE (rel->r_info))
574 {
575 case R_SPARC_GOT10:
576 case R_SPARC_GOT13:
577 case R_SPARC_GOT22:
578 /* This symbol requires a global offset table entry. */
579
580 if (dynobj == NULL)
581 {
582 /* Create the .got section. */
583 elf_hash_table (info)->dynobj = dynobj = abfd;
584 if (! _bfd_elf_create_got_section (dynobj, info))
585 return false;
586 }
587
588 if (sgot == NULL)
589 {
590 sgot = bfd_get_section_by_name (dynobj, ".got");
591 BFD_ASSERT (sgot != NULL);
592 }
593
594 if (srelgot == NULL && (h != NULL || info->shared))
595 {
596 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
597 if (srelgot == NULL)
598 {
599 srelgot = bfd_make_section (dynobj, ".rela.got");
600 if (srelgot == NULL
601 || ! bfd_set_section_flags (dynobj, srelgot,
602 (SEC_ALLOC
603 | SEC_LOAD
604 | SEC_HAS_CONTENTS
605 | SEC_IN_MEMORY
606 | SEC_LINKER_CREATED
607 | SEC_READONLY))
608 || ! bfd_set_section_alignment (dynobj, srelgot, 3))
609 return false;
610 }
611 }
612
613 if (h != NULL)
614 {
615 if (h->got.offset != (bfd_vma) -1)
616 {
617 /* We have already allocated space in the .got. */
618 break;
619 }
620 h->got.offset = sgot->_raw_size;
621
622 /* Make sure this symbol is output as a dynamic symbol. */
623 if (h->dynindx == -1)
624 {
625 if (! bfd_elf64_link_record_dynamic_symbol (info, h))
626 return false;
627 }
628
629 srelgot->_raw_size += sizeof (Elf64_External_Rela);
630 }
631 else
632 {
633 /* This is a global offset table entry for a local
634 symbol. */
635 if (local_got_offsets == NULL)
636 {
637 size_t size;
638 register unsigned int i;
639
640 size = symtab_hdr->sh_info * sizeof (bfd_vma);
641 local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
642 if (local_got_offsets == NULL)
643 return false;
644 elf_local_got_offsets (abfd) = local_got_offsets;
645 for (i = 0; i < symtab_hdr->sh_info; i++)
646 local_got_offsets[i] = (bfd_vma) -1;
647 }
648 if (local_got_offsets[r_symndx] != (bfd_vma) -1)
649 {
650 /* We have already allocated space in the .got. */
651 break;
652 }
653 local_got_offsets[r_symndx] = sgot->_raw_size;
654
655 if (info->shared)
656 {
657 /* If we are generating a shared object, we need to
658 output a R_SPARC_RELATIVE reloc so that the
659 dynamic linker can adjust this GOT entry. */
660 srelgot->_raw_size += sizeof (Elf64_External_Rela);
661 }
662 }
663
664 sgot->_raw_size += 8;
665
666 #if 0
667 /* Doesn't work for 64-bit -fPIC, since sethi/or builds
668 unsigned numbers. If we permit ourselves to modify
669 code so we get sethi/xor, this could work.
670 Question: do we consider conditionally re-enabling
671 this for -fpic, once we know about object code models? */
672 /* If the .got section is more than 0x1000 bytes, we add
673 0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13
674 bit relocations have a greater chance of working. */
675 if (sgot->_raw_size >= 0x1000
676 && elf_hash_table (info)->hgot->root.u.def.value == 0)
677 elf_hash_table (info)->hgot->root.u.def.value = 0x1000;
678 #endif
679
680 break;
681
682 case R_SPARC_WPLT30:
683 case R_SPARC_PLT32:
684 case R_SPARC_HIPLT22:
685 case R_SPARC_LOPLT10:
686 case R_SPARC_PCPLT32:
687 case R_SPARC_PCPLT22:
688 case R_SPARC_PCPLT10:
689 case R_SPARC_PLT64:
690 /* This symbol requires a procedure linkage table entry. We
691 actually build the entry in adjust_dynamic_symbol,
692 because this might be a case of linking PIC code without
693 linking in any dynamic objects, in which case we don't
694 need to generate a procedure linkage table after all. */
695
696 if (h == NULL)
697 {
698 /* It does not make sense to have a procedure linkage
699 table entry for a local symbol. */
700 bfd_set_error (bfd_error_bad_value);
701 return false;
702 }
703
704 /* Make sure this symbol is output as a dynamic symbol. */
705 if (h->dynindx == -1)
706 {
707 if (! bfd_elf64_link_record_dynamic_symbol (info, h))
708 return false;
709 }
710
711 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
712 break;
713
714 case R_SPARC_PC10:
715 case R_SPARC_PC22:
716 case R_SPARC_PC_HH22:
717 case R_SPARC_PC_HM10:
718 case R_SPARC_PC_LM22:
719 if (h != NULL
720 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
721 break;
722 /* Fall through. */
723 case R_SPARC_DISP8:
724 case R_SPARC_DISP16:
725 case R_SPARC_DISP32:
726 case R_SPARC_DISP64:
727 case R_SPARC_WDISP30:
728 case R_SPARC_WDISP22:
729 case R_SPARC_WDISP19:
730 case R_SPARC_WDISP16:
731 if (h == NULL)
732 break;
733 /* Fall through. */
734 case R_SPARC_8:
735 case R_SPARC_16:
736 case R_SPARC_32:
737 case R_SPARC_HI22:
738 case R_SPARC_22:
739 case R_SPARC_13:
740 case R_SPARC_LO10:
741 case R_SPARC_UA32:
742 case R_SPARC_10:
743 case R_SPARC_11:
744 case R_SPARC_64:
745 case R_SPARC_OLO10:
746 case R_SPARC_HH22:
747 case R_SPARC_HM10:
748 case R_SPARC_LM22:
749 case R_SPARC_7:
750 case R_SPARC_5:
751 case R_SPARC_6:
752 case R_SPARC_HIX22:
753 case R_SPARC_LOX10:
754 case R_SPARC_H44:
755 case R_SPARC_M44:
756 case R_SPARC_L44:
757 case R_SPARC_UA64:
758 case R_SPARC_UA16:
759 /* When creating a shared object, we must copy these relocs
760 into the output file. We create a reloc section in
761 dynobj and make room for the reloc.
762
763 But don't do this for debugging sections -- this shows up
764 with DWARF2 -- first because they are not loaded, and
765 second because DWARF sez the debug info is not to be
766 biased by the load address. */
767 if (info->shared && (sec->flags & SEC_ALLOC))
768 {
769 if (sreloc == NULL)
770 {
771 const char *name;
772
773 name = (bfd_elf_string_from_elf_section
774 (abfd,
775 elf_elfheader (abfd)->e_shstrndx,
776 elf_section_data (sec)->rel_hdr.sh_name));
777 if (name == NULL)
778 return false;
779
780 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
781 && strcmp (bfd_get_section_name (abfd, sec),
782 name + 5) == 0);
783
784 sreloc = bfd_get_section_by_name (dynobj, name);
785 if (sreloc == NULL)
786 {
787 flagword flags;
788
789 sreloc = bfd_make_section (dynobj, name);
790 flags = (SEC_HAS_CONTENTS | SEC_READONLY
791 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
792 if ((sec->flags & SEC_ALLOC) != 0)
793 flags |= SEC_ALLOC | SEC_LOAD;
794 if (sreloc == NULL
795 || ! bfd_set_section_flags (dynobj, sreloc, flags)
796 || ! bfd_set_section_alignment (dynobj, sreloc, 3))
797 return false;
798 }
799 }
800
801 sreloc->_raw_size += sizeof (Elf64_External_Rela);
802 }
803 break;
804
805 case R_SPARC_REGISTER:
806 /* Nothing to do. */
807 break;
808
809 default:
810 (*_bfd_error_handler)(_("%s: check_relocs: unhandled reloc type %d"),
811 bfd_get_filename(abfd),
812 ELF64_R_TYPE (rel->r_info));
813 return false;
814 }
815 }
816
817 return true;
818 }
819
820 /* Adjust a symbol defined by a dynamic object and referenced by a
821 regular object. The current definition is in some section of the
822 dynamic object, but we're not including those sections. We have to
823 change the definition to something the rest of the link can
824 understand. */
825
826 static boolean
827 sparc64_elf_adjust_dynamic_symbol (info, h)
828 struct bfd_link_info *info;
829 struct elf_link_hash_entry *h;
830 {
831 bfd *dynobj;
832 asection *s;
833 unsigned int power_of_two;
834
835 dynobj = elf_hash_table (info)->dynobj;
836
837 /* Make sure we know what is going on here. */
838 BFD_ASSERT (dynobj != NULL
839 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
840 || h->weakdef != NULL
841 || ((h->elf_link_hash_flags
842 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
843 && (h->elf_link_hash_flags
844 & ELF_LINK_HASH_REF_REGULAR) != 0
845 && (h->elf_link_hash_flags
846 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
847
848 /* If this is a function, put it in the procedure linkage table. We
849 will fill in the contents of the procedure linkage table later
850 (although we could actually do it here). The STT_NOTYPE
851 condition is a hack specifically for the Oracle libraries
852 delivered for Solaris; for some inexplicable reason, they define
853 some of their functions as STT_NOTYPE when they really should be
854 STT_FUNC. */
855 if (h->type == STT_FUNC
856 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0
857 || (h->type == STT_NOTYPE
858 && (h->root.type == bfd_link_hash_defined
859 || h->root.type == bfd_link_hash_defweak)
860 && (h->root.u.def.section->flags & SEC_CODE) != 0))
861 {
862 if (! elf_hash_table (info)->dynamic_sections_created)
863 {
864 /* This case can occur if we saw a WPLT30 reloc in an input
865 file, but none of the input files were dynamic objects.
866 In such a case, we don't actually need to build a
867 procedure linkage table, and we can just do a WDISP30
868 reloc instead. */
869 BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
870 return true;
871 }
872
873 s = bfd_get_section_by_name (dynobj, ".plt");
874 BFD_ASSERT (s != NULL);
875
876 /* The first four bit in .plt is reserved. */
877 if (s->_raw_size == 0)
878 s->_raw_size = PLT_HEADER_SIZE;
879
880 /* If this symbol is not defined in a regular file, and we are
881 not generating a shared library, then set the symbol to this
882 location in the .plt. This is required to make function
883 pointers compare as equal between the normal executable and
884 the shared library. */
885 if (! info->shared
886 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
887 {
888 h->root.u.def.section = s;
889 h->root.u.def.value = s->_raw_size;
890 }
891
892 /* To simplify matters later, just store the plt index here. */
893 h->plt.offset = s->_raw_size / PLT_ENTRY_SIZE;
894
895 /* Make room for this entry. */
896 s->_raw_size += PLT_ENTRY_SIZE;
897
898 /* We also need to make an entry in the .rela.plt section. */
899
900 s = bfd_get_section_by_name (dynobj, ".rela.plt");
901 BFD_ASSERT (s != NULL);
902
903 /* The first plt entries are reserved, and the relocations must
904 pair up exactly. */
905 if (s->_raw_size == 0)
906 s->_raw_size += (PLT_HEADER_SIZE/PLT_ENTRY_SIZE
907 * sizeof (Elf64_External_Rela));
908
909 s->_raw_size += sizeof (Elf64_External_Rela);
910
911 /* The procedure linkage table size is bounded by the magnitude
912 of the offset we can describe in the entry. */
913 if (s->_raw_size >= (bfd_vma)1 << 32)
914 {
915 bfd_set_error (bfd_error_bad_value);
916 return false;
917 }
918
919 return true;
920 }
921
922 /* If this is a weak symbol, and there is a real definition, the
923 processor independent code will have arranged for us to see the
924 real definition first, and we can just use the same value. */
925 if (h->weakdef != NULL)
926 {
927 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
928 || h->weakdef->root.type == bfd_link_hash_defweak);
929 h->root.u.def.section = h->weakdef->root.u.def.section;
930 h->root.u.def.value = h->weakdef->root.u.def.value;
931 return true;
932 }
933
934 /* This is a reference to a symbol defined by a dynamic object which
935 is not a function. */
936
937 /* If we are creating a shared library, we must presume that the
938 only references to the symbol are via the global offset table.
939 For such cases we need not do anything here; the relocations will
940 be handled correctly by relocate_section. */
941 if (info->shared)
942 return true;
943
944 /* We must allocate the symbol in our .dynbss section, which will
945 become part of the .bss section of the executable. There will be
946 an entry for this symbol in the .dynsym section. The dynamic
947 object will contain position independent code, so all references
948 from the dynamic object to this symbol will go through the global
949 offset table. The dynamic linker will use the .dynsym entry to
950 determine the address it must put in the global offset table, so
951 both the dynamic object and the regular object will refer to the
952 same memory location for the variable. */
953
954 s = bfd_get_section_by_name (dynobj, ".dynbss");
955 BFD_ASSERT (s != NULL);
956
957 /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker
958 to copy the initial value out of the dynamic object and into the
959 runtime process image. We need to remember the offset into the
960 .rel.bss section we are going to use. */
961 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
962 {
963 asection *srel;
964
965 srel = bfd_get_section_by_name (dynobj, ".rela.bss");
966 BFD_ASSERT (srel != NULL);
967 srel->_raw_size += sizeof (Elf64_External_Rela);
968 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
969 }
970
971 /* We need to figure out the alignment required for this symbol. I
972 have no idea how ELF linkers handle this. 16-bytes is the size
973 of the largest type that requires hard alignment -- long double. */
974 power_of_two = bfd_log2 (h->size);
975 if (power_of_two > 4)
976 power_of_two = 4;
977
978 /* Apply the required alignment. */
979 s->_raw_size = BFD_ALIGN (s->_raw_size,
980 (bfd_size_type) (1 << power_of_two));
981 if (power_of_two > bfd_get_section_alignment (dynobj, s))
982 {
983 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
984 return false;
985 }
986
987 /* Define the symbol as being at this point in the section. */
988 h->root.u.def.section = s;
989 h->root.u.def.value = s->_raw_size;
990
991 /* Increment the section size to make room for the symbol. */
992 s->_raw_size += h->size;
993
994 return true;
995 }
996
997 /* Set the sizes of the dynamic sections. */
998
999 static boolean
1000 sparc64_elf_size_dynamic_sections (output_bfd, info)
1001 bfd *output_bfd;
1002 struct bfd_link_info *info;
1003 {
1004 bfd *dynobj;
1005 asection *s;
1006 boolean reltext;
1007 boolean relplt;
1008
1009 dynobj = elf_hash_table (info)->dynobj;
1010 BFD_ASSERT (dynobj != NULL);
1011
1012 if (elf_hash_table (info)->dynamic_sections_created)
1013 {
1014 /* Set the contents of the .interp section to the interpreter. */
1015 if (! info->shared)
1016 {
1017 s = bfd_get_section_by_name (dynobj, ".interp");
1018 BFD_ASSERT (s != NULL);
1019 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
1020 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1021 }
1022 }
1023 else
1024 {
1025 /* We may have created entries in the .rela.got section.
1026 However, if we are not creating the dynamic sections, we will
1027 not actually use these entries. Reset the size of .rela.got,
1028 which will cause it to get stripped from the output file
1029 below. */
1030 s = bfd_get_section_by_name (dynobj, ".rela.got");
1031 if (s != NULL)
1032 s->_raw_size = 0;
1033 }
1034
1035 /* The check_relocs and adjust_dynamic_symbol entry points have
1036 determined the sizes of the various dynamic sections. Allocate
1037 memory for them. */
1038 reltext = false;
1039 relplt = false;
1040 for (s = dynobj->sections; s != NULL; s = s->next)
1041 {
1042 const char *name;
1043 boolean strip;
1044
1045 if ((s->flags & SEC_LINKER_CREATED) == 0)
1046 continue;
1047
1048 /* It's OK to base decisions on the section name, because none
1049 of the dynobj section names depend upon the input files. */
1050 name = bfd_get_section_name (dynobj, s);
1051
1052 strip = false;
1053
1054 if (strncmp (name, ".rela", 5) == 0)
1055 {
1056 if (s->_raw_size == 0)
1057 {
1058 /* If we don't need this section, strip it from the
1059 output file. This is to handle .rela.bss and
1060 .rel.plt. We must create it in
1061 create_dynamic_sections, because it must be created
1062 before the linker maps input sections to output
1063 sections. The linker does that before
1064 adjust_dynamic_symbol is called, and it is that
1065 function which decides whether anything needs to go
1066 into these sections. */
1067 strip = true;
1068 }
1069 else
1070 {
1071 const char *outname;
1072 asection *target;
1073
1074 /* If this relocation section applies to a read only
1075 section, then we probably need a DT_TEXTREL entry. */
1076 outname = bfd_get_section_name (output_bfd,
1077 s->output_section);
1078 target = bfd_get_section_by_name (output_bfd, outname + 5);
1079 if (target != NULL
1080 && (target->flags & SEC_READONLY) != 0)
1081 reltext = true;
1082
1083 if (strcmp (name, ".rela.plt") == 0)
1084 relplt = true;
1085
1086 /* We use the reloc_count field as a counter if we need
1087 to copy relocs into the output file. */
1088 s->reloc_count = 0;
1089 }
1090 }
1091 else if (strcmp (name, ".plt") != 0
1092 && strncmp (name, ".got", 4) != 0)
1093 {
1094 /* It's not one of our sections, so don't allocate space. */
1095 continue;
1096 }
1097
1098 if (strip)
1099 {
1100 _bfd_strip_section_from_output (s);
1101 continue;
1102 }
1103
1104 /* Allocate memory for the section contents. Zero the memory
1105 for the benefit of .rela.plt, which has 4 unused entries
1106 at the beginning, and we don't want garbage. */
1107 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
1108 if (s->contents == NULL && s->_raw_size != 0)
1109 return false;
1110 }
1111
1112 if (elf_hash_table (info)->dynamic_sections_created)
1113 {
1114 /* Add some entries to the .dynamic section. We fill in the
1115 values later, in sparc64_elf_finish_dynamic_sections, but we
1116 must add the entries now so that we get the correct size for
1117 the .dynamic section. The DT_DEBUG entry is filled in by the
1118 dynamic linker and used by the debugger. */
1119 if (! info->shared)
1120 {
1121 if (! bfd_elf64_add_dynamic_entry (info, DT_DEBUG, 0))
1122 return false;
1123 }
1124
1125 if (relplt)
1126 {
1127 if (! bfd_elf64_add_dynamic_entry (info, DT_PLTGOT, 0)
1128 || ! bfd_elf64_add_dynamic_entry (info, DT_PLTRELSZ, 0)
1129 || ! bfd_elf64_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
1130 || ! bfd_elf64_add_dynamic_entry (info, DT_JMPREL, 0)
1131 || ! bfd_elf64_add_dynamic_entry (info, DT_SPARC_PLTFMT,
1132 (info->shared != 0) + 1))
1133 return false;
1134 }
1135
1136 if (! bfd_elf64_add_dynamic_entry (info, DT_RELA, 0)
1137 || ! bfd_elf64_add_dynamic_entry (info, DT_RELASZ, 0)
1138 || ! bfd_elf64_add_dynamic_entry (info, DT_RELAENT,
1139 sizeof (Elf64_External_Rela)))
1140 return false;
1141
1142 if (reltext)
1143 {
1144 if (! bfd_elf64_add_dynamic_entry (info, DT_TEXTREL, 0))
1145 return false;
1146 }
1147 }
1148
1149 /* If we are generating a shared library, we generate a section
1150 symbol for each output section for which we might need to copy
1151 relocs. These are local symbols, which means that they must come
1152 first in the dynamic symbol table. That means we must increment
1153 the dynamic symbol index of every other dynamic symbol. */
1154 if (info->shared)
1155 {
1156 int c;
1157
1158 c = 0;
1159 for (s = output_bfd->sections; s != NULL; s = s->next)
1160 {
1161 if ((s->flags & SEC_LINKER_CREATED) != 0
1162 || (s->flags & SEC_ALLOC) == 0)
1163 continue;
1164
1165 elf_section_data (s)->dynindx = c + 1;
1166
1167 /* These symbols will have no names, so we don't need to
1168 fiddle with dynstr_index. */
1169
1170 ++c;
1171 }
1172
1173 elf_link_hash_traverse (elf_hash_table (info),
1174 sparc64_elf_adjust_dynindx,
1175 (PTR) &c);
1176 elf_hash_table (info)->dynsymcount += c;
1177 }
1178
1179 return true;
1180 }
1181
1182 /* Increment the index of a dynamic symbol by a given amount. Called
1183 via elf_link_hash_traverse. */
1184
1185 static boolean
1186 sparc64_elf_adjust_dynindx (h, cparg)
1187 struct elf_link_hash_entry *h;
1188 PTR cparg;
1189 {
1190 int *cp = (int *) cparg;
1191
1192 if (h->dynindx != -1)
1193 h->dynindx += *cp;
1194 return true;
1195 }
1196
1197 \f
1198 /* Relocate a SPARC64 ELF section. */
1199
1200 static boolean
1201 sparc64_elf_relocate_section (output_bfd, info, input_bfd, input_section,
1202 contents, relocs, local_syms, local_sections)
1203 bfd *output_bfd;
1204 struct bfd_link_info *info;
1205 bfd *input_bfd;
1206 asection *input_section;
1207 bfd_byte *contents;
1208 Elf_Internal_Rela *relocs;
1209 Elf_Internal_Sym *local_syms;
1210 asection **local_sections;
1211 {
1212 bfd *dynobj;
1213 Elf_Internal_Shdr *symtab_hdr;
1214 struct elf_link_hash_entry **sym_hashes;
1215 bfd_vma *local_got_offsets;
1216 bfd_vma got_base;
1217 asection *sgot;
1218 asection *splt;
1219 asection *sreloc;
1220 Elf_Internal_Rela *rel;
1221 Elf_Internal_Rela *relend;
1222
1223 dynobj = elf_hash_table (info)->dynobj;
1224 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1225 sym_hashes = elf_sym_hashes (input_bfd);
1226 local_got_offsets = elf_local_got_offsets (input_bfd);
1227
1228 if (elf_hash_table(info)->hgot == NULL)
1229 got_base = 0;
1230 else
1231 got_base = elf_hash_table (info)->hgot->root.u.def.value;
1232
1233 sgot = splt = sreloc = NULL;
1234
1235 rel = relocs;
1236 relend = relocs + input_section->reloc_count;
1237 for (; rel < relend; rel++)
1238 {
1239 int r_type;
1240 reloc_howto_type *howto;
1241 long r_symndx;
1242 struct elf_link_hash_entry *h;
1243 Elf_Internal_Sym *sym;
1244 asection *sec;
1245 bfd_vma relocation;
1246 bfd_reloc_status_type r;
1247
1248 r_type = ELF64_R_TYPE (rel->r_info);
1249 if (r_type < 0 || r_type >= (int) R_SPARC_max_std)
1250 {
1251 bfd_set_error (bfd_error_bad_value);
1252 return false;
1253 }
1254 howto = sparc64_elf_howto_table + r_type;
1255
1256 r_symndx = ELF64_R_SYM (rel->r_info);
1257
1258 if (info->relocateable)
1259 {
1260 /* This is a relocateable link. We don't have to change
1261 anything, unless the reloc is against a section symbol,
1262 in which case we have to adjust according to where the
1263 section symbol winds up in the output section. */
1264 if (r_symndx < symtab_hdr->sh_info)
1265 {
1266 sym = local_syms + r_symndx;
1267 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1268 {
1269 sec = local_sections[r_symndx];
1270 rel->r_addend += sec->output_offset + sym->st_value;
1271 }
1272 }
1273
1274 continue;
1275 }
1276
1277 /* This is a final link. */
1278 h = NULL;
1279 sym = NULL;
1280 sec = NULL;
1281 if (r_symndx < symtab_hdr->sh_info)
1282 {
1283 sym = local_syms + r_symndx;
1284 sec = local_sections[r_symndx];
1285 relocation = (sec->output_section->vma
1286 + sec->output_offset
1287 + sym->st_value);
1288 }
1289 else
1290 {
1291 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1292 while (h->root.type == bfd_link_hash_indirect
1293 || h->root.type == bfd_link_hash_warning)
1294 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1295 if (h->root.type == bfd_link_hash_defined
1296 || h->root.type == bfd_link_hash_defweak)
1297 {
1298 boolean skip_it = false;
1299 sec = h->root.u.def.section;
1300
1301 switch (r_type)
1302 {
1303 case R_SPARC_WPLT30:
1304 case R_SPARC_PLT32:
1305 case R_SPARC_HIPLT22:
1306 case R_SPARC_LOPLT10:
1307 case R_SPARC_PCPLT32:
1308 case R_SPARC_PCPLT22:
1309 case R_SPARC_PCPLT10:
1310 case R_SPARC_PLT64:
1311 if (h->plt.offset != (bfd_vma) -1)
1312 skip_it = true;
1313 break;
1314
1315 case R_SPARC_GOT10:
1316 case R_SPARC_GOT13:
1317 case R_SPARC_GOT22:
1318 if (elf_hash_table(info)->dynamic_sections_created
1319 && (!info->shared
1320 || (!info->symbolic && h->dynindx != -1)
1321 || !(h->elf_link_hash_flags
1322 & ELF_LINK_HASH_DEF_REGULAR)))
1323 skip_it = true;
1324 break;
1325
1326 case R_SPARC_PC10:
1327 case R_SPARC_PC22:
1328 case R_SPARC_PC_HH22:
1329 case R_SPARC_PC_HM10:
1330 case R_SPARC_PC_LM22:
1331 if (!strcmp(h->root.root.string, "_GLOBAL_OFFSET_TABLE_"))
1332 break;
1333 /* FALLTHRU */
1334
1335 case R_SPARC_8:
1336 case R_SPARC_16:
1337 case R_SPARC_32:
1338 case R_SPARC_DISP8:
1339 case R_SPARC_DISP16:
1340 case R_SPARC_DISP32:
1341 case R_SPARC_WDISP30:
1342 case R_SPARC_WDISP22:
1343 case R_SPARC_HI22:
1344 case R_SPARC_22:
1345 case R_SPARC_13:
1346 case R_SPARC_LO10:
1347 case R_SPARC_UA32:
1348 case R_SPARC_10:
1349 case R_SPARC_11:
1350 case R_SPARC_64:
1351 case R_SPARC_OLO10:
1352 case R_SPARC_HH22:
1353 case R_SPARC_HM10:
1354 case R_SPARC_LM22:
1355 case R_SPARC_WDISP19:
1356 case R_SPARC_WDISP16:
1357 case R_SPARC_7:
1358 case R_SPARC_5:
1359 case R_SPARC_6:
1360 case R_SPARC_DISP64:
1361 case R_SPARC_HIX22:
1362 case R_SPARC_LOX10:
1363 case R_SPARC_H44:
1364 case R_SPARC_M44:
1365 case R_SPARC_L44:
1366 case R_SPARC_UA64:
1367 case R_SPARC_UA16:
1368 if (info->shared
1369 && ((!info->symbolic && h->dynindx != -1)
1370 || !(h->elf_link_hash_flags
1371 & ELF_LINK_HASH_DEF_REGULAR)))
1372 skip_it = true;
1373 break;
1374 }
1375
1376 if (skip_it)
1377 {
1378 /* In these cases, we don't need the relocation
1379 value. We check specially because in some
1380 obscure cases sec->output_section will be NULL. */
1381 relocation = 0;
1382 }
1383 else
1384 {
1385 relocation = (h->root.u.def.value
1386 + sec->output_section->vma
1387 + sec->output_offset);
1388 }
1389 }
1390 else if (h->root.type == bfd_link_hash_undefweak)
1391 relocation = 0;
1392 else if (info->shared && !info->symbolic && !info->no_undefined)
1393 relocation = 0;
1394 else
1395 {
1396 if (! ((*info->callbacks->undefined_symbol)
1397 (info, h->root.root.string, input_bfd,
1398 input_section, rel->r_offset)))
1399 return false;
1400 relocation = 0;
1401 }
1402 }
1403
1404 /* When generating a shared object, these relocations are copied
1405 into the output file to be resolved at run time. */
1406 if (info->shared && (input_section->flags & SEC_ALLOC))
1407 {
1408 switch (r_type)
1409 {
1410 case R_SPARC_PC10:
1411 case R_SPARC_PC22:
1412 case R_SPARC_PC_HH22:
1413 case R_SPARC_PC_HM10:
1414 case R_SPARC_PC_LM22:
1415 if (h != NULL
1416 && !strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_"))
1417 break;
1418 /* Fall through. */
1419 case R_SPARC_DISP8:
1420 case R_SPARC_DISP16:
1421 case R_SPARC_DISP32:
1422 case R_SPARC_WDISP30:
1423 case R_SPARC_WDISP22:
1424 case R_SPARC_WDISP19:
1425 case R_SPARC_WDISP16:
1426 case R_SPARC_DISP64:
1427 if (h == NULL)
1428 break;
1429 /* Fall through. */
1430 case R_SPARC_8:
1431 case R_SPARC_16:
1432 case R_SPARC_32:
1433 case R_SPARC_HI22:
1434 case R_SPARC_22:
1435 case R_SPARC_13:
1436 case R_SPARC_LO10:
1437 case R_SPARC_UA32:
1438 case R_SPARC_10:
1439 case R_SPARC_11:
1440 case R_SPARC_64:
1441 case R_SPARC_OLO10:
1442 case R_SPARC_HH22:
1443 case R_SPARC_HM10:
1444 case R_SPARC_LM22:
1445 case R_SPARC_7:
1446 case R_SPARC_5:
1447 case R_SPARC_6:
1448 case R_SPARC_HIX22:
1449 case R_SPARC_LOX10:
1450 case R_SPARC_H44:
1451 case R_SPARC_M44:
1452 case R_SPARC_L44:
1453 case R_SPARC_UA64:
1454 case R_SPARC_UA16:
1455 {
1456 Elf_Internal_Rela outrel;
1457 boolean skip;
1458
1459 if (sreloc == NULL)
1460 {
1461 const char *name =
1462 (bfd_elf_string_from_elf_section
1463 (input_bfd,
1464 elf_elfheader (input_bfd)->e_shstrndx,
1465 elf_section_data (input_section)->rel_hdr.sh_name));
1466
1467 if (name == NULL)
1468 return false;
1469
1470 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
1471 && strcmp (bfd_get_section_name(input_bfd,
1472 input_section),
1473 name + 5) == 0);
1474
1475 sreloc = bfd_get_section_by_name (dynobj, name);
1476 BFD_ASSERT (sreloc != NULL);
1477 }
1478
1479 skip = false;
1480
1481 if (elf_section_data (input_section)->stab_info == NULL)
1482 outrel.r_offset = rel->r_offset;
1483 else
1484 {
1485 bfd_vma off;
1486
1487 off = (_bfd_stab_section_offset
1488 (output_bfd, &elf_hash_table (info)->stab_info,
1489 input_section,
1490 &elf_section_data (input_section)->stab_info,
1491 rel->r_offset));
1492 if (off == MINUS_ONE)
1493 skip = true;
1494 outrel.r_offset = off;
1495 }
1496
1497 outrel.r_offset += (input_section->output_section->vma
1498 + input_section->output_offset);
1499
1500 /* Optimize unaligned reloc usage now that we know where
1501 it finally resides. */
1502 switch (r_type)
1503 {
1504 case R_SPARC_16:
1505 if (outrel.r_offset & 1) r_type = R_SPARC_UA16;
1506 break;
1507 case R_SPARC_UA16:
1508 if (!(outrel.r_offset & 1)) r_type = R_SPARC_16;
1509 break;
1510 case R_SPARC_32:
1511 if (outrel.r_offset & 3) r_type = R_SPARC_UA32;
1512 break;
1513 case R_SPARC_UA32:
1514 if (!(outrel.r_offset & 3)) r_type = R_SPARC_32;
1515 break;
1516 case R_SPARC_64:
1517 if (outrel.r_offset & 7) r_type = R_SPARC_UA64;
1518 break;
1519 case R_SPARC_UA64:
1520 if (!(outrel.r_offset & 7)) r_type = R_SPARC_64;
1521 break;
1522 }
1523
1524 if (skip)
1525 memset (&outrel, 0, sizeof outrel);
1526 /* h->dynindx may be -1 if the symbol was marked to
1527 become local. */
1528 else if (h != NULL
1529 && ((! info->symbolic && h->dynindx != -1)
1530 || (h->elf_link_hash_flags
1531 & ELF_LINK_HASH_DEF_REGULAR) == 0))
1532 {
1533 BFD_ASSERT (h->dynindx != -1);
1534 outrel.r_info = ELF64_R_INFO (h->dynindx, r_type);
1535 outrel.r_addend = rel->r_addend;
1536 }
1537 else
1538 {
1539 if (r_type == R_SPARC_64)
1540 {
1541 outrel.r_info = ELF64_R_INFO (0, R_SPARC_RELATIVE);
1542 outrel.r_addend = relocation + rel->r_addend;
1543 }
1544 else
1545 {
1546 long indx;
1547
1548 if (h == NULL)
1549 sec = local_sections[r_symndx];
1550 else
1551 {
1552 BFD_ASSERT (h->root.type == bfd_link_hash_defined
1553 || (h->root.type
1554 == bfd_link_hash_defweak));
1555 sec = h->root.u.def.section;
1556 }
1557 if (sec != NULL && bfd_is_abs_section (sec))
1558 indx = 0;
1559 else if (sec == NULL || sec->owner == NULL)
1560 {
1561 bfd_set_error (bfd_error_bad_value);
1562 return false;
1563 }
1564 else
1565 {
1566 asection *osec;
1567
1568 osec = sec->output_section;
1569 indx = elf_section_data (osec)->dynindx;
1570
1571 /* FIXME: we really should be able to link non-pic
1572 shared libraries. */
1573 if (indx == 0)
1574 {
1575 BFD_FAIL ();
1576 (*_bfd_error_handler)
1577 (_("%s: probably compiled without -fPIC?"),
1578 bfd_get_filename (input_bfd));
1579 bfd_set_error (bfd_error_bad_value);
1580 return false;
1581 }
1582 }
1583
1584 outrel.r_info = ELF64_R_INFO (indx, r_type);
1585
1586 /* For non-RELATIVE dynamic relocations, we keep the
1587 same symbol, and so generally the same addend. But
1588 we do need to adjust those relocations referencing
1589 sections. */
1590 outrel.r_addend = rel->r_addend;
1591 if (r_symndx < symtab_hdr->sh_info
1592 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1593 outrel.r_addend += sec->output_offset+sym->st_value;
1594 }
1595 }
1596
1597 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
1598 (((Elf64_External_Rela *)
1599 sreloc->contents)
1600 + sreloc->reloc_count));
1601 ++sreloc->reloc_count;
1602
1603 /* This reloc will be computed at runtime, so there's no
1604 need to do anything now, unless this is a RELATIVE
1605 reloc in an unallocated section. */
1606 if (skip
1607 || (input_section->flags & SEC_ALLOC) != 0
1608 || ELF64_R_TYPE (outrel.r_info) != R_SPARC_RELATIVE)
1609 continue;
1610 }
1611 break;
1612 }
1613 }
1614
1615 switch (r_type)
1616 {
1617 case R_SPARC_GOT10:
1618 case R_SPARC_GOT13:
1619 case R_SPARC_GOT22:
1620 /* Relocation is to the entry for this symbol in the global
1621 offset table. */
1622 if (sgot == NULL)
1623 {
1624 sgot = bfd_get_section_by_name (dynobj, ".got");
1625 BFD_ASSERT (sgot != NULL);
1626 }
1627
1628 if (h != NULL)
1629 {
1630 bfd_vma off = h->got.offset;
1631 BFD_ASSERT (off != (bfd_vma) -1);
1632
1633 if (! elf_hash_table (info)->dynamic_sections_created
1634 || (info->shared
1635 && (info->symbolic || h->dynindx == -1)
1636 && (h->elf_link_hash_flags
1637 & ELF_LINK_HASH_DEF_REGULAR)))
1638 {
1639 /* This is actually a static link, or it is a -Bsymbolic
1640 link and the symbol is defined locally, or the symbol
1641 was forced to be local because of a version file. We
1642 must initialize this entry in the global offset table.
1643 Since the offset must always be a multiple of 8, we
1644 use the least significant bit to record whether we
1645 have initialized it already.
1646
1647 When doing a dynamic link, we create a .rela.got
1648 relocation entry to initialize the value. This is
1649 done in the finish_dynamic_symbol routine. */
1650
1651 if ((off & 1) != 0)
1652 off &= ~1;
1653 else
1654 {
1655 bfd_put_64 (output_bfd, relocation,
1656 sgot->contents + off);
1657 h->got.offset |= 1;
1658 }
1659 }
1660 relocation = sgot->output_offset + off - got_base;
1661 }
1662 else
1663 {
1664 bfd_vma off;
1665
1666 BFD_ASSERT (local_got_offsets != NULL);
1667 off = local_got_offsets[r_symndx];
1668 BFD_ASSERT (off != (bfd_vma) -1);
1669
1670 /* The offset must always be a multiple of 8. We use
1671 the least significant bit to record whether we have
1672 already processed this entry. */
1673 if ((off & 1) != 0)
1674 off &= ~1;
1675 else
1676 {
1677 bfd_put_64 (output_bfd, relocation, sgot->contents + off);
1678 local_got_offsets[r_symndx] |= 1;
1679
1680 if (info->shared)
1681 {
1682 asection *srelgot;
1683 Elf_Internal_Rela outrel;
1684
1685 /* We need to generate a R_SPARC_RELATIVE reloc
1686 for the dynamic linker. */
1687 srelgot = bfd_get_section_by_name(dynobj, ".rela.got");
1688 BFD_ASSERT (srelgot != NULL);
1689
1690 outrel.r_offset = (sgot->output_section->vma
1691 + sgot->output_offset
1692 + off);
1693 outrel.r_info = ELF64_R_INFO (0, R_SPARC_RELATIVE);
1694 outrel.r_addend = relocation;
1695 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
1696 (((Elf64_External_Rela *)
1697 srelgot->contents)
1698 + srelgot->reloc_count));
1699 ++srelgot->reloc_count;
1700 }
1701 }
1702 relocation = sgot->output_offset + off - got_base;
1703 }
1704 goto do_default;
1705
1706 case R_SPARC_WPLT30:
1707 case R_SPARC_PLT32:
1708 case R_SPARC_HIPLT22:
1709 case R_SPARC_LOPLT10:
1710 case R_SPARC_PCPLT32:
1711 case R_SPARC_PCPLT22:
1712 case R_SPARC_PCPLT10:
1713 case R_SPARC_PLT64:
1714 /* Relocation is to the entry for this symbol in the
1715 procedure linkage table. */
1716 BFD_ASSERT (h != NULL);
1717
1718 if (h->plt.offset == (bfd_vma) -1)
1719 {
1720 /* We didn't make a PLT entry for this symbol. This
1721 happens when statically linking PIC code, or when
1722 using -Bsymbolic. */
1723 goto do_default;
1724 }
1725
1726 if (splt == NULL)
1727 {
1728 splt = bfd_get_section_by_name (dynobj, ".plt");
1729 BFD_ASSERT (splt != NULL);
1730 }
1731
1732 relocation = (splt->output_section->vma
1733 + splt->output_offset
1734 + sparc64_elf_plt_entry_offset (h->plt.offset));
1735 goto do_default;
1736
1737 case R_SPARC_OLO10:
1738 {
1739 bfd_vma x;
1740
1741 relocation += rel->r_addend;
1742 relocation = (relocation & 0x3ff) + ELF64_R_TYPE_DATA (rel->r_info);
1743
1744 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
1745 x = (x & ~0x1fff) | (relocation & 0x1fff);
1746 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
1747
1748 r = bfd_check_overflow (howto->complain_on_overflow,
1749 howto->bitsize, howto->rightshift,
1750 bfd_arch_bits_per_address (input_bfd),
1751 relocation);
1752 }
1753 break;
1754
1755 case R_SPARC_WDISP16:
1756 {
1757 bfd_vma x;
1758
1759 relocation += rel->r_addend;
1760 /* Adjust for pc-relative-ness. */
1761 relocation -= (input_section->output_section->vma
1762 + input_section->output_offset);
1763 relocation -= rel->r_offset;
1764
1765 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
1766 x = (x & ~0x303fff) | ((((relocation >> 2) & 0xc000) << 6)
1767 | ((relocation >> 2) & 0x3fff));
1768 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
1769
1770 r = bfd_check_overflow (howto->complain_on_overflow,
1771 howto->bitsize, howto->rightshift,
1772 bfd_arch_bits_per_address (input_bfd),
1773 relocation);
1774 }
1775 break;
1776
1777 case R_SPARC_HIX22:
1778 {
1779 bfd_vma x;
1780
1781 relocation += rel->r_addend;
1782 relocation = relocation ^ MINUS_ONE;
1783
1784 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
1785 x = (x & ~0x3fffff) | ((relocation >> 10) & 0x3fffff);
1786 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
1787
1788 r = bfd_check_overflow (howto->complain_on_overflow,
1789 howto->bitsize, howto->rightshift,
1790 bfd_arch_bits_per_address (input_bfd),
1791 relocation);
1792 }
1793 break;
1794
1795 case R_SPARC_LOX10:
1796 {
1797 bfd_vma x;
1798
1799 relocation += rel->r_addend;
1800 relocation = (relocation & 0x3ff) | 0x1c00;
1801
1802 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
1803 x = (x & ~0x1fff) | relocation;
1804 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
1805
1806 r = bfd_reloc_ok;
1807 }
1808 break;
1809
1810 default:
1811 do_default:
1812 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1813 contents, rel->r_offset,
1814 relocation, rel->r_addend);
1815 break;
1816 }
1817
1818 switch (r)
1819 {
1820 case bfd_reloc_ok:
1821 break;
1822
1823 default:
1824 case bfd_reloc_outofrange:
1825 abort ();
1826
1827 case bfd_reloc_overflow:
1828 {
1829 const char *name;
1830
1831 if (h != NULL)
1832 {
1833 if (h->root.type == bfd_link_hash_undefweak
1834 && howto->pc_relative)
1835 {
1836 /* Assume this is a call protected by other code that
1837 detect the symbol is undefined. If this is the case,
1838 we can safely ignore the overflow. If not, the
1839 program is hosed anyway, and a little warning isn't
1840 going to help. */
1841 break;
1842 }
1843
1844 name = h->root.root.string;
1845 }
1846 else
1847 {
1848 name = (bfd_elf_string_from_elf_section
1849 (input_bfd,
1850 symtab_hdr->sh_link,
1851 sym->st_name));
1852 if (name == NULL)
1853 return false;
1854 if (*name == '\0')
1855 name = bfd_section_name (input_bfd, sec);
1856 }
1857 if (! ((*info->callbacks->reloc_overflow)
1858 (info, name, howto->name, (bfd_vma) 0,
1859 input_bfd, input_section, rel->r_offset)))
1860 return false;
1861 }
1862 break;
1863 }
1864 }
1865
1866 return true;
1867 }
1868
1869 /* Finish up dynamic symbol handling. We set the contents of various
1870 dynamic sections here. */
1871
1872 static boolean
1873 sparc64_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
1874 bfd *output_bfd;
1875 struct bfd_link_info *info;
1876 struct elf_link_hash_entry *h;
1877 Elf_Internal_Sym *sym;
1878 {
1879 bfd *dynobj;
1880
1881 dynobj = elf_hash_table (info)->dynobj;
1882
1883 if (h->plt.offset != (bfd_vma) -1)
1884 {
1885 asection *splt;
1886 asection *srela;
1887 Elf_Internal_Rela rela;
1888
1889 /* This symbol has an entry in the PLT. Set it up. */
1890
1891 BFD_ASSERT (h->dynindx != -1);
1892
1893 splt = bfd_get_section_by_name (dynobj, ".plt");
1894 srela = bfd_get_section_by_name (dynobj, ".rela.plt");
1895 BFD_ASSERT (splt != NULL && srela != NULL);
1896
1897 /* Fill in the entry in the .rela.plt section. */
1898
1899 if (h->plt.offset < LARGE_PLT_THRESHOLD)
1900 {
1901 rela.r_offset = sparc64_elf_plt_entry_offset (h->plt.offset);
1902 rela.r_addend = 0;
1903 }
1904 else
1905 {
1906 int max = splt->_raw_size / PLT_ENTRY_SIZE;
1907 rela.r_offset = sparc64_elf_plt_ptr_offset (h->plt.offset, max);
1908 rela.r_addend = -(sparc64_elf_plt_entry_offset (h->plt.offset) + 4);
1909 }
1910 rela.r_offset += (splt->output_section->vma + splt->output_offset);
1911 rela.r_info = ELF64_R_INFO (h->dynindx, R_SPARC_JMP_SLOT);
1912
1913 bfd_elf64_swap_reloca_out (output_bfd, &rela,
1914 ((Elf64_External_Rela *) srela->contents
1915 + h->plt.offset));
1916
1917 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1918 {
1919 /* Mark the symbol as undefined, rather than as defined in
1920 the .plt section. Leave the value alone. */
1921 sym->st_shndx = SHN_UNDEF;
1922 }
1923 }
1924
1925 if (h->got.offset != (bfd_vma) -1)
1926 {
1927 asection *sgot;
1928 asection *srela;
1929 Elf_Internal_Rela rela;
1930
1931 /* This symbol has an entry in the GOT. Set it up. */
1932
1933 sgot = bfd_get_section_by_name (dynobj, ".got");
1934 srela = bfd_get_section_by_name (dynobj, ".rela.got");
1935 BFD_ASSERT (sgot != NULL && srela != NULL);
1936
1937 rela.r_offset = (sgot->output_section->vma
1938 + sgot->output_offset
1939 + (h->got.offset &~ 1));
1940
1941 /* If this is a -Bsymbolic link, and the symbol is defined
1942 locally, we just want to emit a RELATIVE reloc. Likewise if
1943 the symbol was forced to be local because of a version file.
1944 The entry in the global offset table will already have been
1945 initialized in the relocate_section function. */
1946 if (info->shared
1947 && (info->symbolic || h->dynindx == -1)
1948 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
1949 {
1950 asection *sec = h->root.u.def.section;
1951 rela.r_info = ELF64_R_INFO (0, R_SPARC_RELATIVE);
1952 rela.r_addend = (h->root.u.def.value
1953 + sec->output_section->vma
1954 + sec->output_offset);
1955 }
1956 else
1957 {
1958 bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
1959 rela.r_info = ELF64_R_INFO (h->dynindx, R_SPARC_GLOB_DAT);
1960 rela.r_addend = 0;
1961 }
1962
1963 bfd_elf64_swap_reloca_out (output_bfd, &rela,
1964 ((Elf64_External_Rela *) srela->contents
1965 + srela->reloc_count));
1966 ++srela->reloc_count;
1967 }
1968
1969 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
1970 {
1971 asection *s;
1972 Elf_Internal_Rela rela;
1973
1974 /* This symbols needs a copy reloc. Set it up. */
1975
1976 BFD_ASSERT (h->dynindx != -1);
1977
1978 s = bfd_get_section_by_name (h->root.u.def.section->owner,
1979 ".rela.bss");
1980 BFD_ASSERT (s != NULL);
1981
1982 rela.r_offset = (h->root.u.def.value
1983 + h->root.u.def.section->output_section->vma
1984 + h->root.u.def.section->output_offset);
1985 rela.r_info = ELF64_R_INFO (h->dynindx, R_SPARC_COPY);
1986 rela.r_addend = 0;
1987 bfd_elf64_swap_reloca_out (output_bfd, &rela,
1988 ((Elf64_External_Rela *) s->contents
1989 + s->reloc_count));
1990 ++s->reloc_count;
1991 }
1992
1993 /* Mark some specially defined symbols as absolute. */
1994 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
1995 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
1996 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
1997 sym->st_shndx = SHN_ABS;
1998
1999 return true;
2000 }
2001
2002 /* Finish up the dynamic sections. */
2003
2004 static boolean
2005 sparc64_elf_finish_dynamic_sections (output_bfd, info)
2006 bfd *output_bfd;
2007 struct bfd_link_info *info;
2008 {
2009 bfd *dynobj;
2010 asection *sdyn;
2011 asection *sgot;
2012
2013 dynobj = elf_hash_table (info)->dynobj;
2014
2015 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2016
2017 if (elf_hash_table (info)->dynamic_sections_created)
2018 {
2019 asection *splt;
2020 Elf64_External_Dyn *dyncon, *dynconend;
2021
2022 splt = bfd_get_section_by_name (dynobj, ".plt");
2023 BFD_ASSERT (splt != NULL && sdyn != NULL);
2024
2025 dyncon = (Elf64_External_Dyn *) sdyn->contents;
2026 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
2027 for (; dyncon < dynconend; dyncon++)
2028 {
2029 Elf_Internal_Dyn dyn;
2030 const char *name;
2031 boolean size;
2032
2033 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
2034
2035 switch (dyn.d_tag)
2036 {
2037 case DT_PLTGOT: name = ".plt"; size = false; break;
2038 case DT_PLTRELSZ: name = ".rela.plt"; size = true; break;
2039 case DT_JMPREL: name = ".rela.plt"; size = false; break;
2040 default: name = NULL; size = false; break;
2041 }
2042
2043 if (name != NULL)
2044 {
2045 asection *s;
2046
2047 s = bfd_get_section_by_name (output_bfd, name);
2048 if (s == NULL)
2049 dyn.d_un.d_val = 0;
2050 else
2051 {
2052 if (! size)
2053 dyn.d_un.d_ptr = s->vma;
2054 else
2055 {
2056 if (s->_cooked_size != 0)
2057 dyn.d_un.d_val = s->_cooked_size;
2058 else
2059 dyn.d_un.d_val = s->_raw_size;
2060 }
2061 }
2062 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2063 }
2064 }
2065
2066 /* Initialize the contents of the .plt section. */
2067 if (splt->_raw_size > 0)
2068 {
2069 sparc64_elf_build_plt(output_bfd, splt->contents,
2070 splt->_raw_size / PLT_ENTRY_SIZE);
2071 }
2072
2073 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
2074 PLT_ENTRY_SIZE;
2075 }
2076
2077 /* Set the first entry in the global offset table to the address of
2078 the dynamic section. */
2079 sgot = bfd_get_section_by_name (dynobj, ".got");
2080 BFD_ASSERT (sgot != NULL);
2081 if (sgot->_raw_size > 0)
2082 {
2083 if (sdyn == NULL)
2084 bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents);
2085 else
2086 bfd_put_64 (output_bfd,
2087 sdyn->output_section->vma + sdyn->output_offset,
2088 sgot->contents);
2089 }
2090
2091 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 8;
2092
2093 if (info->shared)
2094 {
2095 asection *sdynsym;
2096 asection *s;
2097 Elf_Internal_Sym sym;
2098 int c;
2099
2100 /* Set up the section symbols for the output sections. */
2101
2102 sdynsym = bfd_get_section_by_name (dynobj, ".dynsym");
2103 BFD_ASSERT (sdynsym != NULL);
2104
2105 sym.st_size = 0;
2106 sym.st_name = 0;
2107 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
2108 sym.st_other = 0;
2109
2110 c = 0;
2111 for (s = output_bfd->sections; s != NULL; s = s->next)
2112 {
2113 int indx;
2114
2115 if (elf_section_data (s)->dynindx == 0)
2116 continue;
2117
2118 sym.st_value = s->vma;
2119
2120 indx = elf_section_data (s)->this_idx;
2121 BFD_ASSERT (indx > 0);
2122 sym.st_shndx = indx;
2123
2124 bfd_elf64_swap_symbol_out (output_bfd, &sym,
2125 (PTR) (((Elf64_External_Sym *)
2126 sdynsym->contents)
2127 + elf_section_data (s)->dynindx));
2128
2129 ++c;
2130 }
2131
2132 /* Set the sh_info field of the output .dynsym section to the
2133 index of the first global symbol. */
2134 elf_section_data (sdynsym->output_section)->this_hdr.sh_info = c + 1;
2135 }
2136
2137 return true;
2138 }
2139 \f
2140 /* Functions for dealing with the e_flags field. */
2141
2142 /* Merge backend specific data from an object file to the output
2143 object file when linking. */
2144
2145 static boolean
2146 sparc64_elf_merge_private_bfd_data (ibfd, obfd)
2147 bfd *ibfd;
2148 bfd *obfd;
2149 {
2150 boolean error;
2151 flagword new_flags, old_flags;
2152 int new_mm, old_mm;
2153
2154 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2155 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2156 return true;
2157
2158 new_flags = elf_elfheader (ibfd)->e_flags;
2159 old_flags = elf_elfheader (obfd)->e_flags;
2160
2161 if (!elf_flags_init (obfd)) /* First call, no flags set */
2162 {
2163 elf_flags_init (obfd) = true;
2164 elf_elfheader (obfd)->e_flags = new_flags;
2165 }
2166
2167 else if (new_flags == old_flags) /* Compatible flags are ok */
2168 ;
2169
2170 else /* Incompatible flags */
2171 {
2172 error = false;
2173
2174 old_flags |= (new_flags & (EF_SPARC_SUN_US1|EF_SPARC_HAL_R1));
2175 new_flags |= (old_flags & (EF_SPARC_SUN_US1|EF_SPARC_HAL_R1));
2176 if ((old_flags & (EF_SPARC_SUN_US1|EF_SPARC_HAL_R1)) ==
2177 (EF_SPARC_SUN_US1|EF_SPARC_HAL_R1))
2178 {
2179 error = true;
2180 (*_bfd_error_handler)
2181 (_("%s: linking UltraSPARC specific with HAL specific code"),
2182 bfd_get_filename (ibfd));
2183 }
2184
2185 /* Choose the most restrictive memory ordering */
2186 old_mm = (old_flags & EF_SPARCV9_MM);
2187 new_mm = (new_flags & EF_SPARCV9_MM);
2188 old_flags &= ~EF_SPARCV9_MM;
2189 new_flags &= ~EF_SPARCV9_MM;
2190 if (new_mm < old_mm) old_mm = new_mm;
2191 old_flags |= old_mm;
2192 new_flags |= old_mm;
2193
2194 /* Warn about any other mismatches */
2195 if (new_flags != old_flags)
2196 {
2197 error = true;
2198 (*_bfd_error_handler)
2199 (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
2200 bfd_get_filename (ibfd), (long)new_flags, (long)old_flags);
2201 }
2202
2203 elf_elfheader (obfd)->e_flags = old_flags;
2204
2205 if (error)
2206 {
2207 bfd_set_error (bfd_error_bad_value);
2208 return false;
2209 }
2210 }
2211 return true;
2212 }
2213
2214 \f
2215 /* Set the right machine number for a SPARC64 ELF file. */
2216
2217 static boolean
2218 sparc64_elf_object_p (abfd)
2219 bfd *abfd;
2220 {
2221 unsigned long mach = bfd_mach_sparc_v9;
2222
2223 if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
2224 mach = bfd_mach_sparc_v9a;
2225 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, mach);
2226 }
2227
2228 #define TARGET_BIG_SYM bfd_elf64_sparc_vec
2229 #define TARGET_BIG_NAME "elf64-sparc"
2230 #define ELF_ARCH bfd_arch_sparc
2231 #define ELF_MAXPAGESIZE 0x100000
2232
2233 /* This is the official ABI value. */
2234 #define ELF_MACHINE_CODE EM_SPARCV9
2235
2236 /* This is the value that we used before the ABI was released. */
2237 #define ELF_MACHINE_ALT1 EM_OLD_SPARCV9
2238
2239 #define elf_info_to_howto \
2240 sparc64_elf_info_to_howto
2241 #define bfd_elf64_bfd_reloc_type_lookup \
2242 sparc64_elf_reloc_type_lookup
2243
2244 #define elf_backend_create_dynamic_sections \
2245 _bfd_elf_create_dynamic_sections
2246 #define elf_backend_check_relocs \
2247 sparc64_elf_check_relocs
2248 #define elf_backend_adjust_dynamic_symbol \
2249 sparc64_elf_adjust_dynamic_symbol
2250 #define elf_backend_size_dynamic_sections \
2251 sparc64_elf_size_dynamic_sections
2252 #define elf_backend_relocate_section \
2253 sparc64_elf_relocate_section
2254 #define elf_backend_finish_dynamic_symbol \
2255 sparc64_elf_finish_dynamic_symbol
2256 #define elf_backend_finish_dynamic_sections \
2257 sparc64_elf_finish_dynamic_sections
2258
2259 #define bfd_elf64_bfd_merge_private_bfd_data \
2260 sparc64_elf_merge_private_bfd_data
2261
2262 #define elf_backend_object_p \
2263 sparc64_elf_object_p
2264
2265 #define elf_backend_want_got_plt 0
2266 #define elf_backend_plt_readonly 0
2267 #define elf_backend_want_plt_sym 1
2268
2269 /* Section 5.2.4 of the ABI specifies a 256-byte boundary for the table. */
2270 #define elf_backend_plt_alignment 8
2271
2272 #define elf_backend_got_header_size 8
2273 #define elf_backend_plt_header_size PLT_HEADER_SIZE
2274
2275 #include "elf64-target.h"
git-cvsimport of binutils cvsroot