projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
PR ld/13311
[deliverable/binutils-gdb.git] / bfd / elfxx-sparc.c
CommitLineData
22b75d0a 1/* SPARC-specific support for ELF
7686d77d
AM		 2 Copyright 2005, 2006, 2007, 2008, 2009, 2010, 2011
3 Free Software Foundation, Inc.
22b75d0a
DM		 4
5 This file is part of BFD, the Binary File Descriptor library.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
cd123cb7 9 the Free Software Foundation; either version 3 of the License, or
22b75d0a
DM		 10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
cd123cb7
NC		 19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
21
22b75d0a
DM		 22
23/* This file handles functionality common to the different SPARC ABI's. */
24
22b75d0a 25#include "sysdep.h"
3db64b00 26#include "bfd.h"
22b75d0a
DM		 27#include "bfdlink.h"
28#include "libbfd.h"
910600e9 29#include "libiberty.h"
22b75d0a
DM		 30#include "elf-bfd.h"
31#include "elf/sparc.h"
32#include "opcode/sparc.h"
33#include "elfxx-sparc.h"
910600e9 34#include "elf-vxworks.h"
d0c9aeb3
DM		 35#include "objalloc.h"
36#include "hashtab.h"
22b75d0a
DM		 37
38/* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
39#define MINUS_ONE (~ (bfd_vma) 0)
40
41#define ABI_64_P(abfd) \
42 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
43
44/* The relocation "howto" table. */
45
46/* Utility for performing the standard initial work of an instruction
47 relocation.
48 *PRELOCATION will contain the relocated item.
49 *PINSN will contain the instruction from the input stream.
50 If the result is `bfd_reloc_other' the caller can continue with
51 performing the relocation. Otherwise it must stop and return the
52 value to its caller. */
53
54static bfd_reloc_status_type
55init_insn_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
56 PTR data, asection *input_section, bfd *output_bfd,
57 bfd_vma *prelocation, bfd_vma *pinsn)
58{
59 bfd_vma relocation;
60 reloc_howto_type *howto = reloc_entry->howto;
61
62 if (output_bfd != (bfd *) NULL
63 && (symbol->flags & BSF_SECTION_SYM) == 0
64 && (! howto->partial_inplace
65 || reloc_entry->addend == 0))
66 {
67 reloc_entry->address += input_section->output_offset;
68 return bfd_reloc_ok;
69 }
70
71 /* This works because partial_inplace is FALSE. */
72 if (output_bfd != NULL)
73 return bfd_reloc_continue;
74
75 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
76 return bfd_reloc_outofrange;
77
78 relocation = (symbol->value
79 + symbol->section->output_section->vma
80 + symbol->section->output_offset);
81 relocation += reloc_entry->addend;
82 if (howto->pc_relative)
83 {
84 relocation -= (input_section->output_section->vma
85 + input_section->output_offset);
86 relocation -= reloc_entry->address;
87 }
88
89 *prelocation = relocation;
90 *pinsn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
91 return bfd_reloc_other;
92}
93
94/* For unsupported relocs. */
95
96static bfd_reloc_status_type
97sparc_elf_notsup_reloc (bfd *abfd ATTRIBUTE_UNUSED,
98 arelent *reloc_entry ATTRIBUTE_UNUSED,
99 asymbol *symbol ATTRIBUTE_UNUSED,
100 PTR data ATTRIBUTE_UNUSED,
101 asection *input_section ATTRIBUTE_UNUSED,
102 bfd *output_bfd ATTRIBUTE_UNUSED,
103 char **error_message ATTRIBUTE_UNUSED)
104{
105 return bfd_reloc_notsupported;
106}
107
108/* Handle the WDISP16 reloc. */
109
110static bfd_reloc_status_type
111sparc_elf_wdisp16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
112 PTR data, asection *input_section, bfd *output_bfd,
113 char **error_message ATTRIBUTE_UNUSED)
114{
115 bfd_vma relocation;
116 bfd_vma insn;
117 bfd_reloc_status_type status;
118
119 status = init_insn_reloc (abfd, reloc_entry, symbol, data,
120 input_section, output_bfd, &relocation, &insn);
121 if (status != bfd_reloc_other)
122 return status;
123
124 insn &= ~ (bfd_vma) 0x303fff;
125 insn |= (((relocation >> 2) & 0xc000) << 6) | ((relocation >> 2) & 0x3fff);
126 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
127
128 if ((bfd_signed_vma) relocation < - 0x40000
129 || (bfd_signed_vma) relocation > 0x3ffff)
130 return bfd_reloc_overflow;
131 else
132 return bfd_reloc_ok;
133}
134
135/* Handle the HIX22 reloc. */
136
137static bfd_reloc_status_type
138sparc_elf_hix22_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
139 PTR data, asection *input_section, bfd *output_bfd,
140 char **error_message ATTRIBUTE_UNUSED)
141{
142 bfd_vma relocation;
143 bfd_vma insn;
144 bfd_reloc_status_type status;
145
146 status = init_insn_reloc (abfd, reloc_entry, symbol, data,
147 input_section, output_bfd, &relocation, &insn);
148 if (status != bfd_reloc_other)
149 return status;
150
151 relocation ^= MINUS_ONE;
152 insn = (insn &~ (bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
153 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
154
155 if ((relocation & ~ (bfd_vma) 0xffffffff) != 0)
156 return bfd_reloc_overflow;
157 else
158 return bfd_reloc_ok;
159}
160
161/* Handle the LOX10 reloc. */
162
163static bfd_reloc_status_type
164sparc_elf_lox10_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
165 PTR data, asection *input_section, bfd *output_bfd,
166 char **error_message ATTRIBUTE_UNUSED)
167{
168 bfd_vma relocation;
169 bfd_vma insn;
170 bfd_reloc_status_type status;
171
172 status = init_insn_reloc (abfd, reloc_entry, symbol, data,
173 input_section, output_bfd, &relocation, &insn);
174 if (status != bfd_reloc_other)
175 return status;
176
177 insn = (insn &~ (bfd_vma) 0x1fff) | 0x1c00 | (relocation & 0x3ff);
178 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
179
180 return bfd_reloc_ok;
181}
182
183static reloc_howto_type _bfd_sparc_elf_howto_table[] =
184{
185 HOWTO(R_SPARC_NONE, 0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", FALSE,0,0x00000000,TRUE),
186 HOWTO(R_SPARC_8, 0,0, 8,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_8", FALSE,0,0x000000ff,TRUE),
187 HOWTO(R_SPARC_16, 0,1,16,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_16", FALSE,0,0x0000ffff,TRUE),
188 HOWTO(R_SPARC_32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_32", FALSE,0,0xffffffff,TRUE),
189 HOWTO(R_SPARC_DISP8, 0,0, 8,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP8", FALSE,0,0x000000ff,TRUE),
190 HOWTO(R_SPARC_DISP16, 0,1,16,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP16", FALSE,0,0x0000ffff,TRUE),
191 HOWTO(R_SPARC_DISP32, 0,2,32,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP32", FALSE,0,0xffffffff,TRUE),
192 HOWTO(R_SPARC_WDISP30, 2,2,30,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP30", FALSE,0,0x3fffffff,TRUE),
193 HOWTO(R_SPARC_WDISP22, 2,2,22,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP22", FALSE,0,0x003fffff,TRUE),
194 HOWTO(R_SPARC_HI22, 10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_HI22", FALSE,0,0x003fffff,TRUE),
195 HOWTO(R_SPARC_22, 0,2,22,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_22", FALSE,0,0x003fffff,TRUE),
196 HOWTO(R_SPARC_13, 0,2,13,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_13", FALSE,0,0x00001fff,TRUE),
197 HOWTO(R_SPARC_LO10, 0,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_LO10", FALSE,0,0x000003ff,TRUE),
198 HOWTO(R_SPARC_GOT10, 0,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOT10", FALSE,0,0x000003ff,TRUE),
199 HOWTO(R_SPARC_GOT13, 0,2,13,FALSE,0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_GOT13", FALSE,0,0x00001fff,TRUE),
200 HOWTO(R_SPARC_GOT22, 10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOT22", FALSE,0,0x003fffff,TRUE),
201 HOWTO(R_SPARC_PC10, 0,2,10,TRUE, 0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_PC10", FALSE,0,0x000003ff,TRUE),
202 HOWTO(R_SPARC_PC22, 10,2,22,TRUE, 0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_PC22", FALSE,0,0x003fffff,TRUE),
203 HOWTO(R_SPARC_WPLT30, 2,2,30,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WPLT30", FALSE,0,0x3fffffff,TRUE),
204 HOWTO(R_SPARC_COPY, 0,0,00,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_COPY", FALSE,0,0x00000000,TRUE),
205 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),
206 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),
207 HOWTO(R_SPARC_RELATIVE, 0,0,00,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_RELATIVE",FALSE,0,0x00000000,TRUE),
208 HOWTO(R_SPARC_UA32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA32", FALSE,0,0xffffffff,TRUE),
209 HOWTO(R_SPARC_PLT32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_PLT32", FALSE,0,0xffffffff,TRUE),
210 HOWTO(R_SPARC_HIPLT22, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_HIPLT22", FALSE,0,0x00000000,TRUE),
211 HOWTO(R_SPARC_LOPLT10, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_LOPLT10", FALSE,0,0x00000000,TRUE),
212 HOWTO(R_SPARC_PCPLT32, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PCPLT32", FALSE,0,0x00000000,TRUE),
213 HOWTO(R_SPARC_PCPLT22, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PCPLT22", FALSE,0,0x00000000,TRUE),
214 HOWTO(R_SPARC_PCPLT10, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PCPLT10", FALSE,0,0x00000000,TRUE),
215 HOWTO(R_SPARC_10, 0,2,10,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_10", FALSE,0,0x000003ff,TRUE),
216 HOWTO(R_SPARC_11, 0,2,11,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_11", FALSE,0,0x000007ff,TRUE),
217 HOWTO(R_SPARC_64, 0,4,64,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_64", FALSE,0,MINUS_ONE, TRUE),
218 HOWTO(R_SPARC_OLO10, 0,2,13,FALSE,0,complain_overflow_signed, sparc_elf_notsup_reloc, "R_SPARC_OLO10", FALSE,0,0x00001fff,TRUE),
219 HOWTO(R_SPARC_HH22, 42,2,22,FALSE,0,complain_overflow_unsigned,bfd_elf_generic_reloc, "R_SPARC_HH22", FALSE,0,0x003fffff,TRUE),
220 HOWTO(R_SPARC_HM10, 32,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_HM10", FALSE,0,0x000003ff,TRUE),
221 HOWTO(R_SPARC_LM22, 10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_LM22", FALSE,0,0x003fffff,TRUE),
222 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),
223 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),
224 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),
225 HOWTO(R_SPARC_WDISP16, 2,2,16,TRUE, 0,complain_overflow_signed, sparc_elf_wdisp16_reloc,"R_SPARC_WDISP16", FALSE,0,0x00000000,TRUE),
226 HOWTO(R_SPARC_WDISP19, 2,2,19,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP19", FALSE,0,0x0007ffff,TRUE),
227 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),
228 HOWTO(R_SPARC_7, 0,2, 7,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_7", FALSE,0,0x0000007f,TRUE),
229 HOWTO(R_SPARC_5, 0,2, 5,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_5", FALSE,0,0x0000001f,TRUE),
230 HOWTO(R_SPARC_6, 0,2, 6,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_6", FALSE,0,0x0000003f,TRUE),
231 HOWTO(R_SPARC_DISP64, 0,4,64,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP64", FALSE,0,MINUS_ONE, TRUE),
232 HOWTO(R_SPARC_PLT64, 0,4,64,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_PLT64", FALSE,0,MINUS_ONE, TRUE),
233 HOWTO(R_SPARC_HIX22, 0,4, 0,FALSE,0,complain_overflow_bitfield,sparc_elf_hix22_reloc, "R_SPARC_HIX22", FALSE,0,MINUS_ONE, FALSE),
234 HOWTO(R_SPARC_LOX10, 0,4, 0,FALSE,0,complain_overflow_dont, sparc_elf_lox10_reloc, "R_SPARC_LOX10", FALSE,0,MINUS_ONE, FALSE),
235 HOWTO(R_SPARC_H44, 22,2,22,FALSE,0,complain_overflow_unsigned,bfd_elf_generic_reloc, "R_SPARC_H44", FALSE,0,0x003fffff,FALSE),
236 HOWTO(R_SPARC_M44, 12,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_M44", FALSE,0,0x000003ff,FALSE),
237 HOWTO(R_SPARC_L44, 0,2,13,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_L44", FALSE,0,0x00000fff,FALSE),
238 HOWTO(R_SPARC_REGISTER, 0,4, 0,FALSE,0,complain_overflow_bitfield,sparc_elf_notsup_reloc, "R_SPARC_REGISTER",FALSE,0,MINUS_ONE, FALSE),
239 HOWTO(R_SPARC_UA64, 0,4,64,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA64", FALSE,0,MINUS_ONE, TRUE),
240 HOWTO(R_SPARC_UA16, 0,1,16,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA16", FALSE,0,0x0000ffff,TRUE),
241 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),
242 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),
243 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),
244 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),
245 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),
246 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),
247 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),
248 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),
249 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),
250 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),
251 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),
252 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),
253 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),
254 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),
255 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),
256 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),
257 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),
258 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),
259 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),
260 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),
261 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),
262 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),
263 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),
739f7f82
DM		 264 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),
265 HOWTO(R_SPARC_GOTDATA_HIX22,0,2,0,FALSE,0,complain_overflow_bitfield,sparc_elf_hix22_reloc,"R_SPARC_GOTDATA_HIX22",FALSE,0,0x003fffff, FALSE),
266 HOWTO(R_SPARC_GOTDATA_LOX10,0,2,0,FALSE,0,complain_overflow_dont, sparc_elf_lox10_reloc, "R_SPARC_GOTDATA_LOX10",FALSE,0,0x000003ff, FALSE),
267 HOWTO(R_SPARC_GOTDATA_OP_HIX22,0,2,0,FALSE,0,complain_overflow_bitfield,sparc_elf_hix22_reloc,"R_SPARC_GOTDATA_OP_HIX22",FALSE,0,0x003fffff, FALSE),
268 HOWTO(R_SPARC_GOTDATA_OP_LOX10,0,2,0,FALSE,0,complain_overflow_dont, sparc_elf_lox10_reloc, "R_SPARC_GOTDATA_OP_LOX10",FALSE,0,0x000003ff, FALSE),
269 HOWTO(R_SPARC_GOTDATA_OP,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOTDATA_OP",FALSE,0,0x00000000,TRUE),
22b75d0a 270};
d0c9aeb3
DM		 271static reloc_howto_type sparc_jmp_irel_howto =
272 HOWTO(R_SPARC_JMP_IREL, 0,0,00,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_JMP_IREL",FALSE,0,0x00000000,TRUE);
273static reloc_howto_type sparc_irelative_howto =
274 HOWTO(R_SPARC_IRELATIVE, 0,0,00,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_IRELATIVE",FALSE,0,0x00000000,TRUE);
22b75d0a
DM		 275static reloc_howto_type sparc_vtinherit_howto =
276 HOWTO (R_SPARC_GNU_VTINHERIT, 0,2,0,FALSE,0,complain_overflow_dont, NULL, "R_SPARC_GNU_VTINHERIT", FALSE,0, 0, FALSE);
277static reloc_howto_type sparc_vtentry_howto =
278 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);
279static reloc_howto_type sparc_rev32_howto =
280 HOWTO(R_SPARC_REV32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_REV32", FALSE,0,0xffffffff,TRUE);
281
22b75d0a
DM		 282reloc_howto_type *
283_bfd_sparc_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
284 bfd_reloc_code_real_type code)
285{
679b7c76
DM		 286 /* We explicitly handle each relocation type in the switch
287 instead of using a lookup table for efficiency. */
22b75d0a
DM		 288 switch (code)
289 {
679b7c76
DM		 290 case BFD_RELOC_NONE:
291 return &_bfd_sparc_elf_howto_table[R_SPARC_NONE];
292
293 case BFD_RELOC_8:
294 return &_bfd_sparc_elf_howto_table[R_SPARC_8];
295
296 case BFD_RELOC_16:
297 return &_bfd_sparc_elf_howto_table[R_SPARC_16];
298
299 case BFD_RELOC_32:
300 return &_bfd_sparc_elf_howto_table[R_SPARC_32];
301
302 case BFD_RELOC_8_PCREL:
303 return &_bfd_sparc_elf_howto_table[R_SPARC_DISP8];
304
305 case BFD_RELOC_16_PCREL:
306 return &_bfd_sparc_elf_howto_table[R_SPARC_DISP16];
307
308 case BFD_RELOC_32_PCREL:
309 return &_bfd_sparc_elf_howto_table[R_SPARC_DISP32];
310
311 case BFD_RELOC_32_PCREL_S2:
312 return &_bfd_sparc_elf_howto_table[R_SPARC_WDISP30];
313
314 case BFD_RELOC_SPARC_WDISP22:
315 return &_bfd_sparc_elf_howto_table[R_SPARC_WDISP22];
316
317 case BFD_RELOC_HI22:
318 return &_bfd_sparc_elf_howto_table[R_SPARC_HI22];
319
320 case BFD_RELOC_SPARC22:
321 return &_bfd_sparc_elf_howto_table[R_SPARC_22];
322
323 case BFD_RELOC_SPARC13:
324 return &_bfd_sparc_elf_howto_table[R_SPARC_13];
325
326 case BFD_RELOC_LO10:
327 return &_bfd_sparc_elf_howto_table[R_SPARC_LO10];
328
329 case BFD_RELOC_SPARC_GOT10:
330 return &_bfd_sparc_elf_howto_table[R_SPARC_GOT10];
331
332 case BFD_RELOC_SPARC_GOT13:
333 return &_bfd_sparc_elf_howto_table[R_SPARC_GOT13];
334
335 case BFD_RELOC_SPARC_GOT22:
336 return &_bfd_sparc_elf_howto_table[R_SPARC_GOT22];
337
338 case BFD_RELOC_SPARC_PC10:
339 return &_bfd_sparc_elf_howto_table[R_SPARC_PC10];
340
341 case BFD_RELOC_SPARC_PC22:
342 return &_bfd_sparc_elf_howto_table[R_SPARC_PC22];
343
344 case BFD_RELOC_SPARC_WPLT30:
345 return &_bfd_sparc_elf_howto_table[R_SPARC_WPLT30];
346
347 case BFD_RELOC_SPARC_COPY:
348 return &_bfd_sparc_elf_howto_table[R_SPARC_COPY];
349
350 case BFD_RELOC_SPARC_GLOB_DAT:
351 return &_bfd_sparc_elf_howto_table[R_SPARC_GLOB_DAT];
352
353 case BFD_RELOC_SPARC_JMP_SLOT:
354 return &_bfd_sparc_elf_howto_table[R_SPARC_JMP_SLOT];
355
356 case BFD_RELOC_SPARC_RELATIVE:
357 return &_bfd_sparc_elf_howto_table[R_SPARC_RELATIVE];
358
359 case BFD_RELOC_SPARC_UA32:
360 return &_bfd_sparc_elf_howto_table[R_SPARC_UA32];
361
362 case BFD_RELOC_SPARC_PLT32:
363 return &_bfd_sparc_elf_howto_table[R_SPARC_PLT32];
364
365 case BFD_RELOC_SPARC_10:
366 return &_bfd_sparc_elf_howto_table[R_SPARC_10];
367
368 case BFD_RELOC_SPARC_11:
369 return &_bfd_sparc_elf_howto_table[R_SPARC_11];
370
371 case BFD_RELOC_SPARC_64:
372 return &_bfd_sparc_elf_howto_table[R_SPARC_64];
373
374 case BFD_RELOC_SPARC_OLO10:
375 return &_bfd_sparc_elf_howto_table[R_SPARC_OLO10];
376
377 case BFD_RELOC_SPARC_HH22:
378 return &_bfd_sparc_elf_howto_table[R_SPARC_HH22];
379
380 case BFD_RELOC_SPARC_HM10:
381 return &_bfd_sparc_elf_howto_table[R_SPARC_HM10];
382
383 case BFD_RELOC_SPARC_LM22:
384 return &_bfd_sparc_elf_howto_table[R_SPARC_LM22];
385
386 case BFD_RELOC_SPARC_PC_HH22:
387 return &_bfd_sparc_elf_howto_table[R_SPARC_PC_HH22];
388
389 case BFD_RELOC_SPARC_PC_HM10:
390 return &_bfd_sparc_elf_howto_table[R_SPARC_PC_HM10];
391
392 case BFD_RELOC_SPARC_PC_LM22:
393 return &_bfd_sparc_elf_howto_table[R_SPARC_PC_LM22];
394
395 case BFD_RELOC_SPARC_WDISP16:
396 return &_bfd_sparc_elf_howto_table[R_SPARC_WDISP16];
397
398 case BFD_RELOC_SPARC_WDISP19:
399 return &_bfd_sparc_elf_howto_table[R_SPARC_WDISP19];
400
401 case BFD_RELOC_SPARC_7:
402 return &_bfd_sparc_elf_howto_table[R_SPARC_7];
403
404 case BFD_RELOC_SPARC_5:
405 return &_bfd_sparc_elf_howto_table[R_SPARC_5];
406
407 case BFD_RELOC_SPARC_6:
408 return &_bfd_sparc_elf_howto_table[R_SPARC_6];
409
410 case BFD_RELOC_SPARC_DISP64:
411 return &_bfd_sparc_elf_howto_table[R_SPARC_DISP64];
412
413 case BFD_RELOC_SPARC_PLT64:
414 return &_bfd_sparc_elf_howto_table[R_SPARC_PLT64];
415
416 case BFD_RELOC_SPARC_HIX22:
417 return &_bfd_sparc_elf_howto_table[R_SPARC_HIX22];
418
419 case BFD_RELOC_SPARC_LOX10:
420 return &_bfd_sparc_elf_howto_table[R_SPARC_LOX10];
421
422 case BFD_RELOC_SPARC_H44:
423 return &_bfd_sparc_elf_howto_table[R_SPARC_H44];
424
425 case BFD_RELOC_SPARC_M44:
426 return &_bfd_sparc_elf_howto_table[R_SPARC_M44];
427
428 case BFD_RELOC_SPARC_L44:
429 return &_bfd_sparc_elf_howto_table[R_SPARC_L44];
430
431 case BFD_RELOC_SPARC_REGISTER:
432 return &_bfd_sparc_elf_howto_table[R_SPARC_REGISTER];
433
434 case BFD_RELOC_SPARC_UA64:
435 return &_bfd_sparc_elf_howto_table[R_SPARC_UA64];
436
437 case BFD_RELOC_SPARC_UA16:
438 return &_bfd_sparc_elf_howto_table[R_SPARC_UA16];
439
440 case BFD_RELOC_SPARC_TLS_GD_HI22:
441 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_GD_HI22];
442
443 case BFD_RELOC_SPARC_TLS_GD_LO10:
444 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_GD_LO10];
445
446 case BFD_RELOC_SPARC_TLS_GD_ADD:
447 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_GD_ADD];
448
449 case BFD_RELOC_SPARC_TLS_GD_CALL:
450 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_GD_CALL];
451
452 case BFD_RELOC_SPARC_TLS_LDM_HI22:
453 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDM_HI22];
454
455 case BFD_RELOC_SPARC_TLS_LDM_LO10:
456 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDM_LO10];
457
458 case BFD_RELOC_SPARC_TLS_LDM_ADD:
459 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDM_ADD];
460
461 case BFD_RELOC_SPARC_TLS_LDM_CALL:
462 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDM_CALL];
463
464 case BFD_RELOC_SPARC_TLS_LDO_HIX22:
465 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDO_HIX22];
466
467 case BFD_RELOC_SPARC_TLS_LDO_LOX10:
468 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDO_LOX10];
469
470 case BFD_RELOC_SPARC_TLS_LDO_ADD:
471 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDO_ADD];
472
473 case BFD_RELOC_SPARC_TLS_IE_HI22:
474 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_IE_HI22];
475
476 case BFD_RELOC_SPARC_TLS_IE_LO10:
477 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_IE_LO10];
478
479 case BFD_RELOC_SPARC_TLS_IE_LD:
480 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_IE_LD];
481
482 case BFD_RELOC_SPARC_TLS_IE_LDX:
483 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_IE_LDX];
484
485 case BFD_RELOC_SPARC_TLS_IE_ADD:
486 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_IE_ADD];
487
488 case BFD_RELOC_SPARC_TLS_LE_HIX22:
489 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LE_HIX22];
490
491 case BFD_RELOC_SPARC_TLS_LE_LOX10:
492 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LE_LOX10];
493
494 case BFD_RELOC_SPARC_TLS_DTPMOD32:
495 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_DTPMOD32];
496
497 case BFD_RELOC_SPARC_TLS_DTPMOD64:
498 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_DTPMOD64];
499
500 case BFD_RELOC_SPARC_TLS_DTPOFF32:
501 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_DTPOFF32];
502
503 case BFD_RELOC_SPARC_TLS_DTPOFF64:
504 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_DTPOFF64];
505
506 case BFD_RELOC_SPARC_TLS_TPOFF32:
507 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_TPOFF32];
508
509 case BFD_RELOC_SPARC_TLS_TPOFF64:
510 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_TPOFF64];
511
512 case BFD_RELOC_SPARC_GOTDATA_HIX22:
513 return &_bfd_sparc_elf_howto_table[R_SPARC_GOTDATA_HIX22];
514
515 case BFD_RELOC_SPARC_GOTDATA_LOX10:
516 return &_bfd_sparc_elf_howto_table[R_SPARC_GOTDATA_LOX10];
517
518 case BFD_RELOC_SPARC_GOTDATA_OP_HIX22:
519 return &_bfd_sparc_elf_howto_table[R_SPARC_GOTDATA_OP_HIX22];
520
521 case BFD_RELOC_SPARC_GOTDATA_OP_LOX10:
522 return &_bfd_sparc_elf_howto_table[R_SPARC_GOTDATA_OP_LOX10];
523
524 case BFD_RELOC_SPARC_GOTDATA_OP:
525 return &_bfd_sparc_elf_howto_table[R_SPARC_GOTDATA_OP];
526
d0c9aeb3
DM		 527 case BFD_RELOC_SPARC_JMP_IREL:
528 return &sparc_jmp_irel_howto;
529
530 case BFD_RELOC_SPARC_IRELATIVE:
531 return &sparc_irelative_howto;
532
22b75d0a
DM		 533 case BFD_RELOC_VTABLE_INHERIT:
534 return &sparc_vtinherit_howto;
535
536 case BFD_RELOC_VTABLE_ENTRY:
537 return &sparc_vtentry_howto;
538
539 case BFD_RELOC_SPARC_REV32:
540 return &sparc_rev32_howto;
541
542 default:
679b7c76 543 break;
22b75d0a
DM		 544 }
545 bfd_set_error (bfd_error_bad_value);
546 return NULL;
547}
548
157090f7
AM		 549reloc_howto_type *
550_bfd_sparc_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
551 const char *r_name)
552{
553 unsigned int i;
554
555 for (i = 0;
556 i < (sizeof (_bfd_sparc_elf_howto_table)
557 / sizeof (_bfd_sparc_elf_howto_table[0]));
558 i++)
559 if (_bfd_sparc_elf_howto_table[i].name != NULL
560 && strcasecmp (_bfd_sparc_elf_howto_table[i].name, r_name) == 0)
561 return &_bfd_sparc_elf_howto_table[i];
562
563 if (strcasecmp (sparc_vtinherit_howto.name, r_name) == 0)
564 return &sparc_vtinherit_howto;
565 if (strcasecmp (sparc_vtentry_howto.name, r_name) == 0)
566 return &sparc_vtentry_howto;
567 if (strcasecmp (sparc_rev32_howto.name, r_name) == 0)
568 return &sparc_rev32_howto;
569
570 return NULL;
571}
572
22b75d0a
DM		 573reloc_howto_type *
574_bfd_sparc_elf_info_to_howto_ptr (unsigned int r_type)
575{
576 switch (r_type)
577 {
d0c9aeb3
DM		 578 case R_SPARC_JMP_IREL:
579 return &sparc_jmp_irel_howto;
580
581 case R_SPARC_IRELATIVE:
582 return &sparc_irelative_howto;
583
22b75d0a
DM		 584 case R_SPARC_GNU_VTINHERIT:
585 return &sparc_vtinherit_howto;
586
587 case R_SPARC_GNU_VTENTRY:
588 return &sparc_vtentry_howto;
589
590 case R_SPARC_REV32:
591 return &sparc_rev32_howto;
592
593 default:
d0fb9a8d
JJ		 594 if (r_type >= (unsigned int) R_SPARC_max_std)
595 {
596 (*_bfd_error_handler) (_("invalid relocation type %d"),
597 (int) r_type);
598 r_type = R_SPARC_NONE;
599 }
22b75d0a
DM		 600 return &_bfd_sparc_elf_howto_table[r_type];
601 }
602}
603
604/* Both 32-bit and 64-bit sparc encode this in an identical manner,
605 so just take advantage of that. */
606#define SPARC_ELF_R_TYPE(r_info) \
607 ((r_info) & 0xff)
608
609void
610_bfd_sparc_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
611 Elf_Internal_Rela *dst)
612{
613 unsigned int r_type = SPARC_ELF_R_TYPE (dst->r_info);
614
615 cache_ptr->howto = _bfd_sparc_elf_info_to_howto_ptr (r_type);
616}
617\f
618
619/* The nop opcode we use. */
620#define SPARC_NOP 0x01000000
621
622#define SPARC_INSN_BYTES 4
623
624/* The SPARC linker needs to keep track of the number of relocs that it
625 decides to copy as dynamic relocs in check_relocs for each symbol.
626 This is so that it can later discard them if they are found to be
627 unnecessary. We store the information in a field extending the
628 regular ELF linker hash table. */
629
630struct _bfd_sparc_elf_dyn_relocs
631{
632 struct _bfd_sparc_elf_dyn_relocs *next;
633
634 /* The input section of the reloc. */
635 asection *sec;
636
637 /* Total number of relocs copied for the input section. */
638 bfd_size_type count;
639
640 /* Number of pc-relative relocs copied for the input section. */
641 bfd_size_type pc_count;
642};
643
644/* SPARC ELF linker hash entry. */
645
646struct _bfd_sparc_elf_link_hash_entry
647{
648 struct elf_link_hash_entry elf;
649
650 /* Track dynamic relocs copied for this symbol. */
651 struct _bfd_sparc_elf_dyn_relocs *dyn_relocs;
652
653#define GOT_UNKNOWN 0
654#define GOT_NORMAL 1
655#define GOT_TLS_GD 2
656#define GOT_TLS_IE 3
657 unsigned char tls_type;
658};
659
660#define _bfd_sparc_elf_hash_entry(ent) ((struct _bfd_sparc_elf_link_hash_entry *)(ent))
661
662struct _bfd_sparc_elf_obj_tdata
663{
664 struct elf_obj_tdata root;
665
666 /* tls_type for each local got entry. */
667 char *local_got_tls_type;
668
669 /* TRUE if TLS GD relocs has been seen for this object. */
670 bfd_boolean has_tlsgd;
671};
672
673#define _bfd_sparc_elf_tdata(abfd) \
674 ((struct _bfd_sparc_elf_obj_tdata *) (abfd)->tdata.any)
675
676#define _bfd_sparc_elf_local_got_tls_type(abfd) \
677 (_bfd_sparc_elf_tdata (abfd)->local_got_tls_type)
678
0ffa91dd
NC		 679#define is_sparc_elf(bfd) \
680 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
681 && elf_tdata (bfd) != NULL \
4dfe6ac6 682 && elf_object_id (bfd) == SPARC_ELF_DATA)
0ffa91dd 683
22b75d0a
DM		 684bfd_boolean
685_bfd_sparc_elf_mkobject (bfd *abfd)
686{
0ffa91dd 687 return bfd_elf_allocate_object (abfd, sizeof (struct _bfd_sparc_elf_obj_tdata),
4dfe6ac6 688 SPARC_ELF_DATA);
22b75d0a
DM		 689}
690
691static void
91d6fa6a 692sparc_put_word_32 (bfd *abfd, bfd_vma val, void *ptr)
22b75d0a 693{
91d6fa6a 694 bfd_put_32 (abfd, val, ptr);
22b75d0a
DM		 695}
696
697static void
91d6fa6a 698sparc_put_word_64 (bfd *abfd, bfd_vma val, void *ptr)
22b75d0a 699{
91d6fa6a 700 bfd_put_64 (abfd, val, ptr);
22b75d0a
DM		 701}
702
703static void
39817122 704sparc_elf_append_rela (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
22b75d0a 705{
39817122
RS		 706 const struct elf_backend_data *bed;
707 bfd_byte *loc;
22b75d0a 708
39817122
RS		 709 bed = get_elf_backend_data (abfd);
710 loc = s->contents + (s->reloc_count++ * bed->s->sizeof_rela);
711 bed->s->swap_reloca_out (abfd, rel, loc);
22b75d0a
DM		 712}
713
714static bfd_vma
e459dc7b 715sparc_elf_r_info_64 (Elf_Internal_Rela *in_rel ATTRIBUTE_UNUSED,
91d6fa6a 716 bfd_vma rel_index ATTRIBUTE_UNUSED,
e459dc7b 717 bfd_vma type ATTRIBUTE_UNUSED)
22b75d0a 718{
91d6fa6a 719 return ELF64_R_INFO (rel_index,
22b75d0a
DM		 720 (in_rel ?
721 ELF64_R_TYPE_INFO (ELF64_R_TYPE_DATA (in_rel->r_info),
722 type) : type));
723}
724
725static bfd_vma
726sparc_elf_r_info_32 (Elf_Internal_Rela *in_rel ATTRIBUTE_UNUSED,
91d6fa6a 727 bfd_vma rel_index, bfd_vma type)
22b75d0a 728{
91d6fa6a 729 return ELF32_R_INFO (rel_index, type);
22b75d0a
DM		 730}
731
732static bfd_vma
733sparc_elf_r_symndx_64 (bfd_vma r_info)
734{
e8be8da4
DM		 735 bfd_vma r_symndx = ELF32_R_SYM (r_info);
736 return (r_symndx >> 24);
22b75d0a
DM		 737}
738
739static bfd_vma
740sparc_elf_r_symndx_32 (bfd_vma r_info)
741{
742 return ELF32_R_SYM (r_info);
743}
744
745/* PLT/GOT stuff */
746
747#define PLT32_ENTRY_SIZE 12
748#define PLT32_HEADER_SIZE (4 * PLT32_ENTRY_SIZE)
749
750/* The first four entries in a 32-bit procedure linkage table are reserved,
751 and the initial contents are unimportant (we zero them out).
752 Subsequent entries look like this. See the SVR4 ABI SPARC
753 supplement to see how this works. */
754
755/* sethi %hi(.-.plt0),%g1. We fill in the address later. */
756#define PLT32_ENTRY_WORD0 0x03000000
757/* b,a .plt0. We fill in the offset later. */
758#define PLT32_ENTRY_WORD1 0x30800000
759/* nop. */
760#define PLT32_ENTRY_WORD2 SPARC_NOP
761
762static int
763sparc32_plt_entry_build (bfd *output_bfd, asection *splt, bfd_vma offset,
764 bfd_vma max ATTRIBUTE_UNUSED,
765 bfd_vma *r_offset)
766{
767 bfd_put_32 (output_bfd,
768 PLT32_ENTRY_WORD0 + offset,
769 splt->contents + offset);
770 bfd_put_32 (output_bfd,
771 (PLT32_ENTRY_WORD1
772 + (((- (offset + 4)) >> 2) & 0x3fffff)),
773 splt->contents + offset + 4);
774 bfd_put_32 (output_bfd, (bfd_vma) PLT32_ENTRY_WORD2,
775 splt->contents + offset + 8);
776
777 *r_offset = offset;
778
779 return offset / PLT32_ENTRY_SIZE - 4;
780}
781
782/* Both the headers and the entries are icache aligned. */
783#define PLT64_ENTRY_SIZE 32
784#define PLT64_HEADER_SIZE (4 * PLT64_ENTRY_SIZE)
785#define PLT64_LARGE_THRESHOLD 32768
786
787static int
788sparc64_plt_entry_build (bfd *output_bfd, asection *splt, bfd_vma offset,
789 bfd_vma max, bfd_vma *r_offset)
790{
791 unsigned char *entry = splt->contents + offset;
792 const unsigned int nop = SPARC_NOP;
91d6fa6a 793 int plt_index;
22b75d0a
DM		 794
795 if (offset < (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE))
796 {
797 unsigned int sethi, ba;
798
799 *r_offset = offset;
800
91d6fa6a 801 plt_index = (offset / PLT64_ENTRY_SIZE);
22b75d0a 802
91d6fa6a 803 sethi = 0x03000000 | (plt_index * PLT64_ENTRY_SIZE);
22b75d0a
DM		 804 ba = 0x30680000
805 | (((splt->contents + PLT64_ENTRY_SIZE) - (entry + 4)) / 4 & 0x7ffff);
806
807 bfd_put_32 (output_bfd, (bfd_vma) sethi, entry);
808 bfd_put_32 (output_bfd, (bfd_vma) ba, entry + 4);
809 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 8);
810 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 12);
811 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 16);
812 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 20);
813 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 24);
814 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 28);
815 }
816 else
817 {
818 unsigned char *ptr;
819 unsigned int ldx;
820 int block, last_block, ofs, last_ofs, chunks_this_block;
821 const int insn_chunk_size = (6 * 4);
822 const int ptr_chunk_size = (1 * 8);
823 const int entries_per_block = 160;
824 const int block_size = entries_per_block * (insn_chunk_size
825 + ptr_chunk_size);
826
827 /* Entries 32768 and higher are grouped into blocks of 160.
828 The blocks are further subdivided into 160 sequences of
829 6 instructions and 160 pointers. If a block does not require
830 the full 160 entries, let's say it requires N, then there
831 will be N sequences of 6 instructions and N pointers. */
832
833 offset -= (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE);
834 max -= (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE);
835
836 block = offset / block_size;
837 last_block = max / block_size;
838 if (block != last_block)
839 {
840 chunks_this_block = 160;
841 }
842 else
843 {
844 last_ofs = max % block_size;
845 chunks_this_block = last_ofs / (insn_chunk_size + ptr_chunk_size);
846 }
847
848 ofs = offset % block_size;
849
91d6fa6a 850 plt_index = (PLT64_LARGE_THRESHOLD +
22b75d0a
DM		 851 (block * 160) +
852 (ofs / insn_chunk_size));
853
854 ptr = splt->contents
855 + (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE)
856 + (block * block_size)
857 + (chunks_this_block * insn_chunk_size)
858 + (ofs / insn_chunk_size) * ptr_chunk_size;
859
860 *r_offset = (bfd_vma) (ptr - splt->contents);
861
862 ldx = 0xc25be000 | ((ptr - (entry+4)) & 0x1fff);
863
864 /* mov %o7,%g5
865 call .+8
866 nop
867 ldx [%o7+P],%g1
868 jmpl %o7+%g1,%g1
869 mov %g5,%o7 */
870 bfd_put_32 (output_bfd, (bfd_vma) 0x8a10000f, entry);
871 bfd_put_32 (output_bfd, (bfd_vma) 0x40000002, entry + 4);
872 bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP, entry + 8);
873 bfd_put_32 (output_bfd, (bfd_vma) ldx, entry + 12);
874 bfd_put_32 (output_bfd, (bfd_vma) 0x83c3c001, entry + 16);
875 bfd_put_32 (output_bfd, (bfd_vma) 0x9e100005, entry + 20);
876
877 bfd_put_64 (output_bfd, (bfd_vma) (splt->contents - (entry + 4)), ptr);
878 }
879
91d6fa6a 880 return plt_index - 4;
22b75d0a
DM		 881}
882
910600e9
RS		 883/* The format of the first PLT entry in a VxWorks executable. */
884static const bfd_vma sparc_vxworks_exec_plt0_entry[] =
885 {
886 0x05000000, /* sethi %hi(_GLOBAL_OFFSET_TABLE_+8), %g2 */
887 0x8410a000, /* or %g2, %lo(_GLOBAL_OFFSET_TABLE_+8), %g2 */
888 0xc4008000, /* ld [ %g2 ], %g2 */
889 0x81c08000, /* jmp %g2 */
890 0x01000000 /* nop */
891 };
892
893/* The format of subsequent PLT entries. */
894static const bfd_vma sparc_vxworks_exec_plt_entry[] =
895 {
896 0x03000000, /* sethi %hi(_GLOBAL_OFFSET_TABLE_+f@got), %g1 */
897 0x82106000, /* or %g1, %lo(_GLOBAL_OFFSET_TABLE_+f@got), %g1 */
898 0xc2004000, /* ld [ %g1 ], %g1 */
899 0x81c04000, /* jmp %g1 */
900 0x01000000, /* nop */
901 0x03000000, /* sethi %hi(f@pltindex), %g1 */
902 0x10800000, /* b _PLT_resolve */
903 0x82106000 /* or %g1, %lo(f@pltindex), %g1 */
904 };
905
906/* The format of the first PLT entry in a VxWorks shared object. */
907static const bfd_vma sparc_vxworks_shared_plt0_entry[] =
908 {
909 0xc405e008, /* ld [ %l7 + 8 ], %g2 */
910 0x81c08000, /* jmp %g2 */
911 0x01000000 /* nop */
912 };
913
914/* The format of subsequent PLT entries. */
915static const bfd_vma sparc_vxworks_shared_plt_entry[] =
916 {
917 0x03000000, /* sethi %hi(f@got), %g1 */
918 0x82106000, /* or %g1, %lo(f@got), %g1 */
919 0xc205c001, /* ld [ %l7 + %g1 ], %g1 */
920 0x81c04000, /* jmp %g1 */
921 0x01000000, /* nop */
922 0x03000000, /* sethi %hi(f@pltindex), %g1 */
923 0x10800000, /* b _PLT_resolve */
924 0x82106000 /* or %g1, %lo(f@pltindex), %g1 */
925 };
926
22b75d0a
DM		 927#define SPARC_ELF_PUT_WORD(htab, bfd, val, ptr) \
928 htab->put_word(bfd, val, ptr)
929
22b75d0a
DM		 930#define SPARC_ELF_R_INFO(htab, in_rel, index, type) \
931 htab->r_info(in_rel, index, type)
932
933#define SPARC_ELF_R_SYMNDX(htab, r_info) \
934 htab->r_symndx(r_info)
935
936#define SPARC_ELF_WORD_BYTES(htab) \
937 htab->bytes_per_word
938
939#define SPARC_ELF_RELA_BYTES(htab) \
940 htab->bytes_per_rela
941
942#define SPARC_ELF_DTPOFF_RELOC(htab) \
943 htab->dtpoff_reloc
944
945#define SPARC_ELF_DTPMOD_RELOC(htab) \
946 htab->dtpmod_reloc
947
948#define SPARC_ELF_TPOFF_RELOC(htab) \
949 htab->tpoff_reloc
950
951#define SPARC_ELF_BUILD_PLT_ENTRY(htab, obfd, splt, off, max, r_off) \
952 htab->build_plt_entry (obfd, splt, off, max, r_off)
953
954/* Create an entry in an SPARC ELF linker hash table. */
955
956static struct bfd_hash_entry *
957link_hash_newfunc (struct bfd_hash_entry *entry,
958 struct bfd_hash_table *table, const char *string)
959{
960 /* Allocate the structure if it has not already been allocated by a
961 subclass. */
962 if (entry == NULL)
963 {
964 entry = bfd_hash_allocate (table,
965 sizeof (struct _bfd_sparc_elf_link_hash_entry));
966 if (entry == NULL)
967 return entry;
968 }
969
970 /* Call the allocation method of the superclass. */
971 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
972 if (entry != NULL)
973 {
974 struct _bfd_sparc_elf_link_hash_entry *eh;
975
976 eh = (struct _bfd_sparc_elf_link_hash_entry *) entry;
977 eh->dyn_relocs = NULL;
978 eh->tls_type = GOT_UNKNOWN;
979 }
980
981 return entry;
982}
983
984/* The name of the dynamic interpreter. This is put in the .interp
985 section. */
986
987#define ELF32_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
988#define ELF64_DYNAMIC_INTERPRETER "/usr/lib/sparcv9/ld.so.1"
989
d0c9aeb3
DM		 990/* Compute a hash of a local hash entry. We use elf_link_hash_entry
991 for local symbol so that we can handle local STT_GNU_IFUNC symbols
992 as global symbol. We reuse indx and dynstr_index for local symbol
993 hash since they aren't used by global symbols in this backend. */
994
995static hashval_t
996elf_sparc_local_htab_hash (const void *ptr)
997{
998 struct elf_link_hash_entry *h
999 = (struct elf_link_hash_entry *) ptr;
1000 return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);
1001}
1002
1003/* Compare local hash entries. */
1004
1005static int
1006elf_sparc_local_htab_eq (const void *ptr1, const void *ptr2)
1007{
1008 struct elf_link_hash_entry *h1
1009 = (struct elf_link_hash_entry *) ptr1;
1010 struct elf_link_hash_entry *h2
1011 = (struct elf_link_hash_entry *) ptr2;
1012
1013 return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
1014}
1015
1016/* Find and/or create a hash entry for local symbol. */
1017
1018static struct elf_link_hash_entry *
1019elf_sparc_get_local_sym_hash (struct _bfd_sparc_elf_link_hash_table *htab,
1020 bfd *abfd, const Elf_Internal_Rela *rel,
1021 bfd_boolean create)
1022{
1023 struct _bfd_sparc_elf_link_hash_entry e, *ret;
1024 asection *sec = abfd->sections;
1025 unsigned long r_symndx;
1026 hashval_t h;
1027 void **slot;
1028
1029 r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
1030 h = ELF_LOCAL_SYMBOL_HASH (sec->id, r_symndx);
1031
1032 e.elf.indx = sec->id;
1033 e.elf.dynstr_index = r_symndx;
1034 slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,
1035 create ? INSERT : NO_INSERT);
1036
1037 if (!slot)
1038 return NULL;
1039
1040 if (*slot)
1041 {
1042 ret = (struct _bfd_sparc_elf_link_hash_entry *) *slot;
1043 return &ret->elf;
1044 }
1045
1046 ret = (struct _bfd_sparc_elf_link_hash_entry *)
1047 objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,
1048 sizeof (struct _bfd_sparc_elf_link_hash_entry));
1049 if (ret)
1050 {
1051 memset (ret, 0, sizeof (*ret));
1052 ret->elf.indx = sec->id;
1053 ret->elf.dynstr_index = r_symndx;
1054 ret->elf.dynindx = -1;
1055 ret->elf.plt.offset = (bfd_vma) -1;
1056 ret->elf.got.offset = (bfd_vma) -1;
1057 *slot = ret;
1058 }
1059 return &ret->elf;
1060}
1061
22b75d0a
DM		 1062/* Create a SPARC ELF linker hash table. */
1063
1064struct bfd_link_hash_table *
1065_bfd_sparc_elf_link_hash_table_create (bfd *abfd)
1066{
1067 struct _bfd_sparc_elf_link_hash_table *ret;
1068 bfd_size_type amt = sizeof (struct _bfd_sparc_elf_link_hash_table);
1069
1070 ret = (struct _bfd_sparc_elf_link_hash_table *) bfd_zmalloc (amt);
1071 if (ret == NULL)
1072 return NULL;
1073
1074 if (ABI_64_P (abfd))
1075 {
1076 ret->put_word = sparc_put_word_64;
22b75d0a
DM		 1077 ret->r_info = sparc_elf_r_info_64;
1078 ret->r_symndx = sparc_elf_r_symndx_64;
22b75d0a
DM		 1079 ret->dtpoff_reloc = R_SPARC_TLS_DTPOFF64;
1080 ret->dtpmod_reloc = R_SPARC_TLS_DTPMOD64;
1081 ret->tpoff_reloc = R_SPARC_TLS_TPOFF64;
1082 ret->word_align_power = 3;
1083 ret->align_power_max = 4;
1084 ret->bytes_per_word = 8;
1085 ret->bytes_per_rela = sizeof (Elf64_External_Rela);
c2e70a82 1086 ret->dynamic_interpreter = ELF64_DYNAMIC_INTERPRETER;
22b75d0a 1087 ret->dynamic_interpreter_size = sizeof ELF64_DYNAMIC_INTERPRETER;
d0c9aeb3
DM		 1088
1089 ret->build_plt_entry = sparc64_plt_entry_build;
1090 ret->plt_header_size = PLT64_HEADER_SIZE;
1091 ret->plt_entry_size = PLT64_ENTRY_SIZE;
22b75d0a
DM		 1092 }
1093 else
1094 {
1095 ret->put_word = sparc_put_word_32;
22b75d0a
DM		 1096 ret->r_info = sparc_elf_r_info_32;
1097 ret->r_symndx = sparc_elf_r_symndx_32;
22b75d0a
DM		 1098 ret->dtpoff_reloc = R_SPARC_TLS_DTPOFF32;
1099 ret->dtpmod_reloc = R_SPARC_TLS_DTPMOD32;
1100 ret->tpoff_reloc = R_SPARC_TLS_TPOFF32;
1101 ret->word_align_power = 2;
1102 ret->align_power_max = 3;
1103 ret->bytes_per_word = 4;
1104 ret->bytes_per_rela = sizeof (Elf32_External_Rela);
c2e70a82 1105 ret->dynamic_interpreter = ELF32_DYNAMIC_INTERPRETER;
22b75d0a 1106 ret->dynamic_interpreter_size = sizeof ELF32_DYNAMIC_INTERPRETER;
d0c9aeb3
DM		 1107
1108 ret->build_plt_entry = sparc32_plt_entry_build;
1109 ret->plt_header_size = PLT32_HEADER_SIZE;
1110 ret->plt_entry_size = PLT32_ENTRY_SIZE;
22b75d0a
DM		 1111 }
1112
66eb6687 1113 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc,
4dfe6ac6
NC		 1114 sizeof (struct _bfd_sparc_elf_link_hash_entry),
1115 SPARC_ELF_DATA))
22b75d0a
DM		 1116 {
1117 free (ret);
1118 return NULL;
1119 }
1120
d0c9aeb3
DM		 1121 ret->loc_hash_table = htab_try_create (1024,
1122 elf_sparc_local_htab_hash,
1123 elf_sparc_local_htab_eq,
1124 NULL);
1125 ret->loc_hash_memory = objalloc_create ();
1126 if (!ret->loc_hash_table || !ret->loc_hash_memory)
1127 {
1128 free (ret);
1129 return NULL;
1130 }
1131
22b75d0a
DM		 1132 return &ret->elf.root;
1133}
1134
d0c9aeb3
DM		 1135/* Destroy a SPARC ELF linker hash table. */
1136
1137void
1138_bfd_sparc_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
1139{
1140 struct _bfd_sparc_elf_link_hash_table *htab
1141 = (struct _bfd_sparc_elf_link_hash_table *) hash;
1142
1143 if (htab->loc_hash_table)
1144 htab_delete (htab->loc_hash_table);
1145 if (htab->loc_hash_memory)
1146 objalloc_free ((struct objalloc *) htab->loc_hash_memory);
1147 _bfd_generic_link_hash_table_free (hash);
1148}
1149
22b75d0a
DM		 1150/* Create .plt, .rela.plt, .got, .rela.got, .dynbss, and
1151 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
1152 hash table. */
1153
1154bfd_boolean
1155_bfd_sparc_elf_create_dynamic_sections (bfd *dynobj,
1156 struct bfd_link_info *info)
1157{
1158 struct _bfd_sparc_elf_link_hash_table *htab;
1159
1160 htab = _bfd_sparc_elf_hash_table (info);
4dfe6ac6
NC		 1161 BFD_ASSERT (htab != NULL);
1162
22b75d0a
DM		 1163 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
1164 return FALSE;
1165
22b75d0a
DM		 1166 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
1167 if (!info->shared)
1168 htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss");
1169
910600e9
RS		 1170 if (htab->is_vxworks)
1171 {
1172 if (!elf_vxworks_create_dynamic_sections (dynobj, info, &htab->srelplt2))
1173 return FALSE;
1174 if (info->shared)
1175 {
1176 htab->plt_header_size
1177 = 4 * ARRAY_SIZE (sparc_vxworks_shared_plt0_entry);
1178 htab->plt_entry_size
1179 = 4 * ARRAY_SIZE (sparc_vxworks_shared_plt_entry);
1180 }
1181 else
1182 {
1183 htab->plt_header_size
1184 = 4 * ARRAY_SIZE (sparc_vxworks_exec_plt0_entry);
1185 htab->plt_entry_size
1186 = 4 * ARRAY_SIZE (sparc_vxworks_exec_plt_entry);
1187 }
1188 }
910600e9 1189
72fbc6e5 1190 if (!htab->elf.splt || !htab->elf.srelplt || !htab->sdynbss
22b75d0a
DM		 1191 || (!info->shared && !htab->srelbss))
1192 abort ();
1193
1194 return TRUE;
1195}
1196
d0c9aeb3
DM		 1197static bfd_boolean
1198create_ifunc_sections (bfd *abfd, struct bfd_link_info *info)
1199{
1200 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1201 struct elf_link_hash_table *htab = elf_hash_table (info);
1202 flagword flags, pltflags;
1203 asection *s;
1204
1205 if (htab->irelifunc != NULL || htab->iplt != NULL)
1206 return TRUE;
1207
1208 flags = bed->dynamic_sec_flags;
1209 pltflags = flags | SEC_ALLOC | SEC_CODE | SEC_LOAD;
1210
1211 s = bfd_make_section_with_flags (abfd, ".iplt", pltflags);
1212 if (s == NULL
1213 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
1214 return FALSE;
1215 htab->iplt = s;
1216
1217 s = bfd_make_section_with_flags (abfd, ".rela.iplt",
1218 flags | SEC_READONLY);
1219 if (s == NULL
1220 || ! bfd_set_section_alignment (abfd, s,
1221 bed->s->log_file_align))
1222 return FALSE;
1223 htab->irelplt = s;
1224
1225 return TRUE;
1226}
1227
22b75d0a
DM		 1228/* Copy the extra info we tack onto an elf_link_hash_entry. */
1229
1230void
fcfa13d2 1231_bfd_sparc_elf_copy_indirect_symbol (struct bfd_link_info *info,
22b75d0a
DM		 1232 struct elf_link_hash_entry *dir,
1233 struct elf_link_hash_entry *ind)
1234{
1235 struct _bfd_sparc_elf_link_hash_entry *edir, *eind;
1236
1237 edir = (struct _bfd_sparc_elf_link_hash_entry *) dir;
1238 eind = (struct _bfd_sparc_elf_link_hash_entry *) ind;
1239
1240 if (eind->dyn_relocs != NULL)
1241 {
1242 if (edir->dyn_relocs != NULL)
1243 {
1244 struct _bfd_sparc_elf_dyn_relocs **pp;
1245 struct _bfd_sparc_elf_dyn_relocs *p;
1246
fcfa13d2 1247 /* Add reloc counts against the indirect sym to the direct sym
22b75d0a
DM		 1248 list. Merge any entries against the same section. */
1249 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1250 {
1251 struct _bfd_sparc_elf_dyn_relocs *q;
1252
1253 for (q = edir->dyn_relocs; q != NULL; q = q->next)
1254 if (q->sec == p->sec)
1255 {
1256 q->pc_count += p->pc_count;
1257 q->count += p->count;
1258 *pp = p->next;
1259 break;
1260 }
1261 if (q == NULL)
1262 pp = &p->next;
1263 }
1264 *pp = edir->dyn_relocs;
1265 }
1266
1267 edir->dyn_relocs = eind->dyn_relocs;
1268 eind->dyn_relocs = NULL;
1269 }
1270
1271 if (ind->root.type == bfd_link_hash_indirect
1272 && dir->got.refcount <= 0)
1273 {
1274 edir->tls_type = eind->tls_type;
1275 eind->tls_type = GOT_UNKNOWN;
1276 }
fcfa13d2 1277 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
22b75d0a
DM		 1278}
1279
1280static int
1281sparc_elf_tls_transition (struct bfd_link_info *info, bfd *abfd,
1282 int r_type, int is_local)
1283{
1284 if (! ABI_64_P (abfd)
1285 && r_type == R_SPARC_TLS_GD_HI22
1286 && ! _bfd_sparc_elf_tdata (abfd)->has_tlsgd)
1287 r_type = R_SPARC_REV32;
1288
1289 if (info->shared)
1290 return r_type;
1291
1292 switch (r_type)
1293 {
1294 case R_SPARC_TLS_GD_HI22:
1295 if (is_local)
1296 return R_SPARC_TLS_LE_HIX22;
1297 return R_SPARC_TLS_IE_HI22;
1298 case R_SPARC_TLS_GD_LO10:
1299 if (is_local)
1300 return R_SPARC_TLS_LE_LOX10;
1301 return R_SPARC_TLS_IE_LO10;
1302 case R_SPARC_TLS_IE_HI22:
1303 if (is_local)
1304 return R_SPARC_TLS_LE_HIX22;
1305 return r_type;
1306 case R_SPARC_TLS_IE_LO10:
1307 if (is_local)
1308 return R_SPARC_TLS_LE_LOX10;
1309 return r_type;
1310 case R_SPARC_TLS_LDM_HI22:
1311 return R_SPARC_TLS_LE_HIX22;
1312 case R_SPARC_TLS_LDM_LO10:
1313 return R_SPARC_TLS_LE_LOX10;
1314 }
1315
1316 return r_type;
1317}
1318\f
1319/* Look through the relocs for a section during the first phase, and
1320 allocate space in the global offset table or procedure linkage
1321 table. */
1322
1323bfd_boolean
1324_bfd_sparc_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
1325 asection *sec, const Elf_Internal_Rela *relocs)
1326{
1327 struct _bfd_sparc_elf_link_hash_table *htab;
1328 Elf_Internal_Shdr *symtab_hdr;
1329 struct elf_link_hash_entry **sym_hashes;
22b75d0a
DM		 1330 const Elf_Internal_Rela *rel;
1331 const Elf_Internal_Rela *rel_end;
1332 asection *sreloc;
1333 int num_relocs;
1334 bfd_boolean checked_tlsgd = FALSE;
1335
1336 if (info->relocatable)
1337 return TRUE;
1338
1339 htab = _bfd_sparc_elf_hash_table (info);
4dfe6ac6 1340 BFD_ASSERT (htab != NULL);
0ffa91dd 1341 symtab_hdr = &elf_symtab_hdr (abfd);
22b75d0a 1342 sym_hashes = elf_sym_hashes (abfd);
22b75d0a
DM		 1343
1344 sreloc = NULL;
1345
1346 if (ABI_64_P (abfd))
d4730f92 1347 num_relocs = NUM_SHDR_ENTRIES (_bfd_elf_single_rel_hdr (sec));
22b75d0a
DM		 1348 else
1349 num_relocs = sec->reloc_count;
0ffa91dd
NC		 1350
1351 BFD_ASSERT (is_sparc_elf (abfd) || num_relocs == 0);
1352
d0c9aeb3
DM		 1353 if (htab->elf.dynobj == NULL)
1354 htab->elf.dynobj = abfd;
1355 if (!create_ifunc_sections (htab->elf.dynobj, info))
1356 return FALSE;
1357
22b75d0a
DM		 1358 rel_end = relocs + num_relocs;
1359 for (rel = relocs; rel < rel_end; rel++)
1360 {
1361 unsigned int r_type;
1362 unsigned long r_symndx;
1363 struct elf_link_hash_entry *h;
d0c9aeb3 1364 Elf_Internal_Sym *isym;
22b75d0a
DM		 1365
1366 r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
1367 r_type = SPARC_ELF_R_TYPE (rel->r_info);
1368
1369 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1370 {
1371 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1372 abfd, r_symndx);
1373 return FALSE;
1374 }
1375
d0c9aeb3 1376 isym = NULL;
22b75d0a 1377 if (r_symndx < symtab_hdr->sh_info)
d0c9aeb3
DM		 1378 {
1379 /* A local symbol. */
1380 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1381 abfd, r_symndx);
1382 if (isym == NULL)
1383 return FALSE;
1384
1385 /* Check relocation against local STT_GNU_IFUNC symbol. */
1386 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1387 {
1388 h = elf_sparc_get_local_sym_hash (htab, abfd, rel,
1389 TRUE);
1390 if (h == NULL)
1391 return FALSE;
1392
1393 /* Fake a STT_GNU_IFUNC symbol. */
1394 h->type = STT_GNU_IFUNC;
1395 h->def_regular = 1;
1396 h->ref_regular = 1;
1397 h->forced_local = 1;
1398 h->root.type = bfd_link_hash_defined;
1399 }
1400 else
1401 h = NULL;
1402 }
22b75d0a 1403 else
973a3492
L		 1404 {
1405 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1406 while (h->root.type == bfd_link_hash_indirect
1407 || h->root.type == bfd_link_hash_warning)
1408 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1409 }
22b75d0a 1410
d0c9aeb3
DM		 1411 if (h && h->type == STT_GNU_IFUNC)
1412 {
1413 if (h->def_regular)
b48ca1d4
DM		 1414 {
1415 h->ref_regular = 1;
1416 h->plt.refcount += 1;
1417 }
d0c9aeb3
DM		 1418 }
1419
22b75d0a
DM		 1420 /* Compatibility with old R_SPARC_REV32 reloc conflicting
1421 with R_SPARC_TLS_GD_HI22. */
1422 if (! ABI_64_P (abfd) && ! checked_tlsgd)
1423 switch (r_type)
1424 {
1425 case R_SPARC_TLS_GD_HI22:
1426 {
1427 const Elf_Internal_Rela *relt;
1428
1429 for (relt = rel + 1; relt < rel_end; relt++)
1430 if (ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_LO10
1431 || ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_ADD
1432 || ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_CALL)
1433 break;
1434 checked_tlsgd = TRUE;
1435 _bfd_sparc_elf_tdata (abfd)->has_tlsgd = relt < rel_end;
1436 }
1437 break;
1438 case R_SPARC_TLS_GD_LO10:
1439 case R_SPARC_TLS_GD_ADD:
1440 case R_SPARC_TLS_GD_CALL:
1441 checked_tlsgd = TRUE;
1442 _bfd_sparc_elf_tdata (abfd)->has_tlsgd = TRUE;
1443 break;
1444 }
1445
1446 r_type = sparc_elf_tls_transition (info, abfd, r_type, h == NULL);
1447 switch (r_type)
1448 {
1449 case R_SPARC_TLS_LDM_HI22:
1450 case R_SPARC_TLS_LDM_LO10:
1451 htab->tls_ldm_got.refcount += 1;
1452 break;
1453
1454 case R_SPARC_TLS_LE_HIX22:
1455 case R_SPARC_TLS_LE_LOX10:
1456 if (info->shared)
1457 goto r_sparc_plt32;
1458 break;
1459
1460 case R_SPARC_TLS_IE_HI22:
1461 case R_SPARC_TLS_IE_LO10:
1462 if (info->shared)
1463 info->flags |= DF_STATIC_TLS;
1464 /* Fall through */
1465
1466 case R_SPARC_GOT10:
1467 case R_SPARC_GOT13:
1468 case R_SPARC_GOT22:
739f7f82
DM		 1469 case R_SPARC_GOTDATA_HIX22:
1470 case R_SPARC_GOTDATA_LOX10:
1471 case R_SPARC_GOTDATA_OP_HIX22:
1472 case R_SPARC_GOTDATA_OP_LOX10:
22b75d0a
DM		 1473 case R_SPARC_TLS_GD_HI22:
1474 case R_SPARC_TLS_GD_LO10:
1475 /* This symbol requires a global offset table entry. */
1476 {
1477 int tls_type, old_tls_type;
1478
1479 switch (r_type)
1480 {
1481 default:
1482 case R_SPARC_GOT10:
1483 case R_SPARC_GOT13:
1484 case R_SPARC_GOT22:
739f7f82
DM		 1485 case R_SPARC_GOTDATA_OP_HIX22:
1486 case R_SPARC_GOTDATA_OP_LOX10:
22b75d0a
DM		 1487 tls_type = GOT_NORMAL;
1488 break;
1489 case R_SPARC_TLS_GD_HI22:
1490 case R_SPARC_TLS_GD_LO10:
1491 tls_type = GOT_TLS_GD;
1492 break;
1493 case R_SPARC_TLS_IE_HI22:
1494 case R_SPARC_TLS_IE_LO10:
1495 tls_type = GOT_TLS_IE;
1496 break;
1497 }
1498
1499 if (h != NULL)
1500 {
1501 h->got.refcount += 1;
1502 old_tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
1503 }
1504 else
1505 {
1506 bfd_signed_vma *local_got_refcounts;
1507
1508 /* This is a global offset table entry for a local symbol. */
1509 local_got_refcounts = elf_local_got_refcounts (abfd);
1510 if (local_got_refcounts == NULL)
1511 {
1512 bfd_size_type size;
1513
1514 size = symtab_hdr->sh_info;
1515 size *= (sizeof (bfd_signed_vma) + sizeof(char));
1516 local_got_refcounts = ((bfd_signed_vma *)
1517 bfd_zalloc (abfd, size));
1518 if (local_got_refcounts == NULL)
1519 return FALSE;
1520 elf_local_got_refcounts (abfd) = local_got_refcounts;
1521 _bfd_sparc_elf_local_got_tls_type (abfd)
1522 = (char *) (local_got_refcounts + symtab_hdr->sh_info);
1523 }
00c50991
DM		 1524 switch (r_type)
1525 {
1526 case R_SPARC_GOTDATA_OP_HIX22:
1527 case R_SPARC_GOTDATA_OP_LOX10:
1528 break;
1529
1530 default:
1531 local_got_refcounts[r_symndx] += 1;
1532 break;
1533 }
22b75d0a
DM		 1534 old_tls_type = _bfd_sparc_elf_local_got_tls_type (abfd) [r_symndx];
1535 }
1536
1537 /* If a TLS symbol is accessed using IE at least once,
1538 there is no point to use dynamic model for it. */
1539 if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1540 && (old_tls_type != GOT_TLS_GD
1541 || tls_type != GOT_TLS_IE))
1542 {
1543 if (old_tls_type == GOT_TLS_IE && tls_type == GOT_TLS_GD)
1544 tls_type = old_tls_type;
1545 else
1546 {
1547 (*_bfd_error_handler)
1548 (_("%B: `%s' accessed both as normal and thread local symbol"),
1549 abfd, h ? h->root.root.string : "<local>");
1550 return FALSE;
1551 }
1552 }
1553
1554 if (old_tls_type != tls_type)
1555 {
1556 if (h != NULL)
1557 _bfd_sparc_elf_hash_entry (h)->tls_type = tls_type;
1558 else
1559 _bfd_sparc_elf_local_got_tls_type (abfd) [r_symndx] = tls_type;
1560 }
1561 }
1562
72fbc6e5 1563 if (htab->elf.sgot == NULL)
22b75d0a 1564 {
72fbc6e5 1565 if (!_bfd_elf_create_got_section (htab->elf.dynobj, info))
22b75d0a
DM		 1566 return FALSE;
1567 }
1568 break;
1569
1570 case R_SPARC_TLS_GD_CALL:
1571 case R_SPARC_TLS_LDM_CALL:
1572 if (info->shared)
1573 {
1574 /* These are basically R_SPARC_TLS_WPLT30 relocs against
1575 __tls_get_addr. */
1576 struct bfd_link_hash_entry *bh = NULL;
1577 if (! _bfd_generic_link_add_one_symbol (info, abfd,
1578 "__tls_get_addr", 0,
1579 bfd_und_section_ptr, 0,
1580 NULL, FALSE, FALSE,
1581 &bh))
1582 return FALSE;
1583 h = (struct elf_link_hash_entry *) bh;
1584 }
1585 else
1586 break;
1587 /* Fall through */
1588
1589 case R_SPARC_PLT32:
1590 case R_SPARC_WPLT30:
1591 case R_SPARC_HIPLT22:
1592 case R_SPARC_LOPLT10:
1593 case R_SPARC_PCPLT32:
1594 case R_SPARC_PCPLT22:
1595 case R_SPARC_PCPLT10:
1596 case R_SPARC_PLT64:
1597 /* This symbol requires a procedure linkage table entry. We
1598 actually build the entry in adjust_dynamic_symbol,
1599 because this might be a case of linking PIC code without
1600 linking in any dynamic objects, in which case we don't
1601 need to generate a procedure linkage table after all. */
1602
1603 if (h == NULL)
1604 {
1605 if (! ABI_64_P (abfd))
1606 {
1607 /* The Solaris native assembler will generate a WPLT30
1608 reloc for a local symbol if you assemble a call from
1609 one section to another when using -K pic. We treat
1610 it as WDISP30. */
1611 if (ELF32_R_TYPE (rel->r_info) == R_SPARC_PLT32)
1612 goto r_sparc_plt32;
1613 break;
1614 }
af1fb11f
NC		 1615 /* PR 7027: We need similar behaviour for 64-bit binaries. */
1616 else if (r_type == R_SPARC_WPLT30)
1617 break;
22b75d0a
DM		 1618
1619 /* It does not make sense to have a procedure linkage
1620 table entry for a local symbol. */
1621 bfd_set_error (bfd_error_bad_value);
1622 return FALSE;
1623 }
1624
1625 h->needs_plt = 1;
1626
1627 {
1628 int this_r_type;
1629
1630 this_r_type = SPARC_ELF_R_TYPE (rel->r_info);
1631 if (this_r_type == R_SPARC_PLT32
1632 || this_r_type == R_SPARC_PLT64)
1633 goto r_sparc_plt32;
1634 }
1635 h->plt.refcount += 1;
1636 break;
1637
1638 case R_SPARC_PC10:
1639 case R_SPARC_PC22:
1640 case R_SPARC_PC_HH22:
1641 case R_SPARC_PC_HM10:
1642 case R_SPARC_PC_LM22:
1643 if (h != NULL)
1644 h->non_got_ref = 1;
1645
1646 if (h != NULL
1647 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1648 break;
1649 /* Fall through. */
1650
1651 case R_SPARC_DISP8:
1652 case R_SPARC_DISP16:
1653 case R_SPARC_DISP32:
1654 case R_SPARC_DISP64:
1655 case R_SPARC_WDISP30:
1656 case R_SPARC_WDISP22:
1657 case R_SPARC_WDISP19:
1658 case R_SPARC_WDISP16:
1659 case R_SPARC_8:
1660 case R_SPARC_16:
1661 case R_SPARC_32:
1662 case R_SPARC_HI22:
1663 case R_SPARC_22:
1664 case R_SPARC_13:
1665 case R_SPARC_LO10:
1666 case R_SPARC_UA16:
1667 case R_SPARC_UA32:
1668 case R_SPARC_10:
1669 case R_SPARC_11:
1670 case R_SPARC_64:
1671 case R_SPARC_OLO10:
1672 case R_SPARC_HH22:
1673 case R_SPARC_HM10:
1674 case R_SPARC_LM22:
1675 case R_SPARC_7:
1676 case R_SPARC_5:
1677 case R_SPARC_6:
1678 case R_SPARC_HIX22:
1679 case R_SPARC_LOX10:
1680 case R_SPARC_H44:
1681 case R_SPARC_M44:
1682 case R_SPARC_L44:
1683 case R_SPARC_UA64:
1684 if (h != NULL)
1685 h->non_got_ref = 1;
1686
1687 r_sparc_plt32:
1688 if (h != NULL && !info->shared)
1689 {
1690 /* We may need a .plt entry if the function this reloc
1691 refers to is in a shared lib. */
1692 h->plt.refcount += 1;
1693 }
1694
1695 /* If we are creating a shared library, and this is a reloc
1696 against a global symbol, or a non PC relative reloc
1697 against a local symbol, then we need to copy the reloc
1698 into the shared library. However, if we are linking with
1699 -Bsymbolic, we do not need to copy a reloc against a
1700 global symbol which is defined in an object we are
1701 including in the link (i.e., DEF_REGULAR is set). At
1702 this point we have not seen all the input files, so it is
1703 possible that DEF_REGULAR is not set now but will be set
1704 later (it is never cleared). In case of a weak definition,
1705 DEF_REGULAR may be cleared later by a strong definition in
1706 a shared library. We account for that possibility below by
1707 storing information in the relocs_copied field of the hash
1708 table entry. A similar situation occurs when creating
1709 shared libraries and symbol visibility changes render the
1710 symbol local.
1711
1712 If on the other hand, we are creating an executable, we
1713 may need to keep relocations for symbols satisfied by a
1714 dynamic library if we manage to avoid copy relocs for the
1715 symbol. */
1716 if ((info->shared
1717 && (sec->flags & SEC_ALLOC) != 0
1718 && (! _bfd_sparc_elf_howto_table[r_type].pc_relative
1719 || (h != NULL
72fbc6e5 1720 && (! SYMBOLIC_BIND (info, h)
22b75d0a
DM		 1721 || h->root.type == bfd_link_hash_defweak
1722 || !h->def_regular))))
1723 || (!info->shared
1724 && (sec->flags & SEC_ALLOC) != 0
1725 && h != NULL
1726 && (h->root.type == bfd_link_hash_defweak
d0c9aeb3
DM		 1727 || !h->def_regular))
1728 || (!info->shared
1729 && h != NULL
1730 && h->type == STT_GNU_IFUNC))
22b75d0a
DM		 1731 {
1732 struct _bfd_sparc_elf_dyn_relocs *p;
1733 struct _bfd_sparc_elf_dyn_relocs **head;
1734
1735 /* When creating a shared object, we must copy these
1736 relocs into the output file. We create a reloc
1737 section in dynobj and make room for the reloc. */
1738 if (sreloc == NULL)
1739 {
83bac4b0
NC		 1740 sreloc = _bfd_elf_make_dynamic_reloc_section
1741 (sec, htab->elf.dynobj, htab->word_align_power,
1742 abfd, /*rela?*/ TRUE);
1743
22b75d0a 1744 if (sreloc == NULL)
83bac4b0 1745 return FALSE;
22b75d0a
DM		 1746 }
1747
1748 /* If this is a global symbol, we count the number of
1749 relocations we need for this symbol. */
1750 if (h != NULL)
1751 head = &((struct _bfd_sparc_elf_link_hash_entry *) h)->dyn_relocs;
1752 else
1753 {
1754 /* Track dynamic relocs needed for local syms too.
1755 We really need local syms available to do this
1756 easily. Oh well. */
22b75d0a 1757 asection *s;
6edfbbad 1758 void *vpp;
22b75d0a 1759
d0c9aeb3 1760 BFD_ASSERT (isym != NULL);
87d72d41
AM		 1761 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1762 if (s == NULL)
1763 s = sec;
1764
6edfbbad
DJ		 1765 vpp = &elf_section_data (s)->local_dynrel;
1766 head = (struct _bfd_sparc_elf_dyn_relocs **) vpp;
22b75d0a
DM		 1767 }
1768
1769 p = *head;
1770 if (p == NULL || p->sec != sec)
1771 {
1772 bfd_size_type amt = sizeof *p;
1773 p = ((struct _bfd_sparc_elf_dyn_relocs *)
1774 bfd_alloc (htab->elf.dynobj, amt));
1775 if (p == NULL)
1776 return FALSE;
1777 p->next = *head;
1778 *head = p;
1779 p->sec = sec;
1780 p->count = 0;
1781 p->pc_count = 0;
1782 }
1783
1784 p->count += 1;
1785 if (_bfd_sparc_elf_howto_table[r_type].pc_relative)
1786 p->pc_count += 1;
1787 }
1788
1789 break;
1790
1791 case R_SPARC_GNU_VTINHERIT:
1792 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1793 return FALSE;
1794 break;
1795
1796 case R_SPARC_GNU_VTENTRY:
d17e0c6e
JB		 1797 BFD_ASSERT (h != NULL);
1798 if (h != NULL
1799 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
22b75d0a
DM		 1800 return FALSE;
1801 break;
1802
1803 case R_SPARC_REGISTER:
1804 /* Nothing to do. */
1805 break;
1806
1807 default:
1808 break;
1809 }
1810 }
1811
1812 return TRUE;
1813}
1814\f
1815asection *
1816_bfd_sparc_elf_gc_mark_hook (asection *sec,
1817 struct bfd_link_info *info,
1818 Elf_Internal_Rela *rel,
1819 struct elf_link_hash_entry *h,
1820 Elf_Internal_Sym *sym)
1821{
1822 if (h != NULL)
07adf181 1823 switch (SPARC_ELF_R_TYPE (rel->r_info))
22b75d0a
DM		 1824 {
1825 case R_SPARC_GNU_VTINHERIT:
1826 case R_SPARC_GNU_VTENTRY:
07adf181 1827 return NULL;
22b75d0a 1828 }
22b75d0a 1829
07adf181 1830 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
22b75d0a
DM		 1831}
1832
abd242a9
DM		 1833static Elf_Internal_Rela *
1834sparc_elf_find_reloc_at_ofs (Elf_Internal_Rela *rel,
1835 Elf_Internal_Rela *relend,
1836 bfd_vma offset)
1837{
1838 while (rel < relend)
1839 {
1840 if (rel->r_offset == offset)
1841 return rel;
1842 rel++;
1843 }
1844 return NULL;
1845}
1846
22b75d0a
DM		 1847/* Update the got entry reference counts for the section being removed. */
1848bfd_boolean
1849_bfd_sparc_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
1850 asection *sec, const Elf_Internal_Rela *relocs)
1851{
1852 struct _bfd_sparc_elf_link_hash_table *htab;
1853 Elf_Internal_Shdr *symtab_hdr;
1854 struct elf_link_hash_entry **sym_hashes;
1855 bfd_signed_vma *local_got_refcounts;
1856 const Elf_Internal_Rela *rel, *relend;
1857
7dda2462
TG		 1858 if (info->relocatable)
1859 return TRUE;
1860
0ffa91dd
NC		 1861 BFD_ASSERT (is_sparc_elf (abfd) || sec->reloc_count == 0);
1862
22b75d0a
DM		 1863 elf_section_data (sec)->local_dynrel = NULL;
1864
1865 htab = _bfd_sparc_elf_hash_table (info);
4dfe6ac6 1866 BFD_ASSERT (htab != NULL);
0ffa91dd 1867 symtab_hdr = &elf_symtab_hdr (abfd);
22b75d0a
DM		 1868 sym_hashes = elf_sym_hashes (abfd);
1869 local_got_refcounts = elf_local_got_refcounts (abfd);
1870
1871 relend = relocs + sec->reloc_count;
1872 for (rel = relocs; rel < relend; rel++)
1873 {
1874 unsigned long r_symndx;
1875 unsigned int r_type;
1876 struct elf_link_hash_entry *h = NULL;
1877
1878 r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
1879 if (r_symndx >= symtab_hdr->sh_info)
1880 {
1881 struct _bfd_sparc_elf_link_hash_entry *eh;
1882 struct _bfd_sparc_elf_dyn_relocs **pp;
1883 struct _bfd_sparc_elf_dyn_relocs *p;
1884
1885 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1886 while (h->root.type == bfd_link_hash_indirect
1887 || h->root.type == bfd_link_hash_warning)
1888 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1889 eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
1890 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1891 if (p->sec == sec)
1892 {
1893 /* Everything must go for SEC. */
1894 *pp = p->next;
1895 break;
1896 }
1897 }
1898
1899 r_type = SPARC_ELF_R_TYPE (rel->r_info);
1900 r_type = sparc_elf_tls_transition (info, abfd, r_type, h != NULL);
1901 switch (r_type)
1902 {
1903 case R_SPARC_TLS_LDM_HI22:
1904 case R_SPARC_TLS_LDM_LO10:
1905 if (_bfd_sparc_elf_hash_table (info)->tls_ldm_got.refcount > 0)
1906 _bfd_sparc_elf_hash_table (info)->tls_ldm_got.refcount -= 1;
1907 break;
1908
1909 case R_SPARC_TLS_GD_HI22:
1910 case R_SPARC_TLS_GD_LO10:
1911 case R_SPARC_TLS_IE_HI22:
1912 case R_SPARC_TLS_IE_LO10:
1913 case R_SPARC_GOT10:
1914 case R_SPARC_GOT13:
1915 case R_SPARC_GOT22:
739f7f82
DM		 1916 case R_SPARC_GOTDATA_HIX22:
1917 case R_SPARC_GOTDATA_LOX10:
1918 case R_SPARC_GOTDATA_OP_HIX22:
1919 case R_SPARC_GOTDATA_OP_LOX10:
22b75d0a
DM		 1920 if (h != NULL)
1921 {
1922 if (h->got.refcount > 0)
1923 h->got.refcount--;
1924 }
1925 else
1926 {
00c50991
DM		 1927 switch (r_type)
1928 {
1929 case R_SPARC_GOTDATA_OP_HIX22:
1930 case R_SPARC_GOTDATA_OP_LOX10:
1931 break;
1932
1933 default:
1934 if (local_got_refcounts[r_symndx] > 0)
1935 local_got_refcounts[r_symndx]--;
1936 break;
1937 }
22b75d0a
DM		 1938 }
1939 break;
1940
1941 case R_SPARC_PC10:
1942 case R_SPARC_PC22:
1943 case R_SPARC_PC_HH22:
1944 case R_SPARC_PC_HM10:
1945 case R_SPARC_PC_LM22:
1946 if (h != NULL
1947 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1948 break;
1949 /* Fall through. */
1950
1951 case R_SPARC_DISP8:
1952 case R_SPARC_DISP16:
1953 case R_SPARC_DISP32:
1954 case R_SPARC_DISP64:
1955 case R_SPARC_WDISP30:
1956 case R_SPARC_WDISP22:
1957 case R_SPARC_WDISP19:
1958 case R_SPARC_WDISP16:
1959 case R_SPARC_8:
1960 case R_SPARC_16:
1961 case R_SPARC_32:
1962 case R_SPARC_HI22:
1963 case R_SPARC_22:
1964 case R_SPARC_13:
1965 case R_SPARC_LO10:
1966 case R_SPARC_UA16:
1967 case R_SPARC_UA32:
1968 case R_SPARC_PLT32:
1969 case R_SPARC_10:
1970 case R_SPARC_11:
1971 case R_SPARC_64:
1972 case R_SPARC_OLO10:
1973 case R_SPARC_HH22:
1974 case R_SPARC_HM10:
1975 case R_SPARC_LM22:
1976 case R_SPARC_7:
1977 case R_SPARC_5:
1978 case R_SPARC_6:
1979 case R_SPARC_HIX22:
1980 case R_SPARC_LOX10:
1981 case R_SPARC_H44:
1982 case R_SPARC_M44:
1983 case R_SPARC_L44:
1984 case R_SPARC_UA64:
1985 if (info->shared)
1986 break;
1987 /* Fall through. */
1988
1989 case R_SPARC_WPLT30:
1990 if (h != NULL)
1991 {
1992 if (h->plt.refcount > 0)
1993 h->plt.refcount--;
1994 }
1995 break;
1996
1997 default:
1998 break;
1999 }
2000 }
2001
2002 return TRUE;
2003}
2004
2005/* Adjust a symbol defined by a dynamic object and referenced by a
2006 regular object. The current definition is in some section of the
2007 dynamic object, but we're not including those sections. We have to
2008 change the definition to something the rest of the link can
2009 understand. */
2010
2011bfd_boolean
2012_bfd_sparc_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
2013 struct elf_link_hash_entry *h)
2014{
2015 struct _bfd_sparc_elf_link_hash_table *htab;
2016 struct _bfd_sparc_elf_link_hash_entry * eh;
2017 struct _bfd_sparc_elf_dyn_relocs *p;
2018 asection *s;
22b75d0a
DM		 2019
2020 htab = _bfd_sparc_elf_hash_table (info);
4dfe6ac6 2021 BFD_ASSERT (htab != NULL);
22b75d0a
DM		 2022
2023 /* Make sure we know what is going on here. */
2024 BFD_ASSERT (htab->elf.dynobj != NULL
2025 && (h->needs_plt
d0c9aeb3 2026 || h->type == STT_GNU_IFUNC
22b75d0a
DM		 2027 || h->u.weakdef != NULL
2028 || (h->def_dynamic
2029 && h->ref_regular
2030 && !h->def_regular)));
2031
2032 /* If this is a function, put it in the procedure linkage table. We
2033 will fill in the contents of the procedure linkage table later
2034 (although we could actually do it here). The STT_NOTYPE
2035 condition is a hack specifically for the Oracle libraries
2036 delivered for Solaris; for some inexplicable reason, they define
2037 some of their functions as STT_NOTYPE when they really should be
2038 STT_FUNC. */
2039 if (h->type == STT_FUNC
d0c9aeb3 2040 || h->type == STT_GNU_IFUNC
22b75d0a
DM		 2041 || h->needs_plt
2042 || (h->type == STT_NOTYPE
2043 && (h->root.type == bfd_link_hash_defined
2044 || h->root.type == bfd_link_hash_defweak)
2045 && (h->root.u.def.section->flags & SEC_CODE) != 0))
2046 {
2047 if (h->plt.refcount <= 0
d0c9aeb3
DM		 2048 || (h->type != STT_GNU_IFUNC
2049 && (SYMBOL_CALLS_LOCAL (info, h)
2050 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2051 && h->root.type == bfd_link_hash_undefweak))))
22b75d0a
DM		 2052 {
2053 /* This case can occur if we saw a WPLT30 reloc in an input
2054 file, but the symbol was never referred to by a dynamic
2055 object, or if all references were garbage collected. In
2056 such a case, we don't actually need to build a procedure
2057 linkage table, and we can just do a WDISP30 reloc instead. */
2058 h->plt.offset = (bfd_vma) -1;
2059 h->needs_plt = 0;
2060 }
2061
2062 return TRUE;
2063 }
2064 else
2065 h->plt.offset = (bfd_vma) -1;
2066
2067 /* If this is a weak symbol, and there is a real definition, the
2068 processor independent code will have arranged for us to see the
2069 real definition first, and we can just use the same value. */
2070 if (h->u.weakdef != NULL)
2071 {
2072 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2073 || h->u.weakdef->root.type == bfd_link_hash_defweak);
2074 h->root.u.def.section = h->u.weakdef->root.u.def.section;
2075 h->root.u.def.value = h->u.weakdef->root.u.def.value;
2076 return TRUE;
2077 }
2078
2079 /* This is a reference to a symbol defined by a dynamic object which
2080 is not a function. */
2081
2082 /* If we are creating a shared library, we must presume that the
2083 only references to the symbol are via the global offset table.
2084 For such cases we need not do anything here; the relocations will
2085 be handled correctly by relocate_section. */
2086 if (info->shared)
2087 return TRUE;
2088
2089 /* If there are no references to this symbol that do not use the
2090 GOT, we don't need to generate a copy reloc. */
2091 if (!h->non_got_ref)
2092 return TRUE;
2093
72fbc6e5
DM		 2094 /* If -z nocopyreloc was given, we won't generate them either. */
2095 if (info->nocopyreloc)
2096 {
2097 h->non_got_ref = 0;
2098 return TRUE;
2099 }
2100
22b75d0a
DM		 2101 eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
2102 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2103 {
2104 s = p->sec->output_section;
2105 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2106 break;
2107 }
2108
2109 /* If we didn't find any dynamic relocs in read-only sections, then
2110 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2111 if (p == NULL)
2112 {
2113 h->non_got_ref = 0;
2114 return TRUE;
2115 }
2116
909272ee
AM		 2117 if (h->size == 0)
2118 {
2119 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
2120 h->root.root.string);
2121 return TRUE;
2122 }
2123
22b75d0a
DM		 2124 /* We must allocate the symbol in our .dynbss section, which will
2125 become part of the .bss section of the executable. There will be
2126 an entry for this symbol in the .dynsym section. The dynamic
2127 object will contain position independent code, so all references
2128 from the dynamic object to this symbol will go through the global
2129 offset table. The dynamic linker will use the .dynsym entry to
2130 determine the address it must put in the global offset table, so
2131 both the dynamic object and the regular object will refer to the
2132 same memory location for the variable. */
2133
2134 /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker
2135 to copy the initial value out of the dynamic object and into the
2136 runtime process image. We need to remember the offset into the
2137 .rel.bss section we are going to use. */
2138 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
2139 {
2140 htab->srelbss->size += SPARC_ELF_RELA_BYTES (htab);
2141 h->needs_copy = 1;
2142 }
2143
22b75d0a 2144 s = htab->sdynbss;
22b75d0a 2145
027297b7 2146 return _bfd_elf_adjust_dynamic_copy (h, s);
22b75d0a
DM		 2147}
2148
2149/* Allocate space in .plt, .got and associated reloc sections for
2150 dynamic relocs. */
2151
2152static bfd_boolean
2153allocate_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
2154{
2155 struct bfd_link_info *info;
2156 struct _bfd_sparc_elf_link_hash_table *htab;
2157 struct _bfd_sparc_elf_link_hash_entry *eh;
2158 struct _bfd_sparc_elf_dyn_relocs *p;
2159
2160 if (h->root.type == bfd_link_hash_indirect)
2161 return TRUE;
2162
22b75d0a
DM		 2163 info = (struct bfd_link_info *) inf;
2164 htab = _bfd_sparc_elf_hash_table (info);
4dfe6ac6 2165 BFD_ASSERT (htab != NULL);
22b75d0a 2166
d0c9aeb3
DM		 2167 if ((htab->elf.dynamic_sections_created
2168 && h->plt.refcount > 0)
2169 || (h->type == STT_GNU_IFUNC
b48ca1d4
DM		 2170 && h->def_regular
2171 && h->ref_regular))
22b75d0a
DM		 2172 {
2173 /* Make sure this symbol is output as a dynamic symbol.
2174 Undefined weak syms won't yet be marked as dynamic. */
2175 if (h->dynindx == -1
2176 && !h->forced_local)
2177 {
2178 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2179 return FALSE;
2180 }
2181
d0c9aeb3 2182 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h)
b48ca1d4
DM		 2183 || (h->type == STT_GNU_IFUNC
2184 && h->def_regular))
22b75d0a 2185 {
72fbc6e5 2186 asection *s = htab->elf.splt;
22b75d0a 2187
d0c9aeb3
DM		 2188 if (s == NULL)
2189 s = htab->elf.iplt;
2190
910600e9 2191 /* Allocate room for the header. */
22b75d0a 2192 if (s->size == 0)
910600e9
RS		 2193 {
2194 s->size = htab->plt_header_size;
2195
2196 /* Allocate space for the .rela.plt.unloaded relocations. */
2197 if (htab->is_vxworks && !info->shared)
2198 htab->srelplt2->size = sizeof (Elf32_External_Rela) * 2;
2199 }
22b75d0a
DM		 2200
2201 /* The procedure linkage table size is bounded by the magnitude
2202 of the offset we can describe in the entry. */
2203 if (s->size >= (SPARC_ELF_WORD_BYTES(htab) == 8 ?
e8be8da4 2204 (((bfd_vma)1 << 31) << 1) : 0x400000))
22b75d0a
DM		 2205 {
2206 bfd_set_error (bfd_error_bad_value);
2207 return FALSE;
2208 }
2209
2210 if (SPARC_ELF_WORD_BYTES(htab) == 8
2211 && s->size >= PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE)
2212 {
2213 bfd_vma off = s->size - PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE;
2214
2215
2216 off = (off % (160 * PLT64_ENTRY_SIZE)) / PLT64_ENTRY_SIZE;
2217
2218 h->plt.offset = (s->size - (off * 8));
2219 }
2220 else
2221 h->plt.offset = s->size;
2222
2223 /* If this symbol is not defined in a regular file, and we are
2224 not generating a shared library, then set the symbol to this
2225 location in the .plt. This is required to make function
2226 pointers compare as equal between the normal executable and
2227 the shared library. */
2228 if (! info->shared
2229 && !h->def_regular)
2230 {
2231 h->root.u.def.section = s;
2232 h->root.u.def.value = h->plt.offset;
2233 }
2234
2235 /* Make room for this entry. */
910600e9 2236 s->size += htab->plt_entry_size;
22b75d0a
DM		 2237
2238 /* We also need to make an entry in the .rela.plt section. */
d0c9aeb3
DM		 2239 if (s == htab->elf.splt)
2240 htab->elf.srelplt->size += SPARC_ELF_RELA_BYTES (htab);
2241 else
2242 htab->elf.irelplt->size += SPARC_ELF_RELA_BYTES (htab);
910600e9
RS		 2243
2244 if (htab->is_vxworks)
2245 {
2246 /* Allocate space for the .got.plt entry. */
72fbc6e5 2247 htab->elf.sgotplt->size += 4;
910600e9
RS		 2248
2249 /* ...and for the .rela.plt.unloaded relocations. */
2250 if (!info->shared)
2251 htab->srelplt2->size += sizeof (Elf32_External_Rela) * 3;
2252 }
22b75d0a
DM		 2253 }
2254 else
2255 {
2256 h->plt.offset = (bfd_vma) -1;
2257 h->needs_plt = 0;
2258 }
2259 }
2260 else
2261 {
2262 h->plt.offset = (bfd_vma) -1;
2263 h->needs_plt = 0;
2264 }
2265
2266 /* If R_SPARC_TLS_IE_{HI22,LO10} symbol is now local to the binary,
2267 make it a R_SPARC_TLS_LE_{HI22,LO10} requiring no TLS entry. */
2268 if (h->got.refcount > 0
2269 && !info->shared
2270 && h->dynindx == -1
2271 && _bfd_sparc_elf_hash_entry(h)->tls_type == GOT_TLS_IE)
2272 h->got.offset = (bfd_vma) -1;
2273 else if (h->got.refcount > 0)
2274 {
2275 asection *s;
2276 bfd_boolean dyn;
2277 int tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
2278
2279 /* Make sure this symbol is output as a dynamic symbol.
2280 Undefined weak syms won't yet be marked as dynamic. */
2281 if (h->dynindx == -1
2282 && !h->forced_local)
2283 {
2284 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2285 return FALSE;
2286 }
2287
72fbc6e5 2288 s = htab->elf.sgot;
22b75d0a
DM		 2289 h->got.offset = s->size;
2290 s->size += SPARC_ELF_WORD_BYTES (htab);
2291 /* R_SPARC_TLS_GD_HI{22,LO10} needs 2 consecutive GOT slots. */
2292 if (tls_type == GOT_TLS_GD)
2293 s->size += SPARC_ELF_WORD_BYTES (htab);
2294 dyn = htab->elf.dynamic_sections_created;
2295 /* R_SPARC_TLS_IE_{HI22,LO10} needs one dynamic relocation,
2296 R_SPARC_TLS_GD_{HI22,LO10} needs one if local symbol and two if
2297 global. */
2298 if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
d0c9aeb3
DM		 2299 || tls_type == GOT_TLS_IE
2300 || h->type == STT_GNU_IFUNC)
72fbc6e5 2301 htab->elf.srelgot->size += SPARC_ELF_RELA_BYTES (htab);
22b75d0a 2302 else if (tls_type == GOT_TLS_GD)
72fbc6e5 2303 htab->elf.srelgot->size += 2 * SPARC_ELF_RELA_BYTES (htab);
22b75d0a 2304 else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
72fbc6e5 2305 htab->elf.srelgot->size += SPARC_ELF_RELA_BYTES (htab);
22b75d0a
DM		 2306 }
2307 else
2308 h->got.offset = (bfd_vma) -1;
2309
2310 eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
2311 if (eh->dyn_relocs == NULL)
2312 return TRUE;
2313
2314 /* In the shared -Bsymbolic case, discard space allocated for
2315 dynamic pc-relative relocs against symbols which turn out to be
2316 defined in regular objects. For the normal shared case, discard
2317 space for pc-relative relocs that have become local due to symbol
2318 visibility changes. */
2319
2320 if (info->shared)
2321 {
72fbc6e5 2322 if (SYMBOL_CALLS_LOCAL (info, h))
22b75d0a
DM		 2323 {
2324 struct _bfd_sparc_elf_dyn_relocs **pp;
2325
2326 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2327 {
2328 p->count -= p->pc_count;
2329 p->pc_count = 0;
2330 if (p->count == 0)
2331 *pp = p->next;
2332 else
2333 pp = &p->next;
2334 }
2335 }
22d606e9 2336
3348747a
NS		 2337 if (htab->is_vxworks)
2338 {
2339 struct _bfd_sparc_elf_dyn_relocs **pp;
2340
2341 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2342 {
2343 if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
2344 *pp = p->next;
2345 else
2346 pp = &p->next;
2347 }
2348 }
2349
22d606e9
AM		 2350 /* Also discard relocs on undefined weak syms with non-default
2351 visibility. */
2352 if (eh->dyn_relocs != NULL
2353 && h->root.type == bfd_link_hash_undefweak)
2354 {
2355 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2356 eh->dyn_relocs = NULL;
2357
2358 /* Make sure undefined weak symbols are output as a dynamic
2359 symbol in PIEs. */
2360 else if (h->dynindx == -1
2361 && !h->forced_local)
2362 {
2363 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2364 return FALSE;
2365 }
2366 }
22b75d0a
DM		 2367 }
2368 else
2369 {
2370 /* For the non-shared case, discard space for relocs against
2371 symbols which turn out to need copy relocs or are not
2372 dynamic. */
2373
2374 if (!h->non_got_ref
2375 && ((h->def_dynamic
2376 && !h->def_regular)
2377 || (htab->elf.dynamic_sections_created
2378 && (h->root.type == bfd_link_hash_undefweak
2379 || h->root.type == bfd_link_hash_undefined))))
2380 {
2381 /* Make sure this symbol is output as a dynamic symbol.
2382 Undefined weak syms won't yet be marked as dynamic. */
2383 if (h->dynindx == -1
2384 && !h->forced_local)
2385 {
2386 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2387 return FALSE;
2388 }
2389
2390 /* If that succeeded, we know we'll be keeping all the
2391 relocs. */
2392 if (h->dynindx != -1)
2393 goto keep;
2394 }
2395
2396 eh->dyn_relocs = NULL;
2397
2398 keep: ;
2399 }
2400
2401 /* Finally, allocate space. */
2402 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2403 {
2404 asection *sreloc = elf_section_data (p->sec)->sreloc;
2405 sreloc->size += p->count * SPARC_ELF_RELA_BYTES (htab);
2406 }
2407
2408 return TRUE;
2409}
2410
d0c9aeb3
DM		 2411/* Allocate space in .plt, .got and associated reloc sections for
2412 local dynamic relocs. */
2413
2414static bfd_boolean
2415allocate_local_dynrelocs (void **slot, void *inf)
2416{
2417 struct elf_link_hash_entry *h
2418 = (struct elf_link_hash_entry *) *slot;
2419
2420 if (h->type != STT_GNU_IFUNC
2421 || !h->def_regular
2422 || !h->ref_regular
2423 || !h->forced_local
2424 || h->root.type != bfd_link_hash_defined)
2425 abort ();
2426
2427 return allocate_dynrelocs (h, inf);
2428}
2429
22b75d0a
DM		 2430/* Find any dynamic relocs that apply to read-only sections. */
2431
2432static bfd_boolean
2433readonly_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
2434{
2435 struct _bfd_sparc_elf_link_hash_entry *eh;
2436 struct _bfd_sparc_elf_dyn_relocs *p;
2437
22b75d0a
DM		 2438 eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
2439 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2440 {
2441 asection *s = p->sec->output_section;
2442
2443 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2444 {
2445 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2446
2447 info->flags |= DF_TEXTREL;
2448
2449 /* Not an error, just cut short the traversal. */
2450 return FALSE;
2451 }
2452 }
2453 return TRUE;
2454}
2455
2456/* Return true if the dynamic symbol for a given section should be
2457 omitted when creating a shared library. */
2458
2459bfd_boolean
2460_bfd_sparc_elf_omit_section_dynsym (bfd *output_bfd,
2461 struct bfd_link_info *info,
2462 asection *p)
2463{
2464 /* We keep the .got section symbol so that explicit relocations
2465 against the _GLOBAL_OFFSET_TABLE_ symbol emitted in PIC mode
2466 can be turned into relocations against the .got symbol. */
2467 if (strcmp (p->name, ".got") == 0)
2468 return FALSE;
2469
2470 return _bfd_elf_link_omit_section_dynsym (output_bfd, info, p);
2471}
2472
2473/* Set the sizes of the dynamic sections. */
2474
2475bfd_boolean
2476_bfd_sparc_elf_size_dynamic_sections (bfd *output_bfd,
2477 struct bfd_link_info *info)
2478{
2479 struct _bfd_sparc_elf_link_hash_table *htab;
2480 bfd *dynobj;
2481 asection *s;
2482 bfd *ibfd;
2483
2484 htab = _bfd_sparc_elf_hash_table (info);
4dfe6ac6 2485 BFD_ASSERT (htab != NULL);
22b75d0a
DM		 2486 dynobj = htab->elf.dynobj;
2487 BFD_ASSERT (dynobj != NULL);
2488
2489 if (elf_hash_table (info)->dynamic_sections_created)
2490 {
2491 /* Set the contents of the .interp section to the interpreter. */
2492 if (info->executable)
2493 {
2494 s = bfd_get_section_by_name (dynobj, ".interp");
2495 BFD_ASSERT (s != NULL);
2496 s->size = htab->dynamic_interpreter_size;
2497 s->contents = (unsigned char *) htab->dynamic_interpreter;
2498 }
2499 }
2500
2501 /* Set up .got offsets for local syms, and space for local dynamic
2502 relocs. */
2503 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2504 {
2505 bfd_signed_vma *local_got;
2506 bfd_signed_vma *end_local_got;
2507 char *local_tls_type;
2508 bfd_size_type locsymcount;
2509 Elf_Internal_Shdr *symtab_hdr;
2510 asection *srel;
2511
0ffa91dd 2512 if (! is_sparc_elf (ibfd))
22b75d0a
DM		 2513 continue;
2514
2515 for (s = ibfd->sections; s != NULL; s = s->next)
2516 {
2517 struct _bfd_sparc_elf_dyn_relocs *p;
2518
6edfbbad 2519 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
22b75d0a
DM		 2520 {
2521 if (!bfd_is_abs_section (p->sec)
2522 && bfd_is_abs_section (p->sec->output_section))
2523 {
2524 /* Input section has been discarded, either because
2525 it is a copy of a linkonce section or due to
2526 linker script /DISCARD/, so we'll be discarding
2527 the relocs too. */
2528 }
3348747a
NS		 2529 else if (htab->is_vxworks
2530 && strcmp (p->sec->output_section->name,
2531 ".tls_vars") == 0)
2532 {
2533 /* Relocations in vxworks .tls_vars sections are
2534 handled specially by the loader. */
2535 }
22b75d0a
DM		 2536 else if (p->count != 0)
2537 {
2538 srel = elf_section_data (p->sec)->sreloc;
d0c9aeb3
DM		 2539 if (!htab->elf.dynamic_sections_created)
2540 srel = htab->elf.irelplt;
22b75d0a
DM		 2541 srel->size += p->count * SPARC_ELF_RELA_BYTES (htab);
2542 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2543 info->flags |= DF_TEXTREL;
2544 }
2545 }
2546 }
2547
2548 local_got = elf_local_got_refcounts (ibfd);
2549 if (!local_got)
2550 continue;
2551
0ffa91dd 2552 symtab_hdr = &elf_symtab_hdr (ibfd);
22b75d0a
DM		 2553 locsymcount = symtab_hdr->sh_info;
2554 end_local_got = local_got + locsymcount;
2555 local_tls_type = _bfd_sparc_elf_local_got_tls_type (ibfd);
72fbc6e5
DM		 2556 s = htab->elf.sgot;
2557 srel = htab->elf.srelgot;
22b75d0a
DM		 2558 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
2559 {
2560 if (*local_got > 0)
2561 {
2562 *local_got = s->size;
2563 s->size += SPARC_ELF_WORD_BYTES (htab);
2564 if (*local_tls_type == GOT_TLS_GD)
2565 s->size += SPARC_ELF_WORD_BYTES (htab);
2566 if (info->shared
2567 || *local_tls_type == GOT_TLS_GD
2568 || *local_tls_type == GOT_TLS_IE)
2569 srel->size += SPARC_ELF_RELA_BYTES (htab);
2570 }
2571 else
2572 *local_got = (bfd_vma) -1;
2573 }
2574 }
2575
2576 if (htab->tls_ldm_got.refcount > 0)
2577 {
2578 /* Allocate 2 got entries and 1 dynamic reloc for
2579 R_SPARC_TLS_LDM_{HI22,LO10} relocs. */
72fbc6e5
DM		 2580 htab->tls_ldm_got.offset = htab->elf.sgot->size;
2581 htab->elf.sgot->size += (2 * SPARC_ELF_WORD_BYTES (htab));
2582 htab->elf.srelgot->size += SPARC_ELF_RELA_BYTES (htab);
22b75d0a
DM		 2583 }
2584 else
2585 htab->tls_ldm_got.offset = -1;
2586
2587 /* Allocate global sym .plt and .got entries, and space for global
2588 sym dynamic relocs. */
2589 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
2590
d0c9aeb3
DM		 2591 /* Allocate .plt and .got entries, and space for local symbols. */
2592 htab_traverse (htab->loc_hash_table, allocate_local_dynrelocs, info);
2593
22b75d0a 2594 if (! ABI_64_P (output_bfd)
910600e9 2595 && !htab->is_vxworks
22b75d0a
DM		 2596 && elf_hash_table (info)->dynamic_sections_created)
2597 {
2598 /* Make space for the trailing nop in .plt. */
72fbc6e5
DM		 2599 if (htab->elf.splt->size > 0)
2600 htab->elf.splt->size += 1 * SPARC_INSN_BYTES;
22b75d0a
DM		 2601
2602 /* If the .got section is more than 0x1000 bytes, we add
2603 0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13
2604 bit relocations have a greater chance of working.
2605
2606 FIXME: Make this optimization work for 64-bit too. */
72fbc6e5 2607 if (htab->elf.sgot->size >= 0x1000
22b75d0a
DM		 2608 && elf_hash_table (info)->hgot->root.u.def.value == 0)
2609 elf_hash_table (info)->hgot->root.u.def.value = 0x1000;
2610 }
2611
2612 /* The check_relocs and adjust_dynamic_symbol entry points have
2613 determined the sizes of the various dynamic sections. Allocate
2614 memory for them. */
2615 for (s = dynobj->sections; s != NULL; s = s->next)
2616 {
22b75d0a
DM		 2617 if ((s->flags & SEC_LINKER_CREATED) == 0)
2618 continue;
2619
72fbc6e5
DM		 2620 if (s == htab->elf.splt
2621 || s == htab->elf.sgot
910600e9 2622 || s == htab->sdynbss
d0c9aeb3 2623 || s == htab->elf.iplt
72fbc6e5 2624 || s == htab->elf.sgotplt)
22b75d0a 2625 {
c456f082
AM		 2626 /* Strip this section if we don't need it; see the
2627 comment below. */
2628 }
0112cd26 2629 else if (CONST_STRNEQ (s->name, ".rela"))
c456f082
AM		 2630 {
2631 if (s->size != 0)
22b75d0a
DM		 2632 {
2633 /* We use the reloc_count field as a counter if we need
2634 to copy relocs into the output file. */
2635 s->reloc_count = 0;
2636 }
2637 }
c456f082 2638 else
22b75d0a 2639 {
c456f082 2640 /* It's not one of our sections. */
22b75d0a
DM		 2641 continue;
2642 }
2643
c456f082 2644 if (s->size == 0)
22b75d0a 2645 {
c456f082
AM		 2646 /* If we don't need this section, strip it from the
2647 output file. This is mostly to handle .rela.bss and
2648 .rela.plt. We must create both sections in
2649 create_dynamic_sections, because they must be created
2650 before the linker maps input sections to output
2651 sections. The linker does that before
2652 adjust_dynamic_symbol is called, and it is that
2653 function which decides whether anything needs to go
2654 into these sections. */
8423293d 2655 s->flags |= SEC_EXCLUDE;
22b75d0a
DM		 2656 continue;
2657 }
2658
c456f082
AM		 2659 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2660 continue;
2661
22b75d0a
DM		 2662 /* Allocate memory for the section contents. Zero the memory
2663 for the benefit of .rela.plt, which has 4 unused entries
2664 at the beginning, and we don't want garbage. */
2665 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
c456f082 2666 if (s->contents == NULL)
22b75d0a
DM		 2667 return FALSE;
2668 }
2669
2670 if (elf_hash_table (info)->dynamic_sections_created)
2671 {
2672 /* Add some entries to the .dynamic section. We fill in the
2673 values later, in _bfd_sparc_elf_finish_dynamic_sections, but we
2674 must add the entries now so that we get the correct size for
2675 the .dynamic section. The DT_DEBUG entry is filled in by the
2676 dynamic linker and used by the debugger. */
2677#define add_dynamic_entry(TAG, VAL) \
2678 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2679
2680 if (info->executable)
2681 {
2682 if (!add_dynamic_entry (DT_DEBUG, 0))
2683 return FALSE;
2684 }
2685
72fbc6e5 2686 if (htab->elf.srelplt->size != 0)
22b75d0a
DM		 2687 {
2688 if (!add_dynamic_entry (DT_PLTGOT, 0)
2689 || !add_dynamic_entry (DT_PLTRELSZ, 0)
2690 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2691 || !add_dynamic_entry (DT_JMPREL, 0))
2692 return FALSE;
2693 }
2694
2695 if (!add_dynamic_entry (DT_RELA, 0)
2696 || !add_dynamic_entry (DT_RELASZ, 0)
2697 || !add_dynamic_entry (DT_RELAENT,
2698 SPARC_ELF_RELA_BYTES (htab)))
2699 return FALSE;
2700
2701 /* If any dynamic relocs apply to a read-only section,
2702 then we need a DT_TEXTREL entry. */
2703 if ((info->flags & DF_TEXTREL) == 0)
2704 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
2705 (PTR) info);
2706
2707 if (info->flags & DF_TEXTREL)
2708 {
2709 if (!add_dynamic_entry (DT_TEXTREL, 0))
2710 return FALSE;
2711 }
2712
2713 if (ABI_64_P (output_bfd))
2714 {
2715 int reg;
2716 struct _bfd_sparc_elf_app_reg * app_regs;
2717 struct elf_strtab_hash *dynstr;
2718 struct elf_link_hash_table *eht = elf_hash_table (info);
2719
2720 /* Add dynamic STT_REGISTER symbols and corresponding DT_SPARC_REGISTER
2721 entries if needed. */
2722 app_regs = _bfd_sparc_elf_hash_table (info)->app_regs;
2723 dynstr = eht->dynstr;
2724
2725 for (reg = 0; reg < 4; reg++)
2726 if (app_regs [reg].name != NULL)
2727 {
2728 struct elf_link_local_dynamic_entry *entry, *e;
2729
2730 if (!add_dynamic_entry (DT_SPARC_REGISTER, 0))
2731 return FALSE;
2732
2733 entry = (struct elf_link_local_dynamic_entry *)
2734 bfd_hash_allocate (&info->hash->table, sizeof (*entry));
2735 if (entry == NULL)
2736 return FALSE;
2737
2738 /* We cheat here a little bit: the symbol will not be local, so we
2739 put it at the end of the dynlocal linked list. We will fix it
2740 later on, as we have to fix other fields anyway. */
2741 entry->isym.st_value = reg < 2 ? reg + 2 : reg + 4;
2742 entry->isym.st_size = 0;
2743 if (*app_regs [reg].name != '\0')
2744 entry->isym.st_name
2745 = _bfd_elf_strtab_add (dynstr, app_regs[reg].name, FALSE);
2746 else
2747 entry->isym.st_name = 0;
2748 entry->isym.st_other = 0;
2749 entry->isym.st_info = ELF_ST_INFO (app_regs [reg].bind,
2750 STT_REGISTER);
2751 entry->isym.st_shndx = app_regs [reg].shndx;
35fc36a8 2752 entry->isym.st_target_internal = 0;
22b75d0a
DM		 2753 entry->next = NULL;
2754 entry->input_bfd = output_bfd;
2755 entry->input_indx = -1;
2756
2757 if (eht->dynlocal == NULL)
2758 eht->dynlocal = entry;
2759 else
2760 {
2761 for (e = eht->dynlocal; e->next; e = e->next)
2762 ;
2763 e->next = entry;
2764 }
2765 eht->dynsymcount++;
2766 }
2767 }
7a2b07ff
NS		 2768 if (htab->is_vxworks
2769 && !elf_vxworks_add_dynamic_entries (output_bfd, info))
2770 return FALSE;
22b75d0a
DM		 2771 }
2772#undef add_dynamic_entry
2773
2774 return TRUE;
2775}
2776\f
2777bfd_boolean
2778_bfd_sparc_elf_new_section_hook (bfd *abfd, asection *sec)
2779{
f592407e
AM		 2780 if (!sec->used_by_bfd)
2781 {
2782 struct _bfd_sparc_elf_section_data *sdata;
2783 bfd_size_type amt = sizeof (*sdata);
22b75d0a 2784
f592407e
AM		 2785 sdata = bfd_zalloc (abfd, amt);
2786 if (sdata == NULL)
2787 return FALSE;
2788 sec->used_by_bfd = sdata;
2789 }
22b75d0a
DM		 2790
2791 return _bfd_elf_new_section_hook (abfd, sec);
2792}
2793
2794bfd_boolean
2795_bfd_sparc_elf_relax_section (bfd *abfd ATTRIBUTE_UNUSED,
2796 struct bfd_section *section,
2797 struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
2798 bfd_boolean *again)
2799{
c8a1f254
NS		 2800 if (link_info->relocatable)
2801 (*link_info->callbacks->einfo)
2802 (_("%P%F: --relax and -r may not be used together\n"));
2803
22b75d0a
DM		 2804 *again = FALSE;
2805 sec_do_relax (section) = 1;
2806 return TRUE;
2807}
2808\f
2809/* Return the base VMA address which should be subtracted from real addresses
2810 when resolving @dtpoff relocation.
2811 This is PT_TLS segment p_vaddr. */
2812
2813static bfd_vma
2814dtpoff_base (struct bfd_link_info *info)
2815{
2816 /* If tls_sec is NULL, we should have signalled an error already. */
2817 if (elf_hash_table (info)->tls_sec == NULL)
2818 return 0;
2819 return elf_hash_table (info)->tls_sec->vma;
2820}
2821
2822/* Return the relocation value for @tpoff relocation
2823 if STT_TLS virtual address is ADDRESS. */
2824
2825static bfd_vma
2826tpoff (struct bfd_link_info *info, bfd_vma address)
2827{
2828 struct elf_link_hash_table *htab = elf_hash_table (info);
1360ba76
RO		 2829 const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
2830 bfd_vma static_tls_size;
22b75d0a
DM		 2831
2832 /* If tls_sec is NULL, we should have signalled an error already. */
2833 if (htab->tls_sec == NULL)
2834 return 0;
1360ba76
RO		 2835
2836 /* Consider special static TLS alignment requirements. */
2837 static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
2838 return address - static_tls_size - htab->tls_sec->vma;
22b75d0a
DM		 2839}
2840
00c50991
DM		 2841/* Return the relocation value for a %gdop relocation. */
2842
2843static bfd_vma
2844gdopoff (struct bfd_link_info *info, bfd_vma address)
2845{
2846 struct elf_link_hash_table *htab = elf_hash_table (info);
2847 bfd_vma got_base;
2848
2849 got_base = (htab->hgot->root.u.def.value
2850 + htab->hgot->root.u.def.section->output_offset
2851 + htab->hgot->root.u.def.section->output_section->vma);
2852
2853 return address - got_base;
2854}
2855
22b75d0a
DM		 2856/* Relocate a SPARC ELF section. */
2857
2858bfd_boolean
ab96bf03
AM		 2859_bfd_sparc_elf_relocate_section (bfd *output_bfd,
2860 struct bfd_link_info *info,
2861 bfd *input_bfd,
2862 asection *input_section,
2863 bfd_byte *contents,
2864 Elf_Internal_Rela *relocs,
2865 Elf_Internal_Sym *local_syms,
2866 asection **local_sections)
22b75d0a
DM		 2867{
2868 struct _bfd_sparc_elf_link_hash_table *htab;
2869 Elf_Internal_Shdr *symtab_hdr;
2870 struct elf_link_hash_entry **sym_hashes;
2871 bfd_vma *local_got_offsets;
2872 bfd_vma got_base;
2873 asection *sreloc;
2874 Elf_Internal_Rela *rel;
2875 Elf_Internal_Rela *relend;
2876 int num_relocs;
3348747a 2877 bfd_boolean is_vxworks_tls;
22b75d0a 2878
22b75d0a 2879 htab = _bfd_sparc_elf_hash_table (info);
4dfe6ac6 2880 BFD_ASSERT (htab != NULL);
0ffa91dd 2881 symtab_hdr = &elf_symtab_hdr (input_bfd);
22b75d0a
DM		 2882 sym_hashes = elf_sym_hashes (input_bfd);
2883 local_got_offsets = elf_local_got_offsets (input_bfd);
2884
2885 if (elf_hash_table (info)->hgot == NULL)
2886 got_base = 0;
2887 else
2888 got_base = elf_hash_table (info)->hgot->root.u.def.value;
2889
2890 sreloc = elf_section_data (input_section)->sreloc;
3348747a
NS		 2891 /* We have to handle relocations in vxworks .tls_vars sections
2892 specially, because the dynamic loader is 'weird'. */
2893 is_vxworks_tls = (htab->is_vxworks && info->shared
2894 && !strcmp (input_section->output_section->name,
2895 ".tls_vars"));
22b75d0a
DM		 2896
2897 rel = relocs;
2898 if (ABI_64_P (output_bfd))
d4730f92 2899 num_relocs = NUM_SHDR_ENTRIES (_bfd_elf_single_rel_hdr (input_section));
22b75d0a
DM		 2900 else
2901 num_relocs = input_section->reloc_count;
2902 relend = relocs + num_relocs;
2903 for (; rel < relend; rel++)
2904 {
2905 int r_type, tls_type;
2906 reloc_howto_type *howto;
2907 unsigned long r_symndx;
2908 struct elf_link_hash_entry *h;
2909 Elf_Internal_Sym *sym;
2910 asection *sec;
2911 bfd_vma relocation, off;
2912 bfd_reloc_status_type r;
2913 bfd_boolean is_plt = FALSE;
2914 bfd_boolean unresolved_reloc;
2915
2916 r_type = SPARC_ELF_R_TYPE (rel->r_info);
2917 if (r_type == R_SPARC_GNU_VTINHERIT
2918 || r_type == R_SPARC_GNU_VTENTRY)
2919 continue;
2920
2921 if (r_type < 0 || r_type >= (int) R_SPARC_max_std)
2922 {
2923 bfd_set_error (bfd_error_bad_value);
2924 return FALSE;
2925 }
2926 howto = _bfd_sparc_elf_howto_table + r_type;
2927
22b75d0a
DM		 2928 r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
2929 h = NULL;
2930 sym = NULL;
2931 sec = NULL;
2932 unresolved_reloc = FALSE;
2933 if (r_symndx < symtab_hdr->sh_info)
2934 {
2935 sym = local_syms + r_symndx;
2936 sec = local_sections[r_symndx];
2937 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
d0c9aeb3
DM		 2938
2939 if (!info->relocatable
2940 && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
2941 {
2942 /* Relocate against local STT_GNU_IFUNC symbol. */
2943 h = elf_sparc_get_local_sym_hash (htab, input_bfd,
2944 rel, FALSE);
2945 if (h == NULL)
2946 abort ();
2947
2948 /* Set STT_GNU_IFUNC symbol value. */
2949 h->root.u.def.value = sym->st_value;
2950 h->root.u.def.section = sec;
2951 }
22b75d0a
DM		 2952 }
2953 else
2954 {
2955 bfd_boolean warned;
2956
2957 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2958 r_symndx, symtab_hdr, sym_hashes,
2959 h, sec, relocation,
2960 unresolved_reloc, warned);
2961 if (warned)
2962 {
2963 /* To avoid generating warning messages about truncated
2964 relocations, set the relocation's address to be the same as
2965 the start of this section. */
2966 if (input_section->output_section != NULL)
2967 relocation = input_section->output_section->vma;
2968 else
2969 relocation = 0;
2970 }
2971 }
2972
ab96bf03 2973 if (sec != NULL && elf_discarded_section (sec))
e4067dbb
DJ		 2974 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
2975 rel, relend, howto, contents);
ab96bf03
AM		 2976
2977 if (info->relocatable)
2978 continue;
2979
d0c9aeb3
DM		 2980 if (h != NULL
2981 && h->type == STT_GNU_IFUNC
2982 && h->def_regular)
2983 {
2984 asection *plt_sec;
2985 const char *name;
2986
2987 if ((input_section->flags & SEC_ALLOC) == 0
2988 || h->plt.offset == (bfd_vma) -1)
2989 abort ();
2990
2991 plt_sec = htab->elf.splt;
2992 if (! plt_sec)
2993 plt_sec =htab->elf.iplt;
2994
2995 switch (r_type)
2996 {
00c50991
DM		 2997 case R_SPARC_GOTDATA_OP:
2998 continue;
2999
d0c9aeb3
DM		 3000 case R_SPARC_GOTDATA_OP_HIX22:
3001 case R_SPARC_GOTDATA_OP_LOX10:
00c50991
DM		 3002 r_type = (r_type == R_SPARC_GOTDATA_OP_HIX22
3003 ? R_SPARC_GOT22
3004 : R_SPARC_GOT10);
3005 howto = _bfd_sparc_elf_howto_table + r_type;
3006 /* Fall through. */
3007
d0c9aeb3
DM		 3008 case R_SPARC_GOT10:
3009 case R_SPARC_GOT13:
3010 case R_SPARC_GOT22:
3011 if (htab->elf.sgot == NULL)
3012 abort ();
3013 off = h->got.offset;
3014 if (off == (bfd_vma) -1)
3015 abort();
3016 relocation = htab->elf.sgot->output_offset + off - got_base;
3017 goto do_relocation;
3018
3019 case R_SPARC_WPLT30:
3020 case R_SPARC_WDISP30:
3021 relocation = (plt_sec->output_section->vma
3022 + plt_sec->output_offset + h->plt.offset);
3023 goto do_relocation;
3024
3025 case R_SPARC_32:
3026 case R_SPARC_64:
3027 if (info->shared && h->non_got_ref)
3028 {
3029 Elf_Internal_Rela outrel;
3030 bfd_vma offset;
3031
3032 offset = _bfd_elf_section_offset (output_bfd, info,
3033 input_section,
3034 rel->r_offset);
3035 if (offset == (bfd_vma) -1
3036 || offset == (bfd_vma) -2)
3037 abort();
3038
3039 outrel.r_offset = (input_section->output_section->vma
3040 + input_section->output_offset
3041 + offset);
3042
3043 if (h->dynindx == -1
3044 || h->forced_local
3045 || info->executable)
3046 {
3047 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
3048 0, R_SPARC_IRELATIVE);
3049 outrel.r_addend = relocation + rel->r_addend;
3050 }
3051 else
3052 {
3053 if (h->dynindx == -1)
3054 abort();
3055 outrel.r_info = SPARC_ELF_R_INFO (htab, rel, h->dynindx, r_type);
3056 outrel.r_addend = rel->r_addend;
3057 }
3058
3059 sparc_elf_append_rela (output_bfd, sreloc, &outrel);
3060 continue;
3061 }
3062
3063 relocation = (plt_sec->output_section->vma
3064 + plt_sec->output_offset + h->plt.offset);
3065 goto do_relocation;
3066
3067 case R_SPARC_HI22:
3068 case R_SPARC_LO10:
3069 /* We should only see such relocs in static links. */
3070 if (info->shared)
3071 abort();
3072 relocation = (plt_sec->output_section->vma
3073 + plt_sec->output_offset + h->plt.offset);
3074 goto do_relocation;
3075
3076 default:
3077 if (h->root.root.string)
3078 name = h->root.root.string;
3079 else
3080 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3081 NULL);
3082 (*_bfd_error_handler)
3083 (_("%B: relocation %s against STT_GNU_IFUNC "
3084 "symbol `%s' isn't handled by %s"), input_bfd,
3085 _bfd_sparc_elf_howto_table[r_type].name,
3086 name, __FUNCTION__);
3087 bfd_set_error (bfd_error_bad_value);
3088 return FALSE;
3089 }
3090 }
3091
22b75d0a
DM		 3092 switch (r_type)
3093 {
739f7f82
DM		 3094 case R_SPARC_GOTDATA_OP_HIX22:
3095 case R_SPARC_GOTDATA_OP_LOX10:
00c50991
DM		 3096 if (SYMBOL_REFERENCES_LOCAL (info, h))
3097 r_type = (r_type == R_SPARC_GOTDATA_OP_HIX22
3098 ? R_SPARC_GOTDATA_HIX22
3099 : R_SPARC_GOTDATA_LOX10);
739f7f82 3100 else
00c50991
DM		 3101 r_type = (r_type == R_SPARC_GOTDATA_OP_HIX22
3102 ? R_SPARC_GOT22
3103 : R_SPARC_GOT10);
3104 howto = _bfd_sparc_elf_howto_table + r_type;
3105 break;
3106
3107 case R_SPARC_GOTDATA_OP:
3108 if (SYMBOL_REFERENCES_LOCAL (info, h))
3109 {
3110 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3111
3112 /* {ld,ldx} [%rs1 + %rs2], %rd --> add %rs1, %rs2, %rd */
3113 relocation = 0x80000000 | (insn & 0x3e07c01f);
3114 bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3115 }
3116 continue;
3117 }
3118
3119 switch (r_type)
3120 {
3121 case R_SPARC_GOTDATA_HIX22:
3122 case R_SPARC_GOTDATA_LOX10:
3123 relocation = gdopoff (info, relocation);
3124 break;
739f7f82 3125
22b75d0a
DM		 3126 case R_SPARC_GOT10:
3127 case R_SPARC_GOT13:
3128 case R_SPARC_GOT22:
3129 /* Relocation is to the entry for this symbol in the global
3130 offset table. */
72fbc6e5 3131 if (htab->elf.sgot == NULL)
22b75d0a
DM		 3132 abort ();
3133
3134 if (h != NULL)
3135 {
3136 bfd_boolean dyn;
3137
3138 off = h->got.offset;
3139 BFD_ASSERT (off != (bfd_vma) -1);
3140 dyn = elf_hash_table (info)->dynamic_sections_created;
3141
3142 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3143 || (info->shared
72fbc6e5 3144 && SYMBOL_REFERENCES_LOCAL (info, h)))
22b75d0a
DM		 3145 {
3146 /* This is actually a static link, or it is a
3147 -Bsymbolic link and the symbol is defined
3148 locally, or the symbol was forced to be local
3149 because of a version file. We must initialize
3150 this entry in the global offset table. Since the
3151 offset must always be a multiple of 8 for 64-bit
3152 and 4 for 32-bit, we use the least significant bit
3153 to record whether we have initialized it already.
3154
3155 When doing a dynamic link, we create a .rela.got
3156 relocation entry to initialize the value. This
3157 is done in the finish_dynamic_symbol routine. */
3158 if ((off & 1) != 0)
3159 off &= ~1;
3160 else
3161 {
3162 SPARC_ELF_PUT_WORD (htab, output_bfd, relocation,
72fbc6e5 3163 htab->elf.sgot->contents + off);
22b75d0a
DM		 3164 h->got.offset |= 1;
3165 }
3166 }
3167 else
3168 unresolved_reloc = FALSE;
3169 }
3170 else
3171 {
3172 BFD_ASSERT (local_got_offsets != NULL
3173 && local_got_offsets[r_symndx] != (bfd_vma) -1);
3174
3175 off = local_got_offsets[r_symndx];
3176
3177 /* The offset must always be a multiple of 8 on 64-bit and
3178 4 on 32-bit. We use the least significant bit to record
3179 whether we have already processed this entry. */
3180 if ((off & 1) != 0)
3181 off &= ~1;
3182 else
3183 {
3184
3185 if (info->shared)
3186 {
3187 asection *s;
3188 Elf_Internal_Rela outrel;
3189
3190 /* We need to generate a R_SPARC_RELATIVE reloc
3191 for the dynamic linker. */
72fbc6e5 3192 s = htab->elf.srelgot;
22b75d0a
DM		 3193 BFD_ASSERT (s != NULL);
3194
72fbc6e5
DM		 3195 outrel.r_offset = (htab->elf.sgot->output_section->vma
3196 + htab->elf.sgot->output_offset
22b75d0a
DM		 3197 + off);
3198 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
3199 0, R_SPARC_RELATIVE);
3200 outrel.r_addend = relocation;
3201 relocation = 0;
39817122 3202 sparc_elf_append_rela (output_bfd, s, &outrel);
22b75d0a
DM		 3203 }
3204
3205 SPARC_ELF_PUT_WORD (htab, output_bfd, relocation,
72fbc6e5 3206 htab->elf.sgot->contents + off);
22b75d0a
DM		 3207 local_got_offsets[r_symndx] |= 1;
3208 }
3209 }
72fbc6e5 3210 relocation = htab->elf.sgot->output_offset + off - got_base;
22b75d0a
DM		 3211 break;
3212
3213 case R_SPARC_PLT32:
3214 case R_SPARC_PLT64:
3215 if (h == NULL || h->plt.offset == (bfd_vma) -1)
3216 {
3217 r_type = (r_type == R_SPARC_PLT32) ? R_SPARC_32 : R_SPARC_64;
3218 goto r_sparc_plt32;
3219 }
3220 /* Fall through. */
3221
3222 case R_SPARC_WPLT30:
3223 case R_SPARC_HIPLT22:
3224 case R_SPARC_LOPLT10:
3225 case R_SPARC_PCPLT32:
3226 case R_SPARC_PCPLT22:
3227 case R_SPARC_PCPLT10:
3228 r_sparc_wplt30:
3229 /* Relocation is to the entry for this symbol in the
3230 procedure linkage table. */
3231
3232 if (! ABI_64_P (output_bfd))
3233 {
3234 /* The Solaris native assembler will generate a WPLT30 reloc
3235 for a local symbol if you assemble a call from one
3236 section to another when using -K pic. We treat it as
3237 WDISP30. */
3238 if (h == NULL)
3239 break;
3240 }
af1fb11f
NC		 3241 /* PR 7027: We need similar behaviour for 64-bit binaries. */
3242 else if (r_type == R_SPARC_WPLT30 && h == NULL)
3243 break;
22b75d0a
DM		 3244 else
3245 {
3246 BFD_ASSERT (h != NULL);
3247 }
3248
72fbc6e5 3249 if (h->plt.offset == (bfd_vma) -1 || htab->elf.splt == NULL)
22b75d0a
DM		 3250 {
3251 /* We didn't make a PLT entry for this symbol. This
3252 happens when statically linking PIC code, or when
3253 using -Bsymbolic. */
3254 break;
3255 }
3256
72fbc6e5
DM		 3257 relocation = (htab->elf.splt->output_section->vma
3258 + htab->elf.splt->output_offset
22b75d0a
DM		 3259 + h->plt.offset);
3260 unresolved_reloc = FALSE;
3261 if (r_type == R_SPARC_PLT32 || r_type == R_SPARC_PLT64)
3262 {
3263 r_type = r_type == R_SPARC_PLT32 ? R_SPARC_32 : R_SPARC_64;
3264 is_plt = TRUE;
3265 goto r_sparc_plt32;
3266 }
3267 break;
3268
3269 case R_SPARC_PC10:
3270 case R_SPARC_PC22:
3271 case R_SPARC_PC_HH22:
3272 case R_SPARC_PC_HM10:
3273 case R_SPARC_PC_LM22:
3274 if (h != NULL
3275 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3276 break;
3277 /* Fall through. */
3278 case R_SPARC_DISP8:
3279 case R_SPARC_DISP16:
3280 case R_SPARC_DISP32:
3281 case R_SPARC_DISP64:
3282 case R_SPARC_WDISP30:
3283 case R_SPARC_WDISP22:
3284 case R_SPARC_WDISP19:
3285 case R_SPARC_WDISP16:
3286 case R_SPARC_8:
3287 case R_SPARC_16:
3288 case R_SPARC_32:
3289 case R_SPARC_HI22:
3290 case R_SPARC_22:
3291 case R_SPARC_13:
3292 case R_SPARC_LO10:
3293 case R_SPARC_UA16:
3294 case R_SPARC_UA32:
3295 case R_SPARC_10:
3296 case R_SPARC_11:
3297 case R_SPARC_64:
3298 case R_SPARC_OLO10:
3299 case R_SPARC_HH22:
3300 case R_SPARC_HM10:
3301 case R_SPARC_LM22:
3302 case R_SPARC_7:
3303 case R_SPARC_5:
3304 case R_SPARC_6:
3305 case R_SPARC_HIX22:
3306 case R_SPARC_LOX10:
3307 case R_SPARC_H44:
3308 case R_SPARC_M44:
3309 case R_SPARC_L44:
3310 case R_SPARC_UA64:
3311 r_sparc_plt32:
3348747a
NS		 3312 if ((input_section->flags & SEC_ALLOC) == 0
3313 || is_vxworks_tls)
22b75d0a
DM		 3314 break;
3315
3316 if ((info->shared
3317 && (h == NULL
3318 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3319 || h->root.type != bfd_link_hash_undefweak)
3320 && (! howto->pc_relative
72fbc6e5 3321 || !SYMBOL_CALLS_LOCAL (info, h)))
22b75d0a
DM		 3322 || (!info->shared
3323 && h != NULL
3324 && h->dynindx != -1
3325 && !h->non_got_ref
3326 && ((h->def_dynamic
3327 && !h->def_regular)
3328 || h->root.type == bfd_link_hash_undefweak
3329 || h->root.type == bfd_link_hash_undefined)))
3330 {
3331 Elf_Internal_Rela outrel;
3332 bfd_boolean skip, relocate = FALSE;
3333
3334 /* When generating a shared object, these relocations
3335 are copied into the output file to be resolved at run
3336 time. */
3337
3338 BFD_ASSERT (sreloc != NULL);
3339
3340 skip = FALSE;
3341
3342 outrel.r_offset =
3343 _bfd_elf_section_offset (output_bfd, info, input_section,
3344 rel->r_offset);
3345 if (outrel.r_offset == (bfd_vma) -1)
3346 skip = TRUE;
3347 else if (outrel.r_offset == (bfd_vma) -2)
3348 skip = TRUE, relocate = TRUE;
3349 outrel.r_offset += (input_section->output_section->vma
3350 + input_section->output_offset);
3351
3352 /* Optimize unaligned reloc usage now that we know where
3353 it finally resides. */
3354 switch (r_type)
3355 {
3356 case R_SPARC_16:
3357 if (outrel.r_offset & 1)
3358 r_type = R_SPARC_UA16;
3359 break;
3360 case R_SPARC_UA16:
3361 if (!(outrel.r_offset & 1))
3362 r_type = R_SPARC_16;
3363 break;
3364 case R_SPARC_32:
3365 if (outrel.r_offset & 3)
3366 r_type = R_SPARC_UA32;
3367 break;
3368 case R_SPARC_UA32:
3369 if (!(outrel.r_offset & 3))
3370 r_type = R_SPARC_32;
3371 break;
3372 case R_SPARC_64:
3373 if (outrel.r_offset & 7)
3374 r_type = R_SPARC_UA64;
3375 break;
3376 case R_SPARC_UA64:
3377 if (!(outrel.r_offset & 7))
3378 r_type = R_SPARC_64;
3379 break;
3380 case R_SPARC_DISP8:
3381 case R_SPARC_DISP16:
3382 case R_SPARC_DISP32:
3383 case R_SPARC_DISP64:
3384 /* If the symbol is not dynamic, we should not keep
3385 a dynamic relocation. But an .rela.* slot has been
3386 allocated for it, output R_SPARC_NONE.
3387 FIXME: Add code tracking needed dynamic relocs as
3388 e.g. i386 has. */
3389 if (h->dynindx == -1)
3390 skip = TRUE, relocate = TRUE;
3391 break;
3392 }
3393
3394 if (skip)
3395 memset (&outrel, 0, sizeof outrel);
3396 /* h->dynindx may be -1 if the symbol was marked to
3397 become local. */
72fbc6e5
DM		 3398 else if (h != NULL &&
3399 h->dynindx != -1
3400 && (! is_plt
3401 || !info->shared
3402 || !SYMBOLIC_BIND (info, h)
22b75d0a
DM		 3403 || !h->def_regular))
3404 {
3405 BFD_ASSERT (h->dynindx != -1);
3406 outrel.r_info = SPARC_ELF_R_INFO (htab, rel, h->dynindx, r_type);
3407 outrel.r_addend = rel->r_addend;
3408 }
3409 else
3410 {
3411 if (r_type == R_SPARC_32 || r_type == R_SPARC_64)
3412 {
3413 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
3414 0, R_SPARC_RELATIVE);
3415 outrel.r_addend = relocation + rel->r_addend;
3416 }
3417 else
3418 {
3419 long indx;
3420
74541ad4
AM		 3421 outrel.r_addend = relocation + rel->r_addend;
3422
22b75d0a 3423 if (is_plt)
72fbc6e5 3424 sec = htab->elf.splt;
22b75d0a
DM		 3425
3426 if (bfd_is_abs_section (sec))
3427 indx = 0;
3428 else if (sec == NULL || sec->owner == NULL)
3429 {
3430 bfd_set_error (bfd_error_bad_value);
3431 return FALSE;
3432 }
3433 else
3434 {
3435 asection *osec;
3436
74541ad4
AM		 3437 /* We are turning this relocation into one
3438 against a section symbol. It would be
3439 proper to subtract the symbol's value,
3440 osec->vma, from the emitted reloc addend,
3441 but ld.so expects buggy relocs. */
22b75d0a
DM		 3442 osec = sec->output_section;
3443 indx = elf_section_data (osec)->dynindx;
3444
74541ad4
AM		 3445 if (indx == 0)
3446 {
3447 osec = htab->elf.text_index_section;
3448 indx = elf_section_data (osec)->dynindx;
3449 }
3450
22b75d0a
DM		 3451 /* FIXME: we really should be able to link non-pic
3452 shared libraries. */
3453 if (indx == 0)
3454 {
3455 BFD_FAIL ();
3456 (*_bfd_error_handler)
3457 (_("%B: probably compiled without -fPIC?"),
3458 input_bfd);
3459 bfd_set_error (bfd_error_bad_value);
3460 return FALSE;
3461 }
3462 }
3463
74541ad4
AM		 3464 outrel.r_info = SPARC_ELF_R_INFO (htab, rel, indx,
3465 r_type);
22b75d0a
DM		 3466 }
3467 }
3468
39817122 3469 sparc_elf_append_rela (output_bfd, sreloc, &outrel);
22b75d0a
DM		 3470
3471 /* This reloc will be computed at runtime, so there's no
3472 need to do anything now. */
3473 if (! relocate)
3474 continue;
3475 }
3476 break;
3477
3478 case R_SPARC_TLS_GD_HI22:
3479 if (! ABI_64_P (input_bfd)
3480 && ! _bfd_sparc_elf_tdata (input_bfd)->has_tlsgd)
3481 {
3482 /* R_SPARC_REV32 used the same reloc number as
3483 R_SPARC_TLS_GD_HI22. */
3484 r_type = R_SPARC_REV32;
3485 break;
3486 }
3487 /* Fall through */
3488
3489 case R_SPARC_TLS_GD_LO10:
3490 case R_SPARC_TLS_IE_HI22:
3491 case R_SPARC_TLS_IE_LO10:
3492 r_type = sparc_elf_tls_transition (info, input_bfd, r_type, h == NULL);
3493 tls_type = GOT_UNKNOWN;
3494 if (h == NULL && local_got_offsets)
3495 tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3496 else if (h != NULL)
3497 {
3498 tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3499 if (!info->shared && h->dynindx == -1 && tls_type == GOT_TLS_IE)
3500 switch (SPARC_ELF_R_TYPE (rel->r_info))
3501 {
3502 case R_SPARC_TLS_GD_HI22:
3503 case R_SPARC_TLS_IE_HI22:
3504 r_type = R_SPARC_TLS_LE_HIX22;
3505 break;
3506 default:
3507 r_type = R_SPARC_TLS_LE_LOX10;
3508 break;
3509 }
3510 }
3511 if (tls_type == GOT_TLS_IE)
3512 switch (r_type)
3513 {
3514 case R_SPARC_TLS_GD_HI22:
3515 r_type = R_SPARC_TLS_IE_HI22;
3516 break;
3517 case R_SPARC_TLS_GD_LO10:
3518 r_type = R_SPARC_TLS_IE_LO10;
3519 break;
3520 }
3521
3522 if (r_type == R_SPARC_TLS_LE_HIX22)
3523 {
3524 relocation = tpoff (info, relocation);
3525 break;
3526 }
3527 if (r_type == R_SPARC_TLS_LE_LOX10)
3528 {
3529 /* Change add into xor. */
3530 relocation = tpoff (info, relocation);
3531 bfd_put_32 (output_bfd, (bfd_get_32 (input_bfd,
3532 contents + rel->r_offset)
3533 | 0x80182000), contents + rel->r_offset);
3534 break;
3535 }
3536
3537 if (h != NULL)
3538 {
3539 off = h->got.offset;
3540 h->got.offset |= 1;
3541 }
3542 else
3543 {
3544 BFD_ASSERT (local_got_offsets != NULL);
3545 off = local_got_offsets[r_symndx];
3546 local_got_offsets[r_symndx] |= 1;
3547 }
3548
3549 r_sparc_tlsldm:
72fbc6e5 3550 if (htab->elf.sgot == NULL)
22b75d0a
DM		 3551 abort ();
3552
3553 if ((off & 1) != 0)
3554 off &= ~1;
3555 else
3556 {
3557 Elf_Internal_Rela outrel;
3558 int dr_type, indx;
3559
72fbc6e5 3560 if (htab->elf.srelgot == NULL)
22b75d0a
DM		 3561 abort ();
3562
72fbc6e5
DM		 3563 SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3564 htab->elf.sgot->contents + off);
3565 outrel.r_offset = (htab->elf.sgot->output_section->vma
3566 + htab->elf.sgot->output_offset + off);
22b75d0a
DM		 3567 indx = h && h->dynindx != -1 ? h->dynindx : 0;
3568 if (r_type == R_SPARC_TLS_IE_HI22
3569 || r_type == R_SPARC_TLS_IE_LO10)
3570 dr_type = SPARC_ELF_TPOFF_RELOC (htab);
3571 else
3572 dr_type = SPARC_ELF_DTPMOD_RELOC (htab);
3573 if (dr_type == SPARC_ELF_TPOFF_RELOC (htab) && indx == 0)
3574 outrel.r_addend = relocation - dtpoff_base (info);
3575 else
3576 outrel.r_addend = 0;
3577 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx, dr_type);
72fbc6e5 3578 sparc_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel);
22b75d0a
DM		 3579
3580 if (r_type == R_SPARC_TLS_GD_HI22
3581 || r_type == R_SPARC_TLS_GD_LO10)
3582 {
3583 if (indx == 0)
3584 {
3585 BFD_ASSERT (! unresolved_reloc);
3586 SPARC_ELF_PUT_WORD (htab, output_bfd,
3587 relocation - dtpoff_base (info),
72fbc6e5 3588 (htab->elf.sgot->contents + off
22b75d0a
DM		 3589 + SPARC_ELF_WORD_BYTES (htab)));
3590 }
3591 else
3592 {
3593 SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
72fbc6e5 3594 (htab->elf.sgot->contents + off
22b75d0a
DM		 3595 + SPARC_ELF_WORD_BYTES (htab)));
3596 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx,
3597 SPARC_ELF_DTPOFF_RELOC (htab));
3598 outrel.r_offset += SPARC_ELF_WORD_BYTES (htab);
72fbc6e5 3599 sparc_elf_append_rela (output_bfd, htab->elf.srelgot,
39817122 3600 &outrel);
22b75d0a
DM		 3601 }
3602 }
3603 else if (dr_type == SPARC_ELF_DTPMOD_RELOC (htab))
3604 {
3605 SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
72fbc6e5 3606 (htab->elf.sgot->contents + off
22b75d0a
DM		 3607 + SPARC_ELF_WORD_BYTES (htab)));
3608 }
3609 }
3610
3611 if (off >= (bfd_vma) -2)
3612 abort ();
3613
72fbc6e5 3614 relocation = htab->elf.sgot->output_offset + off - got_base;
22b75d0a
DM		 3615 unresolved_reloc = FALSE;
3616 howto = _bfd_sparc_elf_howto_table + r_type;
3617 break;
3618
3619 case R_SPARC_TLS_LDM_HI22:
3620 case R_SPARC_TLS_LDM_LO10:
3621 if (! info->shared)
3622 {
3623 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3624 continue;
3625 }
3626 off = htab->tls_ldm_got.offset;
3627 htab->tls_ldm_got.offset |= 1;
3628 goto r_sparc_tlsldm;
3629
3630 case R_SPARC_TLS_LDO_HIX22:
3631 case R_SPARC_TLS_LDO_LOX10:
3632 if (info->shared)
3633 {
3634 relocation -= dtpoff_base (info);
3635 break;
3636 }
3637
3638 r_type = (r_type == R_SPARC_TLS_LDO_HIX22
3639 ? R_SPARC_TLS_LE_HIX22 : R_SPARC_TLS_LE_LOX10);
3640 /* Fall through. */
3641
3642 case R_SPARC_TLS_LE_HIX22:
3643 case R_SPARC_TLS_LE_LOX10:
3644 if (info->shared)
3645 {
3646 Elf_Internal_Rela outrel;
c7e2358a 3647 bfd_boolean skip;
22b75d0a
DM		 3648
3649 BFD_ASSERT (sreloc != NULL);
3650 skip = FALSE;
3651 outrel.r_offset =
3652 _bfd_elf_section_offset (output_bfd, info, input_section,
3653 rel->r_offset);
3654 if (outrel.r_offset == (bfd_vma) -1)
3655 skip = TRUE;
3656 else if (outrel.r_offset == (bfd_vma) -2)
c7e2358a 3657 skip = TRUE;
22b75d0a
DM		 3658 outrel.r_offset += (input_section->output_section->vma
3659 + input_section->output_offset);
3660 if (skip)
3661 memset (&outrel, 0, sizeof outrel);
3662 else
3663 {
3664 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, r_type);
3665 outrel.r_addend = relocation - dtpoff_base (info)
3666 + rel->r_addend;
3667 }
3668
39817122 3669 sparc_elf_append_rela (output_bfd, sreloc, &outrel);
22b75d0a
DM		 3670 continue;
3671 }
3672 relocation = tpoff (info, relocation);
3673 break;
3674
3675 case R_SPARC_TLS_LDM_CALL:
3676 if (! info->shared)
3677 {
3678 /* mov %g0, %o0 */
3679 bfd_put_32 (output_bfd, 0x90100000, contents + rel->r_offset);
3680 continue;
3681 }
3682 /* Fall through */
3683
3684 case R_SPARC_TLS_GD_CALL:
3685 tls_type = GOT_UNKNOWN;
3686 if (h == NULL && local_got_offsets)
3687 tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3688 else if (h != NULL)
3689 tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3690 if (! info->shared
3691 || (r_type == R_SPARC_TLS_GD_CALL && tls_type == GOT_TLS_IE))
3692 {
abd242a9 3693 Elf_Internal_Rela *rel2;
22b75d0a
DM		 3694 bfd_vma insn;
3695
3696 if (!info->shared && (h == NULL || h->dynindx == -1))
3697 {
3698 /* GD -> LE */
3699 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3700 continue;
3701 }
3702
3703 /* GD -> IE */
3704 if (rel + 1 < relend
3705 && SPARC_ELF_R_TYPE (rel[1].r_info) == R_SPARC_TLS_GD_ADD
3706 && rel[1].r_offset == rel->r_offset + 4
3707 && SPARC_ELF_R_SYMNDX (htab, rel[1].r_info) == r_symndx
3708 && (((insn = bfd_get_32 (input_bfd,
3709 contents + rel[1].r_offset))
3710 >> 25) & 0x1f) == 8)
3711 {
3712 /* We have
3713 call __tls_get_addr, %tgd_call(foo)
3714 add %reg1, %reg2, %o0, %tgd_add(foo)
3715 and change it into IE:
3716 {ld,ldx} [%reg1 + %reg2], %o0, %tie_ldx(foo)
3717 add %g7, %o0, %o0, %tie_add(foo).
3718 add is 0x80000000 | (rd << 25) | (rs1 << 14) | rs2,
3719 ld is 0xc0000000 | (rd << 25) | (rs1 << 14) | rs2,
3720 ldx is 0xc0580000 | (rd << 25) | (rs1 << 14) | rs2. */
3721 bfd_put_32 (output_bfd, insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000),
3722 contents + rel->r_offset);
3723 bfd_put_32 (output_bfd, 0x9001c008,
3724 contents + rel->r_offset + 4);
3725 rel++;
3726 continue;
3727 }
3728
abd242a9
DM		 3729 /* We cannot just overwrite the delay slot instruction,
3730 as it might be what puts the %o0 argument to
3731 __tls_get_addr into place. So we have to transpose
3732 the delay slot with the add we patch in. */
3733 insn = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
3734 bfd_put_32 (output_bfd, insn,
3735 contents + rel->r_offset);
3736 bfd_put_32 (output_bfd, 0x9001c008,
3737 contents + rel->r_offset + 4);
3738
3739 rel2 = rel;
3740 while ((rel2 = sparc_elf_find_reloc_at_ofs (rel2 + 1, relend,
3741 rel->r_offset + 4))
3742 != NULL)
3743 {
3744 /* If the instruction we moved has a relocation attached to
3745 it, adjust the offset so that it will apply to the correct
3746 instruction. */
3747 rel2->r_offset -= 4;
3748 }
22b75d0a
DM		 3749 continue;
3750 }
3751
3752 h = (struct elf_link_hash_entry *)
3753 bfd_link_hash_lookup (info->hash, "__tls_get_addr", FALSE,
3754 FALSE, TRUE);
3755 BFD_ASSERT (h != NULL);
3756 r_type = R_SPARC_WPLT30;
3757 howto = _bfd_sparc_elf_howto_table + r_type;
3758 goto r_sparc_wplt30;
3759
3760 case R_SPARC_TLS_GD_ADD:
3761 tls_type = GOT_UNKNOWN;
3762 if (h == NULL && local_got_offsets)
3763 tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3764 else if (h != NULL)
3765 tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3766 if (! info->shared || tls_type == GOT_TLS_IE)
3767 {
3768 /* add %reg1, %reg2, %reg3, %tgd_add(foo)
3769 changed into IE:
3770 {ld,ldx} [%reg1 + %reg2], %reg3, %tie_ldx(foo)
3771 or LE:
3772 add %g7, %reg2, %reg3. */
3773 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3774 if ((h != NULL && h->dynindx != -1) || info->shared)
3775 relocation = insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000);
3776 else
3777 relocation = (insn & ~0x7c000) | 0x1c000;
3778 bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3779 }
3780 continue;
3781
3782 case R_SPARC_TLS_LDM_ADD:
3783 if (! info->shared)
3784 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3785 continue;
3786
3787 case R_SPARC_TLS_LDO_ADD:
3788 if (! info->shared)
3789 {
3790 /* Change rs1 into %g7. */
3791 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3792 insn = (insn & ~0x7c000) | 0x1c000;
3793 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3794 }
3795 continue;
3796
3797 case R_SPARC_TLS_IE_LD:
3798 case R_SPARC_TLS_IE_LDX:
3799 if (! info->shared && (h == NULL || h->dynindx == -1))
3800 {
3801 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3802 int rs2 = insn & 0x1f;
3803 int rd = (insn >> 25) & 0x1f;
3804
3805 if (rs2 == rd)
3806 relocation = SPARC_NOP;
3807 else
3808 relocation = 0x80100000 | (insn & 0x3e00001f);
3809 bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3810 }
3811 continue;
3812
3813 case R_SPARC_TLS_IE_ADD:
3814 /* Totally useless relocation. */
3815 continue;
3816
3817 case R_SPARC_TLS_DTPOFF32:
3818 case R_SPARC_TLS_DTPOFF64:
3819 relocation -= dtpoff_base (info);
3820 break;
3821
3822 default:
3823 break;
3824 }
3825
3826 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3827 because such sections are not SEC_ALLOC and thus ld.so will
3828 not process them. */
3829 if (unresolved_reloc
3830 && !((input_section->flags & SEC_DEBUGGING) != 0
3831 && h->def_dynamic))
3832 (*_bfd_error_handler)
843fe662 3833 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
22b75d0a
DM		 3834 input_bfd,
3835 input_section,
3836 (long) rel->r_offset,
843fe662 3837 howto->name,
22b75d0a
DM		 3838 h->root.root.string);
3839
3840 r = bfd_reloc_continue;
3841 if (r_type == R_SPARC_OLO10)
3842 {
3843 bfd_vma x;
3844
3845 if (! ABI_64_P (output_bfd))
3846 abort ();
3847
3848 relocation += rel->r_addend;
3849 relocation = (relocation & 0x3ff) + ELF64_R_TYPE_DATA (rel->r_info);
3850
3851 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3852 x = (x & ~(bfd_vma) 0x1fff) | (relocation & 0x1fff);
3853 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3854
3855 r = bfd_check_overflow (howto->complain_on_overflow,
3856 howto->bitsize, howto->rightshift,
3857 bfd_arch_bits_per_address (input_bfd),
3858 relocation);
3859 }
3860 else if (r_type == R_SPARC_WDISP16)
3861 {
3862 bfd_vma x;
3863
3864 relocation += rel->r_addend;
3865 relocation -= (input_section->output_section->vma
3866 + input_section->output_offset);
3867 relocation -= rel->r_offset;
3868
3869 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3870 x |= ((((relocation >> 2) & 0xc000) << 6)
3871 | ((relocation >> 2) & 0x3fff));
3872 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3873
3874 r = bfd_check_overflow (howto->complain_on_overflow,
3875 howto->bitsize, howto->rightshift,
3876 bfd_arch_bits_per_address (input_bfd),
3877 relocation);
3878 }
3879 else if (r_type == R_SPARC_REV32)
3880 {
3881 bfd_vma x;
3882
3883 relocation = relocation + rel->r_addend;
3884
3885 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3886 x = x + relocation;
3887 bfd_putl32 (/*input_bfd,*/ x, contents + rel->r_offset);
3888 r = bfd_reloc_ok;
3889 }
3890 else if (r_type == R_SPARC_TLS_LDO_HIX22
3891 || r_type == R_SPARC_TLS_LE_HIX22)
3892 {
3893 bfd_vma x;
3894
3895 relocation += rel->r_addend;
3896 if (r_type == R_SPARC_TLS_LE_HIX22)
3897 relocation ^= MINUS_ONE;
3898
3899 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3900 x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
3901 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3902 r = bfd_reloc_ok;
3903 }
3904 else if (r_type == R_SPARC_TLS_LDO_LOX10
3905 || r_type == R_SPARC_TLS_LE_LOX10)
3906 {
3907 bfd_vma x;
3908
3909 relocation += rel->r_addend;
3910 relocation &= 0x3ff;
3911 if (r_type == R_SPARC_TLS_LE_LOX10)
3912 relocation |= 0x1c00;
3913
3914 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3915 x = (x & ~(bfd_vma) 0x1fff) | relocation;
3916 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3917
3918 r = bfd_reloc_ok;
3919 }
00c50991
DM		 3920 else if (r_type == R_SPARC_HIX22
3921 || r_type == R_SPARC_GOTDATA_HIX22)
22b75d0a
DM		 3922 {
3923 bfd_vma x;
3924
3925 relocation += rel->r_addend;
00c50991
DM		 3926 if (r_type == R_SPARC_HIX22
3927 || (bfd_signed_vma) relocation < 0)
3928 relocation = relocation ^ MINUS_ONE;
22b75d0a
DM		 3929
3930 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3931 x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
3932 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3933
3934 r = bfd_check_overflow (howto->complain_on_overflow,
3935 howto->bitsize, howto->rightshift,
3936 bfd_arch_bits_per_address (input_bfd),
3937 relocation);
3938 }
00c50991
DM		 3939 else if (r_type == R_SPARC_LOX10
3940 || r_type == R_SPARC_GOTDATA_LOX10)
22b75d0a
DM		 3941 {
3942 bfd_vma x;
3943
3944 relocation += rel->r_addend;
00c50991
DM		 3945 if (r_type == R_SPARC_LOX10
3946 || (bfd_signed_vma) relocation < 0)
3947 relocation = (relocation & 0x3ff) | 0x1c00;
3948 else
3949 relocation = (relocation & 0x3ff);
22b75d0a
DM		 3950
3951 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3952 x = (x & ~(bfd_vma) 0x1fff) | relocation;
3953 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3954
3955 r = bfd_reloc_ok;
3956 }
3957 else if ((r_type == R_SPARC_WDISP30 || r_type == R_SPARC_WPLT30)
3958 && sec_do_relax (input_section)
3959 && rel->r_offset + 4 < input_section->size)
3960 {
3961#define G0 0
3962#define O7 15
3963#define XCC (2 << 20)
3964#define COND(x) (((x)&0xf)<<25)
3965#define CONDA COND(0x8)
3966#define INSN_BPA (F2(0,1) | CONDA | BPRED | XCC)
3967#define INSN_BA (F2(0,2) | CONDA)
3968#define INSN_OR F3(2, 0x2, 0)
3969#define INSN_NOP F2(0,4)
3970
3971 bfd_vma x, y;
3972
3973 /* If the instruction is a call with either:
3974 restore
3975 arithmetic instruction with rd == %o7
3976 where rs1 != %o7 and rs2 if it is register != %o7
3977 then we can optimize if the call destination is near
3978 by changing the call into a branch always. */
3979 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3980 y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
3981 if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2))
3982 {
3983 if (((y & OP3(~0)) == OP3(0x3d) /* restore */
3984 || ((y & OP3(0x28)) == 0 /* arithmetic */
3985 && (y & RD(~0)) == RD(O7)))
3986 && (y & RS1(~0)) != RS1(O7)
3987 && ((y & F3I(~0))
3988 || (y & RS2(~0)) != RS2(O7)))
3989 {
3990 bfd_vma reloc;
3991
3992 reloc = relocation + rel->r_addend - rel->r_offset;
3993 reloc -= (input_section->output_section->vma
3994 + input_section->output_offset);
3995
3996 /* Ensure the branch fits into simm22. */
3997 if ((reloc & 3) == 0
3998 && ((reloc & ~(bfd_vma)0x7fffff) == 0
3999 || ((reloc | 0x7fffff) == ~(bfd_vma)0)))
4000 {
4001 reloc >>= 2;
4002
4003 /* Check whether it fits into simm19. */
4004 if (((reloc & 0x3c0000) == 0
4005 || (reloc & 0x3c0000) == 0x3c0000)
4006 && (ABI_64_P (output_bfd)
4007 || elf_elfheader (output_bfd)->e_flags & EF_SPARC_32PLUS))
4008 x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */
4009 else
4010 x = INSN_BA | (reloc & 0x3fffff); /* ba */
4011 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
4012 r = bfd_reloc_ok;
4013 if (rel->r_offset >= 4
4014 && (y & (0xffffffff ^ RS1(~0)))
4015 == (INSN_OR | RD(O7) | RS2(G0)))
4016 {
4017 bfd_vma z;
4018 unsigned int reg;
4019
4020 z = bfd_get_32 (input_bfd,
4021 contents + rel->r_offset - 4);
4022 if ((z & (0xffffffff ^ RD(~0)))
4023 != (INSN_OR | RS1(O7) | RS2(G0)))
4024 break;
4025
4026 /* The sequence was
4027 or %o7, %g0, %rN
4028 call foo
4029 or %rN, %g0, %o7
4030
4031 If call foo was replaced with ba, replace
4032 or %rN, %g0, %o7 with nop. */
4033
4034 reg = (y & RS1(~0)) >> 14;
4035 if (reg != ((z & RD(~0)) >> 25)
4036 || reg == G0 || reg == O7)
4037 break;
4038
4039 bfd_put_32 (input_bfd, (bfd_vma) INSN_NOP,
4040 contents + rel->r_offset + 4);
4041 }
4042
4043 }
4044 }
4045 }
4046 }
4047
4048 if (r == bfd_reloc_continue)
d0c9aeb3
DM		 4049 {
4050do_relocation:
4051 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4052 contents, rel->r_offset,
4053 relocation, rel->r_addend);
4054 }
22b75d0a
DM		 4055 if (r != bfd_reloc_ok)
4056 {
4057 switch (r)
4058 {
4059 default:
4060 case bfd_reloc_outofrange:
4061 abort ();
4062 case bfd_reloc_overflow:
4063 {
4064 const char *name;
4065
dc669dc8
EB		 4066 /* The Solaris native linker silently disregards overflows.
4067 We don't, but this breaks stabs debugging info, whose
4068 relocations are only 32-bits wide. Ignore overflows in
4069 this case and also for discarded entries. */
4070 if ((r_type == R_SPARC_32 || r_type == R_SPARC_DISP32)
4071 && (((input_section->flags & SEC_DEBUGGING) != 0
4072 && strcmp (bfd_section_name (input_bfd,
4073 input_section),
4074 ".stab") == 0)
4075 || _bfd_elf_section_offset (output_bfd, info,
4076 input_section,
4077 rel->r_offset)
4078 == (bfd_vma)-1))
4079 break;
4080
22b75d0a 4081 if (h != NULL)
bb29dfea
EB		 4082 {
4083 /* Assume this is a call protected by other code that
4084 detect the symbol is undefined. If this is the case,
4085 we can safely ignore the overflow. If not, the
4086 program is hosed anyway, and a little warning isn't
4087 going to help. */
4088 if (h->root.type == bfd_link_hash_undefweak
4089 && howto->pc_relative)
4090 break;
4091
4092 name = NULL;
4093 }
22b75d0a
DM		 4094 else
4095 {
4096 name = bfd_elf_string_from_elf_section (input_bfd,
4097 symtab_hdr->sh_link,
4098 sym->st_name);
4099 if (name == NULL)
4100 return FALSE;
4101 if (*name == '\0')
4102 name = bfd_section_name (input_bfd, sec);
4103 }
4104 if (! ((*info->callbacks->reloc_overflow)
4105 (info, (h ? &h->root : NULL), name, howto->name,
4106 (bfd_vma) 0, input_bfd, input_section,
4107 rel->r_offset)))
4108 return FALSE;
4109 }
4110 break;
4111 }
4112 }
4113 }
4114
4115 return TRUE;
4116}
4117
910600e9
RS		 4118/* Build a VxWorks PLT entry. PLT_INDEX is the index of the PLT entry
4119 and PLT_OFFSET is the byte offset from the start of .plt. GOT_OFFSET
4120 is the offset of the associated .got.plt entry from
4121 _GLOBAL_OFFSET_TABLE_. */
4122
4123static void
4124sparc_vxworks_build_plt_entry (bfd *output_bfd, struct bfd_link_info *info,
4125 bfd_vma plt_offset, bfd_vma plt_index,
4126 bfd_vma got_offset)
4127{
4128 bfd_vma got_base;
4129 const bfd_vma *plt_entry;
4130 struct _bfd_sparc_elf_link_hash_table *htab;
4131 bfd_byte *loc;
4132 Elf_Internal_Rela rela;
4133
4134 htab = _bfd_sparc_elf_hash_table (info);
4dfe6ac6
NC		 4135 BFD_ASSERT (htab != NULL);
4136
910600e9
RS		 4137 if (info->shared)
4138 {
4139 plt_entry = sparc_vxworks_shared_plt_entry;
4140 got_base = 0;
4141 }
4142 else
4143 {
4144 plt_entry = sparc_vxworks_exec_plt_entry;
4145 got_base = (htab->elf.hgot->root.u.def.value
4146 + htab->elf.hgot->root.u.def.section->output_offset
4147 + htab->elf.hgot->root.u.def.section->output_section->vma);
4148 }
4149
4150 /* Fill in the entry in the procedure linkage table. */
4151 bfd_put_32 (output_bfd, plt_entry[0] + ((got_base + got_offset) >> 10),
72fbc6e5 4152 htab->elf.splt->contents + plt_offset);
910600e9 4153 bfd_put_32 (output_bfd, plt_entry[1] + ((got_base + got_offset) & 0x3ff),
72fbc6e5 4154 htab->elf.splt->contents + plt_offset + 4);
910600e9 4155 bfd_put_32 (output_bfd, plt_entry[2],
72fbc6e5 4156 htab->elf.splt->contents + plt_offset + 8);
910600e9 4157 bfd_put_32 (output_bfd, plt_entry[3],
72fbc6e5 4158 htab->elf.splt->contents + plt_offset + 12);
910600e9 4159 bfd_put_32 (output_bfd, plt_entry[4],
72fbc6e5 4160 htab->elf.splt->contents + plt_offset + 16);
910600e9 4161 bfd_put_32 (output_bfd, plt_entry[5] + (plt_index >> 10),
72fbc6e5 4162 htab->elf.splt->contents + plt_offset + 20);
910600e9
RS		 4163 /* PC-relative displacement for a branch to the start of
4164 the PLT section. */
4165 bfd_put_32 (output_bfd, plt_entry[6] + (((-plt_offset - 24) >> 2)
4166 & 0x003fffff),
72fbc6e5 4167 htab->elf.splt->contents + plt_offset + 24);
910600e9 4168 bfd_put_32 (output_bfd, plt_entry[7] + (plt_index & 0x3ff),
72fbc6e5 4169 htab->elf.splt->contents + plt_offset + 28);
910600e9
RS		 4170
4171 /* Fill in the .got.plt entry, pointing initially at the
4172 second half of the PLT entry. */
72fbc6e5 4173 BFD_ASSERT (htab->elf.sgotplt != NULL);
910600e9 4174 bfd_put_32 (output_bfd,
72fbc6e5
DM		 4175 htab->elf.splt->output_section->vma
4176 + htab->elf.splt->output_offset
910600e9 4177 + plt_offset + 20,
72fbc6e5 4178 htab->elf.sgotplt->contents + got_offset);
910600e9
RS		 4179
4180 /* Add relocations to .rela.plt.unloaded. */
4181 if (!info->shared)
4182 {
4183 loc = (htab->srelplt2->contents
4184 + (2 + 3 * plt_index) * sizeof (Elf32_External_Rela));
4185
4186 /* Relocate the initial sethi. */
72fbc6e5
DM		 4187 rela.r_offset = (htab->elf.splt->output_section->vma
4188 + htab->elf.splt->output_offset
910600e9
RS		 4189 + plt_offset);
4190 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4191 rela.r_addend = got_offset;
4192 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4193 loc += sizeof (Elf32_External_Rela);
4194
4195 /* Likewise the following or. */
4196 rela.r_offset += 4;
4197 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4198 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4199 loc += sizeof (Elf32_External_Rela);
4200
4201 /* Relocate the .got.plt entry. */
72fbc6e5
DM		 4202 rela.r_offset = (htab->elf.sgotplt->output_section->vma
4203 + htab->elf.sgotplt->output_offset
910600e9
RS		 4204 + got_offset);
4205 rela.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_SPARC_32);
4206 rela.r_addend = plt_offset + 20;
4207 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4208 }
4209}
4210
22b75d0a
DM		 4211/* Finish up dynamic symbol handling. We set the contents of various
4212 dynamic sections here. */
4213
4214bfd_boolean
4215_bfd_sparc_elf_finish_dynamic_symbol (bfd *output_bfd,
4216 struct bfd_link_info *info,
4217 struct elf_link_hash_entry *h,
4218 Elf_Internal_Sym *sym)
4219{
22b75d0a 4220 struct _bfd_sparc_elf_link_hash_table *htab;
39817122 4221 const struct elf_backend_data *bed;
22b75d0a
DM		 4222
4223 htab = _bfd_sparc_elf_hash_table (info);
4dfe6ac6 4224 BFD_ASSERT (htab != NULL);
39817122 4225 bed = get_elf_backend_data (output_bfd);
22b75d0a
DM		 4226
4227 if (h->plt.offset != (bfd_vma) -1)
4228 {
4229 asection *splt;
4230 asection *srela;
4231 Elf_Internal_Rela rela;
4232 bfd_byte *loc;
910600e9 4233 bfd_vma r_offset, got_offset;
22b75d0a
DM		 4234 int rela_index;
4235
d0c9aeb3
DM		 4236 /* When building a static executable, use .iplt and
4237 .rela.iplt sections for STT_GNU_IFUNC symbols. */
4238 if (htab->elf.splt != NULL)
4239 {
4240 splt = htab->elf.splt;
4241 srela = htab->elf.srelplt;
4242 }
4243 else
4244 {
4245 splt = htab->elf.iplt;
4246 srela = htab->elf.irelplt;
4247 }
22b75d0a 4248
d0c9aeb3
DM		 4249 if (splt == NULL || srela == NULL)
4250 abort ();
22b75d0a 4251
22b75d0a 4252 /* Fill in the entry in the .rela.plt section. */
910600e9 4253 if (htab->is_vxworks)
22b75d0a 4254 {
910600e9
RS		 4255 /* Work out the index of this PLT entry. */
4256 rela_index = ((h->plt.offset - htab->plt_header_size)
4257 / htab->plt_entry_size);
4258
4259 /* Calculate the offset of the associated .got.plt entry.
4260 The first three entries are reserved. */
4261 got_offset = (rela_index + 3) * 4;
4262
4263 sparc_vxworks_build_plt_entry (output_bfd, info, h->plt.offset,
4264 rela_index, got_offset);
4265
4266
4267 /* On VxWorks, the relocation points to the .got.plt entry,
4268 not the .plt entry. */
72fbc6e5
DM		 4269 rela.r_offset = (htab->elf.sgotplt->output_section->vma
4270 + htab->elf.sgotplt->output_offset
910600e9 4271 + got_offset);
22b75d0a 4272 rela.r_addend = 0;
d0c9aeb3
DM		 4273 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx,
4274 R_SPARC_JMP_SLOT);
22b75d0a
DM		 4275 }
4276 else
4277 {
d0c9aeb3
DM		 4278 bfd_boolean ifunc = FALSE;
4279
910600e9
RS		 4280 /* Fill in the entry in the procedure linkage table. */
4281 rela_index = SPARC_ELF_BUILD_PLT_ENTRY (htab, output_bfd, splt,
4282 h->plt.offset, splt->size,
4283 &r_offset);
4284
d0c9aeb3
DM		 4285 if (h == NULL
4286 || h->dynindx == -1
4287 || ((info->executable
4288 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
4289 && h->def_regular
4290 && h->type == STT_GNU_IFUNC))
4291 {
4292 ifunc = TRUE;
4293 BFD_ASSERT (h == NULL
4294 || (h->type == STT_GNU_IFUNC
4295 && h->def_regular
4296 && (h->root.type == bfd_link_hash_defined
4297 || h->root.type == bfd_link_hash_defweak)));
4298 }
4299
910600e9
RS		 4300 rela.r_offset = r_offset
4301 + (splt->output_section->vma + splt->output_offset);
d0c9aeb3
DM		 4302 if (ABI_64_P (output_bfd)
4303 && h->plt.offset >= (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE))
910600e9 4304 {
d0c9aeb3
DM		 4305 if (ifunc)
4306 {
4307 rela.r_addend = (h->root.u.def.section->output_section->vma
4308 + h->root.u.def.section->output_offset
4309 + h->root.u.def.value);
4310 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0,
4311 R_SPARC_IRELATIVE);
4312 }
4313 else
4314 {
4315 rela.r_addend = (-(h->plt.offset + 4)
4316 - splt->output_section->vma
4317 - splt->output_offset);
4318 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx,
4319 R_SPARC_JMP_SLOT);
4320 }
910600e9
RS		 4321 }
4322 else
4323 {
d0c9aeb3
DM		 4324 if (ifunc)
4325 {
4326 rela.r_addend = (h->root.u.def.section->output_section->vma
4327 + h->root.u.def.section->output_offset
4328 + h->root.u.def.value);
4329 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0,
4330 R_SPARC_JMP_IREL);
4331 }
4332 else
4333 {
4334 rela.r_addend = 0;
4335 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx,
4336 R_SPARC_JMP_SLOT);
4337 }
910600e9 4338 }
22b75d0a 4339 }
22b75d0a
DM		 4340
4341 /* Adjust for the first 4 reserved elements in the .plt section
4342 when setting the offset in the .rela.plt section.
4343 Sun forgot to read their own ABI and copied elf32-sparc behaviour,
4344 thus .plt[4] has corresponding .rela.plt[0] and so on. */
4345
4346 loc = srela->contents;
39817122
RS		 4347 loc += rela_index * bed->s->sizeof_rela;
4348 bed->s->swap_reloca_out (output_bfd, &rela, loc);
22b75d0a
DM		 4349
4350 if (!h->def_regular)
4351 {
4352 /* Mark the symbol as undefined, rather than as defined in
4353 the .plt section. Leave the value alone. */
4354 sym->st_shndx = SHN_UNDEF;
4355 /* If the symbol is weak, we do need to clear the value.
4356 Otherwise, the PLT entry would provide a definition for
4357 the symbol even if the symbol wasn't defined anywhere,
4358 and so the symbol would never be NULL. */
4359 if (!h->ref_regular_nonweak)
4360 sym->st_value = 0;
4361 }
4362 }
4363
4364 if (h->got.offset != (bfd_vma) -1
4365 && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_GD
4366 && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_IE)
4367 {
4368 asection *sgot;
4369 asection *srela;
4370 Elf_Internal_Rela rela;
4371
4372 /* This symbol has an entry in the GOT. Set it up. */
4373
72fbc6e5
DM		 4374 sgot = htab->elf.sgot;
4375 srela = htab->elf.srelgot;
22b75d0a
DM		 4376 BFD_ASSERT (sgot != NULL && srela != NULL);
4377
4378 rela.r_offset = (sgot->output_section->vma
4379 + sgot->output_offset
4380 + (h->got.offset &~ (bfd_vma) 1));
4381
4382 /* If this is a -Bsymbolic link, and the symbol is defined
4383 locally, we just want to emit a RELATIVE reloc. Likewise if
4384 the symbol was forced to be local because of a version file.
4385 The entry in the global offset table will already have been
4386 initialized in the relocate_section function. */
d0c9aeb3
DM		 4387 if (! info->shared
4388 && h->type == STT_GNU_IFUNC
4389 && h->def_regular)
4390 {
4391 asection *plt;
4392
4393 /* We load the GOT entry with the PLT entry. */
4394 plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
4395 SPARC_ELF_PUT_WORD (htab, output_bfd,
4396 (plt->output_section->vma
4397 + plt->output_offset + h->plt.offset),
4398 htab->elf.sgot->contents
4399 + (h->got.offset & ~(bfd_vma) 1));
4400 return TRUE;
4401 }
4402 else if (info->shared
4403 && SYMBOL_REFERENCES_LOCAL (info, h))
22b75d0a
DM		 4404 {
4405 asection *sec = h->root.u.def.section;
d0c9aeb3
DM		 4406 if (h->type == STT_GNU_IFUNC)
4407 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, R_SPARC_IRELATIVE);
4408 else
4409 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, R_SPARC_RELATIVE);
22b75d0a
DM		 4410 rela.r_addend = (h->root.u.def.value
4411 + sec->output_section->vma
4412 + sec->output_offset);
4413 }
4414 else
4415 {
4416 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_GLOB_DAT);
4417 rela.r_addend = 0;
4418 }
4419
4420 SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
4421 sgot->contents + (h->got.offset & ~(bfd_vma) 1));
39817122 4422 sparc_elf_append_rela (output_bfd, srela, &rela);
22b75d0a
DM		 4423 }
4424
4425 if (h->needs_copy)
4426 {
4427 asection *s;
4428 Elf_Internal_Rela rela;
4429
4430 /* This symbols needs a copy reloc. Set it up. */
4431 BFD_ASSERT (h->dynindx != -1);
4432
4433 s = bfd_get_section_by_name (h->root.u.def.section->owner,
4434 ".rela.bss");
4435 BFD_ASSERT (s != NULL);
4436
4437 rela.r_offset = (h->root.u.def.value
4438 + h->root.u.def.section->output_section->vma
4439 + h->root.u.def.section->output_offset);
4440 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_COPY);
4441 rela.r_addend = 0;
39817122 4442 sparc_elf_append_rela (output_bfd, s, &rela);
22b75d0a
DM		 4443 }
4444
910600e9
RS		 4445 /* Mark some specially defined symbols as absolute. On VxWorks,
4446 _GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the
4447 ".got" section. Likewise _PROCEDURE_LINKAGE_TABLE_ and ".plt". */
d0c9aeb3
DM		 4448 if (sym != NULL
4449 && (strcmp (h->root.root.string, "_DYNAMIC") == 0
4450 || (!htab->is_vxworks
4451 && (h == htab->elf.hgot || h == htab->elf.hplt))))
22b75d0a
DM		 4452 sym->st_shndx = SHN_ABS;
4453
4454 return TRUE;
4455}
4456
4457/* Finish up the dynamic sections. */
4458
22b75d0a 4459static bfd_boolean
39817122
RS		 4460sparc_finish_dyn (bfd *output_bfd, struct bfd_link_info *info,
4461 bfd *dynobj, asection *sdyn,
4462 asection *splt ATTRIBUTE_UNUSED)
22b75d0a 4463{
910600e9 4464 struct _bfd_sparc_elf_link_hash_table *htab;
39817122
RS		 4465 const struct elf_backend_data *bed;
4466 bfd_byte *dyncon, *dynconend;
4467 size_t dynsize;
4468 int stt_regidx = -1;
4469 bfd_boolean abi_64_p;
22b75d0a 4470
910600e9 4471 htab = _bfd_sparc_elf_hash_table (info);
4dfe6ac6 4472 BFD_ASSERT (htab != NULL);
39817122
RS		 4473 bed = get_elf_backend_data (output_bfd);
4474 dynsize = bed->s->sizeof_dyn;
4475 dynconend = sdyn->contents + sdyn->size;
4476 abi_64_p = ABI_64_P (output_bfd);
4477 for (dyncon = sdyn->contents; dyncon < dynconend; dyncon += dynsize)
22b75d0a
DM		 4478 {
4479 Elf_Internal_Dyn dyn;
4480 const char *name;
4481 bfd_boolean size;
4482
39817122 4483 bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
22b75d0a 4484
910600e9 4485 if (htab->is_vxworks && dyn.d_tag == DT_RELASZ)
22b75d0a 4486 {
910600e9
RS		 4487 /* On VxWorks, DT_RELASZ should not include the relocations
4488 in .rela.plt. */
72fbc6e5 4489 if (htab->elf.srelplt)
910600e9 4490 {
72fbc6e5 4491 dyn.d_un.d_val -= htab->elf.srelplt->size;
39817122 4492 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
910600e9 4493 }
22b75d0a 4494 }
910600e9 4495 else if (htab->is_vxworks && dyn.d_tag == DT_PLTGOT)
22b75d0a 4496 {
910600e9
RS		 4497 /* On VxWorks, DT_PLTGOT should point to the start of the GOT,
4498 not to the start of the PLT. */
72fbc6e5 4499 if (htab->elf.sgotplt)
910600e9 4500 {
72fbc6e5
DM		 4501 dyn.d_un.d_val = (htab->elf.sgotplt->output_section->vma
4502 + htab->elf.sgotplt->output_offset);
39817122 4503 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
910600e9
RS		 4504 }
4505 }
7a2b07ff
NS		 4506 else if (htab->is_vxworks
4507 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
4508 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
39817122
RS		 4509 else if (abi_64_p && dyn.d_tag == DT_SPARC_REGISTER)
4510 {
4511 if (stt_regidx == -1)
4512 {
4513 stt_regidx =
4514 _bfd_elf_link_lookup_local_dynindx (info, output_bfd, -1);
4515 if (stt_regidx == -1)
4516 return FALSE;
4517 }
4518 dyn.d_un.d_val = stt_regidx++;
4519 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4520 }
910600e9
RS		 4521 else
4522 {
4523 switch (dyn.d_tag)
4524 {
4525 case DT_PLTGOT: name = ".plt"; size = FALSE; break;
4526 case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break;
4527 case DT_JMPREL: name = ".rela.plt"; size = FALSE; break;
39817122 4528 default: name = NULL; size = FALSE; break;
910600e9 4529 }
22b75d0a 4530
910600e9 4531 if (name != NULL)
22b75d0a 4532 {
910600e9
RS		 4533 asection *s;
4534
4535 s = bfd_get_section_by_name (output_bfd, name);
4536 if (s == NULL)
4537 dyn.d_un.d_val = 0;
22b75d0a 4538 else
910600e9
RS		 4539 {
4540 if (! size)
4541 dyn.d_un.d_ptr = s->vma;
4542 else
4543 dyn.d_un.d_val = s->size;
4544 }
39817122 4545 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
22b75d0a 4546 }
22b75d0a
DM		 4547 }
4548 }
4549 return TRUE;
4550}
4551
910600e9
RS		 4552/* Install the first PLT entry in a VxWorks executable and make sure that
4553 .rela.plt.unloaded relocations have the correct symbol indexes. */
4554
4555static void
4556sparc_vxworks_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info)
4557{
4558 struct _bfd_sparc_elf_link_hash_table *htab;
4559 Elf_Internal_Rela rela;
4560 bfd_vma got_base;
4561 bfd_byte *loc;
4562
4563 htab = _bfd_sparc_elf_hash_table (info);
4dfe6ac6 4564 BFD_ASSERT (htab != NULL);
910600e9
RS		 4565
4566 /* Calculate the absolute value of _GLOBAL_OFFSET_TABLE_. */
4567 got_base = (htab->elf.hgot->root.u.def.section->output_section->vma
4568 + htab->elf.hgot->root.u.def.section->output_offset
4569 + htab->elf.hgot->root.u.def.value);
4570
4571 /* Install the initial PLT entry. */
4572 bfd_put_32 (output_bfd,
4573 sparc_vxworks_exec_plt0_entry[0] + ((got_base + 8) >> 10),
72fbc6e5 4574 htab->elf.splt->contents);
910600e9
RS		 4575 bfd_put_32 (output_bfd,
4576 sparc_vxworks_exec_plt0_entry[1] + ((got_base + 8) & 0x3ff),
72fbc6e5 4577 htab->elf.splt->contents + 4);
910600e9
RS		 4578 bfd_put_32 (output_bfd,
4579 sparc_vxworks_exec_plt0_entry[2],
72fbc6e5 4580 htab->elf.splt->contents + 8);
910600e9
RS		 4581 bfd_put_32 (output_bfd,
4582 sparc_vxworks_exec_plt0_entry[3],
72fbc6e5 4583 htab->elf.splt->contents + 12);
910600e9
RS		 4584 bfd_put_32 (output_bfd,
4585 sparc_vxworks_exec_plt0_entry[4],
72fbc6e5 4586 htab->elf.splt->contents + 16);
910600e9
RS		 4587
4588 loc = htab->srelplt2->contents;
4589
4590 /* Add an unloaded relocation for the initial entry's "sethi". */
72fbc6e5
DM		 4591 rela.r_offset = (htab->elf.splt->output_section->vma
4592 + htab->elf.splt->output_offset);
910600e9
RS		 4593 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4594 rela.r_addend = 8;
4595 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4596 loc += sizeof (Elf32_External_Rela);
4597
4598 /* Likewise the following "or". */
4599 rela.r_offset += 4;
4600 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4601 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4602 loc += sizeof (Elf32_External_Rela);
4603
4604 /* Fix up the remaining .rela.plt.unloaded relocations. They may have
4605 the wrong symbol index for _G_O_T_ or _P_L_T_ depending on the order
4606 in which symbols were output. */
4607 while (loc < htab->srelplt2->contents + htab->srelplt2->size)
4608 {
4609 Elf_Internal_Rela rel;
4610
4611 /* The entry's initial "sethi" (against _G_O_T_). */
4612 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4613 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4614 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4615 loc += sizeof (Elf32_External_Rela);
4616
4617 /* The following "or" (also against _G_O_T_). */
4618 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4619 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4620 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4621 loc += sizeof (Elf32_External_Rela);
4622
4623 /* The .got.plt entry (against _P_L_T_). */
4624 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4625 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_SPARC_32);
4626 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4627 loc += sizeof (Elf32_External_Rela);
4628 }
4629}
4630
4631/* Install the first PLT entry in a VxWorks shared object. */
4632
4633static void
4634sparc_vxworks_finish_shared_plt (bfd *output_bfd, struct bfd_link_info *info)
4635{
4636 struct _bfd_sparc_elf_link_hash_table *htab;
4637 unsigned int i;
4638
4639 htab = _bfd_sparc_elf_hash_table (info);
4dfe6ac6
NC		 4640 BFD_ASSERT (htab != NULL);
4641
910600e9
RS		 4642 for (i = 0; i < ARRAY_SIZE (sparc_vxworks_shared_plt0_entry); i++)
4643 bfd_put_32 (output_bfd, sparc_vxworks_shared_plt0_entry[i],
72fbc6e5 4644 htab->elf.splt->contents + i * 4);
910600e9
RS		 4645}
4646
d0c9aeb3
DM		 4647/* Finish up local dynamic symbol handling. We set the contents of
4648 various dynamic sections here. */
4649
4650static bfd_boolean
4651finish_local_dynamic_symbol (void **slot, void *inf)
4652{
4653 struct elf_link_hash_entry *h
4654 = (struct elf_link_hash_entry *) *slot;
4655 struct bfd_link_info *info
4656 = (struct bfd_link_info *) inf;
4657
4658 return _bfd_sparc_elf_finish_dynamic_symbol (info->output_bfd, info,
4659 h, NULL);
4660}
4661
22b75d0a
DM		 4662bfd_boolean
4663_bfd_sparc_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
4664{
4665 bfd *dynobj;
4666 asection *sdyn;
4667 struct _bfd_sparc_elf_link_hash_table *htab;
4668
4669 htab = _bfd_sparc_elf_hash_table (info);
4dfe6ac6 4670 BFD_ASSERT (htab != NULL);
22b75d0a
DM		 4671 dynobj = htab->elf.dynobj;
4672
4673 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4674
4675 if (elf_hash_table (info)->dynamic_sections_created)
4676 {
4677 asection *splt;
22b75d0a
DM		 4678
4679 splt = bfd_get_section_by_name (dynobj, ".plt");
4680 BFD_ASSERT (splt != NULL && sdyn != NULL);
4681
39817122
RS		 4682 if (!sparc_finish_dyn (output_bfd, info, dynobj, sdyn, splt))
4683 return FALSE;
22b75d0a
DM		 4684
4685 /* Initialize the contents of the .plt section. */
4686 if (splt->size > 0)
4687 {
910600e9
RS		 4688 if (htab->is_vxworks)
4689 {
4690 if (info->shared)
4691 sparc_vxworks_finish_shared_plt (output_bfd, info);
4692 else
4693 sparc_vxworks_finish_exec_plt (output_bfd, info);
4694 }
22b75d0a
DM		 4695 else
4696 {
910600e9
RS		 4697 memset (splt->contents, 0, htab->plt_header_size);
4698 if (!ABI_64_P (output_bfd))
4699 bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP,
4700 splt->contents + splt->size - 4);
22b75d0a
DM		 4701 }
4702 }
4703
910600e9 4704 elf_section_data (splt->output_section)->this_hdr.sh_entsize
7eeb1be6
JJ		 4705 = (htab->is_vxworks || !ABI_64_P (output_bfd))
4706 ? 0 : htab->plt_entry_size;
22b75d0a
DM		 4707 }
4708
4709 /* Set the first entry in the global offset table to the address of
4710 the dynamic section. */
72fbc6e5 4711 if (htab->elf.sgot && htab->elf.sgot->size > 0)
22b75d0a
DM		 4712 {
4713 bfd_vma val = (sdyn ?
4714 sdyn->output_section->vma + sdyn->output_offset :
4715 0);
4716
72fbc6e5 4717 SPARC_ELF_PUT_WORD (htab, output_bfd, val, htab->elf.sgot->contents);
22b75d0a
DM		 4718 }
4719
72fbc6e5
DM		 4720 if (htab->elf.sgot)
4721 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize =
22b75d0a
DM		 4722 SPARC_ELF_WORD_BYTES (htab);
4723
d0c9aeb3
DM		 4724 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
4725 htab_traverse (htab->loc_hash_table, finish_local_dynamic_symbol, info);
4726
22b75d0a
DM		 4727 return TRUE;
4728}
4729
4730\f
4731/* Set the right machine number for a SPARC ELF file. */
4732
4733bfd_boolean
4734_bfd_sparc_elf_object_p (bfd *abfd)
4735{
4736 if (ABI_64_P (abfd))
4737 {
4738 unsigned long mach = bfd_mach_sparc_v9;
4739
4740 if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
4741 mach = bfd_mach_sparc_v9b;
4742 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
4743 mach = bfd_mach_sparc_v9a;
4744 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, mach);
4745 }
4746 else
4747 {
4748 if (elf_elfheader (abfd)->e_machine == EM_SPARC32PLUS)
4749 {
4750 if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
4751 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4752 bfd_mach_sparc_v8plusb);
4753 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
4754 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4755 bfd_mach_sparc_v8plusa);
4756 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_32PLUS)
4757 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4758 bfd_mach_sparc_v8plus);
4759 else
4760 return FALSE;
4761 }
4762 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_LEDATA)
4763 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4764 bfd_mach_sparc_sparclite_le);
4765 else
4766 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc);
4767 }
4768}
4769
4770/* Return address for Ith PLT stub in section PLT, for relocation REL
4771 or (bfd_vma) -1 if it should not be included. */
4772
4773bfd_vma
4774_bfd_sparc_elf_plt_sym_val (bfd_vma i, const asection *plt, const arelent *rel)
4775{
4776 if (ABI_64_P (plt->owner))
4777 {
4778 bfd_vma j;
4779
4780 i += PLT64_HEADER_SIZE / PLT64_ENTRY_SIZE;
4781 if (i < PLT64_LARGE_THRESHOLD)
4782 return plt->vma + i * PLT64_ENTRY_SIZE;
4783
4784 j = (i - PLT64_LARGE_THRESHOLD) % 160;
4785 i -= j;
4786 return plt->vma + i * PLT64_ENTRY_SIZE + j * 4 * 6;
4787 }
4788 else
4789 return rel->address;
4790}
9e8c70f9
DM		 4791
4792/* Merge backend specific data from an object file to the output
4793 object file when linking. */
4794
4795bfd_boolean
4796_bfd_sparc_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
4797{
4798 obj_attribute *in_attr, *in_attrs;
4799 obj_attribute *out_attr, *out_attrs;
4800
4801 if (!elf_known_obj_attributes_proc (obfd)[0].i)
4802 {
4803 /* This is the first object. Copy the attributes. */
4804 _bfd_elf_copy_obj_attributes (ibfd, obfd);
4805
4806 /* Use the Tag_null value to indicate the attributes have been
4807 initialized. */
4808 elf_known_obj_attributes_proc (obfd)[0].i = 1;
4809
4810 return TRUE;
4811 }
4812
4813 in_attrs = elf_known_obj_attributes (ibfd)[OBJ_ATTR_GNU];
4814 out_attrs = elf_known_obj_attributes (obfd)[OBJ_ATTR_GNU];
4815
4816 in_attr = &in_attrs[Tag_GNU_Sparc_HWCAPS];
4817 out_attr = &out_attrs[Tag_GNU_Sparc_HWCAPS];
4818
4819 out_attr->i |= in_attr->i;
4820
4821 /* Merge Tag_compatibility attributes and any common GNU ones. */
4822 _bfd_elf_merge_object_attributes (ibfd, obfd);
4823
4824 return TRUE;
4825}
GDB Binutils - Deliverables
This page took 0.578975 seconds and 4 git commands to generate.