~drizzle-trunk/drizzle/development

/* Copyright (C) 2000 MySQL AB

   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; version 2 of the License.

   This program 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, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */

/* Resolve numeric stack dump produced by drizzled 3.23.30 and later

   versions into symbolic names. By Sasha Pachev <sasha@mysql.com>

 */

#include <drizzled/global.h>

#include <mystrings/m_ctype.h>

#include <mysys/my_sys.h>

#include <mystrings/m_string.h>

#include <errno.h>

#include <mysys/my_getopt.h>

#include <stdio.h>

#define INIT_SYM_TABLE  4096

#define INC_SYM_TABLE  4096

#define MAX_SYM_SIZE   128

#define DUMP_VERSION "1.4"

#define HEX_INVALID  (unsigned char)255

typedef struct sym_entry

{

  char symbol[MAX_SYM_SIZE];

  unsigned char* addr;

} SYM_ENTRY;

static char* dump_fname = 0, *sym_fname = 0;

static DYNAMIC_ARRAY sym_table; /* how do you like this , static DYNAMIC ? */

static FILE* fp_dump, *fp_sym = 0, *fp_out;

static struct my_option my_long_options[] =

{

  {"help", 'h', "Display this help and exit.",

   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},

  {"version", 'V', "Output version information and exit.",

   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},

  {"symbols-file", 's', "Use specified symbols file.", (char**) &sym_fname,

   (char**) &sym_fname, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

  {"numeric-dump-file", 'n', "Read the dump from specified file.",

   (char**) &dump_fname, (char**) &dump_fname, 0, GET_STR, REQUIRED_ARG,

   0, 0, 0, 0, 0, 0},

  { 0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}

};

static void verify_sort(void);

static void print_version(void)

{

  printf("%s  Ver %s Distrib %s, for %s (%s)\n",my_progname,DUMP_VERSION,

	 VERSION,SYSTEM_TYPE,MACHINE_TYPE);

}

static void usage(void)

{

  print_version();

  printf("MySQL AB, by Sasha Pachev\n");

  printf("This software comes with ABSOLUTELY NO WARRANTY\n\n");

  printf("Resolve numeric stack strace dump into symbols.\n\n");

  printf("Usage: %s [OPTIONS] symbols-file [numeric-dump-file]\n",

	 my_progname);

  my_print_help(my_long_options);

  my_print_variables(my_long_options);

  printf("\n\

The symbols-file should include the output from:  'nm --numeric-sort drizzled'.\n\

The numeric-dump-file should contain a numeric stack trace from drizzled.\n\

If the numeric-dump-file is not given, the stack trace is read from stdin.\n");

}

static void die(const char* fmt, ...)

{

  va_list args;

  va_start(args, fmt);

  fprintf(stderr, "%s: ", my_progname);

  vfprintf(stderr, fmt, args);

  fprintf(stderr, "\n");

  va_end(args);

  exit(1);

}

extern "C"

bool get_one_option(int optid, const struct my_option *, char *)

{

  switch(optid) {

  case 'V':

    print_version();

    exit(0);

  case '?':

    usage();

    exit(0);

  }

  return 0;

}

static int parse_args(int argc, char **argv)

{

  int ho_error;

  if ((ho_error= handle_options(&argc, &argv, my_long_options, get_one_option)))

    exit(ho_error);

  /*

    The following code is to make the command compatible with the old

    version that required one to use the -n and -s options

  */

  if (argc == 2)

  {

    sym_fname= argv[0];

    dump_fname= argv[1];

  }

  else if (argc == 1)

  {

    if (!sym_fname)

      sym_fname = argv[0];

    else if (!dump_fname)

      dump_fname = argv[0];

    else

    {

      usage();

      exit(1);

    }

  }

  else if (argc != 0 || !sym_fname)

  {

    usage();

    exit(1);

  }

  return 0;

}

static void open_files(void)

{

  fp_out = stdout;

  fp_dump = stdin;

  if (dump_fname && !(fp_dump= fopen(dump_fname, "r")))

      die("Could not open %s", dump_fname);

  /* if name not given, assume stdin*/

  if (!sym_fname)

    die("Please run nm --numeric-sort on drizzled binary that produced stack \

trace dump and specify the path to it with -s or --symbols-file");

  if (!(fp_sym= fopen(sym_fname, "r")))

    die("Could not open %s", sym_fname);

}

static unsigned char hex_val(char c)

{

  unsigned char l;

  if (my_isdigit(&my_charset_utf8_general_ci,c))

    return c - '0';

  l = my_tolower(&my_charset_utf8_general_ci,c);

  if (l < 'a' || l > 'f')

    return HEX_INVALID;

  return (unsigned char)10 + ((unsigned char)c - (unsigned char)'a');

}

static unsigned long read_addr(char** buf)

{

  unsigned char c;

  char* p = *buf;

  unsigned long addr = 0;

  while((c = hex_val(*p++)) != HEX_INVALID)

      addr = (addr << 4) + c;

  *buf = p;

  return addr;

}

static int init_sym_entry(SYM_ENTRY* se, char* buf)

{

  char* p, *p_end;

  se->addr = (unsigned char*)read_addr(&buf);

  if (!se->addr)

    return -1;

  while (my_isspace(&my_charset_utf8_general_ci,*buf++))

    /* empty */;

  while (my_isspace(&my_charset_utf8_general_ci,*buf++))

    /* empty - skip more space */;

  --buf;

  /* now we are on the symbol */

  for (p = se->symbol, p_end = se->symbol + sizeof(se->symbol) - 1;

       *buf != '\n' && *buf && p < p_end; ++buf,++p)

    *p = *buf;

  *p = 0;

  if (!strcmp(se->symbol, "gcc2_compiled."))

    return -1;

  return 0;

}

static void init_sym_table(void)

{

  char buf[512];

  if (my_init_dynamic_array(&sym_table, sizeof(SYM_ENTRY), INIT_SYM_TABLE,

			    INC_SYM_TABLE))

    die("Failed in my_init_dynamic_array() -- looks like out of memory problem");

  while (fgets(buf, sizeof(buf), fp_sym))

  {

    SYM_ENTRY se;

    if (init_sym_entry(&se, buf))

      continue;

    if (insert_dynamic(&sym_table, (unsigned char*)&se))

      die("insert_dynamic() failed - looks like we are out of memory");

  }

  verify_sort();

}

static void clean_up(void)

{

  delete_dynamic(&sym_table);

}

static void verify_sort()

{

  uint32_t i;

  unsigned char* last = 0;

  for (i = 0; i < sym_table.elements; i++)

  {

    SYM_ENTRY se;

    get_dynamic(&sym_table, (unsigned char*)&se, i);

    if (se.addr < last)

      die("sym table does not appear to be sorted, did you forget \

--numeric-sort arg to nm? trouble addr = %p, last = %p", se.addr, last);

    last = se.addr;

  }

}

static SYM_ENTRY* resolve_addr(unsigned char* addr, SYM_ENTRY* se)

{

  uint32_t i;

  get_dynamic(&sym_table, (unsigned char*)se, 0);

  if (addr < se->addr)

    return 0;

  for (i = 1; i < sym_table.elements; i++)

  {

    get_dynamic(&sym_table, (unsigned char*)se, i);

    if (addr < se->addr)

    {

      get_dynamic(&sym_table, (unsigned char*)se, i - 1);

      return se;

    }

  }

  return se;

}

static void do_resolve(void)

{

  char buf[1024], *p;

  while (fgets(buf, sizeof(buf), fp_dump))

  {

    p = buf;

    /* skip space */

    while (my_isspace(&my_charset_utf8_general_ci,*p))

      ++p;

    if (*p++ == '0' && *p++ == 'x')

    {

      SYM_ENTRY se ;

      unsigned char* addr = (unsigned char*)read_addr(&p);

      if (resolve_addr(addr, &se))

	fprintf(fp_out, "%p %s + %d\n", addr, se.symbol,

		(int) (addr - se.addr));

      else

	fprintf(fp_out, "%p (?)\n", addr);

    }

    else

    {

      fputs(buf, fp_out);

      continue;

    }

  }

}

int main(int argc, char** argv)

{

  MY_INIT(argv[0]);

  parse_args(argc, argv);

  open_files();

  init_sym_table();

  do_resolve();

  clean_up();

  return 0;

}