1
/* SPARC-specific support for ELF
2
Copyright 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
3
Free Software Foundation, Inc.
5
This file is part of BFD, the Binary File Descriptor library.
7
This program is free software; you can redistribute it and/or modify
8
it under the terms of the GNU General Public License as published by
9
the Free Software Foundation; either version 3 of the License, or
10
(at your option) any later version.
12
This program is distributed in the hope that it will be useful,
13
but WITHOUT ANY WARRANTY; without even the implied warranty of
14
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15
GNU General Public License for more details.
17
You should have received a copy of the GNU General Public License
18
along with this program; if not, write to the Free Software
19
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20
MA 02110-1301, USA. */
23
/* This file handles functionality common to the different SPARC ABI's. */
29
#include "libiberty.h"
31
#include "elf/sparc.h"
32
#include "opcode/sparc.h"
33
#include "elfxx-sparc.h"
34
#include "elf-vxworks.h"
38
/* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
39
#define MINUS_ONE (~ (bfd_vma) 0)
41
#define ABI_64_P(abfd) \
42
(get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
44
/* The relocation "howto" table. */
46
/* Utility for performing the standard initial work of an instruction
48
*PRELOCATION will contain the relocated item.
49
*PINSN will contain the instruction from the input stream.
50
If the result is `bfd_reloc_other' the caller can continue with
51
performing the relocation. Otherwise it must stop and return the
52
value to its caller. */
54
static bfd_reloc_status_type
55
init_insn_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
56
void * data, asection *input_section, bfd *output_bfd,
57
bfd_vma *prelocation, bfd_vma *pinsn)
60
reloc_howto_type *howto = reloc_entry->howto;
62
if (output_bfd != (bfd *) NULL
63
&& (symbol->flags & BSF_SECTION_SYM) == 0
64
&& (! howto->partial_inplace
65
|| reloc_entry->addend == 0))
67
reloc_entry->address += input_section->output_offset;
71
/* This works because partial_inplace is FALSE. */
72
if (output_bfd != NULL)
73
return bfd_reloc_continue;
75
if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
76
return bfd_reloc_outofrange;
78
relocation = (symbol->value
79
+ symbol->section->output_section->vma
80
+ symbol->section->output_offset);
81
relocation += reloc_entry->addend;
82
if (howto->pc_relative)
84
relocation -= (input_section->output_section->vma
85
+ input_section->output_offset);
86
relocation -= reloc_entry->address;
89
*prelocation = relocation;
90
*pinsn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
91
return bfd_reloc_other;
94
/* For unsupported relocs. */
96
static bfd_reloc_status_type
97
sparc_elf_notsup_reloc (bfd *abfd ATTRIBUTE_UNUSED,
98
arelent *reloc_entry ATTRIBUTE_UNUSED,
99
asymbol *symbol ATTRIBUTE_UNUSED,
100
void * data ATTRIBUTE_UNUSED,
101
asection *input_section ATTRIBUTE_UNUSED,
102
bfd *output_bfd ATTRIBUTE_UNUSED,
103
char **error_message ATTRIBUTE_UNUSED)
105
return bfd_reloc_notsupported;
108
/* Handle the WDISP16 reloc. */
110
static bfd_reloc_status_type
111
sparc_elf_wdisp16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
112
void * data, asection *input_section, bfd *output_bfd,
113
char **error_message ATTRIBUTE_UNUSED)
117
bfd_reloc_status_type status;
119
status = init_insn_reloc (abfd, reloc_entry, symbol, data,
120
input_section, output_bfd, &relocation, &insn);
121
if (status != bfd_reloc_other)
124
insn &= ~ (bfd_vma) 0x303fff;
125
insn |= (((relocation >> 2) & 0xc000) << 6) | ((relocation >> 2) & 0x3fff);
126
bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
128
if ((bfd_signed_vma) relocation < - 0x40000
129
|| (bfd_signed_vma) relocation > 0x3ffff)
130
return bfd_reloc_overflow;
135
/* Handle the WDISP10 reloc. */
137
static bfd_reloc_status_type
138
sparc_elf_wdisp10_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
139
void * data, asection *input_section, bfd *output_bfd,
140
char **error_message ATTRIBUTE_UNUSED)
144
bfd_reloc_status_type status;
146
status = init_insn_reloc (abfd, reloc_entry, symbol, data,
147
input_section, output_bfd, &relocation, &insn);
148
if (status != bfd_reloc_other)
151
insn &= ~ (bfd_vma) 0x181fe0;
152
insn |= (((relocation >> 2) & 0x300) << 11)
153
| (((relocation >> 2) & 0xff) << 5);
154
bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
156
if ((bfd_signed_vma) relocation < - 0x1000
157
|| (bfd_signed_vma) relocation > 0xfff)
158
return bfd_reloc_overflow;
163
/* Handle the HIX22 reloc. */
165
static bfd_reloc_status_type
166
sparc_elf_hix22_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
167
void * data, asection *input_section, bfd *output_bfd,
168
char **error_message ATTRIBUTE_UNUSED)
172
bfd_reloc_status_type status;
174
status = init_insn_reloc (abfd, reloc_entry, symbol, data,
175
input_section, output_bfd, &relocation, &insn);
176
if (status != bfd_reloc_other)
179
relocation ^= MINUS_ONE;
180
insn = (insn &~ (bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
181
bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
183
if ((relocation & ~ (bfd_vma) 0xffffffff) != 0)
184
return bfd_reloc_overflow;
189
/* Handle the LOX10 reloc. */
191
static bfd_reloc_status_type
192
sparc_elf_lox10_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
193
void * data, asection *input_section, bfd *output_bfd,
194
char **error_message ATTRIBUTE_UNUSED)
198
bfd_reloc_status_type status;
200
status = init_insn_reloc (abfd, reloc_entry, symbol, data,
201
input_section, output_bfd, &relocation, &insn);
202
if (status != bfd_reloc_other)
205
insn = (insn &~ (bfd_vma) 0x1fff) | 0x1c00 | (relocation & 0x3ff);
206
bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
211
static reloc_howto_type _bfd_sparc_elf_howto_table[] =
213
HOWTO(R_SPARC_NONE, 0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", FALSE,0,0x00000000,TRUE),
214
HOWTO(R_SPARC_8, 0,0, 8,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_8", FALSE,0,0x000000ff,TRUE),
215
HOWTO(R_SPARC_16, 0,1,16,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_16", FALSE,0,0x0000ffff,TRUE),
216
HOWTO(R_SPARC_32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_32", FALSE,0,0xffffffff,TRUE),
217
HOWTO(R_SPARC_DISP8, 0,0, 8,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP8", FALSE,0,0x000000ff,TRUE),
218
HOWTO(R_SPARC_DISP16, 0,1,16,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP16", FALSE,0,0x0000ffff,TRUE),
219
HOWTO(R_SPARC_DISP32, 0,2,32,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP32", FALSE,0,0xffffffff,TRUE),
220
HOWTO(R_SPARC_WDISP30, 2,2,30,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP30", FALSE,0,0x3fffffff,TRUE),
221
HOWTO(R_SPARC_WDISP22, 2,2,22,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP22", FALSE,0,0x003fffff,TRUE),
222
HOWTO(R_SPARC_HI22, 10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_HI22", FALSE,0,0x003fffff,TRUE),
223
HOWTO(R_SPARC_22, 0,2,22,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_22", FALSE,0,0x003fffff,TRUE),
224
HOWTO(R_SPARC_13, 0,2,13,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_13", FALSE,0,0x00001fff,TRUE),
225
HOWTO(R_SPARC_LO10, 0,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_LO10", FALSE,0,0x000003ff,TRUE),
226
HOWTO(R_SPARC_GOT10, 0,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOT10", FALSE,0,0x000003ff,TRUE),
227
HOWTO(R_SPARC_GOT13, 0,2,13,FALSE,0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_GOT13", FALSE,0,0x00001fff,TRUE),
228
HOWTO(R_SPARC_GOT22, 10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOT22", FALSE,0,0x003fffff,TRUE),
229
HOWTO(R_SPARC_PC10, 0,2,10,TRUE, 0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_PC10", FALSE,0,0x000003ff,TRUE),
230
HOWTO(R_SPARC_PC22, 10,2,22,TRUE, 0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_PC22", FALSE,0,0x003fffff,TRUE),
231
HOWTO(R_SPARC_WPLT30, 2,2,30,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WPLT30", FALSE,0,0x3fffffff,TRUE),
232
HOWTO(R_SPARC_COPY, 0,0,00,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_COPY", FALSE,0,0x00000000,TRUE),
233
HOWTO(R_SPARC_GLOB_DAT, 0,0,00,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GLOB_DAT",FALSE,0,0x00000000,TRUE),
234
HOWTO(R_SPARC_JMP_SLOT, 0,0,00,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_JMP_SLOT",FALSE,0,0x00000000,TRUE),
235
HOWTO(R_SPARC_RELATIVE, 0,0,00,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_RELATIVE",FALSE,0,0x00000000,TRUE),
236
HOWTO(R_SPARC_UA32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA32", FALSE,0,0xffffffff,TRUE),
237
HOWTO(R_SPARC_PLT32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_PLT32", FALSE,0,0xffffffff,TRUE),
238
HOWTO(R_SPARC_HIPLT22, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_HIPLT22", FALSE,0,0x00000000,TRUE),
239
HOWTO(R_SPARC_LOPLT10, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_LOPLT10", FALSE,0,0x00000000,TRUE),
240
HOWTO(R_SPARC_PCPLT32, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PCPLT32", FALSE,0,0x00000000,TRUE),
241
HOWTO(R_SPARC_PCPLT22, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PCPLT22", FALSE,0,0x00000000,TRUE),
242
HOWTO(R_SPARC_PCPLT10, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PCPLT10", FALSE,0,0x00000000,TRUE),
243
HOWTO(R_SPARC_10, 0,2,10,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_10", FALSE,0,0x000003ff,TRUE),
244
HOWTO(R_SPARC_11, 0,2,11,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_11", FALSE,0,0x000007ff,TRUE),
245
HOWTO(R_SPARC_64, 0,4,64,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_64", FALSE,0,MINUS_ONE, TRUE),
246
HOWTO(R_SPARC_OLO10, 0,2,13,FALSE,0,complain_overflow_signed, sparc_elf_notsup_reloc, "R_SPARC_OLO10", FALSE,0,0x00001fff,TRUE),
247
HOWTO(R_SPARC_HH22, 42,2,22,FALSE,0,complain_overflow_unsigned,bfd_elf_generic_reloc, "R_SPARC_HH22", FALSE,0,0x003fffff,TRUE),
248
HOWTO(R_SPARC_HM10, 32,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_HM10", FALSE,0,0x000003ff,TRUE),
249
HOWTO(R_SPARC_LM22, 10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_LM22", FALSE,0,0x003fffff,TRUE),
250
HOWTO(R_SPARC_PC_HH22, 42,2,22,TRUE, 0,complain_overflow_unsigned,bfd_elf_generic_reloc, "R_SPARC_PC_HH22", FALSE,0,0x003fffff,TRUE),
251
HOWTO(R_SPARC_PC_HM10, 32,2,10,TRUE, 0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_PC_HM10", FALSE,0,0x000003ff,TRUE),
252
HOWTO(R_SPARC_PC_LM22, 10,2,22,TRUE, 0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_PC_LM22", FALSE,0,0x003fffff,TRUE),
253
HOWTO(R_SPARC_WDISP16, 2,2,16,TRUE, 0,complain_overflow_signed, sparc_elf_wdisp16_reloc,"R_SPARC_WDISP16", FALSE,0,0x00000000,TRUE),
254
HOWTO(R_SPARC_WDISP19, 2,2,19,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP19", FALSE,0,0x0007ffff,TRUE),
255
HOWTO(R_SPARC_UNUSED_42, 0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_UNUSED_42",FALSE,0,0x00000000,TRUE),
256
HOWTO(R_SPARC_7, 0,2, 7,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_7", FALSE,0,0x0000007f,TRUE),
257
HOWTO(R_SPARC_5, 0,2, 5,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_5", FALSE,0,0x0000001f,TRUE),
258
HOWTO(R_SPARC_6, 0,2, 6,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_6", FALSE,0,0x0000003f,TRUE),
259
HOWTO(R_SPARC_DISP64, 0,4,64,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP64", FALSE,0,MINUS_ONE, TRUE),
260
HOWTO(R_SPARC_PLT64, 0,4,64,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_PLT64", FALSE,0,MINUS_ONE, TRUE),
261
HOWTO(R_SPARC_HIX22, 0,4, 0,FALSE,0,complain_overflow_bitfield,sparc_elf_hix22_reloc, "R_SPARC_HIX22", FALSE,0,MINUS_ONE, FALSE),
262
HOWTO(R_SPARC_LOX10, 0,4, 0,FALSE,0,complain_overflow_dont, sparc_elf_lox10_reloc, "R_SPARC_LOX10", FALSE,0,MINUS_ONE, FALSE),
263
HOWTO(R_SPARC_H44, 22,2,22,FALSE,0,complain_overflow_unsigned,bfd_elf_generic_reloc, "R_SPARC_H44", FALSE,0,0x003fffff,FALSE),
264
HOWTO(R_SPARC_M44, 12,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_M44", FALSE,0,0x000003ff,FALSE),
265
HOWTO(R_SPARC_L44, 0,2,13,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_L44", FALSE,0,0x00000fff,FALSE),
266
HOWTO(R_SPARC_REGISTER, 0,4, 0,FALSE,0,complain_overflow_bitfield,sparc_elf_notsup_reloc, "R_SPARC_REGISTER",FALSE,0,MINUS_ONE, FALSE),
267
HOWTO(R_SPARC_UA64, 0,4,64,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA64", FALSE,0,MINUS_ONE, TRUE),
268
HOWTO(R_SPARC_UA16, 0,1,16,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA16", FALSE,0,0x0000ffff,TRUE),
269
HOWTO(R_SPARC_TLS_GD_HI22,10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_GD_HI22",FALSE,0,0x003fffff,TRUE),
270
HOWTO(R_SPARC_TLS_GD_LO10,0,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_GD_LO10",FALSE,0,0x000003ff,TRUE),
271
HOWTO(R_SPARC_TLS_GD_ADD,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_GD_ADD",FALSE,0,0x00000000,TRUE),
272
HOWTO(R_SPARC_TLS_GD_CALL,2,2,30,TRUE,0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_TLS_GD_CALL",FALSE,0,0x3fffffff,TRUE),
273
HOWTO(R_SPARC_TLS_LDM_HI22,10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_LDM_HI22",FALSE,0,0x003fffff,TRUE),
274
HOWTO(R_SPARC_TLS_LDM_LO10,0,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_LDM_LO10",FALSE,0,0x000003ff,TRUE),
275
HOWTO(R_SPARC_TLS_LDM_ADD,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_LDM_ADD",FALSE,0,0x00000000,TRUE),
276
HOWTO(R_SPARC_TLS_LDM_CALL,2,2,30,TRUE,0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_TLS_LDM_CALL",FALSE,0,0x3fffffff,TRUE),
277
HOWTO(R_SPARC_TLS_LDO_HIX22,0,2,0,FALSE,0,complain_overflow_bitfield,sparc_elf_hix22_reloc,"R_SPARC_TLS_LDO_HIX22",FALSE,0,0x003fffff, FALSE),
278
HOWTO(R_SPARC_TLS_LDO_LOX10,0,2,0,FALSE,0,complain_overflow_dont, sparc_elf_lox10_reloc, "R_SPARC_TLS_LDO_LOX10",FALSE,0,0x000003ff, FALSE),
279
HOWTO(R_SPARC_TLS_LDO_ADD,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_LDO_ADD",FALSE,0,0x00000000,TRUE),
280
HOWTO(R_SPARC_TLS_IE_HI22,10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_IE_HI22",FALSE,0,0x003fffff,TRUE),
281
HOWTO(R_SPARC_TLS_IE_LO10,0,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_IE_LO10",FALSE,0,0x000003ff,TRUE),
282
HOWTO(R_SPARC_TLS_IE_LD,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_IE_LD",FALSE,0,0x00000000,TRUE),
283
HOWTO(R_SPARC_TLS_IE_LDX,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_IE_LDX",FALSE,0,0x00000000,TRUE),
284
HOWTO(R_SPARC_TLS_IE_ADD,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_IE_ADD",FALSE,0,0x00000000,TRUE),
285
HOWTO(R_SPARC_TLS_LE_HIX22,0,2,0,FALSE,0,complain_overflow_bitfield,sparc_elf_hix22_reloc, "R_SPARC_TLS_LE_HIX22",FALSE,0,0x003fffff, FALSE),
286
HOWTO(R_SPARC_TLS_LE_LOX10,0,2,0,FALSE,0,complain_overflow_dont, sparc_elf_lox10_reloc, "R_SPARC_TLS_LE_LOX10",FALSE,0,0x000003ff, FALSE),
287
HOWTO(R_SPARC_TLS_DTPMOD32,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_DTPMOD32",FALSE,0,0x00000000,TRUE),
288
HOWTO(R_SPARC_TLS_DTPMOD64,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_DTPMOD64",FALSE,0,0x00000000,TRUE),
289
HOWTO(R_SPARC_TLS_DTPOFF32,0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,"R_SPARC_TLS_DTPOFF32",FALSE,0,0xffffffff,TRUE),
290
HOWTO(R_SPARC_TLS_DTPOFF64,0,4,64,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,"R_SPARC_TLS_DTPOFF64",FALSE,0,MINUS_ONE,TRUE),
291
HOWTO(R_SPARC_TLS_TPOFF32,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_TPOFF32",FALSE,0,0x00000000,TRUE),
292
HOWTO(R_SPARC_TLS_TPOFF64,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_TPOFF64",FALSE,0,0x00000000,TRUE),
293
HOWTO(R_SPARC_GOTDATA_HIX22,0,2,0,FALSE,0,complain_overflow_bitfield,sparc_elf_hix22_reloc,"R_SPARC_GOTDATA_HIX22",FALSE,0,0x003fffff, FALSE),
294
HOWTO(R_SPARC_GOTDATA_LOX10,0,2,0,FALSE,0,complain_overflow_dont, sparc_elf_lox10_reloc, "R_SPARC_GOTDATA_LOX10",FALSE,0,0x000003ff, FALSE),
295
HOWTO(R_SPARC_GOTDATA_OP_HIX22,0,2,0,FALSE,0,complain_overflow_bitfield,sparc_elf_hix22_reloc,"R_SPARC_GOTDATA_OP_HIX22",FALSE,0,0x003fffff, FALSE),
296
HOWTO(R_SPARC_GOTDATA_OP_LOX10,0,2,0,FALSE,0,complain_overflow_dont, sparc_elf_lox10_reloc, "R_SPARC_GOTDATA_OP_LOX10",FALSE,0,0x000003ff, FALSE),
297
HOWTO(R_SPARC_GOTDATA_OP,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOTDATA_OP",FALSE,0,0x00000000,TRUE),
298
HOWTO(R_SPARC_H34,12,2,22,FALSE,0,complain_overflow_unsigned,bfd_elf_generic_reloc,"R_SPARC_H34",FALSE,0,0x003fffff,FALSE),
299
HOWTO(R_SPARC_SIZE32,0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,"R_SPARC_SIZE32",FALSE,0,0xffffffff,TRUE),
300
HOWTO(R_SPARC_SIZE64,0,4,64,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,"R_SPARC_SIZE64",FALSE,0,MINUS_ONE, TRUE),
301
HOWTO(R_SPARC_WDISP10,2,2,10,TRUE, 0,complain_overflow_signed,sparc_elf_wdisp10_reloc,"R_SPARC_WDISP10",FALSE,0,0x00000000,TRUE),
303
static reloc_howto_type sparc_jmp_irel_howto =
304
HOWTO(R_SPARC_JMP_IREL, 0,0,00,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_JMP_IREL",FALSE,0,0x00000000,TRUE);
305
static reloc_howto_type sparc_irelative_howto =
306
HOWTO(R_SPARC_IRELATIVE, 0,0,00,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_IRELATIVE",FALSE,0,0x00000000,TRUE);
307
static reloc_howto_type sparc_vtinherit_howto =
308
HOWTO (R_SPARC_GNU_VTINHERIT, 0,2,0,FALSE,0,complain_overflow_dont, NULL, "R_SPARC_GNU_VTINHERIT", FALSE,0, 0, FALSE);
309
static reloc_howto_type sparc_vtentry_howto =
310
HOWTO (R_SPARC_GNU_VTENTRY, 0,2,0,FALSE,0,complain_overflow_dont, _bfd_elf_rel_vtable_reloc_fn,"R_SPARC_GNU_VTENTRY", FALSE,0,0, FALSE);
311
static reloc_howto_type sparc_rev32_howto =
312
HOWTO(R_SPARC_REV32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_REV32", FALSE,0,0xffffffff,TRUE);
315
_bfd_sparc_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
316
bfd_reloc_code_real_type code)
318
/* We explicitly handle each relocation type in the switch
319
instead of using a lookup table for efficiency. */
323
return &_bfd_sparc_elf_howto_table[R_SPARC_NONE];
326
return &_bfd_sparc_elf_howto_table[R_SPARC_8];
329
return &_bfd_sparc_elf_howto_table[R_SPARC_16];
332
return &_bfd_sparc_elf_howto_table[R_SPARC_32];
334
case BFD_RELOC_8_PCREL:
335
return &_bfd_sparc_elf_howto_table[R_SPARC_DISP8];
337
case BFD_RELOC_16_PCREL:
338
return &_bfd_sparc_elf_howto_table[R_SPARC_DISP16];
340
case BFD_RELOC_32_PCREL:
341
return &_bfd_sparc_elf_howto_table[R_SPARC_DISP32];
343
case BFD_RELOC_32_PCREL_S2:
344
return &_bfd_sparc_elf_howto_table[R_SPARC_WDISP30];
346
case BFD_RELOC_SPARC_WDISP22:
347
return &_bfd_sparc_elf_howto_table[R_SPARC_WDISP22];
350
return &_bfd_sparc_elf_howto_table[R_SPARC_HI22];
352
case BFD_RELOC_SPARC22:
353
return &_bfd_sparc_elf_howto_table[R_SPARC_22];
355
case BFD_RELOC_SPARC13:
356
return &_bfd_sparc_elf_howto_table[R_SPARC_13];
359
return &_bfd_sparc_elf_howto_table[R_SPARC_LO10];
361
case BFD_RELOC_SPARC_GOT10:
362
return &_bfd_sparc_elf_howto_table[R_SPARC_GOT10];
364
case BFD_RELOC_SPARC_GOT13:
365
return &_bfd_sparc_elf_howto_table[R_SPARC_GOT13];
367
case BFD_RELOC_SPARC_GOT22:
368
return &_bfd_sparc_elf_howto_table[R_SPARC_GOT22];
370
case BFD_RELOC_SPARC_PC10:
371
return &_bfd_sparc_elf_howto_table[R_SPARC_PC10];
373
case BFD_RELOC_SPARC_PC22:
374
return &_bfd_sparc_elf_howto_table[R_SPARC_PC22];
376
case BFD_RELOC_SPARC_WPLT30:
377
return &_bfd_sparc_elf_howto_table[R_SPARC_WPLT30];
379
case BFD_RELOC_SPARC_COPY:
380
return &_bfd_sparc_elf_howto_table[R_SPARC_COPY];
382
case BFD_RELOC_SPARC_GLOB_DAT:
383
return &_bfd_sparc_elf_howto_table[R_SPARC_GLOB_DAT];
385
case BFD_RELOC_SPARC_JMP_SLOT:
386
return &_bfd_sparc_elf_howto_table[R_SPARC_JMP_SLOT];
388
case BFD_RELOC_SPARC_RELATIVE:
389
return &_bfd_sparc_elf_howto_table[R_SPARC_RELATIVE];
391
case BFD_RELOC_SPARC_UA32:
392
return &_bfd_sparc_elf_howto_table[R_SPARC_UA32];
394
case BFD_RELOC_SPARC_PLT32:
395
return &_bfd_sparc_elf_howto_table[R_SPARC_PLT32];
397
case BFD_RELOC_SPARC_10:
398
return &_bfd_sparc_elf_howto_table[R_SPARC_10];
400
case BFD_RELOC_SPARC_11:
401
return &_bfd_sparc_elf_howto_table[R_SPARC_11];
403
case BFD_RELOC_SPARC_64:
404
return &_bfd_sparc_elf_howto_table[R_SPARC_64];
406
case BFD_RELOC_SPARC_OLO10:
407
return &_bfd_sparc_elf_howto_table[R_SPARC_OLO10];
409
case BFD_RELOC_SPARC_HH22:
410
return &_bfd_sparc_elf_howto_table[R_SPARC_HH22];
412
case BFD_RELOC_SPARC_HM10:
413
return &_bfd_sparc_elf_howto_table[R_SPARC_HM10];
415
case BFD_RELOC_SPARC_LM22:
416
return &_bfd_sparc_elf_howto_table[R_SPARC_LM22];
418
case BFD_RELOC_SPARC_PC_HH22:
419
return &_bfd_sparc_elf_howto_table[R_SPARC_PC_HH22];
421
case BFD_RELOC_SPARC_PC_HM10:
422
return &_bfd_sparc_elf_howto_table[R_SPARC_PC_HM10];
424
case BFD_RELOC_SPARC_PC_LM22:
425
return &_bfd_sparc_elf_howto_table[R_SPARC_PC_LM22];
427
case BFD_RELOC_SPARC_WDISP16:
428
return &_bfd_sparc_elf_howto_table[R_SPARC_WDISP16];
430
case BFD_RELOC_SPARC_WDISP19:
431
return &_bfd_sparc_elf_howto_table[R_SPARC_WDISP19];
433
case BFD_RELOC_SPARC_7:
434
return &_bfd_sparc_elf_howto_table[R_SPARC_7];
436
case BFD_RELOC_SPARC_5:
437
return &_bfd_sparc_elf_howto_table[R_SPARC_5];
439
case BFD_RELOC_SPARC_6:
440
return &_bfd_sparc_elf_howto_table[R_SPARC_6];
442
case BFD_RELOC_SPARC_DISP64:
443
return &_bfd_sparc_elf_howto_table[R_SPARC_DISP64];
445
case BFD_RELOC_SPARC_PLT64:
446
return &_bfd_sparc_elf_howto_table[R_SPARC_PLT64];
448
case BFD_RELOC_SPARC_HIX22:
449
return &_bfd_sparc_elf_howto_table[R_SPARC_HIX22];
451
case BFD_RELOC_SPARC_LOX10:
452
return &_bfd_sparc_elf_howto_table[R_SPARC_LOX10];
454
case BFD_RELOC_SPARC_H44:
455
return &_bfd_sparc_elf_howto_table[R_SPARC_H44];
457
case BFD_RELOC_SPARC_M44:
458
return &_bfd_sparc_elf_howto_table[R_SPARC_M44];
460
case BFD_RELOC_SPARC_L44:
461
return &_bfd_sparc_elf_howto_table[R_SPARC_L44];
463
case BFD_RELOC_SPARC_REGISTER:
464
return &_bfd_sparc_elf_howto_table[R_SPARC_REGISTER];
466
case BFD_RELOC_SPARC_UA64:
467
return &_bfd_sparc_elf_howto_table[R_SPARC_UA64];
469
case BFD_RELOC_SPARC_UA16:
470
return &_bfd_sparc_elf_howto_table[R_SPARC_UA16];
472
case BFD_RELOC_SPARC_TLS_GD_HI22:
473
return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_GD_HI22];
475
case BFD_RELOC_SPARC_TLS_GD_LO10:
476
return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_GD_LO10];
478
case BFD_RELOC_SPARC_TLS_GD_ADD:
479
return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_GD_ADD];
481
case BFD_RELOC_SPARC_TLS_GD_CALL:
482
return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_GD_CALL];
484
case BFD_RELOC_SPARC_TLS_LDM_HI22:
485
return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDM_HI22];
487
case BFD_RELOC_SPARC_TLS_LDM_LO10:
488
return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDM_LO10];
490
case BFD_RELOC_SPARC_TLS_LDM_ADD:
491
return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDM_ADD];
493
case BFD_RELOC_SPARC_TLS_LDM_CALL:
494
return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDM_CALL];
496
case BFD_RELOC_SPARC_TLS_LDO_HIX22:
497
return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDO_HIX22];
499
case BFD_RELOC_SPARC_TLS_LDO_LOX10:
500
return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDO_LOX10];
502
case BFD_RELOC_SPARC_TLS_LDO_ADD:
503
return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDO_ADD];
505
case BFD_RELOC_SPARC_TLS_IE_HI22:
506
return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_IE_HI22];
508
case BFD_RELOC_SPARC_TLS_IE_LO10:
509
return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_IE_LO10];
511
case BFD_RELOC_SPARC_TLS_IE_LD:
512
return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_IE_LD];
514
case BFD_RELOC_SPARC_TLS_IE_LDX:
515
return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_IE_LDX];
517
case BFD_RELOC_SPARC_TLS_IE_ADD:
518
return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_IE_ADD];
520
case BFD_RELOC_SPARC_TLS_LE_HIX22:
521
return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LE_HIX22];
523
case BFD_RELOC_SPARC_TLS_LE_LOX10:
524
return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LE_LOX10];
526
case BFD_RELOC_SPARC_TLS_DTPMOD32:
527
return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_DTPMOD32];
529
case BFD_RELOC_SPARC_TLS_DTPMOD64:
530
return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_DTPMOD64];
532
case BFD_RELOC_SPARC_TLS_DTPOFF32:
533
return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_DTPOFF32];
535
case BFD_RELOC_SPARC_TLS_DTPOFF64:
536
return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_DTPOFF64];
538
case BFD_RELOC_SPARC_TLS_TPOFF32:
539
return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_TPOFF32];
541
case BFD_RELOC_SPARC_TLS_TPOFF64:
542
return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_TPOFF64];
544
case BFD_RELOC_SPARC_GOTDATA_HIX22:
545
return &_bfd_sparc_elf_howto_table[R_SPARC_GOTDATA_HIX22];
547
case BFD_RELOC_SPARC_GOTDATA_LOX10:
548
return &_bfd_sparc_elf_howto_table[R_SPARC_GOTDATA_LOX10];
550
case BFD_RELOC_SPARC_GOTDATA_OP_HIX22:
551
return &_bfd_sparc_elf_howto_table[R_SPARC_GOTDATA_OP_HIX22];
553
case BFD_RELOC_SPARC_GOTDATA_OP_LOX10:
554
return &_bfd_sparc_elf_howto_table[R_SPARC_GOTDATA_OP_LOX10];
556
case BFD_RELOC_SPARC_GOTDATA_OP:
557
return &_bfd_sparc_elf_howto_table[R_SPARC_GOTDATA_OP];
559
case BFD_RELOC_SPARC_H34:
560
return &_bfd_sparc_elf_howto_table[R_SPARC_H34];
562
case BFD_RELOC_SPARC_SIZE32:
563
return &_bfd_sparc_elf_howto_table[R_SPARC_SIZE32];
565
case BFD_RELOC_SPARC_SIZE64:
566
return &_bfd_sparc_elf_howto_table[R_SPARC_SIZE64];
568
case BFD_RELOC_SPARC_WDISP10:
569
return &_bfd_sparc_elf_howto_table[R_SPARC_WDISP10];
571
case BFD_RELOC_SPARC_JMP_IREL:
572
return &sparc_jmp_irel_howto;
574
case BFD_RELOC_SPARC_IRELATIVE:
575
return &sparc_irelative_howto;
577
case BFD_RELOC_VTABLE_INHERIT:
578
return &sparc_vtinherit_howto;
580
case BFD_RELOC_VTABLE_ENTRY:
581
return &sparc_vtentry_howto;
583
case BFD_RELOC_SPARC_REV32:
584
return &sparc_rev32_howto;
589
bfd_set_error (bfd_error_bad_value);
594
_bfd_sparc_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
600
i < (sizeof (_bfd_sparc_elf_howto_table)
601
/ sizeof (_bfd_sparc_elf_howto_table[0]));
603
if (_bfd_sparc_elf_howto_table[i].name != NULL
604
&& strcasecmp (_bfd_sparc_elf_howto_table[i].name, r_name) == 0)
605
return &_bfd_sparc_elf_howto_table[i];
607
if (strcasecmp (sparc_vtinherit_howto.name, r_name) == 0)
608
return &sparc_vtinherit_howto;
609
if (strcasecmp (sparc_vtentry_howto.name, r_name) == 0)
610
return &sparc_vtentry_howto;
611
if (strcasecmp (sparc_rev32_howto.name, r_name) == 0)
612
return &sparc_rev32_howto;
618
_bfd_sparc_elf_info_to_howto_ptr (unsigned int r_type)
622
case R_SPARC_JMP_IREL:
623
return &sparc_jmp_irel_howto;
625
case R_SPARC_IRELATIVE:
626
return &sparc_irelative_howto;
628
case R_SPARC_GNU_VTINHERIT:
629
return &sparc_vtinherit_howto;
631
case R_SPARC_GNU_VTENTRY:
632
return &sparc_vtentry_howto;
635
return &sparc_rev32_howto;
638
if (r_type >= (unsigned int) R_SPARC_max_std)
640
(*_bfd_error_handler) (_("invalid relocation type %d"),
642
r_type = R_SPARC_NONE;
644
return &_bfd_sparc_elf_howto_table[r_type];
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) \
654
_bfd_sparc_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
655
Elf_Internal_Rela *dst)
657
unsigned int r_type = SPARC_ELF_R_TYPE (dst->r_info);
659
cache_ptr->howto = _bfd_sparc_elf_info_to_howto_ptr (r_type);
663
/* The nop opcode we use. */
664
#define SPARC_NOP 0x01000000
666
#define SPARC_INSN_BYTES 4
668
/* The SPARC linker needs to keep track of the number of relocs that it
669
decides to copy as dynamic relocs in check_relocs for each symbol.
670
This is so that it can later discard them if they are found to be
671
unnecessary. We store the information in a field extending the
672
regular ELF linker hash table. */
674
struct _bfd_sparc_elf_dyn_relocs
676
struct _bfd_sparc_elf_dyn_relocs *next;
678
/* The input section of the reloc. */
681
/* Total number of relocs copied for the input section. */
684
/* Number of pc-relative relocs copied for the input section. */
685
bfd_size_type pc_count;
688
/* SPARC ELF linker hash entry. */
690
struct _bfd_sparc_elf_link_hash_entry
692
struct elf_link_hash_entry elf;
694
/* Track dynamic relocs copied for this symbol. */
695
struct _bfd_sparc_elf_dyn_relocs *dyn_relocs;
697
#define GOT_UNKNOWN 0
701
unsigned char tls_type;
704
#define _bfd_sparc_elf_hash_entry(ent) ((struct _bfd_sparc_elf_link_hash_entry *)(ent))
706
struct _bfd_sparc_elf_obj_tdata
708
struct elf_obj_tdata root;
710
/* tls_type for each local got entry. */
711
char *local_got_tls_type;
713
/* TRUE if TLS GD relocs has been seen for this object. */
714
bfd_boolean has_tlsgd;
717
#define _bfd_sparc_elf_tdata(abfd) \
718
((struct _bfd_sparc_elf_obj_tdata *) (abfd)->tdata.any)
720
#define _bfd_sparc_elf_local_got_tls_type(abfd) \
721
(_bfd_sparc_elf_tdata (abfd)->local_got_tls_type)
723
#define is_sparc_elf(bfd) \
724
(bfd_get_flavour (bfd) == bfd_target_elf_flavour \
725
&& elf_tdata (bfd) != NULL \
726
&& elf_object_id (bfd) == SPARC_ELF_DATA)
729
_bfd_sparc_elf_mkobject (bfd *abfd)
731
return bfd_elf_allocate_object (abfd, sizeof (struct _bfd_sparc_elf_obj_tdata),
736
sparc_put_word_32 (bfd *abfd, bfd_vma val, void *ptr)
738
bfd_put_32 (abfd, val, ptr);
742
sparc_put_word_64 (bfd *abfd, bfd_vma val, void *ptr)
744
bfd_put_64 (abfd, val, ptr);
748
sparc_elf_append_rela (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
750
const struct elf_backend_data *bed;
753
bed = get_elf_backend_data (abfd);
754
loc = s->contents + (s->reloc_count++ * bed->s->sizeof_rela);
755
bed->s->swap_reloca_out (abfd, rel, loc);
759
sparc_elf_r_info_64 (Elf_Internal_Rela *in_rel ATTRIBUTE_UNUSED,
760
bfd_vma rel_index ATTRIBUTE_UNUSED,
761
bfd_vma type ATTRIBUTE_UNUSED)
763
return ELF64_R_INFO (rel_index,
765
ELF64_R_TYPE_INFO (ELF64_R_TYPE_DATA (in_rel->r_info),
770
sparc_elf_r_info_32 (Elf_Internal_Rela *in_rel ATTRIBUTE_UNUSED,
771
bfd_vma rel_index, bfd_vma type)
773
return ELF32_R_INFO (rel_index, type);
777
sparc_elf_r_symndx_64 (bfd_vma r_info)
779
bfd_vma r_symndx = ELF32_R_SYM (r_info);
780
return (r_symndx >> 24);
784
sparc_elf_r_symndx_32 (bfd_vma r_info)
786
return ELF32_R_SYM (r_info);
791
#define PLT32_ENTRY_SIZE 12
792
#define PLT32_HEADER_SIZE (4 * PLT32_ENTRY_SIZE)
794
/* The first four entries in a 32-bit procedure linkage table are reserved,
795
and the initial contents are unimportant (we zero them out).
796
Subsequent entries look like this. See the SVR4 ABI SPARC
797
supplement to see how this works. */
799
/* sethi %hi(.-.plt0),%g1. We fill in the address later. */
800
#define PLT32_ENTRY_WORD0 0x03000000
801
/* b,a .plt0. We fill in the offset later. */
802
#define PLT32_ENTRY_WORD1 0x30800000
804
#define PLT32_ENTRY_WORD2 SPARC_NOP
807
sparc32_plt_entry_build (bfd *output_bfd, asection *splt, bfd_vma offset,
808
bfd_vma max ATTRIBUTE_UNUSED,
811
bfd_put_32 (output_bfd,
812
PLT32_ENTRY_WORD0 + offset,
813
splt->contents + offset);
814
bfd_put_32 (output_bfd,
816
+ (((- (offset + 4)) >> 2) & 0x3fffff)),
817
splt->contents + offset + 4);
818
bfd_put_32 (output_bfd, (bfd_vma) PLT32_ENTRY_WORD2,
819
splt->contents + offset + 8);
823
return offset / PLT32_ENTRY_SIZE - 4;
826
/* Both the headers and the entries are icache aligned. */
827
#define PLT64_ENTRY_SIZE 32
828
#define PLT64_HEADER_SIZE (4 * PLT64_ENTRY_SIZE)
829
#define PLT64_LARGE_THRESHOLD 32768
832
sparc64_plt_entry_build (bfd *output_bfd, asection *splt, bfd_vma offset,
833
bfd_vma max, bfd_vma *r_offset)
835
unsigned char *entry = splt->contents + offset;
836
const unsigned int nop = SPARC_NOP;
839
if (offset < (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE))
841
unsigned int sethi, ba;
845
plt_index = (offset / PLT64_ENTRY_SIZE);
847
sethi = 0x03000000 | (plt_index * PLT64_ENTRY_SIZE);
849
| (((splt->contents + PLT64_ENTRY_SIZE) - (entry + 4)) / 4 & 0x7ffff);
851
bfd_put_32 (output_bfd, (bfd_vma) sethi, entry);
852
bfd_put_32 (output_bfd, (bfd_vma) ba, entry + 4);
853
bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 8);
854
bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 12);
855
bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 16);
856
bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 20);
857
bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 24);
858
bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 28);
864
int block, last_block, ofs, last_ofs, chunks_this_block;
865
const int insn_chunk_size = (6 * 4);
866
const int ptr_chunk_size = (1 * 8);
867
const int entries_per_block = 160;
868
const int block_size = entries_per_block * (insn_chunk_size
871
/* Entries 32768 and higher are grouped into blocks of 160.
872
The blocks are further subdivided into 160 sequences of
873
6 instructions and 160 pointers. If a block does not require
874
the full 160 entries, let's say it requires N, then there
875
will be N sequences of 6 instructions and N pointers. */
877
offset -= (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE);
878
max -= (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE);
880
block = offset / block_size;
881
last_block = max / block_size;
882
if (block != last_block)
884
chunks_this_block = 160;
888
last_ofs = max % block_size;
889
chunks_this_block = last_ofs / (insn_chunk_size + ptr_chunk_size);
892
ofs = offset % block_size;
894
plt_index = (PLT64_LARGE_THRESHOLD +
896
(ofs / insn_chunk_size));
899
+ (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE)
900
+ (block * block_size)
901
+ (chunks_this_block * insn_chunk_size)
902
+ (ofs / insn_chunk_size) * ptr_chunk_size;
904
*r_offset = (bfd_vma) (ptr - splt->contents);
906
ldx = 0xc25be000 | ((ptr - (entry+4)) & 0x1fff);
914
bfd_put_32 (output_bfd, (bfd_vma) 0x8a10000f, entry);
915
bfd_put_32 (output_bfd, (bfd_vma) 0x40000002, entry + 4);
916
bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP, entry + 8);
917
bfd_put_32 (output_bfd, (bfd_vma) ldx, entry + 12);
918
bfd_put_32 (output_bfd, (bfd_vma) 0x83c3c001, entry + 16);
919
bfd_put_32 (output_bfd, (bfd_vma) 0x9e100005, entry + 20);
921
bfd_put_64 (output_bfd, (bfd_vma) (splt->contents - (entry + 4)), ptr);
924
return plt_index - 4;
927
/* The format of the first PLT entry in a VxWorks executable. */
928
static const bfd_vma sparc_vxworks_exec_plt0_entry[] =
930
0x05000000, /* sethi %hi(_GLOBAL_OFFSET_TABLE_+8), %g2 */
931
0x8410a000, /* or %g2, %lo(_GLOBAL_OFFSET_TABLE_+8), %g2 */
932
0xc4008000, /* ld [ %g2 ], %g2 */
933
0x81c08000, /* jmp %g2 */
937
/* The format of subsequent PLT entries. */
938
static const bfd_vma sparc_vxworks_exec_plt_entry[] =
940
0x03000000, /* sethi %hi(_GLOBAL_OFFSET_TABLE_+f@got), %g1 */
941
0x82106000, /* or %g1, %lo(_GLOBAL_OFFSET_TABLE_+f@got), %g1 */
942
0xc2004000, /* ld [ %g1 ], %g1 */
943
0x81c04000, /* jmp %g1 */
944
0x01000000, /* nop */
945
0x03000000, /* sethi %hi(f@pltindex), %g1 */
946
0x10800000, /* b _PLT_resolve */
947
0x82106000 /* or %g1, %lo(f@pltindex), %g1 */
950
/* The format of the first PLT entry in a VxWorks shared object. */
951
static const bfd_vma sparc_vxworks_shared_plt0_entry[] =
953
0xc405e008, /* ld [ %l7 + 8 ], %g2 */
954
0x81c08000, /* jmp %g2 */
958
/* The format of subsequent PLT entries. */
959
static const bfd_vma sparc_vxworks_shared_plt_entry[] =
961
0x03000000, /* sethi %hi(f@got), %g1 */
962
0x82106000, /* or %g1, %lo(f@got), %g1 */
963
0xc205c001, /* ld [ %l7 + %g1 ], %g1 */
964
0x81c04000, /* jmp %g1 */
965
0x01000000, /* nop */
966
0x03000000, /* sethi %hi(f@pltindex), %g1 */
967
0x10800000, /* b _PLT_resolve */
968
0x82106000 /* or %g1, %lo(f@pltindex), %g1 */
971
#define SPARC_ELF_PUT_WORD(htab, bfd, val, ptr) \
972
htab->put_word(bfd, val, ptr)
974
#define SPARC_ELF_R_INFO(htab, in_rel, index, type) \
975
htab->r_info(in_rel, index, type)
977
#define SPARC_ELF_R_SYMNDX(htab, r_info) \
978
htab->r_symndx(r_info)
980
#define SPARC_ELF_WORD_BYTES(htab) \
983
#define SPARC_ELF_RELA_BYTES(htab) \
986
#define SPARC_ELF_DTPOFF_RELOC(htab) \
989
#define SPARC_ELF_DTPMOD_RELOC(htab) \
992
#define SPARC_ELF_TPOFF_RELOC(htab) \
995
#define SPARC_ELF_BUILD_PLT_ENTRY(htab, obfd, splt, off, max, r_off) \
996
htab->build_plt_entry (obfd, splt, off, max, r_off)
998
/* Create an entry in an SPARC ELF linker hash table. */
1000
static struct bfd_hash_entry *
1001
link_hash_newfunc (struct bfd_hash_entry *entry,
1002
struct bfd_hash_table *table, const char *string)
1004
/* Allocate the structure if it has not already been allocated by a
1008
entry = bfd_hash_allocate (table,
1009
sizeof (struct _bfd_sparc_elf_link_hash_entry));
1014
/* Call the allocation method of the superclass. */
1015
entry = _bfd_elf_link_hash_newfunc (entry, table, string);
1018
struct _bfd_sparc_elf_link_hash_entry *eh;
1020
eh = (struct _bfd_sparc_elf_link_hash_entry *) entry;
1021
eh->dyn_relocs = NULL;
1022
eh->tls_type = GOT_UNKNOWN;
1028
/* The name of the dynamic interpreter. This is put in the .interp
1031
#define ELF32_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
1032
#define ELF64_DYNAMIC_INTERPRETER "/usr/lib/sparcv9/ld.so.1"
1034
/* Compute a hash of a local hash entry. We use elf_link_hash_entry
1035
for local symbol so that we can handle local STT_GNU_IFUNC symbols
1036
as global symbol. We reuse indx and dynstr_index for local symbol
1037
hash since they aren't used by global symbols in this backend. */
1040
elf_sparc_local_htab_hash (const void *ptr)
1042
struct elf_link_hash_entry *h
1043
= (struct elf_link_hash_entry *) ptr;
1044
return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);
1047
/* Compare local hash entries. */
1050
elf_sparc_local_htab_eq (const void *ptr1, const void *ptr2)
1052
struct elf_link_hash_entry *h1
1053
= (struct elf_link_hash_entry *) ptr1;
1054
struct elf_link_hash_entry *h2
1055
= (struct elf_link_hash_entry *) ptr2;
1057
return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
1060
/* Find and/or create a hash entry for local symbol. */
1062
static struct elf_link_hash_entry *
1063
elf_sparc_get_local_sym_hash (struct _bfd_sparc_elf_link_hash_table *htab,
1064
bfd *abfd, const Elf_Internal_Rela *rel,
1067
struct _bfd_sparc_elf_link_hash_entry e, *ret;
1068
asection *sec = abfd->sections;
1069
unsigned long r_symndx;
1073
r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
1074
h = ELF_LOCAL_SYMBOL_HASH (sec->id, r_symndx);
1076
e.elf.indx = sec->id;
1077
e.elf.dynstr_index = r_symndx;
1078
slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,
1079
create ? INSERT : NO_INSERT);
1086
ret = (struct _bfd_sparc_elf_link_hash_entry *) *slot;
1090
ret = (struct _bfd_sparc_elf_link_hash_entry *)
1091
objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,
1092
sizeof (struct _bfd_sparc_elf_link_hash_entry));
1095
memset (ret, 0, sizeof (*ret));
1096
ret->elf.indx = sec->id;
1097
ret->elf.dynstr_index = r_symndx;
1098
ret->elf.dynindx = -1;
1099
ret->elf.plt.offset = (bfd_vma) -1;
1100
ret->elf.got.offset = (bfd_vma) -1;
1106
/* Create a SPARC ELF linker hash table. */
1108
struct bfd_link_hash_table *
1109
_bfd_sparc_elf_link_hash_table_create (bfd *abfd)
1111
struct _bfd_sparc_elf_link_hash_table *ret;
1112
bfd_size_type amt = sizeof (struct _bfd_sparc_elf_link_hash_table);
1114
ret = (struct _bfd_sparc_elf_link_hash_table *) bfd_zmalloc (amt);
1118
if (ABI_64_P (abfd))
1120
ret->put_word = sparc_put_word_64;
1121
ret->r_info = sparc_elf_r_info_64;
1122
ret->r_symndx = sparc_elf_r_symndx_64;
1123
ret->dtpoff_reloc = R_SPARC_TLS_DTPOFF64;
1124
ret->dtpmod_reloc = R_SPARC_TLS_DTPMOD64;
1125
ret->tpoff_reloc = R_SPARC_TLS_TPOFF64;
1126
ret->word_align_power = 3;
1127
ret->align_power_max = 4;
1128
ret->bytes_per_word = 8;
1129
ret->bytes_per_rela = sizeof (Elf64_External_Rela);
1130
ret->dynamic_interpreter = ELF64_DYNAMIC_INTERPRETER;
1131
ret->dynamic_interpreter_size = sizeof ELF64_DYNAMIC_INTERPRETER;
1133
ret->build_plt_entry = sparc64_plt_entry_build;
1134
ret->plt_header_size = PLT64_HEADER_SIZE;
1135
ret->plt_entry_size = PLT64_ENTRY_SIZE;
1139
ret->put_word = sparc_put_word_32;
1140
ret->r_info = sparc_elf_r_info_32;
1141
ret->r_symndx = sparc_elf_r_symndx_32;
1142
ret->dtpoff_reloc = R_SPARC_TLS_DTPOFF32;
1143
ret->dtpmod_reloc = R_SPARC_TLS_DTPMOD32;
1144
ret->tpoff_reloc = R_SPARC_TLS_TPOFF32;
1145
ret->word_align_power = 2;
1146
ret->align_power_max = 3;
1147
ret->bytes_per_word = 4;
1148
ret->bytes_per_rela = sizeof (Elf32_External_Rela);
1149
ret->dynamic_interpreter = ELF32_DYNAMIC_INTERPRETER;
1150
ret->dynamic_interpreter_size = sizeof ELF32_DYNAMIC_INTERPRETER;
1152
ret->build_plt_entry = sparc32_plt_entry_build;
1153
ret->plt_header_size = PLT32_HEADER_SIZE;
1154
ret->plt_entry_size = PLT32_ENTRY_SIZE;
1157
if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc,
1158
sizeof (struct _bfd_sparc_elf_link_hash_entry),
1165
ret->loc_hash_table = htab_try_create (1024,
1166
elf_sparc_local_htab_hash,
1167
elf_sparc_local_htab_eq,
1169
ret->loc_hash_memory = objalloc_create ();
1170
if (!ret->loc_hash_table || !ret->loc_hash_memory)
1176
return &ret->elf.root;
1179
/* Destroy a SPARC ELF linker hash table. */
1182
_bfd_sparc_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
1184
struct _bfd_sparc_elf_link_hash_table *htab
1185
= (struct _bfd_sparc_elf_link_hash_table *) hash;
1187
if (htab->loc_hash_table)
1188
htab_delete (htab->loc_hash_table);
1189
if (htab->loc_hash_memory)
1190
objalloc_free ((struct objalloc *) htab->loc_hash_memory);
1191
_bfd_generic_link_hash_table_free (hash);
1194
/* Create .plt, .rela.plt, .got, .rela.got, .dynbss, and
1195
.rela.bss sections in DYNOBJ, and set up shortcuts to them in our
1199
_bfd_sparc_elf_create_dynamic_sections (bfd *dynobj,
1200
struct bfd_link_info *info)
1202
struct _bfd_sparc_elf_link_hash_table *htab;
1204
htab = _bfd_sparc_elf_hash_table (info);
1205
BFD_ASSERT (htab != NULL);
1207
if (!_bfd_elf_create_dynamic_sections (dynobj, info))
1210
htab->sdynbss = bfd_get_linker_section (dynobj, ".dynbss");
1212
htab->srelbss = bfd_get_linker_section (dynobj, ".rela.bss");
1214
if (htab->is_vxworks)
1216
if (!elf_vxworks_create_dynamic_sections (dynobj, info, &htab->srelplt2))
1220
htab->plt_header_size
1221
= 4 * ARRAY_SIZE (sparc_vxworks_shared_plt0_entry);
1222
htab->plt_entry_size
1223
= 4 * ARRAY_SIZE (sparc_vxworks_shared_plt_entry);
1227
htab->plt_header_size
1228
= 4 * ARRAY_SIZE (sparc_vxworks_exec_plt0_entry);
1229
htab->plt_entry_size
1230
= 4 * ARRAY_SIZE (sparc_vxworks_exec_plt_entry);
1234
if (!htab->elf.splt || !htab->elf.srelplt || !htab->sdynbss
1235
|| (!info->shared && !htab->srelbss))
1242
create_ifunc_sections (bfd *abfd, struct bfd_link_info *info)
1244
const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1245
struct elf_link_hash_table *htab = elf_hash_table (info);
1246
flagword flags, pltflags;
1249
if (htab->irelifunc != NULL || htab->iplt != NULL)
1252
flags = bed->dynamic_sec_flags;
1253
pltflags = flags | SEC_ALLOC | SEC_CODE | SEC_LOAD;
1255
s = bfd_make_section_with_flags (abfd, ".iplt", pltflags);
1257
|| ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
1261
s = bfd_make_section_with_flags (abfd, ".rela.iplt",
1262
flags | SEC_READONLY);
1264
|| ! bfd_set_section_alignment (abfd, s,
1265
bed->s->log_file_align))
1272
/* Copy the extra info we tack onto an elf_link_hash_entry. */
1275
_bfd_sparc_elf_copy_indirect_symbol (struct bfd_link_info *info,
1276
struct elf_link_hash_entry *dir,
1277
struct elf_link_hash_entry *ind)
1279
struct _bfd_sparc_elf_link_hash_entry *edir, *eind;
1281
edir = (struct _bfd_sparc_elf_link_hash_entry *) dir;
1282
eind = (struct _bfd_sparc_elf_link_hash_entry *) ind;
1284
if (eind->dyn_relocs != NULL)
1286
if (edir->dyn_relocs != NULL)
1288
struct _bfd_sparc_elf_dyn_relocs **pp;
1289
struct _bfd_sparc_elf_dyn_relocs *p;
1291
/* Add reloc counts against the indirect sym to the direct sym
1292
list. Merge any entries against the same section. */
1293
for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1295
struct _bfd_sparc_elf_dyn_relocs *q;
1297
for (q = edir->dyn_relocs; q != NULL; q = q->next)
1298
if (q->sec == p->sec)
1300
q->pc_count += p->pc_count;
1301
q->count += p->count;
1308
*pp = edir->dyn_relocs;
1311
edir->dyn_relocs = eind->dyn_relocs;
1312
eind->dyn_relocs = NULL;
1315
if (ind->root.type == bfd_link_hash_indirect
1316
&& dir->got.refcount <= 0)
1318
edir->tls_type = eind->tls_type;
1319
eind->tls_type = GOT_UNKNOWN;
1321
_bfd_elf_link_hash_copy_indirect (info, dir, ind);
1325
sparc_elf_tls_transition (struct bfd_link_info *info, bfd *abfd,
1326
int r_type, int is_local)
1328
if (! ABI_64_P (abfd)
1329
&& r_type == R_SPARC_TLS_GD_HI22
1330
&& ! _bfd_sparc_elf_tdata (abfd)->has_tlsgd)
1331
r_type = R_SPARC_REV32;
1338
case R_SPARC_TLS_GD_HI22:
1340
return R_SPARC_TLS_LE_HIX22;
1341
return R_SPARC_TLS_IE_HI22;
1342
case R_SPARC_TLS_GD_LO10:
1344
return R_SPARC_TLS_LE_LOX10;
1345
return R_SPARC_TLS_IE_LO10;
1346
case R_SPARC_TLS_IE_HI22:
1348
return R_SPARC_TLS_LE_HIX22;
1350
case R_SPARC_TLS_IE_LO10:
1352
return R_SPARC_TLS_LE_LOX10;
1354
case R_SPARC_TLS_LDM_HI22:
1355
return R_SPARC_TLS_LE_HIX22;
1356
case R_SPARC_TLS_LDM_LO10:
1357
return R_SPARC_TLS_LE_LOX10;
1363
/* Look through the relocs for a section during the first phase, and
1364
allocate space in the global offset table or procedure linkage
1368
_bfd_sparc_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
1369
asection *sec, const Elf_Internal_Rela *relocs)
1371
struct _bfd_sparc_elf_link_hash_table *htab;
1372
Elf_Internal_Shdr *symtab_hdr;
1373
struct elf_link_hash_entry **sym_hashes;
1374
const Elf_Internal_Rela *rel;
1375
const Elf_Internal_Rela *rel_end;
1378
bfd_boolean checked_tlsgd = FALSE;
1380
if (info->relocatable)
1383
htab = _bfd_sparc_elf_hash_table (info);
1384
BFD_ASSERT (htab != NULL);
1385
symtab_hdr = &elf_symtab_hdr (abfd);
1386
sym_hashes = elf_sym_hashes (abfd);
1390
if (ABI_64_P (abfd))
1391
num_relocs = NUM_SHDR_ENTRIES (_bfd_elf_single_rel_hdr (sec));
1393
num_relocs = sec->reloc_count;
1395
BFD_ASSERT (is_sparc_elf (abfd) || num_relocs == 0);
1397
if (htab->elf.dynobj == NULL)
1398
htab->elf.dynobj = abfd;
1399
if (!create_ifunc_sections (htab->elf.dynobj, info))
1402
rel_end = relocs + num_relocs;
1403
for (rel = relocs; rel < rel_end; rel++)
1405
unsigned int r_type;
1406
unsigned long r_symndx;
1407
struct elf_link_hash_entry *h;
1408
Elf_Internal_Sym *isym;
1410
r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
1411
r_type = SPARC_ELF_R_TYPE (rel->r_info);
1413
if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1415
(*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1421
if (r_symndx < symtab_hdr->sh_info)
1423
/* A local symbol. */
1424
isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1429
/* Check relocation against local STT_GNU_IFUNC symbol. */
1430
if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1432
h = elf_sparc_get_local_sym_hash (htab, abfd, rel,
1437
/* Fake a STT_GNU_IFUNC symbol. */
1438
h->type = STT_GNU_IFUNC;
1441
h->forced_local = 1;
1442
h->root.type = bfd_link_hash_defined;
1449
h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1450
while (h->root.type == bfd_link_hash_indirect
1451
|| h->root.type == bfd_link_hash_warning)
1452
h = (struct elf_link_hash_entry *) h->root.u.i.link;
1454
/* PR15323, ref flags aren't set for references in the same
1456
h->root.non_ir_ref = 1;
1459
if (h && h->type == STT_GNU_IFUNC)
1464
h->plt.refcount += 1;
1468
/* Compatibility with old R_SPARC_REV32 reloc conflicting
1469
with R_SPARC_TLS_GD_HI22. */
1470
if (! ABI_64_P (abfd) && ! checked_tlsgd)
1473
case R_SPARC_TLS_GD_HI22:
1475
const Elf_Internal_Rela *relt;
1477
for (relt = rel + 1; relt < rel_end; relt++)
1478
if (ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_LO10
1479
|| ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_ADD
1480
|| ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_CALL)
1482
checked_tlsgd = TRUE;
1483
_bfd_sparc_elf_tdata (abfd)->has_tlsgd = relt < rel_end;
1486
case R_SPARC_TLS_GD_LO10:
1487
case R_SPARC_TLS_GD_ADD:
1488
case R_SPARC_TLS_GD_CALL:
1489
checked_tlsgd = TRUE;
1490
_bfd_sparc_elf_tdata (abfd)->has_tlsgd = TRUE;
1494
r_type = sparc_elf_tls_transition (info, abfd, r_type, h == NULL);
1497
case R_SPARC_TLS_LDM_HI22:
1498
case R_SPARC_TLS_LDM_LO10:
1499
htab->tls_ldm_got.refcount += 1;
1502
case R_SPARC_TLS_LE_HIX22:
1503
case R_SPARC_TLS_LE_LOX10:
1508
case R_SPARC_TLS_IE_HI22:
1509
case R_SPARC_TLS_IE_LO10:
1511
info->flags |= DF_STATIC_TLS;
1517
case R_SPARC_GOTDATA_HIX22:
1518
case R_SPARC_GOTDATA_LOX10:
1519
case R_SPARC_GOTDATA_OP_HIX22:
1520
case R_SPARC_GOTDATA_OP_LOX10:
1521
case R_SPARC_TLS_GD_HI22:
1522
case R_SPARC_TLS_GD_LO10:
1523
/* This symbol requires a global offset table entry. */
1525
int tls_type, old_tls_type;
1533
case R_SPARC_GOTDATA_OP_HIX22:
1534
case R_SPARC_GOTDATA_OP_LOX10:
1535
tls_type = GOT_NORMAL;
1537
case R_SPARC_TLS_GD_HI22:
1538
case R_SPARC_TLS_GD_LO10:
1539
tls_type = GOT_TLS_GD;
1541
case R_SPARC_TLS_IE_HI22:
1542
case R_SPARC_TLS_IE_LO10:
1543
tls_type = GOT_TLS_IE;
1549
h->got.refcount += 1;
1550
old_tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
1554
bfd_signed_vma *local_got_refcounts;
1556
/* This is a global offset table entry for a local symbol. */
1557
local_got_refcounts = elf_local_got_refcounts (abfd);
1558
if (local_got_refcounts == NULL)
1562
size = symtab_hdr->sh_info;
1563
size *= (sizeof (bfd_signed_vma) + sizeof(char));
1564
local_got_refcounts = ((bfd_signed_vma *)
1565
bfd_zalloc (abfd, size));
1566
if (local_got_refcounts == NULL)
1568
elf_local_got_refcounts (abfd) = local_got_refcounts;
1569
_bfd_sparc_elf_local_got_tls_type (abfd)
1570
= (char *) (local_got_refcounts + symtab_hdr->sh_info);
1574
case R_SPARC_GOTDATA_OP_HIX22:
1575
case R_SPARC_GOTDATA_OP_LOX10:
1579
local_got_refcounts[r_symndx] += 1;
1582
old_tls_type = _bfd_sparc_elf_local_got_tls_type (abfd) [r_symndx];
1585
/* If a TLS symbol is accessed using IE at least once,
1586
there is no point to use dynamic model for it. */
1587
if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1588
&& (old_tls_type != GOT_TLS_GD
1589
|| tls_type != GOT_TLS_IE))
1591
if (old_tls_type == GOT_TLS_IE && tls_type == GOT_TLS_GD)
1592
tls_type = old_tls_type;
1595
(*_bfd_error_handler)
1596
(_("%B: `%s' accessed both as normal and thread local symbol"),
1597
abfd, h ? h->root.root.string : "<local>");
1602
if (old_tls_type != tls_type)
1605
_bfd_sparc_elf_hash_entry (h)->tls_type = tls_type;
1607
_bfd_sparc_elf_local_got_tls_type (abfd) [r_symndx] = tls_type;
1611
if (htab->elf.sgot == NULL)
1613
if (!_bfd_elf_create_got_section (htab->elf.dynobj, info))
1618
case R_SPARC_TLS_GD_CALL:
1619
case R_SPARC_TLS_LDM_CALL:
1622
/* These are basically R_SPARC_TLS_WPLT30 relocs against
1624
struct bfd_link_hash_entry *bh = NULL;
1625
if (! _bfd_generic_link_add_one_symbol (info, abfd,
1626
"__tls_get_addr", 0,
1627
bfd_und_section_ptr, 0,
1631
h = (struct elf_link_hash_entry *) bh;
1638
case R_SPARC_WPLT30:
1639
case R_SPARC_HIPLT22:
1640
case R_SPARC_LOPLT10:
1641
case R_SPARC_PCPLT32:
1642
case R_SPARC_PCPLT22:
1643
case R_SPARC_PCPLT10:
1645
/* This symbol requires a procedure linkage table entry. We
1646
actually build the entry in adjust_dynamic_symbol,
1647
because this might be a case of linking PIC code without
1648
linking in any dynamic objects, in which case we don't
1649
need to generate a procedure linkage table after all. */
1653
if (! ABI_64_P (abfd))
1655
/* The Solaris native assembler will generate a WPLT30
1656
reloc for a local symbol if you assemble a call from
1657
one section to another when using -K pic. We treat
1659
if (ELF32_R_TYPE (rel->r_info) == R_SPARC_PLT32)
1663
/* PR 7027: We need similar behaviour for 64-bit binaries. */
1664
else if (r_type == R_SPARC_WPLT30)
1667
/* It does not make sense to have a procedure linkage
1668
table entry for a local symbol. */
1669
bfd_set_error (bfd_error_bad_value);
1678
this_r_type = SPARC_ELF_R_TYPE (rel->r_info);
1679
if (this_r_type == R_SPARC_PLT32
1680
|| this_r_type == R_SPARC_PLT64)
1683
h->plt.refcount += 1;
1688
case R_SPARC_PC_HH22:
1689
case R_SPARC_PC_HM10:
1690
case R_SPARC_PC_LM22:
1695
&& strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1700
case R_SPARC_DISP16:
1701
case R_SPARC_DISP32:
1702
case R_SPARC_DISP64:
1703
case R_SPARC_WDISP30:
1704
case R_SPARC_WDISP22:
1705
case R_SPARC_WDISP19:
1706
case R_SPARC_WDISP16:
1707
case R_SPARC_WDISP10:
1738
if (h != NULL && !info->shared)
1740
/* We may need a .plt entry if the function this reloc
1741
refers to is in a shared lib. */
1742
h->plt.refcount += 1;
1745
/* If we are creating a shared library, and this is a reloc
1746
against a global symbol, or a non PC relative reloc
1747
against a local symbol, then we need to copy the reloc
1748
into the shared library. However, if we are linking with
1749
-Bsymbolic, we do not need to copy a reloc against a
1750
global symbol which is defined in an object we are
1751
including in the link (i.e., DEF_REGULAR is set). At
1752
this point we have not seen all the input files, so it is
1753
possible that DEF_REGULAR is not set now but will be set
1754
later (it is never cleared). In case of a weak definition,
1755
DEF_REGULAR may be cleared later by a strong definition in
1756
a shared library. We account for that possibility below by
1757
storing information in the relocs_copied field of the hash
1758
table entry. A similar situation occurs when creating
1759
shared libraries and symbol visibility changes render the
1762
If on the other hand, we are creating an executable, we
1763
may need to keep relocations for symbols satisfied by a
1764
dynamic library if we manage to avoid copy relocs for the
1767
&& (sec->flags & SEC_ALLOC) != 0
1768
&& (! _bfd_sparc_elf_howto_table[r_type].pc_relative
1770
&& (! SYMBOLIC_BIND (info, h)
1771
|| h->root.type == bfd_link_hash_defweak
1772
|| !h->def_regular))))
1774
&& (sec->flags & SEC_ALLOC) != 0
1776
&& (h->root.type == bfd_link_hash_defweak
1777
|| !h->def_regular))
1780
&& h->type == STT_GNU_IFUNC))
1782
struct _bfd_sparc_elf_dyn_relocs *p;
1783
struct _bfd_sparc_elf_dyn_relocs **head;
1785
/* When creating a shared object, we must copy these
1786
relocs into the output file. We create a reloc
1787
section in dynobj and make room for the reloc. */
1790
sreloc = _bfd_elf_make_dynamic_reloc_section
1791
(sec, htab->elf.dynobj, htab->word_align_power,
1792
abfd, /*rela?*/ TRUE);
1798
/* If this is a global symbol, we count the number of
1799
relocations we need for this symbol. */
1801
head = &((struct _bfd_sparc_elf_link_hash_entry *) h)->dyn_relocs;
1804
/* Track dynamic relocs needed for local syms too.
1805
We really need local syms available to do this
1810
BFD_ASSERT (isym != NULL);
1811
s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1815
vpp = &elf_section_data (s)->local_dynrel;
1816
head = (struct _bfd_sparc_elf_dyn_relocs **) vpp;
1820
if (p == NULL || p->sec != sec)
1822
bfd_size_type amt = sizeof *p;
1823
p = ((struct _bfd_sparc_elf_dyn_relocs *)
1824
bfd_alloc (htab->elf.dynobj, amt));
1835
if (_bfd_sparc_elf_howto_table[r_type].pc_relative)
1841
case R_SPARC_GNU_VTINHERIT:
1842
if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1846
case R_SPARC_GNU_VTENTRY:
1847
BFD_ASSERT (h != NULL);
1849
&& !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1853
case R_SPARC_REGISTER:
1854
/* Nothing to do. */
1866
_bfd_sparc_elf_gc_mark_hook (asection *sec,
1867
struct bfd_link_info *info,
1868
Elf_Internal_Rela *rel,
1869
struct elf_link_hash_entry *h,
1870
Elf_Internal_Sym *sym)
1873
switch (SPARC_ELF_R_TYPE (rel->r_info))
1875
case R_SPARC_GNU_VTINHERIT:
1876
case R_SPARC_GNU_VTENTRY:
1880
/* FIXME: The test here, in check_relocs and in relocate_section
1881
dealing with TLS optimization, ought to be !info->executable. */
1884
switch (SPARC_ELF_R_TYPE (rel->r_info))
1886
case R_SPARC_TLS_GD_CALL:
1887
case R_SPARC_TLS_LDM_CALL:
1888
/* This reloc implicitly references __tls_get_addr. We know
1889
another reloc will reference the same symbol as the one
1890
on this reloc, so the real symbol and section will be
1891
gc marked when processing the other reloc. That lets
1892
us handle __tls_get_addr here. */
1893
h = elf_link_hash_lookup (elf_hash_table (info), "__tls_get_addr",
1894
FALSE, FALSE, TRUE);
1895
BFD_ASSERT (h != NULL);
1897
if (h->u.weakdef != NULL)
1898
h->u.weakdef->mark = 1;
1903
return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1906
static Elf_Internal_Rela *
1907
sparc_elf_find_reloc_at_ofs (Elf_Internal_Rela *rel,
1908
Elf_Internal_Rela *relend,
1911
while (rel < relend)
1913
if (rel->r_offset == offset)
1920
/* Update the got entry reference counts for the section being removed. */
1922
_bfd_sparc_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
1923
asection *sec, const Elf_Internal_Rela *relocs)
1925
struct _bfd_sparc_elf_link_hash_table *htab;
1926
Elf_Internal_Shdr *symtab_hdr;
1927
struct elf_link_hash_entry **sym_hashes;
1928
bfd_signed_vma *local_got_refcounts;
1929
const Elf_Internal_Rela *rel, *relend;
1931
if (info->relocatable)
1934
BFD_ASSERT (is_sparc_elf (abfd) || sec->reloc_count == 0);
1936
elf_section_data (sec)->local_dynrel = NULL;
1938
htab = _bfd_sparc_elf_hash_table (info);
1939
BFD_ASSERT (htab != NULL);
1940
symtab_hdr = &elf_symtab_hdr (abfd);
1941
sym_hashes = elf_sym_hashes (abfd);
1942
local_got_refcounts = elf_local_got_refcounts (abfd);
1944
relend = relocs + sec->reloc_count;
1945
for (rel = relocs; rel < relend; rel++)
1947
unsigned long r_symndx;
1948
unsigned int r_type;
1949
struct elf_link_hash_entry *h = NULL;
1951
r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
1952
if (r_symndx >= symtab_hdr->sh_info)
1954
struct _bfd_sparc_elf_link_hash_entry *eh;
1955
struct _bfd_sparc_elf_dyn_relocs **pp;
1956
struct _bfd_sparc_elf_dyn_relocs *p;
1958
h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1959
while (h->root.type == bfd_link_hash_indirect
1960
|| h->root.type == bfd_link_hash_warning)
1961
h = (struct elf_link_hash_entry *) h->root.u.i.link;
1962
eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
1963
for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1966
/* Everything must go for SEC. */
1972
r_type = SPARC_ELF_R_TYPE (rel->r_info);
1973
r_type = sparc_elf_tls_transition (info, abfd, r_type, h != NULL);
1976
case R_SPARC_TLS_LDM_HI22:
1977
case R_SPARC_TLS_LDM_LO10:
1978
if (_bfd_sparc_elf_hash_table (info)->tls_ldm_got.refcount > 0)
1979
_bfd_sparc_elf_hash_table (info)->tls_ldm_got.refcount -= 1;
1982
case R_SPARC_TLS_GD_HI22:
1983
case R_SPARC_TLS_GD_LO10:
1984
case R_SPARC_TLS_IE_HI22:
1985
case R_SPARC_TLS_IE_LO10:
1989
case R_SPARC_GOTDATA_HIX22:
1990
case R_SPARC_GOTDATA_LOX10:
1991
case R_SPARC_GOTDATA_OP_HIX22:
1992
case R_SPARC_GOTDATA_OP_LOX10:
1995
if (h->got.refcount > 0)
2002
case R_SPARC_GOTDATA_OP_HIX22:
2003
case R_SPARC_GOTDATA_OP_LOX10:
2007
if (local_got_refcounts[r_symndx] > 0)
2008
local_got_refcounts[r_symndx]--;
2016
case R_SPARC_PC_HH22:
2017
case R_SPARC_PC_HM10:
2018
case R_SPARC_PC_LM22:
2020
&& strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2025
case R_SPARC_DISP16:
2026
case R_SPARC_DISP32:
2027
case R_SPARC_DISP64:
2028
case R_SPARC_WDISP30:
2029
case R_SPARC_WDISP22:
2030
case R_SPARC_WDISP19:
2031
case R_SPARC_WDISP16:
2032
case R_SPARC_WDISP10:
2064
case R_SPARC_WPLT30:
2067
if (h->plt.refcount > 0)
2080
/* Adjust a symbol defined by a dynamic object and referenced by a
2081
regular object. The current definition is in some section of the
2082
dynamic object, but we're not including those sections. We have to
2083
change the definition to something the rest of the link can
2087
_bfd_sparc_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
2088
struct elf_link_hash_entry *h)
2090
struct _bfd_sparc_elf_link_hash_table *htab;
2091
struct _bfd_sparc_elf_link_hash_entry * eh;
2092
struct _bfd_sparc_elf_dyn_relocs *p;
2095
htab = _bfd_sparc_elf_hash_table (info);
2096
BFD_ASSERT (htab != NULL);
2098
/* Make sure we know what is going on here. */
2099
BFD_ASSERT (htab->elf.dynobj != NULL
2101
|| h->type == STT_GNU_IFUNC
2102
|| h->u.weakdef != NULL
2105
&& !h->def_regular)));
2107
/* If this is a function, put it in the procedure linkage table. We
2108
will fill in the contents of the procedure linkage table later
2109
(although we could actually do it here). The STT_NOTYPE
2110
condition is a hack specifically for the Oracle libraries
2111
delivered for Solaris; for some inexplicable reason, they define
2112
some of their functions as STT_NOTYPE when they really should be
2114
if (h->type == STT_FUNC
2115
|| h->type == STT_GNU_IFUNC
2117
|| (h->type == STT_NOTYPE
2118
&& (h->root.type == bfd_link_hash_defined
2119
|| h->root.type == bfd_link_hash_defweak)
2120
&& (h->root.u.def.section->flags & SEC_CODE) != 0))
2122
if (h->plt.refcount <= 0
2123
|| (h->type != STT_GNU_IFUNC
2124
&& (SYMBOL_CALLS_LOCAL (info, h)
2125
|| (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2126
&& h->root.type == bfd_link_hash_undefweak))))
2128
/* This case can occur if we saw a WPLT30 reloc in an input
2129
file, but the symbol was never referred to by a dynamic
2130
object, or if all references were garbage collected. In
2131
such a case, we don't actually need to build a procedure
2132
linkage table, and we can just do a WDISP30 reloc instead. */
2133
h->plt.offset = (bfd_vma) -1;
2140
h->plt.offset = (bfd_vma) -1;
2142
/* If this is a weak symbol, and there is a real definition, the
2143
processor independent code will have arranged for us to see the
2144
real definition first, and we can just use the same value. */
2145
if (h->u.weakdef != NULL)
2147
BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2148
|| h->u.weakdef->root.type == bfd_link_hash_defweak);
2149
h->root.u.def.section = h->u.weakdef->root.u.def.section;
2150
h->root.u.def.value = h->u.weakdef->root.u.def.value;
2154
/* This is a reference to a symbol defined by a dynamic object which
2155
is not a function. */
2157
/* If we are creating a shared library, we must presume that the
2158
only references to the symbol are via the global offset table.
2159
For such cases we need not do anything here; the relocations will
2160
be handled correctly by relocate_section. */
2164
/* If there are no references to this symbol that do not use the
2165
GOT, we don't need to generate a copy reloc. */
2166
if (!h->non_got_ref)
2169
/* If -z nocopyreloc was given, we won't generate them either. */
2170
if (info->nocopyreloc)
2176
eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
2177
for (p = eh->dyn_relocs; p != NULL; p = p->next)
2179
s = p->sec->output_section;
2180
if (s != NULL && (s->flags & SEC_READONLY) != 0)
2184
/* If we didn't find any dynamic relocs in read-only sections, then
2185
we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2192
/* We must allocate the symbol in our .dynbss section, which will
2193
become part of the .bss section of the executable. There will be
2194
an entry for this symbol in the .dynsym section. The dynamic
2195
object will contain position independent code, so all references
2196
from the dynamic object to this symbol will go through the global
2197
offset table. The dynamic linker will use the .dynsym entry to
2198
determine the address it must put in the global offset table, so
2199
both the dynamic object and the regular object will refer to the
2200
same memory location for the variable. */
2202
/* We must generate a R_SPARC_COPY reloc to tell the dynamic linker
2203
to copy the initial value out of the dynamic object and into the
2204
runtime process image. We need to remember the offset into the
2205
.rel.bss section we are going to use. */
2206
if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
2208
htab->srelbss->size += SPARC_ELF_RELA_BYTES (htab);
2214
return _bfd_elf_adjust_dynamic_copy (h, s);
2217
/* Allocate space in .plt, .got and associated reloc sections for
2221
allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
2223
struct bfd_link_info *info;
2224
struct _bfd_sparc_elf_link_hash_table *htab;
2225
struct _bfd_sparc_elf_link_hash_entry *eh;
2226
struct _bfd_sparc_elf_dyn_relocs *p;
2228
if (h->root.type == bfd_link_hash_indirect)
2231
info = (struct bfd_link_info *) inf;
2232
htab = _bfd_sparc_elf_hash_table (info);
2233
BFD_ASSERT (htab != NULL);
2235
if ((htab->elf.dynamic_sections_created
2236
&& h->plt.refcount > 0)
2237
|| (h->type == STT_GNU_IFUNC
2241
/* Make sure this symbol is output as a dynamic symbol.
2242
Undefined weak syms won't yet be marked as dynamic. */
2243
if (h->dynindx == -1
2244
&& !h->forced_local)
2246
if (! bfd_elf_link_record_dynamic_symbol (info, h))
2250
if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h)
2251
|| (h->type == STT_GNU_IFUNC
2254
asection *s = htab->elf.splt;
2259
/* Allocate room for the header. */
2262
s->size = htab->plt_header_size;
2264
/* Allocate space for the .rela.plt.unloaded relocations. */
2265
if (htab->is_vxworks && !info->shared)
2266
htab->srelplt2->size = sizeof (Elf32_External_Rela) * 2;
2269
/* The procedure linkage table size is bounded by the magnitude
2270
of the offset we can describe in the entry. */
2271
if (s->size >= (SPARC_ELF_WORD_BYTES(htab) == 8 ?
2272
(((bfd_vma)1 << 31) << 1) : 0x400000))
2274
bfd_set_error (bfd_error_bad_value);
2278
if (SPARC_ELF_WORD_BYTES(htab) == 8
2279
&& s->size >= PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE)
2281
bfd_vma off = s->size - PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE;
2284
off = (off % (160 * PLT64_ENTRY_SIZE)) / PLT64_ENTRY_SIZE;
2286
h->plt.offset = (s->size - (off * 8));
2289
h->plt.offset = s->size;
2291
/* If this symbol is not defined in a regular file, and we are
2292
not generating a shared library, then set the symbol to this
2293
location in the .plt. This is required to make function
2294
pointers compare as equal between the normal executable and
2295
the shared library. */
2299
h->root.u.def.section = s;
2300
h->root.u.def.value = h->plt.offset;
2303
/* Make room for this entry. */
2304
s->size += htab->plt_entry_size;
2306
/* We also need to make an entry in the .rela.plt section. */
2307
if (s == htab->elf.splt)
2308
htab->elf.srelplt->size += SPARC_ELF_RELA_BYTES (htab);
2310
htab->elf.irelplt->size += SPARC_ELF_RELA_BYTES (htab);
2312
if (htab->is_vxworks)
2314
/* Allocate space for the .got.plt entry. */
2315
htab->elf.sgotplt->size += 4;
2317
/* ...and for the .rela.plt.unloaded relocations. */
2319
htab->srelplt2->size += sizeof (Elf32_External_Rela) * 3;
2324
h->plt.offset = (bfd_vma) -1;
2330
h->plt.offset = (bfd_vma) -1;
2334
/* If R_SPARC_TLS_IE_{HI22,LO10} symbol is now local to the binary,
2335
make it a R_SPARC_TLS_LE_{HI22,LO10} requiring no TLS entry. */
2336
if (h->got.refcount > 0
2339
&& _bfd_sparc_elf_hash_entry(h)->tls_type == GOT_TLS_IE)
2340
h->got.offset = (bfd_vma) -1;
2341
else if (h->got.refcount > 0)
2345
int tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
2347
/* Make sure this symbol is output as a dynamic symbol.
2348
Undefined weak syms won't yet be marked as dynamic. */
2349
if (h->dynindx == -1
2350
&& !h->forced_local)
2352
if (! bfd_elf_link_record_dynamic_symbol (info, h))
2357
h->got.offset = s->size;
2358
s->size += SPARC_ELF_WORD_BYTES (htab);
2359
/* R_SPARC_TLS_GD_HI{22,LO10} needs 2 consecutive GOT slots. */
2360
if (tls_type == GOT_TLS_GD)
2361
s->size += SPARC_ELF_WORD_BYTES (htab);
2362
dyn = htab->elf.dynamic_sections_created;
2363
/* R_SPARC_TLS_IE_{HI22,LO10} needs one dynamic relocation,
2364
R_SPARC_TLS_GD_{HI22,LO10} needs one if local symbol and two if
2366
if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
2367
|| tls_type == GOT_TLS_IE
2368
|| h->type == STT_GNU_IFUNC)
2369
htab->elf.srelgot->size += SPARC_ELF_RELA_BYTES (htab);
2370
else if (tls_type == GOT_TLS_GD)
2371
htab->elf.srelgot->size += 2 * SPARC_ELF_RELA_BYTES (htab);
2372
else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
2373
htab->elf.srelgot->size += SPARC_ELF_RELA_BYTES (htab);
2376
h->got.offset = (bfd_vma) -1;
2378
eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
2379
if (eh->dyn_relocs == NULL)
2382
/* In the shared -Bsymbolic case, discard space allocated for
2383
dynamic pc-relative relocs against symbols which turn out to be
2384
defined in regular objects. For the normal shared case, discard
2385
space for pc-relative relocs that have become local due to symbol
2386
visibility changes. */
2390
if (SYMBOL_CALLS_LOCAL (info, h))
2392
struct _bfd_sparc_elf_dyn_relocs **pp;
2394
for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2396
p->count -= p->pc_count;
2405
if (htab->is_vxworks)
2407
struct _bfd_sparc_elf_dyn_relocs **pp;
2409
for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2411
if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
2418
/* Also discard relocs on undefined weak syms with non-default
2420
if (eh->dyn_relocs != NULL
2421
&& h->root.type == bfd_link_hash_undefweak)
2423
if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2424
eh->dyn_relocs = NULL;
2426
/* Make sure undefined weak symbols are output as a dynamic
2428
else if (h->dynindx == -1
2429
&& !h->forced_local)
2431
if (! bfd_elf_link_record_dynamic_symbol (info, h))
2438
/* For the non-shared case, discard space for relocs against
2439
symbols which turn out to need copy relocs or are not
2445
|| (htab->elf.dynamic_sections_created
2446
&& (h->root.type == bfd_link_hash_undefweak
2447
|| h->root.type == bfd_link_hash_undefined))))
2449
/* Make sure this symbol is output as a dynamic symbol.
2450
Undefined weak syms won't yet be marked as dynamic. */
2451
if (h->dynindx == -1
2452
&& !h->forced_local)
2454
if (! bfd_elf_link_record_dynamic_symbol (info, h))
2458
/* If that succeeded, we know we'll be keeping all the
2460
if (h->dynindx != -1)
2464
eh->dyn_relocs = NULL;
2469
/* Finally, allocate space. */
2470
for (p = eh->dyn_relocs; p != NULL; p = p->next)
2472
asection *sreloc = elf_section_data (p->sec)->sreloc;
2473
sreloc->size += p->count * SPARC_ELF_RELA_BYTES (htab);
2479
/* Allocate space in .plt, .got and associated reloc sections for
2480
local dynamic relocs. */
2483
allocate_local_dynrelocs (void **slot, void *inf)
2485
struct elf_link_hash_entry *h
2486
= (struct elf_link_hash_entry *) *slot;
2488
if (h->type != STT_GNU_IFUNC
2492
|| h->root.type != bfd_link_hash_defined)
2495
return allocate_dynrelocs (h, inf);
2498
/* Find any dynamic relocs that apply to read-only sections. */
2501
readonly_dynrelocs (struct elf_link_hash_entry *h, void * inf)
2503
struct _bfd_sparc_elf_link_hash_entry *eh;
2504
struct _bfd_sparc_elf_dyn_relocs *p;
2506
eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
2507
for (p = eh->dyn_relocs; p != NULL; p = p->next)
2509
asection *s = p->sec->output_section;
2511
if (s != NULL && (s->flags & SEC_READONLY) != 0)
2513
struct bfd_link_info *info = (struct bfd_link_info *) inf;
2515
info->flags |= DF_TEXTREL;
2517
/* Not an error, just cut short the traversal. */
2524
/* Return true if the dynamic symbol for a given section should be
2525
omitted when creating a shared library. */
2528
_bfd_sparc_elf_omit_section_dynsym (bfd *output_bfd,
2529
struct bfd_link_info *info,
2532
/* We keep the .got section symbol so that explicit relocations
2533
against the _GLOBAL_OFFSET_TABLE_ symbol emitted in PIC mode
2534
can be turned into relocations against the .got symbol. */
2535
if (strcmp (p->name, ".got") == 0)
2538
return _bfd_elf_link_omit_section_dynsym (output_bfd, info, p);
2541
/* Set the sizes of the dynamic sections. */
2544
_bfd_sparc_elf_size_dynamic_sections (bfd *output_bfd,
2545
struct bfd_link_info *info)
2547
struct _bfd_sparc_elf_link_hash_table *htab;
2552
htab = _bfd_sparc_elf_hash_table (info);
2553
BFD_ASSERT (htab != NULL);
2554
dynobj = htab->elf.dynobj;
2555
BFD_ASSERT (dynobj != NULL);
2557
if (elf_hash_table (info)->dynamic_sections_created)
2559
/* Set the contents of the .interp section to the interpreter. */
2560
if (info->executable)
2562
s = bfd_get_linker_section (dynobj, ".interp");
2563
BFD_ASSERT (s != NULL);
2564
s->size = htab->dynamic_interpreter_size;
2565
s->contents = (unsigned char *) htab->dynamic_interpreter;
2569
/* Set up .got offsets for local syms, and space for local dynamic
2571
for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2573
bfd_signed_vma *local_got;
2574
bfd_signed_vma *end_local_got;
2575
char *local_tls_type;
2576
bfd_size_type locsymcount;
2577
Elf_Internal_Shdr *symtab_hdr;
2580
if (! is_sparc_elf (ibfd))
2583
for (s = ibfd->sections; s != NULL; s = s->next)
2585
struct _bfd_sparc_elf_dyn_relocs *p;
2587
for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
2589
if (!bfd_is_abs_section (p->sec)
2590
&& bfd_is_abs_section (p->sec->output_section))
2592
/* Input section has been discarded, either because
2593
it is a copy of a linkonce section or due to
2594
linker script /DISCARD/, so we'll be discarding
2597
else if (htab->is_vxworks
2598
&& strcmp (p->sec->output_section->name,
2601
/* Relocations in vxworks .tls_vars sections are
2602
handled specially by the loader. */
2604
else if (p->count != 0)
2606
srel = elf_section_data (p->sec)->sreloc;
2607
if (!htab->elf.dynamic_sections_created)
2608
srel = htab->elf.irelplt;
2609
srel->size += p->count * SPARC_ELF_RELA_BYTES (htab);
2610
if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2611
info->flags |= DF_TEXTREL;
2616
local_got = elf_local_got_refcounts (ibfd);
2620
symtab_hdr = &elf_symtab_hdr (ibfd);
2621
locsymcount = symtab_hdr->sh_info;
2622
end_local_got = local_got + locsymcount;
2623
local_tls_type = _bfd_sparc_elf_local_got_tls_type (ibfd);
2625
srel = htab->elf.srelgot;
2626
for (; local_got < end_local_got; ++local_got, ++local_tls_type)
2630
*local_got = s->size;
2631
s->size += SPARC_ELF_WORD_BYTES (htab);
2632
if (*local_tls_type == GOT_TLS_GD)
2633
s->size += SPARC_ELF_WORD_BYTES (htab);
2635
|| *local_tls_type == GOT_TLS_GD
2636
|| *local_tls_type == GOT_TLS_IE)
2637
srel->size += SPARC_ELF_RELA_BYTES (htab);
2640
*local_got = (bfd_vma) -1;
2644
if (htab->tls_ldm_got.refcount > 0)
2646
/* Allocate 2 got entries and 1 dynamic reloc for
2647
R_SPARC_TLS_LDM_{HI22,LO10} relocs. */
2648
htab->tls_ldm_got.offset = htab->elf.sgot->size;
2649
htab->elf.sgot->size += (2 * SPARC_ELF_WORD_BYTES (htab));
2650
htab->elf.srelgot->size += SPARC_ELF_RELA_BYTES (htab);
2653
htab->tls_ldm_got.offset = -1;
2655
/* Allocate global sym .plt and .got entries, and space for global
2656
sym dynamic relocs. */
2657
elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
2659
/* Allocate .plt and .got entries, and space for local symbols. */
2660
htab_traverse (htab->loc_hash_table, allocate_local_dynrelocs, info);
2662
if (! ABI_64_P (output_bfd)
2663
&& !htab->is_vxworks
2664
&& elf_hash_table (info)->dynamic_sections_created)
2666
/* Make space for the trailing nop in .plt. */
2667
if (htab->elf.splt->size > 0)
2668
htab->elf.splt->size += 1 * SPARC_INSN_BYTES;
2670
/* If the .got section is more than 0x1000 bytes, we add
2671
0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13
2672
bit relocations have a greater chance of working.
2674
FIXME: Make this optimization work for 64-bit too. */
2675
if (htab->elf.sgot->size >= 0x1000
2676
&& elf_hash_table (info)->hgot->root.u.def.value == 0)
2677
elf_hash_table (info)->hgot->root.u.def.value = 0x1000;
2680
/* The check_relocs and adjust_dynamic_symbol entry points have
2681
determined the sizes of the various dynamic sections. Allocate
2683
for (s = dynobj->sections; s != NULL; s = s->next)
2685
if ((s->flags & SEC_LINKER_CREATED) == 0)
2688
if (s == htab->elf.splt
2689
|| s == htab->elf.sgot
2690
|| s == htab->sdynbss
2691
|| s == htab->elf.iplt
2692
|| s == htab->elf.sgotplt)
2694
/* Strip this section if we don't need it; see the
2697
else if (CONST_STRNEQ (s->name, ".rela"))
2701
/* We use the reloc_count field as a counter if we need
2702
to copy relocs into the output file. */
2708
/* It's not one of our sections. */
2714
/* If we don't need this section, strip it from the
2715
output file. This is mostly to handle .rela.bss and
2716
.rela.plt. We must create both sections in
2717
create_dynamic_sections, because they must be created
2718
before the linker maps input sections to output
2719
sections. The linker does that before
2720
adjust_dynamic_symbol is called, and it is that
2721
function which decides whether anything needs to go
2722
into these sections. */
2723
s->flags |= SEC_EXCLUDE;
2727
if ((s->flags & SEC_HAS_CONTENTS) == 0)
2730
/* Allocate memory for the section contents. Zero the memory
2731
for the benefit of .rela.plt, which has 4 unused entries
2732
at the beginning, and we don't want garbage. */
2733
s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2734
if (s->contents == NULL)
2738
if (elf_hash_table (info)->dynamic_sections_created)
2740
/* Add some entries to the .dynamic section. We fill in the
2741
values later, in _bfd_sparc_elf_finish_dynamic_sections, but we
2742
must add the entries now so that we get the correct size for
2743
the .dynamic section. The DT_DEBUG entry is filled in by the
2744
dynamic linker and used by the debugger. */
2745
#define add_dynamic_entry(TAG, VAL) \
2746
_bfd_elf_add_dynamic_entry (info, TAG, VAL)
2748
if (info->executable)
2750
if (!add_dynamic_entry (DT_DEBUG, 0))
2754
if (htab->elf.srelplt->size != 0)
2756
if (!add_dynamic_entry (DT_PLTGOT, 0)
2757
|| !add_dynamic_entry (DT_PLTRELSZ, 0)
2758
|| !add_dynamic_entry (DT_PLTREL, DT_RELA)
2759
|| !add_dynamic_entry (DT_JMPREL, 0))
2763
if (!add_dynamic_entry (DT_RELA, 0)
2764
|| !add_dynamic_entry (DT_RELASZ, 0)
2765
|| !add_dynamic_entry (DT_RELAENT,
2766
SPARC_ELF_RELA_BYTES (htab)))
2769
/* If any dynamic relocs apply to a read-only section,
2770
then we need a DT_TEXTREL entry. */
2771
if ((info->flags & DF_TEXTREL) == 0)
2772
elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
2774
if (info->flags & DF_TEXTREL)
2776
if (!add_dynamic_entry (DT_TEXTREL, 0))
2780
if (ABI_64_P (output_bfd))
2783
struct _bfd_sparc_elf_app_reg * app_regs;
2784
struct elf_strtab_hash *dynstr;
2785
struct elf_link_hash_table *eht = elf_hash_table (info);
2787
/* Add dynamic STT_REGISTER symbols and corresponding DT_SPARC_REGISTER
2788
entries if needed. */
2789
app_regs = _bfd_sparc_elf_hash_table (info)->app_regs;
2790
dynstr = eht->dynstr;
2792
for (reg = 0; reg < 4; reg++)
2793
if (app_regs [reg].name != NULL)
2795
struct elf_link_local_dynamic_entry *entry, *e;
2797
if (!add_dynamic_entry (DT_SPARC_REGISTER, 0))
2800
entry = (struct elf_link_local_dynamic_entry *)
2801
bfd_hash_allocate (&info->hash->table, sizeof (*entry));
2805
/* We cheat here a little bit: the symbol will not be local, so we
2806
put it at the end of the dynlocal linked list. We will fix it
2807
later on, as we have to fix other fields anyway. */
2808
entry->isym.st_value = reg < 2 ? reg + 2 : reg + 4;
2809
entry->isym.st_size = 0;
2810
if (*app_regs [reg].name != '\0')
2812
= _bfd_elf_strtab_add (dynstr, app_regs[reg].name, FALSE);
2814
entry->isym.st_name = 0;
2815
entry->isym.st_other = 0;
2816
entry->isym.st_info = ELF_ST_INFO (app_regs [reg].bind,
2818
entry->isym.st_shndx = app_regs [reg].shndx;
2819
entry->isym.st_target_internal = 0;
2821
entry->input_bfd = output_bfd;
2822
entry->input_indx = -1;
2824
if (eht->dynlocal == NULL)
2825
eht->dynlocal = entry;
2828
for (e = eht->dynlocal; e->next; e = e->next)
2835
if (htab->is_vxworks
2836
&& !elf_vxworks_add_dynamic_entries (output_bfd, info))
2839
#undef add_dynamic_entry
2845
_bfd_sparc_elf_new_section_hook (bfd *abfd, asection *sec)
2847
if (!sec->used_by_bfd)
2849
struct _bfd_sparc_elf_section_data *sdata;
2850
bfd_size_type amt = sizeof (*sdata);
2852
sdata = bfd_zalloc (abfd, amt);
2855
sec->used_by_bfd = sdata;
2858
return _bfd_elf_new_section_hook (abfd, sec);
2862
_bfd_sparc_elf_relax_section (bfd *abfd ATTRIBUTE_UNUSED,
2863
struct bfd_section *section,
2864
struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
2867
if (link_info->relocatable)
2868
(*link_info->callbacks->einfo)
2869
(_("%P%F: --relax and -r may not be used together\n"));
2872
sec_do_relax (section) = 1;
2876
/* Return the base VMA address which should be subtracted from real addresses
2877
when resolving @dtpoff relocation.
2878
This is PT_TLS segment p_vaddr. */
2881
dtpoff_base (struct bfd_link_info *info)
2883
/* If tls_sec is NULL, we should have signalled an error already. */
2884
if (elf_hash_table (info)->tls_sec == NULL)
2886
return elf_hash_table (info)->tls_sec->vma;
2889
/* Return the relocation value for @tpoff relocation
2890
if STT_TLS virtual address is ADDRESS. */
2893
tpoff (struct bfd_link_info *info, bfd_vma address)
2895
struct elf_link_hash_table *htab = elf_hash_table (info);
2896
const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
2897
bfd_vma static_tls_size;
2899
/* If tls_sec is NULL, we should have signalled an error already. */
2900
if (htab->tls_sec == NULL)
2903
/* Consider special static TLS alignment requirements. */
2904
static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
2905
return address - static_tls_size - htab->tls_sec->vma;
2908
/* Return the relocation value for a %gdop relocation. */
2911
gdopoff (struct bfd_link_info *info, bfd_vma address)
2913
struct elf_link_hash_table *htab = elf_hash_table (info);
2916
got_base = (htab->hgot->root.u.def.value
2917
+ htab->hgot->root.u.def.section->output_offset
2918
+ htab->hgot->root.u.def.section->output_section->vma);
2920
return address - got_base;
2923
/* Relocate a SPARC ELF section. */
2926
_bfd_sparc_elf_relocate_section (bfd *output_bfd,
2927
struct bfd_link_info *info,
2929
asection *input_section,
2931
Elf_Internal_Rela *relocs,
2932
Elf_Internal_Sym *local_syms,
2933
asection **local_sections)
2935
struct _bfd_sparc_elf_link_hash_table *htab;
2936
Elf_Internal_Shdr *symtab_hdr;
2937
struct elf_link_hash_entry **sym_hashes;
2938
bfd_vma *local_got_offsets;
2941
Elf_Internal_Rela *rel;
2942
Elf_Internal_Rela *relend;
2944
bfd_boolean is_vxworks_tls;
2946
htab = _bfd_sparc_elf_hash_table (info);
2947
BFD_ASSERT (htab != NULL);
2948
symtab_hdr = &elf_symtab_hdr (input_bfd);
2949
sym_hashes = elf_sym_hashes (input_bfd);
2950
local_got_offsets = elf_local_got_offsets (input_bfd);
2952
if (elf_hash_table (info)->hgot == NULL)
2955
got_base = elf_hash_table (info)->hgot->root.u.def.value;
2957
sreloc = elf_section_data (input_section)->sreloc;
2958
/* We have to handle relocations in vxworks .tls_vars sections
2959
specially, because the dynamic loader is 'weird'. */
2960
is_vxworks_tls = (htab->is_vxworks && info->shared
2961
&& !strcmp (input_section->output_section->name,
2965
if (ABI_64_P (output_bfd))
2966
num_relocs = NUM_SHDR_ENTRIES (_bfd_elf_single_rel_hdr (input_section));
2968
num_relocs = input_section->reloc_count;
2969
relend = relocs + num_relocs;
2970
for (; rel < relend; rel++)
2972
int r_type, tls_type;
2973
reloc_howto_type *howto;
2974
unsigned long r_symndx;
2975
struct elf_link_hash_entry *h;
2976
Elf_Internal_Sym *sym;
2978
bfd_vma relocation, off;
2979
bfd_reloc_status_type r;
2980
bfd_boolean is_plt = FALSE;
2981
bfd_boolean unresolved_reloc;
2983
r_type = SPARC_ELF_R_TYPE (rel->r_info);
2984
if (r_type == R_SPARC_GNU_VTINHERIT
2985
|| r_type == R_SPARC_GNU_VTENTRY)
2988
if (r_type < 0 || r_type >= (int) R_SPARC_max_std)
2990
bfd_set_error (bfd_error_bad_value);
2993
howto = _bfd_sparc_elf_howto_table + r_type;
2995
r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
2999
unresolved_reloc = FALSE;
3000
if (r_symndx < symtab_hdr->sh_info)
3002
sym = local_syms + r_symndx;
3003
sec = local_sections[r_symndx];
3004
relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
3006
if (!info->relocatable
3007
&& ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
3009
/* Relocate against local STT_GNU_IFUNC symbol. */
3010
h = elf_sparc_get_local_sym_hash (htab, input_bfd,
3015
/* Set STT_GNU_IFUNC symbol value. */
3016
h->root.u.def.value = sym->st_value;
3017
h->root.u.def.section = sec;
3024
RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3025
r_symndx, symtab_hdr, sym_hashes,
3027
unresolved_reloc, warned);
3030
/* To avoid generating warning messages about truncated
3031
relocations, set the relocation's address to be the same as
3032
the start of this section. */
3033
if (input_section->output_section != NULL)
3034
relocation = input_section->output_section->vma;
3040
if (sec != NULL && discarded_section (sec))
3041
RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
3042
rel, 1, relend, howto, 0, contents);
3044
if (info->relocatable)
3048
&& h->type == STT_GNU_IFUNC
3054
if ((input_section->flags & SEC_ALLOC) == 0
3055
|| h->plt.offset == (bfd_vma) -1)
3058
plt_sec = htab->elf.splt;
3060
plt_sec =htab->elf.iplt;
3064
case R_SPARC_GOTDATA_OP:
3067
case R_SPARC_GOTDATA_OP_HIX22:
3068
case R_SPARC_GOTDATA_OP_LOX10:
3069
r_type = (r_type == R_SPARC_GOTDATA_OP_HIX22
3072
howto = _bfd_sparc_elf_howto_table + r_type;
3078
if (htab->elf.sgot == NULL)
3080
off = h->got.offset;
3081
if (off == (bfd_vma) -1)
3083
relocation = htab->elf.sgot->output_offset + off - got_base;
3086
case R_SPARC_WPLT30:
3087
case R_SPARC_WDISP30:
3088
relocation = (plt_sec->output_section->vma
3089
+ plt_sec->output_offset + h->plt.offset);
3094
if (info->shared && h->non_got_ref)
3096
Elf_Internal_Rela outrel;
3099
offset = _bfd_elf_section_offset (output_bfd, info,
3102
if (offset == (bfd_vma) -1
3103
|| offset == (bfd_vma) -2)
3106
outrel.r_offset = (input_section->output_section->vma
3107
+ input_section->output_offset
3110
if (h->dynindx == -1
3112
|| info->executable)
3114
outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
3115
0, R_SPARC_IRELATIVE);
3116
outrel.r_addend = relocation + rel->r_addend;
3120
if (h->dynindx == -1)
3122
outrel.r_info = SPARC_ELF_R_INFO (htab, rel, h->dynindx, r_type);
3123
outrel.r_addend = rel->r_addend;
3126
sparc_elf_append_rela (output_bfd, sreloc, &outrel);
3130
relocation = (plt_sec->output_section->vma
3131
+ plt_sec->output_offset + h->plt.offset);
3136
/* We should only see such relocs in static links. */
3139
relocation = (plt_sec->output_section->vma
3140
+ plt_sec->output_offset + h->plt.offset);
3144
if (h->root.root.string)
3145
name = h->root.root.string;
3147
name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3149
(*_bfd_error_handler)
3150
(_("%B: relocation %s against STT_GNU_IFUNC "
3151
"symbol `%s' isn't handled by %s"), input_bfd,
3152
_bfd_sparc_elf_howto_table[r_type].name,
3153
name, __FUNCTION__);
3154
bfd_set_error (bfd_error_bad_value);
3161
case R_SPARC_GOTDATA_OP_HIX22:
3162
case R_SPARC_GOTDATA_OP_LOX10:
3163
if (SYMBOL_REFERENCES_LOCAL (info, h))
3164
r_type = (r_type == R_SPARC_GOTDATA_OP_HIX22
3165
? R_SPARC_GOTDATA_HIX22
3166
: R_SPARC_GOTDATA_LOX10);
3168
r_type = (r_type == R_SPARC_GOTDATA_OP_HIX22
3171
howto = _bfd_sparc_elf_howto_table + r_type;
3174
case R_SPARC_GOTDATA_OP:
3175
if (SYMBOL_REFERENCES_LOCAL (info, h))
3177
bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3179
/* {ld,ldx} [%rs1 + %rs2], %rd --> add %rs1, %rs2, %rd */
3180
relocation = 0x80000000 | (insn & 0x3e07c01f);
3181
bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3188
case R_SPARC_GOTDATA_HIX22:
3189
case R_SPARC_GOTDATA_LOX10:
3190
relocation = gdopoff (info, relocation);
3196
/* Relocation is to the entry for this symbol in the global
3198
if (htab->elf.sgot == NULL)
3205
off = h->got.offset;
3206
BFD_ASSERT (off != (bfd_vma) -1);
3207
dyn = elf_hash_table (info)->dynamic_sections_created;
3209
if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3211
&& SYMBOL_REFERENCES_LOCAL (info, h)))
3213
/* This is actually a static link, or it is a
3214
-Bsymbolic link and the symbol is defined
3215
locally, or the symbol was forced to be local
3216
because of a version file. We must initialize
3217
this entry in the global offset table. Since the
3218
offset must always be a multiple of 8 for 64-bit
3219
and 4 for 32-bit, we use the least significant bit
3220
to record whether we have initialized it already.
3222
When doing a dynamic link, we create a .rela.got
3223
relocation entry to initialize the value. This
3224
is done in the finish_dynamic_symbol routine. */
3229
SPARC_ELF_PUT_WORD (htab, output_bfd, relocation,
3230
htab->elf.sgot->contents + off);
3235
unresolved_reloc = FALSE;
3239
BFD_ASSERT (local_got_offsets != NULL
3240
&& local_got_offsets[r_symndx] != (bfd_vma) -1);
3242
off = local_got_offsets[r_symndx];
3244
/* The offset must always be a multiple of 8 on 64-bit and
3245
4 on 32-bit. We use the least significant bit to record
3246
whether we have already processed this entry. */
3255
Elf_Internal_Rela outrel;
3257
/* We need to generate a R_SPARC_RELATIVE reloc
3258
for the dynamic linker. */
3259
s = htab->elf.srelgot;
3260
BFD_ASSERT (s != NULL);
3262
outrel.r_offset = (htab->elf.sgot->output_section->vma
3263
+ htab->elf.sgot->output_offset
3265
outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
3266
0, R_SPARC_RELATIVE);
3267
outrel.r_addend = relocation;
3269
sparc_elf_append_rela (output_bfd, s, &outrel);
3272
SPARC_ELF_PUT_WORD (htab, output_bfd, relocation,
3273
htab->elf.sgot->contents + off);
3274
local_got_offsets[r_symndx] |= 1;
3277
relocation = htab->elf.sgot->output_offset + off - got_base;
3282
if (h == NULL || h->plt.offset == (bfd_vma) -1)
3284
r_type = (r_type == R_SPARC_PLT32) ? R_SPARC_32 : R_SPARC_64;
3289
case R_SPARC_WPLT30:
3290
case R_SPARC_HIPLT22:
3291
case R_SPARC_LOPLT10:
3292
case R_SPARC_PCPLT32:
3293
case R_SPARC_PCPLT22:
3294
case R_SPARC_PCPLT10:
3296
/* Relocation is to the entry for this symbol in the
3297
procedure linkage table. */
3299
if (! ABI_64_P (output_bfd))
3301
/* The Solaris native assembler will generate a WPLT30 reloc
3302
for a local symbol if you assemble a call from one
3303
section to another when using -K pic. We treat it as
3308
/* PR 7027: We need similar behaviour for 64-bit binaries. */
3309
else if (r_type == R_SPARC_WPLT30 && h == NULL)
3313
BFD_ASSERT (h != NULL);
3316
if (h->plt.offset == (bfd_vma) -1 || htab->elf.splt == NULL)
3318
/* We didn't make a PLT entry for this symbol. This
3319
happens when statically linking PIC code, or when
3320
using -Bsymbolic. */
3324
relocation = (htab->elf.splt->output_section->vma
3325
+ htab->elf.splt->output_offset
3327
unresolved_reloc = FALSE;
3328
if (r_type == R_SPARC_PLT32 || r_type == R_SPARC_PLT64)
3330
r_type = r_type == R_SPARC_PLT32 ? R_SPARC_32 : R_SPARC_64;
3338
case R_SPARC_PC_HH22:
3339
case R_SPARC_PC_HM10:
3340
case R_SPARC_PC_LM22:
3342
&& strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3346
case R_SPARC_DISP16:
3347
case R_SPARC_DISP32:
3348
case R_SPARC_DISP64:
3349
case R_SPARC_WDISP30:
3350
case R_SPARC_WDISP22:
3351
case R_SPARC_WDISP19:
3352
case R_SPARC_WDISP16:
3353
case R_SPARC_WDISP10:
3381
if ((input_section->flags & SEC_ALLOC) == 0
3387
|| ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3388
|| h->root.type != bfd_link_hash_undefweak)
3389
&& (! howto->pc_relative
3390
|| !SYMBOL_CALLS_LOCAL (info, h)))
3397
|| h->root.type == bfd_link_hash_undefweak
3398
|| h->root.type == bfd_link_hash_undefined)))
3400
Elf_Internal_Rela outrel;
3401
bfd_boolean skip, relocate = FALSE;
3403
/* When generating a shared object, these relocations
3404
are copied into the output file to be resolved at run
3407
BFD_ASSERT (sreloc != NULL);
3412
_bfd_elf_section_offset (output_bfd, info, input_section,
3414
if (outrel.r_offset == (bfd_vma) -1)
3416
else if (outrel.r_offset == (bfd_vma) -2)
3417
skip = TRUE, relocate = TRUE;
3418
outrel.r_offset += (input_section->output_section->vma
3419
+ input_section->output_offset);
3421
/* Optimize unaligned reloc usage now that we know where
3422
it finally resides. */
3426
if (outrel.r_offset & 1)
3427
r_type = R_SPARC_UA16;
3430
if (!(outrel.r_offset & 1))
3431
r_type = R_SPARC_16;
3434
if (outrel.r_offset & 3)
3435
r_type = R_SPARC_UA32;
3438
if (!(outrel.r_offset & 3))
3439
r_type = R_SPARC_32;
3442
if (outrel.r_offset & 7)
3443
r_type = R_SPARC_UA64;
3446
if (!(outrel.r_offset & 7))
3447
r_type = R_SPARC_64;
3450
case R_SPARC_DISP16:
3451
case R_SPARC_DISP32:
3452
case R_SPARC_DISP64:
3453
/* If the symbol is not dynamic, we should not keep
3454
a dynamic relocation. But an .rela.* slot has been
3455
allocated for it, output R_SPARC_NONE.
3456
FIXME: Add code tracking needed dynamic relocs as
3458
if (h->dynindx == -1)
3459
skip = TRUE, relocate = TRUE;
3464
memset (&outrel, 0, sizeof outrel);
3465
/* h->dynindx may be -1 if the symbol was marked to
3467
else if (h != NULL &&
3471
|| !SYMBOLIC_BIND (info, h)
3472
|| !h->def_regular))
3474
BFD_ASSERT (h->dynindx != -1);
3475
outrel.r_info = SPARC_ELF_R_INFO (htab, rel, h->dynindx, r_type);
3476
outrel.r_addend = rel->r_addend;
3480
if (r_type == R_SPARC_32 || r_type == R_SPARC_64)
3482
outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
3483
0, R_SPARC_RELATIVE);
3484
outrel.r_addend = relocation + rel->r_addend;
3490
outrel.r_addend = relocation + rel->r_addend;
3493
sec = htab->elf.splt;
3495
if (bfd_is_abs_section (sec))
3497
else if (sec == NULL || sec->owner == NULL)
3499
bfd_set_error (bfd_error_bad_value);
3506
/* We are turning this relocation into one
3507
against a section symbol. It would be
3508
proper to subtract the symbol's value,
3509
osec->vma, from the emitted reloc addend,
3510
but ld.so expects buggy relocs. */
3511
osec = sec->output_section;
3512
indx = elf_section_data (osec)->dynindx;
3516
osec = htab->elf.text_index_section;
3517
indx = elf_section_data (osec)->dynindx;
3520
/* FIXME: we really should be able to link non-pic
3521
shared libraries. */
3525
(*_bfd_error_handler)
3526
(_("%B: probably compiled without -fPIC?"),
3528
bfd_set_error (bfd_error_bad_value);
3533
outrel.r_info = SPARC_ELF_R_INFO (htab, rel, indx,
3538
sparc_elf_append_rela (output_bfd, sreloc, &outrel);
3540
/* This reloc will be computed at runtime, so there's no
3541
need to do anything now. */
3547
case R_SPARC_TLS_GD_HI22:
3548
if (! ABI_64_P (input_bfd)
3549
&& ! _bfd_sparc_elf_tdata (input_bfd)->has_tlsgd)
3551
/* R_SPARC_REV32 used the same reloc number as
3552
R_SPARC_TLS_GD_HI22. */
3553
r_type = R_SPARC_REV32;
3558
case R_SPARC_TLS_GD_LO10:
3559
case R_SPARC_TLS_IE_HI22:
3560
case R_SPARC_TLS_IE_LO10:
3561
r_type = sparc_elf_tls_transition (info, input_bfd, r_type, h == NULL);
3562
tls_type = GOT_UNKNOWN;
3563
if (h == NULL && local_got_offsets)
3564
tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3567
tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3568
if (!info->shared && h->dynindx == -1 && tls_type == GOT_TLS_IE)
3569
switch (SPARC_ELF_R_TYPE (rel->r_info))
3571
case R_SPARC_TLS_GD_HI22:
3572
case R_SPARC_TLS_IE_HI22:
3573
r_type = R_SPARC_TLS_LE_HIX22;
3576
r_type = R_SPARC_TLS_LE_LOX10;
3580
if (tls_type == GOT_TLS_IE)
3583
case R_SPARC_TLS_GD_HI22:
3584
r_type = R_SPARC_TLS_IE_HI22;
3586
case R_SPARC_TLS_GD_LO10:
3587
r_type = R_SPARC_TLS_IE_LO10;
3591
if (r_type == R_SPARC_TLS_LE_HIX22)
3593
relocation = tpoff (info, relocation);
3596
if (r_type == R_SPARC_TLS_LE_LOX10)
3598
/* Change add into xor. */
3599
relocation = tpoff (info, relocation);
3600
bfd_put_32 (output_bfd, (bfd_get_32 (input_bfd,
3601
contents + rel->r_offset)
3602
| 0x80182000), contents + rel->r_offset);
3608
off = h->got.offset;
3613
BFD_ASSERT (local_got_offsets != NULL);
3614
off = local_got_offsets[r_symndx];
3615
local_got_offsets[r_symndx] |= 1;
3619
if (htab->elf.sgot == NULL)
3626
Elf_Internal_Rela outrel;
3629
if (htab->elf.srelgot == NULL)
3632
SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3633
htab->elf.sgot->contents + off);
3634
outrel.r_offset = (htab->elf.sgot->output_section->vma
3635
+ htab->elf.sgot->output_offset + off);
3636
indx = h && h->dynindx != -1 ? h->dynindx : 0;
3637
if (r_type == R_SPARC_TLS_IE_HI22
3638
|| r_type == R_SPARC_TLS_IE_LO10)
3639
dr_type = SPARC_ELF_TPOFF_RELOC (htab);
3641
dr_type = SPARC_ELF_DTPMOD_RELOC (htab);
3642
if (dr_type == SPARC_ELF_TPOFF_RELOC (htab) && indx == 0)
3643
outrel.r_addend = relocation - dtpoff_base (info);
3645
outrel.r_addend = 0;
3646
outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx, dr_type);
3647
sparc_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel);
3649
if (r_type == R_SPARC_TLS_GD_HI22
3650
|| r_type == R_SPARC_TLS_GD_LO10)
3654
BFD_ASSERT (! unresolved_reloc);
3655
SPARC_ELF_PUT_WORD (htab, output_bfd,
3656
relocation - dtpoff_base (info),
3657
(htab->elf.sgot->contents + off
3658
+ SPARC_ELF_WORD_BYTES (htab)));
3662
SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3663
(htab->elf.sgot->contents + off
3664
+ SPARC_ELF_WORD_BYTES (htab)));
3665
outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx,
3666
SPARC_ELF_DTPOFF_RELOC (htab));
3667
outrel.r_offset += SPARC_ELF_WORD_BYTES (htab);
3668
sparc_elf_append_rela (output_bfd, htab->elf.srelgot,
3672
else if (dr_type == SPARC_ELF_DTPMOD_RELOC (htab))
3674
SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3675
(htab->elf.sgot->contents + off
3676
+ SPARC_ELF_WORD_BYTES (htab)));
3680
if (off >= (bfd_vma) -2)
3683
relocation = htab->elf.sgot->output_offset + off - got_base;
3684
unresolved_reloc = FALSE;
3685
howto = _bfd_sparc_elf_howto_table + r_type;
3688
case R_SPARC_TLS_LDM_HI22:
3689
case R_SPARC_TLS_LDM_LO10:
3692
bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3695
off = htab->tls_ldm_got.offset;
3696
htab->tls_ldm_got.offset |= 1;
3697
goto r_sparc_tlsldm;
3699
case R_SPARC_TLS_LDO_HIX22:
3700
case R_SPARC_TLS_LDO_LOX10:
3703
relocation -= dtpoff_base (info);
3707
r_type = (r_type == R_SPARC_TLS_LDO_HIX22
3708
? R_SPARC_TLS_LE_HIX22 : R_SPARC_TLS_LE_LOX10);
3711
case R_SPARC_TLS_LE_HIX22:
3712
case R_SPARC_TLS_LE_LOX10:
3715
Elf_Internal_Rela outrel;
3718
BFD_ASSERT (sreloc != NULL);
3721
_bfd_elf_section_offset (output_bfd, info, input_section,
3723
if (outrel.r_offset == (bfd_vma) -1)
3725
else if (outrel.r_offset == (bfd_vma) -2)
3727
outrel.r_offset += (input_section->output_section->vma
3728
+ input_section->output_offset);
3730
memset (&outrel, 0, sizeof outrel);
3733
outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, r_type);
3734
outrel.r_addend = relocation - dtpoff_base (info)
3738
sparc_elf_append_rela (output_bfd, sreloc, &outrel);
3741
relocation = tpoff (info, relocation);
3744
case R_SPARC_TLS_LDM_CALL:
3748
bfd_put_32 (output_bfd, 0x90100000, contents + rel->r_offset);
3753
case R_SPARC_TLS_GD_CALL:
3754
tls_type = GOT_UNKNOWN;
3755
if (h == NULL && local_got_offsets)
3756
tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3758
tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3760
|| (r_type == R_SPARC_TLS_GD_CALL && tls_type == GOT_TLS_IE))
3762
Elf_Internal_Rela *rel2;
3765
if (!info->shared && (h == NULL || h->dynindx == -1))
3768
bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3773
if (rel + 1 < relend
3774
&& SPARC_ELF_R_TYPE (rel[1].r_info) == R_SPARC_TLS_GD_ADD
3775
&& rel[1].r_offset == rel->r_offset + 4
3776
&& SPARC_ELF_R_SYMNDX (htab, rel[1].r_info) == r_symndx
3777
&& (((insn = bfd_get_32 (input_bfd,
3778
contents + rel[1].r_offset))
3779
>> 25) & 0x1f) == 8)
3782
call __tls_get_addr, %tgd_call(foo)
3783
add %reg1, %reg2, %o0, %tgd_add(foo)
3784
and change it into IE:
3785
{ld,ldx} [%reg1 + %reg2], %o0, %tie_ldx(foo)
3786
add %g7, %o0, %o0, %tie_add(foo).
3787
add is 0x80000000 | (rd << 25) | (rs1 << 14) | rs2,
3788
ld is 0xc0000000 | (rd << 25) | (rs1 << 14) | rs2,
3789
ldx is 0xc0580000 | (rd << 25) | (rs1 << 14) | rs2. */
3790
bfd_put_32 (output_bfd, insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000),
3791
contents + rel->r_offset);
3792
bfd_put_32 (output_bfd, 0x9001c008,
3793
contents + rel->r_offset + 4);
3798
/* We cannot just overwrite the delay slot instruction,
3799
as it might be what puts the %o0 argument to
3800
__tls_get_addr into place. So we have to transpose
3801
the delay slot with the add we patch in. */
3802
insn = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
3803
bfd_put_32 (output_bfd, insn,
3804
contents + rel->r_offset);
3805
bfd_put_32 (output_bfd, 0x9001c008,
3806
contents + rel->r_offset + 4);
3809
while ((rel2 = sparc_elf_find_reloc_at_ofs (rel2 + 1, relend,
3813
/* If the instruction we moved has a relocation attached to
3814
it, adjust the offset so that it will apply to the correct
3816
rel2->r_offset -= 4;
3821
h = (struct elf_link_hash_entry *)
3822
bfd_link_hash_lookup (info->hash, "__tls_get_addr", FALSE,
3824
BFD_ASSERT (h != NULL);
3825
r_type = R_SPARC_WPLT30;
3826
howto = _bfd_sparc_elf_howto_table + r_type;
3827
goto r_sparc_wplt30;
3829
case R_SPARC_TLS_GD_ADD:
3830
tls_type = GOT_UNKNOWN;
3831
if (h == NULL && local_got_offsets)
3832
tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3834
tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3835
if (! info->shared || tls_type == GOT_TLS_IE)
3837
/* add %reg1, %reg2, %reg3, %tgd_add(foo)
3839
{ld,ldx} [%reg1 + %reg2], %reg3, %tie_ldx(foo)
3841
add %g7, %reg2, %reg3. */
3842
bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3843
if ((h != NULL && h->dynindx != -1) || info->shared)
3844
relocation = insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000);
3846
relocation = (insn & ~0x7c000) | 0x1c000;
3847
bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3851
case R_SPARC_TLS_LDM_ADD:
3853
bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3856
case R_SPARC_TLS_LDO_ADD:
3859
/* Change rs1 into %g7. */
3860
bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3861
insn = (insn & ~0x7c000) | 0x1c000;
3862
bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3866
case R_SPARC_TLS_IE_LD:
3867
case R_SPARC_TLS_IE_LDX:
3868
if (! info->shared && (h == NULL || h->dynindx == -1))
3870
bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3871
int rs2 = insn & 0x1f;
3872
int rd = (insn >> 25) & 0x1f;
3875
relocation = SPARC_NOP;
3877
relocation = 0x80100000 | (insn & 0x3e00001f);
3878
bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3882
case R_SPARC_TLS_IE_ADD:
3883
/* Totally useless relocation. */
3886
case R_SPARC_TLS_DTPOFF32:
3887
case R_SPARC_TLS_DTPOFF64:
3888
relocation -= dtpoff_base (info);
3895
/* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3896
because such sections are not SEC_ALLOC and thus ld.so will
3897
not process them. */
3898
if (unresolved_reloc
3899
&& !((input_section->flags & SEC_DEBUGGING) != 0
3901
&& _bfd_elf_section_offset (output_bfd, info, input_section,
3902
rel->r_offset) != (bfd_vma) -1)
3903
(*_bfd_error_handler)
3904
(_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3907
(long) rel->r_offset,
3909
h->root.root.string);
3911
r = bfd_reloc_continue;
3912
if (r_type == R_SPARC_OLO10)
3916
if (! ABI_64_P (output_bfd))
3919
relocation += rel->r_addend;
3920
relocation = (relocation & 0x3ff) + ELF64_R_TYPE_DATA (rel->r_info);
3922
x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3923
x = (x & ~(bfd_vma) 0x1fff) | (relocation & 0x1fff);
3924
bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3926
r = bfd_check_overflow (howto->complain_on_overflow,
3927
howto->bitsize, howto->rightshift,
3928
bfd_arch_bits_per_address (input_bfd),
3931
else if (r_type == R_SPARC_WDISP16)
3935
relocation += rel->r_addend;
3936
relocation -= (input_section->output_section->vma
3937
+ input_section->output_offset);
3938
relocation -= rel->r_offset;
3940
x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3941
x |= ((((relocation >> 2) & 0xc000) << 6)
3942
| ((relocation >> 2) & 0x3fff));
3943
bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3945
r = bfd_check_overflow (howto->complain_on_overflow,
3946
howto->bitsize, howto->rightshift,
3947
bfd_arch_bits_per_address (input_bfd),
3950
else if (r_type == R_SPARC_WDISP10)
3954
relocation += rel->r_addend;
3955
relocation -= (input_section->output_section->vma
3956
+ input_section->output_offset);
3957
relocation -= rel->r_offset;
3959
x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3960
x |= ((((relocation >> 2) & 0x300) << 11)
3961
| (((relocation >> 2) & 0xff) << 5));
3962
bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3964
r = bfd_check_overflow (howto->complain_on_overflow,
3965
howto->bitsize, howto->rightshift,
3966
bfd_arch_bits_per_address (input_bfd),
3969
else if (r_type == R_SPARC_REV32)
3973
relocation = relocation + rel->r_addend;
3975
x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3977
bfd_putl32 (/*input_bfd,*/ x, contents + rel->r_offset);
3980
else if (r_type == R_SPARC_TLS_LDO_HIX22
3981
|| r_type == R_SPARC_TLS_LE_HIX22)
3985
relocation += rel->r_addend;
3986
if (r_type == R_SPARC_TLS_LE_HIX22)
3987
relocation ^= MINUS_ONE;
3989
x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3990
x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
3991
bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3994
else if (r_type == R_SPARC_TLS_LDO_LOX10
3995
|| r_type == R_SPARC_TLS_LE_LOX10)
3999
relocation += rel->r_addend;
4000
relocation &= 0x3ff;
4001
if (r_type == R_SPARC_TLS_LE_LOX10)
4002
relocation |= 0x1c00;
4004
x = bfd_get_32 (input_bfd, contents + rel->r_offset);
4005
x = (x & ~(bfd_vma) 0x1fff) | relocation;
4006
bfd_put_32 (input_bfd, x, contents + rel->r_offset);
4010
else if (r_type == R_SPARC_HIX22
4011
|| r_type == R_SPARC_GOTDATA_HIX22)
4015
relocation += rel->r_addend;
4016
if (r_type == R_SPARC_HIX22
4017
|| (bfd_signed_vma) relocation < 0)
4018
relocation = relocation ^ MINUS_ONE;
4020
x = bfd_get_32 (input_bfd, contents + rel->r_offset);
4021
x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
4022
bfd_put_32 (input_bfd, x, contents + rel->r_offset);
4024
r = bfd_check_overflow (howto->complain_on_overflow,
4025
howto->bitsize, howto->rightshift,
4026
bfd_arch_bits_per_address (input_bfd),
4029
else if (r_type == R_SPARC_LOX10
4030
|| r_type == R_SPARC_GOTDATA_LOX10)
4034
relocation += rel->r_addend;
4035
if (r_type == R_SPARC_LOX10
4036
|| (bfd_signed_vma) relocation < 0)
4037
relocation = (relocation & 0x3ff) | 0x1c00;
4039
relocation = (relocation & 0x3ff);
4041
x = bfd_get_32 (input_bfd, contents + rel->r_offset);
4042
x = (x & ~(bfd_vma) 0x1fff) | relocation;
4043
bfd_put_32 (input_bfd, x, contents + rel->r_offset);
4047
else if ((r_type == R_SPARC_WDISP30 || r_type == R_SPARC_WPLT30)
4048
&& sec_do_relax (input_section)
4049
&& rel->r_offset + 4 < input_section->size)
4053
#define XCC (2 << 20)
4054
#define COND(x) (((x)&0xf)<<25)
4055
#define CONDA COND(0x8)
4056
#define INSN_BPA (F2(0,1) | CONDA | BPRED | XCC)
4057
#define INSN_BA (F2(0,2) | CONDA)
4058
#define INSN_OR F3(2, 0x2, 0)
4059
#define INSN_NOP F2(0,4)
4063
/* If the instruction is a call with either:
4065
arithmetic instruction with rd == %o7
4066
where rs1 != %o7 and rs2 if it is register != %o7
4067
then we can optimize if the call destination is near
4068
by changing the call into a branch always. */
4069
x = bfd_get_32 (input_bfd, contents + rel->r_offset);
4070
y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
4071
if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2))
4073
if (((y & OP3(~0)) == OP3(0x3d) /* restore */
4074
|| ((y & OP3(0x28)) == 0 /* arithmetic */
4075
&& (y & RD(~0)) == RD(O7)))
4076
&& (y & RS1(~0)) != RS1(O7)
4078
|| (y & RS2(~0)) != RS2(O7)))
4082
reloc = relocation + rel->r_addend - rel->r_offset;
4083
reloc -= (input_section->output_section->vma
4084
+ input_section->output_offset);
4086
/* Ensure the branch fits into simm22. */
4087
if ((reloc & 3) == 0
4088
&& ((reloc & ~(bfd_vma)0x7fffff) == 0
4089
|| ((reloc | 0x7fffff) == ~(bfd_vma)0)))
4093
/* Check whether it fits into simm19. */
4094
if (((reloc & 0x3c0000) == 0
4095
|| (reloc & 0x3c0000) == 0x3c0000)
4096
&& (ABI_64_P (output_bfd)
4097
|| elf_elfheader (output_bfd)->e_flags & EF_SPARC_32PLUS))
4098
x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */
4100
x = INSN_BA | (reloc & 0x3fffff); /* ba */
4101
bfd_put_32 (input_bfd, x, contents + rel->r_offset);
4103
if (rel->r_offset >= 4
4104
&& (y & (0xffffffff ^ RS1(~0)))
4105
== (INSN_OR | RD(O7) | RS2(G0)))
4110
z = bfd_get_32 (input_bfd,
4111
contents + rel->r_offset - 4);
4112
if ((z & (0xffffffff ^ RD(~0)))
4113
!= (INSN_OR | RS1(O7) | RS2(G0)))
4121
If call foo was replaced with ba, replace
4122
or %rN, %g0, %o7 with nop. */
4124
reg = (y & RS1(~0)) >> 14;
4125
if (reg != ((z & RD(~0)) >> 25)
4126
|| reg == G0 || reg == O7)
4129
bfd_put_32 (input_bfd, (bfd_vma) INSN_NOP,
4130
contents + rel->r_offset + 4);
4138
if (r == bfd_reloc_continue)
4141
r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4142
contents, rel->r_offset,
4143
relocation, rel->r_addend);
4145
if (r != bfd_reloc_ok)
4150
case bfd_reloc_outofrange:
4152
case bfd_reloc_overflow:
4156
/* The Solaris native linker silently disregards overflows.
4157
We don't, but this breaks stabs debugging info, whose
4158
relocations are only 32-bits wide. Ignore overflows in
4159
this case and also for discarded entries. */
4160
if ((r_type == R_SPARC_32
4161
|| r_type == R_SPARC_UA32
4162
|| r_type == R_SPARC_DISP32)
4163
&& (((input_section->flags & SEC_DEBUGGING) != 0
4164
&& strcmp (bfd_section_name (input_bfd,
4167
|| _bfd_elf_section_offset (output_bfd, info,
4175
/* Assume this is a call protected by other code that
4176
detect the symbol is undefined. If this is the case,
4177
we can safely ignore the overflow. If not, the
4178
program is hosed anyway, and a little warning isn't
4180
if (h->root.type == bfd_link_hash_undefweak
4181
&& howto->pc_relative)
4188
name = bfd_elf_string_from_elf_section (input_bfd,
4189
symtab_hdr->sh_link,
4194
name = bfd_section_name (input_bfd, sec);
4196
if (! ((*info->callbacks->reloc_overflow)
4197
(info, (h ? &h->root : NULL), name, howto->name,
4198
(bfd_vma) 0, input_bfd, input_section,
4210
/* Build a VxWorks PLT entry. PLT_INDEX is the index of the PLT entry
4211
and PLT_OFFSET is the byte offset from the start of .plt. GOT_OFFSET
4212
is the offset of the associated .got.plt entry from
4213
_GLOBAL_OFFSET_TABLE_. */
4216
sparc_vxworks_build_plt_entry (bfd *output_bfd, struct bfd_link_info *info,
4217
bfd_vma plt_offset, bfd_vma plt_index,
4221
const bfd_vma *plt_entry;
4222
struct _bfd_sparc_elf_link_hash_table *htab;
4224
Elf_Internal_Rela rela;
4226
htab = _bfd_sparc_elf_hash_table (info);
4227
BFD_ASSERT (htab != NULL);
4231
plt_entry = sparc_vxworks_shared_plt_entry;
4236
plt_entry = sparc_vxworks_exec_plt_entry;
4237
got_base = (htab->elf.hgot->root.u.def.value
4238
+ htab->elf.hgot->root.u.def.section->output_offset
4239
+ htab->elf.hgot->root.u.def.section->output_section->vma);
4242
/* Fill in the entry in the procedure linkage table. */
4243
bfd_put_32 (output_bfd, plt_entry[0] + ((got_base + got_offset) >> 10),
4244
htab->elf.splt->contents + plt_offset);
4245
bfd_put_32 (output_bfd, plt_entry[1] + ((got_base + got_offset) & 0x3ff),
4246
htab->elf.splt->contents + plt_offset + 4);
4247
bfd_put_32 (output_bfd, plt_entry[2],
4248
htab->elf.splt->contents + plt_offset + 8);
4249
bfd_put_32 (output_bfd, plt_entry[3],
4250
htab->elf.splt->contents + plt_offset + 12);
4251
bfd_put_32 (output_bfd, plt_entry[4],
4252
htab->elf.splt->contents + plt_offset + 16);
4253
bfd_put_32 (output_bfd, plt_entry[5] + (plt_index >> 10),
4254
htab->elf.splt->contents + plt_offset + 20);
4255
/* PC-relative displacement for a branch to the start of
4257
bfd_put_32 (output_bfd, plt_entry[6] + (((-plt_offset - 24) >> 2)
4259
htab->elf.splt->contents + plt_offset + 24);
4260
bfd_put_32 (output_bfd, plt_entry[7] + (plt_index & 0x3ff),
4261
htab->elf.splt->contents + plt_offset + 28);
4263
/* Fill in the .got.plt entry, pointing initially at the
4264
second half of the PLT entry. */
4265
BFD_ASSERT (htab->elf.sgotplt != NULL);
4266
bfd_put_32 (output_bfd,
4267
htab->elf.splt->output_section->vma
4268
+ htab->elf.splt->output_offset
4270
htab->elf.sgotplt->contents + got_offset);
4272
/* Add relocations to .rela.plt.unloaded. */
4275
loc = (htab->srelplt2->contents
4276
+ (2 + 3 * plt_index) * sizeof (Elf32_External_Rela));
4278
/* Relocate the initial sethi. */
4279
rela.r_offset = (htab->elf.splt->output_section->vma
4280
+ htab->elf.splt->output_offset
4282
rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4283
rela.r_addend = got_offset;
4284
bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4285
loc += sizeof (Elf32_External_Rela);
4287
/* Likewise the following or. */
4289
rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4290
bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4291
loc += sizeof (Elf32_External_Rela);
4293
/* Relocate the .got.plt entry. */
4294
rela.r_offset = (htab->elf.sgotplt->output_section->vma
4295
+ htab->elf.sgotplt->output_offset
4297
rela.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_SPARC_32);
4298
rela.r_addend = plt_offset + 20;
4299
bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4303
/* Finish up dynamic symbol handling. We set the contents of various
4304
dynamic sections here. */
4307
_bfd_sparc_elf_finish_dynamic_symbol (bfd *output_bfd,
4308
struct bfd_link_info *info,
4309
struct elf_link_hash_entry *h,
4310
Elf_Internal_Sym *sym)
4312
struct _bfd_sparc_elf_link_hash_table *htab;
4313
const struct elf_backend_data *bed;
4315
htab = _bfd_sparc_elf_hash_table (info);
4316
BFD_ASSERT (htab != NULL);
4317
bed = get_elf_backend_data (output_bfd);
4319
if (h->plt.offset != (bfd_vma) -1)
4323
Elf_Internal_Rela rela;
4325
bfd_vma r_offset, got_offset;
4328
/* When building a static executable, use .iplt and
4329
.rela.iplt sections for STT_GNU_IFUNC symbols. */
4330
if (htab->elf.splt != NULL)
4332
splt = htab->elf.splt;
4333
srela = htab->elf.srelplt;
4337
splt = htab->elf.iplt;
4338
srela = htab->elf.irelplt;
4341
if (splt == NULL || srela == NULL)
4344
/* Fill in the entry in the .rela.plt section. */
4345
if (htab->is_vxworks)
4347
/* Work out the index of this PLT entry. */
4348
rela_index = ((h->plt.offset - htab->plt_header_size)
4349
/ htab->plt_entry_size);
4351
/* Calculate the offset of the associated .got.plt entry.
4352
The first three entries are reserved. */
4353
got_offset = (rela_index + 3) * 4;
4355
sparc_vxworks_build_plt_entry (output_bfd, info, h->plt.offset,
4356
rela_index, got_offset);
4359
/* On VxWorks, the relocation points to the .got.plt entry,
4360
not the .plt entry. */
4361
rela.r_offset = (htab->elf.sgotplt->output_section->vma
4362
+ htab->elf.sgotplt->output_offset
4365
rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx,
4370
bfd_boolean ifunc = FALSE;
4372
/* Fill in the entry in the procedure linkage table. */
4373
rela_index = SPARC_ELF_BUILD_PLT_ENTRY (htab, output_bfd, splt,
4374
h->plt.offset, splt->size,
4379
|| ((info->executable
4380
|| ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
4382
&& h->type == STT_GNU_IFUNC))
4385
BFD_ASSERT (h == NULL
4386
|| (h->type == STT_GNU_IFUNC
4388
&& (h->root.type == bfd_link_hash_defined
4389
|| h->root.type == bfd_link_hash_defweak)));
4392
rela.r_offset = r_offset
4393
+ (splt->output_section->vma + splt->output_offset);
4394
if (ABI_64_P (output_bfd)
4395
&& h->plt.offset >= (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE))
4399
rela.r_addend = (h->root.u.def.section->output_section->vma
4400
+ h->root.u.def.section->output_offset
4401
+ h->root.u.def.value);
4402
rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0,
4407
rela.r_addend = (-(h->plt.offset + 4)
4408
- splt->output_section->vma
4409
- splt->output_offset);
4410
rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx,
4418
rela.r_addend = (h->root.u.def.section->output_section->vma
4419
+ h->root.u.def.section->output_offset
4420
+ h->root.u.def.value);
4421
rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0,
4427
rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx,
4433
/* Adjust for the first 4 reserved elements in the .plt section
4434
when setting the offset in the .rela.plt section.
4435
Sun forgot to read their own ABI and copied elf32-sparc behaviour,
4436
thus .plt[4] has corresponding .rela.plt[0] and so on. */
4438
loc = srela->contents;
4439
loc += rela_index * bed->s->sizeof_rela;
4440
bed->s->swap_reloca_out (output_bfd, &rela, loc);
4442
if (!h->def_regular)
4444
/* Mark the symbol as undefined, rather than as defined in
4445
the .plt section. Leave the value alone. */
4446
sym->st_shndx = SHN_UNDEF;
4447
/* If the symbol is weak, we do need to clear the value.
4448
Otherwise, the PLT entry would provide a definition for
4449
the symbol even if the symbol wasn't defined anywhere,
4450
and so the symbol would never be NULL. */
4451
if (!h->ref_regular_nonweak)
4456
if (h->got.offset != (bfd_vma) -1
4457
&& _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_GD
4458
&& _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_IE)
4462
Elf_Internal_Rela rela;
4464
/* This symbol has an entry in the GOT. Set it up. */
4466
sgot = htab->elf.sgot;
4467
srela = htab->elf.srelgot;
4468
BFD_ASSERT (sgot != NULL && srela != NULL);
4470
rela.r_offset = (sgot->output_section->vma
4471
+ sgot->output_offset
4472
+ (h->got.offset &~ (bfd_vma) 1));
4474
/* If this is a -Bsymbolic link, and the symbol is defined
4475
locally, we just want to emit a RELATIVE reloc. Likewise if
4476
the symbol was forced to be local because of a version file.
4477
The entry in the global offset table will already have been
4478
initialized in the relocate_section function. */
4480
&& h->type == STT_GNU_IFUNC
4485
/* We load the GOT entry with the PLT entry. */
4486
plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
4487
SPARC_ELF_PUT_WORD (htab, output_bfd,
4488
(plt->output_section->vma
4489
+ plt->output_offset + h->plt.offset),
4490
htab->elf.sgot->contents
4491
+ (h->got.offset & ~(bfd_vma) 1));
4494
else if (info->shared
4495
&& SYMBOL_REFERENCES_LOCAL (info, h))
4497
asection *sec = h->root.u.def.section;
4498
if (h->type == STT_GNU_IFUNC)
4499
rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, R_SPARC_IRELATIVE);
4501
rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, R_SPARC_RELATIVE);
4502
rela.r_addend = (h->root.u.def.value
4503
+ sec->output_section->vma
4504
+ sec->output_offset);
4508
rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_GLOB_DAT);
4512
SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
4513
sgot->contents + (h->got.offset & ~(bfd_vma) 1));
4514
sparc_elf_append_rela (output_bfd, srela, &rela);
4520
Elf_Internal_Rela rela;
4522
/* This symbols needs a copy reloc. Set it up. */
4523
BFD_ASSERT (h->dynindx != -1);
4525
s = bfd_get_linker_section (h->root.u.def.section->owner,
4527
BFD_ASSERT (s != NULL);
4529
rela.r_offset = (h->root.u.def.value
4530
+ h->root.u.def.section->output_section->vma
4531
+ h->root.u.def.section->output_offset);
4532
rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_COPY);
4534
sparc_elf_append_rela (output_bfd, s, &rela);
4537
/* Mark some specially defined symbols as absolute. On VxWorks,
4538
_GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the
4539
".got" section. Likewise _PROCEDURE_LINKAGE_TABLE_ and ".plt". */
4541
&& (h == htab->elf.hdynamic
4542
|| (!htab->is_vxworks
4543
&& (h == htab->elf.hgot || h == htab->elf.hplt))))
4544
sym->st_shndx = SHN_ABS;
4549
/* Finish up the dynamic sections. */
4552
sparc_finish_dyn (bfd *output_bfd, struct bfd_link_info *info,
4553
bfd *dynobj, asection *sdyn,
4554
asection *splt ATTRIBUTE_UNUSED)
4556
struct _bfd_sparc_elf_link_hash_table *htab;
4557
const struct elf_backend_data *bed;
4558
bfd_byte *dyncon, *dynconend;
4560
int stt_regidx = -1;
4561
bfd_boolean abi_64_p;
4563
htab = _bfd_sparc_elf_hash_table (info);
4564
BFD_ASSERT (htab != NULL);
4565
bed = get_elf_backend_data (output_bfd);
4566
dynsize = bed->s->sizeof_dyn;
4567
dynconend = sdyn->contents + sdyn->size;
4568
abi_64_p = ABI_64_P (output_bfd);
4569
for (dyncon = sdyn->contents; dyncon < dynconend; dyncon += dynsize)
4571
Elf_Internal_Dyn dyn;
4575
bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
4577
if (htab->is_vxworks && dyn.d_tag == DT_RELASZ)
4579
/* On VxWorks, DT_RELASZ should not include the relocations
4581
if (htab->elf.srelplt)
4583
dyn.d_un.d_val -= htab->elf.srelplt->size;
4584
bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4587
else if (htab->is_vxworks && dyn.d_tag == DT_PLTGOT)
4589
/* On VxWorks, DT_PLTGOT should point to the start of the GOT,
4590
not to the start of the PLT. */
4591
if (htab->elf.sgotplt)
4593
dyn.d_un.d_val = (htab->elf.sgotplt->output_section->vma
4594
+ htab->elf.sgotplt->output_offset);
4595
bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4598
else if (htab->is_vxworks
4599
&& elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
4600
bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4601
else if (abi_64_p && dyn.d_tag == DT_SPARC_REGISTER)
4603
if (stt_regidx == -1)
4606
_bfd_elf_link_lookup_local_dynindx (info, output_bfd, -1);
4607
if (stt_regidx == -1)
4610
dyn.d_un.d_val = stt_regidx++;
4611
bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4617
case DT_PLTGOT: name = ".plt"; size = FALSE; break;
4618
case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break;
4619
case DT_JMPREL: name = ".rela.plt"; size = FALSE; break;
4620
default: name = NULL; size = FALSE; break;
4627
s = bfd_get_section_by_name (output_bfd, name);
4633
dyn.d_un.d_ptr = s->vma;
4635
dyn.d_un.d_val = s->size;
4637
bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4644
/* Install the first PLT entry in a VxWorks executable and make sure that
4645
.rela.plt.unloaded relocations have the correct symbol indexes. */
4648
sparc_vxworks_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info)
4650
struct _bfd_sparc_elf_link_hash_table *htab;
4651
Elf_Internal_Rela rela;
4655
htab = _bfd_sparc_elf_hash_table (info);
4656
BFD_ASSERT (htab != NULL);
4658
/* Calculate the absolute value of _GLOBAL_OFFSET_TABLE_. */
4659
got_base = (htab->elf.hgot->root.u.def.section->output_section->vma
4660
+ htab->elf.hgot->root.u.def.section->output_offset
4661
+ htab->elf.hgot->root.u.def.value);
4663
/* Install the initial PLT entry. */
4664
bfd_put_32 (output_bfd,
4665
sparc_vxworks_exec_plt0_entry[0] + ((got_base + 8) >> 10),
4666
htab->elf.splt->contents);
4667
bfd_put_32 (output_bfd,
4668
sparc_vxworks_exec_plt0_entry[1] + ((got_base + 8) & 0x3ff),
4669
htab->elf.splt->contents + 4);
4670
bfd_put_32 (output_bfd,
4671
sparc_vxworks_exec_plt0_entry[2],
4672
htab->elf.splt->contents + 8);
4673
bfd_put_32 (output_bfd,
4674
sparc_vxworks_exec_plt0_entry[3],
4675
htab->elf.splt->contents + 12);
4676
bfd_put_32 (output_bfd,
4677
sparc_vxworks_exec_plt0_entry[4],
4678
htab->elf.splt->contents + 16);
4680
loc = htab->srelplt2->contents;
4682
/* Add an unloaded relocation for the initial entry's "sethi". */
4683
rela.r_offset = (htab->elf.splt->output_section->vma
4684
+ htab->elf.splt->output_offset);
4685
rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4687
bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4688
loc += sizeof (Elf32_External_Rela);
4690
/* Likewise the following "or". */
4692
rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4693
bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4694
loc += sizeof (Elf32_External_Rela);
4696
/* Fix up the remaining .rela.plt.unloaded relocations. They may have
4697
the wrong symbol index for _G_O_T_ or _P_L_T_ depending on the order
4698
in which symbols were output. */
4699
while (loc < htab->srelplt2->contents + htab->srelplt2->size)
4701
Elf_Internal_Rela rel;
4703
/* The entry's initial "sethi" (against _G_O_T_). */
4704
bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4705
rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4706
bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4707
loc += sizeof (Elf32_External_Rela);
4709
/* The following "or" (also against _G_O_T_). */
4710
bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4711
rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4712
bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4713
loc += sizeof (Elf32_External_Rela);
4715
/* The .got.plt entry (against _P_L_T_). */
4716
bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4717
rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_SPARC_32);
4718
bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4719
loc += sizeof (Elf32_External_Rela);
4723
/* Install the first PLT entry in a VxWorks shared object. */
4726
sparc_vxworks_finish_shared_plt (bfd *output_bfd, struct bfd_link_info *info)
4728
struct _bfd_sparc_elf_link_hash_table *htab;
4731
htab = _bfd_sparc_elf_hash_table (info);
4732
BFD_ASSERT (htab != NULL);
4734
for (i = 0; i < ARRAY_SIZE (sparc_vxworks_shared_plt0_entry); i++)
4735
bfd_put_32 (output_bfd, sparc_vxworks_shared_plt0_entry[i],
4736
htab->elf.splt->contents + i * 4);
4739
/* Finish up local dynamic symbol handling. We set the contents of
4740
various dynamic sections here. */
4743
finish_local_dynamic_symbol (void **slot, void *inf)
4745
struct elf_link_hash_entry *h
4746
= (struct elf_link_hash_entry *) *slot;
4747
struct bfd_link_info *info
4748
= (struct bfd_link_info *) inf;
4750
return _bfd_sparc_elf_finish_dynamic_symbol (info->output_bfd, info,
4755
_bfd_sparc_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
4759
struct _bfd_sparc_elf_link_hash_table *htab;
4761
htab = _bfd_sparc_elf_hash_table (info);
4762
BFD_ASSERT (htab != NULL);
4763
dynobj = htab->elf.dynobj;
4765
sdyn = bfd_get_linker_section (dynobj, ".dynamic");
4767
if (elf_hash_table (info)->dynamic_sections_created)
4771
splt = htab->elf.splt;
4772
BFD_ASSERT (splt != NULL && sdyn != NULL);
4774
if (!sparc_finish_dyn (output_bfd, info, dynobj, sdyn, splt))
4777
/* Initialize the contents of the .plt section. */
4780
if (htab->is_vxworks)
4783
sparc_vxworks_finish_shared_plt (output_bfd, info);
4785
sparc_vxworks_finish_exec_plt (output_bfd, info);
4789
memset (splt->contents, 0, htab->plt_header_size);
4790
if (!ABI_64_P (output_bfd))
4791
bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP,
4792
splt->contents + splt->size - 4);
4796
elf_section_data (splt->output_section)->this_hdr.sh_entsize
4797
= (htab->is_vxworks || !ABI_64_P (output_bfd))
4798
? 0 : htab->plt_entry_size;
4801
/* Set the first entry in the global offset table to the address of
4802
the dynamic section. */
4803
if (htab->elf.sgot && htab->elf.sgot->size > 0)
4805
bfd_vma val = (sdyn ?
4806
sdyn->output_section->vma + sdyn->output_offset :
4809
SPARC_ELF_PUT_WORD (htab, output_bfd, val, htab->elf.sgot->contents);
4813
elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize =
4814
SPARC_ELF_WORD_BYTES (htab);
4816
/* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
4817
htab_traverse (htab->loc_hash_table, finish_local_dynamic_symbol, info);
4823
/* Set the right machine number for a SPARC ELF file. */
4826
_bfd_sparc_elf_object_p (bfd *abfd)
4828
if (ABI_64_P (abfd))
4830
unsigned long mach = bfd_mach_sparc_v9;
4832
if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
4833
mach = bfd_mach_sparc_v9b;
4834
else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
4835
mach = bfd_mach_sparc_v9a;
4836
return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, mach);
4840
if (elf_elfheader (abfd)->e_machine == EM_SPARC32PLUS)
4842
if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
4843
return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4844
bfd_mach_sparc_v8plusb);
4845
else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
4846
return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4847
bfd_mach_sparc_v8plusa);
4848
else if (elf_elfheader (abfd)->e_flags & EF_SPARC_32PLUS)
4849
return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4850
bfd_mach_sparc_v8plus);
4854
else if (elf_elfheader (abfd)->e_flags & EF_SPARC_LEDATA)
4855
return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4856
bfd_mach_sparc_sparclite_le);
4858
return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc);
4862
/* Return address for Ith PLT stub in section PLT, for relocation REL
4863
or (bfd_vma) -1 if it should not be included. */
4866
_bfd_sparc_elf_plt_sym_val (bfd_vma i, const asection *plt, const arelent *rel)
4868
if (ABI_64_P (plt->owner))
4872
i += PLT64_HEADER_SIZE / PLT64_ENTRY_SIZE;
4873
if (i < PLT64_LARGE_THRESHOLD)
4874
return plt->vma + i * PLT64_ENTRY_SIZE;
4876
j = (i - PLT64_LARGE_THRESHOLD) % 160;
4878
return plt->vma + i * PLT64_ENTRY_SIZE + j * 4 * 6;
4881
return rel->address;
4884
/* Merge backend specific data from an object file to the output
4885
object file when linking. */
4888
_bfd_sparc_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
4890
obj_attribute *in_attr, *in_attrs;
4891
obj_attribute *out_attr, *out_attrs;
4893
if (!elf_known_obj_attributes_proc (obfd)[0].i)
4895
/* This is the first object. Copy the attributes. */
4896
_bfd_elf_copy_obj_attributes (ibfd, obfd);
4898
/* Use the Tag_null value to indicate the attributes have been
4900
elf_known_obj_attributes_proc (obfd)[0].i = 1;
4905
in_attrs = elf_known_obj_attributes (ibfd)[OBJ_ATTR_GNU];
4906
out_attrs = elf_known_obj_attributes (obfd)[OBJ_ATTR_GNU];
4908
in_attr = &in_attrs[Tag_GNU_Sparc_HWCAPS];
4909
out_attr = &out_attrs[Tag_GNU_Sparc_HWCAPS];
4911
out_attr->i |= in_attr->i;
4914
/* Merge Tag_compatibility attributes and any common GNU ones. */
4915
_bfd_elf_merge_object_attributes (ibfd, obfd);
added
removed
binutils-2.23.52.20130611/bfd/elfxx-sparc.c
