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