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