projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
2002-09-27 David Carlton <carlton@math.stanford.edu>
[deliverable/binutils-gdb.git] / bfd / elf32-i386.c
CommitLineData
252b5132 1/* Intel 80386/80486-specific support for 32-bit ELF
e92d460e 2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
638632bd 3 Free Software Foundation, Inc.
252b5132
RH		 4
5This file is part of BFD, the Binary File Descriptor library.
6
7This program is free software; you can redistribute it and/or modify
8it under the terms of the GNU General Public License as published by
9the Free Software Foundation; either version 2 of the License, or
10(at your option) any later version.
11
12This program is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15GNU General Public License for more details.
16
17You should have received a copy of the GNU General Public License
18along with this program; if not, write to the Free Software
19Foundation, 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
27static reloc_howto_type *elf_i386_reloc_type_lookup
28 PARAMS ((bfd *, bfd_reloc_code_real_type));
29static void elf_i386_info_to_howto
30 PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *));
31static void elf_i386_info_to_howto_rel
32 PARAMS ((bfd *, arelent *, Elf32_Internal_Rel *));
ebe50bae
AM		 33static boolean elf_i386_is_local_label_name
34 PARAMS ((bfd *, const char *));
38701953
AM		 35static boolean elf_i386_grok_prstatus
36 PARAMS ((bfd *abfd, Elf_Internal_Note *note));
37static boolean elf_i386_grok_psinfo
38 PARAMS ((bfd *abfd, Elf_Internal_Note *note));
39static struct bfd_hash_entry *link_hash_newfunc
252b5132
RH		 40 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
41static struct bfd_link_hash_table *elf_i386_link_hash_table_create
42 PARAMS ((bfd *));
ebe50bae
AM		 43static boolean create_got_section
44 PARAMS((bfd *, struct bfd_link_info *));
6725bdbf
AM		 45static boolean elf_i386_create_dynamic_sections
46 PARAMS((bfd *, struct bfd_link_info *));
51b64d56 47static void elf_i386_copy_indirect_symbol
b48fa14c
AM		 48 PARAMS ((struct elf_backend_data *, struct elf_link_hash_entry *,
49 struct elf_link_hash_entry *));
13ae64f3
JJ		 50static int elf_i386_tls_transition
51 PARAMS ((struct bfd_link_info *, int, int));
52
53static boolean elf_i386_mkobject
54 PARAMS((bfd *));
55static boolean elf_i386_object_p
56 PARAMS((bfd *));
252b5132
RH		 57static boolean elf_i386_check_relocs
58 PARAMS ((bfd *, struct bfd_link_info *, asection *,
59 const Elf_Internal_Rela *));
a7b97311 60static asection *elf_i386_gc_mark_hook
1e2f5b6e 61 PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
a7b97311
AM		 62 struct elf_link_hash_entry *, Elf_Internal_Sym *));
63static boolean elf_i386_gc_sweep_hook
64 PARAMS ((bfd *, struct bfd_link_info *, asection *,
65 const Elf_Internal_Rela *));
252b5132
RH		 66static boolean elf_i386_adjust_dynamic_symbol
67 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
0c715baa
AM		 68static boolean allocate_dynrelocs
69 PARAMS ((struct elf_link_hash_entry *, PTR));
70static boolean readonly_dynrelocs
6725bdbf 71 PARAMS ((struct elf_link_hash_entry *, PTR));
38701953
AM		 72static boolean elf_i386_fake_sections
73 PARAMS ((bfd *, Elf32_Internal_Shdr *, asection *));
252b5132
RH		 74static boolean elf_i386_size_dynamic_sections
75 PARAMS ((bfd *, struct bfd_link_info *));
13ae64f3
JJ		 76static bfd_vma dtpoff_base
77 PARAMS ((struct bfd_link_info *));
78static bfd_vma tpoff
79 PARAMS ((struct bfd_link_info *, bfd_vma));
252b5132
RH		 80static boolean elf_i386_relocate_section
81 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
82 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
83static boolean elf_i386_finish_dynamic_symbol
84 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
85 Elf_Internal_Sym *));
f51e552e
AM		 86static enum elf_reloc_type_class elf_i386_reloc_type_class
87 PARAMS ((const Elf_Internal_Rela *));
38701953
AM		 88static boolean elf_i386_finish_dynamic_sections
89 PARAMS ((bfd *, struct bfd_link_info *));
252b5132
RH		 90
91#define USE_REL 1 /* 386 uses REL relocations instead of RELA */
92
93#include "elf/i386.h"
94
95static reloc_howto_type elf_howto_table[]=
96{
1b452ec6
AM		 97 HOWTO(R_386_NONE, 0, 0, 0, false, 0, complain_overflow_bitfield,
98 bfd_elf_generic_reloc, "R_386_NONE",
99 true, 0x00000000, 0x00000000, false),
100 HOWTO(R_386_32, 0, 2, 32, false, 0, complain_overflow_bitfield,
101 bfd_elf_generic_reloc, "R_386_32",
102 true, 0xffffffff, 0xffffffff, false),
103 HOWTO(R_386_PC32, 0, 2, 32, true, 0, complain_overflow_bitfield,
104 bfd_elf_generic_reloc, "R_386_PC32",
105 true, 0xffffffff, 0xffffffff, true),
106 HOWTO(R_386_GOT32, 0, 2, 32, false, 0, complain_overflow_bitfield,
107 bfd_elf_generic_reloc, "R_386_GOT32",
108 true, 0xffffffff, 0xffffffff, false),
109 HOWTO(R_386_PLT32, 0, 2, 32, true, 0, complain_overflow_bitfield,
110 bfd_elf_generic_reloc, "R_386_PLT32",
111 true, 0xffffffff, 0xffffffff, true),
112 HOWTO(R_386_COPY, 0, 2, 32, false, 0, complain_overflow_bitfield,
113 bfd_elf_generic_reloc, "R_386_COPY",
114 true, 0xffffffff, 0xffffffff, false),
115 HOWTO(R_386_GLOB_DAT, 0, 2, 32, false, 0, complain_overflow_bitfield,
116 bfd_elf_generic_reloc, "R_386_GLOB_DAT",
117 true, 0xffffffff, 0xffffffff, false),
118 HOWTO(R_386_JUMP_SLOT, 0, 2, 32, false, 0, complain_overflow_bitfield,
119 bfd_elf_generic_reloc, "R_386_JUMP_SLOT",
120 true, 0xffffffff, 0xffffffff, false),
121 HOWTO(R_386_RELATIVE, 0, 2, 32, false, 0, complain_overflow_bitfield,
122 bfd_elf_generic_reloc, "R_386_RELATIVE",
123 true, 0xffffffff, 0xffffffff, false),
124 HOWTO(R_386_GOTOFF, 0, 2, 32, false, 0, complain_overflow_bitfield,
125 bfd_elf_generic_reloc, "R_386_GOTOFF",
126 true, 0xffffffff, 0xffffffff, false),
127 HOWTO(R_386_GOTPC, 0, 2, 32, true, 0, complain_overflow_bitfield,
128 bfd_elf_generic_reloc, "R_386_GOTPC",
129 true, 0xffffffff, 0xffffffff, true),
130
dc47f327
AM		 131 /* We have a gap in the reloc numbers here.
132 R_386_standard counts the number up to this point, and
133 R_386_ext_offset is the value to subtract from a reloc type of
134 R_386_16 thru R_386_PC8 to form an index into this table. */
1b452ec6 135#define R_386_standard ((unsigned int) R_386_GOTPC + 1)
37e55690 136#define R_386_ext_offset ((unsigned int) R_386_TLS_TPOFF - R_386_standard)
1b452ec6 137
37e55690
JJ		 138 /* These relocs are a GNU extension. */
139 HOWTO(R_386_TLS_TPOFF, 0, 2, 32, false, 0, complain_overflow_bitfield,
140 bfd_elf_generic_reloc, "R_386_TLS_TPOFF",
141 true, 0xffffffff, 0xffffffff, false),
142 HOWTO(R_386_TLS_IE, 0, 2, 32, false, 0, complain_overflow_bitfield,
143 bfd_elf_generic_reloc, "R_386_TLS_IE",
144 true, 0xffffffff, 0xffffffff, false),
145 HOWTO(R_386_TLS_GOTIE, 0, 2, 32, false, 0, complain_overflow_bitfield,
146 bfd_elf_generic_reloc, "R_386_TLS_GOTIE",
147 true, 0xffffffff, 0xffffffff, false),
13ae64f3
JJ		 148 HOWTO(R_386_TLS_LE, 0, 2, 32, false, 0, complain_overflow_bitfield,
149 bfd_elf_generic_reloc, "R_386_TLS_LE",
150 true, 0xffffffff, 0xffffffff, false),
151 HOWTO(R_386_TLS_GD, 0, 2, 32, false, 0, complain_overflow_bitfield,
152 bfd_elf_generic_reloc, "R_386_TLS_GD",
153 true, 0xffffffff, 0xffffffff, false),
154 HOWTO(R_386_TLS_LDM, 0, 2, 32, false, 0, complain_overflow_bitfield,
155 bfd_elf_generic_reloc, "R_386_TLS_LDM",
156 true, 0xffffffff, 0xffffffff, false),
1b452ec6
AM		 157 HOWTO(R_386_16, 0, 1, 16, false, 0, complain_overflow_bitfield,
158 bfd_elf_generic_reloc, "R_386_16",
159 true, 0xffff, 0xffff, false),
160 HOWTO(R_386_PC16, 0, 1, 16, true, 0, complain_overflow_bitfield,
161 bfd_elf_generic_reloc, "R_386_PC16",
162 true, 0xffff, 0xffff, true),
163 HOWTO(R_386_8, 0, 0, 8, false, 0, complain_overflow_bitfield,
164 bfd_elf_generic_reloc, "R_386_8",
165 true, 0xff, 0xff, false),
166 HOWTO(R_386_PC8, 0, 0, 8, true, 0, complain_overflow_signed,
167 bfd_elf_generic_reloc, "R_386_PC8",
dc47f327
AM		 168 true, 0xff, 0xff, true),
169
dc47f327 170#define R_386_ext ((unsigned int) R_386_PC8 + 1 - R_386_ext_offset)
13ae64f3
JJ		 171#define R_386_tls_offset ((unsigned int) R_386_TLS_LDO_32 - R_386_ext)
172 /* These are common with Solaris TLS implementation. */
173 HOWTO(R_386_TLS_LDO_32, 0, 2, 32, false, 0, complain_overflow_bitfield,
174 bfd_elf_generic_reloc, "R_386_TLS_LDO_32",
175 true, 0xffffffff, 0xffffffff, false),
176 HOWTO(R_386_TLS_IE_32, 0, 2, 32, false, 0, complain_overflow_bitfield,
177 bfd_elf_generic_reloc, "R_386_TLS_IE_32",
178 true, 0xffffffff, 0xffffffff, false),
179 HOWTO(R_386_TLS_LE_32, 0, 2, 32, false, 0, complain_overflow_bitfield,
180 bfd_elf_generic_reloc, "R_386_TLS_LE_32",
181 true, 0xffffffff, 0xffffffff, false),
182 HOWTO(R_386_TLS_DTPMOD32, 0, 2, 32, false, 0, complain_overflow_bitfield,
183 bfd_elf_generic_reloc, "R_386_TLS_DTPMOD32",
184 true, 0xffffffff, 0xffffffff, false),
185 HOWTO(R_386_TLS_DTPOFF32, 0, 2, 32, false, 0, complain_overflow_bitfield,
186 bfd_elf_generic_reloc, "R_386_TLS_DTPOFF32",
187 true, 0xffffffff, 0xffffffff, false),
188 HOWTO(R_386_TLS_TPOFF32, 0, 2, 32, false, 0, complain_overflow_bitfield,
189 bfd_elf_generic_reloc, "R_386_TLS_TPOFF32",
190 true, 0xffffffff, 0xffffffff, false),
191
192 /* Another gap. */
193#define R_386_tls ((unsigned int) R_386_TLS_TPOFF32 + 1 - R_386_tls_offset)
194#define R_386_vt_offset ((unsigned int) R_386_GNU_VTINHERIT - R_386_tls)
252b5132
RH		 195
196/* GNU extension to record C++ vtable hierarchy. */
252b5132
RH		 197 HOWTO (R_386_GNU_VTINHERIT, /* type */
198 0, /* rightshift */
199 2, /* size (0 = byte, 1 = short, 2 = long) */
200 0, /* bitsize */
201 false, /* pc_relative */
202 0, /* bitpos */
203 complain_overflow_dont, /* complain_on_overflow */
204 NULL, /* special_function */
205 "R_386_GNU_VTINHERIT", /* name */
206 false, /* partial_inplace */
207 0, /* src_mask */
208 0, /* dst_mask */
4a335f3d 209 false), /* pcrel_offset */
252b5132
RH		 210
211/* GNU extension to record C++ vtable member usage. */
252b5132
RH		 212 HOWTO (R_386_GNU_VTENTRY, /* type */
213 0, /* rightshift */
214 2, /* size (0 = byte, 1 = short, 2 = long) */
215 0, /* bitsize */
216 false, /* pc_relative */
217 0, /* bitpos */
218 complain_overflow_dont, /* complain_on_overflow */
219 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
220 "R_386_GNU_VTENTRY", /* name */
221 false, /* partial_inplace */
222 0, /* src_mask */
223 0, /* dst_mask */
4a335f3d 224 false) /* pcrel_offset */
dc47f327
AM		 225
226#define R_386_vt ((unsigned int) R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
227
228};
229
252b5132
RH		 230#ifdef DEBUG_GEN_RELOC
231#define TRACE(str) fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
232#else
233#define TRACE(str)
234#endif
235
236static reloc_howto_type *
237elf_i386_reloc_type_lookup (abfd, code)
7442e600 238 bfd *abfd ATTRIBUTE_UNUSED;
252b5132
RH		 239 bfd_reloc_code_real_type code;
240{
241 switch (code)
242 {
243 case BFD_RELOC_NONE:
244 TRACE ("BFD_RELOC_NONE");
1b452ec6 245 return &elf_howto_table[(unsigned int) R_386_NONE ];
252b5132
RH		 246
247 case BFD_RELOC_32:
248 TRACE ("BFD_RELOC_32");
1b452ec6 249 return &elf_howto_table[(unsigned int) R_386_32 ];
252b5132
RH		 250
251 case BFD_RELOC_CTOR:
252 TRACE ("BFD_RELOC_CTOR");
1b452ec6 253 return &elf_howto_table[(unsigned int) R_386_32 ];
252b5132
RH		 254
255 case BFD_RELOC_32_PCREL:
256 TRACE ("BFD_RELOC_PC32");
1b452ec6 257 return &elf_howto_table[(unsigned int) R_386_PC32 ];
252b5132
RH		 258
259 case BFD_RELOC_386_GOT32:
260 TRACE ("BFD_RELOC_386_GOT32");
1b452ec6 261 return &elf_howto_table[(unsigned int) R_386_GOT32 ];
252b5132
RH		 262
263 case BFD_RELOC_386_PLT32:
264 TRACE ("BFD_RELOC_386_PLT32");
1b452ec6 265 return &elf_howto_table[(unsigned int) R_386_PLT32 ];
252b5132
RH		 266
267 case BFD_RELOC_386_COPY:
268 TRACE ("BFD_RELOC_386_COPY");
1b452ec6 269 return &elf_howto_table[(unsigned int) R_386_COPY ];
252b5132
RH		 270
271 case BFD_RELOC_386_GLOB_DAT:
272 TRACE ("BFD_RELOC_386_GLOB_DAT");
1b452ec6 273 return &elf_howto_table[(unsigned int) R_386_GLOB_DAT ];
252b5132
RH		 274
275 case BFD_RELOC_386_JUMP_SLOT:
276 TRACE ("BFD_RELOC_386_JUMP_SLOT");
1b452ec6 277 return &elf_howto_table[(unsigned int) R_386_JUMP_SLOT ];
252b5132
RH		 278
279 case BFD_RELOC_386_RELATIVE:
280 TRACE ("BFD_RELOC_386_RELATIVE");
1b452ec6 281 return &elf_howto_table[(unsigned int) R_386_RELATIVE ];
252b5132
RH		 282
283 case BFD_RELOC_386_GOTOFF:
284 TRACE ("BFD_RELOC_386_GOTOFF");
1b452ec6 285 return &elf_howto_table[(unsigned int) R_386_GOTOFF ];
252b5132
RH		 286
287 case BFD_RELOC_386_GOTPC:
288 TRACE ("BFD_RELOC_386_GOTPC");
1b452ec6 289 return &elf_howto_table[(unsigned int) R_386_GOTPC ];
252b5132 290
37e55690
JJ		 291 /* These relocs are a GNU extension. */
292 case BFD_RELOC_386_TLS_TPOFF:
293 TRACE ("BFD_RELOC_386_TLS_TPOFF");
294 return &elf_howto_table[(unsigned int) R_386_TLS_TPOFF - R_386_ext_offset];
295
296 case BFD_RELOC_386_TLS_IE:
297 TRACE ("BFD_RELOC_386_TLS_IE");
298 return &elf_howto_table[(unsigned int) R_386_TLS_IE - R_386_ext_offset];
299
300 case BFD_RELOC_386_TLS_GOTIE:
301 TRACE ("BFD_RELOC_386_TLS_GOTIE");
302 return &elf_howto_table[(unsigned int) R_386_TLS_GOTIE - R_386_ext_offset];
303
13ae64f3
JJ		 304 case BFD_RELOC_386_TLS_LE:
305 TRACE ("BFD_RELOC_386_TLS_LE");
306 return &elf_howto_table[(unsigned int) R_386_TLS_LE - R_386_ext_offset];
307
308 case BFD_RELOC_386_TLS_GD:
309 TRACE ("BFD_RELOC_386_TLS_GD");
310 return &elf_howto_table[(unsigned int) R_386_TLS_GD - R_386_ext_offset];
311
312 case BFD_RELOC_386_TLS_LDM:
313 TRACE ("BFD_RELOC_386_TLS_LDM");
314 return &elf_howto_table[(unsigned int) R_386_TLS_LDM - R_386_ext_offset];
315
252b5132
RH		 316 case BFD_RELOC_16:
317 TRACE ("BFD_RELOC_16");
1b452ec6 318 return &elf_howto_table[(unsigned int) R_386_16 - R_386_ext_offset];
252b5132
RH		 319
320 case BFD_RELOC_16_PCREL:
321 TRACE ("BFD_RELOC_16_PCREL");
1b452ec6 322 return &elf_howto_table[(unsigned int) R_386_PC16 - R_386_ext_offset];
252b5132
RH		 323
324 case BFD_RELOC_8:
325 TRACE ("BFD_RELOC_8");
1b452ec6 326 return &elf_howto_table[(unsigned int) R_386_8 - R_386_ext_offset];
252b5132
RH		 327
328 case BFD_RELOC_8_PCREL:
329 TRACE ("BFD_RELOC_8_PCREL");
1b452ec6 330 return &elf_howto_table[(unsigned int) R_386_PC8 - R_386_ext_offset];
252b5132 331
13ae64f3
JJ		 332 /* Common with Sun TLS implementation. */
333 case BFD_RELOC_386_TLS_LDO_32:
334 TRACE ("BFD_RELOC_386_TLS_LDO_32");
335 return &elf_howto_table[(unsigned int) R_386_TLS_LDO_32 - R_386_tls_offset];
336
337 case BFD_RELOC_386_TLS_IE_32:
338 TRACE ("BFD_RELOC_386_TLS_IE_32");
339 return &elf_howto_table[(unsigned int) R_386_TLS_IE_32 - R_386_tls_offset];
340
341 case BFD_RELOC_386_TLS_LE_32:
342 TRACE ("BFD_RELOC_386_TLS_LE_32");
343 return &elf_howto_table[(unsigned int) R_386_TLS_LE_32 - R_386_tls_offset];
344
345 case BFD_RELOC_386_TLS_DTPMOD32:
346 TRACE ("BFD_RELOC_386_TLS_DTPMOD32");
347 return &elf_howto_table[(unsigned int) R_386_TLS_DTPMOD32 - R_386_tls_offset];
348
349 case BFD_RELOC_386_TLS_DTPOFF32:
350 TRACE ("BFD_RELOC_386_TLS_DTPOFF32");
351 return &elf_howto_table[(unsigned int) R_386_TLS_DTPOFF32 - R_386_tls_offset];
352
353 case BFD_RELOC_386_TLS_TPOFF32:
354 TRACE ("BFD_RELOC_386_TLS_TPOFF32");
355 return &elf_howto_table[(unsigned int) R_386_TLS_TPOFF32 - R_386_tls_offset];
356
252b5132
RH		 357 case BFD_RELOC_VTABLE_INHERIT:
358 TRACE ("BFD_RELOC_VTABLE_INHERIT");
dc47f327
AM		 359 return &elf_howto_table[(unsigned int) R_386_GNU_VTINHERIT
360 - R_386_vt_offset];
252b5132
RH		 361
362 case BFD_RELOC_VTABLE_ENTRY:
363 TRACE ("BFD_RELOC_VTABLE_ENTRY");
dc47f327
AM		 364 return &elf_howto_table[(unsigned int) R_386_GNU_VTENTRY
365 - R_386_vt_offset];
252b5132
RH		 366
367 default:
368 break;
369 }
370
371 TRACE ("Unknown");
372 return 0;
373}
374
375static void
376elf_i386_info_to_howto (abfd, cache_ptr, dst)
7442e600
ILT		 377 bfd *abfd ATTRIBUTE_UNUSED;
378 arelent *cache_ptr ATTRIBUTE_UNUSED;
379 Elf32_Internal_Rela *dst ATTRIBUTE_UNUSED;
252b5132
RH		 380{
381 abort ();
382}
383
384static void
385elf_i386_info_to_howto_rel (abfd, cache_ptr, dst)
7442e600 386 bfd *abfd ATTRIBUTE_UNUSED;
252b5132
RH		 387 arelent *cache_ptr;
388 Elf32_Internal_Rel *dst;
389{
dc47f327
AM		 390 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
391 unsigned int indx;
392
393 if ((indx = r_type) >= R_386_standard
394 && ((indx = r_type - R_386_ext_offset) - R_386_standard
395 >= R_386_ext - R_386_standard)
13ae64f3
JJ		 396 && ((indx = r_type - R_386_tls_offset) - R_386_ext
397 >= R_386_tls - R_386_ext)
398 && ((indx = r_type - R_386_vt_offset) - R_386_tls
399 >= R_386_vt - R_386_tls))
252b5132 400 {
dc47f327 401 (*_bfd_error_handler) (_("%s: invalid relocation type %d"),
8f615d07 402 bfd_archive_filename (abfd), (int) r_type);
dc47f327 403 indx = (unsigned int) R_386_NONE;
252b5132 404 }
dc47f327 405 cache_ptr->howto = &elf_howto_table[indx];
252b5132
RH		 406}
407
408/* Return whether a symbol name implies a local label. The UnixWare
409 2.1 cc generates temporary symbols that start with .X, so we
410 recognize them here. FIXME: do other SVR4 compilers also use .X?.
411 If so, we should move the .X recognition into
412 _bfd_elf_is_local_label_name. */
413
414static boolean
415elf_i386_is_local_label_name (abfd, name)
416 bfd *abfd;
417 const char *name;
418{
419 if (name[0] == '.' && name[1] == 'X')
420 return true;
421
422 return _bfd_elf_is_local_label_name (abfd, name);
423}
424\f
38701953
AM		 425/* Support for core dump NOTE sections. */
426static boolean
427elf_i386_grok_prstatus (abfd, note)
428 bfd *abfd;
429 Elf_Internal_Note *note;
430{
431 int offset;
432 size_t raw_size;
433
434 switch (note->descsz)
435 {
436 default:
437 return false;
438
439 case 144: /* Linux/i386 */
440 /* pr_cursig */
441 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
442
443 /* pr_pid */
444 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
445
446 /* pr_reg */
447 offset = 72;
448 raw_size = 68;
449
450 break;
451 }
452
453 /* Make a ".reg/999" section. */
454 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
455 raw_size, note->descpos + offset);
456}
457
458static boolean
459elf_i386_grok_psinfo (abfd, note)
460 bfd *abfd;
461 Elf_Internal_Note *note;
462{
463 switch (note->descsz)
464 {
465 default:
466 return false;
467
fd29389c 468 case 124: /* Linux/i386 elf_prpsinfo */
38701953
AM		 469 elf_tdata (abfd)->core_program
470 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
471 elf_tdata (abfd)->core_command
472 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
473 }
474
475 /* Note that for some reason, a spurious space is tacked
476 onto the end of the args in some (at least one anyway)
477 implementations, so strip it off if it exists. */
478
479 {
480 char *command = elf_tdata (abfd)->core_command;
481 int n = strlen (command);
482
483 if (0 < n && command[n - 1] == ' ')
484 command[n - 1] = '\0';
485 }
486
487 return true;
488}
489\f
490/* Functions for the i386 ELF linker.
491
492 In order to gain some understanding of code in this file without
493 knowing all the intricate details of the linker, note the
494 following:
495
496 Functions named elf_i386_* are called by external routines, other
497 functions are only called locally. elf_i386_* functions appear
498 in this file more or less in the order in which they are called
499 from external routines. eg. elf_i386_check_relocs is called
500 early in the link process, elf_i386_finish_dynamic_sections is
501 one of the last functions. */
502
252b5132
RH		 503
504/* The name of the dynamic interpreter. This is put in the .interp
505 section. */
506
507#define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
508
509/* The size in bytes of an entry in the procedure linkage table. */
510
511#define PLT_ENTRY_SIZE 16
512
513/* The first entry in an absolute procedure linkage table looks like
514 this. See the SVR4 ABI i386 supplement to see how this works. */
515
516static const bfd_byte elf_i386_plt0_entry[PLT_ENTRY_SIZE] =
517{
518 0xff, 0x35, /* pushl contents of address */
519 0, 0, 0, 0, /* replaced with address of .got + 4. */
520 0xff, 0x25, /* jmp indirect */
521 0, 0, 0, 0, /* replaced with address of .got + 8. */
522 0, 0, 0, 0 /* pad out to 16 bytes. */
523};
524
525/* Subsequent entries in an absolute procedure linkage table look like
526 this. */
527
528static const bfd_byte elf_i386_plt_entry[PLT_ENTRY_SIZE] =
529{
530 0xff, 0x25, /* jmp indirect */
531 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
532 0x68, /* pushl immediate */
533 0, 0, 0, 0, /* replaced with offset into relocation table. */
534 0xe9, /* jmp relative */
535 0, 0, 0, 0 /* replaced with offset to start of .plt. */
536};
537
538/* The first entry in a PIC procedure linkage table look like this. */
539
540static const bfd_byte elf_i386_pic_plt0_entry[PLT_ENTRY_SIZE] =
541{
542 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
543 0xff, 0xa3, 8, 0, 0, 0, /* jmp *8(%ebx) */
544 0, 0, 0, 0 /* pad out to 16 bytes. */
545};
546
547/* Subsequent entries in a PIC procedure linkage table look like this. */
548
549static const bfd_byte elf_i386_pic_plt_entry[PLT_ENTRY_SIZE] =
550{
551 0xff, 0xa3, /* jmp *offset(%ebx) */
552 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
553 0x68, /* pushl immediate */
554 0, 0, 0, 0, /* replaced with offset into relocation table. */
555 0xe9, /* jmp relative */
556 0, 0, 0, 0 /* replaced with offset to start of .plt. */
557};
558
559/* The i386 linker needs to keep track of the number of relocs that it
ffb2e45b
AM		 560 decides to copy as dynamic relocs in check_relocs for each symbol.
561 This is so that it can later discard them if they are found to be
562 unnecessary. We store the information in a field extending the
563 regular ELF linker hash table. */
252b5132 564
ffb2e45b 565struct elf_i386_dyn_relocs
252b5132 566{
ffb2e45b 567 struct elf_i386_dyn_relocs *next;
0c715baa
AM		 568
569 /* The input section of the reloc. */
570 asection *sec;
571
572 /* Total number of relocs copied for the input section. */
252b5132 573 bfd_size_type count;
0c715baa
AM		 574
575 /* Number of pc-relative relocs copied for the input section. */
576 bfd_size_type pc_count;
252b5132
RH		 577};
578
579/* i386 ELF linker hash entry. */
580
581struct elf_i386_link_hash_entry
582{
ebe50bae 583 struct elf_link_hash_entry elf;
252b5132 584
0c715baa 585 /* Track dynamic relocs copied for this symbol. */
ffb2e45b 586 struct elf_i386_dyn_relocs *dyn_relocs;
13ae64f3 587
37e55690
JJ		 588#define GOT_UNKNOWN 0
589#define GOT_NORMAL 1
590#define GOT_TLS_GD 2
591#define GOT_TLS_IE 4
592#define GOT_TLS_IE_POS 5
593#define GOT_TLS_IE_NEG 6
594#define GOT_TLS_IE_BOTH 7
595 unsigned char tls_type;
13ae64f3
JJ		 596};
597
598#define elf_i386_hash_entry(ent) ((struct elf_i386_link_hash_entry *)(ent))
599
600struct elf_i386_obj_tdata
601{
602 struct elf_obj_tdata root;
603
604 /* tls_type for each local got entry. */
605 char *local_got_tls_type;
252b5132
RH		 606};
607
13ae64f3
JJ		 608#define elf_i386_tdata(abfd) \
609 ((struct elf_i386_obj_tdata *) (abfd)->tdata.any)
610
611#define elf_i386_local_got_tls_type(abfd) \
612 (elf_i386_tdata (abfd)->local_got_tls_type)
613
614static boolean
615elf_i386_mkobject (abfd)
616 bfd *abfd;
617{
618 bfd_size_type amt = sizeof (struct elf_i386_obj_tdata);
619 abfd->tdata.any = bfd_zalloc (abfd, amt);
620 if (abfd->tdata.any == NULL)
621 return false;
622 return true;
623}
cedb70c5 624
13ae64f3
JJ		 625static boolean
626elf_i386_object_p (abfd)
627 bfd *abfd;
628{
629 /* Allocate our special target data. */
630 struct elf_i386_obj_tdata *new_tdata;
631 bfd_size_type amt = sizeof (struct elf_i386_obj_tdata);
632 new_tdata = bfd_zalloc (abfd, amt);
633 if (new_tdata == NULL)
634 return false;
635 new_tdata->root = *abfd->tdata.elf_obj_data;
636 abfd->tdata.any = new_tdata;
637 return true;
638}
639
252b5132
RH		 640/* i386 ELF linker hash table. */
641
642struct elf_i386_link_hash_table
643{
ebe50bae 644 struct elf_link_hash_table elf;
252b5132 645
6725bdbf
AM		 646 /* Short-cuts to get to dynamic linker sections. */
647 asection *sgot;
648 asection *sgotplt;
649 asection *srelgot;
650 asection *splt;
651 asection *srelplt;
652 asection *sdynbss;
653 asection *srelbss;
ec338859 654
13ae64f3
JJ		 655 union {
656 bfd_signed_vma refcount;
657 bfd_vma offset;
658 } tls_ldm_got;
659
ec338859
AM		 660 /* Small local sym to section mapping cache. */
661 struct sym_sec_cache sym_sec;
6725bdbf 662};
252b5132
RH		 663
664/* Get the i386 ELF linker hash table from a link_info structure. */
665
666#define elf_i386_hash_table(p) \
667 ((struct elf_i386_link_hash_table *) ((p)->hash))
668
669/* Create an entry in an i386 ELF linker hash table. */
670
671static struct bfd_hash_entry *
38701953 672link_hash_newfunc (entry, table, string)
252b5132
RH		 673 struct bfd_hash_entry *entry;
674 struct bfd_hash_table *table;
675 const char *string;
676{
252b5132
RH		 677 /* Allocate the structure if it has not already been allocated by a
678 subclass. */
ebe50bae
AM		 679 if (entry == NULL)
680 {
681 entry = bfd_hash_allocate (table,
682 sizeof (struct elf_i386_link_hash_entry));
683 if (entry == NULL)
684 return entry;
685 }
252b5132
RH		 686
687 /* Call the allocation method of the superclass. */
ebe50bae
AM		 688 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
689 if (entry != NULL)
252b5132 690 {
ebe50bae
AM		 691 struct elf_i386_link_hash_entry *eh;
692
693 eh = (struct elf_i386_link_hash_entry *) entry;
694 eh->dyn_relocs = NULL;
13ae64f3 695 eh->tls_type = GOT_UNKNOWN;
252b5132
RH		 696 }
697
ebe50bae 698 return entry;
252b5132
RH		 699}
700
701/* Create an i386 ELF linker hash table. */
702
703static struct bfd_link_hash_table *
704elf_i386_link_hash_table_create (abfd)
705 bfd *abfd;
706{
707 struct elf_i386_link_hash_table *ret;
dc810e39 708 bfd_size_type amt = sizeof (struct elf_i386_link_hash_table);
252b5132 709
e2d34d7d 710 ret = (struct elf_i386_link_hash_table *) bfd_malloc (amt);
ebe50bae 711 if (ret == NULL)
252b5132
RH		 712 return NULL;
713
ebe50bae 714 if (! _bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc))
252b5132 715 {
e2d34d7d 716 free (ret);
252b5132
RH		 717 return NULL;
718 }
719
6725bdbf
AM		 720 ret->sgot = NULL;
721 ret->sgotplt = NULL;
722 ret->srelgot = NULL;
723 ret->splt = NULL;
724 ret->srelplt = NULL;
725 ret->sdynbss = NULL;
726 ret->srelbss = NULL;
7a624474 727 ret->tls_ldm_got.refcount = 0;
ec338859 728 ret->sym_sec.abfd = NULL;
6725bdbf 729
ebe50bae 730 return &ret->elf.root;
252b5132
RH		 731}
732
6725bdbf
AM		 733/* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
734 shortcuts to them in our hash table. */
735
736static boolean
737create_got_section (dynobj, info)
738 bfd *dynobj;
739 struct bfd_link_info *info;
740{
741 struct elf_i386_link_hash_table *htab;
742
743 if (! _bfd_elf_create_got_section (dynobj, info))
744 return false;
745
746 htab = elf_i386_hash_table (info);
747 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
748 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
749 if (!htab->sgot || !htab->sgotplt)
750 abort ();
751
752 htab->srelgot = bfd_make_section (dynobj, ".rel.got");
753 if (htab->srelgot == NULL
754 || ! bfd_set_section_flags (dynobj, htab->srelgot,
755 (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
756 | SEC_IN_MEMORY | SEC_LINKER_CREATED
757 | SEC_READONLY))
758 || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
759 return false;
760 return true;
761}
762
763/* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
764 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
765 hash table. */
766
767static boolean
768elf_i386_create_dynamic_sections (dynobj, info)
769 bfd *dynobj;
770 struct bfd_link_info *info;
771{
772 struct elf_i386_link_hash_table *htab;
773
774 htab = elf_i386_hash_table (info);
775 if (!htab->sgot && !create_got_section (dynobj, info))
776 return false;
777
778 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
779 return false;
780
781 htab->splt = bfd_get_section_by_name (dynobj, ".plt");
782 htab->srelplt = bfd_get_section_by_name (dynobj, ".rel.plt");
783 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
784 if (!info->shared)
785 htab->srelbss = bfd_get_section_by_name (dynobj, ".rel.bss");
786
787 if (!htab->splt || !htab->srelplt || !htab->sdynbss
788 || (!info->shared && !htab->srelbss))
789 abort ();
790
791 return true;
792}
793
ebe50bae
AM		 794/* Copy the extra info we tack onto an elf_link_hash_entry. */
795
51b64d56 796static void
b48fa14c
AM		 797elf_i386_copy_indirect_symbol (bed, dir, ind)
798 struct elf_backend_data *bed;
ebe50bae
AM		 799 struct elf_link_hash_entry *dir, *ind;
800{
801 struct elf_i386_link_hash_entry *edir, *eind;
802
803 edir = (struct elf_i386_link_hash_entry *) dir;
804 eind = (struct elf_i386_link_hash_entry *) ind;
805
bbd7ec4a 806 if (eind->dyn_relocs != NULL)
ebe50bae 807 {
bbd7ec4a
AM		 808 if (edir->dyn_relocs != NULL)
809 {
810 struct elf_i386_dyn_relocs **pp;
811 struct elf_i386_dyn_relocs *p;
812
1e370bd2 813 if (ind->root.type == bfd_link_hash_indirect)
bbd7ec4a
AM		 814 abort ();
815
816 /* Add reloc counts against the weak sym to the strong sym
817 list. Merge any entries against the same section. */
818 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
819 {
820 struct elf_i386_dyn_relocs *q;
821
822 for (q = edir->dyn_relocs; q != NULL; q = q->next)
823 if (q->sec == p->sec)
824 {
825 q->pc_count += p->pc_count;
826 q->count += p->count;
827 *pp = p->next;
828 break;
829 }
830 if (q == NULL)
831 pp = &p->next;
832 }
833 *pp = edir->dyn_relocs;
834 }
835
ebe50bae
AM		 836 edir->dyn_relocs = eind->dyn_relocs;
837 eind->dyn_relocs = NULL;
838 }
ebe50bae 839
cd67d266
JJ		 840 if (ind->root.type == bfd_link_hash_indirect
841 && dir->got.refcount <= 0)
842 {
843 edir->tls_type = eind->tls_type;
844 eind->tls_type = GOT_UNKNOWN;
845 }
b48fa14c 846 _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
ebe50bae
AM		 847}
848
13ae64f3
JJ		 849static int
850elf_i386_tls_transition (info, r_type, is_local)
851 struct bfd_link_info *info;
852 int r_type;
853 int is_local;
854{
855 if (info->shared)
856 return r_type;
857
858 switch (r_type)
859 {
860 case R_386_TLS_GD:
861 case R_386_TLS_IE_32:
862 if (is_local)
863 return R_386_TLS_LE_32;
864 return R_386_TLS_IE_32;
37e55690
JJ		 865 case R_386_TLS_IE:
866 case R_386_TLS_GOTIE:
867 if (is_local)
868 return R_386_TLS_LE_32;
869 return r_type;
13ae64f3
JJ		 870 case R_386_TLS_LDM:
871 return R_386_TLS_LE_32;
872 }
873
874 return r_type;
875}
876
252b5132 877/* Look through the relocs for a section during the first phase, and
0ac8d2ca
AM		 878 calculate needed space in the global offset table, procedure linkage
879 table, and dynamic reloc sections. */
252b5132
RH		 880
881static boolean
882elf_i386_check_relocs (abfd, info, sec, relocs)
883 bfd *abfd;
884 struct bfd_link_info *info;
885 asection *sec;
886 const Elf_Internal_Rela *relocs;
887{
6725bdbf 888 struct elf_i386_link_hash_table *htab;
252b5132
RH		 889 Elf_Internal_Shdr *symtab_hdr;
890 struct elf_link_hash_entry **sym_hashes;
252b5132
RH		 891 const Elf_Internal_Rela *rel;
892 const Elf_Internal_Rela *rel_end;
252b5132
RH		 893 asection *sreloc;
894
895 if (info->relocateable)
896 return true;
897
6725bdbf 898 htab = elf_i386_hash_table (info);
252b5132
RH		 899 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
900 sym_hashes = elf_sym_hashes (abfd);
252b5132 901
252b5132
RH		 902 sreloc = NULL;
903
904 rel_end = relocs + sec->reloc_count;
905 for (rel = relocs; rel < rel_end; rel++)
906 {
13ae64f3 907 unsigned int r_type;
252b5132
RH		 908 unsigned long r_symndx;
909 struct elf_link_hash_entry *h;
910
911 r_symndx = ELF32_R_SYM (rel->r_info);
13ae64f3 912 r_type = ELF32_R_TYPE (rel->r_info);
252b5132 913
d9bc7a44 914 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
f5f31454 915 {
8f615d07
AM		 916 (*_bfd_error_handler) (_("%s: bad symbol index: %d"),
917 bfd_archive_filename (abfd),
918 r_symndx);
f5f31454
L		 919 return false;
920 }
921
252b5132
RH		 922 if (r_symndx < symtab_hdr->sh_info)
923 h = NULL;
924 else
925 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
926
13ae64f3
JJ		 927 r_type = elf_i386_tls_transition (info, r_type, h == NULL);
928
929 switch (r_type)
252b5132 930 {
37e55690
JJ		 931 case R_386_TLS_LDM:
932 htab->tls_ldm_got.refcount += 1;
933 goto create_got;
934
935 case R_386_PLT32:
936 /* This symbol requires a procedure linkage table entry. We
937 actually build the entry in adjust_dynamic_symbol,
938 because this might be a case of linking PIC code which is
939 never referenced by a dynamic object, in which case we
940 don't need to generate a procedure linkage table entry
941 after all. */
942
943 /* If this is a local symbol, we resolve it directly without
944 creating a procedure linkage table entry. */
945 if (h == NULL)
946 continue;
947
948 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
949 h->plt.refcount += 1;
950 break;
951
13ae64f3 952 case R_386_TLS_IE_32:
37e55690
JJ		 953 case R_386_TLS_IE:
954 case R_386_TLS_GOTIE:
13ae64f3
JJ		 955 if (info->shared)
956 info->flags |= DF_STATIC_TLS;
37e55690
JJ		 957 /* Fall through */
958
252b5132 959 case R_386_GOT32:
13ae64f3 960 case R_386_TLS_GD:
252b5132 961 /* This symbol requires a global offset table entry. */
13ae64f3
JJ		 962 {
963 int tls_type, old_tls_type;
964
965 switch (r_type)
966 {
967 default:
968 case R_386_GOT32: tls_type = GOT_NORMAL; break;
969 case R_386_TLS_GD: tls_type = GOT_TLS_GD; break;
37e55690
JJ		 970 case R_386_TLS_IE_32:
971 if (ELF32_R_TYPE (rel->r_info) == r_type)
972 tls_type = GOT_TLS_IE_NEG;
973 else
974 /* If this is a GD->IE transition, we may use either of
975 R_386_TLS_TPOFF and R_386_TLS_TPOFF32. */
976 tls_type = GOT_TLS_IE;
977 break;
978 case R_386_TLS_IE:
979 case R_386_TLS_GOTIE:
980 tls_type = GOT_TLS_IE_POS; break;
13ae64f3
JJ		 981 }
982
983 if (h != NULL)
984 {
985 h->got.refcount += 1;
986 old_tls_type = elf_i386_hash_entry(h)->tls_type;
987 }
988 else
989 {
990 bfd_signed_vma *local_got_refcounts;
991
992 /* This is a global offset table entry for a local symbol. */
993 local_got_refcounts = elf_local_got_refcounts (abfd);
994 if (local_got_refcounts == NULL)
995 {
996 bfd_size_type size;
997
998 size = symtab_hdr->sh_info;
999 size *= (sizeof (bfd_signed_vma) + sizeof(char));
1000 local_got_refcounts = ((bfd_signed_vma *)
1001 bfd_zalloc (abfd, size));
1002 if (local_got_refcounts == NULL)
1003 return false;
1004 elf_local_got_refcounts (abfd) = local_got_refcounts;
1005 elf_i386_local_got_tls_type (abfd)
1006 = (char *) (local_got_refcounts + symtab_hdr->sh_info);
1007 }
1008 local_got_refcounts[r_symndx] += 1;
1009 old_tls_type = elf_i386_local_got_tls_type (abfd) [r_symndx];
1010 }
1011
37e55690
JJ		 1012 if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_IE))
1013 tls_type |= old_tls_type;
13ae64f3
JJ		 1014 /* If a TLS symbol is accessed using IE at least once,
1015 there is no point to use dynamic model for it. */
37e55690
JJ		 1016 else if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1017 && (old_tls_type != GOT_TLS_GD
1018 || (tls_type & GOT_TLS_IE) == 0))
13ae64f3 1019 {
37e55690
JJ		 1020 if ((old_tls_type & GOT_TLS_IE) && tls_type == GOT_TLS_GD)
1021 tls_type = old_tls_type;
13ae64f3
JJ		 1022 else
1023 {
1024 (*_bfd_error_handler)
1025 (_("%s: `%s' accessed both as normal and thread local symbol"),
37e55690
JJ		 1026 bfd_archive_filename (abfd),
1027 h ? h->root.root.string : "<local>");
252b5132 1028 return false;
13ae64f3
JJ		 1029 }
1030 }
1031
1032 if (old_tls_type != tls_type)
1033 {
1034 if (h != NULL)
1035 elf_i386_hash_entry (h)->tls_type = tls_type;
1036 else
1037 elf_i386_local_got_tls_type (abfd) [r_symndx] = tls_type;
1038 }
1039 }
0ac8d2ca
AM		 1040 /* Fall through */
1041
1042 case R_386_GOTOFF:
1043 case R_386_GOTPC:
13ae64f3 1044 create_got:
0ac8d2ca
AM		 1045 if (htab->sgot == NULL)
1046 {
1047 if (htab->elf.dynobj == NULL)
1048 htab->elf.dynobj = abfd;
1049 if (!create_got_section (htab->elf.dynobj, info))
1050 return false;
1051 }
37e55690
JJ		 1052 if (r_type != R_386_TLS_IE)
1053 break;
1054 /* Fall through */
252b5132 1055
37e55690
JJ		 1056 case R_386_TLS_LE_32:
1057 case R_386_TLS_LE:
1058 if (!info->shared)
1059 break;
1060 /* Fall through */
252b5132
RH		 1061
1062 case R_386_32:
1063 case R_386_PC32:
12d0ee4a 1064 if (h != NULL && !info->shared)
6725bdbf 1065 {
12d0ee4a 1066 /* If this reloc is in a read-only section, we might
ebe50bae
AM		 1067 need a copy reloc. We can't check reliably at this
1068 stage whether the section is read-only, as input
1069 sections have not yet been mapped to output sections.
1070 Tentatively set the flag for now, and correct in
1071 adjust_dynamic_symbol. */
1072 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
12d0ee4a
AM		 1073
1074 /* We may need a .plt entry if the function this reloc
1075 refers to is in a shared lib. */
51b64d56 1076 h->plt.refcount += 1;
6725bdbf 1077 }
7843f00e 1078
252b5132 1079 /* If we are creating a shared library, and this is a reloc
f69da49f
AM		 1080 against a global symbol, or a non PC relative reloc
1081 against a local symbol, then we need to copy the reloc
1082 into the shared library. However, if we are linking with
1083 -Bsymbolic, we do not need to copy a reloc against a
1084 global symbol which is defined in an object we are
1085 including in the link (i.e., DEF_REGULAR is set). At
1086 this point we have not seen all the input files, so it is
1087 possible that DEF_REGULAR is not set now but will be set
1f655a09
L		 1088 later (it is never cleared). In case of a weak definition,
1089 DEF_REGULAR may be cleared later by a strong definition in
ebe50bae 1090 a shared library. We account for that possibility below by
1f655a09
L		 1091 storing information in the relocs_copied field of the hash
1092 table entry. A similar situation occurs when creating
1093 shared libraries and symbol visibility changes render the
12d0ee4a 1094 symbol local.
56882138 1095
12d0ee4a
AM		 1096 If on the other hand, we are creating an executable, we
1097 may need to keep relocations for symbols satisfied by a
1098 dynamic library if we manage to avoid copy relocs for the
1099 symbol. */
1100 if ((info->shared
1101 && (sec->flags & SEC_ALLOC) != 0
13ae64f3 1102 && (r_type != R_386_PC32
12d0ee4a
AM		 1103 || (h != NULL
1104 && (! info->symbolic
1105 || h->root.type == bfd_link_hash_defweak
1106 || (h->elf_link_hash_flags
1107 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
1108 || (!info->shared
1109 && (sec->flags & SEC_ALLOC) != 0
1110 && h != NULL
12d0ee4a
AM		 1111 && (h->root.type == bfd_link_hash_defweak
1112 || (h->elf_link_hash_flags
1113 & ELF_LINK_HASH_DEF_REGULAR) == 0)))
252b5132 1114 {
ec338859
AM		 1115 struct elf_i386_dyn_relocs *p;
1116 struct elf_i386_dyn_relocs **head;
1117
12d0ee4a
AM		 1118 /* We must copy these reloc types into the output file.
1119 Create a reloc section in dynobj and make room for
1120 this reloc. */
252b5132
RH		 1121 if (sreloc == NULL)
1122 {
1123 const char *name;
0ac8d2ca 1124 bfd *dynobj;
e92d460e
AM		 1125 unsigned int strndx = elf_elfheader (abfd)->e_shstrndx;
1126 unsigned int shnam = elf_section_data (sec)->rel_hdr.sh_name;
252b5132 1127
e92d460e 1128 name = bfd_elf_string_from_elf_section (abfd, strndx, shnam);
252b5132
RH		 1129 if (name == NULL)
1130 return false;
1131
c8492176
L		 1132 if (strncmp (name, ".rel", 4) != 0
1133 || strcmp (bfd_get_section_name (abfd, sec),
1134 name + 4) != 0)
1135 {
0c715baa
AM		 1136 (*_bfd_error_handler)
1137 (_("%s: bad relocation section name `%s\'"),
1138 bfd_archive_filename (abfd), name);
f5f31454 1139 }
252b5132 1140
0ac8d2ca
AM		 1141 if (htab->elf.dynobj == NULL)
1142 htab->elf.dynobj = abfd;
1143
1144 dynobj = htab->elf.dynobj;
252b5132
RH		 1145 sreloc = bfd_get_section_by_name (dynobj, name);
1146 if (sreloc == NULL)
1147 {
1148 flagword flags;
1149
1150 sreloc = bfd_make_section (dynobj, name);
1151 flags = (SEC_HAS_CONTENTS | SEC_READONLY
1152 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1153 if ((sec->flags & SEC_ALLOC) != 0)
1154 flags |= SEC_ALLOC | SEC_LOAD;
1155 if (sreloc == NULL
1156 || ! bfd_set_section_flags (dynobj, sreloc, flags)
1157 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
1158 return false;
1159 }
0c715baa 1160 elf_section_data (sec)->sreloc = sreloc;
252b5132
RH		 1161 }
1162
0c715baa
AM		 1163 /* If this is a global symbol, we count the number of
1164 relocations we need for this symbol. */
1165 if (h != NULL)
252b5132 1166 {
ec338859 1167 head = &((struct elf_i386_link_hash_entry *) h)->dyn_relocs;
0c715baa
AM		 1168 }
1169 else
1170 {
ec338859
AM		 1171 /* Track dynamic relocs needed for local syms too.
1172 We really need local syms available to do this
1173 easily. Oh well. */
1174
1175 asection *s;
1176 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
1177 sec, r_symndx);
1178 if (s == NULL)
1179 return false;
1180
1181 head = ((struct elf_i386_dyn_relocs **)
1182 &elf_section_data (s)->local_dynrel);
1183 }
1184
1185 p = *head;
1186 if (p == NULL || p->sec != sec)
1187 {
1188 bfd_size_type amt = sizeof *p;
1189 p = ((struct elf_i386_dyn_relocs *)
1190 bfd_alloc (htab->elf.dynobj, amt));
1191 if (p == NULL)
1192 return false;
1193 p->next = *head;
1194 *head = p;
1195 p->sec = sec;
1196 p->count = 0;
1197 p->pc_count = 0;
252b5132 1198 }
ec338859
AM		 1199
1200 p->count += 1;
13ae64f3 1201 if (r_type == R_386_PC32)
ec338859 1202 p->pc_count += 1;
252b5132 1203 }
252b5132
RH		 1204 break;
1205
1206 /* This relocation describes the C++ object vtable hierarchy.
1207 Reconstruct it for later use during GC. */
1208 case R_386_GNU_VTINHERIT:
1209 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1210 return false;
1211 break;
1212
1213 /* This relocation describes which C++ vtable entries are actually
1214 used. Record for later use during GC. */
1215 case R_386_GNU_VTENTRY:
1216 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
1217 return false;
1218 break;
1219
1220 default:
1221 break;
1222 }
1223 }
1224
1225 return true;
1226}
1227
1228/* Return the section that should be marked against GC for a given
1229 relocation. */
1230
1231static asection *
1e2f5b6e
AM		 1232elf_i386_gc_mark_hook (sec, info, rel, h, sym)
1233 asection *sec;
7442e600 1234 struct bfd_link_info *info ATTRIBUTE_UNUSED;
252b5132
RH		 1235 Elf_Internal_Rela *rel;
1236 struct elf_link_hash_entry *h;
1237 Elf_Internal_Sym *sym;
1238{
1239 if (h != NULL)
1240 {
1241 switch (ELF32_R_TYPE (rel->r_info))
1242 {
1243 case R_386_GNU_VTINHERIT:
1244 case R_386_GNU_VTENTRY:
1245 break;
1246
1247 default:
1248 switch (h->root.type)
1249 {
1250 case bfd_link_hash_defined:
1251 case bfd_link_hash_defweak:
1252 return h->root.u.def.section;
1253
1254 case bfd_link_hash_common:
1255 return h->root.u.c.p->section;
1256
1257 default:
1258 break;
1259 }
1260 }
1261 }
1262 else
1e2f5b6e 1263 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
252b5132
RH		 1264
1265 return NULL;
1266}
1267
1268/* Update the got entry reference counts for the section being removed. */
1269
1270static boolean
1271elf_i386_gc_sweep_hook (abfd, info, sec, relocs)
dd5724d5 1272 bfd *abfd;
6725bdbf 1273 struct bfd_link_info *info;
dd5724d5
AM		 1274 asection *sec;
1275 const Elf_Internal_Rela *relocs;
252b5132 1276{
dd5724d5
AM		 1277 Elf_Internal_Shdr *symtab_hdr;
1278 struct elf_link_hash_entry **sym_hashes;
1279 bfd_signed_vma *local_got_refcounts;
1280 const Elf_Internal_Rela *rel, *relend;
1281 unsigned long r_symndx;
37e55690 1282 int r_type;
dd5724d5 1283 struct elf_link_hash_entry *h;
dd5724d5 1284
ec338859 1285 elf_section_data (sec)->local_dynrel = NULL;
dd5724d5 1286
6725bdbf
AM		 1287 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1288 sym_hashes = elf_sym_hashes (abfd);
1289 local_got_refcounts = elf_local_got_refcounts (abfd);
dd5724d5
AM		 1290
1291 relend = relocs + sec->reloc_count;
1292 for (rel = relocs; rel < relend; rel++)
37e55690
JJ		 1293 switch ((r_type = elf_i386_tls_transition (info,
1294 ELF32_R_TYPE (rel->r_info),
1295 ELF32_R_SYM (rel->r_info)
1296 >= symtab_hdr->sh_info)))
dd5724d5 1297 {
13ae64f3
JJ		 1298 case R_386_TLS_LDM:
1299 if (elf_i386_hash_table (info)->tls_ldm_got.refcount > 0)
1300 elf_i386_hash_table (info)->tls_ldm_got.refcount -= 1;
1301 break;
1302
1303 case R_386_TLS_GD:
1304 case R_386_TLS_IE_32:
37e55690
JJ		 1305 case R_386_TLS_IE:
1306 case R_386_TLS_GOTIE:
dd5724d5 1307 case R_386_GOT32:
dd5724d5
AM		 1308 r_symndx = ELF32_R_SYM (rel->r_info);
1309 if (r_symndx >= symtab_hdr->sh_info)
1310 {
1311 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1312 if (h->got.refcount > 0)
6725bdbf 1313 h->got.refcount -= 1;
dd5724d5
AM		 1314 }
1315 else if (local_got_refcounts != NULL)
1316 {
1317 if (local_got_refcounts[r_symndx] > 0)
6725bdbf 1318 local_got_refcounts[r_symndx] -= 1;
dd5724d5 1319 }
37e55690
JJ		 1320 if (r_type != R_386_TLS_IE)
1321 break;
1322 /* Fall through */
1323
1324 case R_386_TLS_LE_32:
1325 case R_386_TLS_LE:
1326 if (!info->shared)
1327 break;
1328 /* Fall through */
dd5724d5 1329
6725bdbf
AM		 1330 case R_386_32:
1331 case R_386_PC32:
0c715baa
AM		 1332 r_symndx = ELF32_R_SYM (rel->r_info);
1333 if (r_symndx >= symtab_hdr->sh_info)
1334 {
1335 struct elf_i386_link_hash_entry *eh;
1336 struct elf_i386_dyn_relocs **pp;
1337 struct elf_i386_dyn_relocs *p;
1338
1339 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1340
1341 if (!info->shared && h->plt.refcount > 0)
1342 h->plt.refcount -= 1;
1343
1344 eh = (struct elf_i386_link_hash_entry *) h;
1345
1346 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1347 if (p->sec == sec)
1348 {
1349 if (ELF32_R_TYPE (rel->r_info) == R_386_PC32)
1350 p->pc_count -= 1;
1351 p->count -= 1;
1352 if (p->count == 0)
1353 *pp = p->next;
1354 break;
1355 }
1356 }
1357 break;
6725bdbf 1358
dd5724d5
AM		 1359 case R_386_PLT32:
1360 r_symndx = ELF32_R_SYM (rel->r_info);
1361 if (r_symndx >= symtab_hdr->sh_info)
1362 {
1363 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1364 if (h->plt.refcount > 0)
1365 h->plt.refcount -= 1;
1366 }
1367 break;
1368
1369 default:
1370 break;
1371 }
252b5132
RH		 1372
1373 return true;
1374}
1375
1376/* Adjust a symbol defined by a dynamic object and referenced by a
1377 regular object. The current definition is in some section of the
1378 dynamic object, but we're not including those sections. We have to
1379 change the definition to something the rest of the link can
1380 understand. */
1381
1382static boolean
1383elf_i386_adjust_dynamic_symbol (info, h)
1384 struct bfd_link_info *info;
1385 struct elf_link_hash_entry *h;
1386{
6725bdbf 1387 struct elf_i386_link_hash_table *htab;
ebe50bae
AM		 1388 struct elf_i386_link_hash_entry * eh;
1389 struct elf_i386_dyn_relocs *p;
252b5132
RH		 1390 asection *s;
1391 unsigned int power_of_two;
1392
252b5132
RH		 1393 /* If this is a function, put it in the procedure linkage table. We
1394 will fill in the contents of the procedure linkage table later,
1395 when we know the address of the .got section. */
1396 if (h->type == STT_FUNC
1397 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
1398 {
6725bdbf
AM		 1399 if (h->plt.refcount <= 0
1400 || (! info->shared
1401 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
f9cd9119
MS		 1402 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0
1403 && h->root.type != bfd_link_hash_undefweak
1404 && h->root.type != bfd_link_hash_undefined))
252b5132
RH		 1405 {
1406 /* This case can occur if we saw a PLT32 reloc in an input
dd5724d5
AM		 1407 file, but the symbol was never referred to by a dynamic
1408 object, or if all references were garbage collected. In
1409 such a case, we don't actually need to build a procedure
1410 linkage table, and we can just do a PC32 reloc instead. */
bbd7ec4a 1411 h->plt.offset = (bfd_vma) -1;
dd5724d5 1412 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
252b5132
RH		 1413 }
1414
252b5132
RH		 1415 return true;
1416 }
6725bdbf
AM		 1417 else
1418 /* It's possible that we incorrectly decided a .plt reloc was
1419 needed for an R_386_PC32 reloc to a non-function sym in
1420 check_relocs. We can't decide accurately between function and
1421 non-function syms in check-relocs; Objects loaded later in
1422 the link may change h->type. So fix it now. */
bbd7ec4a 1423 h->plt.offset = (bfd_vma) -1;
252b5132
RH		 1424
1425 /* If this is a weak symbol, and there is a real definition, the
1426 processor independent code will have arranged for us to see the
1427 real definition first, and we can just use the same value. */
1428 if (h->weakdef != NULL)
1429 {
1430 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
1431 || h->weakdef->root.type == bfd_link_hash_defweak);
1432 h->root.u.def.section = h->weakdef->root.u.def.section;
1433 h->root.u.def.value = h->weakdef->root.u.def.value;
0a991dfe 1434 return true;
252b5132
RH		 1435 }
1436
1437 /* This is a reference to a symbol defined by a dynamic object which
1438 is not a function. */
1439
1440 /* If we are creating a shared library, we must presume that the
1441 only references to the symbol are via the global offset table.
1442 For such cases we need not do anything here; the relocations will
1443 be handled correctly by relocate_section. */
1444 if (info->shared)
1445 return true;
1446
7843f00e
ILT		 1447 /* If there are no references to this symbol that do not use the
1448 GOT, we don't need to generate a copy reloc. */
1449 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
1450 return true;
1451
8bd621d8
AM		 1452 /* If -z nocopyreloc was given, we won't generate them either. */
1453 if (info->nocopyreloc)
1454 {
1455 h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
1456 return true;
1457 }
1458
ebe50bae
AM		 1459 eh = (struct elf_i386_link_hash_entry *) h;
1460 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1461 {
1462 s = p->sec->output_section;
1463 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1464 break;
1465 }
1466
1467 /* If we didn't find any dynamic relocs in read-only sections, then
cedb70c5 1468 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
ebe50bae
AM		 1469 if (p == NULL)
1470 {
1471 h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
1472 return true;
1473 }
1474
252b5132
RH		 1475 /* We must allocate the symbol in our .dynbss section, which will
1476 become part of the .bss section of the executable. There will be
1477 an entry for this symbol in the .dynsym section. The dynamic
1478 object will contain position independent code, so all references
1479 from the dynamic object to this symbol will go through the global
1480 offset table. The dynamic linker will use the .dynsym entry to
1481 determine the address it must put in the global offset table, so
1482 both the dynamic object and the regular object will refer to the
1483 same memory location for the variable. */
1484
0ac8d2ca 1485 htab = elf_i386_hash_table (info);
252b5132
RH		 1486
1487 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1488 copy the initial value out of the dynamic object and into the
0ac8d2ca 1489 runtime process image. */
252b5132
RH		 1490 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1491 {
0ac8d2ca 1492 htab->srelbss->_raw_size += sizeof (Elf32_External_Rel);
252b5132
RH		 1493 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
1494 }
1495
1496 /* We need to figure out the alignment required for this symbol. I
1497 have no idea how ELF linkers handle this. */
1498 power_of_two = bfd_log2 (h->size);
1499 if (power_of_two > 3)
1500 power_of_two = 3;
1501
1502 /* Apply the required alignment. */
0ac8d2ca
AM		 1503 s = htab->sdynbss;
1504 s->_raw_size = BFD_ALIGN (s->_raw_size, (bfd_size_type) (1 << power_of_two));
1505 if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
252b5132 1506 {
0ac8d2ca 1507 if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
252b5132
RH		 1508 return false;
1509 }
1510
1511 /* Define the symbol as being at this point in the section. */
1512 h->root.u.def.section = s;
1513 h->root.u.def.value = s->_raw_size;
1514
1515 /* Increment the section size to make room for the symbol. */
1516 s->_raw_size += h->size;
1517
1518 return true;
1519}
1520
6725bdbf
AM		 1521/* This is the condition under which elf_i386_finish_dynamic_symbol
1522 will be called from elflink.h. If elflink.h doesn't call our
1523 finish_dynamic_symbol routine, we'll need to do something about
1524 initializing any .plt and .got entries in elf_i386_relocate_section. */
1525#define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
1526 ((DYN) \
1527 && ((INFO)->shared \
1528 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
1529 && ((H)->dynindx != -1 \
1530 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1531
1532/* Allocate space in .plt, .got and associated reloc sections for
0c715baa 1533 dynamic relocs. */
6725bdbf
AM		 1534
1535static boolean
0c715baa 1536allocate_dynrelocs (h, inf)
6725bdbf
AM		 1537 struct elf_link_hash_entry *h;
1538 PTR inf;
1539{
1540 struct bfd_link_info *info;
1541 struct elf_i386_link_hash_table *htab;
5a15f56f 1542 struct elf_i386_link_hash_entry *eh;
0c715baa 1543 struct elf_i386_dyn_relocs *p;
6725bdbf 1544
e92d460e 1545 if (h->root.type == bfd_link_hash_indirect)
6725bdbf
AM		 1546 return true;
1547
e92d460e
AM		 1548 if (h->root.type == bfd_link_hash_warning)
1549 /* When warning symbols are created, they **replace** the "real"
1550 entry in the hash table, thus we never get to see the real
1551 symbol in a hash traversal. So look at it now. */
1552 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1553
6725bdbf
AM		 1554 info = (struct bfd_link_info *) inf;
1555 htab = elf_i386_hash_table (info);
1556
ebe50bae 1557 if (htab->elf.dynamic_sections_created
6725bdbf
AM		 1558 && h->plt.refcount > 0)
1559 {
5a15f56f
AM		 1560 /* Make sure this symbol is output as a dynamic symbol.
1561 Undefined weak syms won't yet be marked as dynamic. */
1562 if (h->dynindx == -1
1563 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1564 {
1565 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1566 return false;
1567 }
1568
ced53ee5
AM		 1569 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info, h))
1570 {
0ac8d2ca 1571 asection *s = htab->splt;
6725bdbf 1572
ced53ee5
AM		 1573 /* If this is the first .plt entry, make room for the special
1574 first entry. */
1575 if (s->_raw_size == 0)
1576 s->_raw_size += PLT_ENTRY_SIZE;
6725bdbf 1577
ced53ee5 1578 h->plt.offset = s->_raw_size;
6725bdbf 1579
ced53ee5
AM		 1580 /* If this symbol is not defined in a regular file, and we are
1581 not generating a shared library, then set the symbol to this
1582 location in the .plt. This is required to make function
1583 pointers compare as equal between the normal executable and
1584 the shared library. */
1585 if (! info->shared
1586 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1587 {
1588 h->root.u.def.section = s;
1589 h->root.u.def.value = h->plt.offset;
1590 }
6725bdbf 1591
ced53ee5
AM		 1592 /* Make room for this entry. */
1593 s->_raw_size += PLT_ENTRY_SIZE;
6725bdbf 1594
ced53ee5
AM		 1595 /* We also need to make an entry in the .got.plt section, which
1596 will be placed in the .got section by the linker script. */
0ac8d2ca 1597 htab->sgotplt->_raw_size += 4;
6725bdbf 1598
6725bdbf 1599 /* We also need to make an entry in the .rel.plt section. */
0ac8d2ca 1600 htab->srelplt->_raw_size += sizeof (Elf32_External_Rel);
6725bdbf 1601 }
ced53ee5
AM		 1602 else
1603 {
51b64d56 1604 h->plt.offset = (bfd_vma) -1;
ced53ee5
AM		 1605 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1606 }
6725bdbf
AM		 1607 }
1608 else
1609 {
51b64d56 1610 h->plt.offset = (bfd_vma) -1;
6725bdbf
AM		 1611 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1612 }
1613
37e55690 1614 /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
13ae64f3
JJ		 1615 make it a R_386_TLS_LE_32 requiring no TLS entry. */
1616 if (h->got.refcount > 0
1617 && !info->shared
1618 && h->dynindx == -1
37e55690 1619 && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE))
cedb70c5 1620 h->got.offset = (bfd_vma) -1;
13ae64f3 1621 else if (h->got.refcount > 0)
6725bdbf 1622 {
0ac8d2ca 1623 asection *s;
6725bdbf 1624 boolean dyn;
13ae64f3 1625 int tls_type = elf_i386_hash_entry(h)->tls_type;
6725bdbf 1626
5a15f56f
AM		 1627 /* Make sure this symbol is output as a dynamic symbol.
1628 Undefined weak syms won't yet be marked as dynamic. */
1629 if (h->dynindx == -1
1630 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1631 {
1632 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1633 return false;
1634 }
1635
6725bdbf
AM		 1636 s = htab->sgot;
1637 h->got.offset = s->_raw_size;
1638 s->_raw_size += 4;
13ae64f3 1639 /* R_386_TLS_GD needs 2 consecutive GOT slots. */
37e55690 1640 if (tls_type == GOT_TLS_GD || tls_type == GOT_TLS_IE_BOTH)
13ae64f3 1641 s->_raw_size += 4;
ebe50bae 1642 dyn = htab->elf.dynamic_sections_created;
13ae64f3 1643 /* R_386_TLS_IE_32 needs one dynamic relocation,
37e55690
JJ		 1644 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
1645 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
1646 need two), R_386_TLS_GD needs one if local symbol and two if
1647 global. */
1648 if (tls_type == GOT_TLS_IE_BOTH)
1649 htab->srelgot->_raw_size += 2 * sizeof (Elf32_External_Rel);
1650 else if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
1651 || (tls_type & GOT_TLS_IE))
13ae64f3
JJ		 1652 htab->srelgot->_raw_size += sizeof (Elf32_External_Rel);
1653 else if (tls_type == GOT_TLS_GD)
1654 htab->srelgot->_raw_size += 2 * sizeof (Elf32_External_Rel);
1655 else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h))
6725bdbf
AM		 1656 htab->srelgot->_raw_size += sizeof (Elf32_External_Rel);
1657 }
1658 else
51b64d56 1659 h->got.offset = (bfd_vma) -1;
6725bdbf 1660
5a15f56f
AM		 1661 eh = (struct elf_i386_link_hash_entry *) h;
1662 if (eh->dyn_relocs == NULL)
1663 return true;
1664
0c715baa
AM		 1665 /* In the shared -Bsymbolic case, discard space allocated for
1666 dynamic pc-relative relocs against symbols which turn out to be
1667 defined in regular objects. For the normal shared case, discard
0ac8d2ca
AM		 1668 space for pc-relative relocs that have become local due to symbol
1669 visibility changes. */
0c715baa
AM		 1670
1671 if (info->shared)
5a15f56f 1672 {
0c715baa
AM		 1673 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
1674 && ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
1675 || info->symbolic))
5a15f56f 1676 {
0c715baa
AM		 1677 struct elf_i386_dyn_relocs **pp;
1678
1679 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1680 {
1681 p->count -= p->pc_count;
1682 p->pc_count = 0;
1683 if (p->count == 0)
1684 *pp = p->next;
1685 else
1686 pp = &p->next;
1687 }
5a15f56f 1688 }
0c715baa
AM		 1689 }
1690 else
1691 {
1692 /* For the non-shared case, discard space for relocs against
1693 symbols which turn out to need copy relocs or are not
1694 dynamic. */
1695
1696 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
1697 && (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1698 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
ebe50bae 1699 || (htab->elf.dynamic_sections_created
0c715baa
AM		 1700 && (h->root.type == bfd_link_hash_undefweak
1701 || h->root.type == bfd_link_hash_undefined))))
1702 {
1703 /* Make sure this symbol is output as a dynamic symbol.
1704 Undefined weak syms won't yet be marked as dynamic. */
1705 if (h->dynindx == -1
1706 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1707 {
1708 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1709 return false;
1710 }
5a15f56f 1711
0c715baa
AM		 1712 /* If that succeeded, we know we'll be keeping all the
1713 relocs. */
1714 if (h->dynindx != -1)
1715 goto keep;
1716 }
1717
1718 eh->dyn_relocs = NULL;
1719
ec338859 1720 keep: ;
5a15f56f
AM		 1721 }
1722
0c715baa
AM		 1723 /* Finally, allocate space. */
1724 for (p = eh->dyn_relocs; p != NULL; p = p->next)
12d0ee4a 1725 {
0c715baa
AM		 1726 asection *sreloc = elf_section_data (p->sec)->sreloc;
1727 sreloc->_raw_size += p->count * sizeof (Elf32_External_Rel);
12d0ee4a
AM		 1728 }
1729
6725bdbf
AM		 1730 return true;
1731}
1732
0c715baa
AM		 1733/* Find any dynamic relocs that apply to read-only sections. */
1734
1735static boolean
1736readonly_dynrelocs (h, inf)
1737 struct elf_link_hash_entry *h;
1738 PTR inf;
1739{
1740 struct elf_i386_link_hash_entry *eh;
1741 struct elf_i386_dyn_relocs *p;
1742
e92d460e
AM		 1743 if (h->root.type == bfd_link_hash_warning)
1744 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1745
0c715baa
AM		 1746 eh = (struct elf_i386_link_hash_entry *) h;
1747 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1748 {
1749 asection *s = p->sec->output_section;
1750
1751 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1752 {
1753 struct bfd_link_info *info = (struct bfd_link_info *) inf;
1754
1755 info->flags |= DF_TEXTREL;
1756
1757 /* Not an error, just cut short the traversal. */
1758 return false;
1759 }
1760 }
1761 return true;
1762}
1763
252b5132
RH		 1764/* Set the sizes of the dynamic sections. */
1765
1766static boolean
1767elf_i386_size_dynamic_sections (output_bfd, info)
db6751f2 1768 bfd *output_bfd ATTRIBUTE_UNUSED;
252b5132
RH		 1769 struct bfd_link_info *info;
1770{
6725bdbf 1771 struct elf_i386_link_hash_table *htab;
252b5132
RH		 1772 bfd *dynobj;
1773 asection *s;
252b5132 1774 boolean relocs;
0c715baa 1775 bfd *ibfd;
252b5132 1776
6725bdbf 1777 htab = elf_i386_hash_table (info);
ebe50bae 1778 dynobj = htab->elf.dynobj;
ffb2e45b
AM		 1779 if (dynobj == NULL)
1780 abort ();
252b5132 1781
ebe50bae 1782 if (htab->elf.dynamic_sections_created)
252b5132
RH		 1783 {
1784 /* Set the contents of the .interp section to the interpreter. */
1785 if (! info->shared)
1786 {
1787 s = bfd_get_section_by_name (dynobj, ".interp");
ffb2e45b
AM		 1788 if (s == NULL)
1789 abort ();
252b5132
RH		 1790 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
1791 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1792 }
161d71a6 1793 }
6725bdbf 1794
0c715baa
AM		 1795 /* Set up .got offsets for local syms, and space for local dynamic
1796 relocs. */
1797 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
161d71a6
L		 1798 {
1799 bfd_signed_vma *local_got;
1800 bfd_signed_vma *end_local_got;
13ae64f3 1801 char *local_tls_type;
161d71a6
L		 1802 bfd_size_type locsymcount;
1803 Elf_Internal_Shdr *symtab_hdr;
1804 asection *srel;
6725bdbf 1805
0c715baa 1806 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
161d71a6 1807 continue;
6725bdbf 1808
0c715baa
AM		 1809 for (s = ibfd->sections; s != NULL; s = s->next)
1810 {
ec338859 1811 struct elf_i386_dyn_relocs *p;
0c715baa 1812
ec338859
AM		 1813 for (p = *((struct elf_i386_dyn_relocs **)
1814 &elf_section_data (s)->local_dynrel);
1815 p != NULL;
1816 p = p->next)
0c715baa 1817 {
ec338859
AM		 1818 if (!bfd_is_abs_section (p->sec)
1819 && bfd_is_abs_section (p->sec->output_section))
1820 {
1821 /* Input section has been discarded, either because
1822 it is a copy of a linkonce section or due to
1823 linker script /DISCARD/, so we'll be discarding
1824 the relocs too. */
1825 }
248866a8 1826 else if (p->count != 0)
ec338859
AM		 1827 {
1828 srel = elf_section_data (p->sec)->sreloc;
1829 srel->_raw_size += p->count * sizeof (Elf32_External_Rel);
248866a8
AM		 1830 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
1831 info->flags |= DF_TEXTREL;
ec338859 1832 }
0c715baa
AM		 1833 }
1834 }
1835
1836 local_got = elf_local_got_refcounts (ibfd);
161d71a6
L		 1837 if (!local_got)
1838 continue;
6725bdbf 1839
0c715baa 1840 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
161d71a6
L		 1841 locsymcount = symtab_hdr->sh_info;
1842 end_local_got = local_got + locsymcount;
13ae64f3 1843 local_tls_type = elf_i386_local_got_tls_type (ibfd);
161d71a6
L		 1844 s = htab->sgot;
1845 srel = htab->srelgot;
13ae64f3 1846 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
161d71a6
L		 1847 {
1848 if (*local_got > 0)
6725bdbf 1849 {
161d71a6
L		 1850 *local_got = s->_raw_size;
1851 s->_raw_size += 4;
37e55690
JJ		 1852 if (*local_tls_type == GOT_TLS_GD
1853 || *local_tls_type == GOT_TLS_IE_BOTH)
13ae64f3
JJ		 1854 s->_raw_size += 4;
1855 if (info->shared
1856 || *local_tls_type == GOT_TLS_GD
37e55690
JJ		 1857 || (*local_tls_type & GOT_TLS_IE))
1858 {
1859 if (*local_tls_type == GOT_TLS_IE_BOTH)
1860 srel->_raw_size += 2 * sizeof (Elf32_External_Rel);
1861 else
1862 srel->_raw_size += sizeof (Elf32_External_Rel);
1863 }
6725bdbf 1864 }
161d71a6
L		 1865 else
1866 *local_got = (bfd_vma) -1;
6725bdbf 1867 }
252b5132 1868 }
6725bdbf 1869
13ae64f3
JJ		 1870 if (htab->tls_ldm_got.refcount > 0)
1871 {
1872 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
1873 relocs. */
1874 htab->tls_ldm_got.offset = htab->sgot->_raw_size;
1875 htab->sgot->_raw_size += 8;
1876 htab->srelgot->_raw_size += sizeof (Elf32_External_Rel);
1877 }
1878 else
1879 htab->tls_ldm_got.offset = -1;
1880
0c715baa
AM		 1881 /* Allocate global sym .plt and .got entries, and space for global
1882 sym dynamic relocs. */
ebe50bae 1883 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
252b5132 1884
5a15f56f
AM		 1885 /* We now have determined the sizes of the various dynamic sections.
1886 Allocate memory for them. */
252b5132 1887 relocs = false;
252b5132
RH		 1888 for (s = dynobj->sections; s != NULL; s = s->next)
1889 {
252b5132
RH		 1890 if ((s->flags & SEC_LINKER_CREATED) == 0)
1891 continue;
1892
6725bdbf
AM		 1893 if (s == htab->splt
1894 || s == htab->sgot
1895 || s == htab->sgotplt)
252b5132 1896 {
6725bdbf
AM		 1897 /* Strip this section if we don't need it; see the
1898 comment below. */
252b5132 1899 }
6725bdbf 1900 else if (strncmp (bfd_get_section_name (dynobj, s), ".rel", 4) == 0)
252b5132 1901 {
0ac8d2ca
AM		 1902 if (s->_raw_size != 0 && s != htab->srelplt)
1903 relocs = true;
252b5132 1904
0ac8d2ca
AM		 1905 /* We use the reloc_count field as a counter if we need
1906 to copy relocs into the output file. */
1907 s->reloc_count = 0;
252b5132 1908 }
6725bdbf 1909 else
252b5132
RH		 1910 {
1911 /* It's not one of our sections, so don't allocate space. */
1912 continue;
1913 }
1914
6725bdbf 1915 if (s->_raw_size == 0)
252b5132 1916 {
0ac8d2ca
AM		 1917 /* If we don't need this section, strip it from the
1918 output file. This is mostly to handle .rel.bss and
1919 .rel.plt. We must create both sections in
1920 create_dynamic_sections, because they must be created
1921 before the linker maps input sections to output
1922 sections. The linker does that before
1923 adjust_dynamic_symbol is called, and it is that
1924 function which decides whether anything needs to go
1925 into these sections. */
1926
7f8d5fc9 1927 _bfd_strip_section_from_output (info, s);
252b5132
RH		 1928 continue;
1929 }
1930
f69da49f
AM		 1931 /* Allocate memory for the section contents. We use bfd_zalloc
1932 here in case unused entries are not reclaimed before the
1933 section's contents are written out. This should not happen,
1934 but this way if it does, we get a R_386_NONE reloc instead
1935 of garbage. */
7a9af8c4 1936 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
6725bdbf 1937 if (s->contents == NULL)
252b5132
RH		 1938 return false;
1939 }
1940
ebe50bae 1941 if (htab->elf.dynamic_sections_created)
252b5132
RH		 1942 {
1943 /* Add some entries to the .dynamic section. We fill in the
1944 values later, in elf_i386_finish_dynamic_sections, but we
1945 must add the entries now so that we get the correct size for
1946 the .dynamic section. The DT_DEBUG entry is filled in by the
1947 dynamic linker and used by the debugger. */
dc810e39
AM		 1948#define add_dynamic_entry(TAG, VAL) \
1949 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1950
252b5132
RH		 1951 if (! info->shared)
1952 {
dc810e39 1953 if (!add_dynamic_entry (DT_DEBUG, 0))
252b5132
RH		 1954 return false;
1955 }
1956
6725bdbf 1957 if (htab->splt->_raw_size != 0)
252b5132 1958 {
dc810e39
AM		 1959 if (!add_dynamic_entry (DT_PLTGOT, 0)
1960 || !add_dynamic_entry (DT_PLTRELSZ, 0)
1961 || !add_dynamic_entry (DT_PLTREL, DT_REL)
1962 || !add_dynamic_entry (DT_JMPREL, 0))
252b5132
RH		 1963 return false;
1964 }
1965
1966 if (relocs)
1967 {
dc810e39
AM		 1968 if (!add_dynamic_entry (DT_REL, 0)
1969 || !add_dynamic_entry (DT_RELSZ, 0)
1970 || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
252b5132 1971 return false;
252b5132 1972
0c715baa
AM		 1973 /* If any dynamic relocs apply to a read-only section,
1974 then we need a DT_TEXTREL entry. */
248866a8
AM		 1975 if ((info->flags & DF_TEXTREL) == 0)
1976 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
1977 (PTR) info);
0c715baa
AM		 1978
1979 if ((info->flags & DF_TEXTREL) != 0)
1980 {
1981 if (!add_dynamic_entry (DT_TEXTREL, 0))
1982 return false;
1983 }
252b5132
RH		 1984 }
1985 }
dc810e39 1986#undef add_dynamic_entry
252b5132
RH		 1987
1988 return true;
1989}
1990
38701953
AM		 1991/* Set the correct type for an x86 ELF section. We do this by the
1992 section name, which is a hack, but ought to work. */
1993
1994static boolean
1995elf_i386_fake_sections (abfd, hdr, sec)
1996 bfd *abfd ATTRIBUTE_UNUSED;
1997 Elf32_Internal_Shdr *hdr;
1998 asection *sec;
1999{
2000 register const char *name;
2001
2002 name = bfd_get_section_name (abfd, sec);
2003
2004 /* This is an ugly, but unfortunately necessary hack that is
2005 needed when producing EFI binaries on x86. It tells
2006 elf.c:elf_fake_sections() not to consider ".reloc" as a section
2007 containing ELF relocation info. We need this hack in order to
2008 be able to generate ELF binaries that can be translated into
2009 EFI applications (which are essentially COFF objects). Those
2010 files contain a COFF ".reloc" section inside an ELFNN object,
2011 which would normally cause BFD to segfault because it would
2012 attempt to interpret this section as containing relocation
2013 entries for section "oc". With this hack enabled, ".reloc"
2014 will be treated as a normal data section, which will avoid the
2015 segfault. However, you won't be able to create an ELFNN binary
2016 with a section named "oc" that needs relocations, but that's
2017 the kind of ugly side-effects you get when detecting section
2018 types based on their names... In practice, this limitation is
2019 unlikely to bite. */
2020 if (strcmp (name, ".reloc") == 0)
2021 hdr->sh_type = SHT_PROGBITS;
2022
2023 return true;
2024}
2025
13ae64f3
JJ		 2026/* Return the base VMA address which should be subtracted from real addresses
2027 when resolving @dtpoff relocation.
2028 This is PT_TLS segment p_vaddr. */
2029
2030static bfd_vma
2031dtpoff_base (info)
2032 struct bfd_link_info *info;
2033{
6a30718d
JJ		 2034 /* If tls_segment is NULL, we should have signalled an error already. */
2035 if (elf_hash_table (info)->tls_segment == NULL)
2036 return 0;
13ae64f3
JJ		 2037 return elf_hash_table (info)->tls_segment->start;
2038}
2039
2040/* Return the relocation value for @tpoff relocation
2041 if STT_TLS virtual address is ADDRESS. */
2042
2043static bfd_vma
2044tpoff (info, address)
2045 struct bfd_link_info *info;
2046 bfd_vma address;
2047{
2048 struct elf_link_tls_segment *tls_segment
2049 = elf_hash_table (info)->tls_segment;
2050
6a30718d
JJ		 2051 /* If tls_segment is NULL, we should have signalled an error already. */
2052 if (tls_segment == NULL)
2053 return 0;
13ae64f3
JJ		 2054 return (align_power (tls_segment->size, tls_segment->align)
2055 + tls_segment->start - address);
2056}
2057
252b5132
RH		 2058/* Relocate an i386 ELF section. */
2059
2060static boolean
2061elf_i386_relocate_section (output_bfd, info, input_bfd, input_section,
2062 contents, relocs, local_syms, local_sections)
2063 bfd *output_bfd;
2064 struct bfd_link_info *info;
2065 bfd *input_bfd;
2066 asection *input_section;
2067 bfd_byte *contents;
2068 Elf_Internal_Rela *relocs;
2069 Elf_Internal_Sym *local_syms;
2070 asection **local_sections;
2071{
6725bdbf 2072 struct elf_i386_link_hash_table *htab;
252b5132
RH		 2073 Elf_Internal_Shdr *symtab_hdr;
2074 struct elf_link_hash_entry **sym_hashes;
2075 bfd_vma *local_got_offsets;
252b5132
RH		 2076 Elf_Internal_Rela *rel;
2077 Elf_Internal_Rela *relend;
2078
6725bdbf 2079 htab = elf_i386_hash_table (info);
252b5132
RH		 2080 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2081 sym_hashes = elf_sym_hashes (input_bfd);
2082 local_got_offsets = elf_local_got_offsets (input_bfd);
2083
252b5132
RH		 2084 rel = relocs;
2085 relend = relocs + input_section->reloc_count;
2086 for (; rel < relend; rel++)
2087 {
13ae64f3 2088 unsigned int r_type;
252b5132
RH		 2089 reloc_howto_type *howto;
2090 unsigned long r_symndx;
2091 struct elf_link_hash_entry *h;
2092 Elf_Internal_Sym *sym;
2093 asection *sec;
ffb2e45b 2094 bfd_vma off;
252b5132 2095 bfd_vma relocation;
83be169b 2096 boolean unresolved_reloc;
252b5132 2097 bfd_reloc_status_type r;
1b452ec6 2098 unsigned int indx;
13ae64f3 2099 int tls_type;
252b5132
RH		 2100
2101 r_type = ELF32_R_TYPE (rel->r_info);
dc47f327
AM		 2102 if (r_type == (int) R_386_GNU_VTINHERIT
2103 || r_type == (int) R_386_GNU_VTENTRY)
252b5132 2104 continue;
dc47f327 2105
1b452ec6 2106 if ((indx = (unsigned) r_type) >= R_386_standard
13ae64f3
JJ		 2107 && ((indx = r_type - R_386_ext_offset) - R_386_standard
2108 >= R_386_ext - R_386_standard)
2109 && ((indx = r_type - R_386_tls_offset) - R_386_ext
2110 >= R_386_tls - R_386_ext))
252b5132
RH		 2111 {
2112 bfd_set_error (bfd_error_bad_value);
2113 return false;
2114 }
1b452ec6 2115 howto = elf_howto_table + indx;
252b5132
RH		 2116
2117 r_symndx = ELF32_R_SYM (rel->r_info);
2118
2119 if (info->relocateable)
2120 {
4a335f3d 2121 bfd_vma val;
4a335f3d
AM		 2122 bfd_byte *where;
2123
0ac8d2ca 2124 /* This is a relocatable link. We don't have to change
252b5132
RH		 2125 anything, unless the reloc is against a section symbol,
2126 in which case we have to adjust according to where the
2127 section symbol winds up in the output section. */
4a335f3d
AM		 2128 if (r_symndx >= symtab_hdr->sh_info)
2129 continue;
2130
2131 sym = local_syms + r_symndx;
2132 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2133 continue;
2134
2135 sec = local_sections[r_symndx];
2136 val = sec->output_offset;
2137 if (val == 0)
2138 continue;
2139
2140 where = contents + rel->r_offset;
2141 switch (howto->size)
252b5132 2142 {
16a10388 2143 /* FIXME: overflow checks. */
4a335f3d 2144 case 0:
16a10388 2145 val += bfd_get_8 (input_bfd, where);
4a335f3d 2146 bfd_put_8 (input_bfd, val, where);
4a335f3d
AM		 2147 break;
2148 case 1:
16a10388 2149 val += bfd_get_16 (input_bfd, where);
4a335f3d 2150 bfd_put_16 (input_bfd, val, where);
4a335f3d
AM		 2151 break;
2152 case 2:
2153 val += bfd_get_32 (input_bfd, where);
2154 bfd_put_32 (input_bfd, val, where);
2155 break;
2156 default:
2157 abort ();
252b5132 2158 }
252b5132
RH		 2159 continue;
2160 }
2161
2162 /* This is a final link. */
2163 h = NULL;
2164 sym = NULL;
2165 sec = NULL;
83be169b 2166 unresolved_reloc = false;
252b5132
RH		 2167 if (r_symndx < symtab_hdr->sh_info)
2168 {
2169 sym = local_syms + r_symndx;
2170 sec = local_sections[r_symndx];
2171 relocation = (sec->output_section->vma
2172 + sec->output_offset
2173 + sym->st_value);
f8df10f4
JJ		 2174 if ((sec->flags & SEC_MERGE)
2175 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2176 {
2177 asection *msec;
2178 bfd_vma addend;
4a335f3d 2179 bfd_byte *where = contents + rel->r_offset;
f8df10f4 2180
4a335f3d 2181 switch (howto->size)
f8df10f4 2182 {
4a335f3d
AM		 2183 case 0:
2184 addend = bfd_get_8 (input_bfd, where);
2185 if (howto->pc_relative)
2186 {
2187 addend = (addend ^ 0x80) - 0x80;
2188 addend += 1;
2189 }
2190 break;
2191 case 1:
2192 addend = bfd_get_16 (input_bfd, where);
2193 if (howto->pc_relative)
2194 {
2195 addend = (addend ^ 0x8000) - 0x8000;
2196 addend += 2;
2197 }
2198 break;
2199 case 2:
2200 addend = bfd_get_32 (input_bfd, where);
2201 if (howto->pc_relative)
2202 {
2203 addend = (addend ^ 0x80000000) - 0x80000000;
2204 addend += 4;
2205 }
2206 break;
2207 default:
2208 abort ();
f8df10f4
JJ		 2209 }
2210
f8df10f4 2211 msec = sec;
4a335f3d
AM		 2212 addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend);
2213 addend -= relocation;
f8df10f4 2214 addend += msec->output_section->vma + msec->output_offset;
4a335f3d
AM		 2215
2216 switch (howto->size)
2217 {
2218 case 0:
16a10388 2219 /* FIXME: overflow checks. */
4a335f3d
AM		 2220 if (howto->pc_relative)
2221 addend -= 1;
2222 bfd_put_8 (input_bfd, addend, where);
4a335f3d
AM		 2223 break;
2224 case 1:
2225 if (howto->pc_relative)
2226 addend -= 2;
2227 bfd_put_16 (input_bfd, addend, where);
4a335f3d
AM		 2228 break;
2229 case 2:
2230 if (howto->pc_relative)
2231 addend -= 4;
2232 bfd_put_32 (input_bfd, addend, where);
2233 break;
2234 }
f8df10f4 2235 }
252b5132
RH		 2236 }
2237 else
2238 {
2239 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2240 while (h->root.type == bfd_link_hash_indirect
2241 || h->root.type == bfd_link_hash_warning)
2242 h = (struct elf_link_hash_entry *) h->root.u.i.link;
ffb2e45b 2243
6725bdbf 2244 relocation = 0;
252b5132
RH		 2245 if (h->root.type == bfd_link_hash_defined
2246 || h->root.type == bfd_link_hash_defweak)
2247 {
2248 sec = h->root.u.def.section;
83be169b
AM		 2249 if (sec->output_section == NULL)
2250 /* Set a flag that will be cleared later if we find a
2251 relocation value for this symbol. output_section
2252 is typically NULL for symbols satisfied by a shared
2253 library. */
2254 unresolved_reloc = true;
252b5132
RH		 2255 else
2256 relocation = (h->root.u.def.value
2257 + sec->output_section->vma
2258 + sec->output_offset);
2259 }
2260 else if (h->root.type == bfd_link_hash_undefweak)
6725bdbf 2261 ;
671bae9c
NC		 2262 else if (info->shared
2263 && (!info->symbolic || info->allow_shlib_undefined)
3a27a730
L		 2264 && !info->no_undefined
2265 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
6725bdbf 2266 ;
252b5132
RH		 2267 else
2268 {
2269 if (! ((*info->callbacks->undefined_symbol)
2270 (info, h->root.root.string, input_bfd,
5cc7c785 2271 input_section, rel->r_offset,
3a27a730
L		 2272 (!info->shared || info->no_undefined
2273 || ELF_ST_VISIBILITY (h->other)))))
252b5132 2274 return false;
252b5132
RH		 2275 }
2276 }
2277
2278 switch (r_type)
2279 {
2280 case R_386_GOT32:
2281 /* Relocation is to the entry for this symbol in the global
2282 offset table. */
ffb2e45b
AM		 2283 if (htab->sgot == NULL)
2284 abort ();
252b5132
RH		 2285
2286 if (h != NULL)
2287 {
6725bdbf 2288 boolean dyn;
252b5132
RH		 2289
2290 off = h->got.offset;
ebe50bae 2291 dyn = htab->elf.dynamic_sections_created;
6725bdbf 2292 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h)
252b5132 2293 || (info->shared
6725bdbf
AM		 2294 && (info->symbolic
2295 || h->dynindx == -1
2296 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
252b5132
RH		 2297 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
2298 {
2299 /* This is actually a static link, or it is a
2300 -Bsymbolic link and the symbol is defined
2301 locally, or the symbol was forced to be local
2302 because of a version file. We must initialize
2303 this entry in the global offset table. Since the
2304 offset must always be a multiple of 4, we use the
2305 least significant bit to record whether we have
2306 initialized it already.
2307
2308 When doing a dynamic link, we create a .rel.got
2309 relocation entry to initialize the value. This
2310 is done in the finish_dynamic_symbol routine. */
2311 if ((off & 1) != 0)
2312 off &= ~1;
2313 else
2314 {
2315 bfd_put_32 (output_bfd, relocation,
6725bdbf 2316 htab->sgot->contents + off);
252b5132
RH		 2317 h->got.offset |= 1;
2318 }
2319 }
8c694914
AM		 2320 else
2321 unresolved_reloc = false;
252b5132
RH		 2322 }
2323 else
2324 {
ffb2e45b
AM		 2325 if (local_got_offsets == NULL)
2326 abort ();
252b5132
RH		 2327
2328 off = local_got_offsets[r_symndx];
2329
2330 /* The offset must always be a multiple of 4. We use
83be169b
AM		 2331 the least significant bit to record whether we have
2332 already generated the necessary reloc. */
252b5132
RH		 2333 if ((off & 1) != 0)
2334 off &= ~1;
2335 else
2336 {
6725bdbf
AM		 2337 bfd_put_32 (output_bfd, relocation,
2338 htab->sgot->contents + off);
252b5132
RH		 2339
2340 if (info->shared)
2341 {
2342 asection *srelgot;
2343 Elf_Internal_Rel outrel;
0ac8d2ca 2344 Elf32_External_Rel *loc;
252b5132 2345
6725bdbf 2346 srelgot = htab->srelgot;
ffb2e45b
AM		 2347 if (srelgot == NULL)
2348 abort ();
252b5132 2349
6725bdbf
AM		 2350 outrel.r_offset = (htab->sgot->output_section->vma
2351 + htab->sgot->output_offset
252b5132
RH		 2352 + off);
2353 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
0ac8d2ca
AM		 2354 loc = (Elf32_External_Rel *) srelgot->contents;
2355 loc += srelgot->reloc_count++;
2356 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
252b5132
RH		 2357 }
2358
2359 local_got_offsets[r_symndx] |= 1;
2360 }
252b5132
RH		 2361 }
2362
ffb2e45b
AM		 2363 if (off >= (bfd_vma) -2)
2364 abort ();
2365
2366 relocation = htab->sgot->output_offset + off;
252b5132
RH		 2367 break;
2368
2369 case R_386_GOTOFF:
2370 /* Relocation is relative to the start of the global offset
2371 table. */
2372
252b5132
RH		 2373 /* Note that sgot->output_offset is not involved in this
2374 calculation. We always want the start of .got. If we
2375 defined _GLOBAL_OFFSET_TABLE in a different way, as is
2376 permitted by the ABI, we might have to change this
2377 calculation. */
6725bdbf 2378 relocation -= htab->sgot->output_section->vma;
252b5132
RH		 2379 break;
2380
2381 case R_386_GOTPC:
2382 /* Use global offset table as symbol value. */
6725bdbf 2383 relocation = htab->sgot->output_section->vma;
83be169b 2384 unresolved_reloc = false;
252b5132
RH		 2385 break;
2386
2387 case R_386_PLT32:
2388 /* Relocation is to the entry for this symbol in the
2389 procedure linkage table. */
2390
dd5724d5 2391 /* Resolve a PLT32 reloc against a local symbol directly,
83be169b 2392 without using the procedure linkage table. */
252b5132
RH		 2393 if (h == NULL)
2394 break;
2395
dd5724d5 2396 if (h->plt.offset == (bfd_vma) -1
6725bdbf 2397 || htab->splt == NULL)
252b5132
RH		 2398 {
2399 /* We didn't make a PLT entry for this symbol. This
83be169b
AM		 2400 happens when statically linking PIC code, or when
2401 using -Bsymbolic. */
252b5132
RH		 2402 break;
2403 }
2404
6725bdbf
AM		 2405 relocation = (htab->splt->output_section->vma
2406 + htab->splt->output_offset
252b5132 2407 + h->plt.offset);
83be169b 2408 unresolved_reloc = false;
252b5132
RH		 2409 break;
2410
2411 case R_386_32:
2412 case R_386_PC32:
ec338859
AM		 2413 /* r_symndx will be zero only for relocs against symbols
2414 from removed linkonce sections, or sections discarded by
2415 a linker script. */
2416 if (r_symndx == 0
2417 || (input_section->flags & SEC_ALLOC) == 0)
2418 break;
2419
12d0ee4a 2420 if ((info->shared
12d0ee4a
AM		 2421 && (r_type != R_386_PC32
2422 || (h != NULL
2423 && h->dynindx != -1
2424 && (! info->symbolic
2425 || (h->elf_link_hash_flags
2426 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
2427 || (!info->shared
12d0ee4a
AM		 2428 && h != NULL
2429 && h->dynindx != -1
2430 && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
56882138
AM		 2431 && (((h->elf_link_hash_flags
2432 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2433 && (h->elf_link_hash_flags
2434 & ELF_LINK_HASH_DEF_REGULAR) == 0)
28d0b90e
AM		 2435 || h->root.type == bfd_link_hash_undefweak
2436 || h->root.type == bfd_link_hash_undefined)))
252b5132
RH		 2437 {
2438 Elf_Internal_Rel outrel;
2439 boolean skip, relocate;
0c715baa
AM		 2440 asection *sreloc;
2441 Elf32_External_Rel *loc;
252b5132
RH		 2442
2443 /* When generating a shared object, these relocations
2444 are copied into the output file to be resolved at run
2445 time. */
2446
252b5132 2447 skip = false;
0bb2d96a 2448 relocate = false;
252b5132 2449
c629eae0
JJ		 2450 outrel.r_offset =
2451 _bfd_elf_section_offset (output_bfd, info, input_section,
2452 rel->r_offset);
2453 if (outrel.r_offset == (bfd_vma) -1)
2454 skip = true;
0bb2d96a
JJ		 2455 else if (outrel.r_offset == (bfd_vma) -2)
2456 skip = true, relocate = true;
252b5132
RH		 2457 outrel.r_offset += (input_section->output_section->vma
2458 + input_section->output_offset);
2459
2460 if (skip)
0bb2d96a 2461 memset (&outrel, 0, sizeof outrel);
5a15f56f
AM		 2462 else if (h != NULL
2463 && h->dynindx != -1
2464 && (r_type == R_386_PC32
2465 || !info->shared
2466 || !info->symbolic
2467 || (h->elf_link_hash_flags
2468 & ELF_LINK_HASH_DEF_REGULAR) == 0))
0bb2d96a 2469 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
252b5132
RH		 2470 else
2471 {
5a15f56f
AM		 2472 /* This symbol is local, or marked to become local. */
2473 relocate = true;
2474 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
252b5132
RH		 2475 }
2476
0c715baa
AM		 2477 sreloc = elf_section_data (input_section)->sreloc;
2478 if (sreloc == NULL)
2479 abort ();
2480
0ac8d2ca
AM		 2481 loc = (Elf32_External_Rel *) sreloc->contents;
2482 loc += sreloc->reloc_count++;
0c715baa 2483 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
252b5132
RH		 2484
2485 /* If this reloc is against an external symbol, we do
2486 not want to fiddle with the addend. Otherwise, we
2487 need to include the symbol value so that it becomes
2488 an addend for the dynamic reloc. */
2489 if (! relocate)
2490 continue;
2491 }
252b5132
RH		 2492 break;
2493
37e55690
JJ		 2494 case R_386_TLS_IE:
2495 if (info->shared)
2496 {
2497 Elf_Internal_Rel outrel;
2498 asection *sreloc;
2499 Elf32_External_Rel *loc;
2500
2501 outrel.r_offset = rel->r_offset
2502 + input_section->output_section->vma
2503 + input_section->output_offset;
2504 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2505 sreloc = elf_section_data (input_section)->sreloc;
2506 if (sreloc == NULL)
2507 abort ();
2508 loc = (Elf32_External_Rel *) sreloc->contents;
2509 loc += sreloc->reloc_count++;
2510 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2511 }
2512 /* Fall through */
2513
13ae64f3
JJ		 2514 case R_386_TLS_GD:
2515 case R_386_TLS_IE_32:
37e55690 2516 case R_386_TLS_GOTIE:
13ae64f3
JJ		 2517 r_type = elf_i386_tls_transition (info, r_type, h == NULL);
2518 tls_type = GOT_UNKNOWN;
2519 if (h == NULL && local_got_offsets)
2520 tls_type = elf_i386_local_got_tls_type (input_bfd) [r_symndx];
2521 else if (h != NULL)
2522 {
2523 tls_type = elf_i386_hash_entry(h)->tls_type;
37e55690 2524 if (!info->shared && h->dynindx == -1 && (tls_type & GOT_TLS_IE))
13ae64f3
JJ		 2525 r_type = R_386_TLS_LE_32;
2526 }
37e55690
JJ		 2527 if (tls_type == GOT_TLS_IE)
2528 tls_type = GOT_TLS_IE_NEG;
2529 if (r_type == R_386_TLS_GD)
2530 {
2531 if (tls_type == GOT_TLS_IE_POS)
2532 r_type = R_386_TLS_GOTIE;
2533 else if (tls_type & GOT_TLS_IE)
2534 r_type = R_386_TLS_IE_32;
2535 }
13ae64f3
JJ		 2536
2537 if (r_type == R_386_TLS_LE_32)
2538 {
82e51918 2539 BFD_ASSERT (! unresolved_reloc);
13ae64f3
JJ		 2540 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
2541 {
2542 unsigned int val, type;
2543 bfd_vma roff;
2544
2545 /* GD->LE transition. */
2546 BFD_ASSERT (rel->r_offset >= 2);
2547 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2548 BFD_ASSERT (type == 0x8d || type == 0x04);
2549 BFD_ASSERT (rel->r_offset + 9 <= input_section->_raw_size);
2550 BFD_ASSERT (bfd_get_8 (input_bfd,
2551 contents + rel->r_offset + 4)
2552 == 0xe8);
2553 BFD_ASSERT (rel + 1 < relend);
2554 BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2555 roff = rel->r_offset + 5;
2556 val = bfd_get_8 (input_bfd,
2557 contents + rel->r_offset - 1);
2558 if (type == 0x04)
2559 {
2560 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2561 Change it into:
2562 movl %gs:0, %eax; subl $foo@tpoff, %eax
2563 (6 byte form of subl). */
2564 BFD_ASSERT (rel->r_offset >= 3);
2565 BFD_ASSERT (bfd_get_8 (input_bfd,
2566 contents + rel->r_offset - 3)
2567 == 0x8d);
2568 BFD_ASSERT ((val & 0xc7) == 0x05 && val != (4 << 3));
2569 memcpy (contents + rel->r_offset - 3,
2570 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2571 }
2572 else
2573 {
2574 BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2575 if (rel->r_offset + 10 <= input_section->_raw_size
2576 && bfd_get_8 (input_bfd,
2577 contents + rel->r_offset + 9) == 0x90)
2578 {
2579 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2580 Change it into:
2581 movl %gs:0, %eax; subl $foo@tpoff, %eax
2582 (6 byte form of subl). */
2583 memcpy (contents + rel->r_offset - 2,
2584 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2585 roff = rel->r_offset + 6;
2586 }
2587 else
2588 {
2589 /* leal foo(%reg), %eax; call ___tls_get_addr
2590 Change it into:
2591 movl %gs:0, %eax; subl $foo@tpoff, %eax
2592 (5 byte form of subl). */
2593 memcpy (contents + rel->r_offset - 2,
2594 "\x65\xa1\0\0\0\0\x2d\0\0\0", 11);
2595 }
2596 }
2597 bfd_put_32 (output_bfd, tpoff (info, relocation),
2598 contents + roff);
2599 /* Skip R_386_PLT32. */
2600 rel++;
2601 continue;
2602 }
37e55690 2603 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_IE)
13ae64f3
JJ		 2604 {
2605 unsigned int val, type;
2606
2607 /* IE->LE transition:
37e55690
JJ		 2608 Originally it can be one of:
2609 movl foo, %eax
2610 movl foo, %reg
2611 addl foo, %reg
2612 We change it into:
2613 movl $foo, %eax
2614 movl $foo, %reg
2615 addl $foo, %reg. */
2616 BFD_ASSERT (rel->r_offset >= 1);
2617 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2618 BFD_ASSERT (rel->r_offset + 4 <= input_section->_raw_size);
2619 if (val != 0xa1)
2620 {
2621 BFD_ASSERT (rel->r_offset >= 2);
2622 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2623 }
2624 if (val == 0xa1)
2625 {
2626 /* movl foo, %eax. */
2627 bfd_put_8 (output_bfd, 0xb8, contents + rel->r_offset - 2);
2628 }
2629 else if (type == 0x8b)
2630 {
2631 /* movl */
2632 BFD_ASSERT ((val & 0xc7) == 0x05);
2633 bfd_put_8 (output_bfd, 0xc7,
2634 contents + rel->r_offset - 2);
2635 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
2636 contents + rel->r_offset - 1);
2637 }
2638 else if (type == 0x03)
2639 {
2640 /* addl */
2641 BFD_ASSERT ((val & 0xc7) == 0x05);
2642 bfd_put_8 (output_bfd, 0x81,
2643 contents + rel->r_offset - 2);
2644 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
2645 contents + rel->r_offset - 1);
2646 }
2647 else
2648 BFD_FAIL ();
2649 bfd_put_32 (output_bfd, -tpoff (info, relocation),
2650 contents + rel->r_offset);
2651 continue;
2652 }
2653 else
2654 {
2655 unsigned int val, type;
2656
2657 /* {IE_32,GOTIE}->LE transition:
2658 Originally it can be one of:
13ae64f3 2659 subl foo(%reg1), %reg2
13ae64f3 2660 movl foo(%reg1), %reg2
37e55690 2661 addl foo(%reg1), %reg2
13ae64f3
JJ		 2662 We change it into:
2663 subl $foo, %reg2
37e55690
JJ		 2664 movl $foo, %reg2 (6 byte form)
2665 addl $foo, %reg2. */
13ae64f3
JJ		 2666 BFD_ASSERT (rel->r_offset >= 2);
2667 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2668 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2669 BFD_ASSERT (rel->r_offset + 4 <= input_section->_raw_size);
37e55690 2670 BFD_ASSERT ((val & 0xc0) == 0x80 && (val & 7) != 4);
13ae64f3
JJ		 2671 if (type == 0x8b)
2672 {
2673 /* movl */
13ae64f3
JJ		 2674 bfd_put_8 (output_bfd, 0xc7,
2675 contents + rel->r_offset - 2);
2676 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
2677 contents + rel->r_offset - 1);
2678 }
2679 else if (type == 0x2b)
2680 {
2681 /* subl */
13ae64f3
JJ		 2682 bfd_put_8 (output_bfd, 0x81,
2683 contents + rel->r_offset - 2);
2684 bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
2685 contents + rel->r_offset - 1);
2686 }
37e55690
JJ		 2687 else if (type == 0x03)
2688 {
2689 /* addl */
2690 bfd_put_8 (output_bfd, 0x81,
2691 contents + rel->r_offset - 2);
2692 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
2693 contents + rel->r_offset - 1);
2694 }
13ae64f3
JJ		 2695 else
2696 BFD_FAIL ();
37e55690
JJ		 2697 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTIE)
2698 bfd_put_32 (output_bfd, -tpoff (info, relocation),
2699 contents + rel->r_offset);
2700 else
2701 bfd_put_32 (output_bfd, tpoff (info, relocation),
2702 contents + rel->r_offset);
13ae64f3
JJ		 2703 continue;
2704 }
2705 }
2706
2707 if (htab->sgot == NULL)
2708 abort ();
2709
2710 if (h != NULL)
2711 off = h->got.offset;
2712 else
2713 {
2714 if (local_got_offsets == NULL)
2715 abort ();
2716
2717 off = local_got_offsets[r_symndx];
2718 }
2719
2720 if ((off & 1) != 0)
2721 off &= ~1;
2722 else
2723 {
2724 Elf_Internal_Rel outrel;
2725 Elf32_External_Rel *loc;
2726 int dr_type, indx;
2727
2728 if (htab->srelgot == NULL)
2729 abort ();
2730
2731 outrel.r_offset = (htab->sgot->output_section->vma
2732 + htab->sgot->output_offset + off);
2733
13ae64f3
JJ		 2734 indx = h && h->dynindx != -1 ? h->dynindx : 0;
2735 if (r_type == R_386_TLS_GD)
2736 dr_type = R_386_TLS_DTPMOD32;
37e55690
JJ		 2737 else if (tls_type == GOT_TLS_IE_POS)
2738 dr_type = R_386_TLS_TPOFF;
13ae64f3
JJ		 2739 else
2740 dr_type = R_386_TLS_TPOFF32;
37e55690
JJ		 2741 if (dr_type == R_386_TLS_TPOFF && indx == 0)
2742 bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
2743 htab->sgot->contents + off);
2744 else if (dr_type == R_386_TLS_TPOFF32 && indx == 0)
c5c1f40c 2745 bfd_put_32 (output_bfd, dtpoff_base (info) - relocation,
c366c25e
JJ		 2746 htab->sgot->contents + off);
2747 else
2748 bfd_put_32 (output_bfd, 0,
2749 htab->sgot->contents + off);
13ae64f3
JJ		 2750 outrel.r_info = ELF32_R_INFO (indx, dr_type);
2751 loc = (Elf32_External_Rel *) htab->srelgot->contents;
2752 loc += htab->srelgot->reloc_count++;
2753 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2754
2755 if (r_type == R_386_TLS_GD)
2756 {
2757 if (indx == 0)
2758 {
82e51918 2759 BFD_ASSERT (! unresolved_reloc);
13ae64f3
JJ		 2760 bfd_put_32 (output_bfd,
2761 relocation - dtpoff_base (info),
2762 htab->sgot->contents + off + 4);
2763 }
2764 else
2765 {
2766 bfd_put_32 (output_bfd, 0,
2767 htab->sgot->contents + off + 4);
2768 outrel.r_info = ELF32_R_INFO (indx,
2769 R_386_TLS_DTPOFF32);
2770 outrel.r_offset += 4;
2771 htab->srelgot->reloc_count++;
2772 loc++;
2773 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
2774 loc);
2775 }
2776 }
37e55690
JJ		 2777 else if (tls_type == GOT_TLS_IE_BOTH)
2778 {
2779 bfd_put_32 (output_bfd,
2780 indx == 0 ? relocation - dtpoff_base (info) : 0,
2781 htab->sgot->contents + off + 4);
2782 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
2783 outrel.r_offset += 4;
2784 htab->srelgot->reloc_count++;
2785 loc++;
2786 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2787 }
13ae64f3
JJ		 2788
2789 if (h != NULL)
2790 h->got.offset |= 1;
2791 else
2792 local_got_offsets[r_symndx] |= 1;
2793 }
2794
2795 if (off >= (bfd_vma) -2)
2796 abort ();
2797 if (r_type == ELF32_R_TYPE (rel->r_info))
2798 {
2799 relocation = htab->sgot->output_offset + off;
37e55690
JJ		 2800 if ((r_type == R_386_TLS_IE || r_type == R_386_TLS_GOTIE)
2801 && tls_type == GOT_TLS_IE_BOTH)
2802 relocation += 4;
2803 if (r_type == R_386_TLS_IE)
2804 relocation += htab->sgot->output_section->vma;
13ae64f3
JJ		 2805 unresolved_reloc = false;
2806 }
2807 else
2808 {
2809 unsigned int val, type;
2810 bfd_vma roff;
2811
2812 /* GD->IE transition. */
2813 BFD_ASSERT (rel->r_offset >= 2);
2814 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2815 BFD_ASSERT (type == 0x8d || type == 0x04);
2816 BFD_ASSERT (rel->r_offset + 9 <= input_section->_raw_size);
2817 BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
2818 == 0xe8);
2819 BFD_ASSERT (rel + 1 < relend);
2820 BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2821 roff = rel->r_offset - 3;
2822 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2823 if (type == 0x04)
2824 {
2825 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2826 Change it into:
2827 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
2828 BFD_ASSERT (rel->r_offset >= 3);
2829 BFD_ASSERT (bfd_get_8 (input_bfd,
2830 contents + rel->r_offset - 3)
2831 == 0x8d);
2832 BFD_ASSERT ((val & 0xc7) == 0x05 && val != (4 << 3));
2833 val >>= 3;
2834 }
2835 else
2836 {
2837 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2838 Change it into:
2839 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
2840 BFD_ASSERT (rel->r_offset + 10 <= input_section->_raw_size);
2841 BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2842 BFD_ASSERT (bfd_get_8 (input_bfd,
2843 contents + rel->r_offset + 9)
2844 == 0x90);
2845 roff = rel->r_offset - 2;
2846 }
2847 memcpy (contents + roff,
2848 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
2849 contents[roff + 7] = 0x80 | (val & 7);
37e55690
JJ		 2850 /* If foo is used only with foo@gotntpoff(%reg) and
2851 foo@indntpoff, but not with foo@gottpoff(%reg), change
2852 subl $foo@gottpoff(%reg), %eax
2853 into:
2854 addl $foo@gotntpoff(%reg), %eax. */
2855 if (r_type == R_386_TLS_GOTIE)
2856 {
2857 contents[roff + 6] = 0x03;
2858 if (tls_type == GOT_TLS_IE_BOTH)
2859 off += 4;
2860 }
13ae64f3
JJ		 2861 bfd_put_32 (output_bfd, htab->sgot->output_offset + off,
2862 contents + roff + 8);
2863 /* Skip R_386_PLT32. */
2864 rel++;
2865 continue;
2866 }
2867 break;
2868
2869 case R_386_TLS_LDM:
2870 if (! info->shared)
2871 {
2872 unsigned int val;
2873
2874 /* LD->LE transition:
2875 Ensure it is:
2876 leal foo(%reg), %eax; call ___tls_get_addr.
2877 We change it into:
2878 movl %gs:0, %eax; nop; leal 0(%esi,1), %esi. */
2879 BFD_ASSERT (rel->r_offset >= 2);
2880 BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset - 2)
2881 == 0x8d);
2882 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2883 BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2884 BFD_ASSERT (rel->r_offset + 9 <= input_section->_raw_size);
2885 BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
2886 == 0xe8);
2887 BFD_ASSERT (rel + 1 < relend);
2888 BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2889 memcpy (contents + rel->r_offset - 2,
2890 "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
2891 /* Skip R_386_PLT32. */
2892 rel++;
2893 continue;
2894 }
2895
2896 if (htab->sgot == NULL)
2897 abort ();
2898
2899 off = htab->tls_ldm_got.offset;
2900 if (off & 1)
2901 off &= ~1;
2902 else
2903 {
2904 Elf_Internal_Rel outrel;
2905 Elf32_External_Rel *loc;
2906
2907 if (htab->srelgot == NULL)
2908 abort ();
2909
2910 outrel.r_offset = (htab->sgot->output_section->vma
2911 + htab->sgot->output_offset + off);
2912
2913 bfd_put_32 (output_bfd, 0,
2914 htab->sgot->contents + off);
2915 bfd_put_32 (output_bfd, 0,
2916 htab->sgot->contents + off + 4);
2917 outrel.r_info = ELF32_R_INFO (0, R_386_TLS_DTPMOD32);
2918 loc = (Elf32_External_Rel *) htab->srelgot->contents;
2919 loc += htab->srelgot->reloc_count++;
2920 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2921 htab->tls_ldm_got.offset |= 1;
2922 }
2923 relocation = htab->sgot->output_offset + off;
2924 unresolved_reloc = false;
2925 break;
2926
2927 case R_386_TLS_LDO_32:
2928 if (info->shared)
2929 relocation -= dtpoff_base (info);
2930 else
2931 /* When converting LDO to LE, we must negate. */
2932 relocation = -tpoff (info, relocation);
2933 break;
2934
2935 case R_386_TLS_LE_32:
13ae64f3 2936 case R_386_TLS_LE:
37e55690
JJ		 2937 if (info->shared)
2938 {
2939 Elf_Internal_Rel outrel;
2940 asection *sreloc;
2941 Elf32_External_Rel *loc;
2942 int indx;
2943
2944 outrel.r_offset = rel->r_offset
2945 + input_section->output_section->vma
2946 + input_section->output_offset;
2947 if (h != NULL && h->dynindx != -1)
2948 indx = h->dynindx;
2949 else
2950 indx = 0;
2951 if (r_type == R_386_TLS_LE_32)
2952 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF32);
2953 else
2954 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
2955 sreloc = elf_section_data (input_section)->sreloc;
2956 if (sreloc == NULL)
2957 abort ();
2958 loc = (Elf32_External_Rel *) sreloc->contents;
2959 loc += sreloc->reloc_count++;
2960 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2961 if (indx)
2962 continue;
2963 else if (r_type == R_386_TLS_LE_32)
2964 relocation = dtpoff_base (info) - relocation;
2965 else
2966 relocation -= dtpoff_base (info);
2967 }
2968 else if (r_type == R_386_TLS_LE_32)
2969 relocation = tpoff (info, relocation);
2970 else
2971 relocation = -tpoff (info, relocation);
13ae64f3
JJ		 2972 break;
2973
252b5132
RH		 2974 default:
2975 break;
2976 }
2977
239e1f3a
AM		 2978 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2979 because such sections are not SEC_ALLOC and thus ld.so will
2980 not process them. */
8c694914 2981 if (unresolved_reloc
239e1f3a 2982 && !((input_section->flags & SEC_DEBUGGING) != 0
8c694914 2983 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
6a30718d
JJ		 2984 {
2985 (*_bfd_error_handler)
2986 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
2987 bfd_archive_filename (input_bfd),
2988 bfd_get_section_name (input_bfd, input_section),
2989 (long) rel->r_offset,
2990 h->root.root.string);
2991 return false;
2992 }
83be169b 2993
252b5132
RH		 2994 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2995 contents, rel->r_offset,
2996 relocation, (bfd_vma) 0);
2997
cf5c0c5b 2998 if (r != bfd_reloc_ok)
252b5132 2999 {
cf5c0c5b 3000 const char *name;
ffb2e45b 3001
cf5c0c5b
AM		 3002 if (h != NULL)
3003 name = h->root.root.string;
3004 else
3005 {
3006 name = bfd_elf_string_from_elf_section (input_bfd,
3007 symtab_hdr->sh_link,
3008 sym->st_name);
3009 if (name == NULL)
3010 return false;
3011 if (*name == '\0')
3012 name = bfd_section_name (input_bfd, sec);
3013 }
ffb2e45b 3014
cf5c0c5b
AM		 3015 if (r == bfd_reloc_overflow)
3016 {
cf5c0c5b
AM		 3017 if (! ((*info->callbacks->reloc_overflow)
3018 (info, name, howto->name, (bfd_vma) 0,
3019 input_bfd, input_section, rel->r_offset)))
3020 return false;
3021 }
3022 else
3023 {
3024 (*_bfd_error_handler)
3025 (_("%s(%s+0x%lx): reloc against `%s': error %d"),
3026 bfd_archive_filename (input_bfd),
3027 bfd_get_section_name (input_bfd, input_section),
3028 (long) rel->r_offset, name, (int) r);
3029 return false;
3030 }
252b5132
RH		 3031 }
3032 }
3033
3034 return true;
3035}
3036
3037/* Finish up dynamic symbol handling. We set the contents of various
3038 dynamic sections here. */
3039
3040static boolean
3041elf_i386_finish_dynamic_symbol (output_bfd, info, h, sym)
3042 bfd *output_bfd;
3043 struct bfd_link_info *info;
3044 struct elf_link_hash_entry *h;
3045 Elf_Internal_Sym *sym;
3046{
6725bdbf 3047 struct elf_i386_link_hash_table *htab;
252b5132 3048
6725bdbf 3049 htab = elf_i386_hash_table (info);
252b5132
RH		 3050
3051 if (h->plt.offset != (bfd_vma) -1)
3052 {
252b5132
RH		 3053 bfd_vma plt_index;
3054 bfd_vma got_offset;
3055 Elf_Internal_Rel rel;
0ac8d2ca 3056 Elf32_External_Rel *loc;
252b5132
RH		 3057
3058 /* This symbol has an entry in the procedure linkage table. Set
3059 it up. */
3060
ffb2e45b
AM		 3061 if (h->dynindx == -1
3062 || htab->splt == NULL
3063 || htab->sgotplt == NULL
3064 || htab->srelplt == NULL)
3065 abort ();
252b5132
RH		 3066
3067 /* Get the index in the procedure linkage table which
3068 corresponds to this symbol. This is the index of this symbol
3069 in all the symbols for which we are making plt entries. The
3070 first entry in the procedure linkage table is reserved. */
3071 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
3072
3073 /* Get the offset into the .got table of the entry that
3074 corresponds to this function. Each .got entry is 4 bytes.
3075 The first three are reserved. */
3076 got_offset = (plt_index + 3) * 4;
3077
3078 /* Fill in the entry in the procedure linkage table. */
3079 if (! info->shared)
3080 {
6725bdbf 3081 memcpy (htab->splt->contents + h->plt.offset, elf_i386_plt_entry,
252b5132
RH		 3082 PLT_ENTRY_SIZE);
3083 bfd_put_32 (output_bfd,
6725bdbf
AM		 3084 (htab->sgotplt->output_section->vma
3085 + htab->sgotplt->output_offset
252b5132 3086 + got_offset),
6725bdbf 3087 htab->splt->contents + h->plt.offset + 2);
252b5132
RH		 3088 }
3089 else
3090 {
6725bdbf 3091 memcpy (htab->splt->contents + h->plt.offset, elf_i386_pic_plt_entry,
252b5132
RH		 3092 PLT_ENTRY_SIZE);
3093 bfd_put_32 (output_bfd, got_offset,
6725bdbf 3094 htab->splt->contents + h->plt.offset + 2);
252b5132
RH		 3095 }
3096
3097 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
6725bdbf 3098 htab->splt->contents + h->plt.offset + 7);
252b5132 3099 bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
6725bdbf 3100 htab->splt->contents + h->plt.offset + 12);
252b5132
RH		 3101
3102 /* Fill in the entry in the global offset table. */
3103 bfd_put_32 (output_bfd,
6725bdbf
AM		 3104 (htab->splt->output_section->vma
3105 + htab->splt->output_offset
252b5132
RH		 3106 + h->plt.offset
3107 + 6),
6725bdbf 3108 htab->sgotplt->contents + got_offset);
252b5132
RH		 3109
3110 /* Fill in the entry in the .rel.plt section. */
6725bdbf
AM		 3111 rel.r_offset = (htab->sgotplt->output_section->vma
3112 + htab->sgotplt->output_offset
252b5132
RH		 3113 + got_offset);
3114 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
0ac8d2ca
AM		 3115 loc = (Elf32_External_Rel *) htab->srelplt->contents + plt_index;
3116 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
252b5132
RH		 3117
3118 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3119 {
3120 /* Mark the symbol as undefined, rather than as defined in
51b64d56
AM		 3121 the .plt section. Leave the value alone. This is a clue
3122 for the dynamic linker, to make function pointer
3123 comparisons work between an application and shared
cedb70c5 3124 library. */
252b5132
RH		 3125 sym->st_shndx = SHN_UNDEF;
3126 }
3127 }
3128
13ae64f3
JJ		 3129 if (h->got.offset != (bfd_vma) -1
3130 && elf_i386_hash_entry(h)->tls_type != GOT_TLS_GD
37e55690 3131 && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE) == 0)
252b5132 3132 {
252b5132 3133 Elf_Internal_Rel rel;
0ac8d2ca 3134 Elf32_External_Rel *loc;
252b5132
RH		 3135
3136 /* This symbol has an entry in the global offset table. Set it
3137 up. */
3138
ffb2e45b
AM		 3139 if (htab->sgot == NULL || htab->srelgot == NULL)
3140 abort ();
252b5132 3141
6725bdbf
AM		 3142 rel.r_offset = (htab->sgot->output_section->vma
3143 + htab->sgot->output_offset
dc810e39 3144 + (h->got.offset & ~(bfd_vma) 1));
252b5132 3145
dd5724d5
AM		 3146 /* If this is a static link, or it is a -Bsymbolic link and the
3147 symbol is defined locally or was forced to be local because
3148 of a version file, we just want to emit a RELATIVE reloc.
252b5132
RH		 3149 The entry in the global offset table will already have been
3150 initialized in the relocate_section function. */
6725bdbf
AM		 3151 if (info->shared
3152 && (info->symbolic
3153 || h->dynindx == -1
3154 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
3155 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
dd5724d5 3156 {
6725bdbf 3157 BFD_ASSERT((h->got.offset & 1) != 0);
dd5724d5
AM		 3158 rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
3159 }
252b5132
RH		 3160 else
3161 {
dd5724d5 3162 BFD_ASSERT((h->got.offset & 1) == 0);
6725bdbf
AM		 3163 bfd_put_32 (output_bfd, (bfd_vma) 0,
3164 htab->sgot->contents + h->got.offset);
252b5132
RH		 3165 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
3166 }
3167
0ac8d2ca
AM		 3168 loc = (Elf32_External_Rel *) htab->srelgot->contents;
3169 loc += htab->srelgot->reloc_count++;
3170 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
252b5132
RH		 3171 }
3172
791987af 3173 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
252b5132 3174 {
252b5132 3175 Elf_Internal_Rel rel;
0ac8d2ca 3176 Elf32_External_Rel *loc;
252b5132
RH		 3177
3178 /* This symbol needs a copy reloc. Set it up. */
3179
ffb2e45b
AM		 3180 if (h->dynindx == -1
3181 || (h->root.type != bfd_link_hash_defined
3182 && h->root.type != bfd_link_hash_defweak)
3183 || htab->srelbss == NULL)
3184 abort ();
252b5132
RH		 3185
3186 rel.r_offset = (h->root.u.def.value
3187 + h->root.u.def.section->output_section->vma
3188 + h->root.u.def.section->output_offset);
3189 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
0ac8d2ca
AM		 3190 loc = (Elf32_External_Rel *) htab->srelbss->contents;
3191 loc += htab->srelbss->reloc_count++;
3192 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
252b5132
RH		 3193 }
3194
3195 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3196 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3197 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3198 sym->st_shndx = SHN_ABS;
3199
3200 return true;
3201}
3202
38701953
AM		 3203/* Used to decide how to sort relocs in an optimal manner for the
3204 dynamic linker, before writing them out. */
3205
3206static enum elf_reloc_type_class
3207elf_i386_reloc_type_class (rela)
3208 const Elf_Internal_Rela *rela;
3209{
3210 switch ((int) ELF32_R_TYPE (rela->r_info))
3211 {
3212 case R_386_RELATIVE:
3213 return reloc_class_relative;
3214 case R_386_JUMP_SLOT:
3215 return reloc_class_plt;
3216 case R_386_COPY:
3217 return reloc_class_copy;
3218 default:
3219 return reloc_class_normal;
3220 }
3221}
3222
252b5132
RH		 3223/* Finish up the dynamic sections. */
3224
3225static boolean
3226elf_i386_finish_dynamic_sections (output_bfd, info)
3227 bfd *output_bfd;
3228 struct bfd_link_info *info;
3229{
6725bdbf 3230 struct elf_i386_link_hash_table *htab;
252b5132 3231 bfd *dynobj;
252b5132
RH		 3232 asection *sdyn;
3233
6725bdbf 3234 htab = elf_i386_hash_table (info);
ebe50bae 3235 dynobj = htab->elf.dynobj;
252b5132
RH		 3236 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3237
ebe50bae 3238 if (htab->elf.dynamic_sections_created)
252b5132 3239 {
252b5132
RH		 3240 Elf32_External_Dyn *dyncon, *dynconend;
3241
ffb2e45b
AM		 3242 if (sdyn == NULL || htab->sgot == NULL)
3243 abort ();
252b5132
RH		 3244
3245 dyncon = (Elf32_External_Dyn *) sdyn->contents;
3246 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3247 for (; dyncon < dynconend; dyncon++)
3248 {
3249 Elf_Internal_Dyn dyn;
51b64d56 3250 asection *s;
252b5132
RH		 3251
3252 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3253
3254 switch (dyn.d_tag)
3255 {
3256 default:
0ac8d2ca 3257 continue;
252b5132
RH		 3258
3259 case DT_PLTGOT:
6725bdbf 3260 dyn.d_un.d_ptr = htab->sgot->output_section->vma;
6725bdbf
AM		 3261 break;
3262
252b5132 3263 case DT_JMPREL:
6725bdbf 3264 dyn.d_un.d_ptr = htab->srelplt->output_section->vma;
252b5132
RH		 3265 break;
3266
3267 case DT_PLTRELSZ:
51b64d56
AM		 3268 s = htab->srelplt->output_section;
3269 if (s->_cooked_size != 0)
3270 dyn.d_un.d_val = s->_cooked_size;
252b5132 3271 else
51b64d56 3272 dyn.d_un.d_val = s->_raw_size;
252b5132
RH		 3273 break;
3274
3275 case DT_RELSZ:
3276 /* My reading of the SVR4 ABI indicates that the
3277 procedure linkage table relocs (DT_JMPREL) should be
3278 included in the overall relocs (DT_REL). This is
3279 what Solaris does. However, UnixWare can not handle
3280 that case. Therefore, we override the DT_RELSZ entry
3281 here to make it not include the JMPREL relocs. Since
3282 the linker script arranges for .rel.plt to follow all
3283 other relocation sections, we don't have to worry
3284 about changing the DT_REL entry. */
6725bdbf 3285 if (htab->srelplt != NULL)
252b5132 3286 {
51b64d56
AM		 3287 s = htab->srelplt->output_section;
3288 if (s->_cooked_size != 0)
3289 dyn.d_un.d_val -= s->_cooked_size;
252b5132 3290 else
51b64d56 3291 dyn.d_un.d_val -= s->_raw_size;
252b5132 3292 }
252b5132
RH		 3293 break;
3294 }
0ac8d2ca
AM		 3295
3296 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
252b5132
RH		 3297 }
3298
3299 /* Fill in the first entry in the procedure linkage table. */
6725bdbf 3300 if (htab->splt && htab->splt->_raw_size > 0)
252b5132
RH		 3301 {
3302 if (info->shared)
6725bdbf
AM		 3303 memcpy (htab->splt->contents,
3304 elf_i386_pic_plt0_entry, PLT_ENTRY_SIZE);
252b5132
RH		 3305 else
3306 {
6725bdbf
AM		 3307 memcpy (htab->splt->contents,
3308 elf_i386_plt0_entry, PLT_ENTRY_SIZE);
252b5132 3309 bfd_put_32 (output_bfd,
6725bdbf
AM		 3310 (htab->sgotplt->output_section->vma
3311 + htab->sgotplt->output_offset
3312 + 4),
3313 htab->splt->contents + 2);
252b5132 3314 bfd_put_32 (output_bfd,
6725bdbf
AM		 3315 (htab->sgotplt->output_section->vma
3316 + htab->sgotplt->output_offset
3317 + 8),
3318 htab->splt->contents + 8);
252b5132
RH		 3319 }
3320
3321 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3322 really seem like the right value. */
6725bdbf
AM		 3323 elf_section_data (htab->splt->output_section)
3324 ->this_hdr.sh_entsize = 4;
252b5132
RH		 3325 }
3326 }
3327
12d0ee4a 3328 if (htab->sgotplt)
252b5132 3329 {
12d0ee4a
AM		 3330 /* Fill in the first three entries in the global offset table. */
3331 if (htab->sgotplt->_raw_size > 0)
3332 {
3333 bfd_put_32 (output_bfd,
3334 (sdyn == NULL ? (bfd_vma) 0
3335 : sdyn->output_section->vma + sdyn->output_offset),
3336 htab->sgotplt->contents);
3337 bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 4);
3338 bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 8);
3339 }
252b5132 3340
12d0ee4a
AM		 3341 elf_section_data (htab->sgotplt->output_section)->this_hdr.sh_entsize = 4;
3342 }
252b5132
RH		 3343 return true;
3344}
3345
4ada7262 3346#ifndef ELF_ARCH
252b5132
RH		 3347#define TARGET_LITTLE_SYM bfd_elf32_i386_vec
3348#define TARGET_LITTLE_NAME "elf32-i386"
3349#define ELF_ARCH bfd_arch_i386
3350#define ELF_MACHINE_CODE EM_386
3351#define ELF_MAXPAGESIZE 0x1000
4ada7262 3352#endif /* ELF_ARCH */
252b5132
RH		 3353
3354#define elf_backend_can_gc_sections 1
51b64d56 3355#define elf_backend_can_refcount 1
252b5132
RH		 3356#define elf_backend_want_got_plt 1
3357#define elf_backend_plt_readonly 1
3358#define elf_backend_want_plt_sym 0
3359#define elf_backend_got_header_size 12
3360#define elf_backend_plt_header_size PLT_ENTRY_SIZE
3361
dd5724d5
AM		 3362#define elf_info_to_howto elf_i386_info_to_howto
3363#define elf_info_to_howto_rel elf_i386_info_to_howto_rel
3364
13ae64f3
JJ		 3365#define bfd_elf32_mkobject elf_i386_mkobject
3366#define elf_backend_object_p elf_i386_object_p
3367
dd5724d5
AM		 3368#define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
3369#define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
3370#define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
3371
3372#define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
3373#define elf_backend_check_relocs elf_i386_check_relocs
0ac8d2ca 3374#define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
6725bdbf 3375#define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
0ac8d2ca 3376#define elf_backend_fake_sections elf_i386_fake_sections
dd5724d5
AM		 3377#define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
3378#define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
3379#define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
3380#define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
c5fccbec
DJ		 3381#define elf_backend_grok_prstatus elf_i386_grok_prstatus
3382#define elf_backend_grok_psinfo elf_i386_grok_psinfo
db6751f2 3383#define elf_backend_reloc_type_class elf_i386_reloc_type_class
0ac8d2ca
AM		 3384#define elf_backend_relocate_section elf_i386_relocate_section
3385#define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
dd5724d5 3386
caf47ea6 3387#ifndef ELF32_I386_C_INCLUDED
252b5132 3388#include "elf32-target.h"
caf47ea6 3389#endif
GDB Binutils - Deliverables
This page took 0.369726 seconds and 4 git commands to generate.