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