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