?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
merge from gcc
[binutils.git] / bfd / elfxx-sparc.c
blob63eed174aa26632e79bb9c7cda39294212f4c656
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 {
1536 struct _bfd_sparc_elf_link_hash_table *htab;
1537
1538 htab = _bfd_sparc_elf_hash_table (info);
1539 switch (SPARC_ELF_R_TYPE (rel->r_info))
1540 {
1541 case R_SPARC_GNU_VTINHERIT:
1542 case R_SPARC_GNU_VTENTRY:
1543 break;
1544
1545 default:
1546 switch (h->root.type)
1547 {
1548 case bfd_link_hash_defined:
1549 case bfd_link_hash_defweak:
1550 return h->root.u.def.section;
1551
1552 case bfd_link_hash_common:
1553 return h->root.u.c.p->section;
1554
1555 default:
1556 break;
1557 }
1558 }
1559 }
1560 else
1561 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
1562
1563 return NULL;
1564 }
1565
1566 /* Update the got entry reference counts for the section being removed. */
1567 bfd_boolean
1568 _bfd_sparc_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
1569 asection *sec, const Elf_Internal_Rela *relocs)
1570 {
1571 struct _bfd_sparc_elf_link_hash_table *htab;
1572 Elf_Internal_Shdr *symtab_hdr;
1573 struct elf_link_hash_entry **sym_hashes;
1574 bfd_signed_vma *local_got_refcounts;
1575 const Elf_Internal_Rela *rel, *relend;
1576
1577 elf_section_data (sec)->local_dynrel = NULL;
1578
1579 htab = _bfd_sparc_elf_hash_table (info);
1580 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1581 sym_hashes = elf_sym_hashes (abfd);
1582 local_got_refcounts = elf_local_got_refcounts (abfd);
1583
1584 relend = relocs + sec->reloc_count;
1585 for (rel = relocs; rel < relend; rel++)
1586 {
1587 unsigned long r_symndx;
1588 unsigned int r_type;
1589 struct elf_link_hash_entry *h = NULL;
1590
1591 r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
1592 if (r_symndx >= symtab_hdr->sh_info)
1593 {
1594 struct _bfd_sparc_elf_link_hash_entry *eh;
1595 struct _bfd_sparc_elf_dyn_relocs **pp;
1596 struct _bfd_sparc_elf_dyn_relocs *p;
1597
1598 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1599 while (h->root.type == bfd_link_hash_indirect
1600 || h->root.type == bfd_link_hash_warning)
1601 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1602 eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
1603 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1604 if (p->sec == sec)
1605 {
1606 /* Everything must go for SEC. */
1607 *pp = p->next;
1608 break;
1609 }
1610 }
1611
1612 r_type = SPARC_ELF_R_TYPE (rel->r_info);
1613 r_type = sparc_elf_tls_transition (info, abfd, r_type, h != NULL);
1614 switch (r_type)
1615 {
1616 case R_SPARC_TLS_LDM_HI22:
1617 case R_SPARC_TLS_LDM_LO10:
1618 if (_bfd_sparc_elf_hash_table (info)->tls_ldm_got.refcount > 0)
1619 _bfd_sparc_elf_hash_table (info)->tls_ldm_got.refcount -= 1;
1620 break;
1621
1622 case R_SPARC_TLS_GD_HI22:
1623 case R_SPARC_TLS_GD_LO10:
1624 case R_SPARC_TLS_IE_HI22:
1625 case R_SPARC_TLS_IE_LO10:
1626 case R_SPARC_GOT10:
1627 case R_SPARC_GOT13:
1628 case R_SPARC_GOT22:
1629 if (h != NULL)
1630 {
1631 if (h->got.refcount > 0)
1632 h->got.refcount--;
1633 }
1634 else
1635 {
1636 if (local_got_refcounts[r_symndx] > 0)
1637 local_got_refcounts[r_symndx]--;
1638 }
1639 break;
1640
1641 case R_SPARC_PC10:
1642 case R_SPARC_PC22:
1643 case R_SPARC_PC_HH22:
1644 case R_SPARC_PC_HM10:
1645 case R_SPARC_PC_LM22:
1646 if (h != NULL
1647 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1648 break;
1649 /* Fall through. */
1650
1651 case R_SPARC_DISP8:
1652 case R_SPARC_DISP16:
1653 case R_SPARC_DISP32:
1654 case R_SPARC_DISP64:
1655 case R_SPARC_WDISP30:
1656 case R_SPARC_WDISP22:
1657 case R_SPARC_WDISP19:
1658 case R_SPARC_WDISP16:
1659 case R_SPARC_8:
1660 case R_SPARC_16:
1661 case R_SPARC_32:
1662 case R_SPARC_HI22:
1663 case R_SPARC_22:
1664 case R_SPARC_13:
1665 case R_SPARC_LO10:
1666 case R_SPARC_UA16:
1667 case R_SPARC_UA32:
1668 case R_SPARC_PLT32:
1669 case R_SPARC_10:
1670 case R_SPARC_11:
1671 case R_SPARC_64:
1672 case R_SPARC_OLO10:
1673 case R_SPARC_HH22:
1674 case R_SPARC_HM10:
1675 case R_SPARC_LM22:
1676 case R_SPARC_7:
1677 case R_SPARC_5:
1678 case R_SPARC_6:
1679 case R_SPARC_HIX22:
1680 case R_SPARC_LOX10:
1681 case R_SPARC_H44:
1682 case R_SPARC_M44:
1683 case R_SPARC_L44:
1684 case R_SPARC_UA64:
1685 if (info->shared)
1686 break;
1687 /* Fall through. */
1688
1689 case R_SPARC_WPLT30:
1690 if (h != NULL)
1691 {
1692 if (h->plt.refcount > 0)
1693 h->plt.refcount--;
1694 }
1695 break;
1696
1697 default:
1698 break;
1699 }
1700 }
1701
1702 return TRUE;
1703 }
1704
1705 /* Adjust a symbol defined by a dynamic object and referenced by a
1706 regular object. The current definition is in some section of the
1707 dynamic object, but we're not including those sections. We have to
1708 change the definition to something the rest of the link can
1709 understand. */
1710
1711 bfd_boolean
1712 _bfd_sparc_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1713 struct elf_link_hash_entry *h)
1714 {
1715 struct _bfd_sparc_elf_link_hash_table *htab;
1716 struct _bfd_sparc_elf_link_hash_entry * eh;
1717 struct _bfd_sparc_elf_dyn_relocs *p;
1718 asection *s;
1719 unsigned int power_of_two;
1720
1721 htab = _bfd_sparc_elf_hash_table (info);
1722
1723 /* Make sure we know what is going on here. */
1724 BFD_ASSERT (htab->elf.dynobj != NULL
1725 && (h->needs_plt
1726 || h->u.weakdef != NULL
1727 || (h->def_dynamic
1728 && h->ref_regular
1729 && !h->def_regular)));
1730
1731 /* If this is a function, put it in the procedure linkage table. We
1732 will fill in the contents of the procedure linkage table later
1733 (although we could actually do it here). The STT_NOTYPE
1734 condition is a hack specifically for the Oracle libraries
1735 delivered for Solaris; for some inexplicable reason, they define
1736 some of their functions as STT_NOTYPE when they really should be
1737 STT_FUNC. */
1738 if (h->type == STT_FUNC
1739 || h->needs_plt
1740 || (h->type == STT_NOTYPE
1741 && (h->root.type == bfd_link_hash_defined
1742 || h->root.type == bfd_link_hash_defweak)
1743 && (h->root.u.def.section->flags & SEC_CODE) != 0))
1744 {
1745 if (h->plt.refcount <= 0
1746 || (! info->shared
1747 && !h->def_dynamic
1748 && !h->ref_dynamic
1749 && h->root.type != bfd_link_hash_undefweak
1750 && h->root.type != bfd_link_hash_undefined))
1751 {
1752 /* This case can occur if we saw a WPLT30 reloc in an input
1753 file, but the symbol was never referred to by a dynamic
1754 object, or if all references were garbage collected. In
1755 such a case, we don't actually need to build a procedure
1756 linkage table, and we can just do a WDISP30 reloc instead. */
1757 h->plt.offset = (bfd_vma) -1;
1758 h->needs_plt = 0;
1759 }
1760
1761 return TRUE;
1762 }
1763 else
1764 h->plt.offset = (bfd_vma) -1;
1765
1766 /* If this is a weak symbol, and there is a real definition, the
1767 processor independent code will have arranged for us to see the
1768 real definition first, and we can just use the same value. */
1769 if (h->u.weakdef != NULL)
1770 {
1771 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1772 || h->u.weakdef->root.type == bfd_link_hash_defweak);
1773 h->root.u.def.section = h->u.weakdef->root.u.def.section;
1774 h->root.u.def.value = h->u.weakdef->root.u.def.value;
1775 return TRUE;
1776 }
1777
1778 /* This is a reference to a symbol defined by a dynamic object which
1779 is not a function. */
1780
1781 /* If we are creating a shared library, we must presume that the
1782 only references to the symbol are via the global offset table.
1783 For such cases we need not do anything here; the relocations will
1784 be handled correctly by relocate_section. */
1785 if (info->shared)
1786 return TRUE;
1787
1788 /* If there are no references to this symbol that do not use the
1789 GOT, we don't need to generate a copy reloc. */
1790 if (!h->non_got_ref)
1791 return TRUE;
1792
1793 eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
1794 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1795 {
1796 s = p->sec->output_section;
1797 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1798 break;
1799 }
1800
1801 /* If we didn't find any dynamic relocs in read-only sections, then
1802 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1803 if (p == NULL)
1804 {
1805 h->non_got_ref = 0;
1806 return TRUE;
1807 }
1808
1809 if (h->size == 0)
1810 {
1811 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
1812 h->root.root.string);
1813 return TRUE;
1814 }
1815
1816 /* We must allocate the symbol in our .dynbss section, which will
1817 become part of the .bss section of the executable. There will be
1818 an entry for this symbol in the .dynsym section. The dynamic
1819 object will contain position independent code, so all references
1820 from the dynamic object to this symbol will go through the global
1821 offset table. The dynamic linker will use the .dynsym entry to
1822 determine the address it must put in the global offset table, so
1823 both the dynamic object and the regular object will refer to the
1824 same memory location for the variable. */
1825
1826 /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker
1827 to copy the initial value out of the dynamic object and into the
1828 runtime process image. We need to remember the offset into the
1829 .rel.bss section we are going to use. */
1830 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1831 {
1832 htab->srelbss->size += SPARC_ELF_RELA_BYTES (htab);
1833 h->needs_copy = 1;
1834 }
1835
1836 /* We need to figure out the alignment required for this symbol. I
1837 have no idea how ELF linkers handle this. */
1838 power_of_two = bfd_log2 (h->size);
1839 if (power_of_two > htab->align_power_max)
1840 power_of_two = htab->align_power_max;
1841
1842 /* Apply the required alignment. */
1843 s = htab->sdynbss;
1844 s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
1845 if (power_of_two > bfd_get_section_alignment (dynobj, s))
1846 {
1847 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
1848 return FALSE;
1849 }
1850
1851 /* Define the symbol as being at this point in the section. */
1852 h->root.u.def.section = s;
1853 h->root.u.def.value = s->size;
1854
1855 /* Increment the section size to make room for the symbol. */
1856 s->size += h->size;
1857
1858 return TRUE;
1859 }
1860
1861 /* Allocate space in .plt, .got and associated reloc sections for
1862 dynamic relocs. */
1863
1864 static bfd_boolean
1865 allocate_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
1866 {
1867 struct bfd_link_info *info;
1868 struct _bfd_sparc_elf_link_hash_table *htab;
1869 struct _bfd_sparc_elf_link_hash_entry *eh;
1870 struct _bfd_sparc_elf_dyn_relocs *p;
1871
1872 if (h->root.type == bfd_link_hash_indirect)
1873 return TRUE;
1874
1875 if (h->root.type == bfd_link_hash_warning)
1876 /* When warning symbols are created, they **replace** the "real"
1877 entry in the hash table, thus we never get to see the real
1878 symbol in a hash traversal. So look at it now. */
1879 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1880
1881 info = (struct bfd_link_info *) inf;
1882 htab = _bfd_sparc_elf_hash_table (info);
1883
1884 if (htab->elf.dynamic_sections_created
1885 && h->plt.refcount > 0)
1886 {
1887 /* Make sure this symbol is output as a dynamic symbol.
1888 Undefined weak syms won't yet be marked as dynamic. */
1889 if (h->dynindx == -1
1890 && !h->forced_local)
1891 {
1892 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1893 return FALSE;
1894 }
1895
1896 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
1897 {
1898 asection *s = htab->splt;
1899
1900 /* Allocate room for the header. */
1901 if (s->size == 0)
1902 {
1903 s->size = htab->plt_header_size;
1904
1905 /* Allocate space for the .rela.plt.unloaded relocations. */
1906 if (htab->is_vxworks && !info->shared)
1907 htab->srelplt2->size = sizeof (Elf32_External_Rela) * 2;
1908 }
1909
1910 /* The procedure linkage table size is bounded by the magnitude
1911 of the offset we can describe in the entry. */
1912 if (s->size >= (SPARC_ELF_WORD_BYTES(htab) == 8 ?
1913 (((bfd_vma)1 << 31) << 1) : 0x400000))
1914 {
1915 bfd_set_error (bfd_error_bad_value);
1916 return FALSE;
1917 }
1918
1919 if (SPARC_ELF_WORD_BYTES(htab) == 8
1920 && s->size >= PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE)
1921 {
1922 bfd_vma off = s->size - PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE;
1923
1924
1925 off = (off % (160 * PLT64_ENTRY_SIZE)) / PLT64_ENTRY_SIZE;
1926
1927 h->plt.offset = (s->size - (off * 8));
1928 }
1929 else
1930 h->plt.offset = s->size;
1931
1932 /* If this symbol is not defined in a regular file, and we are
1933 not generating a shared library, then set the symbol to this
1934 location in the .plt. This is required to make function
1935 pointers compare as equal between the normal executable and
1936 the shared library. */
1937 if (! info->shared
1938 && !h->def_regular)
1939 {
1940 h->root.u.def.section = s;
1941 h->root.u.def.value = h->plt.offset;
1942 }
1943
1944 /* Make room for this entry. */
1945 s->size += htab->plt_entry_size;
1946
1947 /* We also need to make an entry in the .rela.plt section. */
1948 htab->srelplt->size += SPARC_ELF_RELA_BYTES (htab);
1949
1950 if (htab->is_vxworks)
1951 {
1952 /* Allocate space for the .got.plt entry. */
1953 htab->sgotplt->size += 4;
1954
1955 /* ...and for the .rela.plt.unloaded relocations. */
1956 if (!info->shared)
1957 htab->srelplt2->size += sizeof (Elf32_External_Rela) * 3;
1958 }
1959 }
1960 else
1961 {
1962 h->plt.offset = (bfd_vma) -1;
1963 h->needs_plt = 0;
1964 }
1965 }
1966 else
1967 {
1968 h->plt.offset = (bfd_vma) -1;
1969 h->needs_plt = 0;
1970 }
1971
1972 /* If R_SPARC_TLS_IE_{HI22,LO10} symbol is now local to the binary,
1973 make it a R_SPARC_TLS_LE_{HI22,LO10} requiring no TLS entry. */
1974 if (h->got.refcount > 0
1975 && !info->shared
1976 && h->dynindx == -1
1977 && _bfd_sparc_elf_hash_entry(h)->tls_type == GOT_TLS_IE)
1978 h->got.offset = (bfd_vma) -1;
1979 else if (h->got.refcount > 0)
1980 {
1981 asection *s;
1982 bfd_boolean dyn;
1983 int tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
1984
1985 /* Make sure this symbol is output as a dynamic symbol.
1986 Undefined weak syms won't yet be marked as dynamic. */
1987 if (h->dynindx == -1
1988 && !h->forced_local)
1989 {
1990 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1991 return FALSE;
1992 }
1993
1994 s = htab->sgot;
1995 h->got.offset = s->size;
1996 s->size += SPARC_ELF_WORD_BYTES (htab);
1997 /* R_SPARC_TLS_GD_HI{22,LO10} needs 2 consecutive GOT slots. */
1998 if (tls_type == GOT_TLS_GD)
1999 s->size += SPARC_ELF_WORD_BYTES (htab);
2000 dyn = htab->elf.dynamic_sections_created;
2001 /* R_SPARC_TLS_IE_{HI22,LO10} needs one dynamic relocation,
2002 R_SPARC_TLS_GD_{HI22,LO10} needs one if local symbol and two if
2003 global. */
2004 if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
2005 || tls_type == GOT_TLS_IE)
2006 htab->srelgot->size += SPARC_ELF_RELA_BYTES (htab);
2007 else if (tls_type == GOT_TLS_GD)
2008 htab->srelgot->size += 2 * SPARC_ELF_RELA_BYTES (htab);
2009 else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
2010 htab->srelgot->size += SPARC_ELF_RELA_BYTES (htab);
2011 }
2012 else
2013 h->got.offset = (bfd_vma) -1;
2014
2015 eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
2016 if (eh->dyn_relocs == NULL)
2017 return TRUE;
2018
2019 /* In the shared -Bsymbolic case, discard space allocated for
2020 dynamic pc-relative relocs against symbols which turn out to be
2021 defined in regular objects. For the normal shared case, discard
2022 space for pc-relative relocs that have become local due to symbol
2023 visibility changes. */
2024
2025 if (info->shared)
2026 {
2027 if (h->def_regular
2028 && (h->forced_local
2029 || info->symbolic))
2030 {
2031 struct _bfd_sparc_elf_dyn_relocs **pp;
2032
2033 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2034 {
2035 p->count -= p->pc_count;
2036 p->pc_count = 0;
2037 if (p->count == 0)
2038 *pp = p->next;
2039 else
2040 pp = &p->next;
2041 }
2042 }
2043
2044 /* Also discard relocs on undefined weak syms with non-default
2045 visibility. */
2046 if (eh->dyn_relocs != NULL
2047 && h->root.type == bfd_link_hash_undefweak)
2048 {
2049 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2050 eh->dyn_relocs = NULL;
2051
2052 /* Make sure undefined weak symbols are output as a dynamic
2053 symbol in PIEs. */
2054 else if (h->dynindx == -1
2055 && !h->forced_local)
2056 {
2057 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2058 return FALSE;
2059 }
2060 }
2061 }
2062 else
2063 {
2064 /* For the non-shared case, discard space for relocs against
2065 symbols which turn out to need copy relocs or are not
2066 dynamic. */
2067
2068 if (!h->non_got_ref
2069 && ((h->def_dynamic
2070 && !h->def_regular)
2071 || (htab->elf.dynamic_sections_created
2072 && (h->root.type == bfd_link_hash_undefweak
2073 || h->root.type == bfd_link_hash_undefined))))
2074 {
2075 /* Make sure this symbol is output as a dynamic symbol.
2076 Undefined weak syms won't yet be marked as dynamic. */
2077 if (h->dynindx == -1
2078 && !h->forced_local)
2079 {
2080 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2081 return FALSE;
2082 }
2083
2084 /* If that succeeded, we know we'll be keeping all the
2085 relocs. */
2086 if (h->dynindx != -1)
2087 goto keep;
2088 }
2089
2090 eh->dyn_relocs = NULL;
2091
2092 keep: ;
2093 }
2094
2095 /* Finally, allocate space. */
2096 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2097 {
2098 asection *sreloc = elf_section_data (p->sec)->sreloc;
2099 sreloc->size += p->count * SPARC_ELF_RELA_BYTES (htab);
2100 }
2101
2102 return TRUE;
2103 }
2104
2105 /* Find any dynamic relocs that apply to read-only sections. */
2106
2107 static bfd_boolean
2108 readonly_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
2109 {
2110 struct _bfd_sparc_elf_link_hash_entry *eh;
2111 struct _bfd_sparc_elf_dyn_relocs *p;
2112
2113 if (h->root.type == bfd_link_hash_warning)
2114 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2115
2116 eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
2117 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2118 {
2119 asection *s = p->sec->output_section;
2120
2121 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2122 {
2123 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2124
2125 info->flags |= DF_TEXTREL;
2126
2127 /* Not an error, just cut short the traversal. */
2128 return FALSE;
2129 }
2130 }
2131 return TRUE;
2132 }
2133
2134 /* Return true if the dynamic symbol for a given section should be
2135 omitted when creating a shared library. */
2136
2137 bfd_boolean
2138 _bfd_sparc_elf_omit_section_dynsym (bfd *output_bfd,
2139 struct bfd_link_info *info,
2140 asection *p)
2141 {
2142 /* We keep the .got section symbol so that explicit relocations
2143 against the _GLOBAL_OFFSET_TABLE_ symbol emitted in PIC mode
2144 can be turned into relocations against the .got symbol. */
2145 if (strcmp (p->name, ".got") == 0)
2146 return FALSE;
2147
2148 return _bfd_elf_link_omit_section_dynsym (output_bfd, info, p);
2149 }
2150
2151 /* Set the sizes of the dynamic sections. */
2152
2153 bfd_boolean
2154 _bfd_sparc_elf_size_dynamic_sections (bfd *output_bfd,
2155 struct bfd_link_info *info)
2156 {
2157 struct _bfd_sparc_elf_link_hash_table *htab;
2158 bfd *dynobj;
2159 asection *s;
2160 bfd *ibfd;
2161
2162 htab = _bfd_sparc_elf_hash_table (info);
2163 dynobj = htab->elf.dynobj;
2164 BFD_ASSERT (dynobj != NULL);
2165
2166 if (elf_hash_table (info)->dynamic_sections_created)
2167 {
2168 /* Set the contents of the .interp section to the interpreter. */
2169 if (info->executable)
2170 {
2171 s = bfd_get_section_by_name (dynobj, ".interp");
2172 BFD_ASSERT (s != NULL);
2173 s->size = htab->dynamic_interpreter_size;
2174 s->contents = (unsigned char *) htab->dynamic_interpreter;
2175 }
2176 }
2177
2178 /* Set up .got offsets for local syms, and space for local dynamic
2179 relocs. */
2180 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2181 {
2182 bfd_signed_vma *local_got;
2183 bfd_signed_vma *end_local_got;
2184 char *local_tls_type;
2185 bfd_size_type locsymcount;
2186 Elf_Internal_Shdr *symtab_hdr;
2187 asection *srel;
2188
2189 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2190 continue;
2191
2192 for (s = ibfd->sections; s != NULL; s = s->next)
2193 {
2194 struct _bfd_sparc_elf_dyn_relocs *p;
2195
2196 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
2197 {
2198 if (!bfd_is_abs_section (p->sec)
2199 && bfd_is_abs_section (p->sec->output_section))
2200 {
2201 /* Input section has been discarded, either because
2202 it is a copy of a linkonce section or due to
2203 linker script /DISCARD/, so we'll be discarding
2204 the relocs too. */
2205 }
2206 else if (p->count != 0)
2207 {
2208 srel = elf_section_data (p->sec)->sreloc;
2209 srel->size += p->count * SPARC_ELF_RELA_BYTES (htab);
2210 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2211 info->flags |= DF_TEXTREL;
2212 }
2213 }
2214 }
2215
2216 local_got = elf_local_got_refcounts (ibfd);
2217 if (!local_got)
2218 continue;
2219
2220 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2221 locsymcount = symtab_hdr->sh_info;
2222 end_local_got = local_got + locsymcount;
2223 local_tls_type = _bfd_sparc_elf_local_got_tls_type (ibfd);
2224 s = htab->sgot;
2225 srel = htab->srelgot;
2226 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
2227 {
2228 if (*local_got > 0)
2229 {
2230 *local_got = s->size;
2231 s->size += SPARC_ELF_WORD_BYTES (htab);
2232 if (*local_tls_type == GOT_TLS_GD)
2233 s->size += SPARC_ELF_WORD_BYTES (htab);
2234 if (info->shared
2235 || *local_tls_type == GOT_TLS_GD
2236 || *local_tls_type == GOT_TLS_IE)
2237 srel->size += SPARC_ELF_RELA_BYTES (htab);
2238 }
2239 else
2240 *local_got = (bfd_vma) -1;
2241 }
2242 }
2243
2244 if (htab->tls_ldm_got.refcount > 0)
2245 {
2246 /* Allocate 2 got entries and 1 dynamic reloc for
2247 R_SPARC_TLS_LDM_{HI22,LO10} relocs. */
2248 htab->tls_ldm_got.offset = htab->sgot->size;
2249 htab->sgot->size += (2 * SPARC_ELF_WORD_BYTES (htab));
2250 htab->srelgot->size += SPARC_ELF_RELA_BYTES (htab);
2251 }
2252 else
2253 htab->tls_ldm_got.offset = -1;
2254
2255 /* Allocate global sym .plt and .got entries, and space for global
2256 sym dynamic relocs. */
2257 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
2258
2259 if (! ABI_64_P (output_bfd)
2260 && !htab->is_vxworks
2261 && elf_hash_table (info)->dynamic_sections_created)
2262 {
2263 /* Make space for the trailing nop in .plt. */
2264 if (htab->splt->size > 0)
2265 htab->splt->size += 1 * SPARC_INSN_BYTES;
2266
2267 /* If the .got section is more than 0x1000 bytes, we add
2268 0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13
2269 bit relocations have a greater chance of working.
2270
2271 FIXME: Make this optimization work for 64-bit too. */
2272 if (htab->sgot->size >= 0x1000
2273 && elf_hash_table (info)->hgot->root.u.def.value == 0)
2274 elf_hash_table (info)->hgot->root.u.def.value = 0x1000;
2275 }
2276
2277 /* The check_relocs and adjust_dynamic_symbol entry points have
2278 determined the sizes of the various dynamic sections. Allocate
2279 memory for them. */
2280 for (s = dynobj->sections; s != NULL; s = s->next)
2281 {
2282 if ((s->flags & SEC_LINKER_CREATED) == 0)
2283 continue;
2284
2285 if (s == htab->splt
2286 || s == htab->sgot
2287 || s == htab->sdynbss
2288 || s == htab->sgotplt)
2289 {
2290 /* Strip this section if we don't need it; see the
2291 comment below. */
2292 }
2293 else if (CONST_STRNEQ (s->name, ".rela"))
2294 {
2295 if (s->size != 0)
2296 {
2297 /* We use the reloc_count field as a counter if we need
2298 to copy relocs into the output file. */
2299 s->reloc_count = 0;
2300 }
2301 }
2302 else
2303 {
2304 /* It's not one of our sections. */
2305 continue;
2306 }
2307
2308 if (s->size == 0)
2309 {
2310 /* If we don't need this section, strip it from the
2311 output file. This is mostly to handle .rela.bss and
2312 .rela.plt. We must create both sections in
2313 create_dynamic_sections, because they must be created
2314 before the linker maps input sections to output
2315 sections. The linker does that before
2316 adjust_dynamic_symbol is called, and it is that
2317 function which decides whether anything needs to go
2318 into these sections. */
2319 s->flags |= SEC_EXCLUDE;
2320 continue;
2321 }
2322
2323 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2324 continue;
2325
2326 /* Allocate memory for the section contents. Zero the memory
2327 for the benefit of .rela.plt, which has 4 unused entries
2328 at the beginning, and we don't want garbage. */
2329 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2330 if (s->contents == NULL)
2331 return FALSE;
2332 }
2333
2334 if (elf_hash_table (info)->dynamic_sections_created)
2335 {
2336 /* Add some entries to the .dynamic section. We fill in the
2337 values later, in _bfd_sparc_elf_finish_dynamic_sections, but we
2338 must add the entries now so that we get the correct size for
2339 the .dynamic section. The DT_DEBUG entry is filled in by the
2340 dynamic linker and used by the debugger. */
2341 #define add_dynamic_entry(TAG, VAL) \
2342 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2343
2344 if (info->executable)
2345 {
2346 if (!add_dynamic_entry (DT_DEBUG, 0))
2347 return FALSE;
2348 }
2349
2350 if (htab->srelplt->size != 0)
2351 {
2352 if (!add_dynamic_entry (DT_PLTGOT, 0)
2353 || !add_dynamic_entry (DT_PLTRELSZ, 0)
2354 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2355 || !add_dynamic_entry (DT_JMPREL, 0))
2356 return FALSE;
2357 }
2358
2359 if (!add_dynamic_entry (DT_RELA, 0)
2360 || !add_dynamic_entry (DT_RELASZ, 0)
2361 || !add_dynamic_entry (DT_RELAENT,
2362 SPARC_ELF_RELA_BYTES (htab)))
2363 return FALSE;
2364
2365 /* If any dynamic relocs apply to a read-only section,
2366 then we need a DT_TEXTREL entry. */
2367 if ((info->flags & DF_TEXTREL) == 0)
2368 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
2369 (PTR) info);
2370
2371 if (info->flags & DF_TEXTREL)
2372 {
2373 if (!add_dynamic_entry (DT_TEXTREL, 0))
2374 return FALSE;
2375 }
2376
2377 if (ABI_64_P (output_bfd))
2378 {
2379 int reg;
2380 struct _bfd_sparc_elf_app_reg * app_regs;
2381 struct elf_strtab_hash *dynstr;
2382 struct elf_link_hash_table *eht = elf_hash_table (info);
2383
2384 /* Add dynamic STT_REGISTER symbols and corresponding DT_SPARC_REGISTER
2385 entries if needed. */
2386 app_regs = _bfd_sparc_elf_hash_table (info)->app_regs;
2387 dynstr = eht->dynstr;
2388
2389 for (reg = 0; reg < 4; reg++)
2390 if (app_regs [reg].name != NULL)
2391 {
2392 struct elf_link_local_dynamic_entry *entry, *e;
2393
2394 if (!add_dynamic_entry (DT_SPARC_REGISTER, 0))
2395 return FALSE;
2396
2397 entry = (struct elf_link_local_dynamic_entry *)
2398 bfd_hash_allocate (&info->hash->table, sizeof (*entry));
2399 if (entry == NULL)
2400 return FALSE;
2401
2402 /* We cheat here a little bit: the symbol will not be local, so we
2403 put it at the end of the dynlocal linked list. We will fix it
2404 later on, as we have to fix other fields anyway. */
2405 entry->isym.st_value = reg < 2 ? reg + 2 : reg + 4;
2406 entry->isym.st_size = 0;
2407 if (*app_regs [reg].name != '\0')
2408 entry->isym.st_name
2409 = _bfd_elf_strtab_add (dynstr, app_regs[reg].name, FALSE);
2410 else
2411 entry->isym.st_name = 0;
2412 entry->isym.st_other = 0;
2413 entry->isym.st_info = ELF_ST_INFO (app_regs [reg].bind,
2414 STT_REGISTER);
2415 entry->isym.st_shndx = app_regs [reg].shndx;
2416 entry->next = NULL;
2417 entry->input_bfd = output_bfd;
2418 entry->input_indx = -1;
2419
2420 if (eht->dynlocal == NULL)
2421 eht->dynlocal = entry;
2422 else
2423 {
2424 for (e = eht->dynlocal; e->next; e = e->next)
2425 ;
2426 e->next = entry;
2427 }
2428 eht->dynsymcount++;
2429 }
2430 }
2431 }
2432 #undef add_dynamic_entry
2433
2434 return TRUE;
2435 }
2436 \f
2437 bfd_boolean
2438 _bfd_sparc_elf_new_section_hook (bfd *abfd, asection *sec)
2439 {
2440 if (!sec->used_by_bfd)
2441 {
2442 struct _bfd_sparc_elf_section_data *sdata;
2443 bfd_size_type amt = sizeof (*sdata);
2444
2445 sdata = bfd_zalloc (abfd, amt);
2446 if (sdata == NULL)
2447 return FALSE;
2448 sec->used_by_bfd = sdata;
2449 }
2450
2451 return _bfd_elf_new_section_hook (abfd, sec);
2452 }
2453
2454 bfd_boolean
2455 _bfd_sparc_elf_relax_section (bfd *abfd ATTRIBUTE_UNUSED,
2456 struct bfd_section *section,
2457 struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
2458 bfd_boolean *again)
2459 {
2460 *again = FALSE;
2461 sec_do_relax (section) = 1;
2462 return TRUE;
2463 }
2464 \f
2465 /* Return the base VMA address which should be subtracted from real addresses
2466 when resolving @dtpoff relocation.
2467 This is PT_TLS segment p_vaddr. */
2468
2469 static bfd_vma
2470 dtpoff_base (struct bfd_link_info *info)
2471 {
2472 /* If tls_sec is NULL, we should have signalled an error already. */
2473 if (elf_hash_table (info)->tls_sec == NULL)
2474 return 0;
2475 return elf_hash_table (info)->tls_sec->vma;
2476 }
2477
2478 /* Return the relocation value for @tpoff relocation
2479 if STT_TLS virtual address is ADDRESS. */
2480
2481 static bfd_vma
2482 tpoff (struct bfd_link_info *info, bfd_vma address)
2483 {
2484 struct elf_link_hash_table *htab = elf_hash_table (info);
2485
2486 /* If tls_sec is NULL, we should have signalled an error already. */
2487 if (htab->tls_sec == NULL)
2488 return 0;
2489 return address - htab->tls_size - htab->tls_sec->vma;
2490 }
2491
2492 /* Relocate a SPARC ELF section. */
2493
2494 bfd_boolean
2495 _bfd_sparc_elf_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
2496 bfd *input_bfd, asection *input_section,
2497 bfd_byte *contents, Elf_Internal_Rela *relocs,
2498 Elf_Internal_Sym *local_syms, asection **local_sections)
2499 {
2500 struct _bfd_sparc_elf_link_hash_table *htab;
2501 Elf_Internal_Shdr *symtab_hdr;
2502 struct elf_link_hash_entry **sym_hashes;
2503 bfd_vma *local_got_offsets;
2504 bfd_vma got_base;
2505 asection *sreloc;
2506 Elf_Internal_Rela *rel;
2507 Elf_Internal_Rela *relend;
2508 int num_relocs;
2509
2510 if (info->relocatable)
2511 return TRUE;
2512
2513 htab = _bfd_sparc_elf_hash_table (info);
2514 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2515 sym_hashes = elf_sym_hashes (input_bfd);
2516 local_got_offsets = elf_local_got_offsets (input_bfd);
2517
2518 if (elf_hash_table (info)->hgot == NULL)
2519 got_base = 0;
2520 else
2521 got_base = elf_hash_table (info)->hgot->root.u.def.value;
2522
2523 sreloc = elf_section_data (input_section)->sreloc;
2524
2525 rel = relocs;
2526 if (ABI_64_P (output_bfd))
2527 num_relocs = NUM_SHDR_ENTRIES (& elf_section_data (input_section)->rel_hdr);
2528 else
2529 num_relocs = input_section->reloc_count;
2530 relend = relocs + num_relocs;
2531 for (; rel < relend; rel++)
2532 {
2533 int r_type, tls_type;
2534 reloc_howto_type *howto;
2535 unsigned long r_symndx;
2536 struct elf_link_hash_entry *h;
2537 Elf_Internal_Sym *sym;
2538 asection *sec;
2539 bfd_vma relocation, off;
2540 bfd_reloc_status_type r;
2541 bfd_boolean is_plt = FALSE;
2542 bfd_boolean unresolved_reloc;
2543
2544 r_type = SPARC_ELF_R_TYPE (rel->r_info);
2545 if (r_type == R_SPARC_GNU_VTINHERIT
2546 || r_type == R_SPARC_GNU_VTENTRY)
2547 continue;
2548
2549 if (r_type < 0 || r_type >= (int) R_SPARC_max_std)
2550 {
2551 bfd_set_error (bfd_error_bad_value);
2552 return FALSE;
2553 }
2554 howto = _bfd_sparc_elf_howto_table + r_type;
2555
2556 /* This is a final link. */
2557 r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
2558 h = NULL;
2559 sym = NULL;
2560 sec = NULL;
2561 unresolved_reloc = FALSE;
2562 if (r_symndx < symtab_hdr->sh_info)
2563 {
2564 sym = local_syms + r_symndx;
2565 sec = local_sections[r_symndx];
2566 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2567 }
2568 else
2569 {
2570 bfd_boolean warned;
2571
2572 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2573 r_symndx, symtab_hdr, sym_hashes,
2574 h, sec, relocation,
2575 unresolved_reloc, warned);
2576 if (warned)
2577 {
2578 /* To avoid generating warning messages about truncated
2579 relocations, set the relocation's address to be the same as
2580 the start of this section. */
2581 if (input_section->output_section != NULL)
2582 relocation = input_section->output_section->vma;
2583 else
2584 relocation = 0;
2585 }
2586 }
2587
2588 switch (r_type)
2589 {
2590 case R_SPARC_GOT10:
2591 case R_SPARC_GOT13:
2592 case R_SPARC_GOT22:
2593 /* Relocation is to the entry for this symbol in the global
2594 offset table. */
2595 if (htab->sgot == NULL)
2596 abort ();
2597
2598 if (h != NULL)
2599 {
2600 bfd_boolean dyn;
2601
2602 off = h->got.offset;
2603 BFD_ASSERT (off != (bfd_vma) -1);
2604 dyn = elf_hash_table (info)->dynamic_sections_created;
2605
2606 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2607 || (info->shared
2608 && (info->symbolic
2609 || h->dynindx == -1
2610 || h->forced_local)
2611 && h->def_regular))
2612 {
2613 /* This is actually a static link, or it is a
2614 -Bsymbolic link and the symbol is defined
2615 locally, or the symbol was forced to be local
2616 because of a version file. We must initialize
2617 this entry in the global offset table. Since the
2618 offset must always be a multiple of 8 for 64-bit
2619 and 4 for 32-bit, we use the least significant bit
2620 to record whether we have initialized it already.
2621
2622 When doing a dynamic link, we create a .rela.got
2623 relocation entry to initialize the value. This
2624 is done in the finish_dynamic_symbol routine. */
2625 if ((off & 1) != 0)
2626 off &= ~1;
2627 else
2628 {
2629 SPARC_ELF_PUT_WORD (htab, output_bfd, relocation,
2630 htab->sgot->contents + off);
2631 h->got.offset |= 1;
2632 }
2633 }
2634 else
2635 unresolved_reloc = FALSE;
2636 }
2637 else
2638 {
2639 BFD_ASSERT (local_got_offsets != NULL
2640 && local_got_offsets[r_symndx] != (bfd_vma) -1);
2641
2642 off = local_got_offsets[r_symndx];
2643
2644 /* The offset must always be a multiple of 8 on 64-bit and
2645 4 on 32-bit. We use the least significant bit to record
2646 whether we have already processed this entry. */
2647 if ((off & 1) != 0)
2648 off &= ~1;
2649 else
2650 {
2651
2652 if (info->shared)
2653 {
2654 asection *s;
2655 Elf_Internal_Rela outrel;
2656
2657 /* We need to generate a R_SPARC_RELATIVE reloc
2658 for the dynamic linker. */
2659 s = htab->srelgot;
2660 BFD_ASSERT (s != NULL);
2661
2662 outrel.r_offset = (htab->sgot->output_section->vma
2663 + htab->sgot->output_offset
2664 + off);
2665 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
2666 0, R_SPARC_RELATIVE);
2667 outrel.r_addend = relocation;
2668 relocation = 0;
2669 SPARC_ELF_APPEND_RELA (htab, output_bfd, s, &outrel);
2670 }
2671
2672 SPARC_ELF_PUT_WORD (htab, output_bfd, relocation,
2673 htab->sgot->contents + off);
2674 local_got_offsets[r_symndx] |= 1;
2675 }
2676 }
2677 relocation = htab->sgot->output_offset + off - got_base;
2678 break;
2679
2680 case R_SPARC_PLT32:
2681 case R_SPARC_PLT64:
2682 if (h == NULL || h->plt.offset == (bfd_vma) -1)
2683 {
2684 r_type = (r_type == R_SPARC_PLT32) ? R_SPARC_32 : R_SPARC_64;
2685 goto r_sparc_plt32;
2686 }
2687 /* Fall through. */
2688
2689 case R_SPARC_WPLT30:
2690 case R_SPARC_HIPLT22:
2691 case R_SPARC_LOPLT10:
2692 case R_SPARC_PCPLT32:
2693 case R_SPARC_PCPLT22:
2694 case R_SPARC_PCPLT10:
2695 r_sparc_wplt30:
2696 /* Relocation is to the entry for this symbol in the
2697 procedure linkage table. */
2698
2699 if (! ABI_64_P (output_bfd))
2700 {
2701 /* The Solaris native assembler will generate a WPLT30 reloc
2702 for a local symbol if you assemble a call from one
2703 section to another when using -K pic. We treat it as
2704 WDISP30. */
2705 if (h == NULL)
2706 break;
2707 }
2708 else
2709 {
2710 BFD_ASSERT (h != NULL);
2711 }
2712
2713 if (h->plt.offset == (bfd_vma) -1 || htab->splt == NULL)
2714 {
2715 /* We didn't make a PLT entry for this symbol. This
2716 happens when statically linking PIC code, or when
2717 using -Bsymbolic. */
2718 break;
2719 }
2720
2721 relocation = (htab->splt->output_section->vma
2722 + htab->splt->output_offset
2723 + h->plt.offset);
2724 unresolved_reloc = FALSE;
2725 if (r_type == R_SPARC_PLT32 || r_type == R_SPARC_PLT64)
2726 {
2727 r_type = r_type == R_SPARC_PLT32 ? R_SPARC_32 : R_SPARC_64;
2728 is_plt = TRUE;
2729 goto r_sparc_plt32;
2730 }
2731 break;
2732
2733 case R_SPARC_PC10:
2734 case R_SPARC_PC22:
2735 case R_SPARC_PC_HH22:
2736 case R_SPARC_PC_HM10:
2737 case R_SPARC_PC_LM22:
2738 if (h != NULL
2739 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2740 break;
2741 /* Fall through. */
2742 case R_SPARC_DISP8:
2743 case R_SPARC_DISP16:
2744 case R_SPARC_DISP32:
2745 case R_SPARC_DISP64:
2746 case R_SPARC_WDISP30:
2747 case R_SPARC_WDISP22:
2748 case R_SPARC_WDISP19:
2749 case R_SPARC_WDISP16:
2750 case R_SPARC_8:
2751 case R_SPARC_16:
2752 case R_SPARC_32:
2753 case R_SPARC_HI22:
2754 case R_SPARC_22:
2755 case R_SPARC_13:
2756 case R_SPARC_LO10:
2757 case R_SPARC_UA16:
2758 case R_SPARC_UA32:
2759 case R_SPARC_10:
2760 case R_SPARC_11:
2761 case R_SPARC_64:
2762 case R_SPARC_OLO10:
2763 case R_SPARC_HH22:
2764 case R_SPARC_HM10:
2765 case R_SPARC_LM22:
2766 case R_SPARC_7:
2767 case R_SPARC_5:
2768 case R_SPARC_6:
2769 case R_SPARC_HIX22:
2770 case R_SPARC_LOX10:
2771 case R_SPARC_H44:
2772 case R_SPARC_M44:
2773 case R_SPARC_L44:
2774 case R_SPARC_UA64:
2775 r_sparc_plt32:
2776 /* r_symndx will be zero only for relocs against symbols
2777 from removed linkonce sections, or sections discarded by
2778 a linker script. */
2779 if (r_symndx == 0
2780 || (input_section->flags & SEC_ALLOC) == 0)
2781 break;
2782
2783 if ((info->shared
2784 && (h == NULL
2785 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2786 || h->root.type != bfd_link_hash_undefweak)
2787 && (! howto->pc_relative
2788 || (h != NULL
2789 && h->dynindx != -1
2790 && (! info->symbolic
2791 || !h->def_regular))))
2792 || (!info->shared
2793 && h != NULL
2794 && h->dynindx != -1
2795 && !h->non_got_ref
2796 && ((h->def_dynamic
2797 && !h->def_regular)
2798 || h->root.type == bfd_link_hash_undefweak
2799 || h->root.type == bfd_link_hash_undefined)))
2800 {
2801 Elf_Internal_Rela outrel;
2802 bfd_boolean skip, relocate = FALSE;
2803
2804 /* When generating a shared object, these relocations
2805 are copied into the output file to be resolved at run
2806 time. */
2807
2808 BFD_ASSERT (sreloc != NULL);
2809
2810 skip = FALSE;
2811
2812 outrel.r_offset =
2813 _bfd_elf_section_offset (output_bfd, info, input_section,
2814 rel->r_offset);
2815 if (outrel.r_offset == (bfd_vma) -1)
2816 skip = TRUE;
2817 else if (outrel.r_offset == (bfd_vma) -2)
2818 skip = TRUE, relocate = TRUE;
2819 outrel.r_offset += (input_section->output_section->vma
2820 + input_section->output_offset);
2821
2822 /* Optimize unaligned reloc usage now that we know where
2823 it finally resides. */
2824 switch (r_type)
2825 {
2826 case R_SPARC_16:
2827 if (outrel.r_offset & 1)
2828 r_type = R_SPARC_UA16;
2829 break;
2830 case R_SPARC_UA16:
2831 if (!(outrel.r_offset & 1))
2832 r_type = R_SPARC_16;
2833 break;
2834 case R_SPARC_32:
2835 if (outrel.r_offset & 3)
2836 r_type = R_SPARC_UA32;
2837 break;
2838 case R_SPARC_UA32:
2839 if (!(outrel.r_offset & 3))
2840 r_type = R_SPARC_32;
2841 break;
2842 case R_SPARC_64:
2843 if (outrel.r_offset & 7)
2844 r_type = R_SPARC_UA64;
2845 break;
2846 case R_SPARC_UA64:
2847 if (!(outrel.r_offset & 7))
2848 r_type = R_SPARC_64;
2849 break;
2850 case R_SPARC_DISP8:
2851 case R_SPARC_DISP16:
2852 case R_SPARC_DISP32:
2853 case R_SPARC_DISP64:
2854 /* If the symbol is not dynamic, we should not keep
2855 a dynamic relocation. But an .rela.* slot has been
2856 allocated for it, output R_SPARC_NONE.
2857 FIXME: Add code tracking needed dynamic relocs as
2858 e.g. i386 has. */
2859 if (h->dynindx == -1)
2860 skip = TRUE, relocate = TRUE;
2861 break;
2862 }
2863
2864 if (skip)
2865 memset (&outrel, 0, sizeof outrel);
2866 /* h->dynindx may be -1 if the symbol was marked to
2867 become local. */
2868 else if (h != NULL && ! is_plt
2869 && ((! info->symbolic && h->dynindx != -1)
2870 || !h->def_regular))
2871 {
2872 BFD_ASSERT (h->dynindx != -1);
2873 outrel.r_info = SPARC_ELF_R_INFO (htab, rel, h->dynindx, r_type);
2874 outrel.r_addend = rel->r_addend;
2875 }
2876 else
2877 {
2878 if (r_type == R_SPARC_32 || r_type == R_SPARC_64)
2879 {
2880 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
2881 0, R_SPARC_RELATIVE);
2882 outrel.r_addend = relocation + rel->r_addend;
2883 }
2884 else
2885 {
2886 long indx;
2887
2888 if (is_plt)
2889 sec = htab->splt;
2890
2891 if (bfd_is_abs_section (sec))
2892 indx = 0;
2893 else if (sec == NULL || sec->owner == NULL)
2894 {
2895 bfd_set_error (bfd_error_bad_value);
2896 return FALSE;
2897 }
2898 else
2899 {
2900 asection *osec;
2901
2902 osec = sec->output_section;
2903 indx = elf_section_data (osec)->dynindx;
2904
2905 /* FIXME: we really should be able to link non-pic
2906 shared libraries. */
2907 if (indx == 0)
2908 {
2909 BFD_FAIL ();
2910 (*_bfd_error_handler)
2911 (_("%B: probably compiled without -fPIC?"),
2912 input_bfd);
2913 bfd_set_error (bfd_error_bad_value);
2914 return FALSE;
2915 }
2916 }
2917
2918 outrel.r_info = SPARC_ELF_R_INFO (htab, rel, indx, r_type);
2919 outrel.r_addend = relocation + rel->r_addend;
2920 }
2921 }
2922
2923 SPARC_ELF_APPEND_RELA (htab, output_bfd, sreloc, &outrel);
2924
2925 /* This reloc will be computed at runtime, so there's no
2926 need to do anything now. */
2927 if (! relocate)
2928 continue;
2929 }
2930 break;
2931
2932 case R_SPARC_TLS_GD_HI22:
2933 if (! ABI_64_P (input_bfd)
2934 && ! _bfd_sparc_elf_tdata (input_bfd)->has_tlsgd)
2935 {
2936 /* R_SPARC_REV32 used the same reloc number as
2937 R_SPARC_TLS_GD_HI22. */
2938 r_type = R_SPARC_REV32;
2939 break;
2940 }
2941 /* Fall through */
2942
2943 case R_SPARC_TLS_GD_LO10:
2944 case R_SPARC_TLS_IE_HI22:
2945 case R_SPARC_TLS_IE_LO10:
2946 r_type = sparc_elf_tls_transition (info, input_bfd, r_type, h == NULL);
2947 tls_type = GOT_UNKNOWN;
2948 if (h == NULL && local_got_offsets)
2949 tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
2950 else if (h != NULL)
2951 {
2952 tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
2953 if (!info->shared && h->dynindx == -1 && tls_type == GOT_TLS_IE)
2954 switch (SPARC_ELF_R_TYPE (rel->r_info))
2955 {
2956 case R_SPARC_TLS_GD_HI22:
2957 case R_SPARC_TLS_IE_HI22:
2958 r_type = R_SPARC_TLS_LE_HIX22;
2959 break;
2960 default:
2961 r_type = R_SPARC_TLS_LE_LOX10;
2962 break;
2963 }
2964 }
2965 if (tls_type == GOT_TLS_IE)
2966 switch (r_type)
2967 {
2968 case R_SPARC_TLS_GD_HI22:
2969 r_type = R_SPARC_TLS_IE_HI22;
2970 break;
2971 case R_SPARC_TLS_GD_LO10:
2972 r_type = R_SPARC_TLS_IE_LO10;
2973 break;
2974 }
2975
2976 if (r_type == R_SPARC_TLS_LE_HIX22)
2977 {
2978 relocation = tpoff (info, relocation);
2979 break;
2980 }
2981 if (r_type == R_SPARC_TLS_LE_LOX10)
2982 {
2983 /* Change add into xor. */
2984 relocation = tpoff (info, relocation);
2985 bfd_put_32 (output_bfd, (bfd_get_32 (input_bfd,
2986 contents + rel->r_offset)
2987 | 0x80182000), contents + rel->r_offset);
2988 break;
2989 }
2990
2991 if (h != NULL)
2992 {
2993 off = h->got.offset;
2994 h->got.offset |= 1;
2995 }
2996 else
2997 {
2998 BFD_ASSERT (local_got_offsets != NULL);
2999 off = local_got_offsets[r_symndx];
3000 local_got_offsets[r_symndx] |= 1;
3001 }
3002
3003 r_sparc_tlsldm:
3004 if (htab->sgot == NULL)
3005 abort ();
3006
3007 if ((off & 1) != 0)
3008 off &= ~1;
3009 else
3010 {
3011 Elf_Internal_Rela outrel;
3012 int dr_type, indx;
3013
3014 if (htab->srelgot == NULL)
3015 abort ();
3016
3017 SPARC_ELF_PUT_WORD (htab, output_bfd, 0, htab->sgot->contents + off);
3018 outrel.r_offset = (htab->sgot->output_section->vma
3019 + htab->sgot->output_offset + off);
3020 indx = h && h->dynindx != -1 ? h->dynindx : 0;
3021 if (r_type == R_SPARC_TLS_IE_HI22
3022 || r_type == R_SPARC_TLS_IE_LO10)
3023 dr_type = SPARC_ELF_TPOFF_RELOC (htab);
3024 else
3025 dr_type = SPARC_ELF_DTPMOD_RELOC (htab);
3026 if (dr_type == SPARC_ELF_TPOFF_RELOC (htab) && indx == 0)
3027 outrel.r_addend = relocation - dtpoff_base (info);
3028 else
3029 outrel.r_addend = 0;
3030 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx, dr_type);
3031 SPARC_ELF_APPEND_RELA (htab, output_bfd, htab->srelgot, &outrel);
3032
3033 if (r_type == R_SPARC_TLS_GD_HI22
3034 || r_type == R_SPARC_TLS_GD_LO10)
3035 {
3036 if (indx == 0)
3037 {
3038 BFD_ASSERT (! unresolved_reloc);
3039 SPARC_ELF_PUT_WORD (htab, output_bfd,
3040 relocation - dtpoff_base (info),
3041 (htab->sgot->contents + off
3042 + SPARC_ELF_WORD_BYTES (htab)));
3043 }
3044 else
3045 {
3046 SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3047 (htab->sgot->contents + off
3048 + SPARC_ELF_WORD_BYTES (htab)));
3049 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx,
3050 SPARC_ELF_DTPOFF_RELOC (htab));
3051 outrel.r_offset += SPARC_ELF_WORD_BYTES (htab);
3052 SPARC_ELF_APPEND_RELA (htab, output_bfd, htab->srelgot, &outrel);
3053 }
3054 }
3055 else if (dr_type == SPARC_ELF_DTPMOD_RELOC (htab))
3056 {
3057 SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3058 (htab->sgot->contents + off
3059 + SPARC_ELF_WORD_BYTES (htab)));
3060 }
3061 }
3062
3063 if (off >= (bfd_vma) -2)
3064 abort ();
3065
3066 relocation = htab->sgot->output_offset + off - got_base;
3067 unresolved_reloc = FALSE;
3068 howto = _bfd_sparc_elf_howto_table + r_type;
3069 break;
3070
3071 case R_SPARC_TLS_LDM_HI22:
3072 case R_SPARC_TLS_LDM_LO10:
3073 if (! info->shared)
3074 {
3075 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3076 continue;
3077 }
3078 off = htab->tls_ldm_got.offset;
3079 htab->tls_ldm_got.offset |= 1;
3080 goto r_sparc_tlsldm;
3081
3082 case R_SPARC_TLS_LDO_HIX22:
3083 case R_SPARC_TLS_LDO_LOX10:
3084 if (info->shared)
3085 {
3086 relocation -= dtpoff_base (info);
3087 break;
3088 }
3089
3090 r_type = (r_type == R_SPARC_TLS_LDO_HIX22
3091 ? R_SPARC_TLS_LE_HIX22 : R_SPARC_TLS_LE_LOX10);
3092 /* Fall through. */
3093
3094 case R_SPARC_TLS_LE_HIX22:
3095 case R_SPARC_TLS_LE_LOX10:
3096 if (info->shared)
3097 {
3098 Elf_Internal_Rela outrel;
3099 bfd_boolean skip, relocate = FALSE;
3100
3101 BFD_ASSERT (sreloc != NULL);
3102 skip = FALSE;
3103 outrel.r_offset =
3104 _bfd_elf_section_offset (output_bfd, info, input_section,
3105 rel->r_offset);
3106 if (outrel.r_offset == (bfd_vma) -1)
3107 skip = TRUE;
3108 else if (outrel.r_offset == (bfd_vma) -2)
3109 skip = TRUE, relocate = TRUE;
3110 outrel.r_offset += (input_section->output_section->vma
3111 + input_section->output_offset);
3112 if (skip)
3113 memset (&outrel, 0, sizeof outrel);
3114 else
3115 {
3116 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, r_type);
3117 outrel.r_addend = relocation - dtpoff_base (info)
3118 + rel->r_addend;
3119 }
3120
3121 SPARC_ELF_APPEND_RELA (htab, output_bfd, sreloc, &outrel);
3122 continue;
3123 }
3124 relocation = tpoff (info, relocation);
3125 break;
3126
3127 case R_SPARC_TLS_LDM_CALL:
3128 if (! info->shared)
3129 {
3130 /* mov %g0, %o0 */
3131 bfd_put_32 (output_bfd, 0x90100000, contents + rel->r_offset);
3132 continue;
3133 }
3134 /* Fall through */
3135
3136 case R_SPARC_TLS_GD_CALL:
3137 tls_type = GOT_UNKNOWN;
3138 if (h == NULL && local_got_offsets)
3139 tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3140 else if (h != NULL)
3141 tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3142 if (! info->shared
3143 || (r_type == R_SPARC_TLS_GD_CALL && tls_type == GOT_TLS_IE))
3144 {
3145 bfd_vma insn;
3146
3147 if (!info->shared && (h == NULL || h->dynindx == -1))
3148 {
3149 /* GD -> LE */
3150 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3151 continue;
3152 }
3153
3154 /* GD -> IE */
3155 if (rel + 1 < relend
3156 && SPARC_ELF_R_TYPE (rel[1].r_info) == R_SPARC_TLS_GD_ADD
3157 && rel[1].r_offset == rel->r_offset + 4
3158 && SPARC_ELF_R_SYMNDX (htab, rel[1].r_info) == r_symndx
3159 && (((insn = bfd_get_32 (input_bfd,
3160 contents + rel[1].r_offset))
3161 >> 25) & 0x1f) == 8)
3162 {
3163 /* We have
3164 call __tls_get_addr, %tgd_call(foo)
3165 add %reg1, %reg2, %o0, %tgd_add(foo)
3166 and change it into IE:
3167 {ld,ldx} [%reg1 + %reg2], %o0, %tie_ldx(foo)
3168 add %g7, %o0, %o0, %tie_add(foo).
3169 add is 0x80000000 | (rd << 25) | (rs1 << 14) | rs2,
3170 ld is 0xc0000000 | (rd << 25) | (rs1 << 14) | rs2,
3171 ldx is 0xc0580000 | (rd << 25) | (rs1 << 14) | rs2. */
3172 bfd_put_32 (output_bfd, insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000),
3173 contents + rel->r_offset);
3174 bfd_put_32 (output_bfd, 0x9001c008,
3175 contents + rel->r_offset + 4);
3176 rel++;
3177 continue;
3178 }
3179
3180 bfd_put_32 (output_bfd, 0x9001c008, contents + rel->r_offset);
3181 continue;
3182 }
3183
3184 h = (struct elf_link_hash_entry *)
3185 bfd_link_hash_lookup (info->hash, "__tls_get_addr", FALSE,
3186 FALSE, TRUE);
3187 BFD_ASSERT (h != NULL);
3188 r_type = R_SPARC_WPLT30;
3189 howto = _bfd_sparc_elf_howto_table + r_type;
3190 goto r_sparc_wplt30;
3191
3192 case R_SPARC_TLS_GD_ADD:
3193 tls_type = GOT_UNKNOWN;
3194 if (h == NULL && local_got_offsets)
3195 tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3196 else if (h != NULL)
3197 tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3198 if (! info->shared || tls_type == GOT_TLS_IE)
3199 {
3200 /* add %reg1, %reg2, %reg3, %tgd_add(foo)
3201 changed into IE:
3202 {ld,ldx} [%reg1 + %reg2], %reg3, %tie_ldx(foo)
3203 or LE:
3204 add %g7, %reg2, %reg3. */
3205 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3206 if ((h != NULL && h->dynindx != -1) || info->shared)
3207 relocation = insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000);
3208 else
3209 relocation = (insn & ~0x7c000) | 0x1c000;
3210 bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3211 }
3212 continue;
3213
3214 case R_SPARC_TLS_LDM_ADD:
3215 if (! info->shared)
3216 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3217 continue;
3218
3219 case R_SPARC_TLS_LDO_ADD:
3220 if (! info->shared)
3221 {
3222 /* Change rs1 into %g7. */
3223 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3224 insn = (insn & ~0x7c000) | 0x1c000;
3225 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3226 }
3227 continue;
3228
3229 case R_SPARC_TLS_IE_LD:
3230 case R_SPARC_TLS_IE_LDX:
3231 if (! info->shared && (h == NULL || h->dynindx == -1))
3232 {
3233 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3234 int rs2 = insn & 0x1f;
3235 int rd = (insn >> 25) & 0x1f;
3236
3237 if (rs2 == rd)
3238 relocation = SPARC_NOP;
3239 else
3240 relocation = 0x80100000 | (insn & 0x3e00001f);
3241 bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3242 }
3243 continue;
3244
3245 case R_SPARC_TLS_IE_ADD:
3246 /* Totally useless relocation. */
3247 continue;
3248
3249 case R_SPARC_TLS_DTPOFF32:
3250 case R_SPARC_TLS_DTPOFF64:
3251 relocation -= dtpoff_base (info);
3252 break;
3253
3254 default:
3255 break;
3256 }
3257
3258 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3259 because such sections are not SEC_ALLOC and thus ld.so will
3260 not process them. */
3261 if (unresolved_reloc
3262 && !((input_section->flags & SEC_DEBUGGING) != 0
3263 && h->def_dynamic))
3264 (*_bfd_error_handler)
3265 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3266 input_bfd,
3267 input_section,
3268 (long) rel->r_offset,
3269 howto->name,
3270 h->root.root.string);
3271
3272 r = bfd_reloc_continue;
3273 if (r_type == R_SPARC_OLO10)
3274 {
3275 bfd_vma x;
3276
3277 if (! ABI_64_P (output_bfd))
3278 abort ();
3279
3280 relocation += rel->r_addend;
3281 relocation = (relocation & 0x3ff) + ELF64_R_TYPE_DATA (rel->r_info);
3282
3283 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3284 x = (x & ~(bfd_vma) 0x1fff) | (relocation & 0x1fff);
3285 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3286
3287 r = bfd_check_overflow (howto->complain_on_overflow,
3288 howto->bitsize, howto->rightshift,
3289 bfd_arch_bits_per_address (input_bfd),
3290 relocation);
3291 }
3292 else if (r_type == R_SPARC_WDISP16)
3293 {
3294 bfd_vma x;
3295
3296 relocation += rel->r_addend;
3297 relocation -= (input_section->output_section->vma
3298 + input_section->output_offset);
3299 relocation -= rel->r_offset;
3300
3301 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3302 x |= ((((relocation >> 2) & 0xc000) << 6)
3303 | ((relocation >> 2) & 0x3fff));
3304 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3305
3306 r = bfd_check_overflow (howto->complain_on_overflow,
3307 howto->bitsize, howto->rightshift,
3308 bfd_arch_bits_per_address (input_bfd),
3309 relocation);
3310 }
3311 else if (r_type == R_SPARC_REV32)
3312 {
3313 bfd_vma x;
3314
3315 relocation = relocation + rel->r_addend;
3316
3317 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3318 x = x + relocation;
3319 bfd_putl32 (/*input_bfd,*/ x, contents + rel->r_offset);
3320 r = bfd_reloc_ok;
3321 }
3322 else if (r_type == R_SPARC_TLS_LDO_HIX22
3323 || r_type == R_SPARC_TLS_LE_HIX22)
3324 {
3325 bfd_vma x;
3326
3327 relocation += rel->r_addend;
3328 if (r_type == R_SPARC_TLS_LE_HIX22)
3329 relocation ^= MINUS_ONE;
3330
3331 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3332 x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
3333 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3334 r = bfd_reloc_ok;
3335 }
3336 else if (r_type == R_SPARC_TLS_LDO_LOX10
3337 || r_type == R_SPARC_TLS_LE_LOX10)
3338 {
3339 bfd_vma x;
3340
3341 relocation += rel->r_addend;
3342 relocation &= 0x3ff;
3343 if (r_type == R_SPARC_TLS_LE_LOX10)
3344 relocation |= 0x1c00;
3345
3346 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3347 x = (x & ~(bfd_vma) 0x1fff) | relocation;
3348 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3349
3350 r = bfd_reloc_ok;
3351 }
3352 else if (r_type == R_SPARC_HIX22)
3353 {
3354 bfd_vma x;
3355
3356 relocation += rel->r_addend;
3357 relocation = relocation ^ MINUS_ONE;
3358
3359 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3360 x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
3361 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3362
3363 r = bfd_check_overflow (howto->complain_on_overflow,
3364 howto->bitsize, howto->rightshift,
3365 bfd_arch_bits_per_address (input_bfd),
3366 relocation);
3367 }
3368 else if (r_type == R_SPARC_LOX10)
3369 {
3370 bfd_vma x;
3371
3372 relocation += rel->r_addend;
3373 relocation = (relocation & 0x3ff) | 0x1c00;
3374
3375 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3376 x = (x & ~(bfd_vma) 0x1fff) | relocation;
3377 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3378
3379 r = bfd_reloc_ok;
3380 }
3381 else if ((r_type == R_SPARC_WDISP30 || r_type == R_SPARC_WPLT30)
3382 && sec_do_relax (input_section)
3383 && rel->r_offset + 4 < input_section->size)
3384 {
3385 #define G0 0
3386 #define O7 15
3387 #define XCC (2 << 20)
3388 #define COND(x) (((x)&0xf)<<25)
3389 #define CONDA COND(0x8)
3390 #define INSN_BPA (F2(0,1) | CONDA | BPRED | XCC)
3391 #define INSN_BA (F2(0,2) | CONDA)
3392 #define INSN_OR F3(2, 0x2, 0)
3393 #define INSN_NOP F2(0,4)
3394
3395 bfd_vma x, y;
3396
3397 /* If the instruction is a call with either:
3398 restore
3399 arithmetic instruction with rd == %o7
3400 where rs1 != %o7 and rs2 if it is register != %o7
3401 then we can optimize if the call destination is near
3402 by changing the call into a branch always. */
3403 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3404 y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
3405 if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2))
3406 {
3407 if (((y & OP3(~0)) == OP3(0x3d) /* restore */
3408 || ((y & OP3(0x28)) == 0 /* arithmetic */
3409 && (y & RD(~0)) == RD(O7)))
3410 && (y & RS1(~0)) != RS1(O7)
3411 && ((y & F3I(~0))
3412 || (y & RS2(~0)) != RS2(O7)))
3413 {
3414 bfd_vma reloc;
3415
3416 reloc = relocation + rel->r_addend - rel->r_offset;
3417 reloc -= (input_section->output_section->vma
3418 + input_section->output_offset);
3419
3420 /* Ensure the branch fits into simm22. */
3421 if ((reloc & 3) == 0
3422 && ((reloc & ~(bfd_vma)0x7fffff) == 0
3423 || ((reloc | 0x7fffff) == ~(bfd_vma)0)))
3424 {
3425 reloc >>= 2;
3426
3427 /* Check whether it fits into simm19. */
3428 if (((reloc & 0x3c0000) == 0
3429 || (reloc & 0x3c0000) == 0x3c0000)
3430 && (ABI_64_P (output_bfd)
3431 || elf_elfheader (output_bfd)->e_flags & EF_SPARC_32PLUS))
3432 x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */
3433 else
3434 x = INSN_BA | (reloc & 0x3fffff); /* ba */
3435 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3436 r = bfd_reloc_ok;
3437 if (rel->r_offset >= 4
3438 && (y & (0xffffffff ^ RS1(~0)))
3439 == (INSN_OR | RD(O7) | RS2(G0)))
3440 {
3441 bfd_vma z;
3442 unsigned int reg;
3443
3444 z = bfd_get_32 (input_bfd,
3445 contents + rel->r_offset - 4);
3446 if ((z & (0xffffffff ^ RD(~0)))
3447 != (INSN_OR | RS1(O7) | RS2(G0)))
3448 break;
3449
3450 /* The sequence was
3451 or %o7, %g0, %rN
3452 call foo
3453 or %rN, %g0, %o7
3454
3455 If call foo was replaced with ba, replace
3456 or %rN, %g0, %o7 with nop. */
3457
3458 reg = (y & RS1(~0)) >> 14;
3459 if (reg != ((z & RD(~0)) >> 25)
3460 || reg == G0 || reg == O7)
3461 break;
3462
3463 bfd_put_32 (input_bfd, (bfd_vma) INSN_NOP,
3464 contents + rel->r_offset + 4);
3465 }
3466
3467 }
3468 }
3469 }
3470 }
3471
3472 if (r == bfd_reloc_continue)
3473 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3474 contents, rel->r_offset,
3475 relocation, rel->r_addend);
3476
3477 if (r != bfd_reloc_ok)
3478 {
3479 switch (r)
3480 {
3481 default:
3482 case bfd_reloc_outofrange:
3483 abort ();
3484 case bfd_reloc_overflow:
3485 {
3486 const char *name;
3487
3488 /* The Solaris native linker silently disregards overflows.
3489 We don't, but this breaks stabs debugging info, whose
3490 relocations are only 32-bits wide. Ignore overflows in
3491 this case and also for discarded entries. */
3492 if ((r_type == R_SPARC_32 || r_type == R_SPARC_DISP32)
3493 && (((input_section->flags & SEC_DEBUGGING) != 0
3494 && strcmp (bfd_section_name (input_bfd,
3495 input_section),
3496 ".stab") == 0)
3497 || _bfd_elf_section_offset (output_bfd, info,
3498 input_section,
3499 rel->r_offset)
3500 == (bfd_vma)-1))
3501 break;
3502
3503 if (h != NULL)
3504 {
3505 /* Assume this is a call protected by other code that
3506 detect the symbol is undefined. If this is the case,
3507 we can safely ignore the overflow. If not, the
3508 program is hosed anyway, and a little warning isn't
3509 going to help. */
3510 if (h->root.type == bfd_link_hash_undefweak
3511 && howto->pc_relative)
3512 break;
3513
3514 name = NULL;
3515 }
3516 else
3517 {
3518 name = bfd_elf_string_from_elf_section (input_bfd,
3519 symtab_hdr->sh_link,
3520 sym->st_name);
3521 if (name == NULL)
3522 return FALSE;
3523 if (*name == '\0')
3524 name = bfd_section_name (input_bfd, sec);
3525 }
3526 if (! ((*info->callbacks->reloc_overflow)
3527 (info, (h ? &h->root : NULL), name, howto->name,
3528 (bfd_vma) 0, input_bfd, input_section,
3529 rel->r_offset)))
3530 return FALSE;
3531 }
3532 break;
3533 }
3534 }
3535 }
3536
3537 return TRUE;
3538 }
3539
3540 /* Build a VxWorks PLT entry. PLT_INDEX is the index of the PLT entry
3541 and PLT_OFFSET is the byte offset from the start of .plt. GOT_OFFSET
3542 is the offset of the associated .got.plt entry from
3543 _GLOBAL_OFFSET_TABLE_. */
3544
3545 static void
3546 sparc_vxworks_build_plt_entry (bfd *output_bfd, struct bfd_link_info *info,
3547 bfd_vma plt_offset, bfd_vma plt_index,
3548 bfd_vma got_offset)
3549 {
3550 bfd_vma got_base;
3551 const bfd_vma *plt_entry;
3552 struct _bfd_sparc_elf_link_hash_table *htab;
3553 bfd_byte *loc;
3554 Elf_Internal_Rela rela;
3555
3556 htab = _bfd_sparc_elf_hash_table (info);
3557 if (info->shared)
3558 {
3559 plt_entry = sparc_vxworks_shared_plt_entry;
3560 got_base = 0;
3561 }
3562 else
3563 {
3564 plt_entry = sparc_vxworks_exec_plt_entry;
3565 got_base = (htab->elf.hgot->root.u.def.value
3566 + htab->elf.hgot->root.u.def.section->output_offset
3567 + htab->elf.hgot->root.u.def.section->output_section->vma);
3568 }
3569
3570 /* Fill in the entry in the procedure linkage table. */
3571 bfd_put_32 (output_bfd, plt_entry[0] + ((got_base + got_offset) >> 10),
3572 htab->splt->contents + plt_offset);
3573 bfd_put_32 (output_bfd, plt_entry[1] + ((got_base + got_offset) & 0x3ff),
3574 htab->splt->contents + plt_offset + 4);
3575 bfd_put_32 (output_bfd, plt_entry[2],
3576 htab->splt->contents + plt_offset + 8);
3577 bfd_put_32 (output_bfd, plt_entry[3],
3578 htab->splt->contents + plt_offset + 12);
3579 bfd_put_32 (output_bfd, plt_entry[4],
3580 htab->splt->contents + plt_offset + 16);
3581 bfd_put_32 (output_bfd, plt_entry[5] + (plt_index >> 10),
3582 htab->splt->contents + plt_offset + 20);
3583 /* PC-relative displacement for a branch to the start of
3584 the PLT section. */
3585 bfd_put_32 (output_bfd, plt_entry[6] + (((-plt_offset - 24) >> 2)
3586 & 0x003fffff),
3587 htab->splt->contents + plt_offset + 24);
3588 bfd_put_32 (output_bfd, plt_entry[7] + (plt_index & 0x3ff),
3589 htab->splt->contents + plt_offset + 28);
3590
3591 /* Fill in the .got.plt entry, pointing initially at the
3592 second half of the PLT entry. */
3593 BFD_ASSERT (htab->sgotplt != NULL);
3594 bfd_put_32 (output_bfd,
3595 htab->splt->output_section->vma
3596 + htab->splt->output_offset
3597 + plt_offset + 20,
3598 htab->sgotplt->contents + got_offset);
3599
3600 /* Add relocations to .rela.plt.unloaded. */
3601 if (!info->shared)
3602 {
3603 loc = (htab->srelplt2->contents
3604 + (2 + 3 * plt_index) * sizeof (Elf32_External_Rela));
3605
3606 /* Relocate the initial sethi. */
3607 rela.r_offset = (htab->splt->output_section->vma
3608 + htab->splt->output_offset
3609 + plt_offset);
3610 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
3611 rela.r_addend = got_offset;
3612 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3613 loc += sizeof (Elf32_External_Rela);
3614
3615 /* Likewise the following or. */
3616 rela.r_offset += 4;
3617 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
3618 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3619 loc += sizeof (Elf32_External_Rela);
3620
3621 /* Relocate the .got.plt entry. */
3622 rela.r_offset = (htab->sgotplt->output_section->vma
3623 + htab->sgotplt->output_offset
3624 + got_offset);
3625 rela.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_SPARC_32);
3626 rela.r_addend = plt_offset + 20;
3627 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3628 }
3629 }
3630
3631 /* Finish up dynamic symbol handling. We set the contents of various
3632 dynamic sections here. */
3633
3634 bfd_boolean
3635 _bfd_sparc_elf_finish_dynamic_symbol (bfd *output_bfd,
3636 struct bfd_link_info *info,
3637 struct elf_link_hash_entry *h,
3638 Elf_Internal_Sym *sym)
3639 {
3640 bfd *dynobj;
3641 struct _bfd_sparc_elf_link_hash_table *htab;
3642
3643 htab = _bfd_sparc_elf_hash_table (info);
3644 dynobj = htab->elf.dynobj;
3645
3646 if (h->plt.offset != (bfd_vma) -1)
3647 {
3648 asection *splt;
3649 asection *srela;
3650 Elf_Internal_Rela rela;
3651 bfd_byte *loc;
3652 bfd_vma r_offset, got_offset;
3653 int rela_index;
3654
3655 /* This symbol has an entry in the PLT. Set it up. */
3656
3657 BFD_ASSERT (h->dynindx != -1);
3658
3659 splt = htab->splt;
3660 srela = htab->srelplt;
3661 BFD_ASSERT (splt != NULL && srela != NULL);
3662
3663 /* Fill in the entry in the .rela.plt section. */
3664 if (htab->is_vxworks)
3665 {
3666 /* Work out the index of this PLT entry. */
3667 rela_index = ((h->plt.offset - htab->plt_header_size)
3668 / htab->plt_entry_size);
3669
3670 /* Calculate the offset of the associated .got.plt entry.
3671 The first three entries are reserved. */
3672 got_offset = (rela_index + 3) * 4;
3673
3674 sparc_vxworks_build_plt_entry (output_bfd, info, h->plt.offset,
3675 rela_index, got_offset);
3676
3677
3678 /* On VxWorks, the relocation points to the .got.plt entry,
3679 not the .plt entry. */
3680 rela.r_offset = (htab->sgotplt->output_section->vma
3681 + htab->sgotplt->output_offset
3682 + got_offset);
3683 rela.r_addend = 0;
3684 }
3685 else
3686 {
3687 /* Fill in the entry in the procedure linkage table. */
3688 rela_index = SPARC_ELF_BUILD_PLT_ENTRY (htab, output_bfd, splt,
3689 h->plt.offset, splt->size,
3690 &r_offset);
3691
3692 rela.r_offset = r_offset
3693 + (splt->output_section->vma + splt->output_offset);
3694 if (! ABI_64_P (output_bfd)
3695 || h->plt.offset < (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE))
3696 {
3697 rela.r_addend = 0;
3698 }
3699 else
3700 {
3701 rela.r_addend = (-(h->plt.offset + 4)
3702 - splt->output_section->vma
3703 - splt->output_offset);
3704 }
3705 }
3706 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_JMP_SLOT);
3707
3708 /* Adjust for the first 4 reserved elements in the .plt section
3709 when setting the offset in the .rela.plt section.
3710 Sun forgot to read their own ABI and copied elf32-sparc behaviour,
3711 thus .plt[4] has corresponding .rela.plt[0] and so on. */
3712
3713 loc = srela->contents;
3714 #ifdef BFD64
3715 if (ABI_64_P (output_bfd))
3716 {
3717 loc += rela_index * sizeof (Elf64_External_Rela);
3718 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3719 }
3720 else
3721 #endif
3722 {
3723 loc += rela_index * sizeof (Elf32_External_Rela);
3724 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3725 }
3726
3727 if (!h->def_regular)
3728 {
3729 /* Mark the symbol as undefined, rather than as defined in
3730 the .plt section. Leave the value alone. */
3731 sym->st_shndx = SHN_UNDEF;
3732 /* If the symbol is weak, we do need to clear the value.
3733 Otherwise, the PLT entry would provide a definition for
3734 the symbol even if the symbol wasn't defined anywhere,
3735 and so the symbol would never be NULL. */
3736 if (!h->ref_regular_nonweak)
3737 sym->st_value = 0;
3738 }
3739 }
3740
3741 if (h->got.offset != (bfd_vma) -1
3742 && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_GD
3743 && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_IE)
3744 {
3745 asection *sgot;
3746 asection *srela;
3747 Elf_Internal_Rela rela;
3748
3749 /* This symbol has an entry in the GOT. Set it up. */
3750
3751 sgot = htab->sgot;
3752 srela = htab->srelgot;
3753 BFD_ASSERT (sgot != NULL && srela != NULL);
3754
3755 rela.r_offset = (sgot->output_section->vma
3756 + sgot->output_offset
3757 + (h->got.offset &~ (bfd_vma) 1));
3758
3759 /* If this is a -Bsymbolic link, and the symbol is defined
3760 locally, we just want to emit a RELATIVE reloc. Likewise if
3761 the symbol was forced to be local because of a version file.
3762 The entry in the global offset table will already have been
3763 initialized in the relocate_section function. */
3764 if (info->shared
3765 && (info->symbolic || h->dynindx == -1)
3766 && h->def_regular)
3767 {
3768 asection *sec = h->root.u.def.section;
3769 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, R_SPARC_RELATIVE);
3770 rela.r_addend = (h->root.u.def.value
3771 + sec->output_section->vma
3772 + sec->output_offset);
3773 }
3774 else
3775 {
3776 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_GLOB_DAT);
3777 rela.r_addend = 0;
3778 }
3779
3780 SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3781 sgot->contents + (h->got.offset & ~(bfd_vma) 1));
3782 SPARC_ELF_APPEND_RELA (htab, output_bfd, srela, &rela);
3783 }
3784
3785 if (h->needs_copy)
3786 {
3787 asection *s;
3788 Elf_Internal_Rela rela;
3789
3790 /* This symbols needs a copy reloc. Set it up. */
3791 BFD_ASSERT (h->dynindx != -1);
3792
3793 s = bfd_get_section_by_name (h->root.u.def.section->owner,
3794 ".rela.bss");
3795 BFD_ASSERT (s != NULL);
3796
3797 rela.r_offset = (h->root.u.def.value
3798 + h->root.u.def.section->output_section->vma
3799 + h->root.u.def.section->output_offset);
3800 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_COPY);
3801 rela.r_addend = 0;
3802 SPARC_ELF_APPEND_RELA (htab, output_bfd, s, &rela);
3803 }
3804
3805 /* Mark some specially defined symbols as absolute. On VxWorks,
3806 _GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the
3807 ".got" section. Likewise _PROCEDURE_LINKAGE_TABLE_ and ".plt". */
3808 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3809 || (!htab->is_vxworks
3810 && (h == htab->elf.hgot || h == htab->elf.hplt)))
3811 sym->st_shndx = SHN_ABS;
3812
3813 return TRUE;
3814 }
3815
3816 /* Finish up the dynamic sections. */
3817
3818 #ifdef BFD64
3819 static bfd_boolean
3820 sparc64_finish_dyn (bfd *output_bfd, struct bfd_link_info *info,
3821 bfd *dynobj, asection *sdyn,
3822 asection *splt ATTRIBUTE_UNUSED)
3823 {
3824 Elf64_External_Dyn *dyncon, *dynconend;
3825 int stt_regidx = -1;
3826
3827 dyncon = (Elf64_External_Dyn *) sdyn->contents;
3828 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
3829 for (; dyncon < dynconend; dyncon++)
3830 {
3831 Elf_Internal_Dyn dyn;
3832 const char *name;
3833 bfd_boolean size;
3834
3835 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3836
3837 switch (dyn.d_tag)
3838 {
3839 case DT_PLTGOT: name = ".plt"; size = FALSE; break;
3840 case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break;
3841 case DT_JMPREL: name = ".rela.plt"; size = FALSE; break;
3842 case DT_SPARC_REGISTER:
3843 if (stt_regidx == -1)
3844 {
3845 stt_regidx =
3846 _bfd_elf_link_lookup_local_dynindx (info, output_bfd, -1);
3847 if (stt_regidx == -1)
3848 return FALSE;
3849 }
3850 dyn.d_un.d_val = stt_regidx++;
3851 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3852 /* fallthrough */
3853 default: name = NULL; size = FALSE; break;
3854 }
3855
3856 if (name != NULL)
3857 {
3858 asection *s;
3859
3860 s = bfd_get_section_by_name (output_bfd, name);
3861 if (s == NULL)
3862 dyn.d_un.d_val = 0;
3863 else
3864 {
3865 if (! size)
3866 dyn.d_un.d_ptr = s->vma;
3867 else
3868 dyn.d_un.d_val = s->size;
3869 }
3870 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3871 }
3872 }
3873 return TRUE;
3874 }
3875 #endif
3876
3877 static bfd_boolean
3878 sparc32_finish_dyn (bfd *output_bfd, struct bfd_link_info *info,
3879 bfd *dynobj, asection *sdyn,
3880 asection *splt ATTRIBUTE_UNUSED)
3881 {
3882 Elf32_External_Dyn *dyncon, *dynconend;
3883 struct _bfd_sparc_elf_link_hash_table *htab;
3884
3885 htab = _bfd_sparc_elf_hash_table (info);
3886 dyncon = (Elf32_External_Dyn *) sdyn->contents;
3887 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3888 for (; dyncon < dynconend; dyncon++)
3889 {
3890 Elf_Internal_Dyn dyn;
3891 const char *name;
3892 bfd_boolean size;
3893
3894 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3895
3896 if (htab->is_vxworks && dyn.d_tag == DT_RELASZ)
3897 {
3898 /* On VxWorks, DT_RELASZ should not include the relocations
3899 in .rela.plt. */
3900 if (htab->srelplt)
3901 {
3902 dyn.d_un.d_val -= htab->srelplt->size;
3903 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3904 }
3905 }
3906 else if (htab->is_vxworks && dyn.d_tag == DT_PLTGOT)
3907 {
3908 /* On VxWorks, DT_PLTGOT should point to the start of the GOT,
3909 not to the start of the PLT. */
3910 if (htab->sgotplt)
3911 {
3912 dyn.d_un.d_val = (htab->sgotplt->output_section->vma
3913 + htab->sgotplt->output_offset);
3914 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3915 }
3916 }
3917 else
3918 {
3919 switch (dyn.d_tag)
3920 {
3921 case DT_PLTGOT: name = ".plt"; size = FALSE; break;
3922 case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break;
3923 case DT_JMPREL: name = ".rela.plt"; size = FALSE; break;
3924 default: name = NULL; size = FALSE; break;
3925 }
3926
3927 if (name != NULL)
3928 {
3929 asection *s;
3930
3931 s = bfd_get_section_by_name (output_bfd, name);
3932 if (s == NULL)
3933 dyn.d_un.d_val = 0;
3934 else
3935 {
3936 if (! size)
3937 dyn.d_un.d_ptr = s->vma;
3938 else
3939 dyn.d_un.d_val = s->size;
3940 }
3941 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3942 }
3943 }
3944 }
3945 return TRUE;
3946 }
3947
3948 /* Install the first PLT entry in a VxWorks executable and make sure that
3949 .rela.plt.unloaded relocations have the correct symbol indexes. */
3950
3951 static void
3952 sparc_vxworks_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info)
3953 {
3954 struct _bfd_sparc_elf_link_hash_table *htab;
3955 Elf_Internal_Rela rela;
3956 bfd_vma got_base;
3957 bfd_byte *loc;
3958
3959 htab = _bfd_sparc_elf_hash_table (info);
3960
3961 /* Calculate the absolute value of _GLOBAL_OFFSET_TABLE_. */
3962 got_base = (htab->elf.hgot->root.u.def.section->output_section->vma
3963 + htab->elf.hgot->root.u.def.section->output_offset
3964 + htab->elf.hgot->root.u.def.value);
3965
3966 /* Install the initial PLT entry. */
3967 bfd_put_32 (output_bfd,
3968 sparc_vxworks_exec_plt0_entry[0] + ((got_base + 8) >> 10),
3969 htab->splt->contents);
3970 bfd_put_32 (output_bfd,
3971 sparc_vxworks_exec_plt0_entry[1] + ((got_base + 8) & 0x3ff),
3972 htab->splt->contents + 4);
3973 bfd_put_32 (output_bfd,
3974 sparc_vxworks_exec_plt0_entry[2],
3975 htab->splt->contents + 8);
3976 bfd_put_32 (output_bfd,
3977 sparc_vxworks_exec_plt0_entry[3],
3978 htab->splt->contents + 12);
3979 bfd_put_32 (output_bfd,
3980 sparc_vxworks_exec_plt0_entry[4],
3981 htab->splt->contents + 16);
3982
3983 loc = htab->srelplt2->contents;
3984
3985 /* Add an unloaded relocation for the initial entry's "sethi". */
3986 rela.r_offset = (htab->splt->output_section->vma
3987 + htab->splt->output_offset);
3988 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
3989 rela.r_addend = 8;
3990 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3991 loc += sizeof (Elf32_External_Rela);
3992
3993 /* Likewise the following "or". */
3994 rela.r_offset += 4;
3995 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
3996 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3997 loc += sizeof (Elf32_External_Rela);
3998
3999 /* Fix up the remaining .rela.plt.unloaded relocations. They may have
4000 the wrong symbol index for _G_O_T_ or _P_L_T_ depending on the order
4001 in which symbols were output. */
4002 while (loc < htab->srelplt2->contents + htab->srelplt2->size)
4003 {
4004 Elf_Internal_Rela rel;
4005
4006 /* The entry's initial "sethi" (against _G_O_T_). */
4007 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4008 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4009 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4010 loc += sizeof (Elf32_External_Rela);
4011
4012 /* The following "or" (also against _G_O_T_). */
4013 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4014 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4015 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4016 loc += sizeof (Elf32_External_Rela);
4017
4018 /* The .got.plt entry (against _P_L_T_). */
4019 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4020 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_SPARC_32);
4021 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4022 loc += sizeof (Elf32_External_Rela);
4023 }
4024 }
4025
4026 /* Install the first PLT entry in a VxWorks shared object. */
4027
4028 static void
4029 sparc_vxworks_finish_shared_plt (bfd *output_bfd, struct bfd_link_info *info)
4030 {
4031 struct _bfd_sparc_elf_link_hash_table *htab;
4032 unsigned int i;
4033
4034 htab = _bfd_sparc_elf_hash_table (info);
4035 for (i = 0; i < ARRAY_SIZE (sparc_vxworks_shared_plt0_entry); i++)
4036 bfd_put_32 (output_bfd, sparc_vxworks_shared_plt0_entry[i],
4037 htab->splt->contents + i * 4);
4038 }
4039
4040 bfd_boolean
4041 _bfd_sparc_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
4042 {
4043 bfd *dynobj;
4044 asection *sdyn;
4045 struct _bfd_sparc_elf_link_hash_table *htab;
4046
4047 htab = _bfd_sparc_elf_hash_table (info);
4048 dynobj = htab->elf.dynobj;
4049
4050 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4051
4052 if (elf_hash_table (info)->dynamic_sections_created)
4053 {
4054 asection *splt;
4055 bfd_boolean ret;
4056
4057 splt = bfd_get_section_by_name (dynobj, ".plt");
4058 BFD_ASSERT (splt != NULL && sdyn != NULL);
4059
4060 #ifdef BFD64
4061 if (ABI_64_P (output_bfd))
4062 ret = sparc64_finish_dyn (output_bfd, info, dynobj, sdyn, splt);
4063 else
4064 #endif
4065 ret = sparc32_finish_dyn (output_bfd, info, dynobj, sdyn, splt);
4066
4067 if (ret != TRUE)
4068 return ret;
4069
4070 /* Initialize the contents of the .plt section. */
4071 if (splt->size > 0)
4072 {
4073 if (htab->is_vxworks)
4074 {
4075 if (info->shared)
4076 sparc_vxworks_finish_shared_plt (output_bfd, info);
4077 else
4078 sparc_vxworks_finish_exec_plt (output_bfd, info);
4079 }
4080 else
4081 {
4082 memset (splt->contents, 0, htab->plt_header_size);
4083 if (!ABI_64_P (output_bfd))
4084 bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP,
4085 splt->contents + splt->size - 4);
4086 }
4087 }
4088
4089 elf_section_data (splt->output_section)->this_hdr.sh_entsize
4090 = htab->plt_entry_size;
4091 }
4092
4093 /* Set the first entry in the global offset table to the address of
4094 the dynamic section. */
4095 if (htab->sgot && htab->sgot->size > 0)
4096 {
4097 bfd_vma val = (sdyn ?
4098 sdyn->output_section->vma + sdyn->output_offset :
4099 0);
4100
4101 SPARC_ELF_PUT_WORD (htab, output_bfd, val, htab->sgot->contents);
4102 }
4103
4104 if (htab->sgot)
4105 elf_section_data (htab->sgot->output_section)->this_hdr.sh_entsize =
4106 SPARC_ELF_WORD_BYTES (htab);
4107
4108 return TRUE;
4109 }
4110
4111 \f
4112 /* Set the right machine number for a SPARC ELF file. */
4113
4114 bfd_boolean
4115 _bfd_sparc_elf_object_p (bfd *abfd)
4116 {
4117 if (ABI_64_P (abfd))
4118 {
4119 unsigned long mach = bfd_mach_sparc_v9;
4120
4121 if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
4122 mach = bfd_mach_sparc_v9b;
4123 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
4124 mach = bfd_mach_sparc_v9a;
4125 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, mach);
4126 }
4127 else
4128 {
4129 if (elf_elfheader (abfd)->e_machine == EM_SPARC32PLUS)
4130 {
4131 if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
4132 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4133 bfd_mach_sparc_v8plusb);
4134 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
4135 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4136 bfd_mach_sparc_v8plusa);
4137 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_32PLUS)
4138 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4139 bfd_mach_sparc_v8plus);
4140 else
4141 return FALSE;
4142 }
4143 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_LEDATA)
4144 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4145 bfd_mach_sparc_sparclite_le);
4146 else
4147 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc);
4148 }
4149 }
4150
4151 /* Return address for Ith PLT stub in section PLT, for relocation REL
4152 or (bfd_vma) -1 if it should not be included. */
4153
4154 bfd_vma
4155 _bfd_sparc_elf_plt_sym_val (bfd_vma i, const asection *plt, const arelent *rel)
4156 {
4157 if (ABI_64_P (plt->owner))
4158 {
4159 bfd_vma j;
4160
4161 i += PLT64_HEADER_SIZE / PLT64_ENTRY_SIZE;
4162 if (i < PLT64_LARGE_THRESHOLD)
4163 return plt->vma + i * PLT64_ENTRY_SIZE;
4164
4165 j = (i - PLT64_LARGE_THRESHOLD) % 160;
4166 i -= j;
4167 return plt->vma + i * PLT64_ENTRY_SIZE + j * 4 * 6;
4168 }
4169 else
4170 return rel->address;
4171 }
git-cvsimport of binutils cvsroot