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