projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Set dynamic tag VMA and size from dynamic section when possible
[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
1547 /* Addend for R_386_GOT32 and R_386_GOT32X relocations must be 0. */
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
1561 if (r_type == R_386_GOT32X && baseless && is_pic)
1562 {
1563 /* For PIC, disallow R_386_GOT32X without a base register
1564 since we don't know what the GOT base is. Allow
1565 R_386_GOT32 for existing object files. */
1566 const char *name;
1567
1568 if (h == NULL)
1569 {
1570 isym = bfd_sym_from_r_symndx (&htab->sym_cache, abfd,
1571 r_symndx);
1572 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1573 }
1574 else
1575 name = h->root.root.string;
1576
1577 (*_bfd_error_handler)
1578 (_("%B: direct GOT relocation R_386_GOT32X against `%s' without base register can not be used when making a shared object"),
1579 abfd, name);
1580 return FALSE;
1581 }
1582
1583 opcode = bfd_get_8 (abfd, contents + roff - 2);
1584
1585 /* Convert mov to lea since it has been done for a while. */
1586 if (opcode != 0x8b)
1587 {
1588 /* Only convert R_386_GOT32X relocation for call, jmp or
1589 one of adc, add, and, cmp, or, sbb, sub, test, xor
1590 instructions. */
1591 if (r_type != R_386_GOT32X)
1592 return TRUE;
1593 }
1594
1595 /* Convert to R_386_32 if PIC is false or there is no base
1596 register. */
1597 to_reloc_32 = !is_pic || baseless;
1598
1599 /* Try to convert R_386_GOT32 and R_386_GOT32X. Get the symbol
1600 referred to by the reloc. */
1601 if (h == NULL)
1602 {
1603 if (opcode == 0x0ff)
1604 /* Convert "call/jmp *foo@GOT[(%reg)]". */
1605 goto convert_branch;
1606 else
1607 /* Convert "mov foo@GOT[(%reg1)], %reg2",
1608 "test %reg1, foo@GOT(%reg2)" and
1609 "binop foo@GOT[(%reg1)], %reg2". */
1610 goto convert_load;
1611 }
1612
1613 /* Undefined weak symbol is only bound locally in executable
1614 and its reference is resolved as 0. */
1615 if (UNDEFINED_WEAK_RESOLVED_TO_ZERO (link_info, TRUE,
1616 elf_i386_hash_entry (h)))
1617 {
1618 if (opcode == 0xff)
1619 {
1620 /* No direct branch to 0 for PIC. */
1621 if (is_pic)
1622 return TRUE;
1623 else
1624 goto convert_branch;
1625 }
1626 else
1627 {
1628 /* We can convert load of address 0 to R_386_32. */
1629 to_reloc_32 = TRUE;
1630 goto convert_load;
1631 }
1632 }
1633
1634 if (opcode == 0xff)
1635 {
1636 /* We have "call/jmp *foo@GOT[(%reg)]". */
1637 if ((h->root.type == bfd_link_hash_defined
1638 || h->root.type == bfd_link_hash_defweak)
1639 && SYMBOL_REFERENCES_LOCAL (link_info, h))
1640 {
1641 /* The function is locally defined. */
1642convert_branch:
1643 /* Convert R_386_GOT32X to R_386_PC32. */
1644 if (modrm == 0x15 || (modrm & 0xf8) == 0x90)
1645 {
1646 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
1647 is a nop prefix. */
1648 modrm = 0xe8;
1649 nop = link_info->call_nop_byte;
1650 if (link_info->call_nop_as_suffix)
1651 {
1652 nop_offset = roff + 3;
1653 irel->r_offset -= 1;
1654 }
1655 else
1656 nop_offset = roff - 2;
1657 }
1658 else
1659 {
1660 /* Convert to "jmp foo nop". */
1661 modrm = 0xe9;
1662 nop = NOP_OPCODE;
1663 nop_offset = roff + 3;
1664 irel->r_offset -= 1;
1665 }
1666
1667 bfd_put_8 (abfd, nop, contents + nop_offset);
1668 bfd_put_8 (abfd, modrm, contents + irel->r_offset - 1);
1669 /* When converting to PC-relative relocation, we
1670 need to adjust addend by -4. */
1671 bfd_put_32 (abfd, -4, contents + irel->r_offset);
1672 irel->r_info = ELF32_R_INFO (r_symndx, R_386_PC32);
1673
1674 *converted = TRUE;
1675 }
1676 }
1677 else
1678 {
1679 /* We have "mov foo@GOT[(%re1g)], %reg2",
1680 "test %reg1, foo@GOT(%reg2)" and
1681 "binop foo@GOT[(%reg1)], %reg2".
1682
1683 Avoid optimizing _DYNAMIC since ld.so may use its
1684 link-time address. */
1685 if (h == htab->elf.hdynamic)
1686 return TRUE;
1687
1688 /* def_regular is set by an assignment in a linker script in
1689 bfd_elf_record_link_assignment. */
1690 if ((h->def_regular
1691 || h->root.type == bfd_link_hash_defined
1692 || h->root.type == bfd_link_hash_defweak)
1693 && SYMBOL_REFERENCES_LOCAL (link_info, h))
1694 {
1695convert_load:
1696 if (opcode == 0x8b)
1697 {
1698 if (to_reloc_32)
1699 {
1700 /* Convert "mov foo@GOT[(%reg1)], %reg2" to
1701 "mov $foo, %reg2" with R_386_32. */
1702 r_type = R_386_32;
1703 modrm = 0xc0 | (modrm & 0x38) >> 3;
1704 bfd_put_8 (abfd, modrm, contents + roff - 1);
1705 opcode = 0xc7;
1706 }
1707 else
1708 {
1709 /* Convert "mov foo@GOT(%reg1), %reg2" to
1710 "lea foo@GOTOFF(%reg1), %reg2". */
1711 r_type = R_386_GOTOFF;
1712 opcode = 0x8d;
1713 }
1714 }
1715 else
1716 {
1717 /* Only R_386_32 is supported. */
1718 if (!to_reloc_32)
1719 return TRUE;
1720
1721 if (opcode == 0x85)
1722 {
1723 /* Convert "test %reg1, foo@GOT(%reg2)" to
1724 "test $foo, %reg1". */
1725 modrm = 0xc0 | (modrm & 0x38) >> 3;
1726 opcode = 0xf7;
1727 }
1728 else
1729 {
1730 /* Convert "binop foo@GOT(%reg1), %reg2" to
1731 "binop $foo, %reg2". */
1732 modrm = (0xc0
1733 | (modrm & 0x38) >> 3
1734 | (opcode & 0x3c));
1735 opcode = 0x81;
1736 }
1737 bfd_put_8 (abfd, modrm, contents + roff - 1);
1738 r_type = R_386_32;
1739 }
1740
1741 bfd_put_8 (abfd, opcode, contents + roff - 2);
1742 irel->r_info = ELF32_R_INFO (r_symndx, r_type);
1743
1744 *converted = TRUE;
1745 }
1746 }
1747
1748 return TRUE;
1749}
1750
c1d11331
L		 1751/* Rename some of the generic section flags to better document how they
1752 are used here. */
c337a162
L		 1753#define need_convert_load sec_flg0
1754#define check_relocs_failed sec_flg1
c1d11331 1755
252b5132 1756/* Look through the relocs for a section during the first phase, and
0ac8d2ca
AM		 1757 calculate needed space in the global offset table, procedure linkage
1758 table, and dynamic reloc sections. */
252b5132 1759
b34976b6 1760static bfd_boolean
55fd94b0
AM		 1761elf_i386_check_relocs (bfd *abfd,
1762 struct bfd_link_info *info,
1763 asection *sec,
1764 const Elf_Internal_Rela *relocs)
252b5132 1765{
6725bdbf 1766 struct elf_i386_link_hash_table *htab;
252b5132
RH		 1767 Elf_Internal_Shdr *symtab_hdr;
1768 struct elf_link_hash_entry **sym_hashes;
252b5132
RH		 1769 const Elf_Internal_Rela *rel;
1770 const Elf_Internal_Rela *rel_end;
252b5132 1771 asection *sreloc;
bedfd056 1772 bfd_byte *contents;
dd7e64d4 1773 bfd_boolean use_plt_got;
252b5132 1774
0e1862bb 1775 if (bfd_link_relocatable (info))
b34976b6 1776 return TRUE;
252b5132 1777
0ffa91dd
NC		 1778 BFD_ASSERT (is_i386_elf (abfd));
1779
6725bdbf 1780 htab = elf_i386_hash_table (info);
4dfe6ac6 1781 if (htab == NULL)
c337a162
L		 1782 {
1783 sec->check_relocs_failed = 1;
1784 return FALSE;
1785 }
4dfe6ac6 1786
bedfd056
L		 1787 /* Get the section contents. */
1788 if (elf_section_data (sec)->this_hdr.contents != NULL)
1789 contents = elf_section_data (sec)->this_hdr.contents;
1790 else if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1791 {
1792 sec->check_relocs_failed = 1;
1793 return FALSE;
1794 }
1795
dd7e64d4
L		 1796 use_plt_got = (!get_elf_i386_backend_data (abfd)->is_vxworks
1797 && (get_elf_i386_backend_data (abfd)
1798 == &elf_i386_arch_bed));
1799
0ffa91dd 1800 symtab_hdr = &elf_symtab_hdr (abfd);
252b5132 1801 sym_hashes = elf_sym_hashes (abfd);
252b5132 1802
252b5132
RH		 1803 sreloc = NULL;
1804
1805 rel_end = relocs + sec->reloc_count;
1806 for (rel = relocs; rel < rel_end; rel++)
1807 {
13ae64f3 1808 unsigned int r_type;
252b5132
RH		 1809 unsigned long r_symndx;
1810 struct elf_link_hash_entry *h;
d5597ebc 1811 struct elf_i386_link_hash_entry *eh;
4c544807
L		 1812 Elf_Internal_Sym *isym;
1813 const char *name;
06a6a421 1814 bfd_boolean size_reloc;
252b5132
RH		 1815
1816 r_symndx = ELF32_R_SYM (rel->r_info);
13ae64f3 1817 r_type = ELF32_R_TYPE (rel->r_info);
252b5132 1818
d9bc7a44 1819 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
f5f31454 1820 {
d003868e
AM		 1821 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1822 abfd,
8f615d07 1823 r_symndx);
c337a162 1824 goto error_return;
f5f31454
L		 1825 }
1826
252b5132 1827 if (r_symndx < symtab_hdr->sh_info)
c25bc9fc
L		 1828 {
1829 /* A local symbol. */
c2e61a4e
L		 1830 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1831 abfd, r_symndx);
1832 if (isym == NULL)
c337a162 1833 goto error_return;
c25bc9fc
L		 1834
1835 /* Check relocation against local STT_GNU_IFUNC symbol. */
c25bc9fc
L		 1836 if (ELF32_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1837 {
9fff0c39 1838 h = elf_i386_get_local_sym_hash (htab, abfd, rel, TRUE);
c25bc9fc 1839 if (h == NULL)
c337a162 1840 goto error_return;
6bbec505 1841
c25bc9fc
L		 1842 /* Fake a STT_GNU_IFUNC symbol. */
1843 h->type = STT_GNU_IFUNC;
1844 h->def_regular = 1;
1845 h->ref_regular = 1;
1846 h->forced_local = 1;
1847 h->root.type = bfd_link_hash_defined;
1848 }
1849 else
1850 h = NULL;
1851 }
252b5132 1852 else
71cb9464 1853 {
4c544807 1854 isym = NULL;
71cb9464
L		 1855 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1856 while (h->root.type == bfd_link_hash_indirect
1857 || h->root.type == bfd_link_hash_warning)
1858 h = (struct elf_link_hash_entry *) h->root.u.i.link;
c25bc9fc 1859 }
cbe950e9 1860
d5597ebc 1861 eh = (struct elf_i386_link_hash_entry *) h;
c25bc9fc
L		 1862 if (h != NULL)
1863 {
cbe950e9
L		 1864 switch (r_type)
1865 {
1866 default:
1867 break;
1868
d5597ebc
L		 1869 case R_386_GOTOFF:
1870 eh->gotoff_ref = 1;
cbe950e9
L		 1871 case R_386_32:
1872 case R_386_PC32:
1873 case R_386_PLT32:
1874 case R_386_GOT32:
02a86693 1875 case R_386_GOT32X:
9d4057ee
AM		 1876 if (htab->elf.dynobj == NULL)
1877 htab->elf.dynobj = abfd;
466ee2af
L		 1878 /* Create the ifunc sections for static executables. */
1879 if (h->type == STT_GNU_IFUNC
1880 && !_bfd_elf_create_ifunc_sections (htab->elf.dynobj,
1881 info))
c337a162 1882 goto error_return;
cbe950e9
L		 1883 break;
1884 }
1885
ad1e85de
L		 1886 /* It is referenced by a non-shared object. */
1887 h->ref_regular = 1;
61315175 1888 h->root.non_ir_ref = 1;
13a2df29
L		 1889
1890 if (h->type == STT_GNU_IFUNC)
1891 elf_tdata (info->output_bfd)->has_gnu_symbols
1892 |= elf_gnu_symbol_ifunc;
71cb9464 1893 }
252b5132 1894
bedfd056 1895 if (! elf_i386_tls_transition (info, abfd, sec, contents,
142411ca
L		 1896 symtab_hdr, sym_hashes,
1897 &r_type, GOT_UNKNOWN,
bedfd056 1898 rel, rel_end, h, r_symndx, FALSE))
c337a162 1899 goto error_return;
13ae64f3
JJ		 1900
1901 switch (r_type)
252b5132 1902 {
37e55690
JJ		 1903 case R_386_TLS_LDM:
1904 htab->tls_ldm_got.refcount += 1;
1905 goto create_got;
1906
1907 case R_386_PLT32:
1908 /* This symbol requires a procedure linkage table entry. We
1909 actually build the entry in adjust_dynamic_symbol,
1910 because this might be a case of linking PIC code which is
1911 never referenced by a dynamic object, in which case we
1912 don't need to generate a procedure linkage table entry
1913 after all. */
1914
1915 /* If this is a local symbol, we resolve it directly without
1916 creating a procedure linkage table entry. */
1917 if (h == NULL)
1918 continue;
1919
aec6b87e 1920 eh->has_got_reloc = 1;
f5385ebf 1921 h->needs_plt = 1;
37e55690
JJ		 1922 h->plt.refcount += 1;
1923 break;
1924
6a3e1bae 1925 case R_386_SIZE32:
06a6a421 1926 size_reloc = TRUE;
6a3e1bae
L		 1927 goto do_size;
1928
13ae64f3 1929 case R_386_TLS_IE_32:
37e55690
JJ		 1930 case R_386_TLS_IE:
1931 case R_386_TLS_GOTIE:
0e1862bb 1932 if (!bfd_link_executable (info))
13ae64f3 1933 info->flags |= DF_STATIC_TLS;
37e55690
JJ		 1934 /* Fall through */
1935
252b5132 1936 case R_386_GOT32:
02a86693 1937 case R_386_GOT32X:
13ae64f3 1938 case R_386_TLS_GD:
67a4f2b7
AO		 1939 case R_386_TLS_GOTDESC:
1940 case R_386_TLS_DESC_CALL:
252b5132 1941 /* This symbol requires a global offset table entry. */
13ae64f3
JJ		 1942 {
1943 int tls_type, old_tls_type;
1944
1945 switch (r_type)
1946 {
1947 default:
02a86693
L		 1948 case R_386_GOT32:
1949 case R_386_GOT32X:
1950 tls_type = GOT_NORMAL;
1951 break;
13ae64f3 1952 case R_386_TLS_GD: tls_type = GOT_TLS_GD; break;
67a4f2b7
AO		 1953 case R_386_TLS_GOTDESC:
1954 case R_386_TLS_DESC_CALL:
1955 tls_type = GOT_TLS_GDESC; break;
37e55690
JJ		 1956 case R_386_TLS_IE_32:
1957 if (ELF32_R_TYPE (rel->r_info) == r_type)
1958 tls_type = GOT_TLS_IE_NEG;
1959 else
ebcfb3c0
JJ		 1960 /* If this is a GD->IE transition, we may use either of
1961 R_386_TLS_TPOFF and R_386_TLS_TPOFF32. */
37e55690
JJ		 1962 tls_type = GOT_TLS_IE;
1963 break;
1964 case R_386_TLS_IE:
1965 case R_386_TLS_GOTIE:
1966 tls_type = GOT_TLS_IE_POS; break;
13ae64f3
JJ		 1967 }
1968
1969 if (h != NULL)
1970 {
1971 h->got.refcount += 1;
1972 old_tls_type = elf_i386_hash_entry(h)->tls_type;
1973 }
1974 else
1975 {
1976 bfd_signed_vma *local_got_refcounts;
1977
1978 /* This is a global offset table entry for a local symbol. */
1979 local_got_refcounts = elf_local_got_refcounts (abfd);
1980 if (local_got_refcounts == NULL)
1981 {
1982 bfd_size_type size;
1983
1984 size = symtab_hdr->sh_info;
67a4f2b7
AO		 1985 size *= (sizeof (bfd_signed_vma)
1986 + sizeof (bfd_vma) + sizeof(char));
a50b1753
NC		 1987 local_got_refcounts = (bfd_signed_vma *)
1988 bfd_zalloc (abfd, size);
13ae64f3 1989 if (local_got_refcounts == NULL)
c337a162 1990 goto error_return;
13ae64f3 1991 elf_local_got_refcounts (abfd) = local_got_refcounts;
67a4f2b7
AO		 1992 elf_i386_local_tlsdesc_gotent (abfd)
1993 = (bfd_vma *) (local_got_refcounts + symtab_hdr->sh_info);
13ae64f3 1994 elf_i386_local_got_tls_type (abfd)
67a4f2b7 1995 = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
13ae64f3
JJ		 1996 }
1997 local_got_refcounts[r_symndx] += 1;
1998 old_tls_type = elf_i386_local_got_tls_type (abfd) [r_symndx];
1999 }
2000
37e55690
JJ		 2001 if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_IE))
2002 tls_type |= old_tls_type;
13ae64f3
JJ		 2003 /* If a TLS symbol is accessed using IE at least once,
2004 there is no point to use dynamic model for it. */
ebcfb3c0 2005 else if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
67a4f2b7 2006 && (! GOT_TLS_GD_ANY_P (old_tls_type)
37e55690 2007 || (tls_type & GOT_TLS_IE) == 0))
13ae64f3 2008 {
67a4f2b7 2009 if ((old_tls_type & GOT_TLS_IE) && GOT_TLS_GD_ANY_P (tls_type))
37e55690 2010 tls_type = old_tls_type;
67a4f2b7
AO		 2011 else if (GOT_TLS_GD_ANY_P (old_tls_type)
2012 && GOT_TLS_GD_ANY_P (tls_type))
2013 tls_type |= old_tls_type;
13ae64f3
JJ		 2014 else
2015 {
09a24cbf 2016 if (h)
4c544807
L		 2017 name = h->root.root.string;
2018 else
2019 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
2020 NULL);
13ae64f3 2021 (*_bfd_error_handler)
d003868e 2022 (_("%B: `%s' accessed both as normal and "
55fd94b0 2023 "thread local symbol"),
4c544807 2024 abfd, name);
68c4a57e 2025 bfd_set_error (bfd_error_bad_value);
c337a162 2026 goto error_return;
13ae64f3
JJ		 2027 }
2028 }
2029
2030 if (old_tls_type != tls_type)
2031 {
2032 if (h != NULL)
2033 elf_i386_hash_entry (h)->tls_type = tls_type;
2034 else
2035 elf_i386_local_got_tls_type (abfd) [r_symndx] = tls_type;
2036 }
2037 }
0ac8d2ca
AM		 2038 /* Fall through */
2039
2040 case R_386_GOTOFF:
2041 case R_386_GOTPC:
13ae64f3 2042 create_got:
6de2ae4a 2043 if (htab->elf.sgot == NULL)
0ac8d2ca
AM		 2044 {
2045 if (htab->elf.dynobj == NULL)
2046 htab->elf.dynobj = abfd;
6de2ae4a 2047 if (!_bfd_elf_create_got_section (htab->elf.dynobj, info))
c337a162 2048 goto error_return;
0ac8d2ca 2049 }
37e55690 2050 if (r_type != R_386_TLS_IE)
aec6b87e
L		 2051 {
2052 if (eh != NULL)
2053 eh->has_got_reloc = 1;
2054 break;
2055 }
37e55690 2056 /* Fall through */
252b5132 2057
37e55690
JJ		 2058 case R_386_TLS_LE_32:
2059 case R_386_TLS_LE:
aec6b87e
L		 2060 if (eh != NULL)
2061 eh->has_got_reloc = 1;
0e1862bb 2062 if (bfd_link_executable (info))
37e55690 2063 break;
bffbf940 2064 info->flags |= DF_STATIC_TLS;
aec6b87e 2065 goto do_relocation;
252b5132
RH		 2066
2067 case R_386_32:
2068 case R_386_PC32:
aec6b87e
L		 2069 if (eh != NULL && (sec->flags & SEC_CODE) != 0)
2070 eh->has_non_got_reloc = 1;
2071do_relocation:
d1ed1c7d
L		 2072 /* STT_GNU_IFUNC symbol must go through PLT even if it is
2073 locally defined and undefined symbol may turn out to be
2074 a STT_GNU_IFUNC symbol later. */
2075 if (h != NULL
2076 && (bfd_link_executable (info)
2077 || ((h->type == STT_GNU_IFUNC
2078 || h->root.type == bfd_link_hash_undefweak
2079 || h->root.type == bfd_link_hash_undefined)
2080 && SYMBOLIC_BIND (info, h))))
6725bdbf 2081 {
12d0ee4a 2082 /* If this reloc is in a read-only section, we might
ebe50bae
AM		 2083 need a copy reloc. We can't check reliably at this
2084 stage whether the section is read-only, as input
2085 sections have not yet been mapped to output sections.
2086 Tentatively set the flag for now, and correct in
2087 adjust_dynamic_symbol. */
f5385ebf 2088 h->non_got_ref = 1;
12d0ee4a
AM		 2089
2090 /* We may need a .plt entry if the function this reloc
2091 refers to is in a shared lib. */
51b64d56 2092 h->plt.refcount += 1;
4b627c18
L		 2093 if (r_type == R_386_PC32)
2094 {
2095 /* Since something like ".long foo - ." may be used
2096 as pointer, make sure that PLT is used if foo is
2097 a function defined in a shared library. */
2098 if ((sec->flags & SEC_CODE) == 0)
2099 h->pointer_equality_needed = 1;
2100 }
2101 else
04ebc307
L		 2102 {
2103 h->pointer_equality_needed = 1;
2104 /* R_386_32 can be resolved at run-time. */
2105 if (r_type == R_386_32
2106 && (sec->flags & SEC_READONLY) == 0)
2107 eh->func_pointer_refcount += 1;
2108 }
6725bdbf 2109 }
7843f00e 2110
06a6a421 2111 size_reloc = FALSE;
6a3e1bae 2112do_size:
252b5132 2113 /* If we are creating a shared library, and this is a reloc
f69da49f
AM		 2114 against a global symbol, or a non PC relative reloc
2115 against a local symbol, then we need to copy the reloc
2116 into the shared library. However, if we are linking with
2117 -Bsymbolic, we do not need to copy a reloc against a
2118 global symbol which is defined in an object we are
2119 including in the link (i.e., DEF_REGULAR is set). At
2120 this point we have not seen all the input files, so it is
2121 possible that DEF_REGULAR is not set now but will be set
1f655a09
L		 2122 later (it is never cleared). In case of a weak definition,
2123 DEF_REGULAR may be cleared later by a strong definition in
ebe50bae 2124 a shared library. We account for that possibility below by
1f655a09
L		 2125 storing information in the relocs_copied field of the hash
2126 table entry. A similar situation occurs when creating
2127 shared libraries and symbol visibility changes render the
12d0ee4a 2128 symbol local.
56882138 2129
12d0ee4a
AM		 2130 If on the other hand, we are creating an executable, we
2131 may need to keep relocations for symbols satisfied by a
2132 dynamic library if we manage to avoid copy relocs for the
2133 symbol. */
0e1862bb 2134 if ((bfd_link_pic (info)
12d0ee4a 2135 && (sec->flags & SEC_ALLOC) != 0
13ae64f3 2136 && (r_type != R_386_PC32
12d0ee4a 2137 || (h != NULL
4e0c91e4
L		 2138 && (! (bfd_link_pie (info)
2139 || SYMBOLIC_BIND (info, h))
12d0ee4a 2140 || h->root.type == bfd_link_hash_defweak
f5385ebf 2141 || !h->def_regular))))
a23b6845 2142 || (ELIMINATE_COPY_RELOCS
0e1862bb 2143 && !bfd_link_pic (info)
12d0ee4a
AM		 2144 && (sec->flags & SEC_ALLOC) != 0
2145 && h != NULL
12d0ee4a 2146 && (h->root.type == bfd_link_hash_defweak
0f88be7a 2147 || !h->def_regular)))
252b5132 2148 {
e03a8ed8
L		 2149 struct elf_dyn_relocs *p;
2150 struct elf_dyn_relocs **head;
ec338859 2151
12d0ee4a
AM		 2152 /* We must copy these reloc types into the output file.
2153 Create a reloc section in dynobj and make room for
2154 this reloc. */
252b5132
RH		 2155 if (sreloc == NULL)
2156 {
0ac8d2ca
AM		 2157 if (htab->elf.dynobj == NULL)
2158 htab->elf.dynobj = abfd;
2159
83bac4b0
NC		 2160 sreloc = _bfd_elf_make_dynamic_reloc_section
2161 (sec, htab->elf.dynobj, 2, abfd, /*rela?*/ FALSE);
2162
252b5132 2163 if (sreloc == NULL)
c337a162 2164 goto error_return;
252b5132
RH		 2165 }
2166
0c715baa
AM		 2167 /* If this is a global symbol, we count the number of
2168 relocations we need for this symbol. */
2169 if (h != NULL)
252b5132 2170 {
d5597ebc 2171 head = &eh->dyn_relocs;
0c715baa
AM		 2172 }
2173 else
2174 {
ec338859
AM		 2175 /* Track dynamic relocs needed for local syms too.
2176 We really need local syms available to do this
2177 easily. Oh well. */
87d72d41 2178 void **vpp;
ec338859 2179 asection *s;
87d72d41
AM		 2180
2181 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2182 abfd, r_symndx);
2183 if (isym == NULL)
c337a162 2184 goto error_return;
87d72d41
AM		 2185
2186 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
ec338859 2187 if (s == NULL)
87d72d41 2188 s = sec;
ec338859 2189
e81d3500 2190 vpp = &elf_section_data (s)->local_dynrel;
e03a8ed8 2191 head = (struct elf_dyn_relocs **)vpp;
ec338859
AM		 2192 }
2193
2194 p = *head;
2195 if (p == NULL || p->sec != sec)
2196 {
2197 bfd_size_type amt = sizeof *p;
a50b1753
NC		 2198 p = (struct elf_dyn_relocs *) bfd_alloc (htab->elf.dynobj,
2199 amt);
ec338859 2200 if (p == NULL)
c337a162 2201 goto error_return;
ec338859
AM		 2202 p->next = *head;
2203 *head = p;
2204 p->sec = sec;
2205 p->count = 0;
2206 p->pc_count = 0;
252b5132 2207 }
ec338859
AM		 2208
2209 p->count += 1;
06a6a421
L		 2210 /* Count size relocation as PC-relative relocation. */
2211 if (r_type == R_386_PC32 || size_reloc)
ec338859 2212 p->pc_count += 1;
252b5132 2213 }
252b5132
RH		 2214 break;
2215
2216 /* This relocation describes the C++ object vtable hierarchy.
2217 Reconstruct it for later use during GC. */
2218 case R_386_GNU_VTINHERIT:
d17e0c6e 2219 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
c337a162 2220 goto error_return;
252b5132
RH		 2221 break;
2222
2223 /* This relocation describes which C++ vtable entries are actually
2224 used. Record for later use during GC. */
2225 case R_386_GNU_VTENTRY:
c6aa130f
MS		 2226 BFD_ASSERT (h != NULL);
2227 if (h != NULL
2228 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
c337a162 2229 goto error_return;
252b5132
RH		 2230 break;
2231
2232 default:
2233 break;
2234 }
dd7e64d4
L		 2235
2236 if (use_plt_got
2237 && h != NULL
2238 && h->plt.refcount > 0
8ded2ddc
L		 2239 && (((info->flags & DF_BIND_NOW) && !h->pointer_equality_needed)
2240 || h->got.refcount > 0)
dd7e64d4
L		 2241 && htab->plt_got == NULL)
2242 {
2243 /* Create the GOT procedure linkage table. */
2244 unsigned int plt_got_align;
2245 const struct elf_backend_data *bed;
2246
2247 bed = get_elf_backend_data (info->output_bfd);
2248 BFD_ASSERT (sizeof (elf_i386_got_plt_entry) == 8
2249 && (sizeof (elf_i386_got_plt_entry)
2250 == sizeof (elf_i386_pic_got_plt_entry)));
2251 plt_got_align = 3;
2252
2253 if (htab->elf.dynobj == NULL)
2254 htab->elf.dynobj = abfd;
2255 htab->plt_got
2256 = bfd_make_section_anyway_with_flags (htab->elf.dynobj,
2257 ".plt.got",
2258 (bed->dynamic_sec_flags
2259 | SEC_ALLOC
2260 | SEC_CODE
2261 | SEC_LOAD
2262 | SEC_READONLY));
2263 if (htab->plt_got == NULL
2264 || !bfd_set_section_alignment (htab->elf.dynobj,
2265 htab->plt_got,
2266 plt_got_align))
c337a162 2267 goto error_return;
dd7e64d4 2268 }
c1d11331 2269
02a86693 2270 if ((r_type == R_386_GOT32 || r_type == R_386_GOT32X)
c1d11331 2271 && (h == NULL || h->type != STT_GNU_IFUNC))
02a86693 2272 sec->need_convert_load = 1;
252b5132
RH		 2273 }
2274
bedfd056
L		 2275 if (elf_section_data (sec)->this_hdr.contents != contents)
2276 {
2277 if (!info->keep_memory)
2278 free (contents);
2279 else
2280 {
2281 /* Cache the section contents for elf_link_input_bfd. */
2282 elf_section_data (sec)->this_hdr.contents = contents;
2283 }
2284 }
2285
b34976b6 2286 return TRUE;
c337a162
L		 2287
2288error_return:
bedfd056
L		 2289 if (elf_section_data (sec)->this_hdr.contents != contents)
2290 free (contents);
c337a162
L		 2291 sec->check_relocs_failed = 1;
2292 return FALSE;
252b5132
RH		 2293}
2294
2295/* Return the section that should be marked against GC for a given
2296 relocation. */
2297
2298static asection *
55fd94b0 2299elf_i386_gc_mark_hook (asection *sec,
07adf181 2300 struct bfd_link_info *info,
55fd94b0
AM		 2301 Elf_Internal_Rela *rel,
2302 struct elf_link_hash_entry *h,
2303 Elf_Internal_Sym *sym)
252b5132
RH		 2304{
2305 if (h != NULL)
07adf181
AM		 2306 switch (ELF32_R_TYPE (rel->r_info))
2307 {
2308 case R_386_GNU_VTINHERIT:
2309 case R_386_GNU_VTENTRY:
2310 return NULL;
2311 }
2312
2313 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
252b5132
RH		 2314}
2315
aec6b87e
L		 2316/* Remove undefined weak symbol from the dynamic symbol table if it
2317 is resolved to 0. */
2318
2319static bfd_boolean
2320elf_i386_fixup_symbol (struct bfd_link_info *info,
2321 struct elf_link_hash_entry *h)
2322{
2323 if (h->dynindx != -1
2324 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info,
e62b9723 2325 elf_i386_hash_entry (h)->has_got_reloc,
aec6b87e
L		 2326 elf_i386_hash_entry (h)))
2327 {
2328 h->dynindx = -1;
2329 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
2330 h->dynstr_index);
2331 }
2332 return TRUE;
2333}
2334
252b5132
RH		 2335/* Adjust a symbol defined by a dynamic object and referenced by a
2336 regular object. The current definition is in some section of the
2337 dynamic object, but we're not including those sections. We have to
2338 change the definition to something the rest of the link can
2339 understand. */
2340
b34976b6 2341static bfd_boolean
55fd94b0
AM		 2342elf_i386_adjust_dynamic_symbol (struct bfd_link_info *info,
2343 struct elf_link_hash_entry *h)
252b5132 2344{
6725bdbf 2345 struct elf_i386_link_hash_table *htab;
252b5132 2346 asection *s;
5ca5bb35
L		 2347 struct elf_i386_link_hash_entry *eh;
2348 struct elf_dyn_relocs *p;
252b5132 2349
cbe950e9
L		 2350 /* STT_GNU_IFUNC symbol must go through PLT. */
2351 if (h->type == STT_GNU_IFUNC)
2352 {
73bcf233
L		 2353 /* All local STT_GNU_IFUNC references must be treate as local
2354 calls via local PLT. */
5ca5bb35
L		 2355 if (h->ref_regular
2356 && SYMBOL_CALLS_LOCAL (info, h))
2357 {
73bcf233 2358 bfd_size_type pc_count = 0, count = 0;
5ca5bb35
L		 2359 struct elf_dyn_relocs **pp;
2360
2361 eh = (struct elf_i386_link_hash_entry *) h;
2362 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2363 {
2364 pc_count += p->pc_count;
2365 p->count -= p->pc_count;
2366 p->pc_count = 0;
73bcf233 2367 count += p->count;
5ca5bb35
L		 2368 if (p->count == 0)
2369 *pp = p->next;
2370 else
2371 pp = &p->next;
2372 }
2373
73bcf233 2374 if (pc_count || count)
5ca5bb35
L		 2375 {
2376 h->needs_plt = 1;
5ca5bb35 2377 h->non_got_ref = 1;
a5479e5f
L		 2378 if (h->plt.refcount <= 0)
2379 h->plt.refcount = 1;
2380 else
2381 h->plt.refcount += 1;
5ca5bb35
L		 2382 }
2383 }
2384
cbe950e9
L		 2385 if (h->plt.refcount <= 0)
2386 {
2387 h->plt.offset = (bfd_vma) -1;
2388 h->needs_plt = 0;
2389 }
2390 return TRUE;
2391 }
2392
252b5132
RH		 2393 /* If this is a function, put it in the procedure linkage table. We
2394 will fill in the contents of the procedure linkage table later,
2395 when we know the address of the .got section. */
2396 if (h->type == STT_FUNC
f5385ebf 2397 || h->needs_plt)
252b5132 2398 {
6725bdbf 2399 if (h->plt.refcount <= 0
9c7a29a3
AM		 2400 || SYMBOL_CALLS_LOCAL (info, h)
2401 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2402 && h->root.type == bfd_link_hash_undefweak))
252b5132
RH		 2403 {
2404 /* This case can occur if we saw a PLT32 reloc in an input
dd5724d5
AM		 2405 file, but the symbol was never referred to by a dynamic
2406 object, or if all references were garbage collected. In
2407 such a case, we don't actually need to build a procedure
2408 linkage table, and we can just do a PC32 reloc instead. */
bbd7ec4a 2409 h->plt.offset = (bfd_vma) -1;
f5385ebf 2410 h->needs_plt = 0;
252b5132
RH		 2411 }
2412
b34976b6 2413 return TRUE;
252b5132 2414 }
6725bdbf
AM		 2415 else
2416 /* It's possible that we incorrectly decided a .plt reloc was
2417 needed for an R_386_PC32 reloc to a non-function sym in
2418 check_relocs. We can't decide accurately between function and
2419 non-function syms in check-relocs; Objects loaded later in
2420 the link may change h->type. So fix it now. */
bbd7ec4a 2421 h->plt.offset = (bfd_vma) -1;
252b5132
RH		 2422
2423 /* If this is a weak symbol, and there is a real definition, the
2424 processor independent code will have arranged for us to see the
2425 real definition first, and we can just use the same value. */
f6e332e6 2426 if (h->u.weakdef != NULL)
252b5132 2427 {
f6e332e6
AM		 2428 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2429 || h->u.weakdef->root.type == bfd_link_hash_defweak);
2430 h->root.u.def.section = h->u.weakdef->root.u.def.section;
2431 h->root.u.def.value = h->u.weakdef->root.u.def.value;
a23b6845 2432 if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
f6e332e6 2433 h->non_got_ref = h->u.weakdef->non_got_ref;
b34976b6 2434 return TRUE;
252b5132
RH		 2435 }
2436
2437 /* This is a reference to a symbol defined by a dynamic object which
2438 is not a function. */
2439
2440 /* If we are creating a shared library, we must presume that the
2441 only references to the symbol are via the global offset table.
2442 For such cases we need not do anything here; the relocations will
2443 be handled correctly by relocate_section. */
0e1862bb 2444 if (!bfd_link_executable (info))
b34976b6 2445 return TRUE;
252b5132 2446
7843f00e 2447 /* If there are no references to this symbol that do not use the
d5597ebc
L		 2448 GOT nor R_386_GOTOFF relocation, we don't need to generate a copy
2449 reloc. */
2450 eh = (struct elf_i386_link_hash_entry *) h;
2451 if (!h->non_got_ref && !eh->gotoff_ref)
b34976b6 2452 return TRUE;
7843f00e 2453
8bd621d8
AM		 2454 /* If -z nocopyreloc was given, we won't generate them either. */
2455 if (info->nocopyreloc)
2456 {
f5385ebf 2457 h->non_got_ref = 0;
b34976b6 2458 return TRUE;
8bd621d8
AM		 2459 }
2460
643796e3 2461 htab = elf_i386_hash_table (info);
4dfe6ac6
NC		 2462 if (htab == NULL)
2463 return FALSE;
643796e3 2464
d5597ebc
L		 2465 /* If there aren't any dynamic relocs in read-only sections nor
2466 R_386_GOTOFF relocation, then we can keep the dynamic relocs and
2467 avoid the copy reloc. This doesn't work on VxWorks, where we can
2468 not have dynamic relocations (other than copy and jump slot
2469 relocations) in an executable. */
23209a78 2470 if (ELIMINATE_COPY_RELOCS
d5597ebc 2471 && !eh->gotoff_ref
23209a78 2472 && !get_elf_i386_backend_data (info->output_bfd)->is_vxworks)
ebe50bae 2473 {
a23b6845
AM		 2474 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2475 {
2476 s = p->sec->output_section;
2477 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2478 break;
2479 }
2480
a23b6845
AM		 2481 if (p == NULL)
2482 {
f5385ebf 2483 h->non_got_ref = 0;
a23b6845
AM		 2484 return TRUE;
2485 }
ebe50bae
AM		 2486 }
2487
252b5132
RH		 2488 /* We must allocate the symbol in our .dynbss section, which will
2489 become part of the .bss section of the executable. There will be
2490 an entry for this symbol in the .dynsym section. The dynamic
2491 object will contain position independent code, so all references
2492 from the dynamic object to this symbol will go through the global
2493 offset table. The dynamic linker will use the .dynsym entry to
2494 determine the address it must put in the global offset table, so
2495 both the dynamic object and the regular object will refer to the
2496 same memory location for the variable. */
2497
252b5132
RH		 2498 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
2499 copy the initial value out of the dynamic object and into the
0ac8d2ca 2500 runtime process image. */
1d7e9d18 2501 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
252b5132 2502 {
eea6121a 2503 htab->srelbss->size += sizeof (Elf32_External_Rel);
f5385ebf 2504 h->needs_copy = 1;
252b5132
RH		 2505 }
2506
0ac8d2ca 2507 s = htab->sdynbss;
252b5132 2508
6cabe1ea 2509 return _bfd_elf_adjust_dynamic_copy (info, h, s);
252b5132
RH		 2510}
2511
6725bdbf 2512/* Allocate space in .plt, .got and associated reloc sections for
0c715baa 2513 dynamic relocs. */
6725bdbf 2514
b34976b6 2515static bfd_boolean
eb4ff4d6 2516elf_i386_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
6725bdbf
AM		 2517{
2518 struct bfd_link_info *info;
2519 struct elf_i386_link_hash_table *htab;
5a15f56f 2520 struct elf_i386_link_hash_entry *eh;
e03a8ed8 2521 struct elf_dyn_relocs *p;
25e762b9 2522 unsigned plt_entry_size;
aec6b87e 2523 bfd_boolean resolved_to_zero;
6725bdbf 2524
e92d460e 2525 if (h->root.type == bfd_link_hash_indirect)
b34976b6 2526 return TRUE;
6725bdbf 2527
cbe950e9 2528 eh = (struct elf_i386_link_hash_entry *) h;
e92d460e 2529
6725bdbf
AM		 2530 info = (struct bfd_link_info *) inf;
2531 htab = elf_i386_hash_table (info);
4dfe6ac6
NC		 2532 if (htab == NULL)
2533 return FALSE;
6725bdbf 2534
25e762b9
RM		 2535 plt_entry_size = GET_PLT_ENTRY_SIZE (info->output_bfd);
2536
e62b9723
L		 2537 resolved_to_zero = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info,
2538 eh->has_got_reloc,
2539 eh);
aec6b87e 2540
04ebc307
L		 2541 /* Clear the reference count of function pointer relocations if
2542 symbol isn't a normal function. */
2543 if (h->type != STT_FUNC)
2544 eh->func_pointer_refcount = 0;
2545
dd7e64d4
L		 2546 /* We can't use the GOT PLT if pointer equality is needed since
2547 finish_dynamic_symbol won't clear symbol value and the dynamic
2548 linker won't update the GOT slot. We will get into an infinite
2549 loop at run-time. */
2550 if (htab->plt_got != NULL
2551 && h->type != STT_GNU_IFUNC
2552 && !h->pointer_equality_needed
2553 && h->plt.refcount > 0
2554 && h->got.refcount > 0)
2555 {
2556 /* Don't use the regular PLT if there are both GOT and GOTPLT
2557 reloctions. */
2558 h->plt.offset = (bfd_vma) -1;
2559
2560 /* Use the GOT PLT. */
2561 eh->plt_got.refcount = 1;
2562 }
2563
cbe950e9
L		 2564 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2565 here if it is defined and referenced in a non-shared object. */
2566 if (h->type == STT_GNU_IFUNC
2567 && h->def_regular)
25e762b9 2568 return _bfd_elf_allocate_ifunc_dyn_relocs (info, h, &eh->dyn_relocs,
2df3368d
L		 2569 &htab->readonly_dynrelocs_against_ifunc,
2570 plt_entry_size,
7b70956d 2571 plt_entry_size, 4);
04ebc307
L		 2572 /* Don't create the PLT entry if there are only function pointer
2573 relocations which can be resolved at run-time. */
cbe950e9 2574 else if (htab->elf.dynamic_sections_created
04ebc307
L		 2575 && (h->plt.refcount > eh->func_pointer_refcount
2576 || eh->plt_got.refcount > 0))
6725bdbf 2577 {
25070364
L		 2578 bfd_boolean use_plt_got;
2579
04ebc307
L		 2580 /* Clear the reference count of function pointer relocations
2581 if PLT is used. */
2582 eh->func_pointer_refcount = 0;
2583
8ded2ddc 2584 if ((info->flags & DF_BIND_NOW) && !h->pointer_equality_needed)
25070364
L		 2585 {
2586 /* Don't use the regular PLT for DF_BIND_NOW. */
2587 h->plt.offset = (bfd_vma) -1;
2588
2589 /* Use the GOT PLT. */
2590 h->got.refcount = 1;
2591 eh->plt_got.refcount = 1;
2592 }
2593
2594 use_plt_got = eh->plt_got.refcount > 0;
dd7e64d4 2595
5a15f56f
AM		 2596 /* Make sure this symbol is output as a dynamic symbol.
2597 Undefined weak syms won't yet be marked as dynamic. */
2598 if (h->dynindx == -1
aec6b87e
L		 2599 && !h->forced_local
2600 && !resolved_to_zero)
5a15f56f 2601 {
c152c796 2602 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 2603 return FALSE;
5a15f56f
AM		 2604 }
2605
0e1862bb 2606 if (bfd_link_pic (info)
4e795f50 2607 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
ced53ee5 2608 {
6de2ae4a 2609 asection *s = htab->elf.splt;
dd7e64d4 2610 asection *got_s = htab->plt_got;
6725bdbf 2611
7c1e8d3e
L		 2612 /* If this is the first .plt entry, make room for the special
2613 first entry. The .plt section is used by prelink to undo
2614 prelinking for dynamic relocations. */
2615 if (s->size == 0)
2616 s->size = plt_entry_size;
2617
dd7e64d4
L		 2618 if (use_plt_got)
2619 eh->plt_got.offset = got_s->size;
2620 else
7c1e8d3e 2621 h->plt.offset = s->size;
6725bdbf 2622
ced53ee5
AM		 2623 /* If this symbol is not defined in a regular file, and we are
2624 not generating a shared library, then set the symbol to this
2625 location in the .plt. This is required to make function
2626 pointers compare as equal between the normal executable and
2627 the shared library. */
0e1862bb 2628 if (! bfd_link_pic (info)
f5385ebf 2629 && !h->def_regular)
ced53ee5 2630 {
dd7e64d4
L		 2631 if (use_plt_got)
2632 {
2633 /* We need to make a call to the entry of the GOT PLT
2634 instead of regular PLT entry. */
2635 h->root.u.def.section = got_s;
2636 h->root.u.def.value = eh->plt_got.offset;
2637 }
2638 else
2639 {
2640 h->root.u.def.section = s;
2641 h->root.u.def.value = h->plt.offset;
2642 }
ced53ee5 2643 }
6725bdbf 2644
ced53ee5 2645 /* Make room for this entry. */
dd7e64d4
L		 2646 if (use_plt_got)
2647 got_s->size += sizeof (elf_i386_got_plt_entry);
2648 else
2649 {
2650 s->size += plt_entry_size;
6725bdbf 2651
dd7e64d4
L		 2652 /* We also need to make an entry in the .got.plt section,
2653 which will be placed in the .got section by the linker
2654 script. */
2655 htab->elf.sgotplt->size += 4;
6725bdbf 2656
aec6b87e
L		 2657 /* There should be no PLT relocation against resolved
2658 undefined weak symbol in executable. */
2659 if (!resolved_to_zero)
2660 {
2661 /* We also need to make an entry in the .rel.plt
2662 section. */
2663 htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
2664 htab->elf.srelplt->reloc_count++;
2665 }
dd7e64d4 2666 }
eac338cf 2667
23209a78 2668 if (get_elf_i386_backend_data (info->output_bfd)->is_vxworks
0e1862bb 2669 && !bfd_link_pic (info))
eac338cf
PB		 2670 {
2671 /* VxWorks has a second set of relocations for each PLT entry
2672 in executables. They go in a separate relocation section,
2673 which is processed by the kernel loader. */
2674
2675 /* There are two relocations for the initial PLT entry: an
2676 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
2677 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
2678
25e762b9 2679 if (h->plt.offset == plt_entry_size)
eac338cf
PB		 2680 htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
2681
2682 /* There are two extra relocations for each subsequent PLT entry:
2683 an R_386_32 relocation for the GOT entry, and an R_386_32
2684 relocation for the PLT entry. */
2685
2686 htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
2687 }
6725bdbf 2688 }
ced53ee5
AM		 2689 else
2690 {
13f42277 2691 eh->plt_got.offset = (bfd_vma) -1;
51b64d56 2692 h->plt.offset = (bfd_vma) -1;
f5385ebf 2693 h->needs_plt = 0;
ced53ee5 2694 }
6725bdbf
AM		 2695 }
2696 else
2697 {
13f42277 2698 eh->plt_got.offset = (bfd_vma) -1;
51b64d56 2699 h->plt.offset = (bfd_vma) -1;
f5385ebf 2700 h->needs_plt = 0;
6725bdbf
AM		 2701 }
2702
67a4f2b7
AO		 2703 eh->tlsdesc_got = (bfd_vma) -1;
2704
37e55690 2705 /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
13ae64f3
JJ		 2706 make it a R_386_TLS_LE_32 requiring no TLS entry. */
2707 if (h->got.refcount > 0
0e1862bb 2708 && bfd_link_executable (info)
13ae64f3 2709 && h->dynindx == -1
37e55690 2710 && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE))
cedb70c5 2711 h->got.offset = (bfd_vma) -1;
13ae64f3 2712 else if (h->got.refcount > 0)
6725bdbf 2713 {
0ac8d2ca 2714 asection *s;
b34976b6 2715 bfd_boolean dyn;
13ae64f3 2716 int tls_type = elf_i386_hash_entry(h)->tls_type;
6725bdbf 2717
5a15f56f
AM		 2718 /* Make sure this symbol is output as a dynamic symbol.
2719 Undefined weak syms won't yet be marked as dynamic. */
2720 if (h->dynindx == -1
aec6b87e
L		 2721 && !h->forced_local
2722 && !resolved_to_zero)
5a15f56f 2723 {
c152c796 2724 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 2725 return FALSE;
5a15f56f
AM		 2726 }
2727
6de2ae4a 2728 s = htab->elf.sgot;
67a4f2b7
AO		 2729 if (GOT_TLS_GDESC_P (tls_type))
2730 {
6de2ae4a 2731 eh->tlsdesc_got = htab->elf.sgotplt->size
67a4f2b7 2732 - elf_i386_compute_jump_table_size (htab);
6de2ae4a 2733 htab->elf.sgotplt->size += 8;
67a4f2b7
AO		 2734 h->got.offset = (bfd_vma) -2;
2735 }
2736 if (! GOT_TLS_GDESC_P (tls_type)
2737 || GOT_TLS_GD_P (tls_type))
2738 {
2739 h->got.offset = s->size;
2740 s->size += 4;
2741 /* R_386_TLS_GD needs 2 consecutive GOT slots. */
2742 if (GOT_TLS_GD_P (tls_type) || tls_type == GOT_TLS_IE_BOTH)
2743 s->size += 4;
2744 }
ebe50bae 2745 dyn = htab->elf.dynamic_sections_created;
13ae64f3 2746 /* R_386_TLS_IE_32 needs one dynamic relocation,
37e55690
JJ		 2747 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
2748 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
2749 need two), R_386_TLS_GD needs one if local symbol and two if
aec6b87e
L		 2750 global. No dynamic relocation against resolved undefined weak
2751 symbol in executable. */
37e55690 2752 if (tls_type == GOT_TLS_IE_BOTH)
6de2ae4a 2753 htab->elf.srelgot->size += 2 * sizeof (Elf32_External_Rel);
67a4f2b7 2754 else if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
37e55690 2755 || (tls_type & GOT_TLS_IE))
6de2ae4a 2756 htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
67a4f2b7 2757 else if (GOT_TLS_GD_P (tls_type))
6de2ae4a 2758 htab->elf.srelgot->size += 2 * sizeof (Elf32_External_Rel);
67a4f2b7 2759 else if (! GOT_TLS_GDESC_P (tls_type)
aec6b87e
L		 2760 && ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2761 && !resolved_to_zero)
67a4f2b7 2762 || h->root.type != bfd_link_hash_undefweak)
0e1862bb 2763 && (bfd_link_pic (info)
ef5aade5 2764 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
6de2ae4a 2765 htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
67a4f2b7 2766 if (GOT_TLS_GDESC_P (tls_type))
6de2ae4a 2767 htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
6725bdbf
AM		 2768 }
2769 else
51b64d56 2770 h->got.offset = (bfd_vma) -1;
6725bdbf 2771
5a15f56f 2772 if (eh->dyn_relocs == NULL)
b34976b6 2773 return TRUE;
5a15f56f 2774
0c715baa
AM		 2775 /* In the shared -Bsymbolic case, discard space allocated for
2776 dynamic pc-relative relocs against symbols which turn out to be
2777 defined in regular objects. For the normal shared case, discard
0ac8d2ca
AM		 2778 space for pc-relative relocs that have become local due to symbol
2779 visibility changes. */
0c715baa 2780
0e1862bb 2781 if (bfd_link_pic (info))
5a15f56f 2782 {
09695f56
AM		 2783 /* The only reloc that uses pc_count is R_386_PC32, which will
2784 appear on a call or on something like ".long foo - .". We
2785 want calls to protected symbols to resolve directly to the
2786 function rather than going via the plt. If people want
2787 function pointer comparisons to work as expected then they
2788 should avoid writing assembly like ".long foo - .". */
2789 if (SYMBOL_CALLS_LOCAL (info, h))
5a15f56f 2790 {
e03a8ed8 2791 struct elf_dyn_relocs **pp;
0c715baa
AM		 2792
2793 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2794 {
c3ce498c
L		 2795 p->count -= p->pc_count;
2796 p->pc_count = 0;
0c715baa
AM		 2797 if (p->count == 0)
2798 *pp = p->next;
2799 else
2800 pp = &p->next;
2801 }
5a15f56f 2802 }
4e795f50 2803
23209a78 2804 if (get_elf_i386_backend_data (info->output_bfd)->is_vxworks)
3348747a 2805 {
e03a8ed8 2806 struct elf_dyn_relocs **pp;
3348747a
NS		 2807 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2808 {
2809 if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
2810 *pp = p->next;
2811 else
2812 pp = &p->next;
2813 }
2814 }
2815
4e795f50 2816 /* Also discard relocs on undefined weak syms with non-default
aec6b87e 2817 visibility or in PIE. */
22d606e9 2818 if (eh->dyn_relocs != NULL
c353e543 2819 && h->root.type == bfd_link_hash_undefweak)
22d606e9 2820 {
aec6b87e
L		 2821 /* Undefined weak symbol is never bound locally in shared
2822 library. */
2823 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2824 || resolved_to_zero)
2825 {
2826 if (h->non_got_ref)
2827 {
2828 /* Keep dynamic non-GOT/non-PLT relocation so that we
2829 can branch to 0 without PLT. */
2830 struct elf_dyn_relocs **pp;
2831
2832 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2833 if (p->pc_count == 0)
2834 *pp = p->next;
2835 else
2836 {
2837 /* Remove non-R_386_PC32 relocation. */
2838 p->count = p->pc_count;
2839 pp = &p->next;
2840 }
22d606e9 2841
aec6b87e
L		 2842 if (eh->dyn_relocs != NULL)
2843 {
2844 /* Make sure undefined weak symbols are output
2845 as dynamic symbols in PIEs for dynamic non-GOT
2846 non-PLT reloations. */
2847 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2848 return FALSE;
2849 }
2850 }
2851 else
2852 eh->dyn_relocs = NULL;
2853 }
22d606e9
AM		 2854 else if (h->dynindx == -1
2855 && !h->forced_local)
2856 {
2857 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2858 return FALSE;
2859 }
2860 }
0c715baa 2861 }
a23b6845 2862 else if (ELIMINATE_COPY_RELOCS)
0c715baa
AM		 2863 {
2864 /* For the non-shared case, discard space for relocs against
2865 symbols which turn out to need copy relocs or are not
04ebc307
L		 2866 dynamic. Keep dynamic relocations for run-time function
2867 pointer initialization. */
0c715baa 2868
aec6b87e
L		 2869 if ((!h->non_got_ref
2870 || eh->func_pointer_refcount > 0
2871 || (h->root.type == bfd_link_hash_undefweak
2872 && !resolved_to_zero))
f5385ebf
AM		 2873 && ((h->def_dynamic
2874 && !h->def_regular)
ebe50bae 2875 || (htab->elf.dynamic_sections_created
0c715baa
AM		 2876 && (h->root.type == bfd_link_hash_undefweak
2877 || h->root.type == bfd_link_hash_undefined))))
2878 {
2879 /* Make sure this symbol is output as a dynamic symbol.
2880 Undefined weak syms won't yet be marked as dynamic. */
2881 if (h->dynindx == -1
aec6b87e
L		 2882 && !h->forced_local
2883 && !resolved_to_zero)
0c715baa 2884 {
c152c796 2885 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 2886 return FALSE;
0c715baa 2887 }
5a15f56f 2888
0c715baa
AM		 2889 /* If that succeeded, we know we'll be keeping all the
2890 relocs. */
2891 if (h->dynindx != -1)
2892 goto keep;
2893 }
2894
2895 eh->dyn_relocs = NULL;
04ebc307 2896 eh->func_pointer_refcount = 0;
0c715baa 2897
ec338859 2898 keep: ;
5a15f56f
AM		 2899 }
2900
0c715baa
AM		 2901 /* Finally, allocate space. */
2902 for (p = eh->dyn_relocs; p != NULL; p = p->next)
12d0ee4a 2903 {
e7c33416
NC		 2904 asection *sreloc;
2905
cbe950e9 2906 sreloc = elf_section_data (p->sec)->sreloc;
e7c33416
NC		 2907
2908 BFD_ASSERT (sreloc != NULL);
eea6121a 2909 sreloc->size += p->count * sizeof (Elf32_External_Rel);
12d0ee4a
AM		 2910 }
2911
b34976b6 2912 return TRUE;
6725bdbf
AM		 2913}
2914
c25bc9fc
L		 2915/* Allocate space in .plt, .got and associated reloc sections for
2916 local dynamic relocs. */
2917
2918static bfd_boolean
2919elf_i386_allocate_local_dynrelocs (void **slot, void *inf)
2920{
2921 struct elf_link_hash_entry *h
2922 = (struct elf_link_hash_entry *) *slot;
2923
2924 if (h->type != STT_GNU_IFUNC
2925 || !h->def_regular
2926 || !h->ref_regular
2927 || !h->forced_local
2928 || h->root.type != bfd_link_hash_defined)
2929 abort ();
2930
2931 return elf_i386_allocate_dynrelocs (h, inf);
2932}
2933
0c715baa
AM		 2934/* Find any dynamic relocs that apply to read-only sections. */
2935
b34976b6 2936static bfd_boolean
eb4ff4d6 2937elf_i386_readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
0c715baa
AM		 2938{
2939 struct elf_i386_link_hash_entry *eh;
e03a8ed8 2940 struct elf_dyn_relocs *p;
0c715baa 2941
aa715242
L		 2942 /* Skip local IFUNC symbols. */
2943 if (h->forced_local && h->type == STT_GNU_IFUNC)
2944 return TRUE;
2945
0c715baa
AM		 2946 eh = (struct elf_i386_link_hash_entry *) h;
2947 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2948 {
2949 asection *s = p->sec->output_section;
2950
2951 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2952 {
2953 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2954
2955 info->flags |= DF_TEXTREL;
2956
0e1862bb 2957 if ((info->warn_shared_textrel && bfd_link_pic (info))
1952c5cd
L		 2958 || info->error_textrel)
2959 info->callbacks->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
b70321a2
L		 2960 p->sec->owner, h->root.root.string,
2961 p->sec);
2962
0c715baa 2963 /* Not an error, just cut short the traversal. */
b34976b6 2964 return FALSE;
0c715baa
AM		 2965 }
2966 }
b34976b6 2967 return TRUE;
0c715baa
AM		 2968}
2969
c175a657 2970/* Convert load via the GOT slot to load immediate. */
daa67607
L		 2971
2972static bfd_boolean
02a86693 2973elf_i386_convert_load (bfd *abfd, asection *sec,
a6af384b 2974 struct bfd_link_info *link_info)
daa67607 2975{
c175a657 2976 struct elf_i386_link_hash_table *htab;
daa67607
L		 2977 Elf_Internal_Shdr *symtab_hdr;
2978 Elf_Internal_Rela *internal_relocs;
2979 Elf_Internal_Rela *irel, *irelend;
2980 bfd_byte *contents;
c175a657 2981 bfd_boolean changed;
daa67607
L		 2982 bfd_signed_vma *local_got_refcounts;
2983
2984 /* Don't even try to convert non-ELF outputs. */
2985 if (!is_elf_hash_table (link_info->hash))
2986 return FALSE;
2987
c1d11331 2988 /* Nothing to do if there is no need or no output. */
daa67607 2989 if ((sec->flags & (SEC_CODE | SEC_RELOC)) != (SEC_CODE | SEC_RELOC)
02a86693 2990 || sec->need_convert_load == 0
c8831961 2991 || bfd_is_abs_section (sec->output_section))
daa67607
L		 2992 return TRUE;
2993
2994 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2995
2996 /* Load the relocations for this section. */
2997 internal_relocs = (_bfd_elf_link_read_relocs
2998 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
2999 link_info->keep_memory));
3000 if (internal_relocs == NULL)
3001 return FALSE;
3002
c175a657 3003 changed = FALSE;
daa67607 3004 htab = elf_i386_hash_table (link_info);
daa67607
L		 3005 local_got_refcounts = elf_local_got_refcounts (abfd);
3006
3007 /* Get the section contents. */
3008 if (elf_section_data (sec)->this_hdr.contents != NULL)
3009 contents = elf_section_data (sec)->this_hdr.contents;
3010 else
3011 {
3012 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
3013 goto error_return;
3014 }
3015
3016 irelend = internal_relocs + sec->reloc_count;
3017 for (irel = internal_relocs; irel < irelend; irel++)
3018 {
3019 unsigned int r_type = ELF32_R_TYPE (irel->r_info);
c175a657 3020 unsigned int r_symndx;
daa67607 3021 struct elf_link_hash_entry *h;
c175a657 3022 bfd_boolean converted;
daa67607 3023
02a86693 3024 if (r_type != R_386_GOT32 && r_type != R_386_GOT32X)
daa67607
L		 3025 continue;
3026
c175a657 3027 r_symndx = ELF32_R_SYM (irel->r_info);
02a86693 3028 if (r_symndx < symtab_hdr->sh_info)
c175a657
L		 3029 h = elf_i386_get_local_sym_hash (htab, sec->owner,
3030 (const Elf_Internal_Rela *) irel,
3031 FALSE);
3032 else
02a86693 3033 {
c175a657
L		 3034 h = elf_sym_hashes (abfd)[r_symndx - symtab_hdr->sh_info];
3035 while (h->root.type == bfd_link_hash_indirect
3036 || h->root.type == bfd_link_hash_warning)
3037 h = (struct elf_link_hash_entry *) h->root.u.i.link;
daa67607
L		 3038 }
3039
02a86693 3040 /* STT_GNU_IFUNC must keep GOT32 relocations. */
c175a657 3041 if (h != NULL && h->type == STT_GNU_IFUNC)
02a86693
L		 3042 continue;
3043
c175a657
L		 3044 converted = FALSE;
3045 if (!elf_i386_convert_load_reloc (abfd, symtab_hdr, contents,
3046 irel, h, &converted, link_info))
3047 goto error_return;
bae420ef 3048
c175a657 3049 if (converted)
02a86693 3050 {
c175a657
L		 3051 changed = converted;
3052 if (h)
02a86693 3053 {
c175a657
L		 3054 if (h->got.refcount > 0)
3055 h->got.refcount -= 1;
02a86693 3056 }
c175a657 3057 else
02a86693 3058 {
c175a657
L		 3059 if (local_got_refcounts != NULL
3060 && local_got_refcounts[r_symndx] > 0)
3061 local_got_refcounts[r_symndx] -= 1;
02a86693 3062 }
daa67607
L		 3063 }
3064 }
3065
3066 if (contents != NULL
3067 && elf_section_data (sec)->this_hdr.contents != contents)
3068 {
c175a657 3069 if (!changed && !link_info->keep_memory)
daa67607
L		 3070 free (contents);
3071 else
3072 {
3073 /* Cache the section contents for elf_link_input_bfd. */
3074 elf_section_data (sec)->this_hdr.contents = contents;
3075 }
3076 }
3077
3078 if (elf_section_data (sec)->relocs != internal_relocs)
3079 {
c175a657 3080 if (!changed)
daa67607
L		 3081 free (internal_relocs);
3082 else
3083 elf_section_data (sec)->relocs = internal_relocs;
3084 }
3085
3086 return TRUE;
3087
3088 error_return:
3089 if (contents != NULL
3090 && elf_section_data (sec)->this_hdr.contents != contents)
3091 free (contents);
3092 if (internal_relocs != NULL
3093 && elf_section_data (sec)->relocs != internal_relocs)
3094 free (internal_relocs);
3095 return FALSE;
3096}
3097
252b5132
RH		 3098/* Set the sizes of the dynamic sections. */
3099
b34976b6 3100static bfd_boolean
23209a78 3101elf_i386_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
252b5132 3102{
6725bdbf 3103 struct elf_i386_link_hash_table *htab;
252b5132
RH		 3104 bfd *dynobj;
3105 asection *s;
b34976b6 3106 bfd_boolean relocs;
0c715baa 3107 bfd *ibfd;
252b5132 3108
6725bdbf 3109 htab = elf_i386_hash_table (info);
4dfe6ac6
NC		 3110 if (htab == NULL)
3111 return FALSE;
ebe50bae 3112 dynobj = htab->elf.dynobj;
ffb2e45b
AM		 3113 if (dynobj == NULL)
3114 abort ();
252b5132 3115
0c715baa
AM		 3116 /* Set up .got offsets for local syms, and space for local dynamic
3117 relocs. */
c72f2fb2 3118 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
161d71a6
L		 3119 {
3120 bfd_signed_vma *local_got;
3121 bfd_signed_vma *end_local_got;
13ae64f3 3122 char *local_tls_type;
67a4f2b7 3123 bfd_vma *local_tlsdesc_gotent;
161d71a6
L		 3124 bfd_size_type locsymcount;
3125 Elf_Internal_Shdr *symtab_hdr;
3126 asection *srel;
6725bdbf 3127
0ffa91dd 3128 if (! is_i386_elf (ibfd))
161d71a6 3129 continue;
6725bdbf 3130
0c715baa
AM		 3131 for (s = ibfd->sections; s != NULL; s = s->next)
3132 {
e03a8ed8 3133 struct elf_dyn_relocs *p;
0c715baa 3134
02a86693 3135 if (!elf_i386_convert_load (ibfd, s, info))
daa67607
L		 3136 return FALSE;
3137
e03a8ed8 3138 for (p = ((struct elf_dyn_relocs *)
e81d3500 3139 elf_section_data (s)->local_dynrel);
ec338859
AM		 3140 p != NULL;
3141 p = p->next)
0c715baa 3142 {
ec338859
AM		 3143 if (!bfd_is_abs_section (p->sec)
3144 && bfd_is_abs_section (p->sec->output_section))
3145 {
3146 /* Input section has been discarded, either because
3147 it is a copy of a linkonce section or due to
3148 linker script /DISCARD/, so we'll be discarding
3149 the relocs too. */
3150 }
23209a78 3151 else if (get_elf_i386_backend_data (output_bfd)->is_vxworks
3348747a
NS		 3152 && strcmp (p->sec->output_section->name,
3153 ".tls_vars") == 0)
3154 {
3155 /* Relocations in vxworks .tls_vars sections are
3156 handled specially by the loader. */
3157 }
248866a8 3158 else if (p->count != 0)
ec338859
AM		 3159 {
3160 srel = elf_section_data (p->sec)->sreloc;
eea6121a 3161 srel->size += p->count * sizeof (Elf32_External_Rel);
4b819e1f
L		 3162 if ((p->sec->output_section->flags & SEC_READONLY) != 0
3163 && (info->flags & DF_TEXTREL) == 0)
b70321a2
L		 3164 {
3165 info->flags |= DF_TEXTREL;
0e1862bb 3166 if ((info->warn_shared_textrel && bfd_link_pic (info))
1952c5cd
L		 3167 || info->error_textrel)
3168 info->callbacks->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
b70321a2 3169 p->sec->owner, p->sec);
b70321a2 3170 }
ec338859 3171 }
0c715baa
AM		 3172 }
3173 }
3174
3175 local_got = elf_local_got_refcounts (ibfd);
161d71a6
L		 3176 if (!local_got)
3177 continue;
6725bdbf 3178
0ffa91dd 3179 symtab_hdr = &elf_symtab_hdr (ibfd);
161d71a6
L		 3180 locsymcount = symtab_hdr->sh_info;
3181 end_local_got = local_got + locsymcount;
13ae64f3 3182 local_tls_type = elf_i386_local_got_tls_type (ibfd);
67a4f2b7 3183 local_tlsdesc_gotent = elf_i386_local_tlsdesc_gotent (ibfd);
6de2ae4a
L		 3184 s = htab->elf.sgot;
3185 srel = htab->elf.srelgot;
67a4f2b7
AO		 3186 for (; local_got < end_local_got;
3187 ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
161d71a6 3188 {
67a4f2b7 3189 *local_tlsdesc_gotent = (bfd_vma) -1;
161d71a6 3190 if (*local_got > 0)
6725bdbf 3191 {
67a4f2b7
AO		 3192 if (GOT_TLS_GDESC_P (*local_tls_type))
3193 {
6de2ae4a 3194 *local_tlsdesc_gotent = htab->elf.sgotplt->size
67a4f2b7 3195 - elf_i386_compute_jump_table_size (htab);
6de2ae4a 3196 htab->elf.sgotplt->size += 8;
67a4f2b7
AO		 3197 *local_got = (bfd_vma) -2;
3198 }
3199 if (! GOT_TLS_GDESC_P (*local_tls_type)
3200 || GOT_TLS_GD_P (*local_tls_type))
3201 {
3202 *local_got = s->size;
3203 s->size += 4;
3204 if (GOT_TLS_GD_P (*local_tls_type)
3205 || *local_tls_type == GOT_TLS_IE_BOTH)
3206 s->size += 4;
3207 }
0e1862bb 3208 if (bfd_link_pic (info)
67a4f2b7 3209 || GOT_TLS_GD_ANY_P (*local_tls_type)
37e55690
JJ		 3210 || (*local_tls_type & GOT_TLS_IE))
3211 {
3212 if (*local_tls_type == GOT_TLS_IE_BOTH)
eea6121a 3213 srel->size += 2 * sizeof (Elf32_External_Rel);
67a4f2b7
AO		 3214 else if (GOT_TLS_GD_P (*local_tls_type)
3215 || ! GOT_TLS_GDESC_P (*local_tls_type))
eea6121a 3216 srel->size += sizeof (Elf32_External_Rel);
67a4f2b7 3217 if (GOT_TLS_GDESC_P (*local_tls_type))
6de2ae4a 3218 htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
37e55690 3219 }
6725bdbf 3220 }
161d71a6
L		 3221 else
3222 *local_got = (bfd_vma) -1;
6725bdbf 3223 }
252b5132 3224 }
6725bdbf 3225
13ae64f3
JJ		 3226 if (htab->tls_ldm_got.refcount > 0)
3227 {
3228 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
3229 relocs. */
6de2ae4a
L		 3230 htab->tls_ldm_got.offset = htab->elf.sgot->size;
3231 htab->elf.sgot->size += 8;
3232 htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
13ae64f3
JJ		 3233 }
3234 else
3235 htab->tls_ldm_got.offset = -1;
3236
0c715baa
AM		 3237 /* Allocate global sym .plt and .got entries, and space for global
3238 sym dynamic relocs. */
eb4ff4d6 3239 elf_link_hash_traverse (&htab->elf, elf_i386_allocate_dynrelocs, info);
252b5132 3240
c25bc9fc
L		 3241 /* Allocate .plt and .got entries, and space for local symbols. */
3242 htab_traverse (htab->loc_hash_table,
3243 elf_i386_allocate_local_dynrelocs,
3244 info);
3245
67a4f2b7
AO		 3246 /* For every jump slot reserved in the sgotplt, reloc_count is
3247 incremented. However, when we reserve space for TLS descriptors,
3248 it's not incremented, so in order to compute the space reserved
3249 for them, it suffices to multiply the reloc count by the jump
e1f98742 3250 slot size.
caa0075c 3251
e1f98742
L		 3252 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3253 so that R_386_IRELATIVE entries come last. */
6de2ae4a 3254 if (htab->elf.srelplt)
e1f98742
L		 3255 {
3256 htab->next_tls_desc_index = htab->elf.srelplt->reloc_count;
3257 htab->sgotplt_jump_table_size = htab->next_tls_desc_index * 4;
3258 htab->next_irelative_index = htab->elf.srelplt->reloc_count - 1;
3259 }
3260 else if (htab->elf.irelplt)
3261 htab->next_irelative_index = htab->elf.irelplt->reloc_count - 1;
3262
67a4f2b7 3263
a7b16ceb
L		 3264 if (htab->elf.sgotplt)
3265 {
3266 /* Don't allocate .got.plt section if there are no GOT nor PLT
9a2a56cc 3267 entries and there is no reference to _GLOBAL_OFFSET_TABLE_. */
9d4b2dba
L		 3268 if ((htab->elf.hgot == NULL
3269 || !htab->elf.hgot->ref_regular_nonweak)
e28df02b
L		 3270 && (htab->elf.sgotplt->size
3271 == get_elf_backend_data (output_bfd)->got_header_size)
a7b16ceb
L		 3272 && (htab->elf.splt == NULL
3273 || htab->elf.splt->size == 0)
3274 && (htab->elf.sgot == NULL
3275 || htab->elf.sgot->size == 0)
3276 && (htab->elf.iplt == NULL
3277 || htab->elf.iplt->size == 0)
3278 && (htab->elf.igotplt == NULL
3279 || htab->elf.igotplt->size == 0))
3280 htab->elf.sgotplt->size = 0;
3281 }
3282
9a2a56cc
AM		 3283
3284 if (htab->plt_eh_frame != NULL
3285 && htab->elf.splt != NULL
3286 && htab->elf.splt->size != 0
3287 && !bfd_is_abs_section (htab->elf.splt->output_section)
3288 && _bfd_elf_eh_frame_present (info))
3289 htab->plt_eh_frame->size = sizeof (elf_i386_eh_frame_plt);
3290
5a15f56f
AM		 3291 /* We now have determined the sizes of the various dynamic sections.
3292 Allocate memory for them. */
b34976b6 3293 relocs = FALSE;
252b5132
RH		 3294 for (s = dynobj->sections; s != NULL; s = s->next)
3295 {
eac338cf
PB		 3296 bfd_boolean strip_section = TRUE;
3297
252b5132
RH		 3298 if ((s->flags & SEC_LINKER_CREATED) == 0)
3299 continue;
3300
6de2ae4a 3301 if (s == htab->elf.splt
9a2a56cc 3302 || s == htab->elf.sgot)
252b5132 3303 {
6725bdbf
AM		 3304 /* Strip this section if we don't need it; see the
3305 comment below. */
eac338cf
PB		 3306 /* We'd like to strip these sections if they aren't needed, but if
3307 we've exported dynamic symbols from them we must leave them.
3308 It's too late to tell BFD to get rid of the symbols. */
3309
7325306f 3310 if (htab->elf.hplt != NULL)
eac338cf 3311 strip_section = FALSE;
252b5132 3312 }
9a2a56cc
AM		 3313 else if (s == htab->elf.sgotplt
3314 || s == htab->elf.iplt
3315 || s == htab->elf.igotplt
dd7e64d4 3316 || s == htab->plt_got
9a2a56cc
AM		 3317 || s == htab->plt_eh_frame
3318 || s == htab->sdynbss)
3319 {
3320 /* Strip these too. */
3321 }
0112cd26 3322 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rel"))
252b5132 3323 {
6de2ae4a
L		 3324 if (s->size != 0
3325 && s != htab->elf.srelplt
3326 && s != htab->srelplt2)
b34976b6 3327 relocs = TRUE;
252b5132 3328
0ac8d2ca
AM		 3329 /* We use the reloc_count field as a counter if we need
3330 to copy relocs into the output file. */
5ae0bfb6 3331 s->reloc_count = 0;
252b5132 3332 }
6725bdbf 3333 else
252b5132
RH		 3334 {
3335 /* It's not one of our sections, so don't allocate space. */
3336 continue;
3337 }
3338
c456f082 3339 if (s->size == 0)
252b5132 3340 {
0ac8d2ca
AM		 3341 /* If we don't need this section, strip it from the
3342 output file. This is mostly to handle .rel.bss and
3343 .rel.plt. We must create both sections in
3344 create_dynamic_sections, because they must be created
3345 before the linker maps input sections to output
3346 sections. The linker does that before
3347 adjust_dynamic_symbol is called, and it is that
3348 function which decides whether anything needs to go
3349 into these sections. */
c456f082
AM		 3350 if (strip_section)
3351 s->flags |= SEC_EXCLUDE;
252b5132
RH		 3352 continue;
3353 }
3354
c456f082
AM		 3355 if ((s->flags & SEC_HAS_CONTENTS) == 0)
3356 continue;
3357
f69da49f
AM		 3358 /* Allocate memory for the section contents. We use bfd_zalloc
3359 here in case unused entries are not reclaimed before the
3360 section's contents are written out. This should not happen,
3361 but this way if it does, we get a R_386_NONE reloc instead
3362 of garbage. */
a50b1753 3363 s->contents = (unsigned char *) bfd_zalloc (dynobj, s->size);
6725bdbf 3364 if (s->contents == NULL)
b34976b6 3365 return FALSE;
252b5132
RH		 3366 }
3367
e41b3a13 3368 if (htab->plt_eh_frame != NULL
9a2a56cc
AM		 3369 && htab->plt_eh_frame->contents != NULL)
3370 {
3371 memcpy (htab->plt_eh_frame->contents, elf_i386_eh_frame_plt,
3372 sizeof (elf_i386_eh_frame_plt));
3373 bfd_put_32 (dynobj, htab->elf.splt->size,
3374 htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET);
3375 }
e41b3a13 3376
ebe50bae 3377 if (htab->elf.dynamic_sections_created)
252b5132
RH		 3378 {
3379 /* Add some entries to the .dynamic section. We fill in the
3380 values later, in elf_i386_finish_dynamic_sections, but we
3381 must add the entries now so that we get the correct size for
3382 the .dynamic section. The DT_DEBUG entry is filled in by the
3383 dynamic linker and used by the debugger. */
dc810e39 3384#define add_dynamic_entry(TAG, VAL) \
5a580b3a 3385 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
dc810e39 3386
0e1862bb 3387 if (bfd_link_executable (info))
252b5132 3388 {
dc810e39 3389 if (!add_dynamic_entry (DT_DEBUG, 0))
b34976b6 3390 return FALSE;
252b5132
RH		 3391 }
3392
6de2ae4a 3393 if (htab->elf.splt->size != 0)
252b5132 3394 {
7c1e8d3e
L		 3395 /* DT_PLTGOT is used by prelink even if there is no PLT
3396 relocation. */
3397 if (!add_dynamic_entry (DT_PLTGOT, 0))
b34976b6 3398 return FALSE;
7c1e8d3e
L		 3399
3400 if (htab->elf.srelplt->size != 0)
3401 {
3402 if (!add_dynamic_entry (DT_PLTRELSZ, 0)
3403 || !add_dynamic_entry (DT_PLTREL, DT_REL)
3404 || !add_dynamic_entry (DT_JMPREL, 0))
3405 return FALSE;
3406 }
252b5132
RH		 3407 }
3408
3409 if (relocs)
3410 {
dc810e39
AM		 3411 if (!add_dynamic_entry (DT_REL, 0)
3412 || !add_dynamic_entry (DT_RELSZ, 0)
3413 || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
b34976b6 3414 return FALSE;
252b5132 3415
0c715baa
AM		 3416 /* If any dynamic relocs apply to a read-only section,
3417 then we need a DT_TEXTREL entry. */
248866a8 3418 if ((info->flags & DF_TEXTREL) == 0)
eb4ff4d6
L		 3419 elf_link_hash_traverse (&htab->elf,
3420 elf_i386_readonly_dynrelocs, info);
0c715baa
AM		 3421
3422 if ((info->flags & DF_TEXTREL) != 0)
3423 {
2df3368d 3424 if (htab->readonly_dynrelocs_against_ifunc)
8efa2874
L		 3425 {
3426 info->callbacks->einfo
3427 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
3428 bfd_set_error (bfd_error_bad_value);
3429 return FALSE;
3430 }
3431
0c715baa 3432 if (!add_dynamic_entry (DT_TEXTREL, 0))
b34976b6 3433 return FALSE;
0c715baa 3434 }
252b5132 3435 }
23209a78 3436 if (get_elf_i386_backend_data (output_bfd)->is_vxworks
7a2b07ff
NS		 3437 && !elf_vxworks_add_dynamic_entries (output_bfd, info))
3438 return FALSE;
252b5132 3439 }
dc810e39 3440#undef add_dynamic_entry
252b5132 3441
b34976b6 3442 return TRUE;
252b5132
RH		 3443}
3444
67a4f2b7
AO		 3445static bfd_boolean
3446elf_i386_always_size_sections (bfd *output_bfd,
3447 struct bfd_link_info *info)
3448{
3449 asection *tls_sec = elf_hash_table (info)->tls_sec;
3450
3451 if (tls_sec)
3452 {
3453 struct elf_link_hash_entry *tlsbase;
3454
3455 tlsbase = elf_link_hash_lookup (elf_hash_table (info),
3456 "_TLS_MODULE_BASE_",
3457 FALSE, FALSE, FALSE);
3458
3459 if (tlsbase && tlsbase->type == STT_TLS)
3460 {
4dfe6ac6 3461 struct elf_i386_link_hash_table *htab;
67a4f2b7
AO		 3462 struct bfd_link_hash_entry *bh = NULL;
3463 const struct elf_backend_data *bed
3464 = get_elf_backend_data (output_bfd);
3465
4dfe6ac6
NC		 3466 htab = elf_i386_hash_table (info);
3467 if (htab == NULL)
3468 return FALSE;
3469
67a4f2b7
AO		 3470 if (!(_bfd_generic_link_add_one_symbol
3471 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
3472 tls_sec, 0, NULL, FALSE,
3473 bed->collect, &bh)))
3474 return FALSE;
9f03412a 3475
4dfe6ac6 3476 htab->tls_module_base = bh;
9f03412a 3477
67a4f2b7
AO		 3478 tlsbase = (struct elf_link_hash_entry *)bh;
3479 tlsbase->def_regular = 1;
3480 tlsbase->other = STV_HIDDEN;
576fa883 3481 tlsbase->root.linker_def = 1;
67a4f2b7
AO		 3482 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
3483 }
3484 }
3485
3486 return TRUE;
3487}
3488
38701953
AM		 3489/* Set the correct type for an x86 ELF section. We do this by the
3490 section name, which is a hack, but ought to work. */
3491
b34976b6 3492static bfd_boolean
55fd94b0
AM		 3493elf_i386_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
3494 Elf_Internal_Shdr *hdr,
3495 asection *sec)
38701953 3496{
91d6fa6a 3497 const char *name;
38701953
AM		 3498
3499 name = bfd_get_section_name (abfd, sec);
3500
3501 /* This is an ugly, but unfortunately necessary hack that is
3502 needed when producing EFI binaries on x86. It tells
3503 elf.c:elf_fake_sections() not to consider ".reloc" as a section
3504 containing ELF relocation info. We need this hack in order to
3505 be able to generate ELF binaries that can be translated into
3506 EFI applications (which are essentially COFF objects). Those
3507 files contain a COFF ".reloc" section inside an ELFNN object,
3508 which would normally cause BFD to segfault because it would
3509 attempt to interpret this section as containing relocation
3510 entries for section "oc". With this hack enabled, ".reloc"
3511 will be treated as a normal data section, which will avoid the
3512 segfault. However, you won't be able to create an ELFNN binary
3513 with a section named "oc" that needs relocations, but that's
3514 the kind of ugly side-effects you get when detecting section
3515 types based on their names... In practice, this limitation is
3516 unlikely to bite. */
3517 if (strcmp (name, ".reloc") == 0)
3518 hdr->sh_type = SHT_PROGBITS;
3519
b34976b6 3520 return TRUE;
38701953
AM		 3521}
3522
9f03412a
AO		 3523/* _TLS_MODULE_BASE_ needs to be treated especially when linking
3524 executables. Rather than setting it to the beginning of the TLS
3525 section, we have to set it to the end. This function may be called
3526 multiple times, it is idempotent. */
3527
3528static void
eb4ff4d6 3529elf_i386_set_tls_module_base (struct bfd_link_info *info)
9f03412a 3530{
4dfe6ac6 3531 struct elf_i386_link_hash_table *htab;
9f03412a
AO		 3532 struct bfd_link_hash_entry *base;
3533
0e1862bb 3534 if (!bfd_link_executable (info))
9f03412a
AO		 3535 return;
3536
4dfe6ac6
NC		 3537 htab = elf_i386_hash_table (info);
3538 if (htab == NULL)
3539 return;
9f03412a 3540
4dfe6ac6
NC		 3541 base = htab->tls_module_base;
3542 if (base == NULL)
9f03412a
AO		 3543 return;
3544
4dfe6ac6 3545 base->u.def.value = htab->elf.tls_size;
9f03412a
AO		 3546}
3547
13ae64f3
JJ		 3548/* Return the base VMA address which should be subtracted from real addresses
3549 when resolving @dtpoff relocation.
3550 This is PT_TLS segment p_vaddr. */
3551
3552static bfd_vma
eb4ff4d6 3553elf_i386_dtpoff_base (struct bfd_link_info *info)
13ae64f3 3554{
e1918d23
AM		 3555 /* If tls_sec is NULL, we should have signalled an error already. */
3556 if (elf_hash_table (info)->tls_sec == NULL)
6a30718d 3557 return 0;
e1918d23 3558 return elf_hash_table (info)->tls_sec->vma;
13ae64f3
JJ		 3559}
3560
3561/* Return the relocation value for @tpoff relocation
3562 if STT_TLS virtual address is ADDRESS. */
3563
3564static bfd_vma
eb4ff4d6 3565elf_i386_tpoff (struct bfd_link_info *info, bfd_vma address)
13ae64f3 3566{
e1918d23 3567 struct elf_link_hash_table *htab = elf_hash_table (info);
7dc98aea
RO		 3568 const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
3569 bfd_vma static_tls_size;
13ae64f3 3570
e1918d23
AM		 3571 /* If tls_sec is NULL, we should have signalled an error already. */
3572 if (htab->tls_sec == NULL)
6a30718d 3573 return 0;
7dc98aea
RO		 3574
3575 /* Consider special static TLS alignment requirements. */
3576 static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
3577 return static_tls_size + htab->tls_sec->vma - address;
13ae64f3
JJ		 3578}
3579
252b5132
RH		 3580/* Relocate an i386 ELF section. */
3581
b34976b6 3582static bfd_boolean
55fd94b0
AM		 3583elf_i386_relocate_section (bfd *output_bfd,
3584 struct bfd_link_info *info,
3585 bfd *input_bfd,
3586 asection *input_section,
3587 bfd_byte *contents,
3588 Elf_Internal_Rela *relocs,
3589 Elf_Internal_Sym *local_syms,
3590 asection **local_sections)
252b5132 3591{
6725bdbf 3592 struct elf_i386_link_hash_table *htab;
252b5132
RH		 3593 Elf_Internal_Shdr *symtab_hdr;
3594 struct elf_link_hash_entry **sym_hashes;
3595 bfd_vma *local_got_offsets;
67a4f2b7 3596 bfd_vma *local_tlsdesc_gotents;
252b5132 3597 Elf_Internal_Rela *rel;
60f2e42e 3598 Elf_Internal_Rela *wrel;
252b5132 3599 Elf_Internal_Rela *relend;
3348747a 3600 bfd_boolean is_vxworks_tls;
25e762b9 3601 unsigned plt_entry_size;
252b5132 3602
0ffa91dd 3603 BFD_ASSERT (is_i386_elf (input_bfd));
6bbec505 3604
c337a162
L		 3605 /* Skip if check_relocs failed. */
3606 if (input_section->check_relocs_failed)
3607 return FALSE;
3608
6725bdbf 3609 htab = elf_i386_hash_table (info);
4dfe6ac6
NC		 3610 if (htab == NULL)
3611 return FALSE;
0ffa91dd 3612 symtab_hdr = &elf_symtab_hdr (input_bfd);
252b5132
RH		 3613 sym_hashes = elf_sym_hashes (input_bfd);
3614 local_got_offsets = elf_local_got_offsets (input_bfd);
67a4f2b7 3615 local_tlsdesc_gotents = elf_i386_local_tlsdesc_gotent (input_bfd);
3348747a
NS		 3616 /* We have to handle relocations in vxworks .tls_vars sections
3617 specially, because the dynamic loader is 'weird'. */
23209a78 3618 is_vxworks_tls = (get_elf_i386_backend_data (output_bfd)->is_vxworks
0e1862bb 3619 && bfd_link_pic (info)
3348747a
NS		 3620 && !strcmp (input_section->output_section->name,
3621 ".tls_vars"));
252b5132 3622
eb4ff4d6 3623 elf_i386_set_tls_module_base (info);
9f03412a 3624
25e762b9
RM		 3625 plt_entry_size = GET_PLT_ENTRY_SIZE (output_bfd);
3626
60f2e42e 3627 rel = wrel = relocs;
252b5132 3628 relend = relocs + input_section->reloc_count;
60f2e42e 3629 for (; rel < relend; wrel++, rel++)
252b5132 3630 {
13ae64f3 3631 unsigned int r_type;
252b5132
RH		 3632 reloc_howto_type *howto;
3633 unsigned long r_symndx;
3634 struct elf_link_hash_entry *h;
dd7e64d4 3635 struct elf_i386_link_hash_entry *eh;
252b5132
RH		 3636 Elf_Internal_Sym *sym;
3637 asection *sec;
dd7e64d4 3638 bfd_vma off, offplt, plt_offset;
252b5132 3639 bfd_vma relocation;
b34976b6 3640 bfd_boolean unresolved_reloc;
252b5132 3641 bfd_reloc_status_type r;
1b452ec6 3642 unsigned int indx;
13ae64f3 3643 int tls_type;
1788fc08 3644 bfd_vma st_size;
dd7e64d4 3645 asection *resolved_plt;
aec6b87e 3646 bfd_boolean resolved_to_zero;
252b5132
RH		 3647
3648 r_type = ELF32_R_TYPE (rel->r_info);
55fd94b0
AM		 3649 if (r_type == R_386_GNU_VTINHERIT
3650 || r_type == R_386_GNU_VTENTRY)
18954b29
L		 3651 {
3652 if (wrel != rel)
3653 *wrel = *rel;
3654 continue;
3655 }
dc47f327 3656
55fd94b0 3657 if ((indx = r_type) >= R_386_standard
13ae64f3
JJ		 3658 && ((indx = r_type - R_386_ext_offset) - R_386_standard
3659 >= R_386_ext - R_386_standard)
3660 && ((indx = r_type - R_386_tls_offset) - R_386_ext
c74be520 3661 >= R_386_ext2 - R_386_ext))
252b5132 3662 {
6ba842b6 3663 (*_bfd_error_handler)
d003868e
AM		 3664 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3665 input_bfd, input_section, r_type);
252b5132 3666 bfd_set_error (bfd_error_bad_value);
b34976b6 3667 return FALSE;
252b5132 3668 }
1b452ec6 3669 howto = elf_howto_table + indx;
252b5132
RH		 3670
3671 r_symndx = ELF32_R_SYM (rel->r_info);
252b5132
RH		 3672 h = NULL;
3673 sym = NULL;
3674 sec = NULL;
b34976b6 3675 unresolved_reloc = FALSE;
252b5132
RH		 3676 if (r_symndx < symtab_hdr->sh_info)
3677 {
3678 sym = local_syms + r_symndx;
3679 sec = local_sections[r_symndx];
3680 relocation = (sec->output_section->vma
3681 + sec->output_offset
3682 + sym->st_value);
1788fc08 3683 st_size = sym->st_size;
ab96bf03
AM		 3684
3685 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION
3686 && ((sec->flags & SEC_MERGE) != 0
0e1862bb 3687 || (bfd_link_relocatable (info)
ab96bf03 3688 && sec->output_offset != 0)))
f8df10f4 3689 {
f8df10f4 3690 bfd_vma addend;
4a335f3d 3691 bfd_byte *where = contents + rel->r_offset;
f8df10f4 3692
4a335f3d 3693 switch (howto->size)
f8df10f4 3694 {
4a335f3d
AM		 3695 case 0:
3696 addend = bfd_get_8 (input_bfd, where);
3697 if (howto->pc_relative)
3698 {
3699 addend = (addend ^ 0x80) - 0x80;
3700 addend += 1;
3701 }
3702 break;
3703 case 1:
3704 addend = bfd_get_16 (input_bfd, where);
3705 if (howto->pc_relative)
3706 {
3707 addend = (addend ^ 0x8000) - 0x8000;
3708 addend += 2;
3709 }
3710 break;
3711 case 2:
3712 addend = bfd_get_32 (input_bfd, where);
3713 if (howto->pc_relative)
3714 {
3715 addend = (addend ^ 0x80000000) - 0x80000000;
3716 addend += 4;
3717 }
3718 break;
3719 default:
3720 abort ();
f8df10f4
JJ		 3721 }
3722
0e1862bb 3723 if (bfd_link_relocatable (info))
ab96bf03
AM		 3724 addend += sec->output_offset;
3725 else
3726 {
3727 asection *msec = sec;
3728 addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec,
3729 addend);
3730 addend -= relocation;
3731 addend += msec->output_section->vma + msec->output_offset;
3732 }
4a335f3d
AM		 3733
3734 switch (howto->size)
3735 {
3736 case 0:
16a10388 3737 /* FIXME: overflow checks. */
4a335f3d
AM		 3738 if (howto->pc_relative)
3739 addend -= 1;
3740 bfd_put_8 (input_bfd, addend, where);
4a335f3d
AM		 3741 break;
3742 case 1:
3743 if (howto->pc_relative)
3744 addend -= 2;
3745 bfd_put_16 (input_bfd, addend, where);
4a335f3d
AM		 3746 break;
3747 case 2:
3748 if (howto->pc_relative)
3749 addend -= 4;
3750 bfd_put_32 (input_bfd, addend, where);
3751 break;
3752 }
f8df10f4 3753 }
0e1862bb 3754 else if (!bfd_link_relocatable (info)
1f85278f 3755 && ELF32_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
c25bc9fc
L		 3756 {
3757 /* Relocate against local STT_GNU_IFUNC symbol. */
9fff0c39
L		 3758 h = elf_i386_get_local_sym_hash (htab, input_bfd, rel,
3759 FALSE);
c25bc9fc
L		 3760 if (h == NULL)
3761 abort ();
3762
23209a78 3763 /* Set STT_GNU_IFUNC symbol value. */
c25bc9fc
L		 3764 h->root.u.def.value = sym->st_value;
3765 h->root.u.def.section = sec;
3766 }
252b5132
RH		 3767 }
3768 else
3769 {
3d540e93 3770 bfd_boolean warned ATTRIBUTE_UNUSED;
62d887d4 3771 bfd_boolean ignored ATTRIBUTE_UNUSED;
ffb2e45b 3772
b2a8e766
AM		 3773 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3774 r_symndx, symtab_hdr, sym_hashes,
3775 h, sec, relocation,
62d887d4 3776 unresolved_reloc, warned, ignored);
1788fc08 3777 st_size = h->size;
252b5132
RH		 3778 }
3779
dbaa2011 3780 if (sec != NULL && discarded_section (sec))
60f2e42e
L		 3781 {
3782 _bfd_clear_contents (howto, input_bfd, input_section,
3783 contents + rel->r_offset);
3784 wrel->r_offset = rel->r_offset;
3785 wrel->r_info = 0;
3786 wrel->r_addend = 0;
3787
3788 /* For ld -r, remove relocations in debug sections against
3789 sections defined in discarded sections. Not done for
3790 eh_frame editing code expects to be present. */
3791 if (bfd_link_relocatable (info)
3792 && (input_section->flags & SEC_DEBUGGING))
3793 wrel--;
3794
3795 continue;
3796 }
9635fe29 3797
0e1862bb 3798 if (bfd_link_relocatable (info))
2d5da473
L		 3799 {
3800 if (wrel != rel)
3801 *wrel = *rel;
3802 continue;
3803 }
ab96bf03 3804
cbe950e9
L		 3805 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3806 it here if it is defined in a non-shared object. */
3807 if (h != NULL
3808 && h->type == STT_GNU_IFUNC
3809 && h->def_regular)
3810 {
3811 asection *plt, *gotplt, *base_got;
3812 bfd_vma plt_index;
4c544807 3813 const char *name;
cbe950e9 3814
97dc35c8
L		 3815 if ((input_section->flags & SEC_ALLOC) == 0)
3816 {
3817 /* Dynamic relocs are not propagated for SEC_DEBUGGING
3818 sections because such sections are not SEC_ALLOC and
3819 thus ld.so will not process them. */
3820 if ((input_section->flags & SEC_DEBUGGING) != 0)
0eace210 3821 continue;
97dc35c8
L		 3822 abort ();
3823 }
3824 else if (h->plt.offset == (bfd_vma) -1)
cbe950e9
L		 3825 abort ();
3826
3827 /* STT_GNU_IFUNC symbol must go through PLT. */
6de2ae4a 3828 if (htab->elf.splt != NULL)
cbe950e9 3829 {
6de2ae4a
L		 3830 plt = htab->elf.splt;
3831 gotplt = htab->elf.sgotplt;
cbe950e9
L		 3832 }
3833 else
3834 {
6de2ae4a
L		 3835 plt = htab->elf.iplt;
3836 gotplt = htab->elf.igotplt;
cbe950e9
L		 3837 }
3838
3839 relocation = (plt->output_section->vma
3840 + plt->output_offset + h->plt.offset);
3841
3842 switch (r_type)
3843 {
3844 default:
4c544807
L		 3845 if (h->root.root.string)
3846 name = h->root.root.string;
3847 else
3848 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3849 NULL);
cbe950e9
L		 3850 (*_bfd_error_handler)
3851 (_("%B: relocation %s against STT_GNU_IFUNC "
3852 "symbol `%s' isn't handled by %s"), input_bfd,
3853 elf_howto_table[r_type].name,
4c544807 3854 name, __FUNCTION__);
cbe950e9
L		 3855 bfd_set_error (bfd_error_bad_value);
3856 return FALSE;
3857
3858 case R_386_32:
710ab287 3859 /* Generate dynamic relcoation only when there is a
c293fa49 3860 non-GOT reference in a shared object. */
0e1862bb 3861 if (bfd_link_pic (info) && h->non_got_ref)
710ab287
L		 3862 {
3863 Elf_Internal_Rela outrel;
710ab287
L		 3864 asection *sreloc;
3865 bfd_vma offset;
3866
c25bc9fc
L		 3867 /* Need a dynamic relocation to get the real function
3868 adddress. */
710ab287
L		 3869 offset = _bfd_elf_section_offset (output_bfd,
3870 info,
3871 input_section,
3872 rel->r_offset);
3873 if (offset == (bfd_vma) -1
3874 || offset == (bfd_vma) -2)
3875 abort ();
3876
3877 outrel.r_offset = (input_section->output_section->vma
3878 + input_section->output_offset
3879 + offset);
3880
3881 if (h->dynindx == -1
44c4ea11 3882 || h->forced_local
0e1862bb 3883 || bfd_link_executable (info))
710ab287
L		 3884 {
3885 /* This symbol is resolved locally. */
56b8aada
L		 3886 outrel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
3887 bfd_put_32 (output_bfd,
3888 (h->root.u.def.value
3889 + h->root.u.def.section->output_section->vma
3890 + h->root.u.def.section->output_offset),
3891 contents + offset);
710ab287
L		 3892 }
3893 else
56b8aada 3894 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
710ab287 3895
6de2ae4a 3896 sreloc = htab->elf.irelifunc;
59d6ffb2 3897 elf_append_rel (output_bfd, sreloc, &outrel);
710ab287
L		 3898
3899 /* If this reloc is against an external symbol, we
3900 do not want to fiddle with the addend. Otherwise,
3901 we need to include the symbol value so that it
3902 becomes an addend for the dynamic reloc. For an
3903 internal symbol, we have updated addend. */
56b8aada 3904 continue;
710ab287 3905 }
d59a60e9 3906 /* FALLTHROUGH */
cbe950e9
L		 3907 case R_386_PC32:
3908 case R_386_PLT32:
3909 goto do_relocation;
3910
3911 case R_386_GOT32:
02a86693 3912 case R_386_GOT32X:
6de2ae4a 3913 base_got = htab->elf.sgot;
cbe950e9
L		 3914 off = h->got.offset;
3915
7afd84dc 3916 if (base_got == NULL)
cbe950e9
L		 3917 abort ();
3918
7afd84dc 3919 if (off == (bfd_vma) -1)
cbe950e9 3920 {
7afd84dc
L		 3921 /* We can't use h->got.offset here to save state, or
3922 even just remember the offset, as finish_dynamic_symbol
3923 would use that as offset into .got. */
6bbec505 3924
6de2ae4a 3925 if (htab->elf.splt != NULL)
7afd84dc 3926 {
25e762b9 3927 plt_index = h->plt.offset / plt_entry_size - 1;
7afd84dc 3928 off = (plt_index + 3) * 4;
6de2ae4a 3929 base_got = htab->elf.sgotplt;
7afd84dc 3930 }
cbe950e9
L		 3931 else
3932 {
25e762b9 3933 plt_index = h->plt.offset / plt_entry_size;
7afd84dc 3934 off = plt_index * 4;
6de2ae4a 3935 base_got = htab->elf.igotplt;
7afd84dc
L		 3936 }
3937
3938 if (h->dynindx == -1
3939 || h->forced_local
3940 || info->symbolic)
3941 {
3942 /* This references the local defitionion. We must
3943 initialize this entry in the global offset table.
3944 Since the offset must always be a multiple of 8,
3945 we use the least significant bit to record
3946 whether we have initialized it already.
3947
3948 When doing a dynamic link, we create a .rela.got
3949 relocation entry to initialize the value. This
3950 is done in the finish_dynamic_symbol routine. */
3951 if ((off & 1) != 0)
3952 off &= ~1;
3953 else
3954 {
3955 bfd_put_32 (output_bfd, relocation,
3956 base_got->contents + off);
3957 h->got.offset |= 1;
3958 }
cbe950e9 3959 }
cbe950e9 3960
7afd84dc 3961 relocation = off;
cbe950e9 3962
7afd84dc 3963 /* Adjust for static executables. */
6de2ae4a 3964 if (htab->elf.splt == NULL)
7afd84dc
L		 3965 relocation += gotplt->output_offset;
3966 }
3967 else
0018b0a3
L		 3968 {
3969 relocation = (base_got->output_section->vma
3970 + base_got->output_offset + off
3971 - gotplt->output_section->vma
3972 - gotplt->output_offset);
3973 /* Adjust for static executables. */
6de2ae4a 3974 if (htab->elf.splt == NULL)
0018b0a3
L		 3975 relocation += gotplt->output_offset;
3976 }
3977
cbe950e9
L		 3978 goto do_relocation;
3979
3980 case R_386_GOTOFF:
3981 relocation -= (gotplt->output_section->vma
3982 + gotplt->output_offset);
3983 goto do_relocation;
3984 }
3985 }
3986
04ebc307 3987 eh = (struct elf_i386_link_hash_entry *) h;
aec6b87e 3988 resolved_to_zero = (eh != NULL
e62b9723
L		 3989 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info,
3990 eh->has_got_reloc,
3991 eh));
aec6b87e 3992
252b5132
RH		 3993 switch (r_type)
3994 {
02a86693
L		 3995 case R_386_GOT32X:
3996 /* Avoid optimizing _DYNAMIC since ld.so may use its
3997 link-time address. */
3998 if (h == htab->elf.hdynamic)
3999 goto r_386_got32;
4000
4001 if (bfd_link_pic (info))
4002 {
4003 /* It is OK to convert mov to lea and convert indirect
4004 branch to direct branch. It is OK to convert adc,
4005 add, and, cmp, or, sbb, sub, test, xor only when PIC
4006 is false. */
02e2aef8
L		 4007 unsigned int opcode, addend;
4008 addend = bfd_get_32 (input_bfd, contents + rel->r_offset);
4009 if (addend != 0)
4010 goto r_386_got32;
4011 opcode = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
02a86693
L		 4012 if (opcode != 0x8b && opcode != 0xff)
4013 goto r_386_got32;
4014 }
4015
4016 /* Resolve "mov GOT[(%reg)], %reg",
4017 "call/jmp *GOT[(%reg)]", "test %reg, foo@GOT[(%reg)]"
4018 and "binop foo@GOT[(%reg)], %reg". */
4019 if (h == NULL
4020 || (h->plt.offset == (bfd_vma) -1
4021 && h->got.offset == (bfd_vma) -1)
4022 || htab->elf.sgotplt == NULL)
4023 abort ();
4024
4025 offplt = (htab->elf.sgotplt->output_section->vma
4026 + htab->elf.sgotplt->output_offset);
4027
4028 /* It is relative to .got.plt section. */
4029 if (h->got.offset != (bfd_vma) -1)
32875eb1
L		 4030 /* Use GOT entry. Mask off the least significant bit in
4031 GOT offset which may be set by R_386_GOT32 processing
4032 below. */
02a86693
L		 4033 relocation = (htab->elf.sgot->output_section->vma
4034 + htab->elf.sgot->output_offset
32875eb1 4035 + (h->got.offset & ~1) - offplt);
02a86693
L		 4036 else
4037 /* Use GOTPLT entry. */
4038 relocation = (h->plt.offset / plt_entry_size - 1 + 3) * 4;
4039
4040 if (!bfd_link_pic (info))
4041 {
4042 /* If not PIC, add the .got.plt section address for
a3718e9e 4043 baseless addressing. */
02a86693 4044 unsigned int modrm;
02e2aef8 4045 modrm = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
02a86693
L		 4046 if ((modrm & 0xc7) == 0x5)
4047 relocation += offplt;
4048 }
4049
4050 unresolved_reloc = FALSE;
4051 break;
4052
252b5132 4053 case R_386_GOT32:
02a86693 4054r_386_got32:
252b5132
RH		 4055 /* Relocation is to the entry for this symbol in the global
4056 offset table. */
6de2ae4a 4057 if (htab->elf.sgot == NULL)
ffb2e45b 4058 abort ();
252b5132
RH		 4059
4060 if (h != NULL)
4061 {
b34976b6 4062 bfd_boolean dyn;
252b5132
RH		 4063
4064 off = h->got.offset;
ebe50bae 4065 dyn = htab->elf.dynamic_sections_created;
0e1862bb
L		 4066 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
4067 bfd_link_pic (info),
4068 h)
4069 || (bfd_link_pic (info)
586119b3 4070 && SYMBOL_REFERENCES_LOCAL (info, h))
ef5aade5
L		 4071 || (ELF_ST_VISIBILITY (h->other)
4072 && h->root.type == bfd_link_hash_undefweak))
252b5132
RH		 4073 {
4074 /* This is actually a static link, or it is a
4075 -Bsymbolic link and the symbol is defined
4076 locally, or the symbol was forced to be local
4077 because of a version file. We must initialize
4078 this entry in the global offset table. Since the
4079 offset must always be a multiple of 4, we use the
4080 least significant bit to record whether we have
4081 initialized it already.
4082
4083 When doing a dynamic link, we create a .rel.got
4084 relocation entry to initialize the value. This
4085 is done in the finish_dynamic_symbol routine. */
4086 if ((off & 1) != 0)
4087 off &= ~1;
4088 else
4089 {
4090 bfd_put_32 (output_bfd, relocation,
6de2ae4a 4091 htab->elf.sgot->contents + off);
252b5132
RH		 4092 h->got.offset |= 1;
4093 }
4094 }
8c694914 4095 else
b34976b6 4096 unresolved_reloc = FALSE;
252b5132
RH		 4097 }
4098 else
4099 {
ffb2e45b
AM		 4100 if (local_got_offsets == NULL)
4101 abort ();
252b5132
RH		 4102
4103 off = local_got_offsets[r_symndx];
4104
4105 /* The offset must always be a multiple of 4. We use
83be169b
AM		 4106 the least significant bit to record whether we have
4107 already generated the necessary reloc. */
252b5132
RH		 4108 if ((off & 1) != 0)
4109 off &= ~1;
4110 else
4111 {
6725bdbf 4112 bfd_put_32 (output_bfd, relocation,
6de2ae4a 4113 htab->elf.sgot->contents + off);
252b5132 4114
0e1862bb 4115 if (bfd_link_pic (info))
252b5132 4116 {
947216bf
AM		 4117 asection *s;
4118 Elf_Internal_Rela outrel;
252b5132 4119
6de2ae4a 4120 s = htab->elf.srelgot;
947216bf 4121 if (s == NULL)
ffb2e45b 4122 abort ();
252b5132 4123
6de2ae4a
L		 4124 outrel.r_offset = (htab->elf.sgot->output_section->vma
4125 + htab->elf.sgot->output_offset
252b5132
RH		 4126 + off);
4127 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
59d6ffb2 4128 elf_append_rel (output_bfd, s, &outrel);
252b5132
RH		 4129 }
4130
4131 local_got_offsets[r_symndx] |= 1;
4132 }
252b5132
RH		 4133 }
4134
ffb2e45b
AM		 4135 if (off >= (bfd_vma) -2)
4136 abort ();
4137
6de2ae4a
L		 4138 relocation = htab->elf.sgot->output_section->vma
4139 + htab->elf.sgot->output_offset + off
4140 - htab->elf.sgotplt->output_section->vma
4141 - htab->elf.sgotplt->output_offset;
252b5132
RH		 4142 break;
4143
4144 case R_386_GOTOFF:
4145 /* Relocation is relative to the start of the global offset
4146 table. */
4147
3d949995
L		 4148 /* Check to make sure it isn't a protected function or data
4149 symbol for shared library since it may not be local when
4150 used as function address or with copy relocation. We also
e3c0e327 4151 need to make sure that a symbol is referenced locally. */
0e1862bb 4152 if (!bfd_link_executable (info) && h)
90f487df 4153 {
41bed6dd
L		 4154 if (!h->def_regular)
4155 {
4156 const char *v;
4157
4158 switch (ELF_ST_VISIBILITY (h->other))
4159 {
4160 case STV_HIDDEN:
4161 v = _("hidden symbol");
4162 break;
4163 case STV_INTERNAL:
4164 v = _("internal symbol");
4165 break;
4166 case STV_PROTECTED:
4167 v = _("protected symbol");
4168 break;
4169 default:
4170 v = _("symbol");
4171 break;
4172 }
4173
4174 (*_bfd_error_handler)
4175 (_("%B: relocation R_386_GOTOFF against undefined %s `%s' can not be used when making a shared object"),
4176 input_bfd, v, h->root.root.string);
4177 bfd_set_error (bfd_error_bad_value);
4178 return FALSE;
4179 }
d5597ebc 4180 else if (!SYMBOL_REFERENCES_LOCAL (info, h)
3d949995
L		 4181 && (h->type == STT_FUNC
4182 || h->type == STT_OBJECT)
41bed6dd
L		 4183 && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
4184 {
4185 (*_bfd_error_handler)
3d949995
L		 4186 (_("%B: relocation R_386_GOTOFF against protected %s `%s' can not be used when making a shared object"),
4187 input_bfd,
4188 h->type == STT_FUNC ? "function" : "data",
4189 h->root.root.string);
41bed6dd
L		 4190 bfd_set_error (bfd_error_bad_value);
4191 return FALSE;
4192 }
90f487df
L		 4193 }
4194
8c37241b
JJ		 4195 /* Note that sgot is not involved in this
4196 calculation. We always want the start of .got.plt. If we
4197 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
252b5132
RH		 4198 permitted by the ABI, we might have to change this
4199 calculation. */
6de2ae4a
L		 4200 relocation -= htab->elf.sgotplt->output_section->vma
4201 + htab->elf.sgotplt->output_offset;
252b5132
RH		 4202 break;
4203
4204 case R_386_GOTPC:
4205 /* Use global offset table as symbol value. */
6de2ae4a
L		 4206 relocation = htab->elf.sgotplt->output_section->vma
4207 + htab->elf.sgotplt->output_offset;
b34976b6 4208 unresolved_reloc = FALSE;
252b5132
RH		 4209 break;
4210
4211 case R_386_PLT32:
4212 /* Relocation is to the entry for this symbol in the
4213 procedure linkage table. */
4214
dd5724d5 4215 /* Resolve a PLT32 reloc against a local symbol directly,
83be169b 4216 without using the procedure linkage table. */
252b5132
RH		 4217 if (h == NULL)
4218 break;
4219
dd7e64d4
L		 4220 if ((h->plt.offset == (bfd_vma) -1
4221 && eh->plt_got.offset == (bfd_vma) -1)
6de2ae4a 4222 || htab->elf.splt == NULL)
252b5132
RH		 4223 {
4224 /* We didn't make a PLT entry for this symbol. This
83be169b
AM		 4225 happens when statically linking PIC code, or when
4226 using -Bsymbolic. */
252b5132
RH		 4227 break;
4228 }
4229
dd7e64d4
L		 4230 if (h->plt.offset != (bfd_vma) -1)
4231 {
4232 resolved_plt = htab->elf.splt;
4233 plt_offset = h->plt.offset;
4234 }
4235 else
4236 {
4237 resolved_plt = htab->plt_got;
4238 plt_offset = eh->plt_got.offset;
4239 }
4240
4241 relocation = (resolved_plt->output_section->vma
4242 + resolved_plt->output_offset
4243 + plt_offset);
b34976b6 4244 unresolved_reloc = FALSE;
252b5132
RH		 4245 break;
4246
1788fc08 4247 case R_386_SIZE32:
1788fc08
L		 4248 /* Set to symbol size. */
4249 relocation = st_size;
4250 /* Fall through. */
4251
252b5132
RH		 4252 case R_386_32:
4253 case R_386_PC32:
3348747a
NS		 4254 if ((input_section->flags & SEC_ALLOC) == 0
4255 || is_vxworks_tls)
ec338859
AM		 4256 break;
4257
aec6b87e
L		 4258 /* Copy dynamic function pointer relocations. Don't generate
4259 dynamic relocations against resolved undefined weak symbols
4260 in PIE, except for R_386_PC32. */
0e1862bb 4261 if ((bfd_link_pic (info)
ef5aade5 4262 && (h == NULL
aec6b87e
L		 4263 || ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
4264 && (!resolved_to_zero
4265 || r_type == R_386_PC32))
4266 || h->root.type != bfd_link_hash_undefweak))
1788fc08 4267 && ((r_type != R_386_PC32 && r_type != R_386_SIZE32)
f6c52c13 4268 || !SYMBOL_CALLS_LOCAL (info, h)))
a23b6845 4269 || (ELIMINATE_COPY_RELOCS
0e1862bb 4270 && !bfd_link_pic (info)
12d0ee4a
AM		 4271 && h != NULL
4272 && h->dynindx != -1
aec6b87e
L		 4273 && (!h->non_got_ref
4274 || eh->func_pointer_refcount > 0
4275 || (h->root.type == bfd_link_hash_undefweak
4276 && !resolved_to_zero))
bae420ef
L		 4277 && ((h->def_dynamic && !h->def_regular)
4278 /* Undefined weak symbol is bound locally when
4279 PIC is false. */
4280 || h->root.type == bfd_link_hash_undefweak)))
252b5132 4281 {
947216bf 4282 Elf_Internal_Rela outrel;
b34976b6 4283 bfd_boolean skip, relocate;
0c715baa 4284 asection *sreloc;
252b5132
RH		 4285
4286 /* When generating a shared object, these relocations
4287 are copied into the output file to be resolved at run
4288 time. */
4289
b34976b6
AM		 4290 skip = FALSE;
4291 relocate = FALSE;
252b5132 4292
c629eae0
JJ		 4293 outrel.r_offset =
4294 _bfd_elf_section_offset (output_bfd, info, input_section,
4295 rel->r_offset);
4296 if (outrel.r_offset == (bfd_vma) -1)
b34976b6 4297 skip = TRUE;
0bb2d96a 4298 else if (outrel.r_offset == (bfd_vma) -2)
b34976b6 4299 skip = TRUE, relocate = TRUE;
252b5132
RH		 4300 outrel.r_offset += (input_section->output_section->vma
4301 + input_section->output_offset);
4302
4303 if (skip)
0bb2d96a 4304 memset (&outrel, 0, sizeof outrel);
5a15f56f
AM		 4305 else if (h != NULL
4306 && h->dynindx != -1
4307 && (r_type == R_386_PC32
4e0c91e4
L		 4308 || !(bfd_link_executable (info)
4309 || SYMBOLIC_BIND (info, h))
f5385ebf 4310 || !h->def_regular))
0bb2d96a 4311 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
252b5132
RH		 4312 else
4313 {
5a15f56f 4314 /* This symbol is local, or marked to become local. */
b34976b6 4315 relocate = TRUE;
5a15f56f 4316 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
252b5132
RH		 4317 }
4318
cbe950e9 4319 sreloc = elf_section_data (input_section)->sreloc;
e7c33416 4320
62d78908
L		 4321 if (sreloc == NULL || sreloc->contents == NULL)
4322 {
4323 r = bfd_reloc_notsupported;
4324 goto check_relocation_error;
4325 }
0c715baa 4326
59d6ffb2 4327 elf_append_rel (output_bfd, sreloc, &outrel);
252b5132
RH		 4328
4329 /* If this reloc is against an external symbol, we do
4330 not want to fiddle with the addend. Otherwise, we
4331 need to include the symbol value so that it becomes
4332 an addend for the dynamic reloc. */
0f88be7a 4333 if (! relocate)
252b5132
RH		 4334 continue;
4335 }
252b5132
RH		 4336 break;
4337
37e55690 4338 case R_386_TLS_IE:
0e1862bb 4339 if (!bfd_link_executable (info))
37e55690 4340 {
947216bf 4341 Elf_Internal_Rela outrel;
37e55690 4342 asection *sreloc;
37e55690
JJ		 4343
4344 outrel.r_offset = rel->r_offset
4345 + input_section->output_section->vma
4346 + input_section->output_offset;
4347 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
4348 sreloc = elf_section_data (input_section)->sreloc;
4349 if (sreloc == NULL)
4350 abort ();
59d6ffb2 4351 elf_append_rel (output_bfd, sreloc, &outrel);
37e55690
JJ		 4352 }
4353 /* Fall through */
4354
13ae64f3 4355 case R_386_TLS_GD:
67a4f2b7
AO		 4356 case R_386_TLS_GOTDESC:
4357 case R_386_TLS_DESC_CALL:
13ae64f3 4358 case R_386_TLS_IE_32:
37e55690 4359 case R_386_TLS_GOTIE:
13ae64f3
JJ		 4360 tls_type = GOT_UNKNOWN;
4361 if (h == NULL && local_got_offsets)
4362 tls_type = elf_i386_local_got_tls_type (input_bfd) [r_symndx];
4363 else if (h != NULL)
142411ca 4364 tls_type = elf_i386_hash_entry(h)->tls_type;
37e55690
JJ		 4365 if (tls_type == GOT_TLS_IE)
4366 tls_type = GOT_TLS_IE_NEG;
142411ca
L		 4367
4368 if (! elf_i386_tls_transition (info, input_bfd,
4369 input_section, contents,
4370 symtab_hdr, sym_hashes,
4371 &r_type, tls_type, rel,
bedfd056 4372 relend, h, r_symndx, TRUE))
142411ca 4373 return FALSE;
13ae64f3
JJ		 4374
4375 if (r_type == R_386_TLS_LE_32)
4376 {
82e51918 4377 BFD_ASSERT (! unresolved_reloc);
13ae64f3
JJ		 4378 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
4379 {
142411ca 4380 unsigned int type;
13ae64f3
JJ		 4381 bfd_vma roff;
4382
4383 /* GD->LE transition. */
13ae64f3 4384 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
13ae64f3
JJ		 4385 if (type == 0x04)
4386 {
4387 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
4388 Change it into:
4389 movl %gs:0, %eax; subl $foo@tpoff, %eax
4390 (6 byte form of subl). */
13ae64f3
JJ		 4391 memcpy (contents + rel->r_offset - 3,
4392 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
142411ca 4393 roff = rel->r_offset + 5;
13ae64f3
JJ		 4394 }
4395 else
4396 {
142411ca
L		 4397 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
4398 Change it into:
4399 movl %gs:0, %eax; subl $foo@tpoff, %eax
4400 (6 byte form of subl). */
4401 memcpy (contents + rel->r_offset - 2,
4402 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
4403 roff = rel->r_offset + 6;
13ae64f3 4404 }
eb4ff4d6 4405 bfd_put_32 (output_bfd, elf_i386_tpoff (info, relocation),
13ae64f3 4406 contents + roff);
a3fadc9a 4407 /* Skip R_386_PC32/R_386_PLT32. */
13ae64f3 4408 rel++;
60f2e42e 4409 wrel++;
13ae64f3
JJ		 4410 continue;
4411 }
67a4f2b7
AO		 4412 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
4413 {
4414 /* GDesc -> LE transition.
4415 It's originally something like:
4416 leal x@tlsdesc(%ebx), %eax
4417
4418 leal x@ntpoff, %eax
4419
4420 Registers other than %eax may be set up here. */
4421
142411ca 4422 unsigned int val;
67a4f2b7
AO		 4423 bfd_vma roff;
4424
67a4f2b7 4425 roff = rel->r_offset;
67a4f2b7 4426 val = bfd_get_8 (input_bfd, contents + roff - 1);
67a4f2b7
AO		 4427
4428 /* Now modify the instruction as appropriate. */
4429 /* aoliva FIXME: remove the above and xor the byte
4430 below with 0x86. */
4431 bfd_put_8 (output_bfd, val ^ 0x86,
4432 contents + roff - 1);
eb4ff4d6 4433 bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
67a4f2b7
AO		 4434 contents + roff);
4435 continue;
4436 }
4437 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
4438 {
4439 /* GDesc -> LE transition.
4440 It's originally:
4441 call *(%eax)
4442 Turn it into:
142411ca 4443 xchg %ax,%ax */
67a4f2b7 4444
67a4f2b7 4445 bfd_vma roff;
6bbec505 4446
67a4f2b7 4447 roff = rel->r_offset;
10efb593 4448 bfd_put_8 (output_bfd, 0x66, contents + roff);
67a4f2b7
AO		 4449 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4450 continue;
4451 }
37e55690 4452 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_IE)
13ae64f3 4453 {
142411ca 4454 unsigned int val;
13ae64f3
JJ		 4455
4456 /* IE->LE transition:
37e55690
JJ		 4457 Originally it can be one of:
4458 movl foo, %eax
4459 movl foo, %reg
4460 addl foo, %reg
4461 We change it into:
4462 movl $foo, %eax
4463 movl $foo, %reg
4464 addl $foo, %reg. */
37e55690 4465 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
37e55690
JJ		 4466 if (val == 0xa1)
4467 {
4468 /* movl foo, %eax. */
55fd94b0
AM		 4469 bfd_put_8 (output_bfd, 0xb8,
4470 contents + rel->r_offset - 1);
37e55690 4471 }
299bf759 4472 else
37e55690 4473 {
142411ca
L		 4474 unsigned int type;
4475
55fd94b0
AM		 4476 type = bfd_get_8 (input_bfd,
4477 contents + rel->r_offset - 2);
299bf759 4478 switch (type)
26e41594 4479 {
299bf759
L		 4480 case 0x8b:
4481 /* movl */
299bf759
L		 4482 bfd_put_8 (output_bfd, 0xc7,
4483 contents + rel->r_offset - 2);
4484 bfd_put_8 (output_bfd,
4485 0xc0 | ((val >> 3) & 7),
4486 contents + rel->r_offset - 1);
4487 break;
4488 case 0x03:
4489 /* addl */
299bf759
L		 4490 bfd_put_8 (output_bfd, 0x81,
4491 contents + rel->r_offset - 2);
4492 bfd_put_8 (output_bfd,
4493 0xc0 | ((val >> 3) & 7),
4494 contents + rel->r_offset - 1);
4495 break;
4496 default:
4497 BFD_FAIL ();
4498 break;
26e41594 4499 }
37e55690 4500 }
eb4ff4d6 4501 bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
37e55690
JJ		 4502 contents + rel->r_offset);
4503 continue;
4504 }
4505 else
4506 {
4507 unsigned int val, type;
4508
4509 /* {IE_32,GOTIE}->LE transition:
4510 Originally it can be one of:
13ae64f3 4511 subl foo(%reg1), %reg2
13ae64f3 4512 movl foo(%reg1), %reg2
37e55690 4513 addl foo(%reg1), %reg2
13ae64f3
JJ		 4514 We change it into:
4515 subl $foo, %reg2
37e55690
JJ		 4516 movl $foo, %reg2 (6 byte form)
4517 addl $foo, %reg2. */
13ae64f3
JJ		 4518 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
4519 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
13ae64f3
JJ		 4520 if (type == 0x8b)
4521 {
4522 /* movl */
13ae64f3
JJ		 4523 bfd_put_8 (output_bfd, 0xc7,
4524 contents + rel->r_offset - 2);
4525 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
4526 contents + rel->r_offset - 1);
4527 }
4528 else if (type == 0x2b)
4529 {
4530 /* subl */
13ae64f3
JJ		 4531 bfd_put_8 (output_bfd, 0x81,
4532 contents + rel->r_offset - 2);
4533 bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
4534 contents + rel->r_offset - 1);
4535 }
37e55690
JJ		 4536 else if (type == 0x03)
4537 {
4538 /* addl */
4539 bfd_put_8 (output_bfd, 0x81,
4540 contents + rel->r_offset - 2);
4541 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
4542 contents + rel->r_offset - 1);
4543 }
13ae64f3
JJ		 4544 else
4545 BFD_FAIL ();
37e55690 4546 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTIE)
eb4ff4d6 4547 bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
37e55690
JJ		 4548 contents + rel->r_offset);
4549 else
eb4ff4d6 4550 bfd_put_32 (output_bfd, elf_i386_tpoff (info, relocation),
37e55690 4551 contents + rel->r_offset);
13ae64f3
JJ		 4552 continue;
4553 }
4554 }
4555
6de2ae4a 4556 if (htab->elf.sgot == NULL)
13ae64f3
JJ		 4557 abort ();
4558
4559 if (h != NULL)
67a4f2b7
AO		 4560 {
4561 off = h->got.offset;
4562 offplt = elf_i386_hash_entry (h)->tlsdesc_got;
4563 }
13ae64f3
JJ		 4564 else
4565 {
4566 if (local_got_offsets == NULL)
4567 abort ();
4568
4569 off = local_got_offsets[r_symndx];
67a4f2b7 4570 offplt = local_tlsdesc_gotents[r_symndx];
13ae64f3
JJ		 4571 }
4572
4573 if ((off & 1) != 0)
4574 off &= ~1;
26e41594 4575 else
13ae64f3 4576 {
947216bf 4577 Elf_Internal_Rela outrel;
91d6fa6a 4578 int dr_type;
67a4f2b7 4579 asection *sreloc;
13ae64f3 4580
6de2ae4a 4581 if (htab->elf.srelgot == NULL)
13ae64f3
JJ		 4582 abort ();
4583
67a4f2b7
AO		 4584 indx = h && h->dynindx != -1 ? h->dynindx : 0;
4585
4586 if (GOT_TLS_GDESC_P (tls_type))
4587 {
59d6ffb2 4588 bfd_byte *loc;
67a4f2b7
AO		 4589 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_DESC);
4590 BFD_ASSERT (htab->sgotplt_jump_table_size + offplt + 8
6de2ae4a
L		 4591 <= htab->elf.sgotplt->size);
4592 outrel.r_offset = (htab->elf.sgotplt->output_section->vma
4593 + htab->elf.sgotplt->output_offset
67a4f2b7
AO		 4594 + offplt
4595 + htab->sgotplt_jump_table_size);
6de2ae4a 4596 sreloc = htab->elf.srelplt;
67a4f2b7 4597 loc = sreloc->contents;
5ae0bfb6
RS		 4598 loc += (htab->next_tls_desc_index++
4599 * sizeof (Elf32_External_Rel));
67a4f2b7 4600 BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
c3b02097 4601 <= sreloc->contents + sreloc->size);
67a4f2b7
AO		 4602 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
4603 if (indx == 0)
4604 {
4605 BFD_ASSERT (! unresolved_reloc);
4606 bfd_put_32 (output_bfd,
eb4ff4d6 4607 relocation - elf_i386_dtpoff_base (info),
6de2ae4a 4608 htab->elf.sgotplt->contents + offplt
67a4f2b7
AO		 4609 + htab->sgotplt_jump_table_size + 4);
4610 }
4611 else
4612 {
4613 bfd_put_32 (output_bfd, 0,
6de2ae4a 4614 htab->elf.sgotplt->contents + offplt
67a4f2b7
AO		 4615 + htab->sgotplt_jump_table_size + 4);
4616 }
4617 }
4618
6de2ae4a 4619 sreloc = htab->elf.srelgot;
67a4f2b7 4620
6de2ae4a
L		 4621 outrel.r_offset = (htab->elf.sgot->output_section->vma
4622 + htab->elf.sgot->output_offset + off);
13ae64f3 4623
67a4f2b7 4624 if (GOT_TLS_GD_P (tls_type))
13ae64f3 4625 dr_type = R_386_TLS_DTPMOD32;
67a4f2b7
AO		 4626 else if (GOT_TLS_GDESC_P (tls_type))
4627 goto dr_done;
37e55690
JJ		 4628 else if (tls_type == GOT_TLS_IE_POS)
4629 dr_type = R_386_TLS_TPOFF;
13ae64f3
JJ		 4630 else
4631 dr_type = R_386_TLS_TPOFF32;
67a4f2b7 4632
37e55690 4633 if (dr_type == R_386_TLS_TPOFF && indx == 0)
eb4ff4d6
L		 4634 bfd_put_32 (output_bfd,
4635 relocation - elf_i386_dtpoff_base (info),
6de2ae4a 4636 htab->elf.sgot->contents + off);
37e55690 4637 else if (dr_type == R_386_TLS_TPOFF32 && indx == 0)
23209a78 4638 bfd_put_32 (output_bfd,
eb4ff4d6 4639 elf_i386_dtpoff_base (info) - relocation,
6de2ae4a 4640 htab->elf.sgot->contents + off);
67a4f2b7 4641 else if (dr_type != R_386_TLS_DESC)
c366c25e 4642 bfd_put_32 (output_bfd, 0,
6de2ae4a 4643 htab->elf.sgot->contents + off);
13ae64f3 4644 outrel.r_info = ELF32_R_INFO (indx, dr_type);
67a4f2b7 4645
59d6ffb2 4646 elf_append_rel (output_bfd, sreloc, &outrel);
13ae64f3 4647
67a4f2b7 4648 if (GOT_TLS_GD_P (tls_type))
13ae64f3
JJ		 4649 {
4650 if (indx == 0)
4651 {
82e51918 4652 BFD_ASSERT (! unresolved_reloc);
13ae64f3 4653 bfd_put_32 (output_bfd,
eb4ff4d6 4654 relocation - elf_i386_dtpoff_base (info),
6de2ae4a 4655 htab->elf.sgot->contents + off + 4);
13ae64f3
JJ		 4656 }
4657 else
4658 {
4659 bfd_put_32 (output_bfd, 0,
6de2ae4a 4660 htab->elf.sgot->contents + off + 4);
13ae64f3
JJ		 4661 outrel.r_info = ELF32_R_INFO (indx,
4662 R_386_TLS_DTPOFF32);
4663 outrel.r_offset += 4;
59d6ffb2 4664 elf_append_rel (output_bfd, sreloc, &outrel);
13ae64f3
JJ		 4665 }
4666 }
37e55690
JJ		 4667 else if (tls_type == GOT_TLS_IE_BOTH)
4668 {
4669 bfd_put_32 (output_bfd,
eb4ff4d6
L		 4670 (indx == 0
4671 ? relocation - elf_i386_dtpoff_base (info)
4672 : 0),
6de2ae4a 4673 htab->elf.sgot->contents + off + 4);
37e55690
JJ		 4674 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
4675 outrel.r_offset += 4;
59d6ffb2 4676 elf_append_rel (output_bfd, sreloc, &outrel);
37e55690 4677 }
13ae64f3 4678
67a4f2b7 4679 dr_done:
13ae64f3
JJ		 4680 if (h != NULL)
4681 h->got.offset |= 1;
4682 else
4683 local_got_offsets[r_symndx] |= 1;
4684 }
4685
67a4f2b7
AO		 4686 if (off >= (bfd_vma) -2
4687 && ! GOT_TLS_GDESC_P (tls_type))
13ae64f3 4688 abort ();
67a4f2b7
AO		 4689 if (r_type == R_386_TLS_GOTDESC
4690 || r_type == R_386_TLS_DESC_CALL)
4691 {
4692 relocation = htab->sgotplt_jump_table_size + offplt;
4693 unresolved_reloc = FALSE;
4694 }
4695 else if (r_type == ELF32_R_TYPE (rel->r_info))
13ae64f3 4696 {
6de2ae4a
L		 4697 bfd_vma g_o_t = htab->elf.sgotplt->output_section->vma
4698 + htab->elf.sgotplt->output_offset;
4699 relocation = htab->elf.sgot->output_section->vma
4700 + htab->elf.sgot->output_offset + off - g_o_t;
37e55690
JJ		 4701 if ((r_type == R_386_TLS_IE || r_type == R_386_TLS_GOTIE)
4702 && tls_type == GOT_TLS_IE_BOTH)
4703 relocation += 4;
4704 if (r_type == R_386_TLS_IE)
8c37241b 4705 relocation += g_o_t;
b34976b6 4706 unresolved_reloc = FALSE;
13ae64f3 4707 }
67a4f2b7 4708 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
13ae64f3
JJ		 4709 {
4710 unsigned int val, type;
4711 bfd_vma roff;
4712
4713 /* GD->IE transition. */
13ae64f3 4714 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
13ae64f3
JJ		 4715 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
4716 if (type == 0x04)
4717 {
4718 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
4719 Change it into:
4720 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
13ae64f3 4721 val >>= 3;
142411ca 4722 roff = rel->r_offset - 3;
13ae64f3
JJ		 4723 }
4724 else
4725 {
4726 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
4727 Change it into:
4728 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
13ae64f3
JJ		 4729 roff = rel->r_offset - 2;
4730 }
4731 memcpy (contents + roff,
4732 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
4733 contents[roff + 7] = 0x80 | (val & 7);
37e55690
JJ		 4734 /* If foo is used only with foo@gotntpoff(%reg) and
4735 foo@indntpoff, but not with foo@gottpoff(%reg), change
4736 subl $foo@gottpoff(%reg), %eax
4737 into:
4738 addl $foo@gotntpoff(%reg), %eax. */
ebcfb3c0
JJ		 4739 if (tls_type == GOT_TLS_IE_POS)
4740 contents[roff + 6] = 0x03;
8c37241b 4741 bfd_put_32 (output_bfd,
6de2ae4a
L		 4742 htab->elf.sgot->output_section->vma
4743 + htab->elf.sgot->output_offset + off
4744 - htab->elf.sgotplt->output_section->vma
4745 - htab->elf.sgotplt->output_offset,
13ae64f3
JJ		 4746 contents + roff + 8);
4747 /* Skip R_386_PLT32. */
4748 rel++;
60f2e42e 4749 wrel++;
13ae64f3
JJ		 4750 continue;
4751 }
67a4f2b7
AO		 4752 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
4753 {
4754 /* GDesc -> IE transition.
4755 It's originally something like:
4756 leal x@tlsdesc(%ebx), %eax
4757
4758 Change it to:
142411ca 4759 movl x@gotntpoff(%ebx), %eax # before xchg %ax,%ax
67a4f2b7
AO		 4760 or:
4761 movl x@gottpoff(%ebx), %eax # before negl %eax
4762
4763 Registers other than %eax may be set up here. */
4764
67a4f2b7
AO		 4765 bfd_vma roff;
4766
4767 /* First, make sure it's a leal adding ebx to a 32-bit
4768 offset into any register, although it's probably
4769 almost always going to be eax. */
4770 roff = rel->r_offset;
67a4f2b7
AO		 4771
4772 /* Now modify the instruction as appropriate. */
4773 /* To turn a leal into a movl in the form we use it, it
4774 suffices to change the first byte from 0x8d to 0x8b.
4775 aoliva FIXME: should we decide to keep the leal, all
4776 we have to do is remove the statement below, and
4777 adjust the relaxation of R_386_TLS_DESC_CALL. */
4778 bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
4779
4780 if (tls_type == GOT_TLS_IE_BOTH)
4781 off += 4;
4782
4783 bfd_put_32 (output_bfd,
6de2ae4a
L		 4784 htab->elf.sgot->output_section->vma
4785 + htab->elf.sgot->output_offset + off
4786 - htab->elf.sgotplt->output_section->vma
4787 - htab->elf.sgotplt->output_offset,
67a4f2b7
AO		 4788 contents + roff);
4789 continue;
4790 }
4791 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
4792 {
4793 /* GDesc -> IE transition.
4794 It's originally:
4795 call *(%eax)
4796
4797 Change it to:
142411ca 4798 xchg %ax,%ax
67a4f2b7
AO		 4799 or
4800 negl %eax
4801 depending on how we transformed the TLS_GOTDESC above.
4802 */
4803
67a4f2b7
AO		 4804 bfd_vma roff;
4805
67a4f2b7 4806 roff = rel->r_offset;
67a4f2b7
AO		 4807
4808 /* Now modify the instruction as appropriate. */
4809 if (tls_type != GOT_TLS_IE_NEG)
4810 {
10efb593
L		 4811 /* xchg %ax,%ax */
4812 bfd_put_8 (output_bfd, 0x66, contents + roff);
67a4f2b7
AO		 4813 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4814 }
4815 else
4816 {
4817 /* negl %eax */
4818 bfd_put_8 (output_bfd, 0xf7, contents + roff);
4819 bfd_put_8 (output_bfd, 0xd8, contents + roff + 1);
4820 }
4821
4822 continue;
4823 }
4824 else
4825 BFD_ASSERT (FALSE);
13ae64f3
JJ		 4826 break;
4827
4828 case R_386_TLS_LDM:
142411ca
L		 4829 if (! elf_i386_tls_transition (info, input_bfd,
4830 input_section, contents,
4831 symtab_hdr, sym_hashes,
4832 &r_type, GOT_UNKNOWN, rel,
bedfd056 4833 relend, h, r_symndx, TRUE))
142411ca 4834 return FALSE;
13ae64f3 4835
142411ca
L		 4836 if (r_type != R_386_TLS_LDM)
4837 {
13ae64f3 4838 /* LD->LE transition:
13ae64f3
JJ		 4839 leal foo(%reg), %eax; call ___tls_get_addr.
4840 We change it into:
4841 movl %gs:0, %eax; nop; leal 0(%esi,1), %esi. */
142411ca 4842 BFD_ASSERT (r_type == R_386_TLS_LE_32);
13ae64f3
JJ		 4843 memcpy (contents + rel->r_offset - 2,
4844 "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
a3fadc9a 4845 /* Skip R_386_PC32/R_386_PLT32. */
13ae64f3 4846 rel++;
60f2e42e 4847 wrel++;
13ae64f3
JJ		 4848 continue;
4849 }
4850
6de2ae4a 4851 if (htab->elf.sgot == NULL)
13ae64f3
JJ		 4852 abort ();
4853
4854 off = htab->tls_ldm_got.offset;
4855 if (off & 1)
4856 off &= ~1;
4857 else
4858 {
947216bf 4859 Elf_Internal_Rela outrel;
13ae64f3 4860
6de2ae4a 4861 if (htab->elf.srelgot == NULL)
13ae64f3
JJ		 4862 abort ();
4863
6de2ae4a
L		 4864 outrel.r_offset = (htab->elf.sgot->output_section->vma
4865 + htab->elf.sgot->output_offset + off);
13ae64f3
JJ		 4866
4867 bfd_put_32 (output_bfd, 0,
6de2ae4a 4868 htab->elf.sgot->contents + off);
13ae64f3 4869 bfd_put_32 (output_bfd, 0,
6de2ae4a 4870 htab->elf.sgot->contents + off + 4);
13ae64f3 4871 outrel.r_info = ELF32_R_INFO (0, R_386_TLS_DTPMOD32);
59d6ffb2 4872 elf_append_rel (output_bfd, htab->elf.srelgot, &outrel);
13ae64f3
JJ		 4873 htab->tls_ldm_got.offset |= 1;
4874 }
6de2ae4a
L		 4875 relocation = htab->elf.sgot->output_section->vma
4876 + htab->elf.sgot->output_offset + off
4877 - htab->elf.sgotplt->output_section->vma
4878 - htab->elf.sgotplt->output_offset;
b34976b6 4879 unresolved_reloc = FALSE;
13ae64f3
JJ		 4880 break;
4881
4882 case R_386_TLS_LDO_32:
0e1862bb
L		 4883 if (!bfd_link_executable (info)
4884 || (input_section->flags & SEC_CODE) == 0)
eb4ff4d6 4885 relocation -= elf_i386_dtpoff_base (info);
13ae64f3
JJ		 4886 else
4887 /* When converting LDO to LE, we must negate. */
eb4ff4d6 4888 relocation = -elf_i386_tpoff (info, relocation);
13ae64f3
JJ		 4889 break;
4890
4891 case R_386_TLS_LE_32:
13ae64f3 4892 case R_386_TLS_LE:
0e1862bb 4893 if (!bfd_link_executable (info))
37e55690 4894 {
947216bf 4895 Elf_Internal_Rela outrel;
37e55690 4896 asection *sreloc;
37e55690
JJ		 4897
4898 outrel.r_offset = rel->r_offset
4899 + input_section->output_section->vma
4900 + input_section->output_offset;
4901 if (h != NULL && h->dynindx != -1)
4902 indx = h->dynindx;
4903 else
4904 indx = 0;
4905 if (r_type == R_386_TLS_LE_32)
4906 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF32);
4907 else
4908 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
4909 sreloc = elf_section_data (input_section)->sreloc;
4910 if (sreloc == NULL)
4911 abort ();
59d6ffb2 4912 elf_append_rel (output_bfd, sreloc, &outrel);
37e55690
JJ		 4913 if (indx)
4914 continue;
4915 else if (r_type == R_386_TLS_LE_32)
eb4ff4d6 4916 relocation = elf_i386_dtpoff_base (info) - relocation;
37e55690 4917 else
eb4ff4d6 4918 relocation -= elf_i386_dtpoff_base (info);
37e55690
JJ		 4919 }
4920 else if (r_type == R_386_TLS_LE_32)
eb4ff4d6 4921 relocation = elf_i386_tpoff (info, relocation);
37e55690 4922 else
eb4ff4d6 4923 relocation = -elf_i386_tpoff (info, relocation);
13ae64f3
JJ		 4924 break;
4925
252b5132
RH		 4926 default:
4927 break;
4928 }
4929
239e1f3a
AM		 4930 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4931 because such sections are not SEC_ALLOC and thus ld.so will
4932 not process them. */
8c694914 4933 if (unresolved_reloc
239e1f3a 4934 && !((input_section->flags & SEC_DEBUGGING) != 0
1d5316ab
AM		 4935 && h->def_dynamic)
4936 && _bfd_elf_section_offset (output_bfd, info, input_section,
4937 rel->r_offset) != (bfd_vma) -1)
6a30718d
JJ		 4938 {
4939 (*_bfd_error_handler)
843fe662 4940 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
d003868e
AM		 4941 input_bfd,
4942 input_section,
6a30718d 4943 (long) rel->r_offset,
843fe662 4944 howto->name,
6a30718d 4945 h->root.root.string);
b34976b6 4946 return FALSE;
6a30718d 4947 }
83be169b 4948
cbe950e9 4949do_relocation:
252b5132
RH		 4950 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4951 contents, rel->r_offset,
55fd94b0 4952 relocation, 0);
252b5132 4953
62d78908 4954check_relocation_error:
cf5c0c5b 4955 if (r != bfd_reloc_ok)
252b5132 4956 {
cf5c0c5b 4957 const char *name;
ffb2e45b 4958
cf5c0c5b
AM		 4959 if (h != NULL)
4960 name = h->root.root.string;
4961 else
4962 {
4963 name = bfd_elf_string_from_elf_section (input_bfd,
4964 symtab_hdr->sh_link,
4965 sym->st_name);
4966 if (name == NULL)
b34976b6 4967 return FALSE;
cf5c0c5b
AM		 4968 if (*name == '\0')
4969 name = bfd_section_name (input_bfd, sec);
4970 }
ffb2e45b 4971
cf5c0c5b
AM		 4972 if (r == bfd_reloc_overflow)
4973 {
cf5c0c5b 4974 if (! ((*info->callbacks->reloc_overflow)
dfeffb9f
L		 4975 (info, (h ? &h->root : NULL), name, howto->name,
4976 (bfd_vma) 0, input_bfd, input_section,
4977 rel->r_offset)))
b34976b6 4978 return FALSE;
cf5c0c5b
AM		 4979 }
4980 else
4981 {
4982 (*_bfd_error_handler)
d003868e
AM		 4983 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4984 input_bfd, input_section,
cf5c0c5b 4985 (long) rel->r_offset, name, (int) r);
b34976b6 4986 return FALSE;
cf5c0c5b 4987 }
252b5132 4988 }
60f2e42e
L		 4989
4990 if (wrel != rel)
4991 *wrel = *rel;
4992 }
4993
4994 if (wrel != rel)
4995 {
4996 Elf_Internal_Shdr *rel_hdr;
4997 size_t deleted = rel - wrel;
4998
4999 rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
5000 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
5001 if (rel_hdr->sh_size == 0)
5002 {
5003 /* It is too late to remove an empty reloc section. Leave
5004 one NONE reloc.
5005 ??? What is wrong with an empty section??? */
5006 rel_hdr->sh_size = rel_hdr->sh_entsize;
5007 deleted -= 1;
5008 }
5009 rel_hdr = _bfd_elf_single_rel_hdr (input_section);
5010 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
5011 input_section->reloc_count -= deleted;
252b5132
RH		 5012 }
5013
b34976b6 5014 return TRUE;
252b5132
RH		 5015}
5016
5017/* Finish up dynamic symbol handling. We set the contents of various
5018 dynamic sections here. */
5019
b34976b6 5020static bfd_boolean
55fd94b0
AM		 5021elf_i386_finish_dynamic_symbol (bfd *output_bfd,
5022 struct bfd_link_info *info,
5023 struct elf_link_hash_entry *h,
5024 Elf_Internal_Sym *sym)
252b5132 5025{
6725bdbf 5026 struct elf_i386_link_hash_table *htab;
25e762b9
RM		 5027 unsigned plt_entry_size;
5028 const struct elf_i386_backend_data *abed;
dd7e64d4 5029 struct elf_i386_link_hash_entry *eh;
aec6b87e 5030 bfd_boolean local_undefweak;
252b5132 5031
6725bdbf 5032 htab = elf_i386_hash_table (info);
4dfe6ac6
NC		 5033 if (htab == NULL)
5034 return FALSE;
252b5132 5035
25e762b9
RM		 5036 abed = get_elf_i386_backend_data (output_bfd);
5037 plt_entry_size = GET_PLT_ENTRY_SIZE (output_bfd);
5038
dd7e64d4
L		 5039 eh = (struct elf_i386_link_hash_entry *) h;
5040
aec6b87e
L		 5041 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
5042 resolved undefined weak symbols in executable so that their
5043 references have value 0 at run-time. */
e62b9723
L		 5044 local_undefweak = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info,
5045 eh->has_got_reloc,
5046 eh);
aec6b87e 5047
252b5132
RH		 5048 if (h->plt.offset != (bfd_vma) -1)
5049 {
252b5132
RH		 5050 bfd_vma plt_index;
5051 bfd_vma got_offset;
947216bf
AM		 5052 Elf_Internal_Rela rel;
5053 bfd_byte *loc;
cbe950e9
L		 5054 asection *plt, *gotplt, *relplt;
5055
5056 /* When building a static executable, use .iplt, .igot.plt and
5057 .rel.iplt sections for STT_GNU_IFUNC symbols. */
6de2ae4a 5058 if (htab->elf.splt != NULL)
cbe950e9 5059 {
6de2ae4a
L		 5060 plt = htab->elf.splt;
5061 gotplt = htab->elf.sgotplt;
5062 relplt = htab->elf.srelplt;
cbe950e9
L		 5063 }
5064 else
5065 {
6de2ae4a
L		 5066 plt = htab->elf.iplt;
5067 gotplt = htab->elf.igotplt;
5068 relplt = htab->elf.irelplt;
cbe950e9 5069 }
252b5132
RH		 5070
5071 /* This symbol has an entry in the procedure linkage table. Set
5072 it up. */
5073
cbe950e9 5074 if ((h->dynindx == -1
aec6b87e 5075 && !local_undefweak
0e1862bb 5076 && !((h->forced_local || bfd_link_executable (info))
cbe950e9
L		 5077 && h->def_regular
5078 && h->type == STT_GNU_IFUNC))
5079 || plt == NULL
5080 || gotplt == NULL
5081 || relplt == NULL)
cec7f46a 5082 abort ();
252b5132
RH		 5083
5084 /* Get the index in the procedure linkage table which
5085 corresponds to this symbol. This is the index of this symbol
5086 in all the symbols for which we are making plt entries. The
cbe950e9 5087 first entry in the procedure linkage table is reserved.
252b5132 5088
cbe950e9 5089 Get the offset into the .got table of the entry that
252b5132 5090 corresponds to this function. Each .got entry is 4 bytes.
cbe950e9 5091 The first three are reserved.
6bbec505 5092
cbe950e9
L		 5093 For static executables, we don't reserve anything. */
5094
6de2ae4a 5095 if (plt == htab->elf.splt)
cbe950e9 5096 {
e1f98742
L		 5097 got_offset = h->plt.offset / plt_entry_size - 1;
5098 got_offset = (got_offset + 3) * 4;
cbe950e9
L		 5099 }
5100 else
5101 {
e1f98742
L		 5102 got_offset = h->plt.offset / plt_entry_size;
5103 got_offset = got_offset * 4;
cbe950e9 5104 }
252b5132
RH		 5105
5106 /* Fill in the entry in the procedure linkage table. */
0e1862bb 5107 if (! bfd_link_pic (info))
252b5132 5108 {
25e762b9
RM		 5109 memcpy (plt->contents + h->plt.offset, abed->plt->plt_entry,
5110 abed->plt->plt_entry_size);
252b5132 5111 bfd_put_32 (output_bfd,
cbe950e9
L		 5112 (gotplt->output_section->vma
5113 + gotplt->output_offset
252b5132 5114 + got_offset),
25e762b9
RM		 5115 plt->contents + h->plt.offset
5116 + abed->plt->plt_got_offset);
eac338cf 5117
25e762b9 5118 if (abed->is_vxworks)
eac338cf
PB		 5119 {
5120 int s, k, reloc_index;
5121
5122 /* Create the R_386_32 relocation referencing the GOT
5123 for this PLT entry. */
5124
5125 /* S: Current slot number (zero-based). */
25e762b9
RM		 5126 s = ((h->plt.offset - abed->plt->plt_entry_size)
5127 / abed->plt->plt_entry_size);
eac338cf 5128 /* K: Number of relocations for PLTResolve. */
0e1862bb 5129 if (bfd_link_pic (info))
eac338cf
PB		 5130 k = PLTRESOLVE_RELOCS_SHLIB;
5131 else
5132 k = PLTRESOLVE_RELOCS;
5133 /* Skip the PLTresolve relocations, and the relocations for
5134 the other PLT slots. */
5135 reloc_index = k + s * PLT_NON_JUMP_SLOT_RELOCS;
5136 loc = (htab->srelplt2->contents + reloc_index
5137 * sizeof (Elf32_External_Rel));
5138
6de2ae4a
L		 5139 rel.r_offset = (htab->elf.splt->output_section->vma
5140 + htab->elf.splt->output_offset
eac338cf 5141 + h->plt.offset + 2),
7325306f 5142 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
eac338cf
PB		 5143 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
5144
5145 /* Create the R_386_32 relocation referencing the beginning of
5146 the PLT for this GOT entry. */
6de2ae4a
L		 5147 rel.r_offset = (htab->elf.sgotplt->output_section->vma
5148 + htab->elf.sgotplt->output_offset
eac338cf 5149 + got_offset);
7325306f 5150 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
eac338cf 5151 bfd_elf32_swap_reloc_out (output_bfd, &rel,
13ca3149 5152 loc + sizeof (Elf32_External_Rel));
eac338cf 5153 }
252b5132
RH		 5154 }
5155 else
5156 {
25e762b9
RM		 5157 memcpy (plt->contents + h->plt.offset, abed->plt->pic_plt_entry,
5158 abed->plt->plt_entry_size);
252b5132 5159 bfd_put_32 (output_bfd, got_offset,
25e762b9
RM		 5160 plt->contents + h->plt.offset
5161 + abed->plt->plt_got_offset);
252b5132
RH		 5162 }
5163
aec6b87e
L		 5164 /* Fill in the entry in the global offset table. Leave the entry
5165 as zero for undefined weak symbol in PIE. No PLT relocation
5166 against undefined weak symbol in PIE. */
5167 if (!local_undefweak)
cbe950e9 5168 {
cbe950e9 5169 bfd_put_32 (output_bfd,
aec6b87e
L		 5170 (plt->output_section->vma
5171 + plt->output_offset
5172 + h->plt.offset
5173 + abed->plt->plt_lazy_offset),
cbe950e9 5174 gotplt->contents + got_offset);
252b5132 5175
aec6b87e
L		 5176 /* Fill in the entry in the .rel.plt section. */
5177 rel.r_offset = (gotplt->output_section->vma
5178 + gotplt->output_offset
5179 + got_offset);
5180 if (h->dynindx == -1
5181 || ((bfd_link_executable (info)
5182 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
5183 && h->def_regular
5184 && h->type == STT_GNU_IFUNC))
5185 {
5186 /* If an STT_GNU_IFUNC symbol is locally defined, generate
5187 R_386_IRELATIVE instead of R_386_JUMP_SLOT. Store addend
5188 in the .got.plt section. */
5189 bfd_put_32 (output_bfd,
5190 (h->root.u.def.value
5191 + h->root.u.def.section->output_section->vma
5192 + h->root.u.def.section->output_offset),
5193 gotplt->contents + got_offset);
5194 rel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
5195 /* R_386_IRELATIVE comes last. */
5196 plt_index = htab->next_irelative_index--;
5197 }
5198 else
5199 {
5200 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
5201 plt_index = htab->next_jump_slot_index++;
5202 }
5203
5204 loc = relplt->contents + plt_index * sizeof (Elf32_External_Rel);
5205 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
5206
5207 /* Don't fill PLT entry for static executables. */
5208 if (plt == htab->elf.splt)
5209 {
5210 bfd_put_32 (output_bfd,
5211 plt_index * sizeof (Elf32_External_Rel),
5212 plt->contents + h->plt.offset
5213 + abed->plt->plt_reloc_offset);
5214 bfd_put_32 (output_bfd, - (h->plt.offset
5215 + abed->plt->plt_plt_offset + 4),
5216 plt->contents + h->plt.offset
5217 + abed->plt->plt_plt_offset);
5218 }
e1f98742 5219 }
dd7e64d4
L		 5220 }
5221 else if (eh->plt_got.offset != (bfd_vma) -1)
5222 {
5223 bfd_vma got_offset, plt_offset;
5224 asection *plt, *got, *gotplt;
5225 const bfd_byte *got_plt_entry;
5226
5227 /* Offset of displacement of the indirect jump. */
5228 bfd_vma plt_got_offset = 2;
e1f98742 5229
dd7e64d4
L		 5230 /* Set the entry in the GOT procedure linkage table. */
5231 plt = htab->plt_got;
5232 got = htab->elf.sgot;
5233 gotplt = htab->elf.sgotplt;
5234 got_offset = h->got.offset;
5235
5236 if (got_offset == (bfd_vma) -1
5237 || plt == NULL
5238 || got == NULL
5239 || gotplt == NULL)
5240 abort ();
5241
5242 /* Fill in the entry in the GOT procedure linkage table. */
0e1862bb 5243 if (! bfd_link_pic (info))
252b5132 5244 {
dd7e64d4
L		 5245 got_plt_entry = elf_i386_got_plt_entry;
5246 got_offset += got->output_section->vma + got->output_offset;
252b5132 5247 }
dd7e64d4
L		 5248 else
5249 {
5250 got_plt_entry = elf_i386_pic_got_plt_entry;
5251 got_offset += (got->output_section->vma
5252 + got->output_offset
5253 - gotplt->output_section->vma
5254 - gotplt->output_offset);
5255 }
5256
5257 plt_offset = eh->plt_got.offset;
5258 memcpy (plt->contents + plt_offset, got_plt_entry,
5259 sizeof (elf_i386_got_plt_entry));
5260 bfd_put_32 (output_bfd, got_offset,
5261 plt->contents + plt_offset + plt_got_offset);
5262 }
5263
aec6b87e
L		 5264 if (!local_undefweak
5265 && !h->def_regular
dd7e64d4
L		 5266 && (h->plt.offset != (bfd_vma) -1
5267 || eh->plt_got.offset != (bfd_vma) -1))
5268 {
5269 /* Mark the symbol as undefined, rather than as defined in
5270 the .plt section. Leave the value if there were any
5271 relocations where pointer equality matters (this is a clue
5272 for the dynamic linker, to make function pointer
5273 comparisons work between an application and shared
5274 library), otherwise set it to zero. If a function is only
5275 called from a binary, there is no need to slow down
5276 shared libraries because of that. */
5277 sym->st_shndx = SHN_UNDEF;
5278 if (!h->pointer_equality_needed)
5279 sym->st_value = 0;
252b5132
RH		 5280 }
5281
aec6b87e
L		 5282 /* Don't generate dynamic GOT relocation against undefined weak
5283 symbol in executable. */
13ae64f3 5284 if (h->got.offset != (bfd_vma) -1
67a4f2b7 5285 && ! GOT_TLS_GD_ANY_P (elf_i386_hash_entry(h)->tls_type)
aec6b87e
L		 5286 && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE) == 0
5287 && !local_undefweak)
252b5132 5288 {
947216bf 5289 Elf_Internal_Rela rel;
252b5132
RH		 5290
5291 /* This symbol has an entry in the global offset table. Set it
5292 up. */
5293
6de2ae4a 5294 if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
ffb2e45b 5295 abort ();
252b5132 5296
6de2ae4a
L		 5297 rel.r_offset = (htab->elf.sgot->output_section->vma
5298 + htab->elf.sgot->output_offset
dc810e39 5299 + (h->got.offset & ~(bfd_vma) 1));
252b5132 5300
dd5724d5
AM		 5301 /* If this is a static link, or it is a -Bsymbolic link and the
5302 symbol is defined locally or was forced to be local because
5303 of a version file, we just want to emit a RELATIVE reloc.
252b5132
RH		 5304 The entry in the global offset table will already have been
5305 initialized in the relocate_section function. */
710ab287 5306 if (h->def_regular
0018b0a3
L		 5307 && h->type == STT_GNU_IFUNC)
5308 {
0e1862bb 5309 if (bfd_link_pic (info))
710ab287
L		 5310 {
5311 /* Generate R_386_GLOB_DAT. */
5312 goto do_glob_dat;
5313 }
5314 else
5315 {
cd2b2c10
L		 5316 asection *plt;
5317
710ab287
L		 5318 if (!h->pointer_equality_needed)
5319 abort ();
5320
5321 /* For non-shared object, we can't use .got.plt, which
5322 contains the real function addres if we need pointer
5323 equality. We load the GOT entry with the PLT entry. */
cd2b2c10 5324 plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
710ab287
L		 5325 bfd_put_32 (output_bfd,
5326 (plt->output_section->vma
5327 + plt->output_offset + h->plt.offset),
6de2ae4a 5328 htab->elf.sgot->contents + h->got.offset);
710ab287
L		 5329 return TRUE;
5330 }
0018b0a3 5331 }
0e1862bb 5332 else if (bfd_link_pic (info)
0018b0a3 5333 && SYMBOL_REFERENCES_LOCAL (info, h))
dd5724d5 5334 {
6725bdbf 5335 BFD_ASSERT((h->got.offset & 1) != 0);
dd5724d5
AM		 5336 rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
5337 }
252b5132
RH		 5338 else
5339 {
dd5724d5 5340 BFD_ASSERT((h->got.offset & 1) == 0);
710ab287 5341do_glob_dat:
6725bdbf 5342 bfd_put_32 (output_bfd, (bfd_vma) 0,
6de2ae4a 5343 htab->elf.sgot->contents + h->got.offset);
252b5132
RH		 5344 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
5345 }
5346
59d6ffb2 5347 elf_append_rel (output_bfd, htab->elf.srelgot, &rel);
252b5132
RH		 5348 }
5349
f5385ebf 5350 if (h->needs_copy)
252b5132 5351 {
947216bf 5352 Elf_Internal_Rela rel;
252b5132
RH		 5353
5354 /* This symbol needs a copy reloc. Set it up. */
5355
ffb2e45b
AM		 5356 if (h->dynindx == -1
5357 || (h->root.type != bfd_link_hash_defined
5358 && h->root.type != bfd_link_hash_defweak)
5359 || htab->srelbss == NULL)
5360 abort ();
252b5132
RH		 5361
5362 rel.r_offset = (h->root.u.def.value
5363 + h->root.u.def.section->output_section->vma
5364 + h->root.u.def.section->output_offset);
5365 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
59d6ffb2 5366 elf_append_rel (output_bfd, htab->srelbss, &rel);
252b5132
RH		 5367 }
5368
b34976b6 5369 return TRUE;
252b5132
RH		 5370}
5371
c25bc9fc
L		 5372/* Finish up local dynamic symbol handling. We set the contents of
5373 various dynamic sections here. */
5374
5375static bfd_boolean
5376elf_i386_finish_local_dynamic_symbol (void **slot, void *inf)
5377{
5378 struct elf_link_hash_entry *h
5379 = (struct elf_link_hash_entry *) *slot;
5380 struct bfd_link_info *info
23209a78 5381 = (struct bfd_link_info *) inf;
c25bc9fc
L		 5382
5383 return elf_i386_finish_dynamic_symbol (info->output_bfd, info,
5384 h, NULL);
5385}
5386
aec6b87e
L		 5387/* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
5388 here since undefined weak symbol may not be dynamic and may not be
5389 called for elf_i386_finish_dynamic_symbol. */
5390
5391static bfd_boolean
5392elf_i386_pie_finish_undefweak_symbol (struct bfd_hash_entry *bh,
5393 void *inf)
5394{
5395 struct elf_link_hash_entry *h = (struct elf_link_hash_entry *) bh;
5396 struct bfd_link_info *info = (struct bfd_link_info *) inf;
5397
5398 if (h->root.type != bfd_link_hash_undefweak
5399 || h->dynindx != -1)
5400 return TRUE;
5401
5402 return elf_i386_finish_dynamic_symbol (info->output_bfd,
5403 info, h, NULL);
5404}
5405
38701953
AM		 5406/* Used to decide how to sort relocs in an optimal manner for the
5407 dynamic linker, before writing them out. */
5408
5409static enum elf_reloc_type_class
cae1fbbb 5410elf_i386_reloc_type_class (const struct bfd_link_info *info,
7e612e98
AM		 5411 const asection *rel_sec ATTRIBUTE_UNUSED,
5412 const Elf_Internal_Rela *rela)
38701953 5413{
cae1fbbb
L		 5414 bfd *abfd = info->output_bfd;
5415 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5416 struct elf_link_hash_table *htab = elf_hash_table (info);
cae1fbbb 5417
d9e3b590
L		 5418 if (htab->dynsym != NULL
5419 && htab->dynsym->contents != NULL)
5420 {
5421 /* Check relocation against STT_GNU_IFUNC symbol if there are
5422 dynamic symbols. */
5423 unsigned long r_symndx = ELF32_R_SYM (rela->r_info);
5424 Elf_Internal_Sym sym;
5425 if (!bed->s->swap_symbol_in (abfd,
5426 (htab->dynsym->contents
5427 + r_symndx * sizeof (Elf32_External_Sym)),
5428 0, &sym))
5429 abort ();
5430
5431 if (ELF32_ST_TYPE (sym.st_info) == STT_GNU_IFUNC)
5432 return reloc_class_ifunc;
5433 }
cae1fbbb 5434
55fd94b0 5435 switch (ELF32_R_TYPE (rela->r_info))
38701953
AM		 5436 {
5437 case R_386_RELATIVE:
5438 return reloc_class_relative;
5439 case R_386_JUMP_SLOT:
5440 return reloc_class_plt;
5441 case R_386_COPY:
5442 return reloc_class_copy;
5443 default:
5444 return reloc_class_normal;
5445 }
5446}
5447
252b5132
RH		 5448/* Finish up the dynamic sections. */
5449
b34976b6 5450static bfd_boolean
55fd94b0
AM		 5451elf_i386_finish_dynamic_sections (bfd *output_bfd,
5452 struct bfd_link_info *info)
252b5132 5453{
6725bdbf 5454 struct elf_i386_link_hash_table *htab;
252b5132 5455 bfd *dynobj;
252b5132 5456 asection *sdyn;
25e762b9 5457 const struct elf_i386_backend_data *abed;
252b5132 5458
6725bdbf 5459 htab = elf_i386_hash_table (info);
4dfe6ac6
NC		 5460 if (htab == NULL)
5461 return FALSE;
5462
ebe50bae 5463 dynobj = htab->elf.dynobj;
3d4d4302 5464 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
25e762b9 5465 abed = get_elf_i386_backend_data (output_bfd);
252b5132 5466
ebe50bae 5467 if (htab->elf.dynamic_sections_created)
252b5132 5468 {
252b5132
RH		 5469 Elf32_External_Dyn *dyncon, *dynconend;
5470
6de2ae4a 5471 if (sdyn == NULL || htab->elf.sgot == NULL)
ffb2e45b 5472 abort ();
252b5132
RH		 5473
5474 dyncon = (Elf32_External_Dyn *) sdyn->contents;
eea6121a 5475 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
252b5132
RH		 5476 for (; dyncon < dynconend; dyncon++)
5477 {
5478 Elf_Internal_Dyn dyn;
51b64d56 5479 asection *s;
252b5132
RH		 5480
5481 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
5482
5483 switch (dyn.d_tag)
5484 {
5485 default:
25e762b9
RM		 5486 if (abed->is_vxworks
5487 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
7a2b07ff 5488 break;
0ac8d2ca 5489 continue;
252b5132
RH		 5490
5491 case DT_PLTGOT:
6de2ae4a 5492 s = htab->elf.sgotplt;
8c37241b 5493 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
6725bdbf
AM		 5494 break;
5495
252b5132 5496 case DT_JMPREL:
6de2ae4a 5497 s = htab->elf.srelplt;
6348e046 5498 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
252b5132
RH		 5499 break;
5500
5501 case DT_PLTRELSZ:
6de2ae4a 5502 s = htab->elf.srelplt;
eea6121a 5503 dyn.d_un.d_val = s->size;
252b5132
RH		 5504 break;
5505
5506 case DT_RELSZ:
5507 /* My reading of the SVR4 ABI indicates that the
5508 procedure linkage table relocs (DT_JMPREL) should be
5509 included in the overall relocs (DT_REL). This is
5510 what Solaris does. However, UnixWare can not handle
5511 that case. Therefore, we override the DT_RELSZ entry
6348e046 5512 here to make it not include the JMPREL relocs. */
6de2ae4a 5513 s = htab->elf.srelplt;
6348e046
AM		 5514 if (s == NULL)
5515 continue;
eea6121a 5516 dyn.d_un.d_val -= s->size;
6348e046
AM		 5517 break;
5518
5519 case DT_REL:
5520 /* We may not be using the standard ELF linker script.
5521 If .rel.plt is the first .rel section, we adjust
5522 DT_REL to not include it. */
6de2ae4a 5523 s = htab->elf.srelplt;
6348e046
AM		 5524 if (s == NULL)
5525 continue;
5526 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
5527 continue;
eea6121a 5528 dyn.d_un.d_ptr += s->size;
252b5132
RH		 5529 break;
5530 }
0ac8d2ca
AM		 5531
5532 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
252b5132
RH		 5533 }
5534
5535 /* Fill in the first entry in the procedure linkage table. */
6de2ae4a 5536 if (htab->elf.splt && htab->elf.splt->size > 0)
252b5132 5537 {
0e1862bb 5538 if (bfd_link_pic (info))
eac338cf 5539 {
25e762b9
RM		 5540 memcpy (htab->elf.splt->contents, abed->plt->pic_plt0_entry,
5541 abed->plt->plt0_entry_size);
5542 memset (htab->elf.splt->contents + abed->plt->plt0_entry_size,
5543 abed->plt0_pad_byte,
5544 abed->plt->plt_entry_size - abed->plt->plt0_entry_size);
eac338cf 5545 }
252b5132
RH		 5546 else
5547 {
25e762b9
RM		 5548 memcpy (htab->elf.splt->contents, abed->plt->plt0_entry,
5549 abed->plt->plt0_entry_size);
5550 memset (htab->elf.splt->contents + abed->plt->plt0_entry_size,
5551 abed->plt0_pad_byte,
5552 abed->plt->plt_entry_size - abed->plt->plt0_entry_size);
252b5132 5553 bfd_put_32 (output_bfd,
6de2ae4a
L		 5554 (htab->elf.sgotplt->output_section->vma
5555 + htab->elf.sgotplt->output_offset
6725bdbf 5556 + 4),
25e762b9
RM		 5557 htab->elf.splt->contents
5558 + abed->plt->plt0_got1_offset);
252b5132 5559 bfd_put_32 (output_bfd,
6de2ae4a
L		 5560 (htab->elf.sgotplt->output_section->vma
5561 + htab->elf.sgotplt->output_offset
6725bdbf 5562 + 8),
25e762b9
RM		 5563 htab->elf.splt->contents
5564 + abed->plt->plt0_got2_offset);
eac338cf 5565
25e762b9 5566 if (abed->is_vxworks)
eac338cf
PB		 5567 {
5568 Elf_Internal_Rela rel;
7325306f 5569
eac338cf
PB		 5570 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 4.
5571 On IA32 we use REL relocations so the addend goes in
5572 the PLT directly. */
6de2ae4a
L		 5573 rel.r_offset = (htab->elf.splt->output_section->vma
5574 + htab->elf.splt->output_offset
25e762b9 5575 + abed->plt->plt0_got1_offset);
7325306f 5576 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
eac338cf
PB		 5577 bfd_elf32_swap_reloc_out (output_bfd, &rel,
5578 htab->srelplt2->contents);
5579 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
6de2ae4a
L		 5580 rel.r_offset = (htab->elf.splt->output_section->vma
5581 + htab->elf.splt->output_offset
25e762b9 5582 + abed->plt->plt0_got2_offset);
7325306f 5583 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
eac338cf
PB		 5584 bfd_elf32_swap_reloc_out (output_bfd, &rel,
5585 htab->srelplt2->contents +
5586 sizeof (Elf32_External_Rel));
5587 }
252b5132
RH		 5588 }
5589
5590 /* UnixWare sets the entsize of .plt to 4, although that doesn't
5591 really seem like the right value. */
6de2ae4a 5592 elf_section_data (htab->elf.splt->output_section)
6725bdbf 5593 ->this_hdr.sh_entsize = 4;
eac338cf
PB		 5594
5595 /* Correct the .rel.plt.unloaded relocations. */
0e1862bb 5596 if (abed->is_vxworks && !bfd_link_pic (info))
eac338cf 5597 {
25e762b9
RM		 5598 int num_plts = (htab->elf.splt->size
5599 / abed->plt->plt_entry_size) - 1;
4c9b0de6 5600 unsigned char *p;
eac338cf
PB		 5601
5602 p = htab->srelplt2->contents;
0e1862bb 5603 if (bfd_link_pic (info))
eac338cf
PB		 5604 p += PLTRESOLVE_RELOCS_SHLIB * sizeof (Elf32_External_Rel);
5605 else
5606 p += PLTRESOLVE_RELOCS * sizeof (Elf32_External_Rel);
5607
5608 for (; num_plts; num_plts--)
5609 {
5610 Elf_Internal_Rela rel;
5611 bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
7325306f 5612 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
eac338cf
PB		 5613 bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
5614 p += sizeof (Elf32_External_Rel);
5615
5616 bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
7325306f 5617 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
eac338cf
PB		 5618 bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
5619 p += sizeof (Elf32_External_Rel);
5620 }
5621 }
252b5132
RH		 5622 }
5623 }
5624
6de2ae4a 5625 if (htab->elf.sgotplt)
252b5132 5626 {
56d4289c
L		 5627 if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
5628 {
5629 (*_bfd_error_handler)
5630 (_("discarded output section: `%A'"), htab->elf.sgotplt);
5631 return FALSE;
5632 }
5633
12d0ee4a 5634 /* Fill in the first three entries in the global offset table. */
6de2ae4a 5635 if (htab->elf.sgotplt->size > 0)
12d0ee4a
AM		 5636 {
5637 bfd_put_32 (output_bfd,
55fd94b0 5638 (sdyn == NULL ? 0
12d0ee4a 5639 : sdyn->output_section->vma + sdyn->output_offset),
6de2ae4a
L		 5640 htab->elf.sgotplt->contents);
5641 bfd_put_32 (output_bfd, 0, htab->elf.sgotplt->contents + 4);
5642 bfd_put_32 (output_bfd, 0, htab->elf.sgotplt->contents + 8);
12d0ee4a 5643 }
252b5132 5644
6de2ae4a 5645 elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize = 4;
12d0ee4a 5646 }
8c37241b 5647
e41b3a13 5648 /* Adjust .eh_frame for .plt section. */
9a2a56cc
AM		 5649 if (htab->plt_eh_frame != NULL
5650 && htab->plt_eh_frame->contents != NULL)
e41b3a13
JJ		 5651 {
5652 if (htab->elf.splt != NULL
5653 && htab->elf.splt->size != 0
5654 && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
5655 && htab->elf.splt->output_section != NULL
5656 && htab->plt_eh_frame->output_section != NULL)
5657 {
5658 bfd_vma plt_start = htab->elf.splt->output_section->vma;
5659 bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
5660 + htab->plt_eh_frame->output_offset
5661 + PLT_FDE_START_OFFSET;
5662 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
5663 htab->plt_eh_frame->contents
5664 + PLT_FDE_START_OFFSET);
5665 }
5666 if (htab->plt_eh_frame->sec_info_type
dbaa2011 5667 == SEC_INFO_TYPE_EH_FRAME)
e41b3a13
JJ		 5668 {
5669 if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
5670 htab->plt_eh_frame,
5671 htab->plt_eh_frame->contents))
5672 return FALSE;
5673 }
5674 }
5675
6de2ae4a
L		 5676 if (htab->elf.sgot && htab->elf.sgot->size > 0)
5677 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 4;
8c37241b 5678
c25bc9fc
L		 5679 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
5680 htab_traverse (htab->loc_hash_table,
5681 elf_i386_finish_local_dynamic_symbol,
5682 info);
5683
aec6b87e
L		 5684 /* Fill PLT entries for undefined weak symbols in PIE. */
5685 if (bfd_link_pie (info))
5686 bfd_hash_traverse (&info->hash->table,
5687 elf_i386_pie_finish_undefweak_symbol,
5688 info);
5689
b34976b6 5690 return TRUE;
252b5132
RH		 5691}
5692
3972882e 5693/* Return an array of PLT entry symbol values. */
4c45e5c9 5694
3972882e
L		 5695static bfd_vma *
5696elf_i386_get_plt_sym_val (bfd *abfd, asymbol **dynsyms, asection *plt,
5697 asection *relplt)
4c45e5c9 5698{
3972882e
L		 5699 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
5700 arelent *p;
5701 long count, i;
5702 bfd_vma *plt_sym_val;
144bed8d 5703 bfd_vma plt_offset;
3972882e
L		 5704 bfd_byte *plt_contents;
5705 const struct elf_i386_backend_data *bed
5706 = get_elf_i386_backend_data (abfd);
5707 Elf_Internal_Shdr *hdr;
5708
5709 /* Get the .plt section contents. */
5710 plt_contents = (bfd_byte *) bfd_malloc (plt->size);
5711 if (plt_contents == NULL)
5712 return NULL;
5713 if (!bfd_get_section_contents (abfd, (asection *) plt,
5714 plt_contents, 0, plt->size))
5715 {
5716bad_return:
5717 free (plt_contents);
5718 return NULL;
5719 }
144bed8d 5720
3972882e
L		 5721 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
5722 if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
5723 goto bad_return;
144bed8d 5724
3972882e
L		 5725 hdr = &elf_section_data (relplt)->this_hdr;
5726 count = relplt->size / hdr->sh_entsize;
5727
5728 plt_sym_val = (bfd_vma *) bfd_malloc (sizeof (bfd_vma) * count);
5729 if (plt_sym_val == NULL)
5730 goto bad_return;
cca5b8b6 5731
35181b3e 5732 for (i = 0; i < count; i++)
3972882e 5733 plt_sym_val[i] = -1;
cca5b8b6 5734
3972882e
L		 5735 plt_offset = bed->plt->plt_entry_size;
5736 p = relplt->relocation;
5737 for (i = 0; i < count; i++, p++)
144bed8d 5738 {
3972882e
L		 5739 long reloc_index;
5740
6f25f223 5741 /* Skip unknown relocation. PR 17512: file: bc9d6cf5. */
533d0af0 5742 if (p->howto == NULL)
6f25f223 5743 continue;
533d0af0
L		 5744
5745 if (p->howto->type != R_386_JUMP_SLOT
5746 && p->howto->type != R_386_IRELATIVE)
3972882e
L		 5747 continue;
5748
5749 reloc_index = H_GET_32 (abfd, (plt_contents + plt_offset
5750 + bed->plt->plt_reloc_offset));
5751 reloc_index /= sizeof (Elf32_External_Rel);
ec1f73bb
AM		 5752 if (reloc_index < count)
5753 plt_sym_val[reloc_index] = plt->vma + plt_offset;
5754
144bed8d 5755 plt_offset += bed->plt->plt_entry_size;
fca6ae69
L		 5756
5757 /* PR binutils/18437: Skip extra relocations in the .rel.plt
5758 section. */
5759 if (plt_offset >= plt->size)
5760 break;
144bed8d
L		 5761 }
5762
3972882e
L		 5763 free (plt_contents);
5764
5765 return plt_sym_val;
5766}
5767
5768/* Similar to _bfd_elf_get_synthetic_symtab. */
5769
5770static long
5771elf_i386_get_synthetic_symtab (bfd *abfd,
5772 long symcount,
5773 asymbol **syms,
5774 long dynsymcount,
5775 asymbol **dynsyms,
5776 asymbol **ret)
5777{
5778 asection *plt = bfd_get_section_by_name (abfd, ".plt");
5779 return _bfd_elf_ifunc_get_synthetic_symtab (abfd, symcount, syms,
5780 dynsymcount, dynsyms, ret,
5781 plt,
5782 elf_i386_get_plt_sym_val);
4c45e5c9
JJ		 5783}
5784
fdc90cb4
JJ		 5785/* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
5786
5787static bfd_boolean
5788elf_i386_hash_symbol (struct elf_link_hash_entry *h)
5789{
5790 if (h->plt.offset != (bfd_vma) -1
5791 && !h->def_regular
5792 && !h->pointer_equality_needed)
5793 return FALSE;
5794
5795 return _bfd_elf_hash_symbol (h);
5796}
4c45e5c9 5797
d8045f23
NC		 5798/* Hook called by the linker routine which adds symbols from an object
5799 file. */
5800
5801static bfd_boolean
c16153ae 5802elf_i386_add_symbol_hook (bfd * abfd,
f1885d1e 5803 struct bfd_link_info * info,
d8045f23
NC		 5804 Elf_Internal_Sym * sym,
5805 const char ** namep ATTRIBUTE_UNUSED,
5806 flagword * flagsp ATTRIBUTE_UNUSED,
5807 asection ** secp ATTRIBUTE_UNUSED,
5808 bfd_vma * valp ATTRIBUTE_UNUSED)
5809{
13a2df29 5810 if (ELF_ST_BIND (sym->st_info) == STB_GNU_UNIQUE
f1885d1e
AM		 5811 && (abfd->flags & DYNAMIC) == 0
5812 && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
13a2df29
L		 5813 elf_tdata (info->output_bfd)->has_gnu_symbols
5814 |= elf_gnu_symbol_unique;
d8045f23
NC		 5815
5816 return TRUE;
5817}
5818
6d00b590 5819#define TARGET_LITTLE_SYM i386_elf32_vec
252b5132
RH		 5820#define TARGET_LITTLE_NAME "elf32-i386"
5821#define ELF_ARCH bfd_arch_i386
ae95ffa6 5822#define ELF_TARGET_ID I386_ELF_DATA
252b5132
RH		 5823#define ELF_MACHINE_CODE EM_386
5824#define ELF_MAXPAGESIZE 0x1000
252b5132
RH		 5825
5826#define elf_backend_can_gc_sections 1
51b64d56 5827#define elf_backend_can_refcount 1
252b5132
RH		 5828#define elf_backend_want_got_plt 1
5829#define elf_backend_plt_readonly 1
5830#define elf_backend_want_plt_sym 0
5831#define elf_backend_got_header_size 12
e41b3a13 5832#define elf_backend_plt_alignment 4
f7483970 5833#define elf_backend_extern_protected_data 1
bedfd056 5834#define elf_backend_caches_rawsize 1
252b5132 5835
8c29f035
AM		 5836/* Support RELA for objdump of prelink objects. */
5837#define elf_info_to_howto elf_i386_info_to_howto_rel
dd5724d5
AM		 5838#define elf_info_to_howto_rel elf_i386_info_to_howto_rel
5839
13ae64f3 5840#define bfd_elf32_mkobject elf_i386_mkobject
13ae64f3 5841
dd5724d5
AM		 5842#define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
5843#define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
5844#define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
13285a1b 5845#define bfd_elf32_bfd_reloc_name_lookup elf_i386_reloc_name_lookup
3972882e 5846#define bfd_elf32_get_synthetic_symtab elf_i386_get_synthetic_symtab
dd5724d5
AM		 5847
5848#define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
13285a1b 5849#define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
dd5724d5 5850#define elf_backend_check_relocs elf_i386_check_relocs
0ac8d2ca 5851#define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
6725bdbf 5852#define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
0ac8d2ca 5853#define elf_backend_fake_sections elf_i386_fake_sections
dd5724d5
AM		 5854#define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
5855#define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
5856#define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
c5fccbec
DJ		 5857#define elf_backend_grok_prstatus elf_i386_grok_prstatus
5858#define elf_backend_grok_psinfo elf_i386_grok_psinfo
db6751f2 5859#define elf_backend_reloc_type_class elf_i386_reloc_type_class
0ac8d2ca
AM		 5860#define elf_backend_relocate_section elf_i386_relocate_section
5861#define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
67a4f2b7 5862#define elf_backend_always_size_sections elf_i386_always_size_sections
74541ad4
AM		 5863#define elf_backend_omit_section_dynsym \
5864 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
fdc90cb4 5865#define elf_backend_hash_symbol elf_i386_hash_symbol
d8045f23 5866#define elf_backend_add_symbol_hook elf_i386_add_symbol_hook
aec6b87e 5867#define elf_backend_fixup_symbol elf_i386_fixup_symbol
dd5724d5 5868
252b5132 5869#include "elf32-target.h"
2bc3c89a
AM		 5870
5871/* FreeBSD support. */
5872
5873#undef TARGET_LITTLE_SYM
6d00b590 5874#define TARGET_LITTLE_SYM i386_elf32_fbsd_vec
2bc3c89a
AM		 5875#undef TARGET_LITTLE_NAME
5876#define TARGET_LITTLE_NAME "elf32-i386-freebsd"
d1036acb
L		 5877#undef ELF_OSABI
5878#define ELF_OSABI ELFOSABI_FREEBSD
2bc3c89a
AM		 5879
5880/* The kernel recognizes executables as valid only if they carry a
5881 "FreeBSD" label in the ELF header. So we put this label on all
5882 executables and (for simplicity) also all other object files. */
5883
2bc3c89a 5884static void
d8045f23 5885elf_i386_fbsd_post_process_headers (bfd *abfd, struct bfd_link_info *info)
2bc3c89a 5886{
78245035 5887 _bfd_elf_post_process_headers (abfd, info);
2bc3c89a 5888
2bc3c89a 5889#ifdef OLD_FREEBSD_ABI_LABEL
cf7363b4
L		 5890 {
5891 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
5892 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
5893 memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
5894 }
caf47ea6 5895#endif
2bc3c89a
AM		 5896}
5897
5898#undef elf_backend_post_process_headers
d8045f23 5899#define elf_backend_post_process_headers elf_i386_fbsd_post_process_headers
571fe01f
NC		 5900#undef elf32_bed
5901#define elf32_bed elf32_i386_fbsd_bed
2bc3c89a 5902
d8045f23
NC		 5903#undef elf_backend_add_symbol_hook
5904
2bc3c89a 5905#include "elf32-target.h"
eac338cf 5906
a6cc6b3b
RO		 5907/* Solaris 2. */
5908
5909#undef TARGET_LITTLE_SYM
6d00b590 5910#define TARGET_LITTLE_SYM i386_elf32_sol2_vec
a6cc6b3b
RO		 5911#undef TARGET_LITTLE_NAME
5912#define TARGET_LITTLE_NAME "elf32-i386-sol2"
5913
914082d1
L		 5914#undef elf_backend_post_process_headers
5915
a6cc6b3b
RO		 5916/* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
5917 objects won't be recognized. */
5918#undef ELF_OSABI
5919
5920#undef elf32_bed
5921#define elf32_bed elf32_i386_sol2_bed
5922
7dc98aea
RO		 5923/* The 32-bit static TLS arena size is rounded to the nearest 8-byte
5924 boundary. */
84865015 5925#undef elf_backend_static_tls_alignment
7dc98aea
RO		 5926#define elf_backend_static_tls_alignment 8
5927
a6cc6b3b
RO		 5928/* The Solaris 2 ABI requires a plt symbol on all platforms.
5929
5930 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
5931 File, p.63. */
84865015 5932#undef elf_backend_want_plt_sym
a6cc6b3b
RO		 5933#define elf_backend_want_plt_sym 1
5934
84865015
NC		 5935#undef elf_backend_strtab_flags
5936#define elf_backend_strtab_flags SHF_STRINGS
5937
5522f910
NC		 5938/* Called to set the sh_flags, sh_link and sh_info fields of OSECTION which
5939 has a type >= SHT_LOOS. Returns TRUE if these fields were initialised
5940 FALSE otherwise. ISECTION is the best guess matching section from the
5941 input bfd IBFD, but it might be NULL. */
5942
84865015 5943static bfd_boolean
5522f910
NC		 5944elf32_i386_copy_solaris_special_section_fields (const bfd *ibfd ATTRIBUTE_UNUSED,
5945 bfd *obfd ATTRIBUTE_UNUSED,
5946 const Elf_Internal_Shdr *isection ATTRIBUTE_UNUSED,
5947 Elf_Internal_Shdr *osection ATTRIBUTE_UNUSED)
84865015
NC		 5948{
5949 /* PR 19938: FIXME: Need to add code for setting the sh_info
5522f910
NC		 5950 and sh_link fields of Solaris specific section types. */
5951 return FALSE;
84865015 5952
5522f910 5953 /* Based upon Oracle Solaris 11.3 Linkers and Libraries Guide, Ch. 13,
84865015
NC		 5954 Object File Format, Table 13-9 ELF sh_link and sh_info Interpretation:
5955
5956http://docs.oracle.com/cd/E53394_01/html/E54813/chapter6-94076.html#scrolltoc
5957
5958 The following values should be set:
5959
5960Type Link Info
5961-----------------------------------------------------------------------------
5962SHT_SUNW_ancillary The section header index of 0
5963 [0x6fffffee] the associated string table.
5964
5965SHT_SUNW_capinfo The section header index of For a dynamic object, the
5966 [0x6ffffff0] the associated symbol table. section header index of
5967 the associated
5968 SHT_SUNW_capchain table,
5969 otherwise 0.
5970
5971SHT_SUNW_symsort The section header index of 0
5972 [0x6ffffff1] the associated symbol table.
5973
5974SHT_SUNW_tlssort The section header index of 0
5975 [0x6ffffff2] the associated symbol table.
5976
5977SHT_SUNW_LDYNSYM The section header index of One greater than the
5978 [0x6ffffff3] the associated string table. symbol table index of the
5979 This index is the same string last local symbol,
5980 table used by the SHT_DYNSYM STB_LOCAL. Since
5981 section. SHT_SUNW_LDYNSYM only
5982 contains local symbols,
5983 sh_info is equivalent to
5984 the number of symbols in
5985 the table.
5986
5987SHT_SUNW_cap If symbol capabilities exist, If any capabilities refer
5988 [0x6ffffff5] the section header index of to named strings, the
5989 the associated section header index of
5990 SHT_SUNW_capinfo table, the associated string
5991 otherwise 0. table, otherwise 0.
5992
5993SHT_SUNW_move The section header index of 0
5994 [0x6ffffffa] the associated symbol table.
5995
5996SHT_SUNW_COMDAT 0 0
5997 [0x6ffffffb]
5998
5999SHT_SUNW_syminfo The section header index of The section header index
6000 [0x6ffffffc] the associated symbol table. of the associated
6001 .dynamic section.
6002
6003SHT_SUNW_verdef The section header index of The number of version
6004 [0x6ffffffd] the associated string table. definitions within the
6005 section.
6006
6007SHT_SUNW_verneed The section header index of The number of version
6008 [0x6ffffffe] the associated string table. dependencies within the
6009 section.
6010
6011SHT_SUNW_versym The section header index of 0
6012 [0x6fffffff] the associated symbol table. */
84865015
NC		 6013}
6014
5522f910
NC		 6015#undef elf_backend_copy_special_section_fields
6016#define elf_backend_copy_special_section_fields elf32_i386_copy_solaris_special_section_fields
84865015 6017
a6cc6b3b
RO		 6018#include "elf32-target.h"
6019
bf64a951
L		 6020/* Intel MCU support. */
6021
6022static bfd_boolean
6023elf32_iamcu_elf_object_p (bfd *abfd)
6024{
6025 /* Set the right machine number for an IAMCU elf32 file. */
6026 bfd_default_set_arch_mach (abfd, bfd_arch_iamcu, bfd_mach_i386_iamcu);
6027 return TRUE;
6028}
6029
6030#undef TARGET_LITTLE_SYM
6031#define TARGET_LITTLE_SYM iamcu_elf32_vec
6032#undef TARGET_LITTLE_NAME
6033#define TARGET_LITTLE_NAME "elf32-iamcu"
84865015 6034#undef ELF_ARCH
bf64a951
L		 6035#define ELF_ARCH bfd_arch_iamcu
6036
6037#undef ELF_MACHINE_CODE
6038#define ELF_MACHINE_CODE EM_IAMCU
6039
6040#undef ELF_OSABI
6041
6042#undef elf32_bed
6043#define elf32_bed elf32_iamcu_bed
6044
6045#undef elf_backend_object_p
6046#define elf_backend_object_p elf32_iamcu_elf_object_p
6047
6048#undef elf_backend_static_tls_alignment
6049
6050#undef elf_backend_want_plt_sym
6051#define elf_backend_want_plt_sym 0
6052
84865015 6053#undef elf_backend_strtab_flags
5522f910 6054#undef elf_backend_copy_special_section_fields
84865015 6055
030e823c
L		 6056#undef elf_backend_add_symbol_hook
6057#define elf_backend_add_symbol_hook elf_i386_add_symbol_hook
6058
bf64a951
L		 6059#include "elf32-target.h"
6060
6061/* Restore defaults. */
6062#undef ELF_ARCH
6063#define ELF_ARCH bfd_arch_i386
6064#undef ELF_MACHINE_CODE
6065#define ELF_MACHINE_CODE EM_386
6066
a27e4371
RM		 6067/* Native Client support. */
6068
6069#undef TARGET_LITTLE_SYM
6d00b590 6070#define TARGET_LITTLE_SYM i386_elf32_nacl_vec
a27e4371
RM		 6071#undef TARGET_LITTLE_NAME
6072#define TARGET_LITTLE_NAME "elf32-i386-nacl"
6073#undef elf32_bed
6074#define elf32_bed elf32_i386_nacl_bed
6075
6076#undef ELF_MAXPAGESIZE
6077#define ELF_MAXPAGESIZE 0x10000
6078
6079/* Restore defaults. */
6080#undef ELF_OSABI
6081#undef elf_backend_want_plt_sym
6082#define elf_backend_want_plt_sym 0
6083#undef elf_backend_post_process_headers
a27e4371
RM		 6084#undef elf_backend_static_tls_alignment
6085
6086/* NaCl uses substantially different PLT entries for the same effects. */
6087
6088#undef elf_backend_plt_alignment
6089#define elf_backend_plt_alignment 5
6090#define NACL_PLT_ENTRY_SIZE 64
6091#define NACLMASK 0xe0 /* 32-byte alignment mask. */
6092
6093static const bfd_byte elf_i386_nacl_plt0_entry[] =
6094 {
6095 0xff, 0x35, /* pushl contents of address */
6096 0, 0, 0, 0, /* replaced with address of .got + 4. */
6097 0x8b, 0x0d, /* movl contents of address, %ecx */
6098 0, 0, 0, 0, /* replaced with address of .got + 8. */
6099 0x83, 0xe1, NACLMASK, /* andl $NACLMASK, %ecx */
6100 0xff, 0xe1 /* jmp *%ecx */
6101 };
6102
6103static const bfd_byte elf_i386_nacl_plt_entry[NACL_PLT_ENTRY_SIZE] =
6104 {
6105 0x8b, 0x0d, /* movl contents of address, %ecx */
6106 0, 0, 0, 0, /* replaced with GOT slot address. */
6107 0x83, 0xe1, NACLMASK, /* andl $NACLMASK, %ecx */
6108 0xff, 0xe1, /* jmp *%ecx */
6109
6110 /* Pad to the next 32-byte boundary with nop instructions. */
6111 0x90,
6112 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6113 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6114
6115 /* Lazy GOT entries point here (32-byte aligned). */
6116 0x68, /* pushl immediate */
6117 0, 0, 0, 0, /* replaced with reloc offset. */
6118 0xe9, /* jmp relative */
6119 0, 0, 0, 0, /* replaced with offset to .plt. */
6120
6121 /* Pad to the next 32-byte boundary with nop instructions. */
6122 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6123 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6124 0x90, 0x90
6125 };
6126
6127static const bfd_byte
6128elf_i386_nacl_pic_plt0_entry[sizeof (elf_i386_nacl_plt0_entry)] =
6129 {
6130 0xff, 0x73, 0x04, /* pushl 4(%ebx) */
6131 0x8b, 0x4b, 0x08, /* mov 0x8(%ebx), %ecx */
6132 0x83, 0xe1, 0xe0, /* and $NACLMASK, %ecx */
6133 0xff, 0xe1, /* jmp *%ecx */
caa0075c
RM		 6134
6135 /* This is expected to be the same size as elf_i386_nacl_plt0_entry,
6136 so pad to that size with nop instructions. */
6137 0x90, 0x90, 0x90, 0x90, 0x90, 0x90
a27e4371
RM		 6138 };
6139
6140static const bfd_byte elf_i386_nacl_pic_plt_entry[NACL_PLT_ENTRY_SIZE] =
6141 {
6142 0x8b, 0x8b, /* movl offset(%ebx), %ecx */
6143 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
6144 0x83, 0xe1, 0xe0, /* andl $NACLMASK, %ecx */
6145 0xff, 0xe1, /* jmp *%ecx */
6146
6147 /* Pad to the next 32-byte boundary with nop instructions. */
6148 0x90,
6149 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6150 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6151
6152 /* Lazy GOT entries point here (32-byte aligned). */
6153 0x68, /* pushl immediate */
6154 0, 0, 0, 0, /* replaced with offset into relocation table. */
6155 0xe9, /* jmp relative */
6156 0, 0, 0, 0, /* replaced with offset to start of .plt. */
6157
6158 /* Pad to the next 32-byte boundary with nop instructions. */
6159 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6160 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6161 0x90, 0x90
6162 };
6163
6164static const bfd_byte elf_i386_nacl_eh_frame_plt[] =
6165 {
6166#if (PLT_CIE_LENGTH != 20 \
6167 || PLT_FDE_LENGTH != 36 \
6168 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
6169 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
6170# error "Need elf_i386_backend_data parameters for eh_frame_plt offsets!"
6171#endif
6172 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
6173 0, 0, 0, 0, /* CIE ID */
6174 1, /* CIE version */
6175 'z', 'R', 0, /* Augmentation string */
6176 1, /* Code alignment factor */
6177 0x7c, /* Data alignment factor: -4 */
6178 8, /* Return address column */
6179 1, /* Augmentation size */
6180 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
6181 DW_CFA_def_cfa, 4, 4, /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
6182 DW_CFA_offset + 8, 1, /* DW_CFA_offset: r8 (eip) at cfa-4 */
6183 DW_CFA_nop, DW_CFA_nop,
6184
6185 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
6186 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
6187 0, 0, 0, 0, /* R_386_PC32 .plt goes here */
6188 0, 0, 0, 0, /* .plt size goes here */
6189 0, /* Augmentation size */
6190 DW_CFA_def_cfa_offset, 8, /* DW_CFA_def_cfa_offset: 8 */
6191 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
6192 DW_CFA_def_cfa_offset, 12, /* DW_CFA_def_cfa_offset: 12 */
6193 DW_CFA_advance_loc + 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
6194 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
6195 13, /* Block length */
6196 DW_OP_breg4, 4, /* DW_OP_breg4 (esp): 4 */
6197 DW_OP_breg8, 0, /* DW_OP_breg8 (eip): 0 */
6198 DW_OP_const1u, 63, DW_OP_and, DW_OP_const1u, 37, DW_OP_ge,
6199 DW_OP_lit2, DW_OP_shl, DW_OP_plus,
6200 DW_CFA_nop, DW_CFA_nop
6201 };
6202
6203static const struct elf_i386_plt_layout elf_i386_nacl_plt =
6204 {
6205 elf_i386_nacl_plt0_entry, /* plt0_entry */
6206 sizeof (elf_i386_nacl_plt0_entry), /* plt0_entry_size */
6207 2, /* plt0_got1_offset */
6208 8, /* plt0_got2_offset */
6209 elf_i386_nacl_plt_entry, /* plt_entry */
6210 NACL_PLT_ENTRY_SIZE, /* plt_entry_size */
6211 2, /* plt_got_offset */
6212 33, /* plt_reloc_offset */
6213 38, /* plt_plt_offset */
6214 32, /* plt_lazy_offset */
6215 elf_i386_nacl_pic_plt0_entry, /* pic_plt0_entry */
6216 elf_i386_nacl_pic_plt_entry, /* pic_plt_entry */
6217 elf_i386_nacl_eh_frame_plt, /* eh_frame_plt */
6218 sizeof (elf_i386_nacl_eh_frame_plt),/* eh_frame_plt_size */
6219 };
6220
6221static const struct elf_i386_backend_data elf_i386_nacl_arch_bed =
6222 {
6223 &elf_i386_nacl_plt, /* plt */
6224 0x90, /* plt0_pad_byte: nop insn */
6225 0, /* is_vxworks */
6226 };
6227
64b384e1
RM		 6228static bfd_boolean
6229elf32_i386_nacl_elf_object_p (bfd *abfd)
6230{
6231 /* Set the right machine number for a NaCl i386 ELF32 file. */
6232 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_i386_i386_nacl);
6233 return TRUE;
6234}
6235
a27e4371
RM		 6236#undef elf_backend_arch_data
6237#define elf_backend_arch_data &elf_i386_nacl_arch_bed
6238
64b384e1
RM		 6239#undef elf_backend_object_p
6240#define elf_backend_object_p elf32_i386_nacl_elf_object_p
5a68afcf
RM		 6241#undef elf_backend_modify_segment_map
6242#define elf_backend_modify_segment_map nacl_modify_segment_map
6243#undef elf_backend_modify_program_headers
6244#define elf_backend_modify_program_headers nacl_modify_program_headers
887badb3
RM		 6245#undef elf_backend_final_write_processing
6246#define elf_backend_final_write_processing nacl_final_write_processing
5a68afcf 6247
a27e4371
RM		 6248#include "elf32-target.h"
6249
5a68afcf 6250/* Restore defaults. */
64b384e1 6251#undef elf_backend_object_p
5a68afcf
RM		 6252#undef elf_backend_modify_segment_map
6253#undef elf_backend_modify_program_headers
887badb3 6254#undef elf_backend_final_write_processing
5a68afcf 6255
eac338cf
PB		 6256/* VxWorks support. */
6257
6258#undef TARGET_LITTLE_SYM
6d00b590 6259#define TARGET_LITTLE_SYM i386_elf32_vxworks_vec
eac338cf
PB		 6260#undef TARGET_LITTLE_NAME
6261#define TARGET_LITTLE_NAME "elf32-i386-vxworks"
d1036acb 6262#undef ELF_OSABI
a27e4371
RM		 6263#undef elf_backend_plt_alignment
6264#define elf_backend_plt_alignment 4
eac338cf 6265
23209a78
RM		 6266static const struct elf_i386_backend_data elf_i386_vxworks_arch_bed =
6267 {
25e762b9 6268 &elf_i386_plt, /* plt */
23209a78
RM		 6269 0x90, /* plt0_pad_byte */
6270 1, /* is_vxworks */
6271 };
eac338cf 6272
23209a78
RM		 6273#undef elf_backend_arch_data
6274#define elf_backend_arch_data &elf_i386_vxworks_arch_bed
eac338cf 6275
13285a1b 6276#undef elf_backend_relocs_compatible
eac338cf
PB		 6277#undef elf_backend_add_symbol_hook
6278#define elf_backend_add_symbol_hook \
6279 elf_vxworks_add_symbol_hook
6280#undef elf_backend_link_output_symbol_hook
6281#define elf_backend_link_output_symbol_hook \
9c72ff84 6282 elf_vxworks_link_output_symbol_hook
eac338cf
PB		 6283#undef elf_backend_emit_relocs
6284#define elf_backend_emit_relocs elf_vxworks_emit_relocs
6285#undef elf_backend_final_write_processing
6286#define elf_backend_final_write_processing \
6287 elf_vxworks_final_write_processing
7dc98aea 6288#undef elf_backend_static_tls_alignment
eac338cf
PB		 6289
6290/* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
6291 define it. */
6292#undef elf_backend_want_plt_sym
6293#define elf_backend_want_plt_sym 1
6294
6295#undef elf32_bed
6296#define elf32_bed elf32_i386_vxworks_bed
6297
6298#include "elf32-target.h"
GDB Binutils - Deliverables
This page took 1.484606 seconds and 4 git commands to generate.