ran "indent -gnu"; have not fixed block comment style

1 files changed, 422 insertions, 388 deletions

diff --git a/gprof/core.c b/gprof/core.c
index bf02be2..a525c60 100644
--- a/gprof/core.c
+++ b/gprof/core.c
@@ -11,191 +11,209 @@ PTR core_text_space;
 
 
 void
-DEFUN(core_init, (a_out_name), const char *a_out_name)
+DEFUN (core_init, (a_out_name), const char *a_out_name)
 {
-    core_bfd = bfd_openr(a_out_name, 0);
-
-    if (!core_bfd) {
-	perror(a_out_name);
-	done(1);
-    } /* if */
-
-    if (!bfd_check_format(core_bfd, bfd_object)) {
-	fprintf(stderr, "%s: %s: not in a.out format\n", whoami, a_out_name);
-	done(1);
-    } /* if */
-
-    /* get core's text section: */
-    core_text_sect = bfd_get_section_by_name(core_bfd, ".text");
-    if (!core_text_sect) {
-	core_text_sect = bfd_get_section_by_name(core_bfd, "$CODE$");
-	if (!core_text_sect) {
-	    fprintf(stderr, "%s: can't find .text section in %s\n",
-		    whoami, a_out_name);
-	    done(1);
-	} /* if */
-    } /* if */
-
-    /* read core's symbol table: */
-
-    /* this will probably give us more than we need, but that's ok:  */
-    core_num_syms = bfd_get_symtab_upper_bound(core_bfd);
-    if (core_num_syms < 0) {
-	fprintf(stderr, "%s: %s: %s\n", whoami, a_out_name,
-		bfd_errmsg(bfd_get_error()));
-	done(1);
-    } /* if */
-
-    core_syms = (asymbol**)xmalloc(core_num_syms);
-    core_num_syms = bfd_canonicalize_symtab(core_bfd, core_syms);
-    if (core_num_syms < 0) {
-	fprintf(stderr, "%s: %s: %s\n", whoami, a_out_name,
-		bfd_errmsg(bfd_get_error()));
-	done(1);
-    } /* if */
-} /* core_init */
+  core_bfd = bfd_openr (a_out_name, 0);
+
+  if (!core_bfd)
+    {
+      perror (a_out_name);
+      done (1);
+    }				/* if */
+
+  if (!bfd_check_format (core_bfd, bfd_object))
+    {
+      fprintf (stderr, "%s: %s: not in a.out format\n", whoami, a_out_name);
+      done (1);
+    }				/* if */
+
+  /* get core's text section: */
+  core_text_sect = bfd_get_section_by_name (core_bfd, ".text");
+  if (!core_text_sect)
+    {
+      core_text_sect = bfd_get_section_by_name (core_bfd, "$CODE$");
+      if (!core_text_sect)
+	{
+	  fprintf (stderr, "%s: can't find .text section in %s\n",
+		   whoami, a_out_name);
+	  done (1);
+	}			/* if */
+    }				/* if */
+
+  /* read core's symbol table: */
+
+  /* this will probably give us more than we need, but that's ok:  */
+  core_num_syms = bfd_get_symtab_upper_bound (core_bfd);
+  if (core_num_syms < 0)
+    {
+      fprintf (stderr, "%s: %s: %s\n", whoami, a_out_name,
+	       bfd_errmsg (bfd_get_error ()));
+      done (1);
+    }				/* if */
+
+  core_syms = (asymbol **) xmalloc (core_num_syms);
+  core_num_syms = bfd_canonicalize_symtab (core_bfd, core_syms);
+  if (core_num_syms < 0)
+    {
+      fprintf (stderr, "%s: %s: %s\n", whoami, a_out_name,
+	       bfd_errmsg (bfd_get_error ()));
+      done (1);
+    }				/* if */
+}				/* core_init */
 
 
 /*
  * Read in the text space of an a.out file
  */
 void
-DEFUN(core_get_text_space, (core_bfd), bfd *core_bfd)
+DEFUN (core_get_text_space, (core_bfd), bfd * core_bfd)
 {
-    core_text_space = (PTR) malloc(core_text_sect->_raw_size);
-
-    if (!core_text_space) {
-	fprintf(stderr, "%s: ran out room for %ld bytes of text space\n",
-		whoami, core_text_sect->_raw_size);
-	done(1);
-    } /* if */
-    if (!bfd_get_section_contents(core_bfd, core_text_sect, core_text_space,
-				  0, core_text_sect->_raw_size))
+  core_text_space = (PTR) malloc (core_text_sect->_raw_size);
+
+  if (!core_text_space)
     {
-	bfd_perror("bfd_get_section_contents");
-	free(core_text_space);
-	core_text_space = 0;
-    } /* if */
-    if (!core_text_space) {
-	fprintf(stderr, "%s: can't do -c\n", whoami);
-    } /* if */
-} /* core_get_text_space */
+      fprintf (stderr, "%s: ran out room for %ld bytes of text space\n",
+	       whoami, core_text_sect->_raw_size);
+      done (1);
+    }				/* if */
+  if (!bfd_get_section_contents (core_bfd, core_text_sect, core_text_space,
+				 0, core_text_sect->_raw_size))
+    {
+      bfd_perror ("bfd_get_section_contents");
+      free (core_text_space);
+      core_text_space = 0;
+    }				/* if */
+  if (!core_text_space)
+    {
+      fprintf (stderr, "%s: can't do -c\n", whoami);
+    }				/* if */
+}				/* core_get_text_space */
 
 
 /*
  * Return class of symbol SYM.  The returned class can be any of:
- *	0   -> symbol is not interesting to us
- *	'T' -> symbol is a global name
- *	't' -> symbol is a local (static) name
+ *      0   -> symbol is not interesting to us
+ *      'T' -> symbol is a global name
+ *      't' -> symbol is a local (static) name
  */
 static int
-DEFUN(core_sym_class, (sym), asymbol *sym)
+DEFUN (core_sym_class, (sym), asymbol * sym)
 {
-    symbol_info syminfo;
-    const char *name;
-    char sym_prefix;
-    int i;
-
-    /*
-     * Must be a text symbol, and static text symbols don't qualify if
-     * ignore_static_funcs set.
-     */
-    if (!sym->section) {
-	return 0;
-    } /* if */
-
-    if (ignore_static_funcs && (sym->flags & BSF_LOCAL)) {
-	DBG(AOUTDEBUG, printf("[core_sym_class] %s: not a function\n",
+  symbol_info syminfo;
+  const char *name;
+  char sym_prefix;
+  int i;
+
+  /*
+   * Must be a text symbol, and static text symbols don't qualify if
+   * ignore_static_funcs set.
+   */
+  if (!sym->section)
+    {
+      return 0;
+    }				/* if */
+
+  if (ignore_static_funcs && (sym->flags & BSF_LOCAL))
+    {
+      DBG (AOUTDEBUG, printf ("[core_sym_class] %s: not a function\n",
 			      sym->name));
-	return 0;
-    } /* if */
+      return 0;
+    }				/* if */
 
-    bfd_get_symbol_info(core_bfd, sym, &syminfo);
-    i = syminfo.type;
+  bfd_get_symbol_info (core_bfd, sym, &syminfo);
+  i = syminfo.type;
 
-    if (i == 'T') {
-	return i;	/* it's a global symbol */
-    } /* if */
+  if (i == 'T')
+    {
+      return i;			/* it's a global symbol */
+    }				/* if */
 
-    if (i != 't') {
-	/* not a static text symbol */
-	DBG(AOUTDEBUG, printf("[core_sym_class] %s is of class %c\n",
+  if (i != 't')
+    {
+      /* not a static text symbol */
+      DBG (AOUTDEBUG, printf ("[core_sym_class] %s is of class %c\n",
 			      sym->name, i));
-	return 0;
-    } /* if */
-
-    /* do some more filtering on static function-names: */
-
-    if (ignore_static_funcs) {
-	return 0;
-    } /* if */
-    /*
-     * Can't zero-length name or funny characters in name, where
-     * `funny' includes: `.' (.o file names) and `$' (Pascal labels).
-     */
-    if (!sym->name || sym->name[0] == '\0') {
-	return 0;
-    } /* if */
-
-    for (name = sym->name; *name; ++name) {
-	if (*name == '.' || *name == '$') {
-	    return 0;
-	} /* if */
-    } /* if */
-    /*
-     * On systems where the C compiler adds an underscore to all
-     * names, static names without underscores seem usually to be
-     * labels in hand written assembler in the library.  We don't want
-     * these names.  This is certainly necessary on a Sparc running
-     * SunOS 4.1 (try profiling a program that does a lot of
-     * division). I don't know whether it has harmful side effects on
-     * other systems.  Perhaps it should be made configurable.
-     */
-    sym_prefix = bfd_get_symbol_leading_char(core_bfd);
-    if (sym_prefix && sym_prefix != sym->name[0]
-	/*
-	 * GCC may add special symbols to help gdb figure out the file
-	 * language.  We want to ignore these, since sometimes they mask
-	 * the real function.  (dj@ctron)
-	 */
-	|| !strncmp (sym->name, "__gnu_compiled", 14)
-	|| !strncmp (sym->name, "___gnu_compiled", 15))
+      return 0;
+    }				/* if */
+
+  /* do some more filtering on static function-names: */
+
+  if (ignore_static_funcs)
+    {
+      return 0;
+    }				/* if */
+  /*
+   * Can't zero-length name or funny characters in name, where
+   * `funny' includes: `.' (.o file names) and `$' (Pascal labels).
+   */
+  if (!sym->name || sym->name[0] == '\0')
     {
-	return 0;
-    } /* if */
-    return 't';		/* it's a static text symbol */
-} /* core_sym_class */
+      return 0;
+    }				/* if */
+
+  for (name = sym->name; *name; ++name)
+    {
+      if (*name == '.' || *name == '$')
+	{
+	  return 0;
+	}			/* if */
+    }				/* if */
+  /*
+   * On systems where the C compiler adds an underscore to all
+   * names, static names without underscores seem usually to be
+   * labels in hand written assembler in the library.  We don't want
+   * these names.  This is certainly necessary on a Sparc running
+   * SunOS 4.1 (try profiling a program that does a lot of
+   * division). I don't know whether it has harmful side effects on
+   * other systems.  Perhaps it should be made configurable.
+   */
+  sym_prefix = bfd_get_symbol_leading_char (core_bfd);
+  if (sym_prefix && sym_prefix != sym->name[0]
+  /*
+   * GCC may add special symbols to help gdb figure out the file
+   * language.  We want to ignore these, since sometimes they mask
+   * the real function.  (dj@ctron)
+   */
+      || !strncmp (sym->name, "__gnu_compiled", 14)
+      || !strncmp (sym->name, "___gnu_compiled", 15))
+    {
+      return 0;
+    }				/* if */
+  return 't';			/* it's a static text symbol */
+}				/* core_sym_class */
 
 
 /*
  * Get whatever source info we can get regarding address ADDR:
  */
 static bool
-DEFUN(get_src_info, (addr, filename, name, line_num),
-      bfd_vma addr AND const char **filename AND const char **name
-      AND int *line_num)
+DEFUN (get_src_info, (addr, filename, name, line_num),
+       bfd_vma addr AND const char **filename AND const char **name
+       AND int *line_num)
 {
-    const char *fname = 0, *func_name = 0;
-    int l = 0;
+  const char *fname = 0, *func_name = 0;
+  int l = 0;
 
-    if (bfd_find_nearest_line(core_bfd, core_text_sect, core_syms,
-			      addr - core_text_sect->vma,
-			      &fname, &func_name, &l)
-	&& fname && func_name && l)
+  if (bfd_find_nearest_line (core_bfd, core_text_sect, core_syms,
+			     addr - core_text_sect->vma,
+			     &fname, &func_name, &l)
+      && fname && func_name && l)
     {
-	DBG(AOUTDEBUG, printf("[get_src_info] 0x%lx -> %s:%d (%s)\n",
+      DBG (AOUTDEBUG, printf ("[get_src_info] 0x%lx -> %s:%d (%s)\n",
 			      addr, fname, l, func_name));
-	*filename = fname;
-	*name = func_name;
-	*line_num = l;
-	return TRUE;
-    } else {
-	DBG(AOUTDEBUG, printf("[get_src_info] no info for 0x%lx (%s:%d,%s)\n",
+      *filename = fname;
+      *name = func_name;
+      *line_num = l;
+      return TRUE;
+    }
+  else
+    {
+      DBG (AOUTDEBUG, printf ("[get_src_info] no info for 0x%lx (%s:%d,%s)\n",
 			      (long) addr, fname ? fname : "<unknown>", l,
 			      func_name ? func_name : "<unknown>"));
-	return FALSE;
-    } /* if */
-} /* get_src_info */
+      return FALSE;
+    }				/* if */
+}				/* get_src_info */
 
 
 /*
@@ -203,119 +221,126 @@ DEFUN(get_src_info, (addr, filename, name, line_num),
  * entered.
  */
 void
-DEFUN(core_create_function_syms, (core_bfd), bfd *core_bfd)
+DEFUN (core_create_function_syms, (core_bfd), bfd * core_bfd)
 {
-    bfd_vma min_vma = ~0, max_vma = 0;
-    const char *filename, *func_name;
-    int class;
-    long i;
-
-    /* pass 1 - determine upper bound on number of function names: */
-    symtab.len = 0;
-    for (i = 0; i < core_num_syms; ++i) {
-	if (!core_sym_class(core_syms[i])) {
-	    continue;
-	} /* if */
-	++symtab.len;
-    } /* for */
-
-    if (symtab.len == 0) {
-	fprintf(stderr, "%s: file `%s' has no symbols\n", whoami, a_out_name);
-	done(1);
-    } /* if */
-
-    /* the "+ 2" is for the sentinels: */
-    symtab.base = (Sym*)xmalloc((symtab.len + 2) * sizeof(Sym));
-
-    /* pass 2 - create symbols: */
-
-    symtab.limit = symtab.base;
-    for (i = 0; i < core_num_syms; ++i) {
-	class = core_sym_class(core_syms[i]);
-	if (!class) {
-	    DBG(AOUTDEBUG,
-		printf("[core_create_function_syms] rejecting: 0x%lx %s\n",
+  bfd_vma min_vma = ~0, max_vma = 0;
+  const char *filename, *func_name;
+  int class;
+  long i;
+
+  /* pass 1 - determine upper bound on number of function names: */
+  symtab.len = 0;
+  for (i = 0; i < core_num_syms; ++i)
+    {
+      if (!core_sym_class (core_syms[i]))
+	{
+	  continue;
+	}			/* if */
+      ++symtab.len;
+    }				/* for */
+
+  if (symtab.len == 0)
+    {
+      fprintf (stderr, "%s: file `%s' has no symbols\n", whoami, a_out_name);
+      done (1);
+    }				/* if */
+
+  /* the "+ 2" is for the sentinels: */
+  symtab.base = (Sym *) xmalloc ((symtab.len + 2) * sizeof (Sym));
+
+  /* pass 2 - create symbols: */
+
+  symtab.limit = symtab.base;
+  for (i = 0; i < core_num_syms; ++i)
+    {
+      class = core_sym_class (core_syms[i]);
+      if (!class)
+	{
+	  DBG (AOUTDEBUG,
+	       printf ("[core_create_function_syms] rejecting: 0x%lx %s\n",
 		       core_syms[i]->value, core_syms[i]->name));
-	    continue;
-	} /* if */
+	  continue;
+	}			/* if */
 
-	sym_init(symtab.limit);
+      sym_init (symtab.limit);
 
-	/* symbol offsets are always section-relative: */
+      /* symbol offsets are always section-relative: */
 
-	symtab.limit->addr = core_syms[i]->value + core_syms[i]->section->vma;
-	symtab.limit->name = core_syms[i]->name;
+      symtab.limit->addr = core_syms[i]->value + core_syms[i]->section->vma;
+      symtab.limit->name = core_syms[i]->name;
 
 #ifdef __osf__
-	/*
-	 * Suppress symbols that are not function names.  This is
-	 * useful to suppress code-labels and aliases.
-	 *
-	 * This is known to be useful under DEC's OSF/1.  Under SunOS 4.x,
-	 * labels do not appear in the symbol table info, so this isn't
-	 * necessary.
-	 */
-	if (get_src_info(symtab.limit->addr, &filename, &func_name,
-			 &symtab.limit->line_num))
+      /*
+       * Suppress symbols that are not function names.  This is
+       * useful to suppress code-labels and aliases.
+       *
+       * This is known to be useful under DEC's OSF/1.  Under SunOS 4.x,
+       * labels do not appear in the symbol table info, so this isn't
+       * necessary.
+       */
+      if (get_src_info (symtab.limit->addr, &filename, &func_name,
+			&symtab.limit->line_num))
 	{
-	    symtab.limit->file = source_file_lookup_path(filename);
-
-	    if (strcmp(symtab.limit->name, func_name) != 0) {
-		/*
-		 * The symbol's address maps to a different name, so
-		 * it can't be a function-entry point.  This happens
-		 * for labels, for example.
-		 */
-		DBG(AOUTDEBUG,
-		    printf("[core_create_function_syms: rej %s (maps to %s)\n",
-			   symtab.limit->name, func_name));
-		continue;
-	    } /* if */
-	} /* if */
+	  symtab.limit->file = source_file_lookup_path (filename);
+
+	  if (strcmp (symtab.limit->name, func_name) != 0)
+	    {
+	      /*
+	       * The symbol's address maps to a different name, so
+	       * it can't be a function-entry point.  This happens
+	       * for labels, for example.
+	       */
+	      DBG (AOUTDEBUG,
+		printf ("[core_create_function_syms: rej %s (maps to %s)\n",
+			symtab.limit->name, func_name));
+	      continue;
+	    }			/* if */
+	}			/* if */
 #endif
 
-	symtab.limit->is_func = TRUE;
-	symtab.limit->is_bb_head = TRUE;
-	if (class == 't') {
-	    symtab.limit->is_static = TRUE;
-	} /* if */
-
-	min_vma = MIN(symtab.limit->addr, min_vma);
-	max_vma = MAX(symtab.limit->addr, max_vma);
-
-	/*
-	 * If we see "main" without an initial '_', we assume names
-	 * are *not* prefixed by '_'.
-	 */
-	if (symtab.limit->name[0] == 'm' && discard_underscores
-	    && strcmp(symtab.limit->name, "main") == 0)
+      symtab.limit->is_func = TRUE;
+      symtab.limit->is_bb_head = TRUE;
+      if (class == 't')
+	{
+	  symtab.limit->is_static = TRUE;
+	}			/* if */
+
+      min_vma = MIN (symtab.limit->addr, min_vma);
+      max_vma = MAX (symtab.limit->addr, max_vma);
+
+      /*
+       * If we see "main" without an initial '_', we assume names
+       * are *not* prefixed by '_'.
+       */
+      if (symtab.limit->name[0] == 'm' && discard_underscores
+	  && strcmp (symtab.limit->name, "main") == 0)
 	{
-	    discard_underscores = 0;
-	} /* if */
+	  discard_underscores = 0;
+	}			/* if */
 
-	DBG(AOUTDEBUG, printf("[core_create_function_syms] %ld %s 0x%lx\n",
-			      (long)(symtab.limit - symtab.base),
+      DBG (AOUTDEBUG, printf ("[core_create_function_syms] %ld %s 0x%lx\n",
+			      (long) (symtab.limit - symtab.base),
 			      symtab.limit->name, symtab.limit->addr));
-	++symtab.limit;
-    } /* for */
+      ++symtab.limit;
+    }				/* for */
 
-    /* create sentinels: */
+  /* create sentinels: */
 
-    sym_init(symtab.limit);
-    symtab.limit->name = "<locore>";
-    symtab.limit->addr = 0;
-    symtab.limit->end_addr = min_vma - 1;
-    ++symtab.limit;
+  sym_init (symtab.limit);
+  symtab.limit->name = "<locore>";
+  symtab.limit->addr = 0;
+  symtab.limit->end_addr = min_vma - 1;
+  ++symtab.limit;
 
-    sym_init(symtab.limit);
-    symtab.limit->name = "<hicore>";
-    symtab.limit->addr = max_vma + 1;
-    symtab.limit->end_addr = ~0;
-    ++symtab.limit;
+  sym_init (symtab.limit);
+  symtab.limit->name = "<hicore>";
+  symtab.limit->addr = max_vma + 1;
+  symtab.limit->end_addr = ~0;
+  ++symtab.limit;
 
-    symtab.len = symtab.limit - symtab.base;
-    symtab_finalize(&symtab);
-} /* core_create_function_syms */
+  symtab.len = symtab.limit - symtab.base;
+  symtab_finalize (&symtab);
+}				/* core_create_function_syms */
 
 
 /*
@@ -323,154 +348,163 @@ DEFUN(core_create_function_syms, (core_bfd), bfd *core_bfd)
  * is entered.
  */
 void
-DEFUN(core_create_line_syms, (core_bfd), bfd *core_bfd)
+DEFUN (core_create_line_syms, (core_bfd), bfd * core_bfd)
 {
-    char prev_name[PATH_MAX], prev_filename[PATH_MAX];
-    bfd_vma vma, min_vma = ~0, max_vma = 0;
-    bfd_vma offset, prev_offset, min_dist;
-    Sym *prev, dummy, *sentinel, *sym;
-    const char *filename;
-    int prev_line_num, i;
-    Sym_Table ltab;
-    /*
-     * Create symbols for functions as usual.  This is necessary in
-     * cases where parts of a program were not compiled with -g.  For
-     * those parts we still want to get info at the function level:
-     */
-    core_create_function_syms(core_bfd);
-
-    /* pass 1 - counter number of symbols: */
-
-    /*
-     * To find all line information, walk through all possible
-     * text-space addresses (one by one!) and get the debugging
-     * info for each address.  When the debugging info changes,
-     * it is time to create a new symbol.
-     *
-     * Of course, this is rather slow and it would be better if
-     * bfd would provide an iterator for enumerating all line
-     * infos, but for now, we try to speed up the second pass
-     * by determining what the minimum code distance between two
-     * lines is.
-     */
-    prev_name[0] = '\0';
-    ltab.len = 0;
-    min_dist = core_text_sect->_raw_size;
-    prev_offset = -min_dist;
-    prev_filename[0] = '\0';
-    prev_line_num = 0;
-    for (offset = 0; offset < core_text_sect->_raw_size; ++offset) {
-	vma = core_text_sect->vma + offset;
-	if (!get_src_info(vma, &filename, &dummy.name, &dummy.line_num)
-	    || (prev_line_num == dummy.line_num &&
-		strcmp(prev_name, dummy.name) == 0
-		&& strcmp(prev_filename, filename) == 0))
+  char prev_name[PATH_MAX], prev_filename[PATH_MAX];
+  bfd_vma vma, min_vma = ~0, max_vma = 0;
+  bfd_vma offset, prev_offset, min_dist;
+  Sym *prev, dummy, *sentinel, *sym;
+  const char *filename;
+  int prev_line_num, i;
+  Sym_Table ltab;
+  /*
+   * Create symbols for functions as usual.  This is necessary in
+   * cases where parts of a program were not compiled with -g.  For
+   * those parts we still want to get info at the function level:
+   */
+  core_create_function_syms (core_bfd);
+
+  /* pass 1 - counter number of symbols: */
+
+  /*
+   * To find all line information, walk through all possible
+   * text-space addresses (one by one!) and get the debugging
+   * info for each address.  When the debugging info changes,
+   * it is time to create a new symbol.
+   *
+   * Of course, this is rather slow and it would be better if
+   * bfd would provide an iterator for enumerating all line
+   * infos, but for now, we try to speed up the second pass
+   * by determining what the minimum code distance between two
+   * lines is.
+   */
+  prev_name[0] = '\0';
+  ltab.len = 0;
+  min_dist = core_text_sect->_raw_size;
+  prev_offset = -min_dist;
+  prev_filename[0] = '\0';
+  prev_line_num = 0;
+  for (offset = 0; offset < core_text_sect->_raw_size; ++offset)
+    {
+      vma = core_text_sect->vma + offset;
+      if (!get_src_info (vma, &filename, &dummy.name, &dummy.line_num)
+	  || (prev_line_num == dummy.line_num &&
+	      strcmp (prev_name, dummy.name) == 0
+	      && strcmp (prev_filename, filename) == 0))
 	{
-	    continue;
-	} /* if */
-
-	++ltab.len;
-	prev_line_num = dummy.line_num;
-	strcpy(prev_name, dummy.name);
-	strcpy(prev_filename, filename);
-
-	if (offset - prev_offset < min_dist) {
-	    min_dist = offset - prev_offset;
-	} /* if */
-	prev_offset = offset;
-
-	min_vma = MIN(vma, min_vma);
-	max_vma = MAX(vma, max_vma);
-    } /* for */
-
-    DBG(AOUTDEBUG, printf("[core_create_line_syms] min_dist=%lx\n", min_dist));
-
-    /* make room for function symbols, too: */
-    ltab.len += symtab.len;
-    ltab.base = (Sym*) xmalloc(ltab.len * sizeof(Sym));
-    ltab.limit = ltab.base;
-
-    /* pass 2 - create symbols: */
-
-    prev = 0;
-    for (offset = 0; offset < core_text_sect->_raw_size; offset += min_dist) {
-	sym_init(ltab.limit);
-	if (!get_src_info(core_text_sect->vma + offset, &filename,
-			  &ltab.limit->name, &ltab.limit->line_num)
-	    || (prev && prev->line_num == ltab.limit->line_num
-		&& strcmp(prev->name, ltab.limit->name) == 0
-		&& strcmp(prev->file->name, filename) == 0))
+	  continue;
+	}			/* if */
+
+      ++ltab.len;
+      prev_line_num = dummy.line_num;
+      strcpy (prev_name, dummy.name);
+      strcpy (prev_filename, filename);
+
+      if (offset - prev_offset < min_dist)
 	{
-	    continue;
-	} /* if */
-
-	/* make name pointer a malloc'ed string: */
-	ltab.limit->name = strdup(ltab.limit->name);
-	ltab.limit->file = source_file_lookup_path(filename);
-
-	ltab.limit->addr = core_text_sect->vma + offset;
-	prev = ltab.limit;
-
-	/*
-	 * If we see "main" without an initial '_', we assume names
-	 * are *not* prefixed by '_'.
-	 */
-	if (ltab.limit->name[0] == 'm' && discard_underscores
-	    && strcmp(ltab.limit->name, "main") == 0)
+	  min_dist = offset - prev_offset;
+	}			/* if */
+      prev_offset = offset;
+
+      min_vma = MIN (vma, min_vma);
+      max_vma = MAX (vma, max_vma);
+    }				/* for */
+
+  DBG (AOUTDEBUG, printf ("[core_create_line_syms] min_dist=%lx\n", min_dist));
+
+  /* make room for function symbols, too: */
+  ltab.len += symtab.len;
+  ltab.base = (Sym *) xmalloc (ltab.len * sizeof (Sym));
+  ltab.limit = ltab.base;
+
+  /* pass 2 - create symbols: */
+
+  prev = 0;
+  for (offset = 0; offset < core_text_sect->_raw_size; offset += min_dist)
+    {
+      sym_init (ltab.limit);
+      if (!get_src_info (core_text_sect->vma + offset, &filename,
+			 &ltab.limit->name, &ltab.limit->line_num)
+	  || (prev && prev->line_num == ltab.limit->line_num
+	      && strcmp (prev->name, ltab.limit->name) == 0
+	      && strcmp (prev->file->name, filename) == 0))
 	{
-	    discard_underscores = 0;
-	} /* if */
+	  continue;
+	}			/* if */
+
+      /* make name pointer a malloc'ed string: */
+      ltab.limit->name = strdup (ltab.limit->name);
+      ltab.limit->file = source_file_lookup_path (filename);
+
+      ltab.limit->addr = core_text_sect->vma + offset;
+      prev = ltab.limit;
+
+      /*
+       * If we see "main" without an initial '_', we assume names
+       * are *not* prefixed by '_'.
+       */
+      if (ltab.limit->name[0] == 'm' && discard_underscores
+	  && strcmp (ltab.limit->name, "main") == 0)
+	{
+	  discard_underscores = 0;
+	}			/* if */
 
-	DBG(AOUTDEBUG, printf("[core_create_line_syms] %d %s 0x%lx\n",
+      DBG (AOUTDEBUG, printf ("[core_create_line_syms] %d %s 0x%lx\n",
 			      ltab.len, ltab.limit->name,
 			      ltab.limit->addr));
-	++ltab.limit;
-    } /* for */
+      ++ltab.limit;
+    }				/* for */
+
+  /* update sentinels: */
+
+  sentinel = sym_lookup (&symtab, 0);
+  if (strcmp (sentinel->name, "<locore>") == 0
+      && min_vma <= sentinel->end_addr)
+    {
+      sentinel->end_addr = min_vma - 1;
+    }				/* if */
+
+  sentinel = sym_lookup (&symtab, ~0);
+  if (strcmp (sentinel->name, "<hicore>") == 0 && max_vma >= sentinel->addr)
+    {
+      sentinel->addr = max_vma + 1;
+    }				/* if */
 
-    /* update sentinels: */
+  /* copy in function symbols: */
+  memcpy (ltab.limit, symtab.base, symtab.len * sizeof (Sym));
+  ltab.limit += symtab.len;
 
-    sentinel = sym_lookup(&symtab, 0);
-    if (strcmp(sentinel->name, "<locore>") == 0
-	&& min_vma <= sentinel->end_addr)
+  if (ltab.limit - ltab.base != ltab.len)
     {
-	sentinel->end_addr = min_vma - 1;
-    } /* if */
-
-    sentinel = sym_lookup(&symtab, ~0);
-    if (strcmp(sentinel->name, "<hicore>") == 0 && max_vma >= sentinel->addr) {
-	sentinel->addr = max_vma + 1;
-    } /* if */
-
-    /* copy in function symbols: */
-    memcpy(ltab.limit, symtab.base, symtab.len * sizeof(Sym));
-    ltab.limit += symtab.len;
-
-    if (ltab.limit - ltab.base != ltab.len) {
-	fprintf(stderr,
-		"%s: somebody miscounted: ltab.len=%ld instead of %d\n",
-		whoami, (long) (ltab.limit - ltab.base), ltab.len);
-	done(1);
-    } /* if */
-
-    /* finalize ltab and make it symbol table: */
-
-    symtab_finalize(&ltab);
-    free(symtab.base);
-    symtab = ltab;
-
-    /* now go through all core symbols and set is_static accordingly: */
-
-    for (i = 0; i < core_num_syms; ++i) {
-	if (core_sym_class(core_syms[i]) == 't') {
-	    sym = sym_lookup(&symtab, core_syms[i]->value
-			     + core_syms[i]->section->vma);
-	    do {
-		sym++->is_static = TRUE;
-	    } while (sym->file == sym[-1].file &&
-		     strcmp(sym->name, sym[-1].name) == 0);
-	} /* if */
-    } /* for */
-
-} /* core_create_line_syms */
-
-			/*** end of core.c ***/
+      fprintf (stderr,
+	       "%s: somebody miscounted: ltab.len=%ld instead of %d\n",
+	       whoami, (long) (ltab.limit - ltab.base), ltab.len);
+      done (1);
+    }				/* if */
+
+  /* finalize ltab and make it symbol table: */
+
+  symtab_finalize (&ltab);
+  free (symtab.base);
+  symtab = ltab;
+
+  /* now go through all core symbols and set is_static accordingly: */
+
+  for (i = 0; i < core_num_syms; ++i)
+    {
+      if (core_sym_class (core_syms[i]) == 't')
+	{
+	  sym = sym_lookup (&symtab, core_syms[i]->value
+			    + core_syms[i]->section->vma);
+	  do
+	    {
+	      sym++->is_static = TRUE;
+	    }
+	  while (sym->file == sym[-1].file &&
+		 strcmp (sym->name, sym[-1].name) == 0);
+	}			/* if */
+    }				/* for */
+
+}				/* core_create_line_syms */
+
+/*** end of core.c ***/