bfd/coffgen.c

   1 /* Support for the generic parts of COFF, for BFD.
   2    Copyright 1990, 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
   3    Written by Cygnus Support.
   4
   5 This file is part of BFD, the Binary File Descriptor library.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21 /* Most of this hacked by  Steve Chamberlain, [email protected].
  22    Split out of coffcode.h by Ian Taylor, [email protected].  */
  23
  24 /* This file contains COFF code that is not dependent on any
  25    particular COFF target.  There is only one version of this file in
  26    libbfd.a, so no target specific code may be put in here.  Or, to
  27    put it another way,
  28
  29    ********** DO NOT PUT TARGET SPECIFIC CODE IN THIS FILE **********
  30
  31    If you need to add some target specific behaviour, add a new hook
  32    function to bfd_coff_backend_data.
  33
  34    Some of these functions are also called by the ECOFF routines.
  35    Those functions may not use any COFF specific information, such as
  36    coff_data (abfd).  */
  37
  38 #include "bfd.h"
  39 #include "sysdep.h"
  40 #include "libbfd.h"
  41 #include "coff/internal.h"
  42 #include "libcoff.h"
  43
  44 static boolean coff_write_symbol PARAMS ((bfd *, asymbol *,
  45                                           combined_entry_type *,
  46                                           unsigned int *));
  47 static boolean coff_write_alien_symbol PARAMS ((bfd *, asymbol *,
  48                                                 unsigned int *));
  49 static boolean coff_write_native_symbol PARAMS ((bfd *, coff_symbol_type *,
  50                                                  unsigned int *));
  51
  52 static asection bfd_debug_section = { "*DEBUG*" };
  53
  54 #define STRING_SIZE_SIZE (4)
  55
  56 /* Take a section header read from a coff file (in HOST byte order),
  57    and make a BFD "section" out of it.  This is used by ECOFF.  */
  58 static          boolean
  59 make_a_section_from_file (abfd, hdr, target_index)
  60      bfd            *abfd;
  61      struct internal_scnhdr  *hdr;
  62      unsigned int target_index;
  63 {
  64   asection       *return_section;
  65   char *name;
  66
  67   /* Assorted wastage to null-terminate the name, thanks AT&T! */
  68   name = bfd_alloc(abfd, sizeof (hdr->s_name)+1);
  69   if (name == NULL) {
  70       bfd_set_error (bfd_error_no_memory);
  71       return false;
  72     }
  73   strncpy(name, (char *) &hdr->s_name[0], sizeof (hdr->s_name));
  74   name[sizeof (hdr->s_name)] = 0;
  75
  76   return_section = bfd_make_section(abfd, name);
  77   if (return_section == NULL)
  78     return_section = bfd_coff_make_section_hook (abfd, name);
  79
  80   /* Handle several sections of the same name.  For example, if an executable
  81      has two .bss sections, GDB better be able to find both of them
  82      (PR 3562).  */
  83   if (return_section == NULL)
  84     return_section = bfd_make_section_anyway (abfd, name);
  85
  86   if (return_section == NULL)
  87     return false;
  88
  89   /* s_paddr is presumed to be = to s_vaddr */
  90
  91   return_section->vma = hdr->s_vaddr;
  92   return_section->_raw_size = hdr->s_size;
  93   return_section->filepos = hdr->s_scnptr;
  94   return_section->rel_filepos =  hdr->s_relptr;
  95   return_section->reloc_count = hdr->s_nreloc;
  96
  97   bfd_coff_set_alignment_hook (abfd, return_section, hdr);
  98
  99   return_section->line_filepos =  hdr->s_lnnoptr;
 100
 101   return_section->lineno_count = hdr->s_nlnno;
 102   return_section->userdata = NULL;
 103   return_section->next = (asection *) NULL;
 104   return_section->flags = bfd_coff_styp_to_sec_flags_hook (abfd, hdr, name);
 105
 106   return_section->target_index = target_index;
 107
 108   /* At least on i386-coff, the line number count for a shared library
 109      section must be ignored.  */
 110   if ((return_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
 111     return_section->lineno_count = 0;
 112
 113   if (hdr->s_nreloc != 0)
 114     return_section->flags |= SEC_RELOC;
 115   /* FIXME: should this check 'hdr->s_size > 0' */
 116   if (hdr->s_scnptr != 0)
 117     return_section->flags |= SEC_HAS_CONTENTS;
 118   return true;
 119 }
 120
 121 /* Read in a COFF object and make it into a BFD.  This is used by
 122    ECOFF as well.  */
 123
 124 static const bfd_target *
 125 coff_real_object_p (abfd, nscns, internal_f, internal_a)
 126      bfd            *abfd;
 127      unsigned        nscns;
 128      struct internal_filehdr *internal_f;
 129      struct internal_aouthdr *internal_a;
 130 {
 131   PTR tdata;
 132   size_t          readsize;     /* length of file_info */
 133   unsigned int scnhsz;
 134   char *external_sections;
 135
 136   /* Build a play area */
 137   tdata = bfd_coff_mkobject_hook (abfd, (PTR) internal_f, (PTR) internal_a);
 138   if (tdata == NULL)
 139     return 0;
 140
 141   scnhsz = bfd_coff_scnhsz (abfd);
 142   readsize = nscns * scnhsz;
 143   external_sections = (char *)bfd_alloc(abfd, readsize);
 144   if (!external_sections)
 145     {
 146       bfd_set_error (bfd_error_no_memory);
 147       goto fail;
 148     }
 149
 150   if (bfd_read((PTR)external_sections, 1, readsize, abfd) != readsize) {
 151     goto fail;
 152   }
 153
 154   /* Now copy data as required; construct all asections etc */
 155   if (nscns != 0) {
 156     unsigned int    i;
 157     for (i = 0; i < nscns; i++) {
 158       struct internal_scnhdr tmp;
 159       bfd_coff_swap_scnhdr_in(abfd, (PTR) (external_sections + i * scnhsz),
 160                               (PTR) &tmp);
 161       make_a_section_from_file(abfd,&tmp, i+1);
 162     }
 163   }
 164
 165 /*  make_abs_section(abfd);*/
 166
 167   if (bfd_coff_set_arch_mach_hook (abfd, (PTR) internal_f) == false)
 168     goto fail;
 169
 170   if (!(internal_f->f_flags & F_RELFLG))
 171     abfd->flags |= HAS_RELOC;
 172   if ((internal_f->f_flags & F_EXEC))
 173     abfd->flags |= EXEC_P;
 174   if (!(internal_f->f_flags & F_LNNO))
 175     abfd->flags |= HAS_LINENO;
 176   if (!(internal_f->f_flags & F_LSYMS))
 177     abfd->flags |= HAS_LOCALS;
 178
 179   /* FIXME: How can we set D_PAGED correctly?  */
 180   if ((internal_f->f_flags & F_EXEC) != 0)
 181     abfd->flags |= D_PAGED;
 182
 183   bfd_get_symcount(abfd) = internal_f->f_nsyms;
 184   if (internal_f->f_nsyms)
 185     abfd->flags |= HAS_SYMS;
 186
 187   if (internal_a != (struct internal_aouthdr *) NULL)
 188     bfd_get_start_address (abfd) = internal_a->entry;
 189   else
 190     bfd_get_start_address (abfd) = 0;
 191
 192   return abfd->xvec;
 193  fail:
 194   bfd_release(abfd, tdata);
 195   return (const bfd_target *)NULL;
 196 }
 197
 198 /* Turn a COFF file into a BFD, but fail with bfd_error_wrong_format if it is
 199    not a COFF file.  This is also used by ECOFF.  */
 200
 201 const bfd_target *
 202 coff_object_p (abfd)
 203      bfd            *abfd;
 204 {
 205   unsigned int filhsz;
 206   unsigned int aoutsz;
 207   int   nscns;
 208   PTR filehdr;
 209   struct internal_filehdr internal_f;
 210   struct internal_aouthdr internal_a;
 211
 212   /* figure out how much to read */
 213   filhsz = bfd_coff_filhsz (abfd);
 214   aoutsz = bfd_coff_aoutsz (abfd);
 215
 216   filehdr = bfd_alloc (abfd, filhsz);
 217   if (filehdr == NULL)
 218     return 0;
 219   if (bfd_read(filehdr, 1, filhsz, abfd) != filhsz)
 220     {
 221       if (bfd_get_error () != bfd_error_system_call)
 222         bfd_set_error (bfd_error_wrong_format);
 223       return 0;
 224     }
 225   bfd_coff_swap_filehdr_in(abfd, filehdr, &internal_f);
 226   bfd_release (abfd, filehdr);
 227
 228   if (bfd_coff_bad_format_hook (abfd, &internal_f) == false) {
 229     bfd_set_error (bfd_error_wrong_format);
 230     return 0;
 231   }
 232   nscns =internal_f.f_nscns;
 233
 234   if (internal_f.f_opthdr) {
 235     PTR opthdr;
 236
 237     opthdr = bfd_alloc (abfd, aoutsz);
 238     if (opthdr == NULL)
 239       return 0;;
 240     if (bfd_read(opthdr, 1,aoutsz, abfd) != aoutsz) {
 241       return 0;
 242     }
 243     bfd_coff_swap_aouthdr_in(abfd, opthdr, (PTR)&internal_a);
 244   }
 245
 246   /* Seek past the opt hdr stuff */
 247   if (bfd_seek(abfd, (file_ptr) (internal_f.f_opthdr + filhsz), SEEK_SET)
 248       != 0)
 249     return NULL;
 250
 251   return coff_real_object_p(abfd, nscns, &internal_f,
 252                             (internal_f.f_opthdr != 0
 253                              ? &internal_a
 254                              : (struct internal_aouthdr *) NULL));
 255 }
 256
 257 /* Get the BFD section from a COFF symbol section number.  */
 258
 259 asection *
 260 coff_section_from_bfd_index (abfd, index)
 261      bfd            *abfd;
 262      int             index;
 263 {
 264   struct sec *answer = abfd->sections;
 265
 266   if (index == N_ABS)
 267   {
 268     return bfd_abs_section_ptr;
 269   }
 270   if (index == N_UNDEF)
 271   {
 272     return bfd_und_section_ptr;
 273   }
 274   if(index == N_DEBUG)
 275   {
 276     return &bfd_debug_section;
 277
 278   }
 279
 280   while (answer) {
 281       if (answer->target_index == index)
 282        return answer;
 283       answer = answer->next;
 284     }
 285
 286   /* We should not reach this point, but the SCO 3.2v4 /lib/libc_s.a
 287      has a bad symbol table in biglitpow.o.  */
 288   return bfd_und_section_ptr;
 289 }
 290
 291 /* Get the upper bound of a COFF symbol table.  */
 292
 293 long
 294 coff_get_symtab_upper_bound(abfd)
 295 bfd            *abfd;
 296 {
 297   if (!bfd_coff_slurp_symbol_table(abfd))
 298     return -1;
 299
 300   return (bfd_get_symcount(abfd) + 1) * (sizeof(coff_symbol_type *));
 301 }
 302
 303
 304 /* Canonicalize a COFF symbol table.  */
 305
 306 long
 307 coff_get_symtab (abfd, alocation)
 308      bfd *abfd;
 309      asymbol **alocation;
 310 {
 311   unsigned int counter;
 312   coff_symbol_type *symbase;
 313   coff_symbol_type **location = (coff_symbol_type **) alocation;
 314
 315   if (! bfd_coff_slurp_symbol_table (abfd))
 316     return -1;
 317
 318   symbase = obj_symbols (abfd);
 319   counter = bfd_get_symcount (abfd);
 320   while (counter-- > 0)
 321     *location++ = symbase++;
 322
 323   *location = NULL;
 324
 325   return bfd_get_symcount (abfd);
 326 }
 327
 328 /* Set lineno_count for the output sections of a COFF file.  */
 329
 330 int
 331 coff_count_linenumbers (abfd)
 332      bfd *abfd;
 333 {
 334   unsigned int limit = bfd_get_symcount(abfd);
 335   unsigned int i;
 336   int total = 0;
 337   asymbol **p;
 338   asection *s;
 339
 340   if (limit == 0)
 341     {
 342       /* This may be from the backend linker, in which case the
 343          lineno_count in the sections is correct.  */
 344       for (s = abfd->sections; s != NULL; s = s->next)
 345         total += s->lineno_count;
 346       return total;
 347     }
 348
 349   for (s = abfd->sections; s != NULL; s = s->next)
 350     BFD_ASSERT (s->lineno_count == 0);
 351
 352   for (p = abfd->outsymbols, i = 0; i < limit; i++, p++)
 353     {
 354       asymbol *q_maybe = *p;
 355
 356       if (bfd_asymbol_flavour (q_maybe) == bfd_target_coff_flavour)
 357         {
 358           coff_symbol_type *q = coffsymbol (q_maybe);
 359
 360           if (q->lineno != NULL)
 361             {
 362               /* This symbol has line numbers.  Increment the owning
 363                  section's linenumber count.  */
 364               alent *l = q->lineno;
 365
 366               ++q->symbol.section->output_section->lineno_count;
 367               ++total;
 368               ++l;
 369               while (l->line_number != 0)
 370                 {
 371                   ++total;
 372                   ++q->symbol.section->output_section->lineno_count;
 373                   ++l;
 374                 }
 375             }
 376         }
 377     }
 378
 379   return total;
 380 }
 381
 382 /* Takes a bfd and a symbol, returns a pointer to the coff specific
 383    area of the symbol if there is one.  */
 384
 385 /*ARGSUSED*/
 386 coff_symbol_type *
 387 coff_symbol_from (ignore_abfd, symbol)
 388      bfd            *ignore_abfd;
 389      asymbol        *symbol;
 390 {
 391   if (bfd_asymbol_flavour(symbol) != bfd_target_coff_flavour)
 392     return (coff_symbol_type *)NULL;
 393
 394   if (bfd_asymbol_bfd(symbol)->tdata.coff_obj_data == (coff_data_type*)NULL)
 395     return (coff_symbol_type *)NULL;
 396
 397   return  (coff_symbol_type *) symbol;
 398 }
 399
 400 static void
 401 fixup_symbol_value (coff_symbol_ptr, syment)
 402      coff_symbol_type *coff_symbol_ptr;
 403      struct internal_syment *syment;
 404 {
 405
 406   /* Normalize the symbol flags */
 407   if (bfd_is_com_section (coff_symbol_ptr->symbol.section)) {
 408     /* a common symbol is undefined with a value */
 409     syment->n_scnum = N_UNDEF;
 410     syment->n_value = coff_symbol_ptr->symbol.value;
 411   }
 412   else if (coff_symbol_ptr->symbol.flags & BSF_DEBUGGING) {
 413     syment->n_value = coff_symbol_ptr->symbol.value;
 414   }
 415   else if (bfd_is_und_section (coff_symbol_ptr->symbol.section)) {
 416     syment->n_scnum = N_UNDEF;
 417     syment->n_value = 0;
 418   }
 419   else {
 420     if (coff_symbol_ptr->symbol.section) {
 421       syment->n_scnum    =
 422        coff_symbol_ptr->symbol.section->output_section->target_index;
 423
 424       syment->n_value =
 425        coff_symbol_ptr->symbol.value +
 426         coff_symbol_ptr->symbol.section->output_offset +
 427          coff_symbol_ptr->symbol.section->output_section->vma;
 428     }
 429     else {
 430         BFD_ASSERT(0);
 431       /* This can happen, but I don't know why yet ([email protected]) */
 432       syment->n_scnum = N_ABS;
 433       syment->n_value = coff_symbol_ptr->symbol.value;
 434     }
 435   }
 436 }
 437
 438 /* run through all the symbols in the symbol table and work out what
 439    their indexes into the symbol table will be when output
 440
 441  Coff requires that each C_FILE symbol points to the next one in the
 442  chain, and that the last one points to the first external symbol. We
 443  do that here too.
 444
 445 */
 446 boolean
 447 coff_renumber_symbols (bfd_ptr)
 448      bfd *bfd_ptr;
 449 {
 450   unsigned int symbol_count = bfd_get_symcount(bfd_ptr);
 451   asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;
 452   unsigned int native_index = 0;
 453   struct internal_syment *last_file = (struct internal_syment *)NULL;
 454   unsigned int symbol_index;
 455
 456   /* COFF demands that undefined symbols come after all other symbols.
 457      Since we don't need to impose this extra knowledge on all our client
 458      programs, deal with that here.  Sort the symbol table; just move the
 459      undefined symbols to the end, leaving the rest alone.  */
 460   /* @@ Do we have some condition we could test for, so we don't always
 461      have to do this?  I don't think relocatability is quite right, but
 462      I'm not certain.  [raeburn:19920508.1711EST]  */
 463   {
 464     asymbol **newsyms;
 465     int i;
 466
 467     newsyms = (asymbol **) bfd_alloc_by_size_t (bfd_ptr,
 468                                                 sizeof (asymbol *)
 469                                                 * (symbol_count + 1));
 470     if (!newsyms)
 471       {
 472         bfd_set_error (bfd_error_no_memory);
 473         return false;
 474       }
 475     bfd_ptr->outsymbols = newsyms;
 476     for (i = 0; i < symbol_count; i++)
 477       if (! bfd_is_und_section (symbol_ptr_ptr[i]->section))
 478         *newsyms++ = symbol_ptr_ptr[i];
 479     for (i = 0; i < symbol_count; i++)
 480       if (bfd_is_und_section (symbol_ptr_ptr[i]->section))
 481         *newsyms++ = symbol_ptr_ptr[i];
 482     *newsyms = (asymbol *) NULL;
 483     symbol_ptr_ptr = bfd_ptr->outsymbols;
 484   }
 485
 486   for (symbol_index = 0; symbol_index < symbol_count; symbol_index++)
 487       {
 488         coff_symbol_type *coff_symbol_ptr = coff_symbol_from(bfd_ptr, symbol_ptr_ptr[symbol_index]);
 489         if (coff_symbol_ptr && coff_symbol_ptr->native) {
 490           combined_entry_type *s = coff_symbol_ptr->native;
 491           int i;
 492
 493           if (s->u.syment.n_sclass == C_FILE)
 494               {
 495                 if (last_file != (struct internal_syment *)NULL) {
 496                   last_file->n_value = native_index;
 497                 }
 498                 last_file = &(s->u.syment);
 499               }
 500           else {
 501
 502             /* Modify the symbol values according to their section and
 503                type */
 504
 505             fixup_symbol_value(coff_symbol_ptr, &(s->u.syment));
 506           }
 507           for (i = 0; i < s->u.syment.n_numaux + 1; i++) {
 508             s[i].offset = native_index ++;
 509           }
 510         }
 511         else {
 512           native_index++;
 513         }
 514       }
 515   obj_conv_table_size (bfd_ptr) = native_index;
 516   return true;
 517 }
 518
 519 /*
 520  Run thorough the symbol table again, and fix it so that all pointers to
 521  entries are changed to the entries' index in the output symbol table.
 522
 523 */
 524 void
 525 coff_mangle_symbols (bfd_ptr)
 526      bfd *bfd_ptr;
 527 {
 528   unsigned int symbol_count = bfd_get_symcount (bfd_ptr);
 529   asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;
 530   unsigned int symbol_index;
 531
 532   for (symbol_index = 0; symbol_index < symbol_count; symbol_index++)
 533     {
 534       coff_symbol_type *coff_symbol_ptr =
 535         coff_symbol_from (bfd_ptr, symbol_ptr_ptr[symbol_index]);
 536
 537       if (coff_symbol_ptr && coff_symbol_ptr->native)
 538         {
 539           int i;
 540           combined_entry_type *s = coff_symbol_ptr->native;
 541
 542           if (s->fix_value)
 543             {
 544               /* FIXME: We should use a union here.  */
 545               s->u.syment.n_value =
 546                 ((combined_entry_type *) s->u.syment.n_value)->offset;
 547               s->fix_value = 0;
 548             }
 549           for (i = 0; i < s->u.syment.n_numaux ; i++)
 550             {
 551               combined_entry_type *a = s + i + 1;
 552               if (a->fix_tag)
 553                 {
 554                   a->u.auxent.x_sym.x_tagndx.l =
 555                     a->u.auxent.x_sym.x_tagndx.p->offset;
 556                   a->fix_tag = 0;
 557                 }
 558               if (a->fix_end)
 559                 {
 560                   a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l =
 561                     a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p->offset;
 562                   a->fix_end = 0;
 563                 }
 564               if (a->fix_scnlen)
 565                 {
 566                   a->u.auxent.x_csect.x_scnlen.l =
 567                     a->u.auxent.x_csect.x_scnlen.p->offset;
 568                   a->fix_scnlen = 0;
 569                 }
 570             }
 571         }
 572     }
 573 }
 574
 575 static bfd_size_type string_size;
 576 static bfd_size_type debug_string_size;
 577 static asection *debug_string_section;
 578
 579 static void
 580 coff_fix_symbol_name (abfd, symbol, native)
 581      bfd *abfd;
 582      asymbol *symbol;
 583      combined_entry_type *native;
 584 {
 585   unsigned int    name_length;
 586   union internal_auxent *auxent;
 587   char *  name = ( char *)(symbol->name);
 588
 589   if (name == (char *) NULL) {
 590     /* coff symbols always have names, so we'll make one up */
 591     symbol->name = "strange";
 592     name = (char *)symbol->name;
 593   }
 594   name_length = strlen(name);
 595
 596   if (native->u.syment.n_sclass == C_FILE) {
 597     strncpy(native->u.syment._n._n_name, ".file", SYMNMLEN);
 598     auxent = &(native+1)->u.auxent;
 599
 600     if (bfd_coff_long_filenames (abfd)) {
 601       if (name_length <= FILNMLEN) {
 602         strncpy(auxent->x_file.x_fname, name, FILNMLEN);
 603       }
 604       else {
 605         auxent->x_file.x_n.x_offset = string_size + STRING_SIZE_SIZE;
 606         auxent->x_file.x_n.x_zeroes = 0;
 607         string_size += name_length + 1;
 608       }
 609     }
 610     else {
 611       strncpy(auxent->x_file.x_fname, name, FILNMLEN);
 612       if (name_length > FILNMLEN) {
 613         name[FILNMLEN] = '\0';
 614       }
 615     }
 616   }
 617   else
 618     {                           /* NOT A C_FILE SYMBOL */
 619       if (name_length <= SYMNMLEN)
 620         {
 621           /* This name will fit into the symbol neatly */
 622           strncpy(native->u.syment._n._n_name, symbol->name, SYMNMLEN);
 623         }
 624       else if (! bfd_coff_symname_in_debug (abfd, &native->u.syment))
 625         {
 626           native->u.syment._n._n_n._n_offset =  string_size + STRING_SIZE_SIZE;
 627           native->u.syment._n._n_n._n_zeroes = 0;
 628           string_size += name_length + 1;
 629         }
 630       else
 631         {
 632           long filepos;
 633           bfd_byte buf[2];
 634
 635           /* This name should be written into the .debug section.  For
 636              some reason each name is preceded by a two byte length
 637              and also followed by a null byte.  FIXME: We assume that
 638              the .debug section has already been created, and that it
 639              is large enough.  */
 640           if (debug_string_section == (asection *) NULL)
 641             debug_string_section = bfd_get_section_by_name (abfd, ".debug");
 642           filepos = bfd_tell (abfd);
 643           bfd_put_16 (abfd, name_length + 1, buf);
 644           if (! bfd_set_section_contents (abfd,
 645                                           debug_string_section,
 646                                           (PTR) buf,
 647                                           (file_ptr) debug_string_size,
 648                                           (bfd_size_type) 2)
 649               || ! bfd_set_section_contents (abfd,
 650                                              debug_string_section,
 651                                              (PTR) symbol->name,
 652                                              (file_ptr) debug_string_size + 2,
 653                                              (bfd_size_type) name_length + 1))
 654             abort ();
 655           if (bfd_seek (abfd, filepos, SEEK_SET) != 0)
 656             abort ();
 657           native->u.syment._n._n_n._n_offset = debug_string_size + 2;
 658           native->u.syment._n._n_n._n_zeroes = 0;
 659           debug_string_size += name_length + 3;
 660         }
 661     }
 662 }
 663
 664 /* We need to keep track of the symbol index so that when we write out
 665    the relocs we can get the index for a symbol.  This method is a
 666    hack.  FIXME.  */
 667
 668 #define set_index(symbol, idx)  ((symbol)->udata.i = (idx))
 669
 670 /* Write a symbol out to a COFF file.  */
 671
 672 static boolean
 673 coff_write_symbol (abfd, symbol, native, written)
 674      bfd *abfd;
 675      asymbol *symbol;
 676      combined_entry_type *native;
 677      unsigned int *written;
 678 {
 679   unsigned int numaux = native->u.syment.n_numaux;
 680   int type = native->u.syment.n_type;
 681   int class =  native->u.syment.n_sclass;
 682   PTR buf;
 683   bfd_size_type symesz;
 684
 685   /* @@ bfd_debug_section isn't accessible outside this file, but we
 686      know that C_FILE symbols belong there.  So move them.  */
 687   if (native->u.syment.n_sclass == C_FILE)
 688     symbol->section = &bfd_debug_section;
 689
 690   if (bfd_is_abs_section (symbol->section))
 691     {
 692       native->u.syment.n_scnum = N_ABS;
 693     }
 694   else if (symbol->section == &bfd_debug_section)
 695     {
 696       native->u.syment.n_scnum = N_DEBUG;
 697     }
 698   else if (bfd_is_und_section (symbol->section))
 699     {
 700       native->u.syment.n_scnum = N_UNDEF;
 701     }
 702   else
 703     {
 704       native->u.syment.n_scnum =
 705         symbol->section->output_section->target_index;
 706     }
 707
 708   coff_fix_symbol_name (abfd, symbol, native);
 709
 710   symesz = bfd_coff_symesz (abfd);
 711   buf = bfd_alloc (abfd, symesz);
 712   if (!buf)
 713     {
 714       bfd_set_error (bfd_error_no_memory);
 715       return false;
 716     }
 717   bfd_coff_swap_sym_out (abfd, &native->u.syment, buf);
 718   if (bfd_write (buf, 1, symesz, abfd) != symesz)
 719     return false;
 720   bfd_release (abfd, buf);
 721
 722   if (native->u.syment.n_numaux > 0)
 723     {
 724       bfd_size_type auxesz;
 725       unsigned int j;
 726
 727       auxesz = bfd_coff_auxesz (abfd);
 728       buf = bfd_alloc (abfd, auxesz);
 729       if (!buf)
 730         {
 731           bfd_set_error (bfd_error_no_memory);
 732           return false;
 733         }
 734       for (j = 0; j < native->u.syment.n_numaux;  j++)
 735         {
 736           bfd_coff_swap_aux_out (abfd,
 737                                  &((native + j + 1)->u.auxent),
 738                                  type,
 739                                  class,
 740                                  j,
 741                                  native->u.syment.n_numaux,
 742                                  buf);
 743           if (bfd_write (buf, 1, auxesz, abfd)!= auxesz)
 744             return false;
 745         }
 746       bfd_release (abfd, buf);
 747     }
 748
 749   /* Store the index for use when we write out the relocs.  */
 750   set_index (symbol, *written);
 751
 752   *written += numaux + 1;
 753   return true;
 754 }
 755
 756 /* Write out a symbol to a COFF file that does not come from a COFF
 757    file originally.  This symbol may have been created by the linker,
 758    or we may be linking a non COFF file to a COFF file.  */
 759
 760 static boolean
 761 coff_write_alien_symbol (abfd, symbol, written)
 762      bfd *abfd;
 763      asymbol *symbol;
 764      unsigned int *written;
 765 {
 766   combined_entry_type *native;
 767   combined_entry_type dummy;
 768
 769   native = &dummy;
 770   native->u.syment.n_type =  T_NULL;
 771   native->u.syment.n_flags =  0;
 772   if (bfd_is_und_section (symbol->section))
 773     {
 774       native->u.syment.n_scnum = N_UNDEF;
 775       native->u.syment.n_value = symbol->value;
 776     }
 777   else if (bfd_is_com_section (symbol->section))
 778     {
 779       native->u.syment.n_scnum = N_UNDEF;
 780       native->u.syment.n_value = symbol->value;
 781     }
 782   else if (symbol->flags & BSF_DEBUGGING)
 783     {
 784       /* There isn't much point to writing out a debugging symbol
 785          unless we are prepared to convert it into COFF debugging
 786          format.  So, we just ignore them.  We must clobber the symbol
 787          name to keep it from being put in the string table.  */
 788       symbol->name = "";
 789       return true;
 790     }
 791   else
 792     {
 793       native->u.syment.n_scnum =
 794         symbol->section->output_section->target_index;
 795       native->u.syment.n_value = (symbol->value
 796                                   + symbol->section->output_section->vma
 797                                   + symbol->section->output_offset);
 798
 799       /* Copy the any flags from the the file header into the symbol.
 800          FIXME: Why?  */
 801       {
 802         coff_symbol_type *c = coff_symbol_from (abfd, symbol);
 803         if (c != (coff_symbol_type *) NULL)
 804           native->u.syment.n_flags = bfd_asymbol_bfd (&c->symbol)->flags;
 805       }
 806     }
 807
 808   native->u.syment.n_type = 0;
 809   if (symbol->flags & BSF_LOCAL)
 810     native->u.syment.n_sclass = C_STAT;
 811   else
 812     native->u.syment.n_sclass = C_EXT;
 813   native->u.syment.n_numaux = 0;
 814
 815   return coff_write_symbol (abfd, symbol, native, written);
 816 }
 817
 818 /* Write a native symbol to a COFF file.  */
 819
 820 static boolean
 821 coff_write_native_symbol (abfd, symbol, written)
 822      bfd *abfd;
 823      coff_symbol_type *symbol;
 824      unsigned int *written;
 825 {
 826   combined_entry_type *native = symbol->native;
 827   alent *lineno = symbol->lineno;
 828
 829   /* If this symbol has an associated line number, we must store the
 830      symbol index in the line number field.  We also tag the auxent to
 831      point to the right place in the lineno table.  */
 832   if (lineno && !symbol->done_lineno)
 833     {
 834       unsigned int count = 0;
 835       lineno[count].u.offset = *written;
 836       if (native->u.syment.n_numaux)
 837         {
 838           union internal_auxent  *a = &((native+1)->u.auxent);
 839
 840           a->x_sym.x_fcnary.x_fcn.x_lnnoptr =
 841             symbol->symbol.section->output_section->moving_line_filepos;
 842         }
 843
 844       /* Count and relocate all other linenumbers.  */
 845       count++;
 846       while (lineno[count].line_number != 0)
 847         {
 848 #if 0
 849           /* 13 april 92. sac
 850              I've been told this, but still need proof:
 851              > The second bug is also in `bfd/coffcode.h'.  This bug
 852              > causes the linker to screw up the pc-relocations for
 853              > all the line numbers in COFF code.  This bug isn't only
 854              > specific to A29K implementations, but affects all
 855              > systems using COFF format binaries.  Note that in COFF
 856              > object files, the line number core offsets output by
 857              > the assembler are relative to the start of each
 858              > procedure, not to the start of the .text section.  This
 859              > patch relocates the line numbers relative to the
 860              > `native->u.syment.n_value' instead of the section
 861              > virtual address.
 862              > [email protected] (Jon Olson)
 863              */
 864           lineno[count].u.offset += native->u.syment.n_value;
 865 #else
 866           lineno[count].u.offset +=
 867             (symbol->symbol.section->output_section->vma
 868              + symbol->symbol.section->output_offset);
 869 #endif
 870           count++;
 871         }
 872       symbol->done_lineno = true;
 873
 874       symbol->symbol.section->output_section->moving_line_filepos +=
 875         count * bfd_coff_linesz (abfd);
 876     }
 877
 878   return coff_write_symbol (abfd, &(symbol->symbol), native, written);
 879 }
 880
 881 /* Write out the COFF symbols.  */
 882
 883 boolean
 884 coff_write_symbols (abfd)
 885      bfd *abfd;
 886 {
 887   unsigned int i;
 888   unsigned int limit = bfd_get_symcount(abfd);
 889   unsigned int written = 0;
 890   asymbol **p;
 891
 892   string_size = 0;
 893   debug_string_size = 0;
 894
 895   /* Seek to the right place */
 896   if (bfd_seek (abfd, obj_sym_filepos(abfd), SEEK_SET) != 0)
 897     return false;
 898
 899   /* Output all the symbols we have */
 900
 901   written = 0;
 902   for (p = abfd->outsymbols, i = 0; i < limit; i++, p++)
 903     {
 904       asymbol *symbol = *p;
 905       coff_symbol_type *c_symbol = coff_symbol_from (abfd, symbol);
 906
 907       if (c_symbol == (coff_symbol_type *) NULL
 908           || c_symbol->native == (combined_entry_type *)NULL)
 909         {
 910           if (! coff_write_alien_symbol (abfd, symbol, &written))
 911             return false;
 912         }
 913       else
 914         {
 915           if (! coff_write_native_symbol (abfd, c_symbol, &written))
 916             return false;
 917         }
 918     }
 919
 920   obj_raw_syment_count (abfd) = written;
 921
 922   /* Now write out strings */
 923
 924   if (string_size != 0)
 925    {
 926      unsigned int size = string_size + STRING_SIZE_SIZE;
 927      bfd_byte buffer[STRING_SIZE_SIZE];
 928
 929 #if STRING_SIZE_SIZE == 4
 930      bfd_h_put_32 (abfd, size, buffer);
 931 #else
 932  #error Change bfd_h_put_32
 933 #endif
 934      if (bfd_write ((PTR) buffer, 1, sizeof (buffer), abfd) != sizeof (buffer))
 935        return false;
 936      for (p = abfd->outsymbols, i = 0;
 937           i < limit;
 938           i++, p++)
 939        {
 940          asymbol *q = *p;
 941          size_t name_length = strlen (q->name);
 942          coff_symbol_type *c_symbol = coff_symbol_from (abfd, q);
 943          size_t maxlen;
 944
 945          /* Figure out whether the symbol name should go in the string
 946             table.  Symbol names that are short enough are stored
 947             directly in the syment structure.  File names permit a
 948             different, longer, length in the syment structure.  On
 949             XCOFF, some symbol names are stored in the .debug section
 950             rather than in the string table.  */
 951
 952          if (c_symbol == NULL
 953              || c_symbol->native == NULL)
 954            {
 955              /* This is not a COFF symbol, so it certainly is not a
 956                 file name, nor does it go in the .debug section.  */
 957              maxlen = SYMNMLEN;
 958            }
 959          else if (bfd_coff_symname_in_debug (abfd,
 960                                              &c_symbol->native->u.syment))
 961            {
 962              /* This symbol name is in the XCOFF .debug section.
 963                 Don't write it into the string table.  */
 964              maxlen = name_length;
 965            }
 966          else if (c_symbol->native->u.syment.n_sclass == C_FILE)
 967            maxlen = FILNMLEN;
 968          else
 969            maxlen = SYMNMLEN;
 970
 971          if (name_length > maxlen)
 972            {
 973              if (bfd_write ((PTR) (q->name), 1, name_length + 1, abfd)
 974                  != name_length + 1)
 975                return false;
 976            }
 977        }
 978    }
 979   else
 980     {
 981       /* We would normally not write anything here, but we'll write
 982          out 4 so that any stupid coff reader which tries to read the
 983          string table even when there isn't one won't croak.  */
 984       unsigned int size = STRING_SIZE_SIZE;
 985       bfd_byte buffer[STRING_SIZE_SIZE];
 986
 987 #if STRING_SIZE_SIZE == 4
 988       bfd_h_put_32 (abfd, size, buffer);
 989 #else
 990  #error Change bfd_h_put_32
 991 #endif
 992       if (bfd_write ((PTR) buffer, 1, STRING_SIZE_SIZE, abfd)
 993           != STRING_SIZE_SIZE)
 994         return false;
 995     }
 996
 997   /* Make sure the .debug section was created to be the correct size.
 998      We should create it ourselves on the fly, but we don't because
 999      BFD won't let us write to any section until we know how large all
1000      the sections are.  We could still do it by making another pass
1001      over the symbols.  FIXME.  */
1002   BFD_ASSERT (debug_string_size == 0
1003               || (debug_string_section != (asection *) NULL
1004                   && (BFD_ALIGN (debug_string_size,
1005                                  1 << debug_string_section->alignment_power)
1006                       == bfd_section_size (abfd, debug_string_section))));
1007
1008   return true;
1009 }
1010
1011 boolean
1012 coff_write_linenumbers (abfd)
1013      bfd            *abfd;
1014 {
1015   asection       *s;
1016   bfd_size_type linesz;
1017   PTR buff;
1018
1019   linesz = bfd_coff_linesz (abfd);
1020   buff = bfd_alloc (abfd, linesz);
1021   if (!buff)
1022     {
1023       bfd_set_error (bfd_error_no_memory);
1024       return false;
1025     }
1026   for (s = abfd->sections; s != (asection *) NULL; s = s->next) {
1027     if (s->lineno_count) {
1028       asymbol       **q = abfd->outsymbols;
1029       if (bfd_seek(abfd, s->line_filepos, SEEK_SET) != 0)
1030         return false;
1031       /* Find all the linenumbers in this section */
1032       while (*q) {
1033         asymbol        *p = *q;
1034         if (p->section->output_section == s) {
1035           alent          *l =
1036            BFD_SEND(bfd_asymbol_bfd(p), _get_lineno, (bfd_asymbol_bfd(p), p));
1037           if (l) {
1038             /* Found a linenumber entry, output */
1039             struct internal_lineno  out;
1040             memset( (PTR)&out, 0, sizeof(out));
1041             out.l_lnno = 0;
1042             out.l_addr.l_symndx = l->u.offset;
1043             bfd_coff_swap_lineno_out(abfd, &out, buff);
1044             if (bfd_write(buff, 1, linesz, abfd) != linesz)
1045               return false;
1046             l++;
1047             while (l->line_number) {
1048               out.l_lnno = l->line_number;
1049               out.l_addr.l_symndx = l->u.offset;
1050               bfd_coff_swap_lineno_out(abfd, &out, buff);
1051               if (bfd_write(buff, 1, linesz, abfd) != linesz)
1052                 return false;
1053               l++;
1054             }
1055           }
1056         }
1057         q++;
1058       }
1059     }
1060   }
1061   bfd_release (abfd, buff);
1062   return true;
1063 }
1064
1065 /*ARGSUSED*/
1066 alent   *
1067 coff_get_lineno (ignore_abfd, symbol)
1068      bfd            *ignore_abfd;
1069      asymbol        *symbol;
1070 {
1071   return coffsymbol(symbol)->lineno;
1072 }
1073
1074 asymbol *
1075 coff_section_symbol (abfd, name)
1076      bfd *abfd;
1077      char *name;
1078 {
1079   asection *sec = bfd_make_section_old_way (abfd, name);
1080   asymbol *sym;
1081   combined_entry_type *csym;
1082
1083   sym = sec->symbol;
1084   csym = coff_symbol_from (abfd, sym)->native;
1085   /* Make sure back-end COFF stuff is there.  */
1086   if (csym == 0)
1087     {
1088       struct foo {
1089         coff_symbol_type sym;
1090         /* @@FIXME This shouldn't use a fixed size!!  */
1091         combined_entry_type e[10];
1092       };
1093       struct foo *f;
1094       f = (struct foo *) bfd_alloc_by_size_t (abfd, sizeof (*f));
1095       if (!f)
1096         {
1097           bfd_set_error (bfd_error_no_error);
1098           return NULL;
1099         }
1100       memset ((char *) f, 0, sizeof (*f));
1101       coff_symbol_from (abfd, sym)->native = csym = f->e;
1102     }
1103   csym[0].u.syment.n_sclass = C_STAT;
1104   csym[0].u.syment.n_numaux = 1;
1105 /*  SF_SET_STATICS (sym);       @@ ??? */
1106   csym[1].u.auxent.x_scn.x_scnlen = sec->_raw_size;
1107   csym[1].u.auxent.x_scn.x_nreloc = sec->reloc_count;
1108   csym[1].u.auxent.x_scn.x_nlinno = sec->lineno_count;
1109
1110   if (sec->output_section == NULL)
1111     {
1112       sec->output_section = sec;
1113       sec->output_offset = 0;
1114     }
1115
1116   return sym;
1117 }
1118
1119 /* This function transforms the offsets into the symbol table into
1120    pointers to syments.  */
1121
1122 static void
1123 coff_pointerize_aux (abfd, table_base, type, class, auxent)
1124      bfd *abfd;
1125      combined_entry_type *table_base;
1126      int type;
1127      int class;
1128      combined_entry_type *auxent;
1129 {
1130   /* Don't bother if this is a file or a section */
1131   if (class == C_STAT && type == T_NULL) return;
1132   if (class == C_FILE) return;
1133
1134   /* Otherwise patch up */
1135 #define N_TMASK coff_data (abfd)->local_n_tmask
1136 #define N_BTSHFT coff_data (abfd)->local_n_btshft
1137   if ((ISFCN(type) || ISTAG(class) || class == C_BLOCK)
1138       && auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l > 0)
1139     {
1140       auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p =
1141         (table_base
1142          + auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l);
1143       auxent->fix_end = 1;
1144     }
1145   /* A negative tagndx is meaningless, but the SCO 3.2v4 cc can
1146      generate one, so we must be careful to ignore it.  */
1147   if (auxent->u.auxent.x_sym.x_tagndx.l > 0) {
1148       auxent->u.auxent.x_sym.x_tagndx.p =
1149        table_base +  auxent->u.auxent.x_sym.x_tagndx.l;
1150       auxent->fix_tag = 1;
1151     }
1152 }
1153
1154 static char *
1155 build_string_table (abfd)
1156      bfd *abfd;
1157 {
1158   char string_table_size_buffer[STRING_SIZE_SIZE];
1159   unsigned int string_table_size;
1160   char *string_table;
1161
1162   /* At this point we should be "seek"'d to the end of the
1163      symbols === the symbol table size.  */
1164   if (bfd_read((char *) string_table_size_buffer,
1165                sizeof(string_table_size_buffer),
1166                1, abfd) != sizeof(string_table_size))
1167     return (NULL);
1168
1169 #if STRING_SIZE_SIZE == 4
1170   string_table_size = bfd_h_get_32(abfd, (bfd_byte *) string_table_size_buffer);
1171 #else
1172  #error Change bfd_h_get_32
1173 #endif
1174
1175   if ((string_table = (PTR) bfd_alloc(abfd,
1176                                       string_table_size -= STRING_SIZE_SIZE))
1177       == NULL)
1178     {
1179       bfd_set_error (bfd_error_no_memory);
1180       return (NULL);
1181     }                           /* on mallocation error */
1182   if (bfd_read(string_table, string_table_size, 1, abfd) != string_table_size)
1183     return (NULL);
1184   return string_table;
1185 }
1186
1187 /* Allocate space for the ".debug" section, and read it.
1188    We did not read the debug section until now, because
1189    we didn't want to go to the trouble until someone needed it. */
1190
1191 static char *
1192 build_debug_section (abfd)
1193      bfd *abfd;
1194 {
1195   char *debug_section;
1196   long position;
1197
1198   asection *sect = bfd_get_section_by_name (abfd, ".debug");
1199
1200   if (!sect) {
1201      bfd_set_error (bfd_error_no_debug_section);
1202      return NULL;
1203   }
1204
1205   debug_section = (PTR) bfd_alloc (abfd,
1206                                    bfd_get_section_size_before_reloc (sect));
1207   if (debug_section == NULL) {
1208     bfd_set_error (bfd_error_no_memory);
1209     return NULL;
1210   }
1211
1212   /* Seek to the beginning of the `.debug' section and read it.
1213      Save the current position first; it is needed by our caller.
1214      Then read debug section and reset the file pointer.  */
1215
1216   position = bfd_tell (abfd);
1217   if (bfd_seek (abfd, sect->filepos, SEEK_SET) != 0
1218       || (bfd_read (debug_section,
1219                     bfd_get_section_size_before_reloc (sect), 1, abfd)
1220           != bfd_get_section_size_before_reloc(sect))
1221       || bfd_seek (abfd, position, SEEK_SET) != 0)
1222     return NULL;
1223   return debug_section;
1224 }
1225
1226
1227 /* Return a pointer to a malloc'd copy of 'name'.  'name' may not be
1228  \0-terminated, but will not exceed 'maxlen' characters.  The copy *will*
1229  be \0-terminated.  */
1230 static char *
1231 copy_name (abfd, name, maxlen)
1232      bfd *abfd;
1233      char *name;
1234      int maxlen;
1235 {
1236   int  len;
1237   char *newname;
1238
1239   for (len = 0; len < maxlen; ++len) {
1240     if (name[len] == '\0') {
1241       break;
1242     }
1243   }
1244
1245   if ((newname = (PTR) bfd_alloc(abfd, len+1)) == NULL) {
1246     bfd_set_error (bfd_error_no_memory);
1247     return (NULL);
1248   }
1249   strncpy(newname, name, len);
1250   newname[len] = '\0';
1251   return newname;
1252 }
1253
1254 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
1255    knit the symbol names into a normalized form.  By normalized here I
1256    mean that all symbols have an n_offset pointer that points to a null-
1257    terminated string.  */
1258
1259 combined_entry_type *
1260 coff_get_normalized_symtab (abfd)
1261      bfd            *abfd;
1262 {
1263   combined_entry_type          *internal;
1264   combined_entry_type          *internal_ptr;
1265   combined_entry_type          *symbol_ptr;
1266   combined_entry_type         *internal_end;
1267   bfd_size_type symesz;
1268   PTR raw;
1269   char *raw_src;
1270   char *raw_end;
1271   char           *string_table = NULL;
1272   char           *debug_section = NULL;
1273   unsigned long   size;
1274   unsigned int raw_size;
1275
1276   if (obj_raw_syments (abfd) != NULL)
1277     return obj_raw_syments (abfd);
1278
1279   size = obj_raw_syment_count (abfd) * sizeof (combined_entry_type);
1280   internal = (combined_entry_type *) bfd_alloc (abfd, size);
1281   if (internal == NULL && size != 0)
1282     {
1283       bfd_set_error (bfd_error_no_memory);
1284       return NULL;
1285     }
1286   internal_end = internal + obj_raw_syment_count (abfd);
1287
1288   symesz = bfd_coff_symesz (abfd);
1289   raw_size = obj_raw_syment_count (abfd) * symesz;
1290   raw = bfd_alloc (abfd, raw_size);
1291   if (raw == NULL && raw_size != 0)
1292     {
1293       bfd_set_error (bfd_error_no_memory);
1294       return NULL;
1295     }
1296
1297   if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) == -1
1298       || bfd_read (raw, raw_size, 1, abfd) != raw_size)
1299     return NULL;
1300
1301   /* mark the end of the symbols */
1302   raw_end = (char *) raw + obj_raw_syment_count (abfd) * symesz;
1303
1304   /*
1305     FIXME SOMEDAY.  A string table size of zero is very weird, but
1306     probably possible.  If one shows up, it will probably kill us.
1307     */
1308
1309   /* Swap all the raw entries */
1310   for (raw_src = (char *) raw, internal_ptr = internal;
1311        raw_src < raw_end;
1312        raw_src += symesz, internal_ptr++) {
1313
1314       unsigned int i;
1315       bfd_coff_swap_sym_in(abfd, (PTR)raw_src, (PTR)&internal_ptr->u.syment);
1316       internal_ptr->fix_value = 0;
1317       internal_ptr->fix_tag = 0;
1318       internal_ptr->fix_end = 0;
1319       internal_ptr->fix_scnlen = 0;
1320       symbol_ptr = internal_ptr;
1321
1322       for (i = 0;
1323            i < symbol_ptr->u.syment.n_numaux;
1324            i++)
1325       {
1326         internal_ptr++;
1327         raw_src += symesz;
1328
1329         internal_ptr->fix_value = 0;
1330         internal_ptr->fix_tag = 0;
1331         internal_ptr->fix_end = 0;
1332         internal_ptr->fix_scnlen = 0;
1333         bfd_coff_swap_aux_in(abfd, (PTR) raw_src,
1334                              symbol_ptr->u.syment.n_type,
1335                              symbol_ptr->u.syment.n_sclass,
1336                              i, symbol_ptr->u.syment.n_numaux,
1337                              &(internal_ptr->u.auxent));
1338         /* Remember that bal entries arn't pointerized */
1339         if (i != 1 || symbol_ptr->u.syment.n_sclass != C_LEAFPROC)
1340         {
1341
1342         coff_pointerize_aux(abfd,
1343                             internal,
1344                             symbol_ptr->u.syment.n_type,
1345                             symbol_ptr->u.syment.n_sclass,
1346                             internal_ptr);
1347       }
1348
1349       }
1350     }
1351
1352   /* Free all the raw stuff */
1353   if (raw != NULL)
1354     bfd_release (abfd, raw);
1355
1356   for (internal_ptr = internal; internal_ptr < internal_end;
1357        internal_ptr ++)
1358   {
1359     if (internal_ptr->u.syment.n_sclass == C_FILE
1360         && internal_ptr->u.syment.n_numaux > 0) {
1361         /* make a file symbol point to the name in the auxent, since
1362            the text ".file" is redundant */
1363         if ((internal_ptr+1)->u.auxent.x_file.x_n.x_zeroes == 0) {
1364             /* the filename is a long one, point into the string table */
1365             if (string_table == NULL) {
1366                 string_table = build_string_table(abfd);
1367               }
1368
1369             internal_ptr->u.syment._n._n_n._n_offset =
1370              (long) (string_table - STRING_SIZE_SIZE +
1371                     (internal_ptr+1)->u.auxent.x_file.x_n.x_offset);
1372           }
1373         else {
1374             /* ordinary short filename, put into memory anyway */
1375             internal_ptr->u.syment._n._n_n._n_offset = (long)
1376              copy_name(abfd, (internal_ptr+1)->u.auxent.x_file.x_fname,
1377                        FILNMLEN);
1378           }
1379       }
1380     else {
1381         if (internal_ptr->u.syment._n._n_n._n_zeroes != 0) {
1382             /* This is a "short" name.  Make it long.  */
1383             unsigned long   i = 0;
1384             char           *newstring = NULL;
1385
1386             /* find the length of this string without walking into memory
1387                that isn't ours.  */
1388             for (i = 0; i < 8; ++i) {
1389                 if (internal_ptr->u.syment._n._n_name[i] == '\0') {
1390                     break;
1391                   }             /* if end of string */
1392               }                 /* possible lengths of this string. */
1393
1394             if ((newstring = (PTR) bfd_alloc(abfd, ++i)) == NULL) {
1395                 bfd_set_error (bfd_error_no_memory);
1396                 return (NULL);
1397               }                 /* on error */
1398             memset(newstring, 0, i);
1399             strncpy(newstring, internal_ptr->u.syment._n._n_name, i-1);
1400             internal_ptr->u.syment._n._n_n._n_offset =  (long int) newstring;
1401             internal_ptr->u.syment._n._n_n._n_zeroes = 0;
1402           }
1403         else if (internal_ptr->u.syment._n._n_n._n_offset == 0)
1404           internal_ptr->u.syment._n._n_n._n_offset = (long int) "";
1405         else if (!bfd_coff_symname_in_debug(abfd, &internal_ptr->u.syment)) {
1406             /* Long name already.  Point symbol at the string in the table.  */
1407             if (string_table == NULL) {
1408                 string_table = build_string_table(abfd);
1409               }
1410             internal_ptr->u.syment._n._n_n._n_offset = (long int)
1411              (string_table
1412               - STRING_SIZE_SIZE
1413               + internal_ptr->u.syment._n._n_n._n_offset);
1414           }
1415         else {
1416             /* Long name in debug section.  Very similar.  */
1417             if (debug_section == NULL) {
1418                 debug_section = build_debug_section(abfd);
1419               }
1420             internal_ptr->u.syment._n._n_n._n_offset = (long int)
1421              (debug_section + internal_ptr->u.syment._n._n_n._n_offset);
1422           }
1423       }
1424     internal_ptr += internal_ptr->u.syment.n_numaux;
1425   }
1426
1427   obj_raw_syments(abfd) = internal;
1428   BFD_ASSERT (obj_raw_syment_count (abfd) == internal_ptr - internal);
1429
1430   return (internal);
1431 }                               /* coff_get_normalized_symtab() */
1432
1433 long
1434 coff_get_reloc_upper_bound (abfd, asect)
1435      bfd            *abfd;
1436      sec_ptr         asect;
1437 {
1438   if (bfd_get_format(abfd) != bfd_object) {
1439     bfd_set_error (bfd_error_invalid_operation);
1440     return -1;
1441   }
1442   return (asect->reloc_count + 1) * sizeof(arelent *);
1443 }
1444
1445 asymbol *
1446 coff_make_empty_symbol (abfd)
1447      bfd            *abfd;
1448 {
1449   coff_symbol_type *new = (coff_symbol_type *) bfd_alloc(abfd, sizeof(coff_symbol_type));
1450   if (new == NULL) {
1451     bfd_set_error (bfd_error_no_memory);
1452     return (NULL);
1453   }                             /* on error */
1454   memset (new, 0, sizeof *new);
1455   new->symbol.section = 0;
1456   new->native = 0;
1457   new->lineno = (alent *) NULL;
1458   new->done_lineno = false;
1459   new->symbol.the_bfd = abfd;
1460   return &new->symbol;
1461 }
1462
1463 /* Make a debugging symbol.  */
1464
1465 asymbol *
1466 coff_bfd_make_debug_symbol (abfd, ptr, sz)
1467      bfd *abfd;
1468      PTR ptr;
1469      unsigned long sz;
1470 {
1471   coff_symbol_type *new = (coff_symbol_type *) bfd_alloc(abfd, sizeof(coff_symbol_type));
1472   if (new == NULL) {
1473     bfd_set_error (bfd_error_no_memory);
1474     return (NULL);
1475   }                             /* on error */
1476   /* @@ This shouldn't be using a constant multiplier.  */
1477   new->native = (combined_entry_type *) bfd_zalloc (abfd, sizeof (combined_entry_type) * 10);
1478   if (!new->native)
1479     {
1480       bfd_set_error (bfd_error_no_memory);
1481       return (NULL);
1482     }                           /* on error */
1483   new->symbol.section = &bfd_debug_section;
1484   new->lineno = (alent *) NULL;
1485   new->done_lineno = false;
1486   new->symbol.the_bfd = abfd;
1487   return &new->symbol;
1488 }
1489
1490 /*ARGSUSED*/
1491 void
1492 coff_get_symbol_info (abfd, symbol, ret)
1493      bfd *abfd;
1494      asymbol *symbol;
1495      symbol_info *ret;
1496 {
1497   bfd_symbol_info (symbol, ret);
1498 }
1499
1500 /* Print out information about COFF symbol.  */
1501
1502 void
1503 coff_print_symbol (abfd, filep, symbol, how)
1504      bfd *abfd;
1505      PTR filep;
1506      asymbol *symbol;
1507      bfd_print_symbol_type how;
1508 {
1509   FILE *file = (FILE *) filep;
1510
1511   switch (how)
1512     {
1513     case bfd_print_symbol_name:
1514       fprintf (file, "%s", symbol->name);
1515       break;
1516
1517     case bfd_print_symbol_more:
1518       fprintf (file, "coff %s %s",
1519                coffsymbol(symbol)->native ? "n" : "g",
1520                coffsymbol(symbol)->lineno ? "l" : " ");
1521       break;
1522
1523     case bfd_print_symbol_all:
1524       if (coffsymbol(symbol)->native)
1525         {
1526           unsigned int aux;
1527           combined_entry_type *combined = coffsymbol (symbol)->native;
1528           combined_entry_type *root = obj_raw_syments (abfd);
1529           struct lineno_cache_entry *l = coffsymbol(symbol)->lineno;
1530
1531           fprintf (file,"[%3ld]", (long) (combined - root));
1532
1533           fprintf (file,
1534                    "(sc %2d)(fl 0x%02x)(ty %3x)(sc %3d) (nx %d) 0x%08lx %s",
1535                    combined->u.syment.n_scnum,
1536                    combined->u.syment.n_flags,
1537                    combined->u.syment.n_type,
1538                    combined->u.syment.n_sclass,
1539                    combined->u.syment.n_numaux,
1540                    (unsigned long) combined->u.syment.n_value,
1541                    symbol->name);
1542
1543           for (aux = 0; aux < combined->u.syment.n_numaux; aux++)
1544             {
1545               combined_entry_type *auxp = combined + aux + 1;
1546               long tagndx;
1547
1548               if (auxp->fix_tag)
1549                 tagndx = auxp->u.auxent.x_sym.x_tagndx.p - root;
1550               else
1551                 tagndx = auxp->u.auxent.x_sym.x_tagndx.l;
1552
1553               fprintf (file, "\n");
1554               switch (combined->u.syment.n_sclass)
1555                 {
1556                 case C_FILE:
1557                   fprintf (file, "File ");
1558                   break;
1559
1560                 case C_STAT:
1561                   if (combined->u.syment.n_type == T_NULL)
1562                     /* probably a section symbol? */
1563                     {
1564                       fprintf (file, "AUX scnlen 0x%lx nreloc %d nlnno %d",
1565                                (long) auxp->u.auxent.x_scn.x_scnlen,
1566                                auxp->u.auxent.x_scn.x_nreloc,
1567                                auxp->u.auxent.x_scn.x_nlinno);
1568                       break;
1569                     }
1570                   /* else fall through */
1571
1572                 default:
1573                   fprintf (file, "AUX lnno %d size 0x%x tagndx %ld",
1574                            auxp->u.auxent.x_sym.x_misc.x_lnsz.x_lnno,
1575                            auxp->u.auxent.x_sym.x_misc.x_lnsz.x_size,
1576                            tagndx);
1577                   if (auxp->fix_end)
1578                     fprintf (file, " endndx %ld",
1579                              ((long)
1580                               (auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p
1581                                - root)));
1582                   break;
1583                 }
1584             }
1585
1586           if (l)
1587             {
1588               fprintf (file, "\n%s :", l->u.sym->name);
1589               l++;
1590               while (l->line_number)
1591                 {
1592                   fprintf (file, "\n%4d : 0x%lx",
1593                            l->line_number,
1594                            ((unsigned long)
1595                             (l->u.offset + symbol->section->vma)));
1596                   l++;
1597                 }
1598             }
1599         }
1600       else
1601         {
1602           bfd_print_symbol_vandf ((PTR) file, symbol);
1603           fprintf (file, " %-5s %s %s %s",
1604                    symbol->section->name,
1605                    coffsymbol(symbol)->native ? "n" : "g",
1606                    coffsymbol(symbol)->lineno ? "l" : " ",
1607                    symbol->name);
1608         }
1609     }
1610 }
1611
1612 /* Provided a BFD, a section and an offset into the section, calculate
1613    and return the name of the source file and the line nearest to the
1614    wanted location.  */
1615
1616 /*ARGSUSED*/
1617 boolean
1618 coff_find_nearest_line (abfd, section, ignore_symbols, offset, filename_ptr,
1619                         functionname_ptr, line_ptr)
1620      bfd            *abfd;
1621      asection       *section;
1622      asymbol       **ignore_symbols;
1623      bfd_vma         offset;
1624      CONST char      **filename_ptr;
1625      CONST char       **functionname_ptr;
1626      unsigned int   *line_ptr;
1627 {
1628   static bfd     *cache_abfd;
1629   static asection *cache_section;
1630   static bfd_vma  cache_offset;
1631   static unsigned int cache_i;
1632   static CONST char *cache_function;
1633   static unsigned int    line_base = 0;
1634
1635   unsigned int i;
1636   coff_data_type *cof = coff_data(abfd);
1637   /* Run through the raw syments if available */
1638   combined_entry_type *p;
1639   combined_entry_type *pend;
1640   alent          *l;
1641
1642
1643   *filename_ptr = 0;
1644   *functionname_ptr = 0;
1645   *line_ptr = 0;
1646
1647   /* Don't try and find line numbers in a non coff file */
1648   if (abfd->xvec->flavour != bfd_target_coff_flavour)
1649     return false;
1650
1651   if (cof == NULL)
1652     return false;
1653
1654   /* Find the first C_FILE symbol.  */
1655   p = cof->raw_syments;
1656   pend = p + cof->raw_syment_count;
1657   while (p < pend)
1658     {
1659       if (p->u.syment.n_sclass == C_FILE)
1660         break;
1661       p += 1 + p->u.syment.n_numaux;
1662     }
1663
1664   if (p < pend)
1665     {
1666       bfd_vma maxdiff;
1667
1668       /* Look through the C_FILE symbols to find the best one.  */
1669       *filename_ptr = (char *) p->u.syment._n._n_n._n_offset;
1670       maxdiff = (bfd_vma) 0 - (bfd_vma) 1;
1671       while (1)
1672         {
1673           combined_entry_type *p2;
1674
1675           for (p2 = p + 1 + p->u.syment.n_numaux;
1676                p2 < pend;
1677                p2 += 1 + p2->u.syment.n_numaux)
1678             {
1679               if (p2->u.syment.n_scnum > 0
1680                   && (section
1681                       == coff_section_from_bfd_index (abfd,
1682                                                       p2->u.syment.n_scnum)))
1683                 break;
1684               if (p2->u.syment.n_sclass == C_FILE)
1685                 {
1686                   p2 = pend;
1687                   break;
1688                 }
1689             }
1690
1691           if (p2 < pend
1692               && offset >= p2->u.syment.n_value
1693               && offset - p2->u.syment.n_value < maxdiff)
1694             {
1695               *filename_ptr = (char *) p->u.syment._n._n_n._n_offset;
1696               maxdiff = offset - p2->u.syment.n_value;
1697             }
1698
1699           /* Avoid endless loops on erroneous files by ensuring that
1700              we always move forward in the file.  */
1701           if (p - cof->raw_syments >= p->u.syment.n_value)
1702             break;
1703
1704           p = cof->raw_syments + p->u.syment.n_value;
1705           if (p > pend || p->u.syment.n_sclass != C_FILE)
1706             break;
1707         }
1708     }
1709
1710   /* Now wander though the raw linenumbers of the section */
1711   /*
1712     If this is the same BFD as we were previously called with and this is
1713     the same section, and the offset we want is further down then we can
1714     prime the lookup loop
1715     */
1716   if (abfd == cache_abfd &&
1717       section == cache_section &&
1718       offset >= cache_offset) {
1719     i = cache_i;
1720     *functionname_ptr = cache_function;
1721   }
1722   else {
1723     i = 0;
1724   }
1725   l = &section->lineno[i];
1726
1727   for (; i < section->lineno_count; i++) {
1728     if (l->line_number == 0) {
1729       /* Get the symbol this line number points at */
1730       coff_symbol_type *coff = (coff_symbol_type *) (l->u.sym);
1731       if (coff->symbol.value > offset)
1732         break;
1733       *functionname_ptr = coff->symbol.name;
1734       if (coff->native) {
1735         combined_entry_type  *s = coff->native;
1736         s = s + 1 + s->u.syment.n_numaux;
1737
1738         /* In XCOFF a debugging symbol can follow the function
1739            symbol.  */
1740         if (s->u.syment.n_scnum == N_DEBUG)
1741           s = s + 1 + s->u.syment.n_numaux;
1742
1743         /*
1744           S should now point to the .bf of the function
1745           */
1746         if (s->u.syment.n_numaux) {
1747           /*
1748             The linenumber is stored in the auxent
1749             */
1750           union internal_auxent   *a = &((s + 1)->u.auxent);
1751           line_base = a->x_sym.x_misc.x_lnsz.x_lnno;
1752           *line_ptr = line_base;
1753         }
1754       }
1755     }
1756     else {
1757       if (l->u.offset + bfd_get_section_vma (abfd, section) > offset)
1758         break;
1759       *line_ptr = l->line_number + line_base - 1;
1760     }
1761     l++;
1762   }
1763
1764   cache_abfd = abfd;
1765   cache_section = section;
1766   cache_offset = offset;
1767   cache_i = i;
1768   cache_function = *functionname_ptr;
1769
1770   return true;
1771 }
1772
1773 int
1774 coff_sizeof_headers (abfd, reloc)
1775      bfd *abfd;
1776      boolean reloc;
1777 {
1778     size_t size;
1779
1780     if (reloc == false) {
1781         size = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
1782     }
1783     else {
1784         size = bfd_coff_filhsz (abfd);
1785     }
1786
1787     size +=  abfd->section_count * bfd_coff_scnhsz (abfd);
1788     return size;
1789 }