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