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