gdb.rb 0.1.0

data/patches/gdb-eval.patch

@@ -0,0 +1,57 @@
+diff --git a/python/py-value.c b/python/py-value.c
+index 0146593..8f8c610 100644
+--- a/python/py-value.c
++++ b/python/py-value.c
+@@ -972,6 +972,27 @@ gdbpy_history (PyObject *self, PyObject *args)
+   return value_to_value_object (res_val);
+ }
+ 
++/* Returns value object for a given expression.  */
++PyObject *
++gdbpy_eval (PyObject *self, PyObject *args)
++{
++  char *arg;
++  struct value *res_val = NULL;	  /* Initialize to appease gcc warning.  */
++  volatile struct gdb_exception except;
++
++  if (! PyArg_ParseTuple (args, "s", &arg))
++    return NULL;
++
++  TRY_CATCH (except, RETURN_MASK_ALL)
++    {
++      res_val = parse_and_eval (arg);
++    }
++  GDB_PY_HANDLE_EXCEPTION (except);
++
++  return value_to_value_object (res_val);
++}
++
++
+ void
+ gdbpy_initialize_values (void)
+ {
+diff --git a/python/python-internal.h b/python/python-internal.h
+index 67a78af..fbf8247 100644
+--- a/python/python-internal.h
++++ b/python/python-internal.h
+@@ -68,6 +68,7 @@ extern PyObject *gdb_module;
+ extern PyTypeObject value_object_type;
+ 
+ PyObject *gdbpy_history (PyObject *self, PyObject *args);
++PyObject *gdbpy_eval (PyObject *self, PyObject *args);
+ PyObject *gdbpy_frame_stop_reason_string (PyObject *, PyObject *);
+ PyObject *gdbpy_selected_frame (PyObject *self, PyObject *args);
+ PyObject *gdbpy_lookup_type (PyObject *self, PyObject *args, PyObject *kw);
+diff --git a/python/python.c b/python/python.c
+index 254bd28..c96fa29 100644
+--- a/python/python.c
++++ b/python/python.c
+@@ -651,6 +651,8 @@ static PyMethodDef GdbMethods[] =
+ {
+   { "history", gdbpy_history, METH_VARARGS,
+     "Get a value from history" },
++  { "eval", gdbpy_eval, METH_VARARGS,
++    "Get a value of an expression" },
+   { "execute", execute_gdb_command, METH_VARARGS,
+     "Execute a gdb command" },
+   { "parameter", gdbpy_parameter, METH_VARARGS,

data/patches/gdb-leak.patch

@@ -0,0 +1,183 @@
+diff --git a/python/py-value.c b/python/py-value.c
+index 8f8c610..c3a6cbf 100644
+--- a/python/py-value.c
++++ b/python/py-value.c
+@@ -139,7 +139,7 @@ valpy_new (PyTypeObject *subtype, PyObject *args, PyObject *keywords)
+     }
+ 
+   value_obj->value = value;
+-  value_incref (value);
++  release_value_or_incref (value);
+   value_obj->address = NULL;
+   value_obj->type = NULL;
+   note_value (value_obj);
+@@ -263,6 +263,7 @@ valpy_cast (PyObject *self, PyObject *args)
+ {
+   PyObject *type_obj;
+   struct type *type;
++  PyObject *res_obj = NULL;
+   struct value *res_val = NULL;	  /* Initialize to appease gcc warning.  */
+   volatile struct gdb_exception except;
+ 
+@@ -301,8 +302,10 @@ valpy_getitem (PyObject *self, PyObject *key)
+ {
+   value_object *self_value = (value_object *) self;
+   char *field = NULL;
++  PyObject *res_obj = NULL;
+   struct value *res_val = NULL;
+   volatile struct gdb_exception except;
++  struct value *mark = value_mark ();
+ 
+   if (gdbpy_is_string (key))
+     {  
+@@ -340,9 +343,13 @@ valpy_getitem (PyObject *self, PyObject *key)
+     }
+ 
+   xfree (field);
+-  GDB_PY_HANDLE_EXCEPTION (except);
++  GDB_PY_HANDLE_EXCEPTION_AND_CLEANUP (except, mark);
++
++  if (res_val)
++    res_obj = value_to_value_object (res_val);
+ 
+-  return res_val ? value_to_value_object (res_val) : NULL;
++  value_free_to_mark (mark);
++  return res_obj;
+ }
+ 
+ static int
+@@ -423,8 +430,10 @@ enum valpy_opcode
+ static PyObject *
+ valpy_binop (enum valpy_opcode opcode, PyObject *self, PyObject *other)
+ {
++  PyObject *res_obj = NULL;
+   struct value *res_val = NULL;	  /* Initialize to appease gcc warning.  */
+   volatile struct gdb_exception except;
++  struct value *mark = value_mark ();
+ 
+   TRY_CATCH (except, RETURN_MASK_ALL)
+     {
+@@ -515,9 +524,13 @@ valpy_binop (enum valpy_opcode opcode, PyObject *self, PyObject *other)
+ 	  break;
+ 	}
+     }
+-  GDB_PY_HANDLE_EXCEPTION (except);
++  GDB_PY_HANDLE_EXCEPTION_AND_CLEANUP (except, mark);
++
++  if (res_val)
++    res_obj = value_to_value_object (res_val);
+ 
+-  return res_val ? value_to_value_object (res_val) : NULL;
++  value_free_to_mark (mark);
++  return res_obj;
+ }
+ 
+ static PyObject *
+@@ -680,6 +693,7 @@ valpy_richcompare (PyObject *self, PyObject *other, int op)
+   int result = 0;
+   struct value *value_other;
+   volatile struct gdb_exception except;
++  struct value *mark = value_mark ();
+ 
+   if (other == Py_None)
+     /* Comparing with None is special.  From what I can tell, in Python
+@@ -738,6 +752,7 @@ valpy_richcompare (PyObject *self, PyObject *other, int op)
+ 	  break;
+       }
+     }
++  value_free_to_mark (mark);
+   GDB_PY_HANDLE_EXCEPTION (except);
+ 
+   /* In this case, the Python exception has already been set.  */
+@@ -858,7 +873,7 @@ value_to_value_object (struct value *val)
+   if (val_obj != NULL)
+     {
+       val_obj->value = val;
+-      value_incref (val);
++      release_value_or_incref (val);
+       val_obj->address = NULL;
+       val_obj->type = NULL;
+       note_value (val_obj);
+diff --git a/python/python-internal.h b/python/python-internal.h
+index fa4a62b..bc9c8c0 100644
+--- a/python/python-internal.h
++++ b/python/python-internal.h
+@@ -103,11 +103,17 @@ extern const struct language_defn *python_language;
+ /* Use this after a TRY_EXCEPT to throw the appropriate Python
+    exception.  */
+ #define GDB_PY_HANDLE_EXCEPTION(Exception)				\
++    GDB_PY_HANDLE_EXCEPTION_AND_CLEANUP(Exception, NULL)
++
++#define GDB_PY_HANDLE_EXCEPTION_AND_CLEANUP(Exception, mark)				\
+     do {								\
+-      if (Exception.reason < 0)						\
++      if (Exception.reason < 0) {					\
++        if (mark)						\
++          value_free_to_mark (mark);						\
+ 	return PyErr_Format (Exception.reason == RETURN_QUIT		\
+ 			     ? PyExc_KeyboardInterrupt : PyExc_RuntimeError, \
+ 			     "%s", Exception.message);			\
++      }						\
+     } while (0)
+ 
+ 
+diff --git a/value.c b/value.c
+index 589e03b..59a0196 100644
+--- a/value.c
++++ b/value.c
+@@ -675,7 +675,7 @@ free_all_values (void)
+ /* Remove VAL from the chain all_values
+    so it will not be freed automatically.  */
+ 
+-void
++int
+ release_value (struct value *val)
+ {
+   struct value *v;
+@@ -683,7 +683,7 @@ release_value (struct value *val)
+   if (all_values == val)
+     {
+       all_values = val->next;
+-      return;
++      return 1;
+     }
+ 
+   for (v = all_values; v; v = v->next)
+@@ -691,9 +691,21 @@ release_value (struct value *val)
+       if (v->next == val)
+ 	{
+ 	  v->next = val->next;
+-	  break;
++	  return 1;
+ 	}
+     }
++
++  return 0;
++}
++
++/* Release VAL or increment its reference count if
++   it was released already */
++
++void
++release_value_or_incref (struct value *val)
++{
++  if (release_value (val) == 0)
++    value_incref (val);
+ }
+ 
+ /* Release all values up to mark  */
+diff --git a/value.h b/value.h
+index 51e6960..4760c4a 100644
+--- a/value.h
++++ b/value.h
+@@ -594,7 +594,9 @@ extern void value_free (struct value *val);
+ 
+ extern void free_all_values (void);
+ 
+-extern void release_value (struct value *val);
++extern int release_value (struct value *val);
++
++extern void release_value_or_incref (struct value *val);
+ 
+ extern int record_latest_value (struct value *val);
+ 

data/scripts/ruby-gdb.py

@@ -0,0 +1,404 @@
+import re
+import gdb
+
+class ZeroDict(dict):
+  def __getitem__(self, i):
+    if i not in self: self[i] = 0
+    return dict.__getitem__(self, i)
+
+class Ruby (gdb.Command):
+  def __init__ (self):
+    super (Ruby, self).__init__ ("ruby", gdb.COMMAND_NONE, gdb.COMPLETE_COMMAND, True)
+
+class RubyThreads (gdb.Command):
+  def __init__ (self):
+    super (RubyThreads, self).__init__ ("ruby threads", gdb.COMMAND_NONE)
+
+  def complete (self, text, word):
+    if text == word:
+      if word == '':
+        return ['trace', 'list']
+      elif word[0] == 't':
+        return ['trace']
+      elif word[0] == 'l':
+        return ['list']
+
+  def invoke (self, arg, from_tty):
+    if re.match('trace', arg):
+      self.trace()
+    else:
+      self.type = arg if arg == 'list' else None
+      self.show()
+
+  def trace (self):
+    self.type = 'list'
+    self.curr = None
+    self.main = gdb.eval('rb_main_thread')
+
+    self.height = gdb.parameter('height') or 26
+    self.unwind = gdb.parameter('unwindonsignal')
+    gdb.execute('set height 0')
+    gdb.execute('set unwindonsignal on')
+
+    gdb.execute('watch rb_curr_thread')
+    gdb.breakpoints()[-1].silent = True
+    num = gdb.breakpoints()[-1].number
+
+    try:
+      prev = None
+      while True:
+        gdb.execute('continue')
+        curr = gdb.eval('rb_curr_thread')
+        if curr == prev: break
+        self.print_thread(curr)
+        prev = curr
+    except KeyboardInterrupt:
+      None
+
+    gdb.execute('delete %d' % num)
+    gdb.execute('set unwindonsignal %s' % ('on' if self.unwind else 'off'))
+    gdb.execute('set height %d' % self.height)
+
+  def show (self):
+    self.main = gdb.eval('rb_main_thread')
+    self.curr = gdb.eval('rb_curr_thread')
+    self.now = gdb.eval('timeofday()')
+
+    try:
+      gdb.eval('rb_thread_start_2')
+    except RuntimeError:
+      self.is_heap_stack = False
+    else:
+      self.is_heap_stack = True
+
+    if self.main == 0:
+      print "Ruby VM is not running!"
+    else:
+      th = self.main
+      while True:
+        self.print_thread(th)
+        th = th['next']
+        if th == self.main: break
+
+      print
+
+  def print_thread (self, th):
+    if self.type != 'list': print
+    print th,
+    print 'main' if th == self.main else '    ',
+    print 'curr' if th == self.curr else '    ',
+    print "thread", " %s" % str(th['status']).ljust(16), "%s" % self.wait_state(th), "   ",
+    if th != self.curr:
+      print "% 8d bytes" % th['stk_len']
+    else:
+      print
+
+    if self.type == 'list': return
+
+    if th == self.curr:
+      frame = gdb.eval('ruby_frame')
+      node = gdb.eval('ruby_current_node')
+    else:
+      frame = th['frame']
+      node = frame['node']
+
+    self.print_stack(th, frame, node)
+
+  def wait_state (self, th):
+    mask = th['wait_for']
+    state = list()
+    if mask == 0: state.append('WAIT_NONE')
+    if mask & 1:  state.append('WAIT_FD(%d)' % th['fd'])
+    if mask & 2:  state.append('WAIT_SELECT')
+    if mask & 4:
+      delay = th['delay']
+      time = delay-self.now
+      state.append('WAIT_TIME(%5.2f)' % time)
+    if mask & 8:  state.append('WAIT_JOIN(%s)' % th['join'])
+    if mask & 16: state.append('WAIT_PID')
+    return ', '.join(state).ljust(22)
+
+  def print_stack (self, th, frame, node):
+    while True:
+      stk_pos = th['stk_pos']
+      stk_ptr = th['stk_ptr']
+      stk_len = th['stk_len']
+      addr = gdb.eval('(VALUE*)%s' % frame)
+
+      if not self.is_heap_stack and th != self.curr and stk_pos < addr and addr < (stk_pos+stk_len):
+        frame = (addr-stk_pos) + stk_ptr
+        frame = gdb.eval('(struct FRAME *)%s' % frame)
+        node = frame['node']
+
+      file = node['nd_file'].string()
+      line = gdb.eval('nd_line(%s)' % node)
+      type = gdb.eval('(enum node_type) nd_type(%s)' % node)
+
+      if frame['last_func']:
+        method = gdb.eval('rb_id2name(%s)' % frame['last_func']).string()
+      else:
+        method = '(unknown)'
+
+      print "  ",
+      print str(type).lower().center(18), "%s in %s:%d" % (method, file, line)
+
+      if frame['prev'] == 0 or frame['last_func'] == 0: break
+      frame = frame['prev']
+      node = frame['node']
+      if node == 0: break
+
+class RubyTrace (gdb.Command):
+  def __init__ (self):
+    super (RubyTrace, self).__init__ ("ruby trace", gdb.COMMAND_NONE, gdb.COMPLETE_NONE)
+
+  def setup (self):
+    commands = """
+      set $func = malloc(1)
+      p ((char*)$func)[0] = '\xc3'
+      p mprotect(($func&0xfffffffffffff000), 1, 0x7)
+      p rb_add_event_hook($func, RUBY_EVENT_C_CALL|RUBY_EVENT_CALL)
+      b *$func
+    """.split("\n")
+
+    for c in commands:
+      gdb.execute(c)
+
+    gdb.breakpoints()[-1].silent = True
+    self.func = gdb.eval('$func')
+
+    self.height = gdb.parameter('height') or 26
+    self.unwind = gdb.parameter('unwindonsignal')
+    gdb.execute('set height 0')
+    gdb.execute('set unwindonsignal on')
+
+  def teardown (self):
+    commands = """
+      finish
+      clear *$func
+      p mprotect(($func&0xfffffffffffff000), 1, 0x3)
+      p rb_remove_event_hook($func)
+      p free($func)
+      set $func = 0
+    """.split("\n")
+
+    for c in commands:
+      gdb.execute(c)
+
+    gdb.execute('set unwindonsignal %s' % ('on' if self.unwind else 'off'))
+    gdb.execute('set height %d' % self.height)
+
+  def invoke (self, arg, from_tty):
+    self.dont_repeat()
+    num = int(arg) if arg else 100
+    self.setup()
+
+    try:
+      while num > 0:
+        num -= 1
+        gdb.execute('continue')
+
+        frame = gdb.selected_frame()
+        if frame.pc() != self.func:
+          raise KeyboardInterrupt
+
+        node = gdb.eval('(NODE*) $rsi')
+        file = node['nd_file'].string()
+        line = gdb.eval('nd_line(%s)' % node)
+        method = gdb.eval('rb_id2name($rcx)')
+        method = method.string() if method > 0 else '(unknown)'
+
+        print "%s in %s:%d" % (method,file,line)
+
+      self.teardown()
+    except KeyboardInterrupt:
+      self.teardown()
+    except RuntimeError, text:
+      self.teardown()
+      if not re.search('signaled while in a function called from GDB', text):
+        raise
+
+class RubyObjects (gdb.Command):
+  def __init__ (self):
+    super (RubyObjects, self).__init__ ("ruby objects", gdb.COMMAND_NONE)
+
+  def invoke (self, arg, from_tty):
+    self.height = gdb.parameter('height') or 26
+    gdb.execute('set height 0')
+
+    if arg == 'classes':
+      self.print_classes()
+    elif arg == 'nodes':
+      self.print_nodes()
+    elif arg == 'strings':
+      self.print_strings()
+    else:
+      self.print_stats()
+
+    gdb.execute('set height %d' % self.height)
+
+  def complete (self, text, word):
+    if text == word:
+      if word == '':
+        return ['classes', 'strings', 'nodes']
+      elif word[0] == 'c':
+        return ['classes']
+      elif word[0] == 'n':
+        return ['nodes']
+      elif word[0] == 's':
+        return ['strings']
+
+  def print_nodes (self):
+    nodes = ZeroDict()
+
+    for (obj, type) in self.live_objects():
+      if type == 0x3f:
+        nodes[ (int(obj['as']['node']['flags']) >> 12) & 0xff ] += 1
+
+    for (node, num) in sorted(nodes.items(), key=lambda(k,v):(v,k)):
+      print "% 8d %s" % (num, gdb.eval('(enum node_type) (%d)' % node))
+
+  def print_classes (self):
+    classes = ZeroDict()
+
+    for (obj, type) in self.live_objects():
+      if type == 0x2:
+        classes[ int(obj['as']['basic']['klass']) ] += 1
+
+    for (klass, num) in sorted(classes.items(), key=lambda(k,v):(v,k)):
+      print "% 8d %s" % (num, gdb.eval('rb_class2name(%d)' % klass).string())
+
+  def print_strings (self):
+    strings = ZeroDict()
+    bytes = 0
+
+    for (obj, type) in self.live_objects():
+      if type == 0x7:
+        s = obj['as']['string']
+        ptr = s['ptr']
+        if ptr:
+          bytes += s['len']
+          strings[ ptr.string() ] += 1
+
+    for (s, num) in sorted(strings.items(), key=lambda(k,v):(v,k)):
+      print "% 9d" % num, repr(s)
+
+    print
+    print "% 9d" % len(strings), "unique strings"
+    print "% 9d" % bytes, "bytes"
+    print
+
+  def print_stats (self):
+    total = live = free = 0
+    types = ZeroDict()
+
+    for (obj, flags) in self.all_objects():
+      if flags:
+        live += 1
+        types[ int(flags & 0x3f) ] += 1
+      else:
+        free += 1
+
+      total += 1
+
+    print
+    print "  HEAPS    % 9d" % self.heaps_used
+    print "  SLOTS    % 9d" % total
+    print "  LIVE     % 9d (%3.2f%%)" % (live, 100.0*live/total)
+    print "  FREE     % 9d (%3.2f%%)" % (free, 100.0*free/total)
+    print
+
+    for (type, num) in sorted(types.items(), key=lambda(k,v):(v,k)):
+      print "  %s % 9d (%3.2f%%)" % (self.obj_type(type).ljust(8), num, 100.0*num/live)
+
+    print
+
+  def all_objects (self):
+    self.heaps_used = gdb.eval('heaps_used')
+
+    for i in xrange(self.heaps_used):
+      p = gdb.eval("(RVALUE*) heaps[%i].slot" % i)
+      pend = p + gdb.eval("heaps[%i].limit" % i)
+
+      while p < pend:
+        yield p, p['as']['basic']['flags']
+        p += 1
+
+  def live_objects (self):
+    for (obj, flags) in self.all_objects():
+      if flags:
+        yield obj, int(flags & 0x3f)
+
+  def obj_type (self, type):
+    return RubyObjects.TYPES.get(type, 'unknown')
+
+Ruby()
+RubyThreads()
+RubyTrace()
+RubyObjects()
+
+macros = """
+  macro define R_CAST(st)   (struct st*)
+  macro define RNODE(obj)  (R_CAST(RNode)(obj))
+  macro define FL_USHIFT    12
+  macro define CHAR_BIT 8
+  macro define NODE_LSHIFT (FL_USHIFT+8)
+  macro define NODE_LMASK  (((long)1<<(sizeof(NODE*)*CHAR_BIT-NODE_LSHIFT))-1)
+  macro define nd_line(n) ((unsigned int)(((RNODE(n))->flags>>NODE_LSHIFT)&NODE_LMASK))
+  macro define nd_type(n) ((int)(((RNODE(n))->flags>>FL_USHIFT)&0xff))
+
+  macro define T_MASK   0x3f
+  macro define BUILTIN_TYPE(x) (((struct RBasic*)(x))->flags & T_MASK)
+
+  macro define WAIT_FD (1<<0)
+  macro define WAIT_SELECT (1<<1)
+  macro define WAIT_TIME (1<<2)
+  macro define WAIT_JOIN (1<<3)
+  macro define WAIT_PID (1<<4)
+
+  macro define RUBY_EVENT_CALL     0x08
+  macro define RUBY_EVENT_C_CALL   0x20
+""".split("\n")
+
+for m in macros:
+  if len(m.strip()) > 0:
+    gdb.execute(m)
+
+types = """
+  T_NONE   0x00
+
+  T_NIL    0x01
+  T_OBJECT 0x02
+  T_CLASS  0x03
+  T_ICLASS 0x04
+  T_MODULE 0x05
+  T_FLOAT  0x06
+  T_STRING 0x07
+  T_REGEXP 0x08
+  T_ARRAY  0x09
+  T_FIXNUM 0x0a
+  T_HASH   0x0b
+  T_STRUCT 0x0c
+  T_BIGNUM 0x0d
+  T_FILE   0x0e
+
+  T_TRUE   0x20
+  T_FALSE  0x21
+  T_DATA   0x22
+  T_MATCH  0x23
+  T_SYMBOL 0x24
+
+  T_BLKTAG 0x3b
+  T_UNDEF  0x3c
+  T_VARMAP 0x3d
+  T_SCOPE  0x3e
+  T_NODE   0x3f
+""".split("\n")
+
+RubyObjects.TYPES = {}
+
+for t in types:
+  if len(t.strip()) > 0:
+    name, val = t.split()
+    gdb.execute("macro define %s %s" % (name, val))
+    RubyObjects.TYPES[int(val,16)] = name[2:].lower()
+