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