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