source: trunk/binutils/bfd/elf32-sparc.c@ 2817

Last change on this file since 2817 was 610, checked in by bird, 22 years ago

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