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