projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Add hdynamic to elf_link_hash_table for _DYNAMIC
[deliverable/binutils-gdb.git] / bfd / elfxx-sparc.c
1 /* SPARC-specific support for ELF
2 Copyright 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
3 Free Software Foundation, Inc.
4
5 This file is part of BFD, the Binary File Descriptor library.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
21
22
23 /* This file handles functionality common to the different SPARC ABI's. */
24
25 #include "sysdep.h"
26 #include "bfd.h"
27 #include "bfdlink.h"
28 #include "libbfd.h"
29 #include "libiberty.h"
30 #include "elf-bfd.h"
31 #include "elf/sparc.h"
32 #include "opcode/sparc.h"
33 #include "elfxx-sparc.h"
34 #include "elf-vxworks.h"
35 #include "objalloc.h"
36 #include "hashtab.h"
37
38 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
39 #define MINUS_ONE (~ (bfd_vma) 0)
40
41 #define ABI_64_P(abfd) \
42 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
43
44 /* The relocation "howto" table. */
45
46 /* Utility for performing the standard initial work of an instruction
47 relocation.
48 *PRELOCATION will contain the relocated item.
49 *PINSN will contain the instruction from the input stream.
50 If the result is `bfd_reloc_other' the caller can continue with
51 performing the relocation. Otherwise it must stop and return the
52 value to its caller. */
53
54 static bfd_reloc_status_type
55 init_insn_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
56 void * data, asection *input_section, bfd *output_bfd,
57 bfd_vma *prelocation, bfd_vma *pinsn)
58 {
59 bfd_vma relocation;
60 reloc_howto_type *howto = reloc_entry->howto;
61
62 if (output_bfd != (bfd *) NULL
63 && (symbol->flags & BSF_SECTION_SYM) == 0
64 && (! howto->partial_inplace
65 || reloc_entry->addend == 0))
66 {
67 reloc_entry->address += input_section->output_offset;
68 return bfd_reloc_ok;
69 }
70
71 /* This works because partial_inplace is FALSE. */
72 if (output_bfd != NULL)
73 return bfd_reloc_continue;
74
75 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
76 return bfd_reloc_outofrange;
77
78 relocation = (symbol->value
79 + symbol->section->output_section->vma
80 + symbol->section->output_offset);
81 relocation += reloc_entry->addend;
82 if (howto->pc_relative)
83 {
84 relocation -= (input_section->output_section->vma
85 + input_section->output_offset);
86 relocation -= reloc_entry->address;
87 }
88
89 *prelocation = relocation;
90 *pinsn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
91 return bfd_reloc_other;
92 }
93
94 /* For unsupported relocs. */
95
96 static bfd_reloc_status_type
97 sparc_elf_notsup_reloc (bfd *abfd ATTRIBUTE_UNUSED,
98 arelent *reloc_entry ATTRIBUTE_UNUSED,
99 asymbol *symbol ATTRIBUTE_UNUSED,
100 void * data ATTRIBUTE_UNUSED,
101 asection *input_section ATTRIBUTE_UNUSED,
102 bfd *output_bfd ATTRIBUTE_UNUSED,
103 char **error_message ATTRIBUTE_UNUSED)
104 {
105 return bfd_reloc_notsupported;
106 }
107
108 /* Handle the WDISP16 reloc. */
109
110 static bfd_reloc_status_type
111 sparc_elf_wdisp16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
112 void * data, asection *input_section, bfd *output_bfd,
113 char **error_message ATTRIBUTE_UNUSED)
114 {
115 bfd_vma relocation;
116 bfd_vma insn;
117 bfd_reloc_status_type status;
118
119 status = init_insn_reloc (abfd, reloc_entry, symbol, data,
120 input_section, output_bfd, &relocation, &insn);
121 if (status != bfd_reloc_other)
122 return status;
123
124 insn &= ~ (bfd_vma) 0x303fff;
125 insn |= (((relocation >> 2) & 0xc000) << 6) | ((relocation >> 2) & 0x3fff);
126 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
127
128 if ((bfd_signed_vma) relocation < - 0x40000
129 || (bfd_signed_vma) relocation > 0x3ffff)
130 return bfd_reloc_overflow;
131 else
132 return bfd_reloc_ok;
133 }
134
135 /* Handle the WDISP10 reloc. */
136
137 static bfd_reloc_status_type
138 sparc_elf_wdisp10_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
139 void * data, asection *input_section, bfd *output_bfd,
140 char **error_message ATTRIBUTE_UNUSED)
141 {
142 bfd_vma relocation;
143 bfd_vma insn;
144 bfd_reloc_status_type status;
145
146 status = init_insn_reloc (abfd, reloc_entry, symbol, data,
147 input_section, output_bfd, &relocation, &insn);
148 if (status != bfd_reloc_other)
149 return status;
150
151 insn &= ~ (bfd_vma) 0x181fe0;
152 insn |= (((relocation >> 2) & 0x300) << 11)
153 | (((relocation >> 2) & 0xff) << 5);
154 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
155
156 if ((bfd_signed_vma) relocation < - 0x1000
157 || (bfd_signed_vma) relocation > 0xfff)
158 return bfd_reloc_overflow;
159 else
160 return bfd_reloc_ok;
161 }
162
163 /* Handle the HIX22 reloc. */
164
165 static bfd_reloc_status_type
166 sparc_elf_hix22_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
167 void * data, asection *input_section, bfd *output_bfd,
168 char **error_message ATTRIBUTE_UNUSED)
169 {
170 bfd_vma relocation;
171 bfd_vma insn;
172 bfd_reloc_status_type status;
173
174 status = init_insn_reloc (abfd, reloc_entry, symbol, data,
175 input_section, output_bfd, &relocation, &insn);
176 if (status != bfd_reloc_other)
177 return status;
178
179 relocation ^= MINUS_ONE;
180 insn = (insn &~ (bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
181 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
182
183 if ((relocation & ~ (bfd_vma) 0xffffffff) != 0)
184 return bfd_reloc_overflow;
185 else
186 return bfd_reloc_ok;
187 }
188
189 /* Handle the LOX10 reloc. */
190
191 static bfd_reloc_status_type
192 sparc_elf_lox10_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
193 void * data, asection *input_section, bfd *output_bfd,
194 char **error_message ATTRIBUTE_UNUSED)
195 {
196 bfd_vma relocation;
197 bfd_vma insn;
198 bfd_reloc_status_type status;
199
200 status = init_insn_reloc (abfd, reloc_entry, symbol, data,
201 input_section, output_bfd, &relocation, &insn);
202 if (status != bfd_reloc_other)
203 return status;
204
205 insn = (insn &~ (bfd_vma) 0x1fff) | 0x1c00 | (relocation & 0x3ff);
206 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
207
208 return bfd_reloc_ok;
209 }
210
211 static reloc_howto_type _bfd_sparc_elf_howto_table[] =
212 {
213 HOWTO(R_SPARC_NONE, 0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", FALSE,0,0x00000000,TRUE),
214 HOWTO(R_SPARC_8, 0,0, 8,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_8", FALSE,0,0x000000ff,TRUE),
215 HOWTO(R_SPARC_16, 0,1,16,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_16", FALSE,0,0x0000ffff,TRUE),
216 HOWTO(R_SPARC_32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_32", FALSE,0,0xffffffff,TRUE),
217 HOWTO(R_SPARC_DISP8, 0,0, 8,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP8", FALSE,0,0x000000ff,TRUE),
218 HOWTO(R_SPARC_DISP16, 0,1,16,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP16", FALSE,0,0x0000ffff,TRUE),
219 HOWTO(R_SPARC_DISP32, 0,2,32,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP32", FALSE,0,0xffffffff,TRUE),
220 HOWTO(R_SPARC_WDISP30, 2,2,30,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP30", FALSE,0,0x3fffffff,TRUE),
221 HOWTO(R_SPARC_WDISP22, 2,2,22,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP22", FALSE,0,0x003fffff,TRUE),
222 HOWTO(R_SPARC_HI22, 10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_HI22", FALSE,0,0x003fffff,TRUE),
223 HOWTO(R_SPARC_22, 0,2,22,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_22", FALSE,0,0x003fffff,TRUE),
224 HOWTO(R_SPARC_13, 0,2,13,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_13", FALSE,0,0x00001fff,TRUE),
225 HOWTO(R_SPARC_LO10, 0,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_LO10", FALSE,0,0x000003ff,TRUE),
226 HOWTO(R_SPARC_GOT10, 0,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOT10", FALSE,0,0x000003ff,TRUE),
227 HOWTO(R_SPARC_GOT13, 0,2,13,FALSE,0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_GOT13", FALSE,0,0x00001fff,TRUE),
228 HOWTO(R_SPARC_GOT22, 10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOT22", FALSE,0,0x003fffff,TRUE),
229 HOWTO(R_SPARC_PC10, 0,2,10,TRUE, 0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_PC10", FALSE,0,0x000003ff,TRUE),
230 HOWTO(R_SPARC_PC22, 10,2,22,TRUE, 0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_PC22", FALSE,0,0x003fffff,TRUE),
231 HOWTO(R_SPARC_WPLT30, 2,2,30,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WPLT30", FALSE,0,0x3fffffff,TRUE),
232 HOWTO(R_SPARC_COPY, 0,0,00,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_COPY", FALSE,0,0x00000000,TRUE),
233 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),
234 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),
235 HOWTO(R_SPARC_RELATIVE, 0,0,00,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_RELATIVE",FALSE,0,0x00000000,TRUE),
236 HOWTO(R_SPARC_UA32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA32", FALSE,0,0xffffffff,TRUE),
237 HOWTO(R_SPARC_PLT32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_PLT32", FALSE,0,0xffffffff,TRUE),
238 HOWTO(R_SPARC_HIPLT22, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_HIPLT22", FALSE,0,0x00000000,TRUE),
239 HOWTO(R_SPARC_LOPLT10, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_LOPLT10", FALSE,0,0x00000000,TRUE),
240 HOWTO(R_SPARC_PCPLT32, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PCPLT32", FALSE,0,0x00000000,TRUE),
241 HOWTO(R_SPARC_PCPLT22, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PCPLT22", FALSE,0,0x00000000,TRUE),
242 HOWTO(R_SPARC_PCPLT10, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PCPLT10", FALSE,0,0x00000000,TRUE),
243 HOWTO(R_SPARC_10, 0,2,10,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_10", FALSE,0,0x000003ff,TRUE),
244 HOWTO(R_SPARC_11, 0,2,11,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_11", FALSE,0,0x000007ff,TRUE),
245 HOWTO(R_SPARC_64, 0,4,64,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_64", FALSE,0,MINUS_ONE, TRUE),
246 HOWTO(R_SPARC_OLO10, 0,2,13,FALSE,0,complain_overflow_signed, sparc_elf_notsup_reloc, "R_SPARC_OLO10", FALSE,0,0x00001fff,TRUE),
247 HOWTO(R_SPARC_HH22, 42,2,22,FALSE,0,complain_overflow_unsigned,bfd_elf_generic_reloc, "R_SPARC_HH22", FALSE,0,0x003fffff,TRUE),
248 HOWTO(R_SPARC_HM10, 32,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_HM10", FALSE,0,0x000003ff,TRUE),
249 HOWTO(R_SPARC_LM22, 10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_LM22", FALSE,0,0x003fffff,TRUE),
250 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),
251 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),
252 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),
253 HOWTO(R_SPARC_WDISP16, 2,2,16,TRUE, 0,complain_overflow_signed, sparc_elf_wdisp16_reloc,"R_SPARC_WDISP16", FALSE,0,0x00000000,TRUE),
254 HOWTO(R_SPARC_WDISP19, 2,2,19,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP19", FALSE,0,0x0007ffff,TRUE),
255 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),
256 HOWTO(R_SPARC_7, 0,2, 7,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_7", FALSE,0,0x0000007f,TRUE),
257 HOWTO(R_SPARC_5, 0,2, 5,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_5", FALSE,0,0x0000001f,TRUE),
258 HOWTO(R_SPARC_6, 0,2, 6,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_6", FALSE,0,0x0000003f,TRUE),
259 HOWTO(R_SPARC_DISP64, 0,4,64,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP64", FALSE,0,MINUS_ONE, TRUE),
260 HOWTO(R_SPARC_PLT64, 0,4,64,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_PLT64", FALSE,0,MINUS_ONE, TRUE),
261 HOWTO(R_SPARC_HIX22, 0,4, 0,FALSE,0,complain_overflow_bitfield,sparc_elf_hix22_reloc, "R_SPARC_HIX22", FALSE,0,MINUS_ONE, FALSE),
262 HOWTO(R_SPARC_LOX10, 0,4, 0,FALSE,0,complain_overflow_dont, sparc_elf_lox10_reloc, "R_SPARC_LOX10", FALSE,0,MINUS_ONE, FALSE),
263 HOWTO(R_SPARC_H44, 22,2,22,FALSE,0,complain_overflow_unsigned,bfd_elf_generic_reloc, "R_SPARC_H44", FALSE,0,0x003fffff,FALSE),
264 HOWTO(R_SPARC_M44, 12,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_M44", FALSE,0,0x000003ff,FALSE),
265 HOWTO(R_SPARC_L44, 0,2,13,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_L44", FALSE,0,0x00000fff,FALSE),
266 HOWTO(R_SPARC_REGISTER, 0,4, 0,FALSE,0,complain_overflow_bitfield,sparc_elf_notsup_reloc, "R_SPARC_REGISTER",FALSE,0,MINUS_ONE, FALSE),
267 HOWTO(R_SPARC_UA64, 0,4,64,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA64", FALSE,0,MINUS_ONE, TRUE),
268 HOWTO(R_SPARC_UA16, 0,1,16,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA16", FALSE,0,0x0000ffff,TRUE),
269 HOWTO(R_SPARC_TLS_GD_HI22,10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_GD_HI22",FALSE,0,0x003fffff,TRUE),
270 HOWTO(R_SPARC_TLS_GD_LO10,0,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_GD_LO10",FALSE,0,0x000003ff,TRUE),
271 HOWTO(R_SPARC_TLS_GD_ADD,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_GD_ADD",FALSE,0,0x00000000,TRUE),
272 HOWTO(R_SPARC_TLS_GD_CALL,2,2,30,TRUE,0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_TLS_GD_CALL",FALSE,0,0x3fffffff,TRUE),
273 HOWTO(R_SPARC_TLS_LDM_HI22,10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_LDM_HI22",FALSE,0,0x003fffff,TRUE),
274 HOWTO(R_SPARC_TLS_LDM_LO10,0,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_LDM_LO10",FALSE,0,0x000003ff,TRUE),
275 HOWTO(R_SPARC_TLS_LDM_ADD,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_LDM_ADD",FALSE,0,0x00000000,TRUE),
276 HOWTO(R_SPARC_TLS_LDM_CALL,2,2,30,TRUE,0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_TLS_LDM_CALL",FALSE,0,0x3fffffff,TRUE),
277 HOWTO(R_SPARC_TLS_LDO_HIX22,0,2,0,FALSE,0,complain_overflow_bitfield,sparc_elf_hix22_reloc,"R_SPARC_TLS_LDO_HIX22",FALSE,0,0x003fffff, FALSE),
278 HOWTO(R_SPARC_TLS_LDO_LOX10,0,2,0,FALSE,0,complain_overflow_dont, sparc_elf_lox10_reloc, "R_SPARC_TLS_LDO_LOX10",FALSE,0,0x000003ff, FALSE),
279 HOWTO(R_SPARC_TLS_LDO_ADD,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_LDO_ADD",FALSE,0,0x00000000,TRUE),
280 HOWTO(R_SPARC_TLS_IE_HI22,10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_IE_HI22",FALSE,0,0x003fffff,TRUE),
281 HOWTO(R_SPARC_TLS_IE_LO10,0,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_IE_LO10",FALSE,0,0x000003ff,TRUE),
282 HOWTO(R_SPARC_TLS_IE_LD,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_IE_LD",FALSE,0,0x00000000,TRUE),
283 HOWTO(R_SPARC_TLS_IE_LDX,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_IE_LDX",FALSE,0,0x00000000,TRUE),
284 HOWTO(R_SPARC_TLS_IE_ADD,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_IE_ADD",FALSE,0,0x00000000,TRUE),
285 HOWTO(R_SPARC_TLS_LE_HIX22,0,2,0,FALSE,0,complain_overflow_bitfield,sparc_elf_hix22_reloc, "R_SPARC_TLS_LE_HIX22",FALSE,0,0x003fffff, FALSE),
286 HOWTO(R_SPARC_TLS_LE_LOX10,0,2,0,FALSE,0,complain_overflow_dont, sparc_elf_lox10_reloc, "R_SPARC_TLS_LE_LOX10",FALSE,0,0x000003ff, FALSE),
287 HOWTO(R_SPARC_TLS_DTPMOD32,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_DTPMOD32",FALSE,0,0x00000000,TRUE),
288 HOWTO(R_SPARC_TLS_DTPMOD64,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_DTPMOD64",FALSE,0,0x00000000,TRUE),
289 HOWTO(R_SPARC_TLS_DTPOFF32,0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,"R_SPARC_TLS_DTPOFF32",FALSE,0,0xffffffff,TRUE),
290 HOWTO(R_SPARC_TLS_DTPOFF64,0,4,64,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,"R_SPARC_TLS_DTPOFF64",FALSE,0,MINUS_ONE,TRUE),
291 HOWTO(R_SPARC_TLS_TPOFF32,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_TPOFF32",FALSE,0,0x00000000,TRUE),
292 HOWTO(R_SPARC_TLS_TPOFF64,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_TPOFF64",FALSE,0,0x00000000,TRUE),
293 HOWTO(R_SPARC_GOTDATA_HIX22,0,2,0,FALSE,0,complain_overflow_bitfield,sparc_elf_hix22_reloc,"R_SPARC_GOTDATA_HIX22",FALSE,0,0x003fffff, FALSE),
294 HOWTO(R_SPARC_GOTDATA_LOX10,0,2,0,FALSE,0,complain_overflow_dont, sparc_elf_lox10_reloc, "R_SPARC_GOTDATA_LOX10",FALSE,0,0x000003ff, FALSE),
295 HOWTO(R_SPARC_GOTDATA_OP_HIX22,0,2,0,FALSE,0,complain_overflow_bitfield,sparc_elf_hix22_reloc,"R_SPARC_GOTDATA_OP_HIX22",FALSE,0,0x003fffff, FALSE),
296 HOWTO(R_SPARC_GOTDATA_OP_LOX10,0,2,0,FALSE,0,complain_overflow_dont, sparc_elf_lox10_reloc, "R_SPARC_GOTDATA_OP_LOX10",FALSE,0,0x000003ff, FALSE),
297 HOWTO(R_SPARC_GOTDATA_OP,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOTDATA_OP",FALSE,0,0x00000000,TRUE),
298 HOWTO(R_SPARC_H34,12,2,22,FALSE,0,complain_overflow_unsigned,bfd_elf_generic_reloc,"R_SPARC_H34",FALSE,0,0x003fffff,FALSE),
299 HOWTO(R_SPARC_SIZE32,0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,"R_SPARC_SIZE32",FALSE,0,0xffffffff,TRUE),
300 HOWTO(R_SPARC_SIZE64,0,4,64,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,"R_SPARC_SIZE64",FALSE,0,MINUS_ONE, TRUE),
301 HOWTO(R_SPARC_WDISP10,2,2,10,TRUE, 0,complain_overflow_signed,sparc_elf_wdisp10_reloc,"R_SPARC_WDISP10",FALSE,0,0x00000000,TRUE),
302 };
303 static reloc_howto_type sparc_jmp_irel_howto =
304 HOWTO(R_SPARC_JMP_IREL, 0,0,00,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_JMP_IREL",FALSE,0,0x00000000,TRUE);
305 static reloc_howto_type sparc_irelative_howto =
306 HOWTO(R_SPARC_IRELATIVE, 0,0,00,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_IRELATIVE",FALSE,0,0x00000000,TRUE);
307 static reloc_howto_type sparc_vtinherit_howto =
308 HOWTO (R_SPARC_GNU_VTINHERIT, 0,2,0,FALSE,0,complain_overflow_dont, NULL, "R_SPARC_GNU_VTINHERIT", FALSE,0, 0, FALSE);
309 static reloc_howto_type sparc_vtentry_howto =
310 HOWTO (R_SPARC_GNU_VTENTRY, 0,2,0,FALSE,0,complain_overflow_dont, _bfd_elf_rel_vtable_reloc_fn,"R_SPARC_GNU_VTENTRY", FALSE,0,0, FALSE);
311 static reloc_howto_type sparc_rev32_howto =
312 HOWTO(R_SPARC_REV32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_REV32", FALSE,0,0xffffffff,TRUE);
313
314 reloc_howto_type *
315 _bfd_sparc_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
316 bfd_reloc_code_real_type code)
317 {
318 /* We explicitly handle each relocation type in the switch
319 instead of using a lookup table for efficiency. */
320 switch (code)
321 {
322 case BFD_RELOC_NONE:
323 return &_bfd_sparc_elf_howto_table[R_SPARC_NONE];
324
325 case BFD_RELOC_8:
326 return &_bfd_sparc_elf_howto_table[R_SPARC_8];
327
328 case BFD_RELOC_16:
329 return &_bfd_sparc_elf_howto_table[R_SPARC_16];
330
331 case BFD_RELOC_32:
332 return &_bfd_sparc_elf_howto_table[R_SPARC_32];
333
334 case BFD_RELOC_8_PCREL:
335 return &_bfd_sparc_elf_howto_table[R_SPARC_DISP8];
336
337 case BFD_RELOC_16_PCREL:
338 return &_bfd_sparc_elf_howto_table[R_SPARC_DISP16];
339
340 case BFD_RELOC_32_PCREL:
341 return &_bfd_sparc_elf_howto_table[R_SPARC_DISP32];
342
343 case BFD_RELOC_32_PCREL_S2:
344 return &_bfd_sparc_elf_howto_table[R_SPARC_WDISP30];
345
346 case BFD_RELOC_SPARC_WDISP22:
347 return &_bfd_sparc_elf_howto_table[R_SPARC_WDISP22];
348
349 case BFD_RELOC_HI22:
350 return &_bfd_sparc_elf_howto_table[R_SPARC_HI22];
351
352 case BFD_RELOC_SPARC22:
353 return &_bfd_sparc_elf_howto_table[R_SPARC_22];
354
355 case BFD_RELOC_SPARC13:
356 return &_bfd_sparc_elf_howto_table[R_SPARC_13];
357
358 case BFD_RELOC_LO10:
359 return &_bfd_sparc_elf_howto_table[R_SPARC_LO10];
360
361 case BFD_RELOC_SPARC_GOT10:
362 return &_bfd_sparc_elf_howto_table[R_SPARC_GOT10];
363
364 case BFD_RELOC_SPARC_GOT13:
365 return &_bfd_sparc_elf_howto_table[R_SPARC_GOT13];
366
367 case BFD_RELOC_SPARC_GOT22:
368 return &_bfd_sparc_elf_howto_table[R_SPARC_GOT22];
369
370 case BFD_RELOC_SPARC_PC10:
371 return &_bfd_sparc_elf_howto_table[R_SPARC_PC10];
372
373 case BFD_RELOC_SPARC_PC22:
374 return &_bfd_sparc_elf_howto_table[R_SPARC_PC22];
375
376 case BFD_RELOC_SPARC_WPLT30:
377 return &_bfd_sparc_elf_howto_table[R_SPARC_WPLT30];
378
379 case BFD_RELOC_SPARC_COPY:
380 return &_bfd_sparc_elf_howto_table[R_SPARC_COPY];
381
382 case BFD_RELOC_SPARC_GLOB_DAT:
383 return &_bfd_sparc_elf_howto_table[R_SPARC_GLOB_DAT];
384
385 case BFD_RELOC_SPARC_JMP_SLOT:
386 return &_bfd_sparc_elf_howto_table[R_SPARC_JMP_SLOT];
387
388 case BFD_RELOC_SPARC_RELATIVE:
389 return &_bfd_sparc_elf_howto_table[R_SPARC_RELATIVE];
390
391 case BFD_RELOC_SPARC_UA32:
392 return &_bfd_sparc_elf_howto_table[R_SPARC_UA32];
393
394 case BFD_RELOC_SPARC_PLT32:
395 return &_bfd_sparc_elf_howto_table[R_SPARC_PLT32];
396
397 case BFD_RELOC_SPARC_10:
398 return &_bfd_sparc_elf_howto_table[R_SPARC_10];
399
400 case BFD_RELOC_SPARC_11:
401 return &_bfd_sparc_elf_howto_table[R_SPARC_11];
402
403 case BFD_RELOC_SPARC_64:
404 return &_bfd_sparc_elf_howto_table[R_SPARC_64];
405
406 case BFD_RELOC_SPARC_OLO10:
407 return &_bfd_sparc_elf_howto_table[R_SPARC_OLO10];
408
409 case BFD_RELOC_SPARC_HH22:
410 return &_bfd_sparc_elf_howto_table[R_SPARC_HH22];
411
412 case BFD_RELOC_SPARC_HM10:
413 return &_bfd_sparc_elf_howto_table[R_SPARC_HM10];
414
415 case BFD_RELOC_SPARC_LM22:
416 return &_bfd_sparc_elf_howto_table[R_SPARC_LM22];
417
418 case BFD_RELOC_SPARC_PC_HH22:
419 return &_bfd_sparc_elf_howto_table[R_SPARC_PC_HH22];
420
421 case BFD_RELOC_SPARC_PC_HM10:
422 return &_bfd_sparc_elf_howto_table[R_SPARC_PC_HM10];
423
424 case BFD_RELOC_SPARC_PC_LM22:
425 return &_bfd_sparc_elf_howto_table[R_SPARC_PC_LM22];
426
427 case BFD_RELOC_SPARC_WDISP16:
428 return &_bfd_sparc_elf_howto_table[R_SPARC_WDISP16];
429
430 case BFD_RELOC_SPARC_WDISP19:
431 return &_bfd_sparc_elf_howto_table[R_SPARC_WDISP19];
432
433 case BFD_RELOC_SPARC_7:
434 return &_bfd_sparc_elf_howto_table[R_SPARC_7];
435
436 case BFD_RELOC_SPARC_5:
437 return &_bfd_sparc_elf_howto_table[R_SPARC_5];
438
439 case BFD_RELOC_SPARC_6:
440 return &_bfd_sparc_elf_howto_table[R_SPARC_6];
441
442 case BFD_RELOC_SPARC_DISP64:
443 return &_bfd_sparc_elf_howto_table[R_SPARC_DISP64];
444
445 case BFD_RELOC_SPARC_PLT64:
446 return &_bfd_sparc_elf_howto_table[R_SPARC_PLT64];
447
448 case BFD_RELOC_SPARC_HIX22:
449 return &_bfd_sparc_elf_howto_table[R_SPARC_HIX22];
450
451 case BFD_RELOC_SPARC_LOX10:
452 return &_bfd_sparc_elf_howto_table[R_SPARC_LOX10];
453
454 case BFD_RELOC_SPARC_H44:
455 return &_bfd_sparc_elf_howto_table[R_SPARC_H44];
456
457 case BFD_RELOC_SPARC_M44:
458 return &_bfd_sparc_elf_howto_table[R_SPARC_M44];
459
460 case BFD_RELOC_SPARC_L44:
461 return &_bfd_sparc_elf_howto_table[R_SPARC_L44];
462
463 case BFD_RELOC_SPARC_REGISTER:
464 return &_bfd_sparc_elf_howto_table[R_SPARC_REGISTER];
465
466 case BFD_RELOC_SPARC_UA64:
467 return &_bfd_sparc_elf_howto_table[R_SPARC_UA64];
468
469 case BFD_RELOC_SPARC_UA16:
470 return &_bfd_sparc_elf_howto_table[R_SPARC_UA16];
471
472 case BFD_RELOC_SPARC_TLS_GD_HI22:
473 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_GD_HI22];
474
475 case BFD_RELOC_SPARC_TLS_GD_LO10:
476 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_GD_LO10];
477
478 case BFD_RELOC_SPARC_TLS_GD_ADD:
479 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_GD_ADD];
480
481 case BFD_RELOC_SPARC_TLS_GD_CALL:
482 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_GD_CALL];
483
484 case BFD_RELOC_SPARC_TLS_LDM_HI22:
485 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDM_HI22];
486
487 case BFD_RELOC_SPARC_TLS_LDM_LO10:
488 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDM_LO10];
489
490 case BFD_RELOC_SPARC_TLS_LDM_ADD:
491 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDM_ADD];
492
493 case BFD_RELOC_SPARC_TLS_LDM_CALL:
494 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDM_CALL];
495
496 case BFD_RELOC_SPARC_TLS_LDO_HIX22:
497 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDO_HIX22];
498
499 case BFD_RELOC_SPARC_TLS_LDO_LOX10:
500 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDO_LOX10];
501
502 case BFD_RELOC_SPARC_TLS_LDO_ADD:
503 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDO_ADD];
504
505 case BFD_RELOC_SPARC_TLS_IE_HI22:
506 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_IE_HI22];
507
508 case BFD_RELOC_SPARC_TLS_IE_LO10:
509 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_IE_LO10];
510
511 case BFD_RELOC_SPARC_TLS_IE_LD:
512 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_IE_LD];
513
514 case BFD_RELOC_SPARC_TLS_IE_LDX:
515 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_IE_LDX];
516
517 case BFD_RELOC_SPARC_TLS_IE_ADD:
518 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_IE_ADD];
519
520 case BFD_RELOC_SPARC_TLS_LE_HIX22:
521 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LE_HIX22];
522
523 case BFD_RELOC_SPARC_TLS_LE_LOX10:
524 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LE_LOX10];
525
526 case BFD_RELOC_SPARC_TLS_DTPMOD32:
527 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_DTPMOD32];
528
529 case BFD_RELOC_SPARC_TLS_DTPMOD64:
530 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_DTPMOD64];
531
532 case BFD_RELOC_SPARC_TLS_DTPOFF32:
533 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_DTPOFF32];
534
535 case BFD_RELOC_SPARC_TLS_DTPOFF64:
536 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_DTPOFF64];
537
538 case BFD_RELOC_SPARC_TLS_TPOFF32:
539 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_TPOFF32];
540
541 case BFD_RELOC_SPARC_TLS_TPOFF64:
542 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_TPOFF64];
543
544 case BFD_RELOC_SPARC_GOTDATA_HIX22:
545 return &_bfd_sparc_elf_howto_table[R_SPARC_GOTDATA_HIX22];
546
547 case BFD_RELOC_SPARC_GOTDATA_LOX10:
548 return &_bfd_sparc_elf_howto_table[R_SPARC_GOTDATA_LOX10];
549
550 case BFD_RELOC_SPARC_GOTDATA_OP_HIX22:
551 return &_bfd_sparc_elf_howto_table[R_SPARC_GOTDATA_OP_HIX22];
552
553 case BFD_RELOC_SPARC_GOTDATA_OP_LOX10:
554 return &_bfd_sparc_elf_howto_table[R_SPARC_GOTDATA_OP_LOX10];
555
556 case BFD_RELOC_SPARC_GOTDATA_OP:
557 return &_bfd_sparc_elf_howto_table[R_SPARC_GOTDATA_OP];
558
559 case BFD_RELOC_SPARC_H34:
560 return &_bfd_sparc_elf_howto_table[R_SPARC_H34];
561
562 case BFD_RELOC_SPARC_SIZE32:
563 return &_bfd_sparc_elf_howto_table[R_SPARC_SIZE32];
564
565 case BFD_RELOC_SPARC_SIZE64:
566 return &_bfd_sparc_elf_howto_table[R_SPARC_SIZE64];
567
568 case BFD_RELOC_SPARC_WDISP10:
569 return &_bfd_sparc_elf_howto_table[R_SPARC_WDISP10];
570
571 case BFD_RELOC_SPARC_JMP_IREL:
572 return &sparc_jmp_irel_howto;
573
574 case BFD_RELOC_SPARC_IRELATIVE:
575 return &sparc_irelative_howto;
576
577 case BFD_RELOC_VTABLE_INHERIT:
578 return &sparc_vtinherit_howto;
579
580 case BFD_RELOC_VTABLE_ENTRY:
581 return &sparc_vtentry_howto;
582
583 case BFD_RELOC_SPARC_REV32:
584 return &sparc_rev32_howto;
585
586 default:
587 break;
588 }
589 bfd_set_error (bfd_error_bad_value);
590 return NULL;
591 }
592
593 reloc_howto_type *
594 _bfd_sparc_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
595 const char *r_name)
596 {
597 unsigned int i;
598
599 for (i = 0;
600 i < (sizeof (_bfd_sparc_elf_howto_table)
601 / sizeof (_bfd_sparc_elf_howto_table[0]));
602 i++)
603 if (_bfd_sparc_elf_howto_table[i].name != NULL
604 && strcasecmp (_bfd_sparc_elf_howto_table[i].name, r_name) == 0)
605 return &_bfd_sparc_elf_howto_table[i];
606
607 if (strcasecmp (sparc_vtinherit_howto.name, r_name) == 0)
608 return &sparc_vtinherit_howto;
609 if (strcasecmp (sparc_vtentry_howto.name, r_name) == 0)
610 return &sparc_vtentry_howto;
611 if (strcasecmp (sparc_rev32_howto.name, r_name) == 0)
612 return &sparc_rev32_howto;
613
614 return NULL;
615 }
616
617 reloc_howto_type *
618 _bfd_sparc_elf_info_to_howto_ptr (unsigned int r_type)
619 {
620 switch (r_type)
621 {
622 case R_SPARC_JMP_IREL:
623 return &sparc_jmp_irel_howto;
624
625 case R_SPARC_IRELATIVE:
626 return &sparc_irelative_howto;
627
628 case R_SPARC_GNU_VTINHERIT:
629 return &sparc_vtinherit_howto;
630
631 case R_SPARC_GNU_VTENTRY:
632 return &sparc_vtentry_howto;
633
634 case R_SPARC_REV32:
635 return &sparc_rev32_howto;
636
637 default:
638 if (r_type >= (unsigned int) R_SPARC_max_std)
639 {
640 (*_bfd_error_handler) (_("invalid relocation type %d"),
641 (int) r_type);
642 r_type = R_SPARC_NONE;
643 }
644 return &_bfd_sparc_elf_howto_table[r_type];
645 }
646 }
647
648 /* Both 32-bit and 64-bit sparc encode this in an identical manner,
649 so just take advantage of that. */
650 #define SPARC_ELF_R_TYPE(r_info) \
651 ((r_info) & 0xff)
652
653 void
654 _bfd_sparc_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
655 Elf_Internal_Rela *dst)
656 {
657 unsigned int r_type = SPARC_ELF_R_TYPE (dst->r_info);
658
659 cache_ptr->howto = _bfd_sparc_elf_info_to_howto_ptr (r_type);
660 }
661 \f
662
663 /* The nop opcode we use. */
664 #define SPARC_NOP 0x01000000
665
666 #define SPARC_INSN_BYTES 4
667
668 /* The SPARC linker needs to keep track of the number of relocs that it
669 decides to copy as dynamic relocs in check_relocs for each symbol.
670 This is so that it can later discard them if they are found to be
671 unnecessary. We store the information in a field extending the
672 regular ELF linker hash table. */
673
674 struct _bfd_sparc_elf_dyn_relocs
675 {
676 struct _bfd_sparc_elf_dyn_relocs *next;
677
678 /* The input section of the reloc. */
679 asection *sec;
680
681 /* Total number of relocs copied for the input section. */
682 bfd_size_type count;
683
684 /* Number of pc-relative relocs copied for the input section. */
685 bfd_size_type pc_count;
686 };
687
688 /* SPARC ELF linker hash entry. */
689
690 struct _bfd_sparc_elf_link_hash_entry
691 {
692 struct elf_link_hash_entry elf;
693
694 /* Track dynamic relocs copied for this symbol. */
695 struct _bfd_sparc_elf_dyn_relocs *dyn_relocs;
696
697 #define GOT_UNKNOWN 0
698 #define GOT_NORMAL 1
699 #define GOT_TLS_GD 2
700 #define GOT_TLS_IE 3
701 unsigned char tls_type;
702 };
703
704 #define _bfd_sparc_elf_hash_entry(ent) ((struct _bfd_sparc_elf_link_hash_entry *)(ent))
705
706 struct _bfd_sparc_elf_obj_tdata
707 {
708 struct elf_obj_tdata root;
709
710 /* tls_type for each local got entry. */
711 char *local_got_tls_type;
712
713 /* TRUE if TLS GD relocs has been seen for this object. */
714 bfd_boolean has_tlsgd;
715 };
716
717 #define _bfd_sparc_elf_tdata(abfd) \
718 ((struct _bfd_sparc_elf_obj_tdata *) (abfd)->tdata.any)
719
720 #define _bfd_sparc_elf_local_got_tls_type(abfd) \
721 (_bfd_sparc_elf_tdata (abfd)->local_got_tls_type)
722
723 #define is_sparc_elf(bfd) \
724 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
725 && elf_tdata (bfd) != NULL \
726 && elf_object_id (bfd) == SPARC_ELF_DATA)
727
728 bfd_boolean
729 _bfd_sparc_elf_mkobject (bfd *abfd)
730 {
731 return bfd_elf_allocate_object (abfd, sizeof (struct _bfd_sparc_elf_obj_tdata),
732 SPARC_ELF_DATA);
733 }
734
735 static void
736 sparc_put_word_32 (bfd *abfd, bfd_vma val, void *ptr)
737 {
738 bfd_put_32 (abfd, val, ptr);
739 }
740
741 static void
742 sparc_put_word_64 (bfd *abfd, bfd_vma val, void *ptr)
743 {
744 bfd_put_64 (abfd, val, ptr);
745 }
746
747 static void
748 sparc_elf_append_rela (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
749 {
750 const struct elf_backend_data *bed;
751 bfd_byte *loc;
752
753 bed = get_elf_backend_data (abfd);
754 loc = s->contents + (s->reloc_count++ * bed->s->sizeof_rela);
755 bed->s->swap_reloca_out (abfd, rel, loc);
756 }
757
758 static bfd_vma
759 sparc_elf_r_info_64 (Elf_Internal_Rela *in_rel ATTRIBUTE_UNUSED,
760 bfd_vma rel_index ATTRIBUTE_UNUSED,
761 bfd_vma type ATTRIBUTE_UNUSED)
762 {
763 return ELF64_R_INFO (rel_index,
764 (in_rel ?
765 ELF64_R_TYPE_INFO (ELF64_R_TYPE_DATA (in_rel->r_info),
766 type) : type));
767 }
768
769 static bfd_vma
770 sparc_elf_r_info_32 (Elf_Internal_Rela *in_rel ATTRIBUTE_UNUSED,
771 bfd_vma rel_index, bfd_vma type)
772 {
773 return ELF32_R_INFO (rel_index, type);
774 }
775
776 static bfd_vma
777 sparc_elf_r_symndx_64 (bfd_vma r_info)
778 {
779 bfd_vma r_symndx = ELF32_R_SYM (r_info);
780 return (r_symndx >> 24);
781 }
782
783 static bfd_vma
784 sparc_elf_r_symndx_32 (bfd_vma r_info)
785 {
786 return ELF32_R_SYM (r_info);
787 }
788
789 /* PLT/GOT stuff */
790
791 #define PLT32_ENTRY_SIZE 12
792 #define PLT32_HEADER_SIZE (4 * PLT32_ENTRY_SIZE)
793
794 /* The first four entries in a 32-bit procedure linkage table are reserved,
795 and the initial contents are unimportant (we zero them out).
796 Subsequent entries look like this. See the SVR4 ABI SPARC
797 supplement to see how this works. */
798
799 /* sethi %hi(.-.plt0),%g1. We fill in the address later. */
800 #define PLT32_ENTRY_WORD0 0x03000000
801 /* b,a .plt0. We fill in the offset later. */
802 #define PLT32_ENTRY_WORD1 0x30800000
803 /* nop. */
804 #define PLT32_ENTRY_WORD2 SPARC_NOP
805
806 static int
807 sparc32_plt_entry_build (bfd *output_bfd, asection *splt, bfd_vma offset,
808 bfd_vma max ATTRIBUTE_UNUSED,
809 bfd_vma *r_offset)
810 {
811 bfd_put_32 (output_bfd,
812 PLT32_ENTRY_WORD0 + offset,
813 splt->contents + offset);
814 bfd_put_32 (output_bfd,
815 (PLT32_ENTRY_WORD1
816 + (((- (offset + 4)) >> 2) & 0x3fffff)),
817 splt->contents + offset + 4);
818 bfd_put_32 (output_bfd, (bfd_vma) PLT32_ENTRY_WORD2,
819 splt->contents + offset + 8);
820
821 *r_offset = offset;
822
823 return offset / PLT32_ENTRY_SIZE - 4;
824 }
825
826 /* Both the headers and the entries are icache aligned. */
827 #define PLT64_ENTRY_SIZE 32
828 #define PLT64_HEADER_SIZE (4 * PLT64_ENTRY_SIZE)
829 #define PLT64_LARGE_THRESHOLD 32768
830
831 static int
832 sparc64_plt_entry_build (bfd *output_bfd, asection *splt, bfd_vma offset,
833 bfd_vma max, bfd_vma *r_offset)
834 {
835 unsigned char *entry = splt->contents + offset;
836 const unsigned int nop = SPARC_NOP;
837 int plt_index;
838
839 if (offset < (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE))
840 {
841 unsigned int sethi, ba;
842
843 *r_offset = offset;
844
845 plt_index = (offset / PLT64_ENTRY_SIZE);
846
847 sethi = 0x03000000 | (plt_index * PLT64_ENTRY_SIZE);
848 ba = 0x30680000
849 | (((splt->contents + PLT64_ENTRY_SIZE) - (entry + 4)) / 4 & 0x7ffff);
850
851 bfd_put_32 (output_bfd, (bfd_vma) sethi, entry);
852 bfd_put_32 (output_bfd, (bfd_vma) ba, entry + 4);
853 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 8);
854 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 12);
855 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 16);
856 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 20);
857 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 24);
858 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 28);
859 }
860 else
861 {
862 unsigned char *ptr;
863 unsigned int ldx;
864 int block, last_block, ofs, last_ofs, chunks_this_block;
865 const int insn_chunk_size = (6 * 4);
866 const int ptr_chunk_size = (1 * 8);
867 const int entries_per_block = 160;
868 const int block_size = entries_per_block * (insn_chunk_size
869 + ptr_chunk_size);
870
871 /* Entries 32768 and higher are grouped into blocks of 160.
872 The blocks are further subdivided into 160 sequences of
873 6 instructions and 160 pointers. If a block does not require
874 the full 160 entries, let's say it requires N, then there
875 will be N sequences of 6 instructions and N pointers. */
876
877 offset -= (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE);
878 max -= (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE);
879
880 block = offset / block_size;
881 last_block = max / block_size;
882 if (block != last_block)
883 {
884 chunks_this_block = 160;
885 }
886 else
887 {
888 last_ofs = max % block_size;
889 chunks_this_block = last_ofs / (insn_chunk_size + ptr_chunk_size);
890 }
891
892 ofs = offset % block_size;
893
894 plt_index = (PLT64_LARGE_THRESHOLD +
895 (block * 160) +
896 (ofs / insn_chunk_size));
897
898 ptr = splt->contents
899 + (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE)
900 + (block * block_size)
901 + (chunks_this_block * insn_chunk_size)
902 + (ofs / insn_chunk_size) * ptr_chunk_size;
903
904 *r_offset = (bfd_vma) (ptr - splt->contents);
905
906 ldx = 0xc25be000 | ((ptr - (entry+4)) & 0x1fff);
907
908 /* mov %o7,%g5
909 call .+8
910 nop
911 ldx [%o7+P],%g1
912 jmpl %o7+%g1,%g1
913 mov %g5,%o7 */
914 bfd_put_32 (output_bfd, (bfd_vma) 0x8a10000f, entry);
915 bfd_put_32 (output_bfd, (bfd_vma) 0x40000002, entry + 4);
916 bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP, entry + 8);
917 bfd_put_32 (output_bfd, (bfd_vma) ldx, entry + 12);
918 bfd_put_32 (output_bfd, (bfd_vma) 0x83c3c001, entry + 16);
919 bfd_put_32 (output_bfd, (bfd_vma) 0x9e100005, entry + 20);
920
921 bfd_put_64 (output_bfd, (bfd_vma) (splt->contents - (entry + 4)), ptr);
922 }
923
924 return plt_index - 4;
925 }
926
927 /* The format of the first PLT entry in a VxWorks executable. */
928 static const bfd_vma sparc_vxworks_exec_plt0_entry[] =
929 {
930 0x05000000, /* sethi %hi(_GLOBAL_OFFSET_TABLE_+8), %g2 */
931 0x8410a000, /* or %g2, %lo(_GLOBAL_OFFSET_TABLE_+8), %g2 */
932 0xc4008000, /* ld [ %g2 ], %g2 */
933 0x81c08000, /* jmp %g2 */
934 0x01000000 /* nop */
935 };
936
937 /* The format of subsequent PLT entries. */
938 static const bfd_vma sparc_vxworks_exec_plt_entry[] =
939 {
940 0x03000000, /* sethi %hi(_GLOBAL_OFFSET_TABLE_+f@got), %g1 */
941 0x82106000, /* or %g1, %lo(_GLOBAL_OFFSET_TABLE_+f@got), %g1 */
942 0xc2004000, /* ld [ %g1 ], %g1 */
943 0x81c04000, /* jmp %g1 */
944 0x01000000, /* nop */
945 0x03000000, /* sethi %hi(f@pltindex), %g1 */
946 0x10800000, /* b _PLT_resolve */
947 0x82106000 /* or %g1, %lo(f@pltindex), %g1 */
948 };
949
950 /* The format of the first PLT entry in a VxWorks shared object. */
951 static const bfd_vma sparc_vxworks_shared_plt0_entry[] =
952 {
953 0xc405e008, /* ld [ %l7 + 8 ], %g2 */
954 0x81c08000, /* jmp %g2 */
955 0x01000000 /* nop */
956 };
957
958 /* The format of subsequent PLT entries. */
959 static const bfd_vma sparc_vxworks_shared_plt_entry[] =
960 {
961 0x03000000, /* sethi %hi(f@got), %g1 */
962 0x82106000, /* or %g1, %lo(f@got), %g1 */
963 0xc205c001, /* ld [ %l7 + %g1 ], %g1 */
964 0x81c04000, /* jmp %g1 */
965 0x01000000, /* nop */
966 0x03000000, /* sethi %hi(f@pltindex), %g1 */
967 0x10800000, /* b _PLT_resolve */
968 0x82106000 /* or %g1, %lo(f@pltindex), %g1 */
969 };
970
971 #define SPARC_ELF_PUT_WORD(htab, bfd, val, ptr) \
972 htab->put_word(bfd, val, ptr)
973
974 #define SPARC_ELF_R_INFO(htab, in_rel, index, type) \
975 htab->r_info(in_rel, index, type)
976
977 #define SPARC_ELF_R_SYMNDX(htab, r_info) \
978 htab->r_symndx(r_info)
979
980 #define SPARC_ELF_WORD_BYTES(htab) \
981 htab->bytes_per_word
982
983 #define SPARC_ELF_RELA_BYTES(htab) \
984 htab->bytes_per_rela
985
986 #define SPARC_ELF_DTPOFF_RELOC(htab) \
987 htab->dtpoff_reloc
988
989 #define SPARC_ELF_DTPMOD_RELOC(htab) \
990 htab->dtpmod_reloc
991
992 #define SPARC_ELF_TPOFF_RELOC(htab) \
993 htab->tpoff_reloc
994
995 #define SPARC_ELF_BUILD_PLT_ENTRY(htab, obfd, splt, off, max, r_off) \
996 htab->build_plt_entry (obfd, splt, off, max, r_off)
997
998 /* Create an entry in an SPARC ELF linker hash table. */
999
1000 static struct bfd_hash_entry *
1001 link_hash_newfunc (struct bfd_hash_entry *entry,
1002 struct bfd_hash_table *table, const char *string)
1003 {
1004 /* Allocate the structure if it has not already been allocated by a
1005 subclass. */
1006 if (entry == NULL)
1007 {
1008 entry = bfd_hash_allocate (table,
1009 sizeof (struct _bfd_sparc_elf_link_hash_entry));
1010 if (entry == NULL)
1011 return entry;
1012 }
1013
1014 /* Call the allocation method of the superclass. */
1015 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
1016 if (entry != NULL)
1017 {
1018 struct _bfd_sparc_elf_link_hash_entry *eh;
1019
1020 eh = (struct _bfd_sparc_elf_link_hash_entry *) entry;
1021 eh->dyn_relocs = NULL;
1022 eh->tls_type = GOT_UNKNOWN;
1023 }
1024
1025 return entry;
1026 }
1027
1028 /* The name of the dynamic interpreter. This is put in the .interp
1029 section. */
1030
1031 #define ELF32_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
1032 #define ELF64_DYNAMIC_INTERPRETER "/usr/lib/sparcv9/ld.so.1"
1033
1034 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
1035 for local symbol so that we can handle local STT_GNU_IFUNC symbols
1036 as global symbol. We reuse indx and dynstr_index for local symbol
1037 hash since they aren't used by global symbols in this backend. */
1038
1039 static hashval_t
1040 elf_sparc_local_htab_hash (const void *ptr)
1041 {
1042 struct elf_link_hash_entry *h
1043 = (struct elf_link_hash_entry *) ptr;
1044 return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);
1045 }
1046
1047 /* Compare local hash entries. */
1048
1049 static int
1050 elf_sparc_local_htab_eq (const void *ptr1, const void *ptr2)
1051 {
1052 struct elf_link_hash_entry *h1
1053 = (struct elf_link_hash_entry *) ptr1;
1054 struct elf_link_hash_entry *h2
1055 = (struct elf_link_hash_entry *) ptr2;
1056
1057 return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
1058 }
1059
1060 /* Find and/or create a hash entry for local symbol. */
1061
1062 static struct elf_link_hash_entry *
1063 elf_sparc_get_local_sym_hash (struct _bfd_sparc_elf_link_hash_table *htab,
1064 bfd *abfd, const Elf_Internal_Rela *rel,
1065 bfd_boolean create)
1066 {
1067 struct _bfd_sparc_elf_link_hash_entry e, *ret;
1068 asection *sec = abfd->sections;
1069 unsigned long r_symndx;
1070 hashval_t h;
1071 void **slot;
1072
1073 r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
1074 h = ELF_LOCAL_SYMBOL_HASH (sec->id, r_symndx);
1075
1076 e.elf.indx = sec->id;
1077 e.elf.dynstr_index = r_symndx;
1078 slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,
1079 create ? INSERT : NO_INSERT);
1080
1081 if (!slot)
1082 return NULL;
1083
1084 if (*slot)
1085 {
1086 ret = (struct _bfd_sparc_elf_link_hash_entry *) *slot;
1087 return &ret->elf;
1088 }
1089
1090 ret = (struct _bfd_sparc_elf_link_hash_entry *)
1091 objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,
1092 sizeof (struct _bfd_sparc_elf_link_hash_entry));
1093 if (ret)
1094 {
1095 memset (ret, 0, sizeof (*ret));
1096 ret->elf.indx = sec->id;
1097 ret->elf.dynstr_index = r_symndx;
1098 ret->elf.dynindx = -1;
1099 ret->elf.plt.offset = (bfd_vma) -1;
1100 ret->elf.got.offset = (bfd_vma) -1;
1101 *slot = ret;
1102 }
1103 return &ret->elf;
1104 }
1105
1106 /* Create a SPARC ELF linker hash table. */
1107
1108 struct bfd_link_hash_table *
1109 _bfd_sparc_elf_link_hash_table_create (bfd *abfd)
1110 {
1111 struct _bfd_sparc_elf_link_hash_table *ret;
1112 bfd_size_type amt = sizeof (struct _bfd_sparc_elf_link_hash_table);
1113
1114 ret = (struct _bfd_sparc_elf_link_hash_table *) bfd_zmalloc (amt);
1115 if (ret == NULL)
1116 return NULL;
1117
1118 if (ABI_64_P (abfd))
1119 {
1120 ret->put_word = sparc_put_word_64;
1121 ret->r_info = sparc_elf_r_info_64;
1122 ret->r_symndx = sparc_elf_r_symndx_64;
1123 ret->dtpoff_reloc = R_SPARC_TLS_DTPOFF64;
1124 ret->dtpmod_reloc = R_SPARC_TLS_DTPMOD64;
1125 ret->tpoff_reloc = R_SPARC_TLS_TPOFF64;
1126 ret->word_align_power = 3;
1127 ret->align_power_max = 4;
1128 ret->bytes_per_word = 8;
1129 ret->bytes_per_rela = sizeof (Elf64_External_Rela);
1130 ret->dynamic_interpreter = ELF64_DYNAMIC_INTERPRETER;
1131 ret->dynamic_interpreter_size = sizeof ELF64_DYNAMIC_INTERPRETER;
1132
1133 ret->build_plt_entry = sparc64_plt_entry_build;
1134 ret->plt_header_size = PLT64_HEADER_SIZE;
1135 ret->plt_entry_size = PLT64_ENTRY_SIZE;
1136 }
1137 else
1138 {
1139 ret->put_word = sparc_put_word_32;
1140 ret->r_info = sparc_elf_r_info_32;
1141 ret->r_symndx = sparc_elf_r_symndx_32;
1142 ret->dtpoff_reloc = R_SPARC_TLS_DTPOFF32;
1143 ret->dtpmod_reloc = R_SPARC_TLS_DTPMOD32;
1144 ret->tpoff_reloc = R_SPARC_TLS_TPOFF32;
1145 ret->word_align_power = 2;
1146 ret->align_power_max = 3;
1147 ret->bytes_per_word = 4;
1148 ret->bytes_per_rela = sizeof (Elf32_External_Rela);
1149 ret->dynamic_interpreter = ELF32_DYNAMIC_INTERPRETER;
1150 ret->dynamic_interpreter_size = sizeof ELF32_DYNAMIC_INTERPRETER;
1151
1152 ret->build_plt_entry = sparc32_plt_entry_build;
1153 ret->plt_header_size = PLT32_HEADER_SIZE;
1154 ret->plt_entry_size = PLT32_ENTRY_SIZE;
1155 }
1156
1157 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc,
1158 sizeof (struct _bfd_sparc_elf_link_hash_entry),
1159 SPARC_ELF_DATA))
1160 {
1161 free (ret);
1162 return NULL;
1163 }
1164
1165 ret->loc_hash_table = htab_try_create (1024,
1166 elf_sparc_local_htab_hash,
1167 elf_sparc_local_htab_eq,
1168 NULL);
1169 ret->loc_hash_memory = objalloc_create ();
1170 if (!ret->loc_hash_table || !ret->loc_hash_memory)
1171 {
1172 free (ret);
1173 return NULL;
1174 }
1175
1176 return &ret->elf.root;
1177 }
1178
1179 /* Destroy a SPARC ELF linker hash table. */
1180
1181 void
1182 _bfd_sparc_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
1183 {
1184 struct _bfd_sparc_elf_link_hash_table *htab
1185 = (struct _bfd_sparc_elf_link_hash_table *) hash;
1186
1187 if (htab->loc_hash_table)
1188 htab_delete (htab->loc_hash_table);
1189 if (htab->loc_hash_memory)
1190 objalloc_free ((struct objalloc *) htab->loc_hash_memory);
1191 _bfd_generic_link_hash_table_free (hash);
1192 }
1193
1194 /* Create .plt, .rela.plt, .got, .rela.got, .dynbss, and
1195 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
1196 hash table. */
1197
1198 bfd_boolean
1199 _bfd_sparc_elf_create_dynamic_sections (bfd *dynobj,
1200 struct bfd_link_info *info)
1201 {
1202 struct _bfd_sparc_elf_link_hash_table *htab;
1203
1204 htab = _bfd_sparc_elf_hash_table (info);
1205 BFD_ASSERT (htab != NULL);
1206
1207 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
1208 return FALSE;
1209
1210 htab->sdynbss = bfd_get_linker_section (dynobj, ".dynbss");
1211 if (!info->shared)
1212 htab->srelbss = bfd_get_linker_section (dynobj, ".rela.bss");
1213
1214 if (htab->is_vxworks)
1215 {
1216 if (!elf_vxworks_create_dynamic_sections (dynobj, info, &htab->srelplt2))
1217 return FALSE;
1218 if (info->shared)
1219 {
1220 htab->plt_header_size
1221 = 4 * ARRAY_SIZE (sparc_vxworks_shared_plt0_entry);
1222 htab->plt_entry_size
1223 = 4 * ARRAY_SIZE (sparc_vxworks_shared_plt_entry);
1224 }
1225 else
1226 {
1227 htab->plt_header_size
1228 = 4 * ARRAY_SIZE (sparc_vxworks_exec_plt0_entry);
1229 htab->plt_entry_size
1230 = 4 * ARRAY_SIZE (sparc_vxworks_exec_plt_entry);
1231 }
1232 }
1233
1234 if (!htab->elf.splt || !htab->elf.srelplt || !htab->sdynbss
1235 || (!info->shared && !htab->srelbss))
1236 abort ();
1237
1238 return TRUE;
1239 }
1240
1241 static bfd_boolean
1242 create_ifunc_sections (bfd *abfd, struct bfd_link_info *info)
1243 {
1244 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1245 struct elf_link_hash_table *htab = elf_hash_table (info);
1246 flagword flags, pltflags;
1247 asection *s;
1248
1249 if (htab->irelifunc != NULL || htab->iplt != NULL)
1250 return TRUE;
1251
1252 flags = bed->dynamic_sec_flags;
1253 pltflags = flags | SEC_ALLOC | SEC_CODE | SEC_LOAD;
1254
1255 s = bfd_make_section_with_flags (abfd, ".iplt", pltflags);
1256 if (s == NULL
1257 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
1258 return FALSE;
1259 htab->iplt = s;
1260
1261 s = bfd_make_section_with_flags (abfd, ".rela.iplt",
1262 flags | SEC_READONLY);
1263 if (s == NULL
1264 || ! bfd_set_section_alignment (abfd, s,
1265 bed->s->log_file_align))
1266 return FALSE;
1267 htab->irelplt = s;
1268
1269 return TRUE;
1270 }
1271
1272 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1273
1274 void
1275 _bfd_sparc_elf_copy_indirect_symbol (struct bfd_link_info *info,
1276 struct elf_link_hash_entry *dir,
1277 struct elf_link_hash_entry *ind)
1278 {
1279 struct _bfd_sparc_elf_link_hash_entry *edir, *eind;
1280
1281 edir = (struct _bfd_sparc_elf_link_hash_entry *) dir;
1282 eind = (struct _bfd_sparc_elf_link_hash_entry *) ind;
1283
1284 if (eind->dyn_relocs != NULL)
1285 {
1286 if (edir->dyn_relocs != NULL)
1287 {
1288 struct _bfd_sparc_elf_dyn_relocs **pp;
1289 struct _bfd_sparc_elf_dyn_relocs *p;
1290
1291 /* Add reloc counts against the indirect sym to the direct sym
1292 list. Merge any entries against the same section. */
1293 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1294 {
1295 struct _bfd_sparc_elf_dyn_relocs *q;
1296
1297 for (q = edir->dyn_relocs; q != NULL; q = q->next)
1298 if (q->sec == p->sec)
1299 {
1300 q->pc_count += p->pc_count;
1301 q->count += p->count;
1302 *pp = p->next;
1303 break;
1304 }
1305 if (q == NULL)
1306 pp = &p->next;
1307 }
1308 *pp = edir->dyn_relocs;
1309 }
1310
1311 edir->dyn_relocs = eind->dyn_relocs;
1312 eind->dyn_relocs = NULL;
1313 }
1314
1315 if (ind->root.type == bfd_link_hash_indirect
1316 && dir->got.refcount <= 0)
1317 {
1318 edir->tls_type = eind->tls_type;
1319 eind->tls_type = GOT_UNKNOWN;
1320 }
1321 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1322 }
1323
1324 static int
1325 sparc_elf_tls_transition (struct bfd_link_info *info, bfd *abfd,
1326 int r_type, int is_local)
1327 {
1328 if (! ABI_64_P (abfd)
1329 && r_type == R_SPARC_TLS_GD_HI22
1330 && ! _bfd_sparc_elf_tdata (abfd)->has_tlsgd)
1331 r_type = R_SPARC_REV32;
1332
1333 if (info->shared)
1334 return r_type;
1335
1336 switch (r_type)
1337 {
1338 case R_SPARC_TLS_GD_HI22:
1339 if (is_local)
1340 return R_SPARC_TLS_LE_HIX22;
1341 return R_SPARC_TLS_IE_HI22;
1342 case R_SPARC_TLS_GD_LO10:
1343 if (is_local)
1344 return R_SPARC_TLS_LE_LOX10;
1345 return R_SPARC_TLS_IE_LO10;
1346 case R_SPARC_TLS_IE_HI22:
1347 if (is_local)
1348 return R_SPARC_TLS_LE_HIX22;
1349 return r_type;
1350 case R_SPARC_TLS_IE_LO10:
1351 if (is_local)
1352 return R_SPARC_TLS_LE_LOX10;
1353 return r_type;
1354 case R_SPARC_TLS_LDM_HI22:
1355 return R_SPARC_TLS_LE_HIX22;
1356 case R_SPARC_TLS_LDM_LO10:
1357 return R_SPARC_TLS_LE_LOX10;
1358 }
1359
1360 return r_type;
1361 }
1362 \f
1363 /* Look through the relocs for a section during the first phase, and
1364 allocate space in the global offset table or procedure linkage
1365 table. */
1366
1367 bfd_boolean
1368 _bfd_sparc_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
1369 asection *sec, const Elf_Internal_Rela *relocs)
1370 {
1371 struct _bfd_sparc_elf_link_hash_table *htab;
1372 Elf_Internal_Shdr *symtab_hdr;
1373 struct elf_link_hash_entry **sym_hashes;
1374 const Elf_Internal_Rela *rel;
1375 const Elf_Internal_Rela *rel_end;
1376 asection *sreloc;
1377 int num_relocs;
1378 bfd_boolean checked_tlsgd = FALSE;
1379
1380 if (info->relocatable)
1381 return TRUE;
1382
1383 htab = _bfd_sparc_elf_hash_table (info);
1384 BFD_ASSERT (htab != NULL);
1385 symtab_hdr = &elf_symtab_hdr (abfd);
1386 sym_hashes = elf_sym_hashes (abfd);
1387
1388 sreloc = NULL;
1389
1390 if (ABI_64_P (abfd))
1391 num_relocs = NUM_SHDR_ENTRIES (_bfd_elf_single_rel_hdr (sec));
1392 else
1393 num_relocs = sec->reloc_count;
1394
1395 BFD_ASSERT (is_sparc_elf (abfd) || num_relocs == 0);
1396
1397 if (htab->elf.dynobj == NULL)
1398 htab->elf.dynobj = abfd;
1399 if (!create_ifunc_sections (htab->elf.dynobj, info))
1400 return FALSE;
1401
1402 rel_end = relocs + num_relocs;
1403 for (rel = relocs; rel < rel_end; rel++)
1404 {
1405 unsigned int r_type;
1406 unsigned long r_symndx;
1407 struct elf_link_hash_entry *h;
1408 Elf_Internal_Sym *isym;
1409
1410 r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
1411 r_type = SPARC_ELF_R_TYPE (rel->r_info);
1412
1413 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1414 {
1415 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1416 abfd, r_symndx);
1417 return FALSE;
1418 }
1419
1420 isym = NULL;
1421 if (r_symndx < symtab_hdr->sh_info)
1422 {
1423 /* A local symbol. */
1424 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1425 abfd, r_symndx);
1426 if (isym == NULL)
1427 return FALSE;
1428
1429 /* Check relocation against local STT_GNU_IFUNC symbol. */
1430 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1431 {
1432 h = elf_sparc_get_local_sym_hash (htab, abfd, rel,
1433 TRUE);
1434 if (h == NULL)
1435 return FALSE;
1436
1437 /* Fake a STT_GNU_IFUNC symbol. */
1438 h->type = STT_GNU_IFUNC;
1439 h->def_regular = 1;
1440 h->ref_regular = 1;
1441 h->forced_local = 1;
1442 h->root.type = bfd_link_hash_defined;
1443 }
1444 else
1445 h = NULL;
1446 }
1447 else
1448 {
1449 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1450 while (h->root.type == bfd_link_hash_indirect
1451 || h->root.type == bfd_link_hash_warning)
1452 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1453 }
1454
1455 if (h && h->type == STT_GNU_IFUNC)
1456 {
1457 if (h->def_regular)
1458 {
1459 h->ref_regular = 1;
1460 h->plt.refcount += 1;
1461 }
1462 }
1463
1464 /* Compatibility with old R_SPARC_REV32 reloc conflicting
1465 with R_SPARC_TLS_GD_HI22. */
1466 if (! ABI_64_P (abfd) && ! checked_tlsgd)
1467 switch (r_type)
1468 {
1469 case R_SPARC_TLS_GD_HI22:
1470 {
1471 const Elf_Internal_Rela *relt;
1472
1473 for (relt = rel + 1; relt < rel_end; relt++)
1474 if (ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_LO10
1475 || ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_ADD
1476 || ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_CALL)
1477 break;
1478 checked_tlsgd = TRUE;
1479 _bfd_sparc_elf_tdata (abfd)->has_tlsgd = relt < rel_end;
1480 }
1481 break;
1482 case R_SPARC_TLS_GD_LO10:
1483 case R_SPARC_TLS_GD_ADD:
1484 case R_SPARC_TLS_GD_CALL:
1485 checked_tlsgd = TRUE;
1486 _bfd_sparc_elf_tdata (abfd)->has_tlsgd = TRUE;
1487 break;
1488 }
1489
1490 r_type = sparc_elf_tls_transition (info, abfd, r_type, h == NULL);
1491 switch (r_type)
1492 {
1493 case R_SPARC_TLS_LDM_HI22:
1494 case R_SPARC_TLS_LDM_LO10:
1495 htab->tls_ldm_got.refcount += 1;
1496 break;
1497
1498 case R_SPARC_TLS_LE_HIX22:
1499 case R_SPARC_TLS_LE_LOX10:
1500 if (info->shared)
1501 goto r_sparc_plt32;
1502 break;
1503
1504 case R_SPARC_TLS_IE_HI22:
1505 case R_SPARC_TLS_IE_LO10:
1506 if (info->shared)
1507 info->flags |= DF_STATIC_TLS;
1508 /* Fall through */
1509
1510 case R_SPARC_GOT10:
1511 case R_SPARC_GOT13:
1512 case R_SPARC_GOT22:
1513 case R_SPARC_GOTDATA_HIX22:
1514 case R_SPARC_GOTDATA_LOX10:
1515 case R_SPARC_GOTDATA_OP_HIX22:
1516 case R_SPARC_GOTDATA_OP_LOX10:
1517 case R_SPARC_TLS_GD_HI22:
1518 case R_SPARC_TLS_GD_LO10:
1519 /* This symbol requires a global offset table entry. */
1520 {
1521 int tls_type, old_tls_type;
1522
1523 switch (r_type)
1524 {
1525 default:
1526 case R_SPARC_GOT10:
1527 case R_SPARC_GOT13:
1528 case R_SPARC_GOT22:
1529 case R_SPARC_GOTDATA_OP_HIX22:
1530 case R_SPARC_GOTDATA_OP_LOX10:
1531 tls_type = GOT_NORMAL;
1532 break;
1533 case R_SPARC_TLS_GD_HI22:
1534 case R_SPARC_TLS_GD_LO10:
1535 tls_type = GOT_TLS_GD;
1536 break;
1537 case R_SPARC_TLS_IE_HI22:
1538 case R_SPARC_TLS_IE_LO10:
1539 tls_type = GOT_TLS_IE;
1540 break;
1541 }
1542
1543 if (h != NULL)
1544 {
1545 h->got.refcount += 1;
1546 old_tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
1547 }
1548 else
1549 {
1550 bfd_signed_vma *local_got_refcounts;
1551
1552 /* This is a global offset table entry for a local symbol. */
1553 local_got_refcounts = elf_local_got_refcounts (abfd);
1554 if (local_got_refcounts == NULL)
1555 {
1556 bfd_size_type size;
1557
1558 size = symtab_hdr->sh_info;
1559 size *= (sizeof (bfd_signed_vma) + sizeof(char));
1560 local_got_refcounts = ((bfd_signed_vma *)
1561 bfd_zalloc (abfd, size));
1562 if (local_got_refcounts == NULL)
1563 return FALSE;
1564 elf_local_got_refcounts (abfd) = local_got_refcounts;
1565 _bfd_sparc_elf_local_got_tls_type (abfd)
1566 = (char *) (local_got_refcounts + symtab_hdr->sh_info);
1567 }
1568 switch (r_type)
1569 {
1570 case R_SPARC_GOTDATA_OP_HIX22:
1571 case R_SPARC_GOTDATA_OP_LOX10:
1572 break;
1573
1574 default:
1575 local_got_refcounts[r_symndx] += 1;
1576 break;
1577 }
1578 old_tls_type = _bfd_sparc_elf_local_got_tls_type (abfd) [r_symndx];
1579 }
1580
1581 /* If a TLS symbol is accessed using IE at least once,
1582 there is no point to use dynamic model for it. */
1583 if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1584 && (old_tls_type != GOT_TLS_GD
1585 || tls_type != GOT_TLS_IE))
1586 {
1587 if (old_tls_type == GOT_TLS_IE && tls_type == GOT_TLS_GD)
1588 tls_type = old_tls_type;
1589 else
1590 {
1591 (*_bfd_error_handler)
1592 (_("%B: `%s' accessed both as normal and thread local symbol"),
1593 abfd, h ? h->root.root.string : "<local>");
1594 return FALSE;
1595 }
1596 }
1597
1598 if (old_tls_type != tls_type)
1599 {
1600 if (h != NULL)
1601 _bfd_sparc_elf_hash_entry (h)->tls_type = tls_type;
1602 else
1603 _bfd_sparc_elf_local_got_tls_type (abfd) [r_symndx] = tls_type;
1604 }
1605 }
1606
1607 if (htab->elf.sgot == NULL)
1608 {
1609 if (!_bfd_elf_create_got_section (htab->elf.dynobj, info))
1610 return FALSE;
1611 }
1612 break;
1613
1614 case R_SPARC_TLS_GD_CALL:
1615 case R_SPARC_TLS_LDM_CALL:
1616 if (info->shared)
1617 {
1618 /* These are basically R_SPARC_TLS_WPLT30 relocs against
1619 __tls_get_addr. */
1620 struct bfd_link_hash_entry *bh = NULL;
1621 if (! _bfd_generic_link_add_one_symbol (info, abfd,
1622 "__tls_get_addr", 0,
1623 bfd_und_section_ptr, 0,
1624 NULL, FALSE, FALSE,
1625 &bh))
1626 return FALSE;
1627 h = (struct elf_link_hash_entry *) bh;
1628 }
1629 else
1630 break;
1631 /* Fall through */
1632
1633 case R_SPARC_PLT32:
1634 case R_SPARC_WPLT30:
1635 case R_SPARC_HIPLT22:
1636 case R_SPARC_LOPLT10:
1637 case R_SPARC_PCPLT32:
1638 case R_SPARC_PCPLT22:
1639 case R_SPARC_PCPLT10:
1640 case R_SPARC_PLT64:
1641 /* This symbol requires a procedure linkage table entry. We
1642 actually build the entry in adjust_dynamic_symbol,
1643 because this might be a case of linking PIC code without
1644 linking in any dynamic objects, in which case we don't
1645 need to generate a procedure linkage table after all. */
1646
1647 if (h == NULL)
1648 {
1649 if (! ABI_64_P (abfd))
1650 {
1651 /* The Solaris native assembler will generate a WPLT30
1652 reloc for a local symbol if you assemble a call from
1653 one section to another when using -K pic. We treat
1654 it as WDISP30. */
1655 if (ELF32_R_TYPE (rel->r_info) == R_SPARC_PLT32)
1656 goto r_sparc_plt32;
1657 break;
1658 }
1659 /* PR 7027: We need similar behaviour for 64-bit binaries. */
1660 else if (r_type == R_SPARC_WPLT30)
1661 break;
1662
1663 /* It does not make sense to have a procedure linkage
1664 table entry for a local symbol. */
1665 bfd_set_error (bfd_error_bad_value);
1666 return FALSE;
1667 }
1668
1669 h->needs_plt = 1;
1670
1671 {
1672 int this_r_type;
1673
1674 this_r_type = SPARC_ELF_R_TYPE (rel->r_info);
1675 if (this_r_type == R_SPARC_PLT32
1676 || this_r_type == R_SPARC_PLT64)
1677 goto r_sparc_plt32;
1678 }
1679 h->plt.refcount += 1;
1680 break;
1681
1682 case R_SPARC_PC10:
1683 case R_SPARC_PC22:
1684 case R_SPARC_PC_HH22:
1685 case R_SPARC_PC_HM10:
1686 case R_SPARC_PC_LM22:
1687 if (h != NULL)
1688 h->non_got_ref = 1;
1689
1690 if (h != NULL
1691 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1692 break;
1693 /* Fall through. */
1694
1695 case R_SPARC_DISP8:
1696 case R_SPARC_DISP16:
1697 case R_SPARC_DISP32:
1698 case R_SPARC_DISP64:
1699 case R_SPARC_WDISP30:
1700 case R_SPARC_WDISP22:
1701 case R_SPARC_WDISP19:
1702 case R_SPARC_WDISP16:
1703 case R_SPARC_WDISP10:
1704 case R_SPARC_8:
1705 case R_SPARC_16:
1706 case R_SPARC_32:
1707 case R_SPARC_HI22:
1708 case R_SPARC_22:
1709 case R_SPARC_13:
1710 case R_SPARC_LO10:
1711 case R_SPARC_UA16:
1712 case R_SPARC_UA32:
1713 case R_SPARC_10:
1714 case R_SPARC_11:
1715 case R_SPARC_64:
1716 case R_SPARC_OLO10:
1717 case R_SPARC_HH22:
1718 case R_SPARC_HM10:
1719 case R_SPARC_LM22:
1720 case R_SPARC_7:
1721 case R_SPARC_5:
1722 case R_SPARC_6:
1723 case R_SPARC_HIX22:
1724 case R_SPARC_LOX10:
1725 case R_SPARC_H44:
1726 case R_SPARC_M44:
1727 case R_SPARC_L44:
1728 case R_SPARC_H34:
1729 case R_SPARC_UA64:
1730 if (h != NULL)
1731 h->non_got_ref = 1;
1732
1733 r_sparc_plt32:
1734 if (h != NULL && !info->shared)
1735 {
1736 /* We may need a .plt entry if the function this reloc
1737 refers to is in a shared lib. */
1738 h->plt.refcount += 1;
1739 }
1740
1741 /* If we are creating a shared library, and this is a reloc
1742 against a global symbol, or a non PC relative reloc
1743 against a local symbol, then we need to copy the reloc
1744 into the shared library. However, if we are linking with
1745 -Bsymbolic, we do not need to copy a reloc against a
1746 global symbol which is defined in an object we are
1747 including in the link (i.e., DEF_REGULAR is set). At
1748 this point we have not seen all the input files, so it is
1749 possible that DEF_REGULAR is not set now but will be set
1750 later (it is never cleared). In case of a weak definition,
1751 DEF_REGULAR may be cleared later by a strong definition in
1752 a shared library. We account for that possibility below by
1753 storing information in the relocs_copied field of the hash
1754 table entry. A similar situation occurs when creating
1755 shared libraries and symbol visibility changes render the
1756 symbol local.
1757
1758 If on the other hand, we are creating an executable, we
1759 may need to keep relocations for symbols satisfied by a
1760 dynamic library if we manage to avoid copy relocs for the
1761 symbol. */
1762 if ((info->shared
1763 && (sec->flags & SEC_ALLOC) != 0
1764 && (! _bfd_sparc_elf_howto_table[r_type].pc_relative
1765 || (h != NULL
1766 && (! SYMBOLIC_BIND (info, h)
1767 || h->root.type == bfd_link_hash_defweak
1768 || !h->def_regular))))
1769 || (!info->shared
1770 && (sec->flags & SEC_ALLOC) != 0
1771 && h != NULL
1772 && (h->root.type == bfd_link_hash_defweak
1773 || !h->def_regular))
1774 || (!info->shared
1775 && h != NULL
1776 && h->type == STT_GNU_IFUNC))
1777 {
1778 struct _bfd_sparc_elf_dyn_relocs *p;
1779 struct _bfd_sparc_elf_dyn_relocs **head;
1780
1781 /* When creating a shared object, we must copy these
1782 relocs into the output file. We create a reloc
1783 section in dynobj and make room for the reloc. */
1784 if (sreloc == NULL)
1785 {
1786 sreloc = _bfd_elf_make_dynamic_reloc_section
1787 (sec, htab->elf.dynobj, htab->word_align_power,
1788 abfd, /*rela?*/ TRUE);
1789
1790 if (sreloc == NULL)
1791 return FALSE;
1792 }
1793
1794 /* If this is a global symbol, we count the number of
1795 relocations we need for this symbol. */
1796 if (h != NULL)
1797 head = &((struct _bfd_sparc_elf_link_hash_entry *) h)->dyn_relocs;
1798 else
1799 {
1800 /* Track dynamic relocs needed for local syms too.
1801 We really need local syms available to do this
1802 easily. Oh well. */
1803 asection *s;
1804 void *vpp;
1805
1806 BFD_ASSERT (isym != NULL);
1807 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1808 if (s == NULL)
1809 s = sec;
1810
1811 vpp = &elf_section_data (s)->local_dynrel;
1812 head = (struct _bfd_sparc_elf_dyn_relocs **) vpp;
1813 }
1814
1815 p = *head;
1816 if (p == NULL || p->sec != sec)
1817 {
1818 bfd_size_type amt = sizeof *p;
1819 p = ((struct _bfd_sparc_elf_dyn_relocs *)
1820 bfd_alloc (htab->elf.dynobj, amt));
1821 if (p == NULL)
1822 return FALSE;
1823 p->next = *head;
1824 *head = p;
1825 p->sec = sec;
1826 p->count = 0;
1827 p->pc_count = 0;
1828 }
1829
1830 p->count += 1;
1831 if (_bfd_sparc_elf_howto_table[r_type].pc_relative)
1832 p->pc_count += 1;
1833 }
1834
1835 break;
1836
1837 case R_SPARC_GNU_VTINHERIT:
1838 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1839 return FALSE;
1840 break;
1841
1842 case R_SPARC_GNU_VTENTRY:
1843 BFD_ASSERT (h != NULL);
1844 if (h != NULL
1845 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1846 return FALSE;
1847 break;
1848
1849 case R_SPARC_REGISTER:
1850 /* Nothing to do. */
1851 break;
1852
1853 default:
1854 break;
1855 }
1856 }
1857
1858 return TRUE;
1859 }
1860 \f
1861 asection *
1862 _bfd_sparc_elf_gc_mark_hook (asection *sec,
1863 struct bfd_link_info *info,
1864 Elf_Internal_Rela *rel,
1865 struct elf_link_hash_entry *h,
1866 Elf_Internal_Sym *sym)
1867 {
1868 if (h != NULL)
1869 switch (SPARC_ELF_R_TYPE (rel->r_info))
1870 {
1871 case R_SPARC_GNU_VTINHERIT:
1872 case R_SPARC_GNU_VTENTRY:
1873 return NULL;
1874 }
1875
1876 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1877 }
1878
1879 static Elf_Internal_Rela *
1880 sparc_elf_find_reloc_at_ofs (Elf_Internal_Rela *rel,
1881 Elf_Internal_Rela *relend,
1882 bfd_vma offset)
1883 {
1884 while (rel < relend)
1885 {
1886 if (rel->r_offset == offset)
1887 return rel;
1888 rel++;
1889 }
1890 return NULL;
1891 }
1892
1893 /* Update the got entry reference counts for the section being removed. */
1894 bfd_boolean
1895 _bfd_sparc_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
1896 asection *sec, const Elf_Internal_Rela *relocs)
1897 {
1898 struct _bfd_sparc_elf_link_hash_table *htab;
1899 Elf_Internal_Shdr *symtab_hdr;
1900 struct elf_link_hash_entry **sym_hashes;
1901 bfd_signed_vma *local_got_refcounts;
1902 const Elf_Internal_Rela *rel, *relend;
1903
1904 if (info->relocatable)
1905 return TRUE;
1906
1907 BFD_ASSERT (is_sparc_elf (abfd) || sec->reloc_count == 0);
1908
1909 elf_section_data (sec)->local_dynrel = NULL;
1910
1911 htab = _bfd_sparc_elf_hash_table (info);
1912 BFD_ASSERT (htab != NULL);
1913 symtab_hdr = &elf_symtab_hdr (abfd);
1914 sym_hashes = elf_sym_hashes (abfd);
1915 local_got_refcounts = elf_local_got_refcounts (abfd);
1916
1917 relend = relocs + sec->reloc_count;
1918 for (rel = relocs; rel < relend; rel++)
1919 {
1920 unsigned long r_symndx;
1921 unsigned int r_type;
1922 struct elf_link_hash_entry *h = NULL;
1923
1924 r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
1925 if (r_symndx >= symtab_hdr->sh_info)
1926 {
1927 struct _bfd_sparc_elf_link_hash_entry *eh;
1928 struct _bfd_sparc_elf_dyn_relocs **pp;
1929 struct _bfd_sparc_elf_dyn_relocs *p;
1930
1931 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1932 while (h->root.type == bfd_link_hash_indirect
1933 || h->root.type == bfd_link_hash_warning)
1934 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1935 eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
1936 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1937 if (p->sec == sec)
1938 {
1939 /* Everything must go for SEC. */
1940 *pp = p->next;
1941 break;
1942 }
1943 }
1944
1945 r_type = SPARC_ELF_R_TYPE (rel->r_info);
1946 r_type = sparc_elf_tls_transition (info, abfd, r_type, h != NULL);
1947 switch (r_type)
1948 {
1949 case R_SPARC_TLS_LDM_HI22:
1950 case R_SPARC_TLS_LDM_LO10:
1951 if (_bfd_sparc_elf_hash_table (info)->tls_ldm_got.refcount > 0)
1952 _bfd_sparc_elf_hash_table (info)->tls_ldm_got.refcount -= 1;
1953 break;
1954
1955 case R_SPARC_TLS_GD_HI22:
1956 case R_SPARC_TLS_GD_LO10:
1957 case R_SPARC_TLS_IE_HI22:
1958 case R_SPARC_TLS_IE_LO10:
1959 case R_SPARC_GOT10:
1960 case R_SPARC_GOT13:
1961 case R_SPARC_GOT22:
1962 case R_SPARC_GOTDATA_HIX22:
1963 case R_SPARC_GOTDATA_LOX10:
1964 case R_SPARC_GOTDATA_OP_HIX22:
1965 case R_SPARC_GOTDATA_OP_LOX10:
1966 if (h != NULL)
1967 {
1968 if (h->got.refcount > 0)
1969 h->got.refcount--;
1970 }
1971 else
1972 {
1973 switch (r_type)
1974 {
1975 case R_SPARC_GOTDATA_OP_HIX22:
1976 case R_SPARC_GOTDATA_OP_LOX10:
1977 break;
1978
1979 default:
1980 if (local_got_refcounts[r_symndx] > 0)
1981 local_got_refcounts[r_symndx]--;
1982 break;
1983 }
1984 }
1985 break;
1986
1987 case R_SPARC_PC10:
1988 case R_SPARC_PC22:
1989 case R_SPARC_PC_HH22:
1990 case R_SPARC_PC_HM10:
1991 case R_SPARC_PC_LM22:
1992 if (h != NULL
1993 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1994 break;
1995 /* Fall through. */
1996
1997 case R_SPARC_DISP8:
1998 case R_SPARC_DISP16:
1999 case R_SPARC_DISP32:
2000 case R_SPARC_DISP64:
2001 case R_SPARC_WDISP30:
2002 case R_SPARC_WDISP22:
2003 case R_SPARC_WDISP19:
2004 case R_SPARC_WDISP16:
2005 case R_SPARC_WDISP10:
2006 case R_SPARC_8:
2007 case R_SPARC_16:
2008 case R_SPARC_32:
2009 case R_SPARC_HI22:
2010 case R_SPARC_22:
2011 case R_SPARC_13:
2012 case R_SPARC_LO10:
2013 case R_SPARC_UA16:
2014 case R_SPARC_UA32:
2015 case R_SPARC_PLT32:
2016 case R_SPARC_10:
2017 case R_SPARC_11:
2018 case R_SPARC_64:
2019 case R_SPARC_OLO10:
2020 case R_SPARC_HH22:
2021 case R_SPARC_HM10:
2022 case R_SPARC_LM22:
2023 case R_SPARC_7:
2024 case R_SPARC_5:
2025 case R_SPARC_6:
2026 case R_SPARC_HIX22:
2027 case R_SPARC_LOX10:
2028 case R_SPARC_H44:
2029 case R_SPARC_M44:
2030 case R_SPARC_L44:
2031 case R_SPARC_H34:
2032 case R_SPARC_UA64:
2033 if (info->shared)
2034 break;
2035 /* Fall through. */
2036
2037 case R_SPARC_WPLT30:
2038 if (h != NULL)
2039 {
2040 if (h->plt.refcount > 0)
2041 h->plt.refcount--;
2042 }
2043 break;
2044
2045 default:
2046 break;
2047 }
2048 }
2049
2050 return TRUE;
2051 }
2052
2053 /* Adjust a symbol defined by a dynamic object and referenced by a
2054 regular object. The current definition is in some section of the
2055 dynamic object, but we're not including those sections. We have to
2056 change the definition to something the rest of the link can
2057 understand. */
2058
2059 bfd_boolean
2060 _bfd_sparc_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
2061 struct elf_link_hash_entry *h)
2062 {
2063 struct _bfd_sparc_elf_link_hash_table *htab;
2064 struct _bfd_sparc_elf_link_hash_entry * eh;
2065 struct _bfd_sparc_elf_dyn_relocs *p;
2066 asection *s;
2067
2068 htab = _bfd_sparc_elf_hash_table (info);
2069 BFD_ASSERT (htab != NULL);
2070
2071 /* Make sure we know what is going on here. */
2072 BFD_ASSERT (htab->elf.dynobj != NULL
2073 && (h->needs_plt
2074 || h->type == STT_GNU_IFUNC
2075 || h->u.weakdef != NULL
2076 || (h->def_dynamic
2077 && h->ref_regular
2078 && !h->def_regular)));
2079
2080 /* If this is a function, put it in the procedure linkage table. We
2081 will fill in the contents of the procedure linkage table later
2082 (although we could actually do it here). The STT_NOTYPE
2083 condition is a hack specifically for the Oracle libraries
2084 delivered for Solaris; for some inexplicable reason, they define
2085 some of their functions as STT_NOTYPE when they really should be
2086 STT_FUNC. */
2087 if (h->type == STT_FUNC
2088 || h->type == STT_GNU_IFUNC
2089 || h->needs_plt
2090 || (h->type == STT_NOTYPE
2091 && (h->root.type == bfd_link_hash_defined
2092 || h->root.type == bfd_link_hash_defweak)
2093 && (h->root.u.def.section->flags & SEC_CODE) != 0))
2094 {
2095 if (h->plt.refcount <= 0
2096 || (h->type != STT_GNU_IFUNC
2097 && (SYMBOL_CALLS_LOCAL (info, h)
2098 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2099 && h->root.type == bfd_link_hash_undefweak))))
2100 {
2101 /* This case can occur if we saw a WPLT30 reloc in an input
2102 file, but the symbol was never referred to by a dynamic
2103 object, or if all references were garbage collected. In
2104 such a case, we don't actually need to build a procedure
2105 linkage table, and we can just do a WDISP30 reloc instead. */
2106 h->plt.offset = (bfd_vma) -1;
2107 h->needs_plt = 0;
2108 }
2109
2110 return TRUE;
2111 }
2112 else
2113 h->plt.offset = (bfd_vma) -1;
2114
2115 /* If this is a weak symbol, and there is a real definition, the
2116 processor independent code will have arranged for us to see the
2117 real definition first, and we can just use the same value. */
2118 if (h->u.weakdef != NULL)
2119 {
2120 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2121 || h->u.weakdef->root.type == bfd_link_hash_defweak);
2122 h->root.u.def.section = h->u.weakdef->root.u.def.section;
2123 h->root.u.def.value = h->u.weakdef->root.u.def.value;
2124 return TRUE;
2125 }
2126
2127 /* This is a reference to a symbol defined by a dynamic object which
2128 is not a function. */
2129
2130 /* If we are creating a shared library, we must presume that the
2131 only references to the symbol are via the global offset table.
2132 For such cases we need not do anything here; the relocations will
2133 be handled correctly by relocate_section. */
2134 if (info->shared)
2135 return TRUE;
2136
2137 /* If there are no references to this symbol that do not use the
2138 GOT, we don't need to generate a copy reloc. */
2139 if (!h->non_got_ref)
2140 return TRUE;
2141
2142 /* If -z nocopyreloc was given, we won't generate them either. */
2143 if (info->nocopyreloc)
2144 {
2145 h->non_got_ref = 0;
2146 return TRUE;
2147 }
2148
2149 eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
2150 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2151 {
2152 s = p->sec->output_section;
2153 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2154 break;
2155 }
2156
2157 /* If we didn't find any dynamic relocs in read-only sections, then
2158 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2159 if (p == NULL)
2160 {
2161 h->non_got_ref = 0;
2162 return TRUE;
2163 }
2164
2165 /* We must allocate the symbol in our .dynbss section, which will
2166 become part of the .bss section of the executable. There will be
2167 an entry for this symbol in the .dynsym section. The dynamic
2168 object will contain position independent code, so all references
2169 from the dynamic object to this symbol will go through the global
2170 offset table. The dynamic linker will use the .dynsym entry to
2171 determine the address it must put in the global offset table, so
2172 both the dynamic object and the regular object will refer to the
2173 same memory location for the variable. */
2174
2175 /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker
2176 to copy the initial value out of the dynamic object and into the
2177 runtime process image. We need to remember the offset into the
2178 .rel.bss section we are going to use. */
2179 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
2180 {
2181 htab->srelbss->size += SPARC_ELF_RELA_BYTES (htab);
2182 h->needs_copy = 1;
2183 }
2184
2185 s = htab->sdynbss;
2186
2187 return _bfd_elf_adjust_dynamic_copy (h, s);
2188 }
2189
2190 /* Allocate space in .plt, .got and associated reloc sections for
2191 dynamic relocs. */
2192
2193 static bfd_boolean
2194 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
2195 {
2196 struct bfd_link_info *info;
2197 struct _bfd_sparc_elf_link_hash_table *htab;
2198 struct _bfd_sparc_elf_link_hash_entry *eh;
2199 struct _bfd_sparc_elf_dyn_relocs *p;
2200
2201 if (h->root.type == bfd_link_hash_indirect)
2202 return TRUE;
2203
2204 info = (struct bfd_link_info *) inf;
2205 htab = _bfd_sparc_elf_hash_table (info);
2206 BFD_ASSERT (htab != NULL);
2207
2208 if ((htab->elf.dynamic_sections_created
2209 && h->plt.refcount > 0)
2210 || (h->type == STT_GNU_IFUNC
2211 && h->def_regular
2212 && h->ref_regular))
2213 {
2214 /* Make sure this symbol is output as a dynamic symbol.
2215 Undefined weak syms won't yet be marked as dynamic. */
2216 if (h->dynindx == -1
2217 && !h->forced_local)
2218 {
2219 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2220 return FALSE;
2221 }
2222
2223 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h)
2224 || (h->type == STT_GNU_IFUNC
2225 && h->def_regular))
2226 {
2227 asection *s = htab->elf.splt;
2228
2229 if (s == NULL)
2230 s = htab->elf.iplt;
2231
2232 /* Allocate room for the header. */
2233 if (s->size == 0)
2234 {
2235 s->size = htab->plt_header_size;
2236
2237 /* Allocate space for the .rela.plt.unloaded relocations. */
2238 if (htab->is_vxworks && !info->shared)
2239 htab->srelplt2->size = sizeof (Elf32_External_Rela) * 2;
2240 }
2241
2242 /* The procedure linkage table size is bounded by the magnitude
2243 of the offset we can describe in the entry. */
2244 if (s->size >= (SPARC_ELF_WORD_BYTES(htab) == 8 ?
2245 (((bfd_vma)1 << 31) << 1) : 0x400000))
2246 {
2247 bfd_set_error (bfd_error_bad_value);
2248 return FALSE;
2249 }
2250
2251 if (SPARC_ELF_WORD_BYTES(htab) == 8
2252 && s->size >= PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE)
2253 {
2254 bfd_vma off = s->size - PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE;
2255
2256
2257 off = (off % (160 * PLT64_ENTRY_SIZE)) / PLT64_ENTRY_SIZE;
2258
2259 h->plt.offset = (s->size - (off * 8));
2260 }
2261 else
2262 h->plt.offset = s->size;
2263
2264 /* If this symbol is not defined in a regular file, and we are
2265 not generating a shared library, then set the symbol to this
2266 location in the .plt. This is required to make function
2267 pointers compare as equal between the normal executable and
2268 the shared library. */
2269 if (! info->shared
2270 && !h->def_regular)
2271 {
2272 h->root.u.def.section = s;
2273 h->root.u.def.value = h->plt.offset;
2274 }
2275
2276 /* Make room for this entry. */
2277 s->size += htab->plt_entry_size;
2278
2279 /* We also need to make an entry in the .rela.plt section. */
2280 if (s == htab->elf.splt)
2281 htab->elf.srelplt->size += SPARC_ELF_RELA_BYTES (htab);
2282 else
2283 htab->elf.irelplt->size += SPARC_ELF_RELA_BYTES (htab);
2284
2285 if (htab->is_vxworks)
2286 {
2287 /* Allocate space for the .got.plt entry. */
2288 htab->elf.sgotplt->size += 4;
2289
2290 /* ...and for the .rela.plt.unloaded relocations. */
2291 if (!info->shared)
2292 htab->srelplt2->size += sizeof (Elf32_External_Rela) * 3;
2293 }
2294 }
2295 else
2296 {
2297 h->plt.offset = (bfd_vma) -1;
2298 h->needs_plt = 0;
2299 }
2300 }
2301 else
2302 {
2303 h->plt.offset = (bfd_vma) -1;
2304 h->needs_plt = 0;
2305 }
2306
2307 /* If R_SPARC_TLS_IE_{HI22,LO10} symbol is now local to the binary,
2308 make it a R_SPARC_TLS_LE_{HI22,LO10} requiring no TLS entry. */
2309 if (h->got.refcount > 0
2310 && !info->shared
2311 && h->dynindx == -1
2312 && _bfd_sparc_elf_hash_entry(h)->tls_type == GOT_TLS_IE)
2313 h->got.offset = (bfd_vma) -1;
2314 else if (h->got.refcount > 0)
2315 {
2316 asection *s;
2317 bfd_boolean dyn;
2318 int tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
2319
2320 /* Make sure this symbol is output as a dynamic symbol.
2321 Undefined weak syms won't yet be marked as dynamic. */
2322 if (h->dynindx == -1
2323 && !h->forced_local)
2324 {
2325 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2326 return FALSE;
2327 }
2328
2329 s = htab->elf.sgot;
2330 h->got.offset = s->size;
2331 s->size += SPARC_ELF_WORD_BYTES (htab);
2332 /* R_SPARC_TLS_GD_HI{22,LO10} needs 2 consecutive GOT slots. */
2333 if (tls_type == GOT_TLS_GD)
2334 s->size += SPARC_ELF_WORD_BYTES (htab);
2335 dyn = htab->elf.dynamic_sections_created;
2336 /* R_SPARC_TLS_IE_{HI22,LO10} needs one dynamic relocation,
2337 R_SPARC_TLS_GD_{HI22,LO10} needs one if local symbol and two if
2338 global. */
2339 if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
2340 || tls_type == GOT_TLS_IE
2341 || h->type == STT_GNU_IFUNC)
2342 htab->elf.srelgot->size += SPARC_ELF_RELA_BYTES (htab);
2343 else if (tls_type == GOT_TLS_GD)
2344 htab->elf.srelgot->size += 2 * SPARC_ELF_RELA_BYTES (htab);
2345 else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
2346 htab->elf.srelgot->size += SPARC_ELF_RELA_BYTES (htab);
2347 }
2348 else
2349 h->got.offset = (bfd_vma) -1;
2350
2351 eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
2352 if (eh->dyn_relocs == NULL)
2353 return TRUE;
2354
2355 /* In the shared -Bsymbolic case, discard space allocated for
2356 dynamic pc-relative relocs against symbols which turn out to be
2357 defined in regular objects. For the normal shared case, discard
2358 space for pc-relative relocs that have become local due to symbol
2359 visibility changes. */
2360
2361 if (info->shared)
2362 {
2363 if (SYMBOL_CALLS_LOCAL (info, h))
2364 {
2365 struct _bfd_sparc_elf_dyn_relocs **pp;
2366
2367 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2368 {
2369 p->count -= p->pc_count;
2370 p->pc_count = 0;
2371 if (p->count == 0)
2372 *pp = p->next;
2373 else
2374 pp = &p->next;
2375 }
2376 }
2377
2378 if (htab->is_vxworks)
2379 {
2380 struct _bfd_sparc_elf_dyn_relocs **pp;
2381
2382 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2383 {
2384 if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
2385 *pp = p->next;
2386 else
2387 pp = &p->next;
2388 }
2389 }
2390
2391 /* Also discard relocs on undefined weak syms with non-default
2392 visibility. */
2393 if (eh->dyn_relocs != NULL
2394 && h->root.type == bfd_link_hash_undefweak)
2395 {
2396 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2397 eh->dyn_relocs = NULL;
2398
2399 /* Make sure undefined weak symbols are output as a dynamic
2400 symbol in PIEs. */
2401 else if (h->dynindx == -1
2402 && !h->forced_local)
2403 {
2404 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2405 return FALSE;
2406 }
2407 }
2408 }
2409 else
2410 {
2411 /* For the non-shared case, discard space for relocs against
2412 symbols which turn out to need copy relocs or are not
2413 dynamic. */
2414
2415 if (!h->non_got_ref
2416 && ((h->def_dynamic
2417 && !h->def_regular)
2418 || (htab->elf.dynamic_sections_created
2419 && (h->root.type == bfd_link_hash_undefweak
2420 || h->root.type == bfd_link_hash_undefined))))
2421 {
2422 /* Make sure this symbol is output as a dynamic symbol.
2423 Undefined weak syms won't yet be marked as dynamic. */
2424 if (h->dynindx == -1
2425 && !h->forced_local)
2426 {
2427 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2428 return FALSE;
2429 }
2430
2431 /* If that succeeded, we know we'll be keeping all the
2432 relocs. */
2433 if (h->dynindx != -1)
2434 goto keep;
2435 }
2436
2437 eh->dyn_relocs = NULL;
2438
2439 keep: ;
2440 }
2441
2442 /* Finally, allocate space. */
2443 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2444 {
2445 asection *sreloc = elf_section_data (p->sec)->sreloc;
2446 sreloc->size += p->count * SPARC_ELF_RELA_BYTES (htab);
2447 }
2448
2449 return TRUE;
2450 }
2451
2452 /* Allocate space in .plt, .got and associated reloc sections for
2453 local dynamic relocs. */
2454
2455 static bfd_boolean
2456 allocate_local_dynrelocs (void **slot, void *inf)
2457 {
2458 struct elf_link_hash_entry *h
2459 = (struct elf_link_hash_entry *) *slot;
2460
2461 if (h->type != STT_GNU_IFUNC
2462 || !h->def_regular
2463 || !h->ref_regular
2464 || !h->forced_local
2465 || h->root.type != bfd_link_hash_defined)
2466 abort ();
2467
2468 return allocate_dynrelocs (h, inf);
2469 }
2470
2471 /* Find any dynamic relocs that apply to read-only sections. */
2472
2473 static bfd_boolean
2474 readonly_dynrelocs (struct elf_link_hash_entry *h, void * inf)
2475 {
2476 struct _bfd_sparc_elf_link_hash_entry *eh;
2477 struct _bfd_sparc_elf_dyn_relocs *p;
2478
2479 eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
2480 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2481 {
2482 asection *s = p->sec->output_section;
2483
2484 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2485 {
2486 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2487
2488 info->flags |= DF_TEXTREL;
2489
2490 /* Not an error, just cut short the traversal. */
2491 return FALSE;
2492 }
2493 }
2494 return TRUE;
2495 }
2496
2497 /* Return true if the dynamic symbol for a given section should be
2498 omitted when creating a shared library. */
2499
2500 bfd_boolean
2501 _bfd_sparc_elf_omit_section_dynsym (bfd *output_bfd,
2502 struct bfd_link_info *info,
2503 asection *p)
2504 {
2505 /* We keep the .got section symbol so that explicit relocations
2506 against the _GLOBAL_OFFSET_TABLE_ symbol emitted in PIC mode
2507 can be turned into relocations against the .got symbol. */
2508 if (strcmp (p->name, ".got") == 0)
2509 return FALSE;
2510
2511 return _bfd_elf_link_omit_section_dynsym (output_bfd, info, p);
2512 }
2513
2514 /* Set the sizes of the dynamic sections. */
2515
2516 bfd_boolean
2517 _bfd_sparc_elf_size_dynamic_sections (bfd *output_bfd,
2518 struct bfd_link_info *info)
2519 {
2520 struct _bfd_sparc_elf_link_hash_table *htab;
2521 bfd *dynobj;
2522 asection *s;
2523 bfd *ibfd;
2524
2525 htab = _bfd_sparc_elf_hash_table (info);
2526 BFD_ASSERT (htab != NULL);
2527 dynobj = htab->elf.dynobj;
2528 BFD_ASSERT (dynobj != NULL);
2529
2530 if (elf_hash_table (info)->dynamic_sections_created)
2531 {
2532 /* Set the contents of the .interp section to the interpreter. */
2533 if (info->executable)
2534 {
2535 s = bfd_get_linker_section (dynobj, ".interp");
2536 BFD_ASSERT (s != NULL);
2537 s->size = htab->dynamic_interpreter_size;
2538 s->contents = (unsigned char *) htab->dynamic_interpreter;
2539 }
2540 }
2541
2542 /* Set up .got offsets for local syms, and space for local dynamic
2543 relocs. */
2544 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2545 {
2546 bfd_signed_vma *local_got;
2547 bfd_signed_vma *end_local_got;
2548 char *local_tls_type;
2549 bfd_size_type locsymcount;
2550 Elf_Internal_Shdr *symtab_hdr;
2551 asection *srel;
2552
2553 if (! is_sparc_elf (ibfd))
2554 continue;
2555
2556 for (s = ibfd->sections; s != NULL; s = s->next)
2557 {
2558 struct _bfd_sparc_elf_dyn_relocs *p;
2559
2560 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
2561 {
2562 if (!bfd_is_abs_section (p->sec)
2563 && bfd_is_abs_section (p->sec->output_section))
2564 {
2565 /* Input section has been discarded, either because
2566 it is a copy of a linkonce section or due to
2567 linker script /DISCARD/, so we'll be discarding
2568 the relocs too. */
2569 }
2570 else if (htab->is_vxworks
2571 && strcmp (p->sec->output_section->name,
2572 ".tls_vars") == 0)
2573 {
2574 /* Relocations in vxworks .tls_vars sections are
2575 handled specially by the loader. */
2576 }
2577 else if (p->count != 0)
2578 {
2579 srel = elf_section_data (p->sec)->sreloc;
2580 if (!htab->elf.dynamic_sections_created)
2581 srel = htab->elf.irelplt;
2582 srel->size += p->count * SPARC_ELF_RELA_BYTES (htab);
2583 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2584 info->flags |= DF_TEXTREL;
2585 }
2586 }
2587 }
2588
2589 local_got = elf_local_got_refcounts (ibfd);
2590 if (!local_got)
2591 continue;
2592
2593 symtab_hdr = &elf_symtab_hdr (ibfd);
2594 locsymcount = symtab_hdr->sh_info;
2595 end_local_got = local_got + locsymcount;
2596 local_tls_type = _bfd_sparc_elf_local_got_tls_type (ibfd);
2597 s = htab->elf.sgot;
2598 srel = htab->elf.srelgot;
2599 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
2600 {
2601 if (*local_got > 0)
2602 {
2603 *local_got = s->size;
2604 s->size += SPARC_ELF_WORD_BYTES (htab);
2605 if (*local_tls_type == GOT_TLS_GD)
2606 s->size += SPARC_ELF_WORD_BYTES (htab);
2607 if (info->shared
2608 || *local_tls_type == GOT_TLS_GD
2609 || *local_tls_type == GOT_TLS_IE)
2610 srel->size += SPARC_ELF_RELA_BYTES (htab);
2611 }
2612 else
2613 *local_got = (bfd_vma) -1;
2614 }
2615 }
2616
2617 if (htab->tls_ldm_got.refcount > 0)
2618 {
2619 /* Allocate 2 got entries and 1 dynamic reloc for
2620 R_SPARC_TLS_LDM_{HI22,LO10} relocs. */
2621 htab->tls_ldm_got.offset = htab->elf.sgot->size;
2622 htab->elf.sgot->size += (2 * SPARC_ELF_WORD_BYTES (htab));
2623 htab->elf.srelgot->size += SPARC_ELF_RELA_BYTES (htab);
2624 }
2625 else
2626 htab->tls_ldm_got.offset = -1;
2627
2628 /* Allocate global sym .plt and .got entries, and space for global
2629 sym dynamic relocs. */
2630 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
2631
2632 /* Allocate .plt and .got entries, and space for local symbols. */
2633 htab_traverse (htab->loc_hash_table, allocate_local_dynrelocs, info);
2634
2635 if (! ABI_64_P (output_bfd)
2636 && !htab->is_vxworks
2637 && elf_hash_table (info)->dynamic_sections_created)
2638 {
2639 /* Make space for the trailing nop in .plt. */
2640 if (htab->elf.splt->size > 0)
2641 htab->elf.splt->size += 1 * SPARC_INSN_BYTES;
2642
2643 /* If the .got section is more than 0x1000 bytes, we add
2644 0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13
2645 bit relocations have a greater chance of working.
2646
2647 FIXME: Make this optimization work for 64-bit too. */
2648 if (htab->elf.sgot->size >= 0x1000
2649 && elf_hash_table (info)->hgot->root.u.def.value == 0)
2650 elf_hash_table (info)->hgot->root.u.def.value = 0x1000;
2651 }
2652
2653 /* The check_relocs and adjust_dynamic_symbol entry points have
2654 determined the sizes of the various dynamic sections. Allocate
2655 memory for them. */
2656 for (s = dynobj->sections; s != NULL; s = s->next)
2657 {
2658 if ((s->flags & SEC_LINKER_CREATED) == 0)
2659 continue;
2660
2661 if (s == htab->elf.splt
2662 || s == htab->elf.sgot
2663 || s == htab->sdynbss
2664 || s == htab->elf.iplt
2665 || s == htab->elf.sgotplt)
2666 {
2667 /* Strip this section if we don't need it; see the
2668 comment below. */
2669 }
2670 else if (CONST_STRNEQ (s->name, ".rela"))
2671 {
2672 if (s->size != 0)
2673 {
2674 /* We use the reloc_count field as a counter if we need
2675 to copy relocs into the output file. */
2676 s->reloc_count = 0;
2677 }
2678 }
2679 else
2680 {
2681 /* It's not one of our sections. */
2682 continue;
2683 }
2684
2685 if (s->size == 0)
2686 {
2687 /* If we don't need this section, strip it from the
2688 output file. This is mostly to handle .rela.bss and
2689 .rela.plt. We must create both sections in
2690 create_dynamic_sections, because they must be created
2691 before the linker maps input sections to output
2692 sections. The linker does that before
2693 adjust_dynamic_symbol is called, and it is that
2694 function which decides whether anything needs to go
2695 into these sections. */
2696 s->flags |= SEC_EXCLUDE;
2697 continue;
2698 }
2699
2700 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2701 continue;
2702
2703 /* Allocate memory for the section contents. Zero the memory
2704 for the benefit of .rela.plt, which has 4 unused entries
2705 at the beginning, and we don't want garbage. */
2706 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2707 if (s->contents == NULL)
2708 return FALSE;
2709 }
2710
2711 if (elf_hash_table (info)->dynamic_sections_created)
2712 {
2713 /* Add some entries to the .dynamic section. We fill in the
2714 values later, in _bfd_sparc_elf_finish_dynamic_sections, but we
2715 must add the entries now so that we get the correct size for
2716 the .dynamic section. The DT_DEBUG entry is filled in by the
2717 dynamic linker and used by the debugger. */
2718 #define add_dynamic_entry(TAG, VAL) \
2719 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2720
2721 if (info->executable)
2722 {
2723 if (!add_dynamic_entry (DT_DEBUG, 0))
2724 return FALSE;
2725 }
2726
2727 if (htab->elf.srelplt->size != 0)
2728 {
2729 if (!add_dynamic_entry (DT_PLTGOT, 0)
2730 || !add_dynamic_entry (DT_PLTRELSZ, 0)
2731 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2732 || !add_dynamic_entry (DT_JMPREL, 0))
2733 return FALSE;
2734 }
2735
2736 if (!add_dynamic_entry (DT_RELA, 0)
2737 || !add_dynamic_entry (DT_RELASZ, 0)
2738 || !add_dynamic_entry (DT_RELAENT,
2739 SPARC_ELF_RELA_BYTES (htab)))
2740 return FALSE;
2741
2742 /* If any dynamic relocs apply to a read-only section,
2743 then we need a DT_TEXTREL entry. */
2744 if ((info->flags & DF_TEXTREL) == 0)
2745 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
2746
2747 if (info->flags & DF_TEXTREL)
2748 {
2749 if (!add_dynamic_entry (DT_TEXTREL, 0))
2750 return FALSE;
2751 }
2752
2753 if (ABI_64_P (output_bfd))
2754 {
2755 int reg;
2756 struct _bfd_sparc_elf_app_reg * app_regs;
2757 struct elf_strtab_hash *dynstr;
2758 struct elf_link_hash_table *eht = elf_hash_table (info);
2759
2760 /* Add dynamic STT_REGISTER symbols and corresponding DT_SPARC_REGISTER
2761 entries if needed. */
2762 app_regs = _bfd_sparc_elf_hash_table (info)->app_regs;
2763 dynstr = eht->dynstr;
2764
2765 for (reg = 0; reg < 4; reg++)
2766 if (app_regs [reg].name != NULL)
2767 {
2768 struct elf_link_local_dynamic_entry *entry, *e;
2769
2770 if (!add_dynamic_entry (DT_SPARC_REGISTER, 0))
2771 return FALSE;
2772
2773 entry = (struct elf_link_local_dynamic_entry *)
2774 bfd_hash_allocate (&info->hash->table, sizeof (*entry));
2775 if (entry == NULL)
2776 return FALSE;
2777
2778 /* We cheat here a little bit: the symbol will not be local, so we
2779 put it at the end of the dynlocal linked list. We will fix it
2780 later on, as we have to fix other fields anyway. */
2781 entry->isym.st_value = reg < 2 ? reg + 2 : reg + 4;
2782 entry->isym.st_size = 0;
2783 if (*app_regs [reg].name != '\0')
2784 entry->isym.st_name
2785 = _bfd_elf_strtab_add (dynstr, app_regs[reg].name, FALSE);
2786 else
2787 entry->isym.st_name = 0;
2788 entry->isym.st_other = 0;
2789 entry->isym.st_info = ELF_ST_INFO (app_regs [reg].bind,
2790 STT_REGISTER);
2791 entry->isym.st_shndx = app_regs [reg].shndx;
2792 entry->isym.st_target_internal = 0;
2793 entry->next = NULL;
2794 entry->input_bfd = output_bfd;
2795 entry->input_indx = -1;
2796
2797 if (eht->dynlocal == NULL)
2798 eht->dynlocal = entry;
2799 else
2800 {
2801 for (e = eht->dynlocal; e->next; e = e->next)
2802 ;
2803 e->next = entry;
2804 }
2805 eht->dynsymcount++;
2806 }
2807 }
2808 if (htab->is_vxworks
2809 && !elf_vxworks_add_dynamic_entries (output_bfd, info))
2810 return FALSE;
2811 }
2812 #undef add_dynamic_entry
2813
2814 return TRUE;
2815 }
2816 \f
2817 bfd_boolean
2818 _bfd_sparc_elf_new_section_hook (bfd *abfd, asection *sec)
2819 {
2820 if (!sec->used_by_bfd)
2821 {
2822 struct _bfd_sparc_elf_section_data *sdata;
2823 bfd_size_type amt = sizeof (*sdata);
2824
2825 sdata = bfd_zalloc (abfd, amt);
2826 if (sdata == NULL)
2827 return FALSE;
2828 sec->used_by_bfd = sdata;
2829 }
2830
2831 return _bfd_elf_new_section_hook (abfd, sec);
2832 }
2833
2834 bfd_boolean
2835 _bfd_sparc_elf_relax_section (bfd *abfd ATTRIBUTE_UNUSED,
2836 struct bfd_section *section,
2837 struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
2838 bfd_boolean *again)
2839 {
2840 if (link_info->relocatable)
2841 (*link_info->callbacks->einfo)
2842 (_("%P%F: --relax and -r may not be used together\n"));
2843
2844 *again = FALSE;
2845 sec_do_relax (section) = 1;
2846 return TRUE;
2847 }
2848 \f
2849 /* Return the base VMA address which should be subtracted from real addresses
2850 when resolving @dtpoff relocation.
2851 This is PT_TLS segment p_vaddr. */
2852
2853 static bfd_vma
2854 dtpoff_base (struct bfd_link_info *info)
2855 {
2856 /* If tls_sec is NULL, we should have signalled an error already. */
2857 if (elf_hash_table (info)->tls_sec == NULL)
2858 return 0;
2859 return elf_hash_table (info)->tls_sec->vma;
2860 }
2861
2862 /* Return the relocation value for @tpoff relocation
2863 if STT_TLS virtual address is ADDRESS. */
2864
2865 static bfd_vma
2866 tpoff (struct bfd_link_info *info, bfd_vma address)
2867 {
2868 struct elf_link_hash_table *htab = elf_hash_table (info);
2869 const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
2870 bfd_vma static_tls_size;
2871
2872 /* If tls_sec is NULL, we should have signalled an error already. */
2873 if (htab->tls_sec == NULL)
2874 return 0;
2875
2876 /* Consider special static TLS alignment requirements. */
2877 static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
2878 return address - static_tls_size - htab->tls_sec->vma;
2879 }
2880
2881 /* Return the relocation value for a %gdop relocation. */
2882
2883 static bfd_vma
2884 gdopoff (struct bfd_link_info *info, bfd_vma address)
2885 {
2886 struct elf_link_hash_table *htab = elf_hash_table (info);
2887 bfd_vma got_base;
2888
2889 got_base = (htab->hgot->root.u.def.value
2890 + htab->hgot->root.u.def.section->output_offset
2891 + htab->hgot->root.u.def.section->output_section->vma);
2892
2893 return address - got_base;
2894 }
2895
2896 /* Relocate a SPARC ELF section. */
2897
2898 bfd_boolean
2899 _bfd_sparc_elf_relocate_section (bfd *output_bfd,
2900 struct bfd_link_info *info,
2901 bfd *input_bfd,
2902 asection *input_section,
2903 bfd_byte *contents,
2904 Elf_Internal_Rela *relocs,
2905 Elf_Internal_Sym *local_syms,
2906 asection **local_sections)
2907 {
2908 struct _bfd_sparc_elf_link_hash_table *htab;
2909 Elf_Internal_Shdr *symtab_hdr;
2910 struct elf_link_hash_entry **sym_hashes;
2911 bfd_vma *local_got_offsets;
2912 bfd_vma got_base;
2913 asection *sreloc;
2914 Elf_Internal_Rela *rel;
2915 Elf_Internal_Rela *relend;
2916 int num_relocs;
2917 bfd_boolean is_vxworks_tls;
2918
2919 htab = _bfd_sparc_elf_hash_table (info);
2920 BFD_ASSERT (htab != NULL);
2921 symtab_hdr = &elf_symtab_hdr (input_bfd);
2922 sym_hashes = elf_sym_hashes (input_bfd);
2923 local_got_offsets = elf_local_got_offsets (input_bfd);
2924
2925 if (elf_hash_table (info)->hgot == NULL)
2926 got_base = 0;
2927 else
2928 got_base = elf_hash_table (info)->hgot->root.u.def.value;
2929
2930 sreloc = elf_section_data (input_section)->sreloc;
2931 /* We have to handle relocations in vxworks .tls_vars sections
2932 specially, because the dynamic loader is 'weird'. */
2933 is_vxworks_tls = (htab->is_vxworks && info->shared
2934 && !strcmp (input_section->output_section->name,
2935 ".tls_vars"));
2936
2937 rel = relocs;
2938 if (ABI_64_P (output_bfd))
2939 num_relocs = NUM_SHDR_ENTRIES (_bfd_elf_single_rel_hdr (input_section));
2940 else
2941 num_relocs = input_section->reloc_count;
2942 relend = relocs + num_relocs;
2943 for (; rel < relend; rel++)
2944 {
2945 int r_type, tls_type;
2946 reloc_howto_type *howto;
2947 unsigned long r_symndx;
2948 struct elf_link_hash_entry *h;
2949 Elf_Internal_Sym *sym;
2950 asection *sec;
2951 bfd_vma relocation, off;
2952 bfd_reloc_status_type r;
2953 bfd_boolean is_plt = FALSE;
2954 bfd_boolean unresolved_reloc;
2955
2956 r_type = SPARC_ELF_R_TYPE (rel->r_info);
2957 if (r_type == R_SPARC_GNU_VTINHERIT
2958 || r_type == R_SPARC_GNU_VTENTRY)
2959 continue;
2960
2961 if (r_type < 0 || r_type >= (int) R_SPARC_max_std)
2962 {
2963 bfd_set_error (bfd_error_bad_value);
2964 return FALSE;
2965 }
2966 howto = _bfd_sparc_elf_howto_table + r_type;
2967
2968 r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
2969 h = NULL;
2970 sym = NULL;
2971 sec = NULL;
2972 unresolved_reloc = FALSE;
2973 if (r_symndx < symtab_hdr->sh_info)
2974 {
2975 sym = local_syms + r_symndx;
2976 sec = local_sections[r_symndx];
2977 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2978
2979 if (!info->relocatable
2980 && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
2981 {
2982 /* Relocate against local STT_GNU_IFUNC symbol. */
2983 h = elf_sparc_get_local_sym_hash (htab, input_bfd,
2984 rel, FALSE);
2985 if (h == NULL)
2986 abort ();
2987
2988 /* Set STT_GNU_IFUNC symbol value. */
2989 h->root.u.def.value = sym->st_value;
2990 h->root.u.def.section = sec;
2991 }
2992 }
2993 else
2994 {
2995 bfd_boolean warned;
2996
2997 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2998 r_symndx, symtab_hdr, sym_hashes,
2999 h, sec, relocation,
3000 unresolved_reloc, warned);
3001 if (warned)
3002 {
3003 /* To avoid generating warning messages about truncated
3004 relocations, set the relocation's address to be the same as
3005 the start of this section. */
3006 if (input_section->output_section != NULL)
3007 relocation = input_section->output_section->vma;
3008 else
3009 relocation = 0;
3010 }
3011 }
3012
3013 if (sec != NULL && discarded_section (sec))
3014 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
3015 rel, 1, relend, howto, 0, contents);
3016
3017 if (info->relocatable)
3018 continue;
3019
3020 if (h != NULL
3021 && h->type == STT_GNU_IFUNC
3022 && h->def_regular)
3023 {
3024 asection *plt_sec;
3025 const char *name;
3026
3027 if ((input_section->flags & SEC_ALLOC) == 0
3028 || h->plt.offset == (bfd_vma) -1)
3029 abort ();
3030
3031 plt_sec = htab->elf.splt;
3032 if (! plt_sec)
3033 plt_sec =htab->elf.iplt;
3034
3035 switch (r_type)
3036 {
3037 case R_SPARC_GOTDATA_OP:
3038 continue;
3039
3040 case R_SPARC_GOTDATA_OP_HIX22:
3041 case R_SPARC_GOTDATA_OP_LOX10:
3042 r_type = (r_type == R_SPARC_GOTDATA_OP_HIX22
3043 ? R_SPARC_GOT22
3044 : R_SPARC_GOT10);
3045 howto = _bfd_sparc_elf_howto_table + r_type;
3046 /* Fall through. */
3047
3048 case R_SPARC_GOT10:
3049 case R_SPARC_GOT13:
3050 case R_SPARC_GOT22:
3051 if (htab->elf.sgot == NULL)
3052 abort ();
3053 off = h->got.offset;
3054 if (off == (bfd_vma) -1)
3055 abort();
3056 relocation = htab->elf.sgot->output_offset + off - got_base;
3057 goto do_relocation;
3058
3059 case R_SPARC_WPLT30:
3060 case R_SPARC_WDISP30:
3061 relocation = (plt_sec->output_section->vma
3062 + plt_sec->output_offset + h->plt.offset);
3063 goto do_relocation;
3064
3065 case R_SPARC_32:
3066 case R_SPARC_64:
3067 if (info->shared && h->non_got_ref)
3068 {
3069 Elf_Internal_Rela outrel;
3070 bfd_vma offset;
3071
3072 offset = _bfd_elf_section_offset (output_bfd, info,
3073 input_section,
3074 rel->r_offset);
3075 if (offset == (bfd_vma) -1
3076 || offset == (bfd_vma) -2)
3077 abort();
3078
3079 outrel.r_offset = (input_section->output_section->vma
3080 + input_section->output_offset
3081 + offset);
3082
3083 if (h->dynindx == -1
3084 || h->forced_local
3085 || info->executable)
3086 {
3087 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
3088 0, R_SPARC_IRELATIVE);
3089 outrel.r_addend = relocation + rel->r_addend;
3090 }
3091 else
3092 {
3093 if (h->dynindx == -1)
3094 abort();
3095 outrel.r_info = SPARC_ELF_R_INFO (htab, rel, h->dynindx, r_type);
3096 outrel.r_addend = rel->r_addend;
3097 }
3098
3099 sparc_elf_append_rela (output_bfd, sreloc, &outrel);
3100 continue;
3101 }
3102
3103 relocation = (plt_sec->output_section->vma
3104 + plt_sec->output_offset + h->plt.offset);
3105 goto do_relocation;
3106
3107 case R_SPARC_HI22:
3108 case R_SPARC_LO10:
3109 /* We should only see such relocs in static links. */
3110 if (info->shared)
3111 abort();
3112 relocation = (plt_sec->output_section->vma
3113 + plt_sec->output_offset + h->plt.offset);
3114 goto do_relocation;
3115
3116 default:
3117 if (h->root.root.string)
3118 name = h->root.root.string;
3119 else
3120 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3121 NULL);
3122 (*_bfd_error_handler)
3123 (_("%B: relocation %s against STT_GNU_IFUNC "
3124 "symbol `%s' isn't handled by %s"), input_bfd,
3125 _bfd_sparc_elf_howto_table[r_type].name,
3126 name, __FUNCTION__);
3127 bfd_set_error (bfd_error_bad_value);
3128 return FALSE;
3129 }
3130 }
3131
3132 switch (r_type)
3133 {
3134 case R_SPARC_GOTDATA_OP_HIX22:
3135 case R_SPARC_GOTDATA_OP_LOX10:
3136 if (SYMBOL_REFERENCES_LOCAL (info, h))
3137 r_type = (r_type == R_SPARC_GOTDATA_OP_HIX22
3138 ? R_SPARC_GOTDATA_HIX22
3139 : R_SPARC_GOTDATA_LOX10);
3140 else
3141 r_type = (r_type == R_SPARC_GOTDATA_OP_HIX22
3142 ? R_SPARC_GOT22
3143 : R_SPARC_GOT10);
3144 howto = _bfd_sparc_elf_howto_table + r_type;
3145 break;
3146
3147 case R_SPARC_GOTDATA_OP:
3148 if (SYMBOL_REFERENCES_LOCAL (info, h))
3149 {
3150 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3151
3152 /* {ld,ldx} [%rs1 + %rs2], %rd --> add %rs1, %rs2, %rd */
3153 relocation = 0x80000000 | (insn & 0x3e07c01f);
3154 bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3155 }
3156 continue;
3157 }
3158
3159 switch (r_type)
3160 {
3161 case R_SPARC_GOTDATA_HIX22:
3162 case R_SPARC_GOTDATA_LOX10:
3163 relocation = gdopoff (info, relocation);
3164 break;
3165
3166 case R_SPARC_GOT10:
3167 case R_SPARC_GOT13:
3168 case R_SPARC_GOT22:
3169 /* Relocation is to the entry for this symbol in the global
3170 offset table. */
3171 if (htab->elf.sgot == NULL)
3172 abort ();
3173
3174 if (h != NULL)
3175 {
3176 bfd_boolean dyn;
3177
3178 off = h->got.offset;
3179 BFD_ASSERT (off != (bfd_vma) -1);
3180 dyn = elf_hash_table (info)->dynamic_sections_created;
3181
3182 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3183 || (info->shared
3184 && SYMBOL_REFERENCES_LOCAL (info, h)))
3185 {
3186 /* This is actually a static link, or it is a
3187 -Bsymbolic link and the symbol is defined
3188 locally, or the symbol was forced to be local
3189 because of a version file. We must initialize
3190 this entry in the global offset table. Since the
3191 offset must always be a multiple of 8 for 64-bit
3192 and 4 for 32-bit, we use the least significant bit
3193 to record whether we have initialized it already.
3194
3195 When doing a dynamic link, we create a .rela.got
3196 relocation entry to initialize the value. This
3197 is done in the finish_dynamic_symbol routine. */
3198 if ((off & 1) != 0)
3199 off &= ~1;
3200 else
3201 {
3202 SPARC_ELF_PUT_WORD (htab, output_bfd, relocation,
3203 htab->elf.sgot->contents + off);
3204 h->got.offset |= 1;
3205 }
3206 }
3207 else
3208 unresolved_reloc = FALSE;
3209 }
3210 else
3211 {
3212 BFD_ASSERT (local_got_offsets != NULL
3213 && local_got_offsets[r_symndx] != (bfd_vma) -1);
3214
3215 off = local_got_offsets[r_symndx];
3216
3217 /* The offset must always be a multiple of 8 on 64-bit and
3218 4 on 32-bit. We use the least significant bit to record
3219 whether we have already processed this entry. */
3220 if ((off & 1) != 0)
3221 off &= ~1;
3222 else
3223 {
3224
3225 if (info->shared)
3226 {
3227 asection *s;
3228 Elf_Internal_Rela outrel;
3229
3230 /* We need to generate a R_SPARC_RELATIVE reloc
3231 for the dynamic linker. */
3232 s = htab->elf.srelgot;
3233 BFD_ASSERT (s != NULL);
3234
3235 outrel.r_offset = (htab->elf.sgot->output_section->vma
3236 + htab->elf.sgot->output_offset
3237 + off);
3238 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
3239 0, R_SPARC_RELATIVE);
3240 outrel.r_addend = relocation;
3241 relocation = 0;
3242 sparc_elf_append_rela (output_bfd, s, &outrel);
3243 }
3244
3245 SPARC_ELF_PUT_WORD (htab, output_bfd, relocation,
3246 htab->elf.sgot->contents + off);
3247 local_got_offsets[r_symndx] |= 1;
3248 }
3249 }
3250 relocation = htab->elf.sgot->output_offset + off - got_base;
3251 break;
3252
3253 case R_SPARC_PLT32:
3254 case R_SPARC_PLT64:
3255 if (h == NULL || h->plt.offset == (bfd_vma) -1)
3256 {
3257 r_type = (r_type == R_SPARC_PLT32) ? R_SPARC_32 : R_SPARC_64;
3258 goto r_sparc_plt32;
3259 }
3260 /* Fall through. */
3261
3262 case R_SPARC_WPLT30:
3263 case R_SPARC_HIPLT22:
3264 case R_SPARC_LOPLT10:
3265 case R_SPARC_PCPLT32:
3266 case R_SPARC_PCPLT22:
3267 case R_SPARC_PCPLT10:
3268 r_sparc_wplt30:
3269 /* Relocation is to the entry for this symbol in the
3270 procedure linkage table. */
3271
3272 if (! ABI_64_P (output_bfd))
3273 {
3274 /* The Solaris native assembler will generate a WPLT30 reloc
3275 for a local symbol if you assemble a call from one
3276 section to another when using -K pic. We treat it as
3277 WDISP30. */
3278 if (h == NULL)
3279 break;
3280 }
3281 /* PR 7027: We need similar behaviour for 64-bit binaries. */
3282 else if (r_type == R_SPARC_WPLT30 && h == NULL)
3283 break;
3284 else
3285 {
3286 BFD_ASSERT (h != NULL);
3287 }
3288
3289 if (h->plt.offset == (bfd_vma) -1 || htab->elf.splt == NULL)
3290 {
3291 /* We didn't make a PLT entry for this symbol. This
3292 happens when statically linking PIC code, or when
3293 using -Bsymbolic. */
3294 break;
3295 }
3296
3297 relocation = (htab->elf.splt->output_section->vma
3298 + htab->elf.splt->output_offset
3299 + h->plt.offset);
3300 unresolved_reloc = FALSE;
3301 if (r_type == R_SPARC_PLT32 || r_type == R_SPARC_PLT64)
3302 {
3303 r_type = r_type == R_SPARC_PLT32 ? R_SPARC_32 : R_SPARC_64;
3304 is_plt = TRUE;
3305 goto r_sparc_plt32;
3306 }
3307 break;
3308
3309 case R_SPARC_PC10:
3310 case R_SPARC_PC22:
3311 case R_SPARC_PC_HH22:
3312 case R_SPARC_PC_HM10:
3313 case R_SPARC_PC_LM22:
3314 if (h != NULL
3315 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3316 break;
3317 /* Fall through. */
3318 case R_SPARC_DISP8:
3319 case R_SPARC_DISP16:
3320 case R_SPARC_DISP32:
3321 case R_SPARC_DISP64:
3322 case R_SPARC_WDISP30:
3323 case R_SPARC_WDISP22:
3324 case R_SPARC_WDISP19:
3325 case R_SPARC_WDISP16:
3326 case R_SPARC_WDISP10:
3327 case R_SPARC_8:
3328 case R_SPARC_16:
3329 case R_SPARC_32:
3330 case R_SPARC_HI22:
3331 case R_SPARC_22:
3332 case R_SPARC_13:
3333 case R_SPARC_LO10:
3334 case R_SPARC_UA16:
3335 case R_SPARC_UA32:
3336 case R_SPARC_10:
3337 case R_SPARC_11:
3338 case R_SPARC_64:
3339 case R_SPARC_OLO10:
3340 case R_SPARC_HH22:
3341 case R_SPARC_HM10:
3342 case R_SPARC_LM22:
3343 case R_SPARC_7:
3344 case R_SPARC_5:
3345 case R_SPARC_6:
3346 case R_SPARC_HIX22:
3347 case R_SPARC_LOX10:
3348 case R_SPARC_H44:
3349 case R_SPARC_M44:
3350 case R_SPARC_L44:
3351 case R_SPARC_H34:
3352 case R_SPARC_UA64:
3353 r_sparc_plt32:
3354 if ((input_section->flags & SEC_ALLOC) == 0
3355 || is_vxworks_tls)
3356 break;
3357
3358 if ((info->shared
3359 && (h == NULL
3360 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3361 || h->root.type != bfd_link_hash_undefweak)
3362 && (! howto->pc_relative
3363 || !SYMBOL_CALLS_LOCAL (info, h)))
3364 || (!info->shared
3365 && h != NULL
3366 && h->dynindx != -1
3367 && !h->non_got_ref
3368 && ((h->def_dynamic
3369 && !h->def_regular)
3370 || h->root.type == bfd_link_hash_undefweak
3371 || h->root.type == bfd_link_hash_undefined)))
3372 {
3373 Elf_Internal_Rela outrel;
3374 bfd_boolean skip, relocate = FALSE;
3375
3376 /* When generating a shared object, these relocations
3377 are copied into the output file to be resolved at run
3378 time. */
3379
3380 BFD_ASSERT (sreloc != NULL);
3381
3382 skip = FALSE;
3383
3384 outrel.r_offset =
3385 _bfd_elf_section_offset (output_bfd, info, input_section,
3386 rel->r_offset);
3387 if (outrel.r_offset == (bfd_vma) -1)
3388 skip = TRUE;
3389 else if (outrel.r_offset == (bfd_vma) -2)
3390 skip = TRUE, relocate = TRUE;
3391 outrel.r_offset += (input_section->output_section->vma
3392 + input_section->output_offset);
3393
3394 /* Optimize unaligned reloc usage now that we know where
3395 it finally resides. */
3396 switch (r_type)
3397 {
3398 case R_SPARC_16:
3399 if (outrel.r_offset & 1)
3400 r_type = R_SPARC_UA16;
3401 break;
3402 case R_SPARC_UA16:
3403 if (!(outrel.r_offset & 1))
3404 r_type = R_SPARC_16;
3405 break;
3406 case R_SPARC_32:
3407 if (outrel.r_offset & 3)
3408 r_type = R_SPARC_UA32;
3409 break;
3410 case R_SPARC_UA32:
3411 if (!(outrel.r_offset & 3))
3412 r_type = R_SPARC_32;
3413 break;
3414 case R_SPARC_64:
3415 if (outrel.r_offset & 7)
3416 r_type = R_SPARC_UA64;
3417 break;
3418 case R_SPARC_UA64:
3419 if (!(outrel.r_offset & 7))
3420 r_type = R_SPARC_64;
3421 break;
3422 case R_SPARC_DISP8:
3423 case R_SPARC_DISP16:
3424 case R_SPARC_DISP32:
3425 case R_SPARC_DISP64:
3426 /* If the symbol is not dynamic, we should not keep
3427 a dynamic relocation. But an .rela.* slot has been
3428 allocated for it, output R_SPARC_NONE.
3429 FIXME: Add code tracking needed dynamic relocs as
3430 e.g. i386 has. */
3431 if (h->dynindx == -1)
3432 skip = TRUE, relocate = TRUE;
3433 break;
3434 }
3435
3436 if (skip)
3437 memset (&outrel, 0, sizeof outrel);
3438 /* h->dynindx may be -1 if the symbol was marked to
3439 become local. */
3440 else if (h != NULL &&
3441 h->dynindx != -1
3442 && (! is_plt
3443 || !info->shared
3444 || !SYMBOLIC_BIND (info, h)
3445 || !h->def_regular))
3446 {
3447 BFD_ASSERT (h->dynindx != -1);
3448 outrel.r_info = SPARC_ELF_R_INFO (htab, rel, h->dynindx, r_type);
3449 outrel.r_addend = rel->r_addend;
3450 }
3451 else
3452 {
3453 if (r_type == R_SPARC_32 || r_type == R_SPARC_64)
3454 {
3455 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
3456 0, R_SPARC_RELATIVE);
3457 outrel.r_addend = relocation + rel->r_addend;
3458 }
3459 else
3460 {
3461 long indx;
3462
3463 outrel.r_addend = relocation + rel->r_addend;
3464
3465 if (is_plt)
3466 sec = htab->elf.splt;
3467
3468 if (bfd_is_abs_section (sec))
3469 indx = 0;
3470 else if (sec == NULL || sec->owner == NULL)
3471 {
3472 bfd_set_error (bfd_error_bad_value);
3473 return FALSE;
3474 }
3475 else
3476 {
3477 asection *osec;
3478
3479 /* We are turning this relocation into one
3480 against a section symbol. It would be
3481 proper to subtract the symbol's value,
3482 osec->vma, from the emitted reloc addend,
3483 but ld.so expects buggy relocs. */
3484 osec = sec->output_section;
3485 indx = elf_section_data (osec)->dynindx;
3486
3487 if (indx == 0)
3488 {
3489 osec = htab->elf.text_index_section;
3490 indx = elf_section_data (osec)->dynindx;
3491 }
3492
3493 /* FIXME: we really should be able to link non-pic
3494 shared libraries. */
3495 if (indx == 0)
3496 {
3497 BFD_FAIL ();
3498 (*_bfd_error_handler)
3499 (_("%B: probably compiled without -fPIC?"),
3500 input_bfd);
3501 bfd_set_error (bfd_error_bad_value);
3502 return FALSE;
3503 }
3504 }
3505
3506 outrel.r_info = SPARC_ELF_R_INFO (htab, rel, indx,
3507 r_type);
3508 }
3509 }
3510
3511 sparc_elf_append_rela (output_bfd, sreloc, &outrel);
3512
3513 /* This reloc will be computed at runtime, so there's no
3514 need to do anything now. */
3515 if (! relocate)
3516 continue;
3517 }
3518 break;
3519
3520 case R_SPARC_TLS_GD_HI22:
3521 if (! ABI_64_P (input_bfd)
3522 && ! _bfd_sparc_elf_tdata (input_bfd)->has_tlsgd)
3523 {
3524 /* R_SPARC_REV32 used the same reloc number as
3525 R_SPARC_TLS_GD_HI22. */
3526 r_type = R_SPARC_REV32;
3527 break;
3528 }
3529 /* Fall through */
3530
3531 case R_SPARC_TLS_GD_LO10:
3532 case R_SPARC_TLS_IE_HI22:
3533 case R_SPARC_TLS_IE_LO10:
3534 r_type = sparc_elf_tls_transition (info, input_bfd, r_type, h == NULL);
3535 tls_type = GOT_UNKNOWN;
3536 if (h == NULL && local_got_offsets)
3537 tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3538 else if (h != NULL)
3539 {
3540 tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3541 if (!info->shared && h->dynindx == -1 && tls_type == GOT_TLS_IE)
3542 switch (SPARC_ELF_R_TYPE (rel->r_info))
3543 {
3544 case R_SPARC_TLS_GD_HI22:
3545 case R_SPARC_TLS_IE_HI22:
3546 r_type = R_SPARC_TLS_LE_HIX22;
3547 break;
3548 default:
3549 r_type = R_SPARC_TLS_LE_LOX10;
3550 break;
3551 }
3552 }
3553 if (tls_type == GOT_TLS_IE)
3554 switch (r_type)
3555 {
3556 case R_SPARC_TLS_GD_HI22:
3557 r_type = R_SPARC_TLS_IE_HI22;
3558 break;
3559 case R_SPARC_TLS_GD_LO10:
3560 r_type = R_SPARC_TLS_IE_LO10;
3561 break;
3562 }
3563
3564 if (r_type == R_SPARC_TLS_LE_HIX22)
3565 {
3566 relocation = tpoff (info, relocation);
3567 break;
3568 }
3569 if (r_type == R_SPARC_TLS_LE_LOX10)
3570 {
3571 /* Change add into xor. */
3572 relocation = tpoff (info, relocation);
3573 bfd_put_32 (output_bfd, (bfd_get_32 (input_bfd,
3574 contents + rel->r_offset)
3575 | 0x80182000), contents + rel->r_offset);
3576 break;
3577 }
3578
3579 if (h != NULL)
3580 {
3581 off = h->got.offset;
3582 h->got.offset |= 1;
3583 }
3584 else
3585 {
3586 BFD_ASSERT (local_got_offsets != NULL);
3587 off = local_got_offsets[r_symndx];
3588 local_got_offsets[r_symndx] |= 1;
3589 }
3590
3591 r_sparc_tlsldm:
3592 if (htab->elf.sgot == NULL)
3593 abort ();
3594
3595 if ((off & 1) != 0)
3596 off &= ~1;
3597 else
3598 {
3599 Elf_Internal_Rela outrel;
3600 int dr_type, indx;
3601
3602 if (htab->elf.srelgot == NULL)
3603 abort ();
3604
3605 SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3606 htab->elf.sgot->contents + off);
3607 outrel.r_offset = (htab->elf.sgot->output_section->vma
3608 + htab->elf.sgot->output_offset + off);
3609 indx = h && h->dynindx != -1 ? h->dynindx : 0;
3610 if (r_type == R_SPARC_TLS_IE_HI22
3611 || r_type == R_SPARC_TLS_IE_LO10)
3612 dr_type = SPARC_ELF_TPOFF_RELOC (htab);
3613 else
3614 dr_type = SPARC_ELF_DTPMOD_RELOC (htab);
3615 if (dr_type == SPARC_ELF_TPOFF_RELOC (htab) && indx == 0)
3616 outrel.r_addend = relocation - dtpoff_base (info);
3617 else
3618 outrel.r_addend = 0;
3619 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx, dr_type);
3620 sparc_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel);
3621
3622 if (r_type == R_SPARC_TLS_GD_HI22
3623 || r_type == R_SPARC_TLS_GD_LO10)
3624 {
3625 if (indx == 0)
3626 {
3627 BFD_ASSERT (! unresolved_reloc);
3628 SPARC_ELF_PUT_WORD (htab, output_bfd,
3629 relocation - dtpoff_base (info),
3630 (htab->elf.sgot->contents + off
3631 + SPARC_ELF_WORD_BYTES (htab)));
3632 }
3633 else
3634 {
3635 SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3636 (htab->elf.sgot->contents + off
3637 + SPARC_ELF_WORD_BYTES (htab)));
3638 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx,
3639 SPARC_ELF_DTPOFF_RELOC (htab));
3640 outrel.r_offset += SPARC_ELF_WORD_BYTES (htab);
3641 sparc_elf_append_rela (output_bfd, htab->elf.srelgot,
3642 &outrel);
3643 }
3644 }
3645 else if (dr_type == SPARC_ELF_DTPMOD_RELOC (htab))
3646 {
3647 SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3648 (htab->elf.sgot->contents + off
3649 + SPARC_ELF_WORD_BYTES (htab)));
3650 }
3651 }
3652
3653 if (off >= (bfd_vma) -2)
3654 abort ();
3655
3656 relocation = htab->elf.sgot->output_offset + off - got_base;
3657 unresolved_reloc = FALSE;
3658 howto = _bfd_sparc_elf_howto_table + r_type;
3659 break;
3660
3661 case R_SPARC_TLS_LDM_HI22:
3662 case R_SPARC_TLS_LDM_LO10:
3663 if (! info->shared)
3664 {
3665 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3666 continue;
3667 }
3668 off = htab->tls_ldm_got.offset;
3669 htab->tls_ldm_got.offset |= 1;
3670 goto r_sparc_tlsldm;
3671
3672 case R_SPARC_TLS_LDO_HIX22:
3673 case R_SPARC_TLS_LDO_LOX10:
3674 if (info->shared)
3675 {
3676 relocation -= dtpoff_base (info);
3677 break;
3678 }
3679
3680 r_type = (r_type == R_SPARC_TLS_LDO_HIX22
3681 ? R_SPARC_TLS_LE_HIX22 : R_SPARC_TLS_LE_LOX10);
3682 /* Fall through. */
3683
3684 case R_SPARC_TLS_LE_HIX22:
3685 case R_SPARC_TLS_LE_LOX10:
3686 if (info->shared)
3687 {
3688 Elf_Internal_Rela outrel;
3689 bfd_boolean skip;
3690
3691 BFD_ASSERT (sreloc != NULL);
3692 skip = FALSE;
3693 outrel.r_offset =
3694 _bfd_elf_section_offset (output_bfd, info, input_section,
3695 rel->r_offset);
3696 if (outrel.r_offset == (bfd_vma) -1)
3697 skip = TRUE;
3698 else if (outrel.r_offset == (bfd_vma) -2)
3699 skip = TRUE;
3700 outrel.r_offset += (input_section->output_section->vma
3701 + input_section->output_offset);
3702 if (skip)
3703 memset (&outrel, 0, sizeof outrel);
3704 else
3705 {
3706 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, r_type);
3707 outrel.r_addend = relocation - dtpoff_base (info)
3708 + rel->r_addend;
3709 }
3710
3711 sparc_elf_append_rela (output_bfd, sreloc, &outrel);
3712 continue;
3713 }
3714 relocation = tpoff (info, relocation);
3715 break;
3716
3717 case R_SPARC_TLS_LDM_CALL:
3718 if (! info->shared)
3719 {
3720 /* mov %g0, %o0 */
3721 bfd_put_32 (output_bfd, 0x90100000, contents + rel->r_offset);
3722 continue;
3723 }
3724 /* Fall through */
3725
3726 case R_SPARC_TLS_GD_CALL:
3727 tls_type = GOT_UNKNOWN;
3728 if (h == NULL && local_got_offsets)
3729 tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3730 else if (h != NULL)
3731 tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3732 if (! info->shared
3733 || (r_type == R_SPARC_TLS_GD_CALL && tls_type == GOT_TLS_IE))
3734 {
3735 Elf_Internal_Rela *rel2;
3736 bfd_vma insn;
3737
3738 if (!info->shared && (h == NULL || h->dynindx == -1))
3739 {
3740 /* GD -> LE */
3741 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3742 continue;
3743 }
3744
3745 /* GD -> IE */
3746 if (rel + 1 < relend
3747 && SPARC_ELF_R_TYPE (rel[1].r_info) == R_SPARC_TLS_GD_ADD
3748 && rel[1].r_offset == rel->r_offset + 4
3749 && SPARC_ELF_R_SYMNDX (htab, rel[1].r_info) == r_symndx
3750 && (((insn = bfd_get_32 (input_bfd,
3751 contents + rel[1].r_offset))
3752 >> 25) & 0x1f) == 8)
3753 {
3754 /* We have
3755 call __tls_get_addr, %tgd_call(foo)
3756 add %reg1, %reg2, %o0, %tgd_add(foo)
3757 and change it into IE:
3758 {ld,ldx} [%reg1 + %reg2], %o0, %tie_ldx(foo)
3759 add %g7, %o0, %o0, %tie_add(foo).
3760 add is 0x80000000 | (rd << 25) | (rs1 << 14) | rs2,
3761 ld is 0xc0000000 | (rd << 25) | (rs1 << 14) | rs2,
3762 ldx is 0xc0580000 | (rd << 25) | (rs1 << 14) | rs2. */
3763 bfd_put_32 (output_bfd, insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000),
3764 contents + rel->r_offset);
3765 bfd_put_32 (output_bfd, 0x9001c008,
3766 contents + rel->r_offset + 4);
3767 rel++;
3768 continue;
3769 }
3770
3771 /* We cannot just overwrite the delay slot instruction,
3772 as it might be what puts the %o0 argument to
3773 __tls_get_addr into place. So we have to transpose
3774 the delay slot with the add we patch in. */
3775 insn = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
3776 bfd_put_32 (output_bfd, insn,
3777 contents + rel->r_offset);
3778 bfd_put_32 (output_bfd, 0x9001c008,
3779 contents + rel->r_offset + 4);
3780
3781 rel2 = rel;
3782 while ((rel2 = sparc_elf_find_reloc_at_ofs (rel2 + 1, relend,
3783 rel->r_offset + 4))
3784 != NULL)
3785 {
3786 /* If the instruction we moved has a relocation attached to
3787 it, adjust the offset so that it will apply to the correct
3788 instruction. */
3789 rel2->r_offset -= 4;
3790 }
3791 continue;
3792 }
3793
3794 h = (struct elf_link_hash_entry *)
3795 bfd_link_hash_lookup (info->hash, "__tls_get_addr", FALSE,
3796 FALSE, TRUE);
3797 BFD_ASSERT (h != NULL);
3798 r_type = R_SPARC_WPLT30;
3799 howto = _bfd_sparc_elf_howto_table + r_type;
3800 goto r_sparc_wplt30;
3801
3802 case R_SPARC_TLS_GD_ADD:
3803 tls_type = GOT_UNKNOWN;
3804 if (h == NULL && local_got_offsets)
3805 tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3806 else if (h != NULL)
3807 tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3808 if (! info->shared || tls_type == GOT_TLS_IE)
3809 {
3810 /* add %reg1, %reg2, %reg3, %tgd_add(foo)
3811 changed into IE:
3812 {ld,ldx} [%reg1 + %reg2], %reg3, %tie_ldx(foo)
3813 or LE:
3814 add %g7, %reg2, %reg3. */
3815 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3816 if ((h != NULL && h->dynindx != -1) || info->shared)
3817 relocation = insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000);
3818 else
3819 relocation = (insn & ~0x7c000) | 0x1c000;
3820 bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3821 }
3822 continue;
3823
3824 case R_SPARC_TLS_LDM_ADD:
3825 if (! info->shared)
3826 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3827 continue;
3828
3829 case R_SPARC_TLS_LDO_ADD:
3830 if (! info->shared)
3831 {
3832 /* Change rs1 into %g7. */
3833 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3834 insn = (insn & ~0x7c000) | 0x1c000;
3835 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3836 }
3837 continue;
3838
3839 case R_SPARC_TLS_IE_LD:
3840 case R_SPARC_TLS_IE_LDX:
3841 if (! info->shared && (h == NULL || h->dynindx == -1))
3842 {
3843 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3844 int rs2 = insn & 0x1f;
3845 int rd = (insn >> 25) & 0x1f;
3846
3847 if (rs2 == rd)
3848 relocation = SPARC_NOP;
3849 else
3850 relocation = 0x80100000 | (insn & 0x3e00001f);
3851 bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3852 }
3853 continue;
3854
3855 case R_SPARC_TLS_IE_ADD:
3856 /* Totally useless relocation. */
3857 continue;
3858
3859 case R_SPARC_TLS_DTPOFF32:
3860 case R_SPARC_TLS_DTPOFF64:
3861 relocation -= dtpoff_base (info);
3862 break;
3863
3864 default:
3865 break;
3866 }
3867
3868 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3869 because such sections are not SEC_ALLOC and thus ld.so will
3870 not process them. */
3871 if (unresolved_reloc
3872 && !((input_section->flags & SEC_DEBUGGING) != 0
3873 && h->def_dynamic)
3874 && _bfd_elf_section_offset (output_bfd, info, input_section,
3875 rel->r_offset) != (bfd_vma) -1)
3876 (*_bfd_error_handler)
3877 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3878 input_bfd,
3879 input_section,
3880 (long) rel->r_offset,
3881 howto->name,
3882 h->root.root.string);
3883
3884 r = bfd_reloc_continue;
3885 if (r_type == R_SPARC_OLO10)
3886 {
3887 bfd_vma x;
3888
3889 if (! ABI_64_P (output_bfd))
3890 abort ();
3891
3892 relocation += rel->r_addend;
3893 relocation = (relocation & 0x3ff) + ELF64_R_TYPE_DATA (rel->r_info);
3894
3895 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3896 x = (x & ~(bfd_vma) 0x1fff) | (relocation & 0x1fff);
3897 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3898
3899 r = bfd_check_overflow (howto->complain_on_overflow,
3900 howto->bitsize, howto->rightshift,
3901 bfd_arch_bits_per_address (input_bfd),
3902 relocation);
3903 }
3904 else if (r_type == R_SPARC_WDISP16)
3905 {
3906 bfd_vma x;
3907
3908 relocation += rel->r_addend;
3909 relocation -= (input_section->output_section->vma
3910 + input_section->output_offset);
3911 relocation -= rel->r_offset;
3912
3913 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3914 x |= ((((relocation >> 2) & 0xc000) << 6)
3915 | ((relocation >> 2) & 0x3fff));
3916 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3917
3918 r = bfd_check_overflow (howto->complain_on_overflow,
3919 howto->bitsize, howto->rightshift,
3920 bfd_arch_bits_per_address (input_bfd),
3921 relocation);
3922 }
3923 else if (r_type == R_SPARC_WDISP10)
3924 {
3925 bfd_vma x;
3926
3927 relocation += rel->r_addend;
3928 relocation -= (input_section->output_section->vma
3929 + input_section->output_offset);
3930 relocation -= rel->r_offset;
3931
3932 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3933 x |= ((((relocation >> 2) & 0x300) << 11)
3934 | (((relocation >> 2) & 0xff) << 5));
3935 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3936
3937 r = bfd_check_overflow (howto->complain_on_overflow,
3938 howto->bitsize, howto->rightshift,
3939 bfd_arch_bits_per_address (input_bfd),
3940 relocation);
3941 }
3942 else if (r_type == R_SPARC_REV32)
3943 {
3944 bfd_vma x;
3945
3946 relocation = relocation + rel->r_addend;
3947
3948 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3949 x = x + relocation;
3950 bfd_putl32 (/*input_bfd,*/ x, contents + rel->r_offset);
3951 r = bfd_reloc_ok;
3952 }
3953 else if (r_type == R_SPARC_TLS_LDO_HIX22
3954 || r_type == R_SPARC_TLS_LE_HIX22)
3955 {
3956 bfd_vma x;
3957
3958 relocation += rel->r_addend;
3959 if (r_type == R_SPARC_TLS_LE_HIX22)
3960 relocation ^= MINUS_ONE;
3961
3962 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3963 x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
3964 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3965 r = bfd_reloc_ok;
3966 }
3967 else if (r_type == R_SPARC_TLS_LDO_LOX10
3968 || r_type == R_SPARC_TLS_LE_LOX10)
3969 {
3970 bfd_vma x;
3971
3972 relocation += rel->r_addend;
3973 relocation &= 0x3ff;
3974 if (r_type == R_SPARC_TLS_LE_LOX10)
3975 relocation |= 0x1c00;
3976
3977 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3978 x = (x & ~(bfd_vma) 0x1fff) | relocation;
3979 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3980
3981 r = bfd_reloc_ok;
3982 }
3983 else if (r_type == R_SPARC_HIX22
3984 || r_type == R_SPARC_GOTDATA_HIX22)
3985 {
3986 bfd_vma x;
3987
3988 relocation += rel->r_addend;
3989 if (r_type == R_SPARC_HIX22
3990 || (bfd_signed_vma) relocation < 0)
3991 relocation = relocation ^ MINUS_ONE;
3992
3993 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3994 x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
3995 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3996
3997 r = bfd_check_overflow (howto->complain_on_overflow,
3998 howto->bitsize, howto->rightshift,
3999 bfd_arch_bits_per_address (input_bfd),
4000 relocation);
4001 }
4002 else if (r_type == R_SPARC_LOX10
4003 || r_type == R_SPARC_GOTDATA_LOX10)
4004 {
4005 bfd_vma x;
4006
4007 relocation += rel->r_addend;
4008 if (r_type == R_SPARC_LOX10
4009 || (bfd_signed_vma) relocation < 0)
4010 relocation = (relocation & 0x3ff) | 0x1c00;
4011 else
4012 relocation = (relocation & 0x3ff);
4013
4014 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
4015 x = (x & ~(bfd_vma) 0x1fff) | relocation;
4016 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
4017
4018 r = bfd_reloc_ok;
4019 }
4020 else if ((r_type == R_SPARC_WDISP30 || r_type == R_SPARC_WPLT30)
4021 && sec_do_relax (input_section)
4022 && rel->r_offset + 4 < input_section->size)
4023 {
4024 #define G0 0
4025 #define O7 15
4026 #define XCC (2 << 20)
4027 #define COND(x) (((x)&0xf)<<25)
4028 #define CONDA COND(0x8)
4029 #define INSN_BPA (F2(0,1) | CONDA | BPRED | XCC)
4030 #define INSN_BA (F2(0,2) | CONDA)
4031 #define INSN_OR F3(2, 0x2, 0)
4032 #define INSN_NOP F2(0,4)
4033
4034 bfd_vma x, y;
4035
4036 /* If the instruction is a call with either:
4037 restore
4038 arithmetic instruction with rd == %o7
4039 where rs1 != %o7 and rs2 if it is register != %o7
4040 then we can optimize if the call destination is near
4041 by changing the call into a branch always. */
4042 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
4043 y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
4044 if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2))
4045 {
4046 if (((y & OP3(~0)) == OP3(0x3d) /* restore */
4047 || ((y & OP3(0x28)) == 0 /* arithmetic */
4048 && (y & RD(~0)) == RD(O7)))
4049 && (y & RS1(~0)) != RS1(O7)
4050 && ((y & F3I(~0))
4051 || (y & RS2(~0)) != RS2(O7)))
4052 {
4053 bfd_vma reloc;
4054
4055 reloc = relocation + rel->r_addend - rel->r_offset;
4056 reloc -= (input_section->output_section->vma
4057 + input_section->output_offset);
4058
4059 /* Ensure the branch fits into simm22. */
4060 if ((reloc & 3) == 0
4061 && ((reloc & ~(bfd_vma)0x7fffff) == 0
4062 || ((reloc | 0x7fffff) == ~(bfd_vma)0)))
4063 {
4064 reloc >>= 2;
4065
4066 /* Check whether it fits into simm19. */
4067 if (((reloc & 0x3c0000) == 0
4068 || (reloc & 0x3c0000) == 0x3c0000)
4069 && (ABI_64_P (output_bfd)
4070 || elf_elfheader (output_bfd)->e_flags & EF_SPARC_32PLUS))
4071 x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */
4072 else
4073 x = INSN_BA | (reloc & 0x3fffff); /* ba */
4074 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
4075 r = bfd_reloc_ok;
4076 if (rel->r_offset >= 4
4077 && (y & (0xffffffff ^ RS1(~0)))
4078 == (INSN_OR | RD(O7) | RS2(G0)))
4079 {
4080 bfd_vma z;
4081 unsigned int reg;
4082
4083 z = bfd_get_32 (input_bfd,
4084 contents + rel->r_offset - 4);
4085 if ((z & (0xffffffff ^ RD(~0)))
4086 != (INSN_OR | RS1(O7) | RS2(G0)))
4087 break;
4088
4089 /* The sequence was
4090 or %o7, %g0, %rN
4091 call foo
4092 or %rN, %g0, %o7
4093
4094 If call foo was replaced with ba, replace
4095 or %rN, %g0, %o7 with nop. */
4096
4097 reg = (y & RS1(~0)) >> 14;
4098 if (reg != ((z & RD(~0)) >> 25)
4099 || reg == G0 || reg == O7)
4100 break;
4101
4102 bfd_put_32 (input_bfd, (bfd_vma) INSN_NOP,
4103 contents + rel->r_offset + 4);
4104 }
4105
4106 }
4107 }
4108 }
4109 }
4110
4111 if (r == bfd_reloc_continue)
4112 {
4113 do_relocation:
4114 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4115 contents, rel->r_offset,
4116 relocation, rel->r_addend);
4117 }
4118 if (r != bfd_reloc_ok)
4119 {
4120 switch (r)
4121 {
4122 default:
4123 case bfd_reloc_outofrange:
4124 abort ();
4125 case bfd_reloc_overflow:
4126 {
4127 const char *name;
4128
4129 /* The Solaris native linker silently disregards overflows.
4130 We don't, but this breaks stabs debugging info, whose
4131 relocations are only 32-bits wide. Ignore overflows in
4132 this case and also for discarded entries. */
4133 if ((r_type == R_SPARC_32
4134 || r_type == R_SPARC_UA32
4135 || r_type == R_SPARC_DISP32)
4136 && (((input_section->flags & SEC_DEBUGGING) != 0
4137 && strcmp (bfd_section_name (input_bfd,
4138 input_section),
4139 ".stab") == 0)
4140 || _bfd_elf_section_offset (output_bfd, info,
4141 input_section,
4142 rel->r_offset)
4143 == (bfd_vma)-1))
4144 break;
4145
4146 if (h != NULL)
4147 {
4148 /* Assume this is a call protected by other code that
4149 detect the symbol is undefined. If this is the case,
4150 we can safely ignore the overflow. If not, the
4151 program is hosed anyway, and a little warning isn't
4152 going to help. */
4153 if (h->root.type == bfd_link_hash_undefweak
4154 && howto->pc_relative)
4155 break;
4156
4157 name = NULL;
4158 }
4159 else
4160 {
4161 name = bfd_elf_string_from_elf_section (input_bfd,
4162 symtab_hdr->sh_link,
4163 sym->st_name);
4164 if (name == NULL)
4165 return FALSE;
4166 if (*name == '\0')
4167 name = bfd_section_name (input_bfd, sec);
4168 }
4169 if (! ((*info->callbacks->reloc_overflow)
4170 (info, (h ? &h->root : NULL), name, howto->name,
4171 (bfd_vma) 0, input_bfd, input_section,
4172 rel->r_offset)))
4173 return FALSE;
4174 }
4175 break;
4176 }
4177 }
4178 }
4179
4180 return TRUE;
4181 }
4182
4183 /* Build a VxWorks PLT entry. PLT_INDEX is the index of the PLT entry
4184 and PLT_OFFSET is the byte offset from the start of .plt. GOT_OFFSET
4185 is the offset of the associated .got.plt entry from
4186 _GLOBAL_OFFSET_TABLE_. */
4187
4188 static void
4189 sparc_vxworks_build_plt_entry (bfd *output_bfd, struct bfd_link_info *info,
4190 bfd_vma plt_offset, bfd_vma plt_index,
4191 bfd_vma got_offset)
4192 {
4193 bfd_vma got_base;
4194 const bfd_vma *plt_entry;
4195 struct _bfd_sparc_elf_link_hash_table *htab;
4196 bfd_byte *loc;
4197 Elf_Internal_Rela rela;
4198
4199 htab = _bfd_sparc_elf_hash_table (info);
4200 BFD_ASSERT (htab != NULL);
4201
4202 if (info->shared)
4203 {
4204 plt_entry = sparc_vxworks_shared_plt_entry;
4205 got_base = 0;
4206 }
4207 else
4208 {
4209 plt_entry = sparc_vxworks_exec_plt_entry;
4210 got_base = (htab->elf.hgot->root.u.def.value
4211 + htab->elf.hgot->root.u.def.section->output_offset
4212 + htab->elf.hgot->root.u.def.section->output_section->vma);
4213 }
4214
4215 /* Fill in the entry in the procedure linkage table. */
4216 bfd_put_32 (output_bfd, plt_entry[0] + ((got_base + got_offset) >> 10),
4217 htab->elf.splt->contents + plt_offset);
4218 bfd_put_32 (output_bfd, plt_entry[1] + ((got_base + got_offset) & 0x3ff),
4219 htab->elf.splt->contents + plt_offset + 4);
4220 bfd_put_32 (output_bfd, plt_entry[2],
4221 htab->elf.splt->contents + plt_offset + 8);
4222 bfd_put_32 (output_bfd, plt_entry[3],
4223 htab->elf.splt->contents + plt_offset + 12);
4224 bfd_put_32 (output_bfd, plt_entry[4],
4225 htab->elf.splt->contents + plt_offset + 16);
4226 bfd_put_32 (output_bfd, plt_entry[5] + (plt_index >> 10),
4227 htab->elf.splt->contents + plt_offset + 20);
4228 /* PC-relative displacement for a branch to the start of
4229 the PLT section. */
4230 bfd_put_32 (output_bfd, plt_entry[6] + (((-plt_offset - 24) >> 2)
4231 & 0x003fffff),
4232 htab->elf.splt->contents + plt_offset + 24);
4233 bfd_put_32 (output_bfd, plt_entry[7] + (plt_index & 0x3ff),
4234 htab->elf.splt->contents + plt_offset + 28);
4235
4236 /* Fill in the .got.plt entry, pointing initially at the
4237 second half of the PLT entry. */
4238 BFD_ASSERT (htab->elf.sgotplt != NULL);
4239 bfd_put_32 (output_bfd,
4240 htab->elf.splt->output_section->vma
4241 + htab->elf.splt->output_offset
4242 + plt_offset + 20,
4243 htab->elf.sgotplt->contents + got_offset);
4244
4245 /* Add relocations to .rela.plt.unloaded. */
4246 if (!info->shared)
4247 {
4248 loc = (htab->srelplt2->contents
4249 + (2 + 3 * plt_index) * sizeof (Elf32_External_Rela));
4250
4251 /* Relocate the initial sethi. */
4252 rela.r_offset = (htab->elf.splt->output_section->vma
4253 + htab->elf.splt->output_offset
4254 + plt_offset);
4255 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4256 rela.r_addend = got_offset;
4257 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4258 loc += sizeof (Elf32_External_Rela);
4259
4260 /* Likewise the following or. */
4261 rela.r_offset += 4;
4262 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4263 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4264 loc += sizeof (Elf32_External_Rela);
4265
4266 /* Relocate the .got.plt entry. */
4267 rela.r_offset = (htab->elf.sgotplt->output_section->vma
4268 + htab->elf.sgotplt->output_offset
4269 + got_offset);
4270 rela.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_SPARC_32);
4271 rela.r_addend = plt_offset + 20;
4272 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4273 }
4274 }
4275
4276 /* Finish up dynamic symbol handling. We set the contents of various
4277 dynamic sections here. */
4278
4279 bfd_boolean
4280 _bfd_sparc_elf_finish_dynamic_symbol (bfd *output_bfd,
4281 struct bfd_link_info *info,
4282 struct elf_link_hash_entry *h,
4283 Elf_Internal_Sym *sym)
4284 {
4285 struct _bfd_sparc_elf_link_hash_table *htab;
4286 const struct elf_backend_data *bed;
4287
4288 htab = _bfd_sparc_elf_hash_table (info);
4289 BFD_ASSERT (htab != NULL);
4290 bed = get_elf_backend_data (output_bfd);
4291
4292 if (h->plt.offset != (bfd_vma) -1)
4293 {
4294 asection *splt;
4295 asection *srela;
4296 Elf_Internal_Rela rela;
4297 bfd_byte *loc;
4298 bfd_vma r_offset, got_offset;
4299 int rela_index;
4300
4301 /* When building a static executable, use .iplt and
4302 .rela.iplt sections for STT_GNU_IFUNC symbols. */
4303 if (htab->elf.splt != NULL)
4304 {
4305 splt = htab->elf.splt;
4306 srela = htab->elf.srelplt;
4307 }
4308 else
4309 {
4310 splt = htab->elf.iplt;
4311 srela = htab->elf.irelplt;
4312 }
4313
4314 if (splt == NULL || srela == NULL)
4315 abort ();
4316
4317 /* Fill in the entry in the .rela.plt section. */
4318 if (htab->is_vxworks)
4319 {
4320 /* Work out the index of this PLT entry. */
4321 rela_index = ((h->plt.offset - htab->plt_header_size)
4322 / htab->plt_entry_size);
4323
4324 /* Calculate the offset of the associated .got.plt entry.
4325 The first three entries are reserved. */
4326 got_offset = (rela_index + 3) * 4;
4327
4328 sparc_vxworks_build_plt_entry (output_bfd, info, h->plt.offset,
4329 rela_index, got_offset);
4330
4331
4332 /* On VxWorks, the relocation points to the .got.plt entry,
4333 not the .plt entry. */
4334 rela.r_offset = (htab->elf.sgotplt->output_section->vma
4335 + htab->elf.sgotplt->output_offset
4336 + got_offset);
4337 rela.r_addend = 0;
4338 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx,
4339 R_SPARC_JMP_SLOT);
4340 }
4341 else
4342 {
4343 bfd_boolean ifunc = FALSE;
4344
4345 /* Fill in the entry in the procedure linkage table. */
4346 rela_index = SPARC_ELF_BUILD_PLT_ENTRY (htab, output_bfd, splt,
4347 h->plt.offset, splt->size,
4348 &r_offset);
4349
4350 if (h == NULL
4351 || h->dynindx == -1
4352 || ((info->executable
4353 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
4354 && h->def_regular
4355 && h->type == STT_GNU_IFUNC))
4356 {
4357 ifunc = TRUE;
4358 BFD_ASSERT (h == NULL
4359 || (h->type == STT_GNU_IFUNC
4360 && h->def_regular
4361 && (h->root.type == bfd_link_hash_defined
4362 || h->root.type == bfd_link_hash_defweak)));
4363 }
4364
4365 rela.r_offset = r_offset
4366 + (splt->output_section->vma + splt->output_offset);
4367 if (ABI_64_P (output_bfd)
4368 && h->plt.offset >= (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE))
4369 {
4370 if (ifunc)
4371 {
4372 rela.r_addend = (h->root.u.def.section->output_section->vma
4373 + h->root.u.def.section->output_offset
4374 + h->root.u.def.value);
4375 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0,
4376 R_SPARC_IRELATIVE);
4377 }
4378 else
4379 {
4380 rela.r_addend = (-(h->plt.offset + 4)
4381 - splt->output_section->vma
4382 - splt->output_offset);
4383 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx,
4384 R_SPARC_JMP_SLOT);
4385 }
4386 }
4387 else
4388 {
4389 if (ifunc)
4390 {
4391 rela.r_addend = (h->root.u.def.section->output_section->vma
4392 + h->root.u.def.section->output_offset
4393 + h->root.u.def.value);
4394 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0,
4395 R_SPARC_JMP_IREL);
4396 }
4397 else
4398 {
4399 rela.r_addend = 0;
4400 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx,
4401 R_SPARC_JMP_SLOT);
4402 }
4403 }
4404 }
4405
4406 /* Adjust for the first 4 reserved elements in the .plt section
4407 when setting the offset in the .rela.plt section.
4408 Sun forgot to read their own ABI and copied elf32-sparc behaviour,
4409 thus .plt[4] has corresponding .rela.plt[0] and so on. */
4410
4411 loc = srela->contents;
4412 loc += rela_index * bed->s->sizeof_rela;
4413 bed->s->swap_reloca_out (output_bfd, &rela, loc);
4414
4415 if (!h->def_regular)
4416 {
4417 /* Mark the symbol as undefined, rather than as defined in
4418 the .plt section. Leave the value alone. */
4419 sym->st_shndx = SHN_UNDEF;
4420 /* If the symbol is weak, we do need to clear the value.
4421 Otherwise, the PLT entry would provide a definition for
4422 the symbol even if the symbol wasn't defined anywhere,
4423 and so the symbol would never be NULL. */
4424 if (!h->ref_regular_nonweak)
4425 sym->st_value = 0;
4426 }
4427 }
4428
4429 if (h->got.offset != (bfd_vma) -1
4430 && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_GD
4431 && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_IE)
4432 {
4433 asection *sgot;
4434 asection *srela;
4435 Elf_Internal_Rela rela;
4436
4437 /* This symbol has an entry in the GOT. Set it up. */
4438
4439 sgot = htab->elf.sgot;
4440 srela = htab->elf.srelgot;
4441 BFD_ASSERT (sgot != NULL && srela != NULL);
4442
4443 rela.r_offset = (sgot->output_section->vma
4444 + sgot->output_offset
4445 + (h->got.offset &~ (bfd_vma) 1));
4446
4447 /* If this is a -Bsymbolic link, and the symbol is defined
4448 locally, we just want to emit a RELATIVE reloc. Likewise if
4449 the symbol was forced to be local because of a version file.
4450 The entry in the global offset table will already have been
4451 initialized in the relocate_section function. */
4452 if (! info->shared
4453 && h->type == STT_GNU_IFUNC
4454 && h->def_regular)
4455 {
4456 asection *plt;
4457
4458 /* We load the GOT entry with the PLT entry. */
4459 plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
4460 SPARC_ELF_PUT_WORD (htab, output_bfd,
4461 (plt->output_section->vma
4462 + plt->output_offset + h->plt.offset),
4463 htab->elf.sgot->contents
4464 + (h->got.offset & ~(bfd_vma) 1));
4465 return TRUE;
4466 }
4467 else if (info->shared
4468 && SYMBOL_REFERENCES_LOCAL (info, h))
4469 {
4470 asection *sec = h->root.u.def.section;
4471 if (h->type == STT_GNU_IFUNC)
4472 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, R_SPARC_IRELATIVE);
4473 else
4474 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, R_SPARC_RELATIVE);
4475 rela.r_addend = (h->root.u.def.value
4476 + sec->output_section->vma
4477 + sec->output_offset);
4478 }
4479 else
4480 {
4481 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_GLOB_DAT);
4482 rela.r_addend = 0;
4483 }
4484
4485 SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
4486 sgot->contents + (h->got.offset & ~(bfd_vma) 1));
4487 sparc_elf_append_rela (output_bfd, srela, &rela);
4488 }
4489
4490 if (h->needs_copy)
4491 {
4492 asection *s;
4493 Elf_Internal_Rela rela;
4494
4495 /* This symbols needs a copy reloc. Set it up. */
4496 BFD_ASSERT (h->dynindx != -1);
4497
4498 s = bfd_get_linker_section (h->root.u.def.section->owner,
4499 ".rela.bss");
4500 BFD_ASSERT (s != NULL);
4501
4502 rela.r_offset = (h->root.u.def.value
4503 + h->root.u.def.section->output_section->vma
4504 + h->root.u.def.section->output_offset);
4505 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_COPY);
4506 rela.r_addend = 0;
4507 sparc_elf_append_rela (output_bfd, s, &rela);
4508 }
4509
4510 /* Mark some specially defined symbols as absolute. On VxWorks,
4511 _GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the
4512 ".got" section. Likewise _PROCEDURE_LINKAGE_TABLE_ and ".plt". */
4513 if (sym != NULL
4514 && (h == htab->elf.hdynamic
4515 || (!htab->is_vxworks
4516 && (h == htab->elf.hgot || h == htab->elf.hplt))))
4517 sym->st_shndx = SHN_ABS;
4518
4519 return TRUE;
4520 }
4521
4522 /* Finish up the dynamic sections. */
4523
4524 static bfd_boolean
4525 sparc_finish_dyn (bfd *output_bfd, struct bfd_link_info *info,
4526 bfd *dynobj, asection *sdyn,
4527 asection *splt ATTRIBUTE_UNUSED)
4528 {
4529 struct _bfd_sparc_elf_link_hash_table *htab;
4530 const struct elf_backend_data *bed;
4531 bfd_byte *dyncon, *dynconend;
4532 size_t dynsize;
4533 int stt_regidx = -1;
4534 bfd_boolean abi_64_p;
4535
4536 htab = _bfd_sparc_elf_hash_table (info);
4537 BFD_ASSERT (htab != NULL);
4538 bed = get_elf_backend_data (output_bfd);
4539 dynsize = bed->s->sizeof_dyn;
4540 dynconend = sdyn->contents + sdyn->size;
4541 abi_64_p = ABI_64_P (output_bfd);
4542 for (dyncon = sdyn->contents; dyncon < dynconend; dyncon += dynsize)
4543 {
4544 Elf_Internal_Dyn dyn;
4545 const char *name;
4546 bfd_boolean size;
4547
4548 bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
4549
4550 if (htab->is_vxworks && dyn.d_tag == DT_RELASZ)
4551 {
4552 /* On VxWorks, DT_RELASZ should not include the relocations
4553 in .rela.plt. */
4554 if (htab->elf.srelplt)
4555 {
4556 dyn.d_un.d_val -= htab->elf.srelplt->size;
4557 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4558 }
4559 }
4560 else if (htab->is_vxworks && dyn.d_tag == DT_PLTGOT)
4561 {
4562 /* On VxWorks, DT_PLTGOT should point to the start of the GOT,
4563 not to the start of the PLT. */
4564 if (htab->elf.sgotplt)
4565 {
4566 dyn.d_un.d_val = (htab->elf.sgotplt->output_section->vma
4567 + htab->elf.sgotplt->output_offset);
4568 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4569 }
4570 }
4571 else if (htab->is_vxworks
4572 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
4573 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4574 else if (abi_64_p && dyn.d_tag == DT_SPARC_REGISTER)
4575 {
4576 if (stt_regidx == -1)
4577 {
4578 stt_regidx =
4579 _bfd_elf_link_lookup_local_dynindx (info, output_bfd, -1);
4580 if (stt_regidx == -1)
4581 return FALSE;
4582 }
4583 dyn.d_un.d_val = stt_regidx++;
4584 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4585 }
4586 else
4587 {
4588 switch (dyn.d_tag)
4589 {
4590 case DT_PLTGOT: name = ".plt"; size = FALSE; break;
4591 case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break;
4592 case DT_JMPREL: name = ".rela.plt"; size = FALSE; break;
4593 default: name = NULL; size = FALSE; break;
4594 }
4595
4596 if (name != NULL)
4597 {
4598 asection *s;
4599
4600 s = bfd_get_section_by_name (output_bfd, name);
4601 if (s == NULL)
4602 dyn.d_un.d_val = 0;
4603 else
4604 {
4605 if (! size)
4606 dyn.d_un.d_ptr = s->vma;
4607 else
4608 dyn.d_un.d_val = s->size;
4609 }
4610 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4611 }
4612 }
4613 }
4614 return TRUE;
4615 }
4616
4617 /* Install the first PLT entry in a VxWorks executable and make sure that
4618 .rela.plt.unloaded relocations have the correct symbol indexes. */
4619
4620 static void
4621 sparc_vxworks_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info)
4622 {
4623 struct _bfd_sparc_elf_link_hash_table *htab;
4624 Elf_Internal_Rela rela;
4625 bfd_vma got_base;
4626 bfd_byte *loc;
4627
4628 htab = _bfd_sparc_elf_hash_table (info);
4629 BFD_ASSERT (htab != NULL);
4630
4631 /* Calculate the absolute value of _GLOBAL_OFFSET_TABLE_. */
4632 got_base = (htab->elf.hgot->root.u.def.section->output_section->vma
4633 + htab->elf.hgot->root.u.def.section->output_offset
4634 + htab->elf.hgot->root.u.def.value);
4635
4636 /* Install the initial PLT entry. */
4637 bfd_put_32 (output_bfd,
4638 sparc_vxworks_exec_plt0_entry[0] + ((got_base + 8) >> 10),
4639 htab->elf.splt->contents);
4640 bfd_put_32 (output_bfd,
4641 sparc_vxworks_exec_plt0_entry[1] + ((got_base + 8) & 0x3ff),
4642 htab->elf.splt->contents + 4);
4643 bfd_put_32 (output_bfd,
4644 sparc_vxworks_exec_plt0_entry[2],
4645 htab->elf.splt->contents + 8);
4646 bfd_put_32 (output_bfd,
4647 sparc_vxworks_exec_plt0_entry[3],
4648 htab->elf.splt->contents + 12);
4649 bfd_put_32 (output_bfd,
4650 sparc_vxworks_exec_plt0_entry[4],
4651 htab->elf.splt->contents + 16);
4652
4653 loc = htab->srelplt2->contents;
4654
4655 /* Add an unloaded relocation for the initial entry's "sethi". */
4656 rela.r_offset = (htab->elf.splt->output_section->vma
4657 + htab->elf.splt->output_offset);
4658 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4659 rela.r_addend = 8;
4660 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4661 loc += sizeof (Elf32_External_Rela);
4662
4663 /* Likewise the following "or". */
4664 rela.r_offset += 4;
4665 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4666 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4667 loc += sizeof (Elf32_External_Rela);
4668
4669 /* Fix up the remaining .rela.plt.unloaded relocations. They may have
4670 the wrong symbol index for _G_O_T_ or _P_L_T_ depending on the order
4671 in which symbols were output. */
4672 while (loc < htab->srelplt2->contents + htab->srelplt2->size)
4673 {
4674 Elf_Internal_Rela rel;
4675
4676 /* The entry's initial "sethi" (against _G_O_T_). */
4677 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4678 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4679 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4680 loc += sizeof (Elf32_External_Rela);
4681
4682 /* The following "or" (also against _G_O_T_). */
4683 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4684 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4685 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4686 loc += sizeof (Elf32_External_Rela);
4687
4688 /* The .got.plt entry (against _P_L_T_). */
4689 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4690 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_SPARC_32);
4691 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4692 loc += sizeof (Elf32_External_Rela);
4693 }
4694 }
4695
4696 /* Install the first PLT entry in a VxWorks shared object. */
4697
4698 static void
4699 sparc_vxworks_finish_shared_plt (bfd *output_bfd, struct bfd_link_info *info)
4700 {
4701 struct _bfd_sparc_elf_link_hash_table *htab;
4702 unsigned int i;
4703
4704 htab = _bfd_sparc_elf_hash_table (info);
4705 BFD_ASSERT (htab != NULL);
4706
4707 for (i = 0; i < ARRAY_SIZE (sparc_vxworks_shared_plt0_entry); i++)
4708 bfd_put_32 (output_bfd, sparc_vxworks_shared_plt0_entry[i],
4709 htab->elf.splt->contents + i * 4);
4710 }
4711
4712 /* Finish up local dynamic symbol handling. We set the contents of
4713 various dynamic sections here. */
4714
4715 static bfd_boolean
4716 finish_local_dynamic_symbol (void **slot, void *inf)
4717 {
4718 struct elf_link_hash_entry *h
4719 = (struct elf_link_hash_entry *) *slot;
4720 struct bfd_link_info *info
4721 = (struct bfd_link_info *) inf;
4722
4723 return _bfd_sparc_elf_finish_dynamic_symbol (info->output_bfd, info,
4724 h, NULL);
4725 }
4726
4727 bfd_boolean
4728 _bfd_sparc_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
4729 {
4730 bfd *dynobj;
4731 asection *sdyn;
4732 struct _bfd_sparc_elf_link_hash_table *htab;
4733
4734 htab = _bfd_sparc_elf_hash_table (info);
4735 BFD_ASSERT (htab != NULL);
4736 dynobj = htab->elf.dynobj;
4737
4738 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
4739
4740 if (elf_hash_table (info)->dynamic_sections_created)
4741 {
4742 asection *splt;
4743
4744 splt = htab->elf.splt;
4745 BFD_ASSERT (splt != NULL && sdyn != NULL);
4746
4747 if (!sparc_finish_dyn (output_bfd, info, dynobj, sdyn, splt))
4748 return FALSE;
4749
4750 /* Initialize the contents of the .plt section. */
4751 if (splt->size > 0)
4752 {
4753 if (htab->is_vxworks)
4754 {
4755 if (info->shared)
4756 sparc_vxworks_finish_shared_plt (output_bfd, info);
4757 else
4758 sparc_vxworks_finish_exec_plt (output_bfd, info);
4759 }
4760 else
4761 {
4762 memset (splt->contents, 0, htab->plt_header_size);
4763 if (!ABI_64_P (output_bfd))
4764 bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP,
4765 splt->contents + splt->size - 4);
4766 }
4767 }
4768
4769 elf_section_data (splt->output_section)->this_hdr.sh_entsize
4770 = (htab->is_vxworks || !ABI_64_P (output_bfd))
4771 ? 0 : htab->plt_entry_size;
4772 }
4773
4774 /* Set the first entry in the global offset table to the address of
4775 the dynamic section. */
4776 if (htab->elf.sgot && htab->elf.sgot->size > 0)
4777 {
4778 bfd_vma val = (sdyn ?
4779 sdyn->output_section->vma + sdyn->output_offset :
4780 0);
4781
4782 SPARC_ELF_PUT_WORD (htab, output_bfd, val, htab->elf.sgot->contents);
4783 }
4784
4785 if (htab->elf.sgot)
4786 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize =
4787 SPARC_ELF_WORD_BYTES (htab);
4788
4789 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
4790 htab_traverse (htab->loc_hash_table, finish_local_dynamic_symbol, info);
4791
4792 return TRUE;
4793 }
4794
4795 \f
4796 /* Set the right machine number for a SPARC ELF file. */
4797
4798 bfd_boolean
4799 _bfd_sparc_elf_object_p (bfd *abfd)
4800 {
4801 if (ABI_64_P (abfd))
4802 {
4803 unsigned long mach = bfd_mach_sparc_v9;
4804
4805 if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
4806 mach = bfd_mach_sparc_v9b;
4807 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
4808 mach = bfd_mach_sparc_v9a;
4809 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, mach);
4810 }
4811 else
4812 {
4813 if (elf_elfheader (abfd)->e_machine == EM_SPARC32PLUS)
4814 {
4815 if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
4816 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4817 bfd_mach_sparc_v8plusb);
4818 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
4819 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4820 bfd_mach_sparc_v8plusa);
4821 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_32PLUS)
4822 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4823 bfd_mach_sparc_v8plus);
4824 else
4825 return FALSE;
4826 }
4827 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_LEDATA)
4828 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4829 bfd_mach_sparc_sparclite_le);
4830 else
4831 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc);
4832 }
4833 }
4834
4835 /* Return address for Ith PLT stub in section PLT, for relocation REL
4836 or (bfd_vma) -1 if it should not be included. */
4837
4838 bfd_vma
4839 _bfd_sparc_elf_plt_sym_val (bfd_vma i, const asection *plt, const arelent *rel)
4840 {
4841 if (ABI_64_P (plt->owner))
4842 {
4843 bfd_vma j;
4844
4845 i += PLT64_HEADER_SIZE / PLT64_ENTRY_SIZE;
4846 if (i < PLT64_LARGE_THRESHOLD)
4847 return plt->vma + i * PLT64_ENTRY_SIZE;
4848
4849 j = (i - PLT64_LARGE_THRESHOLD) % 160;
4850 i -= j;
4851 return plt->vma + i * PLT64_ENTRY_SIZE + j * 4 * 6;
4852 }
4853 else
4854 return rel->address;
4855 }
4856
4857 /* Merge backend specific data from an object file to the output
4858 object file when linking. */
4859
4860 bfd_boolean
4861 _bfd_sparc_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
4862 {
4863 obj_attribute *in_attr, *in_attrs;
4864 obj_attribute *out_attr, *out_attrs;
4865
4866 if (!elf_known_obj_attributes_proc (obfd)[0].i)
4867 {
4868 /* This is the first object. Copy the attributes. */
4869 _bfd_elf_copy_obj_attributes (ibfd, obfd);
4870
4871 /* Use the Tag_null value to indicate the attributes have been
4872 initialized. */
4873 elf_known_obj_attributes_proc (obfd)[0].i = 1;
4874
4875 return TRUE;
4876 }
4877
4878 in_attrs = elf_known_obj_attributes (ibfd)[OBJ_ATTR_GNU];
4879 out_attrs = elf_known_obj_attributes (obfd)[OBJ_ATTR_GNU];
4880
4881 in_attr = &in_attrs[Tag_GNU_Sparc_HWCAPS];
4882 out_attr = &out_attrs[Tag_GNU_Sparc_HWCAPS];
4883
4884 out_attr->i |= in_attr->i;
4885
4886 /* Merge Tag_compatibility attributes and any common GNU ones. */
4887 _bfd_elf_merge_object_attributes (ibfd, obfd);
4888
4889 return TRUE;
4890 }
GDB Binutils - Deliverables
This page took 0.268926 seconds and 5 git commands to generate.