projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* elf-m10300.c (_bfd_mn10300_elf_adjust_dynamic_symbol): Don't error
[deliverable/binutils-gdb.git] / bfd / elfxx-sparc.c
1 /* SPARC-specific support for ELF
2 Copyright 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
3 Free Software Foundation, Inc.
4
5 This file is part of BFD, the Binary File Descriptor library.
6
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.
11
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.
16
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. */
21
22
23 /* This file handles functionality common to the different SPARC ABI's. */
24
25 #include "sysdep.h"
26 #include "bfd.h"
27 #include "bfdlink.h"
28 #include "libbfd.h"
29 #include "libiberty.h"
30 #include "elf-bfd.h"
31 #include "elf/sparc.h"
32 #include "opcode/sparc.h"
33 #include "elfxx-sparc.h"
34 #include "elf-vxworks.h"
35 #include "objalloc.h"
36 #include "hashtab.h"
37
38 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
39 #define MINUS_ONE (~ (bfd_vma) 0)
40
41 #define ABI_64_P(abfd) \
42 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
43
44 /* The relocation "howto" table. */
45
46 /* Utility for performing the standard initial work of an instruction
47 relocation.
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. */
53
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)
58 {
59 bfd_vma relocation;
60 reloc_howto_type *howto = reloc_entry->howto;
61
62 if (output_bfd != (bfd *) NULL
63 && (symbol->flags & BSF_SECTION_SYM) == 0
64 && (! howto->partial_inplace
65 || reloc_entry->addend == 0))
66 {
67 reloc_entry->address += input_section->output_offset;
68 return bfd_reloc_ok;
69 }
70
71 /* This works because partial_inplace is FALSE. */
72 if (output_bfd != NULL)
73 return bfd_reloc_continue;
74
75 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
76 return bfd_reloc_outofrange;
77
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)
83 {
84 relocation -= (input_section->output_section->vma
85 + input_section->output_offset);
86 relocation -= reloc_entry->address;
87 }
88
89 *prelocation = relocation;
90 *pinsn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
91 return bfd_reloc_other;
92 }
93
94 /* For unsupported relocs. */
95
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)
104 {
105 return bfd_reloc_notsupported;
106 }
107
108 /* Handle the WDISP16 reloc. */
109
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)
114 {
115 bfd_vma relocation;
116 bfd_vma insn;
117 bfd_reloc_status_type status;
118
119 status = init_insn_reloc (abfd, reloc_entry, symbol, data,
120 input_section, output_bfd, &relocation, &insn);
121 if (status != bfd_reloc_other)
122 return status;
123
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);
127
128 if ((bfd_signed_vma) relocation < - 0x40000
129 || (bfd_signed_vma) relocation > 0x3ffff)
130 return bfd_reloc_overflow;
131 else
132 return bfd_reloc_ok;
133 }
134
135 /* Handle the HIX22 reloc. */
136
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)
141 {
142 bfd_vma relocation;
143 bfd_vma insn;
144 bfd_reloc_status_type status;
145
146 status = init_insn_reloc (abfd, reloc_entry, symbol, data,
147 input_section, output_bfd, &relocation, &insn);
148 if (status != bfd_reloc_other)
149 return status;
150
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);
154
155 if ((relocation & ~ (bfd_vma) 0xffffffff) != 0)
156 return bfd_reloc_overflow;
157 else
158 return bfd_reloc_ok;
159 }
160
161 /* Handle the LOX10 reloc. */
162
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)
167 {
168 bfd_vma relocation;
169 bfd_vma insn;
170 bfd_reloc_status_type status;
171
172 status = init_insn_reloc (abfd, reloc_entry, symbol, data,
173 input_section, output_bfd, &relocation, &insn);
174 if (status != bfd_reloc_other)
175 return status;
176
177 insn = (insn &~ (bfd_vma) 0x1fff) | 0x1c00 | (relocation & 0x3ff);
178 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
179
180 return bfd_reloc_ok;
181 }
182
183 static reloc_howto_type _bfd_sparc_elf_howto_table[] =
184 {
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),
270 };
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);
281
282 reloc_howto_type *
283 _bfd_sparc_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
284 bfd_reloc_code_real_type code)
285 {
286 /* We explicitly handle each relocation type in the switch
287 instead of using a lookup table for efficiency. */
288 switch (code)
289 {
290 case BFD_RELOC_NONE:
291 return &_bfd_sparc_elf_howto_table[R_SPARC_NONE];
292
293 case BFD_RELOC_8:
294 return &_bfd_sparc_elf_howto_table[R_SPARC_8];
295
296 case BFD_RELOC_16:
297 return &_bfd_sparc_elf_howto_table[R_SPARC_16];
298
299 case BFD_RELOC_32:
300 return &_bfd_sparc_elf_howto_table[R_SPARC_32];
301
302 case BFD_RELOC_8_PCREL:
303 return &_bfd_sparc_elf_howto_table[R_SPARC_DISP8];
304
305 case BFD_RELOC_16_PCREL:
306 return &_bfd_sparc_elf_howto_table[R_SPARC_DISP16];
307
308 case BFD_RELOC_32_PCREL:
309 return &_bfd_sparc_elf_howto_table[R_SPARC_DISP32];
310
311 case BFD_RELOC_32_PCREL_S2:
312 return &_bfd_sparc_elf_howto_table[R_SPARC_WDISP30];
313
314 case BFD_RELOC_SPARC_WDISP22:
315 return &_bfd_sparc_elf_howto_table[R_SPARC_WDISP22];
316
317 case BFD_RELOC_HI22:
318 return &_bfd_sparc_elf_howto_table[R_SPARC_HI22];
319
320 case BFD_RELOC_SPARC22:
321 return &_bfd_sparc_elf_howto_table[R_SPARC_22];
322
323 case BFD_RELOC_SPARC13:
324 return &_bfd_sparc_elf_howto_table[R_SPARC_13];
325
326 case BFD_RELOC_LO10:
327 return &_bfd_sparc_elf_howto_table[R_SPARC_LO10];
328
329 case BFD_RELOC_SPARC_GOT10:
330 return &_bfd_sparc_elf_howto_table[R_SPARC_GOT10];
331
332 case BFD_RELOC_SPARC_GOT13:
333 return &_bfd_sparc_elf_howto_table[R_SPARC_GOT13];
334
335 case BFD_RELOC_SPARC_GOT22:
336 return &_bfd_sparc_elf_howto_table[R_SPARC_GOT22];
337
338 case BFD_RELOC_SPARC_PC10:
339 return &_bfd_sparc_elf_howto_table[R_SPARC_PC10];
340
341 case BFD_RELOC_SPARC_PC22:
342 return &_bfd_sparc_elf_howto_table[R_SPARC_PC22];
343
344 case BFD_RELOC_SPARC_WPLT30:
345 return &_bfd_sparc_elf_howto_table[R_SPARC_WPLT30];
346
347 case BFD_RELOC_SPARC_COPY:
348 return &_bfd_sparc_elf_howto_table[R_SPARC_COPY];
349
350 case BFD_RELOC_SPARC_GLOB_DAT:
351 return &_bfd_sparc_elf_howto_table[R_SPARC_GLOB_DAT];
352
353 case BFD_RELOC_SPARC_JMP_SLOT:
354 return &_bfd_sparc_elf_howto_table[R_SPARC_JMP_SLOT];
355
356 case BFD_RELOC_SPARC_RELATIVE:
357 return &_bfd_sparc_elf_howto_table[R_SPARC_RELATIVE];
358
359 case BFD_RELOC_SPARC_UA32:
360 return &_bfd_sparc_elf_howto_table[R_SPARC_UA32];
361
362 case BFD_RELOC_SPARC_PLT32:
363 return &_bfd_sparc_elf_howto_table[R_SPARC_PLT32];
364
365 case BFD_RELOC_SPARC_10:
366 return &_bfd_sparc_elf_howto_table[R_SPARC_10];
367
368 case BFD_RELOC_SPARC_11:
369 return &_bfd_sparc_elf_howto_table[R_SPARC_11];
370
371 case BFD_RELOC_SPARC_64:
372 return &_bfd_sparc_elf_howto_table[R_SPARC_64];
373
374 case BFD_RELOC_SPARC_OLO10:
375 return &_bfd_sparc_elf_howto_table[R_SPARC_OLO10];
376
377 case BFD_RELOC_SPARC_HH22:
378 return &_bfd_sparc_elf_howto_table[R_SPARC_HH22];
379
380 case BFD_RELOC_SPARC_HM10:
381 return &_bfd_sparc_elf_howto_table[R_SPARC_HM10];
382
383 case BFD_RELOC_SPARC_LM22:
384 return &_bfd_sparc_elf_howto_table[R_SPARC_LM22];
385
386 case BFD_RELOC_SPARC_PC_HH22:
387 return &_bfd_sparc_elf_howto_table[R_SPARC_PC_HH22];
388
389 case BFD_RELOC_SPARC_PC_HM10:
390 return &_bfd_sparc_elf_howto_table[R_SPARC_PC_HM10];
391
392 case BFD_RELOC_SPARC_PC_LM22:
393 return &_bfd_sparc_elf_howto_table[R_SPARC_PC_LM22];
394
395 case BFD_RELOC_SPARC_WDISP16:
396 return &_bfd_sparc_elf_howto_table[R_SPARC_WDISP16];
397
398 case BFD_RELOC_SPARC_WDISP19:
399 return &_bfd_sparc_elf_howto_table[R_SPARC_WDISP19];
400
401 case BFD_RELOC_SPARC_7:
402 return &_bfd_sparc_elf_howto_table[R_SPARC_7];
403
404 case BFD_RELOC_SPARC_5:
405 return &_bfd_sparc_elf_howto_table[R_SPARC_5];
406
407 case BFD_RELOC_SPARC_6:
408 return &_bfd_sparc_elf_howto_table[R_SPARC_6];
409
410 case BFD_RELOC_SPARC_DISP64:
411 return &_bfd_sparc_elf_howto_table[R_SPARC_DISP64];
412
413 case BFD_RELOC_SPARC_PLT64:
414 return &_bfd_sparc_elf_howto_table[R_SPARC_PLT64];
415
416 case BFD_RELOC_SPARC_HIX22:
417 return &_bfd_sparc_elf_howto_table[R_SPARC_HIX22];
418
419 case BFD_RELOC_SPARC_LOX10:
420 return &_bfd_sparc_elf_howto_table[R_SPARC_LOX10];
421
422 case BFD_RELOC_SPARC_H44:
423 return &_bfd_sparc_elf_howto_table[R_SPARC_H44];
424
425 case BFD_RELOC_SPARC_M44:
426 return &_bfd_sparc_elf_howto_table[R_SPARC_M44];
427
428 case BFD_RELOC_SPARC_L44:
429 return &_bfd_sparc_elf_howto_table[R_SPARC_L44];
430
431 case BFD_RELOC_SPARC_REGISTER:
432 return &_bfd_sparc_elf_howto_table[R_SPARC_REGISTER];
433
434 case BFD_RELOC_SPARC_UA64:
435 return &_bfd_sparc_elf_howto_table[R_SPARC_UA64];
436
437 case BFD_RELOC_SPARC_UA16:
438 return &_bfd_sparc_elf_howto_table[R_SPARC_UA16];
439
440 case BFD_RELOC_SPARC_TLS_GD_HI22:
441 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_GD_HI22];
442
443 case BFD_RELOC_SPARC_TLS_GD_LO10:
444 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_GD_LO10];
445
446 case BFD_RELOC_SPARC_TLS_GD_ADD:
447 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_GD_ADD];
448
449 case BFD_RELOC_SPARC_TLS_GD_CALL:
450 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_GD_CALL];
451
452 case BFD_RELOC_SPARC_TLS_LDM_HI22:
453 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDM_HI22];
454
455 case BFD_RELOC_SPARC_TLS_LDM_LO10:
456 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDM_LO10];
457
458 case BFD_RELOC_SPARC_TLS_LDM_ADD:
459 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDM_ADD];
460
461 case BFD_RELOC_SPARC_TLS_LDM_CALL:
462 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDM_CALL];
463
464 case BFD_RELOC_SPARC_TLS_LDO_HIX22:
465 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDO_HIX22];
466
467 case BFD_RELOC_SPARC_TLS_LDO_LOX10:
468 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDO_LOX10];
469
470 case BFD_RELOC_SPARC_TLS_LDO_ADD:
471 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDO_ADD];
472
473 case BFD_RELOC_SPARC_TLS_IE_HI22:
474 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_IE_HI22];
475
476 case BFD_RELOC_SPARC_TLS_IE_LO10:
477 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_IE_LO10];
478
479 case BFD_RELOC_SPARC_TLS_IE_LD:
480 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_IE_LD];
481
482 case BFD_RELOC_SPARC_TLS_IE_LDX:
483 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_IE_LDX];
484
485 case BFD_RELOC_SPARC_TLS_IE_ADD:
486 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_IE_ADD];
487
488 case BFD_RELOC_SPARC_TLS_LE_HIX22:
489 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LE_HIX22];
490
491 case BFD_RELOC_SPARC_TLS_LE_LOX10:
492 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LE_LOX10];
493
494 case BFD_RELOC_SPARC_TLS_DTPMOD32:
495 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_DTPMOD32];
496
497 case BFD_RELOC_SPARC_TLS_DTPMOD64:
498 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_DTPMOD64];
499
500 case BFD_RELOC_SPARC_TLS_DTPOFF32:
501 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_DTPOFF32];
502
503 case BFD_RELOC_SPARC_TLS_DTPOFF64:
504 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_DTPOFF64];
505
506 case BFD_RELOC_SPARC_TLS_TPOFF32:
507 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_TPOFF32];
508
509 case BFD_RELOC_SPARC_TLS_TPOFF64:
510 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_TPOFF64];
511
512 case BFD_RELOC_SPARC_GOTDATA_HIX22:
513 return &_bfd_sparc_elf_howto_table[R_SPARC_GOTDATA_HIX22];
514
515 case BFD_RELOC_SPARC_GOTDATA_LOX10:
516 return &_bfd_sparc_elf_howto_table[R_SPARC_GOTDATA_LOX10];
517
518 case BFD_RELOC_SPARC_GOTDATA_OP_HIX22:
519 return &_bfd_sparc_elf_howto_table[R_SPARC_GOTDATA_OP_HIX22];
520
521 case BFD_RELOC_SPARC_GOTDATA_OP_LOX10:
522 return &_bfd_sparc_elf_howto_table[R_SPARC_GOTDATA_OP_LOX10];
523
524 case BFD_RELOC_SPARC_GOTDATA_OP:
525 return &_bfd_sparc_elf_howto_table[R_SPARC_GOTDATA_OP];
526
527 case BFD_RELOC_SPARC_JMP_IREL:
528 return &sparc_jmp_irel_howto;
529
530 case BFD_RELOC_SPARC_IRELATIVE:
531 return &sparc_irelative_howto;
532
533 case BFD_RELOC_VTABLE_INHERIT:
534 return &sparc_vtinherit_howto;
535
536 case BFD_RELOC_VTABLE_ENTRY:
537 return &sparc_vtentry_howto;
538
539 case BFD_RELOC_SPARC_REV32:
540 return &sparc_rev32_howto;
541
542 default:
543 break;
544 }
545 bfd_set_error (bfd_error_bad_value);
546 return NULL;
547 }
548
549 reloc_howto_type *
550 _bfd_sparc_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
551 const char *r_name)
552 {
553 unsigned int i;
554
555 for (i = 0;
556 i < (sizeof (_bfd_sparc_elf_howto_table)
557 / sizeof (_bfd_sparc_elf_howto_table[0]));
558 i++)
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];
562
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;
569
570 return NULL;
571 }
572
573 reloc_howto_type *
574 _bfd_sparc_elf_info_to_howto_ptr (unsigned int r_type)
575 {
576 switch (r_type)
577 {
578 case R_SPARC_JMP_IREL:
579 return &sparc_jmp_irel_howto;
580
581 case R_SPARC_IRELATIVE:
582 return &sparc_irelative_howto;
583
584 case R_SPARC_GNU_VTINHERIT:
585 return &sparc_vtinherit_howto;
586
587 case R_SPARC_GNU_VTENTRY:
588 return &sparc_vtentry_howto;
589
590 case R_SPARC_REV32:
591 return &sparc_rev32_howto;
592
593 default:
594 if (r_type >= (unsigned int) R_SPARC_max_std)
595 {
596 (*_bfd_error_handler) (_("invalid relocation type %d"),
597 (int) r_type);
598 r_type = R_SPARC_NONE;
599 }
600 return &_bfd_sparc_elf_howto_table[r_type];
601 }
602 }
603
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) \
607 ((r_info) & 0xff)
608
609 void
610 _bfd_sparc_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
611 Elf_Internal_Rela *dst)
612 {
613 unsigned int r_type = SPARC_ELF_R_TYPE (dst->r_info);
614
615 cache_ptr->howto = _bfd_sparc_elf_info_to_howto_ptr (r_type);
616 }
617 \f
618
619 /* The nop opcode we use. */
620 #define SPARC_NOP 0x01000000
621
622 #define SPARC_INSN_BYTES 4
623
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. */
629
630 struct _bfd_sparc_elf_dyn_relocs
631 {
632 struct _bfd_sparc_elf_dyn_relocs *next;
633
634 /* The input section of the reloc. */
635 asection *sec;
636
637 /* Total number of relocs copied for the input section. */
638 bfd_size_type count;
639
640 /* Number of pc-relative relocs copied for the input section. */
641 bfd_size_type pc_count;
642 };
643
644 /* SPARC ELF linker hash entry. */
645
646 struct _bfd_sparc_elf_link_hash_entry
647 {
648 struct elf_link_hash_entry elf;
649
650 /* Track dynamic relocs copied for this symbol. */
651 struct _bfd_sparc_elf_dyn_relocs *dyn_relocs;
652
653 #define GOT_UNKNOWN 0
654 #define GOT_NORMAL 1
655 #define GOT_TLS_GD 2
656 #define GOT_TLS_IE 3
657 unsigned char tls_type;
658 };
659
660 #define _bfd_sparc_elf_hash_entry(ent) ((struct _bfd_sparc_elf_link_hash_entry *)(ent))
661
662 struct _bfd_sparc_elf_obj_tdata
663 {
664 struct elf_obj_tdata root;
665
666 /* tls_type for each local got entry. */
667 char *local_got_tls_type;
668
669 /* TRUE if TLS GD relocs has been seen for this object. */
670 bfd_boolean has_tlsgd;
671 };
672
673 #define _bfd_sparc_elf_tdata(abfd) \
674 ((struct _bfd_sparc_elf_obj_tdata *) (abfd)->tdata.any)
675
676 #define _bfd_sparc_elf_local_got_tls_type(abfd) \
677 (_bfd_sparc_elf_tdata (abfd)->local_got_tls_type)
678
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)
683
684 bfd_boolean
685 _bfd_sparc_elf_mkobject (bfd *abfd)
686 {
687 return bfd_elf_allocate_object (abfd, sizeof (struct _bfd_sparc_elf_obj_tdata),
688 SPARC_ELF_DATA);
689 }
690
691 static void
692 sparc_put_word_32 (bfd *abfd, bfd_vma val, void *ptr)
693 {
694 bfd_put_32 (abfd, val, ptr);
695 }
696
697 static void
698 sparc_put_word_64 (bfd *abfd, bfd_vma val, void *ptr)
699 {
700 bfd_put_64 (abfd, val, ptr);
701 }
702
703 static void
704 sparc_elf_append_rela (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
705 {
706 const struct elf_backend_data *bed;
707 bfd_byte *loc;
708
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);
712 }
713
714 static bfd_vma
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)
718 {
719 return ELF64_R_INFO (rel_index,
720 (in_rel ?
721 ELF64_R_TYPE_INFO (ELF64_R_TYPE_DATA (in_rel->r_info),
722 type) : type));
723 }
724
725 static bfd_vma
726 sparc_elf_r_info_32 (Elf_Internal_Rela *in_rel ATTRIBUTE_UNUSED,
727 bfd_vma rel_index, bfd_vma type)
728 {
729 return ELF32_R_INFO (rel_index, type);
730 }
731
732 static bfd_vma
733 sparc_elf_r_symndx_64 (bfd_vma r_info)
734 {
735 bfd_vma r_symndx = ELF32_R_SYM (r_info);
736 return (r_symndx >> 24);
737 }
738
739 static bfd_vma
740 sparc_elf_r_symndx_32 (bfd_vma r_info)
741 {
742 return ELF32_R_SYM (r_info);
743 }
744
745 /* PLT/GOT stuff */
746
747 #define PLT32_ENTRY_SIZE 12
748 #define PLT32_HEADER_SIZE (4 * PLT32_ENTRY_SIZE)
749
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. */
754
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
759 /* nop. */
760 #define PLT32_ENTRY_WORD2 SPARC_NOP
761
762 static int
763 sparc32_plt_entry_build (bfd *output_bfd, asection *splt, bfd_vma offset,
764 bfd_vma max ATTRIBUTE_UNUSED,
765 bfd_vma *r_offset)
766 {
767 bfd_put_32 (output_bfd,
768 PLT32_ENTRY_WORD0 + offset,
769 splt->contents + offset);
770 bfd_put_32 (output_bfd,
771 (PLT32_ENTRY_WORD1
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);
776
777 *r_offset = offset;
778
779 return offset / PLT32_ENTRY_SIZE - 4;
780 }
781
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
786
787 static int
788 sparc64_plt_entry_build (bfd *output_bfd, asection *splt, bfd_vma offset,
789 bfd_vma max, bfd_vma *r_offset)
790 {
791 unsigned char *entry = splt->contents + offset;
792 const unsigned int nop = SPARC_NOP;
793 int plt_index;
794
795 if (offset < (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE))
796 {
797 unsigned int sethi, ba;
798
799 *r_offset = offset;
800
801 plt_index = (offset / PLT64_ENTRY_SIZE);
802
803 sethi = 0x03000000 | (plt_index * PLT64_ENTRY_SIZE);
804 ba = 0x30680000
805 | (((splt->contents + PLT64_ENTRY_SIZE) - (entry + 4)) / 4 & 0x7ffff);
806
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);
815 }
816 else
817 {
818 unsigned char *ptr;
819 unsigned int ldx;
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
825 + ptr_chunk_size);
826
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. */
832
833 offset -= (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE);
834 max -= (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE);
835
836 block = offset / block_size;
837 last_block = max / block_size;
838 if (block != last_block)
839 {
840 chunks_this_block = 160;
841 }
842 else
843 {
844 last_ofs = max % block_size;
845 chunks_this_block = last_ofs / (insn_chunk_size + ptr_chunk_size);
846 }
847
848 ofs = offset % block_size;
849
850 plt_index = (PLT64_LARGE_THRESHOLD +
851 (block * 160) +
852 (ofs / insn_chunk_size));
853
854 ptr = splt->contents
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;
859
860 *r_offset = (bfd_vma) (ptr - splt->contents);
861
862 ldx = 0xc25be000 | ((ptr - (entry+4)) & 0x1fff);
863
864 /* mov %o7,%g5
865 call .+8
866 nop
867 ldx [%o7+P],%g1
868 jmpl %o7+%g1,%g1
869 mov %g5,%o7 */
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);
876
877 bfd_put_64 (output_bfd, (bfd_vma) (splt->contents - (entry + 4)), ptr);
878 }
879
880 return plt_index - 4;
881 }
882
883 /* The format of the first PLT entry in a VxWorks executable. */
884 static const bfd_vma sparc_vxworks_exec_plt0_entry[] =
885 {
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 */
890 0x01000000 /* nop */
891 };
892
893 /* The format of subsequent PLT entries. */
894 static const bfd_vma sparc_vxworks_exec_plt_entry[] =
895 {
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 */
904 };
905
906 /* The format of the first PLT entry in a VxWorks shared object. */
907 static const bfd_vma sparc_vxworks_shared_plt0_entry[] =
908 {
909 0xc405e008, /* ld [ %l7 + 8 ], %g2 */
910 0x81c08000, /* jmp %g2 */
911 0x01000000 /* nop */
912 };
913
914 /* The format of subsequent PLT entries. */
915 static const bfd_vma sparc_vxworks_shared_plt_entry[] =
916 {
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 */
925 };
926
927 #define SPARC_ELF_PUT_WORD(htab, bfd, val, ptr) \
928 htab->put_word(bfd, val, ptr)
929
930 #define SPARC_ELF_R_INFO(htab, in_rel, index, type) \
931 htab->r_info(in_rel, index, type)
932
933 #define SPARC_ELF_R_SYMNDX(htab, r_info) \
934 htab->r_symndx(r_info)
935
936 #define SPARC_ELF_WORD_BYTES(htab) \
937 htab->bytes_per_word
938
939 #define SPARC_ELF_RELA_BYTES(htab) \
940 htab->bytes_per_rela
941
942 #define SPARC_ELF_DTPOFF_RELOC(htab) \
943 htab->dtpoff_reloc
944
945 #define SPARC_ELF_DTPMOD_RELOC(htab) \
946 htab->dtpmod_reloc
947
948 #define SPARC_ELF_TPOFF_RELOC(htab) \
949 htab->tpoff_reloc
950
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)
953
954 /* Create an entry in an SPARC ELF linker hash table. */
955
956 static struct bfd_hash_entry *
957 link_hash_newfunc (struct bfd_hash_entry *entry,
958 struct bfd_hash_table *table, const char *string)
959 {
960 /* Allocate the structure if it has not already been allocated by a
961 subclass. */
962 if (entry == NULL)
963 {
964 entry = bfd_hash_allocate (table,
965 sizeof (struct _bfd_sparc_elf_link_hash_entry));
966 if (entry == NULL)
967 return entry;
968 }
969
970 /* Call the allocation method of the superclass. */
971 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
972 if (entry != NULL)
973 {
974 struct _bfd_sparc_elf_link_hash_entry *eh;
975
976 eh = (struct _bfd_sparc_elf_link_hash_entry *) entry;
977 eh->dyn_relocs = NULL;
978 eh->tls_type = GOT_UNKNOWN;
979 }
980
981 return entry;
982 }
983
984 /* The name of the dynamic interpreter. This is put in the .interp
985 section. */
986
987 #define ELF32_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
988 #define ELF64_DYNAMIC_INTERPRETER "/usr/lib/sparcv9/ld.so.1"
989
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. */
994
995 static hashval_t
996 elf_sparc_local_htab_hash (const void *ptr)
997 {
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);
1001 }
1002
1003 /* Compare local hash entries. */
1004
1005 static int
1006 elf_sparc_local_htab_eq (const void *ptr1, const void *ptr2)
1007 {
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;
1012
1013 return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
1014 }
1015
1016 /* Find and/or create a hash entry for local symbol. */
1017
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,
1021 bfd_boolean create)
1022 {
1023 struct _bfd_sparc_elf_link_hash_entry e, *ret;
1024 asection *sec = abfd->sections;
1025 unsigned long r_symndx;
1026 hashval_t h;
1027 void **slot;
1028
1029 r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
1030 h = ELF_LOCAL_SYMBOL_HASH (sec->id, r_symndx);
1031
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);
1036
1037 if (!slot)
1038 return NULL;
1039
1040 if (*slot)
1041 {
1042 ret = (struct _bfd_sparc_elf_link_hash_entry *) *slot;
1043 return &ret->elf;
1044 }
1045
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));
1049 if (ret)
1050 {
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;
1057 *slot = ret;
1058 }
1059 return &ret->elf;
1060 }
1061
1062 /* Create a SPARC ELF linker hash table. */
1063
1064 struct bfd_link_hash_table *
1065 _bfd_sparc_elf_link_hash_table_create (bfd *abfd)
1066 {
1067 struct _bfd_sparc_elf_link_hash_table *ret;
1068 bfd_size_type amt = sizeof (struct _bfd_sparc_elf_link_hash_table);
1069
1070 ret = (struct _bfd_sparc_elf_link_hash_table *) bfd_zmalloc (amt);
1071 if (ret == NULL)
1072 return NULL;
1073
1074 if (ABI_64_P (abfd))
1075 {
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;
1088
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;
1092 }
1093 else
1094 {
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;
1107
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;
1111 }
1112
1113 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc,
1114 sizeof (struct _bfd_sparc_elf_link_hash_entry),
1115 SPARC_ELF_DATA))
1116 {
1117 free (ret);
1118 return NULL;
1119 }
1120
1121 ret->loc_hash_table = htab_try_create (1024,
1122 elf_sparc_local_htab_hash,
1123 elf_sparc_local_htab_eq,
1124 NULL);
1125 ret->loc_hash_memory = objalloc_create ();
1126 if (!ret->loc_hash_table || !ret->loc_hash_memory)
1127 {
1128 free (ret);
1129 return NULL;
1130 }
1131
1132 return &ret->elf.root;
1133 }
1134
1135 /* Destroy a SPARC ELF linker hash table. */
1136
1137 void
1138 _bfd_sparc_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
1139 {
1140 struct _bfd_sparc_elf_link_hash_table *htab
1141 = (struct _bfd_sparc_elf_link_hash_table *) hash;
1142
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);
1148 }
1149
1150 /* Create .plt, .rela.plt, .got, .rela.got, .dynbss, and
1151 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
1152 hash table. */
1153
1154 bfd_boolean
1155 _bfd_sparc_elf_create_dynamic_sections (bfd *dynobj,
1156 struct bfd_link_info *info)
1157 {
1158 struct _bfd_sparc_elf_link_hash_table *htab;
1159
1160 htab = _bfd_sparc_elf_hash_table (info);
1161 BFD_ASSERT (htab != NULL);
1162
1163 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
1164 return FALSE;
1165
1166 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
1167 if (!info->shared)
1168 htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss");
1169
1170 if (htab->is_vxworks)
1171 {
1172 if (!elf_vxworks_create_dynamic_sections (dynobj, info, &htab->srelplt2))
1173 return FALSE;
1174 if (info->shared)
1175 {
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);
1180 }
1181 else
1182 {
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);
1187 }
1188 }
1189
1190 if (!htab->elf.splt || !htab->elf.srelplt || !htab->sdynbss
1191 || (!info->shared && !htab->srelbss))
1192 abort ();
1193
1194 return TRUE;
1195 }
1196
1197 static bfd_boolean
1198 create_ifunc_sections (bfd *abfd, struct bfd_link_info *info)
1199 {
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;
1203 asection *s;
1204
1205 if (htab->irelifunc != NULL || htab->iplt != NULL)
1206 return TRUE;
1207
1208 flags = bed->dynamic_sec_flags;
1209 pltflags = flags | SEC_ALLOC | SEC_CODE | SEC_LOAD;
1210
1211 s = bfd_make_section_with_flags (abfd, ".iplt", pltflags);
1212 if (s == NULL
1213 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
1214 return FALSE;
1215 htab->iplt = s;
1216
1217 s = bfd_make_section_with_flags (abfd, ".rela.iplt",
1218 flags | SEC_READONLY);
1219 if (s == NULL
1220 || ! bfd_set_section_alignment (abfd, s,
1221 bed->s->log_file_align))
1222 return FALSE;
1223 htab->irelplt = s;
1224
1225 return TRUE;
1226 }
1227
1228 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1229
1230 void
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)
1234 {
1235 struct _bfd_sparc_elf_link_hash_entry *edir, *eind;
1236
1237 edir = (struct _bfd_sparc_elf_link_hash_entry *) dir;
1238 eind = (struct _bfd_sparc_elf_link_hash_entry *) ind;
1239
1240 if (eind->dyn_relocs != NULL)
1241 {
1242 if (edir->dyn_relocs != NULL)
1243 {
1244 struct _bfd_sparc_elf_dyn_relocs **pp;
1245 struct _bfd_sparc_elf_dyn_relocs *p;
1246
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; )
1250 {
1251 struct _bfd_sparc_elf_dyn_relocs *q;
1252
1253 for (q = edir->dyn_relocs; q != NULL; q = q->next)
1254 if (q->sec == p->sec)
1255 {
1256 q->pc_count += p->pc_count;
1257 q->count += p->count;
1258 *pp = p->next;
1259 break;
1260 }
1261 if (q == NULL)
1262 pp = &p->next;
1263 }
1264 *pp = edir->dyn_relocs;
1265 }
1266
1267 edir->dyn_relocs = eind->dyn_relocs;
1268 eind->dyn_relocs = NULL;
1269 }
1270
1271 if (ind->root.type == bfd_link_hash_indirect
1272 && dir->got.refcount <= 0)
1273 {
1274 edir->tls_type = eind->tls_type;
1275 eind->tls_type = GOT_UNKNOWN;
1276 }
1277 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1278 }
1279
1280 static int
1281 sparc_elf_tls_transition (struct bfd_link_info *info, bfd *abfd,
1282 int r_type, int is_local)
1283 {
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;
1288
1289 if (info->shared)
1290 return r_type;
1291
1292 switch (r_type)
1293 {
1294 case R_SPARC_TLS_GD_HI22:
1295 if (is_local)
1296 return R_SPARC_TLS_LE_HIX22;
1297 return R_SPARC_TLS_IE_HI22;
1298 case R_SPARC_TLS_GD_LO10:
1299 if (is_local)
1300 return R_SPARC_TLS_LE_LOX10;
1301 return R_SPARC_TLS_IE_LO10;
1302 case R_SPARC_TLS_IE_HI22:
1303 if (is_local)
1304 return R_SPARC_TLS_LE_HIX22;
1305 return r_type;
1306 case R_SPARC_TLS_IE_LO10:
1307 if (is_local)
1308 return R_SPARC_TLS_LE_LOX10;
1309 return r_type;
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;
1314 }
1315
1316 return r_type;
1317 }
1318 \f
1319 /* Look through the relocs for a section during the first phase, and
1320 allocate space in the global offset table or procedure linkage
1321 table. */
1322
1323 bfd_boolean
1324 _bfd_sparc_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
1325 asection *sec, const Elf_Internal_Rela *relocs)
1326 {
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;
1332 asection *sreloc;
1333 int num_relocs;
1334 bfd_boolean checked_tlsgd = FALSE;
1335
1336 if (info->relocatable)
1337 return TRUE;
1338
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);
1343
1344 sreloc = NULL;
1345
1346 if (ABI_64_P (abfd))
1347 num_relocs = NUM_SHDR_ENTRIES (_bfd_elf_single_rel_hdr (sec));
1348 else
1349 num_relocs = sec->reloc_count;
1350
1351 BFD_ASSERT (is_sparc_elf (abfd) || num_relocs == 0);
1352
1353 if (htab->elf.dynobj == NULL)
1354 htab->elf.dynobj = abfd;
1355 if (!create_ifunc_sections (htab->elf.dynobj, info))
1356 return FALSE;
1357
1358 rel_end = relocs + num_relocs;
1359 for (rel = relocs; rel < rel_end; rel++)
1360 {
1361 unsigned int r_type;
1362 unsigned long r_symndx;
1363 struct elf_link_hash_entry *h;
1364 Elf_Internal_Sym *isym;
1365
1366 r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
1367 r_type = SPARC_ELF_R_TYPE (rel->r_info);
1368
1369 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1370 {
1371 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1372 abfd, r_symndx);
1373 return FALSE;
1374 }
1375
1376 isym = NULL;
1377 if (r_symndx < symtab_hdr->sh_info)
1378 {
1379 /* A local symbol. */
1380 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1381 abfd, r_symndx);
1382 if (isym == NULL)
1383 return FALSE;
1384
1385 /* Check relocation against local STT_GNU_IFUNC symbol. */
1386 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1387 {
1388 h = elf_sparc_get_local_sym_hash (htab, abfd, rel,
1389 TRUE);
1390 if (h == NULL)
1391 return FALSE;
1392
1393 /* Fake a STT_GNU_IFUNC symbol. */
1394 h->type = STT_GNU_IFUNC;
1395 h->def_regular = 1;
1396 h->ref_regular = 1;
1397 h->forced_local = 1;
1398 h->root.type = bfd_link_hash_defined;
1399 }
1400 else
1401 h = NULL;
1402 }
1403 else
1404 {
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;
1409 }
1410
1411 if (h && h->type == STT_GNU_IFUNC)
1412 {
1413 if (h->def_regular)
1414 {
1415 h->ref_regular = 1;
1416 h->plt.refcount += 1;
1417 }
1418 }
1419
1420 /* Compatibility with old R_SPARC_REV32 reloc conflicting
1421 with R_SPARC_TLS_GD_HI22. */
1422 if (! ABI_64_P (abfd) && ! checked_tlsgd)
1423 switch (r_type)
1424 {
1425 case R_SPARC_TLS_GD_HI22:
1426 {
1427 const Elf_Internal_Rela *relt;
1428
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)
1433 break;
1434 checked_tlsgd = TRUE;
1435 _bfd_sparc_elf_tdata (abfd)->has_tlsgd = relt < rel_end;
1436 }
1437 break;
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;
1443 break;
1444 }
1445
1446 r_type = sparc_elf_tls_transition (info, abfd, r_type, h == NULL);
1447 switch (r_type)
1448 {
1449 case R_SPARC_TLS_LDM_HI22:
1450 case R_SPARC_TLS_LDM_LO10:
1451 htab->tls_ldm_got.refcount += 1;
1452 break;
1453
1454 case R_SPARC_TLS_LE_HIX22:
1455 case R_SPARC_TLS_LE_LOX10:
1456 if (info->shared)
1457 goto r_sparc_plt32;
1458 break;
1459
1460 case R_SPARC_TLS_IE_HI22:
1461 case R_SPARC_TLS_IE_LO10:
1462 if (info->shared)
1463 info->flags |= DF_STATIC_TLS;
1464 /* Fall through */
1465
1466 case R_SPARC_GOT10:
1467 case R_SPARC_GOT13:
1468 case R_SPARC_GOT22:
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. */
1476 {
1477 int tls_type, old_tls_type;
1478
1479 switch (r_type)
1480 {
1481 default:
1482 case R_SPARC_GOT10:
1483 case R_SPARC_GOT13:
1484 case R_SPARC_GOT22:
1485 case R_SPARC_GOTDATA_OP_HIX22:
1486 case R_SPARC_GOTDATA_OP_LOX10:
1487 tls_type = GOT_NORMAL;
1488 break;
1489 case R_SPARC_TLS_GD_HI22:
1490 case R_SPARC_TLS_GD_LO10:
1491 tls_type = GOT_TLS_GD;
1492 break;
1493 case R_SPARC_TLS_IE_HI22:
1494 case R_SPARC_TLS_IE_LO10:
1495 tls_type = GOT_TLS_IE;
1496 break;
1497 }
1498
1499 if (h != NULL)
1500 {
1501 h->got.refcount += 1;
1502 old_tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
1503 }
1504 else
1505 {
1506 bfd_signed_vma *local_got_refcounts;
1507
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)
1511 {
1512 bfd_size_type size;
1513
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)
1519 return FALSE;
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);
1523 }
1524 switch (r_type)
1525 {
1526 case R_SPARC_GOTDATA_OP_HIX22:
1527 case R_SPARC_GOTDATA_OP_LOX10:
1528 break;
1529
1530 default:
1531 local_got_refcounts[r_symndx] += 1;
1532 break;
1533 }
1534 old_tls_type = _bfd_sparc_elf_local_got_tls_type (abfd) [r_symndx];
1535 }
1536
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))
1542 {
1543 if (old_tls_type == GOT_TLS_IE && tls_type == GOT_TLS_GD)
1544 tls_type = old_tls_type;
1545 else
1546 {
1547 (*_bfd_error_handler)
1548 (_("%B: `%s' accessed both as normal and thread local symbol"),
1549 abfd, h ? h->root.root.string : "<local>");
1550 return FALSE;
1551 }
1552 }
1553
1554 if (old_tls_type != tls_type)
1555 {
1556 if (h != NULL)
1557 _bfd_sparc_elf_hash_entry (h)->tls_type = tls_type;
1558 else
1559 _bfd_sparc_elf_local_got_tls_type (abfd) [r_symndx] = tls_type;
1560 }
1561 }
1562
1563 if (htab->elf.sgot == NULL)
1564 {
1565 if (!_bfd_elf_create_got_section (htab->elf.dynobj, info))
1566 return FALSE;
1567 }
1568 break;
1569
1570 case R_SPARC_TLS_GD_CALL:
1571 case R_SPARC_TLS_LDM_CALL:
1572 if (info->shared)
1573 {
1574 /* These are basically R_SPARC_TLS_WPLT30 relocs against
1575 __tls_get_addr. */
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,
1580 NULL, FALSE, FALSE,
1581 &bh))
1582 return FALSE;
1583 h = (struct elf_link_hash_entry *) bh;
1584 }
1585 else
1586 break;
1587 /* Fall through */
1588
1589 case R_SPARC_PLT32:
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:
1596 case R_SPARC_PLT64:
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. */
1602
1603 if (h == NULL)
1604 {
1605 if (! ABI_64_P (abfd))
1606 {
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
1610 it as WDISP30. */
1611 if (ELF32_R_TYPE (rel->r_info) == R_SPARC_PLT32)
1612 goto r_sparc_plt32;
1613 break;
1614 }
1615 /* PR 7027: We need similar behaviour for 64-bit binaries. */
1616 else if (r_type == R_SPARC_WPLT30)
1617 break;
1618
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);
1622 return FALSE;
1623 }
1624
1625 h->needs_plt = 1;
1626
1627 {
1628 int this_r_type;
1629
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)
1633 goto r_sparc_plt32;
1634 }
1635 h->plt.refcount += 1;
1636 break;
1637
1638 case R_SPARC_PC10:
1639 case R_SPARC_PC22:
1640 case R_SPARC_PC_HH22:
1641 case R_SPARC_PC_HM10:
1642 case R_SPARC_PC_LM22:
1643 if (h != NULL)
1644 h->non_got_ref = 1;
1645
1646 if (h != NULL
1647 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1648 break;
1649 /* Fall through. */
1650
1651 case R_SPARC_DISP8:
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:
1659 case R_SPARC_8:
1660 case R_SPARC_16:
1661 case R_SPARC_32:
1662 case R_SPARC_HI22:
1663 case R_SPARC_22:
1664 case R_SPARC_13:
1665 case R_SPARC_LO10:
1666 case R_SPARC_UA16:
1667 case R_SPARC_UA32:
1668 case R_SPARC_10:
1669 case R_SPARC_11:
1670 case R_SPARC_64:
1671 case R_SPARC_OLO10:
1672 case R_SPARC_HH22:
1673 case R_SPARC_HM10:
1674 case R_SPARC_LM22:
1675 case R_SPARC_7:
1676 case R_SPARC_5:
1677 case R_SPARC_6:
1678 case R_SPARC_HIX22:
1679 case R_SPARC_LOX10:
1680 case R_SPARC_H44:
1681 case R_SPARC_M44:
1682 case R_SPARC_L44:
1683 case R_SPARC_UA64:
1684 if (h != NULL)
1685 h->non_got_ref = 1;
1686
1687 r_sparc_plt32:
1688 if (h != NULL && !info->shared)
1689 {
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;
1693 }
1694
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
1710 symbol local.
1711
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
1715 symbol. */
1716 if ((info->shared
1717 && (sec->flags & SEC_ALLOC) != 0
1718 && (! _bfd_sparc_elf_howto_table[r_type].pc_relative
1719 || (h != NULL
1720 && (! SYMBOLIC_BIND (info, h)
1721 || h->root.type == bfd_link_hash_defweak
1722 || !h->def_regular))))
1723 || (!info->shared
1724 && (sec->flags & SEC_ALLOC) != 0
1725 && h != NULL
1726 && (h->root.type == bfd_link_hash_defweak
1727 || !h->def_regular))
1728 || (!info->shared
1729 && h != NULL
1730 && h->type == STT_GNU_IFUNC))
1731 {
1732 struct _bfd_sparc_elf_dyn_relocs *p;
1733 struct _bfd_sparc_elf_dyn_relocs **head;
1734
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. */
1738 if (sreloc == NULL)
1739 {
1740 sreloc = _bfd_elf_make_dynamic_reloc_section
1741 (sec, htab->elf.dynobj, htab->word_align_power,
1742 abfd, /*rela?*/ TRUE);
1743
1744 if (sreloc == NULL)
1745 return FALSE;
1746 }
1747
1748 /* If this is a global symbol, we count the number of
1749 relocations we need for this symbol. */
1750 if (h != NULL)
1751 head = &((struct _bfd_sparc_elf_link_hash_entry *) h)->dyn_relocs;
1752 else
1753 {
1754 /* Track dynamic relocs needed for local syms too.
1755 We really need local syms available to do this
1756 easily. Oh well. */
1757 asection *s;
1758 void *vpp;
1759
1760 BFD_ASSERT (isym != NULL);
1761 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1762 if (s == NULL)
1763 s = sec;
1764
1765 vpp = &elf_section_data (s)->local_dynrel;
1766 head = (struct _bfd_sparc_elf_dyn_relocs **) vpp;
1767 }
1768
1769 p = *head;
1770 if (p == NULL || p->sec != sec)
1771 {
1772 bfd_size_type amt = sizeof *p;
1773 p = ((struct _bfd_sparc_elf_dyn_relocs *)
1774 bfd_alloc (htab->elf.dynobj, amt));
1775 if (p == NULL)
1776 return FALSE;
1777 p->next = *head;
1778 *head = p;
1779 p->sec = sec;
1780 p->count = 0;
1781 p->pc_count = 0;
1782 }
1783
1784 p->count += 1;
1785 if (_bfd_sparc_elf_howto_table[r_type].pc_relative)
1786 p->pc_count += 1;
1787 }
1788
1789 break;
1790
1791 case R_SPARC_GNU_VTINHERIT:
1792 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1793 return FALSE;
1794 break;
1795
1796 case R_SPARC_GNU_VTENTRY:
1797 BFD_ASSERT (h != NULL);
1798 if (h != NULL
1799 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1800 return FALSE;
1801 break;
1802
1803 case R_SPARC_REGISTER:
1804 /* Nothing to do. */
1805 break;
1806
1807 default:
1808 break;
1809 }
1810 }
1811
1812 return TRUE;
1813 }
1814 \f
1815 asection *
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)
1821 {
1822 if (h != NULL)
1823 switch (SPARC_ELF_R_TYPE (rel->r_info))
1824 {
1825 case R_SPARC_GNU_VTINHERIT:
1826 case R_SPARC_GNU_VTENTRY:
1827 return NULL;
1828 }
1829
1830 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1831 }
1832
1833 static Elf_Internal_Rela *
1834 sparc_elf_find_reloc_at_ofs (Elf_Internal_Rela *rel,
1835 Elf_Internal_Rela *relend,
1836 bfd_vma offset)
1837 {
1838 while (rel < relend)
1839 {
1840 if (rel->r_offset == offset)
1841 return rel;
1842 rel++;
1843 }
1844 return NULL;
1845 }
1846
1847 /* Update the got entry reference counts for the section being removed. */
1848 bfd_boolean
1849 _bfd_sparc_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
1850 asection *sec, const Elf_Internal_Rela *relocs)
1851 {
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;
1857
1858 if (info->relocatable)
1859 return TRUE;
1860
1861 BFD_ASSERT (is_sparc_elf (abfd) || sec->reloc_count == 0);
1862
1863 elf_section_data (sec)->local_dynrel = NULL;
1864
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);
1870
1871 relend = relocs + sec->reloc_count;
1872 for (rel = relocs; rel < relend; rel++)
1873 {
1874 unsigned long r_symndx;
1875 unsigned int r_type;
1876 struct elf_link_hash_entry *h = NULL;
1877
1878 r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
1879 if (r_symndx >= symtab_hdr->sh_info)
1880 {
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;
1884
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)
1891 if (p->sec == sec)
1892 {
1893 /* Everything must go for SEC. */
1894 *pp = p->next;
1895 break;
1896 }
1897 }
1898
1899 r_type = SPARC_ELF_R_TYPE (rel->r_info);
1900 r_type = sparc_elf_tls_transition (info, abfd, r_type, h != NULL);
1901 switch (r_type)
1902 {
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;
1907 break;
1908
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:
1913 case R_SPARC_GOT10:
1914 case R_SPARC_GOT13:
1915 case R_SPARC_GOT22:
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:
1920 if (h != NULL)
1921 {
1922 if (h->got.refcount > 0)
1923 h->got.refcount--;
1924 }
1925 else
1926 {
1927 switch (r_type)
1928 {
1929 case R_SPARC_GOTDATA_OP_HIX22:
1930 case R_SPARC_GOTDATA_OP_LOX10:
1931 break;
1932
1933 default:
1934 if (local_got_refcounts[r_symndx] > 0)
1935 local_got_refcounts[r_symndx]--;
1936 break;
1937 }
1938 }
1939 break;
1940
1941 case R_SPARC_PC10:
1942 case R_SPARC_PC22:
1943 case R_SPARC_PC_HH22:
1944 case R_SPARC_PC_HM10:
1945 case R_SPARC_PC_LM22:
1946 if (h != NULL
1947 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1948 break;
1949 /* Fall through. */
1950
1951 case R_SPARC_DISP8:
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:
1959 case R_SPARC_8:
1960 case R_SPARC_16:
1961 case R_SPARC_32:
1962 case R_SPARC_HI22:
1963 case R_SPARC_22:
1964 case R_SPARC_13:
1965 case R_SPARC_LO10:
1966 case R_SPARC_UA16:
1967 case R_SPARC_UA32:
1968 case R_SPARC_PLT32:
1969 case R_SPARC_10:
1970 case R_SPARC_11:
1971 case R_SPARC_64:
1972 case R_SPARC_OLO10:
1973 case R_SPARC_HH22:
1974 case R_SPARC_HM10:
1975 case R_SPARC_LM22:
1976 case R_SPARC_7:
1977 case R_SPARC_5:
1978 case R_SPARC_6:
1979 case R_SPARC_HIX22:
1980 case R_SPARC_LOX10:
1981 case R_SPARC_H44:
1982 case R_SPARC_M44:
1983 case R_SPARC_L44:
1984 case R_SPARC_UA64:
1985 if (info->shared)
1986 break;
1987 /* Fall through. */
1988
1989 case R_SPARC_WPLT30:
1990 if (h != NULL)
1991 {
1992 if (h->plt.refcount > 0)
1993 h->plt.refcount--;
1994 }
1995 break;
1996
1997 default:
1998 break;
1999 }
2000 }
2001
2002 return TRUE;
2003 }
2004
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
2009 understand. */
2010
2011 bfd_boolean
2012 _bfd_sparc_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
2013 struct elf_link_hash_entry *h)
2014 {
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;
2018 asection *s;
2019
2020 htab = _bfd_sparc_elf_hash_table (info);
2021 BFD_ASSERT (htab != NULL);
2022
2023 /* Make sure we know what is going on here. */
2024 BFD_ASSERT (htab->elf.dynobj != NULL
2025 && (h->needs_plt
2026 || h->type == STT_GNU_IFUNC
2027 || h->u.weakdef != NULL
2028 || (h->def_dynamic
2029 && h->ref_regular
2030 && !h->def_regular)));
2031
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
2038 STT_FUNC. */
2039 if (h->type == STT_FUNC
2040 || h->type == STT_GNU_IFUNC
2041 || h->needs_plt
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))
2046 {
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))))
2052 {
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;
2059 h->needs_plt = 0;
2060 }
2061
2062 return TRUE;
2063 }
2064 else
2065 h->plt.offset = (bfd_vma) -1;
2066
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)
2071 {
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;
2076 return TRUE;
2077 }
2078
2079 /* This is a reference to a symbol defined by a dynamic object which
2080 is not a function. */
2081
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. */
2086 if (info->shared)
2087 return TRUE;
2088
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)
2092 return TRUE;
2093
2094 /* If -z nocopyreloc was given, we won't generate them either. */
2095 if (info->nocopyreloc)
2096 {
2097 h->non_got_ref = 0;
2098 return TRUE;
2099 }
2100
2101 eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
2102 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2103 {
2104 s = p->sec->output_section;
2105 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2106 break;
2107 }
2108
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. */
2111 if (p == NULL)
2112 {
2113 h->non_got_ref = 0;
2114 return TRUE;
2115 }
2116
2117 /* We must allocate the symbol in our .dynbss section, which will
2118 become part of the .bss section of the executable. There will be
2119 an entry for this symbol in the .dynsym section. The dynamic
2120 object will contain position independent code, so all references
2121 from the dynamic object to this symbol will go through the global
2122 offset table. The dynamic linker will use the .dynsym entry to
2123 determine the address it must put in the global offset table, so
2124 both the dynamic object and the regular object will refer to the
2125 same memory location for the variable. */
2126
2127 /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker
2128 to copy the initial value out of the dynamic object and into the
2129 runtime process image. We need to remember the offset into the
2130 .rel.bss section we are going to use. */
2131 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
2132 {
2133 htab->srelbss->size += SPARC_ELF_RELA_BYTES (htab);
2134 h->needs_copy = 1;
2135 }
2136
2137 s = htab->sdynbss;
2138
2139 return _bfd_elf_adjust_dynamic_copy (h, s);
2140 }
2141
2142 /* Allocate space in .plt, .got and associated reloc sections for
2143 dynamic relocs. */
2144
2145 static bfd_boolean
2146 allocate_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
2147 {
2148 struct bfd_link_info *info;
2149 struct _bfd_sparc_elf_link_hash_table *htab;
2150 struct _bfd_sparc_elf_link_hash_entry *eh;
2151 struct _bfd_sparc_elf_dyn_relocs *p;
2152
2153 if (h->root.type == bfd_link_hash_indirect)
2154 return TRUE;
2155
2156 info = (struct bfd_link_info *) inf;
2157 htab = _bfd_sparc_elf_hash_table (info);
2158 BFD_ASSERT (htab != NULL);
2159
2160 if ((htab->elf.dynamic_sections_created
2161 && h->plt.refcount > 0)
2162 || (h->type == STT_GNU_IFUNC
2163 && h->def_regular
2164 && h->ref_regular))
2165 {
2166 /* Make sure this symbol is output as a dynamic symbol.
2167 Undefined weak syms won't yet be marked as dynamic. */
2168 if (h->dynindx == -1
2169 && !h->forced_local)
2170 {
2171 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2172 return FALSE;
2173 }
2174
2175 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h)
2176 || (h->type == STT_GNU_IFUNC
2177 && h->def_regular))
2178 {
2179 asection *s = htab->elf.splt;
2180
2181 if (s == NULL)
2182 s = htab->elf.iplt;
2183
2184 /* Allocate room for the header. */
2185 if (s->size == 0)
2186 {
2187 s->size = htab->plt_header_size;
2188
2189 /* Allocate space for the .rela.plt.unloaded relocations. */
2190 if (htab->is_vxworks && !info->shared)
2191 htab->srelplt2->size = sizeof (Elf32_External_Rela) * 2;
2192 }
2193
2194 /* The procedure linkage table size is bounded by the magnitude
2195 of the offset we can describe in the entry. */
2196 if (s->size >= (SPARC_ELF_WORD_BYTES(htab) == 8 ?
2197 (((bfd_vma)1 << 31) << 1) : 0x400000))
2198 {
2199 bfd_set_error (bfd_error_bad_value);
2200 return FALSE;
2201 }
2202
2203 if (SPARC_ELF_WORD_BYTES(htab) == 8
2204 && s->size >= PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE)
2205 {
2206 bfd_vma off = s->size - PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE;
2207
2208
2209 off = (off % (160 * PLT64_ENTRY_SIZE)) / PLT64_ENTRY_SIZE;
2210
2211 h->plt.offset = (s->size - (off * 8));
2212 }
2213 else
2214 h->plt.offset = s->size;
2215
2216 /* If this symbol is not defined in a regular file, and we are
2217 not generating a shared library, then set the symbol to this
2218 location in the .plt. This is required to make function
2219 pointers compare as equal between the normal executable and
2220 the shared library. */
2221 if (! info->shared
2222 && !h->def_regular)
2223 {
2224 h->root.u.def.section = s;
2225 h->root.u.def.value = h->plt.offset;
2226 }
2227
2228 /* Make room for this entry. */
2229 s->size += htab->plt_entry_size;
2230
2231 /* We also need to make an entry in the .rela.plt section. */
2232 if (s == htab->elf.splt)
2233 htab->elf.srelplt->size += SPARC_ELF_RELA_BYTES (htab);
2234 else
2235 htab->elf.irelplt->size += SPARC_ELF_RELA_BYTES (htab);
2236
2237 if (htab->is_vxworks)
2238 {
2239 /* Allocate space for the .got.plt entry. */
2240 htab->elf.sgotplt->size += 4;
2241
2242 /* ...and for the .rela.plt.unloaded relocations. */
2243 if (!info->shared)
2244 htab->srelplt2->size += sizeof (Elf32_External_Rela) * 3;
2245 }
2246 }
2247 else
2248 {
2249 h->plt.offset = (bfd_vma) -1;
2250 h->needs_plt = 0;
2251 }
2252 }
2253 else
2254 {
2255 h->plt.offset = (bfd_vma) -1;
2256 h->needs_plt = 0;
2257 }
2258
2259 /* If R_SPARC_TLS_IE_{HI22,LO10} symbol is now local to the binary,
2260 make it a R_SPARC_TLS_LE_{HI22,LO10} requiring no TLS entry. */
2261 if (h->got.refcount > 0
2262 && !info->shared
2263 && h->dynindx == -1
2264 && _bfd_sparc_elf_hash_entry(h)->tls_type == GOT_TLS_IE)
2265 h->got.offset = (bfd_vma) -1;
2266 else if (h->got.refcount > 0)
2267 {
2268 asection *s;
2269 bfd_boolean dyn;
2270 int tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
2271
2272 /* Make sure this symbol is output as a dynamic symbol.
2273 Undefined weak syms won't yet be marked as dynamic. */
2274 if (h->dynindx == -1
2275 && !h->forced_local)
2276 {
2277 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2278 return FALSE;
2279 }
2280
2281 s = htab->elf.sgot;
2282 h->got.offset = s->size;
2283 s->size += SPARC_ELF_WORD_BYTES (htab);
2284 /* R_SPARC_TLS_GD_HI{22,LO10} needs 2 consecutive GOT slots. */
2285 if (tls_type == GOT_TLS_GD)
2286 s->size += SPARC_ELF_WORD_BYTES (htab);
2287 dyn = htab->elf.dynamic_sections_created;
2288 /* R_SPARC_TLS_IE_{HI22,LO10} needs one dynamic relocation,
2289 R_SPARC_TLS_GD_{HI22,LO10} needs one if local symbol and two if
2290 global. */
2291 if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
2292 || tls_type == GOT_TLS_IE
2293 || h->type == STT_GNU_IFUNC)
2294 htab->elf.srelgot->size += SPARC_ELF_RELA_BYTES (htab);
2295 else if (tls_type == GOT_TLS_GD)
2296 htab->elf.srelgot->size += 2 * SPARC_ELF_RELA_BYTES (htab);
2297 else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
2298 htab->elf.srelgot->size += SPARC_ELF_RELA_BYTES (htab);
2299 }
2300 else
2301 h->got.offset = (bfd_vma) -1;
2302
2303 eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
2304 if (eh->dyn_relocs == NULL)
2305 return TRUE;
2306
2307 /* In the shared -Bsymbolic case, discard space allocated for
2308 dynamic pc-relative relocs against symbols which turn out to be
2309 defined in regular objects. For the normal shared case, discard
2310 space for pc-relative relocs that have become local due to symbol
2311 visibility changes. */
2312
2313 if (info->shared)
2314 {
2315 if (SYMBOL_CALLS_LOCAL (info, h))
2316 {
2317 struct _bfd_sparc_elf_dyn_relocs **pp;
2318
2319 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2320 {
2321 p->count -= p->pc_count;
2322 p->pc_count = 0;
2323 if (p->count == 0)
2324 *pp = p->next;
2325 else
2326 pp = &p->next;
2327 }
2328 }
2329
2330 if (htab->is_vxworks)
2331 {
2332 struct _bfd_sparc_elf_dyn_relocs **pp;
2333
2334 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2335 {
2336 if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
2337 *pp = p->next;
2338 else
2339 pp = &p->next;
2340 }
2341 }
2342
2343 /* Also discard relocs on undefined weak syms with non-default
2344 visibility. */
2345 if (eh->dyn_relocs != NULL
2346 && h->root.type == bfd_link_hash_undefweak)
2347 {
2348 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2349 eh->dyn_relocs = NULL;
2350
2351 /* Make sure undefined weak symbols are output as a dynamic
2352 symbol in PIEs. */
2353 else if (h->dynindx == -1
2354 && !h->forced_local)
2355 {
2356 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2357 return FALSE;
2358 }
2359 }
2360 }
2361 else
2362 {
2363 /* For the non-shared case, discard space for relocs against
2364 symbols which turn out to need copy relocs or are not
2365 dynamic. */
2366
2367 if (!h->non_got_ref
2368 && ((h->def_dynamic
2369 && !h->def_regular)
2370 || (htab->elf.dynamic_sections_created
2371 && (h->root.type == bfd_link_hash_undefweak
2372 || h->root.type == bfd_link_hash_undefined))))
2373 {
2374 /* Make sure this symbol is output as a dynamic symbol.
2375 Undefined weak syms won't yet be marked as dynamic. */
2376 if (h->dynindx == -1
2377 && !h->forced_local)
2378 {
2379 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2380 return FALSE;
2381 }
2382
2383 /* If that succeeded, we know we'll be keeping all the
2384 relocs. */
2385 if (h->dynindx != -1)
2386 goto keep;
2387 }
2388
2389 eh->dyn_relocs = NULL;
2390
2391 keep: ;
2392 }
2393
2394 /* Finally, allocate space. */
2395 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2396 {
2397 asection *sreloc = elf_section_data (p->sec)->sreloc;
2398 sreloc->size += p->count * SPARC_ELF_RELA_BYTES (htab);
2399 }
2400
2401 return TRUE;
2402 }
2403
2404 /* Allocate space in .plt, .got and associated reloc sections for
2405 local dynamic relocs. */
2406
2407 static bfd_boolean
2408 allocate_local_dynrelocs (void **slot, void *inf)
2409 {
2410 struct elf_link_hash_entry *h
2411 = (struct elf_link_hash_entry *) *slot;
2412
2413 if (h->type != STT_GNU_IFUNC
2414 || !h->def_regular
2415 || !h->ref_regular
2416 || !h->forced_local
2417 || h->root.type != bfd_link_hash_defined)
2418 abort ();
2419
2420 return allocate_dynrelocs (h, inf);
2421 }
2422
2423 /* Find any dynamic relocs that apply to read-only sections. */
2424
2425 static bfd_boolean
2426 readonly_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
2427 {
2428 struct _bfd_sparc_elf_link_hash_entry *eh;
2429 struct _bfd_sparc_elf_dyn_relocs *p;
2430
2431 eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
2432 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2433 {
2434 asection *s = p->sec->output_section;
2435
2436 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2437 {
2438 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2439
2440 info->flags |= DF_TEXTREL;
2441
2442 /* Not an error, just cut short the traversal. */
2443 return FALSE;
2444 }
2445 }
2446 return TRUE;
2447 }
2448
2449 /* Return true if the dynamic symbol for a given section should be
2450 omitted when creating a shared library. */
2451
2452 bfd_boolean
2453 _bfd_sparc_elf_omit_section_dynsym (bfd *output_bfd,
2454 struct bfd_link_info *info,
2455 asection *p)
2456 {
2457 /* We keep the .got section symbol so that explicit relocations
2458 against the _GLOBAL_OFFSET_TABLE_ symbol emitted in PIC mode
2459 can be turned into relocations against the .got symbol. */
2460 if (strcmp (p->name, ".got") == 0)
2461 return FALSE;
2462
2463 return _bfd_elf_link_omit_section_dynsym (output_bfd, info, p);
2464 }
2465
2466 /* Set the sizes of the dynamic sections. */
2467
2468 bfd_boolean
2469 _bfd_sparc_elf_size_dynamic_sections (bfd *output_bfd,
2470 struct bfd_link_info *info)
2471 {
2472 struct _bfd_sparc_elf_link_hash_table *htab;
2473 bfd *dynobj;
2474 asection *s;
2475 bfd *ibfd;
2476
2477 htab = _bfd_sparc_elf_hash_table (info);
2478 BFD_ASSERT (htab != NULL);
2479 dynobj = htab->elf.dynobj;
2480 BFD_ASSERT (dynobj != NULL);
2481
2482 if (elf_hash_table (info)->dynamic_sections_created)
2483 {
2484 /* Set the contents of the .interp section to the interpreter. */
2485 if (info->executable)
2486 {
2487 s = bfd_get_section_by_name (dynobj, ".interp");
2488 BFD_ASSERT (s != NULL);
2489 s->size = htab->dynamic_interpreter_size;
2490 s->contents = (unsigned char *) htab->dynamic_interpreter;
2491 }
2492 }
2493
2494 /* Set up .got offsets for local syms, and space for local dynamic
2495 relocs. */
2496 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2497 {
2498 bfd_signed_vma *local_got;
2499 bfd_signed_vma *end_local_got;
2500 char *local_tls_type;
2501 bfd_size_type locsymcount;
2502 Elf_Internal_Shdr *symtab_hdr;
2503 asection *srel;
2504
2505 if (! is_sparc_elf (ibfd))
2506 continue;
2507
2508 for (s = ibfd->sections; s != NULL; s = s->next)
2509 {
2510 struct _bfd_sparc_elf_dyn_relocs *p;
2511
2512 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
2513 {
2514 if (!bfd_is_abs_section (p->sec)
2515 && bfd_is_abs_section (p->sec->output_section))
2516 {
2517 /* Input section has been discarded, either because
2518 it is a copy of a linkonce section or due to
2519 linker script /DISCARD/, so we'll be discarding
2520 the relocs too. */
2521 }
2522 else if (htab->is_vxworks
2523 && strcmp (p->sec->output_section->name,
2524 ".tls_vars") == 0)
2525 {
2526 /* Relocations in vxworks .tls_vars sections are
2527 handled specially by the loader. */
2528 }
2529 else if (p->count != 0)
2530 {
2531 srel = elf_section_data (p->sec)->sreloc;
2532 if (!htab->elf.dynamic_sections_created)
2533 srel = htab->elf.irelplt;
2534 srel->size += p->count * SPARC_ELF_RELA_BYTES (htab);
2535 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2536 info->flags |= DF_TEXTREL;
2537 }
2538 }
2539 }
2540
2541 local_got = elf_local_got_refcounts (ibfd);
2542 if (!local_got)
2543 continue;
2544
2545 symtab_hdr = &elf_symtab_hdr (ibfd);
2546 locsymcount = symtab_hdr->sh_info;
2547 end_local_got = local_got + locsymcount;
2548 local_tls_type = _bfd_sparc_elf_local_got_tls_type (ibfd);
2549 s = htab->elf.sgot;
2550 srel = htab->elf.srelgot;
2551 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
2552 {
2553 if (*local_got > 0)
2554 {
2555 *local_got = s->size;
2556 s->size += SPARC_ELF_WORD_BYTES (htab);
2557 if (*local_tls_type == GOT_TLS_GD)
2558 s->size += SPARC_ELF_WORD_BYTES (htab);
2559 if (info->shared
2560 || *local_tls_type == GOT_TLS_GD
2561 || *local_tls_type == GOT_TLS_IE)
2562 srel->size += SPARC_ELF_RELA_BYTES (htab);
2563 }
2564 else
2565 *local_got = (bfd_vma) -1;
2566 }
2567 }
2568
2569 if (htab->tls_ldm_got.refcount > 0)
2570 {
2571 /* Allocate 2 got entries and 1 dynamic reloc for
2572 R_SPARC_TLS_LDM_{HI22,LO10} relocs. */
2573 htab->tls_ldm_got.offset = htab->elf.sgot->size;
2574 htab->elf.sgot->size += (2 * SPARC_ELF_WORD_BYTES (htab));
2575 htab->elf.srelgot->size += SPARC_ELF_RELA_BYTES (htab);
2576 }
2577 else
2578 htab->tls_ldm_got.offset = -1;
2579
2580 /* Allocate global sym .plt and .got entries, and space for global
2581 sym dynamic relocs. */
2582 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
2583
2584 /* Allocate .plt and .got entries, and space for local symbols. */
2585 htab_traverse (htab->loc_hash_table, allocate_local_dynrelocs, info);
2586
2587 if (! ABI_64_P (output_bfd)
2588 && !htab->is_vxworks
2589 && elf_hash_table (info)->dynamic_sections_created)
2590 {
2591 /* Make space for the trailing nop in .plt. */
2592 if (htab->elf.splt->size > 0)
2593 htab->elf.splt->size += 1 * SPARC_INSN_BYTES;
2594
2595 /* If the .got section is more than 0x1000 bytes, we add
2596 0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13
2597 bit relocations have a greater chance of working.
2598
2599 FIXME: Make this optimization work for 64-bit too. */
2600 if (htab->elf.sgot->size >= 0x1000
2601 && elf_hash_table (info)->hgot->root.u.def.value == 0)
2602 elf_hash_table (info)->hgot->root.u.def.value = 0x1000;
2603 }
2604
2605 /* The check_relocs and adjust_dynamic_symbol entry points have
2606 determined the sizes of the various dynamic sections. Allocate
2607 memory for them. */
2608 for (s = dynobj->sections; s != NULL; s = s->next)
2609 {
2610 if ((s->flags & SEC_LINKER_CREATED) == 0)
2611 continue;
2612
2613 if (s == htab->elf.splt
2614 || s == htab->elf.sgot
2615 || s == htab->sdynbss
2616 || s == htab->elf.iplt
2617 || s == htab->elf.sgotplt)
2618 {
2619 /* Strip this section if we don't need it; see the
2620 comment below. */
2621 }
2622 else if (CONST_STRNEQ (s->name, ".rela"))
2623 {
2624 if (s->size != 0)
2625 {
2626 /* We use the reloc_count field as a counter if we need
2627 to copy relocs into the output file. */
2628 s->reloc_count = 0;
2629 }
2630 }
2631 else
2632 {
2633 /* It's not one of our sections. */
2634 continue;
2635 }
2636
2637 if (s->size == 0)
2638 {
2639 /* If we don't need this section, strip it from the
2640 output file. This is mostly to handle .rela.bss and
2641 .rela.plt. We must create both sections in
2642 create_dynamic_sections, because they must be created
2643 before the linker maps input sections to output
2644 sections. The linker does that before
2645 adjust_dynamic_symbol is called, and it is that
2646 function which decides whether anything needs to go
2647 into these sections. */
2648 s->flags |= SEC_EXCLUDE;
2649 continue;
2650 }
2651
2652 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2653 continue;
2654
2655 /* Allocate memory for the section contents. Zero the memory
2656 for the benefit of .rela.plt, which has 4 unused entries
2657 at the beginning, and we don't want garbage. */
2658 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2659 if (s->contents == NULL)
2660 return FALSE;
2661 }
2662
2663 if (elf_hash_table (info)->dynamic_sections_created)
2664 {
2665 /* Add some entries to the .dynamic section. We fill in the
2666 values later, in _bfd_sparc_elf_finish_dynamic_sections, but we
2667 must add the entries now so that we get the correct size for
2668 the .dynamic section. The DT_DEBUG entry is filled in by the
2669 dynamic linker and used by the debugger. */
2670 #define add_dynamic_entry(TAG, VAL) \
2671 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2672
2673 if (info->executable)
2674 {
2675 if (!add_dynamic_entry (DT_DEBUG, 0))
2676 return FALSE;
2677 }
2678
2679 if (htab->elf.srelplt->size != 0)
2680 {
2681 if (!add_dynamic_entry (DT_PLTGOT, 0)
2682 || !add_dynamic_entry (DT_PLTRELSZ, 0)
2683 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2684 || !add_dynamic_entry (DT_JMPREL, 0))
2685 return FALSE;
2686 }
2687
2688 if (!add_dynamic_entry (DT_RELA, 0)
2689 || !add_dynamic_entry (DT_RELASZ, 0)
2690 || !add_dynamic_entry (DT_RELAENT,
2691 SPARC_ELF_RELA_BYTES (htab)))
2692 return FALSE;
2693
2694 /* If any dynamic relocs apply to a read-only section,
2695 then we need a DT_TEXTREL entry. */
2696 if ((info->flags & DF_TEXTREL) == 0)
2697 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
2698 (PTR) info);
2699
2700 if (info->flags & DF_TEXTREL)
2701 {
2702 if (!add_dynamic_entry (DT_TEXTREL, 0))
2703 return FALSE;
2704 }
2705
2706 if (ABI_64_P (output_bfd))
2707 {
2708 int reg;
2709 struct _bfd_sparc_elf_app_reg * app_regs;
2710 struct elf_strtab_hash *dynstr;
2711 struct elf_link_hash_table *eht = elf_hash_table (info);
2712
2713 /* Add dynamic STT_REGISTER symbols and corresponding DT_SPARC_REGISTER
2714 entries if needed. */
2715 app_regs = _bfd_sparc_elf_hash_table (info)->app_regs;
2716 dynstr = eht->dynstr;
2717
2718 for (reg = 0; reg < 4; reg++)
2719 if (app_regs [reg].name != NULL)
2720 {
2721 struct elf_link_local_dynamic_entry *entry, *e;
2722
2723 if (!add_dynamic_entry (DT_SPARC_REGISTER, 0))
2724 return FALSE;
2725
2726 entry = (struct elf_link_local_dynamic_entry *)
2727 bfd_hash_allocate (&info->hash->table, sizeof (*entry));
2728 if (entry == NULL)
2729 return FALSE;
2730
2731 /* We cheat here a little bit: the symbol will not be local, so we
2732 put it at the end of the dynlocal linked list. We will fix it
2733 later on, as we have to fix other fields anyway. */
2734 entry->isym.st_value = reg < 2 ? reg + 2 : reg + 4;
2735 entry->isym.st_size = 0;
2736 if (*app_regs [reg].name != '\0')
2737 entry->isym.st_name
2738 = _bfd_elf_strtab_add (dynstr, app_regs[reg].name, FALSE);
2739 else
2740 entry->isym.st_name = 0;
2741 entry->isym.st_other = 0;
2742 entry->isym.st_info = ELF_ST_INFO (app_regs [reg].bind,
2743 STT_REGISTER);
2744 entry->isym.st_shndx = app_regs [reg].shndx;
2745 entry->isym.st_target_internal = 0;
2746 entry->next = NULL;
2747 entry->input_bfd = output_bfd;
2748 entry->input_indx = -1;
2749
2750 if (eht->dynlocal == NULL)
2751 eht->dynlocal = entry;
2752 else
2753 {
2754 for (e = eht->dynlocal; e->next; e = e->next)
2755 ;
2756 e->next = entry;
2757 }
2758 eht->dynsymcount++;
2759 }
2760 }
2761 if (htab->is_vxworks
2762 && !elf_vxworks_add_dynamic_entries (output_bfd, info))
2763 return FALSE;
2764 }
2765 #undef add_dynamic_entry
2766
2767 return TRUE;
2768 }
2769 \f
2770 bfd_boolean
2771 _bfd_sparc_elf_new_section_hook (bfd *abfd, asection *sec)
2772 {
2773 if (!sec->used_by_bfd)
2774 {
2775 struct _bfd_sparc_elf_section_data *sdata;
2776 bfd_size_type amt = sizeof (*sdata);
2777
2778 sdata = bfd_zalloc (abfd, amt);
2779 if (sdata == NULL)
2780 return FALSE;
2781 sec->used_by_bfd = sdata;
2782 }
2783
2784 return _bfd_elf_new_section_hook (abfd, sec);
2785 }
2786
2787 bfd_boolean
2788 _bfd_sparc_elf_relax_section (bfd *abfd ATTRIBUTE_UNUSED,
2789 struct bfd_section *section,
2790 struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
2791 bfd_boolean *again)
2792 {
2793 if (link_info->relocatable)
2794 (*link_info->callbacks->einfo)
2795 (_("%P%F: --relax and -r may not be used together\n"));
2796
2797 *again = FALSE;
2798 sec_do_relax (section) = 1;
2799 return TRUE;
2800 }
2801 \f
2802 /* Return the base VMA address which should be subtracted from real addresses
2803 when resolving @dtpoff relocation.
2804 This is PT_TLS segment p_vaddr. */
2805
2806 static bfd_vma
2807 dtpoff_base (struct bfd_link_info *info)
2808 {
2809 /* If tls_sec is NULL, we should have signalled an error already. */
2810 if (elf_hash_table (info)->tls_sec == NULL)
2811 return 0;
2812 return elf_hash_table (info)->tls_sec->vma;
2813 }
2814
2815 /* Return the relocation value for @tpoff relocation
2816 if STT_TLS virtual address is ADDRESS. */
2817
2818 static bfd_vma
2819 tpoff (struct bfd_link_info *info, bfd_vma address)
2820 {
2821 struct elf_link_hash_table *htab = elf_hash_table (info);
2822 const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
2823 bfd_vma static_tls_size;
2824
2825 /* If tls_sec is NULL, we should have signalled an error already. */
2826 if (htab->tls_sec == NULL)
2827 return 0;
2828
2829 /* Consider special static TLS alignment requirements. */
2830 static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
2831 return address - static_tls_size - htab->tls_sec->vma;
2832 }
2833
2834 /* Return the relocation value for a %gdop relocation. */
2835
2836 static bfd_vma
2837 gdopoff (struct bfd_link_info *info, bfd_vma address)
2838 {
2839 struct elf_link_hash_table *htab = elf_hash_table (info);
2840 bfd_vma got_base;
2841
2842 got_base = (htab->hgot->root.u.def.value
2843 + htab->hgot->root.u.def.section->output_offset
2844 + htab->hgot->root.u.def.section->output_section->vma);
2845
2846 return address - got_base;
2847 }
2848
2849 /* Relocate a SPARC ELF section. */
2850
2851 bfd_boolean
2852 _bfd_sparc_elf_relocate_section (bfd *output_bfd,
2853 struct bfd_link_info *info,
2854 bfd *input_bfd,
2855 asection *input_section,
2856 bfd_byte *contents,
2857 Elf_Internal_Rela *relocs,
2858 Elf_Internal_Sym *local_syms,
2859 asection **local_sections)
2860 {
2861 struct _bfd_sparc_elf_link_hash_table *htab;
2862 Elf_Internal_Shdr *symtab_hdr;
2863 struct elf_link_hash_entry **sym_hashes;
2864 bfd_vma *local_got_offsets;
2865 bfd_vma got_base;
2866 asection *sreloc;
2867 Elf_Internal_Rela *rel;
2868 Elf_Internal_Rela *relend;
2869 int num_relocs;
2870 bfd_boolean is_vxworks_tls;
2871
2872 htab = _bfd_sparc_elf_hash_table (info);
2873 BFD_ASSERT (htab != NULL);
2874 symtab_hdr = &elf_symtab_hdr (input_bfd);
2875 sym_hashes = elf_sym_hashes (input_bfd);
2876 local_got_offsets = elf_local_got_offsets (input_bfd);
2877
2878 if (elf_hash_table (info)->hgot == NULL)
2879 got_base = 0;
2880 else
2881 got_base = elf_hash_table (info)->hgot->root.u.def.value;
2882
2883 sreloc = elf_section_data (input_section)->sreloc;
2884 /* We have to handle relocations in vxworks .tls_vars sections
2885 specially, because the dynamic loader is 'weird'. */
2886 is_vxworks_tls = (htab->is_vxworks && info->shared
2887 && !strcmp (input_section->output_section->name,
2888 ".tls_vars"));
2889
2890 rel = relocs;
2891 if (ABI_64_P (output_bfd))
2892 num_relocs = NUM_SHDR_ENTRIES (_bfd_elf_single_rel_hdr (input_section));
2893 else
2894 num_relocs = input_section->reloc_count;
2895 relend = relocs + num_relocs;
2896 for (; rel < relend; rel++)
2897 {
2898 int r_type, tls_type;
2899 reloc_howto_type *howto;
2900 unsigned long r_symndx;
2901 struct elf_link_hash_entry *h;
2902 Elf_Internal_Sym *sym;
2903 asection *sec;
2904 bfd_vma relocation, off;
2905 bfd_reloc_status_type r;
2906 bfd_boolean is_plt = FALSE;
2907 bfd_boolean unresolved_reloc;
2908
2909 r_type = SPARC_ELF_R_TYPE (rel->r_info);
2910 if (r_type == R_SPARC_GNU_VTINHERIT
2911 || r_type == R_SPARC_GNU_VTENTRY)
2912 continue;
2913
2914 if (r_type < 0 || r_type >= (int) R_SPARC_max_std)
2915 {
2916 bfd_set_error (bfd_error_bad_value);
2917 return FALSE;
2918 }
2919 howto = _bfd_sparc_elf_howto_table + r_type;
2920
2921 r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
2922 h = NULL;
2923 sym = NULL;
2924 sec = NULL;
2925 unresolved_reloc = FALSE;
2926 if (r_symndx < symtab_hdr->sh_info)
2927 {
2928 sym = local_syms + r_symndx;
2929 sec = local_sections[r_symndx];
2930 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2931
2932 if (!info->relocatable
2933 && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
2934 {
2935 /* Relocate against local STT_GNU_IFUNC symbol. */
2936 h = elf_sparc_get_local_sym_hash (htab, input_bfd,
2937 rel, FALSE);
2938 if (h == NULL)
2939 abort ();
2940
2941 /* Set STT_GNU_IFUNC symbol value. */
2942 h->root.u.def.value = sym->st_value;
2943 h->root.u.def.section = sec;
2944 }
2945 }
2946 else
2947 {
2948 bfd_boolean warned;
2949
2950 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2951 r_symndx, symtab_hdr, sym_hashes,
2952 h, sec, relocation,
2953 unresolved_reloc, warned);
2954 if (warned)
2955 {
2956 /* To avoid generating warning messages about truncated
2957 relocations, set the relocation's address to be the same as
2958 the start of this section. */
2959 if (input_section->output_section != NULL)
2960 relocation = input_section->output_section->vma;
2961 else
2962 relocation = 0;
2963 }
2964 }
2965
2966 if (sec != NULL && elf_discarded_section (sec))
2967 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
2968 rel, relend, howto, contents);
2969
2970 if (info->relocatable)
2971 continue;
2972
2973 if (h != NULL
2974 && h->type == STT_GNU_IFUNC
2975 && h->def_regular)
2976 {
2977 asection *plt_sec;
2978 const char *name;
2979
2980 if ((input_section->flags & SEC_ALLOC) == 0
2981 || h->plt.offset == (bfd_vma) -1)
2982 abort ();
2983
2984 plt_sec = htab->elf.splt;
2985 if (! plt_sec)
2986 plt_sec =htab->elf.iplt;
2987
2988 switch (r_type)
2989 {
2990 case R_SPARC_GOTDATA_OP:
2991 continue;
2992
2993 case R_SPARC_GOTDATA_OP_HIX22:
2994 case R_SPARC_GOTDATA_OP_LOX10:
2995 r_type = (r_type == R_SPARC_GOTDATA_OP_HIX22
2996 ? R_SPARC_GOT22
2997 : R_SPARC_GOT10);
2998 howto = _bfd_sparc_elf_howto_table + r_type;
2999 /* Fall through. */
3000
3001 case R_SPARC_GOT10:
3002 case R_SPARC_GOT13:
3003 case R_SPARC_GOT22:
3004 if (htab->elf.sgot == NULL)
3005 abort ();
3006 off = h->got.offset;
3007 if (off == (bfd_vma) -1)
3008 abort();
3009 relocation = htab->elf.sgot->output_offset + off - got_base;
3010 goto do_relocation;
3011
3012 case R_SPARC_WPLT30:
3013 case R_SPARC_WDISP30:
3014 relocation = (plt_sec->output_section->vma
3015 + plt_sec->output_offset + h->plt.offset);
3016 goto do_relocation;
3017
3018 case R_SPARC_32:
3019 case R_SPARC_64:
3020 if (info->shared && h->non_got_ref)
3021 {
3022 Elf_Internal_Rela outrel;
3023 bfd_vma offset;
3024
3025 offset = _bfd_elf_section_offset (output_bfd, info,
3026 input_section,
3027 rel->r_offset);
3028 if (offset == (bfd_vma) -1
3029 || offset == (bfd_vma) -2)
3030 abort();
3031
3032 outrel.r_offset = (input_section->output_section->vma
3033 + input_section->output_offset
3034 + offset);
3035
3036 if (h->dynindx == -1
3037 || h->forced_local
3038 || info->executable)
3039 {
3040 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
3041 0, R_SPARC_IRELATIVE);
3042 outrel.r_addend = relocation + rel->r_addend;
3043 }
3044 else
3045 {
3046 if (h->dynindx == -1)
3047 abort();
3048 outrel.r_info = SPARC_ELF_R_INFO (htab, rel, h->dynindx, r_type);
3049 outrel.r_addend = rel->r_addend;
3050 }
3051
3052 sparc_elf_append_rela (output_bfd, sreloc, &outrel);
3053 continue;
3054 }
3055
3056 relocation = (plt_sec->output_section->vma
3057 + plt_sec->output_offset + h->plt.offset);
3058 goto do_relocation;
3059
3060 case R_SPARC_HI22:
3061 case R_SPARC_LO10:
3062 /* We should only see such relocs in static links. */
3063 if (info->shared)
3064 abort();
3065 relocation = (plt_sec->output_section->vma
3066 + plt_sec->output_offset + h->plt.offset);
3067 goto do_relocation;
3068
3069 default:
3070 if (h->root.root.string)
3071 name = h->root.root.string;
3072 else
3073 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3074 NULL);
3075 (*_bfd_error_handler)
3076 (_("%B: relocation %s against STT_GNU_IFUNC "
3077 "symbol `%s' isn't handled by %s"), input_bfd,
3078 _bfd_sparc_elf_howto_table[r_type].name,
3079 name, __FUNCTION__);
3080 bfd_set_error (bfd_error_bad_value);
3081 return FALSE;
3082 }
3083 }
3084
3085 switch (r_type)
3086 {
3087 case R_SPARC_GOTDATA_OP_HIX22:
3088 case R_SPARC_GOTDATA_OP_LOX10:
3089 if (SYMBOL_REFERENCES_LOCAL (info, h))
3090 r_type = (r_type == R_SPARC_GOTDATA_OP_HIX22
3091 ? R_SPARC_GOTDATA_HIX22
3092 : R_SPARC_GOTDATA_LOX10);
3093 else
3094 r_type = (r_type == R_SPARC_GOTDATA_OP_HIX22
3095 ? R_SPARC_GOT22
3096 : R_SPARC_GOT10);
3097 howto = _bfd_sparc_elf_howto_table + r_type;
3098 break;
3099
3100 case R_SPARC_GOTDATA_OP:
3101 if (SYMBOL_REFERENCES_LOCAL (info, h))
3102 {
3103 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3104
3105 /* {ld,ldx} [%rs1 + %rs2], %rd --> add %rs1, %rs2, %rd */
3106 relocation = 0x80000000 | (insn & 0x3e07c01f);
3107 bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3108 }
3109 continue;
3110 }
3111
3112 switch (r_type)
3113 {
3114 case R_SPARC_GOTDATA_HIX22:
3115 case R_SPARC_GOTDATA_LOX10:
3116 relocation = gdopoff (info, relocation);
3117 break;
3118
3119 case R_SPARC_GOT10:
3120 case R_SPARC_GOT13:
3121 case R_SPARC_GOT22:
3122 /* Relocation is to the entry for this symbol in the global
3123 offset table. */
3124 if (htab->elf.sgot == NULL)
3125 abort ();
3126
3127 if (h != NULL)
3128 {
3129 bfd_boolean dyn;
3130
3131 off = h->got.offset;
3132 BFD_ASSERT (off != (bfd_vma) -1);
3133 dyn = elf_hash_table (info)->dynamic_sections_created;
3134
3135 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3136 || (info->shared
3137 && SYMBOL_REFERENCES_LOCAL (info, h)))
3138 {
3139 /* This is actually a static link, or it is a
3140 -Bsymbolic link and the symbol is defined
3141 locally, or the symbol was forced to be local
3142 because of a version file. We must initialize
3143 this entry in the global offset table. Since the
3144 offset must always be a multiple of 8 for 64-bit
3145 and 4 for 32-bit, we use the least significant bit
3146 to record whether we have initialized it already.
3147
3148 When doing a dynamic link, we create a .rela.got
3149 relocation entry to initialize the value. This
3150 is done in the finish_dynamic_symbol routine. */
3151 if ((off & 1) != 0)
3152 off &= ~1;
3153 else
3154 {
3155 SPARC_ELF_PUT_WORD (htab, output_bfd, relocation,
3156 htab->elf.sgot->contents + off);
3157 h->got.offset |= 1;
3158 }
3159 }
3160 else
3161 unresolved_reloc = FALSE;
3162 }
3163 else
3164 {
3165 BFD_ASSERT (local_got_offsets != NULL
3166 && local_got_offsets[r_symndx] != (bfd_vma) -1);
3167
3168 off = local_got_offsets[r_symndx];
3169
3170 /* The offset must always be a multiple of 8 on 64-bit and
3171 4 on 32-bit. We use the least significant bit to record
3172 whether we have already processed this entry. */
3173 if ((off & 1) != 0)
3174 off &= ~1;
3175 else
3176 {
3177
3178 if (info->shared)
3179 {
3180 asection *s;
3181 Elf_Internal_Rela outrel;
3182
3183 /* We need to generate a R_SPARC_RELATIVE reloc
3184 for the dynamic linker. */
3185 s = htab->elf.srelgot;
3186 BFD_ASSERT (s != NULL);
3187
3188 outrel.r_offset = (htab->elf.sgot->output_section->vma
3189 + htab->elf.sgot->output_offset
3190 + off);
3191 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
3192 0, R_SPARC_RELATIVE);
3193 outrel.r_addend = relocation;
3194 relocation = 0;
3195 sparc_elf_append_rela (output_bfd, s, &outrel);
3196 }
3197
3198 SPARC_ELF_PUT_WORD (htab, output_bfd, relocation,
3199 htab->elf.sgot->contents + off);
3200 local_got_offsets[r_symndx] |= 1;
3201 }
3202 }
3203 relocation = htab->elf.sgot->output_offset + off - got_base;
3204 break;
3205
3206 case R_SPARC_PLT32:
3207 case R_SPARC_PLT64:
3208 if (h == NULL || h->plt.offset == (bfd_vma) -1)
3209 {
3210 r_type = (r_type == R_SPARC_PLT32) ? R_SPARC_32 : R_SPARC_64;
3211 goto r_sparc_plt32;
3212 }
3213 /* Fall through. */
3214
3215 case R_SPARC_WPLT30:
3216 case R_SPARC_HIPLT22:
3217 case R_SPARC_LOPLT10:
3218 case R_SPARC_PCPLT32:
3219 case R_SPARC_PCPLT22:
3220 case R_SPARC_PCPLT10:
3221 r_sparc_wplt30:
3222 /* Relocation is to the entry for this symbol in the
3223 procedure linkage table. */
3224
3225 if (! ABI_64_P (output_bfd))
3226 {
3227 /* The Solaris native assembler will generate a WPLT30 reloc
3228 for a local symbol if you assemble a call from one
3229 section to another when using -K pic. We treat it as
3230 WDISP30. */
3231 if (h == NULL)
3232 break;
3233 }
3234 /* PR 7027: We need similar behaviour for 64-bit binaries. */
3235 else if (r_type == R_SPARC_WPLT30 && h == NULL)
3236 break;
3237 else
3238 {
3239 BFD_ASSERT (h != NULL);
3240 }
3241
3242 if (h->plt.offset == (bfd_vma) -1 || htab->elf.splt == NULL)
3243 {
3244 /* We didn't make a PLT entry for this symbol. This
3245 happens when statically linking PIC code, or when
3246 using -Bsymbolic. */
3247 break;
3248 }
3249
3250 relocation = (htab->elf.splt->output_section->vma
3251 + htab->elf.splt->output_offset
3252 + h->plt.offset);
3253 unresolved_reloc = FALSE;
3254 if (r_type == R_SPARC_PLT32 || r_type == R_SPARC_PLT64)
3255 {
3256 r_type = r_type == R_SPARC_PLT32 ? R_SPARC_32 : R_SPARC_64;
3257 is_plt = TRUE;
3258 goto r_sparc_plt32;
3259 }
3260 break;
3261
3262 case R_SPARC_PC10:
3263 case R_SPARC_PC22:
3264 case R_SPARC_PC_HH22:
3265 case R_SPARC_PC_HM10:
3266 case R_SPARC_PC_LM22:
3267 if (h != NULL
3268 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3269 break;
3270 /* Fall through. */
3271 case R_SPARC_DISP8:
3272 case R_SPARC_DISP16:
3273 case R_SPARC_DISP32:
3274 case R_SPARC_DISP64:
3275 case R_SPARC_WDISP30:
3276 case R_SPARC_WDISP22:
3277 case R_SPARC_WDISP19:
3278 case R_SPARC_WDISP16:
3279 case R_SPARC_8:
3280 case R_SPARC_16:
3281 case R_SPARC_32:
3282 case R_SPARC_HI22:
3283 case R_SPARC_22:
3284 case R_SPARC_13:
3285 case R_SPARC_LO10:
3286 case R_SPARC_UA16:
3287 case R_SPARC_UA32:
3288 case R_SPARC_10:
3289 case R_SPARC_11:
3290 case R_SPARC_64:
3291 case R_SPARC_OLO10:
3292 case R_SPARC_HH22:
3293 case R_SPARC_HM10:
3294 case R_SPARC_LM22:
3295 case R_SPARC_7:
3296 case R_SPARC_5:
3297 case R_SPARC_6:
3298 case R_SPARC_HIX22:
3299 case R_SPARC_LOX10:
3300 case R_SPARC_H44:
3301 case R_SPARC_M44:
3302 case R_SPARC_L44:
3303 case R_SPARC_UA64:
3304 r_sparc_plt32:
3305 if ((input_section->flags & SEC_ALLOC) == 0
3306 || is_vxworks_tls)
3307 break;
3308
3309 if ((info->shared
3310 && (h == NULL
3311 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3312 || h->root.type != bfd_link_hash_undefweak)
3313 && (! howto->pc_relative
3314 || !SYMBOL_CALLS_LOCAL (info, h)))
3315 || (!info->shared
3316 && h != NULL
3317 && h->dynindx != -1
3318 && !h->non_got_ref
3319 && ((h->def_dynamic
3320 && !h->def_regular)
3321 || h->root.type == bfd_link_hash_undefweak
3322 || h->root.type == bfd_link_hash_undefined)))
3323 {
3324 Elf_Internal_Rela outrel;
3325 bfd_boolean skip, relocate = FALSE;
3326
3327 /* When generating a shared object, these relocations
3328 are copied into the output file to be resolved at run
3329 time. */
3330
3331 BFD_ASSERT (sreloc != NULL);
3332
3333 skip = FALSE;
3334
3335 outrel.r_offset =
3336 _bfd_elf_section_offset (output_bfd, info, input_section,
3337 rel->r_offset);
3338 if (outrel.r_offset == (bfd_vma) -1)
3339 skip = TRUE;
3340 else if (outrel.r_offset == (bfd_vma) -2)
3341 skip = TRUE, relocate = TRUE;
3342 outrel.r_offset += (input_section->output_section->vma
3343 + input_section->output_offset);
3344
3345 /* Optimize unaligned reloc usage now that we know where
3346 it finally resides. */
3347 switch (r_type)
3348 {
3349 case R_SPARC_16:
3350 if (outrel.r_offset & 1)
3351 r_type = R_SPARC_UA16;
3352 break;
3353 case R_SPARC_UA16:
3354 if (!(outrel.r_offset & 1))
3355 r_type = R_SPARC_16;
3356 break;
3357 case R_SPARC_32:
3358 if (outrel.r_offset & 3)
3359 r_type = R_SPARC_UA32;
3360 break;
3361 case R_SPARC_UA32:
3362 if (!(outrel.r_offset & 3))
3363 r_type = R_SPARC_32;
3364 break;
3365 case R_SPARC_64:
3366 if (outrel.r_offset & 7)
3367 r_type = R_SPARC_UA64;
3368 break;
3369 case R_SPARC_UA64:
3370 if (!(outrel.r_offset & 7))
3371 r_type = R_SPARC_64;
3372 break;
3373 case R_SPARC_DISP8:
3374 case R_SPARC_DISP16:
3375 case R_SPARC_DISP32:
3376 case R_SPARC_DISP64:
3377 /* If the symbol is not dynamic, we should not keep
3378 a dynamic relocation. But an .rela.* slot has been
3379 allocated for it, output R_SPARC_NONE.
3380 FIXME: Add code tracking needed dynamic relocs as
3381 e.g. i386 has. */
3382 if (h->dynindx == -1)
3383 skip = TRUE, relocate = TRUE;
3384 break;
3385 }
3386
3387 if (skip)
3388 memset (&outrel, 0, sizeof outrel);
3389 /* h->dynindx may be -1 if the symbol was marked to
3390 become local. */
3391 else if (h != NULL &&
3392 h->dynindx != -1
3393 && (! is_plt
3394 || !info->shared
3395 || !SYMBOLIC_BIND (info, h)
3396 || !h->def_regular))
3397 {
3398 BFD_ASSERT (h->dynindx != -1);
3399 outrel.r_info = SPARC_ELF_R_INFO (htab, rel, h->dynindx, r_type);
3400 outrel.r_addend = rel->r_addend;
3401 }
3402 else
3403 {
3404 if (r_type == R_SPARC_32 || r_type == R_SPARC_64)
3405 {
3406 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
3407 0, R_SPARC_RELATIVE);
3408 outrel.r_addend = relocation + rel->r_addend;
3409 }
3410 else
3411 {
3412 long indx;
3413
3414 outrel.r_addend = relocation + rel->r_addend;
3415
3416 if (is_plt)
3417 sec = htab->elf.splt;
3418
3419 if (bfd_is_abs_section (sec))
3420 indx = 0;
3421 else if (sec == NULL || sec->owner == NULL)
3422 {
3423 bfd_set_error (bfd_error_bad_value);
3424 return FALSE;
3425 }
3426 else
3427 {
3428 asection *osec;
3429
3430 /* We are turning this relocation into one
3431 against a section symbol. It would be
3432 proper to subtract the symbol's value,
3433 osec->vma, from the emitted reloc addend,
3434 but ld.so expects buggy relocs. */
3435 osec = sec->output_section;
3436 indx = elf_section_data (osec)->dynindx;
3437
3438 if (indx == 0)
3439 {
3440 osec = htab->elf.text_index_section;
3441 indx = elf_section_data (osec)->dynindx;
3442 }
3443
3444 /* FIXME: we really should be able to link non-pic
3445 shared libraries. */
3446 if (indx == 0)
3447 {
3448 BFD_FAIL ();
3449 (*_bfd_error_handler)
3450 (_("%B: probably compiled without -fPIC?"),
3451 input_bfd);
3452 bfd_set_error (bfd_error_bad_value);
3453 return FALSE;
3454 }
3455 }
3456
3457 outrel.r_info = SPARC_ELF_R_INFO (htab, rel, indx,
3458 r_type);
3459 }
3460 }
3461
3462 sparc_elf_append_rela (output_bfd, sreloc, &outrel);
3463
3464 /* This reloc will be computed at runtime, so there's no
3465 need to do anything now. */
3466 if (! relocate)
3467 continue;
3468 }
3469 break;
3470
3471 case R_SPARC_TLS_GD_HI22:
3472 if (! ABI_64_P (input_bfd)
3473 && ! _bfd_sparc_elf_tdata (input_bfd)->has_tlsgd)
3474 {
3475 /* R_SPARC_REV32 used the same reloc number as
3476 R_SPARC_TLS_GD_HI22. */
3477 r_type = R_SPARC_REV32;
3478 break;
3479 }
3480 /* Fall through */
3481
3482 case R_SPARC_TLS_GD_LO10:
3483 case R_SPARC_TLS_IE_HI22:
3484 case R_SPARC_TLS_IE_LO10:
3485 r_type = sparc_elf_tls_transition (info, input_bfd, r_type, h == NULL);
3486 tls_type = GOT_UNKNOWN;
3487 if (h == NULL && local_got_offsets)
3488 tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3489 else if (h != NULL)
3490 {
3491 tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3492 if (!info->shared && h->dynindx == -1 && tls_type == GOT_TLS_IE)
3493 switch (SPARC_ELF_R_TYPE (rel->r_info))
3494 {
3495 case R_SPARC_TLS_GD_HI22:
3496 case R_SPARC_TLS_IE_HI22:
3497 r_type = R_SPARC_TLS_LE_HIX22;
3498 break;
3499 default:
3500 r_type = R_SPARC_TLS_LE_LOX10;
3501 break;
3502 }
3503 }
3504 if (tls_type == GOT_TLS_IE)
3505 switch (r_type)
3506 {
3507 case R_SPARC_TLS_GD_HI22:
3508 r_type = R_SPARC_TLS_IE_HI22;
3509 break;
3510 case R_SPARC_TLS_GD_LO10:
3511 r_type = R_SPARC_TLS_IE_LO10;
3512 break;
3513 }
3514
3515 if (r_type == R_SPARC_TLS_LE_HIX22)
3516 {
3517 relocation = tpoff (info, relocation);
3518 break;
3519 }
3520 if (r_type == R_SPARC_TLS_LE_LOX10)
3521 {
3522 /* Change add into xor. */
3523 relocation = tpoff (info, relocation);
3524 bfd_put_32 (output_bfd, (bfd_get_32 (input_bfd,
3525 contents + rel->r_offset)
3526 | 0x80182000), contents + rel->r_offset);
3527 break;
3528 }
3529
3530 if (h != NULL)
3531 {
3532 off = h->got.offset;
3533 h->got.offset |= 1;
3534 }
3535 else
3536 {
3537 BFD_ASSERT (local_got_offsets != NULL);
3538 off = local_got_offsets[r_symndx];
3539 local_got_offsets[r_symndx] |= 1;
3540 }
3541
3542 r_sparc_tlsldm:
3543 if (htab->elf.sgot == NULL)
3544 abort ();
3545
3546 if ((off & 1) != 0)
3547 off &= ~1;
3548 else
3549 {
3550 Elf_Internal_Rela outrel;
3551 int dr_type, indx;
3552
3553 if (htab->elf.srelgot == NULL)
3554 abort ();
3555
3556 SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3557 htab->elf.sgot->contents + off);
3558 outrel.r_offset = (htab->elf.sgot->output_section->vma
3559 + htab->elf.sgot->output_offset + off);
3560 indx = h && h->dynindx != -1 ? h->dynindx : 0;
3561 if (r_type == R_SPARC_TLS_IE_HI22
3562 || r_type == R_SPARC_TLS_IE_LO10)
3563 dr_type = SPARC_ELF_TPOFF_RELOC (htab);
3564 else
3565 dr_type = SPARC_ELF_DTPMOD_RELOC (htab);
3566 if (dr_type == SPARC_ELF_TPOFF_RELOC (htab) && indx == 0)
3567 outrel.r_addend = relocation - dtpoff_base (info);
3568 else
3569 outrel.r_addend = 0;
3570 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx, dr_type);
3571 sparc_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel);
3572
3573 if (r_type == R_SPARC_TLS_GD_HI22
3574 || r_type == R_SPARC_TLS_GD_LO10)
3575 {
3576 if (indx == 0)
3577 {
3578 BFD_ASSERT (! unresolved_reloc);
3579 SPARC_ELF_PUT_WORD (htab, output_bfd,
3580 relocation - dtpoff_base (info),
3581 (htab->elf.sgot->contents + off
3582 + SPARC_ELF_WORD_BYTES (htab)));
3583 }
3584 else
3585 {
3586 SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3587 (htab->elf.sgot->contents + off
3588 + SPARC_ELF_WORD_BYTES (htab)));
3589 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx,
3590 SPARC_ELF_DTPOFF_RELOC (htab));
3591 outrel.r_offset += SPARC_ELF_WORD_BYTES (htab);
3592 sparc_elf_append_rela (output_bfd, htab->elf.srelgot,
3593 &outrel);
3594 }
3595 }
3596 else if (dr_type == SPARC_ELF_DTPMOD_RELOC (htab))
3597 {
3598 SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3599 (htab->elf.sgot->contents + off
3600 + SPARC_ELF_WORD_BYTES (htab)));
3601 }
3602 }
3603
3604 if (off >= (bfd_vma) -2)
3605 abort ();
3606
3607 relocation = htab->elf.sgot->output_offset + off - got_base;
3608 unresolved_reloc = FALSE;
3609 howto = _bfd_sparc_elf_howto_table + r_type;
3610 break;
3611
3612 case R_SPARC_TLS_LDM_HI22:
3613 case R_SPARC_TLS_LDM_LO10:
3614 if (! info->shared)
3615 {
3616 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3617 continue;
3618 }
3619 off = htab->tls_ldm_got.offset;
3620 htab->tls_ldm_got.offset |= 1;
3621 goto r_sparc_tlsldm;
3622
3623 case R_SPARC_TLS_LDO_HIX22:
3624 case R_SPARC_TLS_LDO_LOX10:
3625 if (info->shared)
3626 {
3627 relocation -= dtpoff_base (info);
3628 break;
3629 }
3630
3631 r_type = (r_type == R_SPARC_TLS_LDO_HIX22
3632 ? R_SPARC_TLS_LE_HIX22 : R_SPARC_TLS_LE_LOX10);
3633 /* Fall through. */
3634
3635 case R_SPARC_TLS_LE_HIX22:
3636 case R_SPARC_TLS_LE_LOX10:
3637 if (info->shared)
3638 {
3639 Elf_Internal_Rela outrel;
3640 bfd_boolean skip;
3641
3642 BFD_ASSERT (sreloc != NULL);
3643 skip = FALSE;
3644 outrel.r_offset =
3645 _bfd_elf_section_offset (output_bfd, info, input_section,
3646 rel->r_offset);
3647 if (outrel.r_offset == (bfd_vma) -1)
3648 skip = TRUE;
3649 else if (outrel.r_offset == (bfd_vma) -2)
3650 skip = TRUE;
3651 outrel.r_offset += (input_section->output_section->vma
3652 + input_section->output_offset);
3653 if (skip)
3654 memset (&outrel, 0, sizeof outrel);
3655 else
3656 {
3657 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, r_type);
3658 outrel.r_addend = relocation - dtpoff_base (info)
3659 + rel->r_addend;
3660 }
3661
3662 sparc_elf_append_rela (output_bfd, sreloc, &outrel);
3663 continue;
3664 }
3665 relocation = tpoff (info, relocation);
3666 break;
3667
3668 case R_SPARC_TLS_LDM_CALL:
3669 if (! info->shared)
3670 {
3671 /* mov %g0, %o0 */
3672 bfd_put_32 (output_bfd, 0x90100000, contents + rel->r_offset);
3673 continue;
3674 }
3675 /* Fall through */
3676
3677 case R_SPARC_TLS_GD_CALL:
3678 tls_type = GOT_UNKNOWN;
3679 if (h == NULL && local_got_offsets)
3680 tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3681 else if (h != NULL)
3682 tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3683 if (! info->shared
3684 || (r_type == R_SPARC_TLS_GD_CALL && tls_type == GOT_TLS_IE))
3685 {
3686 Elf_Internal_Rela *rel2;
3687 bfd_vma insn;
3688
3689 if (!info->shared && (h == NULL || h->dynindx == -1))
3690 {
3691 /* GD -> LE */
3692 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3693 continue;
3694 }
3695
3696 /* GD -> IE */
3697 if (rel + 1 < relend
3698 && SPARC_ELF_R_TYPE (rel[1].r_info) == R_SPARC_TLS_GD_ADD
3699 && rel[1].r_offset == rel->r_offset + 4
3700 && SPARC_ELF_R_SYMNDX (htab, rel[1].r_info) == r_symndx
3701 && (((insn = bfd_get_32 (input_bfd,
3702 contents + rel[1].r_offset))
3703 >> 25) & 0x1f) == 8)
3704 {
3705 /* We have
3706 call __tls_get_addr, %tgd_call(foo)
3707 add %reg1, %reg2, %o0, %tgd_add(foo)
3708 and change it into IE:
3709 {ld,ldx} [%reg1 + %reg2], %o0, %tie_ldx(foo)
3710 add %g7, %o0, %o0, %tie_add(foo).
3711 add is 0x80000000 | (rd << 25) | (rs1 << 14) | rs2,
3712 ld is 0xc0000000 | (rd << 25) | (rs1 << 14) | rs2,
3713 ldx is 0xc0580000 | (rd << 25) | (rs1 << 14) | rs2. */
3714 bfd_put_32 (output_bfd, insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000),
3715 contents + rel->r_offset);
3716 bfd_put_32 (output_bfd, 0x9001c008,
3717 contents + rel->r_offset + 4);
3718 rel++;
3719 continue;
3720 }
3721
3722 /* We cannot just overwrite the delay slot instruction,
3723 as it might be what puts the %o0 argument to
3724 __tls_get_addr into place. So we have to transpose
3725 the delay slot with the add we patch in. */
3726 insn = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
3727 bfd_put_32 (output_bfd, insn,
3728 contents + rel->r_offset);
3729 bfd_put_32 (output_bfd, 0x9001c008,
3730 contents + rel->r_offset + 4);
3731
3732 rel2 = rel;
3733 while ((rel2 = sparc_elf_find_reloc_at_ofs (rel2 + 1, relend,
3734 rel->r_offset + 4))
3735 != NULL)
3736 {
3737 /* If the instruction we moved has a relocation attached to
3738 it, adjust the offset so that it will apply to the correct
3739 instruction. */
3740 rel2->r_offset -= 4;
3741 }
3742 continue;
3743 }
3744
3745 h = (struct elf_link_hash_entry *)
3746 bfd_link_hash_lookup (info->hash, "__tls_get_addr", FALSE,
3747 FALSE, TRUE);
3748 BFD_ASSERT (h != NULL);
3749 r_type = R_SPARC_WPLT30;
3750 howto = _bfd_sparc_elf_howto_table + r_type;
3751 goto r_sparc_wplt30;
3752
3753 case R_SPARC_TLS_GD_ADD:
3754 tls_type = GOT_UNKNOWN;
3755 if (h == NULL && local_got_offsets)
3756 tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3757 else if (h != NULL)
3758 tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3759 if (! info->shared || tls_type == GOT_TLS_IE)
3760 {
3761 /* add %reg1, %reg2, %reg3, %tgd_add(foo)
3762 changed into IE:
3763 {ld,ldx} [%reg1 + %reg2], %reg3, %tie_ldx(foo)
3764 or LE:
3765 add %g7, %reg2, %reg3. */
3766 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3767 if ((h != NULL && h->dynindx != -1) || info->shared)
3768 relocation = insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000);
3769 else
3770 relocation = (insn & ~0x7c000) | 0x1c000;
3771 bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3772 }
3773 continue;
3774
3775 case R_SPARC_TLS_LDM_ADD:
3776 if (! info->shared)
3777 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3778 continue;
3779
3780 case R_SPARC_TLS_LDO_ADD:
3781 if (! info->shared)
3782 {
3783 /* Change rs1 into %g7. */
3784 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3785 insn = (insn & ~0x7c000) | 0x1c000;
3786 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3787 }
3788 continue;
3789
3790 case R_SPARC_TLS_IE_LD:
3791 case R_SPARC_TLS_IE_LDX:
3792 if (! info->shared && (h == NULL || h->dynindx == -1))
3793 {
3794 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3795 int rs2 = insn & 0x1f;
3796 int rd = (insn >> 25) & 0x1f;
3797
3798 if (rs2 == rd)
3799 relocation = SPARC_NOP;
3800 else
3801 relocation = 0x80100000 | (insn & 0x3e00001f);
3802 bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3803 }
3804 continue;
3805
3806 case R_SPARC_TLS_IE_ADD:
3807 /* Totally useless relocation. */
3808 continue;
3809
3810 case R_SPARC_TLS_DTPOFF32:
3811 case R_SPARC_TLS_DTPOFF64:
3812 relocation -= dtpoff_base (info);
3813 break;
3814
3815 default:
3816 break;
3817 }
3818
3819 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3820 because such sections are not SEC_ALLOC and thus ld.so will
3821 not process them. */
3822 if (unresolved_reloc
3823 && !((input_section->flags & SEC_DEBUGGING) != 0
3824 && h->def_dynamic)
3825 && _bfd_elf_section_offset (output_bfd, info, input_section,
3826 rel->r_offset) != (bfd_vma) -1)
3827 (*_bfd_error_handler)
3828 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3829 input_bfd,
3830 input_section,
3831 (long) rel->r_offset,
3832 howto->name,
3833 h->root.root.string);
3834
3835 r = bfd_reloc_continue;
3836 if (r_type == R_SPARC_OLO10)
3837 {
3838 bfd_vma x;
3839
3840 if (! ABI_64_P (output_bfd))
3841 abort ();
3842
3843 relocation += rel->r_addend;
3844 relocation = (relocation & 0x3ff) + ELF64_R_TYPE_DATA (rel->r_info);
3845
3846 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3847 x = (x & ~(bfd_vma) 0x1fff) | (relocation & 0x1fff);
3848 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3849
3850 r = bfd_check_overflow (howto->complain_on_overflow,
3851 howto->bitsize, howto->rightshift,
3852 bfd_arch_bits_per_address (input_bfd),
3853 relocation);
3854 }
3855 else if (r_type == R_SPARC_WDISP16)
3856 {
3857 bfd_vma x;
3858
3859 relocation += rel->r_addend;
3860 relocation -= (input_section->output_section->vma
3861 + input_section->output_offset);
3862 relocation -= rel->r_offset;
3863
3864 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3865 x |= ((((relocation >> 2) & 0xc000) << 6)
3866 | ((relocation >> 2) & 0x3fff));
3867 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3868
3869 r = bfd_check_overflow (howto->complain_on_overflow,
3870 howto->bitsize, howto->rightshift,
3871 bfd_arch_bits_per_address (input_bfd),
3872 relocation);
3873 }
3874 else if (r_type == R_SPARC_REV32)
3875 {
3876 bfd_vma x;
3877
3878 relocation = relocation + rel->r_addend;
3879
3880 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3881 x = x + relocation;
3882 bfd_putl32 (/*input_bfd,*/ x, contents + rel->r_offset);
3883 r = bfd_reloc_ok;
3884 }
3885 else if (r_type == R_SPARC_TLS_LDO_HIX22
3886 || r_type == R_SPARC_TLS_LE_HIX22)
3887 {
3888 bfd_vma x;
3889
3890 relocation += rel->r_addend;
3891 if (r_type == R_SPARC_TLS_LE_HIX22)
3892 relocation ^= MINUS_ONE;
3893
3894 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3895 x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
3896 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3897 r = bfd_reloc_ok;
3898 }
3899 else if (r_type == R_SPARC_TLS_LDO_LOX10
3900 || r_type == R_SPARC_TLS_LE_LOX10)
3901 {
3902 bfd_vma x;
3903
3904 relocation += rel->r_addend;
3905 relocation &= 0x3ff;
3906 if (r_type == R_SPARC_TLS_LE_LOX10)
3907 relocation |= 0x1c00;
3908
3909 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3910 x = (x & ~(bfd_vma) 0x1fff) | relocation;
3911 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3912
3913 r = bfd_reloc_ok;
3914 }
3915 else if (r_type == R_SPARC_HIX22
3916 || r_type == R_SPARC_GOTDATA_HIX22)
3917 {
3918 bfd_vma x;
3919
3920 relocation += rel->r_addend;
3921 if (r_type == R_SPARC_HIX22
3922 || (bfd_signed_vma) relocation < 0)
3923 relocation = relocation ^ MINUS_ONE;
3924
3925 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3926 x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
3927 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3928
3929 r = bfd_check_overflow (howto->complain_on_overflow,
3930 howto->bitsize, howto->rightshift,
3931 bfd_arch_bits_per_address (input_bfd),
3932 relocation);
3933 }
3934 else if (r_type == R_SPARC_LOX10
3935 || r_type == R_SPARC_GOTDATA_LOX10)
3936 {
3937 bfd_vma x;
3938
3939 relocation += rel->r_addend;
3940 if (r_type == R_SPARC_LOX10
3941 || (bfd_signed_vma) relocation < 0)
3942 relocation = (relocation & 0x3ff) | 0x1c00;
3943 else
3944 relocation = (relocation & 0x3ff);
3945
3946 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3947 x = (x & ~(bfd_vma) 0x1fff) | relocation;
3948 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3949
3950 r = bfd_reloc_ok;
3951 }
3952 else if ((r_type == R_SPARC_WDISP30 || r_type == R_SPARC_WPLT30)
3953 && sec_do_relax (input_section)
3954 && rel->r_offset + 4 < input_section->size)
3955 {
3956 #define G0 0
3957 #define O7 15
3958 #define XCC (2 << 20)
3959 #define COND(x) (((x)&0xf)<<25)
3960 #define CONDA COND(0x8)
3961 #define INSN_BPA (F2(0,1) | CONDA | BPRED | XCC)
3962 #define INSN_BA (F2(0,2) | CONDA)
3963 #define INSN_OR F3(2, 0x2, 0)
3964 #define INSN_NOP F2(0,4)
3965
3966 bfd_vma x, y;
3967
3968 /* If the instruction is a call with either:
3969 restore
3970 arithmetic instruction with rd == %o7
3971 where rs1 != %o7 and rs2 if it is register != %o7
3972 then we can optimize if the call destination is near
3973 by changing the call into a branch always. */
3974 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3975 y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
3976 if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2))
3977 {
3978 if (((y & OP3(~0)) == OP3(0x3d) /* restore */
3979 || ((y & OP3(0x28)) == 0 /* arithmetic */
3980 && (y & RD(~0)) == RD(O7)))
3981 && (y & RS1(~0)) != RS1(O7)
3982 && ((y & F3I(~0))
3983 || (y & RS2(~0)) != RS2(O7)))
3984 {
3985 bfd_vma reloc;
3986
3987 reloc = relocation + rel->r_addend - rel->r_offset;
3988 reloc -= (input_section->output_section->vma
3989 + input_section->output_offset);
3990
3991 /* Ensure the branch fits into simm22. */
3992 if ((reloc & 3) == 0
3993 && ((reloc & ~(bfd_vma)0x7fffff) == 0
3994 || ((reloc | 0x7fffff) == ~(bfd_vma)0)))
3995 {
3996 reloc >>= 2;
3997
3998 /* Check whether it fits into simm19. */
3999 if (((reloc & 0x3c0000) == 0
4000 || (reloc & 0x3c0000) == 0x3c0000)
4001 && (ABI_64_P (output_bfd)
4002 || elf_elfheader (output_bfd)->e_flags & EF_SPARC_32PLUS))
4003 x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */
4004 else
4005 x = INSN_BA | (reloc & 0x3fffff); /* ba */
4006 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
4007 r = bfd_reloc_ok;
4008 if (rel->r_offset >= 4
4009 && (y & (0xffffffff ^ RS1(~0)))
4010 == (INSN_OR | RD(O7) | RS2(G0)))
4011 {
4012 bfd_vma z;
4013 unsigned int reg;
4014
4015 z = bfd_get_32 (input_bfd,
4016 contents + rel->r_offset - 4);
4017 if ((z & (0xffffffff ^ RD(~0)))
4018 != (INSN_OR | RS1(O7) | RS2(G0)))
4019 break;
4020
4021 /* The sequence was
4022 or %o7, %g0, %rN
4023 call foo
4024 or %rN, %g0, %o7
4025
4026 If call foo was replaced with ba, replace
4027 or %rN, %g0, %o7 with nop. */
4028
4029 reg = (y & RS1(~0)) >> 14;
4030 if (reg != ((z & RD(~0)) >> 25)
4031 || reg == G0 || reg == O7)
4032 break;
4033
4034 bfd_put_32 (input_bfd, (bfd_vma) INSN_NOP,
4035 contents + rel->r_offset + 4);
4036 }
4037
4038 }
4039 }
4040 }
4041 }
4042
4043 if (r == bfd_reloc_continue)
4044 {
4045 do_relocation:
4046 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4047 contents, rel->r_offset,
4048 relocation, rel->r_addend);
4049 }
4050 if (r != bfd_reloc_ok)
4051 {
4052 switch (r)
4053 {
4054 default:
4055 case bfd_reloc_outofrange:
4056 abort ();
4057 case bfd_reloc_overflow:
4058 {
4059 const char *name;
4060
4061 /* The Solaris native linker silently disregards overflows.
4062 We don't, but this breaks stabs debugging info, whose
4063 relocations are only 32-bits wide. Ignore overflows in
4064 this case and also for discarded entries. */
4065 if ((r_type == R_SPARC_32
4066 || r_type == R_SPARC_UA32
4067 || r_type == R_SPARC_DISP32)
4068 && (((input_section->flags & SEC_DEBUGGING) != 0
4069 && strcmp (bfd_section_name (input_bfd,
4070 input_section),
4071 ".stab") == 0)
4072 || _bfd_elf_section_offset (output_bfd, info,
4073 input_section,
4074 rel->r_offset)
4075 == (bfd_vma)-1))
4076 break;
4077
4078 if (h != NULL)
4079 {
4080 /* Assume this is a call protected by other code that
4081 detect the symbol is undefined. If this is the case,
4082 we can safely ignore the overflow. If not, the
4083 program is hosed anyway, and a little warning isn't
4084 going to help. */
4085 if (h->root.type == bfd_link_hash_undefweak
4086 && howto->pc_relative)
4087 break;
4088
4089 name = NULL;
4090 }
4091 else
4092 {
4093 name = bfd_elf_string_from_elf_section (input_bfd,
4094 symtab_hdr->sh_link,
4095 sym->st_name);
4096 if (name == NULL)
4097 return FALSE;
4098 if (*name == '\0')
4099 name = bfd_section_name (input_bfd, sec);
4100 }
4101 if (! ((*info->callbacks->reloc_overflow)
4102 (info, (h ? &h->root : NULL), name, howto->name,
4103 (bfd_vma) 0, input_bfd, input_section,
4104 rel->r_offset)))
4105 return FALSE;
4106 }
4107 break;
4108 }
4109 }
4110 }
4111
4112 return TRUE;
4113 }
4114
4115 /* Build a VxWorks PLT entry. PLT_INDEX is the index of the PLT entry
4116 and PLT_OFFSET is the byte offset from the start of .plt. GOT_OFFSET
4117 is the offset of the associated .got.plt entry from
4118 _GLOBAL_OFFSET_TABLE_. */
4119
4120 static void
4121 sparc_vxworks_build_plt_entry (bfd *output_bfd, struct bfd_link_info *info,
4122 bfd_vma plt_offset, bfd_vma plt_index,
4123 bfd_vma got_offset)
4124 {
4125 bfd_vma got_base;
4126 const bfd_vma *plt_entry;
4127 struct _bfd_sparc_elf_link_hash_table *htab;
4128 bfd_byte *loc;
4129 Elf_Internal_Rela rela;
4130
4131 htab = _bfd_sparc_elf_hash_table (info);
4132 BFD_ASSERT (htab != NULL);
4133
4134 if (info->shared)
4135 {
4136 plt_entry = sparc_vxworks_shared_plt_entry;
4137 got_base = 0;
4138 }
4139 else
4140 {
4141 plt_entry = sparc_vxworks_exec_plt_entry;
4142 got_base = (htab->elf.hgot->root.u.def.value
4143 + htab->elf.hgot->root.u.def.section->output_offset
4144 + htab->elf.hgot->root.u.def.section->output_section->vma);
4145 }
4146
4147 /* Fill in the entry in the procedure linkage table. */
4148 bfd_put_32 (output_bfd, plt_entry[0] + ((got_base + got_offset) >> 10),
4149 htab->elf.splt->contents + plt_offset);
4150 bfd_put_32 (output_bfd, plt_entry[1] + ((got_base + got_offset) & 0x3ff),
4151 htab->elf.splt->contents + plt_offset + 4);
4152 bfd_put_32 (output_bfd, plt_entry[2],
4153 htab->elf.splt->contents + plt_offset + 8);
4154 bfd_put_32 (output_bfd, plt_entry[3],
4155 htab->elf.splt->contents + plt_offset + 12);
4156 bfd_put_32 (output_bfd, plt_entry[4],
4157 htab->elf.splt->contents + plt_offset + 16);
4158 bfd_put_32 (output_bfd, plt_entry[5] + (plt_index >> 10),
4159 htab->elf.splt->contents + plt_offset + 20);
4160 /* PC-relative displacement for a branch to the start of
4161 the PLT section. */
4162 bfd_put_32 (output_bfd, plt_entry[6] + (((-plt_offset - 24) >> 2)
4163 & 0x003fffff),
4164 htab->elf.splt->contents + plt_offset + 24);
4165 bfd_put_32 (output_bfd, plt_entry[7] + (plt_index & 0x3ff),
4166 htab->elf.splt->contents + plt_offset + 28);
4167
4168 /* Fill in the .got.plt entry, pointing initially at the
4169 second half of the PLT entry. */
4170 BFD_ASSERT (htab->elf.sgotplt != NULL);
4171 bfd_put_32 (output_bfd,
4172 htab->elf.splt->output_section->vma
4173 + htab->elf.splt->output_offset
4174 + plt_offset + 20,
4175 htab->elf.sgotplt->contents + got_offset);
4176
4177 /* Add relocations to .rela.plt.unloaded. */
4178 if (!info->shared)
4179 {
4180 loc = (htab->srelplt2->contents
4181 + (2 + 3 * plt_index) * sizeof (Elf32_External_Rela));
4182
4183 /* Relocate the initial sethi. */
4184 rela.r_offset = (htab->elf.splt->output_section->vma
4185 + htab->elf.splt->output_offset
4186 + plt_offset);
4187 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4188 rela.r_addend = got_offset;
4189 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4190 loc += sizeof (Elf32_External_Rela);
4191
4192 /* Likewise the following or. */
4193 rela.r_offset += 4;
4194 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4195 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4196 loc += sizeof (Elf32_External_Rela);
4197
4198 /* Relocate the .got.plt entry. */
4199 rela.r_offset = (htab->elf.sgotplt->output_section->vma
4200 + htab->elf.sgotplt->output_offset
4201 + got_offset);
4202 rela.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_SPARC_32);
4203 rela.r_addend = plt_offset + 20;
4204 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4205 }
4206 }
4207
4208 /* Finish up dynamic symbol handling. We set the contents of various
4209 dynamic sections here. */
4210
4211 bfd_boolean
4212 _bfd_sparc_elf_finish_dynamic_symbol (bfd *output_bfd,
4213 struct bfd_link_info *info,
4214 struct elf_link_hash_entry *h,
4215 Elf_Internal_Sym *sym)
4216 {
4217 struct _bfd_sparc_elf_link_hash_table *htab;
4218 const struct elf_backend_data *bed;
4219
4220 htab = _bfd_sparc_elf_hash_table (info);
4221 BFD_ASSERT (htab != NULL);
4222 bed = get_elf_backend_data (output_bfd);
4223
4224 if (h->plt.offset != (bfd_vma) -1)
4225 {
4226 asection *splt;
4227 asection *srela;
4228 Elf_Internal_Rela rela;
4229 bfd_byte *loc;
4230 bfd_vma r_offset, got_offset;
4231 int rela_index;
4232
4233 /* When building a static executable, use .iplt and
4234 .rela.iplt sections for STT_GNU_IFUNC symbols. */
4235 if (htab->elf.splt != NULL)
4236 {
4237 splt = htab->elf.splt;
4238 srela = htab->elf.srelplt;
4239 }
4240 else
4241 {
4242 splt = htab->elf.iplt;
4243 srela = htab->elf.irelplt;
4244 }
4245
4246 if (splt == NULL || srela == NULL)
4247 abort ();
4248
4249 /* Fill in the entry in the .rela.plt section. */
4250 if (htab->is_vxworks)
4251 {
4252 /* Work out the index of this PLT entry. */
4253 rela_index = ((h->plt.offset - htab->plt_header_size)
4254 / htab->plt_entry_size);
4255
4256 /* Calculate the offset of the associated .got.plt entry.
4257 The first three entries are reserved. */
4258 got_offset = (rela_index + 3) * 4;
4259
4260 sparc_vxworks_build_plt_entry (output_bfd, info, h->plt.offset,
4261 rela_index, got_offset);
4262
4263
4264 /* On VxWorks, the relocation points to the .got.plt entry,
4265 not the .plt entry. */
4266 rela.r_offset = (htab->elf.sgotplt->output_section->vma
4267 + htab->elf.sgotplt->output_offset
4268 + got_offset);
4269 rela.r_addend = 0;
4270 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx,
4271 R_SPARC_JMP_SLOT);
4272 }
4273 else
4274 {
4275 bfd_boolean ifunc = FALSE;
4276
4277 /* Fill in the entry in the procedure linkage table. */
4278 rela_index = SPARC_ELF_BUILD_PLT_ENTRY (htab, output_bfd, splt,
4279 h->plt.offset, splt->size,
4280 &r_offset);
4281
4282 if (h == NULL
4283 || h->dynindx == -1
4284 || ((info->executable
4285 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
4286 && h->def_regular
4287 && h->type == STT_GNU_IFUNC))
4288 {
4289 ifunc = TRUE;
4290 BFD_ASSERT (h == NULL
4291 || (h->type == STT_GNU_IFUNC
4292 && h->def_regular
4293 && (h->root.type == bfd_link_hash_defined
4294 || h->root.type == bfd_link_hash_defweak)));
4295 }
4296
4297 rela.r_offset = r_offset
4298 + (splt->output_section->vma + splt->output_offset);
4299 if (ABI_64_P (output_bfd)
4300 && h->plt.offset >= (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE))
4301 {
4302 if (ifunc)
4303 {
4304 rela.r_addend = (h->root.u.def.section->output_section->vma
4305 + h->root.u.def.section->output_offset
4306 + h->root.u.def.value);
4307 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0,
4308 R_SPARC_IRELATIVE);
4309 }
4310 else
4311 {
4312 rela.r_addend = (-(h->plt.offset + 4)
4313 - splt->output_section->vma
4314 - splt->output_offset);
4315 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx,
4316 R_SPARC_JMP_SLOT);
4317 }
4318 }
4319 else
4320 {
4321 if (ifunc)
4322 {
4323 rela.r_addend = (h->root.u.def.section->output_section->vma
4324 + h->root.u.def.section->output_offset
4325 + h->root.u.def.value);
4326 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0,
4327 R_SPARC_JMP_IREL);
4328 }
4329 else
4330 {
4331 rela.r_addend = 0;
4332 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx,
4333 R_SPARC_JMP_SLOT);
4334 }
4335 }
4336 }
4337
4338 /* Adjust for the first 4 reserved elements in the .plt section
4339 when setting the offset in the .rela.plt section.
4340 Sun forgot to read their own ABI and copied elf32-sparc behaviour,
4341 thus .plt[4] has corresponding .rela.plt[0] and so on. */
4342
4343 loc = srela->contents;
4344 loc += rela_index * bed->s->sizeof_rela;
4345 bed->s->swap_reloca_out (output_bfd, &rela, loc);
4346
4347 if (!h->def_regular)
4348 {
4349 /* Mark the symbol as undefined, rather than as defined in
4350 the .plt section. Leave the value alone. */
4351 sym->st_shndx = SHN_UNDEF;
4352 /* If the symbol is weak, we do need to clear the value.
4353 Otherwise, the PLT entry would provide a definition for
4354 the symbol even if the symbol wasn't defined anywhere,
4355 and so the symbol would never be NULL. */
4356 if (!h->ref_regular_nonweak)
4357 sym->st_value = 0;
4358 }
4359 }
4360
4361 if (h->got.offset != (bfd_vma) -1
4362 && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_GD
4363 && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_IE)
4364 {
4365 asection *sgot;
4366 asection *srela;
4367 Elf_Internal_Rela rela;
4368
4369 /* This symbol has an entry in the GOT. Set it up. */
4370
4371 sgot = htab->elf.sgot;
4372 srela = htab->elf.srelgot;
4373 BFD_ASSERT (sgot != NULL && srela != NULL);
4374
4375 rela.r_offset = (sgot->output_section->vma
4376 + sgot->output_offset
4377 + (h->got.offset &~ (bfd_vma) 1));
4378
4379 /* If this is a -Bsymbolic link, and the symbol is defined
4380 locally, we just want to emit a RELATIVE reloc. Likewise if
4381 the symbol was forced to be local because of a version file.
4382 The entry in the global offset table will already have been
4383 initialized in the relocate_section function. */
4384 if (! info->shared
4385 && h->type == STT_GNU_IFUNC
4386 && h->def_regular)
4387 {
4388 asection *plt;
4389
4390 /* We load the GOT entry with the PLT entry. */
4391 plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
4392 SPARC_ELF_PUT_WORD (htab, output_bfd,
4393 (plt->output_section->vma
4394 + plt->output_offset + h->plt.offset),
4395 htab->elf.sgot->contents
4396 + (h->got.offset & ~(bfd_vma) 1));
4397 return TRUE;
4398 }
4399 else if (info->shared
4400 && SYMBOL_REFERENCES_LOCAL (info, h))
4401 {
4402 asection *sec = h->root.u.def.section;
4403 if (h->type == STT_GNU_IFUNC)
4404 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, R_SPARC_IRELATIVE);
4405 else
4406 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, R_SPARC_RELATIVE);
4407 rela.r_addend = (h->root.u.def.value
4408 + sec->output_section->vma
4409 + sec->output_offset);
4410 }
4411 else
4412 {
4413 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_GLOB_DAT);
4414 rela.r_addend = 0;
4415 }
4416
4417 SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
4418 sgot->contents + (h->got.offset & ~(bfd_vma) 1));
4419 sparc_elf_append_rela (output_bfd, srela, &rela);
4420 }
4421
4422 if (h->needs_copy)
4423 {
4424 asection *s;
4425 Elf_Internal_Rela rela;
4426
4427 /* This symbols needs a copy reloc. Set it up. */
4428 BFD_ASSERT (h->dynindx != -1);
4429
4430 s = bfd_get_section_by_name (h->root.u.def.section->owner,
4431 ".rela.bss");
4432 BFD_ASSERT (s != NULL);
4433
4434 rela.r_offset = (h->root.u.def.value
4435 + h->root.u.def.section->output_section->vma
4436 + h->root.u.def.section->output_offset);
4437 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_COPY);
4438 rela.r_addend = 0;
4439 sparc_elf_append_rela (output_bfd, s, &rela);
4440 }
4441
4442 /* Mark some specially defined symbols as absolute. On VxWorks,
4443 _GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the
4444 ".got" section. Likewise _PROCEDURE_LINKAGE_TABLE_ and ".plt". */
4445 if (sym != NULL
4446 && (strcmp (h->root.root.string, "_DYNAMIC") == 0
4447 || (!htab->is_vxworks
4448 && (h == htab->elf.hgot || h == htab->elf.hplt))))
4449 sym->st_shndx = SHN_ABS;
4450
4451 return TRUE;
4452 }
4453
4454 /* Finish up the dynamic sections. */
4455
4456 static bfd_boolean
4457 sparc_finish_dyn (bfd *output_bfd, struct bfd_link_info *info,
4458 bfd *dynobj, asection *sdyn,
4459 asection *splt ATTRIBUTE_UNUSED)
4460 {
4461 struct _bfd_sparc_elf_link_hash_table *htab;
4462 const struct elf_backend_data *bed;
4463 bfd_byte *dyncon, *dynconend;
4464 size_t dynsize;
4465 int stt_regidx = -1;
4466 bfd_boolean abi_64_p;
4467
4468 htab = _bfd_sparc_elf_hash_table (info);
4469 BFD_ASSERT (htab != NULL);
4470 bed = get_elf_backend_data (output_bfd);
4471 dynsize = bed->s->sizeof_dyn;
4472 dynconend = sdyn->contents + sdyn->size;
4473 abi_64_p = ABI_64_P (output_bfd);
4474 for (dyncon = sdyn->contents; dyncon < dynconend; dyncon += dynsize)
4475 {
4476 Elf_Internal_Dyn dyn;
4477 const char *name;
4478 bfd_boolean size;
4479
4480 bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
4481
4482 if (htab->is_vxworks && dyn.d_tag == DT_RELASZ)
4483 {
4484 /* On VxWorks, DT_RELASZ should not include the relocations
4485 in .rela.plt. */
4486 if (htab->elf.srelplt)
4487 {
4488 dyn.d_un.d_val -= htab->elf.srelplt->size;
4489 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4490 }
4491 }
4492 else if (htab->is_vxworks && dyn.d_tag == DT_PLTGOT)
4493 {
4494 /* On VxWorks, DT_PLTGOT should point to the start of the GOT,
4495 not to the start of the PLT. */
4496 if (htab->elf.sgotplt)
4497 {
4498 dyn.d_un.d_val = (htab->elf.sgotplt->output_section->vma
4499 + htab->elf.sgotplt->output_offset);
4500 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4501 }
4502 }
4503 else if (htab->is_vxworks
4504 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
4505 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4506 else if (abi_64_p && dyn.d_tag == DT_SPARC_REGISTER)
4507 {
4508 if (stt_regidx == -1)
4509 {
4510 stt_regidx =
4511 _bfd_elf_link_lookup_local_dynindx (info, output_bfd, -1);
4512 if (stt_regidx == -1)
4513 return FALSE;
4514 }
4515 dyn.d_un.d_val = stt_regidx++;
4516 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4517 }
4518 else
4519 {
4520 switch (dyn.d_tag)
4521 {
4522 case DT_PLTGOT: name = ".plt"; size = FALSE; break;
4523 case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break;
4524 case DT_JMPREL: name = ".rela.plt"; size = FALSE; break;
4525 default: name = NULL; size = FALSE; break;
4526 }
4527
4528 if (name != NULL)
4529 {
4530 asection *s;
4531
4532 s = bfd_get_section_by_name (output_bfd, name);
4533 if (s == NULL)
4534 dyn.d_un.d_val = 0;
4535 else
4536 {
4537 if (! size)
4538 dyn.d_un.d_ptr = s->vma;
4539 else
4540 dyn.d_un.d_val = s->size;
4541 }
4542 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4543 }
4544 }
4545 }
4546 return TRUE;
4547 }
4548
4549 /* Install the first PLT entry in a VxWorks executable and make sure that
4550 .rela.plt.unloaded relocations have the correct symbol indexes. */
4551
4552 static void
4553 sparc_vxworks_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info)
4554 {
4555 struct _bfd_sparc_elf_link_hash_table *htab;
4556 Elf_Internal_Rela rela;
4557 bfd_vma got_base;
4558 bfd_byte *loc;
4559
4560 htab = _bfd_sparc_elf_hash_table (info);
4561 BFD_ASSERT (htab != NULL);
4562
4563 /* Calculate the absolute value of _GLOBAL_OFFSET_TABLE_. */
4564 got_base = (htab->elf.hgot->root.u.def.section->output_section->vma
4565 + htab->elf.hgot->root.u.def.section->output_offset
4566 + htab->elf.hgot->root.u.def.value);
4567
4568 /* Install the initial PLT entry. */
4569 bfd_put_32 (output_bfd,
4570 sparc_vxworks_exec_plt0_entry[0] + ((got_base + 8) >> 10),
4571 htab->elf.splt->contents);
4572 bfd_put_32 (output_bfd,
4573 sparc_vxworks_exec_plt0_entry[1] + ((got_base + 8) & 0x3ff),
4574 htab->elf.splt->contents + 4);
4575 bfd_put_32 (output_bfd,
4576 sparc_vxworks_exec_plt0_entry[2],
4577 htab->elf.splt->contents + 8);
4578 bfd_put_32 (output_bfd,
4579 sparc_vxworks_exec_plt0_entry[3],
4580 htab->elf.splt->contents + 12);
4581 bfd_put_32 (output_bfd,
4582 sparc_vxworks_exec_plt0_entry[4],
4583 htab->elf.splt->contents + 16);
4584
4585 loc = htab->srelplt2->contents;
4586
4587 /* Add an unloaded relocation for the initial entry's "sethi". */
4588 rela.r_offset = (htab->elf.splt->output_section->vma
4589 + htab->elf.splt->output_offset);
4590 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4591 rela.r_addend = 8;
4592 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4593 loc += sizeof (Elf32_External_Rela);
4594
4595 /* Likewise the following "or". */
4596 rela.r_offset += 4;
4597 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4598 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4599 loc += sizeof (Elf32_External_Rela);
4600
4601 /* Fix up the remaining .rela.plt.unloaded relocations. They may have
4602 the wrong symbol index for _G_O_T_ or _P_L_T_ depending on the order
4603 in which symbols were output. */
4604 while (loc < htab->srelplt2->contents + htab->srelplt2->size)
4605 {
4606 Elf_Internal_Rela rel;
4607
4608 /* The entry's initial "sethi" (against _G_O_T_). */
4609 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4610 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4611 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4612 loc += sizeof (Elf32_External_Rela);
4613
4614 /* The following "or" (also against _G_O_T_). */
4615 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4616 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4617 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4618 loc += sizeof (Elf32_External_Rela);
4619
4620 /* The .got.plt entry (against _P_L_T_). */
4621 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4622 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_SPARC_32);
4623 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4624 loc += sizeof (Elf32_External_Rela);
4625 }
4626 }
4627
4628 /* Install the first PLT entry in a VxWorks shared object. */
4629
4630 static void
4631 sparc_vxworks_finish_shared_plt (bfd *output_bfd, struct bfd_link_info *info)
4632 {
4633 struct _bfd_sparc_elf_link_hash_table *htab;
4634 unsigned int i;
4635
4636 htab = _bfd_sparc_elf_hash_table (info);
4637 BFD_ASSERT (htab != NULL);
4638
4639 for (i = 0; i < ARRAY_SIZE (sparc_vxworks_shared_plt0_entry); i++)
4640 bfd_put_32 (output_bfd, sparc_vxworks_shared_plt0_entry[i],
4641 htab->elf.splt->contents + i * 4);
4642 }
4643
4644 /* Finish up local dynamic symbol handling. We set the contents of
4645 various dynamic sections here. */
4646
4647 static bfd_boolean
4648 finish_local_dynamic_symbol (void **slot, void *inf)
4649 {
4650 struct elf_link_hash_entry *h
4651 = (struct elf_link_hash_entry *) *slot;
4652 struct bfd_link_info *info
4653 = (struct bfd_link_info *) inf;
4654
4655 return _bfd_sparc_elf_finish_dynamic_symbol (info->output_bfd, info,
4656 h, NULL);
4657 }
4658
4659 bfd_boolean
4660 _bfd_sparc_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
4661 {
4662 bfd *dynobj;
4663 asection *sdyn;
4664 struct _bfd_sparc_elf_link_hash_table *htab;
4665
4666 htab = _bfd_sparc_elf_hash_table (info);
4667 BFD_ASSERT (htab != NULL);
4668 dynobj = htab->elf.dynobj;
4669
4670 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4671
4672 if (elf_hash_table (info)->dynamic_sections_created)
4673 {
4674 asection *splt;
4675
4676 splt = bfd_get_section_by_name (dynobj, ".plt");
4677 BFD_ASSERT (splt != NULL && sdyn != NULL);
4678
4679 if (!sparc_finish_dyn (output_bfd, info, dynobj, sdyn, splt))
4680 return FALSE;
4681
4682 /* Initialize the contents of the .plt section. */
4683 if (splt->size > 0)
4684 {
4685 if (htab->is_vxworks)
4686 {
4687 if (info->shared)
4688 sparc_vxworks_finish_shared_plt (output_bfd, info);
4689 else
4690 sparc_vxworks_finish_exec_plt (output_bfd, info);
4691 }
4692 else
4693 {
4694 memset (splt->contents, 0, htab->plt_header_size);
4695 if (!ABI_64_P (output_bfd))
4696 bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP,
4697 splt->contents + splt->size - 4);
4698 }
4699 }
4700
4701 elf_section_data (splt->output_section)->this_hdr.sh_entsize
4702 = (htab->is_vxworks || !ABI_64_P (output_bfd))
4703 ? 0 : htab->plt_entry_size;
4704 }
4705
4706 /* Set the first entry in the global offset table to the address of
4707 the dynamic section. */
4708 if (htab->elf.sgot && htab->elf.sgot->size > 0)
4709 {
4710 bfd_vma val = (sdyn ?
4711 sdyn->output_section->vma + sdyn->output_offset :
4712 0);
4713
4714 SPARC_ELF_PUT_WORD (htab, output_bfd, val, htab->elf.sgot->contents);
4715 }
4716
4717 if (htab->elf.sgot)
4718 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize =
4719 SPARC_ELF_WORD_BYTES (htab);
4720
4721 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
4722 htab_traverse (htab->loc_hash_table, finish_local_dynamic_symbol, info);
4723
4724 return TRUE;
4725 }
4726
4727 \f
4728 /* Set the right machine number for a SPARC ELF file. */
4729
4730 bfd_boolean
4731 _bfd_sparc_elf_object_p (bfd *abfd)
4732 {
4733 if (ABI_64_P (abfd))
4734 {
4735 unsigned long mach = bfd_mach_sparc_v9;
4736
4737 if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
4738 mach = bfd_mach_sparc_v9b;
4739 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
4740 mach = bfd_mach_sparc_v9a;
4741 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, mach);
4742 }
4743 else
4744 {
4745 if (elf_elfheader (abfd)->e_machine == EM_SPARC32PLUS)
4746 {
4747 if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
4748 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4749 bfd_mach_sparc_v8plusb);
4750 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
4751 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4752 bfd_mach_sparc_v8plusa);
4753 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_32PLUS)
4754 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4755 bfd_mach_sparc_v8plus);
4756 else
4757 return FALSE;
4758 }
4759 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_LEDATA)
4760 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4761 bfd_mach_sparc_sparclite_le);
4762 else
4763 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc);
4764 }
4765 }
4766
4767 /* Return address for Ith PLT stub in section PLT, for relocation REL
4768 or (bfd_vma) -1 if it should not be included. */
4769
4770 bfd_vma
4771 _bfd_sparc_elf_plt_sym_val (bfd_vma i, const asection *plt, const arelent *rel)
4772 {
4773 if (ABI_64_P (plt->owner))
4774 {
4775 bfd_vma j;
4776
4777 i += PLT64_HEADER_SIZE / PLT64_ENTRY_SIZE;
4778 if (i < PLT64_LARGE_THRESHOLD)
4779 return plt->vma + i * PLT64_ENTRY_SIZE;
4780
4781 j = (i - PLT64_LARGE_THRESHOLD) % 160;
4782 i -= j;
4783 return plt->vma + i * PLT64_ENTRY_SIZE + j * 4 * 6;
4784 }
4785 else
4786 return rel->address;
4787 }
4788
4789 /* Merge backend specific data from an object file to the output
4790 object file when linking. */
4791
4792 bfd_boolean
4793 _bfd_sparc_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
4794 {
4795 obj_attribute *in_attr, *in_attrs;
4796 obj_attribute *out_attr, *out_attrs;
4797
4798 if (!elf_known_obj_attributes_proc (obfd)[0].i)
4799 {
4800 /* This is the first object. Copy the attributes. */
4801 _bfd_elf_copy_obj_attributes (ibfd, obfd);
4802
4803 /* Use the Tag_null value to indicate the attributes have been
4804 initialized. */
4805 elf_known_obj_attributes_proc (obfd)[0].i = 1;
4806
4807 return TRUE;
4808 }
4809
4810 in_attrs = elf_known_obj_attributes (ibfd)[OBJ_ATTR_GNU];
4811 out_attrs = elf_known_obj_attributes (obfd)[OBJ_ATTR_GNU];
4812
4813 in_attr = &in_attrs[Tag_GNU_Sparc_HWCAPS];
4814 out_attr = &out_attrs[Tag_GNU_Sparc_HWCAPS];
4815
4816 out_attr->i |= in_attr->i;
4817
4818 /* Merge Tag_compatibility attributes and any common GNU ones. */
4819 _bfd_elf_merge_object_attributes (ibfd, obfd);
4820
4821 return TRUE;
4822 }
GDB Binutils - Deliverables
This page took 0.146744 seconds and 5 git commands to generate.