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