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