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