?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2004-08-26 Paolo Bonzini <bonzini@gnu.org>
[binutils.git] / bfd / elf32-sparc.c
blob5b8053341922b81af8bf6038da631840971410aa
1 /* SPARC-specific support for 32-bit ELF
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003, 2004 Free Software Foundation, Inc.
4
5 This file is part of BFD, the Binary File Descriptor library.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20
21 #include "bfd.h"
22 #include "sysdep.h"
23 #include "bfdlink.h"
24 #include "libbfd.h"
25 #include "elf-bfd.h"
26 #include "elf/sparc.h"
27 #include "opcode/sparc.h"
28
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 *));
50 static bfd_vma tpoff
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 *,
57 Elf_Internal_Sym *));
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
65 PARAMS ((bfd *));
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));
75
76 static bfd_boolean elf32_sparc_mkobject
77 PARAMS ((bfd *));
78 static bfd_boolean elf32_sparc_object_p
79 PARAMS ((bfd *));
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 *));
90 \f
91 /* The relocation "howto" table. */
92
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 **));
101
102 reloc_howto_type _bfd_sparc_elf_howto_table[] =
103 {
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)
188 };
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);
195
196 struct elf_reloc_map {
197 bfd_reloc_code_real_type bfd_reloc_val;
198 unsigned char elf_reloc_val;
199 };
200
201 static const struct elf_reloc_map sparc_reloc_map[] =
202 {
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 }
273 };
274
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;
279 {
280 unsigned int i;
281
282 switch (code)
283 {
284 case BFD_RELOC_VTABLE_INHERIT:
285 return &elf32_sparc_vtinherit_howto;
286
287 case BFD_RELOC_VTABLE_ENTRY:
288 return &elf32_sparc_vtentry_howto;
289
290 case BFD_RELOC_SPARC_REV32:
291 return &elf32_sparc_rev32_howto;
292
293 default:
294 for (i = 0;
295 i < sizeof (sparc_reloc_map) / sizeof (struct elf_reloc_map);
296 i++)
297 {
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);
301 }
302 }
303 bfd_set_error (bfd_error_bad_value);
304 return NULL;
305 }
306
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. */
309
310 static void
311 elf32_sparc_info_to_howto (abfd, cache_ptr, dst)
312 bfd *abfd ATTRIBUTE_UNUSED;
313 arelent *cache_ptr;
314 Elf_Internal_Rela *dst;
315 {
316 switch (ELF32_R_TYPE(dst->r_info))
317 {
318 case R_SPARC_GNU_VTINHERIT:
319 cache_ptr->howto = &elf32_sparc_vtinherit_howto;
320 break;
321
322 case R_SPARC_GNU_VTENTRY:
323 cache_ptr->howto = &elf32_sparc_vtentry_howto;
324 break;
325
326 case R_SPARC_REV32:
327 cache_ptr->howto = &elf32_sparc_rev32_howto;
328 break;
329
330 default:
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)];
333 }
334 }
335 \f
336 /* For unsupported relocs. */
337
338 static bfd_reloc_status_type
339 sparc_elf_notsupported_reloc (abfd,
340 reloc_entry,
341 symbol,
342 data,
343 input_section,
344 output_bfd,
345 error_message)
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;
353 {
354 return bfd_reloc_notsupported;
355 }
356
357 /* Handle the WDISP16 reloc. */
358
359 static bfd_reloc_status_type
360 sparc_elf_wdisp16_reloc (abfd,
361 reloc_entry,
362 symbol,
363 data,
364 input_section,
365 output_bfd,
366 error_message)
367 bfd *abfd;
368 arelent *reloc_entry;
369 asymbol *symbol;
370 PTR data;
371 asection *input_section;
372 bfd *output_bfd;
373 char **error_message ATTRIBUTE_UNUSED;
374 {
375 bfd_vma relocation;
376 bfd_vma x;
377
378 if (output_bfd != (bfd *) NULL
379 && (symbol->flags & BSF_SECTION_SYM) == 0
380 && (! reloc_entry->howto->partial_inplace
381 || reloc_entry->addend == 0))
382 {
383 reloc_entry->address += input_section->output_offset;
384 return bfd_reloc_ok;
385 }
386
387 if (output_bfd != NULL)
388 return bfd_reloc_continue;
389
390 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
391 return bfd_reloc_outofrange;
392
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;
400
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);
405
406 if ((bfd_signed_vma) relocation < - 0x40000
407 || (bfd_signed_vma) relocation > 0x3ffff)
408 return bfd_reloc_overflow;
409 else
410 return bfd_reloc_ok;
411 }
412
413 /* Handle the HIX22 reloc. */
414
415 static bfd_reloc_status_type
416 sparc_elf_hix22_reloc (abfd,
417 reloc_entry,
418 symbol,
419 data,
420 input_section,
421 output_bfd,
422 error_message)
423 bfd *abfd;
424 arelent *reloc_entry;
425 asymbol *symbol;
426 PTR data;
427 asection *input_section;
428 bfd *output_bfd;
429 char **error_message ATTRIBUTE_UNUSED;
430 {
431 bfd_vma relocation;
432 bfd_vma insn;
433
434 if (output_bfd != (bfd *) NULL
435 && (symbol->flags & BSF_SECTION_SYM) == 0)
436 {
437 reloc_entry->address += input_section->output_offset;
438 return bfd_reloc_ok;
439 }
440
441 if (output_bfd != NULL)
442 return bfd_reloc_continue;
443
444 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
445 return bfd_reloc_outofrange;
446
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);
452
453 insn = (insn &~ (bfd_vma) 0x3fffff) | (((~relocation) >> 10) & 0x3fffff);
454 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
455
456 return bfd_reloc_ok;
457 }
458
459 /* Handle the LOX10 reloc. */
460
461 static bfd_reloc_status_type
462 sparc_elf_lox10_reloc (abfd,
463 reloc_entry,
464 symbol,
465 data,
466 input_section,
467 output_bfd,
468 error_message)
469 bfd *abfd;
470 arelent *reloc_entry;
471 asymbol *symbol;
472 PTR data;
473 asection *input_section;
474 bfd *output_bfd;
475 char **error_message ATTRIBUTE_UNUSED;
476 {
477 bfd_vma relocation;
478 bfd_vma insn;
479
480 if (output_bfd != (bfd *) NULL
481 && (symbol->flags & BSF_SECTION_SYM) == 0)
482 {
483 reloc_entry->address += input_section->output_offset;
484 return bfd_reloc_ok;
485 }
486
487 if (output_bfd != NULL)
488 return bfd_reloc_continue;
489
490 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
491 return bfd_reloc_outofrange;
492
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);
498
499 insn = (insn &~ (bfd_vma) 0x1fff) | 0x1c00 | (relocation & 0x3ff);
500 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
501
502 return bfd_reloc_ok;
503 }
504 \f
505 /* Support for core dump NOTE sections. */
506
507 static bfd_boolean
508 elf32_sparc_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
509 {
510 switch (note->descsz)
511 {
512 default:
513 return FALSE;
514
515 case 260: /* Solaris prpsinfo_t. */
516 elf_tdata (abfd)->core_program
517 = _bfd_elfcore_strndup (abfd, note->descdata + 84, 16);
518 elf_tdata (abfd)->core_command
519 = _bfd_elfcore_strndup (abfd, note->descdata + 100, 80);
520 break;
521
522 case 336: /* Solaris psinfo_t. */
523 elf_tdata (abfd)->core_program
524 = _bfd_elfcore_strndup (abfd, note->descdata + 88, 16);
525 elf_tdata (abfd)->core_command
526 = _bfd_elfcore_strndup (abfd, note->descdata + 104, 80);
527 break;
528 }
529
530 return TRUE;
531 }
532
533 \f
534 /* Functions for the SPARC ELF linker. */
535
536 /* The name of the dynamic interpreter. This is put in the .interp
537 section. */
538
539 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
540
541 /* The nop opcode we use. */
542
543 #define SPARC_NOP 0x01000000
544
545 /* The size in bytes of an entry in the procedure linkage table. */
546
547 #define PLT_ENTRY_SIZE 12
548
549 /* The first four entries in a procedure linkage table are reserved,
550 and the initial contents are unimportant (we zero them out).
551 Subsequent entries look like this. See the SVR4 ABI SPARC
552 supplement to see how this works. */
553
554 /* sethi %hi(.-.plt0),%g1. We fill in the address later. */
555 #define PLT_ENTRY_WORD0 0x03000000
556 /* b,a .plt0. We fill in the offset later. */
557 #define PLT_ENTRY_WORD1 0x30800000
558 /* nop. */
559 #define PLT_ENTRY_WORD2 SPARC_NOP
560
561 /* The SPARC linker needs to keep track of the number of relocs that it
562 decides to copy as dynamic relocs in check_relocs for each symbol.
563 This is so that it can later discard them if they are found to be
564 unnecessary. We store the information in a field extending the
565 regular ELF linker hash table. */
566
567 struct elf32_sparc_dyn_relocs
568 {
569 struct elf32_sparc_dyn_relocs *next;
570
571 /* The input section of the reloc. */
572 asection *sec;
573
574 /* Total number of relocs copied for the input section. */
575 bfd_size_type count;
576
577 /* Number of pc-relative relocs copied for the input section. */
578 bfd_size_type pc_count;
579 };
580
581 /* SPARC ELF linker hash entry. */
582
583 struct elf32_sparc_link_hash_entry
584 {
585 struct elf_link_hash_entry elf;
586
587 /* Track dynamic relocs copied for this symbol. */
588 struct elf32_sparc_dyn_relocs *dyn_relocs;
589
590 #define GOT_UNKNOWN 0
591 #define GOT_NORMAL 1
592 #define GOT_TLS_GD 2
593 #define GOT_TLS_IE 3
594 unsigned char tls_type;
595 };
596
597 #define elf32_sparc_hash_entry(ent) ((struct elf32_sparc_link_hash_entry *)(ent))
598
599 struct elf32_sparc_obj_tdata
600 {
601 struct elf_obj_tdata root;
602
603 /* tls_type for each local got entry. */
604 char *local_got_tls_type;
605
606 /* TRUE if TLS GD relocs has been seen for this object. */
607 bfd_boolean has_tlsgd;
608 };
609
610 #define elf32_sparc_tdata(abfd) \
611 ((struct elf32_sparc_obj_tdata *) (abfd)->tdata.any)
612
613 #define elf32_sparc_local_got_tls_type(abfd) \
614 (elf32_sparc_tdata (abfd)->local_got_tls_type)
615
616 static bfd_boolean
617 elf32_sparc_mkobject (abfd)
618 bfd *abfd;
619 {
620 bfd_size_type amt = sizeof (struct elf32_sparc_obj_tdata);
621 abfd->tdata.any = bfd_zalloc (abfd, amt);
622 if (abfd->tdata.any == NULL)
623 return FALSE;
624 return TRUE;
625 }
626
627 /* SPARC ELF linker hash table. */
628
629 struct elf32_sparc_link_hash_table
630 {
631 struct elf_link_hash_table elf;
632
633 /* Short-cuts to get to dynamic linker sections. */
634 asection *sgot;
635 asection *srelgot;
636 asection *splt;
637 asection *srelplt;
638 asection *sdynbss;
639 asection *srelbss;
640
641 union {
642 bfd_signed_vma refcount;
643 bfd_vma offset;
644 } tls_ldm_got;
645
646 /* Small local sym to section mapping cache. */
647 struct sym_sec_cache sym_sec;
648 };
649
650 /* Get the SPARC ELF linker hash table from a link_info structure. */
651
652 #define elf32_sparc_hash_table(p) \
653 ((struct elf32_sparc_link_hash_table *) ((p)->hash))
654
655 /* Create an entry in an i386 ELF linker hash table. */
656
657 static struct bfd_hash_entry *
658 link_hash_newfunc (entry, table, string)
659 struct bfd_hash_entry *entry;
660 struct bfd_hash_table *table;
661 const char *string;
662 {
663 /* Allocate the structure if it has not already been allocated by a
664 subclass. */
665 if (entry == NULL)
666 {
667 entry = bfd_hash_allocate (table,
668 sizeof (struct elf32_sparc_link_hash_entry));
669 if (entry == NULL)
670 return entry;
671 }
672
673 /* Call the allocation method of the superclass. */
674 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
675 if (entry != NULL)
676 {
677 struct elf32_sparc_link_hash_entry *eh;
678
679 eh = (struct elf32_sparc_link_hash_entry *) entry;
680 eh->dyn_relocs = NULL;
681 eh->tls_type = GOT_UNKNOWN;
682 }
683
684 return entry;
685 }
686
687 /* Create a SPARC ELF linker hash table. */
688
689 static struct bfd_link_hash_table *
690 elf32_sparc_link_hash_table_create (abfd)
691 bfd *abfd;
692 {
693 struct elf32_sparc_link_hash_table *ret;
694 bfd_size_type amt = sizeof (struct elf32_sparc_link_hash_table);
695
696 ret = (struct elf32_sparc_link_hash_table *) bfd_malloc (amt);
697 if (ret == NULL)
698 return NULL;
699
700 if (! _bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc))
701 {
702 free (ret);
703 return NULL;
704 }
705
706 ret->sgot = NULL;
707 ret->srelgot = NULL;
708 ret->splt = NULL;
709 ret->srelplt = NULL;
710 ret->sdynbss = NULL;
711 ret->srelbss = NULL;
712 ret->tls_ldm_got.refcount = 0;
713 ret->sym_sec.abfd = NULL;
714
715 return &ret->elf.root;
716 }
717
718 /* Create .got and .rela.got sections in DYNOBJ, and set up
719 shortcuts to them in our hash table. */
720
721 static bfd_boolean
722 create_got_section (dynobj, info)
723 bfd *dynobj;
724 struct bfd_link_info *info;
725 {
726 struct elf32_sparc_link_hash_table *htab;
727
728 if (! _bfd_elf_create_got_section (dynobj, info))
729 return FALSE;
730
731 htab = elf32_sparc_hash_table (info);
732 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
733 if (!htab->sgot)
734 abort ();
735
736 htab->srelgot = bfd_make_section (dynobj, ".rela.got");
737 if (htab->srelgot == NULL
738 || ! bfd_set_section_flags (dynobj, htab->srelgot,
739 (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
740 | SEC_IN_MEMORY | SEC_LINKER_CREATED
741 | SEC_READONLY))
742 || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
743 return FALSE;
744 return TRUE;
745 }
746
747 /* Create .plt, .rela.plt, .got, .rela.got, .dynbss, and
748 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
749 hash table. */
750
751 static bfd_boolean
752 elf32_sparc_create_dynamic_sections (dynobj, info)
753 bfd *dynobj;
754 struct bfd_link_info *info;
755 {
756 struct elf32_sparc_link_hash_table *htab;
757
758 htab = elf32_sparc_hash_table (info);
759 if (!htab->sgot && !create_got_section (dynobj, info))
760 return FALSE;
761
762 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
763 return FALSE;
764
765 htab->splt = bfd_get_section_by_name (dynobj, ".plt");
766 htab->srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
767 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
768 if (!info->shared)
769 htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss");
770
771 if (!htab->splt || !htab->srelplt || !htab->sdynbss
772 || (!info->shared && !htab->srelbss))
773 abort ();
774
775 return TRUE;
776 }
777
778 /* Copy the extra info we tack onto an elf_link_hash_entry. */
779
780 static void
781 elf32_sparc_copy_indirect_symbol (bed, dir, ind)
782 const struct elf_backend_data *bed;
783 struct elf_link_hash_entry *dir, *ind;
784 {
785 struct elf32_sparc_link_hash_entry *edir, *eind;
786
787 edir = (struct elf32_sparc_link_hash_entry *) dir;
788 eind = (struct elf32_sparc_link_hash_entry *) ind;
789
790 if (eind->dyn_relocs != NULL)
791 {
792 if (edir->dyn_relocs != NULL)
793 {
794 struct elf32_sparc_dyn_relocs **pp;
795 struct elf32_sparc_dyn_relocs *p;
796
797 if (ind->root.type == bfd_link_hash_indirect)
798 abort ();
799
800 /* Add reloc counts against the weak sym to the strong sym
801 list. Merge any entries against the same section. */
802 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
803 {
804 struct elf32_sparc_dyn_relocs *q;
805
806 for (q = edir->dyn_relocs; q != NULL; q = q->next)
807 if (q->sec == p->sec)
808 {
809 q->pc_count += p->pc_count;
810 q->count += p->count;
811 *pp = p->next;
812 break;
813 }
814 if (q == NULL)
815 pp = &p->next;
816 }
817 *pp = edir->dyn_relocs;
818 }
819
820 edir->dyn_relocs = eind->dyn_relocs;
821 eind->dyn_relocs = NULL;
822 }
823
824 if (ind->root.type == bfd_link_hash_indirect
825 && dir->got.refcount <= 0)
826 {
827 edir->tls_type = eind->tls_type;
828 eind->tls_type = GOT_UNKNOWN;
829 }
830 _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
831 }
832
833 static int
834 elf32_sparc_tls_transition (info, abfd, r_type, is_local)
835 struct bfd_link_info *info;
836 bfd *abfd;
837 int r_type;
838 int is_local;
839 {
840 if (r_type == R_SPARC_TLS_GD_HI22
841 && ! elf32_sparc_tdata (abfd)->has_tlsgd)
842 r_type = R_SPARC_REV32;
843
844 if (info->shared)
845 return r_type;
846
847 switch (r_type)
848 {
849 case R_SPARC_TLS_GD_HI22:
850 if (is_local)
851 return R_SPARC_TLS_LE_HIX22;
852 return R_SPARC_TLS_IE_HI22;
853 case R_SPARC_TLS_GD_LO10:
854 if (is_local)
855 return R_SPARC_TLS_LE_LOX10;
856 return R_SPARC_TLS_IE_LO10;
857 case R_SPARC_TLS_IE_HI22:
858 if (is_local)
859 return R_SPARC_TLS_LE_HIX22;
860 return r_type;
861 case R_SPARC_TLS_IE_LO10:
862 if (is_local)
863 return R_SPARC_TLS_LE_LOX10;
864 return r_type;
865 case R_SPARC_TLS_LDM_HI22:
866 return R_SPARC_TLS_LE_HIX22;
867 case R_SPARC_TLS_LDM_LO10:
868 return R_SPARC_TLS_LE_LOX10;
869 }
870
871 return r_type;
872 }
873
874 /* Look through the relocs for a section during the first phase, and
875 allocate space in the global offset table or procedure linkage
876 table. */
877
878 static bfd_boolean
879 elf32_sparc_check_relocs (abfd, info, sec, relocs)
880 bfd *abfd;
881 struct bfd_link_info *info;
882 asection *sec;
883 const Elf_Internal_Rela *relocs;
884 {
885 struct elf32_sparc_link_hash_table *htab;
886 Elf_Internal_Shdr *symtab_hdr;
887 struct elf_link_hash_entry **sym_hashes;
888 bfd_vma *local_got_offsets;
889 const Elf_Internal_Rela *rel;
890 const Elf_Internal_Rela *rel_end;
891 asection *sreloc;
892 bfd_boolean checked_tlsgd = FALSE;
893
894 if (info->relocatable)
895 return TRUE;
896
897 htab = elf32_sparc_hash_table (info);
898 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
899 sym_hashes = elf_sym_hashes (abfd);
900 local_got_offsets = elf_local_got_offsets (abfd);
901
902 sreloc = NULL;
903
904 rel_end = relocs + sec->reloc_count;
905 for (rel = relocs; rel < rel_end; rel++)
906 {
907 unsigned int r_type;
908 unsigned long r_symndx;
909 struct elf_link_hash_entry *h;
910
911 r_symndx = ELF32_R_SYM (rel->r_info);
912 r_type = ELF32_R_TYPE (rel->r_info);
913
914 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
915 {
916 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
917 abfd, r_symndx);
918 return FALSE;
919 }
920
921 if (r_symndx < symtab_hdr->sh_info)
922 h = NULL;
923 else
924 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
925
926 /* Compatibility with old R_SPARC_REV32 reloc conflicting
927 with R_SPARC_TLS_GD_HI22. */
928 if (! checked_tlsgd)
929 switch (r_type)
930 {
931 case R_SPARC_TLS_GD_HI22:
932 {
933 const Elf_Internal_Rela *relt;
934
935 for (relt = rel + 1; relt < rel_end; relt++)
936 if (ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_LO10
937 || ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_ADD
938 || ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_CALL)
939 break;
940 checked_tlsgd = TRUE;
941 elf32_sparc_tdata (abfd)->has_tlsgd = relt < rel_end;
942 }
943 break;
944 case R_SPARC_TLS_GD_LO10:
945 case R_SPARC_TLS_GD_ADD:
946 case R_SPARC_TLS_GD_CALL:
947 checked_tlsgd = TRUE;
948 elf32_sparc_tdata (abfd)->has_tlsgd = TRUE;
949 break;
950 }
951
952 r_type = elf32_sparc_tls_transition (info, abfd, r_type, h == NULL);
953 switch (r_type)
954 {
955 case R_SPARC_TLS_LDM_HI22:
956 case R_SPARC_TLS_LDM_LO10:
957 htab->tls_ldm_got.refcount += 1;
958 break;
959
960 case R_SPARC_TLS_LE_HIX22:
961 case R_SPARC_TLS_LE_LOX10:
962 if (info->shared)
963 goto r_sparc_plt32;
964 break;
965
966 case R_SPARC_TLS_IE_HI22:
967 case R_SPARC_TLS_IE_LO10:
968 if (info->shared)
969 info->flags |= DF_STATIC_TLS;
970 /* Fall through */
971
972 case R_SPARC_GOT10:
973 case R_SPARC_GOT13:
974 case R_SPARC_GOT22:
975 case R_SPARC_TLS_GD_HI22:
976 case R_SPARC_TLS_GD_LO10:
977 /* This symbol requires a global offset table entry. */
978 {
979 int tls_type, old_tls_type;
980
981 switch (r_type)
982 {
983 default:
984 case R_SPARC_GOT10:
985 case R_SPARC_GOT13:
986 case R_SPARC_GOT22:
987 tls_type = GOT_NORMAL;
988 break;
989 case R_SPARC_TLS_GD_HI22:
990 case R_SPARC_TLS_GD_LO10:
991 tls_type = GOT_TLS_GD;
992 break;
993 case R_SPARC_TLS_IE_HI22:
994 case R_SPARC_TLS_IE_LO10:
995 tls_type = GOT_TLS_IE;
996 break;
997 }
998
999 if (h != NULL)
1000 {
1001 h->got.refcount += 1;
1002 old_tls_type = elf32_sparc_hash_entry(h)->tls_type;
1003 }
1004 else
1005 {
1006 bfd_signed_vma *local_got_refcounts;
1007
1008 /* This is a global offset table entry for a local symbol. */
1009 local_got_refcounts = elf_local_got_refcounts (abfd);
1010 if (local_got_refcounts == NULL)
1011 {
1012 bfd_size_type size;
1013
1014 size = symtab_hdr->sh_info;
1015 size *= (sizeof (bfd_signed_vma) + sizeof(char));
1016 local_got_refcounts = ((bfd_signed_vma *)
1017 bfd_zalloc (abfd, size));
1018 if (local_got_refcounts == NULL)
1019 return FALSE;
1020 elf_local_got_refcounts (abfd) = local_got_refcounts;
1021 elf32_sparc_local_got_tls_type (abfd)
1022 = (char *) (local_got_refcounts + symtab_hdr->sh_info);
1023 }
1024 local_got_refcounts[r_symndx] += 1;
1025 old_tls_type = elf32_sparc_local_got_tls_type (abfd) [r_symndx];
1026 }
1027
1028 /* If a TLS symbol is accessed using IE at least once,
1029 there is no point to use dynamic model for it. */
1030 if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1031 && (old_tls_type != GOT_TLS_GD
1032 || tls_type != GOT_TLS_IE))
1033 {
1034 if (old_tls_type == GOT_TLS_IE && tls_type == GOT_TLS_GD)
1035 tls_type = old_tls_type;
1036 else
1037 {
1038 (*_bfd_error_handler)
1039 (_("%B: `%s' accessed both as normal and thread local symbol"),
1040 abfd, h ? h->root.root.string : "<local>");
1041 return FALSE;
1042 }
1043 }
1044
1045 if (old_tls_type != tls_type)
1046 {
1047 if (h != NULL)
1048 elf32_sparc_hash_entry (h)->tls_type = tls_type;
1049 else
1050 elf32_sparc_local_got_tls_type (abfd) [r_symndx] = tls_type;
1051 }
1052 }
1053
1054 if (htab->sgot == NULL)
1055 {
1056 if (htab->elf.dynobj == NULL)
1057 htab->elf.dynobj = abfd;
1058 if (!create_got_section (htab->elf.dynobj, info))
1059 return FALSE;
1060 }
1061 break;
1062
1063 case R_SPARC_TLS_GD_CALL:
1064 case R_SPARC_TLS_LDM_CALL:
1065 if (info->shared)
1066 {
1067 /* These are basically R_SPARC_TLS_WPLT30 relocs against
1068 __tls_get_addr. */
1069 struct bfd_link_hash_entry *bh = NULL;
1070 if (! _bfd_generic_link_add_one_symbol (info, abfd,
1071 "__tls_get_addr", 0,
1072 bfd_und_section_ptr, 0,
1073 NULL, FALSE, FALSE,
1074 &bh))
1075 return FALSE;
1076 h = (struct elf_link_hash_entry *) bh;
1077 }
1078 else
1079 break;
1080 /* Fall through */
1081
1082 case R_SPARC_PLT32:
1083 case R_SPARC_WPLT30:
1084 /* This symbol requires a procedure linkage table entry. We
1085 actually build the entry in adjust_dynamic_symbol,
1086 because this might be a case of linking PIC code without
1087 linking in any dynamic objects, in which case we don't
1088 need to generate a procedure linkage table after all. */
1089
1090 if (h == NULL)
1091 {
1092 /* The Solaris native assembler will generate a WPLT30
1093 reloc for a local symbol if you assemble a call from
1094 one section to another when using -K pic. We treat
1095 it as WDISP30. */
1096 if (ELF32_R_TYPE (rel->r_info) == R_SPARC_PLT32)
1097 goto r_sparc_plt32;
1098 break;
1099 }
1100
1101 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
1102
1103 if (ELF32_R_TYPE (rel->r_info) == R_SPARC_PLT32)
1104 goto r_sparc_plt32;
1105 h->plt.refcount += 1;
1106 break;
1107
1108 case R_SPARC_PC10:
1109 case R_SPARC_PC22:
1110 if (h != NULL)
1111 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
1112
1113 if (h != NULL
1114 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1115 break;
1116 /* Fall through. */
1117
1118 case R_SPARC_DISP8:
1119 case R_SPARC_DISP16:
1120 case R_SPARC_DISP32:
1121 case R_SPARC_WDISP30:
1122 case R_SPARC_WDISP22:
1123 case R_SPARC_WDISP19:
1124 case R_SPARC_WDISP16:
1125 case R_SPARC_8:
1126 case R_SPARC_16:
1127 case R_SPARC_32:
1128 case R_SPARC_HI22:
1129 case R_SPARC_22:
1130 case R_SPARC_13:
1131 case R_SPARC_LO10:
1132 case R_SPARC_UA16:
1133 case R_SPARC_UA32:
1134 if (h != NULL)
1135 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
1136
1137 r_sparc_plt32:
1138 if (h != NULL && !info->shared)
1139 {
1140 /* We may need a .plt entry if the function this reloc
1141 refers to is in a shared lib. */
1142 h->plt.refcount += 1;
1143 }
1144
1145 /* If we are creating a shared library, and this is a reloc
1146 against a global symbol, or a non PC relative reloc
1147 against a local symbol, then we need to copy the reloc
1148 into the shared library. However, if we are linking with
1149 -Bsymbolic, we do not need to copy a reloc against a
1150 global symbol which is defined in an object we are
1151 including in the link (i.e., DEF_REGULAR is set). At
1152 this point we have not seen all the input files, so it is
1153 possible that DEF_REGULAR is not set now but will be set
1154 later (it is never cleared). In case of a weak definition,
1155 DEF_REGULAR may be cleared later by a strong definition in
1156 a shared library. We account for that possibility below by
1157 storing information in the relocs_copied field of the hash
1158 table entry. A similar situation occurs when creating
1159 shared libraries and symbol visibility changes render the
1160 symbol local.
1161
1162 If on the other hand, we are creating an executable, we
1163 may need to keep relocations for symbols satisfied by a
1164 dynamic library if we manage to avoid copy relocs for the
1165 symbol. */
1166 if ((info->shared
1167 && (sec->flags & SEC_ALLOC) != 0
1168 && (! _bfd_sparc_elf_howto_table[r_type].pc_relative
1169 || (h != NULL
1170 && (! info->symbolic
1171 || h->root.type == bfd_link_hash_defweak
1172 || (h->elf_link_hash_flags
1173 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
1174 || (!info->shared
1175 && (sec->flags & SEC_ALLOC) != 0
1176 && h != NULL
1177 && (h->root.type == bfd_link_hash_defweak
1178 || (h->elf_link_hash_flags
1179 & ELF_LINK_HASH_DEF_REGULAR) == 0)))
1180 {
1181 struct elf32_sparc_dyn_relocs *p;
1182 struct elf32_sparc_dyn_relocs **head;
1183
1184 /* When creating a shared object, we must copy these
1185 relocs into the output file. We create a reloc
1186 section in dynobj and make room for the reloc. */
1187 if (sreloc == NULL)
1188 {
1189 const char *name;
1190 bfd *dynobj;
1191
1192 name = (bfd_elf_string_from_elf_section
1193 (abfd,
1194 elf_elfheader (abfd)->e_shstrndx,
1195 elf_section_data (sec)->rel_hdr.sh_name));
1196 if (name == NULL)
1197 return FALSE;
1198
1199 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
1200 && strcmp (bfd_get_section_name (abfd, sec),
1201 name + 5) == 0);
1202
1203 if (htab->elf.dynobj == NULL)
1204 htab->elf.dynobj = abfd;
1205 dynobj = htab->elf.dynobj;
1206
1207 sreloc = bfd_get_section_by_name (dynobj, name);
1208 if (sreloc == NULL)
1209 {
1210 flagword flags;
1211
1212 sreloc = bfd_make_section (dynobj, name);
1213 flags = (SEC_HAS_CONTENTS | SEC_READONLY
1214 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1215 if ((sec->flags & SEC_ALLOC) != 0)
1216 flags |= SEC_ALLOC | SEC_LOAD;
1217 if (sreloc == NULL
1218 || ! bfd_set_section_flags (dynobj, sreloc, flags)
1219 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
1220 return FALSE;
1221 }
1222 elf_section_data (sec)->sreloc = sreloc;
1223 }
1224
1225 /* If this is a global symbol, we count the number of
1226 relocations we need for this symbol. */
1227 if (h != NULL)
1228 head = &((struct elf32_sparc_link_hash_entry *) h)->dyn_relocs;
1229 else
1230 {
1231 /* Track dynamic relocs needed for local syms too.
1232 We really need local syms available to do this
1233 easily. Oh well. */
1234
1235 asection *s;
1236 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
1237 sec, r_symndx);
1238 if (s == NULL)
1239 return FALSE;
1240
1241 head = ((struct elf32_sparc_dyn_relocs **)
1242 &elf_section_data (s)->local_dynrel);
1243 }
1244
1245 p = *head;
1246 if (p == NULL || p->sec != sec)
1247 {
1248 bfd_size_type amt = sizeof *p;
1249 p = ((struct elf32_sparc_dyn_relocs *)
1250 bfd_alloc (htab->elf.dynobj, amt));
1251 if (p == NULL)
1252 return FALSE;
1253 p->next = *head;
1254 *head = p;
1255 p->sec = sec;
1256 p->count = 0;
1257 p->pc_count = 0;
1258 }
1259
1260 p->count += 1;
1261 if (_bfd_sparc_elf_howto_table[r_type].pc_relative)
1262 p->pc_count += 1;
1263 }
1264
1265 break;
1266
1267 case R_SPARC_GNU_VTINHERIT:
1268 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1269 return FALSE;
1270 break;
1271
1272 case R_SPARC_GNU_VTENTRY:
1273 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1274 return FALSE;
1275 break;
1276
1277 default:
1278 break;
1279 }
1280 }
1281
1282 return TRUE;
1283 }
1284
1285 static asection *
1286 elf32_sparc_gc_mark_hook (sec, info, rel, h, sym)
1287 asection *sec;
1288 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1289 Elf_Internal_Rela *rel;
1290 struct elf_link_hash_entry *h;
1291 Elf_Internal_Sym *sym;
1292 {
1293 if (h != NULL)
1294 {
1295 switch (ELF32_R_TYPE (rel->r_info))
1296 {
1297 case R_SPARC_GNU_VTINHERIT:
1298 case R_SPARC_GNU_VTENTRY:
1299 break;
1300
1301 default:
1302 switch (h->root.type)
1303 {
1304 case bfd_link_hash_defined:
1305 case bfd_link_hash_defweak:
1306 return h->root.u.def.section;
1307
1308 case bfd_link_hash_common:
1309 return h->root.u.c.p->section;
1310
1311 default:
1312 break;
1313 }
1314 }
1315 }
1316 else
1317 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
1318
1319 return NULL;
1320 }
1321
1322 /* Update the got entry reference counts for the section being removed. */
1323 static bfd_boolean
1324 elf32_sparc_gc_sweep_hook (abfd, info, sec, relocs)
1325 bfd *abfd;
1326 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1327 asection *sec;
1328 const Elf_Internal_Rela *relocs;
1329 {
1330 Elf_Internal_Shdr *symtab_hdr;
1331 struct elf_link_hash_entry **sym_hashes;
1332 bfd_signed_vma *local_got_refcounts;
1333 const Elf_Internal_Rela *rel, *relend;
1334
1335 elf_section_data (sec)->local_dynrel = NULL;
1336
1337 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1338 sym_hashes = elf_sym_hashes (abfd);
1339 local_got_refcounts = elf_local_got_refcounts (abfd);
1340
1341 relend = relocs + sec->reloc_count;
1342 for (rel = relocs; rel < relend; rel++)
1343 {
1344 unsigned long r_symndx;
1345 unsigned int r_type;
1346 struct elf_link_hash_entry *h = NULL;
1347
1348 r_symndx = ELF32_R_SYM (rel->r_info);
1349 if (r_symndx >= symtab_hdr->sh_info)
1350 {
1351 struct elf32_sparc_link_hash_entry *eh;
1352 struct elf32_sparc_dyn_relocs **pp;
1353 struct elf32_sparc_dyn_relocs *p;
1354
1355 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1356 eh = (struct elf32_sparc_link_hash_entry *) h;
1357 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1358 if (p->sec == sec)
1359 {
1360 /* Everything must go for SEC. */
1361 *pp = p->next;
1362 break;
1363 }
1364 }
1365
1366 r_type = ELF32_R_TYPE (rel->r_info);
1367 r_type = elf32_sparc_tls_transition (info, abfd, r_type, h != NULL);
1368 switch (r_type)
1369 {
1370 case R_SPARC_TLS_LDM_HI22:
1371 case R_SPARC_TLS_LDM_LO10:
1372 if (elf32_sparc_hash_table (info)->tls_ldm_got.refcount > 0)
1373 elf32_sparc_hash_table (info)->tls_ldm_got.refcount -= 1;
1374 break;
1375
1376 case R_SPARC_TLS_GD_HI22:
1377 case R_SPARC_TLS_GD_LO10:
1378 case R_SPARC_TLS_IE_HI22:
1379 case R_SPARC_TLS_IE_LO10:
1380 case R_SPARC_GOT10:
1381 case R_SPARC_GOT13:
1382 case R_SPARC_GOT22:
1383 if (h != NULL)
1384 {
1385 if (h->got.refcount > 0)
1386 h->got.refcount--;
1387 }
1388 else
1389 {
1390 if (local_got_refcounts[r_symndx] > 0)
1391 local_got_refcounts[r_symndx]--;
1392 }
1393 break;
1394
1395 case R_SPARC_PC10:
1396 case R_SPARC_PC22:
1397 if (h != NULL
1398 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1399 break;
1400 /* Fall through. */
1401
1402 case R_SPARC_DISP8:
1403 case R_SPARC_DISP16:
1404 case R_SPARC_DISP32:
1405 case R_SPARC_WDISP30:
1406 case R_SPARC_WDISP22:
1407 case R_SPARC_WDISP19:
1408 case R_SPARC_WDISP16:
1409 case R_SPARC_8:
1410 case R_SPARC_16:
1411 case R_SPARC_32:
1412 case R_SPARC_HI22:
1413 case R_SPARC_22:
1414 case R_SPARC_13:
1415 case R_SPARC_LO10:
1416 case R_SPARC_UA16:
1417 case R_SPARC_UA32:
1418 case R_SPARC_PLT32:
1419 if (info->shared)
1420 break;
1421 /* Fall through. */
1422
1423 case R_SPARC_WPLT30:
1424 if (h != NULL)
1425 {
1426 if (h->plt.refcount > 0)
1427 h->plt.refcount--;
1428 }
1429 break;
1430
1431 default:
1432 break;
1433 }
1434 }
1435
1436 return TRUE;
1437 }
1438
1439 /* Adjust a symbol defined by a dynamic object and referenced by a
1440 regular object. The current definition is in some section of the
1441 dynamic object, but we're not including those sections. We have to
1442 change the definition to something the rest of the link can
1443 understand. */
1444
1445 static bfd_boolean
1446 elf32_sparc_adjust_dynamic_symbol (info, h)
1447 struct bfd_link_info *info;
1448 struct elf_link_hash_entry *h;
1449 {
1450 struct elf32_sparc_link_hash_table *htab;
1451 struct elf32_sparc_link_hash_entry * eh;
1452 struct elf32_sparc_dyn_relocs *p;
1453 asection *s;
1454 unsigned int power_of_two;
1455
1456 htab = elf32_sparc_hash_table (info);
1457
1458 /* Make sure we know what is going on here. */
1459 BFD_ASSERT (htab->elf.dynobj != NULL
1460 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
1461 || h->weakdef != NULL
1462 || ((h->elf_link_hash_flags
1463 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1464 && (h->elf_link_hash_flags
1465 & ELF_LINK_HASH_REF_REGULAR) != 0
1466 && (h->elf_link_hash_flags
1467 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
1468
1469 /* If this is a function, put it in the procedure linkage table. We
1470 will fill in the contents of the procedure linkage table later
1471 (although we could actually do it here). The STT_NOTYPE
1472 condition is a hack specifically for the Oracle libraries
1473 delivered for Solaris; for some inexplicable reason, they define
1474 some of their functions as STT_NOTYPE when they really should be
1475 STT_FUNC. */
1476 if (h->type == STT_FUNC
1477 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0
1478 || (h->type == STT_NOTYPE
1479 && (h->root.type == bfd_link_hash_defined
1480 || h->root.type == bfd_link_hash_defweak)
1481 && (h->root.u.def.section->flags & SEC_CODE) != 0))
1482 {
1483 if (h->plt.refcount <= 0
1484 || (! info->shared
1485 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
1486 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0
1487 && h->root.type != bfd_link_hash_undefweak
1488 && h->root.type != bfd_link_hash_undefined))
1489 {
1490 /* This case can occur if we saw a WPLT30 reloc in an input
1491 file, but the symbol was never referred to by a dynamic
1492 object, or if all references were garbage collected. In
1493 such a case, we don't actually need to build a procedure
1494 linkage table, and we can just do a WDISP30 reloc instead. */
1495 h->plt.offset = (bfd_vma) -1;
1496 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1497 }
1498
1499 return TRUE;
1500 }
1501 else
1502 h->plt.offset = (bfd_vma) -1;
1503
1504 /* If this is a weak symbol, and there is a real definition, the
1505 processor independent code will have arranged for us to see the
1506 real definition first, and we can just use the same value. */
1507 if (h->weakdef != NULL)
1508 {
1509 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
1510 || h->weakdef->root.type == bfd_link_hash_defweak);
1511 h->root.u.def.section = h->weakdef->root.u.def.section;
1512 h->root.u.def.value = h->weakdef->root.u.def.value;
1513 return TRUE;
1514 }
1515
1516 /* This is a reference to a symbol defined by a dynamic object which
1517 is not a function. */
1518
1519 /* If we are creating a shared library, we must presume that the
1520 only references to the symbol are via the global offset table.
1521 For such cases we need not do anything here; the relocations will
1522 be handled correctly by relocate_section. */
1523 if (info->shared)
1524 return TRUE;
1525
1526 /* If there are no references to this symbol that do not use the
1527 GOT, we don't need to generate a copy reloc. */
1528 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
1529 return TRUE;
1530
1531 eh = (struct elf32_sparc_link_hash_entry *) h;
1532 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1533 {
1534 s = p->sec->output_section;
1535 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1536 break;
1537 }
1538
1539 /* If we didn't find any dynamic relocs in read-only sections, then
1540 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1541 if (p == NULL)
1542 {
1543 h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
1544 return TRUE;
1545 }
1546
1547 /* We must allocate the symbol in our .dynbss section, which will
1548 become part of the .bss section of the executable. There will be
1549 an entry for this symbol in the .dynsym section. The dynamic
1550 object will contain position independent code, so all references
1551 from the dynamic object to this symbol will go through the global
1552 offset table. The dynamic linker will use the .dynsym entry to
1553 determine the address it must put in the global offset table, so
1554 both the dynamic object and the regular object will refer to the
1555 same memory location for the variable. */
1556
1557 /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker
1558 to copy the initial value out of the dynamic object and into the
1559 runtime process image. We need to remember the offset into the
1560 .rel.bss section we are going to use. */
1561 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1562 {
1563 htab->srelbss->size += sizeof (Elf32_External_Rela);
1564 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
1565 }
1566
1567 /* We need to figure out the alignment required for this symbol. I
1568 have no idea how ELF linkers handle this. */
1569 power_of_two = bfd_log2 (h->size);
1570 if (power_of_two > 3)
1571 power_of_two = 3;
1572
1573 /* Apply the required alignment. */
1574 s = htab->sdynbss;
1575 s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
1576 if (power_of_two > bfd_get_section_alignment (dynobj, s))
1577 {
1578 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
1579 return FALSE;
1580 }
1581
1582 /* Define the symbol as being at this point in the section. */
1583 h->root.u.def.section = s;
1584 h->root.u.def.value = s->size;
1585
1586 /* Increment the section size to make room for the symbol. */
1587 s->size += h->size;
1588
1589 return TRUE;
1590 }
1591
1592 /* Allocate space in .plt, .got and associated reloc sections for
1593 dynamic relocs. */
1594
1595 static bfd_boolean
1596 allocate_dynrelocs (h, inf)
1597 struct elf_link_hash_entry *h;
1598 PTR inf;
1599 {
1600 struct bfd_link_info *info;
1601 struct elf32_sparc_link_hash_table *htab;
1602 struct elf32_sparc_link_hash_entry *eh;
1603 struct elf32_sparc_dyn_relocs *p;
1604
1605 if (h->root.type == bfd_link_hash_indirect)
1606 return TRUE;
1607
1608 if (h->root.type == bfd_link_hash_warning)
1609 /* When warning symbols are created, they **replace** the "real"
1610 entry in the hash table, thus we never get to see the real
1611 symbol in a hash traversal. So look at it now. */
1612 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1613
1614 info = (struct bfd_link_info *) inf;
1615 htab = elf32_sparc_hash_table (info);
1616
1617 if (htab->elf.dynamic_sections_created
1618 && h->plt.refcount > 0)
1619 {
1620 /* Make sure this symbol is output as a dynamic symbol.
1621 Undefined weak syms won't yet be marked as dynamic. */
1622 if (h->dynindx == -1
1623 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1624 {
1625 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1626 return FALSE;
1627 }
1628
1629 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
1630 {
1631 asection *s = htab->splt;
1632
1633 /* The first four entries in .plt are reserved. */
1634 if (s->size == 0)
1635 s->size = 4 * PLT_ENTRY_SIZE;
1636
1637 /* The procedure linkage table has a maximum size. */
1638 if (s->size >= 0x400000)
1639 {
1640 bfd_set_error (bfd_error_bad_value);
1641 return FALSE;
1642 }
1643
1644 h->plt.offset = s->size;
1645
1646 /* If this symbol is not defined in a regular file, and we are
1647 not generating a shared library, then set the symbol to this
1648 location in the .plt. This is required to make function
1649 pointers compare as equal between the normal executable and
1650 the shared library. */
1651 if (! info->shared
1652 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1653 {
1654 h->root.u.def.section = s;
1655 h->root.u.def.value = h->plt.offset;
1656 }
1657
1658 /* Make room for this entry. */
1659 s->size += PLT_ENTRY_SIZE;
1660
1661 /* We also need to make an entry in the .rela.plt section. */
1662 htab->srelplt->size += sizeof (Elf32_External_Rela);
1663 }
1664 else
1665 {
1666 h->plt.offset = (bfd_vma) -1;
1667 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1668 }
1669 }
1670 else
1671 {
1672 h->plt.offset = (bfd_vma) -1;
1673 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1674 }
1675
1676 /* If R_SPARC_TLS_IE_{HI22,LO10} symbol is now local to the binary,
1677 make it a R_SPARC_TLS_LE_{HI22,LO10} requiring no TLS entry. */
1678 if (h->got.refcount > 0
1679 && !info->shared
1680 && h->dynindx == -1
1681 && elf32_sparc_hash_entry(h)->tls_type == GOT_TLS_IE)
1682 h->got.offset = (bfd_vma) -1;
1683 else if (h->got.refcount > 0)
1684 {
1685 asection *s;
1686 bfd_boolean dyn;
1687 int tls_type = elf32_sparc_hash_entry(h)->tls_type;
1688
1689 /* Make sure this symbol is output as a dynamic symbol.
1690 Undefined weak syms won't yet be marked as dynamic. */
1691 if (h->dynindx == -1
1692 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1693 {
1694 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1695 return FALSE;
1696 }
1697
1698 s = htab->sgot;
1699 h->got.offset = s->size;
1700 s->size += 4;
1701 /* R_SPARC_TLS_GD_HI{22,LO10} needs 2 consecutive GOT slots. */
1702 if (tls_type == GOT_TLS_GD)
1703 s->size += 4;
1704 dyn = htab->elf.dynamic_sections_created;
1705 /* R_SPARC_TLS_IE_{HI22,LO10} needs one dynamic relocation,
1706 R_SPARC_TLS_GD_{HI22,LO10} needs one if local symbol and two if
1707 global. */
1708 if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
1709 || tls_type == GOT_TLS_IE)
1710 htab->srelgot->size += sizeof (Elf32_External_Rela);
1711 else if (tls_type == GOT_TLS_GD)
1712 htab->srelgot->size += 2 * sizeof (Elf32_External_Rela);
1713 else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
1714 htab->srelgot->size += sizeof (Elf32_External_Rela);
1715 }
1716 else
1717 h->got.offset = (bfd_vma) -1;
1718
1719 eh = (struct elf32_sparc_link_hash_entry *) h;
1720 if (eh->dyn_relocs == NULL)
1721 return TRUE;
1722
1723 /* In the shared -Bsymbolic case, discard space allocated for
1724 dynamic pc-relative relocs against symbols which turn out to be
1725 defined in regular objects. For the normal shared case, discard
1726 space for pc-relative relocs that have become local due to symbol
1727 visibility changes. */
1728
1729 if (info->shared)
1730 {
1731 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
1732 && ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
1733 || info->symbolic))
1734 {
1735 struct elf32_sparc_dyn_relocs **pp;
1736
1737 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1738 {
1739 p->count -= p->pc_count;
1740 p->pc_count = 0;
1741 if (p->count == 0)
1742 *pp = p->next;
1743 else
1744 pp = &p->next;
1745 }
1746 }
1747 }
1748 else
1749 {
1750 /* For the non-shared case, discard space for relocs against
1751 symbols which turn out to need copy relocs or are not
1752 dynamic. */
1753
1754 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
1755 && (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1756 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1757 || (htab->elf.dynamic_sections_created
1758 && (h->root.type == bfd_link_hash_undefweak
1759 || h->root.type == bfd_link_hash_undefined))))
1760 {
1761 /* Make sure this symbol is output as a dynamic symbol.
1762 Undefined weak syms won't yet be marked as dynamic. */
1763 if (h->dynindx == -1
1764 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1765 {
1766 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1767 return FALSE;
1768 }
1769
1770 /* If that succeeded, we know we'll be keeping all the
1771 relocs. */
1772 if (h->dynindx != -1)
1773 goto keep;
1774 }
1775
1776 eh->dyn_relocs = NULL;
1777
1778 keep: ;
1779 }
1780
1781 /* Finally, allocate space. */
1782 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1783 {
1784 asection *sreloc = elf_section_data (p->sec)->sreloc;
1785 sreloc->size += p->count * sizeof (Elf32_External_Rela);
1786 }
1787
1788 return TRUE;
1789 }
1790
1791 /* Find any dynamic relocs that apply to read-only sections. */
1792
1793 static bfd_boolean
1794 readonly_dynrelocs (h, inf)
1795 struct elf_link_hash_entry *h;
1796 PTR inf;
1797 {
1798 struct elf32_sparc_link_hash_entry *eh;
1799 struct elf32_sparc_dyn_relocs *p;
1800
1801 if (h->root.type == bfd_link_hash_warning)
1802 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1803
1804 eh = (struct elf32_sparc_link_hash_entry *) h;
1805 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1806 {
1807 asection *s = p->sec->output_section;
1808
1809 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1810 {
1811 struct bfd_link_info *info = (struct bfd_link_info *) inf;
1812
1813 info->flags |= DF_TEXTREL;
1814
1815 /* Not an error, just cut short the traversal. */
1816 return FALSE;
1817 }
1818 }
1819 return TRUE;
1820 }
1821
1822 /* Set the sizes of the dynamic sections. */
1823
1824 static bfd_boolean
1825 elf32_sparc_size_dynamic_sections (output_bfd, info)
1826 bfd *output_bfd ATTRIBUTE_UNUSED;
1827 struct bfd_link_info *info;
1828 {
1829 struct elf32_sparc_link_hash_table *htab;
1830 bfd *dynobj;
1831 asection *s;
1832 bfd *ibfd;
1833
1834 htab = elf32_sparc_hash_table (info);
1835 dynobj = htab->elf.dynobj;
1836 BFD_ASSERT (dynobj != NULL);
1837
1838 if (elf_hash_table (info)->dynamic_sections_created)
1839 {
1840 /* Set the contents of the .interp section to the interpreter. */
1841 if (info->executable)
1842 {
1843 s = bfd_get_section_by_name (dynobj, ".interp");
1844 BFD_ASSERT (s != NULL);
1845 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1846 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1847 }
1848 }
1849
1850 /* Set up .got offsets for local syms, and space for local dynamic
1851 relocs. */
1852 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1853 {
1854 bfd_signed_vma *local_got;
1855 bfd_signed_vma *end_local_got;
1856 char *local_tls_type;
1857 bfd_size_type locsymcount;
1858 Elf_Internal_Shdr *symtab_hdr;
1859 asection *srel;
1860
1861 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
1862 continue;
1863
1864 for (s = ibfd->sections; s != NULL; s = s->next)
1865 {
1866 struct elf32_sparc_dyn_relocs *p;
1867
1868 for (p = *((struct elf32_sparc_dyn_relocs **)
1869 &elf_section_data (s)->local_dynrel);
1870 p != NULL;
1871 p = p->next)
1872 {
1873 if (!bfd_is_abs_section (p->sec)
1874 && bfd_is_abs_section (p->sec->output_section))
1875 {
1876 /* Input section has been discarded, either because
1877 it is a copy of a linkonce section or due to
1878 linker script /DISCARD/, so we'll be discarding
1879 the relocs too. */
1880 }
1881 else if (p->count != 0)
1882 {
1883 srel = elf_section_data (p->sec)->sreloc;
1884 srel->size += p->count * sizeof (Elf32_External_Rela);
1885 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
1886 info->flags |= DF_TEXTREL;
1887 }
1888 }
1889 }
1890
1891 local_got = elf_local_got_refcounts (ibfd);
1892 if (!local_got)
1893 continue;
1894
1895 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1896 locsymcount = symtab_hdr->sh_info;
1897 end_local_got = local_got + locsymcount;
1898 local_tls_type = elf32_sparc_local_got_tls_type (ibfd);
1899 s = htab->sgot;
1900 srel = htab->srelgot;
1901 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
1902 {
1903 if (*local_got > 0)
1904 {
1905 *local_got = s->size;
1906 s->size += 4;
1907 if (*local_tls_type == GOT_TLS_GD)
1908 s->size += 4;
1909 if (info->shared
1910 || *local_tls_type == GOT_TLS_GD
1911 || *local_tls_type == GOT_TLS_IE)
1912 srel->size += sizeof (Elf32_External_Rela);
1913 }
1914 else
1915 *local_got = (bfd_vma) -1;
1916 }
1917 }
1918
1919 if (htab->tls_ldm_got.refcount > 0)
1920 {
1921 /* Allocate 2 got entries and 1 dynamic reloc for
1922 R_SPARC_TLS_LDM_{HI22,LO10} relocs. */
1923 htab->tls_ldm_got.offset = htab->sgot->size;
1924 htab->sgot->size += 8;
1925 htab->srelgot->size += sizeof (Elf32_External_Rela);
1926 }
1927 else
1928 htab->tls_ldm_got.offset = -1;
1929
1930 /* Allocate global sym .plt and .got entries, and space for global
1931 sym dynamic relocs. */
1932 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
1933
1934 if (elf_hash_table (info)->dynamic_sections_created)
1935 {
1936 /* Make space for the trailing nop in .plt. */
1937 if (htab->splt->size > 0)
1938 htab->splt->size += 4;
1939
1940 /* If the .got section is more than 0x1000 bytes, we add
1941 0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13
1942 bit relocations have a greater chance of working. */
1943 if (htab->sgot->size >= 0x1000
1944 && elf_hash_table (info)->hgot->root.u.def.value == 0)
1945 elf_hash_table (info)->hgot->root.u.def.value = 0x1000;
1946 }
1947
1948 /* The check_relocs and adjust_dynamic_symbol entry points have
1949 determined the sizes of the various dynamic sections. Allocate
1950 memory for them. */
1951 for (s = dynobj->sections; s != NULL; s = s->next)
1952 {
1953 const char *name;
1954 bfd_boolean strip = FALSE;
1955
1956 if ((s->flags & SEC_LINKER_CREATED) == 0)
1957 continue;
1958
1959 /* It's OK to base decisions on the section name, because none
1960 of the dynobj section names depend upon the input files. */
1961 name = bfd_get_section_name (dynobj, s);
1962
1963 if (strncmp (name, ".rela", 5) == 0)
1964 {
1965 if (s->size == 0)
1966 {
1967 /* If we don't need this section, strip it from the
1968 output file. This is to handle .rela.bss and
1969 .rel.plt. We must create it in
1970 create_dynamic_sections, because it must be created
1971 before the linker maps input sections to output
1972 sections. The linker does that before
1973 adjust_dynamic_symbol is called, and it is that
1974 function which decides whether anything needs to go
1975 into these sections. */
1976 strip = TRUE;
1977 }
1978 else
1979 {
1980 /* We use the reloc_count field as a counter if we need
1981 to copy relocs into the output file. */
1982 s->reloc_count = 0;
1983 }
1984 }
1985 else if (s != htab->splt && s != htab->sgot)
1986 {
1987 /* It's not one of our sections, so don't allocate space. */
1988 continue;
1989 }
1990
1991 if (strip)
1992 {
1993 _bfd_strip_section_from_output (info, s);
1994 continue;
1995 }
1996
1997 /* Allocate memory for the section contents. */
1998 /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
1999 Unused entries should be reclaimed before the section's contents
2000 are written out, but at the moment this does not happen. Thus in
2001 order to prevent writing out garbage, we initialise the section's
2002 contents to zero. */
2003 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2004 if (s->contents == NULL && s->size != 0)
2005 return FALSE;
2006 }
2007
2008 if (elf_hash_table (info)->dynamic_sections_created)
2009 {
2010 /* Add some entries to the .dynamic section. We fill in the
2011 values later, in elf32_sparc_finish_dynamic_sections, but we
2012 must add the entries now so that we get the correct size for
2013 the .dynamic section. The DT_DEBUG entry is filled in by the
2014 dynamic linker and used by the debugger. */
2015 #define add_dynamic_entry(TAG, VAL) \
2016 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2017
2018 if (info->executable)
2019 {
2020 if (!add_dynamic_entry (DT_DEBUG, 0))
2021 return FALSE;
2022 }
2023
2024 if (htab->srelplt->size != 0)
2025 {
2026 if (!add_dynamic_entry (DT_PLTGOT, 0)
2027 || !add_dynamic_entry (DT_PLTRELSZ, 0)
2028 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2029 || !add_dynamic_entry (DT_JMPREL, 0))
2030 return FALSE;
2031 }
2032
2033 if (!add_dynamic_entry (DT_RELA, 0)
2034 || !add_dynamic_entry (DT_RELASZ, 0)
2035 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
2036 return FALSE;
2037
2038 /* If any dynamic relocs apply to a read-only section,
2039 then we need a DT_TEXTREL entry. */
2040 if ((info->flags & DF_TEXTREL) == 0)
2041 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
2042 (PTR) info);
2043
2044 if (info->flags & DF_TEXTREL)
2045 {
2046 if (!add_dynamic_entry (DT_TEXTREL, 0))
2047 return FALSE;
2048 }
2049 }
2050 #undef add_dynamic_entry
2051
2052 return TRUE;
2053 }
2054
2055 struct elf32_sparc_section_data
2056 {
2057 struct bfd_elf_section_data elf;
2058 unsigned int do_relax;
2059 };
2060
2061 #define sec_do_relax(sec) \
2062 ((struct elf32_sparc_section_data *) elf_section_data (sec))->do_relax
2063
2064 static bfd_boolean
2065 elf32_sparc_new_section_hook (abfd, sec)
2066 bfd *abfd;
2067 asection *sec;
2068 {
2069 struct elf32_sparc_section_data *sdata;
2070 bfd_size_type amt = sizeof (*sdata);
2071
2072 sdata = (struct elf32_sparc_section_data *) bfd_zalloc (abfd, amt);
2073 if (sdata == NULL)
2074 return FALSE;
2075 sec->used_by_bfd = (PTR) sdata;
2076
2077 return _bfd_elf_new_section_hook (abfd, sec);
2078 }
2079
2080 static bfd_boolean
2081 elf32_sparc_relax_section (abfd, section, link_info, again)
2082 bfd *abfd ATTRIBUTE_UNUSED;
2083 asection *section ATTRIBUTE_UNUSED;
2084 struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
2085 bfd_boolean *again;
2086 {
2087 *again = FALSE;
2088 sec_do_relax (section) = 1;
2089 return TRUE;
2090 }
2091
2092 /* Return the base VMA address which should be subtracted from real addresses
2093 when resolving @dtpoff relocation.
2094 This is PT_TLS segment p_vaddr. */
2095
2096 static bfd_vma
2097 dtpoff_base (info)
2098 struct bfd_link_info *info;
2099 {
2100 /* If tls_sec is NULL, we should have signalled an error already. */
2101 if (elf_hash_table (info)->tls_sec == NULL)
2102 return 0;
2103 return elf_hash_table (info)->tls_sec->vma;
2104 }
2105
2106 /* Return the relocation value for @tpoff relocation
2107 if STT_TLS virtual address is ADDRESS. */
2108
2109 static bfd_vma
2110 tpoff (info, address)
2111 struct bfd_link_info *info;
2112 bfd_vma address;
2113 {
2114 struct elf_link_hash_table *htab = elf_hash_table (info);
2115
2116 /* If tls_sec is NULL, we should have signalled an error already. */
2117 if (htab->tls_sec == NULL)
2118 return 0;
2119 return address - htab->tls_size - htab->tls_sec->vma;
2120 }
2121
2122 /* Relocate a SPARC ELF section. */
2123
2124 static bfd_boolean
2125 elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section,
2126 contents, relocs, local_syms, local_sections)
2127 bfd *output_bfd;
2128 struct bfd_link_info *info;
2129 bfd *input_bfd;
2130 asection *input_section;
2131 bfd_byte *contents;
2132 Elf_Internal_Rela *relocs;
2133 Elf_Internal_Sym *local_syms;
2134 asection **local_sections;
2135 {
2136 struct elf32_sparc_link_hash_table *htab;
2137 Elf_Internal_Shdr *symtab_hdr;
2138 struct elf_link_hash_entry **sym_hashes;
2139 bfd_vma *local_got_offsets;
2140 bfd_vma got_base;
2141 asection *sreloc;
2142 Elf_Internal_Rela *rel;
2143 Elf_Internal_Rela *relend;
2144
2145 if (info->relocatable)
2146 return TRUE;
2147
2148 htab = elf32_sparc_hash_table (info);
2149 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2150 sym_hashes = elf_sym_hashes (input_bfd);
2151 local_got_offsets = elf_local_got_offsets (input_bfd);
2152
2153 if (elf_hash_table (info)->hgot == NULL)
2154 got_base = 0;
2155 else
2156 got_base = elf_hash_table (info)->hgot->root.u.def.value;
2157
2158 sreloc = elf_section_data (input_section)->sreloc;
2159
2160 rel = relocs;
2161 relend = relocs + input_section->reloc_count;
2162 for (; rel < relend; rel++)
2163 {
2164 int r_type, tls_type;
2165 reloc_howto_type *howto;
2166 unsigned long r_symndx;
2167 struct elf_link_hash_entry *h;
2168 Elf_Internal_Sym *sym;
2169 asection *sec;
2170 bfd_vma relocation, off;
2171 bfd_reloc_status_type r;
2172 bfd_boolean is_plt = FALSE;
2173 bfd_boolean unresolved_reloc;
2174
2175 r_type = ELF32_R_TYPE (rel->r_info);
2176
2177 if (r_type == R_SPARC_GNU_VTINHERIT
2178 || r_type == R_SPARC_GNU_VTENTRY)
2179 continue;
2180
2181 if (r_type < 0 || r_type >= (int) R_SPARC_max_std)
2182 {
2183 bfd_set_error (bfd_error_bad_value);
2184 return FALSE;
2185 }
2186 howto = _bfd_sparc_elf_howto_table + r_type;
2187
2188 /* This is a final link. */
2189 r_symndx = ELF32_R_SYM (rel->r_info);
2190 h = NULL;
2191 sym = NULL;
2192 sec = NULL;
2193 unresolved_reloc = FALSE;
2194 if (r_symndx < symtab_hdr->sh_info)
2195 {
2196 sym = local_syms + r_symndx;
2197 sec = local_sections[r_symndx];
2198 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2199 }
2200 else
2201 {
2202 bfd_boolean warned ATTRIBUTE_UNUSED;
2203
2204 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2205 r_symndx, symtab_hdr, sym_hashes,
2206 h, sec, relocation,
2207 unresolved_reloc, warned);
2208 }
2209
2210 switch (r_type)
2211 {
2212 case R_SPARC_GOT10:
2213 case R_SPARC_GOT13:
2214 case R_SPARC_GOT22:
2215 /* Relocation is to the entry for this symbol in the global
2216 offset table. */
2217 if (htab->sgot == NULL)
2218 abort ();
2219
2220 if (h != NULL)
2221 {
2222 bfd_boolean dyn;
2223
2224 off = h->got.offset;
2225 BFD_ASSERT (off != (bfd_vma) -1);
2226 dyn = elf_hash_table (info)->dynamic_sections_created;
2227
2228 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2229 || (info->shared
2230 && (info->symbolic
2231 || h->dynindx == -1
2232 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
2233 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
2234 {
2235 /* This is actually a static link, or it is a
2236 -Bsymbolic link and the symbol is defined
2237 locally, or the symbol was forced to be local
2238 because of a version file. We must initialize
2239 this entry in the global offset table. Since the
2240 offset must always be a multiple of 4, we use the
2241 least significant bit to record whether we have
2242 initialized it already.
2243
2244 When doing a dynamic link, we create a .rela.got
2245 relocation entry to initialize the value. This
2246 is done in the finish_dynamic_symbol routine. */
2247 if ((off & 1) != 0)
2248 off &= ~1;
2249 else
2250 {
2251 bfd_put_32 (output_bfd, relocation,
2252 htab->sgot->contents + off);
2253 h->got.offset |= 1;
2254 }
2255 }
2256 else
2257 unresolved_reloc = FALSE;
2258 }
2259 else
2260 {
2261 BFD_ASSERT (local_got_offsets != NULL
2262 && local_got_offsets[r_symndx] != (bfd_vma) -1);
2263
2264 off = local_got_offsets[r_symndx];
2265
2266 /* The offset must always be a multiple of 4. We use
2267 the least significant bit to record whether we have
2268 already processed this entry. */
2269 if ((off & 1) != 0)
2270 off &= ~1;
2271 else
2272 {
2273
2274 if (info->shared)
2275 {
2276 asection *s;
2277 Elf_Internal_Rela outrel;
2278 bfd_byte *loc;
2279
2280 /* We need to generate a R_SPARC_RELATIVE reloc
2281 for the dynamic linker. */
2282 s = htab->srelgot;
2283 BFD_ASSERT (s != NULL);
2284
2285 outrel.r_offset = (htab->sgot->output_section->vma
2286 + htab->sgot->output_offset
2287 + off);
2288 outrel.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
2289 outrel.r_addend = relocation;
2290 relocation = 0;
2291 loc = s->contents;
2292 loc += s->reloc_count++ * sizeof (Elf32_External_Rela);
2293 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2294 }
2295
2296 bfd_put_32 (output_bfd, relocation,
2297 htab->sgot->contents + off);
2298 local_got_offsets[r_symndx] |= 1;
2299 }
2300 }
2301 relocation = htab->sgot->output_offset + off - got_base;
2302 break;
2303
2304 case R_SPARC_PLT32:
2305 if (h == NULL || h->plt.offset == (bfd_vma) -1)
2306 {
2307 r_type = R_SPARC_32;
2308 goto r_sparc_plt32;
2309 }
2310 /* Fall through. */
2311 case R_SPARC_WPLT30:
2312 r_sparc_wplt30:
2313 /* Relocation is to the entry for this symbol in the
2314 procedure linkage table. */
2315
2316 /* The Solaris native assembler will generate a WPLT30 reloc
2317 for a local symbol if you assemble a call from one
2318 section to another when using -K pic. We treat it as
2319 WDISP30. */
2320 if (h == NULL)
2321 break;
2322
2323 if (h->plt.offset == (bfd_vma) -1 || htab->splt == NULL)
2324 {
2325 /* We didn't make a PLT entry for this symbol. This
2326 happens when statically linking PIC code, or when
2327 using -Bsymbolic. */
2328 break;
2329 }
2330
2331 relocation = (htab->splt->output_section->vma
2332 + htab->splt->output_offset
2333 + h->plt.offset);
2334 unresolved_reloc = FALSE;
2335 if (r_type == R_SPARC_PLT32)
2336 {
2337 r_type = R_SPARC_32;
2338 is_plt = TRUE;
2339 goto r_sparc_plt32;
2340 }
2341 break;
2342
2343 case R_SPARC_PC10:
2344 case R_SPARC_PC22:
2345 if (h != NULL
2346 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2347 break;
2348 /* Fall through. */
2349 case R_SPARC_DISP8:
2350 case R_SPARC_DISP16:
2351 case R_SPARC_DISP32:
2352 case R_SPARC_WDISP30:
2353 case R_SPARC_WDISP22:
2354 case R_SPARC_WDISP19:
2355 case R_SPARC_WDISP16:
2356 case R_SPARC_8:
2357 case R_SPARC_16:
2358 case R_SPARC_32:
2359 case R_SPARC_HI22:
2360 case R_SPARC_22:
2361 case R_SPARC_13:
2362 case R_SPARC_LO10:
2363 case R_SPARC_UA16:
2364 case R_SPARC_UA32:
2365 r_sparc_plt32:
2366 /* r_symndx will be zero only for relocs against symbols
2367 from removed linkonce sections, or sections discarded by
2368 a linker script. */
2369 if (r_symndx == 0
2370 || (input_section->flags & SEC_ALLOC) == 0)
2371 break;
2372
2373 if ((info->shared
2374 && (h == NULL
2375 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2376 || h->root.type != bfd_link_hash_undefweak)
2377 && (! howto->pc_relative
2378 || (h != NULL
2379 && h->dynindx != -1
2380 && (! info->symbolic
2381 || (h->elf_link_hash_flags
2382 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
2383 || (!info->shared
2384 && h != NULL
2385 && h->dynindx != -1
2386 && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
2387 && (((h->elf_link_hash_flags
2388 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2389 && (h->elf_link_hash_flags
2390 & ELF_LINK_HASH_DEF_REGULAR) == 0)
2391 || h->root.type == bfd_link_hash_undefweak
2392 || h->root.type == bfd_link_hash_undefined)))
2393 {
2394 Elf_Internal_Rela outrel;
2395 bfd_byte *loc;
2396 bfd_boolean skip, relocate = FALSE;
2397
2398 /* When generating a shared object, these relocations
2399 are copied into the output file to be resolved at run
2400 time. */
2401
2402 BFD_ASSERT (sreloc != NULL);
2403
2404 skip = FALSE;
2405
2406 outrel.r_offset =
2407 _bfd_elf_section_offset (output_bfd, info, input_section,
2408 rel->r_offset);
2409 if (outrel.r_offset == (bfd_vma) -1)
2410 skip = TRUE;
2411 else if (outrel.r_offset == (bfd_vma) -2)
2412 skip = TRUE, relocate = TRUE;
2413 outrel.r_offset += (input_section->output_section->vma
2414 + input_section->output_offset);
2415
2416 /* Optimize unaligned reloc usage now that we know where
2417 it finally resides. */
2418 switch (r_type)
2419 {
2420 case R_SPARC_16:
2421 if (outrel.r_offset & 1)
2422 r_type = R_SPARC_UA16;
2423 break;
2424 case R_SPARC_UA16:
2425 if (!(outrel.r_offset & 1))
2426 r_type = R_SPARC_16;
2427 break;
2428 case R_SPARC_32:
2429 if (outrel.r_offset & 3)
2430 r_type = R_SPARC_UA32;
2431 break;
2432 case R_SPARC_UA32:
2433 if (!(outrel.r_offset & 3))
2434 r_type = R_SPARC_32;
2435 break;
2436 case R_SPARC_DISP8:
2437 case R_SPARC_DISP16:
2438 case R_SPARC_DISP32:
2439 /* If the symbol is not dynamic, we should not keep
2440 a dynamic relocation. But an .rela.* slot has been
2441 allocated for it, output R_SPARC_NONE.
2442 FIXME: Add code tracking needed dynamic relocs as
2443 e.g. i386 has. */
2444 if (h->dynindx == -1)
2445 skip = TRUE, relocate = TRUE;
2446 break;
2447 }
2448
2449 if (skip)
2450 memset (&outrel, 0, sizeof outrel);
2451 /* h->dynindx may be -1 if the symbol was marked to
2452 become local. */
2453 else if (h != NULL && ! is_plt
2454 && ((! info->symbolic && h->dynindx != -1)
2455 || (h->elf_link_hash_flags
2456 & ELF_LINK_HASH_DEF_REGULAR) == 0))
2457 {
2458 BFD_ASSERT (h->dynindx != -1);
2459 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2460 outrel.r_addend = rel->r_addend;
2461 }
2462 else
2463 {
2464 if (r_type == R_SPARC_32)
2465 {
2466 outrel.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
2467 outrel.r_addend = relocation + rel->r_addend;
2468 }
2469 else
2470 {
2471 long indx;
2472
2473 if (is_plt)
2474 sec = htab->splt;
2475
2476 if (bfd_is_abs_section (sec))
2477 indx = 0;
2478 else if (sec == NULL || sec->owner == NULL)
2479 {
2480 bfd_set_error (bfd_error_bad_value);
2481 return FALSE;
2482 }
2483 else
2484 {
2485 asection *osec;
2486
2487 osec = sec->output_section;
2488 indx = elf_section_data (osec)->dynindx;
2489
2490 /* FIXME: we really should be able to link non-pic
2491 shared libraries. */
2492 if (indx == 0)
2493 {
2494 BFD_FAIL ();
2495 (*_bfd_error_handler)
2496 (_("%B: probably compiled without -fPIC?"),
2497 input_bfd);
2498 bfd_set_error (bfd_error_bad_value);
2499 return FALSE;
2500 }
2501 }
2502
2503 outrel.r_info = ELF32_R_INFO (indx, r_type);
2504 outrel.r_addend = relocation + rel->r_addend;
2505 }
2506 }
2507
2508 loc = sreloc->contents;
2509 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
2510 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2511
2512 /* This reloc will be computed at runtime, so there's no
2513 need to do anything now. */
2514 if (! relocate)
2515 continue;
2516 }
2517 break;
2518
2519 case R_SPARC_TLS_GD_HI22:
2520 if (! elf32_sparc_tdata (input_bfd)->has_tlsgd)
2521 {
2522 /* R_SPARC_REV32 used the same reloc number as
2523 R_SPARC_TLS_GD_HI22. */
2524 r_type = R_SPARC_REV32;
2525 break;
2526 }
2527 /* Fall through */
2528
2529 case R_SPARC_TLS_GD_LO10:
2530 case R_SPARC_TLS_IE_HI22:
2531 case R_SPARC_TLS_IE_LO10:
2532 r_type = elf32_sparc_tls_transition (info, input_bfd, r_type,
2533 h == NULL);
2534 tls_type = GOT_UNKNOWN;
2535 if (h == NULL && local_got_offsets)
2536 tls_type = elf32_sparc_local_got_tls_type (input_bfd) [r_symndx];
2537 else if (h != NULL)
2538 {
2539 tls_type = elf32_sparc_hash_entry(h)->tls_type;
2540 if (!info->shared && h->dynindx == -1 && tls_type == GOT_TLS_IE)
2541 switch (ELF32_R_TYPE (rel->r_info))
2542 {
2543 case R_SPARC_TLS_GD_HI22:
2544 case R_SPARC_TLS_IE_HI22:
2545 r_type = R_SPARC_TLS_LE_HIX22;
2546 break;
2547 default:
2548 r_type = R_SPARC_TLS_LE_LOX10;
2549 break;
2550 }
2551 }
2552 if (tls_type == GOT_TLS_IE)
2553 switch (r_type)
2554 {
2555 case R_SPARC_TLS_GD_HI22:
2556 r_type = R_SPARC_TLS_IE_HI22;
2557 break;
2558 case R_SPARC_TLS_GD_LO10:
2559 r_type = R_SPARC_TLS_IE_LO10;
2560 break;
2561 }
2562
2563 if (r_type == R_SPARC_TLS_LE_HIX22)
2564 {
2565 relocation = tpoff (info, relocation);
2566 break;
2567 }
2568 if (r_type == R_SPARC_TLS_LE_LOX10)
2569 {
2570 /* Change add into xor. */
2571 relocation = tpoff (info, relocation);
2572 bfd_put_32 (output_bfd, (bfd_get_32 (input_bfd,
2573 contents + rel->r_offset)
2574 | 0x80182000), contents + rel->r_offset);
2575 break;
2576 }
2577
2578 if (h != NULL)
2579 {
2580 off = h->got.offset;
2581 h->got.offset |= 1;
2582 }
2583 else
2584 {
2585 BFD_ASSERT (local_got_offsets != NULL);
2586 off = local_got_offsets[r_symndx];
2587 local_got_offsets[r_symndx] |= 1;
2588 }
2589
2590 r_sparc_tlsldm:
2591 if (htab->sgot == NULL)
2592 abort ();
2593
2594 if ((off & 1) != 0)
2595 off &= ~1;
2596 else
2597 {
2598 Elf_Internal_Rela outrel;
2599 Elf32_External_Rela *loc;
2600 int dr_type, indx;
2601
2602 if (htab->srelgot == NULL)
2603 abort ();
2604
2605 bfd_put_32 (output_bfd, 0, htab->sgot->contents + off);
2606 outrel.r_offset = (htab->sgot->output_section->vma
2607 + htab->sgot->output_offset + off);
2608 indx = h && h->dynindx != -1 ? h->dynindx : 0;
2609 if (r_type == R_SPARC_TLS_IE_HI22
2610 || r_type == R_SPARC_TLS_IE_LO10)
2611 dr_type = R_SPARC_TLS_TPOFF32;
2612 else
2613 dr_type = R_SPARC_TLS_DTPMOD32;
2614 if (dr_type == R_SPARC_TLS_TPOFF32 && indx == 0)
2615 outrel.r_addend = relocation - dtpoff_base (info);
2616 else
2617 outrel.r_addend = 0;
2618 outrel.r_info = ELF32_R_INFO (indx, dr_type);
2619 loc = (Elf32_External_Rela *) htab->srelgot->contents;
2620 loc += htab->srelgot->reloc_count++;
2621 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
2622 (bfd_byte *) loc);
2623
2624 if (r_type == R_SPARC_TLS_GD_HI22
2625 || r_type == R_SPARC_TLS_GD_LO10)
2626 {
2627 if (indx == 0)
2628 {
2629 BFD_ASSERT (! unresolved_reloc);
2630 bfd_put_32 (output_bfd,
2631 relocation - dtpoff_base (info),
2632 htab->sgot->contents + off + 4);
2633 }
2634 else
2635 {
2636 bfd_put_32 (output_bfd, 0,
2637 htab->sgot->contents + off + 4);
2638 outrel.r_info = ELF32_R_INFO (indx,
2639 R_SPARC_TLS_DTPOFF32);
2640 outrel.r_offset += 4;
2641 htab->srelgot->reloc_count++;
2642 loc++;
2643 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
2644 (bfd_byte *) loc);
2645 }
2646 }
2647 else if (dr_type == R_SPARC_TLS_DTPMOD32)
2648 {
2649 bfd_put_32 (output_bfd, 0,
2650 htab->sgot->contents + off + 4);
2651 }
2652 }
2653
2654 if (off >= (bfd_vma) -2)
2655 abort ();
2656
2657 relocation = htab->sgot->output_offset + off - got_base;
2658 unresolved_reloc = FALSE;
2659 howto = _bfd_sparc_elf_howto_table + r_type;
2660 break;
2661
2662 case R_SPARC_TLS_LDM_HI22:
2663 case R_SPARC_TLS_LDM_LO10:
2664 if (! info->shared)
2665 {
2666 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
2667 continue;
2668 }
2669 off = htab->tls_ldm_got.offset;
2670 htab->tls_ldm_got.offset |= 1;
2671 goto r_sparc_tlsldm;
2672
2673 case R_SPARC_TLS_LDO_HIX22:
2674 case R_SPARC_TLS_LDO_LOX10:
2675 if (info->shared)
2676 relocation -= dtpoff_base (info);
2677 else
2678 relocation = tpoff (info, relocation);
2679 break;
2680
2681 case R_SPARC_TLS_LE_HIX22:
2682 case R_SPARC_TLS_LE_LOX10:
2683 if (info->shared)
2684 {
2685 Elf_Internal_Rela outrel;
2686 bfd_boolean skip, relocate = FALSE;
2687
2688 BFD_ASSERT (sreloc != NULL);
2689 skip = FALSE;
2690 outrel.r_offset =
2691 _bfd_elf_section_offset (output_bfd, info, input_section,
2692 rel->r_offset);
2693 if (outrel.r_offset == (bfd_vma) -1)
2694 skip = TRUE;
2695 else if (outrel.r_offset == (bfd_vma) -2)
2696 skip = TRUE, relocate = TRUE;
2697 outrel.r_offset += (input_section->output_section->vma
2698 + input_section->output_offset);
2699 if (skip)
2700 memset (&outrel, 0, sizeof outrel);
2701 else
2702 {
2703 outrel.r_info = ELF32_R_INFO (0, r_type);
2704 outrel.r_addend = relocation - dtpoff_base (info)
2705 + rel->r_addend;
2706 }
2707
2708 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
2709 (bfd_byte *) (((Elf32_External_Rela *)
2710 sreloc->contents)
2711 + sreloc->reloc_count));
2712 ++sreloc->reloc_count;
2713 continue;
2714 }
2715 relocation = tpoff (info, relocation);
2716 break;
2717
2718 case R_SPARC_TLS_LDM_CALL:
2719 if (! info->shared)
2720 {
2721 /* mov %g0, %o0 */
2722 bfd_put_32 (output_bfd, 0x90100000, contents + rel->r_offset);
2723 continue;
2724 }
2725 /* Fall through */
2726
2727 case R_SPARC_TLS_GD_CALL:
2728 tls_type = GOT_UNKNOWN;
2729 if (h == NULL && local_got_offsets)
2730 tls_type = elf32_sparc_local_got_tls_type (input_bfd) [r_symndx];
2731 else if (h != NULL)
2732 tls_type = elf32_sparc_hash_entry(h)->tls_type;
2733 if (! info->shared
2734 || (r_type == R_SPARC_TLS_GD_CALL && tls_type == GOT_TLS_IE))
2735 {
2736 bfd_vma insn;
2737
2738 if (!info->shared && (h == NULL || h->dynindx == -1))
2739 {
2740 /* GD -> LE */
2741 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
2742 continue;
2743 }
2744
2745 /* GD -> IE */
2746 if (rel + 1 < relend
2747 && ELF32_R_TYPE (rel[1].r_info) == R_SPARC_TLS_GD_ADD
2748 && rel[1].r_offset == rel->r_offset + 4
2749 && ELF32_R_SYM (rel[1].r_info) == r_symndx
2750 && (((insn = bfd_get_32 (input_bfd,
2751 contents + rel[1].r_offset))
2752 >> 25) & 0x1f) == 8)
2753 {
2754 /* We have
2755 call __tls_get_addr, %tgd_call(foo)
2756 add %reg1, %reg2, %o0, %tgd_add(foo)
2757 and change it into IE:
2758 ld [%reg1 + %reg2], %o0, %tie_ld(foo)
2759 add %g7, %o0, %o0, %tie_add(foo).
2760 add is 0x80000000 | (rd << 25) | (rs1 << 14) | rs2,
2761 ld is 0xc0000000 | (rd << 25) | (rs1 << 14) | rs2. */
2762 bfd_put_32 (output_bfd, insn | 0xc0000000,
2763 contents + rel->r_offset);
2764 bfd_put_32 (output_bfd, 0x9001c008,
2765 contents + rel->r_offset + 4);
2766 rel++;
2767 continue;
2768 }
2769
2770 bfd_put_32 (output_bfd, 0x9001c008, contents + rel->r_offset);
2771 continue;
2772 }
2773
2774 h = (struct elf_link_hash_entry *)
2775 bfd_link_hash_lookup (info->hash, "__tls_get_addr", FALSE,
2776 FALSE, TRUE);
2777 BFD_ASSERT (h != NULL);
2778 r_type = R_SPARC_WPLT30;
2779 howto = _bfd_sparc_elf_howto_table + r_type;
2780 goto r_sparc_wplt30;
2781
2782 case R_SPARC_TLS_GD_ADD:
2783 tls_type = GOT_UNKNOWN;
2784 if (h == NULL && local_got_offsets)
2785 tls_type = elf32_sparc_local_got_tls_type (input_bfd) [r_symndx];
2786 else if (h != NULL)
2787 tls_type = elf32_sparc_hash_entry(h)->tls_type;
2788 if (! info->shared || tls_type == GOT_TLS_IE)
2789 {
2790 /* add %reg1, %reg2, %reg3, %tgd_add(foo)
2791 changed into IE:
2792 ld [%reg1 + %reg2], %reg3, %tie_ld(foo)
2793 or LE:
2794 add %g7, %reg2, %reg3. */
2795 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
2796 if ((h != NULL && h->dynindx != -1) || info->shared)
2797 relocation = insn | 0xc0000000;
2798 else
2799 relocation = (insn & ~0x7c000) | 0x1c000;
2800 bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
2801 }
2802 continue;
2803
2804 case R_SPARC_TLS_LDM_ADD:
2805 if (! info->shared)
2806 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
2807 continue;
2808
2809 case R_SPARC_TLS_LDO_ADD:
2810 if (! info->shared)
2811 {
2812 /* Change rs1 into %g7. */
2813 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
2814 insn = (insn & ~0x7c000) | 0x1c000;
2815 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
2816 }
2817 continue;
2818
2819 case R_SPARC_TLS_IE_LD:
2820 case R_SPARC_TLS_IE_LDX:
2821 if (! info->shared && (h == NULL || h->dynindx == -1))
2822 {
2823 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
2824 int rs2 = insn & 0x1f;
2825 int rd = (insn >> 25) & 0x1f;
2826
2827 if (rs2 == rd)
2828 relocation = SPARC_NOP;
2829 else
2830 relocation = 0x80100000 | (insn & 0x3e00001f);
2831 bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
2832 }
2833 continue;
2834
2835 case R_SPARC_TLS_IE_ADD:
2836 /* Totally useless relocation. */
2837 continue;
2838
2839 case R_SPARC_TLS_DTPOFF32:
2840 relocation -= dtpoff_base (info);
2841 break;
2842
2843 default:
2844 break;
2845 }
2846
2847 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2848 because such sections are not SEC_ALLOC and thus ld.so will
2849 not process them. */
2850 if (unresolved_reloc
2851 && !((input_section->flags & SEC_DEBUGGING) != 0
2852 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
2853 (*_bfd_error_handler)
2854 (_("%B(%A+0x%lx): unresolvable relocation against symbol `%s'"),
2855 input_bfd,
2856 input_section,
2857 (long) rel->r_offset,
2858 h->root.root.string);
2859
2860 r = bfd_reloc_continue;
2861 if (r_type == R_SPARC_WDISP16)
2862 {
2863 bfd_vma x;
2864
2865 relocation += rel->r_addend;
2866 relocation -= (input_section->output_section->vma
2867 + input_section->output_offset);
2868 relocation -= rel->r_offset;
2869
2870 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2871 x |= ((((relocation >> 2) & 0xc000) << 6)
2872 | ((relocation >> 2) & 0x3fff));
2873 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2874
2875 if ((bfd_signed_vma) relocation < - 0x40000
2876 || (bfd_signed_vma) relocation > 0x3ffff)
2877 r = bfd_reloc_overflow;
2878 else
2879 r = bfd_reloc_ok;
2880 }
2881 else if (r_type == R_SPARC_REV32)
2882 {
2883 bfd_vma x;
2884
2885 relocation = relocation + rel->r_addend;
2886
2887 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2888 x = x + relocation;
2889 bfd_putl32 (/*input_bfd,*/ x, contents + rel->r_offset);
2890 r = bfd_reloc_ok;
2891 }
2892 else if (r_type == R_SPARC_TLS_LDO_HIX22
2893 || r_type == R_SPARC_TLS_LE_HIX22)
2894 {
2895 bfd_vma x;
2896
2897 relocation += rel->r_addend;
2898 relocation = relocation ^ 0xffffffff;
2899
2900 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2901 x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
2902 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2903 r = bfd_reloc_ok;
2904 }
2905 else if (r_type == R_SPARC_TLS_LDO_LOX10
2906 || r_type == R_SPARC_TLS_LE_LOX10)
2907 {
2908 bfd_vma x;
2909
2910 relocation += rel->r_addend;
2911 relocation = (relocation & 0x3ff) | 0x1c00;
2912
2913 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2914 x = (x & ~(bfd_vma) 0x1fff) | relocation;
2915 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2916
2917 r = bfd_reloc_ok;
2918 }
2919 else if ((r_type == R_SPARC_WDISP30 || r_type == R_SPARC_WPLT30)
2920 && sec_do_relax (input_section)
2921 && rel->r_offset + 4 < input_section->size)
2922 {
2923 #define G0 0
2924 #define O7 15
2925 #define XCC (2 << 20)
2926 #define COND(x) (((x)&0xf)<<25)
2927 #define CONDA COND(0x8)
2928 #define INSN_BPA (F2(0,1) | CONDA | BPRED | XCC)
2929 #define INSN_BA (F2(0,2) | CONDA)
2930 #define INSN_OR F3(2, 0x2, 0)
2931 #define INSN_NOP F2(0,4)
2932
2933 bfd_vma x, y;
2934
2935 /* If the instruction is a call with either:
2936 restore
2937 arithmetic instruction with rd == %o7
2938 where rs1 != %o7 and rs2 if it is register != %o7
2939 then we can optimize if the call destination is near
2940 by changing the call into a branch always. */
2941 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2942 y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
2943 if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2))
2944 {
2945 if (((y & OP3(~0)) == OP3(0x3d) /* restore */
2946 || ((y & OP3(0x28)) == 0 /* arithmetic */
2947 && (y & RD(~0)) == RD(O7)))
2948 && (y & RS1(~0)) != RS1(O7)
2949 && ((y & F3I(~0))
2950 || (y & RS2(~0)) != RS2(O7)))
2951 {
2952 bfd_vma reloc;
2953
2954 reloc = relocation + rel->r_addend - rel->r_offset;
2955 reloc -= (input_section->output_section->vma
2956 + input_section->output_offset);
2957
2958 /* Ensure the reloc fits into simm22. */
2959 if ((reloc & 3) == 0
2960 && ((reloc & ~(bfd_vma)0x7fffff) == 0
2961 || ((reloc | 0x7fffff) == ~(bfd_vma)0)))
2962 {
2963 reloc >>= 2;
2964
2965 /* Check whether it fits into simm19 on v9. */
2966 if (((reloc & 0x3c0000) == 0
2967 || (reloc & 0x3c0000) == 0x3c0000)
2968 && (elf_elfheader (output_bfd)->e_flags & EF_SPARC_32PLUS))
2969 x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */
2970 else
2971 x = INSN_BA | (reloc & 0x3fffff); /* ba */
2972 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2973 r = bfd_reloc_ok;
2974 if (rel->r_offset >= 4
2975 && (y & (0xffffffff ^ RS1(~0)))
2976 == (INSN_OR | RD(O7) | RS2(G0)))
2977 {
2978 bfd_vma z;
2979 unsigned int reg;
2980
2981 z = bfd_get_32 (input_bfd,
2982 contents + rel->r_offset - 4);
2983 if ((z & (0xffffffff ^ RD(~0)))
2984 != (INSN_OR | RS1(O7) | RS2(G0)))
2985 break;
2986
2987 /* The sequence was
2988 or %o7, %g0, %rN
2989 call foo
2990 or %rN, %g0, %o7
2991
2992 If call foo was replaced with ba, replace
2993 or %rN, %g0, %o7 with nop. */
2994
2995 reg = (y & RS1(~0)) >> 14;
2996 if (reg != ((z & RD(~0)) >> 25)
2997 || reg == G0 || reg == O7)
2998 break;
2999
3000 bfd_put_32 (input_bfd, (bfd_vma) INSN_NOP,
3001 contents + rel->r_offset + 4);
3002 }
3003
3004 }
3005 }
3006 }
3007 }
3008
3009 if (r == bfd_reloc_continue)
3010 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3011 contents, rel->r_offset,
3012 relocation, rel->r_addend);
3013
3014 if (r != bfd_reloc_ok)
3015 {
3016 switch (r)
3017 {
3018 default:
3019 case bfd_reloc_outofrange:
3020 abort ();
3021 case bfd_reloc_overflow:
3022 {
3023 const char *name;
3024
3025 if (h != NULL)
3026 name = h->root.root.string;
3027 else
3028 {
3029 name = bfd_elf_string_from_elf_section (input_bfd,
3030 symtab_hdr->sh_link,
3031 sym->st_name);
3032 if (name == NULL)
3033 return FALSE;
3034 if (*name == '\0')
3035 name = bfd_section_name (input_bfd, sec);
3036 }
3037 if (! ((*info->callbacks->reloc_overflow)
3038 (info, name, howto->name, (bfd_vma) 0,
3039 input_bfd, input_section, rel->r_offset)))
3040 return FALSE;
3041 }
3042 break;
3043 }
3044 }
3045 }
3046
3047 return TRUE;
3048 }
3049
3050 /* Finish up dynamic symbol handling. We set the contents of various
3051 dynamic sections here. */
3052
3053 static bfd_boolean
3054 elf32_sparc_finish_dynamic_symbol (output_bfd, info, h, sym)
3055 bfd *output_bfd;
3056 struct bfd_link_info *info;
3057 struct elf_link_hash_entry *h;
3058 Elf_Internal_Sym *sym;
3059 {
3060 bfd *dynobj;
3061 struct elf32_sparc_link_hash_table *htab;
3062
3063 htab = elf32_sparc_hash_table (info);
3064 dynobj = htab->elf.dynobj;
3065
3066 if (h->plt.offset != (bfd_vma) -1)
3067 {
3068 asection *splt;
3069 asection *srela;
3070 Elf_Internal_Rela rela;
3071 bfd_byte *loc;
3072
3073 /* This symbol has an entry in the procedure linkage table. Set
3074 it up. */
3075
3076 BFD_ASSERT (h->dynindx != -1);
3077
3078 splt = htab->splt;
3079 srela = htab->srelplt;
3080 BFD_ASSERT (splt != NULL && srela != NULL);
3081
3082 /* Fill in the entry in the procedure linkage table. */
3083 bfd_put_32 (output_bfd,
3084 PLT_ENTRY_WORD0 + h->plt.offset,
3085 splt->contents + h->plt.offset);
3086 bfd_put_32 (output_bfd,
3087 (PLT_ENTRY_WORD1
3088 + (((- (h->plt.offset + 4)) >> 2) & 0x3fffff)),
3089 splt->contents + h->plt.offset + 4);
3090 bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD2,
3091 splt->contents + h->plt.offset + 8);
3092
3093 /* Fill in the entry in the .rela.plt section. */
3094 rela.r_offset = (splt->output_section->vma
3095 + splt->output_offset
3096 + h->plt.offset);
3097 rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_JMP_SLOT);
3098 rela.r_addend = 0;
3099 loc = srela->contents;
3100 loc += (h->plt.offset / PLT_ENTRY_SIZE - 4) * sizeof (Elf32_External_Rela);
3101 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3102
3103 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3104 {
3105 /* Mark the symbol as undefined, rather than as defined in
3106 the .plt section. Leave the value alone. */
3107 sym->st_shndx = SHN_UNDEF;
3108 /* If the symbol is weak, we do need to clear the value.
3109 Otherwise, the PLT entry would provide a definition for
3110 the symbol even if the symbol wasn't defined anywhere,
3111 and so the symbol would never be NULL. */
3112 if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK)
3113 == 0)
3114 sym->st_value = 0;
3115 }
3116 }
3117
3118 if (h->got.offset != (bfd_vma) -1
3119 && elf32_sparc_hash_entry(h)->tls_type != GOT_TLS_GD
3120 && elf32_sparc_hash_entry(h)->tls_type != GOT_TLS_IE)
3121 {
3122 asection *sgot;
3123 asection *srela;
3124 Elf_Internal_Rela rela;
3125 bfd_byte *loc;
3126
3127 /* This symbol has an entry in the global offset table. Set it
3128 up. */
3129
3130 sgot = htab->sgot;
3131 srela = htab->srelgot;
3132 BFD_ASSERT (sgot != NULL && srela != NULL);
3133
3134 rela.r_offset = (sgot->output_section->vma
3135 + sgot->output_offset
3136 + (h->got.offset &~ (bfd_vma) 1));
3137
3138 /* If this is a -Bsymbolic link, and the symbol is defined
3139 locally, we just want to emit a RELATIVE reloc. Likewise if
3140 the symbol was forced to be local because of a version file.
3141 The entry in the global offset table will already have been
3142 initialized in the relocate_section function. */
3143 if (info->shared
3144 && (info->symbolic || h->dynindx == -1)
3145 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
3146 {
3147 asection *sec = h->root.u.def.section;
3148 rela.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
3149 rela.r_addend = (h->root.u.def.value
3150 + sec->output_section->vma
3151 + sec->output_offset);
3152 }
3153 else
3154 {
3155 rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_GLOB_DAT);
3156 rela.r_addend = 0;
3157 }
3158
3159 bfd_put_32 (output_bfd, (bfd_vma) 0,
3160 sgot->contents + (h->got.offset &~ (bfd_vma) 1));
3161 loc = srela->contents;
3162 loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
3163 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3164 }
3165
3166 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
3167 {
3168 asection *s;
3169 Elf_Internal_Rela rela;
3170 bfd_byte *loc;
3171
3172 /* This symbols needs a copy reloc. Set it up. */
3173
3174 BFD_ASSERT (h->dynindx != -1);
3175
3176 s = bfd_get_section_by_name (h->root.u.def.section->owner,
3177 ".rela.bss");
3178 BFD_ASSERT (s != NULL);
3179
3180 rela.r_offset = (h->root.u.def.value
3181 + h->root.u.def.section->output_section->vma
3182 + h->root.u.def.section->output_offset);
3183 rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_COPY);
3184 rela.r_addend = 0;
3185 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
3186 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3187 }
3188
3189 /* Mark some specially defined symbols as absolute. */
3190 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3191 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
3192 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
3193 sym->st_shndx = SHN_ABS;
3194
3195 return TRUE;
3196 }
3197
3198 /* Finish up the dynamic sections. */
3199
3200 static bfd_boolean
3201 elf32_sparc_finish_dynamic_sections (output_bfd, info)
3202 bfd *output_bfd;
3203 struct bfd_link_info *info;
3204 {
3205 bfd *dynobj;
3206 asection *sdyn;
3207 struct elf32_sparc_link_hash_table *htab;
3208
3209 htab = elf32_sparc_hash_table (info);
3210 dynobj = htab->elf.dynobj;
3211
3212 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3213
3214 if (elf_hash_table (info)->dynamic_sections_created)
3215 {
3216 asection *splt;
3217 Elf32_External_Dyn *dyncon, *dynconend;
3218
3219 splt = bfd_get_section_by_name (dynobj, ".plt");
3220 BFD_ASSERT (splt != NULL && sdyn != NULL);
3221
3222 dyncon = (Elf32_External_Dyn *) sdyn->contents;
3223 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3224 for (; dyncon < dynconend; dyncon++)
3225 {
3226 Elf_Internal_Dyn dyn;
3227 const char *name;
3228 bfd_boolean size;
3229
3230 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3231
3232 switch (dyn.d_tag)
3233 {
3234 case DT_PLTGOT: name = ".plt"; size = FALSE; break;
3235 case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break;
3236 case DT_JMPREL: name = ".rela.plt"; size = FALSE; break;
3237 default: name = NULL; size = FALSE; break;
3238 }
3239
3240 if (name != NULL)
3241 {
3242 asection *s;
3243
3244 s = bfd_get_section_by_name (output_bfd, name);
3245 if (s == NULL)
3246 dyn.d_un.d_val = 0;
3247 else
3248 {
3249 if (! size)
3250 dyn.d_un.d_ptr = s->vma;
3251 else
3252 dyn.d_un.d_val = s->size;
3253 }
3254 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3255 }
3256 }
3257
3258 /* Clear the first four entries in the procedure linkage table,
3259 and put a nop in the last four bytes. */
3260 if (splt->size > 0)
3261 {
3262 memset (splt->contents, 0, 4 * PLT_ENTRY_SIZE);
3263 bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP,
3264 splt->contents + splt->size - 4);
3265 }
3266
3267 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 0;
3268 }
3269
3270 /* Set the first entry in the global offset table to the address of
3271 the dynamic section. */
3272 if (htab->sgot && htab->sgot->size > 0)
3273 {
3274 if (sdyn == NULL)
3275 bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgot->contents);
3276 else
3277 bfd_put_32 (output_bfd,
3278 sdyn->output_section->vma + sdyn->output_offset,
3279 htab->sgot->contents);
3280 }
3281
3282 if (htab->sgot)
3283 elf_section_data (htab->sgot->output_section)->this_hdr.sh_entsize = 4;
3284
3285 return TRUE;
3286 }
3287 \f
3288 /* Functions for dealing with the e_flags field.
3289
3290 We don't define set_private_flags or copy_private_bfd_data because
3291 the only currently defined values are based on the bfd mach number,
3292 so we use the latter instead and defer setting e_flags until the
3293 file is written out. */
3294
3295 /* Merge backend specific data from an object file to the output
3296 object file when linking. */
3297
3298 static bfd_boolean
3299 elf32_sparc_merge_private_bfd_data (ibfd, obfd)
3300 bfd *ibfd;
3301 bfd *obfd;
3302 {
3303 bfd_boolean error;
3304 unsigned long ibfd_mach;
3305 /* FIXME: This should not be static. */
3306 static unsigned long previous_ibfd_e_flags = (unsigned long) -1;
3307
3308 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3309 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3310 return TRUE;
3311
3312 error = FALSE;
3313
3314 ibfd_mach = bfd_get_mach (ibfd);
3315 if (bfd_mach_sparc_64bit_p (ibfd_mach))
3316 {
3317 error = TRUE;
3318 (*_bfd_error_handler)
3319 (_("%B: compiled for a 64 bit system and target is 32 bit"), ibfd);
3320 }
3321 else if ((ibfd->flags & DYNAMIC) == 0)
3322 {
3323 if (bfd_get_mach (obfd) < ibfd_mach)
3324 bfd_set_arch_mach (obfd, bfd_arch_sparc, ibfd_mach);
3325 }
3326
3327 if (((elf_elfheader (ibfd)->e_flags & EF_SPARC_LEDATA)
3328 != previous_ibfd_e_flags)
3329 && previous_ibfd_e_flags != (unsigned long) -1)
3330 {
3331 (*_bfd_error_handler)
3332 (_("%B: linking little endian files with big endian files"), ibfd);
3333 error = TRUE;
3334 }
3335 previous_ibfd_e_flags = elf_elfheader (ibfd)->e_flags & EF_SPARC_LEDATA;
3336
3337 if (error)
3338 {
3339 bfd_set_error (bfd_error_bad_value);
3340 return FALSE;
3341 }
3342
3343 return TRUE;
3344 }
3345 \f
3346 /* Set the right machine number. */
3347
3348 static bfd_boolean
3349 elf32_sparc_object_p (abfd)
3350 bfd *abfd;
3351 {
3352 if (elf_elfheader (abfd)->e_machine == EM_SPARC32PLUS)
3353 {
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);
3363 else
3364 return FALSE;
3365 }
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);
3369 else
3370 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc);
3371 }
3372
3373 /* The final processing done just before writing out the object file.
3374 We need to set the e_machine field appropriately. */
3375
3376 static void
3377 elf32_sparc_final_write_processing (abfd, linker)
3378 bfd *abfd;
3379 bfd_boolean linker ATTRIBUTE_UNUSED;
3380 {
3381 switch (bfd_get_mach (abfd))
3382 {
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;
3389 break;
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;
3394 break;
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
3399 | EF_SPARC_SUN_US3;
3400 break;
3401 case bfd_mach_sparc_sparclite_le :
3402 elf_elfheader (abfd)->e_machine = EM_SPARC;
3403 elf_elfheader (abfd)->e_flags |= EF_SPARC_LEDATA;
3404 break;
3405 default :
3406 abort ();
3407 break;
3408 }
3409 }
3410
3411 static enum elf_reloc_type_class
3412 elf32_sparc_reloc_type_class (rela)
3413 const Elf_Internal_Rela *rela;
3414 {
3415 switch ((int) ELF32_R_TYPE (rela->r_info))
3416 {
3417 case R_SPARC_RELATIVE:
3418 return reloc_class_relative;
3419 case R_SPARC_JMP_SLOT:
3420 return reloc_class_plt;
3421 case R_SPARC_COPY:
3422 return reloc_class_copy;
3423 default:
3424 return reloc_class_normal;
3425 }
3426 }
3427
3428 /* Return address for Ith PLT stub in section PLT, for relocation REL
3429 or (bfd_vma) -1 if it should not be included. */
3430
3431 static bfd_vma
3432 elf32_sparc_plt_sym_val (bfd_vma i ATTRIBUTE_UNUSED,
3433 const asection *plt ATTRIBUTE_UNUSED,
3434 const arelent *rel)
3435 {
3436 return rel->address;
3437 }
3438 \f
3439 #define TARGET_BIG_SYM bfd_elf32_sparc_vec
3440 #define TARGET_BIG_NAME "elf32-sparc"
3441 #define ELF_ARCH bfd_arch_sparc
3442 #define ELF_MACHINE_CODE EM_SPARC
3443 #define ELF_MACHINE_ALT1 EM_SPARC32PLUS
3444 #define ELF_MAXPAGESIZE 0x10000
3445
3446 #define bfd_elf32_bfd_reloc_type_lookup elf32_sparc_reloc_type_lookup
3447 #define bfd_elf32_bfd_link_hash_table_create \
3448 elf32_sparc_link_hash_table_create
3449 #define bfd_elf32_bfd_relax_section elf32_sparc_relax_section
3450 #define bfd_elf32_new_section_hook elf32_sparc_new_section_hook
3451 #define elf_info_to_howto elf32_sparc_info_to_howto
3452 #define elf_backend_copy_indirect_symbol \
3453 elf32_sparc_copy_indirect_symbol
3454 #define elf_backend_create_dynamic_sections \
3455 elf32_sparc_create_dynamic_sections
3456 #define elf_backend_check_relocs elf32_sparc_check_relocs
3457 #define elf_backend_adjust_dynamic_symbol \
3458 elf32_sparc_adjust_dynamic_symbol
3459 #define elf_backend_size_dynamic_sections \
3460 elf32_sparc_size_dynamic_sections
3461 #define elf_backend_relocate_section elf32_sparc_relocate_section
3462 #define elf_backend_finish_dynamic_symbol \
3463 elf32_sparc_finish_dynamic_symbol
3464 #define elf_backend_finish_dynamic_sections \
3465 elf32_sparc_finish_dynamic_sections
3466 #define bfd_elf32_bfd_merge_private_bfd_data \
3467 elf32_sparc_merge_private_bfd_data
3468 #define bfd_elf32_mkobject elf32_sparc_mkobject
3469 #define elf_backend_object_p elf32_sparc_object_p
3470 #define elf_backend_final_write_processing \
3471 elf32_sparc_final_write_processing
3472 #define elf_backend_gc_mark_hook elf32_sparc_gc_mark_hook
3473 #define elf_backend_gc_sweep_hook elf32_sparc_gc_sweep_hook
3474 #define elf_backend_grok_psinfo elf32_sparc_grok_psinfo
3475 #define elf_backend_reloc_type_class elf32_sparc_reloc_type_class
3476 #define elf_backend_plt_sym_val elf32_sparc_plt_sym_val
3477
3478 #define elf_backend_can_gc_sections 1
3479 #define elf_backend_can_refcount 1
3480 #define elf_backend_want_got_plt 0
3481 #define elf_backend_plt_readonly 0
3482 #define elf_backend_want_plt_sym 1
3483 #define elf_backend_got_header_size 4
3484 #define elf_backend_rela_normal 1
3485
3486 #include "elf32-target.h"
git-cvsimport of binutils cvsroot