projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* gdb.texinfo (Index Section Format): Update for version 7.
[deliverable/binutils-gdb.git] / bfd / elfxx-sparc.c
CommitLineData
22b75d0a 1/* SPARC-specific support for ELF
0bef263a 2 Copyright 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
7686d77d 3 Free Software Foundation, Inc.
22b75d0a
DM		 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
cd123cb7 9 the Free Software Foundation; either version 3 of the License, or
22b75d0a
DM		 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
cd123cb7
NC		 19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
21
22b75d0a
DM		 22
23/* This file handles functionality common to the different SPARC ABI's. */
24
22b75d0a 25#include "sysdep.h"
3db64b00 26#include "bfd.h"
22b75d0a
DM		 27#include "bfdlink.h"
28#include "libbfd.h"
910600e9 29#include "libiberty.h"
22b75d0a
DM		 30#include "elf-bfd.h"
31#include "elf/sparc.h"
32#include "opcode/sparc.h"
33#include "elfxx-sparc.h"
910600e9 34#include "elf-vxworks.h"
d0c9aeb3
DM		 35#include "objalloc.h"
36#include "hashtab.h"
22b75d0a
DM		 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
54static bfd_reloc_status_type
55init_insn_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
56 PTR 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
96static bfd_reloc_status_type
97sparc_elf_notsup_reloc (bfd *abfd ATTRIBUTE_UNUSED,
98 arelent *reloc_entry ATTRIBUTE_UNUSED,
99 asymbol *symbol ATTRIBUTE_UNUSED,
100 PTR 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
110static bfd_reloc_status_type
111sparc_elf_wdisp16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
112 PTR 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
2615994e
DM		 135/* Handle the WDISP10 reloc. */
136
137static bfd_reloc_status_type
138sparc_elf_wdisp10_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
139 PTR 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
22b75d0a
DM		 163/* Handle the HIX22 reloc. */
164
165static bfd_reloc_status_type
166sparc_elf_hix22_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
167 PTR 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
191static bfd_reloc_status_type
192sparc_elf_lox10_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
193 PTR 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
211static 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),
739f7f82
DM		 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),
2615994e
DM		 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),
22b75d0a 302};
d0c9aeb3
DM		 303static 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);
305static 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);
22b75d0a
DM		 307static 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);
309static 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);
311static 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
22b75d0a
DM		 314reloc_howto_type *
315_bfd_sparc_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
316 bfd_reloc_code_real_type code)
317{
679b7c76
DM		 318 /* We explicitly handle each relocation type in the switch
319 instead of using a lookup table for efficiency. */
22b75d0a
DM		 320 switch (code)
321 {
679b7c76
DM		 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
2615994e
DM		 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
d0c9aeb3
DM		 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
22b75d0a
DM		 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:
679b7c76 587 break;
22b75d0a
DM		 588 }
589 bfd_set_error (bfd_error_bad_value);
590 return NULL;
591}
592
157090f7
AM		 593reloc_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
22b75d0a
DM		 617reloc_howto_type *
618_bfd_sparc_elf_info_to_howto_ptr (unsigned int r_type)
619{
620 switch (r_type)
621 {
d0c9aeb3
DM		 622 case R_SPARC_JMP_IREL:
623 return &sparc_jmp_irel_howto;
624
625 case R_SPARC_IRELATIVE:
626 return &sparc_irelative_howto;
627
22b75d0a
DM		 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:
d0fb9a8d
JJ		 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 }
22b75d0a
DM		 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
653void
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
674struct _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
690struct _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
706struct _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
0ffa91dd
NC		 723#define is_sparc_elf(bfd) \
724 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
725 && elf_tdata (bfd) != NULL \
4dfe6ac6 726 && elf_object_id (bfd) == SPARC_ELF_DATA)
0ffa91dd 727
22b75d0a
DM		 728bfd_boolean
729_bfd_sparc_elf_mkobject (bfd *abfd)
730{
0ffa91dd 731 return bfd_elf_allocate_object (abfd, sizeof (struct _bfd_sparc_elf_obj_tdata),
4dfe6ac6 732 SPARC_ELF_DATA);
22b75d0a
DM		 733}
734
735static void
91d6fa6a 736sparc_put_word_32 (bfd *abfd, bfd_vma val, void *ptr)
22b75d0a 737{
91d6fa6a 738 bfd_put_32 (abfd, val, ptr);
22b75d0a
DM		 739}
740
741static void
91d6fa6a 742sparc_put_word_64 (bfd *abfd, bfd_vma val, void *ptr)
22b75d0a 743{
91d6fa6a 744 bfd_put_64 (abfd, val, ptr);
22b75d0a
DM		 745}
746
747static void
39817122 748sparc_elf_append_rela (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
22b75d0a 749{
39817122
RS		 750 const struct elf_backend_data *bed;
751 bfd_byte *loc;
22b75d0a 752
39817122
RS		 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);
22b75d0a
DM		 756}
757
758static bfd_vma
e459dc7b 759sparc_elf_r_info_64 (Elf_Internal_Rela *in_rel ATTRIBUTE_UNUSED,
91d6fa6a 760 bfd_vma rel_index ATTRIBUTE_UNUSED,
e459dc7b 761 bfd_vma type ATTRIBUTE_UNUSED)
22b75d0a 762{
91d6fa6a 763 return ELF64_R_INFO (rel_index,
22b75d0a
DM		 764 (in_rel ?
765 ELF64_R_TYPE_INFO (ELF64_R_TYPE_DATA (in_rel->r_info),
766 type) : type));
767}
768
769static bfd_vma
770sparc_elf_r_info_32 (Elf_Internal_Rela *in_rel ATTRIBUTE_UNUSED,
91d6fa6a 771 bfd_vma rel_index, bfd_vma type)
22b75d0a 772{
91d6fa6a 773 return ELF32_R_INFO (rel_index, type);
22b75d0a
DM		 774}
775
776static bfd_vma
777sparc_elf_r_symndx_64 (bfd_vma r_info)
778{
e8be8da4
DM		 779 bfd_vma r_symndx = ELF32_R_SYM (r_info);
780 return (r_symndx >> 24);
22b75d0a
DM		 781}
782
783static bfd_vma
784sparc_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
806static int
807sparc32_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
831static int
832sparc64_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;
91d6fa6a 837 int plt_index;
22b75d0a
DM		 838
839 if (offset < (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE))
840 {
841 unsigned int sethi, ba;
842
843 *r_offset = offset;
844
91d6fa6a 845 plt_index = (offset / PLT64_ENTRY_SIZE);
22b75d0a 846
91d6fa6a 847 sethi = 0x03000000 | (plt_index * PLT64_ENTRY_SIZE);
22b75d0a
DM		 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
91d6fa6a 894 plt_index = (PLT64_LARGE_THRESHOLD +
22b75d0a
DM		 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
91d6fa6a 924 return plt_index - 4;
22b75d0a
DM		 925}
926
910600e9
RS		 927/* The format of the first PLT entry in a VxWorks executable. */
928static 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. */
938static 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. */
951static 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. */
959static 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
22b75d0a
DM		 971#define SPARC_ELF_PUT_WORD(htab, bfd, val, ptr) \
972 htab->put_word(bfd, val, ptr)
973
22b75d0a
DM		 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
1000static struct bfd_hash_entry *
1001link_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
d0c9aeb3
DM		 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
1039static hashval_t
1040elf_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
1049static int
1050elf_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
1062static struct elf_link_hash_entry *
1063elf_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
22b75d0a
DM		 1106/* Create a SPARC ELF linker hash table. */
1107
1108struct 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;
22b75d0a
DM		 1121 ret->r_info = sparc_elf_r_info_64;
1122 ret->r_symndx = sparc_elf_r_symndx_64;
22b75d0a
DM		 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);
c2e70a82 1130 ret->dynamic_interpreter = ELF64_DYNAMIC_INTERPRETER;
22b75d0a 1131 ret->dynamic_interpreter_size = sizeof ELF64_DYNAMIC_INTERPRETER;
d0c9aeb3
DM		 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;
22b75d0a
DM		 1136 }
1137 else
1138 {
1139 ret->put_word = sparc_put_word_32;
22b75d0a
DM		 1140 ret->r_info = sparc_elf_r_info_32;
1141 ret->r_symndx = sparc_elf_r_symndx_32;
22b75d0a
DM		 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);
c2e70a82 1149 ret->dynamic_interpreter = ELF32_DYNAMIC_INTERPRETER;
22b75d0a 1150 ret->dynamic_interpreter_size = sizeof ELF32_DYNAMIC_INTERPRETER;
d0c9aeb3
DM		 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;
22b75d0a
DM		 1155 }
1156
66eb6687 1157 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc,
4dfe6ac6
NC		 1158 sizeof (struct _bfd_sparc_elf_link_hash_entry),
1159 SPARC_ELF_DATA))
22b75d0a
DM		 1160 {
1161 free (ret);
1162 return NULL;
1163 }
1164
d0c9aeb3
DM		 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
22b75d0a
DM		 1176 return &ret->elf.root;
1177}
1178
d0c9aeb3
DM		 1179/* Destroy a SPARC ELF linker hash table. */
1180
1181void
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
22b75d0a
DM		 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
1198bfd_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);
4dfe6ac6
NC		 1205 BFD_ASSERT (htab != NULL);
1206
22b75d0a
DM		 1207 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
1208 return FALSE;
1209
22b75d0a
DM		 1210 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
1211 if (!info->shared)
1212 htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss");
1213
910600e9
RS		 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 }
910600e9 1233
72fbc6e5 1234 if (!htab->elf.splt || !htab->elf.srelplt || !htab->sdynbss
22b75d0a
DM		 1235 || (!info->shared && !htab->srelbss))
1236 abort ();
1237
1238 return TRUE;
1239}
1240
d0c9aeb3
DM		 1241static bfd_boolean
1242create_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
22b75d0a
DM		 1272/* Copy the extra info we tack onto an elf_link_hash_entry. */
1273
1274void
fcfa13d2 1275_bfd_sparc_elf_copy_indirect_symbol (struct bfd_link_info *info,
22b75d0a
DM		 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
fcfa13d2 1291 /* Add reloc counts against the indirect sym to the direct sym
22b75d0a
DM		 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 }
fcfa13d2 1321 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
22b75d0a
DM		 1322}
1323
1324static int
1325sparc_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
1367bfd_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;
22b75d0a
DM		 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);
4dfe6ac6 1384 BFD_ASSERT (htab != NULL);
0ffa91dd 1385 symtab_hdr = &elf_symtab_hdr (abfd);
22b75d0a 1386 sym_hashes = elf_sym_hashes (abfd);
22b75d0a
DM		 1387
1388 sreloc = NULL;
1389
1390 if (ABI_64_P (abfd))
d4730f92 1391 num_relocs = NUM_SHDR_ENTRIES (_bfd_elf_single_rel_hdr (sec));
22b75d0a
DM		 1392 else
1393 num_relocs = sec->reloc_count;
0ffa91dd
NC		 1394
1395 BFD_ASSERT (is_sparc_elf (abfd) || num_relocs == 0);
1396
d0c9aeb3
DM		 1397 if (htab->elf.dynobj == NULL)
1398 htab->elf.dynobj = abfd;
1399 if (!create_ifunc_sections (htab->elf.dynobj, info))
1400 return FALSE;
1401
22b75d0a
DM		 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;
d0c9aeb3 1408 Elf_Internal_Sym *isym;
22b75d0a
DM		 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
d0c9aeb3 1420 isym = NULL;
22b75d0a 1421 if (r_symndx < symtab_hdr->sh_info)
d0c9aeb3
DM		 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 }
22b75d0a 1447 else
973a3492
L		 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 }
22b75d0a 1454
d0c9aeb3
DM		 1455 if (h && h->type == STT_GNU_IFUNC)
1456 {
1457 if (h->def_regular)
b48ca1d4
DM		 1458 {
1459 h->ref_regular = 1;
1460 h->plt.refcount += 1;
1461 }
d0c9aeb3
DM		 1462 }
1463
22b75d0a
DM		 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:
739f7f82
DM		 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:
22b75d0a
DM		 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:
739f7f82
DM		 1529 case R_SPARC_GOTDATA_OP_HIX22:
1530 case R_SPARC_GOTDATA_OP_LOX10:
22b75d0a
DM		 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 }
00c50991
DM		 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 }
22b75d0a
DM		 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
72fbc6e5 1607 if (htab->elf.sgot == NULL)
22b75d0a 1608 {
72fbc6e5 1609 if (!_bfd_elf_create_got_section (htab->elf.dynobj, info))
22b75d0a
DM		 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 }
af1fb11f
NC		 1659 /* PR 7027: We need similar behaviour for 64-bit binaries. */
1660 else if (r_type == R_SPARC_WPLT30)
1661 break;
22b75d0a
DM		 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:
2615994e 1703 case R_SPARC_WDISP10:
22b75d0a
DM		 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:
2615994e 1728 case R_SPARC_H34:
22b75d0a
DM		 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
72fbc6e5 1766 && (! SYMBOLIC_BIND (info, h)
22b75d0a
DM		 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
d0c9aeb3
DM		 1773 || !h->def_regular))
1774 || (!info->shared
1775 && h != NULL
1776 && h->type == STT_GNU_IFUNC))
22b75d0a
DM		 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 {
83bac4b0
NC		 1786 sreloc = _bfd_elf_make_dynamic_reloc_section
1787 (sec, htab->elf.dynobj, htab->word_align_power,
1788 abfd, /*rela?*/ TRUE);
1789
22b75d0a 1790 if (sreloc == NULL)
83bac4b0 1791 return FALSE;
22b75d0a
DM		 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. */
22b75d0a 1803 asection *s;
6edfbbad 1804 void *vpp;
22b75d0a 1805
d0c9aeb3 1806 BFD_ASSERT (isym != NULL);
87d72d41
AM		 1807 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1808 if (s == NULL)
1809 s = sec;
1810
6edfbbad
DJ		 1811 vpp = &elf_section_data (s)->local_dynrel;
1812 head = (struct _bfd_sparc_elf_dyn_relocs **) vpp;
22b75d0a
DM		 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:
d17e0c6e
JB		 1843 BFD_ASSERT (h != NULL);
1844 if (h != NULL
1845 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
22b75d0a
DM		 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
1861asection *
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)
07adf181 1869 switch (SPARC_ELF_R_TYPE (rel->r_info))
22b75d0a
DM		 1870 {
1871 case R_SPARC_GNU_VTINHERIT:
1872 case R_SPARC_GNU_VTENTRY:
07adf181 1873 return NULL;
22b75d0a 1874 }
22b75d0a 1875
07adf181 1876 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
22b75d0a
DM		 1877}
1878
abd242a9
DM		 1879static Elf_Internal_Rela *
1880sparc_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
22b75d0a
DM		 1893/* Update the got entry reference counts for the section being removed. */
1894bfd_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
7dda2462
TG		 1904 if (info->relocatable)
1905 return TRUE;
1906
0ffa91dd
NC		 1907 BFD_ASSERT (is_sparc_elf (abfd) || sec->reloc_count == 0);
1908
22b75d0a
DM		 1909 elf_section_data (sec)->local_dynrel = NULL;
1910
1911 htab = _bfd_sparc_elf_hash_table (info);
4dfe6ac6 1912 BFD_ASSERT (htab != NULL);
0ffa91dd 1913 symtab_hdr = &elf_symtab_hdr (abfd);
22b75d0a
DM		 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:
739f7f82
DM		 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:
22b75d0a
DM		 1966 if (h != NULL)
1967 {
1968 if (h->got.refcount > 0)
1969 h->got.refcount--;
1970 }
1971 else
1972 {
00c50991
DM		 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 }
22b75d0a
DM		 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:
2615994e 2005 case R_SPARC_WDISP10:
22b75d0a
DM		 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:
2615994e 2031 case R_SPARC_H34:
22b75d0a
DM		 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
2059bfd_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;
22b75d0a
DM		 2067
2068 htab = _bfd_sparc_elf_hash_table (info);
4dfe6ac6 2069 BFD_ASSERT (htab != NULL);
22b75d0a
DM		 2070
2071 /* Make sure we know what is going on here. */
2072 BFD_ASSERT (htab->elf.dynobj != NULL
2073 && (h->needs_plt
d0c9aeb3 2074 || h->type == STT_GNU_IFUNC
22b75d0a
DM		 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
d0c9aeb3 2088 || h->type == STT_GNU_IFUNC
22b75d0a
DM		 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
d0c9aeb3
DM		 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))))
22b75d0a
DM		 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
72fbc6e5
DM		 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
22b75d0a
DM		 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. */
1d7e9d18 2179 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
22b75d0a
DM		 2180 {
2181 htab->srelbss->size += SPARC_ELF_RELA_BYTES (htab);
2182 h->needs_copy = 1;
2183 }
2184
22b75d0a 2185 s = htab->sdynbss;
22b75d0a 2186
027297b7 2187 return _bfd_elf_adjust_dynamic_copy (h, s);
22b75d0a
DM		 2188}
2189
2190/* Allocate space in .plt, .got and associated reloc sections for
2191 dynamic relocs. */
2192
2193static bfd_boolean
2194allocate_dynrelocs (struct elf_link_hash_entry *h, PTR 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
22b75d0a
DM		 2204 info = (struct bfd_link_info *) inf;
2205 htab = _bfd_sparc_elf_hash_table (info);
4dfe6ac6 2206 BFD_ASSERT (htab != NULL);
22b75d0a 2207
d0c9aeb3
DM		 2208 if ((htab->elf.dynamic_sections_created
2209 && h->plt.refcount > 0)
2210 || (h->type == STT_GNU_IFUNC
b48ca1d4
DM		 2211 && h->def_regular
2212 && h->ref_regular))
22b75d0a
DM		 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
d0c9aeb3 2223 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h)
b48ca1d4
DM		 2224 || (h->type == STT_GNU_IFUNC
2225 && h->def_regular))
22b75d0a 2226 {
72fbc6e5 2227 asection *s = htab->elf.splt;
22b75d0a 2228
d0c9aeb3
DM		 2229 if (s == NULL)
2230 s = htab->elf.iplt;
2231
910600e9 2232 /* Allocate room for the header. */
22b75d0a 2233 if (s->size == 0)
910600e9
RS		 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 }
22b75d0a
DM		 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 ?
e8be8da4 2245 (((bfd_vma)1 << 31) << 1) : 0x400000))
22b75d0a
DM		 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. */
910600e9 2277 s->size += htab->plt_entry_size;
22b75d0a
DM		 2278
2279 /* We also need to make an entry in the .rela.plt section. */
d0c9aeb3
DM		 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);
910600e9
RS		 2284
2285 if (htab->is_vxworks)
2286 {
2287 /* Allocate space for the .got.plt entry. */
72fbc6e5 2288 htab->elf.sgotplt->size += 4;
910600e9
RS		 2289
2290 /* ...and for the .rela.plt.unloaded relocations. */
2291 if (!info->shared)
2292 htab->srelplt2->size += sizeof (Elf32_External_Rela) * 3;
2293 }
22b75d0a
DM		 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
72fbc6e5 2329 s = htab->elf.sgot;
22b75d0a
DM		 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)
d0c9aeb3
DM		 2340 || tls_type == GOT_TLS_IE
2341 || h->type == STT_GNU_IFUNC)
72fbc6e5 2342 htab->elf.srelgot->size += SPARC_ELF_RELA_BYTES (htab);
22b75d0a 2343 else if (tls_type == GOT_TLS_GD)
72fbc6e5 2344 htab->elf.srelgot->size += 2 * SPARC_ELF_RELA_BYTES (htab);
22b75d0a 2345 else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
72fbc6e5 2346 htab->elf.srelgot->size += SPARC_ELF_RELA_BYTES (htab);
22b75d0a
DM		 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 {
72fbc6e5 2363 if (SYMBOL_CALLS_LOCAL (info, h))
22b75d0a
DM		 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 }
22d606e9 2377
3348747a
NS		 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
22d606e9
AM		 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 }
22b75d0a
DM		 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
d0c9aeb3
DM		 2452/* Allocate space in .plt, .got and associated reloc sections for
2453 local dynamic relocs. */
2454
2455static bfd_boolean
2456allocate_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
22b75d0a
DM		 2471/* Find any dynamic relocs that apply to read-only sections. */
2472
2473static bfd_boolean
2474readonly_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
2475{
2476 struct _bfd_sparc_elf_link_hash_entry *eh;
2477 struct _bfd_sparc_elf_dyn_relocs *p;
2478
22b75d0a
DM		 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
2500bfd_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
2516bfd_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);
4dfe6ac6 2526 BFD_ASSERT (htab != NULL);
22b75d0a
DM		 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_section_by_name (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
0ffa91dd 2553 if (! is_sparc_elf (ibfd))
22b75d0a
DM		 2554 continue;
2555
2556 for (s = ibfd->sections; s != NULL; s = s->next)
2557 {
2558 struct _bfd_sparc_elf_dyn_relocs *p;
2559
6edfbbad 2560 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
22b75d0a
DM		 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 }
3348747a
NS		 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 }
22b75d0a
DM		 2577 else if (p->count != 0)
2578 {
2579 srel = elf_section_data (p->sec)->sreloc;
d0c9aeb3
DM		 2580 if (!htab->elf.dynamic_sections_created)
2581 srel = htab->elf.irelplt;
22b75d0a
DM		 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
0ffa91dd 2593 symtab_hdr = &elf_symtab_hdr (ibfd);
22b75d0a
DM		 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);
72fbc6e5
DM		 2597 s = htab->elf.sgot;
2598 srel = htab->elf.srelgot;
22b75d0a
DM		 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. */
72fbc6e5
DM		 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);
22b75d0a
DM		 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, (PTR) info);
2631
d0c9aeb3
DM		 2632 /* Allocate .plt and .got entries, and space for local symbols. */
2633 htab_traverse (htab->loc_hash_table, allocate_local_dynrelocs, info);
2634
22b75d0a 2635 if (! ABI_64_P (output_bfd)
910600e9 2636 && !htab->is_vxworks
22b75d0a
DM		 2637 && elf_hash_table (info)->dynamic_sections_created)
2638 {
2639 /* Make space for the trailing nop in .plt. */
72fbc6e5
DM		 2640 if (htab->elf.splt->size > 0)
2641 htab->elf.splt->size += 1 * SPARC_INSN_BYTES;
22b75d0a
DM		 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. */
72fbc6e5 2648 if (htab->elf.sgot->size >= 0x1000
22b75d0a
DM		 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 {
22b75d0a
DM		 2658 if ((s->flags & SEC_LINKER_CREATED) == 0)
2659 continue;
2660
72fbc6e5
DM		 2661 if (s == htab->elf.splt
2662 || s == htab->elf.sgot
910600e9 2663 || s == htab->sdynbss
d0c9aeb3 2664 || s == htab->elf.iplt
72fbc6e5 2665 || s == htab->elf.sgotplt)
22b75d0a 2666 {
c456f082
AM		 2667 /* Strip this section if we don't need it; see the
2668 comment below. */
2669 }
0112cd26 2670 else if (CONST_STRNEQ (s->name, ".rela"))
c456f082
AM		 2671 {
2672 if (s->size != 0)
22b75d0a
DM		 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 }
c456f082 2679 else
22b75d0a 2680 {
c456f082 2681 /* It's not one of our sections. */
22b75d0a
DM		 2682 continue;
2683 }
2684
c456f082 2685 if (s->size == 0)
22b75d0a 2686 {
c456f082
AM		 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. */
8423293d 2696 s->flags |= SEC_EXCLUDE;
22b75d0a
DM		 2697 continue;
2698 }
2699
c456f082
AM		 2700 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2701 continue;
2702
22b75d0a
DM		 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);
c456f082 2707 if (s->contents == NULL)
22b75d0a
DM		 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
72fbc6e5 2727 if (htab->elf.srelplt->size != 0)
22b75d0a
DM		 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,
2746 (PTR) info);
2747
2748 if (info->flags & DF_TEXTREL)
2749 {
2750 if (!add_dynamic_entry (DT_TEXTREL, 0))
2751 return FALSE;
2752 }
2753
2754 if (ABI_64_P (output_bfd))
2755 {
2756 int reg;
2757 struct _bfd_sparc_elf_app_reg * app_regs;
2758 struct elf_strtab_hash *dynstr;
2759 struct elf_link_hash_table *eht = elf_hash_table (info);
2760
2761 /* Add dynamic STT_REGISTER symbols and corresponding DT_SPARC_REGISTER
2762 entries if needed. */
2763 app_regs = _bfd_sparc_elf_hash_table (info)->app_regs;
2764 dynstr = eht->dynstr;
2765
2766 for (reg = 0; reg < 4; reg++)
2767 if (app_regs [reg].name != NULL)
2768 {
2769 struct elf_link_local_dynamic_entry *entry, *e;
2770
2771 if (!add_dynamic_entry (DT_SPARC_REGISTER, 0))
2772 return FALSE;
2773
2774 entry = (struct elf_link_local_dynamic_entry *)
2775 bfd_hash_allocate (&info->hash->table, sizeof (*entry));
2776 if (entry == NULL)
2777 return FALSE;
2778
2779 /* We cheat here a little bit: the symbol will not be local, so we
2780 put it at the end of the dynlocal linked list. We will fix it
2781 later on, as we have to fix other fields anyway. */
2782 entry->isym.st_value = reg < 2 ? reg + 2 : reg + 4;
2783 entry->isym.st_size = 0;
2784 if (*app_regs [reg].name != '\0')
2785 entry->isym.st_name
2786 = _bfd_elf_strtab_add (dynstr, app_regs[reg].name, FALSE);
2787 else
2788 entry->isym.st_name = 0;
2789 entry->isym.st_other = 0;
2790 entry->isym.st_info = ELF_ST_INFO (app_regs [reg].bind,
2791 STT_REGISTER);
2792 entry->isym.st_shndx = app_regs [reg].shndx;
35fc36a8 2793 entry->isym.st_target_internal = 0;
22b75d0a
DM		 2794 entry->next = NULL;
2795 entry->input_bfd = output_bfd;
2796 entry->input_indx = -1;
2797
2798 if (eht->dynlocal == NULL)
2799 eht->dynlocal = entry;
2800 else
2801 {
2802 for (e = eht->dynlocal; e->next; e = e->next)
2803 ;
2804 e->next = entry;
2805 }
2806 eht->dynsymcount++;
2807 }
2808 }
7a2b07ff
NS		 2809 if (htab->is_vxworks
2810 && !elf_vxworks_add_dynamic_entries (output_bfd, info))
2811 return FALSE;
22b75d0a
DM		 2812 }
2813#undef add_dynamic_entry
2814
2815 return TRUE;
2816}
2817\f
2818bfd_boolean
2819_bfd_sparc_elf_new_section_hook (bfd *abfd, asection *sec)
2820{
f592407e
AM		 2821 if (!sec->used_by_bfd)
2822 {
2823 struct _bfd_sparc_elf_section_data *sdata;
2824 bfd_size_type amt = sizeof (*sdata);
22b75d0a 2825
f592407e
AM		 2826 sdata = bfd_zalloc (abfd, amt);
2827 if (sdata == NULL)
2828 return FALSE;
2829 sec->used_by_bfd = sdata;
2830 }
22b75d0a
DM		 2831
2832 return _bfd_elf_new_section_hook (abfd, sec);
2833}
2834
2835bfd_boolean
2836_bfd_sparc_elf_relax_section (bfd *abfd ATTRIBUTE_UNUSED,
2837 struct bfd_section *section,
2838 struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
2839 bfd_boolean *again)
2840{
c8a1f254
NS		 2841 if (link_info->relocatable)
2842 (*link_info->callbacks->einfo)
2843 (_("%P%F: --relax and -r may not be used together\n"));
2844
22b75d0a
DM		 2845 *again = FALSE;
2846 sec_do_relax (section) = 1;
2847 return TRUE;
2848}
2849\f
2850/* Return the base VMA address which should be subtracted from real addresses
2851 when resolving @dtpoff relocation.
2852 This is PT_TLS segment p_vaddr. */
2853
2854static bfd_vma
2855dtpoff_base (struct bfd_link_info *info)
2856{
2857 /* If tls_sec is NULL, we should have signalled an error already. */
2858 if (elf_hash_table (info)->tls_sec == NULL)
2859 return 0;
2860 return elf_hash_table (info)->tls_sec->vma;
2861}
2862
2863/* Return the relocation value for @tpoff relocation
2864 if STT_TLS virtual address is ADDRESS. */
2865
2866static bfd_vma
2867tpoff (struct bfd_link_info *info, bfd_vma address)
2868{
2869 struct elf_link_hash_table *htab = elf_hash_table (info);
1360ba76
RO		 2870 const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
2871 bfd_vma static_tls_size;
22b75d0a
DM		 2872
2873 /* If tls_sec is NULL, we should have signalled an error already. */
2874 if (htab->tls_sec == NULL)
2875 return 0;
1360ba76
RO		 2876
2877 /* Consider special static TLS alignment requirements. */
2878 static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
2879 return address - static_tls_size - htab->tls_sec->vma;
22b75d0a
DM		 2880}
2881
00c50991
DM		 2882/* Return the relocation value for a %gdop relocation. */
2883
2884static bfd_vma
2885gdopoff (struct bfd_link_info *info, bfd_vma address)
2886{
2887 struct elf_link_hash_table *htab = elf_hash_table (info);
2888 bfd_vma got_base;
2889
2890 got_base = (htab->hgot->root.u.def.value
2891 + htab->hgot->root.u.def.section->output_offset
2892 + htab->hgot->root.u.def.section->output_section->vma);
2893
2894 return address - got_base;
2895}
2896
22b75d0a
DM		 2897/* Relocate a SPARC ELF section. */
2898
2899bfd_boolean
ab96bf03
AM		 2900_bfd_sparc_elf_relocate_section (bfd *output_bfd,
2901 struct bfd_link_info *info,
2902 bfd *input_bfd,
2903 asection *input_section,
2904 bfd_byte *contents,
2905 Elf_Internal_Rela *relocs,
2906 Elf_Internal_Sym *local_syms,
2907 asection **local_sections)
22b75d0a
DM		 2908{
2909 struct _bfd_sparc_elf_link_hash_table *htab;
2910 Elf_Internal_Shdr *symtab_hdr;
2911 struct elf_link_hash_entry **sym_hashes;
2912 bfd_vma *local_got_offsets;
2913 bfd_vma got_base;
2914 asection *sreloc;
2915 Elf_Internal_Rela *rel;
2916 Elf_Internal_Rela *relend;
2917 int num_relocs;
3348747a 2918 bfd_boolean is_vxworks_tls;
22b75d0a 2919
22b75d0a 2920 htab = _bfd_sparc_elf_hash_table (info);
4dfe6ac6 2921 BFD_ASSERT (htab != NULL);
0ffa91dd 2922 symtab_hdr = &elf_symtab_hdr (input_bfd);
22b75d0a
DM		 2923 sym_hashes = elf_sym_hashes (input_bfd);
2924 local_got_offsets = elf_local_got_offsets (input_bfd);
2925
2926 if (elf_hash_table (info)->hgot == NULL)
2927 got_base = 0;
2928 else
2929 got_base = elf_hash_table (info)->hgot->root.u.def.value;
2930
2931 sreloc = elf_section_data (input_section)->sreloc;
3348747a
NS		 2932 /* We have to handle relocations in vxworks .tls_vars sections
2933 specially, because the dynamic loader is 'weird'. */
2934 is_vxworks_tls = (htab->is_vxworks && info->shared
2935 && !strcmp (input_section->output_section->name,
2936 ".tls_vars"));
22b75d0a
DM		 2937
2938 rel = relocs;
2939 if (ABI_64_P (output_bfd))
d4730f92 2940 num_relocs = NUM_SHDR_ENTRIES (_bfd_elf_single_rel_hdr (input_section));
22b75d0a
DM		 2941 else
2942 num_relocs = input_section->reloc_count;
2943 relend = relocs + num_relocs;
2944 for (; rel < relend; rel++)
2945 {
2946 int r_type, tls_type;
2947 reloc_howto_type *howto;
2948 unsigned long r_symndx;
2949 struct elf_link_hash_entry *h;
2950 Elf_Internal_Sym *sym;
2951 asection *sec;
2952 bfd_vma relocation, off;
2953 bfd_reloc_status_type r;
2954 bfd_boolean is_plt = FALSE;
2955 bfd_boolean unresolved_reloc;
2956
2957 r_type = SPARC_ELF_R_TYPE (rel->r_info);
2958 if (r_type == R_SPARC_GNU_VTINHERIT
2959 || r_type == R_SPARC_GNU_VTENTRY)
2960 continue;
2961
2962 if (r_type < 0 || r_type >= (int) R_SPARC_max_std)
2963 {
2964 bfd_set_error (bfd_error_bad_value);
2965 return FALSE;
2966 }
2967 howto = _bfd_sparc_elf_howto_table + r_type;
2968
22b75d0a
DM		 2969 r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
2970 h = NULL;
2971 sym = NULL;
2972 sec = NULL;
2973 unresolved_reloc = FALSE;
2974 if (r_symndx < symtab_hdr->sh_info)
2975 {
2976 sym = local_syms + r_symndx;
2977 sec = local_sections[r_symndx];
2978 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
d0c9aeb3
DM		 2979
2980 if (!info->relocatable
2981 && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
2982 {
2983 /* Relocate against local STT_GNU_IFUNC symbol. */
2984 h = elf_sparc_get_local_sym_hash (htab, input_bfd,
2985 rel, FALSE);
2986 if (h == NULL)
2987 abort ();
2988
2989 /* Set STT_GNU_IFUNC symbol value. */
2990 h->root.u.def.value = sym->st_value;
2991 h->root.u.def.section = sec;
2992 }
22b75d0a
DM		 2993 }
2994 else
2995 {
2996 bfd_boolean warned;
2997
2998 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2999 r_symndx, symtab_hdr, sym_hashes,
3000 h, sec, relocation,
3001 unresolved_reloc, warned);
3002 if (warned)
3003 {
3004 /* To avoid generating warning messages about truncated
3005 relocations, set the relocation's address to be the same as
3006 the start of this section. */
3007 if (input_section->output_section != NULL)
3008 relocation = input_section->output_section->vma;
3009 else
3010 relocation = 0;
3011 }
3012 }
3013
dbaa2011 3014 if (sec != NULL && discarded_section (sec))
e4067dbb 3015 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
545fd46b 3016 rel, 1, relend, howto, 0, contents);
ab96bf03
AM		 3017
3018 if (info->relocatable)
3019 continue;
3020
d0c9aeb3
DM		 3021 if (h != NULL
3022 && h->type == STT_GNU_IFUNC
3023 && h->def_regular)
3024 {
3025 asection *plt_sec;
3026 const char *name;
3027
3028 if ((input_section->flags & SEC_ALLOC) == 0
3029 || h->plt.offset == (bfd_vma) -1)
3030 abort ();
3031
3032 plt_sec = htab->elf.splt;
3033 if (! plt_sec)
3034 plt_sec =htab->elf.iplt;
3035
3036 switch (r_type)
3037 {
00c50991
DM		 3038 case R_SPARC_GOTDATA_OP:
3039 continue;
3040
d0c9aeb3
DM		 3041 case R_SPARC_GOTDATA_OP_HIX22:
3042 case R_SPARC_GOTDATA_OP_LOX10:
00c50991
DM		 3043 r_type = (r_type == R_SPARC_GOTDATA_OP_HIX22
3044 ? R_SPARC_GOT22
3045 : R_SPARC_GOT10);
3046 howto = _bfd_sparc_elf_howto_table + r_type;
3047 /* Fall through. */
3048
d0c9aeb3
DM		 3049 case R_SPARC_GOT10:
3050 case R_SPARC_GOT13:
3051 case R_SPARC_GOT22:
3052 if (htab->elf.sgot == NULL)
3053 abort ();
3054 off = h->got.offset;
3055 if (off == (bfd_vma) -1)
3056 abort();
3057 relocation = htab->elf.sgot->output_offset + off - got_base;
3058 goto do_relocation;
3059
3060 case R_SPARC_WPLT30:
3061 case R_SPARC_WDISP30:
3062 relocation = (plt_sec->output_section->vma
3063 + plt_sec->output_offset + h->plt.offset);
3064 goto do_relocation;
3065
3066 case R_SPARC_32:
3067 case R_SPARC_64:
3068 if (info->shared && h->non_got_ref)
3069 {
3070 Elf_Internal_Rela outrel;
3071 bfd_vma offset;
3072
3073 offset = _bfd_elf_section_offset (output_bfd, info,
3074 input_section,
3075 rel->r_offset);
3076 if (offset == (bfd_vma) -1
3077 || offset == (bfd_vma) -2)
3078 abort();
3079
3080 outrel.r_offset = (input_section->output_section->vma
3081 + input_section->output_offset
3082 + offset);
3083
3084 if (h->dynindx == -1
3085 || h->forced_local
3086 || info->executable)
3087 {
3088 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
3089 0, R_SPARC_IRELATIVE);
3090 outrel.r_addend = relocation + rel->r_addend;
3091 }
3092 else
3093 {
3094 if (h->dynindx == -1)
3095 abort();
3096 outrel.r_info = SPARC_ELF_R_INFO (htab, rel, h->dynindx, r_type);
3097 outrel.r_addend = rel->r_addend;
3098 }
3099
3100 sparc_elf_append_rela (output_bfd, sreloc, &outrel);
3101 continue;
3102 }
3103
3104 relocation = (plt_sec->output_section->vma
3105 + plt_sec->output_offset + h->plt.offset);
3106 goto do_relocation;
3107
3108 case R_SPARC_HI22:
3109 case R_SPARC_LO10:
3110 /* We should only see such relocs in static links. */
3111 if (info->shared)
3112 abort();
3113 relocation = (plt_sec->output_section->vma
3114 + plt_sec->output_offset + h->plt.offset);
3115 goto do_relocation;
3116
3117 default:
3118 if (h->root.root.string)
3119 name = h->root.root.string;
3120 else
3121 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3122 NULL);
3123 (*_bfd_error_handler)
3124 (_("%B: relocation %s against STT_GNU_IFUNC "
3125 "symbol `%s' isn't handled by %s"), input_bfd,
3126 _bfd_sparc_elf_howto_table[r_type].name,
3127 name, __FUNCTION__);
3128 bfd_set_error (bfd_error_bad_value);
3129 return FALSE;
3130 }
3131 }
3132
22b75d0a
DM		 3133 switch (r_type)
3134 {
739f7f82
DM		 3135 case R_SPARC_GOTDATA_OP_HIX22:
3136 case R_SPARC_GOTDATA_OP_LOX10:
00c50991
DM		 3137 if (SYMBOL_REFERENCES_LOCAL (info, h))
3138 r_type = (r_type == R_SPARC_GOTDATA_OP_HIX22
3139 ? R_SPARC_GOTDATA_HIX22
3140 : R_SPARC_GOTDATA_LOX10);
739f7f82 3141 else
00c50991
DM		 3142 r_type = (r_type == R_SPARC_GOTDATA_OP_HIX22
3143 ? R_SPARC_GOT22
3144 : R_SPARC_GOT10);
3145 howto = _bfd_sparc_elf_howto_table + r_type;
3146 break;
3147
3148 case R_SPARC_GOTDATA_OP:
3149 if (SYMBOL_REFERENCES_LOCAL (info, h))
3150 {
3151 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3152
3153 /* {ld,ldx} [%rs1 + %rs2], %rd --> add %rs1, %rs2, %rd */
3154 relocation = 0x80000000 | (insn & 0x3e07c01f);
3155 bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3156 }
3157 continue;
3158 }
3159
3160 switch (r_type)
3161 {
3162 case R_SPARC_GOTDATA_HIX22:
3163 case R_SPARC_GOTDATA_LOX10:
3164 relocation = gdopoff (info, relocation);
3165 break;
739f7f82 3166
22b75d0a
DM		 3167 case R_SPARC_GOT10:
3168 case R_SPARC_GOT13:
3169 case R_SPARC_GOT22:
3170 /* Relocation is to the entry for this symbol in the global
3171 offset table. */
72fbc6e5 3172 if (htab->elf.sgot == NULL)
22b75d0a
DM		 3173 abort ();
3174
3175 if (h != NULL)
3176 {
3177 bfd_boolean dyn;
3178
3179 off = h->got.offset;
3180 BFD_ASSERT (off != (bfd_vma) -1);
3181 dyn = elf_hash_table (info)->dynamic_sections_created;
3182
3183 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3184 || (info->shared
72fbc6e5 3185 && SYMBOL_REFERENCES_LOCAL (info, h)))
22b75d0a
DM		 3186 {
3187 /* This is actually a static link, or it is a
3188 -Bsymbolic link and the symbol is defined
3189 locally, or the symbol was forced to be local
3190 because of a version file. We must initialize
3191 this entry in the global offset table. Since the
3192 offset must always be a multiple of 8 for 64-bit
3193 and 4 for 32-bit, we use the least significant bit
3194 to record whether we have initialized it already.
3195
3196 When doing a dynamic link, we create a .rela.got
3197 relocation entry to initialize the value. This
3198 is done in the finish_dynamic_symbol routine. */
3199 if ((off & 1) != 0)
3200 off &= ~1;
3201 else
3202 {
3203 SPARC_ELF_PUT_WORD (htab, output_bfd, relocation,
72fbc6e5 3204 htab->elf.sgot->contents + off);
22b75d0a
DM		 3205 h->got.offset |= 1;
3206 }
3207 }
3208 else
3209 unresolved_reloc = FALSE;
3210 }
3211 else
3212 {
3213 BFD_ASSERT (local_got_offsets != NULL
3214 && local_got_offsets[r_symndx] != (bfd_vma) -1);
3215
3216 off = local_got_offsets[r_symndx];
3217
3218 /* The offset must always be a multiple of 8 on 64-bit and
3219 4 on 32-bit. We use the least significant bit to record
3220 whether we have already processed this entry. */
3221 if ((off & 1) != 0)
3222 off &= ~1;
3223 else
3224 {
3225
3226 if (info->shared)
3227 {
3228 asection *s;
3229 Elf_Internal_Rela outrel;
3230
3231 /* We need to generate a R_SPARC_RELATIVE reloc
3232 for the dynamic linker. */
72fbc6e5 3233 s = htab->elf.srelgot;
22b75d0a
DM		 3234 BFD_ASSERT (s != NULL);
3235
72fbc6e5
DM		 3236 outrel.r_offset = (htab->elf.sgot->output_section->vma
3237 + htab->elf.sgot->output_offset
22b75d0a
DM		 3238 + off);
3239 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
3240 0, R_SPARC_RELATIVE);
3241 outrel.r_addend = relocation;
3242 relocation = 0;
39817122 3243 sparc_elf_append_rela (output_bfd, s, &outrel);
22b75d0a
DM		 3244 }
3245
3246 SPARC_ELF_PUT_WORD (htab, output_bfd, relocation,
72fbc6e5 3247 htab->elf.sgot->contents + off);
22b75d0a
DM		 3248 local_got_offsets[r_symndx] |= 1;
3249 }
3250 }
72fbc6e5 3251 relocation = htab->elf.sgot->output_offset + off - got_base;
22b75d0a
DM		 3252 break;
3253
3254 case R_SPARC_PLT32:
3255 case R_SPARC_PLT64:
3256 if (h == NULL || h->plt.offset == (bfd_vma) -1)
3257 {
3258 r_type = (r_type == R_SPARC_PLT32) ? R_SPARC_32 : R_SPARC_64;
3259 goto r_sparc_plt32;
3260 }
3261 /* Fall through. */
3262
3263 case R_SPARC_WPLT30:
3264 case R_SPARC_HIPLT22:
3265 case R_SPARC_LOPLT10:
3266 case R_SPARC_PCPLT32:
3267 case R_SPARC_PCPLT22:
3268 case R_SPARC_PCPLT10:
3269 r_sparc_wplt30:
3270 /* Relocation is to the entry for this symbol in the
3271 procedure linkage table. */
3272
3273 if (! ABI_64_P (output_bfd))
3274 {
3275 /* The Solaris native assembler will generate a WPLT30 reloc
3276 for a local symbol if you assemble a call from one
3277 section to another when using -K pic. We treat it as
3278 WDISP30. */
3279 if (h == NULL)
3280 break;
3281 }
af1fb11f
NC		 3282 /* PR 7027: We need similar behaviour for 64-bit binaries. */
3283 else if (r_type == R_SPARC_WPLT30 && h == NULL)
3284 break;
22b75d0a
DM		 3285 else
3286 {
3287 BFD_ASSERT (h != NULL);
3288 }
3289
72fbc6e5 3290 if (h->plt.offset == (bfd_vma) -1 || htab->elf.splt == NULL)
22b75d0a
DM		 3291 {
3292 /* We didn't make a PLT entry for this symbol. This
3293 happens when statically linking PIC code, or when
3294 using -Bsymbolic. */
3295 break;
3296 }
3297
72fbc6e5
DM		 3298 relocation = (htab->elf.splt->output_section->vma
3299 + htab->elf.splt->output_offset
22b75d0a
DM		 3300 + h->plt.offset);
3301 unresolved_reloc = FALSE;
3302 if (r_type == R_SPARC_PLT32 || r_type == R_SPARC_PLT64)
3303 {
3304 r_type = r_type == R_SPARC_PLT32 ? R_SPARC_32 : R_SPARC_64;
3305 is_plt = TRUE;
3306 goto r_sparc_plt32;
3307 }
3308 break;
3309
3310 case R_SPARC_PC10:
3311 case R_SPARC_PC22:
3312 case R_SPARC_PC_HH22:
3313 case R_SPARC_PC_HM10:
3314 case R_SPARC_PC_LM22:
3315 if (h != NULL
3316 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3317 break;
3318 /* Fall through. */
3319 case R_SPARC_DISP8:
3320 case R_SPARC_DISP16:
3321 case R_SPARC_DISP32:
3322 case R_SPARC_DISP64:
3323 case R_SPARC_WDISP30:
3324 case R_SPARC_WDISP22:
3325 case R_SPARC_WDISP19:
3326 case R_SPARC_WDISP16:
2615994e 3327 case R_SPARC_WDISP10:
22b75d0a
DM		 3328 case R_SPARC_8:
3329 case R_SPARC_16:
3330 case R_SPARC_32:
3331 case R_SPARC_HI22:
3332 case R_SPARC_22:
3333 case R_SPARC_13:
3334 case R_SPARC_LO10:
3335 case R_SPARC_UA16:
3336 case R_SPARC_UA32:
3337 case R_SPARC_10:
3338 case R_SPARC_11:
3339 case R_SPARC_64:
3340 case R_SPARC_OLO10:
3341 case R_SPARC_HH22:
3342 case R_SPARC_HM10:
3343 case R_SPARC_LM22:
3344 case R_SPARC_7:
3345 case R_SPARC_5:
3346 case R_SPARC_6:
3347 case R_SPARC_HIX22:
3348 case R_SPARC_LOX10:
3349 case R_SPARC_H44:
3350 case R_SPARC_M44:
3351 case R_SPARC_L44:
2615994e 3352 case R_SPARC_H34:
22b75d0a
DM		 3353 case R_SPARC_UA64:
3354 r_sparc_plt32:
3348747a
NS		 3355 if ((input_section->flags & SEC_ALLOC) == 0
3356 || is_vxworks_tls)
22b75d0a
DM		 3357 break;
3358
3359 if ((info->shared
3360 && (h == NULL
3361 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3362 || h->root.type != bfd_link_hash_undefweak)
3363 && (! howto->pc_relative
72fbc6e5 3364 || !SYMBOL_CALLS_LOCAL (info, h)))
22b75d0a
DM		 3365 || (!info->shared
3366 && h != NULL
3367 && h->dynindx != -1
3368 && !h->non_got_ref
3369 && ((h->def_dynamic
3370 && !h->def_regular)
3371 || h->root.type == bfd_link_hash_undefweak
3372 || h->root.type == bfd_link_hash_undefined)))
3373 {
3374 Elf_Internal_Rela outrel;
3375 bfd_boolean skip, relocate = FALSE;
3376
3377 /* When generating a shared object, these relocations
3378 are copied into the output file to be resolved at run
3379 time. */
3380
3381 BFD_ASSERT (sreloc != NULL);
3382
3383 skip = FALSE;
3384
3385 outrel.r_offset =
3386 _bfd_elf_section_offset (output_bfd, info, input_section,
3387 rel->r_offset);
3388 if (outrel.r_offset == (bfd_vma) -1)
3389 skip = TRUE;
3390 else if (outrel.r_offset == (bfd_vma) -2)
3391 skip = TRUE, relocate = TRUE;
3392 outrel.r_offset += (input_section->output_section->vma
3393 + input_section->output_offset);
3394
3395 /* Optimize unaligned reloc usage now that we know where
3396 it finally resides. */
3397 switch (r_type)
3398 {
3399 case R_SPARC_16:
3400 if (outrel.r_offset & 1)
3401 r_type = R_SPARC_UA16;
3402 break;
3403 case R_SPARC_UA16:
3404 if (!(outrel.r_offset & 1))
3405 r_type = R_SPARC_16;
3406 break;
3407 case R_SPARC_32:
3408 if (outrel.r_offset & 3)
3409 r_type = R_SPARC_UA32;
3410 break;
3411 case R_SPARC_UA32:
3412 if (!(outrel.r_offset & 3))
3413 r_type = R_SPARC_32;
3414 break;
3415 case R_SPARC_64:
3416 if (outrel.r_offset & 7)
3417 r_type = R_SPARC_UA64;
3418 break;
3419 case R_SPARC_UA64:
3420 if (!(outrel.r_offset & 7))
3421 r_type = R_SPARC_64;
3422 break;
3423 case R_SPARC_DISP8:
3424 case R_SPARC_DISP16:
3425 case R_SPARC_DISP32:
3426 case R_SPARC_DISP64:
3427 /* If the symbol is not dynamic, we should not keep
3428 a dynamic relocation. But an .rela.* slot has been
3429 allocated for it, output R_SPARC_NONE.
3430 FIXME: Add code tracking needed dynamic relocs as
3431 e.g. i386 has. */
3432 if (h->dynindx == -1)
3433 skip = TRUE, relocate = TRUE;
3434 break;
3435 }
3436
3437 if (skip)
3438 memset (&outrel, 0, sizeof outrel);
3439 /* h->dynindx may be -1 if the symbol was marked to
3440 become local. */
72fbc6e5
DM		 3441 else if (h != NULL &&
3442 h->dynindx != -1
3443 && (! is_plt
3444 || !info->shared
3445 || !SYMBOLIC_BIND (info, h)
22b75d0a
DM		 3446 || !h->def_regular))
3447 {
3448 BFD_ASSERT (h->dynindx != -1);
3449 outrel.r_info = SPARC_ELF_R_INFO (htab, rel, h->dynindx, r_type);
3450 outrel.r_addend = rel->r_addend;
3451 }
3452 else
3453 {
3454 if (r_type == R_SPARC_32 || r_type == R_SPARC_64)
3455 {
3456 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
3457 0, R_SPARC_RELATIVE);
3458 outrel.r_addend = relocation + rel->r_addend;
3459 }
3460 else
3461 {
3462 long indx;
3463
74541ad4
AM		 3464 outrel.r_addend = relocation + rel->r_addend;
3465
22b75d0a 3466 if (is_plt)
72fbc6e5 3467 sec = htab->elf.splt;
22b75d0a
DM		 3468
3469 if (bfd_is_abs_section (sec))
3470 indx = 0;
3471 else if (sec == NULL || sec->owner == NULL)
3472 {
3473 bfd_set_error (bfd_error_bad_value);
3474 return FALSE;
3475 }
3476 else
3477 {
3478 asection *osec;
3479
74541ad4
AM		 3480 /* We are turning this relocation into one
3481 against a section symbol. It would be
3482 proper to subtract the symbol's value,
3483 osec->vma, from the emitted reloc addend,
3484 but ld.so expects buggy relocs. */
22b75d0a
DM		 3485 osec = sec->output_section;
3486 indx = elf_section_data (osec)->dynindx;
3487
74541ad4
AM		 3488 if (indx == 0)
3489 {
3490 osec = htab->elf.text_index_section;
3491 indx = elf_section_data (osec)->dynindx;
3492 }
3493
22b75d0a
DM		 3494 /* FIXME: we really should be able to link non-pic
3495 shared libraries. */
3496 if (indx == 0)
3497 {
3498 BFD_FAIL ();
3499 (*_bfd_error_handler)
3500 (_("%B: probably compiled without -fPIC?"),
3501 input_bfd);
3502 bfd_set_error (bfd_error_bad_value);
3503 return FALSE;
3504 }
3505 }
3506
74541ad4
AM		 3507 outrel.r_info = SPARC_ELF_R_INFO (htab, rel, indx,
3508 r_type);
22b75d0a
DM		 3509 }
3510 }
3511
39817122 3512 sparc_elf_append_rela (output_bfd, sreloc, &outrel);
22b75d0a
DM		 3513
3514 /* This reloc will be computed at runtime, so there's no
3515 need to do anything now. */
3516 if (! relocate)
3517 continue;
3518 }
3519 break;
3520
3521 case R_SPARC_TLS_GD_HI22:
3522 if (! ABI_64_P (input_bfd)
3523 && ! _bfd_sparc_elf_tdata (input_bfd)->has_tlsgd)
3524 {
3525 /* R_SPARC_REV32 used the same reloc number as
3526 R_SPARC_TLS_GD_HI22. */
3527 r_type = R_SPARC_REV32;
3528 break;
3529 }
3530 /* Fall through */
3531
3532 case R_SPARC_TLS_GD_LO10:
3533 case R_SPARC_TLS_IE_HI22:
3534 case R_SPARC_TLS_IE_LO10:
3535 r_type = sparc_elf_tls_transition (info, input_bfd, r_type, h == NULL);
3536 tls_type = GOT_UNKNOWN;
3537 if (h == NULL && local_got_offsets)
3538 tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3539 else if (h != NULL)
3540 {
3541 tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3542 if (!info->shared && h->dynindx == -1 && tls_type == GOT_TLS_IE)
3543 switch (SPARC_ELF_R_TYPE (rel->r_info))
3544 {
3545 case R_SPARC_TLS_GD_HI22:
3546 case R_SPARC_TLS_IE_HI22:
3547 r_type = R_SPARC_TLS_LE_HIX22;
3548 break;
3549 default:
3550 r_type = R_SPARC_TLS_LE_LOX10;
3551 break;
3552 }
3553 }
3554 if (tls_type == GOT_TLS_IE)
3555 switch (r_type)
3556 {
3557 case R_SPARC_TLS_GD_HI22:
3558 r_type = R_SPARC_TLS_IE_HI22;
3559 break;
3560 case R_SPARC_TLS_GD_LO10:
3561 r_type = R_SPARC_TLS_IE_LO10;
3562 break;
3563 }
3564
3565 if (r_type == R_SPARC_TLS_LE_HIX22)
3566 {
3567 relocation = tpoff (info, relocation);
3568 break;
3569 }
3570 if (r_type == R_SPARC_TLS_LE_LOX10)
3571 {
3572 /* Change add into xor. */
3573 relocation = tpoff (info, relocation);
3574 bfd_put_32 (output_bfd, (bfd_get_32 (input_bfd,
3575 contents + rel->r_offset)
3576 | 0x80182000), contents + rel->r_offset);
3577 break;
3578 }
3579
3580 if (h != NULL)
3581 {
3582 off = h->got.offset;
3583 h->got.offset |= 1;
3584 }
3585 else
3586 {
3587 BFD_ASSERT (local_got_offsets != NULL);
3588 off = local_got_offsets[r_symndx];
3589 local_got_offsets[r_symndx] |= 1;
3590 }
3591
3592 r_sparc_tlsldm:
72fbc6e5 3593 if (htab->elf.sgot == NULL)
22b75d0a
DM		 3594 abort ();
3595
3596 if ((off & 1) != 0)
3597 off &= ~1;
3598 else
3599 {
3600 Elf_Internal_Rela outrel;
3601 int dr_type, indx;
3602
72fbc6e5 3603 if (htab->elf.srelgot == NULL)
22b75d0a
DM		 3604 abort ();
3605
72fbc6e5
DM		 3606 SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3607 htab->elf.sgot->contents + off);
3608 outrel.r_offset = (htab->elf.sgot->output_section->vma
3609 + htab->elf.sgot->output_offset + off);
22b75d0a
DM		 3610 indx = h && h->dynindx != -1 ? h->dynindx : 0;
3611 if (r_type == R_SPARC_TLS_IE_HI22
3612 || r_type == R_SPARC_TLS_IE_LO10)
3613 dr_type = SPARC_ELF_TPOFF_RELOC (htab);
3614 else
3615 dr_type = SPARC_ELF_DTPMOD_RELOC (htab);
3616 if (dr_type == SPARC_ELF_TPOFF_RELOC (htab) && indx == 0)
3617 outrel.r_addend = relocation - dtpoff_base (info);
3618 else
3619 outrel.r_addend = 0;
3620 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx, dr_type);
72fbc6e5 3621 sparc_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel);
22b75d0a
DM		 3622
3623 if (r_type == R_SPARC_TLS_GD_HI22
3624 || r_type == R_SPARC_TLS_GD_LO10)
3625 {
3626 if (indx == 0)
3627 {
3628 BFD_ASSERT (! unresolved_reloc);
3629 SPARC_ELF_PUT_WORD (htab, output_bfd,
3630 relocation - dtpoff_base (info),
72fbc6e5 3631 (htab->elf.sgot->contents + off
22b75d0a
DM		 3632 + SPARC_ELF_WORD_BYTES (htab)));
3633 }
3634 else
3635 {
3636 SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
72fbc6e5 3637 (htab->elf.sgot->contents + off
22b75d0a
DM		 3638 + SPARC_ELF_WORD_BYTES (htab)));
3639 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx,
3640 SPARC_ELF_DTPOFF_RELOC (htab));
3641 outrel.r_offset += SPARC_ELF_WORD_BYTES (htab);
72fbc6e5 3642 sparc_elf_append_rela (output_bfd, htab->elf.srelgot,
39817122 3643 &outrel);
22b75d0a
DM		 3644 }
3645 }
3646 else if (dr_type == SPARC_ELF_DTPMOD_RELOC (htab))
3647 {
3648 SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
72fbc6e5 3649 (htab->elf.sgot->contents + off
22b75d0a
DM		 3650 + SPARC_ELF_WORD_BYTES (htab)));
3651 }
3652 }
3653
3654 if (off >= (bfd_vma) -2)
3655 abort ();
3656
72fbc6e5 3657 relocation = htab->elf.sgot->output_offset + off - got_base;
22b75d0a
DM		 3658 unresolved_reloc = FALSE;
3659 howto = _bfd_sparc_elf_howto_table + r_type;
3660 break;
3661
3662 case R_SPARC_TLS_LDM_HI22:
3663 case R_SPARC_TLS_LDM_LO10:
3664 if (! info->shared)
3665 {
3666 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3667 continue;
3668 }
3669 off = htab->tls_ldm_got.offset;
3670 htab->tls_ldm_got.offset |= 1;
3671 goto r_sparc_tlsldm;
3672
3673 case R_SPARC_TLS_LDO_HIX22:
3674 case R_SPARC_TLS_LDO_LOX10:
3675 if (info->shared)
3676 {
3677 relocation -= dtpoff_base (info);
3678 break;
3679 }
3680
3681 r_type = (r_type == R_SPARC_TLS_LDO_HIX22
3682 ? R_SPARC_TLS_LE_HIX22 : R_SPARC_TLS_LE_LOX10);
3683 /* Fall through. */
3684
3685 case R_SPARC_TLS_LE_HIX22:
3686 case R_SPARC_TLS_LE_LOX10:
3687 if (info->shared)
3688 {
3689 Elf_Internal_Rela outrel;
c7e2358a 3690 bfd_boolean skip;
22b75d0a
DM		 3691
3692 BFD_ASSERT (sreloc != NULL);
3693 skip = FALSE;
3694 outrel.r_offset =
3695 _bfd_elf_section_offset (output_bfd, info, input_section,
3696 rel->r_offset);
3697 if (outrel.r_offset == (bfd_vma) -1)
3698 skip = TRUE;
3699 else if (outrel.r_offset == (bfd_vma) -2)
c7e2358a 3700 skip = TRUE;
22b75d0a
DM		 3701 outrel.r_offset += (input_section->output_section->vma
3702 + input_section->output_offset);
3703 if (skip)
3704 memset (&outrel, 0, sizeof outrel);
3705 else
3706 {
3707 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, r_type);
3708 outrel.r_addend = relocation - dtpoff_base (info)
3709 + rel->r_addend;
3710 }
3711
39817122 3712 sparc_elf_append_rela (output_bfd, sreloc, &outrel);
22b75d0a
DM		 3713 continue;
3714 }
3715 relocation = tpoff (info, relocation);
3716 break;
3717
3718 case R_SPARC_TLS_LDM_CALL:
3719 if (! info->shared)
3720 {
3721 /* mov %g0, %o0 */
3722 bfd_put_32 (output_bfd, 0x90100000, contents + rel->r_offset);
3723 continue;
3724 }
3725 /* Fall through */
3726
3727 case R_SPARC_TLS_GD_CALL:
3728 tls_type = GOT_UNKNOWN;
3729 if (h == NULL && local_got_offsets)
3730 tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3731 else if (h != NULL)
3732 tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3733 if (! info->shared
3734 || (r_type == R_SPARC_TLS_GD_CALL && tls_type == GOT_TLS_IE))
3735 {
abd242a9 3736 Elf_Internal_Rela *rel2;
22b75d0a
DM		 3737 bfd_vma insn;
3738
3739 if (!info->shared && (h == NULL || h->dynindx == -1))
3740 {
3741 /* GD -> LE */
3742 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3743 continue;
3744 }
3745
3746 /* GD -> IE */
3747 if (rel + 1 < relend
3748 && SPARC_ELF_R_TYPE (rel[1].r_info) == R_SPARC_TLS_GD_ADD
3749 && rel[1].r_offset == rel->r_offset + 4
3750 && SPARC_ELF_R_SYMNDX (htab, rel[1].r_info) == r_symndx
3751 && (((insn = bfd_get_32 (input_bfd,
3752 contents + rel[1].r_offset))
3753 >> 25) & 0x1f) == 8)
3754 {
3755 /* We have
3756 call __tls_get_addr, %tgd_call(foo)
3757 add %reg1, %reg2, %o0, %tgd_add(foo)
3758 and change it into IE:
3759 {ld,ldx} [%reg1 + %reg2], %o0, %tie_ldx(foo)
3760 add %g7, %o0, %o0, %tie_add(foo).
3761 add is 0x80000000 | (rd << 25) | (rs1 << 14) | rs2,
3762 ld is 0xc0000000 | (rd << 25) | (rs1 << 14) | rs2,
3763 ldx is 0xc0580000 | (rd << 25) | (rs1 << 14) | rs2. */
3764 bfd_put_32 (output_bfd, insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000),
3765 contents + rel->r_offset);
3766 bfd_put_32 (output_bfd, 0x9001c008,
3767 contents + rel->r_offset + 4);
3768 rel++;
3769 continue;
3770 }
3771
abd242a9
DM		 3772 /* We cannot just overwrite the delay slot instruction,
3773 as it might be what puts the %o0 argument to
3774 __tls_get_addr into place. So we have to transpose
3775 the delay slot with the add we patch in. */
3776 insn = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
3777 bfd_put_32 (output_bfd, insn,
3778 contents + rel->r_offset);
3779 bfd_put_32 (output_bfd, 0x9001c008,
3780 contents + rel->r_offset + 4);
3781
3782 rel2 = rel;
3783 while ((rel2 = sparc_elf_find_reloc_at_ofs (rel2 + 1, relend,
3784 rel->r_offset + 4))
3785 != NULL)
3786 {
3787 /* If the instruction we moved has a relocation attached to
3788 it, adjust the offset so that it will apply to the correct
3789 instruction. */
3790 rel2->r_offset -= 4;
3791 }
22b75d0a
DM		 3792 continue;
3793 }
3794
3795 h = (struct elf_link_hash_entry *)
3796 bfd_link_hash_lookup (info->hash, "__tls_get_addr", FALSE,
3797 FALSE, TRUE);
3798 BFD_ASSERT (h != NULL);
3799 r_type = R_SPARC_WPLT30;
3800 howto = _bfd_sparc_elf_howto_table + r_type;
3801 goto r_sparc_wplt30;
3802
3803 case R_SPARC_TLS_GD_ADD:
3804 tls_type = GOT_UNKNOWN;
3805 if (h == NULL && local_got_offsets)
3806 tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3807 else if (h != NULL)
3808 tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3809 if (! info->shared || tls_type == GOT_TLS_IE)
3810 {
3811 /* add %reg1, %reg2, %reg3, %tgd_add(foo)
3812 changed into IE:
3813 {ld,ldx} [%reg1 + %reg2], %reg3, %tie_ldx(foo)
3814 or LE:
3815 add %g7, %reg2, %reg3. */
3816 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3817 if ((h != NULL && h->dynindx != -1) || info->shared)
3818 relocation = insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000);
3819 else
3820 relocation = (insn & ~0x7c000) | 0x1c000;
3821 bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3822 }
3823 continue;
3824
3825 case R_SPARC_TLS_LDM_ADD:
3826 if (! info->shared)
3827 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3828 continue;
3829
3830 case R_SPARC_TLS_LDO_ADD:
3831 if (! info->shared)
3832 {
3833 /* Change rs1 into %g7. */
3834 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3835 insn = (insn & ~0x7c000) | 0x1c000;
3836 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3837 }
3838 continue;
3839
3840 case R_SPARC_TLS_IE_LD:
3841 case R_SPARC_TLS_IE_LDX:
3842 if (! info->shared && (h == NULL || h->dynindx == -1))
3843 {
3844 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3845 int rs2 = insn & 0x1f;
3846 int rd = (insn >> 25) & 0x1f;
3847
3848 if (rs2 == rd)
3849 relocation = SPARC_NOP;
3850 else
3851 relocation = 0x80100000 | (insn & 0x3e00001f);
3852 bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3853 }
3854 continue;
3855
3856 case R_SPARC_TLS_IE_ADD:
3857 /* Totally useless relocation. */
3858 continue;
3859
3860 case R_SPARC_TLS_DTPOFF32:
3861 case R_SPARC_TLS_DTPOFF64:
3862 relocation -= dtpoff_base (info);
3863 break;
3864
3865 default:
3866 break;
3867 }
3868
3869 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3870 because such sections are not SEC_ALLOC and thus ld.so will
3871 not process them. */
3872 if (unresolved_reloc
3873 && !((input_section->flags & SEC_DEBUGGING) != 0
1d5316ab
AM		 3874 && h->def_dynamic)
3875 && _bfd_elf_section_offset (output_bfd, info, input_section,
3876 rel->r_offset) != (bfd_vma) -1)
22b75d0a 3877 (*_bfd_error_handler)
843fe662 3878 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
22b75d0a
DM		 3879 input_bfd,
3880 input_section,
3881 (long) rel->r_offset,
843fe662 3882 howto->name,
22b75d0a
DM		 3883 h->root.root.string);
3884
3885 r = bfd_reloc_continue;
3886 if (r_type == R_SPARC_OLO10)
3887 {
3888 bfd_vma x;
3889
3890 if (! ABI_64_P (output_bfd))
3891 abort ();
3892
3893 relocation += rel->r_addend;
3894 relocation = (relocation & 0x3ff) + ELF64_R_TYPE_DATA (rel->r_info);
3895
3896 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3897 x = (x & ~(bfd_vma) 0x1fff) | (relocation & 0x1fff);
3898 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3899
3900 r = bfd_check_overflow (howto->complain_on_overflow,
3901 howto->bitsize, howto->rightshift,
3902 bfd_arch_bits_per_address (input_bfd),
3903 relocation);
3904 }
3905 else if (r_type == R_SPARC_WDISP16)
3906 {
3907 bfd_vma x;
3908
3909 relocation += rel->r_addend;
3910 relocation -= (input_section->output_section->vma
3911 + input_section->output_offset);
3912 relocation -= rel->r_offset;
3913
3914 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3915 x |= ((((relocation >> 2) & 0xc000) << 6)
3916 | ((relocation >> 2) & 0x3fff));
3917 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3918
2615994e
DM		 3919 r = bfd_check_overflow (howto->complain_on_overflow,
3920 howto->bitsize, howto->rightshift,
3921 bfd_arch_bits_per_address (input_bfd),
3922 relocation);
3923 }
3924 else if (r_type == R_SPARC_WDISP10)
3925 {
3926 bfd_vma x;
3927
3928 relocation += rel->r_addend;
3929 relocation -= (input_section->output_section->vma
3930 + input_section->output_offset);
3931 relocation -= rel->r_offset;
3932
3933 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3934 x |= ((((relocation >> 2) & 0x300) << 11)
3935 | (((relocation >> 2) & 0xff) << 5));
3936 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3937
22b75d0a
DM		 3938 r = bfd_check_overflow (howto->complain_on_overflow,
3939 howto->bitsize, howto->rightshift,
3940 bfd_arch_bits_per_address (input_bfd),
3941 relocation);
3942 }
3943 else if (r_type == R_SPARC_REV32)
3944 {
3945 bfd_vma x;
3946
3947 relocation = relocation + rel->r_addend;
3948
3949 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3950 x = x + relocation;
3951 bfd_putl32 (/*input_bfd,*/ x, contents + rel->r_offset);
3952 r = bfd_reloc_ok;
3953 }
3954 else if (r_type == R_SPARC_TLS_LDO_HIX22
3955 || r_type == R_SPARC_TLS_LE_HIX22)
3956 {
3957 bfd_vma x;
3958
3959 relocation += rel->r_addend;
3960 if (r_type == R_SPARC_TLS_LE_HIX22)
3961 relocation ^= MINUS_ONE;
3962
3963 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3964 x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
3965 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3966 r = bfd_reloc_ok;
3967 }
3968 else if (r_type == R_SPARC_TLS_LDO_LOX10
3969 || r_type == R_SPARC_TLS_LE_LOX10)
3970 {
3971 bfd_vma x;
3972
3973 relocation += rel->r_addend;
3974 relocation &= 0x3ff;
3975 if (r_type == R_SPARC_TLS_LE_LOX10)
3976 relocation |= 0x1c00;
3977
3978 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3979 x = (x & ~(bfd_vma) 0x1fff) | relocation;
3980 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3981
3982 r = bfd_reloc_ok;
3983 }
00c50991
DM		 3984 else if (r_type == R_SPARC_HIX22
3985 || r_type == R_SPARC_GOTDATA_HIX22)
22b75d0a
DM		 3986 {
3987 bfd_vma x;
3988
3989 relocation += rel->r_addend;
00c50991
DM		 3990 if (r_type == R_SPARC_HIX22
3991 || (bfd_signed_vma) relocation < 0)
3992 relocation = relocation ^ MINUS_ONE;
22b75d0a
DM		 3993
3994 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3995 x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
3996 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3997
3998 r = bfd_check_overflow (howto->complain_on_overflow,
3999 howto->bitsize, howto->rightshift,
4000 bfd_arch_bits_per_address (input_bfd),
4001 relocation);
4002 }
00c50991
DM		 4003 else if (r_type == R_SPARC_LOX10
4004 || r_type == R_SPARC_GOTDATA_LOX10)
22b75d0a
DM		 4005 {
4006 bfd_vma x;
4007
4008 relocation += rel->r_addend;
00c50991
DM		 4009 if (r_type == R_SPARC_LOX10
4010 || (bfd_signed_vma) relocation < 0)
4011 relocation = (relocation & 0x3ff) | 0x1c00;
4012 else
4013 relocation = (relocation & 0x3ff);
22b75d0a
DM		 4014
4015 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
4016 x = (x & ~(bfd_vma) 0x1fff) | relocation;
4017 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
4018
4019 r = bfd_reloc_ok;
4020 }
4021 else if ((r_type == R_SPARC_WDISP30 || r_type == R_SPARC_WPLT30)
4022 && sec_do_relax (input_section)
4023 && rel->r_offset + 4 < input_section->size)
4024 {
4025#define G0 0
4026#define O7 15
4027#define XCC (2 << 20)
4028#define COND(x) (((x)&0xf)<<25)
4029#define CONDA COND(0x8)
4030#define INSN_BPA (F2(0,1) | CONDA | BPRED | XCC)
4031#define INSN_BA (F2(0,2) | CONDA)
4032#define INSN_OR F3(2, 0x2, 0)
4033#define INSN_NOP F2(0,4)
4034
4035 bfd_vma x, y;
4036
4037 /* If the instruction is a call with either:
4038 restore
4039 arithmetic instruction with rd == %o7
4040 where rs1 != %o7 and rs2 if it is register != %o7
4041 then we can optimize if the call destination is near
4042 by changing the call into a branch always. */
4043 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
4044 y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
4045 if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2))
4046 {
4047 if (((y & OP3(~0)) == OP3(0x3d) /* restore */
4048 || ((y & OP3(0x28)) == 0 /* arithmetic */
4049 && (y & RD(~0)) == RD(O7)))
4050 && (y & RS1(~0)) != RS1(O7)
4051 && ((y & F3I(~0))
4052 || (y & RS2(~0)) != RS2(O7)))
4053 {
4054 bfd_vma reloc;
4055
4056 reloc = relocation + rel->r_addend - rel->r_offset;
4057 reloc -= (input_section->output_section->vma
4058 + input_section->output_offset);
4059
4060 /* Ensure the branch fits into simm22. */
4061 if ((reloc & 3) == 0
4062 && ((reloc & ~(bfd_vma)0x7fffff) == 0
4063 || ((reloc | 0x7fffff) == ~(bfd_vma)0)))
4064 {
4065 reloc >>= 2;
4066
4067 /* Check whether it fits into simm19. */
4068 if (((reloc & 0x3c0000) == 0
4069 || (reloc & 0x3c0000) == 0x3c0000)
4070 && (ABI_64_P (output_bfd)
4071 || elf_elfheader (output_bfd)->e_flags & EF_SPARC_32PLUS))
4072 x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */
4073 else
4074 x = INSN_BA | (reloc & 0x3fffff); /* ba */
4075 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
4076 r = bfd_reloc_ok;
4077 if (rel->r_offset >= 4
4078 && (y & (0xffffffff ^ RS1(~0)))
4079 == (INSN_OR | RD(O7) | RS2(G0)))
4080 {
4081 bfd_vma z;
4082 unsigned int reg;
4083
4084 z = bfd_get_32 (input_bfd,
4085 contents + rel->r_offset - 4);
4086 if ((z & (0xffffffff ^ RD(~0)))
4087 != (INSN_OR | RS1(O7) | RS2(G0)))
4088 break;
4089
4090 /* The sequence was
4091 or %o7, %g0, %rN
4092 call foo
4093 or %rN, %g0, %o7
4094
4095 If call foo was replaced with ba, replace
4096 or %rN, %g0, %o7 with nop. */
4097
4098 reg = (y & RS1(~0)) >> 14;
4099 if (reg != ((z & RD(~0)) >> 25)
4100 || reg == G0 || reg == O7)
4101 break;
4102
4103 bfd_put_32 (input_bfd, (bfd_vma) INSN_NOP,
4104 contents + rel->r_offset + 4);
4105 }
4106
4107 }
4108 }
4109 }
4110 }
4111
4112 if (r == bfd_reloc_continue)
d0c9aeb3
DM		 4113 {
4114do_relocation:
4115 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4116 contents, rel->r_offset,
4117 relocation, rel->r_addend);
4118 }
22b75d0a
DM		 4119 if (r != bfd_reloc_ok)
4120 {
4121 switch (r)
4122 {
4123 default:
4124 case bfd_reloc_outofrange:
4125 abort ();
4126 case bfd_reloc_overflow:
4127 {
4128 const char *name;
4129
dc669dc8
EB		 4130 /* The Solaris native linker silently disregards overflows.
4131 We don't, but this breaks stabs debugging info, whose
4132 relocations are only 32-bits wide. Ignore overflows in
4133 this case and also for discarded entries. */
0bef263a
RO		 4134 if ((r_type == R_SPARC_32
4135 || r_type == R_SPARC_UA32
4136 || r_type == R_SPARC_DISP32)
dc669dc8
EB		 4137 && (((input_section->flags & SEC_DEBUGGING) != 0
4138 && strcmp (bfd_section_name (input_bfd,
4139 input_section),
4140 ".stab") == 0)
4141 || _bfd_elf_section_offset (output_bfd, info,
4142 input_section,
4143 rel->r_offset)
4144 == (bfd_vma)-1))
4145 break;
4146
22b75d0a 4147 if (h != NULL)
bb29dfea
EB		 4148 {
4149 /* Assume this is a call protected by other code that
4150 detect the symbol is undefined. If this is the case,
4151 we can safely ignore the overflow. If not, the
4152 program is hosed anyway, and a little warning isn't
4153 going to help. */
4154 if (h->root.type == bfd_link_hash_undefweak
4155 && howto->pc_relative)
4156 break;
4157
4158 name = NULL;
4159 }
22b75d0a
DM		 4160 else
4161 {
4162 name = bfd_elf_string_from_elf_section (input_bfd,
4163 symtab_hdr->sh_link,
4164 sym->st_name);
4165 if (name == NULL)
4166 return FALSE;
4167 if (*name == '\0')
4168 name = bfd_section_name (input_bfd, sec);
4169 }
4170 if (! ((*info->callbacks->reloc_overflow)
4171 (info, (h ? &h->root : NULL), name, howto->name,
4172 (bfd_vma) 0, input_bfd, input_section,
4173 rel->r_offset)))
4174 return FALSE;
4175 }
4176 break;
4177 }
4178 }
4179 }
4180
4181 return TRUE;
4182}
4183
910600e9
RS		 4184/* Build a VxWorks PLT entry. PLT_INDEX is the index of the PLT entry
4185 and PLT_OFFSET is the byte offset from the start of .plt. GOT_OFFSET
4186 is the offset of the associated .got.plt entry from
4187 _GLOBAL_OFFSET_TABLE_. */
4188
4189static void
4190sparc_vxworks_build_plt_entry (bfd *output_bfd, struct bfd_link_info *info,
4191 bfd_vma plt_offset, bfd_vma plt_index,
4192 bfd_vma got_offset)
4193{
4194 bfd_vma got_base;
4195 const bfd_vma *plt_entry;
4196 struct _bfd_sparc_elf_link_hash_table *htab;
4197 bfd_byte *loc;
4198 Elf_Internal_Rela rela;
4199
4200 htab = _bfd_sparc_elf_hash_table (info);
4dfe6ac6
NC		 4201 BFD_ASSERT (htab != NULL);
4202
910600e9
RS		 4203 if (info->shared)
4204 {
4205 plt_entry = sparc_vxworks_shared_plt_entry;
4206 got_base = 0;
4207 }
4208 else
4209 {
4210 plt_entry = sparc_vxworks_exec_plt_entry;
4211 got_base = (htab->elf.hgot->root.u.def.value
4212 + htab->elf.hgot->root.u.def.section->output_offset
4213 + htab->elf.hgot->root.u.def.section->output_section->vma);
4214 }
4215
4216 /* Fill in the entry in the procedure linkage table. */
4217 bfd_put_32 (output_bfd, plt_entry[0] + ((got_base + got_offset) >> 10),
72fbc6e5 4218 htab->elf.splt->contents + plt_offset);
910600e9 4219 bfd_put_32 (output_bfd, plt_entry[1] + ((got_base + got_offset) & 0x3ff),
72fbc6e5 4220 htab->elf.splt->contents + plt_offset + 4);
910600e9 4221 bfd_put_32 (output_bfd, plt_entry[2],
72fbc6e5 4222 htab->elf.splt->contents + plt_offset + 8);
910600e9 4223 bfd_put_32 (output_bfd, plt_entry[3],
72fbc6e5 4224 htab->elf.splt->contents + plt_offset + 12);
910600e9 4225 bfd_put_32 (output_bfd, plt_entry[4],
72fbc6e5 4226 htab->elf.splt->contents + plt_offset + 16);
910600e9 4227 bfd_put_32 (output_bfd, plt_entry[5] + (plt_index >> 10),
72fbc6e5 4228 htab->elf.splt->contents + plt_offset + 20);
910600e9
RS		 4229 /* PC-relative displacement for a branch to the start of
4230 the PLT section. */
4231 bfd_put_32 (output_bfd, plt_entry[6] + (((-plt_offset - 24) >> 2)
4232 & 0x003fffff),
72fbc6e5 4233 htab->elf.splt->contents + plt_offset + 24);
910600e9 4234 bfd_put_32 (output_bfd, plt_entry[7] + (plt_index & 0x3ff),
72fbc6e5 4235 htab->elf.splt->contents + plt_offset + 28);
910600e9
RS		 4236
4237 /* Fill in the .got.plt entry, pointing initially at the
4238 second half of the PLT entry. */
72fbc6e5 4239 BFD_ASSERT (htab->elf.sgotplt != NULL);
910600e9 4240 bfd_put_32 (output_bfd,
72fbc6e5
DM		 4241 htab->elf.splt->output_section->vma
4242 + htab->elf.splt->output_offset
910600e9 4243 + plt_offset + 20,
72fbc6e5 4244 htab->elf.sgotplt->contents + got_offset);
910600e9
RS		 4245
4246 /* Add relocations to .rela.plt.unloaded. */
4247 if (!info->shared)
4248 {
4249 loc = (htab->srelplt2->contents
4250 + (2 + 3 * plt_index) * sizeof (Elf32_External_Rela));
4251
4252 /* Relocate the initial sethi. */
72fbc6e5
DM		 4253 rela.r_offset = (htab->elf.splt->output_section->vma
4254 + htab->elf.splt->output_offset
910600e9
RS		 4255 + plt_offset);
4256 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4257 rela.r_addend = got_offset;
4258 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4259 loc += sizeof (Elf32_External_Rela);
4260
4261 /* Likewise the following or. */
4262 rela.r_offset += 4;
4263 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4264 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4265 loc += sizeof (Elf32_External_Rela);
4266
4267 /* Relocate the .got.plt entry. */
72fbc6e5
DM		 4268 rela.r_offset = (htab->elf.sgotplt->output_section->vma
4269 + htab->elf.sgotplt->output_offset
910600e9
RS		 4270 + got_offset);
4271 rela.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_SPARC_32);
4272 rela.r_addend = plt_offset + 20;
4273 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4274 }
4275}
4276
22b75d0a
DM		 4277/* Finish up dynamic symbol handling. We set the contents of various
4278 dynamic sections here. */
4279
4280bfd_boolean
4281_bfd_sparc_elf_finish_dynamic_symbol (bfd *output_bfd,
4282 struct bfd_link_info *info,
4283 struct elf_link_hash_entry *h,
4284 Elf_Internal_Sym *sym)
4285{
22b75d0a 4286 struct _bfd_sparc_elf_link_hash_table *htab;
39817122 4287 const struct elf_backend_data *bed;
22b75d0a
DM		 4288
4289 htab = _bfd_sparc_elf_hash_table (info);
4dfe6ac6 4290 BFD_ASSERT (htab != NULL);
39817122 4291 bed = get_elf_backend_data (output_bfd);
22b75d0a
DM		 4292
4293 if (h->plt.offset != (bfd_vma) -1)
4294 {
4295 asection *splt;
4296 asection *srela;
4297 Elf_Internal_Rela rela;
4298 bfd_byte *loc;
910600e9 4299 bfd_vma r_offset, got_offset;
22b75d0a
DM		 4300 int rela_index;
4301
d0c9aeb3
DM		 4302 /* When building a static executable, use .iplt and
4303 .rela.iplt sections for STT_GNU_IFUNC symbols. */
4304 if (htab->elf.splt != NULL)
4305 {
4306 splt = htab->elf.splt;
4307 srela = htab->elf.srelplt;
4308 }
4309 else
4310 {
4311 splt = htab->elf.iplt;
4312 srela = htab->elf.irelplt;
4313 }
22b75d0a 4314
d0c9aeb3
DM		 4315 if (splt == NULL || srela == NULL)
4316 abort ();
22b75d0a 4317
22b75d0a 4318 /* Fill in the entry in the .rela.plt section. */
910600e9 4319 if (htab->is_vxworks)
22b75d0a 4320 {
910600e9
RS		 4321 /* Work out the index of this PLT entry. */
4322 rela_index = ((h->plt.offset - htab->plt_header_size)
4323 / htab->plt_entry_size);
4324
4325 /* Calculate the offset of the associated .got.plt entry.
4326 The first three entries are reserved. */
4327 got_offset = (rela_index + 3) * 4;
4328
4329 sparc_vxworks_build_plt_entry (output_bfd, info, h->plt.offset,
4330 rela_index, got_offset);
4331
4332
4333 /* On VxWorks, the relocation points to the .got.plt entry,
4334 not the .plt entry. */
72fbc6e5
DM		 4335 rela.r_offset = (htab->elf.sgotplt->output_section->vma
4336 + htab->elf.sgotplt->output_offset
910600e9 4337 + got_offset);
22b75d0a 4338 rela.r_addend = 0;
d0c9aeb3
DM		 4339 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx,
4340 R_SPARC_JMP_SLOT);
22b75d0a
DM		 4341 }
4342 else
4343 {
d0c9aeb3
DM		 4344 bfd_boolean ifunc = FALSE;
4345
910600e9
RS		 4346 /* Fill in the entry in the procedure linkage table. */
4347 rela_index = SPARC_ELF_BUILD_PLT_ENTRY (htab, output_bfd, splt,
4348 h->plt.offset, splt->size,
4349 &r_offset);
4350
d0c9aeb3
DM		 4351 if (h == NULL
4352 || h->dynindx == -1
4353 || ((info->executable
4354 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
4355 && h->def_regular
4356 && h->type == STT_GNU_IFUNC))
4357 {
4358 ifunc = TRUE;
4359 BFD_ASSERT (h == NULL
4360 || (h->type == STT_GNU_IFUNC
4361 && h->def_regular
4362 && (h->root.type == bfd_link_hash_defined
4363 || h->root.type == bfd_link_hash_defweak)));
4364 }
4365
910600e9
RS		 4366 rela.r_offset = r_offset
4367 + (splt->output_section->vma + splt->output_offset);
d0c9aeb3
DM		 4368 if (ABI_64_P (output_bfd)
4369 && h->plt.offset >= (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE))
910600e9 4370 {
d0c9aeb3
DM		 4371 if (ifunc)
4372 {
4373 rela.r_addend = (h->root.u.def.section->output_section->vma
4374 + h->root.u.def.section->output_offset
4375 + h->root.u.def.value);
4376 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0,
4377 R_SPARC_IRELATIVE);
4378 }
4379 else
4380 {
4381 rela.r_addend = (-(h->plt.offset + 4)
4382 - splt->output_section->vma
4383 - splt->output_offset);
4384 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx,
4385 R_SPARC_JMP_SLOT);
4386 }
910600e9
RS		 4387 }
4388 else
4389 {
d0c9aeb3
DM		 4390 if (ifunc)
4391 {
4392 rela.r_addend = (h->root.u.def.section->output_section->vma
4393 + h->root.u.def.section->output_offset
4394 + h->root.u.def.value);
4395 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0,
4396 R_SPARC_JMP_IREL);
4397 }
4398 else
4399 {
4400 rela.r_addend = 0;
4401 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx,
4402 R_SPARC_JMP_SLOT);
4403 }
910600e9 4404 }
22b75d0a 4405 }
22b75d0a
DM		 4406
4407 /* Adjust for the first 4 reserved elements in the .plt section
4408 when setting the offset in the .rela.plt section.
4409 Sun forgot to read their own ABI and copied elf32-sparc behaviour,
4410 thus .plt[4] has corresponding .rela.plt[0] and so on. */
4411
4412 loc = srela->contents;
39817122
RS		 4413 loc += rela_index * bed->s->sizeof_rela;
4414 bed->s->swap_reloca_out (output_bfd, &rela, loc);
22b75d0a
DM		 4415
4416 if (!h->def_regular)
4417 {
4418 /* Mark the symbol as undefined, rather than as defined in
4419 the .plt section. Leave the value alone. */
4420 sym->st_shndx = SHN_UNDEF;
4421 /* If the symbol is weak, we do need to clear the value.
4422 Otherwise, the PLT entry would provide a definition for
4423 the symbol even if the symbol wasn't defined anywhere,
4424 and so the symbol would never be NULL. */
4425 if (!h->ref_regular_nonweak)
4426 sym->st_value = 0;
4427 }
4428 }
4429
4430 if (h->got.offset != (bfd_vma) -1
4431 && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_GD
4432 && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_IE)
4433 {
4434 asection *sgot;
4435 asection *srela;
4436 Elf_Internal_Rela rela;
4437
4438 /* This symbol has an entry in the GOT. Set it up. */
4439
72fbc6e5
DM		 4440 sgot = htab->elf.sgot;
4441 srela = htab->elf.srelgot;
22b75d0a
DM		 4442 BFD_ASSERT (sgot != NULL && srela != NULL);
4443
4444 rela.r_offset = (sgot->output_section->vma
4445 + sgot->output_offset
4446 + (h->got.offset &~ (bfd_vma) 1));
4447
4448 /* If this is a -Bsymbolic link, and the symbol is defined
4449 locally, we just want to emit a RELATIVE reloc. Likewise if
4450 the symbol was forced to be local because of a version file.
4451 The entry in the global offset table will already have been
4452 initialized in the relocate_section function. */
d0c9aeb3
DM		 4453 if (! info->shared
4454 && h->type == STT_GNU_IFUNC
4455 && h->def_regular)
4456 {
4457 asection *plt;
4458
4459 /* We load the GOT entry with the PLT entry. */
4460 plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
4461 SPARC_ELF_PUT_WORD (htab, output_bfd,
4462 (plt->output_section->vma
4463 + plt->output_offset + h->plt.offset),
4464 htab->elf.sgot->contents
4465 + (h->got.offset & ~(bfd_vma) 1));
4466 return TRUE;
4467 }
4468 else if (info->shared
4469 && SYMBOL_REFERENCES_LOCAL (info, h))
22b75d0a
DM		 4470 {
4471 asection *sec = h->root.u.def.section;
d0c9aeb3
DM		 4472 if (h->type == STT_GNU_IFUNC)
4473 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, R_SPARC_IRELATIVE);
4474 else
4475 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, R_SPARC_RELATIVE);
22b75d0a
DM		 4476 rela.r_addend = (h->root.u.def.value
4477 + sec->output_section->vma
4478 + sec->output_offset);
4479 }
4480 else
4481 {
4482 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_GLOB_DAT);
4483 rela.r_addend = 0;
4484 }
4485
4486 SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
4487 sgot->contents + (h->got.offset & ~(bfd_vma) 1));
39817122 4488 sparc_elf_append_rela (output_bfd, srela, &rela);
22b75d0a
DM		 4489 }
4490
4491 if (h->needs_copy)
4492 {
4493 asection *s;
4494 Elf_Internal_Rela rela;
4495
4496 /* This symbols needs a copy reloc. Set it up. */
4497 BFD_ASSERT (h->dynindx != -1);
4498
4499 s = bfd_get_section_by_name (h->root.u.def.section->owner,
4500 ".rela.bss");
4501 BFD_ASSERT (s != NULL);
4502
4503 rela.r_offset = (h->root.u.def.value
4504 + h->root.u.def.section->output_section->vma
4505 + h->root.u.def.section->output_offset);
4506 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_COPY);
4507 rela.r_addend = 0;
39817122 4508 sparc_elf_append_rela (output_bfd, s, &rela);
22b75d0a
DM		 4509 }
4510
910600e9
RS		 4511 /* Mark some specially defined symbols as absolute. On VxWorks,
4512 _GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the
4513 ".got" section. Likewise _PROCEDURE_LINKAGE_TABLE_ and ".plt". */
d0c9aeb3
DM		 4514 if (sym != NULL
4515 && (strcmp (h->root.root.string, "_DYNAMIC") == 0
4516 || (!htab->is_vxworks
4517 && (h == htab->elf.hgot || h == htab->elf.hplt))))
22b75d0a
DM		 4518 sym->st_shndx = SHN_ABS;
4519
4520 return TRUE;
4521}
4522
4523/* Finish up the dynamic sections. */
4524
22b75d0a 4525static bfd_boolean
39817122
RS		 4526sparc_finish_dyn (bfd *output_bfd, struct bfd_link_info *info,
4527 bfd *dynobj, asection *sdyn,
4528 asection *splt ATTRIBUTE_UNUSED)
22b75d0a 4529{
910600e9 4530 struct _bfd_sparc_elf_link_hash_table *htab;
39817122
RS		 4531 const struct elf_backend_data *bed;
4532 bfd_byte *dyncon, *dynconend;
4533 size_t dynsize;
4534 int stt_regidx = -1;
4535 bfd_boolean abi_64_p;
22b75d0a 4536
910600e9 4537 htab = _bfd_sparc_elf_hash_table (info);
4dfe6ac6 4538 BFD_ASSERT (htab != NULL);
39817122
RS		 4539 bed = get_elf_backend_data (output_bfd);
4540 dynsize = bed->s->sizeof_dyn;
4541 dynconend = sdyn->contents + sdyn->size;
4542 abi_64_p = ABI_64_P (output_bfd);
4543 for (dyncon = sdyn->contents; dyncon < dynconend; dyncon += dynsize)
22b75d0a
DM		 4544 {
4545 Elf_Internal_Dyn dyn;
4546 const char *name;
4547 bfd_boolean size;
4548
39817122 4549 bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
22b75d0a 4550
910600e9 4551 if (htab->is_vxworks && dyn.d_tag == DT_RELASZ)
22b75d0a 4552 {
910600e9
RS		 4553 /* On VxWorks, DT_RELASZ should not include the relocations
4554 in .rela.plt. */
72fbc6e5 4555 if (htab->elf.srelplt)
910600e9 4556 {
72fbc6e5 4557 dyn.d_un.d_val -= htab->elf.srelplt->size;
39817122 4558 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
910600e9 4559 }
22b75d0a 4560 }
910600e9 4561 else if (htab->is_vxworks && dyn.d_tag == DT_PLTGOT)
22b75d0a 4562 {
910600e9
RS		 4563 /* On VxWorks, DT_PLTGOT should point to the start of the GOT,
4564 not to the start of the PLT. */
72fbc6e5 4565 if (htab->elf.sgotplt)
910600e9 4566 {
72fbc6e5
DM		 4567 dyn.d_un.d_val = (htab->elf.sgotplt->output_section->vma
4568 + htab->elf.sgotplt->output_offset);
39817122 4569 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
910600e9
RS		 4570 }
4571 }
7a2b07ff
NS		 4572 else if (htab->is_vxworks
4573 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
4574 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
39817122
RS		 4575 else if (abi_64_p && dyn.d_tag == DT_SPARC_REGISTER)
4576 {
4577 if (stt_regidx == -1)
4578 {
4579 stt_regidx =
4580 _bfd_elf_link_lookup_local_dynindx (info, output_bfd, -1);
4581 if (stt_regidx == -1)
4582 return FALSE;
4583 }
4584 dyn.d_un.d_val = stt_regidx++;
4585 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4586 }
910600e9
RS		 4587 else
4588 {
4589 switch (dyn.d_tag)
4590 {
4591 case DT_PLTGOT: name = ".plt"; size = FALSE; break;
4592 case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break;
4593 case DT_JMPREL: name = ".rela.plt"; size = FALSE; break;
39817122 4594 default: name = NULL; size = FALSE; break;
910600e9 4595 }
22b75d0a 4596
910600e9 4597 if (name != NULL)
22b75d0a 4598 {
910600e9
RS		 4599 asection *s;
4600
4601 s = bfd_get_section_by_name (output_bfd, name);
4602 if (s == NULL)
4603 dyn.d_un.d_val = 0;
22b75d0a 4604 else
910600e9
RS		 4605 {
4606 if (! size)
4607 dyn.d_un.d_ptr = s->vma;
4608 else
4609 dyn.d_un.d_val = s->size;
4610 }
39817122 4611 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
22b75d0a 4612 }
22b75d0a
DM		 4613 }
4614 }
4615 return TRUE;
4616}
4617
910600e9
RS		 4618/* Install the first PLT entry in a VxWorks executable and make sure that
4619 .rela.plt.unloaded relocations have the correct symbol indexes. */
4620
4621static void
4622sparc_vxworks_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info)
4623{
4624 struct _bfd_sparc_elf_link_hash_table *htab;
4625 Elf_Internal_Rela rela;
4626 bfd_vma got_base;
4627 bfd_byte *loc;
4628
4629 htab = _bfd_sparc_elf_hash_table (info);
4dfe6ac6 4630 BFD_ASSERT (htab != NULL);
910600e9
RS		 4631
4632 /* Calculate the absolute value of _GLOBAL_OFFSET_TABLE_. */
4633 got_base = (htab->elf.hgot->root.u.def.section->output_section->vma
4634 + htab->elf.hgot->root.u.def.section->output_offset
4635 + htab->elf.hgot->root.u.def.value);
4636
4637 /* Install the initial PLT entry. */
4638 bfd_put_32 (output_bfd,
4639 sparc_vxworks_exec_plt0_entry[0] + ((got_base + 8) >> 10),
72fbc6e5 4640 htab->elf.splt->contents);
910600e9
RS		 4641 bfd_put_32 (output_bfd,
4642 sparc_vxworks_exec_plt0_entry[1] + ((got_base + 8) & 0x3ff),
72fbc6e5 4643 htab->elf.splt->contents + 4);
910600e9
RS		 4644 bfd_put_32 (output_bfd,
4645 sparc_vxworks_exec_plt0_entry[2],
72fbc6e5 4646 htab->elf.splt->contents + 8);
910600e9
RS		 4647 bfd_put_32 (output_bfd,
4648 sparc_vxworks_exec_plt0_entry[3],
72fbc6e5 4649 htab->elf.splt->contents + 12);
910600e9
RS		 4650 bfd_put_32 (output_bfd,
4651 sparc_vxworks_exec_plt0_entry[4],
72fbc6e5 4652 htab->elf.splt->contents + 16);
910600e9
RS		 4653
4654 loc = htab->srelplt2->contents;
4655
4656 /* Add an unloaded relocation for the initial entry's "sethi". */
72fbc6e5
DM		 4657 rela.r_offset = (htab->elf.splt->output_section->vma
4658 + htab->elf.splt->output_offset);
910600e9
RS		 4659 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4660 rela.r_addend = 8;
4661 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4662 loc += sizeof (Elf32_External_Rela);
4663
4664 /* Likewise the following "or". */
4665 rela.r_offset += 4;
4666 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4667 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4668 loc += sizeof (Elf32_External_Rela);
4669
4670 /* Fix up the remaining .rela.plt.unloaded relocations. They may have
4671 the wrong symbol index for _G_O_T_ or _P_L_T_ depending on the order
4672 in which symbols were output. */
4673 while (loc < htab->srelplt2->contents + htab->srelplt2->size)
4674 {
4675 Elf_Internal_Rela rel;
4676
4677 /* The entry's initial "sethi" (against _G_O_T_). */
4678 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4679 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4680 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4681 loc += sizeof (Elf32_External_Rela);
4682
4683 /* The following "or" (also against _G_O_T_). */
4684 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4685 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4686 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4687 loc += sizeof (Elf32_External_Rela);
4688
4689 /* The .got.plt entry (against _P_L_T_). */
4690 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4691 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_SPARC_32);
4692 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4693 loc += sizeof (Elf32_External_Rela);
4694 }
4695}
4696
4697/* Install the first PLT entry in a VxWorks shared object. */
4698
4699static void
4700sparc_vxworks_finish_shared_plt (bfd *output_bfd, struct bfd_link_info *info)
4701{
4702 struct _bfd_sparc_elf_link_hash_table *htab;
4703 unsigned int i;
4704
4705 htab = _bfd_sparc_elf_hash_table (info);
4dfe6ac6
NC		 4706 BFD_ASSERT (htab != NULL);
4707
910600e9
RS		 4708 for (i = 0; i < ARRAY_SIZE (sparc_vxworks_shared_plt0_entry); i++)
4709 bfd_put_32 (output_bfd, sparc_vxworks_shared_plt0_entry[i],
72fbc6e5 4710 htab->elf.splt->contents + i * 4);
910600e9
RS		 4711}
4712
d0c9aeb3
DM		 4713/* Finish up local dynamic symbol handling. We set the contents of
4714 various dynamic sections here. */
4715
4716static bfd_boolean
4717finish_local_dynamic_symbol (void **slot, void *inf)
4718{
4719 struct elf_link_hash_entry *h
4720 = (struct elf_link_hash_entry *) *slot;
4721 struct bfd_link_info *info
4722 = (struct bfd_link_info *) inf;
4723
4724 return _bfd_sparc_elf_finish_dynamic_symbol (info->output_bfd, info,
4725 h, NULL);
4726}
4727
22b75d0a
DM		 4728bfd_boolean
4729_bfd_sparc_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
4730{
4731 bfd *dynobj;
4732 asection *sdyn;
4733 struct _bfd_sparc_elf_link_hash_table *htab;
4734
4735 htab = _bfd_sparc_elf_hash_table (info);
4dfe6ac6 4736 BFD_ASSERT (htab != NULL);
22b75d0a
DM		 4737 dynobj = htab->elf.dynobj;
4738
4739 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4740
4741 if (elf_hash_table (info)->dynamic_sections_created)
4742 {
4743 asection *splt;
22b75d0a
DM		 4744
4745 splt = bfd_get_section_by_name (dynobj, ".plt");
4746 BFD_ASSERT (splt != NULL && sdyn != NULL);
4747
39817122
RS		 4748 if (!sparc_finish_dyn (output_bfd, info, dynobj, sdyn, splt))
4749 return FALSE;
22b75d0a
DM		 4750
4751 /* Initialize the contents of the .plt section. */
4752 if (splt->size > 0)
4753 {
910600e9
RS		 4754 if (htab->is_vxworks)
4755 {
4756 if (info->shared)
4757 sparc_vxworks_finish_shared_plt (output_bfd, info);
4758 else
4759 sparc_vxworks_finish_exec_plt (output_bfd, info);
4760 }
22b75d0a
DM		 4761 else
4762 {
910600e9
RS		 4763 memset (splt->contents, 0, htab->plt_header_size);
4764 if (!ABI_64_P (output_bfd))
4765 bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP,
4766 splt->contents + splt->size - 4);
22b75d0a
DM		 4767 }
4768 }
4769
910600e9 4770 elf_section_data (splt->output_section)->this_hdr.sh_entsize
7eeb1be6
JJ		 4771 = (htab->is_vxworks || !ABI_64_P (output_bfd))
4772 ? 0 : htab->plt_entry_size;
22b75d0a
DM		 4773 }
4774
4775 /* Set the first entry in the global offset table to the address of
4776 the dynamic section. */
72fbc6e5 4777 if (htab->elf.sgot && htab->elf.sgot->size > 0)
22b75d0a
DM		 4778 {
4779 bfd_vma val = (sdyn ?
4780 sdyn->output_section->vma + sdyn->output_offset :
4781 0);
4782
72fbc6e5 4783 SPARC_ELF_PUT_WORD (htab, output_bfd, val, htab->elf.sgot->contents);
22b75d0a
DM		 4784 }
4785
72fbc6e5
DM		 4786 if (htab->elf.sgot)
4787 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize =
22b75d0a
DM		 4788 SPARC_ELF_WORD_BYTES (htab);
4789
d0c9aeb3
DM		 4790 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
4791 htab_traverse (htab->loc_hash_table, finish_local_dynamic_symbol, info);
4792
22b75d0a
DM		 4793 return TRUE;
4794}
4795
4796\f
4797/* Set the right machine number for a SPARC ELF file. */
4798
4799bfd_boolean
4800_bfd_sparc_elf_object_p (bfd *abfd)
4801{
4802 if (ABI_64_P (abfd))
4803 {
4804 unsigned long mach = bfd_mach_sparc_v9;
4805
4806 if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
4807 mach = bfd_mach_sparc_v9b;
4808 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
4809 mach = bfd_mach_sparc_v9a;
4810 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, mach);
4811 }
4812 else
4813 {
4814 if (elf_elfheader (abfd)->e_machine == EM_SPARC32PLUS)
4815 {
4816 if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
4817 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4818 bfd_mach_sparc_v8plusb);
4819 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
4820 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4821 bfd_mach_sparc_v8plusa);
4822 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_32PLUS)
4823 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4824 bfd_mach_sparc_v8plus);
4825 else
4826 return FALSE;
4827 }
4828 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_LEDATA)
4829 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4830 bfd_mach_sparc_sparclite_le);
4831 else
4832 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc);
4833 }
4834}
4835
4836/* Return address for Ith PLT stub in section PLT, for relocation REL
4837 or (bfd_vma) -1 if it should not be included. */
4838
4839bfd_vma
4840_bfd_sparc_elf_plt_sym_val (bfd_vma i, const asection *plt, const arelent *rel)
4841{
4842 if (ABI_64_P (plt->owner))
4843 {
4844 bfd_vma j;
4845
4846 i += PLT64_HEADER_SIZE / PLT64_ENTRY_SIZE;
4847 if (i < PLT64_LARGE_THRESHOLD)
4848 return plt->vma + i * PLT64_ENTRY_SIZE;
4849
4850 j = (i - PLT64_LARGE_THRESHOLD) % 160;
4851 i -= j;
4852 return plt->vma + i * PLT64_ENTRY_SIZE + j * 4 * 6;
4853 }
4854 else
4855 return rel->address;
4856}
9e8c70f9
DM		 4857
4858/* Merge backend specific data from an object file to the output
4859 object file when linking. */
4860
4861bfd_boolean
4862_bfd_sparc_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
4863{
4864 obj_attribute *in_attr, *in_attrs;
4865 obj_attribute *out_attr, *out_attrs;
4866
4867 if (!elf_known_obj_attributes_proc (obfd)[0].i)
4868 {
4869 /* This is the first object. Copy the attributes. */
4870 _bfd_elf_copy_obj_attributes (ibfd, obfd);
4871
4872 /* Use the Tag_null value to indicate the attributes have been
4873 initialized. */
4874 elf_known_obj_attributes_proc (obfd)[0].i = 1;
4875
4876 return TRUE;
4877 }
4878
4879 in_attrs = elf_known_obj_attributes (ibfd)[OBJ_ATTR_GNU];
4880 out_attrs = elf_known_obj_attributes (obfd)[OBJ_ATTR_GNU];
4881
4882 in_attr = &in_attrs[Tag_GNU_Sparc_HWCAPS];
4883 out_attr = &out_attrs[Tag_GNU_Sparc_HWCAPS];
4884
4885 out_attr->i |= in_attr->i;
4886
4887 /* Merge Tag_compatibility attributes and any common GNU ones. */
4888 _bfd_elf_merge_object_attributes (ibfd, obfd);
4889
4890 return TRUE;
4891}
GDB Binutils - Deliverables
This page took 0.947478 seconds and 4 git commands to generate.