projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* coffgen.c (_bfd_coff_is_local_label_name): Return proper boolean
[deliverable/binutils-gdb.git] / bfd / elf32-i386.c
CommitLineData
e4b6b3e7 1/* Intel 80386/80486-specific support for 32-bit ELF
6e2183b1 2 Copyright 1993, 1994, 1995, 1996, 1997 Free Software Foundation, Inc.
e4b6b3e7
ILT		 3
4This file is part of BFD, the Binary File Descriptor library.
5
6This program is free software; you can redistribute it and/or modify
7it under the terms of the GNU General Public License as published by
8the Free Software Foundation; either version 2 of the License, or
9(at your option) any later version.
10
11This program is distributed in the hope that it will be useful,
12but WITHOUT ANY WARRANTY; without even the implied warranty of
13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14GNU General Public License for more details.
15
16You should have received a copy of the GNU General Public License
17along with this program; if not, write to the Free Software
943fbd5b 18Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
e4b6b3e7 19
e4b6b3e7
ILT		 20#include "bfd.h"
21#include "sysdep.h"
013dec1a 22#include "bfdlink.h"
e4b6b3e7 23#include "libbfd.h"
3b3f7625 24#include "elf-bfd.h"
e4b6b3e7 25
30dc85f1 26static reloc_howto_type *elf_i386_reloc_type_lookup
013dec1a
ILT		 27 PARAMS ((bfd *, bfd_reloc_code_real_type));
28static void elf_i386_info_to_howto
29 PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *));
30static void elf_i386_info_to_howto_rel
31 PARAMS ((bfd *, arelent *, Elf32_Internal_Rel *));
6e2183b1
ILT		 32static boolean elf_i386_is_local_label_name PARAMS ((bfd *, const char *));
33static struct bfd_hash_entry *elf_i386_link_hash_newfunc
34 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
35static struct bfd_link_hash_table *elf_i386_link_hash_table_create
36 PARAMS ((bfd *));
eb4267a3
ILT		 37static boolean elf_i386_check_relocs
38 PARAMS ((bfd *, struct bfd_link_info *, asection *,
39 const Elf_Internal_Rela *));
013dec1a
ILT		 40static boolean elf_i386_adjust_dynamic_symbol
41 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
013dec1a
ILT		 42static boolean elf_i386_size_dynamic_sections
43 PARAMS ((bfd *, struct bfd_link_info *));
44static boolean elf_i386_relocate_section
45 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
eb4267a3 46 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
013dec1a
ILT		 47static boolean elf_i386_finish_dynamic_symbol
48 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
49 Elf_Internal_Sym *));
50static boolean elf_i386_finish_dynamic_sections
51 PARAMS ((bfd *, struct bfd_link_info *));
52
e4b6b3e7
ILT		 53#define USE_REL 1 /* 386 uses REL relocations instead of RELA */
54
55enum reloc_type
56 {
57 R_386_NONE = 0,
68241b2b
ILT		 58 R_386_32,
59 R_386_PC32,
60 R_386_GOT32,
61 R_386_PLT32,
e4b6b3e7 62 R_386_COPY,
68241b2b
ILT		 63 R_386_GLOB_DAT,
64 R_386_JUMP_SLOT,
e4b6b3e7 65 R_386_RELATIVE,
68241b2b
ILT		 66 R_386_GOTOFF,
67 R_386_GOTPC,
ff12f303
ILT		 68 FIRST_INVALID_RELOC,
69 LAST_INVALID_RELOC = 19,
70 /* The remaining relocs are a GNU extension. */
71 R_386_16 = 20,
72 R_386_PC16,
73 R_386_8,
74 R_386_PC8,
e4b6b3e7
ILT		 75 R_386_max
76 };
77
78#if 0
79static CONST char *CONST reloc_type_names[] =
80{
81 "R_386_NONE",
68241b2b
ILT		 82 "R_386_32",
83 "R_386_PC32",
84 "R_386_GOT32",
85 "R_386_PLT32",
e4b6b3e7 86 "R_386_COPY",
68241b2b
ILT		 87 "R_386_GLOB_DAT",
88 "R_386_JUMP_SLOT",
e4b6b3e7 89 "R_386_RELATIVE",
68241b2b
ILT		 90 "R_386_GOTOFF",
91 "R_386_GOTPC",
e4b6b3e7
ILT		 92};
93#endif
94
e4b6b3e7
ILT		 95static reloc_howto_type elf_howto_table[]=
96{
68241b2b
ILT		 97 HOWTO(R_386_NONE, 0,0, 0,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_NONE", true,0x00000000,0x00000000,false),
98 HOWTO(R_386_32, 0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_32", true,0xffffffff,0xffffffff,false),
99 HOWTO(R_386_PC32, 0,2,32,true, 0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_PC32", true,0xffffffff,0xffffffff,true),
100 HOWTO(R_386_GOT32, 0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_GOT32", true,0xffffffff,0xffffffff,false),
eb4267a3 101 HOWTO(R_386_PLT32, 0,2,32,true,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_PLT32", true,0xffffffff,0xffffffff,true),
68241b2b
ILT		 102 HOWTO(R_386_COPY, 0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_COPY", true,0xffffffff,0xffffffff,false),
103 HOWTO(R_386_GLOB_DAT, 0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_GLOB_DAT", true,0xffffffff,0xffffffff,false),
104 HOWTO(R_386_JUMP_SLOT, 0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_JUMP_SLOT",true,0xffffffff,0xffffffff,false),
105 HOWTO(R_386_RELATIVE, 0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_RELATIVE", true,0xffffffff,0xffffffff,false),
106 HOWTO(R_386_GOTOFF, 0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_GOTOFF", true,0xffffffff,0xffffffff,false),
eb4267a3 107 HOWTO(R_386_GOTPC, 0,2,32,true,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_GOTPC", true,0xffffffff,0xffffffff,true),
ff12f303
ILT		 108 { 11 },
109 { 12 },
110 { 13 },
111 { 14 },
112 { 15 },
113 { 16 },
114 { 17 },
115 { 18 },
116 { 19 },
117 /* The remaining relocs are a GNU extension. */
118 HOWTO(R_386_16, 0,1,16,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_16", true,0xffff,0xffff,false),
119 HOWTO(R_386_PC16, 0,1,16,true, 0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_PC16", true,0xffff,0xffff,true),
120 HOWTO(R_386_8, 0,0,8,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_8", true,0xff,0xff,false),
121 HOWTO(R_386_PC8, 0,0,8,true, 0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_PC8", true,0xff,0xff,true),
e4b6b3e7
ILT		 122};
123
124#ifdef DEBUG_GEN_RELOC
125#define TRACE(str) fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
126#else
127#define TRACE(str)
128#endif
129
30dc85f1 130static reloc_howto_type *
013dec1a
ILT		 131elf_i386_reloc_type_lookup (abfd, code)
132 bfd *abfd;
133 bfd_reloc_code_real_type code;
e4b6b3e7
ILT		 134{
135 switch (code)
136 {
137 case BFD_RELOC_NONE:
138 TRACE ("BFD_RELOC_NONE");
139 return &elf_howto_table[ (int)R_386_NONE ];
140
141 case BFD_RELOC_32:
142 TRACE ("BFD_RELOC_32");
143 return &elf_howto_table[ (int)R_386_32 ];
144
145 case BFD_RELOC_32_PCREL:
146 TRACE ("BFD_RELOC_PC32");
147 return &elf_howto_table[ (int)R_386_PC32 ];
148
68241b2b
ILT		 149 case BFD_RELOC_386_GOT32:
150 TRACE ("BFD_RELOC_386_GOT32");
151 return &elf_howto_table[ (int)R_386_GOT32 ];
152
153 case BFD_RELOC_386_PLT32:
154 TRACE ("BFD_RELOC_386_PLT32");
155 return &elf_howto_table[ (int)R_386_PLT32 ];
156
157 case BFD_RELOC_386_COPY:
158 TRACE ("BFD_RELOC_386_COPY");
159 return &elf_howto_table[ (int)R_386_COPY ];
160
161 case BFD_RELOC_386_GLOB_DAT:
162 TRACE ("BFD_RELOC_386_GLOB_DAT");
163 return &elf_howto_table[ (int)R_386_GLOB_DAT ];
164
165 case BFD_RELOC_386_JUMP_SLOT:
166 TRACE ("BFD_RELOC_386_JUMP_SLOT");
167 return &elf_howto_table[ (int)R_386_JUMP_SLOT ];
168
169 case BFD_RELOC_386_RELATIVE:
170 TRACE ("BFD_RELOC_386_RELATIVE");
171 return &elf_howto_table[ (int)R_386_RELATIVE ];
172
173 case BFD_RELOC_386_GOTOFF:
174 TRACE ("BFD_RELOC_386_GOTOFF");
175 return &elf_howto_table[ (int)R_386_GOTOFF ];
176
177 case BFD_RELOC_386_GOTPC:
178 TRACE ("BFD_RELOC_386_GOTPC");
179 return &elf_howto_table[ (int)R_386_GOTPC ];
180
ff12f303
ILT		 181 /* The remaining relocs are a GNU extension. */
182 case BFD_RELOC_16:
183 TRACE ("BFD_RELOC_16");
184 return &elf_howto_table[(int) R_386_16];
185
186 case BFD_RELOC_16_PCREL:
187 TRACE ("BFD_RELOC_16_PCREL");
188 return &elf_howto_table[(int) R_386_PC16];
189
190 case BFD_RELOC_8:
191 TRACE ("BFD_RELOC_8");
192 return &elf_howto_table[(int) R_386_8];
193
194 case BFD_RELOC_8_PCREL:
195 TRACE ("BFD_RELOC_8_PCREL");
196 return &elf_howto_table[(int) R_386_PC8];
197
e4b6b3e7 198 default:
68241b2b 199 break;
e4b6b3e7
ILT		 200 }
201
202 TRACE ("Unknown");
203 return 0;
204}
205
206static void
013dec1a
ILT		 207elf_i386_info_to_howto (abfd, cache_ptr, dst)
208 bfd *abfd;
209 arelent *cache_ptr;
210 Elf32_Internal_Rela *dst;
e4b6b3e7 211{
ff12f303 212 abort ();
e4b6b3e7
ILT		 213}
214
215static void
013dec1a 216elf_i386_info_to_howto_rel (abfd, cache_ptr, dst)
ff12f303
ILT		 217 bfd *abfd;
218 arelent *cache_ptr;
013dec1a 219 Elf32_Internal_Rel *dst;
e4b6b3e7 220{
ff12f303
ILT		 221 enum reloc_type type;
222
223 type = (enum reloc_type) ELF32_R_TYPE (dst->r_info);
224 BFD_ASSERT (type < R_386_max);
225 BFD_ASSERT (type < FIRST_INVALID_RELOC || type > LAST_INVALID_RELOC);
e4b6b3e7 226
ff12f303 227 cache_ptr->howto = &elf_howto_table[(int) type];
e4b6b3e7 228}
6e2183b1
ILT		 229
230/* Return whether a symbol name implies a local label. The UnixWare
231 2.1 cc generates temporary symbols that start with .X, so we
232 recognize them here. FIXME: do other SVR4 compilers also use .X?.
233 If so, we should move the .X recognition into
234 _bfd_elf_is_local_label_name. */
235
236static boolean
237elf_i386_is_local_label_name (abfd, name)
238 bfd *abfd;
239 const char *name;
240{
241 if (name[0] == '.' && name[1] == 'X')
242 return true;
243
244 return _bfd_elf_is_local_label_name (abfd, name);
245}
013dec1a
ILT		 246\f
247/* Functions for the i386 ELF linker. */
248
249/* The name of the dynamic interpreter. This is put in the .interp
250 section. */
251
252#define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
253
254/* The size in bytes of an entry in the procedure linkage table. */
255
256#define PLT_ENTRY_SIZE 16
257
258/* The first entry in an absolute procedure linkage table looks like
259 this. See the SVR4 ABI i386 supplement to see how this works. */
260
89f7a04c 261static const bfd_byte elf_i386_plt0_entry[PLT_ENTRY_SIZE] =
013dec1a
ILT		 262{
263 0xff, 0x35, /* pushl contents of address */
264 0, 0, 0, 0, /* replaced with address of .got + 4. */
265 0xff, 0x25, /* jmp indirect */
266 0, 0, 0, 0, /* replaced with address of .got + 8. */
267 0, 0, 0, 0 /* pad out to 16 bytes. */
268};
269
270/* Subsequent entries in an absolute procedure linkage table look like
271 this. */
272
89f7a04c 273static const bfd_byte elf_i386_plt_entry[PLT_ENTRY_SIZE] =
013dec1a
ILT		 274{
275 0xff, 0x25, /* jmp indirect */
276 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
277 0x68, /* pushl immediate */
278 0, 0, 0, 0, /* replaced with offset into relocation table. */
279 0xe9, /* jmp relative */
280 0, 0, 0, 0 /* replaced with offset to start of .plt. */
281};
282
eb4267a3
ILT		 283/* The first entry in a PIC procedure linkage table look like this. */
284
89f7a04c 285static const bfd_byte elf_i386_pic_plt0_entry[PLT_ENTRY_SIZE] =
eb4267a3 286{
ff12f303
ILT		 287 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
288 0xff, 0xa3, 8, 0, 0, 0, /* jmp *8(%ebx) */
eb4267a3
ILT		 289 0, 0, 0, 0 /* pad out to 16 bytes. */
290};
291
292/* Subsequent entries in a PIC procedure linkage table look like this. */
293
89f7a04c 294static const bfd_byte elf_i386_pic_plt_entry[PLT_ENTRY_SIZE] =
eb4267a3
ILT		 295{
296 0xff, 0xa3, /* jmp *offset(%ebx) */
297 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
298 0x68, /* pushl immediate */
299 0, 0, 0, 0, /* replaced with offset into relocation table. */
300 0xe9, /* jmp relative */
301 0, 0, 0, 0 /* replaced with offset to start of .plt. */
302};
303
6e2183b1
ILT		 304/* The i386 linker needs to keep track of the number of relocs that it
305 decides to copy in check_relocs for each symbol. This is so that
306 it can discard PC relative relocs if it doesn't need them when
307 linking with -Bsymbolic. We store the information in a field
308 extending the regular ELF linker hash table. */
309
310/* This structure keeps track of the number of PC relative relocs we
311 have copied for a given symbol. */
312
313struct elf_i386_pcrel_relocs_copied
314{
315 /* Next section. */
316 struct elf_i386_pcrel_relocs_copied *next;
317 /* A section in dynobj. */
318 asection *section;
319 /* Number of relocs copied in this section. */
320 bfd_size_type count;
321};
322
323/* i386 ELF linker hash entry. */
324
325struct elf_i386_link_hash_entry
326{
327 struct elf_link_hash_entry root;
328
329 /* Number of PC relative relocs copied for this symbol. */
330 struct elf_i386_pcrel_relocs_copied *pcrel_relocs_copied;
331};
332
333/* i386 ELF linker hash table. */
334
335struct elf_i386_link_hash_table
336{
337 struct elf_link_hash_table root;
338};
339
340/* Declare this now that the above structures are defined. */
341
342static boolean elf_i386_discard_copies
343 PARAMS ((struct elf_i386_link_hash_entry *, PTR));
344
345/* Traverse an i386 ELF linker hash table. */
346
347#define elf_i386_link_hash_traverse(table, func, info) \
348 (elf_link_hash_traverse \
349 (&(table)->root, \
350 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
351 (info)))
352
353/* Get the i386 ELF linker hash table from a link_info structure. */
354
355#define elf_i386_hash_table(p) \
356 ((struct elf_i386_link_hash_table *) ((p)->hash))
357
358/* Create an entry in an i386 ELF linker hash table. */
359
360static struct bfd_hash_entry *
361elf_i386_link_hash_newfunc (entry, table, string)
362 struct bfd_hash_entry *entry;
363 struct bfd_hash_table *table;
364 const char *string;
365{
366 struct elf_i386_link_hash_entry *ret =
367 (struct elf_i386_link_hash_entry *) entry;
368
369 /* Allocate the structure if it has not already been allocated by a
370 subclass. */
371 if (ret == (struct elf_i386_link_hash_entry *) NULL)
372 ret = ((struct elf_i386_link_hash_entry *)
373 bfd_hash_allocate (table,
374 sizeof (struct elf_i386_link_hash_entry)));
375 if (ret == (struct elf_i386_link_hash_entry *) NULL)
376 return (struct bfd_hash_entry *) ret;
377
378 /* Call the allocation method of the superclass. */
379 ret = ((struct elf_i386_link_hash_entry *)
380 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
381 table, string));
382 if (ret != (struct elf_i386_link_hash_entry *) NULL)
383 {
384 ret->pcrel_relocs_copied = NULL;
385 }
386
387 return (struct bfd_hash_entry *) ret;
388}
389
390/* Create an i386 ELF linker hash table. */
391
392static struct bfd_link_hash_table *
393elf_i386_link_hash_table_create (abfd)
394 bfd *abfd;
395{
396 struct elf_i386_link_hash_table *ret;
397
398 ret = ((struct elf_i386_link_hash_table *)
399 bfd_alloc (abfd, sizeof (struct elf_i386_link_hash_table)));
400 if (ret == (struct elf_i386_link_hash_table *) NULL)
401 return NULL;
402
403 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
404 elf_i386_link_hash_newfunc))
405 {
406 bfd_release (abfd, ret);
407 return NULL;
408 }
409
410 return &ret->root.root;
411}
412
eb4267a3
ILT		 413/* Look through the relocs for a section during the first phase, and
414 allocate space in the global offset table or procedure linkage
415 table. */
416
417static boolean
418elf_i386_check_relocs (abfd, info, sec, relocs)
419 bfd *abfd;
420 struct bfd_link_info *info;
421 asection *sec;
422 const Elf_Internal_Rela *relocs;
423{
424 bfd *dynobj;
425 Elf_Internal_Shdr *symtab_hdr;
426 struct elf_link_hash_entry **sym_hashes;
427 bfd_vma *local_got_offsets;
428 const Elf_Internal_Rela *rel;
429 const Elf_Internal_Rela *rel_end;
430 asection *sgot;
431 asection *srelgot;
eb4267a3
ILT		 432 asection *sreloc;
433
434 if (info->relocateable)
435 return true;
436
437 dynobj = elf_hash_table (info)->dynobj;
438 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
439 sym_hashes = elf_sym_hashes (abfd);
440 local_got_offsets = elf_local_got_offsets (abfd);
441
442 sgot = NULL;
443 srelgot = NULL;
eb4267a3
ILT		 444 sreloc = NULL;
445
446 rel_end = relocs + sec->reloc_count;
447 for (rel = relocs; rel < rel_end; rel++)
448 {
3b3f7625 449 unsigned long r_symndx;
eb4267a3
ILT		 450 struct elf_link_hash_entry *h;
451
452 r_symndx = ELF32_R_SYM (rel->r_info);
453
454 if (r_symndx < symtab_hdr->sh_info)
455 h = NULL;
456 else
457 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
458
12662be4 459 /* Some relocs require a global offset table. */
eb4267a3
ILT		 460 if (dynobj == NULL)
461 {
462 switch (ELF32_R_TYPE (rel->r_info))
463 {
464 case R_386_GOT32:
eb4267a3
ILT		 465 case R_386_GOTOFF:
466 case R_386_GOTPC:
467 elf_hash_table (info)->dynobj = dynobj = abfd;
ede4eed4 468 if (! _bfd_elf_create_got_section (dynobj, info))
eb4267a3
ILT		 469 return false;
470 break;
471
472 default:
473 break;
474 }
475 }
476
477 switch (ELF32_R_TYPE (rel->r_info))
478 {
479 case R_386_GOT32:
480 /* This symbol requires a global offset table entry. */
ff12f303 481
eb4267a3
ILT		 482 if (sgot == NULL)
483 {
484 sgot = bfd_get_section_by_name (dynobj, ".got");
12662be4
ILT		 485 BFD_ASSERT (sgot != NULL);
486 }
487
488 if (srelgot == NULL
489 && (h != NULL || info->shared))
490 {
eb4267a3
ILT		 491 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
492 if (srelgot == NULL)
493 {
494 srelgot = bfd_make_section (dynobj, ".rel.got");
495 if (srelgot == NULL
496 || ! bfd_set_section_flags (dynobj, srelgot,
497 (SEC_ALLOC
498 | SEC_LOAD
499 | SEC_HAS_CONTENTS
500 | SEC_IN_MEMORY
ff12f303 501 | SEC_LINKER_CREATED
eb4267a3
ILT		 502 | SEC_READONLY))
503 || ! bfd_set_section_alignment (dynobj, srelgot, 2))
504 return false;
505 }
eb4267a3
ILT		 506 }
507
508 if (h != NULL)
509 {
510 if (h->got_offset != (bfd_vma) -1)
511 {
512 /* We have already allocated space in the .got. */
513 break;
514 }
515 h->got_offset = sgot->_raw_size;
516
517 /* Make sure this symbol is output as a dynamic symbol. */
518 if (h->dynindx == -1)
519 {
520 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
521 return false;
522 }
12662be4
ILT		 523
524 srelgot->_raw_size += sizeof (Elf32_External_Rel);
eb4267a3
ILT		 525 }
526 else
527 {
528 /* This is a global offset table entry for a local
529 symbol. */
530 if (local_got_offsets == NULL)
531 {
532 size_t size;
3b3f7625 533 register unsigned int i;
eb4267a3
ILT		 534
535 size = symtab_hdr->sh_info * sizeof (bfd_vma);
536 local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
537 if (local_got_offsets == NULL)
3c38b3df 538 return false;
eb4267a3
ILT		 539 elf_local_got_offsets (abfd) = local_got_offsets;
540 for (i = 0; i < symtab_hdr->sh_info; i++)
541 local_got_offsets[i] = (bfd_vma) -1;
542 }
543 if (local_got_offsets[r_symndx] != (bfd_vma) -1)
544 {
545 /* We have already allocated space in the .got. */
546 break;
547 }
548 local_got_offsets[r_symndx] = sgot->_raw_size;
12662be4
ILT		 549
550 if (info->shared)
551 {
552 /* If we are generating a shared object, we need to
553 output a R_386_RELATIVE reloc so that the dynamic
554 linker can adjust this GOT entry. */
555 srelgot->_raw_size += sizeof (Elf32_External_Rel);
556 }
eb4267a3
ILT		 557 }
558
559 sgot->_raw_size += 4;
eb4267a3
ILT		 560
561 break;
562
563 case R_386_PLT32:
12662be4
ILT		 564 /* This symbol requires a procedure linkage table entry. We
565 actually build the entry in adjust_dynamic_symbol,
ff12f303
ILT		 566 because this might be a case of linking PIC code which is
567 never referenced by a dynamic object, in which case we
568 don't need to generate a procedure linkage table entry
569 after all. */
570
eb4267a3
ILT		 571 /* If this is a local symbol, we resolve it directly without
572 creating a procedure linkage table entry. */
573 if (h == NULL)
574 continue;
575
12662be4 576 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
eb4267a3
ILT		 577
578 break;
579
580 case R_386_32:
581 case R_386_PC32:
6e2183b1
ILT		 582 /* If we are creating a shared library, and this is a reloc
583 against a global symbol, or a non PC relative reloc
584 against a local symbol, then we need to copy the reloc
585 into the shared library. However, if we are linking with
586 -Bsymbolic, we do not need to copy a reloc against a
587 global symbol which is defined in an object we are
588 including in the link (i.e., DEF_REGULAR is set). At
589 this point we have not seen all the input files, so it is
590 possible that DEF_REGULAR is not set now but will be set
591 later (it is never cleared). We account for that
592 possibility below by storing information in the
593 pcrel_relocs_copied field of the hash table entry. */
eb4267a3 594 if (info->shared
6e2183b1
ILT		 595 && (ELF32_R_TYPE (rel->r_info) != R_386_PC32
596 || (h != NULL
597 && (! info->symbolic
598 || (h->elf_link_hash_flags
599 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
eb4267a3 600 {
14cac507
ILT		 601 /* When creating a shared object, we must copy these
602 reloc types into the output file. We create a reloc
603 section in dynobj and make room for this reloc. */
eb4267a3
ILT		 604 if (sreloc == NULL)
605 {
606 const char *name;
607
ede4eed4 608 name = (bfd_elf_string_from_elf_section
eb4267a3
ILT		 609 (abfd,
610 elf_elfheader (abfd)->e_shstrndx,
611 elf_section_data (sec)->rel_hdr.sh_name));
612 if (name == NULL)
613 return false;
614
615 BFD_ASSERT (strncmp (name, ".rel", 4) == 0
616 && strcmp (bfd_get_section_name (abfd, sec),
617 name + 4) == 0);
618
619 sreloc = bfd_get_section_by_name (dynobj, name);
620 if (sreloc == NULL)
621 {
ff12f303
ILT		 622 flagword flags;
623
eb4267a3 624 sreloc = bfd_make_section (dynobj, name);
ff12f303
ILT		 625 flags = (SEC_HAS_CONTENTS | SEC_READONLY
626 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
627 if ((sec->flags & SEC_ALLOC) != 0)
628 flags |= SEC_ALLOC | SEC_LOAD;
eb4267a3 629 if (sreloc == NULL
ff12f303 630 || ! bfd_set_section_flags (dynobj, sreloc, flags)
eb4267a3
ILT		 631 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
632 return false;
633 }
634 }
635
636 sreloc->_raw_size += sizeof (Elf32_External_Rel);
6e2183b1
ILT		 637
638 /* If we are linking with -Bsymbolic, and this is a
639 global symbol, we count the number of PC relative
640 relocations we have entered for this symbol, so that
641 we can discard them again if the symbol is later
642 defined by a regular object. Note that this function
643 is only called if we are using an elf_i386 linker
644 hash table, which means that h is really a pointer to
645 an elf_i386_link_hash_entry. */
6a1878c9
ILT		 646 if (h != NULL && info->symbolic
647 && ELF32_R_TYPE (rel->r_info) == R_386_PC32)
6e2183b1
ILT		 648 {
649 struct elf_i386_link_hash_entry *eh;
650 struct elf_i386_pcrel_relocs_copied *p;
651
652 eh = (struct elf_i386_link_hash_entry *) h;
653
654 for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
655 if (p->section == sreloc)
656 break;
657
658 if (p == NULL)
659 {
660 p = ((struct elf_i386_pcrel_relocs_copied *)
661 bfd_alloc (dynobj, sizeof *p));
662 if (p == NULL)
663 return false;
664 p->next = eh->pcrel_relocs_copied;
665 eh->pcrel_relocs_copied = p;
666 p->section = sreloc;
667 p->count = 0;
668 }
669
670 ++p->count;
671 }
eb4267a3 672 }
ff12f303 673
eb4267a3
ILT		 674 break;
675
676 default:
677 break;
678 }
679 }
013dec1a
ILT		 680
681 return true;
682}
683
684/* Adjust a symbol defined by a dynamic object and referenced by a
685 regular object. The current definition is in some section of the
686 dynamic object, but we're not including those sections. We have to
687 change the definition to something the rest of the link can
688 understand. */
689
690static boolean
691elf_i386_adjust_dynamic_symbol (info, h)
692 struct bfd_link_info *info;
693 struct elf_link_hash_entry *h;
694{
695 bfd *dynobj;
696 asection *s;
697 unsigned int power_of_two;
013dec1a
ILT		 698
699 dynobj = elf_hash_table (info)->dynobj;
700
701 /* Make sure we know what is going on here. */
3004a68c
ILT		 702 BFD_ASSERT (dynobj != NULL
703 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
452a5efb 704 || h->weakdef != NULL
3004a68c
ILT		 705 || ((h->elf_link_hash_flags
706 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
707 && (h->elf_link_hash_flags
708 & ELF_LINK_HASH_REF_REGULAR) != 0
709 && (h->elf_link_hash_flags
710 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
013dec1a
ILT		 711
712 /* If this is a function, put it in the procedure linkage table. We
713 will fill in the contents of the procedure linkage table later,
714 when we know the address of the .got section. */
12662be4
ILT		 715 if (h->type == STT_FUNC
716 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
013dec1a 717 {
ff12f303
ILT		 718 if (! info->shared
719 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
720 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0)
12662be4
ILT		 721 {
722 /* This case can occur if we saw a PLT32 reloc in an input
ff12f303
ILT		 723 file, but the symbol was never referred to by a dynamic
724 object. In such a case, we don't actually need to build
725 a procedure linkage table, and we can just do a PC32
726 reloc instead. */
12662be4
ILT		 727 BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
728 return true;
729 }
730
ff12f303
ILT		 731 /* Make sure this symbol is output as a dynamic symbol. */
732 if (h->dynindx == -1)
733 {
734 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
735 return false;
736 }
737
013dec1a
ILT		 738 s = bfd_get_section_by_name (dynobj, ".plt");
739 BFD_ASSERT (s != NULL);
740
12662be4
ILT		 741 /* If this is the first .plt entry, make room for the special
742 first entry. */
743 if (s->_raw_size == 0)
744 s->_raw_size += PLT_ENTRY_SIZE;
013dec1a 745
9b09a015
ILT		 746 /* If this symbol is not defined in a regular file, and we are
747 not generating a shared library, then set the symbol to this
748 location in the .plt. This is required to make function
749 pointers compare as equal between the normal executable and
750 the shared library. */
751 if (! info->shared
752 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
14cac507
ILT		 753 {
754 h->root.u.def.section = s;
755 h->root.u.def.value = s->_raw_size;
756 }
013dec1a 757
12662be4 758 h->plt_offset = s->_raw_size;
013dec1a 759
12662be4
ILT		 760 /* Make room for this entry. */
761 s->_raw_size += PLT_ENTRY_SIZE;
013dec1a 762
12662be4
ILT		 763 /* We also need to make an entry in the .got.plt section, which
764 will be placed in the .got section by the linker script. */
013dec1a 765
12662be4
ILT		 766 s = bfd_get_section_by_name (dynobj, ".got.plt");
767 BFD_ASSERT (s != NULL);
768 s->_raw_size += 4;
013dec1a 769
12662be4 770 /* We also need to make an entry in the .rel.plt section. */
eb4267a3 771
12662be4
ILT		 772 s = bfd_get_section_by_name (dynobj, ".rel.plt");
773 BFD_ASSERT (s != NULL);
774 s->_raw_size += sizeof (Elf32_External_Rel);
013dec1a
ILT		 775
776 return true;
777 }
778
779 /* If this is a weak symbol, and there is a real definition, the
780 processor independent code will have arranged for us to see the
781 real definition first, and we can just use the same value. */
782 if (h->weakdef != NULL)
783 {
30dc85f1
ILT		 784 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
785 || h->weakdef->root.type == bfd_link_hash_defweak);
013dec1a
ILT		 786 h->root.u.def.section = h->weakdef->root.u.def.section;
787 h->root.u.def.value = h->weakdef->root.u.def.value;
013dec1a
ILT		 788 return true;
789 }
790
791 /* This is a reference to a symbol defined by a dynamic object which
eb4267a3
ILT		 792 is not a function. */
793
794 /* If we are creating a shared library, we must presume that the
795 only references to the symbol are via the global offset table.
796 For such cases we need not do anything here; the relocations will
797 be handled correctly by relocate_section. */
798 if (info->shared)
799 return true;
800
801 /* We must allocate the symbol in our .dynbss section, which will
802 become part of the .bss section of the executable. There will be
803 an entry for this symbol in the .dynsym section. The dynamic
804 object will contain position independent code, so all references
805 from the dynamic object to this symbol will go through the global
806 offset table. The dynamic linker will use the .dynsym entry to
807 determine the address it must put in the global offset table, so
808 both the dynamic object and the regular object will refer to the
809 same memory location for the variable. */
013dec1a
ILT		 810
811 s = bfd_get_section_by_name (dynobj, ".dynbss");
812 BFD_ASSERT (s != NULL);
813
6e2183b1
ILT		 814 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
815 copy the initial value out of the dynamic object and into the
816 runtime process image. We need to remember the offset into the
817 .rel.bss section we are going to use. */
818 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
013dec1a
ILT		 819 {
820 asection *srel;
821
822 srel = bfd_get_section_by_name (dynobj, ".rel.bss");
823 BFD_ASSERT (srel != NULL);
013dec1a 824 srel->_raw_size += sizeof (Elf32_External_Rel);
eb4267a3 825 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
013dec1a
ILT		 826 }
827
828 /* We need to figure out the alignment required for this symbol. I
829 have no idea how ELF linkers handle this. */
7c6da9ca
ILT		 830 power_of_two = bfd_log2 (h->size);
831 if (power_of_two > 3)
832 power_of_two = 3;
013dec1a
ILT		 833
834 /* Apply the required alignment. */
7c6da9ca
ILT		 835 s->_raw_size = BFD_ALIGN (s->_raw_size,
836 (bfd_size_type) (1 << power_of_two));
013dec1a
ILT		 837 if (power_of_two > bfd_get_section_alignment (dynobj, s))
838 {
839 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
840 return false;
841 }
842
843 /* Define the symbol as being at this point in the section. */
844 h->root.u.def.section = s;
845 h->root.u.def.value = s->_raw_size;
846
847 /* Increment the section size to make room for the symbol. */
848 s->_raw_size += h->size;
849
850 return true;
851}
852
013dec1a
ILT		 853/* Set the sizes of the dynamic sections. */
854
855static boolean
856elf_i386_size_dynamic_sections (output_bfd, info)
857 bfd *output_bfd;
858 struct bfd_link_info *info;
859{
860 bfd *dynobj;
861 asection *s;
eb4267a3
ILT		 862 boolean plt;
863 boolean relocs;
864 boolean reltext;
013dec1a
ILT		 865
866 dynobj = elf_hash_table (info)->dynobj;
867 BFD_ASSERT (dynobj != NULL);
868
12662be4 869 if (elf_hash_table (info)->dynamic_sections_created)
8af74670 870 {
12662be4
ILT		 871 /* Set the contents of the .interp section to the interpreter. */
872 if (! info->shared)
873 {
874 s = bfd_get_section_by_name (dynobj, ".interp");
875 BFD_ASSERT (s != NULL);
876 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
877 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
878 }
879 }
880 else
881 {
882 /* We may have created entries in the .rel.got section.
883 However, if we are not creating the dynamic sections, we will
884 not actually use these entries. Reset the size of .rel.got,
885 which will cause it to get stripped from the output file
886 below. */
887 s = bfd_get_section_by_name (dynobj, ".rel.got");
888 if (s != NULL)
889 s->_raw_size = 0;
8af74670 890 }
013dec1a 891
6e2183b1
ILT		 892 /* If this is a -Bsymbolic shared link, then we need to discard all
893 PC relative relocs against symbols defined in a regular object.
894 We allocated space for them in the check_relocs routine, but we
895 will not fill them in in the relocate_section routine. */
896 if (info->shared && info->symbolic)
897 elf_i386_link_hash_traverse (elf_i386_hash_table (info),
898 elf_i386_discard_copies,
899 (PTR) NULL);
900
eb4267a3
ILT		 901 /* The check_relocs and adjust_dynamic_symbol entry points have
902 determined the sizes of the various dynamic sections. Allocate
903 memory for them. */
904 plt = false;
905 relocs = false;
906 reltext = false;
907 for (s = dynobj->sections; s != NULL; s = s->next)
908 {
909 const char *name;
910 boolean strip;
911
ff12f303 912 if ((s->flags & SEC_LINKER_CREATED) == 0)
eb4267a3
ILT		 913 continue;
914
915 /* It's OK to base decisions on the section name, because none
916 of the dynobj section names depend upon the input files. */
917 name = bfd_get_section_name (dynobj, s);
918
919 strip = false;
920
921 if (strcmp (name, ".plt") == 0)
922 {
923 if (s->_raw_size == 0)
924 {
925 /* Strip this section if we don't need it; see the
926 comment below. */
927 strip = true;
928 }
929 else
930 {
931 /* Remember whether there is a PLT. */
932 plt = true;
933 }
934 }
935 else if (strncmp (name, ".rel", 4) == 0)
936 {
937 if (s->_raw_size == 0)
938 {
939 /* If we don't need this section, strip it from the
940 output file. This is mostly to handle .rel.bss and
941 .rel.plt. We must create both sections in
942 create_dynamic_sections, because they must be created
943 before the linker maps input sections to output
944 sections. The linker does that before
945 adjust_dynamic_symbol is called, and it is that
946 function which decides whether anything needs to go
947 into these sections. */
948 strip = true;
949 }
950 else
951 {
952 asection *target;
953
954 /* Remember whether there are any reloc sections other
955 than .rel.plt. */
956 if (strcmp (name, ".rel.plt") != 0)
3c38b3df 957 {
6e2183b1
ILT		 958 const char *outname;
959
3c38b3df
ILT		 960 relocs = true;
961
962 /* If this relocation section applies to a read only
963 section, then we probably need a DT_TEXTREL
964 entry. The entries in the .rel.plt section
965 really apply to the .got section, which we
966 created ourselves and so know is not readonly. */
6e2183b1
ILT		 967 outname = bfd_get_section_name (output_bfd,
968 s->output_section);
969 target = bfd_get_section_by_name (output_bfd, outname + 4);
3c38b3df
ILT		 970 if (target != NULL
971 && (target->flags & SEC_READONLY) != 0)
972 reltext = true;
973 }
eb4267a3
ILT		 974
975 /* We use the reloc_count field as a counter if we need
976 to copy relocs into the output file. */
977 s->reloc_count = 0;
978 }
979 }
980 else if (strncmp (name, ".got", 4) != 0)
981 {
982 /* It's not one of our sections, so don't allocate space. */
983 continue;
984 }
985
986 if (strip)
987 {
988 asection **spp;
989
990 for (spp = &s->output_section->owner->sections;
991 *spp != s->output_section;
992 spp = &(*spp)->next)
993 ;
994 *spp = s->output_section->next;
995 --s->output_section->owner->section_count;
996
997 continue;
998 }
013dec1a 999
eb4267a3
ILT		 1000 /* Allocate memory for the section contents. */
1001 s->contents = (bfd_byte *) bfd_alloc (dynobj, s->_raw_size);
1002 if (s->contents == NULL && s->_raw_size != 0)
3c38b3df 1003 return false;
eb4267a3 1004 }
ff12f303 1005
12662be4 1006 if (elf_hash_table (info)->dynamic_sections_created)
eb4267a3 1007 {
12662be4
ILT		 1008 /* Add some entries to the .dynamic section. We fill in the
1009 values later, in elf_i386_finish_dynamic_sections, but we
1010 must add the entries now so that we get the correct size for
1011 the .dynamic section. The DT_DEBUG entry is filled in by the
1012 dynamic linker and used by the debugger. */
1013 if (! info->shared)
1014 {
1015 if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0))
1016 return false;
1017 }
013dec1a 1018
12662be4
ILT		 1019 if (plt)
1020 {
1021 if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0)
1022 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
1023 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_REL)
1024 || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
1025 return false;
1026 }
013dec1a 1027
12662be4
ILT		 1028 if (relocs)
1029 {
1030 if (! bfd_elf32_add_dynamic_entry (info, DT_REL, 0)
1031 || ! bfd_elf32_add_dynamic_entry (info, DT_RELSZ, 0)
1032 || ! bfd_elf32_add_dynamic_entry (info, DT_RELENT,
1033 sizeof (Elf32_External_Rel)))
1034 return false;
1035 }
013dec1a 1036
12662be4
ILT		 1037 if (reltext)
1038 {
1039 if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0))
1040 return false;
1041 }
eb4267a3
ILT		 1042 }
1043
013dec1a
ILT		 1044 return true;
1045}
1046
6e2183b1
ILT		 1047/* This function is called via elf_i386_link_hash_traverse if we are
1048 creating a shared object with -Bsymbolic. It discards the space
1049 allocated to copy PC relative relocs against symbols which are
1050 defined in regular objects. We allocated space for them in the
1051 check_relocs routine, but we won't fill them in in the
1052 relocate_section routine. */
1053
1054/*ARGSUSED*/
1055static boolean
1056elf_i386_discard_copies (h, ignore)
1057 struct elf_i386_link_hash_entry *h;
1058 PTR ignore;
1059{
1060 struct elf_i386_pcrel_relocs_copied *s;
1061
1062 /* We only discard relocs for symbols defined in a regular object. */
1063 if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1064 return true;
1065
1066 for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
1067 s->section->_raw_size -= s->count * sizeof (Elf32_External_Rel);
1068
1069 return true;
1070}
1071
013dec1a
ILT		 1072/* Relocate an i386 ELF section. */
1073
1074static boolean
1075elf_i386_relocate_section (output_bfd, info, input_bfd, input_section,
eb4267a3 1076 contents, relocs, local_syms, local_sections)
013dec1a
ILT		 1077 bfd *output_bfd;
1078 struct bfd_link_info *info;
1079 bfd *input_bfd;
1080 asection *input_section;
1081 bfd_byte *contents;
1082 Elf_Internal_Rela *relocs;
1083 Elf_Internal_Sym *local_syms;
1084 asection **local_sections;
1085{
eb4267a3 1086 bfd *dynobj;
013dec1a 1087 Elf_Internal_Shdr *symtab_hdr;
eb4267a3
ILT		 1088 struct elf_link_hash_entry **sym_hashes;
1089 bfd_vma *local_got_offsets;
1090 asection *sgot;
1091 asection *splt;
1092 asection *sreloc;
013dec1a
ILT		 1093 Elf_Internal_Rela *rel;
1094 Elf_Internal_Rela *relend;
1095
eb4267a3 1096 dynobj = elf_hash_table (info)->dynobj;
013dec1a 1097 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
eb4267a3
ILT		 1098 sym_hashes = elf_sym_hashes (input_bfd);
1099 local_got_offsets = elf_local_got_offsets (input_bfd);
1100
1101 sgot = NULL;
1102 splt = NULL;
1103 sreloc = NULL;
013dec1a
ILT		 1104
1105 rel = relocs;
1106 relend = relocs + input_section->reloc_count;
1107 for (; rel < relend; rel++)
1108 {
1109 int r_type;
82b1edf7 1110 reloc_howto_type *howto;
3b3f7625 1111 unsigned long r_symndx;
013dec1a
ILT		 1112 struct elf_link_hash_entry *h;
1113 Elf_Internal_Sym *sym;
1114 asection *sec;
1115 bfd_vma relocation;
1116 bfd_reloc_status_type r;
1117
1118 r_type = ELF32_R_TYPE (rel->r_info);
ff12f303
ILT		 1119 if (r_type < 0
1120 || r_type >= (int) R_386_max
1121 || (r_type >= (int) FIRST_INVALID_RELOC
1122 && r_type <= (int) LAST_INVALID_RELOC))
013dec1a
ILT		 1123 {
1124 bfd_set_error (bfd_error_bad_value);
1125 return false;
1126 }
1127 howto = elf_howto_table + r_type;
1128
1129 r_symndx = ELF32_R_SYM (rel->r_info);
1130
1131 if (info->relocateable)
1132 {
1133 /* This is a relocateable link. We don't have to change
1134 anything, unless the reloc is against a section symbol,
1135 in which case we have to adjust according to where the
1136 section symbol winds up in the output section. */
1137 if (r_symndx < symtab_hdr->sh_info)
1138 {
1139 sym = local_syms + r_symndx;
1140 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1141 {
1142 bfd_vma val;
1143
1144 sec = local_sections[r_symndx];
1145 val = bfd_get_32 (input_bfd, contents + rel->r_offset);
1146 val += sec->output_offset + sym->st_value;
1147 bfd_put_32 (input_bfd, val, contents + rel->r_offset);
1148 }
1149 }
1150
1151 continue;
1152 }
1153
1154 /* This is a final link. */
1155 h = NULL;
1156 sym = NULL;
1157 sec = NULL;
1158 if (r_symndx < symtab_hdr->sh_info)
1159 {
1160 sym = local_syms + r_symndx;
1161 sec = local_sections[r_symndx];
1162 relocation = (sec->output_section->vma
1163 + sec->output_offset
1164 + sym->st_value);
1165 }
1166 else
1167 {
eb4267a3 1168 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
cf5138e3
ILT		 1169 while (h->root.type == bfd_link_hash_indirect
1170 || h->root.type == bfd_link_hash_warning)
1171 h = (struct elf_link_hash_entry *) h->root.u.i.link;
30dc85f1
ILT		 1172 if (h->root.type == bfd_link_hash_defined
1173 || h->root.type == bfd_link_hash_defweak)
013dec1a
ILT		 1174 {
1175 sec = h->root.u.def.section;
9b09a015
ILT		 1176 if (r_type == R_386_GOTPC
1177 || (r_type == R_386_PLT32
1178 && h->plt_offset != (bfd_vma) -1)
1179 || (r_type == R_386_GOT32
452a5efb
ILT		 1180 && elf_hash_table (info)->dynamic_sections_created
1181 && (! info->shared
8519ea21 1182 || (! info->symbolic && h->dynindx != -1)
452a5efb
ILT		 1183 || (h->elf_link_hash_flags
1184 & ELF_LINK_HASH_DEF_REGULAR) == 0))
9b09a015 1185 || (info->shared
6a1878c9 1186 && ((! info->symbolic && h->dynindx != -1)
53787b23
ILT		 1187 || (h->elf_link_hash_flags
1188 & ELF_LINK_HASH_DEF_REGULAR) == 0)
9b09a015 1189 && (r_type == R_386_32
ff12f303 1190 || r_type == R_386_PC32)))
9b09a015
ILT		 1191 {
1192 /* In these cases, we don't need the relocation
1193 value. We check specially because in some
1194 obscure cases sec->output_section will be NULL. */
1195 relocation = 0;
1196 }
ff12f303
ILT		 1197 else if (sec->output_section == NULL)
1198 {
1199 (*_bfd_error_handler)
1200 ("%s: warning: unresolvable relocation against symbol `%s' from %s section",
1201 bfd_get_filename (input_bfd), h->root.root.string,
1202 bfd_get_section_name (input_bfd, input_section));
1203 relocation = 0;
1204 }
9b09a015
ILT		 1205 else
1206 relocation = (h->root.u.def.value
1207 + sec->output_section->vma
1208 + sec->output_offset);
013dec1a 1209 }
30dc85f1 1210 else if (h->root.type == bfd_link_hash_undefweak)
013dec1a 1211 relocation = 0;
452a5efb 1212 else if (info->shared && !info->symbolic)
eb4267a3 1213 relocation = 0;
013dec1a
ILT		 1214 else
1215 {
1216 if (! ((*info->callbacks->undefined_symbol)
1217 (info, h->root.root.string, input_bfd,
1218 input_section, rel->r_offset)))
1219 return false;
1220 relocation = 0;
1221 }
1222 }
1223
eb4267a3
ILT		 1224 switch (r_type)
1225 {
1226 case R_386_GOT32:
1227 /* Relocation is to the entry for this symbol in the global
1228 offset table. */
1229 if (sgot == NULL)
1230 {
1231 sgot = bfd_get_section_by_name (dynobj, ".got");
1232 BFD_ASSERT (sgot != NULL);
1233 }
1234
1235 if (h != NULL)
1236 {
12662be4
ILT		 1237 bfd_vma off;
1238
1239 off = h->got_offset;
1240 BFD_ASSERT (off != (bfd_vma) -1);
1241
452a5efb
ILT		 1242 if (! elf_hash_table (info)->dynamic_sections_created
1243 || (info->shared
8519ea21 1244 && (info->symbolic || h->dynindx == -1)
452a5efb 1245 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
12662be4 1246 {
452a5efb
ILT		 1247 /* This is actually a static link, or it is a
1248 -Bsymbolic link and the symbol is defined
8519ea21
ILT		 1249 locally, or the symbol was forced to be local
1250 because of a version file. We must initialize
1251 this entry in the global offset table. Since the
1252 offset must always be a multiple of 4, we use the
1253 least significant bit to record whether we have
452a5efb 1254 initialized it already.
12662be4
ILT		 1255
1256 When doing a dynamic link, we create a .rel.got
1257 relocation entry to initialize the value. This
1258 is done in the finish_dynamic_symbol routine. */
1259 if ((off & 1) != 0)
1260 off &= ~1;
1261 else
1262 {
1263 bfd_put_32 (output_bfd, relocation,
1264 sgot->contents + off);
1265 h->got_offset |= 1;
1266 }
1267 }
1268
1269 relocation = sgot->output_offset + off;
eb4267a3
ILT		 1270 }
1271 else
1272 {
1273 bfd_vma off;
1274
1275 BFD_ASSERT (local_got_offsets != NULL
1276 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1277
1278 off = local_got_offsets[r_symndx];
1279
1280 /* The offset must always be a multiple of 4. We use
1281 the least significant bit to record whether we have
1282 already generated the necessary reloc. */
1283 if ((off & 1) != 0)
1284 off &= ~1;
1285 else
1286 {
eb4267a3
ILT		 1287 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1288
12662be4
ILT		 1289 if (info->shared)
1290 {
1291 asection *srelgot;
1292 Elf_Internal_Rel outrel;
1293
1294 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
1295 BFD_ASSERT (srelgot != NULL);
1296
1297 outrel.r_offset = (sgot->output_section->vma
1298 + sgot->output_offset
1299 + off);
1300 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1301 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1302 (((Elf32_External_Rel *)
1303 srelgot->contents)
1304 + srelgot->reloc_count));
1305 ++srelgot->reloc_count;
1306 }
eb4267a3
ILT		 1307
1308 local_got_offsets[r_symndx] |= 1;
1309 }
1310
1311 relocation = sgot->output_offset + off;
1312 }
1313
1314 break;
1315
1316 case R_386_GOTOFF:
1317 /* Relocation is relative to the start of the global offset
1318 table. */
1319
1320 if (sgot == NULL)
1321 {
1322 sgot = bfd_get_section_by_name (dynobj, ".got");
1323 BFD_ASSERT (sgot != NULL);
1324 }
1325
1326 /* Note that sgot->output_offset is not involved in this
1327 calculation. We always want the start of .got. If we
1328 defined _GLOBAL_OFFSET_TABLE in a different way, as is
1329 permitted by the ABI, we might have to change this
1330 calculation. */
1331 relocation -= sgot->output_section->vma;
1332
1333 break;
1334
1335 case R_386_GOTPC:
1336 /* Use global offset table as symbol value. */
1337
1338 if (sgot == NULL)
1339 {
1340 sgot = bfd_get_section_by_name (dynobj, ".got");
1341 BFD_ASSERT (sgot != NULL);
1342 }
1343
1344 relocation = sgot->output_section->vma;
1345
1346 break;
1347
1348 case R_386_PLT32:
1349 /* Relocation is to the entry for this symbol in the
1350 procedure linkage table. */
1351
1352 /* Resolve a PLT32 reloc again a local symbol directly,
1353 without using the procedure linkage table. */
1354 if (h == NULL)
1355 break;
1356
12662be4
ILT		 1357 if (h->plt_offset == (bfd_vma) -1)
1358 {
1359 /* We didn't make a PLT entry for this symbol. This
452a5efb
ILT		 1360 happens when statically linking PIC code, or when
1361 using -Bsymbolic. */
12662be4
ILT		 1362 break;
1363 }
1364
eb4267a3
ILT		 1365 if (splt == NULL)
1366 {
1367 splt = bfd_get_section_by_name (dynobj, ".plt");
1368 BFD_ASSERT (splt != NULL);
1369 }
1370
eb4267a3
ILT		 1371 relocation = (splt->output_section->vma
1372 + splt->output_offset
1373 + h->plt_offset);
1374
1375 break;
1376
1377 case R_386_32:
1378 case R_386_PC32:
1379 if (info->shared
53787b23
ILT		 1380 && (r_type != R_386_PC32
1381 || (h != NULL
1382 && (! info->symbolic
1383 || (h->elf_link_hash_flags
1384 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
eb4267a3
ILT		 1385 {
1386 Elf_Internal_Rel outrel;
6e2183b1 1387 boolean skip, relocate;
eb4267a3
ILT		 1388
1389 /* When generating a shared object, these relocations
1390 are copied into the output file to be resolved at run
1391 time. */
1392
1393 if (sreloc == NULL)
1394 {
1d5d75e9
ILT		 1395 const char *name;
1396
1397 name = (bfd_elf_string_from_elf_section
eb4267a3
ILT		 1398 (input_bfd,
1399 elf_elfheader (input_bfd)->e_shstrndx,
1400 elf_section_data (input_section)->rel_hdr.sh_name));
1d5d75e9 1401 if (name == NULL)
eb4267a3
ILT		 1402 return false;
1403
1d5d75e9 1404 BFD_ASSERT (strncmp (name, ".rel", 4) == 0
eb4267a3
ILT		 1405 && strcmp (bfd_get_section_name (input_bfd,
1406 input_section),
1d5d75e9 1407 name + 4) == 0);
eb4267a3 1408
1d5d75e9 1409 sreloc = bfd_get_section_by_name (dynobj, name);
eb4267a3
ILT		 1410 BFD_ASSERT (sreloc != NULL);
1411 }
1412
6e2183b1
ILT		 1413 skip = false;
1414
1415 if (elf_section_data (input_section)->stab_info == NULL)
1416 outrel.r_offset = rel->r_offset;
1417 else
1418 {
1419 bfd_vma off;
1420
1421 off = (_bfd_stab_section_offset
1422 (output_bfd, &elf_hash_table (info)->stab_info,
1423 input_section,
1424 &elf_section_data (input_section)->stab_info,
1425 rel->r_offset));
1426 if (off == (bfd_vma) -1)
1427 skip = true;
1428 outrel.r_offset = off;
1429 }
1430
1431 outrel.r_offset += (input_section->output_section->vma
1432 + input_section->output_offset);
1433
1434 if (skip)
1435 {
1436 memset (&outrel, 0, sizeof outrel);
1437 relocate = false;
1438 }
1439 else if (r_type == R_386_PC32)
eb4267a3 1440 {
1d5d75e9 1441 BFD_ASSERT (h != NULL && h->dynindx != -1);
53787b23 1442 relocate = false;
1d5d75e9 1443 outrel.r_info = ELF32_R_INFO (h->dynindx, R_386_PC32);
eb4267a3
ILT		 1444 }
1445 else
1446 {
6e2183b1
ILT		 1447 /* h->dynindx may be -1 if this symbol was marked to
1448 become local. */
53787b23 1449 if (h == NULL
6e2183b1 1450 || ((info->symbolic || h->dynindx == -1)
53787b23
ILT		 1451 && (h->elf_link_hash_flags
1452 & ELF_LINK_HASH_DEF_REGULAR) != 0))
1453 {
1454 relocate = true;
1455 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1456 }
eb4267a3
ILT		 1457 else
1458 {
3b3f7625 1459 BFD_ASSERT (h->dynindx != -1);
53787b23 1460 relocate = false;
eb4267a3
ILT		 1461 outrel.r_info = ELF32_R_INFO (h->dynindx, R_386_32);
1462 }
1463 }
1464
1465 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1466 (((Elf32_External_Rel *)
1467 sreloc->contents)
1468 + sreloc->reloc_count));
1469 ++sreloc->reloc_count;
1470
1471 /* If this reloc is against an external symbol, we do
1472 not want to fiddle with the addend. Otherwise, we
1473 need to include the symbol value so that it becomes
1474 an addend for the dynamic reloc. */
53787b23 1475 if (! relocate)
eb4267a3
ILT		 1476 continue;
1477 }
1478
1479 break;
1480
1481 default:
1482 break;
1483 }
1484
013dec1a
ILT		 1485 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1486 contents, rel->r_offset,
1487 relocation, (bfd_vma) 0);
1488
1489 if (r != bfd_reloc_ok)
1490 {
1491 switch (r)
1492 {
1493 default:
1494 case bfd_reloc_outofrange:
1495 abort ();
1496 case bfd_reloc_overflow:
1497 {
1498 const char *name;
1499
1500 if (h != NULL)
1501 name = h->root.root.string;
1502 else
1503 {
ede4eed4
KR		 1504 name = bfd_elf_string_from_elf_section (input_bfd,
1505 symtab_hdr->sh_link,
1506 sym->st_name);
013dec1a
ILT		 1507 if (name == NULL)
1508 return false;
1509 if (*name == '\0')
1510 name = bfd_section_name (input_bfd, sec);
1511 }
1512 if (! ((*info->callbacks->reloc_overflow)
1513 (info, name, howto->name, (bfd_vma) 0,
1514 input_bfd, input_section, rel->r_offset)))
1515 return false;
1516 }
1517 break;
1518 }
1519 }
1520 }
1521
1522 return true;
1523}
1524
1525/* Finish up dynamic symbol handling. We set the contents of various
1526 dynamic sections here. */
1527
1528static boolean
1529elf_i386_finish_dynamic_symbol (output_bfd, info, h, sym)
1530 bfd *output_bfd;
1531 struct bfd_link_info *info;
1532 struct elf_link_hash_entry *h;
1533 Elf_Internal_Sym *sym;
1534{
eb4267a3 1535 bfd *dynobj;
013dec1a 1536
eb4267a3 1537 dynobj = elf_hash_table (info)->dynobj;
013dec1a 1538
eb4267a3 1539 if (h->plt_offset != (bfd_vma) -1)
013dec1a
ILT		 1540 {
1541 asection *splt;
1542 asection *sgot;
1543 asection *srel;
1544 bfd_vma plt_index;
1545 bfd_vma got_offset;
1546 Elf_Internal_Rel rel;
1547
eb4267a3
ILT		 1548 /* This symbol has an entry in the procedure linkage table. Set
1549 it up. */
013dec1a 1550
eb4267a3
ILT		 1551 BFD_ASSERT (h->dynindx != -1);
1552
1553 splt = bfd_get_section_by_name (dynobj, ".plt");
1554 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1555 srel = bfd_get_section_by_name (dynobj, ".rel.plt");
1556 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
013dec1a
ILT		 1557
1558 /* Get the index in the procedure linkage table which
1559 corresponds to this symbol. This is the index of this symbol
1560 in all the symbols for which we are making plt entries. The
1561 first entry in the procedure linkage table is reserved. */
eb4267a3 1562 plt_index = h->plt_offset / PLT_ENTRY_SIZE - 1;
013dec1a
ILT		 1563
1564 /* Get the offset into the .got table of the entry that
1565 corresponds to this function. Each .got entry is 4 bytes.
1566 The first three are reserved. */
1567 got_offset = (plt_index + 3) * 4;
1568
1569 /* Fill in the entry in the procedure linkage table. */
eb4267a3
ILT		 1570 if (! info->shared)
1571 {
1572 memcpy (splt->contents + h->plt_offset, elf_i386_plt_entry,
1573 PLT_ENTRY_SIZE);
1574 bfd_put_32 (output_bfd,
1575 (sgot->output_section->vma
1576 + sgot->output_offset
1577 + got_offset),
1578 splt->contents + h->plt_offset + 2);
1579 }
1580 else
1581 {
1582 memcpy (splt->contents + h->plt_offset, elf_i386_pic_plt_entry,
1583 PLT_ENTRY_SIZE);
1584 bfd_put_32 (output_bfd, got_offset,
1585 splt->contents + h->plt_offset + 2);
1586 }
1587
013dec1a 1588 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
eb4267a3
ILT		 1589 splt->contents + h->plt_offset + 7);
1590 bfd_put_32 (output_bfd, - (h->plt_offset + PLT_ENTRY_SIZE),
1591 splt->contents + h->plt_offset + 12);
013dec1a
ILT		 1592
1593 /* Fill in the entry in the global offset table. */
1594 bfd_put_32 (output_bfd,
1595 (splt->output_section->vma
1596 + splt->output_offset
eb4267a3 1597 + h->plt_offset
013dec1a
ILT		 1598 + 6),
1599 sgot->contents + got_offset);
1600
1601 /* Fill in the entry in the .rel.plt section. */
1602 rel.r_offset = (sgot->output_section->vma
1603 + sgot->output_offset
1604 + got_offset);
1605 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
1606 bfd_elf32_swap_reloc_out (output_bfd, &rel,
1607 ((Elf32_External_Rel *) srel->contents
1608 + plt_index));
1609
eb4267a3
ILT		 1610 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1611 {
1612 /* Mark the symbol as undefined, rather than as defined in
1613 the .plt section. Leave the value alone. */
1614 sym->st_shndx = SHN_UNDEF;
1615 }
013dec1a 1616 }
eb4267a3
ILT		 1617
1618 if (h->got_offset != (bfd_vma) -1)
013dec1a 1619 {
eb4267a3
ILT		 1620 asection *sgot;
1621 asection *srel;
1622 Elf_Internal_Rel rel;
013dec1a 1623
eb4267a3
ILT		 1624 /* This symbol has an entry in the global offset table. Set it
1625 up. */
ff12f303 1626
eb4267a3
ILT		 1627 sgot = bfd_get_section_by_name (dynobj, ".got");
1628 srel = bfd_get_section_by_name (dynobj, ".rel.got");
1629 BFD_ASSERT (sgot != NULL && srel != NULL);
1630
eb4267a3
ILT		 1631 rel.r_offset = (sgot->output_section->vma
1632 + sgot->output_offset
452a5efb
ILT		 1633 + (h->got_offset &~ 1));
1634
1635 /* If this is a -Bsymbolic link, and the symbol is defined
8519ea21
ILT		 1636 locally, we just want to emit a RELATIVE reloc. Likewise if
1637 the symbol was forced to be local because of a version file.
1638 The entry in the global offset table will already have been
1639 initialized in the relocate_section function. */
452a5efb 1640 if (info->shared
8519ea21 1641 && (info->symbolic || h->dynindx == -1)
452a5efb
ILT		 1642 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
1643 rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1644 else
1645 {
1646 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got_offset);
1647 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
1648 }
1649
eb4267a3
ILT		 1650 bfd_elf32_swap_reloc_out (output_bfd, &rel,
1651 ((Elf32_External_Rel *) srel->contents
1652 + srel->reloc_count));
1653 ++srel->reloc_count;
1654 }
1655
1656 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
1657 {
1658 asection *s;
1659 Elf_Internal_Rel rel;
1660
1661 /* This symbol needs a copy reloc. Set it up. */
1662
1663 BFD_ASSERT (h->dynindx != -1
30dc85f1
ILT		 1664 && (h->root.type == bfd_link_hash_defined
1665 || h->root.type == bfd_link_hash_defweak));
eb4267a3
ILT		 1666
1667 s = bfd_get_section_by_name (h->root.u.def.section->owner,
1668 ".rel.bss");
1669 BFD_ASSERT (s != NULL);
1670
1671 rel.r_offset = (h->root.u.def.value
1672 + h->root.u.def.section->output_section->vma
1673 + h->root.u.def.section->output_offset);
1674 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
1675 bfd_elf32_swap_reloc_out (output_bfd, &rel,
1676 ((Elf32_External_Rel *) s->contents
1677 + s->reloc_count));
1678 ++s->reloc_count;
013dec1a
ILT		 1679 }
1680
eb4267a3
ILT		 1681 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
1682 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
1683 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1684 sym->st_shndx = SHN_ABS;
1685
013dec1a
ILT		 1686 return true;
1687}
1688
1689/* Finish up the dynamic sections. */
1690
1691static boolean
1692elf_i386_finish_dynamic_sections (output_bfd, info)
1693 bfd *output_bfd;
1694 struct bfd_link_info *info;
1695{
eb4267a3 1696 bfd *dynobj;
013dec1a
ILT		 1697 asection *sgot;
1698 asection *sdyn;
013dec1a 1699
eb4267a3
ILT		 1700 dynobj = elf_hash_table (info)->dynobj;
1701
eb4267a3 1702 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
12662be4 1703 BFD_ASSERT (sgot != NULL);
eb4267a3 1704 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
013dec1a 1705
12662be4 1706 if (elf_hash_table (info)->dynamic_sections_created)
013dec1a 1707 {
12662be4
ILT		 1708 asection *splt;
1709 Elf32_External_Dyn *dyncon, *dynconend;
013dec1a 1710
12662be4
ILT		 1711 splt = bfd_get_section_by_name (dynobj, ".plt");
1712 BFD_ASSERT (splt != NULL && sdyn != NULL);
013dec1a 1713
12662be4
ILT		 1714 dyncon = (Elf32_External_Dyn *) sdyn->contents;
1715 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
1716 for (; dyncon < dynconend; dyncon++)
013dec1a 1717 {
12662be4
ILT		 1718 Elf_Internal_Dyn dyn;
1719 const char *name;
1720 asection *s;
eb4267a3 1721
12662be4 1722 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
eb4267a3 1723
12662be4 1724 switch (dyn.d_tag)
013dec1a 1725 {
12662be4
ILT		 1726 default:
1727 break;
1728
1729 case DT_PLTGOT:
1730 name = ".got";
1731 goto get_vma;
1732 case DT_JMPREL:
1733 name = ".rel.plt";
1734 get_vma:
1735 s = bfd_get_section_by_name (output_bfd, name);
1736 BFD_ASSERT (s != NULL);
1737 dyn.d_un.d_ptr = s->vma;
1738 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1739 break;
1740
1741 case DT_PLTRELSZ:
1742 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
1743 BFD_ASSERT (s != NULL);
013dec1a 1744 if (s->_cooked_size != 0)
12662be4 1745 dyn.d_un.d_val = s->_cooked_size;
013dec1a 1746 else
12662be4
ILT		 1747 dyn.d_un.d_val = s->_raw_size;
1748 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1749 break;
1750
1751 case DT_RELSZ:
1752 /* My reading of the SVR4 ABI indicates that the
1753 procedure linkage table relocs (DT_JMPREL) should be
1754 included in the overall relocs (DT_REL). This is
1755 what Solaris does. However, UnixWare can not handle
1756 that case. Therefore, we override the DT_RELSZ entry
1757 here to make it not include the JMPREL relocs. Since
1758 the linker script arranges for .rel.plt to follow all
1759 other relocation sections, we don't have to worry
1760 about changing the DT_REL entry. */
1761 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
1762 if (s != NULL)
1763 {
1764 if (s->_cooked_size != 0)
1765 dyn.d_un.d_val -= s->_cooked_size;
1766 else
1767 dyn.d_un.d_val -= s->_raw_size;
1768 }
1769 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1770 break;
013dec1a 1771 }
013dec1a 1772 }
013dec1a 1773
12662be4
ILT		 1774 /* Fill in the first entry in the procedure linkage table. */
1775 if (splt->_raw_size > 0)
eb4267a3 1776 {
12662be4
ILT		 1777 if (info->shared)
1778 memcpy (splt->contents, elf_i386_pic_plt0_entry, PLT_ENTRY_SIZE);
1779 else
1780 {
1781 memcpy (splt->contents, elf_i386_plt0_entry, PLT_ENTRY_SIZE);
1782 bfd_put_32 (output_bfd,
1783 sgot->output_section->vma + sgot->output_offset + 4,
1784 splt->contents + 2);
1785 bfd_put_32 (output_bfd,
1786 sgot->output_section->vma + sgot->output_offset + 8,
1787 splt->contents + 8);
1788 }
eb4267a3 1789 }
12662be4
ILT		 1790
1791 /* UnixWare sets the entsize of .plt to 4, although that doesn't
1792 really seem like the right value. */
1793 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
013dec1a
ILT		 1794 }
1795
1796 /* Fill in the first three entries in the global offset table. */
1797 if (sgot->_raw_size > 0)
1798 {
12662be4
ILT		 1799 if (sdyn == NULL)
1800 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
1801 else
1802 bfd_put_32 (output_bfd,
1803 sdyn->output_section->vma + sdyn->output_offset,
1804 sgot->contents);
013dec1a
ILT		 1805 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
1806 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
1807 }
1808
1809 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
1810
013dec1a
ILT		 1811 return true;
1812}
e4b6b3e7
ILT		 1813
1814#define TARGET_LITTLE_SYM bfd_elf32_i386_vec
1815#define TARGET_LITTLE_NAME "elf32-i386"
1816#define ELF_ARCH bfd_arch_i386
68241b2b 1817#define ELF_MACHINE_CODE EM_386
6e2183b1 1818#define ELF_MAXPAGESIZE 0x1000
e4b6b3e7
ILT		 1819#define elf_info_to_howto elf_i386_info_to_howto
1820#define elf_info_to_howto_rel elf_i386_info_to_howto_rel
1821#define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
6e2183b1
ILT		 1822#define bfd_elf32_bfd_is_local_label_name \
1823 elf_i386_is_local_label_name
013dec1a 1824#define elf_backend_create_dynamic_sections \
ede4eed4 1825 _bfd_elf_create_dynamic_sections
6e2183b1
ILT		 1826#define bfd_elf32_bfd_link_hash_table_create \
1827 elf_i386_link_hash_table_create
eb4267a3 1828#define elf_backend_check_relocs elf_i386_check_relocs
013dec1a
ILT		 1829#define elf_backend_adjust_dynamic_symbol \
1830 elf_i386_adjust_dynamic_symbol
1831#define elf_backend_size_dynamic_sections \
1832 elf_i386_size_dynamic_sections
1833#define elf_backend_relocate_section elf_i386_relocate_section
1834#define elf_backend_finish_dynamic_symbol \
1835 elf_i386_finish_dynamic_symbol
1836#define elf_backend_finish_dynamic_sections \
1837 elf_i386_finish_dynamic_sections
ede4eed4 1838#define elf_backend_want_got_plt 1
3b3f7625 1839#define elf_backend_plt_readonly 1
ede4eed4 1840#define elf_backend_want_plt_sym 0
e4b6b3e7
ILT		 1841
1842#include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.279501 seconds and 4 git commands to generate.