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