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