--- a/gdb/Makefile.in
+++ b/gdb/Makefile.in
@@ -3416,7 +3416,7 @@ python-cmd.o: $(srcdir)/python/cmd.c $(defs_h) $(python_h) $(value_h) \
 	$(srcdir)/python/cmd.c -o python-cmd.o
 python-frame.o: $(srcdir)/python/frame.c $(defs_h)  $(python_h) \
 	$(python_internal_h) $(frame_h) $(exceptions_h) $(symtab_h) \
-	$(charset_h) $(stack_h)
+	$(charset_h) $(stack_h) $(value_h)
 	$(CC) -c $(INTERNAL_CFLAGS) $(PYTHON_CFLAGS) \
 	$(srcdir)/python/frame.c -o python-frame.o
 python-hooks.o: $(srcdir)/python/hooks.c $(defs_h) $(cli_decode_h) \

--- a/gdb/python/block.c
+++ b/gdb/python/block.c
@@ -49,7 +49,7 @@ static PyMethodDef block_object_methods[] = {
   {NULL}  /* Sentinel */
 };
 
-static PyTypeObject block_object_type = {
+PyTypeObject block_object_type = {
   PyObject_HEAD_INIT (NULL)
   0,				  /*ob_size*/
   "gdb.Block",			  /*tp_name*/
@@ -209,6 +209,12 @@ block_to_block_object (struct block *block)
   return (PyObject *) block_obj;
 }
 
+struct block *
+block_object_to_block (PyObject *obj)
+{
+  return ((block_object *) obj)->block;
+}
+
 static PyObject *
 blpy_block_syms_iter (PyObject *self)
 {

--- a/gdb/python/frame.c
+++ b/gdb/python/frame.c
@@ -23,6 +23,7 @@
 #include "exceptions.h"
 #include "symtab.h"
 #include "stack.h"
+#include "value.h"
 #include "python-internal.h"
 
 typedef struct {
@@ -56,6 +57,7 @@ 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 {							      \
@@ -86,6 +88,8 @@ static PyMethodDef frame_object_methods[] = {
   { "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 */
 };
 
@@ -425,6 +429,34 @@ frapy_find_sal (PyObject *self, PyObject *args)
   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_frames (PyObject *self, PyObject *args)
 {

--- a/gdb/python/python-internal.h
+++ b/gdb/python/python-internal.h
@@ -27,6 +27,9 @@
 #endif
 
 extern PyObject *gdb_module;
+extern PyTypeObject block_object_type;
+extern PyTypeObject value_object_type;
+extern PyTypeObject symbol_object_type;
 
 PyObject *gdb_value_from_int (PyObject *self, PyObject *args);
 PyObject *gdb_value_from_history (PyObject *self, PyObject *args);
@@ -34,6 +37,7 @@ PyObject *gdbpy_breakpoints (PyObject *, PyObject *);
 PyObject *gdbpy_frames (PyObject *, PyObject *);
 PyObject *gdbpy_current_frame (PyObject *, PyObject *);
 PyObject *gdbpy_frame_stop_reason_string (PyObject *, PyObject *);
+PyObject *gdbpy_lookup_symbol (PyObject *self, PyObject *args);
 
 PyObject *value_from_value (struct value *v);
 PyObject *variable_to_python (struct cmd_list_element *);
@@ -41,8 +45,11 @@ 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);
 
-struct value *gdb_value_from_py_value (PyObject *self);
+struct block *block_object_to_block (PyObject *obj);
+struct symbol *symbol_object_to_symbol (PyObject *obj);
+struct value *value_object_to_value (PyObject *self);
 
 PyObject *gdbpy_get_hook_function (const char *);
 
@@ -70,6 +77,4 @@ void gdbpy_initialize_blocks (void);
 void gdbpy_breakpoint_created (int);
 void gdbpy_breakpoint_deleted (int);
 
-extern PyTypeObject value_object_type;
-
 #endif /* GDB_PYTHON_INTERNAL_H */

--- a/gdb/python/python.c
+++ b/gdb/python/python.c
@@ -79,6 +79,8 @@ demand_python ()
 	{ "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." },
 
@@ -215,7 +217,7 @@ list_varobj_children (struct varobj *var, const char *function)
 	  if (!PyObject_IsInstance (py_v, (PyObject *)&value_object_type))
 	    error ("child list has object of invalid type");
 
-	  v = gdb_value_from_py_value (py_v);
+	  v = value_object_to_value (py_v);
 	  
 	  varobj_add_child (var, name, v);
 	}      

--- a/gdb/python/symbol.c
+++ b/gdb/python/symbol.c
@@ -32,6 +32,7 @@ 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 PyObject *sympy_get_class (PyObject *self, PyObject *args);
 
 static PyMethodDef symbol_object_methods[] = {
   { "get_value", sympy_get_value, METH_NOARGS,
@@ -44,10 +45,12 @@ static PyMethodDef symbol_object_methods[] = {
     "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." },
+  { "get_class", sympy_get_class, METH_NOARGS,
+    "Return the class of the symbol." },
   {NULL}  /* Sentinel */
 };
 
-static PyTypeObject symbol_object_type = {
+PyTypeObject symbol_object_type = {
   PyObject_HEAD_INIT (NULL)
   0,				  /*ob_size*/
   "gdb.Symbol",			  /*tp_name*/
@@ -146,6 +149,14 @@ sympy_get_print_name (PyObject *self, PyObject *args)
   return PyString_FromString (SYMBOL_PRINT_NAME (self_sym->symbol));
 }
 
+static PyObject *
+sympy_get_class (PyObject *self, PyObject *args)
+{
+  symbol_object *self_sym = (symbol_object *) self;
+
+  return PyInt_FromLong (SYMBOL_CLASS (self_sym->symbol));
+}
+
 PyObject *
 symbol_to_symbol_object (struct symbol *sym)
 {
@@ -163,6 +174,79 @@ symbol_to_symbol_object (struct symbol *sym)
   return (PyObject *) sym_obj;
 }
 
+struct symbol *
+symbol_object_to_symbol (PyObject *obj)
+{
+  return ((symbol_object *) obj)->symbol;
+}
+
+/* This function has less arguments than its C counterpart, to simplify the
+   Python interface: name, block and domain. The other two arguments are always
+   assumed to be set, and a tuple with 3 elements is always returned. The first
+   is the symbol object or None, the second is a boolean with the value of
+   is_a_field_of_this, and the third is the symbol object or None.  */
+PyObject *gdbpy_lookup_symbol (PyObject *self, PyObject *args)
+{
+  int domain, is_a_field_of_this = 0;
+  const char *name;
+  struct symbol *symbol;
+  struct symtab *symtab;
+  PyObject *block_obj, *ret_tuple, *sym_obj, *symtab_obj, *bool_obj;
+
+  PyArg_ParseTuple (args, "sO!i", &name, &block_object_type, &block_obj,
+		    &domain);
+
+  symbol = lookup_symbol (name, block_object_to_block (block_obj), domain,
+			  &is_a_field_of_this, &symtab);
+
+  ret_tuple = PyTuple_New (3);
+  if (!ret_tuple)
+    {
+      PyErr_SetString (PyExc_MemoryError, "Could not allocate tuple object.");
+      return NULL;
+    }
+
+  if (symbol)
+    {
+      sym_obj = symbol_to_symbol_object (symbol);
+      if (!sym_obj)
+	{
+	  Py_DECREF (ret_tuple);
+	  return NULL;
+	}
+    }
+  else
+    {
+      sym_obj = Py_None;
+      Py_INCREF (Py_None);
+    }
+  PyTuple_SET_ITEM (ret_tuple, 0, sym_obj);
+
+  bool_obj = is_a_field_of_this? Py_True : Py_False;
+  Py_INCREF (bool_obj);
+  PyTuple_SET_ITEM (ret_tuple, 1, bool_obj);
+
+  if (symtab)
+    {
+      symtab_obj = symtab_to_symtab_object (symtab);
+      if (!symtab_obj)
+	{
+	  /* I *think* this will take care of decref'ing sym_obj and
+	     bool_obj.  */
+	  Py_DECREF (ret_tuple);
+	  return NULL;
+	}
+    }
+  else
+    {
+      symtab_obj = Py_None;
+      Py_INCREF (Py_None);
+    }
+  PyTuple_SET_ITEM (ret_tuple, 2, symtab_obj);
+
+  return ret_tuple;
+}
+
 void
 gdbpy_initialize_symbols (void)
 {
@@ -170,6 +254,49 @@ gdbpy_initialize_symbols (void)
   if (PyType_Ready (&symbol_object_type) < 0)
     return;
 
+  /* FIXME: These would probably be best exposed as class attributes of Symbol,
+     but I don't know how to do it except by messing with the type's dictionary.
+     That seems too messy.  */
+  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_UNDEF", LOC_UNDEF);
+  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_CONST", LOC_CONST);
+  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_STATIC", LOC_STATIC);
+  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REGISTER", LOC_REGISTER);
+  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_ARG", LOC_ARG);
+  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REF_ARG", LOC_REF_ARG);
+  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REGPARM", LOC_REGPARM);
+  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REGPARM_ADDR",
+			   LOC_REGPARM_ADDR);
+  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_LOCAL", LOC_LOCAL);
+  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_TYPEDEF", LOC_TYPEDEF);
+  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_LABEL", LOC_LABEL);
+  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_BLOCK", LOC_BLOCK);
+  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_CONST_BYTES",
+			   LOC_CONST_BYTES);
+  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_LOCAL_ARG", LOC_LOCAL_ARG);
+  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_BASEREG", LOC_BASEREG);
+  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_BASEREG_ARG",
+			   LOC_BASEREG_ARG);
+  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_UNRESOLVED", LOC_UNRESOLVED);
+  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_HP_THREAD_LOCAL_STATIC",
+			   LOC_HP_THREAD_LOCAL_STATIC);
+  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_OPTIMIZED_OUT",
+			   LOC_OPTIMIZED_OUT);
+  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_INDIRECT", LOC_INDIRECT);
+  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_COMPUTED", LOC_COMPUTED);
+  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_COMPUTED_ARG",
+			   LOC_COMPUTED_ARG);
+
+  PyModule_AddIntConstant (gdb_module, "SYMBOL_UNDEF_DOMAIN", UNDEF_DOMAIN);
+  PyModule_AddIntConstant (gdb_module, "SYMBOL_VAR_DOMAIN", VAR_DOMAIN);
+  PyModule_AddIntConstant (gdb_module, "SYMBOL_STRUCT_DOMAIN", STRUCT_DOMAIN);
+  PyModule_AddIntConstant (gdb_module, "SYMBOL_LABEL_DOMAIN", LABEL_DOMAIN);
+  PyModule_AddIntConstant (gdb_module, "SYMBOL_VARIABLES_DOMAIN",
+			   VARIABLES_DOMAIN);
+  PyModule_AddIntConstant (gdb_module, "SYMBOL_FUNCTIONS_DOMAIN",
+			   FUNCTIONS_DOMAIN);
+  PyModule_AddIntConstant (gdb_module, "SYMBOL_TYPES_DOMAIN", TYPES_DOMAIN);
+  PyModule_AddIntConstant (gdb_module, "SYMBOL_METHODS_DOMAIN", METHODS_DOMAIN);
+
   Py_INCREF (&symbol_object_type);
   PyModule_AddObject (gdb_module, "Symbol", (PyObject *) &symbol_object_type);
 }

--- a/gdb/python/value.c
+++ b/gdb/python/value.c
@@ -41,6 +41,7 @@ static PyObject *valpy_increment (PyObject *self, PyObject *args);
 static PyObject *valpy_equal_p (PyObject *self, PyObject *args);
 static PyObject * valpy_lazy_p (PyObject *self, PyObject *args);
 static PyObject * valpy_fetch_lazy (PyObject *self, PyObject *args);
+static PyObject * valpy_common_print (PyObject *self, PyObject *args);
 
 static PyMethodDef value_object_methods[] = {
   { "dereference", valpy_dereference, METH_NOARGS, "Dereferences the value." },
@@ -52,6 +53,7 @@ static PyMethodDef value_object_methods[] = {
     "Returns True if the value is lazy, False if not." },
   { "fetch_lazy", valpy_fetch_lazy, METH_NOARGS,
     "Fetches value from inferior memory." },
+  { "common_print", valpy_common_print, METH_VARARGS, "Prints value." },
   {NULL}  /* Sentinel */
 };
 
@@ -254,6 +256,50 @@ valpy_fetch_lazy (PyObject *self, PyObject *args)
   Py_RETURN_NONE;
 }
 
+static PyObject *
+valpy_common_print (PyObject *self, PyObject *args)
+{
+  value_object *self_value = (value_object *) self;
+  int ret = 0, format, recurse, pretty;
+  PyObject *format_obj, *deref_obj;
+  struct ui_stream *stb;
+  struct cleanup *chain;
+  volatile struct gdb_exception except;
+
+  if (!PyArg_ParseTuple (args, "OO!ii", &format_obj, &PyBool_Type, &deref_obj,
+			 &recurse, &pretty))
+    return NULL;
+
+  if (format_obj == Py_None)
+    format = 0;
+  else
+    {
+      if (!PyString_Check (format_obj) || PyString_Size (format_obj) != 1)
+	{
+	  PyErr_SetString (PyExc_TypeError, "Argument 1 must be char or None.");
+	  return NULL;
+	}
+
+      format = *PyString_AsString (format_obj);
+    }
+
+  stb = ui_out_stream_new (uiout);
+  chain = make_cleanup_ui_out_stream_delete (stb);
+
+  TRY_CATCH (except, RETURN_MASK_ALL)
+    {
+      ret = common_val_print (self_value->value, stb->stream, format,
+			      deref_obj == Py_True, recurse, pretty);
+      /* FIXME: should I really use ui_out_field_stream?  */
+      ui_out_field_stream (uiout, "value", stb);
+    }
+  GDB_PY_HANDLE_EXCEPTION (except);
+
+  do_cleanups (chain);
+
+  return PyInt_FromLong (ret);
+}
+
 /* FIXME: clarify the naming to say the value
    won't be deleted by the Python code.  */
 PyObject *
@@ -271,6 +317,14 @@ value_from_value (struct value *v)
 }
 
 PyObject *
+value_to_value_object (struct value *v)
+{
+  value_object *val_obj;
+
+  VALPY_RETURN_VALUE (val_obj, v);
+}
+
+PyObject *
 gdb_value_from_int (PyObject *self, PyObject *args)
 {
   int i;
@@ -324,7 +378,7 @@ gdbpy_initialize_values (void)
 }
 
 struct value *
-gdb_value_from_py_value (PyObject *self)
+value_object_to_value (PyObject *self)
 {
   value_object *real = (value_object *)self;
   return real->value;

--- a/gdb/varobj.c
+++ b/gdb/varobj.c
@@ -887,7 +887,7 @@ int update_dynamic_varobj_children (struct varobj *var,
       if (!PyObject_IsInstance (py_v, (PyObject *)&value_object_type))
 	error ("child list has object of invalid type");
       
-      v = gdb_value_from_py_value (py_v);
+      v = value_object_to_value (py_v);
 
       /* TODO: This assume the name of the i-th child never changes.  */