/* Python interface to types.
- Copyright (C) 2008-2013 Free Software Foundation, Inc.
+ Copyright (C) 2008-2017 Free Software Foundation, Inc.
This file is part of GDB.
#include "defs.h"
#include "value.h"
-#include "exceptions.h"
#include "python-internal.h"
#include "charset.h"
#include "gdbtypes.h"
#include "objfiles.h"
#include "language.h"
#include "vec.h"
-#include "bcache.h"
-#include "dwarf2loc.h"
#include "typeprint.h"
+#include "py-ref.h"
typedef struct pyty_type_object
{
struct pyty_type_object *next;
} type_object;
-static PyTypeObject type_object_type
+extern PyTypeObject type_object_type
CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("type_object");
/* A Field object. */
PyObject *dict;
} field_object;
-static PyTypeObject field_object_type
+extern PyTypeObject field_object_type
CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("field_object");
/* A type iterator object. */
struct pyty_type_object *source;
} typy_iterator_object;
-static PyTypeObject type_iterator_object_type
+extern PyTypeObject type_iterator_object_type
CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("typy_iterator_object");
/* This is used to initialize various gdb.TYPE_ constants. */
\f
+/* Return true if OBJ is of type gdb.Field, false otherwise. */
+
+int
+gdbpy_is_field (PyObject *obj)
+{
+ return PyObject_TypeCheck (obj, &field_object_type);
+}
+
/* Return the code for this type. */
static PyObject *
typy_get_code (PyObject *self, void *closure)
static PyObject *
convert_field (struct type *type, int field)
{
- PyObject *result = field_new ();
- PyObject *arg;
+ gdbpy_ref result (field_new ());
+
+ if (result == NULL)
+ return NULL;
- if (!result)
+ gdbpy_ref arg (type_to_type_object (type));
+ if (arg == NULL)
+ return NULL;
+ if (PyObject_SetAttrString (result.get (), "parent_type", arg.get ()) < 0)
return NULL;
if (!field_is_static (&TYPE_FIELD (type, field)))
if (TYPE_CODE (type) == TYPE_CODE_ENUM)
{
- arg = gdb_py_long_from_longest (TYPE_FIELD_ENUMVAL (type, field));
+ arg.reset (gdb_py_long_from_longest (TYPE_FIELD_ENUMVAL (type,
+ field)));
attrstring = "enumval";
}
else
{
- arg = gdb_py_long_from_longest (TYPE_FIELD_BITPOS (type, field));
+ arg.reset (gdb_py_long_from_longest (TYPE_FIELD_BITPOS (type,
+ field)));
attrstring = "bitpos";
}
- if (!arg)
- goto fail;
+ if (arg == NULL)
+ return NULL;
/* At least python-2.4 had the second parameter non-const. */
- if (PyObject_SetAttrString (result, (char *) attrstring, arg) < 0)
- goto failarg;
- Py_DECREF (arg);
+ if (PyObject_SetAttrString (result.get (), (char *) attrstring,
+ arg.get ()) < 0)
+ return NULL;
}
+ arg.reset (NULL);
if (TYPE_FIELD_NAME (type, field))
- arg = PyString_FromString (TYPE_FIELD_NAME (type, field));
- else
{
- arg = Py_None;
- Py_INCREF (arg);
+ const char *field_name = TYPE_FIELD_NAME (type, field);
+
+ if (field_name[0] != '\0')
+ {
+ arg.reset (PyString_FromString (TYPE_FIELD_NAME (type, field)));
+ if (arg == NULL)
+ return NULL;
+ }
+ }
+ if (arg == NULL)
+ {
+ arg.reset (Py_None);
+ Py_INCREF (arg.get ());
}
- if (!arg)
- goto fail;
- if (PyObject_SetAttrString (result, "name", arg) < 0)
- goto failarg;
- Py_DECREF (arg);
-
- arg = TYPE_FIELD_ARTIFICIAL (type, field) ? Py_True : Py_False;
- Py_INCREF (arg);
- if (PyObject_SetAttrString (result, "artificial", arg) < 0)
- goto failarg;
- Py_DECREF (arg);
-
- if (TYPE_CODE (type) == TYPE_CODE_CLASS)
- arg = field < TYPE_N_BASECLASSES (type) ? Py_True : Py_False;
+ if (PyObject_SetAttrString (result.get (), "name", arg.get ()) < 0)
+ return NULL;
+
+ arg.reset (TYPE_FIELD_ARTIFICIAL (type, field) ? Py_True : Py_False);
+ Py_INCREF (arg.get ());
+ if (PyObject_SetAttrString (result.get (), "artificial", arg.get ()) < 0)
+ return NULL;
+
+ if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
+ arg.reset (field < TYPE_N_BASECLASSES (type) ? Py_True : Py_False);
else
- arg = Py_False;
- Py_INCREF (arg);
- if (PyObject_SetAttrString (result, "is_base_class", arg) < 0)
- goto failarg;
- Py_DECREF (arg);
-
- arg = PyLong_FromLong (TYPE_FIELD_BITSIZE (type, field));
- if (!arg)
- goto fail;
- if (PyObject_SetAttrString (result, "bitsize", arg) < 0)
- goto failarg;
- Py_DECREF (arg);
+ arg.reset (Py_False);
+ Py_INCREF (arg.get ());
+ if (PyObject_SetAttrString (result.get (), "is_base_class", arg.get ()) < 0)
+ return NULL;
+
+ arg.reset (PyLong_FromLong (TYPE_FIELD_BITSIZE (type, field)));
+ if (arg == NULL)
+ return NULL;
+ if (PyObject_SetAttrString (result.get (), "bitsize", arg.get ()) < 0)
+ return NULL;
/* A field can have a NULL type in some situations. */
if (TYPE_FIELD_TYPE (type, field) == NULL)
{
- arg = Py_None;
- Py_INCREF (arg);
+ arg.reset (Py_None);
+ Py_INCREF (arg.get ());
}
else
- arg = type_to_type_object (TYPE_FIELD_TYPE (type, field));
- if (!arg)
- goto fail;
- if (PyObject_SetAttrString (result, "type", arg) < 0)
- goto failarg;
- Py_DECREF (arg);
-
- return result;
+ arg.reset (type_to_type_object (TYPE_FIELD_TYPE (type, field)));
+ if (arg == NULL)
+ return NULL;
+ if (PyObject_SetAttrString (result.get (), "type", arg.get ()) < 0)
+ return NULL;
- failarg:
- Py_DECREF (arg);
- fail:
- Py_DECREF (result);
- return NULL;
+ return result.release ();
}
/* Helper function to return the name of a field, as a gdb.Field object.
static PyObject *
make_fielditem (struct type *type, int i, enum gdbpy_iter_kind kind)
{
- PyObject *item = NULL, *key = NULL, *value = NULL;
-
switch (kind)
{
case iter_items:
- key = field_name (type, i);
- if (key == NULL)
- goto fail;
- value = convert_field (type, i);
- if (value == NULL)
- goto fail;
- item = PyTuple_New (2);
- if (item == NULL)
- goto fail;
- PyTuple_SET_ITEM (item, 0, key);
- PyTuple_SET_ITEM (item, 1, value);
- break;
+ {
+ gdbpy_ref key (field_name (type, i));
+ if (key == NULL)
+ return NULL;
+ gdbpy_ref value (convert_field (type, i));
+ if (value == NULL)
+ return NULL;
+ gdbpy_ref item (PyTuple_New (2));
+ if (item == NULL)
+ return NULL;
+ PyTuple_SET_ITEM (item.get (), 0, key.release ());
+ PyTuple_SET_ITEM (item.get (), 1, value.release ());
+ return item.release ();
+ }
case iter_keys:
- item = field_name (type, i);
- break;
+ return field_name (type, i);
case iter_values:
- item = convert_field (type, i);
- break;
- default:
- gdb_assert_not_reached ("invalid gdbpy_iter_kind");
+ return convert_field (type, i);
}
- return item;
-
- fail:
- Py_XDECREF (key);
- Py_XDECREF (value);
- Py_XDECREF (item);
- return NULL;
+ gdb_assert_not_reached ("invalid gdbpy_iter_kind");
}
/* Return a sequence of all field names, fields, or (name, field) pairs.
{
PyObject *py_type = self;
PyObject *result = NULL, *iter = NULL;
- volatile struct gdb_exception except;
struct type *type = ((type_object *) py_type)->type;
struct type *checked_type = type;
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
- CHECK_TYPEDEF (checked_type);
+ checked_type = check_typedef (checked_type);
}
- GDB_PY_HANDLE_EXCEPTION (except);
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
if (checked_type != type)
py_type = type_to_type_object (checked_type);
}
/* Return a sequence of all fields. Each field is a gdb.Field object.
- This method is similar to typy_values, except where the supplied
+ This method is similar to typy_values, except where the supplied
gdb.Type is an array, in which case it returns a list of one entry
which is a gdb.Field object for a range (the array bounds). */
typy_fields (PyObject *self, PyObject *args)
{
struct type *type = ((type_object *) self)->type;
- PyObject *r, *rl;
-
+
if (TYPE_CODE (type) != TYPE_CODE_ARRAY)
return typy_fields_items (self, iter_values);
/* Array type. Handle this as a special case because the common
machinery wants struct or union or enum types. Build a list of
one entry which is the range for the array. */
- r = convert_field (type, 0);
+ gdbpy_ref r (convert_field (type, 0));
if (r == NULL)
return NULL;
-
- rl = Py_BuildValue ("[O]", r);
- if (rl == NULL)
- {
- Py_DECREF (r);
- }
- return rl;
+ return Py_BuildValue ("[O]", r.get ());
}
/* Return a sequence of all field names. Each field is a gdb.Field object. */
return typy_fields_items (self, iter_keys);
}
-/* Return a sequence of all (name, fields) pairs. Each field is a
+/* Return a sequence of all (name, fields) pairs. Each field is a
gdb.Field object. */
static PyObject *
return typy_fields_items (self, iter_items);
}
+/* Return the type's name, or None. */
+
+static PyObject *
+typy_get_name (PyObject *self, void *closure)
+{
+ struct type *type = ((type_object *) self)->type;
+
+ if (TYPE_NAME (type) == NULL)
+ Py_RETURN_NONE;
+ return PyString_FromString (TYPE_NAME (type));
+}
+
/* Return the type's tag, or None. */
static PyObject *
typy_get_tag (PyObject *self, void *closure)
typy_strip_typedefs (PyObject *self, PyObject *args)
{
struct type *type = ((type_object *) self)->type;
- volatile struct gdb_exception except;
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
type = check_typedef (type);
}
- GDB_PY_HANDLE_EXCEPTION (except);
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
return type_to_type_object (type);
}
static struct type *
typy_get_composite (struct type *type)
{
- volatile struct gdb_exception except;
for (;;)
{
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
- CHECK_TYPEDEF (type);
+ type = check_typedef (type);
}
- GDB_PY_HANDLE_EXCEPTION (except);
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
if (TYPE_CODE (type) != TYPE_CODE_PTR
&& TYPE_CODE (type) != TYPE_CODE_REF)
/* If this is not a struct, union, or enum type, raise TypeError
exception. */
- if (TYPE_CODE (type) != TYPE_CODE_STRUCT
+ if (TYPE_CODE (type) != TYPE_CODE_STRUCT
&& TYPE_CODE (type) != TYPE_CODE_UNION
- && TYPE_CODE (type) != TYPE_CODE_ENUM)
+ && TYPE_CODE (type) != TYPE_CODE_ENUM
+ && TYPE_CODE (type) != TYPE_CODE_FUNC)
{
PyErr_SetString (PyExc_TypeError,
- "Type is not a structure, union, or enum type.");
+ "Type is not a structure, union, enum, or function type.");
return NULL;
}
-
+
return type;
}
PyObject *n2_obj = NULL;
struct type *array = NULL;
struct type *type = ((type_object *) self)->type;
- volatile struct gdb_exception except;
if (! PyArg_ParseTuple (args, "l|O", &n1, &n2_obj))
return NULL;
n1 = 0;
}
- if (n2 < n1)
+ if (n2 < n1 - 1) /* Note: An empty array has n2 == n1 - 1. */
{
PyErr_SetString (PyExc_ValueError,
_("Array length must not be negative"));
return NULL;
}
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
array = lookup_array_range_type (type, n1, n2);
if (is_vector)
make_vector_type (array);
}
- GDB_PY_HANDLE_EXCEPTION (except);
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
return type_to_type_object (array);
}
typy_pointer (PyObject *self, PyObject *args)
{
struct type *type = ((type_object *) self)->type;
- volatile struct gdb_exception except;
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
type = lookup_pointer_type (type);
}
- GDB_PY_HANDLE_EXCEPTION (except);
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
return type_to_type_object (type);
}
typy_range (PyObject *self, PyObject *args)
{
struct type *type = ((type_object *) self)->type;
- PyObject *result;
- PyObject *low_bound = NULL, *high_bound = NULL;
/* Initialize these to appease GCC warnings. */
LONGEST low = 0, high = 0;
break;
}
- low_bound = PyLong_FromLong (low);
- if (!low_bound)
- goto failarg;
+ gdbpy_ref low_bound (PyLong_FromLong (low));
+ if (low_bound == NULL)
+ return NULL;
- high_bound = PyLong_FromLong (high);
- if (!high_bound)
- goto failarg;
+ gdbpy_ref high_bound (PyLong_FromLong (high));
+ if (high_bound == NULL)
+ return NULL;
- result = PyTuple_New (2);
- if (!result)
- goto failarg;
+ gdbpy_ref result (PyTuple_New (2));
+ if (result == NULL)
+ return NULL;
- if (PyTuple_SetItem (result, 0, low_bound) != 0)
- {
- Py_DECREF (result);
- goto failarg;
- }
- if (PyTuple_SetItem (result, 1, high_bound) != 0)
- {
- Py_DECREF (high_bound);
- Py_DECREF (result);
- return NULL;
- }
- return result;
-
- failarg:
- Py_XDECREF (high_bound);
- Py_XDECREF (low_bound);
- return NULL;
+ if (PyTuple_SetItem (result.get (), 0, low_bound.release ()) != 0
+ || PyTuple_SetItem (result.get (), 1, high_bound.release ()) != 0)
+ return NULL;
+ return result.release ();
}
/* Return a Type object which represents a reference to SELF. */
typy_reference (PyObject *self, PyObject *args)
{
struct type *type = ((type_object *) self)->type;
- volatile struct gdb_exception except;
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
type = lookup_reference_type (type);
}
- GDB_PY_HANDLE_EXCEPTION (except);
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
return type_to_type_object (type);
}
if (!TYPE_TARGET_TYPE (type))
{
- PyErr_SetString (PyExc_RuntimeError,
+ PyErr_SetString (PyExc_RuntimeError,
_("Type does not have a target."));
return NULL;
}
typy_const (PyObject *self, PyObject *args)
{
struct type *type = ((type_object *) self)->type;
- volatile struct gdb_exception except;
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
type = make_cv_type (1, 0, type, NULL);
}
- GDB_PY_HANDLE_EXCEPTION (except);
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
return type_to_type_object (type);
}
typy_volatile (PyObject *self, PyObject *args)
{
struct type *type = ((type_object *) self)->type;
- volatile struct gdb_exception except;
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
type = make_cv_type (0, 1, type, NULL);
}
- GDB_PY_HANDLE_EXCEPTION (except);
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
return type_to_type_object (type);
}
typy_unqualified (PyObject *self, PyObject *args)
{
struct type *type = ((type_object *) self)->type;
- volatile struct gdb_exception except;
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
type = make_cv_type (0, 0, type, NULL);
}
- GDB_PY_HANDLE_EXCEPTION (except);
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
return type_to_type_object (type);
}
typy_get_sizeof (PyObject *self, void *closure)
{
struct type *type = ((type_object *) self)->type;
- volatile struct gdb_exception except;
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
check_typedef (type);
}
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ }
+ END_CATCH
+
/* Ignore exceptions. */
return gdb_py_long_from_longest (TYPE_LENGTH (type));
typy_lookup_typename (const char *type_name, const struct block *block)
{
struct type *type = NULL;
- volatile struct gdb_exception except;
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
- if (!strncmp (type_name, "struct ", 7))
+ if (startswith (type_name, "struct "))
type = lookup_struct (type_name + 7, NULL);
- else if (!strncmp (type_name, "union ", 6))
+ else if (startswith (type_name, "union "))
type = lookup_union (type_name + 6, NULL);
- else if (!strncmp (type_name, "enum ", 5))
+ else if (startswith (type_name, "enum "))
type = lookup_enum (type_name + 5, NULL);
else
type = lookup_typename (python_language, python_gdbarch,
type_name, block, 0);
}
- GDB_PY_HANDLE_EXCEPTION (except);
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
return type;
}
struct type *type, *rtype = NULL;
char *type_name = NULL;
enum demangle_component_type demangled_type;
- volatile struct gdb_exception except;
/* Save the type: typy_lookup_type() may (indirectly) overwrite
memory pointed by demangled. */
if (! type)
return NULL;
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
/* If the demangled_type matches with one of the types
below, run the corresponding function and save the type
break;
}
}
- GDB_PY_HANDLE_EXCEPTION (except);
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
}
-
+
/* If we have a type from the switch statement above, just return
that. */
if (rtype)
return rtype;
-
+
/* We don't have a type, so lookup the type. */
type_name = cp_comp_to_string (demangled, 10);
type = typy_lookup_typename (type_name, block);
const char *err;
struct type *argtype;
struct cleanup *cleanup;
- volatile struct gdb_exception except;
if (TYPE_NAME (type) == NULL)
{
return NULL;
}
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
/* Note -- this is not thread-safe. */
info = cp_demangled_name_to_comp (TYPE_NAME (type), &err);
}
- GDB_PY_HANDLE_EXCEPTION (except);
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
if (! info)
{
PyObject *block_obj = NULL;
struct symbol *sym;
struct value *val = NULL;
- volatile struct gdb_exception except;
if (! PyArg_ParseTuple (args, "i|O", &argno, &block_obj))
return NULL;
}
}
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
type = check_typedef (type);
if (TYPE_CODE (type) == TYPE_CODE_REF)
type = check_typedef (TYPE_TARGET_TYPE (type));
}
- GDB_PY_HANDLE_EXCEPTION (except);
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
/* We might not have DW_TAG_template_*, so try to parse the type's
name. This is inefficient if we do not have a template type --
return NULL;
}
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
val = value_of_variable (sym, block);
}
- GDB_PY_HANDLE_EXCEPTION (except);
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
return value_to_value_object (val);
}
static PyObject *
typy_str (PyObject *self)
{
- volatile struct gdb_exception except;
- char *thetype = NULL;
- long length = 0;
+ std::string thetype;
PyObject *result;
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
struct cleanup *old_chain;
struct ui_file *stb;
LA_PRINT_TYPE (type_object_to_type (self), "", stb, -1, 0,
&type_print_raw_options);
- thetype = ui_file_xstrdup (stb, &length);
+ thetype = ui_file_as_string (stb);
do_cleanups (old_chain);
}
- if (except.reason < 0)
+ CATCH (except, RETURN_MASK_ALL)
{
- xfree (thetype);
GDB_PY_HANDLE_EXCEPTION (except);
}
+ END_CATCH
- result = PyUnicode_Decode (thetype, length, host_charset (), NULL);
- xfree (thetype);
+ result = PyUnicode_Decode (thetype.c_str (), thetype.length (),
+ host_charset (), NULL);
return result;
}
-/* An entry in the type-equality bcache. */
-
-typedef struct type_equality_entry
-{
- struct type *type1, *type2;
-} type_equality_entry_d;
-
-DEF_VEC_O (type_equality_entry_d);
-
-/* A helper function to compare two strings. Returns 1 if they are
- the same, 0 otherwise. Handles NULLs properly. */
-
-static int
-compare_maybe_null_strings (const char *s, const char *t)
-{
- if (s == NULL && t != NULL)
- return 0;
- else if (s != NULL && t == NULL)
- return 0;
- else if (s == NULL && t== NULL)
- return 1;
- return strcmp (s, t) == 0;
-}
-
-/* A helper function for typy_richcompare that checks two types for
- "deep" equality. Returns Py_EQ if the types are considered the
- same, Py_NE otherwise. */
-
-static int
-check_types_equal (struct type *type1, struct type *type2,
- VEC (type_equality_entry_d) **worklist)
-{
- CHECK_TYPEDEF (type1);
- CHECK_TYPEDEF (type2);
-
- if (type1 == type2)
- return Py_EQ;
-
- if (TYPE_CODE (type1) != TYPE_CODE (type2)
- || TYPE_LENGTH (type1) != TYPE_LENGTH (type2)
- || TYPE_UNSIGNED (type1) != TYPE_UNSIGNED (type2)
- || TYPE_NOSIGN (type1) != TYPE_NOSIGN (type2)
- || TYPE_VARARGS (type1) != TYPE_VARARGS (type2)
- || TYPE_VECTOR (type1) != TYPE_VECTOR (type2)
- || TYPE_NOTTEXT (type1) != TYPE_NOTTEXT (type2)
- || TYPE_INSTANCE_FLAGS (type1) != TYPE_INSTANCE_FLAGS (type2)
- || TYPE_NFIELDS (type1) != TYPE_NFIELDS (type2))
- return Py_NE;
-
- if (!compare_maybe_null_strings (TYPE_TAG_NAME (type1),
- TYPE_TAG_NAME (type2)))
- return Py_NE;
- if (!compare_maybe_null_strings (TYPE_NAME (type1), TYPE_NAME (type2)))
- return Py_NE;
-
- if (TYPE_CODE (type1) == TYPE_CODE_RANGE)
- {
- if (memcmp (TYPE_RANGE_DATA (type1), TYPE_RANGE_DATA (type2),
- sizeof (*TYPE_RANGE_DATA (type1))) != 0)
- return Py_NE;
- }
- else
- {
- int i;
-
- for (i = 0; i < TYPE_NFIELDS (type1); ++i)
- {
- const struct field *field1 = &TYPE_FIELD (type1, i);
- const struct field *field2 = &TYPE_FIELD (type2, i);
- struct type_equality_entry entry;
-
- if (FIELD_ARTIFICIAL (*field1) != FIELD_ARTIFICIAL (*field2)
- || FIELD_BITSIZE (*field1) != FIELD_BITSIZE (*field2)
- || FIELD_LOC_KIND (*field1) != FIELD_LOC_KIND (*field2))
- return Py_NE;
- if (!compare_maybe_null_strings (FIELD_NAME (*field1),
- FIELD_NAME (*field2)))
- return Py_NE;
- switch (FIELD_LOC_KIND (*field1))
- {
- case FIELD_LOC_KIND_BITPOS:
- if (FIELD_BITPOS (*field1) != FIELD_BITPOS (*field2))
- return Py_NE;
- break;
- case FIELD_LOC_KIND_ENUMVAL:
- if (FIELD_ENUMVAL (*field1) != FIELD_ENUMVAL (*field2))
- return Py_NE;
- break;
- case FIELD_LOC_KIND_PHYSADDR:
- if (FIELD_STATIC_PHYSADDR (*field1)
- != FIELD_STATIC_PHYSADDR (*field2))
- return Py_NE;
- break;
- case FIELD_LOC_KIND_PHYSNAME:
- if (!compare_maybe_null_strings (FIELD_STATIC_PHYSNAME (*field1),
- FIELD_STATIC_PHYSNAME (*field2)))
- return Py_NE;
- break;
- case FIELD_LOC_KIND_DWARF_BLOCK:
- {
- struct dwarf2_locexpr_baton *block1, *block2;
-
- block1 = FIELD_DWARF_BLOCK (*field1);
- block2 = FIELD_DWARF_BLOCK (*field2);
- if (block1->per_cu != block2->per_cu
- || block1->size != block2->size
- || memcmp (block1->data, block2->data, block1->size) != 0)
- return Py_NE;
- }
- break;
- default:
- internal_error (__FILE__, __LINE__, _("Unsupported field kind "
- "%d by check_types_equal"),
- FIELD_LOC_KIND (*field1));
- }
-
- entry.type1 = FIELD_TYPE (*field1);
- entry.type2 = FIELD_TYPE (*field2);
- VEC_safe_push (type_equality_entry_d, *worklist, &entry);
- }
- }
-
- if (TYPE_TARGET_TYPE (type1) != NULL)
- {
- struct type_equality_entry entry;
-
- if (TYPE_TARGET_TYPE (type2) == NULL)
- return Py_NE;
-
- entry.type1 = TYPE_TARGET_TYPE (type1);
- entry.type2 = TYPE_TARGET_TYPE (type2);
- VEC_safe_push (type_equality_entry_d, *worklist, &entry);
- }
- else if (TYPE_TARGET_TYPE (type2) != NULL)
- return Py_NE;
-
- return Py_EQ;
-}
-
-/* Check types on a worklist for equality. Returns Py_NE if any pair
- is not equal, Py_EQ if they are all considered equal. */
-
-static int
-check_types_worklist (VEC (type_equality_entry_d) **worklist,
- struct bcache *cache)
-{
- while (!VEC_empty (type_equality_entry_d, *worklist))
- {
- struct type_equality_entry entry;
- int added;
-
- entry = *VEC_last (type_equality_entry_d, *worklist);
- VEC_pop (type_equality_entry_d, *worklist);
-
- /* If the type pair has already been visited, we know it is
- ok. */
- bcache_full (&entry, sizeof (entry), cache, &added);
- if (!added)
- continue;
-
- if (check_types_equal (entry.type1, entry.type2, worklist) == Py_NE)
- return Py_NE;
- }
-
- return Py_EQ;
-}
-
/* Implement the richcompare method. */
static PyObject *
int result = Py_NE;
struct type *type1 = type_object_to_type (self);
struct type *type2 = type_object_to_type (other);
- volatile struct gdb_exception except;
/* We can only compare ourselves to another Type object, and only
for equality or inequality. */
result = Py_EQ;
else
{
- struct bcache *cache;
- VEC (type_equality_entry_d) *worklist = NULL;
- struct type_equality_entry entry;
-
- cache = bcache_xmalloc (NULL, NULL);
-
- entry.type1 = type1;
- entry.type2 = type2;
- VEC_safe_push (type_equality_entry_d, worklist, &entry);
-
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
- result = check_types_worklist (&worklist, cache);
+ result = types_deeply_equal (type1, type2);
}
- /* check_types_worklist calls several nested Python helper
- functions, some of which can raise a GDB Exception, so we
- just check and convert here. If there is a GDB exception, a
- comparison is not capable (or trusted), so exit. */
- bcache_xfree (cache);
- VEC_free (type_equality_entry_d, worklist);
- GDB_PY_HANDLE_EXCEPTION (except);
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ /* If there is a GDB exception, a comparison is not capable
+ (or trusted), so exit. */
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
}
- if (op == result)
+ if (op == (result ? Py_EQ : Py_NE))
Py_RETURN_TRUE;
Py_RETURN_FALSE;
}
static void
save_objfile_types (struct objfile *objfile, void *datum)
{
- type_object *obj = datum;
+ type_object *obj = (type_object *) datum;
htab_t copied_types;
- struct cleanup *cleanup;
+
+ if (!gdb_python_initialized)
+ return;
/* This prevents another thread from freeing the objects we're
operating on. */
- cleanup = ensure_python_env (get_objfile_arch (objfile), current_language);
+ gdbpy_enter enter_py (get_objfile_arch (objfile), current_language);
copied_types = create_copied_types_hash (objfile);
}
htab_delete (copied_types);
-
- do_cleanups (cleanup);
}
static void
{
struct objfile *objfile = TYPE_OBJFILE (type);
- obj->next = objfile_data (objfile, typy_objfile_data_key);
+ obj->next = ((struct pyty_type_object *)
+ objfile_data (objfile, typy_objfile_data_key));
if (obj->next)
obj->next->prev = obj;
set_objfile_data (objfile, typy_objfile_data_key, obj);
}
/* Implements boolean evaluation of gdb.Type. Handle this like other
- Python objects that don't have a meaningful truth value -- all
+ Python objects that don't have a meaningful truth value -- all
values are true. */
static int
return 1;
}
+/* Return optimized out value of this type. */
+
+static PyObject *
+typy_optimized_out (PyObject *self, PyObject *args)
+{
+ struct type *type = ((type_object *) self)->type;
+
+ return value_to_value_object (allocate_optimized_out_value (type));
+}
+
/* Return a gdb.Field object for the field named by the argument. */
static PyObject *
typy_getitem (PyObject *self, PyObject *key)
{
struct type *type = ((type_object *) self)->type;
- char *field;
int i;
- field = python_string_to_host_string (key);
+ gdb::unique_xmalloc_ptr<char> field = python_string_to_host_string (key);
if (field == NULL)
return NULL;
- /* We want just fields of this type, not of base types, so instead of
+ /* We want just fields of this type, not of base types, so instead of
using lookup_struct_elt_type, portions of that function are
copied here. */
type = typy_get_composite (type);
if (type == NULL)
return NULL;
-
+
for (i = 0; i < TYPE_NFIELDS (type); i++)
{
const char *t_field_name = TYPE_FIELD_NAME (type, i);
- if (t_field_name && (strcmp_iw (t_field_name, field) == 0))
+ if (t_field_name && (strcmp_iw (t_field_name, field.get ()) == 0))
{
return convert_field (type, i);
}
return NULL;
}
-/* Implement the "get" method on the type object. This is the
+/* Implement the "get" method on the type object. This is the
same as getitem if the key is present, but returns the supplied
default value or None if the key is not found. */
typy_get (PyObject *self, PyObject *args)
{
PyObject *key, *defval = Py_None, *result;
-
+
if (!PyArg_UnpackTuple (args, "get", 1, 2, &key, &defval))
return NULL;
-
+
result = typy_getitem (self, key);
if (result != NULL)
return result;
-
+
/* typy_getitem returned error status. If the exception is
KeyError, clear the exception status and return the defval
instead. Otherwise return the exception unchanged. */
if (!PyErr_ExceptionMatches (PyExc_KeyError))
return NULL;
-
+
PyErr_Clear ();
Py_INCREF (defval);
return defval;
if (!PyArg_ParseTuple (args, "s", &field))
return NULL;
- /* We want just fields of this type, not of base types, so instead of
+ /* We want just fields of this type, not of base types, so instead of
using lookup_struct_elt_type, portions of that function are
copied here. */
/* Check that "self" is a structure or union type. */
if (typy_get_composite (((type_object *) self)->type) == NULL)
return NULL;
-
+
typy_iter_obj = PyObject_New (typy_iterator_object,
&type_iterator_object_type);
if (typy_iter_obj == NULL)
typy_iterator_object *iter_obj = (typy_iterator_object *) self;
struct type *type = iter_obj->source->type;
PyObject *result;
-
+
if (iter_obj->field < TYPE_NFIELDS (type))
{
result = make_fielditem (type, iter_obj->field, iter_obj->kind);
return (PyObject *) type_to_type_object (type);
}
-void
+int
gdbpy_initialize_types (void)
{
int i;
= register_objfile_data_with_cleanup (save_objfile_types, NULL);
if (PyType_Ready (&type_object_type) < 0)
- return;
+ return -1;
if (PyType_Ready (&field_object_type) < 0)
- return;
+ return -1;
if (PyType_Ready (&type_iterator_object_type) < 0)
- return;
+ return -1;
for (i = 0; pyty_codes[i].name; ++i)
{
/* Cast needed for Python 2.4. */
(char *) pyty_codes[i].name,
pyty_codes[i].code) < 0)
- return;
+ return -1;
}
- Py_INCREF (&type_object_type);
- PyModule_AddObject (gdb_module, "Type", (PyObject *) &type_object_type);
+ if (gdb_pymodule_addobject (gdb_module, "Type",
+ (PyObject *) &type_object_type) < 0)
+ return -1;
- Py_INCREF (&type_iterator_object_type);
- PyModule_AddObject (gdb_module, "TypeIterator",
- (PyObject *) &type_iterator_object_type);
+ if (gdb_pymodule_addobject (gdb_module, "TypeIterator",
+ (PyObject *) &type_iterator_object_type) < 0)
+ return -1;
- Py_INCREF (&field_object_type);
- PyModule_AddObject (gdb_module, "Field", (PyObject *) &field_object_type);
+ return gdb_pymodule_addobject (gdb_module, "Field",
+ (PyObject *) &field_object_type);
}
\f
{
{ "code", typy_get_code, NULL,
"The code for this type.", NULL },
+ { "name", typy_get_name, NULL,
+ "The name for this type, or None.", NULL },
{ "sizeof", typy_get_sizeof, NULL,
"The size of this type, in bytes.", NULL },
{ "tag", typy_get_tag, NULL,
{ "const", typy_const, METH_NOARGS,
"const () -> Type\n\
Return a const variant of this type." },
+ { "optimized_out", typy_optimized_out, METH_NOARGS,
+ "optimized_out() -> Value\n\
+Return optimized out value of this type." },
{ "fields", typy_fields, METH_NOARGS,
"fields () -> list\n\
Return a list holding all the fields of this type.\n\
NULL /* no "set" method */
};
-static PyTypeObject type_object_type =
+PyTypeObject type_object_type =
{
PyVarObject_HEAD_INIT (NULL, 0)
"gdb.Type", /*tp_name*/
{ NULL }
};
-static PyTypeObject field_object_type =
+PyTypeObject field_object_type =
{
PyVarObject_HEAD_INIT (NULL, 0)
"gdb.Field", /*tp_name*/
0, /* tp_new */
};
-static PyTypeObject type_iterator_object_type = {
+PyTypeObject type_iterator_object_type = {
PyVarObject_HEAD_INIT (NULL, 0)
"gdb.TypeIterator", /*tp_name*/
sizeof (typy_iterator_object), /*tp_basicsize*/
projects / deliverable / binutils-gdb.git / blobdiff