klish/lub/heap/posix/heap_symShow.c

/* 
 * heap_symShow.c - convert addresses to line number and function name
 */   
#include <string.h>
#include <stdlib.h>
#include <stdio.h>

#include "../private.h"
#include "../context.h"

#undef lub_heap_init /* defined for cygwin builds */


#ifdef HAVE_CONFIG_H
#include "config.h"
#endif /* HAVE_CONFIG_H */


extern void sysheap_suppress_leak_detection(void);
extern void sysheap_restore_leak_detection(void);


#if defined(__CYGWIN__)
/*---------------------------------------------------------
 * under CYGWIN we have the nasty behaviour that
 * argv[0] is the program name without the .exe extension
 * which is needed to load the symbol table; hence this
 * crufty hack *8-)
 *--------------------------------------------------------- */
void
cygwin_lub_heap_init(const char *file_name)
{
    char buffer[80];
    sprintf(buffer,"%s.exe",file_name);
    lub_heap_init(buffer);
}
/*--------------------------------------------------------- */
#endif /* __CYGWIN__ */

#ifndef HAVE_LIBBFD
/*--------------------------------------------------------- */
/*
 * Simple vanilla dump of symbols address
 * This is automatically used unless GPL support has been
 * configured.
 */
void 
lub_heap_symShow(unsigned address)
{
    printf(" 0x%08x",address);
}
/*--------------------------------------------------------- */
bool_t
lub_heap_symMatch(unsigned    address,
                  const char *substring)
{
    return BOOL_TRUE;
}
/*--------------------------------------------------------- */
/*
 * dummy initialisation call
 */
void
lub_heap_init(const char *file_name)
{
    file_name = file_name;
    lub_heap__set_framecount(MAX_BACKTRACE);
}
/*--------------------------------------------------------- */
#else /* HAVE_LIBBFD */
/*
   This file is part of the CLISH project http://clish.sourceforge.net/

   The code in this file 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; version 2
   
   This code is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

   Derived from addr2line.c in the GNU binutils package by Ulrich.Lauther@mchp.siemens.de 
*/
#include "bfd.h"

/*--------------------------------------------------------- */
/* These global variables are used to pass information between
   translate_addresses and find_address_in_section.  */
/*--------------------------------------------------------- */
typedef struct
{
    bfd_vma      pc;
    asymbol    **syms;
    const char  *file_name;
    const char  *fn_name;
    unsigned int line_num;
    bfd_boolean  found;
} info_t;
/*--------------------------------------------------------- */
typedef struct
{
    bfd      *abfd;
    asymbol **syms;  /* Symbol table.  */
} lub_heap_posix_t;
/*--------------------------------------------------------- */
static lub_heap_posix_t my_instance; /* instance of this class */

/*--------------------------------------------------------- */
/* Look for an address in a section.  This is called via
   bfd_map_over_sections.  */
/*--------------------------------------------------------- */
static void
find_address_in_section (bfd     *abfd,
                         asection *section,
                         void     *data)
{
    info_t       *info = data;
    bfd_vma       vma;
    bfd_size_type size;

    if (info->found)
        return;

    if ((bfd_get_section_flags (abfd, section) & SEC_ALLOC) == 0)
        return;

    vma = bfd_get_section_vma (abfd, section);
    if (info->pc < vma)
        return;

    size = bfd_get_section_size (section);
    if (info->pc >= vma + size)
        return;

    info->found = bfd_find_nearest_line (abfd, 
                                         section, 
                                         info->syms,
                                         info->pc - vma,
                                         &info->file_name, 
                                         &info->fn_name,
                                         &info->line_num);
    if(!info->line_num || !info->file_name)
    {
        info->found = 0;
    }
    if(info->found)
    {
        const char *last_file_name;
        const char *last_fn_name;
        unsigned    last_line_num;
        
        bfd_find_nearest_line (abfd,
                               section, 
                               info->syms,
                               vma + size - 1,
                               &last_file_name, 
                               &last_fn_name,
                               &last_line_num);
        if(   (last_file_name == info->file_name)
           && (last_fn_name   == info->fn_name  )
           && (last_line_num  == info->line_num))
        {
            info->found = FALSE;
        }
    }
    if(info->found)
    {
        /* strip to the basename */
        char *p;

        p = strrchr (info->file_name, '/');
        if (NULL != p)
        {
            info->file_name = p + 1;
        }
    }
}
/*--------------------------------------------------------- */
static void
lub_heap_posix_fini(void)
{
    lub_heap_posix_t *this = &my_instance;
    if (this->syms != NULL)
    {
      free (this->syms);
      this->syms = NULL;
    }

    if(this->abfd)
    {
        bfd_close (this->abfd);
    }
}
/*--------------------------------------------------------- */
void
lub_heap_init(const char *file_name)
{
    lub_heap_posix_t *this = &my_instance;

    /* remember to cleanup */
    atexit(lub_heap_posix_fini);
    
    /* switch on leak detection */
    lub_heap__set_framecount(MAX_BACKTRACE);

    sysheap_suppress_leak_detection();

    bfd_init ();
    
    this->syms = NULL;
    this->abfd = bfd_openr (file_name, "pe-i386");
    if (this->abfd)
    {
        if(bfd_check_format_matches (this->abfd, bfd_object,NULL))
        {
            unsigned int size;
            long         symcount = 0;
            
            if (!(bfd_get_file_flags (this->abfd) & HAS_SYMS) == 0)
            {
                /* Read in the symbol table.  */
                symcount = bfd_read_minisymbols (this->abfd, 
                                                 FALSE, 
                                                 (void*)&this->syms, 
                                                 &size);
                if(0 == symcount)
                {
                    /* try reading dynamic symbols */
                    symcount = bfd_read_minisymbols (this->abfd, 
                                                     TRUE /* dynamic */, 
                                                     (void*)&this->syms,
                                                     &size);
                }
            }
            if(0 == symcount)
            {
                fprintf(stderr,"*** no symbols found in '%s'\n",bfd_get_filename(this->abfd));
            }
        }
    }
    sysheap_restore_leak_detection();
}
/*--------------------------------------------------------- */
static void
_lub_heap_symGetInfo(lub_heap_posix_t *this,
                     unsigned          address,
                     info_t           *info)
{
    info->pc        = address;
    info->syms      = this->syms;
    info->fn_name   = NULL;
    info->file_name = NULL;
    info->line_num  = 0;
    info->found     = FALSE;
    
    sysheap_suppress_leak_detection();
    if(NULL != this->abfd)
    {

        bfd_map_over_sections (this->abfd, 
                               find_address_in_section, 
                               info);
    }
    sysheap_restore_leak_detection();
}
/*--------------------------------------------------------- */
void
lub_heap_symShow(unsigned address)
{
    lub_heap_posix_t *this = &my_instance;
    info_t            info;

    _lub_heap_symGetInfo(this,address,&info);

    if(!info.found)
    {
        if(this->abfd && this->syms)
        {
            /* a line with the function names */
            printf("%26s","");
        }
        printf(" 0x%08x",address);
        if(!this->abfd)
        {
            /* aline with the function names */
            printf(" - lub_heap_init() not called.");
        }
    }
    else
    {
        printf(" %20s:%-4d",info.file_name,info.line_num);
        printf(" %s()",info.fn_name);
    }
}
/*--------------------------------------------------------- */
bool_t
lub_heap_symMatch(unsigned    address,
                  const char *substring)
{
    lub_heap_posix_t *this = &my_instance;
    info_t            info;
    bool_t            result = BOOL_FALSE;
    _lub_heap_symGetInfo(this,address,&info);

    if(info.found)
    {
        if(strstr(info.fn_name,substring))
        {
            result = TRUE;
        }
    }
    return result;
}
/*--------------------------------------------------------- */
#endif /* HAVE_LIBBFD */