gdb.rb 0.1.0

data/README

@@ -0,0 +1,229 @@
+gdb7 hooks for MRI
+  (c) 2009 Aman Gupta (tmm1)
+
+=== Usage
+
+  $ ps aux | grep deploy.rb
+  13074  0.0  0.7  90164 31720 ?        R    Sep23   2:21 /usr/bin/ruby /usr/bin/god -c deploy.rb
+
+  $ sudo gdb.rb 13074
+  GNU gdb (GDB) 7.0
+  Reading symbols from /usr/bin/ruby...done.
+  Attaching to program: /usr/bin/ruby, process 13074
+  0x00007fa8b9cb3c93 in select () from /lib/libc.so.6
+
+  (gdb) ruby threads list
+  0x1589000 main      thread  THREAD_STOPPED   WAIT_JOIN(0x19ef400)           4417 bytes
+  0x19ef400           thread  THREAD_STOPPED   WAIT_TIME(57.10)               6267 bytes
+  0x19e3400           thread  THREAD_STOPPED   WAIT_FD(5)                    10405 bytes
+  0x19e0000           thread  THREAD_STOPPED   WAIT_NONE                     14237 bytes
+  0x19e0400           thread  THREAD_STOPPED   WAIT_NONE                     14237 bytes
+  0x19e0800           thread  THREAD_STOPPED   WAIT_NONE                     14237 bytes
+  0x19e0c00           thread  THREAD_STOPPED   WAIT_NONE                     14237 bytes
+  0x19de000           thread  THREAD_STOPPED   WAIT_NONE                     14237 bytes
+  0x19de400           thread  THREAD_STOPPED   WAIT_NONE                     14237 bytes
+  0x19de800           thread  THREAD_STOPPED   WAIT_NONE                     14237 bytes
+  0x19dec00           thread  THREAD_STOPPED   WAIT_NONE                     14237 bytes
+  0x19dc000           thread  THREAD_STOPPED   WAIT_NONE                     14237 bytes
+  0x19dc400           thread  THREAD_STOPPED   WAIT_NONE                     14237 bytes
+  0x19dc800           thread  THREAD_STOPPED   WAIT_NONE                     14237 bytes
+  0x19dcc00           thread  THREAD_STOPPED   WAIT_NONE                     14237 bytes
+  0x2266800           thread  THREAD_STOPPED   WAIT_NONE                     14237 bytes
+  0x1d63000      curr thread  THREAD_RUNNABLE  WAIT_NONE                 
+
+  (gdb) ruby threads
+  0x1589000 main      thread  THREAD_STOPPED   WAIT_JOIN(0x19ef400)           4417 bytes
+         node_call      join in /usr/lib/ruby/gems/1.8/gems/god-0.7.13/bin/../lib/god.rb:626
+         node_call      start in /usr/lib/ruby/gems/1.8/gems/god-0.7.13/bin/../lib/god.rb:633
+         node_call      at_exit in /usr/lib/ruby/gems/1.8/gems/god-0.7.13/bin/../lib/god.rb:666
+         node_fcall     (unknown) in /usr/lib/ruby/gems/1.8/gems/god-0.7.13/bin/../lib/god/cli/run.rb:87
+
+  0x19ef400           thread  THREAD_STOPPED   WAIT_TIME(45.25)               6267 bytes
+         node_fcall     sleep in /usr/lib/ruby/gems/1.8/gems/god-0.7.13/bin/../lib/god.rb:622
+         node_fcall     start in /usr/lib/ruby/gems/1.8/gems/god-0.7.13/bin/../lib/god.rb:621
+         node_fcall     loop in /usr/lib/ruby/gems/1.8/gems/god-0.7.13/bin/../lib/god.rb:621
+         node_call      start in /usr/lib/ruby/gems/1.8/gems/god-0.7.13/bin/../lib/god.rb:620
+         node_call      initialize in /usr/lib/ruby/gems/1.8/gems/god-0.7.13/bin/../lib/god.rb:620
+         node_call      new in /usr/lib/ruby/gems/1.8/gems/god-0.7.13/bin/../lib/god.rb:620
+         node_call      start in /usr/lib/ruby/gems/1.8/gems/god-0.7.13/bin/../lib/god.rb:633
+         node_call      at_exit in /usr/lib/ruby/gems/1.8/gems/god-0.7.13/bin/../lib/god.rb:666
+         node_fcall     (unknown) in /usr/lib/ruby/gems/1.8/gems/god-0.7.13/bin/../lib/god/cli/run.rb:87
+
+  0x19e3400           thread  THREAD_STOPPED   WAIT_FD(5)                    10405 bytes
+         node_call      accept in /usr/lib/ruby/1.8/drb/unix.rb:98
+         node_call      accept in /usr/lib/ruby/1.8/drb/drb.rb:1581
+         node_vcall     main_loop in /usr/lib/ruby/1.8/drb/drb.rb:1430
+         node_call      run in /usr/lib/ruby/1.8/drb/drb.rb:1427
+         node_call      start in /usr/lib/ruby/1.8/drb/drb.rb:1427
+         node_vcall     run in /usr/lib/ruby/1.8/drb/drb.rb:1347
+         node_call      initialize in /usr/lib/ruby/1.8/drb/drb.rb:1627
+
+  (gdb) ruby threads trace
+  -- Tracing thread context switches.
+  0x19ef400           thread  THREAD_RUNNABLE  WAIT_NONE                      6267 bytes
+  0x1d63000           thread  THREAD_RUNNABLE  WAIT_NONE                      8623 bytes
+  0x19e3400           thread  THREAD_RUNNABLE  WAIT_NONE                     10405 bytes
+  0x3001c00           thread  THREAD_RUNNABLE  WAIT_NONE                      9507 bytes
+  0x19e3400           thread  THREAD_RUNNABLE  WAIT_NONE                      9507 bytes
+  0x3001c00           thread  THREAD_RUNNABLE  WAIT_NONE                     15059 bytes
+  0x1d63000           thread  THREAD_RUNNABLE  WAIT_NONE                      8623 bytes
+  0x3001c00           thread  THREAD_RUNNABLE  WAIT_NONE                     15059 bytes
+
+  (gdb) ruby trace 25
+  -- Tracing the next 25 ruby method calls.
+  handle_events in /usr/lib/ruby/gems/1.8/gems/god-0.7.13/bin/../lib/god/event_handler.rb:66
+  watching_pid? in /usr/lib/ruby/gems/1.8/gems/god-0.7.13/bin/../lib/god/event_handler.rb:58
+  [] in /usr/lib/ruby/gems/1.8/gems/god-0.7.13/bin/../lib/god/event_handler.rb:59
+  default in /usr/lib/ruby/gems/1.8/gems/god-0.7.13/bin/../lib/god/event_handler.rb:59
+  handle_events in /usr/lib/ruby/gems/1.8/gems/god-0.7.13/bin/../lib/god/event_handler.rb:66
+  watching_pid? in /usr/lib/ruby/gems/1.8/gems/god-0.7.13/bin/../lib/god/event_handler.rb:58
+  [] in /usr/lib/ruby/gems/1.8/gems/god-0.7.13/bin/../lib/god/event_handler.rb:59
+  default in /usr/lib/ruby/gems/1.8/gems/god-0.7.13/bin/../lib/god/event_handler.rb:59
+  handle_events in /usr/lib/ruby/gems/1.8/gems/god-0.7.13/bin/../lib/god/event_handler.rb:66
+  watching_pid? in /usr/lib/ruby/gems/1.8/gems/god-0.7.13/bin/../lib/god/event_handler.rb:58
+  [] in /usr/lib/ruby/gems/1.8/gems/god-0.7.13/bin/../lib/god/event_handler.rb:59
+  default in /usr/lib/ruby/gems/1.8/gems/god-0.7.13/bin/../lib/god/event_handler.rb:59
+  handle_events in /usr/lib/ruby/gems/1.8/gems/god-0.7.13/bin/../lib/god/event_handler.rb:66
+  handle_events in /usr/lib/ruby/gems/1.8/gems/god-0.7.13/bin/../lib/god/event_handler.rb:66
+  handle_events in /usr/lib/ruby/gems/1.8/gems/god-0.7.13/bin/../lib/god/event_handler.rb:66
+  handle_events in /usr/lib/ruby/gems/1.8/gems/god-0.7.13/bin/../lib/god/event_handler.rb:66
+  handle_events in /usr/lib/ruby/gems/1.8/gems/god-0.7.13/bin/../lib/god/event_handler.rb:66
+  handle_events in /usr/lib/ruby/gems/1.8/gems/god-0.7.13/bin/../lib/god/event_handler.rb:66
+  handle_events in /usr/lib/ruby/gems/1.8/gems/god-0.7.13/bin/../lib/god/event_handler.rb:66
+  handle_events in /usr/lib/ruby/gems/1.8/gems/god-0.7.13/bin/../lib/god/event_handler.rb:66
+  handle_events in /usr/lib/ruby/gems/1.8/gems/god-0.7.13/bin/../lib/god/event_handler.rb:66
+  watching_pid? in /usr/lib/ruby/gems/1.8/gems/god-0.7.13/bin/../lib/god/event_handler.rb:58
+  [] in /usr/lib/ruby/gems/1.8/gems/god-0.7.13/bin/../lib/god/event_handler.rb:59
+  default in /usr/lib/ruby/gems/1.8/gems/god-0.7.13/bin/../lib/god/event_handler.rb:59
+  handle_events in /usr/lib/ruby/gems/1.8/gems/god-0.7.13/bin/../lib/god/event_handler.rb:66
+
+  (gdb) ruby objects
+
+    HEAPS            8
+    SLOTS      1686252
+    LIVE        893327 (52.98%)
+    FREE        792925 (47.02%)
+
+    bignum           2 (0.00%)
+    file            51 (0.01%)
+    float           77 (0.01%)
+    module         781 (0.09%)
+    varmap        1354 (0.15%)
+    scope         1641 (0.18%)
+    match         1676 (0.19%)
+    iclass        1744 (0.20%)
+    regexp        2255 (0.25%)
+    data          3539 (0.40%)
+    class         3680 (0.41%)
+    hash          6196 (0.69%)
+    object        8785 (0.98%)
+    array        13850 (1.55%)
+    string      105350 (11.79%)
+    node        742346 (83.10%)
+
+  (gdb) ruby objects classes
+         1 YAML::Syck::Resolver
+         1 YAML::Syck::Resolver
+         1 SystemStackError
+         1 Object
+         1 Object
+         1 NoMemoryError
+         1 fatal
+         1 Object
+         1 Gem::SourceIndex
+         1 Gem::GemPathSearcher
+         1 Gem::ConfigFile
+         1 God::Logger
+         1 God::SimpleLogger
+         1 God::CLI::Run
+         1 DRb::DRbServer::InvokeMethod
+         1 DRb::DRbServer
+         1 DRb::DRbIdConv
+         1 God::Registry
+         1 OptionParser::Switch::OptionalArgument
+         1 OptionParser
+         1 God::Socket
+         1 God::Contacts::Email
+         2 Date::Infinity
+         2 DRb::DRbMessage
+         2 DRb::DRbBadScheme
+         2 DRb::DRbUNIXSocket
+         3 OptionParser::List
+         6 IOError
+         6 Errno::ESRCH
+         6 OptionParser::Switch::RequiredArgument
+         6 Net::InternetMessageIO
+         7 God::System::SlashProcPoller
+         7 God::System::Process
+         7 God::DriverOperation
+         7 Net::SMTP
+         8 StandardError
+        10 OptionParser::Switch::NoArgument
+        13 God::Conditions::Flapping
+        13 God::Conditions::ProcessExits
+        13 God::Behaviors::CleanPidFile
+        13 God::Process
+        13 God::Watch
+        13 God::Driver
+        13 God::DriverEventQueue
+        19 God::DriverEvent
+        38 Process::Status
+        39 God::Conditions::ProcessRunning
+        50 Range
+        63 Gem::Specification
+        65 God::Metric
+        81 Gem::Dependency
+       174 Gem::Version::Part
+       209 Gem::Requirement
+       219 Gem::Version
+
+  (gdb) ruby objects strings 
+         70 u'bin'
+         73 u' INFO'
+         74 u'--main'
+         74 u'I'
+         75 u'..'
+         78 u'ruby'
+         80 u'::'
+         92 u'1.3.2'
+        100 u'README.rdoc'
+        102 u' '
+        108 u'Rakefile'
+        110 u'README'
+        114 u'\r\n'
+        127 u'>='
+        140 u'lib'
+        158 u'0'
+        294 u'\n'
+        619 u''
+
+      30503 unique strings
+    3187435 bytes
+
+  (gdb) ruby objects nodes 
+      8156 NODE_EVSTR
+      8966 NODE_COLON2
+     10020 NODE_DVAR
+     11493 NODE_AND
+     13157 NODE_FCALL
+     14493 NODE_VCALL
+     15148 NODE_ARGS
+     15180 NODE_CONST
+     15445 NODE_SCOPE
+     16582 NODE_IF
+     21594 NODE_LASGN
+     22084 NODE_METHOD
+     26633 NODE_STR
+     37819 NODE_LIT
+     64325 NODE_LVAR
+     64470 NODE_NEWLINE
+     69436 NODE_BLOCK
+     85825 NODE_CALL
+    126739 NODE_ARRAY
+
+=== TODO
+
+  `ruby where` for the current stack trace
+  `ruby print` to inspect ruby variables
+  `ruby breakpoint` to breakpoint on ruby methods
+  `ruby irb` for a simple interactive shell

data/bin/gdb.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+require 'rbconfig'
+
+if ARGV.size == 1 and ARGV[0] =~ /^\d+$/
+  ARGV.unshift "#{Config::CONFIG['bindir']}/ruby"
+elsif ARGV.size == 2 and File.exist?(ARGV[0]) and ARGV[1] =~ /^\d+$/
+else
+  puts "Usage:"
+  puts
+  puts "  gdb.rb <pid>"
+  puts "  gdb.rb <path to ruby> <pid>"
+  puts
+  exit(1)
+end
+
+cmd = "#{File.dirname(__FILE__)}/../ext/dst/bin/gdb -ex 'py execfile(\"#{File.dirname(__FILE__)}/../scripts/ruby-gdb.py\")' #{ARGV.join(" ")}"
+exec(cmd)

data/ext/Makefile

@@ -0,0 +1,2 @@
+default:
+install:

data/ext/extconf.rb

@@ -0,0 +1,71 @@
+CWD = File.expand_path(File.dirname(__FILE__))
+
+def sys(cmd)
+  puts "  -- #{cmd}"
+  unless ret = xsystem(cmd)
+    raise "#{cmd} failed, please report to gdb@tmm1.net with pastie.org link to #{CWD}/mkmf.log and #{CWD}/src/gdb-7.0/config.log"
+  end
+  ret
+end
+
+require 'mkmf'
+require 'fileutils'
+
+if RUBY_VERSION >= "1.9"
+  STDERR.puts "\n\n"
+  STDERR.puts "***************************************************************************************"
+  STDERR.puts "************************** ruby 1.9 is not supported (yet) =( *************************"
+  STDERR.puts "***************************************************************************************"
+  exit(1)
+end
+
+if `uname -a 2>&1` !~ /x86_64/
+  STDERR.puts "\n\n"
+  STDERR.puts "***************************************************************************************"
+  STDERR.puts "********************* Only x86_64 linux is supported (for now) =( *********************"
+  STDERR.puts "***************************************************************************************"
+  exit(1)
+end
+
+unless have_header('python2.5/Python.h') or have_header('python2.6/Python.h')
+  STDERR.puts "\n\n"
+  STDERR.puts "***************************************************************************************"
+  STDERR.puts "***************** Python required (apt-get install python2.5-dev) =( ******************"
+  STDERR.puts "***************************************************************************************"
+  exit(1)
+end
+
+gdb = File.basename('gdb-7.0.tar.bz2')
+dir = File.basename(gdb, '.tar.bz2')
+
+puts "(I'm about to compile gdb7.. this will definitely take a while)"
+
+Dir.chdir('src') do
+  FileUtils.rm_rf(dir) if File.exists?(dir)
+
+  sys("tar jxvf #{gdb}")
+  Dir.chdir(dir+"/gdb") do
+    if ENV['DEV']
+      sys("git init")
+      sys("git add .")
+      sys("git commit -m 'initial source'")
+    end
+
+    %w[
+      gdb-eval
+      gdb-breakpoints
+      gdb-leak
+    ].each do |patch|
+      sys("patch -p1 < ../../../../patches/#{patch}.patch")
+      sys("git commit -am '#{patch}'") if ENV['DEV']
+    end
+  end
+
+  Dir.chdir(dir) do
+    sys("./configure --prefix=#{CWD}/dst/")
+    sys("make")
+    sys("make install")
+  end
+end
+
+FileUtils.touch 'Makefile'

data/gdb.rb.gemspec

@@ -0,0 +1,32 @@
+spec = Gem::Specification.new do |s|
+  s.name = 'gdb.rb'
+  s.version = '0.1.0'
+  s.date = '2009-11-02'
+  s.rubyforge_project = 'gdb-rb'
+  s.summary = 'gdb hooks for MRI'
+  s.description = 'A set of gdb7 extensions for the MRI interpreter'
+
+  s.homepage = "http://github.com/tmm1/gdb.rb"
+
+  s.authors = ["Aman Gupta"]
+  s.email = "gdb@tmm1.net"
+
+  s.has_rdoc = false
+  s.extensions = 'ext/extconf.rb'
+  s.bindir = 'bin'
+  s.executables << 'gdb.rb'
+
+  # ruby -rpp -e' pp `git ls-files`.split("\n").sort '
+  s.files = [
+    "README",
+    "bin/gdb.rb",
+    "ext/extconf.rb",
+    "ext/Makefile",
+    "ext/src/gdb-7.0.tar.bz2",
+    "patches/gdb-eval.patch",
+    "patches/gdb-breakpoints.patch",
+    "patches/gdb-leak.patch",
+    "scripts/ruby-gdb.py",
+    "gdb.rb.gemspec"
+  ]
+end

data/patches/gdb-breakpoints.patch

@@ -0,0 +1,744 @@
+diff --git a/Makefile.in b/Makefile.in
+index 7d53205..ed6729e 100644
+--- a/Makefile.in
++++ b/Makefile.in
+@@ -267,6 +267,7 @@ SUBDIR_TUI_CFLAGS= \
+ #
+ SUBDIR_PYTHON_OBS = \
+ 	python.o \
++	py-breakpoint.o \
+ 	py-cmd.o \
+ 	py-frame.o \
+ 	py-function.o \
+@@ -277,6 +278,7 @@ SUBDIR_PYTHON_OBS = \
+ 	py-value.o
+ SUBDIR_PYTHON_SRCS = \
+ 	python/python.c \
++	python/py-breakpoint.c \
+ 	python/py-cmd.c \
+ 	python/py-frame.c \
+ 	python/py-function.c \
+@@ -1963,6 +1965,10 @@ python.o: $(srcdir)/python/python.c
+ 	$(COMPILE) $(PYTHON_CFLAGS) $(srcdir)/python/python.c
+ 	$(POSTCOMPILE)
+ 
++py-breakpoint.o: $(srcdir)/python/py-breakpoint.c
++	$(COMPILE) $(PYTHON_CFLAGS) $(srcdir)/python/py-breakpoint.c
++	$(POSTCOMPILE)
++
+ py-cmd.o: $(srcdir)/python/py-cmd.c
+ 	$(COMPILE) $(PYTHON_CFLAGS) $(srcdir)/python/py-cmd.c
+ 	$(POSTCOMPILE)
+diff --git a/python/py-breakpoint.c b/python/py-breakpoint.c
+new file mode 100644
+index 0000000..913deec
+--- /dev/null
++++ b/python/py-breakpoint.c
+@@ -0,0 +1,665 @@
++/* Python interface to breakpoints
++
++   Copyright (C) 2008, 2009 Free Software Foundation, Inc.
++
++   This file is part of GDB.
++
++   This program is free software; you can redistribute it and/or modify
++   it under the terms of the GNU General Public License as published by
++   the Free Software Foundation; either version 3 of the License, or
++   (at your option) any later version.
++
++   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, see <http://www.gnu.org/licenses/>.  */
++
++#include "defs.h"
++#include "value.h"
++#include "exceptions.h"
++#include "python-internal.h"
++#include "charset.h"
++#include "breakpoint.h"
++#include "gdbcmd.h"
++#include "gdbthread.h"
++#include "observer.h"
++#include "arch-utils.h"
++#include "language.h"
++
++/* From breakpoint.c.  */
++extern struct breakpoint *breakpoint_chain;
++
++
++typedef struct breakpoint_object breakpoint_object;
++
++static PyTypeObject breakpoint_object_type;
++
++/* A dynamically allocated vector of breakpoint objects.  Each
++   breakpoint has a number.  A breakpoint is valid if its slot in this
++   vector is non-null.  When a breakpoint is deleted, we drop our
++   reference to it and zero its slot; this is how we let the Python
++   object have a lifetime which is independent from that of the gdb
++   breakpoint.  */
++static breakpoint_object **bppy_breakpoints;
++
++/* Number of slots in bppy_breakpoints.  */
++static int bppy_slots;
++
++/* Number of live breakpoints.  */
++static int bppy_live;
++
++/* Variables used to pass information between the Breakpoint
++   constructor and the breakpoint-created hook function.  */
++static breakpoint_object *bppy_pending_object;
++
++struct breakpoint_object
++{
++  PyObject_HEAD
++
++  /* The breakpoint number according to gdb.  */
++  int number;
++
++  /* The gdb breakpoint object, or NULL if the breakpoint has been
++     deleted.  */
++  struct breakpoint *bp;
++};
++
++/* Evaluate to true if the breakpoint NUM is valid, false otherwise.  */
++#define BPPY_VALID_P(Num)			\
++    ((Num) >= 0					\
++     && (Num) < bppy_slots			\
++     && bppy_breakpoints[Num] != NULL)
++
++/* Require that BREAKPOINT be a valid breakpoint ID; throw a Python
++   exception if it is invalid.  */
++#define BPPY_REQUIRE_VALID(Breakpoint)					\
++    do {								\
++      if (! BPPY_VALID_P ((Breakpoint)->number))			\
++	return PyErr_Format (PyExc_RuntimeError, "breakpoint %d is invalid", \
++			     (Breakpoint)->number);			\
++    } while (0)
++
++/* Require that BREAKPOINT be a valid breakpoint ID; throw a Python
++   exception if it is invalid.  This macro is for use in setter functions.  */
++#define BPPY_SET_REQUIRE_VALID(Breakpoint)				\
++    do {								\
++      if (! BPPY_VALID_P ((Breakpoint)->number))			\
++        {								\
++	  PyErr_Format (PyExc_RuntimeError, "breakpoint %d is invalid", \
++			(Breakpoint)->number);				\
++	  return -1;							\
++	}								\
++    } while (0)
++
++/* Python function which checks the validity of a breakpoint object.  */
++static PyObject *
++bppy_is_valid (PyObject *self, PyObject *args)
++{
++  if (((breakpoint_object *) self)->bp)
++    Py_RETURN_TRUE;
++  Py_RETURN_FALSE;
++}
++
++/* Python function to test whether or not the breakpoint is enabled.  */
++static PyObject *
++bppy_get_enabled (PyObject *self, void *closure)
++{
++  if (! ((breakpoint_object *) self)->bp)
++    Py_RETURN_FALSE;
++  /* Not clear what we really want here.  */
++  if (((breakpoint_object *) self)->bp->enable_state == bp_enabled)
++    Py_RETURN_TRUE;
++  Py_RETURN_FALSE;
++}
++
++/* Python function to test whether or not the breakpoint is silent.  */
++static PyObject *
++bppy_get_silent (PyObject *self, void *closure)
++{
++  BPPY_REQUIRE_VALID ((breakpoint_object *) self);
++  if (((breakpoint_object *) self)->bp->silent)
++    Py_RETURN_TRUE;
++  Py_RETURN_FALSE;
++}
++
++/* Python function to set the enabled state of a breakpoint.  */
++static int
++bppy_set_enabled (PyObject *self, PyObject *newvalue, void *closure)
++{
++  breakpoint_object *self_bp = (breakpoint_object *) self;
++  int cmp;
++
++  BPPY_SET_REQUIRE_VALID (self_bp);
++
++  if (newvalue == NULL)
++    {
++      PyErr_SetString (PyExc_TypeError, "cannot delete `enabled' attribute");
++      return -1;
++    }
++  else if (! PyBool_Check (newvalue))
++    {
++      PyErr_SetString (PyExc_TypeError,
++		       "the value of `enabled' must be a boolean");
++      return -1;
++    }
++
++  cmp = PyObject_IsTrue (newvalue);
++  if (cmp < 0)
++    return -1;
++  else if (cmp == 1)
++    enable_breakpoint (self_bp->bp);
++  else 
++    disable_breakpoint (self_bp->bp);
++  return 0;
++}
++
++/* Python function to set the 'silent' state of a breakpoint.  */
++static int
++bppy_set_silent (PyObject *self, PyObject *newvalue, void *closure)
++{
++  breakpoint_object *self_bp = (breakpoint_object *) self;
++  int cmp;
++
++  BPPY_SET_REQUIRE_VALID (self_bp);
++
++  if (newvalue == NULL)
++    {
++      PyErr_SetString (PyExc_TypeError, "cannot delete `silent' attribute");
++      return -1;
++    }
++  else if (! PyBool_Check (newvalue))
++    {
++      PyErr_SetString (PyExc_TypeError,
++		       "the value of `silent' must be a boolean");
++      return -1;
++    }
++
++  cmp = PyObject_IsTrue (newvalue);
++  if (cmp < 0)
++    return -1;
++  else
++    self_bp->bp->silent = cmp;
++
++  return 0;
++}
++
++/* Python function to set the thread of a breakpoint.  */
++static int
++bppy_set_thread (PyObject *self, PyObject *newvalue, void *closure)
++{
++  breakpoint_object *self_bp = (breakpoint_object *) self;
++  int id;
++
++  BPPY_SET_REQUIRE_VALID (self_bp);
++
++  if (newvalue == NULL)
++    {
++      PyErr_SetString (PyExc_TypeError, "cannot delete `thread' attribute");
++      return -1;
++    }
++  else if (PyInt_Check (newvalue))
++    {
++      id = (int) PyInt_AsLong (newvalue);
++      if (! valid_thread_id (id))
++	{
++	  PyErr_SetString (PyExc_RuntimeError, "invalid thread id");
++	  return -1;
++	}
++    }
++  else if (newvalue == Py_None)
++    id = -1;
++  else
++    {
++      PyErr_SetString (PyExc_TypeError,
++		       "the value of `thread' must be an integer or None");
++      return -1;
++    }
++
++  self_bp->bp->thread = id;
++
++  return 0;
++}
++
++/* Python function to set the ignore count of a breakpoint.  */
++static int
++bppy_set_ignore_count (PyObject *self, PyObject *newvalue, void *closure)
++{
++  breakpoint_object *self_bp = (breakpoint_object *) self;
++  long value;
++
++  BPPY_SET_REQUIRE_VALID (self_bp);
++
++  if (newvalue == NULL)
++    {
++      PyErr_SetString (PyExc_TypeError,
++		       "cannot delete `ignore_count' attribute");
++      return -1;
++    }
++  else if (! PyInt_Check (newvalue))
++    {
++      PyErr_SetString (PyExc_TypeError,
++		       "the value of `ignore_count' must be an integer");
++      return -1;
++    }
++
++  value = PyInt_AsLong (newvalue);
++  if (value < 0)
++    value = 0;
++  set_ignore_count (self_bp->number, (int) value, 0);
++
++  return 0;
++}
++
++/* Python function to set the hit count of a breakpoint.  */
++static int
++bppy_set_hit_count (PyObject *self, PyObject *newvalue, void *closure)
++{
++  breakpoint_object *self_bp = (breakpoint_object *) self;
++
++  BPPY_SET_REQUIRE_VALID (self_bp);
++
++  if (newvalue == NULL)
++    {
++      PyErr_SetString (PyExc_TypeError, "cannot delete `hit_count' attribute");
++      return -1;
++    }
++  else if (! PyInt_Check (newvalue) || PyInt_AsLong (newvalue) != 0)
++    {
++      PyErr_SetString (PyExc_AttributeError,
++		       "the value of `hit_count' must be zero");
++      return -1;
++    }
++
++  self_bp->bp->hit_count = 0;
++
++  return 0;
++}
++
++/* Python function to get the location of a breakpoint.  */
++static PyObject *
++bppy_get_location (PyObject *self, void *closure)
++{
++  char *str;
++
++  BPPY_REQUIRE_VALID ((breakpoint_object *) self);
++  str = ((breakpoint_object *) self)->bp->addr_string;
++  /* FIXME: watchpoints?  tracepoints?  */
++  if (! str)
++    str = "";
++  return PyString_Decode (str, strlen (str), host_charset (), NULL);
++}
++
++// /* Python function to get the condition expression of a breakpoint.  */
++// static PyObject *
++// bppy_get_condition (PyObject *self, void *closure)
++// {
++//   char *str;
++//   BPPY_REQUIRE_VALID ((breakpoint_object *) self);
++// 
++//   str = ((breakpoint_object *) self)->bp->cond_string;
++//   if (! str)
++//     Py_RETURN_NONE;
++//   return PyString_Decode (str, strlen (str), host_charset (), NULL);
++// }
++
++// static int
++// bppy_set_condition (PyObject *self, PyObject *newvalue, void *closure)
++// {
++//   char *exp;
++//   breakpoint_object *self_bp = (breakpoint_object *) self;
++//   volatile struct gdb_exception except;
++// 
++//   BPPY_SET_REQUIRE_VALID (self_bp);
++// 
++//   if (newvalue == NULL)
++//     {
++//       PyErr_SetString (PyExc_TypeError, "cannot delete `condition' attribute");
++//       return -1;
++//     }
++//   else if (newvalue == Py_None)
++//     exp = "";
++//   else
++//     {
++//       exp = python_string_to_host_string (newvalue);
++//       if (exp == NULL)
++//  return -1;
++//     }
++// 
++//   TRY_CATCH (except, RETURN_MASK_ALL)
++//     {
++//       set_breakpoint_condition (self_bp->bp, exp, 0);
++//     }
++//   GDB_PY_HANDLE_EXCEPTION (except);
++// 
++//   return 0;
++// }
++
++/* Python function to get the commands attached to a breakpoint.  */
++static PyObject *
++bppy_get_commands (PyObject *self, void *closure)
++{
++  breakpoint_object *self_bp = (breakpoint_object *) self;
++  long length;
++  volatile struct gdb_exception except;
++  struct ui_file *string_file;
++  struct cleanup *chain;
++  PyObject *result;
++  char *cmdstr;
++
++  BPPY_REQUIRE_VALID (self_bp);
++
++  if (! self_bp->bp->commands)
++    Py_RETURN_NONE;
++
++  string_file = mem_fileopen ();
++  chain = make_cleanup_ui_file_delete (string_file);
++
++  TRY_CATCH (except, RETURN_MASK_ALL)
++    {
++      /* FIXME: this can fail.  Maybe we need to be making a new
++	 ui_out object here?  */
++      ui_out_redirect (uiout, string_file);
++      print_command_lines (uiout, self_bp->bp->commands, 0);
++      ui_out_redirect (uiout, NULL);
++    }
++  cmdstr = ui_file_xstrdup (string_file, &length);
++  GDB_PY_HANDLE_EXCEPTION (except);
++
++  result = PyString_Decode (cmdstr, strlen (cmdstr), host_charset (), NULL);
++  do_cleanups (chain);
++  xfree (cmdstr);
++  return result;
++}
++
++/* Python function to get the breakpoint's number.  */
++static PyObject *
++bppy_get_number (PyObject *self, void *closure)
++{
++  breakpoint_object *self_bp = (breakpoint_object *) self;
++
++  BPPY_REQUIRE_VALID (self_bp);
++
++  return PyInt_FromLong (self_bp->number);
++}
++
++/* Python function to get the breakpoint's thread ID.  */
++static PyObject *
++bppy_get_thread (PyObject *self, void *closure)
++{
++  breakpoint_object *self_bp = (breakpoint_object *) self;
++
++  BPPY_REQUIRE_VALID (self_bp);
++
++  if (self_bp->bp->thread == -1)
++    Py_RETURN_NONE;
++
++  return PyInt_FromLong (self_bp->bp->thread);
++}
++
++/* Python function to get the breakpoint's hit count.  */
++static PyObject *
++bppy_get_hit_count (PyObject *self, void *closure)
++{
++  breakpoint_object *self_bp = (breakpoint_object *) self;
++
++  BPPY_REQUIRE_VALID (self_bp);
++
++  return PyInt_FromLong (self_bp->bp->hit_count);
++}
++
++/* Python function to get the breakpoint's ignore count.  */
++static PyObject *
++bppy_get_ignore_count (PyObject *self, void *closure)
++{
++  breakpoint_object *self_bp = (breakpoint_object *) self;
++
++  BPPY_REQUIRE_VALID (self_bp);
++
++  return PyInt_FromLong (self_bp->bp->ignore_count);
++}
++
++/* Python function to create a new breakpoint.  */
++static PyObject *
++bppy_new (PyTypeObject *subtype, PyObject *args, PyObject *kwargs)
++{
++  PyObject *result;
++  char *spec;
++  volatile struct gdb_exception except;
++
++  /* FIXME: allow condition, thread, temporary, ... ? */
++  if (! PyArg_ParseTuple (args, "s", &spec))
++    return NULL;
++  result = subtype->tp_alloc (subtype, 0);
++  if (! result)
++    return NULL;
++  bppy_pending_object = (breakpoint_object *) result;
++  bppy_pending_object->number = -1;
++  bppy_pending_object->bp = NULL;
++
++  TRY_CATCH (except, RETURN_MASK_ALL)
++    {
++      set_breakpoint (python_gdbarch, spec, NULL, 0, 0, -1, 0,
++		      AUTO_BOOLEAN_TRUE, 1);
++    }
++  if (except.reason < 0)
++    {
++      subtype->tp_free (result);
++      return PyErr_Format (except.reason == RETURN_QUIT
++			     ? PyExc_KeyboardInterrupt : PyExc_RuntimeError,
++			     "%s", except.message);
++    }
++
++  BPPY_REQUIRE_VALID ((breakpoint_object *) result);
++  return result;
++}
++
++
++
++/* Static function to return a tuple holding all breakpoints.  */
++
++PyObject *
++gdbpy_breakpoints (PyObject *self, PyObject *args)
++{
++  PyObject *result;
++
++  if (bppy_live == 0)
++    Py_RETURN_NONE;
++
++  result = PyTuple_New (bppy_live);
++  if (result)
++    {
++      int i, out = 0;
++      for (i = 0; out < bppy_live; ++i)
++	{
++	  if (! bppy_breakpoints[i])
++	    continue;
++	  Py_INCREF (bppy_breakpoints[i]);
++	  PyTuple_SetItem (result, out, (PyObject *) bppy_breakpoints[i]);
++	  ++out;
++	}
++    }
++  return result;
++}
++
++
++
++/* Event callback functions.  */
++
++/* Callback that is used when a breakpoint is created.  This function
++   will create a new Python breakpoint object.  */
++static void
++gdbpy_breakpoint_created (int num)
++{
++  breakpoint_object *newbp;
++  struct breakpoint *bp;
++  struct cleanup *cleanup;
++
++  if (num < 0)
++    return;
++
++  for (bp = breakpoint_chain; bp; bp = bp->next)
++    if (bp->number == num)
++      break;
++  if (! bp)
++    return;
++
++  if (num >= bppy_slots)
++    {
++      int old = bppy_slots;
++      bppy_slots = bppy_slots * 2 + 10;
++      bppy_breakpoints
++	= (breakpoint_object **) xrealloc (bppy_breakpoints,
++					   (bppy_slots
++					    * sizeof (breakpoint_object *)));
++      memset (&bppy_breakpoints[old], 0,
++	      (bppy_slots - old) * sizeof (PyObject *));
++    }
++
++  ++bppy_live;
++
++  cleanup = ensure_python_env (get_current_arch (), current_language);
++
++  if (bppy_pending_object)
++    {
++      newbp = bppy_pending_object;
++      bppy_pending_object = NULL;
++    }
++  else
++    newbp = PyObject_New (breakpoint_object, &breakpoint_object_type);
++  if (newbp)
++    {
++      // PyObject *hookfn;
++
++      newbp->number = num;
++      newbp->bp = bp;
++      bppy_breakpoints[num] = newbp;
++
++  //       hookfn = gdbpy_get_hook_function ("new_breakpoint");
++  //       if (hookfn)
++  // {
++  //   PyObject *result;
++  //   result = PyObject_CallFunctionObjArgs (hookfn, newbp, NULL);
++  //   if (result)
++  //     {
++  //       Py_DECREF (result);
++  //     }
++  //   Py_DECREF (hookfn);
++  // }
++    }
++
++  /* Just ignore errors here.  */
++  PyErr_Clear ();
++
++  do_cleanups (cleanup);
++}
++
++/* Callback that is used when a breakpoint is deleted.  This will
++   invalidate the corresponding Python object.  */
++static void
++gdbpy_breakpoint_deleted (int num)
++{
++  struct cleanup *cleanup;
++
++  cleanup = ensure_python_env (get_current_arch (), current_language);
++  if (BPPY_VALID_P (num))
++    {
++      bppy_breakpoints[num]->bp = NULL;
++      Py_DECREF (bppy_breakpoints[num]);
++      bppy_breakpoints[num] = NULL;
++      --bppy_live;
++    }
++  do_cleanups (cleanup);
++}
++
++
++
++/* Initialize the Python breakpoint code.  */
++void
++gdbpy_initialize_breakpoints (void)
++{
++  breakpoint_object_type.tp_new = bppy_new;
++  if (PyType_Ready (&breakpoint_object_type) < 0)
++    return;
++
++  Py_INCREF (&breakpoint_object_type);
++  PyModule_AddObject (gdb_module, "Breakpoint",
++		      (PyObject *) &breakpoint_object_type);
++
++  observer_attach_breakpoint_created (gdbpy_breakpoint_created);
++  observer_attach_breakpoint_deleted (gdbpy_breakpoint_deleted);
++}
++
++
++
++static PyGetSetDef breakpoint_object_getset[] = {
++  { "enabled", bppy_get_enabled, bppy_set_enabled,
++    "Boolean telling whether the breakpoint is enabled.", NULL },
++  { "silent", bppy_get_silent, bppy_set_silent,
++    "Boolean telling whether the breakpoint is silent.", NULL },
++  { "thread", bppy_get_thread, bppy_set_thread,
++    "Thread ID for the breakpoint.\n\
++If the value is a thread ID (integer), then this is a thread-specific breakpoint.\n\
++If the value is None, then this breakpoint not thread-specific.\n\
++No other type of value can be used.", NULL },
++  { "ignore_count", bppy_get_ignore_count, bppy_set_ignore_count,
++    "Number of times this breakpoint should be automatically continued.",
++    NULL },
++  { "number", bppy_get_number, NULL,
++    "Breakpoint's number assigned by GDB.", NULL },
++  { "hit_count", bppy_get_hit_count, bppy_set_hit_count,
++    "Number of times the breakpoint has been hit.\n\
++Can be set to zero to clear the count. No other value is valid\n\
++when setting this property.", NULL },
++  { "location", bppy_get_location, NULL,
++    "Location of the breakpoint, as specified by the user.", NULL},
++//   { "condition", bppy_get_condition, bppy_set_condition,
++//     "Condition of the breakpoint, as specified by the user, or None if no condition set."},
++  { "commands", bppy_get_commands, NULL,
++    "Commands of the breakpoint, as specified by the user."},
++  { NULL }  /* Sentinel.  */
++};
++
++static PyMethodDef breakpoint_object_methods[] =
++{
++  { "is_valid", bppy_is_valid, METH_NOARGS,
++    "Return true if this breakpoint is valid, false if not." },
++  { NULL } /* Sentinel.  */
++};
++
++static PyTypeObject breakpoint_object_type =
++{
++  PyObject_HEAD_INIT (NULL)
++  0,				  /*ob_size*/
++  "gdb.Breakpoint",		  /*tp_name*/
++  sizeof (breakpoint_object),	  /*tp_basicsize*/
++  0,				  /*tp_itemsize*/
++  0,				  /*tp_dealloc*/
++  0,				  /*tp_print*/
++  0,				  /*tp_getattr*/
++  0,				  /*tp_setattr*/
++  0,				  /*tp_compare*/
++  0,				  /*tp_repr*/
++  0,				  /*tp_as_number*/
++  0,				  /*tp_as_sequence*/
++  0,				  /*tp_as_mapping*/
++  0,				  /*tp_hash */
++  0,				  /*tp_call*/
++  0,				  /*tp_str*/
++  0,				  /*tp_getattro*/
++  0,				  /*tp_setattro*/
++  0,				  /*tp_as_buffer*/
++  Py_TPFLAGS_DEFAULT,		  /*tp_flags*/
++  "GDB breakpoint object",	  /* tp_doc */
++  0,				  /* tp_traverse */
++  0,				  /* tp_clear */
++  0,				  /* tp_richcompare */
++  0,				  /* tp_weaklistoffset */
++  0,				  /* tp_iter */
++  0,				  /* tp_iternext */
++  breakpoint_object_methods,	  /* tp_methods */
++  0,				  /* tp_members */
++  breakpoint_object_getset	  /* tp_getset */
++};
+diff --git a/python/python-internal.h b/python/python-internal.h
+index fbf8247..fa4a62b 100644
+--- a/python/python-internal.h
++++ b/python/python-internal.h
+@@ -69,6 +69,7 @@ extern PyTypeObject value_object_type;
+ 
+ PyObject *gdbpy_history (PyObject *self, PyObject *args);
+ PyObject *gdbpy_eval (PyObject *self, PyObject *args);
++PyObject *gdbpy_breakpoints (PyObject *, PyObject *);
+ 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);
+@@ -84,6 +85,7 @@ struct value *convert_value_from_python (PyObject *obj);
+ struct type *type_object_to_type (PyObject *obj);
+ 
+ void gdbpy_initialize_values (void);
++void gdbpy_initialize_breakpoints (void);
+ void gdbpy_initialize_frames (void);
+ void gdbpy_initialize_commands (void);
+ void gdbpy_initialize_types (void);
+diff --git a/python/python.c b/python/python.c
+index c96fa29..006ce29 100644
+--- a/python/python.c
++++ b/python/python.c
+@@ -594,6 +594,7 @@ Enables or disables auto-loading of Python code when an object is opened."),
+   PyModule_AddStringConstant (gdb_module, "TARGET_CONFIG", (char*) target_name);
+ 
+   gdbpy_initialize_values ();
++  gdbpy_initialize_breakpoints ();
+   gdbpy_initialize_frames ();
+   gdbpy_initialize_commands ();
+   gdbpy_initialize_functions ();
+@@ -658,6 +659,9 @@ static PyMethodDef GdbMethods[] =
+   { "parameter", gdbpy_parameter, METH_VARARGS,
+     "Return a gdb parameter's value" },
+ 
++  { "breakpoints", gdbpy_breakpoints, METH_NOARGS,
++  "Return a tuple of all breakpoint objects" },
++
+   { "default_visualizer", gdbpy_default_visualizer, METH_VARARGS,
+     "Find the default visualizer for a Value." },
+