Coverage Report

Created: 2024-05-21 06:29

/src/binutils-gdb/bfd/elfxx-x86.c
Line
Count
Source (jump to first uncovered line)
1
/* x86 specific support for ELF
2
   Copyright (C) 2017-2024 Free Software Foundation, Inc.
3
4
   This file is part of BFD, the Binary File Descriptor library.
5
6
   This program is free software; you can redistribute it and/or modify
7
   it under the terms of the GNU General Public License as published by
8
   the Free Software Foundation; either version 3 of the License, or
9
   (at your option) any later version.
10
11
   This program is distributed in the hope that it will be useful,
12
   but WITHOUT ANY WARRANTY; without even the implied warranty of
13
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
   GNU General Public License for more details.
15
16
   You should have received a copy of the GNU General Public License
17
   along with this program; if not, write to the Free Software
18
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19
   MA 02110-1301, USA.  */
20
21
#include "elfxx-x86.h"
22
#include "elf-vxworks.h"
23
#include "objalloc.h"
24
25
/* The name of the dynamic interpreter.  This is put in the .interp
26
   section.  */
27
28
0
#define ELF32_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
29
0
#define ELF64_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
30
0
#define ELFX32_DYNAMIC_INTERPRETER "/lib/ldx32.so.1"
31
32
bool
33
_bfd_x86_elf_mkobject (bfd *abfd)
34
1.45M
{
35
1.45M
  return bfd_elf_allocate_object (abfd,
36
1.45M
          sizeof (struct elf_x86_obj_tdata),
37
1.45M
          get_elf_backend_data (abfd)->target_id);
38
1.45M
}
39
40
/* _TLS_MODULE_BASE_ needs to be treated especially when linking
41
   executables.  Rather than setting it to the beginning of the TLS
42
   section, we have to set it to the end.    This function may be called
43
   multiple times, it is idempotent.  */
44
45
void
46
_bfd_x86_elf_set_tls_module_base (struct bfd_link_info *info)
47
0
{
48
0
  struct elf_x86_link_hash_table *htab;
49
0
  struct bfd_link_hash_entry *base;
50
0
  const struct elf_backend_data *bed;
51
52
0
  if (!bfd_link_executable (info))
53
0
    return;
54
55
0
  bed = get_elf_backend_data (info->output_bfd);
56
0
  htab = elf_x86_hash_table (info, bed->target_id);
57
0
  if (htab == NULL)
58
0
    return;
59
60
0
  base = htab->tls_module_base;
61
0
  if (base == NULL)
62
0
    return;
63
64
0
  base->u.def.value = htab->elf.tls_size;
65
0
}
66
67
/* Return the base VMA address which should be subtracted from real addresses
68
   when resolving @dtpoff relocation.
69
   This is PT_TLS segment p_vaddr.  */
70
71
bfd_vma
72
_bfd_x86_elf_dtpoff_base (struct bfd_link_info *info)
73
0
{
74
  /* If tls_sec is NULL, we should have signalled an error already.  */
75
0
  if (elf_hash_table (info)->tls_sec == NULL)
76
0
    return 0;
77
0
  return elf_hash_table (info)->tls_sec->vma;
78
0
}
79
80
/* Allocate space in .plt, .got and associated reloc sections for
81
   dynamic relocs.  */
82
83
static bool
84
elf_x86_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
85
0
{
86
0
  struct bfd_link_info *info;
87
0
  struct elf_x86_link_hash_table *htab;
88
0
  struct elf_x86_link_hash_entry *eh;
89
0
  struct elf_dyn_relocs *p;
90
0
  unsigned int plt_entry_size;
91
0
  bool resolved_to_zero;
92
0
  const struct elf_backend_data *bed;
93
94
0
  if (h->root.type == bfd_link_hash_indirect)
95
0
    return true;
96
97
0
  eh = (struct elf_x86_link_hash_entry *) h;
98
99
0
  info = (struct bfd_link_info *) inf;
100
0
  bed = get_elf_backend_data (info->output_bfd);
101
0
  htab = elf_x86_hash_table (info, bed->target_id);
102
0
  if (htab == NULL)
103
0
    return false;
104
105
0
  plt_entry_size = htab->plt.plt_entry_size;
106
107
0
  resolved_to_zero = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, eh);
108
109
  /* We can't use the GOT PLT if pointer equality is needed since
110
     finish_dynamic_symbol won't clear symbol value and the dynamic
111
     linker won't update the GOT slot.  We will get into an infinite
112
     loop at run-time.  */
113
0
  if (htab->plt_got != NULL
114
0
      && h->type != STT_GNU_IFUNC
115
0
      && !h->pointer_equality_needed
116
0
      && h->plt.refcount > 0
117
0
      && h->got.refcount > 0)
118
0
    {
119
      /* Don't use the regular PLT if there are both GOT and GOTPLT
120
   reloctions.  */
121
0
      h->plt.offset = (bfd_vma) -1;
122
123
      /* Use the GOT PLT.  */
124
0
      eh->plt_got.refcount = 1;
125
0
    }
126
127
  /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
128
     here if it is defined and referenced in a non-shared object.  */
129
0
  if (h->type == STT_GNU_IFUNC
130
0
      && h->def_regular)
131
0
    {
132
      /* GOTOFF relocation needs PLT.  */
133
0
      if (eh->gotoff_ref)
134
0
  h->plt.refcount = 1;
135
136
0
      if (_bfd_elf_allocate_ifunc_dyn_relocs (info, h, &h->dyn_relocs,
137
0
                plt_entry_size,
138
0
                (htab->plt.has_plt0
139
0
                 * plt_entry_size),
140
0
                 htab->got_entry_size,
141
0
                 true))
142
0
  {
143
0
    asection *s = htab->plt_second;
144
0
    if (h->plt.offset != (bfd_vma) -1 && s != NULL)
145
0
      {
146
        /* Use the second PLT section if it is created.  */
147
0
        eh->plt_second.offset = s->size;
148
149
        /* Make room for this entry in the second PLT section.  */
150
0
        s->size += htab->non_lazy_plt->plt_entry_size;
151
0
      }
152
153
0
    return true;
154
0
  }
155
0
      else
156
0
  return false;
157
0
    }
158
  /* Don't create the PLT entry if there are only function pointer
159
     relocations which can be resolved at run-time.  */
160
0
  else if (htab->elf.dynamic_sections_created
161
0
     && (h->plt.refcount > 0
162
0
         || eh->plt_got.refcount > 0))
163
0
    {
164
0
      bool use_plt_got = eh->plt_got.refcount > 0;
165
166
      /* Make sure this symbol is output as a dynamic symbol.
167
   Undefined weak syms won't yet be marked as dynamic.  */
168
0
      if (h->dynindx == -1
169
0
    && !h->forced_local
170
0
    && !resolved_to_zero
171
0
    && h->root.type == bfd_link_hash_undefweak)
172
0
  {
173
0
    if (! bfd_elf_link_record_dynamic_symbol (info, h))
174
0
      return false;
175
0
  }
176
177
0
      if (bfd_link_pic (info)
178
0
    || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
179
0
  {
180
0
    asection *s = htab->elf.splt;
181
0
    asection *second_s = htab->plt_second;
182
0
    asection *got_s = htab->plt_got;
183
0
    bool use_plt;
184
185
    /* If this is the first .plt entry, make room for the special
186
       first entry.  The .plt section is used by prelink to undo
187
       prelinking for dynamic relocations.  */
188
0
    if (s->size == 0)
189
0
      s->size = htab->plt.has_plt0 * plt_entry_size;
190
191
0
    if (use_plt_got)
192
0
      eh->plt_got.offset = got_s->size;
193
0
    else
194
0
      {
195
0
        h->plt.offset = s->size;
196
0
        if (second_s)
197
0
    eh->plt_second.offset = second_s->size;
198
0
      }
199
200
    /* If this symbol is not defined in a regular file, and we are
201
       generating PDE, then set the symbol to this location in the
202
       .plt.  This is required to make function pointers compare
203
       as equal between PDE and the shared library.
204
205
       NB: If PLT is PC-relative, we can use the .plt in PIE for
206
       function address. */
207
0
    if (h->def_regular)
208
0
      use_plt = false;
209
0
    else if (htab->pcrel_plt)
210
0
      use_plt = ! bfd_link_dll (info);
211
0
    else
212
0
      use_plt = bfd_link_pde (info);
213
0
    if (use_plt)
214
0
      {
215
0
        if (use_plt_got)
216
0
    {
217
      /* We need to make a call to the entry of the GOT PLT
218
         instead of regular PLT entry.  */
219
0
      h->root.u.def.section = got_s;
220
0
      h->root.u.def.value = eh->plt_got.offset;
221
0
    }
222
0
        else
223
0
    {
224
0
      if (second_s)
225
0
        {
226
          /* We need to make a call to the entry of the
227
       second PLT instead of regular PLT entry.  */
228
0
          h->root.u.def.section = second_s;
229
0
          h->root.u.def.value = eh->plt_second.offset;
230
0
        }
231
0
      else
232
0
        {
233
0
          h->root.u.def.section = s;
234
0
          h->root.u.def.value = h->plt.offset;
235
0
        }
236
0
    }
237
0
      }
238
239
    /* Make room for this entry.  */
240
0
    if (use_plt_got)
241
0
      got_s->size += htab->non_lazy_plt->plt_entry_size;
242
0
    else
243
0
      {
244
0
        s->size += plt_entry_size;
245
0
        if (second_s)
246
0
    second_s->size += htab->non_lazy_plt->plt_entry_size;
247
248
        /* We also need to make an entry in the .got.plt section,
249
     which will be placed in the .got section by the linker
250
     script.  */
251
0
        htab->elf.sgotplt->size += htab->got_entry_size;
252
253
        /* There should be no PLT relocation against resolved
254
     undefined weak symbol in executable.  */
255
0
        if (!resolved_to_zero)
256
0
    {
257
      /* We also need to make an entry in the .rel.plt
258
         section.  */
259
0
      htab->elf.srelplt->size += htab->sizeof_reloc;
260
0
      htab->elf.srelplt->reloc_count++;
261
0
    }
262
0
      }
263
264
0
    if (htab->elf.target_os == is_vxworks && !bfd_link_pic (info))
265
0
      {
266
        /* VxWorks has a second set of relocations for each PLT entry
267
     in executables.  They go in a separate relocation section,
268
     which is processed by the kernel loader.  */
269
270
        /* There are two relocations for the initial PLT entry: an
271
     R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
272
     R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8.  */
273
274
0
        asection *srelplt2 = htab->srelplt2;
275
0
        if (h->plt.offset == plt_entry_size)
276
0
    srelplt2->size += (htab->sizeof_reloc * 2);
277
278
        /* There are two extra relocations for each subsequent PLT entry:
279
     an R_386_32 relocation for the GOT entry, and an R_386_32
280
     relocation for the PLT entry.  */
281
282
0
        srelplt2->size += (htab->sizeof_reloc * 2);
283
0
      }
284
0
  }
285
0
      else
286
0
  {
287
0
    eh->plt_got.offset = (bfd_vma) -1;
288
0
    h->plt.offset = (bfd_vma) -1;
289
0
    h->needs_plt = 0;
290
0
  }
291
0
    }
292
0
  else
293
0
    {
294
0
      eh->plt_got.offset = (bfd_vma) -1;
295
0
      h->plt.offset = (bfd_vma) -1;
296
0
      h->needs_plt = 0;
297
0
    }
298
299
0
  eh->tlsdesc_got = (bfd_vma) -1;
300
301
  /* For i386, if R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the
302
     binary, make it a R_386_TLS_LE_32 requiring no TLS entry.  For
303
     x86-64, if R_X86_64_GOTTPOFF symbol is now local to the binary,
304
     make it a R_X86_64_TPOFF32 requiring no GOT entry.  */
305
0
  if (h->got.refcount > 0
306
0
      && bfd_link_executable (info)
307
0
      && h->dynindx == -1
308
0
      && (elf_x86_hash_entry (h)->tls_type & GOT_TLS_IE))
309
0
    h->got.offset = (bfd_vma) -1;
310
0
  else if (h->got.refcount > 0)
311
0
    {
312
0
      asection *s;
313
0
      bool dyn;
314
0
      int tls_type = elf_x86_hash_entry (h)->tls_type;
315
316
      /* Make sure this symbol is output as a dynamic symbol.
317
   Undefined weak syms won't yet be marked as dynamic.  */
318
0
      if (h->dynindx == -1
319
0
    && !h->forced_local
320
0
    && !resolved_to_zero
321
0
    && h->root.type == bfd_link_hash_undefweak)
322
0
  {
323
0
    if (! bfd_elf_link_record_dynamic_symbol (info, h))
324
0
      return false;
325
0
  }
326
327
0
      s = htab->elf.sgot;
328
0
      if (GOT_TLS_GDESC_P (tls_type))
329
0
  {
330
0
    eh->tlsdesc_got = htab->elf.sgotplt->size
331
0
      - elf_x86_compute_jump_table_size (htab);
332
0
    htab->elf.sgotplt->size += 2 * htab->got_entry_size;
333
0
    h->got.offset = (bfd_vma) -2;
334
0
  }
335
0
      if (! GOT_TLS_GDESC_P (tls_type)
336
0
    || GOT_TLS_GD_P (tls_type))
337
0
  {
338
0
    h->got.offset = s->size;
339
0
    s->size += htab->got_entry_size;
340
    /* R_386_TLS_GD and R_X86_64_TLSGD need 2 consecutive GOT
341
       slots.  */
342
0
    if (GOT_TLS_GD_P (tls_type) || tls_type == GOT_TLS_IE_BOTH)
343
0
      s->size += htab->got_entry_size;
344
0
  }
345
0
      dyn = htab->elf.dynamic_sections_created;
346
      /* R_386_TLS_IE_32 needs one dynamic relocation,
347
   R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
348
   (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
349
   need two), R_386_TLS_GD and R_X86_64_TLSGD need one if local
350
   symbol and two if global.  No dynamic relocation against
351
   resolved undefined weak symbol in executable.  No dynamic
352
   relocation against non-preemptible absolute symbol.  */
353
0
      if (tls_type == GOT_TLS_IE_BOTH)
354
0
  htab->elf.srelgot->size += 2 * htab->sizeof_reloc;
355
0
      else if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
356
0
         || (tls_type & GOT_TLS_IE))
357
0
  htab->elf.srelgot->size += htab->sizeof_reloc;
358
0
      else if (GOT_TLS_GD_P (tls_type))
359
0
  htab->elf.srelgot->size += 2 * htab->sizeof_reloc;
360
0
      else if (! GOT_TLS_GDESC_P (tls_type)
361
0
         && ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
362
0
        && !resolved_to_zero)
363
0
       || h->root.type != bfd_link_hash_undefweak)
364
0
         && ((bfd_link_pic (info)
365
0
        && !(h->dynindx == -1
366
0
       && ABS_SYMBOL_P (h)))
367
0
       || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
368
0
  htab->elf.srelgot->size += htab->sizeof_reloc;
369
0
      if (GOT_TLS_GDESC_P (tls_type))
370
0
  {
371
0
    htab->elf.srelplt->size += htab->sizeof_reloc;
372
0
    if (bed->target_id == X86_64_ELF_DATA)
373
0
      htab->elf.tlsdesc_plt = (bfd_vma) -1;
374
0
  }
375
0
    }
376
0
  else
377
0
    h->got.offset = (bfd_vma) -1;
378
379
0
  if (h->dyn_relocs == NULL)
380
0
    return true;
381
382
  /* In the shared -Bsymbolic case, discard space allocated for
383
     dynamic pc-relative relocs against symbols which turn out to be
384
     defined in regular objects.  For the normal shared case, discard
385
     space for pc-relative relocs that have become local due to symbol
386
     visibility changes.  */
387
388
0
  if (bfd_link_pic (info))
389
0
    {
390
      /* Relocs that use pc_count are those that appear on a call
391
   insn, or certain REL relocs that can generated via assembly.
392
   We want calls to protected symbols to resolve directly to the
393
   function rather than going via the plt.  If people want
394
   function pointer comparisons to work as expected then they
395
   should avoid writing weird assembly.  */
396
0
      if (SYMBOL_CALLS_LOCAL (info, h))
397
0
  {
398
0
    struct elf_dyn_relocs **pp;
399
400
0
    for (pp = &h->dyn_relocs; (p = *pp) != NULL; )
401
0
      {
402
0
        p->count -= p->pc_count;
403
0
        p->pc_count = 0;
404
0
        if (p->count == 0)
405
0
    *pp = p->next;
406
0
        else
407
0
    pp = &p->next;
408
0
      }
409
0
  }
410
411
0
      if (htab->elf.target_os == is_vxworks)
412
0
  {
413
0
    struct elf_dyn_relocs **pp;
414
0
    for (pp = &h->dyn_relocs; (p = *pp) != NULL; )
415
0
      {
416
0
        if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
417
0
    *pp = p->next;
418
0
        else
419
0
    pp = &p->next;
420
0
      }
421
0
  }
422
423
      /* Also discard relocs on undefined weak syms with non-default
424
   visibility or in PIE.  */
425
0
      if (h->dyn_relocs != NULL)
426
0
  {
427
0
    if (h->root.type == bfd_link_hash_undefweak)
428
0
      {
429
        /* Undefined weak symbol is never bound locally in shared
430
     library.  */
431
0
        if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
432
0
      || resolved_to_zero)
433
0
    {
434
0
      if (bed->target_id == I386_ELF_DATA
435
0
          && h->non_got_ref)
436
0
        {
437
          /* Keep dynamic non-GOT/non-PLT relocation so
438
       that we can branch to 0 without PLT.  */
439
0
          struct elf_dyn_relocs **pp;
440
441
0
          for (pp = &h->dyn_relocs; (p = *pp) != NULL; )
442
0
      if (p->pc_count == 0)
443
0
        *pp = p->next;
444
0
      else
445
0
        {
446
          /* Remove non-R_386_PC32 relocation.  */
447
0
          p->count = p->pc_count;
448
0
          pp = &p->next;
449
0
        }
450
451
          /* Make sure undefined weak symbols are output
452
       as dynamic symbols in PIEs for dynamic non-GOT
453
       non-PLT reloations.  */
454
0
          if (h->dyn_relocs != NULL
455
0
        && !bfd_elf_link_record_dynamic_symbol (info, h))
456
0
      return false;
457
0
        }
458
0
      else
459
0
        h->dyn_relocs = NULL;
460
0
    }
461
0
        else if (h->dynindx == -1
462
0
           && !h->forced_local
463
0
           && !bfd_elf_link_record_dynamic_symbol (info, h))
464
0
    return false;
465
0
      }
466
0
    else if (bfd_link_executable (info)
467
0
       && (h->needs_copy || eh->needs_copy)
468
0
       && h->def_dynamic
469
0
       && !h->def_regular)
470
0
      {
471
        /* NB: needs_copy is set only for x86-64.  For PIE,
472
     discard space for pc-relative relocs against symbols
473
     which turn out to need copy relocs.  */
474
0
        struct elf_dyn_relocs **pp;
475
476
0
        for (pp = &h->dyn_relocs; (p = *pp) != NULL; )
477
0
    {
478
0
      if (p->pc_count != 0)
479
0
        *pp = p->next;
480
0
      else
481
0
        pp = &p->next;
482
0
    }
483
0
      }
484
0
  }
485
0
    }
486
0
  else if (ELIMINATE_COPY_RELOCS)
487
0
    {
488
      /* For the non-shared case, discard space for relocs against
489
   symbols which turn out to need copy relocs or are not
490
   dynamic.  Keep dynamic relocations for run-time function
491
   pointer initialization.  */
492
493
0
      if ((!h->non_got_ref
494
0
     || (h->root.type == bfd_link_hash_undefweak
495
0
         && !resolved_to_zero))
496
0
    && ((h->def_dynamic
497
0
         && !h->def_regular)
498
0
        || (htab->elf.dynamic_sections_created
499
0
      && (h->root.type == bfd_link_hash_undefweak
500
0
          || h->root.type == bfd_link_hash_undefined))))
501
0
  {
502
    /* Make sure this symbol is output as a dynamic symbol.
503
       Undefined weak syms won't yet be marked as dynamic.  */
504
0
    if (h->dynindx == -1
505
0
        && !h->forced_local
506
0
        && !resolved_to_zero
507
0
        && h->root.type == bfd_link_hash_undefweak
508
0
        && ! bfd_elf_link_record_dynamic_symbol (info, h))
509
0
      return false;
510
511
    /* If that succeeded, we know we'll be keeping all the
512
       relocs.  */
513
0
    if (h->dynindx != -1)
514
0
      goto keep;
515
0
  }
516
517
0
      h->dyn_relocs = NULL;
518
519
0
    keep: ;
520
0
    }
521
522
  /* Finally, allocate space.  */
523
0
  for (p = h->dyn_relocs; p != NULL; p = p->next)
524
0
    {
525
0
      asection *sreloc;
526
527
0
      if (eh->def_protected && bfd_link_executable (info))
528
0
  {
529
    /* Disallow copy relocation against non-copyable protected
530
       symbol.  */
531
0
    asection *s = p->sec->output_section;
532
0
    if (s != NULL && (s->flags & SEC_READONLY) != 0)
533
0
      {
534
0
        info->callbacks->einfo
535
    /* xgettext:c-format */
536
0
    (_("%F%P: %pB: copy relocation against non-copyable "
537
0
       "protected symbol `%s' in %pB\n"),
538
0
     p->sec->owner, h->root.root.string,
539
0
     h->root.u.def.section->owner);
540
0
        return false;
541
0
      }
542
0
  }
543
544
0
      sreloc = elf_section_data (p->sec)->sreloc;
545
546
0
      BFD_ASSERT (sreloc != NULL);
547
0
      sreloc->size += p->count * htab->sizeof_reloc;
548
0
    }
549
550
0
  return true;
551
0
}
552
553
/* Allocate space in .plt, .got and associated reloc sections for
554
   local dynamic relocs.  */
555
556
static int
557
elf_x86_allocate_local_dynreloc (void **slot, void *inf)
558
0
{
559
0
  struct elf_link_hash_entry *h
560
0
    = (struct elf_link_hash_entry *) *slot;
561
562
0
  if (h->type != STT_GNU_IFUNC
563
0
      || !h->def_regular
564
0
      || !h->ref_regular
565
0
      || !h->forced_local
566
0
      || h->root.type != bfd_link_hash_defined)
567
0
    abort ();
568
569
0
  return elf_x86_allocate_dynrelocs (h, inf);
570
0
}
571
572
/* Find and/or create a hash entry for local symbol.  */
573
574
struct elf_link_hash_entry *
575
_bfd_elf_x86_get_local_sym_hash (struct elf_x86_link_hash_table *htab,
576
         bfd *abfd, const Elf_Internal_Rela *rel,
577
         bool create)
578
0
{
579
0
  struct elf_x86_link_hash_entry e, *ret;
580
0
  asection *sec = abfd->sections;
581
0
  hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id,
582
0
               htab->r_sym (rel->r_info));
583
0
  void **slot;
584
585
0
  e.elf.indx = sec->id;
586
0
  e.elf.dynstr_index = htab->r_sym (rel->r_info);
587
0
  slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,
588
0
           create ? INSERT : NO_INSERT);
589
590
0
  if (!slot)
591
0
    return NULL;
592
593
0
  if (*slot)
594
0
    {
595
0
      ret = (struct elf_x86_link_hash_entry *) *slot;
596
0
      return &ret->elf;
597
0
    }
598
599
0
  ret = (struct elf_x86_link_hash_entry *)
600
0
  objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,
601
0
      sizeof (struct elf_x86_link_hash_entry));
602
0
  if (ret)
603
0
    {
604
0
      memset (ret, 0, sizeof (*ret));
605
0
      ret->elf.indx = sec->id;
606
0
      ret->elf.dynstr_index = htab->r_sym (rel->r_info);
607
0
      ret->elf.dynindx = -1;
608
0
      ret->plt_got.offset = (bfd_vma) -1;
609
0
      *slot = ret;
610
0
    }
611
0
  return &ret->elf;
612
0
}
613
614
/* Create an entry in a x86 ELF linker hash table.  NB: THIS MUST BE IN
615
   SYNC WITH _bfd_elf_link_hash_newfunc.  */
616
617
struct bfd_hash_entry *
618
_bfd_x86_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
619
        struct bfd_hash_table *table,
620
        const char *string)
621
0
{
622
  /* Allocate the structure if it has not already been allocated by a
623
     subclass.  */
624
0
  if (entry == NULL)
625
0
    {
626
0
      entry = (struct bfd_hash_entry *)
627
0
  bfd_hash_allocate (table,
628
0
         sizeof (struct elf_x86_link_hash_entry));
629
0
      if (entry == NULL)
630
0
  return entry;
631
0
    }
632
633
  /* Call the allocation method of the superclass.  */
634
0
  entry = _bfd_link_hash_newfunc (entry, table, string);
635
0
  if (entry != NULL)
636
0
    {
637
0
      struct elf_x86_link_hash_entry *eh
638
0
       = (struct elf_x86_link_hash_entry *) entry;
639
0
      struct elf_link_hash_table *htab
640
0
  = (struct elf_link_hash_table *) table;
641
642
0
      memset (&eh->elf.size, 0,
643
0
        (sizeof (struct elf_x86_link_hash_entry)
644
0
         - offsetof (struct elf_link_hash_entry, size)));
645
      /* Set local fields.  */
646
0
      eh->elf.indx = -1;
647
0
      eh->elf.dynindx = -1;
648
0
      eh->elf.got = htab->init_got_refcount;
649
0
      eh->elf.plt = htab->init_plt_refcount;
650
      /* Assume that we have been called by a non-ELF symbol reader.
651
   This flag is then reset by the code which reads an ELF input
652
   file.  This ensures that a symbol created by a non-ELF symbol
653
   reader will have the flag set correctly.  */
654
0
      eh->elf.non_elf = 1;
655
0
      eh->plt_second.offset = (bfd_vma) -1;
656
0
      eh->plt_got.offset = (bfd_vma) -1;
657
0
      eh->tlsdesc_got = (bfd_vma) -1;
658
0
      eh->zero_undefweak = 1;
659
0
    }
660
661
0
  return entry;
662
0
}
663
664
/* Compute a hash of a local hash entry.  We use elf_link_hash_entry
665
  for local symbol so that we can handle local STT_GNU_IFUNC symbols
666
  as global symbol.  We reuse indx and dynstr_index for local symbol
667
  hash since they aren't used by global symbols in this backend.  */
668
669
hashval_t
670
_bfd_x86_elf_local_htab_hash (const void *ptr)
671
0
{
672
0
  struct elf_link_hash_entry *h
673
0
    = (struct elf_link_hash_entry *) ptr;
674
0
  return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);
675
0
}
676
677
/* Compare local hash entries.  */
678
679
int
680
_bfd_x86_elf_local_htab_eq (const void *ptr1, const void *ptr2)
681
0
{
682
0
  struct elf_link_hash_entry *h1
683
0
     = (struct elf_link_hash_entry *) ptr1;
684
0
  struct elf_link_hash_entry *h2
685
0
    = (struct elf_link_hash_entry *) ptr2;
686
687
0
  return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
688
0
}
689
690
/* Destroy an x86 ELF linker hash table.  */
691
692
static void
693
elf_x86_link_hash_table_free (bfd *obfd)
694
0
{
695
0
  struct elf_x86_link_hash_table *htab
696
0
    = (struct elf_x86_link_hash_table *) obfd->link.hash;
697
698
0
  if (htab->loc_hash_table)
699
0
    htab_delete (htab->loc_hash_table);
700
0
  if (htab->loc_hash_memory)
701
0
    objalloc_free ((struct objalloc *) htab->loc_hash_memory);
702
0
  _bfd_elf_link_hash_table_free (obfd);
703
0
}
704
705
static bool
706
elf_i386_is_reloc_section (const char *secname)
707
0
{
708
0
  return startswith (secname, ".rel");
709
0
}
710
711
static bool
712
elf_x86_64_is_reloc_section (const char *secname)
713
0
{
714
0
  return startswith (secname, ".rela");
715
0
}
716
717
/* Create an x86 ELF linker hash table.  */
718
719
struct bfd_link_hash_table *
720
_bfd_x86_elf_link_hash_table_create (bfd *abfd)
721
0
{
722
0
  struct elf_x86_link_hash_table *ret;
723
0
  const struct elf_backend_data *bed;
724
0
  size_t amt = sizeof (struct elf_x86_link_hash_table);
725
726
0
  ret = (struct elf_x86_link_hash_table *) bfd_zmalloc (amt);
727
0
  if (ret == NULL)
728
0
    return NULL;
729
730
0
  bed = get_elf_backend_data (abfd);
731
0
  if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
732
0
              _bfd_x86_elf_link_hash_newfunc,
733
0
              sizeof (struct elf_x86_link_hash_entry),
734
0
              bed->target_id))
735
0
    {
736
0
      free (ret);
737
0
      return NULL;
738
0
    }
739
740
0
  if (bed->target_id == X86_64_ELF_DATA)
741
0
    {
742
0
      ret->is_reloc_section = elf_x86_64_is_reloc_section;
743
0
      ret->got_entry_size = 8;
744
0
      ret->pcrel_plt = true;
745
0
      ret->tls_get_addr = "__tls_get_addr";
746
0
      ret->relative_r_type = R_X86_64_RELATIVE;
747
0
      ret->relative_r_name = "R_X86_64_RELATIVE";
748
0
      ret->elf_append_reloc = elf_append_rela;
749
0
      ret->elf_write_addend_in_got = _bfd_elf64_write_addend;
750
0
    }
751
0
  if (ABI_64_P (abfd))
752
0
    {
753
0
      ret->sizeof_reloc = sizeof (Elf64_External_Rela);
754
0
      ret->pointer_r_type = R_X86_64_64;
755
0
      ret->dynamic_interpreter = ELF64_DYNAMIC_INTERPRETER;
756
0
      ret->dynamic_interpreter_size = sizeof ELF64_DYNAMIC_INTERPRETER;
757
0
      ret->elf_write_addend = _bfd_elf64_write_addend;
758
0
    }
759
0
  else
760
0
    {
761
0
      if (bed->target_id == X86_64_ELF_DATA)
762
0
  {
763
0
    ret->sizeof_reloc = sizeof (Elf32_External_Rela);
764
0
    ret->pointer_r_type = R_X86_64_32;
765
0
    ret->dynamic_interpreter = ELFX32_DYNAMIC_INTERPRETER;
766
0
    ret->dynamic_interpreter_size
767
0
      = sizeof ELFX32_DYNAMIC_INTERPRETER;
768
0
    ret->elf_write_addend = _bfd_elf32_write_addend;
769
0
  }
770
0
      else
771
0
  {
772
0
    ret->is_reloc_section = elf_i386_is_reloc_section;
773
0
    ret->sizeof_reloc = sizeof (Elf32_External_Rel);
774
0
    ret->got_entry_size = 4;
775
0
    ret->pcrel_plt = false;
776
0
    ret->pointer_r_type = R_386_32;
777
0
    ret->relative_r_type = R_386_RELATIVE;
778
0
    ret->relative_r_name = "R_386_RELATIVE";
779
0
    ret->elf_append_reloc = elf_append_rel;
780
0
    ret->elf_write_addend = _bfd_elf32_write_addend;
781
0
    ret->elf_write_addend_in_got = _bfd_elf32_write_addend;
782
0
    ret->dynamic_interpreter = ELF32_DYNAMIC_INTERPRETER;
783
0
    ret->dynamic_interpreter_size
784
0
      = sizeof ELF32_DYNAMIC_INTERPRETER;
785
0
    ret->tls_get_addr = "___tls_get_addr";
786
0
  }
787
0
    }
788
789
0
  ret->loc_hash_table = htab_try_create (1024,
790
0
           _bfd_x86_elf_local_htab_hash,
791
0
           _bfd_x86_elf_local_htab_eq,
792
0
           NULL);
793
0
  ret->loc_hash_memory = objalloc_create ();
794
0
  if (!ret->loc_hash_table || !ret->loc_hash_memory)
795
0
    {
796
0
      elf_x86_link_hash_table_free (abfd);
797
0
      return NULL;
798
0
    }
799
0
  ret->elf.root.hash_table_free = elf_x86_link_hash_table_free;
800
801
0
  return &ret->elf.root;
802
0
}
803
804
/* Sort relocs into address order.  */
805
806
int
807
_bfd_x86_elf_compare_relocs (const void *ap, const void *bp)
808
134k
{
809
134k
  const arelent *a = * (const arelent **) ap;
810
134k
  const arelent *b = * (const arelent **) bp;
811
812
134k
  if (a->address > b->address)
813
47.1k
    return 1;
814
87.7k
  else if (a->address < b->address)
815
87.7k
    return -1;
816
0
  else
817
0
    return 0;
818
134k
}
819
820
/* Mark symbol, NAME, as locally defined by linker if it is referenced
821
   and not defined in a relocatable object file.  */
822
823
static void
824
elf_x86_linker_defined (struct bfd_link_info *info, const char *name)
825
0
{
826
0
  struct elf_link_hash_entry *h;
827
828
0
  h = elf_link_hash_lookup (elf_hash_table (info), name,
829
0
          false, false, false);
830
0
  if (h == NULL)
831
0
    return;
832
833
0
  while (h->root.type == bfd_link_hash_indirect)
834
0
    h = (struct elf_link_hash_entry *) h->root.u.i.link;
835
836
0
  if (h->root.type == bfd_link_hash_new
837
0
      || h->root.type == bfd_link_hash_undefined
838
0
      || h->root.type == bfd_link_hash_undefweak
839
0
      || h->root.type == bfd_link_hash_common
840
0
      || (!h->def_regular && h->def_dynamic))
841
0
    {
842
0
      elf_x86_hash_entry (h)->local_ref = 2;
843
0
      elf_x86_hash_entry (h)->linker_def = 1;
844
0
    }
845
0
}
846
847
/* Hide a linker-defined symbol, NAME, with hidden visibility.  */
848
849
static void
850
elf_x86_hide_linker_defined (struct bfd_link_info *info,
851
           const char *name)
852
0
{
853
0
  struct elf_link_hash_entry *h;
854
855
0
  h = elf_link_hash_lookup (elf_hash_table (info), name,
856
0
          false, false, false);
857
0
  if (h == NULL)
858
0
    return;
859
860
0
  while (h->root.type == bfd_link_hash_indirect)
861
0
    h = (struct elf_link_hash_entry *) h->root.u.i.link;
862
863
0
  if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
864
0
      || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
865
0
    _bfd_elf_link_hash_hide_symbol (info, h, true);
866
0
}
867
868
bool
869
_bfd_x86_elf_link_check_relocs (bfd *abfd, struct bfd_link_info *info)
870
0
{
871
0
  if (!bfd_link_relocatable (info))
872
0
    {
873
      /* Check for __tls_get_addr reference.  */
874
0
      struct elf_x86_link_hash_table *htab;
875
0
      const struct elf_backend_data *bed = get_elf_backend_data (abfd);
876
0
      htab = elf_x86_hash_table (info, bed->target_id);
877
0
      if (htab)
878
0
  {
879
0
    struct elf_link_hash_entry *h;
880
881
0
    h = elf_link_hash_lookup (elf_hash_table (info),
882
0
            htab->tls_get_addr,
883
0
            false, false, false);
884
0
    if (h != NULL)
885
0
      {
886
0
        elf_x86_hash_entry (h)->tls_get_addr = 1;
887
888
        /* Check the versioned __tls_get_addr symbol.  */
889
0
        while (h->root.type == bfd_link_hash_indirect)
890
0
    {
891
0
      h = (struct elf_link_hash_entry *) h->root.u.i.link;
892
0
      elf_x86_hash_entry (h)->tls_get_addr = 1;
893
0
    }
894
0
      }
895
896
    /* "__ehdr_start" will be defined by linker as a hidden symbol
897
       later if it is referenced and not defined.  */
898
0
    elf_x86_linker_defined (info, "__ehdr_start");
899
900
0
    if (bfd_link_executable (info))
901
0
      {
902
        /* References to __bss_start, _end and _edata should be
903
     locally resolved within executables.  */
904
0
        elf_x86_linker_defined (info, "__bss_start");
905
0
        elf_x86_linker_defined (info, "_end");
906
0
        elf_x86_linker_defined (info, "_edata");
907
0
      }
908
0
    else
909
0
      {
910
        /* Hide hidden __bss_start, _end and _edata in shared
911
     libraries.  */
912
0
        elf_x86_hide_linker_defined (info, "__bss_start");
913
0
        elf_x86_hide_linker_defined (info, "_end");
914
0
        elf_x86_hide_linker_defined (info, "_edata");
915
0
      }
916
0
  }
917
0
    }
918
919
  /* Invoke the regular ELF backend linker to do all the work.  */
920
0
  return _bfd_elf_link_check_relocs (abfd, info);
921
0
}
922
923
/* Look through the relocs for a section before allocation to make the
924
   dynamic reloc section.  */
925
926
bool
927
_bfd_x86_elf_check_relocs (bfd *abfd,
928
         struct bfd_link_info *info,
929
         asection *sec,
930
         const Elf_Internal_Rela *relocs)
931
0
{
932
0
  struct elf_x86_link_hash_table *htab;
933
0
  Elf_Internal_Shdr *symtab_hdr;
934
0
  struct elf_link_hash_entry **sym_hashes;
935
0
  const Elf_Internal_Rela *rel;
936
0
  const Elf_Internal_Rela *rel_end;
937
0
  asection *sreloc;
938
0
  const struct elf_backend_data *bed;
939
0
  bool is_x86_64;
940
941
0
  if (bfd_link_relocatable (info))
942
0
    return true;
943
944
0
  bed = get_elf_backend_data (abfd);
945
0
  htab = elf_x86_hash_table (info, bed->target_id);
946
0
  if (htab == NULL)
947
0
    {
948
0
      sec->check_relocs_failed = 1;
949
0
      return false;
950
0
    }
951
952
0
  is_x86_64 = bed->target_id == X86_64_ELF_DATA;
953
954
0
  symtab_hdr = &elf_symtab_hdr (abfd);
955
0
  sym_hashes = elf_sym_hashes (abfd);
956
957
0
  rel_end = relocs + sec->reloc_count;
958
0
  for (rel = relocs; rel < rel_end; rel++)
959
0
    {
960
0
      unsigned int r_type;
961
0
      unsigned int r_symndx;
962
0
      struct elf_link_hash_entry *h;
963
964
0
      r_symndx = htab->r_sym (rel->r_info);
965
0
      r_type = ELF32_R_TYPE (rel->r_info);
966
967
0
      if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
968
0
  {
969
    /* xgettext:c-format */
970
0
    _bfd_error_handler (_("%pB: bad symbol index: %d"),
971
0
            abfd, r_symndx);
972
0
    goto error_return;
973
0
  }
974
975
0
      if (r_symndx < symtab_hdr->sh_info)
976
0
  h = NULL;
977
0
      else
978
0
  {
979
0
    h = sym_hashes[r_symndx - symtab_hdr->sh_info];
980
0
    while (h->root.type == bfd_link_hash_indirect
981
0
     || h->root.type == bfd_link_hash_warning)
982
0
      h = (struct elf_link_hash_entry *) h->root.u.i.link;
983
0
  }
984
985
0
      if (X86_NEED_DYNAMIC_RELOC_TYPE_P (is_x86_64, r_type)
986
0
    && NEED_DYNAMIC_RELOCATION_P (is_x86_64, info, true, h, sec,
987
0
          r_type, htab->pointer_r_type))
988
0
  {
989
    /* We may copy these reloc types into the output file.
990
       Create a reloc section in dynobj and make room for
991
       this reloc.  */
992
0
    sreloc = _bfd_elf_make_dynamic_reloc_section
993
0
      (sec, htab->elf.dynobj, ABI_64_P (abfd) ? 3 : 2,
994
0
       abfd, sec->use_rela_p);
995
996
0
    if (sreloc != NULL)
997
0
      return true;
998
999
0
  error_return:
1000
0
    sec->check_relocs_failed = 1;
1001
0
    return false;
1002
0
  }
1003
0
    }
1004
1005
0
  return true;
1006
0
}
1007
1008
/* Add an entry to the relative reloc record.  */
1009
1010
static bool
1011
elf_x86_relative_reloc_record_add
1012
  (struct bfd_link_info *info,
1013
   struct elf_x86_relative_reloc_data *relative_reloc,
1014
   Elf_Internal_Rela *rel, asection *sec,
1015
   asection *sym_sec, struct elf_link_hash_entry *h,
1016
   Elf_Internal_Sym *sym, bfd_vma offset, bool *keep_symbuf_p)
1017
0
{
1018
0
  bfd_size_type newidx;
1019
1020
0
  if (relative_reloc->data == NULL)
1021
0
    {
1022
0
      relative_reloc->data = bfd_malloc
1023
0
  (sizeof (struct elf_x86_relative_reloc_record));
1024
0
      relative_reloc->count = 0;
1025
0
      relative_reloc->size = 1;
1026
0
    }
1027
1028
0
  newidx = relative_reloc->count++;
1029
1030
0
  if (relative_reloc->count > relative_reloc->size)
1031
0
    {
1032
0
      relative_reloc->size <<= 1;
1033
0
      relative_reloc->data = bfd_realloc
1034
0
  (relative_reloc->data,
1035
0
   (relative_reloc->size
1036
0
    * sizeof (struct elf_x86_relative_reloc_record)));
1037
0
    }
1038
1039
0
  if (relative_reloc->data == NULL)
1040
0
    {
1041
0
      info->callbacks->einfo
1042
  /* xgettext:c-format */
1043
0
  (_("%F%P: %pB: failed to allocate relative reloc record\n"),
1044
0
   info->output_bfd);
1045
0
      return false;
1046
0
    }
1047
1048
0
  relative_reloc->data[newidx].rel = *rel;
1049
0
  relative_reloc->data[newidx].sec = sec;
1050
0
  if (h != NULL)
1051
0
    {
1052
      /* Set SYM to NULL to indicate a global symbol.  */
1053
0
      relative_reloc->data[newidx].sym = NULL;
1054
0
      relative_reloc->data[newidx].u.h = h;
1055
0
    }
1056
0
  else
1057
0
    {
1058
0
      relative_reloc->data[newidx].sym = sym;
1059
0
      relative_reloc->data[newidx].u.sym_sec = sym_sec;
1060
      /* We must keep the symbol buffer since SYM will be used later.  */
1061
0
      *keep_symbuf_p = true;
1062
0
    }
1063
0
  relative_reloc->data[newidx].offset = offset;
1064
0
  relative_reloc->data[newidx].address = 0;
1065
0
  return true;
1066
0
}
1067
1068
/* After input sections have been mapped to output sections and
1069
   addresses of output sections are set initiallly, scan input
1070
   relocations with the same logic in relocate_section to determine
1071
   if a relative relocation should be generated.  Save the relative
1072
   relocation candidate information for sizing the DT_RELR section
1073
   later after all symbols addresses can be determined.  */
1074
1075
bool
1076
_bfd_x86_elf_link_relax_section (bfd *abfd ATTRIBUTE_UNUSED,
1077
         asection *input_section,
1078
         struct bfd_link_info *info,
1079
         bool *again)
1080
0
{
1081
0
  Elf_Internal_Shdr *symtab_hdr;
1082
0
  Elf_Internal_Rela *internal_relocs;
1083
0
  Elf_Internal_Rela *irel, *irelend;
1084
0
  Elf_Internal_Sym *isymbuf = NULL;
1085
0
  struct elf_link_hash_entry **sym_hashes;
1086
0
  const struct elf_backend_data *bed;
1087
0
  struct elf_x86_link_hash_table *htab;
1088
0
  bfd_vma *local_got_offsets;
1089
0
  bool is_x86_64;
1090
0
  bool unaligned_section;
1091
0
  bool return_status = false;
1092
0
  bool keep_symbuf = false;
1093
1094
0
  if (bfd_link_relocatable (info))
1095
0
    return true;
1096
1097
  /* Assume we're not going to change any sizes, and we'll only need
1098
     one pass.  */
1099
0
  *again = false;
1100
1101
0
  bed = get_elf_backend_data (abfd);
1102
0
  htab = elf_x86_hash_table (info, bed->target_id);
1103
0
  if (htab == NULL)
1104
0
    return true;
1105
1106
  /* Nothing to do if there are no relocations or relative relocations
1107
     have been packed.  */
1108
0
  if (input_section == htab->elf.srelrdyn
1109
0
      || input_section->relative_reloc_packed
1110
0
      || ((input_section->flags & (SEC_RELOC | SEC_ALLOC))
1111
0
    != (SEC_RELOC | SEC_ALLOC))
1112
0
      || (input_section->flags & SEC_DEBUGGING) != 0
1113
0
      || input_section->reloc_count == 0)
1114
0
    return true;
1115
1116
  /* Skip if the section isn't aligned.  */
1117
0
  unaligned_section = input_section->alignment_power == 0;
1118
1119
0
  is_x86_64 = bed->target_id == X86_64_ELF_DATA;
1120
1121
0
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1122
0
  sym_hashes = elf_sym_hashes (abfd);
1123
0
  local_got_offsets = elf_local_got_offsets (abfd);
1124
1125
  /* Load the relocations for this section.  */
1126
0
  internal_relocs =
1127
0
    _bfd_elf_link_info_read_relocs (abfd, info, input_section, NULL,
1128
0
            (Elf_Internal_Rela *) NULL,
1129
0
            info->keep_memory);
1130
0
  if (internal_relocs == NULL)
1131
0
    return false;
1132
1133
0
  irelend = internal_relocs + input_section->reloc_count;
1134
0
  for (irel = internal_relocs; irel < irelend; irel++)
1135
0
    {
1136
0
      unsigned int r_type;
1137
0
      unsigned int r_symndx;
1138
0
      Elf_Internal_Sym *isym;
1139
0
      struct elf_link_hash_entry *h;
1140
0
      struct elf_x86_link_hash_entry *eh;
1141
0
      bfd_vma offset;
1142
0
      bool resolved_to_zero;
1143
0
      bool need_copy_reloc_in_pie;
1144
0
      bool pc32_reloc;
1145
0
      asection *sec;
1146
      /* Offset must be a multiple of 2.  */
1147
0
      bool unaligned_offset = (irel->r_offset & 1) != 0;
1148
      /* True if there is a relative relocation against a dynamic
1149
   symbol.  */
1150
0
      bool dynamic_relative_reloc_p;
1151
1152
      /* Get the value of the symbol referred to by the reloc.  */
1153
0
      r_symndx = htab->r_sym (irel->r_info);
1154
1155
0
      r_type = ELF32_R_TYPE (irel->r_info);
1156
      /* Clear the R_X86_64_converted_reloc_bit bit.  */
1157
0
      r_type &= ~R_X86_64_converted_reloc_bit;
1158
1159
0
      sec = NULL;
1160
0
      h = NULL;
1161
0
      dynamic_relative_reloc_p = false;
1162
1163
0
      if (r_symndx < symtab_hdr->sh_info)
1164
0
  {
1165
    /* Read this BFD's local symbols.  */
1166
0
    if (isymbuf == NULL)
1167
0
      {
1168
0
        isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1169
0
        if (isymbuf == NULL)
1170
0
    {
1171
0
      isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1172
0
              symtab_hdr->sh_info,
1173
0
              0, NULL, NULL, NULL);
1174
0
      if (isymbuf == NULL)
1175
0
        goto error_return;
1176
0
    }
1177
0
      }
1178
1179
0
    isym = isymbuf + r_symndx;
1180
0
    switch (isym->st_shndx)
1181
0
      {
1182
0
      case SHN_ABS:
1183
0
        sec = bfd_abs_section_ptr;
1184
0
        break;
1185
0
      case SHN_COMMON:
1186
0
        sec = bfd_com_section_ptr;
1187
0
        break;
1188
0
      case SHN_X86_64_LCOMMON:
1189
0
        if (!is_x86_64)
1190
0
    abort ();
1191
0
        sec = &_bfd_elf_large_com_section;
1192
0
        break;
1193
0
      default:
1194
0
        sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1195
0
        break;
1196
0
      }
1197
1198
    /* Skip relocation against local STT_GNU_IFUNC symbol.  */
1199
0
    if (ELF32_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1200
0
      continue;
1201
1202
0
    eh = (struct elf_x86_link_hash_entry *) h;
1203
0
    resolved_to_zero = false;
1204
0
  }
1205
0
      else
1206
0
  {
1207
    /* Get H and SEC for GENERATE_DYNAMIC_RELOCATION_P below.  */
1208
0
    h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1209
0
    while (h->root.type == bfd_link_hash_indirect
1210
0
     || h->root.type == bfd_link_hash_warning)
1211
0
      h = (struct elf_link_hash_entry *) h->root.u.i.link;
1212
1213
0
    if (h->root.type == bfd_link_hash_defined
1214
0
        || h->root.type == bfd_link_hash_defweak)
1215
0
      sec = h->root.u.def.section;
1216
1217
    /* Skip relocation against STT_GNU_IFUNC symbol.  */
1218
0
    if (h->type == STT_GNU_IFUNC)
1219
0
      continue;
1220
1221
0
    eh = (struct elf_x86_link_hash_entry *) h;
1222
0
    resolved_to_zero = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, eh);
1223
1224
    /* NB: See how elf_backend_finish_dynamic_symbol is called
1225
       from elf_link_output_extsym.  */
1226
0
    if ((h->dynindx != -1 || h->forced_local)
1227
0
        && ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1228
0
       || h->root.type != bfd_link_hash_undefweak)
1229
0
      || !h->forced_local)
1230
0
        && h->got.offset != (bfd_vma) -1
1231
0
        && ! GOT_TLS_GD_ANY_P (elf_x86_hash_entry (h)->tls_type)
1232
0
        && elf_x86_hash_entry (h)->tls_type != GOT_TLS_IE
1233
0
        && !resolved_to_zero
1234
0
        && SYMBOL_REFERENCES_LOCAL_P (info, h)
1235
0
        && SYMBOL_DEFINED_NON_SHARED_P (h))
1236
0
      dynamic_relative_reloc_p = true;
1237
1238
0
    isym = NULL;
1239
0
  }
1240
1241
0
      if (X86_GOT_TYPE_P (is_x86_64, r_type))
1242
0
  {
1243
    /* Pack GOT relative relocations.  There should be only a
1244
       single R_*_RELATIVE relocation in GOT.  */
1245
0
    if (eh != NULL)
1246
0
      {
1247
0
        if (eh->got_relative_reloc_done)
1248
0
    continue;
1249
1250
0
        if (!(dynamic_relative_reloc_p
1251
0
        || (RESOLVED_LOCALLY_P (info, h, htab)
1252
0
      && GENERATE_RELATIVE_RELOC_P (info, h))))
1253
0
    continue;
1254
1255
0
        if (!dynamic_relative_reloc_p)
1256
0
    eh->no_finish_dynamic_symbol = 1;
1257
0
        eh->got_relative_reloc_done = 1;
1258
0
        offset = h->got.offset;
1259
0
      }
1260
0
    else
1261
0
      {
1262
0
        if (elf_x86_relative_reloc_done (abfd)[r_symndx])
1263
0
    continue;
1264
1265
0
        if (!X86_LOCAL_GOT_RELATIVE_RELOC_P (is_x86_64, info,
1266
0
               isym))
1267
0
    continue;
1268
1269
0
        elf_x86_relative_reloc_done (abfd)[r_symndx] = 1;
1270
0
        offset = local_got_offsets[r_symndx];
1271
0
      }
1272
1273
0
    if (!elf_x86_relative_reloc_record_add (info,
1274
0
              &htab->relative_reloc,
1275
0
              irel, htab->elf.sgot,
1276
0
              sec, h, isym, offset,
1277
0
              &keep_symbuf))
1278
0
      goto error_return;
1279
1280
0
    continue;
1281
0
  }
1282
1283
0
      if (is_x86_64
1284
0
    && irel->r_addend == 0
1285
0
    && !ABI_64_P (info->output_bfd))
1286
0
  {
1287
    /* For x32, if addend is zero, treat R_X86_64_64 like
1288
       R_X86_64_32 and R_X86_64_SIZE64 like R_X86_64_SIZE32.  */
1289
0
    if (r_type == R_X86_64_64)
1290
0
      r_type = R_X86_64_32;
1291
0
    else if (r_type == R_X86_64_SIZE64)
1292
0
      r_type = R_X86_64_SIZE32;
1293
0
  }
1294
1295
0
      if (!X86_RELATIVE_RELOC_TYPE_P (is_x86_64, r_type))
1296
0
  continue;
1297
1298
      /* Pack non-GOT relative relocations.  */
1299
0
      if (is_x86_64)
1300
0
  {
1301
0
    need_copy_reloc_in_pie =
1302
0
      (bfd_link_pie (info)
1303
0
       && h != NULL
1304
0
       && (h->needs_copy
1305
0
     || eh->needs_copy
1306
0
     || (h->root.type == bfd_link_hash_undefined))
1307
0
       && (X86_PCREL_TYPE_P (true, r_type)
1308
0
     || X86_SIZE_TYPE_P (true, r_type)));
1309
0
    pc32_reloc = false;
1310
0
  }
1311
0
      else
1312
0
  {
1313
0
    need_copy_reloc_in_pie = false;
1314
0
    pc32_reloc = r_type == R_386_PC32;
1315
0
  }
1316
1317
0
      if (GENERATE_DYNAMIC_RELOCATION_P (is_x86_64, info, eh, r_type,
1318
0
           sec, need_copy_reloc_in_pie,
1319
0
           resolved_to_zero, pc32_reloc))
1320
0
  {
1321
    /* When generating a shared object, these relocations
1322
       are copied into the output file to be resolved at run
1323
       time.  */
1324
0
    offset = _bfd_elf_section_offset (info->output_bfd, info,
1325
0
              input_section,
1326
0
              irel->r_offset);
1327
0
    if (offset == (bfd_vma) -1
1328
0
        || offset == (bfd_vma) -2
1329
0
        || COPY_INPUT_RELOC_P (is_x86_64, info, h, r_type))
1330
0
      continue;
1331
1332
    /* This symbol is local, or marked to become local.  When
1333
       relocation overflow check is disabled, we convert
1334
       R_X86_64_32 to dynamic R_X86_64_RELATIVE.  */
1335
0
    if (is_x86_64
1336
0
        && !(r_type == htab->pointer_r_type
1337
0
       || (r_type == R_X86_64_32
1338
0
           && htab->params->no_reloc_overflow_check)))
1339
0
      continue;
1340
1341
0
    if (!elf_x86_relative_reloc_record_add
1342
0
          (info,
1343
0
     ((unaligned_section || unaligned_offset)
1344
0
      ? &htab->unaligned_relative_reloc
1345
0
      : &htab->relative_reloc),
1346
0
     irel, input_section, sec, h, isym, offset,
1347
0
     &keep_symbuf))
1348
0
      goto error_return;
1349
0
  }
1350
0
    }
1351
1352
0
  input_section->relative_reloc_packed = 1;
1353
1354
0
  return_status = true;
1355
1356
0
error_return:
1357
0
  if ((unsigned char *) isymbuf != symtab_hdr->contents)
1358
0
    {
1359
      /* Cache the symbol buffer if it must be kept.  */
1360
0
      if (keep_symbuf)
1361
0
  symtab_hdr->contents = (unsigned char *) isymbuf;
1362
0
      else
1363
0
  free (isymbuf);
1364
0
    }
1365
0
  if (elf_section_data (input_section)->relocs != internal_relocs)
1366
0
    free (internal_relocs);
1367
0
  return return_status;
1368
0
}
1369
1370
/* Add an entry to the 64-bit DT_RELR bitmap.  */
1371
1372
static void
1373
elf64_dt_relr_bitmap_add
1374
  (struct bfd_link_info *info, struct elf_dt_relr_bitmap *bitmap,
1375
   uint64_t entry)
1376
0
{
1377
0
  bfd_size_type newidx;
1378
1379
0
  if (bitmap->u.elf64 == NULL)
1380
0
    {
1381
0
      bitmap->u.elf64 = bfd_malloc (sizeof (uint64_t));
1382
0
      bitmap->count = 0;
1383
0
      bitmap->size = 1;
1384
0
    }
1385
1386
0
  newidx = bitmap->count++;
1387
1388
0
  if (bitmap->count > bitmap->size)
1389
0
    {
1390
0
      bitmap->size <<= 1;
1391
0
      bitmap->u.elf64 = bfd_realloc (bitmap->u.elf64,
1392
0
             (bitmap->size * sizeof (uint64_t)));
1393
0
    }
1394
1395
0
  if (bitmap->u.elf64 == NULL)
1396
0
    {
1397
0
      info->callbacks->einfo
1398
  /* xgettext:c-format */
1399
0
  (_("%F%P: %pB: failed to allocate 64-bit DT_RELR bitmap\n"),
1400
0
   info->output_bfd);
1401
0
    }
1402
1403
0
  bitmap->u.elf64[newidx] = entry;
1404
0
}
1405
1406
/* Add an entry to the 32-bit DT_RELR bitmap.  */
1407
1408
static void
1409
elf32_dt_relr_bitmap_add
1410
  (struct bfd_link_info *info, struct elf_dt_relr_bitmap *bitmap,
1411
   uint32_t entry)
1412
0
{
1413
0
  bfd_size_type newidx;
1414
1415
0
  if (bitmap->u.elf32 == NULL)
1416
0
    {
1417
0
      bitmap->u.elf32 = bfd_malloc (sizeof (uint32_t));
1418
0
      bitmap->count = 0;
1419
0
      bitmap->size = 1;
1420
0
    }
1421
1422
0
  newidx = bitmap->count++;
1423
1424
0
  if (bitmap->count > bitmap->size)
1425
0
    {
1426
0
      bitmap->size <<= 1;
1427
0
      bitmap->u.elf32 = bfd_realloc (bitmap->u.elf32,
1428
0
             (bitmap->size * sizeof (uint32_t)));
1429
0
    }
1430
1431
0
  if (bitmap->u.elf32 == NULL)
1432
0
    {
1433
0
      info->callbacks->einfo
1434
  /* xgettext:c-format */
1435
0
  (_("%F%P: %pB: failed to allocate 32-bit DT_RELR bitmap\n"),
1436
0
   info->output_bfd);
1437
0
    }
1438
1439
0
  bitmap->u.elf32[newidx] = entry;
1440
0
}
1441
1442
void
1443
_bfd_elf32_write_addend (bfd *abfd, uint64_t value, void *addr)
1444
0
{
1445
0
  bfd_put_32 (abfd, value, addr);
1446
0
}
1447
1448
void
1449
_bfd_elf64_write_addend (bfd *abfd, uint64_t value, void *addr)
1450
0
{
1451
0
  bfd_put_64 (abfd, value, addr);
1452
0
}
1453
1454
/* Size or finish relative relocations to determine the run-time
1455
   addresses for DT_RELR bitmap computation later.  OUTREL is set
1456
   to NULL in the sizing phase and non-NULL in the finising phase
1457
   where the regular relative relocations will be written out.  */
1458
1459
static void
1460
elf_x86_size_or_finish_relative_reloc
1461
  (bool is_x86_64, struct bfd_link_info *info,
1462
   struct elf_x86_link_hash_table *htab, bool unaligned,
1463
   Elf_Internal_Rela *outrel)
1464
0
{
1465
0
  unsigned int align_mask;
1466
0
  bfd_size_type i, count;
1467
0
  asection *sec, *srel;
1468
0
  struct elf_link_hash_entry *h;
1469
0
  bfd_vma offset;
1470
0
  Elf_Internal_Sym *sym;
1471
0
  asection *sym_sec;
1472
0
  asection *sgot = htab->elf.sgot;
1473
0
  asection *srelgot = htab->elf.srelgot;
1474
0
  struct elf_x86_relative_reloc_data *relative_reloc;
1475
1476
0
  if (unaligned)
1477
0
    {
1478
0
      align_mask = 0;
1479
0
      relative_reloc = &htab->unaligned_relative_reloc;
1480
0
    }
1481
0
  else
1482
0
    {
1483
0
      align_mask = 1;
1484
0
      relative_reloc = &htab->relative_reloc;
1485
0
    }
1486
1487
0
  count = relative_reloc->count;
1488
0
  for (i = 0; i < count; i++)
1489
0
    {
1490
0
      sec = relative_reloc->data[i].sec;
1491
0
      sym = relative_reloc->data[i].sym;
1492
1493
      /* If SYM is NULL, it must be a global symbol.  */
1494
0
      if (sym == NULL)
1495
0
  h = relative_reloc->data[i].u.h;
1496
0
      else
1497
0
  h = NULL;
1498
1499
0
      if (is_x86_64)
1500
0
  {
1501
0
    bfd_vma relocation;
1502
    /* This function may be called more than once and REL may be
1503
       updated by _bfd_elf_rela_local_sym below.  */
1504
0
    Elf_Internal_Rela rel = relative_reloc->data[i].rel;
1505
1506
0
    if (h != NULL)
1507
0
      {
1508
0
        if (h->root.type == bfd_link_hash_defined
1509
0
      || h->root.type == bfd_link_hash_defweak)
1510
0
    {
1511
0
      sym_sec = h->root.u.def.section;
1512
0
      relocation = (h->root.u.def.value
1513
0
        + sym_sec->output_section->vma
1514
0
        + sym_sec->output_offset);
1515
0
    }
1516
0
        else
1517
0
    {
1518
      /* Allow undefined symbol only at the sizing phase.
1519
         Otherwise skip undefined symbol here.  Undefined
1520
         symbol will be reported by relocate_section.  */
1521
0
      if (outrel == NULL)
1522
0
        relocation = 0;
1523
0
      else
1524
0
        continue;
1525
0
    }
1526
0
      }
1527
0
    else
1528
0
      {
1529
0
        sym_sec = relative_reloc->data[i].u.sym_sec;
1530
0
        relocation = _bfd_elf_rela_local_sym
1531
0
    (info->output_bfd, sym, &sym_sec, &rel);
1532
0
      }
1533
1534
0
    if (outrel != NULL)
1535
0
      {
1536
0
        outrel->r_addend = relocation;
1537
0
        if (sec == sgot)
1538
0
    {
1539
0
      if (h != NULL && h->needs_plt)
1540
0
        abort ();
1541
0
    }
1542
0
        else
1543
0
    outrel->r_addend += rel.r_addend;
1544
1545
        /* Write the implicit addend if ALIGN_MASK isn't 0.  */
1546
0
        if (align_mask)
1547
0
    {
1548
0
      if (sec == sgot)
1549
0
        {
1550
0
          if (relative_reloc->data[i].offset >= sec->size)
1551
0
      abort ();
1552
0
          htab->elf_write_addend_in_got
1553
0
      (info->output_bfd, outrel->r_addend,
1554
0
       sec->contents + relative_reloc->data[i].offset);
1555
0
        }
1556
0
      else
1557
0
        {
1558
0
          bfd_byte *contents;
1559
1560
0
          if (rel.r_offset >= sec->size)
1561
0
      abort ();
1562
1563
0
          if (elf_section_data (sec)->this_hdr.contents
1564
0
        != NULL)
1565
0
      contents
1566
0
        = elf_section_data (sec)->this_hdr.contents;
1567
0
          else
1568
0
      {
1569
0
        if (!_bfd_elf_mmap_section_contents (sec->owner,
1570
0
                     sec,
1571
0
                     &contents))
1572
0
          info->callbacks->einfo
1573
            /* xgettext:c-format */
1574
0
            (_("%F%P: %pB: failed to allocate memory for section `%pA'\n"),
1575
0
             info->output_bfd, sec);
1576
1577
        /* Cache the section contents for
1578
           elf_link_input_bfd.  */
1579
0
        elf_section_data (sec)->this_hdr.contents
1580
0
          = contents;
1581
0
      }
1582
0
          htab->elf_write_addend
1583
0
      (info->output_bfd, outrel->r_addend,
1584
0
       contents + rel.r_offset);
1585
0
        }
1586
0
    }
1587
0
      }
1588
0
  }
1589
1590
0
      if (sec == sgot)
1591
0
  srel = srelgot;
1592
0
      else
1593
0
  srel = elf_section_data (sec)->sreloc;
1594
0
      offset = (sec->output_section->vma + sec->output_offset
1595
0
    + relative_reloc->data[i].offset);
1596
0
      relative_reloc->data[i].address = offset;
1597
0
      if (outrel != NULL)
1598
0
  {
1599
0
    outrel->r_offset = offset;
1600
1601
0
    if ((outrel->r_offset & align_mask) != 0)
1602
0
      abort ();
1603
1604
0
    if (htab->params->report_relative_reloc)
1605
0
      _bfd_x86_elf_link_report_relative_reloc
1606
0
        (info, sec, h, sym, htab->relative_r_name, outrel);
1607
1608
    /* Generate regular relative relocation if ALIGN_MASK is 0.  */
1609
0
    if (align_mask == 0)
1610
0
      htab->elf_append_reloc (info->output_bfd, srel, outrel);
1611
0
  }
1612
0
    }
1613
0
}
1614
1615
/* Compute the DT_RELR section size.  Set NEED_PLAYOUT to true if
1616
   the DT_RELR section size has been increased.  */
1617
1618
static void
1619
elf_x86_compute_dl_relr_bitmap
1620
  (struct bfd_link_info *info, struct elf_x86_link_hash_table *htab,
1621
   bool *need_layout)
1622
0
{
1623
0
  bfd_vma base;
1624
0
  bfd_size_type i, count, new_count;
1625
0
  struct elf_x86_relative_reloc_data *relative_reloc =
1626
0
    &htab->relative_reloc;
1627
  /* Save the old DT_RELR bitmap count.  Don't shrink the DT_RELR bitmap
1628
     if the new DT_RELR bitmap count is smaller than the old one.  Pad
1629
     with trailing 1s which won't be decoded to more relocations.  */
1630
0
  bfd_size_type dt_relr_bitmap_count = htab->dt_relr_bitmap.count;
1631
1632
  /* Clear the DT_RELR bitmap count.  */
1633
0
  htab->dt_relr_bitmap.count = 0;
1634
1635
0
  count = relative_reloc->count;
1636
1637
0
  if (ABI_64_P (info->output_bfd))
1638
0
    {
1639
      /* Compute the 64-bit DT_RELR bitmap.  */
1640
0
      i = 0;
1641
0
      while (i < count)
1642
0
  {
1643
0
    if ((relative_reloc->data[i].address % 1) != 0)
1644
0
      abort ();
1645
1646
0
    elf64_dt_relr_bitmap_add (info, &htab->dt_relr_bitmap,
1647
0
            relative_reloc->data[i].address);
1648
1649
0
    base = relative_reloc->data[i].address + 8;
1650
0
    i++;
1651
1652
0
    while (i < count)
1653
0
      {
1654
0
        uint64_t bitmap = 0;
1655
0
        for (; i < count; i++)
1656
0
    {
1657
0
      bfd_vma delta = (relative_reloc->data[i].address
1658
0
           - base);
1659
      /* Stop if it is too far from base.  */
1660
0
      if (delta >= 63 * 8)
1661
0
        break;
1662
      /* Stop if it isn't a multiple of 8.  */
1663
0
      if ((delta % 8) != 0)
1664
0
        break;
1665
0
      bitmap |= 1ULL << (delta / 8);
1666
0
    }
1667
1668
0
        if (bitmap == 0)
1669
0
    break;
1670
1671
0
        elf64_dt_relr_bitmap_add (info, &htab->dt_relr_bitmap,
1672
0
          (bitmap << 1) | 1);
1673
1674
0
        base += 63 * 8;
1675
0
      }
1676
0
  }
1677
1678
0
      new_count = htab->dt_relr_bitmap.count;
1679
0
      if (dt_relr_bitmap_count > new_count)
1680
0
  {
1681
    /* Don't shrink the DT_RELR section size to avoid section
1682
       layout oscillation.  Instead, pad the DT_RELR bitmap with
1683
       1s which do not decode to more relocations.  */
1684
1685
0
    htab->dt_relr_bitmap.count = dt_relr_bitmap_count;
1686
0
    count = dt_relr_bitmap_count - new_count;
1687
0
    for (i = 0; i < count; i++)
1688
0
      htab->dt_relr_bitmap.u.elf64[new_count + i] = 1;
1689
0
  }
1690
0
    }
1691
0
  else
1692
0
    {
1693
      /* Compute the 32-bit DT_RELR bitmap.  */
1694
0
      i = 0;
1695
0
      while (i < count)
1696
0
  {
1697
0
    if ((relative_reloc->data[i].address % 1) != 0)
1698
0
      abort ();
1699
1700
0
    elf32_dt_relr_bitmap_add (info, &htab->dt_relr_bitmap,
1701
0
            relative_reloc->data[i].address);
1702
1703
0
    base = relative_reloc->data[i].address + 4;
1704
0
    i++;
1705
1706
0
    while (i < count)
1707
0
      {
1708
0
        uint32_t bitmap = 0;
1709
0
        for (; i < count; i++)
1710
0
    {
1711
0
      bfd_vma delta = (relative_reloc->data[i].address
1712
0
           - base);
1713
      /* Stop if it is too far from base.  */
1714
0
      if (delta >= 31 * 4)
1715
0
        break;
1716
      /* Stop if it isn't a multiple of 4.  */
1717
0
      if ((delta % 4) != 0)
1718
0
        break;
1719
0
      bitmap |= 1ULL << (delta / 4);
1720
0
    }
1721
1722
0
        if (bitmap == 0)
1723
0
    break;
1724
1725
0
        elf32_dt_relr_bitmap_add (info, &htab->dt_relr_bitmap,
1726
0
          (bitmap << 1) | 1);
1727
1728
0
        base += 31 * 4;
1729
0
      }
1730
0
  }
1731
1732
0
      new_count = htab->dt_relr_bitmap.count;
1733
0
      if (dt_relr_bitmap_count > new_count)
1734
0
  {
1735
    /* Don't shrink the DT_RELR section size to avoid section
1736
       layout oscillation.  Instead, pad the DT_RELR bitmap with
1737
       1s which do not decode to more relocations.  */
1738
1739
0
    htab->dt_relr_bitmap.count = dt_relr_bitmap_count;
1740
0
    count = dt_relr_bitmap_count - new_count;
1741
0
    for (i = 0; i < count; i++)
1742
0
      htab->dt_relr_bitmap.u.elf32[new_count + i] = 1;
1743
0
  }
1744
0
    }
1745
1746
0
  if (htab->dt_relr_bitmap.count != dt_relr_bitmap_count)
1747
0
    {
1748
0
      if (need_layout)
1749
0
  {
1750
    /* The .relr.dyn section size is changed.  Update the section
1751
       size and tell linker to layout sections again.  */
1752
0
    htab->elf.srelrdyn->size =
1753
0
      (htab->dt_relr_bitmap.count
1754
0
       * (ABI_64_P (info->output_bfd) ? 8 : 4));
1755
1756
0
    *need_layout = true;
1757
0
  }
1758
0
      else
1759
0
  info->callbacks->einfo
1760
    /* xgettext:c-format */
1761
0
    (_("%F%P: %pB: size of compact relative reloc section is "
1762
0
       "changed: new (%lu) != old (%lu)\n"),
1763
0
     info->output_bfd, htab->dt_relr_bitmap.count,
1764
0
     dt_relr_bitmap_count);
1765
0
    }
1766
0
}
1767
1768
/* Write out the DT_RELR section.  */
1769
1770
static void
1771
elf_x86_write_dl_relr_bitmap (struct bfd_link_info *info,
1772
            struct elf_x86_link_hash_table *htab)
1773
0
{
1774
0
  asection *sec = htab->elf.srelrdyn;
1775
0
  bfd_size_type size = sec->size;
1776
0
  bfd_size_type i;
1777
0
  unsigned char *contents;
1778
1779
0
  contents = (unsigned char *) bfd_alloc (sec->owner, size);
1780
0
  if (contents == NULL)
1781
0
    info->callbacks->einfo
1782
      /* xgettext:c-format */
1783
0
      (_("%F%P: %pB: failed to allocate compact relative reloc section\n"),
1784
0
       info->output_bfd);
1785
1786
  /* Cache the section contents for elf_link_input_bfd.  */
1787
0
  sec->contents = contents;
1788
1789
0
  if (ABI_64_P (info->output_bfd))
1790
0
    for (i = 0; i < htab->dt_relr_bitmap.count; i++, contents += 8)
1791
0
      bfd_put_64 (info->output_bfd, htab->dt_relr_bitmap.u.elf64[i],
1792
0
      contents);
1793
0
  else
1794
0
    for (i = 0; i < htab->dt_relr_bitmap.count; i++, contents += 4)
1795
0
      bfd_put_32 (info->output_bfd, htab->dt_relr_bitmap.u.elf32[i],
1796
0
      contents);
1797
0
}
1798
1799
/* Sort relative relocations by address.  */
1800
1801
static int
1802
elf_x86_relative_reloc_compare (const void *pa, const void *pb)
1803
0
{
1804
0
  struct elf_x86_relative_reloc_record *a =
1805
0
    (struct elf_x86_relative_reloc_record *) pa;
1806
0
  struct elf_x86_relative_reloc_record *b =
1807
0
    (struct elf_x86_relative_reloc_record *) pb;
1808
0
  if (a->address < b->address)
1809
0
    return -1;
1810
0
  if (a->address > b->address)
1811
0
    return 1;
1812
0
  return 0;
1813
0
}
1814
1815
enum dynobj_sframe_plt_type
1816
{
1817
  SFRAME_PLT = 1,
1818
  SFRAME_PLT_SEC = 2
1819
};
1820
1821
/* Create SFrame stack trace info for the plt entries in the .plt section
1822
   of type PLT_SEC_TYPE.  */
1823
1824
static bool
1825
_bfd_x86_elf_create_sframe_plt (bfd *output_bfd,
1826
        struct bfd_link_info *info,
1827
        unsigned int plt_sec_type)
1828
0
{
1829
0
  struct elf_x86_link_hash_table *htab;
1830
0
  const struct elf_backend_data *bed;
1831
1832
0
  bool plt0_generated_p;
1833
0
  unsigned int plt0_entry_size;
1834
0
  unsigned char func_info;
1835
0
  uint32_t fre_type;
1836
  /* The dynamic plt section for which .sframe stack trace information is being
1837
     created.  */
1838
0
  asection *dpltsec;
1839
1840
0
  int err = 0;
1841
1842
0
  sframe_encoder_ctx **ectx = NULL;
1843
0
  unsigned plt_entry_size = 0;
1844
0
  unsigned int num_pltn_fres = 0;
1845
0
  unsigned int num_pltn_entries = 0;
1846
1847
0
  bed = get_elf_backend_data (output_bfd);
1848
0
  htab = elf_x86_hash_table (info, bed->target_id);
1849
  /* Whether SFrame stack trace info for plt0 is to be generated.  */
1850
0
  plt0_generated_p = htab->plt.has_plt0;
1851
0
  plt0_entry_size
1852
0
    = (plt0_generated_p) ? htab->sframe_plt->plt0_entry_size : 0;
1853
1854
0
  switch (plt_sec_type)
1855
0
    {
1856
0
    case SFRAME_PLT:
1857
0
  {
1858
0
    ectx = &htab->plt_cfe_ctx;
1859
0
    dpltsec = htab->elf.splt;
1860
1861
0
    plt_entry_size = htab->plt.plt_entry_size;
1862
0
    num_pltn_fres = htab->sframe_plt->pltn_num_fres;
1863
0
    num_pltn_entries
1864
0
      = (dpltsec->size - plt0_entry_size) / plt_entry_size;
1865
1866
0
    break;
1867
0
  }
1868
0
    case SFRAME_PLT_SEC:
1869
0
  {
1870
0
    ectx = &htab->plt_second_cfe_ctx;
1871
    /* FIXME - this or htab->plt_second_sframe ?  */
1872
0
    dpltsec = htab->plt_second_eh_frame;
1873
1874
0
    plt_entry_size = htab->sframe_plt->sec_pltn_entry_size;
1875
0
    num_pltn_fres = htab->sframe_plt->sec_pltn_num_fres;
1876
0
    num_pltn_entries = dpltsec->size / plt_entry_size;
1877
0
    break;
1878
0
  }
1879
0
    default:
1880
      /* No other value is possible.  */
1881
0
      return false;
1882
0
      break;
1883
0
    }
1884
1885
0
  *ectx = sframe_encode (SFRAME_VERSION_2,
1886
0
       0,
1887
0
       SFRAME_ABI_AMD64_ENDIAN_LITTLE,
1888
0
       SFRAME_CFA_FIXED_FP_INVALID,
1889
0
       -8, /*  Fixed RA offset.  */
1890
0
       &err);
1891
1892
  /* FRE type is dependent on the size of the function.  */
1893
0
  fre_type = sframe_calc_fre_type (dpltsec->size);
1894
0
  func_info = sframe_fde_create_func_info (fre_type, SFRAME_FDE_TYPE_PCINC);
1895
1896
  /* Add SFrame FDE and the associated FREs for plt0 if plt0 has been
1897
     generated.  */
1898
0
  if (plt0_generated_p)
1899
0
    {
1900
      /* Add SFrame FDE for plt0, the function start address is updated later
1901
   at _bfd_elf_merge_section_sframe time.  */
1902
0
      sframe_encoder_add_funcdesc_v2 (*ectx,
1903
0
              0, /* func start addr.  */
1904
0
              plt0_entry_size,
1905
0
              func_info,
1906
0
              16,
1907
0
              0 /* Num FREs.  */);
1908
0
      sframe_frame_row_entry plt0_fre;
1909
0
      unsigned int num_plt0_fres = htab->sframe_plt->plt0_num_fres;
1910
0
      for (unsigned int j = 0; j < num_plt0_fres; j++)
1911
0
  {
1912
0
    plt0_fre = *(htab->sframe_plt->plt0_fres[j]);
1913
0
    sframe_encoder_add_fre (*ectx, 0, &plt0_fre);
1914
0
  }
1915
0
    }
1916
1917
1918
0
  if (num_pltn_entries)
1919
0
    {
1920
      /* pltn entries use an SFrame FDE of type
1921
   SFRAME_FDE_TYPE_PCMASK to exploit the repetitive
1922
   pattern of the instructions in these entries.  Using this SFrame FDE
1923
   type helps in keeping the SFrame stack trace info for pltn entries
1924
   compact.  */
1925
0
      func_info = sframe_fde_create_func_info (fre_type,
1926
0
                 SFRAME_FDE_TYPE_PCMASK);
1927
      /* Add the SFrame FDE for all PCs starting at the first pltn entry (hence,
1928
   function start address = plt0_entry_size.  As usual, this will be
1929
   updated later at _bfd_elf_merge_section_sframe, by when the
1930
   sections are relocated.  */
1931
0
      sframe_encoder_add_funcdesc_v2 (*ectx,
1932
0
              plt0_entry_size, /* func start addr.  */
1933
0
              dpltsec->size - plt0_entry_size,
1934
0
              func_info,
1935
0
              16,
1936
0
              0 /* Num FREs.  */);
1937
1938
0
      sframe_frame_row_entry pltn_fre;
1939
      /* Now add the FREs for pltn.  Simply adding the two FREs suffices due
1940
   to the usage of SFRAME_FDE_TYPE_PCMASK above.  */
1941
0
      for (unsigned int j = 0; j < num_pltn_fres; j++)
1942
0
  {
1943
0
    pltn_fre = *(htab->sframe_plt->pltn_fres[j]);
1944
0
    sframe_encoder_add_fre (*ectx, 1, &pltn_fre);
1945
0
  }
1946
0
    }
1947
1948
0
  return true;
1949
0
}
1950
1951
/* Put contents of the .sframe section corresponding to the specified
1952
   PLT_SEC_TYPE.  */
1953
1954
static bool
1955
_bfd_x86_elf_write_sframe_plt (bfd *output_bfd,
1956
             struct bfd_link_info *info,
1957
             unsigned int plt_sec_type)
1958
0
{
1959
0
  struct elf_x86_link_hash_table *htab;
1960
0
  const struct elf_backend_data *bed;
1961
0
  sframe_encoder_ctx *ectx;
1962
0
  size_t sec_size;
1963
0
  asection *sec;
1964
0
  bfd *dynobj;
1965
1966
0
  int err = 0;
1967
1968
0
  bed = get_elf_backend_data (output_bfd);
1969
0
  htab = elf_x86_hash_table (info, bed->target_id);
1970
0
  dynobj = htab->elf.dynobj;
1971
1972
0
  switch (plt_sec_type)
1973
0
    {
1974
0
    case SFRAME_PLT:
1975
0
      ectx = htab->plt_cfe_ctx;
1976
0
      sec = htab->plt_sframe;
1977
0
      break;
1978
0
    case SFRAME_PLT_SEC:
1979
0
      ectx = htab->plt_second_cfe_ctx;
1980
0
      sec = htab->plt_second_sframe;
1981
0
      break;
1982
0
    default:
1983
      /* No other value is possible.  */
1984
0
      return false;
1985
0
      break;
1986
0
    }
1987
1988
0
  BFD_ASSERT (ectx);
1989
1990
0
  void *contents = sframe_encoder_write (ectx, &sec_size, &err);
1991
1992
0
  sec->size = (bfd_size_type) sec_size;
1993
0
  sec->contents = (unsigned char *) bfd_zalloc (dynobj, sec->size);
1994
0
  memcpy (sec->contents, contents, sec_size);
1995
1996
0
  sframe_encoder_free (&ectx);
1997
1998
0
  return true;
1999
0
}
2000
2001
bool
2002
_bfd_elf_x86_size_relative_relocs (struct bfd_link_info *info,
2003
           bool *need_layout)
2004
0
{
2005
0
  struct elf_x86_link_hash_table *htab;
2006
0
  const struct elf_backend_data *bed;
2007
0
  bool is_x86_64;
2008
0
  bfd_size_type i, count, unaligned_count;
2009
0
  asection *sec, *srel;
2010
2011
  /* Do nothing for ld -r.  */
2012
0
  if (bfd_link_relocatable (info))
2013
0
    return true;
2014
2015
0
  bed = get_elf_backend_data (info->output_bfd);
2016
0
  htab = elf_x86_hash_table (info, bed->target_id);
2017
0
  if (htab == NULL)
2018
0
    return false;
2019
2020
0
  count = htab->relative_reloc.count;
2021
0
  unaligned_count = htab->unaligned_relative_reloc.count;
2022
0
  if (count == 0)
2023
0
    {
2024
0
      if (htab->generate_relative_reloc_pass == 0
2025
0
    && htab->elf.srelrdyn != NULL)
2026
0
  {
2027
    /* Remove the empty .relr.dyn sections now.  */
2028
0
    if (!bfd_is_abs_section (htab->elf.srelrdyn->output_section))
2029
0
      {
2030
0
        bfd_section_list_remove
2031
0
    (info->output_bfd, htab->elf.srelrdyn->output_section);
2032
0
        info->output_bfd->section_count--;
2033
0
      }
2034
0
    bfd_section_list_remove (htab->elf.srelrdyn->owner,
2035
0
           htab->elf.srelrdyn);
2036
0
    htab->elf.srelrdyn->owner->section_count--;
2037
0
  }
2038
0
      if (unaligned_count == 0)
2039
0
  {
2040
0
    htab->generate_relative_reloc_pass++;
2041
0
    return true;
2042
0
  }
2043
0
    }
2044
2045
0
  is_x86_64 = bed->target_id == X86_64_ELF_DATA;
2046
2047
  /* Size relative relocations.  */
2048
0
  if (htab->generate_relative_reloc_pass)
2049
0
    {
2050
      /* Reset the regular relative relocation count.  */
2051
0
      for (i = 0; i < unaligned_count; i++)
2052
0
  {
2053
0
    sec = htab->unaligned_relative_reloc.data[i].sec;
2054
0
    srel = elf_section_data (sec)->sreloc;
2055
0
    srel->reloc_count = 0;
2056
0
  }
2057
0
    }
2058
0
  else
2059
0
    {
2060
      /* Remove the reserved space for compact relative relocations.  */
2061
0
      if (count)
2062
0
  {
2063
0
    asection *sgot = htab->elf.sgot;
2064
0
    asection *srelgot = htab->elf.srelgot;
2065
2066
0
    for (i = 0; i < count; i++)
2067
0
      {
2068
0
        sec = htab->relative_reloc.data[i].sec;
2069
0
        if (sec == sgot)
2070
0
    srel = srelgot;
2071
0
        else
2072
0
    srel = elf_section_data (sec)->sreloc;
2073
0
        srel->size -= htab->sizeof_reloc;
2074
0
      }
2075
0
  }
2076
0
    }
2077
2078
  /* Size unaligned relative relocations.  */
2079
0
  if (unaligned_count)
2080
0
    elf_x86_size_or_finish_relative_reloc (is_x86_64, info, htab,
2081
0
             true, NULL);
2082
2083
0
  if (count)
2084
0
    {
2085
0
      elf_x86_size_or_finish_relative_reloc (is_x86_64, info, htab,
2086
0
               false, NULL);
2087
2088
      /* Sort relative relocations by addresses.  We only need to
2089
   sort them in the first pass since the relative positions
2090
   won't change.  */
2091
0
      if (htab->generate_relative_reloc_pass == 0)
2092
0
  qsort (htab->relative_reloc.data, count,
2093
0
         sizeof (struct elf_x86_relative_reloc_record),
2094
0
         elf_x86_relative_reloc_compare);
2095
2096
0
      elf_x86_compute_dl_relr_bitmap (info, htab, need_layout);
2097
0
    }
2098
2099
0
  htab->generate_relative_reloc_pass++;
2100
2101
0
  return true;
2102
0
}
2103
2104
bool
2105
_bfd_elf_x86_finish_relative_relocs (struct bfd_link_info *info)
2106
0
{
2107
0
  struct elf_x86_link_hash_table *htab;
2108
0
  const struct elf_backend_data *bed;
2109
0
  Elf_Internal_Rela outrel;
2110
0
  bool is_x86_64;
2111
0
  bfd_size_type count;
2112
2113
  /* Do nothing for ld -r.  */
2114
0
  if (bfd_link_relocatable (info))
2115
0
    return true;
2116
2117
0
  bed = get_elf_backend_data (info->output_bfd);
2118
0
  htab = elf_x86_hash_table (info, bed->target_id);
2119
0
  if (htab == NULL)
2120
0
    return false;
2121
2122
0
  is_x86_64 = bed->target_id == X86_64_ELF_DATA;
2123
2124
0
  outrel.r_info = htab->r_info (0, htab->relative_r_type);
2125
2126
0
  if (htab->unaligned_relative_reloc.count)
2127
0
    elf_x86_size_or_finish_relative_reloc (is_x86_64, info, htab,
2128
0
             true, &outrel);
2129
2130
0
  count = htab->relative_reloc.count;
2131
0
  if (count)
2132
0
    {
2133
0
      elf_x86_size_or_finish_relative_reloc (is_x86_64, info, htab,
2134
0
               false, &outrel);
2135
2136
0
      elf_x86_compute_dl_relr_bitmap (info, htab, NULL);
2137
2138
0
      elf_x86_write_dl_relr_bitmap (info, htab);
2139
0
    }
2140
2141
0
  return true;
2142
0
}
2143
2144
bool
2145
_bfd_elf_x86_valid_reloc_p (asection *input_section,
2146
          struct bfd_link_info *info,
2147
          struct elf_x86_link_hash_table *htab,
2148
          const Elf_Internal_Rela *rel,
2149
          struct elf_link_hash_entry *h,
2150
          Elf_Internal_Sym *sym,
2151
          Elf_Internal_Shdr *symtab_hdr,
2152
          bool *no_dynreloc_p)
2153
0
{
2154
0
  bool valid_p = true;
2155
2156
0
  *no_dynreloc_p = false;
2157
2158
  /* Check If relocation against non-preemptible absolute symbol is
2159
     valid in PIC.  FIXME: Can't use SYMBOL_REFERENCES_LOCAL_P since
2160
     it may call _bfd_elf_link_hide_sym_by_version and result in
2161
     ld-elfvers/ vers21 test failure.  */
2162
0
  if (bfd_link_pic (info)
2163
0
      && (h == NULL || SYMBOL_REFERENCES_LOCAL (info, h)))
2164
0
    {
2165
0
      const struct elf_backend_data *bed;
2166
0
      unsigned int r_type;
2167
0
      Elf_Internal_Rela irel;
2168
2169
      /* Skip non-absolute symbol.  */
2170
0
      if (h)
2171
0
  {
2172
0
    if (!ABS_SYMBOL_P (h))
2173
0
      return valid_p;
2174
0
  }
2175
0
      else if (sym->st_shndx != SHN_ABS)
2176
0
  return valid_p;
2177
2178
0
      bed = get_elf_backend_data (input_section->owner);
2179
0
      r_type = ELF32_R_TYPE (rel->r_info);
2180
0
      irel = *rel;
2181
2182
      /* Only allow relocations against absolute symbol, which can be
2183
   resolved as absolute value + addend.  GOTPCREL and GOT32
2184
   relocations are allowed since absolute value + addend is
2185
   stored in the GOT slot.  */
2186
0
      if (bed->target_id == X86_64_ELF_DATA)
2187
0
  {
2188
0
    r_type &= ~R_X86_64_converted_reloc_bit;
2189
0
    valid_p = (r_type == R_X86_64_64
2190
0
         || r_type == R_X86_64_32
2191
0
         || r_type == R_X86_64_32S
2192
0
         || r_type == R_X86_64_16
2193
0
         || r_type == R_X86_64_8
2194
0
         || r_type == R_X86_64_GOTPCREL
2195
0
         || r_type == R_X86_64_GOTPCRELX
2196
0
         || r_type == R_X86_64_REX_GOTPCRELX);
2197
0
    if (!valid_p)
2198
0
      {
2199
0
        unsigned int r_symndx = htab->r_sym (rel->r_info);
2200
0
        irel.r_info = htab->r_info (r_symndx, r_type);
2201
0
      }
2202
0
  }
2203
0
      else
2204
0
  valid_p = (r_type == R_386_32
2205
0
       || r_type == R_386_16
2206
0
       || r_type == R_386_8
2207
0
       || r_type == R_386_GOT32
2208
0
       || r_type == R_386_GOT32X);
2209
2210
0
      if (valid_p)
2211
0
  *no_dynreloc_p = true;
2212
0
      else
2213
0
  {
2214
0
    const char *name;
2215
0
    arelent internal_reloc;
2216
2217
0
    if (!bed->elf_info_to_howto (input_section->owner,
2218
0
               &internal_reloc, &irel)
2219
0
        || internal_reloc.howto == NULL)
2220
0
      abort ();
2221
2222
0
    if (h)
2223
0
      name = h->root.root.string;
2224
0
    else
2225
0
      name = bfd_elf_sym_name (input_section->owner, symtab_hdr,
2226
0
             sym, NULL);
2227
0
    info->callbacks->einfo
2228
      /* xgettext:c-format */
2229
0
      (_("%F%P: %pB: relocation %s against absolute symbol "
2230
0
         "`%s' in section `%pA' is disallowed\n"),
2231
0
       input_section->owner, internal_reloc.howto->name, name,
2232
0
       input_section);
2233
0
    bfd_set_error (bfd_error_bad_value);
2234
0
  }
2235
0
    }
2236
2237
0
  return valid_p;
2238
0
}
2239
2240
/* Set the sizes of the dynamic sections.  */
2241
2242
bool
2243
_bfd_x86_elf_late_size_sections (bfd *output_bfd,
2244
            struct bfd_link_info *info)
2245
0
{
2246
0
  struct elf_x86_link_hash_table *htab;
2247
0
  bfd *dynobj;
2248
0
  asection *s;
2249
0
  bool relocs;
2250
0
  bfd *ibfd;
2251
0
  const struct elf_backend_data *bed
2252
0
    = get_elf_backend_data (output_bfd);
2253
2254
0
  htab = elf_x86_hash_table (info, bed->target_id);
2255
0
  if (htab == NULL)
2256
0
    return false;
2257
0
  dynobj = htab->elf.dynobj;
2258
0
  if (dynobj == NULL)
2259
0
    return true;
2260
2261
  /* Set up .got offsets for local syms, and space for local dynamic
2262
     relocs.  */
2263
0
  for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2264
0
    {
2265
0
      bfd_signed_vma *local_got;
2266
0
      bfd_signed_vma *end_local_got;
2267
0
      char *local_tls_type;
2268
0
      bfd_vma *local_tlsdesc_gotent;
2269
0
      bfd_size_type locsymcount;
2270
0
      Elf_Internal_Shdr *symtab_hdr;
2271
0
      asection *srel;
2272
2273
0
      if (! is_x86_elf (ibfd, htab))
2274
0
  continue;
2275
2276
0
      for (s = ibfd->sections; s != NULL; s = s->next)
2277
0
  {
2278
0
    struct elf_dyn_relocs *p;
2279
2280
0
    for (p = ((struct elf_dyn_relocs *)
2281
0
         elf_section_data (s)->local_dynrel);
2282
0
         p != NULL;
2283
0
         p = p->next)
2284
0
      {
2285
0
        if (!bfd_is_abs_section (p->sec)
2286
0
      && bfd_is_abs_section (p->sec->output_section))
2287
0
    {
2288
      /* Input section has been discarded, either because
2289
         it is a copy of a linkonce section or due to
2290
         linker script /DISCARD/, so we'll be discarding
2291
         the relocs too.  */
2292
0
    }
2293
0
        else if (htab->elf.target_os == is_vxworks
2294
0
           && strcmp (p->sec->output_section->name,
2295
0
          ".tls_vars") == 0)
2296
0
    {
2297
      /* Relocations in vxworks .tls_vars sections are
2298
         handled specially by the loader.  */
2299
0
    }
2300
0
        else if (p->count != 0)
2301
0
    {
2302
0
      srel = elf_section_data (p->sec)->sreloc;
2303
0
      srel->size += p->count * htab->sizeof_reloc;
2304
0
      if ((p->sec->output_section->flags & SEC_READONLY) != 0
2305
0
          && (info->flags & DF_TEXTREL) == 0)
2306
0
        {
2307
0
          info->flags |= DF_TEXTREL;
2308
0
          if (bfd_link_textrel_check (info))
2309
      /* xgettext:c-format */
2310
0
      info->callbacks->einfo
2311
0
        (_("%P: %pB: warning: relocation "
2312
0
           "in read-only section `%pA'\n"),
2313
0
         p->sec->owner, p->sec);
2314
0
        }
2315
0
    }
2316
0
      }
2317
0
  }
2318
2319
0
      local_got = elf_local_got_refcounts (ibfd);
2320
0
      if (!local_got)
2321
0
  continue;
2322
2323
0
      symtab_hdr = &elf_symtab_hdr (ibfd);
2324
0
      locsymcount = symtab_hdr->sh_info;
2325
0
      end_local_got = local_got + locsymcount;
2326
0
      local_tls_type = elf_x86_local_got_tls_type (ibfd);
2327
0
      local_tlsdesc_gotent = elf_x86_local_tlsdesc_gotent (ibfd);
2328
0
      s = htab->elf.sgot;
2329
0
      srel = htab->elf.srelgot;
2330
0
      for (; local_got < end_local_got;
2331
0
     ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
2332
0
  {
2333
0
    *local_tlsdesc_gotent = (bfd_vma) -1;
2334
0
    if (*local_got > 0)
2335
0
      {
2336
0
        if (GOT_TLS_GDESC_P (*local_tls_type))
2337
0
    {
2338
0
      *local_tlsdesc_gotent = htab->elf.sgotplt->size
2339
0
        - elf_x86_compute_jump_table_size (htab);
2340
0
      htab->elf.sgotplt->size += 2 * htab->got_entry_size;
2341
0
      *local_got = (bfd_vma) -2;
2342
0
    }
2343
0
        if (! GOT_TLS_GDESC_P (*local_tls_type)
2344
0
      || GOT_TLS_GD_P (*local_tls_type))
2345
0
    {
2346
0
      *local_got = s->size;
2347
0
      s->size += htab->got_entry_size;
2348
0
      if (GOT_TLS_GD_P (*local_tls_type)
2349
0
          || *local_tls_type == GOT_TLS_IE_BOTH)
2350
0
        s->size += htab->got_entry_size;
2351
0
    }
2352
0
        if ((bfd_link_pic (info) && *local_tls_type != GOT_ABS)
2353
0
      || GOT_TLS_GD_ANY_P (*local_tls_type)
2354
0
      || (*local_tls_type & GOT_TLS_IE))
2355
0
    {
2356
0
      if (*local_tls_type == GOT_TLS_IE_BOTH)
2357
0
        srel->size += 2 * htab->sizeof_reloc;
2358
0
      else if (GOT_TLS_GD_P (*local_tls_type)
2359
0
         || ! GOT_TLS_GDESC_P (*local_tls_type))
2360
0
        srel->size += htab->sizeof_reloc;
2361
0
      if (GOT_TLS_GDESC_P (*local_tls_type))
2362
0
        {
2363
0
          htab->elf.srelplt->size += htab->sizeof_reloc;
2364
0
          if (bed->target_id == X86_64_ELF_DATA)
2365
0
      htab->elf.tlsdesc_plt = (bfd_vma) -1;
2366
0
        }
2367
0
    }
2368
0
      }
2369
0
    else
2370
0
      *local_got = (bfd_vma) -1;
2371
0
  }
2372
0
    }
2373
2374
0
  if (htab->tls_ld_or_ldm_got.refcount > 0)
2375
0
    {
2376
      /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
2377
   or R_X86_64_TLSLD relocs.  */
2378
0
      htab->tls_ld_or_ldm_got.offset = htab->elf.sgot->size;
2379
0
      htab->elf.sgot->size += 2 * htab->got_entry_size;
2380
0
      htab->elf.srelgot->size += htab->sizeof_reloc;
2381
0
    }
2382
0
  else
2383
0
    htab->tls_ld_or_ldm_got.offset = -1;
2384
2385
  /* Allocate global sym .plt and .got entries, and space for global
2386
     sym dynamic relocs.  */
2387
0
  elf_link_hash_traverse (&htab->elf, elf_x86_allocate_dynrelocs,
2388
0
        info);
2389
2390
  /* Allocate .plt and .got entries, and space for local symbols.  */
2391
0
  htab_traverse (htab->loc_hash_table, elf_x86_allocate_local_dynreloc,
2392
0
     info);
2393
2394
  /* For every jump slot reserved in the sgotplt, reloc_count is
2395
     incremented.  However, when we reserve space for TLS descriptors,
2396
     it's not incremented, so in order to compute the space reserved
2397
     for them, it suffices to multiply the reloc count by the jump
2398
     slot size.
2399
2400
     PR ld/13302: We start next_irelative_index at the end of .rela.plt
2401
     so that R_{386,X86_64}_IRELATIVE entries come last.  */
2402
0
  if (htab->elf.srelplt)
2403
0
    {
2404
0
      htab->next_tls_desc_index = htab->elf.srelplt->reloc_count;
2405
0
      htab->sgotplt_jump_table_size
2406
0
  = elf_x86_compute_jump_table_size (htab);
2407
0
      htab->next_irelative_index = htab->elf.srelplt->reloc_count - 1;
2408
0
    }
2409
0
  else if (htab->elf.irelplt)
2410
0
    htab->next_irelative_index = htab->elf.irelplt->reloc_count - 1;
2411
2412
0
  if (htab->elf.tlsdesc_plt)
2413
0
    {
2414
      /* NB: tlsdesc_plt is set only for x86-64.  If we're not using
2415
   lazy TLS relocations, don't generate the PLT and GOT entries
2416
   they require.  */
2417
0
      if ((info->flags & DF_BIND_NOW))
2418
0
  htab->elf.tlsdesc_plt = 0;
2419
0
      else
2420
0
  {
2421
0
    htab->elf.tlsdesc_got = htab->elf.sgot->size;
2422
0
    htab->elf.sgot->size += htab->got_entry_size;
2423
    /* Reserve room for the initial entry.
2424
       FIXME: we could probably do away with it in this case.  */
2425
0
    if (htab->elf.splt->size == 0)
2426
0
      htab->elf.splt->size = htab->plt.plt_entry_size;
2427
0
    htab->elf.tlsdesc_plt = htab->elf.splt->size;
2428
0
    htab->elf.splt->size += htab->plt.plt_entry_size;
2429
0
  }
2430
0
    }
2431
2432
0
  if (htab->elf.sgotplt)
2433
0
    {
2434
      /* Don't allocate .got.plt section if there are no GOT nor PLT
2435
   entries and there is no reference to _GLOBAL_OFFSET_TABLE_.  */
2436
0
      if ((htab->elf.hgot == NULL
2437
0
     || !htab->got_referenced)
2438
0
    && (htab->elf.sgotplt->size == bed->got_header_size)
2439
0
    && (htab->elf.splt == NULL
2440
0
        || htab->elf.splt->size == 0)
2441
0
    && (htab->elf.sgot == NULL
2442
0
        || htab->elf.sgot->size == 0)
2443
0
    && (htab->elf.iplt == NULL
2444
0
        || htab->elf.iplt->size == 0)
2445
0
    && (htab->elf.igotplt == NULL
2446
0
        || htab->elf.igotplt->size == 0))
2447
0
  {
2448
0
    htab->elf.sgotplt->size = 0;
2449
    /* Solaris requires to keep _GLOBAL_OFFSET_TABLE_ even if it
2450
       isn't used.  */
2451
0
    if (htab->elf.hgot != NULL
2452
0
        && htab->elf.target_os != is_solaris)
2453
0
      {
2454
        /* Remove the unused _GLOBAL_OFFSET_TABLE_ from symbol
2455
     table. */
2456
0
        htab->elf.hgot->root.type = bfd_link_hash_undefined;
2457
0
        htab->elf.hgot->root.u.undef.abfd
2458
0
    = htab->elf.hgot->root.u.def.section->owner;
2459
0
        htab->elf.hgot->root.linker_def = 0;
2460
0
        htab->elf.hgot->ref_regular = 0;
2461
0
        htab->elf.hgot->def_regular = 0;
2462
0
      }
2463
0
  }
2464
0
    }
2465
2466
0
  if (_bfd_elf_eh_frame_present (info))
2467
0
    {
2468
0
      if (htab->plt_eh_frame != NULL
2469
0
    && htab->elf.splt != NULL
2470
0
    && htab->elf.splt->size != 0
2471
0
    && !bfd_is_abs_section (htab->elf.splt->output_section))
2472
0
  htab->plt_eh_frame->size = htab->plt.eh_frame_plt_size;
2473
2474
0
      if (htab->plt_got_eh_frame != NULL
2475
0
    && htab->plt_got != NULL
2476
0
    && htab->plt_got->size != 0
2477
0
    && !bfd_is_abs_section (htab->plt_got->output_section))
2478
0
  htab->plt_got_eh_frame->size
2479
0
    = htab->non_lazy_plt->eh_frame_plt_size;
2480
2481
      /* Unwind info for the second PLT and .plt.got sections are
2482
   identical.  */
2483
0
      if (htab->plt_second_eh_frame != NULL
2484
0
    && htab->plt_second != NULL
2485
0
    && htab->plt_second->size != 0
2486
0
    && !bfd_is_abs_section (htab->plt_second->output_section))
2487
0
  htab->plt_second_eh_frame->size
2488
0
    = htab->non_lazy_plt->eh_frame_plt_size;
2489
0
    }
2490
2491
  /* No need to size the .sframe section explicitly because the write-out
2492
     mechanism is different.  Simply prep up the FDE/FRE for the
2493
     .plt section.  */
2494
0
  if (_bfd_elf_sframe_present (info))
2495
0
    {
2496
0
      if (htab->plt_sframe != NULL
2497
0
    && htab->elf.splt != NULL
2498
0
    && htab->elf.splt->size != 0
2499
0
    && !bfd_is_abs_section (htab->elf.splt->output_section))
2500
0
  {
2501
0
    _bfd_x86_elf_create_sframe_plt (output_bfd, info, SFRAME_PLT);
2502
    /* FIXME - Dirty Hack.  Set the size to something non-zero for now,
2503
       so that the section does not get stripped out below.  The precise
2504
       size of this section is known only when the contents are
2505
       serialized in _bfd_x86_elf_write_sframe_plt.  */
2506
0
    htab->plt_sframe->size = sizeof (sframe_header) + 1;
2507
0
  }
2508
2509
      /* FIXME - generate for .plt.got ?  */
2510
2511
0
      if (htab->plt_second_sframe != NULL
2512
0
    && htab->plt_second != NULL
2513
0
    && htab->plt_second->size != 0
2514
0
    && !bfd_is_abs_section (htab->plt_second->output_section))
2515
0
  {
2516
    /* SFrame stack trace info for the second PLT.  */
2517
0
    _bfd_x86_elf_create_sframe_plt (output_bfd, info, SFRAME_PLT_SEC);
2518
    /* FIXME - Dirty Hack.  Set the size to something non-zero for now,
2519
       so that the section does not get stripped out below.  The precise
2520
       size of this section is known only when the contents are
2521
       serialized in _bfd_x86_elf_write_sframe_plt.  */
2522
0
    htab->plt_second_sframe->size = sizeof (sframe_header) + 1;
2523
0
  }
2524
0
    }
2525
2526
0
  asection *resolved_plt = NULL;
2527
2528
0
  if (htab->params->mark_plt && htab->elf.dynamic_sections_created)
2529
0
    {
2530
0
      if (htab->plt_second != NULL)
2531
0
  resolved_plt = htab->plt_second;
2532
0
      else
2533
0
  resolved_plt = htab->elf.splt;
2534
2535
0
      if (resolved_plt != NULL && resolved_plt->size == 0)
2536
0
  resolved_plt = NULL;
2537
0
    }
2538
2539
  /* We now have determined the sizes of the various dynamic sections.
2540
     Allocate memory for them.  */
2541
0
  relocs = false;
2542
0
  for (s = dynobj->sections; s != NULL; s = s->next)
2543
0
    {
2544
0
      bool strip_section = true;
2545
2546
0
      if ((s->flags & SEC_LINKER_CREATED) == 0)
2547
0
  continue;
2548
2549
      /* The .relr.dyn section for compact relative relocation will
2550
   be filled later.  */
2551
0
      if (s == htab->elf.srelrdyn)
2552
0
  continue;
2553
2554
0
      if (s == htab->elf.splt
2555
0
    || s == htab->elf.sgot)
2556
0
  {
2557
    /* Strip this section if we don't need it; see the
2558
       comment below.  */
2559
    /* We'd like to strip these sections if they aren't needed, but if
2560
       we've exported dynamic symbols from them we must leave them.
2561
       It's too late to tell BFD to get rid of the symbols.  */
2562
2563
0
    if (htab->elf.hplt != NULL)
2564
0
      strip_section = false;
2565
0
  }
2566
0
      else if (s == htab->elf.sgotplt
2567
0
         || s == htab->elf.iplt
2568
0
         || s == htab->elf.igotplt
2569
0
         || s == htab->plt_second
2570
0
         || s == htab->plt_got
2571
0
         || s == htab->plt_eh_frame
2572
0
         || s == htab->plt_got_eh_frame
2573
0
         || s == htab->plt_second_eh_frame
2574
0
         || s == htab->plt_sframe
2575
0
         || s == htab->plt_second_sframe
2576
0
         || s == htab->elf.sdynbss
2577
0
         || s == htab->elf.sdynrelro)
2578
0
  {
2579
    /* Strip these too.  */
2580
0
  }
2581
0
      else if (htab->is_reloc_section (bfd_section_name (s)))
2582
0
  {
2583
0
    if (s->size != 0
2584
0
        && s != htab->elf.srelplt
2585
0
        && s != htab->srelplt2)
2586
0
      relocs = true;
2587
2588
    /* We use the reloc_count field as a counter if we need
2589
       to copy relocs into the output file.  */
2590
0
    if (s != htab->elf.srelplt)
2591
0
      s->reloc_count = 0;
2592
0
  }
2593
0
      else
2594
0
  {
2595
    /* It's not one of our sections, so don't allocate space.  */
2596
0
    continue;
2597
0
  }
2598
2599
0
      if (s->size == 0)
2600
0
  {
2601
    /* If we don't need this section, strip it from the
2602
       output file.  This is mostly to handle .rel.bss and
2603
       .rel.plt.  We must create both sections in
2604
       create_dynamic_sections, because they must be created
2605
       before the linker maps input sections to output
2606
       sections.  The linker does that before
2607
       adjust_dynamic_symbol is called, and it is that
2608
       function which decides whether anything needs to go
2609
       into these sections.  */
2610
0
    if (strip_section)
2611
0
      s->flags |= SEC_EXCLUDE;
2612
0
    continue;
2613
0
  }
2614
2615
0
      if ((s->flags & SEC_HAS_CONTENTS) == 0)
2616
0
  continue;
2617
2618
      /* Skip allocating contents for .sframe section as it is written
2619
   out differently.  See below.  */
2620
0
      if ((s == htab->plt_sframe) || (s == htab->plt_second_sframe))
2621
0
  continue;
2622
2623
      /* NB: Initially, the iplt section has minimal alignment to
2624
   avoid moving dot of the following section backwards when
2625
   it is empty.  Update its section alignment now since it
2626
   is non-empty.  */
2627
0
      if (s == htab->elf.iplt)
2628
0
  bfd_set_section_alignment (s, htab->plt.iplt_alignment);
2629
2630
      /* Allocate memory for the section contents.  We use bfd_zalloc
2631
   here in case unused entries are not reclaimed before the
2632
   section's contents are written out.  This should not happen,
2633
   but this way if it does, we get a R_386_NONE or R_X86_64_NONE
2634
   reloc instead of garbage.  */
2635
0
      s->contents = (unsigned char *) bfd_zalloc (dynobj, s->size);
2636
0
      if (s->contents == NULL)
2637
0
  return false;
2638
0
    }
2639
2640
0
  if (htab->plt_eh_frame != NULL
2641
0
      && htab->plt_eh_frame->contents != NULL)
2642
0
    {
2643
0
      memcpy (htab->plt_eh_frame->contents,
2644
0
        htab->plt.eh_frame_plt,
2645
0
        htab->plt_eh_frame->size);
2646
0
      bfd_put_32 (dynobj, htab->elf.splt->size,
2647
0
      htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET);
2648
0
    }
2649
2650
0
  if (htab->plt_got_eh_frame != NULL
2651
0
      && htab->plt_got_eh_frame->contents != NULL)
2652
0
    {
2653
0
      memcpy (htab->plt_got_eh_frame->contents,
2654
0
        htab->non_lazy_plt->eh_frame_plt,
2655
0
        htab->plt_got_eh_frame->size);
2656
0
      bfd_put_32 (dynobj, htab->plt_got->size,
2657
0
      (htab->plt_got_eh_frame->contents
2658
0
       + PLT_FDE_LEN_OFFSET));
2659
0
    }
2660
2661
0
  if (htab->plt_second_eh_frame != NULL
2662
0
      && htab->plt_second_eh_frame->contents != NULL)
2663
0
    {
2664
0
      memcpy (htab->plt_second_eh_frame->contents,
2665
0
        htab->non_lazy_plt->eh_frame_plt,
2666
0
        htab->plt_second_eh_frame->size);
2667
0
      bfd_put_32 (dynobj, htab->plt_second->size,
2668
0
      (htab->plt_second_eh_frame->contents
2669
0
       + PLT_FDE_LEN_OFFSET));
2670
0
    }
2671
2672
0
  if (_bfd_elf_sframe_present (info))
2673
0
    {
2674
0
      if (htab->plt_sframe != NULL
2675
0
    && htab->elf.splt != NULL
2676
0
    && htab->elf.splt->size != 0
2677
0
    && htab->plt_sframe->contents == NULL)
2678
0
  _bfd_x86_elf_write_sframe_plt (output_bfd, info, SFRAME_PLT);
2679
2680
0
      if (htab->plt_second_sframe != NULL
2681
0
    && htab->elf.splt != NULL
2682
0
    && htab->elf.splt->size != 0
2683
0
    && htab->plt_second_sframe->contents == NULL)
2684
0
  _bfd_x86_elf_write_sframe_plt (output_bfd, info, SFRAME_PLT_SEC);
2685
0
    }
2686
2687
0
  if (resolved_plt != NULL
2688
0
      && (!_bfd_elf_add_dynamic_entry (info, DT_X86_64_PLT, 0)
2689
0
    || !_bfd_elf_add_dynamic_entry (info, DT_X86_64_PLTSZ, 0)
2690
0
    || !_bfd_elf_add_dynamic_entry (info, DT_X86_64_PLTENT, 0)))
2691
0
    return false;
2692
2693
0
  return _bfd_elf_maybe_vxworks_add_dynamic_tags (output_bfd, info,
2694
0
              relocs);
2695
0
}
2696
2697
/* Finish up the x86 dynamic sections.  */
2698
2699
struct elf_x86_link_hash_table *
2700
_bfd_x86_elf_finish_dynamic_sections (bfd *output_bfd,
2701
              struct bfd_link_info *info)
2702
0
{
2703
0
  struct elf_x86_link_hash_table *htab;
2704
0
  const struct elf_backend_data *bed;
2705
0
  bfd *dynobj;
2706
0
  asection *sdyn;
2707
0
  bfd_byte *dyncon, *dynconend;
2708
0
  bfd_size_type sizeof_dyn;
2709
2710
0
  bed = get_elf_backend_data (output_bfd);
2711
0
  htab = elf_x86_hash_table (info, bed->target_id);
2712
0
  if (htab == NULL)
2713
0
    return htab;
2714
2715
0
  dynobj = htab->elf.dynobj;
2716
0
  sdyn = htab->elf.dynamic;
2717
2718
  /* GOT is always created in setup_gnu_properties.  But it may not be
2719
     needed.  .got.plt section may be needed for static IFUNC.  */
2720
0
  if (htab->elf.sgotplt && htab->elf.sgotplt->size > 0)
2721
0
    {
2722
0
      bfd_vma dynamic_addr;
2723
2724
0
      if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
2725
0
  {
2726
0
    _bfd_error_handler
2727
0
      (_("discarded output section: `%pA'"), htab->elf.sgotplt);
2728
0
    return NULL;
2729
0
  }
2730
2731
0
      elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize
2732
0
  = htab->got_entry_size;
2733
2734
0
      dynamic_addr = (sdyn == NULL
2735
0
          ? (bfd_vma) 0
2736
0
          : sdyn->output_section->vma + sdyn->output_offset);
2737
2738
      /* Set the first entry in the global offset table to the address
2739
   of the dynamic section.  Write GOT[1] and GOT[2], needed for
2740
   the dynamic linker.  */
2741
0
      if (htab->got_entry_size == 8)
2742
0
  {
2743
0
    bfd_put_64 (output_bfd, dynamic_addr,
2744
0
          htab->elf.sgotplt->contents);
2745
0
    bfd_put_64 (output_bfd, (bfd_vma) 0,
2746
0
          htab->elf.sgotplt->contents + 8);
2747
0
    bfd_put_64 (output_bfd, (bfd_vma) 0,
2748
0
          htab->elf.sgotplt->contents + 8*2);
2749
0
  }
2750
0
      else
2751
0
  {
2752
0
    bfd_put_32 (output_bfd, dynamic_addr,
2753
0
          htab->elf.sgotplt->contents);
2754
0
    bfd_put_32 (output_bfd, 0,
2755
0
          htab->elf.sgotplt->contents + 4);
2756
0
    bfd_put_32 (output_bfd, 0,
2757
0
          htab->elf.sgotplt->contents + 4*2);
2758
0
  }
2759
0
    }
2760
2761
0
  if (!htab->elf.dynamic_sections_created)
2762
0
    return htab;
2763
2764
0
  if (sdyn == NULL || htab->elf.sgot == NULL)
2765
0
    abort ();
2766
2767
0
  asection *resolved_plt;
2768
0
  if (htab->plt_second != NULL)
2769
0
    resolved_plt = htab->plt_second;
2770
0
  else
2771
0
    resolved_plt = htab->elf.splt;
2772
2773
0
  sizeof_dyn = bed->s->sizeof_dyn;
2774
0
  dyncon = sdyn->contents;
2775
0
  dynconend = sdyn->contents + sdyn->size;
2776
0
  for (; dyncon < dynconend; dyncon += sizeof_dyn)
2777
0
    {
2778
0
      Elf_Internal_Dyn dyn;
2779
0
      asection *s;
2780
2781
0
      (*bed->s->swap_dyn_in) (dynobj, dyncon, &dyn);
2782
2783
0
      switch (dyn.d_tag)
2784
0
  {
2785
0
  default:
2786
0
    if (htab->elf.target_os == is_vxworks
2787
0
        && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
2788
0
      break;
2789
0
    continue;
2790
2791
0
  case DT_PLTGOT:
2792
0
    s = htab->elf.sgotplt;
2793
0
    dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
2794
0
    break;
2795
2796
0
  case DT_JMPREL:
2797
0
    s = htab->elf.srelplt;
2798
0
    dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
2799
0
    break;
2800
2801
0
  case DT_PLTRELSZ:
2802
0
    s = htab->elf.srelplt;
2803
0
    dyn.d_un.d_val = s->size;
2804
0
    break;
2805
2806
0
  case DT_TLSDESC_PLT:
2807
0
    s = htab->elf.splt;
2808
0
    dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
2809
0
      + htab->elf.tlsdesc_plt;
2810
0
    break;
2811
2812
0
  case DT_TLSDESC_GOT:
2813
0
    s = htab->elf.sgot;
2814
0
    dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
2815
0
      + htab->elf.tlsdesc_got;
2816
0
    break;
2817
2818
0
  case DT_X86_64_PLT:
2819
0
    s = resolved_plt->output_section;
2820
0
    dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
2821
0
    break;
2822
2823
0
  case DT_X86_64_PLTSZ:
2824
0
    dyn.d_un.d_val = resolved_plt->size;
2825
0
    break;
2826
2827
0
  case DT_X86_64_PLTENT:
2828
0
    dyn.d_un.d_ptr = htab->plt.plt_entry_size;
2829
0
    break;
2830
0
  }
2831
2832
0
      (*bed->s->swap_dyn_out) (output_bfd, &dyn, dyncon);
2833
0
    }
2834
2835
0
  if (htab->plt_got != NULL && htab->plt_got->size > 0)
2836
0
    elf_section_data (htab->plt_got->output_section)
2837
0
      ->this_hdr.sh_entsize = htab->non_lazy_plt->plt_entry_size;
2838
2839
0
  if (htab->plt_second != NULL && htab->plt_second->size > 0)
2840
0
    elf_section_data (htab->plt_second->output_section)
2841
0
      ->this_hdr.sh_entsize = htab->non_lazy_plt->plt_entry_size;
2842
2843
  /* Adjust .eh_frame for .plt section.  */
2844
0
  if (htab->plt_eh_frame != NULL
2845
0
      && htab->plt_eh_frame->contents != NULL)
2846
0
    {
2847
0
      if (htab->elf.splt != NULL
2848
0
    && htab->elf.splt->size != 0
2849
0
    && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
2850
0
    && htab->elf.splt->output_section != NULL
2851
0
    && htab->plt_eh_frame->output_section != NULL)
2852
0
  {
2853
0
    bfd_vma plt_start = htab->elf.splt->output_section->vma;
2854
0
    bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
2855
0
           + htab->plt_eh_frame->output_offset
2856
0
           + PLT_FDE_START_OFFSET;
2857
0
    bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
2858
0
           htab->plt_eh_frame->contents
2859
0
           + PLT_FDE_START_OFFSET);
2860
0
  }
2861
2862
0
      if (htab->plt_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME)
2863
0
  {
2864
0
    if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
2865
0
             htab->plt_eh_frame,
2866
0
             htab->plt_eh_frame->contents))
2867
0
      return NULL;
2868
0
  }
2869
0
    }
2870
2871
  /* Adjust .eh_frame for .plt.got section.  */
2872
0
  if (htab->plt_got_eh_frame != NULL
2873
0
      && htab->plt_got_eh_frame->contents != NULL)
2874
0
    {
2875
0
      if (htab->plt_got != NULL
2876
0
    && htab->plt_got->size != 0
2877
0
    && (htab->plt_got->flags & SEC_EXCLUDE) == 0
2878
0
    && htab->plt_got->output_section != NULL
2879
0
    && htab->plt_got_eh_frame->output_section != NULL)
2880
0
  {
2881
0
    bfd_vma plt_start = htab->plt_got->output_section->vma;
2882
0
    bfd_vma eh_frame_start = htab->plt_got_eh_frame->output_section->vma
2883
0
           + htab->plt_got_eh_frame->output_offset
2884
0
           + PLT_FDE_START_OFFSET;
2885
0
    bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
2886
0
           htab->plt_got_eh_frame->contents
2887
0
           + PLT_FDE_START_OFFSET);
2888
0
  }
2889
0
      if (htab->plt_got_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME)
2890
0
  {
2891
0
    if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
2892
0
             htab->plt_got_eh_frame,
2893
0
             htab->plt_got_eh_frame->contents))
2894
0
      return NULL;
2895
0
  }
2896
0
    }
2897
2898
  /* Adjust .eh_frame for the second PLT section.  */
2899
0
  if (htab->plt_second_eh_frame != NULL
2900
0
      && htab->plt_second_eh_frame->contents != NULL)
2901
0
    {
2902
0
      if (htab->plt_second != NULL
2903
0
    && htab->plt_second->size != 0
2904
0
    && (htab->plt_second->flags & SEC_EXCLUDE) == 0
2905
0
    && htab->plt_second->output_section != NULL
2906
0
    && htab->plt_second_eh_frame->output_section != NULL)
2907
0
  {
2908
0
    bfd_vma plt_start = htab->plt_second->output_section->vma;
2909
0
    bfd_vma eh_frame_start
2910
0
      = (htab->plt_second_eh_frame->output_section->vma
2911
0
         + htab->plt_second_eh_frame->output_offset
2912
0
         + PLT_FDE_START_OFFSET);
2913
0
    bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
2914
0
           htab->plt_second_eh_frame->contents
2915
0
           + PLT_FDE_START_OFFSET);
2916
0
  }
2917
0
      if (htab->plt_second_eh_frame->sec_info_type
2918
0
    == SEC_INFO_TYPE_EH_FRAME)
2919
0
  {
2920
0
    if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
2921
0
             htab->plt_second_eh_frame,
2922
0
             htab->plt_second_eh_frame->contents))
2923
0
      return NULL;
2924
0
  }
2925
0
    }
2926
2927
  /* Make any adjustment if necessary and merge .sframe section to
2928
     create the final .sframe section for output_bfd.  */
2929
0
  if (htab->plt_sframe != NULL
2930
0
      && htab->plt_sframe->contents != NULL)
2931
0
    {
2932
0
      if (htab->elf.splt != NULL
2933
0
    && htab->elf.splt->size != 0
2934
0
    && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
2935
0
    && htab->elf.splt->output_section != NULL
2936
0
    && htab->plt_sframe->output_section != NULL)
2937
0
  {
2938
0
    bfd_vma plt_start = htab->elf.splt->output_section->vma;
2939
0
    bfd_vma sframe_start = htab->plt_sframe->output_section->vma
2940
0
           + htab->plt_sframe->output_offset
2941
0
           + PLT_SFRAME_FDE_START_OFFSET;
2942
#if 0 /* FIXME Testing only. Remove before review.  */
2943
    bfd_vma test_value = (plt_start - sframe_start)
2944
      + htab->plt_sframe->output_section->vma
2945
      + htab->plt_sframe->output_offset
2946
      + PLT_SFRAME_FDE_START_OFFSET;
2947
    bfd_put_signed_32 (dynobj, test_value,
2948
#endif
2949
0
    bfd_put_signed_32 (dynobj, plt_start - sframe_start,
2950
0
           htab->plt_sframe->contents
2951
0
           + PLT_SFRAME_FDE_START_OFFSET);
2952
0
  }
2953
0
      if (htab->plt_sframe->sec_info_type == SEC_INFO_TYPE_SFRAME)
2954
0
  {
2955
0
    if (! _bfd_elf_merge_section_sframe (output_bfd, info,
2956
0
                 htab->plt_sframe,
2957
0
                 htab->plt_sframe->contents))
2958
0
      return NULL;
2959
0
  }
2960
0
    }
2961
2962
0
  if (htab->plt_second_sframe != NULL
2963
0
      && htab->plt_second_sframe->contents != NULL)
2964
0
    {
2965
0
      if (htab->plt_second != NULL
2966
0
    && htab->plt_second->size != 0
2967
0
    && (htab->plt_second->flags & SEC_EXCLUDE) == 0
2968
0
    && htab->plt_second->output_section != NULL
2969
0
    && htab->plt_second_sframe->output_section != NULL)
2970
0
  {
2971
0
    bfd_vma plt_start = htab->plt_second->output_section->vma;
2972
0
    bfd_vma sframe_start
2973
0
      = (htab->plt_second_sframe->output_section->vma
2974
0
         + htab->plt_second_sframe->output_offset
2975
0
         + PLT_SFRAME_FDE_START_OFFSET);
2976
#if 0 /* FIXME Testing only. Remove before review.  */
2977
    bfd_vma test_value = (plt_start - sframe_start)
2978
      + htab->plt_second_sframe->output_section->vma
2979
      + htab->plt_second_sframe->output_offset
2980
      + PLT_SFRAME_FDE_START_OFFSET;
2981
    bfd_put_signed_32 (dynobj, test_value,
2982
#endif
2983
0
    bfd_put_signed_32 (dynobj, plt_start - sframe_start,
2984
0
           htab->plt_second_sframe->contents
2985
0
           + PLT_SFRAME_FDE_START_OFFSET);
2986
0
  }
2987
0
      if (htab->plt_second_sframe->sec_info_type == SEC_INFO_TYPE_SFRAME)
2988
0
  {
2989
0
    if (! _bfd_elf_merge_section_sframe (output_bfd, info,
2990
0
                 htab->plt_second_sframe,
2991
0
                 htab->plt_second_sframe->contents))
2992
0
      return NULL;
2993
0
  }
2994
0
    }
2995
0
  if (htab->elf.sgot && htab->elf.sgot->size > 0)
2996
0
    elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize
2997
0
      = htab->got_entry_size;
2998
2999
0
  return htab;
3000
0
}
3001
3002
3003
bool
3004
_bfd_x86_elf_early_size_sections (bfd *output_bfd,
3005
          struct bfd_link_info *info)
3006
0
{
3007
0
  asection *tls_sec = elf_hash_table (info)->tls_sec;
3008
3009
0
  if (tls_sec && !bfd_link_relocatable (info))
3010
0
    {
3011
0
      struct elf_link_hash_entry *tlsbase;
3012
3013
0
      tlsbase = elf_link_hash_lookup (elf_hash_table (info),
3014
0
              "_TLS_MODULE_BASE_",
3015
0
              false, false, false);
3016
3017
0
      if (tlsbase && tlsbase->type == STT_TLS)
3018
0
  {
3019
0
    struct elf_x86_link_hash_table *htab;
3020
0
    struct bfd_link_hash_entry *bh = NULL;
3021
0
    const struct elf_backend_data *bed
3022
0
      = get_elf_backend_data (output_bfd);
3023
3024
0
    htab = elf_x86_hash_table (info, bed->target_id);
3025
0
    if (htab == NULL)
3026
0
      return false;
3027
3028
0
    if (!(_bfd_generic_link_add_one_symbol
3029
0
    (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
3030
0
     tls_sec, 0, NULL, false,
3031
0
     bed->collect, &bh)))
3032
0
      return false;
3033
3034
0
    htab->tls_module_base = bh;
3035
3036
0
    tlsbase = (struct elf_link_hash_entry *)bh;
3037
0
    tlsbase->def_regular = 1;
3038
0
    tlsbase->other = STV_HIDDEN;
3039
0
    tlsbase->root.linker_def = 1;
3040
0
    (*bed->elf_backend_hide_symbol) (info, tlsbase, true);
3041
0
  }
3042
0
    }
3043
3044
0
  return true;
3045
0
}
3046
3047
void
3048
_bfd_x86_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
3049
             unsigned int st_other,
3050
             bool definition,
3051
             bool dynamic ATTRIBUTE_UNUSED)
3052
0
{
3053
0
  if (definition)
3054
0
    {
3055
0
      struct elf_x86_link_hash_entry *eh
3056
0
  = (struct elf_x86_link_hash_entry *) h;
3057
0
      eh->def_protected = ELF_ST_VISIBILITY (st_other) == STV_PROTECTED;
3058
0
    }
3059
0
}
3060
3061
/* Copy the extra info we tack onto an elf_link_hash_entry.  */
3062
3063
void
3064
_bfd_x86_elf_copy_indirect_symbol (struct bfd_link_info *info,
3065
           struct elf_link_hash_entry *dir,
3066
           struct elf_link_hash_entry *ind)
3067
0
{
3068
0
  struct elf_x86_link_hash_entry *edir, *eind;
3069
3070
0
  edir = (struct elf_x86_link_hash_entry *) dir;
3071
0
  eind = (struct elf_x86_link_hash_entry *) ind;
3072
3073
0
  if (ind->root.type == bfd_link_hash_indirect
3074
0
      && dir->got.refcount <= 0)
3075
0
    {
3076
0
      edir->tls_type = eind->tls_type;
3077
0
      eind->tls_type = GOT_UNKNOWN;
3078
0
    }
3079
3080
  /* Copy gotoff_ref so that elf_i386_adjust_dynamic_symbol will
3081
     generate a R_386_COPY reloc.  */
3082
0
  edir->gotoff_ref |= eind->gotoff_ref;
3083
3084
0
  edir->zero_undefweak |= eind->zero_undefweak;
3085
3086
0
  if (ELIMINATE_COPY_RELOCS
3087
0
      && ind->root.type != bfd_link_hash_indirect
3088
0
      && dir->dynamic_adjusted)
3089
0
    {
3090
      /* If called to transfer flags for a weakdef during processing
3091
   of elf_adjust_dynamic_symbol, don't copy non_got_ref.
3092
   We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
3093
0
      if (dir->versioned != versioned_hidden)
3094
0
  dir->ref_dynamic |= ind->ref_dynamic;
3095
0
      dir->ref_regular |= ind->ref_regular;
3096
0
      dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
3097
0
      dir->needs_plt |= ind->needs_plt;
3098
0
      dir->pointer_equality_needed |= ind->pointer_equality_needed;
3099
0
    }
3100
0
  else
3101
0
    _bfd_elf_link_hash_copy_indirect (info, dir, ind);
3102
0
}
3103
3104
/* Remove undefined weak symbol from the dynamic symbol table if it
3105
   is resolved to 0.   */
3106
3107
bool
3108
_bfd_x86_elf_fixup_symbol (struct bfd_link_info *info,
3109
         struct elf_link_hash_entry *h)
3110
0
{
3111
0
  if (h->dynindx != -1
3112
0
      && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, elf_x86_hash_entry (h)))
3113
0
    {
3114
0
      h->dynindx = -1;
3115
0
      _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
3116
0
            h->dynstr_index);
3117
0
    }
3118
0
  return true;
3119
0
}
3120
3121
/* Change the STT_GNU_IFUNC symbol defined in position-dependent
3122
   executable into the normal function symbol and set its address
3123
   to its PLT entry, which should be resolved by R_*_IRELATIVE at
3124
   run-time.  */
3125
3126
void
3127
_bfd_x86_elf_link_fixup_ifunc_symbol (struct bfd_link_info *info,
3128
              struct elf_x86_link_hash_table *htab,
3129
              struct elf_link_hash_entry *h,
3130
              Elf_Internal_Sym *sym)
3131
0
{
3132
0
  if (bfd_link_pde (info)
3133
0
      && h->def_regular
3134
0
      && h->dynindx != -1
3135
0
      && h->plt.offset != (bfd_vma) -1
3136
0
      && h->type == STT_GNU_IFUNC)
3137
0
    {
3138
0
      asection *plt_s;
3139
0
      bfd_vma plt_offset;
3140
0
      bfd *output_bfd = info->output_bfd;
3141
3142
0
      if (htab->plt_second)
3143
0
  {
3144
0
    struct elf_x86_link_hash_entry *eh
3145
0
      = (struct elf_x86_link_hash_entry *) h;
3146
3147
0
    plt_s = htab->plt_second;
3148
0
    plt_offset = eh->plt_second.offset;
3149
0
  }
3150
0
      else
3151
0
  {
3152
0
    plt_s = htab->elf.splt;
3153
0
    plt_offset = h->plt.offset;
3154
0
  }
3155
3156
0
      sym->st_size = 0;
3157
0
      sym->st_info = ELF_ST_INFO (ELF_ST_BIND (sym->st_info), STT_FUNC);
3158
0
      sym->st_shndx
3159
0
  = _bfd_elf_section_from_bfd_section (output_bfd,
3160
0
               plt_s->output_section);
3161
0
      sym->st_value = (plt_s->output_section->vma
3162
0
           + plt_s->output_offset + plt_offset);
3163
0
    }
3164
0
}
3165
3166
/* Report relative relocation.  */
3167
3168
void
3169
_bfd_x86_elf_link_report_relative_reloc
3170
  (struct bfd_link_info *info, asection *asect,
3171
   struct elf_link_hash_entry *h, Elf_Internal_Sym *sym,
3172
   const char *reloc_name, const void *reloc)
3173
0
{
3174
0
  const char *name;
3175
0
  bfd *abfd;
3176
0
  const Elf_Internal_Rela *rel = (const Elf_Internal_Rela *) reloc;
3177
3178
  /* Use the output BFD for linker created sections.  */
3179
0
  if ((asect->flags & SEC_LINKER_CREATED) != 0)
3180
0
    abfd = info->output_bfd;
3181
0
  else
3182
0
    abfd = asect->owner;
3183
3184
0
  if (h != NULL && h->root.root.string != NULL)
3185
0
    name = h->root.root.string;
3186
0
  else
3187
0
    name = bfd_elf_sym_name (abfd, &elf_symtab_hdr (abfd), sym, NULL);
3188
3189
0
  if (asect->use_rela_p)
3190
0
    info->callbacks->einfo
3191
0
      (_("%pB: %s (offset: 0x%v, info: 0x%v, addend: 0x%v) against "
3192
0
   "'%s' " "for section '%pA' in %pB\n"),
3193
0
       info->output_bfd, reloc_name, rel->r_offset, rel->r_info,
3194
0
       rel->r_addend, name, asect, abfd);
3195
0
  else
3196
0
    info->callbacks->einfo
3197
0
      (_("%pB: %s (offset: 0x%v, info: 0x%v) against '%s' for section "
3198
0
   "'%pA' in %pB\n"),
3199
0
       info->output_bfd, reloc_name, rel->r_offset, rel->r_info, name,
3200
0
       asect, abfd);
3201
0
}
3202
3203
/* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
3204
3205
bool
3206
_bfd_x86_elf_hash_symbol (struct elf_link_hash_entry *h)
3207
0
{
3208
0
  if (h->plt.offset != (bfd_vma) -1
3209
0
      && !h->def_regular
3210
0
      && !h->pointer_equality_needed)
3211
0
    return false;
3212
3213
0
  return _bfd_elf_hash_symbol (h);
3214
0
}
3215
3216
/* Adjust a symbol defined by a dynamic object and referenced by a
3217
   regular object.  The current definition is in some section of the
3218
   dynamic object, but we're not including those sections.  We have to
3219
   change the definition to something the rest of the link can
3220
   understand.  */
3221
3222
bool
3223
_bfd_x86_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
3224
            struct elf_link_hash_entry *h)
3225
0
{
3226
0
  struct elf_x86_link_hash_table *htab;
3227
0
  asection *s, *srel;
3228
0
  struct elf_x86_link_hash_entry *eh;
3229
0
  struct elf_dyn_relocs *p;
3230
0
  const struct elf_backend_data *bed
3231
0
    = get_elf_backend_data (info->output_bfd);
3232
3233
0
  eh = (struct elf_x86_link_hash_entry *) h;
3234
3235
  /* Clear GNU_PROPERTY_1_NEEDED_INDIRECT_EXTERN_ACCESS if it is turned
3236
     on by an input relocatable file and there is a non-GOT/non-PLT
3237
     reference from another relocatable file without it.
3238
     NB: There can be non-GOT reference in data sections in input with
3239
     GNU_PROPERTY_1_NEEDED_INDIRECT_EXTERN_ACCESS.  */
3240
0
  if (eh->non_got_ref_without_indirect_extern_access
3241
0
      && info->indirect_extern_access == 1
3242
0
      && bfd_link_executable (info))
3243
0
    {
3244
0
      unsigned int needed_1;
3245
0
      info->indirect_extern_access = 0;
3246
      /* Turn off nocopyreloc if implied by indirect_extern_access.  */
3247
0
      if (info->nocopyreloc == 2)
3248
0
  info->nocopyreloc = 0;
3249
0
      needed_1 = bfd_h_get_32 (info->output_bfd, info->needed_1_p);
3250
0
      needed_1 &= ~GNU_PROPERTY_1_NEEDED_INDIRECT_EXTERN_ACCESS;
3251
0
      bfd_h_put_32 (info->output_bfd, needed_1, info->needed_1_p);
3252
0
    }
3253
3254
  /* STT_GNU_IFUNC symbol must go through PLT. */
3255
0
  if (h->type == STT_GNU_IFUNC)
3256
0
    {
3257
      /* All local STT_GNU_IFUNC references must be treate as local
3258
   calls via local PLT.  */
3259
0
      if (h->ref_regular
3260
0
    && SYMBOL_CALLS_LOCAL (info, h))
3261
0
  {
3262
0
    bfd_size_type pc_count = 0, count = 0;
3263
0
    struct elf_dyn_relocs **pp;
3264
3265
0
    eh = (struct elf_x86_link_hash_entry *) h;
3266
0
    for (pp = &h->dyn_relocs; (p = *pp) != NULL; )
3267
0
      {
3268
0
        pc_count += p->pc_count;
3269
0
        p->count -= p->pc_count;
3270
0
        p->pc_count = 0;
3271
0
        count += p->count;
3272
0
        if (p->count == 0)
3273
0
    *pp = p->next;
3274
0
        else
3275
0
    pp = &p->next;
3276
0
      }
3277
3278
0
    if (pc_count || count)
3279
0
      {
3280
0
        h->non_got_ref = 1;
3281
0
        if (pc_count)
3282
0
    {
3283
      /* Increment PLT reference count only for PC-relative
3284
         references.  */
3285
0
      h->needs_plt = 1;
3286
0
      if (h->plt.refcount <= 0)
3287
0
        h->plt.refcount = 1;
3288
0
      else
3289
0
        h->plt.refcount += 1;
3290
0
    }
3291
0
      }
3292
3293
    /* GOTOFF relocation needs PLT.  */
3294
0
    if (eh->gotoff_ref)
3295
0
      h->plt.refcount = 1;
3296
0
  }
3297
3298
0
      if (h->plt.refcount <= 0)
3299
0
  {
3300
0
    h->plt.offset = (bfd_vma) -1;
3301
0
    h->needs_plt = 0;
3302
0
  }
3303
0
      return true;
3304
0
    }
3305
3306
  /* If this is a function, put it in the procedure linkage table.  We
3307
     will fill in the contents of the procedure linkage table later,
3308
     when we know the address of the .got section.  */
3309
0
  if (h->type == STT_FUNC
3310
0
      || h->needs_plt)
3311
0
    {
3312
0
      if (h->plt.refcount <= 0
3313
0
    || SYMBOL_CALLS_LOCAL (info, h)
3314
0
    || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
3315
0
        && h->root.type == bfd_link_hash_undefweak))
3316
0
  {
3317
    /* This case can occur if we saw a PLT32 reloc in an input
3318
       file, but the symbol was never referred to by a dynamic
3319
       object, or if all references were garbage collected.  In
3320
       such a case, we don't actually need to build a procedure
3321
       linkage table, and we can just do a PC32 reloc instead.  */
3322
0
    h->plt.offset = (bfd_vma) -1;
3323
0
    h->needs_plt = 0;
3324
0
  }
3325
3326
0
      return true;
3327
0
    }
3328
0
  else
3329
    /* It's possible that we incorrectly decided a .plt reloc was needed
3330
     * for an R_386_PC32/R_X86_64_PC32 reloc to a non-function sym in
3331
       check_relocs.  We can't decide accurately between function and
3332
       non-function syms in check-relocs;  Objects loaded later in
3333
       the link may change h->type.  So fix it now.  */
3334
0
    h->plt.offset = (bfd_vma) -1;
3335
3336
  /* If this is a weak symbol, and there is a real definition, the
3337
     processor independent code will have arranged for us to see the
3338
     real definition first, and we can just use the same value.  */
3339
0
  if (h->is_weakalias)
3340
0
    {
3341
0
      struct elf_link_hash_entry *def = weakdef (h);
3342
0
      BFD_ASSERT (def->root.type == bfd_link_hash_defined);
3343
0
      h->root.u.def.section = def->root.u.def.section;
3344
0
      h->root.u.def.value = def->root.u.def.value;
3345
0
      if (ELIMINATE_COPY_RELOCS
3346
0
    || info->nocopyreloc
3347
0
    || SYMBOL_NO_COPYRELOC (info, eh))
3348
0
  {
3349
    /* NB: needs_copy is always 0 for i386.  */
3350
0
    h->non_got_ref = def->non_got_ref;
3351
0
    eh->needs_copy = def->needs_copy;
3352
0
  }
3353
0
      return true;
3354
0
    }
3355
3356
  /* This is a reference to a symbol defined by a dynamic object which
3357
     is not a function.  */
3358
3359
  /* If we are creating a shared library, we must presume that the
3360
     only references to the symbol are via the global offset table.
3361
     For such cases we need not do anything here; the relocations will
3362
     be handled correctly by relocate_section.  */
3363
0
  if (!bfd_link_executable (info))
3364
0
    return true;
3365
3366
  /* If there are no references to this symbol that do not use the
3367
     GOT nor R_386_GOTOFF relocation, we don't need to generate a copy
3368
     reloc.  NB: gotoff_ref is always 0 for x86-64.  */
3369
0
  if (!h->non_got_ref && !eh->gotoff_ref)
3370
0
    return true;
3371
3372
  /* If -z nocopyreloc was given, we won't generate them either.  */
3373
0
  if (info->nocopyreloc || SYMBOL_NO_COPYRELOC (info, eh))
3374
0
    {
3375
0
      h->non_got_ref = 0;
3376
0
      return true;
3377
0
    }
3378
3379
0
  htab = elf_x86_hash_table (info, bed->target_id);
3380
0
  if (htab == NULL)
3381
0
    return false;
3382
3383
  /* If there aren't any dynamic relocs in read-only sections nor
3384
     R_386_GOTOFF relocation, then we can keep the dynamic relocs and
3385
     avoid the copy reloc.  This doesn't work on VxWorks, where we can
3386
     not have dynamic relocations (other than copy and jump slot
3387
     relocations) in an executable.  */
3388
0
  if (ELIMINATE_COPY_RELOCS
3389
0
      && (bed->target_id == X86_64_ELF_DATA
3390
0
    || (!eh->gotoff_ref
3391
0
        && htab->elf.target_os != is_vxworks)))
3392
0
    {
3393
      /* If we don't find any dynamic relocs in read-only sections,
3394
   then we'll be keeping the dynamic relocs and avoiding the copy
3395
   reloc.  */
3396
0
      if (!_bfd_elf_readonly_dynrelocs (h))
3397
0
  {
3398
0
    h->non_got_ref = 0;
3399
0
    return true;
3400
0
  }
3401
0
    }
3402
3403
  /* We must allocate the symbol in our .dynbss section, which will
3404
     become part of the .bss section of the executable.  There will be
3405
     an entry for this symbol in the .dynsym section.  The dynamic
3406
     object will contain position independent code, so all references
3407
     from the dynamic object to this symbol will go through the global
3408
     offset table.  The dynamic linker will use the .dynsym entry to
3409
     determine the address it must put in the global offset table, so
3410
     both the dynamic object and the regular object will refer to the
3411
     same memory location for the variable.  */
3412
3413
  /* We must generate a R_386_COPY/R_X86_64_COPY reloc to tell the
3414
     dynamic linker to copy the initial value out of the dynamic object
3415
     and into the runtime process image.  */
3416
0
  if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
3417
0
    {
3418
0
      s = htab->elf.sdynrelro;
3419
0
      srel = htab->elf.sreldynrelro;
3420
0
    }
3421
0
  else
3422
0
    {
3423
0
      s = htab->elf.sdynbss;
3424
0
      srel = htab->elf.srelbss;
3425
0
    }
3426
0
  if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
3427
0
    {
3428
0
      if (eh->def_protected && bfd_link_executable (info))
3429
0
  for (p = h->dyn_relocs; p != NULL; p = p->next)
3430
0
    {
3431
      /* Disallow copy relocation against non-copyable protected
3432
         symbol.  */
3433
0
      s = p->sec->output_section;
3434
0
      if (s != NULL && (s->flags & SEC_READONLY) != 0)
3435
0
        {
3436
0
    info->callbacks->einfo
3437
      /* xgettext:c-format */
3438
0
      (_("%F%P: %pB: copy relocation against non-copyable "
3439
0
         "protected symbol `%s' in %pB\n"),
3440
0
       p->sec->owner, h->root.root.string,
3441
0
       h->root.u.def.section->owner);
3442
0
    return false;
3443
0
        }
3444
0
    }
3445
3446
0
      srel->size += htab->sizeof_reloc;
3447
0
      h->needs_copy = 1;
3448
0
    }
3449
3450
0
  return _bfd_elf_adjust_dynamic_copy (info, h, s);
3451
0
}
3452
3453
void
3454
_bfd_x86_elf_hide_symbol (struct bfd_link_info *info,
3455
        struct elf_link_hash_entry *h,
3456
        bool force_local)
3457
0
{
3458
0
  if (h->root.type == bfd_link_hash_undefweak
3459
0
      && info->nointerp
3460
0
      && bfd_link_pie (info))
3461
0
    {
3462
      /* When there is no dynamic interpreter in PIE, make the undefined
3463
   weak symbol dynamic so that PC relative branch to the undefined
3464
   weak symbol will land to address 0.  */
3465
0
      struct elf_x86_link_hash_entry *eh = elf_x86_hash_entry (h);
3466
0
      if (h->plt.refcount > 0
3467
0
    || eh->plt_got.refcount > 0)
3468
0
  return;
3469
0
    }
3470
3471
0
  _bfd_elf_link_hash_hide_symbol (info, h, force_local);
3472
0
}
3473
3474
/* Return TRUE if a symbol is referenced locally.  It is similar to
3475
   SYMBOL_REFERENCES_LOCAL, but it also checks version script.  It
3476
   works in check_relocs.  */
3477
3478
bool
3479
_bfd_x86_elf_link_symbol_references_local (struct bfd_link_info *info,
3480
             struct elf_link_hash_entry *h)
3481
0
{
3482
0
  struct elf_x86_link_hash_entry *eh = elf_x86_hash_entry (h);
3483
0
  struct elf_x86_link_hash_table *htab
3484
0
    = (struct elf_x86_link_hash_table *) info->hash;
3485
3486
0
  if (eh->local_ref > 1)
3487
0
    return true;
3488
3489
0
  if (eh->local_ref == 1)
3490
0
    return false;
3491
3492
  /* Unversioned symbols defined in regular objects can be forced local
3493
     by linker version script.  A weak undefined symbol is forced local
3494
     if
3495
     1. It has non-default visibility.  Or
3496
     2. When building executable, there is no dynamic linker.  Or
3497
     3. or "-z nodynamic-undefined-weak" is used.
3498
   */
3499
0
  if (_bfd_elf_symbol_refs_local_p (h, info, 1)
3500
0
      || (h->root.type == bfd_link_hash_undefweak
3501
0
    && (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
3502
0
        || (bfd_link_executable (info)
3503
0
      && htab->interp == NULL)
3504
0
        || info->dynamic_undefined_weak == 0))
3505
0
      || ((h->def_regular || ELF_COMMON_DEF_P (h))
3506
0
    && info->version_info != NULL
3507
0
    && _bfd_elf_link_hide_sym_by_version (info, h)))
3508
0
    {
3509
0
      eh->local_ref = 2;
3510
0
      return true;
3511
0
    }
3512
3513
0
  eh->local_ref = 1;
3514
0
  return false;
3515
0
}
3516
3517
/* Return the section that should be marked against GC for a given
3518
   relocation.  */
3519
3520
asection *
3521
_bfd_x86_elf_gc_mark_hook (asection *sec,
3522
         struct bfd_link_info *info,
3523
         Elf_Internal_Rela *rel,
3524
         struct elf_link_hash_entry *h,
3525
         Elf_Internal_Sym *sym)
3526
0
{
3527
  /* Compiler should optimize this out.  */
3528
0
  if (((unsigned int) R_X86_64_GNU_VTINHERIT
3529
0
       != (unsigned int) R_386_GNU_VTINHERIT)
3530
0
      || ((unsigned int) R_X86_64_GNU_VTENTRY
3531
0
    != (unsigned int) R_386_GNU_VTENTRY))
3532
0
    abort ();
3533
3534
0
  if (h != NULL)
3535
0
    switch (ELF32_R_TYPE (rel->r_info))
3536
0
      {
3537
0
      case R_X86_64_GNU_VTINHERIT:
3538
0
      case R_X86_64_GNU_VTENTRY:
3539
0
  return NULL;
3540
0
      }
3541
3542
0
  return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
3543
0
}
3544
3545
static bfd_vma
3546
elf_i386_get_plt_got_vma (struct elf_x86_plt *plt_p ATTRIBUTE_UNUSED,
3547
        bfd_vma off,
3548
        bfd_vma offset ATTRIBUTE_UNUSED,
3549
        bfd_vma got_addr)
3550
5.43k
{
3551
5.43k
  return got_addr + off;
3552
5.43k
}
3553
3554
static bfd_vma
3555
elf_x86_64_get_plt_got_vma (struct elf_x86_plt *plt_p,
3556
          bfd_vma off,
3557
          bfd_vma offset,
3558
          bfd_vma got_addr ATTRIBUTE_UNUSED)
3559
285
{
3560
285
  return plt_p->sec->vma + offset + off + plt_p->plt_got_insn_size;
3561
285
}
3562
3563
static bool
3564
elf_i386_valid_plt_reloc_p (unsigned int type)
3565
5.43k
{
3566
5.43k
  return (type == R_386_JUMP_SLOT
3567
5.43k
    || type == R_386_GLOB_DAT
3568
5.43k
    || type == R_386_IRELATIVE);
3569
5.43k
}
3570
3571
static bool
3572
elf_x86_64_valid_plt_reloc_p (unsigned int type)
3573
283
{
3574
283
  return (type == R_X86_64_JUMP_SLOT
3575
283
    || type == R_X86_64_GLOB_DAT
3576
283
    || type == R_X86_64_IRELATIVE);
3577
283
}
3578
3579
long
3580
_bfd_x86_elf_get_synthetic_symtab (bfd *abfd,
3581
           long count,
3582
           long relsize,
3583
           bfd_vma got_addr,
3584
           struct elf_x86_plt plts[],
3585
           asymbol **dynsyms,
3586
           asymbol **ret)
3587
34
{
3588
34
  long size, i, n, len;
3589
34
  int j;
3590
34
  unsigned int plt_got_offset, plt_entry_size;
3591
34
  asymbol *s;
3592
34
  bfd_byte *plt_contents;
3593
34
  long dynrelcount;
3594
34
  arelent **dynrelbuf, *p;
3595
34
  char *names;
3596
34
  const struct elf_backend_data *bed;
3597
34
  bfd_vma (*get_plt_got_vma) (struct elf_x86_plt *, bfd_vma, bfd_vma,
3598
34
            bfd_vma);
3599
34
  bool (*valid_plt_reloc_p) (unsigned int);
3600
34
  unsigned int jump_slot_reloc;
3601
3602
34
  dynrelbuf = NULL;
3603
34
  if (count == 0)
3604
4
    goto bad_return;
3605
3606
30
  dynrelbuf = (arelent **) bfd_malloc (relsize);
3607
30
  if (dynrelbuf == NULL)
3608
0
    goto bad_return;
3609
3610
30
  dynrelcount = bfd_canonicalize_dynamic_reloc (abfd, dynrelbuf,
3611
30
            dynsyms);
3612
30
  if (dynrelcount <= 0)
3613
0
    goto bad_return;
3614
3615
  /* Sort the relocs by address.  */
3616
30
  qsort (dynrelbuf, dynrelcount, sizeof (arelent *),
3617
30
   _bfd_x86_elf_compare_relocs);
3618
3619
30
  size = count * sizeof (asymbol);
3620
3621
  /* Allocate space for @plt suffixes.  */
3622
30
  n = 0;
3623
16.7k
  for (i = 0; i < dynrelcount; i++)
3624
16.6k
    {
3625
16.6k
      p = dynrelbuf[i];
3626
16.6k
      size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3627
16.6k
      if (p->addend != 0)
3628
860
  size += sizeof ("+0x") - 1 + 8 + 8 * ABI_64_P (abfd);
3629
16.6k
    }
3630
3631
30
  s = *ret = (asymbol *) bfd_zmalloc (size);
3632
30
  if (s == NULL)
3633
0
    goto bad_return;
3634
3635
30
  bed = get_elf_backend_data (abfd);
3636
3637
30
  if (bed->target_id == X86_64_ELF_DATA)
3638
13
    {
3639
13
      get_plt_got_vma = elf_x86_64_get_plt_got_vma;
3640
13
      valid_plt_reloc_p = elf_x86_64_valid_plt_reloc_p;
3641
13
      jump_slot_reloc = R_X86_64_JUMP_SLOT;
3642
13
    }
3643
17
  else
3644
17
    {
3645
17
      get_plt_got_vma = elf_i386_get_plt_got_vma;
3646
17
      valid_plt_reloc_p = elf_i386_valid_plt_reloc_p;
3647
17
      jump_slot_reloc = R_386_JUMP_SLOT;
3648
17
      if (got_addr)
3649
4
  {
3650
    /* Check .got.plt and then .got to get the _GLOBAL_OFFSET_TABLE_
3651
       address.  */
3652
4
    asection *sec = bfd_get_section_by_name (abfd, ".got.plt");
3653
4
    if (sec != NULL)
3654
0
      got_addr = sec->vma;
3655
4
    else
3656
4
      {
3657
4
        sec = bfd_get_section_by_name (abfd, ".got");
3658
4
        if (sec != NULL)
3659
4
    got_addr = sec->vma;
3660
4
      }
3661
3662
4
    if (got_addr == (bfd_vma) -1)
3663
0
      goto bad_return;
3664
4
  }
3665
17
    }
3666
3667
  /* Check for each PLT section.  */
3668
30
  names = (char *) (s + count);
3669
30
  size = 0;
3670
30
  n = 0;
3671
133
  for (j = 0; plts[j].name != NULL; j++)
3672
103
    if ((plt_contents = plts[j].contents) != NULL)
3673
42
      {
3674
42
  long k;
3675
42
  bfd_vma offset;
3676
42
  asection *plt;
3677
42
  struct elf_x86_plt *plt_p = &plts[j];
3678
3679
42
  plt_got_offset = plt_p->plt_got_offset;
3680
42
  plt_entry_size = plt_p->plt_entry_size;
3681
3682
42
  plt = plt_p->sec;
3683
3684
42
  if ((plt_p->type & plt_lazy))
3685
27
    {
3686
      /* Skip PLT0 in lazy PLT.  */
3687
27
      k = 1;
3688
27
      offset = plt_entry_size;
3689
27
    }
3690
15
  else
3691
15
    {
3692
15
      k = 0;
3693
15
      offset = 0;
3694
15
    }
3695
3696
  /* Check each PLT entry against dynamic relocations.  */
3697
5.76k
  for (; k < plt_p->count; k++)
3698
5.72k
    {
3699
5.72k
      int off;
3700
5.72k
      bfd_vma got_vma;
3701
5.72k
      long min, max, mid;
3702
3703
      /* Get the GOT offset for i386 or the PC-relative offset
3704
         for x86-64, a signed 32-bit integer.  */
3705
5.72k
      off = H_GET_32 (abfd, (plt_contents + offset
3706
5.72k
           + plt_got_offset));
3707
5.72k
      got_vma = get_plt_got_vma (plt_p, off, offset, got_addr);
3708
3709
      /* Binary search.  */
3710
5.72k
      p = dynrelbuf[0];
3711
5.72k
      min = 0;
3712
5.72k
      max = dynrelcount;
3713
55.0k
      while ((min + 1) < max)
3714
55.0k
        {
3715
55.0k
    arelent *r;
3716
3717
55.0k
    mid = (min + max) / 2;
3718
55.0k
    r = dynrelbuf[mid];
3719
55.0k
    if (got_vma > r->address)
3720
28.5k
      min = mid;
3721
26.4k
    else if (got_vma < r->address)
3722
20.7k
      max = mid;
3723
5.71k
    else
3724
5.71k
      {
3725
5.71k
        p = r;
3726
5.71k
        break;
3727
5.71k
      }
3728
55.0k
        }
3729
3730
      /* Skip unknown relocation.  PR 17512: file: bc9d6cf5.  */
3731
5.72k
      if (got_vma == p->address
3732
5.72k
    && p->howto != NULL
3733
5.72k
    && valid_plt_reloc_p (p->howto->type))
3734
5.72k
        {
3735
5.72k
    *s = **p->sym_ptr_ptr;
3736
    /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL
3737
       set.  Since we are defining a symbol, ensure one
3738
       of them is set.  */
3739
5.72k
    if ((s->flags & BSF_LOCAL) == 0)
3740
5.72k
      s->flags |= BSF_GLOBAL;
3741
5.72k
    s->flags |= BSF_SYNTHETIC;
3742
    /* This is no longer a section symbol.  */
3743
5.72k
    s->flags &= ~BSF_SECTION_SYM;
3744
5.72k
    s->section = plt;
3745
5.72k
    s->the_bfd = plt->owner;
3746
5.72k
    s->value = offset;
3747
5.72k
    s->udata.p = NULL;
3748
5.72k
    s->name = names;
3749
5.72k
    len = strlen ((*p->sym_ptr_ptr)->name);
3750
5.72k
    memcpy (names, (*p->sym_ptr_ptr)->name, len);
3751
5.72k
    names += len;
3752
    /* There may be JUMP_SLOT and IRELATIVE relocations.
3753
       JUMP_SLOT r_addend should be ignored.  */
3754
5.72k
    if (p->addend != 0 && p->howto->type != jump_slot_reloc)
3755
0
      {
3756
0
        char buf[30], *a;
3757
3758
0
        memcpy (names, "+0x", sizeof ("+0x") - 1);
3759
0
        names += sizeof ("+0x") - 1;
3760
0
        bfd_sprintf_vma (abfd, buf, p->addend);
3761
0
        for (a = buf; *a == '0'; ++a)
3762
0
          ;
3763
0
        size = strlen (a);
3764
0
        memcpy (names, a, size);
3765
0
        names += size;
3766
0
      }
3767
5.72k
    memcpy (names, "@plt", sizeof ("@plt"));
3768
5.72k
    names += sizeof ("@plt");
3769
5.72k
    n++;
3770
5.72k
    s++;
3771
    /* There should be only one entry in PLT for a given
3772
       symbol.  Set howto to NULL after processing a PLT
3773
       entry to guard against corrupted PLT.  */
3774
5.72k
    p->howto = NULL;
3775
5.72k
        }
3776
5.72k
      offset += plt_entry_size;
3777
5.72k
    }
3778
42
      }
3779
3780
  /* PLT entries with R_386_TLS_DESC relocations are skipped.  */
3781
30
  if (n == 0)
3782
0
    {
3783
4
    bad_return:
3784
4
      count = -1;
3785
4
    }
3786
30
  else
3787
30
    count = n;
3788
3789
151
  for (j = 0; plts[j].name != NULL; j++)
3790
117
    _bfd_elf_munmap_section_contents (plts[j].sec, plts[j].contents);
3791
3792
34
  free (dynrelbuf);
3793
3794
34
  return count;
3795
30
}
3796
3797
/* Parse x86 GNU properties.  */
3798
3799
enum elf_property_kind
3800
_bfd_x86_elf_parse_gnu_properties (bfd *abfd, unsigned int type,
3801
           bfd_byte *ptr, unsigned int datasz)
3802
58
{
3803
58
  elf_property *prop;
3804
3805
58
  if (type == GNU_PROPERTY_X86_COMPAT_ISA_1_USED
3806
58
      || type == GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
3807
58
      || (type >= GNU_PROPERTY_X86_UINT32_AND_LO
3808
35
    && type <= GNU_PROPERTY_X86_UINT32_AND_HI)
3809
58
      || (type >= GNU_PROPERTY_X86_UINT32_OR_LO
3810
12
    && type <= GNU_PROPERTY_X86_UINT32_OR_HI)
3811
58
      || (type >= GNU_PROPERTY_X86_UINT32_OR_AND_LO
3812
12
    && type <= GNU_PROPERTY_X86_UINT32_OR_AND_HI))
3813
46
    {
3814
46
      if (datasz != 4)
3815
20
  {
3816
20
    _bfd_error_handler
3817
20
      (_("error: %pB: <corrupt x86 property (0x%x) size: 0x%x>"),
3818
20
       abfd, type, datasz);
3819
20
    return property_corrupt;
3820
20
  }
3821
26
      prop = _bfd_elf_get_property (abfd, type, datasz);
3822
26
      prop->u.number |= bfd_h_get_32 (abfd, ptr);
3823
26
      prop->pr_kind = property_number;
3824
26
      return property_number;
3825
46
    }
3826
3827
12
  return property_ignored;
3828
58
}
3829
3830
/* Merge x86 GNU property BPROP with APROP.  If APROP isn't NULL,
3831
   return TRUE if APROP is updated.  Otherwise, return TRUE if BPROP
3832
   should be merged with ABFD.  */
3833
3834
bool
3835
_bfd_x86_elf_merge_gnu_properties (struct bfd_link_info *info,
3836
           bfd *abfd ATTRIBUTE_UNUSED,
3837
           bfd *bbfd ATTRIBUTE_UNUSED,
3838
           elf_property *aprop,
3839
           elf_property *bprop)
3840
0
{
3841
0
  unsigned int number, features;
3842
0
  bool updated = false;
3843
0
  const struct elf_backend_data *bed;
3844
0
  struct elf_x86_link_hash_table *htab;
3845
0
  unsigned int pr_type = aprop != NULL ? aprop->pr_type : bprop->pr_type;
3846
3847
0
  if (pr_type == GNU_PROPERTY_X86_COMPAT_ISA_1_USED
3848
0
      || (pr_type >= GNU_PROPERTY_X86_UINT32_OR_AND_LO
3849
0
    && pr_type <= GNU_PROPERTY_X86_UINT32_OR_AND_HI))
3850
0
    {
3851
0
      if (aprop == NULL || bprop == NULL)
3852
0
  {
3853
    /* Only one of APROP and BPROP can be NULL.  */
3854
0
    if (aprop != NULL)
3855
0
      {
3856
        /* Remove this property since the other input file doesn't
3857
     have it.  */
3858
0
        aprop->pr_kind = property_remove;
3859
0
        updated = true;
3860
0
      }
3861
0
  }
3862
0
      else
3863
0
  {
3864
0
    number = aprop->u.number;
3865
0
    aprop->u.number = number | bprop->u.number;
3866
0
    updated = number != (unsigned int) aprop->u.number;
3867
0
  }
3868
0
      return updated;
3869
0
    }
3870
0
  else if (pr_type == GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
3871
0
     || (pr_type >= GNU_PROPERTY_X86_UINT32_OR_LO
3872
0
         && pr_type <= GNU_PROPERTY_X86_UINT32_OR_HI))
3873
0
    {
3874
0
      features = 0;
3875
0
      if (pr_type == GNU_PROPERTY_X86_ISA_1_NEEDED)
3876
0
  {
3877
0
    bed = get_elf_backend_data (info->output_bfd);
3878
0
    htab = elf_x86_hash_table (info, bed->target_id);
3879
0
    switch (htab->params->isa_level)
3880
0
      {
3881
0
      case 0:
3882
0
        break;
3883
0
      case 2:
3884
0
        features = GNU_PROPERTY_X86_ISA_1_V2;
3885
0
        break;
3886
0
      case 3:
3887
0
        features = GNU_PROPERTY_X86_ISA_1_V3;
3888
0
        break;
3889
0
      case 4:
3890
0
        features = GNU_PROPERTY_X86_ISA_1_V4;
3891
0
        break;
3892
0
      default:
3893
0
        abort ();
3894
0
      }
3895
0
  }
3896
0
      if (aprop != NULL && bprop != NULL)
3897
0
  {
3898
0
    number = aprop->u.number;
3899
0
    aprop->u.number = number | bprop->u.number | features;
3900
    /* Remove the property if all bits are empty.  */
3901
0
    if (aprop->u.number == 0)
3902
0
      {
3903
0
        aprop->pr_kind = property_remove;
3904
0
        updated = true;
3905
0
      }
3906
0
    else
3907
0
      updated = number != (unsigned int) aprop->u.number;
3908
0
  }
3909
0
      else
3910
0
  {
3911
    /* Only one of APROP and BPROP can be NULL.  */
3912
0
    if (aprop != NULL)
3913
0
      {
3914
0
        aprop->u.number |= features;
3915
0
        if (aprop->u.number == 0)
3916
0
    {
3917
      /* Remove APROP if all bits are empty.  */
3918
0
      aprop->pr_kind = property_remove;
3919
0
      updated = true;
3920
0
    }
3921
0
      }
3922
0
    else
3923
0
      {
3924
        /* Return TRUE if APROP is NULL and all bits of BPROP
3925
     aren't empty to indicate that BPROP should be added
3926
     to ABFD.  */
3927
0
        bprop->u.number |= features;
3928
0
        updated = bprop->u.number != 0;
3929
0
      }
3930
0
  }
3931
0
      return updated;
3932
0
    }
3933
0
  else if (pr_type >= GNU_PROPERTY_X86_UINT32_AND_LO
3934
0
     && pr_type <= GNU_PROPERTY_X86_UINT32_AND_HI)
3935
0
    {
3936
      /* Only one of APROP and BPROP can be NULL:
3937
   1. APROP & BPROP when both APROP and BPROP aren't NULL.
3938
   2. If APROP is NULL, remove x86 feature.
3939
   3. Otherwise, do nothing.
3940
       */
3941
0
      bed = get_elf_backend_data (info->output_bfd);
3942
0
      htab = elf_x86_hash_table (info, bed->target_id);
3943
0
      if (!htab)
3944
0
  abort ();
3945
0
      if (aprop != NULL && bprop != NULL)
3946
0
  {
3947
0
    number = aprop->u.number;
3948
0
    aprop->u.number = number & bprop->u.number;
3949
0
    if (pr_type == GNU_PROPERTY_X86_FEATURE_1_AND)
3950
0
      {
3951
0
        features = 0;
3952
0
        if (htab->params->ibt)
3953
0
    features = GNU_PROPERTY_X86_FEATURE_1_IBT;
3954
0
        if (htab->params->shstk)
3955
0
    features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK;
3956
0
        if (htab->params->lam_u48)
3957
0
    features |= (GNU_PROPERTY_X86_FEATURE_1_LAM_U48
3958
0
           | GNU_PROPERTY_X86_FEATURE_1_LAM_U57);
3959
0
        else if (htab->params->lam_u57)
3960
0
    features |= GNU_PROPERTY_X86_FEATURE_1_LAM_U57;
3961
        /* Add GNU_PROPERTY_X86_FEATURE_1_IBT,
3962
     GNU_PROPERTY_X86_FEATURE_1_SHSTK,
3963
     GNU_PROPERTY_X86_FEATURE_1_LAM_U48 and
3964
     GNU_PROPERTY_X86_FEATURE_1_LAM_U57.  */
3965
0
        aprop->u.number |= features;
3966
0
      }
3967
0
    updated = number != (unsigned int) aprop->u.number;
3968
    /* Remove the property if all feature bits are cleared.  */
3969
0
    if (aprop->u.number == 0)
3970
0
      aprop->pr_kind = property_remove;
3971
0
  }
3972
0
      else
3973
0
  {
3974
    /* There should be no AND properties since some input doesn't
3975
       have them.  Set IBT and SHSTK properties for -z ibt and -z
3976
       shstk if needed.  */
3977
0
    features = 0;
3978
0
    if (pr_type == GNU_PROPERTY_X86_FEATURE_1_AND)
3979
0
      {
3980
0
        if (htab->params->ibt)
3981
0
    features = GNU_PROPERTY_X86_FEATURE_1_IBT;
3982
0
        if (htab->params->shstk)
3983
0
    features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK;
3984
0
        if (htab->params->lam_u48)
3985
0
    features |= (GNU_PROPERTY_X86_FEATURE_1_LAM_U48
3986
0
           | GNU_PROPERTY_X86_FEATURE_1_LAM_U57);
3987
0
        else if (htab->params->lam_u57)
3988
0
    features |= GNU_PROPERTY_X86_FEATURE_1_LAM_U57;
3989
0
      }
3990
0
    if (features)
3991
0
      {
3992
0
        if (aprop != NULL)
3993
0
    {
3994
0
      updated = features != (unsigned int) aprop->u.number;
3995
0
      aprop->u.number = features;
3996
0
    }
3997
0
        else
3998
0
    {
3999
0
      updated = true;
4000
0
      bprop->u.number = features;
4001
0
    }
4002
0
      }
4003
0
    else if (aprop != NULL)
4004
0
      {
4005
0
        aprop->pr_kind = property_remove;
4006
0
        updated = true;
4007
0
      }
4008
0
  }
4009
0
      return updated;
4010
0
    }
4011
0
  else
4012
0
    {
4013
      /* Never should happen.  */
4014
0
      abort ();
4015
0
    }
4016
4017
0
  return updated;
4018
0
}
4019
4020
/* Set up x86 GNU properties.  Return the first relocatable ELF input
4021
   with GNU properties if found.  Otherwise, return NULL.  */
4022
4023
bfd *
4024
_bfd_x86_elf_link_setup_gnu_properties
4025
  (struct bfd_link_info *info, struct elf_x86_init_table *init_table)
4026
0
{
4027
0
  bool normal_target;
4028
0
  bool lazy_plt;
4029
0
  asection *sec, *pltsec;
4030
0
  bfd *dynobj;
4031
0
  bool use_ibt_plt;
4032
0
  unsigned int plt_alignment, features, isa_level;
4033
0
  struct elf_x86_link_hash_table *htab;
4034
0
  bfd *pbfd;
4035
0
  bfd *ebfd = NULL;
4036
0
  elf_property *prop;
4037
0
  const struct elf_backend_data *bed;
4038
0
  unsigned int class_align = ABI_64_P (info->output_bfd) ? 3 : 2;
4039
0
  unsigned int got_align;
4040
4041
  /* Find a normal input file with GNU property note.  */
4042
0
  for (pbfd = info->input_bfds;
4043
0
       pbfd != NULL;
4044
0
       pbfd = pbfd->link.next)
4045
0
    if (bfd_get_flavour (pbfd) == bfd_target_elf_flavour
4046
0
  && bfd_count_sections (pbfd) != 0)
4047
0
      {
4048
0
  ebfd = pbfd;
4049
4050
0
  if (elf_properties (pbfd) != NULL)
4051
0
    break;
4052
0
      }
4053
4054
0
  bed = get_elf_backend_data (info->output_bfd);
4055
4056
0
  htab = elf_x86_hash_table (info, bed->target_id);
4057
0
  if (htab == NULL)
4058
0
    return pbfd;
4059
4060
0
  features = 0;
4061
0
  if (htab->params->ibt)
4062
0
    {
4063
0
      features = GNU_PROPERTY_X86_FEATURE_1_IBT;
4064
0
      htab->params->cet_report &= ~prop_report_ibt;
4065
0
    }
4066
0
  if (htab->params->shstk)
4067
0
    {
4068
0
      features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK;
4069
0
      htab->params->cet_report &= ~prop_report_shstk;
4070
0
    }
4071
0
  if (!(htab->params->cet_report & (prop_report_ibt | prop_report_shstk)))
4072
0
    htab->params->cet_report = prop_report_none;
4073
0
  if (htab->params->lam_u48)
4074
0
    {
4075
0
      features |= (GNU_PROPERTY_X86_FEATURE_1_LAM_U48
4076
0
       | GNU_PROPERTY_X86_FEATURE_1_LAM_U57);
4077
0
      htab->params->lam_u48_report = prop_report_none;
4078
0
      htab->params->lam_u57_report = prop_report_none;
4079
0
    }
4080
0
  else if (htab->params->lam_u57)
4081
0
    {
4082
0
      features |= GNU_PROPERTY_X86_FEATURE_1_LAM_U57;
4083
0
      htab->params->lam_u57_report = prop_report_none;
4084
0
    }
4085
4086
0
  switch (htab->params->isa_level)
4087
0
    {
4088
0
    case 0:
4089
0
      isa_level = 0;
4090
0
      break;
4091
0
    case 1:
4092
0
      isa_level = GNU_PROPERTY_X86_ISA_1_BASELINE;
4093
0
      break;
4094
0
    case 2:
4095
0
      isa_level = GNU_PROPERTY_X86_ISA_1_V2;
4096
0
      break;
4097
0
    case 3:
4098
0
      isa_level = GNU_PROPERTY_X86_ISA_1_V3;
4099
0
      break;
4100
0
    case 4:
4101
0
      isa_level = GNU_PROPERTY_X86_ISA_1_V4;
4102
0
      break;
4103
0
    default:
4104
0
      abort ();
4105
0
    }
4106
4107
0
  if (ebfd != NULL)
4108
0
    {
4109
0
      prop = NULL;
4110
0
      if (features)
4111
0
  {
4112
    /* If features is set, add GNU_PROPERTY_X86_FEATURE_1_IBT,
4113
       GNU_PROPERTY_X86_FEATURE_1_SHSTK,
4114
       GNU_PROPERTY_X86_FEATURE_1_LAM_U48 and
4115
       GNU_PROPERTY_X86_FEATURE_1_LAM_U57.  */
4116
0
    prop = _bfd_elf_get_property (ebfd,
4117
0
          GNU_PROPERTY_X86_FEATURE_1_AND,
4118
0
          4);
4119
0
    prop->u.number |= features;
4120
0
    prop->pr_kind = property_number;
4121
0
  }
4122
4123
0
      if (isa_level)
4124
0
  {
4125
    /* If ISA level is set, add GNU_PROPERTY_X86_ISA_1_NEEDED.  */
4126
0
    prop = _bfd_elf_get_property (ebfd,
4127
0
          GNU_PROPERTY_X86_ISA_1_NEEDED,
4128
0
          4);
4129
0
    prop->u.number |= isa_level;
4130
0
    prop->pr_kind = property_number;
4131
0
  }
4132
4133
      /* Create the GNU property note section if needed.  */
4134
0
      if (prop != NULL && pbfd == NULL)
4135
0
  {
4136
0
    sec = bfd_make_section_with_flags (ebfd,
4137
0
               NOTE_GNU_PROPERTY_SECTION_NAME,
4138
0
               (SEC_ALLOC
4139
0
                | SEC_LOAD
4140
0
                | SEC_IN_MEMORY
4141
0
                | SEC_READONLY
4142
0
                | SEC_HAS_CONTENTS
4143
0
                | SEC_DATA));
4144
0
    if (sec == NULL)
4145
0
      info->callbacks->einfo (_("%F%P: failed to create GNU property section\n"));
4146
4147
0
    if (!bfd_set_section_alignment (sec, class_align))
4148
0
      {
4149
0
      error_alignment:
4150
0
        info->callbacks->einfo (_("%F%pA: failed to align section\n"),
4151
0
              sec);
4152
0
      }
4153
4154
0
    elf_section_type (sec) = SHT_NOTE;
4155
0
  }
4156
0
    }
4157
4158
0
  if (htab->params->cet_report
4159
0
      || htab->params->lam_u48_report
4160
0
      || htab->params->lam_u57_report)
4161
0
    {
4162
      /* Report missing IBT, SHSTK and LAM properties.  */
4163
0
      bfd *abfd;
4164
0
      const char *warning_msg = _("%P: %pB: warning: missing %s\n");
4165
0
      const char *error_msg = _("%X%P: %pB: error: missing %s\n");
4166
0
      const char *cet_msg = NULL;
4167
0
      const char *lam_u48_msg = NULL;
4168
0
      const char *lam_u57_msg = NULL;
4169
0
      const char *missing;
4170
0
      elf_property_list *p;
4171
0
      bool missing_ibt, missing_shstk;
4172
0
      bool missing_lam_u48, missing_lam_u57;
4173
0
      bool check_ibt
4174
0
  = (htab->params->cet_report
4175
0
     && (htab->params->cet_report & prop_report_ibt));
4176
0
      bool check_shstk
4177
0
  = (htab->params->cet_report
4178
0
     && (htab->params->cet_report & prop_report_shstk));
4179
4180
0
      if (htab->params->cet_report)
4181
0
  {
4182
0
    if ((htab->params->cet_report & prop_report_warning))
4183
0
      cet_msg = warning_msg;
4184
0
    else
4185
0
      cet_msg = error_msg;
4186
0
  }
4187
0
      if (htab->params->lam_u48_report)
4188
0
  {
4189
0
    if ((htab->params->lam_u48_report & prop_report_warning))
4190
0
      lam_u48_msg = warning_msg;
4191
0
    else
4192
0
      lam_u48_msg = error_msg;
4193
0
  }
4194
0
      if (htab->params->lam_u57_report)
4195
0
  {
4196
0
    if ((htab->params->lam_u57_report & prop_report_warning))
4197
0
      lam_u57_msg = warning_msg;
4198
0
    else
4199
0
      lam_u57_msg = error_msg;
4200
0
  }
4201
4202
0
      for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link.next)
4203
0
  if (!(abfd->flags & (DYNAMIC | BFD_PLUGIN | BFD_LINKER_CREATED))
4204
0
      && bfd_get_flavour (abfd) == bfd_target_elf_flavour)
4205
0
    {
4206
0
      for (p = elf_properties (abfd); p; p = p->next)
4207
0
        if (p->property.pr_type == GNU_PROPERTY_X86_FEATURE_1_AND)
4208
0
    break;
4209
4210
0
      missing_ibt = check_ibt;
4211
0
      missing_shstk = check_shstk;
4212
0
      missing_lam_u48 = !!lam_u48_msg;
4213
0
      missing_lam_u57 = !!lam_u57_msg;
4214
0
      if (p)
4215
0
        {
4216
0
    missing_ibt &= !(p->property.u.number
4217
0
         & GNU_PROPERTY_X86_FEATURE_1_IBT);
4218
0
    missing_shstk &= !(p->property.u.number
4219
0
           & GNU_PROPERTY_X86_FEATURE_1_SHSTK);
4220
0
    missing_lam_u48 &= !(p->property.u.number
4221
0
             & GNU_PROPERTY_X86_FEATURE_1_LAM_U48);
4222
0
    missing_lam_u57 &= !(p->property.u.number
4223
0
             & GNU_PROPERTY_X86_FEATURE_1_LAM_U57);
4224
0
        }
4225
0
      if (missing_ibt || missing_shstk)
4226
0
        {
4227
0
    if (missing_ibt && missing_shstk)
4228
0
      missing = _("IBT and SHSTK properties");
4229
0
    else if (missing_ibt)
4230
0
      missing = _("IBT property");
4231
0
    else
4232
0
      missing = _("SHSTK property");
4233
0
    info->callbacks->einfo (cet_msg, abfd, missing);
4234
0
        }
4235
0
      if (missing_lam_u48)
4236
0
        {
4237
0
    missing = _("LAM_U48 property");
4238
0
    info->callbacks->einfo (lam_u48_msg, abfd, missing);
4239
0
        }
4240
0
      if (missing_lam_u57)
4241
0
        {
4242
0
    missing = _("LAM_U57 property");
4243
0
    info->callbacks->einfo (lam_u57_msg, abfd, missing);
4244
0
        }
4245
0
    }
4246
0
    }
4247
4248
0
  pbfd = _bfd_elf_link_setup_gnu_properties (info);
4249
4250
0
  htab->r_info = init_table->r_info;
4251
0
  htab->r_sym = init_table->r_sym;
4252
4253
0
  if (bfd_link_relocatable (info))
4254
0
    return pbfd;
4255
4256
0
  htab->plt0_pad_byte = init_table->plt0_pad_byte;
4257
4258
0
  use_ibt_plt = htab->params->ibtplt || htab->params->ibt;
4259
0
  if (!use_ibt_plt && pbfd != NULL)
4260
0
    {
4261
      /* Check if GNU_PROPERTY_X86_FEATURE_1_IBT is on.  */
4262
0
      elf_property_list *p;
4263
4264
      /* The property list is sorted in order of type.  */
4265
0
      for (p = elf_properties (pbfd); p; p = p->next)
4266
0
  {
4267
0
    if (GNU_PROPERTY_X86_FEATURE_1_AND == p->property.pr_type)
4268
0
      {
4269
0
        use_ibt_plt = !!(p->property.u.number
4270
0
             & GNU_PROPERTY_X86_FEATURE_1_IBT);
4271
0
        break;
4272
0
      }
4273
0
    else if (GNU_PROPERTY_X86_FEATURE_1_AND < p->property.pr_type)
4274
0
      break;
4275
0
  }
4276
0
    }
4277
4278
0
  dynobj = htab->elf.dynobj;
4279
4280
  /* Set htab->elf.dynobj here so that there is no need to check and
4281
     set it in check_relocs.  */
4282
0
  if (dynobj == NULL)
4283
0
    {
4284
0
      if (pbfd != NULL)
4285
0
  {
4286
0
    htab->elf.dynobj = pbfd;
4287
0
    dynobj = pbfd;
4288
0
  }
4289
0
      else
4290
0
  {
4291
0
    bfd *abfd;
4292
4293
    /* Find a normal input file to hold linker created
4294
       sections.  */
4295
0
    for (abfd = info->input_bfds;
4296
0
         abfd != NULL;
4297
0
         abfd = abfd->link.next)
4298
0
      if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
4299
0
    && (abfd->flags
4300
0
        & (DYNAMIC | BFD_LINKER_CREATED | BFD_PLUGIN)) == 0
4301
0
    && bed->relocs_compatible (abfd->xvec,
4302
0
             info->output_bfd->xvec))
4303
0
        {
4304
0
    htab->elf.dynobj = abfd;
4305
0
    dynobj = abfd;
4306
0
    break;
4307
0
        }
4308
0
  }
4309
0
    }
4310
4311
  /* Return if there are no normal input files.  */
4312
0
  if (dynobj == NULL)
4313
0
    return pbfd;
4314
4315
  /* Even when lazy binding is disabled by "-z now", the PLT0 entry may
4316
     still be used with LD_AUDIT or LD_PROFILE if PLT entry is used for
4317
     canonical function address.  */
4318
0
  htab->plt.has_plt0 = 1;
4319
0
  htab->plt.plt_indirect_branch_offset = 0;
4320
0
  normal_target = htab->elf.target_os == is_normal;
4321
4322
0
  if (normal_target)
4323
0
    {
4324
0
      if (use_ibt_plt)
4325
0
  {
4326
0
    htab->lazy_plt = init_table->lazy_ibt_plt;
4327
0
    htab->non_lazy_plt = init_table->non_lazy_ibt_plt;
4328
0
    htab->plt.plt_indirect_branch_offset = 4;
4329
0
  }
4330
0
      else
4331
0
  {
4332
0
    htab->lazy_plt = init_table->lazy_plt;
4333
0
    htab->non_lazy_plt = init_table->non_lazy_plt;
4334
0
  }
4335
0
    }
4336
0
  else
4337
0
    {
4338
0
      htab->lazy_plt = init_table->lazy_plt;
4339
0
      htab->non_lazy_plt = NULL;
4340
0
    }
4341
4342
0
  pltsec = htab->elf.splt;
4343
4344
0
  if (htab->non_lazy_plt != NULL
4345
0
      && (!htab->plt.has_plt0 || pltsec == NULL))
4346
0
    lazy_plt = false;
4347
0
  else
4348
0
    lazy_plt = true;
4349
4350
0
  if (normal_target)
4351
0
    {
4352
0
      if (use_ibt_plt)
4353
0
  {
4354
0
    if (lazy_plt)
4355
0
      htab->sframe_plt = init_table->sframe_lazy_ibt_plt;
4356
0
    else
4357
0
      htab->sframe_plt = init_table->sframe_non_lazy_ibt_plt;
4358
0
  }
4359
0
      else
4360
0
  {
4361
0
    if (lazy_plt)
4362
0
      htab->sframe_plt = init_table->sframe_lazy_plt;
4363
0
    else
4364
0
      htab->sframe_plt = init_table->sframe_non_lazy_plt;
4365
0
  }
4366
0
    }
4367
0
  else
4368
0
    htab->sframe_plt = NULL;
4369
4370
  /* If the non-lazy PLT is available, use it for all PLT entries if
4371
     there are no PLT0 or no .plt section.  */
4372
0
  if (!lazy_plt)
4373
0
    {
4374
0
      if (bfd_link_pic (info))
4375
0
  htab->plt.plt_entry = htab->non_lazy_plt->pic_plt_entry;
4376
0
      else
4377
0
  htab->plt.plt_entry = htab->non_lazy_plt->plt_entry;
4378
0
      htab->plt.plt_entry_size = htab->non_lazy_plt->plt_entry_size;
4379
0
      htab->plt.plt_got_offset = htab->non_lazy_plt->plt_got_offset;
4380
0
      htab->plt.plt_got_insn_size
4381
0
  = htab->non_lazy_plt->plt_got_insn_size;
4382
0
      htab->plt.eh_frame_plt_size
4383
0
  = htab->non_lazy_plt->eh_frame_plt_size;
4384
0
      htab->plt.eh_frame_plt = htab->non_lazy_plt->eh_frame_plt;
4385
0
    }
4386
0
  else
4387
0
    {
4388
0
      if (bfd_link_pic (info))
4389
0
  {
4390
0
    htab->plt.plt0_entry = htab->lazy_plt->pic_plt0_entry;
4391
0
    htab->plt.plt_entry = htab->lazy_plt->pic_plt_entry;
4392
0
  }
4393
0
      else
4394
0
  {
4395
0
    htab->plt.plt0_entry = htab->lazy_plt->plt0_entry;
4396
0
    htab->plt.plt_entry = htab->lazy_plt->plt_entry;
4397
0
  }
4398
0
      htab->plt.plt_entry_size = htab->lazy_plt->plt_entry_size;
4399
0
      htab->plt.plt_got_offset = htab->lazy_plt->plt_got_offset;
4400
0
      htab->plt.plt_got_insn_size
4401
0
  = htab->lazy_plt->plt_got_insn_size;
4402
0
      htab->plt.eh_frame_plt_size
4403
0
  = htab->lazy_plt->eh_frame_plt_size;
4404
0
      htab->plt.eh_frame_plt = htab->lazy_plt->eh_frame_plt;
4405
0
    }
4406
4407
0
  if (htab->elf.target_os == is_vxworks
4408
0
      && !elf_vxworks_create_dynamic_sections (dynobj, info,
4409
0
                 &htab->srelplt2))
4410
0
    {
4411
0
      info->callbacks->einfo (_("%F%P: failed to create VxWorks dynamic sections\n"));
4412
0
      return pbfd;
4413
0
    }
4414
4415
  /* Since create_dynamic_sections isn't always called, but GOT
4416
     relocations need GOT relocations, create them here so that we
4417
     don't need to do it in check_relocs.  */
4418
0
  if (htab->elf.sgot == NULL
4419
0
      && !_bfd_elf_create_got_section (dynobj, info))
4420
0
    info->callbacks->einfo (_("%F%P: failed to create GOT sections\n"));
4421
4422
0
  got_align = (bed->target_id == X86_64_ELF_DATA) ? 3 : 2;
4423
4424
  /* Align .got and .got.plt sections to their entry size.  Do it here
4425
     instead of in create_dynamic_sections so that they are always
4426
     properly aligned even if create_dynamic_sections isn't called.  */
4427
0
  sec = htab->elf.sgot;
4428
0
  if (!bfd_set_section_alignment (sec, got_align))
4429
0
    goto error_alignment;
4430
4431
0
  sec = htab->elf.sgotplt;
4432
0
  if (!bfd_set_section_alignment (sec, got_align))
4433
0
    goto error_alignment;
4434
4435
  /* Create the ifunc sections here so that check_relocs can be
4436
     simplified.  */
4437
0
  if (!_bfd_elf_create_ifunc_sections (dynobj, info))
4438
0
    info->callbacks->einfo (_("%F%P: failed to create ifunc sections\n"));
4439
4440
0
  plt_alignment = bfd_log2 (htab->plt.plt_entry_size);
4441
4442
0
  if (pltsec != NULL)
4443
0
    {
4444
      /* Whe creating executable, set the contents of the .interp
4445
   section to the interpreter.  */
4446
0
      if (bfd_link_executable (info) && !info->nointerp)
4447
0
  {
4448
0
    asection *s = bfd_get_linker_section (dynobj, ".interp");
4449
0
    if (s == NULL)
4450
0
      abort ();
4451
0
    s->size = htab->dynamic_interpreter_size;
4452
0
    s->contents = (unsigned char *) htab->dynamic_interpreter;
4453
0
    htab->interp = s;
4454
0
  }
4455
4456
0
      if (normal_target)
4457
0
  {
4458
0
    flagword pltflags = (bed->dynamic_sec_flags
4459
0
             | SEC_ALLOC
4460
0
             | SEC_CODE
4461
0
             | SEC_LOAD
4462
0
             | SEC_READONLY);
4463
0
    unsigned int non_lazy_plt_alignment
4464
0
      = bfd_log2 (htab->non_lazy_plt->plt_entry_size);
4465
4466
0
    sec = pltsec;
4467
0
    if (!bfd_set_section_alignment (sec, plt_alignment))
4468
0
      goto error_alignment;
4469
4470
    /* Create the GOT procedure linkage table.  */
4471
0
    sec = bfd_make_section_anyway_with_flags (dynobj,
4472
0
                ".plt.got",
4473
0
                pltflags);
4474
0
    if (sec == NULL)
4475
0
      info->callbacks->einfo (_("%F%P: failed to create GOT PLT section\n"));
4476
4477
0
    if (!bfd_set_section_alignment (sec, non_lazy_plt_alignment))
4478
0
      goto error_alignment;
4479
4480
0
    htab->plt_got = sec;
4481
4482
0
    if (lazy_plt)
4483
0
      {
4484
0
        sec = NULL;
4485
4486
0
        if (use_ibt_plt)
4487
0
    {
4488
      /* Create the second PLT for Intel IBT support.  IBT
4489
         PLT is needed only for lazy binding.  */
4490
0
      sec = bfd_make_section_anyway_with_flags (dynobj,
4491
0
                  ".plt.sec",
4492
0
                  pltflags);
4493
0
      if (sec == NULL)
4494
0
        info->callbacks->einfo (_("%F%P: failed to create IBT-enabled PLT section\n"));
4495
4496
0
      if (!bfd_set_section_alignment (sec, plt_alignment))
4497
0
        goto error_alignment;
4498
0
    }
4499
4500
0
        htab->plt_second = sec;
4501
0
      }
4502
0
  }
4503
4504
0
      if (!info->no_ld_generated_unwind_info)
4505
0
  {
4506
0
    flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4507
0
          | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4508
0
          | SEC_LINKER_CREATED);
4509
4510
0
    sec = bfd_make_section_anyway_with_flags (dynobj,
4511
0
                ".eh_frame",
4512
0
                flags);
4513
0
    if (sec == NULL)
4514
0
      info->callbacks->einfo (_("%F%P: failed to create PLT .eh_frame section\n"));
4515
4516
0
    if (!bfd_set_section_alignment (sec, class_align))
4517
0
      goto error_alignment;
4518
4519
0
    htab->plt_eh_frame = sec;
4520
4521
0
    if (htab->plt_got != NULL)
4522
0
      {
4523
0
        sec = bfd_make_section_anyway_with_flags (dynobj,
4524
0
              ".eh_frame",
4525
0
              flags);
4526
0
        if (sec == NULL)
4527
0
    info->callbacks->einfo (_("%F%P: failed to create GOT PLT .eh_frame section\n"));
4528
4529
0
        if (!bfd_set_section_alignment (sec, class_align))
4530
0
    goto error_alignment;
4531
4532
0
        htab->plt_got_eh_frame = sec;
4533
0
      }
4534
4535
0
    if (htab->plt_second != NULL)
4536
0
      {
4537
0
        sec = bfd_make_section_anyway_with_flags (dynobj,
4538
0
              ".eh_frame",
4539
0
              flags);
4540
0
        if (sec == NULL)
4541
0
    info->callbacks->einfo (_("%F%P: failed to create the second PLT .eh_frame section\n"));
4542
4543
0
        if (!bfd_set_section_alignment (sec, class_align))
4544
0
    goto error_alignment;
4545
4546
0
        htab->plt_second_eh_frame = sec;
4547
0
      }
4548
0
  }
4549
4550
      /* .sframe sections are emitted for AMD64 ABI only.  */
4551
0
      if (ABI_64_P (info->output_bfd) && !info->no_ld_generated_unwind_info)
4552
0
  {
4553
0
    flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4554
0
          | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4555
0
          | SEC_LINKER_CREATED);
4556
4557
0
    sec = bfd_make_section_anyway_with_flags (dynobj,
4558
0
                ".sframe",
4559
0
                flags);
4560
0
    if (sec == NULL)
4561
0
      info->callbacks->einfo (_("%F%P: failed to create PLT .sframe section\n"));
4562
4563
    // FIXME check this
4564
    // if (!bfd_set_section_alignment (sec, class_align))
4565
    //  goto error_alignment;
4566
4567
0
    htab->plt_sframe = sec;
4568
4569
    /* Second PLT is generated for Intel IBT + lazy plt.  */
4570
0
    if (htab->plt_second != NULL)
4571
0
      {
4572
0
        sec = bfd_make_section_anyway_with_flags (dynobj,
4573
0
              ".sframe",
4574
0
              flags);
4575
0
        if (sec == NULL)
4576
0
    info->callbacks->einfo (_("%F%P: failed to create second PLT .sframe section\n"));
4577
4578
0
        htab->plt_second_sframe = sec;
4579
0
      }
4580
    /* FIXME - add later for plt_got. */
4581
0
  }
4582
0
    }
4583
4584
  /* The .iplt section is used for IFUNC symbols in static
4585
     executables.  */
4586
0
  sec = htab->elf.iplt;
4587
0
  if (sec != NULL)
4588
0
    {
4589
      /* NB: Delay setting its alignment until we know it is non-empty.
4590
   Otherwise an empty iplt section may change vma and lma of the
4591
   following sections, which triggers moving dot of the following
4592
   section backwards, resulting in a warning and section lma not
4593
   being set properly.  It later leads to a "File truncated"
4594
   error.  */
4595
0
      if (!bfd_set_section_alignment (sec, 0))
4596
0
  goto error_alignment;
4597
4598
0
      htab->plt.iplt_alignment = (normal_target
4599
0
          ? plt_alignment
4600
0
          : bed->plt_alignment);
4601
0
    }
4602
4603
0
  if (bfd_link_executable (info)
4604
0
      && !info->nointerp
4605
0
      && !htab->params->has_dynamic_linker
4606
0
      && htab->params->static_before_all_inputs)
4607
0
    {
4608
      /* Report error for dynamic input objects if -static is passed at
4609
   command-line before all input files without --dynamic-linker
4610
   unless --no-dynamic-linker is used.  */
4611
0
      bfd *abfd;
4612
4613
0
      for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link.next)
4614
0
  if ((abfd->flags & DYNAMIC))
4615
0
    info->callbacks->einfo
4616
0
      (_("%X%P: attempted static link of dynamic object `%pB'\n"),
4617
0
       abfd);
4618
0
    }
4619
4620
0
  return pbfd;
4621
0
}
4622
4623
/* Fix up x86 GNU properties.  */
4624
4625
void
4626
_bfd_x86_elf_link_fixup_gnu_properties
4627
  (struct bfd_link_info *info, elf_property_list **listp)
4628
0
{
4629
0
  elf_property_list *p;
4630
4631
0
  for (p = *listp; p; p = p->next)
4632
0
    {
4633
0
      unsigned int type = p->property.pr_type;
4634
0
      if (type == GNU_PROPERTY_X86_COMPAT_ISA_1_USED
4635
0
    || type == GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
4636
0
    || (type >= GNU_PROPERTY_X86_UINT32_AND_LO
4637
0
        && type <= GNU_PROPERTY_X86_UINT32_AND_HI)
4638
0
    || (type >= GNU_PROPERTY_X86_UINT32_OR_LO
4639
0
        && type <= GNU_PROPERTY_X86_UINT32_OR_HI)
4640
0
    || (type >= GNU_PROPERTY_X86_UINT32_OR_AND_LO
4641
0
        && type <= GNU_PROPERTY_X86_UINT32_OR_AND_HI))
4642
0
  {
4643
0
    if (p->property.u.number == 0
4644
0
        && (type == GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
4645
0
      || (type >= GNU_PROPERTY_X86_UINT32_AND_LO
4646
0
          && type <= GNU_PROPERTY_X86_UINT32_AND_HI)
4647
0
      || (type >= GNU_PROPERTY_X86_UINT32_OR_LO
4648
0
          && type <= GNU_PROPERTY_X86_UINT32_OR_HI)))
4649
0
      {
4650
        /* Remove empty property.  */
4651
0
        *listp = p->next;
4652
0
        continue;
4653
0
      }
4654
4655
    /* Keep LAM features only for 64-bit output.  */
4656
0
    if (type == GNU_PROPERTY_X86_FEATURE_1_AND
4657
0
        && !ABI_64_P (info->output_bfd))
4658
0
      p->property.u.number &= ~(GNU_PROPERTY_X86_FEATURE_1_LAM_U48
4659
0
              | GNU_PROPERTY_X86_FEATURE_1_LAM_U57);
4660
4661
0
    listp = &p->next;
4662
0
  }
4663
0
      else if (type > GNU_PROPERTY_HIPROC)
4664
0
  {
4665
    /* The property list is sorted in order of type.  */
4666
0
    break;
4667
0
  }
4668
0
    }
4669
0
}
4670
4671
void
4672
_bfd_elf_linker_x86_set_options (struct bfd_link_info * info,
4673
         struct elf_linker_x86_params *params)
4674
0
{
4675
0
  const struct elf_backend_data *bed
4676
0
    = get_elf_backend_data (info->output_bfd);
4677
0
  struct elf_x86_link_hash_table *htab
4678
0
    = elf_x86_hash_table (info, bed->target_id);
4679
0
  if (htab != NULL)
4680
0
    htab->params = params;
4681
0
}