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