*** empty log message ***

ld/ldmain.c

@@ -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.
@@ -76,8 +77,6 @@ unsigned int commons_pending;
 
 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 );
+    check_v960 (argc, argv);
     emulation = "gld960";
-  for ( i = 1; i < argc; i++ ){
-      if ( !strcmp(argv[i],"-Fcoff") ){
+    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,48 +173,52 @@ 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 (strcmp (config.map_filename, "-") == 0)
 	{
 	  config.map_file = stdout;
 	}
-    else {
-	config.map_file = fopen(config.map_filename, FOPEN_WT);
-	if (config.map_file == (FILE *)NULL) 
+      else
 	{
-	  einfo("%P%F: can't open map file %s\n",
+	  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 */
@@ -222,17 +227,20 @@ main (argc, argv)
   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) {
+      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
@@ -240,63 +248,66 @@ main (argc, argv)
 
       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",
+	      einfo ("%P: Link errors found, deleting executable `%s'\n",
 		     output_filename);
 	    }
 
 	  if (output_bfd->iostream)
-       fclose((FILE*)(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
  */
- 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,36 +334,41 @@ 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 */
+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))  {
+  if (flag_is_constructor (this_symbol_flags))
+    {
       /* Add this constructor to the list we keep */
-    ldlang_add_constructor(sp);
+      ldlang_add_constructor (sp);
       /* Turn any commons into refs */
-    if (sp->scoms_chain != (asymbol **)NULL) {
-      refize(sp, sp->scoms_chain);
+      if (sp->scoms_chain != (asymbol **) NULL)
+	{
+	  refize (sp, sp->scoms_chain);
 	  sp->scoms_chain = 0;
 	}
 
 
     }
-  else {  
-    if (sym->section == &bfd_com_section) {
+  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
@@ -363,31 +379,37 @@ DEFUN(Q_enter_global_ref,(nlist_p, name),
 	      /* 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);
+	      refize (sp, nlist_p);
 	    }
-      else  if (sp->scoms_chain) {
+	  else if (sp->scoms_chain)
+	    {
 	      /* If we have a previous common, keep only the biggest */
-	if ( (*(sp->scoms_chain))->value > sym->value) {
+	      if ((*(sp->scoms_chain))->value > sym->value)
+		{
 		  /* other common is bigger, throw this one away */
-	  refize(sp, nlist_p);
+		  refize (sp, nlist_p);
 		}
-	else if (sp->scoms_chain != nlist_p) {
+	      else if (sp->scoms_chain != nlist_p)
+		{
 		  /* other common is smaller, throw that away */
-	  refize(sp, sp->scoms_chain);
+		  refize (sp, sp->scoms_chain);
 		  sp->scoms_chain = nlist_p;
 		}
 	    }
-      else {
+	  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) {
+	      if (sp->flags & SYM_CONSTRUCTOR)
+		{
 		  /* Turn this into a ref */
-	  refize(sp, nlist_p);
+		  refize (sp, nlist_p);
 		}
-	else {
+	      else
+		{
 		  /* treat like a common */
 		  if (sp->srefs_chain)
 		    undefined_global_sym_count--;
@@ -398,102 +420,127 @@ DEFUN(Q_enter_global_ref,(nlist_p, name),
 	    }
 	}
 
-    else if (sym->section != &bfd_und_section) {
+      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) {
+	  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;
+	      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",
+	      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",
+	      einfo ("%X%C: first seen here\n",
 		     sy->the_bfd, sy->section, stat_symbols, sy->value);
 	    }
-      else {
-	sym->udata =(PTR)( sp->sdefs_chain);
+	  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);
+	  if (sp->scoms_chain)
+	    {
+	      refize (sp, sp->scoms_chain);
 	      sp->scoms_chain = 0;
 	      commons_pending--;
 	    }
-      else if (sp->srefs_chain && relaxing == false) {
+	  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) {
+      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");
+    bfd_make_section_old_way (entry->the_bfd, "COMMON");
 
-  ldlang_add_file(entry);
+  ldlang_add_file (entry);
 
 
-  if (trace_files || option_v) {
-      info("%I\n", entry);
+  if (trace_files || option_v)
+    {
+      info ("%I\n", entry);
     }
 
   total_symbols_seen += entry->symbol_count;
-  total_files_seen ++;
-if (entry->symbol_count)
+  total_files_seen++;
+  if (entry->symbol_count)
+    {
       for (q = entry->asymbols; *q; q++)
 	{
 	  asymbol *p = *q;
 
 	  if (p->flags & BSF_INDIRECT)
 	    {
-      add_indirect(q);
+	      add_indirect (q);
 	    }
 	  else if (p->flags & BSF_WARNING)
 	    {
-      add_warning(p);
+	      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);
+		  Q_enter_global_ref (q, p->name);
 		}
 
-
+	    }
+	}
     }
 }
 
-
-
 /* Searching libraries */
 
 struct lang_input_statement_struct *decode_library_subfile ();
@@ -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) ){
+  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
 	{
-	  einfo("%F%B: malformed input file (not rel or archive) \n",
+	  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,8 +648,9 @@ 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 = (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;
@@ -619,19 +668,22 @@ decode_library_subfile (library_entry, subfile_offset)
 
 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,
+  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) {
+
+  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,13 +699,12 @@ symdef_library (entry)
 
   boolean not_finished = true;
 
-
   while (not_finished == true)
     {
       carsym *exported_library_name;
       bfd *prev_archive_member_bfd = 0;
 
-	int idx = bfd_get_next_mapent(entry->the_bfd,
+      int idx = bfd_get_next_mapent (entry->the_bfd,
 				     BFD_NO_MORE_SYMBOLS,
 				     &exported_library_name);
 
@@ -673,13 +724,13 @@ symdef_library (entry)
 	         undefined or */
 	      if (sp && sp->srefs_chain && !sp->sdefs_chain)
 		{
-			  bfd *archive_member_bfd = bfd_get_elt_at_index(entry->the_bfd, idx);
+		  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
 		    {
 
@@ -692,11 +743,13 @@ symdef_library (entry)
 
 			  /* 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;
+			      archive_member_lang_input_statement_struct = (lang_input_statement_type *) archive_member_bfd->usrdata;
 			    }
-					else {
+			  else
+			    {
 
 			      archive_member_lang_input_statement_struct =
 				decode_library_subfile (entry, archive_member_bfd);
@@ -704,7 +757,8 @@ symdef_library (entry)
 
 			    }
 
-					if (archive_member_lang_input_statement_struct == 0) {
+			  if (archive_member_lang_input_statement_struct == 0)
+			    {
 			      einfo ("%F%I contains invalid archive member %s\n",
 				     entry, sp->name);
 			    }
@@ -738,7 +792,7 @@ symdef_library (entry)
 
 				  /* 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);
+				  clear_syms (entry, exported_library_name->file_offset);
 				  archive_member_lang_input_statement_struct->loaded = true;
 				}
 			    }
@@ -746,33 +800,36 @@ symdef_library (entry)
 		    }
 		}
 	    }
-	      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", 
+  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) {
+    }
+  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) {
+      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;
@@ -781,8 +838,10 @@ struct lang_input_statement_struct *entry;
 						 archive);
 
 	      archive->usrdata = (PTR) subentry;
-	  if (!subentry) return;
-	  if (subentry->loaded == false) {
+	      if (!subentry)
+		return;
+	      if (subentry->loaded == false)
+		{
 		  Q_read_entry_symbols (archive, subentry);
 
 		  if (subfile_wanted_p (subentry) == true)
@@ -800,7 +859,7 @@ struct lang_input_statement_struct *entry;
 		    }
 		}
 	    }
-      archive = bfd_openr_next_archived_file(entry->the_bfd,archive);
+	  archive = bfd_openr_next_archived_file (entry->the_bfd, archive);
 
 	}
 
@@ -814,7 +873,7 @@ struct lang_input_statement_struct *entry;
 
 boolean
 subfile_wanted_p (entry)
-struct lang_input_statement_struct *entry;
+     struct lang_input_statement_struct *entry;
 {
   asymbol **q;
 
@@ -836,13 +895,13 @@ 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)
+	  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.  */
@@ -852,18 +911,22 @@ struct lang_input_statement_struct *entry;
 
 		      /* If the symbol in the table is a constructor, we won't to
 		         anything fancy with it */
-		    if ((sp->flags & SYM_CONSTRUCTOR) == 0) {
+		      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) {
+			  if (sp->scoms_chain)
+			    {
 			      /* Already a common symbol, maybe update it */
-		      if (p->value > (*(sp->scoms_chain))->value) {
+			      if (p->value > (*(sp->scoms_chain))->value)
+				{
 				  (*(sp->scoms_chain))->value = p->value;
 				}
 			    }
-		    else {
+			  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
@@ -873,34 +936,38 @@ struct lang_input_statement_struct *entry;
 
 			      sp->scoms_chain = sp->srefs_chain;
 			      sp->srefs_chain =
-			(asymbol **)((*(sp->srefs_chain))->udata);
-		      (*(sp->scoms_chain))->udata = (PTR)NULL;
+				(asymbol **) ((*(sp->srefs_chain))->udata);
+			      (*(sp->scoms_chain))->udata = (PTR) NULL;
 
-		      (*(  sp->scoms_chain))->section  =
+			      (*(sp->scoms_chain))->section =
 				&bfd_com_section;
-		      (*(  sp->scoms_chain))->flags  = 0;
+			      (*(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) {
+				(asection *) NULL)
+			      {
 				((lang_input_statement_type *)
 				 (com->the_bfd->usrdata))->common_section =
-			   bfd_make_section_old_way(com->the_bfd, "COMMON");
+				  bfd_make_section_old_way (com->the_bfd, "COMMON");
 			      }
 			  }
 			}
-		    ASSERT(p->udata == 0);
+		      ASSERT (p->udata == 0);
 		    }
 
-		else {
+		  else
+		    {
 		      if (write_map)
 			{
-		      info("%I needed due to %s\n",entry, sp->name);
+			  info ("%I needed due to %s\n", entry, sp->name);
 			}
 		      return true;
 		    }
@@ -911,5 +978,3 @@ struct lang_input_statement_struct *entry;
 
   return false;
 }
-
-