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., 59 Temple Place - Suite 330, 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 BFD_ASSERT (r_type
< (unsigned int) R_SPARC_max_std
);
401 return &_bfd_sparc_elf_howto_table
[r_type
];
405 /* Both 32-bit and 64-bit sparc encode this in an identical manner,
406 so just take advantage of that. */
407 #define SPARC_ELF_R_TYPE(r_info) \
411 _bfd_sparc_elf_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*cache_ptr
,
412 Elf_Internal_Rela
*dst
)
414 unsigned int r_type
= SPARC_ELF_R_TYPE (dst
->r_info
);
416 cache_ptr
->howto
= _bfd_sparc_elf_info_to_howto_ptr (r_type
);
420 /* The nop opcode we use. */
421 #define SPARC_NOP 0x01000000
423 #define SPARC_INSN_BYTES 4
425 /* The SPARC linker needs to keep track of the number of relocs that it
426 decides to copy as dynamic relocs in check_relocs for each symbol.
427 This is so that it can later discard them if they are found to be
428 unnecessary. We store the information in a field extending the
429 regular ELF linker hash table. */
431 struct _bfd_sparc_elf_dyn_relocs
433 struct _bfd_sparc_elf_dyn_relocs
*next
;
435 /* The input section of the reloc. */
438 /* Total number of relocs copied for the input section. */
441 /* Number of pc-relative relocs copied for the input section. */
442 bfd_size_type pc_count
;
445 /* SPARC ELF linker hash entry. */
447 struct _bfd_sparc_elf_link_hash_entry
449 struct elf_link_hash_entry elf
;
451 /* Track dynamic relocs copied for this symbol. */
452 struct _bfd_sparc_elf_dyn_relocs
*dyn_relocs
;
454 #define GOT_UNKNOWN 0
458 unsigned char tls_type
;
461 #define _bfd_sparc_elf_hash_entry(ent) ((struct _bfd_sparc_elf_link_hash_entry *)(ent))
463 struct _bfd_sparc_elf_obj_tdata
465 struct elf_obj_tdata root
;
467 /* tls_type for each local got entry. */
468 char *local_got_tls_type
;
470 /* TRUE if TLS GD relocs has been seen for this object. */
471 bfd_boolean has_tlsgd
;
474 #define _bfd_sparc_elf_tdata(abfd) \
475 ((struct _bfd_sparc_elf_obj_tdata *) (abfd)->tdata.any)
477 #define _bfd_sparc_elf_local_got_tls_type(abfd) \
478 (_bfd_sparc_elf_tdata (abfd)->local_got_tls_type)
481 _bfd_sparc_elf_mkobject (bfd
*abfd
)
483 bfd_size_type amt
= sizeof (struct _bfd_sparc_elf_obj_tdata
);
484 abfd
->tdata
.any
= bfd_zalloc (abfd
, amt
);
485 if (abfd
->tdata
.any
== NULL
)
491 sparc_put_word_32 (bfd
*bfd
, bfd_vma val
, void *ptr
)
493 bfd_put_32 (bfd
, val
, ptr
);
497 sparc_put_word_64 (bfd
*bfd
, bfd_vma val
, void *ptr
)
499 bfd_put_64 (bfd
, val
, ptr
);
503 sparc_elf_append_rela_64 (bfd
*abfd ATTRIBUTE_UNUSED
,
504 asection
*s ATTRIBUTE_UNUSED
,
505 Elf_Internal_Rela
*rel ATTRIBUTE_UNUSED
)
508 Elf64_External_Rela
*loc64
;
510 loc64
= (Elf64_External_Rela
*) s
->contents
;
511 loc64
+= s
->reloc_count
++;
512 bfd_elf64_swap_reloca_out (abfd
, rel
, (bfd_byte
*) loc64
);
517 sparc_elf_append_rela_32 (bfd
*abfd
, asection
*s
, Elf_Internal_Rela
*rel
)
519 Elf32_External_Rela
*loc32
;
521 loc32
= (Elf32_External_Rela
*) s
->contents
;
522 loc32
+= s
->reloc_count
++;
523 bfd_elf32_swap_reloca_out (abfd
, rel
, (bfd_byte
*) loc32
);
527 sparc_elf_r_info_64 (Elf_Internal_Rela
*in_rel ATTRIBUTE_UNUSED
,
528 bfd_vma index ATTRIBUTE_UNUSED
,
529 bfd_vma type ATTRIBUTE_UNUSED
)
531 return ELF64_R_INFO (index
,
533 ELF64_R_TYPE_INFO (ELF64_R_TYPE_DATA (in_rel
->r_info
),
538 sparc_elf_r_info_32 (Elf_Internal_Rela
*in_rel ATTRIBUTE_UNUSED
,
539 bfd_vma index
, bfd_vma type
)
541 return ELF32_R_INFO (index
, type
);
545 sparc_elf_r_symndx_64 (bfd_vma r_info
)
547 bfd_vma r_symndx
= ELF32_R_SYM (r_info
);
548 return (r_symndx
>> 24);
552 sparc_elf_r_symndx_32 (bfd_vma r_info
)
554 return ELF32_R_SYM (r_info
);
559 #define PLT32_ENTRY_SIZE 12
560 #define PLT32_HEADER_SIZE (4 * PLT32_ENTRY_SIZE)
562 /* The first four entries in a 32-bit procedure linkage table are reserved,
563 and the initial contents are unimportant (we zero them out).
564 Subsequent entries look like this. See the SVR4 ABI SPARC
565 supplement to see how this works. */
567 /* sethi %hi(.-.plt0),%g1. We fill in the address later. */
568 #define PLT32_ENTRY_WORD0 0x03000000
569 /* b,a .plt0. We fill in the offset later. */
570 #define PLT32_ENTRY_WORD1 0x30800000
572 #define PLT32_ENTRY_WORD2 SPARC_NOP
575 sparc32_plt_entry_build (bfd
*output_bfd
, asection
*splt
, bfd_vma offset
,
576 bfd_vma max ATTRIBUTE_UNUSED
,
579 bfd_put_32 (output_bfd
,
580 PLT32_ENTRY_WORD0
+ offset
,
581 splt
->contents
+ offset
);
582 bfd_put_32 (output_bfd
,
584 + (((- (offset
+ 4)) >> 2) & 0x3fffff)),
585 splt
->contents
+ offset
+ 4);
586 bfd_put_32 (output_bfd
, (bfd_vma
) PLT32_ENTRY_WORD2
,
587 splt
->contents
+ offset
+ 8);
591 return offset
/ PLT32_ENTRY_SIZE
- 4;
594 /* Both the headers and the entries are icache aligned. */
595 #define PLT64_ENTRY_SIZE 32
596 #define PLT64_HEADER_SIZE (4 * PLT64_ENTRY_SIZE)
597 #define PLT64_LARGE_THRESHOLD 32768
600 sparc64_plt_entry_build (bfd
*output_bfd
, asection
*splt
, bfd_vma offset
,
601 bfd_vma max
, bfd_vma
*r_offset
)
603 unsigned char *entry
= splt
->contents
+ offset
;
604 const unsigned int nop
= SPARC_NOP
;
607 if (offset
< (PLT64_LARGE_THRESHOLD
* PLT64_ENTRY_SIZE
))
609 unsigned int sethi
, ba
;
613 index
= (offset
/ PLT64_ENTRY_SIZE
);
615 sethi
= 0x03000000 | (index
* PLT64_ENTRY_SIZE
);
617 | (((splt
->contents
+ PLT64_ENTRY_SIZE
) - (entry
+ 4)) / 4 & 0x7ffff);
619 bfd_put_32 (output_bfd
, (bfd_vma
) sethi
, entry
);
620 bfd_put_32 (output_bfd
, (bfd_vma
) ba
, entry
+ 4);
621 bfd_put_32 (output_bfd
, (bfd_vma
) nop
, entry
+ 8);
622 bfd_put_32 (output_bfd
, (bfd_vma
) nop
, entry
+ 12);
623 bfd_put_32 (output_bfd
, (bfd_vma
) nop
, entry
+ 16);
624 bfd_put_32 (output_bfd
, (bfd_vma
) nop
, entry
+ 20);
625 bfd_put_32 (output_bfd
, (bfd_vma
) nop
, entry
+ 24);
626 bfd_put_32 (output_bfd
, (bfd_vma
) nop
, entry
+ 28);
632 int block
, last_block
, ofs
, last_ofs
, chunks_this_block
;
633 const int insn_chunk_size
= (6 * 4);
634 const int ptr_chunk_size
= (1 * 8);
635 const int entries_per_block
= 160;
636 const int block_size
= entries_per_block
* (insn_chunk_size
639 /* Entries 32768 and higher are grouped into blocks of 160.
640 The blocks are further subdivided into 160 sequences of
641 6 instructions and 160 pointers. If a block does not require
642 the full 160 entries, let's say it requires N, then there
643 will be N sequences of 6 instructions and N pointers. */
645 offset
-= (PLT64_LARGE_THRESHOLD
* PLT64_ENTRY_SIZE
);
646 max
-= (PLT64_LARGE_THRESHOLD
* PLT64_ENTRY_SIZE
);
648 block
= offset
/ block_size
;
649 last_block
= max
/ block_size
;
650 if (block
!= last_block
)
652 chunks_this_block
= 160;
656 last_ofs
= max
% block_size
;
657 chunks_this_block
= last_ofs
/ (insn_chunk_size
+ ptr_chunk_size
);
660 ofs
= offset
% block_size
;
662 index
= (PLT64_LARGE_THRESHOLD
+
664 (ofs
/ insn_chunk_size
));
667 + (PLT64_LARGE_THRESHOLD
* PLT64_ENTRY_SIZE
)
668 + (block
* block_size
)
669 + (chunks_this_block
* insn_chunk_size
)
670 + (ofs
/ insn_chunk_size
) * ptr_chunk_size
;
672 *r_offset
= (bfd_vma
) (ptr
- splt
->contents
);
674 ldx
= 0xc25be000 | ((ptr
- (entry
+4)) & 0x1fff);
682 bfd_put_32 (output_bfd
, (bfd_vma
) 0x8a10000f, entry
);
683 bfd_put_32 (output_bfd
, (bfd_vma
) 0x40000002, entry
+ 4);
684 bfd_put_32 (output_bfd
, (bfd_vma
) SPARC_NOP
, entry
+ 8);
685 bfd_put_32 (output_bfd
, (bfd_vma
) ldx
, entry
+ 12);
686 bfd_put_32 (output_bfd
, (bfd_vma
) 0x83c3c001, entry
+ 16);
687 bfd_put_32 (output_bfd
, (bfd_vma
) 0x9e100005, entry
+ 20);
689 bfd_put_64 (output_bfd
, (bfd_vma
) (splt
->contents
- (entry
+ 4)), ptr
);
695 #define SPARC_ELF_PUT_WORD(htab, bfd, val, ptr) \
696 htab->put_word(bfd, val, ptr)
698 #define SPARC_ELF_APPEND_RELA(htab, bfd, sec, rela) \
699 htab->append_rela(bfd, sec, rela)
701 #define SPARC_ELF_R_INFO(htab, in_rel, index, type) \
702 htab->r_info(in_rel, index, type)
704 #define SPARC_ELF_R_SYMNDX(htab, r_info) \
705 htab->r_symndx(r_info)
707 #define SPARC_ELF_WORD_BYTES(htab) \
710 #define SPARC_ELF_RELA_BYTES(htab) \
713 #define SPARC_ELF_DTPOFF_RELOC(htab) \
716 #define SPARC_ELF_DTPMOD_RELOC(htab) \
719 #define SPARC_ELF_TPOFF_RELOC(htab) \
722 #define SPARC_ELF_BUILD_PLT_ENTRY(htab, obfd, splt, off, max, r_off) \
723 htab->build_plt_entry (obfd, splt, off, max, r_off)
725 /* Create an entry in an SPARC ELF linker hash table. */
727 static struct bfd_hash_entry
*
728 link_hash_newfunc (struct bfd_hash_entry
*entry
,
729 struct bfd_hash_table
*table
, const char *string
)
731 /* Allocate the structure if it has not already been allocated by a
735 entry
= bfd_hash_allocate (table
,
736 sizeof (struct _bfd_sparc_elf_link_hash_entry
));
741 /* Call the allocation method of the superclass. */
742 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
745 struct _bfd_sparc_elf_link_hash_entry
*eh
;
747 eh
= (struct _bfd_sparc_elf_link_hash_entry
*) entry
;
748 eh
->dyn_relocs
= NULL
;
749 eh
->tls_type
= GOT_UNKNOWN
;
755 /* The name of the dynamic interpreter. This is put in the .interp
758 #define ELF32_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
759 #define ELF64_DYNAMIC_INTERPRETER "/usr/lib/sparcv9/ld.so.1"
761 /* Create a SPARC ELF linker hash table. */
763 struct bfd_link_hash_table
*
764 _bfd_sparc_elf_link_hash_table_create (bfd
*abfd
)
766 struct _bfd_sparc_elf_link_hash_table
*ret
;
767 bfd_size_type amt
= sizeof (struct _bfd_sparc_elf_link_hash_table
);
769 ret
= (struct _bfd_sparc_elf_link_hash_table
*) bfd_zmalloc (amt
);
775 ret
->put_word
= sparc_put_word_64
;
776 ret
->append_rela
= sparc_elf_append_rela_64
;
777 ret
->r_info
= sparc_elf_r_info_64
;
778 ret
->r_symndx
= sparc_elf_r_symndx_64
;
779 ret
->build_plt_entry
= sparc64_plt_entry_build
;
780 ret
->dtpoff_reloc
= R_SPARC_TLS_DTPOFF64
;
781 ret
->dtpmod_reloc
= R_SPARC_TLS_DTPMOD64
;
782 ret
->tpoff_reloc
= R_SPARC_TLS_TPOFF64
;
783 ret
->word_align_power
= 3;
784 ret
->align_power_max
= 4;
785 ret
->bytes_per_word
= 8;
786 ret
->bytes_per_rela
= sizeof (Elf64_External_Rela
);
787 ret
->dynamic_interpreter
= ELF64_DYNAMIC_INTERPRETER
;
788 ret
->dynamic_interpreter_size
= sizeof ELF64_DYNAMIC_INTERPRETER
;
792 ret
->put_word
= sparc_put_word_32
;
793 ret
->append_rela
= sparc_elf_append_rela_32
;
794 ret
->r_info
= sparc_elf_r_info_32
;
795 ret
->r_symndx
= sparc_elf_r_symndx_32
;
796 ret
->build_plt_entry
= sparc32_plt_entry_build
;
797 ret
->dtpoff_reloc
= R_SPARC_TLS_DTPOFF32
;
798 ret
->dtpmod_reloc
= R_SPARC_TLS_DTPMOD32
;
799 ret
->tpoff_reloc
= R_SPARC_TLS_TPOFF32
;
800 ret
->word_align_power
= 2;
801 ret
->align_power_max
= 3;
802 ret
->bytes_per_word
= 4;
803 ret
->bytes_per_rela
= sizeof (Elf32_External_Rela
);
804 ret
->dynamic_interpreter
= ELF32_DYNAMIC_INTERPRETER
;
805 ret
->dynamic_interpreter_size
= sizeof ELF32_DYNAMIC_INTERPRETER
;
808 if (! _bfd_elf_link_hash_table_init (&ret
->elf
, abfd
, link_hash_newfunc
))
814 return &ret
->elf
.root
;
817 /* Create .got and .rela.got sections in DYNOBJ, and set up
818 shortcuts to them in our hash table. */
821 create_got_section (bfd
*dynobj
, struct bfd_link_info
*info
)
823 struct _bfd_sparc_elf_link_hash_table
*htab
;
825 if (! _bfd_elf_create_got_section (dynobj
, info
))
828 htab
= _bfd_sparc_elf_hash_table (info
);
829 htab
->sgot
= bfd_get_section_by_name (dynobj
, ".got");
830 BFD_ASSERT (htab
->sgot
!= NULL
);
832 htab
->srelgot
= bfd_make_section (dynobj
, ".rela.got");
833 if (htab
->srelgot
== NULL
834 || ! bfd_set_section_flags (dynobj
, htab
->srelgot
, SEC_ALLOC
840 || ! bfd_set_section_alignment (dynobj
, htab
->srelgot
,
841 htab
->word_align_power
))
846 /* Create .plt, .rela.plt, .got, .rela.got, .dynbss, and
847 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
851 _bfd_sparc_elf_create_dynamic_sections (bfd
*dynobj
,
852 struct bfd_link_info
*info
)
854 struct _bfd_sparc_elf_link_hash_table
*htab
;
856 htab
= _bfd_sparc_elf_hash_table (info
);
857 if (!htab
->sgot
&& !create_got_section (dynobj
, info
))
860 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
863 htab
->splt
= bfd_get_section_by_name (dynobj
, ".plt");
864 htab
->srelplt
= bfd_get_section_by_name (dynobj
, ".rela.plt");
865 htab
->sdynbss
= bfd_get_section_by_name (dynobj
, ".dynbss");
867 htab
->srelbss
= bfd_get_section_by_name (dynobj
, ".rela.bss");
869 if (!htab
->splt
|| !htab
->srelplt
|| !htab
->sdynbss
870 || (!info
->shared
&& !htab
->srelbss
))
876 /* Copy the extra info we tack onto an elf_link_hash_entry. */
879 _bfd_sparc_elf_copy_indirect_symbol (const struct elf_backend_data
*bed
,
880 struct elf_link_hash_entry
*dir
,
881 struct elf_link_hash_entry
*ind
)
883 struct _bfd_sparc_elf_link_hash_entry
*edir
, *eind
;
885 edir
= (struct _bfd_sparc_elf_link_hash_entry
*) dir
;
886 eind
= (struct _bfd_sparc_elf_link_hash_entry
*) ind
;
888 if (eind
->dyn_relocs
!= NULL
)
890 if (edir
->dyn_relocs
!= NULL
)
892 struct _bfd_sparc_elf_dyn_relocs
**pp
;
893 struct _bfd_sparc_elf_dyn_relocs
*p
;
895 if (ind
->root
.type
== bfd_link_hash_indirect
)
898 /* Add reloc counts against the weak sym to the strong sym
899 list. Merge any entries against the same section. */
900 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
902 struct _bfd_sparc_elf_dyn_relocs
*q
;
904 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
905 if (q
->sec
== p
->sec
)
907 q
->pc_count
+= p
->pc_count
;
908 q
->count
+= p
->count
;
915 *pp
= edir
->dyn_relocs
;
918 edir
->dyn_relocs
= eind
->dyn_relocs
;
919 eind
->dyn_relocs
= NULL
;
922 if (ind
->root
.type
== bfd_link_hash_indirect
923 && dir
->got
.refcount
<= 0)
925 edir
->tls_type
= eind
->tls_type
;
926 eind
->tls_type
= GOT_UNKNOWN
;
928 _bfd_elf_link_hash_copy_indirect (bed
, dir
, ind
);
932 sparc_elf_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
933 int r_type
, int is_local
)
935 if (! ABI_64_P (abfd
)
936 && r_type
== R_SPARC_TLS_GD_HI22
937 && ! _bfd_sparc_elf_tdata (abfd
)->has_tlsgd
)
938 r_type
= R_SPARC_REV32
;
945 case R_SPARC_TLS_GD_HI22
:
947 return R_SPARC_TLS_LE_HIX22
;
948 return R_SPARC_TLS_IE_HI22
;
949 case R_SPARC_TLS_GD_LO10
:
951 return R_SPARC_TLS_LE_LOX10
;
952 return R_SPARC_TLS_IE_LO10
;
953 case R_SPARC_TLS_IE_HI22
:
955 return R_SPARC_TLS_LE_HIX22
;
957 case R_SPARC_TLS_IE_LO10
:
959 return R_SPARC_TLS_LE_LOX10
;
961 case R_SPARC_TLS_LDM_HI22
:
962 return R_SPARC_TLS_LE_HIX22
;
963 case R_SPARC_TLS_LDM_LO10
:
964 return R_SPARC_TLS_LE_LOX10
;
970 /* Look through the relocs for a section during the first phase, and
971 allocate space in the global offset table or procedure linkage
975 _bfd_sparc_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
976 asection
*sec
, const Elf_Internal_Rela
*relocs
)
978 struct _bfd_sparc_elf_link_hash_table
*htab
;
979 Elf_Internal_Shdr
*symtab_hdr
;
980 struct elf_link_hash_entry
**sym_hashes
;
981 bfd_vma
*local_got_offsets
;
982 const Elf_Internal_Rela
*rel
;
983 const Elf_Internal_Rela
*rel_end
;
986 bfd_boolean checked_tlsgd
= FALSE
;
988 if (info
->relocatable
)
991 htab
= _bfd_sparc_elf_hash_table (info
);
992 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
993 sym_hashes
= elf_sym_hashes (abfd
);
994 local_got_offsets
= elf_local_got_offsets (abfd
);
999 num_relocs
= NUM_SHDR_ENTRIES (& elf_section_data (sec
)->rel_hdr
);
1001 num_relocs
= sec
->reloc_count
;
1002 rel_end
= relocs
+ num_relocs
;
1003 for (rel
= relocs
; rel
< rel_end
; rel
++)
1005 unsigned int r_type
;
1006 unsigned long r_symndx
;
1007 struct elf_link_hash_entry
*h
;
1009 r_symndx
= SPARC_ELF_R_SYMNDX (htab
, rel
->r_info
);
1010 r_type
= SPARC_ELF_R_TYPE (rel
->r_info
);
1012 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1014 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
1019 if (r_symndx
< symtab_hdr
->sh_info
)
1022 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1024 /* Compatibility with old R_SPARC_REV32 reloc conflicting
1025 with R_SPARC_TLS_GD_HI22. */
1026 if (! ABI_64_P (abfd
) && ! checked_tlsgd
)
1029 case R_SPARC_TLS_GD_HI22
:
1031 const Elf_Internal_Rela
*relt
;
1033 for (relt
= rel
+ 1; relt
< rel_end
; relt
++)
1034 if (ELF32_R_TYPE (relt
->r_info
) == R_SPARC_TLS_GD_LO10
1035 || ELF32_R_TYPE (relt
->r_info
) == R_SPARC_TLS_GD_ADD
1036 || ELF32_R_TYPE (relt
->r_info
) == R_SPARC_TLS_GD_CALL
)
1038 checked_tlsgd
= TRUE
;
1039 _bfd_sparc_elf_tdata (abfd
)->has_tlsgd
= relt
< rel_end
;
1042 case R_SPARC_TLS_GD_LO10
:
1043 case R_SPARC_TLS_GD_ADD
:
1044 case R_SPARC_TLS_GD_CALL
:
1045 checked_tlsgd
= TRUE
;
1046 _bfd_sparc_elf_tdata (abfd
)->has_tlsgd
= TRUE
;
1050 r_type
= sparc_elf_tls_transition (info
, abfd
, r_type
, h
== NULL
);
1053 case R_SPARC_TLS_LDM_HI22
:
1054 case R_SPARC_TLS_LDM_LO10
:
1055 htab
->tls_ldm_got
.refcount
+= 1;
1058 case R_SPARC_TLS_LE_HIX22
:
1059 case R_SPARC_TLS_LE_LOX10
:
1064 case R_SPARC_TLS_IE_HI22
:
1065 case R_SPARC_TLS_IE_LO10
:
1067 info
->flags
|= DF_STATIC_TLS
;
1073 case R_SPARC_TLS_GD_HI22
:
1074 case R_SPARC_TLS_GD_LO10
:
1075 /* This symbol requires a global offset table entry. */
1077 int tls_type
, old_tls_type
;
1085 tls_type
= GOT_NORMAL
;
1087 case R_SPARC_TLS_GD_HI22
:
1088 case R_SPARC_TLS_GD_LO10
:
1089 tls_type
= GOT_TLS_GD
;
1091 case R_SPARC_TLS_IE_HI22
:
1092 case R_SPARC_TLS_IE_LO10
:
1093 tls_type
= GOT_TLS_IE
;
1099 h
->got
.refcount
+= 1;
1100 old_tls_type
= _bfd_sparc_elf_hash_entry(h
)->tls_type
;
1104 bfd_signed_vma
*local_got_refcounts
;
1106 /* This is a global offset table entry for a local symbol. */
1107 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1108 if (local_got_refcounts
== NULL
)
1112 size
= symtab_hdr
->sh_info
;
1113 size
*= (sizeof (bfd_signed_vma
) + sizeof(char));
1114 local_got_refcounts
= ((bfd_signed_vma
*)
1115 bfd_zalloc (abfd
, size
));
1116 if (local_got_refcounts
== NULL
)
1118 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1119 _bfd_sparc_elf_local_got_tls_type (abfd
)
1120 = (char *) (local_got_refcounts
+ symtab_hdr
->sh_info
);
1122 local_got_refcounts
[r_symndx
] += 1;
1123 old_tls_type
= _bfd_sparc_elf_local_got_tls_type (abfd
) [r_symndx
];
1126 /* If a TLS symbol is accessed using IE at least once,
1127 there is no point to use dynamic model for it. */
1128 if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1129 && (old_tls_type
!= GOT_TLS_GD
1130 || tls_type
!= GOT_TLS_IE
))
1132 if (old_tls_type
== GOT_TLS_IE
&& tls_type
== GOT_TLS_GD
)
1133 tls_type
= old_tls_type
;
1136 (*_bfd_error_handler
)
1137 (_("%B: `%s' accessed both as normal and thread local symbol"),
1138 abfd
, h
? h
->root
.root
.string
: "<local>");
1143 if (old_tls_type
!= tls_type
)
1146 _bfd_sparc_elf_hash_entry (h
)->tls_type
= tls_type
;
1148 _bfd_sparc_elf_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1152 if (htab
->sgot
== NULL
)
1154 if (htab
->elf
.dynobj
== NULL
)
1155 htab
->elf
.dynobj
= abfd
;
1156 if (!create_got_section (htab
->elf
.dynobj
, info
))
1161 case R_SPARC_TLS_GD_CALL
:
1162 case R_SPARC_TLS_LDM_CALL
:
1165 /* These are basically R_SPARC_TLS_WPLT30 relocs against
1167 struct bfd_link_hash_entry
*bh
= NULL
;
1168 if (! _bfd_generic_link_add_one_symbol (info
, abfd
,
1169 "__tls_get_addr", 0,
1170 bfd_und_section_ptr
, 0,
1174 h
= (struct elf_link_hash_entry
*) bh
;
1181 case R_SPARC_WPLT30
:
1182 case R_SPARC_HIPLT22
:
1183 case R_SPARC_LOPLT10
:
1184 case R_SPARC_PCPLT32
:
1185 case R_SPARC_PCPLT22
:
1186 case R_SPARC_PCPLT10
:
1188 /* This symbol requires a procedure linkage table entry. We
1189 actually build the entry in adjust_dynamic_symbol,
1190 because this might be a case of linking PIC code without
1191 linking in any dynamic objects, in which case we don't
1192 need to generate a procedure linkage table after all. */
1196 if (! ABI_64_P (abfd
))
1198 /* The Solaris native assembler will generate a WPLT30
1199 reloc for a local symbol if you assemble a call from
1200 one section to another when using -K pic. We treat
1202 if (ELF32_R_TYPE (rel
->r_info
) == R_SPARC_PLT32
)
1207 /* It does not make sense to have a procedure linkage
1208 table entry for a local symbol. */
1209 bfd_set_error (bfd_error_bad_value
);
1218 this_r_type
= SPARC_ELF_R_TYPE (rel
->r_info
);
1219 if (this_r_type
== R_SPARC_PLT32
1220 || this_r_type
== R_SPARC_PLT64
)
1223 h
->plt
.refcount
+= 1;
1228 case R_SPARC_PC_HH22
:
1229 case R_SPARC_PC_HM10
:
1230 case R_SPARC_PC_LM22
:
1235 && strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
1240 case R_SPARC_DISP16
:
1241 case R_SPARC_DISP32
:
1242 case R_SPARC_DISP64
:
1243 case R_SPARC_WDISP30
:
1244 case R_SPARC_WDISP22
:
1245 case R_SPARC_WDISP19
:
1246 case R_SPARC_WDISP16
:
1276 if (h
!= NULL
&& !info
->shared
)
1278 /* We may need a .plt entry if the function this reloc
1279 refers to is in a shared lib. */
1280 h
->plt
.refcount
+= 1;
1283 /* If we are creating a shared library, and this is a reloc
1284 against a global symbol, or a non PC relative reloc
1285 against a local symbol, then we need to copy the reloc
1286 into the shared library. However, if we are linking with
1287 -Bsymbolic, we do not need to copy a reloc against a
1288 global symbol which is defined in an object we are
1289 including in the link (i.e., DEF_REGULAR is set). At
1290 this point we have not seen all the input files, so it is
1291 possible that DEF_REGULAR is not set now but will be set
1292 later (it is never cleared). In case of a weak definition,
1293 DEF_REGULAR may be cleared later by a strong definition in
1294 a shared library. We account for that possibility below by
1295 storing information in the relocs_copied field of the hash
1296 table entry. A similar situation occurs when creating
1297 shared libraries and symbol visibility changes render the
1300 If on the other hand, we are creating an executable, we
1301 may need to keep relocations for symbols satisfied by a
1302 dynamic library if we manage to avoid copy relocs for the
1305 && (sec
->flags
& SEC_ALLOC
) != 0
1306 && (! _bfd_sparc_elf_howto_table
[r_type
].pc_relative
1308 && (! info
->symbolic
1309 || h
->root
.type
== bfd_link_hash_defweak
1310 || !h
->def_regular
))))
1312 && (sec
->flags
& SEC_ALLOC
) != 0
1314 && (h
->root
.type
== bfd_link_hash_defweak
1315 || !h
->def_regular
)))
1317 struct _bfd_sparc_elf_dyn_relocs
*p
;
1318 struct _bfd_sparc_elf_dyn_relocs
**head
;
1320 /* When creating a shared object, we must copy these
1321 relocs into the output file. We create a reloc
1322 section in dynobj and make room for the reloc. */
1328 name
= (bfd_elf_string_from_elf_section
1330 elf_elfheader (abfd
)->e_shstrndx
,
1331 elf_section_data (sec
)->rel_hdr
.sh_name
));
1335 BFD_ASSERT (strncmp (name
, ".rela", 5) == 0
1336 && strcmp (bfd_get_section_name (abfd
, sec
),
1339 if (htab
->elf
.dynobj
== NULL
)
1340 htab
->elf
.dynobj
= abfd
;
1341 dynobj
= htab
->elf
.dynobj
;
1343 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1348 sreloc
= bfd_make_section (dynobj
, name
);
1349 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
1350 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
1351 if ((sec
->flags
& SEC_ALLOC
) != 0)
1352 flags
|= SEC_ALLOC
| SEC_LOAD
;
1354 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
1355 || ! bfd_set_section_alignment (dynobj
, sreloc
,
1356 htab
->word_align_power
))
1359 elf_section_data (sec
)->sreloc
= sreloc
;
1362 /* If this is a global symbol, we count the number of
1363 relocations we need for this symbol. */
1365 head
= &((struct _bfd_sparc_elf_link_hash_entry
*) h
)->dyn_relocs
;
1368 /* Track dynamic relocs needed for local syms too.
1369 We really need local syms available to do this
1373 s
= bfd_section_from_r_symndx (abfd
, &htab
->sym_sec
,
1378 head
= ((struct _bfd_sparc_elf_dyn_relocs
**)
1379 &elf_section_data (s
)->local_dynrel
);
1383 if (p
== NULL
|| p
->sec
!= sec
)
1385 bfd_size_type amt
= sizeof *p
;
1386 p
= ((struct _bfd_sparc_elf_dyn_relocs
*)
1387 bfd_alloc (htab
->elf
.dynobj
, amt
));
1398 if (_bfd_sparc_elf_howto_table
[r_type
].pc_relative
)
1404 case R_SPARC_GNU_VTINHERIT
:
1405 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1409 case R_SPARC_GNU_VTENTRY
:
1410 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
1414 case R_SPARC_REGISTER
:
1415 /* Nothing to do. */
1427 _bfd_sparc_elf_gc_mark_hook (asection
*sec
,
1428 struct bfd_link_info
*info
,
1429 Elf_Internal_Rela
*rel
,
1430 struct elf_link_hash_entry
*h
,
1431 Elf_Internal_Sym
*sym
)
1435 struct _bfd_sparc_elf_link_hash_table
*htab
;
1437 htab
= _bfd_sparc_elf_hash_table (info
);
1438 switch (SPARC_ELF_R_TYPE (rel
->r_info
))
1440 case R_SPARC_GNU_VTINHERIT
:
1441 case R_SPARC_GNU_VTENTRY
:
1445 switch (h
->root
.type
)
1447 case bfd_link_hash_defined
:
1448 case bfd_link_hash_defweak
:
1449 return h
->root
.u
.def
.section
;
1451 case bfd_link_hash_common
:
1452 return h
->root
.u
.c
.p
->section
;
1460 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
1465 /* Update the got entry reference counts for the section being removed. */
1467 _bfd_sparc_elf_gc_sweep_hook (bfd
*abfd
, struct bfd_link_info
*info
,
1468 asection
*sec
, const Elf_Internal_Rela
*relocs
)
1470 struct _bfd_sparc_elf_link_hash_table
*htab
;
1471 Elf_Internal_Shdr
*symtab_hdr
;
1472 struct elf_link_hash_entry
**sym_hashes
;
1473 bfd_signed_vma
*local_got_refcounts
;
1474 const Elf_Internal_Rela
*rel
, *relend
;
1476 elf_section_data (sec
)->local_dynrel
= NULL
;
1478 htab
= _bfd_sparc_elf_hash_table (info
);
1479 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1480 sym_hashes
= elf_sym_hashes (abfd
);
1481 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1483 relend
= relocs
+ sec
->reloc_count
;
1484 for (rel
= relocs
; rel
< relend
; rel
++)
1486 unsigned long r_symndx
;
1487 unsigned int r_type
;
1488 struct elf_link_hash_entry
*h
= NULL
;
1490 r_symndx
= SPARC_ELF_R_SYMNDX (htab
, rel
->r_info
);
1491 if (r_symndx
>= symtab_hdr
->sh_info
)
1493 struct _bfd_sparc_elf_link_hash_entry
*eh
;
1494 struct _bfd_sparc_elf_dyn_relocs
**pp
;
1495 struct _bfd_sparc_elf_dyn_relocs
*p
;
1497 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1498 while (h
->root
.type
== bfd_link_hash_indirect
1499 || h
->root
.type
== bfd_link_hash_warning
)
1500 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1501 eh
= (struct _bfd_sparc_elf_link_hash_entry
*) h
;
1502 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
1505 /* Everything must go for SEC. */
1511 r_type
= SPARC_ELF_R_TYPE (rel
->r_info
);
1512 r_type
= sparc_elf_tls_transition (info
, abfd
, r_type
, h
!= NULL
);
1515 case R_SPARC_TLS_LDM_HI22
:
1516 case R_SPARC_TLS_LDM_LO10
:
1517 if (_bfd_sparc_elf_hash_table (info
)->tls_ldm_got
.refcount
> 0)
1518 _bfd_sparc_elf_hash_table (info
)->tls_ldm_got
.refcount
-= 1;
1521 case R_SPARC_TLS_GD_HI22
:
1522 case R_SPARC_TLS_GD_LO10
:
1523 case R_SPARC_TLS_IE_HI22
:
1524 case R_SPARC_TLS_IE_LO10
:
1530 if (h
->got
.refcount
> 0)
1535 if (local_got_refcounts
[r_symndx
] > 0)
1536 local_got_refcounts
[r_symndx
]--;
1542 case R_SPARC_PC_HH22
:
1543 case R_SPARC_PC_HM10
:
1544 case R_SPARC_PC_LM22
:
1546 && strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
1551 case R_SPARC_DISP16
:
1552 case R_SPARC_DISP32
:
1553 case R_SPARC_DISP64
:
1554 case R_SPARC_WDISP30
:
1555 case R_SPARC_WDISP22
:
1556 case R_SPARC_WDISP19
:
1557 case R_SPARC_WDISP16
:
1588 case R_SPARC_WPLT30
:
1591 if (h
->plt
.refcount
> 0)
1604 /* Adjust a symbol defined by a dynamic object and referenced by a
1605 regular object. The current definition is in some section of the
1606 dynamic object, but we're not including those sections. We have to
1607 change the definition to something the rest of the link can
1611 _bfd_sparc_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
1612 struct elf_link_hash_entry
*h
)
1614 struct _bfd_sparc_elf_link_hash_table
*htab
;
1615 struct _bfd_sparc_elf_link_hash_entry
* eh
;
1616 struct _bfd_sparc_elf_dyn_relocs
*p
;
1618 unsigned int power_of_two
;
1620 htab
= _bfd_sparc_elf_hash_table (info
);
1622 /* Make sure we know what is going on here. */
1623 BFD_ASSERT (htab
->elf
.dynobj
!= NULL
1625 || h
->u
.weakdef
!= NULL
1628 && !h
->def_regular
)));
1630 /* If this is a function, put it in the procedure linkage table. We
1631 will fill in the contents of the procedure linkage table later
1632 (although we could actually do it here). The STT_NOTYPE
1633 condition is a hack specifically for the Oracle libraries
1634 delivered for Solaris; for some inexplicable reason, they define
1635 some of their functions as STT_NOTYPE when they really should be
1637 if (h
->type
== STT_FUNC
1639 || (h
->type
== STT_NOTYPE
1640 && (h
->root
.type
== bfd_link_hash_defined
1641 || h
->root
.type
== bfd_link_hash_defweak
)
1642 && (h
->root
.u
.def
.section
->flags
& SEC_CODE
) != 0))
1644 if (h
->plt
.refcount
<= 0
1648 && h
->root
.type
!= bfd_link_hash_undefweak
1649 && h
->root
.type
!= bfd_link_hash_undefined
))
1651 /* This case can occur if we saw a WPLT30 reloc in an input
1652 file, but the symbol was never referred to by a dynamic
1653 object, or if all references were garbage collected. In
1654 such a case, we don't actually need to build a procedure
1655 linkage table, and we can just do a WDISP30 reloc instead. */
1656 h
->plt
.offset
= (bfd_vma
) -1;
1663 h
->plt
.offset
= (bfd_vma
) -1;
1665 /* If this is a weak symbol, and there is a real definition, the
1666 processor independent code will have arranged for us to see the
1667 real definition first, and we can just use the same value. */
1668 if (h
->u
.weakdef
!= NULL
)
1670 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
1671 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
1672 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
1673 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
1677 /* This is a reference to a symbol defined by a dynamic object which
1678 is not a function. */
1680 /* If we are creating a shared library, we must presume that the
1681 only references to the symbol are via the global offset table.
1682 For such cases we need not do anything here; the relocations will
1683 be handled correctly by relocate_section. */
1687 /* If there are no references to this symbol that do not use the
1688 GOT, we don't need to generate a copy reloc. */
1689 if (!h
->non_got_ref
)
1692 eh
= (struct _bfd_sparc_elf_link_hash_entry
*) h
;
1693 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1695 s
= p
->sec
->output_section
;
1696 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1700 /* If we didn't find any dynamic relocs in read-only sections, then
1701 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1708 /* We must allocate the symbol in our .dynbss section, which will
1709 become part of the .bss section of the executable. There will be
1710 an entry for this symbol in the .dynsym section. The dynamic
1711 object will contain position independent code, so all references
1712 from the dynamic object to this symbol will go through the global
1713 offset table. The dynamic linker will use the .dynsym entry to
1714 determine the address it must put in the global offset table, so
1715 both the dynamic object and the regular object will refer to the
1716 same memory location for the variable. */
1718 /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker
1719 to copy the initial value out of the dynamic object and into the
1720 runtime process image. We need to remember the offset into the
1721 .rel.bss section we are going to use. */
1722 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
1724 htab
->srelbss
->size
+= SPARC_ELF_RELA_BYTES (htab
);
1728 /* We need to figure out the alignment required for this symbol. I
1729 have no idea how ELF linkers handle this. */
1730 power_of_two
= bfd_log2 (h
->size
);
1731 if (power_of_two
> htab
->align_power_max
)
1732 power_of_two
= htab
->align_power_max
;
1734 /* Apply the required alignment. */
1736 s
->size
= BFD_ALIGN (s
->size
, (bfd_size_type
) (1 << power_of_two
));
1737 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
1739 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
1743 /* Define the symbol as being at this point in the section. */
1744 h
->root
.u
.def
.section
= s
;
1745 h
->root
.u
.def
.value
= s
->size
;
1747 /* Increment the section size to make room for the symbol. */
1753 /* Allocate space in .plt, .got and associated reloc sections for
1757 allocate_dynrelocs (struct elf_link_hash_entry
*h
, PTR inf
)
1759 struct bfd_link_info
*info
;
1760 struct _bfd_sparc_elf_link_hash_table
*htab
;
1761 struct _bfd_sparc_elf_link_hash_entry
*eh
;
1762 struct _bfd_sparc_elf_dyn_relocs
*p
;
1764 if (h
->root
.type
== bfd_link_hash_indirect
)
1767 if (h
->root
.type
== bfd_link_hash_warning
)
1768 /* When warning symbols are created, they **replace** the "real"
1769 entry in the hash table, thus we never get to see the real
1770 symbol in a hash traversal. So look at it now. */
1771 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1773 info
= (struct bfd_link_info
*) inf
;
1774 htab
= _bfd_sparc_elf_hash_table (info
);
1776 if (htab
->elf
.dynamic_sections_created
1777 && h
->plt
.refcount
> 0)
1779 /* Make sure this symbol is output as a dynamic symbol.
1780 Undefined weak syms won't yet be marked as dynamic. */
1781 if (h
->dynindx
== -1
1782 && !h
->forced_local
)
1784 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1788 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info
->shared
, h
))
1790 asection
*s
= htab
->splt
;
1792 /* The first four entries in .plt is reserved. */
1794 s
->size
= (SPARC_ELF_WORD_BYTES(htab
) == 8 ?
1795 PLT64_HEADER_SIZE
: PLT32_HEADER_SIZE
);
1797 /* The procedure linkage table size is bounded by the magnitude
1798 of the offset we can describe in the entry. */
1799 if (s
->size
>= (SPARC_ELF_WORD_BYTES(htab
) == 8 ?
1800 (((bfd_vma
)1 << 31) << 1) : 0x400000))
1802 bfd_set_error (bfd_error_bad_value
);
1806 if (SPARC_ELF_WORD_BYTES(htab
) == 8
1807 && s
->size
>= PLT64_LARGE_THRESHOLD
* PLT64_ENTRY_SIZE
)
1809 bfd_vma off
= s
->size
- PLT64_LARGE_THRESHOLD
* PLT64_ENTRY_SIZE
;
1812 off
= (off
% (160 * PLT64_ENTRY_SIZE
)) / PLT64_ENTRY_SIZE
;
1814 h
->plt
.offset
= (s
->size
- (off
* 8));
1817 h
->plt
.offset
= s
->size
;
1819 /* If this symbol is not defined in a regular file, and we are
1820 not generating a shared library, then set the symbol to this
1821 location in the .plt. This is required to make function
1822 pointers compare as equal between the normal executable and
1823 the shared library. */
1827 h
->root
.u
.def
.section
= s
;
1828 h
->root
.u
.def
.value
= h
->plt
.offset
;
1831 /* Make room for this entry. */
1832 s
->size
+= (SPARC_ELF_WORD_BYTES(htab
) == 8 ?
1833 PLT64_ENTRY_SIZE
: PLT32_ENTRY_SIZE
);
1835 /* We also need to make an entry in the .rela.plt section. */
1836 htab
->srelplt
->size
+= SPARC_ELF_RELA_BYTES (htab
);
1840 h
->plt
.offset
= (bfd_vma
) -1;
1846 h
->plt
.offset
= (bfd_vma
) -1;
1850 /* If R_SPARC_TLS_IE_{HI22,LO10} symbol is now local to the binary,
1851 make it a R_SPARC_TLS_LE_{HI22,LO10} requiring no TLS entry. */
1852 if (h
->got
.refcount
> 0
1855 && _bfd_sparc_elf_hash_entry(h
)->tls_type
== GOT_TLS_IE
)
1856 h
->got
.offset
= (bfd_vma
) -1;
1857 else if (h
->got
.refcount
> 0)
1861 int tls_type
= _bfd_sparc_elf_hash_entry(h
)->tls_type
;
1863 /* Make sure this symbol is output as a dynamic symbol.
1864 Undefined weak syms won't yet be marked as dynamic. */
1865 if (h
->dynindx
== -1
1866 && !h
->forced_local
)
1868 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1873 h
->got
.offset
= s
->size
;
1874 s
->size
+= SPARC_ELF_WORD_BYTES (htab
);
1875 /* R_SPARC_TLS_GD_HI{22,LO10} needs 2 consecutive GOT slots. */
1876 if (tls_type
== GOT_TLS_GD
)
1877 s
->size
+= SPARC_ELF_WORD_BYTES (htab
);
1878 dyn
= htab
->elf
.dynamic_sections_created
;
1879 /* R_SPARC_TLS_IE_{HI22,LO10} needs one dynamic relocation,
1880 R_SPARC_TLS_GD_{HI22,LO10} needs one if local symbol and two if
1882 if ((tls_type
== GOT_TLS_GD
&& h
->dynindx
== -1)
1883 || tls_type
== GOT_TLS_IE
)
1884 htab
->srelgot
->size
+= SPARC_ELF_RELA_BYTES (htab
);
1885 else if (tls_type
== GOT_TLS_GD
)
1886 htab
->srelgot
->size
+= 2 * SPARC_ELF_RELA_BYTES (htab
);
1887 else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
))
1888 htab
->srelgot
->size
+= SPARC_ELF_RELA_BYTES (htab
);
1891 h
->got
.offset
= (bfd_vma
) -1;
1893 eh
= (struct _bfd_sparc_elf_link_hash_entry
*) h
;
1894 if (eh
->dyn_relocs
== NULL
)
1897 /* In the shared -Bsymbolic case, discard space allocated for
1898 dynamic pc-relative relocs against symbols which turn out to be
1899 defined in regular objects. For the normal shared case, discard
1900 space for pc-relative relocs that have become local due to symbol
1901 visibility changes. */
1909 struct _bfd_sparc_elf_dyn_relocs
**pp
;
1911 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
1913 p
->count
-= p
->pc_count
;
1924 /* For the non-shared case, discard space for relocs against
1925 symbols which turn out to need copy relocs or are not
1931 || (htab
->elf
.dynamic_sections_created
1932 && (h
->root
.type
== bfd_link_hash_undefweak
1933 || h
->root
.type
== bfd_link_hash_undefined
))))
1935 /* Make sure this symbol is output as a dynamic symbol.
1936 Undefined weak syms won't yet be marked as dynamic. */
1937 if (h
->dynindx
== -1
1938 && !h
->forced_local
)
1940 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1944 /* If that succeeded, we know we'll be keeping all the
1946 if (h
->dynindx
!= -1)
1950 eh
->dyn_relocs
= NULL
;
1955 /* Finally, allocate space. */
1956 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1958 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
1959 sreloc
->size
+= p
->count
* SPARC_ELF_RELA_BYTES (htab
);
1965 /* Find any dynamic relocs that apply to read-only sections. */
1968 readonly_dynrelocs (struct elf_link_hash_entry
*h
, PTR inf
)
1970 struct _bfd_sparc_elf_link_hash_entry
*eh
;
1971 struct _bfd_sparc_elf_dyn_relocs
*p
;
1973 if (h
->root
.type
== bfd_link_hash_warning
)
1974 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1976 eh
= (struct _bfd_sparc_elf_link_hash_entry
*) h
;
1977 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1979 asection
*s
= p
->sec
->output_section
;
1981 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1983 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
1985 info
->flags
|= DF_TEXTREL
;
1987 /* Not an error, just cut short the traversal. */
1994 /* Return true if the dynamic symbol for a given section should be
1995 omitted when creating a shared library. */
1998 _bfd_sparc_elf_omit_section_dynsym (bfd
*output_bfd
,
1999 struct bfd_link_info
*info
,
2002 /* We keep the .got section symbol so that explicit relocations
2003 against the _GLOBAL_OFFSET_TABLE_ symbol emitted in PIC mode
2004 can be turned into relocations against the .got symbol. */
2005 if (strcmp (p
->name
, ".got") == 0)
2008 return _bfd_elf_link_omit_section_dynsym (output_bfd
, info
, p
);
2011 /* Set the sizes of the dynamic sections. */
2014 _bfd_sparc_elf_size_dynamic_sections (bfd
*output_bfd
,
2015 struct bfd_link_info
*info
)
2017 struct _bfd_sparc_elf_link_hash_table
*htab
;
2022 htab
= _bfd_sparc_elf_hash_table (info
);
2023 dynobj
= htab
->elf
.dynobj
;
2024 BFD_ASSERT (dynobj
!= NULL
);
2026 if (elf_hash_table (info
)->dynamic_sections_created
)
2028 /* Set the contents of the .interp section to the interpreter. */
2029 if (info
->executable
)
2031 s
= bfd_get_section_by_name (dynobj
, ".interp");
2032 BFD_ASSERT (s
!= NULL
);
2033 s
->size
= htab
->dynamic_interpreter_size
;
2034 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
2038 /* Set up .got offsets for local syms, and space for local dynamic
2040 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
2042 bfd_signed_vma
*local_got
;
2043 bfd_signed_vma
*end_local_got
;
2044 char *local_tls_type
;
2045 bfd_size_type locsymcount
;
2046 Elf_Internal_Shdr
*symtab_hdr
;
2049 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
2052 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2054 struct _bfd_sparc_elf_dyn_relocs
*p
;
2056 for (p
= *((struct _bfd_sparc_elf_dyn_relocs
**)
2057 &elf_section_data (s
)->local_dynrel
);
2061 if (!bfd_is_abs_section (p
->sec
)
2062 && bfd_is_abs_section (p
->sec
->output_section
))
2064 /* Input section has been discarded, either because
2065 it is a copy of a linkonce section or due to
2066 linker script /DISCARD/, so we'll be discarding
2069 else if (p
->count
!= 0)
2071 srel
= elf_section_data (p
->sec
)->sreloc
;
2072 srel
->size
+= p
->count
* SPARC_ELF_RELA_BYTES (htab
);
2073 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
2074 info
->flags
|= DF_TEXTREL
;
2079 local_got
= elf_local_got_refcounts (ibfd
);
2083 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
2084 locsymcount
= symtab_hdr
->sh_info
;
2085 end_local_got
= local_got
+ locsymcount
;
2086 local_tls_type
= _bfd_sparc_elf_local_got_tls_type (ibfd
);
2088 srel
= htab
->srelgot
;
2089 for (; local_got
< end_local_got
; ++local_got
, ++local_tls_type
)
2093 *local_got
= s
->size
;
2094 s
->size
+= SPARC_ELF_WORD_BYTES (htab
);
2095 if (*local_tls_type
== GOT_TLS_GD
)
2096 s
->size
+= SPARC_ELF_WORD_BYTES (htab
);
2098 || *local_tls_type
== GOT_TLS_GD
2099 || *local_tls_type
== GOT_TLS_IE
)
2100 srel
->size
+= SPARC_ELF_RELA_BYTES (htab
);
2103 *local_got
= (bfd_vma
) -1;
2107 if (htab
->tls_ldm_got
.refcount
> 0)
2109 /* Allocate 2 got entries and 1 dynamic reloc for
2110 R_SPARC_TLS_LDM_{HI22,LO10} relocs. */
2111 htab
->tls_ldm_got
.offset
= htab
->sgot
->size
;
2112 htab
->sgot
->size
+= (2 * SPARC_ELF_WORD_BYTES (htab
));
2113 htab
->srelgot
->size
+= SPARC_ELF_RELA_BYTES (htab
);
2116 htab
->tls_ldm_got
.offset
= -1;
2118 /* Allocate global sym .plt and .got entries, and space for global
2119 sym dynamic relocs. */
2120 elf_link_hash_traverse (&htab
->elf
, allocate_dynrelocs
, (PTR
) info
);
2122 if (! ABI_64_P (output_bfd
)
2123 && elf_hash_table (info
)->dynamic_sections_created
)
2125 /* Make space for the trailing nop in .plt. */
2126 if (htab
->splt
->size
> 0)
2127 htab
->splt
->size
+= 1 * SPARC_INSN_BYTES
;
2129 /* If the .got section is more than 0x1000 bytes, we add
2130 0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13
2131 bit relocations have a greater chance of working.
2133 FIXME: Make this optimization work for 64-bit too. */
2134 if (htab
->sgot
->size
>= 0x1000
2135 && elf_hash_table (info
)->hgot
->root
.u
.def
.value
== 0)
2136 elf_hash_table (info
)->hgot
->root
.u
.def
.value
= 0x1000;
2139 /* The check_relocs and adjust_dynamic_symbol entry points have
2140 determined the sizes of the various dynamic sections. Allocate
2142 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2145 bfd_boolean strip
= FALSE
;
2147 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2150 /* It's OK to base decisions on the section name, because none
2151 of the dynobj section names depend upon the input files. */
2152 name
= bfd_get_section_name (dynobj
, s
);
2154 if (strncmp (name
, ".rela", 5) == 0)
2158 /* If we don't need this section, strip it from the
2159 output file. This is to handle .rela.bss and
2160 .rel.plt. We must create it in
2161 create_dynamic_sections, because it must be created
2162 before the linker maps input sections to output
2163 sections. The linker does that before
2164 adjust_dynamic_symbol is called, and it is that
2165 function which decides whether anything needs to go
2166 into these sections. */
2171 /* We use the reloc_count field as a counter if we need
2172 to copy relocs into the output file. */
2176 else if (s
!= htab
->splt
&& s
!= htab
->sgot
)
2178 /* It's not one of our sections, so don't allocate space. */
2184 _bfd_strip_section_from_output (info
, s
);
2188 /* Allocate memory for the section contents. Zero the memory
2189 for the benefit of .rela.plt, which has 4 unused entries
2190 at the beginning, and we don't want garbage. */
2191 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
2192 if (s
->contents
== NULL
&& s
->size
!= 0)
2196 if (elf_hash_table (info
)->dynamic_sections_created
)
2198 /* Add some entries to the .dynamic section. We fill in the
2199 values later, in _bfd_sparc_elf_finish_dynamic_sections, but we
2200 must add the entries now so that we get the correct size for
2201 the .dynamic section. The DT_DEBUG entry is filled in by the
2202 dynamic linker and used by the debugger. */
2203 #define add_dynamic_entry(TAG, VAL) \
2204 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2206 if (info
->executable
)
2208 if (!add_dynamic_entry (DT_DEBUG
, 0))
2212 if (htab
->srelplt
->size
!= 0)
2214 if (!add_dynamic_entry (DT_PLTGOT
, 0)
2215 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
2216 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
2217 || !add_dynamic_entry (DT_JMPREL
, 0))
2221 if (!add_dynamic_entry (DT_RELA
, 0)
2222 || !add_dynamic_entry (DT_RELASZ
, 0)
2223 || !add_dynamic_entry (DT_RELAENT
,
2224 SPARC_ELF_RELA_BYTES (htab
)))
2227 /* If any dynamic relocs apply to a read-only section,
2228 then we need a DT_TEXTREL entry. */
2229 if ((info
->flags
& DF_TEXTREL
) == 0)
2230 elf_link_hash_traverse (&htab
->elf
, readonly_dynrelocs
,
2233 if (info
->flags
& DF_TEXTREL
)
2235 if (!add_dynamic_entry (DT_TEXTREL
, 0))
2239 if (ABI_64_P (output_bfd
))
2242 struct _bfd_sparc_elf_app_reg
* app_regs
;
2243 struct elf_strtab_hash
*dynstr
;
2244 struct elf_link_hash_table
*eht
= elf_hash_table (info
);
2246 /* Add dynamic STT_REGISTER symbols and corresponding DT_SPARC_REGISTER
2247 entries if needed. */
2248 app_regs
= _bfd_sparc_elf_hash_table (info
)->app_regs
;
2249 dynstr
= eht
->dynstr
;
2251 for (reg
= 0; reg
< 4; reg
++)
2252 if (app_regs
[reg
].name
!= NULL
)
2254 struct elf_link_local_dynamic_entry
*entry
, *e
;
2256 if (!add_dynamic_entry (DT_SPARC_REGISTER
, 0))
2259 entry
= (struct elf_link_local_dynamic_entry
*)
2260 bfd_hash_allocate (&info
->hash
->table
, sizeof (*entry
));
2264 /* We cheat here a little bit: the symbol will not be local, so we
2265 put it at the end of the dynlocal linked list. We will fix it
2266 later on, as we have to fix other fields anyway. */
2267 entry
->isym
.st_value
= reg
< 2 ? reg
+ 2 : reg
+ 4;
2268 entry
->isym
.st_size
= 0;
2269 if (*app_regs
[reg
].name
!= '\0')
2271 = _bfd_elf_strtab_add (dynstr
, app_regs
[reg
].name
, FALSE
);
2273 entry
->isym
.st_name
= 0;
2274 entry
->isym
.st_other
= 0;
2275 entry
->isym
.st_info
= ELF_ST_INFO (app_regs
[reg
].bind
,
2277 entry
->isym
.st_shndx
= app_regs
[reg
].shndx
;
2279 entry
->input_bfd
= output_bfd
;
2280 entry
->input_indx
= -1;
2282 if (eht
->dynlocal
== NULL
)
2283 eht
->dynlocal
= entry
;
2286 for (e
= eht
->dynlocal
; e
->next
; e
= e
->next
)
2294 #undef add_dynamic_entry
2300 _bfd_sparc_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
2302 struct _bfd_sparc_elf_section_data
*sdata
;
2303 bfd_size_type amt
= sizeof (*sdata
);
2305 sdata
= (struct _bfd_sparc_elf_section_data
*) bfd_zalloc (abfd
, amt
);
2308 sec
->used_by_bfd
= (PTR
) sdata
;
2310 return _bfd_elf_new_section_hook (abfd
, sec
);
2314 _bfd_sparc_elf_relax_section (bfd
*abfd ATTRIBUTE_UNUSED
,
2315 struct bfd_section
*section
,
2316 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
,
2320 sec_do_relax (section
) = 1;
2324 /* Return the base VMA address which should be subtracted from real addresses
2325 when resolving @dtpoff relocation.
2326 This is PT_TLS segment p_vaddr. */
2329 dtpoff_base (struct bfd_link_info
*info
)
2331 /* If tls_sec is NULL, we should have signalled an error already. */
2332 if (elf_hash_table (info
)->tls_sec
== NULL
)
2334 return elf_hash_table (info
)->tls_sec
->vma
;
2337 /* Return the relocation value for @tpoff relocation
2338 if STT_TLS virtual address is ADDRESS. */
2341 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
2343 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2345 /* If tls_sec is NULL, we should have signalled an error already. */
2346 if (htab
->tls_sec
== NULL
)
2348 return address
- htab
->tls_size
- htab
->tls_sec
->vma
;
2351 /* Relocate a SPARC ELF section. */
2354 _bfd_sparc_elf_relocate_section (bfd
*output_bfd
, struct bfd_link_info
*info
,
2355 bfd
*input_bfd
, asection
*input_section
,
2356 bfd_byte
*contents
, Elf_Internal_Rela
*relocs
,
2357 Elf_Internal_Sym
*local_syms
, asection
**local_sections
)
2359 struct _bfd_sparc_elf_link_hash_table
*htab
;
2360 Elf_Internal_Shdr
*symtab_hdr
;
2361 struct elf_link_hash_entry
**sym_hashes
;
2362 bfd_vma
*local_got_offsets
;
2365 Elf_Internal_Rela
*rel
;
2366 Elf_Internal_Rela
*relend
;
2369 if (info
->relocatable
)
2372 htab
= _bfd_sparc_elf_hash_table (info
);
2373 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2374 sym_hashes
= elf_sym_hashes (input_bfd
);
2375 local_got_offsets
= elf_local_got_offsets (input_bfd
);
2377 if (elf_hash_table (info
)->hgot
== NULL
)
2380 got_base
= elf_hash_table (info
)->hgot
->root
.u
.def
.value
;
2382 sreloc
= elf_section_data (input_section
)->sreloc
;
2385 if (ABI_64_P (output_bfd
))
2386 num_relocs
= NUM_SHDR_ENTRIES (& elf_section_data (input_section
)->rel_hdr
);
2388 num_relocs
= input_section
->reloc_count
;
2389 relend
= relocs
+ num_relocs
;
2390 for (; rel
< relend
; rel
++)
2392 int r_type
, tls_type
;
2393 reloc_howto_type
*howto
;
2394 unsigned long r_symndx
;
2395 struct elf_link_hash_entry
*h
;
2396 Elf_Internal_Sym
*sym
;
2398 bfd_vma relocation
, off
;
2399 bfd_reloc_status_type r
;
2400 bfd_boolean is_plt
= FALSE
;
2401 bfd_boolean unresolved_reloc
;
2403 r_type
= SPARC_ELF_R_TYPE (rel
->r_info
);
2404 if (r_type
== R_SPARC_GNU_VTINHERIT
2405 || r_type
== R_SPARC_GNU_VTENTRY
)
2408 if (r_type
< 0 || r_type
>= (int) R_SPARC_max_std
)
2410 bfd_set_error (bfd_error_bad_value
);
2413 howto
= _bfd_sparc_elf_howto_table
+ r_type
;
2415 /* This is a final link. */
2416 r_symndx
= SPARC_ELF_R_SYMNDX (htab
, rel
->r_info
);
2420 unresolved_reloc
= FALSE
;
2421 if (r_symndx
< symtab_hdr
->sh_info
)
2423 sym
= local_syms
+ r_symndx
;
2424 sec
= local_sections
[r_symndx
];
2425 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
2431 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2432 r_symndx
, symtab_hdr
, sym_hashes
,
2434 unresolved_reloc
, warned
);
2437 /* To avoid generating warning messages about truncated
2438 relocations, set the relocation's address to be the same as
2439 the start of this section. */
2440 if (input_section
->output_section
!= NULL
)
2441 relocation
= input_section
->output_section
->vma
;
2452 /* Relocation is to the entry for this symbol in the global
2454 if (htab
->sgot
== NULL
)
2461 off
= h
->got
.offset
;
2462 BFD_ASSERT (off
!= (bfd_vma
) -1);
2463 dyn
= elf_hash_table (info
)->dynamic_sections_created
;
2465 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
2472 /* This is actually a static link, or it is a
2473 -Bsymbolic link and the symbol is defined
2474 locally, or the symbol was forced to be local
2475 because of a version file. We must initialize
2476 this entry in the global offset table. Since the
2477 offset must always be a multiple of 8 for 64-bit
2478 and 4 for 32-bit, we use the least significant bit
2479 to record whether we have initialized it already.
2481 When doing a dynamic link, we create a .rela.got
2482 relocation entry to initialize the value. This
2483 is done in the finish_dynamic_symbol routine. */
2488 SPARC_ELF_PUT_WORD (htab
, output_bfd
, relocation
,
2489 htab
->sgot
->contents
+ off
);
2494 unresolved_reloc
= FALSE
;
2498 BFD_ASSERT (local_got_offsets
!= NULL
2499 && local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
2501 off
= local_got_offsets
[r_symndx
];
2503 /* The offset must always be a multiple of 8 on 64-bit and
2504 4 on 32-bit. We use the least significant bit to record
2505 whether we have already processed this entry. */
2514 Elf_Internal_Rela outrel
;
2516 /* We need to generate a R_SPARC_RELATIVE reloc
2517 for the dynamic linker. */
2519 BFD_ASSERT (s
!= NULL
);
2521 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
2522 + htab
->sgot
->output_offset
2524 outrel
.r_info
= SPARC_ELF_R_INFO (htab
, NULL
,
2525 0, R_SPARC_RELATIVE
);
2526 outrel
.r_addend
= relocation
;
2528 SPARC_ELF_APPEND_RELA (htab
, output_bfd
, s
, &outrel
);
2531 SPARC_ELF_PUT_WORD (htab
, output_bfd
, relocation
,
2532 htab
->sgot
->contents
+ off
);
2533 local_got_offsets
[r_symndx
] |= 1;
2536 relocation
= htab
->sgot
->output_offset
+ off
- got_base
;
2541 if (h
== NULL
|| h
->plt
.offset
== (bfd_vma
) -1)
2543 r_type
= (r_type
== R_SPARC_PLT32
) ? R_SPARC_32
: R_SPARC_64
;
2548 case R_SPARC_WPLT30
:
2549 case R_SPARC_HIPLT22
:
2550 case R_SPARC_LOPLT10
:
2551 case R_SPARC_PCPLT32
:
2552 case R_SPARC_PCPLT22
:
2553 case R_SPARC_PCPLT10
:
2555 /* Relocation is to the entry for this symbol in the
2556 procedure linkage table. */
2558 if (! ABI_64_P (output_bfd
))
2560 /* The Solaris native assembler will generate a WPLT30 reloc
2561 for a local symbol if you assemble a call from one
2562 section to another when using -K pic. We treat it as
2569 BFD_ASSERT (h
!= NULL
);
2572 if (h
->plt
.offset
== (bfd_vma
) -1 || htab
->splt
== NULL
)
2574 /* We didn't make a PLT entry for this symbol. This
2575 happens when statically linking PIC code, or when
2576 using -Bsymbolic. */
2580 relocation
= (htab
->splt
->output_section
->vma
2581 + htab
->splt
->output_offset
2583 unresolved_reloc
= FALSE
;
2584 if (r_type
== R_SPARC_PLT32
|| r_type
== R_SPARC_PLT64
)
2586 r_type
= r_type
== R_SPARC_PLT32
? R_SPARC_32
: R_SPARC_64
;
2594 case R_SPARC_PC_HH22
:
2595 case R_SPARC_PC_HM10
:
2596 case R_SPARC_PC_LM22
:
2598 && strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
2602 case R_SPARC_DISP16
:
2603 case R_SPARC_DISP32
:
2604 case R_SPARC_DISP64
:
2605 case R_SPARC_WDISP30
:
2606 case R_SPARC_WDISP22
:
2607 case R_SPARC_WDISP19
:
2608 case R_SPARC_WDISP16
:
2635 /* r_symndx will be zero only for relocs against symbols
2636 from removed linkonce sections, or sections discarded by
2639 || (input_section
->flags
& SEC_ALLOC
) == 0)
2644 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2645 || h
->root
.type
!= bfd_link_hash_undefweak
)
2646 && (! howto
->pc_relative
2649 && (! info
->symbolic
2650 || !h
->def_regular
))))
2657 || h
->root
.type
== bfd_link_hash_undefweak
2658 || h
->root
.type
== bfd_link_hash_undefined
)))
2660 Elf_Internal_Rela outrel
;
2661 bfd_boolean skip
, relocate
= FALSE
;
2663 /* When generating a shared object, these relocations
2664 are copied into the output file to be resolved at run
2667 BFD_ASSERT (sreloc
!= NULL
);
2672 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2674 if (outrel
.r_offset
== (bfd_vma
) -1)
2676 else if (outrel
.r_offset
== (bfd_vma
) -2)
2677 skip
= TRUE
, relocate
= TRUE
;
2678 outrel
.r_offset
+= (input_section
->output_section
->vma
2679 + input_section
->output_offset
);
2681 /* Optimize unaligned reloc usage now that we know where
2682 it finally resides. */
2686 if (outrel
.r_offset
& 1)
2687 r_type
= R_SPARC_UA16
;
2690 if (!(outrel
.r_offset
& 1))
2691 r_type
= R_SPARC_16
;
2694 if (outrel
.r_offset
& 3)
2695 r_type
= R_SPARC_UA32
;
2698 if (!(outrel
.r_offset
& 3))
2699 r_type
= R_SPARC_32
;
2702 if (outrel
.r_offset
& 7)
2703 r_type
= R_SPARC_UA64
;
2706 if (!(outrel
.r_offset
& 7))
2707 r_type
= R_SPARC_64
;
2710 case R_SPARC_DISP16
:
2711 case R_SPARC_DISP32
:
2712 case R_SPARC_DISP64
:
2713 /* If the symbol is not dynamic, we should not keep
2714 a dynamic relocation. But an .rela.* slot has been
2715 allocated for it, output R_SPARC_NONE.
2716 FIXME: Add code tracking needed dynamic relocs as
2718 if (h
->dynindx
== -1)
2719 skip
= TRUE
, relocate
= TRUE
;
2724 memset (&outrel
, 0, sizeof outrel
);
2725 /* h->dynindx may be -1 if the symbol was marked to
2727 else if (h
!= NULL
&& ! is_plt
2728 && ((! info
->symbolic
&& h
->dynindx
!= -1)
2729 || !h
->def_regular
))
2731 BFD_ASSERT (h
->dynindx
!= -1);
2732 outrel
.r_info
= SPARC_ELF_R_INFO (htab
, rel
, h
->dynindx
, r_type
);
2733 outrel
.r_addend
= rel
->r_addend
;
2737 if (r_type
== R_SPARC_32
|| r_type
== R_SPARC_64
)
2739 outrel
.r_info
= SPARC_ELF_R_INFO (htab
, NULL
,
2740 0, R_SPARC_RELATIVE
);
2741 outrel
.r_addend
= relocation
+ rel
->r_addend
;
2750 if (bfd_is_abs_section (sec
))
2752 else if (sec
== NULL
|| sec
->owner
== NULL
)
2754 bfd_set_error (bfd_error_bad_value
);
2761 osec
= sec
->output_section
;
2762 indx
= elf_section_data (osec
)->dynindx
;
2764 /* FIXME: we really should be able to link non-pic
2765 shared libraries. */
2769 (*_bfd_error_handler
)
2770 (_("%B: probably compiled without -fPIC?"),
2772 bfd_set_error (bfd_error_bad_value
);
2777 outrel
.r_info
= SPARC_ELF_R_INFO (htab
, rel
, indx
, r_type
);
2778 outrel
.r_addend
= relocation
+ rel
->r_addend
;
2782 SPARC_ELF_APPEND_RELA (htab
, output_bfd
, sreloc
, &outrel
);
2784 /* This reloc will be computed at runtime, so there's no
2785 need to do anything now. */
2791 case R_SPARC_TLS_GD_HI22
:
2792 if (! ABI_64_P (input_bfd
)
2793 && ! _bfd_sparc_elf_tdata (input_bfd
)->has_tlsgd
)
2795 /* R_SPARC_REV32 used the same reloc number as
2796 R_SPARC_TLS_GD_HI22. */
2797 r_type
= R_SPARC_REV32
;
2802 case R_SPARC_TLS_GD_LO10
:
2803 case R_SPARC_TLS_IE_HI22
:
2804 case R_SPARC_TLS_IE_LO10
:
2805 r_type
= sparc_elf_tls_transition (info
, input_bfd
, r_type
, h
== NULL
);
2806 tls_type
= GOT_UNKNOWN
;
2807 if (h
== NULL
&& local_got_offsets
)
2808 tls_type
= _bfd_sparc_elf_local_got_tls_type (input_bfd
) [r_symndx
];
2811 tls_type
= _bfd_sparc_elf_hash_entry(h
)->tls_type
;
2812 if (!info
->shared
&& h
->dynindx
== -1 && tls_type
== GOT_TLS_IE
)
2813 switch (SPARC_ELF_R_TYPE (rel
->r_info
))
2815 case R_SPARC_TLS_GD_HI22
:
2816 case R_SPARC_TLS_IE_HI22
:
2817 r_type
= R_SPARC_TLS_LE_HIX22
;
2820 r_type
= R_SPARC_TLS_LE_LOX10
;
2824 if (tls_type
== GOT_TLS_IE
)
2827 case R_SPARC_TLS_GD_HI22
:
2828 r_type
= R_SPARC_TLS_IE_HI22
;
2830 case R_SPARC_TLS_GD_LO10
:
2831 r_type
= R_SPARC_TLS_IE_LO10
;
2835 if (r_type
== R_SPARC_TLS_LE_HIX22
)
2837 relocation
= tpoff (info
, relocation
);
2840 if (r_type
== R_SPARC_TLS_LE_LOX10
)
2842 /* Change add into xor. */
2843 relocation
= tpoff (info
, relocation
);
2844 bfd_put_32 (output_bfd
, (bfd_get_32 (input_bfd
,
2845 contents
+ rel
->r_offset
)
2846 | 0x80182000), contents
+ rel
->r_offset
);
2852 off
= h
->got
.offset
;
2857 BFD_ASSERT (local_got_offsets
!= NULL
);
2858 off
= local_got_offsets
[r_symndx
];
2859 local_got_offsets
[r_symndx
] |= 1;
2863 if (htab
->sgot
== NULL
)
2870 Elf_Internal_Rela outrel
;
2873 if (htab
->srelgot
== NULL
)
2876 SPARC_ELF_PUT_WORD (htab
, output_bfd
, 0, htab
->sgot
->contents
+ off
);
2877 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
2878 + htab
->sgot
->output_offset
+ off
);
2879 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
2880 if (r_type
== R_SPARC_TLS_IE_HI22
2881 || r_type
== R_SPARC_TLS_IE_LO10
)
2882 dr_type
= SPARC_ELF_TPOFF_RELOC (htab
);
2884 dr_type
= SPARC_ELF_DTPMOD_RELOC (htab
);
2885 if (dr_type
== SPARC_ELF_TPOFF_RELOC (htab
) && indx
== 0)
2886 outrel
.r_addend
= relocation
- dtpoff_base (info
);
2888 outrel
.r_addend
= 0;
2889 outrel
.r_info
= SPARC_ELF_R_INFO (htab
, NULL
, indx
, dr_type
);
2890 SPARC_ELF_APPEND_RELA (htab
, output_bfd
, htab
->srelgot
, &outrel
);
2892 if (r_type
== R_SPARC_TLS_GD_HI22
2893 || r_type
== R_SPARC_TLS_GD_LO10
)
2897 BFD_ASSERT (! unresolved_reloc
);
2898 SPARC_ELF_PUT_WORD (htab
, output_bfd
,
2899 relocation
- dtpoff_base (info
),
2900 (htab
->sgot
->contents
+ off
2901 + SPARC_ELF_WORD_BYTES (htab
)));
2905 SPARC_ELF_PUT_WORD (htab
, output_bfd
, 0,
2906 (htab
->sgot
->contents
+ off
2907 + SPARC_ELF_WORD_BYTES (htab
)));
2908 outrel
.r_info
= SPARC_ELF_R_INFO (htab
, NULL
, indx
,
2909 SPARC_ELF_DTPOFF_RELOC (htab
));
2910 outrel
.r_offset
+= SPARC_ELF_WORD_BYTES (htab
);
2911 SPARC_ELF_APPEND_RELA (htab
, output_bfd
, htab
->srelgot
, &outrel
);
2914 else if (dr_type
== SPARC_ELF_DTPMOD_RELOC (htab
))
2916 SPARC_ELF_PUT_WORD (htab
, output_bfd
, 0,
2917 (htab
->sgot
->contents
+ off
2918 + SPARC_ELF_WORD_BYTES (htab
)));
2922 if (off
>= (bfd_vma
) -2)
2925 relocation
= htab
->sgot
->output_offset
+ off
- got_base
;
2926 unresolved_reloc
= FALSE
;
2927 howto
= _bfd_sparc_elf_howto_table
+ r_type
;
2930 case R_SPARC_TLS_LDM_HI22
:
2931 case R_SPARC_TLS_LDM_LO10
:
2934 bfd_put_32 (output_bfd
, SPARC_NOP
, contents
+ rel
->r_offset
);
2937 off
= htab
->tls_ldm_got
.offset
;
2938 htab
->tls_ldm_got
.offset
|= 1;
2939 goto r_sparc_tlsldm
;
2941 case R_SPARC_TLS_LDO_HIX22
:
2942 case R_SPARC_TLS_LDO_LOX10
:
2945 relocation
-= dtpoff_base (info
);
2949 r_type
= (r_type
== R_SPARC_TLS_LDO_HIX22
2950 ? R_SPARC_TLS_LE_HIX22
: R_SPARC_TLS_LE_LOX10
);
2953 case R_SPARC_TLS_LE_HIX22
:
2954 case R_SPARC_TLS_LE_LOX10
:
2957 Elf_Internal_Rela outrel
;
2958 bfd_boolean skip
, relocate
= FALSE
;
2960 BFD_ASSERT (sreloc
!= NULL
);
2963 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2965 if (outrel
.r_offset
== (bfd_vma
) -1)
2967 else if (outrel
.r_offset
== (bfd_vma
) -2)
2968 skip
= TRUE
, relocate
= TRUE
;
2969 outrel
.r_offset
+= (input_section
->output_section
->vma
2970 + input_section
->output_offset
);
2972 memset (&outrel
, 0, sizeof outrel
);
2975 outrel
.r_info
= SPARC_ELF_R_INFO (htab
, NULL
, 0, r_type
);
2976 outrel
.r_addend
= relocation
- dtpoff_base (info
)
2980 SPARC_ELF_APPEND_RELA (htab
, output_bfd
, sreloc
, &outrel
);
2983 relocation
= tpoff (info
, relocation
);
2986 case R_SPARC_TLS_LDM_CALL
:
2990 bfd_put_32 (output_bfd
, 0x90100000, contents
+ rel
->r_offset
);
2995 case R_SPARC_TLS_GD_CALL
:
2996 tls_type
= GOT_UNKNOWN
;
2997 if (h
== NULL
&& local_got_offsets
)
2998 tls_type
= _bfd_sparc_elf_local_got_tls_type (input_bfd
) [r_symndx
];
3000 tls_type
= _bfd_sparc_elf_hash_entry(h
)->tls_type
;
3002 || (r_type
== R_SPARC_TLS_GD_CALL
&& tls_type
== GOT_TLS_IE
))
3006 if (!info
->shared
&& (h
== NULL
|| h
->dynindx
== -1))
3009 bfd_put_32 (output_bfd
, SPARC_NOP
, contents
+ rel
->r_offset
);
3014 if (rel
+ 1 < relend
3015 && SPARC_ELF_R_TYPE (rel
[1].r_info
) == R_SPARC_TLS_GD_ADD
3016 && rel
[1].r_offset
== rel
->r_offset
+ 4
3017 && SPARC_ELF_R_SYMNDX (htab
, rel
[1].r_info
) == r_symndx
3018 && (((insn
= bfd_get_32 (input_bfd
,
3019 contents
+ rel
[1].r_offset
))
3020 >> 25) & 0x1f) == 8)
3023 call __tls_get_addr, %tgd_call(foo)
3024 add %reg1, %reg2, %o0, %tgd_add(foo)
3025 and change it into IE:
3026 {ld,ldx} [%reg1 + %reg2], %o0, %tie_ldx(foo)
3027 add %g7, %o0, %o0, %tie_add(foo).
3028 add is 0x80000000 | (rd << 25) | (rs1 << 14) | rs2,
3029 ld is 0xc0000000 | (rd << 25) | (rs1 << 14) | rs2,
3030 ldx is 0xc0580000 | (rd << 25) | (rs1 << 14) | rs2. */
3031 bfd_put_32 (output_bfd
, insn
| (ABI_64_P (output_bfd
) ? 0xc0580000 : 0xc0000000),
3032 contents
+ rel
->r_offset
);
3033 bfd_put_32 (output_bfd
, 0x9001c008,
3034 contents
+ rel
->r_offset
+ 4);
3039 bfd_put_32 (output_bfd
, 0x9001c008, contents
+ rel
->r_offset
);
3043 h
= (struct elf_link_hash_entry
*)
3044 bfd_link_hash_lookup (info
->hash
, "__tls_get_addr", FALSE
,
3046 BFD_ASSERT (h
!= NULL
);
3047 r_type
= R_SPARC_WPLT30
;
3048 howto
= _bfd_sparc_elf_howto_table
+ r_type
;
3049 goto r_sparc_wplt30
;
3051 case R_SPARC_TLS_GD_ADD
:
3052 tls_type
= GOT_UNKNOWN
;
3053 if (h
== NULL
&& local_got_offsets
)
3054 tls_type
= _bfd_sparc_elf_local_got_tls_type (input_bfd
) [r_symndx
];
3056 tls_type
= _bfd_sparc_elf_hash_entry(h
)->tls_type
;
3057 if (! info
->shared
|| tls_type
== GOT_TLS_IE
)
3059 /* add %reg1, %reg2, %reg3, %tgd_add(foo)
3061 {ld,ldx} [%reg1 + %reg2], %reg3, %tie_ldx(foo)
3063 add %g7, %reg2, %reg3. */
3064 bfd_vma insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3065 if ((h
!= NULL
&& h
->dynindx
!= -1) || info
->shared
)
3066 relocation
= insn
| (ABI_64_P (output_bfd
) ? 0xc0580000 : 0xc0000000);
3068 relocation
= (insn
& ~0x7c000) | 0x1c000;
3069 bfd_put_32 (output_bfd
, relocation
, contents
+ rel
->r_offset
);
3073 case R_SPARC_TLS_LDM_ADD
:
3075 bfd_put_32 (output_bfd
, SPARC_NOP
, contents
+ rel
->r_offset
);
3078 case R_SPARC_TLS_LDO_ADD
:
3081 /* Change rs1 into %g7. */
3082 bfd_vma insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3083 insn
= (insn
& ~0x7c000) | 0x1c000;
3084 bfd_put_32 (output_bfd
, insn
, contents
+ rel
->r_offset
);
3088 case R_SPARC_TLS_IE_LD
:
3089 case R_SPARC_TLS_IE_LDX
:
3090 if (! info
->shared
&& (h
== NULL
|| h
->dynindx
== -1))
3092 bfd_vma insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3093 int rs2
= insn
& 0x1f;
3094 int rd
= (insn
>> 25) & 0x1f;
3097 relocation
= SPARC_NOP
;
3099 relocation
= 0x80100000 | (insn
& 0x3e00001f);
3100 bfd_put_32 (output_bfd
, relocation
, contents
+ rel
->r_offset
);
3104 case R_SPARC_TLS_IE_ADD
:
3105 /* Totally useless relocation. */
3108 case R_SPARC_TLS_DTPOFF32
:
3109 case R_SPARC_TLS_DTPOFF64
:
3110 relocation
-= dtpoff_base (info
);
3117 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3118 because such sections are not SEC_ALLOC and thus ld.so will
3119 not process them. */
3120 if (unresolved_reloc
3121 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
3123 (*_bfd_error_handler
)
3124 (_("%B(%A+0x%lx): unresolvable relocation against symbol `%s'"),
3127 (long) rel
->r_offset
,
3128 h
->root
.root
.string
);
3130 r
= bfd_reloc_continue
;
3131 if (r_type
== R_SPARC_OLO10
)
3135 if (! ABI_64_P (output_bfd
))
3138 relocation
+= rel
->r_addend
;
3139 relocation
= (relocation
& 0x3ff) + ELF64_R_TYPE_DATA (rel
->r_info
);
3141 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3142 x
= (x
& ~(bfd_vma
) 0x1fff) | (relocation
& 0x1fff);
3143 bfd_put_32 (input_bfd
, x
, contents
+ rel
->r_offset
);
3145 r
= bfd_check_overflow (howto
->complain_on_overflow
,
3146 howto
->bitsize
, howto
->rightshift
,
3147 bfd_arch_bits_per_address (input_bfd
),
3150 else if (r_type
== R_SPARC_WDISP16
)
3154 relocation
+= rel
->r_addend
;
3155 relocation
-= (input_section
->output_section
->vma
3156 + input_section
->output_offset
);
3157 relocation
-= rel
->r_offset
;
3159 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3160 x
|= ((((relocation
>> 2) & 0xc000) << 6)
3161 | ((relocation
>> 2) & 0x3fff));
3162 bfd_put_32 (input_bfd
, x
, contents
+ rel
->r_offset
);
3164 r
= bfd_check_overflow (howto
->complain_on_overflow
,
3165 howto
->bitsize
, howto
->rightshift
,
3166 bfd_arch_bits_per_address (input_bfd
),
3169 else if (r_type
== R_SPARC_REV32
)
3173 relocation
= relocation
+ rel
->r_addend
;
3175 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3177 bfd_putl32 (/*input_bfd,*/ x
, contents
+ rel
->r_offset
);
3180 else if (r_type
== R_SPARC_TLS_LDO_HIX22
3181 || r_type
== R_SPARC_TLS_LE_HIX22
)
3185 relocation
+= rel
->r_addend
;
3186 if (r_type
== R_SPARC_TLS_LE_HIX22
)
3187 relocation
^= MINUS_ONE
;
3189 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3190 x
= (x
& ~(bfd_vma
) 0x3fffff) | ((relocation
>> 10) & 0x3fffff);
3191 bfd_put_32 (input_bfd
, x
, contents
+ rel
->r_offset
);
3194 else if (r_type
== R_SPARC_TLS_LDO_LOX10
3195 || r_type
== R_SPARC_TLS_LE_LOX10
)
3199 relocation
+= rel
->r_addend
;
3200 relocation
&= 0x3ff;
3201 if (r_type
== R_SPARC_TLS_LE_LOX10
)
3202 relocation
|= 0x1c00;
3204 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3205 x
= (x
& ~(bfd_vma
) 0x1fff) | relocation
;
3206 bfd_put_32 (input_bfd
, x
, contents
+ rel
->r_offset
);
3210 else if (r_type
== R_SPARC_HIX22
)
3214 relocation
+= rel
->r_addend
;
3215 relocation
= relocation
^ MINUS_ONE
;
3217 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3218 x
= (x
& ~(bfd_vma
) 0x3fffff) | ((relocation
>> 10) & 0x3fffff);
3219 bfd_put_32 (input_bfd
, x
, contents
+ rel
->r_offset
);
3221 r
= bfd_check_overflow (howto
->complain_on_overflow
,
3222 howto
->bitsize
, howto
->rightshift
,
3223 bfd_arch_bits_per_address (input_bfd
),
3226 else if (r_type
== R_SPARC_LOX10
)
3230 relocation
+= rel
->r_addend
;
3231 relocation
= (relocation
& 0x3ff) | 0x1c00;
3233 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3234 x
= (x
& ~(bfd_vma
) 0x1fff) | relocation
;
3235 bfd_put_32 (input_bfd
, x
, contents
+ rel
->r_offset
);
3239 else if ((r_type
== R_SPARC_WDISP30
|| r_type
== R_SPARC_WPLT30
)
3240 && sec_do_relax (input_section
)
3241 && rel
->r_offset
+ 4 < input_section
->size
)
3245 #define XCC (2 << 20)
3246 #define COND(x) (((x)&0xf)<<25)
3247 #define CONDA COND(0x8)
3248 #define INSN_BPA (F2(0,1) | CONDA | BPRED | XCC)
3249 #define INSN_BA (F2(0,2) | CONDA)
3250 #define INSN_OR F3(2, 0x2, 0)
3251 #define INSN_NOP F2(0,4)
3255 /* If the instruction is a call with either:
3257 arithmetic instruction with rd == %o7
3258 where rs1 != %o7 and rs2 if it is register != %o7
3259 then we can optimize if the call destination is near
3260 by changing the call into a branch always. */
3261 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3262 y
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
3263 if ((x
& OP(~0)) == OP(1) && (y
& OP(~0)) == OP(2))
3265 if (((y
& OP3(~0)) == OP3(0x3d) /* restore */
3266 || ((y
& OP3(0x28)) == 0 /* arithmetic */
3267 && (y
& RD(~0)) == RD(O7
)))
3268 && (y
& RS1(~0)) != RS1(O7
)
3270 || (y
& RS2(~0)) != RS2(O7
)))
3274 reloc
= relocation
+ rel
->r_addend
- rel
->r_offset
;
3275 reloc
-= (input_section
->output_section
->vma
3276 + input_section
->output_offset
);
3278 /* Ensure the branch fits into simm22. */
3279 if ((reloc
& 3) == 0
3280 && ((reloc
& ~(bfd_vma
)0x7fffff) == 0
3281 || ((reloc
| 0x7fffff) == ~(bfd_vma
)0)))
3285 /* Check whether it fits into simm19. */
3286 if (((reloc
& 0x3c0000) == 0
3287 || (reloc
& 0x3c0000) == 0x3c0000)
3288 && (ABI_64_P (output_bfd
)
3289 || elf_elfheader (output_bfd
)->e_flags
& EF_SPARC_32PLUS
))
3290 x
= INSN_BPA
| (reloc
& 0x7ffff); /* ba,pt %xcc */
3292 x
= INSN_BA
| (reloc
& 0x3fffff); /* ba */
3293 bfd_put_32 (input_bfd
, x
, contents
+ rel
->r_offset
);
3295 if (rel
->r_offset
>= 4
3296 && (y
& (0xffffffff ^ RS1(~0)))
3297 == (INSN_OR
| RD(O7
) | RS2(G0
)))
3302 z
= bfd_get_32 (input_bfd
,
3303 contents
+ rel
->r_offset
- 4);
3304 if ((z
& (0xffffffff ^ RD(~0)))
3305 != (INSN_OR
| RS1(O7
) | RS2(G0
)))
3313 If call foo was replaced with ba, replace
3314 or %rN, %g0, %o7 with nop. */
3316 reg
= (y
& RS1(~0)) >> 14;
3317 if (reg
!= ((z
& RD(~0)) >> 25)
3318 || reg
== G0
|| reg
== O7
)
3321 bfd_put_32 (input_bfd
, (bfd_vma
) INSN_NOP
,
3322 contents
+ rel
->r_offset
+ 4);
3330 if (r
== bfd_reloc_continue
)
3331 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
3332 contents
, rel
->r_offset
,
3333 relocation
, rel
->r_addend
);
3335 if (r
!= bfd_reloc_ok
)
3340 case bfd_reloc_outofrange
:
3342 case bfd_reloc_overflow
:
3350 name
= bfd_elf_string_from_elf_section (input_bfd
,
3351 symtab_hdr
->sh_link
,
3356 name
= bfd_section_name (input_bfd
, sec
);
3358 if (! ((*info
->callbacks
->reloc_overflow
)
3359 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
3360 (bfd_vma
) 0, input_bfd
, input_section
,
3372 /* Finish up dynamic symbol handling. We set the contents of various
3373 dynamic sections here. */
3376 _bfd_sparc_elf_finish_dynamic_symbol (bfd
*output_bfd
,
3377 struct bfd_link_info
*info
,
3378 struct elf_link_hash_entry
*h
,
3379 Elf_Internal_Sym
*sym
)
3382 struct _bfd_sparc_elf_link_hash_table
*htab
;
3384 htab
= _bfd_sparc_elf_hash_table (info
);
3385 dynobj
= htab
->elf
.dynobj
;
3387 if (h
->plt
.offset
!= (bfd_vma
) -1)
3391 Elf_Internal_Rela rela
;
3396 /* This symbol has an entry in the PLT. Set it up. */
3398 BFD_ASSERT (h
->dynindx
!= -1);
3401 srela
= htab
->srelplt
;
3402 BFD_ASSERT (splt
!= NULL
&& srela
!= NULL
);
3404 /* Fill in the entry in the procedure linkage table. */
3405 rela_index
= SPARC_ELF_BUILD_PLT_ENTRY (htab
, output_bfd
, splt
,
3406 h
->plt
.offset
, splt
->size
,
3409 /* Fill in the entry in the .rela.plt section. */
3410 rela
.r_offset
= r_offset
3411 + (splt
->output_section
->vma
+ splt
->output_offset
);
3412 if (! ABI_64_P (output_bfd
)
3413 || h
->plt
.offset
< (PLT64_LARGE_THRESHOLD
* PLT64_ENTRY_SIZE
))
3419 rela
.r_addend
= -(h
->plt
.offset
+ 4)
3420 -(splt
->output_section
->vma
+ splt
->output_offset
);
3422 rela
.r_info
= SPARC_ELF_R_INFO (htab
, NULL
, h
->dynindx
, R_SPARC_JMP_SLOT
);
3424 /* Adjust for the first 4 reserved elements in the .plt section
3425 when setting the offset in the .rela.plt section.
3426 Sun forgot to read their own ABI and copied elf32-sparc behaviour,
3427 thus .plt[4] has corresponding .rela.plt[0] and so on. */
3429 loc
= srela
->contents
;
3431 if (ABI_64_P (output_bfd
))
3433 loc
+= rela_index
* sizeof (Elf64_External_Rela
);
3434 bfd_elf64_swap_reloca_out (output_bfd
, &rela
, loc
);
3439 loc
+= rela_index
* sizeof (Elf32_External_Rela
);
3440 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
3443 if (!h
->def_regular
)
3445 /* Mark the symbol as undefined, rather than as defined in
3446 the .plt section. Leave the value alone. */
3447 sym
->st_shndx
= SHN_UNDEF
;
3448 /* If the symbol is weak, we do need to clear the value.
3449 Otherwise, the PLT entry would provide a definition for
3450 the symbol even if the symbol wasn't defined anywhere,
3451 and so the symbol would never be NULL. */
3452 if (!h
->ref_regular_nonweak
)
3457 if (h
->got
.offset
!= (bfd_vma
) -1
3458 && _bfd_sparc_elf_hash_entry(h
)->tls_type
!= GOT_TLS_GD
3459 && _bfd_sparc_elf_hash_entry(h
)->tls_type
!= GOT_TLS_IE
)
3463 Elf_Internal_Rela rela
;
3465 /* This symbol has an entry in the GOT. Set it up. */
3468 srela
= htab
->srelgot
;
3469 BFD_ASSERT (sgot
!= NULL
&& srela
!= NULL
);
3471 rela
.r_offset
= (sgot
->output_section
->vma
3472 + sgot
->output_offset
3473 + (h
->got
.offset
&~ (bfd_vma
) 1));
3475 /* If this is a -Bsymbolic link, and the symbol is defined
3476 locally, we just want to emit a RELATIVE reloc. Likewise if
3477 the symbol was forced to be local because of a version file.
3478 The entry in the global offset table will already have been
3479 initialized in the relocate_section function. */
3481 && (info
->symbolic
|| h
->dynindx
== -1)
3484 asection
*sec
= h
->root
.u
.def
.section
;
3485 rela
.r_info
= SPARC_ELF_R_INFO (htab
, NULL
, 0, R_SPARC_RELATIVE
);
3486 rela
.r_addend
= (h
->root
.u
.def
.value
3487 + sec
->output_section
->vma
3488 + sec
->output_offset
);
3492 rela
.r_info
= SPARC_ELF_R_INFO (htab
, NULL
, h
->dynindx
, R_SPARC_GLOB_DAT
);
3496 SPARC_ELF_PUT_WORD (htab
, output_bfd
, 0,
3497 sgot
->contents
+ (h
->got
.offset
& ~(bfd_vma
) 1));
3498 SPARC_ELF_APPEND_RELA (htab
, output_bfd
, srela
, &rela
);
3504 Elf_Internal_Rela rela
;
3506 /* This symbols needs a copy reloc. Set it up. */
3507 BFD_ASSERT (h
->dynindx
!= -1);
3509 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
3511 BFD_ASSERT (s
!= NULL
);
3513 rela
.r_offset
= (h
->root
.u
.def
.value
3514 + h
->root
.u
.def
.section
->output_section
->vma
3515 + h
->root
.u
.def
.section
->output_offset
);
3516 rela
.r_info
= SPARC_ELF_R_INFO (htab
, NULL
, h
->dynindx
, R_SPARC_COPY
);
3518 SPARC_ELF_APPEND_RELA (htab
, output_bfd
, s
, &rela
);
3521 /* Mark some specially defined symbols as absolute. */
3522 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
3523 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0
3524 || strcmp (h
->root
.root
.string
, "_PROCEDURE_LINKAGE_TABLE_") == 0)
3525 sym
->st_shndx
= SHN_ABS
;
3530 /* Finish up the dynamic sections. */
3534 sparc64_finish_dyn (bfd
*output_bfd
, struct bfd_link_info
*info
,
3535 bfd
*dynobj
, asection
*sdyn
,
3536 asection
*splt ATTRIBUTE_UNUSED
)
3538 Elf64_External_Dyn
*dyncon
, *dynconend
;
3539 int stt_regidx
= -1;
3541 dyncon
= (Elf64_External_Dyn
*) sdyn
->contents
;
3542 dynconend
= (Elf64_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
3543 for (; dyncon
< dynconend
; dyncon
++)
3545 Elf_Internal_Dyn dyn
;
3549 bfd_elf64_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3553 case DT_PLTGOT
: name
= ".plt"; size
= FALSE
; break;
3554 case DT_PLTRELSZ
: name
= ".rela.plt"; size
= TRUE
; break;
3555 case DT_JMPREL
: name
= ".rela.plt"; size
= FALSE
; break;
3556 case DT_SPARC_REGISTER
:
3557 if (stt_regidx
== -1)
3560 _bfd_elf_link_lookup_local_dynindx (info
, output_bfd
, -1);
3561 if (stt_regidx
== -1)
3564 dyn
.d_un
.d_val
= stt_regidx
++;
3565 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3567 default: name
= NULL
; size
= FALSE
; break;
3574 s
= bfd_get_section_by_name (output_bfd
, name
);
3580 dyn
.d_un
.d_ptr
= s
->vma
;
3582 dyn
.d_un
.d_val
= s
->size
;
3584 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3592 sparc32_finish_dyn (bfd
*output_bfd
,
3593 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3594 bfd
*dynobj
, asection
*sdyn
,
3595 asection
*splt ATTRIBUTE_UNUSED
)
3597 Elf32_External_Dyn
*dyncon
, *dynconend
;
3599 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3600 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
3601 for (; dyncon
< dynconend
; dyncon
++)
3603 Elf_Internal_Dyn dyn
;
3607 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3611 case DT_PLTGOT
: name
= ".plt"; size
= FALSE
; break;
3612 case DT_PLTRELSZ
: name
= ".rela.plt"; size
= TRUE
; break;
3613 case DT_JMPREL
: name
= ".rela.plt"; size
= FALSE
; break;
3614 default: name
= NULL
; size
= FALSE
; break;
3621 s
= bfd_get_section_by_name (output_bfd
, name
);
3627 dyn
.d_un
.d_ptr
= s
->vma
;
3629 dyn
.d_un
.d_val
= s
->size
;
3631 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3638 _bfd_sparc_elf_finish_dynamic_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
3642 struct _bfd_sparc_elf_link_hash_table
*htab
;
3644 htab
= _bfd_sparc_elf_hash_table (info
);
3645 dynobj
= htab
->elf
.dynobj
;
3647 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
3649 if (elf_hash_table (info
)->dynamic_sections_created
)
3654 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3655 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
3658 if (ABI_64_P (output_bfd
))
3659 ret
= sparc64_finish_dyn (output_bfd
, info
, dynobj
, sdyn
, splt
);
3662 ret
= sparc32_finish_dyn (output_bfd
, info
, dynobj
, sdyn
, splt
);
3667 /* Initialize the contents of the .plt section. */
3670 if (ABI_64_P (output_bfd
))
3671 memset (splt
->contents
, 0, 4 * PLT64_ENTRY_SIZE
);
3674 memset (splt
->contents
, 0, 4 * PLT32_ENTRY_SIZE
);
3675 bfd_put_32 (output_bfd
, (bfd_vma
) SPARC_NOP
,
3676 splt
->contents
+ splt
->size
- 4);
3680 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
=
3681 (ABI_64_P (output_bfd
) ? PLT64_ENTRY_SIZE
: PLT32_ENTRY_SIZE
);
3684 /* Set the first entry in the global offset table to the address of
3685 the dynamic section. */
3686 if (htab
->sgot
&& htab
->sgot
->size
> 0)
3688 bfd_vma val
= (sdyn
?
3689 sdyn
->output_section
->vma
+ sdyn
->output_offset
:
3692 SPARC_ELF_PUT_WORD (htab
, output_bfd
, val
, htab
->sgot
->contents
);
3696 elf_section_data (htab
->sgot
->output_section
)->this_hdr
.sh_entsize
=
3697 SPARC_ELF_WORD_BYTES (htab
);
3703 /* Set the right machine number for a SPARC ELF file. */
3706 _bfd_sparc_elf_object_p (bfd
*abfd
)
3708 if (ABI_64_P (abfd
))
3710 unsigned long mach
= bfd_mach_sparc_v9
;
3712 if (elf_elfheader (abfd
)->e_flags
& EF_SPARC_SUN_US3
)
3713 mach
= bfd_mach_sparc_v9b
;
3714 else if (elf_elfheader (abfd
)->e_flags
& EF_SPARC_SUN_US1
)
3715 mach
= bfd_mach_sparc_v9a
;
3716 return bfd_default_set_arch_mach (abfd
, bfd_arch_sparc
, mach
);
3720 if (elf_elfheader (abfd
)->e_machine
== EM_SPARC32PLUS
)
3722 if (elf_elfheader (abfd
)->e_flags
& EF_SPARC_SUN_US3
)
3723 return bfd_default_set_arch_mach (abfd
, bfd_arch_sparc
,
3724 bfd_mach_sparc_v8plusb
);
3725 else if (elf_elfheader (abfd
)->e_flags
& EF_SPARC_SUN_US1
)
3726 return bfd_default_set_arch_mach (abfd
, bfd_arch_sparc
,
3727 bfd_mach_sparc_v8plusa
);
3728 else if (elf_elfheader (abfd
)->e_flags
& EF_SPARC_32PLUS
)
3729 return bfd_default_set_arch_mach (abfd
, bfd_arch_sparc
,
3730 bfd_mach_sparc_v8plus
);
3734 else if (elf_elfheader (abfd
)->e_flags
& EF_SPARC_LEDATA
)
3735 return bfd_default_set_arch_mach (abfd
, bfd_arch_sparc
,
3736 bfd_mach_sparc_sparclite_le
);
3738 return bfd_default_set_arch_mach (abfd
, bfd_arch_sparc
, bfd_mach_sparc
);
3742 /* Return address for Ith PLT stub in section PLT, for relocation REL
3743 or (bfd_vma) -1 if it should not be included. */
3746 _bfd_sparc_elf_plt_sym_val (bfd_vma i
, const asection
*plt
, const arelent
*rel
)
3748 if (ABI_64_P (plt
->owner
))
3752 i
+= PLT64_HEADER_SIZE
/ PLT64_ENTRY_SIZE
;
3753 if (i
< PLT64_LARGE_THRESHOLD
)
3754 return plt
->vma
+ i
* PLT64_ENTRY_SIZE
;
3756 j
= (i
- PLT64_LARGE_THRESHOLD
) % 160;
3758 return plt
->vma
+ i
* PLT64_ENTRY_SIZE
+ j
* 4 * 6;
3761 return rel
->address
;