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