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