Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

source: trunk/src/binutils/bfd/elf32-sparc.c@ 490

Visit:

Last change on this file since 490 was 10, checked in by bird, 23 years ago
Initial revision
Property cvs2svn:cvs-rev set to `1.1` Property svn:eol-style set to `native` Property svn:executable set to ``*
File size: 67.5 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: