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