bfd/coffgen.c

   1 /* Support for the generic parts of COFF, for BFD.
   2    Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   3    2000, 2001
   4    Free Software Foundation, Inc.
   5    Written by Cygnus Support.
   6
   7 This file is part of BFD, the Binary File Descriptor library.
   8
   9 This program is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 2 of the License, or
  12 (at your option) any later version.
  13
  14 This program is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with this program; if not, write to the Free Software
  21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  22
  23 /* Most of this hacked by  Steve Chamberlain, sac@cygnus.com.
  24    Split out of coffcode.h by Ian Taylor, ian@cygnus.com.  */
  25
  26 /* This file contains COFF code that is not dependent on any
  27    particular COFF target.  There is only one version of this file in
  28    libbfd.a, so no target specific code may be put in here.  Or, to
  29    put it another way,
  30
  31    ********** DO NOT PUT TARGET SPECIFIC CODE IN THIS FILE **********
  32
  33    If you need to add some target specific behaviour, add a new hook
  34    function to bfd_coff_backend_data.
  35
  36    Some of these functions are also called by the ECOFF routines.
  37    Those functions may not use any COFF specific information, such as
  38    coff_data (abfd).  */
  39
  40 #include "bfd.h"
  41 #include "sysdep.h"
  42 #include "libbfd.h"
  43 #include "coff/internal.h"
  44 #include "libcoff.h"
  45
  46 static void coff_fix_symbol_name
  47   PARAMS ((bfd *, asymbol *, combined_entry_type *, bfd_size_type *,
  48            asection **, bfd_size_type *));
  49 static boolean coff_write_symbol
  50   PARAMS ((bfd *, asymbol *, combined_entry_type *, bfd_vma *,
  51            bfd_size_type *, asection **, bfd_size_type *));
  52 static boolean coff_write_alien_symbol
  53   PARAMS ((bfd *, asymbol *, bfd_vma *, bfd_size_type *,
  54            asection **, bfd_size_type *));
  55 static boolean coff_write_native_symbol
  56   PARAMS ((bfd *, coff_symbol_type *, bfd_vma *, bfd_size_type *,
  57            asection **, bfd_size_type *));
  58 static void coff_pointerize_aux
  59   PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
  60            unsigned int, combined_entry_type *));
  61 static boolean make_a_section_from_file
  62   PARAMS ((bfd *, struct internal_scnhdr *, unsigned int));
  63 static const bfd_target *coff_real_object_p
  64   PARAMS ((bfd *, unsigned, struct internal_filehdr *,
  65            struct internal_aouthdr *));
  66 static void fixup_symbol_value
  67   PARAMS ((bfd *, coff_symbol_type *, struct internal_syment *));
  68 static char *build_debug_section
  69   PARAMS ((bfd *));
  70 static char *copy_name
  71   PARAMS ((bfd *, char *, int));
  72
  73 #define STRING_SIZE_SIZE (4)
  74
  75 /* Take a section header read from a coff file (in HOST byte order),
  76    and make a BFD "section" out of it.  This is used by ECOFF.  */
  77 static boolean
  78 make_a_section_from_file (abfd, hdr, target_index)
  79      bfd *abfd;
  80      struct internal_scnhdr *hdr;
  81      unsigned int target_index;
  82 {
  83   asection *return_section;
  84   char *name;
  85
  86   name = NULL;
  87
  88   /* Handle long section names as in PE.  */
  89   if (bfd_coff_long_section_names (abfd)
  90       && hdr->s_name[0] == '/')
  91     {
  92       char buf[SCNNMLEN];
  93       long strindex;
  94       char *p;
  95       const char *strings;
  96
  97       memcpy (buf, hdr->s_name + 1, SCNNMLEN - 1);
  98       buf[SCNNMLEN - 1] = '\0';
  99       strindex = strtol (buf, &p, 10);
 100       if (*p == '\0' && strindex >= 0)
 101         {
 102           strings = _bfd_coff_read_string_table (abfd);
 103           if (strings == NULL)
 104             return false;
 105           /* FIXME: For extra safety, we should make sure that
 106              strindex does not run us past the end, but right now we
 107              don't know the length of the string table.  */
 108           strings += strindex;
 109           name = bfd_alloc (abfd, strlen (strings) + 1);
 110           if (name == NULL)
 111             return false;
 112           strcpy (name, strings);
 113         }
 114     }
 115
 116   if (name == NULL)
 117     {
 118       /* Assorted wastage to null-terminate the name, thanks AT&T! */
 119       name = bfd_alloc (abfd, sizeof (hdr->s_name) + 1);
 120       if (name == NULL)
 121         return false;
 122       strncpy (name, (char *) &hdr->s_name[0], sizeof (hdr->s_name));
 123       name[sizeof (hdr->s_name)] = 0;
 124     }
 125
 126   return_section = bfd_make_section_anyway (abfd, name);
 127   if (return_section == NULL)
 128     return false;
 129
 130   return_section->vma = hdr->s_vaddr;
 131   return_section->lma = hdr->s_paddr;
 132   return_section->_raw_size = hdr->s_size;
 133   return_section->filepos = hdr->s_scnptr;
 134   return_section->rel_filepos = hdr->s_relptr;
 135   return_section->reloc_count = hdr->s_nreloc;
 136
 137   bfd_coff_set_alignment_hook (abfd, return_section, hdr);
 138
 139   return_section->line_filepos = hdr->s_lnnoptr;
 140
 141   return_section->lineno_count = hdr->s_nlnno;
 142   return_section->userdata = NULL;
 143   return_section->next = (asection *) NULL;
 144   return_section->target_index = target_index;
 145   return_section->flags = bfd_coff_styp_to_sec_flags_hook (abfd, hdr, name,
 146                                                            return_section);
 147
 148   /* At least on i386-coff, the line number count for a shared library
 149      section must be ignored.  */
 150   if ((return_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
 151     return_section->lineno_count = 0;
 152
 153   if (hdr->s_nreloc != 0)
 154     return_section->flags |= SEC_RELOC;
 155   /* FIXME: should this check 'hdr->s_size > 0' */
 156   if (hdr->s_scnptr != 0)
 157     return_section->flags |= SEC_HAS_CONTENTS;
 158   return true;
 159 }
 160
 161 /* Read in a COFF object and make it into a BFD.  This is used by
 162    ECOFF as well.  */
 163
 164 static const bfd_target *
 165 coff_real_object_p (abfd, nscns, internal_f, internal_a)
 166      bfd *abfd;
 167      unsigned nscns;
 168      struct internal_filehdr *internal_f;
 169      struct internal_aouthdr *internal_a;
 170 {
 171   flagword oflags = abfd->flags;
 172   bfd_vma ostart = bfd_get_start_address (abfd);
 173   PTR tdata;
 174   size_t readsize;              /* length of file_info */
 175   unsigned int scnhsz;
 176   char *external_sections;
 177
 178   if (!(internal_f->f_flags & F_RELFLG))
 179     abfd->flags |= HAS_RELOC;
 180   if ((internal_f->f_flags & F_EXEC))
 181     abfd->flags |= EXEC_P;
 182   if (!(internal_f->f_flags & F_LNNO))
 183     abfd->flags |= HAS_LINENO;
 184   if (!(internal_f->f_flags & F_LSYMS))
 185     abfd->flags |= HAS_LOCALS;
 186
 187   /* FIXME: How can we set D_PAGED correctly?  */
 188   if ((internal_f->f_flags & F_EXEC) != 0)
 189     abfd->flags |= D_PAGED;
 190
 191   bfd_get_symcount (abfd) = internal_f->f_nsyms;
 192   if (internal_f->f_nsyms)
 193     abfd->flags |= HAS_SYMS;
 194
 195   if (internal_a != (struct internal_aouthdr *) NULL)
 196     bfd_get_start_address (abfd) = internal_a->entry;
 197   else
 198     bfd_get_start_address (abfd) = 0;
 199
 200   /* Set up the tdata area.  ECOFF uses its own routine, and overrides
 201      abfd->flags.  */
 202   tdata = bfd_coff_mkobject_hook (abfd, (PTR) internal_f, (PTR) internal_a);
 203   if (tdata == NULL)
 204     return 0;
 205
 206   scnhsz = bfd_coff_scnhsz (abfd);
 207   readsize = nscns * scnhsz;
 208   external_sections = (char *) bfd_alloc (abfd, readsize);
 209   if (!external_sections)
 210     goto fail;
 211
 212   if (bfd_read ((PTR) external_sections, 1, readsize, abfd) != readsize)
 213     goto fail;
 214
 215   /* Set the arch/mach *before* swapping in sections; section header swapping
 216      may depend on arch/mach info.  */
 217   if (bfd_coff_set_arch_mach_hook (abfd, (PTR) internal_f) == false)
 218     goto fail;
 219
 220   /* Now copy data as required; construct all asections etc */
 221   if (nscns != 0)
 222     {
 223       unsigned int i;
 224       for (i = 0; i < nscns; i++)
 225         {
 226           struct internal_scnhdr tmp;
 227           bfd_coff_swap_scnhdr_in (abfd,
 228                                    (PTR) (external_sections + i * scnhsz),
 229                                    (PTR) & tmp);
 230           if (! make_a_section_from_file (abfd, &tmp, i + 1))
 231             goto fail;
 232         }
 233     }
 234
 235   /*  make_abs_section (abfd); */
 236
 237   return abfd->xvec;
 238
 239  fail:
 240   bfd_release (abfd, tdata);
 241   abfd->flags = oflags;
 242   bfd_get_start_address (abfd) = ostart;
 243   return (const bfd_target *) NULL;
 244 }
 245
 246 /* Turn a COFF file into a BFD, but fail with bfd_error_wrong_format if it is
 247    not a COFF file.  This is also used by ECOFF.  */
 248
 249 const bfd_target *
 250 coff_object_p (abfd)
 251      bfd *abfd;
 252 {
 253   unsigned int filhsz;
 254   unsigned int aoutsz;
 255   int nscns;
 256   PTR filehdr;
 257   struct internal_filehdr internal_f;
 258   struct internal_aouthdr internal_a;
 259
 260   /* figure out how much to read */
 261   filhsz = bfd_coff_filhsz (abfd);
 262   aoutsz = bfd_coff_aoutsz (abfd);
 263
 264   filehdr = bfd_alloc (abfd, filhsz);
 265   if (filehdr == NULL)
 266     return 0;
 267   if (bfd_read (filehdr, 1, filhsz, abfd) != filhsz)
 268     {
 269       if (bfd_get_error () != bfd_error_system_call)
 270         bfd_set_error (bfd_error_wrong_format);
 271       return 0;
 272     }
 273   bfd_coff_swap_filehdr_in (abfd, filehdr, &internal_f);
 274   bfd_release (abfd, filehdr);
 275
 276   if (bfd_coff_bad_format_hook (abfd, &internal_f) == false)
 277     {
 278       bfd_set_error (bfd_error_wrong_format);
 279       return 0;
 280     }
 281   nscns = internal_f.f_nscns;
 282
 283   if (internal_f.f_opthdr)
 284     {
 285       PTR opthdr;
 286
 287       opthdr = bfd_alloc (abfd, aoutsz);
 288       if (opthdr == NULL)
 289         return 0;;
 290       if (bfd_read (opthdr, 1, internal_f.f_opthdr, abfd)
 291           != internal_f.f_opthdr)
 292         {
 293           return 0;
 294         }
 295       bfd_coff_swap_aouthdr_in (abfd, opthdr, (PTR) &internal_a);
 296     }
 297
 298   return coff_real_object_p (abfd, nscns, &internal_f,
 299                              (internal_f.f_opthdr != 0
 300                               ? &internal_a
 301                               : (struct internal_aouthdr *) NULL));
 302 }
 303
 304 /* Get the BFD section from a COFF symbol section number.  */
 305
 306 asection *
 307 coff_section_from_bfd_index (abfd, index)
 308      bfd *abfd;
 309      int index;
 310 {
 311   struct sec *answer = abfd->sections;
 312
 313   if (index == N_ABS)
 314     return bfd_abs_section_ptr;
 315   if (index == N_UNDEF)
 316     return bfd_und_section_ptr;
 317   if (index == N_DEBUG)
 318     return bfd_abs_section_ptr;
 319
 320   while (answer)
 321     {
 322       if (answer->target_index == index)
 323         return answer;
 324       answer = answer->next;
 325     }
 326
 327   /* We should not reach this point, but the SCO 3.2v4 /lib/libc_s.a
 328      has a bad symbol table in biglitpow.o.  */
 329   return bfd_und_section_ptr;
 330 }
 331
 332 /* Get the upper bound of a COFF symbol table.  */
 333
 334 long
 335 coff_get_symtab_upper_bound (abfd)
 336      bfd *abfd;
 337 {
 338   if (!bfd_coff_slurp_symbol_table (abfd))
 339     return -1;
 340
 341   return (bfd_get_symcount (abfd) + 1) * (sizeof (coff_symbol_type *));
 342 }
 343
 344 /* Canonicalize a COFF symbol table.  */
 345
 346 long
 347 coff_get_symtab (abfd, alocation)
 348      bfd *abfd;
 349      asymbol **alocation;
 350 {
 351   unsigned int counter;
 352   coff_symbol_type *symbase;
 353   coff_symbol_type **location = (coff_symbol_type **) alocation;
 354
 355   if (!bfd_coff_slurp_symbol_table (abfd))
 356     return -1;
 357
 358   symbase = obj_symbols (abfd);
 359   counter = bfd_get_symcount (abfd);
 360   while (counter-- > 0)
 361     *location++ = symbase++;
 362
 363   *location = NULL;
 364
 365   return bfd_get_symcount (abfd);
 366 }
 367
 368 /* Get the name of a symbol.  The caller must pass in a buffer of size
 369    >= SYMNMLEN + 1.  */
 370
 371 const char *
 372 _bfd_coff_internal_syment_name (abfd, sym, buf)
 373      bfd *abfd;
 374      const struct internal_syment *sym;
 375      char *buf;
 376 {
 377   /* FIXME: It's not clear this will work correctly if sizeof
 378      (_n_zeroes) != 4.  */
 379   if (sym->_n._n_n._n_zeroes != 0
 380       || sym->_n._n_n._n_offset == 0)
 381     {
 382       memcpy (buf, sym->_n._n_name, SYMNMLEN);
 383       buf[SYMNMLEN] = '\0';
 384       return buf;
 385     }
 386   else
 387     {
 388       const char *strings;
 389
 390       BFD_ASSERT (sym->_n._n_n._n_offset >= STRING_SIZE_SIZE);
 391       strings = obj_coff_strings (abfd);
 392       if (strings == NULL)
 393         {
 394           strings = _bfd_coff_read_string_table (abfd);
 395           if (strings == NULL)
 396             return NULL;
 397         }
 398       return strings + sym->_n._n_n._n_offset;
 399     }
 400 }
 401
 402 /* Read in and swap the relocs.  This returns a buffer holding the
 403    relocs for section SEC in file ABFD.  If CACHE is true and
 404    INTERNAL_RELOCS is NULL, the relocs read in will be saved in case
 405    the function is called again.  If EXTERNAL_RELOCS is not NULL, it
 406    is a buffer large enough to hold the unswapped relocs.  If
 407    INTERNAL_RELOCS is not NULL, it is a buffer large enough to hold
 408    the swapped relocs.  If REQUIRE_INTERNAL is true, then the return
 409    value must be INTERNAL_RELOCS.  The function returns NULL on error.  */
 410
 411 struct internal_reloc *
 412 _bfd_coff_read_internal_relocs (abfd, sec, cache, external_relocs,
 413                                 require_internal, internal_relocs)
 414      bfd *abfd;
 415      asection *sec;
 416      boolean cache;
 417      bfd_byte *external_relocs;
 418      boolean require_internal;
 419      struct internal_reloc *internal_relocs;
 420 {
 421   bfd_size_type relsz;
 422   bfd_byte *free_external = NULL;
 423   struct internal_reloc *free_internal = NULL;
 424   bfd_byte *erel;
 425   bfd_byte *erel_end;
 426   struct internal_reloc *irel;
 427
 428   if (coff_section_data (abfd, sec) != NULL
 429       && coff_section_data (abfd, sec)->relocs != NULL)
 430     {
 431       if (! require_internal)
 432         return coff_section_data (abfd, sec)->relocs;
 433       memcpy (internal_relocs, coff_section_data (abfd, sec)->relocs,
 434               sec->reloc_count * sizeof (struct internal_reloc));
 435       return internal_relocs;
 436     }
 437
 438   relsz = bfd_coff_relsz (abfd);
 439
 440   if (external_relocs == NULL)
 441     {
 442       free_external = (bfd_byte *) bfd_malloc (sec->reloc_count * relsz);
 443       if (free_external == NULL && sec->reloc_count > 0)
 444         goto error_return;
 445       external_relocs = free_external;
 446     }
 447
 448   if (bfd_seek (abfd, sec->rel_filepos, SEEK_SET) != 0
 449       || (bfd_read (external_relocs, relsz, sec->reloc_count, abfd)
 450           != relsz * sec->reloc_count))
 451     goto error_return;
 452
 453   if (internal_relocs == NULL)
 454     {
 455       free_internal = ((struct internal_reloc *)
 456                        bfd_malloc (sec->reloc_count
 457                                    * sizeof (struct internal_reloc)));
 458       if (free_internal == NULL && sec->reloc_count > 0)
 459         goto error_return;
 460       internal_relocs = free_internal;
 461     }
 462
 463   /* Swap in the relocs.  */
 464   erel = external_relocs;
 465   erel_end = erel + relsz * sec->reloc_count;
 466   irel = internal_relocs;
 467   for (; erel < erel_end; erel += relsz, irel++)
 468     bfd_coff_swap_reloc_in (abfd, (PTR) erel, (PTR) irel);
 469
 470   if (free_external != NULL)
 471     {
 472       free (free_external);
 473       free_external = NULL;
 474     }
 475
 476   if (cache && free_internal != NULL)
 477     {
 478       if (coff_section_data (abfd, sec) == NULL)
 479         {
 480           sec->used_by_bfd =
 481             (PTR) bfd_zalloc (abfd,
 482                               sizeof (struct coff_section_tdata));
 483           if (sec->used_by_bfd == NULL)
 484             goto error_return;
 485           coff_section_data (abfd, sec)->contents = NULL;
 486         }
 487       coff_section_data (abfd, sec)->relocs = free_internal;
 488     }
 489
 490   return internal_relocs;
 491
 492  error_return:
 493   if (free_external != NULL)
 494     free (free_external);
 495   if (free_internal != NULL)
 496     free (free_internal);
 497   return NULL;
 498 }
 499
 500 /* Set lineno_count for the output sections of a COFF file.  */
 501
 502 int
 503 coff_count_linenumbers (abfd)
 504      bfd *abfd;
 505 {
 506   unsigned int limit = bfd_get_symcount (abfd);
 507   unsigned int i;
 508   int total = 0;
 509   asymbol **p;
 510   asection *s;
 511
 512   if (limit == 0)
 513     {
 514       /* This may be from the backend linker, in which case the
 515          lineno_count in the sections is correct.  */
 516       for (s = abfd->sections; s != NULL; s = s->next)
 517         total += s->lineno_count;
 518       return total;
 519     }
 520
 521   for (s = abfd->sections; s != NULL; s = s->next)
 522     BFD_ASSERT (s->lineno_count == 0);
 523
 524   for (p = abfd->outsymbols, i = 0; i < limit; i++, p++)
 525     {
 526       asymbol *q_maybe = *p;
 527
 528       if (bfd_family_coff (bfd_asymbol_bfd (q_maybe)))
 529         {
 530           coff_symbol_type *q = coffsymbol (q_maybe);
 531
 532           /* The AIX 4.1 compiler can sometimes generate line numbers
 533              attached to debugging symbols.  We try to simply ignore
 534              those here.  */
 535           if (q->lineno != NULL
 536               && q->symbol.section->owner != NULL)
 537             {
 538               /* This symbol has line numbers.  Increment the owning
 539                  section's linenumber count.  */
 540               alent *l = q->lineno;
 541
 542               ++q->symbol.section->output_section->lineno_count;
 543               ++total;
 544               ++l;
 545               while (l->line_number != 0)
 546                 {
 547                   ++total;
 548                   ++q->symbol.section->output_section->lineno_count;
 549                   ++l;
 550                 }
 551             }
 552         }
 553     }
 554
 555   return total;
 556 }
 557
 558 /* Takes a bfd and a symbol, returns a pointer to the coff specific
 559    area of the symbol if there is one.  */
 560
 561 coff_symbol_type *
 562 coff_symbol_from (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                 (bfd_vma)((combined_entry_type *)
 754                           ((unsigned long) s->u.syment.n_value))->offset;
 755               s->fix_value = 0;
 756             }
 757           if (s->fix_line)
 758             {
 759               /* The value is the offset into the line number entries
 760                  for the symbol's section.  On output, the symbol's
 761                  section should be N_DEBUG.  */
 762               s->u.syment.n_value =
 763                 (coff_symbol_ptr->symbol.section->output_section->line_filepos
 764                  + s->u.syment.n_value * bfd_coff_linesz (bfd_ptr));
 765               coff_symbol_ptr->symbol.section =
 766                 coff_section_from_bfd_index (bfd_ptr, N_DEBUG);
 767               BFD_ASSERT (coff_symbol_ptr->symbol.flags & BSF_DEBUGGING);
 768             }
 769           for (i = 0; i < s->u.syment.n_numaux; i++)
 770             {
 771               combined_entry_type *a = s + i + 1;
 772               if (a->fix_tag)
 773                 {
 774                   a->u.auxent.x_sym.x_tagndx.l =
 775                     a->u.auxent.x_sym.x_tagndx.p->offset;
 776                   a->fix_tag = 0;
 777                 }
 778               if (a->fix_end)
 779                 {
 780                   a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l =
 781                     a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p->offset;
 782                   a->fix_end = 0;
 783                 }
 784               if (a->fix_scnlen)
 785                 {
 786                   a->u.auxent.x_csect.x_scnlen.l =
 787                     a->u.auxent.x_csect.x_scnlen.p->offset;
 788                   a->fix_scnlen = 0;
 789                 }
 790             }
 791         }
 792     }
 793 }
 794
 795 static void
 796 coff_fix_symbol_name (abfd, symbol, native, string_size_p,
 797                       debug_string_section_p, debug_string_size_p)
 798      bfd *abfd;
 799      asymbol *symbol;
 800      combined_entry_type *native;
 801      bfd_size_type *string_size_p;
 802      asection **debug_string_section_p;
 803      bfd_size_type *debug_string_size_p;
 804 {
 805   unsigned int name_length;
 806   union internal_auxent *auxent;
 807   char *name = (char *) (symbol->name);
 808
 809   if (name == (char *) NULL)
 810     {
 811       /* coff symbols always have names, so we'll make one up */
 812       symbol->name = "strange";
 813       name = (char *) symbol->name;
 814     }
 815   name_length = strlen (name);
 816
 817   if (native->u.syment.n_sclass == C_FILE
 818       && native->u.syment.n_numaux > 0)
 819     {
 820       unsigned int filnmlen;
 821
 822       if (bfd_coff_force_symnames_in_strings (abfd))
 823         {
 824           native->u.syment._n._n_n._n_offset =
 825               (*string_size_p + STRING_SIZE_SIZE);
 826           native->u.syment._n._n_n._n_zeroes = 0;
 827           *string_size_p += 6;  /* strlen(".file") + 1 */
 828         }
 829       else
 830         strncpy (native->u.syment._n._n_name, ".file", SYMNMLEN);
 831
 832       auxent = &(native + 1)->u.auxent;
 833
 834       filnmlen = bfd_coff_filnmlen (abfd);
 835
 836       if (bfd_coff_long_filenames (abfd))
 837         {
 838           if (name_length <= filnmlen)
 839             {
 840               strncpy (auxent->x_file.x_fname, name, filnmlen);
 841             }
 842           else
 843             {
 844               auxent->x_file.x_n.x_offset = *string_size_p + STRING_SIZE_SIZE;
 845               auxent->x_file.x_n.x_zeroes = 0;
 846               *string_size_p += name_length + 1;
 847             }
 848         }
 849       else
 850         {
 851           strncpy (auxent->x_file.x_fname, name, filnmlen);
 852           if (name_length > filnmlen)
 853             name[filnmlen] = '\0';
 854         }
 855     }
 856   else
 857     {
 858       if (name_length <= SYMNMLEN && !bfd_coff_force_symnames_in_strings (abfd))
 859         {
 860           /* This name will fit into the symbol neatly */
 861           strncpy (native->u.syment._n._n_name, symbol->name, SYMNMLEN);
 862         }
 863       else if (!bfd_coff_symname_in_debug (abfd, &native->u.syment))
 864         {
 865           native->u.syment._n._n_n._n_offset = (*string_size_p
 866                                                 + STRING_SIZE_SIZE);
 867           native->u.syment._n._n_n._n_zeroes = 0;
 868           *string_size_p += name_length + 1;
 869         }
 870       else
 871         {
 872           long filepos;
 873           bfd_byte buf[4];
 874           int prefix_len = bfd_coff_debug_string_prefix_length (abfd);
 875
 876           /* This name should be written into the .debug section.  For
 877              some reason each name is preceded by a two byte length
 878              and also followed by a null byte.  FIXME: We assume that
 879              the .debug section has already been created, and that it
 880              is large enough.  */
 881           if (*debug_string_section_p == (asection *) NULL)
 882             *debug_string_section_p = bfd_get_section_by_name (abfd, ".debug");
 883           filepos = bfd_tell (abfd);
 884           if (prefix_len == 4)
 885             bfd_put_32 (abfd, name_length + 1, buf);
 886           else
 887             bfd_put_16 (abfd, name_length + 1, buf);
 888
 889           if (!bfd_set_section_contents (abfd,
 890                                          *debug_string_section_p,
 891                                          (PTR) buf,
 892                                          (file_ptr) *debug_string_size_p,
 893                                          (bfd_size_type) prefix_len)
 894               || !bfd_set_section_contents (abfd,
 895                                             *debug_string_section_p,
 896                                             (PTR) symbol->name,
 897                                             ((file_ptr) *debug_string_size_p
 898                                              + prefix_len),
 899                                             (bfd_size_type) name_length + 1))
 900             abort ();
 901           if (bfd_seek (abfd, filepos, SEEK_SET) != 0)
 902             abort ();
 903           native->u.syment._n._n_n._n_offset =
 904               *debug_string_size_p + prefix_len;
 905           native->u.syment._n._n_n._n_zeroes = 0;
 906           *debug_string_size_p += name_length + 1 + prefix_len;
 907         }
 908     }
 909 }
 910
 911 /* We need to keep track of the symbol index so that when we write out
 912    the relocs we can get the index for a symbol.  This method is a
 913    hack.  FIXME.  */
 914
 915 #define set_index(symbol, idx)  ((symbol)->udata.i = (idx))
 916
 917 /* Write a symbol out to a COFF file.  */
 918
 919 static boolean
 920 coff_write_symbol (abfd, symbol, native, written, string_size_p,
 921                    debug_string_section_p, debug_string_size_p)
 922      bfd *abfd;
 923      asymbol *symbol;
 924      combined_entry_type *native;
 925      bfd_vma *written;
 926      bfd_size_type *string_size_p;
 927      asection **debug_string_section_p;
 928      bfd_size_type *debug_string_size_p;
 929 {
 930   unsigned int numaux = native->u.syment.n_numaux;
 931   int type = native->u.syment.n_type;
 932   int class = native->u.syment.n_sclass;
 933   PTR buf;
 934   bfd_size_type symesz;
 935
 936   if (native->u.syment.n_sclass == C_FILE)
 937     symbol->flags |= BSF_DEBUGGING;
 938
 939   if (symbol->flags & BSF_DEBUGGING
 940       && bfd_is_abs_section (symbol->section))
 941     {
 942       native->u.syment.n_scnum = N_DEBUG;
 943     }
 944   else if (bfd_is_abs_section (symbol->section))
 945     {
 946       native->u.syment.n_scnum = N_ABS;
 947     }
 948   else if (bfd_is_und_section (symbol->section))
 949     {
 950       native->u.syment.n_scnum = N_UNDEF;
 951     }
 952   else
 953     {
 954       native->u.syment.n_scnum =
 955         symbol->section->output_section->target_index;
 956     }
 957
 958   coff_fix_symbol_name (abfd, symbol, native, string_size_p,
 959                         debug_string_section_p, debug_string_size_p);
 960
 961   symesz = bfd_coff_symesz (abfd);
 962   buf = bfd_alloc (abfd, symesz);
 963   if (!buf)
 964     return false;
 965   bfd_coff_swap_sym_out (abfd, &native->u.syment, buf);
 966   if (bfd_write (buf, 1, symesz, abfd) != symesz)
 967     return false;
 968   bfd_release (abfd, buf);
 969
 970   if (native->u.syment.n_numaux > 0)
 971     {
 972       bfd_size_type auxesz;
 973       unsigned int j;
 974
 975       auxesz = bfd_coff_auxesz (abfd);
 976       buf = bfd_alloc (abfd, auxesz);
 977       if (!buf)
 978         return false;
 979       for (j = 0; j < native->u.syment.n_numaux; j++)
 980         {
 981           bfd_coff_swap_aux_out (abfd,
 982                                  &((native + j + 1)->u.auxent),
 983                                  type,
 984                                  class,
 985                                  j,
 986                                  native->u.syment.n_numaux,
 987                                  buf);
 988           if (bfd_write (buf, 1, auxesz, abfd) != auxesz)
 989             return false;
 990         }
 991       bfd_release (abfd, buf);
 992     }
 993
 994   /* Store the index for use when we write out the relocs.  */
 995   set_index (symbol, *written);
 996
 997   *written += numaux + 1;
 998   return true;
 999 }
1000
1001 /* Write out a symbol to a COFF file that does not come from a COFF
1002    file originally.  This symbol may have been created by the linker,
1003    or we may be linking a non COFF file to a COFF file.  */
1004
1005 static boolean
1006 coff_write_alien_symbol (abfd, symbol, written, string_size_p,
1007                          debug_string_section_p, debug_string_size_p)
1008      bfd *abfd;
1009      asymbol *symbol;
1010      bfd_vma *written;
1011      bfd_size_type *string_size_p;
1012      asection **debug_string_section_p;
1013      bfd_size_type *debug_string_size_p;
1014 {
1015   combined_entry_type *native;
1016   combined_entry_type dummy;
1017
1018   native = &dummy;
1019   native->u.syment.n_type = T_NULL;
1020   native->u.syment.n_flags = 0;
1021   if (bfd_is_und_section (symbol->section))
1022     {
1023       native->u.syment.n_scnum = N_UNDEF;
1024       native->u.syment.n_value = symbol->value;
1025     }
1026   else if (bfd_is_com_section (symbol->section))
1027     {
1028       native->u.syment.n_scnum = N_UNDEF;
1029       native->u.syment.n_value = symbol->value;
1030     }
1031   else if (symbol->flags & BSF_DEBUGGING)
1032     {
1033       /* There isn't much point to writing out a debugging symbol
1034          unless we are prepared to convert it into COFF debugging
1035          format.  So, we just ignore them.  We must clobber the symbol
1036          name to keep it from being put in the string table.  */
1037       symbol->name = "";
1038       return true;
1039     }
1040   else
1041     {
1042       native->u.syment.n_scnum =
1043         symbol->section->output_section->target_index;
1044       native->u.syment.n_value = (symbol->value
1045                                   + symbol->section->output_offset);
1046       if (! obj_pe (abfd))
1047         native->u.syment.n_value += symbol->section->output_section->vma;
1048
1049       /* Copy the any flags from the the file header into the symbol.
1050          FIXME: Why?  */
1051       {
1052         coff_symbol_type *c = coff_symbol_from (abfd, symbol);
1053         if (c != (coff_symbol_type *) NULL)
1054           native->u.syment.n_flags = bfd_asymbol_bfd (&c->symbol)->flags;
1055       }
1056     }
1057
1058   native->u.syment.n_type = 0;
1059   if (symbol->flags & BSF_LOCAL)
1060     native->u.syment.n_sclass = C_STAT;
1061   else if (symbol->flags & BSF_WEAK)
1062     native->u.syment.n_sclass = obj_pe (abfd) ? C_NT_WEAK : C_WEAKEXT;
1063   else
1064     native->u.syment.n_sclass = C_EXT;
1065   native->u.syment.n_numaux = 0;
1066
1067   return coff_write_symbol (abfd, symbol, native, written, string_size_p,
1068                             debug_string_section_p, debug_string_size_p);
1069 }
1070
1071 /* Write a native symbol to a COFF file.  */
1072
1073 static boolean
1074 coff_write_native_symbol (abfd, symbol, written, string_size_p,
1075                           debug_string_section_p, debug_string_size_p)
1076      bfd *abfd;
1077      coff_symbol_type *symbol;
1078      bfd_vma *written;
1079      bfd_size_type *string_size_p;
1080      asection **debug_string_section_p;
1081      bfd_size_type *debug_string_size_p;
1082 {
1083   combined_entry_type *native = symbol->native;
1084   alent *lineno = symbol->lineno;
1085
1086   /* If this symbol has an associated line number, we must store the
1087      symbol index in the line number field.  We also tag the auxent to
1088      point to the right place in the lineno table.  */
1089   if (lineno && !symbol->done_lineno && symbol->symbol.section->owner != NULL)
1090     {
1091       unsigned int count = 0;
1092       lineno[count].u.offset = *written;
1093       if (native->u.syment.n_numaux)
1094         {
1095           union internal_auxent *a = &((native + 1)->u.auxent);
1096
1097           a->x_sym.x_fcnary.x_fcn.x_lnnoptr =
1098             symbol->symbol.section->output_section->moving_line_filepos;
1099         }
1100
1101       /* Count and relocate all other linenumbers.  */
1102       count++;
1103       while (lineno[count].line_number != 0)
1104         {
1105 #if 0
1106           /* 13 april 92. sac
1107              I've been told this, but still need proof:
1108              > The second bug is also in `bfd/coffcode.h'.  This bug
1109              > causes the linker to screw up the pc-relocations for
1110              > all the line numbers in COFF code.  This bug isn't only
1111              > specific to A29K implementations, but affects all
1112              > systems using COFF format binaries.  Note that in COFF
1113              > object files, the line number core offsets output by
1114              > the assembler are relative to the start of each
1115              > procedure, not to the start of the .text section.  This
1116              > patch relocates the line numbers relative to the
1117              > `native->u.syment.n_value' instead of the section
1118              > virtual address.
1119              > modular!olson@cs.arizona.edu (Jon Olson)
1120            */
1121           lineno[count].u.offset += native->u.syment.n_value;
1122 #else
1123           lineno[count].u.offset +=
1124             (symbol->symbol.section->output_section->vma
1125              + symbol->symbol.section->output_offset);
1126 #endif
1127           count++;
1128         }
1129       symbol->done_lineno = true;
1130
1131       symbol->symbol.section->output_section->moving_line_filepos +=
1132         count * bfd_coff_linesz (abfd);
1133     }
1134
1135   return coff_write_symbol (abfd, &(symbol->symbol), native, written,
1136                             string_size_p, debug_string_section_p,
1137                             debug_string_size_p);
1138 }
1139
1140 /* Write out the COFF symbols.  */
1141
1142 boolean
1143 coff_write_symbols (abfd)
1144      bfd *abfd;
1145 {
1146   bfd_size_type string_size;
1147   asection *debug_string_section;
1148   bfd_size_type debug_string_size;
1149   unsigned int i;
1150   unsigned int limit = bfd_get_symcount (abfd);
1151   bfd_signed_vma written = 0;
1152   asymbol **p;
1153
1154   string_size = 0;
1155   debug_string_section = NULL;
1156   debug_string_size = 0;
1157
1158   /* If this target supports long section names, they must be put into
1159      the string table.  This is supported by PE.  This code must
1160      handle section names just as they are handled in
1161      coff_write_object_contents.  */
1162   if (bfd_coff_long_section_names (abfd))
1163     {
1164       asection *o;
1165
1166       for (o = abfd->sections; o != NULL; o = o->next)
1167         {
1168           size_t len;
1169
1170           len = strlen (o->name);
1171           if (len > SCNNMLEN)
1172             string_size += len + 1;
1173         }
1174     }
1175
1176   /* Seek to the right place */
1177   if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0)
1178     return false;
1179
1180   /* Output all the symbols we have */
1181
1182   written = 0;
1183   for (p = abfd->outsymbols, i = 0; i < limit; i++, p++)
1184     {
1185       asymbol *symbol = *p;
1186       coff_symbol_type *c_symbol = coff_symbol_from (abfd, symbol);
1187
1188       if (c_symbol == (coff_symbol_type *) NULL
1189           || c_symbol->native == (combined_entry_type *) NULL)
1190         {
1191           if (!coff_write_alien_symbol (abfd, symbol, &written, &string_size,
1192                                         &debug_string_section,
1193                                         &debug_string_size))
1194             return false;
1195         }
1196       else
1197         {
1198           if (!coff_write_native_symbol (abfd, c_symbol, &written,
1199                                          &string_size, &debug_string_section,
1200                                          &debug_string_size))
1201             return false;
1202         }
1203     }
1204
1205   obj_raw_syment_count (abfd) = written;
1206
1207   /* Now write out strings */
1208
1209   if (string_size != 0)
1210     {
1211       unsigned int size = string_size + STRING_SIZE_SIZE;
1212       bfd_byte buffer[STRING_SIZE_SIZE];
1213
1214 #if STRING_SIZE_SIZE == 4
1215       bfd_h_put_32 (abfd, size, buffer);
1216 #else
1217  #error Change bfd_h_put_32
1218 #endif
1219       if (bfd_write ((PTR) buffer, 1, sizeof (buffer), abfd) != sizeof (buffer))
1220         return false;
1221
1222       /* Handle long section names.  This code must handle section
1223          names just as they are handled in coff_write_object_contents.  */
1224       if (bfd_coff_long_section_names (abfd))
1225         {
1226           asection *o;
1227
1228           for (o = abfd->sections; o != NULL; o = o->next)
1229             {
1230               size_t len;
1231
1232               len = strlen (o->name);
1233               if (len > SCNNMLEN)
1234                 {
1235                   if (bfd_write (o->name, 1, len + 1, abfd) != len + 1)
1236                     return false;
1237                 }
1238             }
1239         }
1240
1241       for (p = abfd->outsymbols, i = 0;
1242            i < limit;
1243            i++, p++)
1244         {
1245           asymbol *q = *p;
1246           size_t name_length = strlen (q->name);
1247           coff_symbol_type *c_symbol = coff_symbol_from (abfd, q);
1248           size_t maxlen;
1249
1250           /* Figure out whether the symbol name should go in the string
1251              table.  Symbol names that are short enough are stored
1252              directly in the syment structure.  File names permit a
1253              different, longer, length in the syment structure.  On
1254              XCOFF, some symbol names are stored in the .debug section
1255              rather than in the string table.  */
1256
1257           if (c_symbol == NULL
1258               || c_symbol->native == NULL)
1259             {
1260               /* This is not a COFF symbol, so it certainly is not a
1261                  file name, nor does it go in the .debug section.  */
1262               maxlen = bfd_coff_force_symnames_in_strings (abfd) ? 0 : SYMNMLEN;
1263             }
1264           else if (bfd_coff_symname_in_debug (abfd,
1265                                               &c_symbol->native->u.syment))
1266             {
1267               /* This symbol name is in the XCOFF .debug section.
1268                  Don't write it into the string table.  */
1269               maxlen = name_length;
1270             }
1271           else if (c_symbol->native->u.syment.n_sclass == C_FILE
1272                    && c_symbol->native->u.syment.n_numaux > 0)
1273             {
1274               if (bfd_coff_force_symnames_in_strings (abfd))
1275                 bfd_write (".file", 1, 6, abfd);
1276               maxlen = bfd_coff_filnmlen (abfd);
1277             }
1278           else
1279             maxlen = bfd_coff_force_symnames_in_strings (abfd) ? 0 : SYMNMLEN;
1280
1281           if (name_length > maxlen)
1282             {
1283               if (bfd_write ((PTR) (q->name), 1, name_length + 1, abfd)
1284                   != name_length + 1)
1285                 return false;
1286             }
1287         }
1288     }
1289   else
1290     {
1291       /* We would normally not write anything here, but we'll write
1292          out 4 so that any stupid coff reader which tries to read the
1293          string table even when there isn't one won't croak.  */
1294       unsigned int size = STRING_SIZE_SIZE;
1295       bfd_byte buffer[STRING_SIZE_SIZE];
1296
1297 #if STRING_SIZE_SIZE == 4
1298       bfd_h_put_32 (abfd, size, buffer);
1299 #else
1300  #error Change bfd_h_put_32
1301 #endif
1302       if (bfd_write ((PTR) buffer, 1, STRING_SIZE_SIZE, abfd)
1303           != STRING_SIZE_SIZE)
1304         return false;
1305     }
1306
1307   /* Make sure the .debug section was created to be the correct size.
1308      We should create it ourselves on the fly, but we don't because
1309      BFD won't let us write to any section until we know how large all
1310      the sections are.  We could still do it by making another pass
1311      over the symbols.  FIXME.  */
1312   BFD_ASSERT (debug_string_size == 0
1313               || (debug_string_section != (asection *) NULL
1314                   && (BFD_ALIGN (debug_string_size,
1315                                  1 << debug_string_section->alignment_power)
1316                       == bfd_section_size (abfd, debug_string_section))));
1317
1318   return true;
1319 }
1320
1321 boolean
1322 coff_write_linenumbers (abfd)
1323      bfd *abfd;
1324 {
1325   asection *s;
1326   bfd_size_type linesz;
1327   PTR buff;
1328
1329   linesz = bfd_coff_linesz (abfd);
1330   buff = bfd_alloc (abfd, linesz);
1331   if (!buff)
1332     return false;
1333   for (s = abfd->sections; s != (asection *) NULL; s = s->next)
1334     {
1335       if (s->lineno_count)
1336         {
1337           asymbol **q = abfd->outsymbols;
1338           if (bfd_seek (abfd, s->line_filepos, SEEK_SET) != 0)
1339             return false;
1340           /* Find all the linenumbers in this section */
1341           while (*q)
1342             {
1343               asymbol *p = *q;
1344               if (p->section->output_section == s)
1345                 {
1346                   alent *l =
1347                   BFD_SEND (bfd_asymbol_bfd (p), _get_lineno,
1348                             (bfd_asymbol_bfd (p), p));
1349                   if (l)
1350                     {
1351                       /* Found a linenumber entry, output */
1352                       struct internal_lineno out;
1353                       memset ((PTR) & out, 0, sizeof (out));
1354                       out.l_lnno = 0;
1355                       out.l_addr.l_symndx = l->u.offset;
1356                       bfd_coff_swap_lineno_out (abfd, &out, buff);
1357                       if (bfd_write (buff, 1, linesz, abfd) != linesz)
1358                         return false;
1359                       l++;
1360                       while (l->line_number)
1361                         {
1362                           out.l_lnno = l->line_number;
1363                           out.l_addr.l_symndx = l->u.offset;
1364                           bfd_coff_swap_lineno_out (abfd, &out, buff);
1365                           if (bfd_write (buff, 1, linesz, abfd) != linesz)
1366                             return false;
1367                           l++;
1368                         }
1369                     }
1370                 }
1371               q++;
1372             }
1373         }
1374     }
1375   bfd_release (abfd, buff);
1376   return true;
1377 }
1378
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 void
1912 coff_get_symbol_info (abfd, symbol, ret)
1913      bfd *abfd;
1914      asymbol *symbol;
1915      symbol_info *ret;
1916 {
1917   bfd_symbol_info (symbol, ret);
1918   if (coffsymbol (symbol)->native != NULL
1919       && coffsymbol (symbol)->native->fix_value)
1920     {
1921       ret->value = coffsymbol (symbol)->native->u.syment.n_value -
1922         (unsigned long) obj_raw_syments (abfd);
1923     }
1924 }
1925
1926 /* Return the COFF syment for a symbol.  */
1927
1928 boolean
1929 bfd_coff_get_syment (abfd, symbol, psyment)
1930      bfd *abfd;
1931      asymbol *symbol;
1932      struct internal_syment *psyment;
1933 {
1934   coff_symbol_type *csym;
1935
1936   csym = coff_symbol_from (abfd, symbol);
1937   if (csym == NULL || csym->native == NULL)
1938     {
1939       bfd_set_error (bfd_error_invalid_operation);
1940       return false;
1941     }
1942
1943   *psyment = csym->native->u.syment;
1944
1945   if (csym->native->fix_value)
1946     psyment->n_value = psyment->n_value -
1947       (unsigned long) obj_raw_syments (abfd);
1948
1949   /* FIXME: We should handle fix_line here.  */
1950
1951   return true;
1952 }
1953
1954 /* Return the COFF auxent for a symbol.  */
1955
1956 boolean
1957 bfd_coff_get_auxent (abfd, symbol, indx, pauxent)
1958      bfd *abfd;
1959      asymbol *symbol;
1960      int indx;
1961      union internal_auxent *pauxent;
1962 {
1963   coff_symbol_type *csym;
1964   combined_entry_type *ent;
1965
1966   csym = coff_symbol_from (abfd, symbol);
1967
1968   if (csym == NULL
1969       || csym->native == NULL
1970       || indx >= csym->native->u.syment.n_numaux)
1971     {
1972       bfd_set_error (bfd_error_invalid_operation);
1973       return false;
1974     }
1975
1976   ent = csym->native + indx + 1;
1977
1978   *pauxent = ent->u.auxent;
1979
1980   if (ent->fix_tag)
1981     pauxent->x_sym.x_tagndx.l =
1982       ((combined_entry_type *) pauxent->x_sym.x_tagndx.p
1983        - obj_raw_syments (abfd));
1984
1985   if (ent->fix_end)
1986     pauxent->x_sym.x_fcnary.x_fcn.x_endndx.l =
1987       ((combined_entry_type *) pauxent->x_sym.x_fcnary.x_fcn.x_endndx.p
1988        - obj_raw_syments (abfd));
1989
1990   if (ent->fix_scnlen)
1991     pauxent->x_csect.x_scnlen.l =
1992       ((combined_entry_type *) pauxent->x_csect.x_scnlen.p
1993        - obj_raw_syments (abfd));
1994
1995   return true;
1996 }
1997
1998 /* Print out information about COFF symbol.  */
1999
2000 void
2001 coff_print_symbol (abfd, filep, symbol, how)
2002      bfd *abfd;
2003      PTR filep;
2004      asymbol *symbol;
2005      bfd_print_symbol_type how;
2006 {
2007   FILE *file = (FILE *) filep;
2008
2009   switch (how)
2010     {
2011     case bfd_print_symbol_name:
2012       fprintf (file, "%s", symbol->name);
2013       break;
2014
2015     case bfd_print_symbol_more:
2016       fprintf (file, "coff %s %s",
2017                coffsymbol (symbol)->native ? "n" : "g",
2018                coffsymbol (symbol)->lineno ? "l" : " ");
2019       break;
2020
2021     case bfd_print_symbol_all:
2022       if (coffsymbol (symbol)->native)
2023         {
2024           bfd_vma val;
2025           unsigned int aux;
2026           combined_entry_type *combined = coffsymbol (symbol)->native;
2027           combined_entry_type *root = obj_raw_syments (abfd);
2028           struct lineno_cache_entry *l = coffsymbol (symbol)->lineno;
2029
2030           fprintf (file, "[%3ld]", (long) (combined - root));
2031
2032           if (! combined->fix_value)
2033             val = (bfd_vma) combined->u.syment.n_value;
2034           else
2035             val = combined->u.syment.n_value - (unsigned long) root;
2036
2037 #ifndef XCOFF64
2038           fprintf (file,
2039                    "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x%08lx %s",
2040                    combined->u.syment.n_scnum,
2041                    combined->u.syment.n_flags,
2042                    combined->u.syment.n_type,
2043                    combined->u.syment.n_sclass,
2044                    combined->u.syment.n_numaux,
2045                    (unsigned long) val,
2046                    symbol->name);
2047 #else
2048           /* Print out the wide, 64 bit, symbol value */
2049           fprintf (file,
2050                    "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x%016llx %s",
2051                    combined->u.syment.n_scnum,
2052                    combined->u.syment.n_flags,
2053                    combined->u.syment.n_type,
2054                    combined->u.syment.n_sclass,
2055                    combined->u.syment.n_numaux,
2056                    val,
2057                    symbol->name);
2058 #endif
2059
2060           for (aux = 0; aux < combined->u.syment.n_numaux; aux++)
2061             {
2062               combined_entry_type *auxp = combined + aux + 1;
2063               long tagndx;
2064
2065               if (auxp->fix_tag)
2066                 tagndx = auxp->u.auxent.x_sym.x_tagndx.p - root;
2067               else
2068                 tagndx = auxp->u.auxent.x_sym.x_tagndx.l;
2069
2070               fprintf (file, "\n");
2071
2072               if (bfd_coff_print_aux (abfd, file, root, combined, auxp, aux))
2073                 continue;
2074
2075               switch (combined->u.syment.n_sclass)
2076                 {
2077                 case C_FILE:
2078                   fprintf (file, "File ");
2079                   break;
2080
2081                 case C_STAT:
2082                   if (combined->u.syment.n_type == T_NULL)
2083                     /* probably a section symbol? */
2084                     {
2085                       fprintf (file, "AUX scnlen 0x%lx nreloc %d nlnno %d",
2086                                (long) auxp->u.auxent.x_scn.x_scnlen,
2087                                auxp->u.auxent.x_scn.x_nreloc,
2088                                auxp->u.auxent.x_scn.x_nlinno);
2089                       if (auxp->u.auxent.x_scn.x_checksum != 0
2090                           || auxp->u.auxent.x_scn.x_associated != 0
2091                           || auxp->u.auxent.x_scn.x_comdat != 0)
2092                         fprintf (file, " checksum 0x%lx assoc %d comdat %d",
2093                                  auxp->u.auxent.x_scn.x_checksum,
2094                                  auxp->u.auxent.x_scn.x_associated,
2095                                  auxp->u.auxent.x_scn.x_comdat);
2096                       break;
2097                     }
2098                     /* else fall through */
2099                 case C_EXT:
2100                   if (ISFCN (combined->u.syment.n_type))
2101                     {
2102                       fprintf (file,
2103                                _("AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld"),
2104                                tagndx,
2105                                auxp->u.auxent.x_sym.x_misc.x_fsize,
2106                                auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_lnnoptr,
2107                                (auxp->fix_end
2108                                 ? ((long)
2109                                    (auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p
2110                                     - root))
2111                                 : auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l));
2112                       break;
2113                     }
2114                   /* else fall through */
2115                 default:
2116                   fprintf (file, "AUX lnno %d size 0x%x tagndx %ld",
2117                            auxp->u.auxent.x_sym.x_misc.x_lnsz.x_lnno,
2118                            auxp->u.auxent.x_sym.x_misc.x_lnsz.x_size,
2119                            tagndx);
2120                   if (auxp->fix_end)
2121                     fprintf (file, " endndx %ld",
2122                              ((long)
2123                               (auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p
2124                                - root)));
2125                   break;
2126                 }
2127             }
2128
2129           if (l)
2130             {
2131               fprintf (file, "\n%s :", l->u.sym->name);
2132               l++;
2133               while (l->line_number)
2134                 {
2135                   fprintf (file, "\n%4d : 0x%lx",
2136                            l->line_number,
2137                            ((unsigned long)
2138                             (l->u.offset + symbol->section->vma)));
2139                   l++;
2140                 }
2141             }
2142         }
2143       else
2144         {
2145           bfd_print_symbol_vandf ((PTR) file, symbol);
2146           fprintf (file, " %-5s %s %s %s",
2147                    symbol->section->name,
2148                    coffsymbol (symbol)->native ? "n" : "g",
2149                    coffsymbol (symbol)->lineno ? "l" : " ",
2150                    symbol->name);
2151         }
2152     }
2153 }
2154
2155 /* Return whether a symbol name implies a local symbol.  In COFF,
2156    local symbols generally start with ``.L''.  Most targets use this
2157    function for the is_local_label_name entry point, but some may
2158    override it.  */
2159
2160 boolean
2161 _bfd_coff_is_local_label_name (abfd, name)
2162      bfd *abfd ATTRIBUTE_UNUSED;
2163      const char *name;
2164 {
2165   return name[0] == '.' && name[1] == 'L';
2166 }
2167
2168 /* Provided a BFD, a section and an offset (in bytes, not octets) into the
2169    section, calculate and return the name of the source file and the line
2170    nearest to the wanted location.  */
2171
2172 boolean
2173 coff_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
2174                         functionname_ptr, line_ptr)
2175      bfd *abfd;
2176      asection *section;
2177      asymbol **symbols;
2178      bfd_vma offset;
2179      CONST char **filename_ptr;
2180      CONST char **functionname_ptr;
2181      unsigned int *line_ptr;
2182 {
2183   boolean found;
2184   unsigned int i;
2185   unsigned int line_base;
2186   coff_data_type *cof = coff_data (abfd);
2187   /* Run through the raw syments if available */
2188   combined_entry_type *p;
2189   combined_entry_type *pend;
2190   alent *l;
2191   struct coff_section_tdata *sec_data;
2192
2193   /* Before looking through the symbol table, try to use a .stab
2194      section to find the information.  */
2195   if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
2196                                              &found, filename_ptr,
2197                                              functionname_ptr, line_ptr,
2198                                              &coff_data(abfd)->line_info))
2199     return false;
2200
2201   if (found)
2202     return true;
2203
2204   /* Also try examining DWARF2 debugging information.  */
2205   if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
2206                                      filename_ptr, functionname_ptr,
2207                                      line_ptr, 0,
2208                                      &coff_data(abfd)->dwarf2_find_line_info))
2209     return true;
2210
2211   *filename_ptr = 0;
2212   *functionname_ptr = 0;
2213   *line_ptr = 0;
2214
2215   /* Don't try and find line numbers in a non coff file */
2216   if (!bfd_family_coff (abfd))
2217     return false;
2218
2219   if (cof == NULL)
2220     return false;
2221
2222   /* Find the first C_FILE symbol.  */
2223   p = cof->raw_syments;
2224   if (!p)
2225     return false;
2226
2227   pend = p + cof->raw_syment_count;
2228   while (p < pend)
2229     {
2230       if (p->u.syment.n_sclass == C_FILE)
2231         break;
2232       p += 1 + p->u.syment.n_numaux;
2233     }
2234
2235   if (p < pend)
2236     {
2237       bfd_vma sec_vma;
2238       bfd_vma maxdiff;
2239
2240       /* Look through the C_FILE symbols to find the best one.  */
2241       sec_vma = bfd_get_section_vma (abfd, section);
2242       *filename_ptr = (char *) p->u.syment._n._n_n._n_offset;
2243       maxdiff = (bfd_vma) 0 - (bfd_vma) 1;
2244       while (1)
2245         {
2246           combined_entry_type *p2;
2247
2248           for (p2 = p + 1 + p->u.syment.n_numaux;
2249                p2 < pend;
2250                p2 += 1 + p2->u.syment.n_numaux)
2251             {
2252               if (p2->u.syment.n_scnum > 0
2253                   && (section
2254                       == coff_section_from_bfd_index (abfd,
2255                                                       p2->u.syment.n_scnum)))
2256                 break;
2257               if (p2->u.syment.n_sclass == C_FILE)
2258                 {
2259                   p2 = pend;
2260                   break;
2261                 }
2262             }
2263
2264           /* We use <= MAXDIFF here so that if we get a zero length
2265              file, we actually use the next file entry.  */
2266           if (p2 < pend
2267               && offset + sec_vma >= (bfd_vma) p2->u.syment.n_value
2268               && offset + sec_vma - (bfd_vma) p2->u.syment.n_value <= maxdiff)
2269             {
2270               *filename_ptr = (char *) p->u.syment._n._n_n._n_offset;
2271               maxdiff = offset + sec_vma - p2->u.syment.n_value;
2272             }
2273
2274           /* Avoid endless loops on erroneous files by ensuring that
2275              we always move forward in the file.  */
2276           if (p - cof->raw_syments >= p->u.syment.n_value)
2277             break;
2278
2279           p = cof->raw_syments + p->u.syment.n_value;
2280           if (p > pend || p->u.syment.n_sclass != C_FILE)
2281             break;
2282         }
2283     }
2284
2285   /* Now wander though the raw linenumbers of the section */
2286   /* If we have been called on this section before, and the offset we
2287      want is further down then we can prime the lookup loop.  */
2288   sec_data = coff_section_data (abfd, section);
2289   if (sec_data != NULL
2290       && sec_data->i > 0
2291       && offset >= sec_data->offset)
2292     {
2293       i = sec_data->i;
2294       *functionname_ptr = sec_data->function;
2295       line_base = sec_data->line_base;
2296     }
2297   else
2298     {
2299       i = 0;
2300       line_base = 0;
2301     }
2302
2303   if (section->lineno != NULL)
2304     {
2305       bfd_vma last_value = 0;
2306
2307       l = &section->lineno[i];
2308
2309       for (; i < section->lineno_count; i++)
2310         {
2311           if (l->line_number == 0)
2312             {
2313               /* Get the symbol this line number points at */
2314               coff_symbol_type *coff = (coff_symbol_type *) (l->u.sym);
2315               if (coff->symbol.value > offset)
2316                 break;
2317               *functionname_ptr = coff->symbol.name;
2318               last_value = coff->symbol.value;
2319               if (coff->native)
2320                 {
2321                   combined_entry_type *s = coff->native;
2322                   s = s + 1 + s->u.syment.n_numaux;
2323
2324                   /* In XCOFF a debugging symbol can follow the
2325                      function symbol.  */
2326                   if (s->u.syment.n_scnum == N_DEBUG)
2327                     s = s + 1 + s->u.syment.n_numaux;
2328
2329                   /* S should now point to the .bf of the function.  */
2330                   if (s->u.syment.n_numaux)
2331                     {
2332                       /* The linenumber is stored in the auxent.  */
2333                       union internal_auxent *a = &((s + 1)->u.auxent);
2334                       line_base = a->x_sym.x_misc.x_lnsz.x_lnno;
2335                       *line_ptr = line_base;
2336                     }
2337                 }
2338             }
2339           else
2340             {
2341               if (l->u.offset > offset)
2342                 break;
2343               *line_ptr = l->line_number + line_base - 1;
2344             }
2345           l++;
2346         }
2347
2348       /* If we fell off the end of the loop, then assume that this
2349          symbol has no line number info.  Otherwise, symbols with no
2350          line number info get reported with the line number of the
2351          last line of the last symbol which does have line number
2352          info.  We use 0x100 as a slop to account for cases where the
2353          last line has executable code.  */
2354       if (i >= section->lineno_count
2355           && last_value != 0
2356           && offset - last_value > 0x100)
2357         {
2358           *functionname_ptr = NULL;
2359           *line_ptr = 0;
2360         }
2361     }
2362
2363   /* Cache the results for the next call.  */
2364   if (sec_data == NULL && section->owner == abfd)
2365     {
2366       section->used_by_bfd =
2367         ((PTR) bfd_zalloc (abfd,
2368                            sizeof (struct coff_section_tdata)));
2369       sec_data = (struct coff_section_tdata *) section->used_by_bfd;
2370     }
2371   if (sec_data != NULL)
2372     {
2373       sec_data->offset = offset;
2374       sec_data->i = i;
2375       sec_data->function = *functionname_ptr;
2376       sec_data->line_base = line_base;
2377     }
2378
2379   return true;
2380 }
2381
2382 int
2383 coff_sizeof_headers (abfd, reloc)
2384      bfd *abfd;
2385      boolean reloc;
2386 {
2387   size_t size;
2388
2389   if (reloc == false)
2390     {
2391       size = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
2392     }
2393   else
2394     {
2395       size = bfd_coff_filhsz (abfd);
2396     }
2397
2398   size += abfd->section_count * bfd_coff_scnhsz (abfd);
2399   return size;
2400 }
2401
2402 /* Change the class of a coff symbol held by BFD.  */
2403 boolean
2404 bfd_coff_set_symbol_class (abfd, symbol, class)
2405      bfd *         abfd;
2406      asymbol *     symbol;
2407      unsigned int  class;
2408 {
2409   coff_symbol_type * csym;
2410
2411   csym = coff_symbol_from (abfd, symbol);
2412   if (csym == NULL)
2413     {
2414       bfd_set_error (bfd_error_invalid_operation);
2415       return false;
2416     }
2417   else if (csym->native == NULL)
2418     {
2419       /* This is an alien symbol which no native coff backend data.
2420          We cheat here by creating a fake native entry for it and
2421          then filling in the class.  This code is based on that in
2422          coff_write_alien_symbol().  */
2423
2424       combined_entry_type * native;
2425
2426       native = (combined_entry_type *) bfd_alloc (abfd, sizeof (* native));
2427       if (native == NULL)
2428         return false;
2429
2430       memset (native, 0, sizeof (* native));
2431
2432       native->u.syment.n_type   = T_NULL;
2433       native->u.syment.n_sclass = class;
2434
2435       if (bfd_is_und_section (symbol->section))
2436         {
2437           native->u.syment.n_scnum = N_UNDEF;
2438           native->u.syment.n_value = symbol->value;
2439         }
2440       else if (bfd_is_com_section (symbol->section))
2441         {
2442           native->u.syment.n_scnum = N_UNDEF;
2443           native->u.syment.n_value = symbol->value;
2444         }
2445       else
2446         {
2447           native->u.syment.n_scnum =
2448             symbol->section->output_section->target_index;
2449           native->u.syment.n_value = (symbol->value
2450                                       + symbol->section->output_offset);
2451           if (! obj_pe (abfd))
2452             native->u.syment.n_value += symbol->section->output_section->vma;
2453
2454           /* Copy the any flags from the the file header into the symbol.
2455              FIXME: Why?  */
2456           native->u.syment.n_flags = bfd_asymbol_bfd (& csym->symbol)->flags;
2457         }
2458
2459       csym->native = native;
2460     }
2461   else
2462     {
2463       csym->native->u.syment.n_sclass = class;
2464     }
2465
2466   return true;
2467 }