1 /* SPARC-specific support for 32-bit ELF
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
3 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
26 #include "elf/sparc.h"
27 #include "opcode/sparc.h"
29 static reloc_howto_type
*elf32_sparc_reloc_type_lookup
30 PARAMS ((bfd
*, bfd_reloc_code_real_type
));
31 static void elf32_sparc_info_to_howto
32 PARAMS ((bfd
*, arelent
*, Elf_Internal_Rela
*));
33 static boolean elf32_sparc_check_relocs
34 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
35 const Elf_Internal_Rela
*));
36 static boolean elf32_sparc_adjust_dynamic_symbol
37 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
38 static boolean elf32_sparc_size_dynamic_sections
39 PARAMS ((bfd
*, struct bfd_link_info
*));
40 static boolean elf32_sparc_relax_section
41 PARAMS ((bfd
*, asection
*, struct bfd_link_info
*, boolean
*));
42 static boolean elf32_sparc_relocate_section
43 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
44 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**));
45 static boolean elf32_sparc_finish_dynamic_symbol
46 PARAMS ((bfd
*, struct bfd_link_info
*, struct elf_link_hash_entry
*,
48 static boolean elf32_sparc_finish_dynamic_sections
49 PARAMS ((bfd
*, struct bfd_link_info
*));
50 static boolean elf32_sparc_merge_private_bfd_data
PARAMS ((bfd
*, bfd
*));
51 static boolean elf32_sparc_object_p
53 static void elf32_sparc_final_write_processing
54 PARAMS ((bfd
*, boolean
));
55 static enum elf_reloc_type_class elf32_sparc_reloc_type_class
56 PARAMS ((const Elf_Internal_Rela
*));
57 static asection
* elf32_sparc_gc_mark_hook
58 PARAMS ((bfd
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
59 struct elf_link_hash_entry
*, Elf_Internal_Sym
*));
60 static boolean elf32_sparc_gc_sweep_hook
61 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
62 const Elf_Internal_Rela
*));
64 /* The relocation "howto" table. */
66 static bfd_reloc_status_type sparc_elf_notsupported_reloc
67 PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
68 static bfd_reloc_status_type sparc_elf_wdisp16_reloc
69 PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
71 reloc_howto_type _bfd_sparc_elf_howto_table
[] =
73 HOWTO(R_SPARC_NONE
, 0,0, 0,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_NONE", false,0,0x00000000,true),
74 HOWTO(R_SPARC_8
, 0,0, 8,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_8", false,0,0x000000ff,true),
75 HOWTO(R_SPARC_16
, 0,1,16,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_16", false,0,0x0000ffff,true),
76 HOWTO(R_SPARC_32
, 0,2,32,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_32", false,0,0xffffffff,true),
77 HOWTO(R_SPARC_DISP8
, 0,0, 8,true, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_DISP8", false,0,0x000000ff,true),
78 HOWTO(R_SPARC_DISP16
, 0,1,16,true, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_DISP16", false,0,0x0000ffff,true),
79 HOWTO(R_SPARC_DISP32
, 0,2,32,true, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_DISP32", false,0,0x00ffffff,true),
80 HOWTO(R_SPARC_WDISP30
, 2,2,30,true, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_WDISP30", false,0,0x3fffffff,true),
81 HOWTO(R_SPARC_WDISP22
, 2,2,22,true, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_WDISP22", false,0,0x003fffff,true),
82 HOWTO(R_SPARC_HI22
, 10,2,22,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_HI22", false,0,0x003fffff,true),
83 HOWTO(R_SPARC_22
, 0,2,22,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_22", false,0,0x003fffff,true),
84 HOWTO(R_SPARC_13
, 0,2,13,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_13", false,0,0x00001fff,true),
85 HOWTO(R_SPARC_LO10
, 0,2,10,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_LO10", false,0,0x000003ff,true),
86 HOWTO(R_SPARC_GOT10
, 0,2,10,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_GOT10", false,0,0x000003ff,true),
87 HOWTO(R_SPARC_GOT13
, 0,2,13,false,0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_GOT13", false,0,0x00001fff,true),
88 HOWTO(R_SPARC_GOT22
, 10,2,22,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_GOT22", false,0,0x003fffff,true),
89 HOWTO(R_SPARC_PC10
, 0,2,10,true, 0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_PC10", false,0,0x000003ff,true),
90 HOWTO(R_SPARC_PC22
, 10,2,22,true, 0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_PC22", false,0,0x003fffff,true),
91 HOWTO(R_SPARC_WPLT30
, 2,2,30,true, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_WPLT30", false,0,0x3fffffff,true),
92 HOWTO(R_SPARC_COPY
, 0,0,00,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_COPY", false,0,0x00000000,true),
93 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),
94 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),
95 HOWTO(R_SPARC_RELATIVE
, 0,0,00,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_RELATIVE",false,0,0x00000000,true),
96 HOWTO(R_SPARC_UA32
, 0,2,32,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_UA32", false,0,0xffffffff,true),
97 HOWTO(R_SPARC_PLT32
, 0,0,00,false,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_PLT32", false,0,0x00000000,true),
98 HOWTO(R_SPARC_HIPLT22
, 0,0,00,false,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_HIPLT22", false,0,0x00000000,true),
99 HOWTO(R_SPARC_LOPLT10
, 0,0,00,false,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_LOPLT10", false,0,0x00000000,true),
100 HOWTO(R_SPARC_PCPLT32
, 0,0,00,false,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_PCPLT32", false,0,0x00000000,true),
101 HOWTO(R_SPARC_PCPLT22
, 0,0,00,false,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_PCPLT22", false,0,0x00000000,true),
102 HOWTO(R_SPARC_PCPLT10
, 0,0,00,false,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_PCPLT10", false,0,0x00000000,true),
103 HOWTO(R_SPARC_10
, 0,2,10,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_10", false,0,0x000003ff,true),
104 HOWTO(R_SPARC_11
, 0,2,11,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_11", false,0,0x000007ff,true),
105 /* These are for sparc64 in a 64 bit environment.
106 Values need to be here because the table is indexed by reloc number. */
107 HOWTO(R_SPARC_64
, 0,0,00,false,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_64", false,0,0x00000000,true),
108 HOWTO(R_SPARC_OLO10
, 0,0,00,false,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_OLO10", false,0,0x00000000,true),
109 HOWTO(R_SPARC_HH22
, 0,0,00,false,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_HH22", false,0,0x00000000,true),
110 HOWTO(R_SPARC_HM10
, 0,0,00,false,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_HM10", false,0,0x00000000,true),
111 HOWTO(R_SPARC_LM22
, 0,0,00,false,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_LM22", false,0,0x00000000,true),
112 HOWTO(R_SPARC_PC_HH22
, 0,0,00,false,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_PC_HH22", false,0,0x00000000,true),
113 HOWTO(R_SPARC_PC_HM10
, 0,0,00,false,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_PC_HM10", false,0,0x00000000,true),
114 HOWTO(R_SPARC_PC_LM22
, 0,0,00,false,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_PC_LM22", false,0,0x00000000,true),
115 /* End sparc64 in 64 bit environment values.
116 The following are for sparc64 in a 32 bit environment. */
117 HOWTO(R_SPARC_WDISP16
, 2,2,16,true, 0,complain_overflow_signed
, sparc_elf_wdisp16_reloc
,"R_SPARC_WDISP16", false,0,0x00000000,true),
118 HOWTO(R_SPARC_WDISP19
, 2,2,19,true, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_WDISP19", false,0,0x0007ffff,true),
119 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),
120 HOWTO(R_SPARC_7
, 0,2, 7,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_7", false,0,0x0000007f,true),
121 HOWTO(R_SPARC_5
, 0,2, 5,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_5", false,0,0x0000001f,true),
122 HOWTO(R_SPARC_6
, 0,2, 6,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_6", false,0,0x0000003f,true),
123 HOWTO(R_SPARC_NONE
, 0,0, 0,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_NONE", false,0,0x00000000,true),
124 HOWTO(R_SPARC_NONE
, 0,0, 0,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_NONE", false,0,0x00000000,true),
125 HOWTO(R_SPARC_NONE
, 0,0, 0,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_NONE", false,0,0x00000000,true),
126 HOWTO(R_SPARC_NONE
, 0,0, 0,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_NONE", false,0,0x00000000,true),
127 HOWTO(R_SPARC_NONE
, 0,0, 0,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_NONE", false,0,0x00000000,true),
128 HOWTO(R_SPARC_NONE
, 0,0, 0,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_NONE", false,0,0x00000000,true),
129 HOWTO(R_SPARC_NONE
, 0,0, 0,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_NONE", false,0,0x00000000,true),
130 HOWTO(R_SPARC_NONE
, 0,0, 0,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_NONE", false,0,0x00000000,true),
131 HOWTO(R_SPARC_UA64
, 0,0, 0,false,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_UA64", false,0,0x00000000,true),
132 HOWTO(R_SPARC_UA16
, 0,1,16,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_UA16", false,0,0x0000ffff,true),
133 HOWTO(R_SPARC_REV32
, 0,2,32,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_REV32", false,0,0xffffffff,true),
135 static reloc_howto_type elf32_sparc_vtinherit_howto
=
136 HOWTO (R_SPARC_GNU_VTINHERIT
, 0,2,0,false,0,complain_overflow_dont
, NULL
, "R_SPARC_GNU_VTINHERIT", false,0, 0, false);
137 static reloc_howto_type elf32_sparc_vtentry_howto
=
138 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);
140 struct elf_reloc_map
{
141 bfd_reloc_code_real_type bfd_reloc_val
;
142 unsigned char elf_reloc_val
;
145 static const struct elf_reloc_map sparc_reloc_map
[] =
147 { BFD_RELOC_NONE
, R_SPARC_NONE
, },
148 { BFD_RELOC_16
, R_SPARC_16
, },
149 { BFD_RELOC_8
, R_SPARC_8
},
150 { BFD_RELOC_8_PCREL
, R_SPARC_DISP8
},
151 { BFD_RELOC_CTOR
, R_SPARC_32
},
152 { BFD_RELOC_32
, R_SPARC_32
},
153 { BFD_RELOC_32_PCREL
, R_SPARC_DISP32
},
154 { BFD_RELOC_HI22
, R_SPARC_HI22
},
155 { BFD_RELOC_LO10
, R_SPARC_LO10
, },
156 { BFD_RELOC_32_PCREL_S2
, R_SPARC_WDISP30
},
157 { BFD_RELOC_SPARC22
, R_SPARC_22
},
158 { BFD_RELOC_SPARC13
, R_SPARC_13
},
159 { BFD_RELOC_SPARC_GOT10
, R_SPARC_GOT10
},
160 { BFD_RELOC_SPARC_GOT13
, R_SPARC_GOT13
},
161 { BFD_RELOC_SPARC_GOT22
, R_SPARC_GOT22
},
162 { BFD_RELOC_SPARC_PC10
, R_SPARC_PC10
},
163 { BFD_RELOC_SPARC_PC22
, R_SPARC_PC22
},
164 { BFD_RELOC_SPARC_WPLT30
, R_SPARC_WPLT30
},
165 { BFD_RELOC_SPARC_COPY
, R_SPARC_COPY
},
166 { BFD_RELOC_SPARC_GLOB_DAT
, R_SPARC_GLOB_DAT
},
167 { BFD_RELOC_SPARC_JMP_SLOT
, R_SPARC_JMP_SLOT
},
168 { BFD_RELOC_SPARC_RELATIVE
, R_SPARC_RELATIVE
},
169 { BFD_RELOC_SPARC_WDISP22
, R_SPARC_WDISP22
},
170 { BFD_RELOC_SPARC_UA16
, R_SPARC_UA16
},
171 { BFD_RELOC_SPARC_UA32
, R_SPARC_UA32
},
172 { BFD_RELOC_SPARC_UA64
, R_SPARC_UA64
},
173 { BFD_RELOC_SPARC_10
, R_SPARC_10
},
174 { BFD_RELOC_SPARC_11
, R_SPARC_11
},
175 { BFD_RELOC_SPARC_64
, R_SPARC_64
},
176 { BFD_RELOC_SPARC_OLO10
, R_SPARC_OLO10
},
177 { BFD_RELOC_SPARC_HH22
, R_SPARC_HH22
},
178 { BFD_RELOC_SPARC_HM10
, R_SPARC_HM10
},
179 { BFD_RELOC_SPARC_LM22
, R_SPARC_LM22
},
180 { BFD_RELOC_SPARC_PC_HH22
, R_SPARC_PC_HH22
},
181 { BFD_RELOC_SPARC_PC_HM10
, R_SPARC_PC_HM10
},
182 { BFD_RELOC_SPARC_PC_LM22
, R_SPARC_PC_LM22
},
183 { BFD_RELOC_SPARC_WDISP16
, R_SPARC_WDISP16
},
184 { BFD_RELOC_SPARC_WDISP19
, R_SPARC_WDISP19
},
185 { BFD_RELOC_SPARC_7
, R_SPARC_7
},
186 { BFD_RELOC_SPARC_5
, R_SPARC_5
},
187 { BFD_RELOC_SPARC_6
, R_SPARC_6
},
188 { BFD_RELOC_SPARC_REV32
, R_SPARC_REV32
},
189 { BFD_RELOC_VTABLE_INHERIT
, R_SPARC_GNU_VTINHERIT
},
190 { BFD_RELOC_VTABLE_ENTRY
, R_SPARC_GNU_VTENTRY
},
193 static reloc_howto_type
*
194 elf32_sparc_reloc_type_lookup (abfd
, code
)
195 bfd
*abfd ATTRIBUTE_UNUSED
;
196 bfd_reloc_code_real_type code
;
202 case BFD_RELOC_VTABLE_INHERIT
:
203 return &elf32_sparc_vtinherit_howto
;
205 case BFD_RELOC_VTABLE_ENTRY
:
206 return &elf32_sparc_vtentry_howto
;
209 for (i
= 0; i
< sizeof (sparc_reloc_map
) / sizeof (struct elf_reloc_map
); i
++)
211 if (sparc_reloc_map
[i
].bfd_reloc_val
== code
)
212 return &_bfd_sparc_elf_howto_table
[(int) sparc_reloc_map
[i
].elf_reloc_val
];
215 bfd_set_error (bfd_error_bad_value
);
219 /* We need to use ELF32_R_TYPE so we have our own copy of this function,
220 and elf64-sparc.c has its own copy. */
223 elf32_sparc_info_to_howto (abfd
, cache_ptr
, dst
)
224 bfd
*abfd ATTRIBUTE_UNUSED
;
226 Elf_Internal_Rela
*dst
;
228 switch (ELF32_R_TYPE(dst
->r_info
))
230 case R_SPARC_GNU_VTINHERIT
:
231 cache_ptr
->howto
= &elf32_sparc_vtinherit_howto
;
234 case R_SPARC_GNU_VTENTRY
:
235 cache_ptr
->howto
= &elf32_sparc_vtentry_howto
;
239 BFD_ASSERT (ELF32_R_TYPE(dst
->r_info
) < (unsigned int) R_SPARC_max_std
);
240 cache_ptr
->howto
= &_bfd_sparc_elf_howto_table
[ELF32_R_TYPE(dst
->r_info
)];
244 /* For unsupported relocs. */
246 static bfd_reloc_status_type
247 sparc_elf_notsupported_reloc (abfd
,
254 bfd
*abfd ATTRIBUTE_UNUSED
;
255 arelent
*reloc_entry ATTRIBUTE_UNUSED
;
256 asymbol
*symbol ATTRIBUTE_UNUSED
;
257 PTR data ATTRIBUTE_UNUSED
;
258 asection
*input_section ATTRIBUTE_UNUSED
;
259 bfd
*output_bfd ATTRIBUTE_UNUSED
;
260 char **error_message ATTRIBUTE_UNUSED
;
262 return bfd_reloc_notsupported
;
265 /* Handle the WDISP16 reloc. */
267 static bfd_reloc_status_type
268 sparc_elf_wdisp16_reloc (abfd
,
276 arelent
*reloc_entry
;
279 asection
*input_section
;
281 char **error_message ATTRIBUTE_UNUSED
;
286 if (output_bfd
!= (bfd
*) NULL
287 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
288 && (! reloc_entry
->howto
->partial_inplace
289 || reloc_entry
->addend
== 0))
291 reloc_entry
->address
+= input_section
->output_offset
;
295 if (output_bfd
!= NULL
)
296 return bfd_reloc_continue
;
298 if (reloc_entry
->address
> input_section
->_cooked_size
)
299 return bfd_reloc_outofrange
;
301 relocation
= (symbol
->value
302 + symbol
->section
->output_section
->vma
303 + symbol
->section
->output_offset
);
304 relocation
+= reloc_entry
->addend
;
305 relocation
-= (input_section
->output_section
->vma
306 + input_section
->output_offset
);
307 relocation
-= reloc_entry
->address
;
309 x
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
310 x
|= ((((relocation
>> 2) & 0xc000) << 6)
311 | ((relocation
>> 2) & 0x3fff));
312 bfd_put_32 (abfd
, x
, (bfd_byte
*) data
+ reloc_entry
->address
);
314 if ((bfd_signed_vma
) relocation
< - 0x40000
315 || (bfd_signed_vma
) relocation
> 0x3ffff)
316 return bfd_reloc_overflow
;
321 /* Functions for the SPARC ELF linker. */
323 /* The name of the dynamic interpreter. This is put in the .interp
326 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
328 /* The nop opcode we use. */
330 #define SPARC_NOP 0x01000000
332 /* The size in bytes of an entry in the procedure linkage table. */
334 #define PLT_ENTRY_SIZE 12
336 /* The first four entries in a procedure linkage table are reserved,
337 and the initial contents are unimportant (we zero them out).
338 Subsequent entries look like this. See the SVR4 ABI SPARC
339 supplement to see how this works. */
341 /* sethi %hi(.-.plt0),%g1. We fill in the address later. */
342 #define PLT_ENTRY_WORD0 0x03000000
343 /* b,a .plt0. We fill in the offset later. */
344 #define PLT_ENTRY_WORD1 0x30800000
346 #define PLT_ENTRY_WORD2 SPARC_NOP
348 /* Look through the relocs for a section during the first phase, and
349 allocate space in the global offset table or procedure linkage
353 elf32_sparc_check_relocs (abfd
, info
, sec
, relocs
)
355 struct bfd_link_info
*info
;
357 const Elf_Internal_Rela
*relocs
;
360 Elf_Internal_Shdr
*symtab_hdr
;
361 struct elf_link_hash_entry
**sym_hashes
;
362 bfd_vma
*local_got_offsets
;
363 const Elf_Internal_Rela
*rel
;
364 const Elf_Internal_Rela
*rel_end
;
369 if (info
->relocateable
)
372 dynobj
= elf_hash_table (info
)->dynobj
;
373 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
374 sym_hashes
= elf_sym_hashes (abfd
);
375 local_got_offsets
= elf_local_got_offsets (abfd
);
381 rel_end
= relocs
+ sec
->reloc_count
;
382 for (rel
= relocs
; rel
< rel_end
; rel
++)
384 unsigned long r_symndx
;
385 struct elf_link_hash_entry
*h
;
387 r_symndx
= ELF32_R_SYM (rel
->r_info
);
388 if (r_symndx
< symtab_hdr
->sh_info
)
391 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
393 switch (ELF32_R_TYPE (rel
->r_info
))
398 /* This symbol requires a global offset table entry. */
402 /* Create the .got section. */
403 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
404 if (! _bfd_elf_create_got_section (dynobj
, info
))
410 sgot
= bfd_get_section_by_name (dynobj
, ".got");
411 BFD_ASSERT (sgot
!= NULL
);
415 && (h
!= NULL
|| info
->shared
))
417 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
420 srelgot
= bfd_make_section (dynobj
, ".rela.got");
422 || ! bfd_set_section_flags (dynobj
, srelgot
,
429 || ! bfd_set_section_alignment (dynobj
, srelgot
, 2))
436 if (h
->got
.offset
!= (bfd_vma
) -1)
438 /* We have already allocated space in the .got. */
441 h
->got
.offset
= sgot
->_raw_size
;
443 /* Make sure this symbol is output as a dynamic symbol. */
444 if (h
->dynindx
== -1)
446 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
450 srelgot
->_raw_size
+= sizeof (Elf32_External_Rela
);
454 /* This is a global offset table entry for a local
456 if (local_got_offsets
== NULL
)
459 register unsigned int i
;
461 size
= symtab_hdr
->sh_info
;
462 size
*= sizeof (bfd_vma
);
463 local_got_offsets
= (bfd_vma
*) bfd_alloc (abfd
, size
);
464 if (local_got_offsets
== NULL
)
466 elf_local_got_offsets (abfd
) = local_got_offsets
;
467 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
468 local_got_offsets
[i
] = (bfd_vma
) -1;
470 if (local_got_offsets
[r_symndx
] != (bfd_vma
) -1)
472 /* We have already allocated space in the .got. */
475 local_got_offsets
[r_symndx
] = sgot
->_raw_size
;
479 /* If we are generating a shared object, we need to
480 output a R_SPARC_RELATIVE reloc so that the
481 dynamic linker can adjust this GOT entry. */
482 srelgot
->_raw_size
+= sizeof (Elf32_External_Rela
);
486 sgot
->_raw_size
+= 4;
488 /* If the .got section is more than 0x1000 bytes, we add
489 0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13
490 bit relocations have a greater chance of working. */
491 if (sgot
->_raw_size
>= 0x1000
492 && elf_hash_table (info
)->hgot
->root
.u
.def
.value
== 0)
493 elf_hash_table (info
)->hgot
->root
.u
.def
.value
= 0x1000;
498 /* This symbol requires a procedure linkage table entry. We
499 actually build the entry in adjust_dynamic_symbol,
500 because this might be a case of linking PIC code without
501 linking in any dynamic objects, in which case we don't
502 need to generate a procedure linkage table after all. */
506 /* The Solaris native assembler will generate a WPLT30
507 reloc for a local symbol if you assemble a call from
508 one section to another when using -K pic. We treat
513 /* Make sure this symbol is output as a dynamic symbol. */
514 if (h
->dynindx
== -1)
516 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
520 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
527 h
->elf_link_hash_flags
|= ELF_LINK_NON_GOT_REF
;
530 && strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
536 case R_SPARC_WDISP30
:
537 case R_SPARC_WDISP22
:
538 case R_SPARC_WDISP19
:
539 case R_SPARC_WDISP16
:
541 h
->elf_link_hash_flags
|= ELF_LINK_NON_GOT_REF
;
543 /* If we are linking with -Bsymbolic, we do not need to copy
544 a PC relative reloc against a global symbol which is
545 defined in an object we are including in the link (i.e.,
546 DEF_REGULAR is set). FIXME: At this point we have not
547 seen all the input files, so it is possible that
548 DEF_REGULAR is not set now but will be set later (it is
549 never cleared). This needs to be handled as in
553 && (h
->elf_link_hash_flags
554 & ELF_LINK_HASH_DEF_REGULAR
) != 0))
567 h
->elf_link_hash_flags
|= ELF_LINK_NON_GOT_REF
;
569 if (info
->shared
&& (sec
->flags
& SEC_ALLOC
))
571 /* When creating a shared object, we must copy these
572 relocs into the output file. We create a reloc
573 section in dynobj and make room for the reloc. */
578 name
= (bfd_elf_string_from_elf_section
580 elf_elfheader (abfd
)->e_shstrndx
,
581 elf_section_data (sec
)->rel_hdr
.sh_name
));
585 BFD_ASSERT (strncmp (name
, ".rela", 5) == 0
586 && strcmp (bfd_get_section_name (abfd
, sec
),
589 sreloc
= bfd_get_section_by_name (dynobj
, name
);
594 sreloc
= bfd_make_section (dynobj
, name
);
595 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
596 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
597 if ((sec
->flags
& SEC_ALLOC
) != 0)
598 flags
|= SEC_ALLOC
| SEC_LOAD
;
600 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
601 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
604 if (sec
->flags
& SEC_READONLY
)
605 info
->flags
|= DF_TEXTREL
;
608 sreloc
->_raw_size
+= sizeof (Elf32_External_Rela
);
613 case R_SPARC_GNU_VTINHERIT
:
614 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
618 case R_SPARC_GNU_VTENTRY
:
619 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
632 elf32_sparc_gc_mark_hook (abfd
, info
, rel
, h
, sym
)
634 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
635 Elf_Internal_Rela
*rel
;
636 struct elf_link_hash_entry
*h
;
637 Elf_Internal_Sym
*sym
;
642 switch (ELF32_R_TYPE (rel
->r_info
))
644 case R_SPARC_GNU_VTINHERIT
:
645 case R_SPARC_GNU_VTENTRY
:
649 switch (h
->root
.type
)
651 case bfd_link_hash_defined
:
652 case bfd_link_hash_defweak
:
653 return h
->root
.u
.def
.section
;
655 case bfd_link_hash_common
:
656 return h
->root
.u
.c
.p
->section
;
665 if (!(elf_bad_symtab (abfd
)
666 && ELF_ST_BIND (sym
->st_info
) != STB_LOCAL
)
667 && ! ((sym
->st_shndx
<= 0 || sym
->st_shndx
>= SHN_LORESERVE
)
668 && sym
->st_shndx
!= SHN_COMMON
))
670 return bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
677 /* Update the got entry reference counts for the section being removed. */
679 elf32_sparc_gc_sweep_hook (abfd
, info
, sec
, relocs
)
681 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
683 const Elf_Internal_Rela
*relocs
;
686 Elf_Internal_Shdr
*symtab_hdr
;
687 struct elf_link_hash_entry
**sym_hashes
;
688 bfd_signed_vma
*local_got_refcounts
;
689 const Elf_Internal_Rela
*rel
, *relend
;
690 unsigned long r_symndx
;
691 struct elf_link_hash_entry
*h
;
693 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
694 sym_hashes
= elf_sym_hashes (abfd
);
695 local_got_refcounts
= elf_local_got_refcounts (abfd
);
697 relend
= relocs
+ sec
->reloc_count
;
698 for (rel
= relocs
; rel
< relend
; rel
++)
699 switch (ELF32_R_TYPE (rel
->r_info
))
704 r_symndx
= ELF32_R_SYM (rel
->r_info
);
705 if (r_symndx
>= symtab_hdr
->sh_info
)
707 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
708 if (h
->got
.refcount
> 0)
713 if (local_got_refcounts
[r_symndx
] > 0)
714 local_got_refcounts
[r_symndx
]--;
719 case R_SPARC_HIPLT22
:
720 case R_SPARC_LOPLT10
:
721 case R_SPARC_PCPLT32
:
722 case R_SPARC_PCPLT10
:
723 r_symndx
= ELF32_R_SYM (rel
->r_info
);
724 if (r_symndx
>= symtab_hdr
->sh_info
)
726 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
727 if (h
->plt
.refcount
> 0)
739 /* Adjust a symbol defined by a dynamic object and referenced by a
740 regular object. The current definition is in some section of the
741 dynamic object, but we're not including those sections. We have to
742 change the definition to something the rest of the link can
746 elf32_sparc_adjust_dynamic_symbol (info
, h
)
747 struct bfd_link_info
*info
;
748 struct elf_link_hash_entry
*h
;
752 unsigned int power_of_two
;
754 dynobj
= elf_hash_table (info
)->dynobj
;
756 /* Make sure we know what is going on here. */
757 BFD_ASSERT (dynobj
!= NULL
758 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
759 || h
->weakdef
!= NULL
760 || ((h
->elf_link_hash_flags
761 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
762 && (h
->elf_link_hash_flags
763 & ELF_LINK_HASH_REF_REGULAR
) != 0
764 && (h
->elf_link_hash_flags
765 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
767 /* If this is a function, put it in the procedure linkage table. We
768 will fill in the contents of the procedure linkage table later
769 (although we could actually do it here). The STT_NOTYPE
770 condition is a hack specifically for the Oracle libraries
771 delivered for Solaris; for some inexplicable reason, they define
772 some of their functions as STT_NOTYPE when they really should be
774 if (h
->type
== STT_FUNC
775 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0
776 || (h
->type
== STT_NOTYPE
777 && (h
->root
.type
== bfd_link_hash_defined
778 || h
->root
.type
== bfd_link_hash_defweak
)
779 && (h
->root
.u
.def
.section
->flags
& SEC_CODE
) != 0))
781 if (! elf_hash_table (info
)->dynamic_sections_created
782 || ((!info
->shared
|| info
->symbolic
|| h
->dynindx
== -1)
783 && (h
->elf_link_hash_flags
784 & ELF_LINK_HASH_DEF_REGULAR
) != 0))
786 /* This case can occur if we saw a WPLT30 reloc in an input
787 file, but none of the input files were dynamic objects.
788 Or, when linking the main application or a -Bsymbolic
789 shared library against PIC code. Or when a global symbol
790 has been made private, e.g. via versioning.
792 In these cases we know what value the symbol will resolve
793 to, so we don't actually need to build a procedure linkage
794 table, and we can just do a WDISP30 reloc instead. */
796 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
800 s
= bfd_get_section_by_name (dynobj
, ".plt");
801 BFD_ASSERT (s
!= NULL
);
803 /* The first four entries in .plt are reserved. */
804 if (s
->_raw_size
== 0)
805 s
->_raw_size
= 4 * PLT_ENTRY_SIZE
;
807 /* The procedure linkage table has a maximum size. */
808 if (s
->_raw_size
>= 0x400000)
810 bfd_set_error (bfd_error_bad_value
);
814 /* If this symbol is not defined in a regular file, and we are
815 not generating a shared library, then set the symbol to this
816 location in the .plt. This is required to make function
817 pointers compare as equal between the normal executable and
818 the shared library. */
820 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
822 h
->root
.u
.def
.section
= s
;
823 h
->root
.u
.def
.value
= s
->_raw_size
;
826 h
->plt
.offset
= s
->_raw_size
;
828 /* Make room for this entry. */
829 s
->_raw_size
+= PLT_ENTRY_SIZE
;
831 /* We also need to make an entry in the .rela.plt section. */
833 s
= bfd_get_section_by_name (dynobj
, ".rela.plt");
834 BFD_ASSERT (s
!= NULL
);
835 s
->_raw_size
+= sizeof (Elf32_External_Rela
);
840 /* If this is a weak symbol, and there is a real definition, the
841 processor independent code will have arranged for us to see the
842 real definition first, and we can just use the same value. */
843 if (h
->weakdef
!= NULL
)
845 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
846 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
847 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
848 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
852 /* This is a reference to a symbol defined by a dynamic object which
853 is not a function. */
855 /* If we are creating a shared library, we must presume that the
856 only references to the symbol are via the global offset table.
857 For such cases we need not do anything here; the relocations will
858 be handled correctly by relocate_section. */
862 /* If there are no references to this symbol that do not use the
863 GOT, we don't need to generate a copy reloc. */
864 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0)
867 /* We must allocate the symbol in our .dynbss section, which will
868 become part of the .bss section of the executable. There will be
869 an entry for this symbol in the .dynsym section. The dynamic
870 object will contain position independent code, so all references
871 from the dynamic object to this symbol will go through the global
872 offset table. The dynamic linker will use the .dynsym entry to
873 determine the address it must put in the global offset table, so
874 both the dynamic object and the regular object will refer to the
875 same memory location for the variable. */
877 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
878 BFD_ASSERT (s
!= NULL
);
880 /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker
881 to copy the initial value out of the dynamic object and into the
882 runtime process image. We need to remember the offset into the
883 .rel.bss section we are going to use. */
884 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
888 srel
= bfd_get_section_by_name (dynobj
, ".rela.bss");
889 BFD_ASSERT (srel
!= NULL
);
890 srel
->_raw_size
+= sizeof (Elf32_External_Rela
);
891 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
894 /* We need to figure out the alignment required for this symbol. I
895 have no idea how ELF linkers handle this. */
896 power_of_two
= bfd_log2 (h
->size
);
897 if (power_of_two
> 3)
900 /* Apply the required alignment. */
901 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
,
902 (bfd_size_type
) (1 << power_of_two
));
903 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
905 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
909 /* Define the symbol as being at this point in the section. */
910 h
->root
.u
.def
.section
= s
;
911 h
->root
.u
.def
.value
= s
->_raw_size
;
913 /* Increment the section size to make room for the symbol. */
914 s
->_raw_size
+= h
->size
;
919 /* Set the sizes of the dynamic sections. */
922 elf32_sparc_size_dynamic_sections (output_bfd
, info
)
923 bfd
*output_bfd ATTRIBUTE_UNUSED
;
924 struct bfd_link_info
*info
;
930 dynobj
= elf_hash_table (info
)->dynobj
;
931 BFD_ASSERT (dynobj
!= NULL
);
933 if (elf_hash_table (info
)->dynamic_sections_created
)
935 /* Set the contents of the .interp section to the interpreter. */
938 s
= bfd_get_section_by_name (dynobj
, ".interp");
939 BFD_ASSERT (s
!= NULL
);
940 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
941 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
944 /* Make space for the trailing nop in .plt. */
945 s
= bfd_get_section_by_name (dynobj
, ".plt");
946 BFD_ASSERT (s
!= NULL
);
947 if (s
->_raw_size
> 0)
952 /* We may have created entries in the .rela.got section.
953 However, if we are not creating the dynamic sections, we will
954 not actually use these entries. Reset the size of .rela.got,
955 which will cause it to get stripped from the output file
957 s
= bfd_get_section_by_name (dynobj
, ".rela.got");
962 /* The check_relocs and adjust_dynamic_symbol entry points have
963 determined the sizes of the various dynamic sections. Allocate
966 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
971 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
974 /* It's OK to base decisions on the section name, because none
975 of the dynobj section names depend upon the input files. */
976 name
= bfd_get_section_name (dynobj
, s
);
980 if (strncmp (name
, ".rela", 5) == 0)
982 if (s
->_raw_size
== 0)
984 /* If we don't need this section, strip it from the
985 output file. This is to handle .rela.bss and
986 .rel.plt. We must create it in
987 create_dynamic_sections, because it must be created
988 before the linker maps input sections to output
989 sections. The linker does that before
990 adjust_dynamic_symbol is called, and it is that
991 function which decides whether anything needs to go
992 into these sections. */
997 if (strcmp (name
, ".rela.plt") == 0)
1000 /* We use the reloc_count field as a counter if we need
1001 to copy relocs into the output file. */
1005 else if (strcmp (name
, ".plt") != 0
1006 && strcmp (name
, ".got") != 0)
1008 /* It's not one of our sections, so don't allocate space. */
1014 _bfd_strip_section_from_output (info
, s
);
1018 /* Allocate memory for the section contents. */
1019 /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
1020 Unused entries should be reclaimed before the section's contents
1021 are written out, but at the moment this does not happen. Thus in
1022 order to prevent writing out garbage, we initialise the section's
1023 contents to zero. */
1024 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
1025 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
1029 if (elf_hash_table (info
)->dynamic_sections_created
)
1031 /* Add some entries to the .dynamic section. We fill in the
1032 values later, in elf32_sparc_finish_dynamic_sections, but we
1033 must add the entries now so that we get the correct size for
1034 the .dynamic section. The DT_DEBUG entry is filled in by the
1035 dynamic linker and used by the debugger. */
1036 #define add_dynamic_entry(TAG, VAL) \
1037 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1041 if (!add_dynamic_entry (DT_DEBUG
, 0))
1047 if (!add_dynamic_entry (DT_PLTGOT
, 0)
1048 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
1049 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
1050 || !add_dynamic_entry (DT_JMPREL
, 0))
1054 if (!add_dynamic_entry (DT_RELA
, 0)
1055 || !add_dynamic_entry (DT_RELASZ
, 0)
1056 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf32_External_Rela
)))
1059 if (info
->flags
& DF_TEXTREL
)
1061 if (!add_dynamic_entry (DT_TEXTREL
, 0))
1065 #undef add_dynamic_entry
1070 #define SET_SEC_DO_RELAX(section) do { elf_section_data(section)->tdata = (void *)1; } while (0)
1071 #define SEC_DO_RELAX(section) (elf_section_data(section)->tdata == (void *)1)
1074 elf32_sparc_relax_section (abfd
, section
, link_info
, again
)
1075 bfd
*abfd ATTRIBUTE_UNUSED
;
1076 asection
*section ATTRIBUTE_UNUSED
;
1077 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
;
1081 SET_SEC_DO_RELAX (section
);
1085 /* Relocate a SPARC ELF section. */
1088 elf32_sparc_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
1089 contents
, relocs
, local_syms
, local_sections
)
1091 struct bfd_link_info
*info
;
1093 asection
*input_section
;
1095 Elf_Internal_Rela
*relocs
;
1096 Elf_Internal_Sym
*local_syms
;
1097 asection
**local_sections
;
1100 Elf_Internal_Shdr
*symtab_hdr
;
1101 struct elf_link_hash_entry
**sym_hashes
;
1102 bfd_vma
*local_got_offsets
;
1107 Elf_Internal_Rela
*rel
;
1108 Elf_Internal_Rela
*relend
;
1110 dynobj
= elf_hash_table (info
)->dynobj
;
1111 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1112 sym_hashes
= elf_sym_hashes (input_bfd
);
1113 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1115 if (elf_hash_table (info
)->hgot
== NULL
)
1118 got_base
= elf_hash_table (info
)->hgot
->root
.u
.def
.value
;
1125 relend
= relocs
+ input_section
->reloc_count
;
1126 for (; rel
< relend
; rel
++)
1129 reloc_howto_type
*howto
;
1130 unsigned long r_symndx
;
1131 struct elf_link_hash_entry
*h
;
1132 Elf_Internal_Sym
*sym
;
1135 bfd_reloc_status_type r
;
1137 r_type
= ELF32_R_TYPE (rel
->r_info
);
1139 if (r_type
== R_SPARC_GNU_VTINHERIT
1140 || r_type
== R_SPARC_GNU_VTENTRY
)
1143 if (r_type
< 0 || r_type
>= (int) R_SPARC_max_std
)
1145 bfd_set_error (bfd_error_bad_value
);
1148 howto
= _bfd_sparc_elf_howto_table
+ r_type
;
1150 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1152 if (info
->relocateable
)
1154 /* This is a relocateable link. We don't have to change
1155 anything, unless the reloc is against a section symbol,
1156 in which case we have to adjust according to where the
1157 section symbol winds up in the output section. */
1158 if (r_symndx
< symtab_hdr
->sh_info
)
1160 sym
= local_syms
+ r_symndx
;
1161 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1163 sec
= local_sections
[r_symndx
];
1164 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
1171 /* This is a final link. */
1175 if (r_symndx
< symtab_hdr
->sh_info
)
1177 sym
= local_syms
+ r_symndx
;
1178 sec
= local_sections
[r_symndx
];
1179 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, sec
, rel
);
1183 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1184 while (h
->root
.type
== bfd_link_hash_indirect
1185 || h
->root
.type
== bfd_link_hash_warning
)
1186 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1187 if (h
->root
.type
== bfd_link_hash_defined
1188 || h
->root
.type
== bfd_link_hash_defweak
)
1190 sec
= h
->root
.u
.def
.section
;
1191 if ((r_type
== R_SPARC_WPLT30
1192 && h
->plt
.offset
!= (bfd_vma
) -1)
1193 || ((r_type
== R_SPARC_GOT10
1194 || r_type
== R_SPARC_GOT13
1195 || r_type
== R_SPARC_GOT22
)
1196 && elf_hash_table (info
)->dynamic_sections_created
1198 || (! info
->symbolic
&& h
->dynindx
!= -1)
1199 || (h
->elf_link_hash_flags
1200 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
1202 && ((! info
->symbolic
&& h
->dynindx
!= -1)
1203 || (h
->elf_link_hash_flags
1204 & ELF_LINK_HASH_DEF_REGULAR
) == 0)
1205 && (r_type
== R_SPARC_8
1206 || r_type
== R_SPARC_16
1207 || r_type
== R_SPARC_32
1208 || r_type
== R_SPARC_DISP8
1209 || r_type
== R_SPARC_DISP16
1210 || r_type
== R_SPARC_DISP32
1211 || r_type
== R_SPARC_WDISP30
1212 || r_type
== R_SPARC_WDISP22
1213 || r_type
== R_SPARC_WDISP19
1214 || r_type
== R_SPARC_WDISP16
1215 || r_type
== R_SPARC_HI22
1216 || r_type
== R_SPARC_22
1217 || r_type
== R_SPARC_13
1218 || r_type
== R_SPARC_LO10
1219 || r_type
== R_SPARC_UA16
1220 || r_type
== R_SPARC_UA32
1221 || ((r_type
== R_SPARC_PC10
1222 || r_type
== R_SPARC_PC22
)
1223 && strcmp (h
->root
.root
.string
,
1224 "_GLOBAL_OFFSET_TABLE_") != 0))
1225 && ((input_section
->flags
& SEC_ALLOC
) != 0
1226 /* DWARF will emit R_SPARC_32 relocations in its
1227 sections against symbols defined externally
1228 in shared libraries. We can't do anything
1230 || ((input_section
->flags
& SEC_DEBUGGING
) != 0
1231 && (h
->elf_link_hash_flags
1232 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0))))
1234 /* In these cases, we don't need the relocation
1235 value. We check specially because in some
1236 obscure cases sec->output_section will be NULL. */
1240 relocation
= (h
->root
.u
.def
.value
1241 + sec
->output_section
->vma
1242 + sec
->output_offset
);
1244 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1246 else if (info
->shared
1247 && (!info
->symbolic
|| info
->allow_shlib_undefined
)
1248 && !info
->no_undefined
1249 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
1253 if (! ((*info
->callbacks
->undefined_symbol
)
1254 (info
, h
->root
.root
.string
, input_bfd
,
1255 input_section
, rel
->r_offset
,
1256 (!info
->shared
|| info
->no_undefined
1257 || ELF_ST_VISIBILITY (h
->other
)))))
1268 /* Relocation is to the entry for this symbol in the global
1272 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1273 BFD_ASSERT (sgot
!= NULL
);
1280 off
= h
->got
.offset
;
1281 BFD_ASSERT (off
!= (bfd_vma
) -1);
1283 if (! elf_hash_table (info
)->dynamic_sections_created
1285 && (info
->symbolic
|| h
->dynindx
== -1)
1286 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
1288 /* This is actually a static link, or it is a
1289 -Bsymbolic link and the symbol is defined
1290 locally, or the symbol was forced to be local
1291 because of a version file. We must initialize
1292 this entry in the global offset table. Since the
1293 offset must always be a multiple of 4, we use the
1294 least significant bit to record whether we have
1295 initialized it already.
1297 When doing a dynamic link, we create a .rela.got
1298 relocation entry to initialize the value. This
1299 is done in the finish_dynamic_symbol routine. */
1304 bfd_put_32 (output_bfd
, relocation
,
1305 sgot
->contents
+ off
);
1310 relocation
= sgot
->output_offset
+ off
- got_base
;
1316 BFD_ASSERT (local_got_offsets
!= NULL
1317 && local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
1319 off
= local_got_offsets
[r_symndx
];
1321 /* The offset must always be a multiple of 4. We use
1322 the least significant bit to record whether we have
1323 already processed this entry. */
1328 bfd_put_32 (output_bfd
, relocation
, sgot
->contents
+ off
);
1333 Elf_Internal_Rela outrel
;
1335 /* We need to generate a R_SPARC_RELATIVE reloc
1336 for the dynamic linker. */
1337 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
1338 BFD_ASSERT (srelgot
!= NULL
);
1340 outrel
.r_offset
= (sgot
->output_section
->vma
1341 + sgot
->output_offset
1343 outrel
.r_info
= ELF32_R_INFO (0, R_SPARC_RELATIVE
);
1344 outrel
.r_addend
= 0;
1345 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
,
1346 (((Elf32_External_Rela
*)
1348 + srelgot
->reloc_count
));
1349 ++srelgot
->reloc_count
;
1352 local_got_offsets
[r_symndx
] |= 1;
1355 relocation
= sgot
->output_offset
+ off
- got_base
;
1360 case R_SPARC_WPLT30
:
1361 /* Relocation is to the entry for this symbol in the
1362 procedure linkage table. */
1364 /* The Solaris native assembler will generate a WPLT30 reloc
1365 for a local symbol if you assemble a call from one
1366 section to another when using -K pic. We treat it as
1371 if (h
->plt
.offset
== (bfd_vma
) -1)
1373 /* We didn't make a PLT entry for this symbol. This
1374 happens when statically linking PIC code, or when
1375 using -Bsymbolic. */
1381 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1382 BFD_ASSERT (splt
!= NULL
);
1385 relocation
= (splt
->output_section
->vma
1386 + splt
->output_offset
1393 && strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
1397 case R_SPARC_DISP16
:
1398 case R_SPARC_DISP32
:
1399 case R_SPARC_WDISP30
:
1400 case R_SPARC_WDISP22
:
1401 case R_SPARC_WDISP19
:
1402 case R_SPARC_WDISP16
:
1405 && (h
->elf_link_hash_flags
1406 & ELF_LINK_HASH_DEF_REGULAR
) != 0))
1420 && (input_section
->flags
& SEC_ALLOC
))
1422 Elf_Internal_Rela outrel
;
1425 /* When generating a shared object, these relocations
1426 are copied into the output file to be resolved at run
1433 name
= (bfd_elf_string_from_elf_section
1435 elf_elfheader (input_bfd
)->e_shstrndx
,
1436 elf_section_data (input_section
)->rel_hdr
.sh_name
));
1440 BFD_ASSERT (strncmp (name
, ".rela", 5) == 0
1441 && strcmp (bfd_get_section_name (input_bfd
,
1445 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1446 BFD_ASSERT (sreloc
!= NULL
);
1451 if (elf_section_data (input_section
)->stab_info
== NULL
)
1452 outrel
.r_offset
= rel
->r_offset
;
1457 off
= (_bfd_stab_section_offset
1458 (output_bfd
, &elf_hash_table (info
)->stab_info
,
1460 &elf_section_data (input_section
)->stab_info
,
1462 if (off
== (bfd_vma
) -1)
1464 outrel
.r_offset
= off
;
1467 outrel
.r_offset
+= (input_section
->output_section
->vma
1468 + input_section
->output_offset
);
1470 /* Optimize unaligned reloc usage now that we know where
1471 it finally resides. */
1475 if (outrel
.r_offset
& 1)
1476 r_type
= R_SPARC_UA16
;
1479 if (!(outrel
.r_offset
& 1))
1480 r_type
= R_SPARC_16
;
1483 if (outrel
.r_offset
& 3)
1484 r_type
= R_SPARC_UA32
;
1487 if (!(outrel
.r_offset
& 3))
1488 r_type
= R_SPARC_32
;
1493 memset (&outrel
, 0, sizeof outrel
);
1494 /* h->dynindx may be -1 if the symbol was marked to
1497 && ((! info
->symbolic
&& h
->dynindx
!= -1)
1498 || (h
->elf_link_hash_flags
1499 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
1501 BFD_ASSERT (h
->dynindx
!= -1);
1502 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
1503 outrel
.r_addend
= rel
->r_addend
;
1507 if (r_type
== R_SPARC_32
|| r_type
== R_SPARC_UA32
)
1509 outrel
.r_info
= ELF32_R_INFO (0, R_SPARC_RELATIVE
);
1510 outrel
.r_addend
= relocation
+ rel
->r_addend
;
1517 sec
= local_sections
[r_symndx
];
1520 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
1522 == bfd_link_hash_defweak
));
1523 sec
= h
->root
.u
.def
.section
;
1525 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
1527 else if (sec
== NULL
|| sec
->owner
== NULL
)
1529 bfd_set_error (bfd_error_bad_value
);
1536 osec
= sec
->output_section
;
1537 indx
= elf_section_data (osec
)->dynindx
;
1539 /* FIXME: we really should be able to link non-pic
1540 shared libraries. */
1544 (*_bfd_error_handler
)
1545 (_("%s: probably compiled without -fPIC?"),
1546 bfd_archive_filename (input_bfd
));
1547 bfd_set_error (bfd_error_bad_value
);
1552 outrel
.r_info
= ELF32_R_INFO (indx
, r_type
);
1553 outrel
.r_addend
= relocation
+ rel
->r_addend
;
1557 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
,
1558 (((Elf32_External_Rela
*)
1560 + sreloc
->reloc_count
));
1561 ++sreloc
->reloc_count
;
1563 /* This reloc will be computed at runtime, so there's no
1564 need to do anything now. */
1573 r
= bfd_reloc_continue
;
1574 if (r_type
== R_SPARC_WDISP16
)
1578 relocation
+= rel
->r_addend
;
1579 relocation
-= (input_section
->output_section
->vma
1580 + input_section
->output_offset
);
1581 relocation
-= rel
->r_offset
;
1583 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
1584 x
|= ((((relocation
>> 2) & 0xc000) << 6)
1585 | ((relocation
>> 2) & 0x3fff));
1586 bfd_put_32 (input_bfd
, x
, contents
+ rel
->r_offset
);
1588 if ((bfd_signed_vma
) relocation
< - 0x40000
1589 || (bfd_signed_vma
) relocation
> 0x3ffff)
1590 r
= bfd_reloc_overflow
;
1594 else if (r_type
== R_SPARC_REV32
)
1598 relocation
= relocation
+ rel
->r_addend
;
1600 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
1602 bfd_putl32 (/*input_bfd,*/ x
, contents
+ rel
->r_offset
);
1605 else if ((r_type
== R_SPARC_WDISP30
|| r_type
== R_SPARC_WPLT30
)
1606 && SEC_DO_RELAX (input_section
)
1607 && rel
->r_offset
+ 4 < input_section
->_raw_size
)
1611 #define XCC (2 << 20)
1612 #define COND(x) (((x)&0xf)<<25)
1613 #define CONDA COND(0x8)
1614 #define INSN_BPA (F2(0,1) | CONDA | BPRED | XCC)
1615 #define INSN_BA (F2(0,2) | CONDA)
1616 #define INSN_OR F3(2, 0x2, 0)
1617 #define INSN_NOP F2(0,4)
1621 /* If the instruction is a call with either:
1623 arithmetic instruction with rd == %o7
1624 where rs1 != %o7 and rs2 if it is register != %o7
1625 then we can optimize if the call destination is near
1626 by changing the call into a branch always. */
1627 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
1628 y
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
1629 if ((x
& OP(~0)) == OP(1) && (y
& OP(~0)) == OP(2))
1631 if (((y
& OP3(~0)) == OP3(0x3d) /* restore */
1632 || ((y
& OP3(0x28)) == 0 /* arithmetic */
1633 && (y
& RD(~0)) == RD(O7
)))
1634 && (y
& RS1(~0)) != RS1(O7
)
1636 || (y
& RS2(~0)) != RS2(O7
)))
1640 reloc
= relocation
+ rel
->r_addend
- rel
->r_offset
;
1641 reloc
-= (input_section
->output_section
->vma
1642 + input_section
->output_offset
);
1644 /* Ensure the reloc fits into simm22. */
1645 if ((reloc
& 3) == 0
1646 && ((reloc
& ~(bfd_vma
)0x7fffff) == 0
1647 || ((reloc
| 0x7fffff) == ~(bfd_vma
)0)))
1651 /* Check whether it fits into simm19 on v9. */
1652 if (((reloc
& 0x3c0000) == 0
1653 || (reloc
& 0x3c0000) == 0x3c0000)
1654 && (elf_elfheader (output_bfd
)->e_flags
& EF_SPARC_32PLUS
))
1655 x
= INSN_BPA
| (reloc
& 0x7ffff); /* ba,pt %xcc */
1657 x
= INSN_BA
| (reloc
& 0x3fffff); /* ba */
1658 bfd_put_32 (input_bfd
, x
, contents
+ rel
->r_offset
);
1660 if (rel
->r_offset
>= 4
1661 && (y
& (0xffffffff ^ RS1(~0)))
1662 == (INSN_OR
| RD(O7
) | RS2(G0
)))
1667 z
= bfd_get_32 (input_bfd
,
1668 contents
+ rel
->r_offset
- 4);
1669 if ((z
& (0xffffffff ^ RD(~0)))
1670 != (INSN_OR
| RS1(O7
) | RS2(G0
)))
1678 If call foo was replaced with ba, replace
1679 or %rN, %g0, %o7 with nop. */
1681 reg
= (y
& RS1(~0)) >> 14;
1682 if (reg
!= ((z
& RD(~0)) >> 25)
1683 || reg
== G0
|| reg
== O7
)
1686 bfd_put_32 (input_bfd
, (bfd_vma
) INSN_NOP
,
1687 contents
+ rel
->r_offset
+ 4);
1695 if (r
== bfd_reloc_continue
)
1696 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1697 contents
, rel
->r_offset
,
1698 relocation
, rel
->r_addend
);
1700 if (r
!= bfd_reloc_ok
)
1705 case bfd_reloc_outofrange
:
1707 case bfd_reloc_overflow
:
1712 name
= h
->root
.root
.string
;
1715 name
= bfd_elf_string_from_elf_section (input_bfd
,
1716 symtab_hdr
->sh_link
,
1721 name
= bfd_section_name (input_bfd
, sec
);
1723 if (! ((*info
->callbacks
->reloc_overflow
)
1724 (info
, name
, howto
->name
, (bfd_vma
) 0,
1725 input_bfd
, input_section
, rel
->r_offset
)))
1736 /* Finish up dynamic symbol handling. We set the contents of various
1737 dynamic sections here. */
1740 elf32_sparc_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
1742 struct bfd_link_info
*info
;
1743 struct elf_link_hash_entry
*h
;
1744 Elf_Internal_Sym
*sym
;
1748 dynobj
= elf_hash_table (info
)->dynobj
;
1750 if (h
->plt
.offset
!= (bfd_vma
) -1)
1754 Elf_Internal_Rela rela
;
1756 /* This symbol has an entry in the procedure linkage table. Set
1759 BFD_ASSERT (h
->dynindx
!= -1);
1761 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1762 srela
= bfd_get_section_by_name (dynobj
, ".rela.plt");
1763 BFD_ASSERT (splt
!= NULL
&& srela
!= NULL
);
1765 /* Fill in the entry in the procedure linkage table. */
1766 bfd_put_32 (output_bfd
,
1767 PLT_ENTRY_WORD0
+ h
->plt
.offset
,
1768 splt
->contents
+ h
->plt
.offset
);
1769 bfd_put_32 (output_bfd
,
1771 + (((- (h
->plt
.offset
+ 4)) >> 2) & 0x3fffff)),
1772 splt
->contents
+ h
->plt
.offset
+ 4);
1773 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_ENTRY_WORD2
,
1774 splt
->contents
+ h
->plt
.offset
+ 8);
1776 /* Fill in the entry in the .rela.plt section. */
1777 rela
.r_offset
= (splt
->output_section
->vma
1778 + splt
->output_offset
1780 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SPARC_JMP_SLOT
);
1782 bfd_elf32_swap_reloca_out (output_bfd
, &rela
,
1783 ((Elf32_External_Rela
*) srela
->contents
1784 + h
->plt
.offset
/ PLT_ENTRY_SIZE
- 4));
1786 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1788 /* Mark the symbol as undefined, rather than as defined in
1789 the .plt section. Leave the value alone. */
1790 sym
->st_shndx
= SHN_UNDEF
;
1791 /* If the symbol is weak, we do need to clear the value.
1792 Otherwise, the PLT entry would provide a definition for
1793 the symbol even if the symbol wasn't defined anywhere,
1794 and so the symbol would never be NULL. */
1795 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR_NONWEAK
)
1801 if (h
->got
.offset
!= (bfd_vma
) -1)
1805 Elf_Internal_Rela rela
;
1807 /* This symbol has an entry in the global offset table. Set it
1810 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1811 srela
= bfd_get_section_by_name (dynobj
, ".rela.got");
1812 BFD_ASSERT (sgot
!= NULL
&& srela
!= NULL
);
1814 rela
.r_offset
= (sgot
->output_section
->vma
1815 + sgot
->output_offset
1816 + (h
->got
.offset
&~ (bfd_vma
) 1));
1818 /* If this is a -Bsymbolic link, and the symbol is defined
1819 locally, we just want to emit a RELATIVE reloc. Likewise if
1820 the symbol was forced to be local because of a version file.
1821 The entry in the global offset table will already have been
1822 initialized in the relocate_section function. */
1824 && (info
->symbolic
|| h
->dynindx
== -1)
1825 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
1826 rela
.r_info
= ELF32_R_INFO (0, R_SPARC_RELATIVE
);
1829 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
1830 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SPARC_GLOB_DAT
);
1834 bfd_elf32_swap_reloca_out (output_bfd
, &rela
,
1835 ((Elf32_External_Rela
*) srela
->contents
1836 + srela
->reloc_count
));
1837 ++srela
->reloc_count
;
1840 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
1843 Elf_Internal_Rela rela
;
1845 /* This symbols needs a copy reloc. Set it up. */
1847 BFD_ASSERT (h
->dynindx
!= -1);
1849 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
1851 BFD_ASSERT (s
!= NULL
);
1853 rela
.r_offset
= (h
->root
.u
.def
.value
1854 + h
->root
.u
.def
.section
->output_section
->vma
1855 + h
->root
.u
.def
.section
->output_offset
);
1856 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SPARC_COPY
);
1858 bfd_elf32_swap_reloca_out (output_bfd
, &rela
,
1859 ((Elf32_External_Rela
*) s
->contents
1864 /* Mark some specially defined symbols as absolute. */
1865 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
1866 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0
1867 || strcmp (h
->root
.root
.string
, "_PROCEDURE_LINKAGE_TABLE_") == 0)
1868 sym
->st_shndx
= SHN_ABS
;
1873 /* Finish up the dynamic sections. */
1876 elf32_sparc_finish_dynamic_sections (output_bfd
, info
)
1878 struct bfd_link_info
*info
;
1884 dynobj
= elf_hash_table (info
)->dynobj
;
1886 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
1888 if (elf_hash_table (info
)->dynamic_sections_created
)
1891 Elf32_External_Dyn
*dyncon
, *dynconend
;
1893 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1894 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
1896 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
1897 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
1898 for (; dyncon
< dynconend
; dyncon
++)
1900 Elf_Internal_Dyn dyn
;
1904 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
1908 case DT_PLTGOT
: name
= ".plt"; size
= false; break;
1909 case DT_PLTRELSZ
: name
= ".rela.plt"; size
= true; break;
1910 case DT_JMPREL
: name
= ".rela.plt"; size
= false; break;
1911 default: name
= NULL
; size
= false; break;
1918 s
= bfd_get_section_by_name (output_bfd
, name
);
1924 dyn
.d_un
.d_ptr
= s
->vma
;
1927 if (s
->_cooked_size
!= 0)
1928 dyn
.d_un
.d_val
= s
->_cooked_size
;
1930 dyn
.d_un
.d_val
= s
->_raw_size
;
1933 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
1937 /* Clear the first four entries in the procedure linkage table,
1938 and put a nop in the last four bytes. */
1939 if (splt
->_raw_size
> 0)
1941 memset (splt
->contents
, 0, 4 * PLT_ENTRY_SIZE
);
1942 bfd_put_32 (output_bfd
, (bfd_vma
) SPARC_NOP
,
1943 splt
->contents
+ splt
->_raw_size
- 4);
1946 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
=
1950 /* Set the first entry in the global offset table to the address of
1951 the dynamic section. */
1952 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1953 BFD_ASSERT (sgot
!= NULL
);
1954 if (sgot
->_raw_size
> 0)
1957 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
1959 bfd_put_32 (output_bfd
,
1960 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
1964 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
1969 /* Functions for dealing with the e_flags field.
1971 We don't define set_private_flags or copy_private_bfd_data because
1972 the only currently defined values are based on the bfd mach number,
1973 so we use the latter instead and defer setting e_flags until the
1974 file is written out. */
1976 /* Merge backend specific data from an object file to the output
1977 object file when linking. */
1980 elf32_sparc_merge_private_bfd_data (ibfd
, obfd
)
1985 /* FIXME: This should not be static. */
1986 static unsigned long previous_ibfd_e_flags
= (unsigned long) -1;
1988 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
1989 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
1994 if (bfd_get_mach (ibfd
) >= bfd_mach_sparc_v9
)
1997 (*_bfd_error_handler
)
1998 (_("%s: compiled for a 64 bit system and target is 32 bit"),
1999 bfd_archive_filename (ibfd
));
2001 else if ((ibfd
->flags
& DYNAMIC
) == 0)
2003 if (bfd_get_mach (obfd
) < bfd_get_mach (ibfd
))
2004 bfd_set_arch_mach (obfd
, bfd_arch_sparc
, bfd_get_mach (ibfd
));
2007 if (((elf_elfheader (ibfd
)->e_flags
& EF_SPARC_LEDATA
)
2008 != previous_ibfd_e_flags
)
2009 && previous_ibfd_e_flags
!= (unsigned long) -1)
2011 (*_bfd_error_handler
)
2012 (_("%s: linking little endian files with big endian files"),
2013 bfd_archive_filename (ibfd
));
2016 previous_ibfd_e_flags
= elf_elfheader (ibfd
)->e_flags
& EF_SPARC_LEDATA
;
2020 bfd_set_error (bfd_error_bad_value
);
2027 /* Set the right machine number. */
2030 elf32_sparc_object_p (abfd
)
2033 if (elf_elfheader (abfd
)->e_machine
== EM_SPARC32PLUS
)
2035 if (elf_elfheader (abfd
)->e_flags
& EF_SPARC_SUN_US3
)
2036 return bfd_default_set_arch_mach (abfd
, bfd_arch_sparc
,
2037 bfd_mach_sparc_v8plusb
);
2038 else if (elf_elfheader (abfd
)->e_flags
& EF_SPARC_SUN_US1
)
2039 return bfd_default_set_arch_mach (abfd
, bfd_arch_sparc
,
2040 bfd_mach_sparc_v8plusa
);
2041 else if (elf_elfheader (abfd
)->e_flags
& EF_SPARC_32PLUS
)
2042 return bfd_default_set_arch_mach (abfd
, bfd_arch_sparc
,
2043 bfd_mach_sparc_v8plus
);
2047 else if (elf_elfheader (abfd
)->e_flags
& EF_SPARC_LEDATA
)
2048 return bfd_default_set_arch_mach (abfd
, bfd_arch_sparc
,
2049 bfd_mach_sparc_sparclite_le
);
2051 return bfd_default_set_arch_mach (abfd
, bfd_arch_sparc
, bfd_mach_sparc
);
2054 /* The final processing done just before writing out the object file.
2055 We need to set the e_machine field appropriately. */
2058 elf32_sparc_final_write_processing (abfd
, linker
)
2060 boolean linker ATTRIBUTE_UNUSED
;
2062 switch (bfd_get_mach (abfd
))
2064 case bfd_mach_sparc
:
2065 break; /* nothing to do */
2066 case bfd_mach_sparc_v8plus
:
2067 elf_elfheader (abfd
)->e_machine
= EM_SPARC32PLUS
;
2068 elf_elfheader (abfd
)->e_flags
&=~ EF_SPARC_32PLUS_MASK
;
2069 elf_elfheader (abfd
)->e_flags
|= EF_SPARC_32PLUS
;
2071 case bfd_mach_sparc_v8plusa
:
2072 elf_elfheader (abfd
)->e_machine
= EM_SPARC32PLUS
;
2073 elf_elfheader (abfd
)->e_flags
&=~ EF_SPARC_32PLUS_MASK
;
2074 elf_elfheader (abfd
)->e_flags
|= EF_SPARC_32PLUS
| EF_SPARC_SUN_US1
;
2076 case bfd_mach_sparc_v8plusb
:
2077 elf_elfheader (abfd
)->e_machine
= EM_SPARC32PLUS
;
2078 elf_elfheader (abfd
)->e_flags
&=~ EF_SPARC_32PLUS_MASK
;
2079 elf_elfheader (abfd
)->e_flags
|= EF_SPARC_32PLUS
| EF_SPARC_SUN_US1
2082 case bfd_mach_sparc_sparclite_le
:
2083 elf_elfheader (abfd
)->e_machine
= EM_SPARC
;
2084 elf_elfheader (abfd
)->e_flags
|= EF_SPARC_LEDATA
;
2092 static enum elf_reloc_type_class
2093 elf32_sparc_reloc_type_class (rela
)
2094 const Elf_Internal_Rela
*rela
;
2096 switch ((int) ELF32_R_TYPE (rela
->r_info
))
2098 case R_SPARC_RELATIVE
:
2099 return reloc_class_relative
;
2100 case R_SPARC_JMP_SLOT
:
2101 return reloc_class_plt
;
2103 return reloc_class_copy
;
2105 return reloc_class_normal
;
2109 #define TARGET_BIG_SYM bfd_elf32_sparc_vec
2110 #define TARGET_BIG_NAME "elf32-sparc"
2111 #define ELF_ARCH bfd_arch_sparc
2112 #define ELF_MACHINE_CODE EM_SPARC
2113 #define ELF_MACHINE_ALT1 EM_SPARC32PLUS
2114 #define ELF_MAXPAGESIZE 0x10000
2116 #define bfd_elf32_bfd_reloc_type_lookup elf32_sparc_reloc_type_lookup
2117 #define bfd_elf32_bfd_relax_section elf32_sparc_relax_section
2118 #define elf_info_to_howto elf32_sparc_info_to_howto
2119 #define elf_backend_create_dynamic_sections \
2120 _bfd_elf_create_dynamic_sections
2121 #define elf_backend_check_relocs elf32_sparc_check_relocs
2122 #define elf_backend_adjust_dynamic_symbol \
2123 elf32_sparc_adjust_dynamic_symbol
2124 #define elf_backend_size_dynamic_sections \
2125 elf32_sparc_size_dynamic_sections
2126 #define elf_backend_relocate_section elf32_sparc_relocate_section
2127 #define elf_backend_finish_dynamic_symbol \
2128 elf32_sparc_finish_dynamic_symbol
2129 #define elf_backend_finish_dynamic_sections \
2130 elf32_sparc_finish_dynamic_sections
2131 #define bfd_elf32_bfd_merge_private_bfd_data \
2132 elf32_sparc_merge_private_bfd_data
2133 #define elf_backend_object_p elf32_sparc_object_p
2134 #define elf_backend_final_write_processing \
2135 elf32_sparc_final_write_processing
2136 #define elf_backend_gc_mark_hook elf32_sparc_gc_mark_hook
2137 #define elf_backend_gc_sweep_hook elf32_sparc_gc_sweep_hook
2138 #define elf_backend_reloc_type_class elf32_sparc_reloc_type_class
2140 #define elf_backend_can_gc_sections 1
2141 #define elf_backend_want_got_plt 0
2142 #define elf_backend_plt_readonly 0
2143 #define elf_backend_want_plt_sym 1
2144 #define elf_backend_got_header_size 4
2145 #define elf_backend_plt_header_size (4*PLT_ENTRY_SIZE)
2147 #include "elf32-target.h"