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.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
26 #include "elf/sparc.h"
27 #include "opcode/sparc.h"
29 static reloc_howto_type
*elf32_sparc_reloc_type_lookup
30 PARAMS ((bfd
*, bfd_reloc_code_real_type
));
31 static void elf32_sparc_info_to_howto
32 PARAMS ((bfd
*, arelent
*, Elf_Internal_Rela
*));
33 static bfd_boolean elf32_sparc_check_relocs
34 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
35 const Elf_Internal_Rela
*));
36 static bfd_boolean elf32_sparc_adjust_dynamic_symbol
37 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
38 static bfd_boolean allocate_dynrelocs
39 PARAMS ((struct elf_link_hash_entry
*, PTR
));
40 static bfd_boolean readonly_dynrelocs
41 PARAMS ((struct elf_link_hash_entry
*, PTR
));
42 static bfd_boolean elf32_sparc_size_dynamic_sections
43 PARAMS ((bfd
*, struct bfd_link_info
*));
44 static bfd_boolean elf32_sparc_new_section_hook
45 PARAMS ((bfd
*, asection
*));
46 static bfd_boolean elf32_sparc_relax_section
47 PARAMS ((bfd
*, asection
*, struct bfd_link_info
*, bfd_boolean
*));
48 static bfd_vma dtpoff_base
49 PARAMS ((struct bfd_link_info
*));
51 PARAMS ((struct bfd_link_info
*, bfd_vma
));
52 static bfd_boolean elf32_sparc_relocate_section
53 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
54 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**));
55 static bfd_boolean elf32_sparc_finish_dynamic_symbol
56 PARAMS ((bfd
*, struct bfd_link_info
*, struct elf_link_hash_entry
*,
58 static bfd_boolean elf32_sparc_finish_dynamic_sections
59 PARAMS ((bfd
*, struct bfd_link_info
*));
60 static bfd_boolean elf32_sparc_merge_private_bfd_data
61 PARAMS ((bfd
*, bfd
*));
62 static struct bfd_hash_entry
*link_hash_newfunc
63 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
64 static struct bfd_link_hash_table
*elf32_sparc_link_hash_table_create
66 static bfd_boolean create_got_section
67 PARAMS ((bfd
*, struct bfd_link_info
*));
68 static bfd_boolean elf32_sparc_create_dynamic_sections
69 PARAMS ((bfd
*, struct bfd_link_info
*));
70 static void elf32_sparc_copy_indirect_symbol
71 PARAMS ((const struct elf_backend_data
*, struct elf_link_hash_entry
*,
72 struct elf_link_hash_entry
*));
73 static int elf32_sparc_tls_transition
74 PARAMS ((struct bfd_link_info
*, bfd
*, int, int));
76 static bfd_boolean elf32_sparc_mkobject
78 static bfd_boolean elf32_sparc_object_p
80 static void elf32_sparc_final_write_processing
81 PARAMS ((bfd
*, bfd_boolean
));
82 static enum elf_reloc_type_class elf32_sparc_reloc_type_class
83 PARAMS ((const Elf_Internal_Rela
*));
84 static asection
* elf32_sparc_gc_mark_hook
85 PARAMS ((asection
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
86 struct elf_link_hash_entry
*, Elf_Internal_Sym
*));
87 static bfd_boolean elf32_sparc_gc_sweep_hook
88 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
89 const Elf_Internal_Rela
*));
91 /* The relocation "howto" table. */
93 static bfd_reloc_status_type sparc_elf_notsupported_reloc
94 PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
95 static bfd_reloc_status_type sparc_elf_wdisp16_reloc
96 PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
97 static bfd_reloc_status_type sparc_elf_hix22_reloc
98 PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
99 static bfd_reloc_status_type sparc_elf_lox10_reloc
100 PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
102 reloc_howto_type _bfd_sparc_elf_howto_table
[] =
104 HOWTO(R_SPARC_NONE
, 0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_NONE", FALSE
,0,0x00000000,TRUE
),
105 HOWTO(R_SPARC_8
, 0,0, 8,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_8", FALSE
,0,0x000000ff,TRUE
),
106 HOWTO(R_SPARC_16
, 0,1,16,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_16", FALSE
,0,0x0000ffff,TRUE
),
107 HOWTO(R_SPARC_32
, 0,2,32,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_32", FALSE
,0,0xffffffff,TRUE
),
108 HOWTO(R_SPARC_DISP8
, 0,0, 8,TRUE
, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_DISP8", FALSE
,0,0x000000ff,TRUE
),
109 HOWTO(R_SPARC_DISP16
, 0,1,16,TRUE
, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_DISP16", FALSE
,0,0x0000ffff,TRUE
),
110 HOWTO(R_SPARC_DISP32
, 0,2,32,TRUE
, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_DISP32", FALSE
,0,0xffffffff,TRUE
),
111 HOWTO(R_SPARC_WDISP30
, 2,2,30,TRUE
, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_WDISP30", FALSE
,0,0x3fffffff,TRUE
),
112 HOWTO(R_SPARC_WDISP22
, 2,2,22,TRUE
, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_WDISP22", FALSE
,0,0x003fffff,TRUE
),
113 HOWTO(R_SPARC_HI22
, 10,2,22,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_HI22", FALSE
,0,0x003fffff,TRUE
),
114 HOWTO(R_SPARC_22
, 0,2,22,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_22", FALSE
,0,0x003fffff,TRUE
),
115 HOWTO(R_SPARC_13
, 0,2,13,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_13", FALSE
,0,0x00001fff,TRUE
),
116 HOWTO(R_SPARC_LO10
, 0,2,10,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_LO10", FALSE
,0,0x000003ff,TRUE
),
117 HOWTO(R_SPARC_GOT10
, 0,2,10,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_GOT10", FALSE
,0,0x000003ff,TRUE
),
118 HOWTO(R_SPARC_GOT13
, 0,2,13,FALSE
,0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_GOT13", FALSE
,0,0x00001fff,TRUE
),
119 HOWTO(R_SPARC_GOT22
, 10,2,22,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_GOT22", FALSE
,0,0x003fffff,TRUE
),
120 HOWTO(R_SPARC_PC10
, 0,2,10,TRUE
, 0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_PC10", FALSE
,0,0x000003ff,TRUE
),
121 HOWTO(R_SPARC_PC22
, 10,2,22,TRUE
, 0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_PC22", FALSE
,0,0x003fffff,TRUE
),
122 HOWTO(R_SPARC_WPLT30
, 2,2,30,TRUE
, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_WPLT30", FALSE
,0,0x3fffffff,TRUE
),
123 HOWTO(R_SPARC_COPY
, 0,0,00,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_COPY", FALSE
,0,0x00000000,TRUE
),
124 HOWTO(R_SPARC_GLOB_DAT
, 0,0,00,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_GLOB_DAT",FALSE
,0,0x00000000,TRUE
),
125 HOWTO(R_SPARC_JMP_SLOT
, 0,0,00,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_JMP_SLOT",FALSE
,0,0x00000000,TRUE
),
126 HOWTO(R_SPARC_RELATIVE
, 0,0,00,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_RELATIVE",FALSE
,0,0x00000000,TRUE
),
127 HOWTO(R_SPARC_UA32
, 0,2,32,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_UA32", FALSE
,0,0xffffffff,TRUE
),
128 HOWTO(R_SPARC_PLT32
, 0,0,00,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_PLT32", FALSE
,0,0xffffffff,TRUE
),
129 HOWTO(R_SPARC_HIPLT22
, 0,0,00,FALSE
,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_HIPLT22", FALSE
,0,0x00000000,TRUE
),
130 HOWTO(R_SPARC_LOPLT10
, 0,0,00,FALSE
,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_LOPLT10", FALSE
,0,0x00000000,TRUE
),
131 HOWTO(R_SPARC_PCPLT32
, 0,0,00,FALSE
,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_PCPLT32", FALSE
,0,0x00000000,TRUE
),
132 HOWTO(R_SPARC_PCPLT22
, 0,0,00,FALSE
,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_PCPLT22", FALSE
,0,0x00000000,TRUE
),
133 HOWTO(R_SPARC_PCPLT10
, 0,0,00,FALSE
,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_PCPLT10", FALSE
,0,0x00000000,TRUE
),
134 HOWTO(R_SPARC_10
, 0,2,10,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_10", FALSE
,0,0x000003ff,TRUE
),
135 HOWTO(R_SPARC_11
, 0,2,11,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_11", FALSE
,0,0x000007ff,TRUE
),
136 /* These are for sparc64 in a 64 bit environment.
137 Values need to be here because the table is indexed by reloc number. */
138 HOWTO(R_SPARC_64
, 0,0,00,FALSE
,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_64", FALSE
,0,0x00000000,TRUE
),
139 HOWTO(R_SPARC_OLO10
, 0,0,00,FALSE
,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_OLO10", FALSE
,0,0x00000000,TRUE
),
140 HOWTO(R_SPARC_HH22
, 0,0,00,FALSE
,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_HH22", FALSE
,0,0x00000000,TRUE
),
141 HOWTO(R_SPARC_HM10
, 0,0,00,FALSE
,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_HM10", FALSE
,0,0x00000000,TRUE
),
142 HOWTO(R_SPARC_LM22
, 0,0,00,FALSE
,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_LM22", FALSE
,0,0x00000000,TRUE
),
143 HOWTO(R_SPARC_PC_HH22
, 0,0,00,FALSE
,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_PC_HH22", FALSE
,0,0x00000000,TRUE
),
144 HOWTO(R_SPARC_PC_HM10
, 0,0,00,FALSE
,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_PC_HM10", FALSE
,0,0x00000000,TRUE
),
145 HOWTO(R_SPARC_PC_LM22
, 0,0,00,FALSE
,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_PC_LM22", FALSE
,0,0x00000000,TRUE
),
146 /* End sparc64 in 64 bit environment values.
147 The following are for sparc64 in a 32 bit environment. */
148 HOWTO(R_SPARC_WDISP16
, 2,2,16,TRUE
, 0,complain_overflow_signed
, sparc_elf_wdisp16_reloc
,"R_SPARC_WDISP16", FALSE
,0,0x00000000,TRUE
),
149 HOWTO(R_SPARC_WDISP19
, 2,2,19,TRUE
, 0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_WDISP19", FALSE
,0,0x0007ffff,TRUE
),
150 HOWTO(R_SPARC_UNUSED_42
, 0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_UNUSED_42",FALSE
,0,0x00000000,TRUE
),
151 HOWTO(R_SPARC_7
, 0,2, 7,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_7", FALSE
,0,0x0000007f,TRUE
),
152 HOWTO(R_SPARC_5
, 0,2, 5,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_5", FALSE
,0,0x0000001f,TRUE
),
153 HOWTO(R_SPARC_6
, 0,2, 6,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_6", FALSE
,0,0x0000003f,TRUE
),
154 HOWTO(R_SPARC_NONE
, 0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_NONE", FALSE
,0,0x00000000,TRUE
),
155 HOWTO(R_SPARC_NONE
, 0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_NONE", FALSE
,0,0x00000000,TRUE
),
156 HOWTO(R_SPARC_NONE
, 0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_NONE", FALSE
,0,0x00000000,TRUE
),
157 HOWTO(R_SPARC_NONE
, 0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_NONE", FALSE
,0,0x00000000,TRUE
),
158 HOWTO(R_SPARC_NONE
, 0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_NONE", FALSE
,0,0x00000000,TRUE
),
159 HOWTO(R_SPARC_NONE
, 0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_NONE", FALSE
,0,0x00000000,TRUE
),
160 HOWTO(R_SPARC_NONE
, 0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_NONE", FALSE
,0,0x00000000,TRUE
),
161 HOWTO(R_SPARC_NONE
, 0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_NONE", FALSE
,0,0x00000000,TRUE
),
162 HOWTO(R_SPARC_UA64
, 0,0, 0,FALSE
,0,complain_overflow_dont
, sparc_elf_notsupported_reloc
, "R_SPARC_UA64", FALSE
,0,0x00000000,TRUE
),
163 HOWTO(R_SPARC_UA16
, 0,1,16,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_UA16", FALSE
,0,0x0000ffff,TRUE
),
164 HOWTO(R_SPARC_TLS_GD_HI22
,10,2,22,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_GD_HI22",FALSE
,0,0x003fffff,TRUE
),
165 HOWTO(R_SPARC_TLS_GD_LO10
,0,2,10,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_GD_LO10",FALSE
,0,0x000003ff,TRUE
),
166 HOWTO(R_SPARC_TLS_GD_ADD
,0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_GD_ADD",FALSE
,0,0x00000000,TRUE
),
167 HOWTO(R_SPARC_TLS_GD_CALL
,2,2,30,TRUE
,0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_TLS_GD_CALL",FALSE
,0,0x3fffffff,TRUE
),
168 HOWTO(R_SPARC_TLS_LDM_HI22
,10,2,22,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_LDM_HI22",FALSE
,0,0x003fffff,TRUE
),
169 HOWTO(R_SPARC_TLS_LDM_LO10
,0,2,10,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_LDM_LO10",FALSE
,0,0x000003ff,TRUE
),
170 HOWTO(R_SPARC_TLS_LDM_ADD
,0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_LDM_ADD",FALSE
,0,0x00000000,TRUE
),
171 HOWTO(R_SPARC_TLS_LDM_CALL
,2,2,30,TRUE
,0,complain_overflow_signed
, bfd_elf_generic_reloc
, "R_SPARC_TLS_LDM_CALL",FALSE
,0,0x3fffffff,TRUE
),
172 HOWTO(R_SPARC_TLS_LDO_HIX22
,0,2,0,FALSE
,0,complain_overflow_bitfield
,sparc_elf_hix22_reloc
,"R_SPARC_TLS_LDO_HIX22",FALSE
,0,0x003fffff, FALSE
),
173 HOWTO(R_SPARC_TLS_LDO_LOX10
,0,2,0,FALSE
,0,complain_overflow_dont
, sparc_elf_lox10_reloc
, "R_SPARC_TLS_LDO_LOX10",FALSE
,0,0x000003ff, FALSE
),
174 HOWTO(R_SPARC_TLS_LDO_ADD
,0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_LDO_ADD",FALSE
,0,0x00000000,TRUE
),
175 HOWTO(R_SPARC_TLS_IE_HI22
,10,2,22,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_IE_HI22",FALSE
,0,0x003fffff,TRUE
),
176 HOWTO(R_SPARC_TLS_IE_LO10
,0,2,10,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_IE_LO10",FALSE
,0,0x000003ff,TRUE
),
177 HOWTO(R_SPARC_TLS_IE_LD
,0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_IE_LD",FALSE
,0,0x00000000,TRUE
),
178 HOWTO(R_SPARC_TLS_IE_LDX
,0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_IE_LDX",FALSE
,0,0x00000000,TRUE
),
179 HOWTO(R_SPARC_TLS_IE_ADD
,0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_IE_ADD",FALSE
,0,0x00000000,TRUE
),
180 HOWTO(R_SPARC_TLS_LE_HIX22
,0,2,0,FALSE
,0,complain_overflow_bitfield
,sparc_elf_hix22_reloc
, "R_SPARC_TLS_LE_HIX22",FALSE
,0,0x003fffff, FALSE
),
181 HOWTO(R_SPARC_TLS_LE_LOX10
,0,2,0,FALSE
,0,complain_overflow_dont
, sparc_elf_lox10_reloc
, "R_SPARC_TLS_LE_LOX10",FALSE
,0,0x000003ff, FALSE
),
182 HOWTO(R_SPARC_TLS_DTPMOD32
,0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_DTPMOD32",FALSE
,0,0x00000000,TRUE
),
183 HOWTO(R_SPARC_TLS_DTPMOD64
,0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_DTPMOD64",FALSE
,0,0x00000000,TRUE
),
184 HOWTO(R_SPARC_TLS_DTPOFF32
,0,2,32,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
,"R_SPARC_TLS_DTPOFF32",FALSE
,0,0xffffffff,TRUE
),
185 HOWTO(R_SPARC_TLS_DTPOFF64
,0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_DTPOFF64",FALSE
,0,0x00000000,TRUE
),
186 HOWTO(R_SPARC_TLS_TPOFF32
,0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_TPOFF32",FALSE
,0,0x00000000,TRUE
),
187 HOWTO(R_SPARC_TLS_TPOFF64
,0,0, 0,FALSE
,0,complain_overflow_dont
, bfd_elf_generic_reloc
, "R_SPARC_TLS_TPOFF64",FALSE
,0,0x00000000,TRUE
)
189 static reloc_howto_type elf32_sparc_vtinherit_howto
=
190 HOWTO (R_SPARC_GNU_VTINHERIT
, 0,2,0,FALSE
,0,complain_overflow_dont
, NULL
, "R_SPARC_GNU_VTINHERIT", FALSE
,0, 0, FALSE
);
191 static reloc_howto_type elf32_sparc_vtentry_howto
=
192 HOWTO (R_SPARC_GNU_VTENTRY
, 0,2,0,FALSE
,0,complain_overflow_dont
, _bfd_elf_rel_vtable_reloc_fn
,"R_SPARC_GNU_VTENTRY", FALSE
,0,0, FALSE
);
193 static reloc_howto_type elf32_sparc_rev32_howto
=
194 HOWTO(R_SPARC_REV32
, 0,2,32,FALSE
,0,complain_overflow_bitfield
,bfd_elf_generic_reloc
, "R_SPARC_REV32", FALSE
,0,0xffffffff,TRUE
);
196 struct elf_reloc_map
{
197 bfd_reloc_code_real_type bfd_reloc_val
;
198 unsigned char elf_reloc_val
;
201 static const struct elf_reloc_map sparc_reloc_map
[] =
203 { BFD_RELOC_NONE
, R_SPARC_NONE
, },
204 { BFD_RELOC_16
, R_SPARC_16
, },
205 { BFD_RELOC_16_PCREL
, R_SPARC_DISP16
},
206 { BFD_RELOC_8
, R_SPARC_8
},
207 { BFD_RELOC_8_PCREL
, R_SPARC_DISP8
},
208 { BFD_RELOC_CTOR
, R_SPARC_32
},
209 { BFD_RELOC_32
, R_SPARC_32
},
210 { BFD_RELOC_32_PCREL
, R_SPARC_DISP32
},
211 { BFD_RELOC_HI22
, R_SPARC_HI22
},
212 { BFD_RELOC_LO10
, R_SPARC_LO10
, },
213 { BFD_RELOC_32_PCREL_S2
, R_SPARC_WDISP30
},
214 { BFD_RELOC_SPARC_PLT32
, R_SPARC_PLT32
},
215 { BFD_RELOC_SPARC22
, R_SPARC_22
},
216 { BFD_RELOC_SPARC13
, R_SPARC_13
},
217 { BFD_RELOC_SPARC_GOT10
, R_SPARC_GOT10
},
218 { BFD_RELOC_SPARC_GOT13
, R_SPARC_GOT13
},
219 { BFD_RELOC_SPARC_GOT22
, R_SPARC_GOT22
},
220 { BFD_RELOC_SPARC_PC10
, R_SPARC_PC10
},
221 { BFD_RELOC_SPARC_PC22
, R_SPARC_PC22
},
222 { BFD_RELOC_SPARC_WPLT30
, R_SPARC_WPLT30
},
223 { BFD_RELOC_SPARC_COPY
, R_SPARC_COPY
},
224 { BFD_RELOC_SPARC_GLOB_DAT
, R_SPARC_GLOB_DAT
},
225 { BFD_RELOC_SPARC_JMP_SLOT
, R_SPARC_JMP_SLOT
},
226 { BFD_RELOC_SPARC_RELATIVE
, R_SPARC_RELATIVE
},
227 { BFD_RELOC_SPARC_WDISP22
, R_SPARC_WDISP22
},
228 { BFD_RELOC_SPARC_UA16
, R_SPARC_UA16
},
229 { BFD_RELOC_SPARC_UA32
, R_SPARC_UA32
},
230 { BFD_RELOC_SPARC_UA64
, R_SPARC_UA64
},
231 { BFD_RELOC_SPARC_10
, R_SPARC_10
},
232 { BFD_RELOC_SPARC_11
, R_SPARC_11
},
233 { BFD_RELOC_SPARC_64
, R_SPARC_64
},
234 { BFD_RELOC_SPARC_OLO10
, R_SPARC_OLO10
},
235 { BFD_RELOC_SPARC_HH22
, R_SPARC_HH22
},
236 { BFD_RELOC_SPARC_HM10
, R_SPARC_HM10
},
237 { BFD_RELOC_SPARC_LM22
, R_SPARC_LM22
},
238 { BFD_RELOC_SPARC_PC_HH22
, R_SPARC_PC_HH22
},
239 { BFD_RELOC_SPARC_PC_HM10
, R_SPARC_PC_HM10
},
240 { BFD_RELOC_SPARC_PC_LM22
, R_SPARC_PC_LM22
},
241 { BFD_RELOC_SPARC_WDISP16
, R_SPARC_WDISP16
},
242 { BFD_RELOC_SPARC_WDISP19
, R_SPARC_WDISP19
},
243 { BFD_RELOC_SPARC_7
, R_SPARC_7
},
244 { BFD_RELOC_SPARC_5
, R_SPARC_5
},
245 { BFD_RELOC_SPARC_6
, R_SPARC_6
},
246 { BFD_RELOC_SPARC_TLS_GD_HI22
, R_SPARC_TLS_GD_HI22
},
247 { BFD_RELOC_SPARC_TLS_GD_LO10
, R_SPARC_TLS_GD_LO10
},
248 { BFD_RELOC_SPARC_TLS_GD_ADD
, R_SPARC_TLS_GD_ADD
},
249 { BFD_RELOC_SPARC_TLS_GD_CALL
, R_SPARC_TLS_GD_CALL
},
250 { BFD_RELOC_SPARC_TLS_LDM_HI22
, R_SPARC_TLS_LDM_HI22
},
251 { BFD_RELOC_SPARC_TLS_LDM_LO10
, R_SPARC_TLS_LDM_LO10
},
252 { BFD_RELOC_SPARC_TLS_LDM_ADD
, R_SPARC_TLS_LDM_ADD
},
253 { BFD_RELOC_SPARC_TLS_LDM_CALL
, R_SPARC_TLS_LDM_CALL
},
254 { BFD_RELOC_SPARC_TLS_LDO_HIX22
, R_SPARC_TLS_LDO_HIX22
},
255 { BFD_RELOC_SPARC_TLS_LDO_LOX10
, R_SPARC_TLS_LDO_LOX10
},
256 { BFD_RELOC_SPARC_TLS_LDO_ADD
, R_SPARC_TLS_LDO_ADD
},
257 { BFD_RELOC_SPARC_TLS_IE_HI22
, R_SPARC_TLS_IE_HI22
},
258 { BFD_RELOC_SPARC_TLS_IE_LO10
, R_SPARC_TLS_IE_LO10
},
259 { BFD_RELOC_SPARC_TLS_IE_LD
, R_SPARC_TLS_IE_LD
},
260 { BFD_RELOC_SPARC_TLS_IE_LDX
, R_SPARC_TLS_IE_LDX
},
261 { BFD_RELOC_SPARC_TLS_IE_ADD
, R_SPARC_TLS_IE_ADD
},
262 { BFD_RELOC_SPARC_TLS_LE_HIX22
, R_SPARC_TLS_LE_HIX22
},
263 { BFD_RELOC_SPARC_TLS_LE_LOX10
, R_SPARC_TLS_LE_LOX10
},
264 { BFD_RELOC_SPARC_TLS_DTPMOD32
, R_SPARC_TLS_DTPMOD32
},
265 { BFD_RELOC_SPARC_TLS_DTPMOD64
, R_SPARC_TLS_DTPMOD64
},
266 { BFD_RELOC_SPARC_TLS_DTPOFF32
, R_SPARC_TLS_DTPOFF32
},
267 { BFD_RELOC_SPARC_TLS_DTPOFF64
, R_SPARC_TLS_DTPOFF64
},
268 { BFD_RELOC_SPARC_TLS_TPOFF32
, R_SPARC_TLS_TPOFF32
},
269 { BFD_RELOC_SPARC_TLS_TPOFF64
, R_SPARC_TLS_TPOFF64
},
270 { BFD_RELOC_VTABLE_INHERIT
, R_SPARC_GNU_VTINHERIT
},
271 { BFD_RELOC_VTABLE_ENTRY
, R_SPARC_GNU_VTENTRY
},
272 { BFD_RELOC_SPARC_REV32
, R_SPARC_REV32
}
275 static reloc_howto_type
*
276 elf32_sparc_reloc_type_lookup (abfd
, code
)
277 bfd
*abfd ATTRIBUTE_UNUSED
;
278 bfd_reloc_code_real_type code
;
284 case BFD_RELOC_VTABLE_INHERIT
:
285 return &elf32_sparc_vtinherit_howto
;
287 case BFD_RELOC_VTABLE_ENTRY
:
288 return &elf32_sparc_vtentry_howto
;
290 case BFD_RELOC_SPARC_REV32
:
291 return &elf32_sparc_rev32_howto
;
295 i
< sizeof (sparc_reloc_map
) / sizeof (struct elf_reloc_map
);
298 if (sparc_reloc_map
[i
].bfd_reloc_val
== code
)
299 return (_bfd_sparc_elf_howto_table
300 + (int) sparc_reloc_map
[i
].elf_reloc_val
);
303 bfd_set_error (bfd_error_bad_value
);
307 /* We need to use ELF32_R_TYPE so we have our own copy of this function,
308 and elf64-sparc.c has its own copy. */
311 elf32_sparc_info_to_howto (abfd
, cache_ptr
, dst
)
312 bfd
*abfd ATTRIBUTE_UNUSED
;
314 Elf_Internal_Rela
*dst
;
316 switch (ELF32_R_TYPE(dst
->r_info
))
318 case R_SPARC_GNU_VTINHERIT
:
319 cache_ptr
->howto
= &elf32_sparc_vtinherit_howto
;
322 case R_SPARC_GNU_VTENTRY
:
323 cache_ptr
->howto
= &elf32_sparc_vtentry_howto
;
327 cache_ptr
->howto
= &elf32_sparc_rev32_howto
;
331 BFD_ASSERT (ELF32_R_TYPE(dst
->r_info
) < (unsigned int) R_SPARC_max_std
);
332 cache_ptr
->howto
= &_bfd_sparc_elf_howto_table
[ELF32_R_TYPE(dst
->r_info
)];
336 /* For unsupported relocs. */
338 static bfd_reloc_status_type
339 sparc_elf_notsupported_reloc (abfd
,
346 bfd
*abfd ATTRIBUTE_UNUSED
;
347 arelent
*reloc_entry ATTRIBUTE_UNUSED
;
348 asymbol
*symbol ATTRIBUTE_UNUSED
;
349 PTR data ATTRIBUTE_UNUSED
;
350 asection
*input_section ATTRIBUTE_UNUSED
;
351 bfd
*output_bfd ATTRIBUTE_UNUSED
;
352 char **error_message ATTRIBUTE_UNUSED
;
354 return bfd_reloc_notsupported
;
357 /* Handle the WDISP16 reloc. */
359 static bfd_reloc_status_type
360 sparc_elf_wdisp16_reloc (abfd
,
368 arelent
*reloc_entry
;
371 asection
*input_section
;
373 char **error_message ATTRIBUTE_UNUSED
;
379 if (output_bfd
!= (bfd
*) NULL
380 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
381 && (! reloc_entry
->howto
->partial_inplace
382 || reloc_entry
->addend
== 0))
384 reloc_entry
->address
+= input_section
->output_offset
;
388 if (output_bfd
!= NULL
)
389 return bfd_reloc_continue
;
391 sz
= input_section
->rawsize
? input_section
->rawsize
: input_section
->size
;
392 if (reloc_entry
->address
> sz
)
393 return bfd_reloc_outofrange
;
395 relocation
= (symbol
->value
396 + symbol
->section
->output_section
->vma
397 + symbol
->section
->output_offset
);
398 relocation
+= reloc_entry
->addend
;
399 relocation
-= (input_section
->output_section
->vma
400 + input_section
->output_offset
);
401 relocation
-= reloc_entry
->address
;
403 x
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
404 x
|= ((((relocation
>> 2) & 0xc000) << 6)
405 | ((relocation
>> 2) & 0x3fff));
406 bfd_put_32 (abfd
, x
, (bfd_byte
*) data
+ reloc_entry
->address
);
408 if ((bfd_signed_vma
) relocation
< - 0x40000
409 || (bfd_signed_vma
) relocation
> 0x3ffff)
410 return bfd_reloc_overflow
;
415 /* Handle the HIX22 reloc. */
417 static bfd_reloc_status_type
418 sparc_elf_hix22_reloc (abfd
,
426 arelent
*reloc_entry
;
429 asection
*input_section
;
431 char **error_message ATTRIBUTE_UNUSED
;
437 if (output_bfd
!= (bfd
*) NULL
438 && (symbol
->flags
& BSF_SECTION_SYM
) == 0)
440 reloc_entry
->address
+= input_section
->output_offset
;
444 if (output_bfd
!= NULL
)
445 return bfd_reloc_continue
;
447 sz
= input_section
->rawsize
? input_section
->rawsize
: input_section
->size
;
448 if (reloc_entry
->address
> sz
)
449 return bfd_reloc_outofrange
;
451 relocation
= (symbol
->value
452 + symbol
->section
->output_section
->vma
453 + symbol
->section
->output_offset
);
454 relocation
+= reloc_entry
->addend
;
455 insn
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
457 insn
= (insn
&~ (bfd_vma
) 0x3fffff) | (((~relocation
) >> 10) & 0x3fffff);
458 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ reloc_entry
->address
);
463 /* Handle the LOX10 reloc. */
465 static bfd_reloc_status_type
466 sparc_elf_lox10_reloc (abfd
,
474 arelent
*reloc_entry
;
477 asection
*input_section
;
479 char **error_message ATTRIBUTE_UNUSED
;
485 if (output_bfd
!= (bfd
*) NULL
486 && (symbol
->flags
& BSF_SECTION_SYM
) == 0)
488 reloc_entry
->address
+= input_section
->output_offset
;
492 if (output_bfd
!= NULL
)
493 return bfd_reloc_continue
;
495 sz
= input_section
->rawsize
? input_section
->rawsize
: input_section
->size
;
496 if (reloc_entry
->address
> sz
)
497 return bfd_reloc_outofrange
;
499 relocation
= (symbol
->value
500 + symbol
->section
->output_section
->vma
501 + symbol
->section
->output_offset
);
502 relocation
+= reloc_entry
->addend
;
503 insn
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
505 insn
= (insn
&~ (bfd_vma
) 0x1fff) | 0x1c00 | (relocation
& 0x3ff);
506 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ reloc_entry
->address
);
511 /* Support for core dump NOTE sections. */
514 elf32_sparc_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
516 switch (note
->descsz
)
521 case 260: /* Solaris prpsinfo_t. */
522 elf_tdata (abfd
)->core_program
523 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 84, 16);
524 elf_tdata (abfd
)->core_command
525 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 100, 80);
528 case 336: /* Solaris psinfo_t. */
529 elf_tdata (abfd
)->core_program
530 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 88, 16);
531 elf_tdata (abfd
)->core_command
532 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 104, 80);
540 /* Functions for the SPARC ELF linker. */
542 /* The name of the dynamic interpreter. This is put in the .interp
545 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
547 /* The nop opcode we use. */
549 #define SPARC_NOP 0x01000000
551 /* The size in bytes of an entry in the procedure linkage table. */
553 #define PLT_ENTRY_SIZE 12
555 /* The first four entries in a procedure linkage table are reserved,
556 and the initial contents are unimportant (we zero them out).
557 Subsequent entries look like this. See the SVR4 ABI SPARC
558 supplement to see how this works. */
560 /* sethi %hi(.-.plt0),%g1. We fill in the address later. */
561 #define PLT_ENTRY_WORD0 0x03000000
562 /* b,a .plt0. We fill in the offset later. */
563 #define PLT_ENTRY_WORD1 0x30800000
565 #define PLT_ENTRY_WORD2 SPARC_NOP
567 /* The SPARC linker needs to keep track of the number of relocs that it
568 decides to copy as dynamic relocs in check_relocs for each symbol.
569 This is so that it can later discard them if they are found to be
570 unnecessary. We store the information in a field extending the
571 regular ELF linker hash table. */
573 struct elf32_sparc_dyn_relocs
575 struct elf32_sparc_dyn_relocs
*next
;
577 /* The input section of the reloc. */
580 /* Total number of relocs copied for the input section. */
583 /* Number of pc-relative relocs copied for the input section. */
584 bfd_size_type pc_count
;
587 /* SPARC ELF linker hash entry. */
589 struct elf32_sparc_link_hash_entry
591 struct elf_link_hash_entry elf
;
593 /* Track dynamic relocs copied for this symbol. */
594 struct elf32_sparc_dyn_relocs
*dyn_relocs
;
596 #define GOT_UNKNOWN 0
600 unsigned char tls_type
;
603 #define elf32_sparc_hash_entry(ent) ((struct elf32_sparc_link_hash_entry *)(ent))
605 struct elf32_sparc_obj_tdata
607 struct elf_obj_tdata root
;
609 /* tls_type for each local got entry. */
610 char *local_got_tls_type
;
612 /* TRUE if TLS GD relocs has been seen for this object. */
613 bfd_boolean has_tlsgd
;
616 #define elf32_sparc_tdata(abfd) \
617 ((struct elf32_sparc_obj_tdata *) (abfd)->tdata.any)
619 #define elf32_sparc_local_got_tls_type(abfd) \
620 (elf32_sparc_tdata (abfd)->local_got_tls_type)
623 elf32_sparc_mkobject (abfd
)
626 bfd_size_type amt
= sizeof (struct elf32_sparc_obj_tdata
);
627 abfd
->tdata
.any
= bfd_zalloc (abfd
, amt
);
628 if (abfd
->tdata
.any
== NULL
)
633 /* SPARC ELF linker hash table. */
635 struct elf32_sparc_link_hash_table
637 struct elf_link_hash_table elf
;
639 /* Short-cuts to get to dynamic linker sections. */
648 bfd_signed_vma refcount
;
652 /* Small local sym to section mapping cache. */
653 struct sym_sec_cache sym_sec
;
656 /* Get the SPARC ELF linker hash table from a link_info structure. */
658 #define elf32_sparc_hash_table(p) \
659 ((struct elf32_sparc_link_hash_table *) ((p)->hash))
661 /* Create an entry in an i386 ELF linker hash table. */
663 static struct bfd_hash_entry
*
664 link_hash_newfunc (entry
, table
, string
)
665 struct bfd_hash_entry
*entry
;
666 struct bfd_hash_table
*table
;
669 /* Allocate the structure if it has not already been allocated by a
673 entry
= bfd_hash_allocate (table
,
674 sizeof (struct elf32_sparc_link_hash_entry
));
679 /* Call the allocation method of the superclass. */
680 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
683 struct elf32_sparc_link_hash_entry
*eh
;
685 eh
= (struct elf32_sparc_link_hash_entry
*) entry
;
686 eh
->dyn_relocs
= NULL
;
687 eh
->tls_type
= GOT_UNKNOWN
;
693 /* Create a SPARC ELF linker hash table. */
695 static struct bfd_link_hash_table
*
696 elf32_sparc_link_hash_table_create (abfd
)
699 struct elf32_sparc_link_hash_table
*ret
;
700 bfd_size_type amt
= sizeof (struct elf32_sparc_link_hash_table
);
702 ret
= (struct elf32_sparc_link_hash_table
*) bfd_malloc (amt
);
706 if (! _bfd_elf_link_hash_table_init (&ret
->elf
, abfd
, link_hash_newfunc
))
718 ret
->tls_ldm_got
.refcount
= 0;
719 ret
->sym_sec
.abfd
= NULL
;
721 return &ret
->elf
.root
;
724 /* Create .got and .rela.got sections in DYNOBJ, and set up
725 shortcuts to them in our hash table. */
728 create_got_section (dynobj
, info
)
730 struct bfd_link_info
*info
;
732 struct elf32_sparc_link_hash_table
*htab
;
734 if (! _bfd_elf_create_got_section (dynobj
, info
))
737 htab
= elf32_sparc_hash_table (info
);
738 htab
->sgot
= bfd_get_section_by_name (dynobj
, ".got");
742 htab
->srelgot
= bfd_make_section (dynobj
, ".rela.got");
743 if (htab
->srelgot
== NULL
744 || ! bfd_set_section_flags (dynobj
, htab
->srelgot
,
745 (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
746 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
748 || ! bfd_set_section_alignment (dynobj
, htab
->srelgot
, 2))
753 /* Create .plt, .rela.plt, .got, .rela.got, .dynbss, and
754 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
758 elf32_sparc_create_dynamic_sections (dynobj
, info
)
760 struct bfd_link_info
*info
;
762 struct elf32_sparc_link_hash_table
*htab
;
764 htab
= elf32_sparc_hash_table (info
);
765 if (!htab
->sgot
&& !create_got_section (dynobj
, info
))
768 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
771 htab
->splt
= bfd_get_section_by_name (dynobj
, ".plt");
772 htab
->srelplt
= bfd_get_section_by_name (dynobj
, ".rela.plt");
773 htab
->sdynbss
= bfd_get_section_by_name (dynobj
, ".dynbss");
775 htab
->srelbss
= bfd_get_section_by_name (dynobj
, ".rela.bss");
777 if (!htab
->splt
|| !htab
->srelplt
|| !htab
->sdynbss
778 || (!info
->shared
&& !htab
->srelbss
))
784 /* Copy the extra info we tack onto an elf_link_hash_entry. */
787 elf32_sparc_copy_indirect_symbol (bed
, dir
, ind
)
788 const struct elf_backend_data
*bed
;
789 struct elf_link_hash_entry
*dir
, *ind
;
791 struct elf32_sparc_link_hash_entry
*edir
, *eind
;
793 edir
= (struct elf32_sparc_link_hash_entry
*) dir
;
794 eind
= (struct elf32_sparc_link_hash_entry
*) ind
;
796 if (eind
->dyn_relocs
!= NULL
)
798 if (edir
->dyn_relocs
!= NULL
)
800 struct elf32_sparc_dyn_relocs
**pp
;
801 struct elf32_sparc_dyn_relocs
*p
;
803 if (ind
->root
.type
== bfd_link_hash_indirect
)
806 /* Add reloc counts against the weak sym to the strong sym
807 list. Merge any entries against the same section. */
808 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
810 struct elf32_sparc_dyn_relocs
*q
;
812 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
813 if (q
->sec
== p
->sec
)
815 q
->pc_count
+= p
->pc_count
;
816 q
->count
+= p
->count
;
823 *pp
= edir
->dyn_relocs
;
826 edir
->dyn_relocs
= eind
->dyn_relocs
;
827 eind
->dyn_relocs
= NULL
;
830 if (ind
->root
.type
== bfd_link_hash_indirect
831 && dir
->got
.refcount
<= 0)
833 edir
->tls_type
= eind
->tls_type
;
834 eind
->tls_type
= GOT_UNKNOWN
;
836 _bfd_elf_link_hash_copy_indirect (bed
, dir
, ind
);
840 elf32_sparc_tls_transition (info
, abfd
, r_type
, is_local
)
841 struct bfd_link_info
*info
;
846 if (r_type
== R_SPARC_TLS_GD_HI22
847 && ! elf32_sparc_tdata (abfd
)->has_tlsgd
)
848 r_type
= R_SPARC_REV32
;
855 case R_SPARC_TLS_GD_HI22
:
857 return R_SPARC_TLS_LE_HIX22
;
858 return R_SPARC_TLS_IE_HI22
;
859 case R_SPARC_TLS_GD_LO10
:
861 return R_SPARC_TLS_LE_LOX10
;
862 return R_SPARC_TLS_IE_LO10
;
863 case R_SPARC_TLS_IE_HI22
:
865 return R_SPARC_TLS_LE_HIX22
;
867 case R_SPARC_TLS_IE_LO10
:
869 return R_SPARC_TLS_LE_LOX10
;
871 case R_SPARC_TLS_LDM_HI22
:
872 return R_SPARC_TLS_LE_HIX22
;
873 case R_SPARC_TLS_LDM_LO10
:
874 return R_SPARC_TLS_LE_LOX10
;
880 /* Look through the relocs for a section during the first phase, and
881 allocate space in the global offset table or procedure linkage
885 elf32_sparc_check_relocs (abfd
, info
, sec
, relocs
)
887 struct bfd_link_info
*info
;
889 const Elf_Internal_Rela
*relocs
;
891 struct elf32_sparc_link_hash_table
*htab
;
892 Elf_Internal_Shdr
*symtab_hdr
;
893 struct elf_link_hash_entry
**sym_hashes
;
894 bfd_vma
*local_got_offsets
;
895 const Elf_Internal_Rela
*rel
;
896 const Elf_Internal_Rela
*rel_end
;
898 bfd_boolean checked_tlsgd
= FALSE
;
900 if (info
->relocatable
)
903 htab
= elf32_sparc_hash_table (info
);
904 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
905 sym_hashes
= elf_sym_hashes (abfd
);
906 local_got_offsets
= elf_local_got_offsets (abfd
);
910 rel_end
= relocs
+ sec
->reloc_count
;
911 for (rel
= relocs
; rel
< rel_end
; rel
++)
914 unsigned long r_symndx
;
915 struct elf_link_hash_entry
*h
;
917 r_symndx
= ELF32_R_SYM (rel
->r_info
);
918 r_type
= ELF32_R_TYPE (rel
->r_info
);
920 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
922 (*_bfd_error_handler
) (_("%s: bad symbol index: %d"),
923 bfd_archive_filename (abfd
),
928 if (r_symndx
< symtab_hdr
->sh_info
)
931 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
933 /* Compatibility with old R_SPARC_REV32 reloc conflicting
934 with R_SPARC_TLS_GD_HI22. */
938 case R_SPARC_TLS_GD_HI22
:
940 const Elf_Internal_Rela
*relt
;
942 for (relt
= rel
+ 1; relt
< rel_end
; relt
++)
943 if (ELF32_R_TYPE (relt
->r_info
) == R_SPARC_TLS_GD_LO10
944 || ELF32_R_TYPE (relt
->r_info
) == R_SPARC_TLS_GD_ADD
945 || ELF32_R_TYPE (relt
->r_info
) == R_SPARC_TLS_GD_CALL
)
947 checked_tlsgd
= TRUE
;
948 elf32_sparc_tdata (abfd
)->has_tlsgd
= relt
< rel_end
;
951 case R_SPARC_TLS_GD_LO10
:
952 case R_SPARC_TLS_GD_ADD
:
953 case R_SPARC_TLS_GD_CALL
:
954 checked_tlsgd
= TRUE
;
955 elf32_sparc_tdata (abfd
)->has_tlsgd
= TRUE
;
959 r_type
= elf32_sparc_tls_transition (info
, abfd
, r_type
, h
== NULL
);
962 case R_SPARC_TLS_LDM_HI22
:
963 case R_SPARC_TLS_LDM_LO10
:
964 htab
->tls_ldm_got
.refcount
+= 1;
967 case R_SPARC_TLS_LE_HIX22
:
968 case R_SPARC_TLS_LE_LOX10
:
973 case R_SPARC_TLS_IE_HI22
:
974 case R_SPARC_TLS_IE_LO10
:
976 info
->flags
|= DF_STATIC_TLS
;
982 case R_SPARC_TLS_GD_HI22
:
983 case R_SPARC_TLS_GD_LO10
:
984 /* This symbol requires a global offset table entry. */
986 int tls_type
, old_tls_type
;
994 tls_type
= GOT_NORMAL
;
996 case R_SPARC_TLS_GD_HI22
:
997 case R_SPARC_TLS_GD_LO10
:
998 tls_type
= GOT_TLS_GD
;
1000 case R_SPARC_TLS_IE_HI22
:
1001 case R_SPARC_TLS_IE_LO10
:
1002 tls_type
= GOT_TLS_IE
;
1008 h
->got
.refcount
+= 1;
1009 old_tls_type
= elf32_sparc_hash_entry(h
)->tls_type
;
1013 bfd_signed_vma
*local_got_refcounts
;
1015 /* This is a global offset table entry for a local symbol. */
1016 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1017 if (local_got_refcounts
== NULL
)
1021 size
= symtab_hdr
->sh_info
;
1022 size
*= (sizeof (bfd_signed_vma
) + sizeof(char));
1023 local_got_refcounts
= ((bfd_signed_vma
*)
1024 bfd_zalloc (abfd
, size
));
1025 if (local_got_refcounts
== NULL
)
1027 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1028 elf32_sparc_local_got_tls_type (abfd
)
1029 = (char *) (local_got_refcounts
+ symtab_hdr
->sh_info
);
1031 local_got_refcounts
[r_symndx
] += 1;
1032 old_tls_type
= elf32_sparc_local_got_tls_type (abfd
) [r_symndx
];
1035 /* If a TLS symbol is accessed using IE at least once,
1036 there is no point to use dynamic model for it. */
1037 if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1038 && (old_tls_type
!= GOT_TLS_GD
1039 || tls_type
!= GOT_TLS_IE
))
1041 if (old_tls_type
== GOT_TLS_IE
&& tls_type
== GOT_TLS_GD
)
1042 tls_type
= old_tls_type
;
1045 (*_bfd_error_handler
)
1046 (_("%s: `%s' accessed both as normal and thread local symbol"),
1047 bfd_archive_filename (abfd
),
1048 h
? h
->root
.root
.string
: "<local>");
1053 if (old_tls_type
!= tls_type
)
1056 elf32_sparc_hash_entry (h
)->tls_type
= tls_type
;
1058 elf32_sparc_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1062 if (htab
->sgot
== NULL
)
1064 if (htab
->elf
.dynobj
== NULL
)
1065 htab
->elf
.dynobj
= abfd
;
1066 if (!create_got_section (htab
->elf
.dynobj
, info
))
1071 case R_SPARC_TLS_GD_CALL
:
1072 case R_SPARC_TLS_LDM_CALL
:
1075 /* These are basically R_SPARC_TLS_WPLT30 relocs against
1077 struct bfd_link_hash_entry
*bh
= NULL
;
1078 if (! _bfd_generic_link_add_one_symbol (info
, abfd
,
1079 "__tls_get_addr", 0,
1080 bfd_und_section_ptr
, 0,
1084 h
= (struct elf_link_hash_entry
*) bh
;
1091 case R_SPARC_WPLT30
:
1092 /* This symbol requires a procedure linkage table entry. We
1093 actually build the entry in adjust_dynamic_symbol,
1094 because this might be a case of linking PIC code without
1095 linking in any dynamic objects, in which case we don't
1096 need to generate a procedure linkage table after all. */
1100 /* The Solaris native assembler will generate a WPLT30
1101 reloc for a local symbol if you assemble a call from
1102 one section to another when using -K pic. We treat
1104 if (ELF32_R_TYPE (rel
->r_info
) == R_SPARC_PLT32
)
1109 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
1111 if (ELF32_R_TYPE (rel
->r_info
) == R_SPARC_PLT32
)
1113 h
->plt
.refcount
+= 1;
1119 h
->elf_link_hash_flags
|= ELF_LINK_NON_GOT_REF
;
1122 && strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
1127 case R_SPARC_DISP16
:
1128 case R_SPARC_DISP32
:
1129 case R_SPARC_WDISP30
:
1130 case R_SPARC_WDISP22
:
1131 case R_SPARC_WDISP19
:
1132 case R_SPARC_WDISP16
:
1143 h
->elf_link_hash_flags
|= ELF_LINK_NON_GOT_REF
;
1146 if (h
!= NULL
&& !info
->shared
)
1148 /* We may need a .plt entry if the function this reloc
1149 refers to is in a shared lib. */
1150 h
->plt
.refcount
+= 1;
1153 /* If we are creating a shared library, and this is a reloc
1154 against a global symbol, or a non PC relative reloc
1155 against a local symbol, then we need to copy the reloc
1156 into the shared library. However, if we are linking with
1157 -Bsymbolic, we do not need to copy a reloc against a
1158 global symbol which is defined in an object we are
1159 including in the link (i.e., DEF_REGULAR is set). At
1160 this point we have not seen all the input files, so it is
1161 possible that DEF_REGULAR is not set now but will be set
1162 later (it is never cleared). In case of a weak definition,
1163 DEF_REGULAR may be cleared later by a strong definition in
1164 a shared library. We account for that possibility below by
1165 storing information in the relocs_copied field of the hash
1166 table entry. A similar situation occurs when creating
1167 shared libraries and symbol visibility changes render the
1170 If on the other hand, we are creating an executable, we
1171 may need to keep relocations for symbols satisfied by a
1172 dynamic library if we manage to avoid copy relocs for the
1175 && (sec
->flags
& SEC_ALLOC
) != 0
1176 && (! _bfd_sparc_elf_howto_table
[r_type
].pc_relative
1178 && (! info
->symbolic
1179 || h
->root
.type
== bfd_link_hash_defweak
1180 || (h
->elf_link_hash_flags
1181 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
1183 && (sec
->flags
& SEC_ALLOC
) != 0
1185 && (h
->root
.type
== bfd_link_hash_defweak
1186 || (h
->elf_link_hash_flags
1187 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
1189 struct elf32_sparc_dyn_relocs
*p
;
1190 struct elf32_sparc_dyn_relocs
**head
;
1192 /* When creating a shared object, we must copy these
1193 relocs into the output file. We create a reloc
1194 section in dynobj and make room for the reloc. */
1200 name
= (bfd_elf_string_from_elf_section
1202 elf_elfheader (abfd
)->e_shstrndx
,
1203 elf_section_data (sec
)->rel_hdr
.sh_name
));
1207 BFD_ASSERT (strncmp (name
, ".rela", 5) == 0
1208 && strcmp (bfd_get_section_name (abfd
, sec
),
1211 if (htab
->elf
.dynobj
== NULL
)
1212 htab
->elf
.dynobj
= abfd
;
1213 dynobj
= htab
->elf
.dynobj
;
1215 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1220 sreloc
= bfd_make_section (dynobj
, name
);
1221 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
1222 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
1223 if ((sec
->flags
& SEC_ALLOC
) != 0)
1224 flags
|= SEC_ALLOC
| SEC_LOAD
;
1226 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
1227 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
1230 elf_section_data (sec
)->sreloc
= sreloc
;
1233 /* If this is a global symbol, we count the number of
1234 relocations we need for this symbol. */
1236 head
= &((struct elf32_sparc_link_hash_entry
*) h
)->dyn_relocs
;
1239 /* Track dynamic relocs needed for local syms too.
1240 We really need local syms available to do this
1244 s
= bfd_section_from_r_symndx (abfd
, &htab
->sym_sec
,
1249 head
= ((struct elf32_sparc_dyn_relocs
**)
1250 &elf_section_data (s
)->local_dynrel
);
1254 if (p
== NULL
|| p
->sec
!= sec
)
1256 bfd_size_type amt
= sizeof *p
;
1257 p
= ((struct elf32_sparc_dyn_relocs
*)
1258 bfd_alloc (htab
->elf
.dynobj
, amt
));
1269 if (_bfd_sparc_elf_howto_table
[r_type
].pc_relative
)
1275 case R_SPARC_GNU_VTINHERIT
:
1276 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1280 case R_SPARC_GNU_VTENTRY
:
1281 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
1294 elf32_sparc_gc_mark_hook (sec
, info
, rel
, h
, sym
)
1296 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1297 Elf_Internal_Rela
*rel
;
1298 struct elf_link_hash_entry
*h
;
1299 Elf_Internal_Sym
*sym
;
1303 switch (ELF32_R_TYPE (rel
->r_info
))
1305 case R_SPARC_GNU_VTINHERIT
:
1306 case R_SPARC_GNU_VTENTRY
:
1310 switch (h
->root
.type
)
1312 case bfd_link_hash_defined
:
1313 case bfd_link_hash_defweak
:
1314 return h
->root
.u
.def
.section
;
1316 case bfd_link_hash_common
:
1317 return h
->root
.u
.c
.p
->section
;
1325 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
1330 /* Update the got entry reference counts for the section being removed. */
1332 elf32_sparc_gc_sweep_hook (abfd
, info
, sec
, relocs
)
1334 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1336 const Elf_Internal_Rela
*relocs
;
1338 Elf_Internal_Shdr
*symtab_hdr
;
1339 struct elf_link_hash_entry
**sym_hashes
;
1340 bfd_signed_vma
*local_got_refcounts
;
1341 const Elf_Internal_Rela
*rel
, *relend
;
1343 elf_section_data (sec
)->local_dynrel
= NULL
;
1345 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1346 sym_hashes
= elf_sym_hashes (abfd
);
1347 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1349 relend
= relocs
+ sec
->reloc_count
;
1350 for (rel
= relocs
; rel
< relend
; rel
++)
1352 unsigned long r_symndx
;
1353 unsigned int r_type
;
1354 struct elf_link_hash_entry
*h
= NULL
;
1356 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1357 if (r_symndx
>= symtab_hdr
->sh_info
)
1359 struct elf32_sparc_link_hash_entry
*eh
;
1360 struct elf32_sparc_dyn_relocs
**pp
;
1361 struct elf32_sparc_dyn_relocs
*p
;
1363 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1364 eh
= (struct elf32_sparc_link_hash_entry
*) h
;
1365 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
1368 /* Everything must go for SEC. */
1374 r_type
= ELF32_R_TYPE (rel
->r_info
);
1375 r_type
= elf32_sparc_tls_transition (info
, abfd
, r_type
, h
!= NULL
);
1378 case R_SPARC_TLS_LDM_HI22
:
1379 case R_SPARC_TLS_LDM_LO10
:
1380 if (elf32_sparc_hash_table (info
)->tls_ldm_got
.refcount
> 0)
1381 elf32_sparc_hash_table (info
)->tls_ldm_got
.refcount
-= 1;
1384 case R_SPARC_TLS_GD_HI22
:
1385 case R_SPARC_TLS_GD_LO10
:
1386 case R_SPARC_TLS_IE_HI22
:
1387 case R_SPARC_TLS_IE_LO10
:
1393 if (h
->got
.refcount
> 0)
1398 if (local_got_refcounts
[r_symndx
] > 0)
1399 local_got_refcounts
[r_symndx
]--;
1406 && strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
1411 case R_SPARC_DISP16
:
1412 case R_SPARC_DISP32
:
1413 case R_SPARC_WDISP30
:
1414 case R_SPARC_WDISP22
:
1415 case R_SPARC_WDISP19
:
1416 case R_SPARC_WDISP16
:
1431 case R_SPARC_WPLT30
:
1434 if (h
->plt
.refcount
> 0)
1447 /* Adjust a symbol defined by a dynamic object and referenced by a
1448 regular object. The current definition is in some section of the
1449 dynamic object, but we're not including those sections. We have to
1450 change the definition to something the rest of the link can
1454 elf32_sparc_adjust_dynamic_symbol (info
, h
)
1455 struct bfd_link_info
*info
;
1456 struct elf_link_hash_entry
*h
;
1458 struct elf32_sparc_link_hash_table
*htab
;
1459 struct elf32_sparc_link_hash_entry
* eh
;
1460 struct elf32_sparc_dyn_relocs
*p
;
1462 unsigned int power_of_two
;
1464 htab
= elf32_sparc_hash_table (info
);
1466 /* Make sure we know what is going on here. */
1467 BFD_ASSERT (htab
->elf
.dynobj
!= NULL
1468 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
1469 || h
->weakdef
!= NULL
1470 || ((h
->elf_link_hash_flags
1471 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1472 && (h
->elf_link_hash_flags
1473 & ELF_LINK_HASH_REF_REGULAR
) != 0
1474 && (h
->elf_link_hash_flags
1475 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
1477 /* If this is a function, put it in the procedure linkage table. We
1478 will fill in the contents of the procedure linkage table later
1479 (although we could actually do it here). The STT_NOTYPE
1480 condition is a hack specifically for the Oracle libraries
1481 delivered for Solaris; for some inexplicable reason, they define
1482 some of their functions as STT_NOTYPE when they really should be
1484 if (h
->type
== STT_FUNC
1485 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0
1486 || (h
->type
== STT_NOTYPE
1487 && (h
->root
.type
== bfd_link_hash_defined
1488 || h
->root
.type
== bfd_link_hash_defweak
)
1489 && (h
->root
.u
.def
.section
->flags
& SEC_CODE
) != 0))
1491 if (h
->plt
.refcount
<= 0
1493 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
1494 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) == 0
1495 && h
->root
.type
!= bfd_link_hash_undefweak
1496 && h
->root
.type
!= bfd_link_hash_undefined
))
1498 /* This case can occur if we saw a WPLT30 reloc in an input
1499 file, but the symbol was never referred to by a dynamic
1500 object, or if all references were garbage collected. In
1501 such a case, we don't actually need to build a procedure
1502 linkage table, and we can just do a WDISP30 reloc instead. */
1503 h
->plt
.offset
= (bfd_vma
) -1;
1504 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1510 h
->plt
.offset
= (bfd_vma
) -1;
1512 /* If this is a weak symbol, and there is a real definition, the
1513 processor independent code will have arranged for us to see the
1514 real definition first, and we can just use the same value. */
1515 if (h
->weakdef
!= NULL
)
1517 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
1518 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
1519 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
1520 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
1524 /* This is a reference to a symbol defined by a dynamic object which
1525 is not a function. */
1527 /* If we are creating a shared library, we must presume that the
1528 only references to the symbol are via the global offset table.
1529 For such cases we need not do anything here; the relocations will
1530 be handled correctly by relocate_section. */
1534 /* If there are no references to this symbol that do not use the
1535 GOT, we don't need to generate a copy reloc. */
1536 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0)
1539 eh
= (struct elf32_sparc_link_hash_entry
*) h
;
1540 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1542 s
= p
->sec
->output_section
;
1543 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1547 /* If we didn't find any dynamic relocs in read-only sections, then
1548 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1551 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_GOT_REF
;
1555 /* We must allocate the symbol in our .dynbss section, which will
1556 become part of the .bss section of the executable. There will be
1557 an entry for this symbol in the .dynsym section. The dynamic
1558 object will contain position independent code, so all references
1559 from the dynamic object to this symbol will go through the global
1560 offset table. The dynamic linker will use the .dynsym entry to
1561 determine the address it must put in the global offset table, so
1562 both the dynamic object and the regular object will refer to the
1563 same memory location for the variable. */
1565 /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker
1566 to copy the initial value out of the dynamic object and into the
1567 runtime process image. We need to remember the offset into the
1568 .rel.bss section we are going to use. */
1569 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
1571 htab
->srelbss
->size
+= sizeof (Elf32_External_Rela
);
1572 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
1575 /* We need to figure out the alignment required for this symbol. I
1576 have no idea how ELF linkers handle this. */
1577 power_of_two
= bfd_log2 (h
->size
);
1578 if (power_of_two
> 3)
1581 /* Apply the required alignment. */
1583 s
->size
= BFD_ALIGN (s
->size
, (bfd_size_type
) (1 << power_of_two
));
1584 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
1586 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
1590 /* Define the symbol as being at this point in the section. */
1591 h
->root
.u
.def
.section
= s
;
1592 h
->root
.u
.def
.value
= s
->size
;
1594 /* Increment the section size to make room for the symbol. */
1600 /* Allocate space in .plt, .got and associated reloc sections for
1604 allocate_dynrelocs (h
, inf
)
1605 struct elf_link_hash_entry
*h
;
1608 struct bfd_link_info
*info
;
1609 struct elf32_sparc_link_hash_table
*htab
;
1610 struct elf32_sparc_link_hash_entry
*eh
;
1611 struct elf32_sparc_dyn_relocs
*p
;
1613 if (h
->root
.type
== bfd_link_hash_indirect
)
1616 if (h
->root
.type
== bfd_link_hash_warning
)
1617 /* When warning symbols are created, they **replace** the "real"
1618 entry in the hash table, thus we never get to see the real
1619 symbol in a hash traversal. So look at it now. */
1620 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1622 info
= (struct bfd_link_info
*) inf
;
1623 htab
= elf32_sparc_hash_table (info
);
1625 if (htab
->elf
.dynamic_sections_created
1626 && h
->plt
.refcount
> 0)
1628 /* Make sure this symbol is output as a dynamic symbol.
1629 Undefined weak syms won't yet be marked as dynamic. */
1630 if (h
->dynindx
== -1
1631 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1633 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1637 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info
->shared
, h
))
1639 asection
*s
= htab
->splt
;
1641 /* The first four entries in .plt are reserved. */
1643 s
->size
= 4 * PLT_ENTRY_SIZE
;
1645 /* The procedure linkage table has a maximum size. */
1646 if (s
->size
>= 0x400000)
1648 bfd_set_error (bfd_error_bad_value
);
1652 h
->plt
.offset
= s
->size
;
1654 /* If this symbol is not defined in a regular file, and we are
1655 not generating a shared library, then set the symbol to this
1656 location in the .plt. This is required to make function
1657 pointers compare as equal between the normal executable and
1658 the shared library. */
1660 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1662 h
->root
.u
.def
.section
= s
;
1663 h
->root
.u
.def
.value
= h
->plt
.offset
;
1666 /* Make room for this entry. */
1667 s
->size
+= PLT_ENTRY_SIZE
;
1669 /* We also need to make an entry in the .rela.plt section. */
1670 htab
->srelplt
->size
+= sizeof (Elf32_External_Rela
);
1674 h
->plt
.offset
= (bfd_vma
) -1;
1675 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1680 h
->plt
.offset
= (bfd_vma
) -1;
1681 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1684 /* If R_SPARC_TLS_IE_{HI22,LO10} symbol is now local to the binary,
1685 make it a R_SPARC_TLS_LE_{HI22,LO10} requiring no TLS entry. */
1686 if (h
->got
.refcount
> 0
1689 && elf32_sparc_hash_entry(h
)->tls_type
== GOT_TLS_IE
)
1690 h
->got
.offset
= (bfd_vma
) -1;
1691 else if (h
->got
.refcount
> 0)
1695 int tls_type
= elf32_sparc_hash_entry(h
)->tls_type
;
1697 /* Make sure this symbol is output as a dynamic symbol.
1698 Undefined weak syms won't yet be marked as dynamic. */
1699 if (h
->dynindx
== -1
1700 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1702 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1707 h
->got
.offset
= s
->size
;
1709 /* R_SPARC_TLS_GD_HI{22,LO10} needs 2 consecutive GOT slots. */
1710 if (tls_type
== GOT_TLS_GD
)
1712 dyn
= htab
->elf
.dynamic_sections_created
;
1713 /* R_SPARC_TLS_IE_{HI22,LO10} needs one dynamic relocation,
1714 R_SPARC_TLS_GD_{HI22,LO10} needs one if local symbol and two if
1716 if ((tls_type
== GOT_TLS_GD
&& h
->dynindx
== -1)
1717 || tls_type
== GOT_TLS_IE
)
1718 htab
->srelgot
->size
+= sizeof (Elf32_External_Rela
);
1719 else if (tls_type
== GOT_TLS_GD
)
1720 htab
->srelgot
->size
+= 2 * sizeof (Elf32_External_Rela
);
1721 else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
))
1722 htab
->srelgot
->size
+= sizeof (Elf32_External_Rela
);
1725 h
->got
.offset
= (bfd_vma
) -1;
1727 eh
= (struct elf32_sparc_link_hash_entry
*) h
;
1728 if (eh
->dyn_relocs
== NULL
)
1731 /* In the shared -Bsymbolic case, discard space allocated for
1732 dynamic pc-relative relocs against symbols which turn out to be
1733 defined in regular objects. For the normal shared case, discard
1734 space for pc-relative relocs that have become local due to symbol
1735 visibility changes. */
1739 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
1740 && ((h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0
1743 struct elf32_sparc_dyn_relocs
**pp
;
1745 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
1747 p
->count
-= p
->pc_count
;
1758 /* For the non-shared case, discard space for relocs against
1759 symbols which turn out to need copy relocs or are not
1762 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
1763 && (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1764 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1765 || (htab
->elf
.dynamic_sections_created
1766 && (h
->root
.type
== bfd_link_hash_undefweak
1767 || h
->root
.type
== bfd_link_hash_undefined
))))
1769 /* Make sure this symbol is output as a dynamic symbol.
1770 Undefined weak syms won't yet be marked as dynamic. */
1771 if (h
->dynindx
== -1
1772 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1774 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1778 /* If that succeeded, we know we'll be keeping all the
1780 if (h
->dynindx
!= -1)
1784 eh
->dyn_relocs
= NULL
;
1789 /* Finally, allocate space. */
1790 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1792 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
1793 sreloc
->size
+= p
->count
* sizeof (Elf32_External_Rela
);
1799 /* Find any dynamic relocs that apply to read-only sections. */
1802 readonly_dynrelocs (h
, inf
)
1803 struct elf_link_hash_entry
*h
;
1806 struct elf32_sparc_link_hash_entry
*eh
;
1807 struct elf32_sparc_dyn_relocs
*p
;
1809 if (h
->root
.type
== bfd_link_hash_warning
)
1810 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1812 eh
= (struct elf32_sparc_link_hash_entry
*) h
;
1813 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1815 asection
*s
= p
->sec
->output_section
;
1817 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1819 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
1821 info
->flags
|= DF_TEXTREL
;
1823 /* Not an error, just cut short the traversal. */
1830 /* Set the sizes of the dynamic sections. */
1833 elf32_sparc_size_dynamic_sections (output_bfd
, info
)
1834 bfd
*output_bfd ATTRIBUTE_UNUSED
;
1835 struct bfd_link_info
*info
;
1837 struct elf32_sparc_link_hash_table
*htab
;
1842 htab
= elf32_sparc_hash_table (info
);
1843 dynobj
= htab
->elf
.dynobj
;
1844 BFD_ASSERT (dynobj
!= NULL
);
1846 if (elf_hash_table (info
)->dynamic_sections_created
)
1848 /* Set the contents of the .interp section to the interpreter. */
1849 if (info
->executable
)
1851 s
= bfd_get_section_by_name (dynobj
, ".interp");
1852 BFD_ASSERT (s
!= NULL
);
1853 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1854 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1858 /* Set up .got offsets for local syms, and space for local dynamic
1860 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
1862 bfd_signed_vma
*local_got
;
1863 bfd_signed_vma
*end_local_got
;
1864 char *local_tls_type
;
1865 bfd_size_type locsymcount
;
1866 Elf_Internal_Shdr
*symtab_hdr
;
1869 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
1872 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
1874 struct elf32_sparc_dyn_relocs
*p
;
1876 for (p
= *((struct elf32_sparc_dyn_relocs
**)
1877 &elf_section_data (s
)->local_dynrel
);
1881 if (!bfd_is_abs_section (p
->sec
)
1882 && bfd_is_abs_section (p
->sec
->output_section
))
1884 /* Input section has been discarded, either because
1885 it is a copy of a linkonce section or due to
1886 linker script /DISCARD/, so we'll be discarding
1889 else if (p
->count
!= 0)
1891 srel
= elf_section_data (p
->sec
)->sreloc
;
1892 srel
->size
+= p
->count
* sizeof (Elf32_External_Rela
);
1893 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
1894 info
->flags
|= DF_TEXTREL
;
1899 local_got
= elf_local_got_refcounts (ibfd
);
1903 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
1904 locsymcount
= symtab_hdr
->sh_info
;
1905 end_local_got
= local_got
+ locsymcount
;
1906 local_tls_type
= elf32_sparc_local_got_tls_type (ibfd
);
1908 srel
= htab
->srelgot
;
1909 for (; local_got
< end_local_got
; ++local_got
, ++local_tls_type
)
1913 *local_got
= s
->size
;
1915 if (*local_tls_type
== GOT_TLS_GD
)
1918 || *local_tls_type
== GOT_TLS_GD
1919 || *local_tls_type
== GOT_TLS_IE
)
1920 srel
->size
+= sizeof (Elf32_External_Rela
);
1923 *local_got
= (bfd_vma
) -1;
1927 if (htab
->tls_ldm_got
.refcount
> 0)
1929 /* Allocate 2 got entries and 1 dynamic reloc for
1930 R_SPARC_TLS_LDM_{HI22,LO10} relocs. */
1931 htab
->tls_ldm_got
.offset
= htab
->sgot
->size
;
1932 htab
->sgot
->size
+= 8;
1933 htab
->srelgot
->size
+= sizeof (Elf32_External_Rela
);
1936 htab
->tls_ldm_got
.offset
= -1;
1938 /* Allocate global sym .plt and .got entries, and space for global
1939 sym dynamic relocs. */
1940 elf_link_hash_traverse (&htab
->elf
, allocate_dynrelocs
, (PTR
) info
);
1942 if (elf_hash_table (info
)->dynamic_sections_created
)
1944 /* Make space for the trailing nop in .plt. */
1945 if (htab
->splt
->size
> 0)
1946 htab
->splt
->size
+= 4;
1948 /* If the .got section is more than 0x1000 bytes, we add
1949 0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13
1950 bit relocations have a greater chance of working. */
1951 if (htab
->sgot
->size
>= 0x1000
1952 && elf_hash_table (info
)->hgot
->root
.u
.def
.value
== 0)
1953 elf_hash_table (info
)->hgot
->root
.u
.def
.value
= 0x1000;
1956 /* The check_relocs and adjust_dynamic_symbol entry points have
1957 determined the sizes of the various dynamic sections. Allocate
1959 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1962 bfd_boolean strip
= FALSE
;
1964 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1967 /* It's OK to base decisions on the section name, because none
1968 of the dynobj section names depend upon the input files. */
1969 name
= bfd_get_section_name (dynobj
, s
);
1971 if (strncmp (name
, ".rela", 5) == 0)
1975 /* If we don't need this section, strip it from the
1976 output file. This is to handle .rela.bss and
1977 .rel.plt. We must create it in
1978 create_dynamic_sections, because it must be created
1979 before the linker maps input sections to output
1980 sections. The linker does that before
1981 adjust_dynamic_symbol is called, and it is that
1982 function which decides whether anything needs to go
1983 into these sections. */
1988 /* We use the reloc_count field as a counter if we need
1989 to copy relocs into the output file. */
1993 else if (s
!= htab
->splt
&& s
!= htab
->sgot
)
1995 /* It's not one of our sections, so don't allocate space. */
2001 _bfd_strip_section_from_output (info
, s
);
2005 /* Allocate memory for the section contents. */
2006 /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
2007 Unused entries should be reclaimed before the section's contents
2008 are written out, but at the moment this does not happen. Thus in
2009 order to prevent writing out garbage, we initialise the section's
2010 contents to zero. */
2011 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
2012 if (s
->contents
== NULL
&& s
->size
!= 0)
2016 if (elf_hash_table (info
)->dynamic_sections_created
)
2018 /* Add some entries to the .dynamic section. We fill in the
2019 values later, in elf32_sparc_finish_dynamic_sections, but we
2020 must add the entries now so that we get the correct size for
2021 the .dynamic section. The DT_DEBUG entry is filled in by the
2022 dynamic linker and used by the debugger. */
2023 #define add_dynamic_entry(TAG, VAL) \
2024 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2026 if (info
->executable
)
2028 if (!add_dynamic_entry (DT_DEBUG
, 0))
2032 if (htab
->srelplt
->size
!= 0)
2034 if (!add_dynamic_entry (DT_PLTGOT
, 0)
2035 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
2036 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
2037 || !add_dynamic_entry (DT_JMPREL
, 0))
2041 if (!add_dynamic_entry (DT_RELA
, 0)
2042 || !add_dynamic_entry (DT_RELASZ
, 0)
2043 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf32_External_Rela
)))
2046 /* If any dynamic relocs apply to a read-only section,
2047 then we need a DT_TEXTREL entry. */
2048 if ((info
->flags
& DF_TEXTREL
) == 0)
2049 elf_link_hash_traverse (&htab
->elf
, readonly_dynrelocs
,
2052 if (info
->flags
& DF_TEXTREL
)
2054 if (!add_dynamic_entry (DT_TEXTREL
, 0))
2058 #undef add_dynamic_entry
2063 struct elf32_sparc_section_data
2065 struct bfd_elf_section_data elf
;
2066 unsigned int do_relax
;
2069 #define sec_do_relax(sec) \
2070 ((struct elf32_sparc_section_data *) elf_section_data (sec))->do_relax
2073 elf32_sparc_new_section_hook (abfd
, sec
)
2077 struct elf32_sparc_section_data
*sdata
;
2078 bfd_size_type amt
= sizeof (*sdata
);
2080 sdata
= (struct elf32_sparc_section_data
*) bfd_zalloc (abfd
, amt
);
2083 sec
->used_by_bfd
= (PTR
) sdata
;
2085 return _bfd_elf_new_section_hook (abfd
, sec
);
2089 elf32_sparc_relax_section (abfd
, section
, link_info
, again
)
2090 bfd
*abfd ATTRIBUTE_UNUSED
;
2091 asection
*section ATTRIBUTE_UNUSED
;
2092 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
;
2096 sec_do_relax (section
) = 1;
2100 /* Return the base VMA address which should be subtracted from real addresses
2101 when resolving @dtpoff relocation.
2102 This is PT_TLS segment p_vaddr. */
2106 struct bfd_link_info
*info
;
2108 /* If tls_sec is NULL, we should have signalled an error already. */
2109 if (elf_hash_table (info
)->tls_sec
== NULL
)
2111 return elf_hash_table (info
)->tls_sec
->vma
;
2114 /* Return the relocation value for @tpoff relocation
2115 if STT_TLS virtual address is ADDRESS. */
2118 tpoff (info
, address
)
2119 struct bfd_link_info
*info
;
2122 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2124 /* If tls_sec is NULL, we should have signalled an error already. */
2125 if (htab
->tls_sec
== NULL
)
2127 return address
- htab
->tls_size
- htab
->tls_sec
->vma
;
2130 /* Relocate a SPARC ELF section. */
2133 elf32_sparc_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
2134 contents
, relocs
, local_syms
, local_sections
)
2136 struct bfd_link_info
*info
;
2138 asection
*input_section
;
2140 Elf_Internal_Rela
*relocs
;
2141 Elf_Internal_Sym
*local_syms
;
2142 asection
**local_sections
;
2144 struct elf32_sparc_link_hash_table
*htab
;
2145 Elf_Internal_Shdr
*symtab_hdr
;
2146 struct elf_link_hash_entry
**sym_hashes
;
2147 bfd_vma
*local_got_offsets
;
2150 Elf_Internal_Rela
*rel
;
2151 Elf_Internal_Rela
*relend
;
2153 if (info
->relocatable
)
2156 htab
= elf32_sparc_hash_table (info
);
2157 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2158 sym_hashes
= elf_sym_hashes (input_bfd
);
2159 local_got_offsets
= elf_local_got_offsets (input_bfd
);
2161 if (elf_hash_table (info
)->hgot
== NULL
)
2164 got_base
= elf_hash_table (info
)->hgot
->root
.u
.def
.value
;
2166 sreloc
= elf_section_data (input_section
)->sreloc
;
2169 relend
= relocs
+ input_section
->reloc_count
;
2170 for (; rel
< relend
; rel
++)
2172 int r_type
, tls_type
;
2173 reloc_howto_type
*howto
;
2174 unsigned long r_symndx
;
2175 struct elf_link_hash_entry
*h
;
2176 Elf_Internal_Sym
*sym
;
2178 bfd_vma relocation
, off
;
2179 bfd_reloc_status_type r
;
2180 bfd_boolean is_plt
= FALSE
;
2181 bfd_boolean unresolved_reloc
;
2183 r_type
= ELF32_R_TYPE (rel
->r_info
);
2185 if (r_type
== R_SPARC_GNU_VTINHERIT
2186 || r_type
== R_SPARC_GNU_VTENTRY
)
2189 if (r_type
< 0 || r_type
>= (int) R_SPARC_max_std
)
2191 bfd_set_error (bfd_error_bad_value
);
2194 howto
= _bfd_sparc_elf_howto_table
+ r_type
;
2196 /* This is a final link. */
2197 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2201 unresolved_reloc
= FALSE
;
2202 if (r_symndx
< symtab_hdr
->sh_info
)
2204 sym
= local_syms
+ r_symndx
;
2205 sec
= local_sections
[r_symndx
];
2206 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
2210 bfd_boolean warned ATTRIBUTE_UNUSED
;
2212 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2213 r_symndx
, symtab_hdr
, sym_hashes
,
2215 unresolved_reloc
, warned
);
2223 /* Relocation is to the entry for this symbol in the global
2225 if (htab
->sgot
== NULL
)
2232 off
= h
->got
.offset
;
2233 BFD_ASSERT (off
!= (bfd_vma
) -1);
2234 dyn
= elf_hash_table (info
)->dynamic_sections_created
;
2236 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
2240 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
))
2241 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
2243 /* This is actually a static link, or it is a
2244 -Bsymbolic link and the symbol is defined
2245 locally, or the symbol was forced to be local
2246 because of a version file. We must initialize
2247 this entry in the global offset table. Since the
2248 offset must always be a multiple of 4, we use the
2249 least significant bit to record whether we have
2250 initialized it already.
2252 When doing a dynamic link, we create a .rela.got
2253 relocation entry to initialize the value. This
2254 is done in the finish_dynamic_symbol routine. */
2259 bfd_put_32 (output_bfd
, relocation
,
2260 htab
->sgot
->contents
+ off
);
2265 unresolved_reloc
= FALSE
;
2269 BFD_ASSERT (local_got_offsets
!= NULL
2270 && local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
2272 off
= local_got_offsets
[r_symndx
];
2274 /* The offset must always be a multiple of 4. We use
2275 the least significant bit to record whether we have
2276 already processed this entry. */
2285 Elf_Internal_Rela outrel
;
2288 /* We need to generate a R_SPARC_RELATIVE reloc
2289 for the dynamic linker. */
2291 BFD_ASSERT (s
!= NULL
);
2293 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
2294 + htab
->sgot
->output_offset
2296 outrel
.r_info
= ELF32_R_INFO (0, R_SPARC_RELATIVE
);
2297 outrel
.r_addend
= relocation
;
2300 loc
+= s
->reloc_count
++ * sizeof (Elf32_External_Rela
);
2301 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
2304 bfd_put_32 (output_bfd
, relocation
,
2305 htab
->sgot
->contents
+ off
);
2306 local_got_offsets
[r_symndx
] |= 1;
2309 relocation
= htab
->sgot
->output_offset
+ off
- got_base
;
2313 if (h
== NULL
|| h
->plt
.offset
== (bfd_vma
) -1)
2315 r_type
= R_SPARC_32
;
2319 case R_SPARC_WPLT30
:
2321 /* Relocation is to the entry for this symbol in the
2322 procedure linkage table. */
2324 /* The Solaris native assembler will generate a WPLT30 reloc
2325 for a local symbol if you assemble a call from one
2326 section to another when using -K pic. We treat it as
2331 if (h
->plt
.offset
== (bfd_vma
) -1 || htab
->splt
== NULL
)
2333 /* We didn't make a PLT entry for this symbol. This
2334 happens when statically linking PIC code, or when
2335 using -Bsymbolic. */
2339 relocation
= (htab
->splt
->output_section
->vma
2340 + htab
->splt
->output_offset
2342 unresolved_reloc
= FALSE
;
2343 if (r_type
== R_SPARC_PLT32
)
2345 r_type
= R_SPARC_32
;
2354 && strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
2358 case R_SPARC_DISP16
:
2359 case R_SPARC_DISP32
:
2360 case R_SPARC_WDISP30
:
2361 case R_SPARC_WDISP22
:
2362 case R_SPARC_WDISP19
:
2363 case R_SPARC_WDISP16
:
2374 /* r_symndx will be zero only for relocs against symbols
2375 from removed linkonce sections, or sections discarded by
2378 || (input_section
->flags
& SEC_ALLOC
) == 0)
2383 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2384 || h
->root
.type
!= bfd_link_hash_undefweak
)
2385 && (! howto
->pc_relative
2388 && (! info
->symbolic
2389 || (h
->elf_link_hash_flags
2390 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
2394 && (h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
2395 && (((h
->elf_link_hash_flags
2396 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2397 && (h
->elf_link_hash_flags
2398 & ELF_LINK_HASH_DEF_REGULAR
) == 0)
2399 || h
->root
.type
== bfd_link_hash_undefweak
2400 || h
->root
.type
== bfd_link_hash_undefined
)))
2402 Elf_Internal_Rela outrel
;
2404 bfd_boolean skip
, relocate
= FALSE
;
2406 /* When generating a shared object, these relocations
2407 are copied into the output file to be resolved at run
2410 BFD_ASSERT (sreloc
!= NULL
);
2415 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2417 if (outrel
.r_offset
== (bfd_vma
) -1)
2419 else if (outrel
.r_offset
== (bfd_vma
) -2)
2420 skip
= TRUE
, relocate
= TRUE
;
2421 outrel
.r_offset
+= (input_section
->output_section
->vma
2422 + input_section
->output_offset
);
2424 /* Optimize unaligned reloc usage now that we know where
2425 it finally resides. */
2429 if (outrel
.r_offset
& 1)
2430 r_type
= R_SPARC_UA16
;
2433 if (!(outrel
.r_offset
& 1))
2434 r_type
= R_SPARC_16
;
2437 if (outrel
.r_offset
& 3)
2438 r_type
= R_SPARC_UA32
;
2441 if (!(outrel
.r_offset
& 3))
2442 r_type
= R_SPARC_32
;
2445 case R_SPARC_DISP16
:
2446 case R_SPARC_DISP32
:
2447 /* If the symbol is not dynamic, we should not keep
2448 a dynamic relocation. But an .rela.* slot has been
2449 allocated for it, output R_SPARC_NONE.
2450 FIXME: Add code tracking needed dynamic relocs as
2452 if (h
->dynindx
== -1)
2453 skip
= TRUE
, relocate
= TRUE
;
2458 memset (&outrel
, 0, sizeof outrel
);
2459 /* h->dynindx may be -1 if the symbol was marked to
2461 else if (h
!= NULL
&& ! is_plt
2462 && ((! info
->symbolic
&& h
->dynindx
!= -1)
2463 || (h
->elf_link_hash_flags
2464 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
2466 BFD_ASSERT (h
->dynindx
!= -1);
2467 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
2468 outrel
.r_addend
= rel
->r_addend
;
2472 if (r_type
== R_SPARC_32
)
2474 outrel
.r_info
= ELF32_R_INFO (0, R_SPARC_RELATIVE
);
2475 outrel
.r_addend
= relocation
+ rel
->r_addend
;
2484 if (bfd_is_abs_section (sec
))
2486 else if (sec
== NULL
|| sec
->owner
== NULL
)
2488 bfd_set_error (bfd_error_bad_value
);
2495 osec
= sec
->output_section
;
2496 indx
= elf_section_data (osec
)->dynindx
;
2498 /* FIXME: we really should be able to link non-pic
2499 shared libraries. */
2503 (*_bfd_error_handler
)
2504 (_("%s: probably compiled without -fPIC?"),
2505 bfd_archive_filename (input_bfd
));
2506 bfd_set_error (bfd_error_bad_value
);
2511 outrel
.r_info
= ELF32_R_INFO (indx
, r_type
);
2512 outrel
.r_addend
= relocation
+ rel
->r_addend
;
2516 loc
= sreloc
->contents
;
2517 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rela
);
2518 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
2520 /* This reloc will be computed at runtime, so there's no
2521 need to do anything now. */
2527 case R_SPARC_TLS_GD_HI22
:
2528 if (! elf32_sparc_tdata (input_bfd
)->has_tlsgd
)
2530 /* R_SPARC_REV32 used the same reloc number as
2531 R_SPARC_TLS_GD_HI22. */
2532 r_type
= R_SPARC_REV32
;
2537 case R_SPARC_TLS_GD_LO10
:
2538 case R_SPARC_TLS_IE_HI22
:
2539 case R_SPARC_TLS_IE_LO10
:
2540 r_type
= elf32_sparc_tls_transition (info
, input_bfd
, r_type
,
2542 tls_type
= GOT_UNKNOWN
;
2543 if (h
== NULL
&& local_got_offsets
)
2544 tls_type
= elf32_sparc_local_got_tls_type (input_bfd
) [r_symndx
];
2547 tls_type
= elf32_sparc_hash_entry(h
)->tls_type
;
2548 if (!info
->shared
&& h
->dynindx
== -1 && tls_type
== GOT_TLS_IE
)
2549 switch (ELF32_R_TYPE (rel
->r_info
))
2551 case R_SPARC_TLS_GD_HI22
:
2552 case R_SPARC_TLS_IE_HI22
:
2553 r_type
= R_SPARC_TLS_LE_HIX22
;
2556 r_type
= R_SPARC_TLS_LE_LOX10
;
2560 if (tls_type
== GOT_TLS_IE
)
2563 case R_SPARC_TLS_GD_HI22
:
2564 r_type
= R_SPARC_TLS_IE_HI22
;
2566 case R_SPARC_TLS_GD_LO10
:
2567 r_type
= R_SPARC_TLS_IE_LO10
;
2571 if (r_type
== R_SPARC_TLS_LE_HIX22
)
2573 relocation
= tpoff (info
, relocation
);
2576 if (r_type
== R_SPARC_TLS_LE_LOX10
)
2578 /* Change add into xor. */
2579 relocation
= tpoff (info
, relocation
);
2580 bfd_put_32 (output_bfd
, (bfd_get_32 (input_bfd
,
2581 contents
+ rel
->r_offset
)
2582 | 0x80182000), contents
+ rel
->r_offset
);
2588 off
= h
->got
.offset
;
2593 BFD_ASSERT (local_got_offsets
!= NULL
);
2594 off
= local_got_offsets
[r_symndx
];
2595 local_got_offsets
[r_symndx
] |= 1;
2599 if (htab
->sgot
== NULL
)
2606 Elf_Internal_Rela outrel
;
2607 Elf32_External_Rela
*loc
;
2610 if (htab
->srelgot
== NULL
)
2613 bfd_put_32 (output_bfd
, 0, htab
->sgot
->contents
+ off
);
2614 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
2615 + htab
->sgot
->output_offset
+ off
);
2616 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
2617 if (r_type
== R_SPARC_TLS_IE_HI22
2618 || r_type
== R_SPARC_TLS_IE_LO10
)
2619 dr_type
= R_SPARC_TLS_TPOFF32
;
2621 dr_type
= R_SPARC_TLS_DTPMOD32
;
2622 if (dr_type
== R_SPARC_TLS_TPOFF32
&& indx
== 0)
2623 outrel
.r_addend
= relocation
- dtpoff_base (info
);
2625 outrel
.r_addend
= 0;
2626 outrel
.r_info
= ELF32_R_INFO (indx
, dr_type
);
2627 loc
= (Elf32_External_Rela
*) htab
->srelgot
->contents
;
2628 loc
+= htab
->srelgot
->reloc_count
++;
2629 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
,
2632 if (r_type
== R_SPARC_TLS_GD_HI22
2633 || r_type
== R_SPARC_TLS_GD_LO10
)
2637 BFD_ASSERT (! unresolved_reloc
);
2638 bfd_put_32 (output_bfd
,
2639 relocation
- dtpoff_base (info
),
2640 htab
->sgot
->contents
+ off
+ 4);
2644 bfd_put_32 (output_bfd
, 0,
2645 htab
->sgot
->contents
+ off
+ 4);
2646 outrel
.r_info
= ELF32_R_INFO (indx
,
2647 R_SPARC_TLS_DTPOFF32
);
2648 outrel
.r_offset
+= 4;
2649 htab
->srelgot
->reloc_count
++;
2651 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
,
2655 else if (dr_type
== R_SPARC_TLS_DTPMOD32
)
2657 bfd_put_32 (output_bfd
, 0,
2658 htab
->sgot
->contents
+ off
+ 4);
2662 if (off
>= (bfd_vma
) -2)
2665 relocation
= htab
->sgot
->output_offset
+ off
- got_base
;
2666 unresolved_reloc
= FALSE
;
2667 howto
= _bfd_sparc_elf_howto_table
+ r_type
;
2670 case R_SPARC_TLS_LDM_HI22
:
2671 case R_SPARC_TLS_LDM_LO10
:
2674 bfd_put_32 (output_bfd
, SPARC_NOP
, contents
+ rel
->r_offset
);
2677 off
= htab
->tls_ldm_got
.offset
;
2678 htab
->tls_ldm_got
.offset
|= 1;
2679 goto r_sparc_tlsldm
;
2681 case R_SPARC_TLS_LDO_HIX22
:
2682 case R_SPARC_TLS_LDO_LOX10
:
2684 relocation
-= dtpoff_base (info
);
2686 relocation
= tpoff (info
, relocation
);
2689 case R_SPARC_TLS_LE_HIX22
:
2690 case R_SPARC_TLS_LE_LOX10
:
2693 Elf_Internal_Rela outrel
;
2694 bfd_boolean skip
, relocate
= FALSE
;
2696 BFD_ASSERT (sreloc
!= NULL
);
2699 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2701 if (outrel
.r_offset
== (bfd_vma
) -1)
2703 else if (outrel
.r_offset
== (bfd_vma
) -2)
2704 skip
= TRUE
, relocate
= TRUE
;
2705 outrel
.r_offset
+= (input_section
->output_section
->vma
2706 + input_section
->output_offset
);
2708 memset (&outrel
, 0, sizeof outrel
);
2711 outrel
.r_info
= ELF32_R_INFO (0, r_type
);
2712 outrel
.r_addend
= relocation
- dtpoff_base (info
)
2716 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
,
2717 (bfd_byte
*) (((Elf32_External_Rela
*)
2719 + sreloc
->reloc_count
));
2720 ++sreloc
->reloc_count
;
2723 relocation
= tpoff (info
, relocation
);
2726 case R_SPARC_TLS_LDM_CALL
:
2730 bfd_put_32 (output_bfd
, 0x90100000, contents
+ rel
->r_offset
);
2735 case R_SPARC_TLS_GD_CALL
:
2736 tls_type
= GOT_UNKNOWN
;
2737 if (h
== NULL
&& local_got_offsets
)
2738 tls_type
= elf32_sparc_local_got_tls_type (input_bfd
) [r_symndx
];
2740 tls_type
= elf32_sparc_hash_entry(h
)->tls_type
;
2742 || (r_type
== R_SPARC_TLS_GD_CALL
&& tls_type
== GOT_TLS_IE
))
2746 if (!info
->shared
&& (h
== NULL
|| h
->dynindx
== -1))
2749 bfd_put_32 (output_bfd
, SPARC_NOP
, contents
+ rel
->r_offset
);
2754 if (rel
+ 1 < relend
2755 && ELF32_R_TYPE (rel
[1].r_info
) == R_SPARC_TLS_GD_ADD
2756 && rel
[1].r_offset
== rel
->r_offset
+ 4
2757 && ELF32_R_SYM (rel
[1].r_info
) == r_symndx
2758 && (((insn
= bfd_get_32 (input_bfd
,
2759 contents
+ rel
[1].r_offset
))
2760 >> 25) & 0x1f) == 8)
2763 call __tls_get_addr, %tgd_call(foo)
2764 add %reg1, %reg2, %o0, %tgd_add(foo)
2765 and change it into IE:
2766 ld [%reg1 + %reg2], %o0, %tie_ld(foo)
2767 add %g7, %o0, %o0, %tie_add(foo).
2768 add is 0x80000000 | (rd << 25) | (rs1 << 14) | rs2,
2769 ld is 0xc0000000 | (rd << 25) | (rs1 << 14) | rs2. */
2770 bfd_put_32 (output_bfd
, insn
| 0xc0000000,
2771 contents
+ rel
->r_offset
);
2772 bfd_put_32 (output_bfd
, 0x9001c008,
2773 contents
+ rel
->r_offset
+ 4);
2778 bfd_put_32 (output_bfd
, 0x9001c008, contents
+ rel
->r_offset
);
2782 h
= (struct elf_link_hash_entry
*)
2783 bfd_link_hash_lookup (info
->hash
, "__tls_get_addr", FALSE
,
2785 BFD_ASSERT (h
!= NULL
);
2786 r_type
= R_SPARC_WPLT30
;
2787 howto
= _bfd_sparc_elf_howto_table
+ r_type
;
2788 goto r_sparc_wplt30
;
2790 case R_SPARC_TLS_GD_ADD
:
2791 tls_type
= GOT_UNKNOWN
;
2792 if (h
== NULL
&& local_got_offsets
)
2793 tls_type
= elf32_sparc_local_got_tls_type (input_bfd
) [r_symndx
];
2795 tls_type
= elf32_sparc_hash_entry(h
)->tls_type
;
2796 if (! info
->shared
|| tls_type
== GOT_TLS_IE
)
2798 /* add %reg1, %reg2, %reg3, %tgd_add(foo)
2800 ld [%reg1 + %reg2], %reg3, %tie_ld(foo)
2802 add %g7, %reg2, %reg3. */
2803 bfd_vma insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2804 if ((h
!= NULL
&& h
->dynindx
!= -1) || info
->shared
)
2805 relocation
= insn
| 0xc0000000;
2807 relocation
= (insn
& ~0x7c000) | 0x1c000;
2808 bfd_put_32 (output_bfd
, relocation
, contents
+ rel
->r_offset
);
2812 case R_SPARC_TLS_LDM_ADD
:
2814 bfd_put_32 (output_bfd
, SPARC_NOP
, contents
+ rel
->r_offset
);
2817 case R_SPARC_TLS_LDO_ADD
:
2820 /* Change rs1 into %g7. */
2821 bfd_vma insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2822 insn
= (insn
& ~0x7c000) | 0x1c000;
2823 bfd_put_32 (output_bfd
, insn
, contents
+ rel
->r_offset
);
2827 case R_SPARC_TLS_IE_LD
:
2828 case R_SPARC_TLS_IE_LDX
:
2829 if (! info
->shared
&& (h
== NULL
|| h
->dynindx
== -1))
2831 bfd_vma insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2832 int rs2
= insn
& 0x1f;
2833 int rd
= (insn
>> 25) & 0x1f;
2836 relocation
= SPARC_NOP
;
2838 relocation
= 0x80100000 | (insn
& 0x3e00001f);
2839 bfd_put_32 (output_bfd
, relocation
, contents
+ rel
->r_offset
);
2843 case R_SPARC_TLS_IE_ADD
:
2844 /* Totally useless relocation. */
2847 case R_SPARC_TLS_DTPOFF32
:
2848 relocation
-= dtpoff_base (info
);
2855 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2856 because such sections are not SEC_ALLOC and thus ld.so will
2857 not process them. */
2858 if (unresolved_reloc
2859 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
2860 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0))
2861 (*_bfd_error_handler
)
2862 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
2863 bfd_archive_filename (input_bfd
),
2864 bfd_get_section_name (input_bfd
, input_section
),
2865 (long) rel
->r_offset
,
2866 h
->root
.root
.string
);
2868 r
= bfd_reloc_continue
;
2869 if (r_type
== R_SPARC_WDISP16
)
2873 relocation
+= rel
->r_addend
;
2874 relocation
-= (input_section
->output_section
->vma
2875 + input_section
->output_offset
);
2876 relocation
-= rel
->r_offset
;
2878 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2879 x
|= ((((relocation
>> 2) & 0xc000) << 6)
2880 | ((relocation
>> 2) & 0x3fff));
2881 bfd_put_32 (input_bfd
, x
, contents
+ rel
->r_offset
);
2883 if ((bfd_signed_vma
) relocation
< - 0x40000
2884 || (bfd_signed_vma
) relocation
> 0x3ffff)
2885 r
= bfd_reloc_overflow
;
2889 else if (r_type
== R_SPARC_REV32
)
2893 relocation
= relocation
+ rel
->r_addend
;
2895 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2897 bfd_putl32 (/*input_bfd,*/ x
, contents
+ rel
->r_offset
);
2900 else if (r_type
== R_SPARC_TLS_LDO_HIX22
2901 || r_type
== R_SPARC_TLS_LE_HIX22
)
2905 relocation
+= rel
->r_addend
;
2906 relocation
= relocation
^ 0xffffffff;
2908 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2909 x
= (x
& ~(bfd_vma
) 0x3fffff) | ((relocation
>> 10) & 0x3fffff);
2910 bfd_put_32 (input_bfd
, x
, contents
+ rel
->r_offset
);
2913 else if (r_type
== R_SPARC_TLS_LDO_LOX10
2914 || r_type
== R_SPARC_TLS_LE_LOX10
)
2918 relocation
+= rel
->r_addend
;
2919 relocation
= (relocation
& 0x3ff) | 0x1c00;
2921 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2922 x
= (x
& ~(bfd_vma
) 0x1fff) | relocation
;
2923 bfd_put_32 (input_bfd
, x
, contents
+ rel
->r_offset
);
2927 else if ((r_type
== R_SPARC_WDISP30
|| r_type
== R_SPARC_WPLT30
)
2928 && sec_do_relax (input_section
)
2929 && rel
->r_offset
+ 4 < input_section
->size
)
2933 #define XCC (2 << 20)
2934 #define COND(x) (((x)&0xf)<<25)
2935 #define CONDA COND(0x8)
2936 #define INSN_BPA (F2(0,1) | CONDA | BPRED | XCC)
2937 #define INSN_BA (F2(0,2) | CONDA)
2938 #define INSN_OR F3(2, 0x2, 0)
2939 #define INSN_NOP F2(0,4)
2943 /* If the instruction is a call with either:
2945 arithmetic instruction with rd == %o7
2946 where rs1 != %o7 and rs2 if it is register != %o7
2947 then we can optimize if the call destination is near
2948 by changing the call into a branch always. */
2949 x
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2950 y
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
2951 if ((x
& OP(~0)) == OP(1) && (y
& OP(~0)) == OP(2))
2953 if (((y
& OP3(~0)) == OP3(0x3d) /* restore */
2954 || ((y
& OP3(0x28)) == 0 /* arithmetic */
2955 && (y
& RD(~0)) == RD(O7
)))
2956 && (y
& RS1(~0)) != RS1(O7
)
2958 || (y
& RS2(~0)) != RS2(O7
)))
2962 reloc
= relocation
+ rel
->r_addend
- rel
->r_offset
;
2963 reloc
-= (input_section
->output_section
->vma
2964 + input_section
->output_offset
);
2966 /* Ensure the reloc fits into simm22. */
2967 if ((reloc
& 3) == 0
2968 && ((reloc
& ~(bfd_vma
)0x7fffff) == 0
2969 || ((reloc
| 0x7fffff) == ~(bfd_vma
)0)))
2973 /* Check whether it fits into simm19 on v9. */
2974 if (((reloc
& 0x3c0000) == 0
2975 || (reloc
& 0x3c0000) == 0x3c0000)
2976 && (elf_elfheader (output_bfd
)->e_flags
& EF_SPARC_32PLUS
))
2977 x
= INSN_BPA
| (reloc
& 0x7ffff); /* ba,pt %xcc */
2979 x
= INSN_BA
| (reloc
& 0x3fffff); /* ba */
2980 bfd_put_32 (input_bfd
, x
, contents
+ rel
->r_offset
);
2982 if (rel
->r_offset
>= 4
2983 && (y
& (0xffffffff ^ RS1(~0)))
2984 == (INSN_OR
| RD(O7
) | RS2(G0
)))
2989 z
= bfd_get_32 (input_bfd
,
2990 contents
+ rel
->r_offset
- 4);
2991 if ((z
& (0xffffffff ^ RD(~0)))
2992 != (INSN_OR
| RS1(O7
) | RS2(G0
)))
3000 If call foo was replaced with ba, replace
3001 or %rN, %g0, %o7 with nop. */
3003 reg
= (y
& RS1(~0)) >> 14;
3004 if (reg
!= ((z
& RD(~0)) >> 25)
3005 || reg
== G0
|| reg
== O7
)
3008 bfd_put_32 (input_bfd
, (bfd_vma
) INSN_NOP
,
3009 contents
+ rel
->r_offset
+ 4);
3017 if (r
== bfd_reloc_continue
)
3018 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
3019 contents
, rel
->r_offset
,
3020 relocation
, rel
->r_addend
);
3022 if (r
!= bfd_reloc_ok
)
3027 case bfd_reloc_outofrange
:
3029 case bfd_reloc_overflow
:
3034 name
= h
->root
.root
.string
;
3037 name
= bfd_elf_string_from_elf_section (input_bfd
,
3038 symtab_hdr
->sh_link
,
3043 name
= bfd_section_name (input_bfd
, sec
);
3045 if (! ((*info
->callbacks
->reloc_overflow
)
3046 (info
, name
, howto
->name
, (bfd_vma
) 0,
3047 input_bfd
, input_section
, rel
->r_offset
)))
3058 /* Finish up dynamic symbol handling. We set the contents of various
3059 dynamic sections here. */
3062 elf32_sparc_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
3064 struct bfd_link_info
*info
;
3065 struct elf_link_hash_entry
*h
;
3066 Elf_Internal_Sym
*sym
;
3069 struct elf32_sparc_link_hash_table
*htab
;
3071 htab
= elf32_sparc_hash_table (info
);
3072 dynobj
= htab
->elf
.dynobj
;
3074 if (h
->plt
.offset
!= (bfd_vma
) -1)
3078 Elf_Internal_Rela rela
;
3081 /* This symbol has an entry in the procedure linkage table. Set
3084 BFD_ASSERT (h
->dynindx
!= -1);
3087 srela
= htab
->srelplt
;
3088 BFD_ASSERT (splt
!= NULL
&& srela
!= NULL
);
3090 /* Fill in the entry in the procedure linkage table. */
3091 bfd_put_32 (output_bfd
,
3092 PLT_ENTRY_WORD0
+ h
->plt
.offset
,
3093 splt
->contents
+ h
->plt
.offset
);
3094 bfd_put_32 (output_bfd
,
3096 + (((- (h
->plt
.offset
+ 4)) >> 2) & 0x3fffff)),
3097 splt
->contents
+ h
->plt
.offset
+ 4);
3098 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_ENTRY_WORD2
,
3099 splt
->contents
+ h
->plt
.offset
+ 8);
3101 /* Fill in the entry in the .rela.plt section. */
3102 rela
.r_offset
= (splt
->output_section
->vma
3103 + splt
->output_offset
3105 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SPARC_JMP_SLOT
);
3107 loc
= srela
->contents
;
3108 loc
+= (h
->plt
.offset
/ PLT_ENTRY_SIZE
- 4) * sizeof (Elf32_External_Rela
);
3109 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
3111 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3113 /* Mark the symbol as undefined, rather than as defined in
3114 the .plt section. Leave the value alone. */
3115 sym
->st_shndx
= SHN_UNDEF
;
3116 /* If the symbol is weak, we do need to clear the value.
3117 Otherwise, the PLT entry would provide a definition for
3118 the symbol even if the symbol wasn't defined anywhere,
3119 and so the symbol would never be NULL. */
3120 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR_NONWEAK
)
3126 if (h
->got
.offset
!= (bfd_vma
) -1
3127 && elf32_sparc_hash_entry(h
)->tls_type
!= GOT_TLS_GD
3128 && elf32_sparc_hash_entry(h
)->tls_type
!= GOT_TLS_IE
)
3132 Elf_Internal_Rela rela
;
3135 /* This symbol has an entry in the global offset table. Set it
3139 srela
= htab
->srelgot
;
3140 BFD_ASSERT (sgot
!= NULL
&& srela
!= NULL
);
3142 rela
.r_offset
= (sgot
->output_section
->vma
3143 + sgot
->output_offset
3144 + (h
->got
.offset
&~ (bfd_vma
) 1));
3146 /* If this is a -Bsymbolic link, and the symbol is defined
3147 locally, we just want to emit a RELATIVE reloc. Likewise if
3148 the symbol was forced to be local because of a version file.
3149 The entry in the global offset table will already have been
3150 initialized in the relocate_section function. */
3152 && (info
->symbolic
|| h
->dynindx
== -1)
3153 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
3155 asection
*sec
= h
->root
.u
.def
.section
;
3156 rela
.r_info
= ELF32_R_INFO (0, R_SPARC_RELATIVE
);
3157 rela
.r_addend
= (h
->root
.u
.def
.value
3158 + sec
->output_section
->vma
3159 + sec
->output_offset
);
3163 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SPARC_GLOB_DAT
);
3167 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
3168 sgot
->contents
+ (h
->got
.offset
&~ (bfd_vma
) 1));
3169 loc
= srela
->contents
;
3170 loc
+= srela
->reloc_count
++ * sizeof (Elf32_External_Rela
);
3171 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
3174 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
3177 Elf_Internal_Rela rela
;
3180 /* This symbols needs a copy reloc. Set it up. */
3182 BFD_ASSERT (h
->dynindx
!= -1);
3184 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
3186 BFD_ASSERT (s
!= NULL
);
3188 rela
.r_offset
= (h
->root
.u
.def
.value
3189 + h
->root
.u
.def
.section
->output_section
->vma
3190 + h
->root
.u
.def
.section
->output_offset
);
3191 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_SPARC_COPY
);
3193 loc
= s
->contents
+ s
->reloc_count
++ * sizeof (Elf32_External_Rela
);
3194 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
3197 /* Mark some specially defined symbols as absolute. */
3198 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
3199 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0
3200 || strcmp (h
->root
.root
.string
, "_PROCEDURE_LINKAGE_TABLE_") == 0)
3201 sym
->st_shndx
= SHN_ABS
;
3206 /* Finish up the dynamic sections. */
3209 elf32_sparc_finish_dynamic_sections (output_bfd
, info
)
3211 struct bfd_link_info
*info
;
3215 struct elf32_sparc_link_hash_table
*htab
;
3217 htab
= elf32_sparc_hash_table (info
);
3218 dynobj
= htab
->elf
.dynobj
;
3220 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
3222 if (elf_hash_table (info
)->dynamic_sections_created
)
3225 Elf32_External_Dyn
*dyncon
, *dynconend
;
3227 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3228 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
3230 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3231 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
3232 for (; dyncon
< dynconend
; dyncon
++)
3234 Elf_Internal_Dyn dyn
;
3238 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3242 case DT_PLTGOT
: name
= ".plt"; size
= FALSE
; break;
3243 case DT_PLTRELSZ
: name
= ".rela.plt"; size
= TRUE
; break;
3244 case DT_JMPREL
: name
= ".rela.plt"; size
= FALSE
; break;
3245 default: name
= NULL
; size
= FALSE
; break;
3252 s
= bfd_get_section_by_name (output_bfd
, name
);
3258 dyn
.d_un
.d_ptr
= s
->vma
;
3260 dyn
.d_un
.d_val
= s
->size
;
3262 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3266 /* Clear the first four entries in the procedure linkage table,
3267 and put a nop in the last four bytes. */
3270 memset (splt
->contents
, 0, 4 * PLT_ENTRY_SIZE
);
3271 bfd_put_32 (output_bfd
, (bfd_vma
) SPARC_NOP
,
3272 splt
->contents
+ splt
->size
- 4);
3275 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
= 0;
3278 /* Set the first entry in the global offset table to the address of
3279 the dynamic section. */
3280 if (htab
->sgot
&& htab
->sgot
->size
> 0)
3283 bfd_put_32 (output_bfd
, (bfd_vma
) 0, htab
->sgot
->contents
);
3285 bfd_put_32 (output_bfd
,
3286 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
3287 htab
->sgot
->contents
);
3291 elf_section_data (htab
->sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
3296 /* Functions for dealing with the e_flags field.
3298 We don't define set_private_flags or copy_private_bfd_data because
3299 the only currently defined values are based on the bfd mach number,
3300 so we use the latter instead and defer setting e_flags until the
3301 file is written out. */
3303 /* Merge backend specific data from an object file to the output
3304 object file when linking. */
3307 elf32_sparc_merge_private_bfd_data (ibfd
, obfd
)
3312 /* FIXME: This should not be static. */
3313 static unsigned long previous_ibfd_e_flags
= (unsigned long) -1;
3315 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
3316 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
3321 if (bfd_get_mach (ibfd
) >= bfd_mach_sparc_v9
)
3324 (*_bfd_error_handler
)
3325 (_("%s: compiled for a 64 bit system and target is 32 bit"),
3326 bfd_archive_filename (ibfd
));
3328 else if ((ibfd
->flags
& DYNAMIC
) == 0)
3330 if (bfd_get_mach (obfd
) < bfd_get_mach (ibfd
))
3331 bfd_set_arch_mach (obfd
, bfd_arch_sparc
, bfd_get_mach (ibfd
));
3334 if (((elf_elfheader (ibfd
)->e_flags
& EF_SPARC_LEDATA
)
3335 != previous_ibfd_e_flags
)
3336 && previous_ibfd_e_flags
!= (unsigned long) -1)
3338 (*_bfd_error_handler
)
3339 (_("%s: linking little endian files with big endian files"),
3340 bfd_archive_filename (ibfd
));
3343 previous_ibfd_e_flags
= elf_elfheader (ibfd
)->e_flags
& EF_SPARC_LEDATA
;
3347 bfd_set_error (bfd_error_bad_value
);
3354 /* Set the right machine number. */
3357 elf32_sparc_object_p (abfd
)
3360 if (elf_elfheader (abfd
)->e_machine
== EM_SPARC32PLUS
)
3362 if (elf_elfheader (abfd
)->e_flags
& EF_SPARC_SUN_US3
)
3363 return bfd_default_set_arch_mach (abfd
, bfd_arch_sparc
,
3364 bfd_mach_sparc_v8plusb
);
3365 else if (elf_elfheader (abfd
)->e_flags
& EF_SPARC_SUN_US1
)
3366 return bfd_default_set_arch_mach (abfd
, bfd_arch_sparc
,
3367 bfd_mach_sparc_v8plusa
);
3368 else if (elf_elfheader (abfd
)->e_flags
& EF_SPARC_32PLUS
)
3369 return bfd_default_set_arch_mach (abfd
, bfd_arch_sparc
,
3370 bfd_mach_sparc_v8plus
);
3374 else if (elf_elfheader (abfd
)->e_flags
& EF_SPARC_LEDATA
)
3375 return bfd_default_set_arch_mach (abfd
, bfd_arch_sparc
,
3376 bfd_mach_sparc_sparclite_le
);
3378 return bfd_default_set_arch_mach (abfd
, bfd_arch_sparc
, bfd_mach_sparc
);
3381 /* The final processing done just before writing out the object file.
3382 We need to set the e_machine field appropriately. */
3385 elf32_sparc_final_write_processing (abfd
, linker
)
3387 bfd_boolean linker ATTRIBUTE_UNUSED
;
3389 switch (bfd_get_mach (abfd
))
3391 case bfd_mach_sparc
:
3392 break; /* nothing to do */
3393 case bfd_mach_sparc_v8plus
:
3394 elf_elfheader (abfd
)->e_machine
= EM_SPARC32PLUS
;
3395 elf_elfheader (abfd
)->e_flags
&=~ EF_SPARC_32PLUS_MASK
;
3396 elf_elfheader (abfd
)->e_flags
|= EF_SPARC_32PLUS
;
3398 case bfd_mach_sparc_v8plusa
:
3399 elf_elfheader (abfd
)->e_machine
= EM_SPARC32PLUS
;
3400 elf_elfheader (abfd
)->e_flags
&=~ EF_SPARC_32PLUS_MASK
;
3401 elf_elfheader (abfd
)->e_flags
|= EF_SPARC_32PLUS
| EF_SPARC_SUN_US1
;
3403 case bfd_mach_sparc_v8plusb
:
3404 elf_elfheader (abfd
)->e_machine
= EM_SPARC32PLUS
;
3405 elf_elfheader (abfd
)->e_flags
&=~ EF_SPARC_32PLUS_MASK
;
3406 elf_elfheader (abfd
)->e_flags
|= EF_SPARC_32PLUS
| EF_SPARC_SUN_US1
3409 case bfd_mach_sparc_sparclite_le
:
3410 elf_elfheader (abfd
)->e_machine
= EM_SPARC
;
3411 elf_elfheader (abfd
)->e_flags
|= EF_SPARC_LEDATA
;
3419 static enum elf_reloc_type_class
3420 elf32_sparc_reloc_type_class (rela
)
3421 const Elf_Internal_Rela
*rela
;
3423 switch ((int) ELF32_R_TYPE (rela
->r_info
))
3425 case R_SPARC_RELATIVE
:
3426 return reloc_class_relative
;
3427 case R_SPARC_JMP_SLOT
:
3428 return reloc_class_plt
;
3430 return reloc_class_copy
;
3432 return reloc_class_normal
;
3436 /* Return address for Ith PLT stub in section PLT, for relocation REL
3437 or (bfd_vma) -1 if it should not be included. */
3440 elf32_sparc_plt_sym_val (bfd_vma i ATTRIBUTE_UNUSED
,
3441 const asection
*plt ATTRIBUTE_UNUSED
,
3444 return rel
->address
;
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
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 #define elf_backend_plt_sym_val elf32_sparc_plt_sym_val
3486 #define elf_backend_can_gc_sections 1
3487 #define elf_backend_can_refcount 1
3488 #define elf_backend_want_got_plt 0
3489 #define elf_backend_plt_readonly 0
3490 #define elf_backend_want_plt_sym 1
3491 #define elf_backend_got_header_size 4
3492 #define elf_backend_rela_normal 1
3494 #include "elf32-target.h"