OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [bfd/] [elf32-i386.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 578 markom
/* Intel 80386/80486-specific support for 32-bit ELF
2
   Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
3
   Free Software Foundation, Inc.
4
 
5
This file is part of BFD, the Binary File Descriptor library.
6
 
7
This program is free software; you can redistribute it and/or modify
8
it under the terms of the GNU General Public License as published by
9
the Free Software Foundation; either version 2 of the License, or
10
(at your option) any later version.
11
 
12
This program is distributed in the hope that it will be useful,
13
but WITHOUT ANY WARRANTY; without even the implied warranty of
14
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
GNU General Public License for more details.
16
 
17
You should have received a copy of the GNU General Public License
18
along with this program; if not, write to the Free Software
19
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
20
 
21
#include "bfd.h"
22
#include "sysdep.h"
23
#include "bfdlink.h"
24
#include "libbfd.h"
25
#include "elf-bfd.h"
26
 
27
static reloc_howto_type *elf_i386_reloc_type_lookup
28
  PARAMS ((bfd *, bfd_reloc_code_real_type));
29
static void elf_i386_info_to_howto
30
  PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *));
31
static void elf_i386_info_to_howto_rel
32
  PARAMS ((bfd *, arelent *, Elf32_Internal_Rel *));
33
static boolean elf_i386_is_local_label_name PARAMS ((bfd *, const char *));
34
static struct bfd_hash_entry *elf_i386_link_hash_newfunc
35
  PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
36
static struct bfd_link_hash_table *elf_i386_link_hash_table_create
37
  PARAMS ((bfd *));
38
static boolean create_got_section PARAMS((bfd *, struct bfd_link_info *));
39
static boolean elf_i386_create_dynamic_sections
40
  PARAMS((bfd *, struct bfd_link_info *));
41
static boolean elf_i386_check_relocs
42
  PARAMS ((bfd *, struct bfd_link_info *, asection *,
43
           const Elf_Internal_Rela *));
44
static boolean elf_i386_adjust_dynamic_symbol
45
  PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
46
static boolean allocate_plt_and_got_and_discard_relocs
47
  PARAMS ((struct elf_link_hash_entry *, PTR));
48
static boolean elf_i386_size_dynamic_sections
49
  PARAMS ((bfd *, struct bfd_link_info *));
50
static boolean elf_i386_relocate_section
51
  PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
52
           Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
53
static boolean elf_i386_finish_dynamic_symbol
54
  PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
55
           Elf_Internal_Sym *));
56
static boolean elf_i386_finish_dynamic_sections
57
  PARAMS ((bfd *, struct bfd_link_info *));
58
 
59
#define USE_REL 1               /* 386 uses REL relocations instead of RELA */
60
 
61
#include "elf/i386.h"
62
 
63
static reloc_howto_type elf_howto_table[]=
64
{
65
  HOWTO(R_386_NONE, 0, 0, 0, false, 0, complain_overflow_bitfield,
66
        bfd_elf_generic_reloc, "R_386_NONE",
67
        true, 0x00000000, 0x00000000, false),
68
  HOWTO(R_386_32, 0, 2, 32, false, 0, complain_overflow_bitfield,
69
        bfd_elf_generic_reloc, "R_386_32",
70
        true, 0xffffffff, 0xffffffff, false),
71
  HOWTO(R_386_PC32, 0, 2, 32, true, 0, complain_overflow_bitfield,
72
        bfd_elf_generic_reloc, "R_386_PC32",
73
        true, 0xffffffff, 0xffffffff, true),
74
  HOWTO(R_386_GOT32, 0, 2, 32, false, 0, complain_overflow_bitfield,
75
        bfd_elf_generic_reloc, "R_386_GOT32",
76
        true, 0xffffffff, 0xffffffff, false),
77
  HOWTO(R_386_PLT32, 0, 2, 32, true, 0, complain_overflow_bitfield,
78
        bfd_elf_generic_reloc, "R_386_PLT32",
79
        true, 0xffffffff, 0xffffffff, true),
80
  HOWTO(R_386_COPY, 0, 2, 32, false, 0, complain_overflow_bitfield,
81
        bfd_elf_generic_reloc, "R_386_COPY",
82
        true, 0xffffffff, 0xffffffff, false),
83
  HOWTO(R_386_GLOB_DAT, 0, 2, 32, false, 0, complain_overflow_bitfield,
84
        bfd_elf_generic_reloc, "R_386_GLOB_DAT",
85
        true, 0xffffffff, 0xffffffff, false),
86
  HOWTO(R_386_JUMP_SLOT, 0, 2, 32, false, 0, complain_overflow_bitfield,
87
        bfd_elf_generic_reloc, "R_386_JUMP_SLOT",
88
        true, 0xffffffff, 0xffffffff, false),
89
  HOWTO(R_386_RELATIVE, 0, 2, 32, false, 0, complain_overflow_bitfield,
90
        bfd_elf_generic_reloc, "R_386_RELATIVE",
91
        true, 0xffffffff, 0xffffffff, false),
92
  HOWTO(R_386_GOTOFF, 0, 2, 32, false, 0, complain_overflow_bitfield,
93
        bfd_elf_generic_reloc, "R_386_GOTOFF",
94
        true, 0xffffffff, 0xffffffff, false),
95
  HOWTO(R_386_GOTPC, 0, 2, 32, true, 0, complain_overflow_bitfield,
96
        bfd_elf_generic_reloc, "R_386_GOTPC",
97
        true, 0xffffffff, 0xffffffff, true),
98
 
99
  /* We have a gap in the reloc numbers here.
100
     R_386_standard counts the number up to this point, and
101
     R_386_ext_offset is the value to subtract from a reloc type of
102
     R_386_16 thru R_386_PC8 to form an index into this table.  */
103
#define R_386_standard ((unsigned int) R_386_GOTPC + 1)
104
#define R_386_ext_offset ((unsigned int) R_386_16 - R_386_standard)
105
 
106
  /* The remaining relocs are a GNU extension.  */
107
  HOWTO(R_386_16, 0, 1, 16, false, 0, complain_overflow_bitfield,
108
        bfd_elf_generic_reloc, "R_386_16",
109
        true, 0xffff, 0xffff, false),
110
  HOWTO(R_386_PC16, 0, 1, 16, true, 0, complain_overflow_bitfield,
111
        bfd_elf_generic_reloc, "R_386_PC16",
112
        true, 0xffff, 0xffff, true),
113
  HOWTO(R_386_8, 0, 0, 8, false, 0, complain_overflow_bitfield,
114
        bfd_elf_generic_reloc, "R_386_8",
115
        true, 0xff, 0xff, false),
116
  HOWTO(R_386_PC8, 0, 0, 8, true, 0, complain_overflow_signed,
117
        bfd_elf_generic_reloc, "R_386_PC8",
118
        true, 0xff, 0xff, true),
119
 
120
  /* Another gap.  */
121
#define R_386_ext ((unsigned int) R_386_PC8 + 1 - R_386_ext_offset)
122
#define R_386_vt_offset ((unsigned int) R_386_GNU_VTINHERIT - R_386_ext)
123
 
124
/* GNU extension to record C++ vtable hierarchy.  */
125
  HOWTO (R_386_GNU_VTINHERIT,   /* type */
126
         0,                      /* rightshift */
127
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
128
         0,                      /* bitsize */
129
         false,                 /* pc_relative */
130
         0,                      /* bitpos */
131
         complain_overflow_dont, /* complain_on_overflow */
132
         NULL,                  /* special_function */
133
         "R_386_GNU_VTINHERIT", /* name */
134
         false,                 /* partial_inplace */
135
         0,                      /* src_mask */
136
         0,                      /* dst_mask */
137
         false),
138
 
139
/* GNU extension to record C++ vtable member usage.  */
140
  HOWTO (R_386_GNU_VTENTRY,     /* type */
141
         0,                      /* rightshift */
142
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
143
         0,                      /* bitsize */
144
         false,                 /* pc_relative */
145
         0,                      /* bitpos */
146
         complain_overflow_dont, /* complain_on_overflow */
147
         _bfd_elf_rel_vtable_reloc_fn, /* special_function */
148
         "R_386_GNU_VTENTRY",   /* name */
149
         false,                 /* partial_inplace */
150
         0,                      /* src_mask */
151
         0,                      /* dst_mask */
152
         false)
153
 
154
#define R_386_vt ((unsigned int) R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
155
 
156
};
157
 
158
#ifdef DEBUG_GEN_RELOC
159
#define TRACE(str) fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
160
#else
161
#define TRACE(str)
162
#endif
163
 
164
static reloc_howto_type *
165
elf_i386_reloc_type_lookup (abfd, code)
166
     bfd *abfd ATTRIBUTE_UNUSED;
167
     bfd_reloc_code_real_type code;
168
{
169
  switch (code)
170
    {
171
    case BFD_RELOC_NONE:
172
      TRACE ("BFD_RELOC_NONE");
173
      return &elf_howto_table[(unsigned int) R_386_NONE ];
174
 
175
    case BFD_RELOC_32:
176
      TRACE ("BFD_RELOC_32");
177
      return &elf_howto_table[(unsigned int) R_386_32 ];
178
 
179
    case BFD_RELOC_CTOR:
180
      TRACE ("BFD_RELOC_CTOR");
181
      return &elf_howto_table[(unsigned int) R_386_32 ];
182
 
183
    case BFD_RELOC_32_PCREL:
184
      TRACE ("BFD_RELOC_PC32");
185
      return &elf_howto_table[(unsigned int) R_386_PC32 ];
186
 
187
    case BFD_RELOC_386_GOT32:
188
      TRACE ("BFD_RELOC_386_GOT32");
189
      return &elf_howto_table[(unsigned int) R_386_GOT32 ];
190
 
191
    case BFD_RELOC_386_PLT32:
192
      TRACE ("BFD_RELOC_386_PLT32");
193
      return &elf_howto_table[(unsigned int) R_386_PLT32 ];
194
 
195
    case BFD_RELOC_386_COPY:
196
      TRACE ("BFD_RELOC_386_COPY");
197
      return &elf_howto_table[(unsigned int) R_386_COPY ];
198
 
199
    case BFD_RELOC_386_GLOB_DAT:
200
      TRACE ("BFD_RELOC_386_GLOB_DAT");
201
      return &elf_howto_table[(unsigned int) R_386_GLOB_DAT ];
202
 
203
    case BFD_RELOC_386_JUMP_SLOT:
204
      TRACE ("BFD_RELOC_386_JUMP_SLOT");
205
      return &elf_howto_table[(unsigned int) R_386_JUMP_SLOT ];
206
 
207
    case BFD_RELOC_386_RELATIVE:
208
      TRACE ("BFD_RELOC_386_RELATIVE");
209
      return &elf_howto_table[(unsigned int) R_386_RELATIVE ];
210
 
211
    case BFD_RELOC_386_GOTOFF:
212
      TRACE ("BFD_RELOC_386_GOTOFF");
213
      return &elf_howto_table[(unsigned int) R_386_GOTOFF ];
214
 
215
    case BFD_RELOC_386_GOTPC:
216
      TRACE ("BFD_RELOC_386_GOTPC");
217
      return &elf_howto_table[(unsigned int) R_386_GOTPC ];
218
 
219
      /* The remaining relocs are a GNU extension.  */
220
    case BFD_RELOC_16:
221
      TRACE ("BFD_RELOC_16");
222
      return &elf_howto_table[(unsigned int) R_386_16 - R_386_ext_offset];
223
 
224
    case BFD_RELOC_16_PCREL:
225
      TRACE ("BFD_RELOC_16_PCREL");
226
      return &elf_howto_table[(unsigned int) R_386_PC16 - R_386_ext_offset];
227
 
228
    case BFD_RELOC_8:
229
      TRACE ("BFD_RELOC_8");
230
      return &elf_howto_table[(unsigned int) R_386_8 - R_386_ext_offset];
231
 
232
    case BFD_RELOC_8_PCREL:
233
      TRACE ("BFD_RELOC_8_PCREL");
234
      return &elf_howto_table[(unsigned int) R_386_PC8 - R_386_ext_offset];
235
 
236
    case BFD_RELOC_VTABLE_INHERIT:
237
      TRACE ("BFD_RELOC_VTABLE_INHERIT");
238
      return &elf_howto_table[(unsigned int) R_386_GNU_VTINHERIT
239
                             - R_386_vt_offset];
240
 
241
    case BFD_RELOC_VTABLE_ENTRY:
242
      TRACE ("BFD_RELOC_VTABLE_ENTRY");
243
      return &elf_howto_table[(unsigned int) R_386_GNU_VTENTRY
244
                             - R_386_vt_offset];
245
 
246
    default:
247
      break;
248
    }
249
 
250
  TRACE ("Unknown");
251
  return 0;
252
}
253
 
254
static void
255
elf_i386_info_to_howto (abfd, cache_ptr, dst)
256
     bfd                *abfd ATTRIBUTE_UNUSED;
257
     arelent            *cache_ptr ATTRIBUTE_UNUSED;
258
     Elf32_Internal_Rela *dst ATTRIBUTE_UNUSED;
259
{
260
  abort ();
261
}
262
 
263
static void
264
elf_i386_info_to_howto_rel (abfd, cache_ptr, dst)
265
     bfd *abfd ATTRIBUTE_UNUSED;
266
     arelent *cache_ptr;
267
     Elf32_Internal_Rel *dst;
268
{
269
  unsigned int r_type = ELF32_R_TYPE (dst->r_info);
270
  unsigned int indx;
271
 
272
  if ((indx = r_type) >= R_386_standard
273
      && ((indx = r_type - R_386_ext_offset) - R_386_standard
274
          >= R_386_ext - R_386_standard)
275
      && ((indx = r_type - R_386_vt_offset) - R_386_ext
276
          >= R_386_vt - R_386_ext))
277
    {
278
      (*_bfd_error_handler) (_("%s: invalid relocation type %d"),
279
                             bfd_get_filename (abfd), (int) r_type);
280
      indx = (unsigned int) R_386_NONE;
281
    }
282
  cache_ptr->howto = &elf_howto_table[indx];
283
}
284
 
285
/* Return whether a symbol name implies a local label.  The UnixWare
286
   2.1 cc generates temporary symbols that start with .X, so we
287
   recognize them here.  FIXME: do other SVR4 compilers also use .X?.
288
   If so, we should move the .X recognition into
289
   _bfd_elf_is_local_label_name.  */
290
 
291
static boolean
292
elf_i386_is_local_label_name (abfd, name)
293
     bfd *abfd;
294
     const char *name;
295
{
296
  if (name[0] == '.' && name[1] == 'X')
297
    return true;
298
 
299
  return _bfd_elf_is_local_label_name (abfd, name);
300
}
301
 
302
/* Functions for the i386 ELF linker.  */
303
 
304
/* The name of the dynamic interpreter.  This is put in the .interp
305
   section.  */
306
 
307
#define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
308
 
309
/* The size in bytes of an entry in the procedure linkage table.  */
310
 
311
#define PLT_ENTRY_SIZE 16
312
 
313
/* The first entry in an absolute procedure linkage table looks like
314
   this.  See the SVR4 ABI i386 supplement to see how this works.  */
315
 
316
static const bfd_byte elf_i386_plt0_entry[PLT_ENTRY_SIZE] =
317
{
318
  0xff, 0x35,   /* pushl contents of address */
319
  0, 0, 0, 0,       /* replaced with address of .got + 4.  */
320
  0xff, 0x25,   /* jmp indirect */
321
  0, 0, 0, 0,       /* replaced with address of .got + 8.  */
322
  0, 0, 0, 0        /* pad out to 16 bytes.  */
323
};
324
 
325
/* Subsequent entries in an absolute procedure linkage table look like
326
   this.  */
327
 
328
static const bfd_byte elf_i386_plt_entry[PLT_ENTRY_SIZE] =
329
{
330
  0xff, 0x25,   /* jmp indirect */
331
  0, 0, 0, 0,       /* replaced with address of this symbol in .got.  */
332
  0x68,         /* pushl immediate */
333
  0, 0, 0, 0,       /* replaced with offset into relocation table.  */
334
  0xe9,         /* jmp relative */
335
  0, 0, 0, 0        /* replaced with offset to start of .plt.  */
336
};
337
 
338
/* The first entry in a PIC procedure linkage table look like this.  */
339
 
340
static const bfd_byte elf_i386_pic_plt0_entry[PLT_ENTRY_SIZE] =
341
{
342
  0xff, 0xb3, 4, 0, 0, 0,  /* pushl 4(%ebx) */
343
  0xff, 0xa3, 8, 0, 0, 0,  /* jmp *8(%ebx) */
344
  0, 0, 0, 0                        /* pad out to 16 bytes.  */
345
};
346
 
347
/* Subsequent entries in a PIC procedure linkage table look like this.  */
348
 
349
static const bfd_byte elf_i386_pic_plt_entry[PLT_ENTRY_SIZE] =
350
{
351
  0xff, 0xa3,   /* jmp *offset(%ebx) */
352
  0, 0, 0, 0,       /* replaced with offset of this symbol in .got.  */
353
  0x68,         /* pushl immediate */
354
  0, 0, 0, 0,       /* replaced with offset into relocation table.  */
355
  0xe9,         /* jmp relative */
356
  0, 0, 0, 0        /* replaced with offset to start of .plt.  */
357
};
358
 
359
/* The i386 linker needs to keep track of the number of relocs that it
360
   decides to copy as dynamic relocs in check_relocs for each symbol.
361
   This is so that it can later discard them if they are found to be
362
   unnecessary.  We store the information in a field extending the
363
   regular ELF linker hash table.  */
364
 
365
struct elf_i386_dyn_relocs
366
{
367
  /* Next section.  */
368
  struct elf_i386_dyn_relocs *next;
369
  /* A section in dynobj.  */
370
  asection *section;
371
  /* Number of relocs copied in this section.  */
372
  bfd_size_type count;
373
};
374
 
375
/* i386 ELF linker hash entry.  */
376
 
377
struct elf_i386_link_hash_entry
378
{
379
  struct elf_link_hash_entry root;
380
 
381
  /* Number of PC relative relocs copied for this symbol.  */
382
  struct elf_i386_dyn_relocs *dyn_relocs;
383
};
384
 
385
/* i386 ELF linker hash table.  */
386
 
387
struct elf_i386_link_hash_table
388
{
389
  struct elf_link_hash_table root;
390
 
391
  /* Short-cuts to get to dynamic linker sections.  */
392
  asection *sgot;
393
  asection *sgotplt;
394
  asection *srelgot;
395
  asection *splt;
396
  asection *srelplt;
397
  asection *sdynbss;
398
  asection *srelbss;
399
};
400
 
401
/* Get the i386 ELF linker hash table from a link_info structure.  */
402
 
403
#define elf_i386_hash_table(p) \
404
  ((struct elf_i386_link_hash_table *) ((p)->hash))
405
 
406
/* Create an entry in an i386 ELF linker hash table.  */
407
 
408
static struct bfd_hash_entry *
409
elf_i386_link_hash_newfunc (entry, table, string)
410
     struct bfd_hash_entry *entry;
411
     struct bfd_hash_table *table;
412
     const char *string;
413
{
414
  struct elf_i386_link_hash_entry *ret =
415
    (struct elf_i386_link_hash_entry *) entry;
416
 
417
  /* Allocate the structure if it has not already been allocated by a
418
     subclass.  */
419
  if (ret == (struct elf_i386_link_hash_entry *) NULL)
420
    ret = ((struct elf_i386_link_hash_entry *)
421
           bfd_hash_allocate (table,
422
                              sizeof (struct elf_i386_link_hash_entry)));
423
  if (ret == (struct elf_i386_link_hash_entry *) NULL)
424
    return (struct bfd_hash_entry *) ret;
425
 
426
  /* Call the allocation method of the superclass.  */
427
  ret = ((struct elf_i386_link_hash_entry *)
428
         _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
429
                                     table, string));
430
  if (ret != (struct elf_i386_link_hash_entry *) NULL)
431
    {
432
      ret->dyn_relocs = NULL;
433
    }
434
 
435
  return (struct bfd_hash_entry *) ret;
436
}
437
 
438
/* Create an i386 ELF linker hash table.  */
439
 
440
static struct bfd_link_hash_table *
441
elf_i386_link_hash_table_create (abfd)
442
     bfd *abfd;
443
{
444
  struct elf_i386_link_hash_table *ret;
445
 
446
  ret = ((struct elf_i386_link_hash_table *)
447
         bfd_alloc (abfd, sizeof (struct elf_i386_link_hash_table)));
448
  if (ret == (struct elf_i386_link_hash_table *) NULL)
449
    return NULL;
450
 
451
  if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
452
                                       elf_i386_link_hash_newfunc))
453
    {
454
      bfd_release (abfd, ret);
455
      return NULL;
456
    }
457
 
458
  ret->sgot = NULL;
459
  ret->sgotplt = NULL;
460
  ret->srelgot = NULL;
461
  ret->splt = NULL;
462
  ret->srelplt = NULL;
463
  ret->sdynbss = NULL;
464
  ret->srelbss = NULL;
465
 
466
  return &ret->root.root;
467
}
468
 
469
/* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
470
   shortcuts to them in our hash table.  */
471
 
472
static boolean
473
create_got_section (dynobj, info)
474
     bfd *dynobj;
475
     struct bfd_link_info *info;
476
{
477
  struct elf_i386_link_hash_table *htab;
478
 
479
  if (! _bfd_elf_create_got_section (dynobj, info))
480
    return false;
481
 
482
  htab = elf_i386_hash_table (info);
483
  htab->sgot = bfd_get_section_by_name (dynobj, ".got");
484
  htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
485
  if (!htab->sgot || !htab->sgotplt)
486
    abort ();
487
 
488
  htab->srelgot = bfd_make_section (dynobj, ".rel.got");
489
  if (htab->srelgot == NULL
490
      || ! bfd_set_section_flags (dynobj, htab->srelgot,
491
                                  (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
492
                                   | SEC_IN_MEMORY | SEC_LINKER_CREATED
493
                                   | SEC_READONLY))
494
      || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
495
    return false;
496
  return true;
497
}
498
 
499
/* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
500
   .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
501
   hash table.  */
502
 
503
static boolean
504
elf_i386_create_dynamic_sections (dynobj, info)
505
     bfd *dynobj;
506
     struct bfd_link_info *info;
507
{
508
  struct elf_i386_link_hash_table *htab;
509
 
510
  htab = elf_i386_hash_table (info);
511
  if (!htab->sgot && !create_got_section (dynobj, info))
512
    return false;
513
 
514
  if (!_bfd_elf_create_dynamic_sections (dynobj, info))
515
    return false;
516
 
517
  htab->splt = bfd_get_section_by_name (dynobj, ".plt");
518
  htab->srelplt = bfd_get_section_by_name (dynobj, ".rel.plt");
519
  htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
520
  if (!info->shared)
521
    htab->srelbss = bfd_get_section_by_name (dynobj, ".rel.bss");
522
 
523
  if (!htab->splt || !htab->srelplt || !htab->sdynbss
524
      || (!info->shared && !htab->srelbss))
525
    abort ();
526
 
527
  return true;
528
}
529
 
530
/* Look through the relocs for a section during the first phase, and
531
   allocate space in the global offset table or procedure linkage
532
   table.  */
533
 
534
static boolean
535
elf_i386_check_relocs (abfd, info, sec, relocs)
536
     bfd *abfd;
537
     struct bfd_link_info *info;
538
     asection *sec;
539
     const Elf_Internal_Rela *relocs;
540
{
541
  struct elf_i386_link_hash_table *htab;
542
  bfd *dynobj;
543
  Elf_Internal_Shdr *symtab_hdr;
544
  struct elf_link_hash_entry **sym_hashes;
545
  bfd_signed_vma *local_got_refcounts;
546
  const Elf_Internal_Rela *rel;
547
  const Elf_Internal_Rela *rel_end;
548
  asection *sreloc;
549
 
550
  if (info->relocateable)
551
    return true;
552
 
553
  htab = elf_i386_hash_table (info);
554
  dynobj = htab->root.dynobj;
555
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
556
  sym_hashes = elf_sym_hashes (abfd);
557
  local_got_refcounts = elf_local_got_refcounts (abfd);
558
 
559
  sreloc = NULL;
560
 
561
  rel_end = relocs + sec->reloc_count;
562
  for (rel = relocs; rel < rel_end; rel++)
563
    {
564
      unsigned long r_symndx;
565
      struct elf_link_hash_entry *h;
566
 
567
      r_symndx = ELF32_R_SYM (rel->r_info);
568
 
569
      if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
570
        {
571
          if (abfd->my_archive)
572
            (*_bfd_error_handler) (_("%s(%s): bad symbol index: %d"),
573
                                   bfd_get_filename (abfd->my_archive),
574
                                   bfd_get_filename (abfd),
575
                                   r_symndx);
576
          else
577
            (*_bfd_error_handler) (_("%s: bad symbol index: %d"),
578
                                   bfd_get_filename (abfd),
579
                                   r_symndx);
580
          return false;
581
        }
582
 
583
      if (r_symndx < symtab_hdr->sh_info)
584
        h = NULL;
585
      else
586
        h = sym_hashes[r_symndx - symtab_hdr->sh_info];
587
 
588
      /* Some relocs require a global offset table.  */
589
      if (htab->sgot == NULL)
590
        {
591
          switch (ELF32_R_TYPE (rel->r_info))
592
            {
593
            case R_386_GOT32:
594
            case R_386_GOTOFF:
595
            case R_386_GOTPC:
596
              if (dynobj == NULL)
597
                htab->root.dynobj = dynobj = abfd;
598
              if (!create_got_section (dynobj, info))
599
                return false;
600
              break;
601
 
602
            default:
603
              break;
604
            }
605
        }
606
 
607
      switch (ELF32_R_TYPE (rel->r_info))
608
        {
609
        case R_386_GOT32:
610
          /* This symbol requires a global offset table entry.  */
611
          if (h != NULL)
612
            {
613
              if (h->got.refcount == -1)
614
                h->got.refcount = 1;
615
              else
616
                h->got.refcount += 1;
617
            }
618
          else
619
            {
620
              /* This is a global offset table entry for a local symbol.  */
621
              if (local_got_refcounts == NULL)
622
                {
623
                  size_t size;
624
 
625
                  size = symtab_hdr->sh_info * sizeof (bfd_signed_vma);
626
                  local_got_refcounts = ((bfd_signed_vma *)
627
                                         bfd_alloc (abfd, size));
628
                  if (local_got_refcounts == NULL)
629
                    return false;
630
                  elf_local_got_refcounts (abfd) = local_got_refcounts;
631
                  memset (local_got_refcounts, -1, size);
632
                }
633
              if (local_got_refcounts[r_symndx] == -1)
634
                local_got_refcounts[r_symndx] = 1;
635
              else
636
                local_got_refcounts[r_symndx] += 1;
637
            }
638
          break;
639
 
640
        case R_386_PLT32:
641
          /* This symbol requires a procedure linkage table entry.  We
642
             actually build the entry in adjust_dynamic_symbol,
643
             because this might be a case of linking PIC code which is
644
             never referenced by a dynamic object, in which case we
645
             don't need to generate a procedure linkage table entry
646
             after all.  */
647
 
648
          /* If this is a local symbol, we resolve it directly without
649
             creating a procedure linkage table entry.  */
650
          if (h == NULL)
651
            continue;
652
 
653
          if (h->plt.refcount == -1)
654
            {
655
              h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
656
              h->plt.refcount = 1;
657
            }
658
          else
659
            h->plt.refcount += 1;
660
          break;
661
 
662
        case R_386_32:
663
        case R_386_PC32:
664
          if (h != NULL && !info->shared)
665
            {
666
              /* If this reloc is in a read-only section, we might
667
                 need a copy reloc.  */
668
              if ((sec->flags & SEC_READONLY) != 0)
669
                h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
670
 
671
              /* We may need a .plt entry if the function this reloc
672
                 refers to is in a shared lib.  */
673
              if (h->plt.refcount == -1)
674
                h->plt.refcount = 1;
675
              else
676
                h->plt.refcount += 1;
677
            }
678
 
679
          /* If we are creating a shared library, and this is a reloc
680
             against a global symbol, or a non PC relative reloc
681
             against a local symbol, then we need to copy the reloc
682
             into the shared library.  However, if we are linking with
683
             -Bsymbolic, we do not need to copy a reloc against a
684
             global symbol which is defined in an object we are
685
             including in the link (i.e., DEF_REGULAR is set).  At
686
             this point we have not seen all the input files, so it is
687
             possible that DEF_REGULAR is not set now but will be set
688
             later (it is never cleared).  In case of a weak definition,
689
             DEF_REGULAR may be cleared later by a strong definition in
690
             a shared library. We account for that possibility below by
691
             storing information in the relocs_copied field of the hash
692
             table entry.  A similar situation occurs when creating
693
             shared libraries and symbol visibility changes render the
694
             symbol local.
695
             If on the other hand, we are creating an executable, we
696
             may need to keep relocations for symbols satisfied by a
697
             dynamic library if we manage to avoid copy relocs for the
698
             symbol.  */
699
          if ((info->shared
700
               && (sec->flags & SEC_ALLOC) != 0
701
               && (ELF32_R_TYPE (rel->r_info) != R_386_PC32
702
                   || (h != NULL
703
                       && (! info->symbolic
704
                           || h->root.type == bfd_link_hash_defweak
705
                           || (h->elf_link_hash_flags
706
                               & ELF_LINK_HASH_DEF_REGULAR) == 0))))
707
              || (!info->shared
708
                  && (sec->flags & SEC_ALLOC) != 0
709
                  && h != NULL
710
                  && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
711
                  && (h->root.type == bfd_link_hash_defweak
712
                      || (h->elf_link_hash_flags
713
                          & ELF_LINK_HASH_DEF_REGULAR) == 0)))
714
            {
715
              /* We must copy these reloc types into the output file.
716
                 Create a reloc section in dynobj and make room for
717
                 this reloc.  */
718
              if (dynobj == NULL)
719
                htab->root.dynobj = dynobj = abfd;
720
 
721
              if (sreloc == NULL)
722
                {
723
                  const char *name;
724
 
725
                  name = (bfd_elf_string_from_elf_section
726
                          (abfd,
727
                           elf_elfheader (abfd)->e_shstrndx,
728
                           elf_section_data (sec)->rel_hdr.sh_name));
729
                  if (name == NULL)
730
                    return false;
731
 
732
                  if (strncmp (name, ".rel", 4) != 0
733
                      || strcmp (bfd_get_section_name (abfd, sec),
734
                                 name + 4) != 0)
735
                    {
736
                      if (abfd->my_archive)
737
                        (*_bfd_error_handler) (_("%s(%s): bad relocation section name `%s\'"),
738
                                               bfd_get_filename (abfd->my_archive),
739
                                               bfd_get_filename (abfd),
740
                                               name);
741
                      else
742
                        (*_bfd_error_handler) (_("%s: bad relocation section name `%s\'"),
743
                                               bfd_get_filename (abfd),
744
                                               name);
745
                    }
746
 
747
                  sreloc = bfd_get_section_by_name (dynobj, name);
748
                  if (sreloc == NULL)
749
                    {
750
                      flagword flags;
751
 
752
                      sreloc = bfd_make_section (dynobj, name);
753
                      flags = (SEC_HAS_CONTENTS | SEC_READONLY
754
                               | SEC_IN_MEMORY | SEC_LINKER_CREATED);
755
                      if ((sec->flags & SEC_ALLOC) != 0)
756
                        flags |= SEC_ALLOC | SEC_LOAD;
757
                      if (sreloc == NULL
758
                          || ! bfd_set_section_flags (dynobj, sreloc, flags)
759
                          || ! bfd_set_section_alignment (dynobj, sreloc, 2))
760
                        return false;
761
                    }
762
                }
763
 
764
              sreloc->_raw_size += sizeof (Elf32_External_Rel);
765
 
766
              /* If this is a global symbol, we count the number of PC
767
                 relative relocations we have entered for this symbol,
768
                 so that we can discard them later as necessary.  Note
769
                 that this function is only called if we are using an
770
                 elf_i386 linker hash table, which means that h is
771
                 really a pointer to an elf_i386_link_hash_entry.  */
772
              if (!info->shared
773
                  || (h != NULL
774
                      && ELF32_R_TYPE (rel->r_info) == R_386_PC32))
775
                {
776
                  struct elf_i386_link_hash_entry *eh;
777
                  struct elf_i386_dyn_relocs *p;
778
 
779
                  eh = (struct elf_i386_link_hash_entry *) h;
780
 
781
                  for (p = eh->dyn_relocs; p != NULL; p = p->next)
782
                    if (p->section == sreloc)
783
                      break;
784
 
785
                  if (p == NULL)
786
                    {
787
                      p = ((struct elf_i386_dyn_relocs *)
788
                           bfd_alloc (dynobj, sizeof *p));
789
                      if (p == NULL)
790
                        return false;
791
                      p->next = eh->dyn_relocs;
792
                      eh->dyn_relocs = p;
793
                      p->section = sreloc;
794
                      p->count = 0;
795
                    }
796
 
797
                  ++p->count;
798
                }
799
            }
800
 
801
          break;
802
 
803
          /* This relocation describes the C++ object vtable hierarchy.
804
             Reconstruct it for later use during GC.  */
805
        case R_386_GNU_VTINHERIT:
806
          if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
807
            return false;
808
          break;
809
 
810
          /* This relocation describes which C++ vtable entries are actually
811
             used.  Record for later use during GC.  */
812
        case R_386_GNU_VTENTRY:
813
          if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
814
            return false;
815
          break;
816
 
817
        default:
818
          break;
819
        }
820
    }
821
 
822
  return true;
823
}
824
 
825
/* Return the section that should be marked against GC for a given
826
   relocation.  */
827
 
828
static asection *
829
elf_i386_gc_mark_hook (abfd, info, rel, h, sym)
830
     bfd *abfd;
831
     struct bfd_link_info *info ATTRIBUTE_UNUSED;
832
     Elf_Internal_Rela *rel;
833
     struct elf_link_hash_entry *h;
834
     Elf_Internal_Sym *sym;
835
{
836
  if (h != NULL)
837
    {
838
      switch (ELF32_R_TYPE (rel->r_info))
839
        {
840
        case R_386_GNU_VTINHERIT:
841
        case R_386_GNU_VTENTRY:
842
          break;
843
 
844
        default:
845
          switch (h->root.type)
846
            {
847
            case bfd_link_hash_defined:
848
            case bfd_link_hash_defweak:
849
              return h->root.u.def.section;
850
 
851
            case bfd_link_hash_common:
852
              return h->root.u.c.p->section;
853
 
854
            default:
855
              break;
856
            }
857
        }
858
    }
859
  else
860
    {
861
      if (!(elf_bad_symtab (abfd)
862
            && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
863
          && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
864
                && sym->st_shndx != SHN_COMMON))
865
        {
866
          return bfd_section_from_elf_index (abfd, sym->st_shndx);
867
        }
868
    }
869
 
870
  return NULL;
871
}
872
 
873
/* Update the got entry reference counts for the section being removed.  */
874
 
875
static boolean
876
elf_i386_gc_sweep_hook (abfd, info, sec, relocs)
877
     bfd *abfd;
878
     struct bfd_link_info *info;
879
     asection *sec;
880
     const Elf_Internal_Rela *relocs;
881
{
882
  Elf_Internal_Shdr *symtab_hdr;
883
  struct elf_link_hash_entry **sym_hashes;
884
  bfd_signed_vma *local_got_refcounts;
885
  const Elf_Internal_Rela *rel, *relend;
886
  unsigned long r_symndx;
887
  struct elf_link_hash_entry *h;
888
  bfd *dynobj;
889
 
890
  dynobj = elf_hash_table (info)->dynobj;
891
  if (dynobj == NULL)
892
    return true;
893
 
894
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
895
  sym_hashes = elf_sym_hashes (abfd);
896
  local_got_refcounts = elf_local_got_refcounts (abfd);
897
 
898
  relend = relocs + sec->reloc_count;
899
  for (rel = relocs; rel < relend; rel++)
900
    switch (ELF32_R_TYPE (rel->r_info))
901
      {
902
      case R_386_GOT32:
903
      case R_386_GOTOFF:
904
      case R_386_GOTPC:
905
        r_symndx = ELF32_R_SYM (rel->r_info);
906
        if (r_symndx >= symtab_hdr->sh_info)
907
          {
908
            h = sym_hashes[r_symndx - symtab_hdr->sh_info];
909
            if (h->got.refcount > 0)
910
              h->got.refcount -= 1;
911
          }
912
        else if (local_got_refcounts != NULL)
913
          {
914
            if (local_got_refcounts[r_symndx] > 0)
915
              local_got_refcounts[r_symndx] -= 1;
916
          }
917
        break;
918
 
919
      case R_386_32:
920
      case R_386_PC32:
921
        if (info->shared)
922
          break;
923
        /* Fall through.  */
924
 
925
      case R_386_PLT32:
926
        r_symndx = ELF32_R_SYM (rel->r_info);
927
        if (r_symndx >= symtab_hdr->sh_info)
928
          {
929
            h = sym_hashes[r_symndx - symtab_hdr->sh_info];
930
            if (h->plt.refcount > 0)
931
              h->plt.refcount -= 1;
932
          }
933
        break;
934
 
935
      default:
936
        break;
937
      }
938
 
939
  return true;
940
}
941
 
942
/* Adjust a symbol defined by a dynamic object and referenced by a
943
   regular object.  The current definition is in some section of the
944
   dynamic object, but we're not including those sections.  We have to
945
   change the definition to something the rest of the link can
946
   understand.  */
947
 
948
static boolean
949
elf_i386_adjust_dynamic_symbol (info, h)
950
     struct bfd_link_info *info;
951
     struct elf_link_hash_entry *h;
952
{
953
  struct elf_i386_link_hash_table *htab;
954
  bfd *dynobj;
955
  asection *s;
956
  unsigned int power_of_two;
957
 
958
  htab = elf_i386_hash_table (info);
959
  dynobj = htab->root.dynobj;
960
 
961
  /* If this is a function, put it in the procedure linkage table.  We
962
     will fill in the contents of the procedure linkage table later,
963
     when we know the address of the .got section.  */
964
  if (h->type == STT_FUNC
965
      || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
966
    {
967
      if (h->plt.refcount <= 0
968
          || (! info->shared
969
              && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
970
              && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0))
971
        {
972
          /* This case can occur if we saw a PLT32 reloc in an input
973
             file, but the symbol was never referred to by a dynamic
974
             object, or if all references were garbage collected.  In
975
             such a case, we don't actually need to build a procedure
976
             linkage table, and we can just do a PC32 reloc instead.  */
977
          h->plt.refcount = (bfd_vma) -1;
978
          h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
979
        }
980
 
981
      return true;
982
    }
983
  else
984
    /* It's possible that we incorrectly decided a .plt reloc was
985
       needed for an R_386_PC32 reloc to a non-function sym in
986
       check_relocs.  We can't decide accurately between function and
987
       non-function syms in check-relocs;  Objects loaded later in
988
       the link may change h->type.  So fix it now.  */
989
    h->plt.refcount = (bfd_vma) -1;
990
 
991
  /* If this is a weak symbol, and there is a real definition, the
992
     processor independent code will have arranged for us to see the
993
     real definition first, and we can just use the same value.  */
994
  if (h->weakdef != NULL)
995
    {
996
      BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
997
                  || h->weakdef->root.type == bfd_link_hash_defweak);
998
      h->root.u.def.section = h->weakdef->root.u.def.section;
999
      h->root.u.def.value = h->weakdef->root.u.def.value;
1000
      return true;
1001
    }
1002
 
1003
  /* This is a reference to a symbol defined by a dynamic object which
1004
     is not a function.  */
1005
 
1006
  /* If we are creating a shared library, we must presume that the
1007
     only references to the symbol are via the global offset table.
1008
     For such cases we need not do anything here; the relocations will
1009
     be handled correctly by relocate_section.  */
1010
  if (info->shared)
1011
    return true;
1012
 
1013
  /* If there are no references to this symbol that do not use the
1014
     GOT, we don't need to generate a copy reloc.  */
1015
  if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
1016
    return true;
1017
 
1018
  /* We must allocate the symbol in our .dynbss section, which will
1019
     become part of the .bss section of the executable.  There will be
1020
     an entry for this symbol in the .dynsym section.  The dynamic
1021
     object will contain position independent code, so all references
1022
     from the dynamic object to this symbol will go through the global
1023
     offset table.  The dynamic linker will use the .dynsym entry to
1024
     determine the address it must put in the global offset table, so
1025
     both the dynamic object and the regular object will refer to the
1026
     same memory location for the variable.  */
1027
 
1028
  s = htab->sdynbss;
1029
  if (s == NULL)
1030
    abort ();
1031
 
1032
  /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1033
     copy the initial value out of the dynamic object and into the
1034
     runtime process image.  We need to remember the offset into the
1035
     .rel.bss section we are going to use.  */
1036
  if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1037
    {
1038
      asection *srel;
1039
 
1040
      srel = htab->srelbss;
1041
      if (srel == NULL)
1042
        abort ();
1043
      srel->_raw_size += sizeof (Elf32_External_Rel);
1044
      h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
1045
    }
1046
 
1047
  /* We need to figure out the alignment required for this symbol.  I
1048
     have no idea how ELF linkers handle this.  */
1049
  power_of_two = bfd_log2 (h->size);
1050
  if (power_of_two > 3)
1051
    power_of_two = 3;
1052
 
1053
  /* Apply the required alignment.  */
1054
  s->_raw_size = BFD_ALIGN (s->_raw_size,
1055
                            (bfd_size_type) (1 << power_of_two));
1056
  if (power_of_two > bfd_get_section_alignment (dynobj, s))
1057
    {
1058
      if (! bfd_set_section_alignment (dynobj, s, power_of_two))
1059
        return false;
1060
    }
1061
 
1062
  /* Define the symbol as being at this point in the section.  */
1063
  h->root.u.def.section = s;
1064
  h->root.u.def.value = s->_raw_size;
1065
 
1066
  /* Increment the section size to make room for the symbol.  */
1067
  s->_raw_size += h->size;
1068
 
1069
  return true;
1070
}
1071
 
1072
/* This is the condition under which elf_i386_finish_dynamic_symbol
1073
   will be called from elflink.h.  If elflink.h doesn't call our
1074
   finish_dynamic_symbol routine, we'll need to do something about
1075
   initializing any .plt and .got entries in elf_i386_relocate_section.  */
1076
#define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
1077
  ((DYN)                                                                \
1078
   && ((INFO)->shared                                                   \
1079
       || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)       \
1080
   && ((H)->dynindx != -1                                               \
1081
       || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1082
 
1083
/* Allocate space in .plt, .got and associated reloc sections for
1084
   global syms. Also discards space allocated for relocs in the
1085
   check_relocs function that we subsequently have found to be
1086
   unneeded.  */
1087
 
1088
static boolean
1089
allocate_plt_and_got_and_discard_relocs (h, inf)
1090
     struct elf_link_hash_entry *h;
1091
     PTR inf;
1092
{
1093
  struct bfd_link_info *info;
1094
  struct elf_i386_link_hash_table *htab;
1095
  asection *s;
1096
  struct elf_i386_link_hash_entry *eh;
1097
 
1098
  if (h->root.type == bfd_link_hash_indirect
1099
      || h->root.type == bfd_link_hash_warning)
1100
    return true;
1101
 
1102
  info = (struct bfd_link_info *) inf;
1103
  htab = elf_i386_hash_table (info);
1104
 
1105
  if (htab->root.dynamic_sections_created
1106
      && h->plt.refcount > 0)
1107
    {
1108
      /* Make sure this symbol is output as a dynamic symbol.
1109
         Undefined weak syms won't yet be marked as dynamic.  */
1110
      if (h->dynindx == -1
1111
          && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1112
        {
1113
          if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1114
            return false;
1115
        }
1116
 
1117
      s = htab->splt;
1118
      if (s == NULL)
1119
        abort ();
1120
 
1121
      /* If this is the first .plt entry, make room for the special
1122
         first entry.  */
1123
      if (s->_raw_size == 0)
1124
        s->_raw_size += PLT_ENTRY_SIZE;
1125
 
1126
      h->plt.offset = s->_raw_size;
1127
 
1128
      /* If this symbol is not defined in a regular file, and we are
1129
         not generating a shared library, then set the symbol to this
1130
         location in the .plt.  This is required to make function
1131
         pointers compare as equal between the normal executable and
1132
         the shared library.  */
1133
      if (! info->shared
1134
          && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1135
        {
1136
          h->root.u.def.section = s;
1137
          h->root.u.def.value = h->plt.offset;
1138
        }
1139
 
1140
      /* Make room for this entry.  */
1141
      s->_raw_size += PLT_ENTRY_SIZE;
1142
 
1143
      /* We also need to make an entry in the .got.plt section, which
1144
         will be placed in the .got section by the linker script.  */
1145
      s = htab->sgotplt;
1146
      if (s == NULL)
1147
        abort ();
1148
      s->_raw_size += 4;
1149
 
1150
      if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info, h))
1151
        {
1152
          /* We also need to make an entry in the .rel.plt section.  */
1153
          s = htab->srelplt;
1154
          if (s == NULL)
1155
            abort ();
1156
          s->_raw_size += sizeof (Elf32_External_Rel);
1157
        }
1158
    }
1159
  else
1160
    {
1161
      h->plt.offset = (bfd_vma) -1;
1162
      h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1163
    }
1164
 
1165
  if (h->got.refcount > 0)
1166
    {
1167
      boolean dyn;
1168
 
1169
      /* Make sure this symbol is output as a dynamic symbol.
1170
         Undefined weak syms won't yet be marked as dynamic.  */
1171
      if (h->dynindx == -1
1172
          && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1173
        {
1174
          if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1175
            return false;
1176
        }
1177
 
1178
      s = htab->sgot;
1179
      h->got.offset = s->_raw_size;
1180
      s->_raw_size += 4;
1181
      dyn = htab->root.dynamic_sections_created;
1182
      if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h))
1183
        htab->srelgot->_raw_size += sizeof (Elf32_External_Rel);
1184
    }
1185
  else
1186
    h->got.offset = (bfd_vma) -1;
1187
 
1188
  /* In the shared -Bsymbolic case, discard space allocated for
1189
     dynamic relocs against symbols which turn out to be defined
1190
     in regular objects.  For the normal shared case, discard space
1191
     for relocs that have become local due to symbol visibility
1192
     changes.  For the non-shared case, discard space for symbols
1193
     which turn out to need copy relocs or are not dynamic.  */
1194
 
1195
  eh = (struct elf_i386_link_hash_entry *) h;
1196
  if (eh->dyn_relocs == NULL)
1197
    return true;
1198
 
1199
  if (!info->shared
1200
      && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
1201
      && ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1202
          || h->root.type == bfd_link_hash_undefweak
1203
          || h->root.type == bfd_link_hash_undefined))
1204
    {
1205
      /* Make sure this symbol is output as a dynamic symbol.
1206
         Undefined weak syms won't yet be marked as dynamic.  */
1207
      if (h->dynindx == -1
1208
          && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1209
        {
1210
          if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1211
            return false;
1212
        }
1213
 
1214
      /* If that succeeded, we know we'll be keeping all the relocs.  */
1215
      if (h->dynindx != -1)
1216
        return true;
1217
    }
1218
 
1219
  if (!info->shared
1220
      || ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
1221
          && ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
1222
              || info->symbolic)))
1223
    {
1224
      struct elf_i386_dyn_relocs *c;
1225
 
1226
      for (c = eh->dyn_relocs; c != NULL; c = c->next)
1227
        c->section->_raw_size -= c->count * sizeof (Elf32_External_Rel);
1228
    }
1229
 
1230
  return true;
1231
}
1232
 
1233
/* Set the sizes of the dynamic sections.  */
1234
 
1235
static boolean
1236
elf_i386_size_dynamic_sections (output_bfd, info)
1237
     bfd *output_bfd;
1238
     struct bfd_link_info *info;
1239
{
1240
  struct elf_i386_link_hash_table *htab;
1241
  bfd *dynobj;
1242
  asection *s;
1243
  boolean relocs;
1244
  boolean reltext;
1245
  bfd *i;
1246
 
1247
  htab = elf_i386_hash_table (info);
1248
  dynobj = htab->root.dynobj;
1249
  if (dynobj == NULL)
1250
    abort ();
1251
 
1252
  if (htab->root.dynamic_sections_created)
1253
    {
1254
      /* Set the contents of the .interp section to the interpreter.  */
1255
      if (! info->shared)
1256
        {
1257
          s = bfd_get_section_by_name (dynobj, ".interp");
1258
          if (s == NULL)
1259
            abort ();
1260
          s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
1261
          s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1262
        }
1263
    }
1264
 
1265
  /* Set up .got offsets for local syms.  */
1266
  for (i = info->input_bfds; i; i = i->link_next)
1267
    {
1268
      bfd_signed_vma *local_got;
1269
      bfd_signed_vma *end_local_got;
1270
      bfd_size_type locsymcount;
1271
      Elf_Internal_Shdr *symtab_hdr;
1272
      asection *srel;
1273
 
1274
      if (bfd_get_flavour (i) != bfd_target_elf_flavour)
1275
        continue;
1276
 
1277
      local_got = elf_local_got_refcounts (i);
1278
      if (!local_got)
1279
        continue;
1280
 
1281
      symtab_hdr = &elf_tdata (i)->symtab_hdr;
1282
      locsymcount = symtab_hdr->sh_info;
1283
      end_local_got = local_got + locsymcount;
1284
      s = htab->sgot;
1285
      srel = htab->srelgot;
1286
      for (; local_got < end_local_got; ++local_got)
1287
        {
1288
          if (*local_got > 0)
1289
            {
1290
              *local_got = s->_raw_size;
1291
              s->_raw_size += 4;
1292
              if (info->shared)
1293
                srel->_raw_size += sizeof (Elf32_External_Rel);
1294
            }
1295
          else
1296
            *local_got = (bfd_vma) -1;
1297
        }
1298
    }
1299
 
1300
  /* Allocate global sym .plt and .got entries.  Also discard all
1301
     unneeded relocs.  */
1302
  elf_link_hash_traverse (&htab->root,
1303
                          allocate_plt_and_got_and_discard_relocs,
1304
                          (PTR) info);
1305
 
1306
  /* We now have determined the sizes of the various dynamic sections.
1307
     Allocate memory for them.  */
1308
  relocs = false;
1309
  reltext = false;
1310
  for (s = dynobj->sections; s != NULL; s = s->next)
1311
    {
1312
      if ((s->flags & SEC_LINKER_CREATED) == 0)
1313
        continue;
1314
 
1315
      if (s == htab->splt
1316
          || s == htab->sgot
1317
          || s == htab->sgotplt)
1318
        {
1319
          /* Strip this section if we don't need it; see the
1320
             comment below.  */
1321
        }
1322
      else if (strncmp (bfd_get_section_name (dynobj, s), ".rel", 4) == 0)
1323
        {
1324
          if (s->_raw_size == 0)
1325
            {
1326
              /* If we don't need this section, strip it from the
1327
                 output file.  This is mostly to handle .rel.bss and
1328
                 .rel.plt.  We must create both sections in
1329
                 create_dynamic_sections, because they must be created
1330
                 before the linker maps input sections to output
1331
                 sections.  The linker does that before
1332
                 adjust_dynamic_symbol is called, and it is that
1333
                 function which decides whether anything needs to go
1334
                 into these sections.  */
1335
            }
1336
          else
1337
            {
1338
              asection *target;
1339
 
1340
              /* Remember whether there are any reloc sections other
1341
                 than .rel.plt.  */
1342
              if (s != htab->srelplt)
1343
                {
1344
                  const char *outname;
1345
 
1346
                  relocs = true;
1347
 
1348
                  /* If this relocation section applies to a read only
1349
                     section, then we probably need a DT_TEXTREL
1350
                     entry.  The entries in the .rel.plt section
1351
                     really apply to the .got section, which we
1352
                     created ourselves and so know is not readonly.  */
1353
                  outname = bfd_get_section_name (output_bfd,
1354
                                                  s->output_section);
1355
                  target = bfd_get_section_by_name (output_bfd, outname + 4);
1356
                  if (target != NULL
1357
                      && (target->flags & SEC_READONLY) != 0
1358
                      && (target->flags & SEC_ALLOC) != 0)
1359
                    reltext = true;
1360
                }
1361
 
1362
              /* We use the reloc_count field as a counter if we need
1363
                 to copy relocs into the output file.  */
1364
              s->reloc_count = 0;
1365
            }
1366
        }
1367
      else
1368
        {
1369
          /* It's not one of our sections, so don't allocate space.  */
1370
          continue;
1371
        }
1372
 
1373
      if (s->_raw_size == 0)
1374
        {
1375
          _bfd_strip_section_from_output (info, s);
1376
          continue;
1377
        }
1378
 
1379
      /* Allocate memory for the section contents.  We use bfd_zalloc
1380
         here in case unused entries are not reclaimed before the
1381
         section's contents are written out.  This should not happen,
1382
         but this way if it does, we get a R_386_NONE reloc instead
1383
         of garbage.  */
1384
      s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
1385
      if (s->contents == NULL)
1386
        return false;
1387
    }
1388
 
1389
  if (htab->root.dynamic_sections_created)
1390
    {
1391
      /* Add some entries to the .dynamic section.  We fill in the
1392
         values later, in elf_i386_finish_dynamic_sections, but we
1393
         must add the entries now so that we get the correct size for
1394
         the .dynamic section.  The DT_DEBUG entry is filled in by the
1395
         dynamic linker and used by the debugger.  */
1396
      if (! info->shared)
1397
        {
1398
          if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0))
1399
            return false;
1400
        }
1401
 
1402
      if (htab->splt->_raw_size != 0)
1403
        {
1404
          if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0)
1405
              || ! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
1406
              || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_REL)
1407
              || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
1408
            return false;
1409
        }
1410
 
1411
      if (relocs)
1412
        {
1413
          if (! bfd_elf32_add_dynamic_entry (info, DT_REL, 0)
1414
              || ! bfd_elf32_add_dynamic_entry (info, DT_RELSZ, 0)
1415
              || ! bfd_elf32_add_dynamic_entry (info, DT_RELENT,
1416
                                                sizeof (Elf32_External_Rel)))
1417
            return false;
1418
        }
1419
 
1420
      if (reltext)
1421
        {
1422
          if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0))
1423
            return false;
1424
          info->flags |= DF_TEXTREL;
1425
        }
1426
    }
1427
 
1428
  return true;
1429
}
1430
 
1431
/* Relocate an i386 ELF section.  */
1432
 
1433
static boolean
1434
elf_i386_relocate_section (output_bfd, info, input_bfd, input_section,
1435
                           contents, relocs, local_syms, local_sections)
1436
     bfd *output_bfd;
1437
     struct bfd_link_info *info;
1438
     bfd *input_bfd;
1439
     asection *input_section;
1440
     bfd_byte *contents;
1441
     Elf_Internal_Rela *relocs;
1442
     Elf_Internal_Sym *local_syms;
1443
     asection **local_sections;
1444
{
1445
  struct elf_i386_link_hash_table *htab;
1446
  bfd *dynobj;
1447
  Elf_Internal_Shdr *symtab_hdr;
1448
  struct elf_link_hash_entry **sym_hashes;
1449
  bfd_vma *local_got_offsets;
1450
  asection *sreloc;
1451
  Elf_Internal_Rela *rel;
1452
  Elf_Internal_Rela *relend;
1453
 
1454
  htab = elf_i386_hash_table (info);
1455
  dynobj = htab->root.dynobj;
1456
  symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1457
  sym_hashes = elf_sym_hashes (input_bfd);
1458
  local_got_offsets = elf_local_got_offsets (input_bfd);
1459
 
1460
  sreloc = NULL;
1461
  rel = relocs;
1462
  relend = relocs + input_section->reloc_count;
1463
  for (; rel < relend; rel++)
1464
    {
1465
      int r_type;
1466
      reloc_howto_type *howto;
1467
      unsigned long r_symndx;
1468
      struct elf_link_hash_entry *h;
1469
      Elf_Internal_Sym *sym;
1470
      asection *sec;
1471
      bfd_vma off;
1472
      bfd_vma relocation;
1473
      boolean unresolved_reloc;
1474
      bfd_reloc_status_type r;
1475
      unsigned int indx;
1476
 
1477
      r_type = ELF32_R_TYPE (rel->r_info);
1478
      if (r_type == (int) R_386_GNU_VTINHERIT
1479
          || r_type == (int) R_386_GNU_VTENTRY)
1480
        continue;
1481
 
1482
      if ((indx = (unsigned) r_type) >= R_386_standard
1483
          && ((indx = (unsigned) r_type - R_386_ext_offset) - R_386_standard
1484
              >= R_386_ext - R_386_standard))
1485
        {
1486
          bfd_set_error (bfd_error_bad_value);
1487
          return false;
1488
        }
1489
      howto = elf_howto_table + indx;
1490
 
1491
      r_symndx = ELF32_R_SYM (rel->r_info);
1492
 
1493
      if (info->relocateable)
1494
        {
1495
          /* This is a relocateable link.  We don't have to change
1496
             anything, unless the reloc is against a section symbol,
1497
             in which case we have to adjust according to where the
1498
             section symbol winds up in the output section.  */
1499
          if (r_symndx < symtab_hdr->sh_info)
1500
            {
1501
              sym = local_syms + r_symndx;
1502
              if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1503
                {
1504
                  bfd_vma val;
1505
 
1506
                  sec = local_sections[r_symndx];
1507
                  val = bfd_get_32 (input_bfd, contents + rel->r_offset);
1508
                  val += sec->output_offset + sym->st_value;
1509
                  bfd_put_32 (input_bfd, val, contents + rel->r_offset);
1510
                }
1511
            }
1512
 
1513
          continue;
1514
        }
1515
 
1516
      /* This is a final link.  */
1517
      h = NULL;
1518
      sym = NULL;
1519
      sec = NULL;
1520
      unresolved_reloc = false;
1521
      if (r_symndx < symtab_hdr->sh_info)
1522
        {
1523
          sym = local_syms + r_symndx;
1524
          sec = local_sections[r_symndx];
1525
          relocation = (sec->output_section->vma
1526
                        + sec->output_offset
1527
                        + sym->st_value);
1528
        }
1529
      else
1530
        {
1531
          h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1532
          while (h->root.type == bfd_link_hash_indirect
1533
                 || h->root.type == bfd_link_hash_warning)
1534
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
1535
 
1536
          relocation = 0;
1537
          if (h->root.type == bfd_link_hash_defined
1538
              || h->root.type == bfd_link_hash_defweak)
1539
            {
1540
              sec = h->root.u.def.section;
1541
              if (sec->output_section == NULL)
1542
                /* Set a flag that will be cleared later if we find a
1543
                   relocation value for this symbol.  output_section
1544
                   is typically NULL for symbols satisfied by a shared
1545
                   library.  */
1546
                unresolved_reloc = true;
1547
              else
1548
                relocation = (h->root.u.def.value
1549
                              + sec->output_section->vma
1550
                              + sec->output_offset);
1551
            }
1552
          else if (h->root.type == bfd_link_hash_undefweak)
1553
            ;
1554
          else if (info->shared && !info->symbolic
1555
                   && !info->no_undefined
1556
                   && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1557
            ;
1558
          else
1559
            {
1560
              if (! ((*info->callbacks->undefined_symbol)
1561
                     (info, h->root.root.string, input_bfd,
1562
                      input_section, rel->r_offset,
1563
                      (!info->shared || info->no_undefined
1564
                       || ELF_ST_VISIBILITY (h->other)))))
1565
                return false;
1566
            }
1567
        }
1568
 
1569
      switch (r_type)
1570
        {
1571
        case R_386_GOT32:
1572
          /* Relocation is to the entry for this symbol in the global
1573
             offset table.  */
1574
          if (htab->sgot == NULL)
1575
            abort ();
1576
 
1577
          if (h != NULL)
1578
            {
1579
              boolean dyn;
1580
 
1581
              off = h->got.offset;
1582
              dyn = htab->root.dynamic_sections_created;
1583
              if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h)
1584
                  || (info->shared
1585
                      && (info->symbolic
1586
                          || h->dynindx == -1
1587
                          || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
1588
                      && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1589
                {
1590
                  /* This is actually a static link, or it is a
1591
                     -Bsymbolic link and the symbol is defined
1592
                     locally, or the symbol was forced to be local
1593
                     because of a version file.  We must initialize
1594
                     this entry in the global offset table.  Since the
1595
                     offset must always be a multiple of 4, we use the
1596
                     least significant bit to record whether we have
1597
                     initialized it already.
1598
 
1599
                     When doing a dynamic link, we create a .rel.got
1600
                     relocation entry to initialize the value.  This
1601
                     is done in the finish_dynamic_symbol routine.  */
1602
                  if ((off & 1) != 0)
1603
                    off &= ~1;
1604
                  else
1605
                    {
1606
                      bfd_put_32 (output_bfd, relocation,
1607
                                  htab->sgot->contents + off);
1608
                      h->got.offset |= 1;
1609
                    }
1610
                }
1611
              else
1612
                unresolved_reloc = false;
1613
            }
1614
          else
1615
            {
1616
              if (local_got_offsets == NULL)
1617
                abort ();
1618
 
1619
              off = local_got_offsets[r_symndx];
1620
 
1621
              /* The offset must always be a multiple of 4.  We use
1622
                 the least significant bit to record whether we have
1623
                 already generated the necessary reloc.  */
1624
              if ((off & 1) != 0)
1625
                off &= ~1;
1626
              else
1627
                {
1628
                  bfd_put_32 (output_bfd, relocation,
1629
                              htab->sgot->contents + off);
1630
 
1631
                  if (info->shared)
1632
                    {
1633
                      asection *srelgot;
1634
                      Elf_Internal_Rel outrel;
1635
 
1636
                      srelgot = htab->srelgot;
1637
                      if (srelgot == NULL)
1638
                        abort ();
1639
 
1640
                      outrel.r_offset = (htab->sgot->output_section->vma
1641
                                         + htab->sgot->output_offset
1642
                                         + off);
1643
                      outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1644
                      bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1645
                                                (((Elf32_External_Rel *)
1646
                                                  srelgot->contents)
1647
                                                 + srelgot->reloc_count));
1648
                      ++srelgot->reloc_count;
1649
                    }
1650
 
1651
                  local_got_offsets[r_symndx] |= 1;
1652
                }
1653
            }
1654
 
1655
          if (off >= (bfd_vma) -2)
1656
            abort ();
1657
 
1658
          relocation = htab->sgot->output_offset + off;
1659
          break;
1660
 
1661
        case R_386_GOTOFF:
1662
          /* Relocation is relative to the start of the global offset
1663
             table.  */
1664
 
1665
          /* Note that sgot->output_offset is not involved in this
1666
             calculation.  We always want the start of .got.  If we
1667
             defined _GLOBAL_OFFSET_TABLE in a different way, as is
1668
             permitted by the ABI, we might have to change this
1669
             calculation.  */
1670
          relocation -= htab->sgot->output_section->vma;
1671
          break;
1672
 
1673
        case R_386_GOTPC:
1674
          /* Use global offset table as symbol value.  */
1675
          relocation = htab->sgot->output_section->vma;
1676
          unresolved_reloc = false;
1677
          break;
1678
 
1679
        case R_386_PLT32:
1680
          /* Relocation is to the entry for this symbol in the
1681
             procedure linkage table.  */
1682
 
1683
          /* Resolve a PLT32 reloc against a local symbol directly,
1684
             without using the procedure linkage table.  */
1685
          if (h == NULL)
1686
            break;
1687
 
1688
          if (h->plt.offset == (bfd_vma) -1
1689
              || htab->splt == NULL)
1690
            {
1691
              /* We didn't make a PLT entry for this symbol.  This
1692
                 happens when statically linking PIC code, or when
1693
                 using -Bsymbolic.  */
1694
              break;
1695
            }
1696
 
1697
          relocation = (htab->splt->output_section->vma
1698
                        + htab->splt->output_offset
1699
                        + h->plt.offset);
1700
          unresolved_reloc = false;
1701
          break;
1702
 
1703
        case R_386_32:
1704
        case R_386_PC32:
1705
          if ((info->shared
1706
               && (input_section->flags & SEC_ALLOC) != 0
1707
               && (r_type != R_386_PC32
1708
                   || (h != NULL
1709
                       && h->dynindx != -1
1710
                       && (! info->symbolic
1711
                           || (h->elf_link_hash_flags
1712
                               & ELF_LINK_HASH_DEF_REGULAR) == 0))))
1713
              || (!info->shared
1714
                  && (input_section->flags & SEC_ALLOC) != 0
1715
                  && h != NULL
1716
                  && h->dynindx != -1
1717
                  && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
1718
                  && ((h->elf_link_hash_flags
1719
                       & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1720
                      || h->root.type == bfd_link_hash_undefweak
1721
                      || h->root.type == bfd_link_hash_undefined)))
1722
            {
1723
              Elf_Internal_Rel outrel;
1724
              boolean skip, relocate;
1725
 
1726
              /* When generating a shared object, these relocations
1727
                 are copied into the output file to be resolved at run
1728
                 time.  */
1729
 
1730
              if (sreloc == NULL)
1731
                {
1732
                  const char *name;
1733
 
1734
                  name = (bfd_elf_string_from_elf_section
1735
                          (input_bfd,
1736
                           elf_elfheader (input_bfd)->e_shstrndx,
1737
                           elf_section_data (input_section)->rel_hdr.sh_name));
1738
                  if (name == NULL)
1739
                    return false;
1740
 
1741
                  if (strncmp (name, ".rel", 4) != 0
1742
                      || strcmp (bfd_get_section_name (input_bfd,
1743
                                                       input_section),
1744
                                 name + 4) != 0)
1745
                    {
1746
                      if (input_bfd->my_archive)
1747
                        (*_bfd_error_handler)\
1748
                          (_("%s(%s): bad relocation section name `%s\'"),
1749
                           bfd_get_filename (input_bfd->my_archive),
1750
                           bfd_get_filename (input_bfd),
1751
                           name);
1752
                      else
1753
                        (*_bfd_error_handler)
1754
                          (_("%s: bad relocation section name `%s\'"),
1755
                           bfd_get_filename (input_bfd),
1756
                           name);
1757
                      return false;
1758
                    }
1759
 
1760
                  sreloc = bfd_get_section_by_name (dynobj, name);
1761
                  if (sreloc == NULL)
1762
                    abort ();
1763
                }
1764
 
1765
              skip = false;
1766
 
1767
              if (elf_section_data (input_section)->stab_info == NULL)
1768
                outrel.r_offset = rel->r_offset;
1769
              else
1770
                {
1771
                  bfd_vma off;
1772
 
1773
                  off = (_bfd_stab_section_offset
1774
                         (output_bfd, htab->root.stab_info, input_section,
1775
                          &elf_section_data (input_section)->stab_info,
1776
                          rel->r_offset));
1777
                  if (off == (bfd_vma) -1)
1778
                    skip = true;
1779
                  outrel.r_offset = off;
1780
                }
1781
 
1782
              outrel.r_offset += (input_section->output_section->vma
1783
                                  + input_section->output_offset);
1784
 
1785
              if (skip)
1786
                {
1787
                  memset (&outrel, 0, sizeof outrel);
1788
                  relocate = false;
1789
                }
1790
              else if (h != NULL
1791
                       && h->dynindx != -1
1792
                       && (r_type == R_386_PC32
1793
                           || !info->shared
1794
                           || !info->symbolic
1795
                           || (h->elf_link_hash_flags
1796
                               & ELF_LINK_HASH_DEF_REGULAR) == 0))
1797
 
1798
                {
1799
                  relocate = false;
1800
                  outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1801
                }
1802
              else
1803
                {
1804
                  /* This symbol is local, or marked to become local.  */
1805
                  relocate = true;
1806
                  outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1807
                }
1808
 
1809
              bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1810
                                        (((Elf32_External_Rel *)
1811
                                          sreloc->contents)
1812
                                         + sreloc->reloc_count));
1813
              ++sreloc->reloc_count;
1814
 
1815
              /* If this reloc is against an external symbol, we do
1816
                 not want to fiddle with the addend.  Otherwise, we
1817
                 need to include the symbol value so that it becomes
1818
                 an addend for the dynamic reloc.  */
1819
              if (! relocate)
1820
                continue;
1821
            }
1822
 
1823
          break;
1824
 
1825
        default:
1826
          break;
1827
        }
1828
 
1829
      /* FIXME: Why do we allow debugging sections to escape this error?
1830
         More importantly, why do we not emit dynamic relocs for
1831
         R_386_32 above in debugging sections (which are ! SEC_ALLOC)?
1832
         If we had emitted the dynamic reloc, we could remove the
1833
         fudge here.  */
1834
      if (unresolved_reloc
1835
          && !(info->shared
1836
               && (input_section->flags & SEC_DEBUGGING) != 0
1837
               && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
1838
        (*_bfd_error_handler)
1839
          (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
1840
           bfd_get_filename (input_bfd),
1841
           bfd_get_section_name (input_bfd, input_section),
1842
           (long) rel->r_offset,
1843
           h->root.root.string);
1844
 
1845
      r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1846
                                    contents, rel->r_offset,
1847
                                    relocation, (bfd_vma) 0);
1848
 
1849
      switch (r)
1850
        {
1851
        case bfd_reloc_ok:
1852
          break;
1853
 
1854
        case bfd_reloc_overflow:
1855
          {
1856
            const char *name;
1857
 
1858
            if (h != NULL)
1859
              name = h->root.root.string;
1860
            else
1861
              {
1862
                name = bfd_elf_string_from_elf_section (input_bfd,
1863
                                                        symtab_hdr->sh_link,
1864
                                                        sym->st_name);
1865
                if (name == NULL)
1866
                  return false;
1867
                if (*name == '\0')
1868
                  name = bfd_section_name (input_bfd, sec);
1869
              }
1870
            if (! ((*info->callbacks->reloc_overflow)
1871
                   (info, name, howto->name, (bfd_vma) 0,
1872
                    input_bfd, input_section, rel->r_offset)))
1873
              return false;
1874
          }
1875
          break;
1876
 
1877
        default:
1878
        case bfd_reloc_outofrange:
1879
          abort ();
1880
          break;
1881
        }
1882
    }
1883
 
1884
  return true;
1885
}
1886
 
1887
/* Finish up dynamic symbol handling.  We set the contents of various
1888
   dynamic sections here.  */
1889
 
1890
static boolean
1891
elf_i386_finish_dynamic_symbol (output_bfd, info, h, sym)
1892
     bfd *output_bfd;
1893
     struct bfd_link_info *info;
1894
     struct elf_link_hash_entry *h;
1895
     Elf_Internal_Sym *sym;
1896
{
1897
  struct elf_i386_link_hash_table *htab;
1898
  bfd *dynobj;
1899
 
1900
  htab = elf_i386_hash_table (info);
1901
  dynobj = htab->root.dynobj;
1902
 
1903
  if (h->plt.offset != (bfd_vma) -1)
1904
    {
1905
      bfd_vma plt_index;
1906
      bfd_vma got_offset;
1907
      Elf_Internal_Rel rel;
1908
 
1909
      /* This symbol has an entry in the procedure linkage table.  Set
1910
         it up.  */
1911
 
1912
      if (h->dynindx == -1
1913
          || htab->splt == NULL
1914
          || htab->sgotplt == NULL
1915
          || htab->srelplt == NULL)
1916
        abort ();
1917
 
1918
      /* Get the index in the procedure linkage table which
1919
         corresponds to this symbol.  This is the index of this symbol
1920
         in all the symbols for which we are making plt entries.  The
1921
         first entry in the procedure linkage table is reserved.  */
1922
      plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1923
 
1924
      /* Get the offset into the .got table of the entry that
1925
         corresponds to this function.  Each .got entry is 4 bytes.
1926
         The first three are reserved.  */
1927
      got_offset = (plt_index + 3) * 4;
1928
 
1929
      /* Fill in the entry in the procedure linkage table.  */
1930
      if (! info->shared)
1931
        {
1932
          memcpy (htab->splt->contents + h->plt.offset, elf_i386_plt_entry,
1933
                  PLT_ENTRY_SIZE);
1934
          bfd_put_32 (output_bfd,
1935
                      (htab->sgotplt->output_section->vma
1936
                       + htab->sgotplt->output_offset
1937
                       + got_offset),
1938
                      htab->splt->contents + h->plt.offset + 2);
1939
        }
1940
      else
1941
        {
1942
          memcpy (htab->splt->contents + h->plt.offset, elf_i386_pic_plt_entry,
1943
                  PLT_ENTRY_SIZE);
1944
          bfd_put_32 (output_bfd, got_offset,
1945
                      htab->splt->contents + h->plt.offset + 2);
1946
        }
1947
 
1948
      bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
1949
                  htab->splt->contents + h->plt.offset + 7);
1950
      bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
1951
                  htab->splt->contents + h->plt.offset + 12);
1952
 
1953
      /* Fill in the entry in the global offset table.  */
1954
      bfd_put_32 (output_bfd,
1955
                  (htab->splt->output_section->vma
1956
                   + htab->splt->output_offset
1957
                   + h->plt.offset
1958
                   + 6),
1959
                  htab->sgotplt->contents + got_offset);
1960
 
1961
      /* Fill in the entry in the .rel.plt section.  */
1962
      rel.r_offset = (htab->sgotplt->output_section->vma
1963
                      + htab->sgotplt->output_offset
1964
                      + got_offset);
1965
      rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
1966
      bfd_elf32_swap_reloc_out (output_bfd, &rel,
1967
                                ((Elf32_External_Rel *) htab->srelplt->contents
1968
                                 + plt_index));
1969
 
1970
      if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1971
        {
1972
          /* Mark the symbol as undefined, rather than as defined in
1973
             the .plt section.  Leave the value alone.  */
1974
          sym->st_shndx = SHN_UNDEF;
1975
        }
1976
    }
1977
 
1978
  if (h->got.offset != (bfd_vma) -1)
1979
    {
1980
      Elf_Internal_Rel rel;
1981
 
1982
      /* This symbol has an entry in the global offset table.  Set it
1983
         up.  */
1984
 
1985
      if (htab->sgot == NULL || htab->srelgot == NULL)
1986
        abort ();
1987
 
1988
      rel.r_offset = (htab->sgot->output_section->vma
1989
                      + htab->sgot->output_offset
1990
                      + (h->got.offset &~ 1));
1991
 
1992
      /* If this is a static link, or it is a -Bsymbolic link and the
1993
         symbol is defined locally or was forced to be local because
1994
         of a version file, we just want to emit a RELATIVE reloc.
1995
         The entry in the global offset table will already have been
1996
         initialized in the relocate_section function.  */
1997
      if (info->shared
1998
          && (info->symbolic
1999
              || h->dynindx == -1
2000
              || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
2001
          && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
2002
        {
2003
          BFD_ASSERT((h->got.offset & 1) != 0);
2004
          rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2005
        }
2006
      else
2007
        {
2008
          BFD_ASSERT((h->got.offset & 1) == 0);
2009
          bfd_put_32 (output_bfd, (bfd_vma) 0,
2010
                      htab->sgot->contents + h->got.offset);
2011
          rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
2012
        }
2013
 
2014
      bfd_elf32_swap_reloc_out (output_bfd, &rel,
2015
                                ((Elf32_External_Rel *) htab->srelgot->contents
2016
                                 + htab->srelgot->reloc_count));
2017
      ++htab->srelgot->reloc_count;
2018
    }
2019
 
2020
  if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
2021
    {
2022
      Elf_Internal_Rel rel;
2023
 
2024
      /* This symbol needs a copy reloc.  Set it up.  */
2025
 
2026
      if (h->dynindx == -1
2027
          || (h->root.type != bfd_link_hash_defined
2028
              && h->root.type != bfd_link_hash_defweak)
2029
          || htab->srelbss == NULL)
2030
        abort ();
2031
 
2032
      rel.r_offset = (h->root.u.def.value
2033
                      + h->root.u.def.section->output_section->vma
2034
                      + h->root.u.def.section->output_offset);
2035
      rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
2036
      bfd_elf32_swap_reloc_out (output_bfd, &rel,
2037
                                ((Elf32_External_Rel *) htab->srelbss->contents
2038
                                 + htab->srelbss->reloc_count));
2039
      ++htab->srelbss->reloc_count;
2040
    }
2041
 
2042
  /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
2043
  if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2044
      || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2045
    sym->st_shndx = SHN_ABS;
2046
 
2047
  return true;
2048
}
2049
 
2050
/* Finish up the dynamic sections.  */
2051
 
2052
static boolean
2053
elf_i386_finish_dynamic_sections (output_bfd, info)
2054
     bfd *output_bfd;
2055
     struct bfd_link_info *info;
2056
{
2057
  struct elf_i386_link_hash_table *htab;
2058
  bfd *dynobj;
2059
  asection *sdyn;
2060
 
2061
  htab = elf_i386_hash_table (info);
2062
  dynobj = htab->root.dynobj;
2063
  sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2064
 
2065
  if (htab->root.dynamic_sections_created)
2066
    {
2067
      Elf32_External_Dyn *dyncon, *dynconend;
2068
 
2069
      if (sdyn == NULL || htab->sgot == NULL)
2070
        abort ();
2071
 
2072
      dyncon = (Elf32_External_Dyn *) sdyn->contents;
2073
      dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
2074
      for (; dyncon < dynconend; dyncon++)
2075
        {
2076
          Elf_Internal_Dyn dyn;
2077
 
2078
          bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
2079
 
2080
          switch (dyn.d_tag)
2081
            {
2082
            default:
2083
              break;
2084
 
2085
            case DT_PLTGOT:
2086
              dyn.d_un.d_ptr = htab->sgot->output_section->vma;
2087
              bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2088
              break;
2089
 
2090
            case DT_JMPREL:
2091
              dyn.d_un.d_ptr = htab->srelplt->output_section->vma;
2092
              bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2093
              break;
2094
 
2095
            case DT_PLTRELSZ:
2096
              if (htab->srelplt->output_section->_cooked_size != 0)
2097
                dyn.d_un.d_val = htab->srelplt->output_section->_cooked_size;
2098
              else
2099
                dyn.d_un.d_val = htab->srelplt->output_section->_raw_size;
2100
              bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2101
              break;
2102
 
2103
            case DT_RELSZ:
2104
              /* My reading of the SVR4 ABI indicates that the
2105
                 procedure linkage table relocs (DT_JMPREL) should be
2106
                 included in the overall relocs (DT_REL).  This is
2107
                 what Solaris does.  However, UnixWare can not handle
2108
                 that case.  Therefore, we override the DT_RELSZ entry
2109
                 here to make it not include the JMPREL relocs.  Since
2110
                 the linker script arranges for .rel.plt to follow all
2111
                 other relocation sections, we don't have to worry
2112
                 about changing the DT_REL entry.  */
2113
              if (htab->srelplt != NULL)
2114
                {
2115
                  if (htab->srelplt->output_section->_cooked_size != 0)
2116
                    dyn.d_un.d_val -= htab->srelplt->output_section->_cooked_size;
2117
                  else
2118
                    dyn.d_un.d_val -= htab->srelplt->output_section->_raw_size;
2119
                }
2120
              bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2121
              break;
2122
            }
2123
        }
2124
 
2125
      /* Fill in the first entry in the procedure linkage table.  */
2126
      if (htab->splt && htab->splt->_raw_size > 0)
2127
        {
2128
          if (info->shared)
2129
            memcpy (htab->splt->contents,
2130
                    elf_i386_pic_plt0_entry, PLT_ENTRY_SIZE);
2131
          else
2132
            {
2133
              memcpy (htab->splt->contents,
2134
                      elf_i386_plt0_entry, PLT_ENTRY_SIZE);
2135
              bfd_put_32 (output_bfd,
2136
                          (htab->sgotplt->output_section->vma
2137
                           + htab->sgotplt->output_offset
2138
                           + 4),
2139
                          htab->splt->contents + 2);
2140
              bfd_put_32 (output_bfd,
2141
                          (htab->sgotplt->output_section->vma
2142
                           + htab->sgotplt->output_offset
2143
                           + 8),
2144
                          htab->splt->contents + 8);
2145
            }
2146
 
2147
          /* UnixWare sets the entsize of .plt to 4, although that doesn't
2148
             really seem like the right value.  */
2149
          elf_section_data (htab->splt->output_section)
2150
            ->this_hdr.sh_entsize = 4;
2151
        }
2152
    }
2153
 
2154
  if (htab->sgotplt)
2155
    {
2156
      /* Fill in the first three entries in the global offset table.  */
2157
      if (htab->sgotplt->_raw_size > 0)
2158
        {
2159
          bfd_put_32 (output_bfd,
2160
                      (sdyn == NULL ? (bfd_vma) 0
2161
                       : sdyn->output_section->vma + sdyn->output_offset),
2162
                      htab->sgotplt->contents);
2163
          bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 4);
2164
          bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 8);
2165
        }
2166
 
2167
      elf_section_data (htab->sgotplt->output_section)->this_hdr.sh_entsize = 4;
2168
    }
2169
  return true;
2170
}
2171
 
2172
/* Set the correct type for an x86 ELF section.  We do this by the
2173
   section name, which is a hack, but ought to work.  */
2174
 
2175
static boolean
2176
elf_i386_fake_sections (abfd, hdr, sec)
2177
     bfd *abfd ATTRIBUTE_UNUSED;
2178
     Elf32_Internal_Shdr *hdr;
2179
     asection *sec;
2180
{
2181
  register const char *name;
2182
 
2183
  name = bfd_get_section_name (abfd, sec);
2184
 
2185
  if (strcmp (name, ".reloc") == 0)
2186
    /*
2187
     * This is an ugly, but unfortunately necessary hack that is
2188
     * needed when producing EFI binaries on x86. It tells
2189
     * elf.c:elf_fake_sections() not to consider ".reloc" as a section
2190
     * containing ELF relocation info.  We need this hack in order to
2191
     * be able to generate ELF binaries that can be translated into
2192
     * EFI applications (which are essentially COFF objects).  Those
2193
     * files contain a COFF ".reloc" section inside an ELFNN object,
2194
     * which would normally cause BFD to segfault because it would
2195
     * attempt to interpret this section as containing relocation
2196
     * entries for section "oc".  With this hack enabled, ".reloc"
2197
     * will be treated as a normal data section, which will avoid the
2198
     * segfault.  However, you won't be able to create an ELFNN binary
2199
     * with a section named "oc" that needs relocations, but that's
2200
     * the kind of ugly side-effects you get when detecting section
2201
     * types based on their names...  In practice, this limitation is
2202
     * unlikely to bite.
2203
     */
2204
    hdr->sh_type = SHT_PROGBITS;
2205
 
2206
  return true;
2207
}
2208
 
2209
 
2210
#define TARGET_LITTLE_SYM               bfd_elf32_i386_vec
2211
#define TARGET_LITTLE_NAME              "elf32-i386"
2212
#define ELF_ARCH                        bfd_arch_i386
2213
#define ELF_MACHINE_CODE                EM_386
2214
#define ELF_MAXPAGESIZE                 0x1000
2215
 
2216
#define elf_backend_can_gc_sections     1
2217
#define elf_backend_want_got_plt        1
2218
#define elf_backend_plt_readonly        1
2219
#define elf_backend_want_plt_sym        0
2220
#define elf_backend_got_header_size     12
2221
#define elf_backend_plt_header_size     PLT_ENTRY_SIZE
2222
 
2223
#define elf_info_to_howto                     elf_i386_info_to_howto
2224
#define elf_info_to_howto_rel                 elf_i386_info_to_howto_rel
2225
 
2226
#define bfd_elf32_bfd_is_local_label_name     elf_i386_is_local_label_name
2227
#define bfd_elf32_bfd_link_hash_table_create  elf_i386_link_hash_table_create
2228
#define bfd_elf32_bfd_reloc_type_lookup       elf_i386_reloc_type_lookup
2229
 
2230
#define elf_backend_adjust_dynamic_symbol     elf_i386_adjust_dynamic_symbol
2231
#define elf_backend_check_relocs              elf_i386_check_relocs
2232
#define elf_backend_create_dynamic_sections   elf_i386_create_dynamic_sections
2233
#define elf_backend_finish_dynamic_sections   elf_i386_finish_dynamic_sections
2234
#define elf_backend_finish_dynamic_symbol     elf_i386_finish_dynamic_symbol
2235
#define elf_backend_gc_mark_hook              elf_i386_gc_mark_hook
2236
#define elf_backend_gc_sweep_hook             elf_i386_gc_sweep_hook
2237
#define elf_backend_relocate_section          elf_i386_relocate_section
2238
#define elf_backend_size_dynamic_sections     elf_i386_size_dynamic_sections
2239
#define elf_backend_fake_sections             elf_i386_fake_sections
2240
 
2241
#include "elf32-target.h"

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.