gdb/python/py-type.c

   1 /* Python interface to types.
   2
   3    Copyright (C) 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "value.h"
  22 #include "exceptions.h"
  23 #include "python-internal.h"
  24 #include "charset.h"
  25 #include "gdbtypes.h"
  26 #include "cp-support.h"
  27 #include "demangle.h"
  28 #include "objfiles.h"
  29 #include "language.h"
  30 #include "vec.h"
  31 #include "bcache.h"
  32
  33 typedef struct pyty_type_object
  34 {
  35   PyObject_HEAD
  36   struct type *type;
  37
  38   /* If a Type object is associated with an objfile, it is kept on a
  39      doubly-linked list, rooted in the objfile.  This lets us copy the
  40      underlying struct type when the objfile is deleted.  */
  41   struct pyty_type_object *prev;
  42   struct pyty_type_object *next;
  43 } type_object;
  44
  45 static PyTypeObject type_object_type;
  46
  47 /* A Field object.  */
  48 typedef struct pyty_field_object
  49 {
  50   PyObject_HEAD
  51
  52   /* Dictionary holding our attributes.  */
  53   PyObject *dict;
  54 } field_object;
  55
  56 static PyTypeObject field_object_type;
  57
  58 /* This is used to initialize various gdb.TYPE_ constants.  */
  59 struct pyty_code
  60 {
  61   /* The code.  */
  62   enum type_code code;
  63   /* The name.  */
  64   const char *name;
  65 };
  66
  67 #define ENTRY(X) { X, #X }
  68
  69 static struct pyty_code pyty_codes[] =
  70 {
  71   ENTRY (TYPE_CODE_PTR),
  72   ENTRY (TYPE_CODE_ARRAY),
  73   ENTRY (TYPE_CODE_STRUCT),
  74   ENTRY (TYPE_CODE_UNION),
  75   ENTRY (TYPE_CODE_ENUM),
  76   ENTRY (TYPE_CODE_FLAGS),
  77   ENTRY (TYPE_CODE_FUNC),
  78   ENTRY (TYPE_CODE_INT),
  79   ENTRY (TYPE_CODE_FLT),
  80   ENTRY (TYPE_CODE_VOID),
  81   ENTRY (TYPE_CODE_SET),
  82   ENTRY (TYPE_CODE_RANGE),
  83   ENTRY (TYPE_CODE_STRING),
  84   ENTRY (TYPE_CODE_BITSTRING),
  85   ENTRY (TYPE_CODE_ERROR),
  86   ENTRY (TYPE_CODE_METHOD),
  87   ENTRY (TYPE_CODE_METHODPTR),
  88   ENTRY (TYPE_CODE_MEMBERPTR),
  89   ENTRY (TYPE_CODE_REF),
  90   ENTRY (TYPE_CODE_CHAR),
  91   ENTRY (TYPE_CODE_BOOL),
  92   ENTRY (TYPE_CODE_COMPLEX),
  93   ENTRY (TYPE_CODE_TYPEDEF),
  94   ENTRY (TYPE_CODE_NAMESPACE),
  95   ENTRY (TYPE_CODE_DECFLOAT),
  96   ENTRY (TYPE_CODE_INTERNAL_FUNCTION),
  97   { TYPE_CODE_UNDEF, NULL }
  98 };
  99
 100 \f
 101
 102 static void
 103 field_dealloc (PyObject *obj)
 104 {
 105   field_object *f = (field_object *) obj;
 106
 107   Py_XDECREF (f->dict);
 108   f->ob_type->tp_free (obj);
 109 }
 110
 111 static PyObject *
 112 field_new (void)
 113 {
 114   field_object *result = PyObject_New (field_object, &field_object_type);
 115
 116   if (result)
 117     {
 118       result->dict = PyDict_New ();
 119       if (!result->dict)
 120         {
 121           Py_DECREF (result);
 122           result = NULL;
 123         }
 124     }
 125   return (PyObject *) result;
 126 }
 127
 128 \f
 129
 130 /* Return the code for this type.  */
 131 static PyObject *
 132 typy_get_code (PyObject *self, void *closure)
 133 {
 134   struct type *type = ((type_object *) self)->type;
 135
 136   return PyInt_FromLong (TYPE_CODE (type));
 137 }
 138
 139 /* Helper function for typy_fields which converts a single field to a
 140    dictionary.  Returns NULL on error.  */
 141 static PyObject *
 142 convert_field (struct type *type, int field)
 143 {
 144   PyObject *result = field_new ();
 145   PyObject *arg;
 146
 147   if (!result)
 148     return NULL;
 149
 150   if (!field_is_static (&TYPE_FIELD (type, field)))
 151     {
 152       arg = PyLong_FromLong (TYPE_FIELD_BITPOS (type, field));
 153       if (!arg)
 154         goto fail;
 155
 156       if (PyObject_SetAttrString (result, "bitpos", arg) < 0)
 157         goto failarg;
 158     }
 159
 160   if (TYPE_FIELD_NAME (type, field))
 161     arg = PyString_FromString (TYPE_FIELD_NAME (type, field));
 162   else
 163     {
 164       arg = Py_None;
 165       Py_INCREF (arg);
 166     }
 167   if (!arg)
 168     goto fail;
 169   if (PyObject_SetAttrString (result, "name", arg) < 0)
 170     goto failarg;
 171
 172   arg = TYPE_FIELD_ARTIFICIAL (type, field) ? Py_True : Py_False;
 173   Py_INCREF (arg);
 174   if (PyObject_SetAttrString (result, "artificial", arg) < 0)
 175     goto failarg;
 176
 177   if (TYPE_CODE (type) == TYPE_CODE_CLASS)
 178     arg = field < TYPE_N_BASECLASSES (type) ? Py_True : Py_False;
 179   else
 180     arg = Py_False;
 181   Py_INCREF (arg);
 182   if (PyObject_SetAttrString (result, "is_base_class", arg) < 0)
 183     goto failarg;
 184
 185   arg = PyLong_FromLong (TYPE_FIELD_BITSIZE (type, field));
 186   if (!arg)
 187     goto fail;
 188   if (PyObject_SetAttrString (result, "bitsize", arg) < 0)
 189     goto failarg;
 190
 191   /* A field can have a NULL type in some situations.  */
 192   if (TYPE_FIELD_TYPE (type, field) == NULL)
 193     {
 194       arg = Py_None;
 195       Py_INCREF (arg);
 196     }
 197   else
 198     arg = type_to_type_object (TYPE_FIELD_TYPE (type, field));
 199   if (!arg)
 200     goto fail;
 201   if (PyObject_SetAttrString (result, "type", arg) < 0)
 202     goto failarg;
 203
 204   return result;
 205
 206  failarg:
 207   Py_DECREF (arg);
 208  fail:
 209   Py_DECREF (result);
 210   return NULL;
 211 }
 212
 213 /* Return a sequence of all fields.  Each field is a dictionary with
 214    some pre-defined keys.  */
 215 static PyObject *
 216 typy_fields (PyObject *self, PyObject *args)
 217 {
 218   PyObject *result;
 219   int i;
 220   struct type *type = ((type_object *) self)->type;
 221   volatile struct gdb_exception except;
 222
 223   TRY_CATCH (except, RETURN_MASK_ALL)
 224     {
 225       CHECK_TYPEDEF (type);
 226     }
 227   GDB_PY_HANDLE_EXCEPTION (except);
 228
 229   /* We would like to make a tuple here, make fields immutable, and
 230      then memoize the result (and perhaps make Field.type() lazy).
 231      However, that can lead to cycles.  */
 232   result = PyList_New (0);
 233
 234   for (i = 0; i < TYPE_NFIELDS (type); ++i)
 235     {
 236       PyObject *dict = convert_field (type, i);
 237
 238       if (!dict)
 239         {
 240           Py_DECREF (result);
 241           return NULL;
 242         }
 243       if (PyList_Append (result, dict))
 244         {
 245           Py_DECREF (dict);
 246           Py_DECREF (result);
 247           return NULL;
 248         }
 249     }
 250
 251   return result;
 252 }
 253
 254 /* Return the type's tag, or None.  */
 255 static PyObject *
 256 typy_get_tag (PyObject *self, void *closure)
 257 {
 258   struct type *type = ((type_object *) self)->type;
 259
 260   if (!TYPE_TAG_NAME (type))
 261     Py_RETURN_NONE;
 262   return PyString_FromString (TYPE_TAG_NAME (type));
 263 }
 264
 265 /* Return the type, stripped of typedefs. */
 266 static PyObject *
 267 typy_strip_typedefs (PyObject *self, PyObject *args)
 268 {
 269   struct type *type = ((type_object *) self)->type;
 270
 271   return type_to_type_object (check_typedef (type));
 272 }
 273
 274 /* Return an array type.  */
 275
 276 static PyObject *
 277 typy_array (PyObject *self, PyObject *args)
 278 {
 279   long n1, n2;
 280   PyObject *n2_obj = NULL;
 281   struct type *array = NULL;
 282   struct type *type = ((type_object *) self)->type;
 283   volatile struct gdb_exception except;
 284
 285   if (! PyArg_ParseTuple (args, "l|O", &n1, &n2_obj))
 286     return NULL;
 287
 288   if (n2_obj)
 289     {
 290       if (!PyInt_Check (n2_obj))
 291         {
 292           PyErr_SetString (PyExc_RuntimeError,
 293                            _("Array bound must be an integer"));
 294           return NULL;
 295         }
 296
 297       if (! gdb_py_int_as_long (n2_obj, &n2))
 298         return NULL;
 299     }
 300   else
 301     {
 302       n2 = n1;
 303       n1 = 0;
 304     }
 305
 306   if (n2 < n1)
 307     {
 308       PyErr_SetString (PyExc_ValueError,
 309                        _("Array length must not be negative"));
 310       return NULL;
 311     }
 312
 313   TRY_CATCH (except, RETURN_MASK_ALL)
 314     {
 315       array = lookup_array_range_type (type, n1, n2);
 316     }
 317   GDB_PY_HANDLE_EXCEPTION (except);
 318
 319   return type_to_type_object (array);
 320 }
 321
 322 /* Return a Type object which represents a pointer to SELF.  */
 323 static PyObject *
 324 typy_pointer (PyObject *self, PyObject *args)
 325 {
 326   struct type *type = ((type_object *) self)->type;
 327   volatile struct gdb_exception except;
 328
 329   TRY_CATCH (except, RETURN_MASK_ALL)
 330     {
 331       type = lookup_pointer_type (type);
 332     }
 333   GDB_PY_HANDLE_EXCEPTION (except);
 334
 335   return type_to_type_object (type);
 336 }
 337
 338 /* Return the range of a type represented by SELF.  The return type is
 339    a tuple.  The first element of the tuple contains the low bound,
 340    while the second element of the tuple contains the high bound.  */
 341 static PyObject *
 342 typy_range (PyObject *self, PyObject *args)
 343 {
 344   struct type *type = ((type_object *) self)->type;
 345   PyObject *result;
 346   PyObject *low_bound = NULL, *high_bound = NULL;
 347   /* Initialize these to appease GCC warnings.  */
 348   LONGEST low = 0, high = 0;
 349
 350   if (TYPE_CODE (type) != TYPE_CODE_ARRAY
 351       && TYPE_CODE (type) != TYPE_CODE_STRING
 352       && TYPE_CODE (type) != TYPE_CODE_RANGE)
 353     {
 354       PyErr_SetString (PyExc_RuntimeError,
 355                        _("This type does not have a range."));
 356       return NULL;
 357     }
 358
 359   switch (TYPE_CODE (type))
 360     {
 361     case TYPE_CODE_ARRAY:
 362     case TYPE_CODE_STRING:
 363       low = TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type));
 364       high = TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (type));
 365       break;
 366     case TYPE_CODE_RANGE:
 367       low = TYPE_LOW_BOUND (type);
 368       high = TYPE_HIGH_BOUND (type);
 369       break;
 370     }
 371
 372   low_bound = PyLong_FromLong (low);
 373   if (!low_bound)
 374     goto failarg;
 375
 376   high_bound = PyLong_FromLong (high);
 377   if (!high_bound)
 378     goto failarg;
 379
 380   result = PyTuple_New (2);
 381   if (!result)
 382     goto failarg;
 383
 384   if (PyTuple_SetItem (result, 0, low_bound) != 0)
 385     {
 386       Py_DECREF (result);
 387       goto failarg;
 388     }
 389   if (PyTuple_SetItem (result, 1, high_bound) != 0)
 390     {
 391       Py_DECREF (high_bound);
 392       Py_DECREF (result);
 393       return NULL;
 394     }
 395   return result;
 396
 397  failarg:
 398   Py_XDECREF (high_bound);
 399   Py_XDECREF (low_bound);
 400   return NULL;
 401 }
 402
 403 /* Return a Type object which represents a reference to SELF.  */
 404 static PyObject *
 405 typy_reference (PyObject *self, PyObject *args)
 406 {
 407   struct type *type = ((type_object *) self)->type;
 408   volatile struct gdb_exception except;
 409
 410   TRY_CATCH (except, RETURN_MASK_ALL)
 411     {
 412       type = lookup_reference_type (type);
 413     }
 414   GDB_PY_HANDLE_EXCEPTION (except);
 415
 416   return type_to_type_object (type);
 417 }
 418
 419 /* Return a Type object which represents the target type of SELF.  */
 420 static PyObject *
 421 typy_target (PyObject *self, PyObject *args)
 422 {
 423   struct type *type = ((type_object *) self)->type;
 424
 425   if (!TYPE_TARGET_TYPE (type))
 426     {
 427       PyErr_SetString (PyExc_RuntimeError,
 428                        _("Type does not have a target."));
 429       return NULL;
 430     }
 431
 432   return type_to_type_object (TYPE_TARGET_TYPE (type));
 433 }
 434
 435 /* Return a const-qualified type variant.  */
 436 static PyObject *
 437 typy_const (PyObject *self, PyObject *args)
 438 {
 439   struct type *type = ((type_object *) self)->type;
 440   volatile struct gdb_exception except;
 441
 442   TRY_CATCH (except, RETURN_MASK_ALL)
 443     {
 444       type = make_cv_type (1, 0, type, NULL);
 445     }
 446   GDB_PY_HANDLE_EXCEPTION (except);
 447
 448   return type_to_type_object (type);
 449 }
 450
 451 /* Return a volatile-qualified type variant.  */
 452 static PyObject *
 453 typy_volatile (PyObject *self, PyObject *args)
 454 {
 455   struct type *type = ((type_object *) self)->type;
 456   volatile struct gdb_exception except;
 457
 458   TRY_CATCH (except, RETURN_MASK_ALL)
 459     {
 460       type = make_cv_type (0, 1, type, NULL);
 461     }
 462   GDB_PY_HANDLE_EXCEPTION (except);
 463
 464   return type_to_type_object (type);
 465 }
 466
 467 /* Return an unqualified type variant.  */
 468 static PyObject *
 469 typy_unqualified (PyObject *self, PyObject *args)
 470 {
 471   struct type *type = ((type_object *) self)->type;
 472   volatile struct gdb_exception except;
 473
 474   TRY_CATCH (except, RETURN_MASK_ALL)
 475     {
 476       type = make_cv_type (0, 0, type, NULL);
 477     }
 478   GDB_PY_HANDLE_EXCEPTION (except);
 479
 480   return type_to_type_object (type);
 481 }
 482
 483 /* Return the size of the type represented by SELF, in bytes.  */
 484 static PyObject *
 485 typy_get_sizeof (PyObject *self, void *closure)
 486 {
 487   struct type *type = ((type_object *) self)->type;
 488   volatile struct gdb_exception except;
 489
 490   TRY_CATCH (except, RETURN_MASK_ALL)
 491     {
 492       check_typedef (type);
 493     }
 494   /* Ignore exceptions.  */
 495
 496   return PyLong_FromLong (TYPE_LENGTH (type));
 497 }
 498
 499 static struct type *
 500 typy_lookup_typename (const char *type_name, struct block *block)
 501 {
 502   struct type *type = NULL;
 503   volatile struct gdb_exception except;
 504
 505   TRY_CATCH (except, RETURN_MASK_ALL)
 506     {
 507       if (!strncmp (type_name, "struct ", 7))
 508         type = lookup_struct (type_name + 7, NULL);
 509       else if (!strncmp (type_name, "union ", 6))
 510         type = lookup_union (type_name + 6, NULL);
 511       else if (!strncmp (type_name, "enum ", 5))
 512         type = lookup_enum (type_name + 5, NULL);
 513       else
 514         type = lookup_typename (python_language, python_gdbarch,
 515                                 type_name, block, 0);
 516     }
 517   if (except.reason < 0)
 518     {
 519       PyErr_Format (except.reason == RETURN_QUIT
 520                     ? PyExc_KeyboardInterrupt : PyExc_RuntimeError,
 521                     "%s", except.message);
 522       return NULL;
 523     }
 524
 525   return type;
 526 }
 527
 528 static struct type *
 529 typy_lookup_type (struct demangle_component *demangled,
 530                   struct block *block)
 531 {
 532   struct type *type;
 533   char *type_name;
 534   enum demangle_component_type demangled_type;
 535
 536   /* Save the type: typy_lookup_type() may (indirectly) overwrite
 537      memory pointed by demangled.  */
 538   demangled_type = demangled->type;
 539
 540   if (demangled_type == DEMANGLE_COMPONENT_POINTER
 541       || demangled_type == DEMANGLE_COMPONENT_REFERENCE
 542       || demangled_type == DEMANGLE_COMPONENT_CONST
 543       || demangled_type == DEMANGLE_COMPONENT_VOLATILE)
 544     {
 545       type = typy_lookup_type (demangled->u.s_binary.left, block);
 546       if (! type)
 547         return NULL;
 548
 549       switch (demangled_type)
 550         {
 551         case DEMANGLE_COMPONENT_REFERENCE:
 552           return lookup_reference_type (type);
 553         case DEMANGLE_COMPONENT_POINTER:
 554           return lookup_pointer_type (type);
 555         case DEMANGLE_COMPONENT_CONST:
 556           return make_cv_type (1, 0, type, NULL);
 557         case DEMANGLE_COMPONENT_VOLATILE:
 558           return make_cv_type (0, 1, type, NULL);
 559         }
 560     }
 561
 562   type_name = cp_comp_to_string (demangled, 10);
 563   type = typy_lookup_typename (type_name, block);
 564   xfree (type_name);
 565
 566   return type;
 567 }
 568
 569 /* This is a helper function for typy_template_argument that is used
 570    when the type does not have template symbols attached.  It works by
 571    parsing the type name.  This happens with compilers, like older
 572    versions of GCC, that do not emit DW_TAG_template_*.  */
 573
 574 static PyObject *
 575 typy_legacy_template_argument (struct type *type, struct block *block,
 576                                int argno)
 577 {
 578   int i;
 579   struct demangle_component *demangled;
 580   struct demangle_parse_info *info;
 581   const char *err;
 582   struct type *argtype;
 583   struct cleanup *cleanup;
 584
 585   if (TYPE_NAME (type) == NULL)
 586     {
 587       PyErr_SetString (PyExc_RuntimeError, _("Null type name."));
 588       return NULL;
 589     }
 590
 591   /* Note -- this is not thread-safe.  */
 592   info = cp_demangled_name_to_comp (TYPE_NAME (type), &err);
 593   if (! info)
 594     {
 595       PyErr_SetString (PyExc_RuntimeError, err);
 596       return NULL;
 597     }
 598   demangled = info->tree;
 599   cleanup = make_cleanup_cp_demangled_name_parse_free (info);
 600
 601   /* Strip off component names.  */
 602   while (demangled->type == DEMANGLE_COMPONENT_QUAL_NAME
 603          || demangled->type == DEMANGLE_COMPONENT_LOCAL_NAME)
 604     demangled = demangled->u.s_binary.right;
 605
 606   if (demangled->type != DEMANGLE_COMPONENT_TEMPLATE)
 607     {
 608       do_cleanups (cleanup);
 609       PyErr_SetString (PyExc_RuntimeError, _("Type is not a template."));
 610       return NULL;
 611     }
 612
 613   /* Skip from the template to the arguments.  */
 614   demangled = demangled->u.s_binary.right;
 615
 616   for (i = 0; demangled && i < argno; ++i)
 617     demangled = demangled->u.s_binary.right;
 618
 619   if (! demangled)
 620     {
 621       do_cleanups (cleanup);
 622       PyErr_Format (PyExc_RuntimeError, _("No argument %d in template."),
 623                     argno);
 624       return NULL;
 625     }
 626
 627   argtype = typy_lookup_type (demangled->u.s_binary.left, block);
 628   do_cleanups (cleanup);
 629   if (! argtype)
 630     return NULL;
 631
 632   return type_to_type_object (argtype);
 633 }
 634
 635 static PyObject *
 636 typy_template_argument (PyObject *self, PyObject *args)
 637 {
 638   int argno;
 639   struct type *type = ((type_object *) self)->type;
 640   struct block *block = NULL;
 641   PyObject *block_obj = NULL;
 642   struct symbol *sym;
 643   struct value *val = NULL;
 644   volatile struct gdb_exception except;
 645
 646   if (! PyArg_ParseTuple (args, "i|O", &argno, &block_obj))
 647     return NULL;
 648
 649   if (block_obj)
 650     {
 651       block = block_object_to_block (block_obj);
 652       if (! block)
 653         {
 654           PyErr_SetString (PyExc_RuntimeError,
 655                            _("Second argument must be block."));
 656           return NULL;
 657         }
 658     }
 659
 660   TRY_CATCH (except, RETURN_MASK_ALL)
 661     {
 662       type = check_typedef (type);
 663       if (TYPE_CODE (type) == TYPE_CODE_REF)
 664         type = check_typedef (TYPE_TARGET_TYPE (type));
 665     }
 666   GDB_PY_HANDLE_EXCEPTION (except);
 667
 668   /* We might not have DW_TAG_template_*, so try to parse the type's
 669      name.  This is inefficient if we do not have a template type --
 670      but that is going to wind up as an error anyhow.  */
 671   if (! TYPE_N_TEMPLATE_ARGUMENTS (type))
 672     return typy_legacy_template_argument (type, block, argno);
 673
 674   if (argno >= TYPE_N_TEMPLATE_ARGUMENTS (type))
 675     {
 676       PyErr_Format (PyExc_RuntimeError, _("No argument %d in template."),
 677                     argno);
 678       return NULL;
 679     }
 680
 681   sym = TYPE_TEMPLATE_ARGUMENT (type, argno);
 682   if (SYMBOL_CLASS (sym) == LOC_TYPEDEF)
 683     return type_to_type_object (SYMBOL_TYPE (sym));
 684   else if (SYMBOL_CLASS (sym) == LOC_OPTIMIZED_OUT)
 685     {
 686       PyErr_Format (PyExc_RuntimeError,
 687                     _("Template argument is optimized out"));
 688       return NULL;
 689     }
 690
 691   TRY_CATCH (except, RETURN_MASK_ALL)
 692     {
 693       val = value_of_variable (sym, block);
 694     }
 695   GDB_PY_HANDLE_EXCEPTION (except);
 696
 697   return value_to_value_object (val);
 698 }
 699
 700 static PyObject *
 701 typy_str (PyObject *self)
 702 {
 703   volatile struct gdb_exception except;
 704   char *thetype = NULL;
 705   long length = 0;
 706   PyObject *result;
 707
 708   TRY_CATCH (except, RETURN_MASK_ALL)
 709     {
 710       struct cleanup *old_chain;
 711       struct ui_file *stb;
 712
 713       stb = mem_fileopen ();
 714       old_chain = make_cleanup_ui_file_delete (stb);
 715
 716       type_print (type_object_to_type (self), "", stb, -1);
 717
 718       thetype = ui_file_xstrdup (stb, &length);
 719       do_cleanups (old_chain);
 720     }
 721   if (except.reason < 0)
 722     {
 723       xfree (thetype);
 724       GDB_PY_HANDLE_EXCEPTION (except);
 725     }
 726
 727   result = PyUnicode_Decode (thetype, length, host_charset (), NULL);
 728   xfree (thetype);
 729
 730   return result;
 731 }
 732
 733 /* An entry in the type-equality bcache.  */
 734
 735 typedef struct type_equality_entry
 736 {
 737   struct type *type1, *type2;
 738 } type_equality_entry_d;
 739
 740 DEF_VEC_O (type_equality_entry_d);
 741
 742 /* A helper function to compare two strings.  Returns 1 if they are
 743    the same, 0 otherwise.  Handles NULLs properly.  */
 744
 745 static int
 746 compare_strings (const char *s, const char *t)
 747 {
 748   if (s == NULL && t != NULL)
 749     return 0;
 750   else if (s != NULL && t == NULL)
 751     return 0;
 752   else if (s == NULL && t== NULL)
 753     return 1;
 754   return strcmp (s, t) == 0;
 755 }
 756
 757 /* A helper function for typy_richcompare that checks two types for
 758    "deep" equality.  Returns Py_EQ if the types are considered the
 759    same, Py_NE otherwise.  */
 760
 761 static int
 762 check_types_equal (struct type *type1, struct type *type2,
 763                    VEC (type_equality_entry_d) **worklist)
 764 {
 765   CHECK_TYPEDEF (type1);
 766   CHECK_TYPEDEF (type2);
 767
 768   if (type1 == type2)
 769     return Py_EQ;
 770
 771   if (TYPE_CODE (type1) != TYPE_CODE (type2)
 772       || TYPE_LENGTH (type1) != TYPE_LENGTH (type2)
 773       || TYPE_UNSIGNED (type1) != TYPE_UNSIGNED (type2)
 774       || TYPE_NOSIGN (type1) != TYPE_NOSIGN (type2)
 775       || TYPE_VARARGS (type1) != TYPE_VARARGS (type2)
 776       || TYPE_VECTOR (type1) != TYPE_VECTOR (type2)
 777       || TYPE_NOTTEXT (type1) != TYPE_NOTTEXT (type2)
 778       || TYPE_INSTANCE_FLAGS (type1) != TYPE_INSTANCE_FLAGS (type2)
 779       || TYPE_NFIELDS (type1) != TYPE_NFIELDS (type2))
 780     return Py_NE;
 781
 782   if (!compare_strings (TYPE_TAG_NAME (type1), TYPE_TAG_NAME (type2)))
 783     return Py_NE;
 784   if (!compare_strings (TYPE_NAME (type1), TYPE_NAME (type2)))
 785     return Py_NE;
 786
 787   if (TYPE_CODE (type1) == TYPE_CODE_RANGE)
 788     {
 789       if (memcmp (TYPE_RANGE_DATA (type1), TYPE_RANGE_DATA (type2),
 790                   sizeof (*TYPE_RANGE_DATA (type1))) != 0)
 791         return Py_NE;
 792     }
 793   else
 794     {
 795       int i;
 796
 797       for (i = 0; i < TYPE_NFIELDS (type1); ++i)
 798         {
 799           const struct field *field1 = &TYPE_FIELD (type1, i);
 800           const struct field *field2 = &TYPE_FIELD (type2, i);
 801           struct type_equality_entry entry;
 802
 803           if (FIELD_ARTIFICIAL (*field1) != FIELD_ARTIFICIAL (*field2)
 804               || FIELD_BITSIZE (*field1) != FIELD_BITSIZE (*field2)
 805               || FIELD_LOC_KIND (*field1) != FIELD_LOC_KIND (*field2))
 806             return Py_NE;
 807           if (!compare_strings (FIELD_NAME (*field1), FIELD_NAME (*field2)))
 808             return Py_NE;
 809           switch (FIELD_LOC_KIND (*field1))
 810             {
 811             case FIELD_LOC_KIND_BITPOS:
 812               if (FIELD_BITPOS (*field1) != FIELD_BITPOS (*field2))
 813                 return Py_NE;
 814               break;
 815             case FIELD_LOC_KIND_PHYSADDR:
 816               if (FIELD_STATIC_PHYSADDR (*field1)
 817                   != FIELD_STATIC_PHYSADDR (*field2))
 818                 return Py_NE;
 819               break;
 820             case FIELD_LOC_KIND_PHYSNAME:
 821               if (!compare_strings (FIELD_STATIC_PHYSNAME (*field1),
 822                                     FIELD_STATIC_PHYSNAME (*field2)))
 823                 return Py_NE;
 824               break;
 825             }
 826
 827           entry.type1 = FIELD_TYPE (*field1);
 828           entry.type2 = FIELD_TYPE (*field2);
 829           VEC_safe_push (type_equality_entry_d, *worklist, &entry);
 830         }
 831     }
 832
 833   if (TYPE_TARGET_TYPE (type1) != NULL)
 834     {
 835       struct type_equality_entry entry;
 836       int added;
 837
 838       if (TYPE_TARGET_TYPE (type2) == NULL)
 839         return Py_NE;
 840
 841       entry.type1 = TYPE_TARGET_TYPE (type1);
 842       entry.type2 = TYPE_TARGET_TYPE (type2);
 843       VEC_safe_push (type_equality_entry_d, *worklist, &entry);
 844     }
 845   else if (TYPE_TARGET_TYPE (type2) != NULL)
 846     return Py_NE;
 847
 848   return Py_EQ;
 849 }
 850
 851 /* Check types on a worklist for equality.  Returns Py_NE if any pair
 852    is not equal, Py_EQ if they are all considered equal.  */
 853
 854 static int
 855 check_types_worklist (VEC (type_equality_entry_d) **worklist,
 856                       struct bcache *cache)
 857 {
 858   while (!VEC_empty (type_equality_entry_d, *worklist))
 859     {
 860       struct type_equality_entry entry;
 861       int added;
 862
 863       entry = *VEC_last (type_equality_entry_d, *worklist);
 864       VEC_pop (type_equality_entry_d, *worklist);
 865
 866       /* If the type pair has already been visited, we know it is
 867          ok.  */
 868       bcache_full (&entry, sizeof (entry), cache, &added);
 869       if (!added)
 870         continue;
 871
 872       if (check_types_equal (entry.type1, entry.type2, worklist) == Py_NE)
 873         return Py_NE;
 874     }
 875
 876   return Py_EQ;
 877 }
 878
 879 /* Implement the richcompare method.  */
 880
 881 static PyObject *
 882 typy_richcompare (PyObject *self, PyObject *other, int op)
 883 {
 884   int result = Py_NE;
 885   struct type *type1 = type_object_to_type (self);
 886   struct type *type2 = type_object_to_type (other);
 887   volatile struct gdb_exception except;
 888
 889   /* We can only compare ourselves to another Type object, and only
 890      for equality or inequality.  */
 891   if (type2 == NULL || (op != Py_EQ && op != Py_NE))
 892     {
 893       Py_INCREF (Py_NotImplemented);
 894       return Py_NotImplemented;
 895     }
 896
 897   if (type1 == type2)
 898     result = Py_EQ;
 899   else
 900     {
 901       struct bcache *cache;
 902       VEC (type_equality_entry_d) *worklist = NULL;
 903       struct type_equality_entry entry;
 904
 905       cache = bcache_xmalloc (NULL, NULL);
 906
 907       entry.type1 = type1;
 908       entry.type2 = type2;
 909       VEC_safe_push (type_equality_entry_d, worklist, &entry);
 910
 911       TRY_CATCH (except, RETURN_MASK_ALL)
 912         {
 913           result = check_types_worklist (&worklist, cache);
 914         }
 915       if (except.reason < 0)
 916         result = Py_NE;
 917
 918       bcache_xfree (cache);
 919       VEC_free (type_equality_entry_d, worklist);
 920     }
 921
 922   if (op == result)
 923     Py_RETURN_TRUE;
 924   Py_RETURN_FALSE;
 925 }
 926
 927 \f
 928
 929 static const struct objfile_data *typy_objfile_data_key;
 930
 931 static void
 932 save_objfile_types (struct objfile *objfile, void *datum)
 933 {
 934   type_object *obj = datum;
 935   htab_t copied_types;
 936   struct cleanup *cleanup;
 937
 938   /* This prevents another thread from freeing the objects we're
 939      operating on.  */
 940   cleanup = ensure_python_env (get_objfile_arch (objfile), current_language);
 941
 942   copied_types = create_copied_types_hash (objfile);
 943
 944   while (obj)
 945     {
 946       type_object *next = obj->next;
 947
 948       htab_empty (copied_types);
 949
 950       obj->type = copy_type_recursive (objfile, obj->type, copied_types);
 951
 952       obj->next = NULL;
 953       obj->prev = NULL;
 954
 955       obj = next;
 956     }
 957
 958   htab_delete (copied_types);
 959
 960   do_cleanups (cleanup);
 961 }
 962
 963 static void
 964 set_type (type_object *obj, struct type *type)
 965 {
 966   obj->type = type;
 967   obj->prev = NULL;
 968   if (type && TYPE_OBJFILE (type))
 969     {
 970       struct objfile *objfile = TYPE_OBJFILE (type);
 971
 972       obj->next = objfile_data (objfile, typy_objfile_data_key);
 973       if (obj->next)
 974         obj->next->prev = obj;
 975       set_objfile_data (objfile, typy_objfile_data_key, obj);
 976     }
 977   else
 978     obj->next = NULL;
 979 }
 980
 981 static void
 982 typy_dealloc (PyObject *obj)
 983 {
 984   type_object *type = (type_object *) obj;
 985
 986   if (type->prev)
 987     type->prev->next = type->next;
 988   else if (type->type && TYPE_OBJFILE (type->type))
 989     {
 990       /* Must reset head of list.  */
 991       struct objfile *objfile = TYPE_OBJFILE (type->type);
 992
 993       if (objfile)
 994         set_objfile_data (objfile, typy_objfile_data_key, type->next);
 995     }
 996   if (type->next)
 997     type->next->prev = type->prev;
 998
 999   type->ob_type->tp_free (type);
1000 }
1001
1002 /* Create a new Type referring to TYPE.  */
1003 PyObject *
1004 type_to_type_object (struct type *type)
1005 {
1006   type_object *type_obj;
1007
1008   type_obj = PyObject_New (type_object, &type_object_type);
1009   if (type_obj)
1010     set_type (type_obj, type);
1011
1012   return (PyObject *) type_obj;
1013 }
1014
1015 struct type *
1016 type_object_to_type (PyObject *obj)
1017 {
1018   if (! PyObject_TypeCheck (obj, &type_object_type))
1019     return NULL;
1020   return ((type_object *) obj)->type;
1021 }
1022
1023 \f
1024
1025 /* Implementation of gdb.lookup_type.  */
1026 PyObject *
1027 gdbpy_lookup_type (PyObject *self, PyObject *args, PyObject *kw)
1028 {
1029   static char *keywords[] = { "name", "block", NULL };
1030   const char *type_name = NULL;
1031   struct type *type = NULL;
1032   PyObject *block_obj = NULL;
1033   struct block *block = NULL;
1034
1035   if (! PyArg_ParseTupleAndKeywords (args, kw, "s|O", keywords,
1036                                      &type_name, &block_obj))
1037     return NULL;
1038
1039   if (block_obj)
1040     {
1041       block = block_object_to_block (block_obj);
1042       if (! block)
1043         {
1044           PyErr_SetString (PyExc_RuntimeError,
1045                            _("'block' argument must be a Block."));
1046           return NULL;
1047         }
1048     }
1049
1050   type = typy_lookup_typename (type_name, block);
1051   if (! type)
1052     return NULL;
1053
1054   return (PyObject *) type_to_type_object (type);
1055 }
1056
1057 void
1058 gdbpy_initialize_types (void)
1059 {
1060   int i;
1061
1062   typy_objfile_data_key
1063     = register_objfile_data_with_cleanup (save_objfile_types, NULL);
1064
1065   if (PyType_Ready (&type_object_type) < 0)
1066     return;
1067   if (PyType_Ready (&field_object_type) < 0)
1068     return;
1069
1070   for (i = 0; pyty_codes[i].name; ++i)
1071     {
1072       if (PyModule_AddIntConstant (gdb_module,
1073                                    /* Cast needed for Python 2.4.  */
1074                                    (char *) pyty_codes[i].name,
1075                                    pyty_codes[i].code) < 0)
1076         return;
1077     }
1078
1079   Py_INCREF (&type_object_type);
1080   PyModule_AddObject (gdb_module, "Type", (PyObject *) &type_object_type);
1081
1082   Py_INCREF (&field_object_type);
1083   PyModule_AddObject (gdb_module, "Field", (PyObject *) &field_object_type);
1084 }
1085
1086 \f
1087
1088 static PyGetSetDef type_object_getset[] =
1089 {
1090   { "code", typy_get_code, NULL,
1091     "The code for this type.", NULL },
1092   { "sizeof", typy_get_sizeof, NULL,
1093     "The size of this type, in bytes.", NULL },
1094   { "tag", typy_get_tag, NULL,
1095     "The tag name for this type, or None.", NULL },
1096   { NULL }
1097 };
1098
1099 static PyMethodDef type_object_methods[] =
1100 {
1101   { "array", typy_array, METH_VARARGS,
1102     "array (N) -> Type\n\
1103 Return a type which represents an array of N objects of this type." },
1104   { "const", typy_const, METH_NOARGS,
1105     "const () -> Type\n\
1106 Return a const variant of this type." },
1107   { "fields", typy_fields, METH_NOARGS,
1108     "field () -> list\n\
1109 Return a sequence holding all the fields of this type.\n\
1110 Each field is a dictionary." },
1111   { "pointer", typy_pointer, METH_NOARGS,
1112     "pointer () -> Type\n\
1113 Return a type of pointer to this type." },
1114   { "range", typy_range, METH_NOARGS,
1115     "range () -> tuple\n\
1116 Return a tuple containing the lower and upper range for this type."},
1117   { "reference", typy_reference, METH_NOARGS,
1118     "reference () -> Type\n\
1119 Return a type of reference to this type." },
1120   { "strip_typedefs", typy_strip_typedefs, METH_NOARGS,
1121     "strip_typedefs () -> Type\n\
1122 Return a type formed by stripping this type of all typedefs."},
1123   { "target", typy_target, METH_NOARGS,
1124     "target () -> Type\n\
1125 Return the target type of this type." },
1126   { "template_argument", typy_template_argument, METH_VARARGS,
1127     "template_argument (arg, [block]) -> Type\n\
1128 Return the type of a template argument." },
1129   { "unqualified", typy_unqualified, METH_NOARGS,
1130     "unqualified () -> Type\n\
1131 Return a variant of this type without const or volatile attributes." },
1132   { "volatile", typy_volatile, METH_NOARGS,
1133     "volatile () -> Type\n\
1134 Return a volatile variant of this type" },
1135   { NULL }
1136 };
1137
1138 static PyTypeObject type_object_type =
1139 {
1140   PyObject_HEAD_INIT (NULL)
1141   0,                              /*ob_size*/
1142   "gdb.Type",                     /*tp_name*/
1143   sizeof (type_object),           /*tp_basicsize*/
1144   0,                              /*tp_itemsize*/
1145   typy_dealloc,                   /*tp_dealloc*/
1146   0,                              /*tp_print*/
1147   0,                              /*tp_getattr*/
1148   0,                              /*tp_setattr*/
1149   0,                              /*tp_compare*/
1150   0,                              /*tp_repr*/
1151   0,                              /*tp_as_number*/
1152   0,                              /*tp_as_sequence*/
1153   0,                              /*tp_as_mapping*/
1154   0,                              /*tp_hash */
1155   0,                              /*tp_call*/
1156   typy_str,                       /*tp_str*/
1157   0,                              /*tp_getattro*/
1158   0,                              /*tp_setattro*/
1159   0,                              /*tp_as_buffer*/
1160   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER,  /*tp_flags*/
1161   "GDB type object",              /* tp_doc */
1162   0,                              /* tp_traverse */
1163   0,                              /* tp_clear */
1164   typy_richcompare,               /* tp_richcompare */
1165   0,                              /* tp_weaklistoffset */
1166   0,                              /* tp_iter */
1167   0,                              /* tp_iternext */
1168   type_object_methods,            /* tp_methods */
1169   0,                              /* tp_members */
1170   type_object_getset,             /* tp_getset */
1171   0,                              /* tp_base */
1172   0,                              /* tp_dict */
1173   0,                              /* tp_descr_get */
1174   0,                              /* tp_descr_set */
1175   0,                              /* tp_dictoffset */
1176   0,                              /* tp_init */
1177   0,                              /* tp_alloc */
1178   0,                              /* tp_new */
1179 };
1180
1181 static PyTypeObject field_object_type =
1182 {
1183   PyObject_HEAD_INIT (NULL)
1184   0,                              /*ob_size*/
1185   "gdb.Field",                    /*tp_name*/
1186   sizeof (field_object),          /*tp_basicsize*/
1187   0,                              /*tp_itemsize*/
1188   field_dealloc,                  /*tp_dealloc*/
1189   0,                              /*tp_print*/
1190   0,                              /*tp_getattr*/
1191   0,                              /*tp_setattr*/
1192   0,                              /*tp_compare*/
1193   0,                              /*tp_repr*/
1194   0,                              /*tp_as_number*/
1195   0,                              /*tp_as_sequence*/
1196   0,                              /*tp_as_mapping*/
1197   0,                              /*tp_hash */
1198   0,                              /*tp_call*/
1199   0,                              /*tp_str*/
1200   0,                              /*tp_getattro*/
1201   0,                              /*tp_setattro*/
1202   0,                              /*tp_as_buffer*/
1203   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER,  /*tp_flags*/
1204   "GDB field object",             /* tp_doc */
1205   0,                              /* tp_traverse */
1206   0,                              /* tp_clear */
1207   0,                              /* tp_richcompare */
1208   0,                              /* tp_weaklistoffset */
1209   0,                              /* tp_iter */
1210   0,                              /* tp_iternext */
1211   0,                              /* tp_methods */
1212   0,                              /* tp_members */
1213   0,                              /* tp_getset */
1214   0,                              /* tp_base */
1215   0,                              /* tp_dict */
1216   0,                              /* tp_descr_get */
1217   0,                              /* tp_descr_set */
1218   offsetof (field_object, dict),  /* tp_dictoffset */
1219   0,                              /* tp_init */
1220   0,                              /* tp_alloc */
1221   0,                              /* tp_new */
1222 };