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