projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* elf32-sparc.c (WILL_CALL_FINISH_DYNAMIC_SYMBOL): New.
[deliverable/binutils-gdb.git] / bfd / elf32-sparc.c
1 /* SPARC-specific support for 32-bit ELF
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
3 Free Software Foundation, Inc.
4
5 This file is part of BFD, the Binary File Descriptor library.
6
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.
11
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.
16
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. */
20
21 #include "bfd.h"
22 #include "sysdep.h"
23 #include "bfdlink.h"
24 #include "libbfd.h"
25 #include "elf-bfd.h"
26 #include "elf/sparc.h"
27 #include "opcode/sparc.h"
28
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 *,
47 Elf_Internal_Sym *));
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
52 PARAMS ((bfd *));
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 *));
63 \f
64 /* The relocation "howto" table. */
65
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 **));
70
71 reloc_howto_type _bfd_sparc_elf_howto_table[] =
72 {
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,0xffffffff,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_bitfield,bfd_elf_generic_reloc, "R_SPARC_PLT32", false,0,0xffffffff,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),
134 };
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);
139
140 struct elf_reloc_map {
141 bfd_reloc_code_real_type bfd_reloc_val;
142 unsigned char elf_reloc_val;
143 };
144
145 static const struct elf_reloc_map sparc_reloc_map[] =
146 {
147 { BFD_RELOC_NONE, R_SPARC_NONE, },
148 { BFD_RELOC_16, R_SPARC_16, },
149 { BFD_RELOC_16_PCREL, R_SPARC_DISP16 },
150 { BFD_RELOC_8, R_SPARC_8 },
151 { BFD_RELOC_8_PCREL, R_SPARC_DISP8 },
152 { BFD_RELOC_CTOR, R_SPARC_32 },
153 { BFD_RELOC_32, R_SPARC_32 },
154 { BFD_RELOC_32_PCREL, R_SPARC_DISP32 },
155 { BFD_RELOC_HI22, R_SPARC_HI22 },
156 { BFD_RELOC_LO10, R_SPARC_LO10, },
157 { BFD_RELOC_32_PCREL_S2, R_SPARC_WDISP30 },
158 { BFD_RELOC_SPARC_PLT32, R_SPARC_PLT32 },
159 { BFD_RELOC_SPARC22, R_SPARC_22 },
160 { BFD_RELOC_SPARC13, R_SPARC_13 },
161 { BFD_RELOC_SPARC_GOT10, R_SPARC_GOT10 },
162 { BFD_RELOC_SPARC_GOT13, R_SPARC_GOT13 },
163 { BFD_RELOC_SPARC_GOT22, R_SPARC_GOT22 },
164 { BFD_RELOC_SPARC_PC10, R_SPARC_PC10 },
165 { BFD_RELOC_SPARC_PC22, R_SPARC_PC22 },
166 { BFD_RELOC_SPARC_WPLT30, R_SPARC_WPLT30 },
167 { BFD_RELOC_SPARC_COPY, R_SPARC_COPY },
168 { BFD_RELOC_SPARC_GLOB_DAT, R_SPARC_GLOB_DAT },
169 { BFD_RELOC_SPARC_JMP_SLOT, R_SPARC_JMP_SLOT },
170 { BFD_RELOC_SPARC_RELATIVE, R_SPARC_RELATIVE },
171 { BFD_RELOC_SPARC_WDISP22, R_SPARC_WDISP22 },
172 { BFD_RELOC_SPARC_UA16, R_SPARC_UA16 },
173 { BFD_RELOC_SPARC_UA32, R_SPARC_UA32 },
174 { BFD_RELOC_SPARC_UA64, R_SPARC_UA64 },
175 { BFD_RELOC_SPARC_10, R_SPARC_10 },
176 { BFD_RELOC_SPARC_11, R_SPARC_11 },
177 { BFD_RELOC_SPARC_64, R_SPARC_64 },
178 { BFD_RELOC_SPARC_OLO10, R_SPARC_OLO10 },
179 { BFD_RELOC_SPARC_HH22, R_SPARC_HH22 },
180 { BFD_RELOC_SPARC_HM10, R_SPARC_HM10 },
181 { BFD_RELOC_SPARC_LM22, R_SPARC_LM22 },
182 { BFD_RELOC_SPARC_PC_HH22, R_SPARC_PC_HH22 },
183 { BFD_RELOC_SPARC_PC_HM10, R_SPARC_PC_HM10 },
184 { BFD_RELOC_SPARC_PC_LM22, R_SPARC_PC_LM22 },
185 { BFD_RELOC_SPARC_WDISP16, R_SPARC_WDISP16 },
186 { BFD_RELOC_SPARC_WDISP19, R_SPARC_WDISP19 },
187 { BFD_RELOC_SPARC_7, R_SPARC_7 },
188 { BFD_RELOC_SPARC_5, R_SPARC_5 },
189 { BFD_RELOC_SPARC_6, R_SPARC_6 },
190 { BFD_RELOC_SPARC_REV32, R_SPARC_REV32 },
191 { BFD_RELOC_VTABLE_INHERIT, R_SPARC_GNU_VTINHERIT },
192 { BFD_RELOC_VTABLE_ENTRY, R_SPARC_GNU_VTENTRY },
193 };
194
195 static reloc_howto_type *
196 elf32_sparc_reloc_type_lookup (abfd, code)
197 bfd *abfd ATTRIBUTE_UNUSED;
198 bfd_reloc_code_real_type code;
199 {
200 unsigned int i;
201
202 switch (code)
203 {
204 case BFD_RELOC_VTABLE_INHERIT:
205 return &elf32_sparc_vtinherit_howto;
206
207 case BFD_RELOC_VTABLE_ENTRY:
208 return &elf32_sparc_vtentry_howto;
209
210 default:
211 for (i = 0; i < sizeof (sparc_reloc_map) / sizeof (struct elf_reloc_map); i++)
212 {
213 if (sparc_reloc_map[i].bfd_reloc_val == code)
214 return &_bfd_sparc_elf_howto_table[(int) sparc_reloc_map[i].elf_reloc_val];
215 }
216 }
217 bfd_set_error (bfd_error_bad_value);
218 return NULL;
219 }
220
221 /* We need to use ELF32_R_TYPE so we have our own copy of this function,
222 and elf64-sparc.c has its own copy. */
223
224 static void
225 elf32_sparc_info_to_howto (abfd, cache_ptr, dst)
226 bfd *abfd ATTRIBUTE_UNUSED;
227 arelent *cache_ptr;
228 Elf_Internal_Rela *dst;
229 {
230 switch (ELF32_R_TYPE(dst->r_info))
231 {
232 case R_SPARC_GNU_VTINHERIT:
233 cache_ptr->howto = &elf32_sparc_vtinherit_howto;
234 break;
235
236 case R_SPARC_GNU_VTENTRY:
237 cache_ptr->howto = &elf32_sparc_vtentry_howto;
238 break;
239
240 default:
241 BFD_ASSERT (ELF32_R_TYPE(dst->r_info) < (unsigned int) R_SPARC_max_std);
242 cache_ptr->howto = &_bfd_sparc_elf_howto_table[ELF32_R_TYPE(dst->r_info)];
243 }
244 }
245 \f
246 /* For unsupported relocs. */
247
248 static bfd_reloc_status_type
249 sparc_elf_notsupported_reloc (abfd,
250 reloc_entry,
251 symbol,
252 data,
253 input_section,
254 output_bfd,
255 error_message)
256 bfd *abfd ATTRIBUTE_UNUSED;
257 arelent *reloc_entry ATTRIBUTE_UNUSED;
258 asymbol *symbol ATTRIBUTE_UNUSED;
259 PTR data ATTRIBUTE_UNUSED;
260 asection *input_section ATTRIBUTE_UNUSED;
261 bfd *output_bfd ATTRIBUTE_UNUSED;
262 char **error_message ATTRIBUTE_UNUSED;
263 {
264 return bfd_reloc_notsupported;
265 }
266
267 /* Handle the WDISP16 reloc. */
268
269 static bfd_reloc_status_type
270 sparc_elf_wdisp16_reloc (abfd,
271 reloc_entry,
272 symbol,
273 data,
274 input_section,
275 output_bfd,
276 error_message)
277 bfd *abfd;
278 arelent *reloc_entry;
279 asymbol *symbol;
280 PTR data;
281 asection *input_section;
282 bfd *output_bfd;
283 char **error_message ATTRIBUTE_UNUSED;
284 {
285 bfd_vma relocation;
286 bfd_vma x;
287
288 if (output_bfd != (bfd *) NULL
289 && (symbol->flags & BSF_SECTION_SYM) == 0
290 && (! reloc_entry->howto->partial_inplace
291 || reloc_entry->addend == 0))
292 {
293 reloc_entry->address += input_section->output_offset;
294 return bfd_reloc_ok;
295 }
296
297 if (output_bfd != NULL)
298 return bfd_reloc_continue;
299
300 if (reloc_entry->address > input_section->_cooked_size)
301 return bfd_reloc_outofrange;
302
303 relocation = (symbol->value
304 + symbol->section->output_section->vma
305 + symbol->section->output_offset);
306 relocation += reloc_entry->addend;
307 relocation -= (input_section->output_section->vma
308 + input_section->output_offset);
309 relocation -= reloc_entry->address;
310
311 x = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
312 x |= ((((relocation >> 2) & 0xc000) << 6)
313 | ((relocation >> 2) & 0x3fff));
314 bfd_put_32 (abfd, x, (bfd_byte *) data + reloc_entry->address);
315
316 if ((bfd_signed_vma) relocation < - 0x40000
317 || (bfd_signed_vma) relocation > 0x3ffff)
318 return bfd_reloc_overflow;
319 else
320 return bfd_reloc_ok;
321 }
322 \f
323 /* Functions for the SPARC ELF linker. */
324
325 /* The name of the dynamic interpreter. This is put in the .interp
326 section. */
327
328 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
329
330 /* The nop opcode we use. */
331
332 #define SPARC_NOP 0x01000000
333
334 /* The size in bytes of an entry in the procedure linkage table. */
335
336 #define PLT_ENTRY_SIZE 12
337
338 /* The first four entries in a procedure linkage table are reserved,
339 and the initial contents are unimportant (we zero them out).
340 Subsequent entries look like this. See the SVR4 ABI SPARC
341 supplement to see how this works. */
342
343 /* sethi %hi(.-.plt0),%g1. We fill in the address later. */
344 #define PLT_ENTRY_WORD0 0x03000000
345 /* b,a .plt0. We fill in the offset later. */
346 #define PLT_ENTRY_WORD1 0x30800000
347 /* nop. */
348 #define PLT_ENTRY_WORD2 SPARC_NOP
349
350 /* Look through the relocs for a section during the first phase, and
351 allocate space in the global offset table or procedure linkage
352 table. */
353
354 static boolean
355 elf32_sparc_check_relocs (abfd, info, sec, relocs)
356 bfd *abfd;
357 struct bfd_link_info *info;
358 asection *sec;
359 const Elf_Internal_Rela *relocs;
360 {
361 bfd *dynobj;
362 Elf_Internal_Shdr *symtab_hdr;
363 struct elf_link_hash_entry **sym_hashes;
364 bfd_vma *local_got_offsets;
365 const Elf_Internal_Rela *rel;
366 const Elf_Internal_Rela *rel_end;
367 asection *sgot;
368 asection *srelgot;
369 asection *sreloc;
370
371 if (info->relocateable)
372 return true;
373
374 dynobj = elf_hash_table (info)->dynobj;
375 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
376 sym_hashes = elf_sym_hashes (abfd);
377 local_got_offsets = elf_local_got_offsets (abfd);
378
379 sgot = NULL;
380 srelgot = NULL;
381 sreloc = NULL;
382
383 rel_end = relocs + sec->reloc_count;
384 for (rel = relocs; rel < rel_end; rel++)
385 {
386 unsigned long r_symndx;
387 struct elf_link_hash_entry *h;
388
389 r_symndx = ELF32_R_SYM (rel->r_info);
390 if (r_symndx < symtab_hdr->sh_info)
391 h = NULL;
392 else
393 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
394
395 switch (ELF32_R_TYPE (rel->r_info))
396 {
397 case R_SPARC_GOT10:
398 case R_SPARC_GOT13:
399 case R_SPARC_GOT22:
400 /* This symbol requires a global offset table entry. */
401
402 if (dynobj == NULL)
403 {
404 /* Create the .got section. */
405 elf_hash_table (info)->dynobj = dynobj = abfd;
406 if (! _bfd_elf_create_got_section (dynobj, info))
407 return false;
408 }
409
410 if (sgot == NULL)
411 {
412 sgot = bfd_get_section_by_name (dynobj, ".got");
413 BFD_ASSERT (sgot != NULL);
414 }
415
416 if (srelgot == NULL
417 && (h != NULL || info->shared))
418 {
419 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
420 if (srelgot == NULL)
421 {
422 srelgot = bfd_make_section (dynobj, ".rela.got");
423 if (srelgot == NULL
424 || ! bfd_set_section_flags (dynobj, srelgot,
425 (SEC_ALLOC
426 | SEC_LOAD
427 | SEC_HAS_CONTENTS
428 | SEC_IN_MEMORY
429 | SEC_LINKER_CREATED
430 | SEC_READONLY))
431 || ! bfd_set_section_alignment (dynobj, srelgot, 2))
432 return false;
433 }
434 }
435
436 if (h != NULL)
437 {
438 if (h->got.offset != (bfd_vma) -1)
439 {
440 /* We have already allocated space in the .got. */
441 break;
442 }
443 h->got.offset = sgot->_raw_size;
444
445 /* Make sure this symbol is output as a dynamic symbol. */
446 if (h->dynindx == -1)
447 {
448 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
449 return false;
450 }
451
452 srelgot->_raw_size += sizeof (Elf32_External_Rela);
453 }
454 else
455 {
456 /* This is a global offset table entry for a local
457 symbol. */
458 if (local_got_offsets == NULL)
459 {
460 bfd_size_type size;
461 register unsigned int i;
462
463 size = symtab_hdr->sh_info;
464 size *= sizeof (bfd_vma);
465 local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
466 if (local_got_offsets == NULL)
467 return false;
468 elf_local_got_offsets (abfd) = local_got_offsets;
469 for (i = 0; i < symtab_hdr->sh_info; i++)
470 local_got_offsets[i] = (bfd_vma) -1;
471 }
472 if (local_got_offsets[r_symndx] != (bfd_vma) -1)
473 {
474 /* We have already allocated space in the .got. */
475 break;
476 }
477 local_got_offsets[r_symndx] = sgot->_raw_size;
478
479 if (info->shared)
480 {
481 /* If we are generating a shared object, we need to
482 output a R_SPARC_RELATIVE reloc so that the
483 dynamic linker can adjust this GOT entry. */
484 srelgot->_raw_size += sizeof (Elf32_External_Rela);
485 }
486 }
487
488 sgot->_raw_size += 4;
489
490 /* If the .got section is more than 0x1000 bytes, we add
491 0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13
492 bit relocations have a greater chance of working. */
493 if (sgot->_raw_size >= 0x1000
494 && elf_hash_table (info)->hgot->root.u.def.value == 0)
495 elf_hash_table (info)->hgot->root.u.def.value = 0x1000;
496
497 break;
498
499 case R_SPARC_PLT32:
500 case R_SPARC_WPLT30:
501 /* This symbol requires a procedure linkage table entry. We
502 actually build the entry in adjust_dynamic_symbol,
503 because this might be a case of linking PIC code without
504 linking in any dynamic objects, in which case we don't
505 need to generate a procedure linkage table after all. */
506
507 if (h == NULL)
508 {
509 /* The Solaris native assembler will generate a WPLT30
510 reloc for a local symbol if you assemble a call from
511 one section to another when using -K pic. We treat
512 it as WDISP30. */
513 if (ELF32_R_TYPE (rel->r_info) != R_SPARC_WPLT30)
514 goto r_sparc_plt32;
515 break;
516 }
517
518 /* Make sure this symbol is output as a dynamic symbol. */
519 if (h->dynindx == -1)
520 {
521 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
522 return false;
523 }
524
525 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
526
527 if (ELF32_R_TYPE (rel->r_info) != R_SPARC_WPLT30)
528 goto r_sparc_plt32;
529 break;
530
531 case R_SPARC_PC10:
532 case R_SPARC_PC22:
533 if (h != NULL)
534 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
535
536 if (h != NULL
537 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
538 break;
539 /* Fall through. */
540 case R_SPARC_DISP8:
541 case R_SPARC_DISP16:
542 case R_SPARC_DISP32:
543 case R_SPARC_WDISP30:
544 case R_SPARC_WDISP22:
545 case R_SPARC_WDISP19:
546 case R_SPARC_WDISP16:
547 if (h != NULL)
548 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
549
550 /* If we are linking with -Bsymbolic, we do not need to copy
551 a PC relative reloc against a global symbol which is
552 defined in an object we are including in the link (i.e.,
553 DEF_REGULAR is set). FIXME: At this point we have not
554 seen all the input files, so it is possible that
555 DEF_REGULAR is not set now but will be set later (it is
556 never cleared). This needs to be handled as in
557 elf32-i386.c. */
558 if (h == NULL
559 || (info->symbolic
560 && (h->elf_link_hash_flags
561 & ELF_LINK_HASH_DEF_REGULAR) != 0))
562 break;
563 /* Fall through. */
564 case R_SPARC_8:
565 case R_SPARC_16:
566 case R_SPARC_32:
567 case R_SPARC_HI22:
568 case R_SPARC_22:
569 case R_SPARC_13:
570 case R_SPARC_LO10:
571 case R_SPARC_UA16:
572 case R_SPARC_UA32:
573 if (h != NULL)
574 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
575
576 r_sparc_plt32:
577 if (info->shared && (sec->flags & SEC_ALLOC))
578 {
579 /* When creating a shared object, we must copy these
580 relocs into the output file. We create a reloc
581 section in dynobj and make room for the reloc. */
582 if (sreloc == NULL)
583 {
584 const char *name;
585
586 name = (bfd_elf_string_from_elf_section
587 (abfd,
588 elf_elfheader (abfd)->e_shstrndx,
589 elf_section_data (sec)->rel_hdr.sh_name));
590 if (name == NULL)
591 return false;
592
593 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
594 && strcmp (bfd_get_section_name (abfd, sec),
595 name + 5) == 0);
596
597 sreloc = bfd_get_section_by_name (dynobj, name);
598 if (sreloc == NULL)
599 {
600 flagword flags;
601
602 sreloc = bfd_make_section (dynobj, name);
603 flags = (SEC_HAS_CONTENTS | SEC_READONLY
604 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
605 if ((sec->flags & SEC_ALLOC) != 0)
606 flags |= SEC_ALLOC | SEC_LOAD;
607 if (sreloc == NULL
608 || ! bfd_set_section_flags (dynobj, sreloc, flags)
609 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
610 return false;
611 }
612 if (sec->flags & SEC_READONLY)
613 info->flags |= DF_TEXTREL;
614 }
615
616 sreloc->_raw_size += sizeof (Elf32_External_Rela);
617 }
618
619 break;
620
621 case R_SPARC_GNU_VTINHERIT:
622 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
623 return false;
624 break;
625
626 case R_SPARC_GNU_VTENTRY:
627 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
628 return false;
629 break;
630
631 default:
632 break;
633 }
634 }
635
636 return true;
637 }
638
639 static asection *
640 elf32_sparc_gc_mark_hook (abfd, info, rel, h, sym)
641 bfd *abfd;
642 struct bfd_link_info *info ATTRIBUTE_UNUSED;
643 Elf_Internal_Rela *rel;
644 struct elf_link_hash_entry *h;
645 Elf_Internal_Sym *sym;
646 {
647
648 if (h != NULL)
649 {
650 switch (ELF32_R_TYPE (rel->r_info))
651 {
652 case R_SPARC_GNU_VTINHERIT:
653 case R_SPARC_GNU_VTENTRY:
654 break;
655
656 default:
657 switch (h->root.type)
658 {
659 case bfd_link_hash_defined:
660 case bfd_link_hash_defweak:
661 return h->root.u.def.section;
662
663 case bfd_link_hash_common:
664 return h->root.u.c.p->section;
665
666 default:
667 break;
668 }
669 }
670 }
671 else
672 {
673 return bfd_section_from_elf_index (abfd, sym->st_shndx);
674 }
675
676 return NULL;
677 }
678
679 /* Update the got entry reference counts for the section being removed. */
680 static boolean
681 elf32_sparc_gc_sweep_hook (abfd, info, sec, relocs)
682 bfd *abfd;
683 struct bfd_link_info *info ATTRIBUTE_UNUSED;
684 asection *sec;
685 const Elf_Internal_Rela *relocs;
686 {
687
688 Elf_Internal_Shdr *symtab_hdr;
689 struct elf_link_hash_entry **sym_hashes;
690 bfd_signed_vma *local_got_refcounts;
691 const Elf_Internal_Rela *rel, *relend;
692 unsigned long r_symndx;
693 struct elf_link_hash_entry *h;
694
695 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
696 sym_hashes = elf_sym_hashes (abfd);
697 local_got_refcounts = elf_local_got_refcounts (abfd);
698
699 relend = relocs + sec->reloc_count;
700 for (rel = relocs; rel < relend; rel++)
701 switch (ELF32_R_TYPE (rel->r_info))
702 {
703 case R_SPARC_GOT10:
704 case R_SPARC_GOT13:
705 case R_SPARC_GOT22:
706 r_symndx = ELF32_R_SYM (rel->r_info);
707 if (r_symndx >= symtab_hdr->sh_info)
708 {
709 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
710 if (h->got.refcount > 0)
711 h->got.refcount--;
712 }
713 else
714 {
715 if (local_got_refcounts[r_symndx] > 0)
716 local_got_refcounts[r_symndx]--;
717 }
718 break;
719
720 case R_SPARC_PLT32:
721 case R_SPARC_HIPLT22:
722 case R_SPARC_LOPLT10:
723 case R_SPARC_PCPLT32:
724 case R_SPARC_PCPLT10:
725 r_symndx = ELF32_R_SYM (rel->r_info);
726 if (r_symndx >= symtab_hdr->sh_info)
727 {
728 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
729 if (h->plt.refcount > 0)
730 h->plt.refcount--;
731 }
732 break;
733
734 default:
735 break;
736 }
737
738 return true;
739 }
740
741 /* Adjust a symbol defined by a dynamic object and referenced by a
742 regular object. The current definition is in some section of the
743 dynamic object, but we're not including those sections. We have to
744 change the definition to something the rest of the link can
745 understand. */
746
747 static boolean
748 elf32_sparc_adjust_dynamic_symbol (info, h)
749 struct bfd_link_info *info;
750 struct elf_link_hash_entry *h;
751 {
752 bfd *dynobj;
753 asection *s;
754 unsigned int power_of_two;
755
756 dynobj = elf_hash_table (info)->dynobj;
757
758 /* Make sure we know what is going on here. */
759 BFD_ASSERT (dynobj != NULL
760 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
761 || h->weakdef != NULL
762 || ((h->elf_link_hash_flags
763 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
764 && (h->elf_link_hash_flags
765 & ELF_LINK_HASH_REF_REGULAR) != 0
766 && (h->elf_link_hash_flags
767 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
768
769 /* If this is a function, put it in the procedure linkage table. We
770 will fill in the contents of the procedure linkage table later
771 (although we could actually do it here). The STT_NOTYPE
772 condition is a hack specifically for the Oracle libraries
773 delivered for Solaris; for some inexplicable reason, they define
774 some of their functions as STT_NOTYPE when they really should be
775 STT_FUNC. */
776 if (h->type == STT_FUNC
777 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0
778 || (h->type == STT_NOTYPE
779 && (h->root.type == bfd_link_hash_defined
780 || h->root.type == bfd_link_hash_defweak)
781 && (h->root.u.def.section->flags & SEC_CODE) != 0))
782 {
783 if (! elf_hash_table (info)->dynamic_sections_created
784 || ((!info->shared || info->symbolic || h->dynindx == -1)
785 && (h->elf_link_hash_flags
786 & ELF_LINK_HASH_DEF_REGULAR) != 0))
787 {
788 /* This case can occur if we saw a WPLT30 reloc in an input
789 file, but none of the input files were dynamic objects.
790 Or, when linking the main application or a -Bsymbolic
791 shared library against PIC code. Or when a global symbol
792 has been made private, e.g. via versioning.
793
794 In these cases we know what value the symbol will resolve
795 to, so we don't actually need to build a procedure linkage
796 table, and we can just do a WDISP30 reloc instead. */
797
798 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
799 return true;
800 }
801
802 s = bfd_get_section_by_name (dynobj, ".plt");
803 BFD_ASSERT (s != NULL);
804
805 /* The first four entries in .plt are reserved. */
806 if (s->_raw_size == 0)
807 s->_raw_size = 4 * PLT_ENTRY_SIZE;
808
809 /* The procedure linkage table has a maximum size. */
810 if (s->_raw_size >= 0x400000)
811 {
812 bfd_set_error (bfd_error_bad_value);
813 return false;
814 }
815
816 /* If this symbol is not defined in a regular file, and we are
817 not generating a shared library, then set the symbol to this
818 location in the .plt. This is required to make function
819 pointers compare as equal between the normal executable and
820 the shared library. */
821 if (! info->shared
822 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
823 {
824 h->root.u.def.section = s;
825 h->root.u.def.value = s->_raw_size;
826 }
827
828 h->plt.offset = s->_raw_size;
829
830 /* Make room for this entry. */
831 s->_raw_size += PLT_ENTRY_SIZE;
832
833 /* We also need to make an entry in the .rela.plt section. */
834
835 s = bfd_get_section_by_name (dynobj, ".rela.plt");
836 BFD_ASSERT (s != NULL);
837 s->_raw_size += sizeof (Elf32_External_Rela);
838
839 return true;
840 }
841
842 /* If this is a weak symbol, and there is a real definition, the
843 processor independent code will have arranged for us to see the
844 real definition first, and we can just use the same value. */
845 if (h->weakdef != NULL)
846 {
847 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
848 || h->weakdef->root.type == bfd_link_hash_defweak);
849 h->root.u.def.section = h->weakdef->root.u.def.section;
850 h->root.u.def.value = h->weakdef->root.u.def.value;
851 return true;
852 }
853
854 /* This is a reference to a symbol defined by a dynamic object which
855 is not a function. */
856
857 /* If we are creating a shared library, we must presume that the
858 only references to the symbol are via the global offset table.
859 For such cases we need not do anything here; the relocations will
860 be handled correctly by relocate_section. */
861 if (info->shared)
862 return true;
863
864 /* If there are no references to this symbol that do not use the
865 GOT, we don't need to generate a copy reloc. */
866 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
867 return true;
868
869 /* We must allocate the symbol in our .dynbss section, which will
870 become part of the .bss section of the executable. There will be
871 an entry for this symbol in the .dynsym section. The dynamic
872 object will contain position independent code, so all references
873 from the dynamic object to this symbol will go through the global
874 offset table. The dynamic linker will use the .dynsym entry to
875 determine the address it must put in the global offset table, so
876 both the dynamic object and the regular object will refer to the
877 same memory location for the variable. */
878
879 s = bfd_get_section_by_name (dynobj, ".dynbss");
880 BFD_ASSERT (s != NULL);
881
882 /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker
883 to copy the initial value out of the dynamic object and into the
884 runtime process image. We need to remember the offset into the
885 .rel.bss section we are going to use. */
886 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
887 {
888 asection *srel;
889
890 srel = bfd_get_section_by_name (dynobj, ".rela.bss");
891 BFD_ASSERT (srel != NULL);
892 srel->_raw_size += sizeof (Elf32_External_Rela);
893 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
894 }
895
896 /* We need to figure out the alignment required for this symbol. I
897 have no idea how ELF linkers handle this. */
898 power_of_two = bfd_log2 (h->size);
899 if (power_of_two > 3)
900 power_of_two = 3;
901
902 /* Apply the required alignment. */
903 s->_raw_size = BFD_ALIGN (s->_raw_size,
904 (bfd_size_type) (1 << power_of_two));
905 if (power_of_two > bfd_get_section_alignment (dynobj, s))
906 {
907 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
908 return false;
909 }
910
911 /* Define the symbol as being at this point in the section. */
912 h->root.u.def.section = s;
913 h->root.u.def.value = s->_raw_size;
914
915 /* Increment the section size to make room for the symbol. */
916 s->_raw_size += h->size;
917
918 return true;
919 }
920
921 /* Set the sizes of the dynamic sections. */
922
923 static boolean
924 elf32_sparc_size_dynamic_sections (output_bfd, info)
925 bfd *output_bfd ATTRIBUTE_UNUSED;
926 struct bfd_link_info *info;
927 {
928 bfd *dynobj;
929 asection *s;
930 boolean relplt;
931
932 dynobj = elf_hash_table (info)->dynobj;
933 BFD_ASSERT (dynobj != NULL);
934
935 if (elf_hash_table (info)->dynamic_sections_created)
936 {
937 /* Set the contents of the .interp section to the interpreter. */
938 if (! info->shared)
939 {
940 s = bfd_get_section_by_name (dynobj, ".interp");
941 BFD_ASSERT (s != NULL);
942 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
943 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
944 }
945
946 /* Make space for the trailing nop in .plt. */
947 s = bfd_get_section_by_name (dynobj, ".plt");
948 BFD_ASSERT (s != NULL);
949 if (s->_raw_size > 0)
950 s->_raw_size += 4;
951 }
952 else
953 {
954 /* We may have created entries in the .rela.got section.
955 However, if we are not creating the dynamic sections, we will
956 not actually use these entries. Reset the size of .rela.got,
957 which will cause it to get stripped from the output file
958 below. */
959 s = bfd_get_section_by_name (dynobj, ".rela.got");
960 if (s != NULL)
961 s->_raw_size = 0;
962 }
963
964 /* The check_relocs and adjust_dynamic_symbol entry points have
965 determined the sizes of the various dynamic sections. Allocate
966 memory for them. */
967 relplt = false;
968 for (s = dynobj->sections; s != NULL; s = s->next)
969 {
970 const char *name;
971 boolean strip;
972
973 if ((s->flags & SEC_LINKER_CREATED) == 0)
974 continue;
975
976 /* It's OK to base decisions on the section name, because none
977 of the dynobj section names depend upon the input files. */
978 name = bfd_get_section_name (dynobj, s);
979
980 strip = false;
981
982 if (strncmp (name, ".rela", 5) == 0)
983 {
984 if (s->_raw_size == 0)
985 {
986 /* If we don't need this section, strip it from the
987 output file. This is to handle .rela.bss and
988 .rel.plt. We must create it in
989 create_dynamic_sections, because it must be created
990 before the linker maps input sections to output
991 sections. The linker does that before
992 adjust_dynamic_symbol is called, and it is that
993 function which decides whether anything needs to go
994 into these sections. */
995 strip = true;
996 }
997 else
998 {
999 if (strcmp (name, ".rela.plt") == 0)
1000 relplt = true;
1001
1002 /* We use the reloc_count field as a counter if we need
1003 to copy relocs into the output file. */
1004 s->reloc_count = 0;
1005 }
1006 }
1007 else if (strcmp (name, ".plt") != 0
1008 && strcmp (name, ".got") != 0)
1009 {
1010 /* It's not one of our sections, so don't allocate space. */
1011 continue;
1012 }
1013
1014 if (strip)
1015 {
1016 _bfd_strip_section_from_output (info, s);
1017 continue;
1018 }
1019
1020 /* Allocate memory for the section contents. */
1021 /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
1022 Unused entries should be reclaimed before the section's contents
1023 are written out, but at the moment this does not happen. Thus in
1024 order to prevent writing out garbage, we initialise the section's
1025 contents to zero. */
1026 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
1027 if (s->contents == NULL && s->_raw_size != 0)
1028 return false;
1029 }
1030
1031 if (elf_hash_table (info)->dynamic_sections_created)
1032 {
1033 /* Add some entries to the .dynamic section. We fill in the
1034 values later, in elf32_sparc_finish_dynamic_sections, but we
1035 must add the entries now so that we get the correct size for
1036 the .dynamic section. The DT_DEBUG entry is filled in by the
1037 dynamic linker and used by the debugger. */
1038 #define add_dynamic_entry(TAG, VAL) \
1039 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1040
1041 if (!info->shared)
1042 {
1043 if (!add_dynamic_entry (DT_DEBUG, 0))
1044 return false;
1045 }
1046
1047 if (relplt)
1048 {
1049 if (!add_dynamic_entry (DT_PLTGOT, 0)
1050 || !add_dynamic_entry (DT_PLTRELSZ, 0)
1051 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1052 || !add_dynamic_entry (DT_JMPREL, 0))
1053 return false;
1054 }
1055
1056 if (!add_dynamic_entry (DT_RELA, 0)
1057 || !add_dynamic_entry (DT_RELASZ, 0)
1058 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
1059 return false;
1060
1061 if (info->flags & DF_TEXTREL)
1062 {
1063 if (!add_dynamic_entry (DT_TEXTREL, 0))
1064 return false;
1065 }
1066 }
1067 #undef add_dynamic_entry
1068
1069 return true;
1070 }
1071
1072 #define SET_SEC_DO_RELAX(section) do { elf_section_data(section)->tdata = (void *)1; } while (0)
1073 #define SEC_DO_RELAX(section) (elf_section_data(section)->tdata == (void *)1)
1074
1075 static boolean
1076 elf32_sparc_relax_section (abfd, section, link_info, again)
1077 bfd *abfd ATTRIBUTE_UNUSED;
1078 asection *section ATTRIBUTE_UNUSED;
1079 struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
1080 boolean *again;
1081 {
1082 *again = false;
1083 SET_SEC_DO_RELAX (section);
1084 return true;
1085 }
1086
1087 /* This is the condition under which finish_dynamic_symbol will be called
1088 from elflink.h. If elflink.h doesn't call our finish_dynamic_symbol
1089 routine, we'll need to do something about initializing any .plt and .got
1090 entries in relocate_section. */
1091 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
1092 ((DYN) \
1093 && ((INFO)->shared \
1094 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
1095 && ((H)->dynindx != -1 \
1096 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1097
1098 /* Relocate a SPARC ELF section. */
1099
1100 static boolean
1101 elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section,
1102 contents, relocs, local_syms, local_sections)
1103 bfd *output_bfd;
1104 struct bfd_link_info *info;
1105 bfd *input_bfd;
1106 asection *input_section;
1107 bfd_byte *contents;
1108 Elf_Internal_Rela *relocs;
1109 Elf_Internal_Sym *local_syms;
1110 asection **local_sections;
1111 {
1112 bfd *dynobj;
1113 Elf_Internal_Shdr *symtab_hdr;
1114 struct elf_link_hash_entry **sym_hashes;
1115 bfd_vma *local_got_offsets;
1116 bfd_vma got_base;
1117 asection *sgot;
1118 asection *splt;
1119 asection *sreloc;
1120 Elf_Internal_Rela *rel;
1121 Elf_Internal_Rela *relend;
1122
1123 dynobj = elf_hash_table (info)->dynobj;
1124 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1125 sym_hashes = elf_sym_hashes (input_bfd);
1126 local_got_offsets = elf_local_got_offsets (input_bfd);
1127
1128 if (elf_hash_table (info)->hgot == NULL)
1129 got_base = 0;
1130 else
1131 got_base = elf_hash_table (info)->hgot->root.u.def.value;
1132
1133 sgot = NULL;
1134 splt = NULL;
1135 sreloc = NULL;
1136
1137 rel = relocs;
1138 relend = relocs + input_section->reloc_count;
1139 for (; rel < relend; rel++)
1140 {
1141 int r_type;
1142 reloc_howto_type *howto;
1143 unsigned long r_symndx;
1144 struct elf_link_hash_entry *h;
1145 Elf_Internal_Sym *sym;
1146 asection *sec;
1147 bfd_vma relocation, off;
1148 bfd_reloc_status_type r;
1149 boolean is_plt = false;
1150 boolean unresolved_reloc;
1151
1152 r_type = ELF32_R_TYPE (rel->r_info);
1153
1154 if (r_type == R_SPARC_GNU_VTINHERIT
1155 || r_type == R_SPARC_GNU_VTENTRY)
1156 continue;
1157
1158 if (r_type < 0 || r_type >= (int) R_SPARC_max_std)
1159 {
1160 bfd_set_error (bfd_error_bad_value);
1161 return false;
1162 }
1163 howto = _bfd_sparc_elf_howto_table + r_type;
1164
1165 r_symndx = ELF32_R_SYM (rel->r_info);
1166
1167 if (info->relocateable)
1168 {
1169 /* This is a relocateable link. We don't have to change
1170 anything, unless the reloc is against a section symbol,
1171 in which case we have to adjust according to where the
1172 section symbol winds up in the output section. */
1173 if (r_symndx < symtab_hdr->sh_info)
1174 {
1175 sym = local_syms + r_symndx;
1176 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1177 {
1178 sec = local_sections[r_symndx];
1179 rel->r_addend += sec->output_offset + sym->st_value;
1180 }
1181 }
1182
1183 continue;
1184 }
1185
1186 /* This is a final link. */
1187 h = NULL;
1188 sym = NULL;
1189 sec = NULL;
1190 unresolved_reloc = false;
1191 if (r_symndx < symtab_hdr->sh_info)
1192 {
1193 sym = local_syms + r_symndx;
1194 sec = local_sections[r_symndx];
1195 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
1196 }
1197 else
1198 {
1199 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1200 while (h->root.type == bfd_link_hash_indirect
1201 || h->root.type == bfd_link_hash_warning)
1202 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1203
1204 relocation = 0;
1205 if (h->root.type == bfd_link_hash_defined
1206 || h->root.type == bfd_link_hash_defweak)
1207 {
1208 sec = h->root.u.def.section;
1209 if (sec->output_section == NULL)
1210 /* Set a flag that will be cleared later if we find a
1211 relocation value for this symbol. output_section
1212 is typically NULL for symbols satisfied by a shared
1213 library. */
1214 unresolved_reloc = true;
1215 else
1216 relocation = (h->root.u.def.value
1217 + sec->output_section->vma
1218 + sec->output_offset);
1219 }
1220 else if (h->root.type == bfd_link_hash_undefweak)
1221 ;
1222 else if (info->shared
1223 && (!info->symbolic || info->allow_shlib_undefined)
1224 && !info->no_undefined
1225 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1226 ;
1227 else
1228 {
1229 if (! ((*info->callbacks->undefined_symbol)
1230 (info, h->root.root.string, input_bfd,
1231 input_section, rel->r_offset,
1232 (!info->shared || info->no_undefined
1233 || ELF_ST_VISIBILITY (h->other)))))
1234 return false;
1235 }
1236 }
1237
1238 switch (r_type)
1239 {
1240 case R_SPARC_GOT10:
1241 case R_SPARC_GOT13:
1242 case R_SPARC_GOT22:
1243 /* Relocation is to the entry for this symbol in the global
1244 offset table. */
1245 if (sgot == NULL)
1246 {
1247 sgot = bfd_get_section_by_name (dynobj, ".got");
1248 BFD_ASSERT (sgot != NULL);
1249 }
1250
1251 if (h != NULL)
1252 {
1253 boolean dyn;
1254
1255 off = h->got.offset;
1256 BFD_ASSERT (off != (bfd_vma) -1);
1257 dyn = elf_hash_table (info)->dynamic_sections_created;
1258
1259 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h)
1260 || (info->shared
1261 && (info->symbolic
1262 || h->dynindx == -1
1263 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
1264 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1265 {
1266 /* This is actually a static link, or it is a
1267 -Bsymbolic link and the symbol is defined
1268 locally, or the symbol was forced to be local
1269 because of a version file. We must initialize
1270 this entry in the global offset table. Since the
1271 offset must always be a multiple of 4, we use the
1272 least significant bit to record whether we have
1273 initialized it already.
1274
1275 When doing a dynamic link, we create a .rela.got
1276 relocation entry to initialize the value. This
1277 is done in the finish_dynamic_symbol routine. */
1278 if ((off & 1) != 0)
1279 off &= ~1;
1280 else
1281 {
1282 bfd_put_32 (output_bfd, relocation,
1283 sgot->contents + off);
1284 h->got.offset |= 1;
1285 }
1286 }
1287 else
1288 unresolved_reloc = false;
1289 }
1290 else
1291 {
1292 BFD_ASSERT (local_got_offsets != NULL
1293 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1294
1295 off = local_got_offsets[r_symndx];
1296
1297 /* The offset must always be a multiple of 4. We use
1298 the least significant bit to record whether we have
1299 already processed this entry. */
1300 if ((off & 1) != 0)
1301 off &= ~1;
1302 else
1303 {
1304 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1305
1306 if (info->shared)
1307 {
1308 asection *srelgot;
1309 Elf_Internal_Rela outrel;
1310
1311 /* We need to generate a R_SPARC_RELATIVE reloc
1312 for the dynamic linker. */
1313 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1314 BFD_ASSERT (srelgot != NULL);
1315
1316 outrel.r_offset = (sgot->output_section->vma
1317 + sgot->output_offset
1318 + off);
1319 outrel.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
1320 outrel.r_addend = 0;
1321 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1322 (((Elf32_External_Rela *)
1323 srelgot->contents)
1324 + srelgot->reloc_count));
1325 ++srelgot->reloc_count;
1326 }
1327
1328 local_got_offsets[r_symndx] |= 1;
1329 }
1330 }
1331 relocation = sgot->output_offset + off - got_base;
1332 break;
1333
1334 case R_SPARC_PLT32:
1335 if (h == NULL || h->plt.offset == (bfd_vma) -1)
1336 {
1337 r_type = R_SPARC_32;
1338 goto r_sparc_plt32;
1339 }
1340 /* Fall through. */
1341 case R_SPARC_WPLT30:
1342 /* Relocation is to the entry for this symbol in the
1343 procedure linkage table. */
1344
1345 /* The Solaris native assembler will generate a WPLT30 reloc
1346 for a local symbol if you assemble a call from one
1347 section to another when using -K pic. We treat it as
1348 WDISP30. */
1349 if (h == NULL)
1350 break;
1351
1352 if (h->plt.offset == (bfd_vma) -1)
1353 {
1354 /* We didn't make a PLT entry for this symbol. This
1355 happens when statically linking PIC code, or when
1356 using -Bsymbolic. */
1357 break;
1358 }
1359
1360 if (splt == NULL)
1361 {
1362 splt = bfd_get_section_by_name (dynobj, ".plt");
1363 BFD_ASSERT (splt != NULL);
1364 }
1365
1366 relocation = (splt->output_section->vma
1367 + splt->output_offset
1368 + h->plt.offset);
1369 unresolved_reloc = false;
1370 if (r_type == R_SPARC_PLT32)
1371 {
1372 r_type = R_SPARC_32;
1373 is_plt = true;
1374 goto r_sparc_plt32;
1375 }
1376 break;
1377
1378 case R_SPARC_PC10:
1379 case R_SPARC_PC22:
1380 if (h != NULL
1381 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1382 break;
1383 /* Fall through. */
1384 case R_SPARC_DISP8:
1385 case R_SPARC_DISP16:
1386 case R_SPARC_DISP32:
1387 case R_SPARC_WDISP30:
1388 case R_SPARC_WDISP22:
1389 case R_SPARC_WDISP19:
1390 case R_SPARC_WDISP16:
1391 if (h == NULL
1392 || (info->symbolic
1393 && (h->elf_link_hash_flags
1394 & ELF_LINK_HASH_DEF_REGULAR) != 0))
1395 break;
1396 /* Fall through. */
1397 case R_SPARC_8:
1398 case R_SPARC_16:
1399 case R_SPARC_32:
1400 case R_SPARC_HI22:
1401 case R_SPARC_22:
1402 case R_SPARC_13:
1403 case R_SPARC_LO10:
1404 case R_SPARC_UA16:
1405 case R_SPARC_UA32:
1406 r_sparc_plt32:
1407 if (info->shared
1408 && r_symndx != 0
1409 && (input_section->flags & SEC_ALLOC))
1410 {
1411 Elf_Internal_Rela outrel;
1412 boolean skip, relocate = false;
1413
1414 /* When generating a shared object, these relocations
1415 are copied into the output file to be resolved at run
1416 time. */
1417
1418 if (sreloc == NULL)
1419 {
1420 const char *name;
1421
1422 name = (bfd_elf_string_from_elf_section
1423 (input_bfd,
1424 elf_elfheader (input_bfd)->e_shstrndx,
1425 elf_section_data (input_section)->rel_hdr.sh_name));
1426 if (name == NULL)
1427 return false;
1428
1429 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
1430 && strcmp (bfd_get_section_name (input_bfd,
1431 input_section),
1432 name + 5) == 0);
1433
1434 sreloc = bfd_get_section_by_name (dynobj, name);
1435 BFD_ASSERT (sreloc != NULL);
1436 }
1437
1438 skip = false;
1439
1440 outrel.r_offset =
1441 _bfd_elf_section_offset (output_bfd, info, input_section,
1442 rel->r_offset);
1443 if (outrel.r_offset == (bfd_vma) -1)
1444 skip = true;
1445 else if (outrel.r_offset == (bfd_vma) -2)
1446 skip = true, relocate = true;
1447 outrel.r_offset += (input_section->output_section->vma
1448 + input_section->output_offset);
1449
1450 /* Optimize unaligned reloc usage now that we know where
1451 it finally resides. */
1452 switch (r_type)
1453 {
1454 case R_SPARC_16:
1455 if (outrel.r_offset & 1)
1456 r_type = R_SPARC_UA16;
1457 break;
1458 case R_SPARC_UA16:
1459 if (!(outrel.r_offset & 1))
1460 r_type = R_SPARC_16;
1461 break;
1462 case R_SPARC_32:
1463 if (outrel.r_offset & 3)
1464 r_type = R_SPARC_UA32;
1465 break;
1466 case R_SPARC_UA32:
1467 if (!(outrel.r_offset & 3))
1468 r_type = R_SPARC_32;
1469 break;
1470 }
1471
1472 if (skip)
1473 memset (&outrel, 0, sizeof outrel);
1474 /* h->dynindx may be -1 if the symbol was marked to
1475 become local. */
1476 else if (h != NULL && ! is_plt
1477 && ((! info->symbolic && h->dynindx != -1)
1478 || (h->elf_link_hash_flags
1479 & ELF_LINK_HASH_DEF_REGULAR) == 0))
1480 {
1481 BFD_ASSERT (h->dynindx != -1);
1482 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1483 outrel.r_addend = rel->r_addend;
1484 }
1485 else
1486 {
1487 if (r_type == R_SPARC_32)
1488 {
1489 outrel.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
1490 outrel.r_addend = relocation + rel->r_addend;
1491 }
1492 else
1493 {
1494 long indx;
1495
1496 if (is_plt)
1497 sec = splt;
1498 else if (h == NULL)
1499 sec = local_sections[r_symndx];
1500 else
1501 {
1502 BFD_ASSERT (h->root.type == bfd_link_hash_defined
1503 || (h->root.type
1504 == bfd_link_hash_defweak));
1505 sec = h->root.u.def.section;
1506 }
1507 if (sec != NULL && bfd_is_abs_section (sec))
1508 indx = 0;
1509 else if (sec == NULL || sec->owner == NULL)
1510 {
1511 bfd_set_error (bfd_error_bad_value);
1512 return false;
1513 }
1514 else
1515 {
1516 asection *osec;
1517
1518 osec = sec->output_section;
1519 indx = elf_section_data (osec)->dynindx;
1520
1521 /* FIXME: we really should be able to link non-pic
1522 shared libraries. */
1523 if (indx == 0)
1524 {
1525 BFD_FAIL ();
1526 (*_bfd_error_handler)
1527 (_("%s: probably compiled without -fPIC?"),
1528 bfd_archive_filename (input_bfd));
1529 bfd_set_error (bfd_error_bad_value);
1530 return false;
1531 }
1532 }
1533
1534 outrel.r_info = ELF32_R_INFO (indx, r_type);
1535 outrel.r_addend = relocation + rel->r_addend;
1536 }
1537 }
1538
1539 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1540 (((Elf32_External_Rela *)
1541 sreloc->contents)
1542 + sreloc->reloc_count));
1543 ++sreloc->reloc_count;
1544
1545 /* This reloc will be computed at runtime, so there's no
1546 need to do anything now. */
1547 if (! relocate)
1548 continue;
1549 }
1550 break;
1551
1552 default:
1553 break;
1554 }
1555
1556 /* ??? Copied from elf32-i386.c, debugging section check and all. */
1557 if (unresolved_reloc
1558 && !(info->shared
1559 && (input_section->flags & SEC_DEBUGGING) != 0
1560 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
1561 (*_bfd_error_handler)
1562 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
1563 bfd_archive_filename (input_bfd),
1564 bfd_get_section_name (input_bfd, input_section),
1565 (long) rel->r_offset,
1566 h->root.root.string);
1567
1568 r = bfd_reloc_continue;
1569 if (r_type == R_SPARC_WDISP16)
1570 {
1571 bfd_vma x;
1572
1573 relocation += rel->r_addend;
1574 relocation -= (input_section->output_section->vma
1575 + input_section->output_offset);
1576 relocation -= rel->r_offset;
1577
1578 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
1579 x |= ((((relocation >> 2) & 0xc000) << 6)
1580 | ((relocation >> 2) & 0x3fff));
1581 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
1582
1583 if ((bfd_signed_vma) relocation < - 0x40000
1584 || (bfd_signed_vma) relocation > 0x3ffff)
1585 r = bfd_reloc_overflow;
1586 else
1587 r = bfd_reloc_ok;
1588 }
1589 else if (r_type == R_SPARC_REV32)
1590 {
1591 bfd_vma x;
1592
1593 relocation = relocation + rel->r_addend;
1594
1595 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
1596 x = x + relocation;
1597 bfd_putl32 (/*input_bfd,*/ x, contents + rel->r_offset);
1598 r = bfd_reloc_ok;
1599 }
1600 else if ((r_type == R_SPARC_WDISP30 || r_type == R_SPARC_WPLT30)
1601 && SEC_DO_RELAX (input_section)
1602 && rel->r_offset + 4 < input_section->_raw_size)
1603 {
1604 #define G0 0
1605 #define O7 15
1606 #define XCC (2 << 20)
1607 #define COND(x) (((x)&0xf)<<25)
1608 #define CONDA COND(0x8)
1609 #define INSN_BPA (F2(0,1) | CONDA | BPRED | XCC)
1610 #define INSN_BA (F2(0,2) | CONDA)
1611 #define INSN_OR F3(2, 0x2, 0)
1612 #define INSN_NOP F2(0,4)
1613
1614 bfd_vma x, y;
1615
1616 /* If the instruction is a call with either:
1617 restore
1618 arithmetic instruction with rd == %o7
1619 where rs1 != %o7 and rs2 if it is register != %o7
1620 then we can optimize if the call destination is near
1621 by changing the call into a branch always. */
1622 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
1623 y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
1624 if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2))
1625 {
1626 if (((y & OP3(~0)) == OP3(0x3d) /* restore */
1627 || ((y & OP3(0x28)) == 0 /* arithmetic */
1628 && (y & RD(~0)) == RD(O7)))
1629 && (y & RS1(~0)) != RS1(O7)
1630 && ((y & F3I(~0))
1631 || (y & RS2(~0)) != RS2(O7)))
1632 {
1633 bfd_vma reloc;
1634
1635 reloc = relocation + rel->r_addend - rel->r_offset;
1636 reloc -= (input_section->output_section->vma
1637 + input_section->output_offset);
1638
1639 /* Ensure the reloc fits into simm22. */
1640 if ((reloc & 3) == 0
1641 && ((reloc & ~(bfd_vma)0x7fffff) == 0
1642 || ((reloc | 0x7fffff) == ~(bfd_vma)0)))
1643 {
1644 reloc >>= 2;
1645
1646 /* Check whether it fits into simm19 on v9. */
1647 if (((reloc & 0x3c0000) == 0
1648 || (reloc & 0x3c0000) == 0x3c0000)
1649 && (elf_elfheader (output_bfd)->e_flags & EF_SPARC_32PLUS))
1650 x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */
1651 else
1652 x = INSN_BA | (reloc & 0x3fffff); /* ba */
1653 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
1654 r = bfd_reloc_ok;
1655 if (rel->r_offset >= 4
1656 && (y & (0xffffffff ^ RS1(~0)))
1657 == (INSN_OR | RD(O7) | RS2(G0)))
1658 {
1659 bfd_vma z;
1660 unsigned int reg;
1661
1662 z = bfd_get_32 (input_bfd,
1663 contents + rel->r_offset - 4);
1664 if ((z & (0xffffffff ^ RD(~0)))
1665 != (INSN_OR | RS1(O7) | RS2(G0)))
1666 break;
1667
1668 /* The sequence was
1669 or %o7, %g0, %rN
1670 call foo
1671 or %rN, %g0, %o7
1672
1673 If call foo was replaced with ba, replace
1674 or %rN, %g0, %o7 with nop. */
1675
1676 reg = (y & RS1(~0)) >> 14;
1677 if (reg != ((z & RD(~0)) >> 25)
1678 || reg == G0 || reg == O7)
1679 break;
1680
1681 bfd_put_32 (input_bfd, (bfd_vma) INSN_NOP,
1682 contents + rel->r_offset + 4);
1683 }
1684
1685 }
1686 }
1687 }
1688 }
1689
1690 if (r == bfd_reloc_continue)
1691 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1692 contents, rel->r_offset,
1693 relocation, rel->r_addend);
1694
1695 if (r != bfd_reloc_ok)
1696 {
1697 switch (r)
1698 {
1699 default:
1700 case bfd_reloc_outofrange:
1701 abort ();
1702 case bfd_reloc_overflow:
1703 {
1704 const char *name;
1705
1706 if (h != NULL)
1707 name = h->root.root.string;
1708 else
1709 {
1710 name = bfd_elf_string_from_elf_section (input_bfd,
1711 symtab_hdr->sh_link,
1712 sym->st_name);
1713 if (name == NULL)
1714 return false;
1715 if (*name == '\0')
1716 name = bfd_section_name (input_bfd, sec);
1717 }
1718 if (! ((*info->callbacks->reloc_overflow)
1719 (info, name, howto->name, (bfd_vma) 0,
1720 input_bfd, input_section, rel->r_offset)))
1721 return false;
1722 }
1723 break;
1724 }
1725 }
1726 }
1727
1728 return true;
1729 }
1730
1731 /* Finish up dynamic symbol handling. We set the contents of various
1732 dynamic sections here. */
1733
1734 static boolean
1735 elf32_sparc_finish_dynamic_symbol (output_bfd, info, h, sym)
1736 bfd *output_bfd;
1737 struct bfd_link_info *info;
1738 struct elf_link_hash_entry *h;
1739 Elf_Internal_Sym *sym;
1740 {
1741 bfd *dynobj;
1742
1743 dynobj = elf_hash_table (info)->dynobj;
1744
1745 if (h->plt.offset != (bfd_vma) -1)
1746 {
1747 asection *splt;
1748 asection *srela;
1749 Elf_Internal_Rela rela;
1750
1751 /* This symbol has an entry in the procedure linkage table. Set
1752 it up. */
1753
1754 BFD_ASSERT (h->dynindx != -1);
1755
1756 splt = bfd_get_section_by_name (dynobj, ".plt");
1757 srela = bfd_get_section_by_name (dynobj, ".rela.plt");
1758 BFD_ASSERT (splt != NULL && srela != NULL);
1759
1760 /* Fill in the entry in the procedure linkage table. */
1761 bfd_put_32 (output_bfd,
1762 PLT_ENTRY_WORD0 + h->plt.offset,
1763 splt->contents + h->plt.offset);
1764 bfd_put_32 (output_bfd,
1765 (PLT_ENTRY_WORD1
1766 + (((- (h->plt.offset + 4)) >> 2) & 0x3fffff)),
1767 splt->contents + h->plt.offset + 4);
1768 bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD2,
1769 splt->contents + h->plt.offset + 8);
1770
1771 /* Fill in the entry in the .rela.plt section. */
1772 rela.r_offset = (splt->output_section->vma
1773 + splt->output_offset
1774 + h->plt.offset);
1775 rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_JMP_SLOT);
1776 rela.r_addend = 0;
1777 bfd_elf32_swap_reloca_out (output_bfd, &rela,
1778 ((Elf32_External_Rela *) srela->contents
1779 + h->plt.offset / PLT_ENTRY_SIZE - 4));
1780
1781 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1782 {
1783 /* Mark the symbol as undefined, rather than as defined in
1784 the .plt section. Leave the value alone. */
1785 sym->st_shndx = SHN_UNDEF;
1786 /* If the symbol is weak, we do need to clear the value.
1787 Otherwise, the PLT entry would provide a definition for
1788 the symbol even if the symbol wasn't defined anywhere,
1789 and so the symbol would never be NULL. */
1790 if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK)
1791 == 0)
1792 sym->st_value = 0;
1793 }
1794 }
1795
1796 if (h->got.offset != (bfd_vma) -1)
1797 {
1798 asection *sgot;
1799 asection *srela;
1800 Elf_Internal_Rela rela;
1801
1802 /* This symbol has an entry in the global offset table. Set it
1803 up. */
1804
1805 sgot = bfd_get_section_by_name (dynobj, ".got");
1806 srela = bfd_get_section_by_name (dynobj, ".rela.got");
1807 BFD_ASSERT (sgot != NULL && srela != NULL);
1808
1809 rela.r_offset = (sgot->output_section->vma
1810 + sgot->output_offset
1811 + (h->got.offset &~ (bfd_vma) 1));
1812
1813 /* If this is a -Bsymbolic link, and the symbol is defined
1814 locally, we just want to emit a RELATIVE reloc. Likewise if
1815 the symbol was forced to be local because of a version file.
1816 The entry in the global offset table will already have been
1817 initialized in the relocate_section function. */
1818 if (info->shared
1819 && (info->symbolic || h->dynindx == -1)
1820 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
1821 rela.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
1822 else
1823 {
1824 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
1825 rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_GLOB_DAT);
1826 }
1827
1828 rela.r_addend = 0;
1829 bfd_elf32_swap_reloca_out (output_bfd, &rela,
1830 ((Elf32_External_Rela *) srela->contents
1831 + srela->reloc_count));
1832 ++srela->reloc_count;
1833 }
1834
1835 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
1836 {
1837 asection *s;
1838 Elf_Internal_Rela rela;
1839
1840 /* This symbols needs a copy reloc. Set it up. */
1841
1842 BFD_ASSERT (h->dynindx != -1);
1843
1844 s = bfd_get_section_by_name (h->root.u.def.section->owner,
1845 ".rela.bss");
1846 BFD_ASSERT (s != NULL);
1847
1848 rela.r_offset = (h->root.u.def.value
1849 + h->root.u.def.section->output_section->vma
1850 + h->root.u.def.section->output_offset);
1851 rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_COPY);
1852 rela.r_addend = 0;
1853 bfd_elf32_swap_reloca_out (output_bfd, &rela,
1854 ((Elf32_External_Rela *) s->contents
1855 + s->reloc_count));
1856 ++s->reloc_count;
1857 }
1858
1859 /* Mark some specially defined symbols as absolute. */
1860 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
1861 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
1862 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
1863 sym->st_shndx = SHN_ABS;
1864
1865 return true;
1866 }
1867
1868 /* Finish up the dynamic sections. */
1869
1870 static boolean
1871 elf32_sparc_finish_dynamic_sections (output_bfd, info)
1872 bfd *output_bfd;
1873 struct bfd_link_info *info;
1874 {
1875 bfd *dynobj;
1876 asection *sdyn;
1877 asection *sgot;
1878
1879 dynobj = elf_hash_table (info)->dynobj;
1880
1881 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
1882
1883 if (elf_hash_table (info)->dynamic_sections_created)
1884 {
1885 asection *splt;
1886 Elf32_External_Dyn *dyncon, *dynconend;
1887
1888 splt = bfd_get_section_by_name (dynobj, ".plt");
1889 BFD_ASSERT (splt != NULL && sdyn != NULL);
1890
1891 dyncon = (Elf32_External_Dyn *) sdyn->contents;
1892 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
1893 for (; dyncon < dynconend; dyncon++)
1894 {
1895 Elf_Internal_Dyn dyn;
1896 const char *name;
1897 boolean size;
1898
1899 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1900
1901 switch (dyn.d_tag)
1902 {
1903 case DT_PLTGOT: name = ".plt"; size = false; break;
1904 case DT_PLTRELSZ: name = ".rela.plt"; size = true; break;
1905 case DT_JMPREL: name = ".rela.plt"; size = false; break;
1906 default: name = NULL; size = false; break;
1907 }
1908
1909 if (name != NULL)
1910 {
1911 asection *s;
1912
1913 s = bfd_get_section_by_name (output_bfd, name);
1914 if (s == NULL)
1915 dyn.d_un.d_val = 0;
1916 else
1917 {
1918 if (! size)
1919 dyn.d_un.d_ptr = s->vma;
1920 else
1921 {
1922 if (s->_cooked_size != 0)
1923 dyn.d_un.d_val = s->_cooked_size;
1924 else
1925 dyn.d_un.d_val = s->_raw_size;
1926 }
1927 }
1928 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1929 }
1930 }
1931
1932 /* Clear the first four entries in the procedure linkage table,
1933 and put a nop in the last four bytes. */
1934 if (splt->_raw_size > 0)
1935 {
1936 memset (splt->contents, 0, 4 * PLT_ENTRY_SIZE);
1937 bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP,
1938 splt->contents + splt->_raw_size - 4);
1939 }
1940
1941 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
1942 PLT_ENTRY_SIZE;
1943 }
1944
1945 /* Set the first entry in the global offset table to the address of
1946 the dynamic section. */
1947 sgot = bfd_get_section_by_name (dynobj, ".got");
1948 BFD_ASSERT (sgot != NULL);
1949 if (sgot->_raw_size > 0)
1950 {
1951 if (sdyn == NULL)
1952 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
1953 else
1954 bfd_put_32 (output_bfd,
1955 sdyn->output_section->vma + sdyn->output_offset,
1956 sgot->contents);
1957 }
1958
1959 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
1960
1961 return true;
1962 }
1963 \f
1964 /* Functions for dealing with the e_flags field.
1965
1966 We don't define set_private_flags or copy_private_bfd_data because
1967 the only currently defined values are based on the bfd mach number,
1968 so we use the latter instead and defer setting e_flags until the
1969 file is written out. */
1970
1971 /* Merge backend specific data from an object file to the output
1972 object file when linking. */
1973
1974 static boolean
1975 elf32_sparc_merge_private_bfd_data (ibfd, obfd)
1976 bfd *ibfd;
1977 bfd *obfd;
1978 {
1979 boolean error;
1980 /* FIXME: This should not be static. */
1981 static unsigned long previous_ibfd_e_flags = (unsigned long) -1;
1982
1983 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1984 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1985 return true;
1986
1987 error = false;
1988
1989 if (bfd_get_mach (ibfd) >= bfd_mach_sparc_v9)
1990 {
1991 error = true;
1992 (*_bfd_error_handler)
1993 (_("%s: compiled for a 64 bit system and target is 32 bit"),
1994 bfd_archive_filename (ibfd));
1995 }
1996 else if ((ibfd->flags & DYNAMIC) == 0)
1997 {
1998 if (bfd_get_mach (obfd) < bfd_get_mach (ibfd))
1999 bfd_set_arch_mach (obfd, bfd_arch_sparc, bfd_get_mach (ibfd));
2000 }
2001
2002 if (((elf_elfheader (ibfd)->e_flags & EF_SPARC_LEDATA)
2003 != previous_ibfd_e_flags)
2004 && previous_ibfd_e_flags != (unsigned long) -1)
2005 {
2006 (*_bfd_error_handler)
2007 (_("%s: linking little endian files with big endian files"),
2008 bfd_archive_filename (ibfd));
2009 error = true;
2010 }
2011 previous_ibfd_e_flags = elf_elfheader (ibfd)->e_flags & EF_SPARC_LEDATA;
2012
2013 if (error)
2014 {
2015 bfd_set_error (bfd_error_bad_value);
2016 return false;
2017 }
2018
2019 return true;
2020 }
2021 \f
2022 /* Set the right machine number. */
2023
2024 static boolean
2025 elf32_sparc_object_p (abfd)
2026 bfd *abfd;
2027 {
2028 if (elf_elfheader (abfd)->e_machine == EM_SPARC32PLUS)
2029 {
2030 if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
2031 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
2032 bfd_mach_sparc_v8plusb);
2033 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
2034 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
2035 bfd_mach_sparc_v8plusa);
2036 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_32PLUS)
2037 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
2038 bfd_mach_sparc_v8plus);
2039 else
2040 return false;
2041 }
2042 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_LEDATA)
2043 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
2044 bfd_mach_sparc_sparclite_le);
2045 else
2046 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc);
2047 }
2048
2049 /* The final processing done just before writing out the object file.
2050 We need to set the e_machine field appropriately. */
2051
2052 static void
2053 elf32_sparc_final_write_processing (abfd, linker)
2054 bfd *abfd;
2055 boolean linker ATTRIBUTE_UNUSED;
2056 {
2057 switch (bfd_get_mach (abfd))
2058 {
2059 case bfd_mach_sparc :
2060 break; /* nothing to do */
2061 case bfd_mach_sparc_v8plus :
2062 elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS;
2063 elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK;
2064 elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS;
2065 break;
2066 case bfd_mach_sparc_v8plusa :
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 | EF_SPARC_SUN_US1;
2070 break;
2071 case bfd_mach_sparc_v8plusb :
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
2075 | EF_SPARC_SUN_US3;
2076 break;
2077 case bfd_mach_sparc_sparclite_le :
2078 elf_elfheader (abfd)->e_machine = EM_SPARC;
2079 elf_elfheader (abfd)->e_flags |= EF_SPARC_LEDATA;
2080 break;
2081 default :
2082 abort ();
2083 break;
2084 }
2085 }
2086
2087 static enum elf_reloc_type_class
2088 elf32_sparc_reloc_type_class (rela)
2089 const Elf_Internal_Rela *rela;
2090 {
2091 switch ((int) ELF32_R_TYPE (rela->r_info))
2092 {
2093 case R_SPARC_RELATIVE:
2094 return reloc_class_relative;
2095 case R_SPARC_JMP_SLOT:
2096 return reloc_class_plt;
2097 case R_SPARC_COPY:
2098 return reloc_class_copy;
2099 default:
2100 return reloc_class_normal;
2101 }
2102 }
2103 \f
2104 #define TARGET_BIG_SYM bfd_elf32_sparc_vec
2105 #define TARGET_BIG_NAME "elf32-sparc"
2106 #define ELF_ARCH bfd_arch_sparc
2107 #define ELF_MACHINE_CODE EM_SPARC
2108 #define ELF_MACHINE_ALT1 EM_SPARC32PLUS
2109 #define ELF_MAXPAGESIZE 0x10000
2110
2111 #define bfd_elf32_bfd_reloc_type_lookup elf32_sparc_reloc_type_lookup
2112 #define bfd_elf32_bfd_relax_section elf32_sparc_relax_section
2113 #define elf_info_to_howto elf32_sparc_info_to_howto
2114 #define elf_backend_create_dynamic_sections \
2115 _bfd_elf_create_dynamic_sections
2116 #define elf_backend_check_relocs elf32_sparc_check_relocs
2117 #define elf_backend_adjust_dynamic_symbol \
2118 elf32_sparc_adjust_dynamic_symbol
2119 #define elf_backend_size_dynamic_sections \
2120 elf32_sparc_size_dynamic_sections
2121 #define elf_backend_relocate_section elf32_sparc_relocate_section
2122 #define elf_backend_finish_dynamic_symbol \
2123 elf32_sparc_finish_dynamic_symbol
2124 #define elf_backend_finish_dynamic_sections \
2125 elf32_sparc_finish_dynamic_sections
2126 #define bfd_elf32_bfd_merge_private_bfd_data \
2127 elf32_sparc_merge_private_bfd_data
2128 #define elf_backend_object_p elf32_sparc_object_p
2129 #define elf_backend_final_write_processing \
2130 elf32_sparc_final_write_processing
2131 #define elf_backend_gc_mark_hook elf32_sparc_gc_mark_hook
2132 #define elf_backend_gc_sweep_hook elf32_sparc_gc_sweep_hook
2133 #define elf_backend_reloc_type_class elf32_sparc_reloc_type_class
2134
2135 #define elf_backend_can_gc_sections 1
2136 #define elf_backend_want_got_plt 0
2137 #define elf_backend_plt_readonly 0
2138 #define elf_backend_want_plt_sym 1
2139 #define elf_backend_got_header_size 4
2140 #define elf_backend_plt_header_size (4*PLT_ENTRY_SIZE)
2141
2142 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.09853 seconds and 5 git commands to generate.