1 /* SPARC-specific support for 64-bit ELF
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
3 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
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.
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.
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. */
25 #include "opcode/sparc.h"
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*/
32 #include "elf/sparc.h"
34 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
35 #define MINUS_ONE (~ (bfd_vma) 0)
37 static struct bfd_link_hash_table
* sparc64_elf_bfd_link_hash_table_create
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
*));
47 static void sparc64_elf_build_plt
48 PARAMS ((bfd
*, unsigned char *, int));
49 static bfd_vma sparc64_elf_plt_entry_offset
51 static bfd_vma sparc64_elf_plt_ptr_offset
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 void sparc64_elf_symbol_processing
67 PARAMS ((bfd
*, asymbol
*));
69 static boolean sparc64_elf_copy_private_bfd_data
70 PARAMS ((bfd
*, bfd
*));
71 static boolean sparc64_elf_merge_private_bfd_data
72 PARAMS ((bfd
*, bfd
*));
74 static const char *sparc64_elf_print_symbol_all
75 PARAMS ((bfd
*, PTR
, asymbol
*));
76 static boolean sparc64_elf_relax_section
77 PARAMS ((bfd
*, asection
*, struct bfd_link_info
*, boolean
*));
78 static boolean sparc64_elf_relocate_section
79 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
80 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**));
81 static boolean sparc64_elf_finish_dynamic_symbol
82 PARAMS ((bfd
*, struct bfd_link_info
*, struct elf_link_hash_entry
*,
84 static boolean sparc64_elf_finish_dynamic_sections
85 PARAMS ((bfd
*, struct bfd_link_info
*));
86 static boolean sparc64_elf_object_p
PARAMS ((bfd
*));
87 static long sparc64_elf_get_reloc_upper_bound
PARAMS ((bfd
*, asection
*));
88 static long sparc64_elf_get_dynamic_reloc_upper_bound
PARAMS ((bfd
*));
89 static boolean sparc64_elf_slurp_one_reloc_table
90 PARAMS ((bfd
*, asection
*, Elf_Internal_Shdr
*, asymbol
**, boolean
));
91 static boolean sparc64_elf_slurp_reloc_table
92 PARAMS ((bfd
*, asection
*, asymbol
**, boolean
));
93 static long sparc64_elf_canonicalize_dynamic_reloc
94 PARAMS ((bfd
*, arelent
**, asymbol
**));
95 static void sparc64_elf_write_relocs
PARAMS ((bfd
*, asection
*, PTR
));
97 /* The relocation "howto" table. */
99 static bfd_reloc_status_type sparc_elf_notsup_reloc
100 PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
101 static bfd_reloc_status_type sparc_elf_wdisp16_reloc
102 PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
103 static bfd_reloc_status_type sparc_elf_hix22_reloc
104 PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
105 static bfd_reloc_status_type sparc_elf_lox10_reloc
106 PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
108 static reloc_howto_type sparc64_elf_howto_table
[] =
110 HOWTO(R_SPARC_NONE
, 0,0, 0,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_NONE", false,0,0x00000000,true),
111 HOWTO(R_SPARC_8
, 0,0, 8,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_8", false,0,0x000000ff,true),
112 HOWTO(R_SPARC_16
, 0,1,16,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_16", false,0,0x0000ffff,true),
113 HOWTO(R_SPARC_32
, 0,2,32,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_32", false,0,0xffffffff,true),
114 HOWTO(R_SPARC_DISP8
, 0,0, 8,true, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_DISP8", false,0,0x000000ff,true),
115 HOWTO(R_SPARC_DISP16
, 0,1,16,true, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_DISP16", false,0,0x0000ffff,true),
116 HOWTO(R_SPARC_DISP32
, 0,2,32,true, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_DISP32", false,0,0x00ffffff,true),
117 HOWTO(R_SPARC_WDISP30
, 2,2,30,true, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_WDISP30", false,0,0x3fffffff,true),
118 HOWTO(R_SPARC_WDISP22
, 2,2,22,true, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_WDISP22", false,0,0x003fffff,true),
119 HOWTO(R_SPARC_HI22
, 10,2,22,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_HI22", false,0,0x003fffff,true),
120 HOWTO(R_SPARC_22
, 0,2,22,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_22", false,0,0x003fffff,true),
121 HOWTO(R_SPARC_13
, 0,2,13,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_13", false,0,0x00001fff,true),
122 HOWTO(R_SPARC_LO10
, 0,2,10,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_LO10", false,0,0x000003ff,true),
123 HOWTO(R_SPARC_GOT10
, 0,2,10,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_GOT10", false,0,0x000003ff,true),
124 HOWTO(R_SPARC_GOT13
, 0,2,13,false,0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_GOT13", false,0,0x00001fff,true),
125 HOWTO(R_SPARC_GOT22
, 10,2,22,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_GOT22", false,0,0x003fffff,true),
126 HOWTO(R_SPARC_PC10
, 0,2,10,true, 0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_PC10", false,0,0x000003ff,true),
127 HOWTO(R_SPARC_PC22
, 10,2,22,true, 0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_PC22", false,0,0x003fffff,true),
128 HOWTO(R_SPARC_WPLT30
, 2,2,30,true, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_WPLT30", false,0,0x3fffffff,true),
129 HOWTO(R_SPARC_COPY
, 0,0,00,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_COPY", false,0,0x00000000,true),
130 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),
131 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),
132 HOWTO(R_SPARC_RELATIVE
, 0,0,00,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_RELATIVE",false,0,0x00000000,true),
133 HOWTO(R_SPARC_UA32
, 0,2,32,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_UA32", false,0,0xffffffff,true),
134 #ifndef SPARC64_OLD_RELOCS
135 /* These aren't implemented yet. */
136 HOWTO(R_SPARC_PLT32
, 0,0,00,false,0,complain_overflow_dont
, sparc_elf_notsup_reloc
, "R_SPARC_PLT32", false,0,0x00000000,true),
137 HOWTO(R_SPARC_HIPLT22
, 0,0,00,false,0,complain_overflow_dont
, sparc_elf_notsup_reloc
, "R_SPARC_HIPLT22", false,0,0x00000000,true),
138 HOWTO(R_SPARC_LOPLT10
, 0,0,00,false,0,complain_overflow_dont
, sparc_elf_notsup_reloc
, "R_SPARC_LOPLT10", false,0,0x00000000,true),
139 HOWTO(R_SPARC_PCPLT32
, 0,0,00,false,0,complain_overflow_dont
, sparc_elf_notsup_reloc
, "R_SPARC_PCPLT32", false,0,0x00000000,true),
140 HOWTO(R_SPARC_PCPLT22
, 0,0,00,false,0,complain_overflow_dont
, sparc_elf_notsup_reloc
, "R_SPARC_PCPLT22", false,0,0x00000000,true),
141 HOWTO(R_SPARC_PCPLT10
, 0,0,00,false,0,complain_overflow_dont
, sparc_elf_notsup_reloc
, "R_SPARC_PCPLT10", false,0,0x00000000,true),
143 HOWTO(R_SPARC_10
, 0,2,10,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_10", false,0,0x000003ff,true),
144 HOWTO(R_SPARC_11
, 0,2,11,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_11", false,0,0x000007ff,true),
145 HOWTO(R_SPARC_64
, 0,4,64,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_64", false,0,MINUS_ONE
, true),
146 HOWTO(R_SPARC_OLO10
, 0,2,13,false,0,complain_overflow_signed
, sparc_elf_notsup_reloc
, "R_SPARC_OLO10", false,0,0x00001fff,true),
147 HOWTO(R_SPARC_HH22
, 42,2,22,false,0,complain_overflow_unsigned
,bfd_elf_generic_reloc
, "R_SPARC_HH22", false,0,0x003fffff,true),
148 HOWTO(R_SPARC_HM10
, 32,2,10,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_HM10", false,0,0x000003ff,true),
149 HOWTO(R_SPARC_LM22
, 10,2,22,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_LM22", false,0,0x003fffff,true),
150 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),
151 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),
152 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),
153 HOWTO(R_SPARC_WDISP16
, 2,2,16,true, 0,complain_overflow_signed
, sparc_elf_wdisp16_reloc
,"R_SPARC_WDISP16", false,0,0x00000000,true),
154 HOWTO(R_SPARC_WDISP19
, 2,2,19,true, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_WDISP19", false,0,0x0007ffff,true),
155 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),
156 HOWTO(R_SPARC_7
, 0,2, 7,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_7", false,0,0x0000007f,true),
157 HOWTO(R_SPARC_5
, 0,2, 5,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_5", false,0,0x0000001f,true),
158 HOWTO(R_SPARC_6
, 0,2, 6,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_6", false,0,0x0000003f,true),
159 HOWTO(R_SPARC_DISP64
, 0,4,64,true, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_DISP64", false,0,MINUS_ONE
, true),
160 HOWTO(R_SPARC_PLT64
, 0,4,64,false,0,complain_overflow_bitfield
,sparc_elf_notsup_reloc
, "R_SPARC_PLT64", false,0,MINUS_ONE
, false),
161 HOWTO(R_SPARC_HIX22
, 0,4, 0,false,0,complain_overflow_bitfield
,sparc_elf_hix22_reloc
, "R_SPARC_HIX22", false,0,MINUS_ONE
, false),
162 HOWTO(R_SPARC_LOX10
, 0,4, 0,false,0,complain_overflow_dont
, sparc_elf_lox10_reloc
, "R_SPARC_LOX10", false,0,MINUS_ONE
, false),
163 HOWTO(R_SPARC_H44
, 22,2,22,false,0,complain_overflow_unsigned
,bfd_elf_generic_reloc
, "R_SPARC_H44", false,0,0x003fffff,false),
164 HOWTO(R_SPARC_M44
, 12,2,10,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_M44", false,0,0x000003ff,false),
165 HOWTO(R_SPARC_L44
, 0,2,13,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_L44", false,0,0x00000fff,false),
166 HOWTO(R_SPARC_REGISTER
, 0,4, 0,false,0,complain_overflow_bitfield
,sparc_elf_notsup_reloc
, "R_SPARC_REGISTER",false,0,MINUS_ONE
, false),
167 HOWTO(R_SPARC_UA64
, 0,4,64,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_UA64", false,0,MINUS_ONE
, true),
168 HOWTO(R_SPARC_UA16
, 0,1,16,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_UA16", false,0,0x0000ffff,true)
171 struct elf_reloc_map
{
172 bfd_reloc_code_real_type bfd_reloc_val
;
173 unsigned char elf_reloc_val
;
176 static CONST
struct elf_reloc_map sparc_reloc_map
[] =
178 { BFD_RELOC_NONE
, R_SPARC_NONE
, },
179 { BFD_RELOC_16
, R_SPARC_16
, },
180 { BFD_RELOC_8
, R_SPARC_8
},
181 { BFD_RELOC_8_PCREL
, R_SPARC_DISP8
},
182 { BFD_RELOC_CTOR
, R_SPARC_64
},
183 { BFD_RELOC_32
, R_SPARC_32
},
184 { BFD_RELOC_32_PCREL
, R_SPARC_DISP32
},
185 { BFD_RELOC_HI22
, R_SPARC_HI22
},
186 { BFD_RELOC_LO10
, R_SPARC_LO10
, },
187 { BFD_RELOC_32_PCREL_S2
, R_SPARC_WDISP30
},
188 { BFD_RELOC_SPARC22
, R_SPARC_22
},
189 { BFD_RELOC_SPARC13
, R_SPARC_13
},
190 { BFD_RELOC_SPARC_GOT10
, R_SPARC_GOT10
},
191 { BFD_RELOC_SPARC_GOT13
, R_SPARC_GOT13
},
192 { BFD_RELOC_SPARC_GOT22
, R_SPARC_GOT22
},
193 { BFD_RELOC_SPARC_PC10
, R_SPARC_PC10
},
194 { BFD_RELOC_SPARC_PC22
, R_SPARC_PC22
},
195 { BFD_RELOC_SPARC_WPLT30
, R_SPARC_WPLT30
},
196 { BFD_RELOC_SPARC_COPY
, R_SPARC_COPY
},
197 { BFD_RELOC_SPARC_GLOB_DAT
, R_SPARC_GLOB_DAT
},
198 { BFD_RELOC_SPARC_JMP_SLOT
, R_SPARC_JMP_SLOT
},
199 { BFD_RELOC_SPARC_RELATIVE
, R_SPARC_RELATIVE
},
200 { BFD_RELOC_SPARC_WDISP22
, R_SPARC_WDISP22
},
201 { BFD_RELOC_SPARC_UA16
, R_SPARC_UA16
},
202 { BFD_RELOC_SPARC_UA32
, R_SPARC_UA32
},
203 { BFD_RELOC_SPARC_UA64
, R_SPARC_UA64
},
204 { BFD_RELOC_SPARC_10
, R_SPARC_10
},
205 { BFD_RELOC_SPARC_11
, R_SPARC_11
},
206 { BFD_RELOC_SPARC_64
, R_SPARC_64
},
207 { BFD_RELOC_SPARC_OLO10
, R_SPARC_OLO10
},
208 { BFD_RELOC_SPARC_HH22
, R_SPARC_HH22
},
209 { BFD_RELOC_SPARC_HM10
, R_SPARC_HM10
},
210 { BFD_RELOC_SPARC_LM22
, R_SPARC_LM22
},
211 { BFD_RELOC_SPARC_PC_HH22
, R_SPARC_PC_HH22
},
212 { BFD_RELOC_SPARC_PC_HM10
, R_SPARC_PC_HM10
},
213 { BFD_RELOC_SPARC_PC_LM22
, R_SPARC_PC_LM22
},
214 { BFD_RELOC_SPARC_WDISP16
, R_SPARC_WDISP16
},
215 { BFD_RELOC_SPARC_WDISP19
, R_SPARC_WDISP19
},
216 { BFD_RELOC_SPARC_7
, R_SPARC_7
},
217 { BFD_RELOC_SPARC_5
, R_SPARC_5
},
218 { BFD_RELOC_SPARC_6
, R_SPARC_6
},
219 { BFD_RELOC_SPARC_DISP64
, R_SPARC_DISP64
},
220 { BFD_RELOC_SPARC_PLT64
, R_SPARC_PLT64
},
221 { BFD_RELOC_SPARC_HIX22
, R_SPARC_HIX22
},
222 { BFD_RELOC_SPARC_LOX10
, R_SPARC_LOX10
},
223 { BFD_RELOC_SPARC_H44
, R_SPARC_H44
},
224 { BFD_RELOC_SPARC_M44
, R_SPARC_M44
},
225 { BFD_RELOC_SPARC_L44
, R_SPARC_L44
},
226 { BFD_RELOC_SPARC_REGISTER
, R_SPARC_REGISTER
}
229 static reloc_howto_type
*
230 sparc64_elf_reloc_type_lookup (abfd
, code
)
231 bfd
*abfd ATTRIBUTE_UNUSED
;
232 bfd_reloc_code_real_type code
;
235 for (i
= 0; i
< sizeof (sparc_reloc_map
) / sizeof (struct elf_reloc_map
); i
++)
237 if (sparc_reloc_map
[i
].bfd_reloc_val
== code
)
238 return &sparc64_elf_howto_table
[(int) sparc_reloc_map
[i
].elf_reloc_val
];
244 sparc64_elf_info_to_howto (abfd
, cache_ptr
, dst
)
245 bfd
*abfd ATTRIBUTE_UNUSED
;
247 Elf64_Internal_Rela
*dst
;
249 BFD_ASSERT (ELF64_R_TYPE_ID (dst
->r_info
) < (unsigned int) R_SPARC_max_std
);
250 cache_ptr
->howto
= &sparc64_elf_howto_table
[ELF64_R_TYPE_ID (dst
->r_info
)];
253 /* Due to the way how we handle R_SPARC_OLO10, each entry in a SHT_RELA
254 section can represent up to two relocs, we must tell the user to allocate
258 sparc64_elf_get_reloc_upper_bound (abfd
, sec
)
259 bfd
*abfd ATTRIBUTE_UNUSED
;
262 return (sec
->reloc_count
* 2 + 1) * sizeof (arelent
*);
266 sparc64_elf_get_dynamic_reloc_upper_bound (abfd
)
269 return _bfd_elf_get_dynamic_reloc_upper_bound (abfd
) * 2;
272 /* Read relocations for ASECT from REL_HDR. There are RELOC_COUNT of
273 them. We cannot use generic elf routines for this, because R_SPARC_OLO10
274 has secondary addend in ELF64_R_TYPE_DATA. We handle it as two relocations
275 for the same location, R_SPARC_LO10 and R_SPARC_13. */
278 sparc64_elf_slurp_one_reloc_table (abfd
, asect
, rel_hdr
, symbols
, dynamic
)
281 Elf_Internal_Shdr
*rel_hdr
;
285 PTR allocated
= NULL
;
286 bfd_byte
*native_relocs
;
293 allocated
= (PTR
) bfd_malloc ((size_t) rel_hdr
->sh_size
);
294 if (allocated
== NULL
)
297 if (bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0
298 || (bfd_read (allocated
, 1, rel_hdr
->sh_size
, abfd
)
299 != rel_hdr
->sh_size
))
302 native_relocs
= (bfd_byte
*) allocated
;
304 relents
= asect
->relocation
+ asect
->reloc_count
;
306 entsize
= rel_hdr
->sh_entsize
;
307 BFD_ASSERT (entsize
== sizeof (Elf64_External_Rela
));
309 count
= rel_hdr
->sh_size
/ entsize
;
311 for (i
= 0, relent
= relents
; i
< count
;
312 i
++, relent
++, native_relocs
+= entsize
)
314 Elf_Internal_Rela rela
;
316 bfd_elf64_swap_reloca_in (abfd
, (Elf64_External_Rela
*) native_relocs
, &rela
);
318 /* The address of an ELF reloc is section relative for an object
319 file, and absolute for an executable file or shared library.
320 The address of a normal BFD reloc is always section relative,
321 and the address of a dynamic reloc is absolute.. */
322 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0 || dynamic
)
323 relent
->address
= rela
.r_offset
;
325 relent
->address
= rela
.r_offset
- asect
->vma
;
327 if (ELF64_R_SYM (rela
.r_info
) == 0)
328 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
333 ps
= symbols
+ ELF64_R_SYM (rela
.r_info
) - 1;
336 /* Canonicalize ELF section symbols. FIXME: Why? */
337 if ((s
->flags
& BSF_SECTION_SYM
) == 0)
338 relent
->sym_ptr_ptr
= ps
;
340 relent
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
343 relent
->addend
= rela
.r_addend
;
345 BFD_ASSERT (ELF64_R_TYPE_ID (rela
.r_info
) < (unsigned int) R_SPARC_max_std
);
346 if (ELF64_R_TYPE_ID (rela
.r_info
) == R_SPARC_OLO10
)
348 relent
->howto
= &sparc64_elf_howto_table
[R_SPARC_LO10
];
349 relent
[1].address
= relent
->address
;
351 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
352 relent
->addend
= ELF64_R_TYPE_DATA (rela
.r_info
);
353 relent
->howto
= &sparc64_elf_howto_table
[R_SPARC_13
];
356 relent
->howto
= &sparc64_elf_howto_table
[ELF64_R_TYPE_ID (rela
.r_info
)];
359 asect
->reloc_count
+= relent
- relents
;
361 if (allocated
!= NULL
)
367 if (allocated
!= NULL
)
372 /* Read in and swap the external relocs. */
375 sparc64_elf_slurp_reloc_table (abfd
, asect
, symbols
, dynamic
)
381 struct bfd_elf_section_data
* const d
= elf_section_data (asect
);
382 Elf_Internal_Shdr
*rel_hdr
;
383 Elf_Internal_Shdr
*rel_hdr2
;
385 if (asect
->relocation
!= NULL
)
390 if ((asect
->flags
& SEC_RELOC
) == 0
391 || asect
->reloc_count
== 0)
394 rel_hdr
= &d
->rel_hdr
;
395 rel_hdr2
= d
->rel_hdr2
;
397 BFD_ASSERT (asect
->rel_filepos
== rel_hdr
->sh_offset
398 || (rel_hdr2
&& asect
->rel_filepos
== rel_hdr2
->sh_offset
));
402 /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
403 case because relocations against this section may use the
404 dynamic symbol table, and in that case bfd_section_from_shdr
405 in elf.c does not update the RELOC_COUNT. */
406 if (asect
->_raw_size
== 0)
409 rel_hdr
= &d
->this_hdr
;
410 asect
->reloc_count
= NUM_SHDR_ENTRIES (rel_hdr
);
414 asect
->relocation
= ((arelent
*)
416 asect
->reloc_count
* 2 * sizeof (arelent
)));
417 if (asect
->relocation
== NULL
)
420 /* The sparc64_elf_slurp_one_reloc_table routine increments reloc_count. */
421 asect
->reloc_count
= 0;
423 if (!sparc64_elf_slurp_one_reloc_table (abfd
, asect
, rel_hdr
, symbols
,
428 && !sparc64_elf_slurp_one_reloc_table (abfd
, asect
, rel_hdr2
, symbols
,
435 /* Canonicalize the dynamic relocation entries. Note that we return
436 the dynamic relocations as a single block, although they are
437 actually associated with particular sections; the interface, which
438 was designed for SunOS style shared libraries, expects that there
439 is only one set of dynamic relocs. Any section that was actually
440 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
441 the dynamic symbol table, is considered to be a dynamic reloc
445 sparc64_elf_canonicalize_dynamic_reloc (abfd
, storage
, syms
)
453 if (elf_dynsymtab (abfd
) == 0)
455 bfd_set_error (bfd_error_invalid_operation
);
460 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
462 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
463 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
468 if (! sparc64_elf_slurp_reloc_table (abfd
, s
, syms
, true))
470 count
= s
->reloc_count
;
472 for (i
= 0; i
< count
; i
++)
483 /* Write out the relocs. */
486 sparc64_elf_write_relocs (abfd
, sec
, data
)
491 boolean
*failedp
= (boolean
*) data
;
492 Elf_Internal_Shdr
*rela_hdr
;
493 Elf64_External_Rela
*outbound_relocas
, *src_rela
;
494 unsigned int idx
, count
;
495 asymbol
*last_sym
= 0;
496 int last_sym_idx
= 0;
498 /* If we have already failed, don't do anything. */
502 if ((sec
->flags
& SEC_RELOC
) == 0)
505 /* The linker backend writes the relocs out itself, and sets the
506 reloc_count field to zero to inhibit writing them here. Also,
507 sometimes the SEC_RELOC flag gets set even when there aren't any
509 if (sec
->reloc_count
== 0)
512 /* We can combine two relocs that refer to the same address
513 into R_SPARC_OLO10 if first one is R_SPARC_LO10 and the
514 latter is R_SPARC_13 with no associated symbol. */
516 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
522 addr
= sec
->orelocation
[idx
]->address
;
523 if (sec
->orelocation
[idx
]->howto
->type
== R_SPARC_LO10
524 && idx
< sec
->reloc_count
- 1)
526 arelent
*r
= sec
->orelocation
[idx
+ 1];
528 if (r
->howto
->type
== R_SPARC_13
529 && r
->address
== addr
530 && bfd_is_abs_section ((*r
->sym_ptr_ptr
)->section
)
531 && (*r
->sym_ptr_ptr
)->value
== 0)
536 rela_hdr
= &elf_section_data (sec
)->rel_hdr
;
538 rela_hdr
->sh_size
= rela_hdr
->sh_entsize
* count
;
539 rela_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rela_hdr
->sh_size
);
540 if (rela_hdr
->contents
== NULL
)
546 /* Figure out whether the relocations are RELA or REL relocations. */
547 if (rela_hdr
->sh_type
!= SHT_RELA
)
550 /* orelocation has the data, reloc_count has the count... */
551 outbound_relocas
= (Elf64_External_Rela
*) rela_hdr
->contents
;
552 src_rela
= outbound_relocas
;
554 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
556 Elf_Internal_Rela dst_rela
;
561 ptr
= sec
->orelocation
[idx
];
563 /* The address of an ELF reloc is section relative for an object
564 file, and absolute for an executable file or shared library.
565 The address of a BFD reloc is always section relative. */
566 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
567 dst_rela
.r_offset
= ptr
->address
;
569 dst_rela
.r_offset
= ptr
->address
+ sec
->vma
;
571 sym
= *ptr
->sym_ptr_ptr
;
574 else if (bfd_is_abs_section (sym
->section
) && sym
->value
== 0)
579 n
= _bfd_elf_symbol_from_bfd_symbol (abfd
, &sym
);
588 if ((*ptr
->sym_ptr_ptr
)->the_bfd
!= NULL
589 && (*ptr
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
590 && ! _bfd_elf_validate_reloc (abfd
, ptr
))
596 if (ptr
->howto
->type
== R_SPARC_LO10
597 && idx
< sec
->reloc_count
- 1)
599 arelent
*r
= sec
->orelocation
[idx
+ 1];
601 if (r
->howto
->type
== R_SPARC_13
602 && r
->address
== ptr
->address
603 && bfd_is_abs_section ((*r
->sym_ptr_ptr
)->section
)
604 && (*r
->sym_ptr_ptr
)->value
== 0)
608 = ELF64_R_INFO (n
, ELF64_R_TYPE_INFO (r
->addend
,
612 dst_rela
.r_info
= ELF64_R_INFO (n
, R_SPARC_LO10
);
615 dst_rela
.r_info
= ELF64_R_INFO (n
, ptr
->howto
->type
);
617 dst_rela
.r_addend
= ptr
->addend
;
618 bfd_elf64_swap_reloca_out (abfd
, &dst_rela
, src_rela
);
623 /* Sparc64 ELF linker hash table. */
625 struct sparc64_elf_app_reg
628 unsigned short shndx
;
633 struct sparc64_elf_link_hash_table
635 struct elf_link_hash_table root
;
637 struct sparc64_elf_app_reg app_regs
[4];
640 /* Get the Sparc64 ELF linker hash table from a link_info structure. */
642 #define sparc64_elf_hash_table(p) \
643 ((struct sparc64_elf_link_hash_table *) ((p)->hash))
645 /* Create a Sparc64 ELF linker hash table. */
647 static struct bfd_link_hash_table
*
648 sparc64_elf_bfd_link_hash_table_create (abfd
)
651 struct sparc64_elf_link_hash_table
*ret
;
653 ret
= ((struct sparc64_elf_link_hash_table
*)
654 bfd_zalloc (abfd
, sizeof (struct sparc64_elf_link_hash_table
)));
655 if (ret
== (struct sparc64_elf_link_hash_table
*) NULL
)
658 if (! _bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
659 _bfd_elf_link_hash_newfunc
))
661 bfd_release (abfd
, ret
);
665 return &ret
->root
.root
;
668 /* Utility for performing the standard initial work of an instruction
670 *PRELOCATION will contain the relocated item.
671 *PINSN will contain the instruction from the input stream.
672 If the result is `bfd_reloc_other' the caller can continue with
673 performing the relocation. Otherwise it must stop and return the
674 value to its caller. */
676 static bfd_reloc_status_type
677 init_insn_reloc (abfd
,
686 arelent
*reloc_entry
;
689 asection
*input_section
;
691 bfd_vma
*prelocation
;
695 reloc_howto_type
*howto
= reloc_entry
->howto
;
697 if (output_bfd
!= (bfd
*) NULL
698 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
699 && (! howto
->partial_inplace
700 || reloc_entry
->addend
== 0))
702 reloc_entry
->address
+= input_section
->output_offset
;
706 /* This works because partial_inplace == false. */
707 if (output_bfd
!= NULL
)
708 return bfd_reloc_continue
;
710 if (reloc_entry
->address
> input_section
->_cooked_size
)
711 return bfd_reloc_outofrange
;
713 relocation
= (symbol
->value
714 + symbol
->section
->output_section
->vma
715 + symbol
->section
->output_offset
);
716 relocation
+= reloc_entry
->addend
;
717 if (howto
->pc_relative
)
719 relocation
-= (input_section
->output_section
->vma
720 + input_section
->output_offset
);
721 relocation
-= reloc_entry
->address
;
724 *prelocation
= relocation
;
725 *pinsn
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
726 return bfd_reloc_other
;
729 /* For unsupported relocs. */
731 static bfd_reloc_status_type
732 sparc_elf_notsup_reloc (abfd
,
739 bfd
*abfd ATTRIBUTE_UNUSED
;
740 arelent
*reloc_entry ATTRIBUTE_UNUSED
;
741 asymbol
*symbol ATTRIBUTE_UNUSED
;
742 PTR data ATTRIBUTE_UNUSED
;
743 asection
*input_section ATTRIBUTE_UNUSED
;
744 bfd
*output_bfd ATTRIBUTE_UNUSED
;
745 char **error_message ATTRIBUTE_UNUSED
;
747 return bfd_reloc_notsupported
;
750 /* Handle the WDISP16 reloc. */
752 static bfd_reloc_status_type
753 sparc_elf_wdisp16_reloc (abfd
, reloc_entry
, symbol
, data
, input_section
,
754 output_bfd
, error_message
)
756 arelent
*reloc_entry
;
759 asection
*input_section
;
761 char **error_message ATTRIBUTE_UNUSED
;
765 bfd_reloc_status_type status
;
767 status
= init_insn_reloc (abfd
, reloc_entry
, symbol
, data
,
768 input_section
, output_bfd
, &relocation
, &insn
);
769 if (status
!= bfd_reloc_other
)
772 insn
= (insn
& ~0x303fff) | ((((relocation
>> 2) & 0xc000) << 6)
773 | ((relocation
>> 2) & 0x3fff));
774 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ reloc_entry
->address
);
776 if ((bfd_signed_vma
) relocation
< - 0x40000
777 || (bfd_signed_vma
) relocation
> 0x3ffff)
778 return bfd_reloc_overflow
;
783 /* Handle the HIX22 reloc. */
785 static bfd_reloc_status_type
786 sparc_elf_hix22_reloc (abfd
,
794 arelent
*reloc_entry
;
797 asection
*input_section
;
799 char **error_message ATTRIBUTE_UNUSED
;
803 bfd_reloc_status_type status
;
805 status
= init_insn_reloc (abfd
, reloc_entry
, symbol
, data
,
806 input_section
, output_bfd
, &relocation
, &insn
);
807 if (status
!= bfd_reloc_other
)
810 relocation
^= MINUS_ONE
;
811 insn
= (insn
& ~0x3fffff) | ((relocation
>> 10) & 0x3fffff);
812 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ reloc_entry
->address
);
814 if ((relocation
& ~ (bfd_vma
) 0xffffffff) != 0)
815 return bfd_reloc_overflow
;
820 /* Handle the LOX10 reloc. */
822 static bfd_reloc_status_type
823 sparc_elf_lox10_reloc (abfd
,
831 arelent
*reloc_entry
;
834 asection
*input_section
;
836 char **error_message ATTRIBUTE_UNUSED
;
840 bfd_reloc_status_type status
;
842 status
= init_insn_reloc (abfd
, reloc_entry
, symbol
, data
,
843 input_section
, output_bfd
, &relocation
, &insn
);
844 if (status
!= bfd_reloc_other
)
847 insn
= (insn
& ~0x1fff) | 0x1c00 | (relocation
& 0x3ff);
848 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ reloc_entry
->address
);
855 /* Both the headers and the entries are icache aligned. */
856 #define PLT_ENTRY_SIZE 32
857 #define PLT_HEADER_SIZE (4 * PLT_ENTRY_SIZE)
858 #define LARGE_PLT_THRESHOLD 32768
859 #define GOT_RESERVED_ENTRIES 1
861 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/sparcv9/ld.so.1"
863 /* Fill in the .plt section. */
866 sparc64_elf_build_plt (output_bfd
, contents
, nentries
)
868 unsigned char *contents
;
871 const unsigned int nop
= 0x01000000;
874 /* The first four entries are reserved, and are initially undefined.
875 We fill them with `illtrap 0' to force ld.so to do something. */
877 for (i
= 0; i
< PLT_HEADER_SIZE
/4; ++i
)
878 bfd_put_32 (output_bfd
, 0, contents
+i
*4);
880 /* The first 32768 entries are close enough to plt1 to get there via
881 a straight branch. */
883 for (i
= 4; i
< LARGE_PLT_THRESHOLD
&& i
< nentries
; ++i
)
885 unsigned char *entry
= contents
+ i
* PLT_ENTRY_SIZE
;
886 unsigned int sethi
, ba
;
888 /* sethi (. - plt0), %g1 */
889 sethi
= 0x03000000 | (i
* PLT_ENTRY_SIZE
);
891 /* ba,a,pt %xcc, plt1 */
892 ba
= 0x30680000 | (((contents
+PLT_ENTRY_SIZE
) - (entry
+4)) / 4 & 0x7ffff);
894 bfd_put_32 (output_bfd
, sethi
, entry
);
895 bfd_put_32 (output_bfd
, ba
, entry
+4);
896 bfd_put_32 (output_bfd
, nop
, entry
+8);
897 bfd_put_32 (output_bfd
, nop
, entry
+12);
898 bfd_put_32 (output_bfd
, nop
, entry
+16);
899 bfd_put_32 (output_bfd
, nop
, entry
+20);
900 bfd_put_32 (output_bfd
, nop
, entry
+24);
901 bfd_put_32 (output_bfd
, nop
, entry
+28);
904 /* Now the tricky bit. Entries 32768 and higher are grouped in blocks of
905 160: 160 entries and 160 pointers. This is to separate code from data,
906 which is much friendlier on the cache. */
908 for (; i
< nentries
; i
+= 160)
910 int block
= (i
+ 160 <= nentries
? 160 : nentries
- i
);
911 for (j
= 0; j
< block
; ++j
)
913 unsigned char *entry
, *ptr
;
916 entry
= contents
+ i
*PLT_ENTRY_SIZE
+ j
*4*6;
917 ptr
= contents
+ i
*PLT_ENTRY_SIZE
+ block
*4*6 + j
*8;
919 /* ldx [%o7 + ptr - entry+4], %g1 */
920 ldx
= 0xc25be000 | ((ptr
- entry
+4) & 0x1fff);
922 bfd_put_32 (output_bfd
, 0x8a10000f, entry
); /* mov %o7,%g5 */
923 bfd_put_32 (output_bfd
, 0x40000002, entry
+4); /* call .+8 */
924 bfd_put_32 (output_bfd
, nop
, entry
+8); /* nop */
925 bfd_put_32 (output_bfd
, ldx
, entry
+12); /* ldx [%o7+P],%g1 */
926 bfd_put_32 (output_bfd
, 0x83c3c001, entry
+16); /* jmpl %o7+%g1,%g1 */
927 bfd_put_32 (output_bfd
, 0x9e100005, entry
+20); /* mov %g5,%o7 */
929 bfd_put_64 (output_bfd
, contents
- (entry
+4), ptr
);
934 /* Return the offset of a particular plt entry within the .plt section. */
937 sparc64_elf_plt_entry_offset (index
)
942 if (index
< LARGE_PLT_THRESHOLD
)
943 return index
* PLT_ENTRY_SIZE
;
945 /* See above for details. */
947 block
= (index
- LARGE_PLT_THRESHOLD
) / 160;
948 ofs
= (index
- LARGE_PLT_THRESHOLD
) % 160;
950 return ((bfd_vma
) (LARGE_PLT_THRESHOLD
+ block
*160) * PLT_ENTRY_SIZE
955 sparc64_elf_plt_ptr_offset (index
, max
)
958 int block
, ofs
, last
;
960 BFD_ASSERT(index
>= LARGE_PLT_THRESHOLD
);
962 /* See above for details. */
964 block
= (((index
- LARGE_PLT_THRESHOLD
) / 160) * 160)
965 + LARGE_PLT_THRESHOLD
;
967 if (block
+ 160 > max
)
968 last
= (max
- LARGE_PLT_THRESHOLD
) % 160;
972 return (block
* PLT_ENTRY_SIZE
977 /* Look through the relocs for a section during the first phase, and
978 allocate space in the global offset table or procedure linkage
982 sparc64_elf_check_relocs (abfd
, info
, sec
, relocs
)
984 struct bfd_link_info
*info
;
986 const Elf_Internal_Rela
*relocs
;
989 Elf_Internal_Shdr
*symtab_hdr
;
990 struct elf_link_hash_entry
**sym_hashes
;
991 bfd_vma
*local_got_offsets
;
992 const Elf_Internal_Rela
*rel
;
993 const Elf_Internal_Rela
*rel_end
;
998 if (info
->relocateable
|| !(sec
->flags
& SEC_ALLOC
))
1001 dynobj
= elf_hash_table (info
)->dynobj
;
1002 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1003 sym_hashes
= elf_sym_hashes (abfd
);
1004 local_got_offsets
= elf_local_got_offsets (abfd
);
1010 rel_end
= relocs
+ NUM_SHDR_ENTRIES (& elf_section_data (sec
)->rel_hdr
);
1011 for (rel
= relocs
; rel
< rel_end
; rel
++)
1013 unsigned long r_symndx
;
1014 struct elf_link_hash_entry
*h
;
1016 r_symndx
= ELF64_R_SYM (rel
->r_info
);
1017 if (r_symndx
< symtab_hdr
->sh_info
)
1020 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1022 switch (ELF64_R_TYPE_ID (rel
->r_info
))
1027 /* This symbol requires a global offset table entry. */
1031 /* Create the .got section. */
1032 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
1033 if (! _bfd_elf_create_got_section (dynobj
, info
))
1039 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1040 BFD_ASSERT (sgot
!= NULL
);
1043 if (srelgot
== NULL
&& (h
!= NULL
|| info
->shared
))
1045 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
1046 if (srelgot
== NULL
)
1048 srelgot
= bfd_make_section (dynobj
, ".rela.got");
1050 || ! bfd_set_section_flags (dynobj
, srelgot
,
1055 | SEC_LINKER_CREATED
1057 || ! bfd_set_section_alignment (dynobj
, srelgot
, 3))
1064 if (h
->got
.offset
!= (bfd_vma
) -1)
1066 /* We have already allocated space in the .got. */
1069 h
->got
.offset
= sgot
->_raw_size
;
1071 /* Make sure this symbol is output as a dynamic symbol. */
1072 if (h
->dynindx
== -1)
1074 if (! bfd_elf64_link_record_dynamic_symbol (info
, h
))
1078 srelgot
->_raw_size
+= sizeof (Elf64_External_Rela
);
1082 /* This is a global offset table entry for a local
1084 if (local_got_offsets
== NULL
)
1087 register unsigned int i
;
1089 size
= symtab_hdr
->sh_info
* sizeof (bfd_vma
);
1090 local_got_offsets
= (bfd_vma
*) bfd_alloc (abfd
, size
);
1091 if (local_got_offsets
== NULL
)
1093 elf_local_got_offsets (abfd
) = local_got_offsets
;
1094 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
1095 local_got_offsets
[i
] = (bfd_vma
) -1;
1097 if (local_got_offsets
[r_symndx
] != (bfd_vma
) -1)
1099 /* We have already allocated space in the .got. */
1102 local_got_offsets
[r_symndx
] = sgot
->_raw_size
;
1106 /* If we are generating a shared object, we need to
1107 output a R_SPARC_RELATIVE reloc so that the
1108 dynamic linker can adjust this GOT entry. */
1109 srelgot
->_raw_size
+= sizeof (Elf64_External_Rela
);
1113 sgot
->_raw_size
+= 8;
1116 /* Doesn't work for 64-bit -fPIC, since sethi/or builds
1117 unsigned numbers. If we permit ourselves to modify
1118 code so we get sethi/xor, this could work.
1119 Question: do we consider conditionally re-enabling
1120 this for -fpic, once we know about object code models? */
1121 /* If the .got section is more than 0x1000 bytes, we add
1122 0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13
1123 bit relocations have a greater chance of working. */
1124 if (sgot
->_raw_size
>= 0x1000
1125 && elf_hash_table (info
)->hgot
->root
.u
.def
.value
== 0)
1126 elf_hash_table (info
)->hgot
->root
.u
.def
.value
= 0x1000;
1131 case R_SPARC_WPLT30
:
1133 case R_SPARC_HIPLT22
:
1134 case R_SPARC_LOPLT10
:
1135 case R_SPARC_PCPLT32
:
1136 case R_SPARC_PCPLT22
:
1137 case R_SPARC_PCPLT10
:
1139 /* This symbol requires a procedure linkage table entry. We
1140 actually build the entry in adjust_dynamic_symbol,
1141 because this might be a case of linking PIC code without
1142 linking in any dynamic objects, in which case we don't
1143 need to generate a procedure linkage table after all. */
1147 /* It does not make sense to have a procedure linkage
1148 table entry for a local symbol. */
1149 bfd_set_error (bfd_error_bad_value
);
1153 /* Make sure this symbol is output as a dynamic symbol. */
1154 if (h
->dynindx
== -1)
1156 if (! bfd_elf64_link_record_dynamic_symbol (info
, h
))
1160 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
1165 case R_SPARC_PC_HH22
:
1166 case R_SPARC_PC_HM10
:
1167 case R_SPARC_PC_LM22
:
1169 && strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
1173 case R_SPARC_DISP16
:
1174 case R_SPARC_DISP32
:
1175 case R_SPARC_DISP64
:
1176 case R_SPARC_WDISP30
:
1177 case R_SPARC_WDISP22
:
1178 case R_SPARC_WDISP19
:
1179 case R_SPARC_WDISP16
:
1208 /* When creating a shared object, we must copy these relocs
1209 into the output file. We create a reloc section in
1210 dynobj and make room for the reloc.
1212 But don't do this for debugging sections -- this shows up
1213 with DWARF2 -- first because they are not loaded, and
1214 second because DWARF sez the debug info is not to be
1215 biased by the load address. */
1216 if (info
->shared
&& (sec
->flags
& SEC_ALLOC
))
1222 name
= (bfd_elf_string_from_elf_section
1224 elf_elfheader (abfd
)->e_shstrndx
,
1225 elf_section_data (sec
)->rel_hdr
.sh_name
));
1229 BFD_ASSERT (strncmp (name
, ".rela", 5) == 0
1230 && strcmp (bfd_get_section_name (abfd
, sec
),
1233 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1238 sreloc
= bfd_make_section (dynobj
, name
);
1239 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
1240 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
1241 if ((sec
->flags
& SEC_ALLOC
) != 0)
1242 flags
|= SEC_ALLOC
| SEC_LOAD
;
1244 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
1245 || ! bfd_set_section_alignment (dynobj
, sreloc
, 3))
1250 sreloc
->_raw_size
+= sizeof (Elf64_External_Rela
);
1254 case R_SPARC_REGISTER
:
1255 /* Nothing to do. */
1259 (*_bfd_error_handler
) (_("%s: check_relocs: unhandled reloc type %d"),
1260 bfd_get_filename(abfd
),
1261 ELF64_R_TYPE_ID (rel
->r_info
));
1269 /* Hook called by the linker routine which adds symbols from an object
1270 file. We use it for STT_REGISTER symbols. */
1273 sparc64_elf_add_symbol_hook (abfd
, info
, sym
, namep
, flagsp
, secp
, valp
)
1275 struct bfd_link_info
*info
;
1276 const Elf_Internal_Sym
*sym
;
1278 flagword
*flagsp ATTRIBUTE_UNUSED
;
1279 asection
**secp ATTRIBUTE_UNUSED
;
1280 bfd_vma
*valp ATTRIBUTE_UNUSED
;
1282 static char *stt_types
[] = { "NOTYPE", "OBJECT", "FUNCTION" };
1284 if (ELF_ST_TYPE (sym
->st_info
) == STT_REGISTER
)
1287 struct sparc64_elf_app_reg
*p
;
1289 reg
= (int)sym
->st_value
;
1292 case 2: reg
-= 2; break;
1293 case 6: reg
-= 4; break;
1295 (*_bfd_error_handler
)
1296 (_("%s: Only registers %%g[2367] can be declared using STT_REGISTER"),
1297 bfd_get_filename (abfd
));
1301 if (info
->hash
->creator
!= abfd
->xvec
1302 || (abfd
->flags
& DYNAMIC
) != 0)
1304 /* STT_REGISTER only works when linking an elf64_sparc object.
1305 If STT_REGISTER comes from a dynamic object, don't put it into
1306 the output bfd. The dynamic linker will recheck it. */
1311 p
= sparc64_elf_hash_table(info
)->app_regs
+ reg
;
1313 if (p
->name
!= NULL
&& strcmp (p
->name
, *namep
))
1315 (*_bfd_error_handler
)
1316 (_("Register %%g%d used incompatibly: "
1317 "previously declared in %s to %s, in %s redefined to %s"),
1319 bfd_get_filename (p
->abfd
), *p
->name
? p
->name
: "#scratch",
1320 bfd_get_filename (abfd
), **namep
? *namep
: "#scratch");
1324 if (p
->name
== NULL
)
1328 struct elf_link_hash_entry
*h
;
1330 h
= (struct elf_link_hash_entry
*)
1331 bfd_link_hash_lookup (info
->hash
, *namep
, false, false, false);
1335 unsigned char type
= h
->type
;
1337 if (type
> STT_FUNC
) type
= 0;
1338 (*_bfd_error_handler
)
1339 (_("Symbol `%s' has differing types: "
1340 "previously %s, REGISTER in %s"),
1341 *namep
, stt_types
[type
], bfd_get_filename (abfd
));
1345 p
->name
= bfd_hash_allocate (&info
->hash
->table
,
1346 strlen (*namep
) + 1);
1350 strcpy (p
->name
, *namep
);
1354 p
->bind
= ELF_ST_BIND (sym
->st_info
);
1356 p
->shndx
= sym
->st_shndx
;
1360 if (p
->bind
== STB_WEAK
1361 && ELF_ST_BIND (sym
->st_info
) == STB_GLOBAL
)
1363 p
->bind
= STB_GLOBAL
;
1370 else if (! *namep
|| ! **namep
)
1375 struct sparc64_elf_app_reg
*p
;
1377 p
= sparc64_elf_hash_table(info
)->app_regs
;
1378 for (i
= 0; i
< 4; i
++, p
++)
1379 if (p
->name
!= NULL
&& ! strcmp (p
->name
, *namep
))
1381 unsigned char type
= ELF_ST_TYPE (sym
->st_info
);
1383 if (type
> STT_FUNC
) type
= 0;
1384 (*_bfd_error_handler
)
1385 (_("Symbol `%s' has differing types: "
1386 "REGISTER in %s, %s in %s"),
1387 *namep
, bfd_get_filename (p
->abfd
), stt_types
[type
],
1388 bfd_get_filename (abfd
));
1395 /* This function takes care of emiting STT_REGISTER symbols
1396 which we cannot easily keep in the symbol hash table. */
1399 sparc64_elf_output_arch_syms (output_bfd
, info
, finfo
, func
)
1400 bfd
*output_bfd ATTRIBUTE_UNUSED
;
1401 struct bfd_link_info
*info
;
1403 boolean (*func
) PARAMS ((PTR
, const char *,
1404 Elf_Internal_Sym
*, asection
*));
1407 struct sparc64_elf_app_reg
*app_regs
=
1408 sparc64_elf_hash_table(info
)->app_regs
;
1409 Elf_Internal_Sym sym
;
1411 /* We arranged in size_dynamic_sections to put the STT_REGISTER entries
1412 at the end of the dynlocal list, so they came at the end of the local
1413 symbols in the symtab. Except that they aren't STB_LOCAL, so we need
1414 to back up symtab->sh_info. */
1415 if (elf_hash_table (info
)->dynlocal
)
1417 bfd
* dynobj
= elf_hash_table (info
)->dynobj
;
1418 asection
*dynsymsec
= bfd_get_section_by_name (dynobj
, ".dynsym");
1419 struct elf_link_local_dynamic_entry
*e
;
1421 for (e
= elf_hash_table (info
)->dynlocal
; e
; e
= e
->next
)
1422 if (e
->input_indx
== -1)
1426 elf_section_data (dynsymsec
->output_section
)->this_hdr
.sh_info
1431 if (info
->strip
== strip_all
)
1434 for (reg
= 0; reg
< 4; reg
++)
1435 if (app_regs
[reg
].name
!= NULL
)
1437 if (info
->strip
== strip_some
1438 && bfd_hash_lookup (info
->keep_hash
,
1439 app_regs
[reg
].name
,
1440 false, false) == NULL
)
1443 sym
.st_value
= reg
< 2 ? reg
+ 2 : reg
+ 4;
1446 sym
.st_info
= ELF_ST_INFO (app_regs
[reg
].bind
, STT_REGISTER
);
1447 sym
.st_shndx
= app_regs
[reg
].shndx
;
1448 if (! (*func
) (finfo
, app_regs
[reg
].name
, &sym
,
1449 sym
.st_shndx
== SHN_ABS
1450 ? bfd_abs_section_ptr
: bfd_und_section_ptr
))
1458 sparc64_elf_get_symbol_type (elf_sym
, type
)
1459 Elf_Internal_Sym
* elf_sym
;
1462 if (ELF_ST_TYPE (elf_sym
->st_info
) == STT_REGISTER
)
1463 return STT_REGISTER
;
1468 /* A STB_GLOBAL,STT_REGISTER symbol should be BSF_GLOBAL
1469 even in SHN_UNDEF section. */
1472 sparc64_elf_symbol_processing (abfd
, asym
)
1473 bfd
*abfd ATTRIBUTE_UNUSED
;
1476 elf_symbol_type
*elfsym
;
1478 elfsym
= (elf_symbol_type
*) asym
;
1479 if (elfsym
->internal_elf_sym
.st_info
1480 == ELF_ST_INFO (STB_GLOBAL
, STT_REGISTER
))
1482 asym
->flags
|= BSF_GLOBAL
;
1486 /* Adjust a symbol defined by a dynamic object and referenced by a
1487 regular object. The current definition is in some section of the
1488 dynamic object, but we're not including those sections. We have to
1489 change the definition to something the rest of the link can
1493 sparc64_elf_adjust_dynamic_symbol (info
, h
)
1494 struct bfd_link_info
*info
;
1495 struct elf_link_hash_entry
*h
;
1499 unsigned int power_of_two
;
1501 dynobj
= elf_hash_table (info
)->dynobj
;
1503 /* Make sure we know what is going on here. */
1504 BFD_ASSERT (dynobj
!= NULL
1505 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
1506 || h
->weakdef
!= NULL
1507 || ((h
->elf_link_hash_flags
1508 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1509 && (h
->elf_link_hash_flags
1510 & ELF_LINK_HASH_REF_REGULAR
) != 0
1511 && (h
->elf_link_hash_flags
1512 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
1514 /* If this is a function, put it in the procedure linkage table. We
1515 will fill in the contents of the procedure linkage table later
1516 (although we could actually do it here). The STT_NOTYPE
1517 condition is a hack specifically for the Oracle libraries
1518 delivered for Solaris; for some inexplicable reason, they define
1519 some of their functions as STT_NOTYPE when they really should be
1521 if (h
->type
== STT_FUNC
1522 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0
1523 || (h
->type
== STT_NOTYPE
1524 && (h
->root
.type
== bfd_link_hash_defined
1525 || h
->root
.type
== bfd_link_hash_defweak
)
1526 && (h
->root
.u
.def
.section
->flags
& SEC_CODE
) != 0))
1528 if (! elf_hash_table (info
)->dynamic_sections_created
)
1530 /* This case can occur if we saw a WPLT30 reloc in an input
1531 file, but none of the input files were dynamic objects.
1532 In such a case, we don't actually need to build a
1533 procedure linkage table, and we can just do a WDISP30
1535 BFD_ASSERT ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0);
1539 s
= bfd_get_section_by_name (dynobj
, ".plt");
1540 BFD_ASSERT (s
!= NULL
);
1542 /* The first four bit in .plt is reserved. */
1543 if (s
->_raw_size
== 0)
1544 s
->_raw_size
= PLT_HEADER_SIZE
;
1546 /* If this symbol is not defined in a regular file, and we are
1547 not generating a shared library, then set the symbol to this
1548 location in the .plt. This is required to make function
1549 pointers compare as equal between the normal executable and
1550 the shared library. */
1552 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1554 h
->root
.u
.def
.section
= s
;
1555 h
->root
.u
.def
.value
= s
->_raw_size
;
1558 /* To simplify matters later, just store the plt index here. */
1559 h
->plt
.offset
= s
->_raw_size
/ PLT_ENTRY_SIZE
;
1561 /* Make room for this entry. */
1562 s
->_raw_size
+= PLT_ENTRY_SIZE
;
1564 /* We also need to make an entry in the .rela.plt section. */
1566 s
= bfd_get_section_by_name (dynobj
, ".rela.plt");
1567 BFD_ASSERT (s
!= NULL
);
1569 s
->_raw_size
+= sizeof (Elf64_External_Rela
);
1571 /* The procedure linkage table size is bounded by the magnitude
1572 of the offset we can describe in the entry. */
1573 if (s
->_raw_size
>= (bfd_vma
)1 << 32)
1575 bfd_set_error (bfd_error_bad_value
);
1582 /* If this is a weak symbol, and there is a real definition, the
1583 processor independent code will have arranged for us to see the
1584 real definition first, and we can just use the same value. */
1585 if (h
->weakdef
!= NULL
)
1587 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
1588 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
1589 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
1590 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
1594 /* This is a reference to a symbol defined by a dynamic object which
1595 is not a function. */
1597 /* If we are creating a shared library, we must presume that the
1598 only references to the symbol are via the global offset table.
1599 For such cases we need not do anything here; the relocations will
1600 be handled correctly by relocate_section. */
1604 /* We must allocate the symbol in our .dynbss section, which will
1605 become part of the .bss section of the executable. There will be
1606 an entry for this symbol in the .dynsym section. The dynamic
1607 object will contain position independent code, so all references
1608 from the dynamic object to this symbol will go through the global
1609 offset table. The dynamic linker will use the .dynsym entry to
1610 determine the address it must put in the global offset table, so
1611 both the dynamic object and the regular object will refer to the
1612 same memory location for the variable. */
1614 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
1615 BFD_ASSERT (s
!= NULL
);
1617 /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker
1618 to copy the initial value out of the dynamic object and into the
1619 runtime process image. We need to remember the offset into the
1620 .rel.bss section we are going to use. */
1621 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
1625 srel
= bfd_get_section_by_name (dynobj
, ".rela.bss");
1626 BFD_ASSERT (srel
!= NULL
);
1627 srel
->_raw_size
+= sizeof (Elf64_External_Rela
);
1628 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
1631 /* We need to figure out the alignment required for this symbol. I
1632 have no idea how ELF linkers handle this. 16-bytes is the size
1633 of the largest type that requires hard alignment -- long double. */
1634 power_of_two
= bfd_log2 (h
->size
);
1635 if (power_of_two
> 4)
1638 /* Apply the required alignment. */
1639 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
,
1640 (bfd_size_type
) (1 << power_of_two
));
1641 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
1643 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
1647 /* Define the symbol as being at this point in the section. */
1648 h
->root
.u
.def
.section
= s
;
1649 h
->root
.u
.def
.value
= s
->_raw_size
;
1651 /* Increment the section size to make room for the symbol. */
1652 s
->_raw_size
+= h
->size
;
1657 /* Set the sizes of the dynamic sections. */
1660 sparc64_elf_size_dynamic_sections (output_bfd
, info
)
1662 struct bfd_link_info
*info
;
1669 dynobj
= elf_hash_table (info
)->dynobj
;
1670 BFD_ASSERT (dynobj
!= NULL
);
1672 if (elf_hash_table (info
)->dynamic_sections_created
)
1674 /* Set the contents of the .interp section to the interpreter. */
1677 s
= bfd_get_section_by_name (dynobj
, ".interp");
1678 BFD_ASSERT (s
!= NULL
);
1679 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1680 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1685 /* We may have created entries in the .rela.got section.
1686 However, if we are not creating the dynamic sections, we will
1687 not actually use these entries. Reset the size of .rela.got,
1688 which will cause it to get stripped from the output file
1690 s
= bfd_get_section_by_name (dynobj
, ".rela.got");
1695 /* The check_relocs and adjust_dynamic_symbol entry points have
1696 determined the sizes of the various dynamic sections. Allocate
1700 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1705 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1708 /* It's OK to base decisions on the section name, because none
1709 of the dynobj section names depend upon the input files. */
1710 name
= bfd_get_section_name (dynobj
, s
);
1714 if (strncmp (name
, ".rela", 5) == 0)
1716 if (s
->_raw_size
== 0)
1718 /* If we don't need this section, strip it from the
1719 output file. This is to handle .rela.bss and
1720 .rel.plt. We must create it in
1721 create_dynamic_sections, because it must be created
1722 before the linker maps input sections to output
1723 sections. The linker does that before
1724 adjust_dynamic_symbol is called, and it is that
1725 function which decides whether anything needs to go
1726 into these sections. */
1731 const char *outname
;
1734 /* If this relocation section applies to a read only
1735 section, then we probably need a DT_TEXTREL entry. */
1736 outname
= bfd_get_section_name (output_bfd
,
1738 target
= bfd_get_section_by_name (output_bfd
, outname
+ 5);
1740 && (target
->flags
& SEC_READONLY
) != 0)
1743 if (strcmp (name
, ".rela.plt") == 0)
1746 /* We use the reloc_count field as a counter if we need
1747 to copy relocs into the output file. */
1751 else if (strcmp (name
, ".plt") != 0
1752 && strncmp (name
, ".got", 4) != 0)
1754 /* It's not one of our sections, so don't allocate space. */
1760 _bfd_strip_section_from_output (info
, s
);
1764 /* Allocate memory for the section contents. Zero the memory
1765 for the benefit of .rela.plt, which has 4 unused entries
1766 at the beginning, and we don't want garbage. */
1767 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
1768 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
1772 if (elf_hash_table (info
)->dynamic_sections_created
)
1774 /* Add some entries to the .dynamic section. We fill in the
1775 values later, in sparc64_elf_finish_dynamic_sections, but we
1776 must add the entries now so that we get the correct size for
1777 the .dynamic section. The DT_DEBUG entry is filled in by the
1778 dynamic linker and used by the debugger. */
1780 struct sparc64_elf_app_reg
* app_regs
;
1781 struct bfd_strtab_hash
*dynstr
;
1782 struct elf_link_hash_table
*eht
= elf_hash_table (info
);
1786 if (! bfd_elf64_add_dynamic_entry (info
, DT_DEBUG
, 0))
1792 if (! bfd_elf64_add_dynamic_entry (info
, DT_PLTGOT
, 0)
1793 || ! bfd_elf64_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
1794 || ! bfd_elf64_add_dynamic_entry (info
, DT_PLTREL
, DT_RELA
)
1795 || ! bfd_elf64_add_dynamic_entry (info
, DT_JMPREL
, 0))
1799 if (! bfd_elf64_add_dynamic_entry (info
, DT_RELA
, 0)
1800 || ! bfd_elf64_add_dynamic_entry (info
, DT_RELASZ
, 0)
1801 || ! bfd_elf64_add_dynamic_entry (info
, DT_RELAENT
,
1802 sizeof (Elf64_External_Rela
)))
1807 if (! bfd_elf64_add_dynamic_entry (info
, DT_TEXTREL
, 0))
1809 info
->flags
|= DF_TEXTREL
;
1812 /* Add dynamic STT_REGISTER symbols and corresponding DT_SPARC_REGISTER
1813 entries if needed. */
1814 app_regs
= sparc64_elf_hash_table (info
)->app_regs
;
1815 dynstr
= eht
->dynstr
;
1817 for (reg
= 0; reg
< 4; reg
++)
1818 if (app_regs
[reg
].name
!= NULL
)
1820 struct elf_link_local_dynamic_entry
*entry
, *e
;
1822 if (! bfd_elf64_add_dynamic_entry (info
, DT_SPARC_REGISTER
, 0))
1825 entry
= (struct elf_link_local_dynamic_entry
*)
1826 bfd_hash_allocate (&info
->hash
->table
, sizeof (*entry
));
1830 /* We cheat here a little bit: the symbol will not be local, so we
1831 put it at the end of the dynlocal linked list. We will fix it
1832 later on, as we have to fix other fields anyway. */
1833 entry
->isym
.st_value
= reg
< 2 ? reg
+ 2 : reg
+ 4;
1834 entry
->isym
.st_size
= 0;
1835 if (*app_regs
[reg
].name
!= '\0')
1837 = _bfd_stringtab_add (dynstr
, app_regs
[reg
].name
, true, false);
1839 entry
->isym
.st_name
= 0;
1840 entry
->isym
.st_other
= 0;
1841 entry
->isym
.st_info
= ELF_ST_INFO (app_regs
[reg
].bind
,
1843 entry
->isym
.st_shndx
= app_regs
[reg
].shndx
;
1845 entry
->input_bfd
= output_bfd
;
1846 entry
->input_indx
= -1;
1848 if (eht
->dynlocal
== NULL
)
1849 eht
->dynlocal
= entry
;
1852 for (e
= eht
->dynlocal
; e
->next
; e
= e
->next
)
1863 #define SET_SEC_DO_RELAX(section) do { elf_section_data(section)->tdata = (void *)1; } while (0)
1864 #define SEC_DO_RELAX(section) (elf_section_data(section)->tdata == (void *)1)
1867 sparc64_elf_relax_section (abfd
, section
, link_info
, again
)
1868 bfd
*abfd ATTRIBUTE_UNUSED
;
1869 asection
*section ATTRIBUTE_UNUSED
;
1870 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
;
1874 SET_SEC_DO_RELAX (section
);
1878 /* Relocate a SPARC64 ELF section. */
1881 sparc64_elf_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
1882 contents
, relocs
, local_syms
, local_sections
)
1884 struct bfd_link_info
*info
;
1886 asection
*input_section
;
1888 Elf_Internal_Rela
*relocs
;
1889 Elf_Internal_Sym
*local_syms
;
1890 asection
**local_sections
;
1893 Elf_Internal_Shdr
*symtab_hdr
;
1894 struct elf_link_hash_entry
**sym_hashes
;
1895 bfd_vma
*local_got_offsets
;
1900 Elf_Internal_Rela
*rel
;
1901 Elf_Internal_Rela
*relend
;
1903 dynobj
= elf_hash_table (info
)->dynobj
;
1904 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1905 sym_hashes
= elf_sym_hashes (input_bfd
);
1906 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1908 if (elf_hash_table(info
)->hgot
== NULL
)
1911 got_base
= elf_hash_table (info
)->hgot
->root
.u
.def
.value
;
1913 sgot
= splt
= sreloc
= NULL
;
1916 relend
= relocs
+ NUM_SHDR_ENTRIES (& elf_section_data (input_section
)->rel_hdr
);
1917 for (; rel
< relend
; rel
++)
1920 reloc_howto_type
*howto
;
1921 unsigned long r_symndx
;
1922 struct elf_link_hash_entry
*h
;
1923 Elf_Internal_Sym
*sym
;
1926 bfd_reloc_status_type r
;
1928 r_type
= ELF64_R_TYPE_ID (rel
->r_info
);
1929 if (r_type
< 0 || r_type
>= (int) R_SPARC_max_std
)
1931 bfd_set_error (bfd_error_bad_value
);
1934 howto
= sparc64_elf_howto_table
+ r_type
;
1936 r_symndx
= ELF64_R_SYM (rel
->r_info
);
1938 if (info
->relocateable
)
1940 /* This is a relocateable link. We don't have to change
1941 anything, unless the reloc is against a section symbol,
1942 in which case we have to adjust according to where the
1943 section symbol winds up in the output section. */
1944 if (r_symndx
< symtab_hdr
->sh_info
)
1946 sym
= local_syms
+ r_symndx
;
1947 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1949 sec
= local_sections
[r_symndx
];
1950 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
1957 /* This is a final link. */
1961 if (r_symndx
< symtab_hdr
->sh_info
)
1963 sym
= local_syms
+ r_symndx
;
1964 sec
= local_sections
[r_symndx
];
1965 relocation
= (sec
->output_section
->vma
1966 + sec
->output_offset
1971 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1972 while (h
->root
.type
== bfd_link_hash_indirect
1973 || h
->root
.type
== bfd_link_hash_warning
)
1974 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1975 if (h
->root
.type
== bfd_link_hash_defined
1976 || h
->root
.type
== bfd_link_hash_defweak
)
1978 boolean skip_it
= false;
1979 sec
= h
->root
.u
.def
.section
;
1983 case R_SPARC_WPLT30
:
1985 case R_SPARC_HIPLT22
:
1986 case R_SPARC_LOPLT10
:
1987 case R_SPARC_PCPLT32
:
1988 case R_SPARC_PCPLT22
:
1989 case R_SPARC_PCPLT10
:
1991 if (h
->plt
.offset
!= (bfd_vma
) -1)
1998 if (elf_hash_table(info
)->dynamic_sections_created
2000 || (!info
->symbolic
&& h
->dynindx
!= -1)
2001 || !(h
->elf_link_hash_flags
2002 & ELF_LINK_HASH_DEF_REGULAR
)))
2008 case R_SPARC_PC_HH22
:
2009 case R_SPARC_PC_HM10
:
2010 case R_SPARC_PC_LM22
:
2011 if (!strcmp(h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_"))
2019 case R_SPARC_DISP16
:
2020 case R_SPARC_DISP32
:
2021 case R_SPARC_WDISP30
:
2022 case R_SPARC_WDISP22
:
2035 case R_SPARC_WDISP19
:
2036 case R_SPARC_WDISP16
:
2040 case R_SPARC_DISP64
:
2049 && ((!info
->symbolic
&& h
->dynindx
!= -1)
2050 || !(h
->elf_link_hash_flags
2051 & ELF_LINK_HASH_DEF_REGULAR
)))
2058 /* In these cases, we don't need the relocation
2059 value. We check specially because in some
2060 obscure cases sec->output_section will be NULL. */
2065 relocation
= (h
->root
.u
.def
.value
2066 + sec
->output_section
->vma
2067 + sec
->output_offset
);
2070 else if (h
->root
.type
== bfd_link_hash_undefweak
)
2072 else if (info
->shared
&& !info
->symbolic
2073 && !info
->no_undefined
2074 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
2078 if (! ((*info
->callbacks
->undefined_symbol
)
2079 (info
, h
->root
.root
.string
, input_bfd
,
2080 input_section
, rel
->r_offset
,
2081 (!info
->shared
|| info
->no_undefined
2082 || ELF_ST_VISIBILITY (h
->other
)))))
2085 /* To avoid generating warning messages about truncated
2086 relocations, set the relocation's address to be the same as
2087 the start of this section. */
2089 if (input_section
->output_section
!= NULL
)
2090 relocation
= input_section
->output_section
->vma
;
2096 /* When generating a shared object, these relocations are copied
2097 into the output file to be resolved at run time. */
2098 if (info
->shared
&& (input_section
->flags
& SEC_ALLOC
))
2104 case R_SPARC_PC_HH22
:
2105 case R_SPARC_PC_HM10
:
2106 case R_SPARC_PC_LM22
:
2108 && !strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_"))
2112 case R_SPARC_DISP16
:
2113 case R_SPARC_DISP32
:
2114 case R_SPARC_WDISP30
:
2115 case R_SPARC_WDISP22
:
2116 case R_SPARC_WDISP19
:
2117 case R_SPARC_WDISP16
:
2118 case R_SPARC_DISP64
:
2148 Elf_Internal_Rela outrel
;
2154 (bfd_elf_string_from_elf_section
2156 elf_elfheader (input_bfd
)->e_shstrndx
,
2157 elf_section_data (input_section
)->rel_hdr
.sh_name
));
2162 BFD_ASSERT (strncmp (name
, ".rela", 5) == 0
2163 && strcmp (bfd_get_section_name(input_bfd
,
2167 sreloc
= bfd_get_section_by_name (dynobj
, name
);
2168 BFD_ASSERT (sreloc
!= NULL
);
2173 if (elf_section_data (input_section
)->stab_info
== NULL
)
2174 outrel
.r_offset
= rel
->r_offset
;
2179 off
= (_bfd_stab_section_offset
2180 (output_bfd
, &elf_hash_table (info
)->stab_info
,
2182 &elf_section_data (input_section
)->stab_info
,
2184 if (off
== MINUS_ONE
)
2186 outrel
.r_offset
= off
;
2189 outrel
.r_offset
+= (input_section
->output_section
->vma
2190 + input_section
->output_offset
);
2192 /* Optimize unaligned reloc usage now that we know where
2193 it finally resides. */
2197 if (outrel
.r_offset
& 1) r_type
= R_SPARC_UA16
;
2200 if (!(outrel
.r_offset
& 1)) r_type
= R_SPARC_16
;
2203 if (outrel
.r_offset
& 3) r_type
= R_SPARC_UA32
;
2206 if (!(outrel
.r_offset
& 3)) r_type
= R_SPARC_32
;
2209 if (outrel
.r_offset
& 7) r_type
= R_SPARC_UA64
;
2212 if (!(outrel
.r_offset
& 7)) r_type
= R_SPARC_64
;
2217 memset (&outrel
, 0, sizeof outrel
);
2218 /* h->dynindx may be -1 if the symbol was marked to
2221 && ((! info
->symbolic
&& h
->dynindx
!= -1)
2222 || (h
->elf_link_hash_flags
2223 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
2225 BFD_ASSERT (h
->dynindx
!= -1);
2227 = ELF64_R_INFO (h
->dynindx
,
2229 ELF64_R_TYPE_DATA (rel
->r_info
),
2231 outrel
.r_addend
= rel
->r_addend
;
2235 if (r_type
== R_SPARC_64
)
2237 outrel
.r_info
= ELF64_R_INFO (0, R_SPARC_RELATIVE
);
2238 outrel
.r_addend
= relocation
+ rel
->r_addend
;
2245 sec
= local_sections
[r_symndx
];
2248 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
2250 == bfd_link_hash_defweak
));
2251 sec
= h
->root
.u
.def
.section
;
2253 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
2255 else if (sec
== NULL
|| sec
->owner
== NULL
)
2257 bfd_set_error (bfd_error_bad_value
);
2264 osec
= sec
->output_section
;
2265 indx
= elf_section_data (osec
)->dynindx
;
2267 /* FIXME: we really should be able to link non-pic
2268 shared libraries. */
2272 (*_bfd_error_handler
)
2273 (_("%s: probably compiled without -fPIC?"),
2274 bfd_get_filename (input_bfd
));
2275 bfd_set_error (bfd_error_bad_value
);
2281 = ELF64_R_INFO (indx
,
2283 ELF64_R_TYPE_DATA (rel
->r_info
),
2285 outrel
.r_addend
= relocation
+ rel
->r_addend
;
2289 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
,
2290 (((Elf64_External_Rela
*)
2292 + sreloc
->reloc_count
));
2293 ++sreloc
->reloc_count
;
2295 /* This reloc will be computed at runtime, so there's no
2296 need to do anything now. */
2308 /* Relocation is to the entry for this symbol in the global
2312 sgot
= bfd_get_section_by_name (dynobj
, ".got");
2313 BFD_ASSERT (sgot
!= NULL
);
2318 bfd_vma off
= h
->got
.offset
;
2319 BFD_ASSERT (off
!= (bfd_vma
) -1);
2321 if (! elf_hash_table (info
)->dynamic_sections_created
2323 && (info
->symbolic
|| h
->dynindx
== -1)
2324 && (h
->elf_link_hash_flags
2325 & ELF_LINK_HASH_DEF_REGULAR
)))
2327 /* This is actually a static link, or it is a -Bsymbolic
2328 link and the symbol is defined locally, or the symbol
2329 was forced to be local because of a version file. We
2330 must initialize this entry in the global offset table.
2331 Since the offset must always be a multiple of 8, we
2332 use the least significant bit to record whether we
2333 have initialized it already.
2335 When doing a dynamic link, we create a .rela.got
2336 relocation entry to initialize the value. This is
2337 done in the finish_dynamic_symbol routine. */
2343 bfd_put_64 (output_bfd
, relocation
,
2344 sgot
->contents
+ off
);
2348 relocation
= sgot
->output_offset
+ off
- got_base
;
2354 BFD_ASSERT (local_got_offsets
!= NULL
);
2355 off
= local_got_offsets
[r_symndx
];
2356 BFD_ASSERT (off
!= (bfd_vma
) -1);
2358 /* The offset must always be a multiple of 8. We use
2359 the least significant bit to record whether we have
2360 already processed this entry. */
2365 local_got_offsets
[r_symndx
] |= 1;
2370 Elf_Internal_Rela outrel
;
2372 /* The Solaris 2.7 64-bit linker adds the contents
2373 of the location to the value of the reloc.
2374 Note this is different behaviour to the
2375 32-bit linker, which both adds the contents
2376 and ignores the addend. So clear the location. */
2377 bfd_put_64 (output_bfd
, 0, sgot
->contents
+ off
);
2379 /* We need to generate a R_SPARC_RELATIVE reloc
2380 for the dynamic linker. */
2381 srelgot
= bfd_get_section_by_name(dynobj
, ".rela.got");
2382 BFD_ASSERT (srelgot
!= NULL
);
2384 outrel
.r_offset
= (sgot
->output_section
->vma
2385 + sgot
->output_offset
2387 outrel
.r_info
= ELF64_R_INFO (0, R_SPARC_RELATIVE
);
2388 outrel
.r_addend
= relocation
;
2389 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
,
2390 (((Elf64_External_Rela
*)
2392 + srelgot
->reloc_count
));
2393 ++srelgot
->reloc_count
;
2396 bfd_put_64 (output_bfd
, relocation
, sgot
->contents
+ off
);
2398 relocation
= sgot
->output_offset
+ off
- got_base
;
2402 case R_SPARC_WPLT30
:
2404 case R_SPARC_HIPLT22
:
2405 case R_SPARC_LOPLT10
:
2406 case R_SPARC_PCPLT32
:
2407 case R_SPARC_PCPLT22
:
2408 case R_SPARC_PCPLT10
:
2410 /* Relocation is to the entry for this symbol in the
2411 procedure linkage table. */
2412 BFD_ASSERT (h
!= NULL
);
2414 if (h
->plt
.offset
== (bfd_vma
) -1)
2416 /* We didn't make a PLT entry for this symbol. This
2417 happens when statically linking PIC code, or when
2418 using -Bsymbolic. */
2424 splt
= bfd_get_section_by_name (dynobj
, ".plt");
2425 BFD_ASSERT (splt
!= NULL
);
2428 relocation
= (splt
->output_section
->vma
2429 + splt
->output_offset
2430 + sparc64_elf_plt_entry_offset (h
->plt
.offset
));
2431 if (r_type
== R_SPARC_WPLT30
)
2439 relocation
+= rel
->r_addend
;
2440 relocation
= (relocation
& 0x3ff) + ELF64_R_TYPE_DATA (rel
->r_info
);
2442 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2443 x
= (x
& ~0x1fff) | (relocation
& 0x1fff);
2444 bfd_put_32 (input_bfd
, x
, contents
+ rel
->r_offset
);
2446 r
= bfd_check_overflow (howto
->complain_on_overflow
,
2447 howto
->bitsize
, howto
->rightshift
,
2448 bfd_arch_bits_per_address (input_bfd
),
2453 case R_SPARC_WDISP16
:
2457 relocation
+= rel
->r_addend
;
2458 /* Adjust for pc-relative-ness. */
2459 relocation
-= (input_section
->output_section
->vma
2460 + input_section
->output_offset
);
2461 relocation
-= rel
->r_offset
;
2463 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2464 x
= (x
& ~0x303fff) | ((((relocation
>> 2) & 0xc000) << 6)
2465 | ((relocation
>> 2) & 0x3fff));
2466 bfd_put_32 (input_bfd
, x
, contents
+ rel
->r_offset
);
2468 r
= bfd_check_overflow (howto
->complain_on_overflow
,
2469 howto
->bitsize
, howto
->rightshift
,
2470 bfd_arch_bits_per_address (input_bfd
),
2479 relocation
+= rel
->r_addend
;
2480 relocation
= relocation
^ MINUS_ONE
;
2482 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2483 x
= (x
& ~0x3fffff) | ((relocation
>> 10) & 0x3fffff);
2484 bfd_put_32 (input_bfd
, x
, contents
+ rel
->r_offset
);
2486 r
= bfd_check_overflow (howto
->complain_on_overflow
,
2487 howto
->bitsize
, howto
->rightshift
,
2488 bfd_arch_bits_per_address (input_bfd
),
2497 relocation
+= rel
->r_addend
;
2498 relocation
= (relocation
& 0x3ff) | 0x1c00;
2500 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2501 x
= (x
& ~0x1fff) | relocation
;
2502 bfd_put_32 (input_bfd
, x
, contents
+ rel
->r_offset
);
2508 case R_SPARC_WDISP30
:
2510 if (SEC_DO_RELAX (input_section
)
2511 && rel
->r_offset
+ 4 < input_section
->_raw_size
)
2515 #define XCC (2 << 20)
2516 #define COND(x) (((x)&0xf)<<25)
2517 #define CONDA COND(0x8)
2518 #define INSN_BPA (F2(0,1) | CONDA | BPRED | XCC)
2519 #define INSN_BA (F2(0,2) | CONDA)
2520 #define INSN_OR F3(2, 0x2, 0)
2521 #define INSN_NOP F2(0,4)
2525 /* If the instruction is a call with either:
2527 arithmetic instruction with rd == %o7
2528 where rs1 != %o7 and rs2 if it is register != %o7
2529 then we can optimize if the call destination is near
2530 by changing the call into a branch always. */
2531 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2532 y
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
2533 if ((x
& OP(~0)) == OP(1) && (y
& OP(~0)) == OP(2))
2535 if (((y
& OP3(~0)) == OP3(0x3d) /* restore */
2536 || ((y
& OP3(0x28)) == 0 /* arithmetic */
2537 && (y
& RD(~0)) == RD(O7
)))
2538 && (y
& RS1(~0)) != RS1(O7
)
2540 || (y
& RS2(~0)) != RS2(O7
)))
2544 reloc
= relocation
+ rel
->r_addend
- rel
->r_offset
;
2545 reloc
-= (input_section
->output_section
->vma
2546 + input_section
->output_offset
);
2550 /* Ensure the branch fits into simm22. */
2551 if ((reloc
& ~(bfd_vma
)0x7fffff)
2552 && ((reloc
| 0x7fffff) != MINUS_ONE
))
2556 /* Check whether it fits into simm19. */
2557 if ((reloc
& 0x3c0000) == 0
2558 || (reloc
& 0x3c0000) == 0x3c0000)
2559 x
= INSN_BPA
| (reloc
& 0x7ffff); /* ba,pt %xcc */
2561 x
= INSN_BA
| (reloc
& 0x3fffff); /* ba */
2562 bfd_put_32 (input_bfd
, x
, contents
+ rel
->r_offset
);
2564 if (rel
->r_offset
>= 4
2565 && (y
& (0xffffffff ^ RS1(~0)))
2566 == (INSN_OR
| RD(O7
) | RS2(G0
)))
2571 z
= bfd_get_32 (input_bfd
,
2572 contents
+ rel
->r_offset
- 4);
2573 if ((z
& (0xffffffff ^ RD(~0)))
2574 != (INSN_OR
| RS1(O7
) | RS2(G0
)))
2582 If call foo was replaced with ba, replace
2583 or %rN, %g0, %o7 with nop. */
2585 reg
= (y
& RS1(~0)) >> 14;
2586 if (reg
!= ((z
& RD(~0)) >> 25)
2587 || reg
== G0
|| reg
== O7
)
2590 bfd_put_32 (input_bfd
, INSN_NOP
,
2591 contents
+ rel
->r_offset
+ 4);
2601 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
2602 contents
, rel
->r_offset
,
2603 relocation
, rel
->r_addend
);
2613 case bfd_reloc_outofrange
:
2616 case bfd_reloc_overflow
:
2622 if (h
->root
.type
== bfd_link_hash_undefweak
2623 && howto
->pc_relative
)
2625 /* Assume this is a call protected by other code that
2626 detect the symbol is undefined. If this is the case,
2627 we can safely ignore the overflow. If not, the
2628 program is hosed anyway, and a little warning isn't
2633 name
= h
->root
.root
.string
;
2637 name
= (bfd_elf_string_from_elf_section
2639 symtab_hdr
->sh_link
,
2644 name
= bfd_section_name (input_bfd
, sec
);
2646 if (! ((*info
->callbacks
->reloc_overflow
)
2647 (info
, name
, howto
->name
, (bfd_vma
) 0,
2648 input_bfd
, input_section
, rel
->r_offset
)))
2658 /* Finish up dynamic symbol handling. We set the contents of various
2659 dynamic sections here. */
2662 sparc64_elf_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
2664 struct bfd_link_info
*info
;
2665 struct elf_link_hash_entry
*h
;
2666 Elf_Internal_Sym
*sym
;
2670 dynobj
= elf_hash_table (info
)->dynobj
;
2672 if (h
->plt
.offset
!= (bfd_vma
) -1)
2676 Elf_Internal_Rela rela
;
2678 /* This symbol has an entry in the PLT. Set it up. */
2680 BFD_ASSERT (h
->dynindx
!= -1);
2682 splt
= bfd_get_section_by_name (dynobj
, ".plt");
2683 srela
= bfd_get_section_by_name (dynobj
, ".rela.plt");
2684 BFD_ASSERT (splt
!= NULL
&& srela
!= NULL
);
2686 /* Fill in the entry in the .rela.plt section. */
2688 if (h
->plt
.offset
< LARGE_PLT_THRESHOLD
)
2690 rela
.r_offset
= sparc64_elf_plt_entry_offset (h
->plt
.offset
);
2695 int max
= splt
->_raw_size
/ PLT_ENTRY_SIZE
;
2696 rela
.r_offset
= sparc64_elf_plt_ptr_offset (h
->plt
.offset
, max
);
2697 rela
.r_addend
= -(sparc64_elf_plt_entry_offset (h
->plt
.offset
) + 4)
2698 -(splt
->output_section
->vma
+ splt
->output_offset
);
2700 rela
.r_offset
+= (splt
->output_section
->vma
+ splt
->output_offset
);
2701 rela
.r_info
= ELF64_R_INFO (h
->dynindx
, R_SPARC_JMP_SLOT
);
2703 /* Adjust for the first 4 reserved elements in the .plt section
2704 when setting the offset in the .rela.plt section.
2705 Sun forgot to read their own ABI and copied elf32-sparc behaviour,
2706 thus .plt[4] has corresponding .rela.plt[0] and so on. */
2708 bfd_elf64_swap_reloca_out (output_bfd
, &rela
,
2709 ((Elf64_External_Rela
*) srela
->contents
2710 + (h
->plt
.offset
- 4)));
2712 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2714 /* Mark the symbol as undefined, rather than as defined in
2715 the .plt section. Leave the value alone. */
2716 sym
->st_shndx
= SHN_UNDEF
;
2717 /* If the symbol is weak, we do need to clear the value.
2718 Otherwise, the PLT entry would provide a definition for
2719 the symbol even if the symbol wasn't defined anywhere,
2720 and so the symbol would never be NULL. */
2721 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR_NONWEAK
)
2727 if (h
->got
.offset
!= (bfd_vma
) -1)
2731 Elf_Internal_Rela rela
;
2733 /* This symbol has an entry in the GOT. Set it up. */
2735 sgot
= bfd_get_section_by_name (dynobj
, ".got");
2736 srela
= bfd_get_section_by_name (dynobj
, ".rela.got");
2737 BFD_ASSERT (sgot
!= NULL
&& srela
!= NULL
);
2739 rela
.r_offset
= (sgot
->output_section
->vma
2740 + sgot
->output_offset
2741 + (h
->got
.offset
&~ 1));
2743 /* If this is a -Bsymbolic link, and the symbol is defined
2744 locally, we just want to emit a RELATIVE reloc. Likewise if
2745 the symbol was forced to be local because of a version file.
2746 The entry in the global offset table will already have been
2747 initialized in the relocate_section function. */
2749 && (info
->symbolic
|| h
->dynindx
== -1)
2750 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
2752 asection
*sec
= h
->root
.u
.def
.section
;
2753 rela
.r_info
= ELF64_R_INFO (0, R_SPARC_RELATIVE
);
2754 rela
.r_addend
= (h
->root
.u
.def
.value
2755 + sec
->output_section
->vma
2756 + sec
->output_offset
);
2760 bfd_put_64 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
2761 rela
.r_info
= ELF64_R_INFO (h
->dynindx
, R_SPARC_GLOB_DAT
);
2765 bfd_elf64_swap_reloca_out (output_bfd
, &rela
,
2766 ((Elf64_External_Rela
*) srela
->contents
2767 + srela
->reloc_count
));
2768 ++srela
->reloc_count
;
2771 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
2774 Elf_Internal_Rela rela
;
2776 /* This symbols needs a copy reloc. Set it up. */
2778 BFD_ASSERT (h
->dynindx
!= -1);
2780 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
2782 BFD_ASSERT (s
!= NULL
);
2784 rela
.r_offset
= (h
->root
.u
.def
.value
2785 + h
->root
.u
.def
.section
->output_section
->vma
2786 + h
->root
.u
.def
.section
->output_offset
);
2787 rela
.r_info
= ELF64_R_INFO (h
->dynindx
, R_SPARC_COPY
);
2789 bfd_elf64_swap_reloca_out (output_bfd
, &rela
,
2790 ((Elf64_External_Rela
*) s
->contents
2795 /* Mark some specially defined symbols as absolute. */
2796 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2797 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0
2798 || strcmp (h
->root
.root
.string
, "_PROCEDURE_LINKAGE_TABLE_") == 0)
2799 sym
->st_shndx
= SHN_ABS
;
2804 /* Finish up the dynamic sections. */
2807 sparc64_elf_finish_dynamic_sections (output_bfd
, info
)
2809 struct bfd_link_info
*info
;
2812 int stt_regidx
= -1;
2816 dynobj
= elf_hash_table (info
)->dynobj
;
2818 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
2820 if (elf_hash_table (info
)->dynamic_sections_created
)
2823 Elf64_External_Dyn
*dyncon
, *dynconend
;
2825 splt
= bfd_get_section_by_name (dynobj
, ".plt");
2826 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
2828 dyncon
= (Elf64_External_Dyn
*) sdyn
->contents
;
2829 dynconend
= (Elf64_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
2830 for (; dyncon
< dynconend
; dyncon
++)
2832 Elf_Internal_Dyn dyn
;
2836 bfd_elf64_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2840 case DT_PLTGOT
: name
= ".plt"; size
= false; break;
2841 case DT_PLTRELSZ
: name
= ".rela.plt"; size
= true; break;
2842 case DT_JMPREL
: name
= ".rela.plt"; size
= false; break;
2843 case DT_SPARC_REGISTER
:
2844 if (stt_regidx
== -1)
2847 _bfd_elf_link_lookup_local_dynindx (info
, output_bfd
, -1);
2848 if (stt_regidx
== -1)
2851 dyn
.d_un
.d_val
= stt_regidx
++;
2852 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2854 default: name
= NULL
; size
= false; break;
2861 s
= bfd_get_section_by_name (output_bfd
, name
);
2867 dyn
.d_un
.d_ptr
= s
->vma
;
2870 if (s
->_cooked_size
!= 0)
2871 dyn
.d_un
.d_val
= s
->_cooked_size
;
2873 dyn
.d_un
.d_val
= s
->_raw_size
;
2876 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2880 /* Initialize the contents of the .plt section. */
2881 if (splt
->_raw_size
> 0)
2883 sparc64_elf_build_plt(output_bfd
, splt
->contents
,
2884 splt
->_raw_size
/ PLT_ENTRY_SIZE
);
2887 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
=
2891 /* Set the first entry in the global offset table to the address of
2892 the dynamic section. */
2893 sgot
= bfd_get_section_by_name (dynobj
, ".got");
2894 BFD_ASSERT (sgot
!= NULL
);
2895 if (sgot
->_raw_size
> 0)
2898 bfd_put_64 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
2900 bfd_put_64 (output_bfd
,
2901 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
2905 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 8;
2910 /* Functions for dealing with the e_flags field. */
2912 /* Copy backend specific data from one object module to another */
2914 sparc64_elf_copy_private_bfd_data (ibfd
, obfd
)
2917 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2918 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2921 BFD_ASSERT (!elf_flags_init (obfd
)
2922 || (elf_elfheader (obfd
)->e_flags
2923 == elf_elfheader (ibfd
)->e_flags
));
2925 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
2926 elf_flags_init (obfd
) = true;
2930 /* Merge backend specific data from an object file to the output
2931 object file when linking. */
2934 sparc64_elf_merge_private_bfd_data (ibfd
, obfd
)
2939 flagword new_flags
, old_flags
;
2942 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2943 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2946 new_flags
= elf_elfheader (ibfd
)->e_flags
;
2947 old_flags
= elf_elfheader (obfd
)->e_flags
;
2949 if (!elf_flags_init (obfd
)) /* First call, no flags set */
2951 elf_flags_init (obfd
) = true;
2952 elf_elfheader (obfd
)->e_flags
= new_flags
;
2955 else if (new_flags
== old_flags
) /* Compatible flags are ok */
2958 else /* Incompatible flags */
2962 #define EF_SPARC_ISA_EXTENSIONS \
2963 (EF_SPARC_SUN_US1 | EF_SPARC_SUN_US3 | EF_SPARC_HAL_R1)
2965 if ((ibfd
->flags
& DYNAMIC
) != 0)
2967 /* We don't want dynamic objects memory ordering and
2968 architecture to have any role. That's what dynamic linker
2970 new_flags
&= ~(EF_SPARCV9_MM
| EF_SPARC_ISA_EXTENSIONS
);
2971 new_flags
|= (old_flags
2972 & (EF_SPARCV9_MM
| EF_SPARC_ISA_EXTENSIONS
));
2976 /* Choose the highest architecture requirements. */
2977 old_flags
|= (new_flags
& EF_SPARC_ISA_EXTENSIONS
);
2978 new_flags
|= (old_flags
& EF_SPARC_ISA_EXTENSIONS
);
2979 if ((old_flags
& (EF_SPARC_SUN_US1
| EF_SPARC_SUN_US3
))
2980 && (old_flags
& EF_SPARC_HAL_R1
))
2983 (*_bfd_error_handler
)
2984 (_("%s: linking UltraSPARC specific with HAL specific code"),
2985 bfd_get_filename (ibfd
));
2987 /* Choose the most restrictive memory ordering. */
2988 old_mm
= (old_flags
& EF_SPARCV9_MM
);
2989 new_mm
= (new_flags
& EF_SPARCV9_MM
);
2990 old_flags
&= ~EF_SPARCV9_MM
;
2991 new_flags
&= ~EF_SPARCV9_MM
;
2992 if (new_mm
< old_mm
)
2994 old_flags
|= old_mm
;
2995 new_flags
|= old_mm
;
2998 /* Warn about any other mismatches */
2999 if (new_flags
!= old_flags
)
3002 (*_bfd_error_handler
)
3003 (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
3004 bfd_get_filename (ibfd
), (long)new_flags
, (long)old_flags
);
3007 elf_elfheader (obfd
)->e_flags
= old_flags
;
3011 bfd_set_error (bfd_error_bad_value
);
3018 /* Print a STT_REGISTER symbol to file FILE. */
3021 sparc64_elf_print_symbol_all (abfd
, filep
, symbol
)
3022 bfd
*abfd ATTRIBUTE_UNUSED
;
3026 FILE *file
= (FILE *) filep
;
3029 if (ELF_ST_TYPE (((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_info
)
3033 reg
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_value
;
3034 type
= symbol
->flags
;
3035 fprintf (file
, "REG_%c%c%11s%c%c R", "GOLI" [reg
/ 8], '0' + (reg
& 7), "",
3037 ? (type
& BSF_GLOBAL
) ? '!' : 'l'
3038 : (type
& BSF_GLOBAL
) ? 'g' : ' '),
3039 (type
& BSF_WEAK
) ? 'w' : ' ');
3040 if (symbol
->name
== NULL
|| symbol
->name
[0] == '\0')
3043 return symbol
->name
;
3046 /* Set the right machine number for a SPARC64 ELF file. */
3049 sparc64_elf_object_p (abfd
)
3052 unsigned long mach
= bfd_mach_sparc_v9
;
3054 if (elf_elfheader (abfd
)->e_flags
& EF_SPARC_SUN_US3
)
3055 mach
= bfd_mach_sparc_v9b
;
3056 else if (elf_elfheader (abfd
)->e_flags
& EF_SPARC_SUN_US1
)
3057 mach
= bfd_mach_sparc_v9a
;
3058 return bfd_default_set_arch_mach (abfd
, bfd_arch_sparc
, mach
);
3061 /* Relocations in the 64 bit SPARC ELF ABI are more complex than in
3062 standard ELF, because R_SPARC_OLO10 has secondary addend in
3063 ELF64_R_TYPE_DATA field. This structure is used to redirect the
3064 relocation handling routines. */
3066 const struct elf_size_info sparc64_elf_size_info
=
3068 sizeof (Elf64_External_Ehdr
),
3069 sizeof (Elf64_External_Phdr
),
3070 sizeof (Elf64_External_Shdr
),
3071 sizeof (Elf64_External_Rel
),
3072 sizeof (Elf64_External_Rela
),
3073 sizeof (Elf64_External_Sym
),
3074 sizeof (Elf64_External_Dyn
),
3075 sizeof (Elf_External_Note
),
3076 4, /* hash-table entry size */
3077 /* internal relocations per external relocations.
3078 For link purposes we use just 1 internal per
3079 1 external, for assembly and slurp symbol table
3086 bfd_elf64_write_out_phdrs
,
3087 bfd_elf64_write_shdrs_and_ehdr
,
3088 sparc64_elf_write_relocs
,
3089 bfd_elf64_swap_symbol_out
,
3090 sparc64_elf_slurp_reloc_table
,
3091 bfd_elf64_slurp_symbol_table
,
3092 bfd_elf64_swap_dyn_in
,
3093 bfd_elf64_swap_dyn_out
,
3100 #define TARGET_BIG_SYM bfd_elf64_sparc_vec
3101 #define TARGET_BIG_NAME "elf64-sparc"
3102 #define ELF_ARCH bfd_arch_sparc
3103 #define ELF_MAXPAGESIZE 0x100000
3105 /* This is the official ABI value. */
3106 #define ELF_MACHINE_CODE EM_SPARCV9
3108 /* This is the value that we used before the ABI was released. */
3109 #define ELF_MACHINE_ALT1 EM_OLD_SPARCV9
3111 #define bfd_elf64_bfd_link_hash_table_create \
3112 sparc64_elf_bfd_link_hash_table_create
3114 #define elf_info_to_howto \
3115 sparc64_elf_info_to_howto
3116 #define bfd_elf64_get_reloc_upper_bound \
3117 sparc64_elf_get_reloc_upper_bound
3118 #define bfd_elf64_get_dynamic_reloc_upper_bound \
3119 sparc64_elf_get_dynamic_reloc_upper_bound
3120 #define bfd_elf64_canonicalize_dynamic_reloc \
3121 sparc64_elf_canonicalize_dynamic_reloc
3122 #define bfd_elf64_bfd_reloc_type_lookup \
3123 sparc64_elf_reloc_type_lookup
3124 #define bfd_elf64_bfd_relax_section \
3125 sparc64_elf_relax_section
3127 #define elf_backend_create_dynamic_sections \
3128 _bfd_elf_create_dynamic_sections
3129 #define elf_backend_add_symbol_hook \
3130 sparc64_elf_add_symbol_hook
3131 #define elf_backend_get_symbol_type \
3132 sparc64_elf_get_symbol_type
3133 #define elf_backend_symbol_processing \
3134 sparc64_elf_symbol_processing
3135 #define elf_backend_check_relocs \
3136 sparc64_elf_check_relocs
3137 #define elf_backend_adjust_dynamic_symbol \
3138 sparc64_elf_adjust_dynamic_symbol
3139 #define elf_backend_size_dynamic_sections \
3140 sparc64_elf_size_dynamic_sections
3141 #define elf_backend_relocate_section \
3142 sparc64_elf_relocate_section
3143 #define elf_backend_finish_dynamic_symbol \
3144 sparc64_elf_finish_dynamic_symbol
3145 #define elf_backend_finish_dynamic_sections \
3146 sparc64_elf_finish_dynamic_sections
3147 #define elf_backend_print_symbol_all \
3148 sparc64_elf_print_symbol_all
3149 #define elf_backend_output_arch_syms \
3150 sparc64_elf_output_arch_syms
3151 #define bfd_elf64_bfd_copy_private_bfd_data \
3152 sparc64_elf_copy_private_bfd_data
3153 #define bfd_elf64_bfd_merge_private_bfd_data \
3154 sparc64_elf_merge_private_bfd_data
3156 #define elf_backend_size_info \
3157 sparc64_elf_size_info
3158 #define elf_backend_object_p \
3159 sparc64_elf_object_p
3161 #define elf_backend_want_got_plt 0
3162 #define elf_backend_plt_readonly 0
3163 #define elf_backend_want_plt_sym 1
3165 /* Section 5.2.4 of the ABI specifies a 256-byte boundary for the table. */
3166 #define elf_backend_plt_alignment 8
3168 #define elf_backend_got_header_size 8
3169 #define elf_backend_plt_header_size PLT_HEADER_SIZE
3171 #include "elf64-target.h"