bfd/coffgen.c

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