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