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

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [bfd/] [coffgen.c] - Blame information for rev 139

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

Line No. Rev Author Line
1 14 khays
/* Support for the generic parts of COFF, for BFD.
2
   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3
   2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4
   Free Software Foundation, Inc.
5
   Written by Cygnus Support.
6
 
7
   This file is part of BFD, the Binary File Descriptor library.
8
 
9
   This program is free software; you can redistribute it and/or modify
10
   it under the terms of the GNU General Public License as published by
11
   the Free Software Foundation; either version 3 of the License, or
12
   (at your option) any later version.
13
 
14
   This program is distributed in the hope that it will be useful,
15
   but WITHOUT ANY WARRANTY; without even the implied warranty of
16
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
   GNU General Public License for more details.
18
 
19
   You should have received a copy of the GNU General Public License
20
   along with this program; if not, write to the Free Software
21
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22
   MA 02110-1301, USA.  */
23
 
24
/* Most of this hacked by  Steve Chamberlain, sac@cygnus.com.
25
   Split out of coffcode.h by Ian Taylor, ian@cygnus.com.  */
26
 
27
/* This file contains COFF code that is not dependent on any
28
   particular COFF target.  There is only one version of this file in
29
   libbfd.a, so no target specific code may be put in here.  Or, to
30
   put it another way,
31
 
32
   ********** DO NOT PUT TARGET SPECIFIC CODE IN THIS FILE **********
33
 
34
   If you need to add some target specific behaviour, add a new hook
35
   function to bfd_coff_backend_data.
36
 
37
   Some of these functions are also called by the ECOFF routines.
38
   Those functions may not use any COFF specific information, such as
39
   coff_data (abfd).  */
40
 
41
#include "sysdep.h"
42
#include "bfd.h"
43
#include "libbfd.h"
44
#include "coff/internal.h"
45
#include "libcoff.h"
46
 
47
/* Take a section header read from a coff file (in HOST byte order),
48
   and make a BFD "section" out of it.  This is used by ECOFF.  */
49
 
50
static bfd_boolean
51
make_a_section_from_file (bfd *abfd,
52
                          struct internal_scnhdr *hdr,
53
                          unsigned int target_index)
54
{
55
  asection *return_section;
56
  char *name;
57
  bfd_boolean result = TRUE;
58
  flagword flags;
59
 
60
  name = NULL;
61
 
62
  /* Handle long section names as in PE.  On reading, we want to
63
    accept long names if the format permits them at all, regardless
64
    of the current state of the flag that dictates if we would generate
65
    them in outputs; this construct checks if that is the case by
66
    attempting to set the flag, without changing its state; the call
67
    will fail for formats that do not support long names at all.  */
68
  if (bfd_coff_set_long_section_names (abfd, bfd_coff_long_section_names (abfd))
69
      && hdr->s_name[0] == '/')
70
    {
71
      char buf[SCNNMLEN];
72
      long strindex;
73
      char *p;
74
      const char *strings;
75
 
76
      /* Flag that this BFD uses long names, even though the format might
77
         expect them to be off by default.  This won't directly affect the
78
         format of any output BFD created from this one, but the information
79
         can be used to decide what to do.  */
80
      bfd_coff_set_long_section_names (abfd, TRUE);
81
      memcpy (buf, hdr->s_name + 1, SCNNMLEN - 1);
82
      buf[SCNNMLEN - 1] = '\0';
83
      strindex = strtol (buf, &p, 10);
84
      if (*p == '\0' && strindex >= 0)
85
        {
86
          strings = _bfd_coff_read_string_table (abfd);
87
          if (strings == NULL)
88
            return FALSE;
89
          /* FIXME: For extra safety, we should make sure that
90
             strindex does not run us past the end, but right now we
91
             don't know the length of the string table.  */
92
          strings += strindex;
93
          name = (char *) bfd_alloc (abfd,
94
                                     (bfd_size_type) strlen (strings) + 1);
95
          if (name == NULL)
96
            return FALSE;
97
          strcpy (name, strings);
98
        }
99
    }
100
 
101
  if (name == NULL)
102
    {
103
      /* Assorted wastage to null-terminate the name, thanks AT&T! */
104
      name = (char *) bfd_alloc (abfd,
105
                                 (bfd_size_type) sizeof (hdr->s_name) + 1);
106
      if (name == NULL)
107
        return FALSE;
108
      strncpy (name, (char *) &hdr->s_name[0], sizeof (hdr->s_name));
109
      name[sizeof (hdr->s_name)] = 0;
110
    }
111
 
112
  return_section = bfd_make_section_anyway (abfd, name);
113
  if (return_section == NULL)
114
    return FALSE;
115
 
116
  return_section->vma = hdr->s_vaddr;
117
  return_section->lma = hdr->s_paddr;
118
  return_section->size = hdr->s_size;
119
  return_section->filepos = hdr->s_scnptr;
120
  return_section->rel_filepos = hdr->s_relptr;
121
  return_section->reloc_count = hdr->s_nreloc;
122
 
123
  bfd_coff_set_alignment_hook (abfd, return_section, hdr);
124
 
125
  return_section->line_filepos = hdr->s_lnnoptr;
126
 
127
  return_section->lineno_count = hdr->s_nlnno;
128
  return_section->userdata = NULL;
129
  return_section->next = NULL;
130
  return_section->target_index = target_index;
131
 
132
  if (! bfd_coff_styp_to_sec_flags_hook (abfd, hdr, name, return_section,
133
                                         & flags))
134
    result = FALSE;
135
 
136
  return_section->flags = flags;
137
 
138
  /* At least on i386-coff, the line number count for a shared library
139
     section must be ignored.  */
140
  if ((return_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
141
    return_section->lineno_count = 0;
142
 
143
  if (hdr->s_nreloc != 0)
144
    return_section->flags |= SEC_RELOC;
145
  /* FIXME: should this check 'hdr->s_size > 0'.  */
146
  if (hdr->s_scnptr != 0)
147
    return_section->flags |= SEC_HAS_CONTENTS;
148
 
149
  return result;
150
}
151
 
152
/* Read in a COFF object and make it into a BFD.  This is used by
153
   ECOFF as well.  */
154
 
155
static const bfd_target *
156
coff_real_object_p (bfd *abfd,
157
                    unsigned nscns,
158
                    struct internal_filehdr *internal_f,
159
                    struct internal_aouthdr *internal_a)
160
{
161
  flagword oflags = abfd->flags;
162
  bfd_vma ostart = bfd_get_start_address (abfd);
163
  void * tdata;
164
  void * tdata_save;
165
  bfd_size_type readsize;       /* Length of file_info.  */
166
  unsigned int scnhsz;
167
  char *external_sections;
168
 
169
  if (!(internal_f->f_flags & F_RELFLG))
170
    abfd->flags |= HAS_RELOC;
171
  if ((internal_f->f_flags & F_EXEC))
172
    abfd->flags |= EXEC_P;
173
  if (!(internal_f->f_flags & F_LNNO))
174
    abfd->flags |= HAS_LINENO;
175
  if (!(internal_f->f_flags & F_LSYMS))
176
    abfd->flags |= HAS_LOCALS;
177
 
178
  /* FIXME: How can we set D_PAGED correctly?  */
179
  if ((internal_f->f_flags & F_EXEC) != 0)
180
    abfd->flags |= D_PAGED;
181
 
182
  bfd_get_symcount (abfd) = internal_f->f_nsyms;
183
  if (internal_f->f_nsyms)
184
    abfd->flags |= HAS_SYMS;
185
 
186
  if (internal_a != (struct internal_aouthdr *) NULL)
187
    bfd_get_start_address (abfd) = internal_a->entry;
188
  else
189
    bfd_get_start_address (abfd) = 0;
190
 
191
  /* Set up the tdata area.  ECOFF uses its own routine, and overrides
192
     abfd->flags.  */
193
  tdata_save = abfd->tdata.any;
194
  tdata = bfd_coff_mkobject_hook (abfd, (void *) internal_f, (void *) internal_a);
195
  if (tdata == NULL)
196
    goto fail2;
197
 
198
  scnhsz = bfd_coff_scnhsz (abfd);
199
  readsize = (bfd_size_type) nscns * scnhsz;
200
  external_sections = (char *) bfd_alloc (abfd, readsize);
201
  if (!external_sections)
202
    goto fail;
203
 
204
  if (bfd_bread ((void *) external_sections, readsize, abfd) != readsize)
205
    goto fail;
206
 
207
  /* Set the arch/mach *before* swapping in sections; section header swapping
208
     may depend on arch/mach info.  */
209
  if (! bfd_coff_set_arch_mach_hook (abfd, (void *) internal_f))
210
    goto fail;
211
 
212
  /* Now copy data as required; construct all asections etc.  */
213
  if (nscns != 0)
214
    {
215
      unsigned int i;
216
      for (i = 0; i < nscns; i++)
217
        {
218
          struct internal_scnhdr tmp;
219
          bfd_coff_swap_scnhdr_in (abfd,
220
                                   (void *) (external_sections + i * scnhsz),
221
                                   (void *) & tmp);
222
          if (! make_a_section_from_file (abfd, &tmp, i + 1))
223
            goto fail;
224
        }
225
    }
226
 
227
  return abfd->xvec;
228
 
229
 fail:
230
  bfd_release (abfd, tdata);
231
 fail2:
232
  abfd->tdata.any = tdata_save;
233
  abfd->flags = oflags;
234
  bfd_get_start_address (abfd) = ostart;
235
  return (const bfd_target *) NULL;
236
}
237
 
238
/* Turn a COFF file into a BFD, but fail with bfd_error_wrong_format if it is
239
   not a COFF file.  This is also used by ECOFF.  */
240
 
241
const bfd_target *
242
coff_object_p (bfd *abfd)
243
{
244
  bfd_size_type filhsz;
245
  bfd_size_type aoutsz;
246
  unsigned int nscns;
247
  void * filehdr;
248
  struct internal_filehdr internal_f;
249
  struct internal_aouthdr internal_a;
250
 
251
  /* Figure out how much to read.  */
252
  filhsz = bfd_coff_filhsz (abfd);
253
  aoutsz = bfd_coff_aoutsz (abfd);
254
 
255
  filehdr = bfd_alloc (abfd, filhsz);
256
  if (filehdr == NULL)
257
    return NULL;
258
  if (bfd_bread (filehdr, filhsz, abfd) != filhsz)
259
    {
260
      if (bfd_get_error () != bfd_error_system_call)
261
        bfd_set_error (bfd_error_wrong_format);
262
      bfd_release (abfd, filehdr);
263
      return NULL;
264
    }
265
  bfd_coff_swap_filehdr_in (abfd, filehdr, &internal_f);
266
  bfd_release (abfd, filehdr);
267
 
268
  /* The XCOFF format has two sizes for the f_opthdr.  SMALL_AOUTSZ
269
     (less than aoutsz) used in object files and AOUTSZ (equal to
270
     aoutsz) in executables.  The bfd_coff_swap_aouthdr_in function
271
     expects this header to be aoutsz bytes in length, so we use that
272
     value in the call to bfd_alloc below.  But we must be careful to
273
     only read in f_opthdr bytes in the call to bfd_bread.  We should
274
     also attempt to catch corrupt or non-COFF binaries with a strange
275
     value for f_opthdr.  */
276
  if (! bfd_coff_bad_format_hook (abfd, &internal_f)
277
      || internal_f.f_opthdr > aoutsz)
278
    {
279
      bfd_set_error (bfd_error_wrong_format);
280
      return NULL;
281
    }
282
  nscns = internal_f.f_nscns;
283
 
284
  if (internal_f.f_opthdr)
285
    {
286
      void * opthdr;
287
 
288
      opthdr = bfd_alloc (abfd, aoutsz);
289
      if (opthdr == NULL)
290
        return NULL;
291
      if (bfd_bread (opthdr, (bfd_size_type) internal_f.f_opthdr, abfd)
292
          != internal_f.f_opthdr)
293
        {
294
          bfd_release (abfd, opthdr);
295
          return NULL;
296
        }
297
      bfd_coff_swap_aouthdr_in (abfd, opthdr, (void *) &internal_a);
298
      bfd_release (abfd, opthdr);
299
    }
300
 
301
  return coff_real_object_p (abfd, nscns, &internal_f,
302
                             (internal_f.f_opthdr != 0
303
                              ? &internal_a
304
                              : (struct internal_aouthdr *) NULL));
305
}
306
 
307
/* Get the BFD section from a COFF symbol section number.  */
308
 
309
asection *
310
coff_section_from_bfd_index (bfd *abfd, int section_index)
311
{
312
  struct bfd_section *answer = abfd->sections;
313
 
314
  if (section_index == N_ABS)
315
    return bfd_abs_section_ptr;
316
  if (section_index == N_UNDEF)
317
    return bfd_und_section_ptr;
318
  if (section_index == N_DEBUG)
319
    return bfd_abs_section_ptr;
320
 
321
  while (answer)
322
    {
323
      if (answer->target_index == section_index)
324
        return answer;
325
      answer = answer->next;
326
    }
327
 
328
  /* We should not reach this point, but the SCO 3.2v4 /lib/libc_s.a
329
     has a bad symbol table in biglitpow.o.  */
330
  return bfd_und_section_ptr;
331
}
332
 
333
/* Get the upper bound of a COFF symbol table.  */
334
 
335
long
336
coff_get_symtab_upper_bound (bfd *abfd)
337
{
338
  if (!bfd_coff_slurp_symbol_table (abfd))
339
    return -1;
340
 
341
  return (bfd_get_symcount (abfd) + 1) * (sizeof (coff_symbol_type *));
342
}
343
 
344
/* Canonicalize a COFF symbol table.  */
345
 
346
long
347
coff_canonicalize_symtab (bfd *abfd, asymbol **alocation)
348
{
349
  unsigned int counter;
350
  coff_symbol_type *symbase;
351
  coff_symbol_type **location = (coff_symbol_type **) alocation;
352
 
353
  if (!bfd_coff_slurp_symbol_table (abfd))
354
    return -1;
355
 
356
  symbase = obj_symbols (abfd);
357
  counter = bfd_get_symcount (abfd);
358
  while (counter-- > 0)
359
    *location++ = symbase++;
360
 
361
  *location = NULL;
362
 
363
  return bfd_get_symcount (abfd);
364
}
365
 
366
/* Get the name of a symbol.  The caller must pass in a buffer of size
367
   >= SYMNMLEN + 1.  */
368
 
369
const char *
370
_bfd_coff_internal_syment_name (bfd *abfd,
371
                                const struct internal_syment *sym,
372
                                char *buf)
373
{
374
  /* FIXME: It's not clear this will work correctly if sizeof
375
     (_n_zeroes) != 4.  */
376
  if (sym->_n._n_n._n_zeroes != 0
377
      || sym->_n._n_n._n_offset == 0)
378
    {
379
      memcpy (buf, sym->_n._n_name, SYMNMLEN);
380
      buf[SYMNMLEN] = '\0';
381
      return buf;
382
    }
383
  else
384
    {
385
      const char *strings;
386
 
387
      BFD_ASSERT (sym->_n._n_n._n_offset >= STRING_SIZE_SIZE);
388
      strings = obj_coff_strings (abfd);
389
      if (strings == NULL)
390
        {
391
          strings = _bfd_coff_read_string_table (abfd);
392
          if (strings == NULL)
393
            return NULL;
394
        }
395
      return strings + sym->_n._n_n._n_offset;
396
    }
397
}
398
 
399
/* Read in and swap the relocs.  This returns a buffer holding the
400
   relocs for section SEC in file ABFD.  If CACHE is TRUE and
401
   INTERNAL_RELOCS is NULL, the relocs read in will be saved in case
402
   the function is called again.  If EXTERNAL_RELOCS is not NULL, it
403
   is a buffer large enough to hold the unswapped relocs.  If
404
   INTERNAL_RELOCS is not NULL, it is a buffer large enough to hold
405
   the swapped relocs.  If REQUIRE_INTERNAL is TRUE, then the return
406
   value must be INTERNAL_RELOCS.  The function returns NULL on error.  */
407
 
408
struct internal_reloc *
409
_bfd_coff_read_internal_relocs (bfd *abfd,
410
                                asection *sec,
411
                                bfd_boolean cache,
412
                                bfd_byte *external_relocs,
413
                                bfd_boolean require_internal,
414
                                struct internal_reloc *internal_relocs)
415
{
416
  bfd_size_type relsz;
417
  bfd_byte *free_external = NULL;
418
  struct internal_reloc *free_internal = NULL;
419
  bfd_byte *erel;
420
  bfd_byte *erel_end;
421
  struct internal_reloc *irel;
422
  bfd_size_type amt;
423
 
424
  if (sec->reloc_count == 0)
425
    return internal_relocs;     /* Nothing to do.  */
426
 
427
  if (coff_section_data (abfd, sec) != NULL
428
      && coff_section_data (abfd, sec)->relocs != NULL)
429
    {
430
      if (! require_internal)
431
        return coff_section_data (abfd, sec)->relocs;
432
      memcpy (internal_relocs, coff_section_data (abfd, sec)->relocs,
433
              sec->reloc_count * sizeof (struct internal_reloc));
434
      return internal_relocs;
435
    }
436
 
437
  relsz = bfd_coff_relsz (abfd);
438
 
439
  amt = sec->reloc_count * relsz;
440
  if (external_relocs == NULL)
441
    {
442
      free_external = (bfd_byte *) bfd_malloc (amt);
443
      if (free_external == NULL)
444
        goto error_return;
445
      external_relocs = free_external;
446
    }
447
 
448
  if (bfd_seek (abfd, sec->rel_filepos, SEEK_SET) != 0
449
      || bfd_bread (external_relocs, amt, abfd) != amt)
450
    goto error_return;
451
 
452
  if (internal_relocs == NULL)
453
    {
454
      amt = sec->reloc_count;
455
      amt *= sizeof (struct internal_reloc);
456
      free_internal = (struct internal_reloc *) bfd_malloc (amt);
457
      if (free_internal == NULL)
458
        goto error_return;
459
      internal_relocs = free_internal;
460
    }
461
 
462
  /* Swap in the relocs.  */
463
  erel = external_relocs;
464
  erel_end = erel + relsz * sec->reloc_count;
465
  irel = internal_relocs;
466
  for (; erel < erel_end; erel += relsz, irel++)
467
    bfd_coff_swap_reloc_in (abfd, (void *) erel, (void *) irel);
468
 
469
  if (free_external != NULL)
470
    {
471
      free (free_external);
472
      free_external = NULL;
473
    }
474
 
475
  if (cache && free_internal != NULL)
476
    {
477
      if (coff_section_data (abfd, sec) == NULL)
478
        {
479
          amt = sizeof (struct coff_section_tdata);
480
          sec->used_by_bfd = bfd_zalloc (abfd, amt);
481
          if (sec->used_by_bfd == NULL)
482
            goto error_return;
483
          coff_section_data (abfd, sec)->contents = NULL;
484
        }
485
      coff_section_data (abfd, sec)->relocs = free_internal;
486
    }
487
 
488
  return internal_relocs;
489
 
490
 error_return:
491
  if (free_external != NULL)
492
    free (free_external);
493
  if (free_internal != NULL)
494
    free (free_internal);
495
  return NULL;
496
}
497
 
498
/* Set lineno_count for the output sections of a COFF file.  */
499
 
500
int
501
coff_count_linenumbers (bfd *abfd)
502
{
503
  unsigned int limit = bfd_get_symcount (abfd);
504
  unsigned int i;
505
  int total = 0;
506
  asymbol **p;
507
  asection *s;
508
 
509
  if (limit == 0)
510
    {
511
      /* This may be from the backend linker, in which case the
512
         lineno_count in the sections is correct.  */
513
      for (s = abfd->sections; s != NULL; s = s->next)
514
        total += s->lineno_count;
515
      return total;
516
    }
517
 
518
  for (s = abfd->sections; s != NULL; s = s->next)
519
    BFD_ASSERT (s->lineno_count == 0);
520
 
521
  for (p = abfd->outsymbols, i = 0; i < limit; i++, p++)
522
    {
523
      asymbol *q_maybe = *p;
524
 
525
      if (bfd_family_coff (bfd_asymbol_bfd (q_maybe)))
526
        {
527
          coff_symbol_type *q = coffsymbol (q_maybe);
528
 
529
          /* The AIX 4.1 compiler can sometimes generate line numbers
530
             attached to debugging symbols.  We try to simply ignore
531
             those here.  */
532
          if (q->lineno != NULL
533
              && q->symbol.section->owner != NULL)
534
            {
535
              /* This symbol has line numbers.  Increment the owning
536
                 section's linenumber count.  */
537
              alent *l = q->lineno;
538
 
539
              do
540
                {
541
                  asection * sec = q->symbol.section->output_section;
542
 
543
                  /* Do not try to update fields in read-only sections.  */
544
                  if (! bfd_is_const_section (sec))
545
                    sec->lineno_count ++;
546
 
547
                  ++total;
548
                  ++l;
549
                }
550
              while (l->line_number != 0);
551
            }
552
        }
553
    }
554
 
555
  return total;
556
}
557
 
558
/* Takes a bfd and a symbol, returns a pointer to the coff specific
559
   area of the symbol if there is one.  */
560
 
561
coff_symbol_type *
562
coff_symbol_from (bfd *ignore_abfd ATTRIBUTE_UNUSED,
563
                  asymbol *symbol)
564
{
565
  if (!bfd_family_coff (bfd_asymbol_bfd (symbol)))
566
    return (coff_symbol_type *) NULL;
567
 
568
  if (bfd_asymbol_bfd (symbol)->tdata.coff_obj_data == (coff_data_type *) NULL)
569
    return (coff_symbol_type *) NULL;
570
 
571
  return (coff_symbol_type *) symbol;
572
}
573
 
574
static void
575
fixup_symbol_value (bfd *abfd,
576
                    coff_symbol_type *coff_symbol_ptr,
577
                    struct internal_syment *syment)
578
{
579
  /* Normalize the symbol flags.  */
580
  if (coff_symbol_ptr->symbol.section
581
      && bfd_is_com_section (coff_symbol_ptr->symbol.section))
582
    {
583
      /* A common symbol is undefined with a value.  */
584
      syment->n_scnum = N_UNDEF;
585
      syment->n_value = coff_symbol_ptr->symbol.value;
586
    }
587
  else if ((coff_symbol_ptr->symbol.flags & BSF_DEBUGGING) != 0
588
           && (coff_symbol_ptr->symbol.flags & BSF_DEBUGGING_RELOC) == 0)
589
    {
590
      syment->n_value = coff_symbol_ptr->symbol.value;
591
    }
592
  else if (bfd_is_und_section (coff_symbol_ptr->symbol.section))
593
    {
594
      syment->n_scnum = N_UNDEF;
595
      syment->n_value = 0;
596
    }
597
  /* FIXME: Do we need to handle the absolute section here?  */
598
  else
599
    {
600
      if (coff_symbol_ptr->symbol.section)
601
        {
602
          syment->n_scnum =
603
            coff_symbol_ptr->symbol.section->output_section->target_index;
604
 
605
          syment->n_value = (coff_symbol_ptr->symbol.value
606
                             + coff_symbol_ptr->symbol.section->output_offset);
607
          if (! obj_pe (abfd))
608
            {
609
              syment->n_value += (syment->n_sclass == C_STATLAB)
610
                ? coff_symbol_ptr->symbol.section->output_section->lma
611
                : coff_symbol_ptr->symbol.section->output_section->vma;
612
            }
613
        }
614
      else
615
        {
616
          BFD_ASSERT (0);
617
          /* This can happen, but I don't know why yet (steve@cygnus.com) */
618
          syment->n_scnum = N_ABS;
619
          syment->n_value = coff_symbol_ptr->symbol.value;
620
        }
621
    }
622
}
623
 
624
/* Run through all the symbols in the symbol table and work out what
625
   their indexes into the symbol table will be when output.
626
 
627
   Coff requires that each C_FILE symbol points to the next one in the
628
   chain, and that the last one points to the first external symbol. We
629
   do that here too.  */
630
 
631
bfd_boolean
632
coff_renumber_symbols (bfd *bfd_ptr, int *first_undef)
633
{
634
  unsigned int symbol_count = bfd_get_symcount (bfd_ptr);
635
  asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;
636
  unsigned int native_index = 0;
637
  struct internal_syment *last_file = NULL;
638
  unsigned int symbol_index;
639
 
640
  /* COFF demands that undefined symbols come after all other symbols.
641
     Since we don't need to impose this extra knowledge on all our
642
     client programs, deal with that here.  Sort the symbol table;
643
     just move the undefined symbols to the end, leaving the rest
644
     alone.  The O'Reilly book says that defined global symbols come
645
     at the end before the undefined symbols, so we do that here as
646
     well.  */
647
  /* @@ Do we have some condition we could test for, so we don't always
648
     have to do this?  I don't think relocatability is quite right, but
649
     I'm not certain.  [raeburn:19920508.1711EST]  */
650
  {
651
    asymbol **newsyms;
652
    unsigned int i;
653
    bfd_size_type amt;
654
 
655
    amt = sizeof (asymbol *) * ((bfd_size_type) symbol_count + 1);
656
    newsyms = (asymbol **) bfd_alloc (bfd_ptr, amt);
657
    if (!newsyms)
658
      return FALSE;
659
    bfd_ptr->outsymbols = newsyms;
660
    for (i = 0; i < symbol_count; i++)
661
      if ((symbol_ptr_ptr[i]->flags & BSF_NOT_AT_END) != 0
662
          || (!bfd_is_und_section (symbol_ptr_ptr[i]->section)
663
              && !bfd_is_com_section (symbol_ptr_ptr[i]->section)
664
              && ((symbol_ptr_ptr[i]->flags & BSF_FUNCTION) != 0
665
                  || ((symbol_ptr_ptr[i]->flags & (BSF_GLOBAL | BSF_WEAK))
666
                      == 0))))
667
        *newsyms++ = symbol_ptr_ptr[i];
668
 
669
    for (i = 0; i < symbol_count; i++)
670
      if ((symbol_ptr_ptr[i]->flags & BSF_NOT_AT_END) == 0
671
          && !bfd_is_und_section (symbol_ptr_ptr[i]->section)
672
          && (bfd_is_com_section (symbol_ptr_ptr[i]->section)
673
              || ((symbol_ptr_ptr[i]->flags & BSF_FUNCTION) == 0
674
                  && ((symbol_ptr_ptr[i]->flags & (BSF_GLOBAL | BSF_WEAK))
675
                      != 0))))
676
        *newsyms++ = symbol_ptr_ptr[i];
677
 
678
    *first_undef = newsyms - bfd_ptr->outsymbols;
679
 
680
    for (i = 0; i < symbol_count; i++)
681
      if ((symbol_ptr_ptr[i]->flags & BSF_NOT_AT_END) == 0
682
          && bfd_is_und_section (symbol_ptr_ptr[i]->section))
683
        *newsyms++ = symbol_ptr_ptr[i];
684
    *newsyms = (asymbol *) NULL;
685
    symbol_ptr_ptr = bfd_ptr->outsymbols;
686
  }
687
 
688
  for (symbol_index = 0; symbol_index < symbol_count; symbol_index++)
689
    {
690
      coff_symbol_type *coff_symbol_ptr = coff_symbol_from (bfd_ptr, symbol_ptr_ptr[symbol_index]);
691
      symbol_ptr_ptr[symbol_index]->udata.i = symbol_index;
692
      if (coff_symbol_ptr && coff_symbol_ptr->native)
693
        {
694
          combined_entry_type *s = coff_symbol_ptr->native;
695
          int i;
696
 
697
          if (s->u.syment.n_sclass == C_FILE)
698
            {
699
              if (last_file != NULL)
700
                last_file->n_value = native_index;
701
              last_file = &(s->u.syment);
702
            }
703
          else
704
            /* Modify the symbol values according to their section and
705
               type.  */
706
            fixup_symbol_value (bfd_ptr, coff_symbol_ptr, &(s->u.syment));
707
 
708
          for (i = 0; i < s->u.syment.n_numaux + 1; i++)
709
            s[i].offset = native_index++;
710
        }
711
      else
712
        native_index++;
713
    }
714
 
715
  obj_conv_table_size (bfd_ptr) = native_index;
716
 
717
  return TRUE;
718
}
719
 
720
/* Run thorough the symbol table again, and fix it so that all
721
   pointers to entries are changed to the entries' index in the output
722
   symbol table.  */
723
 
724
void
725
coff_mangle_symbols (bfd *bfd_ptr)
726
{
727
  unsigned int symbol_count = bfd_get_symcount (bfd_ptr);
728
  asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;
729
  unsigned int symbol_index;
730
 
731
  for (symbol_index = 0; symbol_index < symbol_count; symbol_index++)
732
    {
733
      coff_symbol_type *coff_symbol_ptr =
734
      coff_symbol_from (bfd_ptr, symbol_ptr_ptr[symbol_index]);
735
 
736
      if (coff_symbol_ptr && coff_symbol_ptr->native)
737
        {
738
          int i;
739
          combined_entry_type *s = coff_symbol_ptr->native;
740
 
741
          if (s->fix_value)
742
            {
743
              /* FIXME: We should use a union here.  */
744
              s->u.syment.n_value =
745
                (bfd_hostptr_t) ((combined_entry_type *)
746
                          ((bfd_hostptr_t) s->u.syment.n_value))->offset;
747
              s->fix_value = 0;
748
            }
749
          if (s->fix_line)
750
            {
751
              /* The value is the offset into the line number entries
752
                 for the symbol's section.  On output, the symbol's
753
                 section should be N_DEBUG.  */
754
              s->u.syment.n_value =
755
                (coff_symbol_ptr->symbol.section->output_section->line_filepos
756
                 + s->u.syment.n_value * bfd_coff_linesz (bfd_ptr));
757
              coff_symbol_ptr->symbol.section =
758
                coff_section_from_bfd_index (bfd_ptr, N_DEBUG);
759
              BFD_ASSERT (coff_symbol_ptr->symbol.flags & BSF_DEBUGGING);
760
            }
761
          for (i = 0; i < s->u.syment.n_numaux; i++)
762
            {
763
              combined_entry_type *a = s + i + 1;
764
              if (a->fix_tag)
765
                {
766
                  a->u.auxent.x_sym.x_tagndx.l =
767
                    a->u.auxent.x_sym.x_tagndx.p->offset;
768
                  a->fix_tag = 0;
769
                }
770
              if (a->fix_end)
771
                {
772
                  a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l =
773
                    a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p->offset;
774
                  a->fix_end = 0;
775
                }
776
              if (a->fix_scnlen)
777
                {
778
                  a->u.auxent.x_csect.x_scnlen.l =
779
                    a->u.auxent.x_csect.x_scnlen.p->offset;
780
                  a->fix_scnlen = 0;
781
                }
782
            }
783
        }
784
    }
785
}
786
 
787
static void
788
coff_fix_symbol_name (bfd *abfd,
789
                      asymbol *symbol,
790
                      combined_entry_type *native,
791
                      bfd_size_type *string_size_p,
792
                      asection **debug_string_section_p,
793
                      bfd_size_type *debug_string_size_p)
794
{
795
  unsigned int name_length;
796
  union internal_auxent *auxent;
797
  char *name = (char *) (symbol->name);
798
 
799
  if (name == NULL)
800
    {
801
      /* COFF symbols always have names, so we'll make one up.  */
802
      symbol->name = "strange";
803
      name = (char *) symbol->name;
804
    }
805
  name_length = strlen (name);
806
 
807
  if (native->u.syment.n_sclass == C_FILE
808
      && native->u.syment.n_numaux > 0)
809
    {
810
      unsigned int filnmlen;
811
 
812
      if (bfd_coff_force_symnames_in_strings (abfd))
813
        {
814
          native->u.syment._n._n_n._n_offset =
815
              (*string_size_p + STRING_SIZE_SIZE);
816
          native->u.syment._n._n_n._n_zeroes = 0;
817
          *string_size_p += 6;  /* strlen(".file") + 1 */
818
        }
819
      else
820
        strncpy (native->u.syment._n._n_name, ".file", SYMNMLEN);
821
 
822
      auxent = &(native + 1)->u.auxent;
823
 
824
      filnmlen = bfd_coff_filnmlen (abfd);
825
 
826
      if (bfd_coff_long_filenames (abfd))
827
        {
828
          if (name_length <= filnmlen)
829
            strncpy (auxent->x_file.x_fname, name, filnmlen);
830
          else
831
            {
832
              auxent->x_file.x_n.x_offset = *string_size_p + STRING_SIZE_SIZE;
833
              auxent->x_file.x_n.x_zeroes = 0;
834
              *string_size_p += name_length + 1;
835
            }
836
        }
837
      else
838
        {
839
          strncpy (auxent->x_file.x_fname, name, filnmlen);
840
          if (name_length > filnmlen)
841
            name[filnmlen] = '\0';
842
        }
843
    }
844
  else
845
    {
846
      if (name_length <= SYMNMLEN && !bfd_coff_force_symnames_in_strings (abfd))
847
        /* This name will fit into the symbol neatly.  */
848
        strncpy (native->u.syment._n._n_name, symbol->name, SYMNMLEN);
849
 
850
      else if (!bfd_coff_symname_in_debug (abfd, &native->u.syment))
851
        {
852
          native->u.syment._n._n_n._n_offset = (*string_size_p
853
                                                + STRING_SIZE_SIZE);
854
          native->u.syment._n._n_n._n_zeroes = 0;
855
          *string_size_p += name_length + 1;
856
        }
857
      else
858
        {
859
          file_ptr filepos;
860
          bfd_byte buf[4];
861
          int prefix_len = bfd_coff_debug_string_prefix_length (abfd);
862
 
863
          /* This name should be written into the .debug section.  For
864
             some reason each name is preceded by a two byte length
865
             and also followed by a null byte.  FIXME: We assume that
866
             the .debug section has already been created, and that it
867
             is large enough.  */
868
          if (*debug_string_section_p == (asection *) NULL)
869
            *debug_string_section_p = bfd_get_section_by_name (abfd, ".debug");
870
          filepos = bfd_tell (abfd);
871
          if (prefix_len == 4)
872
            bfd_put_32 (abfd, (bfd_vma) (name_length + 1), buf);
873
          else
874
            bfd_put_16 (abfd, (bfd_vma) (name_length + 1), buf);
875
 
876
          if (!bfd_set_section_contents (abfd,
877
                                         *debug_string_section_p,
878
                                         (void *) buf,
879
                                         (file_ptr) *debug_string_size_p,
880
                                         (bfd_size_type) prefix_len)
881
              || !bfd_set_section_contents (abfd,
882
                                            *debug_string_section_p,
883
                                            (void *) symbol->name,
884
                                            (file_ptr) (*debug_string_size_p
885
                                                        + prefix_len),
886
                                            (bfd_size_type) name_length + 1))
887
            abort ();
888
          if (bfd_seek (abfd, filepos, SEEK_SET) != 0)
889
            abort ();
890
          native->u.syment._n._n_n._n_offset =
891
              *debug_string_size_p + prefix_len;
892
          native->u.syment._n._n_n._n_zeroes = 0;
893
          *debug_string_size_p += name_length + 1 + prefix_len;
894
        }
895
    }
896
}
897
 
898
/* We need to keep track of the symbol index so that when we write out
899
   the relocs we can get the index for a symbol.  This method is a
900
   hack.  FIXME.  */
901
 
902
#define set_index(symbol, idx)  ((symbol)->udata.i = (idx))
903
 
904
/* Write a symbol out to a COFF file.  */
905
 
906
static bfd_boolean
907
coff_write_symbol (bfd *abfd,
908
                   asymbol *symbol,
909
                   combined_entry_type *native,
910
                   bfd_vma *written,
911
                   bfd_size_type *string_size_p,
912
                   asection **debug_string_section_p,
913
                   bfd_size_type *debug_string_size_p)
914
{
915
  unsigned int numaux = native->u.syment.n_numaux;
916
  int type = native->u.syment.n_type;
917
  int n_sclass = (int) native->u.syment.n_sclass;
918
  asection *output_section = symbol->section->output_section
919
                               ? symbol->section->output_section
920
                               : symbol->section;
921
  void * buf;
922
  bfd_size_type symesz;
923
 
924
  if (native->u.syment.n_sclass == C_FILE)
925
    symbol->flags |= BSF_DEBUGGING;
926
 
927
  if (symbol->flags & BSF_DEBUGGING
928
      && bfd_is_abs_section (symbol->section))
929
    native->u.syment.n_scnum = N_DEBUG;
930
 
931
  else if (bfd_is_abs_section (symbol->section))
932
    native->u.syment.n_scnum = N_ABS;
933
 
934
  else if (bfd_is_und_section (symbol->section))
935
    native->u.syment.n_scnum = N_UNDEF;
936
 
937
  else
938
    native->u.syment.n_scnum =
939
      output_section->target_index;
940
 
941
  coff_fix_symbol_name (abfd, symbol, native, string_size_p,
942
                        debug_string_section_p, debug_string_size_p);
943
 
944
  symesz = bfd_coff_symesz (abfd);
945
  buf = bfd_alloc (abfd, symesz);
946
  if (!buf)
947
    return FALSE;
948
  bfd_coff_swap_sym_out (abfd, &native->u.syment, buf);
949
  if (bfd_bwrite (buf, symesz, abfd) != symesz)
950
    return FALSE;
951
  bfd_release (abfd, buf);
952
 
953
  if (native->u.syment.n_numaux > 0)
954
    {
955
      bfd_size_type auxesz;
956
      unsigned int j;
957
 
958
      auxesz = bfd_coff_auxesz (abfd);
959
      buf = bfd_alloc (abfd, auxesz);
960
      if (!buf)
961
        return FALSE;
962
      for (j = 0; j < native->u.syment.n_numaux; j++)
963
        {
964
          bfd_coff_swap_aux_out (abfd,
965
                                 &((native + j + 1)->u.auxent),
966
                                 type, n_sclass, (int) j,
967
                                 native->u.syment.n_numaux,
968
                                 buf);
969
          if (bfd_bwrite (buf, auxesz, abfd) != auxesz)
970
            return FALSE;
971
        }
972
      bfd_release (abfd, buf);
973
    }
974
 
975
  /* Store the index for use when we write out the relocs.  */
976
  set_index (symbol, *written);
977
 
978
  *written += numaux + 1;
979
  return TRUE;
980
}
981
 
982
/* Write out a symbol to a COFF file that does not come from a COFF
983
   file originally.  This symbol may have been created by the linker,
984
   or we may be linking a non COFF file to a COFF file.  */
985
 
986
static bfd_boolean
987
coff_write_alien_symbol (bfd *abfd,
988
                         asymbol *symbol,
989
                         bfd_vma *written,
990
                         bfd_size_type *string_size_p,
991
                         asection **debug_string_section_p,
992
                         bfd_size_type *debug_string_size_p)
993
{
994
  combined_entry_type *native;
995
  combined_entry_type dummy;
996
  asection *output_section = symbol->section->output_section
997
                               ? symbol->section->output_section
998
                               : symbol->section;
999
 
1000
  native = &dummy;
1001
  native->u.syment.n_type = T_NULL;
1002
  native->u.syment.n_flags = 0;
1003
  if (bfd_is_und_section (symbol->section))
1004
    {
1005
      native->u.syment.n_scnum = N_UNDEF;
1006
      native->u.syment.n_value = symbol->value;
1007
    }
1008
  else if (bfd_is_com_section (symbol->section))
1009
    {
1010
      native->u.syment.n_scnum = N_UNDEF;
1011
      native->u.syment.n_value = symbol->value;
1012
    }
1013
  else if (symbol->flags & BSF_DEBUGGING)
1014
    {
1015
      /* There isn't much point to writing out a debugging symbol
1016
         unless we are prepared to convert it into COFF debugging
1017
         format.  So, we just ignore them.  We must clobber the symbol
1018
         name to keep it from being put in the string table.  */
1019
      symbol->name = "";
1020
      return TRUE;
1021
    }
1022
  else
1023
    {
1024
      native->u.syment.n_scnum = output_section->target_index;
1025
      native->u.syment.n_value = (symbol->value
1026
                                  + symbol->section->output_offset);
1027
      if (! obj_pe (abfd))
1028
        native->u.syment.n_value += output_section->vma;
1029
 
1030
      /* Copy the any flags from the file header into the symbol.
1031
         FIXME: Why?  */
1032
      {
1033
        coff_symbol_type *c = coff_symbol_from (abfd, symbol);
1034
        if (c != (coff_symbol_type *) NULL)
1035
          native->u.syment.n_flags = bfd_asymbol_bfd (&c->symbol)->flags;
1036
      }
1037
    }
1038
 
1039
  native->u.syment.n_type = 0;
1040
  if (symbol->flags & BSF_LOCAL)
1041
    native->u.syment.n_sclass = C_STAT;
1042
  else if (symbol->flags & BSF_WEAK)
1043
    native->u.syment.n_sclass = obj_pe (abfd) ? C_NT_WEAK : C_WEAKEXT;
1044
  else
1045
    native->u.syment.n_sclass = C_EXT;
1046
  native->u.syment.n_numaux = 0;
1047
 
1048
  return coff_write_symbol (abfd, symbol, native, written, string_size_p,
1049
                            debug_string_section_p, debug_string_size_p);
1050
}
1051
 
1052
/* Write a native symbol to a COFF file.  */
1053
 
1054
static bfd_boolean
1055
coff_write_native_symbol (bfd *abfd,
1056
                          coff_symbol_type *symbol,
1057
                          bfd_vma *written,
1058
                          bfd_size_type *string_size_p,
1059
                          asection **debug_string_section_p,
1060
                          bfd_size_type *debug_string_size_p)
1061
{
1062
  combined_entry_type *native = symbol->native;
1063
  alent *lineno = symbol->lineno;
1064
 
1065
  /* If this symbol has an associated line number, we must store the
1066
     symbol index in the line number field.  We also tag the auxent to
1067
     point to the right place in the lineno table.  */
1068
  if (lineno && !symbol->done_lineno && symbol->symbol.section->owner != NULL)
1069
    {
1070
      unsigned int count = 0;
1071
 
1072
      lineno[count].u.offset = *written;
1073
      if (native->u.syment.n_numaux)
1074
        {
1075
          union internal_auxent *a = &((native + 1)->u.auxent);
1076
 
1077
          a->x_sym.x_fcnary.x_fcn.x_lnnoptr =
1078
            symbol->symbol.section->output_section->moving_line_filepos;
1079
        }
1080
 
1081
      /* Count and relocate all other linenumbers.  */
1082
      count++;
1083
      while (lineno[count].line_number != 0)
1084
        {
1085
          lineno[count].u.offset +=
1086
            (symbol->symbol.section->output_section->vma
1087
             + symbol->symbol.section->output_offset);
1088
          count++;
1089
        }
1090
      symbol->done_lineno = TRUE;
1091
 
1092
      if (! bfd_is_const_section (symbol->symbol.section->output_section))
1093
        symbol->symbol.section->output_section->moving_line_filepos +=
1094
          count * bfd_coff_linesz (abfd);
1095
    }
1096
 
1097
  return coff_write_symbol (abfd, &(symbol->symbol), native, written,
1098
                            string_size_p, debug_string_section_p,
1099
                            debug_string_size_p);
1100
}
1101
 
1102
static void
1103
null_error_handler (const char * fmt ATTRIBUTE_UNUSED, ...)
1104
{
1105
}
1106
 
1107
/* Write out the COFF symbols.  */
1108
 
1109
bfd_boolean
1110
coff_write_symbols (bfd *abfd)
1111
{
1112
  bfd_size_type string_size;
1113
  asection *debug_string_section;
1114
  bfd_size_type debug_string_size;
1115
  unsigned int i;
1116
  unsigned int limit = bfd_get_symcount (abfd);
1117
  bfd_vma written = 0;
1118
  asymbol **p;
1119
 
1120
  string_size = 0;
1121
  debug_string_section = NULL;
1122
  debug_string_size = 0;
1123
 
1124
  /* If this target supports long section names, they must be put into
1125
     the string table.  This is supported by PE.  This code must
1126
     handle section names just as they are handled in
1127
     coff_write_object_contents.  */
1128
  if (bfd_coff_long_section_names (abfd))
1129
    {
1130
      asection *o;
1131
 
1132
      for (o = abfd->sections; o != NULL; o = o->next)
1133
        {
1134
          size_t len;
1135
 
1136
          len = strlen (o->name);
1137
          if (len > SCNNMLEN)
1138
            string_size += len + 1;
1139
        }
1140
    }
1141
 
1142
  /* Seek to the right place.  */
1143
  if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0)
1144
    return FALSE;
1145
 
1146
  /* Output all the symbols we have.  */
1147
  written = 0;
1148
  for (p = abfd->outsymbols, i = 0; i < limit; i++, p++)
1149
    {
1150
      asymbol *symbol = *p;
1151
      coff_symbol_type *c_symbol = coff_symbol_from (abfd, symbol);
1152
 
1153
      if (c_symbol == (coff_symbol_type *) NULL
1154
          || c_symbol->native == (combined_entry_type *) NULL)
1155
        {
1156
          if (!coff_write_alien_symbol (abfd, symbol, &written, &string_size,
1157
                                        &debug_string_section,
1158
                                        &debug_string_size))
1159
            return FALSE;
1160
        }
1161
      else
1162
        {
1163
          if (coff_backend_info (abfd)->_bfd_coff_classify_symbol != NULL)
1164
            {
1165
              bfd_error_handler_type current_error_handler;
1166
              enum coff_symbol_classification sym_class;
1167
              unsigned char *n_sclass;
1168
 
1169
              /* Suppress error reporting by bfd_coff_classify_symbol.
1170
                 Error messages can be generated when we are processing a local
1171
                 symbol which has no associated section and we do not have to
1172
                 worry about this, all we need to know is that it is local.  */
1173
              current_error_handler = bfd_set_error_handler (null_error_handler);
1174
              sym_class = bfd_coff_classify_symbol (abfd,
1175
                                                   &c_symbol->native->u.syment);
1176
              (void) bfd_set_error_handler (current_error_handler);
1177
 
1178
              n_sclass = &c_symbol->native->u.syment.n_sclass;
1179
 
1180
              /* If the symbol class has been changed (eg objcopy/ld script/etc)
1181
                 we cannot retain the existing sclass from the original symbol.
1182
                 Weak symbols only have one valid sclass, so just set it always.
1183
                 If it is not local class and should be, set it C_STAT.
1184
                 If it is global and not classified as global, or if it is
1185
                 weak (which is also classified as global), set it C_EXT.  */
1186
 
1187
              if (symbol->flags & BSF_WEAK)
1188
                *n_sclass = obj_pe (abfd) ? C_NT_WEAK : C_WEAKEXT;
1189
              else if (symbol->flags & BSF_LOCAL && sym_class != COFF_SYMBOL_LOCAL)
1190
                *n_sclass = C_STAT;
1191
              else if (symbol->flags & BSF_GLOBAL
1192
                       && (sym_class != COFF_SYMBOL_GLOBAL
1193
#ifdef COFF_WITH_PE
1194
                           || *n_sclass == C_NT_WEAK
1195
#endif
1196
                           || *n_sclass == C_WEAKEXT))
1197
                c_symbol->native->u.syment.n_sclass = C_EXT;
1198
            }
1199
 
1200
          if (!coff_write_native_symbol (abfd, c_symbol, &written,
1201
                                         &string_size, &debug_string_section,
1202
                                         &debug_string_size))
1203
            return FALSE;
1204
        }
1205
    }
1206
 
1207
  obj_raw_syment_count (abfd) = written;
1208
 
1209
  /* Now write out strings.  */
1210
  if (string_size != 0)
1211
    {
1212
      unsigned int size = string_size + STRING_SIZE_SIZE;
1213
      bfd_byte buffer[STRING_SIZE_SIZE];
1214
 
1215
#if STRING_SIZE_SIZE == 4
1216
      H_PUT_32 (abfd, size, buffer);
1217
#else
1218
 #error Change H_PUT_32
1219
#endif
1220
      if (bfd_bwrite ((void *) buffer, (bfd_size_type) sizeof (buffer), abfd)
1221
          != sizeof (buffer))
1222
        return FALSE;
1223
 
1224
      /* Handle long section names.  This code must handle section
1225
         names just as they are handled in coff_write_object_contents.  */
1226
      if (bfd_coff_long_section_names (abfd))
1227
        {
1228
          asection *o;
1229
 
1230
          for (o = abfd->sections; o != NULL; o = o->next)
1231
            {
1232
              size_t len;
1233
 
1234
              len = strlen (o->name);
1235
              if (len > SCNNMLEN)
1236
                {
1237
                  if (bfd_bwrite (o->name, (bfd_size_type) (len + 1), abfd)
1238
                      != len + 1)
1239
                    return FALSE;
1240
                }
1241
            }
1242
        }
1243
 
1244
      for (p = abfd->outsymbols, i = 0;
1245
           i < limit;
1246
           i++, p++)
1247
        {
1248
          asymbol *q = *p;
1249
          size_t name_length = strlen (q->name);
1250
          coff_symbol_type *c_symbol = coff_symbol_from (abfd, q);
1251
          size_t maxlen;
1252
 
1253
          /* Figure out whether the symbol name should go in the string
1254
             table.  Symbol names that are short enough are stored
1255
             directly in the syment structure.  File names permit a
1256
             different, longer, length in the syment structure.  On
1257
             XCOFF, some symbol names are stored in the .debug section
1258
             rather than in the string table.  */
1259
 
1260
          if (c_symbol == NULL
1261
              || c_symbol->native == NULL)
1262
            /* This is not a COFF symbol, so it certainly is not a
1263
               file name, nor does it go in the .debug section.  */
1264
            maxlen = bfd_coff_force_symnames_in_strings (abfd) ? 0 : SYMNMLEN;
1265
 
1266
          else if (bfd_coff_symname_in_debug (abfd,
1267
                                              &c_symbol->native->u.syment))
1268
            /* This symbol name is in the XCOFF .debug section.
1269
               Don't write it into the string table.  */
1270
            maxlen = name_length;
1271
 
1272
          else if (c_symbol->native->u.syment.n_sclass == C_FILE
1273
                   && c_symbol->native->u.syment.n_numaux > 0)
1274
            {
1275
              if (bfd_coff_force_symnames_in_strings (abfd))
1276
                {
1277
                  if (bfd_bwrite (".file", (bfd_size_type) 6, abfd) != 6)
1278
                    return FALSE;
1279
                }
1280
              maxlen = bfd_coff_filnmlen (abfd);
1281
            }
1282
          else
1283
            maxlen = bfd_coff_force_symnames_in_strings (abfd) ? 0 : SYMNMLEN;
1284
 
1285
          if (name_length > maxlen)
1286
            {
1287
              if (bfd_bwrite ((void *) (q->name), (bfd_size_type) name_length + 1,
1288
                             abfd) != name_length + 1)
1289
                return FALSE;
1290
            }
1291
        }
1292
    }
1293
  else
1294
    {
1295
      /* We would normally not write anything here, but we'll write
1296
         out 4 so that any stupid coff reader which tries to read the
1297
         string table even when there isn't one won't croak.  */
1298
      unsigned int size = STRING_SIZE_SIZE;
1299
      bfd_byte buffer[STRING_SIZE_SIZE];
1300
 
1301
#if STRING_SIZE_SIZE == 4
1302
      H_PUT_32 (abfd, size, buffer);
1303
#else
1304
 #error Change H_PUT_32
1305
#endif
1306
      if (bfd_bwrite ((void *) buffer, (bfd_size_type) STRING_SIZE_SIZE, abfd)
1307
          != STRING_SIZE_SIZE)
1308
        return FALSE;
1309
    }
1310
 
1311
  /* Make sure the .debug section was created to be the correct size.
1312
     We should create it ourselves on the fly, but we don't because
1313
     BFD won't let us write to any section until we know how large all
1314
     the sections are.  We could still do it by making another pass
1315
     over the symbols.  FIXME.  */
1316
  BFD_ASSERT (debug_string_size == 0
1317
              || (debug_string_section != (asection *) NULL
1318
                  && (BFD_ALIGN (debug_string_size,
1319
                                 1 << debug_string_section->alignment_power)
1320
                      == debug_string_section->size)));
1321
 
1322
  return TRUE;
1323
}
1324
 
1325
bfd_boolean
1326
coff_write_linenumbers (bfd *abfd)
1327
{
1328
  asection *s;
1329
  bfd_size_type linesz;
1330
  void * buff;
1331
 
1332
  linesz = bfd_coff_linesz (abfd);
1333
  buff = bfd_alloc (abfd, linesz);
1334
  if (!buff)
1335
    return FALSE;
1336
  for (s = abfd->sections; s != (asection *) NULL; s = s->next)
1337
    {
1338
      if (s->lineno_count)
1339
        {
1340
          asymbol **q = abfd->outsymbols;
1341
          if (bfd_seek (abfd, s->line_filepos, SEEK_SET) != 0)
1342
            return FALSE;
1343
          /* Find all the linenumbers in this section.  */
1344
          while (*q)
1345
            {
1346
              asymbol *p = *q;
1347
              if (p->section->output_section == s)
1348
                {
1349
                  alent *l =
1350
                  BFD_SEND (bfd_asymbol_bfd (p), _get_lineno,
1351
                            (bfd_asymbol_bfd (p), p));
1352
                  if (l)
1353
                    {
1354
                      /* Found a linenumber entry, output.  */
1355
                      struct internal_lineno out;
1356
                      memset ((void *) & out, 0, sizeof (out));
1357
                      out.l_lnno = 0;
1358
                      out.l_addr.l_symndx = l->u.offset;
1359
                      bfd_coff_swap_lineno_out (abfd, &out, buff);
1360
                      if (bfd_bwrite (buff, (bfd_size_type) linesz, abfd)
1361
                          != linesz)
1362
                        return FALSE;
1363
                      l++;
1364
                      while (l->line_number)
1365
                        {
1366
                          out.l_lnno = l->line_number;
1367
                          out.l_addr.l_symndx = l->u.offset;
1368
                          bfd_coff_swap_lineno_out (abfd, &out, buff);
1369
                          if (bfd_bwrite (buff, (bfd_size_type) linesz, abfd)
1370
                              != linesz)
1371
                            return FALSE;
1372
                          l++;
1373
                        }
1374
                    }
1375
                }
1376
              q++;
1377
            }
1378
        }
1379
    }
1380
  bfd_release (abfd, buff);
1381
  return TRUE;
1382
}
1383
 
1384
alent *
1385
coff_get_lineno (bfd *ignore_abfd ATTRIBUTE_UNUSED, asymbol *symbol)
1386
{
1387
  return coffsymbol (symbol)->lineno;
1388
}
1389
 
1390
/* This function transforms the offsets into the symbol table into
1391
   pointers to syments.  */
1392
 
1393
static void
1394
coff_pointerize_aux (bfd *abfd,
1395
                     combined_entry_type *table_base,
1396
                     combined_entry_type *symbol,
1397
                     unsigned int indaux,
1398
                     combined_entry_type *auxent)
1399
{
1400
  unsigned int type = symbol->u.syment.n_type;
1401
  unsigned int n_sclass = symbol->u.syment.n_sclass;
1402
 
1403
  if (coff_backend_info (abfd)->_bfd_coff_pointerize_aux_hook)
1404
    {
1405
      if ((*coff_backend_info (abfd)->_bfd_coff_pointerize_aux_hook)
1406
          (abfd, table_base, symbol, indaux, auxent))
1407
        return;
1408
    }
1409
 
1410
  /* Don't bother if this is a file or a section.  */
1411
  if (n_sclass == C_STAT && type == T_NULL)
1412
    return;
1413
  if (n_sclass == C_FILE)
1414
    return;
1415
 
1416
  /* Otherwise patch up.  */
1417
#define N_TMASK coff_data  (abfd)->local_n_tmask
1418
#define N_BTSHFT coff_data (abfd)->local_n_btshft
1419
 
1420
  if ((ISFCN (type) || ISTAG (n_sclass) || n_sclass == C_BLOCK
1421
       || n_sclass == C_FCN)
1422
      && auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l > 0)
1423
    {
1424
      auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p =
1425
        table_base + auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l;
1426
      auxent->fix_end = 1;
1427
    }
1428
  /* A negative tagndx is meaningless, but the SCO 3.2v4 cc can
1429
     generate one, so we must be careful to ignore it.  */
1430
  if (auxent->u.auxent.x_sym.x_tagndx.l > 0)
1431
    {
1432
      auxent->u.auxent.x_sym.x_tagndx.p =
1433
        table_base + auxent->u.auxent.x_sym.x_tagndx.l;
1434
      auxent->fix_tag = 1;
1435
    }
1436
}
1437
 
1438
/* Allocate space for the ".debug" section, and read it.
1439
   We did not read the debug section until now, because
1440
   we didn't want to go to the trouble until someone needed it.  */
1441
 
1442
static char *
1443
build_debug_section (bfd *abfd)
1444
{
1445
  char *debug_section;
1446
  file_ptr position;
1447
  bfd_size_type sec_size;
1448
 
1449
  asection *sect = bfd_get_section_by_name (abfd, ".debug");
1450
 
1451
  if (!sect)
1452
    {
1453
      bfd_set_error (bfd_error_no_debug_section);
1454
      return NULL;
1455
    }
1456
 
1457
  sec_size = sect->size;
1458
  debug_section = (char *) bfd_alloc (abfd, sec_size);
1459
  if (debug_section == NULL)
1460
    return NULL;
1461
 
1462
  /* Seek to the beginning of the `.debug' section and read it.
1463
     Save the current position first; it is needed by our caller.
1464
     Then read debug section and reset the file pointer.  */
1465
 
1466
  position = bfd_tell (abfd);
1467
  if (bfd_seek (abfd, sect->filepos, SEEK_SET) != 0
1468
      || bfd_bread (debug_section, sec_size, abfd) != sec_size
1469
      || bfd_seek (abfd, position, SEEK_SET) != 0)
1470
    return NULL;
1471
  return debug_section;
1472
}
1473
 
1474
/* Return a pointer to a malloc'd copy of 'name'.  'name' may not be
1475
   \0-terminated, but will not exceed 'maxlen' characters.  The copy *will*
1476
   be \0-terminated.  */
1477
 
1478
static char *
1479
copy_name (bfd *abfd, char *name, size_t maxlen)
1480
{
1481
  size_t len;
1482
  char *newname;
1483
 
1484
  for (len = 0; len < maxlen; ++len)
1485
    if (name[len] == '\0')
1486
      break;
1487
 
1488
  if ((newname = (char *) bfd_alloc (abfd, (bfd_size_type) len + 1)) == NULL)
1489
    return NULL;
1490
 
1491
  strncpy (newname, name, len);
1492
  newname[len] = '\0';
1493
  return newname;
1494
}
1495
 
1496
/* Read in the external symbols.  */
1497
 
1498
bfd_boolean
1499
_bfd_coff_get_external_symbols (bfd *abfd)
1500
{
1501
  bfd_size_type symesz;
1502
  bfd_size_type size;
1503
  void * syms;
1504
 
1505
  if (obj_coff_external_syms (abfd) != NULL)
1506
    return TRUE;
1507
 
1508
  symesz = bfd_coff_symesz (abfd);
1509
 
1510
  size = obj_raw_syment_count (abfd) * symesz;
1511
  if (size == 0)
1512
    return TRUE;
1513
 
1514
  syms = bfd_malloc (size);
1515
  if (syms == NULL)
1516
    return FALSE;
1517
 
1518
  if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
1519
      || bfd_bread (syms, size, abfd) != size)
1520
    {
1521
      if (syms != NULL)
1522
        free (syms);
1523
      return FALSE;
1524
    }
1525
 
1526
  obj_coff_external_syms (abfd) = syms;
1527
 
1528
  return TRUE;
1529
}
1530
 
1531
/* Read in the external strings.  The strings are not loaded until
1532
   they are needed.  This is because we have no simple way of
1533
   detecting a missing string table in an archive.  */
1534
 
1535
const char *
1536
_bfd_coff_read_string_table (bfd *abfd)
1537
{
1538
  char extstrsize[STRING_SIZE_SIZE];
1539
  bfd_size_type strsize;
1540
  char *strings;
1541
  file_ptr pos;
1542
 
1543
  if (obj_coff_strings (abfd) != NULL)
1544
    return obj_coff_strings (abfd);
1545
 
1546
  if (obj_sym_filepos (abfd) == 0)
1547
    {
1548
      bfd_set_error (bfd_error_no_symbols);
1549
      return NULL;
1550
    }
1551
 
1552
  pos = obj_sym_filepos (abfd);
1553
  pos += obj_raw_syment_count (abfd) * bfd_coff_symesz (abfd);
1554
  if (bfd_seek (abfd, pos, SEEK_SET) != 0)
1555
    return NULL;
1556
 
1557
  if (bfd_bread (extstrsize, (bfd_size_type) sizeof extstrsize, abfd)
1558
      != sizeof extstrsize)
1559
    {
1560
      if (bfd_get_error () != bfd_error_file_truncated)
1561
        return NULL;
1562
 
1563
      /* There is no string table.  */
1564
      strsize = STRING_SIZE_SIZE;
1565
    }
1566
  else
1567
    {
1568
#if STRING_SIZE_SIZE == 4
1569
      strsize = H_GET_32 (abfd, extstrsize);
1570
#else
1571
 #error Change H_GET_32
1572
#endif
1573
    }
1574
 
1575
  if (strsize < STRING_SIZE_SIZE)
1576
    {
1577
      (*_bfd_error_handler)
1578
        (_("%B: bad string table size %lu"), abfd, (unsigned long) strsize);
1579
      bfd_set_error (bfd_error_bad_value);
1580
      return NULL;
1581
    }
1582
 
1583
  strings = (char *) bfd_malloc (strsize);
1584
  if (strings == NULL)
1585
    return NULL;
1586
 
1587
  if (bfd_bread (strings + STRING_SIZE_SIZE, strsize - STRING_SIZE_SIZE, abfd)
1588
      != strsize - STRING_SIZE_SIZE)
1589
    {
1590
      free (strings);
1591
      return NULL;
1592
    }
1593
 
1594
  obj_coff_strings (abfd) = strings;
1595
 
1596
  return strings;
1597
}
1598
 
1599
/* Free up the external symbols and strings read from a COFF file.  */
1600
 
1601
bfd_boolean
1602
_bfd_coff_free_symbols (bfd *abfd)
1603
{
1604
  if (obj_coff_external_syms (abfd) != NULL
1605
      && ! obj_coff_keep_syms (abfd))
1606
    {
1607
      free (obj_coff_external_syms (abfd));
1608
      obj_coff_external_syms (abfd) = NULL;
1609
    }
1610
  if (obj_coff_strings (abfd) != NULL
1611
      && ! obj_coff_keep_strings (abfd))
1612
    {
1613
      free (obj_coff_strings (abfd));
1614
      obj_coff_strings (abfd) = NULL;
1615
    }
1616
  return TRUE;
1617
}
1618
 
1619
/* Read a symbol table into freshly bfd_allocated memory, swap it, and
1620
   knit the symbol names into a normalized form.  By normalized here I
1621
   mean that all symbols have an n_offset pointer that points to a null-
1622
   terminated string.  */
1623
 
1624
combined_entry_type *
1625
coff_get_normalized_symtab (bfd *abfd)
1626
{
1627
  combined_entry_type *internal;
1628
  combined_entry_type *internal_ptr;
1629
  combined_entry_type *symbol_ptr;
1630
  combined_entry_type *internal_end;
1631
  size_t symesz;
1632
  char *raw_src;
1633
  char *raw_end;
1634
  const char *string_table = NULL;
1635
  char *debug_section = NULL;
1636
  bfd_size_type size;
1637
 
1638
  if (obj_raw_syments (abfd) != NULL)
1639
    return obj_raw_syments (abfd);
1640
 
1641
  size = obj_raw_syment_count (abfd) * sizeof (combined_entry_type);
1642
  internal = (combined_entry_type *) bfd_zalloc (abfd, size);
1643
  if (internal == NULL && size != 0)
1644
    return NULL;
1645
  internal_end = internal + obj_raw_syment_count (abfd);
1646
 
1647
  if (! _bfd_coff_get_external_symbols (abfd))
1648
    return NULL;
1649
 
1650
  raw_src = (char *) obj_coff_external_syms (abfd);
1651
 
1652
  /* Mark the end of the symbols.  */
1653
  symesz = bfd_coff_symesz (abfd);
1654
  raw_end = (char *) raw_src + obj_raw_syment_count (abfd) * symesz;
1655
 
1656
  /* FIXME SOMEDAY.  A string table size of zero is very weird, but
1657
     probably possible.  If one shows up, it will probably kill us.  */
1658
 
1659
  /* Swap all the raw entries.  */
1660
  for (internal_ptr = internal;
1661
       raw_src < raw_end;
1662
       raw_src += symesz, internal_ptr++)
1663
    {
1664
 
1665
      unsigned int i;
1666
      bfd_coff_swap_sym_in (abfd, (void *) raw_src,
1667
                            (void *) & internal_ptr->u.syment);
1668
      symbol_ptr = internal_ptr;
1669
 
1670
      for (i = 0;
1671
           i < symbol_ptr->u.syment.n_numaux;
1672
           i++)
1673
        {
1674
          internal_ptr++;
1675
          raw_src += symesz;
1676
          bfd_coff_swap_aux_in (abfd, (void *) raw_src,
1677
                                symbol_ptr->u.syment.n_type,
1678
                                symbol_ptr->u.syment.n_sclass,
1679
                                (int) i, symbol_ptr->u.syment.n_numaux,
1680
                                &(internal_ptr->u.auxent));
1681
          coff_pointerize_aux (abfd, internal, symbol_ptr, i,
1682
                               internal_ptr);
1683
        }
1684
    }
1685
 
1686
  /* Free the raw symbols, but not the strings (if we have them).  */
1687
  obj_coff_keep_strings (abfd) = TRUE;
1688
  if (! _bfd_coff_free_symbols (abfd))
1689
    return NULL;
1690
 
1691
  for (internal_ptr = internal; internal_ptr < internal_end;
1692
       internal_ptr++)
1693
    {
1694
      if (internal_ptr->u.syment.n_sclass == C_FILE
1695
          && internal_ptr->u.syment.n_numaux > 0)
1696
        {
1697
          /* Make a file symbol point to the name in the auxent, since
1698
             the text ".file" is redundant.  */
1699
          if ((internal_ptr + 1)->u.auxent.x_file.x_n.x_zeroes == 0)
1700
            {
1701
              /* The filename is a long one, point into the string table.  */
1702
              if (string_table == NULL)
1703
                {
1704
                  string_table = _bfd_coff_read_string_table (abfd);
1705
                  if (string_table == NULL)
1706
                    return NULL;
1707
                }
1708
 
1709
              internal_ptr->u.syment._n._n_n._n_offset =
1710
                ((bfd_hostptr_t)
1711
                 (string_table
1712
                  + (internal_ptr + 1)->u.auxent.x_file.x_n.x_offset));
1713
            }
1714
          else
1715
            {
1716
              /* Ordinary short filename, put into memory anyway.  The
1717
                 Microsoft PE tools sometimes store a filename in
1718
                 multiple AUX entries.  */
1719
              if (internal_ptr->u.syment.n_numaux > 1
1720
                  && coff_data (abfd)->pe)
1721
                internal_ptr->u.syment._n._n_n._n_offset =
1722
                  ((bfd_hostptr_t)
1723
                   copy_name (abfd,
1724
                              (internal_ptr + 1)->u.auxent.x_file.x_fname,
1725
                              internal_ptr->u.syment.n_numaux * symesz));
1726
              else
1727
                internal_ptr->u.syment._n._n_n._n_offset =
1728
                  ((bfd_hostptr_t)
1729
                   copy_name (abfd,
1730
                              (internal_ptr + 1)->u.auxent.x_file.x_fname,
1731
                              (size_t) bfd_coff_filnmlen (abfd)));
1732
            }
1733
        }
1734
      else
1735
        {
1736
          if (internal_ptr->u.syment._n._n_n._n_zeroes != 0)
1737
            {
1738
              /* This is a "short" name.  Make it long.  */
1739
              size_t i;
1740
              char *newstring;
1741
 
1742
              /* Find the length of this string without walking into memory
1743
                 that isn't ours.  */
1744
              for (i = 0; i < 8; ++i)
1745
                if (internal_ptr->u.syment._n._n_name[i] == '\0')
1746
                  break;
1747
 
1748
              newstring = (char *) bfd_zalloc (abfd, (bfd_size_type) (i + 1));
1749
              if (newstring == NULL)
1750
                return NULL;
1751
              strncpy (newstring, internal_ptr->u.syment._n._n_name, i);
1752
              internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) newstring;
1753
              internal_ptr->u.syment._n._n_n._n_zeroes = 0;
1754
            }
1755
          else if (internal_ptr->u.syment._n._n_n._n_offset == 0)
1756
            internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) "";
1757
          else if (!bfd_coff_symname_in_debug (abfd, &internal_ptr->u.syment))
1758
            {
1759
              /* Long name already.  Point symbol at the string in the
1760
                 table.  */
1761
              if (string_table == NULL)
1762
                {
1763
                  string_table = _bfd_coff_read_string_table (abfd);
1764
                  if (string_table == NULL)
1765
                    return NULL;
1766
                }
1767
              internal_ptr->u.syment._n._n_n._n_offset =
1768
                ((bfd_hostptr_t)
1769
                 (string_table
1770
                  + internal_ptr->u.syment._n._n_n._n_offset));
1771
            }
1772
          else
1773
            {
1774
              /* Long name in debug section.  Very similar.  */
1775
              if (debug_section == NULL)
1776
                debug_section = build_debug_section (abfd);
1777
              internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t)
1778
                (debug_section + internal_ptr->u.syment._n._n_n._n_offset);
1779
            }
1780
        }
1781
      internal_ptr += internal_ptr->u.syment.n_numaux;
1782
    }
1783
 
1784
  obj_raw_syments (abfd) = internal;
1785
  BFD_ASSERT (obj_raw_syment_count (abfd)
1786
              == (unsigned int) (internal_ptr - internal));
1787
 
1788
  return internal;
1789
}
1790
 
1791
long
1792
coff_get_reloc_upper_bound (bfd *abfd, sec_ptr asect)
1793
{
1794
  if (bfd_get_format (abfd) != bfd_object)
1795
    {
1796
      bfd_set_error (bfd_error_invalid_operation);
1797
      return -1;
1798
    }
1799
  return (asect->reloc_count + 1) * sizeof (arelent *);
1800
}
1801
 
1802
asymbol *
1803
coff_make_empty_symbol (bfd *abfd)
1804
{
1805
  bfd_size_type amt = sizeof (coff_symbol_type);
1806
  coff_symbol_type *new_symbol = (coff_symbol_type *) bfd_zalloc (abfd, amt);
1807
 
1808
  if (new_symbol == NULL)
1809
    return NULL;
1810
  new_symbol->symbol.section = 0;
1811
  new_symbol->native = 0;
1812
  new_symbol->lineno = NULL;
1813
  new_symbol->done_lineno = FALSE;
1814
  new_symbol->symbol.the_bfd = abfd;
1815
 
1816
  return & new_symbol->symbol;
1817
}
1818
 
1819
/* Make a debugging symbol.  */
1820
 
1821
asymbol *
1822
coff_bfd_make_debug_symbol (bfd *abfd,
1823
                            void * ptr ATTRIBUTE_UNUSED,
1824
                            unsigned long sz ATTRIBUTE_UNUSED)
1825
{
1826
  bfd_size_type amt = sizeof (coff_symbol_type);
1827
  coff_symbol_type *new_symbol = (coff_symbol_type *) bfd_alloc (abfd, amt);
1828
 
1829
  if (new_symbol == NULL)
1830
    return NULL;
1831
  /* @@ The 10 is a guess at a plausible maximum number of aux entries
1832
     (but shouldn't be a constant).  */
1833
  amt = sizeof (combined_entry_type) * 10;
1834
  new_symbol->native = (combined_entry_type *) bfd_zalloc (abfd, amt);
1835
  if (!new_symbol->native)
1836
    return NULL;
1837
  new_symbol->symbol.section = bfd_abs_section_ptr;
1838
  new_symbol->symbol.flags = BSF_DEBUGGING;
1839
  new_symbol->lineno = NULL;
1840
  new_symbol->done_lineno = FALSE;
1841
  new_symbol->symbol.the_bfd = abfd;
1842
 
1843
  return & new_symbol->symbol;
1844
}
1845
 
1846
void
1847
coff_get_symbol_info (bfd *abfd, asymbol *symbol, symbol_info *ret)
1848
{
1849
  bfd_symbol_info (symbol, ret);
1850
 
1851
  if (coffsymbol (symbol)->native != NULL
1852
      && coffsymbol (symbol)->native->fix_value)
1853
    ret->value = coffsymbol (symbol)->native->u.syment.n_value -
1854
      (bfd_hostptr_t) obj_raw_syments (abfd);
1855
}
1856
 
1857
/* Return the COFF syment for a symbol.  */
1858
 
1859
bfd_boolean
1860
bfd_coff_get_syment (bfd *abfd,
1861
                     asymbol *symbol,
1862
                     struct internal_syment *psyment)
1863
{
1864
  coff_symbol_type *csym;
1865
 
1866
  csym = coff_symbol_from (abfd, symbol);
1867
  if (csym == NULL || csym->native == NULL)
1868
    {
1869
      bfd_set_error (bfd_error_invalid_operation);
1870
      return FALSE;
1871
    }
1872
 
1873
  *psyment = csym->native->u.syment;
1874
 
1875
  if (csym->native->fix_value)
1876
    psyment->n_value = psyment->n_value -
1877
      (bfd_hostptr_t) obj_raw_syments (abfd);
1878
 
1879
  /* FIXME: We should handle fix_line here.  */
1880
 
1881
  return TRUE;
1882
}
1883
 
1884
/* Return the COFF auxent for a symbol.  */
1885
 
1886
bfd_boolean
1887
bfd_coff_get_auxent (bfd *abfd,
1888
                     asymbol *symbol,
1889
                     int indx,
1890
                     union internal_auxent *pauxent)
1891
{
1892
  coff_symbol_type *csym;
1893
  combined_entry_type *ent;
1894
 
1895
  csym = coff_symbol_from (abfd, symbol);
1896
 
1897
  if (csym == NULL
1898
      || csym->native == NULL
1899
      || indx >= csym->native->u.syment.n_numaux)
1900
    {
1901
      bfd_set_error (bfd_error_invalid_operation);
1902
      return FALSE;
1903
    }
1904
 
1905
  ent = csym->native + indx + 1;
1906
 
1907
  *pauxent = ent->u.auxent;
1908
 
1909
  if (ent->fix_tag)
1910
    pauxent->x_sym.x_tagndx.l =
1911
      ((combined_entry_type *) pauxent->x_sym.x_tagndx.p
1912
       - obj_raw_syments (abfd));
1913
 
1914
  if (ent->fix_end)
1915
    pauxent->x_sym.x_fcnary.x_fcn.x_endndx.l =
1916
      ((combined_entry_type *) pauxent->x_sym.x_fcnary.x_fcn.x_endndx.p
1917
       - obj_raw_syments (abfd));
1918
 
1919
  if (ent->fix_scnlen)
1920
    pauxent->x_csect.x_scnlen.l =
1921
      ((combined_entry_type *) pauxent->x_csect.x_scnlen.p
1922
       - obj_raw_syments (abfd));
1923
 
1924
  return TRUE;
1925
}
1926
 
1927
/* Print out information about COFF symbol.  */
1928
 
1929
void
1930
coff_print_symbol (bfd *abfd,
1931
                   void * filep,
1932
                   asymbol *symbol,
1933
                   bfd_print_symbol_type how)
1934
{
1935
  FILE * file = (FILE *) filep;
1936
 
1937
  switch (how)
1938
    {
1939
    case bfd_print_symbol_name:
1940
      fprintf (file, "%s", symbol->name);
1941
      break;
1942
 
1943
    case bfd_print_symbol_more:
1944
      fprintf (file, "coff %s %s",
1945
               coffsymbol (symbol)->native ? "n" : "g",
1946
               coffsymbol (symbol)->lineno ? "l" : " ");
1947
      break;
1948
 
1949
    case bfd_print_symbol_all:
1950
      if (coffsymbol (symbol)->native)
1951
        {
1952
          bfd_vma val;
1953
          unsigned int aux;
1954
          combined_entry_type *combined = coffsymbol (symbol)->native;
1955
          combined_entry_type *root = obj_raw_syments (abfd);
1956
          struct lineno_cache_entry *l = coffsymbol (symbol)->lineno;
1957
 
1958
          fprintf (file, "[%3ld]", (long) (combined - root));
1959
 
1960
          if (! combined->fix_value)
1961
            val = (bfd_vma) combined->u.syment.n_value;
1962
          else
1963
            val = combined->u.syment.n_value - (bfd_hostptr_t) root;
1964
 
1965
          fprintf (file, "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x",
1966
                   combined->u.syment.n_scnum,
1967
                   combined->u.syment.n_flags,
1968
                   combined->u.syment.n_type,
1969
                   combined->u.syment.n_sclass,
1970
                   combined->u.syment.n_numaux);
1971
          bfd_fprintf_vma (abfd, file, val);
1972
          fprintf (file, " %s", symbol->name);
1973
 
1974
          for (aux = 0; aux < combined->u.syment.n_numaux; aux++)
1975
            {
1976
              combined_entry_type *auxp = combined + aux + 1;
1977
              long tagndx;
1978
 
1979
              if (auxp->fix_tag)
1980
                tagndx = auxp->u.auxent.x_sym.x_tagndx.p - root;
1981
              else
1982
                tagndx = auxp->u.auxent.x_sym.x_tagndx.l;
1983
 
1984
              fprintf (file, "\n");
1985
 
1986
              if (bfd_coff_print_aux (abfd, file, root, combined, auxp, aux))
1987
                continue;
1988
 
1989
              switch (combined->u.syment.n_sclass)
1990
                {
1991
                case C_FILE:
1992
                  fprintf (file, "File ");
1993
                  break;
1994
 
1995
                case C_STAT:
1996
                  if (combined->u.syment.n_type == T_NULL)
1997
                    /* Probably a section symbol ?  */
1998
                    {
1999
                      fprintf (file, "AUX scnlen 0x%lx nreloc %d nlnno %d",
2000
                               (unsigned long) auxp->u.auxent.x_scn.x_scnlen,
2001
                               auxp->u.auxent.x_scn.x_nreloc,
2002
                               auxp->u.auxent.x_scn.x_nlinno);
2003
                      if (auxp->u.auxent.x_scn.x_checksum != 0
2004
                          || auxp->u.auxent.x_scn.x_associated != 0
2005
                          || auxp->u.auxent.x_scn.x_comdat != 0)
2006
                        fprintf (file, " checksum 0x%lx assoc %d comdat %d",
2007
                                 auxp->u.auxent.x_scn.x_checksum,
2008
                                 auxp->u.auxent.x_scn.x_associated,
2009
                                 auxp->u.auxent.x_scn.x_comdat);
2010
                      break;
2011
                    }
2012
                    /* Otherwise fall through.  */
2013
                case C_EXT:
2014
                case C_AIX_WEAKEXT:
2015
                  if (ISFCN (combined->u.syment.n_type))
2016
                    {
2017
                      long next, llnos;
2018
 
2019
                      if (auxp->fix_end)
2020
                        next = (auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p
2021
                               - root);
2022
                      else
2023
                        next = auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l;
2024
                      llnos = auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_lnnoptr;
2025
                      fprintf (file,
2026
                               "AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld",
2027
                               tagndx,
2028
                               (unsigned long) auxp->u.auxent.x_sym.x_misc.x_fsize,
2029
                               llnos, next);
2030
                      break;
2031
                    }
2032
                  /* Otherwise fall through.  */
2033
                default:
2034
                  fprintf (file, "AUX lnno %d size 0x%x tagndx %ld",
2035
                           auxp->u.auxent.x_sym.x_misc.x_lnsz.x_lnno,
2036
                           auxp->u.auxent.x_sym.x_misc.x_lnsz.x_size,
2037
                           tagndx);
2038
                  if (auxp->fix_end)
2039
                    fprintf (file, " endndx %ld",
2040
                             ((long)
2041
                              (auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p
2042
                               - root)));
2043
                  break;
2044
                }
2045
            }
2046
 
2047
          if (l)
2048
            {
2049
              fprintf (file, "\n%s :", l->u.sym->name);
2050
              l++;
2051
              while (l->line_number)
2052
                {
2053
                  fprintf (file, "\n%4d : ", l->line_number);
2054
                  bfd_fprintf_vma (abfd, file, l->u.offset + symbol->section->vma);
2055
                  l++;
2056
                }
2057
            }
2058
        }
2059
      else
2060
        {
2061
          bfd_print_symbol_vandf (abfd, (void *) file, symbol);
2062
          fprintf (file, " %-5s %s %s %s",
2063
                   symbol->section->name,
2064
                   coffsymbol (symbol)->native ? "n" : "g",
2065
                   coffsymbol (symbol)->lineno ? "l" : " ",
2066
                   symbol->name);
2067
        }
2068
    }
2069
}
2070
 
2071
/* Return whether a symbol name implies a local symbol.  In COFF,
2072
   local symbols generally start with ``.L''.  Most targets use this
2073
   function for the is_local_label_name entry point, but some may
2074
   override it.  */
2075
 
2076
bfd_boolean
2077
_bfd_coff_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
2078
                               const char *name)
2079
{
2080
  return name[0] == '.' && name[1] == 'L';
2081
}
2082
 
2083
/* Provided a BFD, a section and an offset (in bytes, not octets) into the
2084
   section, calculate and return the name of the source file and the line
2085
   nearest to the wanted location.  */
2086
 
2087
bfd_boolean
2088
coff_find_nearest_line (bfd *abfd,
2089
                        asection *section,
2090
                        asymbol **symbols,
2091
                        bfd_vma offset,
2092
                        const char **filename_ptr,
2093
                        const char **functionname_ptr,
2094
                        unsigned int *line_ptr)
2095
{
2096
  bfd_boolean found;
2097
  unsigned int i;
2098
  unsigned int line_base;
2099
  coff_data_type *cof = coff_data (abfd);
2100
  /* Run through the raw syments if available.  */
2101
  combined_entry_type *p;
2102
  combined_entry_type *pend;
2103
  alent *l;
2104
  struct coff_section_tdata *sec_data;
2105
  bfd_size_type amt;
2106
 
2107
  /* Before looking through the symbol table, try to use a .stab
2108
     section to find the information.  */
2109
  if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
2110
                                             &found, filename_ptr,
2111
                                             functionname_ptr, line_ptr,
2112
                                             &coff_data(abfd)->line_info))
2113
    return FALSE;
2114
 
2115
  if (found)
2116
    return TRUE;
2117
 
2118
  /* Also try examining DWARF2 debugging information.  */
2119
  if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
2120
                                     filename_ptr, functionname_ptr,
2121
                                     line_ptr, 0,
2122
                                     &coff_data(abfd)->dwarf2_find_line_info))
2123
    return TRUE;
2124
 
2125
  *filename_ptr = 0;
2126
  *functionname_ptr = 0;
2127
  *line_ptr = 0;
2128
 
2129
  /* Don't try and find line numbers in a non coff file.  */
2130
  if (!bfd_family_coff (abfd))
2131
    return FALSE;
2132
 
2133
  if (cof == NULL)
2134
    return FALSE;
2135
 
2136
  /* Find the first C_FILE symbol.  */
2137
  p = cof->raw_syments;
2138
  if (!p)
2139
    return FALSE;
2140
 
2141
  pend = p + cof->raw_syment_count;
2142
  while (p < pend)
2143
    {
2144
      if (p->u.syment.n_sclass == C_FILE)
2145
        break;
2146
      p += 1 + p->u.syment.n_numaux;
2147
    }
2148
 
2149
  if (p < pend)
2150
    {
2151
      bfd_vma sec_vma;
2152
      bfd_vma maxdiff;
2153
 
2154
      /* Look through the C_FILE symbols to find the best one.  */
2155
      sec_vma = bfd_get_section_vma (abfd, section);
2156
      *filename_ptr = (char *) p->u.syment._n._n_n._n_offset;
2157
      maxdiff = (bfd_vma) 0 - (bfd_vma) 1;
2158
      while (1)
2159
        {
2160
          bfd_vma file_addr;
2161
          combined_entry_type *p2;
2162
 
2163
          for (p2 = p + 1 + p->u.syment.n_numaux;
2164
               p2 < pend;
2165
               p2 += 1 + p2->u.syment.n_numaux)
2166
            {
2167
              if (p2->u.syment.n_scnum > 0
2168
                  && (section
2169
                      == coff_section_from_bfd_index (abfd,
2170
                                                      p2->u.syment.n_scnum)))
2171
                break;
2172
              if (p2->u.syment.n_sclass == C_FILE)
2173
                {
2174
                  p2 = pend;
2175
                  break;
2176
                }
2177
            }
2178
 
2179
          file_addr = (bfd_vma) p2->u.syment.n_value;
2180
          /* PR 11512: Include the section address of the function name symbol.  */
2181
          if (p2->u.syment.n_scnum > 0)
2182
            file_addr += coff_section_from_bfd_index (abfd,
2183
                                                      p2->u.syment.n_scnum)->vma;
2184
          /* We use <= MAXDIFF here so that if we get a zero length
2185
             file, we actually use the next file entry.  */
2186
          if (p2 < pend
2187
              && offset + sec_vma >= file_addr
2188
              && offset + sec_vma - file_addr <= maxdiff)
2189
            {
2190
              *filename_ptr = (char *) p->u.syment._n._n_n._n_offset;
2191
              maxdiff = offset + sec_vma - p2->u.syment.n_value;
2192
            }
2193
 
2194
          /* Avoid endless loops on erroneous files by ensuring that
2195
             we always move forward in the file.  */
2196
          if (p >= cof->raw_syments + p->u.syment.n_value)
2197
            break;
2198
 
2199
          p = cof->raw_syments + p->u.syment.n_value;
2200
          if (p > pend || p->u.syment.n_sclass != C_FILE)
2201
            break;
2202
        }
2203
    }
2204
 
2205
  /* Now wander though the raw linenumbers of the section.  */
2206
  /* If we have been called on this section before, and the offset we
2207
     want is further down then we can prime the lookup loop.  */
2208
  sec_data = coff_section_data (abfd, section);
2209
  if (sec_data != NULL
2210
      && sec_data->i > 0
2211
      && offset >= sec_data->offset)
2212
    {
2213
      i = sec_data->i;
2214
      *functionname_ptr = sec_data->function;
2215
      line_base = sec_data->line_base;
2216
    }
2217
  else
2218
    {
2219
      i = 0;
2220
      line_base = 0;
2221
    }
2222
 
2223
  if (section->lineno != NULL)
2224
    {
2225
      bfd_vma last_value = 0;
2226
 
2227
      l = &section->lineno[i];
2228
 
2229
      for (; i < section->lineno_count; i++)
2230
        {
2231
          if (l->line_number == 0)
2232
            {
2233
              /* Get the symbol this line number points at.  */
2234
              coff_symbol_type *coff = (coff_symbol_type *) (l->u.sym);
2235
              if (coff->symbol.value > offset)
2236
                break;
2237
              *functionname_ptr = coff->symbol.name;
2238
              last_value = coff->symbol.value;
2239
              if (coff->native)
2240
                {
2241
                  combined_entry_type *s = coff->native;
2242
                  s = s + 1 + s->u.syment.n_numaux;
2243
 
2244
                  /* In XCOFF a debugging symbol can follow the
2245
                     function symbol.  */
2246
                  if (s->u.syment.n_scnum == N_DEBUG)
2247
                    s = s + 1 + s->u.syment.n_numaux;
2248
 
2249
                  /* S should now point to the .bf of the function.  */
2250
                  if (s->u.syment.n_numaux)
2251
                    {
2252
                      /* The linenumber is stored in the auxent.  */
2253
                      union internal_auxent *a = &((s + 1)->u.auxent);
2254
                      line_base = a->x_sym.x_misc.x_lnsz.x_lnno;
2255
                      *line_ptr = line_base;
2256
                    }
2257
                }
2258
            }
2259
          else
2260
            {
2261
              if (l->u.offset > offset)
2262
                break;
2263
              *line_ptr = l->line_number + line_base - 1;
2264
            }
2265
          l++;
2266
        }
2267
 
2268
      /* If we fell off the end of the loop, then assume that this
2269
         symbol has no line number info.  Otherwise, symbols with no
2270
         line number info get reported with the line number of the
2271
         last line of the last symbol which does have line number
2272
         info.  We use 0x100 as a slop to account for cases where the
2273
         last line has executable code.  */
2274
      if (i >= section->lineno_count
2275
          && last_value != 0
2276
          && offset - last_value > 0x100)
2277
        {
2278
          *functionname_ptr = NULL;
2279
          *line_ptr = 0;
2280
        }
2281
    }
2282
 
2283
  /* Cache the results for the next call.  */
2284
  if (sec_data == NULL && section->owner == abfd)
2285
    {
2286
      amt = sizeof (struct coff_section_tdata);
2287
      section->used_by_bfd = bfd_zalloc (abfd, amt);
2288
      sec_data = (struct coff_section_tdata *) section->used_by_bfd;
2289
    }
2290
  if (sec_data != NULL)
2291
    {
2292
      sec_data->offset = offset;
2293
      sec_data->i = i - 1;
2294
      sec_data->function = *functionname_ptr;
2295
      sec_data->line_base = line_base;
2296
    }
2297
 
2298
  return TRUE;
2299
}
2300
 
2301
bfd_boolean
2302
coff_find_inliner_info (bfd *abfd,
2303
                        const char **filename_ptr,
2304
                        const char **functionname_ptr,
2305
                        unsigned int *line_ptr)
2306
{
2307
  bfd_boolean found;
2308
 
2309
  found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
2310
                                         functionname_ptr, line_ptr,
2311
                                         &coff_data(abfd)->dwarf2_find_line_info);
2312
  return (found);
2313
}
2314
 
2315
int
2316
coff_sizeof_headers (bfd *abfd, struct bfd_link_info *info)
2317
{
2318
  size_t size;
2319
 
2320
  if (!info->relocatable)
2321
    size = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
2322
  else
2323
    size = bfd_coff_filhsz (abfd);
2324
 
2325
  size += abfd->section_count * bfd_coff_scnhsz (abfd);
2326
  return size;
2327
}
2328
 
2329
/* Change the class of a coff symbol held by BFD.  */
2330
 
2331
bfd_boolean
2332
bfd_coff_set_symbol_class (bfd *         abfd,
2333
                           asymbol *     symbol,
2334
                           unsigned int  symbol_class)
2335
{
2336
  coff_symbol_type * csym;
2337
 
2338
  csym = coff_symbol_from (abfd, symbol);
2339
  if (csym == NULL)
2340
    {
2341
      bfd_set_error (bfd_error_invalid_operation);
2342
      return FALSE;
2343
    }
2344
  else if (csym->native == NULL)
2345
    {
2346
      /* This is an alien symbol which no native coff backend data.
2347
         We cheat here by creating a fake native entry for it and
2348
         then filling in the class.  This code is based on that in
2349
         coff_write_alien_symbol().  */
2350
 
2351
      combined_entry_type * native;
2352
      bfd_size_type amt = sizeof (* native);
2353
 
2354
      native = (combined_entry_type *) bfd_zalloc (abfd, amt);
2355
      if (native == NULL)
2356
        return FALSE;
2357
 
2358
      native->u.syment.n_type   = T_NULL;
2359
      native->u.syment.n_sclass = symbol_class;
2360
 
2361
      if (bfd_is_und_section (symbol->section))
2362
        {
2363
          native->u.syment.n_scnum = N_UNDEF;
2364
          native->u.syment.n_value = symbol->value;
2365
        }
2366
      else if (bfd_is_com_section (symbol->section))
2367
        {
2368
          native->u.syment.n_scnum = N_UNDEF;
2369
          native->u.syment.n_value = symbol->value;
2370
        }
2371
      else
2372
        {
2373
          native->u.syment.n_scnum =
2374
            symbol->section->output_section->target_index;
2375
          native->u.syment.n_value = (symbol->value
2376
                                      + symbol->section->output_offset);
2377
          if (! obj_pe (abfd))
2378
            native->u.syment.n_value += symbol->section->output_section->vma;
2379
 
2380
          /* Copy the any flags from the file header into the symbol.
2381
             FIXME: Why?  */
2382
          native->u.syment.n_flags = bfd_asymbol_bfd (& csym->symbol)->flags;
2383
        }
2384
 
2385
      csym->native = native;
2386
    }
2387
  else
2388
    csym->native->u.syment.n_sclass = symbol_class;
2389
 
2390
  return TRUE;
2391
}
2392
 
2393
struct coff_comdat_info *
2394
bfd_coff_get_comdat_section (bfd *abfd, struct bfd_section *sec)
2395
{
2396
  if (bfd_get_flavour (abfd) == bfd_target_coff_flavour
2397
      && coff_section_data (abfd, sec) != NULL)
2398
    return coff_section_data (abfd, sec)->comdat;
2399
  else
2400
    return NULL;
2401
}

powered by: WebSVN 2.1.0

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