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