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