1 /* SPARC-specific support for ELF
2 Copyright 2005, 2006 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 2 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, MA 02110-1301, USA. */
20 /* This file handles functionality common to the different SPARC ABI's. */
26 #include "libiberty.h"
28 #include "elf/sparc.h"
29 #include "opcode/sparc.h"
30 #include "elfxx-sparc.h"
31 #include "elf-vxworks.h"
33 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
34 #define MINUS_ONE (~ (bfd_vma) 0)
36 #define ABI_64_P(abfd) \
37 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
39 /* The relocation "howto" table. */
41 /* Utility for performing the standard initial work of an instruction
43 *PRELOCATION will contain the relocated item.
44 *PINSN will contain the instruction from the input stream.
45 If the result is `bfd_reloc_other' the caller can continue with
46 performing the relocation. Otherwise it must stop and return the
47 value to its caller. */
49 static bfd_reloc_status_type
50 init_insn_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
51 PTR data, asection *input_section, bfd *output_bfd,
52 bfd_vma *prelocation, bfd_vma *pinsn)
55 reloc_howto_type *howto = reloc_entry->howto;
57 if (output_bfd != (bfd *) NULL
58 && (symbol->flags & BSF_SECTION_SYM) == 0
59 && (! howto->partial_inplace
60 || reloc_entry->addend == 0))
62 reloc_entry->address += input_section->output_offset;
66 /* This works because partial_inplace is FALSE. */
67 if (output_bfd != NULL)
68 return bfd_reloc_continue;
70 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
71 return bfd_reloc_outofrange;
73 relocation = (symbol->value
74 + symbol->section->output_section->vma
75 + symbol->section->output_offset);
76 relocation += reloc_entry->addend;
77 if (howto->pc_relative)
79 relocation -= (input_section->output_section->vma
80 + input_section->output_offset);
81 relocation -= reloc_entry->address;
84 *prelocation = relocation;
85 *pinsn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
86 return bfd_reloc_other;
89 /* For unsupported relocs. */
91 static bfd_reloc_status_type
92 sparc_elf_notsup_reloc (bfd *abfd ATTRIBUTE_UNUSED,
93 arelent *reloc_entry ATTRIBUTE_UNUSED,
94 asymbol *symbol ATTRIBUTE_UNUSED,
95 PTR data ATTRIBUTE_UNUSED,
96 asection *input_section ATTRIBUTE_UNUSED,
97 bfd *output_bfd ATTRIBUTE_UNUSED,
98 char **error_message ATTRIBUTE_UNUSED)
100 return bfd_reloc_notsupported;
103 /* Handle the WDISP16 reloc. */
105 static bfd_reloc_status_type
106 sparc_elf_wdisp16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
107 PTR data, asection *input_section, bfd *output_bfd,
108 char **error_message ATTRIBUTE_UNUSED)
112 bfd_reloc_status_type status;
114 status = init_insn_reloc (abfd, reloc_entry, symbol, data,
115 input_section, output_bfd, &relocation, &insn);
116 if (status != bfd_reloc_other)
119 insn &= ~ (bfd_vma) 0x303fff;
120 insn |= (((relocation >> 2) & 0xc000) << 6) | ((relocation >> 2) & 0x3fff);
121 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
123 if ((bfd_signed_vma) relocation < - 0x40000
124 || (bfd_signed_vma) relocation > 0x3ffff)
125 return bfd_reloc_overflow;
130 /* Handle the HIX22 reloc. */
132 static bfd_reloc_status_type
133 sparc_elf_hix22_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
134 PTR data, asection *input_section, bfd *output_bfd,
135 char **error_message ATTRIBUTE_UNUSED)
139 bfd_reloc_status_type status;
141 status = init_insn_reloc (abfd, reloc_entry, symbol, data,
142 input_section, output_bfd, &relocation, &insn);
143 if (status != bfd_reloc_other)
146 relocation ^= MINUS_ONE;
147 insn = (insn &~ (bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
148 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
150 if ((relocation & ~ (bfd_vma) 0xffffffff) != 0)
151 return bfd_reloc_overflow;
156 /* Handle the LOX10 reloc. */
158 static bfd_reloc_status_type
159 sparc_elf_lox10_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
160 PTR data, asection *input_section, bfd *output_bfd,
161 char **error_message ATTRIBUTE_UNUSED)
165 bfd_reloc_status_type status;
167 status = init_insn_reloc (abfd, reloc_entry, symbol, data,
168 input_section, output_bfd, &relocation, &insn);
169 if (status != bfd_reloc_other)
172 insn = (insn &~ (bfd_vma) 0x1fff) | 0x1c00 | (relocation & 0x3ff);
173 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
178 static reloc_howto_type _bfd_sparc_elf_howto_table[] =
180 HOWTO(R_SPARC_NONE, 0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", FALSE,0,0x00000000,TRUE),
181 HOWTO(R_SPARC_8, 0,0, 8,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_8", FALSE,0,0x000000ff,TRUE),
182 HOWTO(R_SPARC_16, 0,1,16,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_16", FALSE,0,0x0000ffff,TRUE),
183 HOWTO(R_SPARC_32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_32", FALSE,0,0xffffffff,TRUE),
184 HOWTO(R_SPARC_DISP8, 0,0, 8,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP8", FALSE,0,0x000000ff,TRUE),
185 HOWTO(R_SPARC_DISP16, 0,1,16,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP16", FALSE,0,0x0000ffff,TRUE),
186 HOWTO(R_SPARC_DISP32, 0,2,32,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP32", FALSE,0,0xffffffff,TRUE),
187 HOWTO(R_SPARC_WDISP30, 2,2,30,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP30", FALSE,0,0x3fffffff,TRUE),
188 HOWTO(R_SPARC_WDISP22, 2,2,22,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP22", FALSE,0,0x003fffff,TRUE),
189 HOWTO(R_SPARC_HI22, 10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_HI22", FALSE,0,0x003fffff,TRUE),
190 HOWTO(R_SPARC_22, 0,2,22,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_22", FALSE,0,0x003fffff,TRUE),
191 HOWTO(R_SPARC_13, 0,2,13,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_13", FALSE,0,0x00001fff,TRUE),
192 HOWTO(R_SPARC_LO10, 0,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_LO10", FALSE,0,0x000003ff,TRUE),
193 HOWTO(R_SPARC_GOT10, 0,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOT10", FALSE,0,0x000003ff,TRUE),
194 HOWTO(R_SPARC_GOT13, 0,2,13,FALSE,0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_GOT13", FALSE,0,0x00001fff,TRUE),
195 HOWTO(R_SPARC_GOT22, 10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOT22", FALSE,0,0x003fffff,TRUE),
196 HOWTO(R_SPARC_PC10, 0,2,10,TRUE, 0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_PC10", FALSE,0,0x000003ff,TRUE),
197 HOWTO(R_SPARC_PC22, 10,2,22,TRUE, 0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_PC22", FALSE,0,0x003fffff,TRUE),
198 HOWTO(R_SPARC_WPLT30, 2,2,30,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WPLT30", FALSE,0,0x3fffffff,TRUE),
199 HOWTO(R_SPARC_COPY, 0,0,00,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_COPY", FALSE,0,0x00000000,TRUE),
200 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),
201 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),
202 HOWTO(R_SPARC_RELATIVE, 0,0,00,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_RELATIVE",FALSE,0,0x00000000,TRUE),
203 HOWTO(R_SPARC_UA32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA32", FALSE,0,0xffffffff,TRUE),
204 HOWTO(R_SPARC_PLT32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_PLT32", FALSE,0,0xffffffff,TRUE),
205 HOWTO(R_SPARC_HIPLT22, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_HIPLT22", FALSE,0,0x00000000,TRUE),
206 HOWTO(R_SPARC_LOPLT10, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_LOPLT10", FALSE,0,0x00000000,TRUE),
207 HOWTO(R_SPARC_PCPLT32, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PCPLT32", FALSE,0,0x00000000,TRUE),
208 HOWTO(R_SPARC_PCPLT22, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PCPLT22", FALSE,0,0x00000000,TRUE),
209 HOWTO(R_SPARC_PCPLT10, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PCPLT10", FALSE,0,0x00000000,TRUE),
210 HOWTO(R_SPARC_10, 0,2,10,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_10", FALSE,0,0x000003ff,TRUE),
211 HOWTO(R_SPARC_11, 0,2,11,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_11", FALSE,0,0x000007ff,TRUE),
212 HOWTO(R_SPARC_64, 0,4,64,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_64", FALSE,0,MINUS_ONE, TRUE),
213 HOWTO(R_SPARC_OLO10, 0,2,13,FALSE,0,complain_overflow_signed, sparc_elf_notsup_reloc, "R_SPARC_OLO10", FALSE,0,0x00001fff,TRUE),
214 HOWTO(R_SPARC_HH22, 42,2,22,FALSE,0,complain_overflow_unsigned,bfd_elf_generic_reloc, "R_SPARC_HH22", FALSE,0,0x003fffff,TRUE),
215 HOWTO(R_SPARC_HM10, 32,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_HM10", FALSE,0,0x000003ff,TRUE),
216 HOWTO(R_SPARC_LM22, 10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_LM22", FALSE,0,0x003fffff,TRUE),
217 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),
218 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),
219 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),
220 HOWTO(R_SPARC_WDISP16, 2,2,16,TRUE, 0,complain_overflow_signed, sparc_elf_wdisp16_reloc,"R_SPARC_WDISP16", FALSE,0,0x00000000,TRUE),
221 HOWTO(R_SPARC_WDISP19, 2,2,19,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP19", FALSE,0,0x0007ffff,TRUE),
222 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),
223 HOWTO(R_SPARC_7, 0,2, 7,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_7", FALSE,0,0x0000007f,TRUE),
224 HOWTO(R_SPARC_5, 0,2, 5,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_5", FALSE,0,0x0000001f,TRUE),
225 HOWTO(R_SPARC_6, 0,2, 6,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_6", FALSE,0,0x0000003f,TRUE),
226 HOWTO(R_SPARC_DISP64, 0,4,64,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP64", FALSE,0,MINUS_ONE, TRUE),
227 HOWTO(R_SPARC_PLT64, 0,4,64,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_PLT64", FALSE,0,MINUS_ONE, TRUE),
228 HOWTO(R_SPARC_HIX22, 0,4, 0,FALSE,0,complain_overflow_bitfield,sparc_elf_hix22_reloc, "R_SPARC_HIX22", FALSE,0,MINUS_ONE, FALSE),
229 HOWTO(R_SPARC_LOX10, 0,4, 0,FALSE,0,complain_overflow_dont, sparc_elf_lox10_reloc, "R_SPARC_LOX10", FALSE,0,MINUS_ONE, FALSE),
230 HOWTO(R_SPARC_H44, 22,2,22,FALSE,0,complain_overflow_unsigned,bfd_elf_generic_reloc, "R_SPARC_H44", FALSE,0,0x003fffff,FALSE),
231 HOWTO(R_SPARC_M44, 12,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_M44", FALSE,0,0x000003ff,FALSE),
232 HOWTO(R_SPARC_L44, 0,2,13,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_L44", FALSE,0,0x00000fff,FALSE),
233 HOWTO(R_SPARC_REGISTER, 0,4, 0,FALSE,0,complain_overflow_bitfield,sparc_elf_notsup_reloc, "R_SPARC_REGISTER",FALSE,0,MINUS_ONE, FALSE),
234 HOWTO(R_SPARC_UA64, 0,4,64,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA64", FALSE,0,MINUS_ONE, TRUE),
235 HOWTO(R_SPARC_UA16, 0,1,16,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA16", FALSE,0,0x0000ffff,TRUE),
236 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),
237 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),
238 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),
239 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),
240 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),
241 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),
242 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),
243 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),
244 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),
245 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),
246 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),
247 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),
248 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),
249 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),
250 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),
251 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),
252 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),
253 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),
254 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),
255 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),
256 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),
257 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),
258 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),
259 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)
261 static reloc_howto_type sparc_vtinherit_howto =
262 HOWTO (R_SPARC_GNU_VTINHERIT, 0,2,0,FALSE,0,complain_overflow_dont, NULL, "R_SPARC_GNU_VTINHERIT", FALSE,0, 0, FALSE);
263 static reloc_howto_type sparc_vtentry_howto =
264 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);
265 static reloc_howto_type sparc_rev32_howto =
266 HOWTO(R_SPARC_REV32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_REV32", FALSE,0,0xffffffff,TRUE);
268 struct elf_reloc_map {
269 bfd_reloc_code_real_type bfd_reloc_val;
270 unsigned char elf_reloc_val;
273 static const struct elf_reloc_map sparc_reloc_map[] =
275 { BFD_RELOC_NONE, R_SPARC_NONE, },
276 { BFD_RELOC_16, R_SPARC_16, },
277 { BFD_RELOC_16_PCREL, R_SPARC_DISP16 },
278 { BFD_RELOC_8, R_SPARC_8 },
279 { BFD_RELOC_8_PCREL, R_SPARC_DISP8 },
280 { BFD_RELOC_CTOR, R_SPARC_64 },
281 { BFD_RELOC_32, R_SPARC_32 },
282 { BFD_RELOC_32_PCREL, R_SPARC_DISP32 },
283 { BFD_RELOC_HI22, R_SPARC_HI22 },
284 { BFD_RELOC_LO10, R_SPARC_LO10, },
285 { BFD_RELOC_32_PCREL_S2, R_SPARC_WDISP30 },
286 { BFD_RELOC_64_PCREL, R_SPARC_DISP64 },
287 { BFD_RELOC_SPARC22, R_SPARC_22 },
288 { BFD_RELOC_SPARC13, R_SPARC_13 },
289 { BFD_RELOC_SPARC_GOT10, R_SPARC_GOT10 },
290 { BFD_RELOC_SPARC_GOT13, R_SPARC_GOT13 },
291 { BFD_RELOC_SPARC_GOT22, R_SPARC_GOT22 },
292 { BFD_RELOC_SPARC_PC10, R_SPARC_PC10 },
293 { BFD_RELOC_SPARC_PC22, R_SPARC_PC22 },
294 { BFD_RELOC_SPARC_WPLT30, R_SPARC_WPLT30 },
295 { BFD_RELOC_SPARC_COPY, R_SPARC_COPY },
296 { BFD_RELOC_SPARC_GLOB_DAT, R_SPARC_GLOB_DAT },
297 { BFD_RELOC_SPARC_JMP_SLOT, R_SPARC_JMP_SLOT },
298 { BFD_RELOC_SPARC_RELATIVE, R_SPARC_RELATIVE },
299 { BFD_RELOC_SPARC_WDISP22, R_SPARC_WDISP22 },
300 { BFD_RELOC_SPARC_UA16, R_SPARC_UA16 },
301 { BFD_RELOC_SPARC_UA32, R_SPARC_UA32 },
302 { BFD_RELOC_SPARC_UA64, R_SPARC_UA64 },
303 { BFD_RELOC_SPARC_10, R_SPARC_10 },
304 { BFD_RELOC_SPARC_11, R_SPARC_11 },
305 { BFD_RELOC_SPARC_64, R_SPARC_64 },
306 { BFD_RELOC_SPARC_OLO10, R_SPARC_OLO10 },
307 { BFD_RELOC_SPARC_HH22, R_SPARC_HH22 },
308 { BFD_RELOC_SPARC_HM10, R_SPARC_HM10 },
309 { BFD_RELOC_SPARC_LM22, R_SPARC_LM22 },
310 { BFD_RELOC_SPARC_PC_HH22, R_SPARC_PC_HH22 },
311 { BFD_RELOC_SPARC_PC_HM10, R_SPARC_PC_HM10 },
312 { BFD_RELOC_SPARC_PC_LM22, R_SPARC_PC_LM22 },
313 { BFD_RELOC_SPARC_WDISP16, R_SPARC_WDISP16 },
314 { BFD_RELOC_SPARC_WDISP19, R_SPARC_WDISP19 },
315 { BFD_RELOC_SPARC_7, R_SPARC_7 },
316 { BFD_RELOC_SPARC_5, R_SPARC_5 },
317 { BFD_RELOC_SPARC_6, R_SPARC_6 },
318 { BFD_RELOC_SPARC_DISP64, R_SPARC_DISP64 },
319 { BFD_RELOC_SPARC_TLS_GD_HI22, R_SPARC_TLS_GD_HI22 },
320 { BFD_RELOC_SPARC_TLS_GD_LO10, R_SPARC_TLS_GD_LO10 },
321 { BFD_RELOC_SPARC_TLS_GD_ADD, R_SPARC_TLS_GD_ADD },
322 { BFD_RELOC_SPARC_TLS_GD_CALL, R_SPARC_TLS_GD_CALL },
323 { BFD_RELOC_SPARC_TLS_LDM_HI22, R_SPARC_TLS_LDM_HI22 },
324 { BFD_RELOC_SPARC_TLS_LDM_LO10, R_SPARC_TLS_LDM_LO10 },
325 { BFD_RELOC_SPARC_TLS_LDM_ADD, R_SPARC_TLS_LDM_ADD },
326 { BFD_RELOC_SPARC_TLS_LDM_CALL, R_SPARC_TLS_LDM_CALL },
327 { BFD_RELOC_SPARC_TLS_LDO_HIX22, R_SPARC_TLS_LDO_HIX22 },
328 { BFD_RELOC_SPARC_TLS_LDO_LOX10, R_SPARC_TLS_LDO_LOX10 },
329 { BFD_RELOC_SPARC_TLS_LDO_ADD, R_SPARC_TLS_LDO_ADD },
330 { BFD_RELOC_SPARC_TLS_IE_HI22, R_SPARC_TLS_IE_HI22 },
331 { BFD_RELOC_SPARC_TLS_IE_LO10, R_SPARC_TLS_IE_LO10 },
332 { BFD_RELOC_SPARC_TLS_IE_LD, R_SPARC_TLS_IE_LD },
333 { BFD_RELOC_SPARC_TLS_IE_LDX, R_SPARC_TLS_IE_LDX },
334 { BFD_RELOC_SPARC_TLS_IE_ADD, R_SPARC_TLS_IE_ADD },
335 { BFD_RELOC_SPARC_TLS_LE_HIX22, R_SPARC_TLS_LE_HIX22 },
336 { BFD_RELOC_SPARC_TLS_LE_LOX10, R_SPARC_TLS_LE_LOX10 },
337 { BFD_RELOC_SPARC_TLS_DTPMOD32, R_SPARC_TLS_DTPMOD32 },
338 { BFD_RELOC_SPARC_TLS_DTPMOD64, R_SPARC_TLS_DTPMOD64 },
339 { BFD_RELOC_SPARC_TLS_DTPOFF32, R_SPARC_TLS_DTPOFF32 },
340 { BFD_RELOC_SPARC_TLS_DTPOFF64, R_SPARC_TLS_DTPOFF64 },
341 { BFD_RELOC_SPARC_TLS_TPOFF32, R_SPARC_TLS_TPOFF32 },
342 { BFD_RELOC_SPARC_TLS_TPOFF64, R_SPARC_TLS_TPOFF64 },
343 { BFD_RELOC_SPARC_PLT32, R_SPARC_PLT32 },
344 { BFD_RELOC_SPARC_PLT64, R_SPARC_PLT64 },
345 { BFD_RELOC_SPARC_HIX22, R_SPARC_HIX22 },
346 { BFD_RELOC_SPARC_LOX10, R_SPARC_LOX10 },
347 { BFD_RELOC_SPARC_H44, R_SPARC_H44 },
348 { BFD_RELOC_SPARC_M44, R_SPARC_M44 },
349 { BFD_RELOC_SPARC_L44, R_SPARC_L44 },
350 { BFD_RELOC_SPARC_REGISTER, R_SPARC_REGISTER },
351 { BFD_RELOC_VTABLE_INHERIT, R_SPARC_GNU_VTINHERIT },
352 { BFD_RELOC_VTABLE_ENTRY, R_SPARC_GNU_VTENTRY },
353 { BFD_RELOC_SPARC_REV32, R_SPARC_REV32 },
357 _bfd_sparc_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
358 bfd_reloc_code_real_type code)
364 case BFD_RELOC_VTABLE_INHERIT:
365 return &sparc_vtinherit_howto;
367 case BFD_RELOC_VTABLE_ENTRY:
368 return &sparc_vtentry_howto;
370 case BFD_RELOC_SPARC_REV32:
371 return &sparc_rev32_howto;
375 i < sizeof (sparc_reloc_map) / sizeof (struct elf_reloc_map);
378 if (sparc_reloc_map[i].bfd_reloc_val == code)
379 return (_bfd_sparc_elf_howto_table
380 + (int) sparc_reloc_map[i].elf_reloc_val);
383 bfd_set_error (bfd_error_bad_value);
388 _bfd_sparc_elf_info_to_howto_ptr (unsigned int r_type)
392 case R_SPARC_GNU_VTINHERIT:
393 return &sparc_vtinherit_howto;
395 case R_SPARC_GNU_VTENTRY:
396 return &sparc_vtentry_howto;
399 return &sparc_rev32_howto;
402 if (r_type >= (unsigned int) R_SPARC_max_std)
404 (*_bfd_error_handler) (_("invalid relocation type %d"),
406 r_type = R_SPARC_NONE;
408 return &_bfd_sparc_elf_howto_table[r_type];
412 /* Both 32-bit and 64-bit sparc encode this in an identical manner,
413 so just take advantage of that. */
414 #define SPARC_ELF_R_TYPE(r_info) \
418 _bfd_sparc_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
419 Elf_Internal_Rela *dst)
421 unsigned int r_type = SPARC_ELF_R_TYPE (dst->r_info);
423 cache_ptr->howto = _bfd_sparc_elf_info_to_howto_ptr (r_type);
427 /* The nop opcode we use. */
428 #define SPARC_NOP 0x01000000
430 #define SPARC_INSN_BYTES 4
432 /* The SPARC linker needs to keep track of the number of relocs that it
433 decides to copy as dynamic relocs in check_relocs for each symbol.
434 This is so that it can later discard them if they are found to be
435 unnecessary. We store the information in a field extending the
436 regular ELF linker hash table. */
438 struct _bfd_sparc_elf_dyn_relocs
440 struct _bfd_sparc_elf_dyn_relocs *next;
442 /* The input section of the reloc. */
445 /* Total number of relocs copied for the input section. */
448 /* Number of pc-relative relocs copied for the input section. */
449 bfd_size_type pc_count;
452 /* SPARC ELF linker hash entry. */
454 struct _bfd_sparc_elf_link_hash_entry
456 struct elf_link_hash_entry elf;
458 /* Track dynamic relocs copied for this symbol. */
459 struct _bfd_sparc_elf_dyn_relocs *dyn_relocs;
461 #define GOT_UNKNOWN 0
465 unsigned char tls_type;
468 #define _bfd_sparc_elf_hash_entry(ent) ((struct _bfd_sparc_elf_link_hash_entry *)(ent))
470 struct _bfd_sparc_elf_obj_tdata
472 struct elf_obj_tdata root;
474 /* tls_type for each local got entry. */
475 char *local_got_tls_type;
477 /* TRUE if TLS GD relocs has been seen for this object. */
478 bfd_boolean has_tlsgd;
481 #define _bfd_sparc_elf_tdata(abfd) \
482 ((struct _bfd_sparc_elf_obj_tdata *) (abfd)->tdata.any)
484 #define _bfd_sparc_elf_local_got_tls_type(abfd) \
485 (_bfd_sparc_elf_tdata (abfd)->local_got_tls_type)
488 _bfd_sparc_elf_mkobject (bfd *abfd)
490 if (abfd->tdata.any == NULL)
492 bfd_size_type amt = sizeof (struct _bfd_sparc_elf_obj_tdata);
493 abfd->tdata.any = bfd_zalloc (abfd, amt);
494 if (abfd->tdata.any == NULL)
497 return bfd_elf_mkobject (abfd);
501 sparc_put_word_32 (bfd *bfd, bfd_vma val, void *ptr)
503 bfd_put_32 (bfd, val, ptr);
507 sparc_put_word_64 (bfd *bfd, bfd_vma val, void *ptr)
509 bfd_put_64 (bfd, val, ptr);
513 sparc_elf_append_rela_64 (bfd *abfd ATTRIBUTE_UNUSED,
514 asection *s ATTRIBUTE_UNUSED,
515 Elf_Internal_Rela *rel ATTRIBUTE_UNUSED)
518 Elf64_External_Rela *loc64;
520 loc64 = (Elf64_External_Rela *) s->contents;
521 loc64 += s->reloc_count++;
522 bfd_elf64_swap_reloca_out (abfd, rel, (bfd_byte *) loc64);
527 sparc_elf_append_rela_32 (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
529 Elf32_External_Rela *loc32;
531 loc32 = (Elf32_External_Rela *) s->contents;
532 loc32 += s->reloc_count++;
533 bfd_elf32_swap_reloca_out (abfd, rel, (bfd_byte *) loc32);
537 sparc_elf_r_info_64 (Elf_Internal_Rela *in_rel ATTRIBUTE_UNUSED,
538 bfd_vma index ATTRIBUTE_UNUSED,
539 bfd_vma type ATTRIBUTE_UNUSED)
541 return ELF64_R_INFO (index,
543 ELF64_R_TYPE_INFO (ELF64_R_TYPE_DATA (in_rel->r_info),
548 sparc_elf_r_info_32 (Elf_Internal_Rela *in_rel ATTRIBUTE_UNUSED,
549 bfd_vma index, bfd_vma type)
551 return ELF32_R_INFO (index, type);
555 sparc_elf_r_symndx_64 (bfd_vma r_info)
557 bfd_vma r_symndx = ELF32_R_SYM (r_info);
558 return (r_symndx >> 24);
562 sparc_elf_r_symndx_32 (bfd_vma r_info)
564 return ELF32_R_SYM (r_info);
569 #define PLT32_ENTRY_SIZE 12
570 #define PLT32_HEADER_SIZE (4 * PLT32_ENTRY_SIZE)
572 /* The first four entries in a 32-bit procedure linkage table are reserved,
573 and the initial contents are unimportant (we zero them out).
574 Subsequent entries look like this. See the SVR4 ABI SPARC
575 supplement to see how this works. */
577 /* sethi %hi(.-.plt0),%g1. We fill in the address later. */
578 #define PLT32_ENTRY_WORD0 0x03000000
579 /* b,a .plt0. We fill in the offset later. */
580 #define PLT32_ENTRY_WORD1 0x30800000
582 #define PLT32_ENTRY_WORD2 SPARC_NOP
585 sparc32_plt_entry_build (bfd *output_bfd, asection *splt, bfd_vma offset,
586 bfd_vma max ATTRIBUTE_UNUSED,
589 bfd_put_32 (output_bfd,
590 PLT32_ENTRY_WORD0 + offset,
591 splt->contents + offset);
592 bfd_put_32 (output_bfd,
594 + (((- (offset + 4)) >> 2) & 0x3fffff)),
595 splt->contents + offset + 4);
596 bfd_put_32 (output_bfd, (bfd_vma) PLT32_ENTRY_WORD2,
597 splt->contents + offset + 8);
601 return offset / PLT32_ENTRY_SIZE - 4;
604 /* Both the headers and the entries are icache aligned. */
605 #define PLT64_ENTRY_SIZE 32
606 #define PLT64_HEADER_SIZE (4 * PLT64_ENTRY_SIZE)
607 #define PLT64_LARGE_THRESHOLD 32768
610 sparc64_plt_entry_build (bfd *output_bfd, asection *splt, bfd_vma offset,
611 bfd_vma max, bfd_vma *r_offset)
613 unsigned char *entry = splt->contents + offset;
614 const unsigned int nop = SPARC_NOP;
617 if (offset < (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE))
619 unsigned int sethi, ba;
623 index = (offset / PLT64_ENTRY_SIZE);
625 sethi = 0x03000000 | (index * PLT64_ENTRY_SIZE);
627 | (((splt->contents + PLT64_ENTRY_SIZE) - (entry + 4)) / 4 & 0x7ffff);
629 bfd_put_32 (output_bfd, (bfd_vma) sethi, entry);
630 bfd_put_32 (output_bfd, (bfd_vma) ba, entry + 4);
631 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 8);
632 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 12);
633 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 16);
634 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 20);
635 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 24);
636 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 28);
642 int block, last_block, ofs, last_ofs, chunks_this_block;
643 const int insn_chunk_size = (6 * 4);
644 const int ptr_chunk_size = (1 * 8);
645 const int entries_per_block = 160;
646 const int block_size = entries_per_block * (insn_chunk_size
649 /* Entries 32768 and higher are grouped into blocks of 160.
650 The blocks are further subdivided into 160 sequences of
651 6 instructions and 160 pointers. If a block does not require
652 the full 160 entries, let's say it requires N, then there
653 will be N sequences of 6 instructions and N pointers. */
655 offset -= (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE);
656 max -= (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE);
658 block = offset / block_size;
659 last_block = max / block_size;
660 if (block != last_block)
662 chunks_this_block = 160;
666 last_ofs = max % block_size;
667 chunks_this_block = last_ofs / (insn_chunk_size + ptr_chunk_size);
670 ofs = offset % block_size;
672 index = (PLT64_LARGE_THRESHOLD +
674 (ofs / insn_chunk_size));
677 + (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE)
678 + (block * block_size)
679 + (chunks_this_block * insn_chunk_size)
680 + (ofs / insn_chunk_size) * ptr_chunk_size;
682 *r_offset = (bfd_vma) (ptr - splt->contents);
684 ldx = 0xc25be000 | ((ptr - (entry+4)) & 0x1fff);
692 bfd_put_32 (output_bfd, (bfd_vma) 0x8a10000f, entry);
693 bfd_put_32 (output_bfd, (bfd_vma) 0x40000002, entry + 4);
694 bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP, entry + 8);
695 bfd_put_32 (output_bfd, (bfd_vma) ldx, entry + 12);
696 bfd_put_32 (output_bfd, (bfd_vma) 0x83c3c001, entry + 16);
697 bfd_put_32 (output_bfd, (bfd_vma) 0x9e100005, entry + 20);
699 bfd_put_64 (output_bfd, (bfd_vma) (splt->contents - (entry + 4)), ptr);
705 /* The format of the first PLT entry in a VxWorks executable. */
706 static const bfd_vma sparc_vxworks_exec_plt0_entry[] =
708 0x05000000, /* sethi %hi(_GLOBAL_OFFSET_TABLE_+8), %g2 */
709 0x8410a000, /* or %g2, %lo(_GLOBAL_OFFSET_TABLE_+8), %g2 */
710 0xc4008000, /* ld [ %g2 ], %g2 */
711 0x81c08000, /* jmp %g2 */
715 /* The format of subsequent PLT entries. */
716 static const bfd_vma sparc_vxworks_exec_plt_entry[] =
718 0x03000000, /* sethi %hi(_GLOBAL_OFFSET_TABLE_+f@got), %g1 */
719 0x82106000, /* or %g1, %lo(_GLOBAL_OFFSET_TABLE_+f@got), %g1 */
720 0xc2004000, /* ld [ %g1 ], %g1 */
721 0x81c04000, /* jmp %g1 */
722 0x01000000, /* nop */
723 0x03000000, /* sethi %hi(f@pltindex), %g1 */
724 0x10800000, /* b _PLT_resolve */
725 0x82106000 /* or %g1, %lo(f@pltindex), %g1 */
728 /* The format of the first PLT entry in a VxWorks shared object. */
729 static const bfd_vma sparc_vxworks_shared_plt0_entry[] =
731 0xc405e008, /* ld [ %l7 + 8 ], %g2 */
732 0x81c08000, /* jmp %g2 */
736 /* The format of subsequent PLT entries. */
737 static const bfd_vma sparc_vxworks_shared_plt_entry[] =
739 0x03000000, /* sethi %hi(f@got), %g1 */
740 0x82106000, /* or %g1, %lo(f@got), %g1 */
741 0xc205c001, /* ld [ %l7 + %g1 ], %g1 */
742 0x81c04000, /* jmp %g1 */
743 0x01000000, /* nop */
744 0x03000000, /* sethi %hi(f@pltindex), %g1 */
745 0x10800000, /* b _PLT_resolve */
746 0x82106000 /* or %g1, %lo(f@pltindex), %g1 */
749 #define SPARC_ELF_PUT_WORD(htab, bfd, val, ptr) \
750 htab->put_word(bfd, val, ptr)
752 #define SPARC_ELF_APPEND_RELA(htab, bfd, sec, rela) \
753 htab->append_rela(bfd, sec, rela)
755 #define SPARC_ELF_R_INFO(htab, in_rel, index, type) \
756 htab->r_info(in_rel, index, type)
758 #define SPARC_ELF_R_SYMNDX(htab, r_info) \
759 htab->r_symndx(r_info)
761 #define SPARC_ELF_WORD_BYTES(htab) \
764 #define SPARC_ELF_RELA_BYTES(htab) \
767 #define SPARC_ELF_DTPOFF_RELOC(htab) \
770 #define SPARC_ELF_DTPMOD_RELOC(htab) \
773 #define SPARC_ELF_TPOFF_RELOC(htab) \
776 #define SPARC_ELF_BUILD_PLT_ENTRY(htab, obfd, splt, off, max, r_off) \
777 htab->build_plt_entry (obfd, splt, off, max, r_off)
779 /* Create an entry in an SPARC ELF linker hash table. */
781 static struct bfd_hash_entry *
782 link_hash_newfunc (struct bfd_hash_entry *entry,
783 struct bfd_hash_table *table, const char *string)
785 /* Allocate the structure if it has not already been allocated by a
789 entry = bfd_hash_allocate (table,
790 sizeof (struct _bfd_sparc_elf_link_hash_entry));
795 /* Call the allocation method of the superclass. */
796 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
799 struct _bfd_sparc_elf_link_hash_entry *eh;
801 eh = (struct _bfd_sparc_elf_link_hash_entry *) entry;
802 eh->dyn_relocs = NULL;
803 eh->tls_type = GOT_UNKNOWN;
809 /* The name of the dynamic interpreter. This is put in the .interp
812 #define ELF32_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
813 #define ELF64_DYNAMIC_INTERPRETER "/usr/lib/sparcv9/ld.so.1"
815 /* Create a SPARC ELF linker hash table. */
817 struct bfd_link_hash_table *
818 _bfd_sparc_elf_link_hash_table_create (bfd *abfd)
820 struct _bfd_sparc_elf_link_hash_table *ret;
821 bfd_size_type amt = sizeof (struct _bfd_sparc_elf_link_hash_table);
823 ret = (struct _bfd_sparc_elf_link_hash_table *) bfd_zmalloc (amt);
829 ret->put_word = sparc_put_word_64;
830 ret->append_rela = sparc_elf_append_rela_64;
831 ret->r_info = sparc_elf_r_info_64;
832 ret->r_symndx = sparc_elf_r_symndx_64;
833 ret->dtpoff_reloc = R_SPARC_TLS_DTPOFF64;
834 ret->dtpmod_reloc = R_SPARC_TLS_DTPMOD64;
835 ret->tpoff_reloc = R_SPARC_TLS_TPOFF64;
836 ret->word_align_power = 3;
837 ret->align_power_max = 4;
838 ret->bytes_per_word = 8;
839 ret->bytes_per_rela = sizeof (Elf64_External_Rela);
840 ret->dynamic_interpreter = ELF64_DYNAMIC_INTERPRETER;
841 ret->dynamic_interpreter_size = sizeof ELF64_DYNAMIC_INTERPRETER;
845 ret->put_word = sparc_put_word_32;
846 ret->append_rela = sparc_elf_append_rela_32;
847 ret->r_info = sparc_elf_r_info_32;
848 ret->r_symndx = sparc_elf_r_symndx_32;
849 ret->dtpoff_reloc = R_SPARC_TLS_DTPOFF32;
850 ret->dtpmod_reloc = R_SPARC_TLS_DTPMOD32;
851 ret->tpoff_reloc = R_SPARC_TLS_TPOFF32;
852 ret->word_align_power = 2;
853 ret->align_power_max = 3;
854 ret->bytes_per_word = 4;
855 ret->bytes_per_rela = sizeof (Elf32_External_Rela);
856 ret->dynamic_interpreter = ELF32_DYNAMIC_INTERPRETER;
857 ret->dynamic_interpreter_size = sizeof ELF32_DYNAMIC_INTERPRETER;
860 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc,
861 sizeof (struct _bfd_sparc_elf_link_hash_entry)))
867 return &ret->elf.root;
870 /* Create .got and .rela.got sections in DYNOBJ, and set up
871 shortcuts to them in our hash table. */
874 create_got_section (bfd *dynobj, struct bfd_link_info *info)
876 struct _bfd_sparc_elf_link_hash_table *htab;
878 if (! _bfd_elf_create_got_section (dynobj, info))
881 htab = _bfd_sparc_elf_hash_table (info);
882 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
883 BFD_ASSERT (htab->sgot != NULL);
885 htab->srelgot = bfd_make_section_with_flags (dynobj, ".rela.got",
892 if (htab->srelgot == NULL
893 || ! bfd_set_section_alignment (dynobj, htab->srelgot,
894 htab->word_align_power))
897 if (htab->is_vxworks)
899 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
907 /* Create .plt, .rela.plt, .got, .rela.got, .dynbss, and
908 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
912 _bfd_sparc_elf_create_dynamic_sections (bfd *dynobj,
913 struct bfd_link_info *info)
915 struct _bfd_sparc_elf_link_hash_table *htab;
917 htab = _bfd_sparc_elf_hash_table (info);
918 if (!htab->sgot && !create_got_section (dynobj, info))
921 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
924 htab->splt = bfd_get_section_by_name (dynobj, ".plt");
925 htab->srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
926 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
928 htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss");
930 if (htab->is_vxworks)
932 if (!elf_vxworks_create_dynamic_sections (dynobj, info, &htab->srelplt2))
936 htab->plt_header_size
937 = 4 * ARRAY_SIZE (sparc_vxworks_shared_plt0_entry);
939 = 4 * ARRAY_SIZE (sparc_vxworks_shared_plt_entry);
943 htab->plt_header_size
944 = 4 * ARRAY_SIZE (sparc_vxworks_exec_plt0_entry);
946 = 4 * ARRAY_SIZE (sparc_vxworks_exec_plt_entry);
951 if (ABI_64_P (dynobj))
953 htab->build_plt_entry = sparc64_plt_entry_build;
954 htab->plt_header_size = PLT64_HEADER_SIZE;
955 htab->plt_entry_size = PLT64_ENTRY_SIZE;
959 htab->build_plt_entry = sparc32_plt_entry_build;
960 htab->plt_header_size = PLT32_HEADER_SIZE;
961 htab->plt_entry_size = PLT32_ENTRY_SIZE;
965 if (!htab->splt || !htab->srelplt || !htab->sdynbss
966 || (!info->shared && !htab->srelbss))
972 /* Copy the extra info we tack onto an elf_link_hash_entry. */
975 _bfd_sparc_elf_copy_indirect_symbol (struct bfd_link_info *info,
976 struct elf_link_hash_entry *dir,
977 struct elf_link_hash_entry *ind)
979 struct _bfd_sparc_elf_link_hash_entry *edir, *eind;
981 edir = (struct _bfd_sparc_elf_link_hash_entry *) dir;
982 eind = (struct _bfd_sparc_elf_link_hash_entry *) ind;
984 if (eind->dyn_relocs != NULL)
986 if (edir->dyn_relocs != NULL)
988 struct _bfd_sparc_elf_dyn_relocs **pp;
989 struct _bfd_sparc_elf_dyn_relocs *p;
991 /* Add reloc counts against the indirect sym to the direct sym
992 list. Merge any entries against the same section. */
993 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
995 struct _bfd_sparc_elf_dyn_relocs *q;
997 for (q = edir->dyn_relocs; q != NULL; q = q->next)
998 if (q->sec == p->sec)
1000 q->pc_count += p->pc_count;
1001 q->count += p->count;
1008 *pp = edir->dyn_relocs;
1011 edir->dyn_relocs = eind->dyn_relocs;
1012 eind->dyn_relocs = NULL;
1015 if (ind->root.type == bfd_link_hash_indirect
1016 && dir->got.refcount <= 0)
1018 edir->tls_type = eind->tls_type;
1019 eind->tls_type = GOT_UNKNOWN;
1021 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1025 sparc_elf_tls_transition (struct bfd_link_info *info, bfd *abfd,
1026 int r_type, int is_local)
1028 if (! ABI_64_P (abfd)
1029 && r_type == R_SPARC_TLS_GD_HI22
1030 && ! _bfd_sparc_elf_tdata (abfd)->has_tlsgd)
1031 r_type = R_SPARC_REV32;
1038 case R_SPARC_TLS_GD_HI22:
1040 return R_SPARC_TLS_LE_HIX22;
1041 return R_SPARC_TLS_IE_HI22;
1042 case R_SPARC_TLS_GD_LO10:
1044 return R_SPARC_TLS_LE_LOX10;
1045 return R_SPARC_TLS_IE_LO10;
1046 case R_SPARC_TLS_IE_HI22:
1048 return R_SPARC_TLS_LE_HIX22;
1050 case R_SPARC_TLS_IE_LO10:
1052 return R_SPARC_TLS_LE_LOX10;
1054 case R_SPARC_TLS_LDM_HI22:
1055 return R_SPARC_TLS_LE_HIX22;
1056 case R_SPARC_TLS_LDM_LO10:
1057 return R_SPARC_TLS_LE_LOX10;
1063 /* Look through the relocs for a section during the first phase, and
1064 allocate space in the global offset table or procedure linkage
1068 _bfd_sparc_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
1069 asection *sec, const Elf_Internal_Rela *relocs)
1071 struct _bfd_sparc_elf_link_hash_table *htab;
1072 Elf_Internal_Shdr *symtab_hdr;
1073 struct elf_link_hash_entry **sym_hashes;
1074 bfd_vma *local_got_offsets;
1075 const Elf_Internal_Rela *rel;
1076 const Elf_Internal_Rela *rel_end;
1079 bfd_boolean checked_tlsgd = FALSE;
1081 if (info->relocatable)
1084 htab = _bfd_sparc_elf_hash_table (info);
1085 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1086 sym_hashes = elf_sym_hashes (abfd);
1087 local_got_offsets = elf_local_got_offsets (abfd);
1091 if (ABI_64_P (abfd))
1092 num_relocs = NUM_SHDR_ENTRIES (& elf_section_data (sec)->rel_hdr);
1094 num_relocs = sec->reloc_count;
1095 rel_end = relocs + num_relocs;
1096 for (rel = relocs; rel < rel_end; rel++)
1098 unsigned int r_type;
1099 unsigned long r_symndx;
1100 struct elf_link_hash_entry *h;
1102 r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
1103 r_type = SPARC_ELF_R_TYPE (rel->r_info);
1105 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1107 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1112 if (r_symndx < symtab_hdr->sh_info)
1116 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1117 while (h->root.type == bfd_link_hash_indirect
1118 || h->root.type == bfd_link_hash_warning)
1119 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1122 /* Compatibility with old R_SPARC_REV32 reloc conflicting
1123 with R_SPARC_TLS_GD_HI22. */
1124 if (! ABI_64_P (abfd) && ! checked_tlsgd)
1127 case R_SPARC_TLS_GD_HI22:
1129 const Elf_Internal_Rela *relt;
1131 for (relt = rel + 1; relt < rel_end; relt++)
1132 if (ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_LO10
1133 || ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_ADD
1134 || ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_CALL)
1136 checked_tlsgd = TRUE;
1137 _bfd_sparc_elf_tdata (abfd)->has_tlsgd = relt < rel_end;
1140 case R_SPARC_TLS_GD_LO10:
1141 case R_SPARC_TLS_GD_ADD:
1142 case R_SPARC_TLS_GD_CALL:
1143 checked_tlsgd = TRUE;
1144 _bfd_sparc_elf_tdata (abfd)->has_tlsgd = TRUE;
1148 r_type = sparc_elf_tls_transition (info, abfd, r_type, h == NULL);
1151 case R_SPARC_TLS_LDM_HI22:
1152 case R_SPARC_TLS_LDM_LO10:
1153 htab->tls_ldm_got.refcount += 1;
1156 case R_SPARC_TLS_LE_HIX22:
1157 case R_SPARC_TLS_LE_LOX10:
1162 case R_SPARC_TLS_IE_HI22:
1163 case R_SPARC_TLS_IE_LO10:
1165 info->flags |= DF_STATIC_TLS;
1171 case R_SPARC_TLS_GD_HI22:
1172 case R_SPARC_TLS_GD_LO10:
1173 /* This symbol requires a global offset table entry. */
1175 int tls_type, old_tls_type;
1183 tls_type = GOT_NORMAL;
1185 case R_SPARC_TLS_GD_HI22:
1186 case R_SPARC_TLS_GD_LO10:
1187 tls_type = GOT_TLS_GD;
1189 case R_SPARC_TLS_IE_HI22:
1190 case R_SPARC_TLS_IE_LO10:
1191 tls_type = GOT_TLS_IE;
1197 h->got.refcount += 1;
1198 old_tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
1202 bfd_signed_vma *local_got_refcounts;
1204 /* This is a global offset table entry for a local symbol. */
1205 local_got_refcounts = elf_local_got_refcounts (abfd);
1206 if (local_got_refcounts == NULL)
1210 size = symtab_hdr->sh_info;
1211 size *= (sizeof (bfd_signed_vma) + sizeof(char));
1212 local_got_refcounts = ((bfd_signed_vma *)
1213 bfd_zalloc (abfd, size));
1214 if (local_got_refcounts == NULL)
1216 elf_local_got_refcounts (abfd) = local_got_refcounts;
1217 _bfd_sparc_elf_local_got_tls_type (abfd)
1218 = (char *) (local_got_refcounts + symtab_hdr->sh_info);
1220 local_got_refcounts[r_symndx] += 1;
1221 old_tls_type = _bfd_sparc_elf_local_got_tls_type (abfd) [r_symndx];
1224 /* If a TLS symbol is accessed using IE at least once,
1225 there is no point to use dynamic model for it. */
1226 if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1227 && (old_tls_type != GOT_TLS_GD
1228 || tls_type != GOT_TLS_IE))
1230 if (old_tls_type == GOT_TLS_IE && tls_type == GOT_TLS_GD)
1231 tls_type = old_tls_type;
1234 (*_bfd_error_handler)
1235 (_("%B: `%s' accessed both as normal and thread local symbol"),
1236 abfd, h ? h->root.root.string : "<local>");
1241 if (old_tls_type != tls_type)
1244 _bfd_sparc_elf_hash_entry (h)->tls_type = tls_type;
1246 _bfd_sparc_elf_local_got_tls_type (abfd) [r_symndx] = tls_type;
1250 if (htab->sgot == NULL)
1252 if (htab->elf.dynobj == NULL)
1253 htab->elf.dynobj = abfd;
1254 if (!create_got_section (htab->elf.dynobj, info))
1259 case R_SPARC_TLS_GD_CALL:
1260 case R_SPARC_TLS_LDM_CALL:
1263 /* These are basically R_SPARC_TLS_WPLT30 relocs against
1265 struct bfd_link_hash_entry *bh = NULL;
1266 if (! _bfd_generic_link_add_one_symbol (info, abfd,
1267 "__tls_get_addr", 0,
1268 bfd_und_section_ptr, 0,
1272 h = (struct elf_link_hash_entry *) bh;
1279 case R_SPARC_WPLT30:
1280 case R_SPARC_HIPLT22:
1281 case R_SPARC_LOPLT10:
1282 case R_SPARC_PCPLT32:
1283 case R_SPARC_PCPLT22:
1284 case R_SPARC_PCPLT10:
1286 /* This symbol requires a procedure linkage table entry. We
1287 actually build the entry in adjust_dynamic_symbol,
1288 because this might be a case of linking PIC code without
1289 linking in any dynamic objects, in which case we don't
1290 need to generate a procedure linkage table after all. */
1294 if (! ABI_64_P (abfd))
1296 /* The Solaris native assembler will generate a WPLT30
1297 reloc for a local symbol if you assemble a call from
1298 one section to another when using -K pic. We treat
1300 if (ELF32_R_TYPE (rel->r_info) == R_SPARC_PLT32)
1305 /* It does not make sense to have a procedure linkage
1306 table entry for a local symbol. */
1307 bfd_set_error (bfd_error_bad_value);
1316 this_r_type = SPARC_ELF_R_TYPE (rel->r_info);
1317 if (this_r_type == R_SPARC_PLT32
1318 || this_r_type == R_SPARC_PLT64)
1321 h->plt.refcount += 1;
1326 case R_SPARC_PC_HH22:
1327 case R_SPARC_PC_HM10:
1328 case R_SPARC_PC_LM22:
1333 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1338 case R_SPARC_DISP16:
1339 case R_SPARC_DISP32:
1340 case R_SPARC_DISP64:
1341 case R_SPARC_WDISP30:
1342 case R_SPARC_WDISP22:
1343 case R_SPARC_WDISP19:
1344 case R_SPARC_WDISP16:
1374 if (h != NULL && !info->shared)
1376 /* We may need a .plt entry if the function this reloc
1377 refers to is in a shared lib. */
1378 h->plt.refcount += 1;
1381 /* If we are creating a shared library, and this is a reloc
1382 against a global symbol, or a non PC relative reloc
1383 against a local symbol, then we need to copy the reloc
1384 into the shared library. However, if we are linking with
1385 -Bsymbolic, we do not need to copy a reloc against a
1386 global symbol which is defined in an object we are
1387 including in the link (i.e., DEF_REGULAR is set). At
1388 this point we have not seen all the input files, so it is
1389 possible that DEF_REGULAR is not set now but will be set
1390 later (it is never cleared). In case of a weak definition,
1391 DEF_REGULAR may be cleared later by a strong definition in
1392 a shared library. We account for that possibility below by
1393 storing information in the relocs_copied field of the hash
1394 table entry. A similar situation occurs when creating
1395 shared libraries and symbol visibility changes render the
1398 If on the other hand, we are creating an executable, we
1399 may need to keep relocations for symbols satisfied by a
1400 dynamic library if we manage to avoid copy relocs for the
1403 && (sec->flags & SEC_ALLOC) != 0
1404 && (! _bfd_sparc_elf_howto_table[r_type].pc_relative
1406 && (! info->symbolic
1407 || h->root.type == bfd_link_hash_defweak
1408 || !h->def_regular))))
1410 && (sec->flags & SEC_ALLOC) != 0
1412 && (h->root.type == bfd_link_hash_defweak
1413 || !h->def_regular)))
1415 struct _bfd_sparc_elf_dyn_relocs *p;
1416 struct _bfd_sparc_elf_dyn_relocs **head;
1418 /* When creating a shared object, we must copy these
1419 relocs into the output file. We create a reloc
1420 section in dynobj and make room for the reloc. */
1426 name = (bfd_elf_string_from_elf_section
1428 elf_elfheader (abfd)->e_shstrndx,
1429 elf_section_data (sec)->rel_hdr.sh_name));
1433 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
1434 && strcmp (bfd_get_section_name (abfd, sec),
1437 if (htab->elf.dynobj == NULL)
1438 htab->elf.dynobj = abfd;
1439 dynobj = htab->elf.dynobj;
1441 sreloc = bfd_get_section_by_name (dynobj, name);
1446 flags = (SEC_HAS_CONTENTS | SEC_READONLY
1447 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1448 if ((sec->flags & SEC_ALLOC) != 0)
1449 flags |= SEC_ALLOC | SEC_LOAD;
1450 sreloc = bfd_make_section_with_flags (dynobj,
1454 || ! bfd_set_section_alignment (dynobj, sreloc,
1455 htab->word_align_power))
1458 elf_section_data (sec)->sreloc = sreloc;
1461 /* If this is a global symbol, we count the number of
1462 relocations we need for this symbol. */
1464 head = &((struct _bfd_sparc_elf_link_hash_entry *) h)->dyn_relocs;
1467 /* Track dynamic relocs needed for local syms too.
1468 We really need local syms available to do this
1474 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
1479 vpp = &elf_section_data (s)->local_dynrel;
1480 head = (struct _bfd_sparc_elf_dyn_relocs **) vpp;
1484 if (p == NULL || p->sec != sec)
1486 bfd_size_type amt = sizeof *p;
1487 p = ((struct _bfd_sparc_elf_dyn_relocs *)
1488 bfd_alloc (htab->elf.dynobj, amt));
1499 if (_bfd_sparc_elf_howto_table[r_type].pc_relative)
1505 case R_SPARC_GNU_VTINHERIT:
1506 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1510 case R_SPARC_GNU_VTENTRY:
1511 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1515 case R_SPARC_REGISTER:
1516 /* Nothing to do. */
1528 _bfd_sparc_elf_gc_mark_hook (asection *sec,
1529 struct bfd_link_info *info,
1530 Elf_Internal_Rela *rel,
1531 struct elf_link_hash_entry *h,
1532 Elf_Internal_Sym *sym)
1536 struct _bfd_sparc_elf_link_hash_table *htab;
1538 htab = _bfd_sparc_elf_hash_table (info);
1539 switch (SPARC_ELF_R_TYPE (rel->r_info))
1541 case R_SPARC_GNU_VTINHERIT:
1542 case R_SPARC_GNU_VTENTRY:
1546 switch (h->root.type)
1548 case bfd_link_hash_defined:
1549 case bfd_link_hash_defweak:
1550 return h->root.u.def.section;
1552 case bfd_link_hash_common:
1553 return h->root.u.c.p->section;
1561 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
1566 /* Update the got entry reference counts for the section being removed. */
1568 _bfd_sparc_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
1569 asection *sec, const Elf_Internal_Rela *relocs)
1571 struct _bfd_sparc_elf_link_hash_table *htab;
1572 Elf_Internal_Shdr *symtab_hdr;
1573 struct elf_link_hash_entry **sym_hashes;
1574 bfd_signed_vma *local_got_refcounts;
1575 const Elf_Internal_Rela *rel, *relend;
1577 elf_section_data (sec)->local_dynrel = NULL;
1579 htab = _bfd_sparc_elf_hash_table (info);
1580 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1581 sym_hashes = elf_sym_hashes (abfd);
1582 local_got_refcounts = elf_local_got_refcounts (abfd);
1584 relend = relocs + sec->reloc_count;
1585 for (rel = relocs; rel < relend; rel++)
1587 unsigned long r_symndx;
1588 unsigned int r_type;
1589 struct elf_link_hash_entry *h = NULL;
1591 r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
1592 if (r_symndx >= symtab_hdr->sh_info)
1594 struct _bfd_sparc_elf_link_hash_entry *eh;
1595 struct _bfd_sparc_elf_dyn_relocs **pp;
1596 struct _bfd_sparc_elf_dyn_relocs *p;
1598 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1599 while (h->root.type == bfd_link_hash_indirect
1600 || h->root.type == bfd_link_hash_warning)
1601 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1602 eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
1603 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1606 /* Everything must go for SEC. */
1612 r_type = SPARC_ELF_R_TYPE (rel->r_info);
1613 r_type = sparc_elf_tls_transition (info, abfd, r_type, h != NULL);
1616 case R_SPARC_TLS_LDM_HI22:
1617 case R_SPARC_TLS_LDM_LO10:
1618 if (_bfd_sparc_elf_hash_table (info)->tls_ldm_got.refcount > 0)
1619 _bfd_sparc_elf_hash_table (info)->tls_ldm_got.refcount -= 1;
1622 case R_SPARC_TLS_GD_HI22:
1623 case R_SPARC_TLS_GD_LO10:
1624 case R_SPARC_TLS_IE_HI22:
1625 case R_SPARC_TLS_IE_LO10:
1631 if (h->got.refcount > 0)
1636 if (local_got_refcounts[r_symndx] > 0)
1637 local_got_refcounts[r_symndx]--;
1643 case R_SPARC_PC_HH22:
1644 case R_SPARC_PC_HM10:
1645 case R_SPARC_PC_LM22:
1647 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1652 case R_SPARC_DISP16:
1653 case R_SPARC_DISP32:
1654 case R_SPARC_DISP64:
1655 case R_SPARC_WDISP30:
1656 case R_SPARC_WDISP22:
1657 case R_SPARC_WDISP19:
1658 case R_SPARC_WDISP16:
1689 case R_SPARC_WPLT30:
1692 if (h->plt.refcount > 0)
1705 /* Adjust a symbol defined by a dynamic object and referenced by a
1706 regular object. The current definition is in some section of the
1707 dynamic object, but we're not including those sections. We have to
1708 change the definition to something the rest of the link can
1712 _bfd_sparc_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1713 struct elf_link_hash_entry *h)
1715 struct _bfd_sparc_elf_link_hash_table *htab;
1716 struct _bfd_sparc_elf_link_hash_entry * eh;
1717 struct _bfd_sparc_elf_dyn_relocs *p;
1719 unsigned int power_of_two;
1721 htab = _bfd_sparc_elf_hash_table (info);
1723 /* Make sure we know what is going on here. */
1724 BFD_ASSERT (htab->elf.dynobj != NULL
1726 || h->u.weakdef != NULL
1729 && !h->def_regular)));
1731 /* If this is a function, put it in the procedure linkage table. We
1732 will fill in the contents of the procedure linkage table later
1733 (although we could actually do it here). The STT_NOTYPE
1734 condition is a hack specifically for the Oracle libraries
1735 delivered for Solaris; for some inexplicable reason, they define
1736 some of their functions as STT_NOTYPE when they really should be
1738 if (h->type == STT_FUNC
1740 || (h->type == STT_NOTYPE
1741 && (h->root.type == bfd_link_hash_defined
1742 || h->root.type == bfd_link_hash_defweak)
1743 && (h->root.u.def.section->flags & SEC_CODE) != 0))
1745 if (h->plt.refcount <= 0
1749 && h->root.type != bfd_link_hash_undefweak
1750 && h->root.type != bfd_link_hash_undefined))
1752 /* This case can occur if we saw a WPLT30 reloc in an input
1753 file, but the symbol was never referred to by a dynamic
1754 object, or if all references were garbage collected. In
1755 such a case, we don't actually need to build a procedure
1756 linkage table, and we can just do a WDISP30 reloc instead. */
1757 h->plt.offset = (bfd_vma) -1;
1764 h->plt.offset = (bfd_vma) -1;
1766 /* If this is a weak symbol, and there is a real definition, the
1767 processor independent code will have arranged for us to see the
1768 real definition first, and we can just use the same value. */
1769 if (h->u.weakdef != NULL)
1771 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1772 || h->u.weakdef->root.type == bfd_link_hash_defweak);
1773 h->root.u.def.section = h->u.weakdef->root.u.def.section;
1774 h->root.u.def.value = h->u.weakdef->root.u.def.value;
1778 /* This is a reference to a symbol defined by a dynamic object which
1779 is not a function. */
1781 /* If we are creating a shared library, we must presume that the
1782 only references to the symbol are via the global offset table.
1783 For such cases we need not do anything here; the relocations will
1784 be handled correctly by relocate_section. */
1788 /* If there are no references to this symbol that do not use the
1789 GOT, we don't need to generate a copy reloc. */
1790 if (!h->non_got_ref)
1793 eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
1794 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1796 s = p->sec->output_section;
1797 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1801 /* If we didn't find any dynamic relocs in read-only sections, then
1802 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1811 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
1812 h->root.root.string);
1816 /* We must allocate the symbol in our .dynbss section, which will
1817 become part of the .bss section of the executable. There will be
1818 an entry for this symbol in the .dynsym section. The dynamic
1819 object will contain position independent code, so all references
1820 from the dynamic object to this symbol will go through the global
1821 offset table. The dynamic linker will use the .dynsym entry to
1822 determine the address it must put in the global offset table, so
1823 both the dynamic object and the regular object will refer to the
1824 same memory location for the variable. */
1826 /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker
1827 to copy the initial value out of the dynamic object and into the
1828 runtime process image. We need to remember the offset into the
1829 .rel.bss section we are going to use. */
1830 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1832 htab->srelbss->size += SPARC_ELF_RELA_BYTES (htab);
1836 /* We need to figure out the alignment required for this symbol. I
1837 have no idea how ELF linkers handle this. */
1838 power_of_two = bfd_log2 (h->size);
1839 if (power_of_two > htab->align_power_max)
1840 power_of_two = htab->align_power_max;
1842 /* Apply the required alignment. */
1844 s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
1845 if (power_of_two > bfd_get_section_alignment (dynobj, s))
1847 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
1851 /* Define the symbol as being at this point in the section. */
1852 h->root.u.def.section = s;
1853 h->root.u.def.value = s->size;
1855 /* Increment the section size to make room for the symbol. */
1861 /* Allocate space in .plt, .got and associated reloc sections for
1865 allocate_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
1867 struct bfd_link_info *info;
1868 struct _bfd_sparc_elf_link_hash_table *htab;
1869 struct _bfd_sparc_elf_link_hash_entry *eh;
1870 struct _bfd_sparc_elf_dyn_relocs *p;
1872 if (h->root.type == bfd_link_hash_indirect)
1875 if (h->root.type == bfd_link_hash_warning)
1876 /* When warning symbols are created, they **replace** the "real"
1877 entry in the hash table, thus we never get to see the real
1878 symbol in a hash traversal. So look at it now. */
1879 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1881 info = (struct bfd_link_info *) inf;
1882 htab = _bfd_sparc_elf_hash_table (info);
1884 if (htab->elf.dynamic_sections_created
1885 && h->plt.refcount > 0)
1887 /* Make sure this symbol is output as a dynamic symbol.
1888 Undefined weak syms won't yet be marked as dynamic. */
1889 if (h->dynindx == -1
1890 && !h->forced_local)
1892 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1896 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
1898 asection *s = htab->splt;
1900 /* Allocate room for the header. */
1903 s->size = htab->plt_header_size;
1905 /* Allocate space for the .rela.plt.unloaded relocations. */
1906 if (htab->is_vxworks && !info->shared)
1907 htab->srelplt2->size = sizeof (Elf32_External_Rela) * 2;
1910 /* The procedure linkage table size is bounded by the magnitude
1911 of the offset we can describe in the entry. */
1912 if (s->size >= (SPARC_ELF_WORD_BYTES(htab) == 8 ?
1913 (((bfd_vma)1 << 31) << 1) : 0x400000))
1915 bfd_set_error (bfd_error_bad_value);
1919 if (SPARC_ELF_WORD_BYTES(htab) == 8
1920 && s->size >= PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE)
1922 bfd_vma off = s->size - PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE;
1925 off = (off % (160 * PLT64_ENTRY_SIZE)) / PLT64_ENTRY_SIZE;
1927 h->plt.offset = (s->size - (off * 8));
1930 h->plt.offset = s->size;
1932 /* If this symbol is not defined in a regular file, and we are
1933 not generating a shared library, then set the symbol to this
1934 location in the .plt. This is required to make function
1935 pointers compare as equal between the normal executable and
1936 the shared library. */
1940 h->root.u.def.section = s;
1941 h->root.u.def.value = h->plt.offset;
1944 /* Make room for this entry. */
1945 s->size += htab->plt_entry_size;
1947 /* We also need to make an entry in the .rela.plt section. */
1948 htab->srelplt->size += SPARC_ELF_RELA_BYTES (htab);
1950 if (htab->is_vxworks)
1952 /* Allocate space for the .got.plt entry. */
1953 htab->sgotplt->size += 4;
1955 /* ...and for the .rela.plt.unloaded relocations. */
1957 htab->srelplt2->size += sizeof (Elf32_External_Rela) * 3;
1962 h->plt.offset = (bfd_vma) -1;
1968 h->plt.offset = (bfd_vma) -1;
1972 /* If R_SPARC_TLS_IE_{HI22,LO10} symbol is now local to the binary,
1973 make it a R_SPARC_TLS_LE_{HI22,LO10} requiring no TLS entry. */
1974 if (h->got.refcount > 0
1977 && _bfd_sparc_elf_hash_entry(h)->tls_type == GOT_TLS_IE)
1978 h->got.offset = (bfd_vma) -1;
1979 else if (h->got.refcount > 0)
1983 int tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
1985 /* Make sure this symbol is output as a dynamic symbol.
1986 Undefined weak syms won't yet be marked as dynamic. */
1987 if (h->dynindx == -1
1988 && !h->forced_local)
1990 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1995 h->got.offset = s->size;
1996 s->size += SPARC_ELF_WORD_BYTES (htab);
1997 /* R_SPARC_TLS_GD_HI{22,LO10} needs 2 consecutive GOT slots. */
1998 if (tls_type == GOT_TLS_GD)
1999 s->size += SPARC_ELF_WORD_BYTES (htab);
2000 dyn = htab->elf.dynamic_sections_created;
2001 /* R_SPARC_TLS_IE_{HI22,LO10} needs one dynamic relocation,
2002 R_SPARC_TLS_GD_{HI22,LO10} needs one if local symbol and two if
2004 if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
2005 || tls_type == GOT_TLS_IE)
2006 htab->srelgot->size += SPARC_ELF_RELA_BYTES (htab);
2007 else if (tls_type == GOT_TLS_GD)
2008 htab->srelgot->size += 2 * SPARC_ELF_RELA_BYTES (htab);
2009 else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
2010 htab->srelgot->size += SPARC_ELF_RELA_BYTES (htab);
2013 h->got.offset = (bfd_vma) -1;
2015 eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
2016 if (eh->dyn_relocs == NULL)
2019 /* In the shared -Bsymbolic case, discard space allocated for
2020 dynamic pc-relative relocs against symbols which turn out to be
2021 defined in regular objects. For the normal shared case, discard
2022 space for pc-relative relocs that have become local due to symbol
2023 visibility changes. */
2031 struct _bfd_sparc_elf_dyn_relocs **pp;
2033 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2035 p->count -= p->pc_count;
2044 /* Also discard relocs on undefined weak syms with non-default
2046 if (eh->dyn_relocs != NULL
2047 && h->root.type == bfd_link_hash_undefweak)
2049 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2050 eh->dyn_relocs = NULL;
2052 /* Make sure undefined weak symbols are output as a dynamic
2054 else if (h->dynindx == -1
2055 && !h->forced_local)
2057 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2064 /* For the non-shared case, discard space for relocs against
2065 symbols which turn out to need copy relocs or are not
2071 || (htab->elf.dynamic_sections_created
2072 && (h->root.type == bfd_link_hash_undefweak
2073 || h->root.type == bfd_link_hash_undefined))))
2075 /* Make sure this symbol is output as a dynamic symbol.
2076 Undefined weak syms won't yet be marked as dynamic. */
2077 if (h->dynindx == -1
2078 && !h->forced_local)
2080 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2084 /* If that succeeded, we know we'll be keeping all the
2086 if (h->dynindx != -1)
2090 eh->dyn_relocs = NULL;
2095 /* Finally, allocate space. */
2096 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2098 asection *sreloc = elf_section_data (p->sec)->sreloc;
2099 sreloc->size += p->count * SPARC_ELF_RELA_BYTES (htab);
2105 /* Find any dynamic relocs that apply to read-only sections. */
2108 readonly_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
2110 struct _bfd_sparc_elf_link_hash_entry *eh;
2111 struct _bfd_sparc_elf_dyn_relocs *p;
2113 if (h->root.type == bfd_link_hash_warning)
2114 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2116 eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
2117 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2119 asection *s = p->sec->output_section;
2121 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2123 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2125 info->flags |= DF_TEXTREL;
2127 /* Not an error, just cut short the traversal. */
2134 /* Return true if the dynamic symbol for a given section should be
2135 omitted when creating a shared library. */
2138 _bfd_sparc_elf_omit_section_dynsym (bfd *output_bfd,
2139 struct bfd_link_info *info,
2142 /* We keep the .got section symbol so that explicit relocations
2143 against the _GLOBAL_OFFSET_TABLE_ symbol emitted in PIC mode
2144 can be turned into relocations against the .got symbol. */
2145 if (strcmp (p->name, ".got") == 0)
2148 return _bfd_elf_link_omit_section_dynsym (output_bfd, info, p);
2151 /* Set the sizes of the dynamic sections. */
2154 _bfd_sparc_elf_size_dynamic_sections (bfd *output_bfd,
2155 struct bfd_link_info *info)
2157 struct _bfd_sparc_elf_link_hash_table *htab;
2162 htab = _bfd_sparc_elf_hash_table (info);
2163 dynobj = htab->elf.dynobj;
2164 BFD_ASSERT (dynobj != NULL);
2166 if (elf_hash_table (info)->dynamic_sections_created)
2168 /* Set the contents of the .interp section to the interpreter. */
2169 if (info->executable)
2171 s = bfd_get_section_by_name (dynobj, ".interp");
2172 BFD_ASSERT (s != NULL);
2173 s->size = htab->dynamic_interpreter_size;
2174 s->contents = (unsigned char *) htab->dynamic_interpreter;
2178 /* Set up .got offsets for local syms, and space for local dynamic
2180 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2182 bfd_signed_vma *local_got;
2183 bfd_signed_vma *end_local_got;
2184 char *local_tls_type;
2185 bfd_size_type locsymcount;
2186 Elf_Internal_Shdr *symtab_hdr;
2189 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2192 for (s = ibfd->sections; s != NULL; s = s->next)
2194 struct _bfd_sparc_elf_dyn_relocs *p;
2196 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
2198 if (!bfd_is_abs_section (p->sec)
2199 && bfd_is_abs_section (p->sec->output_section))
2201 /* Input section has been discarded, either because
2202 it is a copy of a linkonce section or due to
2203 linker script /DISCARD/, so we'll be discarding
2206 else if (p->count != 0)
2208 srel = elf_section_data (p->sec)->sreloc;
2209 srel->size += p->count * SPARC_ELF_RELA_BYTES (htab);
2210 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2211 info->flags |= DF_TEXTREL;
2216 local_got = elf_local_got_refcounts (ibfd);
2220 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2221 locsymcount = symtab_hdr->sh_info;
2222 end_local_got = local_got + locsymcount;
2223 local_tls_type = _bfd_sparc_elf_local_got_tls_type (ibfd);
2225 srel = htab->srelgot;
2226 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
2230 *local_got = s->size;
2231 s->size += SPARC_ELF_WORD_BYTES (htab);
2232 if (*local_tls_type == GOT_TLS_GD)
2233 s->size += SPARC_ELF_WORD_BYTES (htab);
2235 || *local_tls_type == GOT_TLS_GD
2236 || *local_tls_type == GOT_TLS_IE)
2237 srel->size += SPARC_ELF_RELA_BYTES (htab);
2240 *local_got = (bfd_vma) -1;
2244 if (htab->tls_ldm_got.refcount > 0)
2246 /* Allocate 2 got entries and 1 dynamic reloc for
2247 R_SPARC_TLS_LDM_{HI22,LO10} relocs. */
2248 htab->tls_ldm_got.offset = htab->sgot->size;
2249 htab->sgot->size += (2 * SPARC_ELF_WORD_BYTES (htab));
2250 htab->srelgot->size += SPARC_ELF_RELA_BYTES (htab);
2253 htab->tls_ldm_got.offset = -1;
2255 /* Allocate global sym .plt and .got entries, and space for global
2256 sym dynamic relocs. */
2257 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
2259 if (! ABI_64_P (output_bfd)
2260 && !htab->is_vxworks
2261 && elf_hash_table (info)->dynamic_sections_created)
2263 /* Make space for the trailing nop in .plt. */
2264 if (htab->splt->size > 0)
2265 htab->splt->size += 1 * SPARC_INSN_BYTES;
2267 /* If the .got section is more than 0x1000 bytes, we add
2268 0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13
2269 bit relocations have a greater chance of working.
2271 FIXME: Make this optimization work for 64-bit too. */
2272 if (htab->sgot->size >= 0x1000
2273 && elf_hash_table (info)->hgot->root.u.def.value == 0)
2274 elf_hash_table (info)->hgot->root.u.def.value = 0x1000;
2277 /* The check_relocs and adjust_dynamic_symbol entry points have
2278 determined the sizes of the various dynamic sections. Allocate
2280 for (s = dynobj->sections; s != NULL; s = s->next)
2282 if ((s->flags & SEC_LINKER_CREATED) == 0)
2287 || s == htab->sdynbss
2288 || s == htab->sgotplt)
2290 /* Strip this section if we don't need it; see the
2293 else if (strncmp (s->name, ".rela", 5) == 0)
2297 /* We use the reloc_count field as a counter if we need
2298 to copy relocs into the output file. */
2304 /* It's not one of our sections. */
2310 /* If we don't need this section, strip it from the
2311 output file. This is mostly to handle .rela.bss and
2312 .rela.plt. We must create both sections in
2313 create_dynamic_sections, because they must be created
2314 before the linker maps input sections to output
2315 sections. The linker does that before
2316 adjust_dynamic_symbol is called, and it is that
2317 function which decides whether anything needs to go
2318 into these sections. */
2319 s->flags |= SEC_EXCLUDE;
2323 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2326 /* Allocate memory for the section contents. Zero the memory
2327 for the benefit of .rela.plt, which has 4 unused entries
2328 at the beginning, and we don't want garbage. */
2329 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2330 if (s->contents == NULL)
2334 if (elf_hash_table (info)->dynamic_sections_created)
2336 /* Add some entries to the .dynamic section. We fill in the
2337 values later, in _bfd_sparc_elf_finish_dynamic_sections, but we
2338 must add the entries now so that we get the correct size for
2339 the .dynamic section. The DT_DEBUG entry is filled in by the
2340 dynamic linker and used by the debugger. */
2341 #define add_dynamic_entry(TAG, VAL) \
2342 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2344 if (info->executable)
2346 if (!add_dynamic_entry (DT_DEBUG, 0))
2350 if (htab->srelplt->size != 0)
2352 if (!add_dynamic_entry (DT_PLTGOT, 0)
2353 || !add_dynamic_entry (DT_PLTRELSZ, 0)
2354 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2355 || !add_dynamic_entry (DT_JMPREL, 0))
2359 if (!add_dynamic_entry (DT_RELA, 0)
2360 || !add_dynamic_entry (DT_RELASZ, 0)
2361 || !add_dynamic_entry (DT_RELAENT,
2362 SPARC_ELF_RELA_BYTES (htab)))
2365 /* If any dynamic relocs apply to a read-only section,
2366 then we need a DT_TEXTREL entry. */
2367 if ((info->flags & DF_TEXTREL) == 0)
2368 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
2371 if (info->flags & DF_TEXTREL)
2373 if (!add_dynamic_entry (DT_TEXTREL, 0))
2377 if (ABI_64_P (output_bfd))
2380 struct _bfd_sparc_elf_app_reg * app_regs;
2381 struct elf_strtab_hash *dynstr;
2382 struct elf_link_hash_table *eht = elf_hash_table (info);
2384 /* Add dynamic STT_REGISTER symbols and corresponding DT_SPARC_REGISTER
2385 entries if needed. */
2386 app_regs = _bfd_sparc_elf_hash_table (info)->app_regs;
2387 dynstr = eht->dynstr;
2389 for (reg = 0; reg < 4; reg++)
2390 if (app_regs [reg].name != NULL)
2392 struct elf_link_local_dynamic_entry *entry, *e;
2394 if (!add_dynamic_entry (DT_SPARC_REGISTER, 0))
2397 entry = (struct elf_link_local_dynamic_entry *)
2398 bfd_hash_allocate (&info->hash->table, sizeof (*entry));
2402 /* We cheat here a little bit: the symbol will not be local, so we
2403 put it at the end of the dynlocal linked list. We will fix it
2404 later on, as we have to fix other fields anyway. */
2405 entry->isym.st_value = reg < 2 ? reg + 2 : reg + 4;
2406 entry->isym.st_size = 0;
2407 if (*app_regs [reg].name != '\0')
2409 = _bfd_elf_strtab_add (dynstr, app_regs[reg].name, FALSE);
2411 entry->isym.st_name = 0;
2412 entry->isym.st_other = 0;
2413 entry->isym.st_info = ELF_ST_INFO (app_regs [reg].bind,
2415 entry->isym.st_shndx = app_regs [reg].shndx;
2417 entry->input_bfd = output_bfd;
2418 entry->input_indx = -1;
2420 if (eht->dynlocal == NULL)
2421 eht->dynlocal = entry;
2424 for (e = eht->dynlocal; e->next; e = e->next)
2432 #undef add_dynamic_entry
2438 _bfd_sparc_elf_new_section_hook (bfd *abfd, asection *sec)
2440 if (!sec->used_by_bfd)
2442 struct _bfd_sparc_elf_section_data *sdata;
2443 bfd_size_type amt = sizeof (*sdata);
2445 sdata = bfd_zalloc (abfd, amt);
2448 sec->used_by_bfd = sdata;
2451 return _bfd_elf_new_section_hook (abfd, sec);
2455 _bfd_sparc_elf_relax_section (bfd *abfd ATTRIBUTE_UNUSED,
2456 struct bfd_section *section,
2457 struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
2461 sec_do_relax (section) = 1;
2465 /* Return the base VMA address which should be subtracted from real addresses
2466 when resolving @dtpoff relocation.
2467 This is PT_TLS segment p_vaddr. */
2470 dtpoff_base (struct bfd_link_info *info)
2472 /* If tls_sec is NULL, we should have signalled an error already. */
2473 if (elf_hash_table (info)->tls_sec == NULL)
2475 return elf_hash_table (info)->tls_sec->vma;
2478 /* Return the relocation value for @tpoff relocation
2479 if STT_TLS virtual address is ADDRESS. */
2482 tpoff (struct bfd_link_info *info, bfd_vma address)
2484 struct elf_link_hash_table *htab = elf_hash_table (info);
2486 /* If tls_sec is NULL, we should have signalled an error already. */
2487 if (htab->tls_sec == NULL)
2489 return address - htab->tls_size - htab->tls_sec->vma;
2492 /* Relocate a SPARC ELF section. */
2495 _bfd_sparc_elf_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
2496 bfd *input_bfd, asection *input_section,
2497 bfd_byte *contents, Elf_Internal_Rela *relocs,
2498 Elf_Internal_Sym *local_syms, asection **local_sections)
2500 struct _bfd_sparc_elf_link_hash_table *htab;
2501 Elf_Internal_Shdr *symtab_hdr;
2502 struct elf_link_hash_entry **sym_hashes;
2503 bfd_vma *local_got_offsets;
2506 Elf_Internal_Rela *rel;
2507 Elf_Internal_Rela *relend;
2510 if (info->relocatable)
2513 htab = _bfd_sparc_elf_hash_table (info);
2514 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2515 sym_hashes = elf_sym_hashes (input_bfd);
2516 local_got_offsets = elf_local_got_offsets (input_bfd);
2518 if (elf_hash_table (info)->hgot == NULL)
2521 got_base = elf_hash_table (info)->hgot->root.u.def.value;
2523 sreloc = elf_section_data (input_section)->sreloc;
2526 if (ABI_64_P (output_bfd))
2527 num_relocs = NUM_SHDR_ENTRIES (& elf_section_data (input_section)->rel_hdr);
2529 num_relocs = input_section->reloc_count;
2530 relend = relocs + num_relocs;
2531 for (; rel < relend; rel++)
2533 int r_type, tls_type;
2534 reloc_howto_type *howto;
2535 unsigned long r_symndx;
2536 struct elf_link_hash_entry *h;
2537 Elf_Internal_Sym *sym;
2539 bfd_vma relocation, off;
2540 bfd_reloc_status_type r;
2541 bfd_boolean is_plt = FALSE;
2542 bfd_boolean unresolved_reloc;
2544 r_type = SPARC_ELF_R_TYPE (rel->r_info);
2545 if (r_type == R_SPARC_GNU_VTINHERIT
2546 || r_type == R_SPARC_GNU_VTENTRY)
2549 if (r_type < 0 || r_type >= (int) R_SPARC_max_std)
2551 bfd_set_error (bfd_error_bad_value);
2554 howto = _bfd_sparc_elf_howto_table + r_type;
2556 /* This is a final link. */
2557 r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
2561 unresolved_reloc = FALSE;
2562 if (r_symndx < symtab_hdr->sh_info)
2564 sym = local_syms + r_symndx;
2565 sec = local_sections[r_symndx];
2566 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2572 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2573 r_symndx, symtab_hdr, sym_hashes,
2575 unresolved_reloc, warned);
2578 /* To avoid generating warning messages about truncated
2579 relocations, set the relocation's address to be the same as
2580 the start of this section. */
2581 if (input_section->output_section != NULL)
2582 relocation = input_section->output_section->vma;
2593 /* Relocation is to the entry for this symbol in the global
2595 if (htab->sgot == NULL)
2602 off = h->got.offset;
2603 BFD_ASSERT (off != (bfd_vma) -1);
2604 dyn = elf_hash_table (info)->dynamic_sections_created;
2606 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2613 /* This is actually a static link, or it is a
2614 -Bsymbolic link and the symbol is defined
2615 locally, or the symbol was forced to be local
2616 because of a version file. We must initialize
2617 this entry in the global offset table. Since the
2618 offset must always be a multiple of 8 for 64-bit
2619 and 4 for 32-bit, we use the least significant bit
2620 to record whether we have initialized it already.
2622 When doing a dynamic link, we create a .rela.got
2623 relocation entry to initialize the value. This
2624 is done in the finish_dynamic_symbol routine. */
2629 SPARC_ELF_PUT_WORD (htab, output_bfd, relocation,
2630 htab->sgot->contents + off);
2635 unresolved_reloc = FALSE;
2639 BFD_ASSERT (local_got_offsets != NULL
2640 && local_got_offsets[r_symndx] != (bfd_vma) -1);
2642 off = local_got_offsets[r_symndx];
2644 /* The offset must always be a multiple of 8 on 64-bit and
2645 4 on 32-bit. We use the least significant bit to record
2646 whether we have already processed this entry. */
2655 Elf_Internal_Rela outrel;
2657 /* We need to generate a R_SPARC_RELATIVE reloc
2658 for the dynamic linker. */
2660 BFD_ASSERT (s != NULL);
2662 outrel.r_offset = (htab->sgot->output_section->vma
2663 + htab->sgot->output_offset
2665 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
2666 0, R_SPARC_RELATIVE);
2667 outrel.r_addend = relocation;
2669 SPARC_ELF_APPEND_RELA (htab, output_bfd, s, &outrel);
2672 SPARC_ELF_PUT_WORD (htab, output_bfd, relocation,
2673 htab->sgot->contents + off);
2674 local_got_offsets[r_symndx] |= 1;
2677 relocation = htab->sgot->output_offset + off - got_base;
2682 if (h == NULL || h->plt.offset == (bfd_vma) -1)
2684 r_type = (r_type == R_SPARC_PLT32) ? R_SPARC_32 : R_SPARC_64;
2689 case R_SPARC_WPLT30:
2690 case R_SPARC_HIPLT22:
2691 case R_SPARC_LOPLT10:
2692 case R_SPARC_PCPLT32:
2693 case R_SPARC_PCPLT22:
2694 case R_SPARC_PCPLT10:
2696 /* Relocation is to the entry for this symbol in the
2697 procedure linkage table. */
2699 if (! ABI_64_P (output_bfd))
2701 /* The Solaris native assembler will generate a WPLT30 reloc
2702 for a local symbol if you assemble a call from one
2703 section to another when using -K pic. We treat it as
2710 BFD_ASSERT (h != NULL);
2713 if (h->plt.offset == (bfd_vma) -1 || htab->splt == NULL)
2715 /* We didn't make a PLT entry for this symbol. This
2716 happens when statically linking PIC code, or when
2717 using -Bsymbolic. */
2721 relocation = (htab->splt->output_section->vma
2722 + htab->splt->output_offset
2724 unresolved_reloc = FALSE;
2725 if (r_type == R_SPARC_PLT32 || r_type == R_SPARC_PLT64)
2727 r_type = r_type == R_SPARC_PLT32 ? R_SPARC_32 : R_SPARC_64;
2735 case R_SPARC_PC_HH22:
2736 case R_SPARC_PC_HM10:
2737 case R_SPARC_PC_LM22:
2739 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2743 case R_SPARC_DISP16:
2744 case R_SPARC_DISP32:
2745 case R_SPARC_DISP64:
2746 case R_SPARC_WDISP30:
2747 case R_SPARC_WDISP22:
2748 case R_SPARC_WDISP19:
2749 case R_SPARC_WDISP16:
2776 /* r_symndx will be zero only for relocs against symbols
2777 from removed linkonce sections, or sections discarded by
2780 || (input_section->flags & SEC_ALLOC) == 0)
2785 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2786 || h->root.type != bfd_link_hash_undefweak)
2787 && (! howto->pc_relative
2790 && (! info->symbolic
2791 || !h->def_regular))))
2798 || h->root.type == bfd_link_hash_undefweak
2799 || h->root.type == bfd_link_hash_undefined)))
2801 Elf_Internal_Rela outrel;
2802 bfd_boolean skip, relocate = FALSE;
2804 /* When generating a shared object, these relocations
2805 are copied into the output file to be resolved at run
2808 BFD_ASSERT (sreloc != NULL);
2813 _bfd_elf_section_offset (output_bfd, info, input_section,
2815 if (outrel.r_offset == (bfd_vma) -1)
2817 else if (outrel.r_offset == (bfd_vma) -2)
2818 skip = TRUE, relocate = TRUE;
2819 outrel.r_offset += (input_section->output_section->vma
2820 + input_section->output_offset);
2822 /* Optimize unaligned reloc usage now that we know where
2823 it finally resides. */
2827 if (outrel.r_offset & 1)
2828 r_type = R_SPARC_UA16;
2831 if (!(outrel.r_offset & 1))
2832 r_type = R_SPARC_16;
2835 if (outrel.r_offset & 3)
2836 r_type = R_SPARC_UA32;
2839 if (!(outrel.r_offset & 3))
2840 r_type = R_SPARC_32;
2843 if (outrel.r_offset & 7)
2844 r_type = R_SPARC_UA64;
2847 if (!(outrel.r_offset & 7))
2848 r_type = R_SPARC_64;
2851 case R_SPARC_DISP16:
2852 case R_SPARC_DISP32:
2853 case R_SPARC_DISP64:
2854 /* If the symbol is not dynamic, we should not keep
2855 a dynamic relocation. But an .rela.* slot has been
2856 allocated for it, output R_SPARC_NONE.
2857 FIXME: Add code tracking needed dynamic relocs as
2859 if (h->dynindx == -1)
2860 skip = TRUE, relocate = TRUE;
2865 memset (&outrel, 0, sizeof outrel);
2866 /* h->dynindx may be -1 if the symbol was marked to
2868 else if (h != NULL && ! is_plt
2869 && ((! info->symbolic && h->dynindx != -1)
2870 || !h->def_regular))
2872 BFD_ASSERT (h->dynindx != -1);
2873 outrel.r_info = SPARC_ELF_R_INFO (htab, rel, h->dynindx, r_type);
2874 outrel.r_addend = rel->r_addend;
2878 if (r_type == R_SPARC_32 || r_type == R_SPARC_64)
2880 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
2881 0, R_SPARC_RELATIVE);
2882 outrel.r_addend = relocation + rel->r_addend;
2891 if (bfd_is_abs_section (sec))
2893 else if (sec == NULL || sec->owner == NULL)
2895 bfd_set_error (bfd_error_bad_value);
2902 osec = sec->output_section;
2903 indx = elf_section_data (osec)->dynindx;
2905 /* FIXME: we really should be able to link non-pic
2906 shared libraries. */
2910 (*_bfd_error_handler)
2911 (_("%B: probably compiled without -fPIC?"),
2913 bfd_set_error (bfd_error_bad_value);
2918 outrel.r_info = SPARC_ELF_R_INFO (htab, rel, indx, r_type);
2919 outrel.r_addend = relocation + rel->r_addend;
2923 SPARC_ELF_APPEND_RELA (htab, output_bfd, sreloc, &outrel);
2925 /* This reloc will be computed at runtime, so there's no
2926 need to do anything now. */
2932 case R_SPARC_TLS_GD_HI22:
2933 if (! ABI_64_P (input_bfd)
2934 && ! _bfd_sparc_elf_tdata (input_bfd)->has_tlsgd)
2936 /* R_SPARC_REV32 used the same reloc number as
2937 R_SPARC_TLS_GD_HI22. */
2938 r_type = R_SPARC_REV32;
2943 case R_SPARC_TLS_GD_LO10:
2944 case R_SPARC_TLS_IE_HI22:
2945 case R_SPARC_TLS_IE_LO10:
2946 r_type = sparc_elf_tls_transition (info, input_bfd, r_type, h == NULL);
2947 tls_type = GOT_UNKNOWN;
2948 if (h == NULL && local_got_offsets)
2949 tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
2952 tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
2953 if (!info->shared && h->dynindx == -1 && tls_type == GOT_TLS_IE)
2954 switch (SPARC_ELF_R_TYPE (rel->r_info))
2956 case R_SPARC_TLS_GD_HI22:
2957 case R_SPARC_TLS_IE_HI22:
2958 r_type = R_SPARC_TLS_LE_HIX22;
2961 r_type = R_SPARC_TLS_LE_LOX10;
2965 if (tls_type == GOT_TLS_IE)
2968 case R_SPARC_TLS_GD_HI22:
2969 r_type = R_SPARC_TLS_IE_HI22;
2971 case R_SPARC_TLS_GD_LO10:
2972 r_type = R_SPARC_TLS_IE_LO10;
2976 if (r_type == R_SPARC_TLS_LE_HIX22)
2978 relocation = tpoff (info, relocation);
2981 if (r_type == R_SPARC_TLS_LE_LOX10)
2983 /* Change add into xor. */
2984 relocation = tpoff (info, relocation);
2985 bfd_put_32 (output_bfd, (bfd_get_32 (input_bfd,
2986 contents + rel->r_offset)
2987 | 0x80182000), contents + rel->r_offset);
2993 off = h->got.offset;
2998 BFD_ASSERT (local_got_offsets != NULL);
2999 off = local_got_offsets[r_symndx];
3000 local_got_offsets[r_symndx] |= 1;
3004 if (htab->sgot == NULL)
3011 Elf_Internal_Rela outrel;
3014 if (htab->srelgot == NULL)
3017 SPARC_ELF_PUT_WORD (htab, output_bfd, 0, htab->sgot->contents + off);
3018 outrel.r_offset = (htab->sgot->output_section->vma
3019 + htab->sgot->output_offset + off);
3020 indx = h && h->dynindx != -1 ? h->dynindx : 0;
3021 if (r_type == R_SPARC_TLS_IE_HI22
3022 || r_type == R_SPARC_TLS_IE_LO10)
3023 dr_type = SPARC_ELF_TPOFF_RELOC (htab);
3025 dr_type = SPARC_ELF_DTPMOD_RELOC (htab);
3026 if (dr_type == SPARC_ELF_TPOFF_RELOC (htab) && indx == 0)
3027 outrel.r_addend = relocation - dtpoff_base (info);
3029 outrel.r_addend = 0;
3030 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx, dr_type);
3031 SPARC_ELF_APPEND_RELA (htab, output_bfd, htab->srelgot, &outrel);
3033 if (r_type == R_SPARC_TLS_GD_HI22
3034 || r_type == R_SPARC_TLS_GD_LO10)
3038 BFD_ASSERT (! unresolved_reloc);
3039 SPARC_ELF_PUT_WORD (htab, output_bfd,
3040 relocation - dtpoff_base (info),
3041 (htab->sgot->contents + off
3042 + SPARC_ELF_WORD_BYTES (htab)));
3046 SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3047 (htab->sgot->contents + off
3048 + SPARC_ELF_WORD_BYTES (htab)));
3049 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx,
3050 SPARC_ELF_DTPOFF_RELOC (htab));
3051 outrel.r_offset += SPARC_ELF_WORD_BYTES (htab);
3052 SPARC_ELF_APPEND_RELA (htab, output_bfd, htab->srelgot, &outrel);
3055 else if (dr_type == SPARC_ELF_DTPMOD_RELOC (htab))
3057 SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3058 (htab->sgot->contents + off
3059 + SPARC_ELF_WORD_BYTES (htab)));
3063 if (off >= (bfd_vma) -2)
3066 relocation = htab->sgot->output_offset + off - got_base;
3067 unresolved_reloc = FALSE;
3068 howto = _bfd_sparc_elf_howto_table + r_type;
3071 case R_SPARC_TLS_LDM_HI22:
3072 case R_SPARC_TLS_LDM_LO10:
3075 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3078 off = htab->tls_ldm_got.offset;
3079 htab->tls_ldm_got.offset |= 1;
3080 goto r_sparc_tlsldm;
3082 case R_SPARC_TLS_LDO_HIX22:
3083 case R_SPARC_TLS_LDO_LOX10:
3086 relocation -= dtpoff_base (info);
3090 r_type = (r_type == R_SPARC_TLS_LDO_HIX22
3091 ? R_SPARC_TLS_LE_HIX22 : R_SPARC_TLS_LE_LOX10);
3094 case R_SPARC_TLS_LE_HIX22:
3095 case R_SPARC_TLS_LE_LOX10:
3098 Elf_Internal_Rela outrel;
3099 bfd_boolean skip, relocate = FALSE;
3101 BFD_ASSERT (sreloc != NULL);
3104 _bfd_elf_section_offset (output_bfd, info, input_section,
3106 if (outrel.r_offset == (bfd_vma) -1)
3108 else if (outrel.r_offset == (bfd_vma) -2)
3109 skip = TRUE, relocate = TRUE;
3110 outrel.r_offset += (input_section->output_section->vma
3111 + input_section->output_offset);
3113 memset (&outrel, 0, sizeof outrel);
3116 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, r_type);
3117 outrel.r_addend = relocation - dtpoff_base (info)
3121 SPARC_ELF_APPEND_RELA (htab, output_bfd, sreloc, &outrel);
3124 relocation = tpoff (info, relocation);
3127 case R_SPARC_TLS_LDM_CALL:
3131 bfd_put_32 (output_bfd, 0x90100000, contents + rel->r_offset);
3136 case R_SPARC_TLS_GD_CALL:
3137 tls_type = GOT_UNKNOWN;
3138 if (h == NULL && local_got_offsets)
3139 tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3141 tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3143 || (r_type == R_SPARC_TLS_GD_CALL && tls_type == GOT_TLS_IE))
3147 if (!info->shared && (h == NULL || h->dynindx == -1))
3150 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3155 if (rel + 1 < relend
3156 && SPARC_ELF_R_TYPE (rel[1].r_info) == R_SPARC_TLS_GD_ADD
3157 && rel[1].r_offset == rel->r_offset + 4
3158 && SPARC_ELF_R_SYMNDX (htab, rel[1].r_info) == r_symndx
3159 && (((insn = bfd_get_32 (input_bfd,
3160 contents + rel[1].r_offset))
3161 >> 25) & 0x1f) == 8)
3164 call __tls_get_addr, %tgd_call(foo)
3165 add %reg1, %reg2, %o0, %tgd_add(foo)
3166 and change it into IE:
3167 {ld,ldx} [%reg1 + %reg2], %o0, %tie_ldx(foo)
3168 add %g7, %o0, %o0, %tie_add(foo).
3169 add is 0x80000000 | (rd << 25) | (rs1 << 14) | rs2,
3170 ld is 0xc0000000 | (rd << 25) | (rs1 << 14) | rs2,
3171 ldx is 0xc0580000 | (rd << 25) | (rs1 << 14) | rs2. */
3172 bfd_put_32 (output_bfd, insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000),
3173 contents + rel->r_offset);
3174 bfd_put_32 (output_bfd, 0x9001c008,
3175 contents + rel->r_offset + 4);
3180 bfd_put_32 (output_bfd, 0x9001c008, contents + rel->r_offset);
3184 h = (struct elf_link_hash_entry *)
3185 bfd_link_hash_lookup (info->hash, "__tls_get_addr", FALSE,
3187 BFD_ASSERT (h != NULL);
3188 r_type = R_SPARC_WPLT30;
3189 howto = _bfd_sparc_elf_howto_table + r_type;
3190 goto r_sparc_wplt30;
3192 case R_SPARC_TLS_GD_ADD:
3193 tls_type = GOT_UNKNOWN;
3194 if (h == NULL && local_got_offsets)
3195 tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3197 tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3198 if (! info->shared || tls_type == GOT_TLS_IE)
3200 /* add %reg1, %reg2, %reg3, %tgd_add(foo)
3202 {ld,ldx} [%reg1 + %reg2], %reg3, %tie_ldx(foo)
3204 add %g7, %reg2, %reg3. */
3205 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3206 if ((h != NULL && h->dynindx != -1) || info->shared)
3207 relocation = insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000);
3209 relocation = (insn & ~0x7c000) | 0x1c000;
3210 bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3214 case R_SPARC_TLS_LDM_ADD:
3216 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3219 case R_SPARC_TLS_LDO_ADD:
3222 /* Change rs1 into %g7. */
3223 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3224 insn = (insn & ~0x7c000) | 0x1c000;
3225 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3229 case R_SPARC_TLS_IE_LD:
3230 case R_SPARC_TLS_IE_LDX:
3231 if (! info->shared && (h == NULL || h->dynindx == -1))
3233 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3234 int rs2 = insn & 0x1f;
3235 int rd = (insn >> 25) & 0x1f;
3238 relocation = SPARC_NOP;
3240 relocation = 0x80100000 | (insn & 0x3e00001f);
3241 bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3245 case R_SPARC_TLS_IE_ADD:
3246 /* Totally useless relocation. */
3249 case R_SPARC_TLS_DTPOFF32:
3250 case R_SPARC_TLS_DTPOFF64:
3251 relocation -= dtpoff_base (info);
3258 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3259 because such sections are not SEC_ALLOC and thus ld.so will
3260 not process them. */
3261 if (unresolved_reloc
3262 && !((input_section->flags & SEC_DEBUGGING) != 0
3264 (*_bfd_error_handler)
3265 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3268 (long) rel->r_offset,
3270 h->root.root.string);
3272 r = bfd_reloc_continue;
3273 if (r_type == R_SPARC_OLO10)
3277 if (! ABI_64_P (output_bfd))
3280 relocation += rel->r_addend;
3281 relocation = (relocation & 0x3ff) + ELF64_R_TYPE_DATA (rel->r_info);
3283 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3284 x = (x & ~(bfd_vma) 0x1fff) | (relocation & 0x1fff);
3285 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3287 r = bfd_check_overflow (howto->complain_on_overflow,
3288 howto->bitsize, howto->rightshift,
3289 bfd_arch_bits_per_address (input_bfd),
3292 else if (r_type == R_SPARC_WDISP16)
3296 relocation += rel->r_addend;
3297 relocation -= (input_section->output_section->vma
3298 + input_section->output_offset);
3299 relocation -= rel->r_offset;
3301 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3302 x |= ((((relocation >> 2) & 0xc000) << 6)
3303 | ((relocation >> 2) & 0x3fff));
3304 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3306 r = bfd_check_overflow (howto->complain_on_overflow,
3307 howto->bitsize, howto->rightshift,
3308 bfd_arch_bits_per_address (input_bfd),
3311 else if (r_type == R_SPARC_REV32)
3315 relocation = relocation + rel->r_addend;
3317 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3319 bfd_putl32 (/*input_bfd,*/ x, contents + rel->r_offset);
3322 else if (r_type == R_SPARC_TLS_LDO_HIX22
3323 || r_type == R_SPARC_TLS_LE_HIX22)
3327 relocation += rel->r_addend;
3328 if (r_type == R_SPARC_TLS_LE_HIX22)
3329 relocation ^= MINUS_ONE;
3331 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3332 x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
3333 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3336 else if (r_type == R_SPARC_TLS_LDO_LOX10
3337 || r_type == R_SPARC_TLS_LE_LOX10)
3341 relocation += rel->r_addend;
3342 relocation &= 0x3ff;
3343 if (r_type == R_SPARC_TLS_LE_LOX10)
3344 relocation |= 0x1c00;
3346 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3347 x = (x & ~(bfd_vma) 0x1fff) | relocation;
3348 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3352 else if (r_type == R_SPARC_HIX22)
3356 relocation += rel->r_addend;
3357 relocation = relocation ^ MINUS_ONE;
3359 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3360 x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
3361 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3363 r = bfd_check_overflow (howto->complain_on_overflow,
3364 howto->bitsize, howto->rightshift,
3365 bfd_arch_bits_per_address (input_bfd),
3368 else if (r_type == R_SPARC_LOX10)
3372 relocation += rel->r_addend;
3373 relocation = (relocation & 0x3ff) | 0x1c00;
3375 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3376 x = (x & ~(bfd_vma) 0x1fff) | relocation;
3377 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3381 else if ((r_type == R_SPARC_WDISP30 || r_type == R_SPARC_WPLT30)
3382 && sec_do_relax (input_section)
3383 && rel->r_offset + 4 < input_section->size)
3387 #define XCC (2 << 20)
3388 #define COND(x) (((x)&0xf)<<25)
3389 #define CONDA COND(0x8)
3390 #define INSN_BPA (F2(0,1) | CONDA | BPRED | XCC)
3391 #define INSN_BA (F2(0,2) | CONDA)
3392 #define INSN_OR F3(2, 0x2, 0)
3393 #define INSN_NOP F2(0,4)
3397 /* If the instruction is a call with either:
3399 arithmetic instruction with rd == %o7
3400 where rs1 != %o7 and rs2 if it is register != %o7
3401 then we can optimize if the call destination is near
3402 by changing the call into a branch always. */
3403 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3404 y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
3405 if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2))
3407 if (((y & OP3(~0)) == OP3(0x3d) /* restore */
3408 || ((y & OP3(0x28)) == 0 /* arithmetic */
3409 && (y & RD(~0)) == RD(O7)))
3410 && (y & RS1(~0)) != RS1(O7)
3412 || (y & RS2(~0)) != RS2(O7)))
3416 reloc = relocation + rel->r_addend - rel->r_offset;
3417 reloc -= (input_section->output_section->vma
3418 + input_section->output_offset);
3420 /* Ensure the branch fits into simm22. */
3421 if ((reloc & 3) == 0
3422 && ((reloc & ~(bfd_vma)0x7fffff) == 0
3423 || ((reloc | 0x7fffff) == ~(bfd_vma)0)))
3427 /* Check whether it fits into simm19. */
3428 if (((reloc & 0x3c0000) == 0
3429 || (reloc & 0x3c0000) == 0x3c0000)
3430 && (ABI_64_P (output_bfd)
3431 || elf_elfheader (output_bfd)->e_flags & EF_SPARC_32PLUS))
3432 x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */
3434 x = INSN_BA | (reloc & 0x3fffff); /* ba */
3435 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3437 if (rel->r_offset >= 4
3438 && (y & (0xffffffff ^ RS1(~0)))
3439 == (INSN_OR | RD(O7) | RS2(G0)))
3444 z = bfd_get_32 (input_bfd,
3445 contents + rel->r_offset - 4);
3446 if ((z & (0xffffffff ^ RD(~0)))
3447 != (INSN_OR | RS1(O7) | RS2(G0)))
3455 If call foo was replaced with ba, replace
3456 or %rN, %g0, %o7 with nop. */
3458 reg = (y & RS1(~0)) >> 14;
3459 if (reg != ((z & RD(~0)) >> 25)
3460 || reg == G0 || reg == O7)
3463 bfd_put_32 (input_bfd, (bfd_vma) INSN_NOP,
3464 contents + rel->r_offset + 4);
3472 if (r == bfd_reloc_continue)
3473 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3474 contents, rel->r_offset,
3475 relocation, rel->r_addend);
3477 if (r != bfd_reloc_ok)
3482 case bfd_reloc_outofrange:
3484 case bfd_reloc_overflow:
3488 /* The Solaris native linker silently disregards overflows.
3489 We don't, but this breaks stabs debugging info, whose
3490 relocations are only 32-bits wide. Ignore overflows in
3491 this case and also for discarded entries. */
3492 if ((r_type == R_SPARC_32 || r_type == R_SPARC_DISP32)
3493 && (((input_section->flags & SEC_DEBUGGING) != 0
3494 && strcmp (bfd_section_name (input_bfd,
3497 || _bfd_elf_section_offset (output_bfd, info,
3505 /* Assume this is a call protected by other code that
3506 detect the symbol is undefined. If this is the case,
3507 we can safely ignore the overflow. If not, the
3508 program is hosed anyway, and a little warning isn't
3510 if (h->root.type == bfd_link_hash_undefweak
3511 && howto->pc_relative)
3518 name = bfd_elf_string_from_elf_section (input_bfd,
3519 symtab_hdr->sh_link,
3524 name = bfd_section_name (input_bfd, sec);
3526 if (! ((*info->callbacks->reloc_overflow)
3527 (info, (h ? &h->root : NULL), name, howto->name,
3528 (bfd_vma) 0, input_bfd, input_section,
3540 /* Build a VxWorks PLT entry. PLT_INDEX is the index of the PLT entry
3541 and PLT_OFFSET is the byte offset from the start of .plt. GOT_OFFSET
3542 is the offset of the associated .got.plt entry from
3543 _GLOBAL_OFFSET_TABLE_. */
3546 sparc_vxworks_build_plt_entry (bfd *output_bfd, struct bfd_link_info *info,
3547 bfd_vma plt_offset, bfd_vma plt_index,
3551 const bfd_vma *plt_entry;
3552 struct _bfd_sparc_elf_link_hash_table *htab;
3554 Elf_Internal_Rela rela;
3556 htab = _bfd_sparc_elf_hash_table (info);
3559 plt_entry = sparc_vxworks_shared_plt_entry;
3564 plt_entry = sparc_vxworks_exec_plt_entry;
3565 got_base = (htab->elf.hgot->root.u.def.value
3566 + htab->elf.hgot->root.u.def.section->output_offset
3567 + htab->elf.hgot->root.u.def.section->output_section->vma);
3570 /* Fill in the entry in the procedure linkage table. */
3571 bfd_put_32 (output_bfd, plt_entry[0] + ((got_base + got_offset) >> 10),
3572 htab->splt->contents + plt_offset);
3573 bfd_put_32 (output_bfd, plt_entry[1] + ((got_base + got_offset) & 0x3ff),
3574 htab->splt->contents + plt_offset + 4);
3575 bfd_put_32 (output_bfd, plt_entry[2],
3576 htab->splt->contents + plt_offset + 8);
3577 bfd_put_32 (output_bfd, plt_entry[3],
3578 htab->splt->contents + plt_offset + 12);
3579 bfd_put_32 (output_bfd, plt_entry[4],
3580 htab->splt->contents + plt_offset + 16);
3581 bfd_put_32 (output_bfd, plt_entry[5] + (plt_index >> 10),
3582 htab->splt->contents + plt_offset + 20);
3583 /* PC-relative displacement for a branch to the start of
3585 bfd_put_32 (output_bfd, plt_entry[6] + (((-plt_offset - 24) >> 2)
3587 htab->splt->contents + plt_offset + 24);
3588 bfd_put_32 (output_bfd, plt_entry[7] + (plt_index & 0x3ff),
3589 htab->splt->contents + plt_offset + 28);
3591 /* Fill in the .got.plt entry, pointing initially at the
3592 second half of the PLT entry. */
3593 BFD_ASSERT (htab->sgotplt != NULL);
3594 bfd_put_32 (output_bfd,
3595 htab->splt->output_section->vma
3596 + htab->splt->output_offset
3598 htab->sgotplt->contents + got_offset);
3600 /* Add relocations to .rela.plt.unloaded. */
3603 loc = (htab->srelplt2->contents
3604 + (2 + 3 * plt_index) * sizeof (Elf32_External_Rela));
3606 /* Relocate the initial sethi. */
3607 rela.r_offset = (htab->splt->output_section->vma
3608 + htab->splt->output_offset
3610 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
3611 rela.r_addend = got_offset;
3612 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3613 loc += sizeof (Elf32_External_Rela);
3615 /* Likewise the following or. */
3617 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
3618 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3619 loc += sizeof (Elf32_External_Rela);
3621 /* Relocate the .got.plt entry. */
3622 rela.r_offset = (htab->sgotplt->output_section->vma
3623 + htab->sgotplt->output_offset
3625 rela.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_SPARC_32);
3626 rela.r_addend = plt_offset + 20;
3627 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3631 /* Finish up dynamic symbol handling. We set the contents of various
3632 dynamic sections here. */
3635 _bfd_sparc_elf_finish_dynamic_symbol (bfd *output_bfd,
3636 struct bfd_link_info *info,
3637 struct elf_link_hash_entry *h,
3638 Elf_Internal_Sym *sym)
3641 struct _bfd_sparc_elf_link_hash_table *htab;
3643 htab = _bfd_sparc_elf_hash_table (info);
3644 dynobj = htab->elf.dynobj;
3646 if (h->plt.offset != (bfd_vma) -1)
3650 Elf_Internal_Rela rela;
3652 bfd_vma r_offset, got_offset;
3655 /* This symbol has an entry in the PLT. Set it up. */
3657 BFD_ASSERT (h->dynindx != -1);
3660 srela = htab->srelplt;
3661 BFD_ASSERT (splt != NULL && srela != NULL);
3663 /* Fill in the entry in the .rela.plt section. */
3664 if (htab->is_vxworks)
3666 /* Work out the index of this PLT entry. */
3667 rela_index = ((h->plt.offset - htab->plt_header_size)
3668 / htab->plt_entry_size);
3670 /* Calculate the offset of the associated .got.plt entry.
3671 The first three entries are reserved. */
3672 got_offset = (rela_index + 3) * 4;
3674 sparc_vxworks_build_plt_entry (output_bfd, info, h->plt.offset,
3675 rela_index, got_offset);
3678 /* On VxWorks, the relocation points to the .got.plt entry,
3679 not the .plt entry. */
3680 rela.r_offset = (htab->sgotplt->output_section->vma
3681 + htab->sgotplt->output_offset
3687 /* Fill in the entry in the procedure linkage table. */
3688 rela_index = SPARC_ELF_BUILD_PLT_ENTRY (htab, output_bfd, splt,
3689 h->plt.offset, splt->size,
3692 rela.r_offset = r_offset
3693 + (splt->output_section->vma + splt->output_offset);
3694 if (! ABI_64_P (output_bfd)
3695 || h->plt.offset < (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE))
3701 rela.r_addend = (-(h->plt.offset + 4)
3702 - splt->output_section->vma
3703 - splt->output_offset);
3706 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_JMP_SLOT);
3708 /* Adjust for the first 4 reserved elements in the .plt section
3709 when setting the offset in the .rela.plt section.
3710 Sun forgot to read their own ABI and copied elf32-sparc behaviour,
3711 thus .plt[4] has corresponding .rela.plt[0] and so on. */
3713 loc = srela->contents;
3715 if (ABI_64_P (output_bfd))
3717 loc += rela_index * sizeof (Elf64_External_Rela);
3718 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3723 loc += rela_index * sizeof (Elf32_External_Rela);
3724 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3727 if (!h->def_regular)
3729 /* Mark the symbol as undefined, rather than as defined in
3730 the .plt section. Leave the value alone. */
3731 sym->st_shndx = SHN_UNDEF;
3732 /* If the symbol is weak, we do need to clear the value.
3733 Otherwise, the PLT entry would provide a definition for
3734 the symbol even if the symbol wasn't defined anywhere,
3735 and so the symbol would never be NULL. */
3736 if (!h->ref_regular_nonweak)
3741 if (h->got.offset != (bfd_vma) -1
3742 && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_GD
3743 && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_IE)
3747 Elf_Internal_Rela rela;
3749 /* This symbol has an entry in the GOT. Set it up. */
3752 srela = htab->srelgot;
3753 BFD_ASSERT (sgot != NULL && srela != NULL);
3755 rela.r_offset = (sgot->output_section->vma
3756 + sgot->output_offset
3757 + (h->got.offset &~ (bfd_vma) 1));
3759 /* If this is a -Bsymbolic link, and the symbol is defined
3760 locally, we just want to emit a RELATIVE reloc. Likewise if
3761 the symbol was forced to be local because of a version file.
3762 The entry in the global offset table will already have been
3763 initialized in the relocate_section function. */
3765 && (info->symbolic || h->dynindx == -1)
3768 asection *sec = h->root.u.def.section;
3769 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, R_SPARC_RELATIVE);
3770 rela.r_addend = (h->root.u.def.value
3771 + sec->output_section->vma
3772 + sec->output_offset);
3776 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_GLOB_DAT);
3780 SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3781 sgot->contents + (h->got.offset & ~(bfd_vma) 1));
3782 SPARC_ELF_APPEND_RELA (htab, output_bfd, srela, &rela);
3788 Elf_Internal_Rela rela;
3790 /* This symbols needs a copy reloc. Set it up. */
3791 BFD_ASSERT (h->dynindx != -1);
3793 s = bfd_get_section_by_name (h->root.u.def.section->owner,
3795 BFD_ASSERT (s != NULL);
3797 rela.r_offset = (h->root.u.def.value
3798 + h->root.u.def.section->output_section->vma
3799 + h->root.u.def.section->output_offset);
3800 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_COPY);
3802 SPARC_ELF_APPEND_RELA (htab, output_bfd, s, &rela);
3805 /* Mark some specially defined symbols as absolute. On VxWorks,
3806 _GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the
3807 ".got" section. Likewise _PROCEDURE_LINKAGE_TABLE_ and ".plt". */
3808 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3809 || (!htab->is_vxworks
3810 && (h == htab->elf.hgot || h == htab->elf.hplt)))
3811 sym->st_shndx = SHN_ABS;
3816 /* Finish up the dynamic sections. */
3820 sparc64_finish_dyn (bfd *output_bfd, struct bfd_link_info *info,
3821 bfd *dynobj, asection *sdyn,
3822 asection *splt ATTRIBUTE_UNUSED)
3824 Elf64_External_Dyn *dyncon, *dynconend;
3825 int stt_regidx = -1;
3827 dyncon = (Elf64_External_Dyn *) sdyn->contents;
3828 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
3829 for (; dyncon < dynconend; dyncon++)
3831 Elf_Internal_Dyn dyn;
3835 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3839 case DT_PLTGOT: name = ".plt"; size = FALSE; break;
3840 case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break;
3841 case DT_JMPREL: name = ".rela.plt"; size = FALSE; break;
3842 case DT_SPARC_REGISTER:
3843 if (stt_regidx == -1)
3846 _bfd_elf_link_lookup_local_dynindx (info, output_bfd, -1);
3847 if (stt_regidx == -1)
3850 dyn.d_un.d_val = stt_regidx++;
3851 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3853 default: name = NULL; size = FALSE; break;
3860 s = bfd_get_section_by_name (output_bfd, name);
3866 dyn.d_un.d_ptr = s->vma;
3868 dyn.d_un.d_val = s->size;
3870 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3878 sparc32_finish_dyn (bfd *output_bfd, struct bfd_link_info *info,
3879 bfd *dynobj, asection *sdyn,
3880 asection *splt ATTRIBUTE_UNUSED)
3882 Elf32_External_Dyn *dyncon, *dynconend;
3883 struct _bfd_sparc_elf_link_hash_table *htab;
3885 htab = _bfd_sparc_elf_hash_table (info);
3886 dyncon = (Elf32_External_Dyn *) sdyn->contents;
3887 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3888 for (; dyncon < dynconend; dyncon++)
3890 Elf_Internal_Dyn dyn;
3894 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3896 if (htab->is_vxworks && dyn.d_tag == DT_RELASZ)
3898 /* On VxWorks, DT_RELASZ should not include the relocations
3902 dyn.d_un.d_val -= htab->srelplt->size;
3903 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3906 else if (htab->is_vxworks && dyn.d_tag == DT_PLTGOT)
3908 /* On VxWorks, DT_PLTGOT should point to the start of the GOT,
3909 not to the start of the PLT. */
3912 dyn.d_un.d_val = (htab->sgotplt->output_section->vma
3913 + htab->sgotplt->output_offset);
3914 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3921 case DT_PLTGOT: name = ".plt"; size = FALSE; break;
3922 case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break;
3923 case DT_JMPREL: name = ".rela.plt"; size = FALSE; break;
3924 default: name = NULL; size = FALSE; break;
3931 s = bfd_get_section_by_name (output_bfd, name);
3937 dyn.d_un.d_ptr = s->vma;
3939 dyn.d_un.d_val = s->size;
3941 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3948 /* Install the first PLT entry in a VxWorks executable and make sure that
3949 .rela.plt.unloaded relocations have the correct symbol indexes. */
3952 sparc_vxworks_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info)
3954 struct _bfd_sparc_elf_link_hash_table *htab;
3955 Elf_Internal_Rela rela;
3959 htab = _bfd_sparc_elf_hash_table (info);
3961 /* Calculate the absolute value of _GLOBAL_OFFSET_TABLE_. */
3962 got_base = (htab->elf.hgot->root.u.def.section->output_section->vma
3963 + htab->elf.hgot->root.u.def.section->output_offset
3964 + htab->elf.hgot->root.u.def.value);
3966 /* Install the initial PLT entry. */
3967 bfd_put_32 (output_bfd,
3968 sparc_vxworks_exec_plt0_entry[0] + ((got_base + 8) >> 10),
3969 htab->splt->contents);
3970 bfd_put_32 (output_bfd,
3971 sparc_vxworks_exec_plt0_entry[1] + ((got_base + 8) & 0x3ff),
3972 htab->splt->contents + 4);
3973 bfd_put_32 (output_bfd,
3974 sparc_vxworks_exec_plt0_entry[2],
3975 htab->splt->contents + 8);
3976 bfd_put_32 (output_bfd,
3977 sparc_vxworks_exec_plt0_entry[3],
3978 htab->splt->contents + 12);
3979 bfd_put_32 (output_bfd,
3980 sparc_vxworks_exec_plt0_entry[4],
3981 htab->splt->contents + 16);
3983 loc = htab->srelplt2->contents;
3985 /* Add an unloaded relocation for the initial entry's "sethi". */
3986 rela.r_offset = (htab->splt->output_section->vma
3987 + htab->splt->output_offset);
3988 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
3990 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3991 loc += sizeof (Elf32_External_Rela);
3993 /* Likewise the following "or". */
3995 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
3996 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3997 loc += sizeof (Elf32_External_Rela);
3999 /* Fix up the remaining .rela.plt.unloaded relocations. They may have
4000 the wrong symbol index for _G_O_T_ or _P_L_T_ depending on the order
4001 in which symbols were output. */
4002 while (loc < htab->srelplt2->contents + htab->srelplt2->size)
4004 Elf_Internal_Rela rel;
4006 /* The entry's initial "sethi" (against _G_O_T_). */
4007 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4008 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4009 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4010 loc += sizeof (Elf32_External_Rela);
4012 /* The following "or" (also against _G_O_T_). */
4013 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4014 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4015 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4016 loc += sizeof (Elf32_External_Rela);
4018 /* The .got.plt entry (against _P_L_T_). */
4019 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4020 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_SPARC_32);
4021 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4022 loc += sizeof (Elf32_External_Rela);
4026 /* Install the first PLT entry in a VxWorks shared object. */
4029 sparc_vxworks_finish_shared_plt (bfd *output_bfd, struct bfd_link_info *info)
4031 struct _bfd_sparc_elf_link_hash_table *htab;
4034 htab = _bfd_sparc_elf_hash_table (info);
4035 for (i = 0; i < ARRAY_SIZE (sparc_vxworks_shared_plt0_entry); i++)
4036 bfd_put_32 (output_bfd, sparc_vxworks_shared_plt0_entry[i],
4037 htab->splt->contents + i * 4);
4041 _bfd_sparc_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
4045 struct _bfd_sparc_elf_link_hash_table *htab;
4047 htab = _bfd_sparc_elf_hash_table (info);
4048 dynobj = htab->elf.dynobj;
4050 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4052 if (elf_hash_table (info)->dynamic_sections_created)
4057 splt = bfd_get_section_by_name (dynobj, ".plt");
4058 BFD_ASSERT (splt != NULL && sdyn != NULL);
4061 if (ABI_64_P (output_bfd))
4062 ret = sparc64_finish_dyn (output_bfd, info, dynobj, sdyn, splt);
4065 ret = sparc32_finish_dyn (output_bfd, info, dynobj, sdyn, splt);
4070 /* Initialize the contents of the .plt section. */
4073 if (htab->is_vxworks)
4076 sparc_vxworks_finish_shared_plt (output_bfd, info);
4078 sparc_vxworks_finish_exec_plt (output_bfd, info);
4082 memset (splt->contents, 0, htab->plt_header_size);
4083 if (!ABI_64_P (output_bfd))
4084 bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP,
4085 splt->contents + splt->size - 4);
4089 elf_section_data (splt->output_section)->this_hdr.sh_entsize
4090 = htab->plt_entry_size;
4093 /* Set the first entry in the global offset table to the address of
4094 the dynamic section. */
4095 if (htab->sgot && htab->sgot->size > 0)
4097 bfd_vma val = (sdyn ?
4098 sdyn->output_section->vma + sdyn->output_offset :
4101 SPARC_ELF_PUT_WORD (htab, output_bfd, val, htab->sgot->contents);
4105 elf_section_data (htab->sgot->output_section)->this_hdr.sh_entsize =
4106 SPARC_ELF_WORD_BYTES (htab);
4112 /* Set the right machine number for a SPARC ELF file. */
4115 _bfd_sparc_elf_object_p (bfd *abfd)
4117 if (ABI_64_P (abfd))
4119 unsigned long mach = bfd_mach_sparc_v9;
4121 if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
4122 mach = bfd_mach_sparc_v9b;
4123 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
4124 mach = bfd_mach_sparc_v9a;
4125 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, mach);
4129 if (elf_elfheader (abfd)->e_machine == EM_SPARC32PLUS)
4131 if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
4132 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4133 bfd_mach_sparc_v8plusb);
4134 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
4135 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4136 bfd_mach_sparc_v8plusa);
4137 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_32PLUS)
4138 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4139 bfd_mach_sparc_v8plus);
4143 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_LEDATA)
4144 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4145 bfd_mach_sparc_sparclite_le);
4147 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc);
4151 /* Return address for Ith PLT stub in section PLT, for relocation REL
4152 or (bfd_vma) -1 if it should not be included. */
4155 _bfd_sparc_elf_plt_sym_val (bfd_vma i, const asection *plt, const arelent *rel)
4157 if (ABI_64_P (plt->owner))
4161 i += PLT64_HEADER_SIZE / PLT64_ENTRY_SIZE;
4162 if (i < PLT64_LARGE_THRESHOLD)
4163 return plt->vma + i * PLT64_ENTRY_SIZE;
4165 j = (i - PLT64_LARGE_THRESHOLD) % 160;
4167 return plt->vma + i * PLT64_ENTRY_SIZE + j * 4 * 6;
4170 return rel->address;