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