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