projects / deliverable / binutils-gdb.git / blob
? search:


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