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