1 /* SPARC-specific support for 32-bit ELF
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003 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 bfd_boolean elf32_sparc_check_relocs
34 PARAMS ((bfd *, struct bfd_link_info *, asection *,
35 const Elf_Internal_Rela *));
36 static bfd_boolean elf32_sparc_adjust_dynamic_symbol
37 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
38 static bfd_boolean allocate_dynrelocs
39 PARAMS ((struct elf_link_hash_entry *, PTR));
40 static bfd_boolean readonly_dynrelocs
41 PARAMS ((struct elf_link_hash_entry *, PTR));
42 static bfd_boolean elf32_sparc_size_dynamic_sections
43 PARAMS ((bfd *, struct bfd_link_info *));
44 static bfd_boolean elf32_sparc_new_section_hook
45 PARAMS ((bfd *, asection *));
46 static bfd_boolean elf32_sparc_relax_section
47 PARAMS ((bfd *, asection *, struct bfd_link_info *, bfd_boolean *));
48 static bfd_vma dtpoff_base
49 PARAMS ((struct bfd_link_info *));
51 PARAMS ((struct bfd_link_info *, bfd_vma));
52 static bfd_boolean elf32_sparc_relocate_section
53 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
54 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
55 static bfd_boolean elf32_sparc_finish_dynamic_symbol
56 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
58 static bfd_boolean elf32_sparc_finish_dynamic_sections
59 PARAMS ((bfd *, struct bfd_link_info *));
60 static bfd_boolean elf32_sparc_merge_private_bfd_data
61 PARAMS ((bfd *, bfd *));
62 static struct bfd_hash_entry *link_hash_newfunc
63 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
64 static struct bfd_link_hash_table *elf32_sparc_link_hash_table_create
66 static bfd_boolean create_got_section
67 PARAMS ((bfd *, struct bfd_link_info *));
68 static bfd_boolean elf32_sparc_create_dynamic_sections
69 PARAMS ((bfd *, struct bfd_link_info *));
70 static void elf32_sparc_copy_indirect_symbol
71 PARAMS ((const struct elf_backend_data *, struct elf_link_hash_entry *,
72 struct elf_link_hash_entry *));
73 static int elf32_sparc_tls_transition
74 PARAMS ((struct bfd_link_info *, bfd *, int, int));
76 static bfd_boolean elf32_sparc_mkobject
78 static bfd_boolean elf32_sparc_object_p
80 static void elf32_sparc_final_write_processing
81 PARAMS ((bfd *, bfd_boolean));
82 static enum elf_reloc_type_class elf32_sparc_reloc_type_class
83 PARAMS ((const Elf_Internal_Rela *));
84 static asection * elf32_sparc_gc_mark_hook
85 PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
86 struct elf_link_hash_entry *, Elf_Internal_Sym *));
87 static bfd_boolean elf32_sparc_gc_sweep_hook
88 PARAMS ((bfd *, struct bfd_link_info *, asection *,
89 const Elf_Internal_Rela *));
91 /* The relocation "howto" table. */
93 static bfd_reloc_status_type sparc_elf_notsupported_reloc
94 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
95 static bfd_reloc_status_type sparc_elf_wdisp16_reloc
96 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
97 static bfd_reloc_status_type sparc_elf_hix22_reloc
98 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
99 static bfd_reloc_status_type sparc_elf_lox10_reloc
100 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
102 reloc_howto_type _bfd_sparc_elf_howto_table[] =
104 HOWTO(R_SPARC_NONE, 0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", FALSE,0,0x00000000,TRUE),
105 HOWTO(R_SPARC_8, 0,0, 8,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_8", FALSE,0,0x000000ff,TRUE),
106 HOWTO(R_SPARC_16, 0,1,16,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_16", FALSE,0,0x0000ffff,TRUE),
107 HOWTO(R_SPARC_32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_32", FALSE,0,0xffffffff,TRUE),
108 HOWTO(R_SPARC_DISP8, 0,0, 8,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP8", FALSE,0,0x000000ff,TRUE),
109 HOWTO(R_SPARC_DISP16, 0,1,16,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP16", FALSE,0,0x0000ffff,TRUE),
110 HOWTO(R_SPARC_DISP32, 0,2,32,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP32", FALSE,0,0xffffffff,TRUE),
111 HOWTO(R_SPARC_WDISP30, 2,2,30,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP30", FALSE,0,0x3fffffff,TRUE),
112 HOWTO(R_SPARC_WDISP22, 2,2,22,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP22", FALSE,0,0x003fffff,TRUE),
113 HOWTO(R_SPARC_HI22, 10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_HI22", FALSE,0,0x003fffff,TRUE),
114 HOWTO(R_SPARC_22, 0,2,22,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_22", FALSE,0,0x003fffff,TRUE),
115 HOWTO(R_SPARC_13, 0,2,13,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_13", FALSE,0,0x00001fff,TRUE),
116 HOWTO(R_SPARC_LO10, 0,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_LO10", FALSE,0,0x000003ff,TRUE),
117 HOWTO(R_SPARC_GOT10, 0,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOT10", FALSE,0,0x000003ff,TRUE),
118 HOWTO(R_SPARC_GOT13, 0,2,13,FALSE,0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_GOT13", FALSE,0,0x00001fff,TRUE),
119 HOWTO(R_SPARC_GOT22, 10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOT22", FALSE,0,0x003fffff,TRUE),
120 HOWTO(R_SPARC_PC10, 0,2,10,TRUE, 0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_PC10", FALSE,0,0x000003ff,TRUE),
121 HOWTO(R_SPARC_PC22, 10,2,22,TRUE, 0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_PC22", FALSE,0,0x003fffff,TRUE),
122 HOWTO(R_SPARC_WPLT30, 2,2,30,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WPLT30", FALSE,0,0x3fffffff,TRUE),
123 HOWTO(R_SPARC_COPY, 0,0,00,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_COPY", FALSE,0,0x00000000,TRUE),
124 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),
125 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),
126 HOWTO(R_SPARC_RELATIVE, 0,0,00,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_RELATIVE",FALSE,0,0x00000000,TRUE),
127 HOWTO(R_SPARC_UA32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA32", FALSE,0,0xffffffff,TRUE),
128 HOWTO(R_SPARC_PLT32, 0,0,00,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_PLT32", FALSE,0,0xffffffff,TRUE),
129 HOWTO(R_SPARC_HIPLT22, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_HIPLT22", FALSE,0,0x00000000,TRUE),
130 HOWTO(R_SPARC_LOPLT10, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_LOPLT10", FALSE,0,0x00000000,TRUE),
131 HOWTO(R_SPARC_PCPLT32, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_PCPLT32", FALSE,0,0x00000000,TRUE),
132 HOWTO(R_SPARC_PCPLT22, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_PCPLT22", FALSE,0,0x00000000,TRUE),
133 HOWTO(R_SPARC_PCPLT10, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_PCPLT10", FALSE,0,0x00000000,TRUE),
134 HOWTO(R_SPARC_10, 0,2,10,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_10", FALSE,0,0x000003ff,TRUE),
135 HOWTO(R_SPARC_11, 0,2,11,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_11", FALSE,0,0x000007ff,TRUE),
136 /* These are for sparc64 in a 64 bit environment.
137 Values need to be here because the table is indexed by reloc number. */
138 HOWTO(R_SPARC_64, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_64", FALSE,0,0x00000000,TRUE),
139 HOWTO(R_SPARC_OLO10, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_OLO10", FALSE,0,0x00000000,TRUE),
140 HOWTO(R_SPARC_HH22, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_HH22", FALSE,0,0x00000000,TRUE),
141 HOWTO(R_SPARC_HM10, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_HM10", FALSE,0,0x00000000,TRUE),
142 HOWTO(R_SPARC_LM22, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_LM22", FALSE,0,0x00000000,TRUE),
143 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),
144 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),
145 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),
146 /* End sparc64 in 64 bit environment values.
147 The following are for sparc64 in a 32 bit environment. */
148 HOWTO(R_SPARC_WDISP16, 2,2,16,TRUE, 0,complain_overflow_signed, sparc_elf_wdisp16_reloc,"R_SPARC_WDISP16", FALSE,0,0x00000000,TRUE),
149 HOWTO(R_SPARC_WDISP19, 2,2,19,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP19", FALSE,0,0x0007ffff,TRUE),
150 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),
151 HOWTO(R_SPARC_7, 0,2, 7,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_7", FALSE,0,0x0000007f,TRUE),
152 HOWTO(R_SPARC_5, 0,2, 5,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_5", FALSE,0,0x0000001f,TRUE),
153 HOWTO(R_SPARC_6, 0,2, 6,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_6", FALSE,0,0x0000003f,TRUE),
154 HOWTO(R_SPARC_NONE, 0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", FALSE,0,0x00000000,TRUE),
155 HOWTO(R_SPARC_NONE, 0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", FALSE,0,0x00000000,TRUE),
156 HOWTO(R_SPARC_NONE, 0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", FALSE,0,0x00000000,TRUE),
157 HOWTO(R_SPARC_NONE, 0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", FALSE,0,0x00000000,TRUE),
158 HOWTO(R_SPARC_NONE, 0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", FALSE,0,0x00000000,TRUE),
159 HOWTO(R_SPARC_NONE, 0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", FALSE,0,0x00000000,TRUE),
160 HOWTO(R_SPARC_NONE, 0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", FALSE,0,0x00000000,TRUE),
161 HOWTO(R_SPARC_NONE, 0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", FALSE,0,0x00000000,TRUE),
162 HOWTO(R_SPARC_UA64, 0,0, 0,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_UA64", FALSE,0,0x00000000,TRUE),
163 HOWTO(R_SPARC_UA16, 0,1,16,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA16", FALSE,0,0x0000ffff,TRUE),
164 HOWTO(R_SPARC_TLS_GD_HI22,10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_GD_HI22",FALSE,0,0x003fffff,TRUE),
165 HOWTO(R_SPARC_TLS_GD_LO10,0,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_GD_LO10",FALSE,0,0x000003ff,TRUE),
166 HOWTO(R_SPARC_TLS_GD_ADD,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_GD_ADD",FALSE,0,0x00000000,TRUE),
167 HOWTO(R_SPARC_TLS_GD_CALL,2,2,30,TRUE,0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_TLS_GD_CALL",FALSE,0,0x3fffffff,TRUE),
168 HOWTO(R_SPARC_TLS_LDM_HI22,10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_LDM_HI22",FALSE,0,0x003fffff,TRUE),
169 HOWTO(R_SPARC_TLS_LDM_LO10,0,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_LDM_LO10",FALSE,0,0x000003ff,TRUE),
170 HOWTO(R_SPARC_TLS_LDM_ADD,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_LDM_ADD",FALSE,0,0x00000000,TRUE),
171 HOWTO(R_SPARC_TLS_LDM_CALL,2,2,30,TRUE,0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_TLS_LDM_CALL",FALSE,0,0x3fffffff,TRUE),
172 HOWTO(R_SPARC_TLS_LDO_HIX22,0,2,0,FALSE,0,complain_overflow_bitfield,sparc_elf_hix22_reloc,"R_SPARC_TLS_LDO_HIX22",FALSE,0,0x003fffff, FALSE),
173 HOWTO(R_SPARC_TLS_LDO_LOX10,0,2,0,FALSE,0,complain_overflow_dont, sparc_elf_lox10_reloc, "R_SPARC_TLS_LDO_LOX10",FALSE,0,0x000003ff, FALSE),
174 HOWTO(R_SPARC_TLS_LDO_ADD,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_LDO_ADD",FALSE,0,0x00000000,TRUE),
175 HOWTO(R_SPARC_TLS_IE_HI22,10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_IE_HI22",FALSE,0,0x003fffff,TRUE),
176 HOWTO(R_SPARC_TLS_IE_LO10,0,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_IE_LO10",FALSE,0,0x000003ff,TRUE),
177 HOWTO(R_SPARC_TLS_IE_LD,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_IE_LD",FALSE,0,0x00000000,TRUE),
178 HOWTO(R_SPARC_TLS_IE_LDX,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_IE_LDX",FALSE,0,0x00000000,TRUE),
179 HOWTO(R_SPARC_TLS_IE_ADD,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_IE_ADD",FALSE,0,0x00000000,TRUE),
180 HOWTO(R_SPARC_TLS_LE_HIX22,0,2,0,FALSE,0,complain_overflow_bitfield,sparc_elf_hix22_reloc, "R_SPARC_TLS_LE_HIX22",FALSE,0,0x003fffff, FALSE),
181 HOWTO(R_SPARC_TLS_LE_LOX10,0,2,0,FALSE,0,complain_overflow_dont, sparc_elf_lox10_reloc, "R_SPARC_TLS_LE_LOX10",FALSE,0,0x000003ff, FALSE),
182 HOWTO(R_SPARC_TLS_DTPMOD32,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_DTPMOD32",FALSE,0,0x00000000,TRUE),
183 HOWTO(R_SPARC_TLS_DTPMOD64,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_DTPMOD64",FALSE,0,0x00000000,TRUE),
184 HOWTO(R_SPARC_TLS_DTPOFF32,0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,"R_SPARC_TLS_DTPOFF32",FALSE,0,0xffffffff,TRUE),
185 HOWTO(R_SPARC_TLS_DTPOFF64,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_DTPOFF64",FALSE,0,0x00000000,TRUE),
186 HOWTO(R_SPARC_TLS_TPOFF32,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_TPOFF32",FALSE,0,0x00000000,TRUE),
187 HOWTO(R_SPARC_TLS_TPOFF64,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_TPOFF64",FALSE,0,0x00000000,TRUE)
189 static reloc_howto_type elf32_sparc_vtinherit_howto =
190 HOWTO (R_SPARC_GNU_VTINHERIT, 0,2,0,FALSE,0,complain_overflow_dont, NULL, "R_SPARC_GNU_VTINHERIT", FALSE,0, 0, FALSE);
191 static reloc_howto_type elf32_sparc_vtentry_howto =
192 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);
193 static reloc_howto_type elf32_sparc_rev32_howto =
194 HOWTO(R_SPARC_REV32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_REV32", FALSE,0,0xffffffff,TRUE);
196 struct elf_reloc_map {
197 bfd_reloc_code_real_type bfd_reloc_val;
198 unsigned char elf_reloc_val;
201 static const struct elf_reloc_map sparc_reloc_map[] =
203 { BFD_RELOC_NONE, R_SPARC_NONE, },
204 { BFD_RELOC_16, R_SPARC_16, },
205 { BFD_RELOC_16_PCREL, R_SPARC_DISP16 },
206 { BFD_RELOC_8, R_SPARC_8 },
207 { BFD_RELOC_8_PCREL, R_SPARC_DISP8 },
208 { BFD_RELOC_CTOR, R_SPARC_32 },
209 { BFD_RELOC_32, R_SPARC_32 },
210 { BFD_RELOC_32_PCREL, R_SPARC_DISP32 },
211 { BFD_RELOC_HI22, R_SPARC_HI22 },
212 { BFD_RELOC_LO10, R_SPARC_LO10, },
213 { BFD_RELOC_32_PCREL_S2, R_SPARC_WDISP30 },
214 { BFD_RELOC_SPARC_PLT32, R_SPARC_PLT32 },
215 { BFD_RELOC_SPARC22, R_SPARC_22 },
216 { BFD_RELOC_SPARC13, R_SPARC_13 },
217 { BFD_RELOC_SPARC_GOT10, R_SPARC_GOT10 },
218 { BFD_RELOC_SPARC_GOT13, R_SPARC_GOT13 },
219 { BFD_RELOC_SPARC_GOT22, R_SPARC_GOT22 },
220 { BFD_RELOC_SPARC_PC10, R_SPARC_PC10 },
221 { BFD_RELOC_SPARC_PC22, R_SPARC_PC22 },
222 { BFD_RELOC_SPARC_WPLT30, R_SPARC_WPLT30 },
223 { BFD_RELOC_SPARC_COPY, R_SPARC_COPY },
224 { BFD_RELOC_SPARC_GLOB_DAT, R_SPARC_GLOB_DAT },
225 { BFD_RELOC_SPARC_JMP_SLOT, R_SPARC_JMP_SLOT },
226 { BFD_RELOC_SPARC_RELATIVE, R_SPARC_RELATIVE },
227 { BFD_RELOC_SPARC_WDISP22, R_SPARC_WDISP22 },
228 { BFD_RELOC_SPARC_UA16, R_SPARC_UA16 },
229 { BFD_RELOC_SPARC_UA32, R_SPARC_UA32 },
230 { BFD_RELOC_SPARC_UA64, R_SPARC_UA64 },
231 { BFD_RELOC_SPARC_10, R_SPARC_10 },
232 { BFD_RELOC_SPARC_11, R_SPARC_11 },
233 { BFD_RELOC_SPARC_64, R_SPARC_64 },
234 { BFD_RELOC_SPARC_OLO10, R_SPARC_OLO10 },
235 { BFD_RELOC_SPARC_HH22, R_SPARC_HH22 },
236 { BFD_RELOC_SPARC_HM10, R_SPARC_HM10 },
237 { BFD_RELOC_SPARC_LM22, R_SPARC_LM22 },
238 { BFD_RELOC_SPARC_PC_HH22, R_SPARC_PC_HH22 },
239 { BFD_RELOC_SPARC_PC_HM10, R_SPARC_PC_HM10 },
240 { BFD_RELOC_SPARC_PC_LM22, R_SPARC_PC_LM22 },
241 { BFD_RELOC_SPARC_WDISP16, R_SPARC_WDISP16 },
242 { BFD_RELOC_SPARC_WDISP19, R_SPARC_WDISP19 },
243 { BFD_RELOC_SPARC_7, R_SPARC_7 },
244 { BFD_RELOC_SPARC_5, R_SPARC_5 },
245 { BFD_RELOC_SPARC_6, R_SPARC_6 },
246 { BFD_RELOC_SPARC_TLS_GD_HI22, R_SPARC_TLS_GD_HI22 },
247 { BFD_RELOC_SPARC_TLS_GD_LO10, R_SPARC_TLS_GD_LO10 },
248 { BFD_RELOC_SPARC_TLS_GD_ADD, R_SPARC_TLS_GD_ADD },
249 { BFD_RELOC_SPARC_TLS_GD_CALL, R_SPARC_TLS_GD_CALL },
250 { BFD_RELOC_SPARC_TLS_LDM_HI22, R_SPARC_TLS_LDM_HI22 },
251 { BFD_RELOC_SPARC_TLS_LDM_LO10, R_SPARC_TLS_LDM_LO10 },
252 { BFD_RELOC_SPARC_TLS_LDM_ADD, R_SPARC_TLS_LDM_ADD },
253 { BFD_RELOC_SPARC_TLS_LDM_CALL, R_SPARC_TLS_LDM_CALL },
254 { BFD_RELOC_SPARC_TLS_LDO_HIX22, R_SPARC_TLS_LDO_HIX22 },
255 { BFD_RELOC_SPARC_TLS_LDO_LOX10, R_SPARC_TLS_LDO_LOX10 },
256 { BFD_RELOC_SPARC_TLS_LDO_ADD, R_SPARC_TLS_LDO_ADD },
257 { BFD_RELOC_SPARC_TLS_IE_HI22, R_SPARC_TLS_IE_HI22 },
258 { BFD_RELOC_SPARC_TLS_IE_LO10, R_SPARC_TLS_IE_LO10 },
259 { BFD_RELOC_SPARC_TLS_IE_LD, R_SPARC_TLS_IE_LD },
260 { BFD_RELOC_SPARC_TLS_IE_LDX, R_SPARC_TLS_IE_LDX },
261 { BFD_RELOC_SPARC_TLS_IE_ADD, R_SPARC_TLS_IE_ADD },
262 { BFD_RELOC_SPARC_TLS_LE_HIX22, R_SPARC_TLS_LE_HIX22 },
263 { BFD_RELOC_SPARC_TLS_LE_LOX10, R_SPARC_TLS_LE_LOX10 },
264 { BFD_RELOC_SPARC_TLS_DTPMOD32, R_SPARC_TLS_DTPMOD32 },
265 { BFD_RELOC_SPARC_TLS_DTPMOD64, R_SPARC_TLS_DTPMOD64 },
266 { BFD_RELOC_SPARC_TLS_DTPOFF32, R_SPARC_TLS_DTPOFF32 },
267 { BFD_RELOC_SPARC_TLS_DTPOFF64, R_SPARC_TLS_DTPOFF64 },
268 { BFD_RELOC_SPARC_TLS_TPOFF32, R_SPARC_TLS_TPOFF32 },
269 { BFD_RELOC_SPARC_TLS_TPOFF64, R_SPARC_TLS_TPOFF64 },
270 { BFD_RELOC_VTABLE_INHERIT, R_SPARC_GNU_VTINHERIT },
271 { BFD_RELOC_VTABLE_ENTRY, R_SPARC_GNU_VTENTRY },
272 { BFD_RELOC_SPARC_REV32, R_SPARC_REV32 }
275 static reloc_howto_type *
276 elf32_sparc_reloc_type_lookup (abfd, code)
277 bfd *abfd ATTRIBUTE_UNUSED;
278 bfd_reloc_code_real_type code;
284 case BFD_RELOC_VTABLE_INHERIT:
285 return &elf32_sparc_vtinherit_howto;
287 case BFD_RELOC_VTABLE_ENTRY:
288 return &elf32_sparc_vtentry_howto;
290 case BFD_RELOC_SPARC_REV32:
291 return &elf32_sparc_rev32_howto;
295 i < sizeof (sparc_reloc_map) / sizeof (struct elf_reloc_map);
298 if (sparc_reloc_map[i].bfd_reloc_val == code)
299 return (_bfd_sparc_elf_howto_table
300 + (int) sparc_reloc_map[i].elf_reloc_val);
303 bfd_set_error (bfd_error_bad_value);
307 /* We need to use ELF32_R_TYPE so we have our own copy of this function,
308 and elf64-sparc.c has its own copy. */
311 elf32_sparc_info_to_howto (abfd, cache_ptr, dst)
312 bfd *abfd ATTRIBUTE_UNUSED;
314 Elf_Internal_Rela *dst;
316 switch (ELF32_R_TYPE(dst->r_info))
318 case R_SPARC_GNU_VTINHERIT:
319 cache_ptr->howto = &elf32_sparc_vtinherit_howto;
322 case R_SPARC_GNU_VTENTRY:
323 cache_ptr->howto = &elf32_sparc_vtentry_howto;
327 cache_ptr->howto = &elf32_sparc_rev32_howto;
331 BFD_ASSERT (ELF32_R_TYPE(dst->r_info) < (unsigned int) R_SPARC_max_std);
332 cache_ptr->howto = &_bfd_sparc_elf_howto_table[ELF32_R_TYPE(dst->r_info)];
336 /* For unsupported relocs. */
338 static bfd_reloc_status_type
339 sparc_elf_notsupported_reloc (abfd,
346 bfd *abfd ATTRIBUTE_UNUSED;
347 arelent *reloc_entry ATTRIBUTE_UNUSED;
348 asymbol *symbol ATTRIBUTE_UNUSED;
349 PTR data ATTRIBUTE_UNUSED;
350 asection *input_section ATTRIBUTE_UNUSED;
351 bfd *output_bfd ATTRIBUTE_UNUSED;
352 char **error_message ATTRIBUTE_UNUSED;
354 return bfd_reloc_notsupported;
357 /* Handle the WDISP16 reloc. */
359 static bfd_reloc_status_type
360 sparc_elf_wdisp16_reloc (abfd,
368 arelent *reloc_entry;
371 asection *input_section;
373 char **error_message ATTRIBUTE_UNUSED;
378 if (output_bfd != (bfd *) NULL
379 && (symbol->flags & BSF_SECTION_SYM) == 0
380 && (! reloc_entry->howto->partial_inplace
381 || reloc_entry->addend == 0))
383 reloc_entry->address += input_section->output_offset;
387 if (output_bfd != NULL)
388 return bfd_reloc_continue;
390 if (reloc_entry->address > input_section->_cooked_size)
391 return bfd_reloc_outofrange;
393 relocation = (symbol->value
394 + symbol->section->output_section->vma
395 + symbol->section->output_offset);
396 relocation += reloc_entry->addend;
397 relocation -= (input_section->output_section->vma
398 + input_section->output_offset);
399 relocation -= reloc_entry->address;
401 x = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
402 x |= ((((relocation >> 2) & 0xc000) << 6)
403 | ((relocation >> 2) & 0x3fff));
404 bfd_put_32 (abfd, x, (bfd_byte *) data + reloc_entry->address);
406 if ((bfd_signed_vma) relocation < - 0x40000
407 || (bfd_signed_vma) relocation > 0x3ffff)
408 return bfd_reloc_overflow;
413 /* Handle the HIX22 reloc. */
415 static bfd_reloc_status_type
416 sparc_elf_hix22_reloc (abfd,
424 arelent *reloc_entry;
427 asection *input_section;
429 char **error_message ATTRIBUTE_UNUSED;
434 if (output_bfd != (bfd *) NULL
435 && (symbol->flags & BSF_SECTION_SYM) == 0)
437 reloc_entry->address += input_section->output_offset;
441 if (output_bfd != NULL)
442 return bfd_reloc_continue;
444 if (reloc_entry->address > input_section->_cooked_size)
445 return bfd_reloc_outofrange;
447 relocation = (symbol->value
448 + symbol->section->output_section->vma
449 + symbol->section->output_offset);
450 relocation += reloc_entry->addend;
451 insn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
453 insn = (insn &~ (bfd_vma) 0x3fffff) | (((~relocation) >> 10) & 0x3fffff);
454 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
459 /* Handle the LOX10 reloc. */
461 static bfd_reloc_status_type
462 sparc_elf_lox10_reloc (abfd,
470 arelent *reloc_entry;
473 asection *input_section;
475 char **error_message ATTRIBUTE_UNUSED;
480 if (output_bfd != (bfd *) NULL
481 && (symbol->flags & BSF_SECTION_SYM) == 0)
483 reloc_entry->address += input_section->output_offset;
487 if (output_bfd != NULL)
488 return bfd_reloc_continue;
490 if (reloc_entry->address > input_section->_cooked_size)
491 return bfd_reloc_outofrange;
493 relocation = (symbol->value
494 + symbol->section->output_section->vma
495 + symbol->section->output_offset);
496 relocation += reloc_entry->addend;
497 insn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
499 insn = (insn &~ (bfd_vma) 0x1fff) | 0x1c00 | (relocation & 0x3ff);
500 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
505 /* Functions for the SPARC ELF linker. */
507 /* The name of the dynamic interpreter. This is put in the .interp
510 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
512 /* The nop opcode we use. */
514 #define SPARC_NOP 0x01000000
516 /* The size in bytes of an entry in the procedure linkage table. */
518 #define PLT_ENTRY_SIZE 12
520 /* The first four entries in a procedure linkage table are reserved,
521 and the initial contents are unimportant (we zero them out).
522 Subsequent entries look like this. See the SVR4 ABI SPARC
523 supplement to see how this works. */
525 /* sethi %hi(.-.plt0),%g1. We fill in the address later. */
526 #define PLT_ENTRY_WORD0 0x03000000
527 /* b,a .plt0. We fill in the offset later. */
528 #define PLT_ENTRY_WORD1 0x30800000
530 #define PLT_ENTRY_WORD2 SPARC_NOP
532 /* The SPARC linker needs to keep track of the number of relocs that it
533 decides to copy as dynamic relocs in check_relocs for each symbol.
534 This is so that it can later discard them if they are found to be
535 unnecessary. We store the information in a field extending the
536 regular ELF linker hash table. */
538 struct elf32_sparc_dyn_relocs
540 struct elf32_sparc_dyn_relocs *next;
542 /* The input section of the reloc. */
545 /* Total number of relocs copied for the input section. */
548 /* Number of pc-relative relocs copied for the input section. */
549 bfd_size_type pc_count;
552 /* SPARC ELF linker hash entry. */
554 struct elf32_sparc_link_hash_entry
556 struct elf_link_hash_entry elf;
558 /* Track dynamic relocs copied for this symbol. */
559 struct elf32_sparc_dyn_relocs *dyn_relocs;
561 #define GOT_UNKNOWN 0
565 unsigned char tls_type;
568 #define elf32_sparc_hash_entry(ent) ((struct elf32_sparc_link_hash_entry *)(ent))
570 struct elf32_sparc_obj_tdata
572 struct elf_obj_tdata root;
574 /* tls_type for each local got entry. */
575 char *local_got_tls_type;
577 /* TRUE if TLS GD relocs has been seen for this object. */
578 bfd_boolean has_tlsgd;
581 #define elf32_sparc_tdata(abfd) \
582 ((struct elf32_sparc_obj_tdata *) (abfd)->tdata.any)
584 #define elf32_sparc_local_got_tls_type(abfd) \
585 (elf32_sparc_tdata (abfd)->local_got_tls_type)
588 elf32_sparc_mkobject (abfd)
591 bfd_size_type amt = sizeof (struct elf32_sparc_obj_tdata);
592 abfd->tdata.any = bfd_zalloc (abfd, amt);
593 if (abfd->tdata.any == NULL)
598 /* SPARC ELF linker hash table. */
600 struct elf32_sparc_link_hash_table
602 struct elf_link_hash_table elf;
604 /* Short-cuts to get to dynamic linker sections. */
613 bfd_signed_vma refcount;
617 /* Small local sym to section mapping cache. */
618 struct sym_sec_cache sym_sec;
621 /* Get the SPARC ELF linker hash table from a link_info structure. */
623 #define elf32_sparc_hash_table(p) \
624 ((struct elf32_sparc_link_hash_table *) ((p)->hash))
626 /* Create an entry in an i386 ELF linker hash table. */
628 static struct bfd_hash_entry *
629 link_hash_newfunc (entry, table, string)
630 struct bfd_hash_entry *entry;
631 struct bfd_hash_table *table;
634 /* Allocate the structure if it has not already been allocated by a
638 entry = bfd_hash_allocate (table,
639 sizeof (struct elf32_sparc_link_hash_entry));
644 /* Call the allocation method of the superclass. */
645 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
648 struct elf32_sparc_link_hash_entry *eh;
650 eh = (struct elf32_sparc_link_hash_entry *) entry;
651 eh->dyn_relocs = NULL;
652 eh->tls_type = GOT_UNKNOWN;
658 /* Create a SPARC ELF linker hash table. */
660 static struct bfd_link_hash_table *
661 elf32_sparc_link_hash_table_create (abfd)
664 struct elf32_sparc_link_hash_table *ret;
665 bfd_size_type amt = sizeof (struct elf32_sparc_link_hash_table);
667 ret = (struct elf32_sparc_link_hash_table *) bfd_malloc (amt);
671 if (! _bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc))
683 ret->tls_ldm_got.refcount = 0;
684 ret->sym_sec.abfd = NULL;
686 return &ret->elf.root;
689 /* Create .got and .rela.got sections in DYNOBJ, and set up
690 shortcuts to them in our hash table. */
693 create_got_section (dynobj, info)
695 struct bfd_link_info *info;
697 struct elf32_sparc_link_hash_table *htab;
699 if (! _bfd_elf_create_got_section (dynobj, info))
702 htab = elf32_sparc_hash_table (info);
703 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
707 htab->srelgot = bfd_make_section (dynobj, ".rela.got");
708 if (htab->srelgot == NULL
709 || ! bfd_set_section_flags (dynobj, htab->srelgot,
710 (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
711 | SEC_IN_MEMORY | SEC_LINKER_CREATED
713 || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
718 /* Create .plt, .rela.plt, .got, .rela.got, .dynbss, and
719 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
723 elf32_sparc_create_dynamic_sections (dynobj, info)
725 struct bfd_link_info *info;
727 struct elf32_sparc_link_hash_table *htab;
729 htab = elf32_sparc_hash_table (info);
730 if (!htab->sgot && !create_got_section (dynobj, info))
733 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
736 htab->splt = bfd_get_section_by_name (dynobj, ".plt");
737 htab->srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
738 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
740 htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss");
742 if (!htab->splt || !htab->srelplt || !htab->sdynbss
743 || (!info->shared && !htab->srelbss))
749 /* Copy the extra info we tack onto an elf_link_hash_entry. */
752 elf32_sparc_copy_indirect_symbol (bed, dir, ind)
753 const struct elf_backend_data *bed;
754 struct elf_link_hash_entry *dir, *ind;
756 struct elf32_sparc_link_hash_entry *edir, *eind;
758 edir = (struct elf32_sparc_link_hash_entry *) dir;
759 eind = (struct elf32_sparc_link_hash_entry *) ind;
761 if (eind->dyn_relocs != NULL)
763 if (edir->dyn_relocs != NULL)
765 struct elf32_sparc_dyn_relocs **pp;
766 struct elf32_sparc_dyn_relocs *p;
768 if (ind->root.type == bfd_link_hash_indirect)
771 /* Add reloc counts against the weak sym to the strong sym
772 list. Merge any entries against the same section. */
773 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
775 struct elf32_sparc_dyn_relocs *q;
777 for (q = edir->dyn_relocs; q != NULL; q = q->next)
778 if (q->sec == p->sec)
780 q->pc_count += p->pc_count;
781 q->count += p->count;
788 *pp = edir->dyn_relocs;
791 edir->dyn_relocs = eind->dyn_relocs;
792 eind->dyn_relocs = NULL;
795 if (ind->root.type == bfd_link_hash_indirect
796 && dir->got.refcount <= 0)
798 edir->tls_type = eind->tls_type;
799 eind->tls_type = GOT_UNKNOWN;
801 _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
805 elf32_sparc_tls_transition (info, abfd, r_type, is_local)
806 struct bfd_link_info *info;
811 if (r_type == R_SPARC_TLS_GD_HI22
812 && ! elf32_sparc_tdata (abfd)->has_tlsgd)
813 r_type = R_SPARC_REV32;
820 case R_SPARC_TLS_GD_HI22:
822 return R_SPARC_TLS_LE_HIX22;
823 return R_SPARC_TLS_IE_HI22;
824 case R_SPARC_TLS_GD_LO10:
826 return R_SPARC_TLS_LE_LOX10;
827 return R_SPARC_TLS_IE_LO10;
828 case R_SPARC_TLS_IE_HI22:
830 return R_SPARC_TLS_LE_HIX22;
832 case R_SPARC_TLS_IE_LO10:
834 return R_SPARC_TLS_LE_LOX10;
836 case R_SPARC_TLS_LDM_HI22:
837 return R_SPARC_TLS_LE_HIX22;
838 case R_SPARC_TLS_LDM_LO10:
839 return R_SPARC_TLS_LE_LOX10;
845 /* Look through the relocs for a section during the first phase, and
846 allocate space in the global offset table or procedure linkage
850 elf32_sparc_check_relocs (abfd, info, sec, relocs)
852 struct bfd_link_info *info;
854 const Elf_Internal_Rela *relocs;
856 struct elf32_sparc_link_hash_table *htab;
857 Elf_Internal_Shdr *symtab_hdr;
858 struct elf_link_hash_entry **sym_hashes;
859 bfd_vma *local_got_offsets;
860 const Elf_Internal_Rela *rel;
861 const Elf_Internal_Rela *rel_end;
863 bfd_boolean checked_tlsgd = FALSE;
865 if (info->relocatable)
868 htab = elf32_sparc_hash_table (info);
869 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
870 sym_hashes = elf_sym_hashes (abfd);
871 local_got_offsets = elf_local_got_offsets (abfd);
875 rel_end = relocs + sec->reloc_count;
876 for (rel = relocs; rel < rel_end; rel++)
879 unsigned long r_symndx;
880 struct elf_link_hash_entry *h;
882 r_symndx = ELF32_R_SYM (rel->r_info);
883 r_type = ELF32_R_TYPE (rel->r_info);
885 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
887 (*_bfd_error_handler) (_("%s: bad symbol index: %d"),
888 bfd_archive_filename (abfd),
893 if (r_symndx < symtab_hdr->sh_info)
896 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
898 /* Compatibility with old R_SPARC_REV32 reloc conflicting
899 with R_SPARC_TLS_GD_HI22. */
903 case R_SPARC_TLS_GD_HI22:
905 const Elf_Internal_Rela *relt;
907 for (relt = rel + 1; relt < rel_end; relt++)
908 if (ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_LO10
909 || ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_ADD
910 || ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_CALL)
912 checked_tlsgd = TRUE;
913 elf32_sparc_tdata (abfd)->has_tlsgd = relt < rel_end;
916 case R_SPARC_TLS_GD_LO10:
917 case R_SPARC_TLS_GD_ADD:
918 case R_SPARC_TLS_GD_CALL:
919 checked_tlsgd = TRUE;
920 elf32_sparc_tdata (abfd)->has_tlsgd = TRUE;
924 r_type = elf32_sparc_tls_transition (info, abfd, r_type, h == NULL);
927 case R_SPARC_TLS_LDM_HI22:
928 case R_SPARC_TLS_LDM_LO10:
929 htab->tls_ldm_got.refcount += 1;
932 case R_SPARC_TLS_LE_HIX22:
933 case R_SPARC_TLS_LE_LOX10:
938 case R_SPARC_TLS_IE_HI22:
939 case R_SPARC_TLS_IE_LO10:
941 info->flags |= DF_STATIC_TLS;
947 case R_SPARC_TLS_GD_HI22:
948 case R_SPARC_TLS_GD_LO10:
949 /* This symbol requires a global offset table entry. */
951 int tls_type, old_tls_type;
959 tls_type = GOT_NORMAL;
961 case R_SPARC_TLS_GD_HI22:
962 case R_SPARC_TLS_GD_LO10:
963 tls_type = GOT_TLS_GD;
965 case R_SPARC_TLS_IE_HI22:
966 case R_SPARC_TLS_IE_LO10:
967 tls_type = GOT_TLS_IE;
973 h->got.refcount += 1;
974 old_tls_type = elf32_sparc_hash_entry(h)->tls_type;
978 bfd_signed_vma *local_got_refcounts;
980 /* This is a global offset table entry for a local symbol. */
981 local_got_refcounts = elf_local_got_refcounts (abfd);
982 if (local_got_refcounts == NULL)
986 size = symtab_hdr->sh_info;
987 size *= (sizeof (bfd_signed_vma) + sizeof(char));
988 local_got_refcounts = ((bfd_signed_vma *)
989 bfd_zalloc (abfd, size));
990 if (local_got_refcounts == NULL)
992 elf_local_got_refcounts (abfd) = local_got_refcounts;
993 elf32_sparc_local_got_tls_type (abfd)
994 = (char *) (local_got_refcounts + symtab_hdr->sh_info);
996 local_got_refcounts[r_symndx] += 1;
997 old_tls_type = elf32_sparc_local_got_tls_type (abfd) [r_symndx];
1000 /* If a TLS symbol is accessed using IE at least once,
1001 there is no point to use dynamic model for it. */
1002 if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1003 && (old_tls_type != GOT_TLS_GD
1004 || tls_type != GOT_TLS_IE))
1006 if (old_tls_type == GOT_TLS_IE && tls_type == GOT_TLS_GD)
1007 tls_type = old_tls_type;
1010 (*_bfd_error_handler)
1011 (_("%s: `%s' accessed both as normal and thread local symbol"),
1012 bfd_archive_filename (abfd),
1013 h ? h->root.root.string : "<local>");
1018 if (old_tls_type != tls_type)
1021 elf32_sparc_hash_entry (h)->tls_type = tls_type;
1023 elf32_sparc_local_got_tls_type (abfd) [r_symndx] = tls_type;
1027 if (htab->sgot == NULL)
1029 if (htab->elf.dynobj == NULL)
1030 htab->elf.dynobj = abfd;
1031 if (!create_got_section (htab->elf.dynobj, info))
1036 case R_SPARC_TLS_GD_CALL:
1037 case R_SPARC_TLS_LDM_CALL:
1040 /* These are basically R_SPARC_TLS_WPLT30 relocs against
1042 struct bfd_link_hash_entry *bh = NULL;
1043 if (! _bfd_generic_link_add_one_symbol (info, abfd,
1044 "__tls_get_addr", 0,
1045 bfd_und_section_ptr, 0,
1049 h = (struct elf_link_hash_entry *) bh;
1056 case R_SPARC_WPLT30:
1057 /* This symbol requires a procedure linkage table entry. We
1058 actually build the entry in adjust_dynamic_symbol,
1059 because this might be a case of linking PIC code without
1060 linking in any dynamic objects, in which case we don't
1061 need to generate a procedure linkage table after all. */
1065 /* The Solaris native assembler will generate a WPLT30
1066 reloc for a local symbol if you assemble a call from
1067 one section to another when using -K pic. We treat
1069 if (ELF32_R_TYPE (rel->r_info) == R_SPARC_PLT32)
1074 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
1076 if (ELF32_R_TYPE (rel->r_info) == R_SPARC_PLT32)
1078 h->plt.refcount += 1;
1084 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
1087 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1092 case R_SPARC_DISP16:
1093 case R_SPARC_DISP32:
1094 case R_SPARC_WDISP30:
1095 case R_SPARC_WDISP22:
1096 case R_SPARC_WDISP19:
1097 case R_SPARC_WDISP16:
1108 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
1111 if (h != NULL && !info->shared)
1113 /* We may need a .plt entry if the function this reloc
1114 refers to is in a shared lib. */
1115 h->plt.refcount += 1;
1118 /* If we are creating a shared library, and this is a reloc
1119 against a global symbol, or a non PC relative reloc
1120 against a local symbol, then we need to copy the reloc
1121 into the shared library. However, if we are linking with
1122 -Bsymbolic, we do not need to copy a reloc against a
1123 global symbol which is defined in an object we are
1124 including in the link (i.e., DEF_REGULAR is set). At
1125 this point we have not seen all the input files, so it is
1126 possible that DEF_REGULAR is not set now but will be set
1127 later (it is never cleared). In case of a weak definition,
1128 DEF_REGULAR may be cleared later by a strong definition in
1129 a shared library. We account for that possibility below by
1130 storing information in the relocs_copied field of the hash
1131 table entry. A similar situation occurs when creating
1132 shared libraries and symbol visibility changes render the
1135 If on the other hand, we are creating an executable, we
1136 may need to keep relocations for symbols satisfied by a
1137 dynamic library if we manage to avoid copy relocs for the
1140 && (sec->flags & SEC_ALLOC) != 0
1141 && (! _bfd_sparc_elf_howto_table[r_type].pc_relative
1143 && (! info->symbolic
1144 || h->root.type == bfd_link_hash_defweak
1145 || (h->elf_link_hash_flags
1146 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
1148 && (sec->flags & SEC_ALLOC) != 0
1150 && (h->root.type == bfd_link_hash_defweak
1151 || (h->elf_link_hash_flags
1152 & ELF_LINK_HASH_DEF_REGULAR) == 0)))
1154 struct elf32_sparc_dyn_relocs *p;
1155 struct elf32_sparc_dyn_relocs **head;
1157 /* When creating a shared object, we must copy these
1158 relocs into the output file. We create a reloc
1159 section in dynobj and make room for the reloc. */
1165 name = (bfd_elf_string_from_elf_section
1167 elf_elfheader (abfd)->e_shstrndx,
1168 elf_section_data (sec)->rel_hdr.sh_name));
1172 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
1173 && strcmp (bfd_get_section_name (abfd, sec),
1176 if (htab->elf.dynobj == NULL)
1177 htab->elf.dynobj = abfd;
1178 dynobj = htab->elf.dynobj;
1180 sreloc = bfd_get_section_by_name (dynobj, name);
1185 sreloc = bfd_make_section (dynobj, name);
1186 flags = (SEC_HAS_CONTENTS | SEC_READONLY
1187 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1188 if ((sec->flags & SEC_ALLOC) != 0)
1189 flags |= SEC_ALLOC | SEC_LOAD;
1191 || ! bfd_set_section_flags (dynobj, sreloc, flags)
1192 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
1195 elf_section_data (sec)->sreloc = sreloc;
1198 /* If this is a global symbol, we count the number of
1199 relocations we need for this symbol. */
1201 head = &((struct elf32_sparc_link_hash_entry *) h)->dyn_relocs;
1204 /* Track dynamic relocs needed for local syms too.
1205 We really need local syms available to do this
1209 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
1214 head = ((struct elf32_sparc_dyn_relocs **)
1215 &elf_section_data (s)->local_dynrel);
1219 if (p == NULL || p->sec != sec)
1221 bfd_size_type amt = sizeof *p;
1222 p = ((struct elf32_sparc_dyn_relocs *)
1223 bfd_alloc (htab->elf.dynobj, amt));
1234 if (_bfd_sparc_elf_howto_table[r_type].pc_relative)
1240 case R_SPARC_GNU_VTINHERIT:
1241 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1245 case R_SPARC_GNU_VTENTRY:
1246 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1259 elf32_sparc_gc_mark_hook (sec, info, rel, h, sym)
1261 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1262 Elf_Internal_Rela *rel;
1263 struct elf_link_hash_entry *h;
1264 Elf_Internal_Sym *sym;
1268 switch (ELF32_R_TYPE (rel->r_info))
1270 case R_SPARC_GNU_VTINHERIT:
1271 case R_SPARC_GNU_VTENTRY:
1275 switch (h->root.type)
1277 case bfd_link_hash_defined:
1278 case bfd_link_hash_defweak:
1279 return h->root.u.def.section;
1281 case bfd_link_hash_common:
1282 return h->root.u.c.p->section;
1290 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
1295 /* Update the got entry reference counts for the section being removed. */
1297 elf32_sparc_gc_sweep_hook (abfd, info, sec, relocs)
1299 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1301 const Elf_Internal_Rela *relocs;
1303 Elf_Internal_Shdr *symtab_hdr;
1304 struct elf_link_hash_entry **sym_hashes;
1305 bfd_signed_vma *local_got_refcounts;
1306 const Elf_Internal_Rela *rel, *relend;
1308 elf_section_data (sec)->local_dynrel = NULL;
1310 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1311 sym_hashes = elf_sym_hashes (abfd);
1312 local_got_refcounts = elf_local_got_refcounts (abfd);
1314 relend = relocs + sec->reloc_count;
1315 for (rel = relocs; rel < relend; rel++)
1317 unsigned long r_symndx;
1318 unsigned int r_type;
1319 struct elf_link_hash_entry *h = NULL;
1321 r_symndx = ELF32_R_SYM (rel->r_info);
1322 if (r_symndx >= symtab_hdr->sh_info)
1324 struct elf32_sparc_link_hash_entry *eh;
1325 struct elf32_sparc_dyn_relocs **pp;
1326 struct elf32_sparc_dyn_relocs *p;
1328 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1329 eh = (struct elf32_sparc_link_hash_entry *) h;
1330 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1333 /* Everything must go for SEC. */
1339 r_type = ELF32_R_TYPE (rel->r_info);
1340 r_type = elf32_sparc_tls_transition (info, abfd, r_type, h != NULL);
1343 case R_SPARC_TLS_LDM_HI22:
1344 case R_SPARC_TLS_LDM_LO10:
1345 if (elf32_sparc_hash_table (info)->tls_ldm_got.refcount > 0)
1346 elf32_sparc_hash_table (info)->tls_ldm_got.refcount -= 1;
1349 case R_SPARC_TLS_GD_HI22:
1350 case R_SPARC_TLS_GD_LO10:
1351 case R_SPARC_TLS_IE_HI22:
1352 case R_SPARC_TLS_IE_LO10:
1358 if (h->got.refcount > 0)
1363 if (local_got_refcounts[r_symndx] > 0)
1364 local_got_refcounts[r_symndx]--;
1371 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1376 case R_SPARC_DISP16:
1377 case R_SPARC_DISP32:
1378 case R_SPARC_WDISP30:
1379 case R_SPARC_WDISP22:
1380 case R_SPARC_WDISP19:
1381 case R_SPARC_WDISP16:
1396 case R_SPARC_WPLT30:
1399 if (h->plt.refcount > 0)
1412 /* Adjust a symbol defined by a dynamic object and referenced by a
1413 regular object. The current definition is in some section of the
1414 dynamic object, but we're not including those sections. We have to
1415 change the definition to something the rest of the link can
1419 elf32_sparc_adjust_dynamic_symbol (info, h)
1420 struct bfd_link_info *info;
1421 struct elf_link_hash_entry *h;
1423 struct elf32_sparc_link_hash_table *htab;
1424 struct elf32_sparc_link_hash_entry * eh;
1425 struct elf32_sparc_dyn_relocs *p;
1427 unsigned int power_of_two;
1429 htab = elf32_sparc_hash_table (info);
1431 /* Make sure we know what is going on here. */
1432 BFD_ASSERT (htab->elf.dynobj != NULL
1433 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
1434 || h->weakdef != NULL
1435 || ((h->elf_link_hash_flags
1436 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1437 && (h->elf_link_hash_flags
1438 & ELF_LINK_HASH_REF_REGULAR) != 0
1439 && (h->elf_link_hash_flags
1440 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
1442 /* If this is a function, put it in the procedure linkage table. We
1443 will fill in the contents of the procedure linkage table later
1444 (although we could actually do it here). The STT_NOTYPE
1445 condition is a hack specifically for the Oracle libraries
1446 delivered for Solaris; for some inexplicable reason, they define
1447 some of their functions as STT_NOTYPE when they really should be
1449 if (h->type == STT_FUNC
1450 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0
1451 || (h->type == STT_NOTYPE
1452 && (h->root.type == bfd_link_hash_defined
1453 || h->root.type == bfd_link_hash_defweak)
1454 && (h->root.u.def.section->flags & SEC_CODE) != 0))
1456 if (h->plt.refcount <= 0
1458 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
1459 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0
1460 && h->root.type != bfd_link_hash_undefweak
1461 && h->root.type != bfd_link_hash_undefined))
1463 /* This case can occur if we saw a WPLT30 reloc in an input
1464 file, but the symbol was never referred to by a dynamic
1465 object, or if all references were garbage collected. In
1466 such a case, we don't actually need to build a procedure
1467 linkage table, and we can just do a WDISP30 reloc instead. */
1468 h->plt.offset = (bfd_vma) -1;
1469 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1475 h->plt.offset = (bfd_vma) -1;
1477 /* If this is a weak symbol, and there is a real definition, the
1478 processor independent code will have arranged for us to see the
1479 real definition first, and we can just use the same value. */
1480 if (h->weakdef != NULL)
1482 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
1483 || h->weakdef->root.type == bfd_link_hash_defweak);
1484 h->root.u.def.section = h->weakdef->root.u.def.section;
1485 h->root.u.def.value = h->weakdef->root.u.def.value;
1489 /* This is a reference to a symbol defined by a dynamic object which
1490 is not a function. */
1492 /* If we are creating a shared library, we must presume that the
1493 only references to the symbol are via the global offset table.
1494 For such cases we need not do anything here; the relocations will
1495 be handled correctly by relocate_section. */
1499 /* If there are no references to this symbol that do not use the
1500 GOT, we don't need to generate a copy reloc. */
1501 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
1504 eh = (struct elf32_sparc_link_hash_entry *) h;
1505 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1507 s = p->sec->output_section;
1508 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1512 /* If we didn't find any dynamic relocs in read-only sections, then
1513 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1516 h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
1520 /* We must allocate the symbol in our .dynbss section, which will
1521 become part of the .bss section of the executable. There will be
1522 an entry for this symbol in the .dynsym section. The dynamic
1523 object will contain position independent code, so all references
1524 from the dynamic object to this symbol will go through the global
1525 offset table. The dynamic linker will use the .dynsym entry to
1526 determine the address it must put in the global offset table, so
1527 both the dynamic object and the regular object will refer to the
1528 same memory location for the variable. */
1530 /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker
1531 to copy the initial value out of the dynamic object and into the
1532 runtime process image. We need to remember the offset into the
1533 .rel.bss section we are going to use. */
1534 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1536 htab->srelbss->_raw_size += sizeof (Elf32_External_Rela);
1537 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
1540 /* We need to figure out the alignment required for this symbol. I
1541 have no idea how ELF linkers handle this. */
1542 power_of_two = bfd_log2 (h->size);
1543 if (power_of_two > 3)
1546 /* Apply the required alignment. */
1548 s->_raw_size = BFD_ALIGN (s->_raw_size,
1549 (bfd_size_type) (1 << power_of_two));
1550 if (power_of_two > bfd_get_section_alignment (dynobj, s))
1552 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
1556 /* Define the symbol as being at this point in the section. */
1557 h->root.u.def.section = s;
1558 h->root.u.def.value = s->_raw_size;
1560 /* Increment the section size to make room for the symbol. */
1561 s->_raw_size += h->size;
1566 /* This is the condition under which finish_dynamic_symbol will be called
1567 from elflink.h. If elflink.h doesn't call our finish_dynamic_symbol
1568 routine, we'll need to do something about initializing any .plt and .got
1569 entries in relocate_section. */
1570 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
1572 && ((INFO)->shared \
1573 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
1574 && ((H)->dynindx != -1 \
1575 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1577 /* Allocate space in .plt, .got and associated reloc sections for
1581 allocate_dynrelocs (h, inf)
1582 struct elf_link_hash_entry *h;
1585 struct bfd_link_info *info;
1586 struct elf32_sparc_link_hash_table *htab;
1587 struct elf32_sparc_link_hash_entry *eh;
1588 struct elf32_sparc_dyn_relocs *p;
1590 if (h->root.type == bfd_link_hash_indirect)
1593 if (h->root.type == bfd_link_hash_warning)
1594 /* When warning symbols are created, they **replace** the "real"
1595 entry in the hash table, thus we never get to see the real
1596 symbol in a hash traversal. So look at it now. */
1597 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1599 info = (struct bfd_link_info *) inf;
1600 htab = elf32_sparc_hash_table (info);
1602 if (htab->elf.dynamic_sections_created
1603 && h->plt.refcount > 0)
1605 /* Make sure this symbol is output as a dynamic symbol.
1606 Undefined weak syms won't yet be marked as dynamic. */
1607 if (h->dynindx == -1
1608 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1610 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1614 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info, h))
1616 asection *s = htab->splt;
1618 /* The first four entries in .plt are reserved. */
1619 if (s->_raw_size == 0)
1620 s->_raw_size = 4 * PLT_ENTRY_SIZE;
1622 /* The procedure linkage table has a maximum size. */
1623 if (s->_raw_size >= 0x400000)
1625 bfd_set_error (bfd_error_bad_value);
1629 h->plt.offset = s->_raw_size;
1631 /* If this symbol is not defined in a regular file, and we are
1632 not generating a shared library, then set the symbol to this
1633 location in the .plt. This is required to make function
1634 pointers compare as equal between the normal executable and
1635 the shared library. */
1637 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1639 h->root.u.def.section = s;
1640 h->root.u.def.value = h->plt.offset;
1643 /* Make room for this entry. */
1644 s->_raw_size += PLT_ENTRY_SIZE;
1646 /* We also need to make an entry in the .rela.plt section. */
1647 htab->srelplt->_raw_size += sizeof (Elf32_External_Rela);
1651 h->plt.offset = (bfd_vma) -1;
1652 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1657 h->plt.offset = (bfd_vma) -1;
1658 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1661 /* If R_SPARC_TLS_IE_{HI22,LO10} symbol is now local to the binary,
1662 make it a R_SPARC_TLS_LE_{HI22,LO10} requiring no TLS entry. */
1663 if (h->got.refcount > 0
1666 && elf32_sparc_hash_entry(h)->tls_type == GOT_TLS_IE)
1667 h->got.offset = (bfd_vma) -1;
1668 else if (h->got.refcount > 0)
1672 int tls_type = elf32_sparc_hash_entry(h)->tls_type;
1674 /* Make sure this symbol is output as a dynamic symbol.
1675 Undefined weak syms won't yet be marked as dynamic. */
1676 if (h->dynindx == -1
1677 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1679 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1684 h->got.offset = s->_raw_size;
1686 /* R_SPARC_TLS_GD_HI{22,LO10} needs 2 consecutive GOT slots. */
1687 if (tls_type == GOT_TLS_GD)
1689 dyn = htab->elf.dynamic_sections_created;
1690 /* R_SPARC_TLS_IE_{HI22,LO10} needs one dynamic relocation,
1691 R_SPARC_TLS_GD_{HI22,LO10} needs one if local symbol and two if
1693 if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
1694 || tls_type == GOT_TLS_IE)
1695 htab->srelgot->_raw_size += sizeof (Elf32_External_Rela);
1696 else if (tls_type == GOT_TLS_GD)
1697 htab->srelgot->_raw_size += 2 * sizeof (Elf32_External_Rela);
1698 else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h))
1699 htab->srelgot->_raw_size += sizeof (Elf32_External_Rela);
1702 h->got.offset = (bfd_vma) -1;
1704 eh = (struct elf32_sparc_link_hash_entry *) h;
1705 if (eh->dyn_relocs == NULL)
1708 /* In the shared -Bsymbolic case, discard space allocated for
1709 dynamic pc-relative relocs against symbols which turn out to be
1710 defined in regular objects. For the normal shared case, discard
1711 space for pc-relative relocs that have become local due to symbol
1712 visibility changes. */
1716 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
1717 && ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
1720 struct elf32_sparc_dyn_relocs **pp;
1722 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1724 p->count -= p->pc_count;
1735 /* For the non-shared case, discard space for relocs against
1736 symbols which turn out to need copy relocs or are not
1739 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
1740 && (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1741 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1742 || (htab->elf.dynamic_sections_created
1743 && (h->root.type == bfd_link_hash_undefweak
1744 || h->root.type == bfd_link_hash_undefined))))
1746 /* Make sure this symbol is output as a dynamic symbol.
1747 Undefined weak syms won't yet be marked as dynamic. */
1748 if (h->dynindx == -1
1749 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1751 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1755 /* If that succeeded, we know we'll be keeping all the
1757 if (h->dynindx != -1)
1761 eh->dyn_relocs = NULL;
1766 /* Finally, allocate space. */
1767 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1769 asection *sreloc = elf_section_data (p->sec)->sreloc;
1770 sreloc->_raw_size += p->count * sizeof (Elf32_External_Rela);
1776 /* Find any dynamic relocs that apply to read-only sections. */
1779 readonly_dynrelocs (h, inf)
1780 struct elf_link_hash_entry *h;
1783 struct elf32_sparc_link_hash_entry *eh;
1784 struct elf32_sparc_dyn_relocs *p;
1786 if (h->root.type == bfd_link_hash_warning)
1787 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1789 eh = (struct elf32_sparc_link_hash_entry *) h;
1790 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1792 asection *s = p->sec->output_section;
1794 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1796 struct bfd_link_info *info = (struct bfd_link_info *) inf;
1798 info->flags |= DF_TEXTREL;
1800 /* Not an error, just cut short the traversal. */
1807 /* Set the sizes of the dynamic sections. */
1810 elf32_sparc_size_dynamic_sections (output_bfd, info)
1811 bfd *output_bfd ATTRIBUTE_UNUSED;
1812 struct bfd_link_info *info;
1814 struct elf32_sparc_link_hash_table *htab;
1819 htab = elf32_sparc_hash_table (info);
1820 dynobj = htab->elf.dynobj;
1821 BFD_ASSERT (dynobj != NULL);
1823 if (elf_hash_table (info)->dynamic_sections_created)
1825 /* Set the contents of the .interp section to the interpreter. */
1826 if (info->executable)
1828 s = bfd_get_section_by_name (dynobj, ".interp");
1829 BFD_ASSERT (s != NULL);
1830 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
1831 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1835 /* Set up .got offsets for local syms, and space for local dynamic
1837 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1839 bfd_signed_vma *local_got;
1840 bfd_signed_vma *end_local_got;
1841 char *local_tls_type;
1842 bfd_size_type locsymcount;
1843 Elf_Internal_Shdr *symtab_hdr;
1846 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
1849 for (s = ibfd->sections; s != NULL; s = s->next)
1851 struct elf32_sparc_dyn_relocs *p;
1853 for (p = *((struct elf32_sparc_dyn_relocs **)
1854 &elf_section_data (s)->local_dynrel);
1858 if (!bfd_is_abs_section (p->sec)
1859 && bfd_is_abs_section (p->sec->output_section))
1861 /* Input section has been discarded, either because
1862 it is a copy of a linkonce section or due to
1863 linker script /DISCARD/, so we'll be discarding
1866 else if (p->count != 0)
1868 srel = elf_section_data (p->sec)->sreloc;
1869 srel->_raw_size += p->count * sizeof (Elf32_External_Rela);
1870 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
1871 info->flags |= DF_TEXTREL;
1876 local_got = elf_local_got_refcounts (ibfd);
1880 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1881 locsymcount = symtab_hdr->sh_info;
1882 end_local_got = local_got + locsymcount;
1883 local_tls_type = elf32_sparc_local_got_tls_type (ibfd);
1885 srel = htab->srelgot;
1886 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
1890 *local_got = s->_raw_size;
1892 if (*local_tls_type == GOT_TLS_GD)
1895 || *local_tls_type == GOT_TLS_GD
1896 || *local_tls_type == GOT_TLS_IE)
1897 srel->_raw_size += sizeof (Elf32_External_Rela);
1900 *local_got = (bfd_vma) -1;
1904 if (htab->tls_ldm_got.refcount > 0)
1906 /* Allocate 2 got entries and 1 dynamic reloc for
1907 R_SPARC_TLS_LDM_{HI22,LO10} relocs. */
1908 htab->tls_ldm_got.offset = htab->sgot->_raw_size;
1909 htab->sgot->_raw_size += 8;
1910 htab->srelgot->_raw_size += sizeof (Elf32_External_Rela);
1913 htab->tls_ldm_got.offset = -1;
1915 /* Allocate global sym .plt and .got entries, and space for global
1916 sym dynamic relocs. */
1917 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
1919 if (elf_hash_table (info)->dynamic_sections_created)
1921 /* Make space for the trailing nop in .plt. */
1922 if (htab->splt->_raw_size > 0)
1923 htab->splt->_raw_size += 4;
1925 /* If the .got section is more than 0x1000 bytes, we add
1926 0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13
1927 bit relocations have a greater chance of working. */
1928 if (htab->sgot->_raw_size >= 0x1000
1929 && elf_hash_table (info)->hgot->root.u.def.value == 0)
1930 elf_hash_table (info)->hgot->root.u.def.value = 0x1000;
1933 /* The check_relocs and adjust_dynamic_symbol entry points have
1934 determined the sizes of the various dynamic sections. Allocate
1936 for (s = dynobj->sections; s != NULL; s = s->next)
1939 bfd_boolean strip = FALSE;
1941 if ((s->flags & SEC_LINKER_CREATED) == 0)
1944 /* It's OK to base decisions on the section name, because none
1945 of the dynobj section names depend upon the input files. */
1946 name = bfd_get_section_name (dynobj, s);
1948 if (strncmp (name, ".rela", 5) == 0)
1950 if (s->_raw_size == 0)
1952 /* If we don't need this section, strip it from the
1953 output file. This is to handle .rela.bss and
1954 .rel.plt. We must create it in
1955 create_dynamic_sections, because it must be created
1956 before the linker maps input sections to output
1957 sections. The linker does that before
1958 adjust_dynamic_symbol is called, and it is that
1959 function which decides whether anything needs to go
1960 into these sections. */
1965 /* We use the reloc_count field as a counter if we need
1966 to copy relocs into the output file. */
1970 else if (s != htab->splt && s != htab->sgot)
1972 /* It's not one of our sections, so don't allocate space. */
1978 _bfd_strip_section_from_output (info, s);
1982 /* Allocate memory for the section contents. */
1983 /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
1984 Unused entries should be reclaimed before the section's contents
1985 are written out, but at the moment this does not happen. Thus in
1986 order to prevent writing out garbage, we initialise the section's
1987 contents to zero. */
1988 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
1989 if (s->contents == NULL && s->_raw_size != 0)
1993 if (elf_hash_table (info)->dynamic_sections_created)
1995 /* Add some entries to the .dynamic section. We fill in the
1996 values later, in elf32_sparc_finish_dynamic_sections, but we
1997 must add the entries now so that we get the correct size for
1998 the .dynamic section. The DT_DEBUG entry is filled in by the
1999 dynamic linker and used by the debugger. */
2000 #define add_dynamic_entry(TAG, VAL) \
2001 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
2003 if (info->executable)
2005 if (!add_dynamic_entry (DT_DEBUG, 0))
2009 if (htab->srelplt->_raw_size != 0)
2011 if (!add_dynamic_entry (DT_PLTGOT, 0)
2012 || !add_dynamic_entry (DT_PLTRELSZ, 0)
2013 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2014 || !add_dynamic_entry (DT_JMPREL, 0))
2018 if (!add_dynamic_entry (DT_RELA, 0)
2019 || !add_dynamic_entry (DT_RELASZ, 0)
2020 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
2023 /* If any dynamic relocs apply to a read-only section,
2024 then we need a DT_TEXTREL entry. */
2025 if ((info->flags & DF_TEXTREL) == 0)
2026 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
2029 if (info->flags & DF_TEXTREL)
2031 if (!add_dynamic_entry (DT_TEXTREL, 0))
2035 #undef add_dynamic_entry
2040 struct elf32_sparc_section_data
2042 struct bfd_elf_section_data elf;
2043 unsigned int do_relax;
2046 #define sec_do_relax(sec) \
2047 ((struct elf32_sparc_section_data *) elf_section_data (sec))->do_relax
2050 elf32_sparc_new_section_hook (abfd, sec)
2054 struct elf32_sparc_section_data *sdata;
2055 bfd_size_type amt = sizeof (*sdata);
2057 sdata = (struct elf32_sparc_section_data *) bfd_zalloc (abfd, amt);
2060 sec->used_by_bfd = (PTR) sdata;
2062 return _bfd_elf_new_section_hook (abfd, sec);
2066 elf32_sparc_relax_section (abfd, section, link_info, again)
2067 bfd *abfd ATTRIBUTE_UNUSED;
2068 asection *section ATTRIBUTE_UNUSED;
2069 struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
2073 sec_do_relax (section) = 1;
2077 /* Return the base VMA address which should be subtracted from real addresses
2078 when resolving @dtpoff relocation.
2079 This is PT_TLS segment p_vaddr. */
2083 struct bfd_link_info *info;
2085 /* If tls_sec is NULL, we should have signalled an error already. */
2086 if (elf_hash_table (info)->tls_sec == NULL)
2088 return elf_hash_table (info)->tls_sec->vma;
2091 /* Return the relocation value for @tpoff relocation
2092 if STT_TLS virtual address is ADDRESS. */
2095 tpoff (info, address)
2096 struct bfd_link_info *info;
2099 struct elf_link_hash_table *htab = elf_hash_table (info);
2101 /* If tls_sec is NULL, we should have signalled an error already. */
2102 if (htab->tls_sec == NULL)
2104 return address - htab->tls_size - htab->tls_sec->vma;
2107 /* Relocate a SPARC ELF section. */
2110 elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section,
2111 contents, relocs, local_syms, local_sections)
2113 struct bfd_link_info *info;
2115 asection *input_section;
2117 Elf_Internal_Rela *relocs;
2118 Elf_Internal_Sym *local_syms;
2119 asection **local_sections;
2121 struct elf32_sparc_link_hash_table *htab;
2122 Elf_Internal_Shdr *symtab_hdr;
2123 struct elf_link_hash_entry **sym_hashes;
2124 bfd_vma *local_got_offsets;
2127 Elf_Internal_Rela *rel;
2128 Elf_Internal_Rela *relend;
2130 if (info->relocatable)
2133 htab = elf32_sparc_hash_table (info);
2134 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2135 sym_hashes = elf_sym_hashes (input_bfd);
2136 local_got_offsets = elf_local_got_offsets (input_bfd);
2138 if (elf_hash_table (info)->hgot == NULL)
2141 got_base = elf_hash_table (info)->hgot->root.u.def.value;
2143 sreloc = elf_section_data (input_section)->sreloc;
2146 relend = relocs + input_section->reloc_count;
2147 for (; rel < relend; rel++)
2149 int r_type, tls_type;
2150 reloc_howto_type *howto;
2151 unsigned long r_symndx;
2152 struct elf_link_hash_entry *h;
2153 Elf_Internal_Sym *sym;
2155 bfd_vma relocation, off;
2156 bfd_reloc_status_type r;
2157 bfd_boolean is_plt = FALSE;
2158 bfd_boolean unresolved_reloc;
2160 r_type = ELF32_R_TYPE (rel->r_info);
2162 if (r_type == R_SPARC_GNU_VTINHERIT
2163 || r_type == R_SPARC_GNU_VTENTRY)
2166 if (r_type < 0 || r_type >= (int) R_SPARC_max_std)
2168 bfd_set_error (bfd_error_bad_value);
2171 howto = _bfd_sparc_elf_howto_table + r_type;
2173 /* This is a final link. */
2174 r_symndx = ELF32_R_SYM (rel->r_info);
2178 unresolved_reloc = FALSE;
2179 if (r_symndx < symtab_hdr->sh_info)
2181 sym = local_syms + r_symndx;
2182 sec = local_sections[r_symndx];
2183 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2187 bfd_boolean warned ATTRIBUTE_UNUSED;
2189 RELOC_FOR_GLOBAL_SYMBOL (h, sym_hashes, r_symndx,
2190 symtab_hdr, relocation, sec,
2191 unresolved_reloc, info,
2200 /* Relocation is to the entry for this symbol in the global
2202 if (htab->sgot == NULL)
2209 off = h->got.offset;
2210 BFD_ASSERT (off != (bfd_vma) -1);
2211 dyn = elf_hash_table (info)->dynamic_sections_created;
2213 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h)
2217 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
2218 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
2220 /* This is actually a static link, or it is a
2221 -Bsymbolic link and the symbol is defined
2222 locally, or the symbol was forced to be local
2223 because of a version file. We must initialize
2224 this entry in the global offset table. Since the
2225 offset must always be a multiple of 4, we use the
2226 least significant bit to record whether we have
2227 initialized it already.
2229 When doing a dynamic link, we create a .rela.got
2230 relocation entry to initialize the value. This
2231 is done in the finish_dynamic_symbol routine. */
2236 bfd_put_32 (output_bfd, relocation,
2237 htab->sgot->contents + off);
2242 unresolved_reloc = FALSE;
2246 BFD_ASSERT (local_got_offsets != NULL
2247 && local_got_offsets[r_symndx] != (bfd_vma) -1);
2249 off = local_got_offsets[r_symndx];
2251 /* The offset must always be a multiple of 4. We use
2252 the least significant bit to record whether we have
2253 already processed this entry. */
2262 Elf_Internal_Rela outrel;
2265 /* We need to generate a R_SPARC_RELATIVE reloc
2266 for the dynamic linker. */
2268 BFD_ASSERT (s != NULL);
2270 outrel.r_offset = (htab->sgot->output_section->vma
2271 + htab->sgot->output_offset
2273 outrel.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
2274 outrel.r_addend = relocation;
2277 loc += s->reloc_count++ * sizeof (Elf32_External_Rela);
2278 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2281 bfd_put_32 (output_bfd, relocation,
2282 htab->sgot->contents + off);
2283 local_got_offsets[r_symndx] |= 1;
2286 relocation = htab->sgot->output_offset + off - got_base;
2290 if (h == NULL || h->plt.offset == (bfd_vma) -1)
2292 r_type = R_SPARC_32;
2296 case R_SPARC_WPLT30:
2298 /* Relocation is to the entry for this symbol in the
2299 procedure linkage table. */
2301 /* The Solaris native assembler will generate a WPLT30 reloc
2302 for a local symbol if you assemble a call from one
2303 section to another when using -K pic. We treat it as
2308 if (h->plt.offset == (bfd_vma) -1)
2310 /* We didn't make a PLT entry for this symbol. This
2311 happens when statically linking PIC code, or when
2312 using -Bsymbolic. */
2316 if (htab->splt == NULL)
2319 relocation = (htab->splt->output_section->vma
2320 + htab->splt->output_offset
2322 unresolved_reloc = FALSE;
2323 if (r_type == R_SPARC_PLT32)
2325 r_type = R_SPARC_32;
2334 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2338 case R_SPARC_DISP16:
2339 case R_SPARC_DISP32:
2340 case R_SPARC_WDISP30:
2341 case R_SPARC_WDISP22:
2342 case R_SPARC_WDISP19:
2343 case R_SPARC_WDISP16:
2354 /* r_symndx will be zero only for relocs against symbols
2355 from removed linkonce sections, or sections discarded by
2358 || (input_section->flags & SEC_ALLOC) == 0)
2362 && (! howto->pc_relative
2365 && (! info->symbolic
2366 || (h->elf_link_hash_flags
2367 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
2371 && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
2372 && (((h->elf_link_hash_flags
2373 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2374 && (h->elf_link_hash_flags
2375 & ELF_LINK_HASH_DEF_REGULAR) == 0)
2376 || h->root.type == bfd_link_hash_undefweak
2377 || h->root.type == bfd_link_hash_undefined)))
2379 Elf_Internal_Rela outrel;
2381 bfd_boolean skip, relocate = FALSE;
2383 /* When generating a shared object, these relocations
2384 are copied into the output file to be resolved at run
2387 BFD_ASSERT (sreloc != NULL);
2392 _bfd_elf_section_offset (output_bfd, info, input_section,
2394 if (outrel.r_offset == (bfd_vma) -1)
2396 else if (outrel.r_offset == (bfd_vma) -2)
2397 skip = TRUE, relocate = TRUE;
2398 outrel.r_offset += (input_section->output_section->vma
2399 + input_section->output_offset);
2401 /* Optimize unaligned reloc usage now that we know where
2402 it finally resides. */
2406 if (outrel.r_offset & 1)
2407 r_type = R_SPARC_UA16;
2410 if (!(outrel.r_offset & 1))
2411 r_type = R_SPARC_16;
2414 if (outrel.r_offset & 3)
2415 r_type = R_SPARC_UA32;
2418 if (!(outrel.r_offset & 3))
2419 r_type = R_SPARC_32;
2422 case R_SPARC_DISP16:
2423 case R_SPARC_DISP32:
2424 /* If the symbol is not dynamic, we should not keep
2425 a dynamic relocation. But an .rela.* slot has been
2426 allocated for it, output R_SPARC_NONE.
2427 FIXME: Add code tracking needed dynamic relocs as
2429 if (h->dynindx == -1)
2430 skip = TRUE, relocate = TRUE;
2435 memset (&outrel, 0, sizeof outrel);
2436 /* h->dynindx may be -1 if the symbol was marked to
2438 else if (h != NULL && ! is_plt
2439 && ((! info->symbolic && h->dynindx != -1)
2440 || (h->elf_link_hash_flags
2441 & ELF_LINK_HASH_DEF_REGULAR) == 0))
2443 BFD_ASSERT (h->dynindx != -1);
2444 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2445 outrel.r_addend = rel->r_addend;
2449 if (r_type == R_SPARC_32)
2451 outrel.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
2452 outrel.r_addend = relocation + rel->r_addend;
2461 if (bfd_is_abs_section (sec))
2463 else if (sec == NULL || sec->owner == NULL)
2465 bfd_set_error (bfd_error_bad_value);
2472 osec = sec->output_section;
2473 indx = elf_section_data (osec)->dynindx;
2475 /* FIXME: we really should be able to link non-pic
2476 shared libraries. */
2480 (*_bfd_error_handler)
2481 (_("%s: probably compiled without -fPIC?"),
2482 bfd_archive_filename (input_bfd));
2483 bfd_set_error (bfd_error_bad_value);
2488 outrel.r_info = ELF32_R_INFO (indx, r_type);
2489 outrel.r_addend = relocation + rel->r_addend;
2493 loc = sreloc->contents;
2494 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
2495 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2497 /* This reloc will be computed at runtime, so there's no
2498 need to do anything now. */
2504 case R_SPARC_TLS_GD_HI22:
2505 if (! elf32_sparc_tdata (input_bfd)->has_tlsgd)
2507 /* R_SPARC_REV32 used the same reloc number as
2508 R_SPARC_TLS_GD_HI22. */
2509 r_type = R_SPARC_REV32;
2514 case R_SPARC_TLS_GD_LO10:
2515 case R_SPARC_TLS_IE_HI22:
2516 case R_SPARC_TLS_IE_LO10:
2517 r_type = elf32_sparc_tls_transition (info, input_bfd, r_type,
2519 tls_type = GOT_UNKNOWN;
2520 if (h == NULL && local_got_offsets)
2521 tls_type = elf32_sparc_local_got_tls_type (input_bfd) [r_symndx];
2524 tls_type = elf32_sparc_hash_entry(h)->tls_type;
2525 if (!info->shared && h->dynindx == -1 && tls_type == GOT_TLS_IE)
2526 switch (ELF32_R_TYPE (rel->r_info))
2528 case R_SPARC_TLS_GD_HI22:
2529 case R_SPARC_TLS_IE_HI22:
2530 r_type = R_SPARC_TLS_LE_HIX22;
2533 r_type = R_SPARC_TLS_LE_LOX10;
2537 if (tls_type == GOT_TLS_IE)
2540 case R_SPARC_TLS_GD_HI22:
2541 r_type = R_SPARC_TLS_IE_HI22;
2543 case R_SPARC_TLS_GD_LO10:
2544 r_type = R_SPARC_TLS_IE_LO10;
2548 if (r_type == R_SPARC_TLS_LE_HIX22)
2550 relocation = tpoff (info, relocation);
2553 if (r_type == R_SPARC_TLS_LE_LOX10)
2555 /* Change add into xor. */
2556 relocation = tpoff (info, relocation);
2557 bfd_put_32 (output_bfd, (bfd_get_32 (input_bfd,
2558 contents + rel->r_offset)
2559 | 0x80182000), contents + rel->r_offset);
2565 off = h->got.offset;
2570 BFD_ASSERT (local_got_offsets != NULL);
2571 off = local_got_offsets[r_symndx];
2572 local_got_offsets[r_symndx] |= 1;
2576 if (htab->sgot == NULL)
2583 Elf_Internal_Rela outrel;
2584 Elf32_External_Rela *loc;
2587 if (htab->srelgot == NULL)
2590 bfd_put_32 (output_bfd, 0, htab->sgot->contents + off);
2591 outrel.r_offset = (htab->sgot->output_section->vma
2592 + htab->sgot->output_offset + off);
2593 indx = h && h->dynindx != -1 ? h->dynindx : 0;
2594 if (r_type == R_SPARC_TLS_IE_HI22
2595 || r_type == R_SPARC_TLS_IE_LO10)
2596 dr_type = R_SPARC_TLS_TPOFF32;
2598 dr_type = R_SPARC_TLS_DTPMOD32;
2599 if (dr_type == R_SPARC_TLS_TPOFF32 && indx == 0)
2600 outrel.r_addend = relocation - dtpoff_base (info);
2602 outrel.r_addend = 0;
2603 outrel.r_info = ELF32_R_INFO (indx, dr_type);
2604 loc = (Elf32_External_Rela *) htab->srelgot->contents;
2605 loc += htab->srelgot->reloc_count++;
2606 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
2609 if (r_type == R_SPARC_TLS_GD_HI22
2610 || r_type == R_SPARC_TLS_GD_LO10)
2614 BFD_ASSERT (! unresolved_reloc);
2615 bfd_put_32 (output_bfd,
2616 relocation - dtpoff_base (info),
2617 htab->sgot->contents + off + 4);
2621 bfd_put_32 (output_bfd, 0,
2622 htab->sgot->contents + off + 4);
2623 outrel.r_info = ELF32_R_INFO (indx,
2624 R_SPARC_TLS_DTPOFF32);
2625 outrel.r_offset += 4;
2626 htab->srelgot->reloc_count++;
2628 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
2632 else if (dr_type == R_SPARC_TLS_DTPMOD32)
2634 bfd_put_32 (output_bfd, 0,
2635 htab->sgot->contents + off + 4);
2639 if (off >= (bfd_vma) -2)
2642 relocation = htab->sgot->output_offset + off - got_base;
2643 unresolved_reloc = FALSE;
2644 howto = _bfd_sparc_elf_howto_table + r_type;
2647 case R_SPARC_TLS_LDM_HI22:
2648 case R_SPARC_TLS_LDM_LO10:
2651 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
2654 off = htab->tls_ldm_got.offset;
2655 htab->tls_ldm_got.offset |= 1;
2656 goto r_sparc_tlsldm;
2658 case R_SPARC_TLS_LDO_HIX22:
2659 case R_SPARC_TLS_LDO_LOX10:
2661 relocation -= dtpoff_base (info);
2663 relocation = tpoff (info, relocation);
2666 case R_SPARC_TLS_LE_HIX22:
2667 case R_SPARC_TLS_LE_LOX10:
2670 Elf_Internal_Rela outrel;
2671 bfd_boolean skip, relocate = FALSE;
2673 BFD_ASSERT (sreloc != NULL);
2676 _bfd_elf_section_offset (output_bfd, info, input_section,
2678 if (outrel.r_offset == (bfd_vma) -1)
2680 else if (outrel.r_offset == (bfd_vma) -2)
2681 skip = TRUE, relocate = TRUE;
2682 outrel.r_offset += (input_section->output_section->vma
2683 + input_section->output_offset);
2685 memset (&outrel, 0, sizeof outrel);
2688 outrel.r_info = ELF32_R_INFO (0, r_type);
2689 outrel.r_addend = relocation - dtpoff_base (info)
2693 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
2694 (bfd_byte *) (((Elf32_External_Rela *)
2696 + sreloc->reloc_count));
2697 ++sreloc->reloc_count;
2700 relocation = tpoff (info, relocation);
2703 case R_SPARC_TLS_LDM_CALL:
2707 bfd_put_32 (output_bfd, 0x90100000, contents + rel->r_offset);
2712 case R_SPARC_TLS_GD_CALL:
2713 tls_type = GOT_UNKNOWN;
2714 if (h == NULL && local_got_offsets)
2715 tls_type = elf32_sparc_local_got_tls_type (input_bfd) [r_symndx];
2717 tls_type = elf32_sparc_hash_entry(h)->tls_type;
2719 || (r_type == R_SPARC_TLS_GD_CALL && tls_type == GOT_TLS_IE))
2723 if (!info->shared && (h == NULL || h->dynindx == -1))
2726 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
2731 if (rel + 1 < relend
2732 && ELF32_R_TYPE (rel[1].r_info) == R_SPARC_TLS_GD_ADD
2733 && rel[1].r_offset == rel->r_offset + 4
2734 && ELF32_R_SYM (rel[1].r_info) == r_symndx
2735 && (((insn = bfd_get_32 (input_bfd,
2736 contents + rel[1].r_offset))
2737 >> 25) & 0x1f) == 8)
2740 call __tls_get_addr, %tgd_call(foo)
2741 add %reg1, %reg2, %o0, %tgd_add(foo)
2742 and change it into IE:
2743 ld [%reg1 + %reg2], %o0, %tie_ld(foo)
2744 add %g7, %o0, %o0, %tie_add(foo).
2745 add is 0x80000000 | (rd << 25) | (rs1 << 14) | rs2,
2746 ld is 0xc0000000 | (rd << 25) | (rs1 << 14) | rs2. */
2747 bfd_put_32 (output_bfd, insn | 0xc0000000,
2748 contents + rel->r_offset);
2749 bfd_put_32 (output_bfd, 0x9001c008,
2750 contents + rel->r_offset + 4);
2755 bfd_put_32 (output_bfd, 0x9001c008, contents + rel->r_offset);
2759 h = (struct elf_link_hash_entry *)
2760 bfd_link_hash_lookup (info->hash, "__tls_get_addr", FALSE,
2762 BFD_ASSERT (h != NULL);
2763 r_type = R_SPARC_WPLT30;
2764 howto = _bfd_sparc_elf_howto_table + r_type;
2765 goto r_sparc_wplt30;
2767 case R_SPARC_TLS_GD_ADD:
2768 tls_type = GOT_UNKNOWN;
2769 if (h == NULL && local_got_offsets)
2770 tls_type = elf32_sparc_local_got_tls_type (input_bfd) [r_symndx];
2772 tls_type = elf32_sparc_hash_entry(h)->tls_type;
2773 if (! info->shared || tls_type == GOT_TLS_IE)
2775 /* add %reg1, %reg2, %reg3, %tgd_add(foo)
2777 ld [%reg1 + %reg2], %reg3, %tie_ld(foo)
2779 add %g7, %reg2, %reg3. */
2780 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
2781 if ((h != NULL && h->dynindx != -1) || info->shared)
2782 relocation = insn | 0xc0000000;
2784 relocation = (insn & ~0x7c000) | 0x1c000;
2785 bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
2789 case R_SPARC_TLS_LDM_ADD:
2791 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
2794 case R_SPARC_TLS_LDO_ADD:
2797 /* Change rs1 into %g7. */
2798 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
2799 insn = (insn & ~0x7c000) | 0x1c000;
2800 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
2804 case R_SPARC_TLS_IE_LD:
2805 case R_SPARC_TLS_IE_LDX:
2806 if (! info->shared && (h == NULL || h->dynindx == -1))
2808 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
2809 int rs2 = insn & 0x1f;
2810 int rd = (insn >> 25) & 0x1f;
2813 relocation = SPARC_NOP;
2815 relocation = 0x80100000 | (insn & 0x3e00001f);
2816 bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
2820 case R_SPARC_TLS_IE_ADD:
2821 /* Totally useless relocation. */
2824 case R_SPARC_TLS_DTPOFF32:
2825 relocation -= dtpoff_base (info);
2832 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2833 because such sections are not SEC_ALLOC and thus ld.so will
2834 not process them. */
2835 if (unresolved_reloc
2836 && !((input_section->flags & SEC_DEBUGGING) != 0
2837 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
2838 (*_bfd_error_handler)
2839 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
2840 bfd_archive_filename (input_bfd),
2841 bfd_get_section_name (input_bfd, input_section),
2842 (long) rel->r_offset,
2843 h->root.root.string);
2845 r = bfd_reloc_continue;
2846 if (r_type == R_SPARC_WDISP16)
2850 relocation += rel->r_addend;
2851 relocation -= (input_section->output_section->vma
2852 + input_section->output_offset);
2853 relocation -= rel->r_offset;
2855 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2856 x |= ((((relocation >> 2) & 0xc000) << 6)
2857 | ((relocation >> 2) & 0x3fff));
2858 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2860 if ((bfd_signed_vma) relocation < - 0x40000
2861 || (bfd_signed_vma) relocation > 0x3ffff)
2862 r = bfd_reloc_overflow;
2866 else if (r_type == R_SPARC_REV32)
2870 relocation = relocation + rel->r_addend;
2872 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2874 bfd_putl32 (/*input_bfd,*/ x, contents + rel->r_offset);
2877 else if (r_type == R_SPARC_TLS_LDO_HIX22
2878 || r_type == R_SPARC_TLS_LE_HIX22)
2882 relocation += rel->r_addend;
2883 relocation = relocation ^ 0xffffffff;
2885 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2886 x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
2887 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2890 else if (r_type == R_SPARC_TLS_LDO_LOX10
2891 || r_type == R_SPARC_TLS_LE_LOX10)
2895 relocation += rel->r_addend;
2896 relocation = (relocation & 0x3ff) | 0x1c00;
2898 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2899 x = (x & ~(bfd_vma) 0x1fff) | relocation;
2900 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2904 else if ((r_type == R_SPARC_WDISP30 || r_type == R_SPARC_WPLT30)
2905 && sec_do_relax (input_section)
2906 && rel->r_offset + 4 < input_section->_raw_size)
2910 #define XCC (2 << 20)
2911 #define COND(x) (((x)&0xf)<<25)
2912 #define CONDA COND(0x8)
2913 #define INSN_BPA (F2(0,1) | CONDA | BPRED | XCC)
2914 #define INSN_BA (F2(0,2) | CONDA)
2915 #define INSN_OR F3(2, 0x2, 0)
2916 #define INSN_NOP F2(0,4)
2920 /* If the instruction is a call with either:
2922 arithmetic instruction with rd == %o7
2923 where rs1 != %o7 and rs2 if it is register != %o7
2924 then we can optimize if the call destination is near
2925 by changing the call into a branch always. */
2926 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2927 y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
2928 if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2))
2930 if (((y & OP3(~0)) == OP3(0x3d) /* restore */
2931 || ((y & OP3(0x28)) == 0 /* arithmetic */
2932 && (y & RD(~0)) == RD(O7)))
2933 && (y & RS1(~0)) != RS1(O7)
2935 || (y & RS2(~0)) != RS2(O7)))
2939 reloc = relocation + rel->r_addend - rel->r_offset;
2940 reloc -= (input_section->output_section->vma
2941 + input_section->output_offset);
2943 /* Ensure the reloc fits into simm22. */
2944 if ((reloc & 3) == 0
2945 && ((reloc & ~(bfd_vma)0x7fffff) == 0
2946 || ((reloc | 0x7fffff) == ~(bfd_vma)0)))
2950 /* Check whether it fits into simm19 on v9. */
2951 if (((reloc & 0x3c0000) == 0
2952 || (reloc & 0x3c0000) == 0x3c0000)
2953 && (elf_elfheader (output_bfd)->e_flags & EF_SPARC_32PLUS))
2954 x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */
2956 x = INSN_BA | (reloc & 0x3fffff); /* ba */
2957 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2959 if (rel->r_offset >= 4
2960 && (y & (0xffffffff ^ RS1(~0)))
2961 == (INSN_OR | RD(O7) | RS2(G0)))
2966 z = bfd_get_32 (input_bfd,
2967 contents + rel->r_offset - 4);
2968 if ((z & (0xffffffff ^ RD(~0)))
2969 != (INSN_OR | RS1(O7) | RS2(G0)))
2977 If call foo was replaced with ba, replace
2978 or %rN, %g0, %o7 with nop. */
2980 reg = (y & RS1(~0)) >> 14;
2981 if (reg != ((z & RD(~0)) >> 25)
2982 || reg == G0 || reg == O7)
2985 bfd_put_32 (input_bfd, (bfd_vma) INSN_NOP,
2986 contents + rel->r_offset + 4);
2994 if (r == bfd_reloc_continue)
2995 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2996 contents, rel->r_offset,
2997 relocation, rel->r_addend);
2999 if (r != bfd_reloc_ok)
3004 case bfd_reloc_outofrange:
3006 case bfd_reloc_overflow:
3011 name = h->root.root.string;
3014 name = bfd_elf_string_from_elf_section (input_bfd,
3015 symtab_hdr->sh_link,
3020 name = bfd_section_name (input_bfd, sec);
3022 if (! ((*info->callbacks->reloc_overflow)
3023 (info, name, howto->name, (bfd_vma) 0,
3024 input_bfd, input_section, rel->r_offset)))
3035 /* Finish up dynamic symbol handling. We set the contents of various
3036 dynamic sections here. */
3039 elf32_sparc_finish_dynamic_symbol (output_bfd, info, h, sym)
3041 struct bfd_link_info *info;
3042 struct elf_link_hash_entry *h;
3043 Elf_Internal_Sym *sym;
3046 struct elf32_sparc_link_hash_table *htab;
3048 htab = elf32_sparc_hash_table (info);
3049 dynobj = htab->elf.dynobj;
3051 if (h->plt.offset != (bfd_vma) -1)
3055 Elf_Internal_Rela rela;
3058 /* This symbol has an entry in the procedure linkage table. Set
3061 BFD_ASSERT (h->dynindx != -1);
3064 srela = htab->srelplt;
3065 BFD_ASSERT (splt != NULL && srela != NULL);
3067 /* Fill in the entry in the procedure linkage table. */
3068 bfd_put_32 (output_bfd,
3069 PLT_ENTRY_WORD0 + h->plt.offset,
3070 splt->contents + h->plt.offset);
3071 bfd_put_32 (output_bfd,
3073 + (((- (h->plt.offset + 4)) >> 2) & 0x3fffff)),
3074 splt->contents + h->plt.offset + 4);
3075 bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD2,
3076 splt->contents + h->plt.offset + 8);
3078 /* Fill in the entry in the .rela.plt section. */
3079 rela.r_offset = (splt->output_section->vma
3080 + splt->output_offset
3082 rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_JMP_SLOT);
3084 loc = srela->contents;
3085 loc += (h->plt.offset / PLT_ENTRY_SIZE - 4) * sizeof (Elf32_External_Rela);
3086 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3088 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3090 /* Mark the symbol as undefined, rather than as defined in
3091 the .plt section. Leave the value alone. */
3092 sym->st_shndx = SHN_UNDEF;
3093 /* If the symbol is weak, we do need to clear the value.
3094 Otherwise, the PLT entry would provide a definition for
3095 the symbol even if the symbol wasn't defined anywhere,
3096 and so the symbol would never be NULL. */
3097 if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK)
3103 if (h->got.offset != (bfd_vma) -1
3104 && elf32_sparc_hash_entry(h)->tls_type != GOT_TLS_GD
3105 && elf32_sparc_hash_entry(h)->tls_type != GOT_TLS_IE)
3109 Elf_Internal_Rela rela;
3112 /* This symbol has an entry in the global offset table. Set it
3116 srela = htab->srelgot;
3117 BFD_ASSERT (sgot != NULL && srela != NULL);
3119 rela.r_offset = (sgot->output_section->vma
3120 + sgot->output_offset
3121 + (h->got.offset &~ (bfd_vma) 1));
3123 /* If this is a -Bsymbolic link, and the symbol is defined
3124 locally, we just want to emit a RELATIVE reloc. Likewise if
3125 the symbol was forced to be local because of a version file.
3126 The entry in the global offset table will already have been
3127 initialized in the relocate_section function. */
3129 && (info->symbolic || h->dynindx == -1)
3130 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
3132 asection *sec = h->root.u.def.section;
3133 rela.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
3134 rela.r_addend = (h->root.u.def.value
3135 + sec->output_section->vma
3136 + sec->output_offset);
3140 rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_GLOB_DAT);
3144 bfd_put_32 (output_bfd, (bfd_vma) 0,
3145 sgot->contents + (h->got.offset &~ (bfd_vma) 1));
3146 loc = srela->contents;
3147 loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
3148 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3151 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
3154 Elf_Internal_Rela rela;
3157 /* This symbols needs a copy reloc. Set it up. */
3159 BFD_ASSERT (h->dynindx != -1);
3161 s = bfd_get_section_by_name (h->root.u.def.section->owner,
3163 BFD_ASSERT (s != NULL);
3165 rela.r_offset = (h->root.u.def.value
3166 + h->root.u.def.section->output_section->vma
3167 + h->root.u.def.section->output_offset);
3168 rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_COPY);
3170 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
3171 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3174 /* Mark some specially defined symbols as absolute. */
3175 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3176 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
3177 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
3178 sym->st_shndx = SHN_ABS;
3183 /* Finish up the dynamic sections. */
3186 elf32_sparc_finish_dynamic_sections (output_bfd, info)
3188 struct bfd_link_info *info;
3192 struct elf32_sparc_link_hash_table *htab;
3194 htab = elf32_sparc_hash_table (info);
3195 dynobj = htab->elf.dynobj;
3197 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3199 if (elf_hash_table (info)->dynamic_sections_created)
3202 Elf32_External_Dyn *dyncon, *dynconend;
3204 splt = bfd_get_section_by_name (dynobj, ".plt");
3205 BFD_ASSERT (splt != NULL && sdyn != NULL);
3207 dyncon = (Elf32_External_Dyn *) sdyn->contents;
3208 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3209 for (; dyncon < dynconend; dyncon++)
3211 Elf_Internal_Dyn dyn;
3215 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3219 case DT_PLTGOT: name = ".plt"; size = FALSE; break;
3220 case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break;
3221 case DT_JMPREL: name = ".rela.plt"; size = FALSE; break;
3222 default: name = NULL; size = FALSE; break;
3229 s = bfd_get_section_by_name (output_bfd, name);
3235 dyn.d_un.d_ptr = s->vma;
3238 if (s->_cooked_size != 0)
3239 dyn.d_un.d_val = s->_cooked_size;
3241 dyn.d_un.d_val = s->_raw_size;
3244 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3248 /* Clear the first four entries in the procedure linkage table,
3249 and put a nop in the last four bytes. */
3250 if (splt->_raw_size > 0)
3252 memset (splt->contents, 0, 4 * PLT_ENTRY_SIZE);
3253 bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP,
3254 splt->contents + splt->_raw_size - 4);
3257 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
3261 /* Set the first entry in the global offset table to the address of
3262 the dynamic section. */
3263 if (htab->sgot && htab->sgot->_raw_size > 0)
3266 bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgot->contents);
3268 bfd_put_32 (output_bfd,
3269 sdyn->output_section->vma + sdyn->output_offset,
3270 htab->sgot->contents);
3274 elf_section_data (htab->sgot->output_section)->this_hdr.sh_entsize = 4;
3279 /* Functions for dealing with the e_flags field.
3281 We don't define set_private_flags or copy_private_bfd_data because
3282 the only currently defined values are based on the bfd mach number,
3283 so we use the latter instead and defer setting e_flags until the
3284 file is written out. */
3286 /* Merge backend specific data from an object file to the output
3287 object file when linking. */
3290 elf32_sparc_merge_private_bfd_data (ibfd, obfd)
3295 /* FIXME: This should not be static. */
3296 static unsigned long previous_ibfd_e_flags = (unsigned long) -1;
3298 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3299 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3304 if (bfd_get_mach (ibfd) >= bfd_mach_sparc_v9)
3307 (*_bfd_error_handler)
3308 (_("%s: compiled for a 64 bit system and target is 32 bit"),
3309 bfd_archive_filename (ibfd));
3311 else if ((ibfd->flags & DYNAMIC) == 0)
3313 if (bfd_get_mach (obfd) < bfd_get_mach (ibfd))
3314 bfd_set_arch_mach (obfd, bfd_arch_sparc, bfd_get_mach (ibfd));
3317 if (((elf_elfheader (ibfd)->e_flags & EF_SPARC_LEDATA)
3318 != previous_ibfd_e_flags)
3319 && previous_ibfd_e_flags != (unsigned long) -1)
3321 (*_bfd_error_handler)
3322 (_("%s: linking little endian files with big endian files"),
3323 bfd_archive_filename (ibfd));
3326 previous_ibfd_e_flags = elf_elfheader (ibfd)->e_flags & EF_SPARC_LEDATA;
3330 bfd_set_error (bfd_error_bad_value);
3337 /* Set the right machine number. */
3340 elf32_sparc_object_p (abfd)
3343 /* Allocate our special target data. */
3344 struct elf32_sparc_obj_tdata *new_tdata;
3345 bfd_size_type amt = sizeof (struct elf32_sparc_obj_tdata);
3346 new_tdata = bfd_zalloc (abfd, amt);
3347 if (new_tdata == NULL)
3349 new_tdata->root = *abfd->tdata.elf_obj_data;
3350 abfd->tdata.any = new_tdata;
3352 if (elf_elfheader (abfd)->e_machine == EM_SPARC32PLUS)
3354 if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
3355 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
3356 bfd_mach_sparc_v8plusb);
3357 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
3358 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
3359 bfd_mach_sparc_v8plusa);
3360 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_32PLUS)
3361 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
3362 bfd_mach_sparc_v8plus);
3366 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_LEDATA)
3367 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
3368 bfd_mach_sparc_sparclite_le);
3370 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc);
3373 /* The final processing done just before writing out the object file.
3374 We need to set the e_machine field appropriately. */
3377 elf32_sparc_final_write_processing (abfd, linker)
3379 bfd_boolean linker ATTRIBUTE_UNUSED;
3381 switch (bfd_get_mach (abfd))
3383 case bfd_mach_sparc :
3384 break; /* nothing to do */
3385 case bfd_mach_sparc_v8plus :
3386 elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS;
3387 elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK;
3388 elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS;
3390 case bfd_mach_sparc_v8plusa :
3391 elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS;
3392 elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK;
3393 elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS | EF_SPARC_SUN_US1;
3395 case bfd_mach_sparc_v8plusb :
3396 elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS;
3397 elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK;
3398 elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS | EF_SPARC_SUN_US1
3401 case bfd_mach_sparc_sparclite_le :
3402 elf_elfheader (abfd)->e_machine = EM_SPARC;
3403 elf_elfheader (abfd)->e_flags |= EF_SPARC_LEDATA;
3411 static enum elf_reloc_type_class
3412 elf32_sparc_reloc_type_class (rela)
3413 const Elf_Internal_Rela *rela;
3415 switch ((int) ELF32_R_TYPE (rela->r_info))
3417 case R_SPARC_RELATIVE:
3418 return reloc_class_relative;
3419 case R_SPARC_JMP_SLOT:
3420 return reloc_class_plt;
3422 return reloc_class_copy;
3424 return reloc_class_normal;
3428 #define TARGET_BIG_SYM bfd_elf32_sparc_vec
3429 #define TARGET_BIG_NAME "elf32-sparc"
3430 #define ELF_ARCH bfd_arch_sparc
3431 #define ELF_MACHINE_CODE EM_SPARC
3432 #define ELF_MACHINE_ALT1 EM_SPARC32PLUS
3433 #define ELF_MAXPAGESIZE 0x10000
3435 #define bfd_elf32_bfd_reloc_type_lookup elf32_sparc_reloc_type_lookup
3436 #define bfd_elf32_bfd_link_hash_table_create \
3437 elf32_sparc_link_hash_table_create
3438 #define bfd_elf32_bfd_relax_section elf32_sparc_relax_section
3439 #define bfd_elf32_new_section_hook elf32_sparc_new_section_hook
3440 #define elf_info_to_howto elf32_sparc_info_to_howto
3441 #define elf_backend_copy_indirect_symbol \
3442 elf32_sparc_copy_indirect_symbol
3443 #define elf_backend_create_dynamic_sections \
3444 elf32_sparc_create_dynamic_sections
3445 #define elf_backend_check_relocs elf32_sparc_check_relocs
3446 #define elf_backend_adjust_dynamic_symbol \
3447 elf32_sparc_adjust_dynamic_symbol
3448 #define elf_backend_size_dynamic_sections \
3449 elf32_sparc_size_dynamic_sections
3450 #define elf_backend_relocate_section elf32_sparc_relocate_section
3451 #define elf_backend_finish_dynamic_symbol \
3452 elf32_sparc_finish_dynamic_symbol
3453 #define elf_backend_finish_dynamic_sections \
3454 elf32_sparc_finish_dynamic_sections
3455 #define bfd_elf32_bfd_merge_private_bfd_data \
3456 elf32_sparc_merge_private_bfd_data
3457 #define bfd_elf32_mkobject elf32_sparc_mkobject
3458 #define elf_backend_object_p elf32_sparc_object_p
3459 #define elf_backend_final_write_processing \
3460 elf32_sparc_final_write_processing
3461 #define elf_backend_gc_mark_hook elf32_sparc_gc_mark_hook
3462 #define elf_backend_gc_sweep_hook elf32_sparc_gc_sweep_hook
3463 #define elf_backend_reloc_type_class elf32_sparc_reloc_type_class
3465 #define elf_backend_can_gc_sections 1
3466 #define elf_backend_can_refcount 1
3467 #define elf_backend_want_got_plt 0
3468 #define elf_backend_plt_readonly 0
3469 #define elf_backend_want_plt_sym 1
3470 #define elf_backend_got_header_size 4
3471 #define elf_backend_rela_normal 1
3473 #include "elf32-target.h"