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