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