projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Automatic date update in version.in
[deliverable/binutils-gdb.git] / bfd / elf32-i386.c
CommitLineData
252b5132 1/* Intel 80386/80486-specific support for 32-bit ELF
6f2750fe 2 Copyright (C) 1993-2016 Free Software Foundation, Inc.
252b5132 3
571fe01f 4 This file is part of BFD, the Binary File Descriptor library.
252b5132 5
571fe01f
NC		 6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
cd123cb7 8 the Free Software Foundation; either version 3 of the License, or
571fe01f 9 (at your option) any later version.
252b5132 10
571fe01f
NC		 11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
252b5132 15
571fe01f
NC		 16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
cd123cb7
NC		 18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
252b5132 20
252b5132 21#include "sysdep.h"
3db64b00 22#include "bfd.h"
252b5132
RH		 23#include "bfdlink.h"
24#include "libbfd.h"
25#include "elf-bfd.h"
5a68afcf 26#include "elf-nacl.h"
eac338cf 27#include "elf-vxworks.h"
142411ca 28#include "bfd_stdint.h"
c25bc9fc
L		 29#include "objalloc.h"
30#include "hashtab.h"
e41b3a13 31#include "dwarf2.h"
02a86693 32#include "opcode/i386.h"
252b5132 33
55fd94b0
AM		 34/* 386 uses REL relocations instead of RELA. */
35#define USE_REL 1
252b5132
RH		 36
37#include "elf/i386.h"
38
39static reloc_howto_type elf_howto_table[]=
40{
6346d5ca 41 HOWTO(R_386_NONE, 0, 3, 0, FALSE, 0, complain_overflow_dont,
1b452ec6 42 bfd_elf_generic_reloc, "R_386_NONE",
b34976b6
AM		 43 TRUE, 0x00000000, 0x00000000, FALSE),
44 HOWTO(R_386_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
1b452ec6 45 bfd_elf_generic_reloc, "R_386_32",
b34976b6
AM		 46 TRUE, 0xffffffff, 0xffffffff, FALSE),
47 HOWTO(R_386_PC32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
1b452ec6 48 bfd_elf_generic_reloc, "R_386_PC32",
b34976b6
AM		 49 TRUE, 0xffffffff, 0xffffffff, TRUE),
50 HOWTO(R_386_GOT32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
1b452ec6 51 bfd_elf_generic_reloc, "R_386_GOT32",
b34976b6
AM		 52 TRUE, 0xffffffff, 0xffffffff, FALSE),
53 HOWTO(R_386_PLT32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
1b452ec6 54 bfd_elf_generic_reloc, "R_386_PLT32",
b34976b6
AM		 55 TRUE, 0xffffffff, 0xffffffff, TRUE),
56 HOWTO(R_386_COPY, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
1b452ec6 57 bfd_elf_generic_reloc, "R_386_COPY",
b34976b6
AM		 58 TRUE, 0xffffffff, 0xffffffff, FALSE),
59 HOWTO(R_386_GLOB_DAT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
1b452ec6 60 bfd_elf_generic_reloc, "R_386_GLOB_DAT",
b34976b6
AM		 61 TRUE, 0xffffffff, 0xffffffff, FALSE),
62 HOWTO(R_386_JUMP_SLOT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
1b452ec6 63 bfd_elf_generic_reloc, "R_386_JUMP_SLOT",
b34976b6
AM		 64 TRUE, 0xffffffff, 0xffffffff, FALSE),
65 HOWTO(R_386_RELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
1b452ec6 66 bfd_elf_generic_reloc, "R_386_RELATIVE",
b34976b6
AM		 67 TRUE, 0xffffffff, 0xffffffff, FALSE),
68 HOWTO(R_386_GOTOFF, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
1b452ec6 69 bfd_elf_generic_reloc, "R_386_GOTOFF",
b34976b6
AM		 70 TRUE, 0xffffffff, 0xffffffff, FALSE),
71 HOWTO(R_386_GOTPC, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
1b452ec6 72 bfd_elf_generic_reloc, "R_386_GOTPC",
b34976b6 73 TRUE, 0xffffffff, 0xffffffff, TRUE),
1b452ec6 74
dc47f327
AM		 75 /* We have a gap in the reloc numbers here.
76 R_386_standard counts the number up to this point, and
77 R_386_ext_offset is the value to subtract from a reloc type of
78 R_386_16 thru R_386_PC8 to form an index into this table. */
55fd94b0
AM		 79#define R_386_standard (R_386_GOTPC + 1)
80#define R_386_ext_offset (R_386_TLS_TPOFF - R_386_standard)
1b452ec6 81
37e55690 82 /* These relocs are a GNU extension. */
b34976b6 83 HOWTO(R_386_TLS_TPOFF, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
37e55690 84 bfd_elf_generic_reloc, "R_386_TLS_TPOFF",
b34976b6
AM		 85 TRUE, 0xffffffff, 0xffffffff, FALSE),
86 HOWTO(R_386_TLS_IE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
37e55690 87 bfd_elf_generic_reloc, "R_386_TLS_IE",
b34976b6
AM		 88 TRUE, 0xffffffff, 0xffffffff, FALSE),
89 HOWTO(R_386_TLS_GOTIE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
37e55690 90 bfd_elf_generic_reloc, "R_386_TLS_GOTIE",
b34976b6
AM		 91 TRUE, 0xffffffff, 0xffffffff, FALSE),
92 HOWTO(R_386_TLS_LE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 93 bfd_elf_generic_reloc, "R_386_TLS_LE",
b34976b6
AM		 94 TRUE, 0xffffffff, 0xffffffff, FALSE),
95 HOWTO(R_386_TLS_GD, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 96 bfd_elf_generic_reloc, "R_386_TLS_GD",
b34976b6
AM		 97 TRUE, 0xffffffff, 0xffffffff, FALSE),
98 HOWTO(R_386_TLS_LDM, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 99 bfd_elf_generic_reloc, "R_386_TLS_LDM",
b34976b6
AM		 100 TRUE, 0xffffffff, 0xffffffff, FALSE),
101 HOWTO(R_386_16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
1b452ec6 102 bfd_elf_generic_reloc, "R_386_16",
b34976b6 103 TRUE, 0xffff, 0xffff, FALSE),
b0360d8c 104 HOWTO(R_386_PC16, 0, 1, 16, TRUE, 0, complain_overflow_bitfield,
1b452ec6 105 bfd_elf_generic_reloc, "R_386_PC16",
b34976b6
AM		 106 TRUE, 0xffff, 0xffff, TRUE),
107 HOWTO(R_386_8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,
1b452ec6 108 bfd_elf_generic_reloc, "R_386_8",
b34976b6
AM		 109 TRUE, 0xff, 0xff, FALSE),
110 HOWTO(R_386_PC8, 0, 0, 8, TRUE, 0, complain_overflow_signed,
1b452ec6 111 bfd_elf_generic_reloc, "R_386_PC8",
b34976b6 112 TRUE, 0xff, 0xff, TRUE),
dc47f327 113
55fd94b0
AM		 114#define R_386_ext (R_386_PC8 + 1 - R_386_ext_offset)
115#define R_386_tls_offset (R_386_TLS_LDO_32 - R_386_ext)
13ae64f3 116 /* These are common with Solaris TLS implementation. */
b34976b6 117 HOWTO(R_386_TLS_LDO_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 118 bfd_elf_generic_reloc, "R_386_TLS_LDO_32",
b34976b6
AM		 119 TRUE, 0xffffffff, 0xffffffff, FALSE),
120 HOWTO(R_386_TLS_IE_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 121 bfd_elf_generic_reloc, "R_386_TLS_IE_32",
b34976b6
AM		 122 TRUE, 0xffffffff, 0xffffffff, FALSE),
123 HOWTO(R_386_TLS_LE_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 124 bfd_elf_generic_reloc, "R_386_TLS_LE_32",
b34976b6
AM		 125 TRUE, 0xffffffff, 0xffffffff, FALSE),
126 HOWTO(R_386_TLS_DTPMOD32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 127 bfd_elf_generic_reloc, "R_386_TLS_DTPMOD32",
b34976b6
AM		 128 TRUE, 0xffffffff, 0xffffffff, FALSE),
129 HOWTO(R_386_TLS_DTPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 130 bfd_elf_generic_reloc, "R_386_TLS_DTPOFF32",
b34976b6
AM		 131 TRUE, 0xffffffff, 0xffffffff, FALSE),
132 HOWTO(R_386_TLS_TPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 133 bfd_elf_generic_reloc, "R_386_TLS_TPOFF32",
b34976b6 134 TRUE, 0xffffffff, 0xffffffff, FALSE),
1788fc08
L		 135 HOWTO(R_386_SIZE32, 0, 2, 32, FALSE, 0, complain_overflow_unsigned,
136 bfd_elf_generic_reloc, "R_386_SIZE32",
137 TRUE, 0xffffffff, 0xffffffff, FALSE),
67a4f2b7
AO		 138 HOWTO(R_386_TLS_GOTDESC, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
139 bfd_elf_generic_reloc, "R_386_TLS_GOTDESC",
140 TRUE, 0xffffffff, 0xffffffff, FALSE),
141 HOWTO(R_386_TLS_DESC_CALL, 0, 0, 0, FALSE, 0, complain_overflow_dont,
142 bfd_elf_generic_reloc, "R_386_TLS_DESC_CALL",
143 FALSE, 0, 0, FALSE),
144 HOWTO(R_386_TLS_DESC, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
145 bfd_elf_generic_reloc, "R_386_TLS_DESC",
146 TRUE, 0xffffffff, 0xffffffff, FALSE),
cbe950e9
L		 147 HOWTO(R_386_IRELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
148 bfd_elf_generic_reloc, "R_386_IRELATIVE",
149 TRUE, 0xffffffff, 0xffffffff, FALSE),
02a86693
L		 150 HOWTO(R_386_GOT32X, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
151 bfd_elf_generic_reloc, "R_386_GOT32X",
152 TRUE, 0xffffffff, 0xffffffff, FALSE),
13ae64f3
JJ		 153
154 /* Another gap. */
02a86693 155#define R_386_ext2 (R_386_GOT32X + 1 - R_386_tls_offset)
c74be520 156#define R_386_vt_offset (R_386_GNU_VTINHERIT - R_386_ext2)
252b5132
RH		 157
158/* GNU extension to record C++ vtable hierarchy. */
252b5132
RH		 159 HOWTO (R_386_GNU_VTINHERIT, /* type */
160 0, /* rightshift */
161 2, /* size (0 = byte, 1 = short, 2 = long) */
162 0, /* bitsize */
b34976b6 163 FALSE, /* pc_relative */
252b5132
RH		 164 0, /* bitpos */
165 complain_overflow_dont, /* complain_on_overflow */
166 NULL, /* special_function */
167 "R_386_GNU_VTINHERIT", /* name */
b34976b6 168 FALSE, /* partial_inplace */
252b5132
RH		 169 0, /* src_mask */
170 0, /* dst_mask */
b34976b6 171 FALSE), /* pcrel_offset */
252b5132
RH		 172
173/* GNU extension to record C++ vtable member usage. */
252b5132
RH		 174 HOWTO (R_386_GNU_VTENTRY, /* type */
175 0, /* rightshift */
176 2, /* size (0 = byte, 1 = short, 2 = long) */
177 0, /* bitsize */
b34976b6 178 FALSE, /* pc_relative */
252b5132
RH		 179 0, /* bitpos */
180 complain_overflow_dont, /* complain_on_overflow */
181 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
182 "R_386_GNU_VTENTRY", /* name */
b34976b6 183 FALSE, /* partial_inplace */
252b5132
RH		 184 0, /* src_mask */
185 0, /* dst_mask */
b34976b6 186 FALSE) /* pcrel_offset */
dc47f327 187
55fd94b0 188#define R_386_vt (R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
dc47f327
AM		 189
190};
191
252b5132 192#ifdef DEBUG_GEN_RELOC
55fd94b0
AM		 193#define TRACE(str) \
194 fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
252b5132
RH		 195#else
196#define TRACE(str)
197#endif
198
199static reloc_howto_type *
55fd94b0
AM		 200elf_i386_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
201 bfd_reloc_code_real_type code)
252b5132
RH		 202{
203 switch (code)
204 {
205 case BFD_RELOC_NONE:
206 TRACE ("BFD_RELOC_NONE");
55fd94b0 207 return &elf_howto_table[R_386_NONE];
252b5132
RH		 208
209 case BFD_RELOC_32:
210 TRACE ("BFD_RELOC_32");
55fd94b0 211 return &elf_howto_table[R_386_32];
252b5132
RH		 212
213 case BFD_RELOC_CTOR:
214 TRACE ("BFD_RELOC_CTOR");
55fd94b0 215 return &elf_howto_table[R_386_32];
252b5132
RH		 216
217 case BFD_RELOC_32_PCREL:
218 TRACE ("BFD_RELOC_PC32");
55fd94b0 219 return &elf_howto_table[R_386_PC32];
252b5132
RH		 220
221 case BFD_RELOC_386_GOT32:
222 TRACE ("BFD_RELOC_386_GOT32");
55fd94b0 223 return &elf_howto_table[R_386_GOT32];
252b5132
RH		 224
225 case BFD_RELOC_386_PLT32:
226 TRACE ("BFD_RELOC_386_PLT32");
55fd94b0 227 return &elf_howto_table[R_386_PLT32];
252b5132
RH		 228
229 case BFD_RELOC_386_COPY:
230 TRACE ("BFD_RELOC_386_COPY");
55fd94b0 231 return &elf_howto_table[R_386_COPY];
252b5132
RH		 232
233 case BFD_RELOC_386_GLOB_DAT:
234 TRACE ("BFD_RELOC_386_GLOB_DAT");
55fd94b0 235 return &elf_howto_table[R_386_GLOB_DAT];
252b5132
RH		 236
237 case BFD_RELOC_386_JUMP_SLOT:
238 TRACE ("BFD_RELOC_386_JUMP_SLOT");
55fd94b0 239 return &elf_howto_table[R_386_JUMP_SLOT];
252b5132
RH		 240
241 case BFD_RELOC_386_RELATIVE:
242 TRACE ("BFD_RELOC_386_RELATIVE");
55fd94b0 243 return &elf_howto_table[R_386_RELATIVE];
252b5132
RH		 244
245 case BFD_RELOC_386_GOTOFF:
246 TRACE ("BFD_RELOC_386_GOTOFF");
55fd94b0 247 return &elf_howto_table[R_386_GOTOFF];
252b5132
RH		 248
249 case BFD_RELOC_386_GOTPC:
250 TRACE ("BFD_RELOC_386_GOTPC");
55fd94b0 251 return &elf_howto_table[R_386_GOTPC];
252b5132 252
37e55690
JJ		 253 /* These relocs are a GNU extension. */
254 case BFD_RELOC_386_TLS_TPOFF:
255 TRACE ("BFD_RELOC_386_TLS_TPOFF");
55fd94b0 256 return &elf_howto_table[R_386_TLS_TPOFF - R_386_ext_offset];
37e55690
JJ		 257
258 case BFD_RELOC_386_TLS_IE:
259 TRACE ("BFD_RELOC_386_TLS_IE");
55fd94b0 260 return &elf_howto_table[R_386_TLS_IE - R_386_ext_offset];
37e55690
JJ		 261
262 case BFD_RELOC_386_TLS_GOTIE:
263 TRACE ("BFD_RELOC_386_TLS_GOTIE");
55fd94b0 264 return &elf_howto_table[R_386_TLS_GOTIE - R_386_ext_offset];
37e55690 265
13ae64f3
JJ		 266 case BFD_RELOC_386_TLS_LE:
267 TRACE ("BFD_RELOC_386_TLS_LE");
55fd94b0 268 return &elf_howto_table[R_386_TLS_LE - R_386_ext_offset];
13ae64f3
JJ		 269
270 case BFD_RELOC_386_TLS_GD:
271 TRACE ("BFD_RELOC_386_TLS_GD");
55fd94b0 272 return &elf_howto_table[R_386_TLS_GD - R_386_ext_offset];
13ae64f3
JJ		 273
274 case BFD_RELOC_386_TLS_LDM:
275 TRACE ("BFD_RELOC_386_TLS_LDM");
55fd94b0 276 return &elf_howto_table[R_386_TLS_LDM - R_386_ext_offset];
13ae64f3 277
252b5132
RH		 278 case BFD_RELOC_16:
279 TRACE ("BFD_RELOC_16");
55fd94b0 280 return &elf_howto_table[R_386_16 - R_386_ext_offset];
252b5132
RH		 281
282 case BFD_RELOC_16_PCREL:
283 TRACE ("BFD_RELOC_16_PCREL");
55fd94b0 284 return &elf_howto_table[R_386_PC16 - R_386_ext_offset];
252b5132
RH		 285
286 case BFD_RELOC_8:
287 TRACE ("BFD_RELOC_8");
55fd94b0 288 return &elf_howto_table[R_386_8 - R_386_ext_offset];
252b5132
RH		 289
290 case BFD_RELOC_8_PCREL:
291 TRACE ("BFD_RELOC_8_PCREL");
55fd94b0 292 return &elf_howto_table[R_386_PC8 - R_386_ext_offset];
252b5132 293
13ae64f3
JJ		 294 /* Common with Sun TLS implementation. */
295 case BFD_RELOC_386_TLS_LDO_32:
296 TRACE ("BFD_RELOC_386_TLS_LDO_32");
55fd94b0 297 return &elf_howto_table[R_386_TLS_LDO_32 - R_386_tls_offset];
13ae64f3
JJ		 298
299 case BFD_RELOC_386_TLS_IE_32:
300 TRACE ("BFD_RELOC_386_TLS_IE_32");
55fd94b0 301 return &elf_howto_table[R_386_TLS_IE_32 - R_386_tls_offset];
13ae64f3
JJ		 302
303 case BFD_RELOC_386_TLS_LE_32:
304 TRACE ("BFD_RELOC_386_TLS_LE_32");
55fd94b0 305 return &elf_howto_table[R_386_TLS_LE_32 - R_386_tls_offset];
13ae64f3
JJ		 306
307 case BFD_RELOC_386_TLS_DTPMOD32:
308 TRACE ("BFD_RELOC_386_TLS_DTPMOD32");
55fd94b0 309 return &elf_howto_table[R_386_TLS_DTPMOD32 - R_386_tls_offset];
13ae64f3
JJ		 310
311 case BFD_RELOC_386_TLS_DTPOFF32:
312 TRACE ("BFD_RELOC_386_TLS_DTPOFF32");
55fd94b0 313 return &elf_howto_table[R_386_TLS_DTPOFF32 - R_386_tls_offset];
13ae64f3
JJ		 314
315 case BFD_RELOC_386_TLS_TPOFF32:
316 TRACE ("BFD_RELOC_386_TLS_TPOFF32");
55fd94b0 317 return &elf_howto_table[R_386_TLS_TPOFF32 - R_386_tls_offset];
13ae64f3 318
1788fc08
L		 319 case BFD_RELOC_SIZE32:
320 TRACE ("BFD_RELOC_SIZE32");
321 return &elf_howto_table[R_386_SIZE32 - R_386_tls_offset];
322
67a4f2b7
AO		 323 case BFD_RELOC_386_TLS_GOTDESC:
324 TRACE ("BFD_RELOC_386_TLS_GOTDESC");
325 return &elf_howto_table[R_386_TLS_GOTDESC - R_386_tls_offset];
326
327 case BFD_RELOC_386_TLS_DESC_CALL:
328 TRACE ("BFD_RELOC_386_TLS_DESC_CALL");
329 return &elf_howto_table[R_386_TLS_DESC_CALL - R_386_tls_offset];
330
331 case BFD_RELOC_386_TLS_DESC:
332 TRACE ("BFD_RELOC_386_TLS_DESC");
333 return &elf_howto_table[R_386_TLS_DESC - R_386_tls_offset];
334
cbe950e9
L		 335 case BFD_RELOC_386_IRELATIVE:
336 TRACE ("BFD_RELOC_386_IRELATIVE");
2a750708 337 return &elf_howto_table[R_386_IRELATIVE - R_386_tls_offset];
cbe950e9 338
02a86693
L		 339 case BFD_RELOC_386_GOT32X:
340 TRACE ("BFD_RELOC_386_GOT32X");
341 return &elf_howto_table[R_386_GOT32X - R_386_tls_offset];
342
252b5132
RH		 343 case BFD_RELOC_VTABLE_INHERIT:
344 TRACE ("BFD_RELOC_VTABLE_INHERIT");
55fd94b0 345 return &elf_howto_table[R_386_GNU_VTINHERIT - R_386_vt_offset];
252b5132
RH		 346
347 case BFD_RELOC_VTABLE_ENTRY:
348 TRACE ("BFD_RELOC_VTABLE_ENTRY");
55fd94b0 349 return &elf_howto_table[R_386_GNU_VTENTRY - R_386_vt_offset];
252b5132
RH		 350
351 default:
352 break;
353 }
354
355 TRACE ("Unknown");
356 return 0;
357}
358
157090f7
AM		 359static reloc_howto_type *
360elf_i386_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
361 const char *r_name)
362{
363 unsigned int i;
364
365 for (i = 0; i < sizeof (elf_howto_table) / sizeof (elf_howto_table[0]); i++)
366 if (elf_howto_table[i].name != NULL
367 && strcasecmp (elf_howto_table[i].name, r_name) == 0)
368 return &elf_howto_table[i];
369
370 return NULL;
371}
372
142411ca
L		 373static reloc_howto_type *
374elf_i386_rtype_to_howto (bfd *abfd, unsigned r_type)
252b5132 375{
dc47f327
AM		 376 unsigned int indx;
377
378 if ((indx = r_type) >= R_386_standard
379 && ((indx = r_type - R_386_ext_offset) - R_386_standard
380 >= R_386_ext - R_386_standard)
13ae64f3 381 && ((indx = r_type - R_386_tls_offset) - R_386_ext
c74be520
L		 382 >= R_386_ext2 - R_386_ext)
383 && ((indx = r_type - R_386_vt_offset) - R_386_ext2
384 >= R_386_vt - R_386_ext2))
252b5132 385 {
d003868e
AM		 386 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
387 abfd, (int) r_type);
55fd94b0 388 indx = R_386_NONE;
252b5132 389 }
06614111
NC		 390 /* PR 17512: file: 0f67f69d. */
391 if (elf_howto_table [indx].type != r_type)
392 return NULL;
142411ca
L		 393 return &elf_howto_table[indx];
394}
395
396static void
397elf_i386_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED,
398 arelent *cache_ptr,
399 Elf_Internal_Rela *dst)
400{
401 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
402 cache_ptr->howto = elf_i386_rtype_to_howto (abfd, r_type);
252b5132
RH		 403}
404
405/* Return whether a symbol name implies a local label. The UnixWare
406 2.1 cc generates temporary symbols that start with .X, so we
407 recognize them here. FIXME: do other SVR4 compilers also use .X?.
408 If so, we should move the .X recognition into
409 _bfd_elf_is_local_label_name. */
410
b34976b6 411static bfd_boolean
55fd94b0 412elf_i386_is_local_label_name (bfd *abfd, const char *name)
252b5132
RH		 413{
414 if (name[0] == '.' && name[1] == 'X')
b34976b6 415 return TRUE;
252b5132
RH		 416
417 return _bfd_elf_is_local_label_name (abfd, name);
418}
419\f
38701953 420/* Support for core dump NOTE sections. */
61adc1a4 421
b34976b6 422static bfd_boolean
55fd94b0 423elf_i386_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
38701953
AM		 424{
425 int offset;
eea6121a 426 size_t size;
38701953 427
61adc1a4 428 if (note->namesz == 8 && strcmp (note->namedata, "FreeBSD") == 0)
38701953 429 {
61adc1a4
NC		 430 int pr_version = bfd_get_32 (abfd, note->descdata);
431
432 if (pr_version != 1)
433 return FALSE;
434
435 /* pr_cursig */
228e534f 436 elf_tdata (abfd)->core->signal = bfd_get_32 (abfd, note->descdata + 20);
61adc1a4
NC		 437
438 /* pr_pid */
228e534f 439 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
61adc1a4
NC		 440
441 /* pr_reg */
442 offset = 28;
eea6121a 443 size = bfd_get_32 (abfd, note->descdata + 8);
61adc1a4
NC		 444 }
445 else
446 {
447 switch (note->descsz)
448 {
449 default:
450 return FALSE;
38701953 451
61adc1a4
NC		 452 case 144: /* Linux/i386 */
453 /* pr_cursig */
228e534f 454 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
38701953 455
61adc1a4 456 /* pr_pid */
228e534f 457 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
38701953 458
61adc1a4
NC		 459 /* pr_reg */
460 offset = 72;
eea6121a 461 size = 68;
38701953 462
61adc1a4
NC		 463 break;
464 }
38701953
AM		 465 }
466
467 /* Make a ".reg/999" section. */
468 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
eea6121a 469 size, note->descpos + offset);
38701953
AM		 470}
471
b34976b6 472static bfd_boolean
55fd94b0 473elf_i386_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
38701953 474{
61adc1a4 475 if (note->namesz == 8 && strcmp (note->namedata, "FreeBSD") == 0)
38701953 476 {
61adc1a4
NC		 477 int pr_version = bfd_get_32 (abfd, note->descdata);
478
479 if (pr_version != 1)
b34976b6 480 return FALSE;
38701953 481
228e534f 482 elf_tdata (abfd)->core->program
61adc1a4 483 = _bfd_elfcore_strndup (abfd, note->descdata + 8, 17);
228e534f 484 elf_tdata (abfd)->core->command
61adc1a4
NC		 485 = _bfd_elfcore_strndup (abfd, note->descdata + 25, 81);
486 }
487 else
488 {
489 switch (note->descsz)
490 {
491 default:
492 return FALSE;
493
494 case 124: /* Linux/i386 elf_prpsinfo. */
228e534f 495 elf_tdata (abfd)->core->pid
261b8d08 496 = bfd_get_32 (abfd, note->descdata + 12);
228e534f 497 elf_tdata (abfd)->core->program
61adc1a4 498 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
228e534f 499 elf_tdata (abfd)->core->command
61adc1a4
NC		 500 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
501 }
38701953
AM		 502 }
503
504 /* Note that for some reason, a spurious space is tacked
505 onto the end of the args in some (at least one anyway)
506 implementations, so strip it off if it exists. */
38701953 507 {
228e534f 508 char *command = elf_tdata (abfd)->core->command;
38701953
AM		 509 int n = strlen (command);
510
511 if (0 < n && command[n - 1] == ' ')
512 command[n - 1] = '\0';
513 }
514
b34976b6 515 return TRUE;
38701953
AM		 516}
517\f
518/* Functions for the i386 ELF linker.
519
520 In order to gain some understanding of code in this file without
521 knowing all the intricate details of the linker, note the
522 following:
523
524 Functions named elf_i386_* are called by external routines, other
525 functions are only called locally. elf_i386_* functions appear
526 in this file more or less in the order in which they are called
527 from external routines. eg. elf_i386_check_relocs is called
528 early in the link process, elf_i386_finish_dynamic_sections is
529 one of the last functions. */
530
252b5132
RH		 531
532/* The name of the dynamic interpreter. This is put in the .interp
533 section. */
534
535#define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
536
a23b6845
AM		 537/* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
538 copying dynamic variables from a shared lib into an app's dynbss
539 section, and instead use a dynamic relocation to point into the
540 shared lib. */
541#define ELIMINATE_COPY_RELOCS 1
542
252b5132
RH		 543/* The size in bytes of an entry in the procedure linkage table. */
544
545#define PLT_ENTRY_SIZE 16
546
547/* The first entry in an absolute procedure linkage table looks like
eac338cf
PB		 548 this. See the SVR4 ABI i386 supplement to see how this works.
549 Will be padded to PLT_ENTRY_SIZE with htab->plt0_pad_byte. */
252b5132 550
eac338cf 551static const bfd_byte elf_i386_plt0_entry[12] =
252b5132
RH		 552{
553 0xff, 0x35, /* pushl contents of address */
554 0, 0, 0, 0, /* replaced with address of .got + 4. */
555 0xff, 0x25, /* jmp indirect */
eac338cf 556 0, 0, 0, 0 /* replaced with address of .got + 8. */
252b5132
RH		 557};
558
559/* Subsequent entries in an absolute procedure linkage table look like
560 this. */
561
562static const bfd_byte elf_i386_plt_entry[PLT_ENTRY_SIZE] =
563{
564 0xff, 0x25, /* jmp indirect */
565 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
566 0x68, /* pushl immediate */
567 0, 0, 0, 0, /* replaced with offset into relocation table. */
568 0xe9, /* jmp relative */
569 0, 0, 0, 0 /* replaced with offset to start of .plt. */
570};
571
eac338cf
PB		 572/* The first entry in a PIC procedure linkage table look like this.
573 Will be padded to PLT_ENTRY_SIZE with htab->plt0_pad_byte. */
252b5132 574
eac338cf 575static const bfd_byte elf_i386_pic_plt0_entry[12] =
252b5132
RH		 576{
577 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
eac338cf 578 0xff, 0xa3, 8, 0, 0, 0 /* jmp *8(%ebx) */
252b5132
RH		 579};
580
581/* Subsequent entries in a PIC procedure linkage table look like this. */
582
583static const bfd_byte elf_i386_pic_plt_entry[PLT_ENTRY_SIZE] =
584{
585 0xff, 0xa3, /* jmp *offset(%ebx) */
586 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
587 0x68, /* pushl immediate */
588 0, 0, 0, 0, /* replaced with offset into relocation table. */
589 0xe9, /* jmp relative */
590 0, 0, 0, 0 /* replaced with offset to start of .plt. */
591};
592
dd7e64d4
L		 593/* Entries in the GOT procedure linkage table look like this. */
594
595static const bfd_byte elf_i386_got_plt_entry[8] =
596{
597 0xff, 0x25, /* jmp indirect */
598 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
599 0x66, 0x90 /* xchg %ax,%ax */
600};
601
602/* Entries in the PIC GOT procedure linkage table look like this. */
603
604static const bfd_byte elf_i386_pic_got_plt_entry[8] =
605{
606 0xff, 0xa3, /* jmp *offset(%ebx) */
607 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
608 0x66, 0x90 /* xchg %ax,%ax */
609};
610
e41b3a13
JJ		 611/* .eh_frame covering the .plt section. */
612
613static const bfd_byte elf_i386_eh_frame_plt[] =
614{
615#define PLT_CIE_LENGTH 20
616#define PLT_FDE_LENGTH 36
617#define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
618#define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
619 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
620 0, 0, 0, 0, /* CIE ID */
621 1, /* CIE version */
622 'z', 'R', 0, /* Augmentation string */
623 1, /* Code alignment factor */
624 0x7c, /* Data alignment factor */
625 8, /* Return address column */
626 1, /* Augmentation size */
627 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
628 DW_CFA_def_cfa, 4, 4, /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
629 DW_CFA_offset + 8, 1, /* DW_CFA_offset: r8 (eip) at cfa-4 */
630 DW_CFA_nop, DW_CFA_nop,
631
632 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
633 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
634 0, 0, 0, 0, /* R_386_PC32 .plt goes here */
635 0, 0, 0, 0, /* .plt size goes here */
636 0, /* Augmentation size */
637 DW_CFA_def_cfa_offset, 8, /* DW_CFA_def_cfa_offset: 8 */
638 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
639 DW_CFA_def_cfa_offset, 12, /* DW_CFA_def_cfa_offset: 12 */
640 DW_CFA_advance_loc + 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
641 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
642 11, /* Block length */
643 DW_OP_breg4, 4, /* DW_OP_breg4 (esp): 4 */
644 DW_OP_breg8, 0, /* DW_OP_breg8 (eip): 0 */
645 DW_OP_lit15, DW_OP_and, DW_OP_lit11, DW_OP_ge,
28ede8be 646 DW_OP_lit2, DW_OP_shl, DW_OP_plus,
e41b3a13
JJ		 647 DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
648};
649
25e762b9
RM		 650struct elf_i386_plt_layout
651{
652 /* The first entry in an absolute procedure linkage table looks like this. */
653 const bfd_byte *plt0_entry;
654 unsigned int plt0_entry_size;
655
656 /* Offsets into plt0_entry that are to be replaced with GOT[1] and GOT[2]. */
657 unsigned int plt0_got1_offset;
658 unsigned int plt0_got2_offset;
659
660 /* Later entries in an absolute procedure linkage table look like this. */
661 const bfd_byte *plt_entry;
662 unsigned int plt_entry_size;
663
664 /* Offsets into plt_entry that are to be replaced with... */
665 unsigned int plt_got_offset; /* ... address of this symbol in .got. */
666 unsigned int plt_reloc_offset; /* ... offset into relocation table. */
667 unsigned int plt_plt_offset; /* ... offset to start of .plt. */
668
669 /* Offset into plt_entry where the initial value of the GOT entry points. */
670 unsigned int plt_lazy_offset;
671
672 /* The first entry in a PIC procedure linkage table looks like this. */
673 const bfd_byte *pic_plt0_entry;
674
675 /* Subsequent entries in a PIC procedure linkage table look like this. */
676 const bfd_byte *pic_plt_entry;
677
678 /* .eh_frame covering the .plt section. */
679 const bfd_byte *eh_frame_plt;
680 unsigned int eh_frame_plt_size;
681};
682
683#define GET_PLT_ENTRY_SIZE(abfd) \
684 get_elf_i386_backend_data (abfd)->plt->plt_entry_size
685
686/* These are the standard parameters. */
687static const struct elf_i386_plt_layout elf_i386_plt =
688 {
689 elf_i386_plt0_entry, /* plt0_entry */
690 sizeof (elf_i386_plt0_entry), /* plt0_entry_size */
691 2, /* plt0_got1_offset */
692 8, /* plt0_got2_offset */
693 elf_i386_plt_entry, /* plt_entry */
694 PLT_ENTRY_SIZE, /* plt_entry_size */
695 2, /* plt_got_offset */
696 7, /* plt_reloc_offset */
697 12, /* plt_plt_offset */
698 6, /* plt_lazy_offset */
699 elf_i386_pic_plt0_entry, /* pic_plt0_entry */
700 elf_i386_pic_plt_entry, /* pic_plt_entry */
701 elf_i386_eh_frame_plt, /* eh_frame_plt */
702 sizeof (elf_i386_eh_frame_plt), /* eh_frame_plt_size */
703 };
704\f
705
eac338cf
PB		 706/* On VxWorks, the .rel.plt.unloaded section has absolute relocations
707 for the PLTResolve stub and then for each PLT entry. */
708#define PLTRESOLVE_RELOCS_SHLIB 0
709#define PLTRESOLVE_RELOCS 2
710#define PLT_NON_JUMP_SLOT_RELOCS 2
711
23209a78
RM		 712/* Architecture-specific backend data for i386. */
713
714struct elf_i386_backend_data
715{
25e762b9
RM		 716 /* Parameters describing PLT generation. */
717 const struct elf_i386_plt_layout *plt;
718
23209a78
RM		 719 /* Value used to fill the unused bytes of the first PLT entry. */
720 bfd_byte plt0_pad_byte;
721
722 /* True if the target system is VxWorks. */
723 int is_vxworks;
724};
725
726#define get_elf_i386_backend_data(abfd) \
727 ((const struct elf_i386_backend_data *) \
728 get_elf_backend_data (abfd)->arch_data)
729
730/* These are the standard parameters. */
731static const struct elf_i386_backend_data elf_i386_arch_bed =
732 {
25e762b9 733 &elf_i386_plt, /* plt */
23209a78
RM		 734 0, /* plt0_pad_byte */
735 0, /* is_vxworks */
736 };
737
738#define elf_backend_arch_data &elf_i386_arch_bed
739
aec6b87e
L		 740/* Is a undefined weak symbol which is resolved to 0. Reference to an
741 undefined weak symbol is resolved to 0 when building executable if
742 it isn't dynamic and
743 1. Has non-GOT/non-PLT relocations in text section. Or
744 2. Has no GOT/PLT relocation.
745 */
e62b9723 746#define UNDEFINED_WEAK_RESOLVED_TO_ZERO(INFO, GOT_RELOC, EH) \
aec6b87e
L		 747 ((EH)->elf.root.type == bfd_link_hash_undefweak \
748 && bfd_link_executable (INFO) \
749 && (elf_i386_hash_table (INFO)->interp == NULL \
e62b9723 750 || !(GOT_RELOC) \
aec6b87e
L		 751 || (EH)->has_non_got_reloc \
752 || !(INFO)->dynamic_undefined_weak))
753
252b5132
RH		 754/* i386 ELF linker hash entry. */
755
756struct elf_i386_link_hash_entry
757{
ebe50bae 758 struct elf_link_hash_entry elf;
252b5132 759
0c715baa 760 /* Track dynamic relocs copied for this symbol. */
e03a8ed8 761 struct elf_dyn_relocs *dyn_relocs;
13ae64f3 762
37e55690
JJ		 763#define GOT_UNKNOWN 0
764#define GOT_NORMAL 1
765#define GOT_TLS_GD 2
766#define GOT_TLS_IE 4
767#define GOT_TLS_IE_POS 5
768#define GOT_TLS_IE_NEG 6
769#define GOT_TLS_IE_BOTH 7
67a4f2b7
AO		 770#define GOT_TLS_GDESC 8
771#define GOT_TLS_GD_BOTH_P(type) \
772 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
773#define GOT_TLS_GD_P(type) \
774 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
775#define GOT_TLS_GDESC_P(type) \
776 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
777#define GOT_TLS_GD_ANY_P(type) \
778 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
37e55690 779 unsigned char tls_type;
67a4f2b7 780
d5597ebc
L		 781 /* Symbol is referenced by R_386_GOTOFF relocation. */
782 unsigned int gotoff_ref : 1;
783
aec6b87e
L		 784 /* Symbol has GOT or PLT relocations. */
785 unsigned int has_got_reloc : 1;
786
787 /* Symbol has non-GOT/non-PLT relocations in text sections. */
788 unsigned int has_non_got_reloc : 1;
789
04ebc307
L		 790 /* Reference count of C/C++ function pointer relocations in read-write
791 section which can be resolved at run-time. */
792 bfd_signed_vma func_pointer_refcount;
793
dd7e64d4
L		 794 /* Information about the GOT PLT entry. Filled when there are both
795 GOT and PLT relocations against the same function. */
796 union gotplt_union plt_got;
797
67a4f2b7
AO		 798 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
799 starting at the end of the jump table. */
800 bfd_vma tlsdesc_got;
13ae64f3
JJ		 801};
802
803#define elf_i386_hash_entry(ent) ((struct elf_i386_link_hash_entry *)(ent))
804
805struct elf_i386_obj_tdata
806{
807 struct elf_obj_tdata root;
808
809 /* tls_type for each local got entry. */
810 char *local_got_tls_type;
67a4f2b7
AO		 811
812 /* GOTPLT entries for TLS descriptors. */
813 bfd_vma *local_tlsdesc_gotent;
252b5132
RH		 814};
815
13ae64f3
JJ		 816#define elf_i386_tdata(abfd) \
817 ((struct elf_i386_obj_tdata *) (abfd)->tdata.any)
818
819#define elf_i386_local_got_tls_type(abfd) \
820 (elf_i386_tdata (abfd)->local_got_tls_type)
821
67a4f2b7
AO		 822#define elf_i386_local_tlsdesc_gotent(abfd) \
823 (elf_i386_tdata (abfd)->local_tlsdesc_gotent)
824
0ffa91dd
NC		 825#define is_i386_elf(bfd) \
826 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
827 && elf_tdata (bfd) != NULL \
4dfe6ac6 828 && elf_object_id (bfd) == I386_ELF_DATA)
0ffa91dd 829
b34976b6 830static bfd_boolean
55fd94b0 831elf_i386_mkobject (bfd *abfd)
13ae64f3 832{
0ffa91dd 833 return bfd_elf_allocate_object (abfd, sizeof (struct elf_i386_obj_tdata),
4dfe6ac6 834 I386_ELF_DATA);
13ae64f3 835}
cedb70c5 836
252b5132
RH		 837/* i386 ELF linker hash table. */
838
839struct elf_i386_link_hash_table
840{
ebe50bae 841 struct elf_link_hash_table elf;
252b5132 842
6725bdbf 843 /* Short-cuts to get to dynamic linker sections. */
aec6b87e 844 asection *interp;
6725bdbf
AM		 845 asection *sdynbss;
846 asection *srelbss;
e41b3a13 847 asection *plt_eh_frame;
dd7e64d4 848 asection *plt_got;
9635fe29 849
4dfe6ac6
NC		 850 union
851 {
13ae64f3
JJ		 852 bfd_signed_vma refcount;
853 bfd_vma offset;
854 } tls_ldm_got;
855
67a4f2b7
AO		 856 /* The amount of space used by the reserved portion of the sgotplt
857 section, plus whatever space is used by the jump slots. */
858 bfd_vma sgotplt_jump_table_size;
859
87d72d41
AM		 860 /* Small local sym cache. */
861 struct sym_cache sym_cache;
9f03412a
AO		 862
863 /* _TLS_MODULE_BASE_ symbol. */
864 struct bfd_link_hash_entry *tls_module_base;
c25bc9fc
L		 865
866 /* Used by local STT_GNU_IFUNC symbols. */
867 htab_t loc_hash_table;
4dfe6ac6
NC		 868 void * loc_hash_memory;
869
870 /* The (unloaded but important) .rel.plt.unloaded section on VxWorks. */
871 asection *srelplt2;
872
4dfe6ac6
NC		 873 /* The index of the next unused R_386_TLS_DESC slot in .rel.plt. */
874 bfd_vma next_tls_desc_index;
e1f98742
L		 875
876 /* The index of the next unused R_386_JUMP_SLOT slot in .rel.plt. */
877 bfd_vma next_jump_slot_index;
878
879 /* The index of the next unused R_386_IRELATIVE slot in .rel.plt. */
880 bfd_vma next_irelative_index;
2df3368d
L		 881
882 /* TRUE if there are dynamic relocs against IFUNC symbols that apply
883 to read-only sections. */
884 bfd_boolean readonly_dynrelocs_against_ifunc;
6725bdbf 885};
252b5132
RH		 886
887/* Get the i386 ELF linker hash table from a link_info structure. */
888
889#define elf_i386_hash_table(p) \
4dfe6ac6
NC		 890 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
891 == I386_ELF_DATA ? ((struct elf_i386_link_hash_table *) ((p)->hash)) : NULL)
252b5132 892
67a4f2b7 893#define elf_i386_compute_jump_table_size(htab) \
998d811a 894 ((htab)->elf.srelplt->reloc_count * 4)
67a4f2b7 895
252b5132
RH		 896/* Create an entry in an i386 ELF linker hash table. */
897
898static struct bfd_hash_entry *
eb4ff4d6
L		 899elf_i386_link_hash_newfunc (struct bfd_hash_entry *entry,
900 struct bfd_hash_table *table,
901 const char *string)
252b5132 902{
252b5132
RH		 903 /* Allocate the structure if it has not already been allocated by a
904 subclass. */
ebe50bae
AM		 905 if (entry == NULL)
906 {
a50b1753
NC		 907 entry = (struct bfd_hash_entry *)
908 bfd_hash_allocate (table, sizeof (struct elf_i386_link_hash_entry));
ebe50bae
AM		 909 if (entry == NULL)
910 return entry;
911 }
252b5132
RH		 912
913 /* Call the allocation method of the superclass. */
ebe50bae
AM		 914 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
915 if (entry != NULL)
252b5132 916 {
ebe50bae
AM		 917 struct elf_i386_link_hash_entry *eh;
918
919 eh = (struct elf_i386_link_hash_entry *) entry;
920 eh->dyn_relocs = NULL;
13ae64f3 921 eh->tls_type = GOT_UNKNOWN;
d5597ebc 922 eh->gotoff_ref = 0;
aec6b87e
L		 923 eh->has_got_reloc = 0;
924 eh->has_non_got_reloc = 0;
04ebc307 925 eh->func_pointer_refcount = 0;
dd7e64d4 926 eh->plt_got.offset = (bfd_vma) -1;
67a4f2b7 927 eh->tlsdesc_got = (bfd_vma) -1;
252b5132
RH		 928 }
929
ebe50bae 930 return entry;
252b5132
RH		 931}
932
c25bc9fc
L		 933/* Compute a hash of a local hash entry. We use elf_link_hash_entry
934 for local symbol so that we can handle local STT_GNU_IFUNC symbols
935 as global symbol. We reuse indx and dynstr_index for local symbol
936 hash since they aren't used by global symbols in this backend. */
937
938static hashval_t
939elf_i386_local_htab_hash (const void *ptr)
940{
941 struct elf_link_hash_entry *h
942 = (struct elf_link_hash_entry *) ptr;
d2149d72 943 return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);
c25bc9fc
L		 944}
945
946/* Compare local hash entries. */
947
948static int
949elf_i386_local_htab_eq (const void *ptr1, const void *ptr2)
950{
951 struct elf_link_hash_entry *h1
952 = (struct elf_link_hash_entry *) ptr1;
953 struct elf_link_hash_entry *h2
954 = (struct elf_link_hash_entry *) ptr2;
955
956 return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
957}
958
959/* Find and/or create a hash entry for local symbol. */
960
961static struct elf_link_hash_entry *
962elf_i386_get_local_sym_hash (struct elf_i386_link_hash_table *htab,
963 bfd *abfd, const Elf_Internal_Rela *rel,
964 bfd_boolean create)
965{
966 struct elf_i386_link_hash_entry e, *ret;
967 asection *sec = abfd->sections;
d2149d72
L		 968 hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id,
969 ELF32_R_SYM (rel->r_info));
c25bc9fc
L		 970 void **slot;
971
972 e.elf.indx = sec->id;
973 e.elf.dynstr_index = ELF32_R_SYM (rel->r_info);
974 slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,
975 create ? INSERT : NO_INSERT);
976
977 if (!slot)
978 return NULL;
979
980 if (*slot)
981 {
982 ret = (struct elf_i386_link_hash_entry *) *slot;
983 return &ret->elf;
984 }
985
986 ret = (struct elf_i386_link_hash_entry *)
987 objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,
988 sizeof (struct elf_i386_link_hash_entry));
989 if (ret)
990 {
991 memset (ret, 0, sizeof (*ret));
992 ret->elf.indx = sec->id;
993 ret->elf.dynstr_index = ELF32_R_SYM (rel->r_info);
994 ret->elf.dynindx = -1;
04ebc307 995 ret->func_pointer_refcount = 0;
dd7e64d4 996 ret->plt_got.offset = (bfd_vma) -1;
c25bc9fc
L		 997 *slot = ret;
998 }
999 return &ret->elf;
1000}
1001
68faa637
AM		 1002/* Destroy an i386 ELF linker hash table. */
1003
1004static void
d495ab0d 1005elf_i386_link_hash_table_free (bfd *obfd)
68faa637
AM		 1006{
1007 struct elf_i386_link_hash_table *htab
d495ab0d 1008 = (struct elf_i386_link_hash_table *) obfd->link.hash;
68faa637
AM		 1009
1010 if (htab->loc_hash_table)
1011 htab_delete (htab->loc_hash_table);
1012 if (htab->loc_hash_memory)
1013 objalloc_free ((struct objalloc *) htab->loc_hash_memory);
d495ab0d 1014 _bfd_elf_link_hash_table_free (obfd);
68faa637
AM		 1015}
1016
252b5132
RH		 1017/* Create an i386 ELF linker hash table. */
1018
1019static struct bfd_link_hash_table *
55fd94b0 1020elf_i386_link_hash_table_create (bfd *abfd)
252b5132
RH		 1021{
1022 struct elf_i386_link_hash_table *ret;
dc810e39 1023 bfd_size_type amt = sizeof (struct elf_i386_link_hash_table);
252b5132 1024
7bf52ea2 1025 ret = (struct elf_i386_link_hash_table *) bfd_zmalloc (amt);
ebe50bae 1026 if (ret == NULL)
252b5132
RH		 1027 return NULL;
1028
eb4ff4d6
L		 1029 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
1030 elf_i386_link_hash_newfunc,
4dfe6ac6
NC		 1031 sizeof (struct elf_i386_link_hash_entry),
1032 I386_ELF_DATA))
252b5132 1033 {
e2d34d7d 1034 free (ret);
252b5132
RH		 1035 return NULL;
1036 }
1037
c25bc9fc
L		 1038 ret->loc_hash_table = htab_try_create (1024,
1039 elf_i386_local_htab_hash,
1040 elf_i386_local_htab_eq,
1041 NULL);
1042 ret->loc_hash_memory = objalloc_create ();
1043 if (!ret->loc_hash_table || !ret->loc_hash_memory)
1044 {
d495ab0d 1045 elf_i386_link_hash_table_free (abfd);
c25bc9fc
L		 1046 return NULL;
1047 }
d495ab0d 1048 ret->elf.root.hash_table_free = elf_i386_link_hash_table_free;
c25bc9fc 1049
ebe50bae 1050 return &ret->elf.root;
252b5132
RH		 1051}
1052
6725bdbf
AM		 1053/* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
1054 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
1055 hash table. */
1056
b34976b6 1057static bfd_boolean
55fd94b0 1058elf_i386_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
6725bdbf
AM		 1059{
1060 struct elf_i386_link_hash_table *htab;
1061
6725bdbf 1062 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
b34976b6 1063 return FALSE;
6725bdbf 1064
6de2ae4a 1065 htab = elf_i386_hash_table (info);
4dfe6ac6
NC		 1066 if (htab == NULL)
1067 return FALSE;
1068
493f652c
L		 1069 /* Set the contents of the .interp section to the interpreter. */
1070 if (bfd_link_executable (info) && !info->nointerp)
1071 {
1072 asection *s = bfd_get_linker_section (dynobj, ".interp");
1073 if (s == NULL)
1074 abort ();
1075 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1076 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1077 htab->interp = s;
1078 }
1079
3d4d4302 1080 htab->sdynbss = bfd_get_linker_section (dynobj, ".dynbss");
d5597ebc 1081 if (!htab->sdynbss)
6725bdbf
AM		 1082 abort ();
1083
0e1862bb 1084 if (bfd_link_executable (info))
d5597ebc
L		 1085 {
1086 /* Always allow copy relocs for building executables. */
1087 asection *s = bfd_get_linker_section (dynobj, ".rel.bss");
1088 if (s == NULL)
1089 {
1090 const struct elf_backend_data *bed = get_elf_backend_data (dynobj);
1091 s = bfd_make_section_anyway_with_flags (dynobj,
1092 ".rel.bss",
1093 (bed->dynamic_sec_flags
1094 | SEC_READONLY));
1095 if (s == NULL
1096 || ! bfd_set_section_alignment (dynobj, s,
1097 bed->s->log_file_align))
1098 return FALSE;
1099 }
1100 htab->srelbss = s;
1101 }
1102
23209a78 1103 if (get_elf_i386_backend_data (dynobj)->is_vxworks
6de2ae4a
L		 1104 && !elf_vxworks_create_dynamic_sections (dynobj, info,
1105 &htab->srelplt2))
711de32c 1106 return FALSE;
eac338cf 1107
e41b3a13 1108 if (!info->no_ld_generated_unwind_info
2fe0fd06 1109 && htab->plt_eh_frame == NULL
e4de50d4 1110 && htab->elf.splt != NULL)
e41b3a13 1111 {
bbf96e4e
L		 1112 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
1113 | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1114 | SEC_LINKER_CREATED);
e41b3a13 1115 htab->plt_eh_frame
bbf96e4e 1116 = bfd_make_section_anyway_with_flags (dynobj, ".eh_frame", flags);
e41b3a13
JJ		 1117 if (htab->plt_eh_frame == NULL
1118 || !bfd_set_section_alignment (dynobj, htab->plt_eh_frame, 2))
1119 return FALSE;
e41b3a13
JJ		 1120 }
1121
b34976b6 1122 return TRUE;
6725bdbf
AM		 1123}
1124
ebe50bae
AM		 1125/* Copy the extra info we tack onto an elf_link_hash_entry. */
1126
51b64d56 1127static void
fcfa13d2 1128elf_i386_copy_indirect_symbol (struct bfd_link_info *info,
55fd94b0
AM		 1129 struct elf_link_hash_entry *dir,
1130 struct elf_link_hash_entry *ind)
ebe50bae
AM		 1131{
1132 struct elf_i386_link_hash_entry *edir, *eind;
1133
1134 edir = (struct elf_i386_link_hash_entry *) dir;
1135 eind = (struct elf_i386_link_hash_entry *) ind;
1136
bbd7ec4a 1137 if (eind->dyn_relocs != NULL)
ebe50bae 1138 {
bbd7ec4a
AM		 1139 if (edir->dyn_relocs != NULL)
1140 {
e03a8ed8
L		 1141 struct elf_dyn_relocs **pp;
1142 struct elf_dyn_relocs *p;
bbd7ec4a 1143
fcfa13d2 1144 /* Add reloc counts against the indirect sym to the direct sym
bbd7ec4a
AM		 1145 list. Merge any entries against the same section. */
1146 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1147 {
e03a8ed8 1148 struct elf_dyn_relocs *q;
bbd7ec4a
AM		 1149
1150 for (q = edir->dyn_relocs; q != NULL; q = q->next)
1151 if (q->sec == p->sec)
1152 {
1153 q->pc_count += p->pc_count;
1154 q->count += p->count;
1155 *pp = p->next;
1156 break;
1157 }
1158 if (q == NULL)
1159 pp = &p->next;
1160 }
1161 *pp = edir->dyn_relocs;
1162 }
1163
ebe50bae
AM		 1164 edir->dyn_relocs = eind->dyn_relocs;
1165 eind->dyn_relocs = NULL;
1166 }
ebe50bae 1167
cd67d266
JJ		 1168 if (ind->root.type == bfd_link_hash_indirect
1169 && dir->got.refcount <= 0)
1170 {
1171 edir->tls_type = eind->tls_type;
1172 eind->tls_type = GOT_UNKNOWN;
1173 }
81848ca0 1174
d5597ebc
L		 1175 /* Copy gotoff_ref so that elf_i386_adjust_dynamic_symbol will
1176 generate a R_386_COPY reloc. */
1177 edir->gotoff_ref |= eind->gotoff_ref;
1178
aec6b87e
L		 1179 edir->has_got_reloc |= eind->has_got_reloc;
1180 edir->has_non_got_reloc |= eind->has_non_got_reloc;
1181
81848ca0
AM		 1182 if (ELIMINATE_COPY_RELOCS
1183 && ind->root.type != bfd_link_hash_indirect
f5385ebf
AM		 1184 && dir->dynamic_adjusted)
1185 {
1186 /* If called to transfer flags for a weakdef during processing
1187 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1188 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1189 dir->ref_dynamic |= ind->ref_dynamic;
1190 dir->ref_regular |= ind->ref_regular;
1191 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
1192 dir->needs_plt |= ind->needs_plt;
1193 dir->pointer_equality_needed |= ind->pointer_equality_needed;
1194 }
81848ca0 1195 else
04ebc307
L		 1196 {
1197 if (eind->func_pointer_refcount > 0)
1198 {
1199 edir->func_pointer_refcount += eind->func_pointer_refcount;
1200 eind->func_pointer_refcount = 0;
1201 }
1202
1203 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1204 }
ebe50bae
AM		 1205}
1206
142411ca
L		 1207/* Return TRUE if the TLS access code sequence support transition
1208 from R_TYPE. */
1209
1210static bfd_boolean
bedfd056 1211elf_i386_check_tls_transition (asection *sec,
142411ca
L		 1212 bfd_byte *contents,
1213 Elf_Internal_Shdr *symtab_hdr,
1214 struct elf_link_hash_entry **sym_hashes,
1215 unsigned int r_type,
1216 const Elf_Internal_Rela *rel,
1217 const Elf_Internal_Rela *relend)
13ae64f3 1218{
142411ca
L		 1219 unsigned int val, type;
1220 unsigned long r_symndx;
1221 struct elf_link_hash_entry *h;
1222 bfd_vma offset;
1223
142411ca 1224 offset = rel->r_offset;
13ae64f3 1225 switch (r_type)
142411ca
L		 1226 {
1227 case R_386_TLS_GD:
1228 case R_386_TLS_LDM:
1229 if (offset < 2 || (rel + 1) >= relend)
1230 return FALSE;
1231
1232 type = bfd_get_8 (abfd, contents + offset - 2);
1233 if (r_type == R_386_TLS_GD)
1234 {
09e8c3bf 1235 /* Check transition from GD access model. Only
142411ca
L		 1236 leal foo@tlsgd(,%reg,1), %eax; call ___tls_get_addr
1237 leal foo@tlsgd(%reg), %eax; call ___tls_get_addr; nop
1238 can transit to different access model. */
1239 if ((offset + 10) > sec->size ||
1240 (type != 0x8d && type != 0x04))
1241 return FALSE;
1242
1243 val = bfd_get_8 (abfd, contents + offset - 1);
1244 if (type == 0x04)
1245 {
1246 /* leal foo@tlsgd(,%reg,1), %eax; call ___tls_get_addr */
1247 if (offset < 3)
1248 return FALSE;
1249
1250 if (bfd_get_8 (abfd, contents + offset - 3) != 0x8d)
1251 return FALSE;
1252
1253 if ((val & 0xc7) != 0x05 || val == (4 << 3))
1254 return FALSE;
1255 }
1256 else
1257 {
1258 /* leal foo@tlsgd(%reg), %eax; call ___tls_get_addr; nop */
1259 if ((val & 0xf8) != 0x80 || (val & 7) == 4)
1260 return FALSE;
1261
1262 if (bfd_get_8 (abfd, contents + offset + 9) != 0x90)
1263 return FALSE;
1264 }
1265 }
1266 else
1267 {
1268 /* Check transition from LD access model. Only
1269 leal foo@tlsgd(%reg), %eax; call ___tls_get_addr
1270 can transit to different access model. */
1271 if (type != 0x8d || (offset + 9) > sec->size)
1272 return FALSE;
1273
1274 val = bfd_get_8 (abfd, contents + offset - 1);
1275 if ((val & 0xf8) != 0x80 || (val & 7) == 4)
1276 return FALSE;
1277 }
1278
1279 if (bfd_get_8 (abfd, contents + offset + 4) != 0xe8)
1280 return FALSE;
1281
1282 r_symndx = ELF32_R_SYM (rel[1].r_info);
1283 if (r_symndx < symtab_hdr->sh_info)
1284 return FALSE;
1285
1286 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
c4fb387b
L		 1287 /* Use strncmp to check ___tls_get_addr since ___tls_get_addr
1288 may be versioned. */
142411ca
L		 1289 return (h != NULL
1290 && h->root.root.string != NULL
1291 && (ELF32_R_TYPE (rel[1].r_info) == R_386_PC32
1292 || ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32)
c4fb387b
L		 1293 && (strncmp (h->root.root.string, "___tls_get_addr",
1294 15) == 0));
142411ca
L		 1295
1296 case R_386_TLS_IE:
1297 /* Check transition from IE access model:
1298 movl foo@indntpoff(%rip), %eax
1299 movl foo@indntpoff(%rip), %reg
1300 addl foo@indntpoff(%rip), %reg
1301 */
1302
1303 if (offset < 1 || (offset + 4) > sec->size)
1304 return FALSE;
1305
1306 /* Check "movl foo@tpoff(%rip), %eax" first. */
1307 val = bfd_get_8 (abfd, contents + offset - 1);
1308 if (val == 0xa1)
1309 return TRUE;
1310
1311 if (offset < 2)
1312 return FALSE;
1313
1314 /* Check movl|addl foo@tpoff(%rip), %reg. */
1315 type = bfd_get_8 (abfd, contents + offset - 2);
1316 return ((type == 0x8b || type == 0x03)
1317 && (val & 0xc7) == 0x05);
1318
1319 case R_386_TLS_GOTIE:
1320 case R_386_TLS_IE_32:
1321 /* Check transition from {IE_32,GOTIE} access model:
1322 subl foo@{tpoff,gontoff}(%reg1), %reg2
1323 movl foo@{tpoff,gontoff}(%reg1), %reg2
1324 addl foo@{tpoff,gontoff}(%reg1), %reg2
1325 */
1326
1327 if (offset < 2 || (offset + 4) > sec->size)
1328 return FALSE;
1329
1330 val = bfd_get_8 (abfd, contents + offset - 1);
1331 if ((val & 0xc0) != 0x80 || (val & 7) == 4)
1332 return FALSE;
1333
1334 type = bfd_get_8 (abfd, contents + offset - 2);
1335 return type == 0x8b || type == 0x2b || type == 0x03;
1336
1337 case R_386_TLS_GOTDESC:
1338 /* Check transition from GDesc access model:
1339 leal x@tlsdesc(%ebx), %eax
1340
1341 Make sure it's a leal adding ebx to a 32-bit offset
1342 into any register, although it's probably almost always
1343 going to be eax. */
1344
1345 if (offset < 2 || (offset + 4) > sec->size)
1346 return FALSE;
1347
1348 if (bfd_get_8 (abfd, contents + offset - 2) != 0x8d)
1349 return FALSE;
1350
1351 val = bfd_get_8 (abfd, contents + offset - 1);
1352 return (val & 0xc7) == 0x83;
1353
1354 case R_386_TLS_DESC_CALL:
1355 /* Check transition from GDesc access model:
1356 call *x@tlsdesc(%rax)
1357 */
1358 if (offset + 2 <= sec->size)
1359 {
1360 /* Make sure that it's a call *x@tlsdesc(%rax). */
fa289a5f
AM		 1361 static const unsigned char call[] = { 0xff, 0x10 };
1362 return memcmp (contents + offset, call, 2) == 0;
142411ca
L		 1363 }
1364
1365 return FALSE;
1366
1367 default:
1368 abort ();
1369 }
1370}
1371
1372/* Return TRUE if the TLS access transition is OK or no transition
1373 will be performed. Update R_TYPE if there is a transition. */
1374
1375static bfd_boolean
1376elf_i386_tls_transition (struct bfd_link_info *info, bfd *abfd,
1377 asection *sec, bfd_byte *contents,
1378 Elf_Internal_Shdr *symtab_hdr,
1379 struct elf_link_hash_entry **sym_hashes,
1380 unsigned int *r_type, int tls_type,
1381 const Elf_Internal_Rela *rel,
1382 const Elf_Internal_Rela *relend,
4c544807 1383 struct elf_link_hash_entry *h,
bedfd056
L		 1384 unsigned long r_symndx,
1385 bfd_boolean from_relocate_section)
142411ca
L		 1386{
1387 unsigned int from_type = *r_type;
1388 unsigned int to_type = from_type;
1389 bfd_boolean check = TRUE;
1390
bb1cb422
L		 1391 /* Skip TLS transition for functions. */
1392 if (h != NULL
1393 && (h->type == STT_FUNC
1394 || h->type == STT_GNU_IFUNC))
1395 return TRUE;
1396
142411ca 1397 switch (from_type)
13ae64f3
JJ		 1398 {
1399 case R_386_TLS_GD:
67a4f2b7
AO		 1400 case R_386_TLS_GOTDESC:
1401 case R_386_TLS_DESC_CALL:
13ae64f3 1402 case R_386_TLS_IE_32:
37e55690
JJ		 1403 case R_386_TLS_IE:
1404 case R_386_TLS_GOTIE:
0e1862bb 1405 if (bfd_link_executable (info))
142411ca
L		 1406 {
1407 if (h == NULL)
1408 to_type = R_386_TLS_LE_32;
1409 else if (from_type != R_386_TLS_IE
1410 && from_type != R_386_TLS_GOTIE)
1411 to_type = R_386_TLS_IE_32;
1412 }
1413
bedfd056
L		 1414 /* When we are called from elf_i386_relocate_section, there may
1415 be additional transitions based on TLS_TYPE. */
1416 if (from_relocate_section)
142411ca
L		 1417 {
1418 unsigned int new_to_type = to_type;
1419
0e1862bb 1420 if (bfd_link_executable (info)
142411ca
L		 1421 && h != NULL
1422 && h->dynindx == -1
1423 && (tls_type & GOT_TLS_IE))
1424 new_to_type = R_386_TLS_LE_32;
1425
1426 if (to_type == R_386_TLS_GD
1427 || to_type == R_386_TLS_GOTDESC
1428 || to_type == R_386_TLS_DESC_CALL)
1429 {
1430 if (tls_type == GOT_TLS_IE_POS)
1431 new_to_type = R_386_TLS_GOTIE;
1432 else if (tls_type & GOT_TLS_IE)
1433 new_to_type = R_386_TLS_IE_32;
1434 }
1435
1436 /* We checked the transition before when we were called from
1437 elf_i386_check_relocs. We only want to check the new
1438 transition which hasn't been checked before. */
1439 check = new_to_type != to_type && from_type == to_type;
1440 to_type = new_to_type;
1441 }
1442
1443 break;
1444
13ae64f3 1445 case R_386_TLS_LDM:
0e1862bb 1446 if (bfd_link_executable (info))
142411ca
L		 1447 to_type = R_386_TLS_LE_32;
1448 break;
1449
1450 default:
1451 return TRUE;
1452 }
1453
1454 /* Return TRUE if there is no transition. */
1455 if (from_type == to_type)
1456 return TRUE;
1457
1458 /* Check if the transition can be performed. */
1459 if (check
bedfd056 1460 && ! elf_i386_check_tls_transition (sec, contents,
142411ca
L		 1461 symtab_hdr, sym_hashes,
1462 from_type, rel, relend))
1463 {
2f629d23 1464 reloc_howto_type *from, *to;
4c544807 1465 const char *name;
142411ca
L		 1466
1467 from = elf_i386_rtype_to_howto (abfd, from_type);
1468 to = elf_i386_rtype_to_howto (abfd, to_type);
1469
4c544807
L		 1470 if (h)
1471 name = h->root.root.string;
1472 else
1473 {
4c544807 1474 struct elf_i386_link_hash_table *htab;
4dfe6ac6 1475
4c544807 1476 htab = elf_i386_hash_table (info);
4dfe6ac6
NC		 1477 if (htab == NULL)
1478 name = "*unknown*";
1479 else
1480 {
1481 Elf_Internal_Sym *isym;
1482
1483 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1484 abfd, r_symndx);
1485 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1486 }
4c544807
L		 1487 }
1488
142411ca
L		 1489 (*_bfd_error_handler)
1490 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1491 "in section `%A' failed"),
4c544807 1492 abfd, sec, from->name, to->name, name,
142411ca
L		 1493 (unsigned long) rel->r_offset);
1494 bfd_set_error (bfd_error_bad_value);
1495 return FALSE;
13ae64f3
JJ		 1496 }
1497
142411ca
L		 1498 *r_type = to_type;
1499 return TRUE;
13ae64f3
JJ		 1500}
1501
c175a657
L		 1502/* With the local symbol, foo, we convert
1503 mov foo@GOT[(%reg1)], %reg2
1504 to
1505 lea foo[@GOTOFF(%reg1)], %reg2
1506 and convert
1507 call/jmp *foo@GOT[(%reg)]
1508 to
1509 nop call foo/jmp foo nop
1510 When PIC is false, convert
1511 test %reg1, foo@GOT[(%reg2)]
1512 to
1513 test $foo, %reg1
1514 and convert
1515 binop foo@GOT[(%reg1)], %reg2
1516 to
1517 binop $foo, %reg2
1518 where binop is one of adc, add, and, cmp, or, sbb, sub, xor
1519 instructions. */
1520
1521static
1522bfd_boolean
1523elf_i386_convert_load_reloc (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
1524 bfd_byte *contents,
1525 Elf_Internal_Rela *irel,
1526 struct elf_link_hash_entry *h,
1527 bfd_boolean *converted,
1528 struct bfd_link_info *link_info)
1529{
1530 struct elf_i386_link_hash_table *htab;
1531 unsigned int opcode;
1532 unsigned int modrm;
1533 bfd_boolean baseless;
1534 Elf_Internal_Sym *isym;
1535 unsigned int addend;
1536 unsigned int nop;
1537 bfd_vma nop_offset;
1538 bfd_boolean is_pic;
1539 bfd_boolean to_reloc_32;
1540 unsigned int r_type;
1541 unsigned int r_symndx;
1542 bfd_vma roff = irel->r_offset;
1543
1544 if (roff < 2)
1545 return TRUE;
1546
7d4d9709 1547 /* Addend for R_386_GOT32X relocations must be 0. */
c175a657
L		 1548 addend = bfd_get_32 (abfd, contents + roff);
1549 if (addend != 0)
1550 return TRUE;
1551
1552 htab = elf_i386_hash_table (link_info);
1553 is_pic = bfd_link_pic (link_info);
1554
1555 r_type = ELF32_R_TYPE (irel->r_info);
1556 r_symndx = ELF32_R_SYM (irel->r_info);
1557
1558 modrm = bfd_get_8 (abfd, contents + roff - 1);
1559 baseless = (modrm & 0xc7) == 0x5;
1560
7d4d9709 1561 if (baseless && is_pic)
c175a657
L		 1562 {
1563 /* For PIC, disallow R_386_GOT32X without a base register
7d4d9709 1564 since we don't know what the GOT base is. */
c175a657
L		 1565 const char *name;
1566
1567 if (h == NULL)
1568 {
1569 isym = bfd_sym_from_r_symndx (&htab->sym_cache, abfd,
1570 r_symndx);
1571 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1572 }
1573 else
1574 name = h->root.root.string;
1575
1576 (*_bfd_error_handler)
1577 (_("%B: direct GOT relocation R_386_GOT32X against `%s' without base register can not be used when making a shared object"),
1578 abfd, name);
1579 return FALSE;
1580 }
1581
1582 opcode = bfd_get_8 (abfd, contents + roff - 2);
1583
c175a657
L		 1584 /* Convert to R_386_32 if PIC is false or there is no base
1585 register. */
1586 to_reloc_32 = !is_pic || baseless;
1587
7d4d9709
L		 1588 /* Try to convert R_386_GOT32X. Get the symbol referred to by the
1589 reloc. */
c175a657
L		 1590 if (h == NULL)
1591 {
1592 if (opcode == 0x0ff)
1593 /* Convert "call/jmp *foo@GOT[(%reg)]". */
1594 goto convert_branch;
1595 else
1596 /* Convert "mov foo@GOT[(%reg1)], %reg2",
1597 "test %reg1, foo@GOT(%reg2)" and
1598 "binop foo@GOT[(%reg1)], %reg2". */
1599 goto convert_load;
1600 }
1601
1602 /* Undefined weak symbol is only bound locally in executable
1603 and its reference is resolved as 0. */
1604 if (UNDEFINED_WEAK_RESOLVED_TO_ZERO (link_info, TRUE,
1605 elf_i386_hash_entry (h)))
1606 {
1607 if (opcode == 0xff)
1608 {
1609 /* No direct branch to 0 for PIC. */
1610 if (is_pic)
1611 return TRUE;
1612 else
1613 goto convert_branch;
1614 }
1615 else
1616 {
1617 /* We can convert load of address 0 to R_386_32. */
1618 to_reloc_32 = TRUE;
1619 goto convert_load;
1620 }
1621 }
1622
1623 if (opcode == 0xff)
1624 {
1625 /* We have "call/jmp *foo@GOT[(%reg)]". */
1626 if ((h->root.type == bfd_link_hash_defined
1627 || h->root.type == bfd_link_hash_defweak)
1628 && SYMBOL_REFERENCES_LOCAL (link_info, h))
1629 {
1630 /* The function is locally defined. */
1631convert_branch:
1632 /* Convert R_386_GOT32X to R_386_PC32. */
1633 if (modrm == 0x15 || (modrm & 0xf8) == 0x90)
1634 {
1635 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
1636 is a nop prefix. */
1637 modrm = 0xe8;
1638 nop = link_info->call_nop_byte;
1639 if (link_info->call_nop_as_suffix)
1640 {
1641 nop_offset = roff + 3;
1642 irel->r_offset -= 1;
1643 }
1644 else
1645 nop_offset = roff - 2;
1646 }
1647 else
1648 {
1649 /* Convert to "jmp foo nop". */
1650 modrm = 0xe9;
1651 nop = NOP_OPCODE;
1652 nop_offset = roff + 3;
1653 irel->r_offset -= 1;
1654 }
1655
1656 bfd_put_8 (abfd, nop, contents + nop_offset);
1657 bfd_put_8 (abfd, modrm, contents + irel->r_offset - 1);
1658 /* When converting to PC-relative relocation, we
1659 need to adjust addend by -4. */
1660 bfd_put_32 (abfd, -4, contents + irel->r_offset);
1661 irel->r_info = ELF32_R_INFO (r_symndx, R_386_PC32);
1662
1663 *converted = TRUE;
1664 }
1665 }
1666 else
1667 {
1668 /* We have "mov foo@GOT[(%re1g)], %reg2",
1669 "test %reg1, foo@GOT(%reg2)" and
1670 "binop foo@GOT[(%reg1)], %reg2".
1671
1672 Avoid optimizing _DYNAMIC since ld.so may use its
1673 link-time address. */
1674 if (h == htab->elf.hdynamic)
1675 return TRUE;
1676
1677 /* def_regular is set by an assignment in a linker script in
1678 bfd_elf_record_link_assignment. */
1679 if ((h->def_regular
1680 || h->root.type == bfd_link_hash_defined
1681 || h->root.type == bfd_link_hash_defweak)
1682 && SYMBOL_REFERENCES_LOCAL (link_info, h))
1683 {
1684convert_load:
1685 if (opcode == 0x8b)
1686 {
1687 if (to_reloc_32)
1688 {
1689 /* Convert "mov foo@GOT[(%reg1)], %reg2" to
1690 "mov $foo, %reg2" with R_386_32. */
1691 r_type = R_386_32;
1692 modrm = 0xc0 | (modrm & 0x38) >> 3;
1693 bfd_put_8 (abfd, modrm, contents + roff - 1);
1694 opcode = 0xc7;
1695 }
1696 else
1697 {
1698 /* Convert "mov foo@GOT(%reg1), %reg2" to
1699 "lea foo@GOTOFF(%reg1), %reg2". */
1700 r_type = R_386_GOTOFF;
1701 opcode = 0x8d;
1702 }
1703 }
1704 else
1705 {
1706 /* Only R_386_32 is supported. */
1707 if (!to_reloc_32)
1708 return TRUE;
1709
1710 if (opcode == 0x85)
1711 {
1712 /* Convert "test %reg1, foo@GOT(%reg2)" to
1713 "test $foo, %reg1". */
1714 modrm = 0xc0 | (modrm & 0x38) >> 3;
1715 opcode = 0xf7;
1716 }
1717 else
1718 {
1719 /* Convert "binop foo@GOT(%reg1), %reg2" to
1720 "binop $foo, %reg2". */
1721 modrm = (0xc0
1722 | (modrm & 0x38) >> 3
1723 | (opcode & 0x3c));
1724 opcode = 0x81;
1725 }
1726 bfd_put_8 (abfd, modrm, contents + roff - 1);
1727 r_type = R_386_32;
1728 }
1729
1730 bfd_put_8 (abfd, opcode, contents + roff - 2);
1731 irel->r_info = ELF32_R_INFO (r_symndx, r_type);
1732
1733 *converted = TRUE;
1734 }
1735 }
1736
1737 return TRUE;
1738}
1739
c1d11331
L		 1740/* Rename some of the generic section flags to better document how they
1741 are used here. */
c337a162
L		 1742#define need_convert_load sec_flg0
1743#define check_relocs_failed sec_flg1
c1d11331 1744
252b5132 1745/* Look through the relocs for a section during the first phase, and
0ac8d2ca
AM		 1746 calculate needed space in the global offset table, procedure linkage
1747 table, and dynamic reloc sections. */
252b5132 1748
b34976b6 1749static bfd_boolean
55fd94b0
AM		 1750elf_i386_check_relocs (bfd *abfd,
1751 struct bfd_link_info *info,
1752 asection *sec,
1753 const Elf_Internal_Rela *relocs)
252b5132 1754{
6725bdbf 1755 struct elf_i386_link_hash_table *htab;
252b5132
RH		 1756 Elf_Internal_Shdr *symtab_hdr;
1757 struct elf_link_hash_entry **sym_hashes;
252b5132
RH		 1758 const Elf_Internal_Rela *rel;
1759 const Elf_Internal_Rela *rel_end;
252b5132 1760 asection *sreloc;
bedfd056 1761 bfd_byte *contents;
dd7e64d4 1762 bfd_boolean use_plt_got;
252b5132 1763
0e1862bb 1764 if (bfd_link_relocatable (info))
b34976b6 1765 return TRUE;
252b5132 1766
0ffa91dd
NC		 1767 BFD_ASSERT (is_i386_elf (abfd));
1768
6725bdbf 1769 htab = elf_i386_hash_table (info);
4dfe6ac6 1770 if (htab == NULL)
c337a162
L		 1771 {
1772 sec->check_relocs_failed = 1;
1773 return FALSE;
1774 }
4dfe6ac6 1775
bedfd056
L		 1776 /* Get the section contents. */
1777 if (elf_section_data (sec)->this_hdr.contents != NULL)
1778 contents = elf_section_data (sec)->this_hdr.contents;
1779 else if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1780 {
1781 sec->check_relocs_failed = 1;
1782 return FALSE;
1783 }
1784
dd7e64d4
L		 1785 use_plt_got = (!get_elf_i386_backend_data (abfd)->is_vxworks
1786 && (get_elf_i386_backend_data (abfd)
1787 == &elf_i386_arch_bed));
1788
0ffa91dd 1789 symtab_hdr = &elf_symtab_hdr (abfd);
252b5132 1790 sym_hashes = elf_sym_hashes (abfd);
252b5132 1791
252b5132
RH		 1792 sreloc = NULL;
1793
1794 rel_end = relocs + sec->reloc_count;
1795 for (rel = relocs; rel < rel_end; rel++)
1796 {
13ae64f3 1797 unsigned int r_type;
252b5132
RH		 1798 unsigned long r_symndx;
1799 struct elf_link_hash_entry *h;
d5597ebc 1800 struct elf_i386_link_hash_entry *eh;
4c544807
L		 1801 Elf_Internal_Sym *isym;
1802 const char *name;
06a6a421 1803 bfd_boolean size_reloc;
252b5132
RH		 1804
1805 r_symndx = ELF32_R_SYM (rel->r_info);
13ae64f3 1806 r_type = ELF32_R_TYPE (rel->r_info);
252b5132 1807
d9bc7a44 1808 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
f5f31454 1809 {
d003868e
AM		 1810 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1811 abfd,
8f615d07 1812 r_symndx);
c337a162 1813 goto error_return;
f5f31454
L		 1814 }
1815
252b5132 1816 if (r_symndx < symtab_hdr->sh_info)
c25bc9fc
L		 1817 {
1818 /* A local symbol. */
c2e61a4e
L		 1819 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1820 abfd, r_symndx);
1821 if (isym == NULL)
c337a162 1822 goto error_return;
c25bc9fc
L		 1823
1824 /* Check relocation against local STT_GNU_IFUNC symbol. */
c25bc9fc
L		 1825 if (ELF32_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1826 {
9fff0c39 1827 h = elf_i386_get_local_sym_hash (htab, abfd, rel, TRUE);
c25bc9fc 1828 if (h == NULL)
c337a162 1829 goto error_return;
6bbec505 1830
c25bc9fc
L		 1831 /* Fake a STT_GNU_IFUNC symbol. */
1832 h->type = STT_GNU_IFUNC;
1833 h->def_regular = 1;
1834 h->ref_regular = 1;
1835 h->forced_local = 1;
1836 h->root.type = bfd_link_hash_defined;
1837 }
1838 else
1839 h = NULL;
1840 }
252b5132 1841 else
71cb9464 1842 {
4c544807 1843 isym = NULL;
71cb9464
L		 1844 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1845 while (h->root.type == bfd_link_hash_indirect
1846 || h->root.type == bfd_link_hash_warning)
1847 h = (struct elf_link_hash_entry *) h->root.u.i.link;
c25bc9fc 1848 }
cbe950e9 1849
d5597ebc 1850 eh = (struct elf_i386_link_hash_entry *) h;
c25bc9fc
L		 1851 if (h != NULL)
1852 {
cbe950e9
L		 1853 switch (r_type)
1854 {
1855 default:
1856 break;
1857
d5597ebc
L		 1858 case R_386_GOTOFF:
1859 eh->gotoff_ref = 1;
cbe950e9
L		 1860 case R_386_32:
1861 case R_386_PC32:
1862 case R_386_PLT32:
1863 case R_386_GOT32:
02a86693 1864 case R_386_GOT32X:
9d4057ee
AM		 1865 if (htab->elf.dynobj == NULL)
1866 htab->elf.dynobj = abfd;
466ee2af
L		 1867 /* Create the ifunc sections for static executables. */
1868 if (h->type == STT_GNU_IFUNC
1869 && !_bfd_elf_create_ifunc_sections (htab->elf.dynobj,
1870 info))
c337a162 1871 goto error_return;
cbe950e9
L		 1872 break;
1873 }
1874
ad1e85de
L		 1875 /* It is referenced by a non-shared object. */
1876 h->ref_regular = 1;
61315175 1877 h->root.non_ir_ref = 1;
13a2df29
L		 1878
1879 if (h->type == STT_GNU_IFUNC)
1880 elf_tdata (info->output_bfd)->has_gnu_symbols
1881 |= elf_gnu_symbol_ifunc;
71cb9464 1882 }
252b5132 1883
bedfd056 1884 if (! elf_i386_tls_transition (info, abfd, sec, contents,
142411ca
L		 1885 symtab_hdr, sym_hashes,
1886 &r_type, GOT_UNKNOWN,
bedfd056 1887 rel, rel_end, h, r_symndx, FALSE))
c337a162 1888 goto error_return;
13ae64f3
JJ		 1889
1890 switch (r_type)
252b5132 1891 {
37e55690
JJ		 1892 case R_386_TLS_LDM:
1893 htab->tls_ldm_got.refcount += 1;
1894 goto create_got;
1895
1896 case R_386_PLT32:
1897 /* This symbol requires a procedure linkage table entry. We
1898 actually build the entry in adjust_dynamic_symbol,
1899 because this might be a case of linking PIC code which is
1900 never referenced by a dynamic object, in which case we
1901 don't need to generate a procedure linkage table entry
1902 after all. */
1903
1904 /* If this is a local symbol, we resolve it directly without
1905 creating a procedure linkage table entry. */
1906 if (h == NULL)
1907 continue;
1908
aec6b87e 1909 eh->has_got_reloc = 1;
f5385ebf 1910 h->needs_plt = 1;
37e55690
JJ		 1911 h->plt.refcount += 1;
1912 break;
1913
6a3e1bae 1914 case R_386_SIZE32:
06a6a421 1915 size_reloc = TRUE;
6a3e1bae
L		 1916 goto do_size;
1917
13ae64f3 1918 case R_386_TLS_IE_32:
37e55690
JJ		 1919 case R_386_TLS_IE:
1920 case R_386_TLS_GOTIE:
0e1862bb 1921 if (!bfd_link_executable (info))
13ae64f3 1922 info->flags |= DF_STATIC_TLS;
37e55690
JJ		 1923 /* Fall through */
1924
252b5132 1925 case R_386_GOT32:
02a86693 1926 case R_386_GOT32X:
13ae64f3 1927 case R_386_TLS_GD:
67a4f2b7
AO		 1928 case R_386_TLS_GOTDESC:
1929 case R_386_TLS_DESC_CALL:
252b5132 1930 /* This symbol requires a global offset table entry. */
13ae64f3
JJ		 1931 {
1932 int tls_type, old_tls_type;
1933
1934 switch (r_type)
1935 {
1936 default:
02a86693
L		 1937 case R_386_GOT32:
1938 case R_386_GOT32X:
1939 tls_type = GOT_NORMAL;
1940 break;
13ae64f3 1941 case R_386_TLS_GD: tls_type = GOT_TLS_GD; break;
67a4f2b7
AO		 1942 case R_386_TLS_GOTDESC:
1943 case R_386_TLS_DESC_CALL:
1944 tls_type = GOT_TLS_GDESC; break;
37e55690
JJ		 1945 case R_386_TLS_IE_32:
1946 if (ELF32_R_TYPE (rel->r_info) == r_type)
1947 tls_type = GOT_TLS_IE_NEG;
1948 else
ebcfb3c0
JJ		 1949 /* If this is a GD->IE transition, we may use either of
1950 R_386_TLS_TPOFF and R_386_TLS_TPOFF32. */
37e55690
JJ		 1951 tls_type = GOT_TLS_IE;
1952 break;
1953 case R_386_TLS_IE:
1954 case R_386_TLS_GOTIE:
1955 tls_type = GOT_TLS_IE_POS; break;
13ae64f3
JJ		 1956 }
1957
1958 if (h != NULL)
1959 {
1960 h->got.refcount += 1;
1961 old_tls_type = elf_i386_hash_entry(h)->tls_type;
1962 }
1963 else
1964 {
1965 bfd_signed_vma *local_got_refcounts;
1966
1967 /* This is a global offset table entry for a local symbol. */
1968 local_got_refcounts = elf_local_got_refcounts (abfd);
1969 if (local_got_refcounts == NULL)
1970 {
1971 bfd_size_type size;
1972
1973 size = symtab_hdr->sh_info;
67a4f2b7
AO		 1974 size *= (sizeof (bfd_signed_vma)
1975 + sizeof (bfd_vma) + sizeof(char));
a50b1753
NC		 1976 local_got_refcounts = (bfd_signed_vma *)
1977 bfd_zalloc (abfd, size);
13ae64f3 1978 if (local_got_refcounts == NULL)
c337a162 1979 goto error_return;
13ae64f3 1980 elf_local_got_refcounts (abfd) = local_got_refcounts;
67a4f2b7
AO		 1981 elf_i386_local_tlsdesc_gotent (abfd)
1982 = (bfd_vma *) (local_got_refcounts + symtab_hdr->sh_info);
13ae64f3 1983 elf_i386_local_got_tls_type (abfd)
67a4f2b7 1984 = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
13ae64f3
JJ		 1985 }
1986 local_got_refcounts[r_symndx] += 1;
1987 old_tls_type = elf_i386_local_got_tls_type (abfd) [r_symndx];
1988 }
1989
37e55690
JJ		 1990 if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_IE))
1991 tls_type |= old_tls_type;
13ae64f3
JJ		 1992 /* If a TLS symbol is accessed using IE at least once,
1993 there is no point to use dynamic model for it. */
ebcfb3c0 1994 else if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
67a4f2b7 1995 && (! GOT_TLS_GD_ANY_P (old_tls_type)
37e55690 1996 || (tls_type & GOT_TLS_IE) == 0))
13ae64f3 1997 {
67a4f2b7 1998 if ((old_tls_type & GOT_TLS_IE) && GOT_TLS_GD_ANY_P (tls_type))
37e55690 1999 tls_type = old_tls_type;
67a4f2b7
AO		 2000 else if (GOT_TLS_GD_ANY_P (old_tls_type)
2001 && GOT_TLS_GD_ANY_P (tls_type))
2002 tls_type |= old_tls_type;
13ae64f3
JJ		 2003 else
2004 {
09a24cbf 2005 if (h)
4c544807
L		 2006 name = h->root.root.string;
2007 else
2008 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
2009 NULL);
13ae64f3 2010 (*_bfd_error_handler)
d003868e 2011 (_("%B: `%s' accessed both as normal and "
55fd94b0 2012 "thread local symbol"),
4c544807 2013 abfd, name);
68c4a57e 2014 bfd_set_error (bfd_error_bad_value);
c337a162 2015 goto error_return;
13ae64f3
JJ		 2016 }
2017 }
2018
2019 if (old_tls_type != tls_type)
2020 {
2021 if (h != NULL)
2022 elf_i386_hash_entry (h)->tls_type = tls_type;
2023 else
2024 elf_i386_local_got_tls_type (abfd) [r_symndx] = tls_type;
2025 }
2026 }
0ac8d2ca
AM		 2027 /* Fall through */
2028
2029 case R_386_GOTOFF:
2030 case R_386_GOTPC:
13ae64f3 2031 create_got:
6de2ae4a 2032 if (htab->elf.sgot == NULL)
0ac8d2ca
AM		 2033 {
2034 if (htab->elf.dynobj == NULL)
2035 htab->elf.dynobj = abfd;
6de2ae4a 2036 if (!_bfd_elf_create_got_section (htab->elf.dynobj, info))
c337a162 2037 goto error_return;
0ac8d2ca 2038 }
37e55690 2039 if (r_type != R_386_TLS_IE)
aec6b87e
L		 2040 {
2041 if (eh != NULL)
2042 eh->has_got_reloc = 1;
2043 break;
2044 }
37e55690 2045 /* Fall through */
252b5132 2046
37e55690
JJ		 2047 case R_386_TLS_LE_32:
2048 case R_386_TLS_LE:
aec6b87e
L		 2049 if (eh != NULL)
2050 eh->has_got_reloc = 1;
0e1862bb 2051 if (bfd_link_executable (info))
37e55690 2052 break;
bffbf940 2053 info->flags |= DF_STATIC_TLS;
aec6b87e 2054 goto do_relocation;
252b5132
RH		 2055
2056 case R_386_32:
2057 case R_386_PC32:
aec6b87e
L		 2058 if (eh != NULL && (sec->flags & SEC_CODE) != 0)
2059 eh->has_non_got_reloc = 1;
2060do_relocation:
d1ed1c7d
L		 2061 /* STT_GNU_IFUNC symbol must go through PLT even if it is
2062 locally defined and undefined symbol may turn out to be
2063 a STT_GNU_IFUNC symbol later. */
2064 if (h != NULL
2065 && (bfd_link_executable (info)
2066 || ((h->type == STT_GNU_IFUNC
2067 || h->root.type == bfd_link_hash_undefweak
2068 || h->root.type == bfd_link_hash_undefined)
2069 && SYMBOLIC_BIND (info, h))))
6725bdbf 2070 {
12d0ee4a 2071 /* If this reloc is in a read-only section, we might
ebe50bae
AM		 2072 need a copy reloc. We can't check reliably at this
2073 stage whether the section is read-only, as input
2074 sections have not yet been mapped to output sections.
2075 Tentatively set the flag for now, and correct in
2076 adjust_dynamic_symbol. */
f5385ebf 2077 h->non_got_ref = 1;
12d0ee4a
AM		 2078
2079 /* We may need a .plt entry if the function this reloc
2080 refers to is in a shared lib. */
51b64d56 2081 h->plt.refcount += 1;
4b627c18
L		 2082 if (r_type == R_386_PC32)
2083 {
2084 /* Since something like ".long foo - ." may be used
2085 as pointer, make sure that PLT is used if foo is
2086 a function defined in a shared library. */
2087 if ((sec->flags & SEC_CODE) == 0)
2088 h->pointer_equality_needed = 1;
2089 }
2090 else
04ebc307
L		 2091 {
2092 h->pointer_equality_needed = 1;
2093 /* R_386_32 can be resolved at run-time. */
2094 if (r_type == R_386_32
2095 && (sec->flags & SEC_READONLY) == 0)
2096 eh->func_pointer_refcount += 1;
2097 }
6725bdbf 2098 }
7843f00e 2099
06a6a421 2100 size_reloc = FALSE;
6a3e1bae 2101do_size:
252b5132 2102 /* If we are creating a shared library, and this is a reloc
f69da49f
AM		 2103 against a global symbol, or a non PC relative reloc
2104 against a local symbol, then we need to copy the reloc
2105 into the shared library. However, if we are linking with
2106 -Bsymbolic, we do not need to copy a reloc against a
2107 global symbol which is defined in an object we are
2108 including in the link (i.e., DEF_REGULAR is set). At
2109 this point we have not seen all the input files, so it is
2110 possible that DEF_REGULAR is not set now but will be set
1f655a09
L		 2111 later (it is never cleared). In case of a weak definition,
2112 DEF_REGULAR may be cleared later by a strong definition in
ebe50bae 2113 a shared library. We account for that possibility below by
1f655a09
L		 2114 storing information in the relocs_copied field of the hash
2115 table entry. A similar situation occurs when creating
2116 shared libraries and symbol visibility changes render the
12d0ee4a 2117 symbol local.
56882138 2118
12d0ee4a
AM		 2119 If on the other hand, we are creating an executable, we
2120 may need to keep relocations for symbols satisfied by a
2121 dynamic library if we manage to avoid copy relocs for the
2122 symbol. */
0e1862bb 2123 if ((bfd_link_pic (info)
12d0ee4a 2124 && (sec->flags & SEC_ALLOC) != 0
13ae64f3 2125 && (r_type != R_386_PC32
12d0ee4a 2126 || (h != NULL
4e0c91e4
L		 2127 && (! (bfd_link_pie (info)
2128 || SYMBOLIC_BIND (info, h))
12d0ee4a 2129 || h->root.type == bfd_link_hash_defweak
f5385ebf 2130 || !h->def_regular))))
a23b6845 2131 || (ELIMINATE_COPY_RELOCS
0e1862bb 2132 && !bfd_link_pic (info)
12d0ee4a
AM		 2133 && (sec->flags & SEC_ALLOC) != 0
2134 && h != NULL
12d0ee4a 2135 && (h->root.type == bfd_link_hash_defweak
0f88be7a 2136 || !h->def_regular)))
252b5132 2137 {
e03a8ed8
L		 2138 struct elf_dyn_relocs *p;
2139 struct elf_dyn_relocs **head;
ec338859 2140
12d0ee4a
AM		 2141 /* We must copy these reloc types into the output file.
2142 Create a reloc section in dynobj and make room for
2143 this reloc. */
252b5132
RH		 2144 if (sreloc == NULL)
2145 {
0ac8d2ca
AM		 2146 if (htab->elf.dynobj == NULL)
2147 htab->elf.dynobj = abfd;
2148
83bac4b0
NC		 2149 sreloc = _bfd_elf_make_dynamic_reloc_section
2150 (sec, htab->elf.dynobj, 2, abfd, /*rela?*/ FALSE);
2151
252b5132 2152 if (sreloc == NULL)
c337a162 2153 goto error_return;
252b5132
RH		 2154 }
2155
0c715baa
AM		 2156 /* If this is a global symbol, we count the number of
2157 relocations we need for this symbol. */
2158 if (h != NULL)
252b5132 2159 {
d5597ebc 2160 head = &eh->dyn_relocs;
0c715baa
AM		 2161 }
2162 else
2163 {
ec338859
AM		 2164 /* Track dynamic relocs needed for local syms too.
2165 We really need local syms available to do this
2166 easily. Oh well. */
87d72d41 2167 void **vpp;
ec338859 2168 asection *s;
87d72d41
AM		 2169
2170 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2171 abfd, r_symndx);
2172 if (isym == NULL)
c337a162 2173 goto error_return;
87d72d41
AM		 2174
2175 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
ec338859 2176 if (s == NULL)
87d72d41 2177 s = sec;
ec338859 2178
e81d3500 2179 vpp = &elf_section_data (s)->local_dynrel;
e03a8ed8 2180 head = (struct elf_dyn_relocs **)vpp;
ec338859
AM		 2181 }
2182
2183 p = *head;
2184 if (p == NULL || p->sec != sec)
2185 {
2186 bfd_size_type amt = sizeof *p;
a50b1753
NC		 2187 p = (struct elf_dyn_relocs *) bfd_alloc (htab->elf.dynobj,
2188 amt);
ec338859 2189 if (p == NULL)
c337a162 2190 goto error_return;
ec338859
AM		 2191 p->next = *head;
2192 *head = p;
2193 p->sec = sec;
2194 p->count = 0;
2195 p->pc_count = 0;
252b5132 2196 }
ec338859
AM		 2197
2198 p->count += 1;
06a6a421
L		 2199 /* Count size relocation as PC-relative relocation. */
2200 if (r_type == R_386_PC32 || size_reloc)
ec338859 2201 p->pc_count += 1;
252b5132 2202 }
252b5132
RH		 2203 break;
2204
2205 /* This relocation describes the C++ object vtable hierarchy.
2206 Reconstruct it for later use during GC. */
2207 case R_386_GNU_VTINHERIT:
d17e0c6e 2208 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
c337a162 2209 goto error_return;
252b5132
RH		 2210 break;
2211
2212 /* This relocation describes which C++ vtable entries are actually
2213 used. Record for later use during GC. */
2214 case R_386_GNU_VTENTRY:
c6aa130f
MS		 2215 BFD_ASSERT (h != NULL);
2216 if (h != NULL
2217 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
c337a162 2218 goto error_return;
252b5132
RH		 2219 break;
2220
2221 default:
2222 break;
2223 }
dd7e64d4
L		 2224
2225 if (use_plt_got
2226 && h != NULL
2227 && h->plt.refcount > 0
8ded2ddc
L		 2228 && (((info->flags & DF_BIND_NOW) && !h->pointer_equality_needed)
2229 || h->got.refcount > 0)
dd7e64d4
L		 2230 && htab->plt_got == NULL)
2231 {
2232 /* Create the GOT procedure linkage table. */
2233 unsigned int plt_got_align;
2234 const struct elf_backend_data *bed;
2235
2236 bed = get_elf_backend_data (info->output_bfd);
2237 BFD_ASSERT (sizeof (elf_i386_got_plt_entry) == 8
2238 && (sizeof (elf_i386_got_plt_entry)
2239 == sizeof (elf_i386_pic_got_plt_entry)));
2240 plt_got_align = 3;
2241
2242 if (htab->elf.dynobj == NULL)
2243 htab->elf.dynobj = abfd;
2244 htab->plt_got
2245 = bfd_make_section_anyway_with_flags (htab->elf.dynobj,
2246 ".plt.got",
2247 (bed->dynamic_sec_flags
2248 | SEC_ALLOC
2249 | SEC_CODE
2250 | SEC_LOAD
2251 | SEC_READONLY));
2252 if (htab->plt_got == NULL
2253 || !bfd_set_section_alignment (htab->elf.dynobj,
2254 htab->plt_got,
2255 plt_got_align))
c337a162 2256 goto error_return;
dd7e64d4 2257 }
c1d11331 2258
52bf37dd 2259 if (r_type == R_386_GOT32X
c1d11331 2260 && (h == NULL || h->type != STT_GNU_IFUNC))
02a86693 2261 sec->need_convert_load = 1;
252b5132
RH		 2262 }
2263
bedfd056
L		 2264 if (elf_section_data (sec)->this_hdr.contents != contents)
2265 {
2266 if (!info->keep_memory)
2267 free (contents);
2268 else
2269 {
2270 /* Cache the section contents for elf_link_input_bfd. */
2271 elf_section_data (sec)->this_hdr.contents = contents;
2272 }
2273 }
2274
b34976b6 2275 return TRUE;
c337a162
L		 2276
2277error_return:
bedfd056
L		 2278 if (elf_section_data (sec)->this_hdr.contents != contents)
2279 free (contents);
c337a162
L		 2280 sec->check_relocs_failed = 1;
2281 return FALSE;
252b5132
RH		 2282}
2283
2284/* Return the section that should be marked against GC for a given
2285 relocation. */
2286
2287static asection *
55fd94b0 2288elf_i386_gc_mark_hook (asection *sec,
07adf181 2289 struct bfd_link_info *info,
55fd94b0
AM		 2290 Elf_Internal_Rela *rel,
2291 struct elf_link_hash_entry *h,
2292 Elf_Internal_Sym *sym)
252b5132
RH		 2293{
2294 if (h != NULL)
07adf181
AM		 2295 switch (ELF32_R_TYPE (rel->r_info))
2296 {
2297 case R_386_GNU_VTINHERIT:
2298 case R_386_GNU_VTENTRY:
2299 return NULL;
2300 }
2301
2302 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
252b5132
RH		 2303}
2304
aec6b87e
L		 2305/* Remove undefined weak symbol from the dynamic symbol table if it
2306 is resolved to 0. */
2307
2308static bfd_boolean
2309elf_i386_fixup_symbol (struct bfd_link_info *info,
2310 struct elf_link_hash_entry *h)
2311{
2312 if (h->dynindx != -1
2313 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info,
e62b9723 2314 elf_i386_hash_entry (h)->has_got_reloc,
aec6b87e
L		 2315 elf_i386_hash_entry (h)))
2316 {
2317 h->dynindx = -1;
2318 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
2319 h->dynstr_index);
2320 }
2321 return TRUE;
2322}
2323
252b5132
RH		 2324/* Adjust a symbol defined by a dynamic object and referenced by a
2325 regular object. The current definition is in some section of the
2326 dynamic object, but we're not including those sections. We have to
2327 change the definition to something the rest of the link can
2328 understand. */
2329
b34976b6 2330static bfd_boolean
55fd94b0
AM		 2331elf_i386_adjust_dynamic_symbol (struct bfd_link_info *info,
2332 struct elf_link_hash_entry *h)
252b5132 2333{
6725bdbf 2334 struct elf_i386_link_hash_table *htab;
252b5132 2335 asection *s;
5ca5bb35
L		 2336 struct elf_i386_link_hash_entry *eh;
2337 struct elf_dyn_relocs *p;
252b5132 2338
cbe950e9
L		 2339 /* STT_GNU_IFUNC symbol must go through PLT. */
2340 if (h->type == STT_GNU_IFUNC)
2341 {
73bcf233
L		 2342 /* All local STT_GNU_IFUNC references must be treate as local
2343 calls via local PLT. */
5ca5bb35
L		 2344 if (h->ref_regular
2345 && SYMBOL_CALLS_LOCAL (info, h))
2346 {
73bcf233 2347 bfd_size_type pc_count = 0, count = 0;
5ca5bb35
L		 2348 struct elf_dyn_relocs **pp;
2349
2350 eh = (struct elf_i386_link_hash_entry *) h;
2351 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2352 {
2353 pc_count += p->pc_count;
2354 p->count -= p->pc_count;
2355 p->pc_count = 0;
73bcf233 2356 count += p->count;
5ca5bb35
L		 2357 if (p->count == 0)
2358 *pp = p->next;
2359 else
2360 pp = &p->next;
2361 }
2362
73bcf233 2363 if (pc_count || count)
5ca5bb35
L		 2364 {
2365 h->needs_plt = 1;
5ca5bb35 2366 h->non_got_ref = 1;
a5479e5f
L		 2367 if (h->plt.refcount <= 0)
2368 h->plt.refcount = 1;
2369 else
2370 h->plt.refcount += 1;
5ca5bb35
L		 2371 }
2372 }
2373
cbe950e9
L		 2374 if (h->plt.refcount <= 0)
2375 {
2376 h->plt.offset = (bfd_vma) -1;
2377 h->needs_plt = 0;
2378 }
2379 return TRUE;
2380 }
2381
252b5132
RH		 2382 /* If this is a function, put it in the procedure linkage table. We
2383 will fill in the contents of the procedure linkage table later,
2384 when we know the address of the .got section. */
2385 if (h->type == STT_FUNC
f5385ebf 2386 || h->needs_plt)
252b5132 2387 {
6725bdbf 2388 if (h->plt.refcount <= 0
9c7a29a3
AM		 2389 || SYMBOL_CALLS_LOCAL (info, h)
2390 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2391 && h->root.type == bfd_link_hash_undefweak))
252b5132
RH		 2392 {
2393 /* This case can occur if we saw a PLT32 reloc in an input
dd5724d5
AM		 2394 file, but the symbol was never referred to by a dynamic
2395 object, or if all references were garbage collected. In
2396 such a case, we don't actually need to build a procedure
2397 linkage table, and we can just do a PC32 reloc instead. */
bbd7ec4a 2398 h->plt.offset = (bfd_vma) -1;
f5385ebf 2399 h->needs_plt = 0;
252b5132
RH		 2400 }
2401
b34976b6 2402 return TRUE;
252b5132 2403 }
6725bdbf
AM		 2404 else
2405 /* It's possible that we incorrectly decided a .plt reloc was
2406 needed for an R_386_PC32 reloc to a non-function sym in
2407 check_relocs. We can't decide accurately between function and
2408 non-function syms in check-relocs; Objects loaded later in
2409 the link may change h->type. So fix it now. */
bbd7ec4a 2410 h->plt.offset = (bfd_vma) -1;
252b5132
RH		 2411
2412 /* If this is a weak symbol, and there is a real definition, the
2413 processor independent code will have arranged for us to see the
2414 real definition first, and we can just use the same value. */
f6e332e6 2415 if (h->u.weakdef != NULL)
252b5132 2416 {
f6e332e6
AM		 2417 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2418 || h->u.weakdef->root.type == bfd_link_hash_defweak);
2419 h->root.u.def.section = h->u.weakdef->root.u.def.section;
2420 h->root.u.def.value = h->u.weakdef->root.u.def.value;
a23b6845 2421 if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
f6e332e6 2422 h->non_got_ref = h->u.weakdef->non_got_ref;
b34976b6 2423 return TRUE;
252b5132
RH		 2424 }
2425
2426 /* This is a reference to a symbol defined by a dynamic object which
2427 is not a function. */
2428
2429 /* If we are creating a shared library, we must presume that the
2430 only references to the symbol are via the global offset table.
2431 For such cases we need not do anything here; the relocations will
2432 be handled correctly by relocate_section. */
0e1862bb 2433 if (!bfd_link_executable (info))
b34976b6 2434 return TRUE;
252b5132 2435
7843f00e 2436 /* If there are no references to this symbol that do not use the
d5597ebc
L		 2437 GOT nor R_386_GOTOFF relocation, we don't need to generate a copy
2438 reloc. */
2439 eh = (struct elf_i386_link_hash_entry *) h;
2440 if (!h->non_got_ref && !eh->gotoff_ref)
b34976b6 2441 return TRUE;
7843f00e 2442
8bd621d8
AM		 2443 /* If -z nocopyreloc was given, we won't generate them either. */
2444 if (info->nocopyreloc)
2445 {
f5385ebf 2446 h->non_got_ref = 0;
b34976b6 2447 return TRUE;
8bd621d8
AM		 2448 }
2449
643796e3 2450 htab = elf_i386_hash_table (info);
4dfe6ac6
NC		 2451 if (htab == NULL)
2452 return FALSE;
643796e3 2453
d5597ebc
L		 2454 /* If there aren't any dynamic relocs in read-only sections nor
2455 R_386_GOTOFF relocation, then we can keep the dynamic relocs and
2456 avoid the copy reloc. This doesn't work on VxWorks, where we can
2457 not have dynamic relocations (other than copy and jump slot
2458 relocations) in an executable. */
23209a78 2459 if (ELIMINATE_COPY_RELOCS
d5597ebc 2460 && !eh->gotoff_ref
23209a78 2461 && !get_elf_i386_backend_data (info->output_bfd)->is_vxworks)
ebe50bae 2462 {
a23b6845
AM		 2463 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2464 {
2465 s = p->sec->output_section;
2466 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2467 break;
2468 }
2469
a23b6845
AM		 2470 if (p == NULL)
2471 {
f5385ebf 2472 h->non_got_ref = 0;
a23b6845
AM		 2473 return TRUE;
2474 }
ebe50bae
AM		 2475 }
2476
252b5132
RH		 2477 /* We must allocate the symbol in our .dynbss section, which will
2478 become part of the .bss section of the executable. There will be
2479 an entry for this symbol in the .dynsym section. The dynamic
2480 object will contain position independent code, so all references
2481 from the dynamic object to this symbol will go through the global
2482 offset table. The dynamic linker will use the .dynsym entry to
2483 determine the address it must put in the global offset table, so
2484 both the dynamic object and the regular object will refer to the
2485 same memory location for the variable. */
2486
252b5132
RH		 2487 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
2488 copy the initial value out of the dynamic object and into the
0ac8d2ca 2489 runtime process image. */
1d7e9d18 2490 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
252b5132 2491 {
eea6121a 2492 htab->srelbss->size += sizeof (Elf32_External_Rel);
f5385ebf 2493 h->needs_copy = 1;
252b5132
RH		 2494 }
2495
0ac8d2ca 2496 s = htab->sdynbss;
252b5132 2497
6cabe1ea 2498 return _bfd_elf_adjust_dynamic_copy (info, h, s);
252b5132
RH		 2499}
2500
6725bdbf 2501/* Allocate space in .plt, .got and associated reloc sections for
0c715baa 2502 dynamic relocs. */
6725bdbf 2503
b34976b6 2504static bfd_boolean
eb4ff4d6 2505elf_i386_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
6725bdbf
AM		 2506{
2507 struct bfd_link_info *info;
2508 struct elf_i386_link_hash_table *htab;
5a15f56f 2509 struct elf_i386_link_hash_entry *eh;
e03a8ed8 2510 struct elf_dyn_relocs *p;
25e762b9 2511 unsigned plt_entry_size;
aec6b87e 2512 bfd_boolean resolved_to_zero;
6725bdbf 2513
e92d460e 2514 if (h->root.type == bfd_link_hash_indirect)
b34976b6 2515 return TRUE;
6725bdbf 2516
cbe950e9 2517 eh = (struct elf_i386_link_hash_entry *) h;
e92d460e 2518
6725bdbf
AM		 2519 info = (struct bfd_link_info *) inf;
2520 htab = elf_i386_hash_table (info);
4dfe6ac6
NC		 2521 if (htab == NULL)
2522 return FALSE;
6725bdbf 2523
25e762b9
RM		 2524 plt_entry_size = GET_PLT_ENTRY_SIZE (info->output_bfd);
2525
e62b9723
L		 2526 resolved_to_zero = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info,
2527 eh->has_got_reloc,
2528 eh);
aec6b87e 2529
04ebc307
L		 2530 /* Clear the reference count of function pointer relocations if
2531 symbol isn't a normal function. */
2532 if (h->type != STT_FUNC)
2533 eh->func_pointer_refcount = 0;
2534
dd7e64d4
L		 2535 /* We can't use the GOT PLT if pointer equality is needed since
2536 finish_dynamic_symbol won't clear symbol value and the dynamic
2537 linker won't update the GOT slot. We will get into an infinite
2538 loop at run-time. */
2539 if (htab->plt_got != NULL
2540 && h->type != STT_GNU_IFUNC
2541 && !h->pointer_equality_needed
2542 && h->plt.refcount > 0
2543 && h->got.refcount > 0)
2544 {
2545 /* Don't use the regular PLT if there are both GOT and GOTPLT
2546 reloctions. */
2547 h->plt.offset = (bfd_vma) -1;
2548
2549 /* Use the GOT PLT. */
2550 eh->plt_got.refcount = 1;
2551 }
2552
cbe950e9
L		 2553 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2554 here if it is defined and referenced in a non-shared object. */
2555 if (h->type == STT_GNU_IFUNC
2556 && h->def_regular)
25e762b9 2557 return _bfd_elf_allocate_ifunc_dyn_relocs (info, h, &eh->dyn_relocs,
2df3368d
L		 2558 &htab->readonly_dynrelocs_against_ifunc,
2559 plt_entry_size,
7b70956d 2560 plt_entry_size, 4);
04ebc307
L		 2561 /* Don't create the PLT entry if there are only function pointer
2562 relocations which can be resolved at run-time. */
cbe950e9 2563 else if (htab->elf.dynamic_sections_created
04ebc307
L		 2564 && (h->plt.refcount > eh->func_pointer_refcount
2565 || eh->plt_got.refcount > 0))
6725bdbf 2566 {
25070364
L		 2567 bfd_boolean use_plt_got;
2568
04ebc307
L		 2569 /* Clear the reference count of function pointer relocations
2570 if PLT is used. */
2571 eh->func_pointer_refcount = 0;
2572
8ded2ddc 2573 if ((info->flags & DF_BIND_NOW) && !h->pointer_equality_needed)
25070364
L		 2574 {
2575 /* Don't use the regular PLT for DF_BIND_NOW. */
2576 h->plt.offset = (bfd_vma) -1;
2577
2578 /* Use the GOT PLT. */
2579 h->got.refcount = 1;
2580 eh->plt_got.refcount = 1;
2581 }
2582
2583 use_plt_got = eh->plt_got.refcount > 0;
dd7e64d4 2584
5a15f56f
AM		 2585 /* Make sure this symbol is output as a dynamic symbol.
2586 Undefined weak syms won't yet be marked as dynamic. */
2587 if (h->dynindx == -1
aec6b87e
L		 2588 && !h->forced_local
2589 && !resolved_to_zero)
5a15f56f 2590 {
c152c796 2591 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 2592 return FALSE;
5a15f56f
AM		 2593 }
2594
0e1862bb 2595 if (bfd_link_pic (info)
4e795f50 2596 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
ced53ee5 2597 {
6de2ae4a 2598 asection *s = htab->elf.splt;
dd7e64d4 2599 asection *got_s = htab->plt_got;
6725bdbf 2600
7c1e8d3e
L		 2601 /* If this is the first .plt entry, make room for the special
2602 first entry. The .plt section is used by prelink to undo
2603 prelinking for dynamic relocations. */
2604 if (s->size == 0)
2605 s->size = plt_entry_size;
2606
dd7e64d4
L		 2607 if (use_plt_got)
2608 eh->plt_got.offset = got_s->size;
2609 else
7c1e8d3e 2610 h->plt.offset = s->size;
6725bdbf 2611
ced53ee5
AM		 2612 /* If this symbol is not defined in a regular file, and we are
2613 not generating a shared library, then set the symbol to this
2614 location in the .plt. This is required to make function
2615 pointers compare as equal between the normal executable and
2616 the shared library. */
0e1862bb 2617 if (! bfd_link_pic (info)
f5385ebf 2618 && !h->def_regular)
ced53ee5 2619 {
dd7e64d4
L		 2620 if (use_plt_got)
2621 {
2622 /* We need to make a call to the entry of the GOT PLT
2623 instead of regular PLT entry. */
2624 h->root.u.def.section = got_s;
2625 h->root.u.def.value = eh->plt_got.offset;
2626 }
2627 else
2628 {
2629 h->root.u.def.section = s;
2630 h->root.u.def.value = h->plt.offset;
2631 }
ced53ee5 2632 }
6725bdbf 2633
ced53ee5 2634 /* Make room for this entry. */
dd7e64d4
L		 2635 if (use_plt_got)
2636 got_s->size += sizeof (elf_i386_got_plt_entry);
2637 else
2638 {
2639 s->size += plt_entry_size;
6725bdbf 2640
dd7e64d4
L		 2641 /* We also need to make an entry in the .got.plt section,
2642 which will be placed in the .got section by the linker
2643 script. */
2644 htab->elf.sgotplt->size += 4;
6725bdbf 2645
aec6b87e
L		 2646 /* There should be no PLT relocation against resolved
2647 undefined weak symbol in executable. */
2648 if (!resolved_to_zero)
2649 {
2650 /* We also need to make an entry in the .rel.plt
2651 section. */
2652 htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
2653 htab->elf.srelplt->reloc_count++;
2654 }
dd7e64d4 2655 }
eac338cf 2656
23209a78 2657 if (get_elf_i386_backend_data (info->output_bfd)->is_vxworks
0e1862bb 2658 && !bfd_link_pic (info))
eac338cf
PB		 2659 {
2660 /* VxWorks has a second set of relocations for each PLT entry
2661 in executables. They go in a separate relocation section,
2662 which is processed by the kernel loader. */
2663
2664 /* There are two relocations for the initial PLT entry: an
2665 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
2666 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
2667
25e762b9 2668 if (h->plt.offset == plt_entry_size)
eac338cf
PB		 2669 htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
2670
2671 /* There are two extra relocations for each subsequent PLT entry:
2672 an R_386_32 relocation for the GOT entry, and an R_386_32
2673 relocation for the PLT entry. */
2674
2675 htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
2676 }
6725bdbf 2677 }
ced53ee5
AM		 2678 else
2679 {
13f42277 2680 eh->plt_got.offset = (bfd_vma) -1;
51b64d56 2681 h->plt.offset = (bfd_vma) -1;
f5385ebf 2682 h->needs_plt = 0;
ced53ee5 2683 }
6725bdbf
AM		 2684 }
2685 else
2686 {
13f42277 2687 eh->plt_got.offset = (bfd_vma) -1;
51b64d56 2688 h->plt.offset = (bfd_vma) -1;
f5385ebf 2689 h->needs_plt = 0;
6725bdbf
AM		 2690 }
2691
67a4f2b7
AO		 2692 eh->tlsdesc_got = (bfd_vma) -1;
2693
37e55690 2694 /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
13ae64f3
JJ		 2695 make it a R_386_TLS_LE_32 requiring no TLS entry. */
2696 if (h->got.refcount > 0
0e1862bb 2697 && bfd_link_executable (info)
13ae64f3 2698 && h->dynindx == -1
37e55690 2699 && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE))
cedb70c5 2700 h->got.offset = (bfd_vma) -1;
13ae64f3 2701 else if (h->got.refcount > 0)
6725bdbf 2702 {
0ac8d2ca 2703 asection *s;
b34976b6 2704 bfd_boolean dyn;
13ae64f3 2705 int tls_type = elf_i386_hash_entry(h)->tls_type;
6725bdbf 2706
5a15f56f
AM		 2707 /* Make sure this symbol is output as a dynamic symbol.
2708 Undefined weak syms won't yet be marked as dynamic. */
2709 if (h->dynindx == -1
aec6b87e
L		 2710 && !h->forced_local
2711 && !resolved_to_zero)
5a15f56f 2712 {
c152c796 2713 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 2714 return FALSE;
5a15f56f
AM		 2715 }
2716
6de2ae4a 2717 s = htab->elf.sgot;
67a4f2b7
AO		 2718 if (GOT_TLS_GDESC_P (tls_type))
2719 {
6de2ae4a 2720 eh->tlsdesc_got = htab->elf.sgotplt->size
67a4f2b7 2721 - elf_i386_compute_jump_table_size (htab);
6de2ae4a 2722 htab->elf.sgotplt->size += 8;
67a4f2b7
AO		 2723 h->got.offset = (bfd_vma) -2;
2724 }
2725 if (! GOT_TLS_GDESC_P (tls_type)
2726 || GOT_TLS_GD_P (tls_type))
2727 {
2728 h->got.offset = s->size;
2729 s->size += 4;
2730 /* R_386_TLS_GD needs 2 consecutive GOT slots. */
2731 if (GOT_TLS_GD_P (tls_type) || tls_type == GOT_TLS_IE_BOTH)
2732 s->size += 4;
2733 }
ebe50bae 2734 dyn = htab->elf.dynamic_sections_created;
13ae64f3 2735 /* R_386_TLS_IE_32 needs one dynamic relocation,
37e55690
JJ		 2736 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
2737 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
2738 need two), R_386_TLS_GD needs one if local symbol and two if
aec6b87e
L		 2739 global. No dynamic relocation against resolved undefined weak
2740 symbol in executable. */
37e55690 2741 if (tls_type == GOT_TLS_IE_BOTH)
6de2ae4a 2742 htab->elf.srelgot->size += 2 * sizeof (Elf32_External_Rel);
67a4f2b7 2743 else if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
37e55690 2744 || (tls_type & GOT_TLS_IE))
6de2ae4a 2745 htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
67a4f2b7 2746 else if (GOT_TLS_GD_P (tls_type))
6de2ae4a 2747 htab->elf.srelgot->size += 2 * sizeof (Elf32_External_Rel);
67a4f2b7 2748 else if (! GOT_TLS_GDESC_P (tls_type)
aec6b87e
L		 2749 && ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2750 && !resolved_to_zero)
67a4f2b7 2751 || h->root.type != bfd_link_hash_undefweak)
0e1862bb 2752 && (bfd_link_pic (info)
ef5aade5 2753 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
6de2ae4a 2754 htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
67a4f2b7 2755 if (GOT_TLS_GDESC_P (tls_type))
6de2ae4a 2756 htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
6725bdbf
AM		 2757 }
2758 else
51b64d56 2759 h->got.offset = (bfd_vma) -1;
6725bdbf 2760
5a15f56f 2761 if (eh->dyn_relocs == NULL)
b34976b6 2762 return TRUE;
5a15f56f 2763
0c715baa
AM		 2764 /* In the shared -Bsymbolic case, discard space allocated for
2765 dynamic pc-relative relocs against symbols which turn out to be
2766 defined in regular objects. For the normal shared case, discard
0ac8d2ca
AM		 2767 space for pc-relative relocs that have become local due to symbol
2768 visibility changes. */
0c715baa 2769
0e1862bb 2770 if (bfd_link_pic (info))
5a15f56f 2771 {
09695f56
AM		 2772 /* The only reloc that uses pc_count is R_386_PC32, which will
2773 appear on a call or on something like ".long foo - .". We
2774 want calls to protected symbols to resolve directly to the
2775 function rather than going via the plt. If people want
2776 function pointer comparisons to work as expected then they
2777 should avoid writing assembly like ".long foo - .". */
2778 if (SYMBOL_CALLS_LOCAL (info, h))
5a15f56f 2779 {
e03a8ed8 2780 struct elf_dyn_relocs **pp;
0c715baa
AM		 2781
2782 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2783 {
c3ce498c
L		 2784 p->count -= p->pc_count;
2785 p->pc_count = 0;
0c715baa
AM		 2786 if (p->count == 0)
2787 *pp = p->next;
2788 else
2789 pp = &p->next;
2790 }
5a15f56f 2791 }
4e795f50 2792
23209a78 2793 if (get_elf_i386_backend_data (info->output_bfd)->is_vxworks)
3348747a 2794 {
e03a8ed8 2795 struct elf_dyn_relocs **pp;
3348747a
NS		 2796 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2797 {
2798 if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
2799 *pp = p->next;
2800 else
2801 pp = &p->next;
2802 }
2803 }
2804
4e795f50 2805 /* Also discard relocs on undefined weak syms with non-default
aec6b87e 2806 visibility or in PIE. */
22d606e9 2807 if (eh->dyn_relocs != NULL
c353e543 2808 && h->root.type == bfd_link_hash_undefweak)
22d606e9 2809 {
aec6b87e
L		 2810 /* Undefined weak symbol is never bound locally in shared
2811 library. */
2812 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2813 || resolved_to_zero)
2814 {
2815 if (h->non_got_ref)
2816 {
2817 /* Keep dynamic non-GOT/non-PLT relocation so that we
2818 can branch to 0 without PLT. */
2819 struct elf_dyn_relocs **pp;
2820
2821 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2822 if (p->pc_count == 0)
2823 *pp = p->next;
2824 else
2825 {
2826 /* Remove non-R_386_PC32 relocation. */
2827 p->count = p->pc_count;
2828 pp = &p->next;
2829 }
22d606e9 2830
aec6b87e
L		 2831 if (eh->dyn_relocs != NULL)
2832 {
2833 /* Make sure undefined weak symbols are output
2834 as dynamic symbols in PIEs for dynamic non-GOT
2835 non-PLT reloations. */
2836 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2837 return FALSE;
2838 }
2839 }
2840 else
2841 eh->dyn_relocs = NULL;
2842 }
22d606e9
AM		 2843 else if (h->dynindx == -1
2844 && !h->forced_local)
2845 {
2846 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2847 return FALSE;
2848 }
2849 }
0c715baa 2850 }
a23b6845 2851 else if (ELIMINATE_COPY_RELOCS)
0c715baa
AM		 2852 {
2853 /* For the non-shared case, discard space for relocs against
2854 symbols which turn out to need copy relocs or are not
04ebc307
L		 2855 dynamic. Keep dynamic relocations for run-time function
2856 pointer initialization. */
0c715baa 2857
aec6b87e
L		 2858 if ((!h->non_got_ref
2859 || eh->func_pointer_refcount > 0
2860 || (h->root.type == bfd_link_hash_undefweak
2861 && !resolved_to_zero))
f5385ebf
AM		 2862 && ((h->def_dynamic
2863 && !h->def_regular)
ebe50bae 2864 || (htab->elf.dynamic_sections_created
0c715baa
AM		 2865 && (h->root.type == bfd_link_hash_undefweak
2866 || h->root.type == bfd_link_hash_undefined))))
2867 {
2868 /* Make sure this symbol is output as a dynamic symbol.
2869 Undefined weak syms won't yet be marked as dynamic. */
2870 if (h->dynindx == -1
aec6b87e
L		 2871 && !h->forced_local
2872 && !resolved_to_zero)
0c715baa 2873 {
c152c796 2874 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 2875 return FALSE;
0c715baa 2876 }
5a15f56f 2877
0c715baa
AM		 2878 /* If that succeeded, we know we'll be keeping all the
2879 relocs. */
2880 if (h->dynindx != -1)
2881 goto keep;
2882 }
2883
2884 eh->dyn_relocs = NULL;
04ebc307 2885 eh->func_pointer_refcount = 0;
0c715baa 2886
ec338859 2887 keep: ;
5a15f56f
AM		 2888 }
2889
0c715baa
AM		 2890 /* Finally, allocate space. */
2891 for (p = eh->dyn_relocs; p != NULL; p = p->next)
12d0ee4a 2892 {
e7c33416
NC		 2893 asection *sreloc;
2894
cbe950e9 2895 sreloc = elf_section_data (p->sec)->sreloc;
e7c33416
NC		 2896
2897 BFD_ASSERT (sreloc != NULL);
eea6121a 2898 sreloc->size += p->count * sizeof (Elf32_External_Rel);
12d0ee4a
AM		 2899 }
2900
b34976b6 2901 return TRUE;
6725bdbf
AM		 2902}
2903
c25bc9fc
L		 2904/* Allocate space in .plt, .got and associated reloc sections for
2905 local dynamic relocs. */
2906
2907static bfd_boolean
2908elf_i386_allocate_local_dynrelocs (void **slot, void *inf)
2909{
2910 struct elf_link_hash_entry *h
2911 = (struct elf_link_hash_entry *) *slot;
2912
2913 if (h->type != STT_GNU_IFUNC
2914 || !h->def_regular
2915 || !h->ref_regular
2916 || !h->forced_local
2917 || h->root.type != bfd_link_hash_defined)
2918 abort ();
2919
2920 return elf_i386_allocate_dynrelocs (h, inf);
2921}
2922
0c715baa
AM		 2923/* Find any dynamic relocs that apply to read-only sections. */
2924
b34976b6 2925static bfd_boolean
eb4ff4d6 2926elf_i386_readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
0c715baa
AM		 2927{
2928 struct elf_i386_link_hash_entry *eh;
e03a8ed8 2929 struct elf_dyn_relocs *p;
0c715baa 2930
aa715242
L		 2931 /* Skip local IFUNC symbols. */
2932 if (h->forced_local && h->type == STT_GNU_IFUNC)
2933 return TRUE;
2934
0c715baa
AM		 2935 eh = (struct elf_i386_link_hash_entry *) h;
2936 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2937 {
2938 asection *s = p->sec->output_section;
2939
2940 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2941 {
2942 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2943
2944 info->flags |= DF_TEXTREL;
2945
0e1862bb 2946 if ((info->warn_shared_textrel && bfd_link_pic (info))
1952c5cd
L		 2947 || info->error_textrel)
2948 info->callbacks->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
b70321a2
L		 2949 p->sec->owner, h->root.root.string,
2950 p->sec);
2951
0c715baa 2952 /* Not an error, just cut short the traversal. */
b34976b6 2953 return FALSE;
0c715baa
AM		 2954 }
2955 }
b34976b6 2956 return TRUE;
0c715baa
AM		 2957}
2958
c175a657 2959/* Convert load via the GOT slot to load immediate. */
daa67607
L		 2960
2961static bfd_boolean
02a86693 2962elf_i386_convert_load (bfd *abfd, asection *sec,
a6af384b 2963 struct bfd_link_info *link_info)
daa67607 2964{
c175a657 2965 struct elf_i386_link_hash_table *htab;
daa67607
L		 2966 Elf_Internal_Shdr *symtab_hdr;
2967 Elf_Internal_Rela *internal_relocs;
2968 Elf_Internal_Rela *irel, *irelend;
2969 bfd_byte *contents;
c175a657 2970 bfd_boolean changed;
daa67607
L		 2971 bfd_signed_vma *local_got_refcounts;
2972
2973 /* Don't even try to convert non-ELF outputs. */
2974 if (!is_elf_hash_table (link_info->hash))
2975 return FALSE;
2976
c1d11331 2977 /* Nothing to do if there is no need or no output. */
daa67607 2978 if ((sec->flags & (SEC_CODE | SEC_RELOC)) != (SEC_CODE | SEC_RELOC)
02a86693 2979 || sec->need_convert_load == 0
c8831961 2980 || bfd_is_abs_section (sec->output_section))
daa67607
L		 2981 return TRUE;
2982
2983 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2984
2985 /* Load the relocations for this section. */
2986 internal_relocs = (_bfd_elf_link_read_relocs
2987 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
2988 link_info->keep_memory));
2989 if (internal_relocs == NULL)
2990 return FALSE;
2991
c175a657 2992 changed = FALSE;
daa67607 2993 htab = elf_i386_hash_table (link_info);
daa67607
L		 2994 local_got_refcounts = elf_local_got_refcounts (abfd);
2995
2996 /* Get the section contents. */
2997 if (elf_section_data (sec)->this_hdr.contents != NULL)
2998 contents = elf_section_data (sec)->this_hdr.contents;
2999 else
3000 {
3001 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
3002 goto error_return;
3003 }
3004
3005 irelend = internal_relocs + sec->reloc_count;
3006 for (irel = internal_relocs; irel < irelend; irel++)
3007 {
3008 unsigned int r_type = ELF32_R_TYPE (irel->r_info);
c175a657 3009 unsigned int r_symndx;
daa67607 3010 struct elf_link_hash_entry *h;
c175a657 3011 bfd_boolean converted;
daa67607 3012
7d4d9709
L		 3013 /* Don't convert R_386_GOT32 since we can't tell if it is applied
3014 to "mov $foo@GOT, %reg" which isn't a load via GOT. */
3015 if (r_type != R_386_GOT32X)
daa67607
L		 3016 continue;
3017
c175a657 3018 r_symndx = ELF32_R_SYM (irel->r_info);
02a86693 3019 if (r_symndx < symtab_hdr->sh_info)
c175a657
L		 3020 h = elf_i386_get_local_sym_hash (htab, sec->owner,
3021 (const Elf_Internal_Rela *) irel,
3022 FALSE);
3023 else
02a86693 3024 {
c175a657
L		 3025 h = elf_sym_hashes (abfd)[r_symndx - symtab_hdr->sh_info];
3026 while (h->root.type == bfd_link_hash_indirect
3027 || h->root.type == bfd_link_hash_warning)
3028 h = (struct elf_link_hash_entry *) h->root.u.i.link;
daa67607
L		 3029 }
3030
02a86693 3031 /* STT_GNU_IFUNC must keep GOT32 relocations. */
c175a657 3032 if (h != NULL && h->type == STT_GNU_IFUNC)
02a86693
L		 3033 continue;
3034
c175a657
L		 3035 converted = FALSE;
3036 if (!elf_i386_convert_load_reloc (abfd, symtab_hdr, contents,
3037 irel, h, &converted, link_info))
3038 goto error_return;
bae420ef 3039
c175a657 3040 if (converted)
02a86693 3041 {
c175a657
L		 3042 changed = converted;
3043 if (h)
02a86693 3044 {
c175a657
L		 3045 if (h->got.refcount > 0)
3046 h->got.refcount -= 1;
02a86693 3047 }
c175a657 3048 else
02a86693 3049 {
c175a657
L		 3050 if (local_got_refcounts != NULL
3051 && local_got_refcounts[r_symndx] > 0)
3052 local_got_refcounts[r_symndx] -= 1;
02a86693 3053 }
daa67607
L		 3054 }
3055 }
3056
3057 if (contents != NULL
3058 && elf_section_data (sec)->this_hdr.contents != contents)
3059 {
c175a657 3060 if (!changed && !link_info->keep_memory)
daa67607
L		 3061 free (contents);
3062 else
3063 {
3064 /* Cache the section contents for elf_link_input_bfd. */
3065 elf_section_data (sec)->this_hdr.contents = contents;
3066 }
3067 }
3068
3069 if (elf_section_data (sec)->relocs != internal_relocs)
3070 {
c175a657 3071 if (!changed)
daa67607
L		 3072 free (internal_relocs);
3073 else
3074 elf_section_data (sec)->relocs = internal_relocs;
3075 }
3076
3077 return TRUE;
3078
3079 error_return:
3080 if (contents != NULL
3081 && elf_section_data (sec)->this_hdr.contents != contents)
3082 free (contents);
3083 if (internal_relocs != NULL
3084 && elf_section_data (sec)->relocs != internal_relocs)
3085 free (internal_relocs);
3086 return FALSE;
3087}
3088
252b5132
RH		 3089/* Set the sizes of the dynamic sections. */
3090
b34976b6 3091static bfd_boolean
23209a78 3092elf_i386_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
252b5132 3093{
6725bdbf 3094 struct elf_i386_link_hash_table *htab;
252b5132
RH		 3095 bfd *dynobj;
3096 asection *s;
b34976b6 3097 bfd_boolean relocs;
0c715baa 3098 bfd *ibfd;
252b5132 3099
6725bdbf 3100 htab = elf_i386_hash_table (info);
4dfe6ac6
NC		 3101 if (htab == NULL)
3102 return FALSE;
ebe50bae 3103 dynobj = htab->elf.dynobj;
ffb2e45b
AM		 3104 if (dynobj == NULL)
3105 abort ();
252b5132 3106
0c715baa
AM		 3107 /* Set up .got offsets for local syms, and space for local dynamic
3108 relocs. */
c72f2fb2 3109 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
161d71a6
L		 3110 {
3111 bfd_signed_vma *local_got;
3112 bfd_signed_vma *end_local_got;
13ae64f3 3113 char *local_tls_type;
67a4f2b7 3114 bfd_vma *local_tlsdesc_gotent;
161d71a6
L		 3115 bfd_size_type locsymcount;
3116 Elf_Internal_Shdr *symtab_hdr;
3117 asection *srel;
6725bdbf 3118
0ffa91dd 3119 if (! is_i386_elf (ibfd))
161d71a6 3120 continue;
6725bdbf 3121
0c715baa
AM		 3122 for (s = ibfd->sections; s != NULL; s = s->next)
3123 {
e03a8ed8 3124 struct elf_dyn_relocs *p;
0c715baa 3125
02a86693 3126 if (!elf_i386_convert_load (ibfd, s, info))
daa67607
L		 3127 return FALSE;
3128
e03a8ed8 3129 for (p = ((struct elf_dyn_relocs *)
e81d3500 3130 elf_section_data (s)->local_dynrel);
ec338859
AM		 3131 p != NULL;
3132 p = p->next)
0c715baa 3133 {
ec338859
AM		 3134 if (!bfd_is_abs_section (p->sec)
3135 && bfd_is_abs_section (p->sec->output_section))
3136 {
3137 /* Input section has been discarded, either because
3138 it is a copy of a linkonce section or due to
3139 linker script /DISCARD/, so we'll be discarding
3140 the relocs too. */
3141 }
23209a78 3142 else if (get_elf_i386_backend_data (output_bfd)->is_vxworks
3348747a
NS		 3143 && strcmp (p->sec->output_section->name,
3144 ".tls_vars") == 0)
3145 {
3146 /* Relocations in vxworks .tls_vars sections are
3147 handled specially by the loader. */
3148 }
248866a8 3149 else if (p->count != 0)
ec338859
AM		 3150 {
3151 srel = elf_section_data (p->sec)->sreloc;
eea6121a 3152 srel->size += p->count * sizeof (Elf32_External_Rel);
4b819e1f
L		 3153 if ((p->sec->output_section->flags & SEC_READONLY) != 0
3154 && (info->flags & DF_TEXTREL) == 0)
b70321a2
L		 3155 {
3156 info->flags |= DF_TEXTREL;
0e1862bb 3157 if ((info->warn_shared_textrel && bfd_link_pic (info))
1952c5cd
L		 3158 || info->error_textrel)
3159 info->callbacks->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
b70321a2 3160 p->sec->owner, p->sec);
b70321a2 3161 }
ec338859 3162 }
0c715baa
AM		 3163 }
3164 }
3165
3166 local_got = elf_local_got_refcounts (ibfd);
161d71a6
L		 3167 if (!local_got)
3168 continue;
6725bdbf 3169
0ffa91dd 3170 symtab_hdr = &elf_symtab_hdr (ibfd);
161d71a6
L		 3171 locsymcount = symtab_hdr->sh_info;
3172 end_local_got = local_got + locsymcount;
13ae64f3 3173 local_tls_type = elf_i386_local_got_tls_type (ibfd);
67a4f2b7 3174 local_tlsdesc_gotent = elf_i386_local_tlsdesc_gotent (ibfd);
6de2ae4a
L		 3175 s = htab->elf.sgot;
3176 srel = htab->elf.srelgot;
67a4f2b7
AO		 3177 for (; local_got < end_local_got;
3178 ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
161d71a6 3179 {
67a4f2b7 3180 *local_tlsdesc_gotent = (bfd_vma) -1;
161d71a6 3181 if (*local_got > 0)
6725bdbf 3182 {
67a4f2b7
AO		 3183 if (GOT_TLS_GDESC_P (*local_tls_type))
3184 {
6de2ae4a 3185 *local_tlsdesc_gotent = htab->elf.sgotplt->size
67a4f2b7 3186 - elf_i386_compute_jump_table_size (htab);
6de2ae4a 3187 htab->elf.sgotplt->size += 8;
67a4f2b7
AO		 3188 *local_got = (bfd_vma) -2;
3189 }
3190 if (! GOT_TLS_GDESC_P (*local_tls_type)
3191 || GOT_TLS_GD_P (*local_tls_type))
3192 {
3193 *local_got = s->size;
3194 s->size += 4;
3195 if (GOT_TLS_GD_P (*local_tls_type)
3196 || *local_tls_type == GOT_TLS_IE_BOTH)
3197 s->size += 4;
3198 }
0e1862bb 3199 if (bfd_link_pic (info)
67a4f2b7 3200 || GOT_TLS_GD_ANY_P (*local_tls_type)
37e55690
JJ		 3201 || (*local_tls_type & GOT_TLS_IE))
3202 {
3203 if (*local_tls_type == GOT_TLS_IE_BOTH)
eea6121a 3204 srel->size += 2 * sizeof (Elf32_External_Rel);
67a4f2b7
AO		 3205 else if (GOT_TLS_GD_P (*local_tls_type)
3206 || ! GOT_TLS_GDESC_P (*local_tls_type))
eea6121a 3207 srel->size += sizeof (Elf32_External_Rel);
67a4f2b7 3208 if (GOT_TLS_GDESC_P (*local_tls_type))
6de2ae4a 3209 htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
37e55690 3210 }
6725bdbf 3211 }
161d71a6
L		 3212 else
3213 *local_got = (bfd_vma) -1;
6725bdbf 3214 }
252b5132 3215 }
6725bdbf 3216
13ae64f3
JJ		 3217 if (htab->tls_ldm_got.refcount > 0)
3218 {
3219 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
3220 relocs. */
6de2ae4a
L		 3221 htab->tls_ldm_got.offset = htab->elf.sgot->size;
3222 htab->elf.sgot->size += 8;
3223 htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
13ae64f3
JJ		 3224 }
3225 else
3226 htab->tls_ldm_got.offset = -1;
3227
0c715baa
AM		 3228 /* Allocate global sym .plt and .got entries, and space for global
3229 sym dynamic relocs. */
eb4ff4d6 3230 elf_link_hash_traverse (&htab->elf, elf_i386_allocate_dynrelocs, info);
252b5132 3231
c25bc9fc
L		 3232 /* Allocate .plt and .got entries, and space for local symbols. */
3233 htab_traverse (htab->loc_hash_table,
3234 elf_i386_allocate_local_dynrelocs,
3235 info);
3236
67a4f2b7
AO		 3237 /* For every jump slot reserved in the sgotplt, reloc_count is
3238 incremented. However, when we reserve space for TLS descriptors,
3239 it's not incremented, so in order to compute the space reserved
3240 for them, it suffices to multiply the reloc count by the jump
e1f98742 3241 slot size.
caa0075c 3242
e1f98742
L		 3243 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3244 so that R_386_IRELATIVE entries come last. */
6de2ae4a 3245 if (htab->elf.srelplt)
e1f98742
L		 3246 {
3247 htab->next_tls_desc_index = htab->elf.srelplt->reloc_count;
3248 htab->sgotplt_jump_table_size = htab->next_tls_desc_index * 4;
3249 htab->next_irelative_index = htab->elf.srelplt->reloc_count - 1;
3250 }
3251 else if (htab->elf.irelplt)
3252 htab->next_irelative_index = htab->elf.irelplt->reloc_count - 1;
3253
67a4f2b7 3254
a7b16ceb
L		 3255 if (htab->elf.sgotplt)
3256 {
3257 /* Don't allocate .got.plt section if there are no GOT nor PLT
9a2a56cc 3258 entries and there is no reference to _GLOBAL_OFFSET_TABLE_. */
9d4b2dba
L		 3259 if ((htab->elf.hgot == NULL
3260 || !htab->elf.hgot->ref_regular_nonweak)
e28df02b
L		 3261 && (htab->elf.sgotplt->size
3262 == get_elf_backend_data (output_bfd)->got_header_size)
a7b16ceb
L		 3263 && (htab->elf.splt == NULL
3264 || htab->elf.splt->size == 0)
3265 && (htab->elf.sgot == NULL
3266 || htab->elf.sgot->size == 0)
3267 && (htab->elf.iplt == NULL
3268 || htab->elf.iplt->size == 0)
3269 && (htab->elf.igotplt == NULL
3270 || htab->elf.igotplt->size == 0))
3271 htab->elf.sgotplt->size = 0;
3272 }
3273
9a2a56cc
AM		 3274
3275 if (htab->plt_eh_frame != NULL
3276 && htab->elf.splt != NULL
3277 && htab->elf.splt->size != 0
3278 && !bfd_is_abs_section (htab->elf.splt->output_section)
3279 && _bfd_elf_eh_frame_present (info))
3280 htab->plt_eh_frame->size = sizeof (elf_i386_eh_frame_plt);
3281
5a15f56f
AM		 3282 /* We now have determined the sizes of the various dynamic sections.
3283 Allocate memory for them. */
b34976b6 3284 relocs = FALSE;
252b5132
RH		 3285 for (s = dynobj->sections; s != NULL; s = s->next)
3286 {
eac338cf
PB		 3287 bfd_boolean strip_section = TRUE;
3288
252b5132
RH		 3289 if ((s->flags & SEC_LINKER_CREATED) == 0)
3290 continue;
3291
6de2ae4a 3292 if (s == htab->elf.splt
9a2a56cc 3293 || s == htab->elf.sgot)
252b5132 3294 {
6725bdbf
AM		 3295 /* Strip this section if we don't need it; see the
3296 comment below. */
eac338cf
PB		 3297 /* We'd like to strip these sections if they aren't needed, but if
3298 we've exported dynamic symbols from them we must leave them.
3299 It's too late to tell BFD to get rid of the symbols. */
3300
7325306f 3301 if (htab->elf.hplt != NULL)
eac338cf 3302 strip_section = FALSE;
252b5132 3303 }
9a2a56cc
AM		 3304 else if (s == htab->elf.sgotplt
3305 || s == htab->elf.iplt
3306 || s == htab->elf.igotplt
dd7e64d4 3307 || s == htab->plt_got
9a2a56cc
AM		 3308 || s == htab->plt_eh_frame
3309 || s == htab->sdynbss)
3310 {
3311 /* Strip these too. */
3312 }
0112cd26 3313 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rel"))
252b5132 3314 {
6de2ae4a
L		 3315 if (s->size != 0
3316 && s != htab->elf.srelplt
3317 && s != htab->srelplt2)
b34976b6 3318 relocs = TRUE;
252b5132 3319
0ac8d2ca
AM		 3320 /* We use the reloc_count field as a counter if we need
3321 to copy relocs into the output file. */
5ae0bfb6 3322 s->reloc_count = 0;
252b5132 3323 }
6725bdbf 3324 else
252b5132
RH		 3325 {
3326 /* It's not one of our sections, so don't allocate space. */
3327 continue;
3328 }
3329
c456f082 3330 if (s->size == 0)
252b5132 3331 {
0ac8d2ca
AM		 3332 /* If we don't need this section, strip it from the
3333 output file. This is mostly to handle .rel.bss and
3334 .rel.plt. We must create both sections in
3335 create_dynamic_sections, because they must be created
3336 before the linker maps input sections to output
3337 sections. The linker does that before
3338 adjust_dynamic_symbol is called, and it is that
3339 function which decides whether anything needs to go
3340 into these sections. */
c456f082
AM		 3341 if (strip_section)
3342 s->flags |= SEC_EXCLUDE;
252b5132
RH		 3343 continue;
3344 }
3345
c456f082
AM		 3346 if ((s->flags & SEC_HAS_CONTENTS) == 0)
3347 continue;
3348
f69da49f
AM		 3349 /* Allocate memory for the section contents. We use bfd_zalloc
3350 here in case unused entries are not reclaimed before the
3351 section's contents are written out. This should not happen,
3352 but this way if it does, we get a R_386_NONE reloc instead
3353 of garbage. */
a50b1753 3354 s->contents = (unsigned char *) bfd_zalloc (dynobj, s->size);
6725bdbf 3355 if (s->contents == NULL)
b34976b6 3356 return FALSE;
252b5132
RH		 3357 }
3358
e41b3a13 3359 if (htab->plt_eh_frame != NULL
9a2a56cc
AM		 3360 && htab->plt_eh_frame->contents != NULL)
3361 {
3362 memcpy (htab->plt_eh_frame->contents, elf_i386_eh_frame_plt,
3363 sizeof (elf_i386_eh_frame_plt));
3364 bfd_put_32 (dynobj, htab->elf.splt->size,
3365 htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET);
3366 }
e41b3a13 3367
ebe50bae 3368 if (htab->elf.dynamic_sections_created)
252b5132
RH		 3369 {
3370 /* Add some entries to the .dynamic section. We fill in the
3371 values later, in elf_i386_finish_dynamic_sections, but we
3372 must add the entries now so that we get the correct size for
3373 the .dynamic section. The DT_DEBUG entry is filled in by the
3374 dynamic linker and used by the debugger. */
dc810e39 3375#define add_dynamic_entry(TAG, VAL) \
5a580b3a 3376 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
dc810e39 3377
0e1862bb 3378 if (bfd_link_executable (info))
252b5132 3379 {
dc810e39 3380 if (!add_dynamic_entry (DT_DEBUG, 0))
b34976b6 3381 return FALSE;
252b5132
RH		 3382 }
3383
6de2ae4a 3384 if (htab->elf.splt->size != 0)
252b5132 3385 {
7c1e8d3e
L		 3386 /* DT_PLTGOT is used by prelink even if there is no PLT
3387 relocation. */
3388 if (!add_dynamic_entry (DT_PLTGOT, 0))
b34976b6 3389 return FALSE;
7c1e8d3e
L		 3390
3391 if (htab->elf.srelplt->size != 0)
3392 {
3393 if (!add_dynamic_entry (DT_PLTRELSZ, 0)
3394 || !add_dynamic_entry (DT_PLTREL, DT_REL)
3395 || !add_dynamic_entry (DT_JMPREL, 0))
3396 return FALSE;
3397 }
252b5132
RH		 3398 }
3399
3400 if (relocs)
3401 {
dc810e39
AM		 3402 if (!add_dynamic_entry (DT_REL, 0)
3403 || !add_dynamic_entry (DT_RELSZ, 0)
3404 || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
b34976b6 3405 return FALSE;
252b5132 3406
0c715baa
AM		 3407 /* If any dynamic relocs apply to a read-only section,
3408 then we need a DT_TEXTREL entry. */
248866a8 3409 if ((info->flags & DF_TEXTREL) == 0)
eb4ff4d6
L		 3410 elf_link_hash_traverse (&htab->elf,
3411 elf_i386_readonly_dynrelocs, info);
0c715baa
AM		 3412
3413 if ((info->flags & DF_TEXTREL) != 0)
3414 {
2df3368d 3415 if (htab->readonly_dynrelocs_against_ifunc)
8efa2874
L		 3416 {
3417 info->callbacks->einfo
3418 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
3419 bfd_set_error (bfd_error_bad_value);
3420 return FALSE;
3421 }
3422
0c715baa 3423 if (!add_dynamic_entry (DT_TEXTREL, 0))
b34976b6 3424 return FALSE;
0c715baa 3425 }
252b5132 3426 }
23209a78 3427 if (get_elf_i386_backend_data (output_bfd)->is_vxworks
7a2b07ff
NS		 3428 && !elf_vxworks_add_dynamic_entries (output_bfd, info))
3429 return FALSE;
252b5132 3430 }
dc810e39 3431#undef add_dynamic_entry
252b5132 3432
b34976b6 3433 return TRUE;
252b5132
RH		 3434}
3435
67a4f2b7
AO		 3436static bfd_boolean
3437elf_i386_always_size_sections (bfd *output_bfd,
3438 struct bfd_link_info *info)
3439{
3440 asection *tls_sec = elf_hash_table (info)->tls_sec;
3441
3442 if (tls_sec)
3443 {
3444 struct elf_link_hash_entry *tlsbase;
3445
3446 tlsbase = elf_link_hash_lookup (elf_hash_table (info),
3447 "_TLS_MODULE_BASE_",
3448 FALSE, FALSE, FALSE);
3449
3450 if (tlsbase && tlsbase->type == STT_TLS)
3451 {
4dfe6ac6 3452 struct elf_i386_link_hash_table *htab;
67a4f2b7
AO		 3453 struct bfd_link_hash_entry *bh = NULL;
3454 const struct elf_backend_data *bed
3455 = get_elf_backend_data (output_bfd);
3456
4dfe6ac6
NC		 3457 htab = elf_i386_hash_table (info);
3458 if (htab == NULL)
3459 return FALSE;
3460
67a4f2b7
AO		 3461 if (!(_bfd_generic_link_add_one_symbol
3462 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
3463 tls_sec, 0, NULL, FALSE,
3464 bed->collect, &bh)))
3465 return FALSE;
9f03412a 3466
4dfe6ac6 3467 htab->tls_module_base = bh;
9f03412a 3468
67a4f2b7
AO		 3469 tlsbase = (struct elf_link_hash_entry *)bh;
3470 tlsbase->def_regular = 1;
3471 tlsbase->other = STV_HIDDEN;
576fa883 3472 tlsbase->root.linker_def = 1;
67a4f2b7
AO		 3473 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
3474 }
3475 }
3476
3477 return TRUE;
3478}
3479
38701953
AM		 3480/* Set the correct type for an x86 ELF section. We do this by the
3481 section name, which is a hack, but ought to work. */
3482
b34976b6 3483static bfd_boolean
55fd94b0
AM		 3484elf_i386_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
3485 Elf_Internal_Shdr *hdr,
3486 asection *sec)
38701953 3487{
91d6fa6a 3488 const char *name;
38701953
AM		 3489
3490 name = bfd_get_section_name (abfd, sec);
3491
3492 /* This is an ugly, but unfortunately necessary hack that is
3493 needed when producing EFI binaries on x86. It tells
3494 elf.c:elf_fake_sections() not to consider ".reloc" as a section
3495 containing ELF relocation info. We need this hack in order to
3496 be able to generate ELF binaries that can be translated into
3497 EFI applications (which are essentially COFF objects). Those
3498 files contain a COFF ".reloc" section inside an ELFNN object,
3499 which would normally cause BFD to segfault because it would
3500 attempt to interpret this section as containing relocation
3501 entries for section "oc". With this hack enabled, ".reloc"
3502 will be treated as a normal data section, which will avoid the
3503 segfault. However, you won't be able to create an ELFNN binary
3504 with a section named "oc" that needs relocations, but that's
3505 the kind of ugly side-effects you get when detecting section
3506 types based on their names... In practice, this limitation is
3507 unlikely to bite. */
3508 if (strcmp (name, ".reloc") == 0)
3509 hdr->sh_type = SHT_PROGBITS;
3510
b34976b6 3511 return TRUE;
38701953
AM		 3512}
3513
9f03412a
AO		 3514/* _TLS_MODULE_BASE_ needs to be treated especially when linking
3515 executables. Rather than setting it to the beginning of the TLS
3516 section, we have to set it to the end. This function may be called
3517 multiple times, it is idempotent. */
3518
3519static void
eb4ff4d6 3520elf_i386_set_tls_module_base (struct bfd_link_info *info)
9f03412a 3521{
4dfe6ac6 3522 struct elf_i386_link_hash_table *htab;
9f03412a
AO		 3523 struct bfd_link_hash_entry *base;
3524
0e1862bb 3525 if (!bfd_link_executable (info))
9f03412a
AO		 3526 return;
3527
4dfe6ac6
NC		 3528 htab = elf_i386_hash_table (info);
3529 if (htab == NULL)
3530 return;
9f03412a 3531
4dfe6ac6
NC		 3532 base = htab->tls_module_base;
3533 if (base == NULL)
9f03412a
AO		 3534 return;
3535
4dfe6ac6 3536 base->u.def.value = htab->elf.tls_size;
9f03412a
AO		 3537}
3538
13ae64f3
JJ		 3539/* Return the base VMA address which should be subtracted from real addresses
3540 when resolving @dtpoff relocation.
3541 This is PT_TLS segment p_vaddr. */
3542
3543static bfd_vma
eb4ff4d6 3544elf_i386_dtpoff_base (struct bfd_link_info *info)
13ae64f3 3545{
e1918d23
AM		 3546 /* If tls_sec is NULL, we should have signalled an error already. */
3547 if (elf_hash_table (info)->tls_sec == NULL)
6a30718d 3548 return 0;
e1918d23 3549 return elf_hash_table (info)->tls_sec->vma;
13ae64f3
JJ		 3550}
3551
3552/* Return the relocation value for @tpoff relocation
3553 if STT_TLS virtual address is ADDRESS. */
3554
3555static bfd_vma
eb4ff4d6 3556elf_i386_tpoff (struct bfd_link_info *info, bfd_vma address)
13ae64f3 3557{
e1918d23 3558 struct elf_link_hash_table *htab = elf_hash_table (info);
7dc98aea
RO		 3559 const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
3560 bfd_vma static_tls_size;
13ae64f3 3561
e1918d23
AM		 3562 /* If tls_sec is NULL, we should have signalled an error already. */
3563 if (htab->tls_sec == NULL)
6a30718d 3564 return 0;
7dc98aea
RO		 3565
3566 /* Consider special static TLS alignment requirements. */
3567 static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
3568 return static_tls_size + htab->tls_sec->vma - address;
13ae64f3
JJ		 3569}
3570
252b5132
RH		 3571/* Relocate an i386 ELF section. */
3572
b34976b6 3573static bfd_boolean
55fd94b0
AM		 3574elf_i386_relocate_section (bfd *output_bfd,
3575 struct bfd_link_info *info,
3576 bfd *input_bfd,
3577 asection *input_section,
3578 bfd_byte *contents,
3579 Elf_Internal_Rela *relocs,
3580 Elf_Internal_Sym *local_syms,
3581 asection **local_sections)
252b5132 3582{
6725bdbf 3583 struct elf_i386_link_hash_table *htab;
252b5132
RH		 3584 Elf_Internal_Shdr *symtab_hdr;
3585 struct elf_link_hash_entry **sym_hashes;
3586 bfd_vma *local_got_offsets;
67a4f2b7 3587 bfd_vma *local_tlsdesc_gotents;
252b5132 3588 Elf_Internal_Rela *rel;
60f2e42e 3589 Elf_Internal_Rela *wrel;
252b5132 3590 Elf_Internal_Rela *relend;
3348747a 3591 bfd_boolean is_vxworks_tls;
25e762b9 3592 unsigned plt_entry_size;
252b5132 3593
0ffa91dd 3594 BFD_ASSERT (is_i386_elf (input_bfd));
6bbec505 3595
c337a162
L		 3596 /* Skip if check_relocs failed. */
3597 if (input_section->check_relocs_failed)
3598 return FALSE;
3599
6725bdbf 3600 htab = elf_i386_hash_table (info);
4dfe6ac6
NC		 3601 if (htab == NULL)
3602 return FALSE;
0ffa91dd 3603 symtab_hdr = &elf_symtab_hdr (input_bfd);
252b5132
RH		 3604 sym_hashes = elf_sym_hashes (input_bfd);
3605 local_got_offsets = elf_local_got_offsets (input_bfd);
67a4f2b7 3606 local_tlsdesc_gotents = elf_i386_local_tlsdesc_gotent (input_bfd);
3348747a
NS		 3607 /* We have to handle relocations in vxworks .tls_vars sections
3608 specially, because the dynamic loader is 'weird'. */
23209a78 3609 is_vxworks_tls = (get_elf_i386_backend_data (output_bfd)->is_vxworks
0e1862bb 3610 && bfd_link_pic (info)
3348747a
NS		 3611 && !strcmp (input_section->output_section->name,
3612 ".tls_vars"));
252b5132 3613
eb4ff4d6 3614 elf_i386_set_tls_module_base (info);
9f03412a 3615
25e762b9
RM		 3616 plt_entry_size = GET_PLT_ENTRY_SIZE (output_bfd);
3617
60f2e42e 3618 rel = wrel = relocs;
252b5132 3619 relend = relocs + input_section->reloc_count;
60f2e42e 3620 for (; rel < relend; wrel++, rel++)
252b5132 3621 {
13ae64f3 3622 unsigned int r_type;
252b5132
RH		 3623 reloc_howto_type *howto;
3624 unsigned long r_symndx;
3625 struct elf_link_hash_entry *h;
dd7e64d4 3626 struct elf_i386_link_hash_entry *eh;
252b5132
RH		 3627 Elf_Internal_Sym *sym;
3628 asection *sec;
dd7e64d4 3629 bfd_vma off, offplt, plt_offset;
252b5132 3630 bfd_vma relocation;
b34976b6 3631 bfd_boolean unresolved_reloc;
252b5132 3632 bfd_reloc_status_type r;
1b452ec6 3633 unsigned int indx;
13ae64f3 3634 int tls_type;
1788fc08 3635 bfd_vma st_size;
dd7e64d4 3636 asection *resolved_plt;
aec6b87e 3637 bfd_boolean resolved_to_zero;
252b5132
RH		 3638
3639 r_type = ELF32_R_TYPE (rel->r_info);
55fd94b0
AM		 3640 if (r_type == R_386_GNU_VTINHERIT
3641 || r_type == R_386_GNU_VTENTRY)
18954b29
L		 3642 {
3643 if (wrel != rel)
3644 *wrel = *rel;
3645 continue;
3646 }
dc47f327 3647
55fd94b0 3648 if ((indx = r_type) >= R_386_standard
13ae64f3
JJ		 3649 && ((indx = r_type - R_386_ext_offset) - R_386_standard
3650 >= R_386_ext - R_386_standard)
3651 && ((indx = r_type - R_386_tls_offset) - R_386_ext
c74be520 3652 >= R_386_ext2 - R_386_ext))
252b5132 3653 {
6ba842b6 3654 (*_bfd_error_handler)
d003868e
AM		 3655 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3656 input_bfd, input_section, r_type);
252b5132 3657 bfd_set_error (bfd_error_bad_value);
b34976b6 3658 return FALSE;
252b5132 3659 }
1b452ec6 3660 howto = elf_howto_table + indx;
252b5132
RH		 3661
3662 r_symndx = ELF32_R_SYM (rel->r_info);
252b5132
RH		 3663 h = NULL;
3664 sym = NULL;
3665 sec = NULL;
b34976b6 3666 unresolved_reloc = FALSE;
252b5132
RH		 3667 if (r_symndx < symtab_hdr->sh_info)
3668 {
3669 sym = local_syms + r_symndx;
3670 sec = local_sections[r_symndx];
3671 relocation = (sec->output_section->vma
3672 + sec->output_offset
3673 + sym->st_value);
1788fc08 3674 st_size = sym->st_size;
ab96bf03
AM		 3675
3676 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION
3677 && ((sec->flags & SEC_MERGE) != 0
0e1862bb 3678 || (bfd_link_relocatable (info)
ab96bf03 3679 && sec->output_offset != 0)))
f8df10f4 3680 {
f8df10f4 3681 bfd_vma addend;
4a335f3d 3682 bfd_byte *where = contents + rel->r_offset;
f8df10f4 3683
4a335f3d 3684 switch (howto->size)
f8df10f4 3685 {
4a335f3d
AM		 3686 case 0:
3687 addend = bfd_get_8 (input_bfd, where);
3688 if (howto->pc_relative)
3689 {
3690 addend = (addend ^ 0x80) - 0x80;
3691 addend += 1;
3692 }
3693 break;
3694 case 1:
3695 addend = bfd_get_16 (input_bfd, where);
3696 if (howto->pc_relative)
3697 {
3698 addend = (addend ^ 0x8000) - 0x8000;
3699 addend += 2;
3700 }
3701 break;
3702 case 2:
3703 addend = bfd_get_32 (input_bfd, where);
3704 if (howto->pc_relative)
3705 {
3706 addend = (addend ^ 0x80000000) - 0x80000000;
3707 addend += 4;
3708 }
3709 break;
3710 default:
3711 abort ();
f8df10f4
JJ		 3712 }
3713
0e1862bb 3714 if (bfd_link_relocatable (info))
ab96bf03
AM		 3715 addend += sec->output_offset;
3716 else
3717 {
3718 asection *msec = sec;
3719 addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec,
3720 addend);
3721 addend -= relocation;
3722 addend += msec->output_section->vma + msec->output_offset;
3723 }
4a335f3d
AM		 3724
3725 switch (howto->size)
3726 {
3727 case 0:
16a10388 3728 /* FIXME: overflow checks. */
4a335f3d
AM		 3729 if (howto->pc_relative)
3730 addend -= 1;
3731 bfd_put_8 (input_bfd, addend, where);
4a335f3d
AM		 3732 break;
3733 case 1:
3734 if (howto->pc_relative)
3735 addend -= 2;
3736 bfd_put_16 (input_bfd, addend, where);
4a335f3d
AM		 3737 break;
3738 case 2:
3739 if (howto->pc_relative)
3740 addend -= 4;
3741 bfd_put_32 (input_bfd, addend, where);
3742 break;
3743 }
f8df10f4 3744 }
0e1862bb 3745 else if (!bfd_link_relocatable (info)
1f85278f 3746 && ELF32_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
c25bc9fc
L		 3747 {
3748 /* Relocate against local STT_GNU_IFUNC symbol. */
9fff0c39
L		 3749 h = elf_i386_get_local_sym_hash (htab, input_bfd, rel,
3750 FALSE);
c25bc9fc
L		 3751 if (h == NULL)
3752 abort ();
3753
23209a78 3754 /* Set STT_GNU_IFUNC symbol value. */
c25bc9fc
L		 3755 h->root.u.def.value = sym->st_value;
3756 h->root.u.def.section = sec;
3757 }
252b5132
RH		 3758 }
3759 else
3760 {
3d540e93 3761 bfd_boolean warned ATTRIBUTE_UNUSED;
62d887d4 3762 bfd_boolean ignored ATTRIBUTE_UNUSED;
ffb2e45b 3763
b2a8e766
AM		 3764 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3765 r_symndx, symtab_hdr, sym_hashes,
3766 h, sec, relocation,
62d887d4 3767 unresolved_reloc, warned, ignored);
1788fc08 3768 st_size = h->size;
252b5132
RH		 3769 }
3770
dbaa2011 3771 if (sec != NULL && discarded_section (sec))
60f2e42e
L		 3772 {
3773 _bfd_clear_contents (howto, input_bfd, input_section,
3774 contents + rel->r_offset);
3775 wrel->r_offset = rel->r_offset;
3776 wrel->r_info = 0;
3777 wrel->r_addend = 0;
3778
3779 /* For ld -r, remove relocations in debug sections against
3780 sections defined in discarded sections. Not done for
3781 eh_frame editing code expects to be present. */
3782 if (bfd_link_relocatable (info)
3783 && (input_section->flags & SEC_DEBUGGING))
3784 wrel--;
3785
3786 continue;
3787 }
9635fe29 3788
0e1862bb 3789 if (bfd_link_relocatable (info))
2d5da473
L		 3790 {
3791 if (wrel != rel)
3792 *wrel = *rel;
3793 continue;
3794 }
ab96bf03 3795
cbe950e9
L		 3796 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3797 it here if it is defined in a non-shared object. */
3798 if (h != NULL
3799 && h->type == STT_GNU_IFUNC
3800 && h->def_regular)
3801 {
3802 asection *plt, *gotplt, *base_got;
3803 bfd_vma plt_index;
4c544807 3804 const char *name;
cbe950e9 3805
97dc35c8
L		 3806 if ((input_section->flags & SEC_ALLOC) == 0)
3807 {
3808 /* Dynamic relocs are not propagated for SEC_DEBUGGING
3809 sections because such sections are not SEC_ALLOC and
3810 thus ld.so will not process them. */
3811 if ((input_section->flags & SEC_DEBUGGING) != 0)
0eace210 3812 continue;
97dc35c8
L		 3813 abort ();
3814 }
3815 else if (h->plt.offset == (bfd_vma) -1)
cbe950e9
L		 3816 abort ();
3817
3818 /* STT_GNU_IFUNC symbol must go through PLT. */
6de2ae4a 3819 if (htab->elf.splt != NULL)
cbe950e9 3820 {
6de2ae4a
L		 3821 plt = htab->elf.splt;
3822 gotplt = htab->elf.sgotplt;
cbe950e9
L		 3823 }
3824 else
3825 {
6de2ae4a
L		 3826 plt = htab->elf.iplt;
3827 gotplt = htab->elf.igotplt;
cbe950e9
L		 3828 }
3829
3830 relocation = (plt->output_section->vma
3831 + plt->output_offset + h->plt.offset);
3832
3833 switch (r_type)
3834 {
3835 default:
4c544807
L		 3836 if (h->root.root.string)
3837 name = h->root.root.string;
3838 else
3839 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3840 NULL);
cbe950e9
L		 3841 (*_bfd_error_handler)
3842 (_("%B: relocation %s against STT_GNU_IFUNC "
3843 "symbol `%s' isn't handled by %s"), input_bfd,
3844 elf_howto_table[r_type].name,
4c544807 3845 name, __FUNCTION__);
cbe950e9
L		 3846 bfd_set_error (bfd_error_bad_value);
3847 return FALSE;
3848
3849 case R_386_32:
710ab287 3850 /* Generate dynamic relcoation only when there is a
c293fa49 3851 non-GOT reference in a shared object. */
0e1862bb 3852 if (bfd_link_pic (info) && h->non_got_ref)
710ab287
L		 3853 {
3854 Elf_Internal_Rela outrel;
710ab287
L		 3855 asection *sreloc;
3856 bfd_vma offset;
3857
c25bc9fc
L		 3858 /* Need a dynamic relocation to get the real function
3859 adddress. */
710ab287
L		 3860 offset = _bfd_elf_section_offset (output_bfd,
3861 info,
3862 input_section,
3863 rel->r_offset);
3864 if (offset == (bfd_vma) -1
3865 || offset == (bfd_vma) -2)
3866 abort ();
3867
3868 outrel.r_offset = (input_section->output_section->vma
3869 + input_section->output_offset
3870 + offset);
3871
3872 if (h->dynindx == -1
44c4ea11 3873 || h->forced_local
0e1862bb 3874 || bfd_link_executable (info))
710ab287
L		 3875 {
3876 /* This symbol is resolved locally. */
56b8aada
L		 3877 outrel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
3878 bfd_put_32 (output_bfd,
3879 (h->root.u.def.value
3880 + h->root.u.def.section->output_section->vma
3881 + h->root.u.def.section->output_offset),
3882 contents + offset);
710ab287
L		 3883 }
3884 else
56b8aada 3885 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
710ab287 3886
6de2ae4a 3887 sreloc = htab->elf.irelifunc;
59d6ffb2 3888 elf_append_rel (output_bfd, sreloc, &outrel);
710ab287
L		 3889
3890 /* If this reloc is against an external symbol, we
3891 do not want to fiddle with the addend. Otherwise,
3892 we need to include the symbol value so that it
3893 becomes an addend for the dynamic reloc. For an
3894 internal symbol, we have updated addend. */
56b8aada 3895 continue;
710ab287 3896 }
d59a60e9 3897 /* FALLTHROUGH */
cbe950e9
L		 3898 case R_386_PC32:
3899 case R_386_PLT32:
3900 goto do_relocation;
3901
3902 case R_386_GOT32:
02a86693 3903 case R_386_GOT32X:
6de2ae4a 3904 base_got = htab->elf.sgot;
cbe950e9
L		 3905 off = h->got.offset;
3906
7afd84dc 3907 if (base_got == NULL)
cbe950e9
L		 3908 abort ();
3909
7afd84dc 3910 if (off == (bfd_vma) -1)
cbe950e9 3911 {
7afd84dc
L		 3912 /* We can't use h->got.offset here to save state, or
3913 even just remember the offset, as finish_dynamic_symbol
3914 would use that as offset into .got. */
6bbec505 3915
6de2ae4a 3916 if (htab->elf.splt != NULL)
7afd84dc 3917 {
25e762b9 3918 plt_index = h->plt.offset / plt_entry_size - 1;
7afd84dc 3919 off = (plt_index + 3) * 4;
6de2ae4a 3920 base_got = htab->elf.sgotplt;
7afd84dc 3921 }
cbe950e9
L		 3922 else
3923 {
25e762b9 3924 plt_index = h->plt.offset / plt_entry_size;
7afd84dc 3925 off = plt_index * 4;
6de2ae4a 3926 base_got = htab->elf.igotplt;
7afd84dc
L		 3927 }
3928
3929 if (h->dynindx == -1
3930 || h->forced_local
3931 || info->symbolic)
3932 {
3933 /* This references the local defitionion. We must
3934 initialize this entry in the global offset table.
3935 Since the offset must always be a multiple of 8,
3936 we use the least significant bit to record
3937 whether we have initialized it already.
3938
3939 When doing a dynamic link, we create a .rela.got
3940 relocation entry to initialize the value. This
3941 is done in the finish_dynamic_symbol routine. */
3942 if ((off & 1) != 0)
3943 off &= ~1;
3944 else
3945 {
3946 bfd_put_32 (output_bfd, relocation,
3947 base_got->contents + off);
3948 h->got.offset |= 1;
3949 }
cbe950e9 3950 }
cbe950e9 3951
7afd84dc 3952 relocation = off;
cbe950e9 3953
7afd84dc 3954 /* Adjust for static executables. */
6de2ae4a 3955 if (htab->elf.splt == NULL)
7afd84dc
L		 3956 relocation += gotplt->output_offset;
3957 }
3958 else
0018b0a3
L		 3959 {
3960 relocation = (base_got->output_section->vma
3961 + base_got->output_offset + off
3962 - gotplt->output_section->vma
3963 - gotplt->output_offset);
3964 /* Adjust for static executables. */
6de2ae4a 3965 if (htab->elf.splt == NULL)
0018b0a3
L		 3966 relocation += gotplt->output_offset;
3967 }
3968
cbe950e9
L		 3969 goto do_relocation;
3970
3971 case R_386_GOTOFF:
3972 relocation -= (gotplt->output_section->vma
3973 + gotplt->output_offset);
3974 goto do_relocation;
3975 }
3976 }
3977
04ebc307 3978 eh = (struct elf_i386_link_hash_entry *) h;
aec6b87e 3979 resolved_to_zero = (eh != NULL
e62b9723
L		 3980 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info,
3981 eh->has_got_reloc,
3982 eh));
aec6b87e 3983
252b5132
RH		 3984 switch (r_type)
3985 {
02a86693
L		 3986 case R_386_GOT32X:
3987 /* Avoid optimizing _DYNAMIC since ld.so may use its
3988 link-time address. */
3989 if (h == htab->elf.hdynamic)
3990 goto r_386_got32;
3991
3992 if (bfd_link_pic (info))
3993 {
3994 /* It is OK to convert mov to lea and convert indirect
3995 branch to direct branch. It is OK to convert adc,
3996 add, and, cmp, or, sbb, sub, test, xor only when PIC
3997 is false. */
02e2aef8
L		 3998 unsigned int opcode, addend;
3999 addend = bfd_get_32 (input_bfd, contents + rel->r_offset);
4000 if (addend != 0)
4001 goto r_386_got32;
4002 opcode = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
02a86693
L		 4003 if (opcode != 0x8b && opcode != 0xff)
4004 goto r_386_got32;
4005 }
4006
4007 /* Resolve "mov GOT[(%reg)], %reg",
4008 "call/jmp *GOT[(%reg)]", "test %reg, foo@GOT[(%reg)]"
4009 and "binop foo@GOT[(%reg)], %reg". */
4010 if (h == NULL
4011 || (h->plt.offset == (bfd_vma) -1
4012 && h->got.offset == (bfd_vma) -1)
4013 || htab->elf.sgotplt == NULL)
4014 abort ();
4015
4016 offplt = (htab->elf.sgotplt->output_section->vma
4017 + htab->elf.sgotplt->output_offset);
4018
4019 /* It is relative to .got.plt section. */
4020 if (h->got.offset != (bfd_vma) -1)
32875eb1
L		 4021 /* Use GOT entry. Mask off the least significant bit in
4022 GOT offset which may be set by R_386_GOT32 processing
4023 below. */
02a86693
L		 4024 relocation = (htab->elf.sgot->output_section->vma
4025 + htab->elf.sgot->output_offset
32875eb1 4026 + (h->got.offset & ~1) - offplt);
02a86693
L		 4027 else
4028 /* Use GOTPLT entry. */
4029 relocation = (h->plt.offset / plt_entry_size - 1 + 3) * 4;
4030
4031 if (!bfd_link_pic (info))
4032 {
4033 /* If not PIC, add the .got.plt section address for
a3718e9e 4034 baseless addressing. */
02a86693 4035 unsigned int modrm;
02e2aef8 4036 modrm = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
02a86693
L		 4037 if ((modrm & 0xc7) == 0x5)
4038 relocation += offplt;
4039 }
4040
4041 unresolved_reloc = FALSE;
4042 break;
4043
252b5132 4044 case R_386_GOT32:
02a86693 4045r_386_got32:
252b5132
RH		 4046 /* Relocation is to the entry for this symbol in the global
4047 offset table. */
6de2ae4a 4048 if (htab->elf.sgot == NULL)
ffb2e45b 4049 abort ();
252b5132
RH		 4050
4051 if (h != NULL)
4052 {
b34976b6 4053 bfd_boolean dyn;
252b5132
RH		 4054
4055 off = h->got.offset;
ebe50bae 4056 dyn = htab->elf.dynamic_sections_created;
0e1862bb
L		 4057 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
4058 bfd_link_pic (info),
4059 h)
4060 || (bfd_link_pic (info)
586119b3 4061 && SYMBOL_REFERENCES_LOCAL (info, h))
ef5aade5
L		 4062 || (ELF_ST_VISIBILITY (h->other)
4063 && h->root.type == bfd_link_hash_undefweak))
252b5132
RH		 4064 {
4065 /* This is actually a static link, or it is a
4066 -Bsymbolic link and the symbol is defined
4067 locally, or the symbol was forced to be local
4068 because of a version file. We must initialize
4069 this entry in the global offset table. Since the
4070 offset must always be a multiple of 4, we use the
4071 least significant bit to record whether we have
4072 initialized it already.
4073
4074 When doing a dynamic link, we create a .rel.got
4075 relocation entry to initialize the value. This
4076 is done in the finish_dynamic_symbol routine. */
4077 if ((off & 1) != 0)
4078 off &= ~1;
4079 else
4080 {
4081 bfd_put_32 (output_bfd, relocation,
6de2ae4a 4082 htab->elf.sgot->contents + off);
252b5132
RH		 4083 h->got.offset |= 1;
4084 }
4085 }
8c694914 4086 else
b34976b6 4087 unresolved_reloc = FALSE;
252b5132
RH		 4088 }
4089 else
4090 {
ffb2e45b
AM		 4091 if (local_got_offsets == NULL)
4092 abort ();
252b5132
RH		 4093
4094 off = local_got_offsets[r_symndx];
4095
4096 /* The offset must always be a multiple of 4. We use
83be169b
AM		 4097 the least significant bit to record whether we have
4098 already generated the necessary reloc. */
252b5132
RH		 4099 if ((off & 1) != 0)
4100 off &= ~1;
4101 else
4102 {
6725bdbf 4103 bfd_put_32 (output_bfd, relocation,
6de2ae4a 4104 htab->elf.sgot->contents + off);
252b5132 4105
0e1862bb 4106 if (bfd_link_pic (info))
252b5132 4107 {
947216bf
AM		 4108 asection *s;
4109 Elf_Internal_Rela outrel;
252b5132 4110
6de2ae4a 4111 s = htab->elf.srelgot;
947216bf 4112 if (s == NULL)
ffb2e45b 4113 abort ();
252b5132 4114
6de2ae4a
L		 4115 outrel.r_offset = (htab->elf.sgot->output_section->vma
4116 + htab->elf.sgot->output_offset
252b5132
RH		 4117 + off);
4118 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
59d6ffb2 4119 elf_append_rel (output_bfd, s, &outrel);
252b5132
RH		 4120 }
4121
4122 local_got_offsets[r_symndx] |= 1;
4123 }
252b5132
RH		 4124 }
4125
ffb2e45b
AM		 4126 if (off >= (bfd_vma) -2)
4127 abort ();
4128
6de2ae4a
L		 4129 relocation = htab->elf.sgot->output_section->vma
4130 + htab->elf.sgot->output_offset + off
4131 - htab->elf.sgotplt->output_section->vma
4132 - htab->elf.sgotplt->output_offset;
252b5132
RH		 4133 break;
4134
4135 case R_386_GOTOFF:
4136 /* Relocation is relative to the start of the global offset
4137 table. */
4138
3d949995
L		 4139 /* Check to make sure it isn't a protected function or data
4140 symbol for shared library since it may not be local when
4141 used as function address or with copy relocation. We also
e3c0e327 4142 need to make sure that a symbol is referenced locally. */
0e1862bb 4143 if (!bfd_link_executable (info) && h)
90f487df 4144 {
41bed6dd
L		 4145 if (!h->def_regular)
4146 {
4147 const char *v;
4148
4149 switch (ELF_ST_VISIBILITY (h->other))
4150 {
4151 case STV_HIDDEN:
4152 v = _("hidden symbol");
4153 break;
4154 case STV_INTERNAL:
4155 v = _("internal symbol");
4156 break;
4157 case STV_PROTECTED:
4158 v = _("protected symbol");
4159 break;
4160 default:
4161 v = _("symbol");
4162 break;
4163 }
4164
4165 (*_bfd_error_handler)
4166 (_("%B: relocation R_386_GOTOFF against undefined %s `%s' can not be used when making a shared object"),
4167 input_bfd, v, h->root.root.string);
4168 bfd_set_error (bfd_error_bad_value);
4169 return FALSE;
4170 }
d5597ebc 4171 else if (!SYMBOL_REFERENCES_LOCAL (info, h)
3d949995
L		 4172 && (h->type == STT_FUNC
4173 || h->type == STT_OBJECT)
41bed6dd
L		 4174 && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
4175 {
4176 (*_bfd_error_handler)
3d949995
L		 4177 (_("%B: relocation R_386_GOTOFF against protected %s `%s' can not be used when making a shared object"),
4178 input_bfd,
4179 h->type == STT_FUNC ? "function" : "data",
4180 h->root.root.string);
41bed6dd
L		 4181 bfd_set_error (bfd_error_bad_value);
4182 return FALSE;
4183 }
90f487df
L		 4184 }
4185
8c37241b
JJ		 4186 /* Note that sgot is not involved in this
4187 calculation. We always want the start of .got.plt. If we
4188 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
252b5132
RH		 4189 permitted by the ABI, we might have to change this
4190 calculation. */
6de2ae4a
L		 4191 relocation -= htab->elf.sgotplt->output_section->vma
4192 + htab->elf.sgotplt->output_offset;
252b5132
RH		 4193 break;
4194
4195 case R_386_GOTPC:
4196 /* Use global offset table as symbol value. */
6de2ae4a
L		 4197 relocation = htab->elf.sgotplt->output_section->vma
4198 + htab->elf.sgotplt->output_offset;
b34976b6 4199 unresolved_reloc = FALSE;
252b5132
RH		 4200 break;
4201
4202 case R_386_PLT32:
4203 /* Relocation is to the entry for this symbol in the
4204 procedure linkage table. */
4205
dd5724d5 4206 /* Resolve a PLT32 reloc against a local symbol directly,
83be169b 4207 without using the procedure linkage table. */
252b5132
RH		 4208 if (h == NULL)
4209 break;
4210
dd7e64d4
L		 4211 if ((h->plt.offset == (bfd_vma) -1
4212 && eh->plt_got.offset == (bfd_vma) -1)
6de2ae4a 4213 || htab->elf.splt == NULL)
252b5132
RH		 4214 {
4215 /* We didn't make a PLT entry for this symbol. This
83be169b
AM		 4216 happens when statically linking PIC code, or when
4217 using -Bsymbolic. */
252b5132
RH		 4218 break;
4219 }
4220
dd7e64d4
L		 4221 if (h->plt.offset != (bfd_vma) -1)
4222 {
4223 resolved_plt = htab->elf.splt;
4224 plt_offset = h->plt.offset;
4225 }
4226 else
4227 {
4228 resolved_plt = htab->plt_got;
4229 plt_offset = eh->plt_got.offset;
4230 }
4231
4232 relocation = (resolved_plt->output_section->vma
4233 + resolved_plt->output_offset
4234 + plt_offset);
b34976b6 4235 unresolved_reloc = FALSE;
252b5132
RH		 4236 break;
4237
1788fc08 4238 case R_386_SIZE32:
1788fc08
L		 4239 /* Set to symbol size. */
4240 relocation = st_size;
4241 /* Fall through. */
4242
252b5132
RH		 4243 case R_386_32:
4244 case R_386_PC32:
3348747a
NS		 4245 if ((input_section->flags & SEC_ALLOC) == 0
4246 || is_vxworks_tls)
ec338859
AM		 4247 break;
4248
aec6b87e
L		 4249 /* Copy dynamic function pointer relocations. Don't generate
4250 dynamic relocations against resolved undefined weak symbols
4251 in PIE, except for R_386_PC32. */
0e1862bb 4252 if ((bfd_link_pic (info)
ef5aade5 4253 && (h == NULL
aec6b87e
L		 4254 || ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
4255 && (!resolved_to_zero
4256 || r_type == R_386_PC32))
4257 || h->root.type != bfd_link_hash_undefweak))
1788fc08 4258 && ((r_type != R_386_PC32 && r_type != R_386_SIZE32)
f6c52c13 4259 || !SYMBOL_CALLS_LOCAL (info, h)))
a23b6845 4260 || (ELIMINATE_COPY_RELOCS
0e1862bb 4261 && !bfd_link_pic (info)
12d0ee4a
AM		 4262 && h != NULL
4263 && h->dynindx != -1
aec6b87e
L		 4264 && (!h->non_got_ref
4265 || eh->func_pointer_refcount > 0
4266 || (h->root.type == bfd_link_hash_undefweak
4267 && !resolved_to_zero))
bae420ef
L		 4268 && ((h->def_dynamic && !h->def_regular)
4269 /* Undefined weak symbol is bound locally when
4270 PIC is false. */
4271 || h->root.type == bfd_link_hash_undefweak)))
252b5132 4272 {
947216bf 4273 Elf_Internal_Rela outrel;
b34976b6 4274 bfd_boolean skip, relocate;
0c715baa 4275 asection *sreloc;
252b5132
RH		 4276
4277 /* When generating a shared object, these relocations
4278 are copied into the output file to be resolved at run
4279 time. */
4280
b34976b6
AM		 4281 skip = FALSE;
4282 relocate = FALSE;
252b5132 4283
c629eae0
JJ		 4284 outrel.r_offset =
4285 _bfd_elf_section_offset (output_bfd, info, input_section,
4286 rel->r_offset);
4287 if (outrel.r_offset == (bfd_vma) -1)
b34976b6 4288 skip = TRUE;
0bb2d96a 4289 else if (outrel.r_offset == (bfd_vma) -2)
b34976b6 4290 skip = TRUE, relocate = TRUE;
252b5132
RH		 4291 outrel.r_offset += (input_section->output_section->vma
4292 + input_section->output_offset);
4293
4294 if (skip)
0bb2d96a 4295 memset (&outrel, 0, sizeof outrel);
5a15f56f
AM		 4296 else if (h != NULL
4297 && h->dynindx != -1
4298 && (r_type == R_386_PC32
4e0c91e4
L		 4299 || !(bfd_link_executable (info)
4300 || SYMBOLIC_BIND (info, h))
f5385ebf 4301 || !h->def_regular))
0bb2d96a 4302 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
252b5132
RH		 4303 else
4304 {
5a15f56f 4305 /* This symbol is local, or marked to become local. */
b34976b6 4306 relocate = TRUE;
5a15f56f 4307 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
252b5132
RH		 4308 }
4309
cbe950e9 4310 sreloc = elf_section_data (input_section)->sreloc;
e7c33416 4311
62d78908
L		 4312 if (sreloc == NULL || sreloc->contents == NULL)
4313 {
4314 r = bfd_reloc_notsupported;
4315 goto check_relocation_error;
4316 }
0c715baa 4317
59d6ffb2 4318 elf_append_rel (output_bfd, sreloc, &outrel);
252b5132
RH		 4319
4320 /* If this reloc is against an external symbol, we do
4321 not want to fiddle with the addend. Otherwise, we
4322 need to include the symbol value so that it becomes
4323 an addend for the dynamic reloc. */
0f88be7a 4324 if (! relocate)
252b5132
RH		 4325 continue;
4326 }
252b5132
RH		 4327 break;
4328
37e55690 4329 case R_386_TLS_IE:
0e1862bb 4330 if (!bfd_link_executable (info))
37e55690 4331 {
947216bf 4332 Elf_Internal_Rela outrel;
37e55690 4333 asection *sreloc;
37e55690
JJ		 4334
4335 outrel.r_offset = rel->r_offset
4336 + input_section->output_section->vma
4337 + input_section->output_offset;
4338 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
4339 sreloc = elf_section_data (input_section)->sreloc;
4340 if (sreloc == NULL)
4341 abort ();
59d6ffb2 4342 elf_append_rel (output_bfd, sreloc, &outrel);
37e55690
JJ		 4343 }
4344 /* Fall through */
4345
13ae64f3 4346 case R_386_TLS_GD:
67a4f2b7
AO		 4347 case R_386_TLS_GOTDESC:
4348 case R_386_TLS_DESC_CALL:
13ae64f3 4349 case R_386_TLS_IE_32:
37e55690 4350 case R_386_TLS_GOTIE:
13ae64f3
JJ		 4351 tls_type = GOT_UNKNOWN;
4352 if (h == NULL && local_got_offsets)
4353 tls_type = elf_i386_local_got_tls_type (input_bfd) [r_symndx];
4354 else if (h != NULL)
142411ca 4355 tls_type = elf_i386_hash_entry(h)->tls_type;
37e55690
JJ		 4356 if (tls_type == GOT_TLS_IE)
4357 tls_type = GOT_TLS_IE_NEG;
142411ca
L		 4358
4359 if (! elf_i386_tls_transition (info, input_bfd,
4360 input_section, contents,
4361 symtab_hdr, sym_hashes,
4362 &r_type, tls_type, rel,
bedfd056 4363 relend, h, r_symndx, TRUE))
142411ca 4364 return FALSE;
13ae64f3
JJ		 4365
4366 if (r_type == R_386_TLS_LE_32)
4367 {
82e51918 4368 BFD_ASSERT (! unresolved_reloc);
13ae64f3
JJ		 4369 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
4370 {
142411ca 4371 unsigned int type;
13ae64f3
JJ		 4372 bfd_vma roff;
4373
4374 /* GD->LE transition. */
13ae64f3 4375 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
13ae64f3
JJ		 4376 if (type == 0x04)
4377 {
4378 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
4379 Change it into:
4380 movl %gs:0, %eax; subl $foo@tpoff, %eax
4381 (6 byte form of subl). */
13ae64f3
JJ		 4382 memcpy (contents + rel->r_offset - 3,
4383 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
142411ca 4384 roff = rel->r_offset + 5;
13ae64f3
JJ		 4385 }
4386 else
4387 {
142411ca
L		 4388 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
4389 Change it into:
4390 movl %gs:0, %eax; subl $foo@tpoff, %eax
4391 (6 byte form of subl). */
4392 memcpy (contents + rel->r_offset - 2,
4393 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
4394 roff = rel->r_offset + 6;
13ae64f3 4395 }
eb4ff4d6 4396 bfd_put_32 (output_bfd, elf_i386_tpoff (info, relocation),
13ae64f3 4397 contents + roff);
a3fadc9a 4398 /* Skip R_386_PC32/R_386_PLT32. */
13ae64f3 4399 rel++;
60f2e42e 4400 wrel++;
13ae64f3
JJ		 4401 continue;
4402 }
67a4f2b7
AO		 4403 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
4404 {
4405 /* GDesc -> LE transition.
4406 It's originally something like:
4407 leal x@tlsdesc(%ebx), %eax
4408
4409 leal x@ntpoff, %eax
4410
4411 Registers other than %eax may be set up here. */
4412
142411ca 4413 unsigned int val;
67a4f2b7
AO		 4414 bfd_vma roff;
4415
67a4f2b7 4416 roff = rel->r_offset;
67a4f2b7 4417 val = bfd_get_8 (input_bfd, contents + roff - 1);
67a4f2b7
AO		 4418
4419 /* Now modify the instruction as appropriate. */
4420 /* aoliva FIXME: remove the above and xor the byte
4421 below with 0x86. */
4422 bfd_put_8 (output_bfd, val ^ 0x86,
4423 contents + roff - 1);
eb4ff4d6 4424 bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
67a4f2b7
AO		 4425 contents + roff);
4426 continue;
4427 }
4428 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
4429 {
4430 /* GDesc -> LE transition.
4431 It's originally:
4432 call *(%eax)
4433 Turn it into:
142411ca 4434 xchg %ax,%ax */
67a4f2b7 4435
67a4f2b7 4436 bfd_vma roff;
6bbec505 4437
67a4f2b7 4438 roff = rel->r_offset;
10efb593 4439 bfd_put_8 (output_bfd, 0x66, contents + roff);
67a4f2b7
AO		 4440 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4441 continue;
4442 }
37e55690 4443 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_IE)
13ae64f3 4444 {
142411ca 4445 unsigned int val;
13ae64f3
JJ		 4446
4447 /* IE->LE transition:
37e55690
JJ		 4448 Originally it can be one of:
4449 movl foo, %eax
4450 movl foo, %reg
4451 addl foo, %reg
4452 We change it into:
4453 movl $foo, %eax
4454 movl $foo, %reg
4455 addl $foo, %reg. */
37e55690 4456 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
37e55690
JJ		 4457 if (val == 0xa1)
4458 {
4459 /* movl foo, %eax. */
55fd94b0
AM		 4460 bfd_put_8 (output_bfd, 0xb8,
4461 contents + rel->r_offset - 1);
37e55690 4462 }
299bf759 4463 else
37e55690 4464 {
142411ca
L		 4465 unsigned int type;
4466
55fd94b0
AM		 4467 type = bfd_get_8 (input_bfd,
4468 contents + rel->r_offset - 2);
299bf759 4469 switch (type)
26e41594 4470 {
299bf759
L		 4471 case 0x8b:
4472 /* movl */
299bf759
L		 4473 bfd_put_8 (output_bfd, 0xc7,
4474 contents + rel->r_offset - 2);
4475 bfd_put_8 (output_bfd,
4476 0xc0 | ((val >> 3) & 7),
4477 contents + rel->r_offset - 1);
4478 break;
4479 case 0x03:
4480 /* addl */
299bf759
L		 4481 bfd_put_8 (output_bfd, 0x81,
4482 contents + rel->r_offset - 2);
4483 bfd_put_8 (output_bfd,
4484 0xc0 | ((val >> 3) & 7),
4485 contents + rel->r_offset - 1);
4486 break;
4487 default:
4488 BFD_FAIL ();
4489 break;
26e41594 4490 }
37e55690 4491 }
eb4ff4d6 4492 bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
37e55690
JJ		 4493 contents + rel->r_offset);
4494 continue;
4495 }
4496 else
4497 {
4498 unsigned int val, type;
4499
4500 /* {IE_32,GOTIE}->LE transition:
4501 Originally it can be one of:
13ae64f3 4502 subl foo(%reg1), %reg2
13ae64f3 4503 movl foo(%reg1), %reg2
37e55690 4504 addl foo(%reg1), %reg2
13ae64f3
JJ		 4505 We change it into:
4506 subl $foo, %reg2
37e55690
JJ		 4507 movl $foo, %reg2 (6 byte form)
4508 addl $foo, %reg2. */
13ae64f3
JJ		 4509 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
4510 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
13ae64f3
JJ		 4511 if (type == 0x8b)
4512 {
4513 /* movl */
13ae64f3
JJ		 4514 bfd_put_8 (output_bfd, 0xc7,
4515 contents + rel->r_offset - 2);
4516 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
4517 contents + rel->r_offset - 1);
4518 }
4519 else if (type == 0x2b)
4520 {
4521 /* subl */
13ae64f3
JJ		 4522 bfd_put_8 (output_bfd, 0x81,
4523 contents + rel->r_offset - 2);
4524 bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
4525 contents + rel->r_offset - 1);
4526 }
37e55690
JJ		 4527 else if (type == 0x03)
4528 {
4529 /* addl */
4530 bfd_put_8 (output_bfd, 0x81,
4531 contents + rel->r_offset - 2);
4532 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
4533 contents + rel->r_offset - 1);
4534 }
13ae64f3
JJ		 4535 else
4536 BFD_FAIL ();
37e55690 4537 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTIE)
eb4ff4d6 4538 bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
37e55690
JJ		 4539 contents + rel->r_offset);
4540 else
eb4ff4d6 4541 bfd_put_32 (output_bfd, elf_i386_tpoff (info, relocation),
37e55690 4542 contents + rel->r_offset);
13ae64f3
JJ		 4543 continue;
4544 }
4545 }
4546
6de2ae4a 4547 if (htab->elf.sgot == NULL)
13ae64f3
JJ		 4548 abort ();
4549
4550 if (h != NULL)
67a4f2b7
AO		 4551 {
4552 off = h->got.offset;
4553 offplt = elf_i386_hash_entry (h)->tlsdesc_got;
4554 }
13ae64f3
JJ		 4555 else
4556 {
4557 if (local_got_offsets == NULL)
4558 abort ();
4559
4560 off = local_got_offsets[r_symndx];
67a4f2b7 4561 offplt = local_tlsdesc_gotents[r_symndx];
13ae64f3
JJ		 4562 }
4563
4564 if ((off & 1) != 0)
4565 off &= ~1;
26e41594 4566 else
13ae64f3 4567 {
947216bf 4568 Elf_Internal_Rela outrel;
91d6fa6a 4569 int dr_type;
67a4f2b7 4570 asection *sreloc;
13ae64f3 4571
6de2ae4a 4572 if (htab->elf.srelgot == NULL)
13ae64f3
JJ		 4573 abort ();
4574
67a4f2b7
AO		 4575 indx = h && h->dynindx != -1 ? h->dynindx : 0;
4576
4577 if (GOT_TLS_GDESC_P (tls_type))
4578 {
59d6ffb2 4579 bfd_byte *loc;
67a4f2b7
AO		 4580 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_DESC);
4581 BFD_ASSERT (htab->sgotplt_jump_table_size + offplt + 8
6de2ae4a
L		 4582 <= htab->elf.sgotplt->size);
4583 outrel.r_offset = (htab->elf.sgotplt->output_section->vma
4584 + htab->elf.sgotplt->output_offset
67a4f2b7
AO		 4585 + offplt
4586 + htab->sgotplt_jump_table_size);
6de2ae4a 4587 sreloc = htab->elf.srelplt;
67a4f2b7 4588 loc = sreloc->contents;
5ae0bfb6
RS		 4589 loc += (htab->next_tls_desc_index++
4590 * sizeof (Elf32_External_Rel));
67a4f2b7 4591 BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
c3b02097 4592 <= sreloc->contents + sreloc->size);
67a4f2b7
AO		 4593 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
4594 if (indx == 0)
4595 {
4596 BFD_ASSERT (! unresolved_reloc);
4597 bfd_put_32 (output_bfd,
eb4ff4d6 4598 relocation - elf_i386_dtpoff_base (info),
6de2ae4a 4599 htab->elf.sgotplt->contents + offplt
67a4f2b7
AO		 4600 + htab->sgotplt_jump_table_size + 4);
4601 }
4602 else
4603 {
4604 bfd_put_32 (output_bfd, 0,
6de2ae4a 4605 htab->elf.sgotplt->contents + offplt
67a4f2b7
AO		 4606 + htab->sgotplt_jump_table_size + 4);
4607 }
4608 }
4609
6de2ae4a 4610 sreloc = htab->elf.srelgot;
67a4f2b7 4611
6de2ae4a
L		 4612 outrel.r_offset = (htab->elf.sgot->output_section->vma
4613 + htab->elf.sgot->output_offset + off);
13ae64f3 4614
67a4f2b7 4615 if (GOT_TLS_GD_P (tls_type))
13ae64f3 4616 dr_type = R_386_TLS_DTPMOD32;
67a4f2b7
AO		 4617 else if (GOT_TLS_GDESC_P (tls_type))
4618 goto dr_done;
37e55690
JJ		 4619 else if (tls_type == GOT_TLS_IE_POS)
4620 dr_type = R_386_TLS_TPOFF;
13ae64f3
JJ		 4621 else
4622 dr_type = R_386_TLS_TPOFF32;
67a4f2b7 4623
37e55690 4624 if (dr_type == R_386_TLS_TPOFF && indx == 0)
eb4ff4d6
L		 4625 bfd_put_32 (output_bfd,
4626 relocation - elf_i386_dtpoff_base (info),
6de2ae4a 4627 htab->elf.sgot->contents + off);
37e55690 4628 else if (dr_type == R_386_TLS_TPOFF32 && indx == 0)
23209a78 4629 bfd_put_32 (output_bfd,
eb4ff4d6 4630 elf_i386_dtpoff_base (info) - relocation,
6de2ae4a 4631 htab->elf.sgot->contents + off);
67a4f2b7 4632 else if (dr_type != R_386_TLS_DESC)
c366c25e 4633 bfd_put_32 (output_bfd, 0,
6de2ae4a 4634 htab->elf.sgot->contents + off);
13ae64f3 4635 outrel.r_info = ELF32_R_INFO (indx, dr_type);
67a4f2b7 4636
59d6ffb2 4637 elf_append_rel (output_bfd, sreloc, &outrel);
13ae64f3 4638
67a4f2b7 4639 if (GOT_TLS_GD_P (tls_type))
13ae64f3
JJ		 4640 {
4641 if (indx == 0)
4642 {
82e51918 4643 BFD_ASSERT (! unresolved_reloc);
13ae64f3 4644 bfd_put_32 (output_bfd,
eb4ff4d6 4645 relocation - elf_i386_dtpoff_base (info),
6de2ae4a 4646 htab->elf.sgot->contents + off + 4);
13ae64f3
JJ		 4647 }
4648 else
4649 {
4650 bfd_put_32 (output_bfd, 0,
6de2ae4a 4651 htab->elf.sgot->contents + off + 4);
13ae64f3
JJ		 4652 outrel.r_info = ELF32_R_INFO (indx,
4653 R_386_TLS_DTPOFF32);
4654 outrel.r_offset += 4;
59d6ffb2 4655 elf_append_rel (output_bfd, sreloc, &outrel);
13ae64f3
JJ		 4656 }
4657 }
37e55690
JJ		 4658 else if (tls_type == GOT_TLS_IE_BOTH)
4659 {
4660 bfd_put_32 (output_bfd,
eb4ff4d6
L		 4661 (indx == 0
4662 ? relocation - elf_i386_dtpoff_base (info)
4663 : 0),
6de2ae4a 4664 htab->elf.sgot->contents + off + 4);
37e55690
JJ		 4665 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
4666 outrel.r_offset += 4;
59d6ffb2 4667 elf_append_rel (output_bfd, sreloc, &outrel);
37e55690 4668 }
13ae64f3 4669
67a4f2b7 4670 dr_done:
13ae64f3
JJ		 4671 if (h != NULL)
4672 h->got.offset |= 1;
4673 else
4674 local_got_offsets[r_symndx] |= 1;
4675 }
4676
67a4f2b7
AO		 4677 if (off >= (bfd_vma) -2
4678 && ! GOT_TLS_GDESC_P (tls_type))
13ae64f3 4679 abort ();
67a4f2b7
AO		 4680 if (r_type == R_386_TLS_GOTDESC
4681 || r_type == R_386_TLS_DESC_CALL)
4682 {
4683 relocation = htab->sgotplt_jump_table_size + offplt;
4684 unresolved_reloc = FALSE;
4685 }
4686 else if (r_type == ELF32_R_TYPE (rel->r_info))
13ae64f3 4687 {
6de2ae4a
L		 4688 bfd_vma g_o_t = htab->elf.sgotplt->output_section->vma
4689 + htab->elf.sgotplt->output_offset;
4690 relocation = htab->elf.sgot->output_section->vma
4691 + htab->elf.sgot->output_offset + off - g_o_t;
37e55690
JJ		 4692 if ((r_type == R_386_TLS_IE || r_type == R_386_TLS_GOTIE)
4693 && tls_type == GOT_TLS_IE_BOTH)
4694 relocation += 4;
4695 if (r_type == R_386_TLS_IE)
8c37241b 4696 relocation += g_o_t;
b34976b6 4697 unresolved_reloc = FALSE;
13ae64f3 4698 }
67a4f2b7 4699 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
13ae64f3
JJ		 4700 {
4701 unsigned int val, type;
4702 bfd_vma roff;
4703
4704 /* GD->IE transition. */
13ae64f3 4705 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
13ae64f3
JJ		 4706 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
4707 if (type == 0x04)
4708 {
4709 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
4710 Change it into:
4711 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
13ae64f3 4712 val >>= 3;
142411ca 4713 roff = rel->r_offset - 3;
13ae64f3
JJ		 4714 }
4715 else
4716 {
4717 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
4718 Change it into:
4719 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
13ae64f3
JJ		 4720 roff = rel->r_offset - 2;
4721 }
4722 memcpy (contents + roff,
4723 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
4724 contents[roff + 7] = 0x80 | (val & 7);
37e55690
JJ		 4725 /* If foo is used only with foo@gotntpoff(%reg) and
4726 foo@indntpoff, but not with foo@gottpoff(%reg), change
4727 subl $foo@gottpoff(%reg), %eax
4728 into:
4729 addl $foo@gotntpoff(%reg), %eax. */
ebcfb3c0
JJ		 4730 if (tls_type == GOT_TLS_IE_POS)
4731 contents[roff + 6] = 0x03;
8c37241b 4732 bfd_put_32 (output_bfd,
6de2ae4a
L		 4733 htab->elf.sgot->output_section->vma
4734 + htab->elf.sgot->output_offset + off
4735 - htab->elf.sgotplt->output_section->vma
4736 - htab->elf.sgotplt->output_offset,
13ae64f3
JJ		 4737 contents + roff + 8);
4738 /* Skip R_386_PLT32. */
4739 rel++;
60f2e42e 4740 wrel++;
13ae64f3
JJ		 4741 continue;
4742 }
67a4f2b7
AO		 4743 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
4744 {
4745 /* GDesc -> IE transition.
4746 It's originally something like:
4747 leal x@tlsdesc(%ebx), %eax
4748
4749 Change it to:
142411ca 4750 movl x@gotntpoff(%ebx), %eax # before xchg %ax,%ax
67a4f2b7
AO		 4751 or:
4752 movl x@gottpoff(%ebx), %eax # before negl %eax
4753
4754 Registers other than %eax may be set up here. */
4755
67a4f2b7
AO		 4756 bfd_vma roff;
4757
4758 /* First, make sure it's a leal adding ebx to a 32-bit
4759 offset into any register, although it's probably
4760 almost always going to be eax. */
4761 roff = rel->r_offset;
67a4f2b7
AO		 4762
4763 /* Now modify the instruction as appropriate. */
4764 /* To turn a leal into a movl in the form we use it, it
4765 suffices to change the first byte from 0x8d to 0x8b.
4766 aoliva FIXME: should we decide to keep the leal, all
4767 we have to do is remove the statement below, and
4768 adjust the relaxation of R_386_TLS_DESC_CALL. */
4769 bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
4770
4771 if (tls_type == GOT_TLS_IE_BOTH)
4772 off += 4;
4773
4774 bfd_put_32 (output_bfd,
6de2ae4a
L		 4775 htab->elf.sgot->output_section->vma
4776 + htab->elf.sgot->output_offset + off
4777 - htab->elf.sgotplt->output_section->vma
4778 - htab->elf.sgotplt->output_offset,
67a4f2b7
AO		 4779 contents + roff);
4780 continue;
4781 }
4782 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
4783 {
4784 /* GDesc -> IE transition.
4785 It's originally:
4786 call *(%eax)
4787
4788 Change it to:
142411ca 4789 xchg %ax,%ax
67a4f2b7
AO		 4790 or
4791 negl %eax
4792 depending on how we transformed the TLS_GOTDESC above.
4793 */
4794
67a4f2b7
AO		 4795 bfd_vma roff;
4796
67a4f2b7 4797 roff = rel->r_offset;
67a4f2b7
AO		 4798
4799 /* Now modify the instruction as appropriate. */
4800 if (tls_type != GOT_TLS_IE_NEG)
4801 {
10efb593
L		 4802 /* xchg %ax,%ax */
4803 bfd_put_8 (output_bfd, 0x66, contents + roff);
67a4f2b7
AO		 4804 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4805 }
4806 else
4807 {
4808 /* negl %eax */
4809 bfd_put_8 (output_bfd, 0xf7, contents + roff);
4810 bfd_put_8 (output_bfd, 0xd8, contents + roff + 1);
4811 }
4812
4813 continue;
4814 }
4815 else
4816 BFD_ASSERT (FALSE);
13ae64f3
JJ		 4817 break;
4818
4819 case R_386_TLS_LDM:
142411ca
L		 4820 if (! elf_i386_tls_transition (info, input_bfd,
4821 input_section, contents,
4822 symtab_hdr, sym_hashes,
4823 &r_type, GOT_UNKNOWN, rel,
bedfd056 4824 relend, h, r_symndx, TRUE))
142411ca 4825 return FALSE;
13ae64f3 4826
142411ca
L		 4827 if (r_type != R_386_TLS_LDM)
4828 {
13ae64f3 4829 /* LD->LE transition:
13ae64f3
JJ		 4830 leal foo(%reg), %eax; call ___tls_get_addr.
4831 We change it into:
4832 movl %gs:0, %eax; nop; leal 0(%esi,1), %esi. */
142411ca 4833 BFD_ASSERT (r_type == R_386_TLS_LE_32);
13ae64f3
JJ		 4834 memcpy (contents + rel->r_offset - 2,
4835 "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
a3fadc9a 4836 /* Skip R_386_PC32/R_386_PLT32. */
13ae64f3 4837 rel++;
60f2e42e 4838 wrel++;
13ae64f3
JJ		 4839 continue;
4840 }
4841
6de2ae4a 4842 if (htab->elf.sgot == NULL)
13ae64f3
JJ		 4843 abort ();
4844
4845 off = htab->tls_ldm_got.offset;
4846 if (off & 1)
4847 off &= ~1;
4848 else
4849 {
947216bf 4850 Elf_Internal_Rela outrel;
13ae64f3 4851
6de2ae4a 4852 if (htab->elf.srelgot == NULL)
13ae64f3
JJ		 4853 abort ();
4854
6de2ae4a
L		 4855 outrel.r_offset = (htab->elf.sgot->output_section->vma
4856 + htab->elf.sgot->output_offset + off);
13ae64f3
JJ		 4857
4858 bfd_put_32 (output_bfd, 0,
6de2ae4a 4859 htab->elf.sgot->contents + off);
13ae64f3 4860 bfd_put_32 (output_bfd, 0,
6de2ae4a 4861 htab->elf.sgot->contents + off + 4);
13ae64f3 4862 outrel.r_info = ELF32_R_INFO (0, R_386_TLS_DTPMOD32);
59d6ffb2 4863 elf_append_rel (output_bfd, htab->elf.srelgot, &outrel);
13ae64f3
JJ		 4864 htab->tls_ldm_got.offset |= 1;
4865 }
6de2ae4a
L		 4866 relocation = htab->elf.sgot->output_section->vma
4867 + htab->elf.sgot->output_offset + off
4868 - htab->elf.sgotplt->output_section->vma
4869 - htab->elf.sgotplt->output_offset;
b34976b6 4870 unresolved_reloc = FALSE;
13ae64f3
JJ		 4871 break;
4872
4873 case R_386_TLS_LDO_32:
0e1862bb
L		 4874 if (!bfd_link_executable (info)
4875 || (input_section->flags & SEC_CODE) == 0)
eb4ff4d6 4876 relocation -= elf_i386_dtpoff_base (info);
13ae64f3
JJ		 4877 else
4878 /* When converting LDO to LE, we must negate. */
eb4ff4d6 4879 relocation = -elf_i386_tpoff (info, relocation);
13ae64f3
JJ		 4880 break;
4881
4882 case R_386_TLS_LE_32:
13ae64f3 4883 case R_386_TLS_LE:
0e1862bb 4884 if (!bfd_link_executable (info))
37e55690 4885 {
947216bf 4886 Elf_Internal_Rela outrel;
37e55690 4887 asection *sreloc;
37e55690
JJ		 4888
4889 outrel.r_offset = rel->r_offset
4890 + input_section->output_section->vma
4891 + input_section->output_offset;
4892 if (h != NULL && h->dynindx != -1)
4893 indx = h->dynindx;
4894 else
4895 indx = 0;
4896 if (r_type == R_386_TLS_LE_32)
4897 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF32);
4898 else
4899 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
4900 sreloc = elf_section_data (input_section)->sreloc;
4901 if (sreloc == NULL)
4902 abort ();
59d6ffb2 4903 elf_append_rel (output_bfd, sreloc, &outrel);
37e55690
JJ		 4904 if (indx)
4905 continue;
4906 else if (r_type == R_386_TLS_LE_32)
eb4ff4d6 4907 relocation = elf_i386_dtpoff_base (info) - relocation;
37e55690 4908 else
eb4ff4d6 4909 relocation -= elf_i386_dtpoff_base (info);
37e55690
JJ		 4910 }
4911 else if (r_type == R_386_TLS_LE_32)
eb4ff4d6 4912 relocation = elf_i386_tpoff (info, relocation);
37e55690 4913 else
eb4ff4d6 4914 relocation = -elf_i386_tpoff (info, relocation);
13ae64f3
JJ		 4915 break;
4916
252b5132
RH		 4917 default:
4918 break;
4919 }
4920
239e1f3a
AM		 4921 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4922 because such sections are not SEC_ALLOC and thus ld.so will
4923 not process them. */
8c694914 4924 if (unresolved_reloc
239e1f3a 4925 && !((input_section->flags & SEC_DEBUGGING) != 0
1d5316ab
AM		 4926 && h->def_dynamic)
4927 && _bfd_elf_section_offset (output_bfd, info, input_section,
4928 rel->r_offset) != (bfd_vma) -1)
6a30718d
JJ		 4929 {
4930 (*_bfd_error_handler)
843fe662 4931 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
d003868e
AM		 4932 input_bfd,
4933 input_section,
6a30718d 4934 (long) rel->r_offset,
843fe662 4935 howto->name,
6a30718d 4936 h->root.root.string);
b34976b6 4937 return FALSE;
6a30718d 4938 }
83be169b 4939
cbe950e9 4940do_relocation:
252b5132
RH		 4941 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4942 contents, rel->r_offset,
55fd94b0 4943 relocation, 0);
252b5132 4944
62d78908 4945check_relocation_error:
cf5c0c5b 4946 if (r != bfd_reloc_ok)
252b5132 4947 {
cf5c0c5b 4948 const char *name;
ffb2e45b 4949
cf5c0c5b
AM		 4950 if (h != NULL)
4951 name = h->root.root.string;
4952 else
4953 {
4954 name = bfd_elf_string_from_elf_section (input_bfd,
4955 symtab_hdr->sh_link,
4956 sym->st_name);
4957 if (name == NULL)
b34976b6 4958 return FALSE;
cf5c0c5b
AM		 4959 if (*name == '\0')
4960 name = bfd_section_name (input_bfd, sec);
4961 }
ffb2e45b 4962
cf5c0c5b 4963 if (r == bfd_reloc_overflow)
1a72702b
AM		 4964 (*info->callbacks->reloc_overflow)
4965 (info, (h ? &h->root : NULL), name, howto->name,
4966 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
cf5c0c5b
AM		 4967 else
4968 {
4969 (*_bfd_error_handler)
d003868e
AM		 4970 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4971 input_bfd, input_section,
cf5c0c5b 4972 (long) rel->r_offset, name, (int) r);
b34976b6 4973 return FALSE;
cf5c0c5b 4974 }
252b5132 4975 }
60f2e42e
L		 4976
4977 if (wrel != rel)
4978 *wrel = *rel;
4979 }
4980
4981 if (wrel != rel)
4982 {
4983 Elf_Internal_Shdr *rel_hdr;
4984 size_t deleted = rel - wrel;
4985
4986 rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
4987 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
4988 if (rel_hdr->sh_size == 0)
4989 {
4990 /* It is too late to remove an empty reloc section. Leave
4991 one NONE reloc.
4992 ??? What is wrong with an empty section??? */
4993 rel_hdr->sh_size = rel_hdr->sh_entsize;
4994 deleted -= 1;
4995 }
4996 rel_hdr = _bfd_elf_single_rel_hdr (input_section);
4997 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
4998 input_section->reloc_count -= deleted;
252b5132
RH		 4999 }
5000
b34976b6 5001 return TRUE;
252b5132
RH		 5002}
5003
5004/* Finish up dynamic symbol handling. We set the contents of various
5005 dynamic sections here. */
5006
b34976b6 5007static bfd_boolean
55fd94b0
AM		 5008elf_i386_finish_dynamic_symbol (bfd *output_bfd,
5009 struct bfd_link_info *info,
5010 struct elf_link_hash_entry *h,
5011 Elf_Internal_Sym *sym)
252b5132 5012{
6725bdbf 5013 struct elf_i386_link_hash_table *htab;
25e762b9
RM		 5014 unsigned plt_entry_size;
5015 const struct elf_i386_backend_data *abed;
dd7e64d4 5016 struct elf_i386_link_hash_entry *eh;
aec6b87e 5017 bfd_boolean local_undefweak;
252b5132 5018
6725bdbf 5019 htab = elf_i386_hash_table (info);
4dfe6ac6
NC		 5020 if (htab == NULL)
5021 return FALSE;
252b5132 5022
25e762b9
RM		 5023 abed = get_elf_i386_backend_data (output_bfd);
5024 plt_entry_size = GET_PLT_ENTRY_SIZE (output_bfd);
5025
dd7e64d4
L		 5026 eh = (struct elf_i386_link_hash_entry *) h;
5027
aec6b87e
L		 5028 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
5029 resolved undefined weak symbols in executable so that their
5030 references have value 0 at run-time. */
e62b9723
L		 5031 local_undefweak = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info,
5032 eh->has_got_reloc,
5033 eh);
aec6b87e 5034
252b5132
RH		 5035 if (h->plt.offset != (bfd_vma) -1)
5036 {
252b5132
RH		 5037 bfd_vma plt_index;
5038 bfd_vma got_offset;
947216bf
AM		 5039 Elf_Internal_Rela rel;
5040 bfd_byte *loc;
cbe950e9
L		 5041 asection *plt, *gotplt, *relplt;
5042
5043 /* When building a static executable, use .iplt, .igot.plt and
5044 .rel.iplt sections for STT_GNU_IFUNC symbols. */
6de2ae4a 5045 if (htab->elf.splt != NULL)
cbe950e9 5046 {
6de2ae4a
L		 5047 plt = htab->elf.splt;
5048 gotplt = htab->elf.sgotplt;
5049 relplt = htab->elf.srelplt;
cbe950e9
L		 5050 }
5051 else
5052 {
6de2ae4a
L		 5053 plt = htab->elf.iplt;
5054 gotplt = htab->elf.igotplt;
5055 relplt = htab->elf.irelplt;
cbe950e9 5056 }
252b5132
RH		 5057
5058 /* This symbol has an entry in the procedure linkage table. Set
5059 it up. */
5060
cbe950e9 5061 if ((h->dynindx == -1
aec6b87e 5062 && !local_undefweak
0e1862bb 5063 && !((h->forced_local || bfd_link_executable (info))
cbe950e9
L		 5064 && h->def_regular
5065 && h->type == STT_GNU_IFUNC))
5066 || plt == NULL
5067 || gotplt == NULL
5068 || relplt == NULL)
cec7f46a 5069 abort ();
252b5132
RH		 5070
5071 /* Get the index in the procedure linkage table which
5072 corresponds to this symbol. This is the index of this symbol
5073 in all the symbols for which we are making plt entries. The
cbe950e9 5074 first entry in the procedure linkage table is reserved.
252b5132 5075
cbe950e9 5076 Get the offset into the .got table of the entry that
252b5132 5077 corresponds to this function. Each .got entry is 4 bytes.
cbe950e9 5078 The first three are reserved.
6bbec505 5079
cbe950e9
L		 5080 For static executables, we don't reserve anything. */
5081
6de2ae4a 5082 if (plt == htab->elf.splt)
cbe950e9 5083 {
e1f98742
L		 5084 got_offset = h->plt.offset / plt_entry_size - 1;
5085 got_offset = (got_offset + 3) * 4;
cbe950e9
L		 5086 }
5087 else
5088 {
e1f98742
L		 5089 got_offset = h->plt.offset / plt_entry_size;
5090 got_offset = got_offset * 4;
cbe950e9 5091 }
252b5132
RH		 5092
5093 /* Fill in the entry in the procedure linkage table. */
0e1862bb 5094 if (! bfd_link_pic (info))
252b5132 5095 {
25e762b9
RM		 5096 memcpy (plt->contents + h->plt.offset, abed->plt->plt_entry,
5097 abed->plt->plt_entry_size);
252b5132 5098 bfd_put_32 (output_bfd,
cbe950e9
L		 5099 (gotplt->output_section->vma
5100 + gotplt->output_offset
252b5132 5101 + got_offset),
25e762b9
RM		 5102 plt->contents + h->plt.offset
5103 + abed->plt->plt_got_offset);
eac338cf 5104
25e762b9 5105 if (abed->is_vxworks)
eac338cf
PB		 5106 {
5107 int s, k, reloc_index;
5108
5109 /* Create the R_386_32 relocation referencing the GOT
5110 for this PLT entry. */
5111
5112 /* S: Current slot number (zero-based). */
25e762b9
RM		 5113 s = ((h->plt.offset - abed->plt->plt_entry_size)
5114 / abed->plt->plt_entry_size);
eac338cf 5115 /* K: Number of relocations for PLTResolve. */
0e1862bb 5116 if (bfd_link_pic (info))
eac338cf
PB		 5117 k = PLTRESOLVE_RELOCS_SHLIB;
5118 else
5119 k = PLTRESOLVE_RELOCS;
5120 /* Skip the PLTresolve relocations, and the relocations for
5121 the other PLT slots. */
5122 reloc_index = k + s * PLT_NON_JUMP_SLOT_RELOCS;
5123 loc = (htab->srelplt2->contents + reloc_index
5124 * sizeof (Elf32_External_Rel));
5125
6de2ae4a
L		 5126 rel.r_offset = (htab->elf.splt->output_section->vma
5127 + htab->elf.splt->output_offset
eac338cf 5128 + h->plt.offset + 2),
7325306f 5129 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
eac338cf
PB		 5130 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
5131
5132 /* Create the R_386_32 relocation referencing the beginning of
5133 the PLT for this GOT entry. */
6de2ae4a
L		 5134 rel.r_offset = (htab->elf.sgotplt->output_section->vma
5135 + htab->elf.sgotplt->output_offset
eac338cf 5136 + got_offset);
7325306f 5137 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
eac338cf 5138 bfd_elf32_swap_reloc_out (output_bfd, &rel,
13ca3149 5139 loc + sizeof (Elf32_External_Rel));
eac338cf 5140 }
252b5132
RH		 5141 }
5142 else
5143 {
25e762b9
RM		 5144 memcpy (plt->contents + h->plt.offset, abed->plt->pic_plt_entry,
5145 abed->plt->plt_entry_size);
252b5132 5146 bfd_put_32 (output_bfd, got_offset,
25e762b9
RM		 5147 plt->contents + h->plt.offset
5148 + abed->plt->plt_got_offset);
252b5132
RH		 5149 }
5150
aec6b87e
L		 5151 /* Fill in the entry in the global offset table. Leave the entry
5152 as zero for undefined weak symbol in PIE. No PLT relocation
5153 against undefined weak symbol in PIE. */
5154 if (!local_undefweak)
cbe950e9 5155 {
cbe950e9 5156 bfd_put_32 (output_bfd,
aec6b87e
L		 5157 (plt->output_section->vma
5158 + plt->output_offset
5159 + h->plt.offset
5160 + abed->plt->plt_lazy_offset),
cbe950e9 5161 gotplt->contents + got_offset);
252b5132 5162
aec6b87e
L		 5163 /* Fill in the entry in the .rel.plt section. */
5164 rel.r_offset = (gotplt->output_section->vma
5165 + gotplt->output_offset
5166 + got_offset);
5167 if (h->dynindx == -1
5168 || ((bfd_link_executable (info)
5169 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
5170 && h->def_regular
5171 && h->type == STT_GNU_IFUNC))
5172 {
5173 /* If an STT_GNU_IFUNC symbol is locally defined, generate
5174 R_386_IRELATIVE instead of R_386_JUMP_SLOT. Store addend
5175 in the .got.plt section. */
5176 bfd_put_32 (output_bfd,
5177 (h->root.u.def.value
5178 + h->root.u.def.section->output_section->vma
5179 + h->root.u.def.section->output_offset),
5180 gotplt->contents + got_offset);
5181 rel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
5182 /* R_386_IRELATIVE comes last. */
5183 plt_index = htab->next_irelative_index--;
5184 }
5185 else
5186 {
5187 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
5188 plt_index = htab->next_jump_slot_index++;
5189 }
5190
5191 loc = relplt->contents + plt_index * sizeof (Elf32_External_Rel);
5192 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
5193
5194 /* Don't fill PLT entry for static executables. */
5195 if (plt == htab->elf.splt)
5196 {
5197 bfd_put_32 (output_bfd,
5198 plt_index * sizeof (Elf32_External_Rel),
5199 plt->contents + h->plt.offset
5200 + abed->plt->plt_reloc_offset);
5201 bfd_put_32 (output_bfd, - (h->plt.offset
5202 + abed->plt->plt_plt_offset + 4),
5203 plt->contents + h->plt.offset
5204 + abed->plt->plt_plt_offset);
5205 }
e1f98742 5206 }
dd7e64d4
L		 5207 }
5208 else if (eh->plt_got.offset != (bfd_vma) -1)
5209 {
5210 bfd_vma got_offset, plt_offset;
5211 asection *plt, *got, *gotplt;
5212 const bfd_byte *got_plt_entry;
5213
5214 /* Offset of displacement of the indirect jump. */
5215 bfd_vma plt_got_offset = 2;
e1f98742 5216
dd7e64d4
L		 5217 /* Set the entry in the GOT procedure linkage table. */
5218 plt = htab->plt_got;
5219 got = htab->elf.sgot;
5220 gotplt = htab->elf.sgotplt;
5221 got_offset = h->got.offset;
5222
5223 if (got_offset == (bfd_vma) -1
5224 || plt == NULL
5225 || got == NULL
5226 || gotplt == NULL)
5227 abort ();
5228
5229 /* Fill in the entry in the GOT procedure linkage table. */
0e1862bb 5230 if (! bfd_link_pic (info))
252b5132 5231 {
dd7e64d4
L		 5232 got_plt_entry = elf_i386_got_plt_entry;
5233 got_offset += got->output_section->vma + got->output_offset;
252b5132 5234 }
dd7e64d4
L		 5235 else
5236 {
5237 got_plt_entry = elf_i386_pic_got_plt_entry;
5238 got_offset += (got->output_section->vma
5239 + got->output_offset
5240 - gotplt->output_section->vma
5241 - gotplt->output_offset);
5242 }
5243
5244 plt_offset = eh->plt_got.offset;
5245 memcpy (plt->contents + plt_offset, got_plt_entry,
5246 sizeof (elf_i386_got_plt_entry));
5247 bfd_put_32 (output_bfd, got_offset,
5248 plt->contents + plt_offset + plt_got_offset);
5249 }
5250
aec6b87e
L		 5251 if (!local_undefweak
5252 && !h->def_regular
dd7e64d4
L		 5253 && (h->plt.offset != (bfd_vma) -1
5254 || eh->plt_got.offset != (bfd_vma) -1))
5255 {
5256 /* Mark the symbol as undefined, rather than as defined in
5257 the .plt section. Leave the value if there were any
5258 relocations where pointer equality matters (this is a clue
5259 for the dynamic linker, to make function pointer
5260 comparisons work between an application and shared
5261 library), otherwise set it to zero. If a function is only
5262 called from a binary, there is no need to slow down
5263 shared libraries because of that. */
5264 sym->st_shndx = SHN_UNDEF;
5265 if (!h->pointer_equality_needed)
5266 sym->st_value = 0;
252b5132
RH		 5267 }
5268
aec6b87e
L		 5269 /* Don't generate dynamic GOT relocation against undefined weak
5270 symbol in executable. */
13ae64f3 5271 if (h->got.offset != (bfd_vma) -1
67a4f2b7 5272 && ! GOT_TLS_GD_ANY_P (elf_i386_hash_entry(h)->tls_type)
aec6b87e
L		 5273 && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE) == 0
5274 && !local_undefweak)
252b5132 5275 {
947216bf 5276 Elf_Internal_Rela rel;
252b5132
RH		 5277
5278 /* This symbol has an entry in the global offset table. Set it
5279 up. */
5280
6de2ae4a 5281 if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
ffb2e45b 5282 abort ();
252b5132 5283
6de2ae4a
L		 5284 rel.r_offset = (htab->elf.sgot->output_section->vma
5285 + htab->elf.sgot->output_offset
dc810e39 5286 + (h->got.offset & ~(bfd_vma) 1));
252b5132 5287
dd5724d5
AM		 5288 /* If this is a static link, or it is a -Bsymbolic link and the
5289 symbol is defined locally or was forced to be local because
5290 of a version file, we just want to emit a RELATIVE reloc.
252b5132
RH		 5291 The entry in the global offset table will already have been
5292 initialized in the relocate_section function. */
710ab287 5293 if (h->def_regular
0018b0a3
L		 5294 && h->type == STT_GNU_IFUNC)
5295 {
0e1862bb 5296 if (bfd_link_pic (info))
710ab287
L		 5297 {
5298 /* Generate R_386_GLOB_DAT. */
5299 goto do_glob_dat;
5300 }
5301 else
5302 {
cd2b2c10
L		 5303 asection *plt;
5304
710ab287
L		 5305 if (!h->pointer_equality_needed)
5306 abort ();
5307
5308 /* For non-shared object, we can't use .got.plt, which
5309 contains the real function addres if we need pointer
5310 equality. We load the GOT entry with the PLT entry. */
cd2b2c10 5311 plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
710ab287
L		 5312 bfd_put_32 (output_bfd,
5313 (plt->output_section->vma
5314 + plt->output_offset + h->plt.offset),
6de2ae4a 5315 htab->elf.sgot->contents + h->got.offset);
710ab287
L		 5316 return TRUE;
5317 }
0018b0a3 5318 }
0e1862bb 5319 else if (bfd_link_pic (info)
0018b0a3 5320 && SYMBOL_REFERENCES_LOCAL (info, h))
dd5724d5 5321 {
6725bdbf 5322 BFD_ASSERT((h->got.offset & 1) != 0);
dd5724d5
AM		 5323 rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
5324 }
252b5132
RH		 5325 else
5326 {
dd5724d5 5327 BFD_ASSERT((h->got.offset & 1) == 0);
710ab287 5328do_glob_dat:
6725bdbf 5329 bfd_put_32 (output_bfd, (bfd_vma) 0,
6de2ae4a 5330 htab->elf.sgot->contents + h->got.offset);
252b5132
RH		 5331 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
5332 }
5333
59d6ffb2 5334 elf_append_rel (output_bfd, htab->elf.srelgot, &rel);
252b5132
RH		 5335 }
5336
f5385ebf 5337 if (h->needs_copy)
252b5132 5338 {
947216bf 5339 Elf_Internal_Rela rel;
252b5132
RH		 5340
5341 /* This symbol needs a copy reloc. Set it up. */
5342
ffb2e45b
AM		 5343 if (h->dynindx == -1
5344 || (h->root.type != bfd_link_hash_defined
5345 && h->root.type != bfd_link_hash_defweak)
5346 || htab->srelbss == NULL)
5347 abort ();
252b5132
RH		 5348
5349 rel.r_offset = (h->root.u.def.value
5350 + h->root.u.def.section->output_section->vma
5351 + h->root.u.def.section->output_offset);
5352 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
59d6ffb2 5353 elf_append_rel (output_bfd, htab->srelbss, &rel);
252b5132
RH		 5354 }
5355
b34976b6 5356 return TRUE;
252b5132
RH		 5357}
5358
c25bc9fc
L		 5359/* Finish up local dynamic symbol handling. We set the contents of
5360 various dynamic sections here. */
5361
5362static bfd_boolean
5363elf_i386_finish_local_dynamic_symbol (void **slot, void *inf)
5364{
5365 struct elf_link_hash_entry *h
5366 = (struct elf_link_hash_entry *) *slot;
5367 struct bfd_link_info *info
23209a78 5368 = (struct bfd_link_info *) inf;
c25bc9fc
L		 5369
5370 return elf_i386_finish_dynamic_symbol (info->output_bfd, info,
5371 h, NULL);
5372}
5373
aec6b87e
L		 5374/* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
5375 here since undefined weak symbol may not be dynamic and may not be
5376 called for elf_i386_finish_dynamic_symbol. */
5377
5378static bfd_boolean
5379elf_i386_pie_finish_undefweak_symbol (struct bfd_hash_entry *bh,
5380 void *inf)
5381{
5382 struct elf_link_hash_entry *h = (struct elf_link_hash_entry *) bh;
5383 struct bfd_link_info *info = (struct bfd_link_info *) inf;
5384
5385 if (h->root.type != bfd_link_hash_undefweak
5386 || h->dynindx != -1)
5387 return TRUE;
5388
5389 return elf_i386_finish_dynamic_symbol (info->output_bfd,
5390 info, h, NULL);
5391}
5392
38701953
AM		 5393/* Used to decide how to sort relocs in an optimal manner for the
5394 dynamic linker, before writing them out. */
5395
5396static enum elf_reloc_type_class
cae1fbbb 5397elf_i386_reloc_type_class (const struct bfd_link_info *info,
7e612e98
AM		 5398 const asection *rel_sec ATTRIBUTE_UNUSED,
5399 const Elf_Internal_Rela *rela)
38701953 5400{
cae1fbbb
L		 5401 bfd *abfd = info->output_bfd;
5402 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5403 struct elf_link_hash_table *htab = elf_hash_table (info);
cae1fbbb 5404
d9e3b590
L		 5405 if (htab->dynsym != NULL
5406 && htab->dynsym->contents != NULL)
5407 {
5408 /* Check relocation against STT_GNU_IFUNC symbol if there are
5409 dynamic symbols. */
5410 unsigned long r_symndx = ELF32_R_SYM (rela->r_info);
5411 Elf_Internal_Sym sym;
5412 if (!bed->s->swap_symbol_in (abfd,
5413 (htab->dynsym->contents
5414 + r_symndx * sizeof (Elf32_External_Sym)),
5415 0, &sym))
5416 abort ();
5417
5418 if (ELF32_ST_TYPE (sym.st_info) == STT_GNU_IFUNC)
5419 return reloc_class_ifunc;
5420 }
cae1fbbb 5421
55fd94b0 5422 switch (ELF32_R_TYPE (rela->r_info))
38701953
AM		 5423 {
5424 case R_386_RELATIVE:
5425 return reloc_class_relative;
5426 case R_386_JUMP_SLOT:
5427 return reloc_class_plt;
5428 case R_386_COPY:
5429 return reloc_class_copy;
5430 default:
5431 return reloc_class_normal;
5432 }
5433}
5434
252b5132
RH		 5435/* Finish up the dynamic sections. */
5436
b34976b6 5437static bfd_boolean
55fd94b0
AM		 5438elf_i386_finish_dynamic_sections (bfd *output_bfd,
5439 struct bfd_link_info *info)
252b5132 5440{
6725bdbf 5441 struct elf_i386_link_hash_table *htab;
252b5132 5442 bfd *dynobj;
252b5132 5443 asection *sdyn;
25e762b9 5444 const struct elf_i386_backend_data *abed;
252b5132 5445
6725bdbf 5446 htab = elf_i386_hash_table (info);
4dfe6ac6
NC		 5447 if (htab == NULL)
5448 return FALSE;
5449
ebe50bae 5450 dynobj = htab->elf.dynobj;
3d4d4302 5451 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
25e762b9 5452 abed = get_elf_i386_backend_data (output_bfd);
252b5132 5453
ebe50bae 5454 if (htab->elf.dynamic_sections_created)
252b5132 5455 {
252b5132
RH		 5456 Elf32_External_Dyn *dyncon, *dynconend;
5457
6de2ae4a 5458 if (sdyn == NULL || htab->elf.sgot == NULL)
ffb2e45b 5459 abort ();
252b5132
RH		 5460
5461 dyncon = (Elf32_External_Dyn *) sdyn->contents;
eea6121a 5462 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
252b5132
RH		 5463 for (; dyncon < dynconend; dyncon++)
5464 {
5465 Elf_Internal_Dyn dyn;
51b64d56 5466 asection *s;
252b5132
RH		 5467
5468 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
5469
5470 switch (dyn.d_tag)
5471 {
5472 default:
25e762b9
RM		 5473 if (abed->is_vxworks
5474 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
7a2b07ff 5475 break;
0ac8d2ca 5476 continue;
252b5132
RH		 5477
5478 case DT_PLTGOT:
6de2ae4a 5479 s = htab->elf.sgotplt;
8c37241b 5480 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
6725bdbf
AM		 5481 break;
5482
252b5132 5483 case DT_JMPREL:
6de2ae4a 5484 s = htab->elf.srelplt;
6348e046 5485 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
252b5132
RH		 5486 break;
5487
5488 case DT_PLTRELSZ:
6de2ae4a 5489 s = htab->elf.srelplt;
eea6121a 5490 dyn.d_un.d_val = s->size;
252b5132
RH		 5491 break;
5492
5493 case DT_RELSZ:
5494 /* My reading of the SVR4 ABI indicates that the
5495 procedure linkage table relocs (DT_JMPREL) should be
5496 included in the overall relocs (DT_REL). This is
5497 what Solaris does. However, UnixWare can not handle
5498 that case. Therefore, we override the DT_RELSZ entry
6348e046 5499 here to make it not include the JMPREL relocs. */
6de2ae4a 5500 s = htab->elf.srelplt;
6348e046
AM		 5501 if (s == NULL)
5502 continue;
eea6121a 5503 dyn.d_un.d_val -= s->size;
6348e046
AM		 5504 break;
5505
5506 case DT_REL:
5507 /* We may not be using the standard ELF linker script.
5508 If .rel.plt is the first .rel section, we adjust
5509 DT_REL to not include it. */
6de2ae4a 5510 s = htab->elf.srelplt;
6348e046
AM		 5511 if (s == NULL)
5512 continue;
5513 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
5514 continue;
eea6121a 5515 dyn.d_un.d_ptr += s->size;
252b5132
RH		 5516 break;
5517 }
0ac8d2ca
AM		 5518
5519 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
252b5132
RH		 5520 }
5521
5522 /* Fill in the first entry in the procedure linkage table. */
6de2ae4a 5523 if (htab->elf.splt && htab->elf.splt->size > 0)
252b5132 5524 {
0e1862bb 5525 if (bfd_link_pic (info))
eac338cf 5526 {
25e762b9
RM		 5527 memcpy (htab->elf.splt->contents, abed->plt->pic_plt0_entry,
5528 abed->plt->plt0_entry_size);
5529 memset (htab->elf.splt->contents + abed->plt->plt0_entry_size,
5530 abed->plt0_pad_byte,
5531 abed->plt->plt_entry_size - abed->plt->plt0_entry_size);
eac338cf 5532 }
252b5132
RH		 5533 else
5534 {
25e762b9
RM		 5535 memcpy (htab->elf.splt->contents, abed->plt->plt0_entry,
5536 abed->plt->plt0_entry_size);
5537 memset (htab->elf.splt->contents + abed->plt->plt0_entry_size,
5538 abed->plt0_pad_byte,
5539 abed->plt->plt_entry_size - abed->plt->plt0_entry_size);
252b5132 5540 bfd_put_32 (output_bfd,
6de2ae4a
L		 5541 (htab->elf.sgotplt->output_section->vma
5542 + htab->elf.sgotplt->output_offset
6725bdbf 5543 + 4),
25e762b9
RM		 5544 htab->elf.splt->contents
5545 + abed->plt->plt0_got1_offset);
252b5132 5546 bfd_put_32 (output_bfd,
6de2ae4a
L		 5547 (htab->elf.sgotplt->output_section->vma
5548 + htab->elf.sgotplt->output_offset
6725bdbf 5549 + 8),
25e762b9
RM		 5550 htab->elf.splt->contents
5551 + abed->plt->plt0_got2_offset);
eac338cf 5552
25e762b9 5553 if (abed->is_vxworks)
eac338cf
PB		 5554 {
5555 Elf_Internal_Rela rel;
7325306f 5556
eac338cf
PB		 5557 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 4.
5558 On IA32 we use REL relocations so the addend goes in
5559 the PLT directly. */
6de2ae4a
L		 5560 rel.r_offset = (htab->elf.splt->output_section->vma
5561 + htab->elf.splt->output_offset
25e762b9 5562 + abed->plt->plt0_got1_offset);
7325306f 5563 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
eac338cf
PB		 5564 bfd_elf32_swap_reloc_out (output_bfd, &rel,
5565 htab->srelplt2->contents);
5566 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
6de2ae4a
L		 5567 rel.r_offset = (htab->elf.splt->output_section->vma
5568 + htab->elf.splt->output_offset
25e762b9 5569 + abed->plt->plt0_got2_offset);
7325306f 5570 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
eac338cf
PB		 5571 bfd_elf32_swap_reloc_out (output_bfd, &rel,
5572 htab->srelplt2->contents +
5573 sizeof (Elf32_External_Rel));
5574 }
252b5132
RH		 5575 }
5576
5577 /* UnixWare sets the entsize of .plt to 4, although that doesn't
5578 really seem like the right value. */
6de2ae4a 5579 elf_section_data (htab->elf.splt->output_section)
6725bdbf 5580 ->this_hdr.sh_entsize = 4;
eac338cf
PB		 5581
5582 /* Correct the .rel.plt.unloaded relocations. */
0e1862bb 5583 if (abed->is_vxworks && !bfd_link_pic (info))
eac338cf 5584 {
25e762b9
RM		 5585 int num_plts = (htab->elf.splt->size
5586 / abed->plt->plt_entry_size) - 1;
4c9b0de6 5587 unsigned char *p;
eac338cf
PB		 5588
5589 p = htab->srelplt2->contents;
0e1862bb 5590 if (bfd_link_pic (info))
eac338cf
PB		 5591 p += PLTRESOLVE_RELOCS_SHLIB * sizeof (Elf32_External_Rel);
5592 else
5593 p += PLTRESOLVE_RELOCS * sizeof (Elf32_External_Rel);
5594
5595 for (; num_plts; num_plts--)
5596 {
5597 Elf_Internal_Rela rel;
5598 bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
7325306f 5599 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
eac338cf
PB		 5600 bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
5601 p += sizeof (Elf32_External_Rel);
5602
5603 bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
7325306f 5604 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
eac338cf
PB		 5605 bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
5606 p += sizeof (Elf32_External_Rel);
5607 }
5608 }
252b5132
RH		 5609 }
5610 }
5611
6de2ae4a 5612 if (htab->elf.sgotplt)
252b5132 5613 {
56d4289c
L		 5614 if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
5615 {
5616 (*_bfd_error_handler)
5617 (_("discarded output section: `%A'"), htab->elf.sgotplt);
5618 return FALSE;
5619 }
5620
12d0ee4a 5621 /* Fill in the first three entries in the global offset table. */
6de2ae4a 5622 if (htab->elf.sgotplt->size > 0)
12d0ee4a
AM		 5623 {
5624 bfd_put_32 (output_bfd,
55fd94b0 5625 (sdyn == NULL ? 0
12d0ee4a 5626 : sdyn->output_section->vma + sdyn->output_offset),
6de2ae4a
L		 5627 htab->elf.sgotplt->contents);
5628 bfd_put_32 (output_bfd, 0, htab->elf.sgotplt->contents + 4);
5629 bfd_put_32 (output_bfd, 0, htab->elf.sgotplt->contents + 8);
12d0ee4a 5630 }
252b5132 5631
6de2ae4a 5632 elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize = 4;
12d0ee4a 5633 }
8c37241b 5634
e41b3a13 5635 /* Adjust .eh_frame for .plt section. */
9a2a56cc
AM		 5636 if (htab->plt_eh_frame != NULL
5637 && htab->plt_eh_frame->contents != NULL)
e41b3a13
JJ		 5638 {
5639 if (htab->elf.splt != NULL
5640 && htab->elf.splt->size != 0
5641 && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
5642 && htab->elf.splt->output_section != NULL
5643 && htab->plt_eh_frame->output_section != NULL)
5644 {
5645 bfd_vma plt_start = htab->elf.splt->output_section->vma;
5646 bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
5647 + htab->plt_eh_frame->output_offset
5648 + PLT_FDE_START_OFFSET;
5649 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
5650 htab->plt_eh_frame->contents
5651 + PLT_FDE_START_OFFSET);
5652 }
5653 if (htab->plt_eh_frame->sec_info_type
dbaa2011 5654 == SEC_INFO_TYPE_EH_FRAME)
e41b3a13
JJ		 5655 {
5656 if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
5657 htab->plt_eh_frame,
5658 htab->plt_eh_frame->contents))
5659 return FALSE;
5660 }
5661 }
5662
6de2ae4a
L		 5663 if (htab->elf.sgot && htab->elf.sgot->size > 0)
5664 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 4;
8c37241b 5665
c25bc9fc
L		 5666 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
5667 htab_traverse (htab->loc_hash_table,
5668 elf_i386_finish_local_dynamic_symbol,
5669 info);
5670
aec6b87e
L		 5671 /* Fill PLT entries for undefined weak symbols in PIE. */
5672 if (bfd_link_pie (info))
5673 bfd_hash_traverse (&info->hash->table,
5674 elf_i386_pie_finish_undefweak_symbol,
5675 info);
5676
b34976b6 5677 return TRUE;
252b5132
RH		 5678}
5679
3972882e 5680/* Return an array of PLT entry symbol values. */
4c45e5c9 5681
3972882e
L		 5682static bfd_vma *
5683elf_i386_get_plt_sym_val (bfd *abfd, asymbol **dynsyms, asection *plt,
5684 asection *relplt)
4c45e5c9 5685{
3972882e
L		 5686 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
5687 arelent *p;
5688 long count, i;
5689 bfd_vma *plt_sym_val;
144bed8d 5690 bfd_vma plt_offset;
3972882e
L		 5691 bfd_byte *plt_contents;
5692 const struct elf_i386_backend_data *bed
5693 = get_elf_i386_backend_data (abfd);
5694 Elf_Internal_Shdr *hdr;
5695
5696 /* Get the .plt section contents. */
5697 plt_contents = (bfd_byte *) bfd_malloc (plt->size);
5698 if (plt_contents == NULL)
5699 return NULL;
5700 if (!bfd_get_section_contents (abfd, (asection *) plt,
5701 plt_contents, 0, plt->size))
5702 {
5703bad_return:
5704 free (plt_contents);
5705 return NULL;
5706 }
144bed8d 5707
3972882e
L		 5708 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
5709 if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
5710 goto bad_return;
144bed8d 5711
3972882e
L		 5712 hdr = &elf_section_data (relplt)->this_hdr;
5713 count = relplt->size / hdr->sh_entsize;
5714
5715 plt_sym_val = (bfd_vma *) bfd_malloc (sizeof (bfd_vma) * count);
5716 if (plt_sym_val == NULL)
5717 goto bad_return;
cca5b8b6 5718
35181b3e 5719 for (i = 0; i < count; i++)
3972882e 5720 plt_sym_val[i] = -1;
cca5b8b6 5721
3972882e
L		 5722 plt_offset = bed->plt->plt_entry_size;
5723 p = relplt->relocation;
5724 for (i = 0; i < count; i++, p++)
144bed8d 5725 {
3972882e
L		 5726 long reloc_index;
5727
6f25f223 5728 /* Skip unknown relocation. PR 17512: file: bc9d6cf5. */
533d0af0 5729 if (p->howto == NULL)
6f25f223 5730 continue;
533d0af0
L		 5731
5732 if (p->howto->type != R_386_JUMP_SLOT
5733 && p->howto->type != R_386_IRELATIVE)
3972882e
L		 5734 continue;
5735
5736 reloc_index = H_GET_32 (abfd, (plt_contents + plt_offset
5737 + bed->plt->plt_reloc_offset));
5738 reloc_index /= sizeof (Elf32_External_Rel);
ec1f73bb
AM		 5739 if (reloc_index < count)
5740 plt_sym_val[reloc_index] = plt->vma + plt_offset;
5741
144bed8d 5742 plt_offset += bed->plt->plt_entry_size;
fca6ae69
L		 5743
5744 /* PR binutils/18437: Skip extra relocations in the .rel.plt
5745 section. */
5746 if (plt_offset >= plt->size)
5747 break;
144bed8d
L		 5748 }
5749
3972882e
L		 5750 free (plt_contents);
5751
5752 return plt_sym_val;
5753}
5754
5755/* Similar to _bfd_elf_get_synthetic_symtab. */
5756
5757static long
5758elf_i386_get_synthetic_symtab (bfd *abfd,
5759 long symcount,
5760 asymbol **syms,
5761 long dynsymcount,
5762 asymbol **dynsyms,
5763 asymbol **ret)
5764{
5765 asection *plt = bfd_get_section_by_name (abfd, ".plt");
5766 return _bfd_elf_ifunc_get_synthetic_symtab (abfd, symcount, syms,
5767 dynsymcount, dynsyms, ret,
5768 plt,
5769 elf_i386_get_plt_sym_val);
4c45e5c9
JJ		 5770}
5771
fdc90cb4
JJ		 5772/* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
5773
5774static bfd_boolean
5775elf_i386_hash_symbol (struct elf_link_hash_entry *h)
5776{
5777 if (h->plt.offset != (bfd_vma) -1
5778 && !h->def_regular
5779 && !h->pointer_equality_needed)
5780 return FALSE;
5781
5782 return _bfd_elf_hash_symbol (h);
5783}
4c45e5c9 5784
6d00b590 5785#define TARGET_LITTLE_SYM i386_elf32_vec
252b5132
RH		 5786#define TARGET_LITTLE_NAME "elf32-i386"
5787#define ELF_ARCH bfd_arch_i386
ae95ffa6 5788#define ELF_TARGET_ID I386_ELF_DATA
252b5132
RH		 5789#define ELF_MACHINE_CODE EM_386
5790#define ELF_MAXPAGESIZE 0x1000
252b5132
RH		 5791
5792#define elf_backend_can_gc_sections 1
51b64d56 5793#define elf_backend_can_refcount 1
252b5132
RH		 5794#define elf_backend_want_got_plt 1
5795#define elf_backend_plt_readonly 1
5796#define elf_backend_want_plt_sym 0
5797#define elf_backend_got_header_size 12
e41b3a13 5798#define elf_backend_plt_alignment 4
f7483970 5799#define elf_backend_extern_protected_data 1
bedfd056 5800#define elf_backend_caches_rawsize 1
252b5132 5801
8c29f035
AM		 5802/* Support RELA for objdump of prelink objects. */
5803#define elf_info_to_howto elf_i386_info_to_howto_rel
dd5724d5
AM		 5804#define elf_info_to_howto_rel elf_i386_info_to_howto_rel
5805
13ae64f3 5806#define bfd_elf32_mkobject elf_i386_mkobject
13ae64f3 5807
dd5724d5
AM		 5808#define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
5809#define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
5810#define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
13285a1b 5811#define bfd_elf32_bfd_reloc_name_lookup elf_i386_reloc_name_lookup
3972882e 5812#define bfd_elf32_get_synthetic_symtab elf_i386_get_synthetic_symtab
dd5724d5
AM		 5813
5814#define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
13285a1b 5815#define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
dd5724d5 5816#define elf_backend_check_relocs elf_i386_check_relocs
0ac8d2ca 5817#define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
6725bdbf 5818#define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
0ac8d2ca 5819#define elf_backend_fake_sections elf_i386_fake_sections
dd5724d5
AM		 5820#define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
5821#define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
5822#define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
c5fccbec
DJ		 5823#define elf_backend_grok_prstatus elf_i386_grok_prstatus
5824#define elf_backend_grok_psinfo elf_i386_grok_psinfo
db6751f2 5825#define elf_backend_reloc_type_class elf_i386_reloc_type_class
0ac8d2ca
AM		 5826#define elf_backend_relocate_section elf_i386_relocate_section
5827#define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
67a4f2b7 5828#define elf_backend_always_size_sections elf_i386_always_size_sections
74541ad4
AM		 5829#define elf_backend_omit_section_dynsym \
5830 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
fdc90cb4 5831#define elf_backend_hash_symbol elf_i386_hash_symbol
aec6b87e 5832#define elf_backend_fixup_symbol elf_i386_fixup_symbol
dd5724d5 5833
252b5132 5834#include "elf32-target.h"
2bc3c89a
AM		 5835
5836/* FreeBSD support. */
5837
5838#undef TARGET_LITTLE_SYM
6d00b590 5839#define TARGET_LITTLE_SYM i386_elf32_fbsd_vec
2bc3c89a
AM		 5840#undef TARGET_LITTLE_NAME
5841#define TARGET_LITTLE_NAME "elf32-i386-freebsd"
d1036acb
L		 5842#undef ELF_OSABI
5843#define ELF_OSABI ELFOSABI_FREEBSD
2bc3c89a
AM		 5844
5845/* The kernel recognizes executables as valid only if they carry a
5846 "FreeBSD" label in the ELF header. So we put this label on all
5847 executables and (for simplicity) also all other object files. */
5848
2bc3c89a 5849static void
d8045f23 5850elf_i386_fbsd_post_process_headers (bfd *abfd, struct bfd_link_info *info)
2bc3c89a 5851{
78245035 5852 _bfd_elf_post_process_headers (abfd, info);
2bc3c89a 5853
2bc3c89a 5854#ifdef OLD_FREEBSD_ABI_LABEL
cf7363b4
L		 5855 {
5856 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
5857 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
5858 memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
5859 }
caf47ea6 5860#endif
2bc3c89a
AM		 5861}
5862
5863#undef elf_backend_post_process_headers
d8045f23 5864#define elf_backend_post_process_headers elf_i386_fbsd_post_process_headers
571fe01f
NC		 5865#undef elf32_bed
5866#define elf32_bed elf32_i386_fbsd_bed
2bc3c89a 5867
d8045f23
NC		 5868#undef elf_backend_add_symbol_hook
5869
2bc3c89a 5870#include "elf32-target.h"
eac338cf 5871
a6cc6b3b
RO		 5872/* Solaris 2. */
5873
5874#undef TARGET_LITTLE_SYM
6d00b590 5875#define TARGET_LITTLE_SYM i386_elf32_sol2_vec
a6cc6b3b
RO		 5876#undef TARGET_LITTLE_NAME
5877#define TARGET_LITTLE_NAME "elf32-i386-sol2"
5878
914082d1
L		 5879#undef elf_backend_post_process_headers
5880
a6cc6b3b
RO		 5881/* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
5882 objects won't be recognized. */
5883#undef ELF_OSABI
5884
5885#undef elf32_bed
5886#define elf32_bed elf32_i386_sol2_bed
5887
7dc98aea
RO		 5888/* The 32-bit static TLS arena size is rounded to the nearest 8-byte
5889 boundary. */
84865015 5890#undef elf_backend_static_tls_alignment
7dc98aea
RO		 5891#define elf_backend_static_tls_alignment 8
5892
a6cc6b3b
RO		 5893/* The Solaris 2 ABI requires a plt symbol on all platforms.
5894
5895 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
5896 File, p.63. */
84865015 5897#undef elf_backend_want_plt_sym
a6cc6b3b
RO		 5898#define elf_backend_want_plt_sym 1
5899
84865015
NC		 5900#undef elf_backend_strtab_flags
5901#define elf_backend_strtab_flags SHF_STRINGS
5902
5522f910
NC		 5903/* Called to set the sh_flags, sh_link and sh_info fields of OSECTION which
5904 has a type >= SHT_LOOS. Returns TRUE if these fields were initialised
5905 FALSE otherwise. ISECTION is the best guess matching section from the
5906 input bfd IBFD, but it might be NULL. */
5907
84865015 5908static bfd_boolean
5522f910
NC		 5909elf32_i386_copy_solaris_special_section_fields (const bfd *ibfd ATTRIBUTE_UNUSED,
5910 bfd *obfd ATTRIBUTE_UNUSED,
5911 const Elf_Internal_Shdr *isection ATTRIBUTE_UNUSED,
5912 Elf_Internal_Shdr *osection ATTRIBUTE_UNUSED)
84865015
NC		 5913{
5914 /* PR 19938: FIXME: Need to add code for setting the sh_info
5522f910
NC		 5915 and sh_link fields of Solaris specific section types. */
5916 return FALSE;
84865015 5917
5522f910 5918 /* Based upon Oracle Solaris 11.3 Linkers and Libraries Guide, Ch. 13,
84865015
NC		 5919 Object File Format, Table 13-9 ELF sh_link and sh_info Interpretation:
5920
5921http://docs.oracle.com/cd/E53394_01/html/E54813/chapter6-94076.html#scrolltoc
5922
5923 The following values should be set:
5924
5925Type Link Info
5926-----------------------------------------------------------------------------
5927SHT_SUNW_ancillary The section header index of 0
5928 [0x6fffffee] the associated string table.
5929
5930SHT_SUNW_capinfo The section header index of For a dynamic object, the
5931 [0x6ffffff0] the associated symbol table. section header index of
5932 the associated
5933 SHT_SUNW_capchain table,
5934 otherwise 0.
5935
5936SHT_SUNW_symsort The section header index of 0
5937 [0x6ffffff1] the associated symbol table.
5938
5939SHT_SUNW_tlssort The section header index of 0
5940 [0x6ffffff2] the associated symbol table.
5941
5942SHT_SUNW_LDYNSYM The section header index of One greater than the
5943 [0x6ffffff3] the associated string table. symbol table index of the
5944 This index is the same string last local symbol,
5945 table used by the SHT_DYNSYM STB_LOCAL. Since
5946 section. SHT_SUNW_LDYNSYM only
5947 contains local symbols,
5948 sh_info is equivalent to
5949 the number of symbols in
5950 the table.
5951
5952SHT_SUNW_cap If symbol capabilities exist, If any capabilities refer
5953 [0x6ffffff5] the section header index of to named strings, the
5954 the associated section header index of
5955 SHT_SUNW_capinfo table, the associated string
5956 otherwise 0. table, otherwise 0.
5957
5958SHT_SUNW_move The section header index of 0
5959 [0x6ffffffa] the associated symbol table.
5960
5961SHT_SUNW_COMDAT 0 0
5962 [0x6ffffffb]
5963
5964SHT_SUNW_syminfo The section header index of The section header index
5965 [0x6ffffffc] the associated symbol table. of the associated
5966 .dynamic section.
5967
5968SHT_SUNW_verdef The section header index of The number of version
5969 [0x6ffffffd] the associated string table. definitions within the
5970 section.
5971
5972SHT_SUNW_verneed The section header index of The number of version
5973 [0x6ffffffe] the associated string table. dependencies within the
5974 section.
5975
5976SHT_SUNW_versym The section header index of 0
5977 [0x6fffffff] the associated symbol table. */
84865015
NC		 5978}
5979
5522f910
NC		 5980#undef elf_backend_copy_special_section_fields
5981#define elf_backend_copy_special_section_fields elf32_i386_copy_solaris_special_section_fields
84865015 5982
a6cc6b3b
RO		 5983#include "elf32-target.h"
5984
bf64a951
L		 5985/* Intel MCU support. */
5986
5987static bfd_boolean
5988elf32_iamcu_elf_object_p (bfd *abfd)
5989{
5990 /* Set the right machine number for an IAMCU elf32 file. */
5991 bfd_default_set_arch_mach (abfd, bfd_arch_iamcu, bfd_mach_i386_iamcu);
5992 return TRUE;
5993}
5994
5995#undef TARGET_LITTLE_SYM
5996#define TARGET_LITTLE_SYM iamcu_elf32_vec
5997#undef TARGET_LITTLE_NAME
5998#define TARGET_LITTLE_NAME "elf32-iamcu"
84865015 5999#undef ELF_ARCH
bf64a951
L		 6000#define ELF_ARCH bfd_arch_iamcu
6001
6002#undef ELF_MACHINE_CODE
6003#define ELF_MACHINE_CODE EM_IAMCU
6004
6005#undef ELF_OSABI
6006
6007#undef elf32_bed
6008#define elf32_bed elf32_iamcu_bed
6009
6010#undef elf_backend_object_p
6011#define elf_backend_object_p elf32_iamcu_elf_object_p
6012
6013#undef elf_backend_static_tls_alignment
6014
6015#undef elf_backend_want_plt_sym
6016#define elf_backend_want_plt_sym 0
6017
84865015 6018#undef elf_backend_strtab_flags
5522f910 6019#undef elf_backend_copy_special_section_fields
84865015 6020
bf64a951
L		 6021#include "elf32-target.h"
6022
6023/* Restore defaults. */
6024#undef ELF_ARCH
6025#define ELF_ARCH bfd_arch_i386
6026#undef ELF_MACHINE_CODE
6027#define ELF_MACHINE_CODE EM_386
6028
a27e4371
RM		 6029/* Native Client support. */
6030
6031#undef TARGET_LITTLE_SYM
6d00b590 6032#define TARGET_LITTLE_SYM i386_elf32_nacl_vec
a27e4371
RM		 6033#undef TARGET_LITTLE_NAME
6034#define TARGET_LITTLE_NAME "elf32-i386-nacl"
6035#undef elf32_bed
6036#define elf32_bed elf32_i386_nacl_bed
6037
6038#undef ELF_MAXPAGESIZE
6039#define ELF_MAXPAGESIZE 0x10000
6040
6041/* Restore defaults. */
6042#undef ELF_OSABI
6043#undef elf_backend_want_plt_sym
6044#define elf_backend_want_plt_sym 0
6045#undef elf_backend_post_process_headers
a27e4371
RM		 6046#undef elf_backend_static_tls_alignment
6047
6048/* NaCl uses substantially different PLT entries for the same effects. */
6049
6050#undef elf_backend_plt_alignment
6051#define elf_backend_plt_alignment 5
6052#define NACL_PLT_ENTRY_SIZE 64
6053#define NACLMASK 0xe0 /* 32-byte alignment mask. */
6054
6055static const bfd_byte elf_i386_nacl_plt0_entry[] =
6056 {
6057 0xff, 0x35, /* pushl contents of address */
6058 0, 0, 0, 0, /* replaced with address of .got + 4. */
6059 0x8b, 0x0d, /* movl contents of address, %ecx */
6060 0, 0, 0, 0, /* replaced with address of .got + 8. */
6061 0x83, 0xe1, NACLMASK, /* andl $NACLMASK, %ecx */
6062 0xff, 0xe1 /* jmp *%ecx */
6063 };
6064
6065static const bfd_byte elf_i386_nacl_plt_entry[NACL_PLT_ENTRY_SIZE] =
6066 {
6067 0x8b, 0x0d, /* movl contents of address, %ecx */
6068 0, 0, 0, 0, /* replaced with GOT slot address. */
6069 0x83, 0xe1, NACLMASK, /* andl $NACLMASK, %ecx */
6070 0xff, 0xe1, /* jmp *%ecx */
6071
6072 /* Pad to the next 32-byte boundary with nop instructions. */
6073 0x90,
6074 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6075 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6076
6077 /* Lazy GOT entries point here (32-byte aligned). */
6078 0x68, /* pushl immediate */
6079 0, 0, 0, 0, /* replaced with reloc offset. */
6080 0xe9, /* jmp relative */
6081 0, 0, 0, 0, /* replaced with offset to .plt. */
6082
6083 /* Pad to the next 32-byte boundary with nop instructions. */
6084 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6085 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6086 0x90, 0x90
6087 };
6088
6089static const bfd_byte
6090elf_i386_nacl_pic_plt0_entry[sizeof (elf_i386_nacl_plt0_entry)] =
6091 {
6092 0xff, 0x73, 0x04, /* pushl 4(%ebx) */
6093 0x8b, 0x4b, 0x08, /* mov 0x8(%ebx), %ecx */
6094 0x83, 0xe1, 0xe0, /* and $NACLMASK, %ecx */
6095 0xff, 0xe1, /* jmp *%ecx */
caa0075c
RM		 6096
6097 /* This is expected to be the same size as elf_i386_nacl_plt0_entry,
6098 so pad to that size with nop instructions. */
6099 0x90, 0x90, 0x90, 0x90, 0x90, 0x90
a27e4371
RM		 6100 };
6101
6102static const bfd_byte elf_i386_nacl_pic_plt_entry[NACL_PLT_ENTRY_SIZE] =
6103 {
6104 0x8b, 0x8b, /* movl offset(%ebx), %ecx */
6105 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
6106 0x83, 0xe1, 0xe0, /* andl $NACLMASK, %ecx */
6107 0xff, 0xe1, /* jmp *%ecx */
6108
6109 /* Pad to the next 32-byte boundary with nop instructions. */
6110 0x90,
6111 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6112 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6113
6114 /* Lazy GOT entries point here (32-byte aligned). */
6115 0x68, /* pushl immediate */
6116 0, 0, 0, 0, /* replaced with offset into relocation table. */
6117 0xe9, /* jmp relative */
6118 0, 0, 0, 0, /* replaced with offset to start of .plt. */
6119
6120 /* Pad to the next 32-byte boundary with nop instructions. */
6121 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6122 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6123 0x90, 0x90
6124 };
6125
6126static const bfd_byte elf_i386_nacl_eh_frame_plt[] =
6127 {
6128#if (PLT_CIE_LENGTH != 20 \
6129 || PLT_FDE_LENGTH != 36 \
6130 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
6131 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
6132# error "Need elf_i386_backend_data parameters for eh_frame_plt offsets!"
6133#endif
6134 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
6135 0, 0, 0, 0, /* CIE ID */
6136 1, /* CIE version */
6137 'z', 'R', 0, /* Augmentation string */
6138 1, /* Code alignment factor */
6139 0x7c, /* Data alignment factor: -4 */
6140 8, /* Return address column */
6141 1, /* Augmentation size */
6142 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
6143 DW_CFA_def_cfa, 4, 4, /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
6144 DW_CFA_offset + 8, 1, /* DW_CFA_offset: r8 (eip) at cfa-4 */
6145 DW_CFA_nop, DW_CFA_nop,
6146
6147 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
6148 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
6149 0, 0, 0, 0, /* R_386_PC32 .plt goes here */
6150 0, 0, 0, 0, /* .plt size goes here */
6151 0, /* Augmentation size */
6152 DW_CFA_def_cfa_offset, 8, /* DW_CFA_def_cfa_offset: 8 */
6153 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
6154 DW_CFA_def_cfa_offset, 12, /* DW_CFA_def_cfa_offset: 12 */
6155 DW_CFA_advance_loc + 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
6156 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
6157 13, /* Block length */
6158 DW_OP_breg4, 4, /* DW_OP_breg4 (esp): 4 */
6159 DW_OP_breg8, 0, /* DW_OP_breg8 (eip): 0 */
6160 DW_OP_const1u, 63, DW_OP_and, DW_OP_const1u, 37, DW_OP_ge,
6161 DW_OP_lit2, DW_OP_shl, DW_OP_plus,
6162 DW_CFA_nop, DW_CFA_nop
6163 };
6164
6165static const struct elf_i386_plt_layout elf_i386_nacl_plt =
6166 {
6167 elf_i386_nacl_plt0_entry, /* plt0_entry */
6168 sizeof (elf_i386_nacl_plt0_entry), /* plt0_entry_size */
6169 2, /* plt0_got1_offset */
6170 8, /* plt0_got2_offset */
6171 elf_i386_nacl_plt_entry, /* plt_entry */
6172 NACL_PLT_ENTRY_SIZE, /* plt_entry_size */
6173 2, /* plt_got_offset */
6174 33, /* plt_reloc_offset */
6175 38, /* plt_plt_offset */
6176 32, /* plt_lazy_offset */
6177 elf_i386_nacl_pic_plt0_entry, /* pic_plt0_entry */
6178 elf_i386_nacl_pic_plt_entry, /* pic_plt_entry */
6179 elf_i386_nacl_eh_frame_plt, /* eh_frame_plt */
6180 sizeof (elf_i386_nacl_eh_frame_plt),/* eh_frame_plt_size */
6181 };
6182
6183static const struct elf_i386_backend_data elf_i386_nacl_arch_bed =
6184 {
6185 &elf_i386_nacl_plt, /* plt */
6186 0x90, /* plt0_pad_byte: nop insn */
6187 0, /* is_vxworks */
6188 };
6189
64b384e1
RM		 6190static bfd_boolean
6191elf32_i386_nacl_elf_object_p (bfd *abfd)
6192{
6193 /* Set the right machine number for a NaCl i386 ELF32 file. */
6194 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_i386_i386_nacl);
6195 return TRUE;
6196}
6197
a27e4371
RM		 6198#undef elf_backend_arch_data
6199#define elf_backend_arch_data &elf_i386_nacl_arch_bed
6200
64b384e1
RM		 6201#undef elf_backend_object_p
6202#define elf_backend_object_p elf32_i386_nacl_elf_object_p
5a68afcf
RM		 6203#undef elf_backend_modify_segment_map
6204#define elf_backend_modify_segment_map nacl_modify_segment_map
6205#undef elf_backend_modify_program_headers
6206#define elf_backend_modify_program_headers nacl_modify_program_headers
887badb3
RM		 6207#undef elf_backend_final_write_processing
6208#define elf_backend_final_write_processing nacl_final_write_processing
5a68afcf 6209
a27e4371
RM		 6210#include "elf32-target.h"
6211
5a68afcf 6212/* Restore defaults. */
64b384e1 6213#undef elf_backend_object_p
5a68afcf
RM		 6214#undef elf_backend_modify_segment_map
6215#undef elf_backend_modify_program_headers
887badb3 6216#undef elf_backend_final_write_processing
5a68afcf 6217
eac338cf
PB		 6218/* VxWorks support. */
6219
6220#undef TARGET_LITTLE_SYM
6d00b590 6221#define TARGET_LITTLE_SYM i386_elf32_vxworks_vec
eac338cf
PB		 6222#undef TARGET_LITTLE_NAME
6223#define TARGET_LITTLE_NAME "elf32-i386-vxworks"
d1036acb 6224#undef ELF_OSABI
a27e4371
RM		 6225#undef elf_backend_plt_alignment
6226#define elf_backend_plt_alignment 4
eac338cf 6227
23209a78
RM		 6228static const struct elf_i386_backend_data elf_i386_vxworks_arch_bed =
6229 {
25e762b9 6230 &elf_i386_plt, /* plt */
23209a78
RM		 6231 0x90, /* plt0_pad_byte */
6232 1, /* is_vxworks */
6233 };
eac338cf 6234
23209a78
RM		 6235#undef elf_backend_arch_data
6236#define elf_backend_arch_data &elf_i386_vxworks_arch_bed
eac338cf 6237
13285a1b 6238#undef elf_backend_relocs_compatible
eac338cf
PB		 6239#undef elf_backend_add_symbol_hook
6240#define elf_backend_add_symbol_hook \
6241 elf_vxworks_add_symbol_hook
6242#undef elf_backend_link_output_symbol_hook
6243#define elf_backend_link_output_symbol_hook \
9c72ff84 6244 elf_vxworks_link_output_symbol_hook
eac338cf
PB		 6245#undef elf_backend_emit_relocs
6246#define elf_backend_emit_relocs elf_vxworks_emit_relocs
6247#undef elf_backend_final_write_processing
6248#define elf_backend_final_write_processing \
6249 elf_vxworks_final_write_processing
7dc98aea 6250#undef elf_backend_static_tls_alignment
eac338cf
PB		 6251
6252/* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
6253 define it. */
6254#undef elf_backend_want_plt_sym
6255#define elf_backend_want_plt_sym 1
6256
6257#undef elf32_bed
6258#define elf32_bed elf32_i386_vxworks_bed
6259
6260#include "elf32-target.h"
GDB Binutils - Deliverables
This page took 1.905783 seconds and 4 git commands to generate.