1 /* SPARC-specific support for ELF
2 Copyright 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
3 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
23 /* This file handles functionality common to the different SPARC ABI's. */
29 #include "libiberty.h"
31 #include "elf/sparc.h"
32 #include "opcode/sparc.h"
33 #include "elfxx-sparc.h"
34 #include "elf-vxworks.h"
38 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
39 #define MINUS_ONE (~ (bfd_vma) 0)
41 #define ABI_64_P(abfd) \
42 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
44 /* The relocation "howto" table. */
46 /* Utility for performing the standard initial work of an instruction
48 *PRELOCATION will contain the relocated item.
49 *PINSN will contain the instruction from the input stream.
50 If the result is `bfd_reloc_other' the caller can continue with
51 performing the relocation. Otherwise it must stop and return the
52 value to its caller. */
54 static bfd_reloc_status_type
55 init_insn_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
56 PTR data, asection *input_section, bfd *output_bfd,
57 bfd_vma *prelocation, bfd_vma *pinsn)
60 reloc_howto_type *howto = reloc_entry->howto;
62 if (output_bfd != (bfd *) NULL
63 && (symbol->flags & BSF_SECTION_SYM) == 0
64 && (! howto->partial_inplace
65 || reloc_entry->addend == 0))
67 reloc_entry->address += input_section->output_offset;
71 /* This works because partial_inplace is FALSE. */
72 if (output_bfd != NULL)
73 return bfd_reloc_continue;
75 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
76 return bfd_reloc_outofrange;
78 relocation = (symbol->value
79 + symbol->section->output_section->vma
80 + symbol->section->output_offset);
81 relocation += reloc_entry->addend;
82 if (howto->pc_relative)
84 relocation -= (input_section->output_section->vma
85 + input_section->output_offset);
86 relocation -= reloc_entry->address;
89 *prelocation = relocation;
90 *pinsn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
91 return bfd_reloc_other;
94 /* For unsupported relocs. */
96 static bfd_reloc_status_type
97 sparc_elf_notsup_reloc (bfd *abfd ATTRIBUTE_UNUSED,
98 arelent *reloc_entry ATTRIBUTE_UNUSED,
99 asymbol *symbol ATTRIBUTE_UNUSED,
100 PTR data ATTRIBUTE_UNUSED,
101 asection *input_section ATTRIBUTE_UNUSED,
102 bfd *output_bfd ATTRIBUTE_UNUSED,
103 char **error_message ATTRIBUTE_UNUSED)
105 return bfd_reloc_notsupported;
108 /* Handle the WDISP16 reloc. */
110 static bfd_reloc_status_type
111 sparc_elf_wdisp16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
112 PTR data, asection *input_section, bfd *output_bfd,
113 char **error_message ATTRIBUTE_UNUSED)
117 bfd_reloc_status_type status;
119 status = init_insn_reloc (abfd, reloc_entry, symbol, data,
120 input_section, output_bfd, &relocation, &insn);
121 if (status != bfd_reloc_other)
124 insn &= ~ (bfd_vma) 0x303fff;
125 insn |= (((relocation >> 2) & 0xc000) << 6) | ((relocation >> 2) & 0x3fff);
126 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
128 if ((bfd_signed_vma) relocation < - 0x40000
129 || (bfd_signed_vma) relocation > 0x3ffff)
130 return bfd_reloc_overflow;
135 /* Handle the HIX22 reloc. */
137 static bfd_reloc_status_type
138 sparc_elf_hix22_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
139 PTR data, asection *input_section, bfd *output_bfd,
140 char **error_message ATTRIBUTE_UNUSED)
144 bfd_reloc_status_type status;
146 status = init_insn_reloc (abfd, reloc_entry, symbol, data,
147 input_section, output_bfd, &relocation, &insn);
148 if (status != bfd_reloc_other)
151 relocation ^= MINUS_ONE;
152 insn = (insn &~ (bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
153 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
155 if ((relocation & ~ (bfd_vma) 0xffffffff) != 0)
156 return bfd_reloc_overflow;
161 /* Handle the LOX10 reloc. */
163 static bfd_reloc_status_type
164 sparc_elf_lox10_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
165 PTR data, asection *input_section, bfd *output_bfd,
166 char **error_message ATTRIBUTE_UNUSED)
170 bfd_reloc_status_type status;
172 status = init_insn_reloc (abfd, reloc_entry, symbol, data,
173 input_section, output_bfd, &relocation, &insn);
174 if (status != bfd_reloc_other)
177 insn = (insn &~ (bfd_vma) 0x1fff) | 0x1c00 | (relocation & 0x3ff);
178 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
183 static reloc_howto_type _bfd_sparc_elf_howto_table[] =
185 HOWTO(R_SPARC_NONE, 0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", FALSE,0,0x00000000,TRUE),
186 HOWTO(R_SPARC_8, 0,0, 8,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_8", FALSE,0,0x000000ff,TRUE),
187 HOWTO(R_SPARC_16, 0,1,16,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_16", FALSE,0,0x0000ffff,TRUE),
188 HOWTO(R_SPARC_32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_32", FALSE,0,0xffffffff,TRUE),
189 HOWTO(R_SPARC_DISP8, 0,0, 8,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP8", FALSE,0,0x000000ff,TRUE),
190 HOWTO(R_SPARC_DISP16, 0,1,16,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP16", FALSE,0,0x0000ffff,TRUE),
191 HOWTO(R_SPARC_DISP32, 0,2,32,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP32", FALSE,0,0xffffffff,TRUE),
192 HOWTO(R_SPARC_WDISP30, 2,2,30,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP30", FALSE,0,0x3fffffff,TRUE),
193 HOWTO(R_SPARC_WDISP22, 2,2,22,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP22", FALSE,0,0x003fffff,TRUE),
194 HOWTO(R_SPARC_HI22, 10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_HI22", FALSE,0,0x003fffff,TRUE),
195 HOWTO(R_SPARC_22, 0,2,22,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_22", FALSE,0,0x003fffff,TRUE),
196 HOWTO(R_SPARC_13, 0,2,13,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_13", FALSE,0,0x00001fff,TRUE),
197 HOWTO(R_SPARC_LO10, 0,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_LO10", FALSE,0,0x000003ff,TRUE),
198 HOWTO(R_SPARC_GOT10, 0,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOT10", FALSE,0,0x000003ff,TRUE),
199 HOWTO(R_SPARC_GOT13, 0,2,13,FALSE,0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_GOT13", FALSE,0,0x00001fff,TRUE),
200 HOWTO(R_SPARC_GOT22, 10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOT22", FALSE,0,0x003fffff,TRUE),
201 HOWTO(R_SPARC_PC10, 0,2,10,TRUE, 0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_PC10", FALSE,0,0x000003ff,TRUE),
202 HOWTO(R_SPARC_PC22, 10,2,22,TRUE, 0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_PC22", FALSE,0,0x003fffff,TRUE),
203 HOWTO(R_SPARC_WPLT30, 2,2,30,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WPLT30", FALSE,0,0x3fffffff,TRUE),
204 HOWTO(R_SPARC_COPY, 0,0,00,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_COPY", FALSE,0,0x00000000,TRUE),
205 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),
206 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),
207 HOWTO(R_SPARC_RELATIVE, 0,0,00,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_RELATIVE",FALSE,0,0x00000000,TRUE),
208 HOWTO(R_SPARC_UA32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA32", FALSE,0,0xffffffff,TRUE),
209 HOWTO(R_SPARC_PLT32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_PLT32", FALSE,0,0xffffffff,TRUE),
210 HOWTO(R_SPARC_HIPLT22, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_HIPLT22", FALSE,0,0x00000000,TRUE),
211 HOWTO(R_SPARC_LOPLT10, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_LOPLT10", FALSE,0,0x00000000,TRUE),
212 HOWTO(R_SPARC_PCPLT32, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PCPLT32", FALSE,0,0x00000000,TRUE),
213 HOWTO(R_SPARC_PCPLT22, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PCPLT22", FALSE,0,0x00000000,TRUE),
214 HOWTO(R_SPARC_PCPLT10, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PCPLT10", FALSE,0,0x00000000,TRUE),
215 HOWTO(R_SPARC_10, 0,2,10,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_10", FALSE,0,0x000003ff,TRUE),
216 HOWTO(R_SPARC_11, 0,2,11,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_11", FALSE,0,0x000007ff,TRUE),
217 HOWTO(R_SPARC_64, 0,4,64,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_64", FALSE,0,MINUS_ONE, TRUE),
218 HOWTO(R_SPARC_OLO10, 0,2,13,FALSE,0,complain_overflow_signed, sparc_elf_notsup_reloc, "R_SPARC_OLO10", FALSE,0,0x00001fff,TRUE),
219 HOWTO(R_SPARC_HH22, 42,2,22,FALSE,0,complain_overflow_unsigned,bfd_elf_generic_reloc, "R_SPARC_HH22", FALSE,0,0x003fffff,TRUE),
220 HOWTO(R_SPARC_HM10, 32,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_HM10", FALSE,0,0x000003ff,TRUE),
221 HOWTO(R_SPARC_LM22, 10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_LM22", FALSE,0,0x003fffff,TRUE),
222 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),
223 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),
224 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),
225 HOWTO(R_SPARC_WDISP16, 2,2,16,TRUE, 0,complain_overflow_signed, sparc_elf_wdisp16_reloc,"R_SPARC_WDISP16", FALSE,0,0x00000000,TRUE),
226 HOWTO(R_SPARC_WDISP19, 2,2,19,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP19", FALSE,0,0x0007ffff,TRUE),
227 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),
228 HOWTO(R_SPARC_7, 0,2, 7,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_7", FALSE,0,0x0000007f,TRUE),
229 HOWTO(R_SPARC_5, 0,2, 5,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_5", FALSE,0,0x0000001f,TRUE),
230 HOWTO(R_SPARC_6, 0,2, 6,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_6", FALSE,0,0x0000003f,TRUE),
231 HOWTO(R_SPARC_DISP64, 0,4,64,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP64", FALSE,0,MINUS_ONE, TRUE),
232 HOWTO(R_SPARC_PLT64, 0,4,64,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_PLT64", FALSE,0,MINUS_ONE, TRUE),
233 HOWTO(R_SPARC_HIX22, 0,4, 0,FALSE,0,complain_overflow_bitfield,sparc_elf_hix22_reloc, "R_SPARC_HIX22", FALSE,0,MINUS_ONE, FALSE),
234 HOWTO(R_SPARC_LOX10, 0,4, 0,FALSE,0,complain_overflow_dont, sparc_elf_lox10_reloc, "R_SPARC_LOX10", FALSE,0,MINUS_ONE, FALSE),
235 HOWTO(R_SPARC_H44, 22,2,22,FALSE,0,complain_overflow_unsigned,bfd_elf_generic_reloc, "R_SPARC_H44", FALSE,0,0x003fffff,FALSE),
236 HOWTO(R_SPARC_M44, 12,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_M44", FALSE,0,0x000003ff,FALSE),
237 HOWTO(R_SPARC_L44, 0,2,13,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_L44", FALSE,0,0x00000fff,FALSE),
238 HOWTO(R_SPARC_REGISTER, 0,4, 0,FALSE,0,complain_overflow_bitfield,sparc_elf_notsup_reloc, "R_SPARC_REGISTER",FALSE,0,MINUS_ONE, FALSE),
239 HOWTO(R_SPARC_UA64, 0,4,64,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA64", FALSE,0,MINUS_ONE, TRUE),
240 HOWTO(R_SPARC_UA16, 0,1,16,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA16", FALSE,0,0x0000ffff,TRUE),
241 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),
242 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),
243 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),
244 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),
245 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),
246 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),
247 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),
248 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),
249 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),
250 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),
251 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),
252 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),
253 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),
254 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),
255 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),
256 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),
257 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),
258 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),
259 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),
260 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),
261 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),
262 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),
263 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),
264 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),
265 HOWTO(R_SPARC_GOTDATA_HIX22,0,2,0,FALSE,0,complain_overflow_bitfield,sparc_elf_hix22_reloc,"R_SPARC_GOTDATA_HIX22",FALSE,0,0x003fffff, FALSE),
266 HOWTO(R_SPARC_GOTDATA_LOX10,0,2,0,FALSE,0,complain_overflow_dont, sparc_elf_lox10_reloc, "R_SPARC_GOTDATA_LOX10",FALSE,0,0x000003ff, FALSE),
267 HOWTO(R_SPARC_GOTDATA_OP_HIX22,0,2,0,FALSE,0,complain_overflow_bitfield,sparc_elf_hix22_reloc,"R_SPARC_GOTDATA_OP_HIX22",FALSE,0,0x003fffff, FALSE),
268 HOWTO(R_SPARC_GOTDATA_OP_LOX10,0,2,0,FALSE,0,complain_overflow_dont, sparc_elf_lox10_reloc, "R_SPARC_GOTDATA_OP_LOX10",FALSE,0,0x000003ff, FALSE),
269 HOWTO(R_SPARC_GOTDATA_OP,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOTDATA_OP",FALSE,0,0x00000000,TRUE),
271 static reloc_howto_type sparc_jmp_irel_howto =
272 HOWTO(R_SPARC_JMP_IREL, 0,0,00,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_JMP_IREL",FALSE,0,0x00000000,TRUE);
273 static reloc_howto_type sparc_irelative_howto =
274 HOWTO(R_SPARC_IRELATIVE, 0,0,00,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_IRELATIVE",FALSE,0,0x00000000,TRUE);
275 static reloc_howto_type sparc_vtinherit_howto =
276 HOWTO (R_SPARC_GNU_VTINHERIT, 0,2,0,FALSE,0,complain_overflow_dont, NULL, "R_SPARC_GNU_VTINHERIT", FALSE,0, 0, FALSE);
277 static reloc_howto_type sparc_vtentry_howto =
278 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);
279 static reloc_howto_type sparc_rev32_howto =
280 HOWTO(R_SPARC_REV32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_REV32", FALSE,0,0xffffffff,TRUE);
283 _bfd_sparc_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
284 bfd_reloc_code_real_type code)
286 /* We explicitly handle each relocation type in the switch
287 instead of using a lookup table for efficiency. */
291 return &_bfd_sparc_elf_howto_table[R_SPARC_NONE];
294 return &_bfd_sparc_elf_howto_table[R_SPARC_8];
297 return &_bfd_sparc_elf_howto_table[R_SPARC_16];
300 return &_bfd_sparc_elf_howto_table[R_SPARC_32];
302 case BFD_RELOC_8_PCREL:
303 return &_bfd_sparc_elf_howto_table[R_SPARC_DISP8];
305 case BFD_RELOC_16_PCREL:
306 return &_bfd_sparc_elf_howto_table[R_SPARC_DISP16];
308 case BFD_RELOC_32_PCREL:
309 return &_bfd_sparc_elf_howto_table[R_SPARC_DISP32];
311 case BFD_RELOC_32_PCREL_S2:
312 return &_bfd_sparc_elf_howto_table[R_SPARC_WDISP30];
314 case BFD_RELOC_SPARC_WDISP22:
315 return &_bfd_sparc_elf_howto_table[R_SPARC_WDISP22];
318 return &_bfd_sparc_elf_howto_table[R_SPARC_HI22];
320 case BFD_RELOC_SPARC22:
321 return &_bfd_sparc_elf_howto_table[R_SPARC_22];
323 case BFD_RELOC_SPARC13:
324 return &_bfd_sparc_elf_howto_table[R_SPARC_13];
327 return &_bfd_sparc_elf_howto_table[R_SPARC_LO10];
329 case BFD_RELOC_SPARC_GOT10:
330 return &_bfd_sparc_elf_howto_table[R_SPARC_GOT10];
332 case BFD_RELOC_SPARC_GOT13:
333 return &_bfd_sparc_elf_howto_table[R_SPARC_GOT13];
335 case BFD_RELOC_SPARC_GOT22:
336 return &_bfd_sparc_elf_howto_table[R_SPARC_GOT22];
338 case BFD_RELOC_SPARC_PC10:
339 return &_bfd_sparc_elf_howto_table[R_SPARC_PC10];
341 case BFD_RELOC_SPARC_PC22:
342 return &_bfd_sparc_elf_howto_table[R_SPARC_PC22];
344 case BFD_RELOC_SPARC_WPLT30:
345 return &_bfd_sparc_elf_howto_table[R_SPARC_WPLT30];
347 case BFD_RELOC_SPARC_COPY:
348 return &_bfd_sparc_elf_howto_table[R_SPARC_COPY];
350 case BFD_RELOC_SPARC_GLOB_DAT:
351 return &_bfd_sparc_elf_howto_table[R_SPARC_GLOB_DAT];
353 case BFD_RELOC_SPARC_JMP_SLOT:
354 return &_bfd_sparc_elf_howto_table[R_SPARC_JMP_SLOT];
356 case BFD_RELOC_SPARC_RELATIVE:
357 return &_bfd_sparc_elf_howto_table[R_SPARC_RELATIVE];
359 case BFD_RELOC_SPARC_UA32:
360 return &_bfd_sparc_elf_howto_table[R_SPARC_UA32];
362 case BFD_RELOC_SPARC_PLT32:
363 return &_bfd_sparc_elf_howto_table[R_SPARC_PLT32];
365 case BFD_RELOC_SPARC_10:
366 return &_bfd_sparc_elf_howto_table[R_SPARC_10];
368 case BFD_RELOC_SPARC_11:
369 return &_bfd_sparc_elf_howto_table[R_SPARC_11];
371 case BFD_RELOC_SPARC_64:
372 return &_bfd_sparc_elf_howto_table[R_SPARC_64];
374 case BFD_RELOC_SPARC_OLO10:
375 return &_bfd_sparc_elf_howto_table[R_SPARC_OLO10];
377 case BFD_RELOC_SPARC_HH22:
378 return &_bfd_sparc_elf_howto_table[R_SPARC_HH22];
380 case BFD_RELOC_SPARC_HM10:
381 return &_bfd_sparc_elf_howto_table[R_SPARC_HM10];
383 case BFD_RELOC_SPARC_LM22:
384 return &_bfd_sparc_elf_howto_table[R_SPARC_LM22];
386 case BFD_RELOC_SPARC_PC_HH22:
387 return &_bfd_sparc_elf_howto_table[R_SPARC_PC_HH22];
389 case BFD_RELOC_SPARC_PC_HM10:
390 return &_bfd_sparc_elf_howto_table[R_SPARC_PC_HM10];
392 case BFD_RELOC_SPARC_PC_LM22:
393 return &_bfd_sparc_elf_howto_table[R_SPARC_PC_LM22];
395 case BFD_RELOC_SPARC_WDISP16:
396 return &_bfd_sparc_elf_howto_table[R_SPARC_WDISP16];
398 case BFD_RELOC_SPARC_WDISP19:
399 return &_bfd_sparc_elf_howto_table[R_SPARC_WDISP19];
401 case BFD_RELOC_SPARC_7:
402 return &_bfd_sparc_elf_howto_table[R_SPARC_7];
404 case BFD_RELOC_SPARC_5:
405 return &_bfd_sparc_elf_howto_table[R_SPARC_5];
407 case BFD_RELOC_SPARC_6:
408 return &_bfd_sparc_elf_howto_table[R_SPARC_6];
410 case BFD_RELOC_SPARC_DISP64:
411 return &_bfd_sparc_elf_howto_table[R_SPARC_DISP64];
413 case BFD_RELOC_SPARC_PLT64:
414 return &_bfd_sparc_elf_howto_table[R_SPARC_PLT64];
416 case BFD_RELOC_SPARC_HIX22:
417 return &_bfd_sparc_elf_howto_table[R_SPARC_HIX22];
419 case BFD_RELOC_SPARC_LOX10:
420 return &_bfd_sparc_elf_howto_table[R_SPARC_LOX10];
422 case BFD_RELOC_SPARC_H44:
423 return &_bfd_sparc_elf_howto_table[R_SPARC_H44];
425 case BFD_RELOC_SPARC_M44:
426 return &_bfd_sparc_elf_howto_table[R_SPARC_M44];
428 case BFD_RELOC_SPARC_L44:
429 return &_bfd_sparc_elf_howto_table[R_SPARC_L44];
431 case BFD_RELOC_SPARC_REGISTER:
432 return &_bfd_sparc_elf_howto_table[R_SPARC_REGISTER];
434 case BFD_RELOC_SPARC_UA64:
435 return &_bfd_sparc_elf_howto_table[R_SPARC_UA64];
437 case BFD_RELOC_SPARC_UA16:
438 return &_bfd_sparc_elf_howto_table[R_SPARC_UA16];
440 case BFD_RELOC_SPARC_TLS_GD_HI22:
441 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_GD_HI22];
443 case BFD_RELOC_SPARC_TLS_GD_LO10:
444 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_GD_LO10];
446 case BFD_RELOC_SPARC_TLS_GD_ADD:
447 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_GD_ADD];
449 case BFD_RELOC_SPARC_TLS_GD_CALL:
450 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_GD_CALL];
452 case BFD_RELOC_SPARC_TLS_LDM_HI22:
453 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDM_HI22];
455 case BFD_RELOC_SPARC_TLS_LDM_LO10:
456 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDM_LO10];
458 case BFD_RELOC_SPARC_TLS_LDM_ADD:
459 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDM_ADD];
461 case BFD_RELOC_SPARC_TLS_LDM_CALL:
462 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDM_CALL];
464 case BFD_RELOC_SPARC_TLS_LDO_HIX22:
465 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDO_HIX22];
467 case BFD_RELOC_SPARC_TLS_LDO_LOX10:
468 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDO_LOX10];
470 case BFD_RELOC_SPARC_TLS_LDO_ADD:
471 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDO_ADD];
473 case BFD_RELOC_SPARC_TLS_IE_HI22:
474 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_IE_HI22];
476 case BFD_RELOC_SPARC_TLS_IE_LO10:
477 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_IE_LO10];
479 case BFD_RELOC_SPARC_TLS_IE_LD:
480 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_IE_LD];
482 case BFD_RELOC_SPARC_TLS_IE_LDX:
483 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_IE_LDX];
485 case BFD_RELOC_SPARC_TLS_IE_ADD:
486 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_IE_ADD];
488 case BFD_RELOC_SPARC_TLS_LE_HIX22:
489 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LE_HIX22];
491 case BFD_RELOC_SPARC_TLS_LE_LOX10:
492 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LE_LOX10];
494 case BFD_RELOC_SPARC_TLS_DTPMOD32:
495 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_DTPMOD32];
497 case BFD_RELOC_SPARC_TLS_DTPMOD64:
498 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_DTPMOD64];
500 case BFD_RELOC_SPARC_TLS_DTPOFF32:
501 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_DTPOFF32];
503 case BFD_RELOC_SPARC_TLS_DTPOFF64:
504 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_DTPOFF64];
506 case BFD_RELOC_SPARC_TLS_TPOFF32:
507 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_TPOFF32];
509 case BFD_RELOC_SPARC_TLS_TPOFF64:
510 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_TPOFF64];
512 case BFD_RELOC_SPARC_GOTDATA_HIX22:
513 return &_bfd_sparc_elf_howto_table[R_SPARC_GOTDATA_HIX22];
515 case BFD_RELOC_SPARC_GOTDATA_LOX10:
516 return &_bfd_sparc_elf_howto_table[R_SPARC_GOTDATA_LOX10];
518 case BFD_RELOC_SPARC_GOTDATA_OP_HIX22:
519 return &_bfd_sparc_elf_howto_table[R_SPARC_GOTDATA_OP_HIX22];
521 case BFD_RELOC_SPARC_GOTDATA_OP_LOX10:
522 return &_bfd_sparc_elf_howto_table[R_SPARC_GOTDATA_OP_LOX10];
524 case BFD_RELOC_SPARC_GOTDATA_OP:
525 return &_bfd_sparc_elf_howto_table[R_SPARC_GOTDATA_OP];
527 case BFD_RELOC_SPARC_JMP_IREL:
528 return &sparc_jmp_irel_howto;
530 case BFD_RELOC_SPARC_IRELATIVE:
531 return &sparc_irelative_howto;
533 case BFD_RELOC_VTABLE_INHERIT:
534 return &sparc_vtinherit_howto;
536 case BFD_RELOC_VTABLE_ENTRY:
537 return &sparc_vtentry_howto;
539 case BFD_RELOC_SPARC_REV32:
540 return &sparc_rev32_howto;
545 bfd_set_error (bfd_error_bad_value);
550 _bfd_sparc_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
556 i < (sizeof (_bfd_sparc_elf_howto_table)
557 / sizeof (_bfd_sparc_elf_howto_table[0]));
559 if (_bfd_sparc_elf_howto_table[i].name != NULL
560 && strcasecmp (_bfd_sparc_elf_howto_table[i].name, r_name) == 0)
561 return &_bfd_sparc_elf_howto_table[i];
563 if (strcasecmp (sparc_vtinherit_howto.name, r_name) == 0)
564 return &sparc_vtinherit_howto;
565 if (strcasecmp (sparc_vtentry_howto.name, r_name) == 0)
566 return &sparc_vtentry_howto;
567 if (strcasecmp (sparc_rev32_howto.name, r_name) == 0)
568 return &sparc_rev32_howto;
574 _bfd_sparc_elf_info_to_howto_ptr (unsigned int r_type)
578 case R_SPARC_JMP_IREL:
579 return &sparc_jmp_irel_howto;
581 case R_SPARC_IRELATIVE:
582 return &sparc_irelative_howto;
584 case R_SPARC_GNU_VTINHERIT:
585 return &sparc_vtinherit_howto;
587 case R_SPARC_GNU_VTENTRY:
588 return &sparc_vtentry_howto;
591 return &sparc_rev32_howto;
594 if (r_type >= (unsigned int) R_SPARC_max_std)
596 (*_bfd_error_handler) (_("invalid relocation type %d"),
598 r_type = R_SPARC_NONE;
600 return &_bfd_sparc_elf_howto_table[r_type];
604 /* Both 32-bit and 64-bit sparc encode this in an identical manner,
605 so just take advantage of that. */
606 #define SPARC_ELF_R_TYPE(r_info) \
610 _bfd_sparc_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
611 Elf_Internal_Rela *dst)
613 unsigned int r_type = SPARC_ELF_R_TYPE (dst->r_info);
615 cache_ptr->howto = _bfd_sparc_elf_info_to_howto_ptr (r_type);
619 /* The nop opcode we use. */
620 #define SPARC_NOP 0x01000000
622 #define SPARC_INSN_BYTES 4
624 /* The SPARC linker needs to keep track of the number of relocs that it
625 decides to copy as dynamic relocs in check_relocs for each symbol.
626 This is so that it can later discard them if they are found to be
627 unnecessary. We store the information in a field extending the
628 regular ELF linker hash table. */
630 struct _bfd_sparc_elf_dyn_relocs
632 struct _bfd_sparc_elf_dyn_relocs *next;
634 /* The input section of the reloc. */
637 /* Total number of relocs copied for the input section. */
640 /* Number of pc-relative relocs copied for the input section. */
641 bfd_size_type pc_count;
644 /* SPARC ELF linker hash entry. */
646 struct _bfd_sparc_elf_link_hash_entry
648 struct elf_link_hash_entry elf;
650 /* Track dynamic relocs copied for this symbol. */
651 struct _bfd_sparc_elf_dyn_relocs *dyn_relocs;
653 #define GOT_UNKNOWN 0
657 unsigned char tls_type;
660 #define _bfd_sparc_elf_hash_entry(ent) ((struct _bfd_sparc_elf_link_hash_entry *)(ent))
662 struct _bfd_sparc_elf_obj_tdata
664 struct elf_obj_tdata root;
666 /* tls_type for each local got entry. */
667 char *local_got_tls_type;
669 /* TRUE if TLS GD relocs has been seen for this object. */
670 bfd_boolean has_tlsgd;
673 #define _bfd_sparc_elf_tdata(abfd) \
674 ((struct _bfd_sparc_elf_obj_tdata *) (abfd)->tdata.any)
676 #define _bfd_sparc_elf_local_got_tls_type(abfd) \
677 (_bfd_sparc_elf_tdata (abfd)->local_got_tls_type)
679 #define is_sparc_elf(bfd) \
680 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
681 && elf_tdata (bfd) != NULL \
682 && elf_object_id (bfd) == SPARC_ELF_DATA)
685 _bfd_sparc_elf_mkobject (bfd *abfd)
687 return bfd_elf_allocate_object (abfd, sizeof (struct _bfd_sparc_elf_obj_tdata),
692 sparc_put_word_32 (bfd *abfd, bfd_vma val, void *ptr)
694 bfd_put_32 (abfd, val, ptr);
698 sparc_put_word_64 (bfd *abfd, bfd_vma val, void *ptr)
700 bfd_put_64 (abfd, val, ptr);
704 sparc_elf_append_rela (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
706 const struct elf_backend_data *bed;
709 bed = get_elf_backend_data (abfd);
710 loc = s->contents + (s->reloc_count++ * bed->s->sizeof_rela);
711 bed->s->swap_reloca_out (abfd, rel, loc);
715 sparc_elf_r_info_64 (Elf_Internal_Rela *in_rel ATTRIBUTE_UNUSED,
716 bfd_vma rel_index ATTRIBUTE_UNUSED,
717 bfd_vma type ATTRIBUTE_UNUSED)
719 return ELF64_R_INFO (rel_index,
721 ELF64_R_TYPE_INFO (ELF64_R_TYPE_DATA (in_rel->r_info),
726 sparc_elf_r_info_32 (Elf_Internal_Rela *in_rel ATTRIBUTE_UNUSED,
727 bfd_vma rel_index, bfd_vma type)
729 return ELF32_R_INFO (rel_index, type);
733 sparc_elf_r_symndx_64 (bfd_vma r_info)
735 bfd_vma r_symndx = ELF32_R_SYM (r_info);
736 return (r_symndx >> 24);
740 sparc_elf_r_symndx_32 (bfd_vma r_info)
742 return ELF32_R_SYM (r_info);
747 #define PLT32_ENTRY_SIZE 12
748 #define PLT32_HEADER_SIZE (4 * PLT32_ENTRY_SIZE)
750 /* The first four entries in a 32-bit procedure linkage table are reserved,
751 and the initial contents are unimportant (we zero them out).
752 Subsequent entries look like this. See the SVR4 ABI SPARC
753 supplement to see how this works. */
755 /* sethi %hi(.-.plt0),%g1. We fill in the address later. */
756 #define PLT32_ENTRY_WORD0 0x03000000
757 /* b,a .plt0. We fill in the offset later. */
758 #define PLT32_ENTRY_WORD1 0x30800000
760 #define PLT32_ENTRY_WORD2 SPARC_NOP
763 sparc32_plt_entry_build (bfd *output_bfd, asection *splt, bfd_vma offset,
764 bfd_vma max ATTRIBUTE_UNUSED,
767 bfd_put_32 (output_bfd,
768 PLT32_ENTRY_WORD0 + offset,
769 splt->contents + offset);
770 bfd_put_32 (output_bfd,
772 + (((- (offset + 4)) >> 2) & 0x3fffff)),
773 splt->contents + offset + 4);
774 bfd_put_32 (output_bfd, (bfd_vma) PLT32_ENTRY_WORD2,
775 splt->contents + offset + 8);
779 return offset / PLT32_ENTRY_SIZE - 4;
782 /* Both the headers and the entries are icache aligned. */
783 #define PLT64_ENTRY_SIZE 32
784 #define PLT64_HEADER_SIZE (4 * PLT64_ENTRY_SIZE)
785 #define PLT64_LARGE_THRESHOLD 32768
788 sparc64_plt_entry_build (bfd *output_bfd, asection *splt, bfd_vma offset,
789 bfd_vma max, bfd_vma *r_offset)
791 unsigned char *entry = splt->contents + offset;
792 const unsigned int nop = SPARC_NOP;
795 if (offset < (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE))
797 unsigned int sethi, ba;
801 plt_index = (offset / PLT64_ENTRY_SIZE);
803 sethi = 0x03000000 | (plt_index * PLT64_ENTRY_SIZE);
805 | (((splt->contents + PLT64_ENTRY_SIZE) - (entry + 4)) / 4 & 0x7ffff);
807 bfd_put_32 (output_bfd, (bfd_vma) sethi, entry);
808 bfd_put_32 (output_bfd, (bfd_vma) ba, entry + 4);
809 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 8);
810 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 12);
811 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 16);
812 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 20);
813 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 24);
814 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 28);
820 int block, last_block, ofs, last_ofs, chunks_this_block;
821 const int insn_chunk_size = (6 * 4);
822 const int ptr_chunk_size = (1 * 8);
823 const int entries_per_block = 160;
824 const int block_size = entries_per_block * (insn_chunk_size
827 /* Entries 32768 and higher are grouped into blocks of 160.
828 The blocks are further subdivided into 160 sequences of
829 6 instructions and 160 pointers. If a block does not require
830 the full 160 entries, let's say it requires N, then there
831 will be N sequences of 6 instructions and N pointers. */
833 offset -= (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE);
834 max -= (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE);
836 block = offset / block_size;
837 last_block = max / block_size;
838 if (block != last_block)
840 chunks_this_block = 160;
844 last_ofs = max % block_size;
845 chunks_this_block = last_ofs / (insn_chunk_size + ptr_chunk_size);
848 ofs = offset % block_size;
850 plt_index = (PLT64_LARGE_THRESHOLD +
852 (ofs / insn_chunk_size));
855 + (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE)
856 + (block * block_size)
857 + (chunks_this_block * insn_chunk_size)
858 + (ofs / insn_chunk_size) * ptr_chunk_size;
860 *r_offset = (bfd_vma) (ptr - splt->contents);
862 ldx = 0xc25be000 | ((ptr - (entry+4)) & 0x1fff);
870 bfd_put_32 (output_bfd, (bfd_vma) 0x8a10000f, entry);
871 bfd_put_32 (output_bfd, (bfd_vma) 0x40000002, entry + 4);
872 bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP, entry + 8);
873 bfd_put_32 (output_bfd, (bfd_vma) ldx, entry + 12);
874 bfd_put_32 (output_bfd, (bfd_vma) 0x83c3c001, entry + 16);
875 bfd_put_32 (output_bfd, (bfd_vma) 0x9e100005, entry + 20);
877 bfd_put_64 (output_bfd, (bfd_vma) (splt->contents - (entry + 4)), ptr);
880 return plt_index - 4;
883 /* The format of the first PLT entry in a VxWorks executable. */
884 static const bfd_vma sparc_vxworks_exec_plt0_entry[] =
886 0x05000000, /* sethi %hi(_GLOBAL_OFFSET_TABLE_+8), %g2 */
887 0x8410a000, /* or %g2, %lo(_GLOBAL_OFFSET_TABLE_+8), %g2 */
888 0xc4008000, /* ld [ %g2 ], %g2 */
889 0x81c08000, /* jmp %g2 */
893 /* The format of subsequent PLT entries. */
894 static const bfd_vma sparc_vxworks_exec_plt_entry[] =
896 0x03000000, /* sethi %hi(_GLOBAL_OFFSET_TABLE_+f@got), %g1 */
897 0x82106000, /* or %g1, %lo(_GLOBAL_OFFSET_TABLE_+f@got), %g1 */
898 0xc2004000, /* ld [ %g1 ], %g1 */
899 0x81c04000, /* jmp %g1 */
900 0x01000000, /* nop */
901 0x03000000, /* sethi %hi(f@pltindex), %g1 */
902 0x10800000, /* b _PLT_resolve */
903 0x82106000 /* or %g1, %lo(f@pltindex), %g1 */
906 /* The format of the first PLT entry in a VxWorks shared object. */
907 static const bfd_vma sparc_vxworks_shared_plt0_entry[] =
909 0xc405e008, /* ld [ %l7 + 8 ], %g2 */
910 0x81c08000, /* jmp %g2 */
914 /* The format of subsequent PLT entries. */
915 static const bfd_vma sparc_vxworks_shared_plt_entry[] =
917 0x03000000, /* sethi %hi(f@got), %g1 */
918 0x82106000, /* or %g1, %lo(f@got), %g1 */
919 0xc205c001, /* ld [ %l7 + %g1 ], %g1 */
920 0x81c04000, /* jmp %g1 */
921 0x01000000, /* nop */
922 0x03000000, /* sethi %hi(f@pltindex), %g1 */
923 0x10800000, /* b _PLT_resolve */
924 0x82106000 /* or %g1, %lo(f@pltindex), %g1 */
927 #define SPARC_ELF_PUT_WORD(htab, bfd, val, ptr) \
928 htab->put_word(bfd, val, ptr)
930 #define SPARC_ELF_R_INFO(htab, in_rel, index, type) \
931 htab->r_info(in_rel, index, type)
933 #define SPARC_ELF_R_SYMNDX(htab, r_info) \
934 htab->r_symndx(r_info)
936 #define SPARC_ELF_WORD_BYTES(htab) \
939 #define SPARC_ELF_RELA_BYTES(htab) \
942 #define SPARC_ELF_DTPOFF_RELOC(htab) \
945 #define SPARC_ELF_DTPMOD_RELOC(htab) \
948 #define SPARC_ELF_TPOFF_RELOC(htab) \
951 #define SPARC_ELF_BUILD_PLT_ENTRY(htab, obfd, splt, off, max, r_off) \
952 htab->build_plt_entry (obfd, splt, off, max, r_off)
954 /* Create an entry in an SPARC ELF linker hash table. */
956 static struct bfd_hash_entry *
957 link_hash_newfunc (struct bfd_hash_entry *entry,
958 struct bfd_hash_table *table, const char *string)
960 /* Allocate the structure if it has not already been allocated by a
964 entry = bfd_hash_allocate (table,
965 sizeof (struct _bfd_sparc_elf_link_hash_entry));
970 /* Call the allocation method of the superclass. */
971 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
974 struct _bfd_sparc_elf_link_hash_entry *eh;
976 eh = (struct _bfd_sparc_elf_link_hash_entry *) entry;
977 eh->dyn_relocs = NULL;
978 eh->tls_type = GOT_UNKNOWN;
984 /* The name of the dynamic interpreter. This is put in the .interp
987 #define ELF32_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
988 #define ELF64_DYNAMIC_INTERPRETER "/usr/lib/sparcv9/ld.so.1"
990 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
991 for local symbol so that we can handle local STT_GNU_IFUNC symbols
992 as global symbol. We reuse indx and dynstr_index for local symbol
993 hash since they aren't used by global symbols in this backend. */
996 elf_sparc_local_htab_hash (const void *ptr)
998 struct elf_link_hash_entry *h
999 = (struct elf_link_hash_entry *) ptr;
1000 return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);
1003 /* Compare local hash entries. */
1006 elf_sparc_local_htab_eq (const void *ptr1, const void *ptr2)
1008 struct elf_link_hash_entry *h1
1009 = (struct elf_link_hash_entry *) ptr1;
1010 struct elf_link_hash_entry *h2
1011 = (struct elf_link_hash_entry *) ptr2;
1013 return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
1016 /* Find and/or create a hash entry for local symbol. */
1018 static struct elf_link_hash_entry *
1019 elf_sparc_get_local_sym_hash (struct _bfd_sparc_elf_link_hash_table *htab,
1020 bfd *abfd, const Elf_Internal_Rela *rel,
1023 struct _bfd_sparc_elf_link_hash_entry e, *ret;
1024 asection *sec = abfd->sections;
1025 unsigned long r_symndx;
1029 r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
1030 h = ELF_LOCAL_SYMBOL_HASH (sec->id, r_symndx);
1032 e.elf.indx = sec->id;
1033 e.elf.dynstr_index = r_symndx;
1034 slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,
1035 create ? INSERT : NO_INSERT);
1042 ret = (struct _bfd_sparc_elf_link_hash_entry *) *slot;
1046 ret = (struct _bfd_sparc_elf_link_hash_entry *)
1047 objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,
1048 sizeof (struct _bfd_sparc_elf_link_hash_entry));
1051 memset (ret, 0, sizeof (*ret));
1052 ret->elf.indx = sec->id;
1053 ret->elf.dynstr_index = r_symndx;
1054 ret->elf.dynindx = -1;
1055 ret->elf.plt.offset = (bfd_vma) -1;
1056 ret->elf.got.offset = (bfd_vma) -1;
1062 /* Create a SPARC ELF linker hash table. */
1064 struct bfd_link_hash_table *
1065 _bfd_sparc_elf_link_hash_table_create (bfd *abfd)
1067 struct _bfd_sparc_elf_link_hash_table *ret;
1068 bfd_size_type amt = sizeof (struct _bfd_sparc_elf_link_hash_table);
1070 ret = (struct _bfd_sparc_elf_link_hash_table *) bfd_zmalloc (amt);
1074 if (ABI_64_P (abfd))
1076 ret->put_word = sparc_put_word_64;
1077 ret->r_info = sparc_elf_r_info_64;
1078 ret->r_symndx = sparc_elf_r_symndx_64;
1079 ret->dtpoff_reloc = R_SPARC_TLS_DTPOFF64;
1080 ret->dtpmod_reloc = R_SPARC_TLS_DTPMOD64;
1081 ret->tpoff_reloc = R_SPARC_TLS_TPOFF64;
1082 ret->word_align_power = 3;
1083 ret->align_power_max = 4;
1084 ret->bytes_per_word = 8;
1085 ret->bytes_per_rela = sizeof (Elf64_External_Rela);
1086 ret->dynamic_interpreter = ELF64_DYNAMIC_INTERPRETER;
1087 ret->dynamic_interpreter_size = sizeof ELF64_DYNAMIC_INTERPRETER;
1089 ret->build_plt_entry = sparc64_plt_entry_build;
1090 ret->plt_header_size = PLT64_HEADER_SIZE;
1091 ret->plt_entry_size = PLT64_ENTRY_SIZE;
1095 ret->put_word = sparc_put_word_32;
1096 ret->r_info = sparc_elf_r_info_32;
1097 ret->r_symndx = sparc_elf_r_symndx_32;
1098 ret->dtpoff_reloc = R_SPARC_TLS_DTPOFF32;
1099 ret->dtpmod_reloc = R_SPARC_TLS_DTPMOD32;
1100 ret->tpoff_reloc = R_SPARC_TLS_TPOFF32;
1101 ret->word_align_power = 2;
1102 ret->align_power_max = 3;
1103 ret->bytes_per_word = 4;
1104 ret->bytes_per_rela = sizeof (Elf32_External_Rela);
1105 ret->dynamic_interpreter = ELF32_DYNAMIC_INTERPRETER;
1106 ret->dynamic_interpreter_size = sizeof ELF32_DYNAMIC_INTERPRETER;
1108 ret->build_plt_entry = sparc32_plt_entry_build;
1109 ret->plt_header_size = PLT32_HEADER_SIZE;
1110 ret->plt_entry_size = PLT32_ENTRY_SIZE;
1113 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc,
1114 sizeof (struct _bfd_sparc_elf_link_hash_entry),
1121 ret->loc_hash_table = htab_try_create (1024,
1122 elf_sparc_local_htab_hash,
1123 elf_sparc_local_htab_eq,
1125 ret->loc_hash_memory = objalloc_create ();
1126 if (!ret->loc_hash_table || !ret->loc_hash_memory)
1132 return &ret->elf.root;
1135 /* Destroy a SPARC ELF linker hash table. */
1138 _bfd_sparc_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
1140 struct _bfd_sparc_elf_link_hash_table *htab
1141 = (struct _bfd_sparc_elf_link_hash_table *) hash;
1143 if (htab->loc_hash_table)
1144 htab_delete (htab->loc_hash_table);
1145 if (htab->loc_hash_memory)
1146 objalloc_free ((struct objalloc *) htab->loc_hash_memory);
1147 _bfd_generic_link_hash_table_free (hash);
1150 /* Create .plt, .rela.plt, .got, .rela.got, .dynbss, and
1151 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
1155 _bfd_sparc_elf_create_dynamic_sections (bfd *dynobj,
1156 struct bfd_link_info *info)
1158 struct _bfd_sparc_elf_link_hash_table *htab;
1160 htab = _bfd_sparc_elf_hash_table (info);
1161 BFD_ASSERT (htab != NULL);
1163 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
1166 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
1168 htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss");
1170 if (htab->is_vxworks)
1172 if (!elf_vxworks_create_dynamic_sections (dynobj, info, &htab->srelplt2))
1176 htab->plt_header_size
1177 = 4 * ARRAY_SIZE (sparc_vxworks_shared_plt0_entry);
1178 htab->plt_entry_size
1179 = 4 * ARRAY_SIZE (sparc_vxworks_shared_plt_entry);
1183 htab->plt_header_size
1184 = 4 * ARRAY_SIZE (sparc_vxworks_exec_plt0_entry);
1185 htab->plt_entry_size
1186 = 4 * ARRAY_SIZE (sparc_vxworks_exec_plt_entry);
1190 if (!htab->elf.splt || !htab->elf.srelplt || !htab->sdynbss
1191 || (!info->shared && !htab->srelbss))
1198 create_ifunc_sections (bfd *abfd, struct bfd_link_info *info)
1200 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1201 struct elf_link_hash_table *htab = elf_hash_table (info);
1202 flagword flags, pltflags;
1205 if (htab->irelifunc != NULL || htab->iplt != NULL)
1208 flags = bed->dynamic_sec_flags;
1209 pltflags = flags | SEC_ALLOC | SEC_CODE | SEC_LOAD;
1211 s = bfd_make_section_with_flags (abfd, ".iplt", pltflags);
1213 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
1217 s = bfd_make_section_with_flags (abfd, ".rela.iplt",
1218 flags | SEC_READONLY);
1220 || ! bfd_set_section_alignment (abfd, s,
1221 bed->s->log_file_align))
1228 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1231 _bfd_sparc_elf_copy_indirect_symbol (struct bfd_link_info *info,
1232 struct elf_link_hash_entry *dir,
1233 struct elf_link_hash_entry *ind)
1235 struct _bfd_sparc_elf_link_hash_entry *edir, *eind;
1237 edir = (struct _bfd_sparc_elf_link_hash_entry *) dir;
1238 eind = (struct _bfd_sparc_elf_link_hash_entry *) ind;
1240 if (eind->dyn_relocs != NULL)
1242 if (edir->dyn_relocs != NULL)
1244 struct _bfd_sparc_elf_dyn_relocs **pp;
1245 struct _bfd_sparc_elf_dyn_relocs *p;
1247 /* Add reloc counts against the indirect sym to the direct sym
1248 list. Merge any entries against the same section. */
1249 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1251 struct _bfd_sparc_elf_dyn_relocs *q;
1253 for (q = edir->dyn_relocs; q != NULL; q = q->next)
1254 if (q->sec == p->sec)
1256 q->pc_count += p->pc_count;
1257 q->count += p->count;
1264 *pp = edir->dyn_relocs;
1267 edir->dyn_relocs = eind->dyn_relocs;
1268 eind->dyn_relocs = NULL;
1271 if (ind->root.type == bfd_link_hash_indirect
1272 && dir->got.refcount <= 0)
1274 edir->tls_type = eind->tls_type;
1275 eind->tls_type = GOT_UNKNOWN;
1277 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1281 sparc_elf_tls_transition (struct bfd_link_info *info, bfd *abfd,
1282 int r_type, int is_local)
1284 if (! ABI_64_P (abfd)
1285 && r_type == R_SPARC_TLS_GD_HI22
1286 && ! _bfd_sparc_elf_tdata (abfd)->has_tlsgd)
1287 r_type = R_SPARC_REV32;
1294 case R_SPARC_TLS_GD_HI22:
1296 return R_SPARC_TLS_LE_HIX22;
1297 return R_SPARC_TLS_IE_HI22;
1298 case R_SPARC_TLS_GD_LO10:
1300 return R_SPARC_TLS_LE_LOX10;
1301 return R_SPARC_TLS_IE_LO10;
1302 case R_SPARC_TLS_IE_HI22:
1304 return R_SPARC_TLS_LE_HIX22;
1306 case R_SPARC_TLS_IE_LO10:
1308 return R_SPARC_TLS_LE_LOX10;
1310 case R_SPARC_TLS_LDM_HI22:
1311 return R_SPARC_TLS_LE_HIX22;
1312 case R_SPARC_TLS_LDM_LO10:
1313 return R_SPARC_TLS_LE_LOX10;
1319 /* Look through the relocs for a section during the first phase, and
1320 allocate space in the global offset table or procedure linkage
1324 _bfd_sparc_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
1325 asection *sec, const Elf_Internal_Rela *relocs)
1327 struct _bfd_sparc_elf_link_hash_table *htab;
1328 Elf_Internal_Shdr *symtab_hdr;
1329 struct elf_link_hash_entry **sym_hashes;
1330 const Elf_Internal_Rela *rel;
1331 const Elf_Internal_Rela *rel_end;
1334 bfd_boolean checked_tlsgd = FALSE;
1336 if (info->relocatable)
1339 htab = _bfd_sparc_elf_hash_table (info);
1340 BFD_ASSERT (htab != NULL);
1341 symtab_hdr = &elf_symtab_hdr (abfd);
1342 sym_hashes = elf_sym_hashes (abfd);
1346 if (ABI_64_P (abfd))
1347 num_relocs = NUM_SHDR_ENTRIES (_bfd_elf_single_rel_hdr (sec));
1349 num_relocs = sec->reloc_count;
1351 BFD_ASSERT (is_sparc_elf (abfd) || num_relocs == 0);
1353 if (htab->elf.dynobj == NULL)
1354 htab->elf.dynobj = abfd;
1355 if (!create_ifunc_sections (htab->elf.dynobj, info))
1358 rel_end = relocs + num_relocs;
1359 for (rel = relocs; rel < rel_end; rel++)
1361 unsigned int r_type;
1362 unsigned long r_symndx;
1363 struct elf_link_hash_entry *h;
1364 Elf_Internal_Sym *isym;
1366 r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
1367 r_type = SPARC_ELF_R_TYPE (rel->r_info);
1369 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1371 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1377 if (r_symndx < symtab_hdr->sh_info)
1379 /* A local symbol. */
1380 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1385 /* Check relocation against local STT_GNU_IFUNC symbol. */
1386 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1388 h = elf_sparc_get_local_sym_hash (htab, abfd, rel,
1393 /* Fake a STT_GNU_IFUNC symbol. */
1394 h->type = STT_GNU_IFUNC;
1397 h->forced_local = 1;
1398 h->root.type = bfd_link_hash_defined;
1405 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1406 while (h->root.type == bfd_link_hash_indirect
1407 || h->root.type == bfd_link_hash_warning)
1408 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1411 if (h && h->type == STT_GNU_IFUNC)
1416 h->plt.refcount += 1;
1420 /* Compatibility with old R_SPARC_REV32 reloc conflicting
1421 with R_SPARC_TLS_GD_HI22. */
1422 if (! ABI_64_P (abfd) && ! checked_tlsgd)
1425 case R_SPARC_TLS_GD_HI22:
1427 const Elf_Internal_Rela *relt;
1429 for (relt = rel + 1; relt < rel_end; relt++)
1430 if (ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_LO10
1431 || ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_ADD
1432 || ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_CALL)
1434 checked_tlsgd = TRUE;
1435 _bfd_sparc_elf_tdata (abfd)->has_tlsgd = relt < rel_end;
1438 case R_SPARC_TLS_GD_LO10:
1439 case R_SPARC_TLS_GD_ADD:
1440 case R_SPARC_TLS_GD_CALL:
1441 checked_tlsgd = TRUE;
1442 _bfd_sparc_elf_tdata (abfd)->has_tlsgd = TRUE;
1446 r_type = sparc_elf_tls_transition (info, abfd, r_type, h == NULL);
1449 case R_SPARC_TLS_LDM_HI22:
1450 case R_SPARC_TLS_LDM_LO10:
1451 htab->tls_ldm_got.refcount += 1;
1454 case R_SPARC_TLS_LE_HIX22:
1455 case R_SPARC_TLS_LE_LOX10:
1460 case R_SPARC_TLS_IE_HI22:
1461 case R_SPARC_TLS_IE_LO10:
1463 info->flags |= DF_STATIC_TLS;
1469 case R_SPARC_GOTDATA_HIX22:
1470 case R_SPARC_GOTDATA_LOX10:
1471 case R_SPARC_GOTDATA_OP_HIX22:
1472 case R_SPARC_GOTDATA_OP_LOX10:
1473 case R_SPARC_TLS_GD_HI22:
1474 case R_SPARC_TLS_GD_LO10:
1475 /* This symbol requires a global offset table entry. */
1477 int tls_type, old_tls_type;
1485 case R_SPARC_GOTDATA_OP_HIX22:
1486 case R_SPARC_GOTDATA_OP_LOX10:
1487 tls_type = GOT_NORMAL;
1489 case R_SPARC_TLS_GD_HI22:
1490 case R_SPARC_TLS_GD_LO10:
1491 tls_type = GOT_TLS_GD;
1493 case R_SPARC_TLS_IE_HI22:
1494 case R_SPARC_TLS_IE_LO10:
1495 tls_type = GOT_TLS_IE;
1501 h->got.refcount += 1;
1502 old_tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
1506 bfd_signed_vma *local_got_refcounts;
1508 /* This is a global offset table entry for a local symbol. */
1509 local_got_refcounts = elf_local_got_refcounts (abfd);
1510 if (local_got_refcounts == NULL)
1514 size = symtab_hdr->sh_info;
1515 size *= (sizeof (bfd_signed_vma) + sizeof(char));
1516 local_got_refcounts = ((bfd_signed_vma *)
1517 bfd_zalloc (abfd, size));
1518 if (local_got_refcounts == NULL)
1520 elf_local_got_refcounts (abfd) = local_got_refcounts;
1521 _bfd_sparc_elf_local_got_tls_type (abfd)
1522 = (char *) (local_got_refcounts + symtab_hdr->sh_info);
1526 case R_SPARC_GOTDATA_OP_HIX22:
1527 case R_SPARC_GOTDATA_OP_LOX10:
1531 local_got_refcounts[r_symndx] += 1;
1534 old_tls_type = _bfd_sparc_elf_local_got_tls_type (abfd) [r_symndx];
1537 /* If a TLS symbol is accessed using IE at least once,
1538 there is no point to use dynamic model for it. */
1539 if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1540 && (old_tls_type != GOT_TLS_GD
1541 || tls_type != GOT_TLS_IE))
1543 if (old_tls_type == GOT_TLS_IE && tls_type == GOT_TLS_GD)
1544 tls_type = old_tls_type;
1547 (*_bfd_error_handler)
1548 (_("%B: `%s' accessed both as normal and thread local symbol"),
1549 abfd, h ? h->root.root.string : "<local>");
1554 if (old_tls_type != tls_type)
1557 _bfd_sparc_elf_hash_entry (h)->tls_type = tls_type;
1559 _bfd_sparc_elf_local_got_tls_type (abfd) [r_symndx] = tls_type;
1563 if (htab->elf.sgot == NULL)
1565 if (!_bfd_elf_create_got_section (htab->elf.dynobj, info))
1570 case R_SPARC_TLS_GD_CALL:
1571 case R_SPARC_TLS_LDM_CALL:
1574 /* These are basically R_SPARC_TLS_WPLT30 relocs against
1576 struct bfd_link_hash_entry *bh = NULL;
1577 if (! _bfd_generic_link_add_one_symbol (info, abfd,
1578 "__tls_get_addr", 0,
1579 bfd_und_section_ptr, 0,
1583 h = (struct elf_link_hash_entry *) bh;
1590 case R_SPARC_WPLT30:
1591 case R_SPARC_HIPLT22:
1592 case R_SPARC_LOPLT10:
1593 case R_SPARC_PCPLT32:
1594 case R_SPARC_PCPLT22:
1595 case R_SPARC_PCPLT10:
1597 /* This symbol requires a procedure linkage table entry. We
1598 actually build the entry in adjust_dynamic_symbol,
1599 because this might be a case of linking PIC code without
1600 linking in any dynamic objects, in which case we don't
1601 need to generate a procedure linkage table after all. */
1605 if (! ABI_64_P (abfd))
1607 /* The Solaris native assembler will generate a WPLT30
1608 reloc for a local symbol if you assemble a call from
1609 one section to another when using -K pic. We treat
1611 if (ELF32_R_TYPE (rel->r_info) == R_SPARC_PLT32)
1615 /* PR 7027: We need similar behaviour for 64-bit binaries. */
1616 else if (r_type == R_SPARC_WPLT30)
1619 /* It does not make sense to have a procedure linkage
1620 table entry for a local symbol. */
1621 bfd_set_error (bfd_error_bad_value);
1630 this_r_type = SPARC_ELF_R_TYPE (rel->r_info);
1631 if (this_r_type == R_SPARC_PLT32
1632 || this_r_type == R_SPARC_PLT64)
1635 h->plt.refcount += 1;
1640 case R_SPARC_PC_HH22:
1641 case R_SPARC_PC_HM10:
1642 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:
1688 if (h != NULL && !info->shared)
1690 /* We may need a .plt entry if the function this reloc
1691 refers to is in a shared lib. */
1692 h->plt.refcount += 1;
1695 /* If we are creating a shared library, and this is a reloc
1696 against a global symbol, or a non PC relative reloc
1697 against a local symbol, then we need to copy the reloc
1698 into the shared library. However, if we are linking with
1699 -Bsymbolic, we do not need to copy a reloc against a
1700 global symbol which is defined in an object we are
1701 including in the link (i.e., DEF_REGULAR is set). At
1702 this point we have not seen all the input files, so it is
1703 possible that DEF_REGULAR is not set now but will be set
1704 later (it is never cleared). In case of a weak definition,
1705 DEF_REGULAR may be cleared later by a strong definition in
1706 a shared library. We account for that possibility below by
1707 storing information in the relocs_copied field of the hash
1708 table entry. A similar situation occurs when creating
1709 shared libraries and symbol visibility changes render the
1712 If on the other hand, we are creating an executable, we
1713 may need to keep relocations for symbols satisfied by a
1714 dynamic library if we manage to avoid copy relocs for the
1717 && (sec->flags & SEC_ALLOC) != 0
1718 && (! _bfd_sparc_elf_howto_table[r_type].pc_relative
1720 && (! SYMBOLIC_BIND (info, h)
1721 || h->root.type == bfd_link_hash_defweak
1722 || !h->def_regular))))
1724 && (sec->flags & SEC_ALLOC) != 0
1726 && (h->root.type == bfd_link_hash_defweak
1727 || !h->def_regular))
1730 && h->type == STT_GNU_IFUNC))
1732 struct _bfd_sparc_elf_dyn_relocs *p;
1733 struct _bfd_sparc_elf_dyn_relocs **head;
1735 /* When creating a shared object, we must copy these
1736 relocs into the output file. We create a reloc
1737 section in dynobj and make room for the reloc. */
1740 sreloc = _bfd_elf_make_dynamic_reloc_section
1741 (sec, htab->elf.dynobj, htab->word_align_power,
1742 abfd, /*rela?*/ TRUE);
1748 /* If this is a global symbol, we count the number of
1749 relocations we need for this symbol. */
1751 head = &((struct _bfd_sparc_elf_link_hash_entry *) h)->dyn_relocs;
1754 /* Track dynamic relocs needed for local syms too.
1755 We really need local syms available to do this
1760 BFD_ASSERT (isym != NULL);
1761 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1765 vpp = &elf_section_data (s)->local_dynrel;
1766 head = (struct _bfd_sparc_elf_dyn_relocs **) vpp;
1770 if (p == NULL || p->sec != sec)
1772 bfd_size_type amt = sizeof *p;
1773 p = ((struct _bfd_sparc_elf_dyn_relocs *)
1774 bfd_alloc (htab->elf.dynobj, amt));
1785 if (_bfd_sparc_elf_howto_table[r_type].pc_relative)
1791 case R_SPARC_GNU_VTINHERIT:
1792 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1796 case R_SPARC_GNU_VTENTRY:
1797 BFD_ASSERT (h != NULL);
1799 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1803 case R_SPARC_REGISTER:
1804 /* Nothing to do. */
1816 _bfd_sparc_elf_gc_mark_hook (asection *sec,
1817 struct bfd_link_info *info,
1818 Elf_Internal_Rela *rel,
1819 struct elf_link_hash_entry *h,
1820 Elf_Internal_Sym *sym)
1823 switch (SPARC_ELF_R_TYPE (rel->r_info))
1825 case R_SPARC_GNU_VTINHERIT:
1826 case R_SPARC_GNU_VTENTRY:
1830 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1833 static Elf_Internal_Rela *
1834 sparc_elf_find_reloc_at_ofs (Elf_Internal_Rela *rel,
1835 Elf_Internal_Rela *relend,
1838 while (rel < relend)
1840 if (rel->r_offset == offset)
1847 /* Update the got entry reference counts for the section being removed. */
1849 _bfd_sparc_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
1850 asection *sec, const Elf_Internal_Rela *relocs)
1852 struct _bfd_sparc_elf_link_hash_table *htab;
1853 Elf_Internal_Shdr *symtab_hdr;
1854 struct elf_link_hash_entry **sym_hashes;
1855 bfd_signed_vma *local_got_refcounts;
1856 const Elf_Internal_Rela *rel, *relend;
1858 if (info->relocatable)
1861 BFD_ASSERT (is_sparc_elf (abfd) || sec->reloc_count == 0);
1863 elf_section_data (sec)->local_dynrel = NULL;
1865 htab = _bfd_sparc_elf_hash_table (info);
1866 BFD_ASSERT (htab != NULL);
1867 symtab_hdr = &elf_symtab_hdr (abfd);
1868 sym_hashes = elf_sym_hashes (abfd);
1869 local_got_refcounts = elf_local_got_refcounts (abfd);
1871 relend = relocs + sec->reloc_count;
1872 for (rel = relocs; rel < relend; rel++)
1874 unsigned long r_symndx;
1875 unsigned int r_type;
1876 struct elf_link_hash_entry *h = NULL;
1878 r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
1879 if (r_symndx >= symtab_hdr->sh_info)
1881 struct _bfd_sparc_elf_link_hash_entry *eh;
1882 struct _bfd_sparc_elf_dyn_relocs **pp;
1883 struct _bfd_sparc_elf_dyn_relocs *p;
1885 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1886 while (h->root.type == bfd_link_hash_indirect
1887 || h->root.type == bfd_link_hash_warning)
1888 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1889 eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
1890 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1893 /* Everything must go for SEC. */
1899 r_type = SPARC_ELF_R_TYPE (rel->r_info);
1900 r_type = sparc_elf_tls_transition (info, abfd, r_type, h != NULL);
1903 case R_SPARC_TLS_LDM_HI22:
1904 case R_SPARC_TLS_LDM_LO10:
1905 if (_bfd_sparc_elf_hash_table (info)->tls_ldm_got.refcount > 0)
1906 _bfd_sparc_elf_hash_table (info)->tls_ldm_got.refcount -= 1;
1909 case R_SPARC_TLS_GD_HI22:
1910 case R_SPARC_TLS_GD_LO10:
1911 case R_SPARC_TLS_IE_HI22:
1912 case R_SPARC_TLS_IE_LO10:
1916 case R_SPARC_GOTDATA_HIX22:
1917 case R_SPARC_GOTDATA_LOX10:
1918 case R_SPARC_GOTDATA_OP_HIX22:
1919 case R_SPARC_GOTDATA_OP_LOX10:
1922 if (h->got.refcount > 0)
1929 case R_SPARC_GOTDATA_OP_HIX22:
1930 case R_SPARC_GOTDATA_OP_LOX10:
1934 if (local_got_refcounts[r_symndx] > 0)
1935 local_got_refcounts[r_symndx]--;
1943 case R_SPARC_PC_HH22:
1944 case R_SPARC_PC_HM10:
1945 case R_SPARC_PC_LM22:
1947 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1952 case R_SPARC_DISP16:
1953 case R_SPARC_DISP32:
1954 case R_SPARC_DISP64:
1955 case R_SPARC_WDISP30:
1956 case R_SPARC_WDISP22:
1957 case R_SPARC_WDISP19:
1958 case R_SPARC_WDISP16:
1989 case R_SPARC_WPLT30:
1992 if (h->plt.refcount > 0)
2005 /* Adjust a symbol defined by a dynamic object and referenced by a
2006 regular object. The current definition is in some section of the
2007 dynamic object, but we're not including those sections. We have to
2008 change the definition to something the rest of the link can
2012 _bfd_sparc_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
2013 struct elf_link_hash_entry *h)
2015 struct _bfd_sparc_elf_link_hash_table *htab;
2016 struct _bfd_sparc_elf_link_hash_entry * eh;
2017 struct _bfd_sparc_elf_dyn_relocs *p;
2020 htab = _bfd_sparc_elf_hash_table (info);
2021 BFD_ASSERT (htab != NULL);
2023 /* Make sure we know what is going on here. */
2024 BFD_ASSERT (htab->elf.dynobj != NULL
2026 || h->type == STT_GNU_IFUNC
2027 || h->u.weakdef != NULL
2030 && !h->def_regular)));
2032 /* If this is a function, put it in the procedure linkage table. We
2033 will fill in the contents of the procedure linkage table later
2034 (although we could actually do it here). The STT_NOTYPE
2035 condition is a hack specifically for the Oracle libraries
2036 delivered for Solaris; for some inexplicable reason, they define
2037 some of their functions as STT_NOTYPE when they really should be
2039 if (h->type == STT_FUNC
2040 || h->type == STT_GNU_IFUNC
2042 || (h->type == STT_NOTYPE
2043 && (h->root.type == bfd_link_hash_defined
2044 || h->root.type == bfd_link_hash_defweak)
2045 && (h->root.u.def.section->flags & SEC_CODE) != 0))
2047 if (h->plt.refcount <= 0
2048 || (h->type != STT_GNU_IFUNC
2049 && (SYMBOL_CALLS_LOCAL (info, h)
2050 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2051 && h->root.type == bfd_link_hash_undefweak))))
2053 /* This case can occur if we saw a WPLT30 reloc in an input
2054 file, but the symbol was never referred to by a dynamic
2055 object, or if all references were garbage collected. In
2056 such a case, we don't actually need to build a procedure
2057 linkage table, and we can just do a WDISP30 reloc instead. */
2058 h->plt.offset = (bfd_vma) -1;
2065 h->plt.offset = (bfd_vma) -1;
2067 /* If this is a weak symbol, and there is a real definition, the
2068 processor independent code will have arranged for us to see the
2069 real definition first, and we can just use the same value. */
2070 if (h->u.weakdef != NULL)
2072 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2073 || h->u.weakdef->root.type == bfd_link_hash_defweak);
2074 h->root.u.def.section = h->u.weakdef->root.u.def.section;
2075 h->root.u.def.value = h->u.weakdef->root.u.def.value;
2079 /* This is a reference to a symbol defined by a dynamic object which
2080 is not a function. */
2082 /* If we are creating a shared library, we must presume that the
2083 only references to the symbol are via the global offset table.
2084 For such cases we need not do anything here; the relocations will
2085 be handled correctly by relocate_section. */
2089 /* If there are no references to this symbol that do not use the
2090 GOT, we don't need to generate a copy reloc. */
2091 if (!h->non_got_ref)
2094 /* If -z nocopyreloc was given, we won't generate them either. */
2095 if (info->nocopyreloc)
2101 eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
2102 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2104 s = p->sec->output_section;
2105 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2109 /* If we didn't find any dynamic relocs in read-only sections, then
2110 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2119 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
2120 h->root.root.string);
2124 /* We must allocate the symbol in our .dynbss section, which will
2125 become part of the .bss section of the executable. There will be
2126 an entry for this symbol in the .dynsym section. The dynamic
2127 object will contain position independent code, so all references
2128 from the dynamic object to this symbol will go through the global
2129 offset table. The dynamic linker will use the .dynsym entry to
2130 determine the address it must put in the global offset table, so
2131 both the dynamic object and the regular object will refer to the
2132 same memory location for the variable. */
2134 /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker
2135 to copy the initial value out of the dynamic object and into the
2136 runtime process image. We need to remember the offset into the
2137 .rel.bss section we are going to use. */
2138 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
2140 htab->srelbss->size += SPARC_ELF_RELA_BYTES (htab);
2146 return _bfd_elf_adjust_dynamic_copy (h, s);
2149 /* Allocate space in .plt, .got and associated reloc sections for
2153 allocate_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
2155 struct bfd_link_info *info;
2156 struct _bfd_sparc_elf_link_hash_table *htab;
2157 struct _bfd_sparc_elf_link_hash_entry *eh;
2158 struct _bfd_sparc_elf_dyn_relocs *p;
2160 if (h->root.type == bfd_link_hash_indirect)
2163 info = (struct bfd_link_info *) inf;
2164 htab = _bfd_sparc_elf_hash_table (info);
2165 BFD_ASSERT (htab != NULL);
2167 if ((htab->elf.dynamic_sections_created
2168 && h->plt.refcount > 0)
2169 || (h->type == STT_GNU_IFUNC
2173 /* Make sure this symbol is output as a dynamic symbol.
2174 Undefined weak syms won't yet be marked as dynamic. */
2175 if (h->dynindx == -1
2176 && !h->forced_local)
2178 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2182 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h)
2183 || (h->type == STT_GNU_IFUNC
2186 asection *s = htab->elf.splt;
2191 /* Allocate room for the header. */
2194 s->size = htab->plt_header_size;
2196 /* Allocate space for the .rela.plt.unloaded relocations. */
2197 if (htab->is_vxworks && !info->shared)
2198 htab->srelplt2->size = sizeof (Elf32_External_Rela) * 2;
2201 /* The procedure linkage table size is bounded by the magnitude
2202 of the offset we can describe in the entry. */
2203 if (s->size >= (SPARC_ELF_WORD_BYTES(htab) == 8 ?
2204 (((bfd_vma)1 << 31) << 1) : 0x400000))
2206 bfd_set_error (bfd_error_bad_value);
2210 if (SPARC_ELF_WORD_BYTES(htab) == 8
2211 && s->size >= PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE)
2213 bfd_vma off = s->size - PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE;
2216 off = (off % (160 * PLT64_ENTRY_SIZE)) / PLT64_ENTRY_SIZE;
2218 h->plt.offset = (s->size - (off * 8));
2221 h->plt.offset = s->size;
2223 /* If this symbol is not defined in a regular file, and we are
2224 not generating a shared library, then set the symbol to this
2225 location in the .plt. This is required to make function
2226 pointers compare as equal between the normal executable and
2227 the shared library. */
2231 h->root.u.def.section = s;
2232 h->root.u.def.value = h->plt.offset;
2235 /* Make room for this entry. */
2236 s->size += htab->plt_entry_size;
2238 /* We also need to make an entry in the .rela.plt section. */
2239 if (s == htab->elf.splt)
2240 htab->elf.srelplt->size += SPARC_ELF_RELA_BYTES (htab);
2242 htab->elf.irelplt->size += SPARC_ELF_RELA_BYTES (htab);
2244 if (htab->is_vxworks)
2246 /* Allocate space for the .got.plt entry. */
2247 htab->elf.sgotplt->size += 4;
2249 /* ...and for the .rela.plt.unloaded relocations. */
2251 htab->srelplt2->size += sizeof (Elf32_External_Rela) * 3;
2256 h->plt.offset = (bfd_vma) -1;
2262 h->plt.offset = (bfd_vma) -1;
2266 /* If R_SPARC_TLS_IE_{HI22,LO10} symbol is now local to the binary,
2267 make it a R_SPARC_TLS_LE_{HI22,LO10} requiring no TLS entry. */
2268 if (h->got.refcount > 0
2271 && _bfd_sparc_elf_hash_entry(h)->tls_type == GOT_TLS_IE)
2272 h->got.offset = (bfd_vma) -1;
2273 else if (h->got.refcount > 0)
2277 int tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
2279 /* Make sure this symbol is output as a dynamic symbol.
2280 Undefined weak syms won't yet be marked as dynamic. */
2281 if (h->dynindx == -1
2282 && !h->forced_local)
2284 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2289 h->got.offset = s->size;
2290 s->size += SPARC_ELF_WORD_BYTES (htab);
2291 /* R_SPARC_TLS_GD_HI{22,LO10} needs 2 consecutive GOT slots. */
2292 if (tls_type == GOT_TLS_GD)
2293 s->size += SPARC_ELF_WORD_BYTES (htab);
2294 dyn = htab->elf.dynamic_sections_created;
2295 /* R_SPARC_TLS_IE_{HI22,LO10} needs one dynamic relocation,
2296 R_SPARC_TLS_GD_{HI22,LO10} needs one if local symbol and two if
2298 if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
2299 || tls_type == GOT_TLS_IE
2300 || h->type == STT_GNU_IFUNC)
2301 htab->elf.srelgot->size += SPARC_ELF_RELA_BYTES (htab);
2302 else if (tls_type == GOT_TLS_GD)
2303 htab->elf.srelgot->size += 2 * SPARC_ELF_RELA_BYTES (htab);
2304 else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
2305 htab->elf.srelgot->size += SPARC_ELF_RELA_BYTES (htab);
2308 h->got.offset = (bfd_vma) -1;
2310 eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
2311 if (eh->dyn_relocs == NULL)
2314 /* In the shared -Bsymbolic case, discard space allocated for
2315 dynamic pc-relative relocs against symbols which turn out to be
2316 defined in regular objects. For the normal shared case, discard
2317 space for pc-relative relocs that have become local due to symbol
2318 visibility changes. */
2322 if (SYMBOL_CALLS_LOCAL (info, h))
2324 struct _bfd_sparc_elf_dyn_relocs **pp;
2326 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2328 p->count -= p->pc_count;
2337 if (htab->is_vxworks)
2339 struct _bfd_sparc_elf_dyn_relocs **pp;
2341 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2343 if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
2350 /* Also discard relocs on undefined weak syms with non-default
2352 if (eh->dyn_relocs != NULL
2353 && h->root.type == bfd_link_hash_undefweak)
2355 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2356 eh->dyn_relocs = NULL;
2358 /* Make sure undefined weak symbols are output as a dynamic
2360 else if (h->dynindx == -1
2361 && !h->forced_local)
2363 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2370 /* For the non-shared case, discard space for relocs against
2371 symbols which turn out to need copy relocs or are not
2377 || (htab->elf.dynamic_sections_created
2378 && (h->root.type == bfd_link_hash_undefweak
2379 || h->root.type == bfd_link_hash_undefined))))
2381 /* Make sure this symbol is output as a dynamic symbol.
2382 Undefined weak syms won't yet be marked as dynamic. */
2383 if (h->dynindx == -1
2384 && !h->forced_local)
2386 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2390 /* If that succeeded, we know we'll be keeping all the
2392 if (h->dynindx != -1)
2396 eh->dyn_relocs = NULL;
2401 /* Finally, allocate space. */
2402 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2404 asection *sreloc = elf_section_data (p->sec)->sreloc;
2405 sreloc->size += p->count * SPARC_ELF_RELA_BYTES (htab);
2411 /* Allocate space in .plt, .got and associated reloc sections for
2412 local dynamic relocs. */
2415 allocate_local_dynrelocs (void **slot, void *inf)
2417 struct elf_link_hash_entry *h
2418 = (struct elf_link_hash_entry *) *slot;
2420 if (h->type != STT_GNU_IFUNC
2424 || h->root.type != bfd_link_hash_defined)
2427 return allocate_dynrelocs (h, inf);
2430 /* Find any dynamic relocs that apply to read-only sections. */
2433 readonly_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
2435 struct _bfd_sparc_elf_link_hash_entry *eh;
2436 struct _bfd_sparc_elf_dyn_relocs *p;
2438 eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
2439 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2441 asection *s = p->sec->output_section;
2443 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2445 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2447 info->flags |= DF_TEXTREL;
2449 /* Not an error, just cut short the traversal. */
2456 /* Return true if the dynamic symbol for a given section should be
2457 omitted when creating a shared library. */
2460 _bfd_sparc_elf_omit_section_dynsym (bfd *output_bfd,
2461 struct bfd_link_info *info,
2464 /* We keep the .got section symbol so that explicit relocations
2465 against the _GLOBAL_OFFSET_TABLE_ symbol emitted in PIC mode
2466 can be turned into relocations against the .got symbol. */
2467 if (strcmp (p->name, ".got") == 0)
2470 return _bfd_elf_link_omit_section_dynsym (output_bfd, info, p);
2473 /* Set the sizes of the dynamic sections. */
2476 _bfd_sparc_elf_size_dynamic_sections (bfd *output_bfd,
2477 struct bfd_link_info *info)
2479 struct _bfd_sparc_elf_link_hash_table *htab;
2484 htab = _bfd_sparc_elf_hash_table (info);
2485 BFD_ASSERT (htab != NULL);
2486 dynobj = htab->elf.dynobj;
2487 BFD_ASSERT (dynobj != NULL);
2489 if (elf_hash_table (info)->dynamic_sections_created)
2491 /* Set the contents of the .interp section to the interpreter. */
2492 if (info->executable)
2494 s = bfd_get_section_by_name (dynobj, ".interp");
2495 BFD_ASSERT (s != NULL);
2496 s->size = htab->dynamic_interpreter_size;
2497 s->contents = (unsigned char *) htab->dynamic_interpreter;
2501 /* Set up .got offsets for local syms, and space for local dynamic
2503 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2505 bfd_signed_vma *local_got;
2506 bfd_signed_vma *end_local_got;
2507 char *local_tls_type;
2508 bfd_size_type locsymcount;
2509 Elf_Internal_Shdr *symtab_hdr;
2512 if (! is_sparc_elf (ibfd))
2515 for (s = ibfd->sections; s != NULL; s = s->next)
2517 struct _bfd_sparc_elf_dyn_relocs *p;
2519 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
2521 if (!bfd_is_abs_section (p->sec)
2522 && bfd_is_abs_section (p->sec->output_section))
2524 /* Input section has been discarded, either because
2525 it is a copy of a linkonce section or due to
2526 linker script /DISCARD/, so we'll be discarding
2529 else if (htab->is_vxworks
2530 && strcmp (p->sec->output_section->name,
2533 /* Relocations in vxworks .tls_vars sections are
2534 handled specially by the loader. */
2536 else if (p->count != 0)
2538 srel = elf_section_data (p->sec)->sreloc;
2539 if (!htab->elf.dynamic_sections_created)
2540 srel = htab->elf.irelplt;
2541 srel->size += p->count * SPARC_ELF_RELA_BYTES (htab);
2542 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2543 info->flags |= DF_TEXTREL;
2548 local_got = elf_local_got_refcounts (ibfd);
2552 symtab_hdr = &elf_symtab_hdr (ibfd);
2553 locsymcount = symtab_hdr->sh_info;
2554 end_local_got = local_got + locsymcount;
2555 local_tls_type = _bfd_sparc_elf_local_got_tls_type (ibfd);
2557 srel = htab->elf.srelgot;
2558 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
2562 *local_got = s->size;
2563 s->size += SPARC_ELF_WORD_BYTES (htab);
2564 if (*local_tls_type == GOT_TLS_GD)
2565 s->size += SPARC_ELF_WORD_BYTES (htab);
2567 || *local_tls_type == GOT_TLS_GD
2568 || *local_tls_type == GOT_TLS_IE)
2569 srel->size += SPARC_ELF_RELA_BYTES (htab);
2572 *local_got = (bfd_vma) -1;
2576 if (htab->tls_ldm_got.refcount > 0)
2578 /* Allocate 2 got entries and 1 dynamic reloc for
2579 R_SPARC_TLS_LDM_{HI22,LO10} relocs. */
2580 htab->tls_ldm_got.offset = htab->elf.sgot->size;
2581 htab->elf.sgot->size += (2 * SPARC_ELF_WORD_BYTES (htab));
2582 htab->elf.srelgot->size += SPARC_ELF_RELA_BYTES (htab);
2585 htab->tls_ldm_got.offset = -1;
2587 /* Allocate global sym .plt and .got entries, and space for global
2588 sym dynamic relocs. */
2589 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
2591 /* Allocate .plt and .got entries, and space for local symbols. */
2592 htab_traverse (htab->loc_hash_table, allocate_local_dynrelocs, info);
2594 if (! ABI_64_P (output_bfd)
2595 && !htab->is_vxworks
2596 && elf_hash_table (info)->dynamic_sections_created)
2598 /* Make space for the trailing nop in .plt. */
2599 if (htab->elf.splt->size > 0)
2600 htab->elf.splt->size += 1 * SPARC_INSN_BYTES;
2602 /* If the .got section is more than 0x1000 bytes, we add
2603 0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13
2604 bit relocations have a greater chance of working.
2606 FIXME: Make this optimization work for 64-bit too. */
2607 if (htab->elf.sgot->size >= 0x1000
2608 && elf_hash_table (info)->hgot->root.u.def.value == 0)
2609 elf_hash_table (info)->hgot->root.u.def.value = 0x1000;
2612 /* The check_relocs and adjust_dynamic_symbol entry points have
2613 determined the sizes of the various dynamic sections. Allocate
2615 for (s = dynobj->sections; s != NULL; s = s->next)
2617 if ((s->flags & SEC_LINKER_CREATED) == 0)
2620 if (s == htab->elf.splt
2621 || s == htab->elf.sgot
2622 || s == htab->sdynbss
2623 || s == htab->elf.iplt
2624 || s == htab->elf.sgotplt)
2626 /* Strip this section if we don't need it; see the
2629 else if (CONST_STRNEQ (s->name, ".rela"))
2633 /* We use the reloc_count field as a counter if we need
2634 to copy relocs into the output file. */
2640 /* It's not one of our sections. */
2646 /* If we don't need this section, strip it from the
2647 output file. This is mostly to handle .rela.bss and
2648 .rela.plt. We must create both sections in
2649 create_dynamic_sections, because they must be created
2650 before the linker maps input sections to output
2651 sections. The linker does that before
2652 adjust_dynamic_symbol is called, and it is that
2653 function which decides whether anything needs to go
2654 into these sections. */
2655 s->flags |= SEC_EXCLUDE;
2659 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2662 /* Allocate memory for the section contents. Zero the memory
2663 for the benefit of .rela.plt, which has 4 unused entries
2664 at the beginning, and we don't want garbage. */
2665 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2666 if (s->contents == NULL)
2670 if (elf_hash_table (info)->dynamic_sections_created)
2672 /* Add some entries to the .dynamic section. We fill in the
2673 values later, in _bfd_sparc_elf_finish_dynamic_sections, but we
2674 must add the entries now so that we get the correct size for
2675 the .dynamic section. The DT_DEBUG entry is filled in by the
2676 dynamic linker and used by the debugger. */
2677 #define add_dynamic_entry(TAG, VAL) \
2678 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2680 if (info->executable)
2682 if (!add_dynamic_entry (DT_DEBUG, 0))
2686 if (htab->elf.srelplt->size != 0)
2688 if (!add_dynamic_entry (DT_PLTGOT, 0)
2689 || !add_dynamic_entry (DT_PLTRELSZ, 0)
2690 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2691 || !add_dynamic_entry (DT_JMPREL, 0))
2695 if (!add_dynamic_entry (DT_RELA, 0)
2696 || !add_dynamic_entry (DT_RELASZ, 0)
2697 || !add_dynamic_entry (DT_RELAENT,
2698 SPARC_ELF_RELA_BYTES (htab)))
2701 /* If any dynamic relocs apply to a read-only section,
2702 then we need a DT_TEXTREL entry. */
2703 if ((info->flags & DF_TEXTREL) == 0)
2704 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
2707 if (info->flags & DF_TEXTREL)
2709 if (!add_dynamic_entry (DT_TEXTREL, 0))
2713 if (ABI_64_P (output_bfd))
2716 struct _bfd_sparc_elf_app_reg * app_regs;
2717 struct elf_strtab_hash *dynstr;
2718 struct elf_link_hash_table *eht = elf_hash_table (info);
2720 /* Add dynamic STT_REGISTER symbols and corresponding DT_SPARC_REGISTER
2721 entries if needed. */
2722 app_regs = _bfd_sparc_elf_hash_table (info)->app_regs;
2723 dynstr = eht->dynstr;
2725 for (reg = 0; reg < 4; reg++)
2726 if (app_regs [reg].name != NULL)
2728 struct elf_link_local_dynamic_entry *entry, *e;
2730 if (!add_dynamic_entry (DT_SPARC_REGISTER, 0))
2733 entry = (struct elf_link_local_dynamic_entry *)
2734 bfd_hash_allocate (&info->hash->table, sizeof (*entry));
2738 /* We cheat here a little bit: the symbol will not be local, so we
2739 put it at the end of the dynlocal linked list. We will fix it
2740 later on, as we have to fix other fields anyway. */
2741 entry->isym.st_value = reg < 2 ? reg + 2 : reg + 4;
2742 entry->isym.st_size = 0;
2743 if (*app_regs [reg].name != '\0')
2745 = _bfd_elf_strtab_add (dynstr, app_regs[reg].name, FALSE);
2747 entry->isym.st_name = 0;
2748 entry->isym.st_other = 0;
2749 entry->isym.st_info = ELF_ST_INFO (app_regs [reg].bind,
2751 entry->isym.st_shndx = app_regs [reg].shndx;
2752 entry->isym.st_target_internal = 0;
2754 entry->input_bfd = output_bfd;
2755 entry->input_indx = -1;
2757 if (eht->dynlocal == NULL)
2758 eht->dynlocal = entry;
2761 for (e = eht->dynlocal; e->next; e = e->next)
2768 if (htab->is_vxworks
2769 && !elf_vxworks_add_dynamic_entries (output_bfd, info))
2772 #undef add_dynamic_entry
2778 _bfd_sparc_elf_new_section_hook (bfd *abfd, asection *sec)
2780 if (!sec->used_by_bfd)
2782 struct _bfd_sparc_elf_section_data *sdata;
2783 bfd_size_type amt = sizeof (*sdata);
2785 sdata = bfd_zalloc (abfd, amt);
2788 sec->used_by_bfd = sdata;
2791 return _bfd_elf_new_section_hook (abfd, sec);
2795 _bfd_sparc_elf_relax_section (bfd *abfd ATTRIBUTE_UNUSED,
2796 struct bfd_section *section,
2797 struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
2800 if (link_info->relocatable)
2801 (*link_info->callbacks->einfo)
2802 (_("%P%F: --relax and -r may not be used together\n"));
2805 sec_do_relax (section) = 1;
2809 /* Return the base VMA address which should be subtracted from real addresses
2810 when resolving @dtpoff relocation.
2811 This is PT_TLS segment p_vaddr. */
2814 dtpoff_base (struct bfd_link_info *info)
2816 /* If tls_sec is NULL, we should have signalled an error already. */
2817 if (elf_hash_table (info)->tls_sec == NULL)
2819 return elf_hash_table (info)->tls_sec->vma;
2822 /* Return the relocation value for @tpoff relocation
2823 if STT_TLS virtual address is ADDRESS. */
2826 tpoff (struct bfd_link_info *info, bfd_vma address)
2828 struct elf_link_hash_table *htab = elf_hash_table (info);
2829 const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
2830 bfd_vma static_tls_size;
2832 /* If tls_sec is NULL, we should have signalled an error already. */
2833 if (htab->tls_sec == NULL)
2836 /* Consider special static TLS alignment requirements. */
2837 static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
2838 return address - static_tls_size - htab->tls_sec->vma;
2841 /* Return the relocation value for a %gdop relocation. */
2844 gdopoff (struct bfd_link_info *info, bfd_vma address)
2846 struct elf_link_hash_table *htab = elf_hash_table (info);
2849 got_base = (htab->hgot->root.u.def.value
2850 + htab->hgot->root.u.def.section->output_offset
2851 + htab->hgot->root.u.def.section->output_section->vma);
2853 return address - got_base;
2856 /* Relocate a SPARC ELF section. */
2859 _bfd_sparc_elf_relocate_section (bfd *output_bfd,
2860 struct bfd_link_info *info,
2862 asection *input_section,
2864 Elf_Internal_Rela *relocs,
2865 Elf_Internal_Sym *local_syms,
2866 asection **local_sections)
2868 struct _bfd_sparc_elf_link_hash_table *htab;
2869 Elf_Internal_Shdr *symtab_hdr;
2870 struct elf_link_hash_entry **sym_hashes;
2871 bfd_vma *local_got_offsets;
2874 Elf_Internal_Rela *rel;
2875 Elf_Internal_Rela *relend;
2877 bfd_boolean is_vxworks_tls;
2879 htab = _bfd_sparc_elf_hash_table (info);
2880 BFD_ASSERT (htab != NULL);
2881 symtab_hdr = &elf_symtab_hdr (input_bfd);
2882 sym_hashes = elf_sym_hashes (input_bfd);
2883 local_got_offsets = elf_local_got_offsets (input_bfd);
2885 if (elf_hash_table (info)->hgot == NULL)
2888 got_base = elf_hash_table (info)->hgot->root.u.def.value;
2890 sreloc = elf_section_data (input_section)->sreloc;
2891 /* We have to handle relocations in vxworks .tls_vars sections
2892 specially, because the dynamic loader is 'weird'. */
2893 is_vxworks_tls = (htab->is_vxworks && info->shared
2894 && !strcmp (input_section->output_section->name,
2898 if (ABI_64_P (output_bfd))
2899 num_relocs = NUM_SHDR_ENTRIES (_bfd_elf_single_rel_hdr (input_section));
2901 num_relocs = input_section->reloc_count;
2902 relend = relocs + num_relocs;
2903 for (; rel < relend; rel++)
2905 int r_type, tls_type;
2906 reloc_howto_type *howto;
2907 unsigned long r_symndx;
2908 struct elf_link_hash_entry *h;
2909 Elf_Internal_Sym *sym;
2911 bfd_vma relocation, off;
2912 bfd_reloc_status_type r;
2913 bfd_boolean is_plt = FALSE;
2914 bfd_boolean unresolved_reloc;
2916 r_type = SPARC_ELF_R_TYPE (rel->r_info);
2917 if (r_type == R_SPARC_GNU_VTINHERIT
2918 || r_type == R_SPARC_GNU_VTENTRY)
2921 if (r_type < 0 || r_type >= (int) R_SPARC_max_std)
2923 bfd_set_error (bfd_error_bad_value);
2926 howto = _bfd_sparc_elf_howto_table + r_type;
2928 r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
2932 unresolved_reloc = FALSE;
2933 if (r_symndx < symtab_hdr->sh_info)
2935 sym = local_syms + r_symndx;
2936 sec = local_sections[r_symndx];
2937 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2939 if (!info->relocatable
2940 && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
2942 /* Relocate against local STT_GNU_IFUNC symbol. */
2943 h = elf_sparc_get_local_sym_hash (htab, input_bfd,
2948 /* Set STT_GNU_IFUNC symbol value. */
2949 h->root.u.def.value = sym->st_value;
2950 h->root.u.def.section = sec;
2957 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2958 r_symndx, symtab_hdr, sym_hashes,
2960 unresolved_reloc, warned);
2963 /* To avoid generating warning messages about truncated
2964 relocations, set the relocation's address to be the same as
2965 the start of this section. */
2966 if (input_section->output_section != NULL)
2967 relocation = input_section->output_section->vma;
2973 if (sec != NULL && elf_discarded_section (sec))
2974 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
2975 rel, relend, howto, contents);
2977 if (info->relocatable)
2981 && h->type == STT_GNU_IFUNC
2987 if ((input_section->flags & SEC_ALLOC) == 0
2988 || h->plt.offset == (bfd_vma) -1)
2991 plt_sec = htab->elf.splt;
2993 plt_sec =htab->elf.iplt;
2997 case R_SPARC_GOTDATA_OP:
3000 case R_SPARC_GOTDATA_OP_HIX22:
3001 case R_SPARC_GOTDATA_OP_LOX10:
3002 r_type = (r_type == R_SPARC_GOTDATA_OP_HIX22
3005 howto = _bfd_sparc_elf_howto_table + r_type;
3011 if (htab->elf.sgot == NULL)
3013 off = h->got.offset;
3014 if (off == (bfd_vma) -1)
3016 relocation = htab->elf.sgot->output_offset + off - got_base;
3019 case R_SPARC_WPLT30:
3020 case R_SPARC_WDISP30:
3021 relocation = (plt_sec->output_section->vma
3022 + plt_sec->output_offset + h->plt.offset);
3027 if (info->shared && h->non_got_ref)
3029 Elf_Internal_Rela outrel;
3032 offset = _bfd_elf_section_offset (output_bfd, info,
3035 if (offset == (bfd_vma) -1
3036 || offset == (bfd_vma) -2)
3039 outrel.r_offset = (input_section->output_section->vma
3040 + input_section->output_offset
3043 if (h->dynindx == -1
3045 || info->executable)
3047 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
3048 0, R_SPARC_IRELATIVE);
3049 outrel.r_addend = relocation + rel->r_addend;
3053 if (h->dynindx == -1)
3055 outrel.r_info = SPARC_ELF_R_INFO (htab, rel, h->dynindx, r_type);
3056 outrel.r_addend = rel->r_addend;
3059 sparc_elf_append_rela (output_bfd, sreloc, &outrel);
3063 relocation = (plt_sec->output_section->vma
3064 + plt_sec->output_offset + h->plt.offset);
3069 /* We should only see such relocs in static links. */
3072 relocation = (plt_sec->output_section->vma
3073 + plt_sec->output_offset + h->plt.offset);
3077 if (h->root.root.string)
3078 name = h->root.root.string;
3080 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3082 (*_bfd_error_handler)
3083 (_("%B: relocation %s against STT_GNU_IFUNC "
3084 "symbol `%s' isn't handled by %s"), input_bfd,
3085 _bfd_sparc_elf_howto_table[r_type].name,
3086 name, __FUNCTION__);
3087 bfd_set_error (bfd_error_bad_value);
3094 case R_SPARC_GOTDATA_OP_HIX22:
3095 case R_SPARC_GOTDATA_OP_LOX10:
3096 if (SYMBOL_REFERENCES_LOCAL (info, h))
3097 r_type = (r_type == R_SPARC_GOTDATA_OP_HIX22
3098 ? R_SPARC_GOTDATA_HIX22
3099 : R_SPARC_GOTDATA_LOX10);
3101 r_type = (r_type == R_SPARC_GOTDATA_OP_HIX22
3104 howto = _bfd_sparc_elf_howto_table + r_type;
3107 case R_SPARC_GOTDATA_OP:
3108 if (SYMBOL_REFERENCES_LOCAL (info, h))
3110 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3112 /* {ld,ldx} [%rs1 + %rs2], %rd --> add %rs1, %rs2, %rd */
3113 relocation = 0x80000000 | (insn & 0x3e07c01f);
3114 bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3121 case R_SPARC_GOTDATA_HIX22:
3122 case R_SPARC_GOTDATA_LOX10:
3123 relocation = gdopoff (info, relocation);
3129 /* Relocation is to the entry for this symbol in the global
3131 if (htab->elf.sgot == NULL)
3138 off = h->got.offset;
3139 BFD_ASSERT (off != (bfd_vma) -1);
3140 dyn = elf_hash_table (info)->dynamic_sections_created;
3142 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3144 && SYMBOL_REFERENCES_LOCAL (info, h)))
3146 /* This is actually a static link, or it is a
3147 -Bsymbolic link and the symbol is defined
3148 locally, or the symbol was forced to be local
3149 because of a version file. We must initialize
3150 this entry in the global offset table. Since the
3151 offset must always be a multiple of 8 for 64-bit
3152 and 4 for 32-bit, we use the least significant bit
3153 to record whether we have initialized it already.
3155 When doing a dynamic link, we create a .rela.got
3156 relocation entry to initialize the value. This
3157 is done in the finish_dynamic_symbol routine. */
3162 SPARC_ELF_PUT_WORD (htab, output_bfd, relocation,
3163 htab->elf.sgot->contents + off);
3168 unresolved_reloc = FALSE;
3172 BFD_ASSERT (local_got_offsets != NULL
3173 && local_got_offsets[r_symndx] != (bfd_vma) -1);
3175 off = local_got_offsets[r_symndx];
3177 /* The offset must always be a multiple of 8 on 64-bit and
3178 4 on 32-bit. We use the least significant bit to record
3179 whether we have already processed this entry. */
3188 Elf_Internal_Rela outrel;
3190 /* We need to generate a R_SPARC_RELATIVE reloc
3191 for the dynamic linker. */
3192 s = htab->elf.srelgot;
3193 BFD_ASSERT (s != NULL);
3195 outrel.r_offset = (htab->elf.sgot->output_section->vma
3196 + htab->elf.sgot->output_offset
3198 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
3199 0, R_SPARC_RELATIVE);
3200 outrel.r_addend = relocation;
3202 sparc_elf_append_rela (output_bfd, s, &outrel);
3205 SPARC_ELF_PUT_WORD (htab, output_bfd, relocation,
3206 htab->elf.sgot->contents + off);
3207 local_got_offsets[r_symndx] |= 1;
3210 relocation = htab->elf.sgot->output_offset + off - got_base;
3215 if (h == NULL || h->plt.offset == (bfd_vma) -1)
3217 r_type = (r_type == R_SPARC_PLT32) ? R_SPARC_32 : R_SPARC_64;
3222 case R_SPARC_WPLT30:
3223 case R_SPARC_HIPLT22:
3224 case R_SPARC_LOPLT10:
3225 case R_SPARC_PCPLT32:
3226 case R_SPARC_PCPLT22:
3227 case R_SPARC_PCPLT10:
3229 /* Relocation is to the entry for this symbol in the
3230 procedure linkage table. */
3232 if (! ABI_64_P (output_bfd))
3234 /* The Solaris native assembler will generate a WPLT30 reloc
3235 for a local symbol if you assemble a call from one
3236 section to another when using -K pic. We treat it as
3241 /* PR 7027: We need similar behaviour for 64-bit binaries. */
3242 else if (r_type == R_SPARC_WPLT30 && h == NULL)
3246 BFD_ASSERT (h != NULL);
3249 if (h->plt.offset == (bfd_vma) -1 || htab->elf.splt == NULL)
3251 /* We didn't make a PLT entry for this symbol. This
3252 happens when statically linking PIC code, or when
3253 using -Bsymbolic. */
3257 relocation = (htab->elf.splt->output_section->vma
3258 + htab->elf.splt->output_offset
3260 unresolved_reloc = FALSE;
3261 if (r_type == R_SPARC_PLT32 || r_type == R_SPARC_PLT64)
3263 r_type = r_type == R_SPARC_PLT32 ? R_SPARC_32 : R_SPARC_64;
3271 case R_SPARC_PC_HH22:
3272 case R_SPARC_PC_HM10:
3273 case R_SPARC_PC_LM22:
3275 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3279 case R_SPARC_DISP16:
3280 case R_SPARC_DISP32:
3281 case R_SPARC_DISP64:
3282 case R_SPARC_WDISP30:
3283 case R_SPARC_WDISP22:
3284 case R_SPARC_WDISP19:
3285 case R_SPARC_WDISP16:
3312 if ((input_section->flags & SEC_ALLOC) == 0
3318 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3319 || h->root.type != bfd_link_hash_undefweak)
3320 && (! howto->pc_relative
3321 || !SYMBOL_CALLS_LOCAL (info, h)))
3328 || h->root.type == bfd_link_hash_undefweak
3329 || h->root.type == bfd_link_hash_undefined)))
3331 Elf_Internal_Rela outrel;
3332 bfd_boolean skip, relocate = FALSE;
3334 /* When generating a shared object, these relocations
3335 are copied into the output file to be resolved at run
3338 BFD_ASSERT (sreloc != NULL);
3343 _bfd_elf_section_offset (output_bfd, info, input_section,
3345 if (outrel.r_offset == (bfd_vma) -1)
3347 else if (outrel.r_offset == (bfd_vma) -2)
3348 skip = TRUE, relocate = TRUE;
3349 outrel.r_offset += (input_section->output_section->vma
3350 + input_section->output_offset);
3352 /* Optimize unaligned reloc usage now that we know where
3353 it finally resides. */
3357 if (outrel.r_offset & 1)
3358 r_type = R_SPARC_UA16;
3361 if (!(outrel.r_offset & 1))
3362 r_type = R_SPARC_16;
3365 if (outrel.r_offset & 3)
3366 r_type = R_SPARC_UA32;
3369 if (!(outrel.r_offset & 3))
3370 r_type = R_SPARC_32;
3373 if (outrel.r_offset & 7)
3374 r_type = R_SPARC_UA64;
3377 if (!(outrel.r_offset & 7))
3378 r_type = R_SPARC_64;
3381 case R_SPARC_DISP16:
3382 case R_SPARC_DISP32:
3383 case R_SPARC_DISP64:
3384 /* If the symbol is not dynamic, we should not keep
3385 a dynamic relocation. But an .rela.* slot has been
3386 allocated for it, output R_SPARC_NONE.
3387 FIXME: Add code tracking needed dynamic relocs as
3389 if (h->dynindx == -1)
3390 skip = TRUE, relocate = TRUE;
3395 memset (&outrel, 0, sizeof outrel);
3396 /* h->dynindx may be -1 if the symbol was marked to
3398 else if (h != NULL &&
3402 || !SYMBOLIC_BIND (info, h)
3403 || !h->def_regular))
3405 BFD_ASSERT (h->dynindx != -1);
3406 outrel.r_info = SPARC_ELF_R_INFO (htab, rel, h->dynindx, r_type);
3407 outrel.r_addend = rel->r_addend;
3411 if (r_type == R_SPARC_32 || r_type == R_SPARC_64)
3413 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
3414 0, R_SPARC_RELATIVE);
3415 outrel.r_addend = relocation + rel->r_addend;
3421 outrel.r_addend = relocation + rel->r_addend;
3424 sec = htab->elf.splt;
3426 if (bfd_is_abs_section (sec))
3428 else if (sec == NULL || sec->owner == NULL)
3430 bfd_set_error (bfd_error_bad_value);
3437 /* We are turning this relocation into one
3438 against a section symbol. It would be
3439 proper to subtract the symbol's value,
3440 osec->vma, from the emitted reloc addend,
3441 but ld.so expects buggy relocs. */
3442 osec = sec->output_section;
3443 indx = elf_section_data (osec)->dynindx;
3447 osec = htab->elf.text_index_section;
3448 indx = elf_section_data (osec)->dynindx;
3451 /* FIXME: we really should be able to link non-pic
3452 shared libraries. */
3456 (*_bfd_error_handler)
3457 (_("%B: probably compiled without -fPIC?"),
3459 bfd_set_error (bfd_error_bad_value);
3464 outrel.r_info = SPARC_ELF_R_INFO (htab, rel, indx,
3469 sparc_elf_append_rela (output_bfd, sreloc, &outrel);
3471 /* This reloc will be computed at runtime, so there's no
3472 need to do anything now. */
3478 case R_SPARC_TLS_GD_HI22:
3479 if (! ABI_64_P (input_bfd)
3480 && ! _bfd_sparc_elf_tdata (input_bfd)->has_tlsgd)
3482 /* R_SPARC_REV32 used the same reloc number as
3483 R_SPARC_TLS_GD_HI22. */
3484 r_type = R_SPARC_REV32;
3489 case R_SPARC_TLS_GD_LO10:
3490 case R_SPARC_TLS_IE_HI22:
3491 case R_SPARC_TLS_IE_LO10:
3492 r_type = sparc_elf_tls_transition (info, input_bfd, r_type, h == NULL);
3493 tls_type = GOT_UNKNOWN;
3494 if (h == NULL && local_got_offsets)
3495 tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3498 tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3499 if (!info->shared && h->dynindx == -1 && tls_type == GOT_TLS_IE)
3500 switch (SPARC_ELF_R_TYPE (rel->r_info))
3502 case R_SPARC_TLS_GD_HI22:
3503 case R_SPARC_TLS_IE_HI22:
3504 r_type = R_SPARC_TLS_LE_HIX22;
3507 r_type = R_SPARC_TLS_LE_LOX10;
3511 if (tls_type == GOT_TLS_IE)
3514 case R_SPARC_TLS_GD_HI22:
3515 r_type = R_SPARC_TLS_IE_HI22;
3517 case R_SPARC_TLS_GD_LO10:
3518 r_type = R_SPARC_TLS_IE_LO10;
3522 if (r_type == R_SPARC_TLS_LE_HIX22)
3524 relocation = tpoff (info, relocation);
3527 if (r_type == R_SPARC_TLS_LE_LOX10)
3529 /* Change add into xor. */
3530 relocation = tpoff (info, relocation);
3531 bfd_put_32 (output_bfd, (bfd_get_32 (input_bfd,
3532 contents + rel->r_offset)
3533 | 0x80182000), contents + rel->r_offset);
3539 off = h->got.offset;
3544 BFD_ASSERT (local_got_offsets != NULL);
3545 off = local_got_offsets[r_symndx];
3546 local_got_offsets[r_symndx] |= 1;
3550 if (htab->elf.sgot == NULL)
3557 Elf_Internal_Rela outrel;
3560 if (htab->elf.srelgot == NULL)
3563 SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3564 htab->elf.sgot->contents + off);
3565 outrel.r_offset = (htab->elf.sgot->output_section->vma
3566 + htab->elf.sgot->output_offset + off);
3567 indx = h && h->dynindx != -1 ? h->dynindx : 0;
3568 if (r_type == R_SPARC_TLS_IE_HI22
3569 || r_type == R_SPARC_TLS_IE_LO10)
3570 dr_type = SPARC_ELF_TPOFF_RELOC (htab);
3572 dr_type = SPARC_ELF_DTPMOD_RELOC (htab);
3573 if (dr_type == SPARC_ELF_TPOFF_RELOC (htab) && indx == 0)
3574 outrel.r_addend = relocation - dtpoff_base (info);
3576 outrel.r_addend = 0;
3577 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx, dr_type);
3578 sparc_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel);
3580 if (r_type == R_SPARC_TLS_GD_HI22
3581 || r_type == R_SPARC_TLS_GD_LO10)
3585 BFD_ASSERT (! unresolved_reloc);
3586 SPARC_ELF_PUT_WORD (htab, output_bfd,
3587 relocation - dtpoff_base (info),
3588 (htab->elf.sgot->contents + off
3589 + SPARC_ELF_WORD_BYTES (htab)));
3593 SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3594 (htab->elf.sgot->contents + off
3595 + SPARC_ELF_WORD_BYTES (htab)));
3596 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx,
3597 SPARC_ELF_DTPOFF_RELOC (htab));
3598 outrel.r_offset += SPARC_ELF_WORD_BYTES (htab);
3599 sparc_elf_append_rela (output_bfd, htab->elf.srelgot,
3603 else if (dr_type == SPARC_ELF_DTPMOD_RELOC (htab))
3605 SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3606 (htab->elf.sgot->contents + off
3607 + SPARC_ELF_WORD_BYTES (htab)));
3611 if (off >= (bfd_vma) -2)
3614 relocation = htab->elf.sgot->output_offset + off - got_base;
3615 unresolved_reloc = FALSE;
3616 howto = _bfd_sparc_elf_howto_table + r_type;
3619 case R_SPARC_TLS_LDM_HI22:
3620 case R_SPARC_TLS_LDM_LO10:
3623 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3626 off = htab->tls_ldm_got.offset;
3627 htab->tls_ldm_got.offset |= 1;
3628 goto r_sparc_tlsldm;
3630 case R_SPARC_TLS_LDO_HIX22:
3631 case R_SPARC_TLS_LDO_LOX10:
3634 relocation -= dtpoff_base (info);
3638 r_type = (r_type == R_SPARC_TLS_LDO_HIX22
3639 ? R_SPARC_TLS_LE_HIX22 : R_SPARC_TLS_LE_LOX10);
3642 case R_SPARC_TLS_LE_HIX22:
3643 case R_SPARC_TLS_LE_LOX10:
3646 Elf_Internal_Rela outrel;
3649 BFD_ASSERT (sreloc != NULL);
3652 _bfd_elf_section_offset (output_bfd, info, input_section,
3654 if (outrel.r_offset == (bfd_vma) -1)
3656 else if (outrel.r_offset == (bfd_vma) -2)
3658 outrel.r_offset += (input_section->output_section->vma
3659 + input_section->output_offset);
3661 memset (&outrel, 0, sizeof outrel);
3664 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, r_type);
3665 outrel.r_addend = relocation - dtpoff_base (info)
3669 sparc_elf_append_rela (output_bfd, sreloc, &outrel);
3672 relocation = tpoff (info, relocation);
3675 case R_SPARC_TLS_LDM_CALL:
3679 bfd_put_32 (output_bfd, 0x90100000, contents + rel->r_offset);
3684 case R_SPARC_TLS_GD_CALL:
3685 tls_type = GOT_UNKNOWN;
3686 if (h == NULL && local_got_offsets)
3687 tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3689 tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3691 || (r_type == R_SPARC_TLS_GD_CALL && tls_type == GOT_TLS_IE))
3693 Elf_Internal_Rela *rel2;
3696 if (!info->shared && (h == NULL || h->dynindx == -1))
3699 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3704 if (rel + 1 < relend
3705 && SPARC_ELF_R_TYPE (rel[1].r_info) == R_SPARC_TLS_GD_ADD
3706 && rel[1].r_offset == rel->r_offset + 4
3707 && SPARC_ELF_R_SYMNDX (htab, rel[1].r_info) == r_symndx
3708 && (((insn = bfd_get_32 (input_bfd,
3709 contents + rel[1].r_offset))
3710 >> 25) & 0x1f) == 8)
3713 call __tls_get_addr, %tgd_call(foo)
3714 add %reg1, %reg2, %o0, %tgd_add(foo)
3715 and change it into IE:
3716 {ld,ldx} [%reg1 + %reg2], %o0, %tie_ldx(foo)
3717 add %g7, %o0, %o0, %tie_add(foo).
3718 add is 0x80000000 | (rd << 25) | (rs1 << 14) | rs2,
3719 ld is 0xc0000000 | (rd << 25) | (rs1 << 14) | rs2,
3720 ldx is 0xc0580000 | (rd << 25) | (rs1 << 14) | rs2. */
3721 bfd_put_32 (output_bfd, insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000),
3722 contents + rel->r_offset);
3723 bfd_put_32 (output_bfd, 0x9001c008,
3724 contents + rel->r_offset + 4);
3729 /* We cannot just overwrite the delay slot instruction,
3730 as it might be what puts the %o0 argument to
3731 __tls_get_addr into place. So we have to transpose
3732 the delay slot with the add we patch in. */
3733 insn = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
3734 bfd_put_32 (output_bfd, insn,
3735 contents + rel->r_offset);
3736 bfd_put_32 (output_bfd, 0x9001c008,
3737 contents + rel->r_offset + 4);
3740 while ((rel2 = sparc_elf_find_reloc_at_ofs (rel2 + 1, relend,
3744 /* If the instruction we moved has a relocation attached to
3745 it, adjust the offset so that it will apply to the correct
3747 rel2->r_offset -= 4;
3752 h = (struct elf_link_hash_entry *)
3753 bfd_link_hash_lookup (info->hash, "__tls_get_addr", FALSE,
3755 BFD_ASSERT (h != NULL);
3756 r_type = R_SPARC_WPLT30;
3757 howto = _bfd_sparc_elf_howto_table + r_type;
3758 goto r_sparc_wplt30;
3760 case R_SPARC_TLS_GD_ADD:
3761 tls_type = GOT_UNKNOWN;
3762 if (h == NULL && local_got_offsets)
3763 tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3765 tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3766 if (! info->shared || tls_type == GOT_TLS_IE)
3768 /* add %reg1, %reg2, %reg3, %tgd_add(foo)
3770 {ld,ldx} [%reg1 + %reg2], %reg3, %tie_ldx(foo)
3772 add %g7, %reg2, %reg3. */
3773 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3774 if ((h != NULL && h->dynindx != -1) || info->shared)
3775 relocation = insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000);
3777 relocation = (insn & ~0x7c000) | 0x1c000;
3778 bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3782 case R_SPARC_TLS_LDM_ADD:
3784 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3787 case R_SPARC_TLS_LDO_ADD:
3790 /* Change rs1 into %g7. */
3791 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3792 insn = (insn & ~0x7c000) | 0x1c000;
3793 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3797 case R_SPARC_TLS_IE_LD:
3798 case R_SPARC_TLS_IE_LDX:
3799 if (! info->shared && (h == NULL || h->dynindx == -1))
3801 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3802 int rs2 = insn & 0x1f;
3803 int rd = (insn >> 25) & 0x1f;
3806 relocation = SPARC_NOP;
3808 relocation = 0x80100000 | (insn & 0x3e00001f);
3809 bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3813 case R_SPARC_TLS_IE_ADD:
3814 /* Totally useless relocation. */
3817 case R_SPARC_TLS_DTPOFF32:
3818 case R_SPARC_TLS_DTPOFF64:
3819 relocation -= dtpoff_base (info);
3826 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3827 because such sections are not SEC_ALLOC and thus ld.so will
3828 not process them. */
3829 if (unresolved_reloc
3830 && !((input_section->flags & SEC_DEBUGGING) != 0
3832 && _bfd_elf_section_offset (output_bfd, info, input_section,
3833 rel->r_offset) != (bfd_vma) -1)
3834 (*_bfd_error_handler)
3835 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3838 (long) rel->r_offset,
3840 h->root.root.string);
3842 r = bfd_reloc_continue;
3843 if (r_type == R_SPARC_OLO10)
3847 if (! ABI_64_P (output_bfd))
3850 relocation += rel->r_addend;
3851 relocation = (relocation & 0x3ff) + ELF64_R_TYPE_DATA (rel->r_info);
3853 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3854 x = (x & ~(bfd_vma) 0x1fff) | (relocation & 0x1fff);
3855 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3857 r = bfd_check_overflow (howto->complain_on_overflow,
3858 howto->bitsize, howto->rightshift,
3859 bfd_arch_bits_per_address (input_bfd),
3862 else if (r_type == R_SPARC_WDISP16)
3866 relocation += rel->r_addend;
3867 relocation -= (input_section->output_section->vma
3868 + input_section->output_offset);
3869 relocation -= rel->r_offset;
3871 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3872 x |= ((((relocation >> 2) & 0xc000) << 6)
3873 | ((relocation >> 2) & 0x3fff));
3874 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3876 r = bfd_check_overflow (howto->complain_on_overflow,
3877 howto->bitsize, howto->rightshift,
3878 bfd_arch_bits_per_address (input_bfd),
3881 else if (r_type == R_SPARC_REV32)
3885 relocation = relocation + rel->r_addend;
3887 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3889 bfd_putl32 (/*input_bfd,*/ x, contents + rel->r_offset);
3892 else if (r_type == R_SPARC_TLS_LDO_HIX22
3893 || r_type == R_SPARC_TLS_LE_HIX22)
3897 relocation += rel->r_addend;
3898 if (r_type == R_SPARC_TLS_LE_HIX22)
3899 relocation ^= MINUS_ONE;
3901 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3902 x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
3903 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3906 else if (r_type == R_SPARC_TLS_LDO_LOX10
3907 || r_type == R_SPARC_TLS_LE_LOX10)
3911 relocation += rel->r_addend;
3912 relocation &= 0x3ff;
3913 if (r_type == R_SPARC_TLS_LE_LOX10)
3914 relocation |= 0x1c00;
3916 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3917 x = (x & ~(bfd_vma) 0x1fff) | relocation;
3918 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3922 else if (r_type == R_SPARC_HIX22
3923 || r_type == R_SPARC_GOTDATA_HIX22)
3927 relocation += rel->r_addend;
3928 if (r_type == R_SPARC_HIX22
3929 || (bfd_signed_vma) relocation < 0)
3930 relocation = relocation ^ MINUS_ONE;
3932 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3933 x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
3934 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3936 r = bfd_check_overflow (howto->complain_on_overflow,
3937 howto->bitsize, howto->rightshift,
3938 bfd_arch_bits_per_address (input_bfd),
3941 else if (r_type == R_SPARC_LOX10
3942 || r_type == R_SPARC_GOTDATA_LOX10)
3946 relocation += rel->r_addend;
3947 if (r_type == R_SPARC_LOX10
3948 || (bfd_signed_vma) relocation < 0)
3949 relocation = (relocation & 0x3ff) | 0x1c00;
3951 relocation = (relocation & 0x3ff);
3953 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3954 x = (x & ~(bfd_vma) 0x1fff) | relocation;
3955 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3959 else if ((r_type == R_SPARC_WDISP30 || r_type == R_SPARC_WPLT30)
3960 && sec_do_relax (input_section)
3961 && rel->r_offset + 4 < input_section->size)
3965 #define XCC (2 << 20)
3966 #define COND(x) (((x)&0xf)<<25)
3967 #define CONDA COND(0x8)
3968 #define INSN_BPA (F2(0,1) | CONDA | BPRED | XCC)
3969 #define INSN_BA (F2(0,2) | CONDA)
3970 #define INSN_OR F3(2, 0x2, 0)
3971 #define INSN_NOP F2(0,4)
3975 /* If the instruction is a call with either:
3977 arithmetic instruction with rd == %o7
3978 where rs1 != %o7 and rs2 if it is register != %o7
3979 then we can optimize if the call destination is near
3980 by changing the call into a branch always. */
3981 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3982 y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
3983 if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2))
3985 if (((y & OP3(~0)) == OP3(0x3d) /* restore */
3986 || ((y & OP3(0x28)) == 0 /* arithmetic */
3987 && (y & RD(~0)) == RD(O7)))
3988 && (y & RS1(~0)) != RS1(O7)
3990 || (y & RS2(~0)) != RS2(O7)))
3994 reloc = relocation + rel->r_addend - rel->r_offset;
3995 reloc -= (input_section->output_section->vma
3996 + input_section->output_offset);
3998 /* Ensure the branch fits into simm22. */
3999 if ((reloc & 3) == 0
4000 && ((reloc & ~(bfd_vma)0x7fffff) == 0
4001 || ((reloc | 0x7fffff) == ~(bfd_vma)0)))
4005 /* Check whether it fits into simm19. */
4006 if (((reloc & 0x3c0000) == 0
4007 || (reloc & 0x3c0000) == 0x3c0000)
4008 && (ABI_64_P (output_bfd)
4009 || elf_elfheader (output_bfd)->e_flags & EF_SPARC_32PLUS))
4010 x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */
4012 x = INSN_BA | (reloc & 0x3fffff); /* ba */
4013 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
4015 if (rel->r_offset >= 4
4016 && (y & (0xffffffff ^ RS1(~0)))
4017 == (INSN_OR | RD(O7) | RS2(G0)))
4022 z = bfd_get_32 (input_bfd,
4023 contents + rel->r_offset - 4);
4024 if ((z & (0xffffffff ^ RD(~0)))
4025 != (INSN_OR | RS1(O7) | RS2(G0)))
4033 If call foo was replaced with ba, replace
4034 or %rN, %g0, %o7 with nop. */
4036 reg = (y & RS1(~0)) >> 14;
4037 if (reg != ((z & RD(~0)) >> 25)
4038 || reg == G0 || reg == O7)
4041 bfd_put_32 (input_bfd, (bfd_vma) INSN_NOP,
4042 contents + rel->r_offset + 4);
4050 if (r == bfd_reloc_continue)
4053 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4054 contents, rel->r_offset,
4055 relocation, rel->r_addend);
4057 if (r != bfd_reloc_ok)
4062 case bfd_reloc_outofrange:
4064 case bfd_reloc_overflow:
4068 /* The Solaris native linker silently disregards overflows.
4069 We don't, but this breaks stabs debugging info, whose
4070 relocations are only 32-bits wide. Ignore overflows in
4071 this case and also for discarded entries. */
4072 if ((r_type == R_SPARC_32
4073 || r_type == R_SPARC_UA32
4074 || r_type == R_SPARC_DISP32)
4075 && (((input_section->flags & SEC_DEBUGGING) != 0
4076 && strcmp (bfd_section_name (input_bfd,
4079 || _bfd_elf_section_offset (output_bfd, info,
4087 /* Assume this is a call protected by other code that
4088 detect the symbol is undefined. If this is the case,
4089 we can safely ignore the overflow. If not, the
4090 program is hosed anyway, and a little warning isn't
4092 if (h->root.type == bfd_link_hash_undefweak
4093 && howto->pc_relative)
4100 name = bfd_elf_string_from_elf_section (input_bfd,
4101 symtab_hdr->sh_link,
4106 name = bfd_section_name (input_bfd, sec);
4108 if (! ((*info->callbacks->reloc_overflow)
4109 (info, (h ? &h->root : NULL), name, howto->name,
4110 (bfd_vma) 0, input_bfd, input_section,
4122 /* Build a VxWorks PLT entry. PLT_INDEX is the index of the PLT entry
4123 and PLT_OFFSET is the byte offset from the start of .plt. GOT_OFFSET
4124 is the offset of the associated .got.plt entry from
4125 _GLOBAL_OFFSET_TABLE_. */
4128 sparc_vxworks_build_plt_entry (bfd *output_bfd, struct bfd_link_info *info,
4129 bfd_vma plt_offset, bfd_vma plt_index,
4133 const bfd_vma *plt_entry;
4134 struct _bfd_sparc_elf_link_hash_table *htab;
4136 Elf_Internal_Rela rela;
4138 htab = _bfd_sparc_elf_hash_table (info);
4139 BFD_ASSERT (htab != NULL);
4143 plt_entry = sparc_vxworks_shared_plt_entry;
4148 plt_entry = sparc_vxworks_exec_plt_entry;
4149 got_base = (htab->elf.hgot->root.u.def.value
4150 + htab->elf.hgot->root.u.def.section->output_offset
4151 + htab->elf.hgot->root.u.def.section->output_section->vma);
4154 /* Fill in the entry in the procedure linkage table. */
4155 bfd_put_32 (output_bfd, plt_entry[0] + ((got_base + got_offset) >> 10),
4156 htab->elf.splt->contents + plt_offset);
4157 bfd_put_32 (output_bfd, plt_entry[1] + ((got_base + got_offset) & 0x3ff),
4158 htab->elf.splt->contents + plt_offset + 4);
4159 bfd_put_32 (output_bfd, plt_entry[2],
4160 htab->elf.splt->contents + plt_offset + 8);
4161 bfd_put_32 (output_bfd, plt_entry[3],
4162 htab->elf.splt->contents + plt_offset + 12);
4163 bfd_put_32 (output_bfd, plt_entry[4],
4164 htab->elf.splt->contents + plt_offset + 16);
4165 bfd_put_32 (output_bfd, plt_entry[5] + (plt_index >> 10),
4166 htab->elf.splt->contents + plt_offset + 20);
4167 /* PC-relative displacement for a branch to the start of
4169 bfd_put_32 (output_bfd, plt_entry[6] + (((-plt_offset - 24) >> 2)
4171 htab->elf.splt->contents + plt_offset + 24);
4172 bfd_put_32 (output_bfd, plt_entry[7] + (plt_index & 0x3ff),
4173 htab->elf.splt->contents + plt_offset + 28);
4175 /* Fill in the .got.plt entry, pointing initially at the
4176 second half of the PLT entry. */
4177 BFD_ASSERT (htab->elf.sgotplt != NULL);
4178 bfd_put_32 (output_bfd,
4179 htab->elf.splt->output_section->vma
4180 + htab->elf.splt->output_offset
4182 htab->elf.sgotplt->contents + got_offset);
4184 /* Add relocations to .rela.plt.unloaded. */
4187 loc = (htab->srelplt2->contents
4188 + (2 + 3 * plt_index) * sizeof (Elf32_External_Rela));
4190 /* Relocate the initial sethi. */
4191 rela.r_offset = (htab->elf.splt->output_section->vma
4192 + htab->elf.splt->output_offset
4194 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4195 rela.r_addend = got_offset;
4196 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4197 loc += sizeof (Elf32_External_Rela);
4199 /* Likewise the following or. */
4201 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4202 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4203 loc += sizeof (Elf32_External_Rela);
4205 /* Relocate the .got.plt entry. */
4206 rela.r_offset = (htab->elf.sgotplt->output_section->vma
4207 + htab->elf.sgotplt->output_offset
4209 rela.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_SPARC_32);
4210 rela.r_addend = plt_offset + 20;
4211 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4215 /* Finish up dynamic symbol handling. We set the contents of various
4216 dynamic sections here. */
4219 _bfd_sparc_elf_finish_dynamic_symbol (bfd *output_bfd,
4220 struct bfd_link_info *info,
4221 struct elf_link_hash_entry *h,
4222 Elf_Internal_Sym *sym)
4224 struct _bfd_sparc_elf_link_hash_table *htab;
4225 const struct elf_backend_data *bed;
4227 htab = _bfd_sparc_elf_hash_table (info);
4228 BFD_ASSERT (htab != NULL);
4229 bed = get_elf_backend_data (output_bfd);
4231 if (h->plt.offset != (bfd_vma) -1)
4235 Elf_Internal_Rela rela;
4237 bfd_vma r_offset, got_offset;
4240 /* When building a static executable, use .iplt and
4241 .rela.iplt sections for STT_GNU_IFUNC symbols. */
4242 if (htab->elf.splt != NULL)
4244 splt = htab->elf.splt;
4245 srela = htab->elf.srelplt;
4249 splt = htab->elf.iplt;
4250 srela = htab->elf.irelplt;
4253 if (splt == NULL || srela == NULL)
4256 /* Fill in the entry in the .rela.plt section. */
4257 if (htab->is_vxworks)
4259 /* Work out the index of this PLT entry. */
4260 rela_index = ((h->plt.offset - htab->plt_header_size)
4261 / htab->plt_entry_size);
4263 /* Calculate the offset of the associated .got.plt entry.
4264 The first three entries are reserved. */
4265 got_offset = (rela_index + 3) * 4;
4267 sparc_vxworks_build_plt_entry (output_bfd, info, h->plt.offset,
4268 rela_index, got_offset);
4271 /* On VxWorks, the relocation points to the .got.plt entry,
4272 not the .plt entry. */
4273 rela.r_offset = (htab->elf.sgotplt->output_section->vma
4274 + htab->elf.sgotplt->output_offset
4277 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx,
4282 bfd_boolean ifunc = FALSE;
4284 /* Fill in the entry in the procedure linkage table. */
4285 rela_index = SPARC_ELF_BUILD_PLT_ENTRY (htab, output_bfd, splt,
4286 h->plt.offset, splt->size,
4291 || ((info->executable
4292 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
4294 && h->type == STT_GNU_IFUNC))
4297 BFD_ASSERT (h == NULL
4298 || (h->type == STT_GNU_IFUNC
4300 && (h->root.type == bfd_link_hash_defined
4301 || h->root.type == bfd_link_hash_defweak)));
4304 rela.r_offset = r_offset
4305 + (splt->output_section->vma + splt->output_offset);
4306 if (ABI_64_P (output_bfd)
4307 && h->plt.offset >= (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE))
4311 rela.r_addend = (h->root.u.def.section->output_section->vma
4312 + h->root.u.def.section->output_offset
4313 + h->root.u.def.value);
4314 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0,
4319 rela.r_addend = (-(h->plt.offset + 4)
4320 - splt->output_section->vma
4321 - splt->output_offset);
4322 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx,
4330 rela.r_addend = (h->root.u.def.section->output_section->vma
4331 + h->root.u.def.section->output_offset
4332 + h->root.u.def.value);
4333 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0,
4339 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx,
4345 /* Adjust for the first 4 reserved elements in the .plt section
4346 when setting the offset in the .rela.plt section.
4347 Sun forgot to read their own ABI and copied elf32-sparc behaviour,
4348 thus .plt[4] has corresponding .rela.plt[0] and so on. */
4350 loc = srela->contents;
4351 loc += rela_index * bed->s->sizeof_rela;
4352 bed->s->swap_reloca_out (output_bfd, &rela, loc);
4354 if (!h->def_regular)
4356 /* Mark the symbol as undefined, rather than as defined in
4357 the .plt section. Leave the value alone. */
4358 sym->st_shndx = SHN_UNDEF;
4359 /* If the symbol is weak, we do need to clear the value.
4360 Otherwise, the PLT entry would provide a definition for
4361 the symbol even if the symbol wasn't defined anywhere,
4362 and so the symbol would never be NULL. */
4363 if (!h->ref_regular_nonweak)
4368 if (h->got.offset != (bfd_vma) -1
4369 && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_GD
4370 && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_IE)
4374 Elf_Internal_Rela rela;
4376 /* This symbol has an entry in the GOT. Set it up. */
4378 sgot = htab->elf.sgot;
4379 srela = htab->elf.srelgot;
4380 BFD_ASSERT (sgot != NULL && srela != NULL);
4382 rela.r_offset = (sgot->output_section->vma
4383 + sgot->output_offset
4384 + (h->got.offset &~ (bfd_vma) 1));
4386 /* If this is a -Bsymbolic link, and the symbol is defined
4387 locally, we just want to emit a RELATIVE reloc. Likewise if
4388 the symbol was forced to be local because of a version file.
4389 The entry in the global offset table will already have been
4390 initialized in the relocate_section function. */
4392 && h->type == STT_GNU_IFUNC
4397 /* We load the GOT entry with the PLT entry. */
4398 plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
4399 SPARC_ELF_PUT_WORD (htab, output_bfd,
4400 (plt->output_section->vma
4401 + plt->output_offset + h->plt.offset),
4402 htab->elf.sgot->contents
4403 + (h->got.offset & ~(bfd_vma) 1));
4406 else if (info->shared
4407 && SYMBOL_REFERENCES_LOCAL (info, h))
4409 asection *sec = h->root.u.def.section;
4410 if (h->type == STT_GNU_IFUNC)
4411 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, R_SPARC_IRELATIVE);
4413 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, R_SPARC_RELATIVE);
4414 rela.r_addend = (h->root.u.def.value
4415 + sec->output_section->vma
4416 + sec->output_offset);
4420 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_GLOB_DAT);
4424 SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
4425 sgot->contents + (h->got.offset & ~(bfd_vma) 1));
4426 sparc_elf_append_rela (output_bfd, srela, &rela);
4432 Elf_Internal_Rela rela;
4434 /* This symbols needs a copy reloc. Set it up. */
4435 BFD_ASSERT (h->dynindx != -1);
4437 s = bfd_get_section_by_name (h->root.u.def.section->owner,
4439 BFD_ASSERT (s != NULL);
4441 rela.r_offset = (h->root.u.def.value
4442 + h->root.u.def.section->output_section->vma
4443 + h->root.u.def.section->output_offset);
4444 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_COPY);
4446 sparc_elf_append_rela (output_bfd, s, &rela);
4449 /* Mark some specially defined symbols as absolute. On VxWorks,
4450 _GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the
4451 ".got" section. Likewise _PROCEDURE_LINKAGE_TABLE_ and ".plt". */
4453 && (strcmp (h->root.root.string, "_DYNAMIC") == 0
4454 || (!htab->is_vxworks
4455 && (h == htab->elf.hgot || h == htab->elf.hplt))))
4456 sym->st_shndx = SHN_ABS;
4461 /* Finish up the dynamic sections. */
4464 sparc_finish_dyn (bfd *output_bfd, struct bfd_link_info *info,
4465 bfd *dynobj, asection *sdyn,
4466 asection *splt ATTRIBUTE_UNUSED)
4468 struct _bfd_sparc_elf_link_hash_table *htab;
4469 const struct elf_backend_data *bed;
4470 bfd_byte *dyncon, *dynconend;
4472 int stt_regidx = -1;
4473 bfd_boolean abi_64_p;
4475 htab = _bfd_sparc_elf_hash_table (info);
4476 BFD_ASSERT (htab != NULL);
4477 bed = get_elf_backend_data (output_bfd);
4478 dynsize = bed->s->sizeof_dyn;
4479 dynconend = sdyn->contents + sdyn->size;
4480 abi_64_p = ABI_64_P (output_bfd);
4481 for (dyncon = sdyn->contents; dyncon < dynconend; dyncon += dynsize)
4483 Elf_Internal_Dyn dyn;
4487 bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
4489 if (htab->is_vxworks && dyn.d_tag == DT_RELASZ)
4491 /* On VxWorks, DT_RELASZ should not include the relocations
4493 if (htab->elf.srelplt)
4495 dyn.d_un.d_val -= htab->elf.srelplt->size;
4496 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4499 else if (htab->is_vxworks && dyn.d_tag == DT_PLTGOT)
4501 /* On VxWorks, DT_PLTGOT should point to the start of the GOT,
4502 not to the start of the PLT. */
4503 if (htab->elf.sgotplt)
4505 dyn.d_un.d_val = (htab->elf.sgotplt->output_section->vma
4506 + htab->elf.sgotplt->output_offset);
4507 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4510 else if (htab->is_vxworks
4511 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
4512 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4513 else if (abi_64_p && dyn.d_tag == DT_SPARC_REGISTER)
4515 if (stt_regidx == -1)
4518 _bfd_elf_link_lookup_local_dynindx (info, output_bfd, -1);
4519 if (stt_regidx == -1)
4522 dyn.d_un.d_val = stt_regidx++;
4523 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4529 case DT_PLTGOT: name = ".plt"; size = FALSE; break;
4530 case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break;
4531 case DT_JMPREL: name = ".rela.plt"; size = FALSE; break;
4532 default: name = NULL; size = FALSE; break;
4539 s = bfd_get_section_by_name (output_bfd, name);
4545 dyn.d_un.d_ptr = s->vma;
4547 dyn.d_un.d_val = s->size;
4549 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4556 /* Install the first PLT entry in a VxWorks executable and make sure that
4557 .rela.plt.unloaded relocations have the correct symbol indexes. */
4560 sparc_vxworks_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info)
4562 struct _bfd_sparc_elf_link_hash_table *htab;
4563 Elf_Internal_Rela rela;
4567 htab = _bfd_sparc_elf_hash_table (info);
4568 BFD_ASSERT (htab != NULL);
4570 /* Calculate the absolute value of _GLOBAL_OFFSET_TABLE_. */
4571 got_base = (htab->elf.hgot->root.u.def.section->output_section->vma
4572 + htab->elf.hgot->root.u.def.section->output_offset
4573 + htab->elf.hgot->root.u.def.value);
4575 /* Install the initial PLT entry. */
4576 bfd_put_32 (output_bfd,
4577 sparc_vxworks_exec_plt0_entry[0] + ((got_base + 8) >> 10),
4578 htab->elf.splt->contents);
4579 bfd_put_32 (output_bfd,
4580 sparc_vxworks_exec_plt0_entry[1] + ((got_base + 8) & 0x3ff),
4581 htab->elf.splt->contents + 4);
4582 bfd_put_32 (output_bfd,
4583 sparc_vxworks_exec_plt0_entry[2],
4584 htab->elf.splt->contents + 8);
4585 bfd_put_32 (output_bfd,
4586 sparc_vxworks_exec_plt0_entry[3],
4587 htab->elf.splt->contents + 12);
4588 bfd_put_32 (output_bfd,
4589 sparc_vxworks_exec_plt0_entry[4],
4590 htab->elf.splt->contents + 16);
4592 loc = htab->srelplt2->contents;
4594 /* Add an unloaded relocation for the initial entry's "sethi". */
4595 rela.r_offset = (htab->elf.splt->output_section->vma
4596 + htab->elf.splt->output_offset);
4597 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4599 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4600 loc += sizeof (Elf32_External_Rela);
4602 /* Likewise the following "or". */
4604 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4605 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4606 loc += sizeof (Elf32_External_Rela);
4608 /* Fix up the remaining .rela.plt.unloaded relocations. They may have
4609 the wrong symbol index for _G_O_T_ or _P_L_T_ depending on the order
4610 in which symbols were output. */
4611 while (loc < htab->srelplt2->contents + htab->srelplt2->size)
4613 Elf_Internal_Rela rel;
4615 /* The entry's initial "sethi" (against _G_O_T_). */
4616 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4617 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4618 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4619 loc += sizeof (Elf32_External_Rela);
4621 /* The following "or" (also against _G_O_T_). */
4622 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4623 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4624 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4625 loc += sizeof (Elf32_External_Rela);
4627 /* The .got.plt entry (against _P_L_T_). */
4628 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4629 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_SPARC_32);
4630 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4631 loc += sizeof (Elf32_External_Rela);
4635 /* Install the first PLT entry in a VxWorks shared object. */
4638 sparc_vxworks_finish_shared_plt (bfd *output_bfd, struct bfd_link_info *info)
4640 struct _bfd_sparc_elf_link_hash_table *htab;
4643 htab = _bfd_sparc_elf_hash_table (info);
4644 BFD_ASSERT (htab != NULL);
4646 for (i = 0; i < ARRAY_SIZE (sparc_vxworks_shared_plt0_entry); i++)
4647 bfd_put_32 (output_bfd, sparc_vxworks_shared_plt0_entry[i],
4648 htab->elf.splt->contents + i * 4);
4651 /* Finish up local dynamic symbol handling. We set the contents of
4652 various dynamic sections here. */
4655 finish_local_dynamic_symbol (void **slot, void *inf)
4657 struct elf_link_hash_entry *h
4658 = (struct elf_link_hash_entry *) *slot;
4659 struct bfd_link_info *info
4660 = (struct bfd_link_info *) inf;
4662 return _bfd_sparc_elf_finish_dynamic_symbol (info->output_bfd, info,
4667 _bfd_sparc_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
4671 struct _bfd_sparc_elf_link_hash_table *htab;
4673 htab = _bfd_sparc_elf_hash_table (info);
4674 BFD_ASSERT (htab != NULL);
4675 dynobj = htab->elf.dynobj;
4677 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4679 if (elf_hash_table (info)->dynamic_sections_created)
4683 splt = bfd_get_section_by_name (dynobj, ".plt");
4684 BFD_ASSERT (splt != NULL && sdyn != NULL);
4686 if (!sparc_finish_dyn (output_bfd, info, dynobj, sdyn, splt))
4689 /* Initialize the contents of the .plt section. */
4692 if (htab->is_vxworks)
4695 sparc_vxworks_finish_shared_plt (output_bfd, info);
4697 sparc_vxworks_finish_exec_plt (output_bfd, info);
4701 memset (splt->contents, 0, htab->plt_header_size);
4702 if (!ABI_64_P (output_bfd))
4703 bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP,
4704 splt->contents + splt->size - 4);
4708 elf_section_data (splt->output_section)->this_hdr.sh_entsize
4709 = (htab->is_vxworks || !ABI_64_P (output_bfd))
4710 ? 0 : htab->plt_entry_size;
4713 /* Set the first entry in the global offset table to the address of
4714 the dynamic section. */
4715 if (htab->elf.sgot && htab->elf.sgot->size > 0)
4717 bfd_vma val = (sdyn ?
4718 sdyn->output_section->vma + sdyn->output_offset :
4721 SPARC_ELF_PUT_WORD (htab, output_bfd, val, htab->elf.sgot->contents);
4725 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize =
4726 SPARC_ELF_WORD_BYTES (htab);
4728 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
4729 htab_traverse (htab->loc_hash_table, finish_local_dynamic_symbol, info);
4735 /* Set the right machine number for a SPARC ELF file. */
4738 _bfd_sparc_elf_object_p (bfd *abfd)
4740 if (ABI_64_P (abfd))
4742 unsigned long mach = bfd_mach_sparc_v9;
4744 if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
4745 mach = bfd_mach_sparc_v9b;
4746 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
4747 mach = bfd_mach_sparc_v9a;
4748 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, mach);
4752 if (elf_elfheader (abfd)->e_machine == EM_SPARC32PLUS)
4754 if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
4755 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4756 bfd_mach_sparc_v8plusb);
4757 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
4758 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4759 bfd_mach_sparc_v8plusa);
4760 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_32PLUS)
4761 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4762 bfd_mach_sparc_v8plus);
4766 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_LEDATA)
4767 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4768 bfd_mach_sparc_sparclite_le);
4770 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc);
4774 /* Return address for Ith PLT stub in section PLT, for relocation REL
4775 or (bfd_vma) -1 if it should not be included. */
4778 _bfd_sparc_elf_plt_sym_val (bfd_vma i, const asection *plt, const arelent *rel)
4780 if (ABI_64_P (plt->owner))
4784 i += PLT64_HEADER_SIZE / PLT64_ENTRY_SIZE;
4785 if (i < PLT64_LARGE_THRESHOLD)
4786 return plt->vma + i * PLT64_ENTRY_SIZE;
4788 j = (i - PLT64_LARGE_THRESHOLD) % 160;
4790 return plt->vma + i * PLT64_ENTRY_SIZE + j * 4 * 6;
4793 return rel->address;
4796 /* Merge backend specific data from an object file to the output
4797 object file when linking. */
4800 _bfd_sparc_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
4802 obj_attribute *in_attr, *in_attrs;
4803 obj_attribute *out_attr, *out_attrs;
4805 if (!elf_known_obj_attributes_proc (obfd)[0].i)
4807 /* This is the first object. Copy the attributes. */
4808 _bfd_elf_copy_obj_attributes (ibfd, obfd);
4810 /* Use the Tag_null value to indicate the attributes have been
4812 elf_known_obj_attributes_proc (obfd)[0].i = 1;
4817 in_attrs = elf_known_obj_attributes (ibfd)[OBJ_ATTR_GNU];
4818 out_attrs = elf_known_obj_attributes (obfd)[OBJ_ATTR_GNU];
4820 in_attr = &in_attrs[Tag_GNU_Sparc_HWCAPS];
4821 out_attr = &out_attrs[Tag_GNU_Sparc_HWCAPS];
4823 out_attr->i |= in_attr->i;
4825 /* Merge Tag_compatibility attributes and any common GNU ones. */
4826 _bfd_elf_merge_object_attributes (ibfd, obfd);