*** empty log message ***

1 files changed, 507 insertions, 442 deletions

diff --git a/ld/ldmain.c b/ld/ldmain.c
index 329ae8bef9..fa02f26db3 100644
--- a/ld/ldmain.c
+++ b/ld/ldmain.c
@@ -1,6 +1,6 @@
 /* Copyright (C) 1991 Free Software Foundation, Inc.
    Written by Steve Chamberlain steve@cygnus.com
-   
+
 This file is part of GLD, the Gnu Linker.
 
 GLD is free software; you can redistribute it and/or modify
@@ -40,10 +40,12 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
 /* IMPORTS */
 extern boolean lang_has_input_file;
 extern boolean trace_files;
+
 /* EXPORTS */
 
 char *default_target;
 char *output_filename = "a.out";
+
 /* Name this program was invoked by.  */
 char *program_name;
 
@@ -58,7 +60,6 @@ char lprefix = 'L';
 /* Count the number of global symbols multiply defined.  */
 int multiple_def_count;
 
-
 /* Count the number of symbols defined through common declarations.
    This count is referenced in symdef_library, linear_library, and
    modified by enter_global_ref.
@@ -71,13 +72,11 @@ int multiple_def_count;
 
 unsigned int commons_pending;
 
-/* Count the number of global symbols referenced and not defined. 
+/* Count the number of global symbols referenced and not defined.
    common symbols are not included in this count.   */
 
 unsigned int undefined_global_sym_count;
 
-
-
 /* Count the number of warning symbols encountered. */
 int warning_count;
 
@@ -87,16 +86,16 @@ extern boolean had_script;
 /* Nonzero means print names of input files as processed.  */
 boolean trace_files;
 
-
-
 /* 1 => write load map.  */
 boolean write_map;
 
 
 int unix_relocate;
+
 #ifdef GNU960
 /* Indicates whether output file will be b.out (default) or coff */
 enum target_flavour output_flavor = BFD_BOUT_FORMAT;
+
 #endif
 
 /* Force the make_executable to be output, even if there are non-fatal
@@ -113,7 +112,6 @@ unsigned int total_symbols_seen;
  */
 unsigned int total_files_seen;
 
-
 /* IMPORTS */
 args_type command_line;
 ld_config_type config;
@@ -123,27 +121,30 @@ main (argc, argv)
      int argc;
 {
   char *emulation;
+
   program_name = argv[0];
   output_filename = "a.out";
 
-  bfd_init();
+  bfd_init ();
 
 #ifdef GNU960
-{
-  int i;
- 
-  check_v960( argc, argv );
-  emulation = "gld960";
-  for ( i = 1; i < argc; i++ ){
-      if ( !strcmp(argv[i],"-Fcoff") ){
-	  emulation = "lnk960";
-	  output_flavor = BFD_COFF_FORMAT;
-	  break;
-	}
-    }
-}
+  {
+    int i;
+
+    check_v960 (argc, argv);
+    emulation = "gld960";
+    for (i = 1; i < argc; i++)
+      {
+	if (!strcmp (argv[i], "-Fcoff"))
+	  {
+	    emulation = "lnk960";
+	    output_flavor = BFD_COFF_FORMAT;
+	    break;
+	  }
+      }
+  }
 #else
-  emulation =  (char *) getenv(EMULATION_ENVIRON); 
+  emulation = (char *) getenv (EMULATION_ENVIRON);
 #endif
 
   /* Initialize the data about options.  */
@@ -155,9 +156,9 @@ main (argc, argv)
   unix_relocate = 0;
   command_line.force_common_definition = false;
 
-  init_bfd_error_vector();
-  ldsym_init();  
-  ldfile_add_arch("");
+  init_bfd_error_vector ();
+  ldsym_init ();
+  ldfile_add_arch ("");
 
   config.make_executable = true;
   force_make_executable = false;
@@ -172,131 +173,141 @@ main (argc, argv)
   config.magic_demand_paged = true;
   config.text_read_only = true;
   config.make_executable = true;
-  if (emulation == (char *)NULL) {
-      emulation=  DEFAULT_EMULATION;
+  if (emulation == (char *) NULL)
+    {
+      emulation = DEFAULT_EMULATION;
     }
 
-  ldemul_choose_mode(emulation);
-  default_target =  ldemul_choose_target();
-  lang_init();
-  ldemul_before_parse();
+  ldemul_choose_mode (emulation);
+  default_target = ldemul_choose_target ();
+  lang_init ();
+  ldemul_before_parse ();
   lang_has_input_file = false;
-  parse_args(argc, argv);
-  lang_final(); 
+  parse_args (argc, argv);
+  lang_final ();
 
-  if (trace_files) {
+  if (trace_files)
+    {
 
-      info("%P: mode %s\n", emulation);
+      info ("%P: mode %s\n", emulation);
 
     }
-  if (lang_has_input_file == false) {
-      einfo("%P%F: No input files\n");
+  if (lang_has_input_file == false)
+    {
+      einfo ("%P%F: No input files\n");
     }
 
-  ldemul_after_parse();
+  ldemul_after_parse ();
 
 
-  if (config.map_filename) 
-  {
-    if (strcmp(config.map_filename, "-") == 0) 
+  if (config.map_filename)
     {
-      config.map_file = stdout;
-    }
-    else {
-	config.map_file = fopen(config.map_filename, FOPEN_WT);
-	if (config.map_file == (FILE *)NULL) 
+      if (strcmp (config.map_filename, "-") == 0)
 	{
-	  einfo("%P%F: can't open map file %s\n",
-		config.map_filename);
+	  config.map_file = stdout;
 	}
-      }
-  }
+      else
+	{
+	  config.map_file = fopen (config.map_filename, FOPEN_WT);
+	  if (config.map_file == (FILE *) NULL)
+	    {
+	      einfo ("%P%F: can't open map file %s\n",
+		     config.map_filename);
+	    }
+	}
+    }
 
 
-  lang_process();
+  lang_process ();
 
   /* Print error messages for any missing symbols, for any warning
      symbols, and possibly multiple definitions */
 
 
-  if (config.text_read_only) 
-  {
-    /* Look for a text section and mark the readonly attribute in it */
-    asection *found = bfd_get_section_by_name(output_bfd, ".text");
-    if (found != (asection *)NULL) {
-      found->flags |= SEC_READONLY;
+  if (config.text_read_only)
+    {
+      /* Look for a text section and mark the readonly attribute in it */
+      asection *found = bfd_get_section_by_name (output_bfd, ".text");
+
+      if (found != (asection *) NULL)
+	{
+	  found->flags |= SEC_READONLY;
+	}
     }
-  }
 
-  if (config.relocateable_output) {
+  if (config.relocateable_output)
+    {
       output_bfd->flags &= ~EXEC_P;
 
-      ldwrite();
-      bfd_close(output_bfd);
+      ldwrite ();
+      bfd_close (output_bfd);
     }
 
   else
-  {
+    {
 
-    output_bfd->flags |= EXEC_P;
+      output_bfd->flags |= EXEC_P;
 
-    ldwrite();
+      ldwrite ();
 
 
-    if (config.make_executable == false && force_make_executable ==false) 
-    {
+      if (config.make_executable == false && force_make_executable == false)
+	{
 
-      if (trace_files == true) 
-      {
-	einfo("%P: Link errors found, deleting executable `%s'\n",
-	      output_filename);
-      }
+	  if (trace_files == true)
+	    {
+	      einfo ("%P: Link errors found, deleting executable `%s'\n",
+		     output_filename);
+	    }
 
-      if (output_bfd->iostream)
-       fclose((FILE*)(output_bfd->iostream));
+	  if (output_bfd->iostream)
+	    fclose ((FILE *) (output_bfd->iostream));
 
-      unlink(output_filename);
-      exit(1);
+	  unlink (output_filename);
+	  exit (1);
+	}
+      else
+	{
+	  bfd_close (output_bfd);
+	}
     }
-    else {  
-	bfd_close(output_bfd); 
-      }
-  }	
 
 
 
-  exit(0);
+  exit (0);
 }				/* main() */
 
-
 void
 Q_read_entry_symbols (desc, entry)
      bfd *desc;
      struct lang_input_statement_struct *entry;
 {
-  if (entry->asymbols == (asymbol **)NULL) {
-    bfd_size_type table_size = get_symtab_upper_bound(desc);
-    entry->asymbols = (asymbol **)ldmalloc(table_size);
-    entry->symbol_count =  bfd_canonicalize_symtab(desc, entry->asymbols) ;
-  }
-}
+  if (entry->asymbols == (asymbol **) NULL)
+    {
+      bfd_size_type table_size = get_symtab_upper_bound (desc);
 
+      entry->asymbols = (asymbol **) ldmalloc (table_size);
+      entry->symbol_count = bfd_canonicalize_symtab (desc, entry->asymbols);
+    }
+}
 
 /*
- * turn this item into a reference 
+ * turn this item into a reference
  */
- void
-refize(sp, nlist_p)
-ldsym_type *sp;
-asymbol **nlist_p;
+void
+refize (sp, nlist_p)
+     ldsym_type *sp;
+     asymbol **nlist_p;
 {
   asymbol *sym = *nlist_p;
+
   sym->value = 0;
   sym->flags = 0;
   sym->section = &bfd_und_section;
-  sym->udata =(PTR)( sp->srefs_chain);
+  sym->udata = (PTR) (sp->srefs_chain);
   sp->srefs_chain = nlist_p;
 }
+
 /*
 This function is called for each name which is seen which has a global
 scope. It enters the name into the global symbol table in the correct
@@ -323,176 +334,212 @@ definitions seen, undefined global symbols and pending commons.
 extern boolean relaxing;
 
 void
-DEFUN(Q_enter_global_ref,(nlist_p, name),
-      asymbol **nlist_p AND /* pointer into symbol table from incoming bfd */
-      CONST char *name            /* name of symbol in linker table */ )
+DEFUN (Q_enter_global_ref, (nlist_p, name),
+       asymbol ** nlist_p AND	/* pointer into symbol table from incoming bfd */
+       CONST char *name /* name of symbol in linker table */ )
 {
   asymbol *sym = *nlist_p;
-  ldsym_type *sp ;
+  ldsym_type *sp;
 
   /* Lookup the name from the incoming bfd's symbol table in the
      linker's global symbol table */
 
 
   flagword this_symbol_flags = sym->flags;
+
   sp = ldsym_get (name);
 
-  ASSERT(sym->udata == 0);
+  ASSERT (sym->udata == 0);
 
 
-  if (flag_is_constructor(this_symbol_flags))  {
-    /* Add this constructor to the list we keep */
-    ldlang_add_constructor(sp);
-    /* Turn any commons into refs */
-    if (sp->scoms_chain != (asymbol **)NULL) {
-      refize(sp, sp->scoms_chain);
-      sp->scoms_chain = 0;
-    }
+  if (flag_is_constructor (this_symbol_flags))
+    {
+      /* Add this constructor to the list we keep */
+      ldlang_add_constructor (sp);
+      /* Turn any commons into refs */
+      if (sp->scoms_chain != (asymbol **) NULL)
+	{
+	  refize (sp, sp->scoms_chain);
+	  sp->scoms_chain = 0;
+	}
 
 
-  }
-  else {  
-    if (sym->section == &bfd_com_section) {
-      /* If we have a definition of this symbol already then
-         this common turns into a reference. Also we only
-         ever point to the largest common, so if we
-         have a common, but it's bigger that the new symbol
-         the turn this into a reference too. */
-      if (sp->sdefs_chain)  
-	  {
-	    /* This is a common symbol, but we already have a definition
-	       for it, so just link it into the ref chain as if
-	       it were a reference  */
-	    refize(sp, nlist_p);
-	  }
-      else  if (sp->scoms_chain) {
-	/* If we have a previous common, keep only the biggest */
-	if ( (*(sp->scoms_chain))->value > sym->value) {
-	  /* other common is bigger, throw this one away */
-	  refize(sp, nlist_p);
-	}
-	else if (sp->scoms_chain != nlist_p) {
-	  /* other common is smaller, throw that away */
-	  refize(sp, sp->scoms_chain);
-	  sp->scoms_chain = nlist_p;
-	}
-      }
-      else {
-	/* This is the first time we've seen a common, so remember it
-	   - if it was undefined before, we know it's defined now. If
-	   the symbol has been marked as really being a constructor,
-	   then treat this as a ref 
-	   */
-	if (sp->flags & SYM_CONSTRUCTOR) {
-	  /* Turn this into a ref */
-	  refize(sp, nlist_p);
+    }
+  else
+    {
+      if (sym->section == &bfd_com_section)
+	{
+	  /* If we have a definition of this symbol already then
+             this common turns into a reference. Also we only
+             ever point to the largest common, so if we
+             have a common, but it's bigger that the new symbol
+             the turn this into a reference too. */
+	  if (sp->sdefs_chain)
+	    {
+	      /* This is a common symbol, but we already have a definition
+	         for it, so just link it into the ref chain as if
+	         it were a reference  */
+	      refize (sp, nlist_p);
+	    }
+	  else if (sp->scoms_chain)
+	    {
+	      /* If we have a previous common, keep only the biggest */
+	      if ((*(sp->scoms_chain))->value > sym->value)
+		{
+		  /* other common is bigger, throw this one away */
+		  refize (sp, nlist_p);
+		}
+	      else if (sp->scoms_chain != nlist_p)
+		{
+		  /* other common is smaller, throw that away */
+		  refize (sp, sp->scoms_chain);
+		  sp->scoms_chain = nlist_p;
+		}
+	    }
+	  else
+	    {
+	      /* This is the first time we've seen a common, so remember it
+	         - if it was undefined before, we know it's defined now. If
+	         the symbol has been marked as really being a constructor,
+	         then treat this as a ref
+	         */
+	      if (sp->flags & SYM_CONSTRUCTOR)
+		{
+		  /* Turn this into a ref */
+		  refize (sp, nlist_p);
+		}
+	      else
+		{
+		  /* treat like a common */
+		  if (sp->srefs_chain)
+		    undefined_global_sym_count--;
+
+		  commons_pending++;
+		  sp->scoms_chain = nlist_p;
+		}
+	    }
 	}
-	else {
-	  /* treat like a common */
-	  if (sp->srefs_chain)
-	    undefined_global_sym_count--;
 
-	  commons_pending++;
-	  sp->scoms_chain = nlist_p;
+      else if (sym->section != &bfd_und_section)
+	{
+	  /* This is the definition of a symbol, add to def chain */
+	  if (sp->sdefs_chain && (*(sp->sdefs_chain))->section != sym->section)
+	    {
+	      /* Multiple definition */
+	      asymbol *sy = *(sp->sdefs_chain);
+	      lang_input_statement_type *stat = (lang_input_statement_type *) sy->the_bfd->usrdata;
+	      lang_input_statement_type *stat1 = (lang_input_statement_type *) sym->the_bfd->usrdata;
+	      asymbol **stat1_symbols = stat1 ? stat1->asymbols : 0;
+	      asymbol **stat_symbols = stat ? stat->asymbols : 0;
+
+	      multiple_def_count++;
+	      einfo ("%X%C: multiple definition of `%T'\n",
+		sym->the_bfd, sym->section, stat1_symbols, sym->value, sym);
+
+	      einfo ("%X%C: first seen here\n",
+		     sy->the_bfd, sy->section, stat_symbols, sy->value);
+	    }
+	  else
+	    {
+	      sym->udata = (PTR) (sp->sdefs_chain);
+	      sp->sdefs_chain = nlist_p;
+	    }
+	  /* A definition overrides a common symbol */
+	  if (sp->scoms_chain)
+	    {
+	      refize (sp, sp->scoms_chain);
+	      sp->scoms_chain = 0;
+	      commons_pending--;
+	    }
+	  else if (sp->srefs_chain && relaxing == false)
+	    {
+	      /* If previously was undefined, then remember as defined */
+	      undefined_global_sym_count--;
+	    }
 	}
-      }
-    }
-
-    else if (sym->section != &bfd_und_section) {
-      /* This is the definition of a symbol, add to def chain */
-      if (sp->sdefs_chain && (*(sp->sdefs_chain))->section != sym->section) {
-	/* Multiple definition */
-	asymbol *sy = *(sp->sdefs_chain);
-	lang_input_statement_type *stat = (lang_input_statement_type *) sy->the_bfd->usrdata;
-	lang_input_statement_type *stat1 = (lang_input_statement_type *) sym->the_bfd->usrdata;
-	asymbol ** stat1_symbols  = stat1 ? stat1->asymbols: 0;
-	asymbol ** stat_symbols = stat ? stat->asymbols:0;
-      
-	multiple_def_count++;
-	einfo("%X%C: multiple definition of `%T'\n",
-	      sym->the_bfd, sym->section, stat1_symbols, sym->value, sym);
-	   
-	einfo("%X%C: first seen here\n",
-	      sy->the_bfd, sy->section, stat_symbols, sy->value);
-      }
-      else {
-	sym->udata =(PTR)( sp->sdefs_chain);
-	sp->sdefs_chain = nlist_p;
-      }
-      /* A definition overrides a common symbol */
-      if (sp->scoms_chain) {
-	refize(sp, sp->scoms_chain);
-	sp->scoms_chain = 0;
-	commons_pending--;
-      }
-      else if (sp->srefs_chain && relaxing == false) {
-	/* If previously was undefined, then remember as defined */
-	undefined_global_sym_count--;
-      }
-    }
-    else {
-      if (sp->scoms_chain == (asymbol **)NULL 
-	  && sp->srefs_chain == (asymbol **)NULL 
-	  && sp->sdefs_chain == (asymbol **)NULL) {
-	/* And it's the first time we've seen it */
-	undefined_global_sym_count++;
+      else
+	{
+	  if (sp->scoms_chain == (asymbol **) NULL
+	      && sp->srefs_chain == (asymbol **) NULL
+	      && sp->sdefs_chain == (asymbol **) NULL)
+	    {
+	      /* And it's the first time we've seen it */
+	      undefined_global_sym_count++;
 
-      }
+	    }
 
-      refize(sp, nlist_p);
+	  refize (sp, nlist_p);
+	}
     }
-  }
 
-  ASSERT(sp->sdefs_chain == 0 || sp->scoms_chain == 0);
-  ASSERT(sp->scoms_chain ==0 || (*(sp->scoms_chain))->udata == 0);
+  ASSERT (sp->sdefs_chain == 0 || sp->scoms_chain == 0);
+  ASSERT (sp->scoms_chain == 0 || (*(sp->scoms_chain))->udata == 0);
 
 
 }
 
 static void
 Q_enter_file_symbols (entry)
-lang_input_statement_type *entry;
+     lang_input_statement_type *entry;
 {
-  asymbol **q ;
+  asymbol **q;
 
   entry->common_section =
-   bfd_make_section_old_way(entry->the_bfd, "COMMON");
-  
-  ldlang_add_file(entry);
-
+    bfd_make_section_old_way (entry->the_bfd, "COMMON");
 
-  if (trace_files || option_v) {
-      info("%I\n", entry);
-    }
+  ldlang_add_file (entry);
 
-  total_symbols_seen += entry->symbol_count;
-  total_files_seen ++;
-if (entry->symbol_count)
-  for (q = entry->asymbols; *q; q++)
-  {
-    asymbol *p = *q;
 
-    if (p->flags & BSF_INDIRECT) 
+  if (trace_files || option_v)
     {
-      add_indirect(q);
+      info ("%I\n", entry);
     }
-    else if (p->flags & BSF_WARNING) 
-    {
-      add_warning(p);
-    }
-    else   if (p->section == &bfd_und_section
-	       || (p->flags & BSF_GLOBAL) 
-	       || p->section == &bfd_com_section
-	       || (p->flags & BSF_CONSTRUCTOR))
+
+  total_symbols_seen += entry->symbol_count;
+  total_files_seen++;
+  if (entry->symbol_count)
     {
-      Q_enter_global_ref(q, p->name);
-    }
+      for (q = entry->asymbols; *q; q++)
+	{
+	  asymbol *p = *q;
 
+	  if (p->flags & BSF_INDIRECT)
+	    {
+	      add_indirect (q);
+	    }
+	  else if (p->flags & BSF_WARNING)
+	    {
+	      add_warning (p);
+	    }
+	  else if (p->section == &bfd_und_section
+		   || (p->flags & BSF_GLOBAL)
+		   || p->section == &bfd_com_section
+		   || (p->flags & BSF_CONSTRUCTOR))
 
-  }
-}
+	    {
 
+	      asymbol *p = *q;
 
+	      if (p->flags & BSF_INDIRECT)
+		{
+		  add_indirect (q);
+		}
+	      else if (p->flags & BSF_WARNING)
+		{
+		  add_warning (p);
+		}
+	      else if (p->section == &bfd_und_section
+		       || (p->flags & BSF_GLOBAL)
+		       || p->section == &bfd_com_section
+		       || (p->flags & BSF_CONSTRUCTOR))
+		{
+		  Q_enter_global_ref (q, p->name);
+		}
+
+	    }
+	}
+    }
+}
 
 /* Searching libraries */
 
@@ -510,53 +557,55 @@ search_library (entry)
 {
 
   /* No need to load a library if no undefined symbols */
-  if (!undefined_global_sym_count) return;
+  if (!undefined_global_sym_count)
+    return;
 
-  if (bfd_has_map(entry->the_bfd)) 
+  if (bfd_has_map (entry->the_bfd))
     symdef_library (entry);
   else
     linear_library (entry);
 
 }
 
-
 #ifdef GNU960
 static
-boolean
+       boolean
 gnu960_check_format (abfd, format)
-bfd *abfd;
-bfd_format format;
+     bfd *abfd;
+     bfd_format format;
 {
   boolean retval;
 
-  if ((bfd_check_format(abfd,format) == true)
-      &&  (abfd->xvec->flavour == output_flavor) ){
-    return true;
-  }
+  if ((bfd_check_format (abfd, format) == true)
+      && (abfd->xvec->flavour == output_flavor))
+    {
+      return true;
+    }
 
 
   return false;
 }
+
 #endif
 
 void
 ldmain_open_file_read_symbol (entry)
-struct lang_input_statement_struct *entry;
+     struct lang_input_statement_struct *entry;
 {
-  if (entry->asymbols == (asymbol **)NULL
-      &&entry->real == true 
-      && entry->filename != (char *)NULL)
+  if (entry->asymbols == (asymbol **) NULL
+      && entry->real == true
+      && entry->filename != (char *) NULL)
     {
       ldfile_open_file (entry);
 
 
 #ifdef GNU960
-      if (gnu960_check_format(entry->the_bfd, bfd_object))
+      if (gnu960_check_format (entry->the_bfd, bfd_object))
 #else
-      if (bfd_check_format(entry->the_bfd, bfd_object))
+      if (bfd_check_format (entry->the_bfd, bfd_object))
 #endif
 	{
-	  entry->the_bfd->usrdata = (PTR)entry;
+	  entry->the_bfd->usrdata = (PTR) entry;
 
 
 	  Q_read_entry_symbols (entry->the_bfd, entry);
@@ -568,26 +617,25 @@ struct lang_input_statement_struct *entry;
 	  Q_enter_file_symbols (entry);
 	}
 #ifdef GNU960
-      else if (gnu960_check_format(entry->the_bfd, bfd_archive)) 
+      else if (gnu960_check_format (entry->the_bfd, bfd_archive))
 #else
-      else if (bfd_check_format(entry->the_bfd, bfd_archive)) 
+      else if (bfd_check_format (entry->the_bfd, bfd_archive))
 #endif
 	{
-	  entry->the_bfd->usrdata = (PTR)entry;
+	  entry->the_bfd->usrdata = (PTR) entry;
 
-	  entry->subfiles = (lang_input_statement_type *)NULL;
+	  entry->subfiles = (lang_input_statement_type *) NULL;
 	  search_library (entry);
 	}
-      else 
+      else
 	{
-	  einfo("%F%B: malformed input file (not rel or archive) \n",
-		entry->the_bfd);
+	  einfo ("%F%B: malformed input file (not rel or archive) \n",
+		 entry->the_bfd);
 	}
     }
 
 }
 
-
 /* Construct and return a lang_input_statement_struct for a library member.
    The library's lang_input_statement_struct is library_entry,
    and the library is open on DESC.
@@ -600,9 +648,10 @@ decode_library_subfile (library_entry, subfile_offset)
      bfd *subfile_offset;
 {
   register struct lang_input_statement_struct *subentry;
-  subentry = (struct lang_input_statement_struct *) ldmalloc ((bfd_size_type)(sizeof (struct lang_input_statement_struct)));
-  subentry->filename = subfile_offset -> filename;
-  subentry->local_sym_name  = subfile_offset->filename;
+  subentry = (struct lang_input_statement_struct *) ldmalloc ((bfd_size_type) (sizeof (struct lang_input_statement_struct)));
+
+  subentry->filename = subfile_offset->filename;
+  subentry->local_sym_name = subfile_offset->filename;
   subentry->asymbols = 0;
   subentry->the_bfd = subfile_offset;
   subentry->subfiles = 0;
@@ -617,22 +666,25 @@ decode_library_subfile (library_entry, subfile_offset)
   return subentry;
 }
 
-boolean  subfile_wanted_p ();
+boolean subfile_wanted_p ();
 void
-clear_syms(entry, offset)
-struct lang_input_statement_struct *entry;
-file_ptr offset;
+clear_syms (entry, offset)
+     struct lang_input_statement_struct *entry;
+     file_ptr offset;
 {
   carsym *car;
-  unsigned long indx = bfd_get_next_mapent(entry->the_bfd,
-					   BFD_NO_MORE_SYMBOLS,
-					   &car);
-  while (indx != BFD_NO_MORE_SYMBOLS) {
-    if (car->file_offset == offset) {
-      car->name = 0;
+  unsigned long indx = bfd_get_next_mapent (entry->the_bfd,
+					    BFD_NO_MORE_SYMBOLS,
+					    &car);
+
+  while (indx != BFD_NO_MORE_SYMBOLS)
+    {
+      if (car->file_offset == offset)
+	{
+	  car->name = 0;
+	}
+      indx = bfd_get_next_mapent (entry->the_bfd, indx, &car);
     }
-    indx = bfd_get_next_mapent(entry->the_bfd, indx, &car);
-  }
 
 }
 
@@ -647,174 +699,181 @@ symdef_library (entry)
 
   boolean not_finished = true;
 
-
   while (not_finished == true)
-      {
-	carsym *exported_library_name;
-	bfd *prev_archive_member_bfd = 0;    
+    {
+      carsym *exported_library_name;
+      bfd *prev_archive_member_bfd = 0;
 
-	int idx = bfd_get_next_mapent(entry->the_bfd,
-				      BFD_NO_MORE_SYMBOLS,
-				      &exported_library_name);
+      int idx = bfd_get_next_mapent (entry->the_bfd,
+				     BFD_NO_MORE_SYMBOLS,
+				     &exported_library_name);
 
-	not_finished = false;
+      not_finished = false;
 
-	while (idx != BFD_NO_MORE_SYMBOLS  && undefined_global_sym_count)
-	    {
+      while (idx != BFD_NO_MORE_SYMBOLS && undefined_global_sym_count)
+	{
 
-	      if (exported_library_name->name) 
-		  {
+	  if (exported_library_name->name)
+	    {
 
-		    ldsym_type *sp =  ldsym_get_soft (exported_library_name->name);
+	      ldsym_type *sp = ldsym_get_soft (exported_library_name->name);
 
-		    /* If we find a symbol that appears to be needed, think carefully
-		       about the archive member that the symbol is in.  */
-		    /* So - if it exists, and is referenced somewhere and is
-		       undefined or */
-		    if (sp && sp->srefs_chain && !sp->sdefs_chain)
-			{
-			  bfd *archive_member_bfd = bfd_get_elt_at_index(entry->the_bfd, idx);
-			  struct lang_input_statement_struct *archive_member_lang_input_statement_struct;
+	      /* If we find a symbol that appears to be needed, think carefully
+	         about the archive member that the symbol is in.  */
+	      /* So - if it exists, and is referenced somewhere and is
+	         undefined or */
+	      if (sp && sp->srefs_chain && !sp->sdefs_chain)
+		{
+		  bfd *archive_member_bfd = bfd_get_elt_at_index (entry->the_bfd, idx);
+		  struct lang_input_statement_struct *archive_member_lang_input_statement_struct;
 
 #ifdef GNU960
-			  if (archive_member_bfd && gnu960_check_format(archive_member_bfd, bfd_object)) 
+		  if (archive_member_bfd && gnu960_check_format (archive_member_bfd, bfd_object))
 #else
-			    if (archive_member_bfd && bfd_check_format(archive_member_bfd, bfd_object)) 
+		  if (archive_member_bfd && bfd_check_format (archive_member_bfd, bfd_object))
 #endif
-				{
+		    {
 
-				  /* Don't think carefully about any archive member
-				     more than once in a given pass.  */
-				  if (prev_archive_member_bfd != archive_member_bfd)
-				      {
+		      /* Don't think carefully about any archive member
+		         more than once in a given pass.  */
+		      if (prev_archive_member_bfd != archive_member_bfd)
+			{
 
-					prev_archive_member_bfd = archive_member_bfd;
+			  prev_archive_member_bfd = archive_member_bfd;
 
-					/* Read the symbol table of the archive member.  */
+			  /* Read the symbol table of the archive member.  */
 
-					if (archive_member_bfd->usrdata != (PTR)NULL) {
+			  if (archive_member_bfd->usrdata != (PTR) NULL)
+			    {
 
-					  archive_member_lang_input_statement_struct =(lang_input_statement_type *) archive_member_bfd->usrdata;
-					}
-					else {
+			      archive_member_lang_input_statement_struct = (lang_input_statement_type *) archive_member_bfd->usrdata;
+			    }
+			  else
+			    {
 
-					  archive_member_lang_input_statement_struct =
-					    decode_library_subfile (entry, archive_member_bfd);
-					  archive_member_bfd->usrdata = (PTR) archive_member_lang_input_statement_struct;
+			      archive_member_lang_input_statement_struct =
+				decode_library_subfile (entry, archive_member_bfd);
+			      archive_member_bfd->usrdata = (PTR) archive_member_lang_input_statement_struct;
 
-					}
+			    }
 
-					if (archive_member_lang_input_statement_struct == 0) {
-					  einfo ("%F%I contains invalid archive member %s\n",
-						 entry, sp->name);
-					}
+			  if (archive_member_lang_input_statement_struct == 0)
+			    {
+			      einfo ("%F%I contains invalid archive member %s\n",
+				     entry, sp->name);
+			    }
 
-					if (archive_member_lang_input_statement_struct->loaded == false)  
-					    {
+			  if (archive_member_lang_input_statement_struct->loaded == false)
+			    {
 
-					      Q_read_entry_symbols (archive_member_bfd, archive_member_lang_input_statement_struct);
-					      /* Now scan the symbol table and decide whether to load.  */
+			      Q_read_entry_symbols (archive_member_bfd, archive_member_lang_input_statement_struct);
+			      /* Now scan the symbol table and decide whether to load.  */
 
 
-					      if (subfile_wanted_p (archive_member_lang_input_statement_struct) == true)
+			      if (subfile_wanted_p (archive_member_lang_input_statement_struct) == true)
 
-						  {
-						    /* This member is needed; load it.
-						       Since we are loading something on this pass,
-						       we must make another pass through the symdef data.  */
+				{
+				  /* This member is needed; load it.
+			             Since we are loading something on this pass,
+			             we must make another pass through the symdef data.  */
 
-						    not_finished = true;
+				  not_finished = true;
 
-						    Q_enter_file_symbols (archive_member_lang_input_statement_struct);
+				  Q_enter_file_symbols (archive_member_lang_input_statement_struct);
 
-						    if (prev)
-						      prev->chain = archive_member_lang_input_statement_struct;
-						    else
-						      entry->subfiles = archive_member_lang_input_statement_struct;
+				  if (prev)
+				    prev->chain = archive_member_lang_input_statement_struct;
+				  else
+				    entry->subfiles = archive_member_lang_input_statement_struct;
 
 
-						    prev = archive_member_lang_input_statement_struct;
+				  prev = archive_member_lang_input_statement_struct;
 
 
-						    /* Clear out this member's symbols from the symdef data
-						       so that following passes won't waste time on them.  */
-						    clear_syms(entry, exported_library_name->file_offset);
-						    archive_member_lang_input_statement_struct->loaded = true;
-						  }
-					    }
-				      }
+				  /* Clear out this member's symbols from the symdef data
+			             so that following passes won't waste time on them.  */
+				  clear_syms (entry, exported_library_name->file_offset);
+				  archive_member_lang_input_statement_struct->loaded = true;
 				}
+			    }
 			}
-		  }
-	      idx = bfd_get_next_mapent(entry->the_bfd, idx, &exported_library_name);
+		    }
+		}
 	    }
-      }
+	  idx = bfd_get_next_mapent (entry->the_bfd, idx, &exported_library_name);
+	}
+    }
 }
 
 void
 linear_library (entry)
-struct lang_input_statement_struct *entry;
+     struct lang_input_statement_struct *entry;
 {
   boolean more_to_do = true;
   register struct lang_input_statement_struct *prev = 0;
 
-  if (entry->complained == false) {
-  einfo("%P: library %s has bad table of contents, rerun ranlib\n", 
-	entry->the_bfd->filename);
-  entry->complained = true;
-}
-  while (more_to_do) {
+  if (entry->complained == false)
+    {
+      einfo ("%P: library %s has bad table of contents, rerun ranlib\n",
+	     entry->the_bfd->filename);
+      entry->complained = true;
+    }
+  while (more_to_do)
+    {
 
-    bfd *  archive = bfd_openr_next_archived_file(entry->the_bfd,0);
+      bfd *archive = bfd_openr_next_archived_file (entry->the_bfd, 0);
 
-    more_to_do = false;
-    while (archive) {
+      more_to_do = false;
+      while (archive)
+	{
 #ifdef GNU960
-      if (gnu960_check_format(archive, bfd_object)) 
+	  if (gnu960_check_format (archive, bfd_object))
 #else
-      if (bfd_check_format(archive, bfd_object)) 
+	  if (bfd_check_format (archive, bfd_object))
 #endif
-	{
-	  register struct lang_input_statement_struct *subentry;
+	    {
+	      register struct lang_input_statement_struct *subentry;
 
-	  subentry = decode_library_subfile (entry,
-					     archive);
+	      subentry = decode_library_subfile (entry,
+						 archive);
 
-	  archive->usrdata = (PTR) subentry;
-	  if (!subentry) return;
-	  if (subentry->loaded == false) {
-	    Q_read_entry_symbols (archive, subentry);
+	      archive->usrdata = (PTR) subentry;
+	      if (!subentry)
+		return;
+	      if (subentry->loaded == false)
+		{
+		  Q_read_entry_symbols (archive, subentry);
 
-	    if (subfile_wanted_p (subentry) == true)
-	      {
-		Q_enter_file_symbols (subentry);
+		  if (subfile_wanted_p (subentry) == true)
+		    {
+		      Q_enter_file_symbols (subentry);
 
-		if (prev)
-		  prev->chain = subentry;
-		else 
-		  entry->subfiles = subentry;
-		prev = subentry;
+		      if (prev)
+			prev->chain = subentry;
+		      else
+			entry->subfiles = subentry;
+		      prev = subentry;
+
+		      more_to_do = true;
+		      subentry->loaded = true;
+		    }
+		}
+	    }
+	  archive = bfd_openr_next_archived_file (entry->the_bfd, archive);
 
-		more_to_do = true;
-		subentry->loaded = true;
-	      }
-	  }
 	}
-      archive = bfd_openr_next_archived_file(entry->the_bfd,archive);
- 
-    }
 
-  }
+    }
 }
 
-  /* ENTRY is an entry for a file inside an archive
-     Its symbols have been read into core, but not entered into the
-     linker ymbol table
-     Return nonzero if we ought to load this file */
+ /* ENTRY is an entry for a file inside an archive
+    Its symbols have been read into core, but not entered into the
+    linker ymbol table
+    Return nonzero if we ought to load this file */
 
 boolean
 subfile_wanted_p (entry)
-struct lang_input_statement_struct *entry;
+     struct lang_input_statement_struct *entry;
 {
   asymbol **q;
 
@@ -825,10 +884,10 @@ struct lang_input_statement_struct *entry;
       /* If the symbol has an interesting definition, we could
 	 potentially want it.  */
 
-      if (p->flags & BSF_INDIRECT) 
-      {
+      if (p->flags & BSF_INDIRECT)
+	{
 /**	add_indirect(q);*/
-      }
+	}
 
       if (p->section == &bfd_com_section
 	  || (p->flags & BSF_GLOBAL)
@@ -836,80 +895,86 @@ struct lang_input_statement_struct *entry;
 	{
 	  register ldsym_type *sp = ldsym_get_soft (p->name);
 
-
 	  /* If this symbol has not been hashed,
 	     we can't be looking for it. */
-	  if (sp != (ldsym_type *)NULL 
-	      && sp->sdefs_chain == (asymbol **)NULL) {
-	    if (sp->srefs_chain  != (asymbol **)NULL
-		|| sp->scoms_chain != (asymbol **)NULL)
-	      {
-		/* This is a symbol we are looking for.  It is either
-		   not yet defined or common.  */
-
-		if (p->section == &bfd_com_section)
-		  {
-
-		    /* If the symbol in the table is a constructor, we won't to
-		       anything fancy with it */
-		    if ((sp->flags & SYM_CONSTRUCTOR) == 0) {
-		    /* This libary member has something to
-		       say about this element. We should 
-		       remember if its a new size  */
-		    /* Move something from the ref list to the com list */
-		    if(sp->scoms_chain) {
-		      /* Already a common symbol, maybe update it */
-		      if (p->value > (*(sp->scoms_chain))->value) {
-			(*(sp->scoms_chain))->value = p->value;
-		      }
-		    }
-		    else {
-		      /* Take a value from the ref chain
-			 Here we are moving a symbol from the owning bfd
-			 to another bfd. We must set up the
-			 common_section portion of the bfd thing */
-
-		      
-
-		      sp->scoms_chain = sp->srefs_chain;
-		      sp->srefs_chain =
-			(asymbol **)((*(sp->srefs_chain))->udata);
-		      (*(sp->scoms_chain))->udata = (PTR)NULL;
-
-		      (*(  sp->scoms_chain))->section  =
-		       &bfd_com_section;
-		      (*(  sp->scoms_chain))->flags  = 0;
-		      /* Remember the size of this item */
-		      sp->scoms_chain[0]->value = p->value;
-		      commons_pending++;
-		      undefined_global_sym_count--;
-		    } {
-		      asymbol *com = *(sp->scoms_chain);
-		      if (((lang_input_statement_type *)
-			   (com->the_bfd->usrdata))->common_section ==
-			  (asection *)NULL) {
-			((lang_input_statement_type *)
-			 (com->the_bfd->usrdata))->common_section = 
-			   bfd_make_section_old_way(com->the_bfd, "COMMON");
-		      }
+	  if (sp != (ldsym_type *) NULL
+	      && sp->sdefs_chain == (asymbol **) NULL)
+	    {
+	      if (sp->srefs_chain != (asymbol **) NULL
+		  || sp->scoms_chain != (asymbol **) NULL)
+		{
+		  /* This is a symbol we are looking for.  It is either
+		     not yet defined or common.  */
+
+		  if (p->section == &bfd_com_section)
+		    {
+
+		      /* If the symbol in the table is a constructor, we won't to
+		         anything fancy with it */
+		      if ((sp->flags & SYM_CONSTRUCTOR) == 0)
+			{
+			  /* This libary member has something to
+		             say about this element. We should
+		             remember if its a new size  */
+			  /* Move something from the ref list to the com list */
+			  if (sp->scoms_chain)
+			    {
+			      /* Already a common symbol, maybe update it */
+			      if (p->value > (*(sp->scoms_chain))->value)
+				{
+				  (*(sp->scoms_chain))->value = p->value;
+				}
+			    }
+			  else
+			    {
+			      /* Take a value from the ref chain
+				 Here we are moving a symbol from the owning bfd
+				 to another bfd. We must set up the
+				 common_section portion of the bfd thing */
+
+
+
+			      sp->scoms_chain = sp->srefs_chain;
+			      sp->srefs_chain =
+				(asymbol **) ((*(sp->srefs_chain))->udata);
+			      (*(sp->scoms_chain))->udata = (PTR) NULL;
+
+			      (*(sp->scoms_chain))->section =
+				&bfd_com_section;
+			      (*(sp->scoms_chain))->flags = 0;
+			      /* Remember the size of this item */
+			      sp->scoms_chain[0]->value = p->value;
+			      commons_pending++;
+			      undefined_global_sym_count--;
+			    }
+			  {
+			    asymbol *com = *(sp->scoms_chain);
+
+			    if (((lang_input_statement_type *)
+				 (com->the_bfd->usrdata))->common_section ==
+				(asection *) NULL)
+			      {
+				((lang_input_statement_type *)
+				 (com->the_bfd->usrdata))->common_section =
+				  bfd_make_section_old_way (com->the_bfd, "COMMON");
+			      }
+			  }
+			}
+		      ASSERT (p->udata == 0);
 		    }
-		  }
-		    ASSERT(p->udata == 0);
-		  }
-	      
-		else {
-		  if (write_map)
+
+		  else
 		    {
-		      info("%I needed due to %s\n",entry, sp->name);
+		      if (write_map)
+			{
+			  info ("%I needed due to %s\n", entry, sp->name);
+			}
+		      return true;
 		    }
-		  return true;
 		}
-	      }
-	  }
+	    }
 	}
     }
 
   return false;
 }
-
-