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