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