1 /* SPARC-specific support for 32-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. */
26 #include "elf/sparc.h"
27 #include "opcode/sparc.h"
29 static reloc_howto_type
*elf32_sparc_reloc_type_lookup
30 PARAMS ((bfd
*, bfd_reloc_code_real_type
));
31 static void elf32_sparc_info_to_howto
32 PARAMS ((bfd
*, arelent
*, Elf_Internal_Rela
*));
33 static boolean elf32_sparc_check_relocs
34 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
35 const Elf_Internal_Rela
*));
36 static boolean elf32_sparc_adjust_dynamic_symbol
37 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
38 static boolean elf32_sparc_size_dynamic_sections
39 PARAMS ((bfd
*, struct bfd_link_info
*));
40 static boolean elf32_sparc_relax_section
41 PARAMS ((bfd
*, asection
*, struct bfd_link_info
*, boolean
*));
42 static boolean elf32_sparc_relocate_section
43 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
44 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**));
45 static boolean elf32_sparc_finish_dynamic_symbol
46 PARAMS ((bfd
*, struct bfd_link_info
*, struct elf_link_hash_entry
*,
48 static boolean elf32_sparc_finish_dynamic_sections
49 PARAMS ((bfd
*, struct bfd_link_info
*));
50 static boolean elf32_sparc_merge_private_bfd_data
PARAMS ((bfd
*, bfd
*));
51 static boolean elf32_sparc_object_p
53 static void elf32_sparc_final_write_processing
54 PARAMS ((bfd
*, boolean
));
55 static enum elf_reloc_type_class elf32_sparc_reloc_type_class
56 PARAMS ((const Elf_Internal_Rela
*));
57 static asection
* elf32_sparc_gc_mark_hook
58 PARAMS ((bfd
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
59 struct elf_link_hash_entry
*, Elf_Internal_Sym
*));
60 static boolean elf32_sparc_gc_sweep_hook
61 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
62 const Elf_Internal_Rela
*));
64 /* The relocation "howto" table. */
66 static bfd_reloc_status_type sparc_elf_notsupported_reloc
67 PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
68 static bfd_reloc_status_type sparc_elf_wdisp16_reloc
69 PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
71 reloc_howto_type _bfd_sparc_elf_howto_table
[] =
73 HOWTO(R_SPARC_NONE
, 0,0, 0,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_NONE", false,0,0x00000000,true),
74 HOWTO(R_SPARC_8
, 0,0, 8,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_8", false,0,0x000000ff,true),
75 HOWTO(R_SPARC_16
, 0,1,16,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_16", false,0,0x0000ffff,true),
76 HOWTO(R_SPARC_32
, 0,2,32,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_32", false,0,0xffffffff,true),
77 HOWTO(R_SPARC_DISP8
, 0,0, 8,true, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_DISP8", false,0,0x000000ff,true),
78 HOWTO(R_SPARC_DISP16
, 0,1,16,true, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_DISP16", false,0,0x0000ffff,true),
79 HOWTO(R_SPARC_DISP32
, 0,2,32,true, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_DISP32", false,0,0xffffffff,true),
80 HOWTO(R_SPARC_WDISP30
, 2,2,30,true, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_WDISP30", false,0,0x3fffffff,true),
81 HOWTO(R_SPARC_WDISP22
, 2,2,22,true, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_WDISP22", false,0,0x003fffff,true),
82 HOWTO(R_SPARC_HI22
, 10,2,22,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_HI22", false,0,0x003fffff,true),
83 HOWTO(R_SPARC_22
, 0,2,22,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_22", false,0,0x003fffff,true),
84 HOWTO(R_SPARC_13
, 0,2,13,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_13", false,0,0x00001fff,true),
85 HOWTO(R_SPARC_LO10
, 0,2,10,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_LO10", false,0,0x000003ff,true),
86 HOWTO(R_SPARC_GOT10
, 0,2,10,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_GOT10", false,0,0x000003ff,true),
87 HOWTO(R_SPARC_GOT13
, 0,2,13,false,0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_GOT13", false,0,0x00001fff,true),
88 HOWTO(R_SPARC_GOT22
, 10,2,22,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_GOT22", false,0,0x003fffff,true),
89 HOWTO(R_SPARC_PC10
, 0,2,10,true, 0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_PC10", false,0,0x000003ff,true),
90 HOWTO(R_SPARC_PC22
, 10,2,22,true, 0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_PC22", false,0,0x003fffff,true),
91 HOWTO(R_SPARC_WPLT30
, 2,2,30,true, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_WPLT30", false,0,0x3fffffff,true),
92 HOWTO(R_SPARC_COPY
, 0,0,00,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_COPY", false,0,0x00000000,true),
93 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),
94 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),
95 HOWTO(R_SPARC_RELATIVE
, 0,0,00,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_RELATIVE",false,0,0x00000000,true),
96 HOWTO(R_SPARC_UA32
, 0,2,32,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_UA32", false,0,0xffffffff,true),
97 HOWTO(R_SPARC_PLT32
, 0,0,00,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_PLT32", false,0,0xffffffff,true),
98 HOWTO(R_SPARC_HIPLT22
, 0,0,00,false,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_HIPLT22", false,0,0x00000000,true),
99 HOWTO(R_SPARC_LOPLT10
, 0,0,00,false,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_LOPLT10", false,0,0x00000000,true),
100 HOWTO(R_SPARC_PCPLT32
, 0,0,00,false,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_PCPLT32", false,0,0x00000000,true),
101 HOWTO(R_SPARC_PCPLT22
, 0,0,00,false,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_PCPLT22", false,0,0x00000000,true),
102 HOWTO(R_SPARC_PCPLT10
, 0,0,00,false,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_PCPLT10", false,0,0x00000000,true),
103 HOWTO(R_SPARC_10
, 0,2,10,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_10", false,0,0x000003ff,true),
104 HOWTO(R_SPARC_11
, 0,2,11,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_11", false,0,0x000007ff,true),
105 /* These are for sparc64 in a 64 bit environment.
106 Values need to be here because the table is indexed by reloc number. */
107 HOWTO(R_SPARC_64
, 0,0,00,false,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_64", false,0,0x00000000,true),
108 HOWTO(R_SPARC_OLO10
, 0,0,00,false,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_OLO10", false,0,0x00000000,true),
109 HOWTO(R_SPARC_HH22
, 0,0,00,false,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_HH22", false,0,0x00000000,true),
110 HOWTO(R_SPARC_HM10
, 0,0,00,false,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_HM10", false,0,0x00000000,true),
111 HOWTO(R_SPARC_LM22
, 0,0,00,false,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_LM22", false,0,0x00000000,true),
112 HOWTO(R_SPARC_PC_HH22
, 0,0,00,false,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_PC_HH22", false,0,0x00000000,true),
113 HOWTO(R_SPARC_PC_HM10
, 0,0,00,false,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_PC_HM10", false,0,0x00000000,true),
114 HOWTO(R_SPARC_PC_LM22
, 0,0,00,false,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_PC_LM22", false,0,0x00000000,true),
115 /* End sparc64 in 64 bit environment values.
116 The following are for sparc64 in a 32 bit environment. */
117 HOWTO(R_SPARC_WDISP16
, 2,2,16,true, 0,complain_overflow_signed
, sparc_elf_wdisp16_reloc
,"R_SPARC_WDISP16", false,0,0x00000000,true),
118 HOWTO(R_SPARC_WDISP19
, 2,2,19,true, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_WDISP19", false,0,0x0007ffff,true),
119 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),
120 HOWTO(R_SPARC_7
, 0,2, 7,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_7", false,0,0x0000007f,true),
121 HOWTO(R_SPARC_5
, 0,2, 5,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_5", false,0,0x0000001f,true),
122 HOWTO(R_SPARC_6
, 0,2, 6,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_6", false,0,0x0000003f,true),
123 HOWTO(R_SPARC_NONE
, 0,0, 0,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_NONE", false,0,0x00000000,true),
124 HOWTO(R_SPARC_NONE
, 0,0, 0,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_NONE", false,0,0x00000000,true),
125 HOWTO(R_SPARC_NONE
, 0,0, 0,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_NONE", false,0,0x00000000,true),
126 HOWTO(R_SPARC_NONE
, 0,0, 0,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_NONE", false,0,0x00000000,true),
127 HOWTO(R_SPARC_NONE
, 0,0, 0,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_NONE", false,0,0x00000000,true),
128 HOWTO(R_SPARC_NONE
, 0,0, 0,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_NONE", false,0,0x00000000,true),
129 HOWTO(R_SPARC_NONE
, 0,0, 0,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_NONE", false,0,0x00000000,true),
130 HOWTO(R_SPARC_NONE
, 0,0, 0,false,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_NONE", false,0,0x00000000,true),
131 HOWTO(R_SPARC_UA64
, 0,0, 0,false,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_UA64", false,0,0x00000000,true),
132 HOWTO(R_SPARC_UA16
, 0,1,16,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_UA16", false,0,0x0000ffff,true),
133 HOWTO(R_SPARC_REV32
, 0,2,32,false,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_REV32", false,0,0xffffffff,true),
135 static reloc_howto_type elf32_sparc_vtinherit_howto
=
136 HOWTO (R_SPARC_GNU_VTINHERIT
, 0,2,0,false,0,complain_overflow_dont
, NULL
, "R_SPARC_GNU_VTINHERIT", false,0, 0, false);
137 static reloc_howto_type elf32_sparc_vtentry_howto
=
138 HOWTO (R_SPARC_GNU_VTENTRY
, 0,2,0,false,0,complain_overflow_dont
, _bfd_elf_rel_vtable_reloc_fn
,"R_SPARC_GNU_VTENTRY", false,0,0, false);
140 struct elf_reloc_map
{
141 bfd_reloc_code_real_type bfd_reloc_val
;
142 unsigned char elf_reloc_val
;
145 static const struct elf_reloc_map sparc_reloc_map
[] =
147 { BFD_RELOC_NONE
, R_SPARC_NONE
, },
148 { BFD_RELOC_16
, R_SPARC_16
, },
149 { BFD_RELOC_16_PCREL
, R_SPARC_DISP16
},
150 { BFD_RELOC_8
, R_SPARC_8
},
151 { BFD_RELOC_8_PCREL
, R_SPARC_DISP8
},
152 { BFD_RELOC_CTOR
, R_SPARC_32
},
153 { BFD_RELOC_32
, R_SPARC_32
},
154 { BFD_RELOC_32_PCREL
, R_SPARC_DISP32
},
155 { BFD_RELOC_HI22
, R_SPARC_HI22
},
156 { BFD_RELOC_LO10
, R_SPARC_LO10
, },
157 { BFD_RELOC_32_PCREL_S2
, R_SPARC_WDISP30
},
158 { BFD_RELOC_SPARC_PLT32
, R_SPARC_PLT32
},
159 { BFD_RELOC_SPARC22
, R_SPARC_22
},
160 { BFD_RELOC_SPARC13
, R_SPARC_13
},
161 { BFD_RELOC_SPARC_GOT10
, R_SPARC_GOT10
},
162 { BFD_RELOC_SPARC_GOT13
, R_SPARC_GOT13
},
163 { BFD_RELOC_SPARC_GOT22
, R_SPARC_GOT22
},
164 { BFD_RELOC_SPARC_PC10
, R_SPARC_PC10
},
165 { BFD_RELOC_SPARC_PC22
, R_SPARC_PC22
},
166 { BFD_RELOC_SPARC_WPLT30
, R_SPARC_WPLT30
},
167 { BFD_RELOC_SPARC_COPY
, R_SPARC_COPY
},
168 { BFD_RELOC_SPARC_GLOB_DAT
, R_SPARC_GLOB_DAT
},
169 { BFD_RELOC_SPARC_JMP_SLOT
, R_SPARC_JMP_SLOT
},
170 { BFD_RELOC_SPARC_RELATIVE
, R_SPARC_RELATIVE
},
171 { BFD_RELOC_SPARC_WDISP22
, R_SPARC_WDISP22
},
172 { BFD_RELOC_SPARC_UA16
, R_SPARC_UA16
},
173 { BFD_RELOC_SPARC_UA32
, R_SPARC_UA32
},
174 { BFD_RELOC_SPARC_UA64
, R_SPARC_UA64
},
175 { BFD_RELOC_SPARC_10
, R_SPARC_10
},
176 { BFD_RELOC_SPARC_11
, R_SPARC_11
},
177 { BFD_RELOC_SPARC_64
, R_SPARC_64
},
178 { BFD_RELOC_SPARC_OLO10
, R_SPARC_OLO10
},
179 { BFD_RELOC_SPARC_HH22
, R_SPARC_HH22
},
180 { BFD_RELOC_SPARC_HM10
, R_SPARC_HM10
},
181 { BFD_RELOC_SPARC_LM22
, R_SPARC_LM22
},
182 { BFD_RELOC_SPARC_PC_HH22
, R_SPARC_PC_HH22
},
183 { BFD_RELOC_SPARC_PC_HM10
, R_SPARC_PC_HM10
},
184 { BFD_RELOC_SPARC_PC_LM22
, R_SPARC_PC_LM22
},
185 { BFD_RELOC_SPARC_WDISP16
, R_SPARC_WDISP16
},
186 { BFD_RELOC_SPARC_WDISP19
, R_SPARC_WDISP19
},
187 { BFD_RELOC_SPARC_7
, R_SPARC_7
},
188 { BFD_RELOC_SPARC_5
, R_SPARC_5
},
189 { BFD_RELOC_SPARC_6
, R_SPARC_6
},
190 { BFD_RELOC_SPARC_REV32
, R_SPARC_REV32
},
191 { BFD_RELOC_VTABLE_INHERIT
, R_SPARC_GNU_VTINHERIT
},
192 { BFD_RELOC_VTABLE_ENTRY
, R_SPARC_GNU_VTENTRY
},
195 static reloc_howto_type
*
196 elf32_sparc_reloc_type_lookup (abfd
, code
)
197 bfd
*abfd ATTRIBUTE_UNUSED
;
198 bfd_reloc_code_real_type code
;
204 case BFD_RELOC_VTABLE_INHERIT
:
205 return &elf32_sparc_vtinherit_howto
;
207 case BFD_RELOC_VTABLE_ENTRY
:
208 return &elf32_sparc_vtentry_howto
;
211 for (i
= 0; i
< sizeof (sparc_reloc_map
) / sizeof (struct elf_reloc_map
); i
++)
213 if (sparc_reloc_map
[i
].bfd_reloc_val
== code
)
214 return &_bfd_sparc_elf_howto_table
[(int) sparc_reloc_map
[i
].elf_reloc_val
];
217 bfd_set_error (bfd_error_bad_value
);
221 /* We need to use ELF32_R_TYPE so we have our own copy of this function,
222 and elf64-sparc.c has its own copy. */
225 elf32_sparc_info_to_howto (abfd
, cache_ptr
, dst
)
226 bfd
*abfd ATTRIBUTE_UNUSED
;
228 Elf_Internal_Rela
*dst
;
230 switch (ELF32_R_TYPE(dst
->r_info
))
232 case R_SPARC_GNU_VTINHERIT
:
233 cache_ptr
->howto
= &elf32_sparc_vtinherit_howto
;
236 case R_SPARC_GNU_VTENTRY
:
237 cache_ptr
->howto
= &elf32_sparc_vtentry_howto
;
241 BFD_ASSERT (ELF32_R_TYPE(dst
->r_info
) < (unsigned int) R_SPARC_max_std
);
242 cache_ptr
->howto
= &_bfd_sparc_elf_howto_table
[ELF32_R_TYPE(dst
->r_info
)];
246 /* For unsupported relocs. */
248 static bfd_reloc_status_type
249 sparc_elf_notsupported_reloc (abfd
,
256 bfd
*abfd ATTRIBUTE_UNUSED
;
257 arelent
*reloc_entry ATTRIBUTE_UNUSED
;
258 asymbol
*symbol ATTRIBUTE_UNUSED
;
259 PTR data ATTRIBUTE_UNUSED
;
260 asection
*input_section ATTRIBUTE_UNUSED
;
261 bfd
*output_bfd ATTRIBUTE_UNUSED
;
262 char **error_message ATTRIBUTE_UNUSED
;
264 return bfd_reloc_notsupported
;
267 /* Handle the WDISP16 reloc. */
269 static bfd_reloc_status_type
270 sparc_elf_wdisp16_reloc (abfd
,
278 arelent
*reloc_entry
;
281 asection
*input_section
;
283 char **error_message ATTRIBUTE_UNUSED
;
288 if (output_bfd
!= (bfd
*) NULL
289 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
290 && (! reloc_entry
->howto
->partial_inplace
291 || reloc_entry
->addend
== 0))
293 reloc_entry
->address
+= input_section
->output_offset
;
297 if (output_bfd
!= NULL
)
298 return bfd_reloc_continue
;
300 if (reloc_entry
->address
> input_section
->_cooked_size
)
301 return bfd_reloc_outofrange
;
303 relocation
= (symbol
->value
304 + symbol
->section
->output_section
->vma
305 + symbol
->section
->output_offset
);
306 relocation
+= reloc_entry
->addend
;
307 relocation
-= (input_section
->output_section
->vma
308 + input_section
->output_offset
);
309 relocation
-= reloc_entry
->address
;
311 x
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
312 x
|= ((((relocation
>> 2) & 0xc000) << 6)
313 | ((relocation
>> 2) & 0x3fff));
314 bfd_put_32 (abfd
, x
, (bfd_byte
*) data
+ reloc_entry
->address
);
316 if ((bfd_signed_vma
) relocation
< - 0x40000
317 || (bfd_signed_vma
) relocation
> 0x3ffff)
318 return bfd_reloc_overflow
;
323 /* Functions for the SPARC ELF linker. */
325 /* The name of the dynamic interpreter. This is put in the .interp
328 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
330 /* The nop opcode we use. */
332 #define SPARC_NOP 0x01000000
334 /* The size in bytes of an entry in the procedure linkage table. */
336 #define PLT_ENTRY_SIZE 12
338 /* The first four entries in a procedure linkage table are reserved,
339 and the initial contents are unimportant (we zero them out).
340 Subsequent entries look like this. See the SVR4 ABI SPARC
341 supplement to see how this works. */
343 /* sethi %hi(.-.plt0),%g1. We fill in the address later. */
344 #define PLT_ENTRY_WORD0 0x03000000
345 /* b,a .plt0. We fill in the offset later. */
346 #define PLT_ENTRY_WORD1 0x30800000
348 #define PLT_ENTRY_WORD2 SPARC_NOP
350 /* Look through the relocs for a section during the first phase, and
351 allocate space in the global offset table or procedure linkage
355 elf32_sparc_check_relocs (abfd
, info
, sec
, relocs
)
357 struct bfd_link_info
*info
;
359 const Elf_Internal_Rela
*relocs
;
362 Elf_Internal_Shdr
*symtab_hdr
;
363 struct elf_link_hash_entry
**sym_hashes
;
364 bfd_vma
*local_got_offsets
;
365 const Elf_Internal_Rela
*rel
;
366 const Elf_Internal_Rela
*rel_end
;
371 if (info
->relocateable
)
374 dynobj
= elf_hash_table (info
)->dynobj
;
375 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
376 sym_hashes
= elf_sym_hashes (abfd
);
377 local_got_offsets
= elf_local_got_offsets (abfd
);
383 rel_end
= relocs
+ sec
->reloc_count
;
384 for (rel
= relocs
; rel
< rel_end
; rel
++)
386 unsigned long r_symndx
;
387 struct elf_link_hash_entry
*h
;
389 r_symndx
= ELF32_R_SYM (rel
->r_info
);
390 if (r_symndx
< symtab_hdr
->sh_info
)
393 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
395 switch (ELF32_R_TYPE (rel
->r_info
))
400 /* This symbol requires a global offset table entry. */
404 /* Create the .got section. */
405 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
406 if (! _bfd_elf_create_got_section (dynobj
, info
))
412 sgot
= bfd_get_section_by_name (dynobj
, ".got");
413 BFD_ASSERT (sgot
!= NULL
);
417 && (h
!= NULL
|| info
->shared
))
419 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
422 srelgot
= bfd_make_section (dynobj
, ".rela.got");
424 || ! bfd_set_section_flags (dynobj
, srelgot
,
431 || ! bfd_set_section_alignment (dynobj
, srelgot
, 2))
438 if (h
->got
.offset
!= (bfd_vma
) -1)
440 /* We have already allocated space in the .got. */
443 h
->got
.offset
= sgot
->_raw_size
;
445 /* Make sure this symbol is output as a dynamic symbol. */
446 if (h
->dynindx
== -1)
448 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
452 srelgot
->_raw_size
+= sizeof (Elf32_External_Rela
);
456 /* This is a global offset table entry for a local
458 if (local_got_offsets
== NULL
)
461 register unsigned int i
;
463 size
= symtab_hdr
->sh_info
;
464 size
*= sizeof (bfd_vma
);
465 local_got_offsets
= (bfd_vma
*) bfd_alloc (abfd
, size
);
466 if (local_got_offsets
== NULL
)
468 elf_local_got_offsets (abfd
) = local_got_offsets
;
469 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
470 local_got_offsets
[i
] = (bfd_vma
) -1;
472 if (local_got_offsets
[r_symndx
] != (bfd_vma
) -1)
474 /* We have already allocated space in the .got. */
477 local_got_offsets
[r_symndx
] = sgot
->_raw_size
;
481 /* If we are generating a shared object, we need to
482 output a R_SPARC_RELATIVE reloc so that the
483 dynamic linker can adjust this GOT entry. */
484 srelgot
->_raw_size
+= sizeof (Elf32_External_Rela
);
488 sgot
->_raw_size
+= 4;
490 /* If the .got section is more than 0x1000 bytes, we add
491 0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13
492 bit relocations have a greater chance of working. */
493 if (sgot
->_raw_size
>= 0x1000
494 && elf_hash_table (info
)->hgot
->root
.u
.def
.value
== 0)
495 elf_hash_table (info
)->hgot
->root
.u
.def
.value
= 0x1000;
501 /* This symbol requires a procedure linkage table entry. We
502 actually build the entry in adjust_dynamic_symbol,
503 because this might be a case of linking PIC code without
504 linking in any dynamic objects, in which case we don't
505 need to generate a procedure linkage table after all. */
509 /* The Solaris native assembler will generate a WPLT30
510 reloc for a local symbol if you assemble a call from
511 one section to another when using -K pic. We treat
513 if (ELF32_R_TYPE (rel
->r_info
) != R_SPARC_WPLT30
)
518 /* Make sure this symbol is output as a dynamic symbol. */
519 if (h
->dynindx
== -1)
521 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
525 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
527 if (ELF32_R_TYPE (rel
->r_info
) != R_SPARC_WPLT30
)
534 h
->elf_link_hash_flags
|= ELF_LINK_NON_GOT_REF
;
537 && strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
543 case R_SPARC_WDISP30
:
544 case R_SPARC_WDISP22
:
545 case R_SPARC_WDISP19
:
546 case R_SPARC_WDISP16
:
548 h
->elf_link_hash_flags
|= ELF_LINK_NON_GOT_REF
;
550 /* If we are linking with -Bsymbolic, we do not need to copy
551 a PC relative reloc against a global symbol which is
552 defined in an object we are including in the link (i.e.,
553 DEF_REGULAR is set). FIXME: At this point we have not
554 seen all the input files, so it is possible that
555 DEF_REGULAR is not set now but will be set later (it is
556 never cleared). This needs to be handled as in
560 && (h
->elf_link_hash_flags
561 & ELF_LINK_HASH_DEF_REGULAR
) != 0))
574 h
->elf_link_hash_flags
|= ELF_LINK_NON_GOT_REF
;
577 if (info
->shared
&& (sec
->flags
& SEC_ALLOC
))
579 /* When creating a shared object, we must copy these
580 relocs into the output file. We create a reloc
581 section in dynobj and make room for the reloc. */
586 name
= (bfd_elf_string_from_elf_section
588 elf_elfheader (abfd
)->e_shstrndx
,
589 elf_section_data (sec
)->rel_hdr
.sh_name
));
593 BFD_ASSERT (strncmp (name
, ".rela", 5) == 0
594 && strcmp (bfd_get_section_name (abfd
, sec
),
597 sreloc
= bfd_get_section_by_name (dynobj
, name
);
602 sreloc
= bfd_make_section (dynobj
, name
);
603 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
604 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
605 if ((sec
->flags
& SEC_ALLOC
) != 0)
606 flags
|= SEC_ALLOC
| SEC_LOAD
;
608 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
609 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
612 if (sec
->flags
& SEC_READONLY
)
613 info
->flags
|= DF_TEXTREL
;
616 sreloc
->_raw_size
+= sizeof (Elf32_External_Rela
);
621 case R_SPARC_GNU_VTINHERIT
:
622 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
626 case R_SPARC_GNU_VTENTRY
:
627 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
640 elf32_sparc_gc_mark_hook (abfd
, info
, rel
, h
, sym
)
642 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
643 Elf_Internal_Rela
*rel
;
644 struct elf_link_hash_entry
*h
;
645 Elf_Internal_Sym
*sym
;
650 switch (ELF32_R_TYPE (rel
->r_info
))
652 case R_SPARC_GNU_VTINHERIT
:
653 case R_SPARC_GNU_VTENTRY
:
657 switch (h
->root
.type
)
659 case bfd_link_hash_defined
:
660 case bfd_link_hash_defweak
:
661 return h
->root
.u
.def
.section
;
663 case bfd_link_hash_common
:
664 return h
->root
.u
.c
.p
->section
;
673 return bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
679 /* Update the got entry reference counts for the section being removed. */
681 elf32_sparc_gc_sweep_hook (abfd
, info
, sec
, relocs
)
683 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
685 const Elf_Internal_Rela
*relocs
;
688 Elf_Internal_Shdr
*symtab_hdr
;
689 struct elf_link_hash_entry
**sym_hashes
;
690 bfd_signed_vma
*local_got_refcounts
;
691 const Elf_Internal_Rela
*rel
, *relend
;
692 unsigned long r_symndx
;
693 struct elf_link_hash_entry
*h
;
695 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
696 sym_hashes
= elf_sym_hashes (abfd
);
697 local_got_refcounts
= elf_local_got_refcounts (abfd
);
699 relend
= relocs
+ sec
->reloc_count
;
700 for (rel
= relocs
; rel
< relend
; rel
++)
701 switch (ELF32_R_TYPE (rel
->r_info
))
706 r_symndx
= ELF32_R_SYM (rel
->r_info
);
707 if (r_symndx
>= symtab_hdr
->sh_info
)
709 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
710 if (h
->got
.refcount
> 0)
715 if (local_got_refcounts
[r_symndx
] > 0)
716 local_got_refcounts
[r_symndx
]--;
721 case R_SPARC_HIPLT22
:
722 case R_SPARC_LOPLT10
:
723 case R_SPARC_PCPLT32
:
724 case R_SPARC_PCPLT10
:
725 r_symndx
= ELF32_R_SYM (rel
->r_info
);
726 if (r_symndx
>= symtab_hdr
->sh_info
)
728 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
729 if (h
->plt
.refcount
> 0)
741 /* Adjust a symbol defined by a dynamic object and referenced by a
742 regular object. The current definition is in some section of the
743 dynamic object, but we're not including those sections. We have to
744 change the definition to something the rest of the link can
748 elf32_sparc_adjust_dynamic_symbol (info
, h
)
749 struct bfd_link_info
*info
;
750 struct elf_link_hash_entry
*h
;
754 unsigned int power_of_two
;
756 dynobj
= elf_hash_table (info
)->dynobj
;
758 /* Make sure we know what is going on here. */
759 BFD_ASSERT (dynobj
!= NULL
760 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
761 || h
->weakdef
!= NULL
762 || ((h
->elf_link_hash_flags
763 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
764 && (h
->elf_link_hash_flags
765 & ELF_LINK_HASH_REF_REGULAR
) != 0
766 && (h
->elf_link_hash_flags
767 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
769 /* If this is a function, put it in the procedure linkage table. We
770 will fill in the contents of the procedure linkage table later
771 (although we could actually do it here). The STT_NOTYPE
772 condition is a hack specifically for the Oracle libraries
773 delivered for Solaris; for some inexplicable reason, they define
774 some of their functions as STT_NOTYPE when they really should be
776 if (h
->type
== STT_FUNC
777 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0
778 || (h
->type
== STT_NOTYPE
779 && (h
->root
.type
== bfd_link_hash_defined
780 || h
->root
.type
== bfd_link_hash_defweak
)
781 && (h
->root
.u
.def
.section
->flags
& SEC_CODE
) != 0))
783 if (! elf_hash_table (info
)->dynamic_sections_created
784 || ((!info
->shared
|| info
->symbolic
|| h
->dynindx
== -1)
785 && (h
->elf_link_hash_flags
786 & ELF_LINK_HASH_DEF_REGULAR
) != 0))
788 /* This case can occur if we saw a WPLT30 reloc in an input
789 file, but none of the input files were dynamic objects.
790 Or, when linking the main application or a -Bsymbolic
791 shared library against PIC code. Or when a global symbol
792 has been made private, e.g. via versioning.
794 In these cases we know what value the symbol will resolve
795 to, so we don't actually need to build a procedure linkage
796 table, and we can just do a WDISP30 reloc instead. */
798 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
802 s
= bfd_get_section_by_name (dynobj
, ".plt");
803 BFD_ASSERT (s
!= NULL
);
805 /* The first four entries in .plt are reserved. */
806 if (s
->_raw_size
== 0)
807 s
->_raw_size
= 4 * PLT_ENTRY_SIZE
;
809 /* The procedure linkage table has a maximum size. */
810 if (s
->_raw_size
>= 0x400000)
812 bfd_set_error (bfd_error_bad_value
);
816 /* If this symbol is not defined in a regular file, and we are
817 not generating a shared library, then set the symbol to this
818 location in the .plt. This is required to make function
819 pointers compare as equal between the normal executable and
820 the shared library. */
822 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
824 h
->root
.u
.def
.section
= s
;
825 h
->root
.u
.def
.value
= s
->_raw_size
;
828 h
->plt
.offset
= s
->_raw_size
;
830 /* Make room for this entry. */
831 s
->_raw_size
+= PLT_ENTRY_SIZE
;
833 /* We also need to make an entry in the .rela.plt section. */
835 s
= bfd_get_section_by_name (dynobj
, ".rela.plt");
836 BFD_ASSERT (s
!= NULL
);
837 s
->_raw_size
+= sizeof (Elf32_External_Rela
);
842 /* If this is a weak symbol, and there is a real definition, the
843 processor independent code will have arranged for us to see the
844 real definition first, and we can just use the same value. */
845 if (h
->weakdef
!= NULL
)
847 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
848 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
849 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
850 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
854 /* This is a reference to a symbol defined by a dynamic object which
855 is not a function. */
857 /* If we are creating a shared library, we must presume that the
858 only references to the symbol are via the global offset table.
859 For such cases we need not do anything here; the relocations will
860 be handled correctly by relocate_section. */
864 /* If there are no references to this symbol that do not use the
865 GOT, we don't need to generate a copy reloc. */
866 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0)
869 /* We must allocate the symbol in our .dynbss section, which will
870 become part of the .bss section of the executable. There will be
871 an entry for this symbol in the .dynsym section. The dynamic
872 object will contain position independent code, so all references
873 from the dynamic object to this symbol will go through the global
874 offset table. The dynamic linker will use the .dynsym entry to
875 determine the address it must put in the global offset table, so
876 both the dynamic object and the regular object will refer to the
877 same memory location for the variable. */
879 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
880 BFD_ASSERT (s
!= NULL
);
882 /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker
883 to copy the initial value out of the dynamic object and into the
884 runtime process image. We need to remember the offset into the
885 .rel.bss section we are going to use. */
886 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
890 srel
= bfd_get_section_by_name (dynobj
, ".rela.bss");
891 BFD_ASSERT (srel
!= NULL
);
892 srel
->_raw_size
+= sizeof (Elf32_External_Rela
);
893 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
896 /* We need to figure out the alignment required for this symbol. I
897 have no idea how ELF linkers handle this. */
898 power_of_two
= bfd_log2 (h
->size
);
899 if (power_of_two
> 3)
902 /* Apply the required alignment. */
903 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
,
904 (bfd_size_type
) (1 << power_of_two
));
905 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
907 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
911 /* Define the symbol as being at this point in the section. */
912 h
->root
.u
.def
.section
= s
;
913 h
->root
.u
.def
.value
= s
->_raw_size
;
915 /* Increment the section size to make room for the symbol. */
916 s
->_raw_size
+= h
->size
;
921 /* Set the sizes of the dynamic sections. */
924 elf32_sparc_size_dynamic_sections (output_bfd
, info
)
925 bfd
*output_bfd ATTRIBUTE_UNUSED
;
926 struct bfd_link_info
*info
;
932 dynobj
= elf_hash_table (info
)->dynobj
;
933 BFD_ASSERT (dynobj
!= NULL
);
935 if (elf_hash_table (info
)->dynamic_sections_created
)
937 /* Set the contents of the .interp section to the interpreter. */
940 s
= bfd_get_section_by_name (dynobj
, ".interp");
941 BFD_ASSERT (s
!= NULL
);
942 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
943 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
946 /* Make space for the trailing nop in .plt. */
947 s
= bfd_get_section_by_name (dynobj
, ".plt");
948 BFD_ASSERT (s
!= NULL
);
949 if (s
->_raw_size
> 0)
954 /* We may have created entries in the .rela.got section.
955 However, if we are not creating the dynamic sections, we will
956 not actually use these entries. Reset the size of .rela.got,
957 which will cause it to get stripped from the output file
959 s
= bfd_get_section_by_name (dynobj
, ".rela.got");
964 /* The check_relocs and adjust_dynamic_symbol entry points have
965 determined the sizes of the various dynamic sections. Allocate
968 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
973 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
976 /* It's OK to base decisions on the section name, because none
977 of the dynobj section names depend upon the input files. */
978 name
= bfd_get_section_name (dynobj
, s
);
982 if (strncmp (name
, ".rela", 5) == 0)
984 if (s
->_raw_size
== 0)
986 /* If we don't need this section, strip it from the
987 output file. This is to handle .rela.bss and
988 .rel.plt. We must create it in
989 create_dynamic_sections, because it must be created
990 before the linker maps input sections to output
991 sections. The linker does that before
992 adjust_dynamic_symbol is called, and it is that
993 function which decides whether anything needs to go
994 into these sections. */
999 if (strcmp (name
, ".rela.plt") == 0)
1002 /* We use the reloc_count field as a counter if we need
1003 to copy relocs into the output file. */
1007 else if (strcmp (name
, ".plt") != 0
1008 && strcmp (name
, ".got") != 0)
1010 /* It's not one of our sections, so don't allocate space. */
1016 _bfd_strip_section_from_output (info
, s
);
1020 /* Allocate memory for the section contents. */
1021 /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
1022 Unused entries should be reclaimed before the section's contents
1023 are written out, but at the moment this does not happen. Thus in
1024 order to prevent writing out garbage, we initialise the section's
1025 contents to zero. */
1026 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
1027 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
1031 if (elf_hash_table (info
)->dynamic_sections_created
)
1033 /* Add some entries to the .dynamic section. We fill in the
1034 values later, in elf32_sparc_finish_dynamic_sections, but we
1035 must add the entries now so that we get the correct size for
1036 the .dynamic section. The DT_DEBUG entry is filled in by the
1037 dynamic linker and used by the debugger. */
1038 #define add_dynamic_entry(TAG, VAL) \
1039 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1043 if (!add_dynamic_entry (DT_DEBUG
, 0))
1049 if (!add_dynamic_entry (DT_PLTGOT
, 0)
1050 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
1051 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
1052 || !add_dynamic_entry (DT_JMPREL
, 0))
1056 if (!add_dynamic_entry (DT_RELA
, 0)
1057 || !add_dynamic_entry (DT_RELASZ
, 0)
1058 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf32_External_Rela
)))
1061 if (info
->flags
& DF_TEXTREL
)
1063 if (!add_dynamic_entry (DT_TEXTREL
, 0))
1067 #undef add_dynamic_entry
1072 #define SET_SEC_DO_RELAX(section) do { elf_section_data(section)->tdata = (void *)1; } while (0)
1073 #define SEC_DO_RELAX(section) (elf_section_data(section)->tdata == (void *)1)
1076 elf32_sparc_relax_section (abfd
, section
, link_info
, again
)
1077 bfd
*abfd ATTRIBUTE_UNUSED
;
1078 asection
*section ATTRIBUTE_UNUSED
;
1079 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
;
1083 SET_SEC_DO_RELAX (section
);
1087 /* Relocate a SPARC ELF section. */
1090 elf32_sparc_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
1091 contents
, relocs
, local_syms
, local_sections
)
1093 struct bfd_link_info
*info
;
1095 asection
*input_section
;
1097 Elf_Internal_Rela
*relocs
;
1098 Elf_Internal_Sym
*local_syms
;
1099 asection
**local_sections
;
1102 Elf_Internal_Shdr
*symtab_hdr
;
1103 struct elf_link_hash_entry
**sym_hashes
;
1104 bfd_vma
*local_got_offsets
;
1109 Elf_Internal_Rela
*rel
;
1110 Elf_Internal_Rela
*relend
;
1112 dynobj
= elf_hash_table (info
)->dynobj
;
1113 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1114 sym_hashes
= elf_sym_hashes (input_bfd
);
1115 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1117 if (elf_hash_table (info
)->hgot
== NULL
)
1120 got_base
= elf_hash_table (info
)->hgot
->root
.u
.def
.value
;
1127 relend
= relocs
+ input_section
->reloc_count
;
1128 for (; rel
< relend
; rel
++)
1131 reloc_howto_type
*howto
;
1132 unsigned long r_symndx
;
1133 struct elf_link_hash_entry
*h
;
1134 Elf_Internal_Sym
*sym
;
1137 bfd_reloc_status_type r
;
1138 boolean is_plt
= false;
1140 r_type
= ELF32_R_TYPE (rel
->r_info
);
1142 if (r_type
== R_SPARC_GNU_VTINHERIT
1143 || r_type
== R_SPARC_GNU_VTENTRY
)
1146 if (r_type
< 0 || r_type
>= (int) R_SPARC_max_std
)
1148 bfd_set_error (bfd_error_bad_value
);
1151 howto
= _bfd_sparc_elf_howto_table
+ r_type
;
1153 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1155 if (info
->relocateable
)
1157 /* This is a relocateable link. We don't have to change
1158 anything, unless the reloc is against a section symbol,
1159 in which case we have to adjust according to where the
1160 section symbol winds up in the output section. */
1161 if (r_symndx
< symtab_hdr
->sh_info
)
1163 sym
= local_syms
+ r_symndx
;
1164 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1166 sec
= local_sections
[r_symndx
];
1167 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
1174 /* This is a final link. */
1178 if (r_symndx
< symtab_hdr
->sh_info
)
1180 sym
= local_syms
+ r_symndx
;
1181 sec
= local_sections
[r_symndx
];
1182 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, sec
, rel
);
1186 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1187 while (h
->root
.type
== bfd_link_hash_indirect
1188 || h
->root
.type
== bfd_link_hash_warning
)
1189 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1190 if (h
->root
.type
== bfd_link_hash_defined
1191 || h
->root
.type
== bfd_link_hash_defweak
)
1193 sec
= h
->root
.u
.def
.section
;
1194 if (((r_type
== R_SPARC_WPLT30
1195 || r_type
== R_SPARC_PLT32
)
1196 && h
->plt
.offset
!= (bfd_vma
) -1)
1197 || ((r_type
== R_SPARC_GOT10
1198 || r_type
== R_SPARC_GOT13
1199 || r_type
== R_SPARC_GOT22
)
1200 && elf_hash_table (info
)->dynamic_sections_created
1202 || (! info
->symbolic
&& h
->dynindx
!= -1)
1203 || (h
->elf_link_hash_flags
1204 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
1206 && ((! info
->symbolic
&& h
->dynindx
!= -1)
1207 || (h
->elf_link_hash_flags
1208 & ELF_LINK_HASH_DEF_REGULAR
) == 0)
1209 && (r_type
== R_SPARC_8
1210 || r_type
== R_SPARC_16
1211 || r_type
== R_SPARC_32
1212 || r_type
== R_SPARC_DISP8
1213 || r_type
== R_SPARC_DISP16
1214 || r_type
== R_SPARC_DISP32
1215 || r_type
== R_SPARC_WDISP30
1216 || r_type
== R_SPARC_WDISP22
1217 || r_type
== R_SPARC_WDISP19
1218 || r_type
== R_SPARC_WDISP16
1219 || r_type
== R_SPARC_HI22
1220 || r_type
== R_SPARC_22
1221 || r_type
== R_SPARC_13
1222 || r_type
== R_SPARC_LO10
1223 || r_type
== R_SPARC_UA16
1224 || r_type
== R_SPARC_UA32
1225 || ((r_type
== R_SPARC_PC10
1226 || r_type
== R_SPARC_PC22
)
1227 && strcmp (h
->root
.root
.string
,
1228 "_GLOBAL_OFFSET_TABLE_") != 0))
1229 && ((input_section
->flags
& SEC_ALLOC
) != 0
1230 /* DWARF will emit R_SPARC_32 relocations in its
1231 sections against symbols defined externally
1232 in shared libraries. We can't do anything
1234 || ((input_section
->flags
& SEC_DEBUGGING
) != 0
1235 && (h
->elf_link_hash_flags
1236 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0))))
1238 /* In these cases, we don't need the relocation
1239 value. We check specially because in some
1240 obscure cases sec->output_section will be NULL. */
1244 relocation
= (h
->root
.u
.def
.value
1245 + sec
->output_section
->vma
1246 + sec
->output_offset
);
1248 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1250 else if (info
->shared
1251 && (!info
->symbolic
|| info
->allow_shlib_undefined
)
1252 && !info
->no_undefined
1253 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
1257 if (! ((*info
->callbacks
->undefined_symbol
)
1258 (info
, h
->root
.root
.string
, input_bfd
,
1259 input_section
, rel
->r_offset
,
1260 (!info
->shared
|| info
->no_undefined
1261 || ELF_ST_VISIBILITY (h
->other
)))))
1272 /* Relocation is to the entry for this symbol in the global
1276 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1277 BFD_ASSERT (sgot
!= NULL
);
1284 off
= h
->got
.offset
;
1285 BFD_ASSERT (off
!= (bfd_vma
) -1);
1287 if (! elf_hash_table (info
)->dynamic_sections_created
1289 && (info
->symbolic
|| h
->dynindx
== -1)
1290 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
1292 /* This is actually a static link, or it is a
1293 -Bsymbolic link and the symbol is defined
1294 locally, or the symbol was forced to be local
1295 because of a version file. We must initialize
1296 this entry in the global offset table. Since the
1297 offset must always be a multiple of 4, we use the
1298 least significant bit to record whether we have
1299 initialized it already.
1301 When doing a dynamic link, we create a .rela.got
1302 relocation entry to initialize the value. This
1303 is done in the finish_dynamic_symbol routine. */
1308 bfd_put_32 (output_bfd
, relocation
,
1309 sgot
->contents
+ off
);
1314 relocation
= sgot
->output_offset
+ off
- got_base
;
1320 BFD_ASSERT (local_got_offsets
!= NULL
1321 && local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
1323 off
= local_got_offsets
[r_symndx
];
1325 /* The offset must always be a multiple of 4. We use
1326 the least significant bit to record whether we have
1327 already processed this entry. */
1332 bfd_put_32 (output_bfd
, relocation
, sgot
->contents
+ off
);
1337 Elf_Internal_Rela outrel
;
1339 /* We need to generate a R_SPARC_RELATIVE reloc
1340 for the dynamic linker. */
1341 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
1342 BFD_ASSERT (srelgot
!= NULL
);
1344 outrel
.r_offset
= (sgot
->output_section
->vma
1345 + sgot
->output_offset
1347 outrel
.r_info
= ELF32_R_INFO (0, R_SPARC_RELATIVE
);
1348 outrel
.r_addend
= 0;
1349 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
,
1350 (((Elf32_External_Rela
*)
1352 + srelgot
->reloc_count
));
1353 ++srelgot
->reloc_count
;
1356 local_got_offsets
[r_symndx
] |= 1;
1359 relocation
= sgot
->output_offset
+ off
- got_base
;
1365 if (h
== NULL
|| h
->plt
.offset
== (bfd_vma
) -1)
1367 r_type
= R_SPARC_32
;
1371 case R_SPARC_WPLT30
:
1372 /* Relocation is to the entry for this symbol in the
1373 procedure linkage table. */
1375 /* The Solaris native assembler will generate a WPLT30 reloc
1376 for a local symbol if you assemble a call from one
1377 section to another when using -K pic. We treat it as
1382 if (h
->plt
.offset
== (bfd_vma
) -1)
1384 /* We didn't make a PLT entry for this symbol. This
1385 happens when statically linking PIC code, or when
1386 using -Bsymbolic. */
1392 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1393 BFD_ASSERT (splt
!= NULL
);
1396 relocation
= (splt
->output_section
->vma
1397 + splt
->output_offset
1399 if (r_type
== R_SPARC_PLT32
)
1401 r_type
= R_SPARC_32
;
1410 && strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
1414 case R_SPARC_DISP16
:
1415 case R_SPARC_DISP32
:
1416 case R_SPARC_WDISP30
:
1417 case R_SPARC_WDISP22
:
1418 case R_SPARC_WDISP19
:
1419 case R_SPARC_WDISP16
:
1422 && (h
->elf_link_hash_flags
1423 & ELF_LINK_HASH_DEF_REGULAR
) != 0))
1438 && (input_section
->flags
& SEC_ALLOC
))
1440 Elf_Internal_Rela outrel
;
1441 boolean skip
, relocate
= false;
1443 /* When generating a shared object, these relocations
1444 are copied into the output file to be resolved at run
1451 name
= (bfd_elf_string_from_elf_section
1453 elf_elfheader (input_bfd
)->e_shstrndx
,
1454 elf_section_data (input_section
)->rel_hdr
.sh_name
));
1458 BFD_ASSERT (strncmp (name
, ".rela", 5) == 0
1459 && strcmp (bfd_get_section_name (input_bfd
,
1463 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1464 BFD_ASSERT (sreloc
!= NULL
);
1470 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
1472 if (outrel
.r_offset
== (bfd_vma
) -1)
1474 else if (outrel
.r_offset
== (bfd_vma
) -2)
1475 skip
= true, relocate
= true;
1476 outrel
.r_offset
+= (input_section
->output_section
->vma
1477 + input_section
->output_offset
);
1479 /* Optimize unaligned reloc usage now that we know where
1480 it finally resides. */
1484 if (outrel
.r_offset
& 1)
1485 r_type
= R_SPARC_UA16
;
1488 if (!(outrel
.r_offset
& 1))
1489 r_type
= R_SPARC_16
;
1492 if (outrel
.r_offset
& 3)
1493 r_type
= R_SPARC_UA32
;
1496 if (!(outrel
.r_offset
& 3))
1497 r_type
= R_SPARC_32
;
1502 memset (&outrel
, 0, sizeof outrel
);
1503 /* h->dynindx may be -1 if the symbol was marked to
1505 else if (h
!= NULL
&& ! is_plt
1506 && ((! info
->symbolic
&& h
->dynindx
!= -1)
1507 || (h
->elf_link_hash_flags
1508 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
1510 BFD_ASSERT (h
->dynindx
!= -1);
1511 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
1512 outrel
.r_addend
= rel
->r_addend
;
1516 if (r_type
== R_SPARC_32
)
1518 outrel
.r_info
= ELF32_R_INFO (0, R_SPARC_RELATIVE
);
1519 outrel
.r_addend
= relocation
+ rel
->r_addend
;
1528 sec
= local_sections
[r_symndx
];
1531 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
1533 == bfd_link_hash_defweak
));
1534 sec
= h
->root
.u
.def
.section
;
1536 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
1538 else if (sec
== NULL
|| sec
->owner
== NULL
)
1540 bfd_set_error (bfd_error_bad_value
);
1547 osec
= sec
->output_section
;
1548 indx
= elf_section_data (osec
)->dynindx
;
1550 /* FIXME: we really should be able to link non-pic
1551 shared libraries. */
1555 (*_bfd_error_handler
)
1556 (_("%s: probably compiled without -fPIC?"),
1557 bfd_archive_filename (input_bfd
));
1558 bfd_set_error (bfd_error_bad_value
);
1563 outrel
.r_info
= ELF32_R_INFO (indx
, r_type
);
1564 outrel
.r_addend
= relocation
+ rel
->r_addend
;
1568 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
,
1569 (((Elf32_External_Rela
*)
1571 + sreloc
->reloc_count
));
1572 ++sreloc
->reloc_count
;
1574 /* This reloc will be computed at runtime, so there's no
1575 need to do anything now. */
1585 r
= bfd_reloc_continue
;
1586 if (r_type
== R_SPARC_WDISP16
)
1590 relocation
+= rel
->r_addend
;
1591 relocation
-= (input_section
->output_section
->vma
1592 + input_section
->output_offset
);
1593 relocation
-= rel
->r_offset
;
1595 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
1596 x
|= ((((relocation
>> 2) & 0xc000) << 6)
1597 | ((relocation
>> 2) & 0x3fff));
1598 bfd_put_32 (input_bfd
, x
, contents
+ rel
->r_offset
);
1600 if ((bfd_signed_vma
) relocation
< - 0x40000
1601 || (bfd_signed_vma
) relocation
> 0x3ffff)
1602 r
= bfd_reloc_overflow
;
1606 else if (r_type
== R_SPARC_REV32
)
1610 relocation
= relocation
+ rel
->r_addend
;
1612 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
1614 bfd_putl32 (/*input_bfd,*/ x
, contents
+ rel
->r_offset
);
1617 else if ((r_type
== R_SPARC_WDISP30
|| r_type
== R_SPARC_WPLT30
)
1618 && SEC_DO_RELAX (input_section
)
1619 && rel
->r_offset
+ 4 < input_section
->_raw_size
)
1623 #define XCC (2 << 20)
1624 #define COND(x) (((x)&0xf)<<25)
1625 #define CONDA COND(0x8)
1626 #define INSN_BPA (F2(0,1) | CONDA | BPRED | XCC)
1627 #define INSN_BA (F2(0,2) | CONDA)
1628 #define INSN_OR F3(2, 0x2, 0)
1629 #define INSN_NOP F2(0,4)
1633 /* If the instruction is a call with either:
1635 arithmetic instruction with rd == %o7
1636 where rs1 != %o7 and rs2 if it is register != %o7
1637 then we can optimize if the call destination is near
1638 by changing the call into a branch always. */
1639 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
1640 y
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
1641 if ((x
& OP(~0)) == OP(1) && (y
& OP(~0)) == OP(2))
1643 if (((y
& OP3(~0)) == OP3(0x3d) /* restore */
1644 || ((y
& OP3(0x28)) == 0 /* arithmetic */
1645 && (y
& RD(~0)) == RD(O7
)))
1646 && (y
& RS1(~0)) != RS1(O7
)
1648 || (y
& RS2(~0)) != RS2(O7
)))
1652 reloc
= relocation
+ rel
->r_addend
- rel
->r_offset
;
1653 reloc
-= (input_section
->output_section
->vma
1654 + input_section
->output_offset
);
1656 /* Ensure the reloc fits into simm22. */
1657 if ((reloc
& 3) == 0
1658 && ((reloc
& ~(bfd_vma
)0x7fffff) == 0
1659 || ((reloc
| 0x7fffff) == ~(bfd_vma
)0)))
1663 /* Check whether it fits into simm19 on v9. */
1664 if (((reloc
& 0x3c0000) == 0
1665 || (reloc
& 0x3c0000) == 0x3c0000)
1666 && (elf_elfheader (output_bfd
)->e_flags
& EF_SPARC_32PLUS
))
1667 x
= INSN_BPA
| (reloc
& 0x7ffff); /* ba,pt %xcc */
1669 x
= INSN_BA
| (reloc
& 0x3fffff); /* ba */
1670 bfd_put_32 (input_bfd
, x
, contents
+ rel
->r_offset
);
1672 if (rel
->r_offset
>= 4
1673 && (y
& (0xffffffff ^ RS1(~0)))
1674 == (INSN_OR
| RD(O7
) | RS2(G0
)))
1679 z
= bfd_get_32 (input_bfd
,
1680 contents
+ rel
->r_offset
- 4);
1681 if ((z
& (0xffffffff ^ RD(~0)))
1682 != (INSN_OR
| RS1(O7
) | RS2(G0
)))
1690 If call foo was replaced with ba, replace
1691 or %rN, %g0, %o7 with nop. */
1693 reg
= (y
& RS1(~0)) >> 14;
1694 if (reg
!= ((z
& RD(~0)) >> 25)
1695 || reg
== G0
|| reg
== O7
)
1698 bfd_put_32 (input_bfd
, (bfd_vma
) INSN_NOP
,
1699 contents
+ rel
->r_offset
+ 4);
1707 if (r
== bfd_reloc_continue
)
1708 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1709 contents
, rel
->r_offset
,
1710 relocation
, rel
->r_addend
);
1712 if (r
!= bfd_reloc_ok
)
1717 case bfd_reloc_outofrange
:
1719 case bfd_reloc_overflow
:
1724 name
= h
->root
.root
.string
;
1727 name
= bfd_elf_string_from_elf_section (input_bfd
,
1728 symtab_hdr
->sh_link
,
1733 name
= bfd_section_name (input_bfd
, sec
);
1735 if (! ((*info
->callbacks
->reloc_overflow
)
1736 (info
, name
, howto
->name
, (bfd_vma
) 0,
1737 input_bfd
, input_section
, rel
->r_offset
)))
1748 /* Finish up dynamic symbol handling. We set the contents of various
1749 dynamic sections here. */
1752 elf32_sparc_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
1754 struct bfd_link_info
*info
;
1755 struct elf_link_hash_entry
*h
;
1756 Elf_Internal_Sym
*sym
;
1760 dynobj
= elf_hash_table (info
)->dynobj
;
1762 if (h
->plt
.offset
!= (bfd_vma
) -1)
1766 Elf_Internal_Rela rela
;
1768 /* This symbol has an entry in the procedure linkage table. Set
1771 BFD_ASSERT (h
->dynindx
!= -1);
1773 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1774 srela
= bfd_get_section_by_name (dynobj
, ".rela.plt");
1775 BFD_ASSERT (splt
!= NULL
&& srela
!= NULL
);
1777 /* Fill in the entry in the procedure linkage table. */
1778 bfd_put_32 (output_bfd
,
1779 PLT_ENTRY_WORD0
+ h
->plt
.offset
,
1780 splt
->contents
+ h
->plt
.offset
);
1781 bfd_put_32 (output_bfd
,
1783 + (((- (h
->plt
.offset
+ 4)) >> 2) & 0x3fffff)),
1784 splt
->contents
+ h
->plt
.offset
+ 4);
1785 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_ENTRY_WORD2
,
1786 splt
->contents
+ h
->plt
.offset
+ 8);
1788 /* Fill in the entry in the .rela.plt section. */
1789 rela
.r_offset
= (splt
->output_section
->vma
1790 + splt
->output_offset
1792 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SPARC_JMP_SLOT
);
1794 bfd_elf32_swap_reloca_out (output_bfd
, &rela
,
1795 ((Elf32_External_Rela
*) srela
->contents
1796 + h
->plt
.offset
/ PLT_ENTRY_SIZE
- 4));
1798 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1800 /* Mark the symbol as undefined, rather than as defined in
1801 the .plt section. Leave the value alone. */
1802 sym
->st_shndx
= SHN_UNDEF
;
1803 /* If the symbol is weak, we do need to clear the value.
1804 Otherwise, the PLT entry would provide a definition for
1805 the symbol even if the symbol wasn't defined anywhere,
1806 and so the symbol would never be NULL. */
1807 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR_NONWEAK
)
1813 if (h
->got
.offset
!= (bfd_vma
) -1)
1817 Elf_Internal_Rela rela
;
1819 /* This symbol has an entry in the global offset table. Set it
1822 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1823 srela
= bfd_get_section_by_name (dynobj
, ".rela.got");
1824 BFD_ASSERT (sgot
!= NULL
&& srela
!= NULL
);
1826 rela
.r_offset
= (sgot
->output_section
->vma
1827 + sgot
->output_offset
1828 + (h
->got
.offset
&~ (bfd_vma
) 1));
1830 /* If this is a -Bsymbolic link, and the symbol is defined
1831 locally, we just want to emit a RELATIVE reloc. Likewise if
1832 the symbol was forced to be local because of a version file.
1833 The entry in the global offset table will already have been
1834 initialized in the relocate_section function. */
1836 && (info
->symbolic
|| h
->dynindx
== -1)
1837 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
1838 rela
.r_info
= ELF32_R_INFO (0, R_SPARC_RELATIVE
);
1841 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
1842 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SPARC_GLOB_DAT
);
1846 bfd_elf32_swap_reloca_out (output_bfd
, &rela
,
1847 ((Elf32_External_Rela
*) srela
->contents
1848 + srela
->reloc_count
));
1849 ++srela
->reloc_count
;
1852 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
1855 Elf_Internal_Rela rela
;
1857 /* This symbols needs a copy reloc. Set it up. */
1859 BFD_ASSERT (h
->dynindx
!= -1);
1861 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
1863 BFD_ASSERT (s
!= NULL
);
1865 rela
.r_offset
= (h
->root
.u
.def
.value
1866 + h
->root
.u
.def
.section
->output_section
->vma
1867 + h
->root
.u
.def
.section
->output_offset
);
1868 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SPARC_COPY
);
1870 bfd_elf32_swap_reloca_out (output_bfd
, &rela
,
1871 ((Elf32_External_Rela
*) s
->contents
1876 /* Mark some specially defined symbols as absolute. */
1877 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
1878 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0
1879 || strcmp (h
->root
.root
.string
, "_PROCEDURE_LINKAGE_TABLE_") == 0)
1880 sym
->st_shndx
= SHN_ABS
;
1885 /* Finish up the dynamic sections. */
1888 elf32_sparc_finish_dynamic_sections (output_bfd
, info
)
1890 struct bfd_link_info
*info
;
1896 dynobj
= elf_hash_table (info
)->dynobj
;
1898 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
1900 if (elf_hash_table (info
)->dynamic_sections_created
)
1903 Elf32_External_Dyn
*dyncon
, *dynconend
;
1905 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1906 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
1908 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
1909 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
1910 for (; dyncon
< dynconend
; dyncon
++)
1912 Elf_Internal_Dyn dyn
;
1916 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
1920 case DT_PLTGOT
: name
= ".plt"; size
= false; break;
1921 case DT_PLTRELSZ
: name
= ".rela.plt"; size
= true; break;
1922 case DT_JMPREL
: name
= ".rela.plt"; size
= false; break;
1923 default: name
= NULL
; size
= false; break;
1930 s
= bfd_get_section_by_name (output_bfd
, name
);
1936 dyn
.d_un
.d_ptr
= s
->vma
;
1939 if (s
->_cooked_size
!= 0)
1940 dyn
.d_un
.d_val
= s
->_cooked_size
;
1942 dyn
.d_un
.d_val
= s
->_raw_size
;
1945 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
1949 /* Clear the first four entries in the procedure linkage table,
1950 and put a nop in the last four bytes. */
1951 if (splt
->_raw_size
> 0)
1953 memset (splt
->contents
, 0, 4 * PLT_ENTRY_SIZE
);
1954 bfd_put_32 (output_bfd
, (bfd_vma
) SPARC_NOP
,
1955 splt
->contents
+ splt
->_raw_size
- 4);
1958 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
=
1962 /* Set the first entry in the global offset table to the address of
1963 the dynamic section. */
1964 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1965 BFD_ASSERT (sgot
!= NULL
);
1966 if (sgot
->_raw_size
> 0)
1969 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
1971 bfd_put_32 (output_bfd
,
1972 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
1976 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
1981 /* Functions for dealing with the e_flags field.
1983 We don't define set_private_flags or copy_private_bfd_data because
1984 the only currently defined values are based on the bfd mach number,
1985 so we use the latter instead and defer setting e_flags until the
1986 file is written out. */
1988 /* Merge backend specific data from an object file to the output
1989 object file when linking. */
1992 elf32_sparc_merge_private_bfd_data (ibfd
, obfd
)
1997 /* FIXME: This should not be static. */
1998 static unsigned long previous_ibfd_e_flags
= (unsigned long) -1;
2000 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2001 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2006 if (bfd_get_mach (ibfd
) >= bfd_mach_sparc_v9
)
2009 (*_bfd_error_handler
)
2010 (_("%s: compiled for a 64 bit system and target is 32 bit"),
2011 bfd_archive_filename (ibfd
));
2013 else if ((ibfd
->flags
& DYNAMIC
) == 0)
2015 if (bfd_get_mach (obfd
) < bfd_get_mach (ibfd
))
2016 bfd_set_arch_mach (obfd
, bfd_arch_sparc
, bfd_get_mach (ibfd
));
2019 if (((elf_elfheader (ibfd
)->e_flags
& EF_SPARC_LEDATA
)
2020 != previous_ibfd_e_flags
)
2021 && previous_ibfd_e_flags
!= (unsigned long) -1)
2023 (*_bfd_error_handler
)
2024 (_("%s: linking little endian files with big endian files"),
2025 bfd_archive_filename (ibfd
));
2028 previous_ibfd_e_flags
= elf_elfheader (ibfd
)->e_flags
& EF_SPARC_LEDATA
;
2032 bfd_set_error (bfd_error_bad_value
);
2039 /* Set the right machine number. */
2042 elf32_sparc_object_p (abfd
)
2045 if (elf_elfheader (abfd
)->e_machine
== EM_SPARC32PLUS
)
2047 if (elf_elfheader (abfd
)->e_flags
& EF_SPARC_SUN_US3
)
2048 return bfd_default_set_arch_mach (abfd
, bfd_arch_sparc
,
2049 bfd_mach_sparc_v8plusb
);
2050 else if (elf_elfheader (abfd
)->e_flags
& EF_SPARC_SUN_US1
)
2051 return bfd_default_set_arch_mach (abfd
, bfd_arch_sparc
,
2052 bfd_mach_sparc_v8plusa
);
2053 else if (elf_elfheader (abfd
)->e_flags
& EF_SPARC_32PLUS
)
2054 return bfd_default_set_arch_mach (abfd
, bfd_arch_sparc
,
2055 bfd_mach_sparc_v8plus
);
2059 else if (elf_elfheader (abfd
)->e_flags
& EF_SPARC_LEDATA
)
2060 return bfd_default_set_arch_mach (abfd
, bfd_arch_sparc
,
2061 bfd_mach_sparc_sparclite_le
);
2063 return bfd_default_set_arch_mach (abfd
, bfd_arch_sparc
, bfd_mach_sparc
);
2066 /* The final processing done just before writing out the object file.
2067 We need to set the e_machine field appropriately. */
2070 elf32_sparc_final_write_processing (abfd
, linker
)
2072 boolean linker ATTRIBUTE_UNUSED
;
2074 switch (bfd_get_mach (abfd
))
2076 case bfd_mach_sparc
:
2077 break; /* nothing to do */
2078 case bfd_mach_sparc_v8plus
:
2079 elf_elfheader (abfd
)->e_machine
= EM_SPARC32PLUS
;
2080 elf_elfheader (abfd
)->e_flags
&=~ EF_SPARC_32PLUS_MASK
;
2081 elf_elfheader (abfd
)->e_flags
|= EF_SPARC_32PLUS
;
2083 case bfd_mach_sparc_v8plusa
:
2084 elf_elfheader (abfd
)->e_machine
= EM_SPARC32PLUS
;
2085 elf_elfheader (abfd
)->e_flags
&=~ EF_SPARC_32PLUS_MASK
;
2086 elf_elfheader (abfd
)->e_flags
|= EF_SPARC_32PLUS
| EF_SPARC_SUN_US1
;
2088 case bfd_mach_sparc_v8plusb
:
2089 elf_elfheader (abfd
)->e_machine
= EM_SPARC32PLUS
;
2090 elf_elfheader (abfd
)->e_flags
&=~ EF_SPARC_32PLUS_MASK
;
2091 elf_elfheader (abfd
)->e_flags
|= EF_SPARC_32PLUS
| EF_SPARC_SUN_US1
2094 case bfd_mach_sparc_sparclite_le
:
2095 elf_elfheader (abfd
)->e_machine
= EM_SPARC
;
2096 elf_elfheader (abfd
)->e_flags
|= EF_SPARC_LEDATA
;
2104 static enum elf_reloc_type_class
2105 elf32_sparc_reloc_type_class (rela
)
2106 const Elf_Internal_Rela
*rela
;
2108 switch ((int) ELF32_R_TYPE (rela
->r_info
))
2110 case R_SPARC_RELATIVE
:
2111 return reloc_class_relative
;
2112 case R_SPARC_JMP_SLOT
:
2113 return reloc_class_plt
;
2115 return reloc_class_copy
;
2117 return reloc_class_normal
;
2121 #define TARGET_BIG_SYM bfd_elf32_sparc_vec
2122 #define TARGET_BIG_NAME "elf32-sparc"
2123 #define ELF_ARCH bfd_arch_sparc
2124 #define ELF_MACHINE_CODE EM_SPARC
2125 #define ELF_MACHINE_ALT1 EM_SPARC32PLUS
2126 #define ELF_MAXPAGESIZE 0x10000
2128 #define bfd_elf32_bfd_reloc_type_lookup elf32_sparc_reloc_type_lookup
2129 #define bfd_elf32_bfd_relax_section elf32_sparc_relax_section
2130 #define elf_info_to_howto elf32_sparc_info_to_howto
2131 #define elf_backend_create_dynamic_sections \
2132 _bfd_elf_create_dynamic_sections
2133 #define elf_backend_check_relocs elf32_sparc_check_relocs
2134 #define elf_backend_adjust_dynamic_symbol \
2135 elf32_sparc_adjust_dynamic_symbol
2136 #define elf_backend_size_dynamic_sections \
2137 elf32_sparc_size_dynamic_sections
2138 #define elf_backend_relocate_section elf32_sparc_relocate_section
2139 #define elf_backend_finish_dynamic_symbol \
2140 elf32_sparc_finish_dynamic_symbol
2141 #define elf_backend_finish_dynamic_sections \
2142 elf32_sparc_finish_dynamic_sections
2143 #define bfd_elf32_bfd_merge_private_bfd_data \
2144 elf32_sparc_merge_private_bfd_data
2145 #define elf_backend_object_p elf32_sparc_object_p
2146 #define elf_backend_final_write_processing \
2147 elf32_sparc_final_write_processing
2148 #define elf_backend_gc_mark_hook elf32_sparc_gc_mark_hook
2149 #define elf_backend_gc_sweep_hook elf32_sparc_gc_sweep_hook
2150 #define elf_backend_reloc_type_class elf32_sparc_reloc_type_class
2152 #define elf_backend_can_gc_sections 1
2153 #define elf_backend_want_got_plt 0
2154 #define elf_backend_plt_readonly 0
2155 #define elf_backend_want_plt_sym 1
2156 #define elf_backend_got_header_size 4
2157 #define elf_backend_plt_header_size (4*PLT_ENTRY_SIZE)
2159 #include "elf32-target.h"