Automatic date update in version.in

[platform/upstream/binutils.git] / gprof / symtab.c

diff --git a/gprof/symtab.c b/gprof/symtab.c
index 273030b..2482350 100644 (file)
--- a/gprof/symtab.c
+++ b/gprof/symtab.c
@@ -1,12 +1,12 @@
 /* symtab.c
 
 /* symtab.c
 

-   Copyright 2000 Free Software Foundation, Inc.
+   Copyright (C) 1999-2014 Free Software Foundation, Inc.

 
    This file is part of GNU Binutils.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
 
    This file is part of GNU Binutils.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by

-   the Free Software Foundation; either version 2 of the License, or
+   the Free Software Foundation; either version 3 of the License, or

    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,


@@ -16,13 +16,17 @@
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software

-   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
-   02111-1307, USA.  */
+   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
+   02110-1301, USA.  */

 \f
 #include "gprof.h"
 \f
 #include "gprof.h"

+#include "search_list.h"
+#include "source.h"
+#include "symtab.h"

 #include "cg_arcs.h"
 #include "corefile.h"
 #include "cg_arcs.h"
 #include "corefile.h"

-#include "symtab.h"
+
+static int cmp_addr (const PTR, const PTR);

 
 Sym_Table symtab;
 
 
 Sym_Table symtab;
 


@@ -30,10 +34,10 @@ Sym_Table symtab;
 /* Initialize a symbol (so it's empty).  */
 
 void
 /* Initialize a symbol (so it's empty).  */
 
 void

-DEFUN (sym_init, (sym), Sym * sym)
+sym_init (Sym *sym)

 {
   memset (sym, 0, sizeof (*sym));
 {
   memset (sym, 0, sizeof (*sym));

-  
+

   /* It is not safe to assume that a binary zero corresponds
      to a floating-point 0.0, so initialize floats explicitly.  */
   sym->hist.time = 0.0;
   /* It is not safe to assume that a binary zero corresponds
      to a floating-point 0.0, so initialize floats explicitly.  */
   sym->hist.time = 0.0;


@@ -54,10 +58,10 @@ DEFUN (sym_init, (sym), Sym * sym)
    the global symbol survives.  */
 
 static int
    the global symbol survives.  */
 
 static int

-DEFUN (cmp_addr, (lp, rp), const PTR lp AND const PTR rp)
+cmp_addr (const PTR lp, const PTR rp)

 {
 {

-  Sym *left = (Sym *) lp;
-  Sym *right = (Sym *) rp;
+  const Sym *left = (const Sym *) lp;
+  const Sym *right = (const Sym *) rp;

 
   if (left->addr > right->addr)
     return 1;
 
   if (left->addr > right->addr)
     return 1;


@@ -72,7 +76,7 @@ DEFUN (cmp_addr, (lp, rp), const PTR lp AND const PTR rp)
 
 
 void
 
 
 void

-DEFUN (symtab_finalize, (tab), Sym_Table * tab)
+symtab_finalize (Sym_Table *tab)

 {
   Sym *src, *dst;
   bfd_vma prev_addr;
 {
   Sym *src, *dst;
   bfd_vma prev_addr;


@@ -86,7 +90,7 @@ DEFUN (symtab_finalize, (tab), Sym_Table * tab)
   /* Remove duplicate entries to speed-up later processing and
      set end_addr if its not set yet.  */
   prev_addr = tab->base[0].addr + 1;
   /* Remove duplicate entries to speed-up later processing and
      set end_addr if its not set yet.  */
   prev_addr = tab->base[0].addr + 1;

-  
+

   for (src = dst = tab->base; src < tab->limit; ++src)
     {
       if (src->addr == prev_addr)
   for (src = dst = tab->base; src < tab->limit; ++src)
     {
       if (src->addr == prev_addr)


@@ -114,7 +118,7 @@ DEFUN (symtab_finalize, (tab), Sym_Table * tab)
                           dst[-1].name, dst[-1].is_static ? 't' : 'T',
                           dst[-1].is_func ? 'F' : 'f');
                   printf (" (addr=%lx)\n", (unsigned long) src->addr));
                           dst[-1].name, dst[-1].is_static ? 't' : 'T',
                           dst[-1].is_func ? 'F' : 'f');
                   printf (" (addr=%lx)\n", (unsigned long) src->addr));

-             
+

              dst[-1] = *src;
            }
          else
              dst[-1] = *src;
            }
          else


@@ -142,9 +146,10 @@ DEFUN (symtab_finalize, (tab), Sym_Table * tab)
            }
        }
     }
            }
        }
     }

-  
+

   if (tab->len > 0 && dst[-1].end_addr == 0)
   if (tab->len > 0 && dst[-1].end_addr == 0)

-    dst[-1].end_addr = core_text_sect->vma + core_text_sect->_raw_size - 1;
+    dst[-1].end_addr
+      = core_text_sect->vma + bfd_get_section_size (core_text_sect) - 1;

 
   DBG (AOUTDEBUG | IDDEBUG,
        printf ("[symtab_finalize]: removed %d duplicate entries\n",
 
   DBG (AOUTDEBUG | IDDEBUG,
        printf ("[symtab_finalize]: removed %d duplicate entries\n",


@@ -157,11 +162,12 @@ DEFUN (symtab_finalize, (tab), Sym_Table * tab)
        unsigned int j;
 
        for (j = 0; j < tab->len; ++j)
        unsigned int j;
 
        for (j = 0; j < tab->len; ++j)

-         {
+        {

           printf ("[symtab_finalize] 0x%lx-0x%lx\t%s\n",
           printf ("[symtab_finalize] 0x%lx-0x%lx\t%s\n",

-                (long) tab->base[j].addr, (long) tab->base[j].end_addr,
-                tab->base[j].name);
-         }
+                  (unsigned long) tab->base[j].addr,
+                  (unsigned long) tab->base[j].end_addr,
+                  tab->base[j].name);
+        }

   );
 }
 
   );
 }
 


@@ -169,25 +175,25 @@ DEFUN (symtab_finalize, (tab), Sym_Table * tab)
 #ifdef DEBUG
 
 Sym *
 #ifdef DEBUG
 
 Sym *

-DEFUN (dbg_sym_lookup, (symtab, address), Sym_Table * symtab AND bfd_vma address)
+dbg_sym_lookup (Sym_Table *sym_tab, bfd_vma address)

 {
 {

-  long low, mid, high;
+  unsigned long low, mid, high;

   Sym *sym;
 
   fprintf (stderr, "[dbg_sym_lookup] address 0x%lx\n",
           (unsigned long) address);
 
   Sym *sym;
 
   fprintf (stderr, "[dbg_sym_lookup] address 0x%lx\n",
           (unsigned long) address);
 

-  sym = symtab->base;
-  for (low = 0, high = symtab->len - 1; low != high;)
+  sym = sym_tab->base;
+  for (low = 0, high = sym_tab->len - 1; low != high;)

     {
       mid = (high + low) >> 1;
     {
       mid = (high + low) >> 1;

-      
+

       fprintf (stderr, "[dbg_sym_lookup] low=0x%lx, mid=0x%lx, high=0x%lx\n",
               low, mid, high);
       fprintf (stderr, "[dbg_sym_lookup] sym[m]=0x%lx sym[m + 1]=0x%lx\n",
               (unsigned long) sym[mid].addr,
               (unsigned long) sym[mid + 1].addr);
       fprintf (stderr, "[dbg_sym_lookup] low=0x%lx, mid=0x%lx, high=0x%lx\n",
               low, mid, high);
       fprintf (stderr, "[dbg_sym_lookup] sym[m]=0x%lx sym[m + 1]=0x%lx\n",
               (unsigned long) sym[mid].addr,
               (unsigned long) sym[mid + 1].addr);

-      
+

       if (sym[mid].addr <= address && sym[mid + 1].addr > address)
        return &sym[mid];
 
       if (sym[mid].addr <= address && sym[mid + 1].addr > address)
        return &sym[mid];
 


@@ -196,9 +202,9 @@ DEFUN (dbg_sym_lookup, (symtab, address), Sym_Table * symtab AND bfd_vma address
       else
        low = mid + 1;
     }
       else
        low = mid + 1;
     }

-  
+

   fprintf (stderr, "[dbg_sym_lookup] binary search fails???\n");
   fprintf (stderr, "[dbg_sym_lookup] binary search fails???\n");

-  
+

   return 0;
 }
 
   return 0;
 }
 


@@ -208,7 +214,7 @@ DEFUN (dbg_sym_lookup, (symtab, address), Sym_Table * symtab AND bfd_vma address
 /* Look up an address in the symbol-table that is sorted by address.
    If address does not hit any symbol, 0 is returned.  */
 Sym *
 /* Look up an address in the symbol-table that is sorted by address.
    If address does not hit any symbol, 0 is returned.  */
 Sym *

-DEFUN (sym_lookup, (symtab, address), Sym_Table * symtab AND bfd_vma address)
+sym_lookup (Sym_Table *sym_tab, bfd_vma address)

 {
   long low, high;
   long mid = -1;
 {
   long low, high;
   long mid = -1;


@@ -217,15 +223,15 @@ DEFUN (sym_lookup, (symtab, address), Sym_Table * symtab AND bfd_vma address)
   int probes = 0;
 #endif /* DEBUG */
 
   int probes = 0;
 #endif /* DEBUG */
 

-  if (!symtab->len)
+  if (!sym_tab->len)

     return 0;
 
     return 0;
 

-  sym = symtab->base;
-  for (low = 0, high = symtab->len - 1; low != high;)
+  sym = sym_tab->base;
+  for (low = 0, high = sym_tab->len - 1; low != high;)

     {
       DBG (LOOKUPDEBUG, ++probes);
       mid = (high + low) / 2;
     {
       DBG (LOOKUPDEBUG, ++probes);
       mid = (high + low) / 2;

-      
+

       if (sym[mid].addr <= address && sym[mid + 1].addr > address)
        {
          if (address > sym[mid].end_addr)
       if (sym[mid].addr <= address && sym[mid + 1].addr > address)
        {
          if (address > sym[mid].end_addr)


@@ -238,17 +244,17 @@ DEFUN (sym_lookup, (symtab, address), Sym_Table * symtab AND bfd_vma address)
            {
              DBG (LOOKUPDEBUG,
                   printf ("[sym_lookup] %d probes (symtab->len=%u)\n",
            {
              DBG (LOOKUPDEBUG,
                   printf ("[sym_lookup] %d probes (symtab->len=%u)\n",

-                          probes, symtab->len - 1));
+                          probes, sym_tab->len - 1));

              return &sym[mid];
            }
        }
              return &sym[mid];
            }
        }

-      
+

       if (sym[mid].addr > address)
        high = mid;
       else
        low = mid + 1;
     }
       if (sym[mid].addr > address)
        high = mid;
       else
        low = mid + 1;
     }

-  
+

   if (sym[mid + 1].addr <= address)
     {
       if (address > sym[mid + 1].end_addr)
   if (sym[mid + 1].addr <= address)
     {
       if (address > sym[mid + 1].end_addr)


@@ -259,10 +265,10 @@ DEFUN (sym_lookup, (symtab, address), Sym_Table * symtab AND bfd_vma address)
       else
        {
          DBG (LOOKUPDEBUG, printf ("[sym_lookup] %d (%u) probes, fall off\n",
       else
        {
          DBG (LOOKUPDEBUG, printf ("[sym_lookup] %d (%u) probes, fall off\n",

-                                   probes, symtab->len - 1));
+                                   probes, sym_tab->len - 1));

          return &sym[mid + 1];
        }
     }
          return &sym[mid + 1];
        }
     }

-  
+

   return 0;
 }
   return 0;
 }