* coffgen.c: Reindented.
authorIan Lance Taylor <ian@airs.com>
Fri, 17 Feb 1995 16:46:52 +0000 (16:46 +0000)
committerIan Lance Taylor <ian@airs.com>
Fri, 17 Feb 1995 16:46:52 +0000 (16:46 +0000)
bfd/ChangeLog
bfd/coffgen.c

index 634376fc265c3b8a30fdc517674d65c1ae538884..f2ed3c32c9a21e6da0fdfadbb7b4457ca3844e2a 100644 (file)
@@ -1,3 +1,7 @@
+Fri Feb 17 11:45:38 1995  Ian Lance Taylor  <ian@cygnus.com>
+
+       * coffgen.c: Reindented.
+
 Thu Feb 16 14:37:23 1995  Doug Evans  <dje@cygnus.com>
 
        * reloc.c (bfd_perform_relocation): Don't use bitpos in overflow
index c6cf11baacd9ec1ab7ed9e4a71ff2120a02868f4..bdea220a15f5368881f554b2a521232db79e12b9 100644 (file)
@@ -1,5 +1,5 @@
 /* Support for the generic parts of COFF, for BFD.
-   Copyright 1990, 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
+   Copyright 1990, 91, 92, 93, 94, 1995 Free Software Foundation, Inc.
    Written by Cygnus Support.
 
 This file is part of BFD, the Binary File Descriptor library.
@@ -49,31 +49,30 @@ static boolean coff_write_alien_symbol PARAMS ((bfd *, asymbol *,
 static boolean coff_write_native_symbol PARAMS ((bfd *, coff_symbol_type *,
                                                 unsigned int *));
 
-static asection bfd_debug_section = { "*DEBUG*" };
-
 #define STRING_SIZE_SIZE (4)
 
 /* Take a section header read from a coff file (in HOST byte order),
    and make a BFD "section" out of it.  This is used by ECOFF.  */
-static          boolean
+static boolean
 make_a_section_from_file (abfd, hdr, target_index)
-     bfd            *abfd;
-     struct internal_scnhdr  *hdr;
+     bfd *abfd;
+     struct internal_scnhdr *hdr;
      unsigned int target_index;
 {
-  asection       *return_section;
+  asection *return_section;
   char *name;
-    
+
   /* Assorted wastage to null-terminate the name, thanks AT&T! */
-  name = bfd_alloc(abfd, sizeof (hdr->s_name)+1);
-  if (name == NULL) {
+  name = bfd_alloc (abfd, sizeof (hdr->s_name) + 1);
+  if (name == NULL)
+    {
       bfd_set_error (bfd_error_no_memory);
       return false;
     }
-  strncpy(name, (char *) &hdr->s_name[0], sizeof (hdr->s_name));
+  strncpy (name, (char *) &hdr->s_name[0], sizeof (hdr->s_name));
   name[sizeof (hdr->s_name)] = 0;
 
-  return_section = bfd_make_section(abfd, name);
+  return_section = bfd_make_section (abfd, name);
   if (return_section == NULL)
     return_section = bfd_coff_make_section_hook (abfd, name);
 
@@ -91,12 +90,12 @@ make_a_section_from_file (abfd, hdr, target_index)
   return_section->vma = hdr->s_vaddr;
   return_section->_raw_size = hdr->s_size;
   return_section->filepos = hdr->s_scnptr;
-  return_section->rel_filepos =  hdr->s_relptr;
+  return_section->rel_filepos = hdr->s_relptr;
   return_section->reloc_count = hdr->s_nreloc;
 
   bfd_coff_set_alignment_hook (abfd, return_section, hdr);
 
-  return_section->line_filepos =  hdr->s_lnnoptr;
+  return_section->line_filepos = hdr->s_lnnoptr;
 
   return_section->lineno_count = hdr->s_nlnno;
   return_section->userdata = NULL;
@@ -123,13 +122,13 @@ make_a_section_from_file (abfd, hdr, target_index)
 
 static const bfd_target *
 coff_real_object_p (abfd, nscns, internal_f, internal_a)
-     bfd            *abfd;
-     unsigned        nscns;
+     bfd *abfd;
+     unsigned nscns;
      struct internal_filehdr *internal_f;
      struct internal_aouthdr *internal_a;
 {
   PTR tdata;
-  size_t          readsize;    /* length of file_info */
+  size_t readsize;             /* length of file_info */
   unsigned int scnhsz;
   char *external_sections;
 
@@ -140,30 +139,31 @@ coff_real_object_p (abfd, nscns, internal_f, internal_a)
 
   scnhsz = bfd_coff_scnhsz (abfd);
   readsize = nscns * scnhsz;
-  external_sections = (char *)bfd_alloc(abfd, readsize);
+  external_sections = (char *) bfd_alloc (abfd, readsize);
   if (!external_sections)
     {
       bfd_set_error (bfd_error_no_memory);
       goto fail;
     }
 
-  if (bfd_read((PTR)external_sections, 1, readsize, abfd) != readsize) {
+  if (bfd_read ((PTR) external_sections, 1, readsize, abfd) != readsize)
     goto fail;
-  }
 
   /* Now copy data as required; construct all asections etc */
-  if (nscns != 0) {
-    unsigned int    i;
-    for (i = 0; i < nscns; i++) {
-      struct internal_scnhdr tmp;
-      bfd_coff_swap_scnhdr_in(abfd, (PTR) (external_sections + i * scnhsz),
-                             (PTR) &tmp);
-      make_a_section_from_file(abfd,&tmp, i+1);
+  if (nscns != 0)
+    {
+      unsigned int i;
+      for (i = 0; i < nscns; i++)
+       {
+         struct internal_scnhdr tmp;
+         bfd_coff_swap_scnhdr_in (abfd, (PTR) (external_sections + i * scnhsz),
+                                  (PTR) & tmp);
+         make_a_section_from_file (abfd, &tmp, i + 1);
+       }
     }
-  }
 
-/*  make_abs_section(abfd);*/
-  
+  /*  make_abs_section (abfd); */
+
   if (bfd_coff_set_arch_mach_hook (abfd, (PTR) internal_f) == false)
     goto fail;
 
@@ -180,7 +180,7 @@ coff_real_object_p (abfd, nscns, internal_f, internal_a)
   if ((internal_f->f_flags & F_EXEC) != 0)
     abfd->flags |= D_PAGED;
 
-  bfd_get_symcount(abfd) = internal_f->f_nsyms;
+  bfd_get_symcount (abfd) = internal_f->f_nsyms;
   if (internal_f->f_nsyms)
     abfd->flags |= HAS_SYMS;
 
@@ -191,8 +191,8 @@ coff_real_object_p (abfd, nscns, internal_f, internal_a)
 
   return abfd->xvec;
  fail:
-  bfd_release(abfd, tdata);
-  return (const bfd_target *)NULL;
+  bfd_release (abfd, tdata);
+  return (const bfd_target *) NULL;
 }
 
 /* Turn a COFF file into a BFD, but fail with bfd_error_wrong_format if it is
@@ -200,11 +200,11 @@ coff_real_object_p (abfd, nscns, internal_f, internal_a)
 
 const bfd_target *
 coff_object_p (abfd)
-     bfd            *abfd;
+     bfd *abfd;
 {
   unsigned int filhsz;
   unsigned int aoutsz;
-  int   nscns;
+  int nscns;
   PTR filehdr;
   struct internal_filehdr internal_f;
   struct internal_aouthdr internal_a;
@@ -216,70 +216,67 @@ coff_object_p (abfd)
   filehdr = bfd_alloc (abfd, filhsz);
   if (filehdr == NULL)
     return 0;
-  if (bfd_read(filehdr, 1, filhsz, abfd) != filhsz)
+  if (bfd_read (filehdr, 1, filhsz, abfd) != filhsz)
     {
       if (bfd_get_error () != bfd_error_system_call)
        bfd_set_error (bfd_error_wrong_format);
       return 0;
     }
-  bfd_coff_swap_filehdr_in(abfd, filehdr, &internal_f);
+  bfd_coff_swap_filehdr_in (abfd, filehdr, &internal_f);
   bfd_release (abfd, filehdr);
 
-  if (bfd_coff_bad_format_hook (abfd, &internal_f) == false) {
-    bfd_set_error (bfd_error_wrong_format);
-    return 0;
-  }
-  nscns =internal_f.f_nscns;
+  if (bfd_coff_bad_format_hook (abfd, &internal_f) == false)
+    {
+      bfd_set_error (bfd_error_wrong_format);
+      return 0;
+    }
+  nscns = internal_f.f_nscns;
 
-  if (internal_f.f_opthdr) {
-    PTR opthdr;
+  if (internal_f.f_opthdr)
+    {
+      PTR opthdr;
 
-    opthdr = bfd_alloc (abfd, aoutsz);
-    if (opthdr == NULL)
-      return 0;;
-    if (bfd_read(opthdr, 1,aoutsz, abfd) != aoutsz) {
-      return 0;
+      opthdr = bfd_alloc (abfd, aoutsz);
+      if (opthdr == NULL)
+       return 0;;
+      if (bfd_read (opthdr, 1, aoutsz, abfd) != aoutsz)
+       {
+         return 0;
+       }
+      bfd_coff_swap_aouthdr_in (abfd, opthdr, (PTR) & internal_a);
     }
-    bfd_coff_swap_aouthdr_in(abfd, opthdr, (PTR)&internal_a);
-  }
 
   /* Seek past the opt hdr stuff */
-  if (bfd_seek(abfd, (file_ptr) (internal_f.f_opthdr + filhsz), SEEK_SET)
+  if (bfd_seek (abfd, (file_ptr) (internal_f.f_opthdr + filhsz), SEEK_SET)
       != 0)
     return NULL;
 
-  return coff_real_object_p(abfd, nscns, &internal_f,
-                           (internal_f.f_opthdr != 0
-                            ? &internal_a
-                            : (struct internal_aouthdr *) NULL));
+  return coff_real_object_p (abfd, nscns, &internal_f,
+                            (internal_f.f_opthdr != 0
+                             ? &internal_a
+                             : (struct internal_aouthdr *) NULL));
 }
 
 /* Get the BFD section from a COFF symbol section number.  */
 
 asection *
 coff_section_from_bfd_index (abfd, index)
-     bfd            *abfd;
-     int             index;
+     bfd *abfd;
+     int index;
 {
   struct sec *answer = abfd->sections;
 
-  if (index == N_ABS) 
-  {
+  if (index == N_ABS)
     return bfd_abs_section_ptr;
-  }
   if (index == N_UNDEF)
-  {
     return bfd_und_section_ptr;
-  }
-  if(index == N_DEBUG)
-  {
-    return &bfd_debug_section;
-    
-  }
-  
-  while (answer) {
+  if (index == N_DEBUG)
+    return bfd_abs_section_ptr;
+
+  while (answer)
+    {
       if (answer->target_index == index)
-       return answer;
+       return answer;
       answer = answer->next;
     }
 
@@ -291,13 +288,13 @@ coff_section_from_bfd_index (abfd, index)
 /* Get the upper bound of a COFF symbol table.  */
 
 long
-coff_get_symtab_upper_bound(abfd)
-bfd            *abfd;
+coff_get_symtab_upper_bound (abfd)
+     bfd *abfd;
 {
-  if (!bfd_coff_slurp_symbol_table(abfd))
+  if (!bfd_coff_slurp_symbol_table (abfd))
     return -1;
 
-  return (bfd_get_symcount(abfd) + 1) * (sizeof(coff_symbol_type *));
+  return (bfd_get_symcount (abfd) + 1) * (sizeof (coff_symbol_type *));
 }
 
 
@@ -312,7 +309,7 @@ coff_get_symtab (abfd, alocation)
   coff_symbol_type *symbase;
   coff_symbol_type **location = (coff_symbol_type **) alocation;
 
-  if (! bfd_coff_slurp_symbol_table (abfd))
+  if (!bfd_coff_slurp_symbol_table (abfd))
     return -1;
 
   symbase = obj_symbols (abfd);
@@ -331,7 +328,7 @@ int
 coff_count_linenumbers (abfd)
      bfd *abfd;
 {
-  unsigned int limit = bfd_get_symcount(abfd);
+  unsigned int limit = bfd_get_symcount (abfd);
   unsigned int i;
   int total = 0;
   asymbol **p;
@@ -360,7 +357,7 @@ coff_count_linenumbers (abfd)
          if (q->lineno != NULL)
            {
              /* This symbol has line numbers.  Increment the owning
-                section's linenumber count.  */
+                section's linenumber count.  */
              alent *l = q->lineno;
 
              ++q->symbol.section->output_section->lineno_count;
@@ -385,16 +382,16 @@ coff_count_linenumbers (abfd)
 /*ARGSUSED*/
 coff_symbol_type *
 coff_symbol_from (ignore_abfd, symbol)
-     bfd            *ignore_abfd;
-     asymbol        *symbol;
+     bfd *ignore_abfd;
+     asymbol *symbol;
 {
-  if (bfd_asymbol_flavour(symbol) != bfd_target_coff_flavour)
-    return (coff_symbol_type *)NULL;
+  if (bfd_asymbol_flavour (symbol) != bfd_target_coff_flavour)
+    return (coff_symbol_type *) NULL;
 
-  if (bfd_asymbol_bfd(symbol)->tdata.coff_obj_data == (coff_data_type*)NULL)
-    return (coff_symbol_type *)NULL;
+  if (bfd_asymbol_bfd (symbol)->tdata.coff_obj_data == (coff_data_type *) NULL)
+    return (coff_symbol_type *) NULL;
 
-  return  (coff_symbol_type *) symbol;
+  return (coff_symbol_type *) symbol;
 }
 
 static void
@@ -404,53 +401,58 @@ fixup_symbol_value (coff_symbol_ptr, syment)
 {
 
   /* Normalize the symbol flags */
-  if (bfd_is_com_section (coff_symbol_ptr->symbol.section)) {
-    /* a common symbol is undefined with a value */
-    syment->n_scnum = N_UNDEF;
-    syment->n_value = coff_symbol_ptr->symbol.value;
-  }
-  else if (coff_symbol_ptr->symbol.flags & BSF_DEBUGGING) {
-    syment->n_value = coff_symbol_ptr->symbol.value;
-  }
-  else if (bfd_is_und_section (coff_symbol_ptr->symbol.section)) {
-    syment->n_scnum = N_UNDEF;
-    syment->n_value = 0;
-  }
-  else {
-    if (coff_symbol_ptr->symbol.section) {
-      syment->n_scnum   =
-       coff_symbol_ptr->symbol.section->output_section->target_index;
-
-      syment->n_value =
-       coff_symbol_ptr->symbol.value +
-       coff_symbol_ptr->symbol.section->output_offset +
-        coff_symbol_ptr->symbol.section->output_section->vma;
+  if (bfd_is_com_section (coff_symbol_ptr->symbol.section))
+    {
+      /* a common symbol is undefined with a value */
+      syment->n_scnum = N_UNDEF;
+      syment->n_value = coff_symbol_ptr->symbol.value;
     }
-    else {
-       BFD_ASSERT(0);
-      /* This can happen, but I don't know why yet (steve@cygnus.com) */
-      syment->n_scnum = N_ABS;
+  else if (coff_symbol_ptr->symbol.flags & BSF_DEBUGGING)
+    {
       syment->n_value = coff_symbol_ptr->symbol.value;
     }
-  }
+  else if (bfd_is_und_section (coff_symbol_ptr->symbol.section))
+    {
+      syment->n_scnum = N_UNDEF;
+      syment->n_value = 0;
+    }
+  else
+    {
+      if (coff_symbol_ptr->symbol.section)
+       {
+         syment->n_scnum =
+           coff_symbol_ptr->symbol.section->output_section->target_index;
+
+         syment->n_value =
+           coff_symbol_ptr->symbol.value +
+           coff_symbol_ptr->symbol.section->output_offset +
+           coff_symbol_ptr->symbol.section->output_section->vma;
+       }
+      else
+       {
+         BFD_ASSERT (0);
+         /* This can happen, but I don't know why yet (steve@cygnus.com) */
+         syment->n_scnum = N_ABS;
+         syment->n_value = coff_symbol_ptr->symbol.value;
+       }
+    }
 }
 
-/* run through all the symbols in the symbol table and work out what
-   their indexes into the symbol table will be when output
+/* Run through all the symbols in the symbol table and work out what
+   their indexes into the symbol table will be when output.
 
- Coff requires that each C_FILE symbol points to the next one in the
- chain, and that the last one points to the first external symbol. We
- do that here too.
  Coff requires that each C_FILE symbol points to the next one in the
  chain, and that the last one points to the first external symbol. We
+   do that here too.  */
 
-*/
 boolean
 coff_renumber_symbols (bfd_ptr)
      bfd *bfd_ptr;
 {
-  unsigned int symbol_count = bfd_get_symcount(bfd_ptr);
+  unsigned int symbol_count = bfd_get_symcount (bfd_ptr);
   asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;
   unsigned int native_index = 0;
-  struct internal_syment *last_file = (struct internal_syment *)NULL;
+  struct internal_syment *last_file = (struct internal_syment *) NULL;
   unsigned int symbol_index;
 
   /* COFF demands that undefined symbols come after all other symbols.
@@ -474,7 +476,7 @@ coff_renumber_symbols (bfd_ptr)
       }
     bfd_ptr->outsymbols = newsyms;
     for (i = 0; i < symbol_count; i++)
-      if (! bfd_is_und_section (symbol_ptr_ptr[i]->section))
+      if (!bfd_is_und_section (symbol_ptr_ptr[i]->section))
        *newsyms++ = symbol_ptr_ptr[i];
     for (i = 0; i < symbol_count; i++)
       if (bfd_is_und_section (symbol_ptr_ptr[i]->section))
@@ -484,43 +486,43 @@ coff_renumber_symbols (bfd_ptr)
   }
 
   for (symbol_index = 0; symbol_index < symbol_count; symbol_index++)
-      {
-       coff_symbol_type *coff_symbol_ptr = coff_symbol_from(bfd_ptr, symbol_ptr_ptr[symbol_index]);
-       if (coff_symbol_ptr && coff_symbol_ptr->native) {
+    {
+      coff_symbol_type *coff_symbol_ptr = coff_symbol_from (bfd_ptr, symbol_ptr_ptr[symbol_index]);
+      if (coff_symbol_ptr && coff_symbol_ptr->native)
+       {
          combined_entry_type *s = coff_symbol_ptr->native;
          int i;
 
          if (s->u.syment.n_sclass == C_FILE)
-             {
-               if (last_file != (struct internal_syment *)NULL) {
-                 last_file->n_value = native_index;
-               }
-               last_file = &(s->u.syment);
-             }
-         else {
-
-           /* Modify the symbol values according to their section and
-              type */
-
-           fixup_symbol_value(coff_symbol_ptr, &(s->u.syment));
-         }
-         for (i = 0; i < s->u.syment.n_numaux + 1; i++) {
-           s[i].offset = native_index ++;
-         }
+           {
+             if (last_file != (struct internal_syment *) NULL)
+               last_file->n_value = native_index;
+             last_file = &(s->u.syment);
+           }
+         else
+           {
+
+             /* Modify the symbol values according to their section and
+                type */
+
+             fixup_symbol_value (coff_symbol_ptr, &(s->u.syment));
+           }
+         for (i = 0; i < s->u.syment.n_numaux + 1; i++)
+           s[i].offset = native_index++;
        }
-       else {
+      else
+       {
          native_index++;
        }
-      }
+    }
   obj_conv_table_size (bfd_ptr) = native_index;
   return true;
 }
 
-/*
- Run thorough the symbol table again, and fix it so that all pointers to
- entries are changed to the entries' index in the output symbol table.
+/* Run thorough the symbol table again, and fix it so that all
+   pointers to entries are changed to the entries' index in the output
+   symbol table.  */
 
-*/
 void
 coff_mangle_symbols (bfd_ptr)
      bfd *bfd_ptr;
@@ -532,7 +534,7 @@ coff_mangle_symbols (bfd_ptr)
   for (symbol_index = 0; symbol_index < symbol_count; symbol_index++)
     {
       coff_symbol_type *coff_symbol_ptr =
-       coff_symbol_from (bfd_ptr, symbol_ptr_ptr[symbol_index]);
+      coff_symbol_from (bfd_ptr, symbol_ptr_ptr[symbol_index]);
 
       if (coff_symbol_ptr && coff_symbol_ptr->native)
        {
@@ -546,7 +548,7 @@ coff_mangle_symbols (bfd_ptr)
                ((combined_entry_type *) s->u.syment.n_value)->offset;
              s->fix_value = 0;
            }
-         for (i = 0; i < s->u.syment.n_numaux ; i++)
+         for (i = 0; i < s->u.syment.n_numaux; i++)
            {
              combined_entry_type *a = s + i + 1;
              if (a->fix_tag)
@@ -582,48 +584,55 @@ coff_fix_symbol_name (abfd, symbol, native)
      asymbol *symbol;
      combined_entry_type *native;
 {
-  unsigned int    name_length;
+  unsigned int name_length;
   union internal_auxent *auxent;
-  char *  name = ( char *)(symbol->name);
+  char *name = (char *) (symbol->name);
 
-  if (name == (char *) NULL) {
-    /* coff symbols always have names, so we'll make one up */
-    symbol->name = "strange";
-    name = (char *)symbol->name;
-  }
-  name_length = strlen(name);
+  if (name == (char *) NULL)
+    {
+      /* coff symbols always have names, so we'll make one up */
+      symbol->name = "strange";
+      name = (char *) symbol->name;
+    }
+  name_length = strlen (name);
 
-  if (native->u.syment.n_sclass == C_FILE) {
-    strncpy(native->u.syment._n._n_name, ".file", SYMNMLEN);
-    auxent = &(native+1)->u.auxent;
+  if (native->u.syment.n_sclass == C_FILE)
+    {
+      strncpy (native->u.syment._n._n_name, ".file", SYMNMLEN);
+      auxent = &(native + 1)->u.auxent;
 
-    if (bfd_coff_long_filenames (abfd)) {
-      if (name_length <= FILNMLEN) {
-       strncpy(auxent->x_file.x_fname, name, FILNMLEN);
-      }
-      else {
-       auxent->x_file.x_n.x_offset = string_size + STRING_SIZE_SIZE;
-       auxent->x_file.x_n.x_zeroes = 0;
-       string_size += name_length + 1;
-      }
-    }
-    else {
-      strncpy(auxent->x_file.x_fname, name, FILNMLEN);
-      if (name_length > FILNMLEN) {
-       name[FILNMLEN] = '\0';
-      }
+      if (bfd_coff_long_filenames (abfd))
+       {
+         if (name_length <= FILNMLEN)
+           {
+             strncpy (auxent->x_file.x_fname, name, FILNMLEN);
+           }
+         else
+           {
+             auxent->x_file.x_n.x_offset = string_size + STRING_SIZE_SIZE;
+             auxent->x_file.x_n.x_zeroes = 0;
+             string_size += name_length + 1;
+           }
+       }
+      else
+       {
+         strncpy (auxent->x_file.x_fname, name, FILNMLEN);
+         if (name_length > FILNMLEN)
+           {
+             name[FILNMLEN] = '\0';
+           }
+       }
     }
-  }
   else
     {                          /* NOT A C_FILE SYMBOL */
       if (name_length <= SYMNMLEN)
        {
          /* This name will fit into the symbol neatly */
-         strncpy(native->u.syment._n._n_name, symbol->name, SYMNMLEN);
+         strncpy (native->u.syment._n._n_name, symbol->name, SYMNMLEN);
        }
-      else if (! bfd_coff_symname_in_debug (abfd, &native->u.syment))
+      else if (!bfd_coff_symname_in_debug (abfd, &native->u.syment))
        {
-         native->u.syment._n._n_n._n_offset =  string_size + STRING_SIZE_SIZE;
+         native->u.syment._n._n_n._n_offset = string_size + STRING_SIZE_SIZE;
          native->u.syment._n._n_n._n_zeroes = 0;
          string_size += name_length + 1;
        }
@@ -641,16 +650,16 @@ coff_fix_symbol_name (abfd, symbol, native)
            debug_string_section = bfd_get_section_by_name (abfd, ".debug");
          filepos = bfd_tell (abfd);
          bfd_put_16 (abfd, name_length + 1, buf);
-         if (! bfd_set_section_contents (abfd,
-                                         debug_string_section,
-                                         (PTR) buf,
-                                         (file_ptr) debug_string_size,
-                                         (bfd_size_type) 2)
-             || ! bfd_set_section_contents (abfd,
-                                            debug_string_section,
-                                            (PTR) symbol->name,
-                                            (file_ptr) debug_string_size + 2,
-                                            (bfd_size_type) name_length + 1))
+         if (!bfd_set_section_contents (abfd,
+                                        debug_string_section,
+                                        (PTR) buf,
+                                        (file_ptr) debug_string_size,
+                                        (bfd_size_type) 2)
+             || !bfd_set_section_contents (abfd,
+                                           debug_string_section,
+                                           (PTR) symbol->name,
+                                           (file_ptr) debug_string_size + 2,
+                                           (bfd_size_type) name_length + 1))
            abort ();
          if (bfd_seek (abfd, filepos, SEEK_SET) != 0)
            abort ();
@@ -678,33 +687,31 @@ coff_write_symbol (abfd, symbol, native, written)
 {
   unsigned int numaux = native->u.syment.n_numaux;
   int type = native->u.syment.n_type;
-  int class =  native->u.syment.n_sclass;
+  int class = native->u.syment.n_sclass;
   PTR buf;
   bfd_size_type symesz;
 
-  /* @@ bfd_debug_section isn't accessible outside this file, but we
-     know that C_FILE symbols belong there.  So move them.  */
   if (native->u.syment.n_sclass == C_FILE)
-    symbol->section = &bfd_debug_section;
+    symbol->flags |= BSF_DEBUGGING;
 
-  if (bfd_is_abs_section (symbol->section))
+  if (symbol->flags & BSF_DEBUGGING)
     {
-      native->u.syment.n_scnum = N_ABS;
+      native->u.syment.n_scnum = N_DEBUG;
     }
-  else if (symbol->section == &bfd_debug_section) 
+  else if (bfd_is_abs_section (symbol->section))
     {
-      native->u.syment.n_scnum = N_DEBUG;
+      native->u.syment.n_scnum = N_ABS;
     }
   else if (bfd_is_und_section (symbol->section))
     {
       native->u.syment.n_scnum = N_UNDEF;
     }
-  else 
+  else
     {
       native->u.syment.n_scnum =
        symbol->section->output_section->target_index;
     }
-  
+
   coff_fix_symbol_name (abfd, symbol, native);
 
   symesz = bfd_coff_symesz (abfd);
@@ -731,7 +738,7 @@ coff_write_symbol (abfd, symbol, native, written)
          bfd_set_error (bfd_error_no_memory);
          return false;
        }
-      for (j = 0; j < native->u.syment.n_numaux;  j++)
+      for (j = 0; j < native->u.syment.n_numaux; j++)
        {
          bfd_coff_swap_aux_out (abfd,
                                 &((native + j + 1)->u.auxent),
@@ -740,7 +747,7 @@ coff_write_symbol (abfd, symbol, native, written)
                                 j,
                                 native->u.syment.n_numaux,
                                 buf);
-         if (bfd_write (buf, 1, auxesz, abfd)!= auxesz)
+         if (bfd_write (buf, 1, auxesz, abfd) != auxesz)
            return false;
        }
       bfd_release (abfd, buf);
@@ -767,8 +774,8 @@ coff_write_alien_symbol (abfd, symbol, written)
   combined_entry_type dummy;
 
   native = &dummy;
-  native->u.syment.n_type =  T_NULL;
-  native->u.syment.n_flags =  0;
+  native->u.syment.n_type = T_NULL;
+  native->u.syment.n_flags = 0;
   if (bfd_is_und_section (symbol->section))
     {
       native->u.syment.n_scnum = N_UNDEF;
@@ -797,7 +804,7 @@ coff_write_alien_symbol (abfd, symbol, written)
                                  + symbol->section->output_offset);
 
       /* Copy the any flags from the the file header into the symbol.
-        FIXME: Why?  */
+         FIXME: Why?  */
       {
        coff_symbol_type *c = coff_symbol_from (abfd, symbol);
        if (c != (coff_symbol_type *) NULL)
@@ -835,7 +842,7 @@ coff_write_native_symbol (abfd, symbol, written)
       lineno[count].u.offset = *written;
       if (native->u.syment.n_numaux)
        {
-         union internal_auxent  *a = &((native+1)->u.auxent);
+         union internal_auxent *a = &((native + 1)->u.auxent);
 
          a->x_sym.x_fcnary.x_fcn.x_lnnoptr =
            symbol->symbol.section->output_section->moving_line_filepos;
@@ -860,7 +867,7 @@ coff_write_native_symbol (abfd, symbol, written)
             > `native->u.syment.n_value' instead of the section
             > virtual address.
             > modular!olson@cs.arizona.edu (Jon Olson)
-            */
+          */
          lineno[count].u.offset += native->u.syment.n_value;
 #else
          lineno[count].u.offset +=
@@ -870,7 +877,7 @@ coff_write_native_symbol (abfd, symbol, written)
          count++;
        }
       symbol->done_lineno = true;
-    
+
       symbol->symbol.section->output_section->moving_line_filepos +=
        count * bfd_coff_linesz (abfd);
     }
@@ -885,7 +892,7 @@ coff_write_symbols (abfd)
      bfd *abfd;
 {
   unsigned int i;
-  unsigned int limit = bfd_get_symcount(abfd);
+  unsigned int limit = bfd_get_symcount (abfd);
   unsigned int written = 0;
   asymbol **p;
 
@@ -893,7 +900,7 @@ coff_write_symbols (abfd)
   debug_string_size = 0;
 
   /* Seek to the right place */
-  if (bfd_seek (abfd, obj_sym_filepos(abfd), SEEK_SET) != 0)
+  if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0)
     return false;
 
   /* Output all the symbols we have */
@@ -905,14 +912,14 @@ coff_write_symbols (abfd)
       coff_symbol_type *c_symbol = coff_symbol_from (abfd, symbol);
 
       if (c_symbol == (coff_symbol_type *) NULL
-         || c_symbol->native == (combined_entry_type *)NULL)
+         || c_symbol->native == (combined_entry_type *) NULL)
        {
-         if (! coff_write_alien_symbol (abfd, symbol, &written))
+         if (!coff_write_alien_symbol (abfd, symbol, &written))
            return false;
        }
       else
        {
-         if (! coff_write_native_symbol (abfd, c_symbol, &written))
+         if (!coff_write_native_symbol (abfd, c_symbol, &written))
            return false;
        }
     }
@@ -922,65 +929,65 @@ coff_write_symbols (abfd)
   /* Now write out strings */
 
   if (string_size != 0)
-   {
-     unsigned int size = string_size + STRING_SIZE_SIZE;
-     bfd_byte buffer[STRING_SIZE_SIZE];
+    {
+      unsigned int size = string_size + STRING_SIZE_SIZE;
+      bfd_byte buffer[STRING_SIZE_SIZE];
 
 #if STRING_SIZE_SIZE == 4
-     bfd_h_put_32 (abfd, size, buffer);
+      bfd_h_put_32 (abfd, size, buffer);
 #else
  #error Change bfd_h_put_32
 #endif
-     if (bfd_write ((PTR) buffer, 1, sizeof (buffer), abfd) != sizeof (buffer))
-       return false;
-     for (p = abfd->outsymbols, i = 0;
-         i < limit;
-         i++, p++)
-       {
-        asymbol *q = *p;
-        size_t name_length = strlen (q->name);
-        coff_symbol_type *c_symbol = coff_symbol_from (abfd, q);
-        size_t maxlen;
-
-        /* Figure out whether the symbol name should go in the string
-           table.  Symbol names that are short enough are stored
-           directly in the syment structure.  File names permit a
-           different, longer, length in the syment structure.  On
-           XCOFF, some symbol names are stored in the .debug section
-           rather than in the string table.  */
-
-        if (c_symbol == NULL
-            || c_symbol->native == NULL)
-          {
-            /* This is not a COFF symbol, so it certainly is not a
-               file name, nor does it go in the .debug section.  */
-            maxlen = SYMNMLEN;
-          }
-        else if (bfd_coff_symname_in_debug (abfd,
-                                            &c_symbol->native->u.syment))
-          {
-            /* This symbol name is in the XCOFF .debug section.
-               Don't write it into the string table.  */
-            maxlen = name_length;
-          }
-        else if (c_symbol->native->u.syment.n_sclass == C_FILE)
-          maxlen = FILNMLEN;
-        else
-          maxlen = SYMNMLEN;
-
-        if (name_length > maxlen)
-          {
-            if (bfd_write ((PTR) (q->name), 1, name_length + 1, abfd)
-                != name_length + 1)
-              return false;
-          }
-       }
-   }
+      if (bfd_write ((PTR) buffer, 1, sizeof (buffer), abfd) != sizeof (buffer))
+       return false;
+      for (p = abfd->outsymbols, i = 0;
+          i < limit;
+          i++, p++)
+       {
+         asymbol *q = *p;
+         size_t name_length = strlen (q->name);
+         coff_symbol_type *c_symbol = coff_symbol_from (abfd, q);
+         size_t maxlen;
+
+         /* Figure out whether the symbol name should go in the string
+            table.  Symbol names that are short enough are stored
+            directly in the syment structure.  File names permit a
+            different, longer, length in the syment structure.  On
+            XCOFF, some symbol names are stored in the .debug section
+            rather than in the string table.  */
+
+         if (c_symbol == NULL
+             || c_symbol->native == NULL)
+           {
+             /* This is not a COFF symbol, so it certainly is not a
+                file name, nor does it go in the .debug section.  */
+             maxlen = SYMNMLEN;
+           }
+         else if (bfd_coff_symname_in_debug (abfd,
+                                             &c_symbol->native->u.syment))
+           {
+             /* This symbol name is in the XCOFF .debug section.
+                Don't write it into the string table.  */
+             maxlen = name_length;
+           }
+         else if (c_symbol->native->u.syment.n_sclass == C_FILE)
+           maxlen = FILNMLEN;
+         else
+           maxlen = SYMNMLEN;
+
+         if (name_length > maxlen)
+           {
+             if (bfd_write ((PTR) (q->name), 1, name_length + 1, abfd)
+                 != name_length + 1)
+               return false;
+           }
+       }
+    }
   else
     {
       /* We would normally not write anything here, but we'll write
-        out 4 so that any stupid coff reader which tries to read the
-        string table even when there isn't one won't croak.  */
+         out 4 so that any stupid coff reader which tries to read the
+         string table even when there isn't one won't croak.  */
       unsigned int size = STRING_SIZE_SIZE;
       bfd_byte buffer[STRING_SIZE_SIZE];
 
@@ -1010,9 +1017,9 @@ coff_write_symbols (abfd)
 
 boolean
 coff_write_linenumbers (abfd)
-     bfd            *abfd;
+     bfd *abfd;
 {
-  asection       *s;
+  asection *s;
   bfd_size_type linesz;
   PTR buff;
 
@@ -1023,52 +1030,59 @@ coff_write_linenumbers (abfd)
       bfd_set_error (bfd_error_no_memory);
       return false;
     }
-  for (s = abfd->sections; s != (asection *) NULL; s = s->next) {
-    if (s->lineno_count) {
-      asymbol       **q = abfd->outsymbols;
-      if (bfd_seek(abfd, s->line_filepos, SEEK_SET) != 0)
-       return false;
-      /* Find all the linenumbers in this section */
-      while (*q) {
-       asymbol        *p = *q;
-       if (p->section->output_section == s) {
-         alent          *l =
-          BFD_SEND(bfd_asymbol_bfd(p), _get_lineno, (bfd_asymbol_bfd(p), p));
-         if (l) {
-           /* Found a linenumber entry, output */
-           struct internal_lineno  out;
-           memset( (PTR)&out, 0, sizeof(out));
-           out.l_lnno = 0;
-           out.l_addr.l_symndx = l->u.offset;
-           bfd_coff_swap_lineno_out(abfd, &out, buff);
-           if (bfd_write(buff, 1, linesz, abfd) != linesz)
-             return false;
-           l++;
-           while (l->line_number) {
-             out.l_lnno = l->line_number;
-             out.l_addr.l_symndx = l->u.offset;
-             bfd_coff_swap_lineno_out(abfd, &out, buff);
-             if (bfd_write(buff, 1, linesz, abfd) != linesz)
-               return false;
-             l++;
+  for (s = abfd->sections; s != (asection *) NULL; s = s->next)
+    {
+      if (s->lineno_count)
+       {
+         asymbol **q = abfd->outsymbols;
+         if (bfd_seek (abfd, s->line_filepos, SEEK_SET) != 0)
+           return false;
+         /* Find all the linenumbers in this section */
+         while (*q)
+           {
+             asymbol *p = *q;
+             if (p->section->output_section == s)
+               {
+                 alent *l =
+                 BFD_SEND (bfd_asymbol_bfd (p), _get_lineno,
+                           (bfd_asymbol_bfd (p), p));
+                 if (l)
+                   {
+                     /* Found a linenumber entry, output */
+                     struct internal_lineno out;
+                     memset ((PTR) & out, 0, sizeof (out));
+                     out.l_lnno = 0;
+                     out.l_addr.l_symndx = l->u.offset;
+                     bfd_coff_swap_lineno_out (abfd, &out, buff);
+                     if (bfd_write (buff, 1, linesz, abfd) != linesz)
+                       return false;
+                     l++;
+                     while (l->line_number)
+                       {
+                         out.l_lnno = l->line_number;
+                         out.l_addr.l_symndx = l->u.offset;
+                         bfd_coff_swap_lineno_out (abfd, &out, buff);
+                         if (bfd_write (buff, 1, linesz, abfd) != linesz)
+                           return false;
+                         l++;
+                       }
+                   }
+               }
+             q++;
            }
-         }
        }
-       q++;
-      }
     }
-  }
   bfd_release (abfd, buff);
   return true;
 }
 
-/*ARGSUSED*/
-alent   *
+/*ARGSUSED */
+alent *
 coff_get_lineno (ignore_abfd, symbol)
-     bfd            *ignore_abfd;
-     asymbol        *symbol;
+     bfd *ignore_abfd;
+     asymbol *symbol;
 {
-  return coffsymbol(symbol)->lineno;
+  return coffsymbol (symbol)->lineno;
 }
 
 asymbol *
@@ -1085,11 +1099,12 @@ coff_section_symbol (abfd, name)
   /* Make sure back-end COFF stuff is there.  */
   if (csym == 0)
     {
-      struct foo {
-       coff_symbol_type sym;
-       /* @@FIXME This shouldn't use a fixed size!!  */
-       combined_entry_type e[10];
-      };
+      struct foo
+       {
+         coff_symbol_type sym;
+         /* @@FIXME This shouldn't use a fixed size!!  */
+         combined_entry_type e[10];
+       };
       struct foo *f;
       f = (struct foo *) bfd_alloc_by_size_t (abfd, sizeof (*f));
       if (!f)
@@ -1102,7 +1117,7 @@ coff_section_symbol (abfd, name)
     }
   csym[0].u.syment.n_sclass = C_STAT;
   csym[0].u.syment.n_numaux = 1;
-/*  SF_SET_STATICS (sym);      @@ ??? */
+/*  SF_SET_STATICS (sym);       @@ ??? */
   csym[1].u.auxent.x_scn.x_scnlen = sec->_raw_size;
   csym[1].u.auxent.x_scn.x_nreloc = sec->reloc_count;
   csym[1].u.auxent.x_scn.x_nlinno = sec->lineno_count;
@@ -1128,13 +1143,15 @@ coff_pointerize_aux (abfd, table_base, type, class, auxent)
      combined_entry_type *auxent;
 {
   /* Don't bother if this is a file or a section */
-  if (class == C_STAT && type == T_NULL) return;
-  if (class == C_FILE) return;
+  if (class == C_STAT && type == T_NULL)
+    return;
+  if (class == C_FILE)
+    return;
 
   /* Otherwise patch up */
 #define N_TMASK coff_data (abfd)->local_n_tmask
 #define N_BTSHFT coff_data (abfd)->local_n_btshft
-  if ((ISFCN(type) || ISTAG(class) || class == C_BLOCK)
+  if ((ISFCN (type) || ISTAG (class) || class == C_BLOCK)
       && auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l > 0)
     {
       auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p =
@@ -1144,9 +1161,10 @@ coff_pointerize_aux (abfd, table_base, type, class, auxent)
     }
   /* A negative tagndx is meaningless, but the SCO 3.2v4 cc can
      generate one, so we must be careful to ignore it.  */
-  if (auxent->u.auxent.x_sym.x_tagndx.l > 0) {
+  if (auxent->u.auxent.x_sym.x_tagndx.l > 0)
+    {
       auxent->u.auxent.x_sym.x_tagndx.p =
-       table_base +  auxent->u.auxent.x_sym.x_tagndx.l;
+       table_base + auxent->u.auxent.x_sym.x_tagndx.l;
       auxent->fix_tag = 1;
     }
 }
@@ -1161,25 +1179,25 @@ build_string_table (abfd)
 
   /* At this point we should be "seek"'d to the end of the
      symbols === the symbol table size.  */
-  if (bfd_read((char *) string_table_size_buffer,
-              sizeof(string_table_size_buffer),
-              1, abfd) != sizeof(string_table_size))
+  if (bfd_read ((char *) string_table_size_buffer,
+               sizeof (string_table_size_buffer),
+               1, abfd) != sizeof (string_table_size))
     return (NULL);
 
 #if STRING_SIZE_SIZE == 4
-  string_table_size = bfd_h_get_32(abfd, (bfd_byte *) string_table_size_buffer);
+  string_table_size = bfd_h_get_32 (abfd, (bfd_byte *) string_table_size_buffer);
 #else
  #error Change bfd_h_get_32
 #endif
 
-  if ((string_table = (PTR) bfd_alloc(abfd,
-                                     string_table_size -= STRING_SIZE_SIZE))
+  if ((string_table = (PTR) bfd_alloc (abfd,
+                                    string_table_size -= STRING_SIZE_SIZE))
       == NULL)
     {
       bfd_set_error (bfd_error_no_memory);
       return (NULL);
     }                          /* on mallocation error */
-  if (bfd_read(string_table, string_table_size, 1, abfd) != string_table_size)
+  if (bfd_read (string_table, string_table_size, 1, abfd) != string_table_size)
     return (NULL);
   return string_table;
 }
@@ -1197,17 +1215,19 @@ build_debug_section (abfd)
 
   asection *sect = bfd_get_section_by_name (abfd, ".debug");
 
-  if (!sect) {
-     bfd_set_error (bfd_error_no_debug_section);
-     return NULL;
-  }
+  if (!sect)
+    {
+      bfd_set_error (bfd_error_no_debug_section);
+      return NULL;
+    }
 
   debug_section = (PTR) bfd_alloc (abfd,
                                   bfd_get_section_size_before_reloc (sect));
-  if (debug_section == NULL) {
-    bfd_set_error (bfd_error_no_memory);
-    return NULL;
-  }
+  if (debug_section == NULL)
+    {
+      bfd_set_error (bfd_error_no_memory);
+      return NULL;
+    }
 
   /* Seek to the beginning of the `.debug' section and read it. 
      Save the current position first; it is needed by our caller.
@@ -1215,9 +1235,9 @@ build_debug_section (abfd)
 
   position = bfd_tell (abfd);
   if (bfd_seek (abfd, sect->filepos, SEEK_SET) != 0
-      || (bfd_read (debug_section, 
+      || (bfd_read (debug_section,
                    bfd_get_section_size_before_reloc (sect), 1, abfd)
-         != bfd_get_section_size_before_reloc(sect))
+         != bfd_get_section_size_before_reloc (sect))
       || bfd_seek (abfd, position, SEEK_SET) != 0)
     return NULL;
   return debug_section;
@@ -1225,28 +1245,31 @@ build_debug_section (abfd)
 
 
 /* Return a pointer to a malloc'd copy of 'name'.  'name' may not be
- \0-terminated, but will not exceed 'maxlen' characters.  The copy *will*
- be \0-terminated.  */
  \0-terminated, but will not exceed 'maxlen' characters.  The copy *will*
  be \0-terminated.  */
 static char *
 copy_name (abfd, name, maxlen)
      bfd *abfd;
      char *name;
      int maxlen;
 {
-  int  len;
+  int len;
   char *newname;
 
-  for (len = 0; len < maxlen; ++len) {
-    if (name[len] == '\0') {
-      break;
+  for (len = 0; len < maxlen; ++len)
+    {
+      if (name[len] == '\0')
+       {
+         break;
+       }
     }
-  }
 
-  if ((newname = (PTR) bfd_alloc(abfd, len+1)) == NULL) {
-    bfd_set_error (bfd_error_no_memory);
-    return (NULL);
-  }
-  strncpy(newname, name, len);
+  if ((newname = (PTR) bfd_alloc (abfd, len + 1)) == NULL)
+    {
+      bfd_set_error (bfd_error_no_memory);
+      return (NULL);
+    }
+  strncpy (newname, name, len);
   newname[len] = '\0';
   return newname;
 }
@@ -1258,19 +1281,19 @@ copy_name (abfd, name, maxlen)
 
 combined_entry_type *
 coff_get_normalized_symtab (abfd)
-     bfd            *abfd;
+     bfd *abfd;
 {
-  combined_entry_type          *internal;
-  combined_entry_type          *internal_ptr;
-  combined_entry_type          *symbol_ptr;
-  combined_entry_type         *internal_end;
+  combined_entry_type *internal;
+  combined_entry_type *internal_ptr;
+  combined_entry_type *symbol_ptr;
+  combined_entry_type *internal_end;
   bfd_size_type symesz;
   PTR raw;
   char *raw_src;
   char *raw_end;
-  char           *string_table = NULL;
-  char          *debug_section = NULL;
-  unsigned long   size;
+  char *string_table = NULL;
+  char *debug_section = NULL;
+  unsigned long size;
   unsigned int raw_size;
 
   if (obj_raw_syments (abfd) != NULL)
@@ -1301,18 +1324,18 @@ coff_get_normalized_symtab (abfd)
   /* mark the end of the symbols */
   raw_end = (char *) raw + obj_raw_syment_count (abfd) * symesz;
 
-  /*
-    FIXME SOMEDAY.  A string table size of zero is very weird, but
-    probably possible.  If one shows up, it will probably kill us.
-    */
+  /* FIXME SOMEDAY.  A string table size of zero is very weird, but
+     probably possible.  If one shows up, it will probably kill us.  */
 
   /* Swap all the raw entries */
   for (raw_src = (char *) raw, internal_ptr = internal;
        raw_src < raw_end;
-       raw_src += symesz, internal_ptr++) {
+       raw_src += symesz, internal_ptr++)
+    {
 
       unsigned int i;
-      bfd_coff_swap_sym_in(abfd, (PTR)raw_src, (PTR)&internal_ptr->u.syment);
+      bfd_coff_swap_sym_in (abfd, (PTR) raw_src,
+                           (PTR) & internal_ptr->u.syment);
       internal_ptr->fix_value = 0;
       internal_ptr->fix_tag = 0;
       internal_ptr->fix_end = 0;
@@ -1321,32 +1344,32 @@ coff_get_normalized_symtab (abfd)
 
       for (i = 0;
           i < symbol_ptr->u.syment.n_numaux;
-          i++) 
-      {
-       internal_ptr++;
-       raw_src += symesz;
-      
-       internal_ptr->fix_value = 0;
-       internal_ptr->fix_tag = 0;
-       internal_ptr->fix_end = 0;
-       internal_ptr->fix_scnlen = 0;
-       bfd_coff_swap_aux_in(abfd, (PTR) raw_src,
-                            symbol_ptr->u.syment.n_type,
-                            symbol_ptr->u.syment.n_sclass,
-                            i, symbol_ptr->u.syment.n_numaux,
-                            &(internal_ptr->u.auxent));
-       /* Remember that bal entries arn't pointerized */
-       if (i != 1 || symbol_ptr->u.syment.n_sclass != C_LEAFPROC)
+          i++)
        {
-         
-       coff_pointerize_aux(abfd,
-                           internal,
-                           symbol_ptr->u.syment.n_type,
-                           symbol_ptr->u.syment.n_sclass,
-                           internal_ptr);
-      }
-       
-      }
+         internal_ptr++;
+         raw_src += symesz;
+
+         internal_ptr->fix_value = 0;
+         internal_ptr->fix_tag = 0;
+         internal_ptr->fix_end = 0;
+         internal_ptr->fix_scnlen = 0;
+         bfd_coff_swap_aux_in (abfd, (PTR) raw_src,
+                               symbol_ptr->u.syment.n_type,
+                               symbol_ptr->u.syment.n_sclass,
+                               i, symbol_ptr->u.syment.n_numaux,
+                               &(internal_ptr->u.auxent));
+         /* Remember that bal entries arn't pointerized */
+         if (i != 1 || symbol_ptr->u.syment.n_sclass != C_LEAFPROC)
+           {
+
+             coff_pointerize_aux (abfd,
+                                  internal,
+                                  symbol_ptr->u.syment.n_type,
+                                  symbol_ptr->u.syment.n_sclass,
+                                  internal_ptr);
+           }
+
+       }
     }
 
   /* Free all the raw stuff */
@@ -1354,77 +1377,85 @@ coff_get_normalized_symtab (abfd)
     bfd_release (abfd, raw);
 
   for (internal_ptr = internal; internal_ptr < internal_end;
-       internal_ptr ++)
-  {
-    if (internal_ptr->u.syment.n_sclass == C_FILE
-       && internal_ptr->u.syment.n_numaux > 0) {
-       /* make a file symbol point to the name in the auxent, since
-          the text ".file" is redundant */
-       if ((internal_ptr+1)->u.auxent.x_file.x_n.x_zeroes == 0) {
-           /* the filename is a long one, point into the string table */
-           if (string_table == NULL) {
-               string_table = build_string_table(abfd);
-             }
-
-           internal_ptr->u.syment._n._n_n._n_offset =
-            (long) (string_table - STRING_SIZE_SIZE +
-                   (internal_ptr+1)->u.auxent.x_file.x_n.x_offset);
-         }
-       else {
-           /* ordinary short filename, put into memory anyway */
-           internal_ptr->u.syment._n._n_n._n_offset = (long)
-            copy_name(abfd, (internal_ptr+1)->u.auxent.x_file.x_fname,
-                      FILNMLEN);
-         }
-      }
-    else {
-       if (internal_ptr->u.syment._n._n_n._n_zeroes != 0) {
-           /* This is a "short" name.  Make it long.  */
-           unsigned long   i = 0;
-           char           *newstring = NULL;
-
-           /* find the length of this string without walking into memory
-              that isn't ours.  */
-           for (i = 0; i < 8; ++i) {
-               if (internal_ptr->u.syment._n._n_name[i] == '\0') {
-                   break;
-                 }             /* if end of string */
-             }                 /* possible lengths of this string. */
-
-           if ((newstring = (PTR) bfd_alloc(abfd, ++i)) == NULL) {
-               bfd_set_error (bfd_error_no_memory);
-               return (NULL);
-             }                 /* on error */
-           memset(newstring, 0, i);
-           strncpy(newstring, internal_ptr->u.syment._n._n_name, i-1);
-           internal_ptr->u.syment._n._n_n._n_offset =  (long int) newstring;
-           internal_ptr->u.syment._n._n_n._n_zeroes = 0;
-         }
-       else if (internal_ptr->u.syment._n._n_n._n_offset == 0)
-         internal_ptr->u.syment._n._n_n._n_offset = (long int) "";
-       else if (!bfd_coff_symname_in_debug(abfd, &internal_ptr->u.syment)) {
-           /* Long name already.  Point symbol at the string in the table.  */
-           if (string_table == NULL) {
-               string_table = build_string_table(abfd);
-             }
-           internal_ptr->u.syment._n._n_n._n_offset = (long int)
-            (string_table
-             - STRING_SIZE_SIZE
-             + internal_ptr->u.syment._n._n_n._n_offset);
-         }
-       else {
-           /* Long name in debug section.  Very similar.  */
-           if (debug_section == NULL) {
-               debug_section = build_debug_section(abfd);
-             }
-           internal_ptr->u.syment._n._n_n._n_offset = (long int)
-            (debug_section + internal_ptr->u.syment._n._n_n._n_offset);
-         }
-      }
-    internal_ptr += internal_ptr->u.syment.n_numaux;
-  }
+       internal_ptr++)
+    {
+      if (internal_ptr->u.syment.n_sclass == C_FILE
+         && internal_ptr->u.syment.n_numaux > 0)
+       {
+         /* make a file symbol point to the name in the auxent, since
+            the text ".file" is redundant */
+         if ((internal_ptr + 1)->u.auxent.x_file.x_n.x_zeroes == 0)
+           {
+             /* the filename is a long one, point into the string table */
+             if (string_table == NULL)
+               string_table = build_string_table (abfd);
 
-  obj_raw_syments(abfd) = internal;
+             internal_ptr->u.syment._n._n_n._n_offset =
+               (long) (string_table - STRING_SIZE_SIZE +
+                       (internal_ptr + 1)->u.auxent.x_file.x_n.x_offset);
+           }
+         else
+           {
+             /* ordinary short filename, put into memory anyway */
+             internal_ptr->u.syment._n._n_n._n_offset = (long)
+               copy_name (abfd, (internal_ptr + 1)->u.auxent.x_file.x_fname,
+                          FILNMLEN);
+           }
+       }
+      else
+       {
+         if (internal_ptr->u.syment._n._n_n._n_zeroes != 0)
+           {
+             /* This is a "short" name.  Make it long.  */
+             unsigned long i = 0;
+             char *newstring = NULL;
+
+             /* find the length of this string without walking into memory
+                that isn't ours.  */
+             for (i = 0; i < 8; ++i)
+               {
+                 if (internal_ptr->u.syment._n._n_name[i] == '\0')
+                   {
+                     break;
+                   }           /* if end of string */
+               }               /* possible lengths of this string. */
+
+             if ((newstring = (PTR) bfd_alloc (abfd, ++i)) == NULL)
+               {
+                 bfd_set_error (bfd_error_no_memory);
+                 return (NULL);
+               }               /* on error */
+             memset (newstring, 0, i);
+             strncpy (newstring, internal_ptr->u.syment._n._n_name, i - 1);
+             internal_ptr->u.syment._n._n_n._n_offset = (long int) newstring;
+             internal_ptr->u.syment._n._n_n._n_zeroes = 0;
+           }
+         else if (internal_ptr->u.syment._n._n_n._n_offset == 0)
+           internal_ptr->u.syment._n._n_n._n_offset = (long int) "";
+         else if (!bfd_coff_symname_in_debug (abfd, &internal_ptr->u.syment))
+           {
+             /* Long name already.  Point symbol at the string in the
+                 table.  */
+             if (string_table == NULL)
+               string_table = build_string_table (abfd);
+             internal_ptr->u.syment._n._n_n._n_offset = (long int)
+               (string_table
+                - STRING_SIZE_SIZE
+                + internal_ptr->u.syment._n._n_n._n_offset);
+           }
+         else
+           {
+             /* Long name in debug section.  Very similar.  */
+             if (debug_section == NULL)
+               debug_section = build_debug_section (abfd);
+             internal_ptr->u.syment._n._n_n._n_offset = (long int)
+               (debug_section + internal_ptr->u.syment._n._n_n._n_offset);
+           }
+       }
+      internal_ptr += internal_ptr->u.syment.n_numaux;
+    }
+
+  obj_raw_syments (abfd) = internal;
   BFD_ASSERT (obj_raw_syment_count (abfd) == internal_ptr - internal);
 
   return (internal);
@@ -1432,25 +1463,27 @@ coff_get_normalized_symtab (abfd)
 
 long
 coff_get_reloc_upper_bound (abfd, asect)
-     bfd            *abfd;
-     sec_ptr         asect;
+     bfd *abfd;
+     sec_ptr asect;
 {
-  if (bfd_get_format(abfd) != bfd_object) {
-    bfd_set_error (bfd_error_invalid_operation);
-    return -1;
-  }
-  return (asect->reloc_count + 1) * sizeof(arelent *);
+  if (bfd_get_format (abfd) != bfd_object)
+    {
+      bfd_set_error (bfd_error_invalid_operation);
+      return -1;
+    }
+  return (asect->reloc_count + 1) * sizeof (arelent *);
 }
 
 asymbol *
 coff_make_empty_symbol (abfd)
-     bfd            *abfd;
+     bfd *abfd;
 {
-  coff_symbol_type *new = (coff_symbol_type *) bfd_alloc(abfd, sizeof(coff_symbol_type));
-  if (new == NULL) {
-    bfd_set_error (bfd_error_no_memory);
-    return (NULL);
-  }                            /* on error */
+  coff_symbol_type *new = (coff_symbol_type *) bfd_alloc (abfd, sizeof (coff_symbol_type));
+  if (new == NULL)
+    {
+      bfd_set_error (bfd_error_no_memory);
+      return (NULL);
+    }                          /* on error */
   memset (new, 0, sizeof *new);
   new->symbol.section = 0;
   new->native = 0;
@@ -1468,11 +1501,12 @@ coff_bfd_make_debug_symbol (abfd, ptr, sz)
      PTR ptr;
      unsigned long sz;
 {
-  coff_symbol_type *new = (coff_symbol_type *) bfd_alloc(abfd, sizeof(coff_symbol_type));
-  if (new == NULL) {
-    bfd_set_error (bfd_error_no_memory);
-    return (NULL);
-  }                            /* on error */
+  coff_symbol_type *new = (coff_symbol_type *) bfd_alloc (abfd, sizeof (coff_symbol_type));
+  if (new == NULL)
+    {
+      bfd_set_error (bfd_error_no_memory);
+      return (NULL);
+    }                          /* on error */
   /* @@ This shouldn't be using a constant multiplier.  */
   new->native = (combined_entry_type *) bfd_zalloc (abfd, sizeof (combined_entry_type) * 10);
   if (!new->native)
@@ -1480,14 +1514,15 @@ coff_bfd_make_debug_symbol (abfd, ptr, sz)
       bfd_set_error (bfd_error_no_memory);
       return (NULL);
     }                          /* on error */
-  new->symbol.section = &bfd_debug_section;
+  new->symbol.section = bfd_abs_section_ptr;
+  new->symbol.flags = BSF_DEBUGGING;
   new->lineno = (alent *) NULL;
   new->done_lineno = false;
   new->symbol.the_bfd = abfd;
   return &new->symbol;
 }
 
-/*ARGSUSED*/
+/*ARGSUSED */
 void
 coff_get_symbol_info (abfd, symbol, ret)
      bfd *abfd;
@@ -1516,22 +1551,22 @@ coff_print_symbol (abfd, filep, symbol, how)
 
     case bfd_print_symbol_more:
       fprintf (file, "coff %s %s",
-              coffsymbol(symbol)->native ? "n" : "g",
-              coffsymbol(symbol)->lineno ? "l" : " ");
+              coffsymbol (symbol)->native ? "n" : "g",
+              coffsymbol (symbol)->lineno ? "l" : " ");
       break;
 
     case bfd_print_symbol_all:
-      if (coffsymbol(symbol)->native) 
+      if (coffsymbol (symbol)->native)
        {
          unsigned int aux;
          combined_entry_type *combined = coffsymbol (symbol)->native;
          combined_entry_type *root = obj_raw_syments (abfd);
-         struct lineno_cache_entry *l = coffsymbol(symbol)->lineno;
-       
-         fprintf (file,"[%3ld]", (long) (combined - root));
+         struct lineno_cache_entry *l = coffsymbol (symbol)->lineno;
+
+         fprintf (file, "[%3ld]", (long) (combined - root));
 
          fprintf (file,
-                  "(sc %2d)(fl 0x%02x)(ty %3x)(sc %3d) (nx %d) 0x%08lx %s",
+                  "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x%08lx %s",
                   combined->u.syment.n_scnum,
                   combined->u.syment.n_flags,
                   combined->u.syment.n_type,
@@ -1540,7 +1575,7 @@ coff_print_symbol (abfd, filep, symbol, how)
                   (unsigned long) combined->u.syment.n_value,
                   symbol->name);
 
-         for (aux = 0; aux < combined->u.syment.n_numaux; aux++) 
+         for (aux = 0; aux < combined->u.syment.n_numaux; aux++)
            {
              combined_entry_type *auxp = combined + aux + 1;
              long tagndx;
@@ -1582,12 +1617,12 @@ coff_print_symbol (abfd, filep, symbol, how)
                  break;
                }
            }
-       
+
          if (l)
            {
              fprintf (file, "\n%s :", l->u.sym->name);
              l++;
-             while (l->line_number) 
+             while (l->line_number)
                {
                  fprintf (file, "\n%4d : 0x%lx",
                           l->line_number,
@@ -1596,14 +1631,14 @@ coff_print_symbol (abfd, filep, symbol, how)
                  l++;
                }
            }
-       } 
+       }
       else
        {
          bfd_print_symbol_vandf ((PTR) file, symbol);
          fprintf (file, " %-5s %s %s %s",
                   symbol->section->name,
-                  coffsymbol(symbol)->native ? "n" : "g",
-                  coffsymbol(symbol)->lineno ? "l" : " ",
+                  coffsymbol (symbol)->native ? "n" : "g",
+                  coffsymbol (symbol)->lineno ? "l" : " ",
                   symbol->name);
        }
     }
@@ -1617,27 +1652,27 @@ coff_print_symbol (abfd, filep, symbol, how)
 boolean
 coff_find_nearest_line (abfd, section, ignore_symbols, offset, filename_ptr,
                        functionname_ptr, line_ptr)
-     bfd            *abfd;
-     asection       *section;
-     asymbol       **ignore_symbols;
-     bfd_vma         offset;
-     CONST char      **filename_ptr;
-     CONST char       **functionname_ptr;
-     unsigned int   *line_ptr;
+     bfd *abfd;
+     asection *section;
+     asymbol **ignore_symbols;
+     bfd_vma offset;
+     CONST char **filename_ptr;
+     CONST char **functionname_ptr;
+     unsigned int *line_ptr;
 {
-  static bfd     *cache_abfd;
+  static bfd *cache_abfd;
   static asection *cache_section;
-  static bfd_vma  cache_offset;
+  static bfd_vma cache_offset;
   static unsigned int cache_i;
   static CONST char *cache_function;
-  static unsigned int    line_base = 0;
+  static unsigned int line_base = 0;
 
   unsigned int i;
-  coff_data_type *cof = coff_data(abfd);
+  coff_data_type *cof = coff_data (abfd);
   /* Run through the raw syments if available */
   combined_entry_type *p;
   combined_entry_type *pend;
-  alent          *l;
+  alent *l;
 
 
   *filename_ptr = 0;
@@ -1708,58 +1743,63 @@ coff_find_nearest_line (abfd, section, ignore_symbols, offset, filename_ptr,
     }
 
   /* Now wander though the raw linenumbers of the section */
-  /*
-    If this is the same BFD as we were previously called with and this is
-    the same section, and the offset we want is further down then we can
-    prime the lookup loop
-    */
+  /* If this is the same BFD as we were previously called with and
+     this is the same section, and the offset we want is further down
+     then we can prime the lookup loop.  */
   if (abfd == cache_abfd &&
       section == cache_section &&
-      offset >= cache_offset) {
-    i = cache_i;
-    *functionname_ptr = cache_function;
-  }
-  else {
-    i = 0;
-  }
+      offset >= cache_offset)
+    {
+      i = cache_i;
+      *functionname_ptr = cache_function;
+    }
+  else
+    {
+      i = 0;
+    }
   l = &section->lineno[i];
 
-  for (; i < section->lineno_count; i++) {
-    if (l->line_number == 0) {
-      /* Get the symbol this line number points at */
-      coff_symbol_type *coff = (coff_symbol_type *) (l->u.sym);
-      if (coff->symbol.value > offset)
-       break;
-      *functionname_ptr = coff->symbol.name;
-      if (coff->native) {
-       combined_entry_type  *s = coff->native;
-       s = s + 1 + s->u.syment.n_numaux;
-
-       /* In XCOFF a debugging symbol can follow the function
-          symbol.  */
-       if (s->u.syment.n_scnum == N_DEBUG)
-         s = s + 1 + s->u.syment.n_numaux;
-
-       /*
-         S should now point to the .bf of the function
-         */
-       if (s->u.syment.n_numaux) {
-         /*
-           The linenumber is stored in the auxent
-           */
-         union internal_auxent   *a = &((s + 1)->u.auxent);
-         line_base = a->x_sym.x_misc.x_lnsz.x_lnno;
-         *line_ptr = line_base;
+  for (; i < section->lineno_count; i++)
+    {
+      if (l->line_number == 0)
+       {
+         /* Get the symbol this line number points at */
+         coff_symbol_type *coff = (coff_symbol_type *) (l->u.sym);
+         if (coff->symbol.value > offset)
+           break;
+         *functionname_ptr = coff->symbol.name;
+         if (coff->native)
+           {
+             combined_entry_type *s = coff->native;
+             s = s + 1 + s->u.syment.n_numaux;
+
+             /* In XCOFF a debugging symbol can follow the function
+                symbol.  */
+             if (s->u.syment.n_scnum == N_DEBUG)
+               s = s + 1 + s->u.syment.n_numaux;
+
+             /*
+                S should now point to the .bf of the function
+              */
+             if (s->u.syment.n_numaux)
+               {
+                 /*
+                    The linenumber is stored in the auxent
+                  */
+                 union internal_auxent *a = &((s + 1)->u.auxent);
+                 line_base = a->x_sym.x_misc.x_lnsz.x_lnno;
+                 *line_ptr = line_base;
+               }
+           }
        }
-      }
-    }
-    else {
-      if (l->u.offset + bfd_get_section_vma (abfd, section) > offset)
-       break;
-      *line_ptr = l->line_number + line_base - 1;
+      else
+       {
+         if (l->u.offset + bfd_get_section_vma (abfd, section) > offset)
+           break;
+         *line_ptr = l->line_number + line_base - 1;
+       }
+      l++;
     }
-    l++;
-  }
 
   cache_abfd = abfd;
   cache_section = section;
@@ -1775,15 +1815,17 @@ coff_sizeof_headers (abfd, reloc)
      bfd *abfd;
      boolean reloc;
 {
-    size_t size;
+  size_t size;
 
-    if (reloc == false) {
-       size = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
+  if (reloc == false)
+    {
+      size = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
     }
-    else {
-       size = bfd_coff_filhsz (abfd);
+  else
+    {
+      size = bfd_coff_filhsz (abfd);
     }
 
-    size +=  abfd->section_count * bfd_coff_scnhsz (abfd);
-    return size;
+  size += abfd->section_count * bfd_coff_scnhsz (abfd);
+  return size;
 }