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


73284db6454f5071b83d41df1607543eeba5524c
[deliverable/binutils-gdb.git] / bfd / elfxx-sparc.c
1 /* SPARC-specific support for ELF
2 Copyright 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
3
4 This file is part of BFD, the Binary File Descriptor library.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
20
21
22 /* This file handles functionality common to the different SPARC ABI's. */
23
24 #include "sysdep.h"
25 #include "bfd.h"
26 #include "bfdlink.h"
27 #include "libbfd.h"
28 #include "libiberty.h"
29 #include "elf-bfd.h"
30 #include "elf/sparc.h"
31 #include "opcode/sparc.h"
32 #include "elfxx-sparc.h"
33 #include "elf-vxworks.h"
34
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_DATA)
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_DATA);
533 }
534
535 static void
536 sparc_put_word_32 (bfd *abfd, bfd_vma val, void *ptr)
537 {
538 bfd_put_32 (abfd, val, ptr);
539 }
540
541 static void
542 sparc_put_word_64 (bfd *abfd, bfd_vma val, void *ptr)
543 {
544 bfd_put_64 (abfd, 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 rel_index ATTRIBUTE_UNUSED,
561 bfd_vma type ATTRIBUTE_UNUSED)
562 {
563 return ELF64_R_INFO (rel_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 rel_index, bfd_vma type)
572 {
573 return ELF32_R_INFO (rel_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 plt_index;
638
639 if (offset < (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE))
640 {
641 unsigned int sethi, ba;
642
643 *r_offset = offset;
644
645 plt_index = (offset / PLT64_ENTRY_SIZE);
646
647 sethi = 0x03000000 | (plt_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 plt_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 plt_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 SPARC_ELF_DATA))
880 {
881 free (ret);
882 return NULL;
883 }
884
885 return &ret->elf.root;
886 }
887
888 /* Create .got and .rela.got sections in DYNOBJ, and set up
889 shortcuts to them in our hash table. */
890
891 static bfd_boolean
892 create_got_section (bfd *dynobj, struct bfd_link_info *info)
893 {
894 struct _bfd_sparc_elf_link_hash_table *htab;
895
896 if (! _bfd_elf_create_got_section (dynobj, info))
897 return FALSE;
898
899 htab = _bfd_sparc_elf_hash_table (info);
900 BFD_ASSERT (htab != NULL);
901
902 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
903 BFD_ASSERT (htab->sgot != NULL);
904
905 htab->srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
906 if (htab->srelgot == NULL
907 || ! bfd_set_section_alignment (dynobj, htab->srelgot,
908 htab->word_align_power))
909 return FALSE;
910
911 if (htab->is_vxworks)
912 {
913 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
914 if (!htab->sgotplt)
915 return FALSE;
916 }
917
918 return TRUE;
919 }
920
921 /* Create .plt, .rela.plt, .got, .rela.got, .dynbss, and
922 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
923 hash table. */
924
925 bfd_boolean
926 _bfd_sparc_elf_create_dynamic_sections (bfd *dynobj,
927 struct bfd_link_info *info)
928 {
929 struct _bfd_sparc_elf_link_hash_table *htab;
930
931 htab = _bfd_sparc_elf_hash_table (info);
932 BFD_ASSERT (htab != NULL);
933
934 if (!htab->sgot && !create_got_section (dynobj, info))
935 return FALSE;
936
937 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
938 return FALSE;
939
940 htab->splt = bfd_get_section_by_name (dynobj, ".plt");
941 htab->srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
942 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
943 if (!info->shared)
944 htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss");
945
946 if (htab->is_vxworks)
947 {
948 if (!elf_vxworks_create_dynamic_sections (dynobj, info, &htab->srelplt2))
949 return FALSE;
950 if (info->shared)
951 {
952 htab->plt_header_size
953 = 4 * ARRAY_SIZE (sparc_vxworks_shared_plt0_entry);
954 htab->plt_entry_size
955 = 4 * ARRAY_SIZE (sparc_vxworks_shared_plt_entry);
956 }
957 else
958 {
959 htab->plt_header_size
960 = 4 * ARRAY_SIZE (sparc_vxworks_exec_plt0_entry);
961 htab->plt_entry_size
962 = 4 * ARRAY_SIZE (sparc_vxworks_exec_plt_entry);
963 }
964 }
965 else
966 {
967 if (ABI_64_P (dynobj))
968 {
969 htab->build_plt_entry = sparc64_plt_entry_build;
970 htab->plt_header_size = PLT64_HEADER_SIZE;
971 htab->plt_entry_size = PLT64_ENTRY_SIZE;
972 }
973 else
974 {
975 htab->build_plt_entry = sparc32_plt_entry_build;
976 htab->plt_header_size = PLT32_HEADER_SIZE;
977 htab->plt_entry_size = PLT32_ENTRY_SIZE;
978 }
979 }
980
981 if (!htab->splt || !htab->srelplt || !htab->sdynbss
982 || (!info->shared && !htab->srelbss))
983 abort ();
984
985 return TRUE;
986 }
987
988 /* Copy the extra info we tack onto an elf_link_hash_entry. */
989
990 void
991 _bfd_sparc_elf_copy_indirect_symbol (struct bfd_link_info *info,
992 struct elf_link_hash_entry *dir,
993 struct elf_link_hash_entry *ind)
994 {
995 struct _bfd_sparc_elf_link_hash_entry *edir, *eind;
996
997 edir = (struct _bfd_sparc_elf_link_hash_entry *) dir;
998 eind = (struct _bfd_sparc_elf_link_hash_entry *) ind;
999
1000 if (eind->dyn_relocs != NULL)
1001 {
1002 if (edir->dyn_relocs != NULL)
1003 {
1004 struct _bfd_sparc_elf_dyn_relocs **pp;
1005 struct _bfd_sparc_elf_dyn_relocs *p;
1006
1007 /* Add reloc counts against the indirect sym to the direct sym
1008 list. Merge any entries against the same section. */
1009 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1010 {
1011 struct _bfd_sparc_elf_dyn_relocs *q;
1012
1013 for (q = edir->dyn_relocs; q != NULL; q = q->next)
1014 if (q->sec == p->sec)
1015 {
1016 q->pc_count += p->pc_count;
1017 q->count += p->count;
1018 *pp = p->next;
1019 break;
1020 }
1021 if (q == NULL)
1022 pp = &p->next;
1023 }
1024 *pp = edir->dyn_relocs;
1025 }
1026
1027 edir->dyn_relocs = eind->dyn_relocs;
1028 eind->dyn_relocs = NULL;
1029 }
1030
1031 if (ind->root.type == bfd_link_hash_indirect
1032 && dir->got.refcount <= 0)
1033 {
1034 edir->tls_type = eind->tls_type;
1035 eind->tls_type = GOT_UNKNOWN;
1036 }
1037 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1038 }
1039
1040 static int
1041 sparc_elf_tls_transition (struct bfd_link_info *info, bfd *abfd,
1042 int r_type, int is_local)
1043 {
1044 if (! ABI_64_P (abfd)
1045 && r_type == R_SPARC_TLS_GD_HI22
1046 && ! _bfd_sparc_elf_tdata (abfd)->has_tlsgd)
1047 r_type = R_SPARC_REV32;
1048
1049 if (info->shared)
1050 return r_type;
1051
1052 switch (r_type)
1053 {
1054 case R_SPARC_TLS_GD_HI22:
1055 if (is_local)
1056 return R_SPARC_TLS_LE_HIX22;
1057 return R_SPARC_TLS_IE_HI22;
1058 case R_SPARC_TLS_GD_LO10:
1059 if (is_local)
1060 return R_SPARC_TLS_LE_LOX10;
1061 return R_SPARC_TLS_IE_LO10;
1062 case R_SPARC_TLS_IE_HI22:
1063 if (is_local)
1064 return R_SPARC_TLS_LE_HIX22;
1065 return r_type;
1066 case R_SPARC_TLS_IE_LO10:
1067 if (is_local)
1068 return R_SPARC_TLS_LE_LOX10;
1069 return r_type;
1070 case R_SPARC_TLS_LDM_HI22:
1071 return R_SPARC_TLS_LE_HIX22;
1072 case R_SPARC_TLS_LDM_LO10:
1073 return R_SPARC_TLS_LE_LOX10;
1074 }
1075
1076 return r_type;
1077 }
1078 \f
1079 /* Look through the relocs for a section during the first phase, and
1080 allocate space in the global offset table or procedure linkage
1081 table. */
1082
1083 bfd_boolean
1084 _bfd_sparc_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
1085 asection *sec, const Elf_Internal_Rela *relocs)
1086 {
1087 struct _bfd_sparc_elf_link_hash_table *htab;
1088 Elf_Internal_Shdr *symtab_hdr;
1089 struct elf_link_hash_entry **sym_hashes;
1090 bfd_vma *local_got_offsets;
1091 const Elf_Internal_Rela *rel;
1092 const Elf_Internal_Rela *rel_end;
1093 asection *sreloc;
1094 int num_relocs;
1095 bfd_boolean checked_tlsgd = FALSE;
1096
1097 if (info->relocatable)
1098 return TRUE;
1099
1100 htab = _bfd_sparc_elf_hash_table (info);
1101 BFD_ASSERT (htab != NULL);
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 asection *s;
1475 void *vpp;
1476 Elf_Internal_Sym *isym;
1477
1478 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1479 abfd, r_symndx);
1480 if (isym == NULL)
1481 return FALSE;
1482
1483 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1484 if (s == NULL)
1485 s = sec;
1486
1487 vpp = &elf_section_data (s)->local_dynrel;
1488 head = (struct _bfd_sparc_elf_dyn_relocs **) vpp;
1489 }
1490
1491 p = *head;
1492 if (p == NULL || p->sec != sec)
1493 {
1494 bfd_size_type amt = sizeof *p;
1495 p = ((struct _bfd_sparc_elf_dyn_relocs *)
1496 bfd_alloc (htab->elf.dynobj, amt));
1497 if (p == NULL)
1498 return FALSE;
1499 p->next = *head;
1500 *head = p;
1501 p->sec = sec;
1502 p->count = 0;
1503 p->pc_count = 0;
1504 }
1505
1506 p->count += 1;
1507 if (_bfd_sparc_elf_howto_table[r_type].pc_relative)
1508 p->pc_count += 1;
1509 }
1510
1511 break;
1512
1513 case R_SPARC_GNU_VTINHERIT:
1514 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1515 return FALSE;
1516 break;
1517
1518 case R_SPARC_GNU_VTENTRY:
1519 BFD_ASSERT (h != NULL);
1520 if (h != NULL
1521 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1522 return FALSE;
1523 break;
1524
1525 case R_SPARC_REGISTER:
1526 /* Nothing to do. */
1527 break;
1528
1529 default:
1530 break;
1531 }
1532 }
1533
1534 return TRUE;
1535 }
1536 \f
1537 asection *
1538 _bfd_sparc_elf_gc_mark_hook (asection *sec,
1539 struct bfd_link_info *info,
1540 Elf_Internal_Rela *rel,
1541 struct elf_link_hash_entry *h,
1542 Elf_Internal_Sym *sym)
1543 {
1544 if (h != NULL)
1545 switch (SPARC_ELF_R_TYPE (rel->r_info))
1546 {
1547 case R_SPARC_GNU_VTINHERIT:
1548 case R_SPARC_GNU_VTENTRY:
1549 return NULL;
1550 }
1551
1552 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1553 }
1554
1555 /* Update the got entry reference counts for the section being removed. */
1556 bfd_boolean
1557 _bfd_sparc_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
1558 asection *sec, const Elf_Internal_Rela *relocs)
1559 {
1560 struct _bfd_sparc_elf_link_hash_table *htab;
1561 Elf_Internal_Shdr *symtab_hdr;
1562 struct elf_link_hash_entry **sym_hashes;
1563 bfd_signed_vma *local_got_refcounts;
1564 const Elf_Internal_Rela *rel, *relend;
1565
1566 if (info->relocatable)
1567 return TRUE;
1568
1569 BFD_ASSERT (is_sparc_elf (abfd) || sec->reloc_count == 0);
1570
1571 elf_section_data (sec)->local_dynrel = NULL;
1572
1573 htab = _bfd_sparc_elf_hash_table (info);
1574 BFD_ASSERT (htab != NULL);
1575 symtab_hdr = &elf_symtab_hdr (abfd);
1576 sym_hashes = elf_sym_hashes (abfd);
1577 local_got_refcounts = elf_local_got_refcounts (abfd);
1578
1579 relend = relocs + sec->reloc_count;
1580 for (rel = relocs; rel < relend; rel++)
1581 {
1582 unsigned long r_symndx;
1583 unsigned int r_type;
1584 struct elf_link_hash_entry *h = NULL;
1585
1586 r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
1587 if (r_symndx >= symtab_hdr->sh_info)
1588 {
1589 struct _bfd_sparc_elf_link_hash_entry *eh;
1590 struct _bfd_sparc_elf_dyn_relocs **pp;
1591 struct _bfd_sparc_elf_dyn_relocs *p;
1592
1593 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1594 while (h->root.type == bfd_link_hash_indirect
1595 || h->root.type == bfd_link_hash_warning)
1596 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1597 eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
1598 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1599 if (p->sec == sec)
1600 {
1601 /* Everything must go for SEC. */
1602 *pp = p->next;
1603 break;
1604 }
1605 }
1606
1607 r_type = SPARC_ELF_R_TYPE (rel->r_info);
1608 r_type = sparc_elf_tls_transition (info, abfd, r_type, h != NULL);
1609 switch (r_type)
1610 {
1611 case R_SPARC_TLS_LDM_HI22:
1612 case R_SPARC_TLS_LDM_LO10:
1613 if (_bfd_sparc_elf_hash_table (info)->tls_ldm_got.refcount > 0)
1614 _bfd_sparc_elf_hash_table (info)->tls_ldm_got.refcount -= 1;
1615 break;
1616
1617 case R_SPARC_TLS_GD_HI22:
1618 case R_SPARC_TLS_GD_LO10:
1619 case R_SPARC_TLS_IE_HI22:
1620 case R_SPARC_TLS_IE_LO10:
1621 case R_SPARC_GOT10:
1622 case R_SPARC_GOT13:
1623 case R_SPARC_GOT22:
1624 case R_SPARC_GOTDATA_HIX22:
1625 case R_SPARC_GOTDATA_LOX10:
1626 case R_SPARC_GOTDATA_OP_HIX22:
1627 case R_SPARC_GOTDATA_OP_LOX10:
1628 if (h != NULL)
1629 {
1630 if (h->got.refcount > 0)
1631 h->got.refcount--;
1632 }
1633 else
1634 {
1635 if (local_got_refcounts[r_symndx] > 0)
1636 local_got_refcounts[r_symndx]--;
1637 }
1638 break;
1639
1640 case R_SPARC_PC10:
1641 case R_SPARC_PC22:
1642 case R_SPARC_PC_HH22:
1643 case R_SPARC_PC_HM10:
1644 case R_SPARC_PC_LM22:
1645 if (h != NULL
1646 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1647 break;
1648 /* Fall through. */
1649
1650 case R_SPARC_DISP8:
1651 case R_SPARC_DISP16:
1652 case R_SPARC_DISP32:
1653 case R_SPARC_DISP64:
1654 case R_SPARC_WDISP30:
1655 case R_SPARC_WDISP22:
1656 case R_SPARC_WDISP19:
1657 case R_SPARC_WDISP16:
1658 case R_SPARC_8:
1659 case R_SPARC_16:
1660 case R_SPARC_32:
1661 case R_SPARC_HI22:
1662 case R_SPARC_22:
1663 case R_SPARC_13:
1664 case R_SPARC_LO10:
1665 case R_SPARC_UA16:
1666 case R_SPARC_UA32:
1667 case R_SPARC_PLT32:
1668 case R_SPARC_10:
1669 case R_SPARC_11:
1670 case R_SPARC_64:
1671 case R_SPARC_OLO10:
1672 case R_SPARC_HH22:
1673 case R_SPARC_HM10:
1674 case R_SPARC_LM22:
1675 case R_SPARC_7:
1676 case R_SPARC_5:
1677 case R_SPARC_6:
1678 case R_SPARC_HIX22:
1679 case R_SPARC_LOX10:
1680 case R_SPARC_H44:
1681 case R_SPARC_M44:
1682 case R_SPARC_L44:
1683 case R_SPARC_UA64:
1684 if (info->shared)
1685 break;
1686 /* Fall through. */
1687
1688 case R_SPARC_WPLT30:
1689 if (h != NULL)
1690 {
1691 if (h->plt.refcount > 0)
1692 h->plt.refcount--;
1693 }
1694 break;
1695
1696 default:
1697 break;
1698 }
1699 }
1700
1701 return TRUE;
1702 }
1703
1704 /* Adjust a symbol defined by a dynamic object and referenced by a
1705 regular object. The current definition is in some section of the
1706 dynamic object, but we're not including those sections. We have to
1707 change the definition to something the rest of the link can
1708 understand. */
1709
1710 bfd_boolean
1711 _bfd_sparc_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1712 struct elf_link_hash_entry *h)
1713 {
1714 struct _bfd_sparc_elf_link_hash_table *htab;
1715 struct _bfd_sparc_elf_link_hash_entry * eh;
1716 struct _bfd_sparc_elf_dyn_relocs *p;
1717 asection *s;
1718
1719 htab = _bfd_sparc_elf_hash_table (info);
1720 BFD_ASSERT (htab != NULL);
1721
1722 /* Make sure we know what is going on here. */
1723 BFD_ASSERT (htab->elf.dynobj != NULL
1724 && (h->needs_plt
1725 || h->u.weakdef != NULL
1726 || (h->def_dynamic
1727 && h->ref_regular
1728 && !h->def_regular)));
1729
1730 /* If this is a function, put it in the procedure linkage table. We
1731 will fill in the contents of the procedure linkage table later
1732 (although we could actually do it here). The STT_NOTYPE
1733 condition is a hack specifically for the Oracle libraries
1734 delivered for Solaris; for some inexplicable reason, they define
1735 some of their functions as STT_NOTYPE when they really should be
1736 STT_FUNC. */
1737 if (h->type == STT_FUNC
1738 || h->needs_plt
1739 || (h->type == STT_NOTYPE
1740 && (h->root.type == bfd_link_hash_defined
1741 || h->root.type == bfd_link_hash_defweak)
1742 && (h->root.u.def.section->flags & SEC_CODE) != 0))
1743 {
1744 if (h->plt.refcount <= 0
1745 || (! info->shared
1746 && !h->def_dynamic
1747 && !h->ref_dynamic
1748 && h->root.type != bfd_link_hash_undefweak
1749 && h->root.type != bfd_link_hash_undefined))
1750 {
1751 /* This case can occur if we saw a WPLT30 reloc in an input
1752 file, but the symbol was never referred to by a dynamic
1753 object, or if all references were garbage collected. In
1754 such a case, we don't actually need to build a procedure
1755 linkage table, and we can just do a WDISP30 reloc instead. */
1756 h->plt.offset = (bfd_vma) -1;
1757 h->needs_plt = 0;
1758 }
1759
1760 return TRUE;
1761 }
1762 else
1763 h->plt.offset = (bfd_vma) -1;
1764
1765 /* If this is a weak symbol, and there is a real definition, the
1766 processor independent code will have arranged for us to see the
1767 real definition first, and we can just use the same value. */
1768 if (h->u.weakdef != NULL)
1769 {
1770 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1771 || h->u.weakdef->root.type == bfd_link_hash_defweak);
1772 h->root.u.def.section = h->u.weakdef->root.u.def.section;
1773 h->root.u.def.value = h->u.weakdef->root.u.def.value;
1774 return TRUE;
1775 }
1776
1777 /* This is a reference to a symbol defined by a dynamic object which
1778 is not a function. */
1779
1780 /* If we are creating a shared library, we must presume that the
1781 only references to the symbol are via the global offset table.
1782 For such cases we need not do anything here; the relocations will
1783 be handled correctly by relocate_section. */
1784 if (info->shared)
1785 return TRUE;
1786
1787 /* If there are no references to this symbol that do not use the
1788 GOT, we don't need to generate a copy reloc. */
1789 if (!h->non_got_ref)
1790 return TRUE;
1791
1792 eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
1793 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1794 {
1795 s = p->sec->output_section;
1796 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1797 break;
1798 }
1799
1800 /* If we didn't find any dynamic relocs in read-only sections, then
1801 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1802 if (p == NULL)
1803 {
1804 h->non_got_ref = 0;
1805 return TRUE;
1806 }
1807
1808 if (h->size == 0)
1809 {
1810 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
1811 h->root.root.string);
1812 return TRUE;
1813 }
1814
1815 /* We must allocate the symbol in our .dynbss section, which will
1816 become part of the .bss section of the executable. There will be
1817 an entry for this symbol in the .dynsym section. The dynamic
1818 object will contain position independent code, so all references
1819 from the dynamic object to this symbol will go through the global
1820 offset table. The dynamic linker will use the .dynsym entry to
1821 determine the address it must put in the global offset table, so
1822 both the dynamic object and the regular object will refer to the
1823 same memory location for the variable. */
1824
1825 /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker
1826 to copy the initial value out of the dynamic object and into the
1827 runtime process image. We need to remember the offset into the
1828 .rel.bss section we are going to use. */
1829 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1830 {
1831 htab->srelbss->size += SPARC_ELF_RELA_BYTES (htab);
1832 h->needs_copy = 1;
1833 }
1834
1835 s = htab->sdynbss;
1836
1837 return _bfd_elf_adjust_dynamic_copy (h, s);
1838 }
1839
1840 /* Allocate space in .plt, .got and associated reloc sections for
1841 dynamic relocs. */
1842
1843 static bfd_boolean
1844 allocate_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
1845 {
1846 struct bfd_link_info *info;
1847 struct _bfd_sparc_elf_link_hash_table *htab;
1848 struct _bfd_sparc_elf_link_hash_entry *eh;
1849 struct _bfd_sparc_elf_dyn_relocs *p;
1850
1851 if (h->root.type == bfd_link_hash_indirect)
1852 return TRUE;
1853
1854 if (h->root.type == bfd_link_hash_warning)
1855 /* When warning symbols are created, they **replace** the "real"
1856 entry in the hash table, thus we never get to see the real
1857 symbol in a hash traversal. So look at it now. */
1858 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1859
1860 info = (struct bfd_link_info *) inf;
1861 htab = _bfd_sparc_elf_hash_table (info);
1862 BFD_ASSERT (htab != NULL);
1863
1864 if (htab->elf.dynamic_sections_created
1865 && h->plt.refcount > 0)
1866 {
1867 /* Make sure this symbol is output as a dynamic symbol.
1868 Undefined weak syms won't yet be marked as dynamic. */
1869 if (h->dynindx == -1
1870 && !h->forced_local)
1871 {
1872 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1873 return FALSE;
1874 }
1875
1876 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
1877 {
1878 asection *s = htab->splt;
1879
1880 /* Allocate room for the header. */
1881 if (s->size == 0)
1882 {
1883 s->size = htab->plt_header_size;
1884
1885 /* Allocate space for the .rela.plt.unloaded relocations. */
1886 if (htab->is_vxworks && !info->shared)
1887 htab->srelplt2->size = sizeof (Elf32_External_Rela) * 2;
1888 }
1889
1890 /* The procedure linkage table size is bounded by the magnitude
1891 of the offset we can describe in the entry. */
1892 if (s->size >= (SPARC_ELF_WORD_BYTES(htab) == 8 ?
1893 (((bfd_vma)1 << 31) << 1) : 0x400000))
1894 {
1895 bfd_set_error (bfd_error_bad_value);
1896 return FALSE;
1897 }
1898
1899 if (SPARC_ELF_WORD_BYTES(htab) == 8
1900 && s->size >= PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE)
1901 {
1902 bfd_vma off = s->size - PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE;
1903
1904
1905 off = (off % (160 * PLT64_ENTRY_SIZE)) / PLT64_ENTRY_SIZE;
1906
1907 h->plt.offset = (s->size - (off * 8));
1908 }
1909 else
1910 h->plt.offset = s->size;
1911
1912 /* If this symbol is not defined in a regular file, and we are
1913 not generating a shared library, then set the symbol to this
1914 location in the .plt. This is required to make function
1915 pointers compare as equal between the normal executable and
1916 the shared library. */
1917 if (! info->shared
1918 && !h->def_regular)
1919 {
1920 h->root.u.def.section = s;
1921 h->root.u.def.value = h->plt.offset;
1922 }
1923
1924 /* Make room for this entry. */
1925 s->size += htab->plt_entry_size;
1926
1927 /* We also need to make an entry in the .rela.plt section. */
1928 htab->srelplt->size += SPARC_ELF_RELA_BYTES (htab);
1929
1930 if (htab->is_vxworks)
1931 {
1932 /* Allocate space for the .got.plt entry. */
1933 htab->sgotplt->size += 4;
1934
1935 /* ...and for the .rela.plt.unloaded relocations. */
1936 if (!info->shared)
1937 htab->srelplt2->size += sizeof (Elf32_External_Rela) * 3;
1938 }
1939 }
1940 else
1941 {
1942 h->plt.offset = (bfd_vma) -1;
1943 h->needs_plt = 0;
1944 }
1945 }
1946 else
1947 {
1948 h->plt.offset = (bfd_vma) -1;
1949 h->needs_plt = 0;
1950 }
1951
1952 /* If R_SPARC_TLS_IE_{HI22,LO10} symbol is now local to the binary,
1953 make it a R_SPARC_TLS_LE_{HI22,LO10} requiring no TLS entry. */
1954 if (h->got.refcount > 0
1955 && !info->shared
1956 && h->dynindx == -1
1957 && _bfd_sparc_elf_hash_entry(h)->tls_type == GOT_TLS_IE)
1958 h->got.offset = (bfd_vma) -1;
1959 else if (h->got.refcount > 0)
1960 {
1961 asection *s;
1962 bfd_boolean dyn;
1963 int tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
1964
1965 /* Make sure this symbol is output as a dynamic symbol.
1966 Undefined weak syms won't yet be marked as dynamic. */
1967 if (h->dynindx == -1
1968 && !h->forced_local)
1969 {
1970 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1971 return FALSE;
1972 }
1973
1974 s = htab->sgot;
1975 h->got.offset = s->size;
1976 s->size += SPARC_ELF_WORD_BYTES (htab);
1977 /* R_SPARC_TLS_GD_HI{22,LO10} needs 2 consecutive GOT slots. */
1978 if (tls_type == GOT_TLS_GD)
1979 s->size += SPARC_ELF_WORD_BYTES (htab);
1980 dyn = htab->elf.dynamic_sections_created;
1981 /* R_SPARC_TLS_IE_{HI22,LO10} needs one dynamic relocation,
1982 R_SPARC_TLS_GD_{HI22,LO10} needs one if local symbol and two if
1983 global. */
1984 if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
1985 || tls_type == GOT_TLS_IE)
1986 htab->srelgot->size += SPARC_ELF_RELA_BYTES (htab);
1987 else if (tls_type == GOT_TLS_GD)
1988 htab->srelgot->size += 2 * SPARC_ELF_RELA_BYTES (htab);
1989 else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
1990 htab->srelgot->size += SPARC_ELF_RELA_BYTES (htab);
1991 }
1992 else
1993 h->got.offset = (bfd_vma) -1;
1994
1995 eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
1996 if (eh->dyn_relocs == NULL)
1997 return TRUE;
1998
1999 /* In the shared -Bsymbolic case, discard space allocated for
2000 dynamic pc-relative relocs against symbols which turn out to be
2001 defined in regular objects. For the normal shared case, discard
2002 space for pc-relative relocs that have become local due to symbol
2003 visibility changes. */
2004
2005 if (info->shared)
2006 {
2007 if (h->def_regular
2008 && (h->forced_local
2009 || info->symbolic))
2010 {
2011 struct _bfd_sparc_elf_dyn_relocs **pp;
2012
2013 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2014 {
2015 p->count -= p->pc_count;
2016 p->pc_count = 0;
2017 if (p->count == 0)
2018 *pp = p->next;
2019 else
2020 pp = &p->next;
2021 }
2022 }
2023
2024 if (htab->is_vxworks)
2025 {
2026 struct _bfd_sparc_elf_dyn_relocs **pp;
2027
2028 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2029 {
2030 if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
2031 *pp = p->next;
2032 else
2033 pp = &p->next;
2034 }
2035 }
2036
2037 /* Also discard relocs on undefined weak syms with non-default
2038 visibility. */
2039 if (eh->dyn_relocs != NULL
2040 && h->root.type == bfd_link_hash_undefweak)
2041 {
2042 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2043 eh->dyn_relocs = NULL;
2044
2045 /* Make sure undefined weak symbols are output as a dynamic
2046 symbol in PIEs. */
2047 else if (h->dynindx == -1
2048 && !h->forced_local)
2049 {
2050 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2051 return FALSE;
2052 }
2053 }
2054 }
2055 else
2056 {
2057 /* For the non-shared case, discard space for relocs against
2058 symbols which turn out to need copy relocs or are not
2059 dynamic. */
2060
2061 if (!h->non_got_ref
2062 && ((h->def_dynamic
2063 && !h->def_regular)
2064 || (htab->elf.dynamic_sections_created
2065 && (h->root.type == bfd_link_hash_undefweak
2066 || h->root.type == bfd_link_hash_undefined))))
2067 {
2068 /* Make sure this symbol is output as a dynamic symbol.
2069 Undefined weak syms won't yet be marked as dynamic. */
2070 if (h->dynindx == -1
2071 && !h->forced_local)
2072 {
2073 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2074 return FALSE;
2075 }
2076
2077 /* If that succeeded, we know we'll be keeping all the
2078 relocs. */
2079 if (h->dynindx != -1)
2080 goto keep;
2081 }
2082
2083 eh->dyn_relocs = NULL;
2084
2085 keep: ;
2086 }
2087
2088 /* Finally, allocate space. */
2089 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2090 {
2091 asection *sreloc = elf_section_data (p->sec)->sreloc;
2092 sreloc->size += p->count * SPARC_ELF_RELA_BYTES (htab);
2093 }
2094
2095 return TRUE;
2096 }
2097
2098 /* Find any dynamic relocs that apply to read-only sections. */
2099
2100 static bfd_boolean
2101 readonly_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
2102 {
2103 struct _bfd_sparc_elf_link_hash_entry *eh;
2104 struct _bfd_sparc_elf_dyn_relocs *p;
2105
2106 if (h->root.type == bfd_link_hash_warning)
2107 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2108
2109 eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
2110 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2111 {
2112 asection *s = p->sec->output_section;
2113
2114 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2115 {
2116 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2117
2118 info->flags |= DF_TEXTREL;
2119
2120 /* Not an error, just cut short the traversal. */
2121 return FALSE;
2122 }
2123 }
2124 return TRUE;
2125 }
2126
2127 /* Return true if the dynamic symbol for a given section should be
2128 omitted when creating a shared library. */
2129
2130 bfd_boolean
2131 _bfd_sparc_elf_omit_section_dynsym (bfd *output_bfd,
2132 struct bfd_link_info *info,
2133 asection *p)
2134 {
2135 /* We keep the .got section symbol so that explicit relocations
2136 against the _GLOBAL_OFFSET_TABLE_ symbol emitted in PIC mode
2137 can be turned into relocations against the .got symbol. */
2138 if (strcmp (p->name, ".got") == 0)
2139 return FALSE;
2140
2141 return _bfd_elf_link_omit_section_dynsym (output_bfd, info, p);
2142 }
2143
2144 /* Set the sizes of the dynamic sections. */
2145
2146 bfd_boolean
2147 _bfd_sparc_elf_size_dynamic_sections (bfd *output_bfd,
2148 struct bfd_link_info *info)
2149 {
2150 struct _bfd_sparc_elf_link_hash_table *htab;
2151 bfd *dynobj;
2152 asection *s;
2153 bfd *ibfd;
2154
2155 htab = _bfd_sparc_elf_hash_table (info);
2156 BFD_ASSERT (htab != NULL);
2157 dynobj = htab->elf.dynobj;
2158 BFD_ASSERT (dynobj != NULL);
2159
2160 if (elf_hash_table (info)->dynamic_sections_created)
2161 {
2162 /* Set the contents of the .interp section to the interpreter. */
2163 if (info->executable)
2164 {
2165 s = bfd_get_section_by_name (dynobj, ".interp");
2166 BFD_ASSERT (s != NULL);
2167 s->size = htab->dynamic_interpreter_size;
2168 s->contents = (unsigned char *) htab->dynamic_interpreter;
2169 }
2170 }
2171
2172 /* Set up .got offsets for local syms, and space for local dynamic
2173 relocs. */
2174 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2175 {
2176 bfd_signed_vma *local_got;
2177 bfd_signed_vma *end_local_got;
2178 char *local_tls_type;
2179 bfd_size_type locsymcount;
2180 Elf_Internal_Shdr *symtab_hdr;
2181 asection *srel;
2182
2183 if (! is_sparc_elf (ibfd))
2184 continue;
2185
2186 for (s = ibfd->sections; s != NULL; s = s->next)
2187 {
2188 struct _bfd_sparc_elf_dyn_relocs *p;
2189
2190 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
2191 {
2192 if (!bfd_is_abs_section (p->sec)
2193 && bfd_is_abs_section (p->sec->output_section))
2194 {
2195 /* Input section has been discarded, either because
2196 it is a copy of a linkonce section or due to
2197 linker script /DISCARD/, so we'll be discarding
2198 the relocs too. */
2199 }
2200 else if (htab->is_vxworks
2201 && strcmp (p->sec->output_section->name,
2202 ".tls_vars") == 0)
2203 {
2204 /* Relocations in vxworks .tls_vars sections are
2205 handled specially by the loader. */
2206 }
2207 else if (p->count != 0)
2208 {
2209 srel = elf_section_data (p->sec)->sreloc;
2210 srel->size += p->count * SPARC_ELF_RELA_BYTES (htab);
2211 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2212 info->flags |= DF_TEXTREL;
2213 }
2214 }
2215 }
2216
2217 local_got = elf_local_got_refcounts (ibfd);
2218 if (!local_got)
2219 continue;
2220
2221 symtab_hdr = &elf_symtab_hdr (ibfd);
2222 locsymcount = symtab_hdr->sh_info;
2223 end_local_got = local_got + locsymcount;
2224 local_tls_type = _bfd_sparc_elf_local_got_tls_type (ibfd);
2225 s = htab->sgot;
2226 srel = htab->srelgot;
2227 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
2228 {
2229 if (*local_got > 0)
2230 {
2231 *local_got = s->size;
2232 s->size += SPARC_ELF_WORD_BYTES (htab);
2233 if (*local_tls_type == GOT_TLS_GD)
2234 s->size += SPARC_ELF_WORD_BYTES (htab);
2235 if (info->shared
2236 || *local_tls_type == GOT_TLS_GD
2237 || *local_tls_type == GOT_TLS_IE)
2238 srel->size += SPARC_ELF_RELA_BYTES (htab);
2239 }
2240 else
2241 *local_got = (bfd_vma) -1;
2242 }
2243 }
2244
2245 if (htab->tls_ldm_got.refcount > 0)
2246 {
2247 /* Allocate 2 got entries and 1 dynamic reloc for
2248 R_SPARC_TLS_LDM_{HI22,LO10} relocs. */
2249 htab->tls_ldm_got.offset = htab->sgot->size;
2250 htab->sgot->size += (2 * SPARC_ELF_WORD_BYTES (htab));
2251 htab->srelgot->size += SPARC_ELF_RELA_BYTES (htab);
2252 }
2253 else
2254 htab->tls_ldm_got.offset = -1;
2255
2256 /* Allocate global sym .plt and .got entries, and space for global
2257 sym dynamic relocs. */
2258 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
2259
2260 if (! ABI_64_P (output_bfd)
2261 && !htab->is_vxworks
2262 && elf_hash_table (info)->dynamic_sections_created)
2263 {
2264 /* Make space for the trailing nop in .plt. */
2265 if (htab->splt->size > 0)
2266 htab->splt->size += 1 * SPARC_INSN_BYTES;
2267
2268 /* If the .got section is more than 0x1000 bytes, we add
2269 0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13
2270 bit relocations have a greater chance of working.
2271
2272 FIXME: Make this optimization work for 64-bit too. */
2273 if (htab->sgot->size >= 0x1000
2274 && elf_hash_table (info)->hgot->root.u.def.value == 0)
2275 elf_hash_table (info)->hgot->root.u.def.value = 0x1000;
2276 }
2277
2278 /* The check_relocs and adjust_dynamic_symbol entry points have
2279 determined the sizes of the various dynamic sections. Allocate
2280 memory for them. */
2281 for (s = dynobj->sections; s != NULL; s = s->next)
2282 {
2283 if ((s->flags & SEC_LINKER_CREATED) == 0)
2284 continue;
2285
2286 if (s == htab->splt
2287 || s == htab->sgot
2288 || s == htab->sdynbss
2289 || s == htab->sgotplt)
2290 {
2291 /* Strip this section if we don't need it; see the
2292 comment below. */
2293 }
2294 else if (CONST_STRNEQ (s->name, ".rela"))
2295 {
2296 if (s->size != 0)
2297 {
2298 /* We use the reloc_count field as a counter if we need
2299 to copy relocs into the output file. */
2300 s->reloc_count = 0;
2301 }
2302 }
2303 else
2304 {
2305 /* It's not one of our sections. */
2306 continue;
2307 }
2308
2309 if (s->size == 0)
2310 {
2311 /* If we don't need this section, strip it from the
2312 output file. This is mostly to handle .rela.bss and
2313 .rela.plt. We must create both sections in
2314 create_dynamic_sections, because they must be created
2315 before the linker maps input sections to output
2316 sections. The linker does that before
2317 adjust_dynamic_symbol is called, and it is that
2318 function which decides whether anything needs to go
2319 into these sections. */
2320 s->flags |= SEC_EXCLUDE;
2321 continue;
2322 }
2323
2324 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2325 continue;
2326
2327 /* Allocate memory for the section contents. Zero the memory
2328 for the benefit of .rela.plt, which has 4 unused entries
2329 at the beginning, and we don't want garbage. */
2330 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2331 if (s->contents == NULL)
2332 return FALSE;
2333 }
2334
2335 if (elf_hash_table (info)->dynamic_sections_created)
2336 {
2337 /* Add some entries to the .dynamic section. We fill in the
2338 values later, in _bfd_sparc_elf_finish_dynamic_sections, but we
2339 must add the entries now so that we get the correct size for
2340 the .dynamic section. The DT_DEBUG entry is filled in by the
2341 dynamic linker and used by the debugger. */
2342 #define add_dynamic_entry(TAG, VAL) \
2343 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2344
2345 if (info->executable)
2346 {
2347 if (!add_dynamic_entry (DT_DEBUG, 0))
2348 return FALSE;
2349 }
2350
2351 if (htab->srelplt->size != 0)
2352 {
2353 if (!add_dynamic_entry (DT_PLTGOT, 0)
2354 || !add_dynamic_entry (DT_PLTRELSZ, 0)
2355 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2356 || !add_dynamic_entry (DT_JMPREL, 0))
2357 return FALSE;
2358 }
2359
2360 if (!add_dynamic_entry (DT_RELA, 0)
2361 || !add_dynamic_entry (DT_RELASZ, 0)
2362 || !add_dynamic_entry (DT_RELAENT,
2363 SPARC_ELF_RELA_BYTES (htab)))
2364 return FALSE;
2365
2366 /* If any dynamic relocs apply to a read-only section,
2367 then we need a DT_TEXTREL entry. */
2368 if ((info->flags & DF_TEXTREL) == 0)
2369 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
2370 (PTR) info);
2371
2372 if (info->flags & DF_TEXTREL)
2373 {
2374 if (!add_dynamic_entry (DT_TEXTREL, 0))
2375 return FALSE;
2376 }
2377
2378 if (ABI_64_P (output_bfd))
2379 {
2380 int reg;
2381 struct _bfd_sparc_elf_app_reg * app_regs;
2382 struct elf_strtab_hash *dynstr;
2383 struct elf_link_hash_table *eht = elf_hash_table (info);
2384
2385 /* Add dynamic STT_REGISTER symbols and corresponding DT_SPARC_REGISTER
2386 entries if needed. */
2387 app_regs = _bfd_sparc_elf_hash_table (info)->app_regs;
2388 dynstr = eht->dynstr;
2389
2390 for (reg = 0; reg < 4; reg++)
2391 if (app_regs [reg].name != NULL)
2392 {
2393 struct elf_link_local_dynamic_entry *entry, *e;
2394
2395 if (!add_dynamic_entry (DT_SPARC_REGISTER, 0))
2396 return FALSE;
2397
2398 entry = (struct elf_link_local_dynamic_entry *)
2399 bfd_hash_allocate (&info->hash->table, sizeof (*entry));
2400 if (entry == NULL)
2401 return FALSE;
2402
2403 /* We cheat here a little bit: the symbol will not be local, so we
2404 put it at the end of the dynlocal linked list. We will fix it
2405 later on, as we have to fix other fields anyway. */
2406 entry->isym.st_value = reg < 2 ? reg + 2 : reg + 4;
2407 entry->isym.st_size = 0;
2408 if (*app_regs [reg].name != '\0')
2409 entry->isym.st_name
2410 = _bfd_elf_strtab_add (dynstr, app_regs[reg].name, FALSE);
2411 else
2412 entry->isym.st_name = 0;
2413 entry->isym.st_other = 0;
2414 entry->isym.st_info = ELF_ST_INFO (app_regs [reg].bind,
2415 STT_REGISTER);
2416 entry->isym.st_shndx = app_regs [reg].shndx;
2417 entry->next = NULL;
2418 entry->input_bfd = output_bfd;
2419 entry->input_indx = -1;
2420
2421 if (eht->dynlocal == NULL)
2422 eht->dynlocal = entry;
2423 else
2424 {
2425 for (e = eht->dynlocal; e->next; e = e->next)
2426 ;
2427 e->next = entry;
2428 }
2429 eht->dynsymcount++;
2430 }
2431 }
2432 if (htab->is_vxworks
2433 && !elf_vxworks_add_dynamic_entries (output_bfd, info))
2434 return FALSE;
2435 }
2436 #undef add_dynamic_entry
2437
2438 return TRUE;
2439 }
2440 \f
2441 bfd_boolean
2442 _bfd_sparc_elf_new_section_hook (bfd *abfd, asection *sec)
2443 {
2444 if (!sec->used_by_bfd)
2445 {
2446 struct _bfd_sparc_elf_section_data *sdata;
2447 bfd_size_type amt = sizeof (*sdata);
2448
2449 sdata = bfd_zalloc (abfd, amt);
2450 if (sdata == NULL)
2451 return FALSE;
2452 sec->used_by_bfd = sdata;
2453 }
2454
2455 return _bfd_elf_new_section_hook (abfd, sec);
2456 }
2457
2458 bfd_boolean
2459 _bfd_sparc_elf_relax_section (bfd *abfd ATTRIBUTE_UNUSED,
2460 struct bfd_section *section,
2461 struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
2462 bfd_boolean *again)
2463 {
2464 if (link_info->relocatable)
2465 (*link_info->callbacks->einfo)
2466 (_("%P%F: --relax and -r may not be used together\n"));
2467
2468 *again = FALSE;
2469 sec_do_relax (section) = 1;
2470 return TRUE;
2471 }
2472 \f
2473 /* Return the base VMA address which should be subtracted from real addresses
2474 when resolving @dtpoff relocation.
2475 This is PT_TLS segment p_vaddr. */
2476
2477 static bfd_vma
2478 dtpoff_base (struct bfd_link_info *info)
2479 {
2480 /* If tls_sec is NULL, we should have signalled an error already. */
2481 if (elf_hash_table (info)->tls_sec == NULL)
2482 return 0;
2483 return elf_hash_table (info)->tls_sec->vma;
2484 }
2485
2486 /* Return the relocation value for @tpoff relocation
2487 if STT_TLS virtual address is ADDRESS. */
2488
2489 static bfd_vma
2490 tpoff (struct bfd_link_info *info, bfd_vma address)
2491 {
2492 struct elf_link_hash_table *htab = elf_hash_table (info);
2493
2494 /* If tls_sec is NULL, we should have signalled an error already. */
2495 if (htab->tls_sec == NULL)
2496 return 0;
2497 return address - htab->tls_size - htab->tls_sec->vma;
2498 }
2499
2500 /* Relocate a SPARC ELF section. */
2501
2502 bfd_boolean
2503 _bfd_sparc_elf_relocate_section (bfd *output_bfd,
2504 struct bfd_link_info *info,
2505 bfd *input_bfd,
2506 asection *input_section,
2507 bfd_byte *contents,
2508 Elf_Internal_Rela *relocs,
2509 Elf_Internal_Sym *local_syms,
2510 asection **local_sections)
2511 {
2512 struct _bfd_sparc_elf_link_hash_table *htab;
2513 Elf_Internal_Shdr *symtab_hdr;
2514 struct elf_link_hash_entry **sym_hashes;
2515 bfd_vma *local_got_offsets;
2516 bfd_vma got_base;
2517 asection *sreloc;
2518 Elf_Internal_Rela *rel;
2519 Elf_Internal_Rela *relend;
2520 int num_relocs;
2521 bfd_boolean is_vxworks_tls;
2522
2523 htab = _bfd_sparc_elf_hash_table (info);
2524 BFD_ASSERT (htab != NULL);
2525 symtab_hdr = &elf_symtab_hdr (input_bfd);
2526 sym_hashes = elf_sym_hashes (input_bfd);
2527 local_got_offsets = elf_local_got_offsets (input_bfd);
2528
2529 if (elf_hash_table (info)->hgot == NULL)
2530 got_base = 0;
2531 else
2532 got_base = elf_hash_table (info)->hgot->root.u.def.value;
2533
2534 sreloc = elf_section_data (input_section)->sreloc;
2535 /* We have to handle relocations in vxworks .tls_vars sections
2536 specially, because the dynamic loader is 'weird'. */
2537 is_vxworks_tls = (htab->is_vxworks && info->shared
2538 && !strcmp (input_section->output_section->name,
2539 ".tls_vars"));
2540
2541 rel = relocs;
2542 if (ABI_64_P (output_bfd))
2543 num_relocs = NUM_SHDR_ENTRIES (& elf_section_data (input_section)->rel_hdr);
2544 else
2545 num_relocs = input_section->reloc_count;
2546 relend = relocs + num_relocs;
2547 for (; rel < relend; rel++)
2548 {
2549 int r_type, tls_type;
2550 reloc_howto_type *howto;
2551 unsigned long r_symndx;
2552 struct elf_link_hash_entry *h;
2553 Elf_Internal_Sym *sym;
2554 asection *sec;
2555 bfd_vma relocation, off;
2556 bfd_reloc_status_type r;
2557 bfd_boolean is_plt = FALSE;
2558 bfd_boolean unresolved_reloc;
2559
2560 r_type = SPARC_ELF_R_TYPE (rel->r_info);
2561 if (r_type == R_SPARC_GNU_VTINHERIT
2562 || r_type == R_SPARC_GNU_VTENTRY)
2563 continue;
2564
2565 if (r_type < 0 || r_type >= (int) R_SPARC_max_std)
2566 {
2567 bfd_set_error (bfd_error_bad_value);
2568 return FALSE;
2569 }
2570 howto = _bfd_sparc_elf_howto_table + r_type;
2571
2572 r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
2573 h = NULL;
2574 sym = NULL;
2575 sec = NULL;
2576 unresolved_reloc = FALSE;
2577 if (r_symndx < symtab_hdr->sh_info)
2578 {
2579 sym = local_syms + r_symndx;
2580 sec = local_sections[r_symndx];
2581 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2582 }
2583 else
2584 {
2585 bfd_boolean warned;
2586
2587 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2588 r_symndx, symtab_hdr, sym_hashes,
2589 h, sec, relocation,
2590 unresolved_reloc, warned);
2591 if (warned)
2592 {
2593 /* To avoid generating warning messages about truncated
2594 relocations, set the relocation's address to be the same as
2595 the start of this section. */
2596 if (input_section->output_section != NULL)
2597 relocation = input_section->output_section->vma;
2598 else
2599 relocation = 0;
2600 }
2601 }
2602
2603 if (sec != NULL && elf_discarded_section (sec))
2604 {
2605 /* For relocs against symbols from removed linkonce
2606 sections, or sections discarded by a linker script, we
2607 just want the section contents zeroed. Avoid any
2608 special processing. */
2609 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
2610 rel->r_info = 0;
2611 rel->r_addend = 0;
2612 continue;
2613 }
2614
2615 if (info->relocatable)
2616 continue;
2617
2618 switch (r_type)
2619 {
2620 case R_SPARC_GOTDATA_HIX22:
2621 case R_SPARC_GOTDATA_LOX10:
2622 case R_SPARC_GOTDATA_OP_HIX22:
2623 case R_SPARC_GOTDATA_OP_LOX10:
2624 /* We don't support these code transformation optimizations
2625 yet, so just leave the sequence alone and treat as
2626 GOT22/GOT10. */
2627 if (r_type == R_SPARC_GOTDATA_HIX22
2628 || r_type == R_SPARC_GOTDATA_OP_HIX22)
2629 r_type = R_SPARC_GOT22;
2630 else
2631 r_type = R_SPARC_GOT10;
2632 /* Fall through. */
2633
2634 case R_SPARC_GOT10:
2635 case R_SPARC_GOT13:
2636 case R_SPARC_GOT22:
2637 /* Relocation is to the entry for this symbol in the global
2638 offset table. */
2639 if (htab->sgot == NULL)
2640 abort ();
2641
2642 if (h != NULL)
2643 {
2644 bfd_boolean dyn;
2645
2646 off = h->got.offset;
2647 BFD_ASSERT (off != (bfd_vma) -1);
2648 dyn = elf_hash_table (info)->dynamic_sections_created;
2649
2650 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2651 || (info->shared
2652 && (info->symbolic
2653 || h->dynindx == -1
2654 || h->forced_local)
2655 && h->def_regular))
2656 {
2657 /* This is actually a static link, or it is a
2658 -Bsymbolic link and the symbol is defined
2659 locally, or the symbol was forced to be local
2660 because of a version file. We must initialize
2661 this entry in the global offset table. Since the
2662 offset must always be a multiple of 8 for 64-bit
2663 and 4 for 32-bit, we use the least significant bit
2664 to record whether we have initialized it already.
2665
2666 When doing a dynamic link, we create a .rela.got
2667 relocation entry to initialize the value. This
2668 is done in the finish_dynamic_symbol routine. */
2669 if ((off & 1) != 0)
2670 off &= ~1;
2671 else
2672 {
2673 SPARC_ELF_PUT_WORD (htab, output_bfd, relocation,
2674 htab->sgot->contents + off);
2675 h->got.offset |= 1;
2676 }
2677 }
2678 else
2679 unresolved_reloc = FALSE;
2680 }
2681 else
2682 {
2683 BFD_ASSERT (local_got_offsets != NULL
2684 && local_got_offsets[r_symndx] != (bfd_vma) -1);
2685
2686 off = local_got_offsets[r_symndx];
2687
2688 /* The offset must always be a multiple of 8 on 64-bit and
2689 4 on 32-bit. We use the least significant bit to record
2690 whether we have already processed this entry. */
2691 if ((off & 1) != 0)
2692 off &= ~1;
2693 else
2694 {
2695
2696 if (info->shared)
2697 {
2698 asection *s;
2699 Elf_Internal_Rela outrel;
2700
2701 /* We need to generate a R_SPARC_RELATIVE reloc
2702 for the dynamic linker. */
2703 s = htab->srelgot;
2704 BFD_ASSERT (s != NULL);
2705
2706 outrel.r_offset = (htab->sgot->output_section->vma
2707 + htab->sgot->output_offset
2708 + off);
2709 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
2710 0, R_SPARC_RELATIVE);
2711 outrel.r_addend = relocation;
2712 relocation = 0;
2713 sparc_elf_append_rela (output_bfd, s, &outrel);
2714 }
2715
2716 SPARC_ELF_PUT_WORD (htab, output_bfd, relocation,
2717 htab->sgot->contents + off);
2718 local_got_offsets[r_symndx] |= 1;
2719 }
2720 }
2721 relocation = htab->sgot->output_offset + off - got_base;
2722 break;
2723
2724 case R_SPARC_PLT32:
2725 case R_SPARC_PLT64:
2726 if (h == NULL || h->plt.offset == (bfd_vma) -1)
2727 {
2728 r_type = (r_type == R_SPARC_PLT32) ? R_SPARC_32 : R_SPARC_64;
2729 goto r_sparc_plt32;
2730 }
2731 /* Fall through. */
2732
2733 case R_SPARC_WPLT30:
2734 case R_SPARC_HIPLT22:
2735 case R_SPARC_LOPLT10:
2736 case R_SPARC_PCPLT32:
2737 case R_SPARC_PCPLT22:
2738 case R_SPARC_PCPLT10:
2739 r_sparc_wplt30:
2740 /* Relocation is to the entry for this symbol in the
2741 procedure linkage table. */
2742
2743 if (! ABI_64_P (output_bfd))
2744 {
2745 /* The Solaris native assembler will generate a WPLT30 reloc
2746 for a local symbol if you assemble a call from one
2747 section to another when using -K pic. We treat it as
2748 WDISP30. */
2749 if (h == NULL)
2750 break;
2751 }
2752 /* PR 7027: We need similar behaviour for 64-bit binaries. */
2753 else if (r_type == R_SPARC_WPLT30 && h == NULL)
2754 break;
2755 else
2756 {
2757 BFD_ASSERT (h != NULL);
2758 }
2759
2760 if (h->plt.offset == (bfd_vma) -1 || htab->splt == NULL)
2761 {
2762 /* We didn't make a PLT entry for this symbol. This
2763 happens when statically linking PIC code, or when
2764 using -Bsymbolic. */
2765 break;
2766 }
2767
2768 relocation = (htab->splt->output_section->vma
2769 + htab->splt->output_offset
2770 + h->plt.offset);
2771 unresolved_reloc = FALSE;
2772 if (r_type == R_SPARC_PLT32 || r_type == R_SPARC_PLT64)
2773 {
2774 r_type = r_type == R_SPARC_PLT32 ? R_SPARC_32 : R_SPARC_64;
2775 is_plt = TRUE;
2776 goto r_sparc_plt32;
2777 }
2778 break;
2779
2780 case R_SPARC_PC10:
2781 case R_SPARC_PC22:
2782 case R_SPARC_PC_HH22:
2783 case R_SPARC_PC_HM10:
2784 case R_SPARC_PC_LM22:
2785 if (h != NULL
2786 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2787 break;
2788 /* Fall through. */
2789 case R_SPARC_DISP8:
2790 case R_SPARC_DISP16:
2791 case R_SPARC_DISP32:
2792 case R_SPARC_DISP64:
2793 case R_SPARC_WDISP30:
2794 case R_SPARC_WDISP22:
2795 case R_SPARC_WDISP19:
2796 case R_SPARC_WDISP16:
2797 case R_SPARC_8:
2798 case R_SPARC_16:
2799 case R_SPARC_32:
2800 case R_SPARC_HI22:
2801 case R_SPARC_22:
2802 case R_SPARC_13:
2803 case R_SPARC_LO10:
2804 case R_SPARC_UA16:
2805 case R_SPARC_UA32:
2806 case R_SPARC_10:
2807 case R_SPARC_11:
2808 case R_SPARC_64:
2809 case R_SPARC_OLO10:
2810 case R_SPARC_HH22:
2811 case R_SPARC_HM10:
2812 case R_SPARC_LM22:
2813 case R_SPARC_7:
2814 case R_SPARC_5:
2815 case R_SPARC_6:
2816 case R_SPARC_HIX22:
2817 case R_SPARC_LOX10:
2818 case R_SPARC_H44:
2819 case R_SPARC_M44:
2820 case R_SPARC_L44:
2821 case R_SPARC_UA64:
2822 r_sparc_plt32:
2823 if ((input_section->flags & SEC_ALLOC) == 0
2824 || is_vxworks_tls)
2825 break;
2826
2827 if ((info->shared
2828 && (h == NULL
2829 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2830 || h->root.type != bfd_link_hash_undefweak)
2831 && (! howto->pc_relative
2832 || (h != NULL
2833 && h->dynindx != -1
2834 && (! info->symbolic
2835 || !h->def_regular))))
2836 || (!info->shared
2837 && h != NULL
2838 && h->dynindx != -1
2839 && !h->non_got_ref
2840 && ((h->def_dynamic
2841 && !h->def_regular)
2842 || h->root.type == bfd_link_hash_undefweak
2843 || h->root.type == bfd_link_hash_undefined)))
2844 {
2845 Elf_Internal_Rela outrel;
2846 bfd_boolean skip, relocate = FALSE;
2847
2848 /* When generating a shared object, these relocations
2849 are copied into the output file to be resolved at run
2850 time. */
2851
2852 BFD_ASSERT (sreloc != NULL);
2853
2854 skip = FALSE;
2855
2856 outrel.r_offset =
2857 _bfd_elf_section_offset (output_bfd, info, input_section,
2858 rel->r_offset);
2859 if (outrel.r_offset == (bfd_vma) -1)
2860 skip = TRUE;
2861 else if (outrel.r_offset == (bfd_vma) -2)
2862 skip = TRUE, relocate = TRUE;
2863 outrel.r_offset += (input_section->output_section->vma
2864 + input_section->output_offset);
2865
2866 /* Optimize unaligned reloc usage now that we know where
2867 it finally resides. */
2868 switch (r_type)
2869 {
2870 case R_SPARC_16:
2871 if (outrel.r_offset & 1)
2872 r_type = R_SPARC_UA16;
2873 break;
2874 case R_SPARC_UA16:
2875 if (!(outrel.r_offset & 1))
2876 r_type = R_SPARC_16;
2877 break;
2878 case R_SPARC_32:
2879 if (outrel.r_offset & 3)
2880 r_type = R_SPARC_UA32;
2881 break;
2882 case R_SPARC_UA32:
2883 if (!(outrel.r_offset & 3))
2884 r_type = R_SPARC_32;
2885 break;
2886 case R_SPARC_64:
2887 if (outrel.r_offset & 7)
2888 r_type = R_SPARC_UA64;
2889 break;
2890 case R_SPARC_UA64:
2891 if (!(outrel.r_offset & 7))
2892 r_type = R_SPARC_64;
2893 break;
2894 case R_SPARC_DISP8:
2895 case R_SPARC_DISP16:
2896 case R_SPARC_DISP32:
2897 case R_SPARC_DISP64:
2898 /* If the symbol is not dynamic, we should not keep
2899 a dynamic relocation. But an .rela.* slot has been
2900 allocated for it, output R_SPARC_NONE.
2901 FIXME: Add code tracking needed dynamic relocs as
2902 e.g. i386 has. */
2903 if (h->dynindx == -1)
2904 skip = TRUE, relocate = TRUE;
2905 break;
2906 }
2907
2908 if (skip)
2909 memset (&outrel, 0, sizeof outrel);
2910 /* h->dynindx may be -1 if the symbol was marked to
2911 become local. */
2912 else if (h != NULL && ! is_plt
2913 && ((! info->symbolic && h->dynindx != -1)
2914 || !h->def_regular))
2915 {
2916 BFD_ASSERT (h->dynindx != -1);
2917 outrel.r_info = SPARC_ELF_R_INFO (htab, rel, h->dynindx, r_type);
2918 outrel.r_addend = rel->r_addend;
2919 }
2920 else
2921 {
2922 if (r_type == R_SPARC_32 || r_type == R_SPARC_64)
2923 {
2924 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
2925 0, R_SPARC_RELATIVE);
2926 outrel.r_addend = relocation + rel->r_addend;
2927 }
2928 else
2929 {
2930 long indx;
2931
2932 outrel.r_addend = relocation + rel->r_addend;
2933
2934 if (is_plt)
2935 sec = htab->splt;
2936
2937 if (bfd_is_abs_section (sec))
2938 indx = 0;
2939 else if (sec == NULL || sec->owner == NULL)
2940 {
2941 bfd_set_error (bfd_error_bad_value);
2942 return FALSE;
2943 }
2944 else
2945 {
2946 asection *osec;
2947
2948 /* We are turning this relocation into one
2949 against a section symbol. It would be
2950 proper to subtract the symbol's value,
2951 osec->vma, from the emitted reloc addend,
2952 but ld.so expects buggy relocs. */
2953 osec = sec->output_section;
2954 indx = elf_section_data (osec)->dynindx;
2955
2956 if (indx == 0)
2957 {
2958 osec = htab->elf.text_index_section;
2959 indx = elf_section_data (osec)->dynindx;
2960 }
2961
2962 /* FIXME: we really should be able to link non-pic
2963 shared libraries. */
2964 if (indx == 0)
2965 {
2966 BFD_FAIL ();
2967 (*_bfd_error_handler)
2968 (_("%B: probably compiled without -fPIC?"),
2969 input_bfd);
2970 bfd_set_error (bfd_error_bad_value);
2971 return FALSE;
2972 }
2973 }
2974
2975 outrel.r_info = SPARC_ELF_R_INFO (htab, rel, indx,
2976 r_type);
2977 }
2978 }
2979
2980 sparc_elf_append_rela (output_bfd, sreloc, &outrel);
2981
2982 /* This reloc will be computed at runtime, so there's no
2983 need to do anything now. */
2984 if (! relocate)
2985 continue;
2986 }
2987 break;
2988
2989 case R_SPARC_TLS_GD_HI22:
2990 if (! ABI_64_P (input_bfd)
2991 && ! _bfd_sparc_elf_tdata (input_bfd)->has_tlsgd)
2992 {
2993 /* R_SPARC_REV32 used the same reloc number as
2994 R_SPARC_TLS_GD_HI22. */
2995 r_type = R_SPARC_REV32;
2996 break;
2997 }
2998 /* Fall through */
2999
3000 case R_SPARC_TLS_GD_LO10:
3001 case R_SPARC_TLS_IE_HI22:
3002 case R_SPARC_TLS_IE_LO10:
3003 r_type = sparc_elf_tls_transition (info, input_bfd, r_type, h == NULL);
3004 tls_type = GOT_UNKNOWN;
3005 if (h == NULL && local_got_offsets)
3006 tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3007 else if (h != NULL)
3008 {
3009 tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3010 if (!info->shared && h->dynindx == -1 && tls_type == GOT_TLS_IE)
3011 switch (SPARC_ELF_R_TYPE (rel->r_info))
3012 {
3013 case R_SPARC_TLS_GD_HI22:
3014 case R_SPARC_TLS_IE_HI22:
3015 r_type = R_SPARC_TLS_LE_HIX22;
3016 break;
3017 default:
3018 r_type = R_SPARC_TLS_LE_LOX10;
3019 break;
3020 }
3021 }
3022 if (tls_type == GOT_TLS_IE)
3023 switch (r_type)
3024 {
3025 case R_SPARC_TLS_GD_HI22:
3026 r_type = R_SPARC_TLS_IE_HI22;
3027 break;
3028 case R_SPARC_TLS_GD_LO10:
3029 r_type = R_SPARC_TLS_IE_LO10;
3030 break;
3031 }
3032
3033 if (r_type == R_SPARC_TLS_LE_HIX22)
3034 {
3035 relocation = tpoff (info, relocation);
3036 break;
3037 }
3038 if (r_type == R_SPARC_TLS_LE_LOX10)
3039 {
3040 /* Change add into xor. */
3041 relocation = tpoff (info, relocation);
3042 bfd_put_32 (output_bfd, (bfd_get_32 (input_bfd,
3043 contents + rel->r_offset)
3044 | 0x80182000), contents + rel->r_offset);
3045 break;
3046 }
3047
3048 if (h != NULL)
3049 {
3050 off = h->got.offset;
3051 h->got.offset |= 1;
3052 }
3053 else
3054 {
3055 BFD_ASSERT (local_got_offsets != NULL);
3056 off = local_got_offsets[r_symndx];
3057 local_got_offsets[r_symndx] |= 1;
3058 }
3059
3060 r_sparc_tlsldm:
3061 if (htab->sgot == NULL)
3062 abort ();
3063
3064 if ((off & 1) != 0)
3065 off &= ~1;
3066 else
3067 {
3068 Elf_Internal_Rela outrel;
3069 int dr_type, indx;
3070
3071 if (htab->srelgot == NULL)
3072 abort ();
3073
3074 SPARC_ELF_PUT_WORD (htab, output_bfd, 0, htab->sgot->contents + off);
3075 outrel.r_offset = (htab->sgot->output_section->vma
3076 + htab->sgot->output_offset + off);
3077 indx = h && h->dynindx != -1 ? h->dynindx : 0;
3078 if (r_type == R_SPARC_TLS_IE_HI22
3079 || r_type == R_SPARC_TLS_IE_LO10)
3080 dr_type = SPARC_ELF_TPOFF_RELOC (htab);
3081 else
3082 dr_type = SPARC_ELF_DTPMOD_RELOC (htab);
3083 if (dr_type == SPARC_ELF_TPOFF_RELOC (htab) && indx == 0)
3084 outrel.r_addend = relocation - dtpoff_base (info);
3085 else
3086 outrel.r_addend = 0;
3087 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx, dr_type);
3088 sparc_elf_append_rela (output_bfd, htab->srelgot, &outrel);
3089
3090 if (r_type == R_SPARC_TLS_GD_HI22
3091 || r_type == R_SPARC_TLS_GD_LO10)
3092 {
3093 if (indx == 0)
3094 {
3095 BFD_ASSERT (! unresolved_reloc);
3096 SPARC_ELF_PUT_WORD (htab, output_bfd,
3097 relocation - dtpoff_base (info),
3098 (htab->sgot->contents + off
3099 + SPARC_ELF_WORD_BYTES (htab)));
3100 }
3101 else
3102 {
3103 SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3104 (htab->sgot->contents + off
3105 + SPARC_ELF_WORD_BYTES (htab)));
3106 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx,
3107 SPARC_ELF_DTPOFF_RELOC (htab));
3108 outrel.r_offset += SPARC_ELF_WORD_BYTES (htab);
3109 sparc_elf_append_rela (output_bfd, htab->srelgot,
3110 &outrel);
3111 }
3112 }
3113 else if (dr_type == SPARC_ELF_DTPMOD_RELOC (htab))
3114 {
3115 SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3116 (htab->sgot->contents + off
3117 + SPARC_ELF_WORD_BYTES (htab)));
3118 }
3119 }
3120
3121 if (off >= (bfd_vma) -2)
3122 abort ();
3123
3124 relocation = htab->sgot->output_offset + off - got_base;
3125 unresolved_reloc = FALSE;
3126 howto = _bfd_sparc_elf_howto_table + r_type;
3127 break;
3128
3129 case R_SPARC_TLS_LDM_HI22:
3130 case R_SPARC_TLS_LDM_LO10:
3131 if (! info->shared)
3132 {
3133 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3134 continue;
3135 }
3136 off = htab->tls_ldm_got.offset;
3137 htab->tls_ldm_got.offset |= 1;
3138 goto r_sparc_tlsldm;
3139
3140 case R_SPARC_TLS_LDO_HIX22:
3141 case R_SPARC_TLS_LDO_LOX10:
3142 if (info->shared)
3143 {
3144 relocation -= dtpoff_base (info);
3145 break;
3146 }
3147
3148 r_type = (r_type == R_SPARC_TLS_LDO_HIX22
3149 ? R_SPARC_TLS_LE_HIX22 : R_SPARC_TLS_LE_LOX10);
3150 /* Fall through. */
3151
3152 case R_SPARC_TLS_LE_HIX22:
3153 case R_SPARC_TLS_LE_LOX10:
3154 if (info->shared)
3155 {
3156 Elf_Internal_Rela outrel;
3157 bfd_boolean skip, relocate = FALSE;
3158
3159 BFD_ASSERT (sreloc != NULL);
3160 skip = FALSE;
3161 outrel.r_offset =
3162 _bfd_elf_section_offset (output_bfd, info, input_section,
3163 rel->r_offset);
3164 if (outrel.r_offset == (bfd_vma) -1)
3165 skip = TRUE;
3166 else if (outrel.r_offset == (bfd_vma) -2)
3167 skip = TRUE, relocate = TRUE;
3168 outrel.r_offset += (input_section->output_section->vma
3169 + input_section->output_offset);
3170 if (skip)
3171 memset (&outrel, 0, sizeof outrel);
3172 else
3173 {
3174 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, r_type);
3175 outrel.r_addend = relocation - dtpoff_base (info)
3176 + rel->r_addend;
3177 }
3178
3179 sparc_elf_append_rela (output_bfd, sreloc, &outrel);
3180 continue;
3181 }
3182 relocation = tpoff (info, relocation);
3183 break;
3184
3185 case R_SPARC_TLS_LDM_CALL:
3186 if (! info->shared)
3187 {
3188 /* mov %g0, %o0 */
3189 bfd_put_32 (output_bfd, 0x90100000, contents + rel->r_offset);
3190 continue;
3191 }
3192 /* Fall through */
3193
3194 case R_SPARC_TLS_GD_CALL:
3195 tls_type = GOT_UNKNOWN;
3196 if (h == NULL && local_got_offsets)
3197 tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3198 else if (h != NULL)
3199 tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3200 if (! info->shared
3201 || (r_type == R_SPARC_TLS_GD_CALL && tls_type == GOT_TLS_IE))
3202 {
3203 bfd_vma insn;
3204
3205 if (!info->shared && (h == NULL || h->dynindx == -1))
3206 {
3207 /* GD -> LE */
3208 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3209 continue;
3210 }
3211
3212 /* GD -> IE */
3213 if (rel + 1 < relend
3214 && SPARC_ELF_R_TYPE (rel[1].r_info) == R_SPARC_TLS_GD_ADD
3215 && rel[1].r_offset == rel->r_offset + 4
3216 && SPARC_ELF_R_SYMNDX (htab, rel[1].r_info) == r_symndx
3217 && (((insn = bfd_get_32 (input_bfd,
3218 contents + rel[1].r_offset))
3219 >> 25) & 0x1f) == 8)
3220 {
3221 /* We have
3222 call __tls_get_addr, %tgd_call(foo)
3223 add %reg1, %reg2, %o0, %tgd_add(foo)
3224 and change it into IE:
3225 {ld,ldx} [%reg1 + %reg2], %o0, %tie_ldx(foo)
3226 add %g7, %o0, %o0, %tie_add(foo).
3227 add is 0x80000000 | (rd << 25) | (rs1 << 14) | rs2,
3228 ld is 0xc0000000 | (rd << 25) | (rs1 << 14) | rs2,
3229 ldx is 0xc0580000 | (rd << 25) | (rs1 << 14) | rs2. */
3230 bfd_put_32 (output_bfd, insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000),
3231 contents + rel->r_offset);
3232 bfd_put_32 (output_bfd, 0x9001c008,
3233 contents + rel->r_offset + 4);
3234 rel++;
3235 continue;
3236 }
3237
3238 bfd_put_32 (output_bfd, 0x9001c008, contents + rel->r_offset);
3239 continue;
3240 }
3241
3242 h = (struct elf_link_hash_entry *)
3243 bfd_link_hash_lookup (info->hash, "__tls_get_addr", FALSE,
3244 FALSE, TRUE);
3245 BFD_ASSERT (h != NULL);
3246 r_type = R_SPARC_WPLT30;
3247 howto = _bfd_sparc_elf_howto_table + r_type;
3248 goto r_sparc_wplt30;
3249
3250 case R_SPARC_TLS_GD_ADD:
3251 tls_type = GOT_UNKNOWN;
3252 if (h == NULL && local_got_offsets)
3253 tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3254 else if (h != NULL)
3255 tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3256 if (! info->shared || tls_type == GOT_TLS_IE)
3257 {
3258 /* add %reg1, %reg2, %reg3, %tgd_add(foo)
3259 changed into IE:
3260 {ld,ldx} [%reg1 + %reg2], %reg3, %tie_ldx(foo)
3261 or LE:
3262 add %g7, %reg2, %reg3. */
3263 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3264 if ((h != NULL && h->dynindx != -1) || info->shared)
3265 relocation = insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000);
3266 else
3267 relocation = (insn & ~0x7c000) | 0x1c000;
3268 bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3269 }
3270 continue;
3271
3272 case R_SPARC_TLS_LDM_ADD:
3273 if (! info->shared)
3274 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3275 continue;
3276
3277 case R_SPARC_TLS_LDO_ADD:
3278 if (! info->shared)
3279 {
3280 /* Change rs1 into %g7. */
3281 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3282 insn = (insn & ~0x7c000) | 0x1c000;
3283 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3284 }
3285 continue;
3286
3287 case R_SPARC_GOTDATA_OP:
3288 /* We don't support gotdata code transformation optimizations
3289 yet, so simply leave the sequence as-is. */
3290 continue;
3291
3292 case R_SPARC_TLS_IE_LD:
3293 case R_SPARC_TLS_IE_LDX:
3294 if (! info->shared && (h == NULL || h->dynindx == -1))
3295 {
3296 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3297 int rs2 = insn & 0x1f;
3298 int rd = (insn >> 25) & 0x1f;
3299
3300 if (rs2 == rd)
3301 relocation = SPARC_NOP;
3302 else
3303 relocation = 0x80100000 | (insn & 0x3e00001f);
3304 bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3305 }
3306 continue;
3307
3308 case R_SPARC_TLS_IE_ADD:
3309 /* Totally useless relocation. */
3310 continue;
3311
3312 case R_SPARC_TLS_DTPOFF32:
3313 case R_SPARC_TLS_DTPOFF64:
3314 relocation -= dtpoff_base (info);
3315 break;
3316
3317 default:
3318 break;
3319 }
3320
3321 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3322 because such sections are not SEC_ALLOC and thus ld.so will
3323 not process them. */
3324 if (unresolved_reloc
3325 && !((input_section->flags & SEC_DEBUGGING) != 0
3326 && h->def_dynamic))
3327 (*_bfd_error_handler)
3328 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3329 input_bfd,
3330 input_section,
3331 (long) rel->r_offset,
3332 howto->name,
3333 h->root.root.string);
3334
3335 r = bfd_reloc_continue;
3336 if (r_type == R_SPARC_OLO10)
3337 {
3338 bfd_vma x;
3339
3340 if (! ABI_64_P (output_bfd))
3341 abort ();
3342
3343 relocation += rel->r_addend;
3344 relocation = (relocation & 0x3ff) + ELF64_R_TYPE_DATA (rel->r_info);
3345
3346 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3347 x = (x & ~(bfd_vma) 0x1fff) | (relocation & 0x1fff);
3348 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3349
3350 r = bfd_check_overflow (howto->complain_on_overflow,
3351 howto->bitsize, howto->rightshift,
3352 bfd_arch_bits_per_address (input_bfd),
3353 relocation);
3354 }
3355 else if (r_type == R_SPARC_WDISP16)
3356 {
3357 bfd_vma x;
3358
3359 relocation += rel->r_addend;
3360 relocation -= (input_section->output_section->vma
3361 + input_section->output_offset);
3362 relocation -= rel->r_offset;
3363
3364 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3365 x |= ((((relocation >> 2) & 0xc000) << 6)
3366 | ((relocation >> 2) & 0x3fff));
3367 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3368
3369 r = bfd_check_overflow (howto->complain_on_overflow,
3370 howto->bitsize, howto->rightshift,
3371 bfd_arch_bits_per_address (input_bfd),
3372 relocation);
3373 }
3374 else if (r_type == R_SPARC_REV32)
3375 {
3376 bfd_vma x;
3377
3378 relocation = relocation + rel->r_addend;
3379
3380 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3381 x = x + relocation;
3382 bfd_putl32 (/*input_bfd,*/ x, contents + rel->r_offset);
3383 r = bfd_reloc_ok;
3384 }
3385 else if (r_type == R_SPARC_TLS_LDO_HIX22
3386 || r_type == R_SPARC_TLS_LE_HIX22)
3387 {
3388 bfd_vma x;
3389
3390 relocation += rel->r_addend;
3391 if (r_type == R_SPARC_TLS_LE_HIX22)
3392 relocation ^= MINUS_ONE;
3393
3394 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3395 x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
3396 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3397 r = bfd_reloc_ok;
3398 }
3399 else if (r_type == R_SPARC_TLS_LDO_LOX10
3400 || r_type == R_SPARC_TLS_LE_LOX10)
3401 {
3402 bfd_vma x;
3403
3404 relocation += rel->r_addend;
3405 relocation &= 0x3ff;
3406 if (r_type == R_SPARC_TLS_LE_LOX10)
3407 relocation |= 0x1c00;
3408
3409 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3410 x = (x & ~(bfd_vma) 0x1fff) | relocation;
3411 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3412
3413 r = bfd_reloc_ok;
3414 }
3415 else if (r_type == R_SPARC_HIX22)
3416 {
3417 bfd_vma x;
3418
3419 relocation += rel->r_addend;
3420 relocation = relocation ^ MINUS_ONE;
3421
3422 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3423 x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
3424 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3425
3426 r = bfd_check_overflow (howto->complain_on_overflow,
3427 howto->bitsize, howto->rightshift,
3428 bfd_arch_bits_per_address (input_bfd),
3429 relocation);
3430 }
3431 else if (r_type == R_SPARC_LOX10)
3432 {
3433 bfd_vma x;
3434
3435 relocation += rel->r_addend;
3436 relocation = (relocation & 0x3ff) | 0x1c00;
3437
3438 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3439 x = (x & ~(bfd_vma) 0x1fff) | relocation;
3440 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3441
3442 r = bfd_reloc_ok;
3443 }
3444 else if ((r_type == R_SPARC_WDISP30 || r_type == R_SPARC_WPLT30)
3445 && sec_do_relax (input_section)
3446 && rel->r_offset + 4 < input_section->size)
3447 {
3448 #define G0 0
3449 #define O7 15
3450 #define XCC (2 << 20)
3451 #define COND(x) (((x)&0xf)<<25)
3452 #define CONDA COND(0x8)
3453 #define INSN_BPA (F2(0,1) | CONDA | BPRED | XCC)
3454 #define INSN_BA (F2(0,2) | CONDA)
3455 #define INSN_OR F3(2, 0x2, 0)
3456 #define INSN_NOP F2(0,4)
3457
3458 bfd_vma x, y;
3459
3460 /* If the instruction is a call with either:
3461 restore
3462 arithmetic instruction with rd == %o7
3463 where rs1 != %o7 and rs2 if it is register != %o7
3464 then we can optimize if the call destination is near
3465 by changing the call into a branch always. */
3466 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3467 y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
3468 if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2))
3469 {
3470 if (((y & OP3(~0)) == OP3(0x3d) /* restore */
3471 || ((y & OP3(0x28)) == 0 /* arithmetic */
3472 && (y & RD(~0)) == RD(O7)))
3473 && (y & RS1(~0)) != RS1(O7)
3474 && ((y & F3I(~0))
3475 || (y & RS2(~0)) != RS2(O7)))
3476 {
3477 bfd_vma reloc;
3478
3479 reloc = relocation + rel->r_addend - rel->r_offset;
3480 reloc -= (input_section->output_section->vma
3481 + input_section->output_offset);
3482
3483 /* Ensure the branch fits into simm22. */
3484 if ((reloc & 3) == 0
3485 && ((reloc & ~(bfd_vma)0x7fffff) == 0
3486 || ((reloc | 0x7fffff) == ~(bfd_vma)0)))
3487 {
3488 reloc >>= 2;
3489
3490 /* Check whether it fits into simm19. */
3491 if (((reloc & 0x3c0000) == 0
3492 || (reloc & 0x3c0000) == 0x3c0000)
3493 && (ABI_64_P (output_bfd)
3494 || elf_elfheader (output_bfd)->e_flags & EF_SPARC_32PLUS))
3495 x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */
3496 else
3497 x = INSN_BA | (reloc & 0x3fffff); /* ba */
3498 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3499 r = bfd_reloc_ok;
3500 if (rel->r_offset >= 4
3501 && (y & (0xffffffff ^ RS1(~0)))
3502 == (INSN_OR | RD(O7) | RS2(G0)))
3503 {
3504 bfd_vma z;
3505 unsigned int reg;
3506
3507 z = bfd_get_32 (input_bfd,
3508 contents + rel->r_offset - 4);
3509 if ((z & (0xffffffff ^ RD(~0)))
3510 != (INSN_OR | RS1(O7) | RS2(G0)))
3511 break;
3512
3513 /* The sequence was
3514 or %o7, %g0, %rN
3515 call foo
3516 or %rN, %g0, %o7
3517
3518 If call foo was replaced with ba, replace
3519 or %rN, %g0, %o7 with nop. */
3520
3521 reg = (y & RS1(~0)) >> 14;
3522 if (reg != ((z & RD(~0)) >> 25)
3523 || reg == G0 || reg == O7)
3524 break;
3525
3526 bfd_put_32 (input_bfd, (bfd_vma) INSN_NOP,
3527 contents + rel->r_offset + 4);
3528 }
3529
3530 }
3531 }
3532 }
3533 }
3534
3535 if (r == bfd_reloc_continue)
3536 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3537 contents, rel->r_offset,
3538 relocation, rel->r_addend);
3539
3540 if (r != bfd_reloc_ok)
3541 {
3542 switch (r)
3543 {
3544 default:
3545 case bfd_reloc_outofrange:
3546 abort ();
3547 case bfd_reloc_overflow:
3548 {
3549 const char *name;
3550
3551 /* The Solaris native linker silently disregards overflows.
3552 We don't, but this breaks stabs debugging info, whose
3553 relocations are only 32-bits wide. Ignore overflows in
3554 this case and also for discarded entries. */
3555 if ((r_type == R_SPARC_32 || r_type == R_SPARC_DISP32)
3556 && (((input_section->flags & SEC_DEBUGGING) != 0
3557 && strcmp (bfd_section_name (input_bfd,
3558 input_section),
3559 ".stab") == 0)
3560 || _bfd_elf_section_offset (output_bfd, info,
3561 input_section,
3562 rel->r_offset)
3563 == (bfd_vma)-1))
3564 break;
3565
3566 if (h != NULL)
3567 {
3568 /* Assume this is a call protected by other code that
3569 detect the symbol is undefined. If this is the case,
3570 we can safely ignore the overflow. If not, the
3571 program is hosed anyway, and a little warning isn't
3572 going to help. */
3573 if (h->root.type == bfd_link_hash_undefweak
3574 && howto->pc_relative)
3575 break;
3576
3577 name = NULL;
3578 }
3579 else
3580 {
3581 name = bfd_elf_string_from_elf_section (input_bfd,
3582 symtab_hdr->sh_link,
3583 sym->st_name);
3584 if (name == NULL)
3585 return FALSE;
3586 if (*name == '\0')
3587 name = bfd_section_name (input_bfd, sec);
3588 }
3589 if (! ((*info->callbacks->reloc_overflow)
3590 (info, (h ? &h->root : NULL), name, howto->name,
3591 (bfd_vma) 0, input_bfd, input_section,
3592 rel->r_offset)))
3593 return FALSE;
3594 }
3595 break;
3596 }
3597 }
3598 }
3599
3600 return TRUE;
3601 }
3602
3603 /* Build a VxWorks PLT entry. PLT_INDEX is the index of the PLT entry
3604 and PLT_OFFSET is the byte offset from the start of .plt. GOT_OFFSET
3605 is the offset of the associated .got.plt entry from
3606 _GLOBAL_OFFSET_TABLE_. */
3607
3608 static void
3609 sparc_vxworks_build_plt_entry (bfd *output_bfd, struct bfd_link_info *info,
3610 bfd_vma plt_offset, bfd_vma plt_index,
3611 bfd_vma got_offset)
3612 {
3613 bfd_vma got_base;
3614 const bfd_vma *plt_entry;
3615 struct _bfd_sparc_elf_link_hash_table *htab;
3616 bfd_byte *loc;
3617 Elf_Internal_Rela rela;
3618
3619 htab = _bfd_sparc_elf_hash_table (info);
3620 BFD_ASSERT (htab != NULL);
3621
3622 if (info->shared)
3623 {
3624 plt_entry = sparc_vxworks_shared_plt_entry;
3625 got_base = 0;
3626 }
3627 else
3628 {
3629 plt_entry = sparc_vxworks_exec_plt_entry;
3630 got_base = (htab->elf.hgot->root.u.def.value
3631 + htab->elf.hgot->root.u.def.section->output_offset
3632 + htab->elf.hgot->root.u.def.section->output_section->vma);
3633 }
3634
3635 /* Fill in the entry in the procedure linkage table. */
3636 bfd_put_32 (output_bfd, plt_entry[0] + ((got_base + got_offset) >> 10),
3637 htab->splt->contents + plt_offset);
3638 bfd_put_32 (output_bfd, plt_entry[1] + ((got_base + got_offset) & 0x3ff),
3639 htab->splt->contents + plt_offset + 4);
3640 bfd_put_32 (output_bfd, plt_entry[2],
3641 htab->splt->contents + plt_offset + 8);
3642 bfd_put_32 (output_bfd, plt_entry[3],
3643 htab->splt->contents + plt_offset + 12);
3644 bfd_put_32 (output_bfd, plt_entry[4],
3645 htab->splt->contents + plt_offset + 16);
3646 bfd_put_32 (output_bfd, plt_entry[5] + (plt_index >> 10),
3647 htab->splt->contents + plt_offset + 20);
3648 /* PC-relative displacement for a branch to the start of
3649 the PLT section. */
3650 bfd_put_32 (output_bfd, plt_entry[6] + (((-plt_offset - 24) >> 2)
3651 & 0x003fffff),
3652 htab->splt->contents + plt_offset + 24);
3653 bfd_put_32 (output_bfd, plt_entry[7] + (plt_index & 0x3ff),
3654 htab->splt->contents + plt_offset + 28);
3655
3656 /* Fill in the .got.plt entry, pointing initially at the
3657 second half of the PLT entry. */
3658 BFD_ASSERT (htab->sgotplt != NULL);
3659 bfd_put_32 (output_bfd,
3660 htab->splt->output_section->vma
3661 + htab->splt->output_offset
3662 + plt_offset + 20,
3663 htab->sgotplt->contents + got_offset);
3664
3665 /* Add relocations to .rela.plt.unloaded. */
3666 if (!info->shared)
3667 {
3668 loc = (htab->srelplt2->contents
3669 + (2 + 3 * plt_index) * sizeof (Elf32_External_Rela));
3670
3671 /* Relocate the initial sethi. */
3672 rela.r_offset = (htab->splt->output_section->vma
3673 + htab->splt->output_offset
3674 + plt_offset);
3675 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
3676 rela.r_addend = got_offset;
3677 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3678 loc += sizeof (Elf32_External_Rela);
3679
3680 /* Likewise the following or. */
3681 rela.r_offset += 4;
3682 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
3683 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3684 loc += sizeof (Elf32_External_Rela);
3685
3686 /* Relocate the .got.plt entry. */
3687 rela.r_offset = (htab->sgotplt->output_section->vma
3688 + htab->sgotplt->output_offset
3689 + got_offset);
3690 rela.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_SPARC_32);
3691 rela.r_addend = plt_offset + 20;
3692 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3693 }
3694 }
3695
3696 /* Finish up dynamic symbol handling. We set the contents of various
3697 dynamic sections here. */
3698
3699 bfd_boolean
3700 _bfd_sparc_elf_finish_dynamic_symbol (bfd *output_bfd,
3701 struct bfd_link_info *info,
3702 struct elf_link_hash_entry *h,
3703 Elf_Internal_Sym *sym)
3704 {
3705 bfd *dynobj;
3706 struct _bfd_sparc_elf_link_hash_table *htab;
3707 const struct elf_backend_data *bed;
3708
3709 htab = _bfd_sparc_elf_hash_table (info);
3710 BFD_ASSERT (htab != NULL);
3711 dynobj = htab->elf.dynobj;
3712 bed = get_elf_backend_data (output_bfd);
3713
3714 if (h->plt.offset != (bfd_vma) -1)
3715 {
3716 asection *splt;
3717 asection *srela;
3718 Elf_Internal_Rela rela;
3719 bfd_byte *loc;
3720 bfd_vma r_offset, got_offset;
3721 int rela_index;
3722
3723 /* This symbol has an entry in the PLT. Set it up. */
3724
3725 BFD_ASSERT (h->dynindx != -1);
3726
3727 splt = htab->splt;
3728 srela = htab->srelplt;
3729 BFD_ASSERT (splt != NULL && srela != NULL);
3730
3731 /* Fill in the entry in the .rela.plt section. */
3732 if (htab->is_vxworks)
3733 {
3734 /* Work out the index of this PLT entry. */
3735 rela_index = ((h->plt.offset - htab->plt_header_size)
3736 / htab->plt_entry_size);
3737
3738 /* Calculate the offset of the associated .got.plt entry.
3739 The first three entries are reserved. */
3740 got_offset = (rela_index + 3) * 4;
3741
3742 sparc_vxworks_build_plt_entry (output_bfd, info, h->plt.offset,
3743 rela_index, got_offset);
3744
3745
3746 /* On VxWorks, the relocation points to the .got.plt entry,
3747 not the .plt entry. */
3748 rela.r_offset = (htab->sgotplt->output_section->vma
3749 + htab->sgotplt->output_offset
3750 + got_offset);
3751 rela.r_addend = 0;
3752 }
3753 else
3754 {
3755 /* Fill in the entry in the procedure linkage table. */
3756 rela_index = SPARC_ELF_BUILD_PLT_ENTRY (htab, output_bfd, splt,
3757 h->plt.offset, splt->size,
3758 &r_offset);
3759
3760 rela.r_offset = r_offset
3761 + (splt->output_section->vma + splt->output_offset);
3762 if (! ABI_64_P (output_bfd)
3763 || h->plt.offset < (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE))
3764 {
3765 rela.r_addend = 0;
3766 }
3767 else
3768 {
3769 rela.r_addend = (-(h->plt.offset + 4)
3770 - splt->output_section->vma
3771 - splt->output_offset);
3772 }
3773 }
3774 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_JMP_SLOT);
3775
3776 /* Adjust for the first 4 reserved elements in the .plt section
3777 when setting the offset in the .rela.plt section.
3778 Sun forgot to read their own ABI and copied elf32-sparc behaviour,
3779 thus .plt[4] has corresponding .rela.plt[0] and so on. */
3780
3781 loc = srela->contents;
3782 loc += rela_index * bed->s->sizeof_rela;
3783 bed->s->swap_reloca_out (output_bfd, &rela, loc);
3784
3785 if (!h->def_regular)
3786 {
3787 /* Mark the symbol as undefined, rather than as defined in
3788 the .plt section. Leave the value alone. */
3789 sym->st_shndx = SHN_UNDEF;
3790 /* If the symbol is weak, we do need to clear the value.
3791 Otherwise, the PLT entry would provide a definition for
3792 the symbol even if the symbol wasn't defined anywhere,
3793 and so the symbol would never be NULL. */
3794 if (!h->ref_regular_nonweak)
3795 sym->st_value = 0;
3796 }
3797 }
3798
3799 if (h->got.offset != (bfd_vma) -1
3800 && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_GD
3801 && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_IE)
3802 {
3803 asection *sgot;
3804 asection *srela;
3805 Elf_Internal_Rela rela;
3806
3807 /* This symbol has an entry in the GOT. Set it up. */
3808
3809 sgot = htab->sgot;
3810 srela = htab->srelgot;
3811 BFD_ASSERT (sgot != NULL && srela != NULL);
3812
3813 rela.r_offset = (sgot->output_section->vma
3814 + sgot->output_offset
3815 + (h->got.offset &~ (bfd_vma) 1));
3816
3817 /* If this is a -Bsymbolic link, and the symbol is defined
3818 locally, we just want to emit a RELATIVE reloc. Likewise if
3819 the symbol was forced to be local because of a version file.
3820 The entry in the global offset table will already have been
3821 initialized in the relocate_section function. */
3822 if (info->shared
3823 && (info->symbolic || h->dynindx == -1)
3824 && h->def_regular)
3825 {
3826 asection *sec = h->root.u.def.section;
3827 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, R_SPARC_RELATIVE);
3828 rela.r_addend = (h->root.u.def.value
3829 + sec->output_section->vma
3830 + sec->output_offset);
3831 }
3832 else
3833 {
3834 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_GLOB_DAT);
3835 rela.r_addend = 0;
3836 }
3837
3838 SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3839 sgot->contents + (h->got.offset & ~(bfd_vma) 1));
3840 sparc_elf_append_rela (output_bfd, srela, &rela);
3841 }
3842
3843 if (h->needs_copy)
3844 {
3845 asection *s;
3846 Elf_Internal_Rela rela;
3847
3848 /* This symbols needs a copy reloc. Set it up. */
3849 BFD_ASSERT (h->dynindx != -1);
3850
3851 s = bfd_get_section_by_name (h->root.u.def.section->owner,
3852 ".rela.bss");
3853 BFD_ASSERT (s != NULL);
3854
3855 rela.r_offset = (h->root.u.def.value
3856 + h->root.u.def.section->output_section->vma
3857 + h->root.u.def.section->output_offset);
3858 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_COPY);
3859 rela.r_addend = 0;
3860 sparc_elf_append_rela (output_bfd, s, &rela);
3861 }
3862
3863 /* Mark some specially defined symbols as absolute. On VxWorks,
3864 _GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the
3865 ".got" section. Likewise _PROCEDURE_LINKAGE_TABLE_ and ".plt". */
3866 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3867 || (!htab->is_vxworks
3868 && (h == htab->elf.hgot || h == htab->elf.hplt)))
3869 sym->st_shndx = SHN_ABS;
3870
3871 return TRUE;
3872 }
3873
3874 /* Finish up the dynamic sections. */
3875
3876 static bfd_boolean
3877 sparc_finish_dyn (bfd *output_bfd, struct bfd_link_info *info,
3878 bfd *dynobj, asection *sdyn,
3879 asection *splt ATTRIBUTE_UNUSED)
3880 {
3881 struct _bfd_sparc_elf_link_hash_table *htab;
3882 const struct elf_backend_data *bed;
3883 bfd_byte *dyncon, *dynconend;
3884 size_t dynsize;
3885 int stt_regidx = -1;
3886 bfd_boolean abi_64_p;
3887
3888 htab = _bfd_sparc_elf_hash_table (info);
3889 BFD_ASSERT (htab != NULL);
3890 bed = get_elf_backend_data (output_bfd);
3891 dynsize = bed->s->sizeof_dyn;
3892 dynconend = sdyn->contents + sdyn->size;
3893 abi_64_p = ABI_64_P (output_bfd);
3894 for (dyncon = sdyn->contents; dyncon < dynconend; dyncon += dynsize)
3895 {
3896 Elf_Internal_Dyn dyn;
3897 const char *name;
3898 bfd_boolean size;
3899
3900 bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
3901
3902 if (htab->is_vxworks && dyn.d_tag == DT_RELASZ)
3903 {
3904 /* On VxWorks, DT_RELASZ should not include the relocations
3905 in .rela.plt. */
3906 if (htab->srelplt)
3907 {
3908 dyn.d_un.d_val -= htab->srelplt->size;
3909 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
3910 }
3911 }
3912 else if (htab->is_vxworks && dyn.d_tag == DT_PLTGOT)
3913 {
3914 /* On VxWorks, DT_PLTGOT should point to the start of the GOT,
3915 not to the start of the PLT. */
3916 if (htab->sgotplt)
3917 {
3918 dyn.d_un.d_val = (htab->sgotplt->output_section->vma
3919 + htab->sgotplt->output_offset);
3920 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
3921 }
3922 }
3923 else if (htab->is_vxworks
3924 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
3925 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
3926 else if (abi_64_p && dyn.d_tag == DT_SPARC_REGISTER)
3927 {
3928 if (stt_regidx == -1)
3929 {
3930 stt_regidx =
3931 _bfd_elf_link_lookup_local_dynindx (info, output_bfd, -1);
3932 if (stt_regidx == -1)
3933 return FALSE;
3934 }
3935 dyn.d_un.d_val = stt_regidx++;
3936 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
3937 }
3938 else
3939 {
3940 switch (dyn.d_tag)
3941 {
3942 case DT_PLTGOT: name = ".plt"; size = FALSE; break;
3943 case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break;
3944 case DT_JMPREL: name = ".rela.plt"; size = FALSE; break;
3945 default: name = NULL; size = FALSE; break;
3946 }
3947
3948 if (name != NULL)
3949 {
3950 asection *s;
3951
3952 s = bfd_get_section_by_name (output_bfd, name);
3953 if (s == NULL)
3954 dyn.d_un.d_val = 0;
3955 else
3956 {
3957 if (! size)
3958 dyn.d_un.d_ptr = s->vma;
3959 else
3960 dyn.d_un.d_val = s->size;
3961 }
3962 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
3963 }
3964 }
3965 }
3966 return TRUE;
3967 }
3968
3969 /* Install the first PLT entry in a VxWorks executable and make sure that
3970 .rela.plt.unloaded relocations have the correct symbol indexes. */
3971
3972 static void
3973 sparc_vxworks_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info)
3974 {
3975 struct _bfd_sparc_elf_link_hash_table *htab;
3976 Elf_Internal_Rela rela;
3977 bfd_vma got_base;
3978 bfd_byte *loc;
3979
3980 htab = _bfd_sparc_elf_hash_table (info);
3981 BFD_ASSERT (htab != NULL);
3982
3983 /* Calculate the absolute value of _GLOBAL_OFFSET_TABLE_. */
3984 got_base = (htab->elf.hgot->root.u.def.section->output_section->vma
3985 + htab->elf.hgot->root.u.def.section->output_offset
3986 + htab->elf.hgot->root.u.def.value);
3987
3988 /* Install the initial PLT entry. */
3989 bfd_put_32 (output_bfd,
3990 sparc_vxworks_exec_plt0_entry[0] + ((got_base + 8) >> 10),
3991 htab->splt->contents);
3992 bfd_put_32 (output_bfd,
3993 sparc_vxworks_exec_plt0_entry[1] + ((got_base + 8) & 0x3ff),
3994 htab->splt->contents + 4);
3995 bfd_put_32 (output_bfd,
3996 sparc_vxworks_exec_plt0_entry[2],
3997 htab->splt->contents + 8);
3998 bfd_put_32 (output_bfd,
3999 sparc_vxworks_exec_plt0_entry[3],
4000 htab->splt->contents + 12);
4001 bfd_put_32 (output_bfd,
4002 sparc_vxworks_exec_plt0_entry[4],
4003 htab->splt->contents + 16);
4004
4005 loc = htab->srelplt2->contents;
4006
4007 /* Add an unloaded relocation for the initial entry's "sethi". */
4008 rela.r_offset = (htab->splt->output_section->vma
4009 + htab->splt->output_offset);
4010 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4011 rela.r_addend = 8;
4012 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4013 loc += sizeof (Elf32_External_Rela);
4014
4015 /* Likewise the following "or". */
4016 rela.r_offset += 4;
4017 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4018 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4019 loc += sizeof (Elf32_External_Rela);
4020
4021 /* Fix up the remaining .rela.plt.unloaded relocations. They may have
4022 the wrong symbol index for _G_O_T_ or _P_L_T_ depending on the order
4023 in which symbols were output. */
4024 while (loc < htab->srelplt2->contents + htab->srelplt2->size)
4025 {
4026 Elf_Internal_Rela rel;
4027
4028 /* The entry's initial "sethi" (against _G_O_T_). */
4029 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4030 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4031 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4032 loc += sizeof (Elf32_External_Rela);
4033
4034 /* The following "or" (also against _G_O_T_). */
4035 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4036 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4037 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4038 loc += sizeof (Elf32_External_Rela);
4039
4040 /* The .got.plt entry (against _P_L_T_). */
4041 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4042 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_SPARC_32);
4043 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4044 loc += sizeof (Elf32_External_Rela);
4045 }
4046 }
4047
4048 /* Install the first PLT entry in a VxWorks shared object. */
4049
4050 static void
4051 sparc_vxworks_finish_shared_plt (bfd *output_bfd, struct bfd_link_info *info)
4052 {
4053 struct _bfd_sparc_elf_link_hash_table *htab;
4054 unsigned int i;
4055
4056 htab = _bfd_sparc_elf_hash_table (info);
4057 BFD_ASSERT (htab != NULL);
4058
4059 for (i = 0; i < ARRAY_SIZE (sparc_vxworks_shared_plt0_entry); i++)
4060 bfd_put_32 (output_bfd, sparc_vxworks_shared_plt0_entry[i],
4061 htab->splt->contents + i * 4);
4062 }
4063
4064 bfd_boolean
4065 _bfd_sparc_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
4066 {
4067 bfd *dynobj;
4068 asection *sdyn;
4069 struct _bfd_sparc_elf_link_hash_table *htab;
4070
4071 htab = _bfd_sparc_elf_hash_table (info);
4072 BFD_ASSERT (htab != NULL);
4073 dynobj = htab->elf.dynobj;
4074
4075 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4076
4077 if (elf_hash_table (info)->dynamic_sections_created)
4078 {
4079 asection *splt;
4080
4081 splt = bfd_get_section_by_name (dynobj, ".plt");
4082 BFD_ASSERT (splt != NULL && sdyn != NULL);
4083
4084 if (!sparc_finish_dyn (output_bfd, info, dynobj, sdyn, splt))
4085 return FALSE;
4086
4087 /* Initialize the contents of the .plt section. */
4088 if (splt->size > 0)
4089 {
4090 if (htab->is_vxworks)
4091 {
4092 if (info->shared)
4093 sparc_vxworks_finish_shared_plt (output_bfd, info);
4094 else
4095 sparc_vxworks_finish_exec_plt (output_bfd, info);
4096 }
4097 else
4098 {
4099 memset (splt->contents, 0, htab->plt_header_size);
4100 if (!ABI_64_P (output_bfd))
4101 bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP,
4102 splt->contents + splt->size - 4);
4103 }
4104 }
4105
4106 elf_section_data (splt->output_section)->this_hdr.sh_entsize
4107 = (htab->is_vxworks || !ABI_64_P (output_bfd))
4108 ? 0 : htab->plt_entry_size;
4109 }
4110
4111 /* Set the first entry in the global offset table to the address of
4112 the dynamic section. */
4113 if (htab->sgot && htab->sgot->size > 0)
4114 {
4115 bfd_vma val = (sdyn ?
4116 sdyn->output_section->vma + sdyn->output_offset :
4117 0);
4118
4119 SPARC_ELF_PUT_WORD (htab, output_bfd, val, htab->sgot->contents);
4120 }
4121
4122 if (htab->sgot)
4123 elf_section_data (htab->sgot->output_section)->this_hdr.sh_entsize =
4124 SPARC_ELF_WORD_BYTES (htab);
4125
4126 return TRUE;
4127 }
4128
4129 \f
4130 /* Set the right machine number for a SPARC ELF file. */
4131
4132 bfd_boolean
4133 _bfd_sparc_elf_object_p (bfd *abfd)
4134 {
4135 if (ABI_64_P (abfd))
4136 {
4137 unsigned long mach = bfd_mach_sparc_v9;
4138
4139 if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
4140 mach = bfd_mach_sparc_v9b;
4141 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
4142 mach = bfd_mach_sparc_v9a;
4143 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, mach);
4144 }
4145 else
4146 {
4147 if (elf_elfheader (abfd)->e_machine == EM_SPARC32PLUS)
4148 {
4149 if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
4150 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4151 bfd_mach_sparc_v8plusb);
4152 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
4153 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4154 bfd_mach_sparc_v8plusa);
4155 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_32PLUS)
4156 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4157 bfd_mach_sparc_v8plus);
4158 else
4159 return FALSE;
4160 }
4161 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_LEDATA)
4162 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4163 bfd_mach_sparc_sparclite_le);
4164 else
4165 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc);
4166 }
4167 }
4168
4169 /* Return address for Ith PLT stub in section PLT, for relocation REL
4170 or (bfd_vma) -1 if it should not be included. */
4171
4172 bfd_vma
4173 _bfd_sparc_elf_plt_sym_val (bfd_vma i, const asection *plt, const arelent *rel)
4174 {
4175 if (ABI_64_P (plt->owner))
4176 {
4177 bfd_vma j;
4178
4179 i += PLT64_HEADER_SIZE / PLT64_ENTRY_SIZE;
4180 if (i < PLT64_LARGE_THRESHOLD)
4181 return plt->vma + i * PLT64_ENTRY_SIZE;
4182
4183 j = (i - PLT64_LARGE_THRESHOLD) % 160;
4184 i -= j;
4185 return plt->vma + i * PLT64_ENTRY_SIZE + j * 4 * 6;
4186 }
4187 else
4188 return rel->address;
4189 }
GDB Binutils - Deliverables
This page took 0.125366 seconds and 4 git commands to generate.