--- a/gdb/Makefile.in
+++ b/gdb/Makefile.in
@@ -254,19 +254,23 @@ SUBDIR_TUI_CFLAGS= \
 #
 SUBDIR_PYTHON_OBS = \
 	python.o \
+	python-block.o \
 	python-breakpoint.o \
 	python-cmd.o \
 	python-frame.o \
 	python-hooks.o \
 	python-symtab.o \
+	python-symbol.o \
 	python-value.o
 SUBDIR_PYTHON_SRCS = \
 	python/python.c \
+	python/block.c \
 	python/breakpoint.c \
 	python/cmd.c \
 	python/frame.c \
 	python/hooks.c \
 	python/symtab.c \
+	python/symbol.c \
 	python/value.c
 SUBDIR_PYTHON_DEPS =
 SUBDIR_PYTHON_LDFLAGS=
@@ -3395,6 +3399,10 @@ python.o: $(srcdir)/python/python.c $(defs_h) $(python_h) $(varobj_h) \
 	$(command_h) $(libiberty_h) $(cli_decode_h) $(charset_h) $(top_h) \
 	$(exceptions_h) $(python_internal_h) $(solib_h)
 	$(CC) -c $(INTERNAL_CFLAGS) $(PYTHON_CFLAGS) $(srcdir)/python/python.c
+python-block.o: $(srcdir)/python/block.c $(defs_h) $(block_h) $(dictionary_h) \
+	$(symtab_h) $(python_h) $(python_internal_h)
+	$(CC) -c $(INTERNAL_CFLAGS) $(PYTHON_CFLAGS) \
+	$(srcdir)/python/block.c -o python-block.o
 python-breakpoint.o: $(srcdir)/python/breakpoint.c $(defs_h) $(python_h) \
 	$(value_h) $(exceptions_h) $(python_internal_h) $(charset_h) \
 	$(breakpoint_h) $(gdbcmd_h)
@@ -3414,6 +3422,10 @@ python-hooks.o: $(srcdir)/python/hooks.c $(defs_h) $(cli_decode_h) \
 	$(charset_h) $(gdb_events_h) $(python_h) $(python_internal_h)
 	$(CC) -c $(INTERNAL_CFLAGS) $(PYTHON_CFLAGS) \
 	$(srcdir)/python/hooks.c -o python-hooks.o
+python-symbol.o: $(srcdir)/python/symbol.c $(defs_h) $(symtab_h) $(python_h) \
+	$(python_internal_h)
+	$(CC) -c $(INTERNAL_CFLAGS) $(PYTHON_CFLAGS) \
+	$(srcdir)/python/symbol.c -o python-symbol.o
 python-symtab.o: $(srcdir)/python/symtab.c $(defs_h) $(charset_h) $(source_h) \
 	$(symtab_h) $(python_h) $(python_internal_h)
 	$(CC) -c $(INTERNAL_CFLAGS) $(PYTHON_CFLAGS) \

--- /dev/null
+++ b/gdb/python/block.c
@@ -0,0 +1,252 @@
+/* Python interface to blocks.
+
+   Copyright (C) 2008 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 "block.h"
+#include "dictionary.h"
+#include "symtab.h"
+#include "python-internal.h"
+
+typedef struct {
+  PyObject_HEAD
+  struct block *block;
+} block_object;
+
+static PyObject *blpy_iter (PyObject *self);
+static PyObject *blpy_itersymbols (PyObject *self, PyObject *args);
+static PyObject *blpy_get_start (PyObject *self, PyObject *args);
+static PyObject *blpy_get_end (PyObject *self, PyObject *args);
+static PyObject *blpy_get_function (PyObject *self, PyObject *args);
+static PyObject *blpy_get_superblock (PyObject *self, PyObject *args);
+
+static PyMethodDef block_object_methods[] = {
+  { "itersymbols", blpy_itersymbols, METH_NOARGS,
+    "Return an iterator to walk through the symbols in the block." },
+  { "get_start", blpy_get_start, METH_NOARGS,
+    "Return the start address of this block." },
+  { "get_end", blpy_get_end, METH_NOARGS,
+    "Return the end address of this block." },
+  { "get_function", blpy_get_function, METH_NOARGS,
+    "Return the symbol that names this block, or None." },
+  { "get_superblock", blpy_get_end, METH_NOARGS,
+    "Return the block containing this block, or None." },
+  {NULL}  /* Sentinel */
+};
+
+static PyTypeObject block_object_type = {
+  PyObject_HEAD_INIT (NULL)
+  0,				  /*ob_size*/
+  "gdb.Block",			  /*tp_name*/
+  sizeof (block_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 | Py_TPFLAGS_HAVE_ITER,  /*tp_flags*/
+  "GDB block object",		  /* tp_doc */
+  0,				  /* tp_traverse */
+  0,				  /* tp_clear */
+  0,				  /* tp_richcompare */
+  0,				  /* tp_weaklistoffset */
+  blpy_iter,			  /* tp_iter */
+  0,				  /* tp_iternext */
+  block_object_methods		  /* tp_methods */
+};
+
+typedef struct {
+  PyObject_HEAD
+  struct dictionary *dict;
+  struct dict_iterator iter;
+  int initialized_p;
+} block_syms_iterator_object;
+
+static PyObject *blpy_block_syms_iter (PyObject *self);
+static PyObject *blpy_block_syms_iternext (PyObject *self);
+
+static PyTypeObject block_syms_iterator_object_type = {
+  PyObject_HEAD_INIT (NULL)
+  0,				  /*ob_size*/
+  "gdb.BlockIterator",		  /*tp_name*/
+  sizeof (block_syms_iterator_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 | Py_TPFLAGS_HAVE_ITER,  /*tp_flags*/
+  "GDB block syms iterator object",	      /* tp_doc */
+  0,				  /* tp_traverse */
+  0,				  /* tp_clear */
+  0,				  /* tp_richcompare */
+  0,				  /* tp_weaklistoffset */
+  blpy_block_syms_iter,		  /* tp_iter */
+  blpy_block_syms_iternext,	  /* tp_iternext */
+  0				  /* tp_methods */
+};
+
+
+static PyObject *
+blpy_iter (PyObject *self)
+{
+  block_syms_iterator_object *block_iter_obj;
+
+  block_iter_obj = PyObject_New (block_syms_iterator_object,
+			    &block_syms_iterator_object_type);
+  if (block_iter_obj == NULL)
+    {
+      PyErr_SetString (PyExc_MemoryError,
+		       "Could not allocate iterator object.");
+      return NULL;
+    }
+
+  block_iter_obj->dict = BLOCK_DICT (((block_object *) self)->block);
+  block_iter_obj->initialized_p = 0;
+
+  return (PyObject *) block_iter_obj;
+}
+
+static PyObject *
+blpy_itersymbols (PyObject *self, PyObject *args)
+{
+  return blpy_iter (self);
+}
+
+static PyObject *
+blpy_get_start (PyObject *self, PyObject *args)
+{
+  block_object *self_block = (block_object *) self;
+
+  return PyLong_FromUnsignedLongLong (BLOCK_START (self_block->block));
+}
+
+static PyObject *
+blpy_get_end (PyObject *self, PyObject *args)
+{
+  block_object *self_block = (block_object *) self;
+
+  return PyLong_FromUnsignedLongLong (BLOCK_END (self_block->block));
+}
+
+static PyObject *
+blpy_get_function (PyObject *self, PyObject *args)
+{
+  block_object *self_block = (block_object *) self;
+  struct symbol *sym;
+
+  sym = BLOCK_FUNCTION (self_block->block);
+  if (sym)
+    return symbol_to_symbol_object (sym);
+
+  Py_RETURN_NONE;
+}
+
+static PyObject *
+blpy_get_superblock (PyObject *self, PyObject *args)
+{
+  block_object *self_block = (block_object *) self;
+  struct block *block;
+
+  block = BLOCK_SUPERBLOCK (self_block->block);
+  if (block)
+    return block_to_block_object (block);
+
+  Py_RETURN_NONE;
+}
+
+PyObject *
+block_to_block_object (struct block *block)
+{
+  block_object *block_obj;
+
+  block_obj = PyObject_New (block_object, &block_object_type);
+  if (block_obj == NULL)
+    {
+      PyErr_SetString (PyExc_MemoryError, "Could not allocate block object.");
+      return NULL;
+    }
+
+  block_obj->block = block;
+
+  return (PyObject *) block_obj;
+}
+
+static PyObject *
+blpy_block_syms_iter (PyObject *self)
+{
+  return self;
+}
+
+static PyObject *
+blpy_block_syms_iternext (PyObject *self)
+{
+  block_syms_iterator_object *iter_obj = (block_syms_iterator_object *) self;
+  struct symbol *sym;
+
+  if (!iter_obj->initialized_p)
+    {
+      sym = dict_iterator_first (iter_obj->dict,  &(iter_obj->iter));
+      iter_obj->initialized_p = 1;
+    }
+  else
+    sym = dict_iterator_next (&(iter_obj->iter));
+
+  return (sym == NULL)? NULL : symbol_to_symbol_object (sym);
+}
+
+void
+gdbpy_initialize_blocks (void)
+{
+  block_object_type.tp_new = PyType_GenericNew;
+  if (PyType_Ready (&block_object_type) < 0)
+    return;
+
+  block_syms_iterator_object_type.tp_new = PyType_GenericNew;
+  if (PyType_Ready (&block_syms_iterator_object_type) < 0)
+    return;
+
+  Py_INCREF (&block_object_type);
+  PyModule_AddObject (gdb_module, "Block", (PyObject *) &block_object_type);
+
+  Py_INCREF (&block_syms_iterator_object_type);
+  PyModule_AddObject (gdb_module, "BlockIterator",
+		      (PyObject *) &block_syms_iterator_object_type);
+}

--- a/gdb/python/frame.c
+++ b/gdb/python/frame.c
@@ -52,6 +52,7 @@ static PyObject *frapy_get_name (frame_object *self);
 static PyObject *frapy_get_type (frame_object *self);
 static PyObject *frapy_get_unwind_stop_reason (frame_object *self);
 static PyObject *frapy_get_pc (frame_object *self);
+static PyObject *frapy_get_address_in_block (PyObject *self, PyObject *args);
 static PyObject *frapy_get_prev (frame_object *self);
 static PyObject *frapy_get_next (frame_object *self);
 static PyObject *frapy_find_sal (frame_object *self);
@@ -81,6 +82,8 @@ static PyMethodDef frame_object_methods[] = {
     METH_NOARGS, "Return the function name of the frame." },
   { "get_pc", (PyCFunction) frapy_get_pc, METH_NOARGS,
     "Return the frame's resume address." },
+  { "get_address_in_block", frapy_get_address_in_block, METH_NOARGS,
+    "Return an address which falls within the frame's code block." },
   { "get_prev", (PyCFunction) frapy_get_prev, METH_NOARGS,
     "Return the previous (outer) frame." },
   { "get_next", (PyCFunction) frapy_get_next, METH_NOARGS,
@@ -287,6 +290,25 @@ frapy_get_pc (frame_object *self)
   return PyLong_FromUnsignedLongLong (pc);
 }
 
+static PyObject *
+frapy_get_address_in_block (PyObject *self, PyObject *args)
+{
+  frame_object *frame_obj = (frame_object *) self;
+  CORE_ADDR pc = 0;	      /* Initialize to appease gcc warning.  */
+  struct frame_info *frame;
+  volatile struct gdb_exception except;
+
+  TRY_CATCH (except, RETURN_MASK_ALL)
+    {
+      FRAPY_REQUIRE_VALID (frame_obj, frame);
+
+      pc = get_frame_address_in_block (frame);
+    }
+  GDB_PY_HANDLE_EXCEPTION (except);
+
+  return PyLong_FromUnsignedLongLong (pc);
+}
+
 static frame_object *
 frame_info_to_frame_object (struct frame_info *frame)
 {

--- a/gdb/python/python-internal.h
+++ b/gdb/python/python-internal.h
@@ -37,6 +37,9 @@ PyObject *gdbpy_frame_stop_reason_string (PyObject *, PyObject *);
 
 PyObject *variable_to_python (struct cmd_list_element *);
 PyObject *symtab_and_line_to_sal_object (struct symtab_and_line sal);
+PyObject *symtab_to_symtab_object (struct symtab *symtab);
+PyObject *symbol_to_symbol_object (struct symbol *sym);
+PyObject *block_to_block_object (struct block *block);
 
 PyObject *gdbpy_get_hook_function (const char *);
 
@@ -46,6 +49,8 @@ void gdbpy_initialize_breakpoints (void);
 void gdbpy_initialize_frames (void);
 void gdbpy_initialize_symtabs (void);
 void gdbpy_initialize_commands (void);
+void gdbpy_initialize_symbols (void);
+void gdbpy_initialize_blocks (void);
 
 /* Use this after a TRY_EXCEPT to throw the appropriate Python
    exception.  FIXME: throw different errors depending on

--- a/gdb/python/python.c
+++ b/gdb/python/python.c
@@ -44,6 +44,7 @@ static PyObject *gdbpy_decode_line (PyObject *, PyObject *);
 static PyObject *gdbpy_version (PyObject *, PyObject *);
 static PyObject *gdbpy_host_conf (PyObject *, PyObject *);
 static PyObject *gdbpy_target_conf (PyObject *, PyObject *);
+static PyObject *gdbpy_find_pc_function (PyObject *, PyObject *);
 
 
 void
@@ -76,6 +77,9 @@ demand_python ()
 	{ "solib_address", gdbpy_solib_address, METH_VARARGS,
 	  "Return shared library holding a given address, or None." },
 
+	{ "find_pc_function", gdbpy_find_pc_function, METH_VARARGS,
+	  "Return the function containing the given pc value, or None." },
+
 	{ "decode_line", gdbpy_decode_line, METH_VARARGS,
 	  "Decode a string argument the way that 'break' or 'edit' does.\n\
 Return a tuple holding the file name (or None) and line number (or None).\n\
@@ -101,6 +105,8 @@ Note: may later change to return an object." },
       gdbpy_initialize_frames ();
       gdbpy_initialize_symtabs ();
       gdbpy_initialize_commands ();
+      gdbpy_initialize_symbols ();
+      gdbpy_initialize_blocks ();
 
       PyRun_SimpleString ("import gdb");
 
@@ -489,6 +495,23 @@ gdbpy_solib_address (PyObject *self, PyObject *args)
 }
 
 PyObject *
+gdbpy_find_pc_function (PyObject *self, PyObject *args)
+{
+  unsigned long long pc;
+  struct symbol *sym;
+  PyObject *sym_obj;
+
+  if (!PyArg_ParseTuple (args, "K", &pc))
+    return NULL;
+
+  sym = find_pc_function (pc);
+  if (sym)
+    return symbol_to_symbol_object (sym);
+
+  Py_RETURN_NONE;
+}
+
+PyObject *
 gdbpy_decode_line (PyObject *self, PyObject *args)
 {
   struct symtabs_and_lines sals = { NULL, 0 }; /* Initialize to appease gcc.  */

--- /dev/null
+++ b/gdb/python/symbol.c
@@ -0,0 +1,175 @@
+/* Python interface to symbols.
+
+   Copyright (C) 2008 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 "symtab.h"
+#include "python-internal.h"
+
+typedef struct {
+  PyObject_HEAD
+  struct symbol *symbol;
+} symbol_object;
+
+static PyObject *sympy_str (PyObject *self);
+static PyObject *sympy_get_value (PyObject *self, PyObject *args);
+static PyObject *sympy_get_symtab (PyObject *self, PyObject *args);
+static PyObject *sympy_get_natural_name (PyObject *self, PyObject *args);
+static PyObject *sympy_get_linkage_name (PyObject *self, PyObject *args);
+static PyObject *sympy_get_print_name (PyObject *self, PyObject *args);
+
+static PyMethodDef symbol_object_methods[] = {
+  { "get_value", sympy_get_value, METH_NOARGS,
+    "Return the value of the symbol." },
+  { "get_symtab", sympy_get_symtab, METH_NOARGS,
+    "Return the value of the symbol." },
+  { "get_natural_name", sympy_get_natural_name, METH_NOARGS,
+    "Return the \"natural\" name of the symbol." },
+  { "get_linkage_name", sympy_get_linkage_name, METH_NOARGS,
+    "Return the name of the symbol as used by the linker." },
+  { "get_print_name", sympy_get_print_name, METH_NOARGS,
+    "Return the name of the symbol in a form suitable for output." },
+  {NULL}  /* Sentinel */
+};
+
+static PyTypeObject symbol_object_type = {
+  PyObject_HEAD_INIT (NULL)
+  0,				  /*ob_size*/
+  "gdb.Symbol",			  /*tp_name*/
+  sizeof (symbol_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*/
+  sympy_str,			  /*tp_str*/
+  0,				  /*tp_getattro*/
+  0,				  /*tp_setattro*/
+  0,				  /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT,		  /*tp_flags*/
+  "GDB symbol object",		  /* tp_doc */
+  0,				  /* tp_traverse */
+  0,				  /* tp_clear */
+  0,				  /* tp_richcompare */
+  0,				  /* tp_weaklistoffset */
+  0,				  /* tp_iter */
+  0,				  /* tp_iternext */
+  symbol_object_methods		  /* tp_methods */
+};
+
+
+static PyObject *
+sympy_str (PyObject *self)
+{
+  int ret;
+  char *s;
+  PyObject *result;
+
+  ret = asprintf (&s, "symbol for %s",
+		  SYMBOL_PRINT_NAME (((symbol_object *) self)->symbol));
+  if (ret < 0)
+    Py_RETURN_NONE;
+
+  result = PyString_FromString (s);
+  xfree (s);
+
+  return result;
+}
+
+static PyObject *
+sympy_get_value (PyObject *self, PyObject *args)
+{
+  symbol_object *self_sym = (symbol_object *) self;
+
+  switch (SYMBOL_CLASS (self_sym->symbol))
+    {
+    case LOC_BLOCK:
+      return block_to_block_object (SYMBOL_BLOCK_VALUE (self_sym->symbol));
+    }
+
+  PyErr_SetString (PyExc_NotImplementedError,
+		   "Symbol type not yet supported in Python scripts.");
+  return NULL;
+}
+
+static PyObject *
+sympy_get_symtab (PyObject *self, PyObject *args)
+{
+  symbol_object *self_sym = (symbol_object *) self;
+
+  return symtab_to_symtab_object (SYMBOL_SYMTAB (self_sym->symbol));
+}
+
+static PyObject *
+sympy_get_natural_name (PyObject *self, PyObject *args)
+{
+  symbol_object *self_sym = (symbol_object *) self;
+
+  return PyString_FromString (SYMBOL_NATURAL_NAME (self_sym->symbol));
+}
+
+static PyObject *
+sympy_get_linkage_name (PyObject *self, PyObject *args)
+{
+  symbol_object *self_sym = (symbol_object *) self;
+
+  return PyString_FromString (SYMBOL_LINKAGE_NAME (self_sym->symbol));
+}
+
+static PyObject *
+sympy_get_print_name (PyObject *self, PyObject *args)
+{
+  symbol_object *self_sym = (symbol_object *) self;
+
+  return PyString_FromString (SYMBOL_PRINT_NAME (self_sym->symbol));
+}
+
+PyObject *
+symbol_to_symbol_object (struct symbol *sym)
+{
+  symbol_object *sym_obj;
+
+  sym_obj = PyObject_New (symbol_object, &symbol_object_type);
+  if (sym_obj == NULL)
+    {
+      PyErr_SetString (PyExc_MemoryError, "Could not allocate symbol object.");
+      return NULL;
+    }
+
+  sym_obj->symbol = sym;
+
+  return (PyObject *) sym_obj;
+}
+
+void
+gdbpy_initialize_symbols (void)
+{
+  symbol_object_type.tp_new = PyType_GenericNew;
+  if (PyType_Ready (&symbol_object_type) < 0)
+    return;
+
+  Py_INCREF (&symbol_object_type);
+  PyModule_AddObject (gdb_module, "Symbol", (PyObject *) &symbol_object_type);
+}

--- a/gdb/python/symtab.c
+++ b/gdb/python/symtab.c
@@ -259,13 +259,10 @@ symtab_and_line_to_sal_object (struct symtab_and_line sal)
 
   if (sal.symtab)
     {
-      symtab_obj = PyObject_New (symtab_object, &symtab_object_type);
+      symtab_obj = (symtab_object *) symtab_to_symtab_object (sal.symtab);
       if (symtab_obj == NULL)
 	{
-	  PyErr_SetString (PyExc_MemoryError,
-			   "Could not allocate Symtab object.");
 	  Py_DECREF (sal_obj);
-
 	  return NULL;
 	}
 
@@ -285,6 +282,25 @@ symtab_and_line_to_sal_object (struct symtab_and_line sal)
   return (PyObject *) sal_obj;
 }
 
+PyObject *
+symtab_to_symtab_object (struct symtab *symtab)
+{
+  symtab_object *symtab_obj;
+  
+  symtab_obj = PyObject_New (symtab_object, &symtab_object_type);
+  if (symtab_obj == NULL)
+    {
+      PyErr_SetString (PyExc_MemoryError,
+	  "Could not allocate Symtab object.");
+
+      return NULL;
+    }
+
+  symtab_obj->symtab = symtab;
+
+  return (PyObject *) symtab_obj;
+}
+
 void
 gdbpy_initialize_symtabs (void)
 {