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