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

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [bfd/] [elflink.c] - Blame information for rev 166

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 14 khays
/* ELF linking support for BFD.
2
   Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3
   2005, 2006, 2007, 2008, 2009, 2010, 2011
4
   Free Software Foundation, Inc.
5
 
6
   This file is part of BFD, the Binary File Descriptor library.
7
 
8
   This program is free software; you can redistribute it and/or modify
9
   it under the terms of the GNU General Public License as published by
10
   the Free Software Foundation; either version 3 of the License, or
11
   (at your option) any later version.
12
 
13
   This program is distributed in the hope that it will be useful,
14
   but WITHOUT ANY WARRANTY; without even the implied warranty of
15
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
   GNU General Public License for more details.
17
 
18
   You should have received a copy of the GNU General Public License
19
   along with this program; if not, write to the Free Software
20
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21
   MA 02110-1301, USA.  */
22
 
23
#include "sysdep.h"
24
#include "bfd.h"
25
#include "bfdlink.h"
26
#include "libbfd.h"
27
#define ARCH_SIZE 0
28
#include "elf-bfd.h"
29
#include "safe-ctype.h"
30
#include "libiberty.h"
31
#include "objalloc.h"
32
 
33
/* This struct is used to pass information to routines called via
34
   elf_link_hash_traverse which must return failure.  */
35
 
36
struct elf_info_failed
37
{
38
  struct bfd_link_info *info;
39
  bfd_boolean failed;
40
};
41
 
42
/* This structure is used to pass information to
43
   _bfd_elf_link_find_version_dependencies.  */
44
 
45
struct elf_find_verdep_info
46
{
47
  /* General link information.  */
48
  struct bfd_link_info *info;
49
  /* The number of dependencies.  */
50
  unsigned int vers;
51
  /* Whether we had a failure.  */
52
  bfd_boolean failed;
53
};
54
 
55
static bfd_boolean _bfd_elf_fix_symbol_flags
56
  (struct elf_link_hash_entry *, struct elf_info_failed *);
57
 
58
/* Define a symbol in a dynamic linkage section.  */
59
 
60
struct elf_link_hash_entry *
61
_bfd_elf_define_linkage_sym (bfd *abfd,
62
                             struct bfd_link_info *info,
63
                             asection *sec,
64
                             const char *name)
65
{
66
  struct elf_link_hash_entry *h;
67
  struct bfd_link_hash_entry *bh;
68
  const struct elf_backend_data *bed;
69
 
70
  h = elf_link_hash_lookup (elf_hash_table (info), name, FALSE, FALSE, FALSE);
71
  if (h != NULL)
72
    {
73
      /* Zap symbol defined in an as-needed lib that wasn't linked.
74
         This is a symptom of a larger problem:  Absolute symbols
75
         defined in shared libraries can't be overridden, because we
76
         lose the link to the bfd which is via the symbol section.  */
77
      h->root.type = bfd_link_hash_new;
78
    }
79
 
80
  bh = &h->root;
81
  if (!_bfd_generic_link_add_one_symbol (info, abfd, name, BSF_GLOBAL,
82
                                         sec, 0, NULL, FALSE,
83
                                         get_elf_backend_data (abfd)->collect,
84
                                         &bh))
85
    return NULL;
86
  h = (struct elf_link_hash_entry *) bh;
87
  h->def_regular = 1;
88
  h->non_elf = 0;
89
  h->type = STT_OBJECT;
90
  h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN;
91
 
92
  bed = get_elf_backend_data (abfd);
93
  (*bed->elf_backend_hide_symbol) (info, h, TRUE);
94
  return h;
95
}
96
 
97
bfd_boolean
98
_bfd_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
99
{
100
  flagword flags;
101
  asection *s;
102
  struct elf_link_hash_entry *h;
103
  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
104
  struct elf_link_hash_table *htab = elf_hash_table (info);
105
 
106
  /* This function may be called more than once.  */
107
  s = bfd_get_section_by_name (abfd, ".got");
108
  if (s != NULL && (s->flags & SEC_LINKER_CREATED) != 0)
109
    return TRUE;
110
 
111
  flags = bed->dynamic_sec_flags;
112
 
113 166 khays
  s = bfd_make_section_anyway_with_flags (abfd,
114
                                          (bed->rela_plts_and_copies_p
115
                                           ? ".rela.got" : ".rel.got"),
116
                                          (bed->dynamic_sec_flags
117
                                           | SEC_READONLY));
118 14 khays
  if (s == NULL
119
      || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
120
    return FALSE;
121
  htab->srelgot = s;
122
 
123 166 khays
  s = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
124 14 khays
  if (s == NULL
125
      || !bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
126
    return FALSE;
127
  htab->sgot = s;
128
 
129
  if (bed->want_got_plt)
130
    {
131 166 khays
      s = bfd_make_section_anyway_with_flags (abfd, ".got.plt", flags);
132 14 khays
      if (s == NULL
133
          || !bfd_set_section_alignment (abfd, s,
134
                                         bed->s->log_file_align))
135
        return FALSE;
136
      htab->sgotplt = s;
137
    }
138
 
139
  /* The first bit of the global offset table is the header.  */
140
  s->size += bed->got_header_size;
141
 
142
  if (bed->want_got_sym)
143
    {
144
      /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
145
         (or .got.plt) section.  We don't do this in the linker script
146
         because we don't want to define the symbol if we are not creating
147
         a global offset table.  */
148
      h = _bfd_elf_define_linkage_sym (abfd, info, s,
149
                                       "_GLOBAL_OFFSET_TABLE_");
150
      elf_hash_table (info)->hgot = h;
151
      if (h == NULL)
152
        return FALSE;
153
    }
154
 
155
  return TRUE;
156
}
157
 
158
/* Create a strtab to hold the dynamic symbol names.  */
159
static bfd_boolean
160
_bfd_elf_link_create_dynstrtab (bfd *abfd, struct bfd_link_info *info)
161
{
162
  struct elf_link_hash_table *hash_table;
163
 
164
  hash_table = elf_hash_table (info);
165
  if (hash_table->dynobj == NULL)
166
    hash_table->dynobj = abfd;
167
 
168
  if (hash_table->dynstr == NULL)
169
    {
170
      hash_table->dynstr = _bfd_elf_strtab_init ();
171
      if (hash_table->dynstr == NULL)
172
        return FALSE;
173
    }
174
  return TRUE;
175
}
176
 
177
/* Create some sections which will be filled in with dynamic linking
178
   information.  ABFD is an input file which requires dynamic sections
179
   to be created.  The dynamic sections take up virtual memory space
180
   when the final executable is run, so we need to create them before
181
   addresses are assigned to the output sections.  We work out the
182
   actual contents and size of these sections later.  */
183
 
184
bfd_boolean
185
_bfd_elf_link_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
186
{
187
  flagword flags;
188
  asection *s;
189
  const struct elf_backend_data *bed;
190
 
191
  if (! is_elf_hash_table (info->hash))
192
    return FALSE;
193
 
194
  if (elf_hash_table (info)->dynamic_sections_created)
195
    return TRUE;
196
 
197
  if (!_bfd_elf_link_create_dynstrtab (abfd, info))
198
    return FALSE;
199
 
200
  abfd = elf_hash_table (info)->dynobj;
201
  bed = get_elf_backend_data (abfd);
202
 
203
  flags = bed->dynamic_sec_flags;
204
 
205
  /* A dynamically linked executable has a .interp section, but a
206
     shared library does not.  */
207
  if (info->executable)
208
    {
209 166 khays
      s = bfd_make_section_anyway_with_flags (abfd, ".interp",
210
                                              flags | SEC_READONLY);
211 14 khays
      if (s == NULL)
212
        return FALSE;
213
    }
214
 
215
  /* Create sections to hold version informations.  These are removed
216
     if they are not needed.  */
217 166 khays
  s = bfd_make_section_anyway_with_flags (abfd, ".gnu.version_d",
218
                                          flags | SEC_READONLY);
219 14 khays
  if (s == NULL
220
      || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
221
    return FALSE;
222
 
223 166 khays
  s = bfd_make_section_anyway_with_flags (abfd, ".gnu.version",
224
                                          flags | SEC_READONLY);
225 14 khays
  if (s == NULL
226
      || ! bfd_set_section_alignment (abfd, s, 1))
227
    return FALSE;
228
 
229 166 khays
  s = bfd_make_section_anyway_with_flags (abfd, ".gnu.version_r",
230
                                          flags | SEC_READONLY);
231 14 khays
  if (s == NULL
232
      || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
233
    return FALSE;
234
 
235 166 khays
  s = bfd_make_section_anyway_with_flags (abfd, ".dynsym",
236
                                          flags | SEC_READONLY);
237 14 khays
  if (s == NULL
238
      || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
239
    return FALSE;
240
 
241 166 khays
  s = bfd_make_section_anyway_with_flags (abfd, ".dynstr",
242
                                          flags | SEC_READONLY);
243 14 khays
  if (s == NULL)
244
    return FALSE;
245
 
246 166 khays
  s = bfd_make_section_anyway_with_flags (abfd, ".dynamic", flags);
247 14 khays
  if (s == NULL
248
      || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
249
    return FALSE;
250
 
251
  /* The special symbol _DYNAMIC is always set to the start of the
252
     .dynamic section.  We could set _DYNAMIC in a linker script, but we
253
     only want to define it if we are, in fact, creating a .dynamic
254
     section.  We don't want to define it if there is no .dynamic
255
     section, since on some ELF platforms the start up code examines it
256
     to decide how to initialize the process.  */
257
  if (!_bfd_elf_define_linkage_sym (abfd, info, s, "_DYNAMIC"))
258
    return FALSE;
259
 
260
  if (info->emit_hash)
261
    {
262 166 khays
      s = bfd_make_section_anyway_with_flags (abfd, ".hash",
263
                                              flags | SEC_READONLY);
264 14 khays
      if (s == NULL
265
          || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
266
        return FALSE;
267
      elf_section_data (s)->this_hdr.sh_entsize = bed->s->sizeof_hash_entry;
268
    }
269
 
270
  if (info->emit_gnu_hash)
271
    {
272 166 khays
      s = bfd_make_section_anyway_with_flags (abfd, ".gnu.hash",
273
                                              flags | SEC_READONLY);
274 14 khays
      if (s == NULL
275
          || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
276
        return FALSE;
277
      /* For 64-bit ELF, .gnu.hash is a non-uniform entity size section:
278
         4 32-bit words followed by variable count of 64-bit words, then
279
         variable count of 32-bit words.  */
280
      if (bed->s->arch_size == 64)
281
        elf_section_data (s)->this_hdr.sh_entsize = 0;
282
      else
283
        elf_section_data (s)->this_hdr.sh_entsize = 4;
284
    }
285
 
286
  /* Let the backend create the rest of the sections.  This lets the
287
     backend set the right flags.  The backend will normally create
288
     the .got and .plt sections.  */
289 148 khays
  if (bed->elf_backend_create_dynamic_sections == NULL
290
      || ! (*bed->elf_backend_create_dynamic_sections) (abfd, info))
291 14 khays
    return FALSE;
292
 
293
  elf_hash_table (info)->dynamic_sections_created = TRUE;
294
 
295
  return TRUE;
296
}
297
 
298
/* Create dynamic sections when linking against a dynamic object.  */
299
 
300
bfd_boolean
301
_bfd_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
302
{
303
  flagword flags, pltflags;
304
  struct elf_link_hash_entry *h;
305
  asection *s;
306
  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
307
  struct elf_link_hash_table *htab = elf_hash_table (info);
308
 
309
  /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
310
     .rel[a].bss sections.  */
311
  flags = bed->dynamic_sec_flags;
312
 
313
  pltflags = flags;
314
  if (bed->plt_not_loaded)
315
    /* We do not clear SEC_ALLOC here because we still want the OS to
316
       allocate space for the section; it's just that there's nothing
317
       to read in from the object file.  */
318
    pltflags &= ~ (SEC_CODE | SEC_LOAD | SEC_HAS_CONTENTS);
319
  else
320
    pltflags |= SEC_ALLOC | SEC_CODE | SEC_LOAD;
321
  if (bed->plt_readonly)
322
    pltflags |= SEC_READONLY;
323
 
324 166 khays
  s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags);
325 14 khays
  if (s == NULL
326
      || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
327
    return FALSE;
328
  htab->splt = s;
329
 
330
  /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
331
     .plt section.  */
332
  if (bed->want_plt_sym)
333
    {
334
      h = _bfd_elf_define_linkage_sym (abfd, info, s,
335
                                       "_PROCEDURE_LINKAGE_TABLE_");
336
      elf_hash_table (info)->hplt = h;
337
      if (h == NULL)
338
        return FALSE;
339
    }
340
 
341 166 khays
  s = bfd_make_section_anyway_with_flags (abfd,
342
                                          (bed->rela_plts_and_copies_p
343
                                           ? ".rela.plt" : ".rel.plt"),
344
                                          flags | SEC_READONLY);
345 14 khays
  if (s == NULL
346
      || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
347
    return FALSE;
348
  htab->srelplt = s;
349
 
350
  if (! _bfd_elf_create_got_section (abfd, info))
351
    return FALSE;
352
 
353
  if (bed->want_dynbss)
354
    {
355
      /* The .dynbss section is a place to put symbols which are defined
356
         by dynamic objects, are referenced by regular objects, and are
357
         not functions.  We must allocate space for them in the process
358
         image and use a R_*_COPY reloc to tell the dynamic linker to
359
         initialize them at run time.  The linker script puts the .dynbss
360
         section into the .bss section of the final image.  */
361 166 khays
      s = bfd_make_section_anyway_with_flags (abfd, ".dynbss",
362
                                              (SEC_ALLOC | SEC_LINKER_CREATED));
363 14 khays
      if (s == NULL)
364
        return FALSE;
365
 
366
      /* The .rel[a].bss section holds copy relocs.  This section is not
367
         normally needed.  We need to create it here, though, so that the
368
         linker will map it to an output section.  We can't just create it
369
         only if we need it, because we will not know whether we need it
370
         until we have seen all the input files, and the first time the
371
         main linker code calls BFD after examining all the input files
372
         (size_dynamic_sections) the input sections have already been
373
         mapped to the output sections.  If the section turns out not to
374
         be needed, we can discard it later.  We will never need this
375
         section when generating a shared object, since they do not use
376
         copy relocs.  */
377
      if (! info->shared)
378
        {
379 166 khays
          s = bfd_make_section_anyway_with_flags (abfd,
380
                                                  (bed->rela_plts_and_copies_p
381
                                                   ? ".rela.bss" : ".rel.bss"),
382
                                                  flags | SEC_READONLY);
383 14 khays
          if (s == NULL
384
              || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
385
            return FALSE;
386
        }
387
    }
388
 
389
  return TRUE;
390
}
391
 
392
/* Record a new dynamic symbol.  We record the dynamic symbols as we
393
   read the input files, since we need to have a list of all of them
394
   before we can determine the final sizes of the output sections.
395
   Note that we may actually call this function even though we are not
396
   going to output any dynamic symbols; in some cases we know that a
397
   symbol should be in the dynamic symbol table, but only if there is
398
   one.  */
399
 
400
bfd_boolean
401
bfd_elf_link_record_dynamic_symbol (struct bfd_link_info *info,
402
                                    struct elf_link_hash_entry *h)
403
{
404
  if (h->dynindx == -1)
405
    {
406
      struct elf_strtab_hash *dynstr;
407
      char *p;
408
      const char *name;
409
      bfd_size_type indx;
410
 
411
      /* XXX: The ABI draft says the linker must turn hidden and
412
         internal symbols into STB_LOCAL symbols when producing the
413
         DSO. However, if ld.so honors st_other in the dynamic table,
414
         this would not be necessary.  */
415
      switch (ELF_ST_VISIBILITY (h->other))
416
        {
417
        case STV_INTERNAL:
418
        case STV_HIDDEN:
419
          if (h->root.type != bfd_link_hash_undefined
420
              && h->root.type != bfd_link_hash_undefweak)
421
            {
422
              h->forced_local = 1;
423
              if (!elf_hash_table (info)->is_relocatable_executable)
424
                return TRUE;
425
            }
426
 
427
        default:
428
          break;
429
        }
430
 
431
      h->dynindx = elf_hash_table (info)->dynsymcount;
432
      ++elf_hash_table (info)->dynsymcount;
433
 
434
      dynstr = elf_hash_table (info)->dynstr;
435
      if (dynstr == NULL)
436
        {
437
          /* Create a strtab to hold the dynamic symbol names.  */
438
          elf_hash_table (info)->dynstr = dynstr = _bfd_elf_strtab_init ();
439
          if (dynstr == NULL)
440
            return FALSE;
441
        }
442
 
443
      /* We don't put any version information in the dynamic string
444
         table.  */
445
      name = h->root.root.string;
446
      p = strchr (name, ELF_VER_CHR);
447
      if (p != NULL)
448
        /* We know that the p points into writable memory.  In fact,
449
           there are only a few symbols that have read-only names, being
450
           those like _GLOBAL_OFFSET_TABLE_ that are created specially
451
           by the backends.  Most symbols will have names pointing into
452
           an ELF string table read from a file, or to objalloc memory.  */
453
        *p = 0;
454
 
455
      indx = _bfd_elf_strtab_add (dynstr, name, p != NULL);
456
 
457
      if (p != NULL)
458
        *p = ELF_VER_CHR;
459
 
460
      if (indx == (bfd_size_type) -1)
461
        return FALSE;
462
      h->dynstr_index = indx;
463
    }
464
 
465
  return TRUE;
466
}
467
 
468
/* Mark a symbol dynamic.  */
469
 
470
static void
471
bfd_elf_link_mark_dynamic_symbol (struct bfd_link_info *info,
472
                                  struct elf_link_hash_entry *h,
473
                                  Elf_Internal_Sym *sym)
474
{
475
  struct bfd_elf_dynamic_list *d = info->dynamic_list;
476
 
477
  /* It may be called more than once on the same H.  */
478
  if(h->dynamic || info->relocatable)
479
    return;
480
 
481
  if ((info->dynamic_data
482
       && (h->type == STT_OBJECT
483
           || (sym != NULL
484
               && ELF_ST_TYPE (sym->st_info) == STT_OBJECT)))
485
      || (d != NULL
486
          && h->root.type == bfd_link_hash_new
487
          && (*d->match) (&d->head, NULL, h->root.root.string)))
488
    h->dynamic = 1;
489
}
490
 
491
/* Record an assignment to a symbol made by a linker script.  We need
492
   this in case some dynamic object refers to this symbol.  */
493
 
494
bfd_boolean
495
bfd_elf_record_link_assignment (bfd *output_bfd,
496
                                struct bfd_link_info *info,
497
                                const char *name,
498
                                bfd_boolean provide,
499
                                bfd_boolean hidden)
500
{
501
  struct elf_link_hash_entry *h, *hv;
502
  struct elf_link_hash_table *htab;
503
  const struct elf_backend_data *bed;
504
 
505
  if (!is_elf_hash_table (info->hash))
506
    return TRUE;
507
 
508
  htab = elf_hash_table (info);
509
  h = elf_link_hash_lookup (htab, name, !provide, TRUE, FALSE);
510
  if (h == NULL)
511
    return provide;
512
 
513
  switch (h->root.type)
514
    {
515
    case bfd_link_hash_defined:
516
    case bfd_link_hash_defweak:
517
    case bfd_link_hash_common:
518
      break;
519
    case bfd_link_hash_undefweak:
520
    case bfd_link_hash_undefined:
521
      /* Since we're defining the symbol, don't let it seem to have not
522
         been defined.  record_dynamic_symbol and size_dynamic_sections
523
         may depend on this.  */
524
      h->root.type = bfd_link_hash_new;
525
      if (h->root.u.undef.next != NULL || htab->root.undefs_tail == &h->root)
526
        bfd_link_repair_undef_list (&htab->root);
527
      break;
528
    case bfd_link_hash_new:
529
      bfd_elf_link_mark_dynamic_symbol (info, h, NULL);
530
      h->non_elf = 0;
531
      break;
532
    case bfd_link_hash_indirect:
533
      /* We had a versioned symbol in a dynamic library.  We make the
534
         the versioned symbol point to this one.  */
535
      bed = get_elf_backend_data (output_bfd);
536
      hv = h;
537
      while (hv->root.type == bfd_link_hash_indirect
538
             || hv->root.type == bfd_link_hash_warning)
539
        hv = (struct elf_link_hash_entry *) hv->root.u.i.link;
540
      /* We don't need to update h->root.u since linker will set them
541
         later.  */
542
      h->root.type = bfd_link_hash_undefined;
543
      hv->root.type = bfd_link_hash_indirect;
544
      hv->root.u.i.link = (struct bfd_link_hash_entry *) h;
545
      (*bed->elf_backend_copy_indirect_symbol) (info, h, hv);
546
      break;
547
    case bfd_link_hash_warning:
548
      abort ();
549
      break;
550
    }
551
 
552
  /* If this symbol is being provided by the linker script, and it is
553
     currently defined by a dynamic object, but not by a regular
554
     object, then mark it as undefined so that the generic linker will
555
     force the correct value.  */
556
  if (provide
557
      && h->def_dynamic
558
      && !h->def_regular)
559
    h->root.type = bfd_link_hash_undefined;
560
 
561
  /* If this symbol is not being provided by the linker script, and it is
562
     currently defined by a dynamic object, but not by a regular object,
563
     then clear out any version information because the symbol will not be
564
     associated with the dynamic object any more.  */
565
  if (!provide
566
      && h->def_dynamic
567
      && !h->def_regular)
568
    h->verinfo.verdef = NULL;
569
 
570
  h->def_regular = 1;
571
 
572
  if (provide && hidden)
573
    {
574
      bed = get_elf_backend_data (output_bfd);
575
      h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN;
576
      (*bed->elf_backend_hide_symbol) (info, h, TRUE);
577
    }
578
 
579
  /* STV_HIDDEN and STV_INTERNAL symbols must be STB_LOCAL in shared objects
580
     and executables.  */
581
  if (!info->relocatable
582
      && h->dynindx != -1
583
      && (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
584
          || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL))
585
    h->forced_local = 1;
586
 
587
  if ((h->def_dynamic
588
       || h->ref_dynamic
589
       || info->shared
590
       || (info->executable && elf_hash_table (info)->is_relocatable_executable))
591
      && h->dynindx == -1)
592
    {
593
      if (! bfd_elf_link_record_dynamic_symbol (info, h))
594
        return FALSE;
595
 
596
      /* If this is a weak defined symbol, and we know a corresponding
597
         real symbol from the same dynamic object, make sure the real
598
         symbol is also made into a dynamic symbol.  */
599
      if (h->u.weakdef != NULL
600
          && h->u.weakdef->dynindx == -1)
601
        {
602
          if (! bfd_elf_link_record_dynamic_symbol (info, h->u.weakdef))
603
            return FALSE;
604
        }
605
    }
606
 
607
  return TRUE;
608
}
609
 
610
/* Record a new local dynamic symbol.  Returns 0 on failure, 1 on
611
   success, and 2 on a failure caused by attempting to record a symbol
612
   in a discarded section, eg. a discarded link-once section symbol.  */
613
 
614
int
615
bfd_elf_link_record_local_dynamic_symbol (struct bfd_link_info *info,
616
                                          bfd *input_bfd,
617
                                          long input_indx)
618
{
619
  bfd_size_type amt;
620
  struct elf_link_local_dynamic_entry *entry;
621
  struct elf_link_hash_table *eht;
622
  struct elf_strtab_hash *dynstr;
623
  unsigned long dynstr_index;
624
  char *name;
625
  Elf_External_Sym_Shndx eshndx;
626
  char esym[sizeof (Elf64_External_Sym)];
627
 
628
  if (! is_elf_hash_table (info->hash))
629
    return 0;
630
 
631
  /* See if the entry exists already.  */
632
  for (entry = elf_hash_table (info)->dynlocal; entry ; entry = entry->next)
633
    if (entry->input_bfd == input_bfd && entry->input_indx == input_indx)
634
      return 1;
635
 
636
  amt = sizeof (*entry);
637
  entry = (struct elf_link_local_dynamic_entry *) bfd_alloc (input_bfd, amt);
638
  if (entry == NULL)
639
    return 0;
640
 
641
  /* Go find the symbol, so that we can find it's name.  */
642
  if (!bfd_elf_get_elf_syms (input_bfd, &elf_tdata (input_bfd)->symtab_hdr,
643
                             1, input_indx, &entry->isym, esym, &eshndx))
644
    {
645
      bfd_release (input_bfd, entry);
646
      return 0;
647
    }
648
 
649
  if (entry->isym.st_shndx != SHN_UNDEF
650
      && entry->isym.st_shndx < SHN_LORESERVE)
651
    {
652
      asection *s;
653
 
654
      s = bfd_section_from_elf_index (input_bfd, entry->isym.st_shndx);
655
      if (s == NULL || bfd_is_abs_section (s->output_section))
656
        {
657
          /* We can still bfd_release here as nothing has done another
658
             bfd_alloc.  We can't do this later in this function.  */
659
          bfd_release (input_bfd, entry);
660
          return 2;
661
        }
662
    }
663
 
664
  name = (bfd_elf_string_from_elf_section
665
          (input_bfd, elf_tdata (input_bfd)->symtab_hdr.sh_link,
666
           entry->isym.st_name));
667
 
668
  dynstr = elf_hash_table (info)->dynstr;
669
  if (dynstr == NULL)
670
    {
671
      /* Create a strtab to hold the dynamic symbol names.  */
672
      elf_hash_table (info)->dynstr = dynstr = _bfd_elf_strtab_init ();
673
      if (dynstr == NULL)
674
        return 0;
675
    }
676
 
677
  dynstr_index = _bfd_elf_strtab_add (dynstr, name, FALSE);
678
  if (dynstr_index == (unsigned long) -1)
679
    return 0;
680
  entry->isym.st_name = dynstr_index;
681
 
682
  eht = elf_hash_table (info);
683
 
684
  entry->next = eht->dynlocal;
685
  eht->dynlocal = entry;
686
  entry->input_bfd = input_bfd;
687
  entry->input_indx = input_indx;
688
  eht->dynsymcount++;
689
 
690
  /* Whatever binding the symbol had before, it's now local.  */
691
  entry->isym.st_info
692
    = ELF_ST_INFO (STB_LOCAL, ELF_ST_TYPE (entry->isym.st_info));
693
 
694
  /* The dynindx will be set at the end of size_dynamic_sections.  */
695
 
696
  return 1;
697
}
698
 
699
/* Return the dynindex of a local dynamic symbol.  */
700
 
701
long
702
_bfd_elf_link_lookup_local_dynindx (struct bfd_link_info *info,
703
                                    bfd *input_bfd,
704
                                    long input_indx)
705
{
706
  struct elf_link_local_dynamic_entry *e;
707
 
708
  for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
709
    if (e->input_bfd == input_bfd && e->input_indx == input_indx)
710
      return e->dynindx;
711
  return -1;
712
}
713
 
714
/* This function is used to renumber the dynamic symbols, if some of
715
   them are removed because they are marked as local.  This is called
716
   via elf_link_hash_traverse.  */
717
 
718
static bfd_boolean
719
elf_link_renumber_hash_table_dynsyms (struct elf_link_hash_entry *h,
720
                                      void *data)
721
{
722
  size_t *count = (size_t *) data;
723
 
724
  if (h->forced_local)
725
    return TRUE;
726
 
727
  if (h->dynindx != -1)
728
    h->dynindx = ++(*count);
729
 
730
  return TRUE;
731
}
732
 
733
 
734
/* Like elf_link_renumber_hash_table_dynsyms, but just number symbols with
735
   STB_LOCAL binding.  */
736
 
737
static bfd_boolean
738
elf_link_renumber_local_hash_table_dynsyms (struct elf_link_hash_entry *h,
739
                                            void *data)
740
{
741
  size_t *count = (size_t *) data;
742
 
743
  if (!h->forced_local)
744
    return TRUE;
745
 
746
  if (h->dynindx != -1)
747
    h->dynindx = ++(*count);
748
 
749
  return TRUE;
750
}
751
 
752
/* Return true if the dynamic symbol for a given section should be
753
   omitted when creating a shared library.  */
754
bfd_boolean
755
_bfd_elf_link_omit_section_dynsym (bfd *output_bfd ATTRIBUTE_UNUSED,
756
                                   struct bfd_link_info *info,
757
                                   asection *p)
758
{
759
  struct elf_link_hash_table *htab;
760
 
761
  switch (elf_section_data (p)->this_hdr.sh_type)
762
    {
763
    case SHT_PROGBITS:
764
    case SHT_NOBITS:
765
      /* If sh_type is yet undecided, assume it could be
766
         SHT_PROGBITS/SHT_NOBITS.  */
767
    case SHT_NULL:
768
      htab = elf_hash_table (info);
769
      if (p == htab->tls_sec)
770
        return FALSE;
771
 
772
      if (htab->text_index_section != NULL)
773
        return p != htab->text_index_section && p != htab->data_index_section;
774
 
775
      if (strcmp (p->name, ".got") == 0
776
          || strcmp (p->name, ".got.plt") == 0
777
          || strcmp (p->name, ".plt") == 0)
778
        {
779
          asection *ip;
780
 
781
          if (htab->dynobj != NULL
782
              && (ip = bfd_get_section_by_name (htab->dynobj, p->name)) != NULL
783
              && (ip->flags & SEC_LINKER_CREATED)
784
              && ip->output_section == p)
785
            return TRUE;
786
        }
787
      return FALSE;
788
 
789
      /* There shouldn't be section relative relocations
790
         against any other section.  */
791
    default:
792
      return TRUE;
793
    }
794
}
795
 
796
/* Assign dynsym indices.  In a shared library we generate a section
797
   symbol for each output section, which come first.  Next come symbols
798
   which have been forced to local binding.  Then all of the back-end
799
   allocated local dynamic syms, followed by the rest of the global
800
   symbols.  */
801
 
802
static unsigned long
803
_bfd_elf_link_renumber_dynsyms (bfd *output_bfd,
804
                                struct bfd_link_info *info,
805
                                unsigned long *section_sym_count)
806
{
807
  unsigned long dynsymcount = 0;
808
 
809
  if (info->shared || elf_hash_table (info)->is_relocatable_executable)
810
    {
811
      const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
812
      asection *p;
813
      for (p = output_bfd->sections; p ; p = p->next)
814
        if ((p->flags & SEC_EXCLUDE) == 0
815
            && (p->flags & SEC_ALLOC) != 0
816
            && !(*bed->elf_backend_omit_section_dynsym) (output_bfd, info, p))
817
          elf_section_data (p)->dynindx = ++dynsymcount;
818
        else
819
          elf_section_data (p)->dynindx = 0;
820
    }
821
  *section_sym_count = dynsymcount;
822
 
823
  elf_link_hash_traverse (elf_hash_table (info),
824
                          elf_link_renumber_local_hash_table_dynsyms,
825
                          &dynsymcount);
826
 
827
  if (elf_hash_table (info)->dynlocal)
828
    {
829
      struct elf_link_local_dynamic_entry *p;
830
      for (p = elf_hash_table (info)->dynlocal; p ; p = p->next)
831
        p->dynindx = ++dynsymcount;
832
    }
833
 
834
  elf_link_hash_traverse (elf_hash_table (info),
835
                          elf_link_renumber_hash_table_dynsyms,
836
                          &dynsymcount);
837
 
838
  /* There is an unused NULL entry at the head of the table which
839
     we must account for in our count.  Unless there weren't any
840
     symbols, which means we'll have no table at all.  */
841
  if (dynsymcount != 0)
842
    ++dynsymcount;
843
 
844
  elf_hash_table (info)->dynsymcount = dynsymcount;
845
  return dynsymcount;
846
}
847
 
848
/* Merge st_other field.  */
849
 
850
static void
851
elf_merge_st_other (bfd *abfd, struct elf_link_hash_entry *h,
852
                    Elf_Internal_Sym *isym, bfd_boolean definition,
853
                    bfd_boolean dynamic)
854
{
855
  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
856
 
857
  /* If st_other has a processor-specific meaning, specific
858
     code might be needed here. We never merge the visibility
859
     attribute with the one from a dynamic object.  */
860
  if (bed->elf_backend_merge_symbol_attribute)
861
    (*bed->elf_backend_merge_symbol_attribute) (h, isym, definition,
862
                                                dynamic);
863
 
864
  /* If this symbol has default visibility and the user has requested
865
     we not re-export it, then mark it as hidden.  */
866
  if (definition
867
      && !dynamic
868
      && (abfd->no_export
869
          || (abfd->my_archive && abfd->my_archive->no_export))
870
      && ELF_ST_VISIBILITY (isym->st_other) != STV_INTERNAL)
871
    isym->st_other = (STV_HIDDEN
872
                      | (isym->st_other & ~ELF_ST_VISIBILITY (-1)));
873
 
874
  if (!dynamic && ELF_ST_VISIBILITY (isym->st_other) != 0)
875
    {
876
      unsigned char hvis, symvis, other, nvis;
877
 
878
      /* Only merge the visibility. Leave the remainder of the
879
         st_other field to elf_backend_merge_symbol_attribute.  */
880
      other = h->other & ~ELF_ST_VISIBILITY (-1);
881
 
882
      /* Combine visibilities, using the most constraining one.  */
883
      hvis = ELF_ST_VISIBILITY (h->other);
884
      symvis = ELF_ST_VISIBILITY (isym->st_other);
885
      if (! hvis)
886
        nvis = symvis;
887
      else if (! symvis)
888
        nvis = hvis;
889
      else
890
        nvis = hvis < symvis ? hvis : symvis;
891
 
892
      h->other = other | nvis;
893
    }
894
}
895
 
896
/* This function is called when we want to define a new symbol.  It
897
   handles the various cases which arise when we find a definition in
898
   a dynamic object, or when there is already a definition in a
899
   dynamic object.  The new symbol is described by NAME, SYM, PSEC,
900
   and PVALUE.  We set SYM_HASH to the hash table entry.  We set
901
   OVERRIDE if the old symbol is overriding a new definition.  We set
902
   TYPE_CHANGE_OK if it is OK for the type to change.  We set
903
   SIZE_CHANGE_OK if it is OK for the size to change.  By OK to
904
   change, we mean that we shouldn't warn if the type or size does
905
   change.  We set POLD_ALIGNMENT if an old common symbol in a dynamic
906
   object is overridden by a regular object.  */
907
 
908
bfd_boolean
909
_bfd_elf_merge_symbol (bfd *abfd,
910
                       struct bfd_link_info *info,
911
                       const char *name,
912
                       Elf_Internal_Sym *sym,
913
                       asection **psec,
914
                       bfd_vma *pvalue,
915
                       unsigned int *pold_alignment,
916
                       struct elf_link_hash_entry **sym_hash,
917
                       bfd_boolean *skip,
918
                       bfd_boolean *override,
919
                       bfd_boolean *type_change_ok,
920
                       bfd_boolean *size_change_ok)
921
{
922
  asection *sec, *oldsec;
923
  struct elf_link_hash_entry *h;
924
  struct elf_link_hash_entry *flip;
925
  int bind;
926
  bfd *oldbfd;
927
  bfd_boolean newdyn, olddyn, olddef, newdef, newdyncommon, olddyncommon;
928
  bfd_boolean newweak, oldweak, newfunc, oldfunc;
929
  const struct elf_backend_data *bed;
930
 
931
  *skip = FALSE;
932
  *override = FALSE;
933
 
934
  sec = *psec;
935
  bind = ELF_ST_BIND (sym->st_info);
936
 
937
  /* Silently discard TLS symbols from --just-syms.  There's no way to
938
     combine a static TLS block with a new TLS block for this executable.  */
939
  if (ELF_ST_TYPE (sym->st_info) == STT_TLS
940
      && sec->sec_info_type == ELF_INFO_TYPE_JUST_SYMS)
941
    {
942
      *skip = TRUE;
943
      return TRUE;
944
    }
945
 
946
  if (! bfd_is_und_section (sec))
947
    h = elf_link_hash_lookup (elf_hash_table (info), name, TRUE, FALSE, FALSE);
948
  else
949
    h = ((struct elf_link_hash_entry *)
950
         bfd_wrapped_link_hash_lookup (abfd, info, name, TRUE, FALSE, FALSE));
951
  if (h == NULL)
952
    return FALSE;
953
  *sym_hash = h;
954
 
955
  bed = get_elf_backend_data (abfd);
956
 
957
  /* This code is for coping with dynamic objects, and is only useful
958
     if we are doing an ELF link.  */
959
  if (!(*bed->relocs_compatible) (abfd->xvec, info->output_bfd->xvec))
960
    return TRUE;
961
 
962
  /* For merging, we only care about real symbols.  */
963
 
964
  while (h->root.type == bfd_link_hash_indirect
965
         || h->root.type == bfd_link_hash_warning)
966
    h = (struct elf_link_hash_entry *) h->root.u.i.link;
967
 
968
  /* We have to check it for every instance since the first few may be
969
     refereences and not all compilers emit symbol type for undefined
970
     symbols.  */
971
  bfd_elf_link_mark_dynamic_symbol (info, h, sym);
972
 
973
  /* If we just created the symbol, mark it as being an ELF symbol.
974
     Other than that, there is nothing to do--there is no merge issue
975
     with a newly defined symbol--so we just return.  */
976
 
977
  if (h->root.type == bfd_link_hash_new)
978
    {
979
      h->non_elf = 0;
980
      return TRUE;
981
    }
982
 
983
  /* OLDBFD and OLDSEC are a BFD and an ASECTION associated with the
984
     existing symbol.  */
985
 
986
  switch (h->root.type)
987
    {
988
    default:
989
      oldbfd = NULL;
990
      oldsec = NULL;
991
      break;
992
 
993
    case bfd_link_hash_undefined:
994
    case bfd_link_hash_undefweak:
995
      oldbfd = h->root.u.undef.abfd;
996
      oldsec = NULL;
997
      break;
998
 
999
    case bfd_link_hash_defined:
1000
    case bfd_link_hash_defweak:
1001
      oldbfd = h->root.u.def.section->owner;
1002
      oldsec = h->root.u.def.section;
1003
      break;
1004
 
1005
    case bfd_link_hash_common:
1006
      oldbfd = h->root.u.c.p->section->owner;
1007
      oldsec = h->root.u.c.p->section;
1008
      break;
1009
    }
1010
 
1011
  /* Differentiate strong and weak symbols.  */
1012
  newweak = bind == STB_WEAK;
1013
  oldweak = (h->root.type == bfd_link_hash_defweak
1014
             || h->root.type == bfd_link_hash_undefweak);
1015
 
1016
  /* In cases involving weak versioned symbols, we may wind up trying
1017
     to merge a symbol with itself.  Catch that here, to avoid the
1018
     confusion that results if we try to override a symbol with
1019
     itself.  The additional tests catch cases like
1020
     _GLOBAL_OFFSET_TABLE_, which are regular symbols defined in a
1021
     dynamic object, which we do want to handle here.  */
1022
  if (abfd == oldbfd
1023
      && (newweak || oldweak)
1024
      && ((abfd->flags & DYNAMIC) == 0
1025
          || !h->def_regular))
1026
    return TRUE;
1027
 
1028
  /* NEWDYN and OLDDYN indicate whether the new or old symbol,
1029
     respectively, is from a dynamic object.  */
1030
 
1031
  newdyn = (abfd->flags & DYNAMIC) != 0;
1032
 
1033
  olddyn = FALSE;
1034
  if (oldbfd != NULL)
1035
    olddyn = (oldbfd->flags & DYNAMIC) != 0;
1036
  else if (oldsec != NULL)
1037
    {
1038
      /* This handles the special SHN_MIPS_{TEXT,DATA} section
1039
         indices used by MIPS ELF.  */
1040
      olddyn = (oldsec->symbol->flags & BSF_DYNAMIC) != 0;
1041
    }
1042
 
1043
  /* NEWDEF and OLDDEF indicate whether the new or old symbol,
1044
     respectively, appear to be a definition rather than reference.  */
1045
 
1046
  newdef = !bfd_is_und_section (sec) && !bfd_is_com_section (sec);
1047
 
1048
  olddef = (h->root.type != bfd_link_hash_undefined
1049
            && h->root.type != bfd_link_hash_undefweak
1050
            && h->root.type != bfd_link_hash_common);
1051
 
1052
  /* NEWFUNC and OLDFUNC indicate whether the new or old symbol,
1053
     respectively, appear to be a function.  */
1054
 
1055
  newfunc = (ELF_ST_TYPE (sym->st_info) != STT_NOTYPE
1056
             && bed->is_function_type (ELF_ST_TYPE (sym->st_info)));
1057
 
1058
  oldfunc = (h->type != STT_NOTYPE
1059
             && bed->is_function_type (h->type));
1060
 
1061
  /* When we try to create a default indirect symbol from the dynamic
1062
     definition with the default version, we skip it if its type and
1063
     the type of existing regular definition mismatch.  We only do it
1064
     if the existing regular definition won't be dynamic.  */
1065
  if (pold_alignment == NULL
1066
      && !info->shared
1067
      && !info->export_dynamic
1068
      && !h->ref_dynamic
1069
      && newdyn
1070
      && newdef
1071
      && !olddyn
1072
      && (olddef || h->root.type == bfd_link_hash_common)
1073
      && ELF_ST_TYPE (sym->st_info) != h->type
1074
      && ELF_ST_TYPE (sym->st_info) != STT_NOTYPE
1075
      && h->type != STT_NOTYPE
1076
      && !(newfunc && oldfunc))
1077
    {
1078
      *skip = TRUE;
1079
      return TRUE;
1080
    }
1081
 
1082 161 khays
  /* Plugin symbol type isn't currently set.  Stop bogus errors.  */
1083
  if (oldbfd != NULL && (oldbfd->flags & BFD_PLUGIN) != 0)
1084
    *type_change_ok = TRUE;
1085
 
1086 14 khays
  /* Check TLS symbol.  We don't check undefined symbol introduced by
1087
     "ld -u".  */
1088 161 khays
  else if (oldbfd != NULL
1089
           && ELF_ST_TYPE (sym->st_info) != h->type
1090
           && (ELF_ST_TYPE (sym->st_info) == STT_TLS || h->type == STT_TLS))
1091 14 khays
    {
1092
      bfd *ntbfd, *tbfd;
1093
      bfd_boolean ntdef, tdef;
1094
      asection *ntsec, *tsec;
1095
 
1096
      if (h->type == STT_TLS)
1097
        {
1098
          ntbfd = abfd;
1099
          ntsec = sec;
1100
          ntdef = newdef;
1101
          tbfd = oldbfd;
1102
          tsec = oldsec;
1103
          tdef = olddef;
1104
        }
1105
      else
1106
        {
1107
          ntbfd = oldbfd;
1108
          ntsec = oldsec;
1109
          ntdef = olddef;
1110
          tbfd = abfd;
1111
          tsec = sec;
1112
          tdef = newdef;
1113
        }
1114
 
1115
      if (tdef && ntdef)
1116
        (*_bfd_error_handler)
1117
          (_("%s: TLS definition in %B section %A mismatches non-TLS definition in %B section %A"),
1118
           tbfd, tsec, ntbfd, ntsec, h->root.root.string);
1119
      else if (!tdef && !ntdef)
1120
        (*_bfd_error_handler)
1121
          (_("%s: TLS reference in %B mismatches non-TLS reference in %B"),
1122
           tbfd, ntbfd, h->root.root.string);
1123
      else if (tdef)
1124
        (*_bfd_error_handler)
1125
          (_("%s: TLS definition in %B section %A mismatches non-TLS reference in %B"),
1126
           tbfd, tsec, ntbfd, h->root.root.string);
1127
      else
1128
        (*_bfd_error_handler)
1129
          (_("%s: TLS reference in %B mismatches non-TLS definition in %B section %A"),
1130
           tbfd, ntbfd, ntsec, h->root.root.string);
1131
 
1132
      bfd_set_error (bfd_error_bad_value);
1133
      return FALSE;
1134
    }
1135
 
1136
  /* We need to remember if a symbol has a definition in a dynamic
1137
     object or is weak in all dynamic objects. Internal and hidden
1138
     visibility will make it unavailable to dynamic objects.  */
1139
  if (newdyn && !h->dynamic_def)
1140
    {
1141
      if (!bfd_is_und_section (sec))
1142
        h->dynamic_def = 1;
1143
      else
1144
        {
1145
          /* Check if this symbol is weak in all dynamic objects. If it
1146
             is the first time we see it in a dynamic object, we mark
1147
             if it is weak. Otherwise, we clear it.  */
1148
          if (!h->ref_dynamic)
1149
            {
1150
              if (bind == STB_WEAK)
1151
                h->dynamic_weak = 1;
1152
            }
1153
          else if (bind != STB_WEAK)
1154
            h->dynamic_weak = 0;
1155
        }
1156
    }
1157
 
1158
  /* If the old symbol has non-default visibility, we ignore the new
1159
     definition from a dynamic object.  */
1160
  if (newdyn
1161
      && ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1162
      && !bfd_is_und_section (sec))
1163
    {
1164
      *skip = TRUE;
1165
      /* Make sure this symbol is dynamic.  */
1166
      h->ref_dynamic = 1;
1167
      /* A protected symbol has external availability. Make sure it is
1168
         recorded as dynamic.
1169
 
1170
         FIXME: Should we check type and size for protected symbol?  */
1171
      if (ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
1172
        return bfd_elf_link_record_dynamic_symbol (info, h);
1173
      else
1174
        return TRUE;
1175
    }
1176
  else if (!newdyn
1177
           && ELF_ST_VISIBILITY (sym->st_other) != STV_DEFAULT
1178
           && h->def_dynamic)
1179
    {
1180
      /* If the new symbol with non-default visibility comes from a
1181
         relocatable file and the old definition comes from a dynamic
1182
         object, we remove the old definition.  */
1183
      if ((*sym_hash)->root.type == bfd_link_hash_indirect)
1184
        {
1185
          /* Handle the case where the old dynamic definition is
1186
             default versioned.  We need to copy the symbol info from
1187
             the symbol with default version to the normal one if it
1188
             was referenced before.  */
1189
          if (h->ref_regular)
1190
            {
1191
              struct elf_link_hash_entry *vh = *sym_hash;
1192
 
1193
              vh->root.type = h->root.type;
1194
              h->root.type = bfd_link_hash_indirect;
1195
              (*bed->elf_backend_copy_indirect_symbol) (info, vh, h);
1196
              /* Protected symbols will override the dynamic definition
1197
                 with default version.  */
1198
              if (ELF_ST_VISIBILITY (sym->st_other) == STV_PROTECTED)
1199
                {
1200
                  h->root.u.i.link = (struct bfd_link_hash_entry *) vh;
1201
                  vh->dynamic_def = 1;
1202
                  vh->ref_dynamic = 1;
1203
                }
1204
              else
1205
                {
1206
                  h->root.type = vh->root.type;
1207
                  vh->ref_dynamic = 0;
1208
                  /* We have to hide it here since it was made dynamic
1209
                     global with extra bits when the symbol info was
1210
                     copied from the old dynamic definition.  */
1211
                  (*bed->elf_backend_hide_symbol) (info, vh, TRUE);
1212
                }
1213
              h = vh;
1214
            }
1215
          else
1216
            h = *sym_hash;
1217
        }
1218
 
1219
      if ((h->root.u.undef.next || info->hash->undefs_tail == &h->root)
1220
          && bfd_is_und_section (sec))
1221
        {
1222
          /* If the new symbol is undefined and the old symbol was
1223
             also undefined before, we need to make sure
1224
             _bfd_generic_link_add_one_symbol doesn't mess
1225
             up the linker hash table undefs list.  Since the old
1226
             definition came from a dynamic object, it is still on the
1227
             undefs list.  */
1228
          h->root.type = bfd_link_hash_undefined;
1229
          h->root.u.undef.abfd = abfd;
1230
        }
1231
      else
1232
        {
1233
          h->root.type = bfd_link_hash_new;
1234
          h->root.u.undef.abfd = NULL;
1235
        }
1236
 
1237
      if (h->def_dynamic)
1238
        {
1239
          h->def_dynamic = 0;
1240
          h->ref_dynamic = 1;
1241
        }
1242
      /* FIXME: Should we check type and size for protected symbol?  */
1243
      h->size = 0;
1244
      h->type = 0;
1245
      return TRUE;
1246
    }
1247
 
1248
  if (bind == STB_GNU_UNIQUE)
1249
    h->unique_global = 1;
1250
 
1251
  /* If a new weak symbol definition comes from a regular file and the
1252
     old symbol comes from a dynamic library, we treat the new one as
1253
     strong.  Similarly, an old weak symbol definition from a regular
1254
     file is treated as strong when the new symbol comes from a dynamic
1255
     library.  Further, an old weak symbol from a dynamic library is
1256
     treated as strong if the new symbol is from a dynamic library.
1257
     This reflects the way glibc's ld.so works.
1258
 
1259
     Do this before setting *type_change_ok or *size_change_ok so that
1260
     we warn properly when dynamic library symbols are overridden.  */
1261
 
1262
  if (newdef && !newdyn && olddyn)
1263
    newweak = FALSE;
1264
  if (olddef && newdyn)
1265
    oldweak = FALSE;
1266
 
1267
  /* Allow changes between different types of function symbol.  */
1268
  if (newfunc && oldfunc)
1269
    *type_change_ok = TRUE;
1270
 
1271
  /* It's OK to change the type if either the existing symbol or the
1272
     new symbol is weak.  A type change is also OK if the old symbol
1273
     is undefined and the new symbol is defined.  */
1274
 
1275
  if (oldweak
1276
      || newweak
1277
      || (newdef
1278
          && h->root.type == bfd_link_hash_undefined))
1279
    *type_change_ok = TRUE;
1280
 
1281
  /* It's OK to change the size if either the existing symbol or the
1282
     new symbol is weak, or if the old symbol is undefined.  */
1283
 
1284
  if (*type_change_ok
1285
      || h->root.type == bfd_link_hash_undefined)
1286
    *size_change_ok = TRUE;
1287
 
1288
  /* NEWDYNCOMMON and OLDDYNCOMMON indicate whether the new or old
1289
     symbol, respectively, appears to be a common symbol in a dynamic
1290
     object.  If a symbol appears in an uninitialized section, and is
1291
     not weak, and is not a function, then it may be a common symbol
1292
     which was resolved when the dynamic object was created.  We want
1293
     to treat such symbols specially, because they raise special
1294
     considerations when setting the symbol size: if the symbol
1295
     appears as a common symbol in a regular object, and the size in
1296
     the regular object is larger, we must make sure that we use the
1297
     larger size.  This problematic case can always be avoided in C,
1298
     but it must be handled correctly when using Fortran shared
1299
     libraries.
1300
 
1301
     Note that if NEWDYNCOMMON is set, NEWDEF will be set, and
1302
     likewise for OLDDYNCOMMON and OLDDEF.
1303
 
1304
     Note that this test is just a heuristic, and that it is quite
1305
     possible to have an uninitialized symbol in a shared object which
1306
     is really a definition, rather than a common symbol.  This could
1307
     lead to some minor confusion when the symbol really is a common
1308
     symbol in some regular object.  However, I think it will be
1309
     harmless.  */
1310
 
1311
  if (newdyn
1312
      && newdef
1313
      && !newweak
1314
      && (sec->flags & SEC_ALLOC) != 0
1315
      && (sec->flags & SEC_LOAD) == 0
1316
      && sym->st_size > 0
1317
      && !newfunc)
1318
    newdyncommon = TRUE;
1319
  else
1320
    newdyncommon = FALSE;
1321
 
1322
  if (olddyn
1323
      && olddef
1324
      && h->root.type == bfd_link_hash_defined
1325
      && h->def_dynamic
1326
      && (h->root.u.def.section->flags & SEC_ALLOC) != 0
1327
      && (h->root.u.def.section->flags & SEC_LOAD) == 0
1328
      && h->size > 0
1329
      && !oldfunc)
1330
    olddyncommon = TRUE;
1331
  else
1332
    olddyncommon = FALSE;
1333
 
1334
  /* We now know everything about the old and new symbols.  We ask the
1335
     backend to check if we can merge them.  */
1336
  if (bed->merge_symbol
1337
      && !bed->merge_symbol (info, sym_hash, h, sym, psec, pvalue,
1338
                             pold_alignment, skip, override,
1339
                             type_change_ok, size_change_ok,
1340
                             &newdyn, &newdef, &newdyncommon, &newweak,
1341
                             abfd, &sec,
1342
                             &olddyn, &olddef, &olddyncommon, &oldweak,
1343
                             oldbfd, &oldsec))
1344
    return FALSE;
1345
 
1346
  /* If both the old and the new symbols look like common symbols in a
1347
     dynamic object, set the size of the symbol to the larger of the
1348
     two.  */
1349
 
1350
  if (olddyncommon
1351
      && newdyncommon
1352
      && sym->st_size != h->size)
1353
    {
1354
      /* Since we think we have two common symbols, issue a multiple
1355
         common warning if desired.  Note that we only warn if the
1356
         size is different.  If the size is the same, we simply let
1357
         the old symbol override the new one as normally happens with
1358
         symbols defined in dynamic objects.  */
1359
 
1360
      if (! ((*info->callbacks->multiple_common)
1361
             (info, &h->root, abfd, bfd_link_hash_common, sym->st_size)))
1362
        return FALSE;
1363
 
1364
      if (sym->st_size > h->size)
1365
        h->size = sym->st_size;
1366
 
1367
      *size_change_ok = TRUE;
1368
    }
1369
 
1370
  /* If we are looking at a dynamic object, and we have found a
1371
     definition, we need to see if the symbol was already defined by
1372
     some other object.  If so, we want to use the existing
1373
     definition, and we do not want to report a multiple symbol
1374
     definition error; we do this by clobbering *PSEC to be
1375
     bfd_und_section_ptr.
1376
 
1377
     We treat a common symbol as a definition if the symbol in the
1378
     shared library is a function, since common symbols always
1379
     represent variables; this can cause confusion in principle, but
1380
     any such confusion would seem to indicate an erroneous program or
1381
     shared library.  We also permit a common symbol in a regular
1382
     object to override a weak symbol in a shared object.  */
1383
 
1384
  if (newdyn
1385
      && newdef
1386
      && (olddef
1387
          || (h->root.type == bfd_link_hash_common
1388
              && (newweak || newfunc))))
1389
    {
1390
      *override = TRUE;
1391
      newdef = FALSE;
1392
      newdyncommon = FALSE;
1393
 
1394
      *psec = sec = bfd_und_section_ptr;
1395
      *size_change_ok = TRUE;
1396
 
1397
      /* If we get here when the old symbol is a common symbol, then
1398
         we are explicitly letting it override a weak symbol or
1399
         function in a dynamic object, and we don't want to warn about
1400
         a type change.  If the old symbol is a defined symbol, a type
1401
         change warning may still be appropriate.  */
1402
 
1403
      if (h->root.type == bfd_link_hash_common)
1404
        *type_change_ok = TRUE;
1405
    }
1406
 
1407
  /* Handle the special case of an old common symbol merging with a
1408
     new symbol which looks like a common symbol in a shared object.
1409
     We change *PSEC and *PVALUE to make the new symbol look like a
1410
     common symbol, and let _bfd_generic_link_add_one_symbol do the
1411
     right thing.  */
1412
 
1413
  if (newdyncommon
1414
      && h->root.type == bfd_link_hash_common)
1415
    {
1416
      *override = TRUE;
1417
      newdef = FALSE;
1418
      newdyncommon = FALSE;
1419
      *pvalue = sym->st_size;
1420
      *psec = sec = bed->common_section (oldsec);
1421
      *size_change_ok = TRUE;
1422
    }
1423
 
1424
  /* Skip weak definitions of symbols that are already defined.  */
1425
  if (newdef && olddef && newweak)
1426
    {
1427
      /* Don't skip new non-IR weak syms.  */
1428 161 khays
      if (!(oldbfd != NULL
1429
            && (oldbfd->flags & BFD_PLUGIN) != 0
1430 14 khays
            && (abfd->flags & BFD_PLUGIN) == 0))
1431
        *skip = TRUE;
1432
 
1433
      /* Merge st_other.  If the symbol already has a dynamic index,
1434
         but visibility says it should not be visible, turn it into a
1435
         local symbol.  */
1436
      elf_merge_st_other (abfd, h, sym, newdef, newdyn);
1437
      if (h->dynindx != -1)
1438
        switch (ELF_ST_VISIBILITY (h->other))
1439
          {
1440
          case STV_INTERNAL:
1441
          case STV_HIDDEN:
1442
            (*bed->elf_backend_hide_symbol) (info, h, TRUE);
1443
            break;
1444
          }
1445
    }
1446
 
1447
  /* If the old symbol is from a dynamic object, and the new symbol is
1448
     a definition which is not from a dynamic object, then the new
1449
     symbol overrides the old symbol.  Symbols from regular files
1450
     always take precedence over symbols from dynamic objects, even if
1451
     they are defined after the dynamic object in the link.
1452
 
1453
     As above, we again permit a common symbol in a regular object to
1454
     override a definition in a shared object if the shared object
1455
     symbol is a function or is weak.  */
1456
 
1457
  flip = NULL;
1458
  if (!newdyn
1459
      && (newdef
1460
          || (bfd_is_com_section (sec)
1461
              && (oldweak || oldfunc)))
1462
      && olddyn
1463
      && olddef
1464
      && h->def_dynamic)
1465
    {
1466
      /* Change the hash table entry to undefined, and let
1467
         _bfd_generic_link_add_one_symbol do the right thing with the
1468
         new definition.  */
1469
 
1470
      h->root.type = bfd_link_hash_undefined;
1471
      h->root.u.undef.abfd = h->root.u.def.section->owner;
1472
      *size_change_ok = TRUE;
1473
 
1474
      olddef = FALSE;
1475
      olddyncommon = FALSE;
1476
 
1477
      /* We again permit a type change when a common symbol may be
1478
         overriding a function.  */
1479
 
1480
      if (bfd_is_com_section (sec))
1481
        {
1482
          if (oldfunc)
1483
            {
1484
              /* If a common symbol overrides a function, make sure
1485
                 that it isn't defined dynamically nor has type
1486
                 function.  */
1487
              h->def_dynamic = 0;
1488
              h->type = STT_NOTYPE;
1489
            }
1490
          *type_change_ok = TRUE;
1491
        }
1492
 
1493
      if ((*sym_hash)->root.type == bfd_link_hash_indirect)
1494
        flip = *sym_hash;
1495
      else
1496
        /* This union may have been set to be non-NULL when this symbol
1497
           was seen in a dynamic object.  We must force the union to be
1498
           NULL, so that it is correct for a regular symbol.  */
1499
        h->verinfo.vertree = NULL;
1500
    }
1501
 
1502
  /* Handle the special case of a new common symbol merging with an
1503
     old symbol that looks like it might be a common symbol defined in
1504
     a shared object.  Note that we have already handled the case in
1505
     which a new common symbol should simply override the definition
1506
     in the shared library.  */
1507
 
1508
  if (! newdyn
1509
      && bfd_is_com_section (sec)
1510
      && olddyncommon)
1511
    {
1512
      /* It would be best if we could set the hash table entry to a
1513
         common symbol, but we don't know what to use for the section
1514
         or the alignment.  */
1515
      if (! ((*info->callbacks->multiple_common)
1516
             (info, &h->root, abfd, bfd_link_hash_common, sym->st_size)))
1517
        return FALSE;
1518
 
1519
      /* If the presumed common symbol in the dynamic object is
1520
         larger, pretend that the new symbol has its size.  */
1521
 
1522
      if (h->size > *pvalue)
1523
        *pvalue = h->size;
1524
 
1525
      /* We need to remember the alignment required by the symbol
1526
         in the dynamic object.  */
1527
      BFD_ASSERT (pold_alignment);
1528
      *pold_alignment = h->root.u.def.section->alignment_power;
1529
 
1530
      olddef = FALSE;
1531
      olddyncommon = FALSE;
1532
 
1533
      h->root.type = bfd_link_hash_undefined;
1534
      h->root.u.undef.abfd = h->root.u.def.section->owner;
1535
 
1536
      *size_change_ok = TRUE;
1537
      *type_change_ok = TRUE;
1538
 
1539
      if ((*sym_hash)->root.type == bfd_link_hash_indirect)
1540
        flip = *sym_hash;
1541
      else
1542
        h->verinfo.vertree = NULL;
1543
    }
1544
 
1545
  if (flip != NULL)
1546
    {
1547
      /* Handle the case where we had a versioned symbol in a dynamic
1548
         library and now find a definition in a normal object.  In this
1549
         case, we make the versioned symbol point to the normal one.  */
1550
      flip->root.type = h->root.type;
1551
      flip->root.u.undef.abfd = h->root.u.undef.abfd;
1552
      h->root.type = bfd_link_hash_indirect;
1553
      h->root.u.i.link = (struct bfd_link_hash_entry *) flip;
1554
      (*bed->elf_backend_copy_indirect_symbol) (info, flip, h);
1555
      if (h->def_dynamic)
1556
        {
1557
          h->def_dynamic = 0;
1558
          flip->ref_dynamic = 1;
1559
        }
1560
    }
1561
 
1562
  return TRUE;
1563
}
1564
 
1565
/* This function is called to create an indirect symbol from the
1566
   default for the symbol with the default version if needed. The
1567
   symbol is described by H, NAME, SYM, PSEC, VALUE, and OVERRIDE.  We
1568
   set DYNSYM if the new indirect symbol is dynamic.  */
1569
 
1570
static bfd_boolean
1571
_bfd_elf_add_default_symbol (bfd *abfd,
1572
                             struct bfd_link_info *info,
1573
                             struct elf_link_hash_entry *h,
1574
                             const char *name,
1575
                             Elf_Internal_Sym *sym,
1576
                             asection **psec,
1577
                             bfd_vma *value,
1578
                             bfd_boolean *dynsym,
1579
                             bfd_boolean override)
1580
{
1581
  bfd_boolean type_change_ok;
1582
  bfd_boolean size_change_ok;
1583
  bfd_boolean skip;
1584
  char *shortname;
1585
  struct elf_link_hash_entry *hi;
1586
  struct bfd_link_hash_entry *bh;
1587
  const struct elf_backend_data *bed;
1588
  bfd_boolean collect;
1589
  bfd_boolean dynamic;
1590
  char *p;
1591
  size_t len, shortlen;
1592
  asection *sec;
1593
 
1594
  /* If this symbol has a version, and it is the default version, we
1595
     create an indirect symbol from the default name to the fully
1596
     decorated name.  This will cause external references which do not
1597
     specify a version to be bound to this version of the symbol.  */
1598
  p = strchr (name, ELF_VER_CHR);
1599
  if (p == NULL || p[1] != ELF_VER_CHR)
1600
    return TRUE;
1601
 
1602
  if (override)
1603
    {
1604
      /* We are overridden by an old definition. We need to check if we
1605
         need to create the indirect symbol from the default name.  */
1606
      hi = elf_link_hash_lookup (elf_hash_table (info), name, TRUE,
1607
                                 FALSE, FALSE);
1608
      BFD_ASSERT (hi != NULL);
1609
      if (hi == h)
1610
        return TRUE;
1611
      while (hi->root.type == bfd_link_hash_indirect
1612
             || hi->root.type == bfd_link_hash_warning)
1613
        {
1614
          hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
1615
          if (hi == h)
1616
            return TRUE;
1617
        }
1618
    }
1619
 
1620
  bed = get_elf_backend_data (abfd);
1621
  collect = bed->collect;
1622
  dynamic = (abfd->flags & DYNAMIC) != 0;
1623
 
1624
  shortlen = p - name;
1625
  shortname = (char *) bfd_hash_allocate (&info->hash->table, shortlen + 1);
1626
  if (shortname == NULL)
1627
    return FALSE;
1628
  memcpy (shortname, name, shortlen);
1629
  shortname[shortlen] = '\0';
1630
 
1631
  /* We are going to create a new symbol.  Merge it with any existing
1632
     symbol with this name.  For the purposes of the merge, act as
1633
     though we were defining the symbol we just defined, although we
1634
     actually going to define an indirect symbol.  */
1635
  type_change_ok = FALSE;
1636
  size_change_ok = FALSE;
1637
  sec = *psec;
1638
  if (!_bfd_elf_merge_symbol (abfd, info, shortname, sym, &sec, value,
1639
                              NULL, &hi, &skip, &override,
1640
                              &type_change_ok, &size_change_ok))
1641
    return FALSE;
1642
 
1643
  if (skip)
1644
    goto nondefault;
1645
 
1646
  if (! override)
1647
    {
1648
      bh = &hi->root;
1649
      if (! (_bfd_generic_link_add_one_symbol
1650
             (info, abfd, shortname, BSF_INDIRECT, bfd_ind_section_ptr,
1651
              0, name, FALSE, collect, &bh)))
1652
        return FALSE;
1653
      hi = (struct elf_link_hash_entry *) bh;
1654
    }
1655
  else
1656
    {
1657
      /* In this case the symbol named SHORTNAME is overriding the
1658
         indirect symbol we want to add.  We were planning on making
1659
         SHORTNAME an indirect symbol referring to NAME.  SHORTNAME
1660
         is the name without a version.  NAME is the fully versioned
1661
         name, and it is the default version.
1662
 
1663
         Overriding means that we already saw a definition for the
1664
         symbol SHORTNAME in a regular object, and it is overriding
1665
         the symbol defined in the dynamic object.
1666
 
1667
         When this happens, we actually want to change NAME, the
1668
         symbol we just added, to refer to SHORTNAME.  This will cause
1669
         references to NAME in the shared object to become references
1670
         to SHORTNAME in the regular object.  This is what we expect
1671
         when we override a function in a shared object: that the
1672
         references in the shared object will be mapped to the
1673
         definition in the regular object.  */
1674
 
1675
      while (hi->root.type == bfd_link_hash_indirect
1676
             || hi->root.type == bfd_link_hash_warning)
1677
        hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
1678
 
1679
      h->root.type = bfd_link_hash_indirect;
1680
      h->root.u.i.link = (struct bfd_link_hash_entry *) hi;
1681
      if (h->def_dynamic)
1682
        {
1683
          h->def_dynamic = 0;
1684
          hi->ref_dynamic = 1;
1685
          if (hi->ref_regular
1686
              || hi->def_regular)
1687
            {
1688
              if (! bfd_elf_link_record_dynamic_symbol (info, hi))
1689
                return FALSE;
1690
            }
1691
        }
1692
 
1693
      /* Now set HI to H, so that the following code will set the
1694
         other fields correctly.  */
1695
      hi = h;
1696
    }
1697
 
1698
  /* Check if HI is a warning symbol.  */
1699
  if (hi->root.type == bfd_link_hash_warning)
1700
    hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
1701
 
1702
  /* If there is a duplicate definition somewhere, then HI may not
1703
     point to an indirect symbol.  We will have reported an error to
1704
     the user in that case.  */
1705
 
1706
  if (hi->root.type == bfd_link_hash_indirect)
1707
    {
1708
      struct elf_link_hash_entry *ht;
1709
 
1710
      ht = (struct elf_link_hash_entry *) hi->root.u.i.link;
1711
      (*bed->elf_backend_copy_indirect_symbol) (info, ht, hi);
1712
 
1713
      /* See if the new flags lead us to realize that the symbol must
1714
         be dynamic.  */
1715
      if (! *dynsym)
1716
        {
1717
          if (! dynamic)
1718
            {
1719
              if (! info->executable
1720
                  || hi->ref_dynamic)
1721
                *dynsym = TRUE;
1722
            }
1723
          else
1724
            {
1725
              if (hi->ref_regular)
1726
                *dynsym = TRUE;
1727
            }
1728
        }
1729
    }
1730
 
1731
  /* We also need to define an indirection from the nondefault version
1732
     of the symbol.  */
1733
 
1734
nondefault:
1735
  len = strlen (name);
1736
  shortname = (char *) bfd_hash_allocate (&info->hash->table, len);
1737
  if (shortname == NULL)
1738
    return FALSE;
1739
  memcpy (shortname, name, shortlen);
1740
  memcpy (shortname + shortlen, p + 1, len - shortlen);
1741
 
1742
  /* Once again, merge with any existing symbol.  */
1743
  type_change_ok = FALSE;
1744
  size_change_ok = FALSE;
1745
  sec = *psec;
1746
  if (!_bfd_elf_merge_symbol (abfd, info, shortname, sym, &sec, value,
1747
                              NULL, &hi, &skip, &override,
1748
                              &type_change_ok, &size_change_ok))
1749
    return FALSE;
1750
 
1751
  if (skip)
1752
    return TRUE;
1753
 
1754
  if (override)
1755
    {
1756
      /* Here SHORTNAME is a versioned name, so we don't expect to see
1757
         the type of override we do in the case above unless it is
1758
         overridden by a versioned definition.  */
1759
      if (hi->root.type != bfd_link_hash_defined
1760
          && hi->root.type != bfd_link_hash_defweak)
1761
        (*_bfd_error_handler)
1762
          (_("%B: unexpected redefinition of indirect versioned symbol `%s'"),
1763
           abfd, shortname);
1764
    }
1765
  else
1766
    {
1767
      bh = &hi->root;
1768
      if (! (_bfd_generic_link_add_one_symbol
1769
             (info, abfd, shortname, BSF_INDIRECT,
1770
              bfd_ind_section_ptr, 0, name, FALSE, collect, &bh)))
1771
        return FALSE;
1772
      hi = (struct elf_link_hash_entry *) bh;
1773
 
1774
      /* If there is a duplicate definition somewhere, then HI may not
1775
         point to an indirect symbol.  We will have reported an error
1776
         to the user in that case.  */
1777
 
1778
      if (hi->root.type == bfd_link_hash_indirect)
1779
        {
1780
          (*bed->elf_backend_copy_indirect_symbol) (info, h, hi);
1781
 
1782
          /* See if the new flags lead us to realize that the symbol
1783
             must be dynamic.  */
1784
          if (! *dynsym)
1785
            {
1786
              if (! dynamic)
1787
                {
1788
                  if (! info->executable
1789
                      || hi->ref_dynamic)
1790
                    *dynsym = TRUE;
1791
                }
1792
              else
1793
                {
1794
                  if (hi->ref_regular)
1795
                    *dynsym = TRUE;
1796
                }
1797
            }
1798
        }
1799
    }
1800
 
1801
  return TRUE;
1802
}
1803
 
1804
/* This routine is used to export all defined symbols into the dynamic
1805
   symbol table.  It is called via elf_link_hash_traverse.  */
1806
 
1807
static bfd_boolean
1808
_bfd_elf_export_symbol (struct elf_link_hash_entry *h, void *data)
1809
{
1810
  struct elf_info_failed *eif = (struct elf_info_failed *) data;
1811
 
1812
  /* Ignore indirect symbols.  These are added by the versioning code.  */
1813
  if (h->root.type == bfd_link_hash_indirect)
1814
    return TRUE;
1815
 
1816 148 khays
  /* Ignore this if we won't export it.  */
1817
  if (!eif->info->export_dynamic && !h->dynamic)
1818
    return TRUE;
1819 14 khays
 
1820
  if (h->dynindx == -1
1821 163 khays
      && (h->def_regular || h->ref_regular)
1822
      && ! bfd_hide_sym_by_version (eif->info->version_info,
1823
                                    h->root.root.string))
1824 14 khays
    {
1825 163 khays
      if (! bfd_elf_link_record_dynamic_symbol (eif->info, h))
1826 14 khays
        {
1827 163 khays
          eif->failed = TRUE;
1828
          return FALSE;
1829 14 khays
        }
1830
    }
1831
 
1832
  return TRUE;
1833
}
1834
 
1835
/* Look through the symbols which are defined in other shared
1836
   libraries and referenced here.  Update the list of version
1837
   dependencies.  This will be put into the .gnu.version_r section.
1838
   This function is called via elf_link_hash_traverse.  */
1839
 
1840
static bfd_boolean
1841
_bfd_elf_link_find_version_dependencies (struct elf_link_hash_entry *h,
1842
                                         void *data)
1843
{
1844
  struct elf_find_verdep_info *rinfo = (struct elf_find_verdep_info *) data;
1845
  Elf_Internal_Verneed *t;
1846
  Elf_Internal_Vernaux *a;
1847
  bfd_size_type amt;
1848
 
1849
  /* We only care about symbols defined in shared objects with version
1850
     information.  */
1851
  if (!h->def_dynamic
1852
      || h->def_regular
1853
      || h->dynindx == -1
1854
      || h->verinfo.verdef == NULL)
1855
    return TRUE;
1856
 
1857
  /* See if we already know about this version.  */
1858
  for (t = elf_tdata (rinfo->info->output_bfd)->verref;
1859
       t != NULL;
1860
       t = t->vn_nextref)
1861
    {
1862
      if (t->vn_bfd != h->verinfo.verdef->vd_bfd)
1863
        continue;
1864
 
1865
      for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1866
        if (a->vna_nodename == h->verinfo.verdef->vd_nodename)
1867
          return TRUE;
1868
 
1869
      break;
1870
    }
1871
 
1872
  /* This is a new version.  Add it to tree we are building.  */
1873
 
1874
  if (t == NULL)
1875
    {
1876
      amt = sizeof *t;
1877
      t = (Elf_Internal_Verneed *) bfd_zalloc (rinfo->info->output_bfd, amt);
1878
      if (t == NULL)
1879
        {
1880
          rinfo->failed = TRUE;
1881
          return FALSE;
1882
        }
1883
 
1884
      t->vn_bfd = h->verinfo.verdef->vd_bfd;
1885
      t->vn_nextref = elf_tdata (rinfo->info->output_bfd)->verref;
1886
      elf_tdata (rinfo->info->output_bfd)->verref = t;
1887
    }
1888
 
1889
  amt = sizeof *a;
1890
  a = (Elf_Internal_Vernaux *) bfd_zalloc (rinfo->info->output_bfd, amt);
1891
  if (a == NULL)
1892
    {
1893
      rinfo->failed = TRUE;
1894
      return FALSE;
1895
    }
1896
 
1897
  /* Note that we are copying a string pointer here, and testing it
1898
     above.  If bfd_elf_string_from_elf_section is ever changed to
1899
     discard the string data when low in memory, this will have to be
1900
     fixed.  */
1901
  a->vna_nodename = h->verinfo.verdef->vd_nodename;
1902
 
1903
  a->vna_flags = h->verinfo.verdef->vd_flags;
1904
  a->vna_nextptr = t->vn_auxptr;
1905
 
1906
  h->verinfo.verdef->vd_exp_refno = rinfo->vers;
1907
  ++rinfo->vers;
1908
 
1909
  a->vna_other = h->verinfo.verdef->vd_exp_refno + 1;
1910
 
1911
  t->vn_auxptr = a;
1912
 
1913
  return TRUE;
1914
}
1915
 
1916
/* Figure out appropriate versions for all the symbols.  We may not
1917
   have the version number script until we have read all of the input
1918
   files, so until that point we don't know which symbols should be
1919
   local.  This function is called via elf_link_hash_traverse.  */
1920
 
1921
static bfd_boolean
1922
_bfd_elf_link_assign_sym_version (struct elf_link_hash_entry *h, void *data)
1923
{
1924
  struct elf_info_failed *sinfo;
1925
  struct bfd_link_info *info;
1926
  const struct elf_backend_data *bed;
1927
  struct elf_info_failed eif;
1928
  char *p;
1929
  bfd_size_type amt;
1930
 
1931
  sinfo = (struct elf_info_failed *) data;
1932
  info = sinfo->info;
1933
 
1934
  /* Fix the symbol flags.  */
1935
  eif.failed = FALSE;
1936
  eif.info = info;
1937
  if (! _bfd_elf_fix_symbol_flags (h, &eif))
1938
    {
1939
      if (eif.failed)
1940
        sinfo->failed = TRUE;
1941
      return FALSE;
1942
    }
1943
 
1944
  /* We only need version numbers for symbols defined in regular
1945
     objects.  */
1946
  if (!h->def_regular)
1947
    return TRUE;
1948
 
1949
  bed = get_elf_backend_data (info->output_bfd);
1950
  p = strchr (h->root.root.string, ELF_VER_CHR);
1951
  if (p != NULL && h->verinfo.vertree == NULL)
1952
    {
1953
      struct bfd_elf_version_tree *t;
1954
      bfd_boolean hidden;
1955
 
1956
      hidden = TRUE;
1957
 
1958
      /* There are two consecutive ELF_VER_CHR characters if this is
1959
         not a hidden symbol.  */
1960
      ++p;
1961
      if (*p == ELF_VER_CHR)
1962
        {
1963
          hidden = FALSE;
1964
          ++p;
1965
        }
1966
 
1967
      /* If there is no version string, we can just return out.  */
1968
      if (*p == '\0')
1969
        {
1970
          if (hidden)
1971
            h->hidden = 1;
1972
          return TRUE;
1973
        }
1974
 
1975
      /* Look for the version.  If we find it, it is no longer weak.  */
1976 163 khays
      for (t = sinfo->info->version_info; t != NULL; t = t->next)
1977 14 khays
        {
1978
          if (strcmp (t->name, p) == 0)
1979
            {
1980
              size_t len;
1981
              char *alc;
1982
              struct bfd_elf_version_expr *d;
1983
 
1984
              len = p - h->root.root.string;
1985
              alc = (char *) bfd_malloc (len);
1986
              if (alc == NULL)
1987
                {
1988
                  sinfo->failed = TRUE;
1989
                  return FALSE;
1990
                }
1991
              memcpy (alc, h->root.root.string, len - 1);
1992
              alc[len - 1] = '\0';
1993
              if (alc[len - 2] == ELF_VER_CHR)
1994
                alc[len - 2] = '\0';
1995
 
1996
              h->verinfo.vertree = t;
1997
              t->used = TRUE;
1998
              d = NULL;
1999
 
2000
              if (t->globals.list != NULL)
2001
                d = (*t->match) (&t->globals, NULL, alc);
2002
 
2003
              /* See if there is anything to force this symbol to
2004
                 local scope.  */
2005
              if (d == NULL && t->locals.list != NULL)
2006
                {
2007
                  d = (*t->match) (&t->locals, NULL, alc);
2008
                  if (d != NULL
2009
                      && h->dynindx != -1
2010
                      && ! info->export_dynamic)
2011
                    (*bed->elf_backend_hide_symbol) (info, h, TRUE);
2012
                }
2013
 
2014
              free (alc);
2015
              break;
2016
            }
2017
        }
2018
 
2019
      /* If we are building an application, we need to create a
2020
         version node for this version.  */
2021
      if (t == NULL && info->executable)
2022
        {
2023
          struct bfd_elf_version_tree **pp;
2024
          int version_index;
2025
 
2026
          /* If we aren't going to export this symbol, we don't need
2027
             to worry about it.  */
2028
          if (h->dynindx == -1)
2029
            return TRUE;
2030
 
2031
          amt = sizeof *t;
2032
          t = (struct bfd_elf_version_tree *) bfd_zalloc (info->output_bfd, amt);
2033
          if (t == NULL)
2034
            {
2035
              sinfo->failed = TRUE;
2036
              return FALSE;
2037
            }
2038
 
2039
          t->name = p;
2040
          t->name_indx = (unsigned int) -1;
2041
          t->used = TRUE;
2042
 
2043
          version_index = 1;
2044
          /* Don't count anonymous version tag.  */
2045 163 khays
          if (sinfo->info->version_info != NULL
2046
              && sinfo->info->version_info->vernum == 0)
2047 14 khays
            version_index = 0;
2048 163 khays
          for (pp = &sinfo->info->version_info;
2049
               *pp != NULL;
2050
               pp = &(*pp)->next)
2051 14 khays
            ++version_index;
2052
          t->vernum = version_index;
2053
 
2054
          *pp = t;
2055
 
2056
          h->verinfo.vertree = t;
2057
        }
2058
      else if (t == NULL)
2059
        {
2060
          /* We could not find the version for a symbol when
2061
             generating a shared archive.  Return an error.  */
2062
          (*_bfd_error_handler)
2063
            (_("%B: version node not found for symbol %s"),
2064
             info->output_bfd, h->root.root.string);
2065
          bfd_set_error (bfd_error_bad_value);
2066
          sinfo->failed = TRUE;
2067
          return FALSE;
2068
        }
2069
 
2070
      if (hidden)
2071
        h->hidden = 1;
2072
    }
2073
 
2074
  /* If we don't have a version for this symbol, see if we can find
2075
     something.  */
2076 163 khays
  if (h->verinfo.vertree == NULL && sinfo->info->version_info != NULL)
2077 14 khays
    {
2078
      bfd_boolean hide;
2079
 
2080 163 khays
      h->verinfo.vertree
2081
        = bfd_find_version_for_sym (sinfo->info->version_info,
2082
                                    h->root.root.string, &hide);
2083 14 khays
      if (h->verinfo.vertree != NULL && hide)
2084
        (*bed->elf_backend_hide_symbol) (info, h, TRUE);
2085
    }
2086
 
2087
  return TRUE;
2088
}
2089
 
2090
/* Read and swap the relocs from the section indicated by SHDR.  This
2091
   may be either a REL or a RELA section.  The relocations are
2092
   translated into RELA relocations and stored in INTERNAL_RELOCS,
2093
   which should have already been allocated to contain enough space.
2094
   The EXTERNAL_RELOCS are a buffer where the external form of the
2095
   relocations should be stored.
2096
 
2097
   Returns FALSE if something goes wrong.  */
2098
 
2099
static bfd_boolean
2100
elf_link_read_relocs_from_section (bfd *abfd,
2101
                                   asection *sec,
2102
                                   Elf_Internal_Shdr *shdr,
2103
                                   void *external_relocs,
2104
                                   Elf_Internal_Rela *internal_relocs)
2105
{
2106
  const struct elf_backend_data *bed;
2107
  void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *);
2108
  const bfd_byte *erela;
2109
  const bfd_byte *erelaend;
2110
  Elf_Internal_Rela *irela;
2111
  Elf_Internal_Shdr *symtab_hdr;
2112
  size_t nsyms;
2113
 
2114
  /* Position ourselves at the start of the section.  */
2115
  if (bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0)
2116
    return FALSE;
2117
 
2118
  /* Read the relocations.  */
2119
  if (bfd_bread (external_relocs, shdr->sh_size, abfd) != shdr->sh_size)
2120
    return FALSE;
2121
 
2122
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2123
  nsyms = NUM_SHDR_ENTRIES (symtab_hdr);
2124
 
2125
  bed = get_elf_backend_data (abfd);
2126
 
2127
  /* Convert the external relocations to the internal format.  */
2128
  if (shdr->sh_entsize == bed->s->sizeof_rel)
2129
    swap_in = bed->s->swap_reloc_in;
2130
  else if (shdr->sh_entsize == bed->s->sizeof_rela)
2131
    swap_in = bed->s->swap_reloca_in;
2132
  else
2133
    {
2134
      bfd_set_error (bfd_error_wrong_format);
2135
      return FALSE;
2136
    }
2137
 
2138
  erela = (const bfd_byte *) external_relocs;
2139
  erelaend = erela + shdr->sh_size;
2140
  irela = internal_relocs;
2141
  while (erela < erelaend)
2142
    {
2143
      bfd_vma r_symndx;
2144
 
2145
      (*swap_in) (abfd, erela, irela);
2146
      r_symndx = ELF32_R_SYM (irela->r_info);
2147
      if (bed->s->arch_size == 64)
2148
        r_symndx >>= 24;
2149
      if (nsyms > 0)
2150
        {
2151
          if ((size_t) r_symndx >= nsyms)
2152
            {
2153
              (*_bfd_error_handler)
2154
                (_("%B: bad reloc symbol index (0x%lx >= 0x%lx)"
2155
                   " for offset 0x%lx in section `%A'"),
2156
                 abfd, sec,
2157
                 (unsigned long) r_symndx, (unsigned long) nsyms, irela->r_offset);
2158
              bfd_set_error (bfd_error_bad_value);
2159
              return FALSE;
2160
            }
2161
        }
2162
      else if (r_symndx != STN_UNDEF)
2163
        {
2164
          (*_bfd_error_handler)
2165
            (_("%B: non-zero symbol index (0x%lx) for offset 0x%lx in section `%A'"
2166
               " when the object file has no symbol table"),
2167
             abfd, sec,
2168
             (unsigned long) r_symndx, (unsigned long) nsyms, irela->r_offset);
2169
          bfd_set_error (bfd_error_bad_value);
2170
          return FALSE;
2171
        }
2172
      irela += bed->s->int_rels_per_ext_rel;
2173
      erela += shdr->sh_entsize;
2174
    }
2175
 
2176
  return TRUE;
2177
}
2178
 
2179
/* Read and swap the relocs for a section O.  They may have been
2180
   cached.  If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are
2181
   not NULL, they are used as buffers to read into.  They are known to
2182
   be large enough.  If the INTERNAL_RELOCS relocs argument is NULL,
2183
   the return value is allocated using either malloc or bfd_alloc,
2184
   according to the KEEP_MEMORY argument.  If O has two relocation
2185
   sections (both REL and RELA relocations), then the REL_HDR
2186
   relocations will appear first in INTERNAL_RELOCS, followed by the
2187
   RELA_HDR relocations.  */
2188
 
2189
Elf_Internal_Rela *
2190
_bfd_elf_link_read_relocs (bfd *abfd,
2191
                           asection *o,
2192
                           void *external_relocs,
2193
                           Elf_Internal_Rela *internal_relocs,
2194
                           bfd_boolean keep_memory)
2195
{
2196
  void *alloc1 = NULL;
2197
  Elf_Internal_Rela *alloc2 = NULL;
2198
  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2199
  struct bfd_elf_section_data *esdo = elf_section_data (o);
2200
  Elf_Internal_Rela *internal_rela_relocs;
2201
 
2202
  if (esdo->relocs != NULL)
2203
    return esdo->relocs;
2204
 
2205
  if (o->reloc_count == 0)
2206
    return NULL;
2207
 
2208
  if (internal_relocs == NULL)
2209
    {
2210
      bfd_size_type size;
2211
 
2212
      size = o->reloc_count;
2213
      size *= bed->s->int_rels_per_ext_rel * sizeof (Elf_Internal_Rela);
2214
      if (keep_memory)
2215
        internal_relocs = alloc2 = (Elf_Internal_Rela *) bfd_alloc (abfd, size);
2216
      else
2217
        internal_relocs = alloc2 = (Elf_Internal_Rela *) bfd_malloc (size);
2218
      if (internal_relocs == NULL)
2219
        goto error_return;
2220
    }
2221
 
2222
  if (external_relocs == NULL)
2223
    {
2224
      bfd_size_type size = 0;
2225
 
2226
      if (esdo->rel.hdr)
2227
        size += esdo->rel.hdr->sh_size;
2228
      if (esdo->rela.hdr)
2229
        size += esdo->rela.hdr->sh_size;
2230
 
2231
      alloc1 = bfd_malloc (size);
2232
      if (alloc1 == NULL)
2233
        goto error_return;
2234
      external_relocs = alloc1;
2235
    }
2236
 
2237
  internal_rela_relocs = internal_relocs;
2238
  if (esdo->rel.hdr)
2239
    {
2240
      if (!elf_link_read_relocs_from_section (abfd, o, esdo->rel.hdr,
2241
                                              external_relocs,
2242
                                              internal_relocs))
2243
        goto error_return;
2244
      external_relocs = (((bfd_byte *) external_relocs)
2245
                         + esdo->rel.hdr->sh_size);
2246
      internal_rela_relocs += (NUM_SHDR_ENTRIES (esdo->rel.hdr)
2247
                               * bed->s->int_rels_per_ext_rel);
2248
    }
2249
 
2250
  if (esdo->rela.hdr
2251
      && (!elf_link_read_relocs_from_section (abfd, o, esdo->rela.hdr,
2252
                                              external_relocs,
2253
                                              internal_rela_relocs)))
2254
    goto error_return;
2255
 
2256
  /* Cache the results for next time, if we can.  */
2257
  if (keep_memory)
2258
    esdo->relocs = internal_relocs;
2259
 
2260
  if (alloc1 != NULL)
2261
    free (alloc1);
2262
 
2263
  /* Don't free alloc2, since if it was allocated we are passing it
2264
     back (under the name of internal_relocs).  */
2265
 
2266
  return internal_relocs;
2267
 
2268
 error_return:
2269
  if (alloc1 != NULL)
2270
    free (alloc1);
2271
  if (alloc2 != NULL)
2272
    {
2273
      if (keep_memory)
2274
        bfd_release (abfd, alloc2);
2275
      else
2276
        free (alloc2);
2277
    }
2278
  return NULL;
2279
}
2280
 
2281
/* Compute the size of, and allocate space for, REL_HDR which is the
2282
   section header for a section containing relocations for O.  */
2283
 
2284
static bfd_boolean
2285
_bfd_elf_link_size_reloc_section (bfd *abfd,
2286
                                  struct bfd_elf_section_reloc_data *reldata)
2287
{
2288
  Elf_Internal_Shdr *rel_hdr = reldata->hdr;
2289
 
2290
  /* That allows us to calculate the size of the section.  */
2291
  rel_hdr->sh_size = rel_hdr->sh_entsize * reldata->count;
2292
 
2293
  /* The contents field must last into write_object_contents, so we
2294
     allocate it with bfd_alloc rather than malloc.  Also since we
2295
     cannot be sure that the contents will actually be filled in,
2296
     we zero the allocated space.  */
2297
  rel_hdr->contents = (unsigned char *) bfd_zalloc (abfd, rel_hdr->sh_size);
2298
  if (rel_hdr->contents == NULL && rel_hdr->sh_size != 0)
2299
    return FALSE;
2300
 
2301
  if (reldata->hashes == NULL && reldata->count)
2302
    {
2303
      struct elf_link_hash_entry **p;
2304
 
2305
      p = (struct elf_link_hash_entry **)
2306
          bfd_zmalloc (reldata->count * sizeof (struct elf_link_hash_entry *));
2307
      if (p == NULL)
2308
        return FALSE;
2309
 
2310
      reldata->hashes = p;
2311
    }
2312
 
2313
  return TRUE;
2314
}
2315
 
2316
/* Copy the relocations indicated by the INTERNAL_RELOCS (which
2317
   originated from the section given by INPUT_REL_HDR) to the
2318
   OUTPUT_BFD.  */
2319
 
2320
bfd_boolean
2321
_bfd_elf_link_output_relocs (bfd *output_bfd,
2322
                             asection *input_section,
2323
                             Elf_Internal_Shdr *input_rel_hdr,
2324
                             Elf_Internal_Rela *internal_relocs,
2325
                             struct elf_link_hash_entry **rel_hash
2326
                               ATTRIBUTE_UNUSED)
2327
{
2328
  Elf_Internal_Rela *irela;
2329
  Elf_Internal_Rela *irelaend;
2330
  bfd_byte *erel;
2331
  struct bfd_elf_section_reloc_data *output_reldata;
2332
  asection *output_section;
2333
  const struct elf_backend_data *bed;
2334
  void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
2335
  struct bfd_elf_section_data *esdo;
2336
 
2337
  output_section = input_section->output_section;
2338
 
2339
  bed = get_elf_backend_data (output_bfd);
2340
  esdo = elf_section_data (output_section);
2341
  if (esdo->rel.hdr && esdo->rel.hdr->sh_entsize == input_rel_hdr->sh_entsize)
2342
    {
2343
      output_reldata = &esdo->rel;
2344
      swap_out = bed->s->swap_reloc_out;
2345
    }
2346
  else if (esdo->rela.hdr
2347
           && esdo->rela.hdr->sh_entsize == input_rel_hdr->sh_entsize)
2348
    {
2349
      output_reldata = &esdo->rela;
2350
      swap_out = bed->s->swap_reloca_out;
2351
    }
2352
  else
2353
    {
2354
      (*_bfd_error_handler)
2355
        (_("%B: relocation size mismatch in %B section %A"),
2356
         output_bfd, input_section->owner, input_section);
2357
      bfd_set_error (bfd_error_wrong_format);
2358
      return FALSE;
2359
    }
2360
 
2361
  erel = output_reldata->hdr->contents;
2362
  erel += output_reldata->count * input_rel_hdr->sh_entsize;
2363
  irela = internal_relocs;
2364
  irelaend = irela + (NUM_SHDR_ENTRIES (input_rel_hdr)
2365
                      * bed->s->int_rels_per_ext_rel);
2366
  while (irela < irelaend)
2367
    {
2368
      (*swap_out) (output_bfd, irela, erel);
2369
      irela += bed->s->int_rels_per_ext_rel;
2370
      erel += input_rel_hdr->sh_entsize;
2371
    }
2372
 
2373
  /* Bump the counter, so that we know where to add the next set of
2374
     relocations.  */
2375
  output_reldata->count += NUM_SHDR_ENTRIES (input_rel_hdr);
2376
 
2377
  return TRUE;
2378
}
2379
 
2380
/* Make weak undefined symbols in PIE dynamic.  */
2381
 
2382
bfd_boolean
2383
_bfd_elf_link_hash_fixup_symbol (struct bfd_link_info *info,
2384
                                 struct elf_link_hash_entry *h)
2385
{
2386
  if (info->pie
2387
      && h->dynindx == -1
2388
      && h->root.type == bfd_link_hash_undefweak)
2389
    return bfd_elf_link_record_dynamic_symbol (info, h);
2390
 
2391
  return TRUE;
2392
}
2393
 
2394
/* Fix up the flags for a symbol.  This handles various cases which
2395
   can only be fixed after all the input files are seen.  This is
2396
   currently called by both adjust_dynamic_symbol and
2397
   assign_sym_version, which is unnecessary but perhaps more robust in
2398
   the face of future changes.  */
2399
 
2400
static bfd_boolean
2401
_bfd_elf_fix_symbol_flags (struct elf_link_hash_entry *h,
2402
                           struct elf_info_failed *eif)
2403
{
2404
  const struct elf_backend_data *bed;
2405
 
2406
  /* If this symbol was mentioned in a non-ELF file, try to set
2407
     DEF_REGULAR and REF_REGULAR correctly.  This is the only way to
2408
     permit a non-ELF file to correctly refer to a symbol defined in
2409
     an ELF dynamic object.  */
2410
  if (h->non_elf)
2411
    {
2412
      while (h->root.type == bfd_link_hash_indirect)
2413
        h = (struct elf_link_hash_entry *) h->root.u.i.link;
2414
 
2415
      if (h->root.type != bfd_link_hash_defined
2416
          && h->root.type != bfd_link_hash_defweak)
2417
        {
2418
          h->ref_regular = 1;
2419
          h->ref_regular_nonweak = 1;
2420
        }
2421
      else
2422
        {
2423
          if (h->root.u.def.section->owner != NULL
2424
              && (bfd_get_flavour (h->root.u.def.section->owner)
2425
                  == bfd_target_elf_flavour))
2426
            {
2427
              h->ref_regular = 1;
2428
              h->ref_regular_nonweak = 1;
2429
            }
2430
          else
2431
            h->def_regular = 1;
2432
        }
2433
 
2434
      if (h->dynindx == -1
2435
          && (h->def_dynamic
2436
              || h->ref_dynamic))
2437
        {
2438
          if (! bfd_elf_link_record_dynamic_symbol (eif->info, h))
2439
            {
2440
              eif->failed = TRUE;
2441
              return FALSE;
2442
            }
2443
        }
2444
    }
2445
  else
2446
    {
2447
      /* Unfortunately, NON_ELF is only correct if the symbol
2448
         was first seen in a non-ELF file.  Fortunately, if the symbol
2449
         was first seen in an ELF file, we're probably OK unless the
2450
         symbol was defined in a non-ELF file.  Catch that case here.
2451
         FIXME: We're still in trouble if the symbol was first seen in
2452
         a dynamic object, and then later in a non-ELF regular object.  */
2453
      if ((h->root.type == bfd_link_hash_defined
2454
           || h->root.type == bfd_link_hash_defweak)
2455
          && !h->def_regular
2456
          && (h->root.u.def.section->owner != NULL
2457
              ? (bfd_get_flavour (h->root.u.def.section->owner)
2458
                 != bfd_target_elf_flavour)
2459
              : (bfd_is_abs_section (h->root.u.def.section)
2460
                 && !h->def_dynamic)))
2461
        h->def_regular = 1;
2462
    }
2463
 
2464
  /* Backend specific symbol fixup.  */
2465
  bed = get_elf_backend_data (elf_hash_table (eif->info)->dynobj);
2466
  if (bed->elf_backend_fixup_symbol
2467
      && !(*bed->elf_backend_fixup_symbol) (eif->info, h))
2468
    return FALSE;
2469
 
2470
  /* If this is a final link, and the symbol was defined as a common
2471
     symbol in a regular object file, and there was no definition in
2472
     any dynamic object, then the linker will have allocated space for
2473
     the symbol in a common section but the DEF_REGULAR
2474
     flag will not have been set.  */
2475
  if (h->root.type == bfd_link_hash_defined
2476
      && !h->def_regular
2477
      && h->ref_regular
2478
      && !h->def_dynamic
2479
      && (h->root.u.def.section->owner->flags & DYNAMIC) == 0)
2480
    h->def_regular = 1;
2481
 
2482
  /* If -Bsymbolic was used (which means to bind references to global
2483
     symbols to the definition within the shared object), and this
2484
     symbol was defined in a regular object, then it actually doesn't
2485
     need a PLT entry.  Likewise, if the symbol has non-default
2486
     visibility.  If the symbol has hidden or internal visibility, we
2487
     will force it local.  */
2488
  if (h->needs_plt
2489
      && eif->info->shared
2490
      && is_elf_hash_table (eif->info->hash)
2491
      && (SYMBOLIC_BIND (eif->info, h)
2492
          || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2493
      && h->def_regular)
2494
    {
2495
      bfd_boolean force_local;
2496
 
2497
      force_local = (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
2498
                     || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN);
2499
      (*bed->elf_backend_hide_symbol) (eif->info, h, force_local);
2500
    }
2501
 
2502
  /* If a weak undefined symbol has non-default visibility, we also
2503
     hide it from the dynamic linker.  */
2504
  if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2505
      && h->root.type == bfd_link_hash_undefweak)
2506
    (*bed->elf_backend_hide_symbol) (eif->info, h, TRUE);
2507
 
2508
  /* If this is a weak defined symbol in a dynamic object, and we know
2509
     the real definition in the dynamic object, copy interesting flags
2510
     over to the real definition.  */
2511
  if (h->u.weakdef != NULL)
2512
    {
2513
      /* If the real definition is defined by a regular object file,
2514
         don't do anything special.  See the longer description in
2515
         _bfd_elf_adjust_dynamic_symbol, below.  */
2516 166 khays
      if (h->u.weakdef->def_regular)
2517 14 khays
        h->u.weakdef = NULL;
2518
      else
2519
        {
2520 166 khays
          struct elf_link_hash_entry *weakdef = h->u.weakdef;
2521
 
2522
          while (h->root.type == bfd_link_hash_indirect)
2523
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
2524
 
2525
          BFD_ASSERT (h->root.type == bfd_link_hash_defined
2526
                      || h->root.type == bfd_link_hash_defweak);
2527
          BFD_ASSERT (weakdef->def_dynamic);
2528 14 khays
          BFD_ASSERT (weakdef->root.type == bfd_link_hash_defined
2529
                      || weakdef->root.type == bfd_link_hash_defweak);
2530
          (*bed->elf_backend_copy_indirect_symbol) (eif->info, weakdef, h);
2531
        }
2532
    }
2533
 
2534
  return TRUE;
2535
}
2536
 
2537
/* Make the backend pick a good value for a dynamic symbol.  This is
2538
   called via elf_link_hash_traverse, and also calls itself
2539
   recursively.  */
2540
 
2541
static bfd_boolean
2542
_bfd_elf_adjust_dynamic_symbol (struct elf_link_hash_entry *h, void *data)
2543
{
2544
  struct elf_info_failed *eif = (struct elf_info_failed *) data;
2545
  bfd *dynobj;
2546
  const struct elf_backend_data *bed;
2547
 
2548
  if (! is_elf_hash_table (eif->info->hash))
2549
    return FALSE;
2550
 
2551
  /* Ignore indirect symbols.  These are added by the versioning code.  */
2552
  if (h->root.type == bfd_link_hash_indirect)
2553
    return TRUE;
2554
 
2555
  /* Fix the symbol flags.  */
2556
  if (! _bfd_elf_fix_symbol_flags (h, eif))
2557
    return FALSE;
2558
 
2559
  /* If this symbol does not require a PLT entry, and it is not
2560
     defined by a dynamic object, or is not referenced by a regular
2561
     object, ignore it.  We do have to handle a weak defined symbol,
2562
     even if no regular object refers to it, if we decided to add it
2563
     to the dynamic symbol table.  FIXME: Do we normally need to worry
2564
     about symbols which are defined by one dynamic object and
2565
     referenced by another one?  */
2566
  if (!h->needs_plt
2567
      && h->type != STT_GNU_IFUNC
2568
      && (h->def_regular
2569
          || !h->def_dynamic
2570
          || (!h->ref_regular
2571
              && (h->u.weakdef == NULL || h->u.weakdef->dynindx == -1))))
2572
    {
2573
      h->plt = elf_hash_table (eif->info)->init_plt_offset;
2574
      return TRUE;
2575
    }
2576
 
2577
  /* If we've already adjusted this symbol, don't do it again.  This
2578
     can happen via a recursive call.  */
2579
  if (h->dynamic_adjusted)
2580
    return TRUE;
2581
 
2582
  /* Don't look at this symbol again.  Note that we must set this
2583
     after checking the above conditions, because we may look at a
2584
     symbol once, decide not to do anything, and then get called
2585
     recursively later after REF_REGULAR is set below.  */
2586
  h->dynamic_adjusted = 1;
2587
 
2588
  /* If this is a weak definition, and we know a real definition, and
2589
     the real symbol is not itself defined by a regular object file,
2590
     then get a good value for the real definition.  We handle the
2591
     real symbol first, for the convenience of the backend routine.
2592
 
2593
     Note that there is a confusing case here.  If the real definition
2594
     is defined by a regular object file, we don't get the real symbol
2595
     from the dynamic object, but we do get the weak symbol.  If the
2596
     processor backend uses a COPY reloc, then if some routine in the
2597
     dynamic object changes the real symbol, we will not see that
2598
     change in the corresponding weak symbol.  This is the way other
2599
     ELF linkers work as well, and seems to be a result of the shared
2600
     library model.
2601
 
2602
     I will clarify this issue.  Most SVR4 shared libraries define the
2603
     variable _timezone and define timezone as a weak synonym.  The
2604
     tzset call changes _timezone.  If you write
2605
       extern int timezone;
2606
       int _timezone = 5;
2607
       int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
2608
     you might expect that, since timezone is a synonym for _timezone,
2609
     the same number will print both times.  However, if the processor
2610
     backend uses a COPY reloc, then actually timezone will be copied
2611
     into your process image, and, since you define _timezone
2612
     yourself, _timezone will not.  Thus timezone and _timezone will
2613
     wind up at different memory locations.  The tzset call will set
2614
     _timezone, leaving timezone unchanged.  */
2615
 
2616
  if (h->u.weakdef != NULL)
2617
    {
2618 161 khays
      /* If we get to this point, there is an implicit reference to
2619
         H->U.WEAKDEF by a regular object file via the weak symbol H.  */
2620 14 khays
      h->u.weakdef->ref_regular = 1;
2621
 
2622 161 khays
      /* Ensure that the backend adjust_dynamic_symbol function sees
2623
         H->U.WEAKDEF before H by recursively calling ourselves.  */
2624 14 khays
      if (! _bfd_elf_adjust_dynamic_symbol (h->u.weakdef, eif))
2625
        return FALSE;
2626
    }
2627
 
2628
  /* If a symbol has no type and no size and does not require a PLT
2629
     entry, then we are probably about to do the wrong thing here: we
2630
     are probably going to create a COPY reloc for an empty object.
2631
     This case can arise when a shared object is built with assembly
2632
     code, and the assembly code fails to set the symbol type.  */
2633
  if (h->size == 0
2634
      && h->type == STT_NOTYPE
2635
      && !h->needs_plt)
2636
    (*_bfd_error_handler)
2637
      (_("warning: type and size of dynamic symbol `%s' are not defined"),
2638
       h->root.root.string);
2639
 
2640
  dynobj = elf_hash_table (eif->info)->dynobj;
2641
  bed = get_elf_backend_data (dynobj);
2642
 
2643
  if (! (*bed->elf_backend_adjust_dynamic_symbol) (eif->info, h))
2644
    {
2645
      eif->failed = TRUE;
2646
      return FALSE;
2647
    }
2648
 
2649
  return TRUE;
2650
}
2651
 
2652
/* Adjust the dynamic symbol, H, for copy in the dynamic bss section,
2653
   DYNBSS.  */
2654
 
2655
bfd_boolean
2656
_bfd_elf_adjust_dynamic_copy (struct elf_link_hash_entry *h,
2657
                              asection *dynbss)
2658
{
2659
  unsigned int power_of_two;
2660
  bfd_vma mask;
2661
  asection *sec = h->root.u.def.section;
2662
 
2663
  /* The section aligment of definition is the maximum alignment
2664
     requirement of symbols defined in the section.  Since we don't
2665
     know the symbol alignment requirement, we start with the
2666
     maximum alignment and check low bits of the symbol address
2667
     for the minimum alignment.  */
2668
  power_of_two = bfd_get_section_alignment (sec->owner, sec);
2669
  mask = ((bfd_vma) 1 << power_of_two) - 1;
2670
  while ((h->root.u.def.value & mask) != 0)
2671
    {
2672
       mask >>= 1;
2673
       --power_of_two;
2674
    }
2675
 
2676
  if (power_of_two > bfd_get_section_alignment (dynbss->owner,
2677
                                                dynbss))
2678
    {
2679
      /* Adjust the section alignment if needed.  */
2680
      if (! bfd_set_section_alignment (dynbss->owner, dynbss,
2681
                                       power_of_two))
2682
        return FALSE;
2683
    }
2684
 
2685
  /* We make sure that the symbol will be aligned properly.  */
2686
  dynbss->size = BFD_ALIGN (dynbss->size, mask + 1);
2687
 
2688
  /* Define the symbol as being at this point in DYNBSS.  */
2689
  h->root.u.def.section = dynbss;
2690
  h->root.u.def.value = dynbss->size;
2691
 
2692
  /* Increment the size of DYNBSS to make room for the symbol.  */
2693
  dynbss->size += h->size;
2694
 
2695
  return TRUE;
2696
}
2697
 
2698
/* Adjust all external symbols pointing into SEC_MERGE sections
2699
   to reflect the object merging within the sections.  */
2700
 
2701
static bfd_boolean
2702
_bfd_elf_link_sec_merge_syms (struct elf_link_hash_entry *h, void *data)
2703
{
2704
  asection *sec;
2705
 
2706
  if ((h->root.type == bfd_link_hash_defined
2707
       || h->root.type == bfd_link_hash_defweak)
2708
      && ((sec = h->root.u.def.section)->flags & SEC_MERGE)
2709
      && sec->sec_info_type == ELF_INFO_TYPE_MERGE)
2710
    {
2711
      bfd *output_bfd = (bfd *) data;
2712
 
2713
      h->root.u.def.value =
2714
        _bfd_merged_section_offset (output_bfd,
2715
                                    &h->root.u.def.section,
2716
                                    elf_section_data (sec)->sec_info,
2717
                                    h->root.u.def.value);
2718
    }
2719
 
2720
  return TRUE;
2721
}
2722
 
2723
/* Returns false if the symbol referred to by H should be considered
2724
   to resolve local to the current module, and true if it should be
2725
   considered to bind dynamically.  */
2726
 
2727
bfd_boolean
2728
_bfd_elf_dynamic_symbol_p (struct elf_link_hash_entry *h,
2729
                           struct bfd_link_info *info,
2730
                           bfd_boolean not_local_protected)
2731
{
2732
  bfd_boolean binding_stays_local_p;
2733
  const struct elf_backend_data *bed;
2734
  struct elf_link_hash_table *hash_table;
2735
 
2736
  if (h == NULL)
2737
    return FALSE;
2738
 
2739
  while (h->root.type == bfd_link_hash_indirect
2740
         || h->root.type == bfd_link_hash_warning)
2741
    h = (struct elf_link_hash_entry *) h->root.u.i.link;
2742
 
2743
  /* If it was forced local, then clearly it's not dynamic.  */
2744
  if (h->dynindx == -1)
2745
    return FALSE;
2746
  if (h->forced_local)
2747
    return FALSE;
2748
 
2749
  /* Identify the cases where name binding rules say that a
2750
     visible symbol resolves locally.  */
2751
  binding_stays_local_p = info->executable || SYMBOLIC_BIND (info, h);
2752
 
2753
  switch (ELF_ST_VISIBILITY (h->other))
2754
    {
2755
    case STV_INTERNAL:
2756
    case STV_HIDDEN:
2757
      return FALSE;
2758
 
2759
    case STV_PROTECTED:
2760
      hash_table = elf_hash_table (info);
2761
      if (!is_elf_hash_table (hash_table))
2762
        return FALSE;
2763
 
2764
      bed = get_elf_backend_data (hash_table->dynobj);
2765
 
2766
      /* Proper resolution for function pointer equality may require
2767
         that these symbols perhaps be resolved dynamically, even though
2768
         we should be resolving them to the current module.  */
2769
      if (!not_local_protected || !bed->is_function_type (h->type))
2770
        binding_stays_local_p = TRUE;
2771
      break;
2772
 
2773
    default:
2774
      break;
2775
    }
2776
 
2777
  /* If it isn't defined locally, then clearly it's dynamic.  */
2778
  if (!h->def_regular && !ELF_COMMON_DEF_P (h))
2779
    return TRUE;
2780
 
2781
  /* Otherwise, the symbol is dynamic if binding rules don't tell
2782
     us that it remains local.  */
2783
  return !binding_stays_local_p;
2784
}
2785
 
2786
/* Return true if the symbol referred to by H should be considered
2787
   to resolve local to the current module, and false otherwise.  Differs
2788
   from (the inverse of) _bfd_elf_dynamic_symbol_p in the treatment of
2789
   undefined symbols.  The two functions are virtually identical except
2790
   for the place where forced_local and dynindx == -1 are tested.  If
2791
   either of those tests are true, _bfd_elf_dynamic_symbol_p will say
2792
   the symbol is local, while _bfd_elf_symbol_refs_local_p will say
2793
   the symbol is local only for defined symbols.
2794
   It might seem that _bfd_elf_dynamic_symbol_p could be rewritten as
2795
   !_bfd_elf_symbol_refs_local_p, except that targets differ in their
2796
   treatment of undefined weak symbols.  For those that do not make
2797
   undefined weak symbols dynamic, both functions may return false.  */
2798
 
2799
bfd_boolean
2800
_bfd_elf_symbol_refs_local_p (struct elf_link_hash_entry *h,
2801
                              struct bfd_link_info *info,
2802
                              bfd_boolean local_protected)
2803
{
2804
  const struct elf_backend_data *bed;
2805
  struct elf_link_hash_table *hash_table;
2806
 
2807
  /* If it's a local sym, of course we resolve locally.  */
2808
  if (h == NULL)
2809
    return TRUE;
2810
 
2811
  /* STV_HIDDEN or STV_INTERNAL ones must be local.  */
2812
  if (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
2813
      || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL)
2814
    return TRUE;
2815
 
2816
  /* Common symbols that become definitions don't get the DEF_REGULAR
2817
     flag set, so test it first, and don't bail out.  */
2818
  if (ELF_COMMON_DEF_P (h))
2819
    /* Do nothing.  */;
2820
  /* If we don't have a definition in a regular file, then we can't
2821
     resolve locally.  The sym is either undefined or dynamic.  */
2822
  else if (!h->def_regular)
2823
    return FALSE;
2824
 
2825
  /* Forced local symbols resolve locally.  */
2826
  if (h->forced_local)
2827
    return TRUE;
2828
 
2829
  /* As do non-dynamic symbols.  */
2830
  if (h->dynindx == -1)
2831
    return TRUE;
2832
 
2833
  /* At this point, we know the symbol is defined and dynamic.  In an
2834
     executable it must resolve locally, likewise when building symbolic
2835
     shared libraries.  */
2836
  if (info->executable || SYMBOLIC_BIND (info, h))
2837
    return TRUE;
2838
 
2839
  /* Now deal with defined dynamic symbols in shared libraries.  Ones
2840
     with default visibility might not resolve locally.  */
2841
  if (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2842
    return FALSE;
2843
 
2844
  hash_table = elf_hash_table (info);
2845
  if (!is_elf_hash_table (hash_table))
2846
    return TRUE;
2847
 
2848
  bed = get_elf_backend_data (hash_table->dynobj);
2849
 
2850
  /* STV_PROTECTED non-function symbols are local.  */
2851
  if (!bed->is_function_type (h->type))
2852
    return TRUE;
2853
 
2854
  /* Function pointer equality tests may require that STV_PROTECTED
2855
     symbols be treated as dynamic symbols.  If the address of a
2856
     function not defined in an executable is set to that function's
2857
     plt entry in the executable, then the address of the function in
2858
     a shared library must also be the plt entry in the executable.  */
2859
  return local_protected;
2860
}
2861
 
2862
/* Caches some TLS segment info, and ensures that the TLS segment vma is
2863
   aligned.  Returns the first TLS output section.  */
2864
 
2865
struct bfd_section *
2866
_bfd_elf_tls_setup (bfd *obfd, struct bfd_link_info *info)
2867
{
2868
  struct bfd_section *sec, *tls;
2869
  unsigned int align = 0;
2870
 
2871
  for (sec = obfd->sections; sec != NULL; sec = sec->next)
2872
    if ((sec->flags & SEC_THREAD_LOCAL) != 0)
2873
      break;
2874
  tls = sec;
2875
 
2876
  for (; sec != NULL && (sec->flags & SEC_THREAD_LOCAL) != 0; sec = sec->next)
2877
    if (sec->alignment_power > align)
2878
      align = sec->alignment_power;
2879
 
2880
  elf_hash_table (info)->tls_sec = tls;
2881
 
2882
  /* Ensure the alignment of the first section is the largest alignment,
2883
     so that the tls segment starts aligned.  */
2884
  if (tls != NULL)
2885
    tls->alignment_power = align;
2886
 
2887
  return tls;
2888
}
2889
 
2890
/* Return TRUE iff this is a non-common, definition of a non-function symbol.  */
2891
static bfd_boolean
2892
is_global_data_symbol_definition (bfd *abfd ATTRIBUTE_UNUSED,
2893
                                  Elf_Internal_Sym *sym)
2894
{
2895
  const struct elf_backend_data *bed;
2896
 
2897
  /* Local symbols do not count, but target specific ones might.  */
2898
  if (ELF_ST_BIND (sym->st_info) != STB_GLOBAL
2899
      && ELF_ST_BIND (sym->st_info) < STB_LOOS)
2900
    return FALSE;
2901
 
2902
  bed = get_elf_backend_data (abfd);
2903
  /* Function symbols do not count.  */
2904
  if (bed->is_function_type (ELF_ST_TYPE (sym->st_info)))
2905
    return FALSE;
2906
 
2907
  /* If the section is undefined, then so is the symbol.  */
2908
  if (sym->st_shndx == SHN_UNDEF)
2909
    return FALSE;
2910
 
2911
  /* If the symbol is defined in the common section, then
2912
     it is a common definition and so does not count.  */
2913
  if (bed->common_definition (sym))
2914
    return FALSE;
2915
 
2916
  /* If the symbol is in a target specific section then we
2917
     must rely upon the backend to tell us what it is.  */
2918
  if (sym->st_shndx >= SHN_LORESERVE && sym->st_shndx < SHN_ABS)
2919
    /* FIXME - this function is not coded yet:
2920
 
2921
       return _bfd_is_global_symbol_definition (abfd, sym);
2922
 
2923
       Instead for now assume that the definition is not global,
2924
       Even if this is wrong, at least the linker will behave
2925
       in the same way that it used to do.  */
2926
    return FALSE;
2927
 
2928
  return TRUE;
2929
}
2930
 
2931
/* Search the symbol table of the archive element of the archive ABFD
2932
   whose archive map contains a mention of SYMDEF, and determine if
2933
   the symbol is defined in this element.  */
2934
static bfd_boolean
2935
elf_link_is_defined_archive_symbol (bfd * abfd, carsym * symdef)
2936
{
2937
  Elf_Internal_Shdr * hdr;
2938
  bfd_size_type symcount;
2939
  bfd_size_type extsymcount;
2940
  bfd_size_type extsymoff;
2941
  Elf_Internal_Sym *isymbuf;
2942
  Elf_Internal_Sym *isym;
2943
  Elf_Internal_Sym *isymend;
2944
  bfd_boolean result;
2945
 
2946
  abfd = _bfd_get_elt_at_filepos (abfd, symdef->file_offset);
2947
  if (abfd == NULL)
2948
    return FALSE;
2949
 
2950
  if (! bfd_check_format (abfd, bfd_object))
2951
    return FALSE;
2952
 
2953
  /* If we have already included the element containing this symbol in the
2954
     link then we do not need to include it again.  Just claim that any symbol
2955
     it contains is not a definition, so that our caller will not decide to
2956
     (re)include this element.  */
2957
  if (abfd->archive_pass)
2958
    return FALSE;
2959
 
2960
  /* Select the appropriate symbol table.  */
2961
  if ((abfd->flags & DYNAMIC) == 0 || elf_dynsymtab (abfd) == 0)
2962
    hdr = &elf_tdata (abfd)->symtab_hdr;
2963
  else
2964
    hdr = &elf_tdata (abfd)->dynsymtab_hdr;
2965
 
2966
  symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
2967
 
2968
  /* The sh_info field of the symtab header tells us where the
2969
     external symbols start.  We don't care about the local symbols.  */
2970
  if (elf_bad_symtab (abfd))
2971
    {
2972
      extsymcount = symcount;
2973
      extsymoff = 0;
2974
    }
2975
  else
2976
    {
2977
      extsymcount = symcount - hdr->sh_info;
2978
      extsymoff = hdr->sh_info;
2979
    }
2980
 
2981
  if (extsymcount == 0)
2982
    return FALSE;
2983
 
2984
  /* Read in the symbol table.  */
2985
  isymbuf = bfd_elf_get_elf_syms (abfd, hdr, extsymcount, extsymoff,
2986
                                  NULL, NULL, NULL);
2987
  if (isymbuf == NULL)
2988
    return FALSE;
2989
 
2990
  /* Scan the symbol table looking for SYMDEF.  */
2991
  result = FALSE;
2992
  for (isym = isymbuf, isymend = isymbuf + extsymcount; isym < isymend; isym++)
2993
    {
2994
      const char *name;
2995
 
2996
      name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
2997
                                              isym->st_name);
2998
      if (name == NULL)
2999
        break;
3000
 
3001
      if (strcmp (name, symdef->name) == 0)
3002
        {
3003
          result = is_global_data_symbol_definition (abfd, isym);
3004
          break;
3005
        }
3006
    }
3007
 
3008
  free (isymbuf);
3009
 
3010
  return result;
3011
}
3012
 
3013
/* Add an entry to the .dynamic table.  */
3014
 
3015
bfd_boolean
3016
_bfd_elf_add_dynamic_entry (struct bfd_link_info *info,
3017
                            bfd_vma tag,
3018
                            bfd_vma val)
3019
{
3020
  struct elf_link_hash_table *hash_table;
3021
  const struct elf_backend_data *bed;
3022
  asection *s;
3023
  bfd_size_type newsize;
3024
  bfd_byte *newcontents;
3025
  Elf_Internal_Dyn dyn;
3026
 
3027
  hash_table = elf_hash_table (info);
3028
  if (! is_elf_hash_table (hash_table))
3029
    return FALSE;
3030
 
3031
  bed = get_elf_backend_data (hash_table->dynobj);
3032
  s = bfd_get_section_by_name (hash_table->dynobj, ".dynamic");
3033
  BFD_ASSERT (s != NULL);
3034
 
3035
  newsize = s->size + bed->s->sizeof_dyn;
3036
  newcontents = (bfd_byte *) bfd_realloc (s->contents, newsize);
3037
  if (newcontents == NULL)
3038
    return FALSE;
3039
 
3040
  dyn.d_tag = tag;
3041
  dyn.d_un.d_val = val;
3042
  bed->s->swap_dyn_out (hash_table->dynobj, &dyn, newcontents + s->size);
3043
 
3044
  s->size = newsize;
3045
  s->contents = newcontents;
3046
 
3047
  return TRUE;
3048
}
3049
 
3050
/* Add a DT_NEEDED entry for this dynamic object if DO_IT is true,
3051
   otherwise just check whether one already exists.  Returns -1 on error,
3052
   1 if a DT_NEEDED tag already exists, and 0 on success.  */
3053
 
3054
static int
3055
elf_add_dt_needed_tag (bfd *abfd,
3056
                       struct bfd_link_info *info,
3057
                       const char *soname,
3058
                       bfd_boolean do_it)
3059
{
3060
  struct elf_link_hash_table *hash_table;
3061
  bfd_size_type oldsize;
3062
  bfd_size_type strindex;
3063
 
3064
  if (!_bfd_elf_link_create_dynstrtab (abfd, info))
3065
    return -1;
3066
 
3067
  hash_table = elf_hash_table (info);
3068
  oldsize = _bfd_elf_strtab_size (hash_table->dynstr);
3069
  strindex = _bfd_elf_strtab_add (hash_table->dynstr, soname, FALSE);
3070
  if (strindex == (bfd_size_type) -1)
3071
    return -1;
3072
 
3073
  if (oldsize == _bfd_elf_strtab_size (hash_table->dynstr))
3074
    {
3075
      asection *sdyn;
3076
      const struct elf_backend_data *bed;
3077
      bfd_byte *extdyn;
3078
 
3079
      bed = get_elf_backend_data (hash_table->dynobj);
3080
      sdyn = bfd_get_section_by_name (hash_table->dynobj, ".dynamic");
3081
      if (sdyn != NULL)
3082
        for (extdyn = sdyn->contents;
3083
             extdyn < sdyn->contents + sdyn->size;
3084
             extdyn += bed->s->sizeof_dyn)
3085
          {
3086
            Elf_Internal_Dyn dyn;
3087
 
3088
            bed->s->swap_dyn_in (hash_table->dynobj, extdyn, &dyn);
3089
            if (dyn.d_tag == DT_NEEDED
3090
                && dyn.d_un.d_val == strindex)
3091
              {
3092
                _bfd_elf_strtab_delref (hash_table->dynstr, strindex);
3093
                return 1;
3094
              }
3095
          }
3096
    }
3097
 
3098
  if (do_it)
3099
    {
3100
      if (!_bfd_elf_link_create_dynamic_sections (hash_table->dynobj, info))
3101
        return -1;
3102
 
3103
      if (!_bfd_elf_add_dynamic_entry (info, DT_NEEDED, strindex))
3104
        return -1;
3105
    }
3106
  else
3107
    /* We were just checking for existence of the tag.  */
3108
    _bfd_elf_strtab_delref (hash_table->dynstr, strindex);
3109
 
3110
  return 0;
3111
}
3112
 
3113
static bfd_boolean
3114
on_needed_list (const char *soname, struct bfd_link_needed_list *needed)
3115
{
3116
  for (; needed != NULL; needed = needed->next)
3117
    if (strcmp (soname, needed->name) == 0)
3118
      return TRUE;
3119
 
3120
  return FALSE;
3121
}
3122
 
3123
/* Sort symbol by value and section.  */
3124
static int
3125
elf_sort_symbol (const void *arg1, const void *arg2)
3126
{
3127
  const struct elf_link_hash_entry *h1;
3128
  const struct elf_link_hash_entry *h2;
3129
  bfd_signed_vma vdiff;
3130
 
3131
  h1 = *(const struct elf_link_hash_entry **) arg1;
3132
  h2 = *(const struct elf_link_hash_entry **) arg2;
3133
  vdiff = h1->root.u.def.value - h2->root.u.def.value;
3134
  if (vdiff != 0)
3135
    return vdiff > 0 ? 1 : -1;
3136
  else
3137
    {
3138
      long sdiff = h1->root.u.def.section->id - h2->root.u.def.section->id;
3139
      if (sdiff != 0)
3140
        return sdiff > 0 ? 1 : -1;
3141
    }
3142
  return 0;
3143
}
3144
 
3145
/* This function is used to adjust offsets into .dynstr for
3146
   dynamic symbols.  This is called via elf_link_hash_traverse.  */
3147
 
3148
static bfd_boolean
3149
elf_adjust_dynstr_offsets (struct elf_link_hash_entry *h, void *data)
3150
{
3151
  struct elf_strtab_hash *dynstr = (struct elf_strtab_hash *) data;
3152
 
3153
  if (h->dynindx != -1)
3154
    h->dynstr_index = _bfd_elf_strtab_offset (dynstr, h->dynstr_index);
3155
  return TRUE;
3156
}
3157
 
3158
/* Assign string offsets in .dynstr, update all structures referencing
3159
   them.  */
3160
 
3161
static bfd_boolean
3162
elf_finalize_dynstr (bfd *output_bfd, struct bfd_link_info *info)
3163
{
3164
  struct elf_link_hash_table *hash_table = elf_hash_table (info);
3165
  struct elf_link_local_dynamic_entry *entry;
3166
  struct elf_strtab_hash *dynstr = hash_table->dynstr;
3167
  bfd *dynobj = hash_table->dynobj;
3168
  asection *sdyn;
3169
  bfd_size_type size;
3170
  const struct elf_backend_data *bed;
3171
  bfd_byte *extdyn;
3172
 
3173
  _bfd_elf_strtab_finalize (dynstr);
3174
  size = _bfd_elf_strtab_size (dynstr);
3175
 
3176
  bed = get_elf_backend_data (dynobj);
3177
  sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3178
  BFD_ASSERT (sdyn != NULL);
3179
 
3180
  /* Update all .dynamic entries referencing .dynstr strings.  */
3181
  for (extdyn = sdyn->contents;
3182
       extdyn < sdyn->contents + sdyn->size;
3183
       extdyn += bed->s->sizeof_dyn)
3184
    {
3185
      Elf_Internal_Dyn dyn;
3186
 
3187
      bed->s->swap_dyn_in (dynobj, extdyn, &dyn);
3188
      switch (dyn.d_tag)
3189
        {
3190
        case DT_STRSZ:
3191
          dyn.d_un.d_val = size;
3192
          break;
3193
        case DT_NEEDED:
3194
        case DT_SONAME:
3195
        case DT_RPATH:
3196
        case DT_RUNPATH:
3197
        case DT_FILTER:
3198
        case DT_AUXILIARY:
3199
        case DT_AUDIT:
3200
        case DT_DEPAUDIT:
3201
          dyn.d_un.d_val = _bfd_elf_strtab_offset (dynstr, dyn.d_un.d_val);
3202
          break;
3203
        default:
3204
          continue;
3205
        }
3206
      bed->s->swap_dyn_out (dynobj, &dyn, extdyn);
3207
    }
3208
 
3209
  /* Now update local dynamic symbols.  */
3210
  for (entry = hash_table->dynlocal; entry ; entry = entry->next)
3211
    entry->isym.st_name = _bfd_elf_strtab_offset (dynstr,
3212
                                                  entry->isym.st_name);
3213
 
3214
  /* And the rest of dynamic symbols.  */
3215
  elf_link_hash_traverse (hash_table, elf_adjust_dynstr_offsets, dynstr);
3216
 
3217
  /* Adjust version definitions.  */
3218
  if (elf_tdata (output_bfd)->cverdefs)
3219
    {
3220
      asection *s;
3221
      bfd_byte *p;
3222
      bfd_size_type i;
3223
      Elf_Internal_Verdef def;
3224
      Elf_Internal_Verdaux defaux;
3225
 
3226
      s = bfd_get_section_by_name (dynobj, ".gnu.version_d");
3227
      p = s->contents;
3228
      do
3229
        {
3230
          _bfd_elf_swap_verdef_in (output_bfd, (Elf_External_Verdef *) p,
3231
                                   &def);
3232
          p += sizeof (Elf_External_Verdef);
3233
          if (def.vd_aux != sizeof (Elf_External_Verdef))
3234
            continue;
3235
          for (i = 0; i < def.vd_cnt; ++i)
3236
            {
3237
              _bfd_elf_swap_verdaux_in (output_bfd,
3238
                                        (Elf_External_Verdaux *) p, &defaux);
3239
              defaux.vda_name = _bfd_elf_strtab_offset (dynstr,
3240
                                                        defaux.vda_name);
3241
              _bfd_elf_swap_verdaux_out (output_bfd,
3242
                                         &defaux, (Elf_External_Verdaux *) p);
3243
              p += sizeof (Elf_External_Verdaux);
3244
            }
3245
        }
3246
      while (def.vd_next);
3247
    }
3248
 
3249
  /* Adjust version references.  */
3250
  if (elf_tdata (output_bfd)->verref)
3251
    {
3252
      asection *s;
3253
      bfd_byte *p;
3254
      bfd_size_type i;
3255
      Elf_Internal_Verneed need;
3256
      Elf_Internal_Vernaux needaux;
3257
 
3258
      s = bfd_get_section_by_name (dynobj, ".gnu.version_r");
3259
      p = s->contents;
3260
      do
3261
        {
3262
          _bfd_elf_swap_verneed_in (output_bfd, (Elf_External_Verneed *) p,
3263
                                    &need);
3264
          need.vn_file = _bfd_elf_strtab_offset (dynstr, need.vn_file);
3265
          _bfd_elf_swap_verneed_out (output_bfd, &need,
3266
                                     (Elf_External_Verneed *) p);
3267
          p += sizeof (Elf_External_Verneed);
3268
          for (i = 0; i < need.vn_cnt; ++i)
3269
            {
3270
              _bfd_elf_swap_vernaux_in (output_bfd,
3271
                                        (Elf_External_Vernaux *) p, &needaux);
3272
              needaux.vna_name = _bfd_elf_strtab_offset (dynstr,
3273
                                                         needaux.vna_name);
3274
              _bfd_elf_swap_vernaux_out (output_bfd,
3275
                                         &needaux,
3276
                                         (Elf_External_Vernaux *) p);
3277
              p += sizeof (Elf_External_Vernaux);
3278
            }
3279
        }
3280
      while (need.vn_next);
3281
    }
3282
 
3283
  return TRUE;
3284
}
3285
 
3286
/* Return TRUE iff relocations for INPUT are compatible with OUTPUT.
3287
   The default is to only match when the INPUT and OUTPUT are exactly
3288
   the same target.  */
3289
 
3290
bfd_boolean
3291
_bfd_elf_default_relocs_compatible (const bfd_target *input,
3292
                                    const bfd_target *output)
3293
{
3294
  return input == output;
3295
}
3296
 
3297
/* Return TRUE iff relocations for INPUT are compatible with OUTPUT.
3298
   This version is used when different targets for the same architecture
3299
   are virtually identical.  */
3300
 
3301
bfd_boolean
3302
_bfd_elf_relocs_compatible (const bfd_target *input,
3303
                            const bfd_target *output)
3304
{
3305
  const struct elf_backend_data *obed, *ibed;
3306
 
3307
  if (input == output)
3308
    return TRUE;
3309
 
3310
  ibed = xvec_get_elf_backend_data (input);
3311
  obed = xvec_get_elf_backend_data (output);
3312
 
3313
  if (ibed->arch != obed->arch)
3314
    return FALSE;
3315
 
3316
  /* If both backends are using this function, deem them compatible.  */
3317
  return ibed->relocs_compatible == obed->relocs_compatible;
3318
}
3319
 
3320
/* Add symbols from an ELF object file to the linker hash table.  */
3321
 
3322
static bfd_boolean
3323
elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
3324
{
3325
  Elf_Internal_Ehdr *ehdr;
3326
  Elf_Internal_Shdr *hdr;
3327
  bfd_size_type symcount;
3328
  bfd_size_type extsymcount;
3329
  bfd_size_type extsymoff;
3330
  struct elf_link_hash_entry **sym_hash;
3331
  bfd_boolean dynamic;
3332
  Elf_External_Versym *extversym = NULL;
3333
  Elf_External_Versym *ever;
3334
  struct elf_link_hash_entry *weaks;
3335
  struct elf_link_hash_entry **nondeflt_vers = NULL;
3336
  bfd_size_type nondeflt_vers_cnt = 0;
3337
  Elf_Internal_Sym *isymbuf = NULL;
3338
  Elf_Internal_Sym *isym;
3339
  Elf_Internal_Sym *isymend;
3340
  const struct elf_backend_data *bed;
3341
  bfd_boolean add_needed;
3342
  struct elf_link_hash_table *htab;
3343
  bfd_size_type amt;
3344
  void *alloc_mark = NULL;
3345
  struct bfd_hash_entry **old_table = NULL;
3346
  unsigned int old_size = 0;
3347
  unsigned int old_count = 0;
3348
  void *old_tab = NULL;
3349
  void *old_hash;
3350
  void *old_ent;
3351
  struct bfd_link_hash_entry *old_undefs = NULL;
3352
  struct bfd_link_hash_entry *old_undefs_tail = NULL;
3353
  long old_dynsymcount = 0;
3354
  size_t tabsize = 0;
3355
  size_t hashsize = 0;
3356
 
3357
  htab = elf_hash_table (info);
3358
  bed = get_elf_backend_data (abfd);
3359
 
3360
  if ((abfd->flags & DYNAMIC) == 0)
3361
    dynamic = FALSE;
3362
  else
3363
    {
3364
      dynamic = TRUE;
3365
 
3366
      /* You can't use -r against a dynamic object.  Also, there's no
3367
         hope of using a dynamic object which does not exactly match
3368
         the format of the output file.  */
3369
      if (info->relocatable
3370
          || !is_elf_hash_table (htab)
3371
          || info->output_bfd->xvec != abfd->xvec)
3372
        {
3373
          if (info->relocatable)
3374
            bfd_set_error (bfd_error_invalid_operation);
3375
          else
3376
            bfd_set_error (bfd_error_wrong_format);
3377
          goto error_return;
3378
        }
3379
    }
3380
 
3381
  ehdr = elf_elfheader (abfd);
3382
  if (info->warn_alternate_em
3383
      && bed->elf_machine_code != ehdr->e_machine
3384
      && ((bed->elf_machine_alt1 != 0
3385
           && ehdr->e_machine == bed->elf_machine_alt1)
3386
          || (bed->elf_machine_alt2 != 0
3387
              && ehdr->e_machine == bed->elf_machine_alt2)))
3388
    info->callbacks->einfo
3389
      (_("%P: alternate ELF machine code found (%d) in %B, expecting %d\n"),
3390
       ehdr->e_machine, abfd, bed->elf_machine_code);
3391
 
3392
  /* As a GNU extension, any input sections which are named
3393
     .gnu.warning.SYMBOL are treated as warning symbols for the given
3394
     symbol.  This differs from .gnu.warning sections, which generate
3395
     warnings when they are included in an output file.  */
3396
  /* PR 12761: Also generate this warning when building shared libraries.  */
3397
  if (info->executable || info->shared)
3398
    {
3399
      asection *s;
3400
 
3401
      for (s = abfd->sections; s != NULL; s = s->next)
3402
        {
3403
          const char *name;
3404
 
3405
          name = bfd_get_section_name (abfd, s);
3406
          if (CONST_STRNEQ (name, ".gnu.warning."))
3407
            {
3408
              char *msg;
3409
              bfd_size_type sz;
3410
 
3411
              name += sizeof ".gnu.warning." - 1;
3412
 
3413
              /* If this is a shared object, then look up the symbol
3414
                 in the hash table.  If it is there, and it is already
3415
                 been defined, then we will not be using the entry
3416
                 from this shared object, so we don't need to warn.
3417
                 FIXME: If we see the definition in a regular object
3418
                 later on, we will warn, but we shouldn't.  The only
3419
                 fix is to keep track of what warnings we are supposed
3420
                 to emit, and then handle them all at the end of the
3421
                 link.  */
3422
              if (dynamic)
3423
                {
3424
                  struct elf_link_hash_entry *h;
3425
 
3426
                  h = elf_link_hash_lookup (htab, name, FALSE, FALSE, TRUE);
3427
 
3428
                  /* FIXME: What about bfd_link_hash_common?  */
3429
                  if (h != NULL
3430
                      && (h->root.type == bfd_link_hash_defined
3431
                          || h->root.type == bfd_link_hash_defweak))
3432
                    {
3433
                      /* We don't want to issue this warning.  Clobber
3434
                         the section size so that the warning does not
3435
                         get copied into the output file.  */
3436
                      s->size = 0;
3437
                      continue;
3438
                    }
3439
                }
3440
 
3441
              sz = s->size;
3442
              msg = (char *) bfd_alloc (abfd, sz + 1);
3443
              if (msg == NULL)
3444
                goto error_return;
3445
 
3446
              if (! bfd_get_section_contents (abfd, s, msg, 0, sz))
3447
                goto error_return;
3448
 
3449
              msg[sz] = '\0';
3450
 
3451
              if (! (_bfd_generic_link_add_one_symbol
3452
                     (info, abfd, name, BSF_WARNING, s, 0, msg,
3453
                      FALSE, bed->collect, NULL)))
3454
                goto error_return;
3455
 
3456
              if (! info->relocatable)
3457
                {
3458
                  /* Clobber the section size so that the warning does
3459
                     not get copied into the output file.  */
3460
                  s->size = 0;
3461
 
3462
                  /* Also set SEC_EXCLUDE, so that symbols defined in
3463
                     the warning section don't get copied to the output.  */
3464
                  s->flags |= SEC_EXCLUDE;
3465
                }
3466
            }
3467
        }
3468
    }
3469
 
3470
  add_needed = TRUE;
3471
  if (! dynamic)
3472
    {
3473
      /* If we are creating a shared library, create all the dynamic
3474
         sections immediately.  We need to attach them to something,
3475
         so we attach them to this BFD, provided it is the right
3476
         format.  FIXME: If there are no input BFD's of the same
3477
         format as the output, we can't make a shared library.  */
3478
      if (info->shared
3479
          && is_elf_hash_table (htab)
3480
          && info->output_bfd->xvec == abfd->xvec
3481
          && !htab->dynamic_sections_created)
3482
        {
3483
          if (! _bfd_elf_link_create_dynamic_sections (abfd, info))
3484
            goto error_return;
3485
        }
3486
    }
3487
  else if (!is_elf_hash_table (htab))
3488
    goto error_return;
3489
  else
3490
    {
3491
      asection *s;
3492
      const char *soname = NULL;
3493
      char *audit = NULL;
3494
      struct bfd_link_needed_list *rpath = NULL, *runpath = NULL;
3495
      int ret;
3496
 
3497
      /* ld --just-symbols and dynamic objects don't mix very well.
3498
         ld shouldn't allow it.  */
3499
      if ((s = abfd->sections) != NULL
3500
          && s->sec_info_type == ELF_INFO_TYPE_JUST_SYMS)
3501
        abort ();
3502
 
3503
      /* If this dynamic lib was specified on the command line with
3504
         --as-needed in effect, then we don't want to add a DT_NEEDED
3505
         tag unless the lib is actually used.  Similary for libs brought
3506
         in by another lib's DT_NEEDED.  When --no-add-needed is used
3507
         on a dynamic lib, we don't want to add a DT_NEEDED entry for
3508
         any dynamic library in DT_NEEDED tags in the dynamic lib at
3509
         all.  */
3510
      add_needed = (elf_dyn_lib_class (abfd)
3511
                    & (DYN_AS_NEEDED | DYN_DT_NEEDED
3512
                       | DYN_NO_NEEDED)) == 0;
3513
 
3514
      s = bfd_get_section_by_name (abfd, ".dynamic");
3515
      if (s != NULL)
3516
        {
3517
          bfd_byte *dynbuf;
3518
          bfd_byte *extdyn;
3519
          unsigned int elfsec;
3520
          unsigned long shlink;
3521
 
3522
          if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
3523
            {
3524
error_free_dyn:
3525
              free (dynbuf);
3526
              goto error_return;
3527
            }
3528
 
3529
          elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
3530
          if (elfsec == SHN_BAD)
3531
            goto error_free_dyn;
3532
          shlink = elf_elfsections (abfd)[elfsec]->sh_link;
3533
 
3534
          for (extdyn = dynbuf;
3535
               extdyn < dynbuf + s->size;
3536
               extdyn += bed->s->sizeof_dyn)
3537
            {
3538
              Elf_Internal_Dyn dyn;
3539
 
3540
              bed->s->swap_dyn_in (abfd, extdyn, &dyn);
3541
              if (dyn.d_tag == DT_SONAME)
3542
                {
3543
                  unsigned int tagv = dyn.d_un.d_val;
3544
                  soname = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3545
                  if (soname == NULL)
3546
                    goto error_free_dyn;
3547
                }
3548
              if (dyn.d_tag == DT_NEEDED)
3549
                {
3550
                  struct bfd_link_needed_list *n, **pn;
3551
                  char *fnm, *anm;
3552
                  unsigned int tagv = dyn.d_un.d_val;
3553
 
3554
                  amt = sizeof (struct bfd_link_needed_list);
3555
                  n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
3556
                  fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3557
                  if (n == NULL || fnm == NULL)
3558
                    goto error_free_dyn;
3559
                  amt = strlen (fnm) + 1;
3560
                  anm = (char *) bfd_alloc (abfd, amt);
3561
                  if (anm == NULL)
3562
                    goto error_free_dyn;
3563
                  memcpy (anm, fnm, amt);
3564
                  n->name = anm;
3565
                  n->by = abfd;
3566
                  n->next = NULL;
3567
                  for (pn = &htab->needed; *pn != NULL; pn = &(*pn)->next)
3568
                    ;
3569
                  *pn = n;
3570
                }
3571
              if (dyn.d_tag == DT_RUNPATH)
3572
                {
3573
                  struct bfd_link_needed_list *n, **pn;
3574
                  char *fnm, *anm;
3575
                  unsigned int tagv = dyn.d_un.d_val;
3576
 
3577
                  amt = sizeof (struct bfd_link_needed_list);
3578
                  n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
3579
                  fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3580
                  if (n == NULL || fnm == NULL)
3581
                    goto error_free_dyn;
3582
                  amt = strlen (fnm) + 1;
3583
                  anm = (char *) bfd_alloc (abfd, amt);
3584
                  if (anm == NULL)
3585
                    goto error_free_dyn;
3586
                  memcpy (anm, fnm, amt);
3587
                  n->name = anm;
3588
                  n->by = abfd;
3589
                  n->next = NULL;
3590
                  for (pn = & runpath;
3591
                       *pn != NULL;
3592
                       pn = &(*pn)->next)
3593
                    ;
3594
                  *pn = n;
3595
                }
3596
              /* Ignore DT_RPATH if we have seen DT_RUNPATH.  */
3597
              if (!runpath && dyn.d_tag == DT_RPATH)
3598
                {
3599
                  struct bfd_link_needed_list *n, **pn;
3600
                  char *fnm, *anm;
3601
                  unsigned int tagv = dyn.d_un.d_val;
3602
 
3603
                  amt = sizeof (struct bfd_link_needed_list);
3604
                  n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
3605
                  fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3606
                  if (n == NULL || fnm == NULL)
3607
                    goto error_free_dyn;
3608
                  amt = strlen (fnm) + 1;
3609
                  anm = (char *) bfd_alloc (abfd, amt);
3610
                  if (anm == NULL)
3611
                    goto error_free_dyn;
3612
                  memcpy (anm, fnm, amt);
3613
                  n->name = anm;
3614
                  n->by = abfd;
3615
                  n->next = NULL;
3616
                  for (pn = & rpath;
3617
                       *pn != NULL;
3618
                       pn = &(*pn)->next)
3619
                    ;
3620
                  *pn = n;
3621
                }
3622
              if (dyn.d_tag == DT_AUDIT)
3623
                {
3624
                  unsigned int tagv = dyn.d_un.d_val;
3625
                  audit = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
3626
                }
3627
            }
3628
 
3629
          free (dynbuf);
3630
        }
3631
 
3632
      /* DT_RUNPATH overrides DT_RPATH.  Do _NOT_ bfd_release, as that
3633
         frees all more recently bfd_alloc'd blocks as well.  */
3634
      if (runpath)
3635
        rpath = runpath;
3636
 
3637
      if (rpath)
3638
        {
3639
          struct bfd_link_needed_list **pn;
3640
          for (pn = &htab->runpath; *pn != NULL; pn = &(*pn)->next)
3641
            ;
3642
          *pn = rpath;
3643
        }
3644
 
3645
      /* We do not want to include any of the sections in a dynamic
3646
         object in the output file.  We hack by simply clobbering the
3647
         list of sections in the BFD.  This could be handled more
3648
         cleanly by, say, a new section flag; the existing
3649
         SEC_NEVER_LOAD flag is not the one we want, because that one
3650
         still implies that the section takes up space in the output
3651
         file.  */
3652
      bfd_section_list_clear (abfd);
3653
 
3654
      /* Find the name to use in a DT_NEEDED entry that refers to this
3655
         object.  If the object has a DT_SONAME entry, we use it.
3656
         Otherwise, if the generic linker stuck something in
3657
         elf_dt_name, we use that.  Otherwise, we just use the file
3658
         name.  */
3659
      if (soname == NULL || *soname == '\0')
3660
        {
3661
          soname = elf_dt_name (abfd);
3662
          if (soname == NULL || *soname == '\0')
3663
            soname = bfd_get_filename (abfd);
3664
        }
3665
 
3666
      /* Save the SONAME because sometimes the linker emulation code
3667
         will need to know it.  */
3668
      elf_dt_name (abfd) = soname;
3669
 
3670
      ret = elf_add_dt_needed_tag (abfd, info, soname, add_needed);
3671
      if (ret < 0)
3672
        goto error_return;
3673
 
3674
      /* If we have already included this dynamic object in the
3675
         link, just ignore it.  There is no reason to include a
3676
         particular dynamic object more than once.  */
3677
      if (ret > 0)
3678
        return TRUE;
3679
 
3680
      /* Save the DT_AUDIT entry for the linker emulation code. */
3681
      elf_dt_audit (abfd) = audit;
3682
    }
3683
 
3684
  /* If this is a dynamic object, we always link against the .dynsym
3685
     symbol table, not the .symtab symbol table.  The dynamic linker
3686
     will only see the .dynsym symbol table, so there is no reason to
3687
     look at .symtab for a dynamic object.  */
3688
 
3689
  if (! dynamic || elf_dynsymtab (abfd) == 0)
3690
    hdr = &elf_tdata (abfd)->symtab_hdr;
3691
  else
3692
    hdr = &elf_tdata (abfd)->dynsymtab_hdr;
3693
 
3694
  symcount = hdr->sh_size / bed->s->sizeof_sym;
3695
 
3696
  /* The sh_info field of the symtab header tells us where the
3697
     external symbols start.  We don't care about the local symbols at
3698
     this point.  */
3699
  if (elf_bad_symtab (abfd))
3700
    {
3701
      extsymcount = symcount;
3702
      extsymoff = 0;
3703
    }
3704
  else
3705
    {
3706
      extsymcount = symcount - hdr->sh_info;
3707
      extsymoff = hdr->sh_info;
3708
    }
3709
 
3710
  sym_hash = NULL;
3711
  if (extsymcount != 0)
3712
    {
3713
      isymbuf = bfd_elf_get_elf_syms (abfd, hdr, extsymcount, extsymoff,
3714
                                      NULL, NULL, NULL);
3715
      if (isymbuf == NULL)
3716
        goto error_return;
3717
 
3718
      /* We store a pointer to the hash table entry for each external
3719
         symbol.  */
3720
      amt = extsymcount * sizeof (struct elf_link_hash_entry *);
3721
      sym_hash = (struct elf_link_hash_entry **) bfd_alloc (abfd, amt);
3722
      if (sym_hash == NULL)
3723
        goto error_free_sym;
3724
      elf_sym_hashes (abfd) = sym_hash;
3725
    }
3726
 
3727
  if (dynamic)
3728
    {
3729
      /* Read in any version definitions.  */
3730
      if (!_bfd_elf_slurp_version_tables (abfd,
3731
                                          info->default_imported_symver))
3732
        goto error_free_sym;
3733
 
3734
      /* Read in the symbol versions, but don't bother to convert them
3735
         to internal format.  */
3736
      if (elf_dynversym (abfd) != 0)
3737
        {
3738
          Elf_Internal_Shdr *versymhdr;
3739
 
3740
          versymhdr = &elf_tdata (abfd)->dynversym_hdr;
3741
          extversym = (Elf_External_Versym *) bfd_malloc (versymhdr->sh_size);
3742
          if (extversym == NULL)
3743
            goto error_free_sym;
3744
          amt = versymhdr->sh_size;
3745
          if (bfd_seek (abfd, versymhdr->sh_offset, SEEK_SET) != 0
3746
              || bfd_bread (extversym, amt, abfd) != amt)
3747
            goto error_free_vers;
3748
        }
3749
    }
3750
 
3751
  /* If we are loading an as-needed shared lib, save the symbol table
3752
     state before we start adding symbols.  If the lib turns out
3753
     to be unneeded, restore the state.  */
3754
  if ((elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0)
3755
    {
3756
      unsigned int i;
3757
      size_t entsize;
3758
 
3759
      for (entsize = 0, i = 0; i < htab->root.table.size; i++)
3760
        {
3761
          struct bfd_hash_entry *p;
3762
          struct elf_link_hash_entry *h;
3763
 
3764
          for (p = htab->root.table.table[i]; p != NULL; p = p->next)
3765
            {
3766
              h = (struct elf_link_hash_entry *) p;
3767
              entsize += htab->root.table.entsize;
3768
              if (h->root.type == bfd_link_hash_warning)
3769
                entsize += htab->root.table.entsize;
3770
            }
3771
        }
3772
 
3773
      tabsize = htab->root.table.size * sizeof (struct bfd_hash_entry *);
3774
      hashsize = extsymcount * sizeof (struct elf_link_hash_entry *);
3775
      old_tab = bfd_malloc (tabsize + entsize + hashsize);
3776
      if (old_tab == NULL)
3777
        goto error_free_vers;
3778
 
3779
      /* Remember the current objalloc pointer, so that all mem for
3780
         symbols added can later be reclaimed.  */
3781
      alloc_mark = bfd_hash_allocate (&htab->root.table, 1);
3782
      if (alloc_mark == NULL)
3783
        goto error_free_vers;
3784
 
3785
      /* Make a special call to the linker "notice" function to
3786
         tell it that we are about to handle an as-needed lib.  */
3787
      if (!(*info->callbacks->notice) (info, NULL, abfd, NULL,
3788
                                       notice_as_needed, 0, NULL))
3789
        goto error_free_vers;
3790
 
3791
      /* Clone the symbol table and sym hashes.  Remember some
3792
         pointers into the symbol table, and dynamic symbol count.  */
3793
      old_hash = (char *) old_tab + tabsize;
3794
      old_ent = (char *) old_hash + hashsize;
3795
      memcpy (old_tab, htab->root.table.table, tabsize);
3796
      memcpy (old_hash, sym_hash, hashsize);
3797
      old_undefs = htab->root.undefs;
3798
      old_undefs_tail = htab->root.undefs_tail;
3799
      old_table = htab->root.table.table;
3800
      old_size = htab->root.table.size;
3801
      old_count = htab->root.table.count;
3802
      old_dynsymcount = htab->dynsymcount;
3803
 
3804
      for (i = 0; i < htab->root.table.size; i++)
3805
        {
3806
          struct bfd_hash_entry *p;
3807
          struct elf_link_hash_entry *h;
3808
 
3809
          for (p = htab->root.table.table[i]; p != NULL; p = p->next)
3810
            {
3811
              memcpy (old_ent, p, htab->root.table.entsize);
3812
              old_ent = (char *) old_ent + htab->root.table.entsize;
3813
              h = (struct elf_link_hash_entry *) p;
3814
              if (h->root.type == bfd_link_hash_warning)
3815
                {
3816
                  memcpy (old_ent, h->root.u.i.link, htab->root.table.entsize);
3817
                  old_ent = (char *) old_ent + htab->root.table.entsize;
3818
                }
3819
            }
3820
        }
3821
    }
3822
 
3823
  weaks = NULL;
3824
  ever = extversym != NULL ? extversym + extsymoff : NULL;
3825
  for (isym = isymbuf, isymend = isymbuf + extsymcount;
3826
       isym < isymend;
3827
       isym++, sym_hash++, ever = (ever != NULL ? ever + 1 : NULL))
3828
    {
3829
      int bind;
3830
      bfd_vma value;
3831
      asection *sec, *new_sec;
3832
      flagword flags;
3833
      const char *name;
3834
      struct elf_link_hash_entry *h;
3835
      bfd_boolean definition;
3836
      bfd_boolean size_change_ok;
3837
      bfd_boolean type_change_ok;
3838
      bfd_boolean new_weakdef;
3839
      bfd_boolean override;
3840
      bfd_boolean common;
3841
      unsigned int old_alignment;
3842
      bfd *old_bfd;
3843
      bfd * undef_bfd = NULL;
3844
 
3845
      override = FALSE;
3846
 
3847
      flags = BSF_NO_FLAGS;
3848
      sec = NULL;
3849
      value = isym->st_value;
3850
      *sym_hash = NULL;
3851
      common = bed->common_definition (isym);
3852
 
3853
      bind = ELF_ST_BIND (isym->st_info);
3854
      switch (bind)
3855
        {
3856
        case STB_LOCAL:
3857
          /* This should be impossible, since ELF requires that all
3858
             global symbols follow all local symbols, and that sh_info
3859
             point to the first global symbol.  Unfortunately, Irix 5
3860
             screws this up.  */
3861
          continue;
3862
 
3863
        case STB_GLOBAL:
3864
          if (isym->st_shndx != SHN_UNDEF && !common)
3865
            flags = BSF_GLOBAL;
3866
          break;
3867
 
3868
        case STB_WEAK:
3869
          flags = BSF_WEAK;
3870
          break;
3871
 
3872
        case STB_GNU_UNIQUE:
3873
          flags = BSF_GNU_UNIQUE;
3874
          break;
3875
 
3876
        default:
3877
          /* Leave it up to the processor backend.  */
3878
          break;
3879
        }
3880
 
3881
      if (isym->st_shndx == SHN_UNDEF)
3882
        sec = bfd_und_section_ptr;
3883
      else if (isym->st_shndx == SHN_ABS)
3884
        sec = bfd_abs_section_ptr;
3885
      else if (isym->st_shndx == SHN_COMMON)
3886
        {
3887
          sec = bfd_com_section_ptr;
3888
          /* What ELF calls the size we call the value.  What ELF
3889
             calls the value we call the alignment.  */
3890
          value = isym->st_size;
3891
        }
3892
      else
3893
        {
3894
          sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
3895
          if (sec == NULL)
3896
            sec = bfd_abs_section_ptr;
3897 161 khays
          else if (elf_discarded_section (sec))
3898 14 khays
            {
3899
              /* Symbols from discarded section are undefined.  We keep
3900
                 its visibility.  */
3901
              sec = bfd_und_section_ptr;
3902
              isym->st_shndx = SHN_UNDEF;
3903
            }
3904
          else if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
3905
            value -= sec->vma;
3906
        }
3907
 
3908
      name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
3909
                                              isym->st_name);
3910
      if (name == NULL)
3911
        goto error_free_vers;
3912
 
3913
      if (isym->st_shndx == SHN_COMMON
3914
          && (abfd->flags & BFD_PLUGIN) != 0)
3915
        {
3916
          asection *xc = bfd_get_section_by_name (abfd, "COMMON");
3917
 
3918
          if (xc == NULL)
3919
            {
3920
              flagword sflags = (SEC_ALLOC | SEC_IS_COMMON | SEC_KEEP
3921
                                 | SEC_EXCLUDE);
3922
              xc = bfd_make_section_with_flags (abfd, "COMMON", sflags);
3923
              if (xc == NULL)
3924
                goto error_free_vers;
3925
            }
3926
          sec = xc;
3927
        }
3928
      else if (isym->st_shndx == SHN_COMMON
3929
               && ELF_ST_TYPE (isym->st_info) == STT_TLS
3930
               && !info->relocatable)
3931
        {
3932
          asection *tcomm = bfd_get_section_by_name (abfd, ".tcommon");
3933
 
3934
          if (tcomm == NULL)
3935
            {
3936
              flagword sflags = (SEC_ALLOC | SEC_THREAD_LOCAL | SEC_IS_COMMON
3937
                                 | SEC_LINKER_CREATED);
3938
              tcomm = bfd_make_section_with_flags (abfd, ".tcommon", sflags);
3939
              if (tcomm == NULL)
3940
                goto error_free_vers;
3941
            }
3942
          sec = tcomm;
3943
        }
3944
      else if (bed->elf_add_symbol_hook)
3945
        {
3946
          if (! (*bed->elf_add_symbol_hook) (abfd, info, isym, &name, &flags,
3947
                                             &sec, &value))
3948
            goto error_free_vers;
3949
 
3950
          /* The hook function sets the name to NULL if this symbol
3951
             should be skipped for some reason.  */
3952
          if (name == NULL)
3953
            continue;
3954
        }
3955
 
3956
      /* Sanity check that all possibilities were handled.  */
3957
      if (sec == NULL)
3958
        {
3959
          bfd_set_error (bfd_error_bad_value);
3960
          goto error_free_vers;
3961
        }
3962
 
3963
      if (bfd_is_und_section (sec)
3964
          || bfd_is_com_section (sec))
3965
        definition = FALSE;
3966
      else
3967
        definition = TRUE;
3968
 
3969
      size_change_ok = FALSE;
3970
      type_change_ok = bed->type_change_ok;
3971
      old_alignment = 0;
3972
      old_bfd = NULL;
3973
      new_sec = sec;
3974
 
3975
      if (is_elf_hash_table (htab))
3976
        {
3977
          Elf_Internal_Versym iver;
3978
          unsigned int vernum = 0;
3979
          bfd_boolean skip;
3980
 
3981
          /* If this is a definition of a symbol which was previously
3982
             referenced in a non-weak manner then make a note of the bfd
3983
             that contained the reference.  This is used if we need to
3984
             refer to the source of the reference later on.  */
3985
          if (! bfd_is_und_section (sec))
3986
            {
3987
              h = elf_link_hash_lookup (elf_hash_table (info), name, FALSE, FALSE, FALSE);
3988
 
3989
              if (h != NULL
3990
                  && h->root.type == bfd_link_hash_undefined
3991
                  && h->root.u.undef.abfd)
3992
                undef_bfd = h->root.u.undef.abfd;
3993
            }
3994
 
3995
          if (ever == NULL)
3996
            {
3997
              if (info->default_imported_symver)
3998
                /* Use the default symbol version created earlier.  */
3999
                iver.vs_vers = elf_tdata (abfd)->cverdefs;
4000
              else
4001
                iver.vs_vers = 0;
4002
            }
4003
          else
4004
            _bfd_elf_swap_versym_in (abfd, ever, &iver);
4005
 
4006
          vernum = iver.vs_vers & VERSYM_VERSION;
4007
 
4008
          /* If this is a hidden symbol, or if it is not version
4009
             1, we append the version name to the symbol name.
4010
             However, we do not modify a non-hidden absolute symbol
4011
             if it is not a function, because it might be the version
4012
             symbol itself.  FIXME: What if it isn't?  */
4013
          if ((iver.vs_vers & VERSYM_HIDDEN) != 0
4014
              || (vernum > 1
4015
                  && (!bfd_is_abs_section (sec)
4016
                      || bed->is_function_type (ELF_ST_TYPE (isym->st_info)))))
4017
            {
4018
              const char *verstr;
4019
              size_t namelen, verlen, newlen;
4020
              char *newname, *p;
4021
 
4022
              if (isym->st_shndx != SHN_UNDEF)
4023
                {
4024
                  if (vernum > elf_tdata (abfd)->cverdefs)
4025
                    verstr = NULL;
4026
                  else if (vernum > 1)
4027
                    verstr =
4028
                      elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
4029
                  else
4030
                    verstr = "";
4031
 
4032
                  if (verstr == NULL)
4033
                    {
4034
                      (*_bfd_error_handler)
4035
                        (_("%B: %s: invalid version %u (max %d)"),
4036
                         abfd, name, vernum,
4037
                         elf_tdata (abfd)->cverdefs);
4038
                      bfd_set_error (bfd_error_bad_value);
4039
                      goto error_free_vers;
4040
                    }
4041
                }
4042
              else
4043
                {
4044
                  /* We cannot simply test for the number of
4045
                     entries in the VERNEED section since the
4046
                     numbers for the needed versions do not start
4047
                     at 0.  */
4048
                  Elf_Internal_Verneed *t;
4049
 
4050
                  verstr = NULL;
4051
                  for (t = elf_tdata (abfd)->verref;
4052
                       t != NULL;
4053
                       t = t->vn_nextref)
4054
                    {
4055
                      Elf_Internal_Vernaux *a;
4056
 
4057
                      for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
4058
                        {
4059
                          if (a->vna_other == vernum)
4060
                            {
4061
                              verstr = a->vna_nodename;
4062
                              break;
4063
                            }
4064
                        }
4065
                      if (a != NULL)
4066
                        break;
4067
                    }
4068
                  if (verstr == NULL)
4069
                    {
4070
                      (*_bfd_error_handler)
4071
                        (_("%B: %s: invalid needed version %d"),
4072
                         abfd, name, vernum);
4073
                      bfd_set_error (bfd_error_bad_value);
4074
                      goto error_free_vers;
4075
                    }
4076
                }
4077
 
4078
              namelen = strlen (name);
4079
              verlen = strlen (verstr);
4080
              newlen = namelen + verlen + 2;
4081
              if ((iver.vs_vers & VERSYM_HIDDEN) == 0
4082
                  && isym->st_shndx != SHN_UNDEF)
4083
                ++newlen;
4084
 
4085
              newname = (char *) bfd_hash_allocate (&htab->root.table, newlen);
4086
              if (newname == NULL)
4087
                goto error_free_vers;
4088
              memcpy (newname, name, namelen);
4089
              p = newname + namelen;
4090
              *p++ = ELF_VER_CHR;
4091
              /* If this is a defined non-hidden version symbol,
4092
                 we add another @ to the name.  This indicates the
4093
                 default version of the symbol.  */
4094
              if ((iver.vs_vers & VERSYM_HIDDEN) == 0
4095
                  && isym->st_shndx != SHN_UNDEF)
4096
                *p++ = ELF_VER_CHR;
4097
              memcpy (p, verstr, verlen + 1);
4098
 
4099
              name = newname;
4100
            }
4101
 
4102
          /* If necessary, make a second attempt to locate the bfd
4103
             containing an unresolved, non-weak reference to the
4104
             current symbol.  */
4105
          if (! bfd_is_und_section (sec) && undef_bfd == NULL)
4106
            {
4107
              h = elf_link_hash_lookup (elf_hash_table (info), name, FALSE, FALSE, FALSE);
4108
 
4109
              if (h != NULL
4110
                  && h->root.type == bfd_link_hash_undefined
4111
                  && h->root.u.undef.abfd)
4112
                undef_bfd = h->root.u.undef.abfd;
4113
            }
4114
 
4115
          if (!_bfd_elf_merge_symbol (abfd, info, name, isym, &sec,
4116
                                      &value, &old_alignment,
4117
                                      sym_hash, &skip, &override,
4118
                                      &type_change_ok, &size_change_ok))
4119
            goto error_free_vers;
4120
 
4121
          if (skip)
4122
            continue;
4123
 
4124
          if (override)
4125
            definition = FALSE;
4126
 
4127
          h = *sym_hash;
4128
          while (h->root.type == bfd_link_hash_indirect
4129
                 || h->root.type == bfd_link_hash_warning)
4130
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
4131
 
4132
          /* Remember the old alignment if this is a common symbol, so
4133
             that we don't reduce the alignment later on.  We can't
4134
             check later, because _bfd_generic_link_add_one_symbol
4135
             will set a default for the alignment which we want to
4136
             override. We also remember the old bfd where the existing
4137
             definition comes from.  */
4138
          switch (h->root.type)
4139
            {
4140
            default:
4141
              break;
4142
 
4143
            case bfd_link_hash_defined:
4144
            case bfd_link_hash_defweak:
4145
              old_bfd = h->root.u.def.section->owner;
4146
              break;
4147
 
4148
            case bfd_link_hash_common:
4149
              old_bfd = h->root.u.c.p->section->owner;
4150
              old_alignment = h->root.u.c.p->alignment_power;
4151
              break;
4152
            }
4153
 
4154
          if (elf_tdata (abfd)->verdef != NULL
4155
              && ! override
4156
              && vernum > 1
4157
              && definition)
4158
            h->verinfo.verdef = &elf_tdata (abfd)->verdef[vernum - 1];
4159
        }
4160
 
4161
      if (! (_bfd_generic_link_add_one_symbol
4162
             (info, abfd, name, flags, sec, value, NULL, FALSE, bed->collect,
4163
              (struct bfd_link_hash_entry **) sym_hash)))
4164
        goto error_free_vers;
4165
 
4166
      h = *sym_hash;
4167
      while (h->root.type == bfd_link_hash_indirect
4168
             || h->root.type == bfd_link_hash_warning)
4169
        h = (struct elf_link_hash_entry *) h->root.u.i.link;
4170
 
4171
      *sym_hash = h;
4172
      if (is_elf_hash_table (htab))
4173
        h->unique_global = (flags & BSF_GNU_UNIQUE) != 0;
4174
 
4175
      new_weakdef = FALSE;
4176
      if (dynamic
4177
          && definition
4178
          && (flags & BSF_WEAK) != 0
4179
          && !bed->is_function_type (ELF_ST_TYPE (isym->st_info))
4180
          && is_elf_hash_table (htab)
4181
          && h->u.weakdef == NULL)
4182
        {
4183
          /* Keep a list of all weak defined non function symbols from
4184
             a dynamic object, using the weakdef field.  Later in this
4185
             function we will set the weakdef field to the correct
4186
             value.  We only put non-function symbols from dynamic
4187
             objects on this list, because that happens to be the only
4188
             time we need to know the normal symbol corresponding to a
4189
             weak symbol, and the information is time consuming to
4190
             figure out.  If the weakdef field is not already NULL,
4191
             then this symbol was already defined by some previous
4192
             dynamic object, and we will be using that previous
4193
             definition anyhow.  */
4194
 
4195
          h->u.weakdef = weaks;
4196
          weaks = h;
4197
          new_weakdef = TRUE;
4198
        }
4199
 
4200
      /* Set the alignment of a common symbol.  */
4201
      if ((common || bfd_is_com_section (sec))
4202
          && h->root.type == bfd_link_hash_common)
4203
        {
4204
          unsigned int align;
4205
 
4206
          if (common)
4207
            align = bfd_log2 (isym->st_value);
4208
          else
4209
            {
4210
              /* The new symbol is a common symbol in a shared object.
4211
                 We need to get the alignment from the section.  */
4212
              align = new_sec->alignment_power;
4213
            }
4214
          if (align > old_alignment)
4215
            h->root.u.c.p->alignment_power = align;
4216
          else
4217
            h->root.u.c.p->alignment_power = old_alignment;
4218
        }
4219
 
4220
      if (is_elf_hash_table (htab))
4221
        {
4222
          bfd_boolean dynsym;
4223
 
4224
          /* Check the alignment when a common symbol is involved. This
4225
             can change when a common symbol is overridden by a normal
4226
             definition or a common symbol is ignored due to the old
4227
             normal definition. We need to make sure the maximum
4228
             alignment is maintained.  */
4229
          if ((old_alignment || common)
4230
              && h->root.type != bfd_link_hash_common)
4231
            {
4232
              unsigned int common_align;
4233
              unsigned int normal_align;
4234
              unsigned int symbol_align;
4235
              bfd *normal_bfd;
4236
              bfd *common_bfd;
4237
 
4238
              symbol_align = ffs (h->root.u.def.value) - 1;
4239
              if (h->root.u.def.section->owner != NULL
4240
                  && (h->root.u.def.section->owner->flags & DYNAMIC) == 0)
4241
                {
4242
                  normal_align = h->root.u.def.section->alignment_power;
4243
                  if (normal_align > symbol_align)
4244
                    normal_align = symbol_align;
4245
                }
4246
              else
4247
                normal_align = symbol_align;
4248
 
4249
              if (old_alignment)
4250
                {
4251
                  common_align = old_alignment;
4252
                  common_bfd = old_bfd;
4253
                  normal_bfd = abfd;
4254
                }
4255
              else
4256
                {
4257
                  common_align = bfd_log2 (isym->st_value);
4258
                  common_bfd = abfd;
4259
                  normal_bfd = old_bfd;
4260
                }
4261
 
4262
              if (normal_align < common_align)
4263
                {
4264
                  /* PR binutils/2735 */
4265
                  if (normal_bfd == NULL)
4266
                    (*_bfd_error_handler)
4267
                      (_("Warning: alignment %u of common symbol `%s' in %B"
4268
                         " is greater than the alignment (%u) of its section %A"),
4269
                       common_bfd, h->root.u.def.section,
4270
                       1 << common_align, name, 1 << normal_align);
4271
                  else
4272
                    (*_bfd_error_handler)
4273
                      (_("Warning: alignment %u of symbol `%s' in %B"
4274
                         " is smaller than %u in %B"),
4275
                       normal_bfd, common_bfd,
4276
                       1 << normal_align, name, 1 << common_align);
4277
                }
4278
            }
4279
 
4280
          /* Remember the symbol size if it isn't undefined.  */
4281
          if ((isym->st_size != 0 && isym->st_shndx != SHN_UNDEF)
4282
              && (definition || h->size == 0))
4283
            {
4284
              if (h->size != 0
4285
                  && h->size != isym->st_size
4286
                  && ! size_change_ok)
4287
                (*_bfd_error_handler)
4288
                  (_("Warning: size of symbol `%s' changed"
4289
                     " from %lu in %B to %lu in %B"),
4290
                   old_bfd, abfd,
4291
                   name, (unsigned long) h->size,
4292
                   (unsigned long) isym->st_size);
4293
 
4294
              h->size = isym->st_size;
4295
            }
4296
 
4297
          /* If this is a common symbol, then we always want H->SIZE
4298
             to be the size of the common symbol.  The code just above
4299
             won't fix the size if a common symbol becomes larger.  We
4300
             don't warn about a size change here, because that is
4301
             covered by --warn-common.  Allow changed between different
4302
             function types.  */
4303
          if (h->root.type == bfd_link_hash_common)
4304
            h->size = h->root.u.c.size;
4305
 
4306
          if (ELF_ST_TYPE (isym->st_info) != STT_NOTYPE
4307
              && (definition || h->type == STT_NOTYPE))
4308
            {
4309
              unsigned int type = ELF_ST_TYPE (isym->st_info);
4310
 
4311
              /* Turn an IFUNC symbol from a DSO into a normal FUNC
4312
                 symbol.  */
4313
              if (type == STT_GNU_IFUNC
4314
                  && (abfd->flags & DYNAMIC) != 0)
4315
                type = STT_FUNC;
4316
 
4317
              if (h->type != type)
4318
                {
4319
                  if (h->type != STT_NOTYPE && ! type_change_ok)
4320
                    (*_bfd_error_handler)
4321
                      (_("Warning: type of symbol `%s' changed"
4322
                         " from %d to %d in %B"),
4323
                       abfd, name, h->type, type);
4324
 
4325
                  h->type = type;
4326
                }
4327
            }
4328
 
4329
          /* Merge st_other field.  */
4330
          elf_merge_st_other (abfd, h, isym, definition, dynamic);
4331
 
4332
          /* Set a flag in the hash table entry indicating the type of
4333
             reference or definition we just found.  Keep a count of
4334
             the number of dynamic symbols we find.  A dynamic symbol
4335
             is one which is referenced or defined by both a regular
4336
             object and a shared object.  */
4337
          dynsym = FALSE;
4338
          if (! dynamic)
4339
            {
4340
              if (! definition)
4341
                {
4342
                  h->ref_regular = 1;
4343
                  if (bind != STB_WEAK)
4344
                    h->ref_regular_nonweak = 1;
4345
                }
4346
              else
4347
                {
4348
                  h->def_regular = 1;
4349
                  if (h->def_dynamic)
4350
                    {
4351
                      h->def_dynamic = 0;
4352
                      h->ref_dynamic = 1;
4353
                    }
4354
                }
4355
              if (! info->executable
4356
                  || h->def_dynamic
4357
                  || h->ref_dynamic)
4358
                dynsym = TRUE;
4359
            }
4360
          else
4361
            {
4362
              if (! definition)
4363
                h->ref_dynamic = 1;
4364
              else
4365 163 khays
                {
4366
                  h->def_dynamic = 1;
4367
                  h->dynamic_def = 1;
4368
                }
4369 14 khays
              if (h->def_regular
4370
                  || h->ref_regular
4371
                  || (h->u.weakdef != NULL
4372
                      && ! new_weakdef
4373
                      && h->u.weakdef->dynindx != -1))
4374
                dynsym = TRUE;
4375
            }
4376
 
4377 163 khays
          /* We don't want to make debug symbol dynamic.  */
4378 14 khays
          if (definition && (sec->flags & SEC_DEBUGGING) && !info->relocatable)
4379 163 khays
            dynsym = FALSE;
4380 14 khays
 
4381 163 khays
          /* Nor should we make plugin symbols dynamic.  */
4382
          if ((abfd->flags & BFD_PLUGIN) != 0)
4383
            dynsym = FALSE;
4384
 
4385 14 khays
          if (definition)
4386
            h->target_internal = isym->st_target_internal;
4387
 
4388
          /* Check to see if we need to add an indirect symbol for
4389
             the default name.  */
4390
          if (definition || h->root.type == bfd_link_hash_common)
4391
            if (!_bfd_elf_add_default_symbol (abfd, info, h, name, isym,
4392
                                              &sec, &value, &dynsym,
4393
                                              override))
4394
              goto error_free_vers;
4395
 
4396
          if (definition && !dynamic)
4397
            {
4398
              char *p = strchr (name, ELF_VER_CHR);
4399
              if (p != NULL && p[1] != ELF_VER_CHR)
4400
                {
4401
                  /* Queue non-default versions so that .symver x, x@FOO
4402
                     aliases can be checked.  */
4403
                  if (!nondeflt_vers)
4404
                    {
4405
                      amt = ((isymend - isym + 1)
4406
                             * sizeof (struct elf_link_hash_entry *));
4407
                      nondeflt_vers =
4408
                          (struct elf_link_hash_entry **) bfd_malloc (amt);
4409
                      if (!nondeflt_vers)
4410
                        goto error_free_vers;
4411
                    }
4412
                  nondeflt_vers[nondeflt_vers_cnt++] = h;
4413
                }
4414
            }
4415
 
4416
          if (dynsym && h->dynindx == -1)
4417
            {
4418
              if (! bfd_elf_link_record_dynamic_symbol (info, h))
4419
                goto error_free_vers;
4420
              if (h->u.weakdef != NULL
4421
                  && ! new_weakdef
4422
                  && h->u.weakdef->dynindx == -1)
4423
                {
4424
                  if (!bfd_elf_link_record_dynamic_symbol (info, h->u.weakdef))
4425
                    goto error_free_vers;
4426
                }
4427
            }
4428
          else if (dynsym && h->dynindx != -1)
4429
            /* If the symbol already has a dynamic index, but
4430
               visibility says it should not be visible, turn it into
4431
               a local symbol.  */
4432
            switch (ELF_ST_VISIBILITY (h->other))
4433
              {
4434
              case STV_INTERNAL:
4435
              case STV_HIDDEN:
4436
                (*bed->elf_backend_hide_symbol) (info, h, TRUE);
4437
                dynsym = FALSE;
4438
                break;
4439
              }
4440
 
4441
          if (!add_needed
4442
              && definition
4443
              && ((dynsym
4444
                   && h->ref_regular)
4445
                  || (h->ref_dynamic
4446
                      && (elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0
4447
                      && !on_needed_list (elf_dt_name (abfd), htab->needed))))
4448
            {
4449
              int ret;
4450
              const char *soname = elf_dt_name (abfd);
4451
 
4452
              /* A symbol from a library loaded via DT_NEEDED of some
4453
                 other library is referenced by a regular object.
4454
                 Add a DT_NEEDED entry for it.  Issue an error if
4455
                 --no-add-needed is used and the reference was not
4456
                 a weak one.  */
4457
              if (undef_bfd != NULL
4458
                  && (elf_dyn_lib_class (abfd) & DYN_NO_NEEDED) != 0)
4459
                {
4460
                  (*_bfd_error_handler)
4461
                    (_("%B: undefined reference to symbol '%s'"),
4462
                     undef_bfd, name);
4463
                  (*_bfd_error_handler)
4464
                    (_("note: '%s' is defined in DSO %B so try adding it to the linker command line"),
4465
                     abfd, name);
4466
                  bfd_set_error (bfd_error_invalid_operation);
4467
                  goto error_free_vers;
4468
                }
4469
 
4470
              elf_dyn_lib_class (abfd) = (enum dynamic_lib_link_class)
4471
                  (elf_dyn_lib_class (abfd) & ~DYN_AS_NEEDED);
4472
 
4473
              add_needed = TRUE;
4474
              ret = elf_add_dt_needed_tag (abfd, info, soname, add_needed);
4475
              if (ret < 0)
4476
                goto error_free_vers;
4477
 
4478
              BFD_ASSERT (ret == 0);
4479
            }
4480
        }
4481
    }
4482
 
4483
  if (extversym != NULL)
4484
    {
4485
      free (extversym);
4486
      extversym = NULL;
4487
    }
4488
 
4489
  if (isymbuf != NULL)
4490
    {
4491
      free (isymbuf);
4492
      isymbuf = NULL;
4493
    }
4494
 
4495
  if ((elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0)
4496
    {
4497
      unsigned int i;
4498
 
4499
      /* Restore the symbol table.  */
4500
      if (bed->as_needed_cleanup)
4501
        (*bed->as_needed_cleanup) (abfd, info);
4502
      old_hash = (char *) old_tab + tabsize;
4503
      old_ent = (char *) old_hash + hashsize;
4504
      sym_hash = elf_sym_hashes (abfd);
4505
      htab->root.table.table = old_table;
4506
      htab->root.table.size = old_size;
4507
      htab->root.table.count = old_count;
4508
      memcpy (htab->root.table.table, old_tab, tabsize);
4509
      memcpy (sym_hash, old_hash, hashsize);
4510
      htab->root.undefs = old_undefs;
4511
      htab->root.undefs_tail = old_undefs_tail;
4512
      for (i = 0; i < htab->root.table.size; i++)
4513
        {
4514
          struct bfd_hash_entry *p;
4515
          struct elf_link_hash_entry *h;
4516 163 khays
          bfd_size_type size;
4517
          unsigned int alignment_power;
4518 14 khays
 
4519
          for (p = htab->root.table.table[i]; p != NULL; p = p->next)
4520
            {
4521
              h = (struct elf_link_hash_entry *) p;
4522
              if (h->root.type == bfd_link_hash_warning)
4523
                h = (struct elf_link_hash_entry *) h->root.u.i.link;
4524
              if (h->dynindx >= old_dynsymcount)
4525
                _bfd_elf_strtab_delref (htab->dynstr, h->dynstr_index);
4526
 
4527 163 khays
              /* Preserve the maximum alignment and size for common
4528
                 symbols even if this dynamic lib isn't on DT_NEEDED
4529
                 since it can still be loaded at the run-time by another
4530
                 dynamic lib.  */
4531
              if (h->root.type == bfd_link_hash_common)
4532
                {
4533
                  size = h->root.u.c.size;
4534
                  alignment_power = h->root.u.c.p->alignment_power;
4535
                }
4536
              else
4537
                {
4538
                  size = 0;
4539
                  alignment_power = 0;
4540
                }
4541 14 khays
              memcpy (p, old_ent, htab->root.table.entsize);
4542
              old_ent = (char *) old_ent + htab->root.table.entsize;
4543
              h = (struct elf_link_hash_entry *) p;
4544
              if (h->root.type == bfd_link_hash_warning)
4545
                {
4546
                  memcpy (h->root.u.i.link, old_ent, htab->root.table.entsize);
4547
                  old_ent = (char *) old_ent + htab->root.table.entsize;
4548
                }
4549 163 khays
              else if (h->root.type == bfd_link_hash_common)
4550
                {
4551
                  if (size > h->root.u.c.size)
4552
                    h->root.u.c.size = size;
4553
                  if (alignment_power > h->root.u.c.p->alignment_power)
4554
                    h->root.u.c.p->alignment_power = alignment_power;
4555
                }
4556 14 khays
            }
4557
        }
4558
 
4559
      /* Make a special call to the linker "notice" function to
4560
         tell it that symbols added for crefs may need to be removed.  */
4561
      if (!(*info->callbacks->notice) (info, NULL, abfd, NULL,
4562
                                       notice_not_needed, 0, NULL))
4563
        goto error_free_vers;
4564
 
4565
      free (old_tab);
4566
      objalloc_free_block ((struct objalloc *) htab->root.table.memory,
4567
                           alloc_mark);
4568
      if (nondeflt_vers != NULL)
4569
        free (nondeflt_vers);
4570
      return TRUE;
4571
    }
4572
 
4573
  if (old_tab != NULL)
4574
    {
4575
      if (!(*info->callbacks->notice) (info, NULL, abfd, NULL,
4576
                                       notice_needed, 0, NULL))
4577
        goto error_free_vers;
4578
      free (old_tab);
4579
      old_tab = NULL;
4580
    }
4581
 
4582
  /* Now that all the symbols from this input file are created, handle
4583
     .symver foo, foo@BAR such that any relocs against foo become foo@BAR.  */
4584
  if (nondeflt_vers != NULL)
4585
    {
4586
      bfd_size_type cnt, symidx;
4587
 
4588
      for (cnt = 0; cnt < nondeflt_vers_cnt; ++cnt)
4589
        {
4590
          struct elf_link_hash_entry *h = nondeflt_vers[cnt], *hi;
4591
          char *shortname, *p;
4592
 
4593
          p = strchr (h->root.root.string, ELF_VER_CHR);
4594
          if (p == NULL
4595
              || (h->root.type != bfd_link_hash_defined
4596
                  && h->root.type != bfd_link_hash_defweak))
4597
            continue;
4598
 
4599
          amt = p - h->root.root.string;
4600
          shortname = (char *) bfd_malloc (amt + 1);
4601
          if (!shortname)
4602
            goto error_free_vers;
4603
          memcpy (shortname, h->root.root.string, amt);
4604
          shortname[amt] = '\0';
4605
 
4606
          hi = (struct elf_link_hash_entry *)
4607
               bfd_link_hash_lookup (&htab->root, shortname,
4608
                                     FALSE, FALSE, FALSE);
4609
          if (hi != NULL
4610
              && hi->root.type == h->root.type
4611
              && hi->root.u.def.value == h->root.u.def.value
4612
              && hi->root.u.def.section == h->root.u.def.section)
4613
            {
4614
              (*bed->elf_backend_hide_symbol) (info, hi, TRUE);
4615
              hi->root.type = bfd_link_hash_indirect;
4616
              hi->root.u.i.link = (struct bfd_link_hash_entry *) h;
4617
              (*bed->elf_backend_copy_indirect_symbol) (info, h, hi);
4618
              sym_hash = elf_sym_hashes (abfd);
4619
              if (sym_hash)
4620
                for (symidx = 0; symidx < extsymcount; ++symidx)
4621
                  if (sym_hash[symidx] == hi)
4622
                    {
4623
                      sym_hash[symidx] = h;
4624
                      break;
4625
                    }
4626
            }
4627
          free (shortname);
4628
        }
4629
      free (nondeflt_vers);
4630
      nondeflt_vers = NULL;
4631
    }
4632
 
4633
  /* Now set the weakdefs field correctly for all the weak defined
4634
     symbols we found.  The only way to do this is to search all the
4635
     symbols.  Since we only need the information for non functions in
4636
     dynamic objects, that's the only time we actually put anything on
4637
     the list WEAKS.  We need this information so that if a regular
4638
     object refers to a symbol defined weakly in a dynamic object, the
4639
     real symbol in the dynamic object is also put in the dynamic
4640
     symbols; we also must arrange for both symbols to point to the
4641
     same memory location.  We could handle the general case of symbol
4642
     aliasing, but a general symbol alias can only be generated in
4643
     assembler code, handling it correctly would be very time
4644
     consuming, and other ELF linkers don't handle general aliasing
4645
     either.  */
4646
  if (weaks != NULL)
4647
    {
4648
      struct elf_link_hash_entry **hpp;
4649
      struct elf_link_hash_entry **hppend;
4650
      struct elf_link_hash_entry **sorted_sym_hash;
4651
      struct elf_link_hash_entry *h;
4652
      size_t sym_count;
4653
 
4654
      /* Since we have to search the whole symbol list for each weak
4655
         defined symbol, search time for N weak defined symbols will be
4656
         O(N^2). Binary search will cut it down to O(NlogN).  */
4657
      amt = extsymcount * sizeof (struct elf_link_hash_entry *);
4658
      sorted_sym_hash = (struct elf_link_hash_entry **) bfd_malloc (amt);
4659
      if (sorted_sym_hash == NULL)
4660
        goto error_return;
4661
      sym_hash = sorted_sym_hash;
4662
      hpp = elf_sym_hashes (abfd);
4663
      hppend = hpp + extsymcount;
4664
      sym_count = 0;
4665
      for (; hpp < hppend; hpp++)
4666
        {
4667
          h = *hpp;
4668
          if (h != NULL
4669
              && h->root.type == bfd_link_hash_defined
4670
              && !bed->is_function_type (h->type))
4671
            {
4672
              *sym_hash = h;
4673
              sym_hash++;
4674
              sym_count++;
4675
            }
4676
        }
4677
 
4678
      qsort (sorted_sym_hash, sym_count,
4679
             sizeof (struct elf_link_hash_entry *),
4680
             elf_sort_symbol);
4681
 
4682
      while (weaks != NULL)
4683
        {
4684
          struct elf_link_hash_entry *hlook;
4685
          asection *slook;
4686
          bfd_vma vlook;
4687
          long ilook;
4688
          size_t i, j, idx;
4689
 
4690
          hlook = weaks;
4691
          weaks = hlook->u.weakdef;
4692
          hlook->u.weakdef = NULL;
4693
 
4694
          BFD_ASSERT (hlook->root.type == bfd_link_hash_defined
4695
                      || hlook->root.type == bfd_link_hash_defweak
4696
                      || hlook->root.type == bfd_link_hash_common
4697
                      || hlook->root.type == bfd_link_hash_indirect);
4698
          slook = hlook->root.u.def.section;
4699
          vlook = hlook->root.u.def.value;
4700
 
4701
          ilook = -1;
4702
          i = 0;
4703
          j = sym_count;
4704
          while (i < j)
4705
            {
4706
              bfd_signed_vma vdiff;
4707
              idx = (i + j) / 2;
4708
              h = sorted_sym_hash [idx];
4709
              vdiff = vlook - h->root.u.def.value;
4710
              if (vdiff < 0)
4711
                j = idx;
4712
              else if (vdiff > 0)
4713
                i = idx + 1;
4714
              else
4715
                {
4716
                  long sdiff = slook->id - h->root.u.def.section->id;
4717
                  if (sdiff < 0)
4718
                    j = idx;
4719
                  else if (sdiff > 0)
4720
                    i = idx + 1;
4721
                  else
4722
                    {
4723
                      ilook = idx;
4724
                      break;
4725
                    }
4726
                }
4727
            }
4728
 
4729
          /* We didn't find a value/section match.  */
4730
          if (ilook == -1)
4731
            continue;
4732
 
4733
          for (i = ilook; i < sym_count; i++)
4734
            {
4735
              h = sorted_sym_hash [i];
4736
 
4737
              /* Stop if value or section doesn't match.  */
4738
              if (h->root.u.def.value != vlook
4739
                  || h->root.u.def.section != slook)
4740
                break;
4741
              else if (h != hlook)
4742
                {
4743
                  hlook->u.weakdef = h;
4744
 
4745
                  /* If the weak definition is in the list of dynamic
4746
                     symbols, make sure the real definition is put
4747
                     there as well.  */
4748
                  if (hlook->dynindx != -1 && h->dynindx == -1)
4749
                    {
4750
                      if (! bfd_elf_link_record_dynamic_symbol (info, h))
4751
                        {
4752
                        err_free_sym_hash:
4753
                          free (sorted_sym_hash);
4754
                          goto error_return;
4755
                        }
4756
                    }
4757
 
4758
                  /* If the real definition is in the list of dynamic
4759
                     symbols, make sure the weak definition is put
4760
                     there as well.  If we don't do this, then the
4761
                     dynamic loader might not merge the entries for the
4762
                     real definition and the weak definition.  */
4763
                  if (h->dynindx != -1 && hlook->dynindx == -1)
4764
                    {
4765
                      if (! bfd_elf_link_record_dynamic_symbol (info, hlook))
4766
                        goto err_free_sym_hash;
4767
                    }
4768
                  break;
4769
                }
4770
            }
4771
        }
4772
 
4773
      free (sorted_sym_hash);
4774
    }
4775
 
4776
  if (bed->check_directives
4777
      && !(*bed->check_directives) (abfd, info))
4778
    return FALSE;
4779
 
4780
  /* If this object is the same format as the output object, and it is
4781
     not a shared library, then let the backend look through the
4782
     relocs.
4783
 
4784
     This is required to build global offset table entries and to
4785
     arrange for dynamic relocs.  It is not required for the
4786
     particular common case of linking non PIC code, even when linking
4787
     against shared libraries, but unfortunately there is no way of
4788
     knowing whether an object file has been compiled PIC or not.
4789
     Looking through the relocs is not particularly time consuming.
4790
     The problem is that we must either (1) keep the relocs in memory,
4791
     which causes the linker to require additional runtime memory or
4792
     (2) read the relocs twice from the input file, which wastes time.
4793
     This would be a good case for using mmap.
4794
 
4795
     I have no idea how to handle linking PIC code into a file of a
4796
     different format.  It probably can't be done.  */
4797
  if (! dynamic
4798
      && is_elf_hash_table (htab)
4799
      && bed->check_relocs != NULL
4800
      && elf_object_id (abfd) == elf_hash_table_id (htab)
4801
      && (*bed->relocs_compatible) (abfd->xvec, info->output_bfd->xvec))
4802
    {
4803
      asection *o;
4804
 
4805
      for (o = abfd->sections; o != NULL; o = o->next)
4806
        {
4807
          Elf_Internal_Rela *internal_relocs;
4808
          bfd_boolean ok;
4809
 
4810
          if ((o->flags & SEC_RELOC) == 0
4811
              || o->reloc_count == 0
4812
              || ((info->strip == strip_all || info->strip == strip_debugger)
4813
                  && (o->flags & SEC_DEBUGGING) != 0)
4814
              || bfd_is_abs_section (o->output_section))
4815
            continue;
4816
 
4817
          internal_relocs = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
4818
                                                       info->keep_memory);
4819
          if (internal_relocs == NULL)
4820
            goto error_return;
4821
 
4822
          ok = (*bed->check_relocs) (abfd, info, o, internal_relocs);
4823
 
4824
          if (elf_section_data (o)->relocs != internal_relocs)
4825
            free (internal_relocs);
4826
 
4827
          if (! ok)
4828
            goto error_return;
4829
        }
4830
    }
4831
 
4832
  /* If this is a non-traditional link, try to optimize the handling
4833
     of the .stab/.stabstr sections.  */
4834
  if (! dynamic
4835
      && ! info->traditional_format
4836
      && is_elf_hash_table (htab)
4837
      && (info->strip != strip_all && info->strip != strip_debugger))
4838
    {
4839
      asection *stabstr;
4840
 
4841
      stabstr = bfd_get_section_by_name (abfd, ".stabstr");
4842
      if (stabstr != NULL)
4843
        {
4844
          bfd_size_type string_offset = 0;
4845
          asection *stab;
4846
 
4847
          for (stab = abfd->sections; stab; stab = stab->next)
4848
            if (CONST_STRNEQ (stab->name, ".stab")
4849
                && (!stab->name[5] ||
4850
                    (stab->name[5] == '.' && ISDIGIT (stab->name[6])))
4851
                && (stab->flags & SEC_MERGE) == 0
4852
                && !bfd_is_abs_section (stab->output_section))
4853
              {
4854
                struct bfd_elf_section_data *secdata;
4855
 
4856
                secdata = elf_section_data (stab);
4857
                if (! _bfd_link_section_stabs (abfd, &htab->stab_info, stab,
4858
                                               stabstr, &secdata->sec_info,
4859
                                               &string_offset))
4860
                  goto error_return;
4861
                if (secdata->sec_info)
4862
                  stab->sec_info_type = ELF_INFO_TYPE_STABS;
4863
            }
4864
        }
4865
    }
4866
 
4867
  if (is_elf_hash_table (htab) && add_needed)
4868
    {
4869
      /* Add this bfd to the loaded list.  */
4870
      struct elf_link_loaded_list *n;
4871
 
4872
      n = (struct elf_link_loaded_list *)
4873
          bfd_alloc (abfd, sizeof (struct elf_link_loaded_list));
4874
      if (n == NULL)
4875
        goto error_return;
4876
      n->abfd = abfd;
4877
      n->next = htab->loaded;
4878
      htab->loaded = n;
4879
    }
4880
 
4881
  return TRUE;
4882
 
4883
 error_free_vers:
4884
  if (old_tab != NULL)
4885
    free (old_tab);
4886
  if (nondeflt_vers != NULL)
4887
    free (nondeflt_vers);
4888
  if (extversym != NULL)
4889
    free (extversym);
4890
 error_free_sym:
4891
  if (isymbuf != NULL)
4892
    free (isymbuf);
4893
 error_return:
4894
  return FALSE;
4895
}
4896
 
4897
/* Return the linker hash table entry of a symbol that might be
4898
   satisfied by an archive symbol.  Return -1 on error.  */
4899
 
4900
struct elf_link_hash_entry *
4901
_bfd_elf_archive_symbol_lookup (bfd *abfd,
4902
                                struct bfd_link_info *info,
4903
                                const char *name)
4904
{
4905
  struct elf_link_hash_entry *h;
4906
  char *p, *copy;
4907
  size_t len, first;
4908
 
4909 148 khays
  h = elf_link_hash_lookup (elf_hash_table (info), name, FALSE, FALSE, TRUE);
4910 14 khays
  if (h != NULL)
4911
    return h;
4912
 
4913
  /* If this is a default version (the name contains @@), look up the
4914
     symbol again with only one `@' as well as without the version.
4915
     The effect is that references to the symbol with and without the
4916
     version will be matched by the default symbol in the archive.  */
4917
 
4918
  p = strchr (name, ELF_VER_CHR);
4919
  if (p == NULL || p[1] != ELF_VER_CHR)
4920
    return h;
4921
 
4922
  /* First check with only one `@'.  */
4923
  len = strlen (name);
4924
  copy = (char *) bfd_alloc (abfd, len);
4925
  if (copy == NULL)
4926
    return (struct elf_link_hash_entry *) 0 - 1;
4927
 
4928
  first = p - name + 1;
4929
  memcpy (copy, name, first);
4930
  memcpy (copy + first, name + first + 1, len - first);
4931
 
4932 148 khays
  h = elf_link_hash_lookup (elf_hash_table (info), copy, FALSE, FALSE, TRUE);
4933 14 khays
  if (h == NULL)
4934
    {
4935
      /* We also need to check references to the symbol without the
4936
         version.  */
4937
      copy[first - 1] = '\0';
4938
      h = elf_link_hash_lookup (elf_hash_table (info), copy,
4939 148 khays
                                FALSE, FALSE, TRUE);
4940 14 khays
    }
4941
 
4942
  bfd_release (abfd, copy);
4943
  return h;
4944
}
4945
 
4946
/* Add symbols from an ELF archive file to the linker hash table.  We
4947
   don't use _bfd_generic_link_add_archive_symbols because of a
4948
   problem which arises on UnixWare.  The UnixWare libc.so is an
4949
   archive which includes an entry libc.so.1 which defines a bunch of
4950
   symbols.  The libc.so archive also includes a number of other
4951
   object files, which also define symbols, some of which are the same
4952
   as those defined in libc.so.1.  Correct linking requires that we
4953
   consider each object file in turn, and include it if it defines any
4954
   symbols we need.  _bfd_generic_link_add_archive_symbols does not do
4955
   this; it looks through the list of undefined symbols, and includes
4956
   any object file which defines them.  When this algorithm is used on
4957
   UnixWare, it winds up pulling in libc.so.1 early and defining a
4958
   bunch of symbols.  This means that some of the other objects in the
4959
   archive are not included in the link, which is incorrect since they
4960
   precede libc.so.1 in the archive.
4961
 
4962
   Fortunately, ELF archive handling is simpler than that done by
4963
   _bfd_generic_link_add_archive_symbols, which has to allow for a.out
4964
   oddities.  In ELF, if we find a symbol in the archive map, and the
4965
   symbol is currently undefined, we know that we must pull in that
4966
   object file.
4967
 
4968
   Unfortunately, we do have to make multiple passes over the symbol
4969
   table until nothing further is resolved.  */
4970
 
4971
static bfd_boolean
4972
elf_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info)
4973
{
4974
  symindex c;
4975
  bfd_boolean *defined = NULL;
4976
  bfd_boolean *included = NULL;
4977
  carsym *symdefs;
4978
  bfd_boolean loop;
4979
  bfd_size_type amt;
4980
  const struct elf_backend_data *bed;
4981
  struct elf_link_hash_entry * (*archive_symbol_lookup)
4982
    (bfd *, struct bfd_link_info *, const char *);
4983
 
4984
  if (! bfd_has_map (abfd))
4985
    {
4986
      /* An empty archive is a special case.  */
4987
      if (bfd_openr_next_archived_file (abfd, NULL) == NULL)
4988
        return TRUE;
4989
      bfd_set_error (bfd_error_no_armap);
4990
      return FALSE;
4991
    }
4992
 
4993
  /* Keep track of all symbols we know to be already defined, and all
4994
     files we know to be already included.  This is to speed up the
4995
     second and subsequent passes.  */
4996
  c = bfd_ardata (abfd)->symdef_count;
4997
  if (c == 0)
4998
    return TRUE;
4999
  amt = c;
5000
  amt *= sizeof (bfd_boolean);
5001
  defined = (bfd_boolean *) bfd_zmalloc (amt);
5002
  included = (bfd_boolean *) bfd_zmalloc (amt);
5003
  if (defined == NULL || included == NULL)
5004
    goto error_return;
5005
 
5006
  symdefs = bfd_ardata (abfd)->symdefs;
5007
  bed = get_elf_backend_data (abfd);
5008
  archive_symbol_lookup = bed->elf_backend_archive_symbol_lookup;
5009
 
5010
  do
5011
    {
5012
      file_ptr last;
5013
      symindex i;
5014
      carsym *symdef;
5015
      carsym *symdefend;
5016
 
5017
      loop = FALSE;
5018
      last = -1;
5019
 
5020
      symdef = symdefs;
5021
      symdefend = symdef + c;
5022
      for (i = 0; symdef < symdefend; symdef++, i++)
5023
        {
5024
          struct elf_link_hash_entry *h;
5025
          bfd *element;
5026
          struct bfd_link_hash_entry *undefs_tail;
5027
          symindex mark;
5028
 
5029
          if (defined[i] || included[i])
5030
            continue;
5031
          if (symdef->file_offset == last)
5032
            {
5033
              included[i] = TRUE;
5034
              continue;
5035
            }
5036
 
5037
          h = archive_symbol_lookup (abfd, info, symdef->name);
5038
          if (h == (struct elf_link_hash_entry *) 0 - 1)
5039
            goto error_return;
5040
 
5041
          if (h == NULL)
5042
            continue;
5043
 
5044
          if (h->root.type == bfd_link_hash_common)
5045
            {
5046
              /* We currently have a common symbol.  The archive map contains
5047
                 a reference to this symbol, so we may want to include it.  We
5048
                 only want to include it however, if this archive element
5049
                 contains a definition of the symbol, not just another common
5050
                 declaration of it.
5051
 
5052
                 Unfortunately some archivers (including GNU ar) will put
5053
                 declarations of common symbols into their archive maps, as
5054
                 well as real definitions, so we cannot just go by the archive
5055
                 map alone.  Instead we must read in the element's symbol
5056
                 table and check that to see what kind of symbol definition
5057
                 this is.  */
5058
              if (! elf_link_is_defined_archive_symbol (abfd, symdef))
5059
                continue;
5060
            }
5061
          else if (h->root.type != bfd_link_hash_undefined)
5062
            {
5063
              if (h->root.type != bfd_link_hash_undefweak)
5064
                defined[i] = TRUE;
5065
              continue;
5066
            }
5067
 
5068
          /* We need to include this archive member.  */
5069
          element = _bfd_get_elt_at_filepos (abfd, symdef->file_offset);
5070
          if (element == NULL)
5071
            goto error_return;
5072
 
5073
          if (! bfd_check_format (element, bfd_object))
5074
            goto error_return;
5075
 
5076
          /* Doublecheck that we have not included this object
5077
             already--it should be impossible, but there may be
5078
             something wrong with the archive.  */
5079
          if (element->archive_pass != 0)
5080
            {
5081
              bfd_set_error (bfd_error_bad_value);
5082
              goto error_return;
5083
            }
5084
          element->archive_pass = 1;
5085
 
5086
          undefs_tail = info->hash->undefs_tail;
5087
 
5088
          if (!(*info->callbacks
5089
                ->add_archive_element) (info, element, symdef->name, &element))
5090
            goto error_return;
5091
          if (!bfd_link_add_symbols (element, info))
5092
            goto error_return;
5093
 
5094
          /* If there are any new undefined symbols, we need to make
5095
             another pass through the archive in order to see whether
5096
             they can be defined.  FIXME: This isn't perfect, because
5097
             common symbols wind up on undefs_tail and because an
5098
             undefined symbol which is defined later on in this pass
5099
             does not require another pass.  This isn't a bug, but it
5100
             does make the code less efficient than it could be.  */
5101
          if (undefs_tail != info->hash->undefs_tail)
5102
            loop = TRUE;
5103
 
5104
          /* Look backward to mark all symbols from this object file
5105
             which we have already seen in this pass.  */
5106
          mark = i;
5107
          do
5108
            {
5109
              included[mark] = TRUE;
5110
              if (mark == 0)
5111
                break;
5112
              --mark;
5113
            }
5114
          while (symdefs[mark].file_offset == symdef->file_offset);
5115
 
5116
          /* We mark subsequent symbols from this object file as we go
5117
             on through the loop.  */
5118
          last = symdef->file_offset;
5119
        }
5120
    }
5121
  while (loop);
5122
 
5123
  free (defined);
5124
  free (included);
5125
 
5126
  return TRUE;
5127
 
5128
 error_return:
5129
  if (defined != NULL)
5130
    free (defined);
5131
  if (included != NULL)
5132
    free (included);
5133
  return FALSE;
5134
}
5135
 
5136
/* Given an ELF BFD, add symbols to the global hash table as
5137
   appropriate.  */
5138
 
5139
bfd_boolean
5140
bfd_elf_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
5141
{
5142
  switch (bfd_get_format (abfd))
5143
    {
5144
    case bfd_object:
5145
      return elf_link_add_object_symbols (abfd, info);
5146
    case bfd_archive:
5147
      return elf_link_add_archive_symbols (abfd, info);
5148
    default:
5149
      bfd_set_error (bfd_error_wrong_format);
5150
      return FALSE;
5151
    }
5152
}
5153
 
5154
struct hash_codes_info
5155
{
5156
  unsigned long *hashcodes;
5157
  bfd_boolean error;
5158
};
5159
 
5160
/* This function will be called though elf_link_hash_traverse to store
5161
   all hash value of the exported symbols in an array.  */
5162
 
5163
static bfd_boolean
5164
elf_collect_hash_codes (struct elf_link_hash_entry *h, void *data)
5165
{
5166
  struct hash_codes_info *inf = (struct hash_codes_info *) data;
5167
  const char *name;
5168
  char *p;
5169
  unsigned long ha;
5170
  char *alc = NULL;
5171
 
5172
  /* Ignore indirect symbols.  These are added by the versioning code.  */
5173
  if (h->dynindx == -1)
5174
    return TRUE;
5175
 
5176
  name = h->root.root.string;
5177
  p = strchr (name, ELF_VER_CHR);
5178
  if (p != NULL)
5179
    {
5180
      alc = (char *) bfd_malloc (p - name + 1);
5181
      if (alc == NULL)
5182
        {
5183
          inf->error = TRUE;
5184
          return FALSE;
5185
        }
5186
      memcpy (alc, name, p - name);
5187
      alc[p - name] = '\0';
5188
      name = alc;
5189
    }
5190
 
5191
  /* Compute the hash value.  */
5192
  ha = bfd_elf_hash (name);
5193
 
5194
  /* Store the found hash value in the array given as the argument.  */
5195
  *(inf->hashcodes)++ = ha;
5196
 
5197
  /* And store it in the struct so that we can put it in the hash table
5198
     later.  */
5199
  h->u.elf_hash_value = ha;
5200
 
5201
  if (alc != NULL)
5202
    free (alc);
5203
 
5204
  return TRUE;
5205
}
5206
 
5207
struct collect_gnu_hash_codes
5208
{
5209
  bfd *output_bfd;
5210
  const struct elf_backend_data *bed;
5211
  unsigned long int nsyms;
5212
  unsigned long int maskbits;
5213
  unsigned long int *hashcodes;
5214
  unsigned long int *hashval;
5215
  unsigned long int *indx;
5216
  unsigned long int *counts;
5217
  bfd_vma *bitmask;
5218
  bfd_byte *contents;
5219
  long int min_dynindx;
5220
  unsigned long int bucketcount;
5221
  unsigned long int symindx;
5222
  long int local_indx;
5223
  long int shift1, shift2;
5224
  unsigned long int mask;
5225
  bfd_boolean error;
5226
};
5227
 
5228
/* This function will be called though elf_link_hash_traverse to store
5229
   all hash value of the exported symbols in an array.  */
5230
 
5231
static bfd_boolean
5232
elf_collect_gnu_hash_codes (struct elf_link_hash_entry *h, void *data)
5233
{
5234
  struct collect_gnu_hash_codes *s = (struct collect_gnu_hash_codes *) data;
5235
  const char *name;
5236
  char *p;
5237
  unsigned long ha;
5238
  char *alc = NULL;
5239
 
5240
  /* Ignore indirect symbols.  These are added by the versioning code.  */
5241
  if (h->dynindx == -1)
5242
    return TRUE;
5243
 
5244
  /* Ignore also local symbols and undefined symbols.  */
5245
  if (! (*s->bed->elf_hash_symbol) (h))
5246
    return TRUE;
5247
 
5248
  name = h->root.root.string;
5249
  p = strchr (name, ELF_VER_CHR);
5250
  if (p != NULL)
5251
    {
5252
      alc = (char *) bfd_malloc (p - name + 1);
5253
      if (alc == NULL)
5254
        {
5255
          s->error = TRUE;
5256
          return FALSE;
5257
        }
5258
      memcpy (alc, name, p - name);
5259
      alc[p - name] = '\0';
5260
      name = alc;
5261
    }
5262
 
5263
  /* Compute the hash value.  */
5264
  ha = bfd_elf_gnu_hash (name);
5265
 
5266
  /* Store the found hash value in the array for compute_bucket_count,
5267
     and also for .dynsym reordering purposes.  */
5268
  s->hashcodes[s->nsyms] = ha;
5269
  s->hashval[h->dynindx] = ha;
5270
  ++s->nsyms;
5271
  if (s->min_dynindx < 0 || s->min_dynindx > h->dynindx)
5272
    s->min_dynindx = h->dynindx;
5273
 
5274
  if (alc != NULL)
5275
    free (alc);
5276
 
5277
  return TRUE;
5278
}
5279
 
5280
/* This function will be called though elf_link_hash_traverse to do
5281
   final dynaminc symbol renumbering.  */
5282
 
5283
static bfd_boolean
5284
elf_renumber_gnu_hash_syms (struct elf_link_hash_entry *h, void *data)
5285
{
5286
  struct collect_gnu_hash_codes *s = (struct collect_gnu_hash_codes *) data;
5287
  unsigned long int bucket;
5288
  unsigned long int val;
5289
 
5290
  /* Ignore indirect symbols.  */
5291
  if (h->dynindx == -1)
5292
    return TRUE;
5293
 
5294
  /* Ignore also local symbols and undefined symbols.  */
5295
  if (! (*s->bed->elf_hash_symbol) (h))
5296
    {
5297
      if (h->dynindx >= s->min_dynindx)
5298
        h->dynindx = s->local_indx++;
5299
      return TRUE;
5300
    }
5301
 
5302
  bucket = s->hashval[h->dynindx] % s->bucketcount;
5303
  val = (s->hashval[h->dynindx] >> s->shift1)
5304
        & ((s->maskbits >> s->shift1) - 1);
5305
  s->bitmask[val] |= ((bfd_vma) 1) << (s->hashval[h->dynindx] & s->mask);
5306
  s->bitmask[val]
5307
    |= ((bfd_vma) 1) << ((s->hashval[h->dynindx] >> s->shift2) & s->mask);
5308
  val = s->hashval[h->dynindx] & ~(unsigned long int) 1;
5309
  if (s->counts[bucket] == 1)
5310
    /* Last element terminates the chain.  */
5311
    val |= 1;
5312
  bfd_put_32 (s->output_bfd, val,
5313
              s->contents + (s->indx[bucket] - s->symindx) * 4);
5314
  --s->counts[bucket];
5315
  h->dynindx = s->indx[bucket]++;
5316
  return TRUE;
5317
}
5318
 
5319
/* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
5320
 
5321
bfd_boolean
5322
_bfd_elf_hash_symbol (struct elf_link_hash_entry *h)
5323
{
5324
  return !(h->forced_local
5325
           || h->root.type == bfd_link_hash_undefined
5326
           || h->root.type == bfd_link_hash_undefweak
5327
           || ((h->root.type == bfd_link_hash_defined
5328
                || h->root.type == bfd_link_hash_defweak)
5329
               && h->root.u.def.section->output_section == NULL));
5330
}
5331
 
5332
/* Array used to determine the number of hash table buckets to use
5333
   based on the number of symbols there are.  If there are fewer than
5334
   3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
5335
   fewer than 37 we use 17 buckets, and so forth.  We never use more
5336
   than 32771 buckets.  */
5337
 
5338
static const size_t elf_buckets[] =
5339
{
5340
  1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 1031, 2053, 4099, 8209,
5341
  16411, 32771, 0
5342
};
5343
 
5344
/* Compute bucket count for hashing table.  We do not use a static set
5345
   of possible tables sizes anymore.  Instead we determine for all
5346
   possible reasonable sizes of the table the outcome (i.e., the
5347
   number of collisions etc) and choose the best solution.  The
5348
   weighting functions are not too simple to allow the table to grow
5349
   without bounds.  Instead one of the weighting factors is the size.
5350
   Therefore the result is always a good payoff between few collisions
5351
   (= short chain lengths) and table size.  */
5352
static size_t
5353
compute_bucket_count (struct bfd_link_info *info ATTRIBUTE_UNUSED,
5354
                      unsigned long int *hashcodes ATTRIBUTE_UNUSED,
5355
                      unsigned long int nsyms,
5356
                      int gnu_hash)
5357
{
5358
  size_t best_size = 0;
5359
  unsigned long int i;
5360
 
5361
  /* We have a problem here.  The following code to optimize the table
5362
     size requires an integer type with more the 32 bits.  If
5363
     BFD_HOST_U_64_BIT is set we know about such a type.  */
5364
#ifdef BFD_HOST_U_64_BIT
5365
  if (info->optimize)
5366
    {
5367
      size_t minsize;
5368
      size_t maxsize;
5369
      BFD_HOST_U_64_BIT best_chlen = ~((BFD_HOST_U_64_BIT) 0);
5370
      bfd *dynobj = elf_hash_table (info)->dynobj;
5371
      size_t dynsymcount = elf_hash_table (info)->dynsymcount;
5372
      const struct elf_backend_data *bed = get_elf_backend_data (dynobj);
5373
      unsigned long int *counts;
5374
      bfd_size_type amt;
5375
      unsigned int no_improvement_count = 0;
5376
 
5377
      /* Possible optimization parameters: if we have NSYMS symbols we say
5378
         that the hashing table must at least have NSYMS/4 and at most
5379
         2*NSYMS buckets.  */
5380
      minsize = nsyms / 4;
5381
      if (minsize == 0)
5382
        minsize = 1;
5383
      best_size = maxsize = nsyms * 2;
5384
      if (gnu_hash)
5385
        {
5386
          if (minsize < 2)
5387
            minsize = 2;
5388
          if ((best_size & 31) == 0)
5389
            ++best_size;
5390
        }
5391
 
5392
      /* Create array where we count the collisions in.  We must use bfd_malloc
5393
         since the size could be large.  */
5394
      amt = maxsize;
5395
      amt *= sizeof (unsigned long int);
5396
      counts = (unsigned long int *) bfd_malloc (amt);
5397
      if (counts == NULL)
5398
        return 0;
5399
 
5400
      /* Compute the "optimal" size for the hash table.  The criteria is a
5401
         minimal chain length.  The minor criteria is (of course) the size
5402
         of the table.  */
5403
      for (i = minsize; i < maxsize; ++i)
5404
        {
5405
          /* Walk through the array of hashcodes and count the collisions.  */
5406
          BFD_HOST_U_64_BIT max;
5407
          unsigned long int j;
5408
          unsigned long int fact;
5409
 
5410
          if (gnu_hash && (i & 31) == 0)
5411
            continue;
5412
 
5413
          memset (counts, '\0', i * sizeof (unsigned long int));
5414
 
5415
          /* Determine how often each hash bucket is used.  */
5416
          for (j = 0; j < nsyms; ++j)
5417
            ++counts[hashcodes[j] % i];
5418
 
5419
          /* For the weight function we need some information about the
5420
             pagesize on the target.  This is information need not be 100%
5421
             accurate.  Since this information is not available (so far) we
5422
             define it here to a reasonable default value.  If it is crucial
5423
             to have a better value some day simply define this value.  */
5424
# ifndef BFD_TARGET_PAGESIZE
5425
#  define BFD_TARGET_PAGESIZE   (4096)
5426
# endif
5427
 
5428
          /* We in any case need 2 + DYNSYMCOUNT entries for the size values
5429
             and the chains.  */
5430
          max = (2 + dynsymcount) * bed->s->sizeof_hash_entry;
5431
 
5432
# if 1
5433
          /* Variant 1: optimize for short chains.  We add the squares
5434
             of all the chain lengths (which favors many small chain
5435
             over a few long chains).  */
5436
          for (j = 0; j < i; ++j)
5437
            max += counts[j] * counts[j];
5438
 
5439
          /* This adds penalties for the overall size of the table.  */
5440
          fact = i / (BFD_TARGET_PAGESIZE / bed->s->sizeof_hash_entry) + 1;
5441
          max *= fact * fact;
5442
# else
5443
          /* Variant 2: Optimize a lot more for small table.  Here we
5444
             also add squares of the size but we also add penalties for
5445
             empty slots (the +1 term).  */
5446
          for (j = 0; j < i; ++j)
5447
            max += (1 + counts[j]) * (1 + counts[j]);
5448
 
5449
          /* The overall size of the table is considered, but not as
5450
             strong as in variant 1, where it is squared.  */
5451
          fact = i / (BFD_TARGET_PAGESIZE / bed->s->sizeof_hash_entry) + 1;
5452
          max *= fact;
5453
# endif
5454
 
5455
          /* Compare with current best results.  */
5456
          if (max < best_chlen)
5457
            {
5458
              best_chlen = max;
5459
              best_size = i;
5460
              no_improvement_count = 0;
5461
            }
5462
          /* PR 11843: Avoid futile long searches for the best bucket size
5463
             when there are a large number of symbols.  */
5464
          else if (++no_improvement_count == 100)
5465
            break;
5466
        }
5467
 
5468
      free (counts);
5469
    }
5470
  else
5471
#endif /* defined (BFD_HOST_U_64_BIT) */
5472
    {
5473
      /* This is the fallback solution if no 64bit type is available or if we
5474
         are not supposed to spend much time on optimizations.  We select the
5475
         bucket count using a fixed set of numbers.  */
5476
      for (i = 0; elf_buckets[i] != 0; i++)
5477
        {
5478
          best_size = elf_buckets[i];
5479
          if (nsyms < elf_buckets[i + 1])
5480
            break;
5481
        }
5482
      if (gnu_hash && best_size < 2)
5483
        best_size = 2;
5484
    }
5485
 
5486
  return best_size;
5487
}
5488
 
5489
/* Size any SHT_GROUP section for ld -r.  */
5490
 
5491
bfd_boolean
5492
_bfd_elf_size_group_sections (struct bfd_link_info *info)
5493
{
5494
  bfd *ibfd;
5495
 
5496
  for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
5497
    if (bfd_get_flavour (ibfd) == bfd_target_elf_flavour
5498
        && !_bfd_elf_fixup_group_sections (ibfd, bfd_abs_section_ptr))
5499
      return FALSE;
5500
  return TRUE;
5501
}
5502
 
5503
/* Set up the sizes and contents of the ELF dynamic sections.  This is
5504
   called by the ELF linker emulation before_allocation routine.  We
5505
   must set the sizes of the sections before the linker sets the
5506
   addresses of the various sections.  */
5507
 
5508
bfd_boolean
5509
bfd_elf_size_dynamic_sections (bfd *output_bfd,
5510
                               const char *soname,
5511
                               const char *rpath,
5512
                               const char *filter_shlib,
5513
                               const char *audit,
5514
                               const char *depaudit,
5515
                               const char * const *auxiliary_filters,
5516
                               struct bfd_link_info *info,
5517 163 khays
                               asection **sinterpptr)
5518 14 khays
{
5519
  bfd_size_type soname_indx;
5520
  bfd *dynobj;
5521
  const struct elf_backend_data *bed;
5522
  struct elf_info_failed asvinfo;
5523
 
5524
  *sinterpptr = NULL;
5525
 
5526
  soname_indx = (bfd_size_type) -1;
5527
 
5528
  if (!is_elf_hash_table (info->hash))
5529
    return TRUE;
5530
 
5531
  bed = get_elf_backend_data (output_bfd);
5532
  if (info->execstack)
5533
    elf_tdata (output_bfd)->stack_flags = PF_R | PF_W | PF_X;
5534
  else if (info->noexecstack)
5535
    elf_tdata (output_bfd)->stack_flags = PF_R | PF_W;
5536
  else
5537
    {
5538
      bfd *inputobj;
5539
      asection *notesec = NULL;
5540
      int exec = 0;
5541
 
5542
      for (inputobj = info->input_bfds;
5543
           inputobj;
5544
           inputobj = inputobj->link_next)
5545
        {
5546
          asection *s;
5547
 
5548 161 khays
          if (inputobj->flags
5549
              & (DYNAMIC | EXEC_P | BFD_PLUGIN | BFD_LINKER_CREATED))
5550 14 khays
            continue;
5551
          s = bfd_get_section_by_name (inputobj, ".note.GNU-stack");
5552
          if (s)
5553
            {
5554
              if (s->flags & SEC_CODE)
5555
                exec = PF_X;
5556
              notesec = s;
5557
            }
5558
          else if (bed->default_execstack)
5559
            exec = PF_X;
5560
        }
5561
      if (notesec)
5562
        {
5563
          elf_tdata (output_bfd)->stack_flags = PF_R | PF_W | exec;
5564
          if (exec && info->relocatable
5565
              && notesec->output_section != bfd_abs_section_ptr)
5566
            notesec->output_section->flags |= SEC_CODE;
5567
        }
5568
    }
5569
 
5570
  /* Any syms created from now on start with -1 in
5571
     got.refcount/offset and plt.refcount/offset.  */
5572
  elf_hash_table (info)->init_got_refcount
5573
    = elf_hash_table (info)->init_got_offset;
5574
  elf_hash_table (info)->init_plt_refcount
5575
    = elf_hash_table (info)->init_plt_offset;
5576
 
5577
  if (info->relocatable
5578
      && !_bfd_elf_size_group_sections (info))
5579
    return FALSE;
5580
 
5581
  /* The backend may have to create some sections regardless of whether
5582
     we're dynamic or not.  */
5583
  if (bed->elf_backend_always_size_sections
5584
      && ! (*bed->elf_backend_always_size_sections) (output_bfd, info))
5585
    return FALSE;
5586
 
5587
  if (! _bfd_elf_maybe_strip_eh_frame_hdr (info))
5588
    return FALSE;
5589
 
5590
  dynobj = elf_hash_table (info)->dynobj;
5591
 
5592
  /* If there were no dynamic objects in the link, there is nothing to
5593
     do here.  */
5594
  if (dynobj == NULL)
5595
    return TRUE;
5596
 
5597
  if (elf_hash_table (info)->dynamic_sections_created)
5598
    {
5599
      struct elf_info_failed eif;
5600
      struct elf_link_hash_entry *h;
5601
      asection *dynstr;
5602
      struct bfd_elf_version_tree *t;
5603
      struct bfd_elf_version_expr *d;
5604
      asection *s;
5605
      bfd_boolean all_defined;
5606
 
5607
      *sinterpptr = bfd_get_section_by_name (dynobj, ".interp");
5608
      BFD_ASSERT (*sinterpptr != NULL || !info->executable);
5609
 
5610
      if (soname != NULL)
5611
        {
5612
          soname_indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
5613
                                             soname, TRUE);
5614
          if (soname_indx == (bfd_size_type) -1
5615
              || !_bfd_elf_add_dynamic_entry (info, DT_SONAME, soname_indx))
5616
            return FALSE;
5617
        }
5618
 
5619
      if (info->symbolic)
5620
        {
5621
          if (!_bfd_elf_add_dynamic_entry (info, DT_SYMBOLIC, 0))
5622
            return FALSE;
5623
          info->flags |= DF_SYMBOLIC;
5624
        }
5625
 
5626
      if (rpath != NULL)
5627
        {
5628
          bfd_size_type indx;
5629
 
5630
          indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, rpath,
5631
                                      TRUE);
5632
          if (indx == (bfd_size_type) -1
5633
              || !_bfd_elf_add_dynamic_entry (info, DT_RPATH, indx))
5634
            return FALSE;
5635
 
5636
          if  (info->new_dtags)
5637
            {
5638
              _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr, indx);
5639
              if (!_bfd_elf_add_dynamic_entry (info, DT_RUNPATH, indx))
5640
                return FALSE;
5641
            }
5642
        }
5643
 
5644
      if (filter_shlib != NULL)
5645
        {
5646
          bfd_size_type indx;
5647
 
5648
          indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
5649
                                      filter_shlib, TRUE);
5650
          if (indx == (bfd_size_type) -1
5651
              || !_bfd_elf_add_dynamic_entry (info, DT_FILTER, indx))
5652
            return FALSE;
5653
        }
5654
 
5655
      if (auxiliary_filters != NULL)
5656
        {
5657
          const char * const *p;
5658
 
5659
          for (p = auxiliary_filters; *p != NULL; p++)
5660
            {
5661
              bfd_size_type indx;
5662
 
5663
              indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
5664
                                          *p, TRUE);
5665
              if (indx == (bfd_size_type) -1
5666
                  || !_bfd_elf_add_dynamic_entry (info, DT_AUXILIARY, indx))
5667
                return FALSE;
5668
            }
5669
        }
5670
 
5671
      if (audit != NULL)
5672
        {
5673
          bfd_size_type indx;
5674
 
5675
          indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, audit,
5676
                                      TRUE);
5677
          if (indx == (bfd_size_type) -1
5678
              || !_bfd_elf_add_dynamic_entry (info, DT_AUDIT, indx))
5679
            return FALSE;
5680
        }
5681
 
5682
      if (depaudit != NULL)
5683
        {
5684
          bfd_size_type indx;
5685
 
5686
          indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, depaudit,
5687
                                      TRUE);
5688
          if (indx == (bfd_size_type) -1
5689
              || !_bfd_elf_add_dynamic_entry (info, DT_DEPAUDIT, indx))
5690
            return FALSE;
5691
        }
5692
 
5693
      eif.info = info;
5694
      eif.failed = FALSE;
5695
 
5696
      /* If we are supposed to export all symbols into the dynamic symbol
5697
         table (this is not the normal case), then do so.  */
5698
      if (info->export_dynamic
5699
          || (info->executable && info->dynamic))
5700
        {
5701
          elf_link_hash_traverse (elf_hash_table (info),
5702
                                  _bfd_elf_export_symbol,
5703
                                  &eif);
5704
          if (eif.failed)
5705
            return FALSE;
5706
        }
5707
 
5708
      /* Make all global versions with definition.  */
5709 163 khays
      for (t = info->version_info; t != NULL; t = t->next)
5710 14 khays
        for (d = t->globals.list; d != NULL; d = d->next)
5711
          if (!d->symver && d->literal)
5712
            {
5713
              const char *verstr, *name;
5714
              size_t namelen, verlen, newlen;
5715
              char *newname, *p, leading_char;
5716
              struct elf_link_hash_entry *newh;
5717
 
5718
              leading_char = bfd_get_symbol_leading_char (output_bfd);
5719
              name = d->pattern;
5720
              namelen = strlen (name) + (leading_char != '\0');
5721
              verstr = t->name;
5722
              verlen = strlen (verstr);
5723
              newlen = namelen + verlen + 3;
5724
 
5725
              newname = (char *) bfd_malloc (newlen);
5726
              if (newname == NULL)
5727
                return FALSE;
5728
              newname[0] = leading_char;
5729
              memcpy (newname + (leading_char != '\0'), name, namelen);
5730
 
5731
              /* Check the hidden versioned definition.  */
5732
              p = newname + namelen;
5733
              *p++ = ELF_VER_CHR;
5734
              memcpy (p, verstr, verlen + 1);
5735
              newh = elf_link_hash_lookup (elf_hash_table (info),
5736
                                           newname, FALSE, FALSE,
5737
                                           FALSE);
5738
              if (newh == NULL
5739
                  || (newh->root.type != bfd_link_hash_defined
5740
                      && newh->root.type != bfd_link_hash_defweak))
5741
                {
5742
                  /* Check the default versioned definition.  */
5743
                  *p++ = ELF_VER_CHR;
5744
                  memcpy (p, verstr, verlen + 1);
5745
                  newh = elf_link_hash_lookup (elf_hash_table (info),
5746
                                               newname, FALSE, FALSE,
5747
                                               FALSE);
5748
                }
5749
              free (newname);
5750
 
5751
              /* Mark this version if there is a definition and it is
5752
                 not defined in a shared object.  */
5753
              if (newh != NULL
5754
                  && !newh->def_dynamic
5755
                  && (newh->root.type == bfd_link_hash_defined
5756
                      || newh->root.type == bfd_link_hash_defweak))
5757
                d->symver = 1;
5758
            }
5759
 
5760
      /* Attach all the symbols to their version information.  */
5761
      asvinfo.info = info;
5762
      asvinfo.failed = FALSE;
5763
 
5764
      elf_link_hash_traverse (elf_hash_table (info),
5765
                              _bfd_elf_link_assign_sym_version,
5766
                              &asvinfo);
5767
      if (asvinfo.failed)
5768
        return FALSE;
5769
 
5770
      if (!info->allow_undefined_version)
5771
        {
5772
          /* Check if all global versions have a definition.  */
5773
          all_defined = TRUE;
5774 163 khays
          for (t = info->version_info; t != NULL; t = t->next)
5775 14 khays
            for (d = t->globals.list; d != NULL; d = d->next)
5776
              if (d->literal && !d->symver && !d->script)
5777
                {
5778
                  (*_bfd_error_handler)
5779
                    (_("%s: undefined version: %s"),
5780
                     d->pattern, t->name);
5781
                  all_defined = FALSE;
5782
                }
5783
 
5784
          if (!all_defined)
5785
            {
5786
              bfd_set_error (bfd_error_bad_value);
5787
              return FALSE;
5788
            }
5789
        }
5790
 
5791
      /* Find all symbols which were defined in a dynamic object and make
5792
         the backend pick a reasonable value for them.  */
5793
      elf_link_hash_traverse (elf_hash_table (info),
5794
                              _bfd_elf_adjust_dynamic_symbol,
5795
                              &eif);
5796
      if (eif.failed)
5797
        return FALSE;
5798
 
5799
      /* Add some entries to the .dynamic section.  We fill in some of the
5800
         values later, in bfd_elf_final_link, but we must add the entries
5801
         now so that we know the final size of the .dynamic section.  */
5802
 
5803
      /* If there are initialization and/or finalization functions to
5804
         call then add the corresponding DT_INIT/DT_FINI entries.  */
5805
      h = (info->init_function
5806
           ? elf_link_hash_lookup (elf_hash_table (info),
5807
                                   info->init_function, FALSE,
5808
                                   FALSE, FALSE)
5809
           : NULL);
5810
      if (h != NULL
5811
          && (h->ref_regular
5812
              || h->def_regular))
5813
        {
5814
          if (!_bfd_elf_add_dynamic_entry (info, DT_INIT, 0))
5815
            return FALSE;
5816
        }
5817
      h = (info->fini_function
5818
           ? elf_link_hash_lookup (elf_hash_table (info),
5819
                                   info->fini_function, FALSE,
5820
                                   FALSE, FALSE)
5821
           : NULL);
5822
      if (h != NULL
5823
          && (h->ref_regular
5824
              || h->def_regular))
5825
        {
5826
          if (!_bfd_elf_add_dynamic_entry (info, DT_FINI, 0))
5827
            return FALSE;
5828
        }
5829
 
5830
      s = bfd_get_section_by_name (output_bfd, ".preinit_array");
5831
      if (s != NULL && s->linker_has_input)
5832
        {
5833
          /* DT_PREINIT_ARRAY is not allowed in shared library.  */
5834
          if (! info->executable)
5835
            {
5836
              bfd *sub;
5837
              asection *o;
5838
 
5839
              for (sub = info->input_bfds; sub != NULL;
5840
                   sub = sub->link_next)
5841
                if (bfd_get_flavour (sub) == bfd_target_elf_flavour)
5842
                  for (o = sub->sections; o != NULL; o = o->next)
5843
                    if (elf_section_data (o)->this_hdr.sh_type
5844
                        == SHT_PREINIT_ARRAY)
5845
                      {
5846
                        (*_bfd_error_handler)
5847
                          (_("%B: .preinit_array section is not allowed in DSO"),
5848
                           sub);
5849
                        break;
5850
                      }
5851
 
5852
              bfd_set_error (bfd_error_nonrepresentable_section);
5853
              return FALSE;
5854
            }
5855
 
5856
          if (!_bfd_elf_add_dynamic_entry (info, DT_PREINIT_ARRAY, 0)
5857
              || !_bfd_elf_add_dynamic_entry (info, DT_PREINIT_ARRAYSZ, 0))
5858
            return FALSE;
5859
        }
5860
      s = bfd_get_section_by_name (output_bfd, ".init_array");
5861
      if (s != NULL && s->linker_has_input)
5862
        {
5863
          if (!_bfd_elf_add_dynamic_entry (info, DT_INIT_ARRAY, 0)
5864
              || !_bfd_elf_add_dynamic_entry (info, DT_INIT_ARRAYSZ, 0))
5865
            return FALSE;
5866
        }
5867
      s = bfd_get_section_by_name (output_bfd, ".fini_array");
5868
      if (s != NULL && s->linker_has_input)
5869
        {
5870
          if (!_bfd_elf_add_dynamic_entry (info, DT_FINI_ARRAY, 0)
5871
              || !_bfd_elf_add_dynamic_entry (info, DT_FINI_ARRAYSZ, 0))
5872
            return FALSE;
5873
        }
5874
 
5875
      dynstr = bfd_get_section_by_name (dynobj, ".dynstr");
5876
      /* If .dynstr is excluded from the link, we don't want any of
5877
         these tags.  Strictly, we should be checking each section
5878
         individually;  This quick check covers for the case where
5879
         someone does a /DISCARD/ : { *(*) }.  */
5880
      if (dynstr != NULL && dynstr->output_section != bfd_abs_section_ptr)
5881
        {
5882
          bfd_size_type strsize;
5883
 
5884
          strsize = _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
5885
          if ((info->emit_hash
5886
               && !_bfd_elf_add_dynamic_entry (info, DT_HASH, 0))
5887
              || (info->emit_gnu_hash
5888
                  && !_bfd_elf_add_dynamic_entry (info, DT_GNU_HASH, 0))
5889
              || !_bfd_elf_add_dynamic_entry (info, DT_STRTAB, 0)
5890
              || !_bfd_elf_add_dynamic_entry (info, DT_SYMTAB, 0)
5891
              || !_bfd_elf_add_dynamic_entry (info, DT_STRSZ, strsize)
5892
              || !_bfd_elf_add_dynamic_entry (info, DT_SYMENT,
5893
                                              bed->s->sizeof_sym))
5894
            return FALSE;
5895
        }
5896
    }
5897
 
5898
  /* The backend must work out the sizes of all the other dynamic
5899
     sections.  */
5900
  if (bed->elf_backend_size_dynamic_sections
5901
      && ! (*bed->elf_backend_size_dynamic_sections) (output_bfd, info))
5902
    return FALSE;
5903
 
5904
  if (elf_hash_table (info)->dynamic_sections_created)
5905
    {
5906
      unsigned long section_sym_count;
5907 163 khays
      struct bfd_elf_version_tree *verdefs;
5908 14 khays
      asection *s;
5909
 
5910
      /* Set up the version definition section.  */
5911
      s = bfd_get_section_by_name (dynobj, ".gnu.version_d");
5912
      BFD_ASSERT (s != NULL);
5913
 
5914
      /* We may have created additional version definitions if we are
5915
         just linking a regular application.  */
5916 163 khays
      verdefs = info->version_info;
5917 14 khays
 
5918
      /* Skip anonymous version tag.  */
5919
      if (verdefs != NULL && verdefs->vernum == 0)
5920
        verdefs = verdefs->next;
5921
 
5922
      if (verdefs == NULL && !info->create_default_symver)
5923
        s->flags |= SEC_EXCLUDE;
5924
      else
5925
        {
5926
          unsigned int cdefs;
5927
          bfd_size_type size;
5928
          struct bfd_elf_version_tree *t;
5929
          bfd_byte *p;
5930
          Elf_Internal_Verdef def;
5931
          Elf_Internal_Verdaux defaux;
5932
          struct bfd_link_hash_entry *bh;
5933
          struct elf_link_hash_entry *h;
5934
          const char *name;
5935
 
5936
          cdefs = 0;
5937
          size = 0;
5938
 
5939
          /* Make space for the base version.  */
5940
          size += sizeof (Elf_External_Verdef);
5941
          size += sizeof (Elf_External_Verdaux);
5942
          ++cdefs;
5943
 
5944
          /* Make space for the default version.  */
5945
          if (info->create_default_symver)
5946
            {
5947
              size += sizeof (Elf_External_Verdef);
5948
              ++cdefs;
5949
            }
5950
 
5951
          for (t = verdefs; t != NULL; t = t->next)
5952
            {
5953
              struct bfd_elf_version_deps *n;
5954
 
5955
              /* Don't emit base version twice.  */
5956
              if (t->vernum == 0)
5957
                continue;
5958
 
5959
              size += sizeof (Elf_External_Verdef);
5960
              size += sizeof (Elf_External_Verdaux);
5961
              ++cdefs;
5962
 
5963
              for (n = t->deps; n != NULL; n = n->next)
5964
                size += sizeof (Elf_External_Verdaux);
5965
            }
5966
 
5967
          s->size = size;
5968
          s->contents = (unsigned char *) bfd_alloc (output_bfd, s->size);
5969
          if (s->contents == NULL && s->size != 0)
5970
            return FALSE;
5971
 
5972
          /* Fill in the version definition section.  */
5973
 
5974
          p = s->contents;
5975
 
5976
          def.vd_version = VER_DEF_CURRENT;
5977
          def.vd_flags = VER_FLG_BASE;
5978
          def.vd_ndx = 1;
5979
          def.vd_cnt = 1;
5980
          if (info->create_default_symver)
5981
            {
5982
              def.vd_aux = 2 * sizeof (Elf_External_Verdef);
5983
              def.vd_next = sizeof (Elf_External_Verdef);
5984
            }
5985
          else
5986
            {
5987
              def.vd_aux = sizeof (Elf_External_Verdef);
5988
              def.vd_next = (sizeof (Elf_External_Verdef)
5989
                             + sizeof (Elf_External_Verdaux));
5990
            }
5991
 
5992
          if (soname_indx != (bfd_size_type) -1)
5993
            {
5994
              _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr,
5995
                                      soname_indx);
5996
              def.vd_hash = bfd_elf_hash (soname);
5997
              defaux.vda_name = soname_indx;
5998
              name = soname;
5999
            }
6000
          else
6001
            {
6002
              bfd_size_type indx;
6003
 
6004
              name = lbasename (output_bfd->filename);
6005
              def.vd_hash = bfd_elf_hash (name);
6006
              indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
6007
                                          name, FALSE);
6008
              if (indx == (bfd_size_type) -1)
6009
                return FALSE;
6010
              defaux.vda_name = indx;
6011
            }
6012
          defaux.vda_next = 0;
6013
 
6014
          _bfd_elf_swap_verdef_out (output_bfd, &def,
6015
                                    (Elf_External_Verdef *) p);
6016
          p += sizeof (Elf_External_Verdef);
6017
          if (info->create_default_symver)
6018
            {
6019
              /* Add a symbol representing this version.  */
6020
              bh = NULL;
6021
              if (! (_bfd_generic_link_add_one_symbol
6022
                     (info, dynobj, name, BSF_GLOBAL, bfd_abs_section_ptr,
6023
                      0, NULL, FALSE,
6024
                      get_elf_backend_data (dynobj)->collect, &bh)))
6025
                return FALSE;
6026
              h = (struct elf_link_hash_entry *) bh;
6027
              h->non_elf = 0;
6028
              h->def_regular = 1;
6029
              h->type = STT_OBJECT;
6030
              h->verinfo.vertree = NULL;
6031
 
6032
              if (! bfd_elf_link_record_dynamic_symbol (info, h))
6033
                return FALSE;
6034
 
6035
              /* Create a duplicate of the base version with the same
6036
                 aux block, but different flags.  */
6037
              def.vd_flags = 0;
6038
              def.vd_ndx = 2;
6039
              def.vd_aux = sizeof (Elf_External_Verdef);
6040
              if (verdefs)
6041
                def.vd_next = (sizeof (Elf_External_Verdef)
6042
                               + sizeof (Elf_External_Verdaux));
6043
              else
6044
                def.vd_next = 0;
6045
              _bfd_elf_swap_verdef_out (output_bfd, &def,
6046
                                        (Elf_External_Verdef *) p);
6047
              p += sizeof (Elf_External_Verdef);
6048
            }
6049
          _bfd_elf_swap_verdaux_out (output_bfd, &defaux,
6050
                                     (Elf_External_Verdaux *) p);
6051
          p += sizeof (Elf_External_Verdaux);
6052
 
6053
          for (t = verdefs; t != NULL; t = t->next)
6054
            {
6055
              unsigned int cdeps;
6056
              struct bfd_elf_version_deps *n;
6057
 
6058
              /* Don't emit the base version twice.  */
6059
              if (t->vernum == 0)
6060
                continue;
6061
 
6062
              cdeps = 0;
6063
              for (n = t->deps; n != NULL; n = n->next)
6064
                ++cdeps;
6065
 
6066
              /* Add a symbol representing this version.  */
6067
              bh = NULL;
6068
              if (! (_bfd_generic_link_add_one_symbol
6069
                     (info, dynobj, t->name, BSF_GLOBAL, bfd_abs_section_ptr,
6070
                      0, NULL, FALSE,
6071
                      get_elf_backend_data (dynobj)->collect, &bh)))
6072
                return FALSE;
6073
              h = (struct elf_link_hash_entry *) bh;
6074
              h->non_elf = 0;
6075
              h->def_regular = 1;
6076
              h->type = STT_OBJECT;
6077
              h->verinfo.vertree = t;
6078
 
6079
              if (! bfd_elf_link_record_dynamic_symbol (info, h))
6080
                return FALSE;
6081
 
6082
              def.vd_version = VER_DEF_CURRENT;
6083
              def.vd_flags = 0;
6084
              if (t->globals.list == NULL
6085
                  && t->locals.list == NULL
6086
                  && ! t->used)
6087
                def.vd_flags |= VER_FLG_WEAK;
6088
              def.vd_ndx = t->vernum + (info->create_default_symver ? 2 : 1);
6089
              def.vd_cnt = cdeps + 1;
6090
              def.vd_hash = bfd_elf_hash (t->name);
6091
              def.vd_aux = sizeof (Elf_External_Verdef);
6092
              def.vd_next = 0;
6093
 
6094
              /* If a basever node is next, it *must* be the last node in
6095
                 the chain, otherwise Verdef construction breaks.  */
6096
              if (t->next != NULL && t->next->vernum == 0)
6097
                BFD_ASSERT (t->next->next == NULL);
6098
 
6099
              if (t->next != NULL && t->next->vernum != 0)
6100
                def.vd_next = (sizeof (Elf_External_Verdef)
6101
                               + (cdeps + 1) * sizeof (Elf_External_Verdaux));
6102
 
6103
              _bfd_elf_swap_verdef_out (output_bfd, &def,
6104
                                        (Elf_External_Verdef *) p);
6105
              p += sizeof (Elf_External_Verdef);
6106
 
6107
              defaux.vda_name = h->dynstr_index;
6108
              _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr,
6109
                                      h->dynstr_index);
6110
              defaux.vda_next = 0;
6111
              if (t->deps != NULL)
6112
                defaux.vda_next = sizeof (Elf_External_Verdaux);
6113
              t->name_indx = defaux.vda_name;
6114
 
6115
              _bfd_elf_swap_verdaux_out (output_bfd, &defaux,
6116
                                         (Elf_External_Verdaux *) p);
6117
              p += sizeof (Elf_External_Verdaux);
6118
 
6119
              for (n = t->deps; n != NULL; n = n->next)
6120
                {
6121
                  if (n->version_needed == NULL)
6122
                    {
6123
                      /* This can happen if there was an error in the
6124
                         version script.  */
6125
                      defaux.vda_name = 0;
6126
                    }
6127
                  else
6128
                    {
6129
                      defaux.vda_name = n->version_needed->name_indx;
6130
                      _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr,
6131
                                              defaux.vda_name);
6132
                    }
6133
                  if (n->next == NULL)
6134
                    defaux.vda_next = 0;
6135
                  else
6136
                    defaux.vda_next = sizeof (Elf_External_Verdaux);
6137
 
6138
                  _bfd_elf_swap_verdaux_out (output_bfd, &defaux,
6139
                                             (Elf_External_Verdaux *) p);
6140
                  p += sizeof (Elf_External_Verdaux);
6141
                }
6142
            }
6143
 
6144
          if (!_bfd_elf_add_dynamic_entry (info, DT_VERDEF, 0)
6145
              || !_bfd_elf_add_dynamic_entry (info, DT_VERDEFNUM, cdefs))
6146
            return FALSE;
6147
 
6148
          elf_tdata (output_bfd)->cverdefs = cdefs;
6149
        }
6150
 
6151
      if ((info->new_dtags && info->flags) || (info->flags & DF_STATIC_TLS))
6152
        {
6153
          if (!_bfd_elf_add_dynamic_entry (info, DT_FLAGS, info->flags))
6154
            return FALSE;
6155
        }
6156
      else if (info->flags & DF_BIND_NOW)
6157
        {
6158
          if (!_bfd_elf_add_dynamic_entry (info, DT_BIND_NOW, 0))
6159
            return FALSE;
6160
        }
6161
 
6162
      if (info->flags_1)
6163
        {
6164
          if (info->executable)
6165
            info->flags_1 &= ~ (DF_1_INITFIRST
6166
                                | DF_1_NODELETE
6167
                                | DF_1_NOOPEN);
6168
          if (!_bfd_elf_add_dynamic_entry (info, DT_FLAGS_1, info->flags_1))
6169
            return FALSE;
6170
        }
6171
 
6172
      /* Work out the size of the version reference section.  */
6173
 
6174
      s = bfd_get_section_by_name (dynobj, ".gnu.version_r");
6175
      BFD_ASSERT (s != NULL);
6176
      {
6177
        struct elf_find_verdep_info sinfo;
6178
 
6179
        sinfo.info = info;
6180
        sinfo.vers = elf_tdata (output_bfd)->cverdefs;
6181
        if (sinfo.vers == 0)
6182
          sinfo.vers = 1;
6183
        sinfo.failed = FALSE;
6184
 
6185
        elf_link_hash_traverse (elf_hash_table (info),
6186
                                _bfd_elf_link_find_version_dependencies,
6187
                                &sinfo);
6188
        if (sinfo.failed)
6189
          return FALSE;
6190
 
6191
        if (elf_tdata (output_bfd)->verref == NULL)
6192
          s->flags |= SEC_EXCLUDE;
6193
        else
6194
          {
6195
            Elf_Internal_Verneed *t;
6196
            unsigned int size;
6197
            unsigned int crefs;
6198
            bfd_byte *p;
6199
 
6200
            /* Build the version dependency section.  */
6201
            size = 0;
6202
            crefs = 0;
6203
            for (t = elf_tdata (output_bfd)->verref;
6204
                 t != NULL;
6205
                 t = t->vn_nextref)
6206
              {
6207
                Elf_Internal_Vernaux *a;
6208
 
6209
                size += sizeof (Elf_External_Verneed);
6210
                ++crefs;
6211
                for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
6212
                  size += sizeof (Elf_External_Vernaux);
6213
              }
6214
 
6215
            s->size = size;
6216
            s->contents = (unsigned char *) bfd_alloc (output_bfd, s->size);
6217
            if (s->contents == NULL)
6218
              return FALSE;
6219
 
6220
            p = s->contents;
6221
            for (t = elf_tdata (output_bfd)->verref;
6222
                 t != NULL;
6223
                 t = t->vn_nextref)
6224
              {
6225
                unsigned int caux;
6226
                Elf_Internal_Vernaux *a;
6227
                bfd_size_type indx;
6228
 
6229
                caux = 0;
6230
                for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
6231
                  ++caux;
6232
 
6233
                t->vn_version = VER_NEED_CURRENT;
6234
                t->vn_cnt = caux;
6235
                indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
6236
                                            elf_dt_name (t->vn_bfd) != NULL
6237
                                            ? elf_dt_name (t->vn_bfd)
6238
                                            : lbasename (t->vn_bfd->filename),
6239
                                            FALSE);
6240
                if (indx == (bfd_size_type) -1)
6241
                  return FALSE;
6242
                t->vn_file = indx;
6243
                t->vn_aux = sizeof (Elf_External_Verneed);
6244
                if (t->vn_nextref == NULL)
6245
                  t->vn_next = 0;
6246
                else
6247
                  t->vn_next = (sizeof (Elf_External_Verneed)
6248
                                + caux * sizeof (Elf_External_Vernaux));
6249
 
6250
                _bfd_elf_swap_verneed_out (output_bfd, t,
6251
                                           (Elf_External_Verneed *) p);
6252
                p += sizeof (Elf_External_Verneed);
6253
 
6254
                for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
6255
                  {
6256
                    a->vna_hash = bfd_elf_hash (a->vna_nodename);
6257
                    indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
6258
                                                a->vna_nodename, FALSE);
6259
                    if (indx == (bfd_size_type) -1)
6260
                      return FALSE;
6261
                    a->vna_name = indx;
6262
                    if (a->vna_nextptr == NULL)
6263
                      a->vna_next = 0;
6264
                    else
6265
                      a->vna_next = sizeof (Elf_External_Vernaux);
6266
 
6267
                    _bfd_elf_swap_vernaux_out (output_bfd, a,
6268
                                               (Elf_External_Vernaux *) p);
6269
                    p += sizeof (Elf_External_Vernaux);
6270
                  }
6271
              }
6272
 
6273
            if (!_bfd_elf_add_dynamic_entry (info, DT_VERNEED, 0)
6274
                || !_bfd_elf_add_dynamic_entry (info, DT_VERNEEDNUM, crefs))
6275
              return FALSE;
6276
 
6277
            elf_tdata (output_bfd)->cverrefs = crefs;
6278
          }
6279
      }
6280
 
6281
      if ((elf_tdata (output_bfd)->cverrefs == 0
6282
           && elf_tdata (output_bfd)->cverdefs == 0)
6283
          || _bfd_elf_link_renumber_dynsyms (output_bfd, info,
6284
                                             &section_sym_count) == 0)
6285
        {
6286
          s = bfd_get_section_by_name (dynobj, ".gnu.version");
6287
          s->flags |= SEC_EXCLUDE;
6288
        }
6289
    }
6290
  return TRUE;
6291
}
6292
 
6293
/* Find the first non-excluded output section.  We'll use its
6294
   section symbol for some emitted relocs.  */
6295
void
6296
_bfd_elf_init_1_index_section (bfd *output_bfd, struct bfd_link_info *info)
6297
{
6298
  asection *s;
6299
 
6300
  for (s = output_bfd->sections; s != NULL; s = s->next)
6301
    if ((s->flags & (SEC_EXCLUDE | SEC_ALLOC)) == SEC_ALLOC
6302
        && !_bfd_elf_link_omit_section_dynsym (output_bfd, info, s))
6303
      {
6304
        elf_hash_table (info)->text_index_section = s;
6305
        break;
6306
      }
6307
}
6308
 
6309
/* Find two non-excluded output sections, one for code, one for data.
6310
   We'll use their section symbols for some emitted relocs.  */
6311
void
6312
_bfd_elf_init_2_index_sections (bfd *output_bfd, struct bfd_link_info *info)
6313
{
6314
  asection *s;
6315
 
6316
  /* Data first, since setting text_index_section changes
6317
     _bfd_elf_link_omit_section_dynsym.  */
6318
  for (s = output_bfd->sections; s != NULL; s = s->next)
6319
    if (((s->flags & (SEC_EXCLUDE | SEC_ALLOC | SEC_READONLY)) == SEC_ALLOC)
6320
        && !_bfd_elf_link_omit_section_dynsym (output_bfd, info, s))
6321
      {
6322
        elf_hash_table (info)->data_index_section = s;
6323
        break;
6324
      }
6325
 
6326
  for (s = output_bfd->sections; s != NULL; s = s->next)
6327
    if (((s->flags & (SEC_EXCLUDE | SEC_ALLOC | SEC_READONLY))
6328
         == (SEC_ALLOC | SEC_READONLY))
6329
        && !_bfd_elf_link_omit_section_dynsym (output_bfd, info, s))
6330
      {
6331
        elf_hash_table (info)->text_index_section = s;
6332
        break;
6333
      }
6334
 
6335
  if (elf_hash_table (info)->text_index_section == NULL)
6336
    elf_hash_table (info)->text_index_section
6337
      = elf_hash_table (info)->data_index_section;
6338
}
6339
 
6340
bfd_boolean
6341
bfd_elf_size_dynsym_hash_dynstr (bfd *output_bfd, struct bfd_link_info *info)
6342
{
6343
  const struct elf_backend_data *bed;
6344
 
6345
  if (!is_elf_hash_table (info->hash))
6346
    return TRUE;
6347
 
6348
  bed = get_elf_backend_data (output_bfd);
6349
  (*bed->elf_backend_init_index_section) (output_bfd, info);
6350
 
6351
  if (elf_hash_table (info)->dynamic_sections_created)
6352
    {
6353
      bfd *dynobj;
6354
      asection *s;
6355
      bfd_size_type dynsymcount;
6356
      unsigned long section_sym_count;
6357
      unsigned int dtagcount;
6358
 
6359
      dynobj = elf_hash_table (info)->dynobj;
6360
 
6361
      /* Assign dynsym indicies.  In a shared library we generate a
6362
         section symbol for each output section, which come first.
6363
         Next come all of the back-end allocated local dynamic syms,
6364
         followed by the rest of the global symbols.  */
6365
 
6366
      dynsymcount = _bfd_elf_link_renumber_dynsyms (output_bfd, info,
6367
                                                    &section_sym_count);
6368
 
6369
      /* Work out the size of the symbol version section.  */
6370
      s = bfd_get_section_by_name (dynobj, ".gnu.version");
6371
      BFD_ASSERT (s != NULL);
6372
      if (dynsymcount != 0
6373
          && (s->flags & SEC_EXCLUDE) == 0)
6374
        {
6375
          s->size = dynsymcount * sizeof (Elf_External_Versym);
6376
          s->contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
6377
          if (s->contents == NULL)
6378
            return FALSE;
6379
 
6380
          if (!_bfd_elf_add_dynamic_entry (info, DT_VERSYM, 0))
6381
            return FALSE;
6382
        }
6383
 
6384
      /* Set the size of the .dynsym and .hash sections.  We counted
6385
         the number of dynamic symbols in elf_link_add_object_symbols.
6386
         We will build the contents of .dynsym and .hash when we build
6387
         the final symbol table, because until then we do not know the
6388
         correct value to give the symbols.  We built the .dynstr
6389
         section as we went along in elf_link_add_object_symbols.  */
6390
      s = bfd_get_section_by_name (dynobj, ".dynsym");
6391
      BFD_ASSERT (s != NULL);
6392
      s->size = dynsymcount * bed->s->sizeof_sym;
6393
 
6394
      if (dynsymcount != 0)
6395
        {
6396
          s->contents = (unsigned char *) bfd_alloc (output_bfd, s->size);
6397
          if (s->contents == NULL)
6398
            return FALSE;
6399
 
6400
          /* The first entry in .dynsym is a dummy symbol.
6401
             Clear all the section syms, in case we don't output them all.  */
6402
          ++section_sym_count;
6403
          memset (s->contents, 0, section_sym_count * bed->s->sizeof_sym);
6404
        }
6405
 
6406
      elf_hash_table (info)->bucketcount = 0;
6407
 
6408
      /* Compute the size of the hashing table.  As a side effect this
6409
         computes the hash values for all the names we export.  */
6410
      if (info->emit_hash)
6411
        {
6412
          unsigned long int *hashcodes;
6413
          struct hash_codes_info hashinf;
6414
          bfd_size_type amt;
6415
          unsigned long int nsyms;
6416
          size_t bucketcount;
6417
          size_t hash_entry_size;
6418
 
6419
          /* Compute the hash values for all exported symbols.  At the same
6420
             time store the values in an array so that we could use them for
6421
             optimizations.  */
6422
          amt = dynsymcount * sizeof (unsigned long int);
6423
          hashcodes = (unsigned long int *) bfd_malloc (amt);
6424
          if (hashcodes == NULL)
6425
            return FALSE;
6426
          hashinf.hashcodes = hashcodes;
6427
          hashinf.error = FALSE;
6428
 
6429
          /* Put all hash values in HASHCODES.  */
6430
          elf_link_hash_traverse (elf_hash_table (info),
6431
                                  elf_collect_hash_codes, &hashinf);
6432
          if (hashinf.error)
6433
            {
6434
              free (hashcodes);
6435
              return FALSE;
6436
            }
6437
 
6438
          nsyms = hashinf.hashcodes - hashcodes;
6439
          bucketcount
6440
            = compute_bucket_count (info, hashcodes, nsyms, 0);
6441
          free (hashcodes);
6442
 
6443
          if (bucketcount == 0)
6444
            return FALSE;
6445
 
6446
          elf_hash_table (info)->bucketcount = bucketcount;
6447
 
6448
          s = bfd_get_section_by_name (dynobj, ".hash");
6449
          BFD_ASSERT (s != NULL);
6450
          hash_entry_size = elf_section_data (s)->this_hdr.sh_entsize;
6451
          s->size = ((2 + bucketcount + dynsymcount) * hash_entry_size);
6452
          s->contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
6453
          if (s->contents == NULL)
6454
            return FALSE;
6455
 
6456
          bfd_put (8 * hash_entry_size, output_bfd, bucketcount, s->contents);
6457
          bfd_put (8 * hash_entry_size, output_bfd, dynsymcount,
6458
                   s->contents + hash_entry_size);
6459
        }
6460
 
6461
      if (info->emit_gnu_hash)
6462
        {
6463
          size_t i, cnt;
6464
          unsigned char *contents;
6465
          struct collect_gnu_hash_codes cinfo;
6466
          bfd_size_type amt;
6467
          size_t bucketcount;
6468
 
6469
          memset (&cinfo, 0, sizeof (cinfo));
6470
 
6471
          /* Compute the hash values for all exported symbols.  At the same
6472
             time store the values in an array so that we could use them for
6473
             optimizations.  */
6474
          amt = dynsymcount * 2 * sizeof (unsigned long int);
6475
          cinfo.hashcodes = (long unsigned int *) bfd_malloc (amt);
6476
          if (cinfo.hashcodes == NULL)
6477
            return FALSE;
6478
 
6479
          cinfo.hashval = cinfo.hashcodes + dynsymcount;
6480
          cinfo.min_dynindx = -1;
6481
          cinfo.output_bfd = output_bfd;
6482
          cinfo.bed = bed;
6483
 
6484
          /* Put all hash values in HASHCODES.  */
6485
          elf_link_hash_traverse (elf_hash_table (info),
6486
                                  elf_collect_gnu_hash_codes, &cinfo);
6487
          if (cinfo.error)
6488
            {
6489
              free (cinfo.hashcodes);
6490
              return FALSE;
6491
            }
6492
 
6493
          bucketcount
6494
            = compute_bucket_count (info, cinfo.hashcodes, cinfo.nsyms, 1);
6495
 
6496
          if (bucketcount == 0)
6497
            {
6498
              free (cinfo.hashcodes);
6499
              return FALSE;
6500
            }
6501
 
6502
          s = bfd_get_section_by_name (dynobj, ".gnu.hash");
6503
          BFD_ASSERT (s != NULL);
6504
 
6505
          if (cinfo.nsyms == 0)
6506
            {
6507
              /* Empty .gnu.hash section is special.  */
6508
              BFD_ASSERT (cinfo.min_dynindx == -1);
6509
              free (cinfo.hashcodes);
6510
              s->size = 5 * 4 + bed->s->arch_size / 8;
6511
              contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
6512
              if (contents == NULL)
6513
                return FALSE;
6514
              s->contents = contents;
6515
              /* 1 empty bucket.  */
6516
              bfd_put_32 (output_bfd, 1, contents);
6517
              /* SYMIDX above the special symbol 0.  */
6518
              bfd_put_32 (output_bfd, 1, contents + 4);
6519
              /* Just one word for bitmask.  */
6520
              bfd_put_32 (output_bfd, 1, contents + 8);
6521
              /* Only hash fn bloom filter.  */
6522
              bfd_put_32 (output_bfd, 0, contents + 12);
6523
              /* No hashes are valid - empty bitmask.  */
6524
              bfd_put (bed->s->arch_size, output_bfd, 0, contents + 16);
6525
              /* No hashes in the only bucket.  */
6526
              bfd_put_32 (output_bfd, 0,
6527
                          contents + 16 + bed->s->arch_size / 8);
6528
            }
6529
          else
6530
            {
6531
              unsigned long int maskwords, maskbitslog2, x;
6532
              BFD_ASSERT (cinfo.min_dynindx != -1);
6533
 
6534
              x = cinfo.nsyms;
6535
              maskbitslog2 = 1;
6536
              while ((x >>= 1) != 0)
6537
                ++maskbitslog2;
6538
              if (maskbitslog2 < 3)
6539
                maskbitslog2 = 5;
6540
              else if ((1 << (maskbitslog2 - 2)) & cinfo.nsyms)
6541
                maskbitslog2 = maskbitslog2 + 3;
6542
              else
6543
                maskbitslog2 = maskbitslog2 + 2;
6544
              if (bed->s->arch_size == 64)
6545
                {
6546
                  if (maskbitslog2 == 5)
6547
                    maskbitslog2 = 6;
6548
                  cinfo.shift1 = 6;
6549
                }
6550
              else
6551
                cinfo.shift1 = 5;
6552
              cinfo.mask = (1 << cinfo.shift1) - 1;
6553
              cinfo.shift2 = maskbitslog2;
6554
              cinfo.maskbits = 1 << maskbitslog2;
6555
              maskwords = 1 << (maskbitslog2 - cinfo.shift1);
6556
              amt = bucketcount * sizeof (unsigned long int) * 2;
6557
              amt += maskwords * sizeof (bfd_vma);
6558
              cinfo.bitmask = (bfd_vma *) bfd_malloc (amt);
6559
              if (cinfo.bitmask == NULL)
6560
                {
6561
                  free (cinfo.hashcodes);
6562
                  return FALSE;
6563
                }
6564
 
6565
              cinfo.counts = (long unsigned int *) (cinfo.bitmask + maskwords);
6566
              cinfo.indx = cinfo.counts + bucketcount;
6567
              cinfo.symindx = dynsymcount - cinfo.nsyms;
6568
              memset (cinfo.bitmask, 0, maskwords * sizeof (bfd_vma));
6569
 
6570
              /* Determine how often each hash bucket is used.  */
6571
              memset (cinfo.counts, 0, bucketcount * sizeof (cinfo.counts[0]));
6572
              for (i = 0; i < cinfo.nsyms; ++i)
6573
                ++cinfo.counts[cinfo.hashcodes[i] % bucketcount];
6574
 
6575
              for (i = 0, cnt = cinfo.symindx; i < bucketcount; ++i)
6576
                if (cinfo.counts[i] != 0)
6577
                  {
6578
                    cinfo.indx[i] = cnt;
6579
                    cnt += cinfo.counts[i];
6580
                  }
6581
              BFD_ASSERT (cnt == dynsymcount);
6582
              cinfo.bucketcount = bucketcount;
6583
              cinfo.local_indx = cinfo.min_dynindx;
6584
 
6585
              s->size = (4 + bucketcount + cinfo.nsyms) * 4;
6586
              s->size += cinfo.maskbits / 8;
6587
              contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
6588
              if (contents == NULL)
6589
                {
6590
                  free (cinfo.bitmask);
6591
                  free (cinfo.hashcodes);
6592
                  return FALSE;
6593
                }
6594
 
6595
              s->contents = contents;
6596
              bfd_put_32 (output_bfd, bucketcount, contents);
6597
              bfd_put_32 (output_bfd, cinfo.symindx, contents + 4);
6598
              bfd_put_32 (output_bfd, maskwords, contents + 8);
6599
              bfd_put_32 (output_bfd, cinfo.shift2, contents + 12);
6600
              contents += 16 + cinfo.maskbits / 8;
6601
 
6602
              for (i = 0; i < bucketcount; ++i)
6603
                {
6604
                  if (cinfo.counts[i] == 0)
6605
                    bfd_put_32 (output_bfd, 0, contents);
6606
                  else
6607
                    bfd_put_32 (output_bfd, cinfo.indx[i], contents);
6608
                  contents += 4;
6609
                }
6610
 
6611
              cinfo.contents = contents;
6612
 
6613
              /* Renumber dynamic symbols, populate .gnu.hash section.  */
6614
              elf_link_hash_traverse (elf_hash_table (info),
6615
                                      elf_renumber_gnu_hash_syms, &cinfo);
6616
 
6617
              contents = s->contents + 16;
6618
              for (i = 0; i < maskwords; ++i)
6619
                {
6620
                  bfd_put (bed->s->arch_size, output_bfd, cinfo.bitmask[i],
6621
                           contents);
6622
                  contents += bed->s->arch_size / 8;
6623
                }
6624
 
6625
              free (cinfo.bitmask);
6626
              free (cinfo.hashcodes);
6627
            }
6628
        }
6629
 
6630
      s = bfd_get_section_by_name (dynobj, ".dynstr");
6631
      BFD_ASSERT (s != NULL);
6632
 
6633
      elf_finalize_dynstr (output_bfd, info);
6634
 
6635
      s->size = _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
6636
 
6637
      for (dtagcount = 0; dtagcount <= info->spare_dynamic_tags; ++dtagcount)
6638
        if (!_bfd_elf_add_dynamic_entry (info, DT_NULL, 0))
6639
          return FALSE;
6640
    }
6641
 
6642
  return TRUE;
6643
}
6644
 
6645
/* Indicate that we are only retrieving symbol values from this
6646
   section.  */
6647
 
6648
void
6649
_bfd_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
6650
{
6651
  if (is_elf_hash_table (info->hash))
6652
    sec->sec_info_type = ELF_INFO_TYPE_JUST_SYMS;
6653
  _bfd_generic_link_just_syms (sec, info);
6654
}
6655
 
6656
/* Make sure sec_info_type is cleared if sec_info is cleared too.  */
6657
 
6658
static void
6659
merge_sections_remove_hook (bfd *abfd ATTRIBUTE_UNUSED,
6660
                            asection *sec)
6661
{
6662
  BFD_ASSERT (sec->sec_info_type == ELF_INFO_TYPE_MERGE);
6663
  sec->sec_info_type = ELF_INFO_TYPE_NONE;
6664
}
6665
 
6666
/* Finish SHF_MERGE section merging.  */
6667
 
6668
bfd_boolean
6669
_bfd_elf_merge_sections (bfd *abfd, struct bfd_link_info *info)
6670
{
6671
  bfd *ibfd;
6672
  asection *sec;
6673
 
6674
  if (!is_elf_hash_table (info->hash))
6675
    return FALSE;
6676
 
6677
  for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
6678
    if ((ibfd->flags & DYNAMIC) == 0)
6679
      for (sec = ibfd->sections; sec != NULL; sec = sec->next)
6680
        if ((sec->flags & SEC_MERGE) != 0
6681
            && !bfd_is_abs_section (sec->output_section))
6682
          {
6683
            struct bfd_elf_section_data *secdata;
6684
 
6685
            secdata = elf_section_data (sec);
6686
            if (! _bfd_add_merge_section (abfd,
6687
                                          &elf_hash_table (info)->merge_info,
6688
                                          sec, &secdata->sec_info))
6689
              return FALSE;
6690
            else if (secdata->sec_info)
6691
              sec->sec_info_type = ELF_INFO_TYPE_MERGE;
6692
          }
6693
 
6694
  if (elf_hash_table (info)->merge_info != NULL)
6695
    _bfd_merge_sections (abfd, info, elf_hash_table (info)->merge_info,
6696
                         merge_sections_remove_hook);
6697
  return TRUE;
6698
}
6699
 
6700
/* Create an entry in an ELF linker hash table.  */
6701
 
6702
struct bfd_hash_entry *
6703
_bfd_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
6704
                            struct bfd_hash_table *table,
6705
                            const char *string)
6706
{
6707
  /* Allocate the structure if it has not already been allocated by a
6708
     subclass.  */
6709
  if (entry == NULL)
6710
    {
6711
      entry = (struct bfd_hash_entry *)
6712
          bfd_hash_allocate (table, sizeof (struct elf_link_hash_entry));
6713
      if (entry == NULL)
6714
        return entry;
6715
    }
6716
 
6717
  /* Call the allocation method of the superclass.  */
6718
  entry = _bfd_link_hash_newfunc (entry, table, string);
6719
  if (entry != NULL)
6720
    {
6721
      struct elf_link_hash_entry *ret = (struct elf_link_hash_entry *) entry;
6722
      struct elf_link_hash_table *htab = (struct elf_link_hash_table *) table;
6723
 
6724
      /* Set local fields.  */
6725
      ret->indx = -1;
6726
      ret->dynindx = -1;
6727
      ret->got = htab->init_got_refcount;
6728
      ret->plt = htab->init_plt_refcount;
6729
      memset (&ret->size, 0, (sizeof (struct elf_link_hash_entry)
6730
                              - offsetof (struct elf_link_hash_entry, size)));
6731
      /* Assume that we have been called by a non-ELF symbol reader.
6732
         This flag is then reset by the code which reads an ELF input
6733
         file.  This ensures that a symbol created by a non-ELF symbol
6734
         reader will have the flag set correctly.  */
6735
      ret->non_elf = 1;
6736
    }
6737
 
6738
  return entry;
6739
}
6740
 
6741
/* Copy data from an indirect symbol to its direct symbol, hiding the
6742
   old indirect symbol.  Also used for copying flags to a weakdef.  */
6743
 
6744
void
6745
_bfd_elf_link_hash_copy_indirect (struct bfd_link_info *info,
6746
                                  struct elf_link_hash_entry *dir,
6747
                                  struct elf_link_hash_entry *ind)
6748
{
6749
  struct elf_link_hash_table *htab;
6750
 
6751
  /* Copy down any references that we may have already seen to the
6752
     symbol which just became indirect.  */
6753
 
6754
  dir->ref_dynamic |= ind->ref_dynamic;
6755
  dir->ref_regular |= ind->ref_regular;
6756
  dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
6757
  dir->non_got_ref |= ind->non_got_ref;
6758
  dir->needs_plt |= ind->needs_plt;
6759
  dir->pointer_equality_needed |= ind->pointer_equality_needed;
6760
 
6761
  if (ind->root.type != bfd_link_hash_indirect)
6762
    return;
6763
 
6764
  /* Copy over the global and procedure linkage table refcount entries.
6765
     These may have been already set up by a check_relocs routine.  */
6766
  htab = elf_hash_table (info);
6767
  if (ind->got.refcount > htab->init_got_refcount.refcount)
6768
    {
6769
      if (dir->got.refcount < 0)
6770
        dir->got.refcount = 0;
6771
      dir->got.refcount += ind->got.refcount;
6772
      ind->got.refcount = htab->init_got_refcount.refcount;
6773
    }
6774
 
6775
  if (ind->plt.refcount > htab->init_plt_refcount.refcount)
6776
    {
6777
      if (dir->plt.refcount < 0)
6778
        dir->plt.refcount = 0;
6779
      dir->plt.refcount += ind->plt.refcount;
6780
      ind->plt.refcount = htab->init_plt_refcount.refcount;
6781
    }
6782
 
6783
  if (ind->dynindx != -1)
6784
    {
6785
      if (dir->dynindx != -1)
6786
        _bfd_elf_strtab_delref (htab->dynstr, dir->dynstr_index);
6787
      dir->dynindx = ind->dynindx;
6788
      dir->dynstr_index = ind->dynstr_index;
6789
      ind->dynindx = -1;
6790
      ind->dynstr_index = 0;
6791
    }
6792
}
6793
 
6794
void
6795
_bfd_elf_link_hash_hide_symbol (struct bfd_link_info *info,
6796
                                struct elf_link_hash_entry *h,
6797
                                bfd_boolean force_local)
6798
{
6799
  /* STT_GNU_IFUNC symbol must go through PLT.  */
6800
  if (h->type != STT_GNU_IFUNC)
6801
    {
6802
      h->plt = elf_hash_table (info)->init_plt_offset;
6803
      h->needs_plt = 0;
6804
    }
6805
  if (force_local)
6806
    {
6807
      h->forced_local = 1;
6808
      if (h->dynindx != -1)
6809
        {
6810
          h->dynindx = -1;
6811
          _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
6812
                                  h->dynstr_index);
6813
        }
6814
    }
6815
}
6816
 
6817
/* Initialize an ELF linker hash table.  */
6818
 
6819
bfd_boolean
6820
_bfd_elf_link_hash_table_init
6821
  (struct elf_link_hash_table *table,
6822
   bfd *abfd,
6823
   struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *,
6824
                                      struct bfd_hash_table *,
6825
                                      const char *),
6826
   unsigned int entsize,
6827
   enum elf_target_id target_id)
6828
{
6829
  bfd_boolean ret;
6830
  int can_refcount = get_elf_backend_data (abfd)->can_refcount;
6831
 
6832
  memset (table, 0, sizeof * table);
6833
  table->init_got_refcount.refcount = can_refcount - 1;
6834
  table->init_plt_refcount.refcount = can_refcount - 1;
6835
  table->init_got_offset.offset = -(bfd_vma) 1;
6836
  table->init_plt_offset.offset = -(bfd_vma) 1;
6837
  /* The first dynamic symbol is a dummy.  */
6838
  table->dynsymcount = 1;
6839
 
6840
  ret = _bfd_link_hash_table_init (&table->root, abfd, newfunc, entsize);
6841
 
6842
  table->root.type = bfd_link_elf_hash_table;
6843
  table->hash_table_id = target_id;
6844
 
6845
  return ret;
6846
}
6847
 
6848
/* Create an ELF linker hash table.  */
6849
 
6850
struct bfd_link_hash_table *
6851
_bfd_elf_link_hash_table_create (bfd *abfd)
6852
{
6853
  struct elf_link_hash_table *ret;
6854
  bfd_size_type amt = sizeof (struct elf_link_hash_table);
6855
 
6856
  ret = (struct elf_link_hash_table *) bfd_malloc (amt);
6857
  if (ret == NULL)
6858
    return NULL;
6859
 
6860
  if (! _bfd_elf_link_hash_table_init (ret, abfd, _bfd_elf_link_hash_newfunc,
6861
                                       sizeof (struct elf_link_hash_entry),
6862
                                       GENERIC_ELF_DATA))
6863
    {
6864
      free (ret);
6865
      return NULL;
6866
    }
6867
 
6868
  return &ret->root;
6869
}
6870
 
6871
/* This is a hook for the ELF emulation code in the generic linker to
6872
   tell the backend linker what file name to use for the DT_NEEDED
6873
   entry for a dynamic object.  */
6874
 
6875
void
6876
bfd_elf_set_dt_needed_name (bfd *abfd, const char *name)
6877
{
6878
  if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
6879
      && bfd_get_format (abfd) == bfd_object)
6880
    elf_dt_name (abfd) = name;
6881
}
6882
 
6883
int
6884
bfd_elf_get_dyn_lib_class (bfd *abfd)
6885
{
6886
  int lib_class;
6887
  if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
6888
      && bfd_get_format (abfd) == bfd_object)
6889
    lib_class = elf_dyn_lib_class (abfd);
6890
  else
6891
    lib_class = 0;
6892
  return lib_class;
6893
}
6894
 
6895
void
6896
bfd_elf_set_dyn_lib_class (bfd *abfd, enum dynamic_lib_link_class lib_class)
6897
{
6898
  if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
6899
      && bfd_get_format (abfd) == bfd_object)
6900
    elf_dyn_lib_class (abfd) = lib_class;
6901
}
6902
 
6903
/* Get the list of DT_NEEDED entries for a link.  This is a hook for
6904
   the linker ELF emulation code.  */
6905
 
6906
struct bfd_link_needed_list *
6907
bfd_elf_get_needed_list (bfd *abfd ATTRIBUTE_UNUSED,
6908
                         struct bfd_link_info *info)
6909
{
6910
  if (! is_elf_hash_table (info->hash))
6911
    return NULL;
6912
  return elf_hash_table (info)->needed;
6913
}
6914
 
6915
/* Get the list of DT_RPATH/DT_RUNPATH entries for a link.  This is a
6916
   hook for the linker ELF emulation code.  */
6917
 
6918
struct bfd_link_needed_list *
6919
bfd_elf_get_runpath_list (bfd *abfd ATTRIBUTE_UNUSED,
6920
                          struct bfd_link_info *info)
6921
{
6922
  if (! is_elf_hash_table (info->hash))
6923
    return NULL;
6924
  return elf_hash_table (info)->runpath;
6925
}
6926
 
6927
/* Get the name actually used for a dynamic object for a link.  This
6928
   is the SONAME entry if there is one.  Otherwise, it is the string
6929
   passed to bfd_elf_set_dt_needed_name, or it is the filename.  */
6930
 
6931
const char *
6932
bfd_elf_get_dt_soname (bfd *abfd)
6933
{
6934
  if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
6935
      && bfd_get_format (abfd) == bfd_object)
6936
    return elf_dt_name (abfd);
6937
  return NULL;
6938
}
6939
 
6940
/* Get the list of DT_NEEDED entries from a BFD.  This is a hook for
6941
   the ELF linker emulation code.  */
6942
 
6943
bfd_boolean
6944
bfd_elf_get_bfd_needed_list (bfd *abfd,
6945
                             struct bfd_link_needed_list **pneeded)
6946
{
6947
  asection *s;
6948
  bfd_byte *dynbuf = NULL;
6949
  unsigned int elfsec;
6950
  unsigned long shlink;
6951
  bfd_byte *extdyn, *extdynend;
6952
  size_t extdynsize;
6953
  void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
6954
 
6955
  *pneeded = NULL;
6956
 
6957
  if (bfd_get_flavour (abfd) != bfd_target_elf_flavour
6958
      || bfd_get_format (abfd) != bfd_object)
6959
    return TRUE;
6960
 
6961
  s = bfd_get_section_by_name (abfd, ".dynamic");
6962
  if (s == NULL || s->size == 0)
6963
    return TRUE;
6964
 
6965
  if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
6966
    goto error_return;
6967
 
6968
  elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
6969
  if (elfsec == SHN_BAD)
6970
    goto error_return;
6971
 
6972
  shlink = elf_elfsections (abfd)[elfsec]->sh_link;
6973
 
6974
  extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
6975
  swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
6976
 
6977
  extdyn = dynbuf;
6978
  extdynend = extdyn + s->size;
6979
  for (; extdyn < extdynend; extdyn += extdynsize)
6980
    {
6981
      Elf_Internal_Dyn dyn;
6982
 
6983
      (*swap_dyn_in) (abfd, extdyn, &dyn);
6984
 
6985
      if (dyn.d_tag == DT_NULL)
6986
        break;
6987
 
6988
      if (dyn.d_tag == DT_NEEDED)
6989
        {
6990
          const char *string;
6991
          struct bfd_link_needed_list *l;
6992
          unsigned int tagv = dyn.d_un.d_val;
6993
          bfd_size_type amt;
6994
 
6995
          string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
6996
          if (string == NULL)
6997
            goto error_return;
6998
 
6999
          amt = sizeof *l;
7000
          l = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
7001
          if (l == NULL)
7002
            goto error_return;
7003
 
7004
          l->by = abfd;
7005
          l->name = string;
7006
          l->next = *pneeded;
7007
          *pneeded = l;
7008
        }
7009
    }
7010
 
7011
  free (dynbuf);
7012
 
7013
  return TRUE;
7014
 
7015
 error_return:
7016
  if (dynbuf != NULL)
7017
    free (dynbuf);
7018
  return FALSE;
7019
}
7020
 
7021
struct elf_symbuf_symbol
7022
{
7023
  unsigned long st_name;        /* Symbol name, index in string tbl */
7024
  unsigned char st_info;        /* Type and binding attributes */
7025
  unsigned char st_other;       /* Visibilty, and target specific */
7026
};
7027
 
7028
struct elf_symbuf_head
7029
{
7030
  struct elf_symbuf_symbol *ssym;
7031
  bfd_size_type count;
7032
  unsigned int st_shndx;
7033
};
7034
 
7035
struct elf_symbol
7036
{
7037
  union
7038
    {
7039
      Elf_Internal_Sym *isym;
7040
      struct elf_symbuf_symbol *ssym;
7041
    } u;
7042
  const char *name;
7043
};
7044
 
7045
/* Sort references to symbols by ascending section number.  */
7046
 
7047
static int
7048
elf_sort_elf_symbol (const void *arg1, const void *arg2)
7049
{
7050
  const Elf_Internal_Sym *s1 = *(const Elf_Internal_Sym **) arg1;
7051
  const Elf_Internal_Sym *s2 = *(const Elf_Internal_Sym **) arg2;
7052
 
7053
  return s1->st_shndx - s2->st_shndx;
7054
}
7055
 
7056
static int
7057
elf_sym_name_compare (const void *arg1, const void *arg2)
7058
{
7059
  const struct elf_symbol *s1 = (const struct elf_symbol *) arg1;
7060
  const struct elf_symbol *s2 = (const struct elf_symbol *) arg2;
7061
  return strcmp (s1->name, s2->name);
7062
}
7063
 
7064
static struct elf_symbuf_head *
7065
elf_create_symbuf (bfd_size_type symcount, Elf_Internal_Sym *isymbuf)
7066
{
7067
  Elf_Internal_Sym **ind, **indbufend, **indbuf;
7068
  struct elf_symbuf_symbol *ssym;
7069
  struct elf_symbuf_head *ssymbuf, *ssymhead;
7070
  bfd_size_type i, shndx_count, total_size;
7071
 
7072
  indbuf = (Elf_Internal_Sym **) bfd_malloc2 (symcount, sizeof (*indbuf));
7073
  if (indbuf == NULL)
7074
    return NULL;
7075
 
7076
  for (ind = indbuf, i = 0; i < symcount; i++)
7077
    if (isymbuf[i].st_shndx != SHN_UNDEF)
7078
      *ind++ = &isymbuf[i];
7079
  indbufend = ind;
7080
 
7081
  qsort (indbuf, indbufend - indbuf, sizeof (Elf_Internal_Sym *),
7082
         elf_sort_elf_symbol);
7083
 
7084
  shndx_count = 0;
7085
  if (indbufend > indbuf)
7086
    for (ind = indbuf, shndx_count++; ind < indbufend - 1; ind++)
7087
      if (ind[0]->st_shndx != ind[1]->st_shndx)
7088
        shndx_count++;
7089
 
7090
  total_size = ((shndx_count + 1) * sizeof (*ssymbuf)
7091
                + (indbufend - indbuf) * sizeof (*ssym));
7092
  ssymbuf = (struct elf_symbuf_head *) bfd_malloc (total_size);
7093
  if (ssymbuf == NULL)
7094
    {
7095
      free (indbuf);
7096
      return NULL;
7097
    }
7098
 
7099
  ssym = (struct elf_symbuf_symbol *) (ssymbuf + shndx_count + 1);
7100
  ssymbuf->ssym = NULL;
7101
  ssymbuf->count = shndx_count;
7102
  ssymbuf->st_shndx = 0;
7103
  for (ssymhead = ssymbuf, ind = indbuf; ind < indbufend; ssym++, ind++)
7104
    {
7105
      if (ind == indbuf || ssymhead->st_shndx != (*ind)->st_shndx)
7106
        {
7107
          ssymhead++;
7108
          ssymhead->ssym = ssym;
7109
          ssymhead->count = 0;
7110
          ssymhead->st_shndx = (*ind)->st_shndx;
7111
        }
7112
      ssym->st_name = (*ind)->st_name;
7113
      ssym->st_info = (*ind)->st_info;
7114
      ssym->st_other = (*ind)->st_other;
7115
      ssymhead->count++;
7116
    }
7117
  BFD_ASSERT ((bfd_size_type) (ssymhead - ssymbuf) == shndx_count
7118
              && (((bfd_hostptr_t) ssym - (bfd_hostptr_t) ssymbuf)
7119
                  == total_size));
7120
 
7121
  free (indbuf);
7122
  return ssymbuf;
7123
}
7124
 
7125
/* Check if 2 sections define the same set of local and global
7126
   symbols.  */
7127
 
7128
static bfd_boolean
7129
bfd_elf_match_symbols_in_sections (asection *sec1, asection *sec2,
7130
                                   struct bfd_link_info *info)
7131
{
7132
  bfd *bfd1, *bfd2;
7133
  const struct elf_backend_data *bed1, *bed2;
7134
  Elf_Internal_Shdr *hdr1, *hdr2;
7135
  bfd_size_type symcount1, symcount2;
7136
  Elf_Internal_Sym *isymbuf1, *isymbuf2;
7137
  struct elf_symbuf_head *ssymbuf1, *ssymbuf2;
7138
  Elf_Internal_Sym *isym, *isymend;
7139
  struct elf_symbol *symtable1 = NULL, *symtable2 = NULL;
7140
  bfd_size_type count1, count2, i;
7141
  unsigned int shndx1, shndx2;
7142
  bfd_boolean result;
7143
 
7144
  bfd1 = sec1->owner;
7145
  bfd2 = sec2->owner;
7146
 
7147
  /* Both sections have to be in ELF.  */
7148
  if (bfd_get_flavour (bfd1) != bfd_target_elf_flavour
7149
      || bfd_get_flavour (bfd2) != bfd_target_elf_flavour)
7150
    return FALSE;
7151
 
7152
  if (elf_section_type (sec1) != elf_section_type (sec2))
7153
    return FALSE;
7154
 
7155
  shndx1 = _bfd_elf_section_from_bfd_section (bfd1, sec1);
7156
  shndx2 = _bfd_elf_section_from_bfd_section (bfd2, sec2);
7157
  if (shndx1 == SHN_BAD || shndx2 == SHN_BAD)
7158
    return FALSE;
7159
 
7160
  bed1 = get_elf_backend_data (bfd1);
7161
  bed2 = get_elf_backend_data (bfd2);
7162
  hdr1 = &elf_tdata (bfd1)->symtab_hdr;
7163
  symcount1 = hdr1->sh_size / bed1->s->sizeof_sym;
7164
  hdr2 = &elf_tdata (bfd2)->symtab_hdr;
7165
  symcount2 = hdr2->sh_size / bed2->s->sizeof_sym;
7166
 
7167
  if (symcount1 == 0 || symcount2 == 0)
7168
    return FALSE;
7169
 
7170
  result = FALSE;
7171
  isymbuf1 = NULL;
7172
  isymbuf2 = NULL;
7173
  ssymbuf1 = (struct elf_symbuf_head *) elf_tdata (bfd1)->symbuf;
7174
  ssymbuf2 = (struct elf_symbuf_head *) elf_tdata (bfd2)->symbuf;
7175
 
7176
  if (ssymbuf1 == NULL)
7177
    {
7178
      isymbuf1 = bfd_elf_get_elf_syms (bfd1, hdr1, symcount1, 0,
7179
                                       NULL, NULL, NULL);
7180
      if (isymbuf1 == NULL)
7181
        goto done;
7182
 
7183
      if (!info->reduce_memory_overheads)
7184
        elf_tdata (bfd1)->symbuf = ssymbuf1
7185
          = elf_create_symbuf (symcount1, isymbuf1);
7186
    }
7187
 
7188
  if (ssymbuf1 == NULL || ssymbuf2 == NULL)
7189
    {
7190
      isymbuf2 = bfd_elf_get_elf_syms (bfd2, hdr2, symcount2, 0,
7191
                                       NULL, NULL, NULL);
7192
      if (isymbuf2 == NULL)
7193
        goto done;
7194
 
7195
      if (ssymbuf1 != NULL && !info->reduce_memory_overheads)
7196
        elf_tdata (bfd2)->symbuf = ssymbuf2
7197
          = elf_create_symbuf (symcount2, isymbuf2);
7198
    }
7199
 
7200
  if (ssymbuf1 != NULL && ssymbuf2 != NULL)
7201
    {
7202
      /* Optimized faster version.  */
7203
      bfd_size_type lo, hi, mid;
7204
      struct elf_symbol *symp;
7205
      struct elf_symbuf_symbol *ssym, *ssymend;
7206
 
7207
      lo = 0;
7208
      hi = ssymbuf1->count;
7209
      ssymbuf1++;
7210
      count1 = 0;
7211
      while (lo < hi)
7212
        {
7213
          mid = (lo + hi) / 2;
7214
          if (shndx1 < ssymbuf1[mid].st_shndx)
7215
            hi = mid;
7216
          else if (shndx1 > ssymbuf1[mid].st_shndx)
7217
            lo = mid + 1;
7218
          else
7219
            {
7220
              count1 = ssymbuf1[mid].count;
7221
              ssymbuf1 += mid;
7222
              break;
7223
            }
7224
        }
7225
 
7226
      lo = 0;
7227
      hi = ssymbuf2->count;
7228
      ssymbuf2++;
7229
      count2 = 0;
7230
      while (lo < hi)
7231
        {
7232
          mid = (lo + hi) / 2;
7233
          if (shndx2 < ssymbuf2[mid].st_shndx)
7234
            hi = mid;
7235
          else if (shndx2 > ssymbuf2[mid].st_shndx)
7236
            lo = mid + 1;
7237
          else
7238
            {
7239
              count2 = ssymbuf2[mid].count;
7240
              ssymbuf2 += mid;
7241
              break;
7242
            }
7243
        }
7244
 
7245
      if (count1 == 0 || count2 == 0 || count1 != count2)
7246
        goto done;
7247
 
7248
      symtable1 = (struct elf_symbol *)
7249
          bfd_malloc (count1 * sizeof (struct elf_symbol));
7250
      symtable2 = (struct elf_symbol *)
7251
          bfd_malloc (count2 * sizeof (struct elf_symbol));
7252
      if (symtable1 == NULL || symtable2 == NULL)
7253
        goto done;
7254
 
7255
      symp = symtable1;
7256
      for (ssym = ssymbuf1->ssym, ssymend = ssym + count1;
7257
           ssym < ssymend; ssym++, symp++)
7258
        {
7259
          symp->u.ssym = ssym;
7260
          symp->name = bfd_elf_string_from_elf_section (bfd1,
7261
                                                        hdr1->sh_link,
7262
                                                        ssym->st_name);
7263
        }
7264
 
7265
      symp = symtable2;
7266
      for (ssym = ssymbuf2->ssym, ssymend = ssym + count2;
7267
           ssym < ssymend; ssym++, symp++)
7268
        {
7269
          symp->u.ssym = ssym;
7270
          symp->name = bfd_elf_string_from_elf_section (bfd2,
7271
                                                        hdr2->sh_link,
7272
                                                        ssym->st_name);
7273
        }
7274
 
7275
      /* Sort symbol by name.  */
7276
      qsort (symtable1, count1, sizeof (struct elf_symbol),
7277
             elf_sym_name_compare);
7278
      qsort (symtable2, count1, sizeof (struct elf_symbol),
7279
             elf_sym_name_compare);
7280
 
7281
      for (i = 0; i < count1; i++)
7282
        /* Two symbols must have the same binding, type and name.  */
7283
        if (symtable1 [i].u.ssym->st_info != symtable2 [i].u.ssym->st_info
7284
            || symtable1 [i].u.ssym->st_other != symtable2 [i].u.ssym->st_other
7285
            || strcmp (symtable1 [i].name, symtable2 [i].name) != 0)
7286
          goto done;
7287
 
7288
      result = TRUE;
7289
      goto done;
7290
    }
7291
 
7292
  symtable1 = (struct elf_symbol *)
7293
      bfd_malloc (symcount1 * sizeof (struct elf_symbol));
7294
  symtable2 = (struct elf_symbol *)
7295
      bfd_malloc (symcount2 * sizeof (struct elf_symbol));
7296
  if (symtable1 == NULL || symtable2 == NULL)
7297
    goto done;
7298
 
7299
  /* Count definitions in the section.  */
7300
  count1 = 0;
7301
  for (isym = isymbuf1, isymend = isym + symcount1; isym < isymend; isym++)
7302
    if (isym->st_shndx == shndx1)
7303
      symtable1[count1++].u.isym = isym;
7304
 
7305
  count2 = 0;
7306
  for (isym = isymbuf2, isymend = isym + symcount2; isym < isymend; isym++)
7307
    if (isym->st_shndx == shndx2)
7308
      symtable2[count2++].u.isym = isym;
7309
 
7310
  if (count1 == 0 || count2 == 0 || count1 != count2)
7311
    goto done;
7312
 
7313
  for (i = 0; i < count1; i++)
7314
    symtable1[i].name
7315
      = bfd_elf_string_from_elf_section (bfd1, hdr1->sh_link,
7316
                                         symtable1[i].u.isym->st_name);
7317
 
7318
  for (i = 0; i < count2; i++)
7319
    symtable2[i].name
7320
      = bfd_elf_string_from_elf_section (bfd2, hdr2->sh_link,
7321
                                         symtable2[i].u.isym->st_name);
7322
 
7323
  /* Sort symbol by name.  */
7324
  qsort (symtable1, count1, sizeof (struct elf_symbol),
7325
         elf_sym_name_compare);
7326
  qsort (symtable2, count1, sizeof (struct elf_symbol),
7327
         elf_sym_name_compare);
7328
 
7329
  for (i = 0; i < count1; i++)
7330
    /* Two symbols must have the same binding, type and name.  */
7331
    if (symtable1 [i].u.isym->st_info != symtable2 [i].u.isym->st_info
7332
        || symtable1 [i].u.isym->st_other != symtable2 [i].u.isym->st_other
7333
        || strcmp (symtable1 [i].name, symtable2 [i].name) != 0)
7334
      goto done;
7335
 
7336
  result = TRUE;
7337
 
7338
done:
7339
  if (symtable1)
7340
    free (symtable1);
7341
  if (symtable2)
7342
    free (symtable2);
7343
  if (isymbuf1)
7344
    free (isymbuf1);
7345
  if (isymbuf2)
7346
    free (isymbuf2);
7347
 
7348
  return result;
7349
}
7350
 
7351
/* Return TRUE if 2 section types are compatible.  */
7352
 
7353
bfd_boolean
7354
_bfd_elf_match_sections_by_type (bfd *abfd, const asection *asec,
7355
                                 bfd *bbfd, const asection *bsec)
7356
{
7357
  if (asec == NULL
7358
      || bsec == NULL
7359
      || abfd->xvec->flavour != bfd_target_elf_flavour
7360
      || bbfd->xvec->flavour != bfd_target_elf_flavour)
7361
    return TRUE;
7362
 
7363
  return elf_section_type (asec) == elf_section_type (bsec);
7364
}
7365
 
7366
/* Final phase of ELF linker.  */
7367
 
7368
/* A structure we use to avoid passing large numbers of arguments.  */
7369
 
7370
struct elf_final_link_info
7371
{
7372
  /* General link information.  */
7373
  struct bfd_link_info *info;
7374
  /* Output BFD.  */
7375
  bfd *output_bfd;
7376
  /* Symbol string table.  */
7377
  struct bfd_strtab_hash *symstrtab;
7378
  /* .dynsym section.  */
7379
  asection *dynsym_sec;
7380
  /* .hash section.  */
7381
  asection *hash_sec;
7382
  /* symbol version section (.gnu.version).  */
7383
  asection *symver_sec;
7384
  /* Buffer large enough to hold contents of any section.  */
7385
  bfd_byte *contents;
7386
  /* Buffer large enough to hold external relocs of any section.  */
7387
  void *external_relocs;
7388
  /* Buffer large enough to hold internal relocs of any section.  */
7389
  Elf_Internal_Rela *internal_relocs;
7390
  /* Buffer large enough to hold external local symbols of any input
7391
     BFD.  */
7392
  bfd_byte *external_syms;
7393
  /* And a buffer for symbol section indices.  */
7394
  Elf_External_Sym_Shndx *locsym_shndx;
7395
  /* Buffer large enough to hold internal local symbols of any input
7396
     BFD.  */
7397
  Elf_Internal_Sym *internal_syms;
7398
  /* Array large enough to hold a symbol index for each local symbol
7399
     of any input BFD.  */
7400
  long *indices;
7401
  /* Array large enough to hold a section pointer for each local
7402
     symbol of any input BFD.  */
7403
  asection **sections;
7404
  /* Buffer to hold swapped out symbols.  */
7405
  bfd_byte *symbuf;
7406
  /* And one for symbol section indices.  */
7407
  Elf_External_Sym_Shndx *symshndxbuf;
7408
  /* Number of swapped out symbols in buffer.  */
7409
  size_t symbuf_count;
7410
  /* Number of symbols which fit in symbuf.  */
7411
  size_t symbuf_size;
7412
  /* And same for symshndxbuf.  */
7413
  size_t shndxbuf_size;
7414
};
7415
 
7416
/* This struct is used to pass information to elf_link_output_extsym.  */
7417
 
7418
struct elf_outext_info
7419
{
7420
  bfd_boolean failed;
7421
  bfd_boolean localsyms;
7422
  struct elf_final_link_info *finfo;
7423
};
7424
 
7425
 
7426
/* Support for evaluating a complex relocation.
7427
 
7428
   Complex relocations are generalized, self-describing relocations.  The
7429
   implementation of them consists of two parts: complex symbols, and the
7430
   relocations themselves.
7431
 
7432
   The relocations are use a reserved elf-wide relocation type code (R_RELC
7433
   external / BFD_RELOC_RELC internal) and an encoding of relocation field
7434
   information (start bit, end bit, word width, etc) into the addend.  This
7435
   information is extracted from CGEN-generated operand tables within gas.
7436
 
7437
   Complex symbols are mangled symbols (BSF_RELC external / STT_RELC
7438
   internal) representing prefix-notation expressions, including but not
7439
   limited to those sorts of expressions normally encoded as addends in the
7440
   addend field.  The symbol mangling format is:
7441
 
7442
   <node> := <literal>
7443
          |  <unary-operator> ':' <node>
7444
          |  <binary-operator> ':' <node> ':' <node>
7445
          ;
7446
 
7447
   <literal> := 's' <digits=N> ':' <N character symbol name>
7448
             |  'S' <digits=N> ':' <N character section name>
7449
             |  '#' <hexdigits>
7450
             ;
7451
 
7452
   <binary-operator> := as in C
7453
   <unary-operator> := as in C, plus "0-" for unambiguous negation.  */
7454
 
7455
static void
7456
set_symbol_value (bfd *bfd_with_globals,
7457
                  Elf_Internal_Sym *isymbuf,
7458
                  size_t locsymcount,
7459
                  size_t symidx,
7460
                  bfd_vma val)
7461
{
7462
  struct elf_link_hash_entry **sym_hashes;
7463
  struct elf_link_hash_entry *h;
7464
  size_t extsymoff = locsymcount;
7465
 
7466
  if (symidx < locsymcount)
7467
    {
7468
      Elf_Internal_Sym *sym;
7469
 
7470
      sym = isymbuf + symidx;
7471
      if (ELF_ST_BIND (sym->st_info) == STB_LOCAL)
7472
        {
7473
          /* It is a local symbol: move it to the
7474
             "absolute" section and give it a value.  */
7475
          sym->st_shndx = SHN_ABS;
7476
          sym->st_value = val;
7477
          return;
7478
        }
7479
      BFD_ASSERT (elf_bad_symtab (bfd_with_globals));
7480
      extsymoff = 0;
7481
    }
7482
 
7483
  /* It is a global symbol: set its link type
7484
     to "defined" and give it a value.  */
7485
 
7486
  sym_hashes = elf_sym_hashes (bfd_with_globals);
7487
  h = sym_hashes [symidx - extsymoff];
7488
  while (h->root.type == bfd_link_hash_indirect
7489
         || h->root.type == bfd_link_hash_warning)
7490
    h = (struct elf_link_hash_entry *) h->root.u.i.link;
7491
  h->root.type = bfd_link_hash_defined;
7492
  h->root.u.def.value = val;
7493
  h->root.u.def.section = bfd_abs_section_ptr;
7494
}
7495
 
7496
static bfd_boolean
7497
resolve_symbol (const char *name,
7498
                bfd *input_bfd,
7499
                struct elf_final_link_info *finfo,
7500
                bfd_vma *result,
7501
                Elf_Internal_Sym *isymbuf,
7502
                size_t locsymcount)
7503
{
7504
  Elf_Internal_Sym *sym;
7505
  struct bfd_link_hash_entry *global_entry;
7506
  const char *candidate = NULL;
7507
  Elf_Internal_Shdr *symtab_hdr;
7508
  size_t i;
7509
 
7510
  symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
7511
 
7512
  for (i = 0; i < locsymcount; ++ i)
7513
    {
7514
      sym = isymbuf + i;
7515
 
7516
      if (ELF_ST_BIND (sym->st_info) != STB_LOCAL)
7517
        continue;
7518
 
7519
      candidate = bfd_elf_string_from_elf_section (input_bfd,
7520
                                                   symtab_hdr->sh_link,
7521
                                                   sym->st_name);
7522
#ifdef DEBUG
7523
      printf ("Comparing string: '%s' vs. '%s' = 0x%lx\n",
7524
              name, candidate, (unsigned long) sym->st_value);
7525
#endif
7526
      if (candidate && strcmp (candidate, name) == 0)
7527
        {
7528
          asection *sec = finfo->sections [i];
7529
 
7530
          *result = _bfd_elf_rel_local_sym (input_bfd, sym, &sec, 0);
7531
          *result += sec->output_offset + sec->output_section->vma;
7532
#ifdef DEBUG
7533
          printf ("Found symbol with value %8.8lx\n",
7534
                  (unsigned long) *result);
7535
#endif
7536
          return TRUE;
7537
        }
7538
    }
7539
 
7540
  /* Hmm, haven't found it yet. perhaps it is a global.  */
7541
  global_entry = bfd_link_hash_lookup (finfo->info->hash, name,
7542
                                       FALSE, FALSE, TRUE);
7543
  if (!global_entry)
7544
    return FALSE;
7545
 
7546
  if (global_entry->type == bfd_link_hash_defined
7547
      || global_entry->type == bfd_link_hash_defweak)
7548
    {
7549
      *result = (global_entry->u.def.value
7550
                 + global_entry->u.def.section->output_section->vma
7551
                 + global_entry->u.def.section->output_offset);
7552
#ifdef DEBUG
7553
      printf ("Found GLOBAL symbol '%s' with value %8.8lx\n",
7554
              global_entry->root.string, (unsigned long) *result);
7555
#endif
7556
      return TRUE;
7557
    }
7558
 
7559
  return FALSE;
7560
}
7561
 
7562
static bfd_boolean
7563
resolve_section (const char *name,
7564
                 asection *sections,
7565
                 bfd_vma *result)
7566
{
7567
  asection *curr;
7568
  unsigned int len;
7569
 
7570
  for (curr = sections; curr; curr = curr->next)
7571
    if (strcmp (curr->name, name) == 0)
7572
      {
7573
        *result = curr->vma;
7574
        return TRUE;
7575
      }
7576
 
7577
  /* Hmm. still haven't found it. try pseudo-section names.  */
7578
  for (curr = sections; curr; curr = curr->next)
7579
    {
7580
      len = strlen (curr->name);
7581
      if (len > strlen (name))
7582
        continue;
7583
 
7584
      if (strncmp (curr->name, name, len) == 0)
7585
        {
7586
          if (strncmp (".end", name + len, 4) == 0)
7587
            {
7588
              *result = curr->vma + curr->size;
7589
              return TRUE;
7590
            }
7591
 
7592
          /* Insert more pseudo-section names here, if you like.  */
7593
        }
7594
    }
7595
 
7596
  return FALSE;
7597
}
7598
 
7599
static void
7600
undefined_reference (const char *reftype, const char *name)
7601
{
7602
  _bfd_error_handler (_("undefined %s reference in complex symbol: %s"),
7603
                      reftype, name);
7604
}
7605
 
7606
static bfd_boolean
7607
eval_symbol (bfd_vma *result,
7608
             const char **symp,
7609
             bfd *input_bfd,
7610
             struct elf_final_link_info *finfo,
7611
             bfd_vma dot,
7612
             Elf_Internal_Sym *isymbuf,
7613
             size_t locsymcount,
7614
             int signed_p)
7615
{
7616
  size_t len;
7617
  size_t symlen;
7618
  bfd_vma a;
7619
  bfd_vma b;
7620
  char symbuf[4096];
7621
  const char *sym = *symp;
7622
  const char *symend;
7623
  bfd_boolean symbol_is_section = FALSE;
7624
 
7625
  len = strlen (sym);
7626
  symend = sym + len;
7627
 
7628
  if (len < 1 || len > sizeof (symbuf))
7629
    {
7630
      bfd_set_error (bfd_error_invalid_operation);
7631
      return FALSE;
7632
    }
7633
 
7634
  switch (* sym)
7635
    {
7636
    case '.':
7637
      *result = dot;
7638
      *symp = sym + 1;
7639
      return TRUE;
7640
 
7641
    case '#':
7642
      ++sym;
7643
      *result = strtoul (sym, (char **) symp, 16);
7644
      return TRUE;
7645
 
7646
    case 'S':
7647
      symbol_is_section = TRUE;
7648
    case 's':
7649
      ++sym;
7650
      symlen = strtol (sym, (char **) symp, 10);
7651
      sym = *symp + 1; /* Skip the trailing ':'.  */
7652
 
7653
      if (symend < sym || symlen + 1 > sizeof (symbuf))
7654
        {
7655
          bfd_set_error (bfd_error_invalid_operation);
7656
          return FALSE;
7657
        }
7658
 
7659
      memcpy (symbuf, sym, symlen);
7660
      symbuf[symlen] = '\0';
7661
      *symp = sym + symlen;
7662
 
7663
      /* Is it always possible, with complex symbols, that gas "mis-guessed"
7664
         the symbol as a section, or vice-versa. so we're pretty liberal in our
7665
         interpretation here; section means "try section first", not "must be a
7666
         section", and likewise with symbol.  */
7667
 
7668
      if (symbol_is_section)
7669
        {
7670
          if (!resolve_section (symbuf, finfo->output_bfd->sections, result)
7671
              && !resolve_symbol (symbuf, input_bfd, finfo, result,
7672
                                  isymbuf, locsymcount))
7673
            {
7674
              undefined_reference ("section", symbuf);
7675
              return FALSE;
7676
            }
7677
        }
7678
      else
7679
        {
7680
          if (!resolve_symbol (symbuf, input_bfd, finfo, result,
7681
                               isymbuf, locsymcount)
7682
              && !resolve_section (symbuf, finfo->output_bfd->sections,
7683
                                   result))
7684
            {
7685
              undefined_reference ("symbol", symbuf);
7686
              return FALSE;
7687
            }
7688
        }
7689
 
7690
      return TRUE;
7691
 
7692
      /* All that remains are operators.  */
7693
 
7694
#define UNARY_OP(op)                                            \
7695
  if (strncmp (sym, #op, strlen (#op)) == 0)                    \
7696
    {                                                           \
7697
      sym += strlen (#op);                                      \
7698
      if (*sym == ':')                                          \
7699
        ++sym;                                                  \
7700
      *symp = sym;                                              \
7701
      if (!eval_symbol (&a, symp, input_bfd, finfo, dot,        \
7702
                        isymbuf, locsymcount, signed_p))        \
7703
        return FALSE;                                           \
7704
      if (signed_p)                                             \
7705
        *result = op ((bfd_signed_vma) a);                      \
7706
      else                                                      \
7707
        *result = op a;                                         \
7708
      return TRUE;                                              \
7709
    }
7710
 
7711
#define BINARY_OP(op)                                           \
7712
  if (strncmp (sym, #op, strlen (#op)) == 0)                    \
7713
    {                                                           \
7714
      sym += strlen (#op);                                      \
7715
      if (*sym == ':')                                          \
7716
        ++sym;                                                  \
7717
      *symp = sym;                                              \
7718
      if (!eval_symbol (&a, symp, input_bfd, finfo, dot,        \
7719
                        isymbuf, locsymcount, signed_p))        \
7720
        return FALSE;                                           \
7721
      ++*symp;                                                  \
7722
      if (!eval_symbol (&b, symp, input_bfd, finfo, dot,        \
7723
                        isymbuf, locsymcount, signed_p))        \
7724
        return FALSE;                                           \
7725
      if (signed_p)                                             \
7726
        *result = ((bfd_signed_vma) a) op ((bfd_signed_vma) b); \
7727
      else                                                      \
7728
        *result = a op b;                                       \
7729
      return TRUE;                                              \
7730
    }
7731
 
7732
    default:
7733
      UNARY_OP  (0-);
7734
      BINARY_OP (<<);
7735
      BINARY_OP (>>);
7736
      BINARY_OP (==);
7737
      BINARY_OP (!=);
7738
      BINARY_OP (<=);
7739
      BINARY_OP (>=);
7740
      BINARY_OP (&&);
7741
      BINARY_OP (||);
7742
      UNARY_OP  (~);
7743
      UNARY_OP  (!);
7744
      BINARY_OP (*);
7745
      BINARY_OP (/);
7746
      BINARY_OP (%);
7747
      BINARY_OP (^);
7748
      BINARY_OP (|);
7749
      BINARY_OP (&);
7750
      BINARY_OP (+);
7751
      BINARY_OP (-);
7752
      BINARY_OP (<);
7753
      BINARY_OP (>);
7754
#undef UNARY_OP
7755
#undef BINARY_OP
7756
      _bfd_error_handler (_("unknown operator '%c' in complex symbol"), * sym);
7757
      bfd_set_error (bfd_error_invalid_operation);
7758
      return FALSE;
7759
    }
7760
}
7761
 
7762
static void
7763
put_value (bfd_vma size,
7764
           unsigned long chunksz,
7765
           bfd *input_bfd,
7766
           bfd_vma x,
7767
           bfd_byte *location)
7768
{
7769
  location += (size - chunksz);
7770
 
7771
  for (; size; size -= chunksz, location -= chunksz, x >>= (chunksz * 8))
7772
    {
7773
      switch (chunksz)
7774
        {
7775
        default:
7776
        case 0:
7777
          abort ();
7778
        case 1:
7779
          bfd_put_8 (input_bfd, x, location);
7780
          break;
7781
        case 2:
7782
          bfd_put_16 (input_bfd, x, location);
7783
          break;
7784
        case 4:
7785
          bfd_put_32 (input_bfd, x, location);
7786
          break;
7787
        case 8:
7788
#ifdef BFD64
7789
          bfd_put_64 (input_bfd, x, location);
7790
#else
7791
          abort ();
7792
#endif
7793
          break;
7794
        }
7795
    }
7796
}
7797
 
7798
static bfd_vma
7799
get_value (bfd_vma size,
7800
           unsigned long chunksz,
7801
           bfd *input_bfd,
7802
           bfd_byte *location)
7803
{
7804
  bfd_vma x = 0;
7805
 
7806
  for (; size; size -= chunksz, location += chunksz)
7807
    {
7808
      switch (chunksz)
7809
        {
7810
        default:
7811
        case 0:
7812
          abort ();
7813
        case 1:
7814
          x = (x << (8 * chunksz)) | bfd_get_8 (input_bfd, location);
7815
          break;
7816
        case 2:
7817
          x = (x << (8 * chunksz)) | bfd_get_16 (input_bfd, location);
7818
          break;
7819
        case 4:
7820
          x = (x << (8 * chunksz)) | bfd_get_32 (input_bfd, location);
7821
          break;
7822
        case 8:
7823
#ifdef BFD64
7824
          x = (x << (8 * chunksz)) | bfd_get_64 (input_bfd, location);
7825
#else
7826
          abort ();
7827
#endif
7828
          break;
7829
        }
7830
    }
7831
  return x;
7832
}
7833
 
7834
static void
7835
decode_complex_addend (unsigned long *start,   /* in bits */
7836
                       unsigned long *oplen,   /* in bits */
7837
                       unsigned long *len,     /* in bits */
7838
                       unsigned long *wordsz,  /* in bytes */
7839
                       unsigned long *chunksz, /* in bytes */
7840
                       unsigned long *lsb0_p,
7841
                       unsigned long *signed_p,
7842
                       unsigned long *trunc_p,
7843
                       unsigned long encoded)
7844
{
7845
  * start     =  encoded        & 0x3F;
7846
  * len       = (encoded >>  6) & 0x3F;
7847
  * oplen     = (encoded >> 12) & 0x3F;
7848
  * wordsz    = (encoded >> 18) & 0xF;
7849
  * chunksz   = (encoded >> 22) & 0xF;
7850
  * lsb0_p    = (encoded >> 27) & 1;
7851
  * signed_p  = (encoded >> 28) & 1;
7852
  * trunc_p   = (encoded >> 29) & 1;
7853
}
7854
 
7855
bfd_reloc_status_type
7856
bfd_elf_perform_complex_relocation (bfd *input_bfd,
7857
                                    asection *input_section ATTRIBUTE_UNUSED,
7858
                                    bfd_byte *contents,
7859
                                    Elf_Internal_Rela *rel,
7860
                                    bfd_vma relocation)
7861
{
7862
  bfd_vma shift, x, mask;
7863
  unsigned long start, oplen, len, wordsz, chunksz, lsb0_p, signed_p, trunc_p;
7864
  bfd_reloc_status_type r;
7865
 
7866
  /*  Perform this reloc, since it is complex.
7867
      (this is not to say that it necessarily refers to a complex
7868
      symbol; merely that it is a self-describing CGEN based reloc.
7869
      i.e. the addend has the complete reloc information (bit start, end,
7870
      word size, etc) encoded within it.).  */
7871
 
7872
  decode_complex_addend (&start, &oplen, &len, &wordsz,
7873
                         &chunksz, &lsb0_p, &signed_p,
7874
                         &trunc_p, rel->r_addend);
7875
 
7876
  mask = (((1L << (len - 1)) - 1) << 1) | 1;
7877
 
7878
  if (lsb0_p)
7879
    shift = (start + 1) - len;
7880
  else
7881
    shift = (8 * wordsz) - (start + len);
7882
 
7883
  /* FIXME: octets_per_byte.  */
7884
  x = get_value (wordsz, chunksz, input_bfd, contents + rel->r_offset);
7885
 
7886
#ifdef DEBUG
7887
  printf ("Doing complex reloc: "
7888
          "lsb0? %ld, signed? %ld, trunc? %ld, wordsz %ld, "
7889
          "chunksz %ld, start %ld, len %ld, oplen %ld\n"
7890
          "    dest: %8.8lx, mask: %8.8lx, reloc: %8.8lx\n",
7891
          lsb0_p, signed_p, trunc_p, wordsz, chunksz, start, len,
7892
          oplen, (unsigned long) x, (unsigned long) mask,
7893
          (unsigned long) relocation);
7894
#endif
7895
 
7896
  r = bfd_reloc_ok;
7897
  if (! trunc_p)
7898
    /* Now do an overflow check.  */
7899
    r = bfd_check_overflow ((signed_p
7900
                             ? complain_overflow_signed
7901
                             : complain_overflow_unsigned),
7902
                            len, 0, (8 * wordsz),
7903
                            relocation);
7904
 
7905
  /* Do the deed.  */
7906
  x = (x & ~(mask << shift)) | ((relocation & mask) << shift);
7907
 
7908
#ifdef DEBUG
7909
  printf ("           relocation: %8.8lx\n"
7910
          "         shifted mask: %8.8lx\n"
7911
          " shifted/masked reloc: %8.8lx\n"
7912
          "               result: %8.8lx\n",
7913
          (unsigned long) relocation, (unsigned long) (mask << shift),
7914
          (unsigned long) ((relocation & mask) << shift), (unsigned long) x);
7915
#endif
7916
  /* FIXME: octets_per_byte.  */
7917
  put_value (wordsz, chunksz, input_bfd, x, contents + rel->r_offset);
7918
  return r;
7919
}
7920
 
7921
/* When performing a relocatable link, the input relocations are
7922
   preserved.  But, if they reference global symbols, the indices
7923
   referenced must be updated.  Update all the relocations found in
7924
   RELDATA.  */
7925
 
7926
static void
7927
elf_link_adjust_relocs (bfd *abfd,
7928
                        struct bfd_elf_section_reloc_data *reldata)
7929
{
7930
  unsigned int i;
7931
  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7932
  bfd_byte *erela;
7933
  void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *);
7934
  void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
7935
  bfd_vma r_type_mask;
7936
  int r_sym_shift;
7937
  unsigned int count = reldata->count;
7938
  struct elf_link_hash_entry **rel_hash = reldata->hashes;
7939
 
7940
  if (reldata->hdr->sh_entsize == bed->s->sizeof_rel)
7941
    {
7942
      swap_in = bed->s->swap_reloc_in;
7943
      swap_out = bed->s->swap_reloc_out;
7944
    }
7945
  else if (reldata->hdr->sh_entsize == bed->s->sizeof_rela)
7946
    {
7947
      swap_in = bed->s->swap_reloca_in;
7948
      swap_out = bed->s->swap_reloca_out;
7949
    }
7950
  else
7951
    abort ();
7952
 
7953
  if (bed->s->int_rels_per_ext_rel > MAX_INT_RELS_PER_EXT_REL)
7954
    abort ();
7955
 
7956
  if (bed->s->arch_size == 32)
7957
    {
7958
      r_type_mask = 0xff;
7959
      r_sym_shift = 8;
7960
    }
7961
  else
7962
    {
7963
      r_type_mask = 0xffffffff;
7964
      r_sym_shift = 32;
7965
    }
7966
 
7967
  erela = reldata->hdr->contents;
7968
  for (i = 0; i < count; i++, rel_hash++, erela += reldata->hdr->sh_entsize)
7969
    {
7970
      Elf_Internal_Rela irela[MAX_INT_RELS_PER_EXT_REL];
7971
      unsigned int j;
7972
 
7973
      if (*rel_hash == NULL)
7974
        continue;
7975
 
7976
      BFD_ASSERT ((*rel_hash)->indx >= 0);
7977
 
7978
      (*swap_in) (abfd, erela, irela);
7979
      for (j = 0; j < bed->s->int_rels_per_ext_rel; j++)
7980
        irela[j].r_info = ((bfd_vma) (*rel_hash)->indx << r_sym_shift
7981
                           | (irela[j].r_info & r_type_mask));
7982
      (*swap_out) (abfd, irela, erela);
7983
    }
7984
}
7985
 
7986
struct elf_link_sort_rela
7987
{
7988
  union {
7989
    bfd_vma offset;
7990
    bfd_vma sym_mask;
7991
  } u;
7992
  enum elf_reloc_type_class type;
7993
  /* We use this as an array of size int_rels_per_ext_rel.  */
7994
  Elf_Internal_Rela rela[1];
7995
};
7996
 
7997
static int
7998
elf_link_sort_cmp1 (const void *A, const void *B)
7999
{
8000
  const struct elf_link_sort_rela *a = (const struct elf_link_sort_rela *) A;
8001
  const struct elf_link_sort_rela *b = (const struct elf_link_sort_rela *) B;
8002
  int relativea, relativeb;
8003
 
8004
  relativea = a->type == reloc_class_relative;
8005
  relativeb = b->type == reloc_class_relative;
8006
 
8007
  if (relativea < relativeb)
8008
    return 1;
8009
  if (relativea > relativeb)
8010
    return -1;
8011
  if ((a->rela->r_info & a->u.sym_mask) < (b->rela->r_info & b->u.sym_mask))
8012
    return -1;
8013
  if ((a->rela->r_info & a->u.sym_mask) > (b->rela->r_info & b->u.sym_mask))
8014
    return 1;
8015
  if (a->rela->r_offset < b->rela->r_offset)
8016
    return -1;
8017
  if (a->rela->r_offset > b->rela->r_offset)
8018
    return 1;
8019
  return 0;
8020
}
8021
 
8022
static int
8023
elf_link_sort_cmp2 (const void *A, const void *B)
8024
{
8025
  const struct elf_link_sort_rela *a = (const struct elf_link_sort_rela *) A;
8026
  const struct elf_link_sort_rela *b = (const struct elf_link_sort_rela *) B;
8027
  int copya, copyb;
8028
 
8029
  if (a->u.offset < b->u.offset)
8030
    return -1;
8031
  if (a->u.offset > b->u.offset)
8032
    return 1;
8033
  copya = (a->type == reloc_class_copy) * 2 + (a->type == reloc_class_plt);
8034
  copyb = (b->type == reloc_class_copy) * 2 + (b->type == reloc_class_plt);
8035
  if (copya < copyb)
8036
    return -1;
8037
  if (copya > copyb)
8038
    return 1;
8039
  if (a->rela->r_offset < b->rela->r_offset)
8040
    return -1;
8041
  if (a->rela->r_offset > b->rela->r_offset)
8042
    return 1;
8043
  return 0;
8044
}
8045
 
8046
static size_t
8047
elf_link_sort_relocs (bfd *abfd, struct bfd_link_info *info, asection **psec)
8048
{
8049
  asection *dynamic_relocs;
8050
  asection *rela_dyn;
8051
  asection *rel_dyn;
8052
  bfd_size_type count, size;
8053
  size_t i, ret, sort_elt, ext_size;
8054
  bfd_byte *sort, *s_non_relative, *p;
8055
  struct elf_link_sort_rela *sq;
8056
  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8057
  int i2e = bed->s->int_rels_per_ext_rel;
8058
  void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *);
8059
  void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
8060
  struct bfd_link_order *lo;
8061
  bfd_vma r_sym_mask;
8062
  bfd_boolean use_rela;
8063
 
8064
  /* Find a dynamic reloc section.  */
8065
  rela_dyn = bfd_get_section_by_name (abfd, ".rela.dyn");
8066
  rel_dyn  = bfd_get_section_by_name (abfd, ".rel.dyn");
8067
  if (rela_dyn != NULL && rela_dyn->size > 0
8068
      && rel_dyn != NULL && rel_dyn->size > 0)
8069
    {
8070
      bfd_boolean use_rela_initialised = FALSE;
8071
 
8072
      /* This is just here to stop gcc from complaining.
8073
         It's initialization checking code is not perfect.  */
8074
      use_rela = TRUE;
8075
 
8076
      /* Both sections are present.  Examine the sizes
8077
         of the indirect sections to help us choose.  */
8078
      for (lo = rela_dyn->map_head.link_order; lo != NULL; lo = lo->next)
8079
        if (lo->type == bfd_indirect_link_order)
8080
          {
8081
            asection *o = lo->u.indirect.section;
8082
 
8083
            if ((o->size % bed->s->sizeof_rela) == 0)
8084
              {
8085
                if ((o->size % bed->s->sizeof_rel) == 0)
8086
                  /* Section size is divisible by both rel and rela sizes.
8087
                     It is of no help to us.  */
8088
                  ;
8089
                else
8090
                  {
8091
                    /* Section size is only divisible by rela.  */
8092
                    if (use_rela_initialised && (use_rela == FALSE))
8093
                      {
8094
                        _bfd_error_handler
8095
                          (_("%B: Unable to sort relocs - they are in more than one size"), abfd);
8096
                        bfd_set_error (bfd_error_invalid_operation);
8097
                        return 0;
8098
                      }
8099
                    else
8100
                      {
8101
                        use_rela = TRUE;
8102
                        use_rela_initialised = TRUE;
8103
                      }
8104
                  }
8105
              }
8106
            else if ((o->size % bed->s->sizeof_rel) == 0)
8107
              {
8108
                /* Section size is only divisible by rel.  */
8109
                if (use_rela_initialised && (use_rela == TRUE))
8110
                  {
8111
                    _bfd_error_handler
8112
                      (_("%B: Unable to sort relocs - they are in more than one size"), abfd);
8113
                    bfd_set_error (bfd_error_invalid_operation);
8114
                    return 0;
8115
                  }
8116
                else
8117
                  {
8118
                    use_rela = FALSE;
8119
                    use_rela_initialised = TRUE;
8120
                  }
8121
              }
8122
            else
8123
              {
8124
                /* The section size is not divisible by either - something is wrong.  */
8125
                _bfd_error_handler
8126
                  (_("%B: Unable to sort relocs - they are of an unknown size"), abfd);
8127
                bfd_set_error (bfd_error_invalid_operation);
8128
                return 0;
8129
              }
8130
          }
8131
 
8132
      for (lo = rel_dyn->map_head.link_order; lo != NULL; lo = lo->next)
8133
        if (lo->type == bfd_indirect_link_order)
8134
          {
8135
            asection *o = lo->u.indirect.section;
8136
 
8137
            if ((o->size % bed->s->sizeof_rela) == 0)
8138
              {
8139
                if ((o->size % bed->s->sizeof_rel) == 0)
8140
                  /* Section size is divisible by both rel and rela sizes.
8141
                     It is of no help to us.  */
8142
                  ;
8143
                else
8144
                  {
8145
                    /* Section size is only divisible by rela.  */
8146
                    if (use_rela_initialised && (use_rela == FALSE))
8147
                      {
8148
                        _bfd_error_handler
8149
                          (_("%B: Unable to sort relocs - they are in more than one size"), abfd);
8150
                        bfd_set_error (bfd_error_invalid_operation);
8151
                        return 0;
8152
                      }
8153
                    else
8154
                      {
8155
                        use_rela = TRUE;
8156
                        use_rela_initialised = TRUE;
8157
                      }
8158
                  }
8159
              }
8160
            else if ((o->size % bed->s->sizeof_rel) == 0)
8161
              {
8162
                /* Section size is only divisible by rel.  */
8163
                if (use_rela_initialised && (use_rela == TRUE))
8164
                  {
8165
                    _bfd_error_handler
8166
                      (_("%B: Unable to sort relocs - they are in more than one size"), abfd);
8167
                    bfd_set_error (bfd_error_invalid_operation);
8168
                    return 0;
8169
                  }
8170
                else
8171
                  {
8172
                    use_rela = FALSE;
8173
                    use_rela_initialised = TRUE;
8174
                  }
8175
              }
8176
            else
8177
              {
8178
                /* The section size is not divisible by either - something is wrong.  */
8179
                _bfd_error_handler
8180
                  (_("%B: Unable to sort relocs - they are of an unknown size"), abfd);
8181
                bfd_set_error (bfd_error_invalid_operation);
8182
                return 0;
8183
              }
8184
          }
8185
 
8186
      if (! use_rela_initialised)
8187
        /* Make a guess.  */
8188
        use_rela = TRUE;
8189
    }
8190
  else if (rela_dyn != NULL && rela_dyn->size > 0)
8191
    use_rela = TRUE;
8192
  else if (rel_dyn != NULL && rel_dyn->size > 0)
8193
    use_rela = FALSE;
8194
  else
8195
    return 0;
8196
 
8197
  if (use_rela)
8198
    {
8199
      dynamic_relocs = rela_dyn;
8200
      ext_size = bed->s->sizeof_rela;
8201
      swap_in = bed->s->swap_reloca_in;
8202
      swap_out = bed->s->swap_reloca_out;
8203
    }
8204
  else
8205
    {
8206
      dynamic_relocs = rel_dyn;
8207
      ext_size = bed->s->sizeof_rel;
8208
      swap_in = bed->s->swap_reloc_in;
8209
      swap_out = bed->s->swap_reloc_out;
8210
    }
8211
 
8212
  size = 0;
8213
  for (lo = dynamic_relocs->map_head.link_order; lo != NULL; lo = lo->next)
8214
    if (lo->type == bfd_indirect_link_order)
8215
      size += lo->u.indirect.section->size;
8216
 
8217
  if (size != dynamic_relocs->size)
8218
    return 0;
8219
 
8220
  sort_elt = (sizeof (struct elf_link_sort_rela)
8221
              + (i2e - 1) * sizeof (Elf_Internal_Rela));
8222
 
8223
  count = dynamic_relocs->size / ext_size;
8224
  if (count == 0)
8225
    return 0;
8226
  sort = (bfd_byte *) bfd_zmalloc (sort_elt * count);
8227
 
8228
  if (sort == NULL)
8229
    {
8230
      (*info->callbacks->warning)
8231
        (info, _("Not enough memory to sort relocations"), 0, abfd, 0, 0);
8232
      return 0;
8233
    }
8234
 
8235
  if (bed->s->arch_size == 32)
8236
    r_sym_mask = ~(bfd_vma) 0xff;
8237
  else
8238
    r_sym_mask = ~(bfd_vma) 0xffffffff;
8239
 
8240
  for (lo = dynamic_relocs->map_head.link_order; lo != NULL; lo = lo->next)
8241
    if (lo->type == bfd_indirect_link_order)
8242
      {
8243
        bfd_byte *erel, *erelend;
8244
        asection *o = lo->u.indirect.section;
8245
 
8246
        if (o->contents == NULL && o->size != 0)
8247
          {
8248
            /* This is a reloc section that is being handled as a normal
8249
               section.  See bfd_section_from_shdr.  We can't combine
8250
               relocs in this case.  */
8251
            free (sort);
8252
            return 0;
8253
          }
8254
        erel = o->contents;
8255
        erelend = o->contents + o->size;
8256
        /* FIXME: octets_per_byte.  */
8257
        p = sort + o->output_offset / ext_size * sort_elt;
8258
 
8259
        while (erel < erelend)
8260
          {
8261
            struct elf_link_sort_rela *s = (struct elf_link_sort_rela *) p;
8262
 
8263
            (*swap_in) (abfd, erel, s->rela);
8264
            s->type = (*bed->elf_backend_reloc_type_class) (s->rela);
8265
            s->u.sym_mask = r_sym_mask;
8266
            p += sort_elt;
8267
            erel += ext_size;
8268
          }
8269
      }
8270
 
8271
  qsort (sort, count, sort_elt, elf_link_sort_cmp1);
8272
 
8273
  for (i = 0, p = sort; i < count; i++, p += sort_elt)
8274
    {
8275
      struct elf_link_sort_rela *s = (struct elf_link_sort_rela *) p;
8276
      if (s->type != reloc_class_relative)
8277
        break;
8278
    }
8279
  ret = i;
8280
  s_non_relative = p;
8281
 
8282
  sq = (struct elf_link_sort_rela *) s_non_relative;
8283
  for (; i < count; i++, p += sort_elt)
8284
    {
8285
      struct elf_link_sort_rela *sp = (struct elf_link_sort_rela *) p;
8286
      if (((sp->rela->r_info ^ sq->rela->r_info) & r_sym_mask) != 0)
8287
        sq = sp;
8288
      sp->u.offset = sq->rela->r_offset;
8289
    }
8290
 
8291
  qsort (s_non_relative, count - ret, sort_elt, elf_link_sort_cmp2);
8292
 
8293
  for (lo = dynamic_relocs->map_head.link_order; lo != NULL; lo = lo->next)
8294
    if (lo->type == bfd_indirect_link_order)
8295
      {
8296
        bfd_byte *erel, *erelend;
8297
        asection *o = lo->u.indirect.section;
8298
 
8299
        erel = o->contents;
8300
        erelend = o->contents + o->size;
8301
        /* FIXME: octets_per_byte.  */
8302
        p = sort + o->output_offset / ext_size * sort_elt;
8303
        while (erel < erelend)
8304
          {
8305
            struct elf_link_sort_rela *s = (struct elf_link_sort_rela *) p;
8306
            (*swap_out) (abfd, s->rela, erel);
8307
            p += sort_elt;
8308
            erel += ext_size;
8309
          }
8310
      }
8311
 
8312
  free (sort);
8313
  *psec = dynamic_relocs;
8314
  return ret;
8315
}
8316
 
8317
/* Flush the output symbols to the file.  */
8318
 
8319
static bfd_boolean
8320
elf_link_flush_output_syms (struct elf_final_link_info *finfo,
8321
                            const struct elf_backend_data *bed)
8322
{
8323
  if (finfo->symbuf_count > 0)
8324
    {
8325
      Elf_Internal_Shdr *hdr;
8326
      file_ptr pos;
8327
      bfd_size_type amt;
8328
 
8329
      hdr = &elf_tdata (finfo->output_bfd)->symtab_hdr;
8330
      pos = hdr->sh_offset + hdr->sh_size;
8331
      amt = finfo->symbuf_count * bed->s->sizeof_sym;
8332
      if (bfd_seek (finfo->output_bfd, pos, SEEK_SET) != 0
8333
          || bfd_bwrite (finfo->symbuf, amt, finfo->output_bfd) != amt)
8334
        return FALSE;
8335
 
8336
      hdr->sh_size += amt;
8337
      finfo->symbuf_count = 0;
8338
    }
8339
 
8340
  return TRUE;
8341
}
8342
 
8343
/* Add a symbol to the output symbol table.  */
8344
 
8345
static int
8346
elf_link_output_sym (struct elf_final_link_info *finfo,
8347
                     const char *name,
8348
                     Elf_Internal_Sym *elfsym,
8349
                     asection *input_sec,
8350
                     struct elf_link_hash_entry *h)
8351
{
8352
  bfd_byte *dest;
8353
  Elf_External_Sym_Shndx *destshndx;
8354
  int (*output_symbol_hook)
8355
    (struct bfd_link_info *, const char *, Elf_Internal_Sym *, asection *,
8356
     struct elf_link_hash_entry *);
8357
  const struct elf_backend_data *bed;
8358
 
8359
  bed = get_elf_backend_data (finfo->output_bfd);
8360
  output_symbol_hook = bed->elf_backend_link_output_symbol_hook;
8361
  if (output_symbol_hook != NULL)
8362
    {
8363
      int ret = (*output_symbol_hook) (finfo->info, name, elfsym, input_sec, h);
8364
      if (ret != 1)
8365
        return ret;
8366
    }
8367
 
8368
  if (name == NULL || *name == '\0')
8369
    elfsym->st_name = 0;
8370
  else if (input_sec->flags & SEC_EXCLUDE)
8371
    elfsym->st_name = 0;
8372
  else
8373
    {
8374
      elfsym->st_name = (unsigned long) _bfd_stringtab_add (finfo->symstrtab,
8375
                                                            name, TRUE, FALSE);
8376
      if (elfsym->st_name == (unsigned long) -1)
8377
        return 0;
8378
    }
8379
 
8380
  if (finfo->symbuf_count >= finfo->symbuf_size)
8381
    {
8382
      if (! elf_link_flush_output_syms (finfo, bed))
8383
        return 0;
8384
    }
8385
 
8386
  dest = finfo->symbuf + finfo->symbuf_count * bed->s->sizeof_sym;
8387
  destshndx = finfo->symshndxbuf;
8388
  if (destshndx != NULL)
8389
    {
8390
      if (bfd_get_symcount (finfo->output_bfd) >= finfo->shndxbuf_size)
8391
        {
8392
          bfd_size_type amt;
8393
 
8394
          amt = finfo->shndxbuf_size * sizeof (Elf_External_Sym_Shndx);
8395
          destshndx = (Elf_External_Sym_Shndx *) bfd_realloc (destshndx,
8396
                                                              amt * 2);
8397
          if (destshndx == NULL)
8398
            return 0;
8399
          finfo->symshndxbuf = destshndx;
8400
          memset ((char *) destshndx + amt, 0, amt);
8401
          finfo->shndxbuf_size *= 2;
8402
        }
8403
      destshndx += bfd_get_symcount (finfo->output_bfd);
8404
    }
8405
 
8406
  bed->s->swap_symbol_out (finfo->output_bfd, elfsym, dest, destshndx);
8407
  finfo->symbuf_count += 1;
8408
  bfd_get_symcount (finfo->output_bfd) += 1;
8409
 
8410
  return 1;
8411
}
8412
 
8413
/* Return TRUE if the dynamic symbol SYM in ABFD is supported.  */
8414
 
8415
static bfd_boolean
8416
check_dynsym (bfd *abfd, Elf_Internal_Sym *sym)
8417
{
8418
  if (sym->st_shndx >= (SHN_LORESERVE & 0xffff)
8419
      && sym->st_shndx < SHN_LORESERVE)
8420
    {
8421
      /* The gABI doesn't support dynamic symbols in output sections
8422
         beyond 64k.  */
8423
      (*_bfd_error_handler)
8424
        (_("%B: Too many sections: %d (>= %d)"),
8425
         abfd, bfd_count_sections (abfd), SHN_LORESERVE & 0xffff);
8426
      bfd_set_error (bfd_error_nonrepresentable_section);
8427
      return FALSE;
8428
    }
8429
  return TRUE;
8430
}
8431
 
8432
/* For DSOs loaded in via a DT_NEEDED entry, emulate ld.so in
8433
   allowing an unsatisfied unversioned symbol in the DSO to match a
8434
   versioned symbol that would normally require an explicit version.
8435
   We also handle the case that a DSO references a hidden symbol
8436
   which may be satisfied by a versioned symbol in another DSO.  */
8437
 
8438
static bfd_boolean
8439
elf_link_check_versioned_symbol (struct bfd_link_info *info,
8440
                                 const struct elf_backend_data *bed,
8441
                                 struct elf_link_hash_entry *h)
8442
{
8443
  bfd *abfd;
8444
  struct elf_link_loaded_list *loaded;
8445
 
8446
  if (!is_elf_hash_table (info->hash))
8447
    return FALSE;
8448
 
8449
  switch (h->root.type)
8450
    {
8451
    default:
8452
      abfd = NULL;
8453
      break;
8454
 
8455
    case bfd_link_hash_undefined:
8456
    case bfd_link_hash_undefweak:
8457
      abfd = h->root.u.undef.abfd;
8458
      if ((abfd->flags & DYNAMIC) == 0
8459
          || (elf_dyn_lib_class (abfd) & DYN_DT_NEEDED) == 0)
8460
        return FALSE;
8461
      break;
8462
 
8463
    case bfd_link_hash_defined:
8464
    case bfd_link_hash_defweak:
8465
      abfd = h->root.u.def.section->owner;
8466
      break;
8467
 
8468
    case bfd_link_hash_common:
8469
      abfd = h->root.u.c.p->section->owner;
8470
      break;
8471
    }
8472
  BFD_ASSERT (abfd != NULL);
8473
 
8474
  for (loaded = elf_hash_table (info)->loaded;
8475
       loaded != NULL;
8476
       loaded = loaded->next)
8477
    {
8478
      bfd *input;
8479
      Elf_Internal_Shdr *hdr;
8480
      bfd_size_type symcount;
8481
      bfd_size_type extsymcount;
8482
      bfd_size_type extsymoff;
8483
      Elf_Internal_Shdr *versymhdr;
8484
      Elf_Internal_Sym *isym;
8485
      Elf_Internal_Sym *isymend;
8486
      Elf_Internal_Sym *isymbuf;
8487
      Elf_External_Versym *ever;
8488
      Elf_External_Versym *extversym;
8489
 
8490
      input = loaded->abfd;
8491
 
8492
      /* We check each DSO for a possible hidden versioned definition.  */
8493
      if (input == abfd
8494
          || (input->flags & DYNAMIC) == 0
8495
          || elf_dynversym (input) == 0)
8496
        continue;
8497
 
8498
      hdr = &elf_tdata (input)->dynsymtab_hdr;
8499
 
8500
      symcount = hdr->sh_size / bed->s->sizeof_sym;
8501
      if (elf_bad_symtab (input))
8502
        {
8503
          extsymcount = symcount;
8504
          extsymoff = 0;
8505
        }
8506
      else
8507
        {
8508
          extsymcount = symcount - hdr->sh_info;
8509
          extsymoff = hdr->sh_info;
8510
        }
8511
 
8512
      if (extsymcount == 0)
8513
        continue;
8514
 
8515
      isymbuf = bfd_elf_get_elf_syms (input, hdr, extsymcount, extsymoff,
8516
                                      NULL, NULL, NULL);
8517
      if (isymbuf == NULL)
8518
        return FALSE;
8519
 
8520
      /* Read in any version definitions.  */
8521
      versymhdr = &elf_tdata (input)->dynversym_hdr;
8522
      extversym = (Elf_External_Versym *) bfd_malloc (versymhdr->sh_size);
8523
      if (extversym == NULL)
8524
        goto error_ret;
8525
 
8526
      if (bfd_seek (input, versymhdr->sh_offset, SEEK_SET) != 0
8527
          || (bfd_bread (extversym, versymhdr->sh_size, input)
8528
              != versymhdr->sh_size))
8529
        {
8530
          free (extversym);
8531
        error_ret:
8532
          free (isymbuf);
8533
          return FALSE;
8534
        }
8535
 
8536
      ever = extversym + extsymoff;
8537
      isymend = isymbuf + extsymcount;
8538
      for (isym = isymbuf; isym < isymend; isym++, ever++)
8539
        {
8540
          const char *name;
8541
          Elf_Internal_Versym iver;
8542
          unsigned short version_index;
8543
 
8544
          if (ELF_ST_BIND (isym->st_info) == STB_LOCAL
8545
              || isym->st_shndx == SHN_UNDEF)
8546
            continue;
8547
 
8548
          name = bfd_elf_string_from_elf_section (input,
8549
                                                  hdr->sh_link,
8550
                                                  isym->st_name);
8551
          if (strcmp (name, h->root.root.string) != 0)
8552
            continue;
8553
 
8554
          _bfd_elf_swap_versym_in (input, ever, &iver);
8555
 
8556
          if ((iver.vs_vers & VERSYM_HIDDEN) == 0
8557
              && !(h->def_regular
8558
                   && h->forced_local))
8559
            {
8560
              /* If we have a non-hidden versioned sym, then it should
8561
                 have provided a definition for the undefined sym unless
8562
                 it is defined in a non-shared object and forced local.
8563
               */
8564
              abort ();
8565
            }
8566
 
8567
          version_index = iver.vs_vers & VERSYM_VERSION;
8568
          if (version_index == 1 || version_index == 2)
8569
            {
8570
              /* This is the base or first version.  We can use it.  */
8571
              free (extversym);
8572
              free (isymbuf);
8573
              return TRUE;
8574
            }
8575
        }
8576
 
8577
      free (extversym);
8578
      free (isymbuf);
8579
    }
8580
 
8581
  return FALSE;
8582
}
8583
 
8584
/* Add an external symbol to the symbol table.  This is called from
8585
   the hash table traversal routine.  When generating a shared object,
8586
   we go through the symbol table twice.  The first time we output
8587
   anything that might have been forced to local scope in a version
8588
   script.  The second time we output the symbols that are still
8589
   global symbols.  */
8590
 
8591
static bfd_boolean
8592 148 khays
elf_link_output_extsym (struct bfd_hash_entry *bh, void *data)
8593 14 khays
{
8594 148 khays
  struct elf_link_hash_entry *h = (struct elf_link_hash_entry *) bh;
8595 14 khays
  struct elf_outext_info *eoinfo = (struct elf_outext_info *) data;
8596
  struct elf_final_link_info *finfo = eoinfo->finfo;
8597
  bfd_boolean strip;
8598
  Elf_Internal_Sym sym;
8599
  asection *input_sec;
8600
  const struct elf_backend_data *bed;
8601
  long indx;
8602
  int ret;
8603
 
8604
  if (h->root.type == bfd_link_hash_warning)
8605
    {
8606
      h = (struct elf_link_hash_entry *) h->root.u.i.link;
8607
      if (h->root.type == bfd_link_hash_new)
8608
        return TRUE;
8609
    }
8610
 
8611
  /* Decide whether to output this symbol in this pass.  */
8612
  if (eoinfo->localsyms)
8613
    {
8614
      if (!h->forced_local)
8615
        return TRUE;
8616
    }
8617
  else
8618
    {
8619
      if (h->forced_local)
8620
        return TRUE;
8621
    }
8622
 
8623
  bed = get_elf_backend_data (finfo->output_bfd);
8624
 
8625
  if (h->root.type == bfd_link_hash_undefined)
8626
    {
8627
      /* If we have an undefined symbol reference here then it must have
8628
         come from a shared library that is being linked in.  (Undefined
8629
         references in regular files have already been handled unless
8630
         they are in unreferenced sections which are removed by garbage
8631
         collection).  */
8632
      bfd_boolean ignore_undef = FALSE;
8633
 
8634
      /* Some symbols may be special in that the fact that they're
8635
         undefined can be safely ignored - let backend determine that.  */
8636
      if (bed->elf_backend_ignore_undef_symbol)
8637
        ignore_undef = bed->elf_backend_ignore_undef_symbol (h);
8638
 
8639
      /* If we are reporting errors for this situation then do so now.  */
8640
      if (!ignore_undef
8641
          && h->ref_dynamic
8642
          && (!h->ref_regular || finfo->info->gc_sections)
8643
          && ! elf_link_check_versioned_symbol (finfo->info, bed, h)
8644
          && finfo->info->unresolved_syms_in_shared_libs != RM_IGNORE)
8645
        {
8646
          if (! (finfo->info->callbacks->undefined_symbol
8647
                 (finfo->info, h->root.root.string,
8648
                  h->ref_regular ? NULL : h->root.u.undef.abfd,
8649
                  NULL, 0, finfo->info->unresolved_syms_in_shared_libs == RM_GENERATE_ERROR)))
8650
            {
8651
              bfd_set_error (bfd_error_bad_value);
8652
              eoinfo->failed = TRUE;
8653
              return FALSE;
8654
            }
8655
        }
8656
    }
8657
 
8658
  /* We should also warn if a forced local symbol is referenced from
8659
     shared libraries.  */
8660 163 khays
  if (!finfo->info->relocatable
8661
      && finfo->info->executable
8662 14 khays
      && h->forced_local
8663
      && h->ref_dynamic
8664 163 khays
      && h->def_regular
8665 14 khays
      && !h->dynamic_def
8666
      && !h->dynamic_weak
8667
      && ! elf_link_check_versioned_symbol (finfo->info, bed, h))
8668
    {
8669
      bfd *def_bfd;
8670
      const char *msg;
8671
 
8672
      if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL)
8673
        msg = _("%B: internal symbol `%s' in %B is referenced by DSO");
8674
      else if (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
8675
        msg = _("%B: hidden symbol `%s' in %B is referenced by DSO");
8676
      else
8677
        msg = _("%B: local symbol `%s' in %B is referenced by DSO");
8678
      def_bfd = finfo->output_bfd;
8679
      if (h->root.u.def.section != bfd_abs_section_ptr)
8680
        def_bfd = h->root.u.def.section->owner;
8681
      (*_bfd_error_handler) (msg, finfo->output_bfd, def_bfd,
8682
                             h->root.root.string);
8683
      bfd_set_error (bfd_error_bad_value);
8684
      eoinfo->failed = TRUE;
8685
      return FALSE;
8686
    }
8687
 
8688
  /* We don't want to output symbols that have never been mentioned by
8689
     a regular file, or that we have been told to strip.  However, if
8690
     h->indx is set to -2, the symbol is used by a reloc and we must
8691
     output it.  */
8692
  if (h->indx == -2)
8693
    strip = FALSE;
8694
  else if ((h->def_dynamic
8695
            || h->ref_dynamic
8696
            || h->root.type == bfd_link_hash_new)
8697
           && !h->def_regular
8698
           && !h->ref_regular)
8699
    strip = TRUE;
8700
  else if (finfo->info->strip == strip_all)
8701
    strip = TRUE;
8702
  else if (finfo->info->strip == strip_some
8703
           && bfd_hash_lookup (finfo->info->keep_hash,
8704
                               h->root.root.string, FALSE, FALSE) == NULL)
8705
    strip = TRUE;
8706 163 khays
  else if ((h->root.type == bfd_link_hash_defined
8707
            || h->root.type == bfd_link_hash_defweak)
8708
           && ((finfo->info->strip_discarded
8709
                && elf_discarded_section (h->root.u.def.section))
8710
               || (h->root.u.def.section->owner != NULL
8711
                   && (h->root.u.def.section->owner->flags & BFD_PLUGIN) != 0)))
8712 14 khays
    strip = TRUE;
8713
  else if ((h->root.type == bfd_link_hash_undefined
8714
            || h->root.type == bfd_link_hash_undefweak)
8715
           && h->root.u.undef.abfd != NULL
8716
           && (h->root.u.undef.abfd->flags & BFD_PLUGIN) != 0)
8717
    strip = TRUE;
8718
  else
8719
    strip = FALSE;
8720
 
8721
  /* If we're stripping it, and it's not a dynamic symbol, there's
8722
     nothing else to do unless it is a forced local symbol or a
8723
     STT_GNU_IFUNC symbol.  */
8724
  if (strip
8725
      && h->dynindx == -1
8726
      && h->type != STT_GNU_IFUNC
8727
      && !h->forced_local)
8728
    return TRUE;
8729
 
8730
  sym.st_value = 0;
8731
  sym.st_size = h->size;
8732
  sym.st_other = h->other;
8733
  if (h->forced_local)
8734
    {
8735
      sym.st_info = ELF_ST_INFO (STB_LOCAL, h->type);
8736
      /* Turn off visibility on local symbol.  */
8737
      sym.st_other &= ~ELF_ST_VISIBILITY (-1);
8738
    }
8739
  else if (h->unique_global)
8740
    sym.st_info = ELF_ST_INFO (STB_GNU_UNIQUE, h->type);
8741
  else if (h->root.type == bfd_link_hash_undefweak
8742
           || h->root.type == bfd_link_hash_defweak)
8743
    sym.st_info = ELF_ST_INFO (STB_WEAK, h->type);
8744
  else
8745
    sym.st_info = ELF_ST_INFO (STB_GLOBAL, h->type);
8746
  sym.st_target_internal = h->target_internal;
8747
 
8748
  switch (h->root.type)
8749
    {
8750
    default:
8751
    case bfd_link_hash_new:
8752
    case bfd_link_hash_warning:
8753
      abort ();
8754
      return FALSE;
8755
 
8756
    case bfd_link_hash_undefined:
8757
    case bfd_link_hash_undefweak:
8758
      input_sec = bfd_und_section_ptr;
8759
      sym.st_shndx = SHN_UNDEF;
8760
      break;
8761
 
8762
    case bfd_link_hash_defined:
8763
    case bfd_link_hash_defweak:
8764
      {
8765
        input_sec = h->root.u.def.section;
8766
        if (input_sec->output_section != NULL)
8767
          {
8768
            sym.st_shndx =
8769
              _bfd_elf_section_from_bfd_section (finfo->output_bfd,
8770
                                                 input_sec->output_section);
8771
            if (sym.st_shndx == SHN_BAD)
8772
              {
8773
                (*_bfd_error_handler)
8774
                  (_("%B: could not find output section %A for input section %A"),
8775
                   finfo->output_bfd, input_sec->output_section, input_sec);
8776
                bfd_set_error (bfd_error_nonrepresentable_section);
8777
                eoinfo->failed = TRUE;
8778
                return FALSE;
8779
              }
8780
 
8781
            /* ELF symbols in relocatable files are section relative,
8782
               but in nonrelocatable files they are virtual
8783
               addresses.  */
8784
            sym.st_value = h->root.u.def.value + input_sec->output_offset;
8785
            if (! finfo->info->relocatable)
8786
              {
8787
                sym.st_value += input_sec->output_section->vma;
8788
                if (h->type == STT_TLS)
8789
                  {
8790
                    asection *tls_sec = elf_hash_table (finfo->info)->tls_sec;
8791
                    if (tls_sec != NULL)
8792
                      sym.st_value -= tls_sec->vma;
8793
                    else
8794
                      {
8795
                        /* The TLS section may have been garbage collected.  */
8796
                        BFD_ASSERT (finfo->info->gc_sections
8797
                                    && !input_sec->gc_mark);
8798
                      }
8799
                  }
8800
              }
8801
          }
8802
        else
8803
          {
8804
            BFD_ASSERT (input_sec->owner == NULL
8805
                        || (input_sec->owner->flags & DYNAMIC) != 0);
8806
            sym.st_shndx = SHN_UNDEF;
8807
            input_sec = bfd_und_section_ptr;
8808
          }
8809
      }
8810
      break;
8811
 
8812
    case bfd_link_hash_common:
8813
      input_sec = h->root.u.c.p->section;
8814
      sym.st_shndx = bed->common_section_index (input_sec);
8815
      sym.st_value = 1 << h->root.u.c.p->alignment_power;
8816
      break;
8817
 
8818
    case bfd_link_hash_indirect:
8819
      /* These symbols are created by symbol versioning.  They point
8820
         to the decorated version of the name.  For example, if the
8821
         symbol foo@@GNU_1.2 is the default, which should be used when
8822
         foo is used with no version, then we add an indirect symbol
8823
         foo which points to foo@@GNU_1.2.  We ignore these symbols,
8824
         since the indirected symbol is already in the hash table.  */
8825
      return TRUE;
8826
    }
8827
 
8828
  /* Give the processor backend a chance to tweak the symbol value,
8829
     and also to finish up anything that needs to be done for this
8830
     symbol.  FIXME: Not calling elf_backend_finish_dynamic_symbol for
8831
     forced local syms when non-shared is due to a historical quirk.
8832
     STT_GNU_IFUNC symbol must go through PLT.  */
8833
  if ((h->type == STT_GNU_IFUNC
8834
       && h->def_regular
8835
       && !finfo->info->relocatable)
8836
      || ((h->dynindx != -1
8837
           || h->forced_local)
8838
          && ((finfo->info->shared
8839
               && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
8840
                   || h->root.type != bfd_link_hash_undefweak))
8841
              || !h->forced_local)
8842
          && elf_hash_table (finfo->info)->dynamic_sections_created))
8843
    {
8844
      if (! ((*bed->elf_backend_finish_dynamic_symbol)
8845
             (finfo->output_bfd, finfo->info, h, &sym)))
8846
        {
8847
          eoinfo->failed = TRUE;
8848
          return FALSE;
8849
        }
8850
    }
8851
 
8852
  /* If we are marking the symbol as undefined, and there are no
8853
     non-weak references to this symbol from a regular object, then
8854
     mark the symbol as weak undefined; if there are non-weak
8855
     references, mark the symbol as strong.  We can't do this earlier,
8856
     because it might not be marked as undefined until the
8857
     finish_dynamic_symbol routine gets through with it.  */
8858
  if (sym.st_shndx == SHN_UNDEF
8859
      && h->ref_regular
8860
      && (ELF_ST_BIND (sym.st_info) == STB_GLOBAL
8861
          || ELF_ST_BIND (sym.st_info) == STB_WEAK))
8862
    {
8863
      int bindtype;
8864
      unsigned int type = ELF_ST_TYPE (sym.st_info);
8865
 
8866
      /* Turn an undefined IFUNC symbol into a normal FUNC symbol. */
8867
      if (type == STT_GNU_IFUNC)
8868
        type = STT_FUNC;
8869
 
8870
      if (h->ref_regular_nonweak)
8871
        bindtype = STB_GLOBAL;
8872
      else
8873
        bindtype = STB_WEAK;
8874
      sym.st_info = ELF_ST_INFO (bindtype, type);
8875
    }
8876
 
8877
  /* If this is a symbol defined in a dynamic library, don't use the
8878
     symbol size from the dynamic library.  Relinking an executable
8879
     against a new library may introduce gratuitous changes in the
8880
     executable's symbols if we keep the size.  */
8881
  if (sym.st_shndx == SHN_UNDEF
8882
      && !h->def_regular
8883
      && h->def_dynamic)
8884
    sym.st_size = 0;
8885
 
8886
  /* If a non-weak symbol with non-default visibility is not defined
8887
     locally, it is a fatal error.  */
8888
  if (! finfo->info->relocatable
8889
      && ELF_ST_VISIBILITY (sym.st_other) != STV_DEFAULT
8890
      && ELF_ST_BIND (sym.st_info) != STB_WEAK
8891
      && h->root.type == bfd_link_hash_undefined
8892
      && !h->def_regular)
8893
    {
8894
      const char *msg;
8895
 
8896
      if (ELF_ST_VISIBILITY (sym.st_other) == STV_PROTECTED)
8897
        msg = _("%B: protected symbol `%s' isn't defined");
8898
      else if (ELF_ST_VISIBILITY (sym.st_other) == STV_INTERNAL)
8899
        msg = _("%B: internal symbol `%s' isn't defined");
8900
      else
8901
        msg = _("%B: hidden symbol `%s' isn't defined");
8902
      (*_bfd_error_handler) (msg, finfo->output_bfd, h->root.root.string);
8903
      bfd_set_error (bfd_error_bad_value);
8904
      eoinfo->failed = TRUE;
8905
      return FALSE;
8906
    }
8907
 
8908
  /* If this symbol should be put in the .dynsym section, then put it
8909
     there now.  We already know the symbol index.  We also fill in
8910
     the entry in the .hash section.  */
8911
  if (h->dynindx != -1
8912
      && elf_hash_table (finfo->info)->dynamic_sections_created)
8913
    {
8914
      bfd_byte *esym;
8915
 
8916
      sym.st_name = h->dynstr_index;
8917
      esym = finfo->dynsym_sec->contents + h->dynindx * bed->s->sizeof_sym;
8918
      if (! check_dynsym (finfo->output_bfd, &sym))
8919
        {
8920
          eoinfo->failed = TRUE;
8921
          return FALSE;
8922
        }
8923
      bed->s->swap_symbol_out (finfo->output_bfd, &sym, esym, 0);
8924
 
8925
      if (finfo->hash_sec != NULL)
8926
        {
8927
          size_t hash_entry_size;
8928
          bfd_byte *bucketpos;
8929
          bfd_vma chain;
8930
          size_t bucketcount;
8931
          size_t bucket;
8932
 
8933
          bucketcount = elf_hash_table (finfo->info)->bucketcount;
8934
          bucket = h->u.elf_hash_value % bucketcount;
8935
 
8936
          hash_entry_size
8937
            = elf_section_data (finfo->hash_sec)->this_hdr.sh_entsize;
8938
          bucketpos = ((bfd_byte *) finfo->hash_sec->contents
8939
                       + (bucket + 2) * hash_entry_size);
8940
          chain = bfd_get (8 * hash_entry_size, finfo->output_bfd, bucketpos);
8941
          bfd_put (8 * hash_entry_size, finfo->output_bfd, h->dynindx, bucketpos);
8942
          bfd_put (8 * hash_entry_size, finfo->output_bfd, chain,
8943
                   ((bfd_byte *) finfo->hash_sec->contents
8944
                    + (bucketcount + 2 + h->dynindx) * hash_entry_size));
8945
        }
8946
 
8947
      if (finfo->symver_sec != NULL && finfo->symver_sec->contents != NULL)
8948
        {
8949
          Elf_Internal_Versym iversym;
8950
          Elf_External_Versym *eversym;
8951
 
8952
          if (!h->def_regular)
8953
            {
8954
              if (h->verinfo.verdef == NULL)
8955
                iversym.vs_vers = 0;
8956
              else
8957
                iversym.vs_vers = h->verinfo.verdef->vd_exp_refno + 1;
8958
            }
8959
          else
8960
            {
8961
              if (h->verinfo.vertree == NULL)
8962
                iversym.vs_vers = 1;
8963
              else
8964
                iversym.vs_vers = h->verinfo.vertree->vernum + 1;
8965
              if (finfo->info->create_default_symver)
8966
                iversym.vs_vers++;
8967
            }
8968
 
8969
          if (h->hidden)
8970
            iversym.vs_vers |= VERSYM_HIDDEN;
8971
 
8972
          eversym = (Elf_External_Versym *) finfo->symver_sec->contents;
8973
          eversym += h->dynindx;
8974
          _bfd_elf_swap_versym_out (finfo->output_bfd, &iversym, eversym);
8975
        }
8976
    }
8977
 
8978
  /* If we're stripping it, then it was just a dynamic symbol, and
8979
     there's nothing else to do.  */
8980
  if (strip || (input_sec->flags & SEC_EXCLUDE) != 0)
8981
    return TRUE;
8982
 
8983
  indx = bfd_get_symcount (finfo->output_bfd);
8984
  ret = elf_link_output_sym (finfo, h->root.root.string, &sym, input_sec, h);
8985
  if (ret == 0)
8986
    {
8987
      eoinfo->failed = TRUE;
8988
      return FALSE;
8989
    }
8990
  else if (ret == 1)
8991
    h->indx = indx;
8992
  else if (h->indx == -2)
8993
    abort();
8994
 
8995
  return TRUE;
8996
}
8997
 
8998
/* Return TRUE if special handling is done for relocs in SEC against
8999
   symbols defined in discarded sections.  */
9000
 
9001
static bfd_boolean
9002
elf_section_ignore_discarded_relocs (asection *sec)
9003
{
9004
  const struct elf_backend_data *bed;
9005
 
9006
  switch (sec->sec_info_type)
9007
    {
9008
    case ELF_INFO_TYPE_STABS:
9009
    case ELF_INFO_TYPE_EH_FRAME:
9010
      return TRUE;
9011
    default:
9012
      break;
9013
    }
9014
 
9015
  bed = get_elf_backend_data (sec->owner);
9016
  if (bed->elf_backend_ignore_discarded_relocs != NULL
9017
      && (*bed->elf_backend_ignore_discarded_relocs) (sec))
9018
    return TRUE;
9019
 
9020
  return FALSE;
9021
}
9022
 
9023
/* Return a mask saying how ld should treat relocations in SEC against
9024
   symbols defined in discarded sections.  If this function returns
9025
   COMPLAIN set, ld will issue a warning message.  If this function
9026
   returns PRETEND set, and the discarded section was link-once and the
9027
   same size as the kept link-once section, ld will pretend that the
9028
   symbol was actually defined in the kept section.  Otherwise ld will
9029
   zero the reloc (at least that is the intent, but some cooperation by
9030
   the target dependent code is needed, particularly for REL targets).  */
9031
 
9032
unsigned int
9033
_bfd_elf_default_action_discarded (asection *sec)
9034
{
9035
  if (sec->flags & SEC_DEBUGGING)
9036
    return PRETEND;
9037
 
9038
  if (strcmp (".eh_frame", sec->name) == 0)
9039
    return 0;
9040
 
9041
  if (strcmp (".gcc_except_table", sec->name) == 0)
9042
    return 0;
9043
 
9044
  return COMPLAIN | PRETEND;
9045
}
9046
 
9047
/* Find a match between a section and a member of a section group.  */
9048
 
9049
static asection *
9050
match_group_member (asection *sec, asection *group,
9051
                    struct bfd_link_info *info)
9052
{
9053
  asection *first = elf_next_in_group (group);
9054
  asection *s = first;
9055
 
9056
  while (s != NULL)
9057
    {
9058
      if (bfd_elf_match_symbols_in_sections (s, sec, info))
9059
        return s;
9060
 
9061
      s = elf_next_in_group (s);
9062
      if (s == first)
9063
        break;
9064
    }
9065
 
9066
  return NULL;
9067
}
9068
 
9069
/* Check if the kept section of a discarded section SEC can be used
9070
   to replace it.  Return the replacement if it is OK.  Otherwise return
9071
   NULL.  */
9072
 
9073
asection *
9074
_bfd_elf_check_kept_section (asection *sec, struct bfd_link_info *info)
9075
{
9076
  asection *kept;
9077
 
9078
  kept = sec->kept_section;
9079
  if (kept != NULL)
9080
    {
9081
      if ((kept->flags & SEC_GROUP) != 0)
9082
        kept = match_group_member (sec, kept, info);
9083
      if (kept != NULL
9084
          && ((sec->rawsize != 0 ? sec->rawsize : sec->size)
9085
              != (kept->rawsize != 0 ? kept->rawsize : kept->size)))
9086
        kept = NULL;
9087
      sec->kept_section = kept;
9088
    }
9089
  return kept;
9090
}
9091
 
9092
/* Link an input file into the linker output file.  This function
9093
   handles all the sections and relocations of the input file at once.
9094
   This is so that we only have to read the local symbols once, and
9095
   don't have to keep them in memory.  */
9096
 
9097
static bfd_boolean
9098
elf_link_input_bfd (struct elf_final_link_info *finfo, bfd *input_bfd)
9099
{
9100
  int (*relocate_section)
9101
    (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
9102
     Elf_Internal_Rela *, Elf_Internal_Sym *, asection **);
9103
  bfd *output_bfd;
9104
  Elf_Internal_Shdr *symtab_hdr;
9105
  size_t locsymcount;
9106
  size_t extsymoff;
9107
  Elf_Internal_Sym *isymbuf;
9108
  Elf_Internal_Sym *isym;
9109
  Elf_Internal_Sym *isymend;
9110
  long *pindex;
9111
  asection **ppsection;
9112
  asection *o;
9113
  const struct elf_backend_data *bed;
9114
  struct elf_link_hash_entry **sym_hashes;
9115
  bfd_size_type address_size;
9116
  bfd_vma r_type_mask;
9117
  int r_sym_shift;
9118
 
9119
  output_bfd = finfo->output_bfd;
9120
  bed = get_elf_backend_data (output_bfd);
9121
  relocate_section = bed->elf_backend_relocate_section;
9122
 
9123
  /* If this is a dynamic object, we don't want to do anything here:
9124
     we don't want the local symbols, and we don't want the section
9125
     contents.  */
9126
  if ((input_bfd->flags & DYNAMIC) != 0)
9127
    return TRUE;
9128
 
9129
  symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
9130
  if (elf_bad_symtab (input_bfd))
9131
    {
9132
      locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym;
9133
      extsymoff = 0;
9134
    }
9135
  else
9136
    {
9137
      locsymcount = symtab_hdr->sh_info;
9138
      extsymoff = symtab_hdr->sh_info;
9139
    }
9140
 
9141
  /* Read the local symbols.  */
9142
  isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
9143
  if (isymbuf == NULL && locsymcount != 0)
9144
    {
9145
      isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, locsymcount, 0,
9146
                                      finfo->internal_syms,
9147
                                      finfo->external_syms,
9148
                                      finfo->locsym_shndx);
9149
      if (isymbuf == NULL)
9150
        return FALSE;
9151
    }
9152
 
9153
  /* Find local symbol sections and adjust values of symbols in
9154
     SEC_MERGE sections.  Write out those local symbols we know are
9155
     going into the output file.  */
9156
  isymend = isymbuf + locsymcount;
9157
  for (isym = isymbuf, pindex = finfo->indices, ppsection = finfo->sections;
9158
       isym < isymend;
9159
       isym++, pindex++, ppsection++)
9160
    {
9161
      asection *isec;
9162
      const char *name;
9163
      Elf_Internal_Sym osym;
9164
      long indx;
9165
      int ret;
9166
 
9167
      *pindex = -1;
9168
 
9169
      if (elf_bad_symtab (input_bfd))
9170
        {
9171
          if (ELF_ST_BIND (isym->st_info) != STB_LOCAL)
9172
            {
9173
              *ppsection = NULL;
9174
              continue;
9175
            }
9176
        }
9177
 
9178
      if (isym->st_shndx == SHN_UNDEF)
9179
        isec = bfd_und_section_ptr;
9180
      else if (isym->st_shndx == SHN_ABS)
9181
        isec = bfd_abs_section_ptr;
9182
      else if (isym->st_shndx == SHN_COMMON)
9183
        isec = bfd_com_section_ptr;
9184
      else
9185
        {
9186
          isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
9187
          if (isec == NULL)
9188
            {
9189
              /* Don't attempt to output symbols with st_shnx in the
9190
                 reserved range other than SHN_ABS and SHN_COMMON.  */
9191
              *ppsection = NULL;
9192
              continue;
9193
            }
9194
          else if (isec->sec_info_type == ELF_INFO_TYPE_MERGE
9195
                   && ELF_ST_TYPE (isym->st_info) != STT_SECTION)
9196
            isym->st_value =
9197
              _bfd_merged_section_offset (output_bfd, &isec,
9198
                                          elf_section_data (isec)->sec_info,
9199
                                          isym->st_value);
9200
        }
9201
 
9202
      *ppsection = isec;
9203
 
9204
      /* Don't output the first, undefined, symbol.  */
9205
      if (ppsection == finfo->sections)
9206
        continue;
9207
 
9208
      if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
9209
        {
9210
          /* We never output section symbols.  Instead, we use the
9211
             section symbol of the corresponding section in the output
9212
             file.  */
9213
          continue;
9214
        }
9215
 
9216
      /* If we are stripping all symbols, we don't want to output this
9217
         one.  */
9218
      if (finfo->info->strip == strip_all)
9219
        continue;
9220
 
9221
      /* If we are discarding all local symbols, we don't want to
9222
         output this one.  If we are generating a relocatable output
9223
         file, then some of the local symbols may be required by
9224
         relocs; we output them below as we discover that they are
9225
         needed.  */
9226
      if (finfo->info->discard == discard_all)
9227
        continue;
9228
 
9229
      /* If this symbol is defined in a section which we are
9230
         discarding, we don't need to keep it.  */
9231
      if (isym->st_shndx != SHN_UNDEF
9232
          && isym->st_shndx < SHN_LORESERVE
9233
          && bfd_section_removed_from_list (output_bfd,
9234
                                            isec->output_section))
9235
        continue;
9236
 
9237
      /* Get the name of the symbol.  */
9238
      name = bfd_elf_string_from_elf_section (input_bfd, symtab_hdr->sh_link,
9239
                                              isym->st_name);
9240
      if (name == NULL)
9241
        return FALSE;
9242
 
9243
      /* See if we are discarding symbols with this name.  */
9244
      if ((finfo->info->strip == strip_some
9245
           && (bfd_hash_lookup (finfo->info->keep_hash, name, FALSE, FALSE)
9246
               == NULL))
9247
          || (((finfo->info->discard == discard_sec_merge
9248
                && (isec->flags & SEC_MERGE) && ! finfo->info->relocatable)
9249
               || finfo->info->discard == discard_l)
9250
              && bfd_is_local_label_name (input_bfd, name)))
9251
        continue;
9252
 
9253
      osym = *isym;
9254
 
9255
      /* Adjust the section index for the output file.  */
9256
      osym.st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
9257
                                                         isec->output_section);
9258
      if (osym.st_shndx == SHN_BAD)
9259
        return FALSE;
9260
 
9261
      /* ELF symbols in relocatable files are section relative, but
9262
         in executable files they are virtual addresses.  Note that
9263
         this code assumes that all ELF sections have an associated
9264
         BFD section with a reasonable value for output_offset; below
9265
         we assume that they also have a reasonable value for
9266
         output_section.  Any special sections must be set up to meet
9267
         these requirements.  */
9268
      osym.st_value += isec->output_offset;
9269
      if (! finfo->info->relocatable)
9270
        {
9271
          osym.st_value += isec->output_section->vma;
9272
          if (ELF_ST_TYPE (osym.st_info) == STT_TLS)
9273
            {
9274
              /* STT_TLS symbols are relative to PT_TLS segment base.  */
9275
              BFD_ASSERT (elf_hash_table (finfo->info)->tls_sec != NULL);
9276
              osym.st_value -= elf_hash_table (finfo->info)->tls_sec->vma;
9277
            }
9278
        }
9279
 
9280
      indx = bfd_get_symcount (output_bfd);
9281
      ret = elf_link_output_sym (finfo, name, &osym, isec, NULL);
9282
      if (ret == 0)
9283
        return FALSE;
9284
      else if (ret == 1)
9285
        *pindex = indx;
9286
    }
9287
 
9288
  if (bed->s->arch_size == 32)
9289
    {
9290
      r_type_mask = 0xff;
9291
      r_sym_shift = 8;
9292
      address_size = 4;
9293
    }
9294
  else
9295
    {
9296
      r_type_mask = 0xffffffff;
9297
      r_sym_shift = 32;
9298
      address_size = 8;
9299
    }
9300
 
9301
  /* Relocate the contents of each section.  */
9302
  sym_hashes = elf_sym_hashes (input_bfd);
9303
  for (o = input_bfd->sections; o != NULL; o = o->next)
9304
    {
9305
      bfd_byte *contents;
9306
 
9307
      if (! o->linker_mark)
9308
        {
9309
          /* This section was omitted from the link.  */
9310
          continue;
9311
        }
9312
 
9313
      if (finfo->info->relocatable
9314
          && (o->flags & (SEC_LINKER_CREATED | SEC_GROUP)) == SEC_GROUP)
9315
        {
9316
          /* Deal with the group signature symbol.  */
9317
          struct bfd_elf_section_data *sec_data = elf_section_data (o);
9318
          unsigned long symndx = sec_data->this_hdr.sh_info;
9319
          asection *osec = o->output_section;
9320
 
9321
          if (symndx >= locsymcount
9322
              || (elf_bad_symtab (input_bfd)
9323
                  && finfo->sections[symndx] == NULL))
9324
            {
9325
              struct elf_link_hash_entry *h = sym_hashes[symndx - extsymoff];
9326
              while (h->root.type == bfd_link_hash_indirect
9327
                     || h->root.type == bfd_link_hash_warning)
9328
                h = (struct elf_link_hash_entry *) h->root.u.i.link;
9329
              /* Arrange for symbol to be output.  */
9330
              h->indx = -2;
9331
              elf_section_data (osec)->this_hdr.sh_info = -2;
9332
            }
9333
          else if (ELF_ST_TYPE (isymbuf[symndx].st_info) == STT_SECTION)
9334
            {
9335
              /* We'll use the output section target_index.  */
9336
              asection *sec = finfo->sections[symndx]->output_section;
9337
              elf_section_data (osec)->this_hdr.sh_info = sec->target_index;
9338
            }
9339
          else
9340
            {
9341
              if (finfo->indices[symndx] == -1)
9342
                {
9343
                  /* Otherwise output the local symbol now.  */
9344
                  Elf_Internal_Sym sym = isymbuf[symndx];
9345
                  asection *sec = finfo->sections[symndx]->output_section;
9346
                  const char *name;
9347
                  long indx;
9348
                  int ret;
9349
 
9350
                  name = bfd_elf_string_from_elf_section (input_bfd,
9351
                                                          symtab_hdr->sh_link,
9352
                                                          sym.st_name);
9353
                  if (name == NULL)
9354
                    return FALSE;
9355
 
9356
                  sym.st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
9357
                                                                    sec);
9358
                  if (sym.st_shndx == SHN_BAD)
9359
                    return FALSE;
9360
 
9361
                  sym.st_value += o->output_offset;
9362
 
9363
                  indx = bfd_get_symcount (output_bfd);
9364
                  ret = elf_link_output_sym (finfo, name, &sym, o, NULL);
9365
                  if (ret == 0)
9366
                    return FALSE;
9367
                  else if (ret == 1)
9368
                    finfo->indices[symndx] = indx;
9369
                  else
9370
                    abort ();
9371
                }
9372
              elf_section_data (osec)->this_hdr.sh_info
9373
                = finfo->indices[symndx];
9374
            }
9375
        }
9376
 
9377
      if ((o->flags & SEC_HAS_CONTENTS) == 0
9378
          || (o->size == 0 && (o->flags & SEC_RELOC) == 0))
9379
        continue;
9380
 
9381
      if ((o->flags & SEC_LINKER_CREATED) != 0)
9382
        {
9383
          /* Section was created by _bfd_elf_link_create_dynamic_sections
9384
             or somesuch.  */
9385
          continue;
9386
        }
9387
 
9388
      /* Get the contents of the section.  They have been cached by a
9389
         relaxation routine.  Note that o is a section in an input
9390
         file, so the contents field will not have been set by any of
9391
         the routines which work on output files.  */
9392
      if (elf_section_data (o)->this_hdr.contents != NULL)
9393
        contents = elf_section_data (o)->this_hdr.contents;
9394
      else
9395
        {
9396
          contents = finfo->contents;
9397
          if (! bfd_get_full_section_contents (input_bfd, o, &contents))
9398
            return FALSE;
9399
        }
9400
 
9401
      if ((o->flags & SEC_RELOC) != 0)
9402
        {
9403
          Elf_Internal_Rela *internal_relocs;
9404
          Elf_Internal_Rela *rel, *relend;
9405
          int action_discarded;
9406
          int ret;
9407
 
9408
          /* Get the swapped relocs.  */
9409
          internal_relocs
9410
            = _bfd_elf_link_read_relocs (input_bfd, o, finfo->external_relocs,
9411
                                         finfo->internal_relocs, FALSE);
9412
          if (internal_relocs == NULL
9413
              && o->reloc_count > 0)
9414
            return FALSE;
9415
 
9416
          /* We need to reverse-copy input .ctors/.dtors sections if
9417
             they are placed in .init_array/.finit_array for output.  */
9418
          if (o->size > address_size
9419
              && ((strncmp (o->name, ".ctors", 6) == 0
9420
                   && strcmp (o->output_section->name,
9421
                              ".init_array") == 0)
9422
                  || (strncmp (o->name, ".dtors", 6) == 0
9423
                      && strcmp (o->output_section->name,
9424
                                 ".fini_array") == 0))
9425
              && (o->name[6] == 0 || o->name[6] == '.'))
9426
            {
9427
              if (o->size != o->reloc_count * address_size)
9428
                {
9429
                  (*_bfd_error_handler)
9430
                    (_("error: %B: size of section %A is not "
9431
                       "multiple of address size"),
9432
                     input_bfd, o);
9433
                  bfd_set_error (bfd_error_on_input);
9434
                  return FALSE;
9435
                }
9436
              o->flags |= SEC_ELF_REVERSE_COPY;
9437
            }
9438
 
9439
          action_discarded = -1;
9440
          if (!elf_section_ignore_discarded_relocs (o))
9441
            action_discarded = (*bed->action_discarded) (o);
9442
 
9443
          /* Run through the relocs evaluating complex reloc symbols and
9444
             looking for relocs against symbols from discarded sections
9445
             or section symbols from removed link-once sections.
9446
             Complain about relocs against discarded sections.  Zero
9447
             relocs against removed link-once sections.  */
9448
 
9449
          rel = internal_relocs;
9450
          relend = rel + o->reloc_count * bed->s->int_rels_per_ext_rel;
9451
          for ( ; rel < relend; rel++)
9452
            {
9453
              unsigned long r_symndx = rel->r_info >> r_sym_shift;
9454
              unsigned int s_type;
9455
              asection **ps, *sec;
9456
              struct elf_link_hash_entry *h = NULL;
9457
              const char *sym_name;
9458
 
9459
              if (r_symndx == STN_UNDEF)
9460
                continue;
9461
 
9462
              if (r_symndx >= locsymcount
9463
                  || (elf_bad_symtab (input_bfd)
9464
                      && finfo->sections[r_symndx] == NULL))
9465
                {
9466
                  h = sym_hashes[r_symndx - extsymoff];
9467
 
9468
                  /* Badly formatted input files can contain relocs that
9469
                     reference non-existant symbols.  Check here so that
9470
                     we do not seg fault.  */
9471
                  if (h == NULL)
9472
                    {
9473
                      char buffer [32];
9474
 
9475
                      sprintf_vma (buffer, rel->r_info);
9476
                      (*_bfd_error_handler)
9477
                        (_("error: %B contains a reloc (0x%s) for section %A "
9478
                           "that references a non-existent global symbol"),
9479
                         input_bfd, o, buffer);
9480
                      bfd_set_error (bfd_error_bad_value);
9481
                      return FALSE;
9482
                    }
9483
 
9484
                  while (h->root.type == bfd_link_hash_indirect
9485
                         || h->root.type == bfd_link_hash_warning)
9486
                    h = (struct elf_link_hash_entry *) h->root.u.i.link;
9487
 
9488
                  s_type = h->type;
9489
 
9490
                  ps = NULL;
9491
                  if (h->root.type == bfd_link_hash_defined
9492
                      || h->root.type == bfd_link_hash_defweak)
9493
                    ps = &h->root.u.def.section;
9494
 
9495
                  sym_name = h->root.root.string;
9496
                }
9497
              else
9498
                {
9499
                  Elf_Internal_Sym *sym = isymbuf + r_symndx;
9500
 
9501
                  s_type = ELF_ST_TYPE (sym->st_info);
9502
                  ps = &finfo->sections[r_symndx];
9503
                  sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr,
9504
                                               sym, *ps);
9505
                }
9506
 
9507
              if ((s_type == STT_RELC || s_type == STT_SRELC)
9508
                  && !finfo->info->relocatable)
9509
                {
9510
                  bfd_vma val;
9511
                  bfd_vma dot = (rel->r_offset
9512
                                 + o->output_offset + o->output_section->vma);
9513
#ifdef DEBUG
9514
                  printf ("Encountered a complex symbol!");
9515
                  printf (" (input_bfd %s, section %s, reloc %ld\n",
9516
                          input_bfd->filename, o->name,
9517
                          (long) (rel - internal_relocs));
9518
                  printf (" symbol: idx  %8.8lx, name %s\n",
9519
                          r_symndx, sym_name);
9520
                  printf (" reloc : info %8.8lx, addr %8.8lx\n",
9521
                          (unsigned long) rel->r_info,
9522
                          (unsigned long) rel->r_offset);
9523
#endif
9524
                  if (!eval_symbol (&val, &sym_name, input_bfd, finfo, dot,
9525
                                    isymbuf, locsymcount, s_type == STT_SRELC))
9526
                    return FALSE;
9527
 
9528
                  /* Symbol evaluated OK.  Update to absolute value.  */
9529
                  set_symbol_value (input_bfd, isymbuf, locsymcount,
9530
                                    r_symndx, val);
9531
                  continue;
9532
                }
9533
 
9534
              if (action_discarded != -1 && ps != NULL)
9535
                {
9536
                  /* Complain if the definition comes from a
9537
                     discarded section.  */
9538
                  if ((sec = *ps) != NULL && elf_discarded_section (sec))
9539
                    {
9540
                      BFD_ASSERT (r_symndx != STN_UNDEF);
9541
                      if (action_discarded & COMPLAIN)
9542
                        (*finfo->info->callbacks->einfo)
9543
                          (_("%X`%s' referenced in section `%A' of %B: "
9544
                             "defined in discarded section `%A' of %B\n"),
9545
                           sym_name, o, input_bfd, sec, sec->owner);
9546
 
9547
                      /* Try to do the best we can to support buggy old
9548
                         versions of gcc.  Pretend that the symbol is
9549
                         really defined in the kept linkonce section.
9550
                         FIXME: This is quite broken.  Modifying the
9551
                         symbol here means we will be changing all later
9552
                         uses of the symbol, not just in this section.  */
9553
                      if (action_discarded & PRETEND)
9554
                        {
9555
                          asection *kept;
9556
 
9557
                          kept = _bfd_elf_check_kept_section (sec,
9558
                                                              finfo->info);
9559
                          if (kept != NULL)
9560
                            {
9561
                              *ps = kept;
9562
                              continue;
9563
                            }
9564
                        }
9565
                    }
9566
                }
9567
            }
9568
 
9569
          /* Relocate the section by invoking a back end routine.
9570
 
9571
             The back end routine is responsible for adjusting the
9572
             section contents as necessary, and (if using Rela relocs
9573
             and generating a relocatable output file) adjusting the
9574
             reloc addend as necessary.
9575
 
9576
             The back end routine does not have to worry about setting
9577
             the reloc address or the reloc symbol index.
9578
 
9579
             The back end routine is given a pointer to the swapped in
9580
             internal symbols, and can access the hash table entries
9581
             for the external symbols via elf_sym_hashes (input_bfd).
9582
 
9583
             When generating relocatable output, the back end routine
9584
             must handle STB_LOCAL/STT_SECTION symbols specially.  The
9585
             output symbol is going to be a section symbol
9586
             corresponding to the output section, which will require
9587
             the addend to be adjusted.  */
9588
 
9589
          ret = (*relocate_section) (output_bfd, finfo->info,
9590
                                     input_bfd, o, contents,
9591
                                     internal_relocs,
9592
                                     isymbuf,
9593
                                     finfo->sections);
9594
          if (!ret)
9595
            return FALSE;
9596
 
9597
          if (ret == 2
9598
              || finfo->info->relocatable
9599
              || finfo->info->emitrelocations)
9600
            {
9601
              Elf_Internal_Rela *irela;
9602
              Elf_Internal_Rela *irelaend, *irelamid;
9603
              bfd_vma last_offset;
9604
              struct elf_link_hash_entry **rel_hash;
9605
              struct elf_link_hash_entry **rel_hash_list, **rela_hash_list;
9606
              Elf_Internal_Shdr *input_rel_hdr, *input_rela_hdr;
9607
              unsigned int next_erel;
9608
              bfd_boolean rela_normal;
9609
              struct bfd_elf_section_data *esdi, *esdo;
9610
 
9611
              esdi = elf_section_data (o);
9612
              esdo = elf_section_data (o->output_section);
9613
              rela_normal = FALSE;
9614
 
9615
              /* Adjust the reloc addresses and symbol indices.  */
9616
 
9617
              irela = internal_relocs;
9618
              irelaend = irela + o->reloc_count * bed->s->int_rels_per_ext_rel;
9619
              rel_hash = esdo->rel.hashes + esdo->rel.count;
9620
              /* We start processing the REL relocs, if any.  When we reach
9621
                 IRELAMID in the loop, we switch to the RELA relocs.  */
9622
              irelamid = irela;
9623
              if (esdi->rel.hdr != NULL)
9624
                irelamid += (NUM_SHDR_ENTRIES (esdi->rel.hdr)
9625
                             * bed->s->int_rels_per_ext_rel);
9626
              rel_hash_list = rel_hash;
9627
              rela_hash_list = NULL;
9628
              last_offset = o->output_offset;
9629
              if (!finfo->info->relocatable)
9630
                last_offset += o->output_section->vma;
9631
              for (next_erel = 0; irela < irelaend; irela++, next_erel++)
9632
                {
9633
                  unsigned long r_symndx;
9634
                  asection *sec;
9635
                  Elf_Internal_Sym sym;
9636
 
9637
                  if (next_erel == bed->s->int_rels_per_ext_rel)
9638
                    {
9639
                      rel_hash++;
9640
                      next_erel = 0;
9641
                    }
9642
 
9643
                  if (irela == irelamid)
9644
                    {
9645
                      rel_hash = esdo->rela.hashes + esdo->rela.count;
9646
                      rela_hash_list = rel_hash;
9647
                      rela_normal = bed->rela_normal;
9648
                    }
9649
 
9650
                  irela->r_offset = _bfd_elf_section_offset (output_bfd,
9651
                                                             finfo->info, o,
9652
                                                             irela->r_offset);
9653
                  if (irela->r_offset >= (bfd_vma) -2)
9654
                    {
9655
                      /* This is a reloc for a deleted entry or somesuch.
9656
                         Turn it into an R_*_NONE reloc, at the same
9657
                         offset as the last reloc.  elf_eh_frame.c and
9658
                         bfd_elf_discard_info rely on reloc offsets
9659
                         being ordered.  */
9660
                      irela->r_offset = last_offset;
9661
                      irela->r_info = 0;
9662
                      irela->r_addend = 0;
9663
                      continue;
9664
                    }
9665
 
9666
                  irela->r_offset += o->output_offset;
9667
 
9668
                  /* Relocs in an executable have to be virtual addresses.  */
9669
                  if (!finfo->info->relocatable)
9670
                    irela->r_offset += o->output_section->vma;
9671
 
9672
                  last_offset = irela->r_offset;
9673
 
9674
                  r_symndx = irela->r_info >> r_sym_shift;
9675
                  if (r_symndx == STN_UNDEF)
9676
                    continue;
9677
 
9678
                  if (r_symndx >= locsymcount
9679
                      || (elf_bad_symtab (input_bfd)
9680
                          && finfo->sections[r_symndx] == NULL))
9681
                    {
9682
                      struct elf_link_hash_entry *rh;
9683
                      unsigned long indx;
9684
 
9685
                      /* This is a reloc against a global symbol.  We
9686
                         have not yet output all the local symbols, so
9687
                         we do not know the symbol index of any global
9688
                         symbol.  We set the rel_hash entry for this
9689
                         reloc to point to the global hash table entry
9690
                         for this symbol.  The symbol index is then
9691
                         set at the end of bfd_elf_final_link.  */
9692
                      indx = r_symndx - extsymoff;
9693
                      rh = elf_sym_hashes (input_bfd)[indx];
9694
                      while (rh->root.type == bfd_link_hash_indirect
9695
                             || rh->root.type == bfd_link_hash_warning)
9696
                        rh = (struct elf_link_hash_entry *) rh->root.u.i.link;
9697
 
9698
                      /* Setting the index to -2 tells
9699
                         elf_link_output_extsym that this symbol is
9700
                         used by a reloc.  */
9701
                      BFD_ASSERT (rh->indx < 0);
9702
                      rh->indx = -2;
9703
 
9704
                      *rel_hash = rh;
9705
 
9706
                      continue;
9707
                    }
9708
 
9709
                  /* This is a reloc against a local symbol.  */
9710
 
9711
                  *rel_hash = NULL;
9712
                  sym = isymbuf[r_symndx];
9713
                  sec = finfo->sections[r_symndx];
9714
                  if (ELF_ST_TYPE (sym.st_info) == STT_SECTION)
9715
                    {
9716
                      /* I suppose the backend ought to fill in the
9717
                         section of any STT_SECTION symbol against a
9718
                         processor specific section.  */
9719
                      r_symndx = STN_UNDEF;
9720
                      if (bfd_is_abs_section (sec))
9721
                        ;
9722
                      else if (sec == NULL || sec->owner == NULL)
9723
                        {
9724
                          bfd_set_error (bfd_error_bad_value);
9725
                          return FALSE;
9726
                        }
9727
                      else
9728
                        {
9729
                          asection *osec = sec->output_section;
9730
 
9731
                          /* If we have discarded a section, the output
9732
                             section will be the absolute section.  In
9733
                             case of discarded SEC_MERGE sections, use
9734
                             the kept section.  relocate_section should
9735
                             have already handled discarded linkonce
9736
                             sections.  */
9737
                          if (bfd_is_abs_section (osec)
9738
                              && sec->kept_section != NULL
9739
                              && sec->kept_section->output_section != NULL)
9740
                            {
9741
                              osec = sec->kept_section->output_section;
9742
                              irela->r_addend -= osec->vma;
9743
                            }
9744
 
9745
                          if (!bfd_is_abs_section (osec))
9746
                            {
9747
                              r_symndx = osec->target_index;
9748
                              if (r_symndx == STN_UNDEF)
9749
                                {
9750
                                  struct elf_link_hash_table *htab;
9751
                                  asection *oi;
9752
 
9753
                                  htab = elf_hash_table (finfo->info);
9754
                                  oi = htab->text_index_section;
9755
                                  if ((osec->flags & SEC_READONLY) == 0
9756
                                      && htab->data_index_section != NULL)
9757
                                    oi = htab->data_index_section;
9758
 
9759
                                  if (oi != NULL)
9760
                                    {
9761
                                      irela->r_addend += osec->vma - oi->vma;
9762
                                      r_symndx = oi->target_index;
9763
                                    }
9764
                                }
9765
 
9766
                              BFD_ASSERT (r_symndx != STN_UNDEF);
9767
                            }
9768
                        }
9769
 
9770
                      /* Adjust the addend according to where the
9771
                         section winds up in the output section.  */
9772
                      if (rela_normal)
9773
                        irela->r_addend += sec->output_offset;
9774
                    }
9775
                  else
9776
                    {
9777
                      if (finfo->indices[r_symndx] == -1)
9778
                        {
9779
                          unsigned long shlink;
9780
                          const char *name;
9781
                          asection *osec;
9782
                          long indx;
9783
 
9784
                          if (finfo->info->strip == strip_all)
9785
                            {
9786
                              /* You can't do ld -r -s.  */
9787
                              bfd_set_error (bfd_error_invalid_operation);
9788
                              return FALSE;
9789
                            }
9790
 
9791
                          /* This symbol was skipped earlier, but
9792
                             since it is needed by a reloc, we
9793
                             must output it now.  */
9794
                          shlink = symtab_hdr->sh_link;
9795
                          name = (bfd_elf_string_from_elf_section
9796
                                  (input_bfd, shlink, sym.st_name));
9797
                          if (name == NULL)
9798
                            return FALSE;
9799
 
9800
                          osec = sec->output_section;
9801
                          sym.st_shndx =
9802
                            _bfd_elf_section_from_bfd_section (output_bfd,
9803
                                                               osec);
9804
                          if (sym.st_shndx == SHN_BAD)
9805
                            return FALSE;
9806
 
9807
                          sym.st_value += sec->output_offset;
9808
                          if (! finfo->info->relocatable)
9809
                            {
9810
                              sym.st_value += osec->vma;
9811
                              if (ELF_ST_TYPE (sym.st_info) == STT_TLS)
9812
                                {
9813
                                  /* STT_TLS symbols are relative to PT_TLS
9814
                                     segment base.  */
9815
                                  BFD_ASSERT (elf_hash_table (finfo->info)
9816
                                              ->tls_sec != NULL);
9817
                                  sym.st_value -= (elf_hash_table (finfo->info)
9818
                                                   ->tls_sec->vma);
9819
                                }
9820
                            }
9821
 
9822
                          indx = bfd_get_symcount (output_bfd);
9823
                          ret = elf_link_output_sym (finfo, name, &sym, sec,
9824
                                                     NULL);
9825
                          if (ret == 0)
9826
                            return FALSE;
9827
                          else if (ret == 1)
9828
                            finfo->indices[r_symndx] = indx;
9829
                          else
9830
                            abort ();
9831
                        }
9832
 
9833
                      r_symndx = finfo->indices[r_symndx];
9834
                    }
9835
 
9836
                  irela->r_info = ((bfd_vma) r_symndx << r_sym_shift
9837
                                   | (irela->r_info & r_type_mask));
9838
                }
9839
 
9840
              /* Swap out the relocs.  */
9841
              input_rel_hdr = esdi->rel.hdr;
9842
              if (input_rel_hdr && input_rel_hdr->sh_size != 0)
9843
                {
9844
                  if (!bed->elf_backend_emit_relocs (output_bfd, o,
9845
                                                     input_rel_hdr,
9846
                                                     internal_relocs,
9847
                                                     rel_hash_list))
9848
                    return FALSE;
9849
                  internal_relocs += (NUM_SHDR_ENTRIES (input_rel_hdr)
9850
                                      * bed->s->int_rels_per_ext_rel);
9851
                  rel_hash_list += NUM_SHDR_ENTRIES (input_rel_hdr);
9852
                }
9853
 
9854
              input_rela_hdr = esdi->rela.hdr;
9855
              if (input_rela_hdr && input_rela_hdr->sh_size != 0)
9856
                {
9857
                  if (!bed->elf_backend_emit_relocs (output_bfd, o,
9858
                                                     input_rela_hdr,
9859
                                                     internal_relocs,
9860
                                                     rela_hash_list))
9861
                    return FALSE;
9862
                }
9863
            }
9864
        }
9865
 
9866
      /* Write out the modified section contents.  */
9867
      if (bed->elf_backend_write_section
9868
          && (*bed->elf_backend_write_section) (output_bfd, finfo->info, o,
9869
                                                contents))
9870
        {
9871
          /* Section written out.  */
9872
        }
9873
      else switch (o->sec_info_type)
9874
        {
9875
        case ELF_INFO_TYPE_STABS:
9876
          if (! (_bfd_write_section_stabs
9877
                 (output_bfd,
9878
                  &elf_hash_table (finfo->info)->stab_info,
9879
                  o, &elf_section_data (o)->sec_info, contents)))
9880
            return FALSE;
9881
          break;
9882
        case ELF_INFO_TYPE_MERGE:
9883
          if (! _bfd_write_merged_section (output_bfd, o,
9884
                                           elf_section_data (o)->sec_info))
9885
            return FALSE;
9886
          break;
9887
        case ELF_INFO_TYPE_EH_FRAME:
9888
          {
9889
            if (! _bfd_elf_write_section_eh_frame (output_bfd, finfo->info,
9890
                                                   o, contents))
9891
              return FALSE;
9892
          }
9893
          break;
9894
        default:
9895
          {
9896
            /* FIXME: octets_per_byte.  */
9897
            if (! (o->flags & SEC_EXCLUDE))
9898
              {
9899
                file_ptr offset = (file_ptr) o->output_offset;
9900
                bfd_size_type todo = o->size;
9901
                if ((o->flags & SEC_ELF_REVERSE_COPY))
9902
                  {
9903
                    /* Reverse-copy input section to output.  */
9904
                    do
9905
                      {
9906
                        todo -= address_size;
9907
                        if (! bfd_set_section_contents (output_bfd,
9908
                                                        o->output_section,
9909
                                                        contents + todo,
9910
                                                        offset,
9911
                                                        address_size))
9912
                          return FALSE;
9913
                        if (todo == 0)
9914
                          break;
9915
                        offset += address_size;
9916
                      }
9917
                    while (1);
9918
                  }
9919
                else if (! bfd_set_section_contents (output_bfd,
9920
                                                     o->output_section,
9921
                                                     contents,
9922
                                                     offset, todo))
9923
                  return FALSE;
9924
              }
9925
          }
9926
          break;
9927
        }
9928
    }
9929
 
9930
  return TRUE;
9931
}
9932
 
9933
/* Generate a reloc when linking an ELF file.  This is a reloc
9934
   requested by the linker, and does not come from any input file.  This
9935
   is used to build constructor and destructor tables when linking
9936
   with -Ur.  */
9937
 
9938
static bfd_boolean
9939
elf_reloc_link_order (bfd *output_bfd,
9940
                      struct bfd_link_info *info,
9941
                      asection *output_section,
9942
                      struct bfd_link_order *link_order)
9943
{
9944
  reloc_howto_type *howto;
9945
  long indx;
9946
  bfd_vma offset;
9947
  bfd_vma addend;
9948
  struct bfd_elf_section_reloc_data *reldata;
9949
  struct elf_link_hash_entry **rel_hash_ptr;
9950
  Elf_Internal_Shdr *rel_hdr;
9951
  const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
9952
  Elf_Internal_Rela irel[MAX_INT_RELS_PER_EXT_REL];
9953
  bfd_byte *erel;
9954
  unsigned int i;
9955
  struct bfd_elf_section_data *esdo = elf_section_data (output_section);
9956
 
9957
  howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
9958
  if (howto == NULL)
9959
    {
9960
      bfd_set_error (bfd_error_bad_value);
9961
      return FALSE;
9962
    }
9963
 
9964
  addend = link_order->u.reloc.p->addend;
9965
 
9966
  if (esdo->rel.hdr)
9967
    reldata = &esdo->rel;
9968
  else if (esdo->rela.hdr)
9969
    reldata = &esdo->rela;
9970
  else
9971
    {
9972
      reldata = NULL;
9973
      BFD_ASSERT (0);
9974
    }
9975
 
9976
  /* Figure out the symbol index.  */
9977
  rel_hash_ptr = reldata->hashes + reldata->count;
9978
  if (link_order->type == bfd_section_reloc_link_order)
9979
    {
9980
      indx = link_order->u.reloc.p->u.section->target_index;
9981
      BFD_ASSERT (indx != 0);
9982
      *rel_hash_ptr = NULL;
9983
    }
9984
  else
9985
    {
9986
      struct elf_link_hash_entry *h;
9987
 
9988
      /* Treat a reloc against a defined symbol as though it were
9989
         actually against the section.  */
9990
      h = ((struct elf_link_hash_entry *)
9991
           bfd_wrapped_link_hash_lookup (output_bfd, info,
9992
                                         link_order->u.reloc.p->u.name,
9993
                                         FALSE, FALSE, TRUE));
9994
      if (h != NULL
9995
          && (h->root.type == bfd_link_hash_defined
9996
              || h->root.type == bfd_link_hash_defweak))
9997
        {
9998
          asection *section;
9999
 
10000
          section = h->root.u.def.section;
10001
          indx = section->output_section->target_index;
10002
          *rel_hash_ptr = NULL;
10003
          /* It seems that we ought to add the symbol value to the
10004
             addend here, but in practice it has already been added
10005
             because it was passed to constructor_callback.  */
10006
          addend += section->output_section->vma + section->output_offset;
10007
        }
10008
      else if (h != NULL)
10009
        {
10010
          /* Setting the index to -2 tells elf_link_output_extsym that
10011
             this symbol is used by a reloc.  */
10012
          h->indx = -2;
10013
          *rel_hash_ptr = h;
10014
          indx = 0;
10015
        }
10016
      else
10017
        {
10018
          if (! ((*info->callbacks->unattached_reloc)
10019
                 (info, link_order->u.reloc.p->u.name, NULL, NULL, 0)))
10020
            return FALSE;
10021
          indx = 0;
10022
        }
10023
    }
10024
 
10025
  /* If this is an inplace reloc, we must write the addend into the
10026
     object file.  */
10027
  if (howto->partial_inplace && addend != 0)
10028
    {
10029
      bfd_size_type size;
10030
      bfd_reloc_status_type rstat;
10031
      bfd_byte *buf;
10032
      bfd_boolean ok;
10033
      const char *sym_name;
10034
 
10035
      size = (bfd_size_type) bfd_get_reloc_size (howto);
10036
      buf = (bfd_byte *) bfd_zmalloc (size);
10037
      if (buf == NULL)
10038
        return FALSE;
10039
      rstat = _bfd_relocate_contents (howto, output_bfd, addend, buf);
10040
      switch (rstat)
10041
        {
10042
        case bfd_reloc_ok:
10043
          break;
10044
 
10045
        default:
10046
        case bfd_reloc_outofrange:
10047
          abort ();
10048
 
10049
        case bfd_reloc_overflow:
10050
          if (link_order->type == bfd_section_reloc_link_order)
10051
            sym_name = bfd_section_name (output_bfd,
10052
                                         link_order->u.reloc.p->u.section);
10053
          else
10054
            sym_name = link_order->u.reloc.p->u.name;
10055
          if (! ((*info->callbacks->reloc_overflow)
10056
                 (info, NULL, sym_name, howto->name, addend, NULL,
10057
                  NULL, (bfd_vma) 0)))
10058
            {
10059
              free (buf);
10060
              return FALSE;
10061
            }
10062
          break;
10063
        }
10064
      ok = bfd_set_section_contents (output_bfd, output_section, buf,
10065
                                     link_order->offset, size);
10066
      free (buf);
10067
      if (! ok)
10068
        return FALSE;
10069
    }
10070
 
10071
  /* The address of a reloc is relative to the section in a
10072
     relocatable file, and is a virtual address in an executable
10073
     file.  */
10074
  offset = link_order->offset;
10075
  if (! info->relocatable)
10076
    offset += output_section->vma;
10077
 
10078
  for (i = 0; i < bed->s->int_rels_per_ext_rel; i++)
10079
    {
10080
      irel[i].r_offset = offset;
10081
      irel[i].r_info = 0;
10082
      irel[i].r_addend = 0;
10083
    }
10084
  if (bed->s->arch_size == 32)
10085
    irel[0].r_info = ELF32_R_INFO (indx, howto->type);
10086
  else
10087
    irel[0].r_info = ELF64_R_INFO (indx, howto->type);
10088
 
10089
  rel_hdr = reldata->hdr;
10090
  erel = rel_hdr->contents;
10091
  if (rel_hdr->sh_type == SHT_REL)
10092
    {
10093
      erel += reldata->count * bed->s->sizeof_rel;
10094
      (*bed->s->swap_reloc_out) (output_bfd, irel, erel);
10095
    }
10096
  else
10097
    {
10098
      irel[0].r_addend = addend;
10099
      erel += reldata->count * bed->s->sizeof_rela;
10100
      (*bed->s->swap_reloca_out) (output_bfd, irel, erel);
10101
    }
10102
 
10103
  ++reldata->count;
10104
 
10105
  return TRUE;
10106
}
10107
 
10108
 
10109
/* Get the output vma of the section pointed to by the sh_link field.  */
10110
 
10111
static bfd_vma
10112
elf_get_linked_section_vma (struct bfd_link_order *p)
10113
{
10114
  Elf_Internal_Shdr **elf_shdrp;
10115
  asection *s;
10116
  int elfsec;
10117
 
10118
  s = p->u.indirect.section;
10119
  elf_shdrp = elf_elfsections (s->owner);
10120
  elfsec = _bfd_elf_section_from_bfd_section (s->owner, s);
10121
  elfsec = elf_shdrp[elfsec]->sh_link;
10122
  /* PR 290:
10123
     The Intel C compiler generates SHT_IA_64_UNWIND with
10124
     SHF_LINK_ORDER.  But it doesn't set the sh_link or
10125
     sh_info fields.  Hence we could get the situation
10126
     where elfsec is 0.  */
10127
  if (elfsec == 0)
10128
    {
10129
      const struct elf_backend_data *bed
10130
        = get_elf_backend_data (s->owner);
10131
      if (bed->link_order_error_handler)
10132
        bed->link_order_error_handler
10133
          (_("%B: warning: sh_link not set for section `%A'"), s->owner, s);
10134
      return 0;
10135
    }
10136
  else
10137
    {
10138
      s = elf_shdrp[elfsec]->bfd_section;
10139
      return s->output_section->vma + s->output_offset;
10140
    }
10141
}
10142
 
10143
 
10144
/* Compare two sections based on the locations of the sections they are
10145
   linked to.  Used by elf_fixup_link_order.  */
10146
 
10147
static int
10148
compare_link_order (const void * a, const void * b)
10149
{
10150
  bfd_vma apos;
10151
  bfd_vma bpos;
10152
 
10153
  apos = elf_get_linked_section_vma (*(struct bfd_link_order **)a);
10154
  bpos = elf_get_linked_section_vma (*(struct bfd_link_order **)b);
10155
  if (apos < bpos)
10156
    return -1;
10157
  return apos > bpos;
10158
}
10159
 
10160
 
10161
/* Looks for sections with SHF_LINK_ORDER set.  Rearranges them into the same
10162
   order as their linked sections.  Returns false if this could not be done
10163
   because an output section includes both ordered and unordered
10164
   sections.  Ideally we'd do this in the linker proper.  */
10165
 
10166
static bfd_boolean
10167
elf_fixup_link_order (bfd *abfd, asection *o)
10168
{
10169
  int seen_linkorder;
10170
  int seen_other;
10171
  int n;
10172
  struct bfd_link_order *p;
10173
  bfd *sub;
10174
  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10175
  unsigned elfsec;
10176
  struct bfd_link_order **sections;
10177
  asection *s, *other_sec, *linkorder_sec;
10178
  bfd_vma offset;
10179
 
10180
  other_sec = NULL;
10181
  linkorder_sec = NULL;
10182
  seen_other = 0;
10183
  seen_linkorder = 0;
10184
  for (p = o->map_head.link_order; p != NULL; p = p->next)
10185
    {
10186
      if (p->type == bfd_indirect_link_order)
10187
        {
10188
          s = p->u.indirect.section;
10189
          sub = s->owner;
10190
          if (bfd_get_flavour (sub) == bfd_target_elf_flavour
10191
              && elf_elfheader (sub)->e_ident[EI_CLASS] == bed->s->elfclass
10192
              && (elfsec = _bfd_elf_section_from_bfd_section (sub, s))
10193
              && elfsec < elf_numsections (sub)
10194
              && elf_elfsections (sub)[elfsec]->sh_flags & SHF_LINK_ORDER
10195
              && elf_elfsections (sub)[elfsec]->sh_link < elf_numsections (sub))
10196
            {
10197
              seen_linkorder++;
10198
              linkorder_sec = s;
10199
            }
10200
          else
10201
            {
10202
              seen_other++;
10203
              other_sec = s;
10204
            }
10205
        }
10206
      else
10207
        seen_other++;
10208
 
10209
      if (seen_other && seen_linkorder)
10210
        {
10211
          if (other_sec && linkorder_sec)
10212
            (*_bfd_error_handler) (_("%A has both ordered [`%A' in %B] and unordered [`%A' in %B] sections"),
10213
                                   o, linkorder_sec,
10214
                                   linkorder_sec->owner, other_sec,
10215
                                   other_sec->owner);
10216
          else
10217
            (*_bfd_error_handler) (_("%A has both ordered and unordered sections"),
10218
                                   o);
10219
          bfd_set_error (bfd_error_bad_value);
10220
          return FALSE;
10221
        }
10222
    }
10223
 
10224
  if (!seen_linkorder)
10225
    return TRUE;
10226
 
10227
  sections = (struct bfd_link_order **)
10228
    bfd_malloc (seen_linkorder * sizeof (struct bfd_link_order *));
10229
  if (sections == NULL)
10230
    return FALSE;
10231
  seen_linkorder = 0;
10232
 
10233
  for (p = o->map_head.link_order; p != NULL; p = p->next)
10234
    {
10235
      sections[seen_linkorder++] = p;
10236
    }
10237
  /* Sort the input sections in the order of their linked section.  */
10238
  qsort (sections, seen_linkorder, sizeof (struct bfd_link_order *),
10239
         compare_link_order);
10240
 
10241
  /* Change the offsets of the sections.  */
10242
  offset = 0;
10243
  for (n = 0; n < seen_linkorder; n++)
10244
    {
10245
      s = sections[n]->u.indirect.section;
10246
      offset &= ~(bfd_vma) 0 << s->alignment_power;
10247
      s->output_offset = offset;
10248
      sections[n]->offset = offset;
10249
      /* FIXME: octets_per_byte.  */
10250
      offset += sections[n]->size;
10251
    }
10252
 
10253
  free (sections);
10254
  return TRUE;
10255
}
10256
 
10257
 
10258
/* Do the final step of an ELF link.  */
10259
 
10260
bfd_boolean
10261
bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
10262
{
10263
  bfd_boolean dynamic;
10264
  bfd_boolean emit_relocs;
10265
  bfd *dynobj;
10266
  struct elf_final_link_info finfo;
10267
  asection *o;
10268
  struct bfd_link_order *p;
10269
  bfd *sub;
10270
  bfd_size_type max_contents_size;
10271
  bfd_size_type max_external_reloc_size;
10272
  bfd_size_type max_internal_reloc_count;
10273
  bfd_size_type max_sym_count;
10274
  bfd_size_type max_sym_shndx_count;
10275
  file_ptr off;
10276
  Elf_Internal_Sym elfsym;
10277
  unsigned int i;
10278
  Elf_Internal_Shdr *symtab_hdr;
10279
  Elf_Internal_Shdr *symtab_shndx_hdr;
10280
  Elf_Internal_Shdr *symstrtab_hdr;
10281
  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10282
  struct elf_outext_info eoinfo;
10283
  bfd_boolean merged;
10284
  size_t relativecount = 0;
10285
  asection *reldyn = 0;
10286
  bfd_size_type amt;
10287
  asection *attr_section = NULL;
10288
  bfd_vma attr_size = 0;
10289
  const char *std_attrs_section;
10290
 
10291
  if (! is_elf_hash_table (info->hash))
10292
    return FALSE;
10293
 
10294
  if (info->shared)
10295
    abfd->flags |= DYNAMIC;
10296
 
10297
  dynamic = elf_hash_table (info)->dynamic_sections_created;
10298
  dynobj = elf_hash_table (info)->dynobj;
10299
 
10300
  emit_relocs = (info->relocatable
10301
                 || info->emitrelocations);
10302
 
10303
  finfo.info = info;
10304
  finfo.output_bfd = abfd;
10305
  finfo.symstrtab = _bfd_elf_stringtab_init ();
10306
  if (finfo.symstrtab == NULL)
10307
    return FALSE;
10308
 
10309
  if (! dynamic)
10310
    {
10311
      finfo.dynsym_sec = NULL;
10312
      finfo.hash_sec = NULL;
10313
      finfo.symver_sec = NULL;
10314
    }
10315
  else
10316
    {
10317
      finfo.dynsym_sec = bfd_get_section_by_name (dynobj, ".dynsym");
10318
      finfo.hash_sec = bfd_get_section_by_name (dynobj, ".hash");
10319
      BFD_ASSERT (finfo.dynsym_sec != NULL);
10320
      finfo.symver_sec = bfd_get_section_by_name (dynobj, ".gnu.version");
10321
      /* Note that it is OK if symver_sec is NULL.  */
10322
    }
10323
 
10324
  finfo.contents = NULL;
10325
  finfo.external_relocs = NULL;
10326
  finfo.internal_relocs = NULL;
10327
  finfo.external_syms = NULL;
10328
  finfo.locsym_shndx = NULL;
10329
  finfo.internal_syms = NULL;
10330
  finfo.indices = NULL;
10331
  finfo.sections = NULL;
10332
  finfo.symbuf = NULL;
10333
  finfo.symshndxbuf = NULL;
10334
  finfo.symbuf_count = 0;
10335
  finfo.shndxbuf_size = 0;
10336
 
10337
  /* The object attributes have been merged.  Remove the input
10338
     sections from the link, and set the contents of the output
10339
     secton.  */
10340
  std_attrs_section = get_elf_backend_data (abfd)->obj_attrs_section;
10341
  for (o = abfd->sections; o != NULL; o = o->next)
10342
    {
10343
      if ((std_attrs_section && strcmp (o->name, std_attrs_section) == 0)
10344
          || strcmp (o->name, ".gnu.attributes") == 0)
10345
        {
10346
          for (p = o->map_head.link_order; p != NULL; p = p->next)
10347
            {
10348
              asection *input_section;
10349
 
10350
              if (p->type != bfd_indirect_link_order)
10351
                continue;
10352
              input_section = p->u.indirect.section;
10353
              /* Hack: reset the SEC_HAS_CONTENTS flag so that
10354
                 elf_link_input_bfd ignores this section.  */
10355
              input_section->flags &= ~SEC_HAS_CONTENTS;
10356
            }
10357
 
10358
          attr_size = bfd_elf_obj_attr_size (abfd);
10359
          if (attr_size)
10360
            {
10361
              bfd_set_section_size (abfd, o, attr_size);
10362
              attr_section = o;
10363
              /* Skip this section later on.  */
10364
              o->map_head.link_order = NULL;
10365
            }
10366
          else
10367
            o->flags |= SEC_EXCLUDE;
10368
        }
10369
    }
10370
 
10371
  /* Count up the number of relocations we will output for each output
10372
     section, so that we know the sizes of the reloc sections.  We
10373
     also figure out some maximum sizes.  */
10374
  max_contents_size = 0;
10375
  max_external_reloc_size = 0;
10376
  max_internal_reloc_count = 0;
10377
  max_sym_count = 0;
10378
  max_sym_shndx_count = 0;
10379
  merged = FALSE;
10380
  for (o = abfd->sections; o != NULL; o = o->next)
10381
    {
10382
      struct bfd_elf_section_data *esdo = elf_section_data (o);
10383
      o->reloc_count = 0;
10384
 
10385
      for (p = o->map_head.link_order; p != NULL; p = p->next)
10386
        {
10387
          unsigned int reloc_count = 0;
10388
          struct bfd_elf_section_data *esdi = NULL;
10389
 
10390
          if (p->type == bfd_section_reloc_link_order
10391
              || p->type == bfd_symbol_reloc_link_order)
10392
            reloc_count = 1;
10393
          else if (p->type == bfd_indirect_link_order)
10394
            {
10395
              asection *sec;
10396
 
10397
              sec = p->u.indirect.section;
10398
              esdi = elf_section_data (sec);
10399
 
10400
              /* Mark all sections which are to be included in the
10401
                 link.  This will normally be every section.  We need
10402
                 to do this so that we can identify any sections which
10403
                 the linker has decided to not include.  */
10404
              sec->linker_mark = TRUE;
10405
 
10406
              if (sec->flags & SEC_MERGE)
10407
                merged = TRUE;
10408
 
10409
              if (info->relocatable || info->emitrelocations)
10410
                reloc_count = sec->reloc_count;
10411
              else if (bed->elf_backend_count_relocs)
10412
                reloc_count = (*bed->elf_backend_count_relocs) (info, sec);
10413
 
10414
              if (sec->rawsize > max_contents_size)
10415
                max_contents_size = sec->rawsize;
10416
              if (sec->size > max_contents_size)
10417
                max_contents_size = sec->size;
10418
 
10419
              /* We are interested in just local symbols, not all
10420
                 symbols.  */
10421
              if (bfd_get_flavour (sec->owner) == bfd_target_elf_flavour
10422
                  && (sec->owner->flags & DYNAMIC) == 0)
10423
                {
10424
                  size_t sym_count;
10425
 
10426
                  if (elf_bad_symtab (sec->owner))
10427
                    sym_count = (elf_tdata (sec->owner)->symtab_hdr.sh_size
10428
                                 / bed->s->sizeof_sym);
10429
                  else
10430
                    sym_count = elf_tdata (sec->owner)->symtab_hdr.sh_info;
10431
 
10432
                  if (sym_count > max_sym_count)
10433
                    max_sym_count = sym_count;
10434
 
10435
                  if (sym_count > max_sym_shndx_count
10436
                      && elf_symtab_shndx (sec->owner) != 0)
10437
                    max_sym_shndx_count = sym_count;
10438
 
10439
                  if ((sec->flags & SEC_RELOC) != 0)
10440
                    {
10441
                      size_t ext_size = 0;
10442
 
10443
                      if (esdi->rel.hdr != NULL)
10444
                        ext_size = esdi->rel.hdr->sh_size;
10445
                      if (esdi->rela.hdr != NULL)
10446
                        ext_size += esdi->rela.hdr->sh_size;
10447
 
10448
                      if (ext_size > max_external_reloc_size)
10449
                        max_external_reloc_size = ext_size;
10450
                      if (sec->reloc_count > max_internal_reloc_count)
10451
                        max_internal_reloc_count = sec->reloc_count;
10452
                    }
10453
                }
10454
            }
10455
 
10456
          if (reloc_count == 0)
10457
            continue;
10458
 
10459
          o->reloc_count += reloc_count;
10460
 
10461
          if (p->type == bfd_indirect_link_order
10462
              && (info->relocatable || info->emitrelocations))
10463
            {
10464
              if (esdi->rel.hdr)
10465
                esdo->rel.count += NUM_SHDR_ENTRIES (esdi->rel.hdr);
10466
              if (esdi->rela.hdr)
10467
                esdo->rela.count += NUM_SHDR_ENTRIES (esdi->rela.hdr);
10468
            }
10469
          else
10470
            {
10471
              if (o->use_rela_p)
10472
                esdo->rela.count += reloc_count;
10473
              else
10474
                esdo->rel.count += reloc_count;
10475
            }
10476
        }
10477
 
10478
      if (o->reloc_count > 0)
10479
        o->flags |= SEC_RELOC;
10480
      else
10481
        {
10482
          /* Explicitly clear the SEC_RELOC flag.  The linker tends to
10483
             set it (this is probably a bug) and if it is set
10484
             assign_section_numbers will create a reloc section.  */
10485
          o->flags &=~ SEC_RELOC;
10486
        }
10487
 
10488
      /* If the SEC_ALLOC flag is not set, force the section VMA to
10489
         zero.  This is done in elf_fake_sections as well, but forcing
10490
         the VMA to 0 here will ensure that relocs against these
10491
         sections are handled correctly.  */
10492
      if ((o->flags & SEC_ALLOC) == 0
10493
          && ! o->user_set_vma)
10494
        o->vma = 0;
10495
    }
10496
 
10497
  if (! info->relocatable && merged)
10498
    elf_link_hash_traverse (elf_hash_table (info),
10499
                            _bfd_elf_link_sec_merge_syms, abfd);
10500
 
10501
  /* Figure out the file positions for everything but the symbol table
10502
     and the relocs.  We set symcount to force assign_section_numbers
10503
     to create a symbol table.  */
10504
  bfd_get_symcount (abfd) = info->strip == strip_all ? 0 : 1;
10505
  BFD_ASSERT (! abfd->output_has_begun);
10506
  if (! _bfd_elf_compute_section_file_positions (abfd, info))
10507
    goto error_return;
10508
 
10509
  /* Set sizes, and assign file positions for reloc sections.  */
10510
  for (o = abfd->sections; o != NULL; o = o->next)
10511
    {
10512
      struct bfd_elf_section_data *esdo = elf_section_data (o);
10513
      if ((o->flags & SEC_RELOC) != 0)
10514
        {
10515
          if (esdo->rel.hdr
10516
              && !(_bfd_elf_link_size_reloc_section (abfd, &esdo->rel)))
10517
            goto error_return;
10518
 
10519
          if (esdo->rela.hdr
10520
              && !(_bfd_elf_link_size_reloc_section (abfd, &esdo->rela)))
10521
            goto error_return;
10522
        }
10523
 
10524
      /* Now, reset REL_COUNT and REL_COUNT2 so that we can use them
10525
         to count upwards while actually outputting the relocations.  */
10526
      esdo->rel.count = 0;
10527
      esdo->rela.count = 0;
10528
    }
10529
 
10530
  _bfd_elf_assign_file_positions_for_relocs (abfd);
10531
 
10532
  /* We have now assigned file positions for all the sections except
10533
     .symtab and .strtab.  We start the .symtab section at the current
10534
     file position, and write directly to it.  We build the .strtab
10535
     section in memory.  */
10536
  bfd_get_symcount (abfd) = 0;
10537
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10538
  /* sh_name is set in prep_headers.  */
10539
  symtab_hdr->sh_type = SHT_SYMTAB;
10540
  /* sh_flags, sh_addr and sh_size all start off zero.  */
10541
  symtab_hdr->sh_entsize = bed->s->sizeof_sym;
10542
  /* sh_link is set in assign_section_numbers.  */
10543
  /* sh_info is set below.  */
10544
  /* sh_offset is set just below.  */
10545
  symtab_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
10546
 
10547
  off = elf_tdata (abfd)->next_file_pos;
10548
  off = _bfd_elf_assign_file_position_for_section (symtab_hdr, off, TRUE);
10549
 
10550
  /* Note that at this point elf_tdata (abfd)->next_file_pos is
10551
     incorrect.  We do not yet know the size of the .symtab section.
10552
     We correct next_file_pos below, after we do know the size.  */
10553
 
10554
  /* Allocate a buffer to hold swapped out symbols.  This is to avoid
10555
     continuously seeking to the right position in the file.  */
10556
  if (! info->keep_memory || max_sym_count < 20)
10557
    finfo.symbuf_size = 20;
10558
  else
10559
    finfo.symbuf_size = max_sym_count;
10560
  amt = finfo.symbuf_size;
10561
  amt *= bed->s->sizeof_sym;
10562
  finfo.symbuf = (bfd_byte *) bfd_malloc (amt);
10563
  if (finfo.symbuf == NULL)
10564
    goto error_return;
10565
  if (elf_numsections (abfd) > (SHN_LORESERVE & 0xFFFF))
10566
    {
10567
      /* Wild guess at number of output symbols.  realloc'd as needed.  */
10568
      amt = 2 * max_sym_count + elf_numsections (abfd) + 1000;
10569
      finfo.shndxbuf_size = amt;
10570
      amt *= sizeof (Elf_External_Sym_Shndx);
10571
      finfo.symshndxbuf = (Elf_External_Sym_Shndx *) bfd_zmalloc (amt);
10572
      if (finfo.symshndxbuf == NULL)
10573
        goto error_return;
10574
    }
10575
 
10576
  /* Start writing out the symbol table.  The first symbol is always a
10577
     dummy symbol.  */
10578
  if (info->strip != strip_all
10579
      || emit_relocs)
10580
    {
10581
      elfsym.st_value = 0;
10582
      elfsym.st_size = 0;
10583
      elfsym.st_info = 0;
10584
      elfsym.st_other = 0;
10585
      elfsym.st_shndx = SHN_UNDEF;
10586
      elfsym.st_target_internal = 0;
10587
      if (elf_link_output_sym (&finfo, NULL, &elfsym, bfd_und_section_ptr,
10588
                               NULL) != 1)
10589
        goto error_return;
10590
    }
10591
 
10592
  /* Output a symbol for each section.  We output these even if we are
10593
     discarding local symbols, since they are used for relocs.  These
10594
     symbols have no names.  We store the index of each one in the
10595
     index field of the section, so that we can find it again when
10596
     outputting relocs.  */
10597
  if (info->strip != strip_all
10598
      || emit_relocs)
10599
    {
10600
      elfsym.st_size = 0;
10601
      elfsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
10602
      elfsym.st_other = 0;
10603
      elfsym.st_value = 0;
10604
      elfsym.st_target_internal = 0;
10605
      for (i = 1; i < elf_numsections (abfd); i++)
10606
        {
10607
          o = bfd_section_from_elf_index (abfd, i);
10608
          if (o != NULL)
10609
            {
10610
              o->target_index = bfd_get_symcount (abfd);
10611
              elfsym.st_shndx = i;
10612
              if (!info->relocatable)
10613
                elfsym.st_value = o->vma;
10614
              if (elf_link_output_sym (&finfo, NULL, &elfsym, o, NULL) != 1)
10615
                goto error_return;
10616
            }
10617
        }
10618
    }
10619
 
10620
  /* Allocate some memory to hold information read in from the input
10621
     files.  */
10622
  if (max_contents_size != 0)
10623
    {
10624
      finfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
10625
      if (finfo.contents == NULL)
10626
        goto error_return;
10627
    }
10628
 
10629
  if (max_external_reloc_size != 0)
10630
    {
10631
      finfo.external_relocs = bfd_malloc (max_external_reloc_size);
10632
      if (finfo.external_relocs == NULL)
10633
        goto error_return;
10634
    }
10635
 
10636
  if (max_internal_reloc_count != 0)
10637
    {
10638
      amt = max_internal_reloc_count * bed->s->int_rels_per_ext_rel;
10639
      amt *= sizeof (Elf_Internal_Rela);
10640
      finfo.internal_relocs = (Elf_Internal_Rela *) bfd_malloc (amt);
10641
      if (finfo.internal_relocs == NULL)
10642
        goto error_return;
10643
    }
10644
 
10645
  if (max_sym_count != 0)
10646
    {
10647
      amt = max_sym_count * bed->s->sizeof_sym;
10648
      finfo.external_syms = (bfd_byte *) bfd_malloc (amt);
10649
      if (finfo.external_syms == NULL)
10650
        goto error_return;
10651
 
10652
      amt = max_sym_count * sizeof (Elf_Internal_Sym);
10653
      finfo.internal_syms = (Elf_Internal_Sym *) bfd_malloc (amt);
10654
      if (finfo.internal_syms == NULL)
10655
        goto error_return;
10656
 
10657
      amt = max_sym_count * sizeof (long);
10658
      finfo.indices = (long int *) bfd_malloc (amt);
10659
      if (finfo.indices == NULL)
10660
        goto error_return;
10661
 
10662
      amt = max_sym_count * sizeof (asection *);
10663
      finfo.sections = (asection **) bfd_malloc (amt);
10664
      if (finfo.sections == NULL)
10665
        goto error_return;
10666
    }
10667
 
10668
  if (max_sym_shndx_count != 0)
10669
    {
10670
      amt = max_sym_shndx_count * sizeof (Elf_External_Sym_Shndx);
10671
      finfo.locsym_shndx = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
10672
      if (finfo.locsym_shndx == NULL)
10673
        goto error_return;
10674
    }
10675
 
10676
  if (elf_hash_table (info)->tls_sec)
10677
    {
10678
      bfd_vma base, end = 0;
10679
      asection *sec;
10680
 
10681
      for (sec = elf_hash_table (info)->tls_sec;
10682
           sec && (sec->flags & SEC_THREAD_LOCAL);
10683
           sec = sec->next)
10684
        {
10685
          bfd_size_type size = sec->size;
10686
 
10687
          if (size == 0
10688
              && (sec->flags & SEC_HAS_CONTENTS) == 0)
10689
            {
10690
              struct bfd_link_order *ord = sec->map_tail.link_order;
10691
 
10692
              if (ord != NULL)
10693
                size = ord->offset + ord->size;
10694
            }
10695
          end = sec->vma + size;
10696
        }
10697
      base = elf_hash_table (info)->tls_sec->vma;
10698
      /* Only align end of TLS section if static TLS doesn't have special
10699
         alignment requirements.  */
10700
      if (bed->static_tls_alignment == 1)
10701
        end = align_power (end,
10702
                           elf_hash_table (info)->tls_sec->alignment_power);
10703
      elf_hash_table (info)->tls_size = end - base;
10704
    }
10705
 
10706
  /* Reorder SHF_LINK_ORDER sections.  */
10707
  for (o = abfd->sections; o != NULL; o = o->next)
10708
    {
10709
      if (!elf_fixup_link_order (abfd, o))
10710
        return FALSE;
10711
    }
10712
 
10713
  /* Since ELF permits relocations to be against local symbols, we
10714
     must have the local symbols available when we do the relocations.
10715
     Since we would rather only read the local symbols once, and we
10716
     would rather not keep them in memory, we handle all the
10717
     relocations for a single input file at the same time.
10718
 
10719
     Unfortunately, there is no way to know the total number of local
10720
     symbols until we have seen all of them, and the local symbol
10721
     indices precede the global symbol indices.  This means that when
10722
     we are generating relocatable output, and we see a reloc against
10723
     a global symbol, we can not know the symbol index until we have
10724
     finished examining all the local symbols to see which ones we are
10725
     going to output.  To deal with this, we keep the relocations in
10726
     memory, and don't output them until the end of the link.  This is
10727
     an unfortunate waste of memory, but I don't see a good way around
10728
     it.  Fortunately, it only happens when performing a relocatable
10729
     link, which is not the common case.  FIXME: If keep_memory is set
10730
     we could write the relocs out and then read them again; I don't
10731
     know how bad the memory loss will be.  */
10732
 
10733
  for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
10734
    sub->output_has_begun = FALSE;
10735
  for (o = abfd->sections; o != NULL; o = o->next)
10736
    {
10737
      for (p = o->map_head.link_order; p != NULL; p = p->next)
10738
        {
10739
          if (p->type == bfd_indirect_link_order
10740
              && (bfd_get_flavour ((sub = p->u.indirect.section->owner))
10741
                  == bfd_target_elf_flavour)
10742
              && elf_elfheader (sub)->e_ident[EI_CLASS] == bed->s->elfclass)
10743
            {
10744
              if (! sub->output_has_begun)
10745
                {
10746
                  if (! elf_link_input_bfd (&finfo, sub))
10747
                    goto error_return;
10748
                  sub->output_has_begun = TRUE;
10749
                }
10750
            }
10751
          else if (p->type == bfd_section_reloc_link_order
10752
                   || p->type == bfd_symbol_reloc_link_order)
10753
            {
10754
              if (! elf_reloc_link_order (abfd, info, o, p))
10755
                goto error_return;
10756
            }
10757
          else
10758
            {
10759
              if (! _bfd_default_link_order (abfd, info, o, p))
10760
                {
10761
                  if (p->type == bfd_indirect_link_order
10762
                      && (bfd_get_flavour (sub)
10763
                          == bfd_target_elf_flavour)
10764
                      && (elf_elfheader (sub)->e_ident[EI_CLASS]
10765
                          != bed->s->elfclass))
10766
                    {
10767
                      const char *iclass, *oclass;
10768
 
10769
                      if (bed->s->elfclass == ELFCLASS64)
10770
                        {
10771
                          iclass = "ELFCLASS32";
10772
                          oclass = "ELFCLASS64";
10773
                        }
10774
                      else
10775
                        {
10776
                          iclass = "ELFCLASS64";
10777
                          oclass = "ELFCLASS32";
10778
                        }
10779
 
10780
                      bfd_set_error (bfd_error_wrong_format);
10781
                      (*_bfd_error_handler)
10782
                        (_("%B: file class %s incompatible with %s"),
10783
                         sub, iclass, oclass);
10784
                    }
10785
 
10786
                  goto error_return;
10787
                }
10788
            }
10789
        }
10790
    }
10791
 
10792
  /* Free symbol buffer if needed.  */
10793
  if (!info->reduce_memory_overheads)
10794
    {
10795
      for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
10796
        if (bfd_get_flavour (sub) == bfd_target_elf_flavour
10797
            && elf_tdata (sub)->symbuf)
10798
          {
10799
            free (elf_tdata (sub)->symbuf);
10800
            elf_tdata (sub)->symbuf = NULL;
10801
          }
10802
    }
10803
 
10804
  /* Output any global symbols that got converted to local in a
10805
     version script or due to symbol visibility.  We do this in a
10806
     separate step since ELF requires all local symbols to appear
10807
     prior to any global symbols.  FIXME: We should only do this if
10808
     some global symbols were, in fact, converted to become local.
10809
     FIXME: Will this work correctly with the Irix 5 linker?  */
10810
  eoinfo.failed = FALSE;
10811
  eoinfo.finfo = &finfo;
10812
  eoinfo.localsyms = TRUE;
10813 148 khays
  bfd_hash_traverse (&info->hash->table, elf_link_output_extsym, &eoinfo);
10814 14 khays
  if (eoinfo.failed)
10815
    return FALSE;
10816
 
10817
  /* If backend needs to output some local symbols not present in the hash
10818
     table, do it now.  */
10819
  if (bed->elf_backend_output_arch_local_syms)
10820
    {
10821
      typedef int (*out_sym_func)
10822
        (void *, const char *, Elf_Internal_Sym *, asection *,
10823
         struct elf_link_hash_entry *);
10824
 
10825
      if (! ((*bed->elf_backend_output_arch_local_syms)
10826
             (abfd, info, &finfo, (out_sym_func) elf_link_output_sym)))
10827
        return FALSE;
10828
    }
10829
 
10830
  /* That wrote out all the local symbols.  Finish up the symbol table
10831
     with the global symbols. Even if we want to strip everything we
10832
     can, we still need to deal with those global symbols that got
10833
     converted to local in a version script.  */
10834
 
10835
  /* The sh_info field records the index of the first non local symbol.  */
10836
  symtab_hdr->sh_info = bfd_get_symcount (abfd);
10837
 
10838
  if (dynamic
10839
      && finfo.dynsym_sec->output_section != bfd_abs_section_ptr)
10840
    {
10841
      Elf_Internal_Sym sym;
10842
      bfd_byte *dynsym = finfo.dynsym_sec->contents;
10843
      long last_local = 0;
10844
 
10845
      /* Write out the section symbols for the output sections.  */
10846
      if (info->shared || elf_hash_table (info)->is_relocatable_executable)
10847
        {
10848
          asection *s;
10849
 
10850
          sym.st_size = 0;
10851
          sym.st_name = 0;
10852
          sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
10853
          sym.st_other = 0;
10854
          sym.st_target_internal = 0;
10855
 
10856
          for (s = abfd->sections; s != NULL; s = s->next)
10857
            {
10858
              int indx;
10859
              bfd_byte *dest;
10860
              long dynindx;
10861
 
10862
              dynindx = elf_section_data (s)->dynindx;
10863
              if (dynindx <= 0)
10864
                continue;
10865
              indx = elf_section_data (s)->this_idx;
10866
              BFD_ASSERT (indx > 0);
10867
              sym.st_shndx = indx;
10868
              if (! check_dynsym (abfd, &sym))
10869
                return FALSE;
10870
              sym.st_value = s->vma;
10871
              dest = dynsym + dynindx * bed->s->sizeof_sym;
10872
              if (last_local < dynindx)
10873
                last_local = dynindx;
10874
              bed->s->swap_symbol_out (abfd, &sym, dest, 0);
10875
            }
10876
        }
10877
 
10878
      /* Write out the local dynsyms.  */
10879
      if (elf_hash_table (info)->dynlocal)
10880
        {
10881
          struct elf_link_local_dynamic_entry *e;
10882
          for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
10883
            {
10884
              asection *s;
10885
              bfd_byte *dest;
10886
 
10887
              /* Copy the internal symbol and turn off visibility.
10888
                 Note that we saved a word of storage and overwrote
10889
                 the original st_name with the dynstr_index.  */
10890
              sym = e->isym;
10891
              sym.st_other &= ~ELF_ST_VISIBILITY (-1);
10892
 
10893
              s = bfd_section_from_elf_index (e->input_bfd,
10894
                                              e->isym.st_shndx);
10895
              if (s != NULL)
10896
                {
10897
                  sym.st_shndx =
10898
                    elf_section_data (s->output_section)->this_idx;
10899
                  if (! check_dynsym (abfd, &sym))
10900
                    return FALSE;
10901
                  sym.st_value = (s->output_section->vma
10902
                                  + s->output_offset
10903
                                  + e->isym.st_value);
10904
                }
10905
 
10906
              if (last_local < e->dynindx)
10907
                last_local = e->dynindx;
10908
 
10909
              dest = dynsym + e->dynindx * bed->s->sizeof_sym;
10910
              bed->s->swap_symbol_out (abfd, &sym, dest, 0);
10911
            }
10912
        }
10913
 
10914
      elf_section_data (finfo.dynsym_sec->output_section)->this_hdr.sh_info =
10915
        last_local + 1;
10916
    }
10917
 
10918
  /* We get the global symbols from the hash table.  */
10919
  eoinfo.failed = FALSE;
10920
  eoinfo.localsyms = FALSE;
10921
  eoinfo.finfo = &finfo;
10922 148 khays
  bfd_hash_traverse (&info->hash->table, elf_link_output_extsym, &eoinfo);
10923 14 khays
  if (eoinfo.failed)
10924
    return FALSE;
10925
 
10926
  /* If backend needs to output some symbols not present in the hash
10927
     table, do it now.  */
10928
  if (bed->elf_backend_output_arch_syms)
10929
    {
10930
      typedef int (*out_sym_func)
10931
        (void *, const char *, Elf_Internal_Sym *, asection *,
10932
         struct elf_link_hash_entry *);
10933
 
10934
      if (! ((*bed->elf_backend_output_arch_syms)
10935
             (abfd, info, &finfo, (out_sym_func) elf_link_output_sym)))
10936
        return FALSE;
10937
    }
10938
 
10939
  /* Flush all symbols to the file.  */
10940
  if (! elf_link_flush_output_syms (&finfo, bed))
10941
    return FALSE;
10942
 
10943
  /* Now we know the size of the symtab section.  */
10944
  off += symtab_hdr->sh_size;
10945
 
10946
  symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
10947
  if (symtab_shndx_hdr->sh_name != 0)
10948
    {
10949
      symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
10950
      symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
10951
      symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
10952
      amt = bfd_get_symcount (abfd) * sizeof (Elf_External_Sym_Shndx);
10953
      symtab_shndx_hdr->sh_size = amt;
10954
 
10955
      off = _bfd_elf_assign_file_position_for_section (symtab_shndx_hdr,
10956
                                                       off, TRUE);
10957
 
10958
      if (bfd_seek (abfd, symtab_shndx_hdr->sh_offset, SEEK_SET) != 0
10959
          || (bfd_bwrite (finfo.symshndxbuf, amt, abfd) != amt))
10960
        return FALSE;
10961
    }
10962
 
10963
 
10964
  /* Finish up and write out the symbol string table (.strtab)
10965
     section.  */
10966
  symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
10967
  /* sh_name was set in prep_headers.  */
10968
  symstrtab_hdr->sh_type = SHT_STRTAB;
10969
  symstrtab_hdr->sh_flags = 0;
10970
  symstrtab_hdr->sh_addr = 0;
10971
  symstrtab_hdr->sh_size = _bfd_stringtab_size (finfo.symstrtab);
10972
  symstrtab_hdr->sh_entsize = 0;
10973
  symstrtab_hdr->sh_link = 0;
10974
  symstrtab_hdr->sh_info = 0;
10975
  /* sh_offset is set just below.  */
10976
  symstrtab_hdr->sh_addralign = 1;
10977
 
10978
  off = _bfd_elf_assign_file_position_for_section (symstrtab_hdr, off, TRUE);
10979
  elf_tdata (abfd)->next_file_pos = off;
10980
 
10981
  if (bfd_get_symcount (abfd) > 0)
10982
    {
10983
      if (bfd_seek (abfd, symstrtab_hdr->sh_offset, SEEK_SET) != 0
10984
          || ! _bfd_stringtab_emit (abfd, finfo.symstrtab))
10985
        return FALSE;
10986
    }
10987
 
10988
  /* Adjust the relocs to have the correct symbol indices.  */
10989
  for (o = abfd->sections; o != NULL; o = o->next)
10990
    {
10991
      struct bfd_elf_section_data *esdo = elf_section_data (o);
10992
      if ((o->flags & SEC_RELOC) == 0)
10993
        continue;
10994
 
10995
      if (esdo->rel.hdr != NULL)
10996
        elf_link_adjust_relocs (abfd, &esdo->rel);
10997
      if (esdo->rela.hdr != NULL)
10998
        elf_link_adjust_relocs (abfd, &esdo->rela);
10999
 
11000
      /* Set the reloc_count field to 0 to prevent write_relocs from
11001
         trying to swap the relocs out itself.  */
11002
      o->reloc_count = 0;
11003
    }
11004
 
11005
  if (dynamic && info->combreloc && dynobj != NULL)
11006
    relativecount = elf_link_sort_relocs (abfd, info, &reldyn);
11007
 
11008
  /* If we are linking against a dynamic object, or generating a
11009
     shared library, finish up the dynamic linking information.  */
11010
  if (dynamic)
11011
    {
11012
      bfd_byte *dyncon, *dynconend;
11013
 
11014
      /* Fix up .dynamic entries.  */
11015
      o = bfd_get_section_by_name (dynobj, ".dynamic");
11016
      BFD_ASSERT (o != NULL);
11017
 
11018
      dyncon = o->contents;
11019
      dynconend = o->contents + o->size;
11020
      for (; dyncon < dynconend; dyncon += bed->s->sizeof_dyn)
11021
        {
11022
          Elf_Internal_Dyn dyn;
11023
          const char *name;
11024
          unsigned int type;
11025
 
11026
          bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
11027
 
11028
          switch (dyn.d_tag)
11029
            {
11030
            default:
11031
              continue;
11032
            case DT_NULL:
11033
              if (relativecount > 0 && dyncon + bed->s->sizeof_dyn < dynconend)
11034
                {
11035
                  switch (elf_section_data (reldyn)->this_hdr.sh_type)
11036
                    {
11037
                    case SHT_REL: dyn.d_tag = DT_RELCOUNT; break;
11038
                    case SHT_RELA: dyn.d_tag = DT_RELACOUNT; break;
11039
                    default: continue;
11040
                    }
11041
                  dyn.d_un.d_val = relativecount;
11042
                  relativecount = 0;
11043
                  break;
11044
                }
11045
              continue;
11046
 
11047
            case DT_INIT:
11048
              name = info->init_function;
11049
              goto get_sym;
11050
            case DT_FINI:
11051
              name = info->fini_function;
11052
            get_sym:
11053
              {
11054
                struct elf_link_hash_entry *h;
11055
 
11056
                h = elf_link_hash_lookup (elf_hash_table (info), name,
11057
                                          FALSE, FALSE, TRUE);
11058
                if (h != NULL
11059
                    && (h->root.type == bfd_link_hash_defined
11060
                        || h->root.type == bfd_link_hash_defweak))
11061
                  {
11062
                    dyn.d_un.d_ptr = h->root.u.def.value;
11063
                    o = h->root.u.def.section;
11064
                    if (o->output_section != NULL)
11065
                      dyn.d_un.d_ptr += (o->output_section->vma
11066
                                         + o->output_offset);
11067
                    else
11068
                      {
11069
                        /* The symbol is imported from another shared
11070
                           library and does not apply to this one.  */
11071
                        dyn.d_un.d_ptr = 0;
11072
                      }
11073
                    break;
11074
                  }
11075
              }
11076
              continue;
11077
 
11078
            case DT_PREINIT_ARRAYSZ:
11079
              name = ".preinit_array";
11080
              goto get_size;
11081
            case DT_INIT_ARRAYSZ:
11082
              name = ".init_array";
11083
              goto get_size;
11084
            case DT_FINI_ARRAYSZ:
11085
              name = ".fini_array";
11086
            get_size:
11087
              o = bfd_get_section_by_name (abfd, name);
11088
              if (o == NULL)
11089
                {
11090
                  (*_bfd_error_handler)
11091
                    (_("%B: could not find output section %s"), abfd, name);
11092
                  goto error_return;
11093
                }
11094
              if (o->size == 0)
11095
                (*_bfd_error_handler)
11096
                  (_("warning: %s section has zero size"), name);
11097
              dyn.d_un.d_val = o->size;
11098
              break;
11099
 
11100
            case DT_PREINIT_ARRAY:
11101
              name = ".preinit_array";
11102
              goto get_vma;
11103
            case DT_INIT_ARRAY:
11104
              name = ".init_array";
11105
              goto get_vma;
11106
            case DT_FINI_ARRAY:
11107
              name = ".fini_array";
11108
              goto get_vma;
11109
 
11110
            case DT_HASH:
11111
              name = ".hash";
11112
              goto get_vma;
11113
            case DT_GNU_HASH:
11114
              name = ".gnu.hash";
11115
              goto get_vma;
11116
            case DT_STRTAB:
11117
              name = ".dynstr";
11118
              goto get_vma;
11119
            case DT_SYMTAB:
11120
              name = ".dynsym";
11121
              goto get_vma;
11122
            case DT_VERDEF:
11123
              name = ".gnu.version_d";
11124
              goto get_vma;
11125
            case DT_VERNEED:
11126
              name = ".gnu.version_r";
11127
              goto get_vma;
11128
            case DT_VERSYM:
11129
              name = ".gnu.version";
11130
            get_vma:
11131
              o = bfd_get_section_by_name (abfd, name);
11132
              if (o == NULL)
11133
                {
11134
                  (*_bfd_error_handler)
11135
                    (_("%B: could not find output section %s"), abfd, name);
11136
                  goto error_return;
11137
                }
11138 148 khays
              if (elf_section_data (o->output_section)->this_hdr.sh_type == SHT_NOTE)
11139
                {
11140
                  (*_bfd_error_handler)
11141
                    (_("warning: section '%s' is being made into a note"), name);
11142
                  bfd_set_error (bfd_error_nonrepresentable_section);
11143
                  goto error_return;
11144
                }
11145 14 khays
              dyn.d_un.d_ptr = o->vma;
11146
              break;
11147
 
11148
            case DT_REL:
11149
            case DT_RELA:
11150
            case DT_RELSZ:
11151
            case DT_RELASZ:
11152
              if (dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ)
11153
                type = SHT_REL;
11154
              else
11155
                type = SHT_RELA;
11156
              dyn.d_un.d_val = 0;
11157
              dyn.d_un.d_ptr = 0;
11158
              for (i = 1; i < elf_numsections (abfd); i++)
11159
                {
11160
                  Elf_Internal_Shdr *hdr;
11161
 
11162
                  hdr = elf_elfsections (abfd)[i];
11163
                  if (hdr->sh_type == type
11164
                      && (hdr->sh_flags & SHF_ALLOC) != 0)
11165
                    {
11166
                      if (dyn.d_tag == DT_RELSZ || dyn.d_tag == DT_RELASZ)
11167
                        dyn.d_un.d_val += hdr->sh_size;
11168
                      else
11169
                        {
11170
                          if (dyn.d_un.d_ptr == 0
11171
                              || hdr->sh_addr < dyn.d_un.d_ptr)
11172
                            dyn.d_un.d_ptr = hdr->sh_addr;
11173
                        }
11174
                    }
11175
                }
11176
              break;
11177
            }
11178
          bed->s->swap_dyn_out (dynobj, &dyn, dyncon);
11179
        }
11180
    }
11181
 
11182
  /* If we have created any dynamic sections, then output them.  */
11183
  if (dynobj != NULL)
11184
    {
11185
      if (! (*bed->elf_backend_finish_dynamic_sections) (abfd, info))
11186
        goto error_return;
11187
 
11188
      /* Check for DT_TEXTREL (late, in case the backend removes it).  */
11189 166 khays
      if (((info->warn_shared_textrel && info->shared)
11190
           || info->error_textrel)
11191
          && (o = bfd_get_section_by_name (dynobj, ".dynamic")) != NULL)
11192 14 khays
        {
11193
          bfd_byte *dyncon, *dynconend;
11194
 
11195
          dyncon = o->contents;
11196
          dynconend = o->contents + o->size;
11197
          for (; dyncon < dynconend; dyncon += bed->s->sizeof_dyn)
11198
            {
11199
              Elf_Internal_Dyn dyn;
11200
 
11201
              bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
11202
 
11203
              if (dyn.d_tag == DT_TEXTREL)
11204
                {
11205 163 khays
                  if (info->error_textrel)
11206
                    info->callbacks->einfo
11207
                      (_("%P%X: read-only segment has dynamic relocations.\n"));
11208
                  else
11209
                    info->callbacks->einfo
11210
                      (_("%P: warning: creating a DT_TEXTREL in a shared object.\n"));
11211 14 khays
                  break;
11212
                }
11213
            }
11214
        }
11215
 
11216
      for (o = dynobj->sections; o != NULL; o = o->next)
11217
        {
11218
          if ((o->flags & SEC_HAS_CONTENTS) == 0
11219
              || o->size == 0
11220
              || o->output_section == bfd_abs_section_ptr)
11221
            continue;
11222
          if ((o->flags & SEC_LINKER_CREATED) == 0)
11223
            {
11224
              /* At this point, we are only interested in sections
11225
                 created by _bfd_elf_link_create_dynamic_sections.  */
11226
              continue;
11227
            }
11228
          if (elf_hash_table (info)->stab_info.stabstr == o)
11229
            continue;
11230
          if (elf_hash_table (info)->eh_info.hdr_sec == o)
11231
            continue;
11232
          if ((elf_section_data (o->output_section)->this_hdr.sh_type
11233
               != SHT_STRTAB)
11234 148 khays
              && (strcmp (bfd_get_section_name (abfd, o), ".dynstr") != 0))
11235 14 khays
            {
11236
              /* FIXME: octets_per_byte.  */
11237
              if (! bfd_set_section_contents (abfd, o->output_section,
11238
                                              o->contents,
11239
                                              (file_ptr) o->output_offset,
11240
                                              o->size))
11241
                goto error_return;
11242
            }
11243
          else
11244
            {
11245
              /* The contents of the .dynstr section are actually in a
11246
                 stringtab.  */
11247
              off = elf_section_data (o->output_section)->this_hdr.sh_offset;
11248
              if (bfd_seek (abfd, off, SEEK_SET) != 0
11249
                  || ! _bfd_elf_strtab_emit (abfd,
11250
                                             elf_hash_table (info)->dynstr))
11251
                goto error_return;
11252
            }
11253
        }
11254
    }
11255
 
11256
  if (info->relocatable)
11257
    {
11258
      bfd_boolean failed = FALSE;
11259
 
11260
      bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
11261
      if (failed)
11262
        goto error_return;
11263
    }
11264
 
11265
  /* If we have optimized stabs strings, output them.  */
11266
  if (elf_hash_table (info)->stab_info.stabstr != NULL)
11267
    {
11268
      if (! _bfd_write_stab_strings (abfd, &elf_hash_table (info)->stab_info))
11269
        goto error_return;
11270
    }
11271
 
11272
  if (info->eh_frame_hdr)
11273
    {
11274
      if (! _bfd_elf_write_section_eh_frame_hdr (abfd, info))
11275
        goto error_return;
11276
    }
11277
 
11278
  if (finfo.symstrtab != NULL)
11279
    _bfd_stringtab_free (finfo.symstrtab);
11280
  if (finfo.contents != NULL)
11281
    free (finfo.contents);
11282
  if (finfo.external_relocs != NULL)
11283
    free (finfo.external_relocs);
11284
  if (finfo.internal_relocs != NULL)
11285
    free (finfo.internal_relocs);
11286
  if (finfo.external_syms != NULL)
11287
    free (finfo.external_syms);
11288
  if (finfo.locsym_shndx != NULL)
11289
    free (finfo.locsym_shndx);
11290
  if (finfo.internal_syms != NULL)
11291
    free (finfo.internal_syms);
11292
  if (finfo.indices != NULL)
11293
    free (finfo.indices);
11294
  if (finfo.sections != NULL)
11295
    free (finfo.sections);
11296
  if (finfo.symbuf != NULL)
11297
    free (finfo.symbuf);
11298
  if (finfo.symshndxbuf != NULL)
11299
    free (finfo.symshndxbuf);
11300
  for (o = abfd->sections; o != NULL; o = o->next)
11301
    {
11302
      struct bfd_elf_section_data *esdo = elf_section_data (o);
11303
      if ((o->flags & SEC_RELOC) != 0 && esdo->rel.hashes != NULL)
11304
        free (esdo->rel.hashes);
11305
      if ((o->flags & SEC_RELOC) != 0 && esdo->rela.hashes != NULL)
11306
        free (esdo->rela.hashes);
11307
    }
11308
 
11309
  elf_tdata (abfd)->linker = TRUE;
11310
 
11311
  if (attr_section)
11312
    {
11313
      bfd_byte *contents = (bfd_byte *) bfd_malloc (attr_size);
11314
      if (contents == NULL)
11315
        return FALSE;   /* Bail out and fail.  */
11316
      bfd_elf_set_obj_attr_contents (abfd, contents, attr_size);
11317
      bfd_set_section_contents (abfd, attr_section, contents, 0, attr_size);
11318
      free (contents);
11319
    }
11320
 
11321
  return TRUE;
11322
 
11323
 error_return:
11324
  if (finfo.symstrtab != NULL)
11325
    _bfd_stringtab_free (finfo.symstrtab);
11326
  if (finfo.contents != NULL)
11327
    free (finfo.contents);
11328
  if (finfo.external_relocs != NULL)
11329
    free (finfo.external_relocs);
11330
  if (finfo.internal_relocs != NULL)
11331
    free (finfo.internal_relocs);
11332
  if (finfo.external_syms != NULL)
11333
    free (finfo.external_syms);
11334
  if (finfo.locsym_shndx != NULL)
11335
    free (finfo.locsym_shndx);
11336
  if (finfo.internal_syms != NULL)
11337
    free (finfo.internal_syms);
11338
  if (finfo.indices != NULL)
11339
    free (finfo.indices);
11340
  if (finfo.sections != NULL)
11341
    free (finfo.sections);
11342
  if (finfo.symbuf != NULL)
11343
    free (finfo.symbuf);
11344
  if (finfo.symshndxbuf != NULL)
11345
    free (finfo.symshndxbuf);
11346
  for (o = abfd->sections; o != NULL; o = o->next)
11347
    {
11348
      struct bfd_elf_section_data *esdo = elf_section_data (o);
11349
      if ((o->flags & SEC_RELOC) != 0 && esdo->rel.hashes != NULL)
11350
        free (esdo->rel.hashes);
11351
      if ((o->flags & SEC_RELOC) != 0 && esdo->rela.hashes != NULL)
11352
        free (esdo->rela.hashes);
11353
    }
11354
 
11355
  return FALSE;
11356
}
11357
 
11358
/* Initialize COOKIE for input bfd ABFD.  */
11359
 
11360
static bfd_boolean
11361
init_reloc_cookie (struct elf_reloc_cookie *cookie,
11362
                   struct bfd_link_info *info, bfd *abfd)
11363
{
11364
  Elf_Internal_Shdr *symtab_hdr;
11365
  const struct elf_backend_data *bed;
11366
 
11367
  bed = get_elf_backend_data (abfd);
11368
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
11369
 
11370
  cookie->abfd = abfd;
11371
  cookie->sym_hashes = elf_sym_hashes (abfd);
11372
  cookie->bad_symtab = elf_bad_symtab (abfd);
11373
  if (cookie->bad_symtab)
11374
    {
11375
      cookie->locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym;
11376
      cookie->extsymoff = 0;
11377
    }
11378
  else
11379
    {
11380
      cookie->locsymcount = symtab_hdr->sh_info;
11381
      cookie->extsymoff = symtab_hdr->sh_info;
11382
    }
11383
 
11384
  if (bed->s->arch_size == 32)
11385
    cookie->r_sym_shift = 8;
11386
  else
11387
    cookie->r_sym_shift = 32;
11388
 
11389
  cookie->locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
11390
  if (cookie->locsyms == NULL && cookie->locsymcount != 0)
11391
    {
11392
      cookie->locsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr,
11393
                                              cookie->locsymcount, 0,
11394
                                              NULL, NULL, NULL);
11395
      if (cookie->locsyms == NULL)
11396
        {
11397
          info->callbacks->einfo (_("%P%X: can not read symbols: %E\n"));
11398
          return FALSE;
11399
        }
11400
      if (info->keep_memory)
11401
        symtab_hdr->contents = (bfd_byte *) cookie->locsyms;
11402
    }
11403
  return TRUE;
11404
}
11405
 
11406
/* Free the memory allocated by init_reloc_cookie, if appropriate.  */
11407
 
11408
static void
11409
fini_reloc_cookie (struct elf_reloc_cookie *cookie, bfd *abfd)
11410
{
11411
  Elf_Internal_Shdr *symtab_hdr;
11412
 
11413
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
11414
  if (cookie->locsyms != NULL
11415
      && symtab_hdr->contents != (unsigned char *) cookie->locsyms)
11416
    free (cookie->locsyms);
11417
}
11418
 
11419
/* Initialize the relocation information in COOKIE for input section SEC
11420
   of input bfd ABFD.  */
11421
 
11422
static bfd_boolean
11423
init_reloc_cookie_rels (struct elf_reloc_cookie *cookie,
11424
                        struct bfd_link_info *info, bfd *abfd,
11425
                        asection *sec)
11426
{
11427
  const struct elf_backend_data *bed;
11428
 
11429
  if (sec->reloc_count == 0)
11430
    {
11431
      cookie->rels = NULL;
11432
      cookie->relend = NULL;
11433
    }
11434
  else
11435
    {
11436
      bed = get_elf_backend_data (abfd);
11437
 
11438
      cookie->rels = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
11439
                                                info->keep_memory);
11440
      if (cookie->rels == NULL)
11441
        return FALSE;
11442
      cookie->rel = cookie->rels;
11443
      cookie->relend = (cookie->rels
11444
                        + sec->reloc_count * bed->s->int_rels_per_ext_rel);
11445
    }
11446
  cookie->rel = cookie->rels;
11447
  return TRUE;
11448
}
11449
 
11450
/* Free the memory allocated by init_reloc_cookie_rels,
11451
   if appropriate.  */
11452
 
11453
static void
11454
fini_reloc_cookie_rels (struct elf_reloc_cookie *cookie,
11455
                        asection *sec)
11456
{
11457
  if (cookie->rels && elf_section_data (sec)->relocs != cookie->rels)
11458
    free (cookie->rels);
11459
}
11460
 
11461
/* Initialize the whole of COOKIE for input section SEC.  */
11462
 
11463
static bfd_boolean
11464
init_reloc_cookie_for_section (struct elf_reloc_cookie *cookie,
11465
                               struct bfd_link_info *info,
11466
                               asection *sec)
11467
{
11468
  if (!init_reloc_cookie (cookie, info, sec->owner))
11469
    goto error1;
11470
  if (!init_reloc_cookie_rels (cookie, info, sec->owner, sec))
11471
    goto error2;
11472
  return TRUE;
11473
 
11474
 error2:
11475
  fini_reloc_cookie (cookie, sec->owner);
11476
 error1:
11477
  return FALSE;
11478
}
11479
 
11480
/* Free the memory allocated by init_reloc_cookie_for_section,
11481
   if appropriate.  */
11482
 
11483
static void
11484
fini_reloc_cookie_for_section (struct elf_reloc_cookie *cookie,
11485
                               asection *sec)
11486
{
11487
  fini_reloc_cookie_rels (cookie, sec);
11488
  fini_reloc_cookie (cookie, sec->owner);
11489
}
11490
 
11491
/* Garbage collect unused sections.  */
11492
 
11493
/* Default gc_mark_hook.  */
11494
 
11495
asection *
11496
_bfd_elf_gc_mark_hook (asection *sec,
11497
                       struct bfd_link_info *info ATTRIBUTE_UNUSED,
11498
                       Elf_Internal_Rela *rel ATTRIBUTE_UNUSED,
11499
                       struct elf_link_hash_entry *h,
11500
                       Elf_Internal_Sym *sym)
11501
{
11502
  const char *sec_name;
11503
 
11504
  if (h != NULL)
11505
    {
11506
      switch (h->root.type)
11507
        {
11508
        case bfd_link_hash_defined:
11509
        case bfd_link_hash_defweak:
11510
          return h->root.u.def.section;
11511
 
11512
        case bfd_link_hash_common:
11513
          return h->root.u.c.p->section;
11514
 
11515
        case bfd_link_hash_undefined:
11516
        case bfd_link_hash_undefweak:
11517
          /* To work around a glibc bug, keep all XXX input sections
11518
             when there is an as yet undefined reference to __start_XXX
11519
             or __stop_XXX symbols.  The linker will later define such
11520
             symbols for orphan input sections that have a name
11521
             representable as a C identifier.  */
11522
          if (strncmp (h->root.root.string, "__start_", 8) == 0)
11523
            sec_name = h->root.root.string + 8;
11524
          else if (strncmp (h->root.root.string, "__stop_", 7) == 0)
11525
            sec_name = h->root.root.string + 7;
11526
          else
11527
            sec_name = NULL;
11528
 
11529
          if (sec_name && *sec_name != '\0')
11530
            {
11531
              bfd *i;
11532
 
11533
              for (i = info->input_bfds; i; i = i->link_next)
11534
                {
11535
                  sec = bfd_get_section_by_name (i, sec_name);
11536
                  if (sec)
11537
                    sec->flags |= SEC_KEEP;
11538
                }
11539
            }
11540
          break;
11541
 
11542
        default:
11543
          break;
11544
        }
11545
    }
11546
  else
11547
    return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
11548
 
11549
  return NULL;
11550
}
11551
 
11552
/* COOKIE->rel describes a relocation against section SEC, which is
11553
   a section we've decided to keep.  Return the section that contains
11554
   the relocation symbol, or NULL if no section contains it.  */
11555
 
11556
asection *
11557
_bfd_elf_gc_mark_rsec (struct bfd_link_info *info, asection *sec,
11558
                       elf_gc_mark_hook_fn gc_mark_hook,
11559
                       struct elf_reloc_cookie *cookie)
11560
{
11561
  unsigned long r_symndx;
11562
  struct elf_link_hash_entry *h;
11563
 
11564
  r_symndx = cookie->rel->r_info >> cookie->r_sym_shift;
11565
  if (r_symndx == STN_UNDEF)
11566
    return NULL;
11567
 
11568
  if (r_symndx >= cookie->locsymcount
11569
      || ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL)
11570
    {
11571
      h = cookie->sym_hashes[r_symndx - cookie->extsymoff];
11572
      while (h->root.type == bfd_link_hash_indirect
11573
             || h->root.type == bfd_link_hash_warning)
11574
        h = (struct elf_link_hash_entry *) h->root.u.i.link;
11575 163 khays
      h->mark = 1;
11576 166 khays
      /* If this symbol is weak and there is a non-weak definition, we
11577
         keep the non-weak definition because many backends put
11578
         dynamic reloc info on the non-weak definition for code
11579
         handling copy relocs.  */
11580
      if (h->u.weakdef != NULL)
11581
        h->u.weakdef->mark = 1;
11582 14 khays
      return (*gc_mark_hook) (sec, info, cookie->rel, h, NULL);
11583
    }
11584
 
11585
  return (*gc_mark_hook) (sec, info, cookie->rel, NULL,
11586
                          &cookie->locsyms[r_symndx]);
11587
}
11588
 
11589
/* COOKIE->rel describes a relocation against section SEC, which is
11590
   a section we've decided to keep.  Mark the section that contains
11591
   the relocation symbol.  */
11592
 
11593
bfd_boolean
11594
_bfd_elf_gc_mark_reloc (struct bfd_link_info *info,
11595
                        asection *sec,
11596
                        elf_gc_mark_hook_fn gc_mark_hook,
11597
                        struct elf_reloc_cookie *cookie)
11598
{
11599
  asection *rsec;
11600
 
11601
  rsec = _bfd_elf_gc_mark_rsec (info, sec, gc_mark_hook, cookie);
11602
  if (rsec && !rsec->gc_mark)
11603
    {
11604
      if (bfd_get_flavour (rsec->owner) != bfd_target_elf_flavour)
11605
        rsec->gc_mark = 1;
11606
      else if (!_bfd_elf_gc_mark (info, rsec, gc_mark_hook))
11607
        return FALSE;
11608
    }
11609
  return TRUE;
11610
}
11611
 
11612
/* The mark phase of garbage collection.  For a given section, mark
11613
   it and any sections in this section's group, and all the sections
11614
   which define symbols to which it refers.  */
11615
 
11616
bfd_boolean
11617
_bfd_elf_gc_mark (struct bfd_link_info *info,
11618
                  asection *sec,
11619
                  elf_gc_mark_hook_fn gc_mark_hook)
11620
{
11621
  bfd_boolean ret;
11622
  asection *group_sec, *eh_frame;
11623
 
11624
  sec->gc_mark = 1;
11625
 
11626
  /* Mark all the sections in the group.  */
11627
  group_sec = elf_section_data (sec)->next_in_group;
11628
  if (group_sec && !group_sec->gc_mark)
11629
    if (!_bfd_elf_gc_mark (info, group_sec, gc_mark_hook))
11630
      return FALSE;
11631
 
11632
  /* Look through the section relocs.  */
11633
  ret = TRUE;
11634
  eh_frame = elf_eh_frame_section (sec->owner);
11635
  if ((sec->flags & SEC_RELOC) != 0
11636
      && sec->reloc_count > 0
11637
      && sec != eh_frame)
11638
    {
11639
      struct elf_reloc_cookie cookie;
11640
 
11641
      if (!init_reloc_cookie_for_section (&cookie, info, sec))
11642
        ret = FALSE;
11643
      else
11644
        {
11645
          for (; cookie.rel < cookie.relend; cookie.rel++)
11646
            if (!_bfd_elf_gc_mark_reloc (info, sec, gc_mark_hook, &cookie))
11647
              {
11648
                ret = FALSE;
11649
                break;
11650
              }
11651
          fini_reloc_cookie_for_section (&cookie, sec);
11652
        }
11653
    }
11654
 
11655
  if (ret && eh_frame && elf_fde_list (sec))
11656
    {
11657
      struct elf_reloc_cookie cookie;
11658
 
11659
      if (!init_reloc_cookie_for_section (&cookie, info, eh_frame))
11660
        ret = FALSE;
11661
      else
11662
        {
11663
          if (!_bfd_elf_gc_mark_fdes (info, sec, eh_frame,
11664
                                      gc_mark_hook, &cookie))
11665
            ret = FALSE;
11666
          fini_reloc_cookie_for_section (&cookie, eh_frame);
11667
        }
11668
    }
11669
 
11670
  return ret;
11671
}
11672
 
11673 161 khays
/* Keep debug and special sections.  */
11674
 
11675
bfd_boolean
11676
_bfd_elf_gc_mark_extra_sections (struct bfd_link_info *info,
11677
                                 elf_gc_mark_hook_fn mark_hook ATTRIBUTE_UNUSED)
11678
{
11679
  bfd *ibfd;
11680
 
11681
  for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11682
    {
11683
      asection *isec;
11684
      bfd_boolean some_kept;
11685
 
11686
      if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
11687
        continue;
11688
 
11689
      /* Ensure all linker created sections are kept, and see whether
11690
         any other section is already marked.  */
11691
      some_kept = FALSE;
11692
      for (isec = ibfd->sections; isec != NULL; isec = isec->next)
11693
        {
11694
          if ((isec->flags & SEC_LINKER_CREATED) != 0)
11695
            isec->gc_mark = 1;
11696
          else if (isec->gc_mark)
11697
            some_kept = TRUE;
11698
        }
11699
 
11700
      /* If no section in this file will be kept, then we can
11701
         toss out debug sections.  */
11702
      if (!some_kept)
11703
        continue;
11704
 
11705
      /* Keep debug and special sections like .comment when they are
11706 163 khays
         not part of a group, or when we have single-member groups.  */
11707 161 khays
      for (isec = ibfd->sections; isec != NULL; isec = isec->next)
11708 163 khays
        if ((elf_next_in_group (isec) == NULL
11709
             || elf_next_in_group (isec) == isec)
11710 161 khays
            && ((isec->flags & SEC_DEBUGGING) != 0
11711
                || (isec->flags & (SEC_ALLOC | SEC_LOAD | SEC_RELOC)) == 0))
11712
          isec->gc_mark = 1;
11713
    }
11714
  return TRUE;
11715
}
11716
 
11717 14 khays
/* Sweep symbols in swept sections.  Called via elf_link_hash_traverse.  */
11718
 
11719
struct elf_gc_sweep_symbol_info
11720
{
11721
  struct bfd_link_info *info;
11722
  void (*hide_symbol) (struct bfd_link_info *, struct elf_link_hash_entry *,
11723
                       bfd_boolean);
11724
};
11725
 
11726
static bfd_boolean
11727
elf_gc_sweep_symbol (struct elf_link_hash_entry *h, void *data)
11728
{
11729 163 khays
  if (!h->mark
11730
      && (((h->root.type == bfd_link_hash_defined
11731
            || h->root.type == bfd_link_hash_defweak)
11732 166 khays
           && !(h->def_regular
11733
                && h->root.u.def.section->gc_mark))
11734 163 khays
          || h->root.type == bfd_link_hash_undefined
11735
          || h->root.type == bfd_link_hash_undefweak))
11736 14 khays
    {
11737 163 khays
      struct elf_gc_sweep_symbol_info *inf;
11738
 
11739
      inf = (struct elf_gc_sweep_symbol_info *) data;
11740 14 khays
      (*inf->hide_symbol) (inf->info, h, TRUE);
11741 163 khays
      h->def_regular = 0;
11742
      h->ref_regular = 0;
11743
      h->ref_regular_nonweak = 0;
11744 14 khays
    }
11745
 
11746
  return TRUE;
11747
}
11748
 
11749
/* The sweep phase of garbage collection.  Remove all garbage sections.  */
11750
 
11751
typedef bfd_boolean (*gc_sweep_hook_fn)
11752
  (bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *);
11753
 
11754
static bfd_boolean
11755
elf_gc_sweep (bfd *abfd, struct bfd_link_info *info)
11756
{
11757
  bfd *sub;
11758
  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
11759
  gc_sweep_hook_fn gc_sweep_hook = bed->gc_sweep_hook;
11760
  unsigned long section_sym_count;
11761
  struct elf_gc_sweep_symbol_info sweep_info;
11762
 
11763
  for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
11764
    {
11765
      asection *o;
11766
 
11767
      if (bfd_get_flavour (sub) != bfd_target_elf_flavour)
11768
        continue;
11769
 
11770
      for (o = sub->sections; o != NULL; o = o->next)
11771
        {
11772
          /* When any section in a section group is kept, we keep all
11773
             sections in the section group.  If the first member of
11774
             the section group is excluded, we will also exclude the
11775
             group section.  */
11776
          if (o->flags & SEC_GROUP)
11777
            {
11778
              asection *first = elf_next_in_group (o);
11779
              o->gc_mark = first->gc_mark;
11780
            }
11781
 
11782
          if (o->gc_mark)
11783
            continue;
11784
 
11785
          /* Skip sweeping sections already excluded.  */
11786
          if (o->flags & SEC_EXCLUDE)
11787
            continue;
11788
 
11789
          /* Since this is early in the link process, it is simple
11790
             to remove a section from the output.  */
11791
          o->flags |= SEC_EXCLUDE;
11792
 
11793
          if (info->print_gc_sections && o->size != 0)
11794
            _bfd_error_handler (_("Removing unused section '%s' in file '%B'"), sub, o->name);
11795
 
11796
          /* But we also have to update some of the relocation
11797
             info we collected before.  */
11798
          if (gc_sweep_hook
11799
              && (o->flags & SEC_RELOC) != 0
11800
              && o->reloc_count > 0
11801
              && !bfd_is_abs_section (o->output_section))
11802
            {
11803
              Elf_Internal_Rela *internal_relocs;
11804
              bfd_boolean r;
11805
 
11806
              internal_relocs
11807
                = _bfd_elf_link_read_relocs (o->owner, o, NULL, NULL,
11808
                                             info->keep_memory);
11809
              if (internal_relocs == NULL)
11810
                return FALSE;
11811
 
11812
              r = (*gc_sweep_hook) (o->owner, info, o, internal_relocs);
11813
 
11814
              if (elf_section_data (o)->relocs != internal_relocs)
11815
                free (internal_relocs);
11816
 
11817
              if (!r)
11818
                return FALSE;
11819
            }
11820
        }
11821
    }
11822
 
11823
  /* Remove the symbols that were in the swept sections from the dynamic
11824
     symbol table.  GCFIXME: Anyone know how to get them out of the
11825
     static symbol table as well?  */
11826
  sweep_info.info = info;
11827
  sweep_info.hide_symbol = bed->elf_backend_hide_symbol;
11828
  elf_link_hash_traverse (elf_hash_table (info), elf_gc_sweep_symbol,
11829
                          &sweep_info);
11830
 
11831
  _bfd_elf_link_renumber_dynsyms (abfd, info, &section_sym_count);
11832
  return TRUE;
11833
}
11834
 
11835
/* Propagate collected vtable information.  This is called through
11836
   elf_link_hash_traverse.  */
11837
 
11838
static bfd_boolean
11839
elf_gc_propagate_vtable_entries_used (struct elf_link_hash_entry *h, void *okp)
11840
{
11841
  /* Those that are not vtables.  */
11842
  if (h->vtable == NULL || h->vtable->parent == NULL)
11843
    return TRUE;
11844
 
11845
  /* Those vtables that do not have parents, we cannot merge.  */
11846
  if (h->vtable->parent == (struct elf_link_hash_entry *) -1)
11847
    return TRUE;
11848
 
11849
  /* If we've already been done, exit.  */
11850
  if (h->vtable->used && h->vtable->used[-1])
11851
    return TRUE;
11852
 
11853
  /* Make sure the parent's table is up to date.  */
11854
  elf_gc_propagate_vtable_entries_used (h->vtable->parent, okp);
11855
 
11856
  if (h->vtable->used == NULL)
11857
    {
11858
      /* None of this table's entries were referenced.  Re-use the
11859
         parent's table.  */
11860
      h->vtable->used = h->vtable->parent->vtable->used;
11861
      h->vtable->size = h->vtable->parent->vtable->size;
11862
    }
11863
  else
11864
    {
11865
      size_t n;
11866
      bfd_boolean *cu, *pu;
11867
 
11868
      /* Or the parent's entries into ours.  */
11869
      cu = h->vtable->used;
11870
      cu[-1] = TRUE;
11871
      pu = h->vtable->parent->vtable->used;
11872
      if (pu != NULL)
11873
        {
11874
          const struct elf_backend_data *bed;
11875
          unsigned int log_file_align;
11876
 
11877
          bed = get_elf_backend_data (h->root.u.def.section->owner);
11878
          log_file_align = bed->s->log_file_align;
11879
          n = h->vtable->parent->vtable->size >> log_file_align;
11880
          while (n--)
11881
            {
11882
              if (*pu)
11883
                *cu = TRUE;
11884
              pu++;
11885
              cu++;
11886
            }
11887
        }
11888
    }
11889
 
11890
  return TRUE;
11891
}
11892
 
11893
static bfd_boolean
11894
elf_gc_smash_unused_vtentry_relocs (struct elf_link_hash_entry *h, void *okp)
11895
{
11896
  asection *sec;
11897
  bfd_vma hstart, hend;
11898
  Elf_Internal_Rela *relstart, *relend, *rel;
11899
  const struct elf_backend_data *bed;
11900
  unsigned int log_file_align;
11901
 
11902
  /* Take care of both those symbols that do not describe vtables as
11903
     well as those that are not loaded.  */
11904
  if (h->vtable == NULL || h->vtable->parent == NULL)
11905
    return TRUE;
11906
 
11907
  BFD_ASSERT (h->root.type == bfd_link_hash_defined
11908
              || h->root.type == bfd_link_hash_defweak);
11909
 
11910
  sec = h->root.u.def.section;
11911
  hstart = h->root.u.def.value;
11912
  hend = hstart + h->size;
11913
 
11914
  relstart = _bfd_elf_link_read_relocs (sec->owner, sec, NULL, NULL, TRUE);
11915
  if (!relstart)
11916
    return *(bfd_boolean *) okp = FALSE;
11917
  bed = get_elf_backend_data (sec->owner);
11918
  log_file_align = bed->s->log_file_align;
11919
 
11920
  relend = relstart + sec->reloc_count * bed->s->int_rels_per_ext_rel;
11921
 
11922
  for (rel = relstart; rel < relend; ++rel)
11923
    if (rel->r_offset >= hstart && rel->r_offset < hend)
11924
      {
11925
        /* If the entry is in use, do nothing.  */
11926
        if (h->vtable->used
11927
            && (rel->r_offset - hstart) < h->vtable->size)
11928
          {
11929
            bfd_vma entry = (rel->r_offset - hstart) >> log_file_align;
11930
            if (h->vtable->used[entry])
11931
              continue;
11932
          }
11933
        /* Otherwise, kill it.  */
11934
        rel->r_offset = rel->r_info = rel->r_addend = 0;
11935
      }
11936
 
11937
  return TRUE;
11938
}
11939
 
11940
/* Mark sections containing dynamically referenced symbols.  When
11941
   building shared libraries, we must assume that any visible symbol is
11942
   referenced.  */
11943
 
11944
bfd_boolean
11945
bfd_elf_gc_mark_dynamic_ref_symbol (struct elf_link_hash_entry *h, void *inf)
11946
{
11947
  struct bfd_link_info *info = (struct bfd_link_info *) inf;
11948
 
11949
  if ((h->root.type == bfd_link_hash_defined
11950
       || h->root.type == bfd_link_hash_defweak)
11951
      && (h->ref_dynamic
11952 163 khays
          || ((!info->executable || info->export_dynamic)
11953 14 khays
              && h->def_regular
11954
              && ELF_ST_VISIBILITY (h->other) != STV_INTERNAL
11955 163 khays
              && ELF_ST_VISIBILITY (h->other) != STV_HIDDEN
11956
              && (strchr (h->root.root.string, ELF_VER_CHR) != NULL
11957
                  || !bfd_hide_sym_by_version (info->version_info,
11958
                                               h->root.root.string)))))
11959 14 khays
    h->root.u.def.section->flags |= SEC_KEEP;
11960
 
11961
  return TRUE;
11962
}
11963
 
11964
/* Keep all sections containing symbols undefined on the command-line,
11965
   and the section containing the entry symbol.  */
11966
 
11967
void
11968
_bfd_elf_gc_keep (struct bfd_link_info *info)
11969
{
11970
  struct bfd_sym_chain *sym;
11971
 
11972
  for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
11973
    {
11974
      struct elf_link_hash_entry *h;
11975
 
11976
      h = elf_link_hash_lookup (elf_hash_table (info), sym->name,
11977
                                FALSE, FALSE, FALSE);
11978
 
11979
      if (h != NULL
11980
          && (h->root.type == bfd_link_hash_defined
11981
              || h->root.type == bfd_link_hash_defweak)
11982
          && !bfd_is_abs_section (h->root.u.def.section))
11983
        h->root.u.def.section->flags |= SEC_KEEP;
11984
    }
11985
}
11986
 
11987
/* Do mark and sweep of unused sections.  */
11988
 
11989
bfd_boolean
11990
bfd_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
11991
{
11992
  bfd_boolean ok = TRUE;
11993
  bfd *sub;
11994
  elf_gc_mark_hook_fn gc_mark_hook;
11995
  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
11996
 
11997
  if (!bed->can_gc_sections
11998
      || !is_elf_hash_table (info->hash))
11999
    {
12000
      (*_bfd_error_handler)(_("Warning: gc-sections option ignored"));
12001
      return TRUE;
12002
    }
12003
 
12004
  bed->gc_keep (info);
12005
 
12006
  /* Try to parse each bfd's .eh_frame section.  Point elf_eh_frame_section
12007
     at the .eh_frame section if we can mark the FDEs individually.  */
12008
  _bfd_elf_begin_eh_frame_parsing (info);
12009
  for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
12010
    {
12011
      asection *sec;
12012
      struct elf_reloc_cookie cookie;
12013
 
12014
      sec = bfd_get_section_by_name (sub, ".eh_frame");
12015
      if (sec && init_reloc_cookie_for_section (&cookie, info, sec))
12016
        {
12017
          _bfd_elf_parse_eh_frame (sub, info, sec, &cookie);
12018
          if (elf_section_data (sec)->sec_info)
12019
            elf_eh_frame_section (sub) = sec;
12020
          fini_reloc_cookie_for_section (&cookie, sec);
12021
        }
12022
    }
12023
  _bfd_elf_end_eh_frame_parsing (info);
12024
 
12025
  /* Apply transitive closure to the vtable entry usage info.  */
12026
  elf_link_hash_traverse (elf_hash_table (info),
12027
                          elf_gc_propagate_vtable_entries_used,
12028
                          &ok);
12029
  if (!ok)
12030
    return FALSE;
12031
 
12032
  /* Kill the vtable relocations that were not used.  */
12033
  elf_link_hash_traverse (elf_hash_table (info),
12034
                          elf_gc_smash_unused_vtentry_relocs,
12035
                          &ok);
12036
  if (!ok)
12037
    return FALSE;
12038
 
12039
  /* Mark dynamically referenced symbols.  */
12040
  if (elf_hash_table (info)->dynamic_sections_created)
12041
    elf_link_hash_traverse (elf_hash_table (info),
12042
                            bed->gc_mark_dynamic_ref,
12043
                            info);
12044
 
12045
  /* Grovel through relocs to find out who stays ...  */
12046
  gc_mark_hook = bed->gc_mark_hook;
12047
  for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
12048
    {
12049
      asection *o;
12050
 
12051
      if (bfd_get_flavour (sub) != bfd_target_elf_flavour)
12052
        continue;
12053
 
12054 161 khays
      /* Start at sections marked with SEC_KEEP (ref _bfd_elf_gc_keep).
12055
         Also treat note sections as a root, if the section is not part
12056
         of a group.  */
12057 14 khays
      for (o = sub->sections; o != NULL; o = o->next)
12058 161 khays
        if (!o->gc_mark
12059
            && (o->flags & SEC_EXCLUDE) == 0
12060 148 khays
            && ((o->flags & SEC_KEEP) != 0
12061 161 khays
                || (elf_section_data (o)->this_hdr.sh_type == SHT_NOTE
12062
                    && elf_next_in_group (o) == NULL )))
12063
          {
12064
            if (!_bfd_elf_gc_mark (info, o, gc_mark_hook))
12065
              return FALSE;
12066
          }
12067 14 khays
    }
12068
 
12069
  /* Allow the backend to mark additional target specific sections.  */
12070 161 khays
  bed->gc_mark_extra_sections (info, gc_mark_hook);
12071 14 khays
 
12072
  /* ... and mark SEC_EXCLUDE for those that go.  */
12073
  return elf_gc_sweep (abfd, info);
12074
}
12075
 
12076
/* Called from check_relocs to record the existence of a VTINHERIT reloc.  */
12077
 
12078
bfd_boolean
12079
bfd_elf_gc_record_vtinherit (bfd *abfd,
12080
                             asection *sec,
12081
                             struct elf_link_hash_entry *h,
12082
                             bfd_vma offset)
12083
{
12084
  struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
12085
  struct elf_link_hash_entry **search, *child;
12086
  bfd_size_type extsymcount;
12087
  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12088
 
12089
  /* The sh_info field of the symtab header tells us where the
12090
     external symbols start.  We don't care about the local symbols at
12091
     this point.  */
12092
  extsymcount = elf_tdata (abfd)->symtab_hdr.sh_size / bed->s->sizeof_sym;
12093
  if (!elf_bad_symtab (abfd))
12094
    extsymcount -= elf_tdata (abfd)->symtab_hdr.sh_info;
12095
 
12096
  sym_hashes = elf_sym_hashes (abfd);
12097
  sym_hashes_end = sym_hashes + extsymcount;
12098
 
12099
  /* Hunt down the child symbol, which is in this section at the same
12100
     offset as the relocation.  */
12101
  for (search = sym_hashes; search != sym_hashes_end; ++search)
12102
    {
12103
      if ((child = *search) != NULL
12104
          && (child->root.type == bfd_link_hash_defined
12105
              || child->root.type == bfd_link_hash_defweak)
12106
          && child->root.u.def.section == sec
12107
          && child->root.u.def.value == offset)
12108
        goto win;
12109
    }
12110
 
12111
  (*_bfd_error_handler) ("%B: %A+%lu: No symbol found for INHERIT",
12112
                         abfd, sec, (unsigned long) offset);
12113
  bfd_set_error (bfd_error_invalid_operation);
12114
  return FALSE;
12115
 
12116
 win:
12117
  if (!child->vtable)
12118
    {
12119
      child->vtable = (struct elf_link_virtual_table_entry *)
12120
          bfd_zalloc (abfd, sizeof (*child->vtable));
12121
      if (!child->vtable)
12122
        return FALSE;
12123
    }
12124
  if (!h)
12125
    {
12126
      /* This *should* only be the absolute section.  It could potentially
12127
         be that someone has defined a non-global vtable though, which
12128
         would be bad.  It isn't worth paging in the local symbols to be
12129
         sure though; that case should simply be handled by the assembler.  */
12130
 
12131
      child->vtable->parent = (struct elf_link_hash_entry *) -1;
12132
    }
12133
  else
12134
    child->vtable->parent = h;
12135
 
12136
  return TRUE;
12137
}
12138
 
12139
/* Called from check_relocs to record the existence of a VTENTRY reloc.  */
12140
 
12141
bfd_boolean
12142
bfd_elf_gc_record_vtentry (bfd *abfd ATTRIBUTE_UNUSED,
12143
                           asection *sec ATTRIBUTE_UNUSED,
12144
                           struct elf_link_hash_entry *h,
12145
                           bfd_vma addend)
12146
{
12147
  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12148
  unsigned int log_file_align = bed->s->log_file_align;
12149
 
12150
  if (!h->vtable)
12151
    {
12152
      h->vtable = (struct elf_link_virtual_table_entry *)
12153
          bfd_zalloc (abfd, sizeof (*h->vtable));
12154
      if (!h->vtable)
12155
        return FALSE;
12156
    }
12157
 
12158
  if (addend >= h->vtable->size)
12159
    {
12160
      size_t size, bytes, file_align;
12161
      bfd_boolean *ptr = h->vtable->used;
12162
 
12163
      /* While the symbol is undefined, we have to be prepared to handle
12164
         a zero size.  */
12165
      file_align = 1 << log_file_align;
12166
      if (h->root.type == bfd_link_hash_undefined)
12167
        size = addend + file_align;
12168
      else
12169
        {
12170
          size = h->size;
12171
          if (addend >= size)
12172
            {
12173
              /* Oops!  We've got a reference past the defined end of
12174
                 the table.  This is probably a bug -- shall we warn?  */
12175
              size = addend + file_align;
12176
            }
12177
        }
12178
      size = (size + file_align - 1) & -file_align;
12179
 
12180
      /* Allocate one extra entry for use as a "done" flag for the
12181
         consolidation pass.  */
12182
      bytes = ((size >> log_file_align) + 1) * sizeof (bfd_boolean);
12183
 
12184
      if (ptr)
12185
        {
12186
          ptr = (bfd_boolean *) bfd_realloc (ptr - 1, bytes);
12187
 
12188
          if (ptr != NULL)
12189
            {
12190
              size_t oldbytes;
12191
 
12192
              oldbytes = (((h->vtable->size >> log_file_align) + 1)
12193
                          * sizeof (bfd_boolean));
12194
              memset (((char *) ptr) + oldbytes, 0, bytes - oldbytes);
12195
            }
12196
        }
12197
      else
12198
        ptr = (bfd_boolean *) bfd_zmalloc (bytes);
12199
 
12200
      if (ptr == NULL)
12201
        return FALSE;
12202
 
12203
      /* And arrange for that done flag to be at index -1.  */
12204
      h->vtable->used = ptr + 1;
12205
      h->vtable->size = size;
12206
    }
12207
 
12208
  h->vtable->used[addend >> log_file_align] = TRUE;
12209
 
12210
  return TRUE;
12211
}
12212
 
12213 161 khays
/* Map an ELF section header flag to its corresponding string.  */
12214
typedef struct
12215
{
12216
  char *flag_name;
12217
  flagword flag_value;
12218
} elf_flags_to_name_table;
12219
 
12220
static elf_flags_to_name_table elf_flags_to_names [] =
12221
{
12222
  { "SHF_WRITE", SHF_WRITE },
12223
  { "SHF_ALLOC", SHF_ALLOC },
12224
  { "SHF_EXECINSTR", SHF_EXECINSTR },
12225
  { "SHF_MERGE", SHF_MERGE },
12226
  { "SHF_STRINGS", SHF_STRINGS },
12227
  { "SHF_INFO_LINK", SHF_INFO_LINK},
12228
  { "SHF_LINK_ORDER", SHF_LINK_ORDER},
12229
  { "SHF_OS_NONCONFORMING", SHF_OS_NONCONFORMING},
12230
  { "SHF_GROUP", SHF_GROUP },
12231
  { "SHF_TLS", SHF_TLS },
12232
  { "SHF_MASKOS", SHF_MASKOS },
12233
  { "SHF_EXCLUDE", SHF_EXCLUDE },
12234
};
12235
 
12236
void
12237
bfd_elf_lookup_section_flags (struct bfd_link_info *info,
12238
                              struct flag_info *finfo)
12239
{
12240
  bfd *output_bfd = info->output_bfd;
12241
  const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
12242
  struct flag_info_list *tf = finfo->flag_list;
12243
  int with_hex = 0;
12244
  int without_hex = 0;
12245
 
12246
  for (tf = finfo->flag_list; tf != NULL; tf = tf->next)
12247
    {
12248
      int i;
12249
      if (bed->elf_backend_lookup_section_flags_hook)
12250
        {
12251
          flagword hexval =
12252
             (*bed->elf_backend_lookup_section_flags_hook) ((char *) tf->name);
12253
 
12254
          if (hexval != 0)
12255
            {
12256
              if (tf->with == with_flags)
12257
                with_hex |= hexval;
12258
              else if (tf->with == without_flags)
12259
                without_hex |= hexval;
12260
              tf->valid = TRUE;
12261
              continue;
12262
            }
12263
        }
12264
      for (i = 0; i < 12; i++)
12265
        {
12266
          if (!strcmp (tf->name, elf_flags_to_names[i].flag_name))
12267
            {
12268
              if (tf->with == with_flags)
12269
                with_hex |= elf_flags_to_names[i].flag_value;
12270
              else if (tf->with == without_flags)
12271
                without_hex |= elf_flags_to_names[i].flag_value;
12272
              tf->valid = TRUE;
12273
              continue;
12274
            }
12275
        }
12276
      if (tf->valid == FALSE)
12277
        {
12278
          info->callbacks->einfo
12279
                (_("Unrecognized INPUT_SECTION_FLAG %s\n"), tf->name);
12280
          return;
12281
        }
12282
    }
12283
 finfo->flags_initialized = TRUE;
12284
 finfo->only_with_flags |= with_hex;
12285
 finfo->not_with_flags |= without_hex;
12286
 
12287
 return;
12288
}
12289
 
12290 14 khays
struct alloc_got_off_arg {
12291
  bfd_vma gotoff;
12292
  struct bfd_link_info *info;
12293
};
12294
 
12295
/* We need a special top-level link routine to convert got reference counts
12296
   to real got offsets.  */
12297
 
12298
static bfd_boolean
12299
elf_gc_allocate_got_offsets (struct elf_link_hash_entry *h, void *arg)
12300
{
12301
  struct alloc_got_off_arg *gofarg = (struct alloc_got_off_arg *) arg;
12302
  bfd *obfd = gofarg->info->output_bfd;
12303
  const struct elf_backend_data *bed = get_elf_backend_data (obfd);
12304
 
12305
  if (h->got.refcount > 0)
12306
    {
12307
      h->got.offset = gofarg->gotoff;
12308
      gofarg->gotoff += bed->got_elt_size (obfd, gofarg->info, h, NULL, 0);
12309
    }
12310
  else
12311
    h->got.offset = (bfd_vma) -1;
12312
 
12313
  return TRUE;
12314
}
12315
 
12316
/* And an accompanying bit to work out final got entry offsets once
12317
   we're done.  Should be called from final_link.  */
12318
 
12319
bfd_boolean
12320
bfd_elf_gc_common_finalize_got_offsets (bfd *abfd,
12321
                                        struct bfd_link_info *info)
12322
{
12323
  bfd *i;
12324
  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12325
  bfd_vma gotoff;
12326
  struct alloc_got_off_arg gofarg;
12327
 
12328
  BFD_ASSERT (abfd == info->output_bfd);
12329
 
12330
  if (! is_elf_hash_table (info->hash))
12331
    return FALSE;
12332
 
12333
  /* The GOT offset is relative to the .got section, but the GOT header is
12334
     put into the .got.plt section, if the backend uses it.  */
12335
  if (bed->want_got_plt)
12336
    gotoff = 0;
12337
  else
12338
    gotoff = bed->got_header_size;
12339
 
12340
  /* Do the local .got entries first.  */
12341
  for (i = info->input_bfds; i; i = i->link_next)
12342
    {
12343
      bfd_signed_vma *local_got;
12344
      bfd_size_type j, locsymcount;
12345
      Elf_Internal_Shdr *symtab_hdr;
12346
 
12347
      if (bfd_get_flavour (i) != bfd_target_elf_flavour)
12348
        continue;
12349
 
12350
      local_got = elf_local_got_refcounts (i);
12351
      if (!local_got)
12352
        continue;
12353
 
12354
      symtab_hdr = &elf_tdata (i)->symtab_hdr;
12355
      if (elf_bad_symtab (i))
12356
        locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym;
12357
      else
12358
        locsymcount = symtab_hdr->sh_info;
12359
 
12360
      for (j = 0; j < locsymcount; ++j)
12361
        {
12362
          if (local_got[j] > 0)
12363
            {
12364
              local_got[j] = gotoff;
12365
              gotoff += bed->got_elt_size (abfd, info, NULL, i, j);
12366
            }
12367
          else
12368
            local_got[j] = (bfd_vma) -1;
12369
        }
12370
    }
12371
 
12372
  /* Then the global .got entries.  .plt refcounts are handled by
12373
     adjust_dynamic_symbol  */
12374
  gofarg.gotoff = gotoff;
12375
  gofarg.info = info;
12376
  elf_link_hash_traverse (elf_hash_table (info),
12377
                          elf_gc_allocate_got_offsets,
12378
                          &gofarg);
12379
  return TRUE;
12380
}
12381
 
12382
/* Many folk need no more in the way of final link than this, once
12383
   got entry reference counting is enabled.  */
12384
 
12385
bfd_boolean
12386
bfd_elf_gc_common_final_link (bfd *abfd, struct bfd_link_info *info)
12387
{
12388
  if (!bfd_elf_gc_common_finalize_got_offsets (abfd, info))
12389
    return FALSE;
12390
 
12391
  /* Invoke the regular ELF backend linker to do all the work.  */
12392
  return bfd_elf_final_link (abfd, info);
12393
}
12394
 
12395
bfd_boolean
12396
bfd_elf_reloc_symbol_deleted_p (bfd_vma offset, void *cookie)
12397
{
12398
  struct elf_reloc_cookie *rcookie = (struct elf_reloc_cookie *) cookie;
12399
 
12400
  if (rcookie->bad_symtab)
12401
    rcookie->rel = rcookie->rels;
12402
 
12403
  for (; rcookie->rel < rcookie->relend; rcookie->rel++)
12404
    {
12405
      unsigned long r_symndx;
12406
 
12407
      if (! rcookie->bad_symtab)
12408
        if (rcookie->rel->r_offset > offset)
12409
          return FALSE;
12410
      if (rcookie->rel->r_offset != offset)
12411
        continue;
12412
 
12413
      r_symndx = rcookie->rel->r_info >> rcookie->r_sym_shift;
12414
      if (r_symndx == STN_UNDEF)
12415
        return TRUE;
12416
 
12417
      if (r_symndx >= rcookie->locsymcount
12418
          || ELF_ST_BIND (rcookie->locsyms[r_symndx].st_info) != STB_LOCAL)
12419
        {
12420
          struct elf_link_hash_entry *h;
12421
 
12422
          h = rcookie->sym_hashes[r_symndx - rcookie->extsymoff];
12423
 
12424
          while (h->root.type == bfd_link_hash_indirect
12425
                 || h->root.type == bfd_link_hash_warning)
12426
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
12427
 
12428
          if ((h->root.type == bfd_link_hash_defined
12429
               || h->root.type == bfd_link_hash_defweak)
12430
              && elf_discarded_section (h->root.u.def.section))
12431
            return TRUE;
12432
          else
12433
            return FALSE;
12434
        }
12435
      else
12436
        {
12437
          /* It's not a relocation against a global symbol,
12438
             but it could be a relocation against a local
12439
             symbol for a discarded section.  */
12440
          asection *isec;
12441
          Elf_Internal_Sym *isym;
12442
 
12443
          /* Need to: get the symbol; get the section.  */
12444
          isym = &rcookie->locsyms[r_symndx];
12445
          isec = bfd_section_from_elf_index (rcookie->abfd, isym->st_shndx);
12446
          if (isec != NULL && elf_discarded_section (isec))
12447
            return TRUE;
12448
        }
12449
      return FALSE;
12450
    }
12451
  return FALSE;
12452
}
12453
 
12454
/* Discard unneeded references to discarded sections.
12455
   Returns TRUE if any section's size was changed.  */
12456
/* This function assumes that the relocations are in sorted order,
12457
   which is true for all known assemblers.  */
12458
 
12459
bfd_boolean
12460
bfd_elf_discard_info (bfd *output_bfd, struct bfd_link_info *info)
12461
{
12462
  struct elf_reloc_cookie cookie;
12463
  asection *stab, *eh;
12464
  const struct elf_backend_data *bed;
12465
  bfd *abfd;
12466
  bfd_boolean ret = FALSE;
12467
 
12468
  if (info->traditional_format
12469
      || !is_elf_hash_table (info->hash))
12470
    return FALSE;
12471
 
12472
  _bfd_elf_begin_eh_frame_parsing (info);
12473
  for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next)
12474
    {
12475
      if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
12476
        continue;
12477
 
12478
      bed = get_elf_backend_data (abfd);
12479
 
12480
      if ((abfd->flags & DYNAMIC) != 0)
12481
        continue;
12482
 
12483
      eh = NULL;
12484
      if (!info->relocatable)
12485
        {
12486
          eh = bfd_get_section_by_name (abfd, ".eh_frame");
12487
          if (eh != NULL
12488
              && (eh->size == 0
12489
                  || bfd_is_abs_section (eh->output_section)))
12490
            eh = NULL;
12491
        }
12492
 
12493
      stab = bfd_get_section_by_name (abfd, ".stab");
12494
      if (stab != NULL
12495
          && (stab->size == 0
12496
              || bfd_is_abs_section (stab->output_section)
12497
              || stab->sec_info_type != ELF_INFO_TYPE_STABS))
12498
        stab = NULL;
12499
 
12500
      if (stab == NULL
12501
          && eh == NULL
12502
          && bed->elf_backend_discard_info == NULL)
12503
        continue;
12504
 
12505
      if (!init_reloc_cookie (&cookie, info, abfd))
12506
        return FALSE;
12507
 
12508
      if (stab != NULL
12509
          && stab->reloc_count > 0
12510
          && init_reloc_cookie_rels (&cookie, info, abfd, stab))
12511
        {
12512
          if (_bfd_discard_section_stabs (abfd, stab,
12513
                                          elf_section_data (stab)->sec_info,
12514
                                          bfd_elf_reloc_symbol_deleted_p,
12515
                                          &cookie))
12516
            ret = TRUE;
12517
          fini_reloc_cookie_rels (&cookie, stab);
12518
        }
12519
 
12520
      if (eh != NULL
12521
          && init_reloc_cookie_rels (&cookie, info, abfd, eh))
12522
        {
12523
          _bfd_elf_parse_eh_frame (abfd, info, eh, &cookie);
12524
          if (_bfd_elf_discard_section_eh_frame (abfd, info, eh,
12525
                                                 bfd_elf_reloc_symbol_deleted_p,
12526
                                                 &cookie))
12527
            ret = TRUE;
12528
          fini_reloc_cookie_rels (&cookie, eh);
12529
        }
12530
 
12531
      if (bed->elf_backend_discard_info != NULL
12532
          && (*bed->elf_backend_discard_info) (abfd, &cookie, info))
12533
        ret = TRUE;
12534
 
12535
      fini_reloc_cookie (&cookie, abfd);
12536
    }
12537
  _bfd_elf_end_eh_frame_parsing (info);
12538
 
12539
  if (info->eh_frame_hdr
12540
      && !info->relocatable
12541
      && _bfd_elf_discard_section_eh_frame_hdr (output_bfd, info))
12542
    ret = TRUE;
12543
 
12544
  return ret;
12545
}
12546
 
12547 161 khays
bfd_boolean
12548
_bfd_elf_section_already_linked (bfd *abfd,
12549
                                 asection *sec,
12550 14 khays
                                 struct bfd_link_info *info)
12551
{
12552
  flagword flags;
12553 161 khays
  const char *name, *key;
12554 14 khays
  struct bfd_section_already_linked *l;
12555
  struct bfd_section_already_linked_hash_entry *already_linked_list;
12556
 
12557
  if (sec->output_section == bfd_abs_section_ptr)
12558 161 khays
    return FALSE;
12559 14 khays
 
12560
  flags = sec->flags;
12561
 
12562
  /* Return if it isn't a linkonce section.  A comdat group section
12563
     also has SEC_LINK_ONCE set.  */
12564
  if ((flags & SEC_LINK_ONCE) == 0)
12565 161 khays
    return FALSE;
12566 14 khays
 
12567
  /* Don't put group member sections on our list of already linked
12568
     sections.  They are handled as a group via their group section.  */
12569
  if (elf_sec_group (sec) != NULL)
12570 161 khays
    return FALSE;
12571 14 khays
 
12572 161 khays
  /* For a SHT_GROUP section, use the group signature as the key.  */
12573
  name = sec->name;
12574
  if ((flags & SEC_GROUP) != 0
12575
      && elf_next_in_group (sec) != NULL
12576
      && elf_group_name (elf_next_in_group (sec)) != NULL)
12577
    key = elf_group_name (elf_next_in_group (sec));
12578 14 khays
  else
12579 161 khays
    {
12580
      /* Otherwise we should have a .gnu.linkonce.<type>.<key> section.  */
12581
      if (CONST_STRNEQ (name, ".gnu.linkonce.")
12582
          && (key = strchr (name + sizeof (".gnu.linkonce.") - 1, '.')) != NULL)
12583
        key++;
12584
      else
12585
        /* Must be a user linkonce section that doesn't follow gcc's
12586
           naming convention.  In this case we won't be matching
12587
           single member groups.  */
12588
        key = name;
12589
    }
12590 14 khays
 
12591 161 khays
  already_linked_list = bfd_section_already_linked_table_lookup (key);
12592 14 khays
 
12593
  for (l = already_linked_list->entry; l != NULL; l = l->next)
12594
    {
12595
      /* We may have 2 different types of sections on the list: group
12596 161 khays
         sections with a signature of <key> (<key> is some string),
12597
         and linkonce sections named .gnu.linkonce.<type>.<key>.
12598
         Match like sections.  LTO plugin sections are an exception.
12599
         They are always named .gnu.linkonce.t.<key> and match either
12600
         type of section.  */
12601
      if (((flags & SEC_GROUP) == (l->sec->flags & SEC_GROUP)
12602
           && ((flags & SEC_GROUP) != 0
12603
               || strcmp (name, l->sec->name) == 0))
12604
          || (l->sec->owner->flags & BFD_PLUGIN) != 0)
12605 14 khays
        {
12606
          /* The section has already been linked.  See if we should
12607
             issue a warning.  */
12608 161 khays
          if (!_bfd_handle_already_linked (sec, l, info))
12609
            return FALSE;
12610 14 khays
 
12611
          if (flags & SEC_GROUP)
12612
            {
12613
              asection *first = elf_next_in_group (sec);
12614
              asection *s = first;
12615
 
12616
              while (s != NULL)
12617
                {
12618
                  s->output_section = bfd_abs_section_ptr;
12619
                  /* Record which group discards it.  */
12620
                  s->kept_section = l->sec;
12621
                  s = elf_next_in_group (s);
12622
                  /* These lists are circular.  */
12623
                  if (s == first)
12624
                    break;
12625
                }
12626
            }
12627
 
12628 161 khays
          return TRUE;
12629 14 khays
        }
12630
    }
12631
 
12632
  /* A single member comdat group section may be discarded by a
12633
     linkonce section and vice versa.  */
12634
  if ((flags & SEC_GROUP) != 0)
12635
    {
12636
      asection *first = elf_next_in_group (sec);
12637
 
12638
      if (first != NULL && elf_next_in_group (first) == first)
12639
        /* Check this single member group against linkonce sections.  */
12640
        for (l = already_linked_list->entry; l != NULL; l = l->next)
12641
          if ((l->sec->flags & SEC_GROUP) == 0
12642
              && bfd_elf_match_symbols_in_sections (l->sec, first, info))
12643
            {
12644
              first->output_section = bfd_abs_section_ptr;
12645
              first->kept_section = l->sec;
12646
              sec->output_section = bfd_abs_section_ptr;
12647
              break;
12648
            }
12649
    }
12650
  else
12651
    /* Check this linkonce section against single member groups.  */
12652
    for (l = already_linked_list->entry; l != NULL; l = l->next)
12653
      if (l->sec->flags & SEC_GROUP)
12654
        {
12655
          asection *first = elf_next_in_group (l->sec);
12656
 
12657
          if (first != NULL
12658
              && elf_next_in_group (first) == first
12659
              && bfd_elf_match_symbols_in_sections (first, sec, info))
12660
            {
12661
              sec->output_section = bfd_abs_section_ptr;
12662
              sec->kept_section = first;
12663
              break;
12664
            }
12665
        }
12666
 
12667
  /* Do not complain on unresolved relocations in `.gnu.linkonce.r.F'
12668
     referencing its discarded `.gnu.linkonce.t.F' counterpart - g++-3.4
12669
     specific as g++-4.x is using COMDAT groups (without the `.gnu.linkonce'
12670
     prefix) instead.  `.gnu.linkonce.r.*' were the `.rodata' part of its
12671
     matching `.gnu.linkonce.t.*'.  If `.gnu.linkonce.r.F' is not discarded
12672
     but its `.gnu.linkonce.t.F' is discarded means we chose one-only
12673
     `.gnu.linkonce.t.F' section from a different bfd not requiring any
12674
     `.gnu.linkonce.r.F'.  Thus `.gnu.linkonce.r.F' should be discarded.
12675
     The reverse order cannot happen as there is never a bfd with only the
12676
     `.gnu.linkonce.r.F' section.  The order of sections in a bfd does not
12677
     matter as here were are looking only for cross-bfd sections.  */
12678
 
12679
  if ((flags & SEC_GROUP) == 0 && CONST_STRNEQ (name, ".gnu.linkonce.r."))
12680
    for (l = already_linked_list->entry; l != NULL; l = l->next)
12681
      if ((l->sec->flags & SEC_GROUP) == 0
12682
          && CONST_STRNEQ (l->sec->name, ".gnu.linkonce.t."))
12683
        {
12684
          if (abfd != l->sec->owner)
12685
            sec->output_section = bfd_abs_section_ptr;
12686
          break;
12687
        }
12688
 
12689
  /* This is the first section with this name.  Record it.  */
12690 161 khays
  if (!bfd_section_already_linked_table_insert (already_linked_list, sec))
12691 14 khays
    info->callbacks->einfo (_("%F%P: already_linked_table: %E\n"));
12692 161 khays
  return sec->output_section == bfd_abs_section_ptr;
12693 14 khays
}
12694
 
12695
bfd_boolean
12696
_bfd_elf_common_definition (Elf_Internal_Sym *sym)
12697
{
12698
  return sym->st_shndx == SHN_COMMON;
12699
}
12700
 
12701
unsigned int
12702
_bfd_elf_common_section_index (asection *sec ATTRIBUTE_UNUSED)
12703
{
12704
  return SHN_COMMON;
12705
}
12706
 
12707
asection *
12708
_bfd_elf_common_section (asection *sec ATTRIBUTE_UNUSED)
12709
{
12710
  return bfd_com_section_ptr;
12711
}
12712
 
12713
bfd_vma
12714
_bfd_elf_default_got_elt_size (bfd *abfd,
12715
                               struct bfd_link_info *info ATTRIBUTE_UNUSED,
12716
                               struct elf_link_hash_entry *h ATTRIBUTE_UNUSED,
12717
                               bfd *ibfd ATTRIBUTE_UNUSED,
12718
                               unsigned long symndx ATTRIBUTE_UNUSED)
12719
{
12720
  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12721
  return bed->s->arch_size / 8;
12722
}
12723
 
12724
/* Routines to support the creation of dynamic relocs.  */
12725
 
12726
/* Returns the name of the dynamic reloc section associated with SEC.  */
12727
 
12728
static const char *
12729
get_dynamic_reloc_section_name (bfd *       abfd,
12730
                                asection *  sec,
12731
                                bfd_boolean is_rela)
12732
{
12733
  char *name;
12734
  const char *old_name = bfd_get_section_name (NULL, sec);
12735
  const char *prefix = is_rela ? ".rela" : ".rel";
12736
 
12737
  if (old_name == NULL)
12738
    return NULL;
12739
 
12740
  name = bfd_alloc (abfd, strlen (prefix) + strlen (old_name) + 1);
12741
  sprintf (name, "%s%s", prefix, old_name);
12742
 
12743
  return name;
12744
}
12745
 
12746
/* Returns the dynamic reloc section associated with SEC.
12747
   If necessary compute the name of the dynamic reloc section based
12748
   on SEC's name (looked up in ABFD's string table) and the setting
12749
   of IS_RELA.  */
12750
 
12751
asection *
12752
_bfd_elf_get_dynamic_reloc_section (bfd *       abfd,
12753
                                    asection *  sec,
12754
                                    bfd_boolean is_rela)
12755
{
12756
  asection * reloc_sec = elf_section_data (sec)->sreloc;
12757
 
12758
  if (reloc_sec == NULL)
12759
    {
12760
      const char * name = get_dynamic_reloc_section_name (abfd, sec, is_rela);
12761
 
12762
      if (name != NULL)
12763
        {
12764
          reloc_sec = bfd_get_section_by_name (abfd, name);
12765
 
12766
          if (reloc_sec != NULL)
12767
            elf_section_data (sec)->sreloc = reloc_sec;
12768
        }
12769
    }
12770
 
12771
  return reloc_sec;
12772
}
12773
 
12774
/* Returns the dynamic reloc section associated with SEC.  If the
12775
   section does not exist it is created and attached to the DYNOBJ
12776
   bfd and stored in the SRELOC field of SEC's elf_section_data
12777
   structure.
12778
 
12779
   ALIGNMENT is the alignment for the newly created section and
12780
   IS_RELA defines whether the name should be .rela.<SEC's name>
12781
   or .rel.<SEC's name>.  The section name is looked up in the
12782
   string table associated with ABFD.  */
12783
 
12784
asection *
12785
_bfd_elf_make_dynamic_reloc_section (asection *         sec,
12786
                                     bfd *              dynobj,
12787
                                     unsigned int       alignment,
12788
                                     bfd *              abfd,
12789
                                     bfd_boolean        is_rela)
12790
{
12791
  asection * reloc_sec = elf_section_data (sec)->sreloc;
12792
 
12793
  if (reloc_sec == NULL)
12794
    {
12795
      const char * name = get_dynamic_reloc_section_name (abfd, sec, is_rela);
12796
 
12797
      if (name == NULL)
12798
        return NULL;
12799
 
12800
      reloc_sec = bfd_get_section_by_name (dynobj, name);
12801
 
12802
      if (reloc_sec == NULL)
12803
        {
12804
          flagword flags;
12805
 
12806
          flags = (SEC_HAS_CONTENTS | SEC_READONLY | SEC_IN_MEMORY | SEC_LINKER_CREATED);
12807
          if ((sec->flags & SEC_ALLOC) != 0)
12808
            flags |= SEC_ALLOC | SEC_LOAD;
12809
 
12810
          reloc_sec = bfd_make_section_with_flags (dynobj, name, flags);
12811
          if (reloc_sec != NULL)
12812
            {
12813
              if (! bfd_set_section_alignment (dynobj, reloc_sec, alignment))
12814
                reloc_sec = NULL;
12815
            }
12816
        }
12817
 
12818
      elf_section_data (sec)->sreloc = reloc_sec;
12819
    }
12820
 
12821
  return reloc_sec;
12822
}
12823
 
12824
/* Copy the ELF symbol type associated with a linker hash entry.  */
12825
void
12826
_bfd_elf_copy_link_hash_symbol_type (bfd *abfd ATTRIBUTE_UNUSED,
12827
    struct bfd_link_hash_entry * hdest,
12828
    struct bfd_link_hash_entry * hsrc)
12829
{
12830
  struct elf_link_hash_entry *ehdest = (struct elf_link_hash_entry *)hdest;
12831
  struct elf_link_hash_entry *ehsrc = (struct elf_link_hash_entry *)hsrc;
12832
 
12833
  ehdest->type = ehsrc->type;
12834
  ehdest->target_internal = ehsrc->target_internal;
12835
}
12836
 
12837
/* Append a RELA relocation REL to section S in BFD.  */
12838
 
12839
void
12840
elf_append_rela (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
12841
{
12842
  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12843
  bfd_byte *loc = s->contents + (s->reloc_count++ * bed->s->sizeof_rela);
12844
  BFD_ASSERT (loc + bed->s->sizeof_rela <= s->contents + s->size);
12845
  bed->s->swap_reloca_out (abfd, rel, loc);
12846
}
12847
 
12848
/* Append a REL relocation REL to section S in BFD.  */
12849
 
12850
void
12851
elf_append_rel (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
12852
{
12853
  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12854
  bfd_byte *loc = s->contents + (s->reloc_count++ * bed->s->sizeof_rel);
12855
  BFD_ASSERT (loc + bed->s->sizeof_rel <= s->contents + s->size);
12856
  bed->s->swap_reloca_out (abfd, rel, loc);
12857
}

powered by: WebSVN 2.1.0

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