1 /* SPARC-specific support for ELF
2 Copyright 2005 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. */
27 #include "elf/sparc.h"
28 #include "opcode/sparc.h"
29 #include "elfxx-sparc.h"
31 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
32 #define MINUS_ONE (~ (bfd_vma) 0)
34 #define ABI_64_P(abfd) \
35 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
37 /* The relocation "howto" table. */
39 /* Utility for performing the standard initial work of an instruction
41 *PRELOCATION will contain the relocated item.
42 *PINSN will contain the instruction from the input stream.
43 If the result is `bfd_reloc_other' the caller can continue with
44 performing the relocation. Otherwise it must stop and return the
45 value to its caller. */
47 static bfd_reloc_status_type
48 init_insn_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
49 PTR data
, asection
*input_section
, bfd
*output_bfd
,
50 bfd_vma
*prelocation
, bfd_vma
*pinsn
)
53 reloc_howto_type
*howto
= reloc_entry
->howto
;
55 if (output_bfd
!= (bfd
*) NULL
56 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
57 && (! howto
->partial_inplace
58 || reloc_entry
->addend
== 0))
60 reloc_entry
->address
+= input_section
->output_offset
;
64 /* This works because partial_inplace is FALSE. */
65 if (output_bfd
!= NULL
)
66 return bfd_reloc_continue
;
68 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
69 return bfd_reloc_outofrange
;
71 relocation
= (symbol
->value
72 + symbol
->section
->output_section
->vma
73 + symbol
->section
->output_offset
);
74 relocation
+= reloc_entry
->addend
;
75 if (howto
->pc_relative
)
77 relocation
-= (input_section
->output_section
->vma
78 + input_section
->output_offset
);
79 relocation
-= reloc_entry
->address
;
82 *prelocation
= relocation
;
83 *pinsn
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
84 return bfd_reloc_other
;
87 /* For unsupported relocs. */
89 static bfd_reloc_status_type
90 sparc_elf_notsup_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
91 arelent
*reloc_entry ATTRIBUTE_UNUSED
,
92 asymbol
*symbol ATTRIBUTE_UNUSED
,
93 PTR data ATTRIBUTE_UNUSED
,
94 asection
*input_section ATTRIBUTE_UNUSED
,
95 bfd
*output_bfd ATTRIBUTE_UNUSED
,
96 char **error_message ATTRIBUTE_UNUSED
)
98 return bfd_reloc_notsupported
;
101 /* Handle the WDISP16 reloc. */
103 static bfd_reloc_status_type
104 sparc_elf_wdisp16_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
105 PTR data
, asection
*input_section
, bfd
*output_bfd
,
106 char **error_message ATTRIBUTE_UNUSED
)
110 bfd_reloc_status_type status
;
112 status
= init_insn_reloc (abfd
, reloc_entry
, symbol
, data
,
113 input_section
, output_bfd
, &relocation
, &insn
);
114 if (status
!= bfd_reloc_other
)
117 insn
&= ~ (bfd_vma
) 0x303fff;
118 insn
|= (((relocation
>> 2) & 0xc000) << 6) | ((relocation
>> 2) & 0x3fff);
119 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ reloc_entry
->address
);
121 if ((bfd_signed_vma
) relocation
< - 0x40000
122 || (bfd_signed_vma
) relocation
> 0x3ffff)
123 return bfd_reloc_overflow
;
128 /* Handle the HIX22 reloc. */
130 static bfd_reloc_status_type
131 sparc_elf_hix22_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
132 PTR data
, asection
*input_section
, bfd
*output_bfd
,
133 char **error_message ATTRIBUTE_UNUSED
)
137 bfd_reloc_status_type status
;
139 status
= init_insn_reloc (abfd
, reloc_entry
, symbol
, data
,
140 input_section
, output_bfd
, &relocation
, &insn
);
141 if (status
!= bfd_reloc_other
)
144 relocation
^= MINUS_ONE
;
145 insn
= (insn
&~ (bfd_vma
) 0x3fffff) | ((relocation
>> 10) & 0x3fffff);
146 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ reloc_entry
->address
);
148 if ((relocation
& ~ (bfd_vma
) 0xffffffff) != 0)
149 return bfd_reloc_overflow
;
154 /* Handle the LOX10 reloc. */
156 static bfd_reloc_status_type
157 sparc_elf_lox10_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
158 PTR data
, asection
*input_section
, bfd
*output_bfd
,
159 char **error_message ATTRIBUTE_UNUSED
)
163 bfd_reloc_status_type status
;
165 status
= init_insn_reloc (abfd
, reloc_entry
, symbol
, data
,
166 input_section
, output_bfd
, &relocation
, &insn
);
167 if (status
!= bfd_reloc_other
)
170 insn
= (insn
&~ (bfd_vma
) 0x1fff) | 0x1c00 | (relocation
& 0x3ff);
171 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ reloc_entry
->address
);
176 static reloc_howto_type _bfd_sparc_elf_howto_table
[] =
178 HOWTO(R_SPARC_NONE
, 0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_NONE", FALSE
,0,0x00000000,TRUE
),
179 HOWTO(R_SPARC_8
, 0,0, 8,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_8", FALSE
,0,0x000000ff,TRUE
),
180 HOWTO(R_SPARC_16
, 0,1,16,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_16", FALSE
,0,0x0000ffff,TRUE
),
181 HOWTO(R_SPARC_32
, 0,2,32,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_32", FALSE
,0,0xffffffff,TRUE
),
182 HOWTO(R_SPARC_DISP8
, 0,0, 8,TRUE
, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_DISP8", FALSE
,0,0x000000ff,TRUE
),
183 HOWTO(R_SPARC_DISP16
, 0,1,16,TRUE
, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_DISP16", FALSE
,0,0x0000ffff,TRUE
),
184 HOWTO(R_SPARC_DISP32
, 0,2,32,TRUE
, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_DISP32", FALSE
,0,0xffffffff,TRUE
),
185 HOWTO(R_SPARC_WDISP30
, 2,2,30,TRUE
, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_WDISP30", FALSE
,0,0x3fffffff,TRUE
),
186 HOWTO(R_SPARC_WDISP22
, 2,2,22,TRUE
, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_WDISP22", FALSE
,0,0x003fffff,TRUE
),
187 HOWTO(R_SPARC_HI22
, 10,2,22,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_HI22", FALSE
,0,0x003fffff,TRUE
),
188 HOWTO(R_SPARC_22
, 0,2,22,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_22", FALSE
,0,0x003fffff,TRUE
),
189 HOWTO(R_SPARC_13
, 0,2,13,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_13", FALSE
,0,0x00001fff,TRUE
),
190 HOWTO(R_SPARC_LO10
, 0,2,10,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_LO10", FALSE
,0,0x000003ff,TRUE
),
191 HOWTO(R_SPARC_GOT10
, 0,2,10,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_GOT10", FALSE
,0,0x000003ff,TRUE
),
192 HOWTO(R_SPARC_GOT13
, 0,2,13,FALSE
,0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_GOT13", FALSE
,0,0x00001fff,TRUE
),
193 HOWTO(R_SPARC_GOT22
, 10,2,22,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_GOT22", FALSE
,0,0x003fffff,TRUE
),
194 HOWTO(R_SPARC_PC10
, 0,2,10,TRUE
, 0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_PC10", FALSE
,0,0x000003ff,TRUE
),
195 HOWTO(R_SPARC_PC22
, 10,2,22,TRUE
, 0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_PC22", FALSE
,0,0x003fffff,TRUE
),
196 HOWTO(R_SPARC_WPLT30
, 2,2,30,TRUE
, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_WPLT30", FALSE
,0,0x3fffffff,TRUE
),
197 HOWTO(R_SPARC_COPY
, 0,0,00,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_COPY", FALSE
,0,0x00000000,TRUE
),
198 HOWTO(R_SPARC_GLOB_DAT
, 0,0,00,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_GLOB_DAT",FALSE
,0,0x00000000,TRUE
),
199 HOWTO(R_SPARC_JMP_SLOT
, 0,0,00,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_JMP_SLOT",FALSE
,0,0x00000000,TRUE
),
200 HOWTO(R_SPARC_RELATIVE
, 0,0,00,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_RELATIVE",FALSE
,0,0x00000000,TRUE
),
201 HOWTO(R_SPARC_UA32
, 0,2,32,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_UA32", FALSE
,0,0xffffffff,TRUE
),
202 HOWTO(R_SPARC_PLT32
, 0,2,32,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_PLT32", FALSE
,0,0xffffffff,TRUE
),
203 HOWTO(R_SPARC_HIPLT22
, 0,0,00,FALSE
,0,complain_overflow_dont
, sparc_elf_notsup_reloc
, "R_SPARC_HIPLT22", FALSE
,0,0x00000000,TRUE
),
204 HOWTO(R_SPARC_LOPLT10
, 0,0,00,FALSE
,0,complain_overflow_dont
, sparc_elf_notsup_reloc
, "R_SPARC_LOPLT10", FALSE
,0,0x00000000,TRUE
),
205 HOWTO(R_SPARC_PCPLT32
, 0,0,00,FALSE
,0,complain_overflow_dont
, sparc_elf_notsup_reloc
, "R_SPARC_PCPLT32", FALSE
,0,0x00000000,TRUE
),
206 HOWTO(R_SPARC_PCPLT22
, 0,0,00,FALSE
,0,complain_overflow_dont
, sparc_elf_notsup_reloc
, "R_SPARC_PCPLT22", FALSE
,0,0x00000000,TRUE
),
207 HOWTO(R_SPARC_PCPLT10
, 0,0,00,FALSE
,0,complain_overflow_dont
, sparc_elf_notsup_reloc
, "R_SPARC_PCPLT10", FALSE
,0,0x00000000,TRUE
),
208 HOWTO(R_SPARC_10
, 0,2,10,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_10", FALSE
,0,0x000003ff,TRUE
),
209 HOWTO(R_SPARC_11
, 0,2,11,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_11", FALSE
,0,0x000007ff,TRUE
),
210 HOWTO(R_SPARC_64
, 0,4,64,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_64", FALSE
,0,MINUS_ONE
, TRUE
),
211 HOWTO(R_SPARC_OLO10
, 0,2,13,FALSE
,0,complain_overflow_signed
, sparc_elf_notsup_reloc
, "R_SPARC_OLO10", FALSE
,0,0x00001fff,TRUE
),
212 HOWTO(R_SPARC_HH22
, 42,2,22,FALSE
,0,complain_overflow_unsigned
,bfd_elf_generic_reloc
, "R_SPARC_HH22", FALSE
,0,0x003fffff,TRUE
),
213 HOWTO(R_SPARC_HM10
, 32,2,10,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_HM10", FALSE
,0,0x000003ff,TRUE
),
214 HOWTO(R_SPARC_LM22
, 10,2,22,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_LM22", FALSE
,0,0x003fffff,TRUE
),
215 HOWTO(R_SPARC_PC_HH22
, 42,2,22,TRUE
, 0,complain_overflow_unsigned
,bfd_elf_generic_reloc
, "R_SPARC_PC_HH22", FALSE
,0,0x003fffff,TRUE
),
216 HOWTO(R_SPARC_PC_HM10
, 32,2,10,TRUE
, 0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_PC_HM10", FALSE
,0,0x000003ff,TRUE
),
217 HOWTO(R_SPARC_PC_LM22
, 10,2,22,TRUE
, 0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_PC_LM22", FALSE
,0,0x003fffff,TRUE
),
218 HOWTO(R_SPARC_WDISP16
, 2,2,16,TRUE
, 0,complain_overflow_signed
, sparc_elf_wdisp16_reloc
,"R_SPARC_WDISP16", FALSE
,0,0x00000000,TRUE
),
219 HOWTO(R_SPARC_WDISP19
, 2,2,19,TRUE
, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_WDISP19", FALSE
,0,0x0007ffff,TRUE
),
220 HOWTO(R_SPARC_UNUSED_42
, 0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_UNUSED_42",FALSE
,0,0x00000000,TRUE
),
221 HOWTO(R_SPARC_7
, 0,2, 7,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_7", FALSE
,0,0x0000007f,TRUE
),
222 HOWTO(R_SPARC_5
, 0,2, 5,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_5", FALSE
,0,0x0000001f,TRUE
),
223 HOWTO(R_SPARC_6
, 0,2, 6,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_6", FALSE
,0,0x0000003f,TRUE
),
224 HOWTO(R_SPARC_DISP64
, 0,4,64,TRUE
, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_DISP64", FALSE
,0,MINUS_ONE
, TRUE
),
225 HOWTO(R_SPARC_PLT64
, 0,4,64,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_PLT64", FALSE
,0,MINUS_ONE
, TRUE
),
226 HOWTO(R_SPARC_HIX22
, 0,4, 0,FALSE
,0,complain_overflow_bitfield
,sparc_elf_hix22_reloc
, "R_SPARC_HIX22", FALSE
,0,MINUS_ONE
, FALSE
),
227 HOWTO(R_SPARC_LOX10
, 0,4, 0,FALSE
,0,complain_overflow_dont
, sparc_elf_lox10_reloc
, "R_SPARC_LOX10", FALSE
,0,MINUS_ONE
, FALSE
),
228 HOWTO(R_SPARC_H44
, 22,2,22,FALSE
,0,complain_overflow_unsigned
,bfd_elf_generic_reloc
, "R_SPARC_H44", FALSE
,0,0x003fffff,FALSE
),
229 HOWTO(R_SPARC_M44
, 12,2,10,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_M44", FALSE
,0,0x000003ff,FALSE
),
230 HOWTO(R_SPARC_L44
, 0,2,13,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_L44", FALSE
,0,0x00000fff,FALSE
),
231 HOWTO(R_SPARC_REGISTER
, 0,4, 0,FALSE
,0,complain_overflow_bitfield
,sparc_elf_notsup_reloc
, "R_SPARC_REGISTER",FALSE
,0,MINUS_ONE
, FALSE
),
232 HOWTO(R_SPARC_UA64
, 0,4,64,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_UA64", FALSE
,0,MINUS_ONE
, TRUE
),
233 HOWTO(R_SPARC_UA16
, 0,1,16,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_UA16", FALSE
,0,0x0000ffff,TRUE
),
234 HOWTO(R_SPARC_TLS_GD_HI22
,10,2,22,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_GD_HI22",FALSE
,0,0x003fffff,TRUE
),
235 HOWTO(R_SPARC_TLS_GD_LO10
,0,2,10,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_GD_LO10",FALSE
,0,0x000003ff,TRUE
),
236 HOWTO(R_SPARC_TLS_GD_ADD
,0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_GD_ADD",FALSE
,0,0x00000000,TRUE
),
237 HOWTO(R_SPARC_TLS_GD_CALL
,2,2,30,TRUE
,0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_TLS_GD_CALL",FALSE
,0,0x3fffffff,TRUE
),
238 HOWTO(R_SPARC_TLS_LDM_HI22
,10,2,22,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_LDM_HI22",FALSE
,0,0x003fffff,TRUE
),
239 HOWTO(R_SPARC_TLS_LDM_LO10
,0,2,10,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_LDM_LO10",FALSE
,0,0x000003ff,TRUE
),
240 HOWTO(R_SPARC_TLS_LDM_ADD
,0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_LDM_ADD",FALSE
,0,0x00000000,TRUE
),
241 HOWTO(R_SPARC_TLS_LDM_CALL
,2,2,30,TRUE
,0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_TLS_LDM_CALL",FALSE
,0,0x3fffffff,TRUE
),
242 HOWTO(R_SPARC_TLS_LDO_HIX22
,0,2,0,FALSE
,0,complain_overflow_bitfield
,sparc_elf_hix22_reloc
,"R_SPARC_TLS_LDO_HIX22",FALSE
,0,0x003fffff, FALSE
),
243 HOWTO(R_SPARC_TLS_LDO_LOX10
,0,2,0,FALSE
,0,complain_overflow_dont
, sparc_elf_lox10_reloc
, "R_SPARC_TLS_LDO_LOX10",FALSE
,0,0x000003ff, FALSE
),
244 HOWTO(R_SPARC_TLS_LDO_ADD
,0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_LDO_ADD",FALSE
,0,0x00000000,TRUE
),
245 HOWTO(R_SPARC_TLS_IE_HI22
,10,2,22,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_IE_HI22",FALSE
,0,0x003fffff,TRUE
),
246 HOWTO(R_SPARC_TLS_IE_LO10
,0,2,10,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_IE_LO10",FALSE
,0,0x000003ff,TRUE
),
247 HOWTO(R_SPARC_TLS_IE_LD
,0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_IE_LD",FALSE
,0,0x00000000,TRUE
),
248 HOWTO(R_SPARC_TLS_IE_LDX
,0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_IE_LDX",FALSE
,0,0x00000000,TRUE
),
249 HOWTO(R_SPARC_TLS_IE_ADD
,0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_IE_ADD",FALSE
,0,0x00000000,TRUE
),
250 HOWTO(R_SPARC_TLS_LE_HIX22
,0,2,0,FALSE
,0,complain_overflow_bitfield
,sparc_elf_hix22_reloc
, "R_SPARC_TLS_LE_HIX22",FALSE
,0,0x003fffff, FALSE
),
251 HOWTO(R_SPARC_TLS_LE_LOX10
,0,2,0,FALSE
,0,complain_overflow_dont
, sparc_elf_lox10_reloc
, "R_SPARC_TLS_LE_LOX10",FALSE
,0,0x000003ff, FALSE
),
252 HOWTO(R_SPARC_TLS_DTPMOD32
,0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_DTPMOD32",FALSE
,0,0x00000000,TRUE
),
253 HOWTO(R_SPARC_TLS_DTPMOD64
,0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_DTPMOD64",FALSE
,0,0x00000000,TRUE
),
254 HOWTO(R_SPARC_TLS_DTPOFF32
,0,2,32,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
,"R_SPARC_TLS_DTPOFF32",FALSE
,0,0xffffffff,TRUE
),
255 HOWTO(R_SPARC_TLS_DTPOFF64
,0,4,64,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
,"R_SPARC_TLS_DTPOFF64",FALSE
,0,MINUS_ONE
,TRUE
),
256 HOWTO(R_SPARC_TLS_TPOFF32
,0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_TPOFF32",FALSE
,0,0x00000000,TRUE
),
257 HOWTO(R_SPARC_TLS_TPOFF64
,0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_TPOFF64",FALSE
,0,0x00000000,TRUE
)
259 static reloc_howto_type sparc_vtinherit_howto
=
260 HOWTO (R_SPARC_GNU_VTINHERIT
, 0,2,0,FALSE
,0,complain_overflow_dont
, NULL
, "R_SPARC_GNU_VTINHERIT", FALSE
,0, 0, FALSE
);
261 static reloc_howto_type sparc_vtentry_howto
=
262 HOWTO (R_SPARC_GNU_VTENTRY
, 0,2,0,FALSE
,0,complain_overflow_dont
, _bfd_elf_rel_vtable_reloc_fn
,"R_SPARC_GNU_VTENTRY", FALSE
,0,0, FALSE
);
263 static reloc_howto_type sparc_rev32_howto
=
264 HOWTO(R_SPARC_REV32
, 0,2,32,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_REV32", FALSE
,0,0xffffffff,TRUE
);
266 struct elf_reloc_map
{
267 bfd_reloc_code_real_type bfd_reloc_val
;
268 unsigned char elf_reloc_val
;
271 static const struct elf_reloc_map sparc_reloc_map
[] =
273 { BFD_RELOC_NONE
, R_SPARC_NONE
, },
274 { BFD_RELOC_16
, R_SPARC_16
, },
275 { BFD_RELOC_16_PCREL
, R_SPARC_DISP16
},
276 { BFD_RELOC_8
, R_SPARC_8
},
277 { BFD_RELOC_8_PCREL
, R_SPARC_DISP8
},
278 { BFD_RELOC_CTOR
, R_SPARC_64
},
279 { BFD_RELOC_32
, R_SPARC_32
},
280 { BFD_RELOC_32_PCREL
, R_SPARC_DISP32
},
281 { BFD_RELOC_HI22
, R_SPARC_HI22
},
282 { BFD_RELOC_LO10
, R_SPARC_LO10
, },
283 { BFD_RELOC_32_PCREL_S2
, R_SPARC_WDISP30
},
284 { BFD_RELOC_64_PCREL
, R_SPARC_DISP64
},
285 { BFD_RELOC_SPARC22
, R_SPARC_22
},
286 { BFD_RELOC_SPARC13
, R_SPARC_13
},
287 { BFD_RELOC_SPARC_GOT10
, R_SPARC_GOT10
},
288 { BFD_RELOC_SPARC_GOT13
, R_SPARC_GOT13
},
289 { BFD_RELOC_SPARC_GOT22
, R_SPARC_GOT22
},
290 { BFD_RELOC_SPARC_PC10
, R_SPARC_PC10
},
291 { BFD_RELOC_SPARC_PC22
, R_SPARC_PC22
},
292 { BFD_RELOC_SPARC_WPLT30
, R_SPARC_WPLT30
},
293 { BFD_RELOC_SPARC_COPY
, R_SPARC_COPY
},
294 { BFD_RELOC_SPARC_GLOB_DAT
, R_SPARC_GLOB_DAT
},
295 { BFD_RELOC_SPARC_JMP_SLOT
, R_SPARC_JMP_SLOT
},
296 { BFD_RELOC_SPARC_RELATIVE
, R_SPARC_RELATIVE
},
297 { BFD_RELOC_SPARC_WDISP22
, R_SPARC_WDISP22
},
298 { BFD_RELOC_SPARC_UA16
, R_SPARC_UA16
},
299 { BFD_RELOC_SPARC_UA32
, R_SPARC_UA32
},
300 { BFD_RELOC_SPARC_UA64
, R_SPARC_UA64
},
301 { BFD_RELOC_SPARC_10
, R_SPARC_10
},
302 { BFD_RELOC_SPARC_11
, R_SPARC_11
},
303 { BFD_RELOC_SPARC_64
, R_SPARC_64
},
304 { BFD_RELOC_SPARC_OLO10
, R_SPARC_OLO10
},
305 { BFD_RELOC_SPARC_HH22
, R_SPARC_HH22
},
306 { BFD_RELOC_SPARC_HM10
, R_SPARC_HM10
},
307 { BFD_RELOC_SPARC_LM22
, R_SPARC_LM22
},
308 { BFD_RELOC_SPARC_PC_HH22
, R_SPARC_PC_HH22
},
309 { BFD_RELOC_SPARC_PC_HM10
, R_SPARC_PC_HM10
},
310 { BFD_RELOC_SPARC_PC_LM22
, R_SPARC_PC_LM22
},
311 { BFD_RELOC_SPARC_WDISP16
, R_SPARC_WDISP16
},
312 { BFD_RELOC_SPARC_WDISP19
, R_SPARC_WDISP19
},
313 { BFD_RELOC_SPARC_7
, R_SPARC_7
},
314 { BFD_RELOC_SPARC_5
, R_SPARC_5
},
315 { BFD_RELOC_SPARC_6
, R_SPARC_6
},
316 { BFD_RELOC_SPARC_DISP64
, R_SPARC_DISP64
},
317 { BFD_RELOC_SPARC_TLS_GD_HI22
, R_SPARC_TLS_GD_HI22
},
318 { BFD_RELOC_SPARC_TLS_GD_LO10
, R_SPARC_TLS_GD_LO10
},
319 { BFD_RELOC_SPARC_TLS_GD_ADD
, R_SPARC_TLS_GD_ADD
},
320 { BFD_RELOC_SPARC_TLS_GD_CALL
, R_SPARC_TLS_GD_CALL
},
321 { BFD_RELOC_SPARC_TLS_LDM_HI22
, R_SPARC_TLS_LDM_HI22
},
322 { BFD_RELOC_SPARC_TLS_LDM_LO10
, R_SPARC_TLS_LDM_LO10
},
323 { BFD_RELOC_SPARC_TLS_LDM_ADD
, R_SPARC_TLS_LDM_ADD
},
324 { BFD_RELOC_SPARC_TLS_LDM_CALL
, R_SPARC_TLS_LDM_CALL
},
325 { BFD_RELOC_SPARC_TLS_LDO_HIX22
, R_SPARC_TLS_LDO_HIX22
},
326 { BFD_RELOC_SPARC_TLS_LDO_LOX10
, R_SPARC_TLS_LDO_LOX10
},
327 { BFD_RELOC_SPARC_TLS_LDO_ADD
, R_SPARC_TLS_LDO_ADD
},
328 { BFD_RELOC_SPARC_TLS_IE_HI22
, R_SPARC_TLS_IE_HI22
},
329 { BFD_RELOC_SPARC_TLS_IE_LO10
, R_SPARC_TLS_IE_LO10
},
330 { BFD_RELOC_SPARC_TLS_IE_LD
, R_SPARC_TLS_IE_LD
},
331 { BFD_RELOC_SPARC_TLS_IE_LDX
, R_SPARC_TLS_IE_LDX
},
332 { BFD_RELOC_SPARC_TLS_IE_ADD
, R_SPARC_TLS_IE_ADD
},
333 { BFD_RELOC_SPARC_TLS_LE_HIX22
, R_SPARC_TLS_LE_HIX22
},
334 { BFD_RELOC_SPARC_TLS_LE_LOX10
, R_SPARC_TLS_LE_LOX10
},
335 { BFD_RELOC_SPARC_TLS_DTPMOD32
, R_SPARC_TLS_DTPMOD32
},
336 { BFD_RELOC_SPARC_TLS_DTPMOD64
, R_SPARC_TLS_DTPMOD64
},
337 { BFD_RELOC_SPARC_TLS_DTPOFF32
, R_SPARC_TLS_DTPOFF32
},
338 { BFD_RELOC_SPARC_TLS_DTPOFF64
, R_SPARC_TLS_DTPOFF64
},
339 { BFD_RELOC_SPARC_TLS_TPOFF32
, R_SPARC_TLS_TPOFF32
},
340 { BFD_RELOC_SPARC_TLS_TPOFF64
, R_SPARC_TLS_TPOFF64
},
341 { BFD_RELOC_SPARC_PLT32
, R_SPARC_PLT32
},
342 { BFD_RELOC_SPARC_PLT64
, R_SPARC_PLT64
},
343 { BFD_RELOC_SPARC_HIX22
, R_SPARC_HIX22
},
344 { BFD_RELOC_SPARC_LOX10
, R_SPARC_LOX10
},
345 { BFD_RELOC_SPARC_H44
, R_SPARC_H44
},
346 { BFD_RELOC_SPARC_M44
, R_SPARC_M44
},
347 { BFD_RELOC_SPARC_L44
, R_SPARC_L44
},
348 { BFD_RELOC_SPARC_REGISTER
, R_SPARC_REGISTER
},
349 { BFD_RELOC_VTABLE_INHERIT
, R_SPARC_GNU_VTINHERIT
},
350 { BFD_RELOC_VTABLE_ENTRY
, R_SPARC_GNU_VTENTRY
},
351 { BFD_RELOC_SPARC_REV32
, R_SPARC_REV32
},
355 _bfd_sparc_elf_reloc_type_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
356 bfd_reloc_code_real_type code
)
362 case BFD_RELOC_VTABLE_INHERIT
:
363 return &sparc_vtinherit_howto
;
365 case BFD_RELOC_VTABLE_ENTRY
:
366 return &sparc_vtentry_howto
;
368 case BFD_RELOC_SPARC_REV32
:
369 return &sparc_rev32_howto
;
373 i
< sizeof (sparc_reloc_map
) / sizeof (struct elf_reloc_map
);
376 if (sparc_reloc_map
[i
].bfd_reloc_val
== code
)
377 return (_bfd_sparc_elf_howto_table
378 + (int) sparc_reloc_map
[i
].elf_reloc_val
);
381 bfd_set_error (bfd_error_bad_value
);
386 _bfd_sparc_elf_info_to_howto_ptr (unsigned int r_type
)
390 case R_SPARC_GNU_VTINHERIT
:
391 return &sparc_vtinherit_howto
;
393 case R_SPARC_GNU_VTENTRY
:
394 return &sparc_vtentry_howto
;
397 return &sparc_rev32_howto
;
400 if (r_type
>= (unsigned int) R_SPARC_max_std
)
402 (*_bfd_error_handler
) (_("invalid relocation type %d"),
404 r_type
= R_SPARC_NONE
;
406 return &_bfd_sparc_elf_howto_table
[r_type
];
410 /* Both 32-bit and 64-bit sparc encode this in an identical manner,
411 so just take advantage of that. */
412 #define SPARC_ELF_R_TYPE(r_info) \
416 _bfd_sparc_elf_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*cache_ptr
,
417 Elf_Internal_Rela
*dst
)
419 unsigned int r_type
= SPARC_ELF_R_TYPE (dst
->r_info
);
421 cache_ptr
->howto
= _bfd_sparc_elf_info_to_howto_ptr (r_type
);
425 /* The nop opcode we use. */
426 #define SPARC_NOP 0x01000000
428 #define SPARC_INSN_BYTES 4
430 /* The SPARC linker needs to keep track of the number of relocs that it
431 decides to copy as dynamic relocs in check_relocs for each symbol.
432 This is so that it can later discard them if they are found to be
433 unnecessary. We store the information in a field extending the
434 regular ELF linker hash table. */
436 struct _bfd_sparc_elf_dyn_relocs
438 struct _bfd_sparc_elf_dyn_relocs
*next
;
440 /* The input section of the reloc. */
443 /* Total number of relocs copied for the input section. */
446 /* Number of pc-relative relocs copied for the input section. */
447 bfd_size_type pc_count
;
450 /* SPARC ELF linker hash entry. */
452 struct _bfd_sparc_elf_link_hash_entry
454 struct elf_link_hash_entry elf
;
456 /* Track dynamic relocs copied for this symbol. */
457 struct _bfd_sparc_elf_dyn_relocs
*dyn_relocs
;
459 #define GOT_UNKNOWN 0
463 unsigned char tls_type
;
466 #define _bfd_sparc_elf_hash_entry(ent) ((struct _bfd_sparc_elf_link_hash_entry *)(ent))
468 struct _bfd_sparc_elf_obj_tdata
470 struct elf_obj_tdata root
;
472 /* tls_type for each local got entry. */
473 char *local_got_tls_type
;
475 /* TRUE if TLS GD relocs has been seen for this object. */
476 bfd_boolean has_tlsgd
;
479 #define _bfd_sparc_elf_tdata(abfd) \
480 ((struct _bfd_sparc_elf_obj_tdata *) (abfd)->tdata.any)
482 #define _bfd_sparc_elf_local_got_tls_type(abfd) \
483 (_bfd_sparc_elf_tdata (abfd)->local_got_tls_type)
486 _bfd_sparc_elf_mkobject (bfd
*abfd
)
488 bfd_size_type amt
= sizeof (struct _bfd_sparc_elf_obj_tdata
);
489 abfd
->tdata
.any
= bfd_zalloc (abfd
, amt
);
490 if (abfd
->tdata
.any
== NULL
)
496 sparc_put_word_32 (bfd
*bfd
, bfd_vma val
, void *ptr
)
498 bfd_put_32 (bfd
, val
, ptr
);
502 sparc_put_word_64 (bfd
*bfd
, bfd_vma val
, void *ptr
)
504 bfd_put_64 (bfd
, val
, ptr
);
508 sparc_elf_append_rela_64 (bfd
*abfd ATTRIBUTE_UNUSED
,
509 asection
*s ATTRIBUTE_UNUSED
,
510 Elf_Internal_Rela
*rel ATTRIBUTE_UNUSED
)
513 Elf64_External_Rela
*loc64
;
515 loc64
= (Elf64_External_Rela
*) s
->contents
;
516 loc64
+= s
->reloc_count
++;
517 bfd_elf64_swap_reloca_out (abfd
, rel
, (bfd_byte
*) loc64
);
522 sparc_elf_append_rela_32 (bfd
*abfd
, asection
*s
, Elf_Internal_Rela
*rel
)
524 Elf32_External_Rela
*loc32
;
526 loc32
= (Elf32_External_Rela
*) s
->contents
;
527 loc32
+= s
->reloc_count
++;
528 bfd_elf32_swap_reloca_out (abfd
, rel
, (bfd_byte
*) loc32
);
532 sparc_elf_r_info_64 (Elf_Internal_Rela
*in_rel ATTRIBUTE_UNUSED
,
533 bfd_vma index ATTRIBUTE_UNUSED
,
534 bfd_vma type ATTRIBUTE_UNUSED
)
536 return ELF64_R_INFO (index
,
538 ELF64_R_TYPE_INFO (ELF64_R_TYPE_DATA (in_rel
->r_info
),
543 sparc_elf_r_info_32 (Elf_Internal_Rela
*in_rel ATTRIBUTE_UNUSED
,
544 bfd_vma index
, bfd_vma type
)
546 return ELF32_R_INFO (index
, type
);
550 sparc_elf_r_symndx_64 (bfd_vma r_info
)
552 bfd_vma r_symndx
= ELF32_R_SYM (r_info
);
553 return (r_symndx
>> 24);
557 sparc_elf_r_symndx_32 (bfd_vma r_info
)
559 return ELF32_R_SYM (r_info
);
564 #define PLT32_ENTRY_SIZE 12
565 #define PLT32_HEADER_SIZE (4 * PLT32_ENTRY_SIZE)
567 /* The first four entries in a 32-bit procedure linkage table are reserved,
568 and the initial contents are unimportant (we zero them out).
569 Subsequent entries look like this. See the SVR4 ABI SPARC
570 supplement to see how this works. */
572 /* sethi %hi(.-.plt0),%g1. We fill in the address later. */
573 #define PLT32_ENTRY_WORD0 0x03000000
574 /* b,a .plt0. We fill in the offset later. */
575 #define PLT32_ENTRY_WORD1 0x30800000
577 #define PLT32_ENTRY_WORD2 SPARC_NOP
580 sparc32_plt_entry_build (bfd
*output_bfd
, asection
*splt
, bfd_vma offset
,
581 bfd_vma max ATTRIBUTE_UNUSED
,
584 bfd_put_32 (output_bfd
,
585 PLT32_ENTRY_WORD0
+ offset
,
586 splt
->contents
+ offset
);
587 bfd_put_32 (output_bfd
,
589 + (((- (offset
+ 4)) >> 2) & 0x3fffff)),
590 splt
->contents
+ offset
+ 4);
591 bfd_put_32 (output_bfd
, (bfd_vma
) PLT32_ENTRY_WORD2
,
592 splt
->contents
+ offset
+ 8);
596 return offset
/ PLT32_ENTRY_SIZE
- 4;
599 /* Both the headers and the entries are icache aligned. */
600 #define PLT64_ENTRY_SIZE 32
601 #define PLT64_HEADER_SIZE (4 * PLT64_ENTRY_SIZE)
602 #define PLT64_LARGE_THRESHOLD 32768
605 sparc64_plt_entry_build (bfd
*output_bfd
, asection
*splt
, bfd_vma offset
,
606 bfd_vma max
, bfd_vma
*r_offset
)
608 unsigned char *entry
= splt
->contents
+ offset
;
609 const unsigned int nop
= SPARC_NOP
;
612 if (offset
< (PLT64_LARGE_THRESHOLD
* PLT64_ENTRY_SIZE
))
614 unsigned int sethi
, ba
;
618 index
= (offset
/ PLT64_ENTRY_SIZE
);
620 sethi
= 0x03000000 | (index
* PLT64_ENTRY_SIZE
);
622 | (((splt
->contents
+ PLT64_ENTRY_SIZE
) - (entry
+ 4)) / 4 & 0x7ffff);
624 bfd_put_32 (output_bfd
, (bfd_vma
) sethi
, entry
);
625 bfd_put_32 (output_bfd
, (bfd_vma
) ba
, entry
+ 4);
626 bfd_put_32 (output_bfd
, (bfd_vma
) nop
, entry
+ 8);
627 bfd_put_32 (output_bfd
, (bfd_vma
) nop
, entry
+ 12);
628 bfd_put_32 (output_bfd
, (bfd_vma
) nop
, entry
+ 16);
629 bfd_put_32 (output_bfd
, (bfd_vma
) nop
, entry
+ 20);
630 bfd_put_32 (output_bfd
, (bfd_vma
) nop
, entry
+ 24);
631 bfd_put_32 (output_bfd
, (bfd_vma
) nop
, entry
+ 28);
637 int block
, last_block
, ofs
, last_ofs
, chunks_this_block
;
638 const int insn_chunk_size
= (6 * 4);
639 const int ptr_chunk_size
= (1 * 8);
640 const int entries_per_block
= 160;
641 const int block_size
= entries_per_block
* (insn_chunk_size
644 /* Entries 32768 and higher are grouped into blocks of 160.
645 The blocks are further subdivided into 160 sequences of
646 6 instructions and 160 pointers. If a block does not require
647 the full 160 entries, let's say it requires N, then there
648 will be N sequences of 6 instructions and N pointers. */
650 offset
-= (PLT64_LARGE_THRESHOLD
* PLT64_ENTRY_SIZE
);
651 max
-= (PLT64_LARGE_THRESHOLD
* PLT64_ENTRY_SIZE
);
653 block
= offset
/ block_size
;
654 last_block
= max
/ block_size
;
655 if (block
!= last_block
)
657 chunks_this_block
= 160;
661 last_ofs
= max
% block_size
;
662 chunks_this_block
= last_ofs
/ (insn_chunk_size
+ ptr_chunk_size
);
665 ofs
= offset
% block_size
;
667 index
= (PLT64_LARGE_THRESHOLD
+
669 (ofs
/ insn_chunk_size
));
672 + (PLT64_LARGE_THRESHOLD
* PLT64_ENTRY_SIZE
)
673 + (block
* block_size
)
674 + (chunks_this_block
* insn_chunk_size
)
675 + (ofs
/ insn_chunk_size
) * ptr_chunk_size
;
677 *r_offset
= (bfd_vma
) (ptr
- splt
->contents
);
679 ldx
= 0xc25be000 | ((ptr
- (entry
+4)) & 0x1fff);
687 bfd_put_32 (output_bfd
, (bfd_vma
) 0x8a10000f, entry
);
688 bfd_put_32 (output_bfd
, (bfd_vma
) 0x40000002, entry
+ 4);
689 bfd_put_32 (output_bfd
, (bfd_vma
) SPARC_NOP
, entry
+ 8);
690 bfd_put_32 (output_bfd
, (bfd_vma
) ldx
, entry
+ 12);
691 bfd_put_32 (output_bfd
, (bfd_vma
) 0x83c3c001, entry
+ 16);
692 bfd_put_32 (output_bfd
, (bfd_vma
) 0x9e100005, entry
+ 20);
694 bfd_put_64 (output_bfd
, (bfd_vma
) (splt
->contents
- (entry
+ 4)), ptr
);
700 #define SPARC_ELF_PUT_WORD(htab, bfd, val, ptr) \
701 htab->put_word(bfd, val, ptr)
703 #define SPARC_ELF_APPEND_RELA(htab, bfd, sec, rela) \
704 htab->append_rela(bfd, sec, rela)
706 #define SPARC_ELF_R_INFO(htab, in_rel, index, type) \
707 htab->r_info(in_rel, index, type)
709 #define SPARC_ELF_R_SYMNDX(htab, r_info) \
710 htab->r_symndx(r_info)
712 #define SPARC_ELF_WORD_BYTES(htab) \
715 #define SPARC_ELF_RELA_BYTES(htab) \
718 #define SPARC_ELF_DTPOFF_RELOC(htab) \
721 #define SPARC_ELF_DTPMOD_RELOC(htab) \
724 #define SPARC_ELF_TPOFF_RELOC(htab) \
727 #define SPARC_ELF_BUILD_PLT_ENTRY(htab, obfd, splt, off, max, r_off) \
728 htab->build_plt_entry (obfd, splt, off, max, r_off)
730 /* Create an entry in an SPARC ELF linker hash table. */
732 static struct bfd_hash_entry
*
733 link_hash_newfunc (struct bfd_hash_entry
*entry
,
734 struct bfd_hash_table
*table
, const char *string
)
736 /* Allocate the structure if it has not already been allocated by a
740 entry
= bfd_hash_allocate (table
,
741 sizeof (struct _bfd_sparc_elf_link_hash_entry
));
746 /* Call the allocation method of the superclass. */
747 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
750 struct _bfd_sparc_elf_link_hash_entry
*eh
;
752 eh
= (struct _bfd_sparc_elf_link_hash_entry
*) entry
;
753 eh
->dyn_relocs
= NULL
;
754 eh
->tls_type
= GOT_UNKNOWN
;
760 /* The name of the dynamic interpreter. This is put in the .interp
763 #define ELF32_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
764 #define ELF64_DYNAMIC_INTERPRETER "/usr/lib/sparcv9/ld.so.1"
766 /* Create a SPARC ELF linker hash table. */
768 struct bfd_link_hash_table
*
769 _bfd_sparc_elf_link_hash_table_create (bfd
*abfd
)
771 struct _bfd_sparc_elf_link_hash_table
*ret
;
772 bfd_size_type amt
= sizeof (struct _bfd_sparc_elf_link_hash_table
);
774 ret
= (struct _bfd_sparc_elf_link_hash_table
*) bfd_zmalloc (amt
);
780 ret
->put_word
= sparc_put_word_64
;
781 ret
->append_rela
= sparc_elf_append_rela_64
;
782 ret
->r_info
= sparc_elf_r_info_64
;
783 ret
->r_symndx
= sparc_elf_r_symndx_64
;
784 ret
->build_plt_entry
= sparc64_plt_entry_build
;
785 ret
->dtpoff_reloc
= R_SPARC_TLS_DTPOFF64
;
786 ret
->dtpmod_reloc
= R_SPARC_TLS_DTPMOD64
;
787 ret
->tpoff_reloc
= R_SPARC_TLS_TPOFF64
;
788 ret
->word_align_power
= 3;
789 ret
->align_power_max
= 4;
790 ret
->bytes_per_word
= 8;
791 ret
->bytes_per_rela
= sizeof (Elf64_External_Rela
);
792 ret
->dynamic_interpreter
= ELF64_DYNAMIC_INTERPRETER
;
793 ret
->dynamic_interpreter_size
= sizeof ELF64_DYNAMIC_INTERPRETER
;
797 ret
->put_word
= sparc_put_word_32
;
798 ret
->append_rela
= sparc_elf_append_rela_32
;
799 ret
->r_info
= sparc_elf_r_info_32
;
800 ret
->r_symndx
= sparc_elf_r_symndx_32
;
801 ret
->build_plt_entry
= sparc32_plt_entry_build
;
802 ret
->dtpoff_reloc
= R_SPARC_TLS_DTPOFF32
;
803 ret
->dtpmod_reloc
= R_SPARC_TLS_DTPMOD32
;
804 ret
->tpoff_reloc
= R_SPARC_TLS_TPOFF32
;
805 ret
->word_align_power
= 2;
806 ret
->align_power_max
= 3;
807 ret
->bytes_per_word
= 4;
808 ret
->bytes_per_rela
= sizeof (Elf32_External_Rela
);
809 ret
->dynamic_interpreter
= ELF32_DYNAMIC_INTERPRETER
;
810 ret
->dynamic_interpreter_size
= sizeof ELF32_DYNAMIC_INTERPRETER
;
813 if (! _bfd_elf_link_hash_table_init (&ret
->elf
, abfd
, link_hash_newfunc
))
819 return &ret
->elf
.root
;
822 /* Create .got and .rela.got sections in DYNOBJ, and set up
823 shortcuts to them in our hash table. */
826 create_got_section (bfd
*dynobj
, struct bfd_link_info
*info
)
828 struct _bfd_sparc_elf_link_hash_table
*htab
;
830 if (! _bfd_elf_create_got_section (dynobj
, info
))
833 htab
= _bfd_sparc_elf_hash_table (info
);
834 htab
->sgot
= bfd_get_section_by_name (dynobj
, ".got");
835 BFD_ASSERT (htab
->sgot
!= NULL
);
837 htab
->srelgot
= bfd_make_section_with_flags (dynobj
, ".rela.got",
844 if (htab
->srelgot
== NULL
845 || ! bfd_set_section_alignment (dynobj
, htab
->srelgot
,
846 htab
->word_align_power
))
851 /* Create .plt, .rela.plt, .got, .rela.got, .dynbss, and
852 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
856 _bfd_sparc_elf_create_dynamic_sections (bfd
*dynobj
,
857 struct bfd_link_info
*info
)
859 struct _bfd_sparc_elf_link_hash_table
*htab
;
861 htab
= _bfd_sparc_elf_hash_table (info
);
862 if (!htab
->sgot
&& !create_got_section (dynobj
, info
))
865 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
868 htab
->splt
= bfd_get_section_by_name (dynobj
, ".plt");
869 htab
->srelplt
= bfd_get_section_by_name (dynobj
, ".rela.plt");
870 htab
->sdynbss
= bfd_get_section_by_name (dynobj
, ".dynbss");
872 htab
->srelbss
= bfd_get_section_by_name (dynobj
, ".rela.bss");
874 if (!htab
->splt
|| !htab
->srelplt
|| !htab
->sdynbss
875 || (!info
->shared
&& !htab
->srelbss
))
881 /* Copy the extra info we tack onto an elf_link_hash_entry. */
884 _bfd_sparc_elf_copy_indirect_symbol (const struct elf_backend_data
*bed
,
885 struct elf_link_hash_entry
*dir
,
886 struct elf_link_hash_entry
*ind
)
888 struct _bfd_sparc_elf_link_hash_entry
*edir
, *eind
;
890 edir
= (struct _bfd_sparc_elf_link_hash_entry
*) dir
;
891 eind
= (struct _bfd_sparc_elf_link_hash_entry
*) ind
;
893 if (eind
->dyn_relocs
!= NULL
)
895 if (edir
->dyn_relocs
!= NULL
)
897 struct _bfd_sparc_elf_dyn_relocs
**pp
;
898 struct _bfd_sparc_elf_dyn_relocs
*p
;
900 if (ind
->root
.type
== bfd_link_hash_indirect
)
903 /* Add reloc counts against the weak sym to the strong sym
904 list. Merge any entries against the same section. */
905 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
907 struct _bfd_sparc_elf_dyn_relocs
*q
;
909 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
910 if (q
->sec
== p
->sec
)
912 q
->pc_count
+= p
->pc_count
;
913 q
->count
+= p
->count
;
920 *pp
= edir
->dyn_relocs
;
923 edir
->dyn_relocs
= eind
->dyn_relocs
;
924 eind
->dyn_relocs
= NULL
;
927 if (ind
->root
.type
== bfd_link_hash_indirect
928 && dir
->got
.refcount
<= 0)
930 edir
->tls_type
= eind
->tls_type
;
931 eind
->tls_type
= GOT_UNKNOWN
;
933 _bfd_elf_link_hash_copy_indirect (bed
, dir
, ind
);
937 sparc_elf_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
938 int r_type
, int is_local
)
940 if (! ABI_64_P (abfd
)
941 && r_type
== R_SPARC_TLS_GD_HI22
942 && ! _bfd_sparc_elf_tdata (abfd
)->has_tlsgd
)
943 r_type
= R_SPARC_REV32
;
950 case R_SPARC_TLS_GD_HI22
:
952 return R_SPARC_TLS_LE_HIX22
;
953 return R_SPARC_TLS_IE_HI22
;
954 case R_SPARC_TLS_GD_LO10
:
956 return R_SPARC_TLS_LE_LOX10
;
957 return R_SPARC_TLS_IE_LO10
;
958 case R_SPARC_TLS_IE_HI22
:
960 return R_SPARC_TLS_LE_HIX22
;
962 case R_SPARC_TLS_IE_LO10
:
964 return R_SPARC_TLS_LE_LOX10
;
966 case R_SPARC_TLS_LDM_HI22
:
967 return R_SPARC_TLS_LE_HIX22
;
968 case R_SPARC_TLS_LDM_LO10
:
969 return R_SPARC_TLS_LE_LOX10
;
975 /* Look through the relocs for a section during the first phase, and
976 allocate space in the global offset table or procedure linkage
980 _bfd_sparc_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
981 asection
*sec
, const Elf_Internal_Rela
*relocs
)
983 struct _bfd_sparc_elf_link_hash_table
*htab
;
984 Elf_Internal_Shdr
*symtab_hdr
;
985 struct elf_link_hash_entry
**sym_hashes
;
986 bfd_vma
*local_got_offsets
;
987 const Elf_Internal_Rela
*rel
;
988 const Elf_Internal_Rela
*rel_end
;
991 bfd_boolean checked_tlsgd
= FALSE
;
993 if (info
->relocatable
)
996 htab
= _bfd_sparc_elf_hash_table (info
);
997 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
998 sym_hashes
= elf_sym_hashes (abfd
);
999 local_got_offsets
= elf_local_got_offsets (abfd
);
1003 if (ABI_64_P (abfd
))
1004 num_relocs
= NUM_SHDR_ENTRIES (& elf_section_data (sec
)->rel_hdr
);
1006 num_relocs
= sec
->reloc_count
;
1007 rel_end
= relocs
+ num_relocs
;
1008 for (rel
= relocs
; rel
< rel_end
; rel
++)
1010 unsigned int r_type
;
1011 unsigned long r_symndx
;
1012 struct elf_link_hash_entry
*h
;
1014 r_symndx
= SPARC_ELF_R_SYMNDX (htab
, rel
->r_info
);
1015 r_type
= SPARC_ELF_R_TYPE (rel
->r_info
);
1017 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1019 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
1024 if (r_symndx
< symtab_hdr
->sh_info
)
1028 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1029 while (h
->root
.type
== bfd_link_hash_indirect
1030 || h
->root
.type
== bfd_link_hash_warning
)
1031 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1034 /* Compatibility with old R_SPARC_REV32 reloc conflicting
1035 with R_SPARC_TLS_GD_HI22. */
1036 if (! ABI_64_P (abfd
) && ! checked_tlsgd
)
1039 case R_SPARC_TLS_GD_HI22
:
1041 const Elf_Internal_Rela
*relt
;
1043 for (relt
= rel
+ 1; relt
< rel_end
; relt
++)
1044 if (ELF32_R_TYPE (relt
->r_info
) == R_SPARC_TLS_GD_LO10
1045 || ELF32_R_TYPE (relt
->r_info
) == R_SPARC_TLS_GD_ADD
1046 || ELF32_R_TYPE (relt
->r_info
) == R_SPARC_TLS_GD_CALL
)
1048 checked_tlsgd
= TRUE
;
1049 _bfd_sparc_elf_tdata (abfd
)->has_tlsgd
= relt
< rel_end
;
1052 case R_SPARC_TLS_GD_LO10
:
1053 case R_SPARC_TLS_GD_ADD
:
1054 case R_SPARC_TLS_GD_CALL
:
1055 checked_tlsgd
= TRUE
;
1056 _bfd_sparc_elf_tdata (abfd
)->has_tlsgd
= TRUE
;
1060 r_type
= sparc_elf_tls_transition (info
, abfd
, r_type
, h
== NULL
);
1063 case R_SPARC_TLS_LDM_HI22
:
1064 case R_SPARC_TLS_LDM_LO10
:
1065 htab
->tls_ldm_got
.refcount
+= 1;
1068 case R_SPARC_TLS_LE_HIX22
:
1069 case R_SPARC_TLS_LE_LOX10
:
1074 case R_SPARC_TLS_IE_HI22
:
1075 case R_SPARC_TLS_IE_LO10
:
1077 info
->flags
|= DF_STATIC_TLS
;
1083 case R_SPARC_TLS_GD_HI22
:
1084 case R_SPARC_TLS_GD_LO10
:
1085 /* This symbol requires a global offset table entry. */
1087 int tls_type
, old_tls_type
;
1095 tls_type
= GOT_NORMAL
;
1097 case R_SPARC_TLS_GD_HI22
:
1098 case R_SPARC_TLS_GD_LO10
:
1099 tls_type
= GOT_TLS_GD
;
1101 case R_SPARC_TLS_IE_HI22
:
1102 case R_SPARC_TLS_IE_LO10
:
1103 tls_type
= GOT_TLS_IE
;
1109 h
->got
.refcount
+= 1;
1110 old_tls_type
= _bfd_sparc_elf_hash_entry(h
)->tls_type
;
1114 bfd_signed_vma
*local_got_refcounts
;
1116 /* This is a global offset table entry for a local symbol. */
1117 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1118 if (local_got_refcounts
== NULL
)
1122 size
= symtab_hdr
->sh_info
;
1123 size
*= (sizeof (bfd_signed_vma
) + sizeof(char));
1124 local_got_refcounts
= ((bfd_signed_vma
*)
1125 bfd_zalloc (abfd
, size
));
1126 if (local_got_refcounts
== NULL
)
1128 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1129 _bfd_sparc_elf_local_got_tls_type (abfd
)
1130 = (char *) (local_got_refcounts
+ symtab_hdr
->sh_info
);
1132 local_got_refcounts
[r_symndx
] += 1;
1133 old_tls_type
= _bfd_sparc_elf_local_got_tls_type (abfd
) [r_symndx
];
1136 /* If a TLS symbol is accessed using IE at least once,
1137 there is no point to use dynamic model for it. */
1138 if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1139 && (old_tls_type
!= GOT_TLS_GD
1140 || tls_type
!= GOT_TLS_IE
))
1142 if (old_tls_type
== GOT_TLS_IE
&& tls_type
== GOT_TLS_GD
)
1143 tls_type
= old_tls_type
;
1146 (*_bfd_error_handler
)
1147 (_("%B: `%s' accessed both as normal and thread local symbol"),
1148 abfd
, h
? h
->root
.root
.string
: "<local>");
1153 if (old_tls_type
!= tls_type
)
1156 _bfd_sparc_elf_hash_entry (h
)->tls_type
= tls_type
;
1158 _bfd_sparc_elf_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1162 if (htab
->sgot
== NULL
)
1164 if (htab
->elf
.dynobj
== NULL
)
1165 htab
->elf
.dynobj
= abfd
;
1166 if (!create_got_section (htab
->elf
.dynobj
, info
))
1171 case R_SPARC_TLS_GD_CALL
:
1172 case R_SPARC_TLS_LDM_CALL
:
1175 /* These are basically R_SPARC_TLS_WPLT30 relocs against
1177 struct bfd_link_hash_entry
*bh
= NULL
;
1178 if (! _bfd_generic_link_add_one_symbol (info
, abfd
,
1179 "__tls_get_addr", 0,
1180 bfd_und_section_ptr
, 0,
1184 h
= (struct elf_link_hash_entry
*) bh
;
1191 case R_SPARC_WPLT30
:
1192 case R_SPARC_HIPLT22
:
1193 case R_SPARC_LOPLT10
:
1194 case R_SPARC_PCPLT32
:
1195 case R_SPARC_PCPLT22
:
1196 case R_SPARC_PCPLT10
:
1198 /* This symbol requires a procedure linkage table entry. We
1199 actually build the entry in adjust_dynamic_symbol,
1200 because this might be a case of linking PIC code without
1201 linking in any dynamic objects, in which case we don't
1202 need to generate a procedure linkage table after all. */
1206 if (! ABI_64_P (abfd
))
1208 /* The Solaris native assembler will generate a WPLT30
1209 reloc for a local symbol if you assemble a call from
1210 one section to another when using -K pic. We treat
1212 if (ELF32_R_TYPE (rel
->r_info
) == R_SPARC_PLT32
)
1217 /* It does not make sense to have a procedure linkage
1218 table entry for a local symbol. */
1219 bfd_set_error (bfd_error_bad_value
);
1228 this_r_type
= SPARC_ELF_R_TYPE (rel
->r_info
);
1229 if (this_r_type
== R_SPARC_PLT32
1230 || this_r_type
== R_SPARC_PLT64
)
1233 h
->plt
.refcount
+= 1;
1238 case R_SPARC_PC_HH22
:
1239 case R_SPARC_PC_HM10
:
1240 case R_SPARC_PC_LM22
:
1245 && strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
1250 case R_SPARC_DISP16
:
1251 case R_SPARC_DISP32
:
1252 case R_SPARC_DISP64
:
1253 case R_SPARC_WDISP30
:
1254 case R_SPARC_WDISP22
:
1255 case R_SPARC_WDISP19
:
1256 case R_SPARC_WDISP16
:
1286 if (h
!= NULL
&& !info
->shared
)
1288 /* We may need a .plt entry if the function this reloc
1289 refers to is in a shared lib. */
1290 h
->plt
.refcount
+= 1;
1293 /* If we are creating a shared library, and this is a reloc
1294 against a global symbol, or a non PC relative reloc
1295 against a local symbol, then we need to copy the reloc
1296 into the shared library. However, if we are linking with
1297 -Bsymbolic, we do not need to copy a reloc against a
1298 global symbol which is defined in an object we are
1299 including in the link (i.e., DEF_REGULAR is set). At
1300 this point we have not seen all the input files, so it is
1301 possible that DEF_REGULAR is not set now but will be set
1302 later (it is never cleared). In case of a weak definition,
1303 DEF_REGULAR may be cleared later by a strong definition in
1304 a shared library. We account for that possibility below by
1305 storing information in the relocs_copied field of the hash
1306 table entry. A similar situation occurs when creating
1307 shared libraries and symbol visibility changes render the
1310 If on the other hand, we are creating an executable, we
1311 may need to keep relocations for symbols satisfied by a
1312 dynamic library if we manage to avoid copy relocs for the
1315 && (sec
->flags
& SEC_ALLOC
) != 0
1316 && (! _bfd_sparc_elf_howto_table
[r_type
].pc_relative
1318 && (! info
->symbolic
1319 || h
->root
.type
== bfd_link_hash_defweak
1320 || !h
->def_regular
))))
1322 && (sec
->flags
& SEC_ALLOC
) != 0
1324 && (h
->root
.type
== bfd_link_hash_defweak
1325 || !h
->def_regular
)))
1327 struct _bfd_sparc_elf_dyn_relocs
*p
;
1328 struct _bfd_sparc_elf_dyn_relocs
**head
;
1330 /* When creating a shared object, we must copy these
1331 relocs into the output file. We create a reloc
1332 section in dynobj and make room for the reloc. */
1338 name
= (bfd_elf_string_from_elf_section
1340 elf_elfheader (abfd
)->e_shstrndx
,
1341 elf_section_data (sec
)->rel_hdr
.sh_name
));
1345 BFD_ASSERT (strncmp (name
, ".rela", 5) == 0
1346 && strcmp (bfd_get_section_name (abfd
, sec
),
1349 if (htab
->elf
.dynobj
== NULL
)
1350 htab
->elf
.dynobj
= abfd
;
1351 dynobj
= htab
->elf
.dynobj
;
1353 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1358 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
1359 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
1360 if ((sec
->flags
& SEC_ALLOC
) != 0)
1361 flags
|= SEC_ALLOC
| SEC_LOAD
;
1362 sreloc
= bfd_make_section_with_flags (dynobj
,
1366 || ! bfd_set_section_alignment (dynobj
, sreloc
,
1367 htab
->word_align_power
))
1370 elf_section_data (sec
)->sreloc
= sreloc
;
1373 /* If this is a global symbol, we count the number of
1374 relocations we need for this symbol. */
1376 head
= &((struct _bfd_sparc_elf_link_hash_entry
*) h
)->dyn_relocs
;
1379 /* Track dynamic relocs needed for local syms too.
1380 We really need local syms available to do this
1384 s
= bfd_section_from_r_symndx (abfd
, &htab
->sym_sec
,
1389 head
= ((struct _bfd_sparc_elf_dyn_relocs
**)
1390 &elf_section_data (s
)->local_dynrel
);
1394 if (p
== NULL
|| p
->sec
!= sec
)
1396 bfd_size_type amt
= sizeof *p
;
1397 p
= ((struct _bfd_sparc_elf_dyn_relocs
*)
1398 bfd_alloc (htab
->elf
.dynobj
, amt
));
1409 if (_bfd_sparc_elf_howto_table
[r_type
].pc_relative
)
1415 case R_SPARC_GNU_VTINHERIT
:
1416 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1420 case R_SPARC_GNU_VTENTRY
:
1421 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
1425 case R_SPARC_REGISTER
:
1426 /* Nothing to do. */
1438 _bfd_sparc_elf_gc_mark_hook (asection
*sec
,
1439 struct bfd_link_info
*info
,
1440 Elf_Internal_Rela
*rel
,
1441 struct elf_link_hash_entry
*h
,
1442 Elf_Internal_Sym
*sym
)
1446 struct _bfd_sparc_elf_link_hash_table
*htab
;
1448 htab
= _bfd_sparc_elf_hash_table (info
);
1449 switch (SPARC_ELF_R_TYPE (rel
->r_info
))
1451 case R_SPARC_GNU_VTINHERIT
:
1452 case R_SPARC_GNU_VTENTRY
:
1456 switch (h
->root
.type
)
1458 case bfd_link_hash_defined
:
1459 case bfd_link_hash_defweak
:
1460 return h
->root
.u
.def
.section
;
1462 case bfd_link_hash_common
:
1463 return h
->root
.u
.c
.p
->section
;
1471 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
1476 /* Update the got entry reference counts for the section being removed. */
1478 _bfd_sparc_elf_gc_sweep_hook (bfd
*abfd
, struct bfd_link_info
*info
,
1479 asection
*sec
, const Elf_Internal_Rela
*relocs
)
1481 struct _bfd_sparc_elf_link_hash_table
*htab
;
1482 Elf_Internal_Shdr
*symtab_hdr
;
1483 struct elf_link_hash_entry
**sym_hashes
;
1484 bfd_signed_vma
*local_got_refcounts
;
1485 const Elf_Internal_Rela
*rel
, *relend
;
1487 elf_section_data (sec
)->local_dynrel
= NULL
;
1489 htab
= _bfd_sparc_elf_hash_table (info
);
1490 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1491 sym_hashes
= elf_sym_hashes (abfd
);
1492 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1494 relend
= relocs
+ sec
->reloc_count
;
1495 for (rel
= relocs
; rel
< relend
; rel
++)
1497 unsigned long r_symndx
;
1498 unsigned int r_type
;
1499 struct elf_link_hash_entry
*h
= NULL
;
1501 r_symndx
= SPARC_ELF_R_SYMNDX (htab
, rel
->r_info
);
1502 if (r_symndx
>= symtab_hdr
->sh_info
)
1504 struct _bfd_sparc_elf_link_hash_entry
*eh
;
1505 struct _bfd_sparc_elf_dyn_relocs
**pp
;
1506 struct _bfd_sparc_elf_dyn_relocs
*p
;
1508 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1509 while (h
->root
.type
== bfd_link_hash_indirect
1510 || h
->root
.type
== bfd_link_hash_warning
)
1511 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1512 eh
= (struct _bfd_sparc_elf_link_hash_entry
*) h
;
1513 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
1516 /* Everything must go for SEC. */
1522 r_type
= SPARC_ELF_R_TYPE (rel
->r_info
);
1523 r_type
= sparc_elf_tls_transition (info
, abfd
, r_type
, h
!= NULL
);
1526 case R_SPARC_TLS_LDM_HI22
:
1527 case R_SPARC_TLS_LDM_LO10
:
1528 if (_bfd_sparc_elf_hash_table (info
)->tls_ldm_got
.refcount
> 0)
1529 _bfd_sparc_elf_hash_table (info
)->tls_ldm_got
.refcount
-= 1;
1532 case R_SPARC_TLS_GD_HI22
:
1533 case R_SPARC_TLS_GD_LO10
:
1534 case R_SPARC_TLS_IE_HI22
:
1535 case R_SPARC_TLS_IE_LO10
:
1541 if (h
->got
.refcount
> 0)
1546 if (local_got_refcounts
[r_symndx
] > 0)
1547 local_got_refcounts
[r_symndx
]--;
1553 case R_SPARC_PC_HH22
:
1554 case R_SPARC_PC_HM10
:
1555 case R_SPARC_PC_LM22
:
1557 && strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
1562 case R_SPARC_DISP16
:
1563 case R_SPARC_DISP32
:
1564 case R_SPARC_DISP64
:
1565 case R_SPARC_WDISP30
:
1566 case R_SPARC_WDISP22
:
1567 case R_SPARC_WDISP19
:
1568 case R_SPARC_WDISP16
:
1599 case R_SPARC_WPLT30
:
1602 if (h
->plt
.refcount
> 0)
1615 /* Adjust a symbol defined by a dynamic object and referenced by a
1616 regular object. The current definition is in some section of the
1617 dynamic object, but we're not including those sections. We have to
1618 change the definition to something the rest of the link can
1622 _bfd_sparc_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
1623 struct elf_link_hash_entry
*h
)
1625 struct _bfd_sparc_elf_link_hash_table
*htab
;
1626 struct _bfd_sparc_elf_link_hash_entry
* eh
;
1627 struct _bfd_sparc_elf_dyn_relocs
*p
;
1629 unsigned int power_of_two
;
1631 htab
= _bfd_sparc_elf_hash_table (info
);
1633 /* Make sure we know what is going on here. */
1634 BFD_ASSERT (htab
->elf
.dynobj
!= NULL
1636 || h
->u
.weakdef
!= NULL
1639 && !h
->def_regular
)));
1641 /* If this is a function, put it in the procedure linkage table. We
1642 will fill in the contents of the procedure linkage table later
1643 (although we could actually do it here). The STT_NOTYPE
1644 condition is a hack specifically for the Oracle libraries
1645 delivered for Solaris; for some inexplicable reason, they define
1646 some of their functions as STT_NOTYPE when they really should be
1648 if (h
->type
== STT_FUNC
1650 || (h
->type
== STT_NOTYPE
1651 && (h
->root
.type
== bfd_link_hash_defined
1652 || h
->root
.type
== bfd_link_hash_defweak
)
1653 && (h
->root
.u
.def
.section
->flags
& SEC_CODE
) != 0))
1655 if (h
->plt
.refcount
<= 0
1659 && h
->root
.type
!= bfd_link_hash_undefweak
1660 && h
->root
.type
!= bfd_link_hash_undefined
))
1662 /* This case can occur if we saw a WPLT30 reloc in an input
1663 file, but the symbol was never referred to by a dynamic
1664 object, or if all references were garbage collected. In
1665 such a case, we don't actually need to build a procedure
1666 linkage table, and we can just do a WDISP30 reloc instead. */
1667 h
->plt
.offset
= (bfd_vma
) -1;
1674 h
->plt
.offset
= (bfd_vma
) -1;
1676 /* If this is a weak symbol, and there is a real definition, the
1677 processor independent code will have arranged for us to see the
1678 real definition first, and we can just use the same value. */
1679 if (h
->u
.weakdef
!= NULL
)
1681 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
1682 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
1683 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
1684 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
1688 /* This is a reference to a symbol defined by a dynamic object which
1689 is not a function. */
1691 /* If we are creating a shared library, we must presume that the
1692 only references to the symbol are via the global offset table.
1693 For such cases we need not do anything here; the relocations will
1694 be handled correctly by relocate_section. */
1698 /* If there are no references to this symbol that do not use the
1699 GOT, we don't need to generate a copy reloc. */
1700 if (!h
->non_got_ref
)
1703 eh
= (struct _bfd_sparc_elf_link_hash_entry
*) h
;
1704 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1706 s
= p
->sec
->output_section
;
1707 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1711 /* If we didn't find any dynamic relocs in read-only sections, then
1712 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1719 /* We must allocate the symbol in our .dynbss section, which will
1720 become part of the .bss section of the executable. There will be
1721 an entry for this symbol in the .dynsym section. The dynamic
1722 object will contain position independent code, so all references
1723 from the dynamic object to this symbol will go through the global
1724 offset table. The dynamic linker will use the .dynsym entry to
1725 determine the address it must put in the global offset table, so
1726 both the dynamic object and the regular object will refer to the
1727 same memory location for the variable. */
1729 /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker
1730 to copy the initial value out of the dynamic object and into the
1731 runtime process image. We need to remember the offset into the
1732 .rel.bss section we are going to use. */
1733 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
1735 htab
->srelbss
->size
+= SPARC_ELF_RELA_BYTES (htab
);
1739 /* We need to figure out the alignment required for this symbol. I
1740 have no idea how ELF linkers handle this. */
1741 power_of_two
= bfd_log2 (h
->size
);
1742 if (power_of_two
> htab
->align_power_max
)
1743 power_of_two
= htab
->align_power_max
;
1745 /* Apply the required alignment. */
1747 s
->size
= BFD_ALIGN (s
->size
, (bfd_size_type
) (1 << power_of_two
));
1748 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
1750 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
1754 /* Define the symbol as being at this point in the section. */
1755 h
->root
.u
.def
.section
= s
;
1756 h
->root
.u
.def
.value
= s
->size
;
1758 /* Increment the section size to make room for the symbol. */
1764 /* Allocate space in .plt, .got and associated reloc sections for
1768 allocate_dynrelocs (struct elf_link_hash_entry
*h
, PTR inf
)
1770 struct bfd_link_info
*info
;
1771 struct _bfd_sparc_elf_link_hash_table
*htab
;
1772 struct _bfd_sparc_elf_link_hash_entry
*eh
;
1773 struct _bfd_sparc_elf_dyn_relocs
*p
;
1775 if (h
->root
.type
== bfd_link_hash_indirect
)
1778 if (h
->root
.type
== bfd_link_hash_warning
)
1779 /* When warning symbols are created, they **replace** the "real"
1780 entry in the hash table, thus we never get to see the real
1781 symbol in a hash traversal. So look at it now. */
1782 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1784 info
= (struct bfd_link_info
*) inf
;
1785 htab
= _bfd_sparc_elf_hash_table (info
);
1787 if (htab
->elf
.dynamic_sections_created
1788 && h
->plt
.refcount
> 0)
1790 /* Make sure this symbol is output as a dynamic symbol.
1791 Undefined weak syms won't yet be marked as dynamic. */
1792 if (h
->dynindx
== -1
1793 && !h
->forced_local
)
1795 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1799 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info
->shared
, h
))
1801 asection
*s
= htab
->splt
;
1803 /* The first four entries in .plt is reserved. */
1805 s
->size
= (SPARC_ELF_WORD_BYTES(htab
) == 8 ?
1806 PLT64_HEADER_SIZE
: PLT32_HEADER_SIZE
);
1808 /* The procedure linkage table size is bounded by the magnitude
1809 of the offset we can describe in the entry. */
1810 if (s
->size
>= (SPARC_ELF_WORD_BYTES(htab
) == 8 ?
1811 (((bfd_vma
)1 << 31) << 1) : 0x400000))
1813 bfd_set_error (bfd_error_bad_value
);
1817 if (SPARC_ELF_WORD_BYTES(htab
) == 8
1818 && s
->size
>= PLT64_LARGE_THRESHOLD
* PLT64_ENTRY_SIZE
)
1820 bfd_vma off
= s
->size
- PLT64_LARGE_THRESHOLD
* PLT64_ENTRY_SIZE
;
1823 off
= (off
% (160 * PLT64_ENTRY_SIZE
)) / PLT64_ENTRY_SIZE
;
1825 h
->plt
.offset
= (s
->size
- (off
* 8));
1828 h
->plt
.offset
= s
->size
;
1830 /* If this symbol is not defined in a regular file, and we are
1831 not generating a shared library, then set the symbol to this
1832 location in the .plt. This is required to make function
1833 pointers compare as equal between the normal executable and
1834 the shared library. */
1838 h
->root
.u
.def
.section
= s
;
1839 h
->root
.u
.def
.value
= h
->plt
.offset
;
1842 /* Make room for this entry. */
1843 s
->size
+= (SPARC_ELF_WORD_BYTES(htab
) == 8 ?
1844 PLT64_ENTRY_SIZE
: PLT32_ENTRY_SIZE
);
1846 /* We also need to make an entry in the .rela.plt section. */
1847 htab
->srelplt
->size
+= SPARC_ELF_RELA_BYTES (htab
);
1851 h
->plt
.offset
= (bfd_vma
) -1;
1857 h
->plt
.offset
= (bfd_vma
) -1;
1861 /* If R_SPARC_TLS_IE_{HI22,LO10} symbol is now local to the binary,
1862 make it a R_SPARC_TLS_LE_{HI22,LO10} requiring no TLS entry. */
1863 if (h
->got
.refcount
> 0
1866 && _bfd_sparc_elf_hash_entry(h
)->tls_type
== GOT_TLS_IE
)
1867 h
->got
.offset
= (bfd_vma
) -1;
1868 else if (h
->got
.refcount
> 0)
1872 int tls_type
= _bfd_sparc_elf_hash_entry(h
)->tls_type
;
1874 /* Make sure this symbol is output as a dynamic symbol.
1875 Undefined weak syms won't yet be marked as dynamic. */
1876 if (h
->dynindx
== -1
1877 && !h
->forced_local
)
1879 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1884 h
->got
.offset
= s
->size
;
1885 s
->size
+= SPARC_ELF_WORD_BYTES (htab
);
1886 /* R_SPARC_TLS_GD_HI{22,LO10} needs 2 consecutive GOT slots. */
1887 if (tls_type
== GOT_TLS_GD
)
1888 s
->size
+= SPARC_ELF_WORD_BYTES (htab
);
1889 dyn
= htab
->elf
.dynamic_sections_created
;
1890 /* R_SPARC_TLS_IE_{HI22,LO10} needs one dynamic relocation,
1891 R_SPARC_TLS_GD_{HI22,LO10} needs one if local symbol and two if
1893 if ((tls_type
== GOT_TLS_GD
&& h
->dynindx
== -1)
1894 || tls_type
== GOT_TLS_IE
)
1895 htab
->srelgot
->size
+= SPARC_ELF_RELA_BYTES (htab
);
1896 else if (tls_type
== GOT_TLS_GD
)
1897 htab
->srelgot
->size
+= 2 * SPARC_ELF_RELA_BYTES (htab
);
1898 else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
))
1899 htab
->srelgot
->size
+= SPARC_ELF_RELA_BYTES (htab
);
1902 h
->got
.offset
= (bfd_vma
) -1;
1904 eh
= (struct _bfd_sparc_elf_link_hash_entry
*) h
;
1905 if (eh
->dyn_relocs
== NULL
)
1908 /* In the shared -Bsymbolic case, discard space allocated for
1909 dynamic pc-relative relocs against symbols which turn out to be
1910 defined in regular objects. For the normal shared case, discard
1911 space for pc-relative relocs that have become local due to symbol
1912 visibility changes. */
1920 struct _bfd_sparc_elf_dyn_relocs
**pp
;
1922 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
1924 p
->count
-= p
->pc_count
;
1935 /* For the non-shared case, discard space for relocs against
1936 symbols which turn out to need copy relocs or are not
1942 || (htab
->elf
.dynamic_sections_created
1943 && (h
->root
.type
== bfd_link_hash_undefweak
1944 || h
->root
.type
== bfd_link_hash_undefined
))))
1946 /* Make sure this symbol is output as a dynamic symbol.
1947 Undefined weak syms won't yet be marked as dynamic. */
1948 if (h
->dynindx
== -1
1949 && !h
->forced_local
)
1951 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1955 /* If that succeeded, we know we'll be keeping all the
1957 if (h
->dynindx
!= -1)
1961 eh
->dyn_relocs
= NULL
;
1966 /* Finally, allocate space. */
1967 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1969 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
1970 sreloc
->size
+= p
->count
* SPARC_ELF_RELA_BYTES (htab
);
1976 /* Find any dynamic relocs that apply to read-only sections. */
1979 readonly_dynrelocs (struct elf_link_hash_entry
*h
, PTR inf
)
1981 struct _bfd_sparc_elf_link_hash_entry
*eh
;
1982 struct _bfd_sparc_elf_dyn_relocs
*p
;
1984 if (h
->root
.type
== bfd_link_hash_warning
)
1985 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1987 eh
= (struct _bfd_sparc_elf_link_hash_entry
*) h
;
1988 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1990 asection
*s
= p
->sec
->output_section
;
1992 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1994 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
1996 info
->flags
|= DF_TEXTREL
;
1998 /* Not an error, just cut short the traversal. */
2005 /* Return true if the dynamic symbol for a given section should be
2006 omitted when creating a shared library. */
2009 _bfd_sparc_elf_omit_section_dynsym (bfd
*output_bfd
,
2010 struct bfd_link_info
*info
,
2013 /* We keep the .got section symbol so that explicit relocations
2014 against the _GLOBAL_OFFSET_TABLE_ symbol emitted in PIC mode
2015 can be turned into relocations against the .got symbol. */
2016 if (strcmp (p
->name
, ".got") == 0)
2019 return _bfd_elf_link_omit_section_dynsym (output_bfd
, info
, p
);
2022 /* Set the sizes of the dynamic sections. */
2025 _bfd_sparc_elf_size_dynamic_sections (bfd
*output_bfd
,
2026 struct bfd_link_info
*info
)
2028 struct _bfd_sparc_elf_link_hash_table
*htab
;
2033 htab
= _bfd_sparc_elf_hash_table (info
);
2034 dynobj
= htab
->elf
.dynobj
;
2035 BFD_ASSERT (dynobj
!= NULL
);
2037 if (elf_hash_table (info
)->dynamic_sections_created
)
2039 /* Set the contents of the .interp section to the interpreter. */
2040 if (info
->executable
)
2042 s
= bfd_get_section_by_name (dynobj
, ".interp");
2043 BFD_ASSERT (s
!= NULL
);
2044 s
->size
= htab
->dynamic_interpreter_size
;
2045 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
2049 /* Set up .got offsets for local syms, and space for local dynamic
2051 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
2053 bfd_signed_vma
*local_got
;
2054 bfd_signed_vma
*end_local_got
;
2055 char *local_tls_type
;
2056 bfd_size_type locsymcount
;
2057 Elf_Internal_Shdr
*symtab_hdr
;
2060 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
2063 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2065 struct _bfd_sparc_elf_dyn_relocs
*p
;
2067 for (p
= *((struct _bfd_sparc_elf_dyn_relocs
**)
2068 &elf_section_data (s
)->local_dynrel
);
2072 if (!bfd_is_abs_section (p
->sec
)
2073 && bfd_is_abs_section (p
->sec
->output_section
))
2075 /* Input section has been discarded, either because
2076 it is a copy of a linkonce section or due to
2077 linker script /DISCARD/, so we'll be discarding
2080 else if (p
->count
!= 0)
2082 srel
= elf_section_data (p
->sec
)->sreloc
;
2083 srel
->size
+= p
->count
* SPARC_ELF_RELA_BYTES (htab
);
2084 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
2085 info
->flags
|= DF_TEXTREL
;
2090 local_got
= elf_local_got_refcounts (ibfd
);
2094 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
2095 locsymcount
= symtab_hdr
->sh_info
;
2096 end_local_got
= local_got
+ locsymcount
;
2097 local_tls_type
= _bfd_sparc_elf_local_got_tls_type (ibfd
);
2099 srel
= htab
->srelgot
;
2100 for (; local_got
< end_local_got
; ++local_got
, ++local_tls_type
)
2104 *local_got
= s
->size
;
2105 s
->size
+= SPARC_ELF_WORD_BYTES (htab
);
2106 if (*local_tls_type
== GOT_TLS_GD
)
2107 s
->size
+= SPARC_ELF_WORD_BYTES (htab
);
2109 || *local_tls_type
== GOT_TLS_GD
2110 || *local_tls_type
== GOT_TLS_IE
)
2111 srel
->size
+= SPARC_ELF_RELA_BYTES (htab
);
2114 *local_got
= (bfd_vma
) -1;
2118 if (htab
->tls_ldm_got
.refcount
> 0)
2120 /* Allocate 2 got entries and 1 dynamic reloc for
2121 R_SPARC_TLS_LDM_{HI22,LO10} relocs. */
2122 htab
->tls_ldm_got
.offset
= htab
->sgot
->size
;
2123 htab
->sgot
->size
+= (2 * SPARC_ELF_WORD_BYTES (htab
));
2124 htab
->srelgot
->size
+= SPARC_ELF_RELA_BYTES (htab
);
2127 htab
->tls_ldm_got
.offset
= -1;
2129 /* Allocate global sym .plt and .got entries, and space for global
2130 sym dynamic relocs. */
2131 elf_link_hash_traverse (&htab
->elf
, allocate_dynrelocs
, (PTR
) info
);
2133 if (! ABI_64_P (output_bfd
)
2134 && elf_hash_table (info
)->dynamic_sections_created
)
2136 /* Make space for the trailing nop in .plt. */
2137 if (htab
->splt
->size
> 0)
2138 htab
->splt
->size
+= 1 * SPARC_INSN_BYTES
;
2140 /* If the .got section is more than 0x1000 bytes, we add
2141 0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13
2142 bit relocations have a greater chance of working.
2144 FIXME: Make this optimization work for 64-bit too. */
2145 if (htab
->sgot
->size
>= 0x1000
2146 && elf_hash_table (info
)->hgot
->root
.u
.def
.value
== 0)
2147 elf_hash_table (info
)->hgot
->root
.u
.def
.value
= 0x1000;
2150 /* The check_relocs and adjust_dynamic_symbol entry points have
2151 determined the sizes of the various dynamic sections. Allocate
2153 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2155 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2160 || s
== htab
->sdynbss
)
2162 /* Strip this section if we don't need it; see the
2165 else if (strncmp (s
->name
, ".rela", 5) == 0)
2169 /* We use the reloc_count field as a counter if we need
2170 to copy relocs into the output file. */
2176 /* It's not one of our sections. */
2182 /* If we don't need this section, strip it from the
2183 output file. This is mostly to handle .rela.bss and
2184 .rela.plt. We must create both sections in
2185 create_dynamic_sections, because they must be created
2186 before the linker maps input sections to output
2187 sections. The linker does that before
2188 adjust_dynamic_symbol is called, and it is that
2189 function which decides whether anything needs to go
2190 into these sections. */
2191 s
->flags
|= SEC_EXCLUDE
;
2195 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
2198 /* Allocate memory for the section contents. Zero the memory
2199 for the benefit of .rela.plt, which has 4 unused entries
2200 at the beginning, and we don't want garbage. */
2201 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
2202 if (s
->contents
== NULL
)
2206 if (elf_hash_table (info
)->dynamic_sections_created
)
2208 /* Add some entries to the .dynamic section. We fill in the
2209 values later, in _bfd_sparc_elf_finish_dynamic_sections, but we
2210 must add the entries now so that we get the correct size for
2211 the .dynamic section. The DT_DEBUG entry is filled in by the
2212 dynamic linker and used by the debugger. */
2213 #define add_dynamic_entry(TAG, VAL) \
2214 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2216 if (info
->executable
)
2218 if (!add_dynamic_entry (DT_DEBUG
, 0))
2222 if (htab
->srelplt
->size
!= 0)
2224 if (!add_dynamic_entry (DT_PLTGOT
, 0)
2225 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
2226 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
2227 || !add_dynamic_entry (DT_JMPREL
, 0))
2231 if (!add_dynamic_entry (DT_RELA
, 0)
2232 || !add_dynamic_entry (DT_RELASZ
, 0)
2233 || !add_dynamic_entry (DT_RELAENT
,
2234 SPARC_ELF_RELA_BYTES (htab
)))
2237 /* If any dynamic relocs apply to a read-only section,
2238 then we need a DT_TEXTREL entry. */
2239 if ((info
->flags
& DF_TEXTREL
) == 0)
2240 elf_link_hash_traverse (&htab
->elf
, readonly_dynrelocs
,
2243 if (info
->flags
& DF_TEXTREL
)
2245 if (!add_dynamic_entry (DT_TEXTREL
, 0))
2249 if (ABI_64_P (output_bfd
))
2252 struct _bfd_sparc_elf_app_reg
* app_regs
;
2253 struct elf_strtab_hash
*dynstr
;
2254 struct elf_link_hash_table
*eht
= elf_hash_table (info
);
2256 /* Add dynamic STT_REGISTER symbols and corresponding DT_SPARC_REGISTER
2257 entries if needed. */
2258 app_regs
= _bfd_sparc_elf_hash_table (info
)->app_regs
;
2259 dynstr
= eht
->dynstr
;
2261 for (reg
= 0; reg
< 4; reg
++)
2262 if (app_regs
[reg
].name
!= NULL
)
2264 struct elf_link_local_dynamic_entry
*entry
, *e
;
2266 if (!add_dynamic_entry (DT_SPARC_REGISTER
, 0))
2269 entry
= (struct elf_link_local_dynamic_entry
*)
2270 bfd_hash_allocate (&info
->hash
->table
, sizeof (*entry
));
2274 /* We cheat here a little bit: the symbol will not be local, so we
2275 put it at the end of the dynlocal linked list. We will fix it
2276 later on, as we have to fix other fields anyway. */
2277 entry
->isym
.st_value
= reg
< 2 ? reg
+ 2 : reg
+ 4;
2278 entry
->isym
.st_size
= 0;
2279 if (*app_regs
[reg
].name
!= '\0')
2281 = _bfd_elf_strtab_add (dynstr
, app_regs
[reg
].name
, FALSE
);
2283 entry
->isym
.st_name
= 0;
2284 entry
->isym
.st_other
= 0;
2285 entry
->isym
.st_info
= ELF_ST_INFO (app_regs
[reg
].bind
,
2287 entry
->isym
.st_shndx
= app_regs
[reg
].shndx
;
2289 entry
->input_bfd
= output_bfd
;
2290 entry
->input_indx
= -1;
2292 if (eht
->dynlocal
== NULL
)
2293 eht
->dynlocal
= entry
;
2296 for (e
= eht
->dynlocal
; e
->next
; e
= e
->next
)
2304 #undef add_dynamic_entry
2310 _bfd_sparc_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
2312 struct _bfd_sparc_elf_section_data
*sdata
;
2313 bfd_size_type amt
= sizeof (*sdata
);
2315 sdata
= (struct _bfd_sparc_elf_section_data
*) bfd_zalloc (abfd
, amt
);
2318 sec
->used_by_bfd
= (PTR
) sdata
;
2320 return _bfd_elf_new_section_hook (abfd
, sec
);
2324 _bfd_sparc_elf_relax_section (bfd
*abfd ATTRIBUTE_UNUSED
,
2325 struct bfd_section
*section
,
2326 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
,
2330 sec_do_relax (section
) = 1;
2334 /* Return the base VMA address which should be subtracted from real addresses
2335 when resolving @dtpoff relocation.
2336 This is PT_TLS segment p_vaddr. */
2339 dtpoff_base (struct bfd_link_info
*info
)
2341 /* If tls_sec is NULL, we should have signalled an error already. */
2342 if (elf_hash_table (info
)->tls_sec
== NULL
)
2344 return elf_hash_table (info
)->tls_sec
->vma
;
2347 /* Return the relocation value for @tpoff relocation
2348 if STT_TLS virtual address is ADDRESS. */
2351 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
2353 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2355 /* If tls_sec is NULL, we should have signalled an error already. */
2356 if (htab
->tls_sec
== NULL
)
2358 return address
- htab
->tls_size
- htab
->tls_sec
->vma
;
2361 /* Relocate a SPARC ELF section. */
2364 _bfd_sparc_elf_relocate_section (bfd
*output_bfd
, struct bfd_link_info
*info
,
2365 bfd
*input_bfd
, asection
*input_section
,
2366 bfd_byte
*contents
, Elf_Internal_Rela
*relocs
,
2367 Elf_Internal_Sym
*local_syms
, asection
**local_sections
)
2369 struct _bfd_sparc_elf_link_hash_table
*htab
;
2370 Elf_Internal_Shdr
*symtab_hdr
;
2371 struct elf_link_hash_entry
**sym_hashes
;
2372 bfd_vma
*local_got_offsets
;
2375 Elf_Internal_Rela
*rel
;
2376 Elf_Internal_Rela
*relend
;
2379 if (info
->relocatable
)
2382 htab
= _bfd_sparc_elf_hash_table (info
);
2383 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2384 sym_hashes
= elf_sym_hashes (input_bfd
);
2385 local_got_offsets
= elf_local_got_offsets (input_bfd
);
2387 if (elf_hash_table (info
)->hgot
== NULL
)
2390 got_base
= elf_hash_table (info
)->hgot
->root
.u
.def
.value
;
2392 sreloc
= elf_section_data (input_section
)->sreloc
;
2395 if (ABI_64_P (output_bfd
))
2396 num_relocs
= NUM_SHDR_ENTRIES (& elf_section_data (input_section
)->rel_hdr
);
2398 num_relocs
= input_section
->reloc_count
;
2399 relend
= relocs
+ num_relocs
;
2400 for (; rel
< relend
; rel
++)
2402 int r_type
, tls_type
;
2403 reloc_howto_type
*howto
;
2404 unsigned long r_symndx
;
2405 struct elf_link_hash_entry
*h
;
2406 Elf_Internal_Sym
*sym
;
2408 bfd_vma relocation
, off
;
2409 bfd_reloc_status_type r
;
2410 bfd_boolean is_plt
= FALSE
;
2411 bfd_boolean unresolved_reloc
;
2413 r_type
= SPARC_ELF_R_TYPE (rel
->r_info
);
2414 if (r_type
== R_SPARC_GNU_VTINHERIT
2415 || r_type
== R_SPARC_GNU_VTENTRY
)
2418 if (r_type
< 0 || r_type
>= (int) R_SPARC_max_std
)
2420 bfd_set_error (bfd_error_bad_value
);
2423 howto
= _bfd_sparc_elf_howto_table
+ r_type
;
2425 /* This is a final link. */
2426 r_symndx
= SPARC_ELF_R_SYMNDX (htab
, rel
->r_info
);
2430 unresolved_reloc
= FALSE
;
2431 if (r_symndx
< symtab_hdr
->sh_info
)
2433 sym
= local_syms
+ r_symndx
;
2434 sec
= local_sections
[r_symndx
];
2435 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
2441 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2442 r_symndx
, symtab_hdr
, sym_hashes
,
2444 unresolved_reloc
, warned
);
2447 /* To avoid generating warning messages about truncated
2448 relocations, set the relocation's address to be the same as
2449 the start of this section. */
2450 if (input_section
->output_section
!= NULL
)
2451 relocation
= input_section
->output_section
->vma
;
2462 /* Relocation is to the entry for this symbol in the global
2464 if (htab
->sgot
== NULL
)
2471 off
= h
->got
.offset
;
2472 BFD_ASSERT (off
!= (bfd_vma
) -1);
2473 dyn
= elf_hash_table (info
)->dynamic_sections_created
;
2475 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
2482 /* This is actually a static link, or it is a
2483 -Bsymbolic link and the symbol is defined
2484 locally, or the symbol was forced to be local
2485 because of a version file. We must initialize
2486 this entry in the global offset table. Since the
2487 offset must always be a multiple of 8 for 64-bit
2488 and 4 for 32-bit, we use the least significant bit
2489 to record whether we have initialized it already.
2491 When doing a dynamic link, we create a .rela.got
2492 relocation entry to initialize the value. This
2493 is done in the finish_dynamic_symbol routine. */
2498 SPARC_ELF_PUT_WORD (htab
, output_bfd
, relocation
,
2499 htab
->sgot
->contents
+ off
);
2504 unresolved_reloc
= FALSE
;
2508 BFD_ASSERT (local_got_offsets
!= NULL
2509 && local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
2511 off
= local_got_offsets
[r_symndx
];
2513 /* The offset must always be a multiple of 8 on 64-bit and
2514 4 on 32-bit. We use the least significant bit to record
2515 whether we have already processed this entry. */
2524 Elf_Internal_Rela outrel
;
2526 /* We need to generate a R_SPARC_RELATIVE reloc
2527 for the dynamic linker. */
2529 BFD_ASSERT (s
!= NULL
);
2531 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
2532 + htab
->sgot
->output_offset
2534 outrel
.r_info
= SPARC_ELF_R_INFO (htab
, NULL
,
2535 0, R_SPARC_RELATIVE
);
2536 outrel
.r_addend
= relocation
;
2538 SPARC_ELF_APPEND_RELA (htab
, output_bfd
, s
, &outrel
);
2541 SPARC_ELF_PUT_WORD (htab
, output_bfd
, relocation
,
2542 htab
->sgot
->contents
+ off
);
2543 local_got_offsets
[r_symndx
] |= 1;
2546 relocation
= htab
->sgot
->output_offset
+ off
- got_base
;
2551 if (h
== NULL
|| h
->plt
.offset
== (bfd_vma
) -1)
2553 r_type
= (r_type
== R_SPARC_PLT32
) ? R_SPARC_32
: R_SPARC_64
;
2558 case R_SPARC_WPLT30
:
2559 case R_SPARC_HIPLT22
:
2560 case R_SPARC_LOPLT10
:
2561 case R_SPARC_PCPLT32
:
2562 case R_SPARC_PCPLT22
:
2563 case R_SPARC_PCPLT10
:
2565 /* Relocation is to the entry for this symbol in the
2566 procedure linkage table. */
2568 if (! ABI_64_P (output_bfd
))
2570 /* The Solaris native assembler will generate a WPLT30 reloc
2571 for a local symbol if you assemble a call from one
2572 section to another when using -K pic. We treat it as
2579 BFD_ASSERT (h
!= NULL
);
2582 if (h
->plt
.offset
== (bfd_vma
) -1 || htab
->splt
== NULL
)
2584 /* We didn't make a PLT entry for this symbol. This
2585 happens when statically linking PIC code, or when
2586 using -Bsymbolic. */
2590 relocation
= (htab
->splt
->output_section
->vma
2591 + htab
->splt
->output_offset
2593 unresolved_reloc
= FALSE
;
2594 if (r_type
== R_SPARC_PLT32
|| r_type
== R_SPARC_PLT64
)
2596 r_type
= r_type
== R_SPARC_PLT32
? R_SPARC_32
: R_SPARC_64
;
2604 case R_SPARC_PC_HH22
:
2605 case R_SPARC_PC_HM10
:
2606 case R_SPARC_PC_LM22
:
2608 && strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
2612 case R_SPARC_DISP16
:
2613 case R_SPARC_DISP32
:
2614 case R_SPARC_DISP64
:
2615 case R_SPARC_WDISP30
:
2616 case R_SPARC_WDISP22
:
2617 case R_SPARC_WDISP19
:
2618 case R_SPARC_WDISP16
:
2645 /* r_symndx will be zero only for relocs against symbols
2646 from removed linkonce sections, or sections discarded by
2649 || (input_section
->flags
& SEC_ALLOC
) == 0)
2654 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2655 || h
->root
.type
!= bfd_link_hash_undefweak
)
2656 && (! howto
->pc_relative
2659 && (! info
->symbolic
2660 || !h
->def_regular
))))
2667 || h
->root
.type
== bfd_link_hash_undefweak
2668 || h
->root
.type
== bfd_link_hash_undefined
)))
2670 Elf_Internal_Rela outrel
;
2671 bfd_boolean skip
, relocate
= FALSE
;
2673 /* When generating a shared object, these relocations
2674 are copied into the output file to be resolved at run
2677 BFD_ASSERT (sreloc
!= NULL
);
2682 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2684 if (outrel
.r_offset
== (bfd_vma
) -1)
2686 else if (outrel
.r_offset
== (bfd_vma
) -2)
2687 skip
= TRUE
, relocate
= TRUE
;
2688 outrel
.r_offset
+= (input_section
->output_section
->vma
2689 + input_section
->output_offset
);
2691 /* Optimize unaligned reloc usage now that we know where
2692 it finally resides. */
2696 if (outrel
.r_offset
& 1)
2697 r_type
= R_SPARC_UA16
;
2700 if (!(outrel
.r_offset
& 1))
2701 r_type
= R_SPARC_16
;
2704 if (outrel
.r_offset
& 3)
2705 r_type
= R_SPARC_UA32
;
2708 if (!(outrel
.r_offset
& 3))
2709 r_type
= R_SPARC_32
;
2712 if (outrel
.r_offset
& 7)
2713 r_type
= R_SPARC_UA64
;
2716 if (!(outrel
.r_offset
& 7))
2717 r_type
= R_SPARC_64
;
2720 case R_SPARC_DISP16
:
2721 case R_SPARC_DISP32
:
2722 case R_SPARC_DISP64
:
2723 /* If the symbol is not dynamic, we should not keep
2724 a dynamic relocation. But an .rela.* slot has been
2725 allocated for it, output R_SPARC_NONE.
2726 FIXME: Add code tracking needed dynamic relocs as
2728 if (h
->dynindx
== -1)
2729 skip
= TRUE
, relocate
= TRUE
;
2734 memset (&outrel
, 0, sizeof outrel
);
2735 /* h->dynindx may be -1 if the symbol was marked to
2737 else if (h
!= NULL
&& ! is_plt
2738 && ((! info
->symbolic
&& h
->dynindx
!= -1)
2739 || !h
->def_regular
))
2741 BFD_ASSERT (h
->dynindx
!= -1);
2742 outrel
.r_info
= SPARC_ELF_R_INFO (htab
, rel
, h
->dynindx
, r_type
);
2743 outrel
.r_addend
= rel
->r_addend
;
2747 if (r_type
== R_SPARC_32
|| r_type
== R_SPARC_64
)
2749 outrel
.r_info
= SPARC_ELF_R_INFO (htab
, NULL
,
2750 0, R_SPARC_RELATIVE
);
2751 outrel
.r_addend
= relocation
+ rel
->r_addend
;
2760 if (bfd_is_abs_section (sec
))
2762 else if (sec
== NULL
|| sec
->owner
== NULL
)
2764 bfd_set_error (bfd_error_bad_value
);
2771 osec
= sec
->output_section
;
2772 indx
= elf_section_data (osec
)->dynindx
;
2774 /* FIXME: we really should be able to link non-pic
2775 shared libraries. */
2779 (*_bfd_error_handler
)
2780 (_("%B: probably compiled without -fPIC?"),
2782 bfd_set_error (bfd_error_bad_value
);
2787 outrel
.r_info
= SPARC_ELF_R_INFO (htab
, rel
, indx
, r_type
);
2788 outrel
.r_addend
= relocation
+ rel
->r_addend
;
2792 SPARC_ELF_APPEND_RELA (htab
, output_bfd
, sreloc
, &outrel
);
2794 /* This reloc will be computed at runtime, so there's no
2795 need to do anything now. */
2801 case R_SPARC_TLS_GD_HI22
:
2802 if (! ABI_64_P (input_bfd
)
2803 && ! _bfd_sparc_elf_tdata (input_bfd
)->has_tlsgd
)
2805 /* R_SPARC_REV32 used the same reloc number as
2806 R_SPARC_TLS_GD_HI22. */
2807 r_type
= R_SPARC_REV32
;
2812 case R_SPARC_TLS_GD_LO10
:
2813 case R_SPARC_TLS_IE_HI22
:
2814 case R_SPARC_TLS_IE_LO10
:
2815 r_type
= sparc_elf_tls_transition (info
, input_bfd
, r_type
, h
== NULL
);
2816 tls_type
= GOT_UNKNOWN
;
2817 if (h
== NULL
&& local_got_offsets
)
2818 tls_type
= _bfd_sparc_elf_local_got_tls_type (input_bfd
) [r_symndx
];
2821 tls_type
= _bfd_sparc_elf_hash_entry(h
)->tls_type
;
2822 if (!info
->shared
&& h
->dynindx
== -1 && tls_type
== GOT_TLS_IE
)
2823 switch (SPARC_ELF_R_TYPE (rel
->r_info
))
2825 case R_SPARC_TLS_GD_HI22
:
2826 case R_SPARC_TLS_IE_HI22
:
2827 r_type
= R_SPARC_TLS_LE_HIX22
;
2830 r_type
= R_SPARC_TLS_LE_LOX10
;
2834 if (tls_type
== GOT_TLS_IE
)
2837 case R_SPARC_TLS_GD_HI22
:
2838 r_type
= R_SPARC_TLS_IE_HI22
;
2840 case R_SPARC_TLS_GD_LO10
:
2841 r_type
= R_SPARC_TLS_IE_LO10
;
2845 if (r_type
== R_SPARC_TLS_LE_HIX22
)
2847 relocation
= tpoff (info
, relocation
);
2850 if (r_type
== R_SPARC_TLS_LE_LOX10
)
2852 /* Change add into xor. */
2853 relocation
= tpoff (info
, relocation
);
2854 bfd_put_32 (output_bfd
, (bfd_get_32 (input_bfd
,
2855 contents
+ rel
->r_offset
)
2856 | 0x80182000), contents
+ rel
->r_offset
);
2862 off
= h
->got
.offset
;
2867 BFD_ASSERT (local_got_offsets
!= NULL
);
2868 off
= local_got_offsets
[r_symndx
];
2869 local_got_offsets
[r_symndx
] |= 1;
2873 if (htab
->sgot
== NULL
)
2880 Elf_Internal_Rela outrel
;
2883 if (htab
->srelgot
== NULL
)
2886 SPARC_ELF_PUT_WORD (htab
, output_bfd
, 0, htab
->sgot
->contents
+ off
);
2887 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
2888 + htab
->sgot
->output_offset
+ off
);
2889 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
2890 if (r_type
== R_SPARC_TLS_IE_HI22
2891 || r_type
== R_SPARC_TLS_IE_LO10
)
2892 dr_type
= SPARC_ELF_TPOFF_RELOC (htab
);
2894 dr_type
= SPARC_ELF_DTPMOD_RELOC (htab
);
2895 if (dr_type
== SPARC_ELF_TPOFF_RELOC (htab
) && indx
== 0)
2896 outrel
.r_addend
= relocation
- dtpoff_base (info
);
2898 outrel
.r_addend
= 0;
2899 outrel
.r_info
= SPARC_ELF_R_INFO (htab
, NULL
, indx
, dr_type
);
2900 SPARC_ELF_APPEND_RELA (htab
, output_bfd
, htab
->srelgot
, &outrel
);
2902 if (r_type
== R_SPARC_TLS_GD_HI22
2903 || r_type
== R_SPARC_TLS_GD_LO10
)
2907 BFD_ASSERT (! unresolved_reloc
);
2908 SPARC_ELF_PUT_WORD (htab
, output_bfd
,
2909 relocation
- dtpoff_base (info
),
2910 (htab
->sgot
->contents
+ off
2911 + SPARC_ELF_WORD_BYTES (htab
)));
2915 SPARC_ELF_PUT_WORD (htab
, output_bfd
, 0,
2916 (htab
->sgot
->contents
+ off
2917 + SPARC_ELF_WORD_BYTES (htab
)));
2918 outrel
.r_info
= SPARC_ELF_R_INFO (htab
, NULL
, indx
,
2919 SPARC_ELF_DTPOFF_RELOC (htab
));
2920 outrel
.r_offset
+= SPARC_ELF_WORD_BYTES (htab
);
2921 SPARC_ELF_APPEND_RELA (htab
, output_bfd
, htab
->srelgot
, &outrel
);
2924 else if (dr_type
== SPARC_ELF_DTPMOD_RELOC (htab
))
2926 SPARC_ELF_PUT_WORD (htab
, output_bfd
, 0,
2927 (htab
->sgot
->contents
+ off
2928 + SPARC_ELF_WORD_BYTES (htab
)));
2932 if (off
>= (bfd_vma
) -2)
2935 relocation
= htab
->sgot
->output_offset
+ off
- got_base
;
2936 unresolved_reloc
= FALSE
;
2937 howto
= _bfd_sparc_elf_howto_table
+ r_type
;
2940 case R_SPARC_TLS_LDM_HI22
:
2941 case R_SPARC_TLS_LDM_LO10
:
2944 bfd_put_32 (output_bfd
, SPARC_NOP
, contents
+ rel
->r_offset
);
2947 off
= htab
->tls_ldm_got
.offset
;
2948 htab
->tls_ldm_got
.offset
|= 1;
2949 goto r_sparc_tlsldm
;
2951 case R_SPARC_TLS_LDO_HIX22
:
2952 case R_SPARC_TLS_LDO_LOX10
:
2955 relocation
-= dtpoff_base (info
);
2959 r_type
= (r_type
== R_SPARC_TLS_LDO_HIX22
2960 ? R_SPARC_TLS_LE_HIX22
: R_SPARC_TLS_LE_LOX10
);
2963 case R_SPARC_TLS_LE_HIX22
:
2964 case R_SPARC_TLS_LE_LOX10
:
2967 Elf_Internal_Rela outrel
;
2968 bfd_boolean skip
, relocate
= FALSE
;
2970 BFD_ASSERT (sreloc
!= NULL
);
2973 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2975 if (outrel
.r_offset
== (bfd_vma
) -1)
2977 else if (outrel
.r_offset
== (bfd_vma
) -2)
2978 skip
= TRUE
, relocate
= TRUE
;
2979 outrel
.r_offset
+= (input_section
->output_section
->vma
2980 + input_section
->output_offset
);
2982 memset (&outrel
, 0, sizeof outrel
);
2985 outrel
.r_info
= SPARC_ELF_R_INFO (htab
, NULL
, 0, r_type
);
2986 outrel
.r_addend
= relocation
- dtpoff_base (info
)
2990 SPARC_ELF_APPEND_RELA (htab
, output_bfd
, sreloc
, &outrel
);
2993 relocation
= tpoff (info
, relocation
);
2996 case R_SPARC_TLS_LDM_CALL
:
3000 bfd_put_32 (output_bfd
, 0x90100000, contents
+ rel
->r_offset
);
3005 case R_SPARC_TLS_GD_CALL
:
3006 tls_type
= GOT_UNKNOWN
;
3007 if (h
== NULL
&& local_got_offsets
)
3008 tls_type
= _bfd_sparc_elf_local_got_tls_type (input_bfd
) [r_symndx
];
3010 tls_type
= _bfd_sparc_elf_hash_entry(h
)->tls_type
;
3012 || (r_type
== R_SPARC_TLS_GD_CALL
&& tls_type
== GOT_TLS_IE
))
3016 if (!info
->shared
&& (h
== NULL
|| h
->dynindx
== -1))
3019 bfd_put_32 (output_bfd
, SPARC_NOP
, contents
+ rel
->r_offset
);
3024 if (rel
+ 1 < relend
3025 && SPARC_ELF_R_TYPE (rel
[1].r_info
) == R_SPARC_TLS_GD_ADD
3026 && rel
[1].r_offset
== rel
->r_offset
+ 4
3027 && SPARC_ELF_R_SYMNDX (htab
, rel
[1].r_info
) == r_symndx
3028 && (((insn
= bfd_get_32 (input_bfd
,
3029 contents
+ rel
[1].r_offset
))
3030 >> 25) & 0x1f) == 8)
3033 call __tls_get_addr, %tgd_call(foo)
3034 add %reg1, %reg2, %o0, %tgd_add(foo)
3035 and change it into IE:
3036 {ld,ldx} [%reg1 + %reg2], %o0, %tie_ldx(foo)
3037 add %g7, %o0, %o0, %tie_add(foo).
3038 add is 0x80000000 | (rd << 25) | (rs1 << 14) | rs2,
3039 ld is 0xc0000000 | (rd << 25) | (rs1 << 14) | rs2,
3040 ldx is 0xc0580000 | (rd << 25) | (rs1 << 14) | rs2. */
3041 bfd_put_32 (output_bfd
, insn
| (ABI_64_P (output_bfd
) ? 0xc0580000 : 0xc0000000),
3042 contents
+ rel
->r_offset
);
3043 bfd_put_32 (output_bfd
, 0x9001c008,
3044 contents
+ rel
->r_offset
+ 4);
3049 bfd_put_32 (output_bfd
, 0x9001c008, contents
+ rel
->r_offset
);
3053 h
= (struct elf_link_hash_entry
*)
3054 bfd_link_hash_lookup (info
->hash
, "__tls_get_addr", FALSE
,
3056 BFD_ASSERT (h
!= NULL
);
3057 r_type
= R_SPARC_WPLT30
;
3058 howto
= _bfd_sparc_elf_howto_table
+ r_type
;
3059 goto r_sparc_wplt30
;
3061 case R_SPARC_TLS_GD_ADD
:
3062 tls_type
= GOT_UNKNOWN
;
3063 if (h
== NULL
&& local_got_offsets
)
3064 tls_type
= _bfd_sparc_elf_local_got_tls_type (input_bfd
) [r_symndx
];
3066 tls_type
= _bfd_sparc_elf_hash_entry(h
)->tls_type
;
3067 if (! info
->shared
|| tls_type
== GOT_TLS_IE
)
3069 /* add %reg1, %reg2, %reg3, %tgd_add(foo)
3071 {ld,ldx} [%reg1 + %reg2], %reg3, %tie_ldx(foo)
3073 add %g7, %reg2, %reg3. */
3074 bfd_vma insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3075 if ((h
!= NULL
&& h
->dynindx
!= -1) || info
->shared
)
3076 relocation
= insn
| (ABI_64_P (output_bfd
) ? 0xc0580000 : 0xc0000000);
3078 relocation
= (insn
& ~0x7c000) | 0x1c000;
3079 bfd_put_32 (output_bfd
, relocation
, contents
+ rel
->r_offset
);
3083 case R_SPARC_TLS_LDM_ADD
:
3085 bfd_put_32 (output_bfd
, SPARC_NOP
, contents
+ rel
->r_offset
);
3088 case R_SPARC_TLS_LDO_ADD
:
3091 /* Change rs1 into %g7. */
3092 bfd_vma insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3093 insn
= (insn
& ~0x7c000) | 0x1c000;
3094 bfd_put_32 (output_bfd
, insn
, contents
+ rel
->r_offset
);
3098 case R_SPARC_TLS_IE_LD
:
3099 case R_SPARC_TLS_IE_LDX
:
3100 if (! info
->shared
&& (h
== NULL
|| h
->dynindx
== -1))
3102 bfd_vma insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3103 int rs2
= insn
& 0x1f;
3104 int rd
= (insn
>> 25) & 0x1f;
3107 relocation
= SPARC_NOP
;
3109 relocation
= 0x80100000 | (insn
& 0x3e00001f);
3110 bfd_put_32 (output_bfd
, relocation
, contents
+ rel
->r_offset
);
3114 case R_SPARC_TLS_IE_ADD
:
3115 /* Totally useless relocation. */
3118 case R_SPARC_TLS_DTPOFF32
:
3119 case R_SPARC_TLS_DTPOFF64
:
3120 relocation
-= dtpoff_base (info
);
3127 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3128 because such sections are not SEC_ALLOC and thus ld.so will
3129 not process them. */
3130 if (unresolved_reloc
3131 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
3133 (*_bfd_error_handler
)
3134 (_("%B(%A+0x%lx): unresolvable relocation against symbol `%s'"),
3137 (long) rel
->r_offset
,
3138 h
->root
.root
.string
);
3140 r
= bfd_reloc_continue
;
3141 if (r_type
== R_SPARC_OLO10
)
3145 if (! ABI_64_P (output_bfd
))
3148 relocation
+= rel
->r_addend
;
3149 relocation
= (relocation
& 0x3ff) + ELF64_R_TYPE_DATA (rel
->r_info
);
3151 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3152 x
= (x
& ~(bfd_vma
) 0x1fff) | (relocation
& 0x1fff);
3153 bfd_put_32 (input_bfd
, x
, contents
+ rel
->r_offset
);
3155 r
= bfd_check_overflow (howto
->complain_on_overflow
,
3156 howto
->bitsize
, howto
->rightshift
,
3157 bfd_arch_bits_per_address (input_bfd
),
3160 else if (r_type
== R_SPARC_WDISP16
)
3164 relocation
+= rel
->r_addend
;
3165 relocation
-= (input_section
->output_section
->vma
3166 + input_section
->output_offset
);
3167 relocation
-= rel
->r_offset
;
3169 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3170 x
|= ((((relocation
>> 2) & 0xc000) << 6)
3171 | ((relocation
>> 2) & 0x3fff));
3172 bfd_put_32 (input_bfd
, x
, contents
+ rel
->r_offset
);
3174 r
= bfd_check_overflow (howto
->complain_on_overflow
,
3175 howto
->bitsize
, howto
->rightshift
,
3176 bfd_arch_bits_per_address (input_bfd
),
3179 else if (r_type
== R_SPARC_REV32
)
3183 relocation
= relocation
+ rel
->r_addend
;
3185 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3187 bfd_putl32 (/*input_bfd,*/ x
, contents
+ rel
->r_offset
);
3190 else if (r_type
== R_SPARC_TLS_LDO_HIX22
3191 || r_type
== R_SPARC_TLS_LE_HIX22
)
3195 relocation
+= rel
->r_addend
;
3196 if (r_type
== R_SPARC_TLS_LE_HIX22
)
3197 relocation
^= MINUS_ONE
;
3199 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3200 x
= (x
& ~(bfd_vma
) 0x3fffff) | ((relocation
>> 10) & 0x3fffff);
3201 bfd_put_32 (input_bfd
, x
, contents
+ rel
->r_offset
);
3204 else if (r_type
== R_SPARC_TLS_LDO_LOX10
3205 || r_type
== R_SPARC_TLS_LE_LOX10
)
3209 relocation
+= rel
->r_addend
;
3210 relocation
&= 0x3ff;
3211 if (r_type
== R_SPARC_TLS_LE_LOX10
)
3212 relocation
|= 0x1c00;
3214 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3215 x
= (x
& ~(bfd_vma
) 0x1fff) | relocation
;
3216 bfd_put_32 (input_bfd
, x
, contents
+ rel
->r_offset
);
3220 else if (r_type
== R_SPARC_HIX22
)
3224 relocation
+= rel
->r_addend
;
3225 relocation
= relocation
^ MINUS_ONE
;
3227 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3228 x
= (x
& ~(bfd_vma
) 0x3fffff) | ((relocation
>> 10) & 0x3fffff);
3229 bfd_put_32 (input_bfd
, x
, contents
+ rel
->r_offset
);
3231 r
= bfd_check_overflow (howto
->complain_on_overflow
,
3232 howto
->bitsize
, howto
->rightshift
,
3233 bfd_arch_bits_per_address (input_bfd
),
3236 else if (r_type
== R_SPARC_LOX10
)
3240 relocation
+= rel
->r_addend
;
3241 relocation
= (relocation
& 0x3ff) | 0x1c00;
3243 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3244 x
= (x
& ~(bfd_vma
) 0x1fff) | relocation
;
3245 bfd_put_32 (input_bfd
, x
, contents
+ rel
->r_offset
);
3249 else if ((r_type
== R_SPARC_WDISP30
|| r_type
== R_SPARC_WPLT30
)
3250 && sec_do_relax (input_section
)
3251 && rel
->r_offset
+ 4 < input_section
->size
)
3255 #define XCC (2 << 20)
3256 #define COND(x) (((x)&0xf)<<25)
3257 #define CONDA COND(0x8)
3258 #define INSN_BPA (F2(0,1) | CONDA | BPRED | XCC)
3259 #define INSN_BA (F2(0,2) | CONDA)
3260 #define INSN_OR F3(2, 0x2, 0)
3261 #define INSN_NOP F2(0,4)
3265 /* If the instruction is a call with either:
3267 arithmetic instruction with rd == %o7
3268 where rs1 != %o7 and rs2 if it is register != %o7
3269 then we can optimize if the call destination is near
3270 by changing the call into a branch always. */
3271 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3272 y
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
3273 if ((x
& OP(~0)) == OP(1) && (y
& OP(~0)) == OP(2))
3275 if (((y
& OP3(~0)) == OP3(0x3d) /* restore */
3276 || ((y
& OP3(0x28)) == 0 /* arithmetic */
3277 && (y
& RD(~0)) == RD(O7
)))
3278 && (y
& RS1(~0)) != RS1(O7
)
3280 || (y
& RS2(~0)) != RS2(O7
)))
3284 reloc
= relocation
+ rel
->r_addend
- rel
->r_offset
;
3285 reloc
-= (input_section
->output_section
->vma
3286 + input_section
->output_offset
);
3288 /* Ensure the branch fits into simm22. */
3289 if ((reloc
& 3) == 0
3290 && ((reloc
& ~(bfd_vma
)0x7fffff) == 0
3291 || ((reloc
| 0x7fffff) == ~(bfd_vma
)0)))
3295 /* Check whether it fits into simm19. */
3296 if (((reloc
& 0x3c0000) == 0
3297 || (reloc
& 0x3c0000) == 0x3c0000)
3298 && (ABI_64_P (output_bfd
)
3299 || elf_elfheader (output_bfd
)->e_flags
& EF_SPARC_32PLUS
))
3300 x
= INSN_BPA
| (reloc
& 0x7ffff); /* ba,pt %xcc */
3302 x
= INSN_BA
| (reloc
& 0x3fffff); /* ba */
3303 bfd_put_32 (input_bfd
, x
, contents
+ rel
->r_offset
);
3305 if (rel
->r_offset
>= 4
3306 && (y
& (0xffffffff ^ RS1(~0)))
3307 == (INSN_OR
| RD(O7
) | RS2(G0
)))
3312 z
= bfd_get_32 (input_bfd
,
3313 contents
+ rel
->r_offset
- 4);
3314 if ((z
& (0xffffffff ^ RD(~0)))
3315 != (INSN_OR
| RS1(O7
) | RS2(G0
)))
3323 If call foo was replaced with ba, replace
3324 or %rN, %g0, %o7 with nop. */
3326 reg
= (y
& RS1(~0)) >> 14;
3327 if (reg
!= ((z
& RD(~0)) >> 25)
3328 || reg
== G0
|| reg
== O7
)
3331 bfd_put_32 (input_bfd
, (bfd_vma
) INSN_NOP
,
3332 contents
+ rel
->r_offset
+ 4);
3340 if (r
== bfd_reloc_continue
)
3341 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
3342 contents
, rel
->r_offset
,
3343 relocation
, rel
->r_addend
);
3345 if (r
!= bfd_reloc_ok
)
3350 case bfd_reloc_outofrange
:
3352 case bfd_reloc_overflow
:
3360 name
= bfd_elf_string_from_elf_section (input_bfd
,
3361 symtab_hdr
->sh_link
,
3366 name
= bfd_section_name (input_bfd
, sec
);
3368 if (! ((*info
->callbacks
->reloc_overflow
)
3369 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
3370 (bfd_vma
) 0, input_bfd
, input_section
,
3382 /* Finish up dynamic symbol handling. We set the contents of various
3383 dynamic sections here. */
3386 _bfd_sparc_elf_finish_dynamic_symbol (bfd
*output_bfd
,
3387 struct bfd_link_info
*info
,
3388 struct elf_link_hash_entry
*h
,
3389 Elf_Internal_Sym
*sym
)
3392 struct _bfd_sparc_elf_link_hash_table
*htab
;
3394 htab
= _bfd_sparc_elf_hash_table (info
);
3395 dynobj
= htab
->elf
.dynobj
;
3397 if (h
->plt
.offset
!= (bfd_vma
) -1)
3401 Elf_Internal_Rela rela
;
3406 /* This symbol has an entry in the PLT. Set it up. */
3408 BFD_ASSERT (h
->dynindx
!= -1);
3411 srela
= htab
->srelplt
;
3412 BFD_ASSERT (splt
!= NULL
&& srela
!= NULL
);
3414 /* Fill in the entry in the procedure linkage table. */
3415 rela_index
= SPARC_ELF_BUILD_PLT_ENTRY (htab
, output_bfd
, splt
,
3416 h
->plt
.offset
, splt
->size
,
3419 /* Fill in the entry in the .rela.plt section. */
3420 rela
.r_offset
= r_offset
3421 + (splt
->output_section
->vma
+ splt
->output_offset
);
3422 if (! ABI_64_P (output_bfd
)
3423 || h
->plt
.offset
< (PLT64_LARGE_THRESHOLD
* PLT64_ENTRY_SIZE
))
3429 rela
.r_addend
= -(h
->plt
.offset
+ 4)
3430 -(splt
->output_section
->vma
+ splt
->output_offset
);
3432 rela
.r_info
= SPARC_ELF_R_INFO (htab
, NULL
, h
->dynindx
, R_SPARC_JMP_SLOT
);
3434 /* Adjust for the first 4 reserved elements in the .plt section
3435 when setting the offset in the .rela.plt section.
3436 Sun forgot to read their own ABI and copied elf32-sparc behaviour,
3437 thus .plt[4] has corresponding .rela.plt[0] and so on. */
3439 loc
= srela
->contents
;
3441 if (ABI_64_P (output_bfd
))
3443 loc
+= rela_index
* sizeof (Elf64_External_Rela
);
3444 bfd_elf64_swap_reloca_out (output_bfd
, &rela
, loc
);
3449 loc
+= rela_index
* sizeof (Elf32_External_Rela
);
3450 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
3453 if (!h
->def_regular
)
3455 /* Mark the symbol as undefined, rather than as defined in
3456 the .plt section. Leave the value alone. */
3457 sym
->st_shndx
= SHN_UNDEF
;
3458 /* If the symbol is weak, we do need to clear the value.
3459 Otherwise, the PLT entry would provide a definition for
3460 the symbol even if the symbol wasn't defined anywhere,
3461 and so the symbol would never be NULL. */
3462 if (!h
->ref_regular_nonweak
)
3467 if (h
->got
.offset
!= (bfd_vma
) -1
3468 && _bfd_sparc_elf_hash_entry(h
)->tls_type
!= GOT_TLS_GD
3469 && _bfd_sparc_elf_hash_entry(h
)->tls_type
!= GOT_TLS_IE
)
3473 Elf_Internal_Rela rela
;
3475 /* This symbol has an entry in the GOT. Set it up. */
3478 srela
= htab
->srelgot
;
3479 BFD_ASSERT (sgot
!= NULL
&& srela
!= NULL
);
3481 rela
.r_offset
= (sgot
->output_section
->vma
3482 + sgot
->output_offset
3483 + (h
->got
.offset
&~ (bfd_vma
) 1));
3485 /* If this is a -Bsymbolic link, and the symbol is defined
3486 locally, we just want to emit a RELATIVE reloc. Likewise if
3487 the symbol was forced to be local because of a version file.
3488 The entry in the global offset table will already have been
3489 initialized in the relocate_section function. */
3491 && (info
->symbolic
|| h
->dynindx
== -1)
3494 asection
*sec
= h
->root
.u
.def
.section
;
3495 rela
.r_info
= SPARC_ELF_R_INFO (htab
, NULL
, 0, R_SPARC_RELATIVE
);
3496 rela
.r_addend
= (h
->root
.u
.def
.value
3497 + sec
->output_section
->vma
3498 + sec
->output_offset
);
3502 rela
.r_info
= SPARC_ELF_R_INFO (htab
, NULL
, h
->dynindx
, R_SPARC_GLOB_DAT
);
3506 SPARC_ELF_PUT_WORD (htab
, output_bfd
, 0,
3507 sgot
->contents
+ (h
->got
.offset
& ~(bfd_vma
) 1));
3508 SPARC_ELF_APPEND_RELA (htab
, output_bfd
, srela
, &rela
);
3514 Elf_Internal_Rela rela
;
3516 /* This symbols needs a copy reloc. Set it up. */
3517 BFD_ASSERT (h
->dynindx
!= -1);
3519 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
3521 BFD_ASSERT (s
!= NULL
);
3523 rela
.r_offset
= (h
->root
.u
.def
.value
3524 + h
->root
.u
.def
.section
->output_section
->vma
3525 + h
->root
.u
.def
.section
->output_offset
);
3526 rela
.r_info
= SPARC_ELF_R_INFO (htab
, NULL
, h
->dynindx
, R_SPARC_COPY
);
3528 SPARC_ELF_APPEND_RELA (htab
, output_bfd
, s
, &rela
);
3531 /* Mark some specially defined symbols as absolute. */
3532 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
3533 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0
3534 || strcmp (h
->root
.root
.string
, "_PROCEDURE_LINKAGE_TABLE_") == 0)
3535 sym
->st_shndx
= SHN_ABS
;
3540 /* Finish up the dynamic sections. */
3544 sparc64_finish_dyn (bfd
*output_bfd
, struct bfd_link_info
*info
,
3545 bfd
*dynobj
, asection
*sdyn
,
3546 asection
*splt ATTRIBUTE_UNUSED
)
3548 Elf64_External_Dyn
*dyncon
, *dynconend
;
3549 int stt_regidx
= -1;
3551 dyncon
= (Elf64_External_Dyn
*) sdyn
->contents
;
3552 dynconend
= (Elf64_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
3553 for (; dyncon
< dynconend
; dyncon
++)
3555 Elf_Internal_Dyn dyn
;
3559 bfd_elf64_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3563 case DT_PLTGOT
: name
= ".plt"; size
= FALSE
; break;
3564 case DT_PLTRELSZ
: name
= ".rela.plt"; size
= TRUE
; break;
3565 case DT_JMPREL
: name
= ".rela.plt"; size
= FALSE
; break;
3566 case DT_SPARC_REGISTER
:
3567 if (stt_regidx
== -1)
3570 _bfd_elf_link_lookup_local_dynindx (info
, output_bfd
, -1);
3571 if (stt_regidx
== -1)
3574 dyn
.d_un
.d_val
= stt_regidx
++;
3575 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3577 default: name
= NULL
; size
= FALSE
; break;
3584 s
= bfd_get_section_by_name (output_bfd
, name
);
3590 dyn
.d_un
.d_ptr
= s
->vma
;
3592 dyn
.d_un
.d_val
= s
->size
;
3594 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3602 sparc32_finish_dyn (bfd
*output_bfd
,
3603 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3604 bfd
*dynobj
, asection
*sdyn
,
3605 asection
*splt ATTRIBUTE_UNUSED
)
3607 Elf32_External_Dyn
*dyncon
, *dynconend
;
3609 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3610 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
3611 for (; dyncon
< dynconend
; dyncon
++)
3613 Elf_Internal_Dyn dyn
;
3617 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3621 case DT_PLTGOT
: name
= ".plt"; size
= FALSE
; break;
3622 case DT_PLTRELSZ
: name
= ".rela.plt"; size
= TRUE
; break;
3623 case DT_JMPREL
: name
= ".rela.plt"; size
= FALSE
; break;
3624 default: name
= NULL
; size
= FALSE
; break;
3631 s
= bfd_get_section_by_name (output_bfd
, name
);
3637 dyn
.d_un
.d_ptr
= s
->vma
;
3639 dyn
.d_un
.d_val
= s
->size
;
3641 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3648 _bfd_sparc_elf_finish_dynamic_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
3652 struct _bfd_sparc_elf_link_hash_table
*htab
;
3654 htab
= _bfd_sparc_elf_hash_table (info
);
3655 dynobj
= htab
->elf
.dynobj
;
3657 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
3659 if (elf_hash_table (info
)->dynamic_sections_created
)
3664 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3665 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
3668 if (ABI_64_P (output_bfd
))
3669 ret
= sparc64_finish_dyn (output_bfd
, info
, dynobj
, sdyn
, splt
);
3672 ret
= sparc32_finish_dyn (output_bfd
, info
, dynobj
, sdyn
, splt
);
3677 /* Initialize the contents of the .plt section. */
3680 if (ABI_64_P (output_bfd
))
3681 memset (splt
->contents
, 0, 4 * PLT64_ENTRY_SIZE
);
3684 memset (splt
->contents
, 0, 4 * PLT32_ENTRY_SIZE
);
3685 bfd_put_32 (output_bfd
, (bfd_vma
) SPARC_NOP
,
3686 splt
->contents
+ splt
->size
- 4);
3690 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
=
3691 (ABI_64_P (output_bfd
) ? PLT64_ENTRY_SIZE
: PLT32_ENTRY_SIZE
);
3694 /* Set the first entry in the global offset table to the address of
3695 the dynamic section. */
3696 if (htab
->sgot
&& htab
->sgot
->size
> 0)
3698 bfd_vma val
= (sdyn
?
3699 sdyn
->output_section
->vma
+ sdyn
->output_offset
:
3702 SPARC_ELF_PUT_WORD (htab
, output_bfd
, val
, htab
->sgot
->contents
);
3706 elf_section_data (htab
->sgot
->output_section
)->this_hdr
.sh_entsize
=
3707 SPARC_ELF_WORD_BYTES (htab
);
3713 /* Set the right machine number for a SPARC ELF file. */
3716 _bfd_sparc_elf_object_p (bfd
*abfd
)
3718 if (ABI_64_P (abfd
))
3720 unsigned long mach
= bfd_mach_sparc_v9
;
3722 if (elf_elfheader (abfd
)->e_flags
& EF_SPARC_SUN_US3
)
3723 mach
= bfd_mach_sparc_v9b
;
3724 else if (elf_elfheader (abfd
)->e_flags
& EF_SPARC_SUN_US1
)
3725 mach
= bfd_mach_sparc_v9a
;
3726 return bfd_default_set_arch_mach (abfd
, bfd_arch_sparc
, mach
);
3730 if (elf_elfheader (abfd
)->e_machine
== EM_SPARC32PLUS
)
3732 if (elf_elfheader (abfd
)->e_flags
& EF_SPARC_SUN_US3
)
3733 return bfd_default_set_arch_mach (abfd
, bfd_arch_sparc
,
3734 bfd_mach_sparc_v8plusb
);
3735 else if (elf_elfheader (abfd
)->e_flags
& EF_SPARC_SUN_US1
)
3736 return bfd_default_set_arch_mach (abfd
, bfd_arch_sparc
,
3737 bfd_mach_sparc_v8plusa
);
3738 else if (elf_elfheader (abfd
)->e_flags
& EF_SPARC_32PLUS
)
3739 return bfd_default_set_arch_mach (abfd
, bfd_arch_sparc
,
3740 bfd_mach_sparc_v8plus
);
3744 else if (elf_elfheader (abfd
)->e_flags
& EF_SPARC_LEDATA
)
3745 return bfd_default_set_arch_mach (abfd
, bfd_arch_sparc
,
3746 bfd_mach_sparc_sparclite_le
);
3748 return bfd_default_set_arch_mach (abfd
, bfd_arch_sparc
, bfd_mach_sparc
);
3752 /* Return address for Ith PLT stub in section PLT, for relocation REL
3753 or (bfd_vma) -1 if it should not be included. */
3756 _bfd_sparc_elf_plt_sym_val (bfd_vma i
, const asection
*plt
, const arelent
*rel
)
3758 if (ABI_64_P (plt
->owner
))
3762 i
+= PLT64_HEADER_SIZE
/ PLT64_ENTRY_SIZE
;
3763 if (i
< PLT64_LARGE_THRESHOLD
)
3764 return plt
->vma
+ i
* PLT64_ENTRY_SIZE
;
3766 j
= (i
- PLT64_LARGE_THRESHOLD
) % 160;
3768 return plt
->vma
+ i
* PLT64_ENTRY_SIZE
+ j
* 4 * 6;
3771 return rel
->address
;