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