--- a/gdb/Makefile.in
+++ b/gdb/Makefile.in
@@ -266,6 +266,7 @@ SUBDIR_PYTHON_OBS = \
 	python-function.o \
 	python-hooks.o \
 	python-symbol.o \
+	python-symtab.o \
 	python-utils.o \
 	python-value.o
 SUBDIR_PYTHON_SRCS = \
@@ -277,6 +278,7 @@ SUBDIR_PYTHON_SRCS = \
 	python/python-function.c \
 	python/python-hooks.c \
 	python/python-symbol.c \
+	python/python-symtab.c \
 	python/python-utils.c \
 	python/python-value.c
 SUBDIR_PYTHON_DEPS =
@@ -3474,6 +3476,10 @@ python-symbol.o: $(srcdir)/python/python-symbol.c $(defs_h) \
 	$(symtab_h) $(python_h) $(python_internal_h)
 	$(CC) -c $(INTERNAL_CFLAGS) $(PYTHON_CFLAGS) \
 	  $(srcdir)/python/python-symbol.c -o python-symbol.o
+python-symtab.o: $(srcdir)/python/python-symtab.c $(defs_h) \
+	$(charset_h) $(source_h) $(symtab_h) $(python_h) $(python_internal_h)
+	$(CC) -c $(INTERNAL_CFLAGS) $(PYTHON_CFLAGS) \
+	  $(srcdir)/python/python-symtab.c -o python-symtab.o
 python-utils.o: $(srcdir)/python/python-utils.c $(defs_h) $(python_internal_h)
 	$(CC) -c $(INTERNAL_CFLAGS) $(PYTHON_CFLAGS) \
 	  $(srcdir)/python/python-utils.c -o python-utils.o

--- a/gdb/python/python-frame.c
+++ b/gdb/python/python-frame.c
@@ -56,6 +56,8 @@ static PyObject *frapy_get_pc (PyObject *self, PyObject *args);
 static PyObject *frapy_get_address_in_block (PyObject *self, PyObject *args);
 static PyObject *frapy_get_prev (PyObject *self, PyObject *args);
 static PyObject *frapy_get_next (PyObject *self, PyObject *args);
+static PyObject *frapy_find_sal (PyObject *self, PyObject *args);
+static PyObject *frapy_read_var_value (PyObject *self, PyObject *args);
 
 #define FRAPY_REQUIRE_VALID(frame_obj, frame)			      \
     do {							      \
@@ -84,6 +86,10 @@ static PyMethodDef frame_object_methods[] = {
   { "get_prev", frapy_get_prev, METH_NOARGS,
     "Return the previous (outer) frame." },
   { "get_next", frapy_get_next, METH_NOARGS, "Return the next (inner) frame." },
+  { "find_sal", frapy_find_sal, METH_NOARGS,
+    "Return the frame's symtab and line." },
+  { "read_var_value", frapy_read_var_value, METH_VARARGS,
+    "Return the value of the variable in this frame." },
   {NULL}  /* Sentinel */
 };
 
@@ -402,6 +408,54 @@ frapy_get_next (PyObject *self, PyObject *args)
   return next_obj;
 }
 
+static PyObject *
+frapy_find_sal (PyObject *self, PyObject *args)
+{
+  struct frame_info *frame;
+  struct symtab_and_line sal;
+  volatile struct gdb_exception except;
+  PyObject *sal_obj = NULL;   /* Initialize to appease gcc warning.  */
+
+  TRY_CATCH (except, RETURN_MASK_ALL)
+    {
+      FRAPY_REQUIRE_VALID ((frame_object *) self, frame);
+
+      find_frame_sal (frame, &sal);
+      sal_obj = symtab_and_line_to_sal_object (sal);
+    }
+  GDB_PY_HANDLE_EXCEPTION (except);
+
+  return sal_obj;
+}
+
+static PyObject *
+frapy_read_var_value (PyObject *self, PyObject *args)
+{
+  struct frame_info *frame;
+  PyObject *sym_obj;
+  struct symbol *var;
+  struct value *val = NULL;
+  volatile struct gdb_exception except;
+
+  if (!PyArg_ParseTuple (args, "O!", &symbol_object_type, &sym_obj))
+    return NULL;
+
+  var = symbol_object_to_symbol (sym_obj);
+
+  TRY_CATCH (except, RETURN_MASK_ALL)
+    {
+      FRAPY_REQUIRE_VALID ((frame_object *) self, frame);
+
+      val = read_var_value (var, frame);
+    }
+  GDB_PY_HANDLE_EXCEPTION (except);
+
+  if (val)
+    return value_to_value_object (val);
+
+  Py_RETURN_NONE;
+}
+
 PyObject *
 gdbpy_get_frames (PyObject *self, PyObject *args)
 {

--- a/gdb/python/python-internal.h
+++ b/gdb/python/python-internal.h
@@ -45,6 +45,7 @@ typedef Py_intptr_t Py_ssize_t;
 
 struct block;
 struct symbol;
+struct symtab_and_line;
 struct value;
 
 extern PyObject *gdb_module;
@@ -57,8 +58,11 @@ PyObject *gdbpy_get_breakpoints (PyObject *, PyObject *);
 PyObject *gdbpy_get_frames (PyObject *, PyObject *);
 PyObject *gdbpy_get_current_frame (PyObject *, PyObject *);
 PyObject *gdbpy_frame_stop_reason_string (PyObject *, PyObject *);
+PyObject *gdbpy_lookup_symbol (PyObject *self, PyObject *args);
 PyObject *gdbpy_get_selected_frame (PyObject *self, PyObject *args);
 
+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 *value_to_value_object (struct value *v);
@@ -73,6 +77,7 @@ PyObject *gdbpy_get_hook_function (const char *);
 void gdbpy_initialize_values (void);
 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);

--- a/gdb/python/python-symbol.c
+++ b/gdb/python/python-symbol.c
@@ -28,6 +28,7 @@ typedef struct {
 
 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);
@@ -36,6 +37,8 @@ static PyObject *sympy_get_class (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,
@@ -115,6 +118,14 @@ sympy_get_value (PyObject *self, PyObject *args)
 }
 
 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;

--- /dev/null
+++ b/gdb/python/python-symtab.c
@@ -0,0 +1,324 @@
+/* Python interface to symbol tables.
+
+   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 "charset.h"
+#include "symtab.h"
+#include "source.h"
+#include "python-internal.h"
+
+typedef struct {
+  PyObject_HEAD
+  struct symtab *symtab;
+} symtab_object;
+
+static PyObject *stpy_str (PyObject *self);
+static PyObject *stpy_filename (PyObject *self, PyObject *args);
+static PyObject *stpy_to_fullname (PyObject *self, PyObject *args);
+
+static PyMethodDef symtab_object_methods[] = {
+  { "get_filename", stpy_filename, METH_NOARGS,
+    "Return the symtab's source filename." },
+  { "to_fullname", stpy_to_fullname, METH_NOARGS,
+    "Return the symtab's full source filename." },
+  {NULL}  /* Sentinel */
+};
+
+static PyTypeObject symtab_object_type = {
+  PyObject_HEAD_INIT (NULL)
+  0,				  /*ob_size*/
+  "gdb.Symtab",			  /*tp_name*/
+  sizeof (symtab_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*/
+  stpy_str,			  /*tp_str*/
+  0,				  /*tp_getattro*/
+  0,				  /*tp_setattro*/
+  0,				  /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT,		  /*tp_flags*/
+  "GDB symtab object",		  /* tp_doc */
+  0,				  /* tp_traverse */
+  0,				  /* tp_clear */
+  0,				  /* tp_richcompare */
+  0,				  /* tp_weaklistoffset */
+  0,				  /* tp_iter */
+  0,				  /* tp_iternext */
+  symtab_object_methods		  /* tp_methods */
+};
+
+typedef struct {
+  PyObject_HEAD
+  symtab_object *symtab;
+  struct symtab_and_line *sal;
+} sal_object;
+
+static void salpy_dealloc (PyObject *self);
+static int salpy_setsymtab (PyObject *self, PyObject *value, void *closure);
+static PyObject *salpy_str (PyObject *self);
+static PyObject *salpy_getsymtab (PyObject *self, void *closure);
+static PyObject *salpy_pc (PyObject *self, PyObject *args);
+static PyObject *salpy_line (PyObject *self, PyObject *args);
+
+static PyGetSetDef sal_object_getseters[] = {
+  { "symtab", salpy_getsymtab, salpy_setsymtab, "Symtab object.", NULL },
+  {NULL}  /* Sentinel */
+};
+
+static PyMethodDef sal_object_methods[] = {
+  { "get_pc", salpy_pc, METH_NOARGS,
+    "Return the symtab_and_line's pc." },
+  { "get_line", salpy_line, METH_NOARGS,
+    "Return the symtab_and_line's line." },
+  {NULL}  /* Sentinel */
+};
+
+static PyTypeObject sal_object_type = {
+  PyObject_HEAD_INIT (NULL)
+  0,				  /*ob_size*/
+  "gdb.Symtab_and_line",	  /*tp_name*/
+  sizeof (sal_object),		  /*tp_basicsize*/
+  0,				  /*tp_itemsize*/
+  salpy_dealloc,		  /*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*/
+  salpy_str,			  /*tp_str*/
+  0,				  /*tp_getattro*/
+  0,				  /*tp_setattro*/
+  0,				  /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT,		  /*tp_flags*/
+  "GDB symtab_and_line object",	  /* tp_doc */
+  0,				  /* tp_traverse */
+  0,				  /* tp_clear */
+  0,				  /* tp_richcompare */
+  0,				  /* tp_weaklistoffset */
+  0,				  /* tp_iter */
+  0,				  /* tp_iternext */
+  sal_object_methods,		  /* tp_methods */
+  0,				  /* tp_members */
+  sal_object_getseters		  /* tp_getset */
+};
+
+
+static PyObject *
+stpy_str (PyObject *self)
+{
+  int ret;
+  char *s;
+  PyObject *result;
+
+  ret = asprintf (&s, "symbol table for %s",
+		  ((symtab_object *) self)->symtab->filename);
+  if (ret < 0)
+    Py_RETURN_NONE;
+
+  result = PyString_FromString (s);
+  xfree (s);
+
+  return result;
+}
+
+/* FIXME: maybe this should be an attribute instead of a method?  */
+static PyObject *
+stpy_filename (PyObject *self, PyObject *args)
+{
+  symtab_object *self_symtab = (symtab_object *) self;
+  PyObject *str_obj;
+
+  /* FIXME: Can symtab->filename really be NULL?  */
+  if (self_symtab->symtab->filename)
+    str_obj = PyString_Decode (self_symtab->symtab->filename,
+			       strlen (self_symtab->symtab->filename),
+			       host_charset (), NULL);
+  else
+    {
+      str_obj = Py_None;
+      Py_INCREF (Py_None);
+    }
+
+  return str_obj;
+}
+
+static PyObject *
+stpy_to_fullname (PyObject *self, PyObject *args)
+{
+  char *fullname;
+
+  fullname = symtab_to_fullname (((symtab_object *) self)->symtab);
+  if (fullname)
+    return PyString_Decode (fullname, strlen (fullname), host_charset (), NULL);
+
+  Py_RETURN_NONE;
+}
+
+static PyObject *
+salpy_str (PyObject *self)
+{
+  int ret;
+  char *s, *filename;
+  sal_object *sal_obj;
+  PyObject *result;
+
+  sal_obj = (sal_object *) self;
+  filename = (sal_obj->symtab == (symtab_object *) Py_None)? "<unknown>" :
+					   sal_obj->symtab->symtab->filename;
+  ret = asprintf (&s, "symbol and line for %s, line %d", filename,
+		  sal_obj->sal->line);
+  if (ret < 0)
+    Py_RETURN_NONE;
+
+  result = PyString_FromString (s);
+  xfree (s);
+
+  return result;
+}
+
+static PyObject *
+salpy_pc (PyObject *self, PyObject *args)
+{
+  return PyLong_FromUnsignedLongLong (((sal_object *) self)->sal->pc);
+}
+
+static PyObject *
+salpy_line (PyObject *self, PyObject *args)
+{
+  return PyLong_FromUnsignedLongLong (((sal_object *) self)->sal->line);
+}
+
+static PyObject *
+salpy_getsymtab (PyObject *self, void *closure)
+{
+  sal_object *self_sal = (sal_object *) self;
+
+  Py_INCREF (self_sal->symtab);
+
+  return (PyObject *) self_sal->symtab;
+}
+
+static int
+salpy_setsymtab (PyObject *self, PyObject *value, void *closure)
+{
+  PyErr_SetString (PyExc_TypeError, "The symtab attribute can't be modified.");
+
+  return -1;
+}
+
+static void 
+salpy_dealloc (PyObject *self)
+{
+  sal_object *self_sal = (sal_object *) self;
+
+  Py_DECREF (self_sal->symtab);
+  xfree (self_sal->sal);
+  self_sal->ob_type->tp_free (self);
+}
+
+PyObject *
+symtab_and_line_to_sal_object (struct symtab_and_line sal)
+{
+  sal_object *sal_obj;
+  symtab_object *symtab_obj;
+
+  sal_obj = PyObject_New (sal_object, &sal_object_type);
+  if (sal_obj == NULL)
+    {
+      PyErr_SetString (PyExc_MemoryError,
+		       "Could not allocate Symtab_and_line object.");
+      return NULL;
+    }
+
+  if (sal.symtab)
+    {
+      symtab_obj = (symtab_object *) symtab_to_symtab_object (sal.symtab);
+      if (symtab_obj == NULL)
+	{
+	  Py_DECREF (sal_obj);
+	  return NULL;
+	}
+
+      symtab_obj->symtab = sal.symtab;
+    }
+  else
+    {
+      symtab_obj = (symtab_object *) Py_None;
+      Py_INCREF (Py_None);
+    }
+
+  sal_obj->sal = (struct symtab_and_line *)
+				    xmalloc (sizeof (struct symtab_and_line));
+  *(sal_obj->sal) = sal;
+  sal_obj->symtab = symtab_obj;
+
+  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)
+{
+  symtab_object_type.tp_new = PyType_GenericNew;
+  if (PyType_Ready (&symtab_object_type) < 0)
+    return;
+
+  sal_object_type.tp_new = PyType_GenericNew;
+  if (PyType_Ready (&sal_object_type) < 0)
+    return;
+
+  Py_INCREF (&symtab_object_type);
+  PyModule_AddObject (gdb_module, "Symtab", (PyObject *) &symtab_object_type);
+
+  Py_INCREF (&sal_object_type);
+  PyModule_AddObject (gdb_module, "Symtab_and_line",
+		      (PyObject *) &sal_object_type);
+}

--- a/gdb/python/python.c
+++ b/gdb/python/python.c
@@ -39,6 +39,9 @@ static int gdbpy_should_print_stack = 1;
 #include "solib.h"
 #include "exceptions.h"
 #include "python-internal.h"
+#include "linespec.h"
+#include "symtab.h"
+#include "source.h"
 #include "version.h"
 #include "target.h"
 #include "gdbthread.h"
@@ -49,6 +52,7 @@ PyObject *gdb_module;
 static PyObject *get_show_variable (PyObject *, PyObject *);
 static PyObject *execute_gdb_command (PyObject *, PyObject *);
 static PyObject *gdbpy_solib_address (PyObject *, PyObject *);
+static PyObject *gdbpy_decode_line (PyObject *, PyObject *);
 static PyObject *gdbpy_find_pc_function (PyObject *, PyObject *);
 static PyObject *gdbpy_write (PyObject *, PyObject *);
 static PyObject *gdbpy_flush (PyObject *, PyObject *);
@@ -74,12 +78,19 @@ static PyMethodDef GdbMethods[] =
   { "frame_stop_reason_string", gdbpy_frame_stop_reason_string,
     METH_VARARGS, "Return a string explaining unwind stop reason" },
 
+  { "lookup_symbol", gdbpy_lookup_symbol, METH_VARARGS,
+    "Return the symbol corresponding to the given name, or None." },
   { "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\
+Note: may later change to return an object." },
+
   { "write", gdbpy_write, METH_VARARGS,
     "Write a string using gdb's filtered stream." },
   { "flush", gdbpy_flush, METH_NOARGS,
@@ -328,6 +339,80 @@ gdbpy_find_pc_function (PyObject *self, PyObject *args)
   Py_RETURN_NONE;
 }
 
+/* A Python function which is a wrapper for decode_line_1.  */
+
+static PyObject *
+gdbpy_decode_line (PyObject *self, PyObject *args)
+{
+  struct symtabs_and_lines sals = { NULL, 0 }; /* Initialize to appease gcc.  */
+  struct symtab_and_line sal;
+  char *arg = NULL;
+  int free_sals = 0, i;
+  PyObject *result = NULL;
+  volatile struct gdb_exception except;
+
+  if (! PyArg_ParseTuple (args, "|s", &arg))
+    return NULL;
+
+  TRY_CATCH (except, RETURN_MASK_ALL)
+    {
+      if (arg)
+	{
+	  char *copy;
+
+	  arg = strdup (arg);
+	  copy = arg;
+
+	  sals = decode_line_1 (&copy, 0, 0, 0, 0, 0);
+	  free_sals = 1;
+	}
+      else
+	{
+	  set_default_source_symtab_and_line ();
+	  sal = get_current_source_symtab_and_line ();
+	  sals.sals = &sal;
+	  sals.nelts = 1;
+	}
+    }
+  if (arg)
+    xfree (arg);
+
+  if (except.reason < 0)
+    {
+      if (free_sals)
+	xfree (sals.sals);
+      /* We know this will always throw.  */
+      GDB_PY_HANDLE_EXCEPTION (except);
+    }
+
+  if (sals.nelts)
+    {
+      result = PyTuple_New (sals.nelts);
+      for (i = 0; i < sals.nelts; ++i)
+	{
+	  PyObject *obj;
+	  char *str;
+
+	  obj = symtab_and_line_to_sal_object (sals.sals[i]);
+	  if (! obj)
+	    {
+	      Py_DECREF (result);
+	      result = NULL;
+	      break;
+	    }
+
+	  PyTuple_SetItem (result, i, obj);
+	}
+    }
+
+  if (free_sals)
+    xfree (sals.sals);
+
+  if (result)
+    return result;
+  Py_RETURN_NONE;
+}
+
 
 
 /* Printing.  */
@@ -472,6 +557,7 @@ Enables or disables printing of Python stack traces."),
   gdbpy_initialize_values ();
   gdbpy_initialize_breakpoints ();
   gdbpy_initialize_frames ();
+  gdbpy_initialize_symtabs ();
   gdbpy_initialize_commands ();
   gdbpy_initialize_symbols ();
   gdbpy_initialize_blocks ();