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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [bfd/] [elflink.c] - Blame information for rev 262

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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