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