?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* elf-bfd.h (enum elf_link_info_type): New.
[binutils.git] / bfd / elf64-sparc.c
blob50b0cd58cc6ecfa500ce48f822e07c81c1f6ffde
1 /* SPARC-specific support for 64-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 "libbfd.h"
24 #include "elf-bfd.h"
25 #include "opcode/sparc.h"
26
27 /* This is defined if one wants to build upward compatible binaries
28 with the original sparc64-elf toolchain. The support is kept in for
29 now but is turned off by default. dje 970930 */
30 /*#define SPARC64_OLD_RELOCS*/
31
32 #include "elf/sparc.h"
33
34 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
35 #define MINUS_ONE (~ (bfd_vma) 0)
36
37 static struct bfd_link_hash_table * sparc64_elf_bfd_link_hash_table_create
38 PARAMS ((bfd *));
39 static bfd_reloc_status_type init_insn_reloc
40 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *,
41 bfd *, bfd_vma *, bfd_vma *));
42 static reloc_howto_type *sparc64_elf_reloc_type_lookup
43 PARAMS ((bfd *, bfd_reloc_code_real_type));
44 static void sparc64_elf_info_to_howto
45 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
46
47 static void sparc64_elf_build_plt
48 PARAMS ((bfd *, unsigned char *, int));
49 static bfd_vma sparc64_elf_plt_entry_offset
50 PARAMS ((bfd_vma));
51 static bfd_vma sparc64_elf_plt_ptr_offset
52 PARAMS ((bfd_vma, bfd_vma));
53
54 static boolean sparc64_elf_check_relocs
55 PARAMS ((bfd *, struct bfd_link_info *, asection *sec,
56 const Elf_Internal_Rela *));
57 static boolean sparc64_elf_adjust_dynamic_symbol
58 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
59 static boolean sparc64_elf_size_dynamic_sections
60 PARAMS ((bfd *, struct bfd_link_info *));
61 static int sparc64_elf_get_symbol_type
62 PARAMS (( Elf_Internal_Sym *, int));
63 static boolean sparc64_elf_add_symbol_hook
64 PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Sym *,
65 const char **, flagword *, asection **, bfd_vma *));
66 static boolean sparc64_elf_output_arch_syms
67 PARAMS ((bfd *, struct bfd_link_info *, PTR,
68 boolean (*) (PTR, const char *, Elf_Internal_Sym *, asection *)));
69 static void sparc64_elf_symbol_processing
70 PARAMS ((bfd *, asymbol *));
71
72 static boolean sparc64_elf_copy_private_bfd_data
73 PARAMS ((bfd *, bfd *));
74 static boolean sparc64_elf_merge_private_bfd_data
75 PARAMS ((bfd *, bfd *));
76
77 static const char *sparc64_elf_print_symbol_all
78 PARAMS ((bfd *, PTR, asymbol *));
79 static boolean sparc64_elf_relax_section
80 PARAMS ((bfd *, asection *, struct bfd_link_info *, boolean *));
81 static boolean sparc64_elf_relocate_section
82 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
83 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
84 static boolean sparc64_elf_finish_dynamic_symbol
85 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
86 Elf_Internal_Sym *));
87 static boolean sparc64_elf_finish_dynamic_sections
88 PARAMS ((bfd *, struct bfd_link_info *));
89 static boolean sparc64_elf_object_p PARAMS ((bfd *));
90 static long sparc64_elf_get_reloc_upper_bound PARAMS ((bfd *, asection *));
91 static long sparc64_elf_get_dynamic_reloc_upper_bound PARAMS ((bfd *));
92 static boolean sparc64_elf_slurp_one_reloc_table
93 PARAMS ((bfd *, asection *, Elf_Internal_Shdr *, asymbol **, boolean));
94 static boolean sparc64_elf_slurp_reloc_table
95 PARAMS ((bfd *, asection *, asymbol **, boolean));
96 static long sparc64_elf_canonicalize_dynamic_reloc
97 PARAMS ((bfd *, arelent **, asymbol **));
98 static void sparc64_elf_write_relocs PARAMS ((bfd *, asection *, PTR));
99 static enum elf_reloc_type_class sparc64_elf_reloc_type_class
100 PARAMS ((const Elf_Internal_Rela *));
101 \f
102 /* The relocation "howto" table. */
103
104 static bfd_reloc_status_type sparc_elf_notsup_reloc
105 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
106 static bfd_reloc_status_type sparc_elf_wdisp16_reloc
107 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
108 static bfd_reloc_status_type sparc_elf_hix22_reloc
109 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
110 static bfd_reloc_status_type sparc_elf_lox10_reloc
111 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
112
113 static reloc_howto_type sparc64_elf_howto_table[] =
114 {
115 HOWTO(R_SPARC_NONE, 0,0, 0,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", false,0,0x00000000,true),
116 HOWTO(R_SPARC_8, 0,0, 8,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_8", false,0,0x000000ff,true),
117 HOWTO(R_SPARC_16, 0,1,16,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_16", false,0,0x0000ffff,true),
118 HOWTO(R_SPARC_32, 0,2,32,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_32", false,0,0xffffffff,true),
119 HOWTO(R_SPARC_DISP8, 0,0, 8,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP8", false,0,0x000000ff,true),
120 HOWTO(R_SPARC_DISP16, 0,1,16,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP16", false,0,0x0000ffff,true),
121 HOWTO(R_SPARC_DISP32, 0,2,32,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP32", false,0,0x00ffffff,true),
122 HOWTO(R_SPARC_WDISP30, 2,2,30,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP30", false,0,0x3fffffff,true),
123 HOWTO(R_SPARC_WDISP22, 2,2,22,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP22", false,0,0x003fffff,true),
124 HOWTO(R_SPARC_HI22, 10,2,22,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_HI22", false,0,0x003fffff,true),
125 HOWTO(R_SPARC_22, 0,2,22,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_22", false,0,0x003fffff,true),
126 HOWTO(R_SPARC_13, 0,2,13,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_13", false,0,0x00001fff,true),
127 HOWTO(R_SPARC_LO10, 0,2,10,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_LO10", false,0,0x000003ff,true),
128 HOWTO(R_SPARC_GOT10, 0,2,10,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOT10", false,0,0x000003ff,true),
129 HOWTO(R_SPARC_GOT13, 0,2,13,false,0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_GOT13", false,0,0x00001fff,true),
130 HOWTO(R_SPARC_GOT22, 10,2,22,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOT22", false,0,0x003fffff,true),
131 HOWTO(R_SPARC_PC10, 0,2,10,true, 0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_PC10", false,0,0x000003ff,true),
132 HOWTO(R_SPARC_PC22, 10,2,22,true, 0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_PC22", false,0,0x003fffff,true),
133 HOWTO(R_SPARC_WPLT30, 2,2,30,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WPLT30", false,0,0x3fffffff,true),
134 HOWTO(R_SPARC_COPY, 0,0,00,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_COPY", false,0,0x00000000,true),
135 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),
136 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),
137 HOWTO(R_SPARC_RELATIVE, 0,0,00,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_RELATIVE",false,0,0x00000000,true),
138 HOWTO(R_SPARC_UA32, 0,2,32,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA32", false,0,0xffffffff,true),
139 #ifndef SPARC64_OLD_RELOCS
140 /* These aren't implemented yet. */
141 HOWTO(R_SPARC_PLT32, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PLT32", false,0,0x00000000,true),
142 HOWTO(R_SPARC_HIPLT22, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_HIPLT22", false,0,0x00000000,true),
143 HOWTO(R_SPARC_LOPLT10, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_LOPLT10", false,0,0x00000000,true),
144 HOWTO(R_SPARC_PCPLT32, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PCPLT32", false,0,0x00000000,true),
145 HOWTO(R_SPARC_PCPLT22, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PCPLT22", false,0,0x00000000,true),
146 HOWTO(R_SPARC_PCPLT10, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PCPLT10", false,0,0x00000000,true),
147 #endif
148 HOWTO(R_SPARC_10, 0,2,10,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_10", false,0,0x000003ff,true),
149 HOWTO(R_SPARC_11, 0,2,11,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_11", false,0,0x000007ff,true),
150 HOWTO(R_SPARC_64, 0,4,64,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_64", false,0,MINUS_ONE, true),
151 HOWTO(R_SPARC_OLO10, 0,2,13,false,0,complain_overflow_signed, sparc_elf_notsup_reloc, "R_SPARC_OLO10", false,0,0x00001fff,true),
152 HOWTO(R_SPARC_HH22, 42,2,22,false,0,complain_overflow_unsigned,bfd_elf_generic_reloc, "R_SPARC_HH22", false,0,0x003fffff,true),
153 HOWTO(R_SPARC_HM10, 32,2,10,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_HM10", false,0,0x000003ff,true),
154 HOWTO(R_SPARC_LM22, 10,2,22,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_LM22", false,0,0x003fffff,true),
155 HOWTO(R_SPARC_PC_HH22, 42,2,22,true, 0,complain_overflow_unsigned,bfd_elf_generic_reloc, "R_SPARC_PC_HH22", false,0,0x003fffff,true),
156 HOWTO(R_SPARC_PC_HM10, 32,2,10,true, 0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_PC_HM10", false,0,0x000003ff,true),
157 HOWTO(R_SPARC_PC_LM22, 10,2,22,true, 0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_PC_LM22", false,0,0x003fffff,true),
158 HOWTO(R_SPARC_WDISP16, 2,2,16,true, 0,complain_overflow_signed, sparc_elf_wdisp16_reloc,"R_SPARC_WDISP16", false,0,0x00000000,true),
159 HOWTO(R_SPARC_WDISP19, 2,2,19,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP19", false,0,0x0007ffff,true),
160 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),
161 HOWTO(R_SPARC_7, 0,2, 7,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_7", false,0,0x0000007f,true),
162 HOWTO(R_SPARC_5, 0,2, 5,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_5", false,0,0x0000001f,true),
163 HOWTO(R_SPARC_6, 0,2, 6,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_6", false,0,0x0000003f,true),
164 HOWTO(R_SPARC_DISP64, 0,4,64,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP64", false,0,MINUS_ONE, true),
165 HOWTO(R_SPARC_PLT64, 0,4,64,false,0,complain_overflow_bitfield,sparc_elf_notsup_reloc, "R_SPARC_PLT64", false,0,MINUS_ONE, false),
166 HOWTO(R_SPARC_HIX22, 0,4, 0,false,0,complain_overflow_bitfield,sparc_elf_hix22_reloc, "R_SPARC_HIX22", false,0,MINUS_ONE, false),
167 HOWTO(R_SPARC_LOX10, 0,4, 0,false,0,complain_overflow_dont, sparc_elf_lox10_reloc, "R_SPARC_LOX10", false,0,MINUS_ONE, false),
168 HOWTO(R_SPARC_H44, 22,2,22,false,0,complain_overflow_unsigned,bfd_elf_generic_reloc, "R_SPARC_H44", false,0,0x003fffff,false),
169 HOWTO(R_SPARC_M44, 12,2,10,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_M44", false,0,0x000003ff,false),
170 HOWTO(R_SPARC_L44, 0,2,13,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_L44", false,0,0x00000fff,false),
171 HOWTO(R_SPARC_REGISTER, 0,4, 0,false,0,complain_overflow_bitfield,sparc_elf_notsup_reloc, "R_SPARC_REGISTER",false,0,MINUS_ONE, false),
172 HOWTO(R_SPARC_UA64, 0,4,64,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA64", false,0,MINUS_ONE, true),
173 HOWTO(R_SPARC_UA16, 0,1,16,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA16", false,0,0x0000ffff,true)
174 };
175
176 struct elf_reloc_map {
177 bfd_reloc_code_real_type bfd_reloc_val;
178 unsigned char elf_reloc_val;
179 };
180
181 static const struct elf_reloc_map sparc_reloc_map[] =
182 {
183 { BFD_RELOC_NONE, R_SPARC_NONE, },
184 { BFD_RELOC_16, R_SPARC_16, },
185 { BFD_RELOC_8, R_SPARC_8 },
186 { BFD_RELOC_8_PCREL, R_SPARC_DISP8 },
187 { BFD_RELOC_CTOR, R_SPARC_64 },
188 { BFD_RELOC_32, R_SPARC_32 },
189 { BFD_RELOC_32_PCREL, R_SPARC_DISP32 },
190 { BFD_RELOC_HI22, R_SPARC_HI22 },
191 { BFD_RELOC_LO10, R_SPARC_LO10, },
192 { BFD_RELOC_32_PCREL_S2, R_SPARC_WDISP30 },
193 { BFD_RELOC_SPARC22, R_SPARC_22 },
194 { BFD_RELOC_SPARC13, R_SPARC_13 },
195 { BFD_RELOC_SPARC_GOT10, R_SPARC_GOT10 },
196 { BFD_RELOC_SPARC_GOT13, R_SPARC_GOT13 },
197 { BFD_RELOC_SPARC_GOT22, R_SPARC_GOT22 },
198 { BFD_RELOC_SPARC_PC10, R_SPARC_PC10 },
199 { BFD_RELOC_SPARC_PC22, R_SPARC_PC22 },
200 { BFD_RELOC_SPARC_WPLT30, R_SPARC_WPLT30 },
201 { BFD_RELOC_SPARC_COPY, R_SPARC_COPY },
202 { BFD_RELOC_SPARC_GLOB_DAT, R_SPARC_GLOB_DAT },
203 { BFD_RELOC_SPARC_JMP_SLOT, R_SPARC_JMP_SLOT },
204 { BFD_RELOC_SPARC_RELATIVE, R_SPARC_RELATIVE },
205 { BFD_RELOC_SPARC_WDISP22, R_SPARC_WDISP22 },
206 { BFD_RELOC_SPARC_UA16, R_SPARC_UA16 },
207 { BFD_RELOC_SPARC_UA32, R_SPARC_UA32 },
208 { BFD_RELOC_SPARC_UA64, R_SPARC_UA64 },
209 { BFD_RELOC_SPARC_10, R_SPARC_10 },
210 { BFD_RELOC_SPARC_11, R_SPARC_11 },
211 { BFD_RELOC_SPARC_64, R_SPARC_64 },
212 { BFD_RELOC_SPARC_OLO10, R_SPARC_OLO10 },
213 { BFD_RELOC_SPARC_HH22, R_SPARC_HH22 },
214 { BFD_RELOC_SPARC_HM10, R_SPARC_HM10 },
215 { BFD_RELOC_SPARC_LM22, R_SPARC_LM22 },
216 { BFD_RELOC_SPARC_PC_HH22, R_SPARC_PC_HH22 },
217 { BFD_RELOC_SPARC_PC_HM10, R_SPARC_PC_HM10 },
218 { BFD_RELOC_SPARC_PC_LM22, R_SPARC_PC_LM22 },
219 { BFD_RELOC_SPARC_WDISP16, R_SPARC_WDISP16 },
220 { BFD_RELOC_SPARC_WDISP19, R_SPARC_WDISP19 },
221 { BFD_RELOC_SPARC_7, R_SPARC_7 },
222 { BFD_RELOC_SPARC_5, R_SPARC_5 },
223 { BFD_RELOC_SPARC_6, R_SPARC_6 },
224 { BFD_RELOC_SPARC_DISP64, R_SPARC_DISP64 },
225 { BFD_RELOC_SPARC_PLT64, R_SPARC_PLT64 },
226 { BFD_RELOC_SPARC_HIX22, R_SPARC_HIX22 },
227 { BFD_RELOC_SPARC_LOX10, R_SPARC_LOX10 },
228 { BFD_RELOC_SPARC_H44, R_SPARC_H44 },
229 { BFD_RELOC_SPARC_M44, R_SPARC_M44 },
230 { BFD_RELOC_SPARC_L44, R_SPARC_L44 },
231 { BFD_RELOC_SPARC_REGISTER, R_SPARC_REGISTER }
232 };
233
234 static reloc_howto_type *
235 sparc64_elf_reloc_type_lookup (abfd, code)
236 bfd *abfd ATTRIBUTE_UNUSED;
237 bfd_reloc_code_real_type code;
238 {
239 unsigned int i;
240 for (i = 0; i < sizeof (sparc_reloc_map) / sizeof (struct elf_reloc_map); i++)
241 {
242 if (sparc_reloc_map[i].bfd_reloc_val == code)
243 return &sparc64_elf_howto_table[(int) sparc_reloc_map[i].elf_reloc_val];
244 }
245 return 0;
246 }
247
248 static void
249 sparc64_elf_info_to_howto (abfd, cache_ptr, dst)
250 bfd *abfd ATTRIBUTE_UNUSED;
251 arelent *cache_ptr;
252 Elf64_Internal_Rela *dst;
253 {
254 BFD_ASSERT (ELF64_R_TYPE_ID (dst->r_info) < (unsigned int) R_SPARC_max_std);
255 cache_ptr->howto = &sparc64_elf_howto_table[ELF64_R_TYPE_ID (dst->r_info)];
256 }
257 \f
258 /* Due to the way how we handle R_SPARC_OLO10, each entry in a SHT_RELA
259 section can represent up to two relocs, we must tell the user to allocate
260 more space. */
261
262 static long
263 sparc64_elf_get_reloc_upper_bound (abfd, sec)
264 bfd *abfd ATTRIBUTE_UNUSED;
265 asection *sec;
266 {
267 return (sec->reloc_count * 2 + 1) * sizeof (arelent *);
268 }
269
270 static long
271 sparc64_elf_get_dynamic_reloc_upper_bound (abfd)
272 bfd *abfd;
273 {
274 return _bfd_elf_get_dynamic_reloc_upper_bound (abfd) * 2;
275 }
276
277 /* Read relocations for ASECT from REL_HDR. There are RELOC_COUNT of
278 them. We cannot use generic elf routines for this, because R_SPARC_OLO10
279 has secondary addend in ELF64_R_TYPE_DATA. We handle it as two relocations
280 for the same location, R_SPARC_LO10 and R_SPARC_13. */
281
282 static boolean
283 sparc64_elf_slurp_one_reloc_table (abfd, asect, rel_hdr, symbols, dynamic)
284 bfd *abfd;
285 asection *asect;
286 Elf_Internal_Shdr *rel_hdr;
287 asymbol **symbols;
288 boolean dynamic;
289 {
290 PTR allocated = NULL;
291 bfd_byte *native_relocs;
292 arelent *relent;
293 unsigned int i;
294 int entsize;
295 bfd_size_type count;
296 arelent *relents;
297
298 allocated = (PTR) bfd_malloc (rel_hdr->sh_size);
299 if (allocated == NULL)
300 goto error_return;
301
302 if (bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0
303 || bfd_bread (allocated, rel_hdr->sh_size, abfd) != rel_hdr->sh_size)
304 goto error_return;
305
306 native_relocs = (bfd_byte *) allocated;
307
308 relents = asect->relocation + asect->reloc_count;
309
310 entsize = rel_hdr->sh_entsize;
311 BFD_ASSERT (entsize == sizeof (Elf64_External_Rela));
312
313 count = rel_hdr->sh_size / entsize;
314
315 for (i = 0, relent = relents; i < count;
316 i++, relent++, native_relocs += entsize)
317 {
318 Elf_Internal_Rela rela;
319
320 bfd_elf64_swap_reloca_in (abfd, (Elf64_External_Rela *) native_relocs, &rela);
321
322 /* The address of an ELF reloc is section relative for an object
323 file, and absolute for an executable file or shared library.
324 The address of a normal BFD reloc is always section relative,
325 and the address of a dynamic reloc is absolute.. */
326 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0 || dynamic)
327 relent->address = rela.r_offset;
328 else
329 relent->address = rela.r_offset - asect->vma;
330
331 if (ELF64_R_SYM (rela.r_info) == 0)
332 relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
333 else
334 {
335 asymbol **ps, *s;
336
337 ps = symbols + ELF64_R_SYM (rela.r_info) - 1;
338 s = *ps;
339
340 /* Canonicalize ELF section symbols. FIXME: Why? */
341 if ((s->flags & BSF_SECTION_SYM) == 0)
342 relent->sym_ptr_ptr = ps;
343 else
344 relent->sym_ptr_ptr = s->section->symbol_ptr_ptr;
345 }
346
347 relent->addend = rela.r_addend;
348
349 BFD_ASSERT (ELF64_R_TYPE_ID (rela.r_info) < (unsigned int) R_SPARC_max_std);
350 if (ELF64_R_TYPE_ID (rela.r_info) == R_SPARC_OLO10)
351 {
352 relent->howto = &sparc64_elf_howto_table[R_SPARC_LO10];
353 relent[1].address = relent->address;
354 relent++;
355 relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
356 relent->addend = ELF64_R_TYPE_DATA (rela.r_info);
357 relent->howto = &sparc64_elf_howto_table[R_SPARC_13];
358 }
359 else
360 relent->howto = &sparc64_elf_howto_table[ELF64_R_TYPE_ID (rela.r_info)];
361 }
362
363 asect->reloc_count += relent - relents;
364
365 if (allocated != NULL)
366 free (allocated);
367
368 return true;
369
370 error_return:
371 if (allocated != NULL)
372 free (allocated);
373 return false;
374 }
375
376 /* Read in and swap the external relocs. */
377
378 static boolean
379 sparc64_elf_slurp_reloc_table (abfd, asect, symbols, dynamic)
380 bfd *abfd;
381 asection *asect;
382 asymbol **symbols;
383 boolean dynamic;
384 {
385 struct bfd_elf_section_data * const d = elf_section_data (asect);
386 Elf_Internal_Shdr *rel_hdr;
387 Elf_Internal_Shdr *rel_hdr2;
388 bfd_size_type amt;
389
390 if (asect->relocation != NULL)
391 return true;
392
393 if (! dynamic)
394 {
395 if ((asect->flags & SEC_RELOC) == 0
396 || asect->reloc_count == 0)
397 return true;
398
399 rel_hdr = &d->rel_hdr;
400 rel_hdr2 = d->rel_hdr2;
401
402 BFD_ASSERT (asect->rel_filepos == rel_hdr->sh_offset
403 || (rel_hdr2 && asect->rel_filepos == rel_hdr2->sh_offset));
404 }
405 else
406 {
407 /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
408 case because relocations against this section may use the
409 dynamic symbol table, and in that case bfd_section_from_shdr
410 in elf.c does not update the RELOC_COUNT. */
411 if (asect->_raw_size == 0)
412 return true;
413
414 rel_hdr = &d->this_hdr;
415 asect->reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
416 rel_hdr2 = NULL;
417 }
418
419 amt = asect->reloc_count;
420 amt *= 2 * sizeof (arelent);
421 asect->relocation = (arelent *) bfd_alloc (abfd, amt);
422 if (asect->relocation == NULL)
423 return false;
424
425 /* The sparc64_elf_slurp_one_reloc_table routine increments reloc_count. */
426 asect->reloc_count = 0;
427
428 if (!sparc64_elf_slurp_one_reloc_table (abfd, asect, rel_hdr, symbols,
429 dynamic))
430 return false;
431
432 if (rel_hdr2
433 && !sparc64_elf_slurp_one_reloc_table (abfd, asect, rel_hdr2, symbols,
434 dynamic))
435 return false;
436
437 return true;
438 }
439
440 /* Canonicalize the dynamic relocation entries. Note that we return
441 the dynamic relocations as a single block, although they are
442 actually associated with particular sections; the interface, which
443 was designed for SunOS style shared libraries, expects that there
444 is only one set of dynamic relocs. Any section that was actually
445 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
446 the dynamic symbol table, is considered to be a dynamic reloc
447 section. */
448
449 static long
450 sparc64_elf_canonicalize_dynamic_reloc (abfd, storage, syms)
451 bfd *abfd;
452 arelent **storage;
453 asymbol **syms;
454 {
455 asection *s;
456 long ret;
457
458 if (elf_dynsymtab (abfd) == 0)
459 {
460 bfd_set_error (bfd_error_invalid_operation);
461 return -1;
462 }
463
464 ret = 0;
465 for (s = abfd->sections; s != NULL; s = s->next)
466 {
467 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
468 && (elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
469 {
470 arelent *p;
471 long count, i;
472
473 if (! sparc64_elf_slurp_reloc_table (abfd, s, syms, true))
474 return -1;
475 count = s->reloc_count;
476 p = s->relocation;
477 for (i = 0; i < count; i++)
478 *storage++ = p++;
479 ret += count;
480 }
481 }
482
483 *storage = NULL;
484
485 return ret;
486 }
487
488 /* Write out the relocs. */
489
490 static void
491 sparc64_elf_write_relocs (abfd, sec, data)
492 bfd *abfd;
493 asection *sec;
494 PTR data;
495 {
496 boolean *failedp = (boolean *) data;
497 Elf_Internal_Shdr *rela_hdr;
498 Elf64_External_Rela *outbound_relocas, *src_rela;
499 unsigned int idx, count;
500 asymbol *last_sym = 0;
501 int last_sym_idx = 0;
502
503 /* If we have already failed, don't do anything. */
504 if (*failedp)
505 return;
506
507 if ((sec->flags & SEC_RELOC) == 0)
508 return;
509
510 /* The linker backend writes the relocs out itself, and sets the
511 reloc_count field to zero to inhibit writing them here. Also,
512 sometimes the SEC_RELOC flag gets set even when there aren't any
513 relocs. */
514 if (sec->reloc_count == 0)
515 return;
516
517 /* We can combine two relocs that refer to the same address
518 into R_SPARC_OLO10 if first one is R_SPARC_LO10 and the
519 latter is R_SPARC_13 with no associated symbol. */
520 count = 0;
521 for (idx = 0; idx < sec->reloc_count; idx++)
522 {
523 bfd_vma addr;
524
525 ++count;
526
527 addr = sec->orelocation[idx]->address;
528 if (sec->orelocation[idx]->howto->type == R_SPARC_LO10
529 && idx < sec->reloc_count - 1)
530 {
531 arelent *r = sec->orelocation[idx + 1];
532
533 if (r->howto->type == R_SPARC_13
534 && r->address == addr
535 && bfd_is_abs_section ((*r->sym_ptr_ptr)->section)
536 && (*r->sym_ptr_ptr)->value == 0)
537 ++idx;
538 }
539 }
540
541 rela_hdr = &elf_section_data (sec)->rel_hdr;
542
543 rela_hdr->sh_size = rela_hdr->sh_entsize * count;
544 rela_hdr->contents = (PTR) bfd_alloc (abfd, rela_hdr->sh_size);
545 if (rela_hdr->contents == NULL)
546 {
547 *failedp = true;
548 return;
549 }
550
551 /* Figure out whether the relocations are RELA or REL relocations. */
552 if (rela_hdr->sh_type != SHT_RELA)
553 abort ();
554
555 /* orelocation has the data, reloc_count has the count... */
556 outbound_relocas = (Elf64_External_Rela *) rela_hdr->contents;
557 src_rela = outbound_relocas;
558
559 for (idx = 0; idx < sec->reloc_count; idx++)
560 {
561 Elf_Internal_Rela dst_rela;
562 arelent *ptr;
563 asymbol *sym;
564 int n;
565
566 ptr = sec->orelocation[idx];
567
568 /* The address of an ELF reloc is section relative for an object
569 file, and absolute for an executable file or shared library.
570 The address of a BFD reloc is always section relative. */
571 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
572 dst_rela.r_offset = ptr->address;
573 else
574 dst_rela.r_offset = ptr->address + sec->vma;
575
576 sym = *ptr->sym_ptr_ptr;
577 if (sym == last_sym)
578 n = last_sym_idx;
579 else if (bfd_is_abs_section (sym->section) && sym->value == 0)
580 n = STN_UNDEF;
581 else
582 {
583 last_sym = sym;
584 n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
585 if (n < 0)
586 {
587 *failedp = true;
588 return;
589 }
590 last_sym_idx = n;
591 }
592
593 if ((*ptr->sym_ptr_ptr)->the_bfd != NULL
594 && (*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
595 && ! _bfd_elf_validate_reloc (abfd, ptr))
596 {
597 *failedp = true;
598 return;
599 }
600
601 if (ptr->howto->type == R_SPARC_LO10
602 && idx < sec->reloc_count - 1)
603 {
604 arelent *r = sec->orelocation[idx + 1];
605
606 if (r->howto->type == R_SPARC_13
607 && r->address == ptr->address
608 && bfd_is_abs_section ((*r->sym_ptr_ptr)->section)
609 && (*r->sym_ptr_ptr)->value == 0)
610 {
611 idx++;
612 dst_rela.r_info
613 = ELF64_R_INFO (n, ELF64_R_TYPE_INFO (r->addend,
614 R_SPARC_OLO10));
615 }
616 else
617 dst_rela.r_info = ELF64_R_INFO (n, R_SPARC_LO10);
618 }
619 else
620 dst_rela.r_info = ELF64_R_INFO (n, ptr->howto->type);
621
622 dst_rela.r_addend = ptr->addend;
623 bfd_elf64_swap_reloca_out (abfd, &dst_rela, src_rela);
624 ++src_rela;
625 }
626 }
627 \f
628 /* Sparc64 ELF linker hash table. */
629
630 struct sparc64_elf_app_reg
631 {
632 unsigned char bind;
633 unsigned short shndx;
634 bfd *abfd;
635 char *name;
636 };
637
638 struct sparc64_elf_link_hash_table
639 {
640 struct elf_link_hash_table root;
641
642 struct sparc64_elf_app_reg app_regs [4];
643 };
644
645 /* Get the Sparc64 ELF linker hash table from a link_info structure. */
646
647 #define sparc64_elf_hash_table(p) \
648 ((struct sparc64_elf_link_hash_table *) ((p)->hash))
649
650 /* Create a Sparc64 ELF linker hash table. */
651
652 static struct bfd_link_hash_table *
653 sparc64_elf_bfd_link_hash_table_create (abfd)
654 bfd *abfd;
655 {
656 struct sparc64_elf_link_hash_table *ret;
657 bfd_size_type amt = sizeof (struct sparc64_elf_link_hash_table);
658
659 ret = (struct sparc64_elf_link_hash_table *) bfd_zalloc (abfd, amt);
660 if (ret == (struct sparc64_elf_link_hash_table *) NULL)
661 return NULL;
662
663 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
664 _bfd_elf_link_hash_newfunc))
665 {
666 bfd_release (abfd, ret);
667 return NULL;
668 }
669
670 return &ret->root.root;
671 }
672 \f
673 /* Utility for performing the standard initial work of an instruction
674 relocation.
675 *PRELOCATION will contain the relocated item.
676 *PINSN will contain the instruction from the input stream.
677 If the result is `bfd_reloc_other' the caller can continue with
678 performing the relocation. Otherwise it must stop and return the
679 value to its caller. */
680
681 static bfd_reloc_status_type
682 init_insn_reloc (abfd,
683 reloc_entry,
684 symbol,
685 data,
686 input_section,
687 output_bfd,
688 prelocation,
689 pinsn)
690 bfd *abfd;
691 arelent *reloc_entry;
692 asymbol *symbol;
693 PTR data;
694 asection *input_section;
695 bfd *output_bfd;
696 bfd_vma *prelocation;
697 bfd_vma *pinsn;
698 {
699 bfd_vma relocation;
700 reloc_howto_type *howto = reloc_entry->howto;
701
702 if (output_bfd != (bfd *) NULL
703 && (symbol->flags & BSF_SECTION_SYM) == 0
704 && (! howto->partial_inplace
705 || reloc_entry->addend == 0))
706 {
707 reloc_entry->address += input_section->output_offset;
708 return bfd_reloc_ok;
709 }
710
711 /* This works because partial_inplace == false. */
712 if (output_bfd != NULL)
713 return bfd_reloc_continue;
714
715 if (reloc_entry->address > input_section->_cooked_size)
716 return bfd_reloc_outofrange;
717
718 relocation = (symbol->value
719 + symbol->section->output_section->vma
720 + symbol->section->output_offset);
721 relocation += reloc_entry->addend;
722 if (howto->pc_relative)
723 {
724 relocation -= (input_section->output_section->vma
725 + input_section->output_offset);
726 relocation -= reloc_entry->address;
727 }
728
729 *prelocation = relocation;
730 *pinsn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
731 return bfd_reloc_other;
732 }
733
734 /* For unsupported relocs. */
735
736 static bfd_reloc_status_type
737 sparc_elf_notsup_reloc (abfd,
738 reloc_entry,
739 symbol,
740 data,
741 input_section,
742 output_bfd,
743 error_message)
744 bfd *abfd ATTRIBUTE_UNUSED;
745 arelent *reloc_entry ATTRIBUTE_UNUSED;
746 asymbol *symbol ATTRIBUTE_UNUSED;
747 PTR data ATTRIBUTE_UNUSED;
748 asection *input_section ATTRIBUTE_UNUSED;
749 bfd *output_bfd ATTRIBUTE_UNUSED;
750 char **error_message ATTRIBUTE_UNUSED;
751 {
752 return bfd_reloc_notsupported;
753 }
754
755 /* Handle the WDISP16 reloc. */
756
757 static bfd_reloc_status_type
758 sparc_elf_wdisp16_reloc (abfd, reloc_entry, symbol, data, input_section,
759 output_bfd, error_message)
760 bfd *abfd;
761 arelent *reloc_entry;
762 asymbol *symbol;
763 PTR data;
764 asection *input_section;
765 bfd *output_bfd;
766 char **error_message ATTRIBUTE_UNUSED;
767 {
768 bfd_vma relocation;
769 bfd_vma insn;
770 bfd_reloc_status_type status;
771
772 status = init_insn_reloc (abfd, reloc_entry, symbol, data,
773 input_section, output_bfd, &relocation, &insn);
774 if (status != bfd_reloc_other)
775 return status;
776
777 insn &= ~ (bfd_vma) 0x303fff;
778 insn |= (((relocation >> 2) & 0xc000) << 6) | ((relocation >> 2) & 0x3fff);
779 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
780
781 if ((bfd_signed_vma) relocation < - 0x40000
782 || (bfd_signed_vma) relocation > 0x3ffff)
783 return bfd_reloc_overflow;
784 else
785 return bfd_reloc_ok;
786 }
787
788 /* Handle the HIX22 reloc. */
789
790 static bfd_reloc_status_type
791 sparc_elf_hix22_reloc (abfd,
792 reloc_entry,
793 symbol,
794 data,
795 input_section,
796 output_bfd,
797 error_message)
798 bfd *abfd;
799 arelent *reloc_entry;
800 asymbol *symbol;
801 PTR data;
802 asection *input_section;
803 bfd *output_bfd;
804 char **error_message ATTRIBUTE_UNUSED;
805 {
806 bfd_vma relocation;
807 bfd_vma insn;
808 bfd_reloc_status_type status;
809
810 status = init_insn_reloc (abfd, reloc_entry, symbol, data,
811 input_section, output_bfd, &relocation, &insn);
812 if (status != bfd_reloc_other)
813 return status;
814
815 relocation ^= MINUS_ONE;
816 insn = (insn &~ (bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
817 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
818
819 if ((relocation & ~ (bfd_vma) 0xffffffff) != 0)
820 return bfd_reloc_overflow;
821 else
822 return bfd_reloc_ok;
823 }
824
825 /* Handle the LOX10 reloc. */
826
827 static bfd_reloc_status_type
828 sparc_elf_lox10_reloc (abfd,
829 reloc_entry,
830 symbol,
831 data,
832 input_section,
833 output_bfd,
834 error_message)
835 bfd *abfd;
836 arelent *reloc_entry;
837 asymbol *symbol;
838 PTR data;
839 asection *input_section;
840 bfd *output_bfd;
841 char **error_message ATTRIBUTE_UNUSED;
842 {
843 bfd_vma relocation;
844 bfd_vma insn;
845 bfd_reloc_status_type status;
846
847 status = init_insn_reloc (abfd, reloc_entry, symbol, data,
848 input_section, output_bfd, &relocation, &insn);
849 if (status != bfd_reloc_other)
850 return status;
851
852 insn = (insn &~ (bfd_vma) 0x1fff) | 0x1c00 | (relocation & 0x3ff);
853 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
854
855 return bfd_reloc_ok;
856 }
857 \f
858 /* PLT/GOT stuff */
859
860 /* Both the headers and the entries are icache aligned. */
861 #define PLT_ENTRY_SIZE 32
862 #define PLT_HEADER_SIZE (4 * PLT_ENTRY_SIZE)
863 #define LARGE_PLT_THRESHOLD 32768
864 #define GOT_RESERVED_ENTRIES 1
865
866 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/sparcv9/ld.so.1"
867
868 /* Fill in the .plt section. */
869
870 static void
871 sparc64_elf_build_plt (output_bfd, contents, nentries)
872 bfd *output_bfd;
873 unsigned char *contents;
874 int nentries;
875 {
876 const unsigned int nop = 0x01000000;
877 int i, j;
878
879 /* The first four entries are reserved, and are initially undefined.
880 We fill them with `illtrap 0' to force ld.so to do something. */
881
882 for (i = 0; i < PLT_HEADER_SIZE/4; ++i)
883 bfd_put_32 (output_bfd, (bfd_vma) 0, contents+i*4);
884
885 /* The first 32768 entries are close enough to plt1 to get there via
886 a straight branch. */
887
888 for (i = 4; i < LARGE_PLT_THRESHOLD && i < nentries; ++i)
889 {
890 unsigned char *entry = contents + i * PLT_ENTRY_SIZE;
891 unsigned int sethi, ba;
892
893 /* sethi (. - plt0), %g1 */
894 sethi = 0x03000000 | (i * PLT_ENTRY_SIZE);
895
896 /* ba,a,pt %xcc, plt1 */
897 ba = 0x30680000 | (((contents+PLT_ENTRY_SIZE) - (entry+4)) / 4 & 0x7ffff);
898
899 bfd_put_32 (output_bfd, (bfd_vma) sethi, entry);
900 bfd_put_32 (output_bfd, (bfd_vma) ba, entry + 4);
901 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 8);
902 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 12);
903 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 16);
904 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 20);
905 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 24);
906 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 28);
907 }
908
909 /* Now the tricky bit. Entries 32768 and higher are grouped in blocks of
910 160: 160 entries and 160 pointers. This is to separate code from data,
911 which is much friendlier on the cache. */
912
913 for (; i < nentries; i += 160)
914 {
915 int block = (i + 160 <= nentries ? 160 : nentries - i);
916 for (j = 0; j < block; ++j)
917 {
918 unsigned char *entry, *ptr;
919 unsigned int ldx;
920
921 entry = contents + i*PLT_ENTRY_SIZE + j*4*6;
922 ptr = contents + i*PLT_ENTRY_SIZE + block*4*6 + j*8;
923
924 /* ldx [%o7 + ptr - (entry+4)], %g1 */
925 ldx = 0xc25be000 | ((ptr - (entry+4)) & 0x1fff);
926
927 /* mov %o7,%g5
928 call .+8
929 nop
930 ldx [%o7+P],%g1
931 jmpl %o7+%g1,%g1
932 mov %g5,%o7 */
933 bfd_put_32 (output_bfd, (bfd_vma) 0x8a10000f, entry);
934 bfd_put_32 (output_bfd, (bfd_vma) 0x40000002, entry + 4);
935 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 8);
936 bfd_put_32 (output_bfd, (bfd_vma) ldx, entry + 12);
937 bfd_put_32 (output_bfd, (bfd_vma) 0x83c3c001, entry + 16);
938 bfd_put_32 (output_bfd, (bfd_vma) 0x9e100005, entry + 20);
939
940 bfd_put_64 (output_bfd, (bfd_vma) (contents - (entry + 4)), ptr);
941 }
942 }
943 }
944
945 /* Return the offset of a particular plt entry within the .plt section. */
946
947 static bfd_vma
948 sparc64_elf_plt_entry_offset (index)
949 bfd_vma index;
950 {
951 bfd_vma block, ofs;
952
953 if (index < LARGE_PLT_THRESHOLD)
954 return index * PLT_ENTRY_SIZE;
955
956 /* See above for details. */
957
958 block = (index - LARGE_PLT_THRESHOLD) / 160;
959 ofs = (index - LARGE_PLT_THRESHOLD) % 160;
960
961 return (LARGE_PLT_THRESHOLD + block * 160) * PLT_ENTRY_SIZE + ofs * 6 * 4;
962 }
963
964 static bfd_vma
965 sparc64_elf_plt_ptr_offset (index, max)
966 bfd_vma index;
967 bfd_vma max;
968 {
969 bfd_vma block, ofs, last;
970
971 BFD_ASSERT(index >= LARGE_PLT_THRESHOLD);
972
973 /* See above for details. */
974
975 block = (((index - LARGE_PLT_THRESHOLD) / 160) * 160) + LARGE_PLT_THRESHOLD;
976 ofs = index - block;
977 if (block + 160 > max)
978 last = (max - LARGE_PLT_THRESHOLD) % 160;
979 else
980 last = 160;
981
982 return (block * PLT_ENTRY_SIZE
983 + last * 6*4
984 + ofs * 8);
985 }
986 \f
987 /* Look through the relocs for a section during the first phase, and
988 allocate space in the global offset table or procedure linkage
989 table. */
990
991 static boolean
992 sparc64_elf_check_relocs (abfd, info, sec, relocs)
993 bfd *abfd;
994 struct bfd_link_info *info;
995 asection *sec;
996 const Elf_Internal_Rela *relocs;
997 {
998 bfd *dynobj;
999 Elf_Internal_Shdr *symtab_hdr;
1000 struct elf_link_hash_entry **sym_hashes;
1001 bfd_vma *local_got_offsets;
1002 const Elf_Internal_Rela *rel;
1003 const Elf_Internal_Rela *rel_end;
1004 asection *sgot;
1005 asection *srelgot;
1006 asection *sreloc;
1007
1008 if (info->relocateable || !(sec->flags & SEC_ALLOC))
1009 return true;
1010
1011 dynobj = elf_hash_table (info)->dynobj;
1012 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1013 sym_hashes = elf_sym_hashes (abfd);
1014 local_got_offsets = elf_local_got_offsets (abfd);
1015
1016 sgot = NULL;
1017 srelgot = NULL;
1018 sreloc = NULL;
1019
1020 rel_end = relocs + NUM_SHDR_ENTRIES (& elf_section_data (sec)->rel_hdr);
1021 for (rel = relocs; rel < rel_end; rel++)
1022 {
1023 unsigned long r_symndx;
1024 struct elf_link_hash_entry *h;
1025
1026 r_symndx = ELF64_R_SYM (rel->r_info);
1027 if (r_symndx < symtab_hdr->sh_info)
1028 h = NULL;
1029 else
1030 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1031
1032 switch (ELF64_R_TYPE_ID (rel->r_info))
1033 {
1034 case R_SPARC_GOT10:
1035 case R_SPARC_GOT13:
1036 case R_SPARC_GOT22:
1037 /* This symbol requires a global offset table entry. */
1038
1039 if (dynobj == NULL)
1040 {
1041 /* Create the .got section. */
1042 elf_hash_table (info)->dynobj = dynobj = abfd;
1043 if (! _bfd_elf_create_got_section (dynobj, info))
1044 return false;
1045 }
1046
1047 if (sgot == NULL)
1048 {
1049 sgot = bfd_get_section_by_name (dynobj, ".got");
1050 BFD_ASSERT (sgot != NULL);
1051 }
1052
1053 if (srelgot == NULL && (h != NULL || info->shared))
1054 {
1055 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1056 if (srelgot == NULL)
1057 {
1058 srelgot = bfd_make_section (dynobj, ".rela.got");
1059 if (srelgot == NULL
1060 || ! bfd_set_section_flags (dynobj, srelgot,
1061 (SEC_ALLOC
1062 | SEC_LOAD
1063 | SEC_HAS_CONTENTS
1064 | SEC_IN_MEMORY
1065 | SEC_LINKER_CREATED
1066 | SEC_READONLY))
1067 || ! bfd_set_section_alignment (dynobj, srelgot, 3))
1068 return false;
1069 }
1070 }
1071
1072 if (h != NULL)
1073 {
1074 if (h->got.offset != (bfd_vma) -1)
1075 {
1076 /* We have already allocated space in the .got. */
1077 break;
1078 }
1079 h->got.offset = sgot->_raw_size;
1080
1081 /* Make sure this symbol is output as a dynamic symbol. */
1082 if (h->dynindx == -1)
1083 {
1084 if (! bfd_elf64_link_record_dynamic_symbol (info, h))
1085 return false;
1086 }
1087
1088 srelgot->_raw_size += sizeof (Elf64_External_Rela);
1089 }
1090 else
1091 {
1092 /* This is a global offset table entry for a local
1093 symbol. */
1094 if (local_got_offsets == NULL)
1095 {
1096 bfd_size_type size;
1097 register unsigned int i;
1098
1099 size = symtab_hdr->sh_info;
1100 size *= sizeof (bfd_vma);
1101 local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
1102 if (local_got_offsets == NULL)
1103 return false;
1104 elf_local_got_offsets (abfd) = local_got_offsets;
1105 for (i = 0; i < symtab_hdr->sh_info; i++)
1106 local_got_offsets[i] = (bfd_vma) -1;
1107 }
1108 if (local_got_offsets[r_symndx] != (bfd_vma) -1)
1109 {
1110 /* We have already allocated space in the .got. */
1111 break;
1112 }
1113 local_got_offsets[r_symndx] = sgot->_raw_size;
1114
1115 if (info->shared)
1116 {
1117 /* If we are generating a shared object, we need to
1118 output a R_SPARC_RELATIVE reloc so that the
1119 dynamic linker can adjust this GOT entry. */
1120 srelgot->_raw_size += sizeof (Elf64_External_Rela);
1121 }
1122 }
1123
1124 sgot->_raw_size += 8;
1125
1126 #if 0
1127 /* Doesn't work for 64-bit -fPIC, since sethi/or builds
1128 unsigned numbers. If we permit ourselves to modify
1129 code so we get sethi/xor, this could work.
1130 Question: do we consider conditionally re-enabling
1131 this for -fpic, once we know about object code models? */
1132 /* If the .got section is more than 0x1000 bytes, we add
1133 0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13
1134 bit relocations have a greater chance of working. */
1135 if (sgot->_raw_size >= 0x1000
1136 && elf_hash_table (info)->hgot->root.u.def.value == 0)
1137 elf_hash_table (info)->hgot->root.u.def.value = 0x1000;
1138 #endif
1139
1140 break;
1141
1142 case R_SPARC_WPLT30:
1143 case R_SPARC_PLT32:
1144 case R_SPARC_HIPLT22:
1145 case R_SPARC_LOPLT10:
1146 case R_SPARC_PCPLT32:
1147 case R_SPARC_PCPLT22:
1148 case R_SPARC_PCPLT10:
1149 case R_SPARC_PLT64:
1150 /* This symbol requires a procedure linkage table entry. We
1151 actually build the entry in adjust_dynamic_symbol,
1152 because this might be a case of linking PIC code without
1153 linking in any dynamic objects, in which case we don't
1154 need to generate a procedure linkage table after all. */
1155
1156 if (h == NULL)
1157 {
1158 /* It does not make sense to have a procedure linkage
1159 table entry for a local symbol. */
1160 bfd_set_error (bfd_error_bad_value);
1161 return false;
1162 }
1163
1164 /* Make sure this symbol is output as a dynamic symbol. */
1165 if (h->dynindx == -1)
1166 {
1167 if (! bfd_elf64_link_record_dynamic_symbol (info, h))
1168 return false;
1169 }
1170
1171 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
1172 break;
1173
1174 case R_SPARC_PC10:
1175 case R_SPARC_PC22:
1176 case R_SPARC_PC_HH22:
1177 case R_SPARC_PC_HM10:
1178 case R_SPARC_PC_LM22:
1179 if (h != NULL
1180 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1181 break;
1182 /* Fall through. */
1183 case R_SPARC_DISP8:
1184 case R_SPARC_DISP16:
1185 case R_SPARC_DISP32:
1186 case R_SPARC_DISP64:
1187 case R_SPARC_WDISP30:
1188 case R_SPARC_WDISP22:
1189 case R_SPARC_WDISP19:
1190 case R_SPARC_WDISP16:
1191 if (h == NULL)
1192 break;
1193 /* Fall through. */
1194 case R_SPARC_8:
1195 case R_SPARC_16:
1196 case R_SPARC_32:
1197 case R_SPARC_HI22:
1198 case R_SPARC_22:
1199 case R_SPARC_13:
1200 case R_SPARC_LO10:
1201 case R_SPARC_UA32:
1202 case R_SPARC_10:
1203 case R_SPARC_11:
1204 case R_SPARC_64:
1205 case R_SPARC_OLO10:
1206 case R_SPARC_HH22:
1207 case R_SPARC_HM10:
1208 case R_SPARC_LM22:
1209 case R_SPARC_7:
1210 case R_SPARC_5:
1211 case R_SPARC_6:
1212 case R_SPARC_HIX22:
1213 case R_SPARC_LOX10:
1214 case R_SPARC_H44:
1215 case R_SPARC_M44:
1216 case R_SPARC_L44:
1217 case R_SPARC_UA64:
1218 case R_SPARC_UA16:
1219 /* When creating a shared object, we must copy these relocs
1220 into the output file. We create a reloc section in
1221 dynobj and make room for the reloc.
1222
1223 But don't do this for debugging sections -- this shows up
1224 with DWARF2 -- first because they are not loaded, and
1225 second because DWARF sez the debug info is not to be
1226 biased by the load address. */
1227 if (info->shared && (sec->flags & SEC_ALLOC))
1228 {
1229 if (sreloc == NULL)
1230 {
1231 const char *name;
1232
1233 name = (bfd_elf_string_from_elf_section
1234 (abfd,
1235 elf_elfheader (abfd)->e_shstrndx,
1236 elf_section_data (sec)->rel_hdr.sh_name));
1237 if (name == NULL)
1238 return false;
1239
1240 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
1241 && strcmp (bfd_get_section_name (abfd, sec),
1242 name + 5) == 0);
1243
1244 sreloc = bfd_get_section_by_name (dynobj, name);
1245 if (sreloc == NULL)
1246 {
1247 flagword flags;
1248
1249 sreloc = bfd_make_section (dynobj, name);
1250 flags = (SEC_HAS_CONTENTS | SEC_READONLY
1251 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1252 if ((sec->flags & SEC_ALLOC) != 0)
1253 flags |= SEC_ALLOC | SEC_LOAD;
1254 if (sreloc == NULL
1255 || ! bfd_set_section_flags (dynobj, sreloc, flags)
1256 || ! bfd_set_section_alignment (dynobj, sreloc, 3))
1257 return false;
1258 }
1259 if (sec->flags & SEC_READONLY)
1260 info->flags |= DF_TEXTREL;
1261 }
1262
1263 sreloc->_raw_size += sizeof (Elf64_External_Rela);
1264 }
1265 break;
1266
1267 case R_SPARC_REGISTER:
1268 /* Nothing to do. */
1269 break;
1270
1271 default:
1272 (*_bfd_error_handler) (_("%s: check_relocs: unhandled reloc type %d"),
1273 bfd_archive_filename (abfd),
1274 ELF64_R_TYPE_ID (rel->r_info));
1275 return false;
1276 }
1277 }
1278
1279 return true;
1280 }
1281
1282 /* Hook called by the linker routine which adds symbols from an object
1283 file. We use it for STT_REGISTER symbols. */
1284
1285 static boolean
1286 sparc64_elf_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
1287 bfd *abfd;
1288 struct bfd_link_info *info;
1289 const Elf_Internal_Sym *sym;
1290 const char **namep;
1291 flagword *flagsp ATTRIBUTE_UNUSED;
1292 asection **secp ATTRIBUTE_UNUSED;
1293 bfd_vma *valp ATTRIBUTE_UNUSED;
1294 {
1295 static const char *const stt_types[] = { "NOTYPE", "OBJECT", "FUNCTION" };
1296
1297 if (ELF_ST_TYPE (sym->st_info) == STT_REGISTER)
1298 {
1299 int reg;
1300 struct sparc64_elf_app_reg *p;
1301
1302 reg = (int)sym->st_value;
1303 switch (reg & ~1)
1304 {
1305 case 2: reg -= 2; break;
1306 case 6: reg -= 4; break;
1307 default:
1308 (*_bfd_error_handler)
1309 (_("%s: Only registers %%g[2367] can be declared using STT_REGISTER"),
1310 bfd_archive_filename (abfd));
1311 return false;
1312 }
1313
1314 if (info->hash->creator != abfd->xvec
1315 || (abfd->flags & DYNAMIC) != 0)
1316 {
1317 /* STT_REGISTER only works when linking an elf64_sparc object.
1318 If STT_REGISTER comes from a dynamic object, don't put it into
1319 the output bfd. The dynamic linker will recheck it. */
1320 *namep = NULL;
1321 return true;
1322 }
1323
1324 p = sparc64_elf_hash_table(info)->app_regs + reg;
1325
1326 if (p->name != NULL && strcmp (p->name, *namep))
1327 {
1328 (*_bfd_error_handler)
1329 (_("Register %%g%d used incompatibly: %s in %s"),
1330 (int) sym->st_value,
1331 **namep ? *namep : "#scratch", bfd_archive_filename (abfd));
1332 (*_bfd_error_handler)
1333 (_(" previously %s in %s"),
1334 *p->name ? p->name : "#scratch", bfd_archive_filename (p->abfd));
1335 return false;
1336 }
1337
1338 if (p->name == NULL)
1339 {
1340 if (**namep)
1341 {
1342 struct elf_link_hash_entry *h;
1343
1344 h = (struct elf_link_hash_entry *)
1345 bfd_link_hash_lookup (info->hash, *namep, false, false, false);
1346
1347 if (h != NULL)
1348 {
1349 unsigned char type = h->type;
1350
1351 if (type > STT_FUNC)
1352 type = 0;
1353 (*_bfd_error_handler)
1354 (_("Symbol `%s' has differing types: %s in %s"),
1355 *namep, "REGISTER", bfd_archive_filename (abfd));
1356 (*_bfd_error_handler)
1357 (_(" previously %s in %s"),
1358 stt_types[type], bfd_archive_filename (p->abfd));
1359 return false;
1360 }
1361
1362 p->name = bfd_hash_allocate (&info->hash->table,
1363 strlen (*namep) + 1);
1364 if (!p->name)
1365 return false;
1366
1367 strcpy (p->name, *namep);
1368 }
1369 else
1370 p->name = "";
1371 p->bind = ELF_ST_BIND (sym->st_info);
1372 p->abfd = abfd;
1373 p->shndx = sym->st_shndx;
1374 }
1375 else
1376 {
1377 if (p->bind == STB_WEAK
1378 && ELF_ST_BIND (sym->st_info) == STB_GLOBAL)
1379 {
1380 p->bind = STB_GLOBAL;
1381 p->abfd = abfd;
1382 }
1383 }
1384 *namep = NULL;
1385 return true;
1386 }
1387 else if (! *namep || ! **namep)
1388 return true;
1389 else
1390 {
1391 int i;
1392 struct sparc64_elf_app_reg *p;
1393
1394 p = sparc64_elf_hash_table(info)->app_regs;
1395 for (i = 0; i < 4; i++, p++)
1396 if (p->name != NULL && ! strcmp (p->name, *namep))
1397 {
1398 unsigned char type = ELF_ST_TYPE (sym->st_info);
1399
1400 if (type > STT_FUNC)
1401 type = 0;
1402 (*_bfd_error_handler)
1403 (_("Symbol `%s' has differing types: %s in %s"),
1404 *namep, stt_types[type], bfd_archive_filename (abfd));
1405 (*_bfd_error_handler)
1406 (_(" previously %s in %s"),
1407 "REGISTER", bfd_archive_filename (p->abfd));
1408 return false;
1409 }
1410 }
1411 return true;
1412 }
1413
1414 /* This function takes care of emiting STT_REGISTER symbols
1415 which we cannot easily keep in the symbol hash table. */
1416
1417 static boolean
1418 sparc64_elf_output_arch_syms (output_bfd, info, finfo, func)
1419 bfd *output_bfd ATTRIBUTE_UNUSED;
1420 struct bfd_link_info *info;
1421 PTR finfo;
1422 boolean (*func) PARAMS ((PTR, const char *,
1423 Elf_Internal_Sym *, asection *));
1424 {
1425 int reg;
1426 struct sparc64_elf_app_reg *app_regs =
1427 sparc64_elf_hash_table(info)->app_regs;
1428 Elf_Internal_Sym sym;
1429
1430 /* We arranged in size_dynamic_sections to put the STT_REGISTER entries
1431 at the end of the dynlocal list, so they came at the end of the local
1432 symbols in the symtab. Except that they aren't STB_LOCAL, so we need
1433 to back up symtab->sh_info. */
1434 if (elf_hash_table (info)->dynlocal)
1435 {
1436 bfd * dynobj = elf_hash_table (info)->dynobj;
1437 asection *dynsymsec = bfd_get_section_by_name (dynobj, ".dynsym");
1438 struct elf_link_local_dynamic_entry *e;
1439
1440 for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
1441 if (e->input_indx == -1)
1442 break;
1443 if (e)
1444 {
1445 elf_section_data (dynsymsec->output_section)->this_hdr.sh_info
1446 = e->dynindx;
1447 }
1448 }
1449
1450 if (info->strip == strip_all)
1451 return true;
1452
1453 for (reg = 0; reg < 4; reg++)
1454 if (app_regs [reg].name != NULL)
1455 {
1456 if (info->strip == strip_some
1457 && bfd_hash_lookup (info->keep_hash,
1458 app_regs [reg].name,
1459 false, false) == NULL)
1460 continue;
1461
1462 sym.st_value = reg < 2 ? reg + 2 : reg + 4;
1463 sym.st_size = 0;
1464 sym.st_other = 0;
1465 sym.st_info = ELF_ST_INFO (app_regs [reg].bind, STT_REGISTER);
1466 sym.st_shndx = app_regs [reg].shndx;
1467 if (! (*func) (finfo, app_regs [reg].name, &sym,
1468 sym.st_shndx == SHN_ABS
1469 ? bfd_abs_section_ptr : bfd_und_section_ptr))
1470 return false;
1471 }
1472
1473 return true;
1474 }
1475
1476 static int
1477 sparc64_elf_get_symbol_type (elf_sym, type)
1478 Elf_Internal_Sym * elf_sym;
1479 int type;
1480 {
1481 if (ELF_ST_TYPE (elf_sym->st_info) == STT_REGISTER)
1482 return STT_REGISTER;
1483 else
1484 return type;
1485 }
1486
1487 /* A STB_GLOBAL,STT_REGISTER symbol should be BSF_GLOBAL
1488 even in SHN_UNDEF section. */
1489
1490 static void
1491 sparc64_elf_symbol_processing (abfd, asym)
1492 bfd *abfd ATTRIBUTE_UNUSED;
1493 asymbol *asym;
1494 {
1495 elf_symbol_type *elfsym;
1496
1497 elfsym = (elf_symbol_type *) asym;
1498 if (elfsym->internal_elf_sym.st_info
1499 == ELF_ST_INFO (STB_GLOBAL, STT_REGISTER))
1500 {
1501 asym->flags |= BSF_GLOBAL;
1502 }
1503 }
1504
1505 /* Adjust a symbol defined by a dynamic object and referenced by a
1506 regular object. The current definition is in some section of the
1507 dynamic object, but we're not including those sections. We have to
1508 change the definition to something the rest of the link can
1509 understand. */
1510
1511 static boolean
1512 sparc64_elf_adjust_dynamic_symbol (info, h)
1513 struct bfd_link_info *info;
1514 struct elf_link_hash_entry *h;
1515 {
1516 bfd *dynobj;
1517 asection *s;
1518 unsigned int power_of_two;
1519
1520 dynobj = elf_hash_table (info)->dynobj;
1521
1522 /* Make sure we know what is going on here. */
1523 BFD_ASSERT (dynobj != NULL
1524 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
1525 || h->weakdef != NULL
1526 || ((h->elf_link_hash_flags
1527 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1528 && (h->elf_link_hash_flags
1529 & ELF_LINK_HASH_REF_REGULAR) != 0
1530 && (h->elf_link_hash_flags
1531 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
1532
1533 /* If this is a function, put it in the procedure linkage table. We
1534 will fill in the contents of the procedure linkage table later
1535 (although we could actually do it here). The STT_NOTYPE
1536 condition is a hack specifically for the Oracle libraries
1537 delivered for Solaris; for some inexplicable reason, they define
1538 some of their functions as STT_NOTYPE when they really should be
1539 STT_FUNC. */
1540 if (h->type == STT_FUNC
1541 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0
1542 || (h->type == STT_NOTYPE
1543 && (h->root.type == bfd_link_hash_defined
1544 || h->root.type == bfd_link_hash_defweak)
1545 && (h->root.u.def.section->flags & SEC_CODE) != 0))
1546 {
1547 if (! elf_hash_table (info)->dynamic_sections_created)
1548 {
1549 /* This case can occur if we saw a WPLT30 reloc in an input
1550 file, but none of the input files were dynamic objects.
1551 In such a case, we don't actually need to build a
1552 procedure linkage table, and we can just do a WDISP30
1553 reloc instead. */
1554 BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
1555 return true;
1556 }
1557
1558 s = bfd_get_section_by_name (dynobj, ".plt");
1559 BFD_ASSERT (s != NULL);
1560
1561 /* The first four bit in .plt is reserved. */
1562 if (s->_raw_size == 0)
1563 s->_raw_size = PLT_HEADER_SIZE;
1564
1565 /* If this symbol is not defined in a regular file, and we are
1566 not generating a shared library, then set the symbol to this
1567 location in the .plt. This is required to make function
1568 pointers compare as equal between the normal executable and
1569 the shared library. */
1570 if (! info->shared
1571 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1572 {
1573 h->root.u.def.section = s;
1574 h->root.u.def.value = s->_raw_size;
1575 }
1576
1577 /* To simplify matters later, just store the plt index here. */
1578 h->plt.offset = s->_raw_size / PLT_ENTRY_SIZE;
1579
1580 /* Make room for this entry. */
1581 s->_raw_size += PLT_ENTRY_SIZE;
1582
1583 /* We also need to make an entry in the .rela.plt section. */
1584
1585 s = bfd_get_section_by_name (dynobj, ".rela.plt");
1586 BFD_ASSERT (s != NULL);
1587
1588 s->_raw_size += sizeof (Elf64_External_Rela);
1589
1590 /* The procedure linkage table size is bounded by the magnitude
1591 of the offset we can describe in the entry. */
1592 if (s->_raw_size >= (bfd_vma)1 << 32)
1593 {
1594 bfd_set_error (bfd_error_bad_value);
1595 return false;
1596 }
1597
1598 return true;
1599 }
1600
1601 /* If this is a weak symbol, and there is a real definition, the
1602 processor independent code will have arranged for us to see the
1603 real definition first, and we can just use the same value. */
1604 if (h->weakdef != NULL)
1605 {
1606 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
1607 || h->weakdef->root.type == bfd_link_hash_defweak);
1608 h->root.u.def.section = h->weakdef->root.u.def.section;
1609 h->root.u.def.value = h->weakdef->root.u.def.value;
1610 return true;
1611 }
1612
1613 /* This is a reference to a symbol defined by a dynamic object which
1614 is not a function. */
1615
1616 /* If we are creating a shared library, we must presume that the
1617 only references to the symbol are via the global offset table.
1618 For such cases we need not do anything here; the relocations will
1619 be handled correctly by relocate_section. */
1620 if (info->shared)
1621 return true;
1622
1623 /* We must allocate the symbol in our .dynbss section, which will
1624 become part of the .bss section of the executable. There will be
1625 an entry for this symbol in the .dynsym section. The dynamic
1626 object will contain position independent code, so all references
1627 from the dynamic object to this symbol will go through the global
1628 offset table. The dynamic linker will use the .dynsym entry to
1629 determine the address it must put in the global offset table, so
1630 both the dynamic object and the regular object will refer to the
1631 same memory location for the variable. */
1632
1633 s = bfd_get_section_by_name (dynobj, ".dynbss");
1634 BFD_ASSERT (s != NULL);
1635
1636 /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker
1637 to copy the initial value out of the dynamic object and into the
1638 runtime process image. We need to remember the offset into the
1639 .rel.bss section we are going to use. */
1640 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1641 {
1642 asection *srel;
1643
1644 srel = bfd_get_section_by_name (dynobj, ".rela.bss");
1645 BFD_ASSERT (srel != NULL);
1646 srel->_raw_size += sizeof (Elf64_External_Rela);
1647 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
1648 }
1649
1650 /* We need to figure out the alignment required for this symbol. I
1651 have no idea how ELF linkers handle this. 16-bytes is the size
1652 of the largest type that requires hard alignment -- long double. */
1653 power_of_two = bfd_log2 (h->size);
1654 if (power_of_two > 4)
1655 power_of_two = 4;
1656
1657 /* Apply the required alignment. */
1658 s->_raw_size = BFD_ALIGN (s->_raw_size,
1659 (bfd_size_type) (1 << power_of_two));
1660 if (power_of_two > bfd_get_section_alignment (dynobj, s))
1661 {
1662 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
1663 return false;
1664 }
1665
1666 /* Define the symbol as being at this point in the section. */
1667 h->root.u.def.section = s;
1668 h->root.u.def.value = s->_raw_size;
1669
1670 /* Increment the section size to make room for the symbol. */
1671 s->_raw_size += h->size;
1672
1673 return true;
1674 }
1675
1676 /* Set the sizes of the dynamic sections. */
1677
1678 static boolean
1679 sparc64_elf_size_dynamic_sections (output_bfd, info)
1680 bfd *output_bfd;
1681 struct bfd_link_info *info;
1682 {
1683 bfd *dynobj;
1684 asection *s;
1685 boolean relplt;
1686
1687 dynobj = elf_hash_table (info)->dynobj;
1688 BFD_ASSERT (dynobj != NULL);
1689
1690 if (elf_hash_table (info)->dynamic_sections_created)
1691 {
1692 /* Set the contents of the .interp section to the interpreter. */
1693 if (! info->shared)
1694 {
1695 s = bfd_get_section_by_name (dynobj, ".interp");
1696 BFD_ASSERT (s != NULL);
1697 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
1698 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1699 }
1700 }
1701 else
1702 {
1703 /* We may have created entries in the .rela.got section.
1704 However, if we are not creating the dynamic sections, we will
1705 not actually use these entries. Reset the size of .rela.got,
1706 which will cause it to get stripped from the output file
1707 below. */
1708 s = bfd_get_section_by_name (dynobj, ".rela.got");
1709 if (s != NULL)
1710 s->_raw_size = 0;
1711 }
1712
1713 /* The check_relocs and adjust_dynamic_symbol entry points have
1714 determined the sizes of the various dynamic sections. Allocate
1715 memory for them. */
1716 relplt = false;
1717 for (s = dynobj->sections; s != NULL; s = s->next)
1718 {
1719 const char *name;
1720 boolean strip;
1721
1722 if ((s->flags & SEC_LINKER_CREATED) == 0)
1723 continue;
1724
1725 /* It's OK to base decisions on the section name, because none
1726 of the dynobj section names depend upon the input files. */
1727 name = bfd_get_section_name (dynobj, s);
1728
1729 strip = false;
1730
1731 if (strncmp (name, ".rela", 5) == 0)
1732 {
1733 if (s->_raw_size == 0)
1734 {
1735 /* If we don't need this section, strip it from the
1736 output file. This is to handle .rela.bss and
1737 .rel.plt. We must create it in
1738 create_dynamic_sections, because it must be created
1739 before the linker maps input sections to output
1740 sections. The linker does that before
1741 adjust_dynamic_symbol is called, and it is that
1742 function which decides whether anything needs to go
1743 into these sections. */
1744 strip = true;
1745 }
1746 else
1747 {
1748 if (strcmp (name, ".rela.plt") == 0)
1749 relplt = true;
1750
1751 /* We use the reloc_count field as a counter if we need
1752 to copy relocs into the output file. */
1753 s->reloc_count = 0;
1754 }
1755 }
1756 else if (strcmp (name, ".plt") != 0
1757 && strncmp (name, ".got", 4) != 0)
1758 {
1759 /* It's not one of our sections, so don't allocate space. */
1760 continue;
1761 }
1762
1763 if (strip)
1764 {
1765 _bfd_strip_section_from_output (info, s);
1766 continue;
1767 }
1768
1769 /* Allocate memory for the section contents. Zero the memory
1770 for the benefit of .rela.plt, which has 4 unused entries
1771 at the beginning, and we don't want garbage. */
1772 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
1773 if (s->contents == NULL && s->_raw_size != 0)
1774 return false;
1775 }
1776
1777 if (elf_hash_table (info)->dynamic_sections_created)
1778 {
1779 /* Add some entries to the .dynamic section. We fill in the
1780 values later, in sparc64_elf_finish_dynamic_sections, but we
1781 must add the entries now so that we get the correct size for
1782 the .dynamic section. The DT_DEBUG entry is filled in by the
1783 dynamic linker and used by the debugger. */
1784 #define add_dynamic_entry(TAG, VAL) \
1785 bfd_elf64_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1786
1787 int reg;
1788 struct sparc64_elf_app_reg * app_regs;
1789 struct elf_strtab_hash *dynstr;
1790 struct elf_link_hash_table *eht = elf_hash_table (info);
1791
1792 if (!info->shared)
1793 {
1794 if (!add_dynamic_entry (DT_DEBUG, 0))
1795 return false;
1796 }
1797
1798 if (relplt)
1799 {
1800 if (!add_dynamic_entry (DT_PLTGOT, 0)
1801 || !add_dynamic_entry (DT_PLTRELSZ, 0)
1802 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1803 || !add_dynamic_entry (DT_JMPREL, 0))
1804 return false;
1805 }
1806
1807 if (!add_dynamic_entry (DT_RELA, 0)
1808 || !add_dynamic_entry (DT_RELASZ, 0)
1809 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
1810 return false;
1811
1812 if (info->flags & DF_TEXTREL)
1813 {
1814 if (!add_dynamic_entry (DT_TEXTREL, 0))
1815 return false;
1816 }
1817
1818 /* Add dynamic STT_REGISTER symbols and corresponding DT_SPARC_REGISTER
1819 entries if needed. */
1820 app_regs = sparc64_elf_hash_table (info)->app_regs;
1821 dynstr = eht->dynstr;
1822
1823 for (reg = 0; reg < 4; reg++)
1824 if (app_regs [reg].name != NULL)
1825 {
1826 struct elf_link_local_dynamic_entry *entry, *e;
1827
1828 if (!add_dynamic_entry (DT_SPARC_REGISTER, 0))
1829 return false;
1830
1831 entry = (struct elf_link_local_dynamic_entry *)
1832 bfd_hash_allocate (&info->hash->table, sizeof (*entry));
1833 if (entry == NULL)
1834 return false;
1835
1836 /* We cheat here a little bit: the symbol will not be local, so we
1837 put it at the end of the dynlocal linked list. We will fix it
1838 later on, as we have to fix other fields anyway. */
1839 entry->isym.st_value = reg < 2 ? reg + 2 : reg + 4;
1840 entry->isym.st_size = 0;
1841 if (*app_regs [reg].name != '\0')
1842 entry->isym.st_name
1843 = _bfd_elf_strtab_add (dynstr, app_regs[reg].name, false);
1844 else
1845 entry->isym.st_name = 0;
1846 entry->isym.st_other = 0;
1847 entry->isym.st_info = ELF_ST_INFO (app_regs [reg].bind,
1848 STT_REGISTER);
1849 entry->isym.st_shndx = app_regs [reg].shndx;
1850 entry->next = NULL;
1851 entry->input_bfd = output_bfd;
1852 entry->input_indx = -1;
1853
1854 if (eht->dynlocal == NULL)
1855 eht->dynlocal = entry;
1856 else
1857 {
1858 for (e = eht->dynlocal; e->next; e = e->next)
1859 ;
1860 e->next = entry;
1861 }
1862 eht->dynsymcount++;
1863 }
1864 }
1865 #undef add_dynamic_entry
1866
1867 return true;
1868 }
1869 \f
1870 #define SET_SEC_DO_RELAX(section) do { elf_section_data(section)->tdata = (void *)1; } while (0)
1871 #define SEC_DO_RELAX(section) (elf_section_data(section)->tdata == (void *)1)
1872
1873 static boolean
1874 sparc64_elf_relax_section (abfd, section, link_info, again)
1875 bfd *abfd ATTRIBUTE_UNUSED;
1876 asection *section ATTRIBUTE_UNUSED;
1877 struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
1878 boolean *again;
1879 {
1880 *again = false;
1881 SET_SEC_DO_RELAX (section);
1882 return true;
1883 }
1884 \f
1885 /* Relocate a SPARC64 ELF section. */
1886
1887 static boolean
1888 sparc64_elf_relocate_section (output_bfd, info, input_bfd, input_section,
1889 contents, relocs, local_syms, local_sections)
1890 bfd *output_bfd;
1891 struct bfd_link_info *info;
1892 bfd *input_bfd;
1893 asection *input_section;
1894 bfd_byte *contents;
1895 Elf_Internal_Rela *relocs;
1896 Elf_Internal_Sym *local_syms;
1897 asection **local_sections;
1898 {
1899 bfd *dynobj;
1900 Elf_Internal_Shdr *symtab_hdr;
1901 struct elf_link_hash_entry **sym_hashes;
1902 bfd_vma *local_got_offsets;
1903 bfd_vma got_base;
1904 asection *sgot;
1905 asection *splt;
1906 asection *sreloc;
1907 Elf_Internal_Rela *rel;
1908 Elf_Internal_Rela *relend;
1909
1910 dynobj = elf_hash_table (info)->dynobj;
1911 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1912 sym_hashes = elf_sym_hashes (input_bfd);
1913 local_got_offsets = elf_local_got_offsets (input_bfd);
1914
1915 if (elf_hash_table(info)->hgot == NULL)
1916 got_base = 0;
1917 else
1918 got_base = elf_hash_table (info)->hgot->root.u.def.value;
1919
1920 sgot = splt = sreloc = NULL;
1921
1922 rel = relocs;
1923 relend = relocs + NUM_SHDR_ENTRIES (& elf_section_data (input_section)->rel_hdr);
1924 for (; rel < relend; rel++)
1925 {
1926 int r_type;
1927 reloc_howto_type *howto;
1928 unsigned long r_symndx;
1929 struct elf_link_hash_entry *h;
1930 Elf_Internal_Sym *sym;
1931 asection *sec;
1932 bfd_vma relocation;
1933 bfd_reloc_status_type r;
1934
1935 r_type = ELF64_R_TYPE_ID (rel->r_info);
1936 if (r_type < 0 || r_type >= (int) R_SPARC_max_std)
1937 {
1938 bfd_set_error (bfd_error_bad_value);
1939 return false;
1940 }
1941 howto = sparc64_elf_howto_table + r_type;
1942
1943 r_symndx = ELF64_R_SYM (rel->r_info);
1944
1945 if (info->relocateable)
1946 {
1947 /* This is a relocateable link. We don't have to change
1948 anything, unless the reloc is against a section symbol,
1949 in which case we have to adjust according to where the
1950 section symbol winds up in the output section. */
1951 if (r_symndx < symtab_hdr->sh_info)
1952 {
1953 sym = local_syms + r_symndx;
1954 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1955 {
1956 sec = local_sections[r_symndx];
1957 rel->r_addend += sec->output_offset + sym->st_value;
1958 }
1959 }
1960
1961 continue;
1962 }
1963
1964 /* This is a final link. */
1965 h = NULL;
1966 sym = NULL;
1967 sec = NULL;
1968 if (r_symndx < symtab_hdr->sh_info)
1969 {
1970 sym = local_syms + r_symndx;
1971 sec = local_sections[r_symndx];
1972 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
1973 }
1974 else
1975 {
1976 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1977 while (h->root.type == bfd_link_hash_indirect
1978 || h->root.type == bfd_link_hash_warning)
1979 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1980 if (h->root.type == bfd_link_hash_defined
1981 || h->root.type == bfd_link_hash_defweak)
1982 {
1983 boolean skip_it = false;
1984 sec = h->root.u.def.section;
1985
1986 switch (r_type)
1987 {
1988 case R_SPARC_WPLT30:
1989 case R_SPARC_PLT32:
1990 case R_SPARC_HIPLT22:
1991 case R_SPARC_LOPLT10:
1992 case R_SPARC_PCPLT32:
1993 case R_SPARC_PCPLT22:
1994 case R_SPARC_PCPLT10:
1995 case R_SPARC_PLT64:
1996 if (h->plt.offset != (bfd_vma) -1)
1997 skip_it = true;
1998 break;
1999
2000 case R_SPARC_GOT10:
2001 case R_SPARC_GOT13:
2002 case R_SPARC_GOT22:
2003 if (elf_hash_table(info)->dynamic_sections_created
2004 && (!info->shared
2005 || (!info->symbolic && h->dynindx != -1)
2006 || !(h->elf_link_hash_flags
2007 & ELF_LINK_HASH_DEF_REGULAR)))
2008 skip_it = true;
2009 break;
2010
2011 case R_SPARC_PC10:
2012 case R_SPARC_PC22:
2013 case R_SPARC_PC_HH22:
2014 case R_SPARC_PC_HM10:
2015 case R_SPARC_PC_LM22:
2016 if (!strcmp(h->root.root.string, "_GLOBAL_OFFSET_TABLE_"))
2017 break;
2018 /* FALLTHRU */
2019
2020 case R_SPARC_8:
2021 case R_SPARC_16:
2022 case R_SPARC_32:
2023 case R_SPARC_DISP8:
2024 case R_SPARC_DISP16:
2025 case R_SPARC_DISP32:
2026 case R_SPARC_WDISP30:
2027 case R_SPARC_WDISP22:
2028 case R_SPARC_HI22:
2029 case R_SPARC_22:
2030 case R_SPARC_13:
2031 case R_SPARC_LO10:
2032 case R_SPARC_UA32:
2033 case R_SPARC_10:
2034 case R_SPARC_11:
2035 case R_SPARC_64:
2036 case R_SPARC_OLO10:
2037 case R_SPARC_HH22:
2038 case R_SPARC_HM10:
2039 case R_SPARC_LM22:
2040 case R_SPARC_WDISP19:
2041 case R_SPARC_WDISP16:
2042 case R_SPARC_7:
2043 case R_SPARC_5:
2044 case R_SPARC_6:
2045 case R_SPARC_DISP64:
2046 case R_SPARC_HIX22:
2047 case R_SPARC_LOX10:
2048 case R_SPARC_H44:
2049 case R_SPARC_M44:
2050 case R_SPARC_L44:
2051 case R_SPARC_UA64:
2052 case R_SPARC_UA16:
2053 if (info->shared
2054 && ((!info->symbolic && h->dynindx != -1)
2055 || !(h->elf_link_hash_flags
2056 & ELF_LINK_HASH_DEF_REGULAR))
2057 && ((input_section->flags & SEC_ALLOC) != 0
2058 /* DWARF will emit R_SPARC_{32,64} relocations in
2059 its sections against symbols defined externally
2060 in shared libraries. We can't do anything
2061 with them here. */
2062 || ((input_section->flags & SEC_DEBUGGING) != 0
2063 && (h->elf_link_hash_flags
2064 & ELF_LINK_HASH_DEF_DYNAMIC) != 0)))
2065 skip_it = true;
2066 break;
2067 }
2068
2069 if (skip_it)
2070 {
2071 /* In these cases, we don't need the relocation
2072 value. We check specially because in some
2073 obscure cases sec->output_section will be NULL. */
2074 relocation = 0;
2075 }
2076 else
2077 {
2078 relocation = (h->root.u.def.value
2079 + sec->output_section->vma
2080 + sec->output_offset);
2081 }
2082 }
2083 else if (h->root.type == bfd_link_hash_undefweak)
2084 relocation = 0;
2085 else if (info->shared
2086 && (!info->symbolic || info->allow_shlib_undefined)
2087 && !info->no_undefined
2088 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2089 relocation = 0;
2090 else
2091 {
2092 if (! ((*info->callbacks->undefined_symbol)
2093 (info, h->root.root.string, input_bfd,
2094 input_section, rel->r_offset,
2095 (!info->shared || info->no_undefined
2096 || ELF_ST_VISIBILITY (h->other)))))
2097 return false;
2098
2099 /* To avoid generating warning messages about truncated
2100 relocations, set the relocation's address to be the same as
2101 the start of this section. */
2102
2103 if (input_section->output_section != NULL)
2104 relocation = input_section->output_section->vma;
2105 else
2106 relocation = 0;
2107 }
2108 }
2109
2110 /* When generating a shared object, these relocations are copied
2111 into the output file to be resolved at run time. */
2112 if (info->shared && r_symndx != 0 && (input_section->flags & SEC_ALLOC))
2113 {
2114 switch (r_type)
2115 {
2116 case R_SPARC_PC10:
2117 case R_SPARC_PC22:
2118 case R_SPARC_PC_HH22:
2119 case R_SPARC_PC_HM10:
2120 case R_SPARC_PC_LM22:
2121 if (h != NULL
2122 && !strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_"))
2123 break;
2124 /* Fall through. */
2125 case R_SPARC_DISP8:
2126 case R_SPARC_DISP16:
2127 case R_SPARC_DISP32:
2128 case R_SPARC_WDISP30:
2129 case R_SPARC_WDISP22:
2130 case R_SPARC_WDISP19:
2131 case R_SPARC_WDISP16:
2132 case R_SPARC_DISP64:
2133 if (h == NULL)
2134 break;
2135 /* Fall through. */
2136 case R_SPARC_8:
2137 case R_SPARC_16:
2138 case R_SPARC_32:
2139 case R_SPARC_HI22:
2140 case R_SPARC_22:
2141 case R_SPARC_13:
2142 case R_SPARC_LO10:
2143 case R_SPARC_UA32:
2144 case R_SPARC_10:
2145 case R_SPARC_11:
2146 case R_SPARC_64:
2147 case R_SPARC_OLO10:
2148 case R_SPARC_HH22:
2149 case R_SPARC_HM10:
2150 case R_SPARC_LM22:
2151 case R_SPARC_7:
2152 case R_SPARC_5:
2153 case R_SPARC_6:
2154 case R_SPARC_HIX22:
2155 case R_SPARC_LOX10:
2156 case R_SPARC_H44:
2157 case R_SPARC_M44:
2158 case R_SPARC_L44:
2159 case R_SPARC_UA64:
2160 case R_SPARC_UA16:
2161 {
2162 Elf_Internal_Rela outrel;
2163 boolean skip;
2164
2165 if (sreloc == NULL)
2166 {
2167 const char *name =
2168 (bfd_elf_string_from_elf_section
2169 (input_bfd,
2170 elf_elfheader (input_bfd)->e_shstrndx,
2171 elf_section_data (input_section)->rel_hdr.sh_name));
2172
2173 if (name == NULL)
2174 return false;
2175
2176 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
2177 && strcmp (bfd_get_section_name(input_bfd,
2178 input_section),
2179 name + 5) == 0);
2180
2181 sreloc = bfd_get_section_by_name (dynobj, name);
2182 BFD_ASSERT (sreloc != NULL);
2183 }
2184
2185 skip = false;
2186
2187 outrel.r_offset =
2188 _bfd_elf_section_offset (output_bfd, info, input_section,
2189 rel->r_offset);
2190 if (outrel.r_offset == (bfd_vma) -1)
2191 skip = true;
2192
2193 outrel.r_offset += (input_section->output_section->vma
2194 + input_section->output_offset);
2195
2196 /* Optimize unaligned reloc usage now that we know where
2197 it finally resides. */
2198 switch (r_type)
2199 {
2200 case R_SPARC_16:
2201 if (outrel.r_offset & 1) r_type = R_SPARC_UA16;
2202 break;
2203 case R_SPARC_UA16:
2204 if (!(outrel.r_offset & 1)) r_type = R_SPARC_16;
2205 break;
2206 case R_SPARC_32:
2207 if (outrel.r_offset & 3) r_type = R_SPARC_UA32;
2208 break;
2209 case R_SPARC_UA32:
2210 if (!(outrel.r_offset & 3)) r_type = R_SPARC_32;
2211 break;
2212 case R_SPARC_64:
2213 if (outrel.r_offset & 7) r_type = R_SPARC_UA64;
2214 break;
2215 case R_SPARC_UA64:
2216 if (!(outrel.r_offset & 7)) r_type = R_SPARC_64;
2217 break;
2218 }
2219
2220 if (skip)
2221 memset (&outrel, 0, sizeof outrel);
2222 /* h->dynindx may be -1 if the symbol was marked to
2223 become local. */
2224 else if (h != NULL
2225 && ((! info->symbolic && h->dynindx != -1)
2226 || (h->elf_link_hash_flags
2227 & ELF_LINK_HASH_DEF_REGULAR) == 0))
2228 {
2229 BFD_ASSERT (h->dynindx != -1);
2230 outrel.r_info
2231 = ELF64_R_INFO (h->dynindx,
2232 ELF64_R_TYPE_INFO (
2233 ELF64_R_TYPE_DATA (rel->r_info),
2234 r_type));
2235 outrel.r_addend = rel->r_addend;
2236 }
2237 else
2238 {
2239 if (r_type == R_SPARC_64)
2240 {
2241 outrel.r_info = ELF64_R_INFO (0, R_SPARC_RELATIVE);
2242 outrel.r_addend = relocation + rel->r_addend;
2243 }
2244 else
2245 {
2246 long indx;
2247
2248 if (h == NULL)
2249 sec = local_sections[r_symndx];
2250 else
2251 {
2252 BFD_ASSERT (h->root.type == bfd_link_hash_defined
2253 || (h->root.type
2254 == bfd_link_hash_defweak));
2255 sec = h->root.u.def.section;
2256 }
2257 if (sec != NULL && bfd_is_abs_section (sec))
2258 indx = 0;
2259 else if (sec == NULL || sec->owner == NULL)
2260 {
2261 bfd_set_error (bfd_error_bad_value);
2262 return false;
2263 }
2264 else
2265 {
2266 asection *osec;
2267
2268 osec = sec->output_section;
2269 indx = elf_section_data (osec)->dynindx;
2270
2271 /* FIXME: we really should be able to link non-pic
2272 shared libraries. */
2273 if (indx == 0)
2274 {
2275 BFD_FAIL ();
2276 (*_bfd_error_handler)
2277 (_("%s: probably compiled without -fPIC?"),
2278 bfd_archive_filename (input_bfd));
2279 bfd_set_error (bfd_error_bad_value);
2280 return false;
2281 }
2282 }
2283
2284 outrel.r_info
2285 = ELF64_R_INFO (indx,
2286 ELF64_R_TYPE_INFO (
2287 ELF64_R_TYPE_DATA (rel->r_info),
2288 r_type));
2289 outrel.r_addend = relocation + rel->r_addend;
2290 }
2291 }
2292
2293 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
2294 (((Elf64_External_Rela *)
2295 sreloc->contents)
2296 + sreloc->reloc_count));
2297 ++sreloc->reloc_count;
2298
2299 /* This reloc will be computed at runtime, so there's no
2300 need to do anything now. */
2301 continue;
2302 }
2303 break;
2304 }
2305 }
2306
2307 switch (r_type)
2308 {
2309 case R_SPARC_GOT10:
2310 case R_SPARC_GOT13:
2311 case R_SPARC_GOT22:
2312 /* Relocation is to the entry for this symbol in the global
2313 offset table. */
2314 if (sgot == NULL)
2315 {
2316 sgot = bfd_get_section_by_name (dynobj, ".got");
2317 BFD_ASSERT (sgot != NULL);
2318 }
2319
2320 if (h != NULL)
2321 {
2322 bfd_vma off = h->got.offset;
2323 BFD_ASSERT (off != (bfd_vma) -1);
2324
2325 if (! elf_hash_table (info)->dynamic_sections_created
2326 || (info->shared
2327 && (info->symbolic || h->dynindx == -1)
2328 && (h->elf_link_hash_flags
2329 & ELF_LINK_HASH_DEF_REGULAR)))
2330 {
2331 /* This is actually a static link, or it is a -Bsymbolic
2332 link and the symbol is defined locally, or the symbol
2333 was forced to be local because of a version file. We
2334 must initialize this entry in the global offset table.
2335 Since the offset must always be a multiple of 8, we
2336 use the least significant bit to record whether we
2337 have initialized it already.
2338
2339 When doing a dynamic link, we create a .rela.got
2340 relocation entry to initialize the value. This is
2341 done in the finish_dynamic_symbol routine. */
2342
2343 if ((off & 1) != 0)
2344 off &= ~1;
2345 else
2346 {
2347 bfd_put_64 (output_bfd, relocation,
2348 sgot->contents + off);
2349 h->got.offset |= 1;
2350 }
2351 }
2352 relocation = sgot->output_offset + off - got_base;
2353 }
2354 else
2355 {
2356 bfd_vma off;
2357
2358 BFD_ASSERT (local_got_offsets != NULL);
2359 off = local_got_offsets[r_symndx];
2360 BFD_ASSERT (off != (bfd_vma) -1);
2361
2362 /* The offset must always be a multiple of 8. We use
2363 the least significant bit to record whether we have
2364 already processed this entry. */
2365 if ((off & 1) != 0)
2366 off &= ~1;
2367 else
2368 {
2369 local_got_offsets[r_symndx] |= 1;
2370
2371 if (info->shared)
2372 {
2373 asection *srelgot;
2374 Elf_Internal_Rela outrel;
2375
2376 /* The Solaris 2.7 64-bit linker adds the contents
2377 of the location to the value of the reloc.
2378 Note this is different behaviour to the
2379 32-bit linker, which both adds the contents
2380 and ignores the addend. So clear the location. */
2381 bfd_put_64 (output_bfd, (bfd_vma) 0,
2382 sgot->contents + off);
2383
2384 /* We need to generate a R_SPARC_RELATIVE reloc
2385 for the dynamic linker. */
2386 srelgot = bfd_get_section_by_name(dynobj, ".rela.got");
2387 BFD_ASSERT (srelgot != NULL);
2388
2389 outrel.r_offset = (sgot->output_section->vma
2390 + sgot->output_offset
2391 + off);
2392 outrel.r_info = ELF64_R_INFO (0, R_SPARC_RELATIVE);
2393 outrel.r_addend = relocation;
2394 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
2395 (((Elf64_External_Rela *)
2396 srelgot->contents)
2397 + srelgot->reloc_count));
2398 ++srelgot->reloc_count;
2399 }
2400 else
2401 bfd_put_64 (output_bfd, relocation, sgot->contents + off);
2402 }
2403 relocation = sgot->output_offset + off - got_base;
2404 }
2405 goto do_default;
2406
2407 case R_SPARC_WPLT30:
2408 case R_SPARC_PLT32:
2409 case R_SPARC_HIPLT22:
2410 case R_SPARC_LOPLT10:
2411 case R_SPARC_PCPLT32:
2412 case R_SPARC_PCPLT22:
2413 case R_SPARC_PCPLT10:
2414 case R_SPARC_PLT64:
2415 /* Relocation is to the entry for this symbol in the
2416 procedure linkage table. */
2417 BFD_ASSERT (h != NULL);
2418
2419 if (h->plt.offset == (bfd_vma) -1)
2420 {
2421 /* We didn't make a PLT entry for this symbol. This
2422 happens when statically linking PIC code, or when
2423 using -Bsymbolic. */
2424 goto do_default;
2425 }
2426
2427 if (splt == NULL)
2428 {
2429 splt = bfd_get_section_by_name (dynobj, ".plt");
2430 BFD_ASSERT (splt != NULL);
2431 }
2432
2433 relocation = (splt->output_section->vma
2434 + splt->output_offset
2435 + sparc64_elf_plt_entry_offset (h->plt.offset));
2436 if (r_type == R_SPARC_WPLT30)
2437 goto do_wplt30;
2438 goto do_default;
2439
2440 case R_SPARC_OLO10:
2441 {
2442 bfd_vma x;
2443
2444 relocation += rel->r_addend;
2445 relocation = (relocation & 0x3ff) + ELF64_R_TYPE_DATA (rel->r_info);
2446
2447 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2448 x = (x & ~(bfd_vma) 0x1fff) | (relocation & 0x1fff);
2449 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2450
2451 r = bfd_check_overflow (howto->complain_on_overflow,
2452 howto->bitsize, howto->rightshift,
2453 bfd_arch_bits_per_address (input_bfd),
2454 relocation);
2455 }
2456 break;
2457
2458 case R_SPARC_WDISP16:
2459 {
2460 bfd_vma x;
2461
2462 relocation += rel->r_addend;
2463 /* Adjust for pc-relative-ness. */
2464 relocation -= (input_section->output_section->vma
2465 + input_section->output_offset);
2466 relocation -= rel->r_offset;
2467
2468 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2469 x &= ~(bfd_vma) 0x303fff;
2470 x |= ((((relocation >> 2) & 0xc000) << 6)
2471 | ((relocation >> 2) & 0x3fff));
2472 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2473
2474 r = bfd_check_overflow (howto->complain_on_overflow,
2475 howto->bitsize, howto->rightshift,
2476 bfd_arch_bits_per_address (input_bfd),
2477 relocation);
2478 }
2479 break;
2480
2481 case R_SPARC_HIX22:
2482 {
2483 bfd_vma x;
2484
2485 relocation += rel->r_addend;
2486 relocation = relocation ^ MINUS_ONE;
2487
2488 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2489 x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
2490 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2491
2492 r = bfd_check_overflow (howto->complain_on_overflow,
2493 howto->bitsize, howto->rightshift,
2494 bfd_arch_bits_per_address (input_bfd),
2495 relocation);
2496 }
2497 break;
2498
2499 case R_SPARC_LOX10:
2500 {
2501 bfd_vma x;
2502
2503 relocation += rel->r_addend;
2504 relocation = (relocation & 0x3ff) | 0x1c00;
2505
2506 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2507 x = (x & ~(bfd_vma) 0x1fff) | relocation;
2508 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2509
2510 r = bfd_reloc_ok;
2511 }
2512 break;
2513
2514 case R_SPARC_WDISP30:
2515 do_wplt30:
2516 if (SEC_DO_RELAX (input_section)
2517 && rel->r_offset + 4 < input_section->_raw_size)
2518 {
2519 #define G0 0
2520 #define O7 15
2521 #define XCC (2 << 20)
2522 #define COND(x) (((x)&0xf)<<25)
2523 #define CONDA COND(0x8)
2524 #define INSN_BPA (F2(0,1) | CONDA | BPRED | XCC)
2525 #define INSN_BA (F2(0,2) | CONDA)
2526 #define INSN_OR F3(2, 0x2, 0)
2527 #define INSN_NOP F2(0,4)
2528
2529 bfd_vma x, y;
2530
2531 /* If the instruction is a call with either:
2532 restore
2533 arithmetic instruction with rd == %o7
2534 where rs1 != %o7 and rs2 if it is register != %o7
2535 then we can optimize if the call destination is near
2536 by changing the call into a branch always. */
2537 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2538 y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
2539 if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2))
2540 {
2541 if (((y & OP3(~0)) == OP3(0x3d) /* restore */
2542 || ((y & OP3(0x28)) == 0 /* arithmetic */
2543 && (y & RD(~0)) == RD(O7)))
2544 && (y & RS1(~0)) != RS1(O7)
2545 && ((y & F3I(~0))
2546 || (y & RS2(~0)) != RS2(O7)))
2547 {
2548 bfd_vma reloc;
2549
2550 reloc = relocation + rel->r_addend - rel->r_offset;
2551 reloc -= (input_section->output_section->vma
2552 + input_section->output_offset);
2553 if (reloc & 3)
2554 goto do_default;
2555
2556 /* Ensure the branch fits into simm22. */
2557 if ((reloc & ~(bfd_vma)0x7fffff)
2558 && ((reloc | 0x7fffff) != MINUS_ONE))
2559 goto do_default;
2560 reloc >>= 2;
2561
2562 /* Check whether it fits into simm19. */
2563 if ((reloc & 0x3c0000) == 0
2564 || (reloc & 0x3c0000) == 0x3c0000)
2565 x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */
2566 else
2567 x = INSN_BA | (reloc & 0x3fffff); /* ba */
2568 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2569 r = bfd_reloc_ok;
2570 if (rel->r_offset >= 4
2571 && (y & (0xffffffff ^ RS1(~0)))
2572 == (INSN_OR | RD(O7) | RS2(G0)))
2573 {
2574 bfd_vma z;
2575 unsigned int reg;
2576
2577 z = bfd_get_32 (input_bfd,
2578 contents + rel->r_offset - 4);
2579 if ((z & (0xffffffff ^ RD(~0)))
2580 != (INSN_OR | RS1(O7) | RS2(G0)))
2581 break;
2582
2583 /* The sequence was
2584 or %o7, %g0, %rN
2585 call foo
2586 or %rN, %g0, %o7
2587
2588 If call foo was replaced with ba, replace
2589 or %rN, %g0, %o7 with nop. */
2590
2591 reg = (y & RS1(~0)) >> 14;
2592 if (reg != ((z & RD(~0)) >> 25)
2593 || reg == G0 || reg == O7)
2594 break;
2595
2596 bfd_put_32 (input_bfd, (bfd_vma) INSN_NOP,
2597 contents + rel->r_offset + 4);
2598 }
2599 break;
2600 }
2601 }
2602 }
2603 /* FALLTHROUGH */
2604
2605 default:
2606 do_default:
2607 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2608 contents, rel->r_offset,
2609 relocation, rel->r_addend);
2610 break;
2611 }
2612
2613 switch (r)
2614 {
2615 case bfd_reloc_ok:
2616 break;
2617
2618 default:
2619 case bfd_reloc_outofrange:
2620 abort ();
2621
2622 case bfd_reloc_overflow:
2623 {
2624 const char *name;
2625
2626 /* The Solaris native linker silently disregards
2627 overflows. We don't, but this breaks stabs debugging
2628 info, whose relocations are only 32-bits wide. Ignore
2629 overflows in this case. */
2630 if (r_type == R_SPARC_32
2631 && (input_section->flags & SEC_DEBUGGING) != 0
2632 && strcmp (bfd_section_name (input_bfd, input_section),
2633 ".stab") == 0)
2634 break;
2635
2636 if (h != NULL)
2637 {
2638 if (h->root.type == bfd_link_hash_undefweak
2639 && howto->pc_relative)
2640 {
2641 /* Assume this is a call protected by other code that
2642 detect the symbol is undefined. If this is the case,
2643 we can safely ignore the overflow. If not, the
2644 program is hosed anyway, and a little warning isn't
2645 going to help. */
2646 break;
2647 }
2648
2649 name = h->root.root.string;
2650 }
2651 else
2652 {
2653 name = (bfd_elf_string_from_elf_section
2654 (input_bfd,
2655 symtab_hdr->sh_link,
2656 sym->st_name));
2657 if (name == NULL)
2658 return false;
2659 if (*name == '\0')
2660 name = bfd_section_name (input_bfd, sec);
2661 }
2662 if (! ((*info->callbacks->reloc_overflow)
2663 (info, name, howto->name, (bfd_vma) 0,
2664 input_bfd, input_section, rel->r_offset)))
2665 return false;
2666 }
2667 break;
2668 }
2669 }
2670
2671 return true;
2672 }
2673
2674 /* Finish up dynamic symbol handling. We set the contents of various
2675 dynamic sections here. */
2676
2677 static boolean
2678 sparc64_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
2679 bfd *output_bfd;
2680 struct bfd_link_info *info;
2681 struct elf_link_hash_entry *h;
2682 Elf_Internal_Sym *sym;
2683 {
2684 bfd *dynobj;
2685
2686 dynobj = elf_hash_table (info)->dynobj;
2687
2688 if (h->plt.offset != (bfd_vma) -1)
2689 {
2690 asection *splt;
2691 asection *srela;
2692 Elf_Internal_Rela rela;
2693
2694 /* This symbol has an entry in the PLT. Set it up. */
2695
2696 BFD_ASSERT (h->dynindx != -1);
2697
2698 splt = bfd_get_section_by_name (dynobj, ".plt");
2699 srela = bfd_get_section_by_name (dynobj, ".rela.plt");
2700 BFD_ASSERT (splt != NULL && srela != NULL);
2701
2702 /* Fill in the entry in the .rela.plt section. */
2703
2704 if (h->plt.offset < LARGE_PLT_THRESHOLD)
2705 {
2706 rela.r_offset = sparc64_elf_plt_entry_offset (h->plt.offset);
2707 rela.r_addend = 0;
2708 }
2709 else
2710 {
2711 bfd_vma max = splt->_raw_size / PLT_ENTRY_SIZE;
2712 rela.r_offset = sparc64_elf_plt_ptr_offset (h->plt.offset, max);
2713 rela.r_addend = -(sparc64_elf_plt_entry_offset (h->plt.offset) + 4)
2714 -(splt->output_section->vma + splt->output_offset);
2715 }
2716 rela.r_offset += (splt->output_section->vma + splt->output_offset);
2717 rela.r_info = ELF64_R_INFO (h->dynindx, R_SPARC_JMP_SLOT);
2718
2719 /* Adjust for the first 4 reserved elements in the .plt section
2720 when setting the offset in the .rela.plt section.
2721 Sun forgot to read their own ABI and copied elf32-sparc behaviour,
2722 thus .plt[4] has corresponding .rela.plt[0] and so on. */
2723
2724 bfd_elf64_swap_reloca_out (output_bfd, &rela,
2725 ((Elf64_External_Rela *) srela->contents
2726 + (h->plt.offset - 4)));
2727
2728 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2729 {
2730 /* Mark the symbol as undefined, rather than as defined in
2731 the .plt section. Leave the value alone. */
2732 sym->st_shndx = SHN_UNDEF;
2733 /* If the symbol is weak, we do need to clear the value.
2734 Otherwise, the PLT entry would provide a definition for
2735 the symbol even if the symbol wasn't defined anywhere,
2736 and so the symbol would never be NULL. */
2737 if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK)
2738 == 0)
2739 sym->st_value = 0;
2740 }
2741 }
2742
2743 if (h->got.offset != (bfd_vma) -1)
2744 {
2745 asection *sgot;
2746 asection *srela;
2747 Elf_Internal_Rela rela;
2748
2749 /* This symbol has an entry in the GOT. Set it up. */
2750
2751 sgot = bfd_get_section_by_name (dynobj, ".got");
2752 srela = bfd_get_section_by_name (dynobj, ".rela.got");
2753 BFD_ASSERT (sgot != NULL && srela != NULL);
2754
2755 rela.r_offset = (sgot->output_section->vma
2756 + sgot->output_offset
2757 + (h->got.offset &~ (bfd_vma) 1));
2758
2759 /* If this is a -Bsymbolic link, and the symbol is defined
2760 locally, we just want to emit a RELATIVE reloc. Likewise if
2761 the symbol was forced to be local because of a version file.
2762 The entry in the global offset table will already have been
2763 initialized in the relocate_section function. */
2764 if (info->shared
2765 && (info->symbolic || h->dynindx == -1)
2766 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
2767 {
2768 asection *sec = h->root.u.def.section;
2769 rela.r_info = ELF64_R_INFO (0, R_SPARC_RELATIVE);
2770 rela.r_addend = (h->root.u.def.value
2771 + sec->output_section->vma
2772 + sec->output_offset);
2773 }
2774 else
2775 {
2776 bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
2777 rela.r_info = ELF64_R_INFO (h->dynindx, R_SPARC_GLOB_DAT);
2778 rela.r_addend = 0;
2779 }
2780
2781 bfd_elf64_swap_reloca_out (output_bfd, &rela,
2782 ((Elf64_External_Rela *) srela->contents
2783 + srela->reloc_count));
2784 ++srela->reloc_count;
2785 }
2786
2787 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
2788 {
2789 asection *s;
2790 Elf_Internal_Rela rela;
2791
2792 /* This symbols needs a copy reloc. Set it up. */
2793
2794 BFD_ASSERT (h->dynindx != -1);
2795
2796 s = bfd_get_section_by_name (h->root.u.def.section->owner,
2797 ".rela.bss");
2798 BFD_ASSERT (s != NULL);
2799
2800 rela.r_offset = (h->root.u.def.value
2801 + h->root.u.def.section->output_section->vma
2802 + h->root.u.def.section->output_offset);
2803 rela.r_info = ELF64_R_INFO (h->dynindx, R_SPARC_COPY);
2804 rela.r_addend = 0;
2805 bfd_elf64_swap_reloca_out (output_bfd, &rela,
2806 ((Elf64_External_Rela *) s->contents
2807 + s->reloc_count));
2808 ++s->reloc_count;
2809 }
2810
2811 /* Mark some specially defined symbols as absolute. */
2812 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2813 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
2814 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
2815 sym->st_shndx = SHN_ABS;
2816
2817 return true;
2818 }
2819
2820 /* Finish up the dynamic sections. */
2821
2822 static boolean
2823 sparc64_elf_finish_dynamic_sections (output_bfd, info)
2824 bfd *output_bfd;
2825 struct bfd_link_info *info;
2826 {
2827 bfd *dynobj;
2828 int stt_regidx = -1;
2829 asection *sdyn;
2830 asection *sgot;
2831
2832 dynobj = elf_hash_table (info)->dynobj;
2833
2834 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2835
2836 if (elf_hash_table (info)->dynamic_sections_created)
2837 {
2838 asection *splt;
2839 Elf64_External_Dyn *dyncon, *dynconend;
2840
2841 splt = bfd_get_section_by_name (dynobj, ".plt");
2842 BFD_ASSERT (splt != NULL && sdyn != NULL);
2843
2844 dyncon = (Elf64_External_Dyn *) sdyn->contents;
2845 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
2846 for (; dyncon < dynconend; dyncon++)
2847 {
2848 Elf_Internal_Dyn dyn;
2849 const char *name;
2850 boolean size;
2851
2852 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
2853
2854 switch (dyn.d_tag)
2855 {
2856 case DT_PLTGOT: name = ".plt"; size = false; break;
2857 case DT_PLTRELSZ: name = ".rela.plt"; size = true; break;
2858 case DT_JMPREL: name = ".rela.plt"; size = false; break;
2859 case DT_SPARC_REGISTER:
2860 if (stt_regidx == -1)
2861 {
2862 stt_regidx =
2863 _bfd_elf_link_lookup_local_dynindx (info, output_bfd, -1);
2864 if (stt_regidx == -1)
2865 return false;
2866 }
2867 dyn.d_un.d_val = stt_regidx++;
2868 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2869 /* fallthrough */
2870 default: name = NULL; size = false; break;
2871 }
2872
2873 if (name != NULL)
2874 {
2875 asection *s;
2876
2877 s = bfd_get_section_by_name (output_bfd, name);
2878 if (s == NULL)
2879 dyn.d_un.d_val = 0;
2880 else
2881 {
2882 if (! size)
2883 dyn.d_un.d_ptr = s->vma;
2884 else
2885 {
2886 if (s->_cooked_size != 0)
2887 dyn.d_un.d_val = s->_cooked_size;
2888 else
2889 dyn.d_un.d_val = s->_raw_size;
2890 }
2891 }
2892 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2893 }
2894 }
2895
2896 /* Initialize the contents of the .plt section. */
2897 if (splt->_raw_size > 0)
2898 {
2899 sparc64_elf_build_plt (output_bfd, splt->contents,
2900 (int) (splt->_raw_size / PLT_ENTRY_SIZE));
2901 }
2902
2903 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
2904 PLT_ENTRY_SIZE;
2905 }
2906
2907 /* Set the first entry in the global offset table to the address of
2908 the dynamic section. */
2909 sgot = bfd_get_section_by_name (dynobj, ".got");
2910 BFD_ASSERT (sgot != NULL);
2911 if (sgot->_raw_size > 0)
2912 {
2913 if (sdyn == NULL)
2914 bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents);
2915 else
2916 bfd_put_64 (output_bfd,
2917 sdyn->output_section->vma + sdyn->output_offset,
2918 sgot->contents);
2919 }
2920
2921 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 8;
2922
2923 return true;
2924 }
2925
2926 static enum elf_reloc_type_class
2927 sparc64_elf_reloc_type_class (rela)
2928 const Elf_Internal_Rela *rela;
2929 {
2930 switch ((int) ELF64_R_TYPE (rela->r_info))
2931 {
2932 case R_SPARC_RELATIVE:
2933 return reloc_class_relative;
2934 case R_SPARC_JMP_SLOT:
2935 return reloc_class_plt;
2936 case R_SPARC_COPY:
2937 return reloc_class_copy;
2938 default:
2939 return reloc_class_normal;
2940 }
2941 }
2942 \f
2943 /* Functions for dealing with the e_flags field. */
2944
2945 /* Copy backend specific data from one object module to another */
2946 static boolean
2947 sparc64_elf_copy_private_bfd_data (ibfd, obfd)
2948 bfd *ibfd, *obfd;
2949 {
2950 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2951 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2952 return true;
2953
2954 BFD_ASSERT (!elf_flags_init (obfd)
2955 || (elf_elfheader (obfd)->e_flags
2956 == elf_elfheader (ibfd)->e_flags));
2957
2958 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
2959 elf_flags_init (obfd) = true;
2960 return true;
2961 }
2962
2963 /* Merge backend specific data from an object file to the output
2964 object file when linking. */
2965
2966 static boolean
2967 sparc64_elf_merge_private_bfd_data (ibfd, obfd)
2968 bfd *ibfd;
2969 bfd *obfd;
2970 {
2971 boolean error;
2972 flagword new_flags, old_flags;
2973 int new_mm, old_mm;
2974
2975 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2976 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2977 return true;
2978
2979 new_flags = elf_elfheader (ibfd)->e_flags;
2980 old_flags = elf_elfheader (obfd)->e_flags;
2981
2982 if (!elf_flags_init (obfd)) /* First call, no flags set */
2983 {
2984 elf_flags_init (obfd) = true;
2985 elf_elfheader (obfd)->e_flags = new_flags;
2986 }
2987
2988 else if (new_flags == old_flags) /* Compatible flags are ok */
2989 ;
2990
2991 else /* Incompatible flags */
2992 {
2993 error = false;
2994
2995 #define EF_SPARC_ISA_EXTENSIONS \
2996 (EF_SPARC_SUN_US1 | EF_SPARC_SUN_US3 | EF_SPARC_HAL_R1)
2997
2998 if ((ibfd->flags & DYNAMIC) != 0)
2999 {
3000 /* We don't want dynamic objects memory ordering and
3001 architecture to have any role. That's what dynamic linker
3002 should do. */
3003 new_flags &= ~(EF_SPARCV9_MM | EF_SPARC_ISA_EXTENSIONS);
3004 new_flags |= (old_flags
3005 & (EF_SPARCV9_MM | EF_SPARC_ISA_EXTENSIONS));
3006 }
3007 else
3008 {
3009 /* Choose the highest architecture requirements. */
3010 old_flags |= (new_flags & EF_SPARC_ISA_EXTENSIONS);
3011 new_flags |= (old_flags & EF_SPARC_ISA_EXTENSIONS);
3012 if ((old_flags & (EF_SPARC_SUN_US1 | EF_SPARC_SUN_US3))
3013 && (old_flags & EF_SPARC_HAL_R1))
3014 {
3015 error = true;
3016 (*_bfd_error_handler)
3017 (_("%s: linking UltraSPARC specific with HAL specific code"),
3018 bfd_archive_filename (ibfd));
3019 }
3020 /* Choose the most restrictive memory ordering. */
3021 old_mm = (old_flags & EF_SPARCV9_MM);
3022 new_mm = (new_flags & EF_SPARCV9_MM);
3023 old_flags &= ~EF_SPARCV9_MM;
3024 new_flags &= ~EF_SPARCV9_MM;
3025 if (new_mm < old_mm)
3026 old_mm = new_mm;
3027 old_flags |= old_mm;
3028 new_flags |= old_mm;
3029 }
3030
3031 /* Warn about any other mismatches */
3032 if (new_flags != old_flags)
3033 {
3034 error = true;
3035 (*_bfd_error_handler)
3036 (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
3037 bfd_archive_filename (ibfd), (long) new_flags, (long) old_flags);
3038 }
3039
3040 elf_elfheader (obfd)->e_flags = old_flags;
3041
3042 if (error)
3043 {
3044 bfd_set_error (bfd_error_bad_value);
3045 return false;
3046 }
3047 }
3048 return true;
3049 }
3050 \f
3051 /* Print a STT_REGISTER symbol to file FILE. */
3052
3053 static const char *
3054 sparc64_elf_print_symbol_all (abfd, filep, symbol)
3055 bfd *abfd ATTRIBUTE_UNUSED;
3056 PTR filep;
3057 asymbol *symbol;
3058 {
3059 FILE *file = (FILE *) filep;
3060 int reg, type;
3061
3062 if (ELF_ST_TYPE (((elf_symbol_type *) symbol)->internal_elf_sym.st_info)
3063 != STT_REGISTER)
3064 return NULL;
3065
3066 reg = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value;
3067 type = symbol->flags;
3068 fprintf (file, "REG_%c%c%11s%c%c R", "GOLI" [reg / 8], '0' + (reg & 7), "",
3069 ((type & BSF_LOCAL)
3070 ? (type & BSF_GLOBAL) ? '!' : 'l'
3071 : (type & BSF_GLOBAL) ? 'g' : ' '),
3072 (type & BSF_WEAK) ? 'w' : ' ');
3073 if (symbol->name == NULL || symbol->name [0] == '\0')
3074 return "#scratch";
3075 else
3076 return symbol->name;
3077 }
3078 \f
3079 /* Set the right machine number for a SPARC64 ELF file. */
3080
3081 static boolean
3082 sparc64_elf_object_p (abfd)
3083 bfd *abfd;
3084 {
3085 unsigned long mach = bfd_mach_sparc_v9;
3086
3087 if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
3088 mach = bfd_mach_sparc_v9b;
3089 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
3090 mach = bfd_mach_sparc_v9a;
3091 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, mach);
3092 }
3093
3094 /* Relocations in the 64 bit SPARC ELF ABI are more complex than in
3095 standard ELF, because R_SPARC_OLO10 has secondary addend in
3096 ELF64_R_TYPE_DATA field. This structure is used to redirect the
3097 relocation handling routines. */
3098
3099 const struct elf_size_info sparc64_elf_size_info =
3100 {
3101 sizeof (Elf64_External_Ehdr),
3102 sizeof (Elf64_External_Phdr),
3103 sizeof (Elf64_External_Shdr),
3104 sizeof (Elf64_External_Rel),
3105 sizeof (Elf64_External_Rela),
3106 sizeof (Elf64_External_Sym),
3107 sizeof (Elf64_External_Dyn),
3108 sizeof (Elf_External_Note),
3109 4, /* hash-table entry size */
3110 /* internal relocations per external relocations.
3111 For link purposes we use just 1 internal per
3112 1 external, for assembly and slurp symbol table
3113 we use 2. */
3114 1,
3115 64, /* arch_size */
3116 8, /* file_align */
3117 ELFCLASS64,
3118 EV_CURRENT,
3119 bfd_elf64_write_out_phdrs,
3120 bfd_elf64_write_shdrs_and_ehdr,
3121 sparc64_elf_write_relocs,
3122 bfd_elf64_swap_symbol_out,
3123 sparc64_elf_slurp_reloc_table,
3124 bfd_elf64_slurp_symbol_table,
3125 bfd_elf64_swap_dyn_in,
3126 bfd_elf64_swap_dyn_out,
3127 NULL,
3128 NULL,
3129 NULL,
3130 NULL
3131 };
3132
3133 #define TARGET_BIG_SYM bfd_elf64_sparc_vec
3134 #define TARGET_BIG_NAME "elf64-sparc"
3135 #define ELF_ARCH bfd_arch_sparc
3136 #define ELF_MAXPAGESIZE 0x100000
3137
3138 /* This is the official ABI value. */
3139 #define ELF_MACHINE_CODE EM_SPARCV9
3140
3141 /* This is the value that we used before the ABI was released. */
3142 #define ELF_MACHINE_ALT1 EM_OLD_SPARCV9
3143
3144 #define bfd_elf64_bfd_link_hash_table_create \
3145 sparc64_elf_bfd_link_hash_table_create
3146
3147 #define elf_info_to_howto \
3148 sparc64_elf_info_to_howto
3149 #define bfd_elf64_get_reloc_upper_bound \
3150 sparc64_elf_get_reloc_upper_bound
3151 #define bfd_elf64_get_dynamic_reloc_upper_bound \
3152 sparc64_elf_get_dynamic_reloc_upper_bound
3153 #define bfd_elf64_canonicalize_dynamic_reloc \
3154 sparc64_elf_canonicalize_dynamic_reloc
3155 #define bfd_elf64_bfd_reloc_type_lookup \
3156 sparc64_elf_reloc_type_lookup
3157 #define bfd_elf64_bfd_relax_section \
3158 sparc64_elf_relax_section
3159
3160 #define elf_backend_create_dynamic_sections \
3161 _bfd_elf_create_dynamic_sections
3162 #define elf_backend_add_symbol_hook \
3163 sparc64_elf_add_symbol_hook
3164 #define elf_backend_get_symbol_type \
3165 sparc64_elf_get_symbol_type
3166 #define elf_backend_symbol_processing \
3167 sparc64_elf_symbol_processing
3168 #define elf_backend_check_relocs \
3169 sparc64_elf_check_relocs
3170 #define elf_backend_adjust_dynamic_symbol \
3171 sparc64_elf_adjust_dynamic_symbol
3172 #define elf_backend_size_dynamic_sections \
3173 sparc64_elf_size_dynamic_sections
3174 #define elf_backend_relocate_section \
3175 sparc64_elf_relocate_section
3176 #define elf_backend_finish_dynamic_symbol \
3177 sparc64_elf_finish_dynamic_symbol
3178 #define elf_backend_finish_dynamic_sections \
3179 sparc64_elf_finish_dynamic_sections
3180 #define elf_backend_print_symbol_all \
3181 sparc64_elf_print_symbol_all
3182 #define elf_backend_output_arch_syms \
3183 sparc64_elf_output_arch_syms
3184 #define bfd_elf64_bfd_copy_private_bfd_data \
3185 sparc64_elf_copy_private_bfd_data
3186 #define bfd_elf64_bfd_merge_private_bfd_data \
3187 sparc64_elf_merge_private_bfd_data
3188
3189 #define elf_backend_size_info \
3190 sparc64_elf_size_info
3191 #define elf_backend_object_p \
3192 sparc64_elf_object_p
3193 #define elf_backend_reloc_type_class \
3194 sparc64_elf_reloc_type_class
3195
3196 #define elf_backend_want_got_plt 0
3197 #define elf_backend_plt_readonly 0
3198 #define elf_backend_want_plt_sym 1
3199
3200 /* Section 5.2.4 of the ABI specifies a 256-byte boundary for the table. */
3201 #define elf_backend_plt_alignment 8
3202
3203 #define elf_backend_got_header_size 8
3204 #define elf_backend_plt_header_size PLT_HEADER_SIZE
3205
3206 #include "elf64-target.h"
git-cvsimport of binutils cvsroot