1 /* SPARC-specific support for ELF
2 Copyright 2005, 2006, 2007 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
20 /* This file handles functionality common to the different SPARC ABI's. */
26 #include "libiberty.h"
28 #include "elf/sparc.h"
29 #include "opcode/sparc.h"
30 #include "elfxx-sparc.h"
31 #include "elf-vxworks.h"
33 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
34 #define MINUS_ONE (~ (bfd_vma) 0)
36 #define ABI_64_P(abfd) \
37 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
39 /* The relocation "howto" table. */
41 /* Utility for performing the standard initial work of an instruction
43 *PRELOCATION will contain the relocated item.
44 *PINSN will contain the instruction from the input stream.
45 If the result is `bfd_reloc_other' the caller can continue with
46 performing the relocation. Otherwise it must stop and return the
47 value to its caller. */
49 static bfd_reloc_status_type
50 init_insn_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
51 PTR data
, asection
*input_section
, bfd
*output_bfd
,
52 bfd_vma
*prelocation
, bfd_vma
*pinsn
)
55 reloc_howto_type
*howto
= reloc_entry
->howto
;
57 if (output_bfd
!= (bfd
*) NULL
58 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
59 && (! howto
->partial_inplace
60 || reloc_entry
->addend
== 0))
62 reloc_entry
->address
+= input_section
->output_offset
;
66 /* This works because partial_inplace is FALSE. */
67 if (output_bfd
!= NULL
)
68 return bfd_reloc_continue
;
70 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
71 return bfd_reloc_outofrange
;
73 relocation
= (symbol
->value
74 + symbol
->section
->output_section
->vma
75 + symbol
->section
->output_offset
);
76 relocation
+= reloc_entry
->addend
;
77 if (howto
->pc_relative
)
79 relocation
-= (input_section
->output_section
->vma
80 + input_section
->output_offset
);
81 relocation
-= reloc_entry
->address
;
84 *prelocation
= relocation
;
85 *pinsn
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
86 return bfd_reloc_other
;
89 /* For unsupported relocs. */
91 static bfd_reloc_status_type
92 sparc_elf_notsup_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
93 arelent
*reloc_entry ATTRIBUTE_UNUSED
,
94 asymbol
*symbol ATTRIBUTE_UNUSED
,
95 PTR data ATTRIBUTE_UNUSED
,
96 asection
*input_section ATTRIBUTE_UNUSED
,
97 bfd
*output_bfd ATTRIBUTE_UNUSED
,
98 char **error_message ATTRIBUTE_UNUSED
)
100 return bfd_reloc_notsupported
;
103 /* Handle the WDISP16 reloc. */
105 static bfd_reloc_status_type
106 sparc_elf_wdisp16_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
107 PTR data
, asection
*input_section
, bfd
*output_bfd
,
108 char **error_message ATTRIBUTE_UNUSED
)
112 bfd_reloc_status_type status
;
114 status
= init_insn_reloc (abfd
, reloc_entry
, symbol
, data
,
115 input_section
, output_bfd
, &relocation
, &insn
);
116 if (status
!= bfd_reloc_other
)
119 insn
&= ~ (bfd_vma
) 0x303fff;
120 insn
|= (((relocation
>> 2) & 0xc000) << 6) | ((relocation
>> 2) & 0x3fff);
121 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ reloc_entry
->address
);
123 if ((bfd_signed_vma
) relocation
< - 0x40000
124 || (bfd_signed_vma
) relocation
> 0x3ffff)
125 return bfd_reloc_overflow
;
130 /* Handle the HIX22 reloc. */
132 static bfd_reloc_status_type
133 sparc_elf_hix22_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
134 PTR data
, asection
*input_section
, bfd
*output_bfd
,
135 char **error_message ATTRIBUTE_UNUSED
)
139 bfd_reloc_status_type status
;
141 status
= init_insn_reloc (abfd
, reloc_entry
, symbol
, data
,
142 input_section
, output_bfd
, &relocation
, &insn
);
143 if (status
!= bfd_reloc_other
)
146 relocation
^= MINUS_ONE
;
147 insn
= (insn
&~ (bfd_vma
) 0x3fffff) | ((relocation
>> 10) & 0x3fffff);
148 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ reloc_entry
->address
);
150 if ((relocation
& ~ (bfd_vma
) 0xffffffff) != 0)
151 return bfd_reloc_overflow
;
156 /* Handle the LOX10 reloc. */
158 static bfd_reloc_status_type
159 sparc_elf_lox10_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
160 PTR data
, asection
*input_section
, bfd
*output_bfd
,
161 char **error_message ATTRIBUTE_UNUSED
)
165 bfd_reloc_status_type status
;
167 status
= init_insn_reloc (abfd
, reloc_entry
, symbol
, data
,
168 input_section
, output_bfd
, &relocation
, &insn
);
169 if (status
!= bfd_reloc_other
)
172 insn
= (insn
&~ (bfd_vma
) 0x1fff) | 0x1c00 | (relocation
& 0x3ff);
173 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ reloc_entry
->address
);
178 static reloc_howto_type _bfd_sparc_elf_howto_table
[] =
180 HOWTO(R_SPARC_NONE
, 0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_NONE", FALSE
,0,0x00000000,TRUE
),
181 HOWTO(R_SPARC_8
, 0,0, 8,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_8", FALSE
,0,0x000000ff,TRUE
),
182 HOWTO(R_SPARC_16
, 0,1,16,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_16", FALSE
,0,0x0000ffff,TRUE
),
183 HOWTO(R_SPARC_32
, 0,2,32,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_32", FALSE
,0,0xffffffff,TRUE
),
184 HOWTO(R_SPARC_DISP8
, 0,0, 8,TRUE
, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_DISP8", FALSE
,0,0x000000ff,TRUE
),
185 HOWTO(R_SPARC_DISP16
, 0,1,16,TRUE
, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_DISP16", FALSE
,0,0x0000ffff,TRUE
),
186 HOWTO(R_SPARC_DISP32
, 0,2,32,TRUE
, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_DISP32", FALSE
,0,0xffffffff,TRUE
),
187 HOWTO(R_SPARC_WDISP30
, 2,2,30,TRUE
, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_WDISP30", FALSE
,0,0x3fffffff,TRUE
),
188 HOWTO(R_SPARC_WDISP22
, 2,2,22,TRUE
, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_WDISP22", FALSE
,0,0x003fffff,TRUE
),
189 HOWTO(R_SPARC_HI22
, 10,2,22,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_HI22", FALSE
,0,0x003fffff,TRUE
),
190 HOWTO(R_SPARC_22
, 0,2,22,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_22", FALSE
,0,0x003fffff,TRUE
),
191 HOWTO(R_SPARC_13
, 0,2,13,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_13", FALSE
,0,0x00001fff,TRUE
),
192 HOWTO(R_SPARC_LO10
, 0,2,10,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_LO10", FALSE
,0,0x000003ff,TRUE
),
193 HOWTO(R_SPARC_GOT10
, 0,2,10,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_GOT10", FALSE
,0,0x000003ff,TRUE
),
194 HOWTO(R_SPARC_GOT13
, 0,2,13,FALSE
,0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_GOT13", FALSE
,0,0x00001fff,TRUE
),
195 HOWTO(R_SPARC_GOT22
, 10,2,22,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_GOT22", FALSE
,0,0x003fffff,TRUE
),
196 HOWTO(R_SPARC_PC10
, 0,2,10,TRUE
, 0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_PC10", FALSE
,0,0x000003ff,TRUE
),
197 HOWTO(R_SPARC_PC22
, 10,2,22,TRUE
, 0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_PC22", FALSE
,0,0x003fffff,TRUE
),
198 HOWTO(R_SPARC_WPLT30
, 2,2,30,TRUE
, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_WPLT30", FALSE
,0,0x3fffffff,TRUE
),
199 HOWTO(R_SPARC_COPY
, 0,0,00,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_COPY", FALSE
,0,0x00000000,TRUE
),
200 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
),
201 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
),
202 HOWTO(R_SPARC_RELATIVE
, 0,0,00,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_RELATIVE",FALSE
,0,0x00000000,TRUE
),
203 HOWTO(R_SPARC_UA32
, 0,2,32,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_UA32", FALSE
,0,0xffffffff,TRUE
),
204 HOWTO(R_SPARC_PLT32
, 0,2,32,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_PLT32", FALSE
,0,0xffffffff,TRUE
),
205 HOWTO(R_SPARC_HIPLT22
, 0,0,00,FALSE
,0,complain_overflow_dont
, sparc_elf_notsup_reloc
, "R_SPARC_HIPLT22", FALSE
,0,0x00000000,TRUE
),
206 HOWTO(R_SPARC_LOPLT10
, 0,0,00,FALSE
,0,complain_overflow_dont
, sparc_elf_notsup_reloc
, "R_SPARC_LOPLT10", FALSE
,0,0x00000000,TRUE
),
207 HOWTO(R_SPARC_PCPLT32
, 0,0,00,FALSE
,0,complain_overflow_dont
, sparc_elf_notsup_reloc
, "R_SPARC_PCPLT32", FALSE
,0,0x00000000,TRUE
),
208 HOWTO(R_SPARC_PCPLT22
, 0,0,00,FALSE
,0,complain_overflow_dont
, sparc_elf_notsup_reloc
, "R_SPARC_PCPLT22", FALSE
,0,0x00000000,TRUE
),
209 HOWTO(R_SPARC_PCPLT10
, 0,0,00,FALSE
,0,complain_overflow_dont
, sparc_elf_notsup_reloc
, "R_SPARC_PCPLT10", FALSE
,0,0x00000000,TRUE
),
210 HOWTO(R_SPARC_10
, 0,2,10,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_10", FALSE
,0,0x000003ff,TRUE
),
211 HOWTO(R_SPARC_11
, 0,2,11,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_11", FALSE
,0,0x000007ff,TRUE
),
212 HOWTO(R_SPARC_64
, 0,4,64,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_64", FALSE
,0,MINUS_ONE
, TRUE
),
213 HOWTO(R_SPARC_OLO10
, 0,2,13,FALSE
,0,complain_overflow_signed
, sparc_elf_notsup_reloc
, "R_SPARC_OLO10", FALSE
,0,0x00001fff,TRUE
),
214 HOWTO(R_SPARC_HH22
, 42,2,22,FALSE
,0,complain_overflow_unsigned
,bfd_elf_generic_reloc
, "R_SPARC_HH22", FALSE
,0,0x003fffff,TRUE
),
215 HOWTO(R_SPARC_HM10
, 32,2,10,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_HM10", FALSE
,0,0x000003ff,TRUE
),
216 HOWTO(R_SPARC_LM22
, 10,2,22,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_LM22", FALSE
,0,0x003fffff,TRUE
),
217 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
),
218 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
),
219 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
),
220 HOWTO(R_SPARC_WDISP16
, 2,2,16,TRUE
, 0,complain_overflow_signed
, sparc_elf_wdisp16_reloc
,"R_SPARC_WDISP16", FALSE
,0,0x00000000,TRUE
),
221 HOWTO(R_SPARC_WDISP19
, 2,2,19,TRUE
, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_WDISP19", FALSE
,0,0x0007ffff,TRUE
),
222 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
),
223 HOWTO(R_SPARC_7
, 0,2, 7,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_7", FALSE
,0,0x0000007f,TRUE
),
224 HOWTO(R_SPARC_5
, 0,2, 5,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_5", FALSE
,0,0x0000001f,TRUE
),
225 HOWTO(R_SPARC_6
, 0,2, 6,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_6", FALSE
,0,0x0000003f,TRUE
),
226 HOWTO(R_SPARC_DISP64
, 0,4,64,TRUE
, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_DISP64", FALSE
,0,MINUS_ONE
, TRUE
),
227 HOWTO(R_SPARC_PLT64
, 0,4,64,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_PLT64", FALSE
,0,MINUS_ONE
, TRUE
),
228 HOWTO(R_SPARC_HIX22
, 0,4, 0,FALSE
,0,complain_overflow_bitfield
,sparc_elf_hix22_reloc
, "R_SPARC_HIX22", FALSE
,0,MINUS_ONE
, FALSE
),
229 HOWTO(R_SPARC_LOX10
, 0,4, 0,FALSE
,0,complain_overflow_dont
, sparc_elf_lox10_reloc
, "R_SPARC_LOX10", FALSE
,0,MINUS_ONE
, FALSE
),
230 HOWTO(R_SPARC_H44
, 22,2,22,FALSE
,0,complain_overflow_unsigned
,bfd_elf_generic_reloc
, "R_SPARC_H44", FALSE
,0,0x003fffff,FALSE
),
231 HOWTO(R_SPARC_M44
, 12,2,10,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_M44", FALSE
,0,0x000003ff,FALSE
),
232 HOWTO(R_SPARC_L44
, 0,2,13,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_L44", FALSE
,0,0x00000fff,FALSE
),
233 HOWTO(R_SPARC_REGISTER
, 0,4, 0,FALSE
,0,complain_overflow_bitfield
,sparc_elf_notsup_reloc
, "R_SPARC_REGISTER",FALSE
,0,MINUS_ONE
, FALSE
),
234 HOWTO(R_SPARC_UA64
, 0,4,64,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_UA64", FALSE
,0,MINUS_ONE
, TRUE
),
235 HOWTO(R_SPARC_UA16
, 0,1,16,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_UA16", FALSE
,0,0x0000ffff,TRUE
),
236 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
),
237 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
),
238 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
),
239 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
),
240 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
),
241 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
),
242 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
),
243 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
),
244 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
),
245 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
),
246 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
),
247 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
),
248 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
),
249 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
),
250 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
),
251 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
),
252 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
),
253 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
),
254 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
),
255 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
),
256 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
),
257 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
),
258 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
),
259 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
)
261 static reloc_howto_type sparc_vtinherit_howto
=
262 HOWTO (R_SPARC_GNU_VTINHERIT
, 0,2,0,FALSE
,0,complain_overflow_dont
, NULL
, "R_SPARC_GNU_VTINHERIT", FALSE
,0, 0, FALSE
);
263 static reloc_howto_type sparc_vtentry_howto
=
264 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
);
265 static reloc_howto_type sparc_rev32_howto
=
266 HOWTO(R_SPARC_REV32
, 0,2,32,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_REV32", FALSE
,0,0xffffffff,TRUE
);
268 struct elf_reloc_map
{
269 bfd_reloc_code_real_type bfd_reloc_val
;
270 unsigned char elf_reloc_val
;
273 static const struct elf_reloc_map sparc_reloc_map
[] =
275 { BFD_RELOC_NONE
, R_SPARC_NONE
, },
276 { BFD_RELOC_16
, R_SPARC_16
, },
277 { BFD_RELOC_16_PCREL
, R_SPARC_DISP16
},
278 { BFD_RELOC_8
, R_SPARC_8
},
279 { BFD_RELOC_8_PCREL
, R_SPARC_DISP8
},
280 { BFD_RELOC_CTOR
, R_SPARC_64
},
281 { BFD_RELOC_32
, R_SPARC_32
},
282 { BFD_RELOC_32_PCREL
, R_SPARC_DISP32
},
283 { BFD_RELOC_HI22
, R_SPARC_HI22
},
284 { BFD_RELOC_LO10
, R_SPARC_LO10
, },
285 { BFD_RELOC_32_PCREL_S2
, R_SPARC_WDISP30
},
286 { BFD_RELOC_64_PCREL
, R_SPARC_DISP64
},
287 { BFD_RELOC_SPARC22
, R_SPARC_22
},
288 { BFD_RELOC_SPARC13
, R_SPARC_13
},
289 { BFD_RELOC_SPARC_GOT10
, R_SPARC_GOT10
},
290 { BFD_RELOC_SPARC_GOT13
, R_SPARC_GOT13
},
291 { BFD_RELOC_SPARC_GOT22
, R_SPARC_GOT22
},
292 { BFD_RELOC_SPARC_PC10
, R_SPARC_PC10
},
293 { BFD_RELOC_SPARC_PC22
, R_SPARC_PC22
},
294 { BFD_RELOC_SPARC_WPLT30
, R_SPARC_WPLT30
},
295 { BFD_RELOC_SPARC_COPY
, R_SPARC_COPY
},
296 { BFD_RELOC_SPARC_GLOB_DAT
, R_SPARC_GLOB_DAT
},
297 { BFD_RELOC_SPARC_JMP_SLOT
, R_SPARC_JMP_SLOT
},
298 { BFD_RELOC_SPARC_RELATIVE
, R_SPARC_RELATIVE
},
299 { BFD_RELOC_SPARC_WDISP22
, R_SPARC_WDISP22
},
300 { BFD_RELOC_SPARC_UA16
, R_SPARC_UA16
},
301 { BFD_RELOC_SPARC_UA32
, R_SPARC_UA32
},
302 { BFD_RELOC_SPARC_UA64
, R_SPARC_UA64
},
303 { BFD_RELOC_SPARC_10
, R_SPARC_10
},
304 { BFD_RELOC_SPARC_11
, R_SPARC_11
},
305 { BFD_RELOC_SPARC_64
, R_SPARC_64
},
306 { BFD_RELOC_SPARC_OLO10
, R_SPARC_OLO10
},
307 { BFD_RELOC_SPARC_HH22
, R_SPARC_HH22
},
308 { BFD_RELOC_SPARC_HM10
, R_SPARC_HM10
},
309 { BFD_RELOC_SPARC_LM22
, R_SPARC_LM22
},
310 { BFD_RELOC_SPARC_PC_HH22
, R_SPARC_PC_HH22
},
311 { BFD_RELOC_SPARC_PC_HM10
, R_SPARC_PC_HM10
},
312 { BFD_RELOC_SPARC_PC_LM22
, R_SPARC_PC_LM22
},
313 { BFD_RELOC_SPARC_WDISP16
, R_SPARC_WDISP16
},
314 { BFD_RELOC_SPARC_WDISP19
, R_SPARC_WDISP19
},
315 { BFD_RELOC_SPARC_7
, R_SPARC_7
},
316 { BFD_RELOC_SPARC_5
, R_SPARC_5
},
317 { BFD_RELOC_SPARC_6
, R_SPARC_6
},
318 { BFD_RELOC_SPARC_DISP64
, R_SPARC_DISP64
},
319 { BFD_RELOC_SPARC_TLS_GD_HI22
, R_SPARC_TLS_GD_HI22
},
320 { BFD_RELOC_SPARC_TLS_GD_LO10
, R_SPARC_TLS_GD_LO10
},
321 { BFD_RELOC_SPARC_TLS_GD_ADD
, R_SPARC_TLS_GD_ADD
},
322 { BFD_RELOC_SPARC_TLS_GD_CALL
, R_SPARC_TLS_GD_CALL
},
323 { BFD_RELOC_SPARC_TLS_LDM_HI22
, R_SPARC_TLS_LDM_HI22
},
324 { BFD_RELOC_SPARC_TLS_LDM_LO10
, R_SPARC_TLS_LDM_LO10
},
325 { BFD_RELOC_SPARC_TLS_LDM_ADD
, R_SPARC_TLS_LDM_ADD
},
326 { BFD_RELOC_SPARC_TLS_LDM_CALL
, R_SPARC_TLS_LDM_CALL
},
327 { BFD_RELOC_SPARC_TLS_LDO_HIX22
, R_SPARC_TLS_LDO_HIX22
},
328 { BFD_RELOC_SPARC_TLS_LDO_LOX10
, R_SPARC_TLS_LDO_LOX10
},
329 { BFD_RELOC_SPARC_TLS_LDO_ADD
, R_SPARC_TLS_LDO_ADD
},
330 { BFD_RELOC_SPARC_TLS_IE_HI22
, R_SPARC_TLS_IE_HI22
},
331 { BFD_RELOC_SPARC_TLS_IE_LO10
, R_SPARC_TLS_IE_LO10
},
332 { BFD_RELOC_SPARC_TLS_IE_LD
, R_SPARC_TLS_IE_LD
},
333 { BFD_RELOC_SPARC_TLS_IE_LDX
, R_SPARC_TLS_IE_LDX
},
334 { BFD_RELOC_SPARC_TLS_IE_ADD
, R_SPARC_TLS_IE_ADD
},
335 { BFD_RELOC_SPARC_TLS_LE_HIX22
, R_SPARC_TLS_LE_HIX22
},
336 { BFD_RELOC_SPARC_TLS_LE_LOX10
, R_SPARC_TLS_LE_LOX10
},
337 { BFD_RELOC_SPARC_TLS_DTPMOD32
, R_SPARC_TLS_DTPMOD32
},
338 { BFD_RELOC_SPARC_TLS_DTPMOD64
, R_SPARC_TLS_DTPMOD64
},
339 { BFD_RELOC_SPARC_TLS_DTPOFF32
, R_SPARC_TLS_DTPOFF32
},
340 { BFD_RELOC_SPARC_TLS_DTPOFF64
, R_SPARC_TLS_DTPOFF64
},
341 { BFD_RELOC_SPARC_TLS_TPOFF32
, R_SPARC_TLS_TPOFF32
},
342 { BFD_RELOC_SPARC_TLS_TPOFF64
, R_SPARC_TLS_TPOFF64
},
343 { BFD_RELOC_SPARC_PLT32
, R_SPARC_PLT32
},
344 { BFD_RELOC_SPARC_PLT64
, R_SPARC_PLT64
},
345 { BFD_RELOC_SPARC_HIX22
, R_SPARC_HIX22
},
346 { BFD_RELOC_SPARC_LOX10
, R_SPARC_LOX10
},
347 { BFD_RELOC_SPARC_H44
, R_SPARC_H44
},
348 { BFD_RELOC_SPARC_M44
, R_SPARC_M44
},
349 { BFD_RELOC_SPARC_L44
, R_SPARC_L44
},
350 { BFD_RELOC_SPARC_REGISTER
, R_SPARC_REGISTER
},
351 { BFD_RELOC_VTABLE_INHERIT
, R_SPARC_GNU_VTINHERIT
},
352 { BFD_RELOC_VTABLE_ENTRY
, R_SPARC_GNU_VTENTRY
},
353 { BFD_RELOC_SPARC_REV32
, R_SPARC_REV32
},
357 _bfd_sparc_elf_reloc_type_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
358 bfd_reloc_code_real_type code
)
364 case BFD_RELOC_VTABLE_INHERIT
:
365 return &sparc_vtinherit_howto
;
367 case BFD_RELOC_VTABLE_ENTRY
:
368 return &sparc_vtentry_howto
;
370 case BFD_RELOC_SPARC_REV32
:
371 return &sparc_rev32_howto
;
375 i
< sizeof (sparc_reloc_map
) / sizeof (struct elf_reloc_map
);
378 if (sparc_reloc_map
[i
].bfd_reloc_val
== code
)
379 return (_bfd_sparc_elf_howto_table
380 + (int) sparc_reloc_map
[i
].elf_reloc_val
);
383 bfd_set_error (bfd_error_bad_value
);
388 _bfd_sparc_elf_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
394 i
< (sizeof (_bfd_sparc_elf_howto_table
)
395 / sizeof (_bfd_sparc_elf_howto_table
[0]));
397 if (_bfd_sparc_elf_howto_table
[i
].name
!= NULL
398 && strcasecmp (_bfd_sparc_elf_howto_table
[i
].name
, r_name
) == 0)
399 return &_bfd_sparc_elf_howto_table
[i
];
401 if (strcasecmp (sparc_vtinherit_howto
.name
, r_name
) == 0)
402 return &sparc_vtinherit_howto
;
403 if (strcasecmp (sparc_vtentry_howto
.name
, r_name
) == 0)
404 return &sparc_vtentry_howto
;
405 if (strcasecmp (sparc_rev32_howto
.name
, r_name
) == 0)
406 return &sparc_rev32_howto
;
412 _bfd_sparc_elf_info_to_howto_ptr (unsigned int r_type
)
416 case R_SPARC_GNU_VTINHERIT
:
417 return &sparc_vtinherit_howto
;
419 case R_SPARC_GNU_VTENTRY
:
420 return &sparc_vtentry_howto
;
423 return &sparc_rev32_howto
;
426 if (r_type
>= (unsigned int) R_SPARC_max_std
)
428 (*_bfd_error_handler
) (_("invalid relocation type %d"),
430 r_type
= R_SPARC_NONE
;
432 return &_bfd_sparc_elf_howto_table
[r_type
];
436 /* Both 32-bit and 64-bit sparc encode this in an identical manner,
437 so just take advantage of that. */
438 #define SPARC_ELF_R_TYPE(r_info) \
442 _bfd_sparc_elf_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*cache_ptr
,
443 Elf_Internal_Rela
*dst
)
445 unsigned int r_type
= SPARC_ELF_R_TYPE (dst
->r_info
);
447 cache_ptr
->howto
= _bfd_sparc_elf_info_to_howto_ptr (r_type
);
451 /* The nop opcode we use. */
452 #define SPARC_NOP 0x01000000
454 #define SPARC_INSN_BYTES 4
456 /* The SPARC linker needs to keep track of the number of relocs that it
457 decides to copy as dynamic relocs in check_relocs for each symbol.
458 This is so that it can later discard them if they are found to be
459 unnecessary. We store the information in a field extending the
460 regular ELF linker hash table. */
462 struct _bfd_sparc_elf_dyn_relocs
464 struct _bfd_sparc_elf_dyn_relocs
*next
;
466 /* The input section of the reloc. */
469 /* Total number of relocs copied for the input section. */
472 /* Number of pc-relative relocs copied for the input section. */
473 bfd_size_type pc_count
;
476 /* SPARC ELF linker hash entry. */
478 struct _bfd_sparc_elf_link_hash_entry
480 struct elf_link_hash_entry elf
;
482 /* Track dynamic relocs copied for this symbol. */
483 struct _bfd_sparc_elf_dyn_relocs
*dyn_relocs
;
485 #define GOT_UNKNOWN 0
489 unsigned char tls_type
;
492 #define _bfd_sparc_elf_hash_entry(ent) ((struct _bfd_sparc_elf_link_hash_entry *)(ent))
494 struct _bfd_sparc_elf_obj_tdata
496 struct elf_obj_tdata root
;
498 /* tls_type for each local got entry. */
499 char *local_got_tls_type
;
501 /* TRUE if TLS GD relocs has been seen for this object. */
502 bfd_boolean has_tlsgd
;
505 #define _bfd_sparc_elf_tdata(abfd) \
506 ((struct _bfd_sparc_elf_obj_tdata *) (abfd)->tdata.any)
508 #define _bfd_sparc_elf_local_got_tls_type(abfd) \
509 (_bfd_sparc_elf_tdata (abfd)->local_got_tls_type)
512 _bfd_sparc_elf_mkobject (bfd
*abfd
)
514 if (abfd
->tdata
.any
== NULL
)
516 bfd_size_type amt
= sizeof (struct _bfd_sparc_elf_obj_tdata
);
517 abfd
->tdata
.any
= bfd_zalloc (abfd
, amt
);
518 if (abfd
->tdata
.any
== NULL
)
521 return bfd_elf_mkobject (abfd
);
525 sparc_put_word_32 (bfd
*bfd
, bfd_vma val
, void *ptr
)
527 bfd_put_32 (bfd
, val
, ptr
);
531 sparc_put_word_64 (bfd
*bfd
, bfd_vma val
, void *ptr
)
533 bfd_put_64 (bfd
, val
, ptr
);
537 sparc_elf_append_rela_64 (bfd
*abfd ATTRIBUTE_UNUSED
,
538 asection
*s ATTRIBUTE_UNUSED
,
539 Elf_Internal_Rela
*rel ATTRIBUTE_UNUSED
)
542 Elf64_External_Rela
*loc64
;
544 loc64
= (Elf64_External_Rela
*) s
->contents
;
545 loc64
+= s
->reloc_count
++;
546 bfd_elf64_swap_reloca_out (abfd
, rel
, (bfd_byte
*) loc64
);
551 sparc_elf_append_rela_32 (bfd
*abfd
, asection
*s
, Elf_Internal_Rela
*rel
)
553 Elf32_External_Rela
*loc32
;
555 loc32
= (Elf32_External_Rela
*) s
->contents
;
556 loc32
+= s
->reloc_count
++;
557 bfd_elf32_swap_reloca_out (abfd
, rel
, (bfd_byte
*) loc32
);
561 sparc_elf_r_info_64 (Elf_Internal_Rela
*in_rel ATTRIBUTE_UNUSED
,
562 bfd_vma index ATTRIBUTE_UNUSED
,
563 bfd_vma type ATTRIBUTE_UNUSED
)
565 return ELF64_R_INFO (index
,
567 ELF64_R_TYPE_INFO (ELF64_R_TYPE_DATA (in_rel
->r_info
),
572 sparc_elf_r_info_32 (Elf_Internal_Rela
*in_rel ATTRIBUTE_UNUSED
,
573 bfd_vma index
, bfd_vma type
)
575 return ELF32_R_INFO (index
, type
);
579 sparc_elf_r_symndx_64 (bfd_vma r_info
)
581 bfd_vma r_symndx
= ELF32_R_SYM (r_info
);
582 return (r_symndx
>> 24);
586 sparc_elf_r_symndx_32 (bfd_vma r_info
)
588 return ELF32_R_SYM (r_info
);
593 #define PLT32_ENTRY_SIZE 12
594 #define PLT32_HEADER_SIZE (4 * PLT32_ENTRY_SIZE)
596 /* The first four entries in a 32-bit procedure linkage table are reserved,
597 and the initial contents are unimportant (we zero them out).
598 Subsequent entries look like this. See the SVR4 ABI SPARC
599 supplement to see how this works. */
601 /* sethi %hi(.-.plt0),%g1. We fill in the address later. */
602 #define PLT32_ENTRY_WORD0 0x03000000
603 /* b,a .plt0. We fill in the offset later. */
604 #define PLT32_ENTRY_WORD1 0x30800000
606 #define PLT32_ENTRY_WORD2 SPARC_NOP
609 sparc32_plt_entry_build (bfd
*output_bfd
, asection
*splt
, bfd_vma offset
,
610 bfd_vma max ATTRIBUTE_UNUSED
,
613 bfd_put_32 (output_bfd
,
614 PLT32_ENTRY_WORD0
+ offset
,
615 splt
->contents
+ offset
);
616 bfd_put_32 (output_bfd
,
618 + (((- (offset
+ 4)) >> 2) & 0x3fffff)),
619 splt
->contents
+ offset
+ 4);
620 bfd_put_32 (output_bfd
, (bfd_vma
) PLT32_ENTRY_WORD2
,
621 splt
->contents
+ offset
+ 8);
625 return offset
/ PLT32_ENTRY_SIZE
- 4;
628 /* Both the headers and the entries are icache aligned. */
629 #define PLT64_ENTRY_SIZE 32
630 #define PLT64_HEADER_SIZE (4 * PLT64_ENTRY_SIZE)
631 #define PLT64_LARGE_THRESHOLD 32768
634 sparc64_plt_entry_build (bfd
*output_bfd
, asection
*splt
, bfd_vma offset
,
635 bfd_vma max
, bfd_vma
*r_offset
)
637 unsigned char *entry
= splt
->contents
+ offset
;
638 const unsigned int nop
= SPARC_NOP
;
641 if (offset
< (PLT64_LARGE_THRESHOLD
* PLT64_ENTRY_SIZE
))
643 unsigned int sethi
, ba
;
647 index
= (offset
/ PLT64_ENTRY_SIZE
);
649 sethi
= 0x03000000 | (index
* PLT64_ENTRY_SIZE
);
651 | (((splt
->contents
+ PLT64_ENTRY_SIZE
) - (entry
+ 4)) / 4 & 0x7ffff);
653 bfd_put_32 (output_bfd
, (bfd_vma
) sethi
, entry
);
654 bfd_put_32 (output_bfd
, (bfd_vma
) ba
, entry
+ 4);
655 bfd_put_32 (output_bfd
, (bfd_vma
) nop
, entry
+ 8);
656 bfd_put_32 (output_bfd
, (bfd_vma
) nop
, entry
+ 12);
657 bfd_put_32 (output_bfd
, (bfd_vma
) nop
, entry
+ 16);
658 bfd_put_32 (output_bfd
, (bfd_vma
) nop
, entry
+ 20);
659 bfd_put_32 (output_bfd
, (bfd_vma
) nop
, entry
+ 24);
660 bfd_put_32 (output_bfd
, (bfd_vma
) nop
, entry
+ 28);
666 int block
, last_block
, ofs
, last_ofs
, chunks_this_block
;
667 const int insn_chunk_size
= (6 * 4);
668 const int ptr_chunk_size
= (1 * 8);
669 const int entries_per_block
= 160;
670 const int block_size
= entries_per_block
* (insn_chunk_size
673 /* Entries 32768 and higher are grouped into blocks of 160.
674 The blocks are further subdivided into 160 sequences of
675 6 instructions and 160 pointers. If a block does not require
676 the full 160 entries, let's say it requires N, then there
677 will be N sequences of 6 instructions and N pointers. */
679 offset
-= (PLT64_LARGE_THRESHOLD
* PLT64_ENTRY_SIZE
);
680 max
-= (PLT64_LARGE_THRESHOLD
* PLT64_ENTRY_SIZE
);
682 block
= offset
/ block_size
;
683 last_block
= max
/ block_size
;
684 if (block
!= last_block
)
686 chunks_this_block
= 160;
690 last_ofs
= max
% block_size
;
691 chunks_this_block
= last_ofs
/ (insn_chunk_size
+ ptr_chunk_size
);
694 ofs
= offset
% block_size
;
696 index
= (PLT64_LARGE_THRESHOLD
+
698 (ofs
/ insn_chunk_size
));
701 + (PLT64_LARGE_THRESHOLD
* PLT64_ENTRY_SIZE
)
702 + (block
* block_size
)
703 + (chunks_this_block
* insn_chunk_size
)
704 + (ofs
/ insn_chunk_size
) * ptr_chunk_size
;
706 *r_offset
= (bfd_vma
) (ptr
- splt
->contents
);
708 ldx
= 0xc25be000 | ((ptr
- (entry
+4)) & 0x1fff);
716 bfd_put_32 (output_bfd
, (bfd_vma
) 0x8a10000f, entry
);
717 bfd_put_32 (output_bfd
, (bfd_vma
) 0x40000002, entry
+ 4);
718 bfd_put_32 (output_bfd
, (bfd_vma
) SPARC_NOP
, entry
+ 8);
719 bfd_put_32 (output_bfd
, (bfd_vma
) ldx
, entry
+ 12);
720 bfd_put_32 (output_bfd
, (bfd_vma
) 0x83c3c001, entry
+ 16);
721 bfd_put_32 (output_bfd
, (bfd_vma
) 0x9e100005, entry
+ 20);
723 bfd_put_64 (output_bfd
, (bfd_vma
) (splt
->contents
- (entry
+ 4)), ptr
);
729 /* The format of the first PLT entry in a VxWorks executable. */
730 static const bfd_vma sparc_vxworks_exec_plt0_entry
[] =
732 0x05000000, /* sethi %hi(_GLOBAL_OFFSET_TABLE_+8), %g2 */
733 0x8410a000, /* or %g2, %lo(_GLOBAL_OFFSET_TABLE_+8), %g2 */
734 0xc4008000, /* ld [ %g2 ], %g2 */
735 0x81c08000, /* jmp %g2 */
739 /* The format of subsequent PLT entries. */
740 static const bfd_vma sparc_vxworks_exec_plt_entry
[] =
742 0x03000000, /* sethi %hi(_GLOBAL_OFFSET_TABLE_+f@got), %g1 */
743 0x82106000, /* or %g1, %lo(_GLOBAL_OFFSET_TABLE_+f@got), %g1 */
744 0xc2004000, /* ld [ %g1 ], %g1 */
745 0x81c04000, /* jmp %g1 */
746 0x01000000, /* nop */
747 0x03000000, /* sethi %hi(f@pltindex), %g1 */
748 0x10800000, /* b _PLT_resolve */
749 0x82106000 /* or %g1, %lo(f@pltindex), %g1 */
752 /* The format of the first PLT entry in a VxWorks shared object. */
753 static const bfd_vma sparc_vxworks_shared_plt0_entry
[] =
755 0xc405e008, /* ld [ %l7 + 8 ], %g2 */
756 0x81c08000, /* jmp %g2 */
760 /* The format of subsequent PLT entries. */
761 static const bfd_vma sparc_vxworks_shared_plt_entry
[] =
763 0x03000000, /* sethi %hi(f@got), %g1 */
764 0x82106000, /* or %g1, %lo(f@got), %g1 */
765 0xc205c001, /* ld [ %l7 + %g1 ], %g1 */
766 0x81c04000, /* jmp %g1 */
767 0x01000000, /* nop */
768 0x03000000, /* sethi %hi(f@pltindex), %g1 */
769 0x10800000, /* b _PLT_resolve */
770 0x82106000 /* or %g1, %lo(f@pltindex), %g1 */
773 #define SPARC_ELF_PUT_WORD(htab, bfd, val, ptr) \
774 htab->put_word(bfd, val, ptr)
776 #define SPARC_ELF_APPEND_RELA(htab, bfd, sec, rela) \
777 htab->append_rela(bfd, sec, rela)
779 #define SPARC_ELF_R_INFO(htab, in_rel, index, type) \
780 htab->r_info(in_rel, index, type)
782 #define SPARC_ELF_R_SYMNDX(htab, r_info) \
783 htab->r_symndx(r_info)
785 #define SPARC_ELF_WORD_BYTES(htab) \
788 #define SPARC_ELF_RELA_BYTES(htab) \
791 #define SPARC_ELF_DTPOFF_RELOC(htab) \
794 #define SPARC_ELF_DTPMOD_RELOC(htab) \
797 #define SPARC_ELF_TPOFF_RELOC(htab) \
800 #define SPARC_ELF_BUILD_PLT_ENTRY(htab, obfd, splt, off, max, r_off) \
801 htab->build_plt_entry (obfd, splt, off, max, r_off)
803 /* Create an entry in an SPARC ELF linker hash table. */
805 static struct bfd_hash_entry
*
806 link_hash_newfunc (struct bfd_hash_entry
*entry
,
807 struct bfd_hash_table
*table
, const char *string
)
809 /* Allocate the structure if it has not already been allocated by a
813 entry
= bfd_hash_allocate (table
,
814 sizeof (struct _bfd_sparc_elf_link_hash_entry
));
819 /* Call the allocation method of the superclass. */
820 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
823 struct _bfd_sparc_elf_link_hash_entry
*eh
;
825 eh
= (struct _bfd_sparc_elf_link_hash_entry
*) entry
;
826 eh
->dyn_relocs
= NULL
;
827 eh
->tls_type
= GOT_UNKNOWN
;
833 /* The name of the dynamic interpreter. This is put in the .interp
836 #define ELF32_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
837 #define ELF64_DYNAMIC_INTERPRETER "/usr/lib/sparcv9/ld.so.1"
839 /* Create a SPARC ELF linker hash table. */
841 struct bfd_link_hash_table
*
842 _bfd_sparc_elf_link_hash_table_create (bfd
*abfd
)
844 struct _bfd_sparc_elf_link_hash_table
*ret
;
845 bfd_size_type amt
= sizeof (struct _bfd_sparc_elf_link_hash_table
);
847 ret
= (struct _bfd_sparc_elf_link_hash_table
*) bfd_zmalloc (amt
);
853 ret
->put_word
= sparc_put_word_64
;
854 ret
->append_rela
= sparc_elf_append_rela_64
;
855 ret
->r_info
= sparc_elf_r_info_64
;
856 ret
->r_symndx
= sparc_elf_r_symndx_64
;
857 ret
->dtpoff_reloc
= R_SPARC_TLS_DTPOFF64
;
858 ret
->dtpmod_reloc
= R_SPARC_TLS_DTPMOD64
;
859 ret
->tpoff_reloc
= R_SPARC_TLS_TPOFF64
;
860 ret
->word_align_power
= 3;
861 ret
->align_power_max
= 4;
862 ret
->bytes_per_word
= 8;
863 ret
->bytes_per_rela
= sizeof (Elf64_External_Rela
);
864 ret
->dynamic_interpreter
= ELF64_DYNAMIC_INTERPRETER
;
865 ret
->dynamic_interpreter_size
= sizeof ELF64_DYNAMIC_INTERPRETER
;
869 ret
->put_word
= sparc_put_word_32
;
870 ret
->append_rela
= sparc_elf_append_rela_32
;
871 ret
->r_info
= sparc_elf_r_info_32
;
872 ret
->r_symndx
= sparc_elf_r_symndx_32
;
873 ret
->dtpoff_reloc
= R_SPARC_TLS_DTPOFF32
;
874 ret
->dtpmod_reloc
= R_SPARC_TLS_DTPMOD32
;
875 ret
->tpoff_reloc
= R_SPARC_TLS_TPOFF32
;
876 ret
->word_align_power
= 2;
877 ret
->align_power_max
= 3;
878 ret
->bytes_per_word
= 4;
879 ret
->bytes_per_rela
= sizeof (Elf32_External_Rela
);
880 ret
->dynamic_interpreter
= ELF32_DYNAMIC_INTERPRETER
;
881 ret
->dynamic_interpreter_size
= sizeof ELF32_DYNAMIC_INTERPRETER
;
884 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
, link_hash_newfunc
,
885 sizeof (struct _bfd_sparc_elf_link_hash_entry
)))
891 return &ret
->elf
.root
;
894 /* Create .got and .rela.got sections in DYNOBJ, and set up
895 shortcuts to them in our hash table. */
898 create_got_section (bfd
*dynobj
, struct bfd_link_info
*info
)
900 struct _bfd_sparc_elf_link_hash_table
*htab
;
902 if (! _bfd_elf_create_got_section (dynobj
, info
))
905 htab
= _bfd_sparc_elf_hash_table (info
);
906 htab
->sgot
= bfd_get_section_by_name (dynobj
, ".got");
907 BFD_ASSERT (htab
->sgot
!= NULL
);
909 htab
->srelgot
= bfd_make_section_with_flags (dynobj
, ".rela.got",
916 if (htab
->srelgot
== NULL
917 || ! bfd_set_section_alignment (dynobj
, htab
->srelgot
,
918 htab
->word_align_power
))
921 if (htab
->is_vxworks
)
923 htab
->sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
931 /* Create .plt, .rela.plt, .got, .rela.got, .dynbss, and
932 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
936 _bfd_sparc_elf_create_dynamic_sections (bfd
*dynobj
,
937 struct bfd_link_info
*info
)
939 struct _bfd_sparc_elf_link_hash_table
*htab
;
941 htab
= _bfd_sparc_elf_hash_table (info
);
942 if (!htab
->sgot
&& !create_got_section (dynobj
, info
))
945 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
948 htab
->splt
= bfd_get_section_by_name (dynobj
, ".plt");
949 htab
->srelplt
= bfd_get_section_by_name (dynobj
, ".rela.plt");
950 htab
->sdynbss
= bfd_get_section_by_name (dynobj
, ".dynbss");
952 htab
->srelbss
= bfd_get_section_by_name (dynobj
, ".rela.bss");
954 if (htab
->is_vxworks
)
956 if (!elf_vxworks_create_dynamic_sections (dynobj
, info
, &htab
->srelplt2
))
960 htab
->plt_header_size
961 = 4 * ARRAY_SIZE (sparc_vxworks_shared_plt0_entry
);
963 = 4 * ARRAY_SIZE (sparc_vxworks_shared_plt_entry
);
967 htab
->plt_header_size
968 = 4 * ARRAY_SIZE (sparc_vxworks_exec_plt0_entry
);
970 = 4 * ARRAY_SIZE (sparc_vxworks_exec_plt_entry
);
975 if (ABI_64_P (dynobj
))
977 htab
->build_plt_entry
= sparc64_plt_entry_build
;
978 htab
->plt_header_size
= PLT64_HEADER_SIZE
;
979 htab
->plt_entry_size
= PLT64_ENTRY_SIZE
;
983 htab
->build_plt_entry
= sparc32_plt_entry_build
;
984 htab
->plt_header_size
= PLT32_HEADER_SIZE
;
985 htab
->plt_entry_size
= PLT32_ENTRY_SIZE
;
989 if (!htab
->splt
|| !htab
->srelplt
|| !htab
->sdynbss
990 || (!info
->shared
&& !htab
->srelbss
))
996 /* Copy the extra info we tack onto an elf_link_hash_entry. */
999 _bfd_sparc_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
1000 struct elf_link_hash_entry
*dir
,
1001 struct elf_link_hash_entry
*ind
)
1003 struct _bfd_sparc_elf_link_hash_entry
*edir
, *eind
;
1005 edir
= (struct _bfd_sparc_elf_link_hash_entry
*) dir
;
1006 eind
= (struct _bfd_sparc_elf_link_hash_entry
*) ind
;
1008 if (eind
->dyn_relocs
!= NULL
)
1010 if (edir
->dyn_relocs
!= NULL
)
1012 struct _bfd_sparc_elf_dyn_relocs
**pp
;
1013 struct _bfd_sparc_elf_dyn_relocs
*p
;
1015 /* Add reloc counts against the indirect sym to the direct sym
1016 list. Merge any entries against the same section. */
1017 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
1019 struct _bfd_sparc_elf_dyn_relocs
*q
;
1021 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
1022 if (q
->sec
== p
->sec
)
1024 q
->pc_count
+= p
->pc_count
;
1025 q
->count
+= p
->count
;
1032 *pp
= edir
->dyn_relocs
;
1035 edir
->dyn_relocs
= eind
->dyn_relocs
;
1036 eind
->dyn_relocs
= NULL
;
1039 if (ind
->root
.type
== bfd_link_hash_indirect
1040 && dir
->got
.refcount
<= 0)
1042 edir
->tls_type
= eind
->tls_type
;
1043 eind
->tls_type
= GOT_UNKNOWN
;
1045 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
1049 sparc_elf_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
1050 int r_type
, int is_local
)
1052 if (! ABI_64_P (abfd
)
1053 && r_type
== R_SPARC_TLS_GD_HI22
1054 && ! _bfd_sparc_elf_tdata (abfd
)->has_tlsgd
)
1055 r_type
= R_SPARC_REV32
;
1062 case R_SPARC_TLS_GD_HI22
:
1064 return R_SPARC_TLS_LE_HIX22
;
1065 return R_SPARC_TLS_IE_HI22
;
1066 case R_SPARC_TLS_GD_LO10
:
1068 return R_SPARC_TLS_LE_LOX10
;
1069 return R_SPARC_TLS_IE_LO10
;
1070 case R_SPARC_TLS_IE_HI22
:
1072 return R_SPARC_TLS_LE_HIX22
;
1074 case R_SPARC_TLS_IE_LO10
:
1076 return R_SPARC_TLS_LE_LOX10
;
1078 case R_SPARC_TLS_LDM_HI22
:
1079 return R_SPARC_TLS_LE_HIX22
;
1080 case R_SPARC_TLS_LDM_LO10
:
1081 return R_SPARC_TLS_LE_LOX10
;
1087 /* Look through the relocs for a section during the first phase, and
1088 allocate space in the global offset table or procedure linkage
1092 _bfd_sparc_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
1093 asection
*sec
, const Elf_Internal_Rela
*relocs
)
1095 struct _bfd_sparc_elf_link_hash_table
*htab
;
1096 Elf_Internal_Shdr
*symtab_hdr
;
1097 struct elf_link_hash_entry
**sym_hashes
;
1098 bfd_vma
*local_got_offsets
;
1099 const Elf_Internal_Rela
*rel
;
1100 const Elf_Internal_Rela
*rel_end
;
1103 bfd_boolean checked_tlsgd
= FALSE
;
1105 if (info
->relocatable
)
1108 htab
= _bfd_sparc_elf_hash_table (info
);
1109 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1110 sym_hashes
= elf_sym_hashes (abfd
);
1111 local_got_offsets
= elf_local_got_offsets (abfd
);
1115 if (ABI_64_P (abfd
))
1116 num_relocs
= NUM_SHDR_ENTRIES (& elf_section_data (sec
)->rel_hdr
);
1118 num_relocs
= sec
->reloc_count
;
1119 rel_end
= relocs
+ num_relocs
;
1120 for (rel
= relocs
; rel
< rel_end
; rel
++)
1122 unsigned int r_type
;
1123 unsigned long r_symndx
;
1124 struct elf_link_hash_entry
*h
;
1126 r_symndx
= SPARC_ELF_R_SYMNDX (htab
, rel
->r_info
);
1127 r_type
= SPARC_ELF_R_TYPE (rel
->r_info
);
1129 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1131 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
1136 if (r_symndx
< symtab_hdr
->sh_info
)
1140 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1141 while (h
->root
.type
== bfd_link_hash_indirect
1142 || h
->root
.type
== bfd_link_hash_warning
)
1143 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1146 /* Compatibility with old R_SPARC_REV32 reloc conflicting
1147 with R_SPARC_TLS_GD_HI22. */
1148 if (! ABI_64_P (abfd
) && ! checked_tlsgd
)
1151 case R_SPARC_TLS_GD_HI22
:
1153 const Elf_Internal_Rela
*relt
;
1155 for (relt
= rel
+ 1; relt
< rel_end
; relt
++)
1156 if (ELF32_R_TYPE (relt
->r_info
) == R_SPARC_TLS_GD_LO10
1157 || ELF32_R_TYPE (relt
->r_info
) == R_SPARC_TLS_GD_ADD
1158 || ELF32_R_TYPE (relt
->r_info
) == R_SPARC_TLS_GD_CALL
)
1160 checked_tlsgd
= TRUE
;
1161 _bfd_sparc_elf_tdata (abfd
)->has_tlsgd
= relt
< rel_end
;
1164 case R_SPARC_TLS_GD_LO10
:
1165 case R_SPARC_TLS_GD_ADD
:
1166 case R_SPARC_TLS_GD_CALL
:
1167 checked_tlsgd
= TRUE
;
1168 _bfd_sparc_elf_tdata (abfd
)->has_tlsgd
= TRUE
;
1172 r_type
= sparc_elf_tls_transition (info
, abfd
, r_type
, h
== NULL
);
1175 case R_SPARC_TLS_LDM_HI22
:
1176 case R_SPARC_TLS_LDM_LO10
:
1177 htab
->tls_ldm_got
.refcount
+= 1;
1180 case R_SPARC_TLS_LE_HIX22
:
1181 case R_SPARC_TLS_LE_LOX10
:
1186 case R_SPARC_TLS_IE_HI22
:
1187 case R_SPARC_TLS_IE_LO10
:
1189 info
->flags
|= DF_STATIC_TLS
;
1195 case R_SPARC_TLS_GD_HI22
:
1196 case R_SPARC_TLS_GD_LO10
:
1197 /* This symbol requires a global offset table entry. */
1199 int tls_type
, old_tls_type
;
1207 tls_type
= GOT_NORMAL
;
1209 case R_SPARC_TLS_GD_HI22
:
1210 case R_SPARC_TLS_GD_LO10
:
1211 tls_type
= GOT_TLS_GD
;
1213 case R_SPARC_TLS_IE_HI22
:
1214 case R_SPARC_TLS_IE_LO10
:
1215 tls_type
= GOT_TLS_IE
;
1221 h
->got
.refcount
+= 1;
1222 old_tls_type
= _bfd_sparc_elf_hash_entry(h
)->tls_type
;
1226 bfd_signed_vma
*local_got_refcounts
;
1228 /* This is a global offset table entry for a local symbol. */
1229 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1230 if (local_got_refcounts
== NULL
)
1234 size
= symtab_hdr
->sh_info
;
1235 size
*= (sizeof (bfd_signed_vma
) + sizeof(char));
1236 local_got_refcounts
= ((bfd_signed_vma
*)
1237 bfd_zalloc (abfd
, size
));
1238 if (local_got_refcounts
== NULL
)
1240 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1241 _bfd_sparc_elf_local_got_tls_type (abfd
)
1242 = (char *) (local_got_refcounts
+ symtab_hdr
->sh_info
);
1244 local_got_refcounts
[r_symndx
] += 1;
1245 old_tls_type
= _bfd_sparc_elf_local_got_tls_type (abfd
) [r_symndx
];
1248 /* If a TLS symbol is accessed using IE at least once,
1249 there is no point to use dynamic model for it. */
1250 if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1251 && (old_tls_type
!= GOT_TLS_GD
1252 || tls_type
!= GOT_TLS_IE
))
1254 if (old_tls_type
== GOT_TLS_IE
&& tls_type
== GOT_TLS_GD
)
1255 tls_type
= old_tls_type
;
1258 (*_bfd_error_handler
)
1259 (_("%B: `%s' accessed both as normal and thread local symbol"),
1260 abfd
, h
? h
->root
.root
.string
: "<local>");
1265 if (old_tls_type
!= tls_type
)
1268 _bfd_sparc_elf_hash_entry (h
)->tls_type
= tls_type
;
1270 _bfd_sparc_elf_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1274 if (htab
->sgot
== NULL
)
1276 if (htab
->elf
.dynobj
== NULL
)
1277 htab
->elf
.dynobj
= abfd
;
1278 if (!create_got_section (htab
->elf
.dynobj
, info
))
1283 case R_SPARC_TLS_GD_CALL
:
1284 case R_SPARC_TLS_LDM_CALL
:
1287 /* These are basically R_SPARC_TLS_WPLT30 relocs against
1289 struct bfd_link_hash_entry
*bh
= NULL
;
1290 if (! _bfd_generic_link_add_one_symbol (info
, abfd
,
1291 "__tls_get_addr", 0,
1292 bfd_und_section_ptr
, 0,
1296 h
= (struct elf_link_hash_entry
*) bh
;
1303 case R_SPARC_WPLT30
:
1304 case R_SPARC_HIPLT22
:
1305 case R_SPARC_LOPLT10
:
1306 case R_SPARC_PCPLT32
:
1307 case R_SPARC_PCPLT22
:
1308 case R_SPARC_PCPLT10
:
1310 /* This symbol requires a procedure linkage table entry. We
1311 actually build the entry in adjust_dynamic_symbol,
1312 because this might be a case of linking PIC code without
1313 linking in any dynamic objects, in which case we don't
1314 need to generate a procedure linkage table after all. */
1318 if (! ABI_64_P (abfd
))
1320 /* The Solaris native assembler will generate a WPLT30
1321 reloc for a local symbol if you assemble a call from
1322 one section to another when using -K pic. We treat
1324 if (ELF32_R_TYPE (rel
->r_info
) == R_SPARC_PLT32
)
1329 /* It does not make sense to have a procedure linkage
1330 table entry for a local symbol. */
1331 bfd_set_error (bfd_error_bad_value
);
1340 this_r_type
= SPARC_ELF_R_TYPE (rel
->r_info
);
1341 if (this_r_type
== R_SPARC_PLT32
1342 || this_r_type
== R_SPARC_PLT64
)
1345 h
->plt
.refcount
+= 1;
1350 case R_SPARC_PC_HH22
:
1351 case R_SPARC_PC_HM10
:
1352 case R_SPARC_PC_LM22
:
1357 && strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
1362 case R_SPARC_DISP16
:
1363 case R_SPARC_DISP32
:
1364 case R_SPARC_DISP64
:
1365 case R_SPARC_WDISP30
:
1366 case R_SPARC_WDISP22
:
1367 case R_SPARC_WDISP19
:
1368 case R_SPARC_WDISP16
:
1398 if (h
!= NULL
&& !info
->shared
)
1400 /* We may need a .plt entry if the function this reloc
1401 refers to is in a shared lib. */
1402 h
->plt
.refcount
+= 1;
1405 /* If we are creating a shared library, and this is a reloc
1406 against a global symbol, or a non PC relative reloc
1407 against a local symbol, then we need to copy the reloc
1408 into the shared library. However, if we are linking with
1409 -Bsymbolic, we do not need to copy a reloc against a
1410 global symbol which is defined in an object we are
1411 including in the link (i.e., DEF_REGULAR is set). At
1412 this point we have not seen all the input files, so it is
1413 possible that DEF_REGULAR is not set now but will be set
1414 later (it is never cleared). In case of a weak definition,
1415 DEF_REGULAR may be cleared later by a strong definition in
1416 a shared library. We account for that possibility below by
1417 storing information in the relocs_copied field of the hash
1418 table entry. A similar situation occurs when creating
1419 shared libraries and symbol visibility changes render the
1422 If on the other hand, we are creating an executable, we
1423 may need to keep relocations for symbols satisfied by a
1424 dynamic library if we manage to avoid copy relocs for the
1427 && (sec
->flags
& SEC_ALLOC
) != 0
1428 && (! _bfd_sparc_elf_howto_table
[r_type
].pc_relative
1430 && (! info
->symbolic
1431 || h
->root
.type
== bfd_link_hash_defweak
1432 || !h
->def_regular
))))
1434 && (sec
->flags
& SEC_ALLOC
) != 0
1436 && (h
->root
.type
== bfd_link_hash_defweak
1437 || !h
->def_regular
)))
1439 struct _bfd_sparc_elf_dyn_relocs
*p
;
1440 struct _bfd_sparc_elf_dyn_relocs
**head
;
1442 /* When creating a shared object, we must copy these
1443 relocs into the output file. We create a reloc
1444 section in dynobj and make room for the reloc. */
1450 name
= (bfd_elf_string_from_elf_section
1452 elf_elfheader (abfd
)->e_shstrndx
,
1453 elf_section_data (sec
)->rel_hdr
.sh_name
));
1457 BFD_ASSERT (CONST_STRNEQ (name
, ".rela")
1458 && strcmp (bfd_get_section_name (abfd
, sec
),
1461 if (htab
->elf
.dynobj
== NULL
)
1462 htab
->elf
.dynobj
= abfd
;
1463 dynobj
= htab
->elf
.dynobj
;
1465 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1470 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
1471 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
1472 if ((sec
->flags
& SEC_ALLOC
) != 0)
1473 flags
|= SEC_ALLOC
| SEC_LOAD
;
1474 sreloc
= bfd_make_section_with_flags (dynobj
,
1478 || ! bfd_set_section_alignment (dynobj
, sreloc
,
1479 htab
->word_align_power
))
1482 elf_section_data (sec
)->sreloc
= sreloc
;
1485 /* If this is a global symbol, we count the number of
1486 relocations we need for this symbol. */
1488 head
= &((struct _bfd_sparc_elf_link_hash_entry
*) h
)->dyn_relocs
;
1491 /* Track dynamic relocs needed for local syms too.
1492 We really need local syms available to do this
1498 s
= bfd_section_from_r_symndx (abfd
, &htab
->sym_sec
,
1503 vpp
= &elf_section_data (s
)->local_dynrel
;
1504 head
= (struct _bfd_sparc_elf_dyn_relocs
**) vpp
;
1508 if (p
== NULL
|| p
->sec
!= sec
)
1510 bfd_size_type amt
= sizeof *p
;
1511 p
= ((struct _bfd_sparc_elf_dyn_relocs
*)
1512 bfd_alloc (htab
->elf
.dynobj
, amt
));
1523 if (_bfd_sparc_elf_howto_table
[r_type
].pc_relative
)
1529 case R_SPARC_GNU_VTINHERIT
:
1530 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1534 case R_SPARC_GNU_VTENTRY
:
1535 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
1539 case R_SPARC_REGISTER
:
1540 /* Nothing to do. */
1552 _bfd_sparc_elf_gc_mark_hook (asection
*sec
,
1553 struct bfd_link_info
*info
,
1554 Elf_Internal_Rela
*rel
,
1555 struct elf_link_hash_entry
*h
,
1556 Elf_Internal_Sym
*sym
)
1559 switch (SPARC_ELF_R_TYPE (rel
->r_info
))
1561 case R_SPARC_GNU_VTINHERIT
:
1562 case R_SPARC_GNU_VTENTRY
:
1566 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
1569 /* Update the got entry reference counts for the section being removed. */
1571 _bfd_sparc_elf_gc_sweep_hook (bfd
*abfd
, struct bfd_link_info
*info
,
1572 asection
*sec
, const Elf_Internal_Rela
*relocs
)
1574 struct _bfd_sparc_elf_link_hash_table
*htab
;
1575 Elf_Internal_Shdr
*symtab_hdr
;
1576 struct elf_link_hash_entry
**sym_hashes
;
1577 bfd_signed_vma
*local_got_refcounts
;
1578 const Elf_Internal_Rela
*rel
, *relend
;
1580 elf_section_data (sec
)->local_dynrel
= NULL
;
1582 htab
= _bfd_sparc_elf_hash_table (info
);
1583 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1584 sym_hashes
= elf_sym_hashes (abfd
);
1585 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1587 relend
= relocs
+ sec
->reloc_count
;
1588 for (rel
= relocs
; rel
< relend
; rel
++)
1590 unsigned long r_symndx
;
1591 unsigned int r_type
;
1592 struct elf_link_hash_entry
*h
= NULL
;
1594 r_symndx
= SPARC_ELF_R_SYMNDX (htab
, rel
->r_info
);
1595 if (r_symndx
>= symtab_hdr
->sh_info
)
1597 struct _bfd_sparc_elf_link_hash_entry
*eh
;
1598 struct _bfd_sparc_elf_dyn_relocs
**pp
;
1599 struct _bfd_sparc_elf_dyn_relocs
*p
;
1601 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1602 while (h
->root
.type
== bfd_link_hash_indirect
1603 || h
->root
.type
== bfd_link_hash_warning
)
1604 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1605 eh
= (struct _bfd_sparc_elf_link_hash_entry
*) h
;
1606 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
1609 /* Everything must go for SEC. */
1615 r_type
= SPARC_ELF_R_TYPE (rel
->r_info
);
1616 r_type
= sparc_elf_tls_transition (info
, abfd
, r_type
, h
!= NULL
);
1619 case R_SPARC_TLS_LDM_HI22
:
1620 case R_SPARC_TLS_LDM_LO10
:
1621 if (_bfd_sparc_elf_hash_table (info
)->tls_ldm_got
.refcount
> 0)
1622 _bfd_sparc_elf_hash_table (info
)->tls_ldm_got
.refcount
-= 1;
1625 case R_SPARC_TLS_GD_HI22
:
1626 case R_SPARC_TLS_GD_LO10
:
1627 case R_SPARC_TLS_IE_HI22
:
1628 case R_SPARC_TLS_IE_LO10
:
1634 if (h
->got
.refcount
> 0)
1639 if (local_got_refcounts
[r_symndx
] > 0)
1640 local_got_refcounts
[r_symndx
]--;
1646 case R_SPARC_PC_HH22
:
1647 case R_SPARC_PC_HM10
:
1648 case R_SPARC_PC_LM22
:
1650 && strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
1655 case R_SPARC_DISP16
:
1656 case R_SPARC_DISP32
:
1657 case R_SPARC_DISP64
:
1658 case R_SPARC_WDISP30
:
1659 case R_SPARC_WDISP22
:
1660 case R_SPARC_WDISP19
:
1661 case R_SPARC_WDISP16
:
1692 case R_SPARC_WPLT30
:
1695 if (h
->plt
.refcount
> 0)
1708 /* Adjust a symbol defined by a dynamic object and referenced by a
1709 regular object. The current definition is in some section of the
1710 dynamic object, but we're not including those sections. We have to
1711 change the definition to something the rest of the link can
1715 _bfd_sparc_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
1716 struct elf_link_hash_entry
*h
)
1718 struct _bfd_sparc_elf_link_hash_table
*htab
;
1719 struct _bfd_sparc_elf_link_hash_entry
* eh
;
1720 struct _bfd_sparc_elf_dyn_relocs
*p
;
1722 unsigned int power_of_two
;
1724 htab
= _bfd_sparc_elf_hash_table (info
);
1726 /* Make sure we know what is going on here. */
1727 BFD_ASSERT (htab
->elf
.dynobj
!= NULL
1729 || h
->u
.weakdef
!= NULL
1732 && !h
->def_regular
)));
1734 /* If this is a function, put it in the procedure linkage table. We
1735 will fill in the contents of the procedure linkage table later
1736 (although we could actually do it here). The STT_NOTYPE
1737 condition is a hack specifically for the Oracle libraries
1738 delivered for Solaris; for some inexplicable reason, they define
1739 some of their functions as STT_NOTYPE when they really should be
1741 if (h
->type
== STT_FUNC
1743 || (h
->type
== STT_NOTYPE
1744 && (h
->root
.type
== bfd_link_hash_defined
1745 || h
->root
.type
== bfd_link_hash_defweak
)
1746 && (h
->root
.u
.def
.section
->flags
& SEC_CODE
) != 0))
1748 if (h
->plt
.refcount
<= 0
1752 && h
->root
.type
!= bfd_link_hash_undefweak
1753 && h
->root
.type
!= bfd_link_hash_undefined
))
1755 /* This case can occur if we saw a WPLT30 reloc in an input
1756 file, but the symbol was never referred to by a dynamic
1757 object, or if all references were garbage collected. In
1758 such a case, we don't actually need to build a procedure
1759 linkage table, and we can just do a WDISP30 reloc instead. */
1760 h
->plt
.offset
= (bfd_vma
) -1;
1767 h
->plt
.offset
= (bfd_vma
) -1;
1769 /* If this is a weak symbol, and there is a real definition, the
1770 processor independent code will have arranged for us to see the
1771 real definition first, and we can just use the same value. */
1772 if (h
->u
.weakdef
!= NULL
)
1774 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
1775 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
1776 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
1777 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
1781 /* This is a reference to a symbol defined by a dynamic object which
1782 is not a function. */
1784 /* If we are creating a shared library, we must presume that the
1785 only references to the symbol are via the global offset table.
1786 For such cases we need not do anything here; the relocations will
1787 be handled correctly by relocate_section. */
1791 /* If there are no references to this symbol that do not use the
1792 GOT, we don't need to generate a copy reloc. */
1793 if (!h
->non_got_ref
)
1796 eh
= (struct _bfd_sparc_elf_link_hash_entry
*) h
;
1797 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1799 s
= p
->sec
->output_section
;
1800 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1804 /* If we didn't find any dynamic relocs in read-only sections, then
1805 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1814 (*_bfd_error_handler
) (_("dynamic variable `%s' is zero size"),
1815 h
->root
.root
.string
);
1819 /* We must allocate the symbol in our .dynbss section, which will
1820 become part of the .bss section of the executable. There will be
1821 an entry for this symbol in the .dynsym section. The dynamic
1822 object will contain position independent code, so all references
1823 from the dynamic object to this symbol will go through the global
1824 offset table. The dynamic linker will use the .dynsym entry to
1825 determine the address it must put in the global offset table, so
1826 both the dynamic object and the regular object will refer to the
1827 same memory location for the variable. */
1829 /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker
1830 to copy the initial value out of the dynamic object and into the
1831 runtime process image. We need to remember the offset into the
1832 .rel.bss section we are going to use. */
1833 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
1835 htab
->srelbss
->size
+= SPARC_ELF_RELA_BYTES (htab
);
1839 /* We need to figure out the alignment required for this symbol. I
1840 have no idea how ELF linkers handle this. */
1841 power_of_two
= bfd_log2 (h
->size
);
1842 if (power_of_two
> htab
->align_power_max
)
1843 power_of_two
= htab
->align_power_max
;
1845 /* Apply the required alignment. */
1847 s
->size
= BFD_ALIGN (s
->size
, (bfd_size_type
) (1 << power_of_two
));
1848 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
1850 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
1854 /* Define the symbol as being at this point in the section. */
1855 h
->root
.u
.def
.section
= s
;
1856 h
->root
.u
.def
.value
= s
->size
;
1858 /* Increment the section size to make room for the symbol. */
1864 /* Allocate space in .plt, .got and associated reloc sections for
1868 allocate_dynrelocs (struct elf_link_hash_entry
*h
, PTR inf
)
1870 struct bfd_link_info
*info
;
1871 struct _bfd_sparc_elf_link_hash_table
*htab
;
1872 struct _bfd_sparc_elf_link_hash_entry
*eh
;
1873 struct _bfd_sparc_elf_dyn_relocs
*p
;
1875 if (h
->root
.type
== bfd_link_hash_indirect
)
1878 if (h
->root
.type
== bfd_link_hash_warning
)
1879 /* When warning symbols are created, they **replace** the "real"
1880 entry in the hash table, thus we never get to see the real
1881 symbol in a hash traversal. So look at it now. */
1882 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1884 info
= (struct bfd_link_info
*) inf
;
1885 htab
= _bfd_sparc_elf_hash_table (info
);
1887 if (htab
->elf
.dynamic_sections_created
1888 && h
->plt
.refcount
> 0)
1890 /* Make sure this symbol is output as a dynamic symbol.
1891 Undefined weak syms won't yet be marked as dynamic. */
1892 if (h
->dynindx
== -1
1893 && !h
->forced_local
)
1895 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1899 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info
->shared
, h
))
1901 asection
*s
= htab
->splt
;
1903 /* Allocate room for the header. */
1906 s
->size
= htab
->plt_header_size
;
1908 /* Allocate space for the .rela.plt.unloaded relocations. */
1909 if (htab
->is_vxworks
&& !info
->shared
)
1910 htab
->srelplt2
->size
= sizeof (Elf32_External_Rela
) * 2;
1913 /* The procedure linkage table size is bounded by the magnitude
1914 of the offset we can describe in the entry. */
1915 if (s
->size
>= (SPARC_ELF_WORD_BYTES(htab
) == 8 ?
1916 (((bfd_vma
)1 << 31) << 1) : 0x400000))
1918 bfd_set_error (bfd_error_bad_value
);
1922 if (SPARC_ELF_WORD_BYTES(htab
) == 8
1923 && s
->size
>= PLT64_LARGE_THRESHOLD
* PLT64_ENTRY_SIZE
)
1925 bfd_vma off
= s
->size
- PLT64_LARGE_THRESHOLD
* PLT64_ENTRY_SIZE
;
1928 off
= (off
% (160 * PLT64_ENTRY_SIZE
)) / PLT64_ENTRY_SIZE
;
1930 h
->plt
.offset
= (s
->size
- (off
* 8));
1933 h
->plt
.offset
= s
->size
;
1935 /* If this symbol is not defined in a regular file, and we are
1936 not generating a shared library, then set the symbol to this
1937 location in the .plt. This is required to make function
1938 pointers compare as equal between the normal executable and
1939 the shared library. */
1943 h
->root
.u
.def
.section
= s
;
1944 h
->root
.u
.def
.value
= h
->plt
.offset
;
1947 /* Make room for this entry. */
1948 s
->size
+= htab
->plt_entry_size
;
1950 /* We also need to make an entry in the .rela.plt section. */
1951 htab
->srelplt
->size
+= SPARC_ELF_RELA_BYTES (htab
);
1953 if (htab
->is_vxworks
)
1955 /* Allocate space for the .got.plt entry. */
1956 htab
->sgotplt
->size
+= 4;
1958 /* ...and for the .rela.plt.unloaded relocations. */
1960 htab
->srelplt2
->size
+= sizeof (Elf32_External_Rela
) * 3;
1965 h
->plt
.offset
= (bfd_vma
) -1;
1971 h
->plt
.offset
= (bfd_vma
) -1;
1975 /* If R_SPARC_TLS_IE_{HI22,LO10} symbol is now local to the binary,
1976 make it a R_SPARC_TLS_LE_{HI22,LO10} requiring no TLS entry. */
1977 if (h
->got
.refcount
> 0
1980 && _bfd_sparc_elf_hash_entry(h
)->tls_type
== GOT_TLS_IE
)
1981 h
->got
.offset
= (bfd_vma
) -1;
1982 else if (h
->got
.refcount
> 0)
1986 int tls_type
= _bfd_sparc_elf_hash_entry(h
)->tls_type
;
1988 /* Make sure this symbol is output as a dynamic symbol.
1989 Undefined weak syms won't yet be marked as dynamic. */
1990 if (h
->dynindx
== -1
1991 && !h
->forced_local
)
1993 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1998 h
->got
.offset
= s
->size
;
1999 s
->size
+= SPARC_ELF_WORD_BYTES (htab
);
2000 /* R_SPARC_TLS_GD_HI{22,LO10} needs 2 consecutive GOT slots. */
2001 if (tls_type
== GOT_TLS_GD
)
2002 s
->size
+= SPARC_ELF_WORD_BYTES (htab
);
2003 dyn
= htab
->elf
.dynamic_sections_created
;
2004 /* R_SPARC_TLS_IE_{HI22,LO10} needs one dynamic relocation,
2005 R_SPARC_TLS_GD_{HI22,LO10} needs one if local symbol and two if
2007 if ((tls_type
== GOT_TLS_GD
&& h
->dynindx
== -1)
2008 || tls_type
== GOT_TLS_IE
)
2009 htab
->srelgot
->size
+= SPARC_ELF_RELA_BYTES (htab
);
2010 else if (tls_type
== GOT_TLS_GD
)
2011 htab
->srelgot
->size
+= 2 * SPARC_ELF_RELA_BYTES (htab
);
2012 else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
))
2013 htab
->srelgot
->size
+= SPARC_ELF_RELA_BYTES (htab
);
2016 h
->got
.offset
= (bfd_vma
) -1;
2018 eh
= (struct _bfd_sparc_elf_link_hash_entry
*) h
;
2019 if (eh
->dyn_relocs
== NULL
)
2022 /* In the shared -Bsymbolic case, discard space allocated for
2023 dynamic pc-relative relocs against symbols which turn out to be
2024 defined in regular objects. For the normal shared case, discard
2025 space for pc-relative relocs that have become local due to symbol
2026 visibility changes. */
2034 struct _bfd_sparc_elf_dyn_relocs
**pp
;
2036 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2038 p
->count
-= p
->pc_count
;
2047 /* Also discard relocs on undefined weak syms with non-default
2049 if (eh
->dyn_relocs
!= NULL
2050 && h
->root
.type
== bfd_link_hash_undefweak
)
2052 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
2053 eh
->dyn_relocs
= NULL
;
2055 /* Make sure undefined weak symbols are output as a dynamic
2057 else if (h
->dynindx
== -1
2058 && !h
->forced_local
)
2060 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2067 /* For the non-shared case, discard space for relocs against
2068 symbols which turn out to need copy relocs or are not
2074 || (htab
->elf
.dynamic_sections_created
2075 && (h
->root
.type
== bfd_link_hash_undefweak
2076 || h
->root
.type
== bfd_link_hash_undefined
))))
2078 /* Make sure this symbol is output as a dynamic symbol.
2079 Undefined weak syms won't yet be marked as dynamic. */
2080 if (h
->dynindx
== -1
2081 && !h
->forced_local
)
2083 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2087 /* If that succeeded, we know we'll be keeping all the
2089 if (h
->dynindx
!= -1)
2093 eh
->dyn_relocs
= NULL
;
2098 /* Finally, allocate space. */
2099 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2101 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
2102 sreloc
->size
+= p
->count
* SPARC_ELF_RELA_BYTES (htab
);
2108 /* Find any dynamic relocs that apply to read-only sections. */
2111 readonly_dynrelocs (struct elf_link_hash_entry
*h
, PTR inf
)
2113 struct _bfd_sparc_elf_link_hash_entry
*eh
;
2114 struct _bfd_sparc_elf_dyn_relocs
*p
;
2116 if (h
->root
.type
== bfd_link_hash_warning
)
2117 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2119 eh
= (struct _bfd_sparc_elf_link_hash_entry
*) h
;
2120 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2122 asection
*s
= p
->sec
->output_section
;
2124 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2126 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
2128 info
->flags
|= DF_TEXTREL
;
2130 /* Not an error, just cut short the traversal. */
2137 /* Return true if the dynamic symbol for a given section should be
2138 omitted when creating a shared library. */
2141 _bfd_sparc_elf_omit_section_dynsym (bfd
*output_bfd
,
2142 struct bfd_link_info
*info
,
2145 /* We keep the .got section symbol so that explicit relocations
2146 against the _GLOBAL_OFFSET_TABLE_ symbol emitted in PIC mode
2147 can be turned into relocations against the .got symbol. */
2148 if (strcmp (p
->name
, ".got") == 0)
2151 return _bfd_elf_link_omit_section_dynsym (output_bfd
, info
, p
);
2154 /* Set the sizes of the dynamic sections. */
2157 _bfd_sparc_elf_size_dynamic_sections (bfd
*output_bfd
,
2158 struct bfd_link_info
*info
)
2160 struct _bfd_sparc_elf_link_hash_table
*htab
;
2165 htab
= _bfd_sparc_elf_hash_table (info
);
2166 dynobj
= htab
->elf
.dynobj
;
2167 BFD_ASSERT (dynobj
!= NULL
);
2169 if (elf_hash_table (info
)->dynamic_sections_created
)
2171 /* Set the contents of the .interp section to the interpreter. */
2172 if (info
->executable
)
2174 s
= bfd_get_section_by_name (dynobj
, ".interp");
2175 BFD_ASSERT (s
!= NULL
);
2176 s
->size
= htab
->dynamic_interpreter_size
;
2177 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
2181 /* Set up .got offsets for local syms, and space for local dynamic
2183 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
2185 bfd_signed_vma
*local_got
;
2186 bfd_signed_vma
*end_local_got
;
2187 char *local_tls_type
;
2188 bfd_size_type locsymcount
;
2189 Elf_Internal_Shdr
*symtab_hdr
;
2192 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
2195 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2197 struct _bfd_sparc_elf_dyn_relocs
*p
;
2199 for (p
= elf_section_data (s
)->local_dynrel
; p
!= NULL
; p
= p
->next
)
2201 if (!bfd_is_abs_section (p
->sec
)
2202 && bfd_is_abs_section (p
->sec
->output_section
))
2204 /* Input section has been discarded, either because
2205 it is a copy of a linkonce section or due to
2206 linker script /DISCARD/, so we'll be discarding
2209 else if (p
->count
!= 0)
2211 srel
= elf_section_data (p
->sec
)->sreloc
;
2212 srel
->size
+= p
->count
* SPARC_ELF_RELA_BYTES (htab
);
2213 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
2214 info
->flags
|= DF_TEXTREL
;
2219 local_got
= elf_local_got_refcounts (ibfd
);
2223 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
2224 locsymcount
= symtab_hdr
->sh_info
;
2225 end_local_got
= local_got
+ locsymcount
;
2226 local_tls_type
= _bfd_sparc_elf_local_got_tls_type (ibfd
);
2228 srel
= htab
->srelgot
;
2229 for (; local_got
< end_local_got
; ++local_got
, ++local_tls_type
)
2233 *local_got
= s
->size
;
2234 s
->size
+= SPARC_ELF_WORD_BYTES (htab
);
2235 if (*local_tls_type
== GOT_TLS_GD
)
2236 s
->size
+= SPARC_ELF_WORD_BYTES (htab
);
2238 || *local_tls_type
== GOT_TLS_GD
2239 || *local_tls_type
== GOT_TLS_IE
)
2240 srel
->size
+= SPARC_ELF_RELA_BYTES (htab
);
2243 *local_got
= (bfd_vma
) -1;
2247 if (htab
->tls_ldm_got
.refcount
> 0)
2249 /* Allocate 2 got entries and 1 dynamic reloc for
2250 R_SPARC_TLS_LDM_{HI22,LO10} relocs. */
2251 htab
->tls_ldm_got
.offset
= htab
->sgot
->size
;
2252 htab
->sgot
->size
+= (2 * SPARC_ELF_WORD_BYTES (htab
));
2253 htab
->srelgot
->size
+= SPARC_ELF_RELA_BYTES (htab
);
2256 htab
->tls_ldm_got
.offset
= -1;
2258 /* Allocate global sym .plt and .got entries, and space for global
2259 sym dynamic relocs. */
2260 elf_link_hash_traverse (&htab
->elf
, allocate_dynrelocs
, (PTR
) info
);
2262 if (! ABI_64_P (output_bfd
)
2263 && !htab
->is_vxworks
2264 && elf_hash_table (info
)->dynamic_sections_created
)
2266 /* Make space for the trailing nop in .plt. */
2267 if (htab
->splt
->size
> 0)
2268 htab
->splt
->size
+= 1 * SPARC_INSN_BYTES
;
2270 /* If the .got section is more than 0x1000 bytes, we add
2271 0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13
2272 bit relocations have a greater chance of working.
2274 FIXME: Make this optimization work for 64-bit too. */
2275 if (htab
->sgot
->size
>= 0x1000
2276 && elf_hash_table (info
)->hgot
->root
.u
.def
.value
== 0)
2277 elf_hash_table (info
)->hgot
->root
.u
.def
.value
= 0x1000;
2280 /* The check_relocs and adjust_dynamic_symbol entry points have
2281 determined the sizes of the various dynamic sections. Allocate
2283 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2285 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2290 || s
== htab
->sdynbss
2291 || s
== htab
->sgotplt
)
2293 /* Strip this section if we don't need it; see the
2296 else if (CONST_STRNEQ (s
->name
, ".rela"))
2300 /* We use the reloc_count field as a counter if we need
2301 to copy relocs into the output file. */
2307 /* It's not one of our sections. */
2313 /* If we don't need this section, strip it from the
2314 output file. This is mostly to handle .rela.bss and
2315 .rela.plt. We must create both sections in
2316 create_dynamic_sections, because they must be created
2317 before the linker maps input sections to output
2318 sections. The linker does that before
2319 adjust_dynamic_symbol is called, and it is that
2320 function which decides whether anything needs to go
2321 into these sections. */
2322 s
->flags
|= SEC_EXCLUDE
;
2326 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
2329 /* Allocate memory for the section contents. Zero the memory
2330 for the benefit of .rela.plt, which has 4 unused entries
2331 at the beginning, and we don't want garbage. */
2332 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
2333 if (s
->contents
== NULL
)
2337 if (elf_hash_table (info
)->dynamic_sections_created
)
2339 /* Add some entries to the .dynamic section. We fill in the
2340 values later, in _bfd_sparc_elf_finish_dynamic_sections, but we
2341 must add the entries now so that we get the correct size for
2342 the .dynamic section. The DT_DEBUG entry is filled in by the
2343 dynamic linker and used by the debugger. */
2344 #define add_dynamic_entry(TAG, VAL) \
2345 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2347 if (info
->executable
)
2349 if (!add_dynamic_entry (DT_DEBUG
, 0))
2353 if (htab
->srelplt
->size
!= 0)
2355 if (!add_dynamic_entry (DT_PLTGOT
, 0)
2356 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
2357 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
2358 || !add_dynamic_entry (DT_JMPREL
, 0))
2362 if (!add_dynamic_entry (DT_RELA
, 0)
2363 || !add_dynamic_entry (DT_RELASZ
, 0)
2364 || !add_dynamic_entry (DT_RELAENT
,
2365 SPARC_ELF_RELA_BYTES (htab
)))
2368 /* If any dynamic relocs apply to a read-only section,
2369 then we need a DT_TEXTREL entry. */
2370 if ((info
->flags
& DF_TEXTREL
) == 0)
2371 elf_link_hash_traverse (&htab
->elf
, readonly_dynrelocs
,
2374 if (info
->flags
& DF_TEXTREL
)
2376 if (!add_dynamic_entry (DT_TEXTREL
, 0))
2380 if (ABI_64_P (output_bfd
))
2383 struct _bfd_sparc_elf_app_reg
* app_regs
;
2384 struct elf_strtab_hash
*dynstr
;
2385 struct elf_link_hash_table
*eht
= elf_hash_table (info
);
2387 /* Add dynamic STT_REGISTER symbols and corresponding DT_SPARC_REGISTER
2388 entries if needed. */
2389 app_regs
= _bfd_sparc_elf_hash_table (info
)->app_regs
;
2390 dynstr
= eht
->dynstr
;
2392 for (reg
= 0; reg
< 4; reg
++)
2393 if (app_regs
[reg
].name
!= NULL
)
2395 struct elf_link_local_dynamic_entry
*entry
, *e
;
2397 if (!add_dynamic_entry (DT_SPARC_REGISTER
, 0))
2400 entry
= (struct elf_link_local_dynamic_entry
*)
2401 bfd_hash_allocate (&info
->hash
->table
, sizeof (*entry
));
2405 /* We cheat here a little bit: the symbol will not be local, so we
2406 put it at the end of the dynlocal linked list. We will fix it
2407 later on, as we have to fix other fields anyway. */
2408 entry
->isym
.st_value
= reg
< 2 ? reg
+ 2 : reg
+ 4;
2409 entry
->isym
.st_size
= 0;
2410 if (*app_regs
[reg
].name
!= '\0')
2412 = _bfd_elf_strtab_add (dynstr
, app_regs
[reg
].name
, FALSE
);
2414 entry
->isym
.st_name
= 0;
2415 entry
->isym
.st_other
= 0;
2416 entry
->isym
.st_info
= ELF_ST_INFO (app_regs
[reg
].bind
,
2418 entry
->isym
.st_shndx
= app_regs
[reg
].shndx
;
2420 entry
->input_bfd
= output_bfd
;
2421 entry
->input_indx
= -1;
2423 if (eht
->dynlocal
== NULL
)
2424 eht
->dynlocal
= entry
;
2427 for (e
= eht
->dynlocal
; e
->next
; e
= e
->next
)
2435 #undef add_dynamic_entry
2441 _bfd_sparc_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
2443 if (!sec
->used_by_bfd
)
2445 struct _bfd_sparc_elf_section_data
*sdata
;
2446 bfd_size_type amt
= sizeof (*sdata
);
2448 sdata
= bfd_zalloc (abfd
, amt
);
2451 sec
->used_by_bfd
= sdata
;
2454 return _bfd_elf_new_section_hook (abfd
, sec
);
2458 _bfd_sparc_elf_relax_section (bfd
*abfd ATTRIBUTE_UNUSED
,
2459 struct bfd_section
*section
,
2460 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
,
2464 sec_do_relax (section
) = 1;
2468 /* Return the base VMA address which should be subtracted from real addresses
2469 when resolving @dtpoff relocation.
2470 This is PT_TLS segment p_vaddr. */
2473 dtpoff_base (struct bfd_link_info
*info
)
2475 /* If tls_sec is NULL, we should have signalled an error already. */
2476 if (elf_hash_table (info
)->tls_sec
== NULL
)
2478 return elf_hash_table (info
)->tls_sec
->vma
;
2481 /* Return the relocation value for @tpoff relocation
2482 if STT_TLS virtual address is ADDRESS. */
2485 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
2487 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2489 /* If tls_sec is NULL, we should have signalled an error already. */
2490 if (htab
->tls_sec
== NULL
)
2492 return address
- htab
->tls_size
- htab
->tls_sec
->vma
;
2495 /* Relocate a SPARC ELF section. */
2498 _bfd_sparc_elf_relocate_section (bfd
*output_bfd
,
2499 struct bfd_link_info
*info
,
2501 asection
*input_section
,
2503 Elf_Internal_Rela
*relocs
,
2504 Elf_Internal_Sym
*local_syms
,
2505 asection
**local_sections
)
2507 struct _bfd_sparc_elf_link_hash_table
*htab
;
2508 Elf_Internal_Shdr
*symtab_hdr
;
2509 struct elf_link_hash_entry
**sym_hashes
;
2510 bfd_vma
*local_got_offsets
;
2513 Elf_Internal_Rela
*rel
;
2514 Elf_Internal_Rela
*relend
;
2517 htab
= _bfd_sparc_elf_hash_table (info
);
2518 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2519 sym_hashes
= elf_sym_hashes (input_bfd
);
2520 local_got_offsets
= elf_local_got_offsets (input_bfd
);
2522 if (elf_hash_table (info
)->hgot
== NULL
)
2525 got_base
= elf_hash_table (info
)->hgot
->root
.u
.def
.value
;
2527 sreloc
= elf_section_data (input_section
)->sreloc
;
2530 if (ABI_64_P (output_bfd
))
2531 num_relocs
= NUM_SHDR_ENTRIES (& elf_section_data (input_section
)->rel_hdr
);
2533 num_relocs
= input_section
->reloc_count
;
2534 relend
= relocs
+ num_relocs
;
2535 for (; rel
< relend
; rel
++)
2537 int r_type
, tls_type
;
2538 reloc_howto_type
*howto
;
2539 unsigned long r_symndx
;
2540 struct elf_link_hash_entry
*h
;
2541 Elf_Internal_Sym
*sym
;
2543 bfd_vma relocation
, off
;
2544 bfd_reloc_status_type r
;
2545 bfd_boolean is_plt
= FALSE
;
2546 bfd_boolean unresolved_reloc
;
2548 r_type
= SPARC_ELF_R_TYPE (rel
->r_info
);
2549 if (r_type
== R_SPARC_GNU_VTINHERIT
2550 || r_type
== R_SPARC_GNU_VTENTRY
)
2553 if (r_type
< 0 || r_type
>= (int) R_SPARC_max_std
)
2555 bfd_set_error (bfd_error_bad_value
);
2558 howto
= _bfd_sparc_elf_howto_table
+ r_type
;
2560 r_symndx
= SPARC_ELF_R_SYMNDX (htab
, rel
->r_info
);
2564 unresolved_reloc
= FALSE
;
2565 if (r_symndx
< symtab_hdr
->sh_info
)
2567 sym
= local_syms
+ r_symndx
;
2568 sec
= local_sections
[r_symndx
];
2569 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
2575 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2576 r_symndx
, symtab_hdr
, sym_hashes
,
2578 unresolved_reloc
, warned
);
2581 /* To avoid generating warning messages about truncated
2582 relocations, set the relocation's address to be the same as
2583 the start of this section. */
2584 if (input_section
->output_section
!= NULL
)
2585 relocation
= input_section
->output_section
->vma
;
2591 if (sec
!= NULL
&& elf_discarded_section (sec
))
2593 /* For relocs against symbols from removed linkonce
2594 sections, or sections discarded by a linker script, we
2595 just want the section contents zeroed. Avoid any
2596 special processing. */
2597 _bfd_clear_contents (howto
, input_bfd
, contents
+ rel
->r_offset
);
2603 if (info
->relocatable
)
2611 /* Relocation is to the entry for this symbol in the global
2613 if (htab
->sgot
== NULL
)
2620 off
= h
->got
.offset
;
2621 BFD_ASSERT (off
!= (bfd_vma
) -1);
2622 dyn
= elf_hash_table (info
)->dynamic_sections_created
;
2624 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
2631 /* This is actually a static link, or it is a
2632 -Bsymbolic link and the symbol is defined
2633 locally, or the symbol was forced to be local
2634 because of a version file. We must initialize
2635 this entry in the global offset table. Since the
2636 offset must always be a multiple of 8 for 64-bit
2637 and 4 for 32-bit, we use the least significant bit
2638 to record whether we have initialized it already.
2640 When doing a dynamic link, we create a .rela.got
2641 relocation entry to initialize the value. This
2642 is done in the finish_dynamic_symbol routine. */
2647 SPARC_ELF_PUT_WORD (htab
, output_bfd
, relocation
,
2648 htab
->sgot
->contents
+ off
);
2653 unresolved_reloc
= FALSE
;
2657 BFD_ASSERT (local_got_offsets
!= NULL
2658 && local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
2660 off
= local_got_offsets
[r_symndx
];
2662 /* The offset must always be a multiple of 8 on 64-bit and
2663 4 on 32-bit. We use the least significant bit to record
2664 whether we have already processed this entry. */
2673 Elf_Internal_Rela outrel
;
2675 /* We need to generate a R_SPARC_RELATIVE reloc
2676 for the dynamic linker. */
2678 BFD_ASSERT (s
!= NULL
);
2680 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
2681 + htab
->sgot
->output_offset
2683 outrel
.r_info
= SPARC_ELF_R_INFO (htab
, NULL
,
2684 0, R_SPARC_RELATIVE
);
2685 outrel
.r_addend
= relocation
;
2687 SPARC_ELF_APPEND_RELA (htab
, output_bfd
, s
, &outrel
);
2690 SPARC_ELF_PUT_WORD (htab
, output_bfd
, relocation
,
2691 htab
->sgot
->contents
+ off
);
2692 local_got_offsets
[r_symndx
] |= 1;
2695 relocation
= htab
->sgot
->output_offset
+ off
- got_base
;
2700 if (h
== NULL
|| h
->plt
.offset
== (bfd_vma
) -1)
2702 r_type
= (r_type
== R_SPARC_PLT32
) ? R_SPARC_32
: R_SPARC_64
;
2707 case R_SPARC_WPLT30
:
2708 case R_SPARC_HIPLT22
:
2709 case R_SPARC_LOPLT10
:
2710 case R_SPARC_PCPLT32
:
2711 case R_SPARC_PCPLT22
:
2712 case R_SPARC_PCPLT10
:
2714 /* Relocation is to the entry for this symbol in the
2715 procedure linkage table. */
2717 if (! ABI_64_P (output_bfd
))
2719 /* The Solaris native assembler will generate a WPLT30 reloc
2720 for a local symbol if you assemble a call from one
2721 section to another when using -K pic. We treat it as
2728 BFD_ASSERT (h
!= NULL
);
2731 if (h
->plt
.offset
== (bfd_vma
) -1 || htab
->splt
== NULL
)
2733 /* We didn't make a PLT entry for this symbol. This
2734 happens when statically linking PIC code, or when
2735 using -Bsymbolic. */
2739 relocation
= (htab
->splt
->output_section
->vma
2740 + htab
->splt
->output_offset
2742 unresolved_reloc
= FALSE
;
2743 if (r_type
== R_SPARC_PLT32
|| r_type
== R_SPARC_PLT64
)
2745 r_type
= r_type
== R_SPARC_PLT32
? R_SPARC_32
: R_SPARC_64
;
2753 case R_SPARC_PC_HH22
:
2754 case R_SPARC_PC_HM10
:
2755 case R_SPARC_PC_LM22
:
2757 && strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
2761 case R_SPARC_DISP16
:
2762 case R_SPARC_DISP32
:
2763 case R_SPARC_DISP64
:
2764 case R_SPARC_WDISP30
:
2765 case R_SPARC_WDISP22
:
2766 case R_SPARC_WDISP19
:
2767 case R_SPARC_WDISP16
:
2794 if ((input_section
->flags
& SEC_ALLOC
) == 0)
2799 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2800 || h
->root
.type
!= bfd_link_hash_undefweak
)
2801 && (! howto
->pc_relative
2804 && (! info
->symbolic
2805 || !h
->def_regular
))))
2812 || h
->root
.type
== bfd_link_hash_undefweak
2813 || h
->root
.type
== bfd_link_hash_undefined
)))
2815 Elf_Internal_Rela outrel
;
2816 bfd_boolean skip
, relocate
= FALSE
;
2818 /* When generating a shared object, these relocations
2819 are copied into the output file to be resolved at run
2822 BFD_ASSERT (sreloc
!= NULL
);
2827 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2829 if (outrel
.r_offset
== (bfd_vma
) -1)
2831 else if (outrel
.r_offset
== (bfd_vma
) -2)
2832 skip
= TRUE
, relocate
= TRUE
;
2833 outrel
.r_offset
+= (input_section
->output_section
->vma
2834 + input_section
->output_offset
);
2836 /* Optimize unaligned reloc usage now that we know where
2837 it finally resides. */
2841 if (outrel
.r_offset
& 1)
2842 r_type
= R_SPARC_UA16
;
2845 if (!(outrel
.r_offset
& 1))
2846 r_type
= R_SPARC_16
;
2849 if (outrel
.r_offset
& 3)
2850 r_type
= R_SPARC_UA32
;
2853 if (!(outrel
.r_offset
& 3))
2854 r_type
= R_SPARC_32
;
2857 if (outrel
.r_offset
& 7)
2858 r_type
= R_SPARC_UA64
;
2861 if (!(outrel
.r_offset
& 7))
2862 r_type
= R_SPARC_64
;
2865 case R_SPARC_DISP16
:
2866 case R_SPARC_DISP32
:
2867 case R_SPARC_DISP64
:
2868 /* If the symbol is not dynamic, we should not keep
2869 a dynamic relocation. But an .rela.* slot has been
2870 allocated for it, output R_SPARC_NONE.
2871 FIXME: Add code tracking needed dynamic relocs as
2873 if (h
->dynindx
== -1)
2874 skip
= TRUE
, relocate
= TRUE
;
2879 memset (&outrel
, 0, sizeof outrel
);
2880 /* h->dynindx may be -1 if the symbol was marked to
2882 else if (h
!= NULL
&& ! is_plt
2883 && ((! info
->symbolic
&& h
->dynindx
!= -1)
2884 || !h
->def_regular
))
2886 BFD_ASSERT (h
->dynindx
!= -1);
2887 outrel
.r_info
= SPARC_ELF_R_INFO (htab
, rel
, h
->dynindx
, r_type
);
2888 outrel
.r_addend
= rel
->r_addend
;
2892 if (r_type
== R_SPARC_32
|| r_type
== R_SPARC_64
)
2894 outrel
.r_info
= SPARC_ELF_R_INFO (htab
, NULL
,
2895 0, R_SPARC_RELATIVE
);
2896 outrel
.r_addend
= relocation
+ rel
->r_addend
;
2902 outrel
.r_addend
= relocation
+ rel
->r_addend
;
2907 if (bfd_is_abs_section (sec
))
2909 else if (sec
== NULL
|| sec
->owner
== NULL
)
2911 bfd_set_error (bfd_error_bad_value
);
2918 /* We are turning this relocation into one
2919 against a section symbol. It would be
2920 proper to subtract the symbol's value,
2921 osec->vma, from the emitted reloc addend,
2922 but ld.so expects buggy relocs. */
2923 osec
= sec
->output_section
;
2924 indx
= elf_section_data (osec
)->dynindx
;
2928 osec
= htab
->elf
.text_index_section
;
2929 indx
= elf_section_data (osec
)->dynindx
;
2932 /* FIXME: we really should be able to link non-pic
2933 shared libraries. */
2937 (*_bfd_error_handler
)
2938 (_("%B: probably compiled without -fPIC?"),
2940 bfd_set_error (bfd_error_bad_value
);
2945 outrel
.r_info
= SPARC_ELF_R_INFO (htab
, rel
, indx
,
2950 SPARC_ELF_APPEND_RELA (htab
, output_bfd
, sreloc
, &outrel
);
2952 /* This reloc will be computed at runtime, so there's no
2953 need to do anything now. */
2959 case R_SPARC_TLS_GD_HI22
:
2960 if (! ABI_64_P (input_bfd
)
2961 && ! _bfd_sparc_elf_tdata (input_bfd
)->has_tlsgd
)
2963 /* R_SPARC_REV32 used the same reloc number as
2964 R_SPARC_TLS_GD_HI22. */
2965 r_type
= R_SPARC_REV32
;
2970 case R_SPARC_TLS_GD_LO10
:
2971 case R_SPARC_TLS_IE_HI22
:
2972 case R_SPARC_TLS_IE_LO10
:
2973 r_type
= sparc_elf_tls_transition (info
, input_bfd
, r_type
, h
== NULL
);
2974 tls_type
= GOT_UNKNOWN
;
2975 if (h
== NULL
&& local_got_offsets
)
2976 tls_type
= _bfd_sparc_elf_local_got_tls_type (input_bfd
) [r_symndx
];
2979 tls_type
= _bfd_sparc_elf_hash_entry(h
)->tls_type
;
2980 if (!info
->shared
&& h
->dynindx
== -1 && tls_type
== GOT_TLS_IE
)
2981 switch (SPARC_ELF_R_TYPE (rel
->r_info
))
2983 case R_SPARC_TLS_GD_HI22
:
2984 case R_SPARC_TLS_IE_HI22
:
2985 r_type
= R_SPARC_TLS_LE_HIX22
;
2988 r_type
= R_SPARC_TLS_LE_LOX10
;
2992 if (tls_type
== GOT_TLS_IE
)
2995 case R_SPARC_TLS_GD_HI22
:
2996 r_type
= R_SPARC_TLS_IE_HI22
;
2998 case R_SPARC_TLS_GD_LO10
:
2999 r_type
= R_SPARC_TLS_IE_LO10
;
3003 if (r_type
== R_SPARC_TLS_LE_HIX22
)
3005 relocation
= tpoff (info
, relocation
);
3008 if (r_type
== R_SPARC_TLS_LE_LOX10
)
3010 /* Change add into xor. */
3011 relocation
= tpoff (info
, relocation
);
3012 bfd_put_32 (output_bfd
, (bfd_get_32 (input_bfd
,
3013 contents
+ rel
->r_offset
)
3014 | 0x80182000), contents
+ rel
->r_offset
);
3020 off
= h
->got
.offset
;
3025 BFD_ASSERT (local_got_offsets
!= NULL
);
3026 off
= local_got_offsets
[r_symndx
];
3027 local_got_offsets
[r_symndx
] |= 1;
3031 if (htab
->sgot
== NULL
)
3038 Elf_Internal_Rela outrel
;
3041 if (htab
->srelgot
== NULL
)
3044 SPARC_ELF_PUT_WORD (htab
, output_bfd
, 0, htab
->sgot
->contents
+ off
);
3045 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
3046 + htab
->sgot
->output_offset
+ off
);
3047 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
3048 if (r_type
== R_SPARC_TLS_IE_HI22
3049 || r_type
== R_SPARC_TLS_IE_LO10
)
3050 dr_type
= SPARC_ELF_TPOFF_RELOC (htab
);
3052 dr_type
= SPARC_ELF_DTPMOD_RELOC (htab
);
3053 if (dr_type
== SPARC_ELF_TPOFF_RELOC (htab
) && indx
== 0)
3054 outrel
.r_addend
= relocation
- dtpoff_base (info
);
3056 outrel
.r_addend
= 0;
3057 outrel
.r_info
= SPARC_ELF_R_INFO (htab
, NULL
, indx
, dr_type
);
3058 SPARC_ELF_APPEND_RELA (htab
, output_bfd
, htab
->srelgot
, &outrel
);
3060 if (r_type
== R_SPARC_TLS_GD_HI22
3061 || r_type
== R_SPARC_TLS_GD_LO10
)
3065 BFD_ASSERT (! unresolved_reloc
);
3066 SPARC_ELF_PUT_WORD (htab
, output_bfd
,
3067 relocation
- dtpoff_base (info
),
3068 (htab
->sgot
->contents
+ off
3069 + SPARC_ELF_WORD_BYTES (htab
)));
3073 SPARC_ELF_PUT_WORD (htab
, output_bfd
, 0,
3074 (htab
->sgot
->contents
+ off
3075 + SPARC_ELF_WORD_BYTES (htab
)));
3076 outrel
.r_info
= SPARC_ELF_R_INFO (htab
, NULL
, indx
,
3077 SPARC_ELF_DTPOFF_RELOC (htab
));
3078 outrel
.r_offset
+= SPARC_ELF_WORD_BYTES (htab
);
3079 SPARC_ELF_APPEND_RELA (htab
, output_bfd
, htab
->srelgot
, &outrel
);
3082 else if (dr_type
== SPARC_ELF_DTPMOD_RELOC (htab
))
3084 SPARC_ELF_PUT_WORD (htab
, output_bfd
, 0,
3085 (htab
->sgot
->contents
+ off
3086 + SPARC_ELF_WORD_BYTES (htab
)));
3090 if (off
>= (bfd_vma
) -2)
3093 relocation
= htab
->sgot
->output_offset
+ off
- got_base
;
3094 unresolved_reloc
= FALSE
;
3095 howto
= _bfd_sparc_elf_howto_table
+ r_type
;
3098 case R_SPARC_TLS_LDM_HI22
:
3099 case R_SPARC_TLS_LDM_LO10
:
3102 bfd_put_32 (output_bfd
, SPARC_NOP
, contents
+ rel
->r_offset
);
3105 off
= htab
->tls_ldm_got
.offset
;
3106 htab
->tls_ldm_got
.offset
|= 1;
3107 goto r_sparc_tlsldm
;
3109 case R_SPARC_TLS_LDO_HIX22
:
3110 case R_SPARC_TLS_LDO_LOX10
:
3113 relocation
-= dtpoff_base (info
);
3117 r_type
= (r_type
== R_SPARC_TLS_LDO_HIX22
3118 ? R_SPARC_TLS_LE_HIX22
: R_SPARC_TLS_LE_LOX10
);
3121 case R_SPARC_TLS_LE_HIX22
:
3122 case R_SPARC_TLS_LE_LOX10
:
3125 Elf_Internal_Rela outrel
;
3126 bfd_boolean skip
, relocate
= FALSE
;
3128 BFD_ASSERT (sreloc
!= NULL
);
3131 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
3133 if (outrel
.r_offset
== (bfd_vma
) -1)
3135 else if (outrel
.r_offset
== (bfd_vma
) -2)
3136 skip
= TRUE
, relocate
= TRUE
;
3137 outrel
.r_offset
+= (input_section
->output_section
->vma
3138 + input_section
->output_offset
);
3140 memset (&outrel
, 0, sizeof outrel
);
3143 outrel
.r_info
= SPARC_ELF_R_INFO (htab
, NULL
, 0, r_type
);
3144 outrel
.r_addend
= relocation
- dtpoff_base (info
)
3148 SPARC_ELF_APPEND_RELA (htab
, output_bfd
, sreloc
, &outrel
);
3151 relocation
= tpoff (info
, relocation
);
3154 case R_SPARC_TLS_LDM_CALL
:
3158 bfd_put_32 (output_bfd
, 0x90100000, contents
+ rel
->r_offset
);
3163 case R_SPARC_TLS_GD_CALL
:
3164 tls_type
= GOT_UNKNOWN
;
3165 if (h
== NULL
&& local_got_offsets
)
3166 tls_type
= _bfd_sparc_elf_local_got_tls_type (input_bfd
) [r_symndx
];
3168 tls_type
= _bfd_sparc_elf_hash_entry(h
)->tls_type
;
3170 || (r_type
== R_SPARC_TLS_GD_CALL
&& tls_type
== GOT_TLS_IE
))
3174 if (!info
->shared
&& (h
== NULL
|| h
->dynindx
== -1))
3177 bfd_put_32 (output_bfd
, SPARC_NOP
, contents
+ rel
->r_offset
);
3182 if (rel
+ 1 < relend
3183 && SPARC_ELF_R_TYPE (rel
[1].r_info
) == R_SPARC_TLS_GD_ADD
3184 && rel
[1].r_offset
== rel
->r_offset
+ 4
3185 && SPARC_ELF_R_SYMNDX (htab
, rel
[1].r_info
) == r_symndx
3186 && (((insn
= bfd_get_32 (input_bfd
,
3187 contents
+ rel
[1].r_offset
))
3188 >> 25) & 0x1f) == 8)
3191 call __tls_get_addr, %tgd_call(foo)
3192 add %reg1, %reg2, %o0, %tgd_add(foo)
3193 and change it into IE:
3194 {ld,ldx} [%reg1 + %reg2], %o0, %tie_ldx(foo)
3195 add %g7, %o0, %o0, %tie_add(foo).
3196 add is 0x80000000 | (rd << 25) | (rs1 << 14) | rs2,
3197 ld is 0xc0000000 | (rd << 25) | (rs1 << 14) | rs2,
3198 ldx is 0xc0580000 | (rd << 25) | (rs1 << 14) | rs2. */
3199 bfd_put_32 (output_bfd
, insn
| (ABI_64_P (output_bfd
) ? 0xc0580000 : 0xc0000000),
3200 contents
+ rel
->r_offset
);
3201 bfd_put_32 (output_bfd
, 0x9001c008,
3202 contents
+ rel
->r_offset
+ 4);
3207 bfd_put_32 (output_bfd
, 0x9001c008, contents
+ rel
->r_offset
);
3211 h
= (struct elf_link_hash_entry
*)
3212 bfd_link_hash_lookup (info
->hash
, "__tls_get_addr", FALSE
,
3214 BFD_ASSERT (h
!= NULL
);
3215 r_type
= R_SPARC_WPLT30
;
3216 howto
= _bfd_sparc_elf_howto_table
+ r_type
;
3217 goto r_sparc_wplt30
;
3219 case R_SPARC_TLS_GD_ADD
:
3220 tls_type
= GOT_UNKNOWN
;
3221 if (h
== NULL
&& local_got_offsets
)
3222 tls_type
= _bfd_sparc_elf_local_got_tls_type (input_bfd
) [r_symndx
];
3224 tls_type
= _bfd_sparc_elf_hash_entry(h
)->tls_type
;
3225 if (! info
->shared
|| tls_type
== GOT_TLS_IE
)
3227 /* add %reg1, %reg2, %reg3, %tgd_add(foo)
3229 {ld,ldx} [%reg1 + %reg2], %reg3, %tie_ldx(foo)
3231 add %g7, %reg2, %reg3. */
3232 bfd_vma insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3233 if ((h
!= NULL
&& h
->dynindx
!= -1) || info
->shared
)
3234 relocation
= insn
| (ABI_64_P (output_bfd
) ? 0xc0580000 : 0xc0000000);
3236 relocation
= (insn
& ~0x7c000) | 0x1c000;
3237 bfd_put_32 (output_bfd
, relocation
, contents
+ rel
->r_offset
);
3241 case R_SPARC_TLS_LDM_ADD
:
3243 bfd_put_32 (output_bfd
, SPARC_NOP
, contents
+ rel
->r_offset
);
3246 case R_SPARC_TLS_LDO_ADD
:
3249 /* Change rs1 into %g7. */
3250 bfd_vma insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3251 insn
= (insn
& ~0x7c000) | 0x1c000;
3252 bfd_put_32 (output_bfd
, insn
, contents
+ rel
->r_offset
);
3256 case R_SPARC_TLS_IE_LD
:
3257 case R_SPARC_TLS_IE_LDX
:
3258 if (! info
->shared
&& (h
== NULL
|| h
->dynindx
== -1))
3260 bfd_vma insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3261 int rs2
= insn
& 0x1f;
3262 int rd
= (insn
>> 25) & 0x1f;
3265 relocation
= SPARC_NOP
;
3267 relocation
= 0x80100000 | (insn
& 0x3e00001f);
3268 bfd_put_32 (output_bfd
, relocation
, contents
+ rel
->r_offset
);
3272 case R_SPARC_TLS_IE_ADD
:
3273 /* Totally useless relocation. */
3276 case R_SPARC_TLS_DTPOFF32
:
3277 case R_SPARC_TLS_DTPOFF64
:
3278 relocation
-= dtpoff_base (info
);
3285 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3286 because such sections are not SEC_ALLOC and thus ld.so will
3287 not process them. */
3288 if (unresolved_reloc
3289 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
3291 (*_bfd_error_handler
)
3292 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3295 (long) rel
->r_offset
,
3297 h
->root
.root
.string
);
3299 r
= bfd_reloc_continue
;
3300 if (r_type
== R_SPARC_OLO10
)
3304 if (! ABI_64_P (output_bfd
))
3307 relocation
+= rel
->r_addend
;
3308 relocation
= (relocation
& 0x3ff) + ELF64_R_TYPE_DATA (rel
->r_info
);
3310 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3311 x
= (x
& ~(bfd_vma
) 0x1fff) | (relocation
& 0x1fff);
3312 bfd_put_32 (input_bfd
, x
, contents
+ rel
->r_offset
);
3314 r
= bfd_check_overflow (howto
->complain_on_overflow
,
3315 howto
->bitsize
, howto
->rightshift
,
3316 bfd_arch_bits_per_address (input_bfd
),
3319 else if (r_type
== R_SPARC_WDISP16
)
3323 relocation
+= rel
->r_addend
;
3324 relocation
-= (input_section
->output_section
->vma
3325 + input_section
->output_offset
);
3326 relocation
-= rel
->r_offset
;
3328 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3329 x
|= ((((relocation
>> 2) & 0xc000) << 6)
3330 | ((relocation
>> 2) & 0x3fff));
3331 bfd_put_32 (input_bfd
, x
, contents
+ rel
->r_offset
);
3333 r
= bfd_check_overflow (howto
->complain_on_overflow
,
3334 howto
->bitsize
, howto
->rightshift
,
3335 bfd_arch_bits_per_address (input_bfd
),
3338 else if (r_type
== R_SPARC_REV32
)
3342 relocation
= relocation
+ rel
->r_addend
;
3344 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3346 bfd_putl32 (/*input_bfd,*/ x
, contents
+ rel
->r_offset
);
3349 else if (r_type
== R_SPARC_TLS_LDO_HIX22
3350 || r_type
== R_SPARC_TLS_LE_HIX22
)
3354 relocation
+= rel
->r_addend
;
3355 if (r_type
== R_SPARC_TLS_LE_HIX22
)
3356 relocation
^= MINUS_ONE
;
3358 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3359 x
= (x
& ~(bfd_vma
) 0x3fffff) | ((relocation
>> 10) & 0x3fffff);
3360 bfd_put_32 (input_bfd
, x
, contents
+ rel
->r_offset
);
3363 else if (r_type
== R_SPARC_TLS_LDO_LOX10
3364 || r_type
== R_SPARC_TLS_LE_LOX10
)
3368 relocation
+= rel
->r_addend
;
3369 relocation
&= 0x3ff;
3370 if (r_type
== R_SPARC_TLS_LE_LOX10
)
3371 relocation
|= 0x1c00;
3373 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3374 x
= (x
& ~(bfd_vma
) 0x1fff) | relocation
;
3375 bfd_put_32 (input_bfd
, x
, contents
+ rel
->r_offset
);
3379 else if (r_type
== R_SPARC_HIX22
)
3383 relocation
+= rel
->r_addend
;
3384 relocation
= relocation
^ MINUS_ONE
;
3386 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3387 x
= (x
& ~(bfd_vma
) 0x3fffff) | ((relocation
>> 10) & 0x3fffff);
3388 bfd_put_32 (input_bfd
, x
, contents
+ rel
->r_offset
);
3390 r
= bfd_check_overflow (howto
->complain_on_overflow
,
3391 howto
->bitsize
, howto
->rightshift
,
3392 bfd_arch_bits_per_address (input_bfd
),
3395 else if (r_type
== R_SPARC_LOX10
)
3399 relocation
+= rel
->r_addend
;
3400 relocation
= (relocation
& 0x3ff) | 0x1c00;
3402 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3403 x
= (x
& ~(bfd_vma
) 0x1fff) | relocation
;
3404 bfd_put_32 (input_bfd
, x
, contents
+ rel
->r_offset
);
3408 else if ((r_type
== R_SPARC_WDISP30
|| r_type
== R_SPARC_WPLT30
)
3409 && sec_do_relax (input_section
)
3410 && rel
->r_offset
+ 4 < input_section
->size
)
3414 #define XCC (2 << 20)
3415 #define COND(x) (((x)&0xf)<<25)
3416 #define CONDA COND(0x8)
3417 #define INSN_BPA (F2(0,1) | CONDA | BPRED | XCC)
3418 #define INSN_BA (F2(0,2) | CONDA)
3419 #define INSN_OR F3(2, 0x2, 0)
3420 #define INSN_NOP F2(0,4)
3424 /* If the instruction is a call with either:
3426 arithmetic instruction with rd == %o7
3427 where rs1 != %o7 and rs2 if it is register != %o7
3428 then we can optimize if the call destination is near
3429 by changing the call into a branch always. */
3430 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3431 y
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
3432 if ((x
& OP(~0)) == OP(1) && (y
& OP(~0)) == OP(2))
3434 if (((y
& OP3(~0)) == OP3(0x3d) /* restore */
3435 || ((y
& OP3(0x28)) == 0 /* arithmetic */
3436 && (y
& RD(~0)) == RD(O7
)))
3437 && (y
& RS1(~0)) != RS1(O7
)
3439 || (y
& RS2(~0)) != RS2(O7
)))
3443 reloc
= relocation
+ rel
->r_addend
- rel
->r_offset
;
3444 reloc
-= (input_section
->output_section
->vma
3445 + input_section
->output_offset
);
3447 /* Ensure the branch fits into simm22. */
3448 if ((reloc
& 3) == 0
3449 && ((reloc
& ~(bfd_vma
)0x7fffff) == 0
3450 || ((reloc
| 0x7fffff) == ~(bfd_vma
)0)))
3454 /* Check whether it fits into simm19. */
3455 if (((reloc
& 0x3c0000) == 0
3456 || (reloc
& 0x3c0000) == 0x3c0000)
3457 && (ABI_64_P (output_bfd
)
3458 || elf_elfheader (output_bfd
)->e_flags
& EF_SPARC_32PLUS
))
3459 x
= INSN_BPA
| (reloc
& 0x7ffff); /* ba,pt %xcc */
3461 x
= INSN_BA
| (reloc
& 0x3fffff); /* ba */
3462 bfd_put_32 (input_bfd
, x
, contents
+ rel
->r_offset
);
3464 if (rel
->r_offset
>= 4
3465 && (y
& (0xffffffff ^ RS1(~0)))
3466 == (INSN_OR
| RD(O7
) | RS2(G0
)))
3471 z
= bfd_get_32 (input_bfd
,
3472 contents
+ rel
->r_offset
- 4);
3473 if ((z
& (0xffffffff ^ RD(~0)))
3474 != (INSN_OR
| RS1(O7
) | RS2(G0
)))
3482 If call foo was replaced with ba, replace
3483 or %rN, %g0, %o7 with nop. */
3485 reg
= (y
& RS1(~0)) >> 14;
3486 if (reg
!= ((z
& RD(~0)) >> 25)
3487 || reg
== G0
|| reg
== O7
)
3490 bfd_put_32 (input_bfd
, (bfd_vma
) INSN_NOP
,
3491 contents
+ rel
->r_offset
+ 4);
3499 if (r
== bfd_reloc_continue
)
3500 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
3501 contents
, rel
->r_offset
,
3502 relocation
, rel
->r_addend
);
3504 if (r
!= bfd_reloc_ok
)
3509 case bfd_reloc_outofrange
:
3511 case bfd_reloc_overflow
:
3515 /* The Solaris native linker silently disregards overflows.
3516 We don't, but this breaks stabs debugging info, whose
3517 relocations are only 32-bits wide. Ignore overflows in
3518 this case and also for discarded entries. */
3519 if ((r_type
== R_SPARC_32
|| r_type
== R_SPARC_DISP32
)
3520 && (((input_section
->flags
& SEC_DEBUGGING
) != 0
3521 && strcmp (bfd_section_name (input_bfd
,
3524 || _bfd_elf_section_offset (output_bfd
, info
,
3532 /* Assume this is a call protected by other code that
3533 detect the symbol is undefined. If this is the case,
3534 we can safely ignore the overflow. If not, the
3535 program is hosed anyway, and a little warning isn't
3537 if (h
->root
.type
== bfd_link_hash_undefweak
3538 && howto
->pc_relative
)
3545 name
= bfd_elf_string_from_elf_section (input_bfd
,
3546 symtab_hdr
->sh_link
,
3551 name
= bfd_section_name (input_bfd
, sec
);
3553 if (! ((*info
->callbacks
->reloc_overflow
)
3554 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
3555 (bfd_vma
) 0, input_bfd
, input_section
,
3567 /* Build a VxWorks PLT entry. PLT_INDEX is the index of the PLT entry
3568 and PLT_OFFSET is the byte offset from the start of .plt. GOT_OFFSET
3569 is the offset of the associated .got.plt entry from
3570 _GLOBAL_OFFSET_TABLE_. */
3573 sparc_vxworks_build_plt_entry (bfd
*output_bfd
, struct bfd_link_info
*info
,
3574 bfd_vma plt_offset
, bfd_vma plt_index
,
3578 const bfd_vma
*plt_entry
;
3579 struct _bfd_sparc_elf_link_hash_table
*htab
;
3581 Elf_Internal_Rela rela
;
3583 htab
= _bfd_sparc_elf_hash_table (info
);
3586 plt_entry
= sparc_vxworks_shared_plt_entry
;
3591 plt_entry
= sparc_vxworks_exec_plt_entry
;
3592 got_base
= (htab
->elf
.hgot
->root
.u
.def
.value
3593 + htab
->elf
.hgot
->root
.u
.def
.section
->output_offset
3594 + htab
->elf
.hgot
->root
.u
.def
.section
->output_section
->vma
);
3597 /* Fill in the entry in the procedure linkage table. */
3598 bfd_put_32 (output_bfd
, plt_entry
[0] + ((got_base
+ got_offset
) >> 10),
3599 htab
->splt
->contents
+ plt_offset
);
3600 bfd_put_32 (output_bfd
, plt_entry
[1] + ((got_base
+ got_offset
) & 0x3ff),
3601 htab
->splt
->contents
+ plt_offset
+ 4);
3602 bfd_put_32 (output_bfd
, plt_entry
[2],
3603 htab
->splt
->contents
+ plt_offset
+ 8);
3604 bfd_put_32 (output_bfd
, plt_entry
[3],
3605 htab
->splt
->contents
+ plt_offset
+ 12);
3606 bfd_put_32 (output_bfd
, plt_entry
[4],
3607 htab
->splt
->contents
+ plt_offset
+ 16);
3608 bfd_put_32 (output_bfd
, plt_entry
[5] + (plt_index
>> 10),
3609 htab
->splt
->contents
+ plt_offset
+ 20);
3610 /* PC-relative displacement for a branch to the start of
3612 bfd_put_32 (output_bfd
, plt_entry
[6] + (((-plt_offset
- 24) >> 2)
3614 htab
->splt
->contents
+ plt_offset
+ 24);
3615 bfd_put_32 (output_bfd
, plt_entry
[7] + (plt_index
& 0x3ff),
3616 htab
->splt
->contents
+ plt_offset
+ 28);
3618 /* Fill in the .got.plt entry, pointing initially at the
3619 second half of the PLT entry. */
3620 BFD_ASSERT (htab
->sgotplt
!= NULL
);
3621 bfd_put_32 (output_bfd
,
3622 htab
->splt
->output_section
->vma
3623 + htab
->splt
->output_offset
3625 htab
->sgotplt
->contents
+ got_offset
);
3627 /* Add relocations to .rela.plt.unloaded. */
3630 loc
= (htab
->srelplt2
->contents
3631 + (2 + 3 * plt_index
) * sizeof (Elf32_External_Rela
));
3633 /* Relocate the initial sethi. */
3634 rela
.r_offset
= (htab
->splt
->output_section
->vma
3635 + htab
->splt
->output_offset
3637 rela
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_SPARC_HI22
);
3638 rela
.r_addend
= got_offset
;
3639 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
3640 loc
+= sizeof (Elf32_External_Rela
);
3642 /* Likewise the following or. */
3644 rela
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_SPARC_LO10
);
3645 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
3646 loc
+= sizeof (Elf32_External_Rela
);
3648 /* Relocate the .got.plt entry. */
3649 rela
.r_offset
= (htab
->sgotplt
->output_section
->vma
3650 + htab
->sgotplt
->output_offset
3652 rela
.r_info
= ELF32_R_INFO (htab
->elf
.hplt
->indx
, R_SPARC_32
);
3653 rela
.r_addend
= plt_offset
+ 20;
3654 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
3658 /* Finish up dynamic symbol handling. We set the contents of various
3659 dynamic sections here. */
3662 _bfd_sparc_elf_finish_dynamic_symbol (bfd
*output_bfd
,
3663 struct bfd_link_info
*info
,
3664 struct elf_link_hash_entry
*h
,
3665 Elf_Internal_Sym
*sym
)
3668 struct _bfd_sparc_elf_link_hash_table
*htab
;
3670 htab
= _bfd_sparc_elf_hash_table (info
);
3671 dynobj
= htab
->elf
.dynobj
;
3673 if (h
->plt
.offset
!= (bfd_vma
) -1)
3677 Elf_Internal_Rela rela
;
3679 bfd_vma r_offset
, got_offset
;
3682 /* This symbol has an entry in the PLT. Set it up. */
3684 BFD_ASSERT (h
->dynindx
!= -1);
3687 srela
= htab
->srelplt
;
3688 BFD_ASSERT (splt
!= NULL
&& srela
!= NULL
);
3690 /* Fill in the entry in the .rela.plt section. */
3691 if (htab
->is_vxworks
)
3693 /* Work out the index of this PLT entry. */
3694 rela_index
= ((h
->plt
.offset
- htab
->plt_header_size
)
3695 / htab
->plt_entry_size
);
3697 /* Calculate the offset of the associated .got.plt entry.
3698 The first three entries are reserved. */
3699 got_offset
= (rela_index
+ 3) * 4;
3701 sparc_vxworks_build_plt_entry (output_bfd
, info
, h
->plt
.offset
,
3702 rela_index
, got_offset
);
3705 /* On VxWorks, the relocation points to the .got.plt entry,
3706 not the .plt entry. */
3707 rela
.r_offset
= (htab
->sgotplt
->output_section
->vma
3708 + htab
->sgotplt
->output_offset
3714 /* Fill in the entry in the procedure linkage table. */
3715 rela_index
= SPARC_ELF_BUILD_PLT_ENTRY (htab
, output_bfd
, splt
,
3716 h
->plt
.offset
, splt
->size
,
3719 rela
.r_offset
= r_offset
3720 + (splt
->output_section
->vma
+ splt
->output_offset
);
3721 if (! ABI_64_P (output_bfd
)
3722 || h
->plt
.offset
< (PLT64_LARGE_THRESHOLD
* PLT64_ENTRY_SIZE
))
3728 rela
.r_addend
= (-(h
->plt
.offset
+ 4)
3729 - splt
->output_section
->vma
3730 - splt
->output_offset
);
3733 rela
.r_info
= SPARC_ELF_R_INFO (htab
, NULL
, h
->dynindx
, R_SPARC_JMP_SLOT
);
3735 /* Adjust for the first 4 reserved elements in the .plt section
3736 when setting the offset in the .rela.plt section.
3737 Sun forgot to read their own ABI and copied elf32-sparc behaviour,
3738 thus .plt[4] has corresponding .rela.plt[0] and so on. */
3740 loc
= srela
->contents
;
3742 if (ABI_64_P (output_bfd
))
3744 loc
+= rela_index
* sizeof (Elf64_External_Rela
);
3745 bfd_elf64_swap_reloca_out (output_bfd
, &rela
, loc
);
3750 loc
+= rela_index
* sizeof (Elf32_External_Rela
);
3751 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
3754 if (!h
->def_regular
)
3756 /* Mark the symbol as undefined, rather than as defined in
3757 the .plt section. Leave the value alone. */
3758 sym
->st_shndx
= SHN_UNDEF
;
3759 /* If the symbol is weak, we do need to clear the value.
3760 Otherwise, the PLT entry would provide a definition for
3761 the symbol even if the symbol wasn't defined anywhere,
3762 and so the symbol would never be NULL. */
3763 if (!h
->ref_regular_nonweak
)
3768 if (h
->got
.offset
!= (bfd_vma
) -1
3769 && _bfd_sparc_elf_hash_entry(h
)->tls_type
!= GOT_TLS_GD
3770 && _bfd_sparc_elf_hash_entry(h
)->tls_type
!= GOT_TLS_IE
)
3774 Elf_Internal_Rela rela
;
3776 /* This symbol has an entry in the GOT. Set it up. */
3779 srela
= htab
->srelgot
;
3780 BFD_ASSERT (sgot
!= NULL
&& srela
!= NULL
);
3782 rela
.r_offset
= (sgot
->output_section
->vma
3783 + sgot
->output_offset
3784 + (h
->got
.offset
&~ (bfd_vma
) 1));
3786 /* If this is a -Bsymbolic link, and the symbol is defined
3787 locally, we just want to emit a RELATIVE reloc. Likewise if
3788 the symbol was forced to be local because of a version file.
3789 The entry in the global offset table will already have been
3790 initialized in the relocate_section function. */
3792 && (info
->symbolic
|| h
->dynindx
== -1)
3795 asection
*sec
= h
->root
.u
.def
.section
;
3796 rela
.r_info
= SPARC_ELF_R_INFO (htab
, NULL
, 0, R_SPARC_RELATIVE
);
3797 rela
.r_addend
= (h
->root
.u
.def
.value
3798 + sec
->output_section
->vma
3799 + sec
->output_offset
);
3803 rela
.r_info
= SPARC_ELF_R_INFO (htab
, NULL
, h
->dynindx
, R_SPARC_GLOB_DAT
);
3807 SPARC_ELF_PUT_WORD (htab
, output_bfd
, 0,
3808 sgot
->contents
+ (h
->got
.offset
& ~(bfd_vma
) 1));
3809 SPARC_ELF_APPEND_RELA (htab
, output_bfd
, srela
, &rela
);
3815 Elf_Internal_Rela rela
;
3817 /* This symbols needs a copy reloc. Set it up. */
3818 BFD_ASSERT (h
->dynindx
!= -1);
3820 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
3822 BFD_ASSERT (s
!= NULL
);
3824 rela
.r_offset
= (h
->root
.u
.def
.value
3825 + h
->root
.u
.def
.section
->output_section
->vma
3826 + h
->root
.u
.def
.section
->output_offset
);
3827 rela
.r_info
= SPARC_ELF_R_INFO (htab
, NULL
, h
->dynindx
, R_SPARC_COPY
);
3829 SPARC_ELF_APPEND_RELA (htab
, output_bfd
, s
, &rela
);
3832 /* Mark some specially defined symbols as absolute. On VxWorks,
3833 _GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the
3834 ".got" section. Likewise _PROCEDURE_LINKAGE_TABLE_ and ".plt". */
3835 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
3836 || (!htab
->is_vxworks
3837 && (h
== htab
->elf
.hgot
|| h
== htab
->elf
.hplt
)))
3838 sym
->st_shndx
= SHN_ABS
;
3843 /* Finish up the dynamic sections. */
3847 sparc64_finish_dyn (bfd
*output_bfd
, struct bfd_link_info
*info
,
3848 bfd
*dynobj
, asection
*sdyn
,
3849 asection
*splt ATTRIBUTE_UNUSED
)
3851 Elf64_External_Dyn
*dyncon
, *dynconend
;
3852 int stt_regidx
= -1;
3854 dyncon
= (Elf64_External_Dyn
*) sdyn
->contents
;
3855 dynconend
= (Elf64_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
3856 for (; dyncon
< dynconend
; dyncon
++)
3858 Elf_Internal_Dyn dyn
;
3862 bfd_elf64_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3866 case DT_PLTGOT
: name
= ".plt"; size
= FALSE
; break;
3867 case DT_PLTRELSZ
: name
= ".rela.plt"; size
= TRUE
; break;
3868 case DT_JMPREL
: name
= ".rela.plt"; size
= FALSE
; break;
3869 case DT_SPARC_REGISTER
:
3870 if (stt_regidx
== -1)
3873 _bfd_elf_link_lookup_local_dynindx (info
, output_bfd
, -1);
3874 if (stt_regidx
== -1)
3877 dyn
.d_un
.d_val
= stt_regidx
++;
3878 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3880 default: name
= NULL
; size
= FALSE
; break;
3887 s
= bfd_get_section_by_name (output_bfd
, name
);
3893 dyn
.d_un
.d_ptr
= s
->vma
;
3895 dyn
.d_un
.d_val
= s
->size
;
3897 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3905 sparc32_finish_dyn (bfd
*output_bfd
, struct bfd_link_info
*info
,
3906 bfd
*dynobj
, asection
*sdyn
,
3907 asection
*splt ATTRIBUTE_UNUSED
)
3909 Elf32_External_Dyn
*dyncon
, *dynconend
;
3910 struct _bfd_sparc_elf_link_hash_table
*htab
;
3912 htab
= _bfd_sparc_elf_hash_table (info
);
3913 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3914 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
3915 for (; dyncon
< dynconend
; dyncon
++)
3917 Elf_Internal_Dyn dyn
;
3921 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3923 if (htab
->is_vxworks
&& dyn
.d_tag
== DT_RELASZ
)
3925 /* On VxWorks, DT_RELASZ should not include the relocations
3929 dyn
.d_un
.d_val
-= htab
->srelplt
->size
;
3930 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3933 else if (htab
->is_vxworks
&& dyn
.d_tag
== DT_PLTGOT
)
3935 /* On VxWorks, DT_PLTGOT should point to the start of the GOT,
3936 not to the start of the PLT. */
3939 dyn
.d_un
.d_val
= (htab
->sgotplt
->output_section
->vma
3940 + htab
->sgotplt
->output_offset
);
3941 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3948 case DT_PLTGOT
: name
= ".plt"; size
= FALSE
; break;
3949 case DT_PLTRELSZ
: name
= ".rela.plt"; size
= TRUE
; break;
3950 case DT_JMPREL
: name
= ".rela.plt"; size
= FALSE
; break;
3951 default: name
= NULL
; size
= FALSE
; break;
3958 s
= bfd_get_section_by_name (output_bfd
, name
);
3964 dyn
.d_un
.d_ptr
= s
->vma
;
3966 dyn
.d_un
.d_val
= s
->size
;
3968 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3975 /* Install the first PLT entry in a VxWorks executable and make sure that
3976 .rela.plt.unloaded relocations have the correct symbol indexes. */
3979 sparc_vxworks_finish_exec_plt (bfd
*output_bfd
, struct bfd_link_info
*info
)
3981 struct _bfd_sparc_elf_link_hash_table
*htab
;
3982 Elf_Internal_Rela rela
;
3986 htab
= _bfd_sparc_elf_hash_table (info
);
3988 /* Calculate the absolute value of _GLOBAL_OFFSET_TABLE_. */
3989 got_base
= (htab
->elf
.hgot
->root
.u
.def
.section
->output_section
->vma
3990 + htab
->elf
.hgot
->root
.u
.def
.section
->output_offset
3991 + htab
->elf
.hgot
->root
.u
.def
.value
);
3993 /* Install the initial PLT entry. */
3994 bfd_put_32 (output_bfd
,
3995 sparc_vxworks_exec_plt0_entry
[0] + ((got_base
+ 8) >> 10),
3996 htab
->splt
->contents
);
3997 bfd_put_32 (output_bfd
,
3998 sparc_vxworks_exec_plt0_entry
[1] + ((got_base
+ 8) & 0x3ff),
3999 htab
->splt
->contents
+ 4);
4000 bfd_put_32 (output_bfd
,
4001 sparc_vxworks_exec_plt0_entry
[2],
4002 htab
->splt
->contents
+ 8);
4003 bfd_put_32 (output_bfd
,
4004 sparc_vxworks_exec_plt0_entry
[3],
4005 htab
->splt
->contents
+ 12);
4006 bfd_put_32 (output_bfd
,
4007 sparc_vxworks_exec_plt0_entry
[4],
4008 htab
->splt
->contents
+ 16);
4010 loc
= htab
->srelplt2
->contents
;
4012 /* Add an unloaded relocation for the initial entry's "sethi". */
4013 rela
.r_offset
= (htab
->splt
->output_section
->vma
4014 + htab
->splt
->output_offset
);
4015 rela
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_SPARC_HI22
);
4017 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
4018 loc
+= sizeof (Elf32_External_Rela
);
4020 /* Likewise the following "or". */
4022 rela
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_SPARC_LO10
);
4023 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
4024 loc
+= sizeof (Elf32_External_Rela
);
4026 /* Fix up the remaining .rela.plt.unloaded relocations. They may have
4027 the wrong symbol index for _G_O_T_ or _P_L_T_ depending on the order
4028 in which symbols were output. */
4029 while (loc
< htab
->srelplt2
->contents
+ htab
->srelplt2
->size
)
4031 Elf_Internal_Rela rel
;
4033 /* The entry's initial "sethi" (against _G_O_T_). */
4034 bfd_elf32_swap_reloc_in (output_bfd
, loc
, &rel
);
4035 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_SPARC_HI22
);
4036 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
4037 loc
+= sizeof (Elf32_External_Rela
);
4039 /* The following "or" (also against _G_O_T_). */
4040 bfd_elf32_swap_reloc_in (output_bfd
, loc
, &rel
);
4041 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_SPARC_LO10
);
4042 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
4043 loc
+= sizeof (Elf32_External_Rela
);
4045 /* The .got.plt entry (against _P_L_T_). */
4046 bfd_elf32_swap_reloc_in (output_bfd
, loc
, &rel
);
4047 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hplt
->indx
, R_SPARC_32
);
4048 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
4049 loc
+= sizeof (Elf32_External_Rela
);
4053 /* Install the first PLT entry in a VxWorks shared object. */
4056 sparc_vxworks_finish_shared_plt (bfd
*output_bfd
, struct bfd_link_info
*info
)
4058 struct _bfd_sparc_elf_link_hash_table
*htab
;
4061 htab
= _bfd_sparc_elf_hash_table (info
);
4062 for (i
= 0; i
< ARRAY_SIZE (sparc_vxworks_shared_plt0_entry
); i
++)
4063 bfd_put_32 (output_bfd
, sparc_vxworks_shared_plt0_entry
[i
],
4064 htab
->splt
->contents
+ i
* 4);
4068 _bfd_sparc_elf_finish_dynamic_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
4072 struct _bfd_sparc_elf_link_hash_table
*htab
;
4074 htab
= _bfd_sparc_elf_hash_table (info
);
4075 dynobj
= htab
->elf
.dynobj
;
4077 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
4079 if (elf_hash_table (info
)->dynamic_sections_created
)
4084 splt
= bfd_get_section_by_name (dynobj
, ".plt");
4085 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
4088 if (ABI_64_P (output_bfd
))
4089 ret
= sparc64_finish_dyn (output_bfd
, info
, dynobj
, sdyn
, splt
);
4092 ret
= sparc32_finish_dyn (output_bfd
, info
, dynobj
, sdyn
, splt
);
4097 /* Initialize the contents of the .plt section. */
4100 if (htab
->is_vxworks
)
4103 sparc_vxworks_finish_shared_plt (output_bfd
, info
);
4105 sparc_vxworks_finish_exec_plt (output_bfd
, info
);
4109 memset (splt
->contents
, 0, htab
->plt_header_size
);
4110 if (!ABI_64_P (output_bfd
))
4111 bfd_put_32 (output_bfd
, (bfd_vma
) SPARC_NOP
,
4112 splt
->contents
+ splt
->size
- 4);
4116 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
4117 = (htab
->is_vxworks
|| !ABI_64_P (output_bfd
))
4118 ? 0 : htab
->plt_entry_size
;
4121 /* Set the first entry in the global offset table to the address of
4122 the dynamic section. */
4123 if (htab
->sgot
&& htab
->sgot
->size
> 0)
4125 bfd_vma val
= (sdyn
?
4126 sdyn
->output_section
->vma
+ sdyn
->output_offset
:
4129 SPARC_ELF_PUT_WORD (htab
, output_bfd
, val
, htab
->sgot
->contents
);
4133 elf_section_data (htab
->sgot
->output_section
)->this_hdr
.sh_entsize
=
4134 SPARC_ELF_WORD_BYTES (htab
);
4140 /* Set the right machine number for a SPARC ELF file. */
4143 _bfd_sparc_elf_object_p (bfd
*abfd
)
4145 if (ABI_64_P (abfd
))
4147 unsigned long mach
= bfd_mach_sparc_v9
;
4149 if (elf_elfheader (abfd
)->e_flags
& EF_SPARC_SUN_US3
)
4150 mach
= bfd_mach_sparc_v9b
;
4151 else if (elf_elfheader (abfd
)->e_flags
& EF_SPARC_SUN_US1
)
4152 mach
= bfd_mach_sparc_v9a
;
4153 return bfd_default_set_arch_mach (abfd
, bfd_arch_sparc
, mach
);
4157 if (elf_elfheader (abfd
)->e_machine
== EM_SPARC32PLUS
)
4159 if (elf_elfheader (abfd
)->e_flags
& EF_SPARC_SUN_US3
)
4160 return bfd_default_set_arch_mach (abfd
, bfd_arch_sparc
,
4161 bfd_mach_sparc_v8plusb
);
4162 else if (elf_elfheader (abfd
)->e_flags
& EF_SPARC_SUN_US1
)
4163 return bfd_default_set_arch_mach (abfd
, bfd_arch_sparc
,
4164 bfd_mach_sparc_v8plusa
);
4165 else if (elf_elfheader (abfd
)->e_flags
& EF_SPARC_32PLUS
)
4166 return bfd_default_set_arch_mach (abfd
, bfd_arch_sparc
,
4167 bfd_mach_sparc_v8plus
);
4171 else if (elf_elfheader (abfd
)->e_flags
& EF_SPARC_LEDATA
)
4172 return bfd_default_set_arch_mach (abfd
, bfd_arch_sparc
,
4173 bfd_mach_sparc_sparclite_le
);
4175 return bfd_default_set_arch_mach (abfd
, bfd_arch_sparc
, bfd_mach_sparc
);
4179 /* Return address for Ith PLT stub in section PLT, for relocation REL
4180 or (bfd_vma) -1 if it should not be included. */
4183 _bfd_sparc_elf_plt_sym_val (bfd_vma i
, const asection
*plt
, const arelent
*rel
)
4185 if (ABI_64_P (plt
->owner
))
4189 i
+= PLT64_HEADER_SIZE
/ PLT64_ENTRY_SIZE
;
4190 if (i
< PLT64_LARGE_THRESHOLD
)
4191 return plt
->vma
+ i
* PLT64_ENTRY_SIZE
;
4193 j
= (i
- PLT64_LARGE_THRESHOLD
) % 160;
4195 return plt
->vma
+ i
* PLT64_ENTRY_SIZE
+ j
* 4 * 6;
4198 return rel
->address
;