1 /* SPARC-specific support for ELF
2 Copyright 2005, 2006, 2007 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
20 /* This file handles functionality common to the different SPARC ABI's. */
26 #include "libiberty.h"
28 #include "elf/sparc.h"
29 #include "opcode/sparc.h"
30 #include "elfxx-sparc.h"
31 #include "elf-vxworks.h"
33 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
34 #define MINUS_ONE (~ (bfd_vma) 0)
36 #define ABI_64_P(abfd) \
37 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
39 /* The relocation "howto" table. */
41 /* Utility for performing the standard initial work of an instruction
43 *PRELOCATION will contain the relocated item.
44 *PINSN will contain the instruction from the input stream.
45 If the result is `bfd_reloc_other' the caller can continue with
46 performing the relocation. Otherwise it must stop and return the
47 value to its caller. */
49 static bfd_reloc_status_type
50 init_insn_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
51 PTR data
, asection
*input_section
, bfd
*output_bfd
,
52 bfd_vma
*prelocation
, bfd_vma
*pinsn
)
55 reloc_howto_type
*howto
= reloc_entry
->howto
;
57 if (output_bfd
!= (bfd
*) NULL
58 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
59 && (! howto
->partial_inplace
60 || reloc_entry
->addend
== 0))
62 reloc_entry
->address
+= input_section
->output_offset
;
66 /* This works because partial_inplace is FALSE. */
67 if (output_bfd
!= NULL
)
68 return bfd_reloc_continue
;
70 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
71 return bfd_reloc_outofrange
;
73 relocation
= (symbol
->value
74 + symbol
->section
->output_section
->vma
75 + symbol
->section
->output_offset
);
76 relocation
+= reloc_entry
->addend
;
77 if (howto
->pc_relative
)
79 relocation
-= (input_section
->output_section
->vma
80 + input_section
->output_offset
);
81 relocation
-= reloc_entry
->address
;
84 *prelocation
= relocation
;
85 *pinsn
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
86 return bfd_reloc_other
;
89 /* For unsupported relocs. */
91 static bfd_reloc_status_type
92 sparc_elf_notsup_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
93 arelent
*reloc_entry ATTRIBUTE_UNUSED
,
94 asymbol
*symbol ATTRIBUTE_UNUSED
,
95 PTR data ATTRIBUTE_UNUSED
,
96 asection
*input_section ATTRIBUTE_UNUSED
,
97 bfd
*output_bfd ATTRIBUTE_UNUSED
,
98 char **error_message ATTRIBUTE_UNUSED
)
100 return bfd_reloc_notsupported
;
103 /* Handle the WDISP16 reloc. */
105 static bfd_reloc_status_type
106 sparc_elf_wdisp16_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
107 PTR data
, asection
*input_section
, bfd
*output_bfd
,
108 char **error_message ATTRIBUTE_UNUSED
)
112 bfd_reloc_status_type status
;
114 status
= init_insn_reloc (abfd
, reloc_entry
, symbol
, data
,
115 input_section
, output_bfd
, &relocation
, &insn
);
116 if (status
!= bfd_reloc_other
)
119 insn
&= ~ (bfd_vma
) 0x303fff;
120 insn
|= (((relocation
>> 2) & 0xc000) << 6) | ((relocation
>> 2) & 0x3fff);
121 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ reloc_entry
->address
);
123 if ((bfd_signed_vma
) relocation
< - 0x40000
124 || (bfd_signed_vma
) relocation
> 0x3ffff)
125 return bfd_reloc_overflow
;
130 /* Handle the HIX22 reloc. */
132 static bfd_reloc_status_type
133 sparc_elf_hix22_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
134 PTR data
, asection
*input_section
, bfd
*output_bfd
,
135 char **error_message ATTRIBUTE_UNUSED
)
139 bfd_reloc_status_type status
;
141 status
= init_insn_reloc (abfd
, reloc_entry
, symbol
, data
,
142 input_section
, output_bfd
, &relocation
, &insn
);
143 if (status
!= bfd_reloc_other
)
146 relocation
^= MINUS_ONE
;
147 insn
= (insn
&~ (bfd_vma
) 0x3fffff) | ((relocation
>> 10) & 0x3fffff);
148 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ reloc_entry
->address
);
150 if ((relocation
& ~ (bfd_vma
) 0xffffffff) != 0)
151 return bfd_reloc_overflow
;
156 /* Handle the LOX10 reloc. */
158 static bfd_reloc_status_type
159 sparc_elf_lox10_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
160 PTR data
, asection
*input_section
, bfd
*output_bfd
,
161 char **error_message ATTRIBUTE_UNUSED
)
165 bfd_reloc_status_type status
;
167 status
= init_insn_reloc (abfd
, reloc_entry
, symbol
, data
,
168 input_section
, output_bfd
, &relocation
, &insn
);
169 if (status
!= bfd_reloc_other
)
172 insn
= (insn
&~ (bfd_vma
) 0x1fff) | 0x1c00 | (relocation
& 0x3ff);
173 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ reloc_entry
->address
);
178 static reloc_howto_type _bfd_sparc_elf_howto_table
[] =
180 HOWTO(R_SPARC_NONE
, 0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_NONE", FALSE
,0,0x00000000,TRUE
),
181 HOWTO(R_SPARC_8
, 0,0, 8,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_8", FALSE
,0,0x000000ff,TRUE
),
182 HOWTO(R_SPARC_16
, 0,1,16,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_16", FALSE
,0,0x0000ffff,TRUE
),
183 HOWTO(R_SPARC_32
, 0,2,32,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_32", FALSE
,0,0xffffffff,TRUE
),
184 HOWTO(R_SPARC_DISP8
, 0,0, 8,TRUE
, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_DISP8", FALSE
,0,0x000000ff,TRUE
),
185 HOWTO(R_SPARC_DISP16
, 0,1,16,TRUE
, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_DISP16", FALSE
,0,0x0000ffff,TRUE
),
186 HOWTO(R_SPARC_DISP32
, 0,2,32,TRUE
, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_DISP32", FALSE
,0,0xffffffff,TRUE
),
187 HOWTO(R_SPARC_WDISP30
, 2,2,30,TRUE
, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_WDISP30", FALSE
,0,0x3fffffff,TRUE
),
188 HOWTO(R_SPARC_WDISP22
, 2,2,22,TRUE
, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_WDISP22", FALSE
,0,0x003fffff,TRUE
),
189 HOWTO(R_SPARC_HI22
, 10,2,22,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_HI22", FALSE
,0,0x003fffff,TRUE
),
190 HOWTO(R_SPARC_22
, 0,2,22,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_22", FALSE
,0,0x003fffff,TRUE
),
191 HOWTO(R_SPARC_13
, 0,2,13,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_13", FALSE
,0,0x00001fff,TRUE
),
192 HOWTO(R_SPARC_LO10
, 0,2,10,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_LO10", FALSE
,0,0x000003ff,TRUE
),
193 HOWTO(R_SPARC_GOT10
, 0,2,10,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_GOT10", FALSE
,0,0x000003ff,TRUE
),
194 HOWTO(R_SPARC_GOT13
, 0,2,13,FALSE
,0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_GOT13", FALSE
,0,0x00001fff,TRUE
),
195 HOWTO(R_SPARC_GOT22
, 10,2,22,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_GOT22", FALSE
,0,0x003fffff,TRUE
),
196 HOWTO(R_SPARC_PC10
, 0,2,10,TRUE
, 0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_PC10", FALSE
,0,0x000003ff,TRUE
),
197 HOWTO(R_SPARC_PC22
, 10,2,22,TRUE
, 0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_PC22", FALSE
,0,0x003fffff,TRUE
),
198 HOWTO(R_SPARC_WPLT30
, 2,2,30,TRUE
, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_WPLT30", FALSE
,0,0x3fffffff,TRUE
),
199 HOWTO(R_SPARC_COPY
, 0,0,00,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_COPY", FALSE
,0,0x00000000,TRUE
),
200 HOWTO(R_SPARC_GLOB_DAT
, 0,0,00,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_GLOB_DAT",FALSE
,0,0x00000000,TRUE
),
201 HOWTO(R_SPARC_JMP_SLOT
, 0,0,00,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_JMP_SLOT",FALSE
,0,0x00000000,TRUE
),
202 HOWTO(R_SPARC_RELATIVE
, 0,0,00,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_RELATIVE",FALSE
,0,0x00000000,TRUE
),
203 HOWTO(R_SPARC_UA32
, 0,2,32,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_UA32", FALSE
,0,0xffffffff,TRUE
),
204 HOWTO(R_SPARC_PLT32
, 0,2,32,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_PLT32", FALSE
,0,0xffffffff,TRUE
),
205 HOWTO(R_SPARC_HIPLT22
, 0,0,00,FALSE
,0,complain_overflow_dont
, sparc_elf_notsup_reloc
, "R_SPARC_HIPLT22", FALSE
,0,0x00000000,TRUE
),
206 HOWTO(R_SPARC_LOPLT10
, 0,0,00,FALSE
,0,complain_overflow_dont
, sparc_elf_notsup_reloc
, "R_SPARC_LOPLT10", FALSE
,0,0x00000000,TRUE
),
207 HOWTO(R_SPARC_PCPLT32
, 0,0,00,FALSE
,0,complain_overflow_dont
, sparc_elf_notsup_reloc
, "R_SPARC_PCPLT32", FALSE
,0,0x00000000,TRUE
),
208 HOWTO(R_SPARC_PCPLT22
, 0,0,00,FALSE
,0,complain_overflow_dont
, sparc_elf_notsup_reloc
, "R_SPARC_PCPLT22", FALSE
,0,0x00000000,TRUE
),
209 HOWTO(R_SPARC_PCPLT10
, 0,0,00,FALSE
,0,complain_overflow_dont
, sparc_elf_notsup_reloc
, "R_SPARC_PCPLT10", FALSE
,0,0x00000000,TRUE
),
210 HOWTO(R_SPARC_10
, 0,2,10,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_10", FALSE
,0,0x000003ff,TRUE
),
211 HOWTO(R_SPARC_11
, 0,2,11,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_11", FALSE
,0,0x000007ff,TRUE
),
212 HOWTO(R_SPARC_64
, 0,4,64,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_64", FALSE
,0,MINUS_ONE
, TRUE
),
213 HOWTO(R_SPARC_OLO10
, 0,2,13,FALSE
,0,complain_overflow_signed
, sparc_elf_notsup_reloc
, "R_SPARC_OLO10", FALSE
,0,0x00001fff,TRUE
),
214 HOWTO(R_SPARC_HH22
, 42,2,22,FALSE
,0,complain_overflow_unsigned
,bfd_elf_generic_reloc
, "R_SPARC_HH22", FALSE
,0,0x003fffff,TRUE
),
215 HOWTO(R_SPARC_HM10
, 32,2,10,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_HM10", FALSE
,0,0x000003ff,TRUE
),
216 HOWTO(R_SPARC_LM22
, 10,2,22,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_LM22", FALSE
,0,0x003fffff,TRUE
),
217 HOWTO(R_SPARC_PC_HH22
, 42,2,22,TRUE
, 0,complain_overflow_unsigned
,bfd_elf_generic_reloc
, "R_SPARC_PC_HH22", FALSE
,0,0x003fffff,TRUE
),
218 HOWTO(R_SPARC_PC_HM10
, 32,2,10,TRUE
, 0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_PC_HM10", FALSE
,0,0x000003ff,TRUE
),
219 HOWTO(R_SPARC_PC_LM22
, 10,2,22,TRUE
, 0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_PC_LM22", FALSE
,0,0x003fffff,TRUE
),
220 HOWTO(R_SPARC_WDISP16
, 2,2,16,TRUE
, 0,complain_overflow_signed
, sparc_elf_wdisp16_reloc
,"R_SPARC_WDISP16", FALSE
,0,0x00000000,TRUE
),
221 HOWTO(R_SPARC_WDISP19
, 2,2,19,TRUE
, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_WDISP19", FALSE
,0,0x0007ffff,TRUE
),
222 HOWTO(R_SPARC_UNUSED_42
, 0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_UNUSED_42",FALSE
,0,0x00000000,TRUE
),
223 HOWTO(R_SPARC_7
, 0,2, 7,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_7", FALSE
,0,0x0000007f,TRUE
),
224 HOWTO(R_SPARC_5
, 0,2, 5,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_5", FALSE
,0,0x0000001f,TRUE
),
225 HOWTO(R_SPARC_6
, 0,2, 6,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_6", FALSE
,0,0x0000003f,TRUE
),
226 HOWTO(R_SPARC_DISP64
, 0,4,64,TRUE
, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_DISP64", FALSE
,0,MINUS_ONE
, TRUE
),
227 HOWTO(R_SPARC_PLT64
, 0,4,64,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_PLT64", FALSE
,0,MINUS_ONE
, TRUE
),
228 HOWTO(R_SPARC_HIX22
, 0,4, 0,FALSE
,0,complain_overflow_bitfield
,sparc_elf_hix22_reloc
, "R_SPARC_HIX22", FALSE
,0,MINUS_ONE
, FALSE
),
229 HOWTO(R_SPARC_LOX10
, 0,4, 0,FALSE
,0,complain_overflow_dont
, sparc_elf_lox10_reloc
, "R_SPARC_LOX10", FALSE
,0,MINUS_ONE
, FALSE
),
230 HOWTO(R_SPARC_H44
, 22,2,22,FALSE
,0,complain_overflow_unsigned
,bfd_elf_generic_reloc
, "R_SPARC_H44", FALSE
,0,0x003fffff,FALSE
),
231 HOWTO(R_SPARC_M44
, 12,2,10,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_M44", FALSE
,0,0x000003ff,FALSE
),
232 HOWTO(R_SPARC_L44
, 0,2,13,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_L44", FALSE
,0,0x00000fff,FALSE
),
233 HOWTO(R_SPARC_REGISTER
, 0,4, 0,FALSE
,0,complain_overflow_bitfield
,sparc_elf_notsup_reloc
, "R_SPARC_REGISTER",FALSE
,0,MINUS_ONE
, FALSE
),
234 HOWTO(R_SPARC_UA64
, 0,4,64,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_UA64", FALSE
,0,MINUS_ONE
, TRUE
),
235 HOWTO(R_SPARC_UA16
, 0,1,16,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_UA16", FALSE
,0,0x0000ffff,TRUE
),
236 HOWTO(R_SPARC_TLS_GD_HI22
,10,2,22,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_GD_HI22",FALSE
,0,0x003fffff,TRUE
),
237 HOWTO(R_SPARC_TLS_GD_LO10
,0,2,10,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_GD_LO10",FALSE
,0,0x000003ff,TRUE
),
238 HOWTO(R_SPARC_TLS_GD_ADD
,0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_GD_ADD",FALSE
,0,0x00000000,TRUE
),
239 HOWTO(R_SPARC_TLS_GD_CALL
,2,2,30,TRUE
,0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_TLS_GD_CALL",FALSE
,0,0x3fffffff,TRUE
),
240 HOWTO(R_SPARC_TLS_LDM_HI22
,10,2,22,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_LDM_HI22",FALSE
,0,0x003fffff,TRUE
),
241 HOWTO(R_SPARC_TLS_LDM_LO10
,0,2,10,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_LDM_LO10",FALSE
,0,0x000003ff,TRUE
),
242 HOWTO(R_SPARC_TLS_LDM_ADD
,0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_LDM_ADD",FALSE
,0,0x00000000,TRUE
),
243 HOWTO(R_SPARC_TLS_LDM_CALL
,2,2,30,TRUE
,0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_TLS_LDM_CALL",FALSE
,0,0x3fffffff,TRUE
),
244 HOWTO(R_SPARC_TLS_LDO_HIX22
,0,2,0,FALSE
,0,complain_overflow_bitfield
,sparc_elf_hix22_reloc
,"R_SPARC_TLS_LDO_HIX22",FALSE
,0,0x003fffff, FALSE
),
245 HOWTO(R_SPARC_TLS_LDO_LOX10
,0,2,0,FALSE
,0,complain_overflow_dont
, sparc_elf_lox10_reloc
, "R_SPARC_TLS_LDO_LOX10",FALSE
,0,0x000003ff, FALSE
),
246 HOWTO(R_SPARC_TLS_LDO_ADD
,0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_LDO_ADD",FALSE
,0,0x00000000,TRUE
),
247 HOWTO(R_SPARC_TLS_IE_HI22
,10,2,22,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_IE_HI22",FALSE
,0,0x003fffff,TRUE
),
248 HOWTO(R_SPARC_TLS_IE_LO10
,0,2,10,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_IE_LO10",FALSE
,0,0x000003ff,TRUE
),
249 HOWTO(R_SPARC_TLS_IE_LD
,0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_IE_LD",FALSE
,0,0x00000000,TRUE
),
250 HOWTO(R_SPARC_TLS_IE_LDX
,0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_IE_LDX",FALSE
,0,0x00000000,TRUE
),
251 HOWTO(R_SPARC_TLS_IE_ADD
,0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_IE_ADD",FALSE
,0,0x00000000,TRUE
),
252 HOWTO(R_SPARC_TLS_LE_HIX22
,0,2,0,FALSE
,0,complain_overflow_bitfield
,sparc_elf_hix22_reloc
, "R_SPARC_TLS_LE_HIX22",FALSE
,0,0x003fffff, FALSE
),
253 HOWTO(R_SPARC_TLS_LE_LOX10
,0,2,0,FALSE
,0,complain_overflow_dont
, sparc_elf_lox10_reloc
, "R_SPARC_TLS_LE_LOX10",FALSE
,0,0x000003ff, FALSE
),
254 HOWTO(R_SPARC_TLS_DTPMOD32
,0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_DTPMOD32",FALSE
,0,0x00000000,TRUE
),
255 HOWTO(R_SPARC_TLS_DTPMOD64
,0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_DTPMOD64",FALSE
,0,0x00000000,TRUE
),
256 HOWTO(R_SPARC_TLS_DTPOFF32
,0,2,32,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
,"R_SPARC_TLS_DTPOFF32",FALSE
,0,0xffffffff,TRUE
),
257 HOWTO(R_SPARC_TLS_DTPOFF64
,0,4,64,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
,"R_SPARC_TLS_DTPOFF64",FALSE
,0,MINUS_ONE
,TRUE
),
258 HOWTO(R_SPARC_TLS_TPOFF32
,0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_TPOFF32",FALSE
,0,0x00000000,TRUE
),
259 HOWTO(R_SPARC_TLS_TPOFF64
,0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_TPOFF64",FALSE
,0,0x00000000,TRUE
)
261 static reloc_howto_type sparc_vtinherit_howto
=
262 HOWTO (R_SPARC_GNU_VTINHERIT
, 0,2,0,FALSE
,0,complain_overflow_dont
, NULL
, "R_SPARC_GNU_VTINHERIT", FALSE
,0, 0, FALSE
);
263 static reloc_howto_type sparc_vtentry_howto
=
264 HOWTO (R_SPARC_GNU_VTENTRY
, 0,2,0,FALSE
,0,complain_overflow_dont
, _bfd_elf_rel_vtable_reloc_fn
,"R_SPARC_GNU_VTENTRY", FALSE
,0,0, FALSE
);
265 static reloc_howto_type sparc_rev32_howto
=
266 HOWTO(R_SPARC_REV32
, 0,2,32,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_REV32", FALSE
,0,0xffffffff,TRUE
);
268 struct elf_reloc_map
{
269 bfd_reloc_code_real_type bfd_reloc_val
;
270 unsigned char elf_reloc_val
;
273 static const struct elf_reloc_map sparc_reloc_map
[] =
275 { BFD_RELOC_NONE
, R_SPARC_NONE
, },
276 { BFD_RELOC_16
, R_SPARC_16
, },
277 { BFD_RELOC_16_PCREL
, R_SPARC_DISP16
},
278 { BFD_RELOC_8
, R_SPARC_8
},
279 { BFD_RELOC_8_PCREL
, R_SPARC_DISP8
},
280 { BFD_RELOC_CTOR
, R_SPARC_64
},
281 { BFD_RELOC_32
, R_SPARC_32
},
282 { BFD_RELOC_32_PCREL
, R_SPARC_DISP32
},
283 { BFD_RELOC_HI22
, R_SPARC_HI22
},
284 { BFD_RELOC_LO10
, R_SPARC_LO10
, },
285 { BFD_RELOC_32_PCREL_S2
, R_SPARC_WDISP30
},
286 { BFD_RELOC_64_PCREL
, R_SPARC_DISP64
},
287 { BFD_RELOC_SPARC22
, R_SPARC_22
},
288 { BFD_RELOC_SPARC13
, R_SPARC_13
},
289 { BFD_RELOC_SPARC_GOT10
, R_SPARC_GOT10
},
290 { BFD_RELOC_SPARC_GOT13
, R_SPARC_GOT13
},
291 { BFD_RELOC_SPARC_GOT22
, R_SPARC_GOT22
},
292 { BFD_RELOC_SPARC_PC10
, R_SPARC_PC10
},
293 { BFD_RELOC_SPARC_PC22
, R_SPARC_PC22
},
294 { BFD_RELOC_SPARC_WPLT30
, R_SPARC_WPLT30
},
295 { BFD_RELOC_SPARC_COPY
, R_SPARC_COPY
},
296 { BFD_RELOC_SPARC_GLOB_DAT
, R_SPARC_GLOB_DAT
},
297 { BFD_RELOC_SPARC_JMP_SLOT
, R_SPARC_JMP_SLOT
},
298 { BFD_RELOC_SPARC_RELATIVE
, R_SPARC_RELATIVE
},
299 { BFD_RELOC_SPARC_WDISP22
, R_SPARC_WDISP22
},
300 { BFD_RELOC_SPARC_UA16
, R_SPARC_UA16
},
301 { BFD_RELOC_SPARC_UA32
, R_SPARC_UA32
},
302 { BFD_RELOC_SPARC_UA64
, R_SPARC_UA64
},
303 { BFD_RELOC_SPARC_10
, R_SPARC_10
},
304 { BFD_RELOC_SPARC_11
, R_SPARC_11
},
305 { BFD_RELOC_SPARC_64
, R_SPARC_64
},
306 { BFD_RELOC_SPARC_OLO10
, R_SPARC_OLO10
},
307 { BFD_RELOC_SPARC_HH22
, R_SPARC_HH22
},
308 { BFD_RELOC_SPARC_HM10
, R_SPARC_HM10
},
309 { BFD_RELOC_SPARC_LM22
, R_SPARC_LM22
},
310 { BFD_RELOC_SPARC_PC_HH22
, R_SPARC_PC_HH22
},
311 { BFD_RELOC_SPARC_PC_HM10
, R_SPARC_PC_HM10
},
312 { BFD_RELOC_SPARC_PC_LM22
, R_SPARC_PC_LM22
},
313 { BFD_RELOC_SPARC_WDISP16
, R_SPARC_WDISP16
},
314 { BFD_RELOC_SPARC_WDISP19
, R_SPARC_WDISP19
},
315 { BFD_RELOC_SPARC_7
, R_SPARC_7
},
316 { BFD_RELOC_SPARC_5
, R_SPARC_5
},
317 { BFD_RELOC_SPARC_6
, R_SPARC_6
},
318 { BFD_RELOC_SPARC_DISP64
, R_SPARC_DISP64
},
319 { BFD_RELOC_SPARC_TLS_GD_HI22
, R_SPARC_TLS_GD_HI22
},
320 { BFD_RELOC_SPARC_TLS_GD_LO10
, R_SPARC_TLS_GD_LO10
},
321 { BFD_RELOC_SPARC_TLS_GD_ADD
, R_SPARC_TLS_GD_ADD
},
322 { BFD_RELOC_SPARC_TLS_GD_CALL
, R_SPARC_TLS_GD_CALL
},
323 { BFD_RELOC_SPARC_TLS_LDM_HI22
, R_SPARC_TLS_LDM_HI22
},
324 { BFD_RELOC_SPARC_TLS_LDM_LO10
, R_SPARC_TLS_LDM_LO10
},
325 { BFD_RELOC_SPARC_TLS_LDM_ADD
, R_SPARC_TLS_LDM_ADD
},
326 { BFD_RELOC_SPARC_TLS_LDM_CALL
, R_SPARC_TLS_LDM_CALL
},
327 { BFD_RELOC_SPARC_TLS_LDO_HIX22
, R_SPARC_TLS_LDO_HIX22
},
328 { BFD_RELOC_SPARC_TLS_LDO_LOX10
, R_SPARC_TLS_LDO_LOX10
},
329 { BFD_RELOC_SPARC_TLS_LDO_ADD
, R_SPARC_TLS_LDO_ADD
},
330 { BFD_RELOC_SPARC_TLS_IE_HI22
, R_SPARC_TLS_IE_HI22
},
331 { BFD_RELOC_SPARC_TLS_IE_LO10
, R_SPARC_TLS_IE_LO10
},
332 { BFD_RELOC_SPARC_TLS_IE_LD
, R_SPARC_TLS_IE_LD
},
333 { BFD_RELOC_SPARC_TLS_IE_LDX
, R_SPARC_TLS_IE_LDX
},
334 { BFD_RELOC_SPARC_TLS_IE_ADD
, R_SPARC_TLS_IE_ADD
},
335 { BFD_RELOC_SPARC_TLS_LE_HIX22
, R_SPARC_TLS_LE_HIX22
},
336 { BFD_RELOC_SPARC_TLS_LE_LOX10
, R_SPARC_TLS_LE_LOX10
},
337 { BFD_RELOC_SPARC_TLS_DTPMOD32
, R_SPARC_TLS_DTPMOD32
},
338 { BFD_RELOC_SPARC_TLS_DTPMOD64
, R_SPARC_TLS_DTPMOD64
},
339 { BFD_RELOC_SPARC_TLS_DTPOFF32
, R_SPARC_TLS_DTPOFF32
},
340 { BFD_RELOC_SPARC_TLS_DTPOFF64
, R_SPARC_TLS_DTPOFF64
},
341 { BFD_RELOC_SPARC_TLS_TPOFF32
, R_SPARC_TLS_TPOFF32
},
342 { BFD_RELOC_SPARC_TLS_TPOFF64
, R_SPARC_TLS_TPOFF64
},
343 { BFD_RELOC_SPARC_PLT32
, R_SPARC_PLT32
},
344 { BFD_RELOC_SPARC_PLT64
, R_SPARC_PLT64
},
345 { BFD_RELOC_SPARC_HIX22
, R_SPARC_HIX22
},
346 { BFD_RELOC_SPARC_LOX10
, R_SPARC_LOX10
},
347 { BFD_RELOC_SPARC_H44
, R_SPARC_H44
},
348 { BFD_RELOC_SPARC_M44
, R_SPARC_M44
},
349 { BFD_RELOC_SPARC_L44
, R_SPARC_L44
},
350 { BFD_RELOC_SPARC_REGISTER
, R_SPARC_REGISTER
},
351 { BFD_RELOC_VTABLE_INHERIT
, R_SPARC_GNU_VTINHERIT
},
352 { BFD_RELOC_VTABLE_ENTRY
, R_SPARC_GNU_VTENTRY
},
353 { BFD_RELOC_SPARC_REV32
, R_SPARC_REV32
},
357 _bfd_sparc_elf_reloc_type_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
358 bfd_reloc_code_real_type code
)
364 case BFD_RELOC_VTABLE_INHERIT
:
365 return &sparc_vtinherit_howto
;
367 case BFD_RELOC_VTABLE_ENTRY
:
368 return &sparc_vtentry_howto
;
370 case BFD_RELOC_SPARC_REV32
:
371 return &sparc_rev32_howto
;
375 i
< sizeof (sparc_reloc_map
) / sizeof (struct elf_reloc_map
);
378 if (sparc_reloc_map
[i
].bfd_reloc_val
== code
)
379 return (_bfd_sparc_elf_howto_table
380 + (int) sparc_reloc_map
[i
].elf_reloc_val
);
383 bfd_set_error (bfd_error_bad_value
);
388 _bfd_sparc_elf_info_to_howto_ptr (unsigned int r_type
)
392 case R_SPARC_GNU_VTINHERIT
:
393 return &sparc_vtinherit_howto
;
395 case R_SPARC_GNU_VTENTRY
:
396 return &sparc_vtentry_howto
;
399 return &sparc_rev32_howto
;
402 if (r_type
>= (unsigned int) R_SPARC_max_std
)
404 (*_bfd_error_handler
) (_("invalid relocation type %d"),
406 r_type
= R_SPARC_NONE
;
408 return &_bfd_sparc_elf_howto_table
[r_type
];
412 /* Both 32-bit and 64-bit sparc encode this in an identical manner,
413 so just take advantage of that. */
414 #define SPARC_ELF_R_TYPE(r_info) \
418 _bfd_sparc_elf_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*cache_ptr
,
419 Elf_Internal_Rela
*dst
)
421 unsigned int r_type
= SPARC_ELF_R_TYPE (dst
->r_info
);
423 cache_ptr
->howto
= _bfd_sparc_elf_info_to_howto_ptr (r_type
);
427 /* The nop opcode we use. */
428 #define SPARC_NOP 0x01000000
430 #define SPARC_INSN_BYTES 4
432 /* The SPARC linker needs to keep track of the number of relocs that it
433 decides to copy as dynamic relocs in check_relocs for each symbol.
434 This is so that it can later discard them if they are found to be
435 unnecessary. We store the information in a field extending the
436 regular ELF linker hash table. */
438 struct _bfd_sparc_elf_dyn_relocs
440 struct _bfd_sparc_elf_dyn_relocs
*next
;
442 /* The input section of the reloc. */
445 /* Total number of relocs copied for the input section. */
448 /* Number of pc-relative relocs copied for the input section. */
449 bfd_size_type pc_count
;
452 /* SPARC ELF linker hash entry. */
454 struct _bfd_sparc_elf_link_hash_entry
456 struct elf_link_hash_entry elf
;
458 /* Track dynamic relocs copied for this symbol. */
459 struct _bfd_sparc_elf_dyn_relocs
*dyn_relocs
;
461 #define GOT_UNKNOWN 0
465 unsigned char tls_type
;
468 #define _bfd_sparc_elf_hash_entry(ent) ((struct _bfd_sparc_elf_link_hash_entry *)(ent))
470 struct _bfd_sparc_elf_obj_tdata
472 struct elf_obj_tdata root
;
474 /* tls_type for each local got entry. */
475 char *local_got_tls_type
;
477 /* TRUE if TLS GD relocs has been seen for this object. */
478 bfd_boolean has_tlsgd
;
481 #define _bfd_sparc_elf_tdata(abfd) \
482 ((struct _bfd_sparc_elf_obj_tdata *) (abfd)->tdata.any)
484 #define _bfd_sparc_elf_local_got_tls_type(abfd) \
485 (_bfd_sparc_elf_tdata (abfd)->local_got_tls_type)
488 _bfd_sparc_elf_mkobject (bfd
*abfd
)
490 if (abfd
->tdata
.any
== NULL
)
492 bfd_size_type amt
= sizeof (struct _bfd_sparc_elf_obj_tdata
);
493 abfd
->tdata
.any
= bfd_zalloc (abfd
, amt
);
494 if (abfd
->tdata
.any
== NULL
)
497 return bfd_elf_mkobject (abfd
);
501 sparc_put_word_32 (bfd
*bfd
, bfd_vma val
, void *ptr
)
503 bfd_put_32 (bfd
, val
, ptr
);
507 sparc_put_word_64 (bfd
*bfd
, bfd_vma val
, void *ptr
)
509 bfd_put_64 (bfd
, val
, ptr
);
513 sparc_elf_append_rela_64 (bfd
*abfd ATTRIBUTE_UNUSED
,
514 asection
*s ATTRIBUTE_UNUSED
,
515 Elf_Internal_Rela
*rel ATTRIBUTE_UNUSED
)
518 Elf64_External_Rela
*loc64
;
520 loc64
= (Elf64_External_Rela
*) s
->contents
;
521 loc64
+= s
->reloc_count
++;
522 bfd_elf64_swap_reloca_out (abfd
, rel
, (bfd_byte
*) loc64
);
527 sparc_elf_append_rela_32 (bfd
*abfd
, asection
*s
, Elf_Internal_Rela
*rel
)
529 Elf32_External_Rela
*loc32
;
531 loc32
= (Elf32_External_Rela
*) s
->contents
;
532 loc32
+= s
->reloc_count
++;
533 bfd_elf32_swap_reloca_out (abfd
, rel
, (bfd_byte
*) loc32
);
537 sparc_elf_r_info_64 (Elf_Internal_Rela
*in_rel ATTRIBUTE_UNUSED
,
538 bfd_vma index ATTRIBUTE_UNUSED
,
539 bfd_vma type ATTRIBUTE_UNUSED
)
541 return ELF64_R_INFO (index
,
543 ELF64_R_TYPE_INFO (ELF64_R_TYPE_DATA (in_rel
->r_info
),
548 sparc_elf_r_info_32 (Elf_Internal_Rela
*in_rel ATTRIBUTE_UNUSED
,
549 bfd_vma index
, bfd_vma type
)
551 return ELF32_R_INFO (index
, type
);
555 sparc_elf_r_symndx_64 (bfd_vma r_info
)
557 bfd_vma r_symndx
= ELF32_R_SYM (r_info
);
558 return (r_symndx
>> 24);
562 sparc_elf_r_symndx_32 (bfd_vma r_info
)
564 return ELF32_R_SYM (r_info
);
569 #define PLT32_ENTRY_SIZE 12
570 #define PLT32_HEADER_SIZE (4 * PLT32_ENTRY_SIZE)
572 /* The first four entries in a 32-bit procedure linkage table are reserved,
573 and the initial contents are unimportant (we zero them out).
574 Subsequent entries look like this. See the SVR4 ABI SPARC
575 supplement to see how this works. */
577 /* sethi %hi(.-.plt0),%g1. We fill in the address later. */
578 #define PLT32_ENTRY_WORD0 0x03000000
579 /* b,a .plt0. We fill in the offset later. */
580 #define PLT32_ENTRY_WORD1 0x30800000
582 #define PLT32_ENTRY_WORD2 SPARC_NOP
585 sparc32_plt_entry_build (bfd
*output_bfd
, asection
*splt
, bfd_vma offset
,
586 bfd_vma max ATTRIBUTE_UNUSED
,
589 bfd_put_32 (output_bfd
,
590 PLT32_ENTRY_WORD0
+ offset
,
591 splt
->contents
+ offset
);
592 bfd_put_32 (output_bfd
,
594 + (((- (offset
+ 4)) >> 2) & 0x3fffff)),
595 splt
->contents
+ offset
+ 4);
596 bfd_put_32 (output_bfd
, (bfd_vma
) PLT32_ENTRY_WORD2
,
597 splt
->contents
+ offset
+ 8);
601 return offset
/ PLT32_ENTRY_SIZE
- 4;
604 /* Both the headers and the entries are icache aligned. */
605 #define PLT64_ENTRY_SIZE 32
606 #define PLT64_HEADER_SIZE (4 * PLT64_ENTRY_SIZE)
607 #define PLT64_LARGE_THRESHOLD 32768
610 sparc64_plt_entry_build (bfd
*output_bfd
, asection
*splt
, bfd_vma offset
,
611 bfd_vma max
, bfd_vma
*r_offset
)
613 unsigned char *entry
= splt
->contents
+ offset
;
614 const unsigned int nop
= SPARC_NOP
;
617 if (offset
< (PLT64_LARGE_THRESHOLD
* PLT64_ENTRY_SIZE
))
619 unsigned int sethi
, ba
;
623 index
= (offset
/ PLT64_ENTRY_SIZE
);
625 sethi
= 0x03000000 | (index
* PLT64_ENTRY_SIZE
);
627 | (((splt
->contents
+ PLT64_ENTRY_SIZE
) - (entry
+ 4)) / 4 & 0x7ffff);
629 bfd_put_32 (output_bfd
, (bfd_vma
) sethi
, entry
);
630 bfd_put_32 (output_bfd
, (bfd_vma
) ba
, entry
+ 4);
631 bfd_put_32 (output_bfd
, (bfd_vma
) nop
, entry
+ 8);
632 bfd_put_32 (output_bfd
, (bfd_vma
) nop
, entry
+ 12);
633 bfd_put_32 (output_bfd
, (bfd_vma
) nop
, entry
+ 16);
634 bfd_put_32 (output_bfd
, (bfd_vma
) nop
, entry
+ 20);
635 bfd_put_32 (output_bfd
, (bfd_vma
) nop
, entry
+ 24);
636 bfd_put_32 (output_bfd
, (bfd_vma
) nop
, entry
+ 28);
642 int block
, last_block
, ofs
, last_ofs
, chunks_this_block
;
643 const int insn_chunk_size
= (6 * 4);
644 const int ptr_chunk_size
= (1 * 8);
645 const int entries_per_block
= 160;
646 const int block_size
= entries_per_block
* (insn_chunk_size
649 /* Entries 32768 and higher are grouped into blocks of 160.
650 The blocks are further subdivided into 160 sequences of
651 6 instructions and 160 pointers. If a block does not require
652 the full 160 entries, let's say it requires N, then there
653 will be N sequences of 6 instructions and N pointers. */
655 offset
-= (PLT64_LARGE_THRESHOLD
* PLT64_ENTRY_SIZE
);
656 max
-= (PLT64_LARGE_THRESHOLD
* PLT64_ENTRY_SIZE
);
658 block
= offset
/ block_size
;
659 last_block
= max
/ block_size
;
660 if (block
!= last_block
)
662 chunks_this_block
= 160;
666 last_ofs
= max
% block_size
;
667 chunks_this_block
= last_ofs
/ (insn_chunk_size
+ ptr_chunk_size
);
670 ofs
= offset
% block_size
;
672 index
= (PLT64_LARGE_THRESHOLD
+
674 (ofs
/ insn_chunk_size
));
677 + (PLT64_LARGE_THRESHOLD
* PLT64_ENTRY_SIZE
)
678 + (block
* block_size
)
679 + (chunks_this_block
* insn_chunk_size
)
680 + (ofs
/ insn_chunk_size
) * ptr_chunk_size
;
682 *r_offset
= (bfd_vma
) (ptr
- splt
->contents
);
684 ldx
= 0xc25be000 | ((ptr
- (entry
+4)) & 0x1fff);
692 bfd_put_32 (output_bfd
, (bfd_vma
) 0x8a10000f, entry
);
693 bfd_put_32 (output_bfd
, (bfd_vma
) 0x40000002, entry
+ 4);
694 bfd_put_32 (output_bfd
, (bfd_vma
) SPARC_NOP
, entry
+ 8);
695 bfd_put_32 (output_bfd
, (bfd_vma
) ldx
, entry
+ 12);
696 bfd_put_32 (output_bfd
, (bfd_vma
) 0x83c3c001, entry
+ 16);
697 bfd_put_32 (output_bfd
, (bfd_vma
) 0x9e100005, entry
+ 20);
699 bfd_put_64 (output_bfd
, (bfd_vma
) (splt
->contents
- (entry
+ 4)), ptr
);
705 /* The format of the first PLT entry in a VxWorks executable. */
706 static const bfd_vma sparc_vxworks_exec_plt0_entry
[] =
708 0x05000000, /* sethi %hi(_GLOBAL_OFFSET_TABLE_+8), %g2 */
709 0x8410a000, /* or %g2, %lo(_GLOBAL_OFFSET_TABLE_+8), %g2 */
710 0xc4008000, /* ld [ %g2 ], %g2 */
711 0x81c08000, /* jmp %g2 */
715 /* The format of subsequent PLT entries. */
716 static const bfd_vma sparc_vxworks_exec_plt_entry
[] =
718 0x03000000, /* sethi %hi(_GLOBAL_OFFSET_TABLE_+f@got), %g1 */
719 0x82106000, /* or %g1, %lo(_GLOBAL_OFFSET_TABLE_+f@got), %g1 */
720 0xc2004000, /* ld [ %g1 ], %g1 */
721 0x81c04000, /* jmp %g1 */
722 0x01000000, /* nop */
723 0x03000000, /* sethi %hi(f@pltindex), %g1 */
724 0x10800000, /* b _PLT_resolve */
725 0x82106000 /* or %g1, %lo(f@pltindex), %g1 */
728 /* The format of the first PLT entry in a VxWorks shared object. */
729 static const bfd_vma sparc_vxworks_shared_plt0_entry
[] =
731 0xc405e008, /* ld [ %l7 + 8 ], %g2 */
732 0x81c08000, /* jmp %g2 */
736 /* The format of subsequent PLT entries. */
737 static const bfd_vma sparc_vxworks_shared_plt_entry
[] =
739 0x03000000, /* sethi %hi(f@got), %g1 */
740 0x82106000, /* or %g1, %lo(f@got), %g1 */
741 0xc205c001, /* ld [ %l7 + %g1 ], %g1 */
742 0x81c04000, /* jmp %g1 */
743 0x01000000, /* nop */
744 0x03000000, /* sethi %hi(f@pltindex), %g1 */
745 0x10800000, /* b _PLT_resolve */
746 0x82106000 /* or %g1, %lo(f@pltindex), %g1 */
749 #define SPARC_ELF_PUT_WORD(htab, bfd, val, ptr) \
750 htab->put_word(bfd, val, ptr)
752 #define SPARC_ELF_APPEND_RELA(htab, bfd, sec, rela) \
753 htab->append_rela(bfd, sec, rela)
755 #define SPARC_ELF_R_INFO(htab, in_rel, index, type) \
756 htab->r_info(in_rel, index, type)
758 #define SPARC_ELF_R_SYMNDX(htab, r_info) \
759 htab->r_symndx(r_info)
761 #define SPARC_ELF_WORD_BYTES(htab) \
764 #define SPARC_ELF_RELA_BYTES(htab) \
767 #define SPARC_ELF_DTPOFF_RELOC(htab) \
770 #define SPARC_ELF_DTPMOD_RELOC(htab) \
773 #define SPARC_ELF_TPOFF_RELOC(htab) \
776 #define SPARC_ELF_BUILD_PLT_ENTRY(htab, obfd, splt, off, max, r_off) \
777 htab->build_plt_entry (obfd, splt, off, max, r_off)
779 /* Create an entry in an SPARC ELF linker hash table. */
781 static struct bfd_hash_entry
*
782 link_hash_newfunc (struct bfd_hash_entry
*entry
,
783 struct bfd_hash_table
*table
, const char *string
)
785 /* Allocate the structure if it has not already been allocated by a
789 entry
= bfd_hash_allocate (table
,
790 sizeof (struct _bfd_sparc_elf_link_hash_entry
));
795 /* Call the allocation method of the superclass. */
796 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
799 struct _bfd_sparc_elf_link_hash_entry
*eh
;
801 eh
= (struct _bfd_sparc_elf_link_hash_entry
*) entry
;
802 eh
->dyn_relocs
= NULL
;
803 eh
->tls_type
= GOT_UNKNOWN
;
809 /* The name of the dynamic interpreter. This is put in the .interp
812 #define ELF32_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
813 #define ELF64_DYNAMIC_INTERPRETER "/usr/lib/sparcv9/ld.so.1"
815 /* Create a SPARC ELF linker hash table. */
817 struct bfd_link_hash_table
*
818 _bfd_sparc_elf_link_hash_table_create (bfd
*abfd
)
820 struct _bfd_sparc_elf_link_hash_table
*ret
;
821 bfd_size_type amt
= sizeof (struct _bfd_sparc_elf_link_hash_table
);
823 ret
= (struct _bfd_sparc_elf_link_hash_table
*) bfd_zmalloc (amt
);
829 ret
->put_word
= sparc_put_word_64
;
830 ret
->append_rela
= sparc_elf_append_rela_64
;
831 ret
->r_info
= sparc_elf_r_info_64
;
832 ret
->r_symndx
= sparc_elf_r_symndx_64
;
833 ret
->dtpoff_reloc
= R_SPARC_TLS_DTPOFF64
;
834 ret
->dtpmod_reloc
= R_SPARC_TLS_DTPMOD64
;
835 ret
->tpoff_reloc
= R_SPARC_TLS_TPOFF64
;
836 ret
->word_align_power
= 3;
837 ret
->align_power_max
= 4;
838 ret
->bytes_per_word
= 8;
839 ret
->bytes_per_rela
= sizeof (Elf64_External_Rela
);
840 ret
->dynamic_interpreter
= ELF64_DYNAMIC_INTERPRETER
;
841 ret
->dynamic_interpreter_size
= sizeof ELF64_DYNAMIC_INTERPRETER
;
845 ret
->put_word
= sparc_put_word_32
;
846 ret
->append_rela
= sparc_elf_append_rela_32
;
847 ret
->r_info
= sparc_elf_r_info_32
;
848 ret
->r_symndx
= sparc_elf_r_symndx_32
;
849 ret
->dtpoff_reloc
= R_SPARC_TLS_DTPOFF32
;
850 ret
->dtpmod_reloc
= R_SPARC_TLS_DTPMOD32
;
851 ret
->tpoff_reloc
= R_SPARC_TLS_TPOFF32
;
852 ret
->word_align_power
= 2;
853 ret
->align_power_max
= 3;
854 ret
->bytes_per_word
= 4;
855 ret
->bytes_per_rela
= sizeof (Elf32_External_Rela
);
856 ret
->dynamic_interpreter
= ELF32_DYNAMIC_INTERPRETER
;
857 ret
->dynamic_interpreter_size
= sizeof ELF32_DYNAMIC_INTERPRETER
;
860 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
, link_hash_newfunc
,
861 sizeof (struct _bfd_sparc_elf_link_hash_entry
)))
867 return &ret
->elf
.root
;
870 /* Create .got and .rela.got sections in DYNOBJ, and set up
871 shortcuts to them in our hash table. */
874 create_got_section (bfd
*dynobj
, struct bfd_link_info
*info
)
876 struct _bfd_sparc_elf_link_hash_table
*htab
;
878 if (! _bfd_elf_create_got_section (dynobj
, info
))
881 htab
= _bfd_sparc_elf_hash_table (info
);
882 htab
->sgot
= bfd_get_section_by_name (dynobj
, ".got");
883 BFD_ASSERT (htab
->sgot
!= NULL
);
885 htab
->srelgot
= bfd_make_section_with_flags (dynobj
, ".rela.got",
892 if (htab
->srelgot
== NULL
893 || ! bfd_set_section_alignment (dynobj
, htab
->srelgot
,
894 htab
->word_align_power
))
897 if (htab
->is_vxworks
)
899 htab
->sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
907 /* Create .plt, .rela.plt, .got, .rela.got, .dynbss, and
908 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
912 _bfd_sparc_elf_create_dynamic_sections (bfd
*dynobj
,
913 struct bfd_link_info
*info
)
915 struct _bfd_sparc_elf_link_hash_table
*htab
;
917 htab
= _bfd_sparc_elf_hash_table (info
);
918 if (!htab
->sgot
&& !create_got_section (dynobj
, info
))
921 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
924 htab
->splt
= bfd_get_section_by_name (dynobj
, ".plt");
925 htab
->srelplt
= bfd_get_section_by_name (dynobj
, ".rela.plt");
926 htab
->sdynbss
= bfd_get_section_by_name (dynobj
, ".dynbss");
928 htab
->srelbss
= bfd_get_section_by_name (dynobj
, ".rela.bss");
930 if (htab
->is_vxworks
)
932 if (!elf_vxworks_create_dynamic_sections (dynobj
, info
, &htab
->srelplt2
))
936 htab
->plt_header_size
937 = 4 * ARRAY_SIZE (sparc_vxworks_shared_plt0_entry
);
939 = 4 * ARRAY_SIZE (sparc_vxworks_shared_plt_entry
);
943 htab
->plt_header_size
944 = 4 * ARRAY_SIZE (sparc_vxworks_exec_plt0_entry
);
946 = 4 * ARRAY_SIZE (sparc_vxworks_exec_plt_entry
);
951 if (ABI_64_P (dynobj
))
953 htab
->build_plt_entry
= sparc64_plt_entry_build
;
954 htab
->plt_header_size
= PLT64_HEADER_SIZE
;
955 htab
->plt_entry_size
= PLT64_ENTRY_SIZE
;
959 htab
->build_plt_entry
= sparc32_plt_entry_build
;
960 htab
->plt_header_size
= PLT32_HEADER_SIZE
;
961 htab
->plt_entry_size
= PLT32_ENTRY_SIZE
;
965 if (!htab
->splt
|| !htab
->srelplt
|| !htab
->sdynbss
966 || (!info
->shared
&& !htab
->srelbss
))
972 /* Copy the extra info we tack onto an elf_link_hash_entry. */
975 _bfd_sparc_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
976 struct elf_link_hash_entry
*dir
,
977 struct elf_link_hash_entry
*ind
)
979 struct _bfd_sparc_elf_link_hash_entry
*edir
, *eind
;
981 edir
= (struct _bfd_sparc_elf_link_hash_entry
*) dir
;
982 eind
= (struct _bfd_sparc_elf_link_hash_entry
*) ind
;
984 if (eind
->dyn_relocs
!= NULL
)
986 if (edir
->dyn_relocs
!= NULL
)
988 struct _bfd_sparc_elf_dyn_relocs
**pp
;
989 struct _bfd_sparc_elf_dyn_relocs
*p
;
991 /* Add reloc counts against the indirect sym to the direct sym
992 list. Merge any entries against the same section. */
993 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
995 struct _bfd_sparc_elf_dyn_relocs
*q
;
997 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
998 if (q
->sec
== p
->sec
)
1000 q
->pc_count
+= p
->pc_count
;
1001 q
->count
+= p
->count
;
1008 *pp
= edir
->dyn_relocs
;
1011 edir
->dyn_relocs
= eind
->dyn_relocs
;
1012 eind
->dyn_relocs
= NULL
;
1015 if (ind
->root
.type
== bfd_link_hash_indirect
1016 && dir
->got
.refcount
<= 0)
1018 edir
->tls_type
= eind
->tls_type
;
1019 eind
->tls_type
= GOT_UNKNOWN
;
1021 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
1025 sparc_elf_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
1026 int r_type
, int is_local
)
1028 if (! ABI_64_P (abfd
)
1029 && r_type
== R_SPARC_TLS_GD_HI22
1030 && ! _bfd_sparc_elf_tdata (abfd
)->has_tlsgd
)
1031 r_type
= R_SPARC_REV32
;
1038 case R_SPARC_TLS_GD_HI22
:
1040 return R_SPARC_TLS_LE_HIX22
;
1041 return R_SPARC_TLS_IE_HI22
;
1042 case R_SPARC_TLS_GD_LO10
:
1044 return R_SPARC_TLS_LE_LOX10
;
1045 return R_SPARC_TLS_IE_LO10
;
1046 case R_SPARC_TLS_IE_HI22
:
1048 return R_SPARC_TLS_LE_HIX22
;
1050 case R_SPARC_TLS_IE_LO10
:
1052 return R_SPARC_TLS_LE_LOX10
;
1054 case R_SPARC_TLS_LDM_HI22
:
1055 return R_SPARC_TLS_LE_HIX22
;
1056 case R_SPARC_TLS_LDM_LO10
:
1057 return R_SPARC_TLS_LE_LOX10
;
1063 /* Look through the relocs for a section during the first phase, and
1064 allocate space in the global offset table or procedure linkage
1068 _bfd_sparc_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
1069 asection
*sec
, const Elf_Internal_Rela
*relocs
)
1071 struct _bfd_sparc_elf_link_hash_table
*htab
;
1072 Elf_Internal_Shdr
*symtab_hdr
;
1073 struct elf_link_hash_entry
**sym_hashes
;
1074 bfd_vma
*local_got_offsets
;
1075 const Elf_Internal_Rela
*rel
;
1076 const Elf_Internal_Rela
*rel_end
;
1079 bfd_boolean checked_tlsgd
= FALSE
;
1081 if (info
->relocatable
)
1084 htab
= _bfd_sparc_elf_hash_table (info
);
1085 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1086 sym_hashes
= elf_sym_hashes (abfd
);
1087 local_got_offsets
= elf_local_got_offsets (abfd
);
1091 if (ABI_64_P (abfd
))
1092 num_relocs
= NUM_SHDR_ENTRIES (& elf_section_data (sec
)->rel_hdr
);
1094 num_relocs
= sec
->reloc_count
;
1095 rel_end
= relocs
+ num_relocs
;
1096 for (rel
= relocs
; rel
< rel_end
; rel
++)
1098 unsigned int r_type
;
1099 unsigned long r_symndx
;
1100 struct elf_link_hash_entry
*h
;
1102 r_symndx
= SPARC_ELF_R_SYMNDX (htab
, rel
->r_info
);
1103 r_type
= SPARC_ELF_R_TYPE (rel
->r_info
);
1105 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1107 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
1112 if (r_symndx
< symtab_hdr
->sh_info
)
1116 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1117 while (h
->root
.type
== bfd_link_hash_indirect
1118 || h
->root
.type
== bfd_link_hash_warning
)
1119 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1122 /* Compatibility with old R_SPARC_REV32 reloc conflicting
1123 with R_SPARC_TLS_GD_HI22. */
1124 if (! ABI_64_P (abfd
) && ! checked_tlsgd
)
1127 case R_SPARC_TLS_GD_HI22
:
1129 const Elf_Internal_Rela
*relt
;
1131 for (relt
= rel
+ 1; relt
< rel_end
; relt
++)
1132 if (ELF32_R_TYPE (relt
->r_info
) == R_SPARC_TLS_GD_LO10
1133 || ELF32_R_TYPE (relt
->r_info
) == R_SPARC_TLS_GD_ADD
1134 || ELF32_R_TYPE (relt
->r_info
) == R_SPARC_TLS_GD_CALL
)
1136 checked_tlsgd
= TRUE
;
1137 _bfd_sparc_elf_tdata (abfd
)->has_tlsgd
= relt
< rel_end
;
1140 case R_SPARC_TLS_GD_LO10
:
1141 case R_SPARC_TLS_GD_ADD
:
1142 case R_SPARC_TLS_GD_CALL
:
1143 checked_tlsgd
= TRUE
;
1144 _bfd_sparc_elf_tdata (abfd
)->has_tlsgd
= TRUE
;
1148 r_type
= sparc_elf_tls_transition (info
, abfd
, r_type
, h
== NULL
);
1151 case R_SPARC_TLS_LDM_HI22
:
1152 case R_SPARC_TLS_LDM_LO10
:
1153 htab
->tls_ldm_got
.refcount
+= 1;
1156 case R_SPARC_TLS_LE_HIX22
:
1157 case R_SPARC_TLS_LE_LOX10
:
1162 case R_SPARC_TLS_IE_HI22
:
1163 case R_SPARC_TLS_IE_LO10
:
1165 info
->flags
|= DF_STATIC_TLS
;
1171 case R_SPARC_TLS_GD_HI22
:
1172 case R_SPARC_TLS_GD_LO10
:
1173 /* This symbol requires a global offset table entry. */
1175 int tls_type
, old_tls_type
;
1183 tls_type
= GOT_NORMAL
;
1185 case R_SPARC_TLS_GD_HI22
:
1186 case R_SPARC_TLS_GD_LO10
:
1187 tls_type
= GOT_TLS_GD
;
1189 case R_SPARC_TLS_IE_HI22
:
1190 case R_SPARC_TLS_IE_LO10
:
1191 tls_type
= GOT_TLS_IE
;
1197 h
->got
.refcount
+= 1;
1198 old_tls_type
= _bfd_sparc_elf_hash_entry(h
)->tls_type
;
1202 bfd_signed_vma
*local_got_refcounts
;
1204 /* This is a global offset table entry for a local symbol. */
1205 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1206 if (local_got_refcounts
== NULL
)
1210 size
= symtab_hdr
->sh_info
;
1211 size
*= (sizeof (bfd_signed_vma
) + sizeof(char));
1212 local_got_refcounts
= ((bfd_signed_vma
*)
1213 bfd_zalloc (abfd
, size
));
1214 if (local_got_refcounts
== NULL
)
1216 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1217 _bfd_sparc_elf_local_got_tls_type (abfd
)
1218 = (char *) (local_got_refcounts
+ symtab_hdr
->sh_info
);
1220 local_got_refcounts
[r_symndx
] += 1;
1221 old_tls_type
= _bfd_sparc_elf_local_got_tls_type (abfd
) [r_symndx
];
1224 /* If a TLS symbol is accessed using IE at least once,
1225 there is no point to use dynamic model for it. */
1226 if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1227 && (old_tls_type
!= GOT_TLS_GD
1228 || tls_type
!= GOT_TLS_IE
))
1230 if (old_tls_type
== GOT_TLS_IE
&& tls_type
== GOT_TLS_GD
)
1231 tls_type
= old_tls_type
;
1234 (*_bfd_error_handler
)
1235 (_("%B: `%s' accessed both as normal and thread local symbol"),
1236 abfd
, h
? h
->root
.root
.string
: "<local>");
1241 if (old_tls_type
!= tls_type
)
1244 _bfd_sparc_elf_hash_entry (h
)->tls_type
= tls_type
;
1246 _bfd_sparc_elf_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1250 if (htab
->sgot
== NULL
)
1252 if (htab
->elf
.dynobj
== NULL
)
1253 htab
->elf
.dynobj
= abfd
;
1254 if (!create_got_section (htab
->elf
.dynobj
, info
))
1259 case R_SPARC_TLS_GD_CALL
:
1260 case R_SPARC_TLS_LDM_CALL
:
1263 /* These are basically R_SPARC_TLS_WPLT30 relocs against
1265 struct bfd_link_hash_entry
*bh
= NULL
;
1266 if (! _bfd_generic_link_add_one_symbol (info
, abfd
,
1267 "__tls_get_addr", 0,
1268 bfd_und_section_ptr
, 0,
1272 h
= (struct elf_link_hash_entry
*) bh
;
1279 case R_SPARC_WPLT30
:
1280 case R_SPARC_HIPLT22
:
1281 case R_SPARC_LOPLT10
:
1282 case R_SPARC_PCPLT32
:
1283 case R_SPARC_PCPLT22
:
1284 case R_SPARC_PCPLT10
:
1286 /* This symbol requires a procedure linkage table entry. We
1287 actually build the entry in adjust_dynamic_symbol,
1288 because this might be a case of linking PIC code without
1289 linking in any dynamic objects, in which case we don't
1290 need to generate a procedure linkage table after all. */
1294 if (! ABI_64_P (abfd
))
1296 /* The Solaris native assembler will generate a WPLT30
1297 reloc for a local symbol if you assemble a call from
1298 one section to another when using -K pic. We treat
1300 if (ELF32_R_TYPE (rel
->r_info
) == R_SPARC_PLT32
)
1305 /* It does not make sense to have a procedure linkage
1306 table entry for a local symbol. */
1307 bfd_set_error (bfd_error_bad_value
);
1316 this_r_type
= SPARC_ELF_R_TYPE (rel
->r_info
);
1317 if (this_r_type
== R_SPARC_PLT32
1318 || this_r_type
== R_SPARC_PLT64
)
1321 h
->plt
.refcount
+= 1;
1326 case R_SPARC_PC_HH22
:
1327 case R_SPARC_PC_HM10
:
1328 case R_SPARC_PC_LM22
:
1333 && strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
1338 case R_SPARC_DISP16
:
1339 case R_SPARC_DISP32
:
1340 case R_SPARC_DISP64
:
1341 case R_SPARC_WDISP30
:
1342 case R_SPARC_WDISP22
:
1343 case R_SPARC_WDISP19
:
1344 case R_SPARC_WDISP16
:
1374 if (h
!= NULL
&& !info
->shared
)
1376 /* We may need a .plt entry if the function this reloc
1377 refers to is in a shared lib. */
1378 h
->plt
.refcount
+= 1;
1381 /* If we are creating a shared library, and this is a reloc
1382 against a global symbol, or a non PC relative reloc
1383 against a local symbol, then we need to copy the reloc
1384 into the shared library. However, if we are linking with
1385 -Bsymbolic, we do not need to copy a reloc against a
1386 global symbol which is defined in an object we are
1387 including in the link (i.e., DEF_REGULAR is set). At
1388 this point we have not seen all the input files, so it is
1389 possible that DEF_REGULAR is not set now but will be set
1390 later (it is never cleared). In case of a weak definition,
1391 DEF_REGULAR may be cleared later by a strong definition in
1392 a shared library. We account for that possibility below by
1393 storing information in the relocs_copied field of the hash
1394 table entry. A similar situation occurs when creating
1395 shared libraries and symbol visibility changes render the
1398 If on the other hand, we are creating an executable, we
1399 may need to keep relocations for symbols satisfied by a
1400 dynamic library if we manage to avoid copy relocs for the
1403 && (sec
->flags
& SEC_ALLOC
) != 0
1404 && (! _bfd_sparc_elf_howto_table
[r_type
].pc_relative
1406 && (! info
->symbolic
1407 || h
->root
.type
== bfd_link_hash_defweak
1408 || !h
->def_regular
))))
1410 && (sec
->flags
& SEC_ALLOC
) != 0
1412 && (h
->root
.type
== bfd_link_hash_defweak
1413 || !h
->def_regular
)))
1415 struct _bfd_sparc_elf_dyn_relocs
*p
;
1416 struct _bfd_sparc_elf_dyn_relocs
**head
;
1418 /* When creating a shared object, we must copy these
1419 relocs into the output file. We create a reloc
1420 section in dynobj and make room for the reloc. */
1426 name
= (bfd_elf_string_from_elf_section
1428 elf_elfheader (abfd
)->e_shstrndx
,
1429 elf_section_data (sec
)->rel_hdr
.sh_name
));
1433 BFD_ASSERT (CONST_STRNEQ (name
, ".rela")
1434 && strcmp (bfd_get_section_name (abfd
, sec
),
1437 if (htab
->elf
.dynobj
== NULL
)
1438 htab
->elf
.dynobj
= abfd
;
1439 dynobj
= htab
->elf
.dynobj
;
1441 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1446 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
1447 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
1448 if ((sec
->flags
& SEC_ALLOC
) != 0)
1449 flags
|= SEC_ALLOC
| SEC_LOAD
;
1450 sreloc
= bfd_make_section_with_flags (dynobj
,
1454 || ! bfd_set_section_alignment (dynobj
, sreloc
,
1455 htab
->word_align_power
))
1458 elf_section_data (sec
)->sreloc
= sreloc
;
1461 /* If this is a global symbol, we count the number of
1462 relocations we need for this symbol. */
1464 head
= &((struct _bfd_sparc_elf_link_hash_entry
*) h
)->dyn_relocs
;
1467 /* Track dynamic relocs needed for local syms too.
1468 We really need local syms available to do this
1474 s
= bfd_section_from_r_symndx (abfd
, &htab
->sym_sec
,
1479 vpp
= &elf_section_data (s
)->local_dynrel
;
1480 head
= (struct _bfd_sparc_elf_dyn_relocs
**) vpp
;
1484 if (p
== NULL
|| p
->sec
!= sec
)
1486 bfd_size_type amt
= sizeof *p
;
1487 p
= ((struct _bfd_sparc_elf_dyn_relocs
*)
1488 bfd_alloc (htab
->elf
.dynobj
, amt
));
1499 if (_bfd_sparc_elf_howto_table
[r_type
].pc_relative
)
1505 case R_SPARC_GNU_VTINHERIT
:
1506 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1510 case R_SPARC_GNU_VTENTRY
:
1511 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
1515 case R_SPARC_REGISTER
:
1516 /* Nothing to do. */
1528 _bfd_sparc_elf_gc_mark_hook (asection
*sec
,
1529 struct bfd_link_info
*info
,
1530 Elf_Internal_Rela
*rel
,
1531 struct elf_link_hash_entry
*h
,
1532 Elf_Internal_Sym
*sym
)
1535 switch (SPARC_ELF_R_TYPE (rel
->r_info
))
1537 case R_SPARC_GNU_VTINHERIT
:
1538 case R_SPARC_GNU_VTENTRY
:
1542 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
1545 /* Update the got entry reference counts for the section being removed. */
1547 _bfd_sparc_elf_gc_sweep_hook (bfd
*abfd
, struct bfd_link_info
*info
,
1548 asection
*sec
, const Elf_Internal_Rela
*relocs
)
1550 struct _bfd_sparc_elf_link_hash_table
*htab
;
1551 Elf_Internal_Shdr
*symtab_hdr
;
1552 struct elf_link_hash_entry
**sym_hashes
;
1553 bfd_signed_vma
*local_got_refcounts
;
1554 const Elf_Internal_Rela
*rel
, *relend
;
1556 elf_section_data (sec
)->local_dynrel
= NULL
;
1558 htab
= _bfd_sparc_elf_hash_table (info
);
1559 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1560 sym_hashes
= elf_sym_hashes (abfd
);
1561 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1563 relend
= relocs
+ sec
->reloc_count
;
1564 for (rel
= relocs
; rel
< relend
; rel
++)
1566 unsigned long r_symndx
;
1567 unsigned int r_type
;
1568 struct elf_link_hash_entry
*h
= NULL
;
1570 r_symndx
= SPARC_ELF_R_SYMNDX (htab
, rel
->r_info
);
1571 if (r_symndx
>= symtab_hdr
->sh_info
)
1573 struct _bfd_sparc_elf_link_hash_entry
*eh
;
1574 struct _bfd_sparc_elf_dyn_relocs
**pp
;
1575 struct _bfd_sparc_elf_dyn_relocs
*p
;
1577 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1578 while (h
->root
.type
== bfd_link_hash_indirect
1579 || h
->root
.type
== bfd_link_hash_warning
)
1580 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1581 eh
= (struct _bfd_sparc_elf_link_hash_entry
*) h
;
1582 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
1585 /* Everything must go for SEC. */
1591 r_type
= SPARC_ELF_R_TYPE (rel
->r_info
);
1592 r_type
= sparc_elf_tls_transition (info
, abfd
, r_type
, h
!= NULL
);
1595 case R_SPARC_TLS_LDM_HI22
:
1596 case R_SPARC_TLS_LDM_LO10
:
1597 if (_bfd_sparc_elf_hash_table (info
)->tls_ldm_got
.refcount
> 0)
1598 _bfd_sparc_elf_hash_table (info
)->tls_ldm_got
.refcount
-= 1;
1601 case R_SPARC_TLS_GD_HI22
:
1602 case R_SPARC_TLS_GD_LO10
:
1603 case R_SPARC_TLS_IE_HI22
:
1604 case R_SPARC_TLS_IE_LO10
:
1610 if (h
->got
.refcount
> 0)
1615 if (local_got_refcounts
[r_symndx
] > 0)
1616 local_got_refcounts
[r_symndx
]--;
1622 case R_SPARC_PC_HH22
:
1623 case R_SPARC_PC_HM10
:
1624 case R_SPARC_PC_LM22
:
1626 && strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
1631 case R_SPARC_DISP16
:
1632 case R_SPARC_DISP32
:
1633 case R_SPARC_DISP64
:
1634 case R_SPARC_WDISP30
:
1635 case R_SPARC_WDISP22
:
1636 case R_SPARC_WDISP19
:
1637 case R_SPARC_WDISP16
:
1668 case R_SPARC_WPLT30
:
1671 if (h
->plt
.refcount
> 0)
1684 /* Adjust a symbol defined by a dynamic object and referenced by a
1685 regular object. The current definition is in some section of the
1686 dynamic object, but we're not including those sections. We have to
1687 change the definition to something the rest of the link can
1691 _bfd_sparc_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
1692 struct elf_link_hash_entry
*h
)
1694 struct _bfd_sparc_elf_link_hash_table
*htab
;
1695 struct _bfd_sparc_elf_link_hash_entry
* eh
;
1696 struct _bfd_sparc_elf_dyn_relocs
*p
;
1698 unsigned int power_of_two
;
1700 htab
= _bfd_sparc_elf_hash_table (info
);
1702 /* Make sure we know what is going on here. */
1703 BFD_ASSERT (htab
->elf
.dynobj
!= NULL
1705 || h
->u
.weakdef
!= NULL
1708 && !h
->def_regular
)));
1710 /* If this is a function, put it in the procedure linkage table. We
1711 will fill in the contents of the procedure linkage table later
1712 (although we could actually do it here). The STT_NOTYPE
1713 condition is a hack specifically for the Oracle libraries
1714 delivered for Solaris; for some inexplicable reason, they define
1715 some of their functions as STT_NOTYPE when they really should be
1717 if (h
->type
== STT_FUNC
1719 || (h
->type
== STT_NOTYPE
1720 && (h
->root
.type
== bfd_link_hash_defined
1721 || h
->root
.type
== bfd_link_hash_defweak
)
1722 && (h
->root
.u
.def
.section
->flags
& SEC_CODE
) != 0))
1724 if (h
->plt
.refcount
<= 0
1728 && h
->root
.type
!= bfd_link_hash_undefweak
1729 && h
->root
.type
!= bfd_link_hash_undefined
))
1731 /* This case can occur if we saw a WPLT30 reloc in an input
1732 file, but the symbol was never referred to by a dynamic
1733 object, or if all references were garbage collected. In
1734 such a case, we don't actually need to build a procedure
1735 linkage table, and we can just do a WDISP30 reloc instead. */
1736 h
->plt
.offset
= (bfd_vma
) -1;
1743 h
->plt
.offset
= (bfd_vma
) -1;
1745 /* If this is a weak symbol, and there is a real definition, the
1746 processor independent code will have arranged for us to see the
1747 real definition first, and we can just use the same value. */
1748 if (h
->u
.weakdef
!= NULL
)
1750 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
1751 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
1752 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
1753 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
1757 /* This is a reference to a symbol defined by a dynamic object which
1758 is not a function. */
1760 /* If we are creating a shared library, we must presume that the
1761 only references to the symbol are via the global offset table.
1762 For such cases we need not do anything here; the relocations will
1763 be handled correctly by relocate_section. */
1767 /* If there are no references to this symbol that do not use the
1768 GOT, we don't need to generate a copy reloc. */
1769 if (!h
->non_got_ref
)
1772 eh
= (struct _bfd_sparc_elf_link_hash_entry
*) h
;
1773 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1775 s
= p
->sec
->output_section
;
1776 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1780 /* If we didn't find any dynamic relocs in read-only sections, then
1781 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1790 (*_bfd_error_handler
) (_("dynamic variable `%s' is zero size"),
1791 h
->root
.root
.string
);
1795 /* We must allocate the symbol in our .dynbss section, which will
1796 become part of the .bss section of the executable. There will be
1797 an entry for this symbol in the .dynsym section. The dynamic
1798 object will contain position independent code, so all references
1799 from the dynamic object to this symbol will go through the global
1800 offset table. The dynamic linker will use the .dynsym entry to
1801 determine the address it must put in the global offset table, so
1802 both the dynamic object and the regular object will refer to the
1803 same memory location for the variable. */
1805 /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker
1806 to copy the initial value out of the dynamic object and into the
1807 runtime process image. We need to remember the offset into the
1808 .rel.bss section we are going to use. */
1809 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
1811 htab
->srelbss
->size
+= SPARC_ELF_RELA_BYTES (htab
);
1815 /* We need to figure out the alignment required for this symbol. I
1816 have no idea how ELF linkers handle this. */
1817 power_of_two
= bfd_log2 (h
->size
);
1818 if (power_of_two
> htab
->align_power_max
)
1819 power_of_two
= htab
->align_power_max
;
1821 /* Apply the required alignment. */
1823 s
->size
= BFD_ALIGN (s
->size
, (bfd_size_type
) (1 << power_of_two
));
1824 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
1826 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
1830 /* Define the symbol as being at this point in the section. */
1831 h
->root
.u
.def
.section
= s
;
1832 h
->root
.u
.def
.value
= s
->size
;
1834 /* Increment the section size to make room for the symbol. */
1840 /* Allocate space in .plt, .got and associated reloc sections for
1844 allocate_dynrelocs (struct elf_link_hash_entry
*h
, PTR inf
)
1846 struct bfd_link_info
*info
;
1847 struct _bfd_sparc_elf_link_hash_table
*htab
;
1848 struct _bfd_sparc_elf_link_hash_entry
*eh
;
1849 struct _bfd_sparc_elf_dyn_relocs
*p
;
1851 if (h
->root
.type
== bfd_link_hash_indirect
)
1854 if (h
->root
.type
== bfd_link_hash_warning
)
1855 /* When warning symbols are created, they **replace** the "real"
1856 entry in the hash table, thus we never get to see the real
1857 symbol in a hash traversal. So look at it now. */
1858 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1860 info
= (struct bfd_link_info
*) inf
;
1861 htab
= _bfd_sparc_elf_hash_table (info
);
1863 if (htab
->elf
.dynamic_sections_created
1864 && h
->plt
.refcount
> 0)
1866 /* Make sure this symbol is output as a dynamic symbol.
1867 Undefined weak syms won't yet be marked as dynamic. */
1868 if (h
->dynindx
== -1
1869 && !h
->forced_local
)
1871 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1875 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info
->shared
, h
))
1877 asection
*s
= htab
->splt
;
1879 /* Allocate room for the header. */
1882 s
->size
= htab
->plt_header_size
;
1884 /* Allocate space for the .rela.plt.unloaded relocations. */
1885 if (htab
->is_vxworks
&& !info
->shared
)
1886 htab
->srelplt2
->size
= sizeof (Elf32_External_Rela
) * 2;
1889 /* The procedure linkage table size is bounded by the magnitude
1890 of the offset we can describe in the entry. */
1891 if (s
->size
>= (SPARC_ELF_WORD_BYTES(htab
) == 8 ?
1892 (((bfd_vma
)1 << 31) << 1) : 0x400000))
1894 bfd_set_error (bfd_error_bad_value
);
1898 if (SPARC_ELF_WORD_BYTES(htab
) == 8
1899 && s
->size
>= PLT64_LARGE_THRESHOLD
* PLT64_ENTRY_SIZE
)
1901 bfd_vma off
= s
->size
- PLT64_LARGE_THRESHOLD
* PLT64_ENTRY_SIZE
;
1904 off
= (off
% (160 * PLT64_ENTRY_SIZE
)) / PLT64_ENTRY_SIZE
;
1906 h
->plt
.offset
= (s
->size
- (off
* 8));
1909 h
->plt
.offset
= s
->size
;
1911 /* If this symbol is not defined in a regular file, and we are
1912 not generating a shared library, then set the symbol to this
1913 location in the .plt. This is required to make function
1914 pointers compare as equal between the normal executable and
1915 the shared library. */
1919 h
->root
.u
.def
.section
= s
;
1920 h
->root
.u
.def
.value
= h
->plt
.offset
;
1923 /* Make room for this entry. */
1924 s
->size
+= htab
->plt_entry_size
;
1926 /* We also need to make an entry in the .rela.plt section. */
1927 htab
->srelplt
->size
+= SPARC_ELF_RELA_BYTES (htab
);
1929 if (htab
->is_vxworks
)
1931 /* Allocate space for the .got.plt entry. */
1932 htab
->sgotplt
->size
+= 4;
1934 /* ...and for the .rela.plt.unloaded relocations. */
1936 htab
->srelplt2
->size
+= sizeof (Elf32_External_Rela
) * 3;
1941 h
->plt
.offset
= (bfd_vma
) -1;
1947 h
->plt
.offset
= (bfd_vma
) -1;
1951 /* If R_SPARC_TLS_IE_{HI22,LO10} symbol is now local to the binary,
1952 make it a R_SPARC_TLS_LE_{HI22,LO10} requiring no TLS entry. */
1953 if (h
->got
.refcount
> 0
1956 && _bfd_sparc_elf_hash_entry(h
)->tls_type
== GOT_TLS_IE
)
1957 h
->got
.offset
= (bfd_vma
) -1;
1958 else if (h
->got
.refcount
> 0)
1962 int tls_type
= _bfd_sparc_elf_hash_entry(h
)->tls_type
;
1964 /* Make sure this symbol is output as a dynamic symbol.
1965 Undefined weak syms won't yet be marked as dynamic. */
1966 if (h
->dynindx
== -1
1967 && !h
->forced_local
)
1969 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1974 h
->got
.offset
= s
->size
;
1975 s
->size
+= SPARC_ELF_WORD_BYTES (htab
);
1976 /* R_SPARC_TLS_GD_HI{22,LO10} needs 2 consecutive GOT slots. */
1977 if (tls_type
== GOT_TLS_GD
)
1978 s
->size
+= SPARC_ELF_WORD_BYTES (htab
);
1979 dyn
= htab
->elf
.dynamic_sections_created
;
1980 /* R_SPARC_TLS_IE_{HI22,LO10} needs one dynamic relocation,
1981 R_SPARC_TLS_GD_{HI22,LO10} needs one if local symbol and two if
1983 if ((tls_type
== GOT_TLS_GD
&& h
->dynindx
== -1)
1984 || tls_type
== GOT_TLS_IE
)
1985 htab
->srelgot
->size
+= SPARC_ELF_RELA_BYTES (htab
);
1986 else if (tls_type
== GOT_TLS_GD
)
1987 htab
->srelgot
->size
+= 2 * SPARC_ELF_RELA_BYTES (htab
);
1988 else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
))
1989 htab
->srelgot
->size
+= SPARC_ELF_RELA_BYTES (htab
);
1992 h
->got
.offset
= (bfd_vma
) -1;
1994 eh
= (struct _bfd_sparc_elf_link_hash_entry
*) h
;
1995 if (eh
->dyn_relocs
== NULL
)
1998 /* In the shared -Bsymbolic case, discard space allocated for
1999 dynamic pc-relative relocs against symbols which turn out to be
2000 defined in regular objects. For the normal shared case, discard
2001 space for pc-relative relocs that have become local due to symbol
2002 visibility changes. */
2010 struct _bfd_sparc_elf_dyn_relocs
**pp
;
2012 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2014 p
->count
-= p
->pc_count
;
2023 /* Also discard relocs on undefined weak syms with non-default
2025 if (eh
->dyn_relocs
!= NULL
2026 && h
->root
.type
== bfd_link_hash_undefweak
)
2028 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
2029 eh
->dyn_relocs
= NULL
;
2031 /* Make sure undefined weak symbols are output as a dynamic
2033 else if (h
->dynindx
== -1
2034 && !h
->forced_local
)
2036 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2043 /* For the non-shared case, discard space for relocs against
2044 symbols which turn out to need copy relocs or are not
2050 || (htab
->elf
.dynamic_sections_created
2051 && (h
->root
.type
== bfd_link_hash_undefweak
2052 || h
->root
.type
== bfd_link_hash_undefined
))))
2054 /* Make sure this symbol is output as a dynamic symbol.
2055 Undefined weak syms won't yet be marked as dynamic. */
2056 if (h
->dynindx
== -1
2057 && !h
->forced_local
)
2059 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2063 /* If that succeeded, we know we'll be keeping all the
2065 if (h
->dynindx
!= -1)
2069 eh
->dyn_relocs
= NULL
;
2074 /* Finally, allocate space. */
2075 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2077 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
2078 sreloc
->size
+= p
->count
* SPARC_ELF_RELA_BYTES (htab
);
2084 /* Find any dynamic relocs that apply to read-only sections. */
2087 readonly_dynrelocs (struct elf_link_hash_entry
*h
, PTR inf
)
2089 struct _bfd_sparc_elf_link_hash_entry
*eh
;
2090 struct _bfd_sparc_elf_dyn_relocs
*p
;
2092 if (h
->root
.type
== bfd_link_hash_warning
)
2093 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2095 eh
= (struct _bfd_sparc_elf_link_hash_entry
*) h
;
2096 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2098 asection
*s
= p
->sec
->output_section
;
2100 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2102 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
2104 info
->flags
|= DF_TEXTREL
;
2106 /* Not an error, just cut short the traversal. */
2113 /* Return true if the dynamic symbol for a given section should be
2114 omitted when creating a shared library. */
2117 _bfd_sparc_elf_omit_section_dynsym (bfd
*output_bfd
,
2118 struct bfd_link_info
*info
,
2121 /* We keep the .got section symbol so that explicit relocations
2122 against the _GLOBAL_OFFSET_TABLE_ symbol emitted in PIC mode
2123 can be turned into relocations against the .got symbol. */
2124 if (strcmp (p
->name
, ".got") == 0)
2127 return _bfd_elf_link_omit_section_dynsym (output_bfd
, info
, p
);
2130 /* Set the sizes of the dynamic sections. */
2133 _bfd_sparc_elf_size_dynamic_sections (bfd
*output_bfd
,
2134 struct bfd_link_info
*info
)
2136 struct _bfd_sparc_elf_link_hash_table
*htab
;
2141 htab
= _bfd_sparc_elf_hash_table (info
);
2142 dynobj
= htab
->elf
.dynobj
;
2143 BFD_ASSERT (dynobj
!= NULL
);
2145 if (elf_hash_table (info
)->dynamic_sections_created
)
2147 /* Set the contents of the .interp section to the interpreter. */
2148 if (info
->executable
)
2150 s
= bfd_get_section_by_name (dynobj
, ".interp");
2151 BFD_ASSERT (s
!= NULL
);
2152 s
->size
= htab
->dynamic_interpreter_size
;
2153 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
2157 /* Set up .got offsets for local syms, and space for local dynamic
2159 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
2161 bfd_signed_vma
*local_got
;
2162 bfd_signed_vma
*end_local_got
;
2163 char *local_tls_type
;
2164 bfd_size_type locsymcount
;
2165 Elf_Internal_Shdr
*symtab_hdr
;
2168 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
2171 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2173 struct _bfd_sparc_elf_dyn_relocs
*p
;
2175 for (p
= elf_section_data (s
)->local_dynrel
; p
!= NULL
; p
= p
->next
)
2177 if (!bfd_is_abs_section (p
->sec
)
2178 && bfd_is_abs_section (p
->sec
->output_section
))
2180 /* Input section has been discarded, either because
2181 it is a copy of a linkonce section or due to
2182 linker script /DISCARD/, so we'll be discarding
2185 else if (p
->count
!= 0)
2187 srel
= elf_section_data (p
->sec
)->sreloc
;
2188 srel
->size
+= p
->count
* SPARC_ELF_RELA_BYTES (htab
);
2189 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
2190 info
->flags
|= DF_TEXTREL
;
2195 local_got
= elf_local_got_refcounts (ibfd
);
2199 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
2200 locsymcount
= symtab_hdr
->sh_info
;
2201 end_local_got
= local_got
+ locsymcount
;
2202 local_tls_type
= _bfd_sparc_elf_local_got_tls_type (ibfd
);
2204 srel
= htab
->srelgot
;
2205 for (; local_got
< end_local_got
; ++local_got
, ++local_tls_type
)
2209 *local_got
= s
->size
;
2210 s
->size
+= SPARC_ELF_WORD_BYTES (htab
);
2211 if (*local_tls_type
== GOT_TLS_GD
)
2212 s
->size
+= SPARC_ELF_WORD_BYTES (htab
);
2214 || *local_tls_type
== GOT_TLS_GD
2215 || *local_tls_type
== GOT_TLS_IE
)
2216 srel
->size
+= SPARC_ELF_RELA_BYTES (htab
);
2219 *local_got
= (bfd_vma
) -1;
2223 if (htab
->tls_ldm_got
.refcount
> 0)
2225 /* Allocate 2 got entries and 1 dynamic reloc for
2226 R_SPARC_TLS_LDM_{HI22,LO10} relocs. */
2227 htab
->tls_ldm_got
.offset
= htab
->sgot
->size
;
2228 htab
->sgot
->size
+= (2 * SPARC_ELF_WORD_BYTES (htab
));
2229 htab
->srelgot
->size
+= SPARC_ELF_RELA_BYTES (htab
);
2232 htab
->tls_ldm_got
.offset
= -1;
2234 /* Allocate global sym .plt and .got entries, and space for global
2235 sym dynamic relocs. */
2236 elf_link_hash_traverse (&htab
->elf
, allocate_dynrelocs
, (PTR
) info
);
2238 if (! ABI_64_P (output_bfd
)
2239 && !htab
->is_vxworks
2240 && elf_hash_table (info
)->dynamic_sections_created
)
2242 /* Make space for the trailing nop in .plt. */
2243 if (htab
->splt
->size
> 0)
2244 htab
->splt
->size
+= 1 * SPARC_INSN_BYTES
;
2246 /* If the .got section is more than 0x1000 bytes, we add
2247 0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13
2248 bit relocations have a greater chance of working.
2250 FIXME: Make this optimization work for 64-bit too. */
2251 if (htab
->sgot
->size
>= 0x1000
2252 && elf_hash_table (info
)->hgot
->root
.u
.def
.value
== 0)
2253 elf_hash_table (info
)->hgot
->root
.u
.def
.value
= 0x1000;
2256 /* The check_relocs and adjust_dynamic_symbol entry points have
2257 determined the sizes of the various dynamic sections. Allocate
2259 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2261 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2266 || s
== htab
->sdynbss
2267 || s
== htab
->sgotplt
)
2269 /* Strip this section if we don't need it; see the
2272 else if (CONST_STRNEQ (s
->name
, ".rela"))
2276 /* We use the reloc_count field as a counter if we need
2277 to copy relocs into the output file. */
2283 /* It's not one of our sections. */
2289 /* If we don't need this section, strip it from the
2290 output file. This is mostly to handle .rela.bss and
2291 .rela.plt. We must create both sections in
2292 create_dynamic_sections, because they must be created
2293 before the linker maps input sections to output
2294 sections. The linker does that before
2295 adjust_dynamic_symbol is called, and it is that
2296 function which decides whether anything needs to go
2297 into these sections. */
2298 s
->flags
|= SEC_EXCLUDE
;
2302 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
2305 /* Allocate memory for the section contents. Zero the memory
2306 for the benefit of .rela.plt, which has 4 unused entries
2307 at the beginning, and we don't want garbage. */
2308 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
2309 if (s
->contents
== NULL
)
2313 if (elf_hash_table (info
)->dynamic_sections_created
)
2315 /* Add some entries to the .dynamic section. We fill in the
2316 values later, in _bfd_sparc_elf_finish_dynamic_sections, but we
2317 must add the entries now so that we get the correct size for
2318 the .dynamic section. The DT_DEBUG entry is filled in by the
2319 dynamic linker and used by the debugger. */
2320 #define add_dynamic_entry(TAG, VAL) \
2321 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2323 if (info
->executable
)
2325 if (!add_dynamic_entry (DT_DEBUG
, 0))
2329 if (htab
->srelplt
->size
!= 0)
2331 if (!add_dynamic_entry (DT_PLTGOT
, 0)
2332 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
2333 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
2334 || !add_dynamic_entry (DT_JMPREL
, 0))
2338 if (!add_dynamic_entry (DT_RELA
, 0)
2339 || !add_dynamic_entry (DT_RELASZ
, 0)
2340 || !add_dynamic_entry (DT_RELAENT
,
2341 SPARC_ELF_RELA_BYTES (htab
)))
2344 /* If any dynamic relocs apply to a read-only section,
2345 then we need a DT_TEXTREL entry. */
2346 if ((info
->flags
& DF_TEXTREL
) == 0)
2347 elf_link_hash_traverse (&htab
->elf
, readonly_dynrelocs
,
2350 if (info
->flags
& DF_TEXTREL
)
2352 if (!add_dynamic_entry (DT_TEXTREL
, 0))
2356 if (ABI_64_P (output_bfd
))
2359 struct _bfd_sparc_elf_app_reg
* app_regs
;
2360 struct elf_strtab_hash
*dynstr
;
2361 struct elf_link_hash_table
*eht
= elf_hash_table (info
);
2363 /* Add dynamic STT_REGISTER symbols and corresponding DT_SPARC_REGISTER
2364 entries if needed. */
2365 app_regs
= _bfd_sparc_elf_hash_table (info
)->app_regs
;
2366 dynstr
= eht
->dynstr
;
2368 for (reg
= 0; reg
< 4; reg
++)
2369 if (app_regs
[reg
].name
!= NULL
)
2371 struct elf_link_local_dynamic_entry
*entry
, *e
;
2373 if (!add_dynamic_entry (DT_SPARC_REGISTER
, 0))
2376 entry
= (struct elf_link_local_dynamic_entry
*)
2377 bfd_hash_allocate (&info
->hash
->table
, sizeof (*entry
));
2381 /* We cheat here a little bit: the symbol will not be local, so we
2382 put it at the end of the dynlocal linked list. We will fix it
2383 later on, as we have to fix other fields anyway. */
2384 entry
->isym
.st_value
= reg
< 2 ? reg
+ 2 : reg
+ 4;
2385 entry
->isym
.st_size
= 0;
2386 if (*app_regs
[reg
].name
!= '\0')
2388 = _bfd_elf_strtab_add (dynstr
, app_regs
[reg
].name
, FALSE
);
2390 entry
->isym
.st_name
= 0;
2391 entry
->isym
.st_other
= 0;
2392 entry
->isym
.st_info
= ELF_ST_INFO (app_regs
[reg
].bind
,
2394 entry
->isym
.st_shndx
= app_regs
[reg
].shndx
;
2396 entry
->input_bfd
= output_bfd
;
2397 entry
->input_indx
= -1;
2399 if (eht
->dynlocal
== NULL
)
2400 eht
->dynlocal
= entry
;
2403 for (e
= eht
->dynlocal
; e
->next
; e
= e
->next
)
2411 #undef add_dynamic_entry
2417 _bfd_sparc_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
2419 if (!sec
->used_by_bfd
)
2421 struct _bfd_sparc_elf_section_data
*sdata
;
2422 bfd_size_type amt
= sizeof (*sdata
);
2424 sdata
= bfd_zalloc (abfd
, amt
);
2427 sec
->used_by_bfd
= sdata
;
2430 return _bfd_elf_new_section_hook (abfd
, sec
);
2434 _bfd_sparc_elf_relax_section (bfd
*abfd ATTRIBUTE_UNUSED
,
2435 struct bfd_section
*section
,
2436 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
,
2440 sec_do_relax (section
) = 1;
2444 /* Return the base VMA address which should be subtracted from real addresses
2445 when resolving @dtpoff relocation.
2446 This is PT_TLS segment p_vaddr. */
2449 dtpoff_base (struct bfd_link_info
*info
)
2451 /* If tls_sec is NULL, we should have signalled an error already. */
2452 if (elf_hash_table (info
)->tls_sec
== NULL
)
2454 return elf_hash_table (info
)->tls_sec
->vma
;
2457 /* Return the relocation value for @tpoff relocation
2458 if STT_TLS virtual address is ADDRESS. */
2461 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
2463 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2465 /* If tls_sec is NULL, we should have signalled an error already. */
2466 if (htab
->tls_sec
== NULL
)
2468 return address
- htab
->tls_size
- htab
->tls_sec
->vma
;
2471 /* Relocate a SPARC ELF section. */
2474 _bfd_sparc_elf_relocate_section (bfd
*output_bfd
,
2475 struct bfd_link_info
*info
,
2477 asection
*input_section
,
2479 Elf_Internal_Rela
*relocs
,
2480 Elf_Internal_Sym
*local_syms
,
2481 asection
**local_sections
)
2483 struct _bfd_sparc_elf_link_hash_table
*htab
;
2484 Elf_Internal_Shdr
*symtab_hdr
;
2485 struct elf_link_hash_entry
**sym_hashes
;
2486 bfd_vma
*local_got_offsets
;
2489 Elf_Internal_Rela
*rel
;
2490 Elf_Internal_Rela
*relend
;
2493 htab
= _bfd_sparc_elf_hash_table (info
);
2494 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2495 sym_hashes
= elf_sym_hashes (input_bfd
);
2496 local_got_offsets
= elf_local_got_offsets (input_bfd
);
2498 if (elf_hash_table (info
)->hgot
== NULL
)
2501 got_base
= elf_hash_table (info
)->hgot
->root
.u
.def
.value
;
2503 sreloc
= elf_section_data (input_section
)->sreloc
;
2506 if (ABI_64_P (output_bfd
))
2507 num_relocs
= NUM_SHDR_ENTRIES (& elf_section_data (input_section
)->rel_hdr
);
2509 num_relocs
= input_section
->reloc_count
;
2510 relend
= relocs
+ num_relocs
;
2511 for (; rel
< relend
; rel
++)
2513 int r_type
, tls_type
;
2514 reloc_howto_type
*howto
;
2515 unsigned long r_symndx
;
2516 struct elf_link_hash_entry
*h
;
2517 Elf_Internal_Sym
*sym
;
2519 bfd_vma relocation
, off
;
2520 bfd_reloc_status_type r
;
2521 bfd_boolean is_plt
= FALSE
;
2522 bfd_boolean unresolved_reloc
;
2524 r_type
= SPARC_ELF_R_TYPE (rel
->r_info
);
2525 if (r_type
== R_SPARC_GNU_VTINHERIT
2526 || r_type
== R_SPARC_GNU_VTENTRY
)
2529 if (r_type
< 0 || r_type
>= (int) R_SPARC_max_std
)
2531 bfd_set_error (bfd_error_bad_value
);
2534 howto
= _bfd_sparc_elf_howto_table
+ r_type
;
2536 r_symndx
= SPARC_ELF_R_SYMNDX (htab
, rel
->r_info
);
2540 unresolved_reloc
= FALSE
;
2541 if (r_symndx
< symtab_hdr
->sh_info
)
2543 sym
= local_syms
+ r_symndx
;
2544 sec
= local_sections
[r_symndx
];
2545 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
2551 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2552 r_symndx
, symtab_hdr
, sym_hashes
,
2554 unresolved_reloc
, warned
);
2557 /* To avoid generating warning messages about truncated
2558 relocations, set the relocation's address to be the same as
2559 the start of this section. */
2560 if (input_section
->output_section
!= NULL
)
2561 relocation
= input_section
->output_section
->vma
;
2567 if (sec
!= NULL
&& elf_discarded_section (sec
))
2569 /* For relocs against symbols from removed linkonce
2570 sections, or sections discarded by a linker script, we
2571 just want the section contents zeroed. Avoid any
2572 special processing. */
2573 _bfd_clear_contents (howto
, input_bfd
, contents
+ rel
->r_offset
);
2579 if (info
->relocatable
)
2587 /* Relocation is to the entry for this symbol in the global
2589 if (htab
->sgot
== NULL
)
2596 off
= h
->got
.offset
;
2597 BFD_ASSERT (off
!= (bfd_vma
) -1);
2598 dyn
= elf_hash_table (info
)->dynamic_sections_created
;
2600 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
2607 /* This is actually a static link, or it is a
2608 -Bsymbolic link and the symbol is defined
2609 locally, or the symbol was forced to be local
2610 because of a version file. We must initialize
2611 this entry in the global offset table. Since the
2612 offset must always be a multiple of 8 for 64-bit
2613 and 4 for 32-bit, we use the least significant bit
2614 to record whether we have initialized it already.
2616 When doing a dynamic link, we create a .rela.got
2617 relocation entry to initialize the value. This
2618 is done in the finish_dynamic_symbol routine. */
2623 SPARC_ELF_PUT_WORD (htab
, output_bfd
, relocation
,
2624 htab
->sgot
->contents
+ off
);
2629 unresolved_reloc
= FALSE
;
2633 BFD_ASSERT (local_got_offsets
!= NULL
2634 && local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
2636 off
= local_got_offsets
[r_symndx
];
2638 /* The offset must always be a multiple of 8 on 64-bit and
2639 4 on 32-bit. We use the least significant bit to record
2640 whether we have already processed this entry. */
2649 Elf_Internal_Rela outrel
;
2651 /* We need to generate a R_SPARC_RELATIVE reloc
2652 for the dynamic linker. */
2654 BFD_ASSERT (s
!= NULL
);
2656 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
2657 + htab
->sgot
->output_offset
2659 outrel
.r_info
= SPARC_ELF_R_INFO (htab
, NULL
,
2660 0, R_SPARC_RELATIVE
);
2661 outrel
.r_addend
= relocation
;
2663 SPARC_ELF_APPEND_RELA (htab
, output_bfd
, s
, &outrel
);
2666 SPARC_ELF_PUT_WORD (htab
, output_bfd
, relocation
,
2667 htab
->sgot
->contents
+ off
);
2668 local_got_offsets
[r_symndx
] |= 1;
2671 relocation
= htab
->sgot
->output_offset
+ off
- got_base
;
2676 if (h
== NULL
|| h
->plt
.offset
== (bfd_vma
) -1)
2678 r_type
= (r_type
== R_SPARC_PLT32
) ? R_SPARC_32
: R_SPARC_64
;
2683 case R_SPARC_WPLT30
:
2684 case R_SPARC_HIPLT22
:
2685 case R_SPARC_LOPLT10
:
2686 case R_SPARC_PCPLT32
:
2687 case R_SPARC_PCPLT22
:
2688 case R_SPARC_PCPLT10
:
2690 /* Relocation is to the entry for this symbol in the
2691 procedure linkage table. */
2693 if (! ABI_64_P (output_bfd
))
2695 /* The Solaris native assembler will generate a WPLT30 reloc
2696 for a local symbol if you assemble a call from one
2697 section to another when using -K pic. We treat it as
2704 BFD_ASSERT (h
!= NULL
);
2707 if (h
->plt
.offset
== (bfd_vma
) -1 || htab
->splt
== NULL
)
2709 /* We didn't make a PLT entry for this symbol. This
2710 happens when statically linking PIC code, or when
2711 using -Bsymbolic. */
2715 relocation
= (htab
->splt
->output_section
->vma
2716 + htab
->splt
->output_offset
2718 unresolved_reloc
= FALSE
;
2719 if (r_type
== R_SPARC_PLT32
|| r_type
== R_SPARC_PLT64
)
2721 r_type
= r_type
== R_SPARC_PLT32
? R_SPARC_32
: R_SPARC_64
;
2729 case R_SPARC_PC_HH22
:
2730 case R_SPARC_PC_HM10
:
2731 case R_SPARC_PC_LM22
:
2733 && strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
2737 case R_SPARC_DISP16
:
2738 case R_SPARC_DISP32
:
2739 case R_SPARC_DISP64
:
2740 case R_SPARC_WDISP30
:
2741 case R_SPARC_WDISP22
:
2742 case R_SPARC_WDISP19
:
2743 case R_SPARC_WDISP16
:
2770 if ((input_section
->flags
& SEC_ALLOC
) == 0)
2775 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2776 || h
->root
.type
!= bfd_link_hash_undefweak
)
2777 && (! howto
->pc_relative
2780 && (! info
->symbolic
2781 || !h
->def_regular
))))
2788 || h
->root
.type
== bfd_link_hash_undefweak
2789 || h
->root
.type
== bfd_link_hash_undefined
)))
2791 Elf_Internal_Rela outrel
;
2792 bfd_boolean skip
, relocate
= FALSE
;
2794 /* When generating a shared object, these relocations
2795 are copied into the output file to be resolved at run
2798 BFD_ASSERT (sreloc
!= NULL
);
2803 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2805 if (outrel
.r_offset
== (bfd_vma
) -1)
2807 else if (outrel
.r_offset
== (bfd_vma
) -2)
2808 skip
= TRUE
, relocate
= TRUE
;
2809 outrel
.r_offset
+= (input_section
->output_section
->vma
2810 + input_section
->output_offset
);
2812 /* Optimize unaligned reloc usage now that we know where
2813 it finally resides. */
2817 if (outrel
.r_offset
& 1)
2818 r_type
= R_SPARC_UA16
;
2821 if (!(outrel
.r_offset
& 1))
2822 r_type
= R_SPARC_16
;
2825 if (outrel
.r_offset
& 3)
2826 r_type
= R_SPARC_UA32
;
2829 if (!(outrel
.r_offset
& 3))
2830 r_type
= R_SPARC_32
;
2833 if (outrel
.r_offset
& 7)
2834 r_type
= R_SPARC_UA64
;
2837 if (!(outrel
.r_offset
& 7))
2838 r_type
= R_SPARC_64
;
2841 case R_SPARC_DISP16
:
2842 case R_SPARC_DISP32
:
2843 case R_SPARC_DISP64
:
2844 /* If the symbol is not dynamic, we should not keep
2845 a dynamic relocation. But an .rela.* slot has been
2846 allocated for it, output R_SPARC_NONE.
2847 FIXME: Add code tracking needed dynamic relocs as
2849 if (h
->dynindx
== -1)
2850 skip
= TRUE
, relocate
= TRUE
;
2855 memset (&outrel
, 0, sizeof outrel
);
2856 /* h->dynindx may be -1 if the symbol was marked to
2858 else if (h
!= NULL
&& ! is_plt
2859 && ((! info
->symbolic
&& h
->dynindx
!= -1)
2860 || !h
->def_regular
))
2862 BFD_ASSERT (h
->dynindx
!= -1);
2863 outrel
.r_info
= SPARC_ELF_R_INFO (htab
, rel
, h
->dynindx
, r_type
);
2864 outrel
.r_addend
= rel
->r_addend
;
2868 if (r_type
== R_SPARC_32
|| r_type
== R_SPARC_64
)
2870 outrel
.r_info
= SPARC_ELF_R_INFO (htab
, NULL
,
2871 0, R_SPARC_RELATIVE
);
2872 outrel
.r_addend
= relocation
+ rel
->r_addend
;
2878 outrel
.r_addend
= relocation
+ rel
->r_addend
;
2883 if (bfd_is_abs_section (sec
))
2885 else if (sec
== NULL
|| sec
->owner
== NULL
)
2887 bfd_set_error (bfd_error_bad_value
);
2894 /* We are turning this relocation into one
2895 against a section symbol. It would be
2896 proper to subtract the symbol's value,
2897 osec->vma, from the emitted reloc addend,
2898 but ld.so expects buggy relocs. */
2899 osec
= sec
->output_section
;
2900 indx
= elf_section_data (osec
)->dynindx
;
2904 osec
= htab
->elf
.text_index_section
;
2905 indx
= elf_section_data (osec
)->dynindx
;
2908 /* FIXME: we really should be able to link non-pic
2909 shared libraries. */
2913 (*_bfd_error_handler
)
2914 (_("%B: probably compiled without -fPIC?"),
2916 bfd_set_error (bfd_error_bad_value
);
2921 outrel
.r_info
= SPARC_ELF_R_INFO (htab
, rel
, indx
,
2926 SPARC_ELF_APPEND_RELA (htab
, output_bfd
, sreloc
, &outrel
);
2928 /* This reloc will be computed at runtime, so there's no
2929 need to do anything now. */
2935 case R_SPARC_TLS_GD_HI22
:
2936 if (! ABI_64_P (input_bfd
)
2937 && ! _bfd_sparc_elf_tdata (input_bfd
)->has_tlsgd
)
2939 /* R_SPARC_REV32 used the same reloc number as
2940 R_SPARC_TLS_GD_HI22. */
2941 r_type
= R_SPARC_REV32
;
2946 case R_SPARC_TLS_GD_LO10
:
2947 case R_SPARC_TLS_IE_HI22
:
2948 case R_SPARC_TLS_IE_LO10
:
2949 r_type
= sparc_elf_tls_transition (info
, input_bfd
, r_type
, h
== NULL
);
2950 tls_type
= GOT_UNKNOWN
;
2951 if (h
== NULL
&& local_got_offsets
)
2952 tls_type
= _bfd_sparc_elf_local_got_tls_type (input_bfd
) [r_symndx
];
2955 tls_type
= _bfd_sparc_elf_hash_entry(h
)->tls_type
;
2956 if (!info
->shared
&& h
->dynindx
== -1 && tls_type
== GOT_TLS_IE
)
2957 switch (SPARC_ELF_R_TYPE (rel
->r_info
))
2959 case R_SPARC_TLS_GD_HI22
:
2960 case R_SPARC_TLS_IE_HI22
:
2961 r_type
= R_SPARC_TLS_LE_HIX22
;
2964 r_type
= R_SPARC_TLS_LE_LOX10
;
2968 if (tls_type
== GOT_TLS_IE
)
2971 case R_SPARC_TLS_GD_HI22
:
2972 r_type
= R_SPARC_TLS_IE_HI22
;
2974 case R_SPARC_TLS_GD_LO10
:
2975 r_type
= R_SPARC_TLS_IE_LO10
;
2979 if (r_type
== R_SPARC_TLS_LE_HIX22
)
2981 relocation
= tpoff (info
, relocation
);
2984 if (r_type
== R_SPARC_TLS_LE_LOX10
)
2986 /* Change add into xor. */
2987 relocation
= tpoff (info
, relocation
);
2988 bfd_put_32 (output_bfd
, (bfd_get_32 (input_bfd
,
2989 contents
+ rel
->r_offset
)
2990 | 0x80182000), contents
+ rel
->r_offset
);
2996 off
= h
->got
.offset
;
3001 BFD_ASSERT (local_got_offsets
!= NULL
);
3002 off
= local_got_offsets
[r_symndx
];
3003 local_got_offsets
[r_symndx
] |= 1;
3007 if (htab
->sgot
== NULL
)
3014 Elf_Internal_Rela outrel
;
3017 if (htab
->srelgot
== NULL
)
3020 SPARC_ELF_PUT_WORD (htab
, output_bfd
, 0, htab
->sgot
->contents
+ off
);
3021 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
3022 + htab
->sgot
->output_offset
+ off
);
3023 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
3024 if (r_type
== R_SPARC_TLS_IE_HI22
3025 || r_type
== R_SPARC_TLS_IE_LO10
)
3026 dr_type
= SPARC_ELF_TPOFF_RELOC (htab
);
3028 dr_type
= SPARC_ELF_DTPMOD_RELOC (htab
);
3029 if (dr_type
== SPARC_ELF_TPOFF_RELOC (htab
) && indx
== 0)
3030 outrel
.r_addend
= relocation
- dtpoff_base (info
);
3032 outrel
.r_addend
= 0;
3033 outrel
.r_info
= SPARC_ELF_R_INFO (htab
, NULL
, indx
, dr_type
);
3034 SPARC_ELF_APPEND_RELA (htab
, output_bfd
, htab
->srelgot
, &outrel
);
3036 if (r_type
== R_SPARC_TLS_GD_HI22
3037 || r_type
== R_SPARC_TLS_GD_LO10
)
3041 BFD_ASSERT (! unresolved_reloc
);
3042 SPARC_ELF_PUT_WORD (htab
, output_bfd
,
3043 relocation
- dtpoff_base (info
),
3044 (htab
->sgot
->contents
+ off
3045 + SPARC_ELF_WORD_BYTES (htab
)));
3049 SPARC_ELF_PUT_WORD (htab
, output_bfd
, 0,
3050 (htab
->sgot
->contents
+ off
3051 + SPARC_ELF_WORD_BYTES (htab
)));
3052 outrel
.r_info
= SPARC_ELF_R_INFO (htab
, NULL
, indx
,
3053 SPARC_ELF_DTPOFF_RELOC (htab
));
3054 outrel
.r_offset
+= SPARC_ELF_WORD_BYTES (htab
);
3055 SPARC_ELF_APPEND_RELA (htab
, output_bfd
, htab
->srelgot
, &outrel
);
3058 else if (dr_type
== SPARC_ELF_DTPMOD_RELOC (htab
))
3060 SPARC_ELF_PUT_WORD (htab
, output_bfd
, 0,
3061 (htab
->sgot
->contents
+ off
3062 + SPARC_ELF_WORD_BYTES (htab
)));
3066 if (off
>= (bfd_vma
) -2)
3069 relocation
= htab
->sgot
->output_offset
+ off
- got_base
;
3070 unresolved_reloc
= FALSE
;
3071 howto
= _bfd_sparc_elf_howto_table
+ r_type
;
3074 case R_SPARC_TLS_LDM_HI22
:
3075 case R_SPARC_TLS_LDM_LO10
:
3078 bfd_put_32 (output_bfd
, SPARC_NOP
, contents
+ rel
->r_offset
);
3081 off
= htab
->tls_ldm_got
.offset
;
3082 htab
->tls_ldm_got
.offset
|= 1;
3083 goto r_sparc_tlsldm
;
3085 case R_SPARC_TLS_LDO_HIX22
:
3086 case R_SPARC_TLS_LDO_LOX10
:
3089 relocation
-= dtpoff_base (info
);
3093 r_type
= (r_type
== R_SPARC_TLS_LDO_HIX22
3094 ? R_SPARC_TLS_LE_HIX22
: R_SPARC_TLS_LE_LOX10
);
3097 case R_SPARC_TLS_LE_HIX22
:
3098 case R_SPARC_TLS_LE_LOX10
:
3101 Elf_Internal_Rela outrel
;
3102 bfd_boolean skip
, relocate
= FALSE
;
3104 BFD_ASSERT (sreloc
!= NULL
);
3107 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
3109 if (outrel
.r_offset
== (bfd_vma
) -1)
3111 else if (outrel
.r_offset
== (bfd_vma
) -2)
3112 skip
= TRUE
, relocate
= TRUE
;
3113 outrel
.r_offset
+= (input_section
->output_section
->vma
3114 + input_section
->output_offset
);
3116 memset (&outrel
, 0, sizeof outrel
);
3119 outrel
.r_info
= SPARC_ELF_R_INFO (htab
, NULL
, 0, r_type
);
3120 outrel
.r_addend
= relocation
- dtpoff_base (info
)
3124 SPARC_ELF_APPEND_RELA (htab
, output_bfd
, sreloc
, &outrel
);
3127 relocation
= tpoff (info
, relocation
);
3130 case R_SPARC_TLS_LDM_CALL
:
3134 bfd_put_32 (output_bfd
, 0x90100000, contents
+ rel
->r_offset
);
3139 case R_SPARC_TLS_GD_CALL
:
3140 tls_type
= GOT_UNKNOWN
;
3141 if (h
== NULL
&& local_got_offsets
)
3142 tls_type
= _bfd_sparc_elf_local_got_tls_type (input_bfd
) [r_symndx
];
3144 tls_type
= _bfd_sparc_elf_hash_entry(h
)->tls_type
;
3146 || (r_type
== R_SPARC_TLS_GD_CALL
&& tls_type
== GOT_TLS_IE
))
3150 if (!info
->shared
&& (h
== NULL
|| h
->dynindx
== -1))
3153 bfd_put_32 (output_bfd
, SPARC_NOP
, contents
+ rel
->r_offset
);
3158 if (rel
+ 1 < relend
3159 && SPARC_ELF_R_TYPE (rel
[1].r_info
) == R_SPARC_TLS_GD_ADD
3160 && rel
[1].r_offset
== rel
->r_offset
+ 4
3161 && SPARC_ELF_R_SYMNDX (htab
, rel
[1].r_info
) == r_symndx
3162 && (((insn
= bfd_get_32 (input_bfd
,
3163 contents
+ rel
[1].r_offset
))
3164 >> 25) & 0x1f) == 8)
3167 call __tls_get_addr, %tgd_call(foo)
3168 add %reg1, %reg2, %o0, %tgd_add(foo)
3169 and change it into IE:
3170 {ld,ldx} [%reg1 + %reg2], %o0, %tie_ldx(foo)
3171 add %g7, %o0, %o0, %tie_add(foo).
3172 add is 0x80000000 | (rd << 25) | (rs1 << 14) | rs2,
3173 ld is 0xc0000000 | (rd << 25) | (rs1 << 14) | rs2,
3174 ldx is 0xc0580000 | (rd << 25) | (rs1 << 14) | rs2. */
3175 bfd_put_32 (output_bfd
, insn
| (ABI_64_P (output_bfd
) ? 0xc0580000 : 0xc0000000),
3176 contents
+ rel
->r_offset
);
3177 bfd_put_32 (output_bfd
, 0x9001c008,
3178 contents
+ rel
->r_offset
+ 4);
3183 bfd_put_32 (output_bfd
, 0x9001c008, contents
+ rel
->r_offset
);
3187 h
= (struct elf_link_hash_entry
*)
3188 bfd_link_hash_lookup (info
->hash
, "__tls_get_addr", FALSE
,
3190 BFD_ASSERT (h
!= NULL
);
3191 r_type
= R_SPARC_WPLT30
;
3192 howto
= _bfd_sparc_elf_howto_table
+ r_type
;
3193 goto r_sparc_wplt30
;
3195 case R_SPARC_TLS_GD_ADD
:
3196 tls_type
= GOT_UNKNOWN
;
3197 if (h
== NULL
&& local_got_offsets
)
3198 tls_type
= _bfd_sparc_elf_local_got_tls_type (input_bfd
) [r_symndx
];
3200 tls_type
= _bfd_sparc_elf_hash_entry(h
)->tls_type
;
3201 if (! info
->shared
|| tls_type
== GOT_TLS_IE
)
3203 /* add %reg1, %reg2, %reg3, %tgd_add(foo)
3205 {ld,ldx} [%reg1 + %reg2], %reg3, %tie_ldx(foo)
3207 add %g7, %reg2, %reg3. */
3208 bfd_vma insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3209 if ((h
!= NULL
&& h
->dynindx
!= -1) || info
->shared
)
3210 relocation
= insn
| (ABI_64_P (output_bfd
) ? 0xc0580000 : 0xc0000000);
3212 relocation
= (insn
& ~0x7c000) | 0x1c000;
3213 bfd_put_32 (output_bfd
, relocation
, contents
+ rel
->r_offset
);
3217 case R_SPARC_TLS_LDM_ADD
:
3219 bfd_put_32 (output_bfd
, SPARC_NOP
, contents
+ rel
->r_offset
);
3222 case R_SPARC_TLS_LDO_ADD
:
3225 /* Change rs1 into %g7. */
3226 bfd_vma insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3227 insn
= (insn
& ~0x7c000) | 0x1c000;
3228 bfd_put_32 (output_bfd
, insn
, contents
+ rel
->r_offset
);
3232 case R_SPARC_TLS_IE_LD
:
3233 case R_SPARC_TLS_IE_LDX
:
3234 if (! info
->shared
&& (h
== NULL
|| h
->dynindx
== -1))
3236 bfd_vma insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3237 int rs2
= insn
& 0x1f;
3238 int rd
= (insn
>> 25) & 0x1f;
3241 relocation
= SPARC_NOP
;
3243 relocation
= 0x80100000 | (insn
& 0x3e00001f);
3244 bfd_put_32 (output_bfd
, relocation
, contents
+ rel
->r_offset
);
3248 case R_SPARC_TLS_IE_ADD
:
3249 /* Totally useless relocation. */
3252 case R_SPARC_TLS_DTPOFF32
:
3253 case R_SPARC_TLS_DTPOFF64
:
3254 relocation
-= dtpoff_base (info
);
3261 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3262 because such sections are not SEC_ALLOC and thus ld.so will
3263 not process them. */
3264 if (unresolved_reloc
3265 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
3267 (*_bfd_error_handler
)
3268 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3271 (long) rel
->r_offset
,
3273 h
->root
.root
.string
);
3275 r
= bfd_reloc_continue
;
3276 if (r_type
== R_SPARC_OLO10
)
3280 if (! ABI_64_P (output_bfd
))
3283 relocation
+= rel
->r_addend
;
3284 relocation
= (relocation
& 0x3ff) + ELF64_R_TYPE_DATA (rel
->r_info
);
3286 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3287 x
= (x
& ~(bfd_vma
) 0x1fff) | (relocation
& 0x1fff);
3288 bfd_put_32 (input_bfd
, x
, contents
+ rel
->r_offset
);
3290 r
= bfd_check_overflow (howto
->complain_on_overflow
,
3291 howto
->bitsize
, howto
->rightshift
,
3292 bfd_arch_bits_per_address (input_bfd
),
3295 else if (r_type
== R_SPARC_WDISP16
)
3299 relocation
+= rel
->r_addend
;
3300 relocation
-= (input_section
->output_section
->vma
3301 + input_section
->output_offset
);
3302 relocation
-= rel
->r_offset
;
3304 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3305 x
|= ((((relocation
>> 2) & 0xc000) << 6)
3306 | ((relocation
>> 2) & 0x3fff));
3307 bfd_put_32 (input_bfd
, x
, contents
+ rel
->r_offset
);
3309 r
= bfd_check_overflow (howto
->complain_on_overflow
,
3310 howto
->bitsize
, howto
->rightshift
,
3311 bfd_arch_bits_per_address (input_bfd
),
3314 else if (r_type
== R_SPARC_REV32
)
3318 relocation
= relocation
+ rel
->r_addend
;
3320 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3322 bfd_putl32 (/*input_bfd,*/ x
, contents
+ rel
->r_offset
);
3325 else if (r_type
== R_SPARC_TLS_LDO_HIX22
3326 || r_type
== R_SPARC_TLS_LE_HIX22
)
3330 relocation
+= rel
->r_addend
;
3331 if (r_type
== R_SPARC_TLS_LE_HIX22
)
3332 relocation
^= MINUS_ONE
;
3334 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3335 x
= (x
& ~(bfd_vma
) 0x3fffff) | ((relocation
>> 10) & 0x3fffff);
3336 bfd_put_32 (input_bfd
, x
, contents
+ rel
->r_offset
);
3339 else if (r_type
== R_SPARC_TLS_LDO_LOX10
3340 || r_type
== R_SPARC_TLS_LE_LOX10
)
3344 relocation
+= rel
->r_addend
;
3345 relocation
&= 0x3ff;
3346 if (r_type
== R_SPARC_TLS_LE_LOX10
)
3347 relocation
|= 0x1c00;
3349 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3350 x
= (x
& ~(bfd_vma
) 0x1fff) | relocation
;
3351 bfd_put_32 (input_bfd
, x
, contents
+ rel
->r_offset
);
3355 else if (r_type
== R_SPARC_HIX22
)
3359 relocation
+= rel
->r_addend
;
3360 relocation
= relocation
^ MINUS_ONE
;
3362 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3363 x
= (x
& ~(bfd_vma
) 0x3fffff) | ((relocation
>> 10) & 0x3fffff);
3364 bfd_put_32 (input_bfd
, x
, contents
+ rel
->r_offset
);
3366 r
= bfd_check_overflow (howto
->complain_on_overflow
,
3367 howto
->bitsize
, howto
->rightshift
,
3368 bfd_arch_bits_per_address (input_bfd
),
3371 else if (r_type
== R_SPARC_LOX10
)
3375 relocation
+= rel
->r_addend
;
3376 relocation
= (relocation
& 0x3ff) | 0x1c00;
3378 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3379 x
= (x
& ~(bfd_vma
) 0x1fff) | relocation
;
3380 bfd_put_32 (input_bfd
, x
, contents
+ rel
->r_offset
);
3384 else if ((r_type
== R_SPARC_WDISP30
|| r_type
== R_SPARC_WPLT30
)
3385 && sec_do_relax (input_section
)
3386 && rel
->r_offset
+ 4 < input_section
->size
)
3390 #define XCC (2 << 20)
3391 #define COND(x) (((x)&0xf)<<25)
3392 #define CONDA COND(0x8)
3393 #define INSN_BPA (F2(0,1) | CONDA | BPRED | XCC)
3394 #define INSN_BA (F2(0,2) | CONDA)
3395 #define INSN_OR F3(2, 0x2, 0)
3396 #define INSN_NOP F2(0,4)
3400 /* If the instruction is a call with either:
3402 arithmetic instruction with rd == %o7
3403 where rs1 != %o7 and rs2 if it is register != %o7
3404 then we can optimize if the call destination is near
3405 by changing the call into a branch always. */
3406 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3407 y
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
3408 if ((x
& OP(~0)) == OP(1) && (y
& OP(~0)) == OP(2))
3410 if (((y
& OP3(~0)) == OP3(0x3d) /* restore */
3411 || ((y
& OP3(0x28)) == 0 /* arithmetic */
3412 && (y
& RD(~0)) == RD(O7
)))
3413 && (y
& RS1(~0)) != RS1(O7
)
3415 || (y
& RS2(~0)) != RS2(O7
)))
3419 reloc
= relocation
+ rel
->r_addend
- rel
->r_offset
;
3420 reloc
-= (input_section
->output_section
->vma
3421 + input_section
->output_offset
);
3423 /* Ensure the branch fits into simm22. */
3424 if ((reloc
& 3) == 0
3425 && ((reloc
& ~(bfd_vma
)0x7fffff) == 0
3426 || ((reloc
| 0x7fffff) == ~(bfd_vma
)0)))
3430 /* Check whether it fits into simm19. */
3431 if (((reloc
& 0x3c0000) == 0
3432 || (reloc
& 0x3c0000) == 0x3c0000)
3433 && (ABI_64_P (output_bfd
)
3434 || elf_elfheader (output_bfd
)->e_flags
& EF_SPARC_32PLUS
))
3435 x
= INSN_BPA
| (reloc
& 0x7ffff); /* ba,pt %xcc */
3437 x
= INSN_BA
| (reloc
& 0x3fffff); /* ba */
3438 bfd_put_32 (input_bfd
, x
, contents
+ rel
->r_offset
);
3440 if (rel
->r_offset
>= 4
3441 && (y
& (0xffffffff ^ RS1(~0)))
3442 == (INSN_OR
| RD(O7
) | RS2(G0
)))
3447 z
= bfd_get_32 (input_bfd
,
3448 contents
+ rel
->r_offset
- 4);
3449 if ((z
& (0xffffffff ^ RD(~0)))
3450 != (INSN_OR
| RS1(O7
) | RS2(G0
)))
3458 If call foo was replaced with ba, replace
3459 or %rN, %g0, %o7 with nop. */
3461 reg
= (y
& RS1(~0)) >> 14;
3462 if (reg
!= ((z
& RD(~0)) >> 25)
3463 || reg
== G0
|| reg
== O7
)
3466 bfd_put_32 (input_bfd
, (bfd_vma
) INSN_NOP
,
3467 contents
+ rel
->r_offset
+ 4);
3475 if (r
== bfd_reloc_continue
)
3476 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
3477 contents
, rel
->r_offset
,
3478 relocation
, rel
->r_addend
);
3480 if (r
!= bfd_reloc_ok
)
3485 case bfd_reloc_outofrange
:
3487 case bfd_reloc_overflow
:
3491 /* The Solaris native linker silently disregards overflows.
3492 We don't, but this breaks stabs debugging info, whose
3493 relocations are only 32-bits wide. Ignore overflows in
3494 this case and also for discarded entries. */
3495 if ((r_type
== R_SPARC_32
|| r_type
== R_SPARC_DISP32
)
3496 && (((input_section
->flags
& SEC_DEBUGGING
) != 0
3497 && strcmp (bfd_section_name (input_bfd
,
3500 || _bfd_elf_section_offset (output_bfd
, info
,
3508 /* Assume this is a call protected by other code that
3509 detect the symbol is undefined. If this is the case,
3510 we can safely ignore the overflow. If not, the
3511 program is hosed anyway, and a little warning isn't
3513 if (h
->root
.type
== bfd_link_hash_undefweak
3514 && howto
->pc_relative
)
3521 name
= bfd_elf_string_from_elf_section (input_bfd
,
3522 symtab_hdr
->sh_link
,
3527 name
= bfd_section_name (input_bfd
, sec
);
3529 if (! ((*info
->callbacks
->reloc_overflow
)
3530 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
3531 (bfd_vma
) 0, input_bfd
, input_section
,
3543 /* Build a VxWorks PLT entry. PLT_INDEX is the index of the PLT entry
3544 and PLT_OFFSET is the byte offset from the start of .plt. GOT_OFFSET
3545 is the offset of the associated .got.plt entry from
3546 _GLOBAL_OFFSET_TABLE_. */
3549 sparc_vxworks_build_plt_entry (bfd
*output_bfd
, struct bfd_link_info
*info
,
3550 bfd_vma plt_offset
, bfd_vma plt_index
,
3554 const bfd_vma
*plt_entry
;
3555 struct _bfd_sparc_elf_link_hash_table
*htab
;
3557 Elf_Internal_Rela rela
;
3559 htab
= _bfd_sparc_elf_hash_table (info
);
3562 plt_entry
= sparc_vxworks_shared_plt_entry
;
3567 plt_entry
= sparc_vxworks_exec_plt_entry
;
3568 got_base
= (htab
->elf
.hgot
->root
.u
.def
.value
3569 + htab
->elf
.hgot
->root
.u
.def
.section
->output_offset
3570 + htab
->elf
.hgot
->root
.u
.def
.section
->output_section
->vma
);
3573 /* Fill in the entry in the procedure linkage table. */
3574 bfd_put_32 (output_bfd
, plt_entry
[0] + ((got_base
+ got_offset
) >> 10),
3575 htab
->splt
->contents
+ plt_offset
);
3576 bfd_put_32 (output_bfd
, plt_entry
[1] + ((got_base
+ got_offset
) & 0x3ff),
3577 htab
->splt
->contents
+ plt_offset
+ 4);
3578 bfd_put_32 (output_bfd
, plt_entry
[2],
3579 htab
->splt
->contents
+ plt_offset
+ 8);
3580 bfd_put_32 (output_bfd
, plt_entry
[3],
3581 htab
->splt
->contents
+ plt_offset
+ 12);
3582 bfd_put_32 (output_bfd
, plt_entry
[4],
3583 htab
->splt
->contents
+ plt_offset
+ 16);
3584 bfd_put_32 (output_bfd
, plt_entry
[5] + (plt_index
>> 10),
3585 htab
->splt
->contents
+ plt_offset
+ 20);
3586 /* PC-relative displacement for a branch to the start of
3588 bfd_put_32 (output_bfd
, plt_entry
[6] + (((-plt_offset
- 24) >> 2)
3590 htab
->splt
->contents
+ plt_offset
+ 24);
3591 bfd_put_32 (output_bfd
, plt_entry
[7] + (plt_index
& 0x3ff),
3592 htab
->splt
->contents
+ plt_offset
+ 28);
3594 /* Fill in the .got.plt entry, pointing initially at the
3595 second half of the PLT entry. */
3596 BFD_ASSERT (htab
->sgotplt
!= NULL
);
3597 bfd_put_32 (output_bfd
,
3598 htab
->splt
->output_section
->vma
3599 + htab
->splt
->output_offset
3601 htab
->sgotplt
->contents
+ got_offset
);
3603 /* Add relocations to .rela.plt.unloaded. */
3606 loc
= (htab
->srelplt2
->contents
3607 + (2 + 3 * plt_index
) * sizeof (Elf32_External_Rela
));
3609 /* Relocate the initial sethi. */
3610 rela
.r_offset
= (htab
->splt
->output_section
->vma
3611 + htab
->splt
->output_offset
3613 rela
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_SPARC_HI22
);
3614 rela
.r_addend
= got_offset
;
3615 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
3616 loc
+= sizeof (Elf32_External_Rela
);
3618 /* Likewise the following or. */
3620 rela
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_SPARC_LO10
);
3621 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
3622 loc
+= sizeof (Elf32_External_Rela
);
3624 /* Relocate the .got.plt entry. */
3625 rela
.r_offset
= (htab
->sgotplt
->output_section
->vma
3626 + htab
->sgotplt
->output_offset
3628 rela
.r_info
= ELF32_R_INFO (htab
->elf
.hplt
->indx
, R_SPARC_32
);
3629 rela
.r_addend
= plt_offset
+ 20;
3630 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
3634 /* Finish up dynamic symbol handling. We set the contents of various
3635 dynamic sections here. */
3638 _bfd_sparc_elf_finish_dynamic_symbol (bfd
*output_bfd
,
3639 struct bfd_link_info
*info
,
3640 struct elf_link_hash_entry
*h
,
3641 Elf_Internal_Sym
*sym
)
3644 struct _bfd_sparc_elf_link_hash_table
*htab
;
3646 htab
= _bfd_sparc_elf_hash_table (info
);
3647 dynobj
= htab
->elf
.dynobj
;
3649 if (h
->plt
.offset
!= (bfd_vma
) -1)
3653 Elf_Internal_Rela rela
;
3655 bfd_vma r_offset
, got_offset
;
3658 /* This symbol has an entry in the PLT. Set it up. */
3660 BFD_ASSERT (h
->dynindx
!= -1);
3663 srela
= htab
->srelplt
;
3664 BFD_ASSERT (splt
!= NULL
&& srela
!= NULL
);
3666 /* Fill in the entry in the .rela.plt section. */
3667 if (htab
->is_vxworks
)
3669 /* Work out the index of this PLT entry. */
3670 rela_index
= ((h
->plt
.offset
- htab
->plt_header_size
)
3671 / htab
->plt_entry_size
);
3673 /* Calculate the offset of the associated .got.plt entry.
3674 The first three entries are reserved. */
3675 got_offset
= (rela_index
+ 3) * 4;
3677 sparc_vxworks_build_plt_entry (output_bfd
, info
, h
->plt
.offset
,
3678 rela_index
, got_offset
);
3681 /* On VxWorks, the relocation points to the .got.plt entry,
3682 not the .plt entry. */
3683 rela
.r_offset
= (htab
->sgotplt
->output_section
->vma
3684 + htab
->sgotplt
->output_offset
3690 /* Fill in the entry in the procedure linkage table. */
3691 rela_index
= SPARC_ELF_BUILD_PLT_ENTRY (htab
, output_bfd
, splt
,
3692 h
->plt
.offset
, splt
->size
,
3695 rela
.r_offset
= r_offset
3696 + (splt
->output_section
->vma
+ splt
->output_offset
);
3697 if (! ABI_64_P (output_bfd
)
3698 || h
->plt
.offset
< (PLT64_LARGE_THRESHOLD
* PLT64_ENTRY_SIZE
))
3704 rela
.r_addend
= (-(h
->plt
.offset
+ 4)
3705 - splt
->output_section
->vma
3706 - splt
->output_offset
);
3709 rela
.r_info
= SPARC_ELF_R_INFO (htab
, NULL
, h
->dynindx
, R_SPARC_JMP_SLOT
);
3711 /* Adjust for the first 4 reserved elements in the .plt section
3712 when setting the offset in the .rela.plt section.
3713 Sun forgot to read their own ABI and copied elf32-sparc behaviour,
3714 thus .plt[4] has corresponding .rela.plt[0] and so on. */
3716 loc
= srela
->contents
;
3718 if (ABI_64_P (output_bfd
))
3720 loc
+= rela_index
* sizeof (Elf64_External_Rela
);
3721 bfd_elf64_swap_reloca_out (output_bfd
, &rela
, loc
);
3726 loc
+= rela_index
* sizeof (Elf32_External_Rela
);
3727 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
3730 if (!h
->def_regular
)
3732 /* Mark the symbol as undefined, rather than as defined in
3733 the .plt section. Leave the value alone. */
3734 sym
->st_shndx
= SHN_UNDEF
;
3735 /* If the symbol is weak, we do need to clear the value.
3736 Otherwise, the PLT entry would provide a definition for
3737 the symbol even if the symbol wasn't defined anywhere,
3738 and so the symbol would never be NULL. */
3739 if (!h
->ref_regular_nonweak
)
3744 if (h
->got
.offset
!= (bfd_vma
) -1
3745 && _bfd_sparc_elf_hash_entry(h
)->tls_type
!= GOT_TLS_GD
3746 && _bfd_sparc_elf_hash_entry(h
)->tls_type
!= GOT_TLS_IE
)
3750 Elf_Internal_Rela rela
;
3752 /* This symbol has an entry in the GOT. Set it up. */
3755 srela
= htab
->srelgot
;
3756 BFD_ASSERT (sgot
!= NULL
&& srela
!= NULL
);
3758 rela
.r_offset
= (sgot
->output_section
->vma
3759 + sgot
->output_offset
3760 + (h
->got
.offset
&~ (bfd_vma
) 1));
3762 /* If this is a -Bsymbolic link, and the symbol is defined
3763 locally, we just want to emit a RELATIVE reloc. Likewise if
3764 the symbol was forced to be local because of a version file.
3765 The entry in the global offset table will already have been
3766 initialized in the relocate_section function. */
3768 && (info
->symbolic
|| h
->dynindx
== -1)
3771 asection
*sec
= h
->root
.u
.def
.section
;
3772 rela
.r_info
= SPARC_ELF_R_INFO (htab
, NULL
, 0, R_SPARC_RELATIVE
);
3773 rela
.r_addend
= (h
->root
.u
.def
.value
3774 + sec
->output_section
->vma
3775 + sec
->output_offset
);
3779 rela
.r_info
= SPARC_ELF_R_INFO (htab
, NULL
, h
->dynindx
, R_SPARC_GLOB_DAT
);
3783 SPARC_ELF_PUT_WORD (htab
, output_bfd
, 0,
3784 sgot
->contents
+ (h
->got
.offset
& ~(bfd_vma
) 1));
3785 SPARC_ELF_APPEND_RELA (htab
, output_bfd
, srela
, &rela
);
3791 Elf_Internal_Rela rela
;
3793 /* This symbols needs a copy reloc. Set it up. */
3794 BFD_ASSERT (h
->dynindx
!= -1);
3796 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
3798 BFD_ASSERT (s
!= NULL
);
3800 rela
.r_offset
= (h
->root
.u
.def
.value
3801 + h
->root
.u
.def
.section
->output_section
->vma
3802 + h
->root
.u
.def
.section
->output_offset
);
3803 rela
.r_info
= SPARC_ELF_R_INFO (htab
, NULL
, h
->dynindx
, R_SPARC_COPY
);
3805 SPARC_ELF_APPEND_RELA (htab
, output_bfd
, s
, &rela
);
3808 /* Mark some specially defined symbols as absolute. On VxWorks,
3809 _GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the
3810 ".got" section. Likewise _PROCEDURE_LINKAGE_TABLE_ and ".plt". */
3811 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
3812 || (!htab
->is_vxworks
3813 && (h
== htab
->elf
.hgot
|| h
== htab
->elf
.hplt
)))
3814 sym
->st_shndx
= SHN_ABS
;
3819 /* Finish up the dynamic sections. */
3823 sparc64_finish_dyn (bfd
*output_bfd
, struct bfd_link_info
*info
,
3824 bfd
*dynobj
, asection
*sdyn
,
3825 asection
*splt ATTRIBUTE_UNUSED
)
3827 Elf64_External_Dyn
*dyncon
, *dynconend
;
3828 int stt_regidx
= -1;
3830 dyncon
= (Elf64_External_Dyn
*) sdyn
->contents
;
3831 dynconend
= (Elf64_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
3832 for (; dyncon
< dynconend
; dyncon
++)
3834 Elf_Internal_Dyn dyn
;
3838 bfd_elf64_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3842 case DT_PLTGOT
: name
= ".plt"; size
= FALSE
; break;
3843 case DT_PLTRELSZ
: name
= ".rela.plt"; size
= TRUE
; break;
3844 case DT_JMPREL
: name
= ".rela.plt"; size
= FALSE
; break;
3845 case DT_SPARC_REGISTER
:
3846 if (stt_regidx
== -1)
3849 _bfd_elf_link_lookup_local_dynindx (info
, output_bfd
, -1);
3850 if (stt_regidx
== -1)
3853 dyn
.d_un
.d_val
= stt_regidx
++;
3854 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3856 default: name
= NULL
; size
= FALSE
; break;
3863 s
= bfd_get_section_by_name (output_bfd
, name
);
3869 dyn
.d_un
.d_ptr
= s
->vma
;
3871 dyn
.d_un
.d_val
= s
->size
;
3873 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3881 sparc32_finish_dyn (bfd
*output_bfd
, struct bfd_link_info
*info
,
3882 bfd
*dynobj
, asection
*sdyn
,
3883 asection
*splt ATTRIBUTE_UNUSED
)
3885 Elf32_External_Dyn
*dyncon
, *dynconend
;
3886 struct _bfd_sparc_elf_link_hash_table
*htab
;
3888 htab
= _bfd_sparc_elf_hash_table (info
);
3889 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3890 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
3891 for (; dyncon
< dynconend
; dyncon
++)
3893 Elf_Internal_Dyn dyn
;
3897 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3899 if (htab
->is_vxworks
&& dyn
.d_tag
== DT_RELASZ
)
3901 /* On VxWorks, DT_RELASZ should not include the relocations
3905 dyn
.d_un
.d_val
-= htab
->srelplt
->size
;
3906 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3909 else if (htab
->is_vxworks
&& dyn
.d_tag
== DT_PLTGOT
)
3911 /* On VxWorks, DT_PLTGOT should point to the start of the GOT,
3912 not to the start of the PLT. */
3915 dyn
.d_un
.d_val
= (htab
->sgotplt
->output_section
->vma
3916 + htab
->sgotplt
->output_offset
);
3917 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3924 case DT_PLTGOT
: name
= ".plt"; size
= FALSE
; break;
3925 case DT_PLTRELSZ
: name
= ".rela.plt"; size
= TRUE
; break;
3926 case DT_JMPREL
: name
= ".rela.plt"; size
= FALSE
; break;
3927 default: name
= NULL
; size
= FALSE
; break;
3934 s
= bfd_get_section_by_name (output_bfd
, name
);
3940 dyn
.d_un
.d_ptr
= s
->vma
;
3942 dyn
.d_un
.d_val
= s
->size
;
3944 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3951 /* Install the first PLT entry in a VxWorks executable and make sure that
3952 .rela.plt.unloaded relocations have the correct symbol indexes. */
3955 sparc_vxworks_finish_exec_plt (bfd
*output_bfd
, struct bfd_link_info
*info
)
3957 struct _bfd_sparc_elf_link_hash_table
*htab
;
3958 Elf_Internal_Rela rela
;
3962 htab
= _bfd_sparc_elf_hash_table (info
);
3964 /* Calculate the absolute value of _GLOBAL_OFFSET_TABLE_. */
3965 got_base
= (htab
->elf
.hgot
->root
.u
.def
.section
->output_section
->vma
3966 + htab
->elf
.hgot
->root
.u
.def
.section
->output_offset
3967 + htab
->elf
.hgot
->root
.u
.def
.value
);
3969 /* Install the initial PLT entry. */
3970 bfd_put_32 (output_bfd
,
3971 sparc_vxworks_exec_plt0_entry
[0] + ((got_base
+ 8) >> 10),
3972 htab
->splt
->contents
);
3973 bfd_put_32 (output_bfd
,
3974 sparc_vxworks_exec_plt0_entry
[1] + ((got_base
+ 8) & 0x3ff),
3975 htab
->splt
->contents
+ 4);
3976 bfd_put_32 (output_bfd
,
3977 sparc_vxworks_exec_plt0_entry
[2],
3978 htab
->splt
->contents
+ 8);
3979 bfd_put_32 (output_bfd
,
3980 sparc_vxworks_exec_plt0_entry
[3],
3981 htab
->splt
->contents
+ 12);
3982 bfd_put_32 (output_bfd
,
3983 sparc_vxworks_exec_plt0_entry
[4],
3984 htab
->splt
->contents
+ 16);
3986 loc
= htab
->srelplt2
->contents
;
3988 /* Add an unloaded relocation for the initial entry's "sethi". */
3989 rela
.r_offset
= (htab
->splt
->output_section
->vma
3990 + htab
->splt
->output_offset
);
3991 rela
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_SPARC_HI22
);
3993 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
3994 loc
+= sizeof (Elf32_External_Rela
);
3996 /* Likewise the following "or". */
3998 rela
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_SPARC_LO10
);
3999 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
4000 loc
+= sizeof (Elf32_External_Rela
);
4002 /* Fix up the remaining .rela.plt.unloaded relocations. They may have
4003 the wrong symbol index for _G_O_T_ or _P_L_T_ depending on the order
4004 in which symbols were output. */
4005 while (loc
< htab
->srelplt2
->contents
+ htab
->srelplt2
->size
)
4007 Elf_Internal_Rela rel
;
4009 /* The entry's initial "sethi" (against _G_O_T_). */
4010 bfd_elf32_swap_reloc_in (output_bfd
, loc
, &rel
);
4011 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_SPARC_HI22
);
4012 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
4013 loc
+= sizeof (Elf32_External_Rela
);
4015 /* The following "or" (also against _G_O_T_). */
4016 bfd_elf32_swap_reloc_in (output_bfd
, loc
, &rel
);
4017 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hgot
->indx
, R_SPARC_LO10
);
4018 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
4019 loc
+= sizeof (Elf32_External_Rela
);
4021 /* The .got.plt entry (against _P_L_T_). */
4022 bfd_elf32_swap_reloc_in (output_bfd
, loc
, &rel
);
4023 rel
.r_info
= ELF32_R_INFO (htab
->elf
.hplt
->indx
, R_SPARC_32
);
4024 bfd_elf32_swap_reloc_out (output_bfd
, &rel
, loc
);
4025 loc
+= sizeof (Elf32_External_Rela
);
4029 /* Install the first PLT entry in a VxWorks shared object. */
4032 sparc_vxworks_finish_shared_plt (bfd
*output_bfd
, struct bfd_link_info
*info
)
4034 struct _bfd_sparc_elf_link_hash_table
*htab
;
4037 htab
= _bfd_sparc_elf_hash_table (info
);
4038 for (i
= 0; i
< ARRAY_SIZE (sparc_vxworks_shared_plt0_entry
); i
++)
4039 bfd_put_32 (output_bfd
, sparc_vxworks_shared_plt0_entry
[i
],
4040 htab
->splt
->contents
+ i
* 4);
4044 _bfd_sparc_elf_finish_dynamic_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
4048 struct _bfd_sparc_elf_link_hash_table
*htab
;
4050 htab
= _bfd_sparc_elf_hash_table (info
);
4051 dynobj
= htab
->elf
.dynobj
;
4053 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
4055 if (elf_hash_table (info
)->dynamic_sections_created
)
4060 splt
= bfd_get_section_by_name (dynobj
, ".plt");
4061 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
4064 if (ABI_64_P (output_bfd
))
4065 ret
= sparc64_finish_dyn (output_bfd
, info
, dynobj
, sdyn
, splt
);
4068 ret
= sparc32_finish_dyn (output_bfd
, info
, dynobj
, sdyn
, splt
);
4073 /* Initialize the contents of the .plt section. */
4076 if (htab
->is_vxworks
)
4079 sparc_vxworks_finish_shared_plt (output_bfd
, info
);
4081 sparc_vxworks_finish_exec_plt (output_bfd
, info
);
4085 memset (splt
->contents
, 0, htab
->plt_header_size
);
4086 if (!ABI_64_P (output_bfd
))
4087 bfd_put_32 (output_bfd
, (bfd_vma
) SPARC_NOP
,
4088 splt
->contents
+ splt
->size
- 4);
4092 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
4093 = (htab
->is_vxworks
|| !ABI_64_P (output_bfd
))
4094 ? 0 : htab
->plt_entry_size
;
4097 /* Set the first entry in the global offset table to the address of
4098 the dynamic section. */
4099 if (htab
->sgot
&& htab
->sgot
->size
> 0)
4101 bfd_vma val
= (sdyn
?
4102 sdyn
->output_section
->vma
+ sdyn
->output_offset
:
4105 SPARC_ELF_PUT_WORD (htab
, output_bfd
, val
, htab
->sgot
->contents
);
4109 elf_section_data (htab
->sgot
->output_section
)->this_hdr
.sh_entsize
=
4110 SPARC_ELF_WORD_BYTES (htab
);
4116 /* Set the right machine number for a SPARC ELF file. */
4119 _bfd_sparc_elf_object_p (bfd
*abfd
)
4121 if (ABI_64_P (abfd
))
4123 unsigned long mach
= bfd_mach_sparc_v9
;
4125 if (elf_elfheader (abfd
)->e_flags
& EF_SPARC_SUN_US3
)
4126 mach
= bfd_mach_sparc_v9b
;
4127 else if (elf_elfheader (abfd
)->e_flags
& EF_SPARC_SUN_US1
)
4128 mach
= bfd_mach_sparc_v9a
;
4129 return bfd_default_set_arch_mach (abfd
, bfd_arch_sparc
, mach
);
4133 if (elf_elfheader (abfd
)->e_machine
== EM_SPARC32PLUS
)
4135 if (elf_elfheader (abfd
)->e_flags
& EF_SPARC_SUN_US3
)
4136 return bfd_default_set_arch_mach (abfd
, bfd_arch_sparc
,
4137 bfd_mach_sparc_v8plusb
);
4138 else if (elf_elfheader (abfd
)->e_flags
& EF_SPARC_SUN_US1
)
4139 return bfd_default_set_arch_mach (abfd
, bfd_arch_sparc
,
4140 bfd_mach_sparc_v8plusa
);
4141 else if (elf_elfheader (abfd
)->e_flags
& EF_SPARC_32PLUS
)
4142 return bfd_default_set_arch_mach (abfd
, bfd_arch_sparc
,
4143 bfd_mach_sparc_v8plus
);
4147 else if (elf_elfheader (abfd
)->e_flags
& EF_SPARC_LEDATA
)
4148 return bfd_default_set_arch_mach (abfd
, bfd_arch_sparc
,
4149 bfd_mach_sparc_sparclite_le
);
4151 return bfd_default_set_arch_mach (abfd
, bfd_arch_sparc
, bfd_mach_sparc
);
4155 /* Return address for Ith PLT stub in section PLT, for relocation REL
4156 or (bfd_vma) -1 if it should not be included. */
4159 _bfd_sparc_elf_plt_sym_val (bfd_vma i
, const asection
*plt
, const arelent
*rel
)
4161 if (ABI_64_P (plt
->owner
))
4165 i
+= PLT64_HEADER_SIZE
/ PLT64_ENTRY_SIZE
;
4166 if (i
< PLT64_LARGE_THRESHOLD
)
4167 return plt
->vma
+ i
* PLT64_ENTRY_SIZE
;
4169 j
= (i
- PLT64_LARGE_THRESHOLD
) % 160;
4171 return plt
->vma
+ i
* PLT64_ENTRY_SIZE
+ j
* 4 * 6;
4174 return rel
->address
;