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