pstack.c File Reference

#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sys/ptrace.h>
#include <asm/ptrace.h>
#include <assert.h>
#include <fcntl.h>
#include <link.h>
#include <malloc.h>
#include <string.h>
#include <stdarg.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <signal.h>
#include <pthread.h>
#include <limits.h>
#include <bfd.h>
#include "libiberty.h"
#include "pstack.h"
#include "budbg.h"
#include "bucomm.h"
#include "debug.h"
#include "linuxthreads.h"

Go to the source code of this file.

Data Structures
struct	debug_block_st
struct	debug_function_t
struct	debug_lineno_t
struct	debug_parameter_t
struct	pr_handle
struct	pr_stack
struct	signal_regs_t
struct	symbol_data_t
Defines
#define	MAXARGS   6
Typedefs
typedef debug_block_st	debug_block_t
Functions
static boolean	append_type (struct pr_handle *info, const char *s)
static int	compare_debug_function_t (const void *ap, const void *bp)
static int	compare_symbols (const void *ap, const void *bp)
static void	decode_symbol (symbol_data_t *symbol_data, const unsigned long addr, char *buf, const int bufsize)
int	fdprintf (int fd, const char *fmt,...)
int	fdputc (char c, int fd)
int	fdputs (const char *s, int fd)
static debug_function_t *	find_debug_function_t (symbol_data_t *symbol_data, const pid_t pid, const unsigned long fp, const unsigned long addr, char *buf, const int bufsize)
static void	indent (struct pr_handle *info)
static boolean	indent_type (struct pr_handle *info)
static bfd *	load_bfd (const int pid)
static int	my_crawl (int pid, symbol_data_t *symbol_data, int fout)
static int	my_ptrace (int request, int pid, int addr, int data)
static int	open_log_file (const pthread_t tid, const pid_t pid)
static void indent	PARAMS ((struct pr_handle *))
static char *	pop_type (struct pr_handle *info)
static boolean	pr_array_type (PTR p, bfd_signed_vma lower, bfd_signed_vma upper, boolean stringp)
static boolean	pr_bool_type (PTR p, unsigned int size)
static boolean	pr_class_baseclass (PTR p, bfd_vma bitpos, boolean virtual, enum debug_visibility visibility)
static boolean	pr_class_end_method (PTR p)
static boolean	pr_class_method_variant (PTR p, const char *physname, enum debug_visibility visibility, boolean constp, boolean volatilep, bfd_vma voffset, boolean context)
static boolean	pr_class_start_method (PTR p, const char *name)
static boolean	pr_class_static_member (PTR p, const char *name, const char *physname, enum debug_visibility visibility)
static boolean	pr_class_static_method_variant (PTR p, const char *physname, enum debug_visibility visibility, boolean constp, boolean volatilep)
static boolean	pr_complex_type (PTR p, unsigned int size)
static boolean	pr_const_type (PTR p)
static boolean	pr_empty_type (PTR p)
static boolean	pr_end_block (PTR p, bfd_vma addr)
static boolean	pr_end_class_type (PTR p)
static boolean	pr_end_function (PTR p)
static boolean	pr_end_struct_type (PTR p)
static boolean	pr_enum_type (PTR p, const char *tag, const char **names, bfd_signed_vma *values)
static boolean	pr_fix_visibility (struct pr_handle *info, enum debug_visibility visibility)
static boolean	pr_float_constant (PTR p, const char *name, double val)
static boolean	pr_float_type (PTR p, unsigned int size)
static boolean	pr_function_parameter (PTR p, const char *name, enum debug_parm_kind kind, bfd_vma val)
static boolean	pr_function_type (PTR p, int argcount, boolean varargs)
static boolean	pr_int_constant (PTR p, const char *name, bfd_vma val)
static boolean	pr_int_type (PTR p, unsigned int size, boolean unsignedp)
static boolean	pr_lineno (PTR p, const char *filename, unsigned long lineno, bfd_vma addr)
static boolean	pr_method_type (PTR p, boolean domain, int argcount, boolean varargs)
static boolean	pr_offset_type (PTR p)
static boolean	pr_pointer_type (PTR p)
static boolean	pr_range_type (PTR p, bfd_signed_vma lower, bfd_signed_vma upper)
static boolean	pr_reference_type (PTR p)
static boolean	pr_set_type (PTR p, boolean bitstringp)
static boolean	pr_start_block (PTR p, bfd_vma addr)
static boolean	pr_start_class_type (PTR p, const char *tag, unsigned int id, boolean structp, unsigned int size, boolean vptr, boolean ownvptr)
static boolean	pr_start_compilation_unit (PTR p, const char *filename)
static boolean	pr_start_function (PTR p, const char *name, boolean global)
static boolean	pr_start_source (PTR p, const char *filename)
static boolean	pr_start_struct_type (PTR p, const char *tag, unsigned int id, boolean structp, unsigned int size)
static boolean	pr_struct_field (PTR p, const char *name, bfd_vma bitpos, bfd_vma bitsize, enum debug_visibility visibility)
static boolean	pr_tag (PTR p, const char *name)
static boolean	pr_tag_type (PTR p, const char *name, unsigned int id, enum debug_type_kind kind)
static boolean	pr_typdef (PTR p, const char *name)
static boolean	pr_typed_constant (PTR p, const char *name, bfd_vma val)
static boolean	pr_typedef_type (PTR p, const char *name)
static boolean	pr_variable (PTR p, const char *name, enum debug_var_kind kind, bfd_vma val)
static boolean	pr_void_type (PTR p)
static boolean	pr_volatile_type (PTR p)
static boolean	prepend_type (struct pr_handle *info, const char *s)
static void	print_vma (bfd_vma vma, char *buf, boolean unsignedp, boolean hexp)
int	pstack_install_segv_action (const char *path_format_)
static boolean	push_type (struct pr_handle *info, const char *type)
static long	remove_useless_symbols (asymbol **symbols, long count)
static void	report_action (int signo, siginfo_t *siginfo, void *ptr)
static void	segv_action (int signo, siginfo_t *siginfo, void *ptr)
static void	show_regs (signal_regs_t *regs, int fd)
static boolean	substitute_type (struct pr_handle *info, const char *s)
Variables
static bfd *	abfd = 0
static PTR	dhandle = 0
static debug_function_t **	functions = 0
static int	functions_size = 0
static const char *	path_format = "stack-trace-on-segv-%d.txt"
static const struct debug_write_fns	pr_fns
signal_regs_t *	ptrace_regs = 0
static pid_t	segv_pid
static pthread_t	segv_tid
static int	sigreport = SIGUSR1
static long	sorted_symcount = 0
static asymbol **	sorted_syms = 0
static long	symcount = 0
static asymbol **	syms = 0

---

Define Documentation

#define MAXARGS   6

Definition at line 2162 of file pstack.c.

---

Typedef Documentation

typedef struct debug_block_st debug_block_t

---

Function Documentation

static boolean append_type (  struct pr_handle *  info, const char *  s )  [static]

Definition at line 389 of file pstack.c. References assert, len, NULL, and xrealloc(). Referenced by indent_type(), pr_array_type(), pr_class_baseclass(), pr_class_method_variant(), pr_class_static_member(), pr_class_static_method_variant(), pr_enum_type(), pr_fix_visibility(), pr_offset_type(), pr_range_type(), pr_set_type(), pr_start_class_type(), pr_start_struct_type(), pr_struct_field(), pr_tag_type(), and substitute_type(). { unsigned int len; if (s == NULL) return false; assert (info->stack != NULL); len = strlen (info->stack->type); info->stack->type = (char *) xrealloc (info->stack->type, len + strlen (s) + 1); strcpy (info->stack->type + len, s); return true; }

static int compare_debug_function_t (  const void *  ap, const void *  bp )  [static]

Definition at line 2491 of file pstack.c. References assert, debug_block_st::begin_addr, and debug_function_t::block. Referenced by pstack_install_segv_action(). { const debug_function_t *a = *(const debug_function_t **)ap; const debug_function_t *b = *(const debug_function_t **)bp; assert(a->block!=0); assert(b->block!=0); { const bfd_vma addr1 = a->block->begin_addr; const bfd_vma addr2 = b->block->begin_addr; if (addr1 > addr2) return 1; else if (addr2 > addr1) return -1; } return 0; }

static int compare_symbols (  const void *  ap, const void *  bp )  [static]

Definition at line 2475 of file pstack.c. Referenced by pstack_install_segv_action(). { const asymbol *a = *(const asymbol **)ap; const asymbol *b = *(const asymbol **)bp; if (bfd_asymbol_value (a) > bfd_asymbol_value (b)) return 1; else if (bfd_asymbol_value (a) < bfd_asymbol_value (b)) return -1; return 0; }

static void decode_symbol (  symbol_data_t *  symbol_data, const unsigned long  addr, char *  buf, const int  bufsize )  [static]

Definition at line 2178 of file pstack.c. References name, symbol_data_t::symcount, symcount, symbol_data_t::syms, syms, and top. Referenced by my_crawl(). { asymbol** syms = symbol_data->syms; const int symcount = symbol_data->symcount; int bottom = 0; int top = symcount - 1; int i; if (symcount==0) { sprintf(buf, "????"); return; } while (top>bottom+1) { i = (top+bottom) / 2; if (bfd_asymbol_value(syms[i])==addr) { sprintf(buf, "%s", syms[i]->name); return; } else if (bfd_asymbol_value(syms[i]) > addr) top = i; else bottom = i; } i = bottom; if (addr<bfd_asymbol_value(syms[i]) || addr>(syms[i]->section->vma+syms[i]->section->_cooked_size)) sprintf(buf, "????"); else sprintf(buf, "%s + 0x%lx", syms[i]->name, addr-bfd_asymbol_value(syms[i])); }

int fdprintf (  int  fd, const char *  fmt,   ... )

Definition at line 83 of file pstack.c. References vsnprintf, and write(). Referenced by my_crawl(), report_action(), segv_action(), and show_regs(). { char xbuf[2048];// FIXME: enough? va_list ap; int r; if (fd<0) return -1; va_start(ap, fmt); r = vsnprintf(xbuf, sizeof(xbuf), fmt, ap); va_end(ap); return write(fd, xbuf, r); }

int fdputc (  char  c, int  fd )

Definition at line 98 of file pstack.c. References write(). Referenced by my_crawl(). { if (fd<0) return -1; return write(fd, &c, sizeof(c)); }

int fdputs (  const char *  s, int  fd )

Definition at line 107 of file pstack.c. References write(). Referenced by my_crawl(). { if (fd<0) return -1; return write(fd, s, strlen(s)); }

static debug_function_t* find_debug_function_t (  symbol_data_t *  symbol_data, const pid_t  pid, const unsigned long  fp, const unsigned long  addr, char *  buf, const int  bufsize )  [static]

Definition at line 2215 of file pstack.c. References debug_lineno_t::addr, arg, debug_function_t::argc, debug_function_t::argv, assert, debug_block_st::begin_addr, debug_function_t::block, yaSSL::block, debug_block_st::end_addr, errno, f(), debug_function_t::filename, symbol_data_t::functions, symbol_data_t::functions_size, debug_lineno_t::lineno, lineno, debug_function_t::lines, debug_function_t::lines_count, my_ptrace(), debug_parameter_t::name, debug_function_t::name, NULL, debug_parameter_t::offset, symcount, syms, and top. Referenced by my_crawl(). : not used! */ { debug_function_t** syms = symbol_data->functions; debug_function_t* f = NULL; debug_block_t* block = NULL; debug_lineno_t* lineno = NULL; const int symcount = symbol_data->functions_size; int bottom = 0; int top = symcount - 1; int i; char* bufptr = buf; if (symcount==0) { sprintf(buf, "????"); return NULL; } while (top>bottom+1) { i = (top+bottom) / 2; if (syms[i]->block->begin_addr==addr) { f = syms[i]; break; } else if (syms[i]->block->begin_addr > addr) top = i; else if (syms[i]->block->end_addr >= addr) { f = syms[i]; break; } else bottom = i; } i = bottom; if (f!=0) block = f->block; else { block = syms[i]->block; if (block->begin_addr>=addr && block->end_addr<=addr) f = syms[i]; } if (f==0) sprintf(buf, "????"); else { /* * Do the backtrace the GDB way... */ unsigned long arg; /* assert(f->lines_count>0); */ if (f->lines_count>0) { lineno = &f->lines[f->lines_count-1]; for (i=1; i<f->lines_count; ++i) if (f->lines[i].addr>addr) { lineno = &f->lines[i-1]; break; } } bufptr[0] = 0; bufptr += sprintf(bufptr, "%s+0x%lx (", f->name, addr-block->begin_addr); for (i=0; i<f->argc; ++i) { bufptr += sprintf(bufptr, "%s = ", f->argv[i].name); /* FIXME: better parameter printing */ errno = 0; arg = my_ptrace(PTRACE_PEEKDATA, pid, fp+f->argv[i].offset, 0); assert(errno==0); bufptr += sprintf(bufptr, "0x%x", arg); if (i!=f->argc-1) bufptr += sprintf(bufptr, ", "); } if (lineno!=0) bufptr += sprintf(bufptr, ") at %s:%d", f->filename, lineno->lineno); } return f; }

static void indent (  struct pr_handle *  info  )  [static]

Definition at line 334 of file pstack.c. References TRACE_PUTC. Referenced by indent_type(), pr_end_block(), pr_lineno(), pr_start_block(), pr_start_function(), and pr_variable(). { unsigned int i; for (i = 0; i < info->indent; i++) TRACE_PUTC ((' ', info->f)); }

static boolean indent_type (  struct pr_handle *  info  )  [static]

Definition at line 457 of file pstack.c. References append_type(), and indent(). Referenced by pr_class_method_variant(), pr_class_static_member(), pr_class_static_method_variant(), pr_fix_visibility(), pr_start_class_type(), pr_start_struct_type(), and pr_struct_field(). { unsigned int i; for (i = 0; i < info->indent; i++) { if (! append_type (info, " ")) return false; } return true; }

static bfd* load_bfd (  const int  pid  )  [static]

Definition at line 2435 of file pstack.c. References abfd, assert, bfd_nonfatal(), filename, free, list_matching_formats(), and NULL. Referenced by pstack_install_segv_action(). { char filename[512]; bfd* abfd = 0; /* Get the contents from procfs. */ #if 1 sprintf(filename, "/proc/%d/exe", pid); #else sprintf(filename, "crashing"); #endif if ((abfd = bfd_openr (filename, 0))== NULL) bfd_nonfatal (filename); else { char** matching; assert(bfd_check_format(abfd, bfd_archive)!=true); /* * There is no indication in BFD documentation that it should be done. * God knows why... */ if (!bfd_check_format_matches (abfd, bfd_object, &matching)) { bfd_nonfatal (bfd_get_filename (abfd)); if (bfd_get_error () == bfd_error_file_ambiguously_recognized) { list_matching_formats (matching); free (matching); } } } return abfd; }

static int my_crawl (  int  pid, symbol_data_t *  symbol_data, int  fout )  [static]

Definition at line 2296 of file pstack.c. References arg, buf, decode_symbol(), errno, f(), fdprintf(), fdputc(), fdputs(), find_debug_function_t(), fp, MAXARGS, my_ptrace(), and perror(). Referenced by report_action(), and segv_action(). { unsigned long pc = 0; unsigned long fp = 0; unsigned long nextfp; unsigned long nargs; unsigned long i; unsigned long arg; char buf[8096]; // FIXME: enough? debug_function_t* f = 0; errno = 0; pc = my_ptrace(PTRACE_PEEKUSER, pid, EIP * 4, 0); if (!errno) fp = my_ptrace(PTRACE_PEEKUSER, pid, EBP * 4, 0); if (!errno) { #if 1 f = find_debug_function_t(symbol_data, pid, fp, pc, buf, sizeof(buf)); fdprintf(fout,"0x%08lx: %s", pc, buf); for ( ; !errno && fp; ) { nextfp = my_ptrace(PTRACE_PEEKDATA, pid, fp, 0); if (errno) break; if (f==0) { nargs = (nextfp - fp - 8) / 4; if (nargs > MAXARGS) nargs = MAXARGS; if (nargs > 0) { fdputs(" (", fout); for (i = 1; i <= nargs; i++) { arg = my_ptrace(PTRACE_PEEKDATA, pid, fp + 4 * (i + 1), 0); if (errno) break; fdprintf(fout,"%lx", arg); if (i < nargs) fdputs(", ", fout); } fdputc(')', fout); nargs = nextfp - fp - 8 - (4 * nargs); if (!errno && nargs > 0) fdprintf(fout," + %lx\n", nargs); else fdputc('\n', fout); } else fdputc('\n', fout); } else fdputc('\n', fout); if (errno || !nextfp) break; pc = my_ptrace(PTRACE_PEEKDATA, pid, fp + 4, 0); fp = nextfp; if (errno) break; f = find_debug_function_t(symbol_data, pid, fp, pc, buf, sizeof(buf)); fdprintf(fout,"0x%08lx: %s", pc, buf); } #else /* 1 */ decode_symbol(symbol_data, pc, buf, sizeof(buf)); fdprintf(fout,"0x%08lx: %s", pc, buf); for ( ; !errno && fp; ) { nextfp = my_ptrace(PTRACE_PEEKDATA, pid, fp, 0); if (errno) break; nargs = (nextfp - fp - 8) / 4; if (nargs > MAXARGS) nargs = MAXARGS; if (nargs > 0) { fputs(" (", fout); for (i = 1; i <= nargs; i++) { arg = my_ptrace(PTRACE_PEEKDATA, pid, fp + 4 * (i + 1), 0); if (errno) break; fdprintf(fout,"%lx", arg); if (i < nargs) fputs(", ", fout); } fdputc(')', fout); nargs = nextfp - fp - 8 - (4 * nargs); if (!errno && nargs > 0) fdprintf(fout," + %lx\n", nargs); else fdputc('\n', fout); } else fdputc('\n', fout); if (errno || !nextfp) break; pc = my_ptrace(PTRACE_PEEKDATA, pid, fp + 4, 0); fp = nextfp; if (errno) break; decode_symbol(symbol_data, pc, buf, sizeof(buf)); fdprintf(fout,"0x%08lx: %s", pc, buf); } #endif /* !1 */ } if (errno) perror("my_crawl"); return errno; }

static int my_ptrace (  int  request, int  pid, int  addr, int  data )  [static]

Definition at line 2136 of file pstack.c. References assert, signal_regs_t::ebp, signal_regs_t::eip, and errno. Referenced by find_debug_function_t(), and my_crawl(). { if (ptrace_regs==0) return ptrace(request, pid, addr, data); /* we are tracing ourselves! */ switch (request) { case PTRACE_ATTACH: return 0; case PTRACE_CONT: return 0; case PTRACE_DETACH: return 0; case PTRACE_PEEKUSER: switch (addr / 4) { case EIP: return ptrace_regs->eip; case EBP: return ptrace_regs->ebp; default: assert(0); } case PTRACE_PEEKTEXT: /* FALLTHROUGH */ case PTRACE_PEEKDATA: return *(int*)(addr); default: assert(0); } errno = 1; /* what to do here? */ return 1; /* failed?! */ }

static int open_log_file (  const pthread_t  tid, const pid_t  pid )  [static]

Definition at line 121 of file pstack.c. References open(), path_format, perror(), S_IRUSR, S_IWUSR, and snprintf. Referenced by report_action(), and segv_action(). { char fname[PATH_MAX]; int r; snprintf(fname, sizeof(fname), path_format, tid, pid); r = open(fname, O_WRONLY|O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR); if (r<0) perror("open"); return r; }

static void indent PARAMS (  (struct pr_handle *)   )  [static]

static char* pop_type (  struct pr_handle *  info  )  [static]

Definition at line 474 of file pstack.c. References assert, free, pr_stack::next, NULL, and pr_stack::type. Referenced by pr_array_type(), pr_class_baseclass(), pr_class_method_variant(), pr_class_static_member(), pr_class_static_method_variant(), pr_function_parameter(), pr_function_type(), pr_method_type(), pr_offset_type(), pr_start_class_type(), pr_start_function(), pr_struct_field(), pr_tag(), pr_typdef(), pr_typed_constant(), and pr_variable(). { struct pr_stack *o; char *ret; assert (info->stack != NULL); o = info->stack; info->stack = o->next; ret = o->type; free (o); return ret; }

static boolean pr_array_type (  PTR  p, bfd_signed_vma  lower, bfd_signed_vma  upper, boolean  stringp )  [static]

Definition at line 837 of file pstack.c. References append_type(), info, NULL, pop_type(), print_vma(), and substitute_type(). { struct pr_handle *info = (struct pr_handle *) p; char *range_type; char abl[20], abu[20], ab[50]; range_type = pop_type (info); if (range_type == NULL) return false; if (lower == 0) { if (upper == -1) sprintf (ab, "|[]"); else { print_vma (upper + 1, abu, false, false); sprintf (ab, "|[%s]", abu); } } else { print_vma (lower, abl, false, false); print_vma (upper, abu, false, false); sprintf (ab, "|[%s:%s]", abl, abu); } if (! substitute_type (info, ab)) return false; if (strcmp (range_type, "int") != 0) { if (! append_type (info, ":") || ! append_type (info, range_type)) return false; } if (stringp) { if (! append_type (info, " /* string */")) return false; } return true; }

static boolean pr_bool_type (  PTR  p, unsigned int  size )  [static]

Definition at line 622 of file pstack.c. References info, and push_type(). { struct pr_handle *info = (struct pr_handle *) p; char ab[10]; sprintf (ab, "bool%d", size * 8); return push_type (info, ab); }

static boolean pr_class_baseclass (  PTR  p, bfd_vma  bitpos, boolean  virtual, enum debug_visibility  visibility )  [static]

Definition at line 1373 of file pstack.c. References append_type(), assert, DEBUG_VISIBILITY_PRIVATE, DEBUG_VISIBILITY_PROTECTED, DEBUG_VISIBILITY_PUBLIC, free, info, memcpy, n, pr_stack::next, NULL, pop_type(), prepend_type(), print_vma(), push_type(), pr_handle::stack, strchr(), substitute_type(), and xmalloc(). { struct pr_handle *info = (struct pr_handle *) p; char *t; const char *prefix; char ab[20]; char *s, *l, *n; assert (info->stack != NULL && info->stack->next != NULL); if (! substitute_type (info, "")) return false; t = pop_type (info); if (t == NULL) return false; if (strncmp (t, "class ", sizeof "class " - 1) == 0) t += sizeof "class " - 1; /* Push it back on to take advantage of the prepend_type and append_type routines. */ if (! push_type (info, t)) return false; if (virtual) { if (! prepend_type (info, "virtual ")) return false; } switch (visibility) { case DEBUG_VISIBILITY_PUBLIC: prefix = "public "; break; case DEBUG_VISIBILITY_PROTECTED: prefix = "protected "; break; case DEBUG_VISIBILITY_PRIVATE: prefix = "private "; break; default: prefix = "/* unknown visibility */ "; break; } if (! prepend_type (info, prefix)) return false; if (bitpos != 0) { print_vma (bitpos, ab, true, false); if (! append_type (info, " /* bitpos ") || ! append_type (info, ab) || ! append_type (info, " */")) return false; } /* Now the top of the stack is something like "public A / * bitpos 10 * /". The next element on the stack is something like "class xx { / * size 8 * /\n...". We want to substitute the top of the stack in before the {. */ s = strchr (info->stack->next->type, '{'); assert (s != NULL); --s; /* If there is already a ':', then we already have a baseclass, and we must append this one after a comma. */ for (l = info->stack->next->type; l != s; l++) if (*l == ':') break; if (! prepend_type (info, l == s ? " : " : ", ")) return false; t = pop_type (info); if (t == NULL) return false; n = (char *) xmalloc (strlen (info->stack->type) + strlen (t) + 1); memcpy (n, info->stack->type, s - info->stack->type); strcpy (n + (s - info->stack->type), t); strcat (n, s); free (info->stack->type); info->stack->type = n; free (t); return true; }

static boolean pr_class_end_method (  PTR  p  )  [static]

Definition at line 1625 of file pstack.c. References info, pr_stack::method, NULL, and pr_handle::stack. { struct pr_handle *info = (struct pr_handle *) p; info->stack->method = NULL; return true; }

static boolean pr_class_method_variant (  PTR  p, const char *  physname, enum debug_visibility  visibility, boolean  constp, boolean  volatilep, bfd_vma  voffset, boolean  context )  [static]

Definition at line 1486 of file pstack.c. References append_type(), assert, indent_type(), info, pr_stack::next, NULL, pop_type(), pr_fix_visibility(), print_vma(), pr_handle::stack, and substitute_type(). { struct pr_handle *info = (struct pr_handle *) p; char *method_type; char *context_type; assert (info->stack != NULL); assert (info->stack->next != NULL); /* Put the const and volatile qualifiers on the type. */ if (volatilep) { if (! append_type (info, " volatile")) return false; } if (constp) { if (! append_type (info, " const")) return false; } /* Stick the name of the method into its type. */ if (! substitute_type (info, (context ? info->stack->next->next->method : info->stack->next->method))) return false; /* Get the type. */ method_type = pop_type (info); if (method_type == NULL) return false; /* Pull off the context type if there is one. */ if (! context) context_type = NULL; else { context_type = pop_type (info); if (context_type == NULL) return false; } /* Now the top of the stack is the class. */ if (! pr_fix_visibility (info, visibility)) return false; if (! append_type (info, method_type) || ! append_type (info, " /* ") || ! append_type (info, physname) || ! append_type (info, " ")) return false; if (context || voffset != 0) { char ab[20]; if (context) { if (! append_type (info, "context ") || ! append_type (info, context_type) || ! append_type (info, " ")) return false; } print_vma (voffset, ab, true, false); if (! append_type (info, "voffset ") || ! append_type (info, ab)) return false; } return (append_type (info, " */;\n") && indent_type (info)); }

static boolean pr_class_start_method (  PTR  p, const char *  name )  [static]

Definition at line 1472 of file pstack.c. References assert, info, pr_stack::method, NULL, and pr_handle::stack. { struct pr_handle *info = (struct pr_handle *) p; assert (info->stack != NULL); info->stack->method = name; return true; }

static boolean pr_class_static_member (  PTR  p, const char *  name, const char *  physname, enum debug_visibility  visibility )  [static]

Definition at line 1341 of file pstack.c. References append_type(), indent_type(), info, NULL, pop_type(), pr_fix_visibility(), prepend_type(), and substitute_type(). { struct pr_handle *info = (struct pr_handle *) p; char *t; if (! substitute_type (info, name)) return false; if (! prepend_type (info, "static ") || ! append_type (info, "; /* ") || ! append_type (info, physname) || ! append_type (info, " */\n") || ! indent_type (info)) return false; t = pop_type (info); if (t == NULL) return false; if (! pr_fix_visibility (info, visibility)) return false; return append_type (info, t); }

static boolean pr_class_static_method_variant (  PTR  p, const char *  physname, enum debug_visibility  visibility, boolean  constp, boolean  volatilep )  [static]

Definition at line 1571 of file pstack.c. References append_type(), assert, indent_type(), info, pr_stack::method, pr_stack::next, NULL, pop_type(), pr_fix_visibility(), prepend_type(), pr_handle::stack, and substitute_type(). { struct pr_handle *info = (struct pr_handle *) p; char *method_type; assert (info->stack != NULL); assert (info->stack->next != NULL); assert (info->stack->next->method != NULL); /* Put the const and volatile qualifiers on the type. */ if (volatilep) { if (! append_type (info, " volatile")) return false; } if (constp) { if (! append_type (info, " const")) return false; } /* Mark it as static. */ if (! prepend_type (info, "static ")) return false; /* Stick the name of the method into its type. */ if (! substitute_type (info, info->stack->next->method)) return false; /* Get the type. */ method_type = pop_type (info); if (method_type == NULL) return false; /* Now the top of the stack is the class. */ if (! pr_fix_visibility (info, visibility)) return false; return (append_type (info, method_type) && append_type (info, " /* ") && append_type (info, physname) && append_type (info, " */;\n") && indent_type (info)); }

static boolean pr_complex_type (  PTR  p, unsigned int  size )  [static]

Definition at line 607 of file pstack.c. References info, pr_float_type(), and prepend_type(). { struct pr_handle *info = (struct pr_handle *) p; if (! pr_float_type (p, size)) return false; return prepend_type (info, "complex "); }

static boolean pr_const_type (  PTR  p  )  [static]

Definition at line 1039 of file pstack.c. References info, and substitute_type(). { struct pr_handle *info = (struct pr_handle *) p; return substitute_type (info, "const |"); }

static boolean pr_empty_type (  PTR  p  )  [static]

Definition at line 551 of file pstack.c. References info, and push_type(). { struct pr_handle *info = (struct pr_handle *) p; return push_type (info, "<undefined>"); }

static boolean pr_end_block (  PTR  p, bfd_vma  addr )  [static]

Definition at line 2061 of file pstack.c. References assert, pr_handle::block, debug_block_st::end_addr, pr_handle::f, indent(), pr_handle::indent, info, debug_block_st::parent, print_vma(), and TRACE_FPRINTF. { struct pr_handle *info = (struct pr_handle *) p; #if 0 char ab[20]; info->indent -= 2; indent (info); print_vma (addr, ab, true, true); TRACE_FPRINTF( (info->f, "} /* %s */\n", ab)); #else /* 0 */ assert(info->block!=0); info->block->end_addr = addr; info->block = info->block->parent; #endif /* !0 */ return true; }

static boolean pr_end_class_type (  PTR  p  )  [static]

Definition at line 1637 of file pstack.c. References pr_end_struct_type(). { return pr_end_struct_type (p); }

static boolean pr_end_function (  PTR  p  )  [static]

Definition at line 2087 of file pstack.c. References assert, pr_handle::block, pr_handle::function, info, and NULL. { struct pr_handle *info = (struct pr_handle *) p; assert(info->block==0); info->function = NULL; return true; }

static boolean pr_end_struct_type (  PTR  p  )  [static]

Definition at line 1224 of file pstack.c. References assert, pr_handle::indent, info, NULL, pr_handle::stack, and pr_stack::type. Referenced by pr_end_class_type(). { struct pr_handle *info = (struct pr_handle *) p; char *s; assert (info->stack != NULL); assert (info->indent >= 2); info->indent -= 2; /* Change the trailing indentation to have a close brace. */ s = info->stack->type + strlen (info->stack->type) - 2; assert (s[0] == ' ' && s[1] == ' ' && s[2] == '\0'); *s++ = '}'; *s = '\0'; return true; }

static boolean pr_enum_type (  PTR  p, const char *  tag, const char **  names, bfd_signed_vma *  values )  [static]

Definition at line 637 of file pstack.c. References append_type(), info, NULL, print_vma(), push_type(), and val. { struct pr_handle *info = (struct pr_handle *) p; unsigned int i; bfd_signed_vma val; if (! push_type (info, "enum ")) return false; if (tag != NULL) { if (! append_type (info, tag) || ! append_type (info, " ")) return false; } if (! append_type (info, "{ ")) return false; if (names == NULL) { if (! append_type (info, "/* undefined */")) return false; } else { val = 0; for (i = 0; names[i] != NULL; i++) { if (i > 0) { if (! append_type (info, ", ")) return false; } if (! append_type (info, names[i])) return false; if (values[i] != val) { char ab[20]; print_vma (values[i], ab, false, false); if (! append_type (info, " = ") || ! append_type (info, ab)) return false; val = values[i]; } ++val; } } return append_type (info, " }"); }

static boolean pr_fix_visibility (  struct pr_handle *  info, enum debug_visibility  visibility )  [static]

Definition at line 1123 of file pstack.c. References abort(), append_type(), assert, DEBUG_VISIBILITY_IGNORE, DEBUG_VISIBILITY_PRIVATE, DEBUG_VISIBILITY_PROTECTED, DEBUG_VISIBILITY_PUBLIC, indent_type(), len, and NULL. Referenced by pr_class_method_variant(), pr_class_static_member(), pr_class_static_method_variant(), and pr_struct_field(). { const char *s; char *t; unsigned int len; assert (info->stack != NULL); if (info->stack->visibility == visibility) return true; assert (info->stack->visibility != DEBUG_VISIBILITY_IGNORE); switch (visibility) { case DEBUG_VISIBILITY_PUBLIC: s = "public"; break; case DEBUG_VISIBILITY_PRIVATE: s = "private"; break; case DEBUG_VISIBILITY_PROTECTED: s = "protected"; break; case DEBUG_VISIBILITY_IGNORE: s = "/* ignore */"; break; default: abort (); return false; } /* Trim off a trailing space in the struct string, to make the output look a bit better, then stick on the visibility string. */ t = info->stack->type; len = strlen (t); assert (t[len - 1] == ' '); t[len - 1] = '\0'; if (! append_type (info, s) || ! append_type (info, ":\n") || ! indent_type (info)) return false; info->stack->visibility = visibility; return true; }

static boolean pr_float_constant (  PTR  p, const char *  name, double  val )  [static]

Definition at line 1782 of file pstack.c. { /* struct pr_handle *info = (struct pr_handle *) p; indent (info); TRACE_FPRINTF( (info->f, "const double %s = %g;\n", name, val)); */ return true; }

static boolean pr_float_type (  PTR  p, unsigned int  size )  [static]

Definition at line 588 of file pstack.c. References info, and push_type(). Referenced by pr_complex_type(). { struct pr_handle *info = (struct pr_handle *) p; char ab[10]; if (size == 4) return push_type (info, "float"); else if (size == 8) return push_type (info, "double"); sprintf (ab, "float%d", size * 8); return push_type (info, ab); }

static boolean pr_function_parameter (  PTR  p, const char *  name, enum debug_parm_kind  kind, bfd_vma  val )  [static]

Definition at line 1922 of file pstack.c. References debug_function_t::argc, debug_function_t::argv, assert, DEBUG_PARM_REF_REG, DEBUG_PARM_REFERENCE, DEBUG_PARM_REG, f(), free, pr_handle::function, info, debug_function_t::max_argc, debug_parameter_t::name, NULL, debug_parameter_t::offset, pop_type(), pr_reference_type(), print_vma(), realloc, substitute_type(), TRACE_FPRINTF, and xmalloc(). { struct pr_handle *info = (struct pr_handle *) p; debug_function_t* f = info->function; char *t; char ab[20]; (void)ab; if (kind == DEBUG_PARM_REFERENCE || kind == DEBUG_PARM_REF_REG) { if (! pr_reference_type (p)) return false; } if (! substitute_type (info, name)) return false; t = pop_type (info); if (t == NULL) return false; #if 0 if (info->parameter != 1) TRACE_FPRINTF( (info->f, ", ")); if (kind == DEBUG_PARM_REG || kind == DEBUG_PARM_REF_REG) TRACE_FPRINTF( (info->f, "register ")); print_vma (val, ab, true, true); TRACE_FPRINTF( (info->f, "%s /* %s */", t, ab)); free (t); ++info->parameter; #else /* 0 */ assert(f!=NULL); if (f->argv==NULL) { f->max_argc = 7; /* rarely anyone has more than that many args... */ f->argv = xmalloc(sizeof(debug_parameter_t)*f->max_argc); } else if (f->argc==f->max_argc) { f->max_argc *= 2; f->argv = realloc(f->argv,sizeof(debug_parameter_t)*f->max_argc); } f->argv[f->argc].offset = val; f->argv[f->argc].name = t; ++f->argc; #endif /* !0 */ return true; }

static boolean pr_function_type (  PTR  p, int  argcount, boolean  varargs )  [static]

Definition at line 715 of file pstack.c. References assert, free, info, len, NULL, pop_type(), pr_handle::stack, substitute_type(), and xmalloc(). { struct pr_handle *info = (struct pr_handle *) p; char **arg_types; unsigned int len; char *s; assert (info->stack != NULL); len = 10; if (argcount <= 0) { arg_types = NULL; len += 15; } else { int i; arg_types = (char **) xmalloc (argcount * sizeof *arg_types); for (i = argcount - 1; i >= 0; i--) { if (! substitute_type (info, "")) return false; arg_types[i] = pop_type (info); if (arg_types[i] == NULL) return false; len += strlen (arg_types[i]) + 2; } if (varargs) len += 5; } /* Now the return type is on the top of the stack. */ s = (char *) xmalloc (len); strcpy (s, "(|) ("); if (argcount < 0) { #if 0 /* Turn off unknown arguments. */ strcat (s, "/* unknown */"); #endif } else { int i; for (i = 0; i < argcount; i++) { if (i > 0) strcat (s, ", "); strcat (s, arg_types[i]); } if (varargs) { if (i > 0) strcat (s, ", "); strcat (s, "..."); } if (argcount > 0) free (arg_types); } strcat (s, ")"); if (! substitute_type (info, s)) return false; free (s); return true; }

static boolean pr_int_constant (  PTR  p, const char *  name, bfd_vma  val )  [static]

Definition at line 1764 of file pstack.c. { /* struct pr_handle *info = (struct pr_handle *) p; char ab[20]; indent (info); print_vma (val, ab, false, false); TRACE_FPRINTF( (info->f, "const int %s = %s;\n", name, ab)); */ return true; }

static boolean pr_int_type (  PTR  p, unsigned int  size, boolean  unsignedp )  [static]

Definition at line 573 of file pstack.c. References info, and push_type(). { struct pr_handle *info = (struct pr_handle *) p; char ab[10]; sprintf (ab, "%sint%d", unsignedp ? "u" : "", size * 8); return push_type (info, ab); }

static boolean pr_lineno (  PTR  p, const char *  filename, unsigned long  lineno, bfd_vma  addr )  [static]

Definition at line 2021 of file pstack.c. References debug_lineno_t::addr, assert, pr_handle::f, f(), debug_function_t::filename, pr_handle::function, indent(), info, debug_lineno_t::lineno, debug_function_t::lines, debug_function_t::lines_count, debug_function_t::max_lines_count, NULL, print_vma(), TRACE_FPRINTF, xmalloc(), and xrealloc(). { struct pr_handle *info = (struct pr_handle *) p; char ab[20]; debug_function_t* f = info->function; (void)ab; #if 0 indent (info); print_vma (addr, ab, true, true); TRACE_FPRINTF( (info->f, "/* file %s line %lu addr %s */\n", filename, lineno, ab)); #else /* 0 */ if (f==NULL) /* FIXME: skips junk silently. */ return true; /* assert(f!=NULL); */ if (f->filename==NULL) { f->filename = filename; assert(f->lines==0); f->max_lines_count = 4; f->lines = xmalloc(sizeof(debug_lineno_t)*f->max_lines_count); } if (f->lines_count==f->max_lines_count) { f->max_lines_count *= 2; f->lines = xrealloc(f->lines, sizeof(debug_lineno_t)*f->max_lines_count); } f->lines[f->lines_count].lineno = lineno; f->lines[f->lines_count].addr = addr; ++f->lines_count; #endif /* !0 */ return true; }

static boolean pr_method_type (  PTR  p, boolean  domain, int  argcount, boolean  varargs )  [static]

Definition at line 938 of file pstack.c. References free, info, len, NULL, pop_type(), strchr(), substitute_type(), and xmalloc(). { struct pr_handle *info = (struct pr_handle *) p; unsigned int len; char *domain_type; char **arg_types; char *s; len = 10; if (! domain) domain_type = NULL; else { if (! substitute_type (info, "")) return false; domain_type = pop_type (info); if (domain_type == NULL) return false; if (strncmp (domain_type, "class ", sizeof "class " - 1) == 0 && strchr (domain_type + sizeof "class " - 1, ' ') == NULL) domain_type += sizeof "class " - 1; else if (strncmp (domain_type, "union class ", sizeof "union class ") == 0 && (strchr (domain_type + sizeof "union class " - 1, ' ') == NULL)) domain_type += sizeof "union class " - 1; len += strlen (domain_type); } if (argcount <= 0) { arg_types = NULL; len += 15; } else { int i; arg_types = (char **) xmalloc (argcount * sizeof *arg_types); for (i = argcount - 1; i >= 0; i--) { if (! substitute_type (info, "")) return false; arg_types[i] = pop_type (info); if (arg_types[i] == NULL) return false; len += strlen (arg_types[i]) + 2; } if (varargs) len += 5; } /* Now the return type is on the top of the stack. */ s = (char *) xmalloc (len); if (! domain) *s = '\0'; else strcpy (s, domain_type); strcat (s, "::| ("); if (argcount < 0) strcat (s, "/* unknown */"); else { int i; for (i = 0; i < argcount; i++) { if (i > 0) strcat (s, ", "); strcat (s, arg_types[i]); } if (varargs) { if (i > 0) strcat (s, ", "); strcat (s, "..."); } if (argcount > 0) free (arg_types); } strcat (s, ")"); if (! substitute_type (info, s)) return false; free (s); return true; }

static boolean pr_offset_type (  PTR  p  )  [static]

Definition at line 916 of file pstack.c. References append_type(), info, NULL, pop_type(), prepend_type(), and substitute_type(). { struct pr_handle *info = (struct pr_handle *) p; char *t; if (! substitute_type (info, "")) return false; t = pop_type (info); if (t == NULL) return false; return (substitute_type (info, "") && prepend_type (info, " ") && prepend_type (info, t) && append_type (info, "::|")); }

static boolean pr_pointer_type (  PTR  p  )  [static]

Definition at line 698 of file pstack.c. References assert, info, NULL, pr_handle::stack, strchr(), substitute_type(), and pr_stack::type. { struct pr_handle *info = (struct pr_handle *) p; char *s; assert (info->stack != NULL); s = strchr (info->stack->type, '|'); if (s != NULL && s[1] == '[') return substitute_type (info, "(*|)"); return substitute_type (info, "*|"); }

static boolean pr_range_type (  PTR  p, bfd_signed_vma  lower, bfd_signed_vma  upper )  [static]

Definition at line 810 of file pstack.c. References append_type(), assert, info, NULL, prepend_type(), print_vma(), pr_handle::stack, and substitute_type(). { struct pr_handle *info = (struct pr_handle *) p; char abl[20], abu[20]; assert (info->stack != NULL); if (! substitute_type (info, "")) return false; print_vma (lower, abl, false, false); print_vma (upper, abu, false, false); return (prepend_type (info, "range (") && append_type (info, "):") && append_type (info, abl) && append_type (info, ":") && append_type (info, abu)); }

static boolean pr_reference_type (  PTR  p  )  [static]

Definition at line 797 of file pstack.c. References assert, info, NULL, pr_handle::stack, and substitute_type(). Referenced by pr_function_parameter(). { struct pr_handle *info = (struct pr_handle *) p; assert (info->stack != NULL); return substitute_type (info, "&|"); }

static boolean pr_set_type (  PTR  p, boolean  bitstringp )  [static]

Definition at line 891 of file pstack.c. References append_type(), info, prepend_type(), and substitute_type(). { struct pr_handle *info = (struct pr_handle *) p; if (! substitute_type (info, "")) return false; if (! prepend_type (info, "set { ") || ! append_type (info, " }")) return false; if (bitstringp) { if (! append_type (info, "/* bitstring */")) return false; } return true; }

static boolean pr_start_block (  PTR  p, bfd_vma  addr )  [static]

Definition at line 1978 of file pstack.c. References debug_block_st::begin_addr, debug_function_t::block, pr_handle::block, yaSSL::block, debug_block_st::childs, debug_block_st::childs_count, debug_block_st::end_addr, pr_handle::f, pr_handle::function, pr_handle::indent, indent(), info, NULL, pr_handle::parameter, debug_block_st::parent, print_vma(), TRACE_FPRINTF, xmalloc(), and xrealloc(). { struct pr_handle *info = (struct pr_handle *) p; char ab[20]; debug_block_t* block = 0; (void)ab; #if 0 if (info->parameter > 0) { TRACE_FPRINTF( (info->f, ")\n")); info->parameter = 0; } indent (info); print_vma (addr, ab, true, true); TRACE_FPRINTF( (info->f, "{ /* %s */\n", ab)); info->indent += 2; #else if (info->block) { if (info->block->childs_count==0) info->block->childs = xmalloc(sizeof(debug_block_t)); else info->block->childs = xrealloc(info->block->childs, info->block->childs_count*sizeof(debug_block_t)); block = &info->block->childs[info->block->childs_count]; } else { block = xmalloc(sizeof(debug_block_t)); info->function->block = block; } block->begin_addr = addr; block->end_addr = 0; block->parent = info->block; block->childs = NULL; block->childs_count = 0; info->block = block; #endif return true; }

static boolean pr_start_class_type (  PTR  p, const char *  tag, unsigned int  id, boolean  structp, unsigned int  size, boolean  vptr, boolean  ownvptr )  [static]

Definition at line 1248 of file pstack.c. References append_type(), DEBUG_VISIBILITY_PRIVATE, pr_handle::indent, indent_type(), info, NULL, pop_type(), and push_type(). { struct pr_handle *info = (struct pr_handle *) p; char *tv = NULL; info->indent += 2; if (vptr && ! ownvptr) { tv = pop_type (info); if (tv == NULL) return false; } if (! push_type (info, structp ? "class " : "union class ")) return false; if (tag != NULL) { if (! append_type (info, tag)) return false; } else { char idbuf[20]; sprintf (idbuf, "%%anon%u", id); if (! append_type (info, idbuf)) return false; } if (! append_type (info, " {")) return false; if (size != 0 || vptr || ownvptr || tag != NULL) { if (! append_type (info, " /*")) return false; if (size != 0) { char ab[20]; sprintf (ab, "%u", size); if (! append_type (info, " size ") || ! append_type (info, ab)) return false; } if (vptr) { if (! append_type (info, " vtable ")) return false; if (ownvptr) { if (! append_type (info, "self ")) return false; } else { if (! append_type (info, tv) || ! append_type (info, " ")) return false; } } if (tag != NULL) { char ab[30]; sprintf (ab, " id %u", id); if (! append_type (info, ab)) return false; } if (! append_type (info, " */")) return false; } info->stack->visibility = DEBUG_VISIBILITY_PRIVATE; return (append_type (info, "\n") && indent_type (info)); }

static boolean pr_start_compilation_unit (  PTR  p, const char *  filename )  [static]

Definition at line 519 of file pstack.c. References assert, pr_handle::indent, and info. { struct pr_handle *info = (struct pr_handle *) p; assert (info->indent == 0); /* TRACE_FPRINTF( (info->f, "%s:\n", filename)); */ return true; }

static boolean pr_start_function (  PTR  p, const char *  name, boolean  global )  [static]

Definition at line 1874 of file pstack.c. References assert, indent(), info, NULL, pop_type(), substitute_type(), TRACE_FPRINTF, and xrealloc(). { struct pr_handle *info = (struct pr_handle *) p; char *t; if (! substitute_type (info, name)) return false; t = pop_type (info); if (t == NULL) return false; #if 0 indent (info); if (! global) TRACE_FPRINTF( (info->f, "static ")); TRACE_FPRINTF( (info->f, "%s (", t)); info->parameter = 1; #else /* 0 */ if (info->functions_size==info->functions_maxsize) { info->functions_maxsize *= 2; info->functions = xrealloc(info->functions, info->functions_maxsize*sizeof(debug_function_t)); assert(info->functions!=0); } /* info->functions[info->functions_size] = xmalloc(sizeof(debug_function_t)); */ info->function = &info->functions[info->functions_size]; ++info->functions_size; info->function->symbol = NULL; info->function->lines = NULL; info->function->lines_count = 0; info->function->max_lines_count = 0; info->function->name = t; info->function->filename = NULL; info->function->block = NULL; info->function->argv = NULL; info->function->argc = 0; info->function->max_argc = 0; #endif /* !0 */ return true; }

static boolean pr_start_source (  PTR  p, const char *  filename )  [static]

Definition at line 535 of file pstack.c. References assert, pr_handle::indent, and info. { struct pr_handle *info = (struct pr_handle *) p; assert (info->indent == 0); /* TRACE_FPRINTF( (info->f, " %s:\n", filename)); */ return true; }

static boolean pr_start_struct_type (  PTR  p, const char *  tag, unsigned int  id, boolean  structp, unsigned int  size )  [static]

Definition at line 1061 of file pstack.c. References append_type(), DEBUG_VISIBILITY_PUBLIC, pr_handle::indent, indent_type(), info, NULL, and push_type(). { struct pr_handle *info = (struct pr_handle *) p; info->indent += 2; if (! push_type (info, structp ? "struct " : "union ")) return false; if (tag != NULL) { if (! append_type (info, tag)) return false; } else { char idbuf[20]; sprintf (idbuf, "%%anon%u", id); if (! append_type (info, idbuf)) return false; } if (! append_type (info, " {")) return false; if (size != 0 || tag != NULL) { char ab[30]; if (! append_type (info, " /*")) return false; if (size != 0) { sprintf (ab, " size %u", size); if (! append_type (info, ab)) return false; } if (tag != NULL) { sprintf (ab, " id %u", id); if (! append_type (info, ab)) return false; } if (! append_type (info, " */")) return false; } if (! append_type (info, "\n")) return false; info->stack->visibility = DEBUG_VISIBILITY_PUBLIC; return indent_type (info); }

static boolean pr_struct_field (  PTR  p, const char *  name, bfd_vma  bitpos, bfd_vma  bitsize, enum debug_visibility  visibility )  [static]

Definition at line 1178 of file pstack.c. References append_type(), indent_type(), info, NULL, pop_type(), pr_fix_visibility(), print_vma(), and substitute_type(). { struct pr_handle *info = (struct pr_handle *) p; char ab[20]; char *t; if (! substitute_type (info, name)) return false; if (! append_type (info, "; /* ")) return false; if (bitsize != 0) { print_vma (bitsize, ab, true, false); if (! append_type (info, "bitsize ") || ! append_type (info, ab) || ! append_type (info, ", ")) return false; } print_vma (bitpos, ab, true, false); if (! append_type (info, "bitpos ") || ! append_type (info, ab) || ! append_type (info, " */\n") || ! indent_type (info)) return false; t = pop_type (info); if (t == NULL) return false; if (! pr_fix_visibility (info, visibility)) return false; return append_type (info, t); }

static boolean pr_tag (  PTR  p, const char *  name )  [static]

Definition at line 1742 of file pstack.c. References free, info, NULL, and pop_type(). { struct pr_handle *info = (struct pr_handle *) p; char *t; t = pop_type (info); if (t == NULL) return false; /* indent (info); TRACE_FPRINTF( (info->f, "%s;\n", t)); */ free (t); return true; }

static boolean pr_tag_type (  PTR  p, const char *  name, unsigned int  id, enum debug_type_kind  kind )  [static]

Definition at line 1658 of file pstack.c. References abort(), append_type(), DEBUG_KIND_CLASS, DEBUG_KIND_ENUM, DEBUG_KIND_STRUCT, DEBUG_KIND_UNION, DEBUG_KIND_UNION_CLASS, info, NULL, and push_type(). { struct pr_handle *info = (struct pr_handle *) p; const char *t, *tag; char idbuf[30]; switch (kind) { case DEBUG_KIND_STRUCT: t = "struct "; break; case DEBUG_KIND_UNION: t = "union "; break; case DEBUG_KIND_ENUM: t = "enum "; break; case DEBUG_KIND_CLASS: t = "class "; break; case DEBUG_KIND_UNION_CLASS: t = "union class "; break; default: abort (); return false; } if (! push_type (info, t)) return false; if (name != NULL) tag = name; else { sprintf (idbuf, "%%anon%u", id); tag = idbuf; } if (! append_type (info, tag)) return false; if (name != NULL && kind != DEBUG_KIND_ENUM) { sprintf (idbuf, " /* id %u */", id); if (! append_type (info, idbuf)) return false; } return true; }

static boolean pr_typdef (  PTR  p, const char *  name )  [static]

Definition at line 1715 of file pstack.c. References free, info, NULL, pop_type(), and substitute_type(). { struct pr_handle *info = (struct pr_handle *) p; char *s; if (! substitute_type (info, name)) return false; s = pop_type (info); if (s == NULL) return false; /* indent (info); TRACE_FPRINTF( (info->f, "typedef %s;\n", s)); */ free (s); return true; }

static boolean pr_typed_constant (  PTR  p, const char *  name, bfd_vma  val )  [static]

Definition at line 1798 of file pstack.c. References free, info, NULL, and pop_type(). { struct pr_handle *info = (struct pr_handle *) p; char *t; t = pop_type (info); if (t == NULL) return false; /* char ab[20]; indent (info); print_vma (val, ab, false, false); TRACE_FPRINTF( (info->f, "const %s %s = %s;\n", t, name, ab)); */ free (t); return true; }

static boolean pr_typedef_type (  PTR  p, const char *  name )  [static]

Definition at line 1646 of file pstack.c. References info, and push_type(). { struct pr_handle *info = (struct pr_handle *) p; return push_type (info, name); }

static boolean pr_variable (  PTR  p, const char *  name, enum debug_var_kind  kind, bfd_vma  val )  [static]

Definition at line 1823 of file pstack.c. References DEBUG_LOCAL_STATIC, DEBUG_REGISTER, DEBUG_STATIC, free, indent(), info, NULL, pop_type(), print_vma(), substitute_type(), and TRACE_FPRINTF. { struct pr_handle *info = (struct pr_handle *) p; char *t; char ab[20]; (void)ab; if (! substitute_type (info, name)) return false; t = pop_type (info); if (t == NULL) return false; #if 0 indent (info); switch (kind) { case DEBUG_STATIC: case DEBUG_LOCAL_STATIC: TRACE_FPRINTF( (info->f, "static ")); break; case DEBUG_REGISTER: TRACE_FPRINTF( (info->f, "register ")); break; default: break; } print_vma (val, ab, true, true); TRACE_FPRINTF( (info->f, "%s /* %s */;\n", t, ab)); #else /* 0 */ #if 0 if (kind==DEBUG_STATIC || kind==DEBUG_LOCAL_STATIC) { print_vma (val, ab, true, true); TRACE_FPRINTF( (info->f, "STATIC_VAR: %s /* %s */;\n", t, ab)); } #endif /* 0 */ #endif /* !0 */ free (t); return true; }

static boolean pr_void_type (  PTR  p  )  [static]

Definition at line 562 of file pstack.c. References info, and push_type(). { struct pr_handle *info = (struct pr_handle *) p; return push_type (info, "void"); }

static boolean pr_volatile_type (  PTR  p  )  [static]

Definition at line 1050 of file pstack.c. References info, and substitute_type(). { struct pr_handle *info = (struct pr_handle *) p; return substitute_type (info, "volatile |"); }

static boolean prepend_type (  struct pr_handle *  info, const char *  s )  [static]

Definition at line 370 of file pstack.c. References assert, free, n, NULL, and xmalloc(). Referenced by pr_class_baseclass(), pr_class_static_member(), pr_class_static_method_variant(), pr_complex_type(), pr_offset_type(), pr_range_type(), pr_set_type(), and substitute_type(). { char *n; assert (info->stack != NULL); n = (char *) xmalloc (strlen (s) + strlen (info->stack->type) + 1); sprintf (n, "%s%s", s, info->stack->type); free (info->stack->type); info->stack->type = n; return true; }

static void print_vma (  bfd_vma  vma, char *  buf, boolean  unsignedp, boolean  hexp )  [static]

Definition at line 493 of file pstack.c. Referenced by pr_array_type(), pr_class_baseclass(), pr_class_method_variant(), pr_end_block(), pr_enum_type(), pr_function_parameter(), pr_lineno(), pr_range_type(), pr_start_block(), pr_struct_field(), and pr_variable(). { if (sizeof (vma) <= sizeof (unsigned long)) { if (hexp) sprintf (buf, "0x%lx", (unsigned long) vma); else if (unsignedp) sprintf (buf, "%lu", (unsigned long) vma); else sprintf (buf, "%ld", (long) vma); } else { buf[0] = '0'; buf[1] = 'x'; sprintf_vma (buf + 2, vma); } }

int pstack_install_segv_action (  const char *  path_format_  )

Definition at line 2630 of file pstack.c. References assert, pr_handle::block, compare_debug_function_t(), compare_symbols(), debug_write(), pr_handle::f, pr_handle::function, pr_handle::functions, pr_handle::functions_maxsize, pr_handle::functions_size, pr_handle::indent, list_supported_targets(), load_bfd(), memcpy, name, NULL, pr_handle::parameter, path_format, perror(), program_name, qsort(), read_debugging_info(), remove_useless_symbols(), report_action(), segv_action(), set_default_bfd_target(), sigemptyset, pr_handle::stack, TRACE_FPRINTF, value, and xmalloc(). Referenced by signal_hand(). { const int pid = getpid(); struct sigaction act; /* Store what we have to for later usage. */ path_format = path_format_; /* We need a signal action for SIGSEGV and sigreport ! */ sigreport = SIGUSR1; act.sa_handler = 0; sigemptyset(&act.sa_mask); act.sa_flags = SA_SIGINFO|SA_ONESHOT; /* Just one SIGSEGV. */ act.sa_sigaction = segv_action; act.sa_restorer = NULL; if (sigaction(SIGSEGV, &act, NULL)!=0) { perror("sigaction"); return 1; } act.sa_sigaction = report_action; act.sa_flags = SA_SIGINFO; /* But many sigreports. */ if (sigaction(sigreport, &act, NULL)!=0) { perror("sigaction"); return 1; } /* And a little setup for libiberty. */ program_name = "crashing"; xmalloc_set_program_name (program_name); /* Umm, and initialize BFD, too */ bfd_init(); #if 0 list_supported_targets(0, stdout); set_default_bfd_target(); #endif /* 0 */ if ((abfd = load_bfd(pid))==0) fprintf(stderr, "BFD load failed..\n"); else { long storage_needed= (bfd_get_file_flags(abfd) & HAS_SYMS) ? bfd_get_symtab_upper_bound (abfd) : 0; long i; (void)i; if (storage_needed < 0) fprintf(stderr, "Symbol table size estimation failure.\n"); else if (storage_needed > 0) { syms = (asymbol **) xmalloc (storage_needed); symcount = bfd_canonicalize_symtab (abfd, syms); TRACE_FPRINTF((stderr, "TOTAL: %ld SYMBOLS.\n", symcount)); /* We need debugging info, too! */ if (symcount==0 || (dhandle = read_debugging_info (abfd, syms, symcount))==0) fprintf(stderr, "NO DEBUGGING INFORMATION FOUND.\n"); /* We make a copy of syms to sort. We don't want to sort syms because that will screw up the relocs. */ sorted_syms = (asymbol **) xmalloc (symcount * sizeof (asymbol *)); memcpy (sorted_syms, syms, symcount * sizeof (asymbol *)); #if 0 for (i=0; i<symcount; ++i) if (syms[i]->name!=0 && strlen(syms[i]->name)>0 && syms[i]->value!=0) printf("%08lx T %s\n", syms[i]->section->vma + syms[i]->value, syms[i]->name); #endif sorted_symcount = remove_useless_symbols (sorted_syms, symcount); TRACE_FPRINTF((stderr, "SORTED: %ld SYMBOLS.\n", sorted_symcount)); /* Sort the symbols into section and symbol order */ qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols); #if 0 for (i=0; i<sorted_symcount; ++i) if (sorted_syms[i]->name!=0 && strlen(sorted_syms[i]->name)>0 && sorted_syms[i]->value!=0) printf("%08lx T %s\n", sorted_syms[i]->section->vma + sorted_syms[i]->value, sorted_syms[i]->name); #endif /* We have symbols, we need debugging info somehow sorted out. */ if (dhandle==0) { fprintf(stderr, "STACK TRACE WILL BE UNCOMFORTABLE.\n"); } else { /* Start collecting the debugging information.... */ struct pr_handle info; info.f = stdout; info.indent = 0; info.stack = NULL; info.parameter = 0; info.block = NULL; info.function = NULL; info.functions_size = 0; info.functions_maxsize = 1000; info.functions = (debug_function_t*)xmalloc(sizeof(debug_function_t)*info.functions_maxsize); debug_write (dhandle, &pr_fns, (PTR) &info); TRACE_FPRINTF((stdout, "\n%d DEBUG SYMBOLS\n", info.functions_size)); assert(info.functions_size!=0); functions = xmalloc(sizeof(debug_function_t*)*info.functions_size); functions_size = info.functions_size; for (i=0; i<functions_size; ++i) functions[i] = &info.functions[i]; /* Sort the symbols into section and symbol order */ qsort (functions, functions_size, sizeof(debug_function_t*), compare_debug_function_t); #if 0 for (i=0; i<info.functions_size; ++i) fprintf(stdout, "%08lx T %s\n", info.functions[i].block->begin_addr, info.functions[i].name); #endif fflush(stdout); } } else /* storage_needed == 0 */ fprintf(stderr, "NO SYMBOLS FOUND.\n"); } return 0; }

static boolean push_type (  struct pr_handle *  info, const char *  type )  [static]

Definition at line 346 of file pstack.c. References DEBUG_VISIBILITY_IGNORE, memset, n, NULL, and xmalloc(). Referenced by pr_bool_type(), pr_class_baseclass(), pr_empty_type(), pr_enum_type(), pr_float_type(), pr_int_type(), pr_start_class_type(), pr_start_struct_type(), pr_tag_type(), pr_typedef_type(), and pr_void_type(). { struct pr_stack *n; if (type == NULL) return false; n = (struct pr_stack *) xmalloc (sizeof *n); memset (n, 0, sizeof *n); n->type = xstrdup (type); n->visibility = DEBUG_VISIBILITY_IGNORE; n->method = NULL; n->next = info->stack; info->stack = n; return true; }

static long remove_useless_symbols (  asymbol **  symbols, long  count )  [static]

Definition at line 2516 of file pstack.c. References NULL. Referenced by pstack_install_segv_action(). { asymbol** in_ptr = symbols; asymbol** out_ptr = symbols; while (--count >= 0) { asymbol *sym = *in_ptr++; if (sym->name == NULL || sym->name[0] == '\0' || sym->value==0) continue; if (sym->flags & (BSF_DEBUGGING)) continue; if (bfd_is_und_section (sym->section) || bfd_is_com_section (sym->section)) continue; *out_ptr++ = sym; } return out_ptr - symbols; }

static void report_action (  int  signo, siginfo_t *  siginfo, void *  ptr )  [static]

Definition at line 2589 of file pstack.c. References assert, close(), fdprintf(), symbol_data_t::functions, symbol_data_t::functions_size, my_crawl(), open_log_file(), show_regs(), symbol_data_t::symcount, and symbol_data_t::syms. Referenced by pstack_install_segv_action(). { const int pid = getpid(); pthread_t tid = pthread_self(); symbol_data_t symbol_data; int fd; if (pthread_equal(tid, segv_tid)) { /* We have already printed our stack trace... */ return; } fd = open_log_file(tid, pid); fdprintf(fd, "REPORT: CURRENT PROCESS:%d, THREAD:%d\n", getpid(), pthread_self()); /* signal(SIGSEGV, SIG_DFL); */ ptrace_regs = (signal_regs_t*)ptr; assert(ptrace_regs!=0); /* Show user how guilty we are. */ fdprintf(fd,"--------- STACK TRACE FOR PROCESS %d, THREAD %d ---------------\n", pid, pthread_self()); show_regs(ptrace_regs, fd); /* Some form of stack trace, too. */ fdprintf(fd, "STACK TRACE:\n"); symbol_data.syms = sorted_syms; symbol_data.symcount = sorted_symcount; symbol_data.functions = functions; symbol_data.functions_size = functions_size; my_crawl(pid, &symbol_data, fd); //fflush(stdout); close(fd); /* Tell segv_thread to proceed after pause(). */ /*pthread_kill(segv_tid, sigreport); kill(segv_pid, sigreport); pthread_cancel(tid); */ }

static void segv_action (  int  signo, siginfo_t *  siginfo, void *  ptr )  [static]

Definition at line 2558 of file pstack.c. References assert, close(), fdprintf(), symbol_data_t::functions, symbol_data_t::functions_size, linuxthreads_notify_others(), my_crawl(), open_log_file(), show_regs(), symbol_data_t::symcount, and symbol_data_t::syms. Referenced by pstack_install_segv_action(). { symbol_data_t symbol_data; int fd = -1; segv_pid = getpid(); segv_tid = pthread_self(); fd = open_log_file(segv_tid, segv_pid); /* signal(SIGSEGV, SIG_DFL); */ ptrace_regs = (signal_regs_t*)ptr; assert(ptrace_regs!=0); /* Show user how guilty we are. */ fdprintf(fd,"--------- SEGV in PROCESS %d, THREAD %d ---------------\n", segv_pid, pthread_self()); show_regs(ptrace_regs, fd); /* Some form of stack trace, too. */ fdprintf(fd, "STACK TRACE:\n"); symbol_data.syms = sorted_syms; symbol_data.symcount = sorted_symcount; symbol_data.functions = functions; symbol_data.functions_size = functions_size; my_crawl(segv_pid, &symbol_data, fd); //fflush(stdout); close(fd); linuxthreads_notify_others(sigreport); }

static void show_regs (  signal_regs_t *  regs, int  fd )  [static]

Definition at line 2406 of file pstack.c. References signal_regs_t::eax, signal_regs_t::ebp, signal_regs_t::ebx, signal_regs_t::ecx, signal_regs_t::edi, signal_regs_t::edx, signal_regs_t::eip, signal_regs_t::esi, signal_regs_t::esp, signal_regs_t::fault_addr, fdprintf(), signal_regs_t::xcs, signal_regs_t::xds, signal_regs_t::xes, and signal_regs_t::xss. Referenced by report_action(), and segv_action(). { /* long cr0 = 0L, cr2 = 0L, cr3 = 0L; */ fdprintf(fd,"\n"); fdprintf(fd,"FAULT ADDR: %08x\n", regs->fault_addr); fdprintf(fd,"EIP: %04x:[<%08x>]",0xffff & regs->xcs,regs->eip); if (regs->xcs & 3) fdprintf(fd," ESP: %04x:%08x",0xffff & regs->xss,regs->esp); /*fdprintf(fd," EFLAGS: %08lx\n",regs->eflags); */ fdprintf(fd, "\n"); fdprintf(fd,"EAX: %08x EBX: %08x ECX: %08x EDX: %08x\n", regs->eax,regs->ebx,regs->ecx,regs->edx); fdprintf(fd,"ESI: %08x EDI: %08x EBP: %08x", regs->esi, regs->edi, regs->ebp); fdprintf(fd," DS: %04x ES: %04x\n", 0xffff & regs->xds,0xffff & regs->xes); /* __asm__("movl %%cr0, %0": "=r" (cr0)); __asm__("movl %%cr2, %0": "=r" (cr2)); __asm__("movl %%cr3, %0": "=r" (cr3)); fprintf(stderr,"CR0: %08lx CR2: %08lx CR3: %08lx\n", cr0, cr2, cr3); */ }

static boolean substitute_type (  struct pr_handle *  info, const char *  s )  [static]

Definition at line 413 of file pstack.c. References append_type(), assert, free, memcpy, n, NULL, prepend_type(), strchr(), and xmalloc(). Referenced by pr_array_type(), pr_class_baseclass(), pr_class_method_variant(), pr_class_static_member(), pr_class_static_method_variant(), pr_const_type(), pr_function_parameter(), pr_function_type(), pr_method_type(), pr_offset_type(), pr_pointer_type(), pr_range_type(), pr_reference_type(), pr_set_type(), pr_start_function(), pr_struct_field(), pr_typdef(), pr_variable(), and pr_volatile_type(). { char *u; assert (info->stack != NULL); u = strchr (info->stack->type, '|'); if (u != NULL) { char *n; n = (char *) xmalloc (strlen (info->stack->type) + strlen (s)); memcpy (n, info->stack->type, u - info->stack->type); strcpy (n + (u - info->stack->type), s); strcat (n, u + 1); free (info->stack->type); info->stack->type = n; return true; } if (strchr (s, '|') != NULL && (strchr (info->stack->type, '{') != NULL || strchr (info->stack->type, '(') != NULL)) { if (! prepend_type (info, "(") || ! append_type (info, ")")) return false; } if (*s == '\0') return true; return (append_type (info, " ") && append_type (info, s)); }

---

Variable Documentation

bfd* abfd = 0 [static]

Definition at line 2539 of file pstack.c. Referenced by ieee_finish_compilation_unit(), and load_bfd().

PTR dhandle = 0 [static]

Definition at line 2540 of file pstack.c. Referenced by ieee_builtin_type(), ieee_read_cxx_class(), ieee_read_cxx_defaults(), parse_ieee_atn(), parse_ieee_ty(), and read_debugging_info().

debug_function_t** functions = 0 [static]

Definition at line 2545 of file pstack.c. Referenced by _db_keyword_(), _db_pop_(), _db_push_(), DoTrace(), and PushState().

int functions_size = 0 [static]

Definition at line 2546 of file pstack.c.

const char* path_format = "stack-trace-on-segv-%d.txt" [static]

Definition at line 119 of file pstack.c. Referenced by open_log_file(), and pstack_install_segv_action().

const struct debug_write_fns pr_fns [static]

Definition at line 282 of file pstack.c.

signal_regs_t* ptrace_regs = 0

Definition at line 2129 of file pstack.c.

pid_t segv_pid [static]

Definition at line 2549 of file pstack.c.

pthread_t segv_tid [static]

Definition at line 2548 of file pstack.c.

int sigreport = SIGUSR1 [static]

Definition at line 2547 of file pstack.c.

long sorted_symcount = 0 [static]

Definition at line 2544 of file pstack.c.

asymbol** sorted_syms = 0 [static]

Definition at line 2543 of file pstack.c.

long symcount = 0 [static]

Definition at line 2542 of file pstack.c. Referenced by decode_symbol(), and find_debug_function_t().

asymbol** syms = 0 [static]

Definition at line 2541 of file pstack.c. Referenced by decode_symbol(), and find_debug_function_t().

---