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