Coverage Report

Created: 2024-05-21 06:29

/src/binutils-gdb/bfd/coffgen.c
Line
Count
Source (jump to first uncovered line)
1
/* Support for the generic parts of COFF, for BFD.
2
   Copyright (C) 1990-2024 Free Software Foundation, Inc.
3
   Written by Cygnus Support.
4
5
   This file is part of BFD, the Binary File Descriptor library.
6
7
   This program is free software; you can redistribute it and/or modify
8
   it under the terms of the GNU General Public License as published by
9
   the Free Software Foundation; either version 3 of the License, or
10
   (at your option) any later version.
11
12
   This program is distributed in the hope that it will be useful,
13
   but WITHOUT ANY WARRANTY; without even the implied warranty of
14
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
   GNU General Public License for more details.
16
17
   You should have received a copy of the GNU General Public License
18
   along with this program; if not, write to the Free Software
19
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20
   MA 02110-1301, USA.  */
21
22
/* Most of this hacked by  Steve Chamberlain, sac@cygnus.com.
23
   Split out of coffcode.h by Ian Taylor, ian@cygnus.com.  */
24
25
/* This file contains COFF code that is not dependent on any
26
   particular COFF target.  There is only one version of this file in
27
   libbfd.a, so no target specific code may be put in here.  Or, to
28
   put it another way,
29
30
   ********** DO NOT PUT TARGET SPECIFIC CODE IN THIS FILE **********
31
32
   If you need to add some target specific behaviour, add a new hook
33
   function to bfd_coff_backend_data.
34
35
   Some of these functions are also called by the ECOFF routines.
36
   Those functions may not use any COFF specific information, such as
37
   coff_data (abfd).  */
38
39
#include "sysdep.h"
40
#include <limits.h>
41
#include "bfd.h"
42
#include "libbfd.h"
43
#include "coff/internal.h"
44
#include "libcoff.h"
45
#include "hashtab.h"
46
47
/* Extract a long section name at STRINDEX and copy it to the bfd objstack.
48
   Return NULL in case of error.  */
49
50
static char *
51
extract_long_section_name(bfd *abfd, unsigned long strindex)
52
22.5k
{
53
22.5k
  const char *strings;
54
22.5k
  char *name;
55
56
22.5k
  strings = _bfd_coff_read_string_table (abfd);
57
22.5k
  if (strings == NULL)
58
4.18k
    return NULL;
59
18.3k
  if ((bfd_size_type)(strindex + 2) >= obj_coff_strings_len (abfd))
60
1.03k
    return NULL;
61
17.3k
  strings += strindex;
62
17.3k
  name = (char *) bfd_alloc (abfd, (bfd_size_type) strlen (strings) + 1);
63
17.3k
  if (name == NULL)
64
0
    return NULL;
65
17.3k
  strcpy (name, strings);
66
67
17.3k
  return name;
68
17.3k
}
69
70
/* Decode a base 64 coded string at STR of length LEN, and write the result
71
   to RES.  Return true on success.
72
   Return false in case of invalid character or overflow.  */
73
74
static bool
75
decode_base64 (const char *str, unsigned len, uint32_t *res)
76
8.13k
{
77
8.13k
  unsigned i;
78
8.13k
  uint32_t val;
79
80
8.13k
  val = 0;
81
28.4k
  for (i = 0; i < len; i++)
82
28.1k
    {
83
28.1k
      char c = str[i];
84
28.1k
      unsigned d;
85
86
28.1k
      if (c >= 'A' && c <= 'Z')
87
2.57k
  d = c - 'A';
88
25.5k
      else if (c >= 'a' && c <= 'z')
89
3.38k
  d = c - 'a' + 26;
90
22.1k
      else if (c >= '0' && c <= '9')
91
1.85k
  d = c - '0' + 52;
92
20.2k
      else if (c == '+')
93
499
  d = 62;
94
19.7k
      else if (c == '/')
95
14.7k
  d = 63;
96
5.03k
      else
97
5.03k
  return false;
98
99
      /* Check for overflow. */
100
23.0k
      if ((val >> 26) != 0)
101
2.74k
  return false;
102
103
20.3k
      val = (val << 6) + d;
104
20.3k
    }
105
106
356
  *res = val;
107
356
  return true;
108
8.13k
}
109
110
/* Take a section header read from a coff file (in HOST byte order),
111
   and make a BFD "section" out of it.  This is used by ECOFF.  */
112
113
static bool
114
make_a_section_from_file (bfd *abfd,
115
        struct internal_scnhdr *hdr,
116
        unsigned int target_index)
117
115M
{
118
115M
  asection *newsect;
119
115M
  char *name;
120
115M
  bool result = true;
121
115M
  flagword flags;
122
123
115M
  name = NULL;
124
125
  /* Handle long section names as in PE.  On reading, we want to
126
    accept long names if the format permits them at all, regardless
127
    of the current state of the flag that dictates if we would generate
128
    them in outputs; this construct checks if that is the case by
129
    attempting to set the flag, without changing its state; the call
130
    will fail for formats that do not support long names at all.  */
131
115M
  if (bfd_coff_set_long_section_names (abfd, bfd_coff_long_section_names (abfd))
132
115M
      && hdr->s_name[0] == '/')
133
53.9k
    {
134
      /* Flag that this BFD uses long names, even though the format might
135
   expect them to be off by default.  This won't directly affect the
136
   format of any output BFD created from this one, but the information
137
   can be used to decide what to do.  */
138
53.9k
      bfd_coff_set_long_section_names (abfd, true);
139
140
53.9k
      if (hdr->s_name[1] == '/')
141
8.13k
  {
142
    /* LLVM extension: the '/' is followed by another '/' and then by
143
       the index in the strtab encoded in base64 without NUL at the
144
       end.  */
145
8.13k
    uint32_t strindex;
146
147
    /* Decode the index.  No overflow is expected as the string table
148
       length is at most 2^32 - 1 (the length is written on the first
149
       four bytes).
150
       Also, contrary to RFC 4648, all the characters must be decoded,
151
       there is no padding.  */
152
8.13k
    if (!decode_base64 (hdr->s_name + 2, SCNNMLEN - 2, &strindex))
153
7.77k
      return false;
154
155
356
    name = extract_long_section_name (abfd, strindex);
156
356
    if (name == NULL)
157
212
      return false;
158
356
  }
159
45.8k
      else
160
45.8k
  {
161
    /* PE classic long section name.  The '/' is followed by the index
162
       in the strtab.  The index is formatted as a decimal string.  */
163
45.8k
    char buf[SCNNMLEN];
164
45.8k
    long strindex;
165
45.8k
    char *p;
166
167
45.8k
    memcpy (buf, hdr->s_name + 1, SCNNMLEN - 1);
168
45.8k
    buf[SCNNMLEN - 1] = '\0';
169
45.8k
    strindex = strtol (buf, &p, 10);
170
45.8k
    if (*p == '\0' && strindex >= 0)
171
22.2k
      {
172
22.2k
        name = extract_long_section_name (abfd, strindex);
173
22.2k
        if (name == NULL)
174
5.01k
    return false;
175
22.2k
      }
176
45.8k
  }
177
53.9k
    }
178
179
115M
  if (name == NULL)
180
115M
    {
181
      /* Assorted wastage to null-terminate the name, thanks AT&T! */
182
115M
      name = (char *) bfd_alloc (abfd,
183
115M
         (bfd_size_type) sizeof (hdr->s_name) + 1 + 1);
184
115M
      if (name == NULL)
185
0
  return false;
186
115M
      strncpy (name, (char *) &hdr->s_name[0], sizeof (hdr->s_name));
187
115M
      name[sizeof (hdr->s_name)] = 0;
188
115M
    }
189
190
115M
  newsect = bfd_make_section_anyway (abfd, name);
191
115M
  if (newsect == NULL)
192
0
    return false;
193
194
115M
  newsect->vma = hdr->s_vaddr;
195
115M
  newsect->lma = hdr->s_paddr;
196
115M
  newsect->size = hdr->s_size;
197
115M
  newsect->filepos = hdr->s_scnptr;
198
115M
  newsect->rel_filepos = hdr->s_relptr;
199
115M
  newsect->reloc_count = hdr->s_nreloc;
200
201
115M
  bfd_coff_set_alignment_hook (abfd, newsect, hdr);
202
203
115M
  newsect->line_filepos = hdr->s_lnnoptr;
204
205
115M
  newsect->lineno_count = hdr->s_nlnno;
206
115M
  newsect->userdata = NULL;
207
115M
  newsect->next = NULL;
208
115M
  newsect->target_index = target_index;
209
210
115M
  if (!bfd_coff_styp_to_sec_flags_hook (abfd, hdr, name, newsect, &flags))
211
427k
    result = false;
212
213
  /* At least on i386-coff, the line number count for a shared library
214
     section must be ignored.  */
215
115M
  if ((flags & SEC_COFF_SHARED_LIBRARY) != 0)
216
20.4M
    newsect->lineno_count = 0;
217
218
115M
  if (hdr->s_nreloc != 0)
219
76.6M
    flags |= SEC_RELOC;
220
  /* FIXME: should this check 'hdr->s_size > 0'.  */
221
115M
  if (hdr->s_scnptr != 0)
222
88.0M
    flags |= SEC_HAS_CONTENTS;
223
224
115M
  newsect->flags = flags;
225
226
  /* Compress/decompress DWARF debug sections.  */
227
115M
  if ((flags & SEC_DEBUGGING) != 0
228
115M
      && (flags & SEC_HAS_CONTENTS) != 0
229
115M
      && (startswith (name, ".debug_")
230
2.50M
    || startswith (name, ".zdebug_")
231
2.50M
    || startswith (name, ".gnu.debuglto_.debug_")
232
2.50M
    || startswith (name, ".gnu.linkonce.wi.")))
233
31.3k
    {
234
31.3k
      enum { nothing, compress, decompress } action = nothing;
235
236
31.3k
      if (bfd_is_section_compressed (abfd, newsect))
237
510
  {
238
    /* Compressed section.  Check if we should decompress.  */
239
510
    if ((abfd->flags & BFD_DECOMPRESS))
240
13
      action = decompress;
241
510
  }
242
30.8k
      else
243
30.8k
  {
244
    /* Normal section.  Check if we should compress.  */
245
30.8k
    if ((abfd->flags & BFD_COMPRESS) && newsect->size != 0)
246
0
      action = compress;
247
30.8k
  }
248
249
31.3k
      if (action == compress)
250
0
  {
251
0
    if (!bfd_init_section_compress_status (abfd, newsect))
252
0
      {
253
0
        _bfd_error_handler
254
    /* xgettext:c-format */
255
0
    (_("%pB: unable to compress section %s"), abfd, name);
256
0
        return false;
257
0
      }
258
0
  }
259
31.3k
      else if (action == decompress)
260
13
  {
261
13
    if (!bfd_init_section_decompress_status (abfd, newsect))
262
11
      {
263
11
        _bfd_error_handler
264
    /* xgettext:c-format */
265
11
    (_("%pB: unable to decompress section %s"), abfd, name);
266
11
        return false;
267
11
      }
268
2
    if (abfd->is_linker_input
269
2
        && name[1] == 'z')
270
0
      {
271
        /* Rename section from .zdebug_* to .debug_* so that ld
272
     scripts will see this section as a debug section.  */
273
0
        char *new_name = bfd_zdebug_name_to_debug (abfd, name);
274
0
        if (new_name == NULL)
275
0
    return false;
276
0
        bfd_rename_section (newsect, new_name);
277
0
      }
278
2
  }
279
31.3k
    }
280
281
115M
  return result;
282
115M
}
283
284
void
285
coff_object_cleanup (bfd *abfd)
286
826k
{
287
826k
  struct coff_tdata *td = coff_data (abfd);
288
826k
  if (td != NULL)
289
730k
    {
290
730k
      if (td->section_by_index)
291
0
  htab_delete (td->section_by_index);
292
730k
      if (td->section_by_target_index)
293
0
  htab_delete (td->section_by_target_index);
294
730k
      if (obj_pe (abfd) && pe_data (abfd)->comdat_hash)
295
340k
  htab_delete (pe_data (abfd)->comdat_hash);
296
730k
    }
297
826k
}
298
299
/* Read in a COFF object and make it into a BFD.  This is used by
300
   ECOFF as well.  */
301
bfd_cleanup
302
coff_real_object_p (bfd *abfd,
303
        unsigned nscns,
304
        struct internal_filehdr *internal_f,
305
        struct internal_aouthdr *internal_a)
306
1.36M
{
307
1.36M
  flagword oflags = abfd->flags;
308
1.36M
  bfd_vma ostart = bfd_get_start_address (abfd);
309
1.36M
  void * tdata;
310
1.36M
  void * tdata_save;
311
1.36M
  bfd_size_type readsize; /* Length of file_info.  */
312
1.36M
  unsigned int scnhsz;
313
1.36M
  char *external_sections;
314
315
1.36M
  if (!(internal_f->f_flags & F_RELFLG))
316
1.06M
    abfd->flags |= HAS_RELOC;
317
1.36M
  if ((internal_f->f_flags & F_EXEC))
318
307k
    abfd->flags |= EXEC_P;
319
1.36M
  if (!(internal_f->f_flags & F_LNNO))
320
1.12M
    abfd->flags |= HAS_LINENO;
321
1.36M
  if (!(internal_f->f_flags & F_LSYMS))
322
1.00M
    abfd->flags |= HAS_LOCALS;
323
324
  /* FIXME: How can we set D_PAGED correctly?  */
325
1.36M
  if ((internal_f->f_flags & F_EXEC) != 0)
326
307k
    abfd->flags |= D_PAGED;
327
328
1.36M
  abfd->symcount = internal_f->f_nsyms;
329
1.36M
  if (internal_f->f_nsyms)
330
1.05M
    abfd->flags |= HAS_SYMS;
331
332
1.36M
  if (internal_a != (struct internal_aouthdr *) NULL)
333
640k
    abfd->start_address = internal_a->entry;
334
726k
  else
335
726k
    abfd->start_address = 0;
336
337
  /* Set up the tdata area.  ECOFF uses its own routine, and overrides
338
     abfd->flags.  */
339
1.36M
  tdata_save = abfd->tdata.any;
340
1.36M
  tdata = bfd_coff_mkobject_hook (abfd, (void *) internal_f, (void *) internal_a);
341
1.36M
  if (tdata == NULL)
342
0
    goto fail2;
343
344
1.36M
  scnhsz = bfd_coff_scnhsz (abfd);
345
1.36M
  readsize = (bfd_size_type) nscns * scnhsz;
346
1.36M
  external_sections = (char *) _bfd_alloc_and_read (abfd, readsize, readsize);
347
1.36M
  if (!external_sections)
348
60.2k
    goto fail;
349
350
  /* Set the arch/mach *before* swapping in sections; section header swapping
351
     may depend on arch/mach info.  */
352
1.30M
  if (! bfd_coff_set_arch_mach_hook (abfd, (void *) internal_f))
353
1.55k
    goto fail;
354
355
  /* Now copy data as required; construct all asections etc.  */
356
1.30M
  if (nscns != 0)
357
1.27M
    {
358
1.27M
      unsigned int i;
359
116M
      for (i = 0; i < nscns; i++)
360
115M
  {
361
115M
    struct internal_scnhdr tmp;
362
115M
    bfd_coff_swap_scnhdr_in (abfd,
363
115M
           (void *) (external_sections + i * scnhsz),
364
115M
           (void *) & tmp);
365
115M
    if (! make_a_section_from_file (abfd, &tmp, i + 1))
366
440k
      goto fail;
367
115M
  }
368
1.27M
    }
369
370
864k
  _bfd_coff_free_symbols (abfd);
371
864k
  return coff_object_cleanup;
372
373
501k
 fail:
374
501k
  coff_object_cleanup (abfd);
375
501k
  _bfd_coff_free_symbols (abfd);
376
501k
  bfd_release (abfd, tdata);
377
501k
 fail2:
378
501k
  abfd->tdata.any = tdata_save;
379
501k
  abfd->flags = oflags;
380
501k
  abfd->start_address = ostart;
381
501k
  return NULL;
382
501k
}
383
384
/* Turn a COFF file into a BFD, but fail with bfd_error_wrong_format if it is
385
   not a COFF file.  This is also used by ECOFF.  */
386
387
bfd_cleanup
388
coff_object_p (bfd *abfd)
389
61.1M
{
390
61.1M
  bfd_size_type filhsz;
391
61.1M
  bfd_size_type aoutsz;
392
61.1M
  unsigned int nscns;
393
61.1M
  void * filehdr;
394
61.1M
  struct internal_filehdr internal_f;
395
61.1M
  struct internal_aouthdr internal_a;
396
397
  /* Figure out how much to read.  */
398
61.1M
  filhsz = bfd_coff_filhsz (abfd);
399
61.1M
  aoutsz = bfd_coff_aoutsz (abfd);
400
401
61.1M
  filehdr = _bfd_alloc_and_read (abfd, filhsz, filhsz);
402
61.1M
  if (filehdr == NULL)
403
1.20M
    {
404
1.20M
      if (bfd_get_error () != bfd_error_system_call)
405
1.18M
  bfd_set_error (bfd_error_wrong_format);
406
1.20M
      return NULL;
407
1.20M
    }
408
59.9M
  bfd_coff_swap_filehdr_in (abfd, filehdr, &internal_f);
409
59.9M
  bfd_release (abfd, filehdr);
410
411
  /* The XCOFF format has two sizes for the f_opthdr.  SMALL_AOUTSZ
412
     (less than aoutsz) used in object files and AOUTSZ (equal to
413
     aoutsz) in executables.  The bfd_coff_swap_aouthdr_in function
414
     expects this header to be aoutsz bytes in length, so we use that
415
     value in the call to bfd_alloc below.  But we must be careful to
416
     only read in f_opthdr bytes in the call to bfd_read.  We should
417
     also attempt to catch corrupt or non-COFF binaries with a strange
418
     value for f_opthdr.  */
419
59.9M
  if (! bfd_coff_bad_format_hook (abfd, &internal_f)
420
59.9M
      || internal_f.f_opthdr > aoutsz)
421
59.2M
    {
422
59.2M
      bfd_set_error (bfd_error_wrong_format);
423
59.2M
      return NULL;
424
59.2M
    }
425
737k
  nscns = internal_f.f_nscns;
426
427
737k
  if (internal_f.f_opthdr)
428
231k
    {
429
231k
      void * opthdr;
430
431
231k
      opthdr = _bfd_alloc_and_read (abfd, aoutsz, internal_f.f_opthdr);
432
231k
      if (opthdr == NULL)
433
2.93k
  return NULL;
434
      /* PR 17512: file: 11056-1136-0.004.  */
435
229k
      if (internal_f.f_opthdr < aoutsz)
436
189k
  memset (((char *) opthdr) + internal_f.f_opthdr, 0,
437
189k
    aoutsz - internal_f.f_opthdr);
438
439
229k
      bfd_coff_swap_aouthdr_in (abfd, opthdr, (void *) &internal_a);
440
229k
      bfd_release (abfd, opthdr);
441
229k
    }
442
443
734k
  return coff_real_object_p (abfd, nscns, &internal_f,
444
734k
           (internal_f.f_opthdr != 0
445
734k
            ? &internal_a
446
734k
            : (struct internal_aouthdr *) NULL));
447
737k
}
448
449
static hashval_t
450
htab_hash_section_target_index (const void * entry)
451
9.26M
{
452
9.26M
  const struct bfd_section * sec = entry;
453
9.26M
  return sec->target_index;
454
9.26M
}
455
456
static int
457
htab_eq_section_target_index (const void * e1, const void * e2)
458
7.71M
{
459
7.71M
  const struct bfd_section * sec1 = e1;
460
7.71M
  const struct bfd_section * sec2 = e2;
461
7.71M
  return sec1->target_index == sec2->target_index;
462
7.71M
}
463
464
/* Get the BFD section from a COFF symbol section number.  */
465
466
asection *
467
coff_section_from_bfd_index (bfd *abfd, int section_index)
468
8.59M
{
469
8.59M
  if (section_index == N_ABS)
470
187k
    return bfd_abs_section_ptr;
471
8.40M
  if (section_index == N_UNDEF)
472
1.82M
    return bfd_und_section_ptr;
473
6.58M
  if (section_index == N_DEBUG)
474
2.58k
    return bfd_abs_section_ptr;
475
476
6.57M
  struct bfd_section *answer;
477
6.57M
  htab_t table = coff_data (abfd)->section_by_target_index;
478
479
6.57M
  if (!table)
480
81.4k
    {
481
81.4k
      table = htab_create (10, htab_hash_section_target_index,
482
81.4k
         htab_eq_section_target_index, NULL);
483
81.4k
      if (table == NULL)
484
0
  return bfd_und_section_ptr;
485
81.4k
      coff_data (abfd)->section_by_target_index = table;
486
81.4k
    }
487
488
6.57M
  if (htab_elements (table) == 0)
489
147k
    {
490
1.25M
      for (answer = abfd->sections; answer; answer = answer->next)
491
1.10M
  {
492
1.10M
    void **slot = htab_find_slot (table, answer, INSERT);
493
1.10M
    if (slot == NULL)
494
0
      return bfd_und_section_ptr;
495
1.10M
    *slot = answer;
496
1.10M
  }
497
147k
    }
498
499
6.57M
  struct bfd_section needle;
500
6.57M
  needle.target_index = section_index;
501
502
6.57M
  answer = htab_find (table, &needle);
503
6.57M
  if (answer != NULL)
504
308k
    return answer;
505
506
  /* Cover the unlikely case of sections added after the first call to
507
     this function.  */
508
7.22G
  for (answer = abfd->sections; answer; answer = answer->next)
509
7.22G
    if (answer->target_index == section_index)
510
242k
      {
511
242k
  void **slot = htab_find_slot (table, answer, INSERT);
512
242k
  if (slot != NULL)
513
242k
    *slot = answer;
514
242k
  return answer;
515
242k
      }
516
517
  /* We should not reach this point, but the SCO 3.2v4 /lib/libc_s.a
518
     has a bad symbol table in biglitpow.o.  */
519
6.02M
  return bfd_und_section_ptr;
520
6.26M
}
521
522
/* Get the upper bound of a COFF symbol table.  */
523
524
long
525
coff_get_symtab_upper_bound (bfd *abfd)
526
15.7k
{
527
15.7k
  if (!bfd_coff_slurp_symbol_table (abfd))
528
12.2k
    return -1;
529
530
3.43k
  return (bfd_get_symcount (abfd) + 1) * (sizeof (coff_symbol_type *));
531
15.7k
}
532
533
/* Canonicalize a COFF symbol table.  */
534
535
long
536
coff_canonicalize_symtab (bfd *abfd, asymbol **alocation)
537
3.43k
{
538
3.43k
  unsigned int counter;
539
3.43k
  coff_symbol_type *symbase;
540
3.43k
  coff_symbol_type **location = (coff_symbol_type **) alocation;
541
542
3.43k
  if (!bfd_coff_slurp_symbol_table (abfd))
543
0
    return -1;
544
545
3.43k
  symbase = obj_symbols (abfd);
546
3.43k
  counter = bfd_get_symcount (abfd);
547
105k
  while (counter-- > 0)
548
101k
    *location++ = symbase++;
549
550
3.43k
  *location = NULL;
551
552
3.43k
  return bfd_get_symcount (abfd);
553
3.43k
}
554
555
/* Get the name of a symbol.  The caller must pass in a buffer of size
556
   >= SYMNMLEN + 1.  */
557
558
const char *
559
_bfd_coff_internal_syment_name (bfd *abfd,
560
        const struct internal_syment *sym,
561
        char *buf)
562
8.92M
{
563
  /* FIXME: It's not clear this will work correctly if sizeof
564
     (_n_zeroes) != 4.  */
565
8.92M
  if (sym->_n._n_n._n_zeroes != 0
566
8.92M
      || sym->_n._n_n._n_offset == 0)
567
6.11M
    {
568
6.11M
      memcpy (buf, sym->_n._n_name, SYMNMLEN);
569
6.11M
      buf[SYMNMLEN] = '\0';
570
6.11M
      return buf;
571
6.11M
    }
572
2.81M
  else
573
2.81M
    {
574
2.81M
      const char *strings;
575
576
2.81M
      BFD_ASSERT (sym->_n._n_n._n_offset >= STRING_SIZE_SIZE);
577
2.81M
      strings = obj_coff_strings (abfd);
578
2.81M
      if (strings == NULL)
579
2.37M
  {
580
2.37M
    strings = _bfd_coff_read_string_table (abfd);
581
2.37M
    if (strings == NULL)
582
2.34M
      return NULL;
583
2.37M
  }
584
468k
      if (sym->_n._n_n._n_offset >= obj_coff_strings_len (abfd))
585
404k
  return NULL;
586
63.7k
      return strings + sym->_n._n_n._n_offset;
587
468k
    }
588
8.92M
}
589
590
/* Read in and swap the relocs.  This returns a buffer holding the
591
   relocs for section SEC in file ABFD.  If CACHE is TRUE and
592
   INTERNAL_RELOCS is NULL, the relocs read in will be saved in case
593
   the function is called again.  If EXTERNAL_RELOCS is not NULL, it
594
   is a buffer large enough to hold the unswapped relocs.  If
595
   INTERNAL_RELOCS is not NULL, it is a buffer large enough to hold
596
   the swapped relocs.  If REQUIRE_INTERNAL is TRUE, then the return
597
   value must be INTERNAL_RELOCS.  The function returns NULL on error.  */
598
599
struct internal_reloc *
600
_bfd_coff_read_internal_relocs (bfd *abfd,
601
        asection *sec,
602
        bool cache,
603
        bfd_byte *external_relocs,
604
        bool require_internal,
605
        struct internal_reloc *internal_relocs)
606
0
{
607
0
  bfd_size_type relsz;
608
0
  bfd_byte *free_external = NULL;
609
0
  struct internal_reloc *free_internal = NULL;
610
0
  bfd_byte *erel;
611
0
  bfd_byte *erel_end;
612
0
  struct internal_reloc *irel;
613
0
  bfd_size_type amt;
614
615
0
  if (sec->reloc_count == 0)
616
0
    return internal_relocs; /* Nothing to do.  */
617
618
0
  if (coff_section_data (abfd, sec) != NULL
619
0
      && coff_section_data (abfd, sec)->relocs != NULL)
620
0
    {
621
0
      if (! require_internal)
622
0
  return coff_section_data (abfd, sec)->relocs;
623
0
      memcpy (internal_relocs, coff_section_data (abfd, sec)->relocs,
624
0
        sec->reloc_count * sizeof (struct internal_reloc));
625
0
      return internal_relocs;
626
0
    }
627
628
0
  relsz = bfd_coff_relsz (abfd);
629
630
0
  amt = sec->reloc_count * relsz;
631
0
  if (external_relocs == NULL)
632
0
    {
633
0
      free_external = (bfd_byte *) bfd_malloc (amt);
634
0
      if (free_external == NULL)
635
0
  goto error_return;
636
0
      external_relocs = free_external;
637
0
    }
638
639
0
  if (bfd_seek (abfd, sec->rel_filepos, SEEK_SET) != 0
640
0
      || bfd_read (external_relocs, amt, abfd) != amt)
641
0
    goto error_return;
642
643
0
  if (internal_relocs == NULL)
644
0
    {
645
0
      amt = sec->reloc_count;
646
0
      amt *= sizeof (struct internal_reloc);
647
0
      free_internal = (struct internal_reloc *) bfd_malloc (amt);
648
0
      if (free_internal == NULL)
649
0
  goto error_return;
650
0
      internal_relocs = free_internal;
651
0
    }
652
653
  /* Swap in the relocs.  */
654
0
  erel = external_relocs;
655
0
  erel_end = erel + relsz * sec->reloc_count;
656
0
  irel = internal_relocs;
657
0
  for (; erel < erel_end; erel += relsz, irel++)
658
0
    bfd_coff_swap_reloc_in (abfd, (void *) erel, (void *) irel);
659
660
0
  free (free_external);
661
0
  free_external = NULL;
662
663
0
  if (cache && free_internal != NULL)
664
0
    {
665
0
      if (coff_section_data (abfd, sec) == NULL)
666
0
  {
667
0
    amt = sizeof (struct coff_section_tdata);
668
0
    sec->used_by_bfd = bfd_zalloc (abfd, amt);
669
0
    if (sec->used_by_bfd == NULL)
670
0
      goto error_return;
671
0
    coff_section_data (abfd, sec)->contents = NULL;
672
0
  }
673
0
      coff_section_data (abfd, sec)->relocs = free_internal;
674
0
    }
675
676
0
  return internal_relocs;
677
678
0
 error_return:
679
0
  free (free_external);
680
0
  free (free_internal);
681
0
  return NULL;
682
0
}
683
684
/* Set lineno_count for the output sections of a COFF file.  */
685
686
int
687
coff_count_linenumbers (bfd *abfd)
688
2
{
689
2
  unsigned int limit = bfd_get_symcount (abfd);
690
2
  unsigned int i;
691
2
  int total = 0;
692
2
  asymbol **p;
693
2
  asection *s;
694
695
2
  if (limit == 0)
696
0
    {
697
      /* This may be from the backend linker, in which case the
698
   lineno_count in the sections is correct.  */
699
0
      for (s = abfd->sections; s != NULL; s = s->next)
700
0
  total += s->lineno_count;
701
0
      return total;
702
0
    }
703
704
9
  for (s = abfd->sections; s != NULL; s = s->next)
705
7
    BFD_ASSERT (s->lineno_count == 0);
706
707
774
  for (p = abfd->outsymbols, i = 0; i < limit; i++, p++)
708
772
    {
709
772
      asymbol *q_maybe = *p;
710
711
772
      if (bfd_asymbol_bfd (q_maybe) != NULL
712
772
    && bfd_family_coff (bfd_asymbol_bfd (q_maybe)))
713
772
  {
714
772
    coff_symbol_type *q = coffsymbol (q_maybe);
715
716
    /* The AIX 4.1 compiler can sometimes generate line numbers
717
       attached to debugging symbols.  We try to simply ignore
718
       those here.  */
719
772
    if (q->lineno != NULL
720
772
        && q->symbol.section->owner != NULL)
721
0
      {
722
        /* This symbol has line numbers.  Increment the owning
723
     section's linenumber count.  */
724
0
        alent *l = q->lineno;
725
726
0
        do
727
0
    {
728
0
      asection * sec = q->symbol.section->output_section;
729
730
      /* Do not try to update fields in read-only sections.  */
731
0
      if (! bfd_is_const_section (sec))
732
0
        sec->lineno_count ++;
733
734
0
      ++total;
735
0
      ++l;
736
0
    }
737
0
        while (l->line_number != 0);
738
0
      }
739
772
  }
740
772
    }
741
742
2
  return total;
743
2
}
744
745
static void
746
fixup_symbol_value (bfd *abfd,
747
        coff_symbol_type *coff_symbol_ptr,
748
        struct internal_syment *syment)
749
772
{
750
  /* Normalize the symbol flags.  */
751
772
  if (coff_symbol_ptr->symbol.section
752
772
      && bfd_is_com_section (coff_symbol_ptr->symbol.section))
753
0
    {
754
      /* A common symbol is undefined with a value.  */
755
0
      syment->n_scnum = N_UNDEF;
756
0
      syment->n_value = coff_symbol_ptr->symbol.value;
757
0
    }
758
772
  else if ((coff_symbol_ptr->symbol.flags & BSF_DEBUGGING) != 0
759
772
     && (coff_symbol_ptr->symbol.flags & BSF_DEBUGGING_RELOC) == 0)
760
0
    {
761
0
      syment->n_value = coff_symbol_ptr->symbol.value;
762
0
    }
763
772
  else if (bfd_is_und_section (coff_symbol_ptr->symbol.section))
764
769
    {
765
769
      syment->n_scnum = N_UNDEF;
766
769
      syment->n_value = 0;
767
769
    }
768
  /* FIXME: Do we need to handle the absolute section here?  */
769
3
  else
770
3
    {
771
3
      if (coff_symbol_ptr->symbol.section)
772
3
  {
773
3
    syment->n_scnum =
774
3
      coff_symbol_ptr->symbol.section->output_section->target_index;
775
776
3
    syment->n_value = (coff_symbol_ptr->symbol.value
777
3
           + coff_symbol_ptr->symbol.section->output_offset);
778
3
    if (! obj_pe (abfd))
779
0
      {
780
0
        syment->n_value += (syment->n_sclass == C_STATLAB)
781
0
    ? coff_symbol_ptr->symbol.section->output_section->lma
782
0
    : coff_symbol_ptr->symbol.section->output_section->vma;
783
0
      }
784
3
  }
785
0
      else
786
0
  {
787
0
    BFD_ASSERT (0);
788
    /* This can happen, but I don't know why yet (steve@cygnus.com) */
789
0
    syment->n_scnum = N_ABS;
790
0
    syment->n_value = coff_symbol_ptr->symbol.value;
791
0
  }
792
3
    }
793
772
}
794
795
/* Run through all the symbols in the symbol table and work out what
796
   their indexes into the symbol table will be when output.
797
798
   Coff requires that each C_FILE symbol points to the next one in the
799
   chain, and that the last one points to the first external symbol. We
800
   do that here too.  */
801
802
bool
803
coff_renumber_symbols (bfd *bfd_ptr, int *first_undef)
804
2
{
805
2
  unsigned int symbol_count = bfd_get_symcount (bfd_ptr);
806
2
  asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;
807
2
  unsigned int native_index = 0;
808
2
  struct internal_syment *last_file = NULL;
809
2
  unsigned int symbol_index;
810
811
  /* COFF demands that undefined symbols come after all other symbols.
812
     Since we don't need to impose this extra knowledge on all our
813
     client programs, deal with that here.  Sort the symbol table;
814
     just move the undefined symbols to the end, leaving the rest
815
     alone.  The O'Reilly book says that defined global symbols come
816
     at the end before the undefined symbols, so we do that here as
817
     well.  */
818
  /* @@ Do we have some condition we could test for, so we don't always
819
     have to do this?  I don't think relocatability is quite right, but
820
     I'm not certain.  [raeburn:19920508.1711EST]  */
821
2
  {
822
2
    asymbol **newsyms;
823
2
    unsigned int i;
824
2
    bfd_size_type amt;
825
826
2
    amt = sizeof (asymbol *) * ((bfd_size_type) symbol_count + 1);
827
2
    newsyms = (asymbol **) bfd_alloc (bfd_ptr, amt);
828
2
    if (!newsyms)
829
0
      return false;
830
2
    bfd_ptr->outsymbols = newsyms;
831
774
    for (i = 0; i < symbol_count; i++)
832
772
      if ((symbol_ptr_ptr[i]->flags & BSF_NOT_AT_END) != 0
833
772
    || (!bfd_is_und_section (symbol_ptr_ptr[i]->section)
834
772
        && !bfd_is_com_section (symbol_ptr_ptr[i]->section)
835
772
        && ((symbol_ptr_ptr[i]->flags & BSF_FUNCTION) != 0
836
3
      || ((symbol_ptr_ptr[i]->flags & (BSF_GLOBAL | BSF_WEAK))
837
3
          == 0))))
838
0
  *newsyms++ = symbol_ptr_ptr[i];
839
840
774
    for (i = 0; i < symbol_count; i++)
841
772
      if ((symbol_ptr_ptr[i]->flags & BSF_NOT_AT_END) == 0
842
772
    && !bfd_is_und_section (symbol_ptr_ptr[i]->section)
843
772
    && (bfd_is_com_section (symbol_ptr_ptr[i]->section)
844
3
        || ((symbol_ptr_ptr[i]->flags & BSF_FUNCTION) == 0
845
3
      && ((symbol_ptr_ptr[i]->flags & (BSF_GLOBAL | BSF_WEAK))
846
3
          != 0))))
847
3
  *newsyms++ = symbol_ptr_ptr[i];
848
849
2
    *first_undef = newsyms - bfd_ptr->outsymbols;
850
851
774
    for (i = 0; i < symbol_count; i++)
852
772
      if ((symbol_ptr_ptr[i]->flags & BSF_NOT_AT_END) == 0
853
772
    && bfd_is_und_section (symbol_ptr_ptr[i]->section))
854
769
  *newsyms++ = symbol_ptr_ptr[i];
855
2
    *newsyms = (asymbol *) NULL;
856
2
    symbol_ptr_ptr = bfd_ptr->outsymbols;
857
2
  }
858
859
774
  for (symbol_index = 0; symbol_index < symbol_count; symbol_index++)
860
772
    {
861
772
      coff_symbol_type *coff_symbol_ptr;
862
863
772
      coff_symbol_ptr = coff_symbol_from (symbol_ptr_ptr[symbol_index]);
864
772
      symbol_ptr_ptr[symbol_index]->udata.i = symbol_index;
865
772
      if (coff_symbol_ptr && coff_symbol_ptr->native)
866
772
  {
867
772
    combined_entry_type *s = coff_symbol_ptr->native;
868
772
    int i;
869
870
772
    BFD_ASSERT (s->is_sym);
871
772
    if (s->u.syment.n_sclass == C_FILE)
872
0
      {
873
0
        if (last_file != NULL)
874
0
    last_file->n_value = native_index;
875
0
        last_file = &(s->u.syment);
876
0
      }
877
772
    else
878
      /* Modify the symbol values according to their section and
879
         type.  */
880
772
      fixup_symbol_value (bfd_ptr, coff_symbol_ptr, &(s->u.syment));
881
882
1.54k
    for (i = 0; i < s->u.syment.n_numaux + 1; i++)
883
772
      s[i].offset = native_index++;
884
772
  }
885
0
      else
886
0
  native_index++;
887
772
    }
888
889
2
  obj_conv_table_size (bfd_ptr) = native_index;
890
891
2
  return true;
892
2
}
893
894
/* Run thorough the symbol table again, and fix it so that all
895
   pointers to entries are changed to the entries' index in the output
896
   symbol table.  */
897
898
void
899
coff_mangle_symbols (bfd *bfd_ptr)
900
2
{
901
2
  unsigned int symbol_count = bfd_get_symcount (bfd_ptr);
902
2
  asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;
903
2
  unsigned int symbol_index;
904
905
774
  for (symbol_index = 0; symbol_index < symbol_count; symbol_index++)
906
772
    {
907
772
      coff_symbol_type *coff_symbol_ptr;
908
909
772
      coff_symbol_ptr = coff_symbol_from (symbol_ptr_ptr[symbol_index]);
910
772
      if (coff_symbol_ptr && coff_symbol_ptr->native)
911
772
  {
912
772
    int i;
913
772
    combined_entry_type *s = coff_symbol_ptr->native;
914
915
772
    BFD_ASSERT (s->is_sym);
916
772
    if (s->fix_value)
917
0
      {
918
        /* FIXME: We should use a union here.  */
919
0
        s->u.syment.n_value =
920
0
    (uintptr_t) ((combined_entry_type *)
921
0
           (uintptr_t) s->u.syment.n_value)->offset;
922
0
        s->fix_value = 0;
923
0
      }
924
772
    if (s->fix_line)
925
0
      {
926
        /* The value is the offset into the line number entries
927
     for the symbol's section.  On output, the symbol's
928
     section should be N_DEBUG.  */
929
0
        s->u.syment.n_value =
930
0
    (coff_symbol_ptr->symbol.section->output_section->line_filepos
931
0
     + s->u.syment.n_value * bfd_coff_linesz (bfd_ptr));
932
0
        coff_symbol_ptr->symbol.section =
933
0
    coff_section_from_bfd_index (bfd_ptr, N_DEBUG);
934
0
        BFD_ASSERT (coff_symbol_ptr->symbol.flags & BSF_DEBUGGING);
935
0
      }
936
772
    for (i = 0; i < s->u.syment.n_numaux; i++)
937
0
      {
938
0
        combined_entry_type *a = s + i + 1;
939
940
0
        BFD_ASSERT (! a->is_sym);
941
0
        if (a->fix_tag)
942
0
    {
943
0
      a->u.auxent.x_sym.x_tagndx.u32 =
944
0
        a->u.auxent.x_sym.x_tagndx.p->offset;
945
0
      a->fix_tag = 0;
946
0
    }
947
0
        if (a->fix_end)
948
0
    {
949
0
      a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.u32 =
950
0
        a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p->offset;
951
0
      a->fix_end = 0;
952
0
    }
953
0
        if (a->fix_scnlen)
954
0
    {
955
0
      a->u.auxent.x_csect.x_scnlen.u64 =
956
0
        a->u.auxent.x_csect.x_scnlen.p->offset;
957
0
      a->fix_scnlen = 0;
958
0
    }
959
0
      }
960
772
  }
961
772
    }
962
2
}
963
964
static bool
965
coff_write_auxent_fname (bfd *abfd,
966
       char *str,
967
       union internal_auxent *auxent,
968
       struct bfd_strtab_hash *strtab,
969
       bool hash)
970
0
{
971
0
  unsigned int str_length = strlen (str);
972
0
  unsigned int filnmlen = bfd_coff_filnmlen (abfd);
973
974
0
  if (bfd_coff_long_filenames (abfd))
975
0
    {
976
0
      if (str_length <= filnmlen)
977
0
  strncpy (auxent->x_file.x_n.x_fname, str, filnmlen);
978
0
      else
979
0
  {
980
0
    bfd_size_type indx = _bfd_stringtab_add (strtab, str, hash, false);
981
982
0
    if (indx == (bfd_size_type) -1)
983
0
      return false;
984
985
0
    auxent->x_file.x_n.x_n.x_offset = STRING_SIZE_SIZE + indx;
986
0
    auxent->x_file.x_n.x_n.x_zeroes = 0;
987
0
  }
988
0
    }
989
0
  else
990
0
    {
991
0
      strncpy (auxent->x_file.x_n.x_fname, str, filnmlen);
992
0
      if (str_length > filnmlen)
993
0
  str[filnmlen] = '\0';
994
0
    }
995
996
0
  return true;
997
0
}
998
999
static bool
1000
coff_fix_symbol_name (bfd *abfd,
1001
          asymbol *symbol,
1002
          combined_entry_type *native,
1003
          struct bfd_strtab_hash *strtab,
1004
          bool hash,
1005
          asection **debug_string_section_p,
1006
          bfd_size_type *debug_string_size_p)
1007
772
{
1008
772
  unsigned int name_length;
1009
772
  char *name = (char *) (symbol->name);
1010
772
  bfd_size_type indx;
1011
1012
772
  if (name == NULL)
1013
0
    {
1014
      /* COFF symbols always have names, so we'll make one up.  */
1015
0
      symbol->name = "strange";
1016
0
      name = (char *) symbol->name;
1017
0
    }
1018
772
  name_length = strlen (name);
1019
1020
772
  BFD_ASSERT (native->is_sym);
1021
772
  if (native->u.syment.n_sclass == C_FILE
1022
772
      && native->u.syment.n_numaux > 0)
1023
0
    {
1024
0
      if (bfd_coff_force_symnames_in_strings (abfd))
1025
0
  {
1026
0
    indx = _bfd_stringtab_add (strtab, ".file", hash, false);
1027
0
    if (indx == (bfd_size_type) -1)
1028
0
      return false;
1029
1030
0
    native->u.syment._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
1031
0
    native->u.syment._n._n_n._n_zeroes = 0;
1032
0
  }
1033
0
      else
1034
0
  strncpy (native->u.syment._n._n_name, ".file", SYMNMLEN);
1035
1036
0
      BFD_ASSERT (! (native + 1)->is_sym);
1037
0
      if (!coff_write_auxent_fname (abfd, name, &(native + 1)->u.auxent,
1038
0
             strtab, hash))
1039
0
  return false;
1040
0
    }
1041
772
  else
1042
772
    {
1043
772
      if (name_length <= SYMNMLEN && !bfd_coff_force_symnames_in_strings (abfd))
1044
  /* This name will fit into the symbol neatly.  */
1045
771
  strncpy (native->u.syment._n._n_name, symbol->name, SYMNMLEN);
1046
1047
1
      else if (!bfd_coff_symname_in_debug (abfd, &native->u.syment))
1048
1
  {
1049
1
    indx = _bfd_stringtab_add (strtab, name, hash, false);
1050
1
    if (indx == (bfd_size_type) -1)
1051
0
      return false;
1052
1053
1
    native->u.syment._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
1054
1
    native->u.syment._n._n_n._n_zeroes = 0;
1055
1
  }
1056
0
      else
1057
0
  {
1058
0
    file_ptr filepos;
1059
0
    bfd_byte buf[4];
1060
0
    int prefix_len = bfd_coff_debug_string_prefix_length (abfd);
1061
1062
    /* This name should be written into the .debug section.  For
1063
       some reason each name is preceded by a two byte length
1064
       and also followed by a null byte.  FIXME: We assume that
1065
       the .debug section has already been created, and that it
1066
       is large enough.  */
1067
0
    if (*debug_string_section_p == (asection *) NULL)
1068
0
      *debug_string_section_p = bfd_get_section_by_name (abfd, ".debug");
1069
0
    filepos = bfd_tell (abfd);
1070
0
    if (prefix_len == 4)
1071
0
      bfd_put_32 (abfd, (bfd_vma) (name_length + 1), buf);
1072
0
    else
1073
0
      bfd_put_16 (abfd, (bfd_vma) (name_length + 1), buf);
1074
1075
0
    if (!bfd_set_section_contents (abfd,
1076
0
           *debug_string_section_p,
1077
0
           (void *) buf,
1078
0
           (file_ptr) *debug_string_size_p,
1079
0
           (bfd_size_type) prefix_len)
1080
0
        || !bfd_set_section_contents (abfd,
1081
0
              *debug_string_section_p,
1082
0
              (void *) symbol->name,
1083
0
              (file_ptr) (*debug_string_size_p
1084
0
              + prefix_len),
1085
0
              (bfd_size_type) name_length + 1))
1086
0
      abort ();
1087
0
    if (bfd_seek (abfd, filepos, SEEK_SET) != 0)
1088
0
      abort ();
1089
0
    native->u.syment._n._n_n._n_offset =
1090
0
        *debug_string_size_p + prefix_len;
1091
0
    native->u.syment._n._n_n._n_zeroes = 0;
1092
0
    *debug_string_size_p += name_length + 1 + prefix_len;
1093
0
  }
1094
772
    }
1095
1096
772
  return true;
1097
772
}
1098
1099
/* We need to keep track of the symbol index so that when we write out
1100
   the relocs we can get the index for a symbol.  This method is a
1101
   hack.  FIXME.  */
1102
1103
772
#define set_index(symbol, idx)  ((symbol)->udata.i = (idx))
1104
1105
/* Write a symbol out to a COFF file.  */
1106
1107
static bool
1108
coff_write_symbol (bfd *abfd,
1109
       asymbol *symbol,
1110
       combined_entry_type *native,
1111
       bfd_vma *written,
1112
       struct bfd_strtab_hash *strtab,
1113
       bool hash,
1114
       asection **debug_string_section_p,
1115
       bfd_size_type *debug_string_size_p)
1116
772
{
1117
772
  unsigned int numaux = native->u.syment.n_numaux;
1118
772
  int type = native->u.syment.n_type;
1119
772
  int n_sclass = (int) native->u.syment.n_sclass;
1120
772
  asection *output_section = symbol->section->output_section
1121
772
             ? symbol->section->output_section
1122
772
             : symbol->section;
1123
772
  void * buf;
1124
772
  bfd_size_type symesz;
1125
1126
772
  BFD_ASSERT (native->is_sym);
1127
1128
772
  if (native->u.syment.n_sclass == C_FILE)
1129
0
    symbol->flags |= BSF_DEBUGGING;
1130
1131
772
  if (symbol->flags & BSF_DEBUGGING
1132
772
      && bfd_is_abs_section (symbol->section))
1133
0
    native->u.syment.n_scnum = N_DEBUG;
1134
1135
772
  else if (bfd_is_abs_section (symbol->section))
1136
0
    native->u.syment.n_scnum = N_ABS;
1137
1138
772
  else if (bfd_is_und_section (symbol->section))
1139
769
    native->u.syment.n_scnum = N_UNDEF;
1140
1141
3
  else
1142
3
    native->u.syment.n_scnum =
1143
3
      output_section->target_index;
1144
1145
772
  if (!coff_fix_symbol_name (abfd, symbol, native, strtab, hash,
1146
772
           debug_string_section_p, debug_string_size_p))
1147
0
    return false;
1148
1149
772
  symesz = bfd_coff_symesz (abfd);
1150
772
  buf = bfd_alloc (abfd, symesz);
1151
772
  if (!buf)
1152
0
    return false;
1153
772
  bfd_coff_swap_sym_out (abfd, &native->u.syment, buf);
1154
772
  if (bfd_write (buf, symesz, abfd) != symesz)
1155
0
    return false;
1156
772
  bfd_release (abfd, buf);
1157
1158
772
  if (native->u.syment.n_numaux > 0)
1159
0
    {
1160
0
      bfd_size_type auxesz;
1161
0
      unsigned int j;
1162
1163
0
      auxesz = bfd_coff_auxesz (abfd);
1164
0
      buf = bfd_alloc (abfd, auxesz);
1165
0
      if (!buf)
1166
0
  return false;
1167
0
      for (j = 0; j < native->u.syment.n_numaux; j++)
1168
0
  {
1169
0
    BFD_ASSERT (! (native + j + 1)->is_sym);
1170
1171
    /* Adjust auxent only if this isn't the filename
1172
       auxiliary entry.  */
1173
0
    if (native->u.syment.n_sclass == C_FILE
1174
0
        && (native + j + 1)->u.auxent.x_file.x_ftype
1175
0
        && (native + j + 1)->extrap)
1176
0
      coff_write_auxent_fname (abfd, (char *) (native + j + 1)->extrap,
1177
0
             &(native + j + 1)->u.auxent, strtab, hash);
1178
1179
0
    bfd_coff_swap_aux_out (abfd,
1180
0
         &((native + j + 1)->u.auxent),
1181
0
         type, n_sclass, (int) j,
1182
0
         native->u.syment.n_numaux,
1183
0
         buf);
1184
0
    if (bfd_write (buf, auxesz, abfd) != auxesz)
1185
0
      return false;
1186
0
  }
1187
0
      bfd_release (abfd, buf);
1188
0
    }
1189
1190
  /* Store the index for use when we write out the relocs.  */
1191
772
  set_index (symbol, *written);
1192
1193
772
  *written += numaux + 1;
1194
772
  return true;
1195
772
}
1196
1197
/* Write out a symbol to a COFF file that does not come from a COFF
1198
   file originally.  This symbol may have been created by the linker,
1199
   or we may be linking a non COFF file to a COFF file.  */
1200
1201
bool
1202
coff_write_alien_symbol (bfd *abfd,
1203
       asymbol *symbol,
1204
       struct internal_syment *isym,
1205
       bfd_vma *written,
1206
       struct bfd_strtab_hash *strtab,
1207
       bool hash,
1208
       asection **debug_string_section_p,
1209
       bfd_size_type *debug_string_size_p)
1210
0
{
1211
0
  combined_entry_type *native;
1212
0
  combined_entry_type dummy[2];
1213
0
  asection *output_section = symbol->section->output_section
1214
0
             ? symbol->section->output_section
1215
0
             : symbol->section;
1216
0
  struct bfd_link_info *link_info = coff_data (abfd)->link_info;
1217
0
  bool ret;
1218
1219
0
  if ((!link_info || link_info->strip_discarded)
1220
0
      && !bfd_is_abs_section (symbol->section)
1221
0
      && symbol->section->output_section == bfd_abs_section_ptr)
1222
0
    {
1223
0
      symbol->name = "";
1224
0
      if (isym != NULL)
1225
0
  memset (isym, 0, sizeof (*isym));
1226
0
      return true;
1227
0
    }
1228
0
  memset (dummy, 0, sizeof dummy);
1229
0
  native = dummy;
1230
0
  native->is_sym = true;
1231
0
  native[1].is_sym = false;
1232
0
  native->u.syment.n_type = T_NULL;
1233
0
  native->u.syment.n_flags = 0;
1234
0
  native->u.syment.n_numaux = 0;
1235
0
  if (bfd_is_und_section (symbol->section))
1236
0
    {
1237
0
      native->u.syment.n_scnum = N_UNDEF;
1238
0
      native->u.syment.n_value = symbol->value;
1239
0
    }
1240
0
  else if (bfd_is_com_section (symbol->section))
1241
0
    {
1242
0
      native->u.syment.n_scnum = N_UNDEF;
1243
0
      native->u.syment.n_value = symbol->value;
1244
0
    }
1245
0
  else if (symbol->flags & BSF_FILE)
1246
0
    {
1247
0
      native->u.syment.n_scnum = N_DEBUG;
1248
0
      native->u.syment.n_numaux = 1;
1249
0
    }
1250
0
  else if (symbol->flags & BSF_DEBUGGING)
1251
0
    {
1252
      /* There isn't much point to writing out a debugging symbol
1253
   unless we are prepared to convert it into COFF debugging
1254
   format.  So, we just ignore them.  We must clobber the symbol
1255
   name to keep it from being put in the string table.  */
1256
0
      symbol->name = "";
1257
0
      if (isym != NULL)
1258
0
  memset (isym, 0, sizeof (*isym));
1259
0
      return true;
1260
0
    }
1261
0
  else
1262
0
    {
1263
0
      native->u.syment.n_scnum = output_section->target_index;
1264
0
      native->u.syment.n_value = (symbol->value
1265
0
          + symbol->section->output_offset);
1266
0
      if (! obj_pe (abfd))
1267
0
  native->u.syment.n_value += output_section->vma;
1268
1269
      /* Copy the any flags from the file header into the symbol.
1270
   FIXME: Why?  */
1271
0
      {
1272
0
  coff_symbol_type *c = coff_symbol_from (symbol);
1273
0
  if (c != (coff_symbol_type *) NULL)
1274
0
    native->u.syment.n_flags = bfd_asymbol_bfd (&c->symbol)->flags;
1275
0
      }
1276
0
    }
1277
1278
0
  native->u.syment.n_type = 0;
1279
0
  if (symbol->flags & BSF_FILE)
1280
0
    native->u.syment.n_sclass = C_FILE;
1281
0
  else if (symbol->flags & BSF_LOCAL)
1282
0
    native->u.syment.n_sclass = C_STAT;
1283
0
  else if (symbol->flags & BSF_WEAK)
1284
0
    native->u.syment.n_sclass = obj_pe (abfd) ? C_NT_WEAK : C_WEAKEXT;
1285
0
  else
1286
0
    native->u.syment.n_sclass = C_EXT;
1287
1288
0
  ret = coff_write_symbol (abfd, symbol, native, written, strtab, hash,
1289
0
         debug_string_section_p, debug_string_size_p);
1290
0
  if (isym != NULL)
1291
0
    *isym = native->u.syment;
1292
0
  return ret;
1293
0
}
1294
1295
/* Write a native symbol to a COFF file.  */
1296
1297
static bool
1298
coff_write_native_symbol (bfd *abfd,
1299
        coff_symbol_type *symbol,
1300
        bfd_vma *written,
1301
        struct bfd_strtab_hash *strtab,
1302
        asection **debug_string_section_p,
1303
        bfd_size_type *debug_string_size_p)
1304
772
{
1305
772
  combined_entry_type *native = symbol->native;
1306
772
  alent *lineno = symbol->lineno;
1307
772
  struct bfd_link_info *link_info = coff_data (abfd)->link_info;
1308
1309
772
  if ((!link_info || link_info->strip_discarded)
1310
772
      && !bfd_is_abs_section (symbol->symbol.section)
1311
772
      && symbol->symbol.section->output_section == bfd_abs_section_ptr)
1312
0
    {
1313
0
      symbol->symbol.name = "";
1314
0
      return true;
1315
0
    }
1316
1317
772
  BFD_ASSERT (native->is_sym);
1318
  /* If this symbol has an associated line number, we must store the
1319
     symbol index in the line number field.  We also tag the auxent to
1320
     point to the right place in the lineno table.  */
1321
772
  if (lineno && !symbol->done_lineno && symbol->symbol.section->owner != NULL)
1322
0
    {
1323
0
      unsigned int count = 0;
1324
1325
0
      lineno[count].u.offset = *written;
1326
0
      if (native->u.syment.n_numaux)
1327
0
  {
1328
0
    union internal_auxent *a = &((native + 1)->u.auxent);
1329
1330
0
    a->x_sym.x_fcnary.x_fcn.x_lnnoptr =
1331
0
      symbol->symbol.section->output_section->moving_line_filepos;
1332
0
  }
1333
1334
      /* Count and relocate all other linenumbers.  */
1335
0
      count++;
1336
0
      while (lineno[count].line_number != 0)
1337
0
  {
1338
0
    lineno[count].u.offset +=
1339
0
      (symbol->symbol.section->output_section->vma
1340
0
       + symbol->symbol.section->output_offset);
1341
0
    count++;
1342
0
  }
1343
0
      symbol->done_lineno = true;
1344
1345
0
      if (! bfd_is_const_section (symbol->symbol.section->output_section))
1346
0
  symbol->symbol.section->output_section->moving_line_filepos +=
1347
0
    count * bfd_coff_linesz (abfd);
1348
0
    }
1349
1350
772
  return coff_write_symbol (abfd, &(symbol->symbol), native, written,
1351
772
          strtab, true, debug_string_section_p,
1352
772
          debug_string_size_p);
1353
772
}
1354
1355
static void
1356
null_error_handler (const char *fmt ATTRIBUTE_UNUSED,
1357
        va_list ap ATTRIBUTE_UNUSED)
1358
768
{
1359
768
}
1360
1361
/* Write out the COFF symbols.  */
1362
1363
bool
1364
coff_write_symbols (bfd *abfd)
1365
2
{
1366
2
  struct bfd_strtab_hash *strtab;
1367
2
  asection *debug_string_section;
1368
2
  bfd_size_type debug_string_size;
1369
2
  unsigned int i;
1370
2
  unsigned int limit = bfd_get_symcount (abfd);
1371
2
  bfd_vma written = 0;
1372
2
  asymbol **p;
1373
1374
2
  debug_string_section = NULL;
1375
2
  debug_string_size = 0;
1376
1377
2
  strtab = _bfd_stringtab_init ();
1378
2
  if (strtab == NULL)
1379
0
    return false;
1380
1381
  /* If this target supports long section names, they must be put into
1382
     the string table.  This is supported by PE.  This code must
1383
     handle section names just as they are handled in
1384
     coff_write_object_contents.  This is why we pass hash as FALSE below.  */
1385
2
  if (bfd_coff_long_section_names (abfd))
1386
1
    {
1387
1
      asection *o;
1388
1389
6
      for (o = abfd->sections; o != NULL; o = o->next)
1390
5
  if (strlen (o->name) > SCNNMLEN
1391
5
      && _bfd_stringtab_add (strtab, o->name, false, false)
1392
0
         == (bfd_size_type) -1)
1393
0
    return false;
1394
1
    }
1395
1396
  /* Seek to the right place.  */
1397
2
  if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0)
1398
0
    return false;
1399
1400
  /* Output all the symbols we have.  */
1401
2
  written = 0;
1402
774
  for (p = abfd->outsymbols, i = 0; i < limit; i++, p++)
1403
772
    {
1404
772
      asymbol *symbol = *p;
1405
772
      coff_symbol_type *c_symbol = coff_symbol_from (symbol);
1406
1407
772
      if (c_symbol == (coff_symbol_type *) NULL
1408
772
    || c_symbol->native == (combined_entry_type *) NULL)
1409
0
  {
1410
0
    if (!coff_write_alien_symbol (abfd, symbol, NULL, &written,
1411
0
          strtab, true, &debug_string_section,
1412
0
          &debug_string_size))
1413
0
      return false;
1414
0
  }
1415
772
      else
1416
772
  {
1417
772
    if (coff_backend_info (abfd)->_bfd_coff_classify_symbol != NULL)
1418
772
      {
1419
772
        bfd_error_handler_type current_error_handler;
1420
772
        enum coff_symbol_classification sym_class;
1421
772
        unsigned char *n_sclass;
1422
1423
        /* Suppress error reporting by bfd_coff_classify_symbol.
1424
     Error messages can be generated when we are processing a local
1425
     symbol which has no associated section and we do not have to
1426
     worry about this, all we need to know is that it is local.  */
1427
772
        current_error_handler = bfd_set_error_handler (null_error_handler);
1428
772
        BFD_ASSERT (c_symbol->native->is_sym);
1429
772
        sym_class = bfd_coff_classify_symbol (abfd,
1430
772
                &c_symbol->native->u.syment);
1431
772
        (void) bfd_set_error_handler (current_error_handler);
1432
1433
772
        n_sclass = &c_symbol->native->u.syment.n_sclass;
1434
1435
        /* If the symbol class has been changed (eg objcopy/ld script/etc)
1436
     we cannot retain the existing sclass from the original symbol.
1437
     Weak symbols only have one valid sclass, so just set it always.
1438
     If it is not local class and should be, set it C_STAT.
1439
     If it is global and not classified as global, or if it is
1440
     weak (which is also classified as global), set it C_EXT.  */
1441
1442
772
        if (symbol->flags & BSF_WEAK)
1443
0
    *n_sclass = obj_pe (abfd) ? C_NT_WEAK : C_WEAKEXT;
1444
772
        else if (symbol->flags & BSF_LOCAL && sym_class != COFF_SYMBOL_LOCAL)
1445
0
    *n_sclass = C_STAT;
1446
772
        else if (symbol->flags & BSF_GLOBAL
1447
772
           && (sym_class != COFF_SYMBOL_GLOBAL
1448
#ifdef COFF_WITH_PE
1449
         || *n_sclass == C_NT_WEAK
1450
#endif
1451
4
         || *n_sclass == C_WEAKEXT))
1452
3
    c_symbol->native->u.syment.n_sclass = C_EXT;
1453
772
      }
1454
1455
772
    if (!coff_write_native_symbol (abfd, c_symbol, &written,
1456
772
           strtab, &debug_string_section,
1457
772
           &debug_string_size))
1458
0
      return false;
1459
772
  }
1460
772
    }
1461
1462
2
  obj_raw_syment_count (abfd) = written;
1463
1464
  /* Now write out strings.
1465
1466
     We would normally not write anything here if there are no strings, but
1467
     we'll write out 4 so that any stupid coff reader which tries to read the
1468
     string table even when there isn't one won't croak.  */
1469
2
  {
1470
2
    bfd_byte buffer[STRING_SIZE_SIZE];
1471
1472
2
#if STRING_SIZE_SIZE == 4
1473
2
    H_PUT_32 (abfd, _bfd_stringtab_size (strtab) + STRING_SIZE_SIZE, buffer);
1474
#else
1475
 #error Change H_PUT_32
1476
#endif
1477
2
    if (bfd_write (buffer, sizeof (buffer), abfd) != sizeof (buffer))
1478
0
      return false;
1479
1480
2
    if (! _bfd_stringtab_emit (abfd, strtab))
1481
0
      return false;
1482
2
  }
1483
1484
2
  _bfd_stringtab_free (strtab);
1485
1486
  /* Make sure the .debug section was created to be the correct size.
1487
     We should create it ourselves on the fly, but we don't because
1488
     BFD won't let us write to any section until we know how large all
1489
     the sections are.  We could still do it by making another pass
1490
     over the symbols.  FIXME.  */
1491
2
  BFD_ASSERT (debug_string_size == 0
1492
2
        || (debug_string_section != (asection *) NULL
1493
2
      && (BFD_ALIGN (debug_string_size,
1494
2
         1 << debug_string_section->alignment_power)
1495
2
          == debug_string_section->size)));
1496
1497
2
  return true;
1498
2
}
1499
1500
bool
1501
coff_write_linenumbers (bfd *abfd)
1502
2
{
1503
2
  asection *s;
1504
2
  bfd_size_type linesz;
1505
2
  void * buff;
1506
1507
2
  linesz = bfd_coff_linesz (abfd);
1508
2
  buff = bfd_alloc (abfd, linesz);
1509
2
  if (!buff)
1510
0
    return false;
1511
9
  for (s = abfd->sections; s != (asection *) NULL; s = s->next)
1512
7
    {
1513
7
      if (s->lineno_count)
1514
0
  {
1515
0
    asymbol **q = abfd->outsymbols;
1516
0
    if (bfd_seek (abfd, s->line_filepos, SEEK_SET) != 0)
1517
0
      return false;
1518
    /* Find all the linenumbers in this section.  */
1519
0
    while (*q)
1520
0
      {
1521
0
        asymbol *p = *q;
1522
0
        if (p->section->output_section == s)
1523
0
    {
1524
0
      alent *l =
1525
0
      BFD_SEND (bfd_asymbol_bfd (p), _get_lineno,
1526
0
          (bfd_asymbol_bfd (p), p));
1527
0
      if (l)
1528
0
        {
1529
          /* Found a linenumber entry, output.  */
1530
0
          struct internal_lineno out;
1531
1532
0
          memset ((void *) & out, 0, sizeof (out));
1533
0
          out.l_lnno = 0;
1534
0
          out.l_addr.l_symndx = l->u.offset;
1535
0
          bfd_coff_swap_lineno_out (abfd, &out, buff);
1536
0
          if (bfd_write (buff, linesz, abfd) != linesz)
1537
0
      return false;
1538
0
          l++;
1539
0
          while (l->line_number)
1540
0
      {
1541
0
        out.l_lnno = l->line_number;
1542
0
        out.l_addr.l_symndx = l->u.offset;
1543
0
        bfd_coff_swap_lineno_out (abfd, &out, buff);
1544
0
        if (bfd_write (buff, linesz, abfd) != linesz)
1545
0
          return false;
1546
0
        l++;
1547
0
      }
1548
0
        }
1549
0
    }
1550
0
        q++;
1551
0
      }
1552
0
  }
1553
7
    }
1554
2
  bfd_release (abfd, buff);
1555
2
  return true;
1556
2
}
1557
1558
alent *
1559
coff_get_lineno (bfd *ignore_abfd ATTRIBUTE_UNUSED, asymbol *symbol)
1560
132
{
1561
132
  return coffsymbol (symbol)->lineno;
1562
132
}
1563
1564
/* This function transforms the offsets into the symbol table into
1565
   pointers to syments.  */
1566
1567
static void
1568
coff_pointerize_aux (bfd *abfd,
1569
         combined_entry_type *table_base,
1570
         combined_entry_type *symbol,
1571
         unsigned int indaux,
1572
         combined_entry_type *auxent)
1573
40.5M
{
1574
40.5M
  unsigned int type = symbol->u.syment.n_type;
1575
40.5M
  unsigned int n_sclass = symbol->u.syment.n_sclass;
1576
1577
40.5M
  BFD_ASSERT (symbol->is_sym);
1578
40.5M
  if (coff_backend_info (abfd)->_bfd_coff_pointerize_aux_hook)
1579
7.29M
    {
1580
7.29M
      if ((*coff_backend_info (abfd)->_bfd_coff_pointerize_aux_hook)
1581
7.29M
    (abfd, table_base, symbol, indaux, auxent))
1582
11.8k
  return;
1583
7.29M
    }
1584
1585
  /* Don't bother if this is a file or a section.  */
1586
40.4M
  if (n_sclass == C_STAT && type == T_NULL)
1587
44.4k
    return;
1588
40.4M
  if (n_sclass == C_FILE)
1589
414k
    return;
1590
40.0M
  if (n_sclass == C_DWARF)
1591
166k
    return;
1592
1593
39.8M
  BFD_ASSERT (! auxent->is_sym);
1594
  /* Otherwise patch up.  */
1595
39.8M
#define N_TMASK coff_data  (abfd)->local_n_tmask
1596
39.8M
#define N_BTSHFT coff_data (abfd)->local_n_btshft
1597
1598
39.8M
  if ((ISFCN (type) || ISTAG (n_sclass) || n_sclass == C_BLOCK
1599
39.8M
       || n_sclass == C_FCN)
1600
39.8M
      && auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.u32 > 0
1601
39.8M
      && (auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.u32
1602
5.55M
    < obj_raw_syment_count (abfd)))
1603
449k
    {
1604
449k
      auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p =
1605
449k
  table_base + auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.u32;
1606
449k
      auxent->fix_end = 1;
1607
449k
    }
1608
1609
  /* A negative tagndx is meaningless, but the SCO 3.2v4 cc can
1610
     generate one, so we must be careful to ignore it.  */
1611
39.8M
  if (auxent->u.auxent.x_sym.x_tagndx.u32 < obj_raw_syment_count (abfd))
1612
17.6M
    {
1613
17.6M
      auxent->u.auxent.x_sym.x_tagndx.p =
1614
17.6M
  table_base + auxent->u.auxent.x_sym.x_tagndx.u32;
1615
17.6M
      auxent->fix_tag = 1;
1616
17.6M
    }
1617
39.8M
}
1618
1619
/* Allocate space for the ".debug" section, and read it.
1620
   We did not read the debug section until now, because
1621
   we didn't want to go to the trouble until someone needed it.  */
1622
1623
static char *
1624
build_debug_section (bfd *abfd, asection ** sect_return)
1625
962
{
1626
962
  char *debug_section;
1627
962
  file_ptr position;
1628
962
  bfd_size_type sec_size;
1629
1630
962
  asection *sect = bfd_get_section_by_name (abfd, ".debug");
1631
1632
962
  if (!sect)
1633
423
    {
1634
423
      bfd_set_error (bfd_error_no_debug_section);
1635
423
      return NULL;
1636
423
    }
1637
1638
  /* Seek to the beginning of the `.debug' section and read it.
1639
     Save the current position first; it is needed by our caller.
1640
     Then read debug section and reset the file pointer.  */
1641
1642
539
  position = bfd_tell (abfd);
1643
539
  if (bfd_seek (abfd, sect->filepos, SEEK_SET) != 0)
1644
0
    return NULL;
1645
1646
539
  sec_size = sect->size;
1647
539
  debug_section = (char *) _bfd_alloc_and_read (abfd, sec_size + 1, sec_size);
1648
539
  if (debug_section == NULL)
1649
182
    return NULL;
1650
357
  debug_section[sec_size] = 0;
1651
1652
357
  if (bfd_seek (abfd, position, SEEK_SET) != 0)
1653
0
    return NULL;
1654
1655
357
  * sect_return = sect;
1656
357
  return debug_section;
1657
357
}
1658
1659
/* Return a pointer to a malloc'd copy of 'name'.  'name' may not be
1660
   \0-terminated, but will not exceed 'maxlen' characters.  The copy *will*
1661
   be \0-terminated.  */
1662
1663
static char *
1664
copy_name (bfd *abfd, char *name, size_t maxlen)
1665
152k
{
1666
152k
  size_t len;
1667
152k
  char *newname;
1668
1669
2.82M
  for (len = 0; len < maxlen; ++len)
1670
2.72M
    if (name[len] == '\0')
1671
47.5k
      break;
1672
1673
152k
  if ((newname = (char *) bfd_alloc (abfd, (bfd_size_type) len + 1)) == NULL)
1674
0
    return NULL;
1675
1676
152k
  strncpy (newname, name, len);
1677
152k
  newname[len] = '\0';
1678
152k
  return newname;
1679
152k
}
1680
1681
/* Read in the external symbols.  */
1682
1683
bool
1684
_bfd_coff_get_external_symbols (bfd *abfd)
1685
574k
{
1686
574k
  size_t symesz;
1687
574k
  size_t size;
1688
574k
  void * syms;
1689
574k
  ufile_ptr filesize;
1690
1691
574k
  if (obj_coff_external_syms (abfd) != NULL)
1692
35.9k
    return true;
1693
1694
538k
  symesz = bfd_coff_symesz (abfd);
1695
538k
  if (_bfd_mul_overflow (obj_raw_syment_count (abfd), symesz, &size))
1696
37.0k
    {
1697
37.0k
      bfd_set_error (bfd_error_file_truncated);
1698
37.0k
      return false;
1699
37.0k
    }
1700
1701
501k
  if (size == 0)
1702
94.6k
    return true;
1703
1704
406k
  filesize = bfd_get_file_size (abfd);
1705
406k
  if (filesize != 0
1706
406k
      && ((ufile_ptr) obj_sym_filepos (abfd) > filesize
1707
406k
    || size > filesize - obj_sym_filepos (abfd)))
1708
153k
    {
1709
153k
      bfd_set_error (bfd_error_file_truncated);
1710
153k
      return false;
1711
153k
    }
1712
1713
253k
  if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0)
1714
0
    return false;
1715
253k
  syms = _bfd_malloc_and_read (abfd, size, size);
1716
253k
  obj_coff_external_syms (abfd) = syms;
1717
253k
  return syms != NULL;
1718
253k
}
1719
1720
/* Read in the external strings.  The strings are not loaded until
1721
   they are needed.  This is because we have no simple way of
1722
   detecting a missing string table in an archive.  If the strings
1723
   are loaded then the STRINGS and STRINGS_LEN fields in the
1724
   coff_tdata structure will be set.  */
1725
1726
const char *
1727
_bfd_coff_read_string_table (bfd *abfd)
1728
2.42M
{
1729
2.42M
  char extstrsize[STRING_SIZE_SIZE];
1730
2.42M
  bfd_size_type strsize;
1731
2.42M
  char *strings;
1732
2.42M
  ufile_ptr pos;
1733
2.42M
  ufile_ptr filesize;
1734
2.42M
  size_t symesz;
1735
2.42M
  size_t size;
1736
1737
2.42M
  if (obj_coff_strings (abfd) != NULL)
1738
11.1k
    return obj_coff_strings (abfd);
1739
1740
2.41M
  if (obj_sym_filepos (abfd) == 0)
1741
2.18k
    {
1742
2.18k
      bfd_set_error (bfd_error_no_symbols);
1743
2.18k
      return NULL;
1744
2.18k
    }
1745
1746
2.41M
  symesz = bfd_coff_symesz (abfd);
1747
2.41M
  pos = obj_sym_filepos (abfd);
1748
2.41M
  if (_bfd_mul_overflow (obj_raw_syment_count (abfd), symesz, &size)
1749
2.41M
      || pos + size < pos)
1750
1.21k
    {
1751
1.21k
      bfd_set_error (bfd_error_file_truncated);
1752
1.21k
      return NULL;
1753
1.21k
    }
1754
1755
2.41M
  if (bfd_seek (abfd, pos + size, SEEK_SET) != 0)
1756
0
    return NULL;
1757
1758
2.41M
  if (bfd_read (extstrsize, sizeof extstrsize, abfd) != sizeof extstrsize)
1759
20.5k
    {
1760
20.5k
      if (bfd_get_error () != bfd_error_file_truncated)
1761
1.98k
  return NULL;
1762
1763
      /* There is no string table.  */
1764
18.5k
      strsize = STRING_SIZE_SIZE;
1765
18.5k
    }
1766
2.39M
  else
1767
2.39M
    {
1768
2.39M
#if STRING_SIZE_SIZE == 4
1769
2.39M
      strsize = H_GET_32 (abfd, extstrsize);
1770
#else
1771
 #error Change H_GET_32
1772
#endif
1773
2.39M
    }
1774
1775
2.40M
  filesize = bfd_get_file_size (abfd);
1776
2.40M
  if (strsize < STRING_SIZE_SIZE
1777
2.40M
      || (filesize != 0 && strsize > filesize))
1778
2.14M
    {
1779
2.14M
      _bfd_error_handler
1780
  /* xgettext: c-format */
1781
2.14M
  (_("%pB: bad string table size %" PRIu64), abfd, (uint64_t) strsize);
1782
2.14M
      bfd_set_error (bfd_error_bad_value);
1783
2.14M
      return NULL;
1784
2.14M
    }
1785
1786
259k
  strings = (char *) bfd_malloc (strsize + 1);
1787
259k
  if (strings == NULL)
1788
0
    return NULL;
1789
1790
  /* PR 17521 file: 079-54929-0.004.
1791
     A corrupt file could contain an index that points into the first
1792
     STRING_SIZE_SIZE bytes of the string table, so make sure that
1793
     they are zero.  */
1794
259k
  memset (strings, 0, STRING_SIZE_SIZE);
1795
1796
259k
  if (bfd_read (strings + STRING_SIZE_SIZE, strsize - STRING_SIZE_SIZE, abfd)
1797
259k
      != strsize - STRING_SIZE_SIZE)
1798
212k
    {
1799
212k
      free (strings);
1800
212k
      return NULL;
1801
212k
    }
1802
1803
46.7k
  obj_coff_strings (abfd) = strings;
1804
46.7k
  obj_coff_strings_len (abfd) = strsize;
1805
  /* Terminate the string table, just in case.  */
1806
46.7k
  strings[strsize] = 0;
1807
46.7k
  return strings;
1808
259k
}
1809
1810
/* Free up the external symbols and strings read from a COFF file.  */
1811
1812
bool
1813
_bfd_coff_free_symbols (bfd *abfd)
1814
1.98M
{
1815
1.98M
  if (! bfd_family_coff (abfd))
1816
40.2k
    return false;
1817
1818
1.94M
  if (obj_coff_external_syms (abfd) != NULL
1819
1.94M
      && ! obj_coff_keep_syms (abfd))
1820
225k
    {
1821
225k
      free (obj_coff_external_syms (abfd));
1822
225k
      obj_coff_external_syms (abfd) = NULL;
1823
225k
    }
1824
1825
1.94M
  if (obj_coff_strings (abfd) != NULL
1826
1.94M
      && ! obj_coff_keep_strings (abfd))
1827
46.7k
    {
1828
46.7k
      free (obj_coff_strings (abfd));
1829
46.7k
      obj_coff_strings (abfd) = NULL;
1830
46.7k
      obj_coff_strings_len (abfd) = 0;
1831
46.7k
    }
1832
1833
1.94M
  return true;
1834
1.98M
}
1835
1836
/* Read a symbol table into freshly bfd_allocated memory, swap it, and
1837
   knit the symbol names into a normalized form.  By normalized here I
1838
   mean that all symbols have an n_offset pointer that points to a null-
1839
   terminated string.  */
1840
1841
combined_entry_type *
1842
coff_get_normalized_symtab (bfd *abfd)
1843
57.8k
{
1844
57.8k
  combined_entry_type *internal;
1845
57.8k
  combined_entry_type *internal_ptr;
1846
57.8k
  size_t symesz;
1847
57.8k
  char *raw_src;
1848
57.8k
  char *raw_end;
1849
57.8k
  const char *string_table = NULL;
1850
57.8k
  asection * debug_sec = NULL;
1851
57.8k
  char *debug_sec_data = NULL;
1852
57.8k
  bfd_size_type size;
1853
1854
57.8k
  if (obj_raw_syments (abfd) != NULL)
1855
0
    return obj_raw_syments (abfd);
1856
1857
57.8k
  if (! _bfd_coff_get_external_symbols (abfd))
1858
22.5k
    return NULL;
1859
1860
35.3k
  size = obj_raw_syment_count (abfd);
1861
  /* Check for integer overflow.  */
1862
35.3k
  if (size > (bfd_size_type) -1 / sizeof (combined_entry_type))
1863
0
    return NULL;
1864
35.3k
  size *= sizeof (combined_entry_type);
1865
35.3k
  internal = (combined_entry_type *) bfd_zalloc (abfd, size);
1866
35.3k
  if (internal == NULL && size != 0)
1867
0
    return NULL;
1868
1869
35.3k
  raw_src = (char *) obj_coff_external_syms (abfd);
1870
1871
  /* Mark the end of the symbols.  */
1872
35.3k
  symesz = bfd_coff_symesz (abfd);
1873
35.3k
  raw_end = PTR_ADD (raw_src, obj_raw_syment_count (abfd) * symesz);
1874
1875
  /* FIXME SOMEDAY.  A string table size of zero is very weird, but
1876
     probably possible.  If one shows up, it will probably kill us.  */
1877
1878
  /* Swap all the raw entries.  */
1879
35.3k
  for (internal_ptr = internal;
1880
3.48M
       raw_src < raw_end;
1881
3.44M
       raw_src += symesz, internal_ptr++)
1882
3.47M
    {
1883
3.47M
      unsigned int i;
1884
1885
3.47M
      bfd_coff_swap_sym_in (abfd, (void *) raw_src,
1886
3.47M
          (void *) & internal_ptr->u.syment);
1887
3.47M
      internal_ptr->is_sym = true;
1888
3.47M
      combined_entry_type *sym = internal_ptr;
1889
1890
      /* PR 17512: Prevent buffer overrun.  */
1891
3.47M
      if (sym->u.syment.n_numaux > ((raw_end - 1) - raw_src) / symesz)
1892
7.91k
  return NULL;
1893
1894
43.9M
      for (i = 0; i < sym->u.syment.n_numaux; i++)
1895
40.5M
  {
1896
40.5M
    internal_ptr++;
1897
40.5M
    raw_src += symesz;
1898
1899
40.5M
    bfd_coff_swap_aux_in (abfd, (void *) raw_src,
1900
40.5M
        sym->u.syment.n_type,
1901
40.5M
        sym->u.syment.n_sclass,
1902
40.5M
        (int) i, sym->u.syment.n_numaux,
1903
40.5M
        &(internal_ptr->u.auxent));
1904
1905
40.5M
    internal_ptr->is_sym = false;
1906
40.5M
    coff_pointerize_aux (abfd, internal, sym, i, internal_ptr);
1907
40.5M
  }
1908
1909
3.46M
      if (sym->u.syment.n_sclass == C_FILE
1910
3.46M
    && sym->u.syment.n_numaux > 0)
1911
7.65k
  {
1912
7.65k
    combined_entry_type * aux = sym + 1;
1913
1914
    /* Make a file symbol point to the name in the auxent, since
1915
       the text ".file" is redundant.  */
1916
7.65k
    BFD_ASSERT (! aux->is_sym);
1917
1918
7.65k
    if (aux->u.auxent.x_file.x_n.x_n.x_zeroes == 0)
1919
2.46k
      {
1920
        /* The filename is a long one, point into the string table.  */
1921
2.46k
        if (string_table == NULL)
1922
110
    {
1923
110
      string_table = _bfd_coff_read_string_table (abfd);
1924
110
      if (string_table == NULL)
1925
76
        return NULL;
1926
110
    }
1927
1928
2.38k
        if ((bfd_size_type) aux->u.auxent.x_file.x_n.x_n.x_offset
1929
2.38k
      >= obj_coff_strings_len (abfd))
1930
1.45k
    sym->u.syment._n._n_n._n_offset =
1931
1.45k
      (uintptr_t) _("<corrupt>");
1932
926
        else
1933
926
    sym->u.syment._n._n_n._n_offset =
1934
926
      (uintptr_t) (string_table
1935
926
             + aux->u.auxent.x_file.x_n.x_n.x_offset);
1936
2.38k
      }
1937
5.19k
    else
1938
5.19k
      {
1939
        /* Ordinary short filename, put into memory anyway.  The
1940
     Microsoft PE tools sometimes store a filename in
1941
     multiple AUX entries.  */
1942
5.19k
        size_t len;
1943
5.19k
        char *src;
1944
5.19k
        if (sym->u.syment.n_numaux > 1 && obj_pe (abfd))
1945
1.38k
    {
1946
1.38k
      len = sym->u.syment.n_numaux * symesz;
1947
1.38k
      src = raw_src - (len - symesz);
1948
1.38k
    }
1949
3.81k
        else
1950
3.81k
    {
1951
3.81k
      len = bfd_coff_filnmlen (abfd);
1952
3.81k
      src = aux->u.auxent.x_file.x_n.x_fname;
1953
3.81k
    }
1954
5.19k
        sym->u.syment._n._n_n._n_offset =
1955
5.19k
    (uintptr_t) copy_name (abfd, src, len);
1956
5.19k
      }
1957
1958
    /* Normalize other strings available in C_FILE aux entries.  */
1959
7.58k
    if (!obj_pe (abfd))
1960
5.54k
      for (int numaux = 1;
1961
274k
     numaux < sym->u.syment.n_numaux;
1962
269k
     numaux++)
1963
269k
        {
1964
269k
    aux = sym + numaux + 1;
1965
269k
    BFD_ASSERT (! aux->is_sym);
1966
1967
269k
    if (aux->u.auxent.x_file.x_n.x_n.x_zeroes == 0)
1968
122k
      {
1969
        /* The string information is a long one, point
1970
           into the string table.  */
1971
122k
        if (string_table == NULL)
1972
194
          {
1973
194
      string_table = _bfd_coff_read_string_table (abfd);
1974
194
      if (string_table == NULL)
1975
97
        return NULL;
1976
194
          }
1977
1978
122k
        if ((bfd_size_type) aux->u.auxent.x_file.x_n.x_n.x_offset
1979
122k
      >= obj_coff_strings_len (abfd))
1980
49.0k
          aux->u.auxent.x_file.x_n.x_n.x_offset =
1981
49.0k
      (uintptr_t) _("<corrupt>");
1982
73.1k
        else
1983
73.1k
          aux->u.auxent.x_file.x_n.x_n.x_offset =
1984
73.1k
      (uintptr_t) (string_table
1985
73.1k
             + aux->u.auxent.x_file.x_n.x_n.x_offset);
1986
122k
      }
1987
147k
    else
1988
147k
      aux->u.auxent.x_file.x_n.x_n.x_offset =
1989
147k
        ((uintptr_t)
1990
147k
         copy_name (abfd,
1991
147k
        aux->u.auxent.x_file.x_n.x_fname,
1992
147k
        bfd_coff_filnmlen (abfd)));
1993
269k
        }
1994
1995
7.58k
  }
1996
3.45M
      else
1997
3.45M
  {
1998
3.45M
    if (sym->u.syment._n._n_n._n_zeroes != 0)
1999
1.24M
      {
2000
        /* This is a "short" name.  Make it long.  */
2001
1.24M
        char *newstring;
2002
2003
        /* Find the length of this string without walking into memory
2004
     that isn't ours.  */
2005
6.29M
        for (i = 0; i < SYMNMLEN; ++i)
2006
5.80M
    if (sym->u.syment._n._n_name[i] == '\0')
2007
759k
      break;
2008
2009
1.24M
        newstring = bfd_alloc (abfd, i + 1);
2010
1.24M
        if (newstring == NULL)
2011
0
    return NULL;
2012
1.24M
        memcpy (newstring, sym->u.syment._n._n_name, i);
2013
1.24M
        newstring[i] = 0;
2014
1.24M
        sym->u.syment._n._n_n._n_offset = (uintptr_t) newstring;
2015
1.24M
        sym->u.syment._n._n_n._n_zeroes = 0;
2016
1.24M
      }
2017
2.21M
    else if (sym->u.syment._n._n_n._n_offset == 0)
2018
1.10M
      sym->u.syment._n._n_n._n_offset = (uintptr_t) "";
2019
1.10M
    else if (!bfd_coff_symname_in_debug (abfd, &sym->u.syment))
2020
1.09M
      {
2021
        /* Long name already.  Point symbol at the string in the
2022
     table.  */
2023
1.09M
        if (string_table == NULL)
2024
27.0k
    {
2025
27.0k
      string_table = _bfd_coff_read_string_table (abfd);
2026
27.0k
      if (string_table == NULL)
2027
16.5k
        return NULL;
2028
27.0k
    }
2029
1.08M
        if (sym->u.syment._n._n_n._n_offset >= obj_coff_strings_len (abfd))
2030
932k
    sym->u.syment._n._n_n._n_offset =
2031
932k
      (uintptr_t) _("<corrupt>");
2032
150k
        else
2033
150k
    sym->u.syment._n._n_n._n_offset =
2034
150k
      (uintptr_t) (string_table
2035
150k
             + sym->u.syment._n._n_n._n_offset);
2036
1.08M
      }
2037
3.04k
    else
2038
3.04k
      {
2039
        /* Long name in debug section.  Very similar.  */
2040
3.04k
        if (debug_sec_data == NULL)
2041
962
    {
2042
962
      debug_sec_data = build_debug_section (abfd, &debug_sec);
2043
962
      if (debug_sec_data == NULL)
2044
605
        return NULL;
2045
962
    }
2046
        /* PR binutils/17512: Catch out of range offsets into
2047
     the debug data.  */
2048
2.43k
        if (sym->u.syment._n._n_n._n_offset >= debug_sec->size)
2049
2.41k
    sym->u.syment._n._n_n._n_offset =
2050
2.41k
      (uintptr_t) _("<corrupt>");
2051
24
        else
2052
24
    sym->u.syment._n._n_n._n_offset =
2053
24
      (uintptr_t) (debug_sec_data
2054
24
             + sym->u.syment._n._n_n._n_offset);
2055
2.43k
      }
2056
3.45M
  }
2057
3.46M
    }
2058
2059
  /* Free the raw symbols.  */
2060
10.0k
  if (obj_coff_external_syms (abfd) != NULL
2061
10.0k
      && ! obj_coff_keep_syms (abfd))
2062
9.83k
    {
2063
9.83k
      free (obj_coff_external_syms (abfd));
2064
9.83k
      obj_coff_external_syms (abfd) = NULL;
2065
9.83k
    }
2066
2067
10.0k
  obj_raw_syments (abfd) = internal;
2068
10.0k
  BFD_ASSERT (obj_raw_syment_count (abfd)
2069
10.0k
        == (size_t) (internal_ptr - internal));
2070
2071
10.0k
  return internal;
2072
35.3k
}
2073
2074
long
2075
coff_get_reloc_upper_bound (bfd *abfd, sec_ptr asect)
2076
244k
{
2077
244k
  size_t count, raw;
2078
2079
244k
  count = asect->reloc_count;
2080
244k
  if (count >= LONG_MAX / sizeof (arelent *)
2081
244k
      || _bfd_mul_overflow (count, bfd_coff_relsz (abfd), &raw))
2082
0
    {
2083
0
      bfd_set_error (bfd_error_file_too_big);
2084
0
      return -1;
2085
0
    }
2086
244k
  if (!bfd_write_p (abfd))
2087
244k
    {
2088
244k
      ufile_ptr filesize = bfd_get_file_size (abfd);
2089
244k
      if (filesize != 0 && raw > filesize)
2090
143k
  {
2091
143k
    bfd_set_error (bfd_error_file_truncated);
2092
143k
    return -1;
2093
143k
  }
2094
244k
    }
2095
101k
  return (count + 1) * sizeof (arelent *);
2096
244k
}
2097
2098
asymbol *
2099
coff_make_empty_symbol (bfd *abfd)
2100
111M
{
2101
111M
  size_t amt = sizeof (coff_symbol_type);
2102
111M
  coff_symbol_type *new_symbol = (coff_symbol_type *) bfd_zalloc (abfd, amt);
2103
2104
111M
  if (new_symbol == NULL)
2105
0
    return NULL;
2106
111M
  new_symbol->symbol.section = 0;
2107
111M
  new_symbol->native = NULL;
2108
111M
  new_symbol->lineno = NULL;
2109
111M
  new_symbol->done_lineno = false;
2110
111M
  new_symbol->symbol.the_bfd = abfd;
2111
2112
111M
  return & new_symbol->symbol;
2113
111M
}
2114
2115
/* Make a debugging symbol.  */
2116
2117
asymbol *
2118
coff_bfd_make_debug_symbol (bfd *abfd)
2119
0
{
2120
0
  size_t amt = sizeof (coff_symbol_type);
2121
0
  coff_symbol_type *new_symbol = (coff_symbol_type *) bfd_alloc (abfd, amt);
2122
2123
0
  if (new_symbol == NULL)
2124
0
    return NULL;
2125
  /* @@ The 10 is a guess at a plausible maximum number of aux entries
2126
     (but shouldn't be a constant).  */
2127
0
  amt = sizeof (combined_entry_type) * 10;
2128
0
  new_symbol->native = (combined_entry_type *) bfd_zalloc (abfd, amt);
2129
0
  if (!new_symbol->native)
2130
0
    return NULL;
2131
0
  new_symbol->native->is_sym = true;
2132
0
  new_symbol->symbol.section = bfd_abs_section_ptr;
2133
0
  new_symbol->symbol.flags = BSF_DEBUGGING;
2134
0
  new_symbol->lineno = NULL;
2135
0
  new_symbol->done_lineno = false;
2136
0
  new_symbol->symbol.the_bfd = abfd;
2137
2138
0
  return & new_symbol->symbol;
2139
0
}
2140
2141
void
2142
coff_get_symbol_info (bfd *abfd, asymbol *symbol, symbol_info *ret)
2143
6.43k
{
2144
6.43k
  bfd_symbol_info (symbol, ret);
2145
2146
6.43k
  if (coffsymbol (symbol)->native != NULL
2147
6.43k
      && coffsymbol (symbol)->native->fix_value
2148
6.43k
      && coffsymbol (symbol)->native->is_sym)
2149
0
    ret->value
2150
0
      = (((uintptr_t) coffsymbol (symbol)->native->u.syment.n_value
2151
0
    - (uintptr_t) obj_raw_syments (abfd))
2152
0
   / sizeof (combined_entry_type));
2153
6.43k
}
2154
2155
/* Print out information about COFF symbol.  */
2156
2157
void
2158
coff_print_symbol (bfd *abfd,
2159
       void * filep,
2160
       asymbol *symbol,
2161
       bfd_print_symbol_type how)
2162
0
{
2163
0
  FILE * file = (FILE *) filep;
2164
2165
0
  switch (how)
2166
0
    {
2167
0
    case bfd_print_symbol_name:
2168
0
      fprintf (file, "%s", symbol->name);
2169
0
      break;
2170
2171
0
    case bfd_print_symbol_more:
2172
0
      fprintf (file, "coff %s %s",
2173
0
         coffsymbol (symbol)->native ? "n" : "g",
2174
0
         coffsymbol (symbol)->lineno ? "l" : " ");
2175
0
      break;
2176
2177
0
    case bfd_print_symbol_all:
2178
0
      if (coffsymbol (symbol)->native)
2179
0
  {
2180
0
    bfd_vma val;
2181
0
    unsigned int aux;
2182
0
    combined_entry_type *combined = coffsymbol (symbol)->native;
2183
0
    combined_entry_type *root = obj_raw_syments (abfd);
2184
0
    struct lineno_cache_entry *l = coffsymbol (symbol)->lineno;
2185
2186
0
    fprintf (file, "[%3ld]", (long) (combined - root));
2187
2188
    /* PR 17512: file: 079-33786-0.001:0.1.  */
2189
0
    if (combined < obj_raw_syments (abfd)
2190
0
        || combined >= obj_raw_syments (abfd) + obj_raw_syment_count (abfd))
2191
0
      {
2192
0
        fprintf (file, _("<corrupt info> %s"), symbol->name);
2193
0
        break;
2194
0
      }
2195
2196
0
    BFD_ASSERT (combined->is_sym);
2197
0
    if (! combined->fix_value)
2198
0
      val = (bfd_vma) combined->u.syment.n_value;
2199
0
    else
2200
0
      val = (((uintptr_t) combined->u.syment.n_value - (uintptr_t) root)
2201
0
       / sizeof (combined_entry_type));
2202
2203
0
    fprintf (file, "(sec %2d)(fl 0x%02x)(ty %4x)(scl %3d) (nx %d) 0x",
2204
0
       combined->u.syment.n_scnum,
2205
0
       combined->u.syment.n_flags,
2206
0
       combined->u.syment.n_type,
2207
0
       combined->u.syment.n_sclass,
2208
0
       combined->u.syment.n_numaux);
2209
0
    bfd_fprintf_vma (abfd, file, val);
2210
0
    fprintf (file, " %s", symbol->name);
2211
2212
0
    for (aux = 0; aux < combined->u.syment.n_numaux; aux++)
2213
0
      {
2214
0
        combined_entry_type *auxp = combined + aux + 1;
2215
0
        long tagndx;
2216
2217
0
        BFD_ASSERT (! auxp->is_sym);
2218
0
        if (auxp->fix_tag)
2219
0
    tagndx = auxp->u.auxent.x_sym.x_tagndx.p - root;
2220
0
        else
2221
0
    tagndx = auxp->u.auxent.x_sym.x_tagndx.u32;
2222
2223
0
        fprintf (file, "\n");
2224
2225
0
        if (bfd_coff_print_aux (abfd, file, root, combined, auxp, aux))
2226
0
    continue;
2227
2228
0
        switch (combined->u.syment.n_sclass)
2229
0
    {
2230
0
    case C_FILE:
2231
0
      fprintf (file, "File ");
2232
      /* Add additional information if this isn't the filename
2233
         auxiliary entry.  */
2234
0
      if (auxp->u.auxent.x_file.x_ftype)
2235
0
        fprintf (file, "ftype %d fname \"%s\"",
2236
0
           auxp->u.auxent.x_file.x_ftype,
2237
0
           (char *) auxp->u.auxent.x_file.x_n.x_n.x_offset);
2238
0
      break;
2239
2240
0
    case C_DWARF:
2241
0
      fprintf (file, "AUX scnlen %#" PRIx64 " nreloc %" PRId64,
2242
0
         auxp->u.auxent.x_sect.x_scnlen,
2243
0
         auxp->u.auxent.x_sect.x_nreloc);
2244
0
      break;
2245
2246
0
    case C_STAT:
2247
0
      if (combined->u.syment.n_type == T_NULL)
2248
        /* Probably a section symbol ?  */
2249
0
        {
2250
0
          fprintf (file, "AUX scnlen 0x%lx nreloc %d nlnno %d",
2251
0
             (unsigned long) auxp->u.auxent.x_scn.x_scnlen,
2252
0
             auxp->u.auxent.x_scn.x_nreloc,
2253
0
             auxp->u.auxent.x_scn.x_nlinno);
2254
0
          if (auxp->u.auxent.x_scn.x_checksum != 0
2255
0
        || auxp->u.auxent.x_scn.x_associated != 0
2256
0
        || auxp->u.auxent.x_scn.x_comdat != 0)
2257
0
      fprintf (file, " checksum 0x%x assoc %d comdat %d",
2258
0
         auxp->u.auxent.x_scn.x_checksum,
2259
0
         auxp->u.auxent.x_scn.x_associated,
2260
0
         auxp->u.auxent.x_scn.x_comdat);
2261
0
          break;
2262
0
        }
2263
      /* Fall through.  */
2264
0
    case C_EXT:
2265
0
    case C_AIX_WEAKEXT:
2266
0
      if (ISFCN (combined->u.syment.n_type))
2267
0
        {
2268
0
          long next, llnos;
2269
2270
0
          if (auxp->fix_end)
2271
0
      next = (auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p
2272
0
             - root);
2273
0
          else
2274
0
      next = auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.u32;
2275
0
          llnos = auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_lnnoptr;
2276
0
          fprintf (file,
2277
0
             "AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld",
2278
0
             tagndx,
2279
0
             (unsigned long) auxp->u.auxent.x_sym.x_misc.x_fsize,
2280
0
             llnos, next);
2281
0
          break;
2282
0
        }
2283
      /* Fall through.  */
2284
0
    default:
2285
0
      fprintf (file, "AUX lnno %d size 0x%x tagndx %ld",
2286
0
         auxp->u.auxent.x_sym.x_misc.x_lnsz.x_lnno,
2287
0
         auxp->u.auxent.x_sym.x_misc.x_lnsz.x_size,
2288
0
         tagndx);
2289
0
      if (auxp->fix_end)
2290
0
        fprintf (file, " endndx %ld",
2291
0
           ((long)
2292
0
            (auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p
2293
0
             - root)));
2294
0
      break;
2295
0
    }
2296
0
      }
2297
2298
0
    if (l)
2299
0
      {
2300
0
        fprintf (file, "\n%s :", l->u.sym->name);
2301
0
        l++;
2302
0
        while (l->line_number)
2303
0
    {
2304
0
      if (l->line_number > 0)
2305
0
        {
2306
0
          fprintf (file, "\n%4d : ", l->line_number);
2307
0
          bfd_fprintf_vma (abfd, file, l->u.offset + symbol->section->vma);
2308
0
        }
2309
0
      l++;
2310
0
    }
2311
0
      }
2312
0
  }
2313
0
      else
2314
0
  {
2315
0
    bfd_print_symbol_vandf (abfd, (void *) file, symbol);
2316
0
    fprintf (file, " %-5s %s %s %s",
2317
0
       symbol->section->name,
2318
0
       coffsymbol (symbol)->native ? "n" : "g",
2319
0
       coffsymbol (symbol)->lineno ? "l" : " ",
2320
0
       symbol->name);
2321
0
  }
2322
0
    }
2323
0
}
2324
2325
/* Return whether a symbol name implies a local symbol.  In COFF,
2326
   local symbols generally start with ``.L''.  Most targets use this
2327
   function for the is_local_label_name entry point, but some may
2328
   override it.  */
2329
2330
bool
2331
_bfd_coff_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
2332
             const char *name)
2333
0
{
2334
0
  return name[0] == '.' && name[1] == 'L';
2335
0
}
2336
2337
/* Provided a BFD, a section and an offset (in bytes, not octets) into the
2338
   section, calculate and return the name of the source file and the line
2339
   nearest to the wanted location.  */
2340
2341
bool
2342
coff_find_nearest_line_with_names (bfd *abfd,
2343
           asymbol **symbols,
2344
           asection *section,
2345
           bfd_vma offset,
2346
           const char **filename_ptr,
2347
           const char **functionname_ptr,
2348
           unsigned int *line_ptr,
2349
           const struct dwarf_debug_section *debug_sections)
2350
187k
{
2351
187k
  bool found;
2352
187k
  unsigned int i;
2353
187k
  unsigned int line_base;
2354
187k
  coff_data_type *cof = coff_data (abfd);
2355
  /* Run through the raw syments if available.  */
2356
187k
  combined_entry_type *p;
2357
187k
  combined_entry_type *pend;
2358
187k
  alent *l;
2359
187k
  struct coff_section_tdata *sec_data;
2360
187k
  size_t amt;
2361
2362
  /* Before looking through the symbol table, try to use a .stab
2363
     section to find the information.  */
2364
187k
  if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
2365
187k
               &found, filename_ptr,
2366
187k
               functionname_ptr, line_ptr,
2367
187k
               &coff_data(abfd)->line_info))
2368
185
    return false;
2369
2370
187k
  if (found)
2371
463
    return true;
2372
2373
  /* Also try examining DWARF2 debugging information.  */
2374
186k
  if (_bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section, offset,
2375
186k
             filename_ptr, functionname_ptr,
2376
186k
             line_ptr, NULL, debug_sections,
2377
186k
             &coff_data(abfd)->dwarf2_find_line_info))
2378
7
    return true;
2379
2380
186k
  sec_data = coff_section_data (abfd, section);
2381
2382
  /* If the DWARF lookup failed, but there is DWARF information available
2383
     then the problem might be that the file has been rebased.  This tool
2384
     changes the VMAs of all the sections, but it does not update the DWARF
2385
     information.  So try again, using a bias against the address sought.  */
2386
186k
  if (coff_data (abfd)->dwarf2_find_line_info != NULL)
2387
186k
    {
2388
186k
      bfd_signed_vma bias = 0;
2389
2390
      /* Create a cache of the result for the next call.  */
2391
186k
      if (sec_data == NULL && section->owner == abfd)
2392
74.5k
  {
2393
74.5k
    amt = sizeof (struct coff_section_tdata);
2394
74.5k
    section->used_by_bfd = bfd_zalloc (abfd, amt);
2395
74.5k
    sec_data = (struct coff_section_tdata *) section->used_by_bfd;
2396
74.5k
  }
2397
2398
186k
      if (sec_data != NULL && sec_data->saved_bias)
2399
34.9k
  bias = sec_data->bias;
2400
151k
      else if (symbols)
2401
739
  {
2402
739
    bias = _bfd_dwarf2_find_symbol_bias (symbols,
2403
739
                 & coff_data (abfd)->dwarf2_find_line_info);
2404
2405
739
    if (sec_data)
2406
739
      {
2407
739
        sec_data->saved_bias = true;
2408
739
        sec_data->bias = bias;
2409
739
      }
2410
739
  }
2411
2412
186k
      if (bias
2413
186k
    && _bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section,
2414
870
              offset + bias,
2415
870
              filename_ptr, functionname_ptr,
2416
870
              line_ptr, NULL, debug_sections,
2417
870
              &coff_data(abfd)->dwarf2_find_line_info))
2418
47
  return true;
2419
186k
    }
2420
2421
186k
  *filename_ptr = 0;
2422
186k
  *functionname_ptr = 0;
2423
186k
  *line_ptr = 0;
2424
2425
  /* Don't try and find line numbers in a non coff file.  */
2426
186k
  if (!bfd_family_coff (abfd))
2427
0
    return false;
2428
2429
186k
  if (cof == NULL)
2430
0
    return false;
2431
2432
  /* Find the first C_FILE symbol.  */
2433
186k
  p = cof->raw_syments;
2434
186k
  if (!p)
2435
147k
    return false;
2436
2437
39.7k
  pend = p + cof->raw_syment_count;
2438
715k
  while (p < pend)
2439
679k
    {
2440
679k
      BFD_ASSERT (p->is_sym);
2441
679k
      if (p->u.syment.n_sclass == C_FILE)
2442
3.82k
  break;
2443
676k
      p += 1 + p->u.syment.n_numaux;
2444
676k
    }
2445
2446
39.7k
  if (p < pend)
2447
3.82k
    {
2448
3.82k
      bfd_vma sec_vma;
2449
3.82k
      bfd_vma maxdiff;
2450
2451
      /* Look through the C_FILE symbols to find the best one.  */
2452
3.82k
      sec_vma = bfd_section_vma (section);
2453
3.82k
      *filename_ptr = (char *) p->u.syment._n._n_n._n_offset;
2454
3.82k
      maxdiff = (bfd_vma) 0 - (bfd_vma) 1;
2455
12.4k
      while (1)
2456
12.4k
  {
2457
12.4k
    bfd_vma file_addr;
2458
12.4k
    combined_entry_type *p2;
2459
2460
12.4k
    for (p2 = p + 1 + p->u.syment.n_numaux;
2461
459k
         p2 < pend;
2462
447k
         p2 += 1 + p2->u.syment.n_numaux)
2463
459k
      {
2464
459k
        BFD_ASSERT (p2->is_sym);
2465
459k
        if (p2->u.syment.n_scnum > 0
2466
459k
      && (section
2467
256k
          == coff_section_from_bfd_index (abfd,
2468
256k
                  p2->u.syment.n_scnum)))
2469
9.01k
    break;
2470
450k
        if (p2->u.syment.n_sclass == C_FILE)
2471
2.73k
    {
2472
2.73k
      p2 = pend;
2473
2.73k
      break;
2474
2.73k
    }
2475
450k
      }
2476
12.4k
    if (p2 >= pend)
2477
3.40k
      break;
2478
2479
9.01k
    file_addr = (bfd_vma) p2->u.syment.n_value;
2480
    /* PR 11512: Include the section address of the function name symbol.  */
2481
9.01k
    if (p2->u.syment.n_scnum > 0)
2482
9.01k
      file_addr += coff_section_from_bfd_index (abfd,
2483
9.01k
                  p2->u.syment.n_scnum)->vma;
2484
    /* We use <= MAXDIFF here so that if we get a zero length
2485
       file, we actually use the next file entry.  */
2486
9.01k
    if (p2 < pend
2487
9.01k
        && offset + sec_vma >= file_addr
2488
9.01k
        && offset + sec_vma - file_addr <= maxdiff)
2489
5.86k
      {
2490
5.86k
        *filename_ptr = (char *) p->u.syment._n._n_n._n_offset;
2491
5.86k
        maxdiff = offset + sec_vma - p2->u.syment.n_value;
2492
5.86k
      }
2493
2494
9.01k
    if (p->u.syment.n_value >= cof->raw_syment_count)
2495
95
      break;
2496
2497
    /* Avoid endless loops on erroneous files by ensuring that
2498
       we always move forward in the file.  */
2499
8.92k
    if (p >= cof->raw_syments + p->u.syment.n_value)
2500
82
      break;
2501
2502
8.84k
    p = cof->raw_syments + p->u.syment.n_value;
2503
8.84k
    if (!p->is_sym || p->u.syment.n_sclass != C_FILE)
2504
244
      break;
2505
8.84k
  }
2506
3.82k
    }
2507
2508
39.7k
  if (section->lineno_count == 0)
2509
34.6k
    {
2510
34.6k
      *functionname_ptr = NULL;
2511
34.6k
      *line_ptr = 0;
2512
34.6k
      return true;
2513
34.6k
    }
2514
2515
  /* Now wander though the raw linenumbers of the section.
2516
     If we have been called on this section before, and the offset
2517
     we want is further down then we can prime the lookup loop.  */
2518
5.04k
  if (sec_data != NULL
2519
5.04k
      && sec_data->i > 0
2520
5.04k
      && offset >= sec_data->offset)
2521
2.87k
    {
2522
2.87k
      i = sec_data->i;
2523
2.87k
      *functionname_ptr = sec_data->function;
2524
2.87k
      line_base = sec_data->line_base;
2525
2.87k
    }
2526
2.16k
  else
2527
2.16k
    {
2528
2.16k
      i = 0;
2529
2.16k
      line_base = 0;
2530
2.16k
    }
2531
2532
5.04k
  if (section->lineno != NULL)
2533
3.22k
    {
2534
3.22k
      bfd_vma last_value = 0;
2535
2536
3.22k
      l = &section->lineno[i];
2537
2538
7.70k
      for (; i < section->lineno_count; i++)
2539
5.23k
  {
2540
5.23k
    if (l->line_number == 0)
2541
3.05k
      {
2542
        /* Get the symbol this line number points at.  */
2543
3.05k
        coff_symbol_type *coff = (coff_symbol_type *) (l->u.sym);
2544
3.05k
        if (coff->symbol.value > offset)
2545
196
    break;
2546
2547
2.85k
        *functionname_ptr = coff->symbol.name;
2548
2.85k
        last_value = coff->symbol.value;
2549
2.85k
        if (coff->native)
2550
2.85k
    {
2551
2.85k
      combined_entry_type *s = coff->native;
2552
2553
2.85k
      BFD_ASSERT (s->is_sym);
2554
2.85k
      s = s + 1 + s->u.syment.n_numaux;
2555
2556
      /* In XCOFF a debugging symbol can follow the
2557
         function symbol.  */
2558
2.85k
      if (((size_t) ((char *) s - (char *) obj_raw_syments (abfd))
2559
2.85k
           < obj_raw_syment_count (abfd) * sizeof (*s))
2560
2.85k
          && s->u.syment.n_scnum == N_DEBUG)
2561
61
        s = s + 1 + s->u.syment.n_numaux;
2562
2563
      /* S should now point to the .bf of the function.  */
2564
2.85k
      if (((size_t) ((char *) s - (char *) obj_raw_syments (abfd))
2565
2.85k
           < obj_raw_syment_count (abfd) * sizeof (*s))
2566
2.85k
          && s->u.syment.n_numaux)
2567
258
        {
2568
          /* The linenumber is stored in the auxent.  */
2569
258
          union internal_auxent *a = &((s + 1)->u.auxent);
2570
2571
258
          line_base = a->x_sym.x_misc.x_lnsz.x_lnno;
2572
258
          *line_ptr = line_base;
2573
258
        }
2574
2.85k
    }
2575
2.85k
      }
2576
2.18k
    else
2577
2.18k
      {
2578
2.18k
        if (l->u.offset > offset)
2579
561
    break;
2580
1.62k
        *line_ptr = l->line_number + line_base - 1;
2581
1.62k
      }
2582
4.48k
    l++;
2583
4.48k
  }
2584
2585
      /* If we fell off the end of the loop, then assume that this
2586
   symbol has no line number info.  Otherwise, symbols with no
2587
   line number info get reported with the line number of the
2588
   last line of the last symbol which does have line number
2589
   info.  We use 0x100 as a slop to account for cases where the
2590
   last line has executable code.  */
2591
3.22k
      if (i >= section->lineno_count
2592
3.22k
    && last_value != 0
2593
3.22k
    && offset - last_value > 0x100)
2594
226
  {
2595
226
    *functionname_ptr = NULL;
2596
226
    *line_ptr = 0;
2597
226
  }
2598
3.22k
    }
2599
2600
  /* Cache the results for the next call.  */
2601
5.04k
  if (sec_data == NULL && section->owner == abfd)
2602
0
    {
2603
0
      amt = sizeof (struct coff_section_tdata);
2604
0
      section->used_by_bfd = bfd_zalloc (abfd, amt);
2605
0
      sec_data = (struct coff_section_tdata *) section->used_by_bfd;
2606
0
    }
2607
2608
5.04k
  if (sec_data != NULL)
2609
5.04k
    {
2610
5.04k
      sec_data->offset = offset;
2611
5.04k
      sec_data->i = i - 1;
2612
5.04k
      sec_data->function = *functionname_ptr;
2613
5.04k
      sec_data->line_base = line_base;
2614
5.04k
    }
2615
2616
5.04k
  return true;
2617
39.7k
}
2618
2619
bool
2620
coff_find_nearest_line (bfd *abfd,
2621
      asymbol **symbols,
2622
      asection *section,
2623
      bfd_vma offset,
2624
      const char **filename_ptr,
2625
      const char **functionname_ptr,
2626
      unsigned int *line_ptr,
2627
      unsigned int *discriminator_ptr)
2628
187k
{
2629
187k
  if (discriminator_ptr)
2630
152k
    *discriminator_ptr = 0;
2631
187k
  return coff_find_nearest_line_with_names (abfd, symbols, section, offset,
2632
187k
              filename_ptr, functionname_ptr,
2633
187k
              line_ptr, dwarf_debug_sections);
2634
187k
}
2635
2636
bool
2637
coff_find_inliner_info (bfd *abfd,
2638
      const char **filename_ptr,
2639
      const char **functionname_ptr,
2640
      unsigned int *line_ptr)
2641
0
{
2642
0
  bool found;
2643
2644
0
  found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
2645
0
           functionname_ptr, line_ptr,
2646
0
           &coff_data(abfd)->dwarf2_find_line_info);
2647
0
  return (found);
2648
0
}
2649
2650
int
2651
coff_sizeof_headers (bfd *abfd, struct bfd_link_info *info)
2652
0
{
2653
0
  size_t size;
2654
2655
0
  if (!bfd_link_relocatable (info))
2656
0
    size = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
2657
0
  else
2658
0
    size = bfd_coff_filhsz (abfd);
2659
2660
0
  size += abfd->section_count * bfd_coff_scnhsz (abfd);
2661
0
  return size;
2662
0
}
2663
2664
/* Change the class of a coff symbol held by BFD.  */
2665
2666
bool
2667
bfd_coff_set_symbol_class (bfd *   abfd,
2668
         asymbol *   symbol,
2669
         unsigned int  symbol_class)
2670
0
{
2671
0
  coff_symbol_type * csym;
2672
2673
0
  csym = coff_symbol_from (symbol);
2674
0
  if (csym == NULL)
2675
0
    {
2676
0
      bfd_set_error (bfd_error_invalid_operation);
2677
0
      return false;
2678
0
    }
2679
0
  else if (csym->native == NULL)
2680
0
    {
2681
      /* This is an alien symbol which no native coff backend data.
2682
   We cheat here by creating a fake native entry for it and
2683
   then filling in the class.  This code is based on that in
2684
   coff_write_alien_symbol().  */
2685
2686
0
      combined_entry_type * native;
2687
0
      size_t amt = sizeof (* native);
2688
2689
0
      native = (combined_entry_type *) bfd_zalloc (abfd, amt);
2690
0
      if (native == NULL)
2691
0
  return false;
2692
2693
0
      native->is_sym = true;
2694
0
      native->u.syment.n_type   = T_NULL;
2695
0
      native->u.syment.n_sclass = symbol_class;
2696
2697
0
      if (bfd_is_und_section (symbol->section))
2698
0
  {
2699
0
    native->u.syment.n_scnum = N_UNDEF;
2700
0
    native->u.syment.n_value = symbol->value;
2701
0
  }
2702
0
      else if (bfd_is_com_section (symbol->section))
2703
0
  {
2704
0
    native->u.syment.n_scnum = N_UNDEF;
2705
0
    native->u.syment.n_value = symbol->value;
2706
0
  }
2707
0
      else
2708
0
  {
2709
0
    native->u.syment.n_scnum =
2710
0
      symbol->section->output_section->target_index;
2711
0
    native->u.syment.n_value = (symbol->value
2712
0
              + symbol->section->output_offset);
2713
0
    if (! obj_pe (abfd))
2714
0
      native->u.syment.n_value += symbol->section->output_section->vma;
2715
2716
    /* Copy the any flags from the file header into the symbol.
2717
       FIXME: Why?  */
2718
0
    native->u.syment.n_flags = bfd_asymbol_bfd (& csym->symbol)->flags;
2719
0
  }
2720
2721
0
      csym->native = native;
2722
0
    }
2723
0
  else
2724
0
    csym->native->u.syment.n_sclass = symbol_class;
2725
2726
0
  return true;
2727
0
}
2728
2729
bool
2730
_bfd_coff_section_already_linked (bfd *abfd,
2731
          asection *sec,
2732
          struct bfd_link_info *info)
2733
0
{
2734
0
  flagword flags;
2735
0
  const char *name, *key;
2736
0
  struct bfd_section_already_linked *l;
2737
0
  struct bfd_section_already_linked_hash_entry *already_linked_list;
2738
0
  struct coff_comdat_info *s_comdat;
2739
2740
0
  if (sec->output_section == bfd_abs_section_ptr)
2741
0
    return false;
2742
2743
0
  flags = sec->flags;
2744
0
  if ((flags & SEC_LINK_ONCE) == 0)
2745
0
    return false;
2746
2747
  /* The COFF backend linker doesn't support group sections.  */
2748
0
  if ((flags & SEC_GROUP) != 0)
2749
0
    return false;
2750
2751
0
  name = bfd_section_name (sec);
2752
0
  s_comdat = bfd_coff_get_comdat_section (abfd, sec);
2753
2754
0
  if (s_comdat != NULL)
2755
0
    key = s_comdat->name;
2756
0
  else
2757
0
    {
2758
0
      if (startswith (name, ".gnu.linkonce.")
2759
0
    && (key = strchr (name + sizeof (".gnu.linkonce.") - 1, '.')) != NULL)
2760
0
  key++;
2761
0
      else
2762
  /* FIXME: gcc as of 2011-09 emits sections like .text$<key>,
2763
     .xdata$<key> and .pdata$<key> only the first of which has a
2764
     comdat key.  Should these all match the LTO IR key?  */
2765
0
  key = name;
2766
0
    }
2767
2768
0
  already_linked_list = bfd_section_already_linked_table_lookup (key);
2769
2770
0
  for (l = already_linked_list->entry; l != NULL; l = l->next)
2771
0
    {
2772
0
      struct coff_comdat_info *l_comdat;
2773
2774
0
      l_comdat = bfd_coff_get_comdat_section (l->sec->owner, l->sec);
2775
2776
      /* The section names must match, and both sections must be
2777
   comdat and have the same comdat name, or both sections must
2778
   be non-comdat.  LTO IR plugin sections are an exception.  They
2779
   are always named .gnu.linkonce.t.<key> (<key> is some string)
2780
   and match any comdat section with comdat name of <key>, and
2781
   any linkonce section with the same suffix, ie.
2782
   .gnu.linkonce.*.<key>.  */
2783
0
      if (((s_comdat != NULL) == (l_comdat != NULL)
2784
0
     && strcmp (name, l->sec->name) == 0)
2785
0
    || (l->sec->owner->flags & BFD_PLUGIN) != 0
2786
0
    || (sec->owner->flags & BFD_PLUGIN) != 0)
2787
0
  {
2788
    /* The section has already been linked.  See if we should
2789
       issue a warning.  */
2790
0
    return _bfd_handle_already_linked (sec, l, info);
2791
0
  }
2792
0
    }
2793
2794
  /* This is the first section with this name.  Record it.  */
2795
0
  if (!bfd_section_already_linked_table_insert (already_linked_list, sec))
2796
0
    info->callbacks->einfo (_("%F%P: already_linked_table: %E\n"));
2797
0
  return false;
2798
0
}
2799
2800
/* Initialize COOKIE for input bfd ABFD. */
2801
2802
static bool
2803
init_reloc_cookie (struct coff_reloc_cookie *cookie,
2804
       struct bfd_link_info *info ATTRIBUTE_UNUSED,
2805
       bfd *abfd)
2806
0
{
2807
  /* Sometimes the symbol table does not yet have been loaded here.  */
2808
0
  bfd_coff_slurp_symbol_table (abfd);
2809
2810
0
  cookie->abfd = abfd;
2811
0
  cookie->sym_hashes = obj_coff_sym_hashes (abfd);
2812
2813
0
  cookie->symbols = obj_symbols (abfd);
2814
2815
0
  return true;
2816
0
}
2817
2818
/* Free the memory allocated by init_reloc_cookie, if appropriate.  */
2819
2820
static void
2821
fini_reloc_cookie (struct coff_reloc_cookie *cookie ATTRIBUTE_UNUSED,
2822
       bfd *abfd ATTRIBUTE_UNUSED)
2823
0
{
2824
  /* Nothing to do.  */
2825
0
}
2826
2827
/* Initialize the relocation information in COOKIE for input section SEC
2828
   of input bfd ABFD.  */
2829
2830
static bool
2831
init_reloc_cookie_rels (struct coff_reloc_cookie *cookie,
2832
      struct bfd_link_info *info ATTRIBUTE_UNUSED,
2833
      bfd *abfd,
2834
      asection *sec)
2835
0
{
2836
0
  if (sec->reloc_count == 0)
2837
0
    {
2838
0
      cookie->rels = NULL;
2839
0
      cookie->relend = NULL;
2840
0
      cookie->rel = NULL;
2841
0
      return true;
2842
0
    }
2843
2844
0
  cookie->rels = _bfd_coff_read_internal_relocs (abfd, sec, false, NULL,
2845
0
             0, NULL);
2846
2847
0
  if (cookie->rels == NULL)
2848
0
    return false;
2849
2850
0
  cookie->rel = cookie->rels;
2851
0
  cookie->relend = (cookie->rels + sec->reloc_count);
2852
0
  return true;
2853
0
}
2854
2855
/* Free the memory allocated by init_reloc_cookie_rels,
2856
   if appropriate.  */
2857
2858
static void
2859
fini_reloc_cookie_rels (struct coff_reloc_cookie *cookie,
2860
      asection *sec)
2861
0
{
2862
0
  if (cookie->rels
2863
      /* PR 20401.  The relocs may not have been cached, so check first.
2864
   If the relocs were loaded by init_reloc_cookie_rels() then this
2865
   will be the case.  FIXME: Would performance be improved if the
2866
   relocs *were* cached ?  */
2867
0
      && coff_section_data (NULL, sec)
2868
0
      && coff_section_data (NULL, sec)->relocs != cookie->rels)
2869
0
    free (cookie->rels);
2870
0
}
2871
2872
/* Initialize the whole of COOKIE for input section SEC.  */
2873
2874
static bool
2875
init_reloc_cookie_for_section (struct coff_reloc_cookie *cookie,
2876
             struct bfd_link_info *info,
2877
             asection *sec)
2878
0
{
2879
0
  if (!init_reloc_cookie (cookie, info, sec->owner))
2880
0
    return false;
2881
2882
0
  if (!init_reloc_cookie_rels (cookie, info, sec->owner, sec))
2883
0
    {
2884
0
      fini_reloc_cookie (cookie, sec->owner);
2885
0
      return false;
2886
0
    }
2887
0
  return true;
2888
0
}
2889
2890
/* Free the memory allocated by init_reloc_cookie_for_section,
2891
   if appropriate.  */
2892
2893
static void
2894
fini_reloc_cookie_for_section (struct coff_reloc_cookie *cookie,
2895
             asection *sec)
2896
0
{
2897
0
  fini_reloc_cookie_rels (cookie, sec);
2898
0
  fini_reloc_cookie (cookie, sec->owner);
2899
0
}
2900
2901
static asection *
2902
_bfd_coff_gc_mark_hook (asection *sec,
2903
      struct bfd_link_info *info ATTRIBUTE_UNUSED,
2904
      struct internal_reloc *rel ATTRIBUTE_UNUSED,
2905
      struct coff_link_hash_entry *h,
2906
      struct internal_syment *sym)
2907
0
{
2908
0
  if (h != NULL)
2909
0
    {
2910
0
      switch (h->root.type)
2911
0
  {
2912
0
  case bfd_link_hash_defined:
2913
0
  case bfd_link_hash_defweak:
2914
0
    return h->root.u.def.section;
2915
2916
0
  case bfd_link_hash_common:
2917
0
    return h->root.u.c.p->section;
2918
2919
0
  case bfd_link_hash_undefweak:
2920
0
    if (h->symbol_class == C_NT_WEAK && h->numaux == 1)
2921
0
      {
2922
        /* PE weak externals.  A weak symbol may include an auxiliary
2923
     record indicating that if the weak symbol is not resolved,
2924
     another external symbol is used instead.  */
2925
0
        struct coff_link_hash_entry *h2 =
2926
0
    h->auxbfd->tdata.coff_obj_data->sym_hashes
2927
0
    [h->aux->x_sym.x_tagndx.u32];
2928
2929
0
        if (h2 && h2->root.type != bfd_link_hash_undefined)
2930
0
    return  h2->root.u.def.section;
2931
0
      }
2932
0
    break;
2933
2934
0
  case bfd_link_hash_undefined:
2935
0
  default:
2936
0
    break;
2937
0
  }
2938
0
      return NULL;
2939
0
    }
2940
2941
0
  return coff_section_from_bfd_index (sec->owner, sym->n_scnum);
2942
0
}
2943
2944
/* COOKIE->rel describes a relocation against section SEC, which is
2945
   a section we've decided to keep.  Return the section that contains
2946
   the relocation symbol, or NULL if no section contains it.  */
2947
2948
static asection *
2949
_bfd_coff_gc_mark_rsec (struct bfd_link_info *info, asection *sec,
2950
      coff_gc_mark_hook_fn gc_mark_hook,
2951
      struct coff_reloc_cookie *cookie)
2952
0
{
2953
0
  struct coff_link_hash_entry *h;
2954
2955
0
  h = cookie->sym_hashes[cookie->rel->r_symndx];
2956
0
  if (h != NULL)
2957
0
    {
2958
0
      while (h->root.type == bfd_link_hash_indirect
2959
0
       || h->root.type == bfd_link_hash_warning)
2960
0
  h = (struct coff_link_hash_entry *) h->root.u.i.link;
2961
2962
0
      return (*gc_mark_hook) (sec, info, cookie->rel, h, NULL);
2963
0
    }
2964
2965
0
  return (*gc_mark_hook) (sec, info, cookie->rel, NULL,
2966
0
        &(cookie->symbols
2967
0
          + obj_convert (sec->owner)[cookie->rel->r_symndx])->native->u.syment);
2968
0
}
2969
2970
static bool _bfd_coff_gc_mark
2971
  (struct bfd_link_info *, asection *, coff_gc_mark_hook_fn);
2972
2973
/* COOKIE->rel describes a relocation against section SEC, which is
2974
   a section we've decided to keep.  Mark the section that contains
2975
   the relocation symbol.  */
2976
2977
static bool
2978
_bfd_coff_gc_mark_reloc (struct bfd_link_info *info,
2979
       asection *sec,
2980
       coff_gc_mark_hook_fn gc_mark_hook,
2981
       struct coff_reloc_cookie *cookie)
2982
0
{
2983
0
  asection *rsec;
2984
2985
0
  rsec = _bfd_coff_gc_mark_rsec (info, sec, gc_mark_hook, cookie);
2986
0
  if (rsec && !rsec->gc_mark)
2987
0
    {
2988
0
      if (bfd_get_flavour (rsec->owner) != bfd_target_coff_flavour)
2989
0
  rsec->gc_mark = 1;
2990
0
      else if (!_bfd_coff_gc_mark (info, rsec, gc_mark_hook))
2991
0
  return false;
2992
0
    }
2993
0
  return true;
2994
0
}
2995
2996
/* The mark phase of garbage collection.  For a given section, mark
2997
   it and any sections in this section's group, and all the sections
2998
   which define symbols to which it refers.  */
2999
3000
static bool
3001
_bfd_coff_gc_mark (struct bfd_link_info *info,
3002
       asection *sec,
3003
       coff_gc_mark_hook_fn gc_mark_hook)
3004
0
{
3005
0
  bool ret = true;
3006
3007
0
  sec->gc_mark = 1;
3008
3009
  /* Look through the section relocs.  */
3010
0
  if ((sec->flags & SEC_RELOC) != 0
3011
0
      && sec->reloc_count > 0)
3012
0
    {
3013
0
      struct coff_reloc_cookie cookie;
3014
3015
0
      if (!init_reloc_cookie_for_section (&cookie, info, sec))
3016
0
  ret = false;
3017
0
      else
3018
0
  {
3019
0
    for (; cookie.rel < cookie.relend; cookie.rel++)
3020
0
      {
3021
0
        if (!_bfd_coff_gc_mark_reloc (info, sec, gc_mark_hook, &cookie))
3022
0
    {
3023
0
      ret = false;
3024
0
      break;
3025
0
    }
3026
0
      }
3027
0
    fini_reloc_cookie_for_section (&cookie, sec);
3028
0
  }
3029
0
    }
3030
3031
0
  return ret;
3032
0
}
3033
3034
static bool
3035
_bfd_coff_gc_mark_extra_sections (struct bfd_link_info *info,
3036
          coff_gc_mark_hook_fn mark_hook ATTRIBUTE_UNUSED)
3037
0
{
3038
0
  bfd *ibfd;
3039
3040
0
  for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
3041
0
    {
3042
0
      asection *isec;
3043
0
      bool some_kept;
3044
3045
0
      if (bfd_get_flavour (ibfd) != bfd_target_coff_flavour)
3046
0
  continue;
3047
3048
      /* Ensure all linker created sections are kept, and see whether
3049
   any other section is already marked.  */
3050
0
      some_kept = false;
3051
0
      for (isec = ibfd->sections; isec != NULL; isec = isec->next)
3052
0
  {
3053
0
    if ((isec->flags & SEC_LINKER_CREATED) != 0)
3054
0
      isec->gc_mark = 1;
3055
0
    else if (isec->gc_mark)
3056
0
      some_kept = true;
3057
0
  }
3058
3059
      /* If no section in this file will be kept, then we can
3060
   toss out debug sections.  */
3061
0
      if (!some_kept)
3062
0
  continue;
3063
3064
      /* Keep debug and special sections like .comment when they are
3065
   not part of a group, or when we have single-member groups.  */
3066
0
      for (isec = ibfd->sections; isec != NULL; isec = isec->next)
3067
0
  if ((isec->flags & SEC_DEBUGGING) != 0
3068
0
      || (isec->flags & (SEC_ALLOC | SEC_LOAD | SEC_RELOC)) == 0)
3069
0
    isec->gc_mark = 1;
3070
0
    }
3071
0
  return true;
3072
0
}
3073
3074
/* Sweep symbols in swept sections.  Called via coff_link_hash_traverse.  */
3075
3076
static bool
3077
coff_gc_sweep_symbol (struct coff_link_hash_entry *h,
3078
          void *data ATTRIBUTE_UNUSED)
3079
0
{
3080
0
  if (h->root.type == bfd_link_hash_warning)
3081
0
    h = (struct coff_link_hash_entry *) h->root.u.i.link;
3082
3083
0
  if ((h->root.type == bfd_link_hash_defined
3084
0
       || h->root.type == bfd_link_hash_defweak)
3085
0
      && !h->root.u.def.section->gc_mark
3086
0
      && !(h->root.u.def.section->owner->flags & DYNAMIC))
3087
0
    {
3088
      /* Do our best to hide the symbol.  */
3089
0
      h->root.u.def.section = bfd_und_section_ptr;
3090
0
      h->symbol_class = C_HIDDEN;
3091
0
    }
3092
3093
0
  return true;
3094
0
}
3095
3096
/* The sweep phase of garbage collection.  Remove all garbage sections.  */
3097
3098
typedef bool (*gc_sweep_hook_fn)
3099
  (bfd *, struct bfd_link_info *, asection *, const struct internal_reloc *);
3100
3101
static bool
3102
coff_gc_sweep (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
3103
0
{
3104
0
  bfd *sub;
3105
3106
0
  for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
3107
0
    {
3108
0
      asection *o;
3109
3110
0
      if (bfd_get_flavour (sub) != bfd_target_coff_flavour)
3111
0
  continue;
3112
3113
0
      for (o = sub->sections; o != NULL; o = o->next)
3114
0
  {
3115
      /* Keep debug and special sections.  */
3116
0
    if ((o->flags & (SEC_DEBUGGING | SEC_LINKER_CREATED)) != 0
3117
0
        || (o->flags & (SEC_ALLOC | SEC_LOAD | SEC_RELOC)) == 0)
3118
0
      o->gc_mark = 1;
3119
0
    else if (startswith (o->name, ".idata")
3120
0
       || startswith (o->name, ".pdata")
3121
0
       || startswith (o->name, ".xdata")
3122
0
       || startswith (o->name, ".rsrc"))
3123
0
      o->gc_mark = 1;
3124
3125
0
    if (o->gc_mark)
3126
0
      continue;
3127
3128
    /* Skip sweeping sections already excluded.  */
3129
0
    if (o->flags & SEC_EXCLUDE)
3130
0
      continue;
3131
3132
    /* Since this is early in the link process, it is simple
3133
       to remove a section from the output.  */
3134
0
    o->flags |= SEC_EXCLUDE;
3135
3136
0
    if (info->print_gc_sections && o->size != 0)
3137
      /* xgettext: c-format */
3138
0
      _bfd_error_handler (_("removing unused section '%pA' in file '%pB'"),
3139
0
        o, sub);
3140
3141
#if 0
3142
    /* But we also have to update some of the relocation
3143
       info we collected before.  */
3144
    if (gc_sweep_hook
3145
        && (o->flags & SEC_RELOC) != 0
3146
        && o->reloc_count > 0
3147
        && !bfd_is_abs_section (o->output_section))
3148
      {
3149
        struct internal_reloc *internal_relocs;
3150
        bool r;
3151
3152
        internal_relocs
3153
    = _bfd_coff_link_read_relocs (o->owner, o, NULL, NULL,
3154
               info->keep_memory);
3155
        if (internal_relocs == NULL)
3156
    return false;
3157
3158
        r = (*gc_sweep_hook) (o->owner, info, o, internal_relocs);
3159
3160
        if (coff_section_data (o)->relocs != internal_relocs)
3161
    free (internal_relocs);
3162
3163
        if (!r)
3164
    return false;
3165
      }
3166
#endif
3167
0
  }
3168
0
    }
3169
3170
  /* Remove the symbols that were in the swept sections from the dynamic
3171
     symbol table.  */
3172
0
  coff_link_hash_traverse (coff_hash_table (info), coff_gc_sweep_symbol,
3173
0
         NULL);
3174
3175
0
  return true;
3176
0
}
3177
3178
/* Keep all sections containing symbols undefined on the command-line,
3179
   and the section containing the entry symbol.  */
3180
3181
static void
3182
_bfd_coff_gc_keep (struct bfd_link_info *info)
3183
0
{
3184
0
  struct bfd_sym_chain *sym;
3185
3186
0
  for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
3187
0
    {
3188
0
      struct coff_link_hash_entry *h;
3189
3190
0
      h = coff_link_hash_lookup (coff_hash_table (info), sym->name,
3191
0
        false, false, false);
3192
3193
0
      if (h != NULL
3194
0
    && (h->root.type == bfd_link_hash_defined
3195
0
        || h->root.type == bfd_link_hash_defweak)
3196
0
    && !bfd_is_abs_section (h->root.u.def.section))
3197
0
  h->root.u.def.section->flags |= SEC_KEEP;
3198
0
    }
3199
0
}
3200
3201
/* Do mark and sweep of unused sections.  */
3202
3203
bool
3204
bfd_coff_gc_sections (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
3205
0
{
3206
0
  bfd *sub;
3207
3208
  /* FIXME: Should we implement this? */
3209
#if 0
3210
  const bfd_coff_backend_data *bed = coff_backend_info (abfd);
3211
3212
  if (!bed->can_gc_sections
3213
      || !is_coff_hash_table (info->hash))
3214
    {
3215
      _bfd_error_handler(_("warning: gc-sections option ignored"));
3216
      return true;
3217
    }
3218
#endif
3219
3220
0
  _bfd_coff_gc_keep (info);
3221
3222
  /* Grovel through relocs to find out who stays ...  */
3223
0
  for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
3224
0
    {
3225
0
      asection *o;
3226
3227
0
      if (bfd_get_flavour (sub) != bfd_target_coff_flavour)
3228
0
  continue;
3229
3230
0
      for (o = sub->sections; o != NULL; o = o->next)
3231
0
  {
3232
0
    if (((o->flags & (SEC_EXCLUDE | SEC_KEEP)) == SEC_KEEP
3233
0
         || startswith (o->name, ".vectors")
3234
0
         || startswith (o->name, ".ctors")
3235
0
         || startswith (o->name, ".dtors"))
3236
0
        && !o->gc_mark)
3237
0
      {
3238
0
        if (!_bfd_coff_gc_mark (info, o, _bfd_coff_gc_mark_hook))
3239
0
    return false;
3240
0
      }
3241
0
  }
3242
0
    }
3243
3244
  /* Allow the backend to mark additional target specific sections.  */
3245
0
  _bfd_coff_gc_mark_extra_sections (info, _bfd_coff_gc_mark_hook);
3246
3247
  /* ... and mark SEC_EXCLUDE for those that go.  */
3248
0
  return coff_gc_sweep (abfd, info);
3249
0
}
3250
3251
/* Return name used to identify a comdat group.  */
3252
3253
const char *
3254
bfd_coff_group_name (bfd *abfd, const asection *sec)
3255
0
{
3256
0
  struct coff_comdat_info *ci = bfd_coff_get_comdat_section (abfd, sec);
3257
0
  if (ci != NULL)
3258
0
    return ci->name;
3259
0
  return NULL;
3260
0
}
3261
3262
bool
3263
_bfd_coff_free_cached_info (bfd *abfd)
3264
665k
{
3265
665k
  struct coff_tdata *tdata;
3266
3267
665k
  if (bfd_family_coff (abfd)
3268
665k
      && (bfd_get_format (abfd) == bfd_object
3269
665k
    || bfd_get_format (abfd) == bfd_core)
3270
665k
      && (tdata = coff_data (abfd)) != NULL)
3271
620k
    {
3272
620k
      if (tdata->section_by_index)
3273
0
  {
3274
0
    htab_delete (tdata->section_by_index);
3275
0
    tdata->section_by_index = NULL;
3276
0
  }
3277
3278
620k
      if (tdata->section_by_target_index)
3279
81.4k
  {
3280
81.4k
    htab_delete (tdata->section_by_target_index);
3281
81.4k
    tdata->section_by_target_index = NULL;
3282
81.4k
  }
3283
3284
620k
      if (obj_pe (abfd) && pe_data (abfd)->comdat_hash)
3285
80.3k
  {
3286
80.3k
    htab_delete (pe_data (abfd)->comdat_hash);
3287
80.3k
    pe_data (abfd)->comdat_hash = NULL;
3288
80.3k
  }
3289
3290
620k
      _bfd_dwarf2_cleanup_debug_info (abfd, &tdata->dwarf2_find_line_info);
3291
620k
      _bfd_stab_cleanup (abfd, &tdata->line_info);
3292
3293
      /* PR 25447:
3294
   Do not clear the keep_syms and keep_strings flags.
3295
   These may have been set by pe_ILF_build_a_bfd() indicating
3296
   that the syms and strings pointers are not to be freed.  */
3297
620k
      if (!_bfd_coff_free_symbols (abfd))
3298
0
  return false;
3299
620k
    }
3300
3301
665k
  return _bfd_generic_bfd_free_cached_info (abfd);
3302
665k
}