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