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