1 /* SPARC-specific support for ELF
2 Copyright 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
22 /* This file handles functionality common to the different SPARC ABI's. */
28 #include "libiberty.h"
30 #include "elf/sparc.h"
31 #include "opcode/sparc.h"
32 #include "elfxx-sparc.h"
33 #include "elf-vxworks.h"
37 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
38 #define MINUS_ONE (~ (bfd_vma) 0)
40 #define ABI_64_P(abfd) \
41 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
43 /* The relocation "howto" table. */
45 /* Utility for performing the standard initial work of an instruction
47 *PRELOCATION will contain the relocated item.
48 *PINSN will contain the instruction from the input stream.
49 If the result is `bfd_reloc_other' the caller can continue with
50 performing the relocation. Otherwise it must stop and return the
51 value to its caller. */
53 static bfd_reloc_status_type
54 init_insn_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
55 PTR data, asection *input_section, bfd *output_bfd,
56 bfd_vma *prelocation, bfd_vma *pinsn)
59 reloc_howto_type *howto = reloc_entry->howto;
61 if (output_bfd != (bfd *) NULL
62 && (symbol->flags & BSF_SECTION_SYM) == 0
63 && (! howto->partial_inplace
64 || reloc_entry->addend == 0))
66 reloc_entry->address += input_section->output_offset;
70 /* This works because partial_inplace is FALSE. */
71 if (output_bfd != NULL)
72 return bfd_reloc_continue;
74 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
75 return bfd_reloc_outofrange;
77 relocation = (symbol->value
78 + symbol->section->output_section->vma
79 + symbol->section->output_offset);
80 relocation += reloc_entry->addend;
81 if (howto->pc_relative)
83 relocation -= (input_section->output_section->vma
84 + input_section->output_offset);
85 relocation -= reloc_entry->address;
88 *prelocation = relocation;
89 *pinsn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
90 return bfd_reloc_other;
93 /* For unsupported relocs. */
95 static bfd_reloc_status_type
96 sparc_elf_notsup_reloc (bfd *abfd ATTRIBUTE_UNUSED,
97 arelent *reloc_entry ATTRIBUTE_UNUSED,
98 asymbol *symbol ATTRIBUTE_UNUSED,
99 PTR data ATTRIBUTE_UNUSED,
100 asection *input_section ATTRIBUTE_UNUSED,
101 bfd *output_bfd ATTRIBUTE_UNUSED,
102 char **error_message ATTRIBUTE_UNUSED)
104 return bfd_reloc_notsupported;
107 /* Handle the WDISP16 reloc. */
109 static bfd_reloc_status_type
110 sparc_elf_wdisp16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
111 PTR data, asection *input_section, bfd *output_bfd,
112 char **error_message ATTRIBUTE_UNUSED)
116 bfd_reloc_status_type status;
118 status = init_insn_reloc (abfd, reloc_entry, symbol, data,
119 input_section, output_bfd, &relocation, &insn);
120 if (status != bfd_reloc_other)
123 insn &= ~ (bfd_vma) 0x303fff;
124 insn |= (((relocation >> 2) & 0xc000) << 6) | ((relocation >> 2) & 0x3fff);
125 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
127 if ((bfd_signed_vma) relocation < - 0x40000
128 || (bfd_signed_vma) relocation > 0x3ffff)
129 return bfd_reloc_overflow;
134 /* Handle the HIX22 reloc. */
136 static bfd_reloc_status_type
137 sparc_elf_hix22_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
138 PTR data, asection *input_section, bfd *output_bfd,
139 char **error_message ATTRIBUTE_UNUSED)
143 bfd_reloc_status_type status;
145 status = init_insn_reloc (abfd, reloc_entry, symbol, data,
146 input_section, output_bfd, &relocation, &insn);
147 if (status != bfd_reloc_other)
150 relocation ^= MINUS_ONE;
151 insn = (insn &~ (bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
152 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
154 if ((relocation & ~ (bfd_vma) 0xffffffff) != 0)
155 return bfd_reloc_overflow;
160 /* Handle the LOX10 reloc. */
162 static bfd_reloc_status_type
163 sparc_elf_lox10_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
164 PTR data, asection *input_section, bfd *output_bfd,
165 char **error_message ATTRIBUTE_UNUSED)
169 bfd_reloc_status_type status;
171 status = init_insn_reloc (abfd, reloc_entry, symbol, data,
172 input_section, output_bfd, &relocation, &insn);
173 if (status != bfd_reloc_other)
176 insn = (insn &~ (bfd_vma) 0x1fff) | 0x1c00 | (relocation & 0x3ff);
177 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
182 static reloc_howto_type _bfd_sparc_elf_howto_table[] =
184 HOWTO(R_SPARC_NONE, 0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", FALSE,0,0x00000000,TRUE),
185 HOWTO(R_SPARC_8, 0,0, 8,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_8", FALSE,0,0x000000ff,TRUE),
186 HOWTO(R_SPARC_16, 0,1,16,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_16", FALSE,0,0x0000ffff,TRUE),
187 HOWTO(R_SPARC_32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_32", FALSE,0,0xffffffff,TRUE),
188 HOWTO(R_SPARC_DISP8, 0,0, 8,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP8", FALSE,0,0x000000ff,TRUE),
189 HOWTO(R_SPARC_DISP16, 0,1,16,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP16", FALSE,0,0x0000ffff,TRUE),
190 HOWTO(R_SPARC_DISP32, 0,2,32,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP32", FALSE,0,0xffffffff,TRUE),
191 HOWTO(R_SPARC_WDISP30, 2,2,30,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP30", FALSE,0,0x3fffffff,TRUE),
192 HOWTO(R_SPARC_WDISP22, 2,2,22,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP22", FALSE,0,0x003fffff,TRUE),
193 HOWTO(R_SPARC_HI22, 10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_HI22", FALSE,0,0x003fffff,TRUE),
194 HOWTO(R_SPARC_22, 0,2,22,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_22", FALSE,0,0x003fffff,TRUE),
195 HOWTO(R_SPARC_13, 0,2,13,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_13", FALSE,0,0x00001fff,TRUE),
196 HOWTO(R_SPARC_LO10, 0,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_LO10", FALSE,0,0x000003ff,TRUE),
197 HOWTO(R_SPARC_GOT10, 0,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOT10", FALSE,0,0x000003ff,TRUE),
198 HOWTO(R_SPARC_GOT13, 0,2,13,FALSE,0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_GOT13", FALSE,0,0x00001fff,TRUE),
199 HOWTO(R_SPARC_GOT22, 10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOT22", FALSE,0,0x003fffff,TRUE),
200 HOWTO(R_SPARC_PC10, 0,2,10,TRUE, 0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_PC10", FALSE,0,0x000003ff,TRUE),
201 HOWTO(R_SPARC_PC22, 10,2,22,TRUE, 0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_PC22", FALSE,0,0x003fffff,TRUE),
202 HOWTO(R_SPARC_WPLT30, 2,2,30,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WPLT30", FALSE,0,0x3fffffff,TRUE),
203 HOWTO(R_SPARC_COPY, 0,0,00,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_COPY", FALSE,0,0x00000000,TRUE),
204 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),
205 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),
206 HOWTO(R_SPARC_RELATIVE, 0,0,00,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_RELATIVE",FALSE,0,0x00000000,TRUE),
207 HOWTO(R_SPARC_UA32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA32", FALSE,0,0xffffffff,TRUE),
208 HOWTO(R_SPARC_PLT32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_PLT32", FALSE,0,0xffffffff,TRUE),
209 HOWTO(R_SPARC_HIPLT22, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_HIPLT22", FALSE,0,0x00000000,TRUE),
210 HOWTO(R_SPARC_LOPLT10, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_LOPLT10", FALSE,0,0x00000000,TRUE),
211 HOWTO(R_SPARC_PCPLT32, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PCPLT32", FALSE,0,0x00000000,TRUE),
212 HOWTO(R_SPARC_PCPLT22, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PCPLT22", FALSE,0,0x00000000,TRUE),
213 HOWTO(R_SPARC_PCPLT10, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PCPLT10", FALSE,0,0x00000000,TRUE),
214 HOWTO(R_SPARC_10, 0,2,10,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_10", FALSE,0,0x000003ff,TRUE),
215 HOWTO(R_SPARC_11, 0,2,11,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_11", FALSE,0,0x000007ff,TRUE),
216 HOWTO(R_SPARC_64, 0,4,64,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_64", FALSE,0,MINUS_ONE, TRUE),
217 HOWTO(R_SPARC_OLO10, 0,2,13,FALSE,0,complain_overflow_signed, sparc_elf_notsup_reloc, "R_SPARC_OLO10", FALSE,0,0x00001fff,TRUE),
218 HOWTO(R_SPARC_HH22, 42,2,22,FALSE,0,complain_overflow_unsigned,bfd_elf_generic_reloc, "R_SPARC_HH22", FALSE,0,0x003fffff,TRUE),
219 HOWTO(R_SPARC_HM10, 32,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_HM10", FALSE,0,0x000003ff,TRUE),
220 HOWTO(R_SPARC_LM22, 10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_LM22", FALSE,0,0x003fffff,TRUE),
221 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),
222 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),
223 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),
224 HOWTO(R_SPARC_WDISP16, 2,2,16,TRUE, 0,complain_overflow_signed, sparc_elf_wdisp16_reloc,"R_SPARC_WDISP16", FALSE,0,0x00000000,TRUE),
225 HOWTO(R_SPARC_WDISP19, 2,2,19,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP19", FALSE,0,0x0007ffff,TRUE),
226 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),
227 HOWTO(R_SPARC_7, 0,2, 7,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_7", FALSE,0,0x0000007f,TRUE),
228 HOWTO(R_SPARC_5, 0,2, 5,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_5", FALSE,0,0x0000001f,TRUE),
229 HOWTO(R_SPARC_6, 0,2, 6,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_6", FALSE,0,0x0000003f,TRUE),
230 HOWTO(R_SPARC_DISP64, 0,4,64,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP64", FALSE,0,MINUS_ONE, TRUE),
231 HOWTO(R_SPARC_PLT64, 0,4,64,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_PLT64", FALSE,0,MINUS_ONE, TRUE),
232 HOWTO(R_SPARC_HIX22, 0,4, 0,FALSE,0,complain_overflow_bitfield,sparc_elf_hix22_reloc, "R_SPARC_HIX22", FALSE,0,MINUS_ONE, FALSE),
233 HOWTO(R_SPARC_LOX10, 0,4, 0,FALSE,0,complain_overflow_dont, sparc_elf_lox10_reloc, "R_SPARC_LOX10", FALSE,0,MINUS_ONE, FALSE),
234 HOWTO(R_SPARC_H44, 22,2,22,FALSE,0,complain_overflow_unsigned,bfd_elf_generic_reloc, "R_SPARC_H44", FALSE,0,0x003fffff,FALSE),
235 HOWTO(R_SPARC_M44, 12,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_M44", FALSE,0,0x000003ff,FALSE),
236 HOWTO(R_SPARC_L44, 0,2,13,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_L44", FALSE,0,0x00000fff,FALSE),
237 HOWTO(R_SPARC_REGISTER, 0,4, 0,FALSE,0,complain_overflow_bitfield,sparc_elf_notsup_reloc, "R_SPARC_REGISTER",FALSE,0,MINUS_ONE, FALSE),
238 HOWTO(R_SPARC_UA64, 0,4,64,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA64", FALSE,0,MINUS_ONE, TRUE),
239 HOWTO(R_SPARC_UA16, 0,1,16,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA16", FALSE,0,0x0000ffff,TRUE),
240 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),
241 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),
242 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),
243 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),
244 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),
245 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),
246 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),
247 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),
248 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),
249 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),
250 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),
251 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),
252 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),
253 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),
254 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),
255 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),
256 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),
257 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),
258 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),
259 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),
260 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),
261 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),
262 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),
263 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),
264 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),
265 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),
266 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),
267 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),
268 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),
270 static reloc_howto_type sparc_jmp_irel_howto =
271 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);
272 static reloc_howto_type sparc_irelative_howto =
273 HOWTO(R_SPARC_IRELATIVE, 0,0,00,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_IRELATIVE",FALSE,0,0x00000000,TRUE);
274 static reloc_howto_type sparc_vtinherit_howto =
275 HOWTO (R_SPARC_GNU_VTINHERIT, 0,2,0,FALSE,0,complain_overflow_dont, NULL, "R_SPARC_GNU_VTINHERIT", FALSE,0, 0, FALSE);
276 static reloc_howto_type sparc_vtentry_howto =
277 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);
278 static reloc_howto_type sparc_rev32_howto =
279 HOWTO(R_SPARC_REV32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_REV32", FALSE,0,0xffffffff,TRUE);
282 _bfd_sparc_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
283 bfd_reloc_code_real_type code)
285 /* We explicitly handle each relocation type in the switch
286 instead of using a lookup table for efficiency. */
290 return &_bfd_sparc_elf_howto_table[R_SPARC_NONE];
293 return &_bfd_sparc_elf_howto_table[R_SPARC_8];
296 return &_bfd_sparc_elf_howto_table[R_SPARC_16];
299 return &_bfd_sparc_elf_howto_table[R_SPARC_32];
301 case BFD_RELOC_8_PCREL:
302 return &_bfd_sparc_elf_howto_table[R_SPARC_DISP8];
304 case BFD_RELOC_16_PCREL:
305 return &_bfd_sparc_elf_howto_table[R_SPARC_DISP16];
307 case BFD_RELOC_32_PCREL:
308 return &_bfd_sparc_elf_howto_table[R_SPARC_DISP32];
310 case BFD_RELOC_32_PCREL_S2:
311 return &_bfd_sparc_elf_howto_table[R_SPARC_WDISP30];
313 case BFD_RELOC_SPARC_WDISP22:
314 return &_bfd_sparc_elf_howto_table[R_SPARC_WDISP22];
317 return &_bfd_sparc_elf_howto_table[R_SPARC_HI22];
319 case BFD_RELOC_SPARC22:
320 return &_bfd_sparc_elf_howto_table[R_SPARC_22];
322 case BFD_RELOC_SPARC13:
323 return &_bfd_sparc_elf_howto_table[R_SPARC_13];
326 return &_bfd_sparc_elf_howto_table[R_SPARC_LO10];
328 case BFD_RELOC_SPARC_GOT10:
329 return &_bfd_sparc_elf_howto_table[R_SPARC_GOT10];
331 case BFD_RELOC_SPARC_GOT13:
332 return &_bfd_sparc_elf_howto_table[R_SPARC_GOT13];
334 case BFD_RELOC_SPARC_GOT22:
335 return &_bfd_sparc_elf_howto_table[R_SPARC_GOT22];
337 case BFD_RELOC_SPARC_PC10:
338 return &_bfd_sparc_elf_howto_table[R_SPARC_PC10];
340 case BFD_RELOC_SPARC_PC22:
341 return &_bfd_sparc_elf_howto_table[R_SPARC_PC22];
343 case BFD_RELOC_SPARC_WPLT30:
344 return &_bfd_sparc_elf_howto_table[R_SPARC_WPLT30];
346 case BFD_RELOC_SPARC_COPY:
347 return &_bfd_sparc_elf_howto_table[R_SPARC_COPY];
349 case BFD_RELOC_SPARC_GLOB_DAT:
350 return &_bfd_sparc_elf_howto_table[R_SPARC_GLOB_DAT];
352 case BFD_RELOC_SPARC_JMP_SLOT:
353 return &_bfd_sparc_elf_howto_table[R_SPARC_JMP_SLOT];
355 case BFD_RELOC_SPARC_RELATIVE:
356 return &_bfd_sparc_elf_howto_table[R_SPARC_RELATIVE];
358 case BFD_RELOC_SPARC_UA32:
359 return &_bfd_sparc_elf_howto_table[R_SPARC_UA32];
361 case BFD_RELOC_SPARC_PLT32:
362 return &_bfd_sparc_elf_howto_table[R_SPARC_PLT32];
364 case BFD_RELOC_SPARC_10:
365 return &_bfd_sparc_elf_howto_table[R_SPARC_10];
367 case BFD_RELOC_SPARC_11:
368 return &_bfd_sparc_elf_howto_table[R_SPARC_11];
370 case BFD_RELOC_SPARC_64:
371 return &_bfd_sparc_elf_howto_table[R_SPARC_64];
373 case BFD_RELOC_SPARC_OLO10:
374 return &_bfd_sparc_elf_howto_table[R_SPARC_OLO10];
376 case BFD_RELOC_SPARC_HH22:
377 return &_bfd_sparc_elf_howto_table[R_SPARC_HH22];
379 case BFD_RELOC_SPARC_HM10:
380 return &_bfd_sparc_elf_howto_table[R_SPARC_HM10];
382 case BFD_RELOC_SPARC_LM22:
383 return &_bfd_sparc_elf_howto_table[R_SPARC_LM22];
385 case BFD_RELOC_SPARC_PC_HH22:
386 return &_bfd_sparc_elf_howto_table[R_SPARC_PC_HH22];
388 case BFD_RELOC_SPARC_PC_HM10:
389 return &_bfd_sparc_elf_howto_table[R_SPARC_PC_HM10];
391 case BFD_RELOC_SPARC_PC_LM22:
392 return &_bfd_sparc_elf_howto_table[R_SPARC_PC_LM22];
394 case BFD_RELOC_SPARC_WDISP16:
395 return &_bfd_sparc_elf_howto_table[R_SPARC_WDISP16];
397 case BFD_RELOC_SPARC_WDISP19:
398 return &_bfd_sparc_elf_howto_table[R_SPARC_WDISP19];
400 case BFD_RELOC_SPARC_7:
401 return &_bfd_sparc_elf_howto_table[R_SPARC_7];
403 case BFD_RELOC_SPARC_5:
404 return &_bfd_sparc_elf_howto_table[R_SPARC_5];
406 case BFD_RELOC_SPARC_6:
407 return &_bfd_sparc_elf_howto_table[R_SPARC_6];
409 case BFD_RELOC_SPARC_DISP64:
410 return &_bfd_sparc_elf_howto_table[R_SPARC_DISP64];
412 case BFD_RELOC_SPARC_PLT64:
413 return &_bfd_sparc_elf_howto_table[R_SPARC_PLT64];
415 case BFD_RELOC_SPARC_HIX22:
416 return &_bfd_sparc_elf_howto_table[R_SPARC_HIX22];
418 case BFD_RELOC_SPARC_LOX10:
419 return &_bfd_sparc_elf_howto_table[R_SPARC_LOX10];
421 case BFD_RELOC_SPARC_H44:
422 return &_bfd_sparc_elf_howto_table[R_SPARC_H44];
424 case BFD_RELOC_SPARC_M44:
425 return &_bfd_sparc_elf_howto_table[R_SPARC_M44];
427 case BFD_RELOC_SPARC_L44:
428 return &_bfd_sparc_elf_howto_table[R_SPARC_L44];
430 case BFD_RELOC_SPARC_REGISTER:
431 return &_bfd_sparc_elf_howto_table[R_SPARC_REGISTER];
433 case BFD_RELOC_SPARC_UA64:
434 return &_bfd_sparc_elf_howto_table[R_SPARC_UA64];
436 case BFD_RELOC_SPARC_UA16:
437 return &_bfd_sparc_elf_howto_table[R_SPARC_UA16];
439 case BFD_RELOC_SPARC_TLS_GD_HI22:
440 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_GD_HI22];
442 case BFD_RELOC_SPARC_TLS_GD_LO10:
443 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_GD_LO10];
445 case BFD_RELOC_SPARC_TLS_GD_ADD:
446 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_GD_ADD];
448 case BFD_RELOC_SPARC_TLS_GD_CALL:
449 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_GD_CALL];
451 case BFD_RELOC_SPARC_TLS_LDM_HI22:
452 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDM_HI22];
454 case BFD_RELOC_SPARC_TLS_LDM_LO10:
455 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDM_LO10];
457 case BFD_RELOC_SPARC_TLS_LDM_ADD:
458 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDM_ADD];
460 case BFD_RELOC_SPARC_TLS_LDM_CALL:
461 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDM_CALL];
463 case BFD_RELOC_SPARC_TLS_LDO_HIX22:
464 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDO_HIX22];
466 case BFD_RELOC_SPARC_TLS_LDO_LOX10:
467 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDO_LOX10];
469 case BFD_RELOC_SPARC_TLS_LDO_ADD:
470 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDO_ADD];
472 case BFD_RELOC_SPARC_TLS_IE_HI22:
473 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_IE_HI22];
475 case BFD_RELOC_SPARC_TLS_IE_LO10:
476 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_IE_LO10];
478 case BFD_RELOC_SPARC_TLS_IE_LD:
479 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_IE_LD];
481 case BFD_RELOC_SPARC_TLS_IE_LDX:
482 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_IE_LDX];
484 case BFD_RELOC_SPARC_TLS_IE_ADD:
485 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_IE_ADD];
487 case BFD_RELOC_SPARC_TLS_LE_HIX22:
488 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LE_HIX22];
490 case BFD_RELOC_SPARC_TLS_LE_LOX10:
491 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LE_LOX10];
493 case BFD_RELOC_SPARC_TLS_DTPMOD32:
494 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_DTPMOD32];
496 case BFD_RELOC_SPARC_TLS_DTPMOD64:
497 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_DTPMOD64];
499 case BFD_RELOC_SPARC_TLS_DTPOFF32:
500 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_DTPOFF32];
502 case BFD_RELOC_SPARC_TLS_DTPOFF64:
503 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_DTPOFF64];
505 case BFD_RELOC_SPARC_TLS_TPOFF32:
506 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_TPOFF32];
508 case BFD_RELOC_SPARC_TLS_TPOFF64:
509 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_TPOFF64];
511 case BFD_RELOC_SPARC_GOTDATA_HIX22:
512 return &_bfd_sparc_elf_howto_table[R_SPARC_GOTDATA_HIX22];
514 case BFD_RELOC_SPARC_GOTDATA_LOX10:
515 return &_bfd_sparc_elf_howto_table[R_SPARC_GOTDATA_LOX10];
517 case BFD_RELOC_SPARC_GOTDATA_OP_HIX22:
518 return &_bfd_sparc_elf_howto_table[R_SPARC_GOTDATA_OP_HIX22];
520 case BFD_RELOC_SPARC_GOTDATA_OP_LOX10:
521 return &_bfd_sparc_elf_howto_table[R_SPARC_GOTDATA_OP_LOX10];
523 case BFD_RELOC_SPARC_GOTDATA_OP:
524 return &_bfd_sparc_elf_howto_table[R_SPARC_GOTDATA_OP];
526 case BFD_RELOC_SPARC_JMP_IREL:
527 return &sparc_jmp_irel_howto;
529 case BFD_RELOC_SPARC_IRELATIVE:
530 return &sparc_irelative_howto;
532 case BFD_RELOC_VTABLE_INHERIT:
533 return &sparc_vtinherit_howto;
535 case BFD_RELOC_VTABLE_ENTRY:
536 return &sparc_vtentry_howto;
538 case BFD_RELOC_SPARC_REV32:
539 return &sparc_rev32_howto;
544 bfd_set_error (bfd_error_bad_value);
549 _bfd_sparc_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
555 i < (sizeof (_bfd_sparc_elf_howto_table)
556 / sizeof (_bfd_sparc_elf_howto_table[0]));
558 if (_bfd_sparc_elf_howto_table[i].name != NULL
559 && strcasecmp (_bfd_sparc_elf_howto_table[i].name, r_name) == 0)
560 return &_bfd_sparc_elf_howto_table[i];
562 if (strcasecmp (sparc_vtinherit_howto.name, r_name) == 0)
563 return &sparc_vtinherit_howto;
564 if (strcasecmp (sparc_vtentry_howto.name, r_name) == 0)
565 return &sparc_vtentry_howto;
566 if (strcasecmp (sparc_rev32_howto.name, r_name) == 0)
567 return &sparc_rev32_howto;
573 _bfd_sparc_elf_info_to_howto_ptr (unsigned int r_type)
577 case R_SPARC_JMP_IREL:
578 return &sparc_jmp_irel_howto;
580 case R_SPARC_IRELATIVE:
581 return &sparc_irelative_howto;
583 case R_SPARC_GNU_VTINHERIT:
584 return &sparc_vtinherit_howto;
586 case R_SPARC_GNU_VTENTRY:
587 return &sparc_vtentry_howto;
590 return &sparc_rev32_howto;
593 if (r_type >= (unsigned int) R_SPARC_max_std)
595 (*_bfd_error_handler) (_("invalid relocation type %d"),
597 r_type = R_SPARC_NONE;
599 return &_bfd_sparc_elf_howto_table[r_type];
603 /* Both 32-bit and 64-bit sparc encode this in an identical manner,
604 so just take advantage of that. */
605 #define SPARC_ELF_R_TYPE(r_info) \
609 _bfd_sparc_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
610 Elf_Internal_Rela *dst)
612 unsigned int r_type = SPARC_ELF_R_TYPE (dst->r_info);
614 cache_ptr->howto = _bfd_sparc_elf_info_to_howto_ptr (r_type);
618 /* The nop opcode we use. */
619 #define SPARC_NOP 0x01000000
621 #define SPARC_INSN_BYTES 4
623 /* The SPARC linker needs to keep track of the number of relocs that it
624 decides to copy as dynamic relocs in check_relocs for each symbol.
625 This is so that it can later discard them if they are found to be
626 unnecessary. We store the information in a field extending the
627 regular ELF linker hash table. */
629 struct _bfd_sparc_elf_dyn_relocs
631 struct _bfd_sparc_elf_dyn_relocs *next;
633 /* The input section of the reloc. */
636 /* Total number of relocs copied for the input section. */
639 /* Number of pc-relative relocs copied for the input section. */
640 bfd_size_type pc_count;
643 /* SPARC ELF linker hash entry. */
645 struct _bfd_sparc_elf_link_hash_entry
647 struct elf_link_hash_entry elf;
649 /* Track dynamic relocs copied for this symbol. */
650 struct _bfd_sparc_elf_dyn_relocs *dyn_relocs;
652 #define GOT_UNKNOWN 0
656 unsigned char tls_type;
659 #define _bfd_sparc_elf_hash_entry(ent) ((struct _bfd_sparc_elf_link_hash_entry *)(ent))
661 struct _bfd_sparc_elf_obj_tdata
663 struct elf_obj_tdata root;
665 /* tls_type for each local got entry. */
666 char *local_got_tls_type;
668 /* TRUE if TLS GD relocs has been seen for this object. */
669 bfd_boolean has_tlsgd;
672 #define _bfd_sparc_elf_tdata(abfd) \
673 ((struct _bfd_sparc_elf_obj_tdata *) (abfd)->tdata.any)
675 #define _bfd_sparc_elf_local_got_tls_type(abfd) \
676 (_bfd_sparc_elf_tdata (abfd)->local_got_tls_type)
678 #define is_sparc_elf(bfd) \
679 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
680 && elf_tdata (bfd) != NULL \
681 && elf_object_id (bfd) == SPARC_ELF_DATA)
684 _bfd_sparc_elf_mkobject (bfd *abfd)
686 return bfd_elf_allocate_object (abfd, sizeof (struct _bfd_sparc_elf_obj_tdata),
691 sparc_put_word_32 (bfd *abfd, bfd_vma val, void *ptr)
693 bfd_put_32 (abfd, val, ptr);
697 sparc_put_word_64 (bfd *abfd, bfd_vma val, void *ptr)
699 bfd_put_64 (abfd, val, ptr);
703 sparc_elf_append_rela (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
705 const struct elf_backend_data *bed;
708 bed = get_elf_backend_data (abfd);
709 loc = s->contents + (s->reloc_count++ * bed->s->sizeof_rela);
710 bed->s->swap_reloca_out (abfd, rel, loc);
714 sparc_elf_r_info_64 (Elf_Internal_Rela *in_rel ATTRIBUTE_UNUSED,
715 bfd_vma rel_index ATTRIBUTE_UNUSED,
716 bfd_vma type ATTRIBUTE_UNUSED)
718 return ELF64_R_INFO (rel_index,
720 ELF64_R_TYPE_INFO (ELF64_R_TYPE_DATA (in_rel->r_info),
725 sparc_elf_r_info_32 (Elf_Internal_Rela *in_rel ATTRIBUTE_UNUSED,
726 bfd_vma rel_index, bfd_vma type)
728 return ELF32_R_INFO (rel_index, type);
732 sparc_elf_r_symndx_64 (bfd_vma r_info)
734 bfd_vma r_symndx = ELF32_R_SYM (r_info);
735 return (r_symndx >> 24);
739 sparc_elf_r_symndx_32 (bfd_vma r_info)
741 return ELF32_R_SYM (r_info);
746 #define PLT32_ENTRY_SIZE 12
747 #define PLT32_HEADER_SIZE (4 * PLT32_ENTRY_SIZE)
749 /* The first four entries in a 32-bit procedure linkage table are reserved,
750 and the initial contents are unimportant (we zero them out).
751 Subsequent entries look like this. See the SVR4 ABI SPARC
752 supplement to see how this works. */
754 /* sethi %hi(.-.plt0),%g1. We fill in the address later. */
755 #define PLT32_ENTRY_WORD0 0x03000000
756 /* b,a .plt0. We fill in the offset later. */
757 #define PLT32_ENTRY_WORD1 0x30800000
759 #define PLT32_ENTRY_WORD2 SPARC_NOP
762 sparc32_plt_entry_build (bfd *output_bfd, asection *splt, bfd_vma offset,
763 bfd_vma max ATTRIBUTE_UNUSED,
766 bfd_put_32 (output_bfd,
767 PLT32_ENTRY_WORD0 + offset,
768 splt->contents + offset);
769 bfd_put_32 (output_bfd,
771 + (((- (offset + 4)) >> 2) & 0x3fffff)),
772 splt->contents + offset + 4);
773 bfd_put_32 (output_bfd, (bfd_vma) PLT32_ENTRY_WORD2,
774 splt->contents + offset + 8);
778 return offset / PLT32_ENTRY_SIZE - 4;
781 /* Both the headers and the entries are icache aligned. */
782 #define PLT64_ENTRY_SIZE 32
783 #define PLT64_HEADER_SIZE (4 * PLT64_ENTRY_SIZE)
784 #define PLT64_LARGE_THRESHOLD 32768
787 sparc64_plt_entry_build (bfd *output_bfd, asection *splt, bfd_vma offset,
788 bfd_vma max, bfd_vma *r_offset)
790 unsigned char *entry = splt->contents + offset;
791 const unsigned int nop = SPARC_NOP;
794 if (offset < (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE))
796 unsigned int sethi, ba;
800 plt_index = (offset / PLT64_ENTRY_SIZE);
802 sethi = 0x03000000 | (plt_index * PLT64_ENTRY_SIZE);
804 | (((splt->contents + PLT64_ENTRY_SIZE) - (entry + 4)) / 4 & 0x7ffff);
806 bfd_put_32 (output_bfd, (bfd_vma) sethi, entry);
807 bfd_put_32 (output_bfd, (bfd_vma) ba, entry + 4);
808 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 8);
809 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 12);
810 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 16);
811 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 20);
812 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 24);
813 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 28);
819 int block, last_block, ofs, last_ofs, chunks_this_block;
820 const int insn_chunk_size = (6 * 4);
821 const int ptr_chunk_size = (1 * 8);
822 const int entries_per_block = 160;
823 const int block_size = entries_per_block * (insn_chunk_size
826 /* Entries 32768 and higher are grouped into blocks of 160.
827 The blocks are further subdivided into 160 sequences of
828 6 instructions and 160 pointers. If a block does not require
829 the full 160 entries, let's say it requires N, then there
830 will be N sequences of 6 instructions and N pointers. */
832 offset -= (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE);
833 max -= (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE);
835 block = offset / block_size;
836 last_block = max / block_size;
837 if (block != last_block)
839 chunks_this_block = 160;
843 last_ofs = max % block_size;
844 chunks_this_block = last_ofs / (insn_chunk_size + ptr_chunk_size);
847 ofs = offset % block_size;
849 plt_index = (PLT64_LARGE_THRESHOLD +
851 (ofs / insn_chunk_size));
854 + (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE)
855 + (block * block_size)
856 + (chunks_this_block * insn_chunk_size)
857 + (ofs / insn_chunk_size) * ptr_chunk_size;
859 *r_offset = (bfd_vma) (ptr - splt->contents);
861 ldx = 0xc25be000 | ((ptr - (entry+4)) & 0x1fff);
869 bfd_put_32 (output_bfd, (bfd_vma) 0x8a10000f, entry);
870 bfd_put_32 (output_bfd, (bfd_vma) 0x40000002, entry + 4);
871 bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP, entry + 8);
872 bfd_put_32 (output_bfd, (bfd_vma) ldx, entry + 12);
873 bfd_put_32 (output_bfd, (bfd_vma) 0x83c3c001, entry + 16);
874 bfd_put_32 (output_bfd, (bfd_vma) 0x9e100005, entry + 20);
876 bfd_put_64 (output_bfd, (bfd_vma) (splt->contents - (entry + 4)), ptr);
879 return plt_index - 4;
882 /* The format of the first PLT entry in a VxWorks executable. */
883 static const bfd_vma sparc_vxworks_exec_plt0_entry[] =
885 0x05000000, /* sethi %hi(_GLOBAL_OFFSET_TABLE_+8), %g2 */
886 0x8410a000, /* or %g2, %lo(_GLOBAL_OFFSET_TABLE_+8), %g2 */
887 0xc4008000, /* ld [ %g2 ], %g2 */
888 0x81c08000, /* jmp %g2 */
892 /* The format of subsequent PLT entries. */
893 static const bfd_vma sparc_vxworks_exec_plt_entry[] =
895 0x03000000, /* sethi %hi(_GLOBAL_OFFSET_TABLE_+f@got), %g1 */
896 0x82106000, /* or %g1, %lo(_GLOBAL_OFFSET_TABLE_+f@got), %g1 */
897 0xc2004000, /* ld [ %g1 ], %g1 */
898 0x81c04000, /* jmp %g1 */
899 0x01000000, /* nop */
900 0x03000000, /* sethi %hi(f@pltindex), %g1 */
901 0x10800000, /* b _PLT_resolve */
902 0x82106000 /* or %g1, %lo(f@pltindex), %g1 */
905 /* The format of the first PLT entry in a VxWorks shared object. */
906 static const bfd_vma sparc_vxworks_shared_plt0_entry[] =
908 0xc405e008, /* ld [ %l7 + 8 ], %g2 */
909 0x81c08000, /* jmp %g2 */
913 /* The format of subsequent PLT entries. */
914 static const bfd_vma sparc_vxworks_shared_plt_entry[] =
916 0x03000000, /* sethi %hi(f@got), %g1 */
917 0x82106000, /* or %g1, %lo(f@got), %g1 */
918 0xc205c001, /* ld [ %l7 + %g1 ], %g1 */
919 0x81c04000, /* jmp %g1 */
920 0x01000000, /* nop */
921 0x03000000, /* sethi %hi(f@pltindex), %g1 */
922 0x10800000, /* b _PLT_resolve */
923 0x82106000 /* or %g1, %lo(f@pltindex), %g1 */
926 #define SPARC_ELF_PUT_WORD(htab, bfd, val, ptr) \
927 htab->put_word(bfd, val, ptr)
929 #define SPARC_ELF_R_INFO(htab, in_rel, index, type) \
930 htab->r_info(in_rel, index, type)
932 #define SPARC_ELF_R_SYMNDX(htab, r_info) \
933 htab->r_symndx(r_info)
935 #define SPARC_ELF_WORD_BYTES(htab) \
938 #define SPARC_ELF_RELA_BYTES(htab) \
941 #define SPARC_ELF_DTPOFF_RELOC(htab) \
944 #define SPARC_ELF_DTPMOD_RELOC(htab) \
947 #define SPARC_ELF_TPOFF_RELOC(htab) \
950 #define SPARC_ELF_BUILD_PLT_ENTRY(htab, obfd, splt, off, max, r_off) \
951 htab->build_plt_entry (obfd, splt, off, max, r_off)
953 /* Create an entry in an SPARC ELF linker hash table. */
955 static struct bfd_hash_entry *
956 link_hash_newfunc (struct bfd_hash_entry *entry,
957 struct bfd_hash_table *table, const char *string)
959 /* Allocate the structure if it has not already been allocated by a
963 entry = bfd_hash_allocate (table,
964 sizeof (struct _bfd_sparc_elf_link_hash_entry));
969 /* Call the allocation method of the superclass. */
970 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
973 struct _bfd_sparc_elf_link_hash_entry *eh;
975 eh = (struct _bfd_sparc_elf_link_hash_entry *) entry;
976 eh->dyn_relocs = NULL;
977 eh->tls_type = GOT_UNKNOWN;
983 /* The name of the dynamic interpreter. This is put in the .interp
986 #define ELF32_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
987 #define ELF64_DYNAMIC_INTERPRETER "/usr/lib/sparcv9/ld.so.1"
989 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
990 for local symbol so that we can handle local STT_GNU_IFUNC symbols
991 as global symbol. We reuse indx and dynstr_index for local symbol
992 hash since they aren't used by global symbols in this backend. */
995 elf_sparc_local_htab_hash (const void *ptr)
997 struct elf_link_hash_entry *h
998 = (struct elf_link_hash_entry *) ptr;
999 return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);
1002 /* Compare local hash entries. */
1005 elf_sparc_local_htab_eq (const void *ptr1, const void *ptr2)
1007 struct elf_link_hash_entry *h1
1008 = (struct elf_link_hash_entry *) ptr1;
1009 struct elf_link_hash_entry *h2
1010 = (struct elf_link_hash_entry *) ptr2;
1012 return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
1015 /* Find and/or create a hash entry for local symbol. */
1017 static struct elf_link_hash_entry *
1018 elf_sparc_get_local_sym_hash (struct _bfd_sparc_elf_link_hash_table *htab,
1019 bfd *abfd, const Elf_Internal_Rela *rel,
1022 struct _bfd_sparc_elf_link_hash_entry e, *ret;
1023 asection *sec = abfd->sections;
1024 unsigned long r_symndx;
1028 r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
1029 h = ELF_LOCAL_SYMBOL_HASH (sec->id, r_symndx);
1031 e.elf.indx = sec->id;
1032 e.elf.dynstr_index = r_symndx;
1033 slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,
1034 create ? INSERT : NO_INSERT);
1041 ret = (struct _bfd_sparc_elf_link_hash_entry *) *slot;
1045 ret = (struct _bfd_sparc_elf_link_hash_entry *)
1046 objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,
1047 sizeof (struct _bfd_sparc_elf_link_hash_entry));
1050 memset (ret, 0, sizeof (*ret));
1051 ret->elf.indx = sec->id;
1052 ret->elf.dynstr_index = r_symndx;
1053 ret->elf.dynindx = -1;
1054 ret->elf.plt.offset = (bfd_vma) -1;
1055 ret->elf.got.offset = (bfd_vma) -1;
1061 /* Create a SPARC ELF linker hash table. */
1063 struct bfd_link_hash_table *
1064 _bfd_sparc_elf_link_hash_table_create (bfd *abfd)
1066 struct _bfd_sparc_elf_link_hash_table *ret;
1067 bfd_size_type amt = sizeof (struct _bfd_sparc_elf_link_hash_table);
1069 ret = (struct _bfd_sparc_elf_link_hash_table *) bfd_zmalloc (amt);
1073 if (ABI_64_P (abfd))
1075 ret->put_word = sparc_put_word_64;
1076 ret->r_info = sparc_elf_r_info_64;
1077 ret->r_symndx = sparc_elf_r_symndx_64;
1078 ret->dtpoff_reloc = R_SPARC_TLS_DTPOFF64;
1079 ret->dtpmod_reloc = R_SPARC_TLS_DTPMOD64;
1080 ret->tpoff_reloc = R_SPARC_TLS_TPOFF64;
1081 ret->word_align_power = 3;
1082 ret->align_power_max = 4;
1083 ret->bytes_per_word = 8;
1084 ret->bytes_per_rela = sizeof (Elf64_External_Rela);
1085 ret->dynamic_interpreter = ELF64_DYNAMIC_INTERPRETER;
1086 ret->dynamic_interpreter_size = sizeof ELF64_DYNAMIC_INTERPRETER;
1088 ret->build_plt_entry = sparc64_plt_entry_build;
1089 ret->plt_header_size = PLT64_HEADER_SIZE;
1090 ret->plt_entry_size = PLT64_ENTRY_SIZE;
1094 ret->put_word = sparc_put_word_32;
1095 ret->r_info = sparc_elf_r_info_32;
1096 ret->r_symndx = sparc_elf_r_symndx_32;
1097 ret->dtpoff_reloc = R_SPARC_TLS_DTPOFF32;
1098 ret->dtpmod_reloc = R_SPARC_TLS_DTPMOD32;
1099 ret->tpoff_reloc = R_SPARC_TLS_TPOFF32;
1100 ret->word_align_power = 2;
1101 ret->align_power_max = 3;
1102 ret->bytes_per_word = 4;
1103 ret->bytes_per_rela = sizeof (Elf32_External_Rela);
1104 ret->dynamic_interpreter = ELF32_DYNAMIC_INTERPRETER;
1105 ret->dynamic_interpreter_size = sizeof ELF32_DYNAMIC_INTERPRETER;
1107 ret->build_plt_entry = sparc32_plt_entry_build;
1108 ret->plt_header_size = PLT32_HEADER_SIZE;
1109 ret->plt_entry_size = PLT32_ENTRY_SIZE;
1112 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc,
1113 sizeof (struct _bfd_sparc_elf_link_hash_entry),
1120 ret->loc_hash_table = htab_try_create (1024,
1121 elf_sparc_local_htab_hash,
1122 elf_sparc_local_htab_eq,
1124 ret->loc_hash_memory = objalloc_create ();
1125 if (!ret->loc_hash_table || !ret->loc_hash_memory)
1131 return &ret->elf.root;
1134 /* Destroy a SPARC ELF linker hash table. */
1137 _bfd_sparc_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
1139 struct _bfd_sparc_elf_link_hash_table *htab
1140 = (struct _bfd_sparc_elf_link_hash_table *) hash;
1142 if (htab->loc_hash_table)
1143 htab_delete (htab->loc_hash_table);
1144 if (htab->loc_hash_memory)
1145 objalloc_free ((struct objalloc *) htab->loc_hash_memory);
1146 _bfd_generic_link_hash_table_free (hash);
1149 /* Create .plt, .rela.plt, .got, .rela.got, .dynbss, and
1150 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
1154 _bfd_sparc_elf_create_dynamic_sections (bfd *dynobj,
1155 struct bfd_link_info *info)
1157 struct _bfd_sparc_elf_link_hash_table *htab;
1159 htab = _bfd_sparc_elf_hash_table (info);
1160 BFD_ASSERT (htab != NULL);
1162 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
1165 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
1167 htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss");
1169 if (htab->is_vxworks)
1171 if (!elf_vxworks_create_dynamic_sections (dynobj, info, &htab->srelplt2))
1175 htab->plt_header_size
1176 = 4 * ARRAY_SIZE (sparc_vxworks_shared_plt0_entry);
1177 htab->plt_entry_size
1178 = 4 * ARRAY_SIZE (sparc_vxworks_shared_plt_entry);
1182 htab->plt_header_size
1183 = 4 * ARRAY_SIZE (sparc_vxworks_exec_plt0_entry);
1184 htab->plt_entry_size
1185 = 4 * ARRAY_SIZE (sparc_vxworks_exec_plt_entry);
1189 if (!htab->elf.splt || !htab->elf.srelplt || !htab->sdynbss
1190 || (!info->shared && !htab->srelbss))
1197 create_ifunc_sections (bfd *abfd, struct bfd_link_info *info)
1199 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1200 struct elf_link_hash_table *htab = elf_hash_table (info);
1201 flagword flags, pltflags;
1204 if (htab->irelifunc != NULL || htab->iplt != NULL)
1207 flags = bed->dynamic_sec_flags;
1208 pltflags = flags | SEC_ALLOC | SEC_CODE | SEC_LOAD;
1210 s = bfd_make_section_with_flags (abfd, ".iplt", pltflags);
1212 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
1216 s = bfd_make_section_with_flags (abfd, ".rela.iplt",
1217 flags | SEC_READONLY);
1219 || ! bfd_set_section_alignment (abfd, s,
1220 bed->s->log_file_align))
1227 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1230 _bfd_sparc_elf_copy_indirect_symbol (struct bfd_link_info *info,
1231 struct elf_link_hash_entry *dir,
1232 struct elf_link_hash_entry *ind)
1234 struct _bfd_sparc_elf_link_hash_entry *edir, *eind;
1236 edir = (struct _bfd_sparc_elf_link_hash_entry *) dir;
1237 eind = (struct _bfd_sparc_elf_link_hash_entry *) ind;
1239 if (eind->dyn_relocs != NULL)
1241 if (edir->dyn_relocs != NULL)
1243 struct _bfd_sparc_elf_dyn_relocs **pp;
1244 struct _bfd_sparc_elf_dyn_relocs *p;
1246 /* Add reloc counts against the indirect sym to the direct sym
1247 list. Merge any entries against the same section. */
1248 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1250 struct _bfd_sparc_elf_dyn_relocs *q;
1252 for (q = edir->dyn_relocs; q != NULL; q = q->next)
1253 if (q->sec == p->sec)
1255 q->pc_count += p->pc_count;
1256 q->count += p->count;
1263 *pp = edir->dyn_relocs;
1266 edir->dyn_relocs = eind->dyn_relocs;
1267 eind->dyn_relocs = NULL;
1270 if (ind->root.type == bfd_link_hash_indirect
1271 && dir->got.refcount <= 0)
1273 edir->tls_type = eind->tls_type;
1274 eind->tls_type = GOT_UNKNOWN;
1276 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1280 sparc_elf_tls_transition (struct bfd_link_info *info, bfd *abfd,
1281 int r_type, int is_local)
1283 if (! ABI_64_P (abfd)
1284 && r_type == R_SPARC_TLS_GD_HI22
1285 && ! _bfd_sparc_elf_tdata (abfd)->has_tlsgd)
1286 r_type = R_SPARC_REV32;
1293 case R_SPARC_TLS_GD_HI22:
1295 return R_SPARC_TLS_LE_HIX22;
1296 return R_SPARC_TLS_IE_HI22;
1297 case R_SPARC_TLS_GD_LO10:
1299 return R_SPARC_TLS_LE_LOX10;
1300 return R_SPARC_TLS_IE_LO10;
1301 case R_SPARC_TLS_IE_HI22:
1303 return R_SPARC_TLS_LE_HIX22;
1305 case R_SPARC_TLS_IE_LO10:
1307 return R_SPARC_TLS_LE_LOX10;
1309 case R_SPARC_TLS_LDM_HI22:
1310 return R_SPARC_TLS_LE_HIX22;
1311 case R_SPARC_TLS_LDM_LO10:
1312 return R_SPARC_TLS_LE_LOX10;
1318 /* Look through the relocs for a section during the first phase, and
1319 allocate space in the global offset table or procedure linkage
1323 _bfd_sparc_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
1324 asection *sec, const Elf_Internal_Rela *relocs)
1326 struct _bfd_sparc_elf_link_hash_table *htab;
1327 Elf_Internal_Shdr *symtab_hdr;
1328 struct elf_link_hash_entry **sym_hashes;
1329 const Elf_Internal_Rela *rel;
1330 const Elf_Internal_Rela *rel_end;
1333 bfd_boolean checked_tlsgd = FALSE;
1335 if (info->relocatable)
1338 htab = _bfd_sparc_elf_hash_table (info);
1339 BFD_ASSERT (htab != NULL);
1340 symtab_hdr = &elf_symtab_hdr (abfd);
1341 sym_hashes = elf_sym_hashes (abfd);
1345 if (ABI_64_P (abfd))
1346 num_relocs = NUM_SHDR_ENTRIES (_bfd_elf_single_rel_hdr (sec));
1348 num_relocs = sec->reloc_count;
1350 BFD_ASSERT (is_sparc_elf (abfd) || num_relocs == 0);
1352 if (htab->elf.dynobj == NULL)
1353 htab->elf.dynobj = abfd;
1354 if (!create_ifunc_sections (htab->elf.dynobj, info))
1357 rel_end = relocs + num_relocs;
1358 for (rel = relocs; rel < rel_end; rel++)
1360 unsigned int r_type;
1361 unsigned long r_symndx;
1362 struct elf_link_hash_entry *h;
1363 Elf_Internal_Sym *isym;
1365 r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
1366 r_type = SPARC_ELF_R_TYPE (rel->r_info);
1368 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1370 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1376 if (r_symndx < symtab_hdr->sh_info)
1378 /* A local symbol. */
1379 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1384 /* Check relocation against local STT_GNU_IFUNC symbol. */
1385 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1387 h = elf_sparc_get_local_sym_hash (htab, abfd, rel,
1392 /* Fake a STT_GNU_IFUNC symbol. */
1393 h->type = STT_GNU_IFUNC;
1396 h->forced_local = 1;
1397 h->root.type = bfd_link_hash_defined;
1404 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1405 while (h->root.type == bfd_link_hash_indirect
1406 || h->root.type == bfd_link_hash_warning)
1407 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1410 if (h && h->type == STT_GNU_IFUNC)
1415 h->plt.refcount += 1;
1419 /* Compatibility with old R_SPARC_REV32 reloc conflicting
1420 with R_SPARC_TLS_GD_HI22. */
1421 if (! ABI_64_P (abfd) && ! checked_tlsgd)
1424 case R_SPARC_TLS_GD_HI22:
1426 const Elf_Internal_Rela *relt;
1428 for (relt = rel + 1; relt < rel_end; relt++)
1429 if (ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_LO10
1430 || ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_ADD
1431 || ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_CALL)
1433 checked_tlsgd = TRUE;
1434 _bfd_sparc_elf_tdata (abfd)->has_tlsgd = relt < rel_end;
1437 case R_SPARC_TLS_GD_LO10:
1438 case R_SPARC_TLS_GD_ADD:
1439 case R_SPARC_TLS_GD_CALL:
1440 checked_tlsgd = TRUE;
1441 _bfd_sparc_elf_tdata (abfd)->has_tlsgd = TRUE;
1445 r_type = sparc_elf_tls_transition (info, abfd, r_type, h == NULL);
1448 case R_SPARC_TLS_LDM_HI22:
1449 case R_SPARC_TLS_LDM_LO10:
1450 htab->tls_ldm_got.refcount += 1;
1453 case R_SPARC_TLS_LE_HIX22:
1454 case R_SPARC_TLS_LE_LOX10:
1459 case R_SPARC_TLS_IE_HI22:
1460 case R_SPARC_TLS_IE_LO10:
1462 info->flags |= DF_STATIC_TLS;
1468 case R_SPARC_GOTDATA_HIX22:
1469 case R_SPARC_GOTDATA_LOX10:
1470 case R_SPARC_GOTDATA_OP_HIX22:
1471 case R_SPARC_GOTDATA_OP_LOX10:
1472 case R_SPARC_TLS_GD_HI22:
1473 case R_SPARC_TLS_GD_LO10:
1474 /* This symbol requires a global offset table entry. */
1476 int tls_type, old_tls_type;
1484 case R_SPARC_GOTDATA_OP_HIX22:
1485 case R_SPARC_GOTDATA_OP_LOX10:
1486 tls_type = GOT_NORMAL;
1488 case R_SPARC_TLS_GD_HI22:
1489 case R_SPARC_TLS_GD_LO10:
1490 tls_type = GOT_TLS_GD;
1492 case R_SPARC_TLS_IE_HI22:
1493 case R_SPARC_TLS_IE_LO10:
1494 tls_type = GOT_TLS_IE;
1500 h->got.refcount += 1;
1501 old_tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
1505 bfd_signed_vma *local_got_refcounts;
1507 /* This is a global offset table entry for a local symbol. */
1508 local_got_refcounts = elf_local_got_refcounts (abfd);
1509 if (local_got_refcounts == NULL)
1513 size = symtab_hdr->sh_info;
1514 size *= (sizeof (bfd_signed_vma) + sizeof(char));
1515 local_got_refcounts = ((bfd_signed_vma *)
1516 bfd_zalloc (abfd, size));
1517 if (local_got_refcounts == NULL)
1519 elf_local_got_refcounts (abfd) = local_got_refcounts;
1520 _bfd_sparc_elf_local_got_tls_type (abfd)
1521 = (char *) (local_got_refcounts + symtab_hdr->sh_info);
1525 case R_SPARC_GOTDATA_OP_HIX22:
1526 case R_SPARC_GOTDATA_OP_LOX10:
1530 local_got_refcounts[r_symndx] += 1;
1533 old_tls_type = _bfd_sparc_elf_local_got_tls_type (abfd) [r_symndx];
1536 /* If a TLS symbol is accessed using IE at least once,
1537 there is no point to use dynamic model for it. */
1538 if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1539 && (old_tls_type != GOT_TLS_GD
1540 || tls_type != GOT_TLS_IE))
1542 if (old_tls_type == GOT_TLS_IE && tls_type == GOT_TLS_GD)
1543 tls_type = old_tls_type;
1546 (*_bfd_error_handler)
1547 (_("%B: `%s' accessed both as normal and thread local symbol"),
1548 abfd, h ? h->root.root.string : "<local>");
1553 if (old_tls_type != tls_type)
1556 _bfd_sparc_elf_hash_entry (h)->tls_type = tls_type;
1558 _bfd_sparc_elf_local_got_tls_type (abfd) [r_symndx] = tls_type;
1562 if (htab->elf.sgot == NULL)
1564 if (!_bfd_elf_create_got_section (htab->elf.dynobj, info))
1569 case R_SPARC_TLS_GD_CALL:
1570 case R_SPARC_TLS_LDM_CALL:
1573 /* These are basically R_SPARC_TLS_WPLT30 relocs against
1575 struct bfd_link_hash_entry *bh = NULL;
1576 if (! _bfd_generic_link_add_one_symbol (info, abfd,
1577 "__tls_get_addr", 0,
1578 bfd_und_section_ptr, 0,
1582 h = (struct elf_link_hash_entry *) bh;
1589 case R_SPARC_WPLT30:
1590 case R_SPARC_HIPLT22:
1591 case R_SPARC_LOPLT10:
1592 case R_SPARC_PCPLT32:
1593 case R_SPARC_PCPLT22:
1594 case R_SPARC_PCPLT10:
1596 /* This symbol requires a procedure linkage table entry. We
1597 actually build the entry in adjust_dynamic_symbol,
1598 because this might be a case of linking PIC code without
1599 linking in any dynamic objects, in which case we don't
1600 need to generate a procedure linkage table after all. */
1604 if (! ABI_64_P (abfd))
1606 /* The Solaris native assembler will generate a WPLT30
1607 reloc for a local symbol if you assemble a call from
1608 one section to another when using -K pic. We treat
1610 if (ELF32_R_TYPE (rel->r_info) == R_SPARC_PLT32)
1614 /* PR 7027: We need similar behaviour for 64-bit binaries. */
1615 else if (r_type == R_SPARC_WPLT30)
1618 /* It does not make sense to have a procedure linkage
1619 table entry for a local symbol. */
1620 bfd_set_error (bfd_error_bad_value);
1629 this_r_type = SPARC_ELF_R_TYPE (rel->r_info);
1630 if (this_r_type == R_SPARC_PLT32
1631 || this_r_type == R_SPARC_PLT64)
1634 h->plt.refcount += 1;
1639 case R_SPARC_PC_HH22:
1640 case R_SPARC_PC_HM10:
1641 case R_SPARC_PC_LM22:
1646 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1651 case R_SPARC_DISP16:
1652 case R_SPARC_DISP32:
1653 case R_SPARC_DISP64:
1654 case R_SPARC_WDISP30:
1655 case R_SPARC_WDISP22:
1656 case R_SPARC_WDISP19:
1657 case R_SPARC_WDISP16:
1687 if (h != NULL && !info->shared)
1689 /* We may need a .plt entry if the function this reloc
1690 refers to is in a shared lib. */
1691 h->plt.refcount += 1;
1694 /* If we are creating a shared library, and this is a reloc
1695 against a global symbol, or a non PC relative reloc
1696 against a local symbol, then we need to copy the reloc
1697 into the shared library. However, if we are linking with
1698 -Bsymbolic, we do not need to copy a reloc against a
1699 global symbol which is defined in an object we are
1700 including in the link (i.e., DEF_REGULAR is set). At
1701 this point we have not seen all the input files, so it is
1702 possible that DEF_REGULAR is not set now but will be set
1703 later (it is never cleared). In case of a weak definition,
1704 DEF_REGULAR may be cleared later by a strong definition in
1705 a shared library. We account for that possibility below by
1706 storing information in the relocs_copied field of the hash
1707 table entry. A similar situation occurs when creating
1708 shared libraries and symbol visibility changes render the
1711 If on the other hand, we are creating an executable, we
1712 may need to keep relocations for symbols satisfied by a
1713 dynamic library if we manage to avoid copy relocs for the
1716 && (sec->flags & SEC_ALLOC) != 0
1717 && (! _bfd_sparc_elf_howto_table[r_type].pc_relative
1719 && (! SYMBOLIC_BIND (info, h)
1720 || h->root.type == bfd_link_hash_defweak
1721 || !h->def_regular))))
1723 && (sec->flags & SEC_ALLOC) != 0
1725 && (h->root.type == bfd_link_hash_defweak
1726 || !h->def_regular))
1729 && h->type == STT_GNU_IFUNC))
1731 struct _bfd_sparc_elf_dyn_relocs *p;
1732 struct _bfd_sparc_elf_dyn_relocs **head;
1734 /* When creating a shared object, we must copy these
1735 relocs into the output file. We create a reloc
1736 section in dynobj and make room for the reloc. */
1739 sreloc = _bfd_elf_make_dynamic_reloc_section
1740 (sec, htab->elf.dynobj, htab->word_align_power,
1741 abfd, /*rela?*/ TRUE);
1747 /* If this is a global symbol, we count the number of
1748 relocations we need for this symbol. */
1750 head = &((struct _bfd_sparc_elf_link_hash_entry *) h)->dyn_relocs;
1753 /* Track dynamic relocs needed for local syms too.
1754 We really need local syms available to do this
1759 BFD_ASSERT (isym != NULL);
1760 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1764 vpp = &elf_section_data (s)->local_dynrel;
1765 head = (struct _bfd_sparc_elf_dyn_relocs **) vpp;
1769 if (p == NULL || p->sec != sec)
1771 bfd_size_type amt = sizeof *p;
1772 p = ((struct _bfd_sparc_elf_dyn_relocs *)
1773 bfd_alloc (htab->elf.dynobj, amt));
1784 if (_bfd_sparc_elf_howto_table[r_type].pc_relative)
1790 case R_SPARC_GNU_VTINHERIT:
1791 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1795 case R_SPARC_GNU_VTENTRY:
1796 BFD_ASSERT (h != NULL);
1798 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1802 case R_SPARC_REGISTER:
1803 /* Nothing to do. */
1815 _bfd_sparc_elf_gc_mark_hook (asection *sec,
1816 struct bfd_link_info *info,
1817 Elf_Internal_Rela *rel,
1818 struct elf_link_hash_entry *h,
1819 Elf_Internal_Sym *sym)
1822 switch (SPARC_ELF_R_TYPE (rel->r_info))
1824 case R_SPARC_GNU_VTINHERIT:
1825 case R_SPARC_GNU_VTENTRY:
1829 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1832 /* Update the got entry reference counts for the section being removed. */
1834 _bfd_sparc_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
1835 asection *sec, const Elf_Internal_Rela *relocs)
1837 struct _bfd_sparc_elf_link_hash_table *htab;
1838 Elf_Internal_Shdr *symtab_hdr;
1839 struct elf_link_hash_entry **sym_hashes;
1840 bfd_signed_vma *local_got_refcounts;
1841 const Elf_Internal_Rela *rel, *relend;
1843 if (info->relocatable)
1846 BFD_ASSERT (is_sparc_elf (abfd) || sec->reloc_count == 0);
1848 elf_section_data (sec)->local_dynrel = NULL;
1850 htab = _bfd_sparc_elf_hash_table (info);
1851 BFD_ASSERT (htab != NULL);
1852 symtab_hdr = &elf_symtab_hdr (abfd);
1853 sym_hashes = elf_sym_hashes (abfd);
1854 local_got_refcounts = elf_local_got_refcounts (abfd);
1856 relend = relocs + sec->reloc_count;
1857 for (rel = relocs; rel < relend; rel++)
1859 unsigned long r_symndx;
1860 unsigned int r_type;
1861 struct elf_link_hash_entry *h = NULL;
1863 r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
1864 if (r_symndx >= symtab_hdr->sh_info)
1866 struct _bfd_sparc_elf_link_hash_entry *eh;
1867 struct _bfd_sparc_elf_dyn_relocs **pp;
1868 struct _bfd_sparc_elf_dyn_relocs *p;
1870 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1871 while (h->root.type == bfd_link_hash_indirect
1872 || h->root.type == bfd_link_hash_warning)
1873 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1874 eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
1875 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1878 /* Everything must go for SEC. */
1884 r_type = SPARC_ELF_R_TYPE (rel->r_info);
1885 r_type = sparc_elf_tls_transition (info, abfd, r_type, h != NULL);
1888 case R_SPARC_TLS_LDM_HI22:
1889 case R_SPARC_TLS_LDM_LO10:
1890 if (_bfd_sparc_elf_hash_table (info)->tls_ldm_got.refcount > 0)
1891 _bfd_sparc_elf_hash_table (info)->tls_ldm_got.refcount -= 1;
1894 case R_SPARC_TLS_GD_HI22:
1895 case R_SPARC_TLS_GD_LO10:
1896 case R_SPARC_TLS_IE_HI22:
1897 case R_SPARC_TLS_IE_LO10:
1901 case R_SPARC_GOTDATA_HIX22:
1902 case R_SPARC_GOTDATA_LOX10:
1903 case R_SPARC_GOTDATA_OP_HIX22:
1904 case R_SPARC_GOTDATA_OP_LOX10:
1907 if (h->got.refcount > 0)
1914 case R_SPARC_GOTDATA_OP_HIX22:
1915 case R_SPARC_GOTDATA_OP_LOX10:
1919 if (local_got_refcounts[r_symndx] > 0)
1920 local_got_refcounts[r_symndx]--;
1928 case R_SPARC_PC_HH22:
1929 case R_SPARC_PC_HM10:
1930 case R_SPARC_PC_LM22:
1932 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1937 case R_SPARC_DISP16:
1938 case R_SPARC_DISP32:
1939 case R_SPARC_DISP64:
1940 case R_SPARC_WDISP30:
1941 case R_SPARC_WDISP22:
1942 case R_SPARC_WDISP19:
1943 case R_SPARC_WDISP16:
1974 case R_SPARC_WPLT30:
1977 if (h->plt.refcount > 0)
1990 /* Adjust a symbol defined by a dynamic object and referenced by a
1991 regular object. The current definition is in some section of the
1992 dynamic object, but we're not including those sections. We have to
1993 change the definition to something the rest of the link can
1997 _bfd_sparc_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1998 struct elf_link_hash_entry *h)
2000 struct _bfd_sparc_elf_link_hash_table *htab;
2001 struct _bfd_sparc_elf_link_hash_entry * eh;
2002 struct _bfd_sparc_elf_dyn_relocs *p;
2005 htab = _bfd_sparc_elf_hash_table (info);
2006 BFD_ASSERT (htab != NULL);
2008 /* Make sure we know what is going on here. */
2009 BFD_ASSERT (htab->elf.dynobj != NULL
2011 || h->type == STT_GNU_IFUNC
2012 || h->u.weakdef != NULL
2015 && !h->def_regular)));
2017 /* If this is a function, put it in the procedure linkage table. We
2018 will fill in the contents of the procedure linkage table later
2019 (although we could actually do it here). The STT_NOTYPE
2020 condition is a hack specifically for the Oracle libraries
2021 delivered for Solaris; for some inexplicable reason, they define
2022 some of their functions as STT_NOTYPE when they really should be
2024 if (h->type == STT_FUNC
2025 || h->type == STT_GNU_IFUNC
2027 || (h->type == STT_NOTYPE
2028 && (h->root.type == bfd_link_hash_defined
2029 || h->root.type == bfd_link_hash_defweak)
2030 && (h->root.u.def.section->flags & SEC_CODE) != 0))
2032 if (h->plt.refcount <= 0
2033 || (h->type != STT_GNU_IFUNC
2034 && (SYMBOL_CALLS_LOCAL (info, h)
2035 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2036 && h->root.type == bfd_link_hash_undefweak))))
2038 /* This case can occur if we saw a WPLT30 reloc in an input
2039 file, but the symbol was never referred to by a dynamic
2040 object, or if all references were garbage collected. In
2041 such a case, we don't actually need to build a procedure
2042 linkage table, and we can just do a WDISP30 reloc instead. */
2043 h->plt.offset = (bfd_vma) -1;
2050 h->plt.offset = (bfd_vma) -1;
2052 /* If this is a weak symbol, and there is a real definition, the
2053 processor independent code will have arranged for us to see the
2054 real definition first, and we can just use the same value. */
2055 if (h->u.weakdef != NULL)
2057 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2058 || h->u.weakdef->root.type == bfd_link_hash_defweak);
2059 h->root.u.def.section = h->u.weakdef->root.u.def.section;
2060 h->root.u.def.value = h->u.weakdef->root.u.def.value;
2064 /* This is a reference to a symbol defined by a dynamic object which
2065 is not a function. */
2067 /* If we are creating a shared library, we must presume that the
2068 only references to the symbol are via the global offset table.
2069 For such cases we need not do anything here; the relocations will
2070 be handled correctly by relocate_section. */
2074 /* If there are no references to this symbol that do not use the
2075 GOT, we don't need to generate a copy reloc. */
2076 if (!h->non_got_ref)
2079 /* If -z nocopyreloc was given, we won't generate them either. */
2080 if (info->nocopyreloc)
2086 eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
2087 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2089 s = p->sec->output_section;
2090 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2094 /* If we didn't find any dynamic relocs in read-only sections, then
2095 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2104 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
2105 h->root.root.string);
2109 /* We must allocate the symbol in our .dynbss section, which will
2110 become part of the .bss section of the executable. There will be
2111 an entry for this symbol in the .dynsym section. The dynamic
2112 object will contain position independent code, so all references
2113 from the dynamic object to this symbol will go through the global
2114 offset table. The dynamic linker will use the .dynsym entry to
2115 determine the address it must put in the global offset table, so
2116 both the dynamic object and the regular object will refer to the
2117 same memory location for the variable. */
2119 /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker
2120 to copy the initial value out of the dynamic object and into the
2121 runtime process image. We need to remember the offset into the
2122 .rel.bss section we are going to use. */
2123 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
2125 htab->srelbss->size += SPARC_ELF_RELA_BYTES (htab);
2131 return _bfd_elf_adjust_dynamic_copy (h, s);
2134 /* Allocate space in .plt, .got and associated reloc sections for
2138 allocate_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
2140 struct bfd_link_info *info;
2141 struct _bfd_sparc_elf_link_hash_table *htab;
2142 struct _bfd_sparc_elf_link_hash_entry *eh;
2143 struct _bfd_sparc_elf_dyn_relocs *p;
2145 if (h->root.type == bfd_link_hash_indirect)
2148 if (h->root.type == bfd_link_hash_warning)
2149 /* When warning symbols are created, they **replace** the "real"
2150 entry in the hash table, thus we never get to see the real
2151 symbol in a hash traversal. So look at it now. */
2152 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2154 info = (struct bfd_link_info *) inf;
2155 htab = _bfd_sparc_elf_hash_table (info);
2156 BFD_ASSERT (htab != NULL);
2158 if ((htab->elf.dynamic_sections_created
2159 && h->plt.refcount > 0)
2160 || (h->type == STT_GNU_IFUNC
2164 /* Make sure this symbol is output as a dynamic symbol.
2165 Undefined weak syms won't yet be marked as dynamic. */
2166 if (h->dynindx == -1
2167 && !h->forced_local)
2169 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2173 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h)
2174 || (h->type == STT_GNU_IFUNC
2177 asection *s = htab->elf.splt;
2182 /* Allocate room for the header. */
2185 s->size = htab->plt_header_size;
2187 /* Allocate space for the .rela.plt.unloaded relocations. */
2188 if (htab->is_vxworks && !info->shared)
2189 htab->srelplt2->size = sizeof (Elf32_External_Rela) * 2;
2192 /* The procedure linkage table size is bounded by the magnitude
2193 of the offset we can describe in the entry. */
2194 if (s->size >= (SPARC_ELF_WORD_BYTES(htab) == 8 ?
2195 (((bfd_vma)1 << 31) << 1) : 0x400000))
2197 bfd_set_error (bfd_error_bad_value);
2201 if (SPARC_ELF_WORD_BYTES(htab) == 8
2202 && s->size >= PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE)
2204 bfd_vma off = s->size - PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE;
2207 off = (off % (160 * PLT64_ENTRY_SIZE)) / PLT64_ENTRY_SIZE;
2209 h->plt.offset = (s->size - (off * 8));
2212 h->plt.offset = s->size;
2214 /* If this symbol is not defined in a regular file, and we are
2215 not generating a shared library, then set the symbol to this
2216 location in the .plt. This is required to make function
2217 pointers compare as equal between the normal executable and
2218 the shared library. */
2222 h->root.u.def.section = s;
2223 h->root.u.def.value = h->plt.offset;
2226 /* Make room for this entry. */
2227 s->size += htab->plt_entry_size;
2229 /* We also need to make an entry in the .rela.plt section. */
2230 if (s == htab->elf.splt)
2231 htab->elf.srelplt->size += SPARC_ELF_RELA_BYTES (htab);
2233 htab->elf.irelplt->size += SPARC_ELF_RELA_BYTES (htab);
2235 if (htab->is_vxworks)
2237 /* Allocate space for the .got.plt entry. */
2238 htab->elf.sgotplt->size += 4;
2240 /* ...and for the .rela.plt.unloaded relocations. */
2242 htab->srelplt2->size += sizeof (Elf32_External_Rela) * 3;
2247 h->plt.offset = (bfd_vma) -1;
2253 h->plt.offset = (bfd_vma) -1;
2257 /* If R_SPARC_TLS_IE_{HI22,LO10} symbol is now local to the binary,
2258 make it a R_SPARC_TLS_LE_{HI22,LO10} requiring no TLS entry. */
2259 if (h->got.refcount > 0
2262 && _bfd_sparc_elf_hash_entry(h)->tls_type == GOT_TLS_IE)
2263 h->got.offset = (bfd_vma) -1;
2264 else if (h->got.refcount > 0)
2268 int tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
2270 /* Make sure this symbol is output as a dynamic symbol.
2271 Undefined weak syms won't yet be marked as dynamic. */
2272 if (h->dynindx == -1
2273 && !h->forced_local)
2275 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2280 h->got.offset = s->size;
2281 s->size += SPARC_ELF_WORD_BYTES (htab);
2282 /* R_SPARC_TLS_GD_HI{22,LO10} needs 2 consecutive GOT slots. */
2283 if (tls_type == GOT_TLS_GD)
2284 s->size += SPARC_ELF_WORD_BYTES (htab);
2285 dyn = htab->elf.dynamic_sections_created;
2286 /* R_SPARC_TLS_IE_{HI22,LO10} needs one dynamic relocation,
2287 R_SPARC_TLS_GD_{HI22,LO10} needs one if local symbol and two if
2289 if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
2290 || tls_type == GOT_TLS_IE
2291 || h->type == STT_GNU_IFUNC)
2292 htab->elf.srelgot->size += SPARC_ELF_RELA_BYTES (htab);
2293 else if (tls_type == GOT_TLS_GD)
2294 htab->elf.srelgot->size += 2 * SPARC_ELF_RELA_BYTES (htab);
2295 else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
2296 htab->elf.srelgot->size += SPARC_ELF_RELA_BYTES (htab);
2299 h->got.offset = (bfd_vma) -1;
2301 eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
2302 if (eh->dyn_relocs == NULL)
2305 /* In the shared -Bsymbolic case, discard space allocated for
2306 dynamic pc-relative relocs against symbols which turn out to be
2307 defined in regular objects. For the normal shared case, discard
2308 space for pc-relative relocs that have become local due to symbol
2309 visibility changes. */
2313 if (SYMBOL_CALLS_LOCAL (info, h))
2315 struct _bfd_sparc_elf_dyn_relocs **pp;
2317 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2319 p->count -= p->pc_count;
2328 if (htab->is_vxworks)
2330 struct _bfd_sparc_elf_dyn_relocs **pp;
2332 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2334 if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
2341 /* Also discard relocs on undefined weak syms with non-default
2343 if (eh->dyn_relocs != NULL
2344 && h->root.type == bfd_link_hash_undefweak)
2346 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2347 eh->dyn_relocs = NULL;
2349 /* Make sure undefined weak symbols are output as a dynamic
2351 else if (h->dynindx == -1
2352 && !h->forced_local)
2354 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2361 /* For the non-shared case, discard space for relocs against
2362 symbols which turn out to need copy relocs or are not
2368 || (htab->elf.dynamic_sections_created
2369 && (h->root.type == bfd_link_hash_undefweak
2370 || h->root.type == bfd_link_hash_undefined))))
2372 /* Make sure this symbol is output as a dynamic symbol.
2373 Undefined weak syms won't yet be marked as dynamic. */
2374 if (h->dynindx == -1
2375 && !h->forced_local)
2377 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2381 /* If that succeeded, we know we'll be keeping all the
2383 if (h->dynindx != -1)
2387 eh->dyn_relocs = NULL;
2392 /* Finally, allocate space. */
2393 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2395 asection *sreloc = elf_section_data (p->sec)->sreloc;
2396 sreloc->size += p->count * SPARC_ELF_RELA_BYTES (htab);
2402 /* Allocate space in .plt, .got and associated reloc sections for
2403 local dynamic relocs. */
2406 allocate_local_dynrelocs (void **slot, void *inf)
2408 struct elf_link_hash_entry *h
2409 = (struct elf_link_hash_entry *) *slot;
2411 if (h->type != STT_GNU_IFUNC
2415 || h->root.type != bfd_link_hash_defined)
2418 return allocate_dynrelocs (h, inf);
2421 /* Find any dynamic relocs that apply to read-only sections. */
2424 readonly_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
2426 struct _bfd_sparc_elf_link_hash_entry *eh;
2427 struct _bfd_sparc_elf_dyn_relocs *p;
2429 if (h->root.type == bfd_link_hash_warning)
2430 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2432 eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
2433 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2435 asection *s = p->sec->output_section;
2437 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2439 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2441 info->flags |= DF_TEXTREL;
2443 /* Not an error, just cut short the traversal. */
2450 /* Return true if the dynamic symbol for a given section should be
2451 omitted when creating a shared library. */
2454 _bfd_sparc_elf_omit_section_dynsym (bfd *output_bfd,
2455 struct bfd_link_info *info,
2458 /* We keep the .got section symbol so that explicit relocations
2459 against the _GLOBAL_OFFSET_TABLE_ symbol emitted in PIC mode
2460 can be turned into relocations against the .got symbol. */
2461 if (strcmp (p->name, ".got") == 0)
2464 return _bfd_elf_link_omit_section_dynsym (output_bfd, info, p);
2467 /* Set the sizes of the dynamic sections. */
2470 _bfd_sparc_elf_size_dynamic_sections (bfd *output_bfd,
2471 struct bfd_link_info *info)
2473 struct _bfd_sparc_elf_link_hash_table *htab;
2478 htab = _bfd_sparc_elf_hash_table (info);
2479 BFD_ASSERT (htab != NULL);
2480 dynobj = htab->elf.dynobj;
2481 BFD_ASSERT (dynobj != NULL);
2483 if (elf_hash_table (info)->dynamic_sections_created)
2485 /* Set the contents of the .interp section to the interpreter. */
2486 if (info->executable)
2488 s = bfd_get_section_by_name (dynobj, ".interp");
2489 BFD_ASSERT (s != NULL);
2490 s->size = htab->dynamic_interpreter_size;
2491 s->contents = (unsigned char *) htab->dynamic_interpreter;
2495 /* Set up .got offsets for local syms, and space for local dynamic
2497 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2499 bfd_signed_vma *local_got;
2500 bfd_signed_vma *end_local_got;
2501 char *local_tls_type;
2502 bfd_size_type locsymcount;
2503 Elf_Internal_Shdr *symtab_hdr;
2506 if (! is_sparc_elf (ibfd))
2509 for (s = ibfd->sections; s != NULL; s = s->next)
2511 struct _bfd_sparc_elf_dyn_relocs *p;
2513 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
2515 if (!bfd_is_abs_section (p->sec)
2516 && bfd_is_abs_section (p->sec->output_section))
2518 /* Input section has been discarded, either because
2519 it is a copy of a linkonce section or due to
2520 linker script /DISCARD/, so we'll be discarding
2523 else if (htab->is_vxworks
2524 && strcmp (p->sec->output_section->name,
2527 /* Relocations in vxworks .tls_vars sections are
2528 handled specially by the loader. */
2530 else if (p->count != 0)
2532 srel = elf_section_data (p->sec)->sreloc;
2533 if (!htab->elf.dynamic_sections_created)
2534 srel = htab->elf.irelplt;
2535 srel->size += p->count * SPARC_ELF_RELA_BYTES (htab);
2536 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2537 info->flags |= DF_TEXTREL;
2542 local_got = elf_local_got_refcounts (ibfd);
2546 symtab_hdr = &elf_symtab_hdr (ibfd);
2547 locsymcount = symtab_hdr->sh_info;
2548 end_local_got = local_got + locsymcount;
2549 local_tls_type = _bfd_sparc_elf_local_got_tls_type (ibfd);
2551 srel = htab->elf.srelgot;
2552 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
2556 *local_got = s->size;
2557 s->size += SPARC_ELF_WORD_BYTES (htab);
2558 if (*local_tls_type == GOT_TLS_GD)
2559 s->size += SPARC_ELF_WORD_BYTES (htab);
2561 || *local_tls_type == GOT_TLS_GD
2562 || *local_tls_type == GOT_TLS_IE)
2563 srel->size += SPARC_ELF_RELA_BYTES (htab);
2566 *local_got = (bfd_vma) -1;
2570 if (htab->tls_ldm_got.refcount > 0)
2572 /* Allocate 2 got entries and 1 dynamic reloc for
2573 R_SPARC_TLS_LDM_{HI22,LO10} relocs. */
2574 htab->tls_ldm_got.offset = htab->elf.sgot->size;
2575 htab->elf.sgot->size += (2 * SPARC_ELF_WORD_BYTES (htab));
2576 htab->elf.srelgot->size += SPARC_ELF_RELA_BYTES (htab);
2579 htab->tls_ldm_got.offset = -1;
2581 /* Allocate global sym .plt and .got entries, and space for global
2582 sym dynamic relocs. */
2583 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
2585 /* Allocate .plt and .got entries, and space for local symbols. */
2586 htab_traverse (htab->loc_hash_table, allocate_local_dynrelocs, info);
2588 if (! ABI_64_P (output_bfd)
2589 && !htab->is_vxworks
2590 && elf_hash_table (info)->dynamic_sections_created)
2592 /* Make space for the trailing nop in .plt. */
2593 if (htab->elf.splt->size > 0)
2594 htab->elf.splt->size += 1 * SPARC_INSN_BYTES;
2596 /* If the .got section is more than 0x1000 bytes, we add
2597 0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13
2598 bit relocations have a greater chance of working.
2600 FIXME: Make this optimization work for 64-bit too. */
2601 if (htab->elf.sgot->size >= 0x1000
2602 && elf_hash_table (info)->hgot->root.u.def.value == 0)
2603 elf_hash_table (info)->hgot->root.u.def.value = 0x1000;
2606 /* The check_relocs and adjust_dynamic_symbol entry points have
2607 determined the sizes of the various dynamic sections. Allocate
2609 for (s = dynobj->sections; s != NULL; s = s->next)
2611 if ((s->flags & SEC_LINKER_CREATED) == 0)
2614 if (s == htab->elf.splt
2615 || s == htab->elf.sgot
2616 || s == htab->sdynbss
2617 || s == htab->elf.iplt
2618 || s == htab->elf.sgotplt)
2620 /* Strip this section if we don't need it; see the
2623 else if (CONST_STRNEQ (s->name, ".rela"))
2627 /* We use the reloc_count field as a counter if we need
2628 to copy relocs into the output file. */
2634 /* It's not one of our sections. */
2640 /* If we don't need this section, strip it from the
2641 output file. This is mostly to handle .rela.bss and
2642 .rela.plt. We must create both sections in
2643 create_dynamic_sections, because they must be created
2644 before the linker maps input sections to output
2645 sections. The linker does that before
2646 adjust_dynamic_symbol is called, and it is that
2647 function which decides whether anything needs to go
2648 into these sections. */
2649 s->flags |= SEC_EXCLUDE;
2653 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2656 /* Allocate memory for the section contents. Zero the memory
2657 for the benefit of .rela.plt, which has 4 unused entries
2658 at the beginning, and we don't want garbage. */
2659 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2660 if (s->contents == NULL)
2664 if (elf_hash_table (info)->dynamic_sections_created)
2666 /* Add some entries to the .dynamic section. We fill in the
2667 values later, in _bfd_sparc_elf_finish_dynamic_sections, but we
2668 must add the entries now so that we get the correct size for
2669 the .dynamic section. The DT_DEBUG entry is filled in by the
2670 dynamic linker and used by the debugger. */
2671 #define add_dynamic_entry(TAG, VAL) \
2672 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2674 if (info->executable)
2676 if (!add_dynamic_entry (DT_DEBUG, 0))
2680 if (htab->elf.srelplt->size != 0)
2682 if (!add_dynamic_entry (DT_PLTGOT, 0)
2683 || !add_dynamic_entry (DT_PLTRELSZ, 0)
2684 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2685 || !add_dynamic_entry (DT_JMPREL, 0))
2689 if (!add_dynamic_entry (DT_RELA, 0)
2690 || !add_dynamic_entry (DT_RELASZ, 0)
2691 || !add_dynamic_entry (DT_RELAENT,
2692 SPARC_ELF_RELA_BYTES (htab)))
2695 /* If any dynamic relocs apply to a read-only section,
2696 then we need a DT_TEXTREL entry. */
2697 if ((info->flags & DF_TEXTREL) == 0)
2698 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
2701 if (info->flags & DF_TEXTREL)
2703 if (!add_dynamic_entry (DT_TEXTREL, 0))
2707 if (ABI_64_P (output_bfd))
2710 struct _bfd_sparc_elf_app_reg * app_regs;
2711 struct elf_strtab_hash *dynstr;
2712 struct elf_link_hash_table *eht = elf_hash_table (info);
2714 /* Add dynamic STT_REGISTER symbols and corresponding DT_SPARC_REGISTER
2715 entries if needed. */
2716 app_regs = _bfd_sparc_elf_hash_table (info)->app_regs;
2717 dynstr = eht->dynstr;
2719 for (reg = 0; reg < 4; reg++)
2720 if (app_regs [reg].name != NULL)
2722 struct elf_link_local_dynamic_entry *entry, *e;
2724 if (!add_dynamic_entry (DT_SPARC_REGISTER, 0))
2727 entry = (struct elf_link_local_dynamic_entry *)
2728 bfd_hash_allocate (&info->hash->table, sizeof (*entry));
2732 /* We cheat here a little bit: the symbol will not be local, so we
2733 put it at the end of the dynlocal linked list. We will fix it
2734 later on, as we have to fix other fields anyway. */
2735 entry->isym.st_value = reg < 2 ? reg + 2 : reg + 4;
2736 entry->isym.st_size = 0;
2737 if (*app_regs [reg].name != '\0')
2739 = _bfd_elf_strtab_add (dynstr, app_regs[reg].name, FALSE);
2741 entry->isym.st_name = 0;
2742 entry->isym.st_other = 0;
2743 entry->isym.st_info = ELF_ST_INFO (app_regs [reg].bind,
2745 entry->isym.st_shndx = app_regs [reg].shndx;
2747 entry->input_bfd = output_bfd;
2748 entry->input_indx = -1;
2750 if (eht->dynlocal == NULL)
2751 eht->dynlocal = entry;
2754 for (e = eht->dynlocal; e->next; e = e->next)
2761 if (htab->is_vxworks
2762 && !elf_vxworks_add_dynamic_entries (output_bfd, info))
2765 #undef add_dynamic_entry
2771 _bfd_sparc_elf_new_section_hook (bfd *abfd, asection *sec)
2773 if (!sec->used_by_bfd)
2775 struct _bfd_sparc_elf_section_data *sdata;
2776 bfd_size_type amt = sizeof (*sdata);
2778 sdata = bfd_zalloc (abfd, amt);
2781 sec->used_by_bfd = sdata;
2784 return _bfd_elf_new_section_hook (abfd, sec);
2788 _bfd_sparc_elf_relax_section (bfd *abfd ATTRIBUTE_UNUSED,
2789 struct bfd_section *section,
2790 struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
2793 if (link_info->relocatable)
2794 (*link_info->callbacks->einfo)
2795 (_("%P%F: --relax and -r may not be used together\n"));
2798 sec_do_relax (section) = 1;
2802 /* Return the base VMA address which should be subtracted from real addresses
2803 when resolving @dtpoff relocation.
2804 This is PT_TLS segment p_vaddr. */
2807 dtpoff_base (struct bfd_link_info *info)
2809 /* If tls_sec is NULL, we should have signalled an error already. */
2810 if (elf_hash_table (info)->tls_sec == NULL)
2812 return elf_hash_table (info)->tls_sec->vma;
2815 /* Return the relocation value for @tpoff relocation
2816 if STT_TLS virtual address is ADDRESS. */
2819 tpoff (struct bfd_link_info *info, bfd_vma address)
2821 struct elf_link_hash_table *htab = elf_hash_table (info);
2822 const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
2823 bfd_vma static_tls_size;
2825 /* If tls_sec is NULL, we should have signalled an error already. */
2826 if (htab->tls_sec == NULL)
2829 /* Consider special static TLS alignment requirements. */
2830 static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
2831 return address - static_tls_size - htab->tls_sec->vma;
2834 /* Return the relocation value for a %gdop relocation. */
2837 gdopoff (struct bfd_link_info *info, bfd_vma address)
2839 struct elf_link_hash_table *htab = elf_hash_table (info);
2842 got_base = (htab->hgot->root.u.def.value
2843 + htab->hgot->root.u.def.section->output_offset
2844 + htab->hgot->root.u.def.section->output_section->vma);
2846 return address - got_base;
2849 /* Relocate a SPARC ELF section. */
2852 _bfd_sparc_elf_relocate_section (bfd *output_bfd,
2853 struct bfd_link_info *info,
2855 asection *input_section,
2857 Elf_Internal_Rela *relocs,
2858 Elf_Internal_Sym *local_syms,
2859 asection **local_sections)
2861 struct _bfd_sparc_elf_link_hash_table *htab;
2862 Elf_Internal_Shdr *symtab_hdr;
2863 struct elf_link_hash_entry **sym_hashes;
2864 bfd_vma *local_got_offsets;
2867 Elf_Internal_Rela *rel;
2868 Elf_Internal_Rela *relend;
2870 bfd_boolean is_vxworks_tls;
2872 htab = _bfd_sparc_elf_hash_table (info);
2873 BFD_ASSERT (htab != NULL);
2874 symtab_hdr = &elf_symtab_hdr (input_bfd);
2875 sym_hashes = elf_sym_hashes (input_bfd);
2876 local_got_offsets = elf_local_got_offsets (input_bfd);
2878 if (elf_hash_table (info)->hgot == NULL)
2881 got_base = elf_hash_table (info)->hgot->root.u.def.value;
2883 sreloc = elf_section_data (input_section)->sreloc;
2884 /* We have to handle relocations in vxworks .tls_vars sections
2885 specially, because the dynamic loader is 'weird'. */
2886 is_vxworks_tls = (htab->is_vxworks && info->shared
2887 && !strcmp (input_section->output_section->name,
2891 if (ABI_64_P (output_bfd))
2892 num_relocs = NUM_SHDR_ENTRIES (_bfd_elf_single_rel_hdr (input_section));
2894 num_relocs = input_section->reloc_count;
2895 relend = relocs + num_relocs;
2896 for (; rel < relend; rel++)
2898 int r_type, tls_type;
2899 reloc_howto_type *howto;
2900 unsigned long r_symndx;
2901 struct elf_link_hash_entry *h;
2902 Elf_Internal_Sym *sym;
2904 bfd_vma relocation, off;
2905 bfd_reloc_status_type r;
2906 bfd_boolean is_plt = FALSE;
2907 bfd_boolean unresolved_reloc;
2909 r_type = SPARC_ELF_R_TYPE (rel->r_info);
2910 if (r_type == R_SPARC_GNU_VTINHERIT
2911 || r_type == R_SPARC_GNU_VTENTRY)
2914 if (r_type < 0 || r_type >= (int) R_SPARC_max_std)
2916 bfd_set_error (bfd_error_bad_value);
2919 howto = _bfd_sparc_elf_howto_table + r_type;
2921 r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
2925 unresolved_reloc = FALSE;
2926 if (r_symndx < symtab_hdr->sh_info)
2928 sym = local_syms + r_symndx;
2929 sec = local_sections[r_symndx];
2930 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2932 if (!info->relocatable
2933 && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
2935 /* Relocate against local STT_GNU_IFUNC symbol. */
2936 h = elf_sparc_get_local_sym_hash (htab, input_bfd,
2941 /* Set STT_GNU_IFUNC symbol value. */
2942 h->root.u.def.value = sym->st_value;
2943 h->root.u.def.section = sec;
2950 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2951 r_symndx, symtab_hdr, sym_hashes,
2953 unresolved_reloc, warned);
2956 /* To avoid generating warning messages about truncated
2957 relocations, set the relocation's address to be the same as
2958 the start of this section. */
2959 if (input_section->output_section != NULL)
2960 relocation = input_section->output_section->vma;
2966 if (sec != NULL && elf_discarded_section (sec))
2968 /* For relocs against symbols from removed linkonce
2969 sections, or sections discarded by a linker script, we
2970 just want the section contents zeroed. Avoid any
2971 special processing. */
2972 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
2978 if (info->relocatable)
2982 && h->type == STT_GNU_IFUNC
2988 if ((input_section->flags & SEC_ALLOC) == 0
2989 || h->plt.offset == (bfd_vma) -1)
2992 plt_sec = htab->elf.splt;
2994 plt_sec =htab->elf.iplt;
2998 case R_SPARC_GOTDATA_OP:
3001 case R_SPARC_GOTDATA_OP_HIX22:
3002 case R_SPARC_GOTDATA_OP_LOX10:
3003 r_type = (r_type == R_SPARC_GOTDATA_OP_HIX22
3006 howto = _bfd_sparc_elf_howto_table + r_type;
3012 if (htab->elf.sgot == NULL)
3014 off = h->got.offset;
3015 if (off == (bfd_vma) -1)
3017 relocation = htab->elf.sgot->output_offset + off - got_base;
3020 case R_SPARC_WPLT30:
3021 case R_SPARC_WDISP30:
3022 relocation = (plt_sec->output_section->vma
3023 + plt_sec->output_offset + h->plt.offset);
3028 if (info->shared && h->non_got_ref)
3030 Elf_Internal_Rela outrel;
3033 offset = _bfd_elf_section_offset (output_bfd, info,
3036 if (offset == (bfd_vma) -1
3037 || offset == (bfd_vma) -2)
3040 outrel.r_offset = (input_section->output_section->vma
3041 + input_section->output_offset
3044 if (h->dynindx == -1
3046 || info->executable)
3048 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
3049 0, R_SPARC_IRELATIVE);
3050 outrel.r_addend = relocation + rel->r_addend;
3054 if (h->dynindx == -1)
3056 outrel.r_info = SPARC_ELF_R_INFO (htab, rel, h->dynindx, r_type);
3057 outrel.r_addend = rel->r_addend;
3060 sparc_elf_append_rela (output_bfd, sreloc, &outrel);
3064 relocation = (plt_sec->output_section->vma
3065 + plt_sec->output_offset + h->plt.offset);
3070 /* We should only see such relocs in static links. */
3073 relocation = (plt_sec->output_section->vma
3074 + plt_sec->output_offset + h->plt.offset);
3078 if (h->root.root.string)
3079 name = h->root.root.string;
3081 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3083 (*_bfd_error_handler)
3084 (_("%B: relocation %s against STT_GNU_IFUNC "
3085 "symbol `%s' isn't handled by %s"), input_bfd,
3086 _bfd_sparc_elf_howto_table[r_type].name,
3087 name, __FUNCTION__);
3088 bfd_set_error (bfd_error_bad_value);
3095 case R_SPARC_GOTDATA_OP_HIX22:
3096 case R_SPARC_GOTDATA_OP_LOX10:
3097 if (SYMBOL_REFERENCES_LOCAL (info, h))
3098 r_type = (r_type == R_SPARC_GOTDATA_OP_HIX22
3099 ? R_SPARC_GOTDATA_HIX22
3100 : R_SPARC_GOTDATA_LOX10);
3102 r_type = (r_type == R_SPARC_GOTDATA_OP_HIX22
3105 howto = _bfd_sparc_elf_howto_table + r_type;
3108 case R_SPARC_GOTDATA_OP:
3109 if (SYMBOL_REFERENCES_LOCAL (info, h))
3111 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3113 /* {ld,ldx} [%rs1 + %rs2], %rd --> add %rs1, %rs2, %rd */
3114 relocation = 0x80000000 | (insn & 0x3e07c01f);
3115 bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3122 case R_SPARC_GOTDATA_HIX22:
3123 case R_SPARC_GOTDATA_LOX10:
3124 relocation = gdopoff (info, relocation);
3130 /* Relocation is to the entry for this symbol in the global
3132 if (htab->elf.sgot == NULL)
3139 off = h->got.offset;
3140 BFD_ASSERT (off != (bfd_vma) -1);
3141 dyn = elf_hash_table (info)->dynamic_sections_created;
3143 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3145 && SYMBOL_REFERENCES_LOCAL (info, h)))
3147 /* This is actually a static link, or it is a
3148 -Bsymbolic link and the symbol is defined
3149 locally, or the symbol was forced to be local
3150 because of a version file. We must initialize
3151 this entry in the global offset table. Since the
3152 offset must always be a multiple of 8 for 64-bit
3153 and 4 for 32-bit, we use the least significant bit
3154 to record whether we have initialized it already.
3156 When doing a dynamic link, we create a .rela.got
3157 relocation entry to initialize the value. This
3158 is done in the finish_dynamic_symbol routine. */
3163 SPARC_ELF_PUT_WORD (htab, output_bfd, relocation,
3164 htab->elf.sgot->contents + off);
3169 unresolved_reloc = FALSE;
3173 BFD_ASSERT (local_got_offsets != NULL
3174 && local_got_offsets[r_symndx] != (bfd_vma) -1);
3176 off = local_got_offsets[r_symndx];
3178 /* The offset must always be a multiple of 8 on 64-bit and
3179 4 on 32-bit. We use the least significant bit to record
3180 whether we have already processed this entry. */
3189 Elf_Internal_Rela outrel;
3191 /* We need to generate a R_SPARC_RELATIVE reloc
3192 for the dynamic linker. */
3193 s = htab->elf.srelgot;
3194 BFD_ASSERT (s != NULL);
3196 outrel.r_offset = (htab->elf.sgot->output_section->vma
3197 + htab->elf.sgot->output_offset
3199 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
3200 0, R_SPARC_RELATIVE);
3201 outrel.r_addend = relocation;
3203 sparc_elf_append_rela (output_bfd, s, &outrel);
3206 SPARC_ELF_PUT_WORD (htab, output_bfd, relocation,
3207 htab->elf.sgot->contents + off);
3208 local_got_offsets[r_symndx] |= 1;
3211 relocation = htab->elf.sgot->output_offset + off - got_base;
3216 if (h == NULL || h->plt.offset == (bfd_vma) -1)
3218 r_type = (r_type == R_SPARC_PLT32) ? R_SPARC_32 : R_SPARC_64;
3223 case R_SPARC_WPLT30:
3224 case R_SPARC_HIPLT22:
3225 case R_SPARC_LOPLT10:
3226 case R_SPARC_PCPLT32:
3227 case R_SPARC_PCPLT22:
3228 case R_SPARC_PCPLT10:
3230 /* Relocation is to the entry for this symbol in the
3231 procedure linkage table. */
3233 if (! ABI_64_P (output_bfd))
3235 /* The Solaris native assembler will generate a WPLT30 reloc
3236 for a local symbol if you assemble a call from one
3237 section to another when using -K pic. We treat it as
3242 /* PR 7027: We need similar behaviour for 64-bit binaries. */
3243 else if (r_type == R_SPARC_WPLT30 && h == NULL)
3247 BFD_ASSERT (h != NULL);
3250 if (h->plt.offset == (bfd_vma) -1 || htab->elf.splt == NULL)
3252 /* We didn't make a PLT entry for this symbol. This
3253 happens when statically linking PIC code, or when
3254 using -Bsymbolic. */
3258 relocation = (htab->elf.splt->output_section->vma
3259 + htab->elf.splt->output_offset
3261 unresolved_reloc = FALSE;
3262 if (r_type == R_SPARC_PLT32 || r_type == R_SPARC_PLT64)
3264 r_type = r_type == R_SPARC_PLT32 ? R_SPARC_32 : R_SPARC_64;
3272 case R_SPARC_PC_HH22:
3273 case R_SPARC_PC_HM10:
3274 case R_SPARC_PC_LM22:
3276 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3280 case R_SPARC_DISP16:
3281 case R_SPARC_DISP32:
3282 case R_SPARC_DISP64:
3283 case R_SPARC_WDISP30:
3284 case R_SPARC_WDISP22:
3285 case R_SPARC_WDISP19:
3286 case R_SPARC_WDISP16:
3313 if ((input_section->flags & SEC_ALLOC) == 0
3319 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3320 || h->root.type != bfd_link_hash_undefweak)
3321 && (! howto->pc_relative
3322 || !SYMBOL_CALLS_LOCAL (info, h)))
3329 || h->root.type == bfd_link_hash_undefweak
3330 || h->root.type == bfd_link_hash_undefined)))
3332 Elf_Internal_Rela outrel;
3333 bfd_boolean skip, relocate = FALSE;
3335 /* When generating a shared object, these relocations
3336 are copied into the output file to be resolved at run
3339 BFD_ASSERT (sreloc != NULL);
3344 _bfd_elf_section_offset (output_bfd, info, input_section,
3346 if (outrel.r_offset == (bfd_vma) -1)
3348 else if (outrel.r_offset == (bfd_vma) -2)
3349 skip = TRUE, relocate = TRUE;
3350 outrel.r_offset += (input_section->output_section->vma
3351 + input_section->output_offset);
3353 /* Optimize unaligned reloc usage now that we know where
3354 it finally resides. */
3358 if (outrel.r_offset & 1)
3359 r_type = R_SPARC_UA16;
3362 if (!(outrel.r_offset & 1))
3363 r_type = R_SPARC_16;
3366 if (outrel.r_offset & 3)
3367 r_type = R_SPARC_UA32;
3370 if (!(outrel.r_offset & 3))
3371 r_type = R_SPARC_32;
3374 if (outrel.r_offset & 7)
3375 r_type = R_SPARC_UA64;
3378 if (!(outrel.r_offset & 7))
3379 r_type = R_SPARC_64;
3382 case R_SPARC_DISP16:
3383 case R_SPARC_DISP32:
3384 case R_SPARC_DISP64:
3385 /* If the symbol is not dynamic, we should not keep
3386 a dynamic relocation. But an .rela.* slot has been
3387 allocated for it, output R_SPARC_NONE.
3388 FIXME: Add code tracking needed dynamic relocs as
3390 if (h->dynindx == -1)
3391 skip = TRUE, relocate = TRUE;
3396 memset (&outrel, 0, sizeof outrel);
3397 /* h->dynindx may be -1 if the symbol was marked to
3399 else if (h != NULL &&
3403 || !SYMBOLIC_BIND (info, h)
3404 || !h->def_regular))
3406 BFD_ASSERT (h->dynindx != -1);
3407 outrel.r_info = SPARC_ELF_R_INFO (htab, rel, h->dynindx, r_type);
3408 outrel.r_addend = rel->r_addend;
3412 if (r_type == R_SPARC_32 || r_type == R_SPARC_64)
3414 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
3415 0, R_SPARC_RELATIVE);
3416 outrel.r_addend = relocation + rel->r_addend;
3422 outrel.r_addend = relocation + rel->r_addend;
3425 sec = htab->elf.splt;
3427 if (bfd_is_abs_section (sec))
3429 else if (sec == NULL || sec->owner == NULL)
3431 bfd_set_error (bfd_error_bad_value);
3438 /* We are turning this relocation into one
3439 against a section symbol. It would be
3440 proper to subtract the symbol's value,
3441 osec->vma, from the emitted reloc addend,
3442 but ld.so expects buggy relocs. */
3443 osec = sec->output_section;
3444 indx = elf_section_data (osec)->dynindx;
3448 osec = htab->elf.text_index_section;
3449 indx = elf_section_data (osec)->dynindx;
3452 /* FIXME: we really should be able to link non-pic
3453 shared libraries. */
3457 (*_bfd_error_handler)
3458 (_("%B: probably compiled without -fPIC?"),
3460 bfd_set_error (bfd_error_bad_value);
3465 outrel.r_info = SPARC_ELF_R_INFO (htab, rel, indx,
3470 sparc_elf_append_rela (output_bfd, sreloc, &outrel);
3472 /* This reloc will be computed at runtime, so there's no
3473 need to do anything now. */
3479 case R_SPARC_TLS_GD_HI22:
3480 if (! ABI_64_P (input_bfd)
3481 && ! _bfd_sparc_elf_tdata (input_bfd)->has_tlsgd)
3483 /* R_SPARC_REV32 used the same reloc number as
3484 R_SPARC_TLS_GD_HI22. */
3485 r_type = R_SPARC_REV32;
3490 case R_SPARC_TLS_GD_LO10:
3491 case R_SPARC_TLS_IE_HI22:
3492 case R_SPARC_TLS_IE_LO10:
3493 r_type = sparc_elf_tls_transition (info, input_bfd, r_type, h == NULL);
3494 tls_type = GOT_UNKNOWN;
3495 if (h == NULL && local_got_offsets)
3496 tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3499 tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3500 if (!info->shared && h->dynindx == -1 && tls_type == GOT_TLS_IE)
3501 switch (SPARC_ELF_R_TYPE (rel->r_info))
3503 case R_SPARC_TLS_GD_HI22:
3504 case R_SPARC_TLS_IE_HI22:
3505 r_type = R_SPARC_TLS_LE_HIX22;
3508 r_type = R_SPARC_TLS_LE_LOX10;
3512 if (tls_type == GOT_TLS_IE)
3515 case R_SPARC_TLS_GD_HI22:
3516 r_type = R_SPARC_TLS_IE_HI22;
3518 case R_SPARC_TLS_GD_LO10:
3519 r_type = R_SPARC_TLS_IE_LO10;
3523 if (r_type == R_SPARC_TLS_LE_HIX22)
3525 relocation = tpoff (info, relocation);
3528 if (r_type == R_SPARC_TLS_LE_LOX10)
3530 /* Change add into xor. */
3531 relocation = tpoff (info, relocation);
3532 bfd_put_32 (output_bfd, (bfd_get_32 (input_bfd,
3533 contents + rel->r_offset)
3534 | 0x80182000), contents + rel->r_offset);
3540 off = h->got.offset;
3545 BFD_ASSERT (local_got_offsets != NULL);
3546 off = local_got_offsets[r_symndx];
3547 local_got_offsets[r_symndx] |= 1;
3551 if (htab->elf.sgot == NULL)
3558 Elf_Internal_Rela outrel;
3561 if (htab->elf.srelgot == NULL)
3564 SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3565 htab->elf.sgot->contents + off);
3566 outrel.r_offset = (htab->elf.sgot->output_section->vma
3567 + htab->elf.sgot->output_offset + off);
3568 indx = h && h->dynindx != -1 ? h->dynindx : 0;
3569 if (r_type == R_SPARC_TLS_IE_HI22
3570 || r_type == R_SPARC_TLS_IE_LO10)
3571 dr_type = SPARC_ELF_TPOFF_RELOC (htab);
3573 dr_type = SPARC_ELF_DTPMOD_RELOC (htab);
3574 if (dr_type == SPARC_ELF_TPOFF_RELOC (htab) && indx == 0)
3575 outrel.r_addend = relocation - dtpoff_base (info);
3577 outrel.r_addend = 0;
3578 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx, dr_type);
3579 sparc_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel);
3581 if (r_type == R_SPARC_TLS_GD_HI22
3582 || r_type == R_SPARC_TLS_GD_LO10)
3586 BFD_ASSERT (! unresolved_reloc);
3587 SPARC_ELF_PUT_WORD (htab, output_bfd,
3588 relocation - dtpoff_base (info),
3589 (htab->elf.sgot->contents + off
3590 + SPARC_ELF_WORD_BYTES (htab)));
3594 SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3595 (htab->elf.sgot->contents + off
3596 + SPARC_ELF_WORD_BYTES (htab)));
3597 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx,
3598 SPARC_ELF_DTPOFF_RELOC (htab));
3599 outrel.r_offset += SPARC_ELF_WORD_BYTES (htab);
3600 sparc_elf_append_rela (output_bfd, htab->elf.srelgot,
3604 else if (dr_type == SPARC_ELF_DTPMOD_RELOC (htab))
3606 SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3607 (htab->elf.sgot->contents + off
3608 + SPARC_ELF_WORD_BYTES (htab)));
3612 if (off >= (bfd_vma) -2)
3615 relocation = htab->elf.sgot->output_offset + off - got_base;
3616 unresolved_reloc = FALSE;
3617 howto = _bfd_sparc_elf_howto_table + r_type;
3620 case R_SPARC_TLS_LDM_HI22:
3621 case R_SPARC_TLS_LDM_LO10:
3624 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3627 off = htab->tls_ldm_got.offset;
3628 htab->tls_ldm_got.offset |= 1;
3629 goto r_sparc_tlsldm;
3631 case R_SPARC_TLS_LDO_HIX22:
3632 case R_SPARC_TLS_LDO_LOX10:
3635 relocation -= dtpoff_base (info);
3639 r_type = (r_type == R_SPARC_TLS_LDO_HIX22
3640 ? R_SPARC_TLS_LE_HIX22 : R_SPARC_TLS_LE_LOX10);
3643 case R_SPARC_TLS_LE_HIX22:
3644 case R_SPARC_TLS_LE_LOX10:
3647 Elf_Internal_Rela outrel;
3650 BFD_ASSERT (sreloc != NULL);
3653 _bfd_elf_section_offset (output_bfd, info, input_section,
3655 if (outrel.r_offset == (bfd_vma) -1)
3657 else if (outrel.r_offset == (bfd_vma) -2)
3659 outrel.r_offset += (input_section->output_section->vma
3660 + input_section->output_offset);
3662 memset (&outrel, 0, sizeof outrel);
3665 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, r_type);
3666 outrel.r_addend = relocation - dtpoff_base (info)
3670 sparc_elf_append_rela (output_bfd, sreloc, &outrel);
3673 relocation = tpoff (info, relocation);
3676 case R_SPARC_TLS_LDM_CALL:
3680 bfd_put_32 (output_bfd, 0x90100000, contents + rel->r_offset);
3685 case R_SPARC_TLS_GD_CALL:
3686 tls_type = GOT_UNKNOWN;
3687 if (h == NULL && local_got_offsets)
3688 tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3690 tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3692 || (r_type == R_SPARC_TLS_GD_CALL && tls_type == GOT_TLS_IE))
3696 if (!info->shared && (h == NULL || h->dynindx == -1))
3699 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3704 if (rel + 1 < relend
3705 && SPARC_ELF_R_TYPE (rel[1].r_info) == R_SPARC_TLS_GD_ADD
3706 && rel[1].r_offset == rel->r_offset + 4
3707 && SPARC_ELF_R_SYMNDX (htab, rel[1].r_info) == r_symndx
3708 && (((insn = bfd_get_32 (input_bfd,
3709 contents + rel[1].r_offset))
3710 >> 25) & 0x1f) == 8)
3713 call __tls_get_addr, %tgd_call(foo)
3714 add %reg1, %reg2, %o0, %tgd_add(foo)
3715 and change it into IE:
3716 {ld,ldx} [%reg1 + %reg2], %o0, %tie_ldx(foo)
3717 add %g7, %o0, %o0, %tie_add(foo).
3718 add is 0x80000000 | (rd << 25) | (rs1 << 14) | rs2,
3719 ld is 0xc0000000 | (rd << 25) | (rs1 << 14) | rs2,
3720 ldx is 0xc0580000 | (rd << 25) | (rs1 << 14) | rs2. */
3721 bfd_put_32 (output_bfd, insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000),
3722 contents + rel->r_offset);
3723 bfd_put_32 (output_bfd, 0x9001c008,
3724 contents + rel->r_offset + 4);
3729 bfd_put_32 (output_bfd, 0x9001c008, contents + rel->r_offset);
3733 h = (struct elf_link_hash_entry *)
3734 bfd_link_hash_lookup (info->hash, "__tls_get_addr", FALSE,
3736 BFD_ASSERT (h != NULL);
3737 r_type = R_SPARC_WPLT30;
3738 howto = _bfd_sparc_elf_howto_table + r_type;
3739 goto r_sparc_wplt30;
3741 case R_SPARC_TLS_GD_ADD:
3742 tls_type = GOT_UNKNOWN;
3743 if (h == NULL && local_got_offsets)
3744 tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3746 tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3747 if (! info->shared || tls_type == GOT_TLS_IE)
3749 /* add %reg1, %reg2, %reg3, %tgd_add(foo)
3751 {ld,ldx} [%reg1 + %reg2], %reg3, %tie_ldx(foo)
3753 add %g7, %reg2, %reg3. */
3754 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3755 if ((h != NULL && h->dynindx != -1) || info->shared)
3756 relocation = insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000);
3758 relocation = (insn & ~0x7c000) | 0x1c000;
3759 bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3763 case R_SPARC_TLS_LDM_ADD:
3765 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3768 case R_SPARC_TLS_LDO_ADD:
3771 /* Change rs1 into %g7. */
3772 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3773 insn = (insn & ~0x7c000) | 0x1c000;
3774 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3778 case R_SPARC_TLS_IE_LD:
3779 case R_SPARC_TLS_IE_LDX:
3780 if (! info->shared && (h == NULL || h->dynindx == -1))
3782 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3783 int rs2 = insn & 0x1f;
3784 int rd = (insn >> 25) & 0x1f;
3787 relocation = SPARC_NOP;
3789 relocation = 0x80100000 | (insn & 0x3e00001f);
3790 bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3794 case R_SPARC_TLS_IE_ADD:
3795 /* Totally useless relocation. */
3798 case R_SPARC_TLS_DTPOFF32:
3799 case R_SPARC_TLS_DTPOFF64:
3800 relocation -= dtpoff_base (info);
3807 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3808 because such sections are not SEC_ALLOC and thus ld.so will
3809 not process them. */
3810 if (unresolved_reloc
3811 && !((input_section->flags & SEC_DEBUGGING) != 0
3813 (*_bfd_error_handler)
3814 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3817 (long) rel->r_offset,
3819 h->root.root.string);
3821 r = bfd_reloc_continue;
3822 if (r_type == R_SPARC_OLO10)
3826 if (! ABI_64_P (output_bfd))
3829 relocation += rel->r_addend;
3830 relocation = (relocation & 0x3ff) + ELF64_R_TYPE_DATA (rel->r_info);
3832 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3833 x = (x & ~(bfd_vma) 0x1fff) | (relocation & 0x1fff);
3834 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3836 r = bfd_check_overflow (howto->complain_on_overflow,
3837 howto->bitsize, howto->rightshift,
3838 bfd_arch_bits_per_address (input_bfd),
3841 else if (r_type == R_SPARC_WDISP16)
3845 relocation += rel->r_addend;
3846 relocation -= (input_section->output_section->vma
3847 + input_section->output_offset);
3848 relocation -= rel->r_offset;
3850 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3851 x |= ((((relocation >> 2) & 0xc000) << 6)
3852 | ((relocation >> 2) & 0x3fff));
3853 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3855 r = bfd_check_overflow (howto->complain_on_overflow,
3856 howto->bitsize, howto->rightshift,
3857 bfd_arch_bits_per_address (input_bfd),
3860 else if (r_type == R_SPARC_REV32)
3864 relocation = relocation + rel->r_addend;
3866 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3868 bfd_putl32 (/*input_bfd,*/ x, contents + rel->r_offset);
3871 else if (r_type == R_SPARC_TLS_LDO_HIX22
3872 || r_type == R_SPARC_TLS_LE_HIX22)
3876 relocation += rel->r_addend;
3877 if (r_type == R_SPARC_TLS_LE_HIX22)
3878 relocation ^= MINUS_ONE;
3880 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3881 x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
3882 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3885 else if (r_type == R_SPARC_TLS_LDO_LOX10
3886 || r_type == R_SPARC_TLS_LE_LOX10)
3890 relocation += rel->r_addend;
3891 relocation &= 0x3ff;
3892 if (r_type == R_SPARC_TLS_LE_LOX10)
3893 relocation |= 0x1c00;
3895 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3896 x = (x & ~(bfd_vma) 0x1fff) | relocation;
3897 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3901 else if (r_type == R_SPARC_HIX22
3902 || r_type == R_SPARC_GOTDATA_HIX22)
3906 relocation += rel->r_addend;
3907 if (r_type == R_SPARC_HIX22
3908 || (bfd_signed_vma) relocation < 0)
3909 relocation = relocation ^ MINUS_ONE;
3911 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3912 x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
3913 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3915 r = bfd_check_overflow (howto->complain_on_overflow,
3916 howto->bitsize, howto->rightshift,
3917 bfd_arch_bits_per_address (input_bfd),
3920 else if (r_type == R_SPARC_LOX10
3921 || r_type == R_SPARC_GOTDATA_LOX10)
3925 relocation += rel->r_addend;
3926 if (r_type == R_SPARC_LOX10
3927 || (bfd_signed_vma) relocation < 0)
3928 relocation = (relocation & 0x3ff) | 0x1c00;
3930 relocation = (relocation & 0x3ff);
3932 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3933 x = (x & ~(bfd_vma) 0x1fff) | relocation;
3934 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3938 else if ((r_type == R_SPARC_WDISP30 || r_type == R_SPARC_WPLT30)
3939 && sec_do_relax (input_section)
3940 && rel->r_offset + 4 < input_section->size)
3944 #define XCC (2 << 20)
3945 #define COND(x) (((x)&0xf)<<25)
3946 #define CONDA COND(0x8)
3947 #define INSN_BPA (F2(0,1) | CONDA | BPRED | XCC)
3948 #define INSN_BA (F2(0,2) | CONDA)
3949 #define INSN_OR F3(2, 0x2, 0)
3950 #define INSN_NOP F2(0,4)
3954 /* If the instruction is a call with either:
3956 arithmetic instruction with rd == %o7
3957 where rs1 != %o7 and rs2 if it is register != %o7
3958 then we can optimize if the call destination is near
3959 by changing the call into a branch always. */
3960 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3961 y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
3962 if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2))
3964 if (((y & OP3(~0)) == OP3(0x3d) /* restore */
3965 || ((y & OP3(0x28)) == 0 /* arithmetic */
3966 && (y & RD(~0)) == RD(O7)))
3967 && (y & RS1(~0)) != RS1(O7)
3969 || (y & RS2(~0)) != RS2(O7)))
3973 reloc = relocation + rel->r_addend - rel->r_offset;
3974 reloc -= (input_section->output_section->vma
3975 + input_section->output_offset);
3977 /* Ensure the branch fits into simm22. */
3978 if ((reloc & 3) == 0
3979 && ((reloc & ~(bfd_vma)0x7fffff) == 0
3980 || ((reloc | 0x7fffff) == ~(bfd_vma)0)))
3984 /* Check whether it fits into simm19. */
3985 if (((reloc & 0x3c0000) == 0
3986 || (reloc & 0x3c0000) == 0x3c0000)
3987 && (ABI_64_P (output_bfd)
3988 || elf_elfheader (output_bfd)->e_flags & EF_SPARC_32PLUS))
3989 x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */
3991 x = INSN_BA | (reloc & 0x3fffff); /* ba */
3992 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3994 if (rel->r_offset >= 4
3995 && (y & (0xffffffff ^ RS1(~0)))
3996 == (INSN_OR | RD(O7) | RS2(G0)))
4001 z = bfd_get_32 (input_bfd,
4002 contents + rel->r_offset - 4);
4003 if ((z & (0xffffffff ^ RD(~0)))
4004 != (INSN_OR | RS1(O7) | RS2(G0)))
4012 If call foo was replaced with ba, replace
4013 or %rN, %g0, %o7 with nop. */
4015 reg = (y & RS1(~0)) >> 14;
4016 if (reg != ((z & RD(~0)) >> 25)
4017 || reg == G0 || reg == O7)
4020 bfd_put_32 (input_bfd, (bfd_vma) INSN_NOP,
4021 contents + rel->r_offset + 4);
4029 if (r == bfd_reloc_continue)
4032 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4033 contents, rel->r_offset,
4034 relocation, rel->r_addend);
4036 if (r != bfd_reloc_ok)
4041 case bfd_reloc_outofrange:
4043 case bfd_reloc_overflow:
4047 /* The Solaris native linker silently disregards overflows.
4048 We don't, but this breaks stabs debugging info, whose
4049 relocations are only 32-bits wide. Ignore overflows in
4050 this case and also for discarded entries. */
4051 if ((r_type == R_SPARC_32 || r_type == R_SPARC_DISP32)
4052 && (((input_section->flags & SEC_DEBUGGING) != 0
4053 && strcmp (bfd_section_name (input_bfd,
4056 || _bfd_elf_section_offset (output_bfd, info,
4064 /* Assume this is a call protected by other code that
4065 detect the symbol is undefined. If this is the case,
4066 we can safely ignore the overflow. If not, the
4067 program is hosed anyway, and a little warning isn't
4069 if (h->root.type == bfd_link_hash_undefweak
4070 && howto->pc_relative)
4077 name = bfd_elf_string_from_elf_section (input_bfd,
4078 symtab_hdr->sh_link,
4083 name = bfd_section_name (input_bfd, sec);
4085 if (! ((*info->callbacks->reloc_overflow)
4086 (info, (h ? &h->root : NULL), name, howto->name,
4087 (bfd_vma) 0, input_bfd, input_section,
4099 /* Build a VxWorks PLT entry. PLT_INDEX is the index of the PLT entry
4100 and PLT_OFFSET is the byte offset from the start of .plt. GOT_OFFSET
4101 is the offset of the associated .got.plt entry from
4102 _GLOBAL_OFFSET_TABLE_. */
4105 sparc_vxworks_build_plt_entry (bfd *output_bfd, struct bfd_link_info *info,
4106 bfd_vma plt_offset, bfd_vma plt_index,
4110 const bfd_vma *plt_entry;
4111 struct _bfd_sparc_elf_link_hash_table *htab;
4113 Elf_Internal_Rela rela;
4115 htab = _bfd_sparc_elf_hash_table (info);
4116 BFD_ASSERT (htab != NULL);
4120 plt_entry = sparc_vxworks_shared_plt_entry;
4125 plt_entry = sparc_vxworks_exec_plt_entry;
4126 got_base = (htab->elf.hgot->root.u.def.value
4127 + htab->elf.hgot->root.u.def.section->output_offset
4128 + htab->elf.hgot->root.u.def.section->output_section->vma);
4131 /* Fill in the entry in the procedure linkage table. */
4132 bfd_put_32 (output_bfd, plt_entry[0] + ((got_base + got_offset) >> 10),
4133 htab->elf.splt->contents + plt_offset);
4134 bfd_put_32 (output_bfd, plt_entry[1] + ((got_base + got_offset) & 0x3ff),
4135 htab->elf.splt->contents + plt_offset + 4);
4136 bfd_put_32 (output_bfd, plt_entry[2],
4137 htab->elf.splt->contents + plt_offset + 8);
4138 bfd_put_32 (output_bfd, plt_entry[3],
4139 htab->elf.splt->contents + plt_offset + 12);
4140 bfd_put_32 (output_bfd, plt_entry[4],
4141 htab->elf.splt->contents + plt_offset + 16);
4142 bfd_put_32 (output_bfd, plt_entry[5] + (plt_index >> 10),
4143 htab->elf.splt->contents + plt_offset + 20);
4144 /* PC-relative displacement for a branch to the start of
4146 bfd_put_32 (output_bfd, plt_entry[6] + (((-plt_offset - 24) >> 2)
4148 htab->elf.splt->contents + plt_offset + 24);
4149 bfd_put_32 (output_bfd, plt_entry[7] + (plt_index & 0x3ff),
4150 htab->elf.splt->contents + plt_offset + 28);
4152 /* Fill in the .got.plt entry, pointing initially at the
4153 second half of the PLT entry. */
4154 BFD_ASSERT (htab->elf.sgotplt != NULL);
4155 bfd_put_32 (output_bfd,
4156 htab->elf.splt->output_section->vma
4157 + htab->elf.splt->output_offset
4159 htab->elf.sgotplt->contents + got_offset);
4161 /* Add relocations to .rela.plt.unloaded. */
4164 loc = (htab->srelplt2->contents
4165 + (2 + 3 * plt_index) * sizeof (Elf32_External_Rela));
4167 /* Relocate the initial sethi. */
4168 rela.r_offset = (htab->elf.splt->output_section->vma
4169 + htab->elf.splt->output_offset
4171 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4172 rela.r_addend = got_offset;
4173 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4174 loc += sizeof (Elf32_External_Rela);
4176 /* Likewise the following or. */
4178 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4179 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4180 loc += sizeof (Elf32_External_Rela);
4182 /* Relocate the .got.plt entry. */
4183 rela.r_offset = (htab->elf.sgotplt->output_section->vma
4184 + htab->elf.sgotplt->output_offset
4186 rela.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_SPARC_32);
4187 rela.r_addend = plt_offset + 20;
4188 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4192 /* Finish up dynamic symbol handling. We set the contents of various
4193 dynamic sections here. */
4196 _bfd_sparc_elf_finish_dynamic_symbol (bfd *output_bfd,
4197 struct bfd_link_info *info,
4198 struct elf_link_hash_entry *h,
4199 Elf_Internal_Sym *sym)
4201 struct _bfd_sparc_elf_link_hash_table *htab;
4202 const struct elf_backend_data *bed;
4204 htab = _bfd_sparc_elf_hash_table (info);
4205 BFD_ASSERT (htab != NULL);
4206 bed = get_elf_backend_data (output_bfd);
4208 if (h->plt.offset != (bfd_vma) -1)
4212 Elf_Internal_Rela rela;
4214 bfd_vma r_offset, got_offset;
4217 /* When building a static executable, use .iplt and
4218 .rela.iplt sections for STT_GNU_IFUNC symbols. */
4219 if (htab->elf.splt != NULL)
4221 splt = htab->elf.splt;
4222 srela = htab->elf.srelplt;
4226 splt = htab->elf.iplt;
4227 srela = htab->elf.irelplt;
4230 if (splt == NULL || srela == NULL)
4233 /* Fill in the entry in the .rela.plt section. */
4234 if (htab->is_vxworks)
4236 /* Work out the index of this PLT entry. */
4237 rela_index = ((h->plt.offset - htab->plt_header_size)
4238 / htab->plt_entry_size);
4240 /* Calculate the offset of the associated .got.plt entry.
4241 The first three entries are reserved. */
4242 got_offset = (rela_index + 3) * 4;
4244 sparc_vxworks_build_plt_entry (output_bfd, info, h->plt.offset,
4245 rela_index, got_offset);
4248 /* On VxWorks, the relocation points to the .got.plt entry,
4249 not the .plt entry. */
4250 rela.r_offset = (htab->elf.sgotplt->output_section->vma
4251 + htab->elf.sgotplt->output_offset
4254 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx,
4259 bfd_boolean ifunc = FALSE;
4261 /* Fill in the entry in the procedure linkage table. */
4262 rela_index = SPARC_ELF_BUILD_PLT_ENTRY (htab, output_bfd, splt,
4263 h->plt.offset, splt->size,
4268 || ((info->executable
4269 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
4271 && h->type == STT_GNU_IFUNC))
4274 BFD_ASSERT (h == NULL
4275 || (h->type == STT_GNU_IFUNC
4277 && (h->root.type == bfd_link_hash_defined
4278 || h->root.type == bfd_link_hash_defweak)));
4281 rela.r_offset = r_offset
4282 + (splt->output_section->vma + splt->output_offset);
4283 if (ABI_64_P (output_bfd)
4284 && h->plt.offset >= (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE))
4288 rela.r_addend = (h->root.u.def.section->output_section->vma
4289 + h->root.u.def.section->output_offset
4290 + h->root.u.def.value);
4291 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0,
4296 rela.r_addend = (-(h->plt.offset + 4)
4297 - splt->output_section->vma
4298 - splt->output_offset);
4299 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx,
4307 rela.r_addend = (h->root.u.def.section->output_section->vma
4308 + h->root.u.def.section->output_offset
4309 + h->root.u.def.value);
4310 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0,
4316 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx,
4322 /* Adjust for the first 4 reserved elements in the .plt section
4323 when setting the offset in the .rela.plt section.
4324 Sun forgot to read their own ABI and copied elf32-sparc behaviour,
4325 thus .plt[4] has corresponding .rela.plt[0] and so on. */
4327 loc = srela->contents;
4328 loc += rela_index * bed->s->sizeof_rela;
4329 bed->s->swap_reloca_out (output_bfd, &rela, loc);
4331 if (!h->def_regular)
4333 /* Mark the symbol as undefined, rather than as defined in
4334 the .plt section. Leave the value alone. */
4335 sym->st_shndx = SHN_UNDEF;
4336 /* If the symbol is weak, we do need to clear the value.
4337 Otherwise, the PLT entry would provide a definition for
4338 the symbol even if the symbol wasn't defined anywhere,
4339 and so the symbol would never be NULL. */
4340 if (!h->ref_regular_nonweak)
4345 if (h->got.offset != (bfd_vma) -1
4346 && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_GD
4347 && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_IE)
4351 Elf_Internal_Rela rela;
4353 /* This symbol has an entry in the GOT. Set it up. */
4355 sgot = htab->elf.sgot;
4356 srela = htab->elf.srelgot;
4357 BFD_ASSERT (sgot != NULL && srela != NULL);
4359 rela.r_offset = (sgot->output_section->vma
4360 + sgot->output_offset
4361 + (h->got.offset &~ (bfd_vma) 1));
4363 /* If this is a -Bsymbolic link, and the symbol is defined
4364 locally, we just want to emit a RELATIVE reloc. Likewise if
4365 the symbol was forced to be local because of a version file.
4366 The entry in the global offset table will already have been
4367 initialized in the relocate_section function. */
4369 && h->type == STT_GNU_IFUNC
4374 /* We load the GOT entry with the PLT entry. */
4375 plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
4376 SPARC_ELF_PUT_WORD (htab, output_bfd,
4377 (plt->output_section->vma
4378 + plt->output_offset + h->plt.offset),
4379 htab->elf.sgot->contents
4380 + (h->got.offset & ~(bfd_vma) 1));
4383 else if (info->shared
4384 && SYMBOL_REFERENCES_LOCAL (info, h))
4386 asection *sec = h->root.u.def.section;
4387 if (h->type == STT_GNU_IFUNC)
4388 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, R_SPARC_IRELATIVE);
4390 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, R_SPARC_RELATIVE);
4391 rela.r_addend = (h->root.u.def.value
4392 + sec->output_section->vma
4393 + sec->output_offset);
4397 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_GLOB_DAT);
4401 SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
4402 sgot->contents + (h->got.offset & ~(bfd_vma) 1));
4403 sparc_elf_append_rela (output_bfd, srela, &rela);
4409 Elf_Internal_Rela rela;
4411 /* This symbols needs a copy reloc. Set it up. */
4412 BFD_ASSERT (h->dynindx != -1);
4414 s = bfd_get_section_by_name (h->root.u.def.section->owner,
4416 BFD_ASSERT (s != NULL);
4418 rela.r_offset = (h->root.u.def.value
4419 + h->root.u.def.section->output_section->vma
4420 + h->root.u.def.section->output_offset);
4421 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_COPY);
4423 sparc_elf_append_rela (output_bfd, s, &rela);
4426 /* Mark some specially defined symbols as absolute. On VxWorks,
4427 _GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the
4428 ".got" section. Likewise _PROCEDURE_LINKAGE_TABLE_ and ".plt". */
4430 && (strcmp (h->root.root.string, "_DYNAMIC") == 0
4431 || (!htab->is_vxworks
4432 && (h == htab->elf.hgot || h == htab->elf.hplt))))
4433 sym->st_shndx = SHN_ABS;
4438 /* Finish up the dynamic sections. */
4441 sparc_finish_dyn (bfd *output_bfd, struct bfd_link_info *info,
4442 bfd *dynobj, asection *sdyn,
4443 asection *splt ATTRIBUTE_UNUSED)
4445 struct _bfd_sparc_elf_link_hash_table *htab;
4446 const struct elf_backend_data *bed;
4447 bfd_byte *dyncon, *dynconend;
4449 int stt_regidx = -1;
4450 bfd_boolean abi_64_p;
4452 htab = _bfd_sparc_elf_hash_table (info);
4453 BFD_ASSERT (htab != NULL);
4454 bed = get_elf_backend_data (output_bfd);
4455 dynsize = bed->s->sizeof_dyn;
4456 dynconend = sdyn->contents + sdyn->size;
4457 abi_64_p = ABI_64_P (output_bfd);
4458 for (dyncon = sdyn->contents; dyncon < dynconend; dyncon += dynsize)
4460 Elf_Internal_Dyn dyn;
4464 bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
4466 if (htab->is_vxworks && dyn.d_tag == DT_RELASZ)
4468 /* On VxWorks, DT_RELASZ should not include the relocations
4470 if (htab->elf.srelplt)
4472 dyn.d_un.d_val -= htab->elf.srelplt->size;
4473 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4476 else if (htab->is_vxworks && dyn.d_tag == DT_PLTGOT)
4478 /* On VxWorks, DT_PLTGOT should point to the start of the GOT,
4479 not to the start of the PLT. */
4480 if (htab->elf.sgotplt)
4482 dyn.d_un.d_val = (htab->elf.sgotplt->output_section->vma
4483 + htab->elf.sgotplt->output_offset);
4484 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4487 else if (htab->is_vxworks
4488 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
4489 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4490 else if (abi_64_p && dyn.d_tag == DT_SPARC_REGISTER)
4492 if (stt_regidx == -1)
4495 _bfd_elf_link_lookup_local_dynindx (info, output_bfd, -1);
4496 if (stt_regidx == -1)
4499 dyn.d_un.d_val = stt_regidx++;
4500 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4506 case DT_PLTGOT: name = ".plt"; size = FALSE; break;
4507 case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break;
4508 case DT_JMPREL: name = ".rela.plt"; size = FALSE; break;
4509 default: name = NULL; size = FALSE; break;
4516 s = bfd_get_section_by_name (output_bfd, name);
4522 dyn.d_un.d_ptr = s->vma;
4524 dyn.d_un.d_val = s->size;
4526 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4533 /* Install the first PLT entry in a VxWorks executable and make sure that
4534 .rela.plt.unloaded relocations have the correct symbol indexes. */
4537 sparc_vxworks_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info)
4539 struct _bfd_sparc_elf_link_hash_table *htab;
4540 Elf_Internal_Rela rela;
4544 htab = _bfd_sparc_elf_hash_table (info);
4545 BFD_ASSERT (htab != NULL);
4547 /* Calculate the absolute value of _GLOBAL_OFFSET_TABLE_. */
4548 got_base = (htab->elf.hgot->root.u.def.section->output_section->vma
4549 + htab->elf.hgot->root.u.def.section->output_offset
4550 + htab->elf.hgot->root.u.def.value);
4552 /* Install the initial PLT entry. */
4553 bfd_put_32 (output_bfd,
4554 sparc_vxworks_exec_plt0_entry[0] + ((got_base + 8) >> 10),
4555 htab->elf.splt->contents);
4556 bfd_put_32 (output_bfd,
4557 sparc_vxworks_exec_plt0_entry[1] + ((got_base + 8) & 0x3ff),
4558 htab->elf.splt->contents + 4);
4559 bfd_put_32 (output_bfd,
4560 sparc_vxworks_exec_plt0_entry[2],
4561 htab->elf.splt->contents + 8);
4562 bfd_put_32 (output_bfd,
4563 sparc_vxworks_exec_plt0_entry[3],
4564 htab->elf.splt->contents + 12);
4565 bfd_put_32 (output_bfd,
4566 sparc_vxworks_exec_plt0_entry[4],
4567 htab->elf.splt->contents + 16);
4569 loc = htab->srelplt2->contents;
4571 /* Add an unloaded relocation for the initial entry's "sethi". */
4572 rela.r_offset = (htab->elf.splt->output_section->vma
4573 + htab->elf.splt->output_offset);
4574 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4576 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4577 loc += sizeof (Elf32_External_Rela);
4579 /* Likewise the following "or". */
4581 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4582 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4583 loc += sizeof (Elf32_External_Rela);
4585 /* Fix up the remaining .rela.plt.unloaded relocations. They may have
4586 the wrong symbol index for _G_O_T_ or _P_L_T_ depending on the order
4587 in which symbols were output. */
4588 while (loc < htab->srelplt2->contents + htab->srelplt2->size)
4590 Elf_Internal_Rela rel;
4592 /* The entry's initial "sethi" (against _G_O_T_). */
4593 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4594 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4595 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4596 loc += sizeof (Elf32_External_Rela);
4598 /* The following "or" (also against _G_O_T_). */
4599 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4600 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4601 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4602 loc += sizeof (Elf32_External_Rela);
4604 /* The .got.plt entry (against _P_L_T_). */
4605 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4606 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_SPARC_32);
4607 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4608 loc += sizeof (Elf32_External_Rela);
4612 /* Install the first PLT entry in a VxWorks shared object. */
4615 sparc_vxworks_finish_shared_plt (bfd *output_bfd, struct bfd_link_info *info)
4617 struct _bfd_sparc_elf_link_hash_table *htab;
4620 htab = _bfd_sparc_elf_hash_table (info);
4621 BFD_ASSERT (htab != NULL);
4623 for (i = 0; i < ARRAY_SIZE (sparc_vxworks_shared_plt0_entry); i++)
4624 bfd_put_32 (output_bfd, sparc_vxworks_shared_plt0_entry[i],
4625 htab->elf.splt->contents + i * 4);
4628 /* Finish up local dynamic symbol handling. We set the contents of
4629 various dynamic sections here. */
4632 finish_local_dynamic_symbol (void **slot, void *inf)
4634 struct elf_link_hash_entry *h
4635 = (struct elf_link_hash_entry *) *slot;
4636 struct bfd_link_info *info
4637 = (struct bfd_link_info *) inf;
4639 return _bfd_sparc_elf_finish_dynamic_symbol (info->output_bfd, info,
4644 _bfd_sparc_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
4648 struct _bfd_sparc_elf_link_hash_table *htab;
4650 htab = _bfd_sparc_elf_hash_table (info);
4651 BFD_ASSERT (htab != NULL);
4652 dynobj = htab->elf.dynobj;
4654 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4656 if (elf_hash_table (info)->dynamic_sections_created)
4660 splt = bfd_get_section_by_name (dynobj, ".plt");
4661 BFD_ASSERT (splt != NULL && sdyn != NULL);
4663 if (!sparc_finish_dyn (output_bfd, info, dynobj, sdyn, splt))
4666 /* Initialize the contents of the .plt section. */
4669 if (htab->is_vxworks)
4672 sparc_vxworks_finish_shared_plt (output_bfd, info);
4674 sparc_vxworks_finish_exec_plt (output_bfd, info);
4678 memset (splt->contents, 0, htab->plt_header_size);
4679 if (!ABI_64_P (output_bfd))
4680 bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP,
4681 splt->contents + splt->size - 4);
4685 elf_section_data (splt->output_section)->this_hdr.sh_entsize
4686 = (htab->is_vxworks || !ABI_64_P (output_bfd))
4687 ? 0 : htab->plt_entry_size;
4690 /* Set the first entry in the global offset table to the address of
4691 the dynamic section. */
4692 if (htab->elf.sgot && htab->elf.sgot->size > 0)
4694 bfd_vma val = (sdyn ?
4695 sdyn->output_section->vma + sdyn->output_offset :
4698 SPARC_ELF_PUT_WORD (htab, output_bfd, val, htab->elf.sgot->contents);
4702 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize =
4703 SPARC_ELF_WORD_BYTES (htab);
4705 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
4706 htab_traverse (htab->loc_hash_table, finish_local_dynamic_symbol, info);
4712 /* Set the right machine number for a SPARC ELF file. */
4715 _bfd_sparc_elf_object_p (bfd *abfd)
4717 if (ABI_64_P (abfd))
4719 unsigned long mach = bfd_mach_sparc_v9;
4721 if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
4722 mach = bfd_mach_sparc_v9b;
4723 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
4724 mach = bfd_mach_sparc_v9a;
4725 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, mach);
4729 if (elf_elfheader (abfd)->e_machine == EM_SPARC32PLUS)
4731 if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
4732 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4733 bfd_mach_sparc_v8plusb);
4734 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
4735 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4736 bfd_mach_sparc_v8plusa);
4737 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_32PLUS)
4738 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4739 bfd_mach_sparc_v8plus);
4743 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_LEDATA)
4744 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4745 bfd_mach_sparc_sparclite_le);
4747 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc);
4751 /* Return address for Ith PLT stub in section PLT, for relocation REL
4752 or (bfd_vma) -1 if it should not be included. */
4755 _bfd_sparc_elf_plt_sym_val (bfd_vma i, const asection *plt, const arelent *rel)
4757 if (ABI_64_P (plt->owner))
4761 i += PLT64_HEADER_SIZE / PLT64_ENTRY_SIZE;
4762 if (i < PLT64_LARGE_THRESHOLD)
4763 return plt->vma + i * PLT64_ENTRY_SIZE;
4765 j = (i - PLT64_LARGE_THRESHOLD) % 160;
4767 return plt->vma + i * PLT64_ENTRY_SIZE + j * 4 * 6;
4770 return rel->address;