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