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 coff_symbol_type *
 561 coff_symbol_from (ignore_abfd, symbol)
 562      bfd *ignore_abfd ATTRIBUTE_UNUSED;
 563      asymbol *symbol;
 564 {
 565   if (!bfd_family_coff (bfd_asymbol_bfd (symbol)))
 566     return (coff_symbol_type *) NULL;
 567
 568   if (bfd_asymbol_bfd (symbol)->tdata.coff_obj_data == (coff_data_type *) NULL)
 569     return (coff_symbol_type *) NULL;
 570
 571   return (coff_symbol_type *) symbol;
 572 }
 573
 574 static void
 575 fixup_symbol_value (abfd, coff_symbol_ptr, syment)
 576      bfd *abfd;
 577      coff_symbol_type *coff_symbol_ptr;
 578      struct internal_syment *syment;
 579 {
 580
 581   /* Normalize the symbol flags */
 582   if (bfd_is_com_section (coff_symbol_ptr->symbol.section))
 583     {
 584       /* a common symbol is undefined with a value */
 585       syment->n_scnum = N_UNDEF;
 586       syment->n_value = coff_symbol_ptr->symbol.value;
 587     }
 588   else if ((coff_symbol_ptr->symbol.flags & BSF_DEBUGGING) != 0
 589            && (coff_symbol_ptr->symbol.flags & BSF_DEBUGGING_RELOC) == 0)
 590     {
 591       syment->n_value = coff_symbol_ptr->symbol.value;
 592     }
 593   else if (bfd_is_und_section (coff_symbol_ptr->symbol.section))
 594     {
 595       syment->n_scnum = N_UNDEF;
 596       syment->n_value = 0;
 597     }
 598   /* FIXME: Do we need to handle the absolute section here?  */
 599   else
 600     {
 601       if (coff_symbol_ptr->symbol.section)
 602         {
 603           syment->n_scnum =
 604             coff_symbol_ptr->symbol.section->output_section->target_index;
 605
 606           syment->n_value = (coff_symbol_ptr->symbol.value
 607                              + coff_symbol_ptr->symbol.section->output_offset);
 608           if (! obj_pe (abfd))
 609             {
 610               syment->n_value += (syment->n_sclass == C_STATLAB)
 611                 ? coff_symbol_ptr->symbol.section->output_section->lma
 612                 : coff_symbol_ptr->symbol.section->output_section->vma;
 613             }
 614         }
 615       else
 616         {
 617           BFD_ASSERT (0);
 618           /* This can happen, but I don't know why yet (steve@cygnus.com) */
 619           syment->n_scnum = N_ABS;
 620           syment->n_value = coff_symbol_ptr->symbol.value;
 621         }
 622     }
 623 }
 624
 625 /* Run through all the symbols in the symbol table and work out what
 626    their indexes into the symbol table will be when output.
 627
 628    Coff requires that each C_FILE symbol points to the next one in the
 629    chain, and that the last one points to the first external symbol. We
 630    do that here too.  */
 631
 632 boolean
 633 coff_renumber_symbols (bfd_ptr, first_undef)
 634      bfd *bfd_ptr;
 635      int *first_undef;
 636 {
 637   unsigned int symbol_count = bfd_get_symcount (bfd_ptr);
 638   asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;
 639   unsigned int native_index = 0;
 640   struct internal_syment *last_file = (struct internal_syment *) NULL;
 641   unsigned int symbol_index;
 642
 643   /* COFF demands that undefined symbols come after all other symbols.
 644      Since we don't need to impose this extra knowledge on all our
 645      client programs, deal with that here.  Sort the symbol table;
 646      just move the undefined symbols to the end, leaving the rest
 647      alone.  The O'Reilly book says that defined global symbols come
 648      at the end before the undefined symbols, so we do that here as
 649      well.  */
 650   /* @@ Do we have some condition we could test for, so we don't always
 651      have to do this?  I don't think relocatability is quite right, but
 652      I'm not certain.  [raeburn:19920508.1711EST]  */
 653   {
 654     asymbol **newsyms;
 655     unsigned int i;
 656
 657     newsyms = (asymbol **) bfd_alloc (bfd_ptr,
 658                                       sizeof (asymbol *) * (symbol_count + 1));
 659     if (!newsyms)
 660       return false;
 661     bfd_ptr->outsymbols = newsyms;
 662     for (i = 0; i < symbol_count; i++)
 663       if ((symbol_ptr_ptr[i]->flags & BSF_NOT_AT_END) != 0
 664           || (!bfd_is_und_section (symbol_ptr_ptr[i]->section)
 665               && !bfd_is_com_section (symbol_ptr_ptr[i]->section)
 666               && ((symbol_ptr_ptr[i]->flags & BSF_FUNCTION) != 0
 667                   || ((symbol_ptr_ptr[i]->flags & (BSF_GLOBAL | BSF_WEAK))
 668                       == 0))))
 669         *newsyms++ = symbol_ptr_ptr[i];
 670
 671     for (i = 0; i < symbol_count; i++)
 672       if ((symbol_ptr_ptr[i]->flags & BSF_NOT_AT_END) == 0
 673           && !bfd_is_und_section (symbol_ptr_ptr[i]->section)
 674           && (bfd_is_com_section (symbol_ptr_ptr[i]->section)
 675               || ((symbol_ptr_ptr[i]->flags & BSF_FUNCTION) == 0
 676                   && ((symbol_ptr_ptr[i]->flags & (BSF_GLOBAL | BSF_WEAK))
 677                       != 0))))
 678         *newsyms++ = symbol_ptr_ptr[i];
 679
 680     *first_undef = newsyms - bfd_ptr->outsymbols;
 681
 682     for (i = 0; i < symbol_count; i++)
 683       if ((symbol_ptr_ptr[i]->flags & BSF_NOT_AT_END) == 0
 684           && bfd_is_und_section (symbol_ptr_ptr[i]->section))
 685         *newsyms++ = symbol_ptr_ptr[i];
 686     *newsyms = (asymbol *) NULL;
 687     symbol_ptr_ptr = bfd_ptr->outsymbols;
 688   }
 689
 690   for (symbol_index = 0; symbol_index < symbol_count; symbol_index++)
 691     {
 692       coff_symbol_type *coff_symbol_ptr = coff_symbol_from (bfd_ptr, symbol_ptr_ptr[symbol_index]);
 693       symbol_ptr_ptr[symbol_index]->udata.i = symbol_index;
 694       if (coff_symbol_ptr && coff_symbol_ptr->native)
 695         {
 696           combined_entry_type *s = coff_symbol_ptr->native;
 697           int i;
 698
 699           if (s->u.syment.n_sclass == C_FILE)
 700             {
 701               if (last_file != (struct internal_syment *) NULL)
 702                 last_file->n_value = native_index;
 703               last_file = &(s->u.syment);
 704             }
 705           else
 706             {
 707
 708               /* Modify the symbol values according to their section and
 709                  type */
 710
 711               fixup_symbol_value (bfd_ptr, coff_symbol_ptr, &(s->u.syment));
 712             }
 713           for (i = 0; i < s->u.syment.n_numaux + 1; i++)
 714             s[i].offset = native_index++;
 715         }
 716       else
 717         {
 718           native_index++;
 719         }
 720     }
 721   obj_conv_table_size (bfd_ptr) = native_index;
 722
 723   return true;
 724 }
 725
 726 /* Run thorough the symbol table again, and fix it so that all
 727    pointers to entries are changed to the entries' index in the output
 728    symbol table.  */
 729
 730 void
 731 coff_mangle_symbols (bfd_ptr)
 732      bfd *bfd_ptr;
 733 {
 734   unsigned int symbol_count = bfd_get_symcount (bfd_ptr);
 735   asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;
 736   unsigned int symbol_index;
 737
 738   for (symbol_index = 0; symbol_index < symbol_count; symbol_index++)
 739     {
 740       coff_symbol_type *coff_symbol_ptr =
 741       coff_symbol_from (bfd_ptr, symbol_ptr_ptr[symbol_index]);
 742
 743       if (coff_symbol_ptr && coff_symbol_ptr->native)
 744         {
 745           int i;
 746           combined_entry_type *s = coff_symbol_ptr->native;
 747
 748           if (s->fix_value)
 749             {
 750               /* FIXME: We should use a union here.  */
 751               s->u.syment.n_value =
 752                 ((combined_entry_type *) s->u.syment.n_value)->offset;
 753               s->fix_value = 0;
 754             }
 755           if (s->fix_line)
 756             {
 757               /* The value is the offset into the line number entries
 758                  for the symbol's section.  On output, the symbol's
 759                  section should be N_DEBUG.  */
 760               s->u.syment.n_value =
 761                 (coff_symbol_ptr->symbol.section->output_section->line_filepos
 762                  + s->u.syment.n_value * bfd_coff_linesz (bfd_ptr));
 763               coff_symbol_ptr->symbol.section =
 764                 coff_section_from_bfd_index (bfd_ptr, N_DEBUG);
 765               BFD_ASSERT (coff_symbol_ptr->symbol.flags & BSF_DEBUGGING);
 766             }
 767           for (i = 0; i < s->u.syment.n_numaux; i++)
 768             {
 769               combined_entry_type *a = s + i + 1;
 770               if (a->fix_tag)
 771                 {
 772                   a->u.auxent.x_sym.x_tagndx.l =
 773                     a->u.auxent.x_sym.x_tagndx.p->offset;
 774                   a->fix_tag = 0;
 775                 }
 776               if (a->fix_end)
 777                 {
 778                   a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l =
 779                     a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p->offset;
 780                   a->fix_end = 0;
 781                 }
 782               if (a->fix_scnlen)
 783                 {
 784                   a->u.auxent.x_csect.x_scnlen.l =
 785                     a->u.auxent.x_csect.x_scnlen.p->offset;
 786                   a->fix_scnlen = 0;
 787                 }
 788             }
 789         }
 790     }
 791 }
 792
 793 static void
 794 coff_fix_symbol_name (abfd, symbol, native, string_size_p,
 795                       debug_string_section_p, debug_string_size_p)
 796      bfd *abfd;
 797      asymbol *symbol;
 798      combined_entry_type *native;
 799      bfd_size_type *string_size_p;
 800      asection **debug_string_section_p;
 801      bfd_size_type *debug_string_size_p;
 802 {
 803   unsigned int name_length;
 804   union internal_auxent *auxent;
 805   char *name = (char *) (symbol->name);
 806
 807   if (name == (char *) NULL)
 808     {
 809       /* coff symbols always have names, so we'll make one up */
 810       symbol->name = "strange";
 811       name = (char *) symbol->name;
 812     }
 813   name_length = strlen (name);
 814
 815   if (native->u.syment.n_sclass == C_FILE
 816       && native->u.syment.n_numaux > 0)
 817     {
 818       unsigned int filnmlen;
 819
 820       if (bfd_coff_force_symnames_in_strings (abfd))
 821         {
 822           native->u.syment._n._n_n._n_offset =
 823               (*string_size_p + STRING_SIZE_SIZE);
 824           native->u.syment._n._n_n._n_zeroes = 0;
 825           *string_size_p += 6;  /* strlen(".file") + 1 */
 826         }
 827       else
 828         strncpy (native->u.syment._n._n_name, ".file", SYMNMLEN);
 829
 830       auxent = &(native + 1)->u.auxent;
 831
 832       filnmlen = bfd_coff_filnmlen (abfd);
 833
 834       if (bfd_coff_long_filenames (abfd))
 835         {
 836           if (name_length <= filnmlen)
 837             {
 838               strncpy (auxent->x_file.x_fname, name, filnmlen);
 839             }
 840           else
 841             {
 842               auxent->x_file.x_n.x_offset = *string_size_p + STRING_SIZE_SIZE;
 843               auxent->x_file.x_n.x_zeroes = 0;
 844               *string_size_p += name_length + 1;
 845             }
 846         }
 847       else
 848         {
 849           strncpy (auxent->x_file.x_fname, name, filnmlen);
 850           if (name_length > filnmlen)
 851             name[filnmlen] = '\0';
 852         }
 853     }
 854   else
 855     {
 856       if (name_length <= SYMNMLEN && !bfd_coff_force_symnames_in_strings (abfd))
 857         {
 858           /* This name will fit into the symbol neatly */
 859           strncpy (native->u.syment._n._n_name, symbol->name, SYMNMLEN);
 860         }
 861       else if (!bfd_coff_symname_in_debug (abfd, &native->u.syment))
 862         {
 863           native->u.syment._n._n_n._n_offset = (*string_size_p
 864                                                 + STRING_SIZE_SIZE);
 865           native->u.syment._n._n_n._n_zeroes = 0;
 866           *string_size_p += name_length + 1;
 867         }
 868       else
 869         {
 870           long filepos;
 871           bfd_byte buf[4];
 872           int prefix_len = bfd_coff_debug_string_prefix_length (abfd);
 873
 874           /* This name should be written into the .debug section.  For
 875              some reason each name is preceded by a two byte length
 876              and also followed by a null byte.  FIXME: We assume that
 877              the .debug section has already been created, and that it
 878              is large enough.  */
 879           if (*debug_string_section_p == (asection *) NULL)
 880             *debug_string_section_p = bfd_get_section_by_name (abfd, ".debug");
 881           filepos = bfd_tell (abfd);
 882           if (prefix_len == 4)
 883             bfd_put_32 (abfd, name_length + 1, buf);
 884           else
 885             bfd_put_16 (abfd, name_length + 1, buf);
 886
 887           if (!bfd_set_section_contents (abfd,
 888                                          *debug_string_section_p,
 889                                          (PTR) buf,
 890                                          (file_ptr) *debug_string_size_p,
 891                                          (bfd_size_type) prefix_len)
 892               || !bfd_set_section_contents (abfd,
 893                                             *debug_string_section_p,
 894                                             (PTR) symbol->name,
 895                                             ((file_ptr) *debug_string_size_p
 896                                              + prefix_len),
 897                                             (bfd_size_type) name_length + 1))
 898             abort ();
 899           if (bfd_seek (abfd, filepos, SEEK_SET) != 0)
 900             abort ();
 901           native->u.syment._n._n_n._n_offset =
 902               *debug_string_size_p + prefix_len;
 903           native->u.syment._n._n_n._n_zeroes = 0;
 904           *debug_string_size_p += name_length + 1 + prefix_len;
 905         }
 906     }
 907 }
 908
 909 /* We need to keep track of the symbol index so that when we write out
 910    the relocs we can get the index for a symbol.  This method is a
 911    hack.  FIXME.  */
 912
 913 #define set_index(symbol, idx)  ((symbol)->udata.i = (idx))
 914
 915 /* Write a symbol out to a COFF file.  */
 916
 917 static boolean
 918 coff_write_symbol (abfd, symbol, native, written, string_size_p,
 919                    debug_string_section_p, debug_string_size_p)
 920      bfd *abfd;
 921      asymbol *symbol;
 922      combined_entry_type *native;
 923      unsigned int *written;
 924      bfd_size_type *string_size_p;
 925      asection **debug_string_section_p;
 926      bfd_size_type *debug_string_size_p;
 927 {
 928   unsigned int numaux = native->u.syment.n_numaux;
 929   int type = native->u.syment.n_type;
 930   int class = native->u.syment.n_sclass;
 931   PTR buf;
 932   bfd_size_type symesz;
 933
 934   if (native->u.syment.n_sclass == C_FILE)
 935     symbol->flags |= BSF_DEBUGGING;
 936
 937   if (symbol->flags & BSF_DEBUGGING
 938       && bfd_is_abs_section (symbol->section))
 939     {
 940       native->u.syment.n_scnum = N_DEBUG;
 941     }
 942   else if (bfd_is_abs_section (symbol->section))
 943     {
 944       native->u.syment.n_scnum = N_ABS;
 945     }
 946   else if (bfd_is_und_section (symbol->section))
 947     {
 948       native->u.syment.n_scnum = N_UNDEF;
 949     }
 950   else
 951     {
 952       native->u.syment.n_scnum =
 953         symbol->section->output_section->target_index;
 954     }
 955
 956   coff_fix_symbol_name (abfd, symbol, native, string_size_p,
 957                         debug_string_section_p, debug_string_size_p);
 958
 959   symesz = bfd_coff_symesz (abfd);
 960   buf = bfd_alloc (abfd, symesz);
 961   if (!buf)
 962     return false;
 963   bfd_coff_swap_sym_out (abfd, &native->u.syment, buf);
 964   if (bfd_write (buf, 1, symesz, abfd) != symesz)
 965     return false;
 966   bfd_release (abfd, buf);
 967
 968   if (native->u.syment.n_numaux > 0)
 969     {
 970       bfd_size_type auxesz;
 971       unsigned int j;
 972
 973       auxesz = bfd_coff_auxesz (abfd);
 974       buf = bfd_alloc (abfd, auxesz);
 975       if (!buf)
 976         return false;
 977       for (j = 0; j < native->u.syment.n_numaux; j++)
 978         {
 979           bfd_coff_swap_aux_out (abfd,
 980                                  &((native + j + 1)->u.auxent),
 981                                  type,
 982                                  class,
 983                                  j,
 984                                  native->u.syment.n_numaux,
 985                                  buf);
 986           if (bfd_write (buf, 1, auxesz, abfd) != auxesz)
 987             return false;
 988         }
 989       bfd_release (abfd, buf);
 990     }
 991
 992   /* Store the index for use when we write out the relocs.  */
 993   set_index (symbol, *written);
 994
 995   *written += numaux + 1;
 996   return true;
 997 }
 998
 999 /* Write out a symbol to a COFF file that does not come from a COFF
1000    file originally.  This symbol may have been created by the linker,
1001    or we may be linking a non COFF file to a COFF file.  */
1002
1003 static boolean
1004 coff_write_alien_symbol (abfd, symbol, written, string_size_p,
1005                          debug_string_section_p, debug_string_size_p)
1006      bfd *abfd;
1007      asymbol *symbol;
1008      unsigned int *written;
1009      bfd_size_type *string_size_p;
1010      asection **debug_string_section_p;
1011      bfd_size_type *debug_string_size_p;
1012 {
1013   combined_entry_type *native;
1014   combined_entry_type dummy;
1015
1016   native = &dummy;
1017   native->u.syment.n_type = T_NULL;
1018   native->u.syment.n_flags = 0;
1019   if (bfd_is_und_section (symbol->section))
1020     {
1021       native->u.syment.n_scnum = N_UNDEF;
1022       native->u.syment.n_value = symbol->value;
1023     }
1024   else if (bfd_is_com_section (symbol->section))
1025     {
1026       native->u.syment.n_scnum = N_UNDEF;
1027       native->u.syment.n_value = symbol->value;
1028     }
1029   else if (symbol->flags & BSF_DEBUGGING)
1030     {
1031       /* There isn't much point to writing out a debugging symbol
1032          unless we are prepared to convert it into COFF debugging
1033          format.  So, we just ignore them.  We must clobber the symbol
1034          name to keep it from being put in the string table.  */
1035       symbol->name = "";
1036       return true;
1037     }
1038   else
1039     {
1040       native->u.syment.n_scnum =
1041         symbol->section->output_section->target_index;
1042       native->u.syment.n_value = (symbol->value
1043                                   + symbol->section->output_offset);
1044       if (! obj_pe (abfd))
1045         native->u.syment.n_value += symbol->section->output_section->vma;
1046
1047       /* Copy the any flags from the the file header into the symbol.
1048          FIXME: Why?  */
1049       {
1050         coff_symbol_type *c = coff_symbol_from (abfd, symbol);
1051         if (c != (coff_symbol_type *) NULL)
1052           native->u.syment.n_flags = bfd_asymbol_bfd (&c->symbol)->flags;
1053       }
1054     }
1055
1056   native->u.syment.n_type = 0;
1057   if (symbol->flags & BSF_LOCAL)
1058     native->u.syment.n_sclass = C_STAT;
1059   else if (symbol->flags & BSF_WEAK)
1060     native->u.syment.n_sclass = obj_pe (abfd) ? C_NT_WEAK : C_WEAKEXT;
1061   else
1062     native->u.syment.n_sclass = C_EXT;
1063   native->u.syment.n_numaux = 0;
1064
1065   return coff_write_symbol (abfd, symbol, native, written, string_size_p,
1066                             debug_string_section_p, debug_string_size_p);
1067 }
1068
1069 /* Write a native symbol to a COFF file.  */
1070
1071 static boolean
1072 coff_write_native_symbol (abfd, symbol, written, string_size_p,
1073                           debug_string_section_p, debug_string_size_p)
1074      bfd *abfd;
1075      coff_symbol_type *symbol;
1076      unsigned int *written;
1077      bfd_size_type *string_size_p;
1078      asection **debug_string_section_p;
1079      bfd_size_type *debug_string_size_p;
1080 {
1081   combined_entry_type *native = symbol->native;
1082   alent *lineno = symbol->lineno;
1083
1084   /* If this symbol has an associated line number, we must store the
1085      symbol index in the line number field.  We also tag the auxent to
1086      point to the right place in the lineno table.  */
1087   if (lineno && !symbol->done_lineno && symbol->symbol.section->owner != NULL)
1088     {
1089       unsigned int count = 0;
1090       lineno[count].u.offset = *written;
1091       if (native->u.syment.n_numaux)
1092         {
1093           union internal_auxent *a = &((native + 1)->u.auxent);
1094
1095           a->x_sym.x_fcnary.x_fcn.x_lnnoptr =
1096             symbol->symbol.section->output_section->moving_line_filepos;
1097         }
1098
1099       /* Count and relocate all other linenumbers.  */
1100       count++;
1101       while (lineno[count].line_number != 0)
1102         {
1103 #if 0
1104           /* 13 april 92. sac
1105              I've been told this, but still need proof:
1106              > The second bug is also in `bfd/coffcode.h'.  This bug
1107              > causes the linker to screw up the pc-relocations for
1108              > all the line numbers in COFF code.  This bug isn't only
1109              > specific to A29K implementations, but affects all
1110              > systems using COFF format binaries.  Note that in COFF
1111              > object files, the line number core offsets output by
1112              > the assembler are relative to the start of each
1113              > procedure, not to the start of the .text section.  This
1114              > patch relocates the line numbers relative to the
1115              > `native->u.syment.n_value' instead of the section
1116              > virtual address.
1117              > modular!olson@cs.arizona.edu (Jon Olson)
1118            */
1119           lineno[count].u.offset += native->u.syment.n_value;
1120 #else
1121           lineno[count].u.offset +=
1122             (symbol->symbol.section->output_section->vma
1123              + symbol->symbol.section->output_offset);
1124 #endif
1125           count++;
1126         }
1127       symbol->done_lineno = true;
1128
1129       symbol->symbol.section->output_section->moving_line_filepos +=
1130         count * bfd_coff_linesz (abfd);
1131     }
1132
1133   return coff_write_symbol (abfd, &(symbol->symbol), native, written,
1134                             string_size_p, debug_string_section_p,
1135                             debug_string_size_p);
1136 }
1137
1138 /* Write out the COFF symbols.  */
1139
1140 boolean
1141 coff_write_symbols (abfd)
1142      bfd *abfd;
1143 {
1144   bfd_size_type string_size;
1145   asection *debug_string_section;
1146   bfd_size_type debug_string_size;
1147   unsigned int i;
1148   unsigned int limit = bfd_get_symcount (abfd);
1149   unsigned int written = 0;
1150   asymbol **p;
1151
1152   string_size = 0;
1153   debug_string_section = NULL;
1154   debug_string_size = 0;
1155
1156   /* If this target supports long section names, they must be put into
1157      the string table.  This is supported by PE.  This code must
1158      handle section names just as they are handled in
1159      coff_write_object_contents.  */
1160   if (bfd_coff_long_section_names (abfd))
1161     {
1162       asection *o;
1163
1164       for (o = abfd->sections; o != NULL; o = o->next)
1165         {
1166           size_t len;
1167
1168           len = strlen (o->name);
1169           if (len > SCNNMLEN)
1170             string_size += len + 1;
1171         }
1172     }
1173
1174   /* Seek to the right place */
1175   if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0)
1176     return false;
1177
1178   /* Output all the symbols we have */
1179
1180   written = 0;
1181   for (p = abfd->outsymbols, i = 0; i < limit; i++, p++)
1182     {
1183       asymbol *symbol = *p;
1184       coff_symbol_type *c_symbol = coff_symbol_from (abfd, symbol);
1185
1186       if (c_symbol == (coff_symbol_type *) NULL
1187           || c_symbol->native == (combined_entry_type *) NULL)
1188         {
1189           if (!coff_write_alien_symbol (abfd, symbol, &written, &string_size,
1190                                         &debug_string_section,
1191                                         &debug_string_size))
1192             return false;
1193         }
1194       else
1195         {
1196           if (!coff_write_native_symbol (abfd, c_symbol, &written,
1197                                          &string_size, &debug_string_section,
1198                                          &debug_string_size))
1199             return false;
1200         }
1201     }
1202
1203   obj_raw_syment_count (abfd) = written;
1204
1205   /* Now write out strings */
1206
1207   if (string_size != 0)
1208     {
1209       unsigned int size = string_size + STRING_SIZE_SIZE;
1210       bfd_byte buffer[STRING_SIZE_SIZE];
1211
1212 #if STRING_SIZE_SIZE == 4
1213       bfd_h_put_32 (abfd, size, buffer);
1214 #else
1215  #error Change bfd_h_put_32
1216 #endif
1217       if (bfd_write ((PTR) buffer, 1, sizeof (buffer), abfd) != sizeof (buffer))
1218         return false;
1219
1220       /* Handle long section names.  This code must handle section
1221          names just as they are handled in coff_write_object_contents.  */
1222       if (bfd_coff_long_section_names (abfd))
1223         {
1224           asection *o;
1225
1226           for (o = abfd->sections; o != NULL; o = o->next)
1227             {
1228               size_t len;
1229
1230               len = strlen (o->name);
1231               if (len > SCNNMLEN)
1232                 {
1233                   if (bfd_write (o->name, 1, len + 1, abfd) != len + 1)
1234                     return false;
1235                 }
1236             }
1237         }
1238
1239       for (p = abfd->outsymbols, i = 0;
1240            i < limit;
1241            i++, p++)
1242         {
1243           asymbol *q = *p;
1244           size_t name_length = strlen (q->name);
1245           coff_symbol_type *c_symbol = coff_symbol_from (abfd, q);
1246           size_t maxlen;
1247
1248           /* Figure out whether the symbol name should go in the string
1249              table.  Symbol names that are short enough are stored
1250              directly in the syment structure.  File names permit a
1251              different, longer, length in the syment structure.  On
1252              XCOFF, some symbol names are stored in the .debug section
1253              rather than in the string table.  */
1254
1255           if (c_symbol == NULL
1256               || c_symbol->native == NULL)
1257             {
1258               /* This is not a COFF symbol, so it certainly is not a
1259                  file name, nor does it go in the .debug section.  */
1260               maxlen = bfd_coff_force_symnames_in_strings (abfd) ? 0 : SYMNMLEN;
1261             }
1262           else if (bfd_coff_symname_in_debug (abfd,
1263                                               &c_symbol->native->u.syment))
1264             {
1265               /* This symbol name is in the XCOFF .debug section.
1266                  Don't write it into the string table.  */
1267               maxlen = name_length;
1268             }
1269           else if (c_symbol->native->u.syment.n_sclass == C_FILE
1270                    && c_symbol->native->u.syment.n_numaux > 0)
1271             {
1272               if (bfd_coff_force_symnames_in_strings (abfd))
1273                 bfd_write (".file", 1, 6, abfd);
1274               maxlen = bfd_coff_filnmlen (abfd);
1275             }
1276           else
1277             maxlen = bfd_coff_force_symnames_in_strings (abfd) ? 0 : SYMNMLEN;
1278
1279           if (name_length > maxlen)
1280             {
1281               if (bfd_write ((PTR) (q->name), 1, name_length + 1, abfd)
1282                   != name_length + 1)
1283                 return false;
1284             }
1285         }
1286     }
1287   else
1288     {
1289       /* We would normally not write anything here, but we'll write
1290          out 4 so that any stupid coff reader which tries to read the
1291          string table even when there isn't one won't croak.  */
1292       unsigned int size = STRING_SIZE_SIZE;
1293       bfd_byte buffer[STRING_SIZE_SIZE];
1294
1295 #if STRING_SIZE_SIZE == 4
1296       bfd_h_put_32 (abfd, size, buffer);
1297 #else
1298  #error Change bfd_h_put_32
1299 #endif
1300       if (bfd_write ((PTR) buffer, 1, STRING_SIZE_SIZE, abfd)
1301           != STRING_SIZE_SIZE)
1302         return false;
1303     }
1304
1305   /* Make sure the .debug section was created to be the correct size.
1306      We should create it ourselves on the fly, but we don't because
1307      BFD won't let us write to any section until we know how large all
1308      the sections are.  We could still do it by making another pass
1309      over the symbols.  FIXME.  */
1310   BFD_ASSERT (debug_string_size == 0
1311               || (debug_string_section != (asection *) NULL
1312                   && (BFD_ALIGN (debug_string_size,
1313                                  1 << debug_string_section->alignment_power)
1314                       == bfd_section_size (abfd, debug_string_section))));
1315
1316   return true;
1317 }
1318
1319 boolean
1320 coff_write_linenumbers (abfd)
1321      bfd *abfd;
1322 {
1323   asection *s;
1324   bfd_size_type linesz;
1325   PTR buff;
1326
1327   linesz = bfd_coff_linesz (abfd);
1328   buff = bfd_alloc (abfd, linesz);
1329   if (!buff)
1330     return false;
1331   for (s = abfd->sections; s != (asection *) NULL; s = s->next)
1332     {
1333       if (s->lineno_count)
1334         {
1335           asymbol **q = abfd->outsymbols;
1336           if (bfd_seek (abfd, s->line_filepos, SEEK_SET) != 0)
1337             return false;
1338           /* Find all the linenumbers in this section */
1339           while (*q)
1340             {
1341               asymbol *p = *q;
1342               if (p->section->output_section == s)
1343                 {
1344                   alent *l =
1345                   BFD_SEND (bfd_asymbol_bfd (p), _get_lineno,
1346                             (bfd_asymbol_bfd (p), p));
1347                   if (l)
1348                     {
1349                       /* Found a linenumber entry, output */
1350                       struct internal_lineno out;
1351                       memset ((PTR) & out, 0, sizeof (out));
1352                       out.l_lnno = 0;
1353                       out.l_addr.l_symndx = l->u.offset;
1354                       bfd_coff_swap_lineno_out (abfd, &out, buff);
1355                       if (bfd_write (buff, 1, linesz, abfd) != linesz)
1356                         return false;
1357                       l++;
1358                       while (l->line_number)
1359                         {
1360                           out.l_lnno = l->line_number;
1361                           out.l_addr.l_symndx = l->u.offset;
1362                           bfd_coff_swap_lineno_out (abfd, &out, buff);
1363                           if (bfd_write (buff, 1, linesz, abfd) != linesz)
1364                             return false;
1365                           l++;
1366                         }
1367                     }
1368                 }
1369               q++;
1370             }
1371         }
1372     }
1373   bfd_release (abfd, buff);
1374   return true;
1375 }
1376
1377 alent *
1378 coff_get_lineno (ignore_abfd, symbol)
1379      bfd *ignore_abfd ATTRIBUTE_UNUSED;
1380      asymbol *symbol;
1381 {
1382   return coffsymbol (symbol)->lineno;
1383 }
1384
1385 #if 0
1386
1387 /* This is only called from coff_add_missing_symbols, which has been
1388    disabled.  */
1389
1390 asymbol *
1391 coff_section_symbol (abfd, name)
1392      bfd *abfd;
1393      char *name;
1394 {
1395   asection *sec = bfd_make_section_old_way (abfd, name);
1396   asymbol *sym;
1397   combined_entry_type *csym;
1398
1399   sym = sec->symbol;
1400   csym = coff_symbol_from (abfd, sym)->native;
1401   /* Make sure back-end COFF stuff is there.  */
1402   if (csym == 0)
1403     {
1404       struct foo
1405         {
1406           coff_symbol_type sym;
1407           /* @@FIXME This shouldn't use a fixed size!!  */
1408           combined_entry_type e[10];
1409         };
1410       struct foo *f;
1411       f = (struct foo *) bfd_alloc (abfd, sizeof (*f));
1412       if (!f)
1413         {
1414           bfd_set_error (bfd_error_no_error);
1415           return NULL;
1416         }
1417       memset ((char *) f, 0, sizeof (*f));
1418       coff_symbol_from (abfd, sym)->native = csym = f->e;
1419     }
1420   csym[0].u.syment.n_sclass = C_STAT;
1421   csym[0].u.syment.n_numaux = 1;
1422 /*  SF_SET_STATICS (sym);       @@ ??? */
1423   csym[1].u.auxent.x_scn.x_scnlen = sec->_raw_size;
1424   csym[1].u.auxent.x_scn.x_nreloc = sec->reloc_count;
1425   csym[1].u.auxent.x_scn.x_nlinno = sec->lineno_count;
1426
1427   if (sec->output_section == NULL)
1428     {
1429       sec->output_section = sec;
1430       sec->output_offset = 0;
1431     }
1432
1433   return sym;
1434 }
1435
1436 #endif /* 0 */
1437
1438 /* This function transforms the offsets into the symbol table into
1439    pointers to syments.  */
1440
1441 static void
1442 coff_pointerize_aux (abfd, table_base, symbol, indaux, auxent)
1443      bfd *abfd;
1444      combined_entry_type *table_base;
1445      combined_entry_type *symbol;
1446      unsigned int indaux;
1447      combined_entry_type *auxent;
1448 {
1449   unsigned int type = symbol->u.syment.n_type;
1450   unsigned int class = symbol->u.syment.n_sclass;
1451
1452   if (coff_backend_info (abfd)->_bfd_coff_pointerize_aux_hook)
1453     {
1454       if ((*coff_backend_info (abfd)->_bfd_coff_pointerize_aux_hook)
1455           (abfd, table_base, symbol, indaux, auxent))
1456         return;
1457     }
1458
1459   /* Don't bother if this is a file or a section */
1460   if (class == C_STAT && type == T_NULL)
1461     return;
1462   if (class == C_FILE)
1463     return;
1464
1465   /* Otherwise patch up */
1466 #define N_TMASK coff_data (abfd)->local_n_tmask
1467 #define N_BTSHFT coff_data (abfd)->local_n_btshft
1468   if ((ISFCN (type) || ISTAG (class) || class == C_BLOCK || class == C_FCN)
1469       && auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l > 0)
1470     {
1471       auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p =
1472         table_base + auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l;
1473       auxent->fix_end = 1;
1474     }
1475   /* A negative tagndx is meaningless, but the SCO 3.2v4 cc can
1476      generate one, so we must be careful to ignore it.  */
1477   if (auxent->u.auxent.x_sym.x_tagndx.l > 0)
1478     {
1479       auxent->u.auxent.x_sym.x_tagndx.p =
1480         table_base + auxent->u.auxent.x_sym.x_tagndx.l;
1481       auxent->fix_tag = 1;
1482     }
1483 }
1484
1485 /* Allocate space for the ".debug" section, and read it.
1486    We did not read the debug section until now, because
1487    we didn't want to go to the trouble until someone needed it.  */
1488
1489 static char *
1490 build_debug_section (abfd)
1491      bfd *abfd;
1492 {
1493   char *debug_section;
1494   long position;
1495
1496   asection *sect = bfd_get_section_by_name (abfd, ".debug");
1497
1498   if (!sect)
1499     {
1500       bfd_set_error (bfd_error_no_debug_section);
1501       return NULL;
1502     }
1503
1504   debug_section = (PTR) bfd_alloc (abfd,
1505                                    bfd_get_section_size_before_reloc (sect));
1506   if (debug_section == NULL)
1507     return NULL;
1508
1509   /* Seek to the beginning of the `.debug' section and read it.
1510      Save the current position first; it is needed by our caller.
1511      Then read debug section and reset the file pointer.  */
1512
1513   position = bfd_tell (abfd);
1514   if (bfd_seek (abfd, sect->filepos, SEEK_SET) != 0
1515       || (bfd_read (debug_section,
1516                     bfd_get_section_size_before_reloc (sect), 1, abfd)
1517           != bfd_get_section_size_before_reloc (sect))
1518       || bfd_seek (abfd, position, SEEK_SET) != 0)
1519     return NULL;
1520   return debug_section;
1521 }
1522
1523 /* Return a pointer to a malloc'd copy of 'name'.  'name' may not be
1524    \0-terminated, but will not exceed 'maxlen' characters.  The copy *will*
1525    be \0-terminated.  */
1526 static char *
1527 copy_name (abfd, name, maxlen)
1528      bfd *abfd;
1529      char *name;
1530      int maxlen;
1531 {
1532   int len;
1533   char *newname;
1534
1535   for (len = 0; len < maxlen; ++len)
1536     {
1537       if (name[len] == '\0')
1538         {
1539           break;
1540         }
1541     }
1542
1543   if ((newname = (PTR) bfd_alloc (abfd, len + 1)) == NULL)
1544     return (NULL);
1545   strncpy (newname, name, len);
1546   newname[len] = '\0';
1547   return newname;
1548 }
1549
1550 /* Read in the external symbols.  */
1551
1552 boolean
1553 _bfd_coff_get_external_symbols (abfd)
1554      bfd *abfd;
1555 {
1556   bfd_size_type symesz;
1557   size_t size;
1558   PTR syms;
1559
1560   if (obj_coff_external_syms (abfd) != NULL)
1561     return true;
1562
1563   symesz = bfd_coff_symesz (abfd);
1564
1565   size = obj_raw_syment_count (abfd) * symesz;
1566
1567   syms = (PTR) bfd_malloc (size);
1568   if (syms == NULL && size != 0)
1569     return false;
1570
1571   if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
1572       || bfd_read (syms, size, 1, abfd) != size)
1573     {
1574       if (syms != NULL)
1575         free (syms);
1576       return false;
1577     }
1578
1579   obj_coff_external_syms (abfd) = syms;
1580
1581   return true;
1582 }
1583
1584 /* Read in the external strings.  The strings are not loaded until
1585    they are needed.  This is because we have no simple way of
1586    detecting a missing string table in an archive.  */
1587
1588 const char *
1589 _bfd_coff_read_string_table (abfd)
1590      bfd *abfd;
1591 {
1592   char extstrsize[STRING_SIZE_SIZE];
1593   size_t strsize;
1594   char *strings;
1595
1596   if (obj_coff_strings (abfd) != NULL)
1597     return obj_coff_strings (abfd);
1598
1599   if (obj_sym_filepos (abfd) == 0)
1600     {
1601       bfd_set_error (bfd_error_no_symbols);
1602       return NULL;
1603     }
1604
1605   if (bfd_seek (abfd,
1606                 (obj_sym_filepos (abfd)
1607                  + obj_raw_syment_count (abfd) * bfd_coff_symesz (abfd)),
1608                 SEEK_SET) != 0)
1609     return NULL;
1610
1611   if (bfd_read (extstrsize, sizeof extstrsize, 1, abfd) != sizeof extstrsize)
1612     {
1613       if (bfd_get_error () != bfd_error_file_truncated)
1614         return NULL;
1615
1616       /* There is no string table.  */
1617       strsize = STRING_SIZE_SIZE;
1618     }
1619   else
1620     {
1621 #if STRING_SIZE_SIZE == 4
1622       strsize = bfd_h_get_32 (abfd, (bfd_byte *) extstrsize);
1623 #else
1624  #error Change bfd_h_get_32
1625 #endif
1626     }
1627
1628   if (strsize < STRING_SIZE_SIZE)
1629     {
1630       (*_bfd_error_handler)
1631         (_("%s: bad string table size %lu"), bfd_get_filename (abfd),
1632          (unsigned long) strsize);
1633       bfd_set_error (bfd_error_bad_value);
1634       return NULL;
1635     }
1636
1637   strings = (char *) bfd_malloc (strsize);
1638   if (strings == NULL)
1639     return NULL;
1640
1641   if (bfd_read (strings + STRING_SIZE_SIZE,
1642                 strsize - STRING_SIZE_SIZE, 1, abfd)
1643       != strsize - STRING_SIZE_SIZE)
1644     {
1645       free (strings);
1646       return NULL;
1647     }
1648
1649   obj_coff_strings (abfd) = strings;
1650
1651   return strings;
1652 }
1653
1654 /* Free up the external symbols and strings read from a COFF file.  */
1655
1656 boolean
1657 _bfd_coff_free_symbols (abfd)
1658      bfd *abfd;
1659 {
1660   if (obj_coff_external_syms (abfd) != NULL
1661       && ! obj_coff_keep_syms (abfd))
1662     {
1663       free (obj_coff_external_syms (abfd));
1664       obj_coff_external_syms (abfd) = NULL;
1665     }
1666   if (obj_coff_strings (abfd) != NULL
1667       && ! obj_coff_keep_strings (abfd))
1668     {
1669       free (obj_coff_strings (abfd));
1670       obj_coff_strings (abfd) = NULL;
1671     }
1672   return true;
1673 }
1674
1675 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
1676    knit the symbol names into a normalized form.  By normalized here I
1677    mean that all symbols have an n_offset pointer that points to a null-
1678    terminated string.  */
1679
1680 combined_entry_type *
1681 coff_get_normalized_symtab (abfd)
1682      bfd *abfd;
1683 {
1684   combined_entry_type *internal;
1685   combined_entry_type *internal_ptr;
1686   combined_entry_type *symbol_ptr;
1687   combined_entry_type *internal_end;
1688   bfd_size_type symesz;
1689   char *raw_src;
1690   char *raw_end;
1691   const char *string_table = NULL;
1692   char *debug_section = NULL;
1693   unsigned long size;
1694
1695   if (obj_raw_syments (abfd) != NULL)
1696     return obj_raw_syments (abfd);
1697
1698   size = obj_raw_syment_count (abfd) * sizeof (combined_entry_type);
1699   internal = (combined_entry_type *) bfd_zalloc (abfd, size);
1700   if (internal == NULL && size != 0)
1701     return NULL;
1702   internal_end = internal + obj_raw_syment_count (abfd);
1703
1704   if (! _bfd_coff_get_external_symbols (abfd))
1705     return NULL;
1706
1707   raw_src = (char *) obj_coff_external_syms (abfd);
1708
1709   /* mark the end of the symbols */
1710   symesz = bfd_coff_symesz (abfd);
1711   raw_end = (char *) raw_src + obj_raw_syment_count (abfd) * symesz;
1712
1713   /* FIXME SOMEDAY.  A string table size of zero is very weird, but
1714      probably possible.  If one shows up, it will probably kill us.  */
1715
1716   /* Swap all the raw entries */
1717   for (internal_ptr = internal;
1718        raw_src < raw_end;
1719        raw_src += symesz, internal_ptr++)
1720     {
1721
1722       unsigned int i;
1723       bfd_coff_swap_sym_in (abfd, (PTR) raw_src,
1724                             (PTR) & internal_ptr->u.syment);
1725       symbol_ptr = internal_ptr;
1726
1727       for (i = 0;
1728            i < symbol_ptr->u.syment.n_numaux;
1729            i++)
1730         {
1731           internal_ptr++;
1732           raw_src += symesz;
1733           bfd_coff_swap_aux_in (abfd, (PTR) raw_src,
1734                                 symbol_ptr->u.syment.n_type,
1735                                 symbol_ptr->u.syment.n_sclass,
1736                                 i, symbol_ptr->u.syment.n_numaux,
1737                                 &(internal_ptr->u.auxent));
1738           coff_pointerize_aux (abfd, internal, symbol_ptr, i,
1739                                internal_ptr);
1740         }
1741     }
1742
1743   /* Free the raw symbols, but not the strings (if we have them).  */
1744   obj_coff_keep_strings (abfd) = true;
1745   if (! _bfd_coff_free_symbols (abfd))
1746     return NULL;
1747
1748   for (internal_ptr = internal; internal_ptr < internal_end;
1749        internal_ptr++)
1750     {
1751       if (internal_ptr->u.syment.n_sclass == C_FILE
1752           && internal_ptr->u.syment.n_numaux > 0)
1753         {
1754           /* make a file symbol point to the name in the auxent, since
1755              the text ".file" is redundant */
1756           if ((internal_ptr + 1)->u.auxent.x_file.x_n.x_zeroes == 0)
1757             {
1758               /* the filename is a long one, point into the string table */
1759               if (string_table == NULL)
1760                 {
1761                   string_table = _bfd_coff_read_string_table (abfd);
1762                   if (string_table == NULL)
1763                     return NULL;
1764                 }
1765
1766               internal_ptr->u.syment._n._n_n._n_offset =
1767                 ((long)
1768                  (string_table
1769                   + (internal_ptr + 1)->u.auxent.x_file.x_n.x_offset));
1770             }
1771           else
1772             {
1773               /* Ordinary short filename, put into memory anyway.  The
1774                  Microsoft PE tools sometimes store a filename in
1775                  multiple AUX entries.  */
1776               if (internal_ptr->u.syment.n_numaux > 1
1777                   && coff_data (abfd)->pe)
1778                 {
1779                   internal_ptr->u.syment._n._n_n._n_offset =
1780                     ((long)
1781                      copy_name (abfd,
1782                                 (internal_ptr + 1)->u.auxent.x_file.x_fname,
1783                                 internal_ptr->u.syment.n_numaux * symesz));
1784                 }
1785               else
1786                 {
1787                   internal_ptr->u.syment._n._n_n._n_offset =
1788                     ((long)
1789                      copy_name (abfd,
1790                                 (internal_ptr + 1)->u.auxent.x_file.x_fname,
1791                                 bfd_coff_filnmlen (abfd)));
1792                 }
1793             }
1794         }
1795       else
1796         {
1797           if (internal_ptr->u.syment._n._n_n._n_zeroes != 0)
1798             {
1799               /* This is a "short" name.  Make it long.  */
1800               unsigned long i = 0;
1801               char *newstring = NULL;
1802
1803               /* find the length of this string without walking into memory
1804                  that isn't ours.  */
1805               for (i = 0; i < 8; ++i)
1806                 {
1807                   if (internal_ptr->u.syment._n._n_name[i] == '\0')
1808                     {
1809                       break;
1810                     }           /* if end of string */
1811                 }               /* possible lengths of this string.  */
1812
1813               if ((newstring = (PTR) bfd_alloc (abfd, ++i)) == NULL)
1814                 return (NULL);
1815               memset (newstring, 0, i);
1816               strncpy (newstring, internal_ptr->u.syment._n._n_name, i - 1);
1817               internal_ptr->u.syment._n._n_n._n_offset = (long int) newstring;
1818               internal_ptr->u.syment._n._n_n._n_zeroes = 0;
1819             }
1820           else if (internal_ptr->u.syment._n._n_n._n_offset == 0)
1821             internal_ptr->u.syment._n._n_n._n_offset = (long int) "";
1822           else if (!bfd_coff_symname_in_debug (abfd, &internal_ptr->u.syment))
1823             {
1824               /* Long name already.  Point symbol at the string in the
1825                  table.  */
1826               if (string_table == NULL)
1827                 {
1828                   string_table = _bfd_coff_read_string_table (abfd);
1829                   if (string_table == NULL)
1830                     return NULL;
1831                 }
1832               internal_ptr->u.syment._n._n_n._n_offset =
1833                 ((long int)
1834                  (string_table
1835                   + internal_ptr->u.syment._n._n_n._n_offset));
1836             }
1837           else
1838             {
1839               /* Long name in debug section.  Very similar.  */
1840               if (debug_section == NULL)
1841                 debug_section = build_debug_section (abfd);
1842               internal_ptr->u.syment._n._n_n._n_offset = (long int)
1843                 (debug_section + internal_ptr->u.syment._n._n_n._n_offset);
1844             }
1845         }
1846       internal_ptr += internal_ptr->u.syment.n_numaux;
1847     }
1848
1849   obj_raw_syments (abfd) = internal;
1850   BFD_ASSERT (obj_raw_syment_count (abfd)
1851               == (unsigned int) (internal_ptr - internal));
1852
1853   return (internal);
1854 }                               /* coff_get_normalized_symtab() */
1855
1856 long
1857 coff_get_reloc_upper_bound (abfd, asect)
1858      bfd *abfd;
1859      sec_ptr asect;
1860 {
1861   if (bfd_get_format (abfd) != bfd_object)
1862     {
1863       bfd_set_error (bfd_error_invalid_operation);
1864       return -1;
1865     }
1866   return (asect->reloc_count + 1) * sizeof (arelent *);
1867 }
1868
1869 asymbol *
1870 coff_make_empty_symbol (abfd)
1871      bfd *abfd;
1872 {
1873   coff_symbol_type *new = (coff_symbol_type *) bfd_alloc (abfd, sizeof (coff_symbol_type));
1874   if (new == NULL)
1875     return (NULL);
1876   memset (new, 0, sizeof *new);
1877   new->symbol.section = 0;
1878   new->native = 0;
1879   new->lineno = (alent *) NULL;
1880   new->done_lineno = false;
1881   new->symbol.the_bfd = abfd;
1882   return &new->symbol;
1883 }
1884
1885 /* Make a debugging symbol.  */
1886
1887 asymbol *
1888 coff_bfd_make_debug_symbol (abfd, ptr, sz)
1889      bfd *abfd;
1890      PTR ptr ATTRIBUTE_UNUSED;
1891      unsigned long sz ATTRIBUTE_UNUSED;
1892 {
1893   coff_symbol_type *new = (coff_symbol_type *) bfd_alloc (abfd, sizeof (coff_symbol_type));
1894   if (new == NULL)
1895     return (NULL);
1896   /* @@ The 10 is a guess at a plausible maximum number of aux entries
1897      (but shouldn't be a constant).  */
1898   new->native = (combined_entry_type *) bfd_zalloc (abfd, sizeof (combined_entry_type) * 10);
1899   if (!new->native)
1900     return (NULL);
1901   new->symbol.section = bfd_abs_section_ptr;
1902   new->symbol.flags = BSF_DEBUGGING;
1903   new->lineno = (alent *) NULL;
1904   new->done_lineno = false;
1905   new->symbol.the_bfd = abfd;
1906   return &new->symbol;
1907 }
1908
1909 void
1910 coff_get_symbol_info (abfd, symbol, ret)
1911      bfd *abfd;
1912      asymbol *symbol;
1913      symbol_info *ret;
1914 {
1915   bfd_symbol_info (symbol, ret);
1916   if (coffsymbol (symbol)->native != NULL
1917       && coffsymbol (symbol)->native->fix_value)
1918     {
1919       combined_entry_type *psym;
1920
1921       psym = ((combined_entry_type *)
1922               coffsymbol (symbol)->native->u.syment.n_value);
1923       ret->value = (bfd_vma) (psym - obj_raw_syments (abfd));
1924     }
1925 }
1926
1927 /* Return the COFF syment for a symbol.  */
1928
1929 boolean
1930 bfd_coff_get_syment (abfd, symbol, psyment)
1931      bfd *abfd;
1932      asymbol *symbol;
1933      struct internal_syment *psyment;
1934 {
1935   coff_symbol_type *csym;
1936
1937   csym = coff_symbol_from (abfd, symbol);
1938   if (csym == NULL || csym->native == NULL)
1939     {
1940       bfd_set_error (bfd_error_invalid_operation);
1941       return false;
1942     }
1943
1944   *psyment = csym->native->u.syment;
1945
1946   if (csym->native->fix_value)
1947     psyment->n_value = ((combined_entry_type *) psyment->n_value
1948                         - obj_raw_syments (abfd));
1949
1950   /* FIXME: We should handle fix_line here.  */
1951
1952   return true;
1953 }
1954
1955 /* Return the COFF auxent for a symbol.  */
1956
1957 boolean
1958 bfd_coff_get_auxent (abfd, symbol, indx, pauxent)
1959      bfd *abfd;
1960      asymbol *symbol;
1961      int indx;
1962      union internal_auxent *pauxent;
1963 {
1964   coff_symbol_type *csym;
1965   combined_entry_type *ent;
1966
1967   csym = coff_symbol_from (abfd, symbol);
1968
1969   if (csym == NULL
1970       || csym->native == NULL
1971       || indx >= csym->native->u.syment.n_numaux)
1972     {
1973       bfd_set_error (bfd_error_invalid_operation);
1974       return false;
1975     }
1976
1977   ent = csym->native + indx + 1;
1978
1979   *pauxent = ent->u.auxent;
1980
1981   if (ent->fix_tag)
1982     pauxent->x_sym.x_tagndx.l =
1983       ((combined_entry_type *) pauxent->x_sym.x_tagndx.p
1984        - obj_raw_syments (abfd));
1985
1986   if (ent->fix_end)
1987     pauxent->x_sym.x_fcnary.x_fcn.x_endndx.l =
1988       ((combined_entry_type *) pauxent->x_sym.x_fcnary.x_fcn.x_endndx.p
1989        - obj_raw_syments (abfd));
1990
1991   if (ent->fix_scnlen)
1992     pauxent->x_csect.x_scnlen.l =
1993       ((combined_entry_type *) pauxent->x_csect.x_scnlen.p
1994        - obj_raw_syments (abfd));
1995
1996   return true;
1997 }
1998
1999 /* Print out information about COFF symbol.  */
2000
2001 void
2002 coff_print_symbol (abfd, filep, symbol, how)
2003      bfd *abfd;
2004      PTR filep;
2005      asymbol *symbol;
2006      bfd_print_symbol_type how;
2007 {
2008   FILE *file = (FILE *) filep;
2009
2010   switch (how)
2011     {
2012     case bfd_print_symbol_name:
2013       fprintf (file, "%s", symbol->name);
2014       break;
2015
2016     case bfd_print_symbol_more:
2017       fprintf (file, "coff %s %s",
2018                coffsymbol (symbol)->native ? "n" : "g",
2019                coffsymbol (symbol)->lineno ? "l" : " ");
2020       break;
2021
2022     case bfd_print_symbol_all:
2023       if (coffsymbol (symbol)->native)
2024         {
2025           unsigned long val;
2026           unsigned int aux;
2027           combined_entry_type *combined = coffsymbol (symbol)->native;
2028           combined_entry_type *root = obj_raw_syments (abfd);
2029           struct lineno_cache_entry *l = coffsymbol (symbol)->lineno;
2030
2031           fprintf (file, "[%3ld]", (long) (combined - root));
2032
2033           if (! combined->fix_value)
2034             val = (unsigned long) combined->u.syment.n_value;
2035           else
2036             val = ((unsigned long)
2037                    ((combined_entry_type *) combined->u.syment.n_value
2038                     - root));
2039
2040           fprintf (file,
2041                    "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x%08lx %s",
2042                    combined->u.syment.n_scnum,
2043                    combined->u.syment.n_flags,
2044                    combined->u.syment.n_type,
2045                    combined->u.syment.n_sclass,
2046                    combined->u.syment.n_numaux,
2047                    val,
2048                    symbol->name);
2049
2050           for (aux = 0; aux < combined->u.syment.n_numaux; aux++)
2051             {
2052               combined_entry_type *auxp = combined + aux + 1;
2053               long tagndx;
2054
2055               if (auxp->fix_tag)
2056                 tagndx = auxp->u.auxent.x_sym.x_tagndx.p - root;
2057               else
2058                 tagndx = auxp->u.auxent.x_sym.x_tagndx.l;
2059
2060               fprintf (file, "\n");
2061
2062               if (bfd_coff_print_aux (abfd, file, root, combined, auxp, aux))
2063                 continue;
2064
2065               switch (combined->u.syment.n_sclass)
2066                 {
2067                 case C_FILE:
2068                   fprintf (file, "File ");
2069                   break;
2070
2071                 case C_STAT:
2072                   if (combined->u.syment.n_type == T_NULL)
2073                     /* probably a section symbol? */
2074                     {
2075                       fprintf (file, "AUX scnlen 0x%lx nreloc %d nlnno %d",
2076                                (long) auxp->u.auxent.x_scn.x_scnlen,
2077                                auxp->u.auxent.x_scn.x_nreloc,
2078                                auxp->u.auxent.x_scn.x_nlinno);
2079                       if (auxp->u.auxent.x_scn.x_checksum != 0
2080                           || auxp->u.auxent.x_scn.x_associated != 0
2081                           || auxp->u.auxent.x_scn.x_comdat != 0)
2082                         fprintf (file, " checksum 0x%lx assoc %d comdat %d",
2083                                  auxp->u.auxent.x_scn.x_checksum,
2084                                  auxp->u.auxent.x_scn.x_associated,
2085                                  auxp->u.auxent.x_scn.x_comdat);
2086                       break;
2087                     }
2088                     /* else fall through */
2089                 case C_EXT:
2090                   if (ISFCN (combined->u.syment.n_type))
2091                     {
2092                       fprintf (file,
2093                                _("AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld"),
2094                                tagndx,
2095                                auxp->u.auxent.x_sym.x_misc.x_fsize,
2096                                auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_lnnoptr,
2097                                (auxp->fix_end
2098                                 ? ((long)
2099                                    (auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p
2100                                     - root))
2101                                 : auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l));
2102                       break;
2103                     }
2104                   /* else fall through */
2105                 default:
2106                   fprintf (file, "AUX lnno %d size 0x%x tagndx %ld",
2107                            auxp->u.auxent.x_sym.x_misc.x_lnsz.x_lnno,
2108                            auxp->u.auxent.x_sym.x_misc.x_lnsz.x_size,
2109                            tagndx);
2110                   if (auxp->fix_end)
2111                     fprintf (file, " endndx %ld",
2112                              ((long)
2113                               (auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p
2114                                - root)));
2115                   break;
2116                 }
2117             }
2118
2119           if (l)
2120             {
2121               fprintf (file, "\n%s :", l->u.sym->name);
2122               l++;
2123               while (l->line_number)
2124                 {
2125                   fprintf (file, "\n%4d : 0x%lx",
2126                            l->line_number,
2127                            ((unsigned long)
2128                             (l->u.offset + symbol->section->vma)));
2129                   l++;
2130                 }
2131             }
2132         }
2133       else
2134         {
2135           bfd_print_symbol_vandf ((PTR) file, symbol);
2136           fprintf (file, " %-5s %s %s %s",
2137                    symbol->section->name,
2138                    coffsymbol (symbol)->native ? "n" : "g",
2139                    coffsymbol (symbol)->lineno ? "l" : " ",
2140                    symbol->name);
2141         }
2142     }
2143 }
2144
2145 /* Return whether a symbol name implies a local symbol.  In COFF,
2146    local symbols generally start with ``.L''.  Most targets use this
2147    function for the is_local_label_name entry point, but some may
2148    override it.  */
2149
2150 boolean
2151 _bfd_coff_is_local_label_name (abfd, name)
2152      bfd *abfd ATTRIBUTE_UNUSED;
2153      const char *name;
2154 {
2155   return name[0] == '.' && name[1] == 'L';
2156 }
2157
2158 /* Provided a BFD, a section and an offset (in bytes, not octets) into the
2159    section, calculate and return the name of the source file and the line
2160    nearest to the wanted location.  */
2161
2162 boolean
2163 coff_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
2164                         functionname_ptr, line_ptr)
2165      bfd *abfd;
2166      asection *section;
2167      asymbol **symbols;
2168      bfd_vma offset;
2169      CONST char **filename_ptr;
2170      CONST char **functionname_ptr;
2171      unsigned int *line_ptr;
2172 {
2173   boolean found;
2174   unsigned int i;
2175   unsigned int line_base;
2176   coff_data_type *cof = coff_data (abfd);
2177   /* Run through the raw syments if available */
2178   combined_entry_type *p;
2179   combined_entry_type *pend;
2180   alent *l;
2181   struct coff_section_tdata *sec_data;
2182
2183   /* Before looking through the symbol table, try to use a .stab
2184      section to find the information.  */
2185   if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
2186                                              &found, filename_ptr,
2187                                              functionname_ptr, line_ptr,
2188                                              &coff_data(abfd)->line_info))
2189     return false;
2190
2191   if (found)
2192     return true;
2193
2194   /* Also try examining DWARF2 debugging information.  */
2195   if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
2196                                      filename_ptr, functionname_ptr,
2197                                      line_ptr, 0,
2198                                      &coff_data(abfd)->dwarf2_find_line_info))
2199     return true;
2200
2201   *filename_ptr = 0;
2202   *functionname_ptr = 0;
2203   *line_ptr = 0;
2204
2205   /* Don't try and find line numbers in a non coff file */
2206   if (!bfd_family_coff (abfd))
2207     return false;
2208
2209   if (cof == NULL)
2210     return false;
2211
2212   /* Find the first C_FILE symbol.  */
2213   p = cof->raw_syments;
2214   if (!p)
2215     return false;
2216
2217   pend = p + cof->raw_syment_count;
2218   while (p < pend)
2219     {
2220       if (p->u.syment.n_sclass == C_FILE)
2221         break;
2222       p += 1 + p->u.syment.n_numaux;
2223     }
2224
2225   if (p < pend)
2226     {
2227       bfd_vma sec_vma;
2228       bfd_vma maxdiff;
2229
2230       /* Look through the C_FILE symbols to find the best one.  */
2231       sec_vma = bfd_get_section_vma (abfd, section);
2232       *filename_ptr = (char *) p->u.syment._n._n_n._n_offset;
2233       maxdiff = (bfd_vma) 0 - (bfd_vma) 1;
2234       while (1)
2235         {
2236           combined_entry_type *p2;
2237
2238           for (p2 = p + 1 + p->u.syment.n_numaux;
2239                p2 < pend;
2240                p2 += 1 + p2->u.syment.n_numaux)
2241             {
2242               if (p2->u.syment.n_scnum > 0
2243                   && (section
2244                       == coff_section_from_bfd_index (abfd,
2245                                                       p2->u.syment.n_scnum)))
2246                 break;
2247               if (p2->u.syment.n_sclass == C_FILE)
2248                 {
2249                   p2 = pend;
2250                   break;
2251                 }
2252             }
2253
2254           /* We use <= MAXDIFF here so that if we get a zero length
2255              file, we actually use the next file entry.  */
2256           if (p2 < pend
2257               && offset + sec_vma >= (bfd_vma) p2->u.syment.n_value
2258               && offset + sec_vma - (bfd_vma) p2->u.syment.n_value <= maxdiff)
2259             {
2260               *filename_ptr = (char *) p->u.syment._n._n_n._n_offset;
2261               maxdiff = offset + sec_vma - p2->u.syment.n_value;
2262             }
2263
2264           /* Avoid endless loops on erroneous files by ensuring that
2265              we always move forward in the file.  */
2266           if (p - cof->raw_syments >= p->u.syment.n_value)
2267             break;
2268
2269           p = cof->raw_syments + p->u.syment.n_value;
2270           if (p > pend || p->u.syment.n_sclass != C_FILE)
2271             break;
2272         }
2273     }
2274
2275   /* Now wander though the raw linenumbers of the section */
2276   /* If we have been called on this section before, and the offset we
2277      want is further down then we can prime the lookup loop.  */
2278   sec_data = coff_section_data (abfd, section);
2279   if (sec_data != NULL
2280       && sec_data->i > 0
2281       && offset >= sec_data->offset)
2282     {
2283       i = sec_data->i;
2284       *functionname_ptr = sec_data->function;
2285       line_base = sec_data->line_base;
2286     }
2287   else
2288     {
2289       i = 0;
2290       line_base = 0;
2291     }
2292
2293   if (section->lineno != NULL)
2294     {
2295       bfd_vma last_value = 0;
2296
2297       l = &section->lineno[i];
2298
2299       for (; i < section->lineno_count; i++)
2300         {
2301           if (l->line_number == 0)
2302             {
2303               /* Get the symbol this line number points at */
2304               coff_symbol_type *coff = (coff_symbol_type *) (l->u.sym);
2305               if (coff->symbol.value > offset)
2306                 break;
2307               *functionname_ptr = coff->symbol.name;
2308               last_value = coff->symbol.value;
2309               if (coff->native)
2310                 {
2311                   combined_entry_type *s = coff->native;
2312                   s = s + 1 + s->u.syment.n_numaux;
2313
2314                   /* In XCOFF a debugging symbol can follow the
2315                      function symbol.  */
2316                   if (s->u.syment.n_scnum == N_DEBUG)
2317                     s = s + 1 + s->u.syment.n_numaux;
2318
2319                   /* S should now point to the .bf of the function.  */
2320                   if (s->u.syment.n_numaux)
2321                     {
2322                       /* The linenumber is stored in the auxent.  */
2323                       union internal_auxent *a = &((s + 1)->u.auxent);
2324                       line_base = a->x_sym.x_misc.x_lnsz.x_lnno;
2325                       *line_ptr = line_base;
2326                     }
2327                 }
2328             }
2329           else
2330             {
2331               if (l->u.offset > offset)
2332                 break;
2333               *line_ptr = l->line_number + line_base - 1;
2334             }
2335           l++;
2336         }
2337
2338       /* If we fell off the end of the loop, then assume that this
2339          symbol has no line number info.  Otherwise, symbols with no
2340          line number info get reported with the line number of the
2341          last line of the last symbol which does have line number
2342          info.  We use 0x100 as a slop to account for cases where the
2343          last line has executable code.  */
2344       if (i >= section->lineno_count
2345           && last_value != 0
2346           && offset - last_value > 0x100)
2347         {
2348           *functionname_ptr = NULL;
2349           *line_ptr = 0;
2350         }
2351     }
2352
2353   /* Cache the results for the next call.  */
2354   if (sec_data == NULL && section->owner == abfd)
2355     {
2356       section->used_by_bfd =
2357         ((PTR) bfd_zalloc (abfd,
2358                            sizeof (struct coff_section_tdata)));
2359       sec_data = (struct coff_section_tdata *) section->used_by_bfd;
2360     }
2361   if (sec_data != NULL)
2362     {
2363       sec_data->offset = offset;
2364       sec_data->i = i;
2365       sec_data->function = *functionname_ptr;
2366       sec_data->line_base = line_base;
2367     }
2368
2369   return true;
2370 }
2371
2372 int
2373 coff_sizeof_headers (abfd, reloc)
2374      bfd *abfd;
2375      boolean reloc;
2376 {
2377   size_t size;
2378
2379   if (reloc == false)
2380     {
2381       size = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
2382     }
2383   else
2384     {
2385       size = bfd_coff_filhsz (abfd);
2386     }
2387
2388   size += abfd->section_count * bfd_coff_scnhsz (abfd);
2389   return size;
2390 }
2391
2392 /* Change the class of a coff symbol held by BFD.  */
2393 boolean
2394 bfd_coff_set_symbol_class (abfd, symbol, class)
2395      bfd *         abfd;
2396      asymbol *     symbol;
2397      unsigned int  class;
2398 {
2399   coff_symbol_type * csym;
2400
2401   csym = coff_symbol_from (abfd, symbol);
2402   if (csym == NULL)
2403     {
2404       bfd_set_error (bfd_error_invalid_operation);
2405       return false;
2406     }
2407   else if (csym->native == NULL)
2408     {
2409       /* This is an alien symbol which no native coff backend data.
2410          We cheat here by creating a fake native entry for it and
2411          then filling in the class.  This code is based on that in
2412          coff_write_alien_symbol().  */
2413
2414       combined_entry_type * native;
2415
2416       native = (combined_entry_type *) bfd_alloc (abfd, sizeof (* native));
2417       if (native == NULL)
2418         return false;
2419
2420       memset (native, 0, sizeof (* native));
2421
2422       native->u.syment.n_type   = T_NULL;
2423       native->u.syment.n_sclass = class;
2424
2425       if (bfd_is_und_section (symbol->section))
2426         {
2427           native->u.syment.n_scnum = N_UNDEF;
2428           native->u.syment.n_value = symbol->value;
2429         }
2430       else if (bfd_is_com_section (symbol->section))
2431         {
2432           native->u.syment.n_scnum = N_UNDEF;
2433           native->u.syment.n_value = symbol->value;
2434         }
2435       else
2436         {
2437           native->u.syment.n_scnum =
2438             symbol->section->output_section->target_index;
2439           native->u.syment.n_value = (symbol->value
2440                                       + symbol->section->output_offset);
2441           if (! obj_pe (abfd))
2442             native->u.syment.n_value += symbol->section->output_section->vma;
2443
2444           /* Copy the any flags from the the file header into the symbol.
2445              FIXME: Why?  */
2446           native->u.syment.n_flags = bfd_asymbol_bfd (& csym->symbol)->flags;
2447         }
2448
2449       csym->native = native;
2450     }
2451   else
2452     {
2453       csym->native->u.syment.n_sclass = class;
2454     }
2455
2456   return true;
2457 }