gdb/python/py-type.c

   1 /* Python interface to types.
   2
   3    Copyright (C) 2008-2020 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 "python-internal.h"
  23 #include "charset.h"
  24 #include "gdbtypes.h"
  25 #include "cp-support.h"
  26 #include "demangle.h"
  27 #include "objfiles.h"
  28 #include "language.h"
  29 #include "typeprint.h"
  30
  31 struct type_object
  32 {
  33   PyObject_HEAD
  34   struct type *type;
  35
  36   /* If a Type object is associated with an objfile, it is kept on a
  37      doubly-linked list, rooted in the objfile.  This lets us copy the
  38      underlying struct type when the objfile is deleted.  */
  39   struct type_object *prev;
  40   struct type_object *next;
  41 };
  42
  43 extern PyTypeObject type_object_type
  44     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("type_object");
  45
  46 /* A Field object.  */
  47 struct field_object
  48 {
  49   PyObject_HEAD
  50
  51   /* Dictionary holding our attributes.  */
  52   PyObject *dict;
  53 };
  54
  55 extern PyTypeObject field_object_type
  56     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("field_object");
  57
  58 /* A type iterator object.  */
  59 struct typy_iterator_object {
  60   PyObject_HEAD
  61   /* The current field index.  */
  62   int field;
  63   /* What to return.  */
  64   enum gdbpy_iter_kind kind;
  65   /* Pointer back to the original source type object.  */
  66   type_object *source;
  67 };
  68
  69 extern PyTypeObject type_iterator_object_type
  70     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("typy_iterator_object");
  71
  72 /* This is used to initialize various gdb.TYPE_ constants.  */
  73 struct pyty_code
  74 {
  75   /* The code.  */
  76   enum type_code code;
  77   /* The name.  */
  78   const char *name;
  79 };
  80
  81 /* Forward declarations.  */
  82 static PyObject *typy_make_iter (PyObject *self, enum gdbpy_iter_kind kind);
  83
  84 #define ENTRY(X) { X, #X }
  85
  86 static struct pyty_code pyty_codes[] =
  87 {
  88   ENTRY (TYPE_CODE_BITSTRING),
  89   ENTRY (TYPE_CODE_PTR),
  90   ENTRY (TYPE_CODE_ARRAY),
  91   ENTRY (TYPE_CODE_STRUCT),
  92   ENTRY (TYPE_CODE_UNION),
  93   ENTRY (TYPE_CODE_ENUM),
  94   ENTRY (TYPE_CODE_FLAGS),
  95   ENTRY (TYPE_CODE_FUNC),
  96   ENTRY (TYPE_CODE_INT),
  97   ENTRY (TYPE_CODE_FLT),
  98   ENTRY (TYPE_CODE_VOID),
  99   ENTRY (TYPE_CODE_SET),
 100   ENTRY (TYPE_CODE_RANGE),
 101   ENTRY (TYPE_CODE_STRING),
 102   ENTRY (TYPE_CODE_ERROR),
 103   ENTRY (TYPE_CODE_METHOD),
 104   ENTRY (TYPE_CODE_METHODPTR),
 105   ENTRY (TYPE_CODE_MEMBERPTR),
 106   ENTRY (TYPE_CODE_REF),
 107   ENTRY (TYPE_CODE_RVALUE_REF),
 108   ENTRY (TYPE_CODE_CHAR),
 109   ENTRY (TYPE_CODE_BOOL),
 110   ENTRY (TYPE_CODE_COMPLEX),
 111   ENTRY (TYPE_CODE_TYPEDEF),
 112   ENTRY (TYPE_CODE_NAMESPACE),
 113   ENTRY (TYPE_CODE_DECFLOAT),
 114   ENTRY (TYPE_CODE_INTERNAL_FUNCTION),
 115   { TYPE_CODE_UNDEF, NULL }
 116 };
 117
 118 \f
 119
 120 static void
 121 field_dealloc (PyObject *obj)
 122 {
 123   field_object *f = (field_object *) obj;
 124
 125   Py_XDECREF (f->dict);
 126   Py_TYPE (obj)->tp_free (obj);
 127 }
 128
 129 static PyObject *
 130 field_new (void)
 131 {
 132   gdbpy_ref<field_object> result (PyObject_New (field_object,
 133                                                 &field_object_type));
 134
 135   if (result != NULL)
 136     {
 137       result->dict = PyDict_New ();
 138       if (!result->dict)
 139         return NULL;
 140     }
 141   return (PyObject *) result.release ();
 142 }
 143
 144 \f
 145
 146 /* Return true if OBJ is of type gdb.Field, false otherwise.  */
 147
 148 int
 149 gdbpy_is_field (PyObject *obj)
 150 {
 151   return PyObject_TypeCheck (obj, &field_object_type);
 152 }
 153
 154 /* Return the code for this type.  */
 155 static PyObject *
 156 typy_get_code (PyObject *self, void *closure)
 157 {
 158   struct type *type = ((type_object *) self)->type;
 159
 160   return gdb_py_object_from_longest (type->code ()).release ();
 161 }
 162
 163 /* Helper function for typy_fields which converts a single field to a
 164    gdb.Field object.  Returns NULL on error.  */
 165
 166 static gdbpy_ref<>
 167 convert_field (struct type *type, int field)
 168 {
 169   gdbpy_ref<> result (field_new ());
 170
 171   if (result == NULL)
 172     return NULL;
 173
 174   gdbpy_ref<> arg (type_to_type_object (type));
 175   if (arg == NULL)
 176     return NULL;
 177   if (PyObject_SetAttrString (result.get (), "parent_type", arg.get ()) < 0)
 178     return NULL;
 179
 180   if (!field_is_static (&type->field (field)))
 181     {
 182       const char *attrstring;
 183
 184       if (type->code () == TYPE_CODE_ENUM)
 185         {
 186           arg = gdb_py_object_from_longest (TYPE_FIELD_ENUMVAL (type, field));
 187           attrstring = "enumval";
 188         }
 189       else
 190         {
 191           if (TYPE_FIELD_LOC_KIND (type, field) == FIELD_LOC_KIND_DWARF_BLOCK)
 192             arg = gdbpy_ref<>::new_reference (Py_None);
 193           else
 194             arg = gdb_py_object_from_longest (TYPE_FIELD_BITPOS (type, field));
 195           attrstring = "bitpos";
 196         }
 197
 198       if (arg == NULL)
 199         return NULL;
 200
 201       if (PyObject_SetAttrString (result.get (), attrstring, arg.get ()) < 0)
 202         return NULL;
 203     }
 204
 205   arg.reset (NULL);
 206   if (TYPE_FIELD_NAME (type, field))
 207     {
 208       const char *field_name = TYPE_FIELD_NAME (type, field);
 209
 210       if (field_name[0] != '\0')
 211         {
 212           arg.reset (PyString_FromString (TYPE_FIELD_NAME (type, field)));
 213           if (arg == NULL)
 214             return NULL;
 215         }
 216     }
 217   if (arg == NULL)
 218     arg = gdbpy_ref<>::new_reference (Py_None);
 219
 220   if (PyObject_SetAttrString (result.get (), "name", arg.get ()) < 0)
 221     return NULL;
 222
 223   arg = gdbpy_ref<>::new_reference (TYPE_FIELD_ARTIFICIAL (type, field)
 224                                     ? Py_True : Py_False);
 225   if (PyObject_SetAttrString (result.get (), "artificial", arg.get ()) < 0)
 226     return NULL;
 227
 228   if (type->code () == TYPE_CODE_STRUCT)
 229     arg = gdbpy_ref<>::new_reference (field < TYPE_N_BASECLASSES (type)
 230                                       ? Py_True : Py_False);
 231   else
 232     arg = gdbpy_ref<>::new_reference (Py_False);
 233   if (PyObject_SetAttrString (result.get (), "is_base_class", arg.get ()) < 0)
 234     return NULL;
 235
 236   arg = gdb_py_object_from_longest (TYPE_FIELD_BITSIZE (type, field));
 237   if (arg == NULL)
 238     return NULL;
 239   if (PyObject_SetAttrString (result.get (), "bitsize", arg.get ()) < 0)
 240     return NULL;
 241
 242   /* A field can have a NULL type in some situations.  */
 243   if (type->field (field).type () == NULL)
 244     arg = gdbpy_ref<>::new_reference (Py_None);
 245   else
 246     arg.reset (type_to_type_object (type->field (field).type ()));
 247   if (arg == NULL)
 248     return NULL;
 249   if (PyObject_SetAttrString (result.get (), "type", arg.get ()) < 0)
 250     return NULL;
 251
 252   return result;
 253 }
 254
 255 /* Helper function to return the name of a field, as a gdb.Field object.
 256    If the field doesn't have a name, None is returned.  */
 257
 258 static gdbpy_ref<>
 259 field_name (struct type *type, int field)
 260 {
 261   gdbpy_ref<> result;
 262
 263   if (TYPE_FIELD_NAME (type, field))
 264     result.reset (PyString_FromString (TYPE_FIELD_NAME (type, field)));
 265   else
 266     result = gdbpy_ref<>::new_reference (Py_None);
 267
 268   return result;
 269 }
 270
 271 /* Helper function for Type standard mapping methods.  Returns a
 272    Python object for field i of the type.  "kind" specifies what to
 273    return: the name of the field, a gdb.Field object corresponding to
 274    the field, or a tuple consisting of field name and gdb.Field
 275    object.  */
 276
 277 static gdbpy_ref<>
 278 make_fielditem (struct type *type, int i, enum gdbpy_iter_kind kind)
 279 {
 280   switch (kind)
 281     {
 282     case iter_items:
 283       {
 284         gdbpy_ref<> key (field_name (type, i));
 285         if (key == NULL)
 286           return NULL;
 287         gdbpy_ref<> value = convert_field (type, i);
 288         if (value == NULL)
 289           return NULL;
 290         gdbpy_ref<> item (PyTuple_New (2));
 291         if (item == NULL)
 292           return NULL;
 293         PyTuple_SET_ITEM (item.get (), 0, key.release ());
 294         PyTuple_SET_ITEM (item.get (), 1, value.release ());
 295         return item;
 296       }
 297     case iter_keys:
 298       return field_name (type, i);
 299     case iter_values:
 300       return convert_field (type, i);
 301     }
 302   gdb_assert_not_reached ("invalid gdbpy_iter_kind");
 303 }
 304
 305 /* Return a sequence of all field names, fields, or (name, field) pairs.
 306    Each field is a gdb.Field object.  */
 307
 308 static PyObject *
 309 typy_fields_items (PyObject *self, enum gdbpy_iter_kind kind)
 310 {
 311   PyObject *py_type = self;
 312   struct type *type = ((type_object *) py_type)->type;
 313   struct type *checked_type = type;
 314
 315   try
 316     {
 317       checked_type = check_typedef (checked_type);
 318     }
 319   catch (const gdb_exception &except)
 320     {
 321       GDB_PY_HANDLE_EXCEPTION (except);
 322     }
 323
 324   gdbpy_ref<> type_holder;
 325   if (checked_type != type)
 326     {
 327       type_holder.reset (type_to_type_object (checked_type));
 328       if (type_holder == nullptr)
 329         return nullptr;
 330       py_type = type_holder.get ();
 331     }
 332   gdbpy_ref<> iter (typy_make_iter (py_type, kind));
 333   if (iter == nullptr)
 334     return nullptr;
 335
 336   return PySequence_List (iter.get ());
 337 }
 338
 339 /* Return a sequence of all fields.  Each field is a gdb.Field object.  */
 340
 341 static PyObject *
 342 typy_values (PyObject *self, PyObject *args)
 343 {
 344   return typy_fields_items (self, iter_values);
 345 }
 346
 347 /* Return a sequence of all fields.  Each field is a gdb.Field object.
 348    This method is similar to typy_values, except where the supplied
 349    gdb.Type is an array, in which case it returns a list of one entry
 350    which is a gdb.Field object for a range (the array bounds).  */
 351
 352 static PyObject *
 353 typy_fields (PyObject *self, PyObject *args)
 354 {
 355   struct type *type = ((type_object *) self)->type;
 356
 357   if (type->code () != TYPE_CODE_ARRAY)
 358     return typy_fields_items (self, iter_values);
 359
 360   /* Array type.  Handle this as a special case because the common
 361      machinery wants struct or union or enum types.  Build a list of
 362      one entry which is the range for the array.  */
 363   gdbpy_ref<> r = convert_field (type, 0);
 364   if (r == NULL)
 365     return NULL;
 366
 367   return Py_BuildValue ("[O]", r.get ());
 368 }
 369
 370 /* Return a sequence of all field names.  Each field is a gdb.Field object.  */
 371
 372 static PyObject *
 373 typy_field_names (PyObject *self, PyObject *args)
 374 {
 375   return typy_fields_items (self, iter_keys);
 376 }
 377
 378 /* Return a sequence of all (name, fields) pairs.  Each field is a
 379    gdb.Field object.  */
 380
 381 static PyObject *
 382 typy_items (PyObject *self, PyObject *args)
 383 {
 384   return typy_fields_items (self, iter_items);
 385 }
 386
 387 /* Return the type's name, or None.  */
 388
 389 static PyObject *
 390 typy_get_name (PyObject *self, void *closure)
 391 {
 392   struct type *type = ((type_object *) self)->type;
 393
 394   if (type->name () == NULL)
 395     Py_RETURN_NONE;
 396   return PyString_FromString (type->name ());
 397 }
 398
 399 /* Return the type's tag, or None.  */
 400 static PyObject *
 401 typy_get_tag (PyObject *self, void *closure)
 402 {
 403   struct type *type = ((type_object *) self)->type;
 404   const char *tagname = nullptr;
 405
 406   if (type->code () == TYPE_CODE_STRUCT
 407       || type->code () == TYPE_CODE_UNION
 408       || type->code () == TYPE_CODE_ENUM)
 409     tagname = type->name ();
 410
 411   if (tagname == nullptr)
 412     Py_RETURN_NONE;
 413   return PyString_FromString (tagname);
 414 }
 415
 416 /* Return the type's objfile, or None.  */
 417 static PyObject *
 418 typy_get_objfile (PyObject *self, void *closure)
 419 {
 420   struct type *type = ((type_object *) self)->type;
 421   struct objfile *objfile = TYPE_OBJFILE (type);
 422
 423   if (objfile == nullptr)
 424     Py_RETURN_NONE;
 425   return objfile_to_objfile_object (objfile).release ();
 426 }
 427
 428 /* Return the type, stripped of typedefs. */
 429 static PyObject *
 430 typy_strip_typedefs (PyObject *self, PyObject *args)
 431 {
 432   struct type *type = ((type_object *) self)->type;
 433
 434   try
 435     {
 436       type = check_typedef (type);
 437     }
 438   catch (const gdb_exception &except)
 439     {
 440       GDB_PY_HANDLE_EXCEPTION (except);
 441     }
 442
 443   return type_to_type_object (type);
 444 }
 445
 446 /* Strip typedefs and pointers/reference from a type.  Then check that
 447    it is a struct, union, or enum type.  If not, raise TypeError.  */
 448
 449 static struct type *
 450 typy_get_composite (struct type *type)
 451 {
 452
 453   for (;;)
 454     {
 455       try
 456         {
 457           type = check_typedef (type);
 458         }
 459       catch (const gdb_exception &except)
 460         {
 461           GDB_PY_HANDLE_EXCEPTION (except);
 462         }
 463
 464       if (type->code () != TYPE_CODE_PTR && !TYPE_IS_REFERENCE (type))
 465         break;
 466       type = TYPE_TARGET_TYPE (type);
 467     }
 468
 469   /* If this is not a struct, union, or enum type, raise TypeError
 470      exception.  */
 471   if (type->code () != TYPE_CODE_STRUCT
 472       && type->code () != TYPE_CODE_UNION
 473       && type->code () != TYPE_CODE_ENUM
 474       && type->code () != TYPE_CODE_METHOD
 475       && type->code () != TYPE_CODE_FUNC)
 476     {
 477       PyErr_SetString (PyExc_TypeError,
 478                        "Type is not a structure, union, enum, or function type.");
 479       return NULL;
 480     }
 481
 482   return type;
 483 }
 484
 485 /* Helper for typy_array and typy_vector.  */
 486
 487 static PyObject *
 488 typy_array_1 (PyObject *self, PyObject *args, int is_vector)
 489 {
 490   long n1, n2;
 491   PyObject *n2_obj = NULL;
 492   struct type *array = NULL;
 493   struct type *type = ((type_object *) self)->type;
 494
 495   if (! PyArg_ParseTuple (args, "l|O", &n1, &n2_obj))
 496     return NULL;
 497
 498   if (n2_obj)
 499     {
 500       if (!PyInt_Check (n2_obj))
 501         {
 502           PyErr_SetString (PyExc_RuntimeError,
 503                            _("Array bound must be an integer"));
 504           return NULL;
 505         }
 506
 507       if (! gdb_py_int_as_long (n2_obj, &n2))
 508         return NULL;
 509     }
 510   else
 511     {
 512       n2 = n1;
 513       n1 = 0;
 514     }
 515
 516   if (n2 < n1 - 1) /* Note: An empty array has n2 == n1 - 1.  */
 517     {
 518       PyErr_SetString (PyExc_ValueError,
 519                        _("Array length must not be negative"));
 520       return NULL;
 521     }
 522
 523   try
 524     {
 525       array = lookup_array_range_type (type, n1, n2);
 526       if (is_vector)
 527         make_vector_type (array);
 528     }
 529   catch (const gdb_exception &except)
 530     {
 531       GDB_PY_HANDLE_EXCEPTION (except);
 532     }
 533
 534   return type_to_type_object (array);
 535 }
 536
 537 /* Return an array type.  */
 538
 539 static PyObject *
 540 typy_array (PyObject *self, PyObject *args)
 541 {
 542   return typy_array_1 (self, args, 0);
 543 }
 544
 545 /* Return a vector type.  */
 546
 547 static PyObject *
 548 typy_vector (PyObject *self, PyObject *args)
 549 {
 550   return typy_array_1 (self, args, 1);
 551 }
 552
 553 /* Return a Type object which represents a pointer to SELF.  */
 554 static PyObject *
 555 typy_pointer (PyObject *self, PyObject *args)
 556 {
 557   struct type *type = ((type_object *) self)->type;
 558
 559   try
 560     {
 561       type = lookup_pointer_type (type);
 562     }
 563   catch (const gdb_exception &except)
 564     {
 565       GDB_PY_HANDLE_EXCEPTION (except);
 566     }
 567
 568   return type_to_type_object (type);
 569 }
 570
 571 /* Return the range of a type represented by SELF.  The return type is
 572    a tuple.  The first element of the tuple contains the low bound,
 573    while the second element of the tuple contains the high bound.  */
 574 static PyObject *
 575 typy_range (PyObject *self, PyObject *args)
 576 {
 577   struct type *type = ((type_object *) self)->type;
 578   /* Initialize these to appease GCC warnings.  */
 579   LONGEST low = 0, high = 0;
 580
 581   if (type->code () != TYPE_CODE_ARRAY
 582       && type->code () != TYPE_CODE_STRING
 583       && type->code () != TYPE_CODE_RANGE)
 584     {
 585       PyErr_SetString (PyExc_RuntimeError,
 586                        _("This type does not have a range."));
 587       return NULL;
 588     }
 589
 590   switch (type->code ())
 591     {
 592     case TYPE_CODE_ARRAY:
 593     case TYPE_CODE_STRING:
 594     case TYPE_CODE_RANGE:
 595       low = type->bounds ()->low.const_val ();
 596       high = type->bounds ()->high.const_val ();;
 597       break;
 598     }
 599
 600   gdbpy_ref<> low_bound = gdb_py_object_from_longest (low);
 601   if (low_bound == NULL)
 602     return NULL;
 603
 604   gdbpy_ref<> high_bound = gdb_py_object_from_longest (high);
 605   if (high_bound == NULL)
 606     return NULL;
 607
 608   gdbpy_ref<> result (PyTuple_New (2));
 609   if (result == NULL)
 610     return NULL;
 611
 612   if (PyTuple_SetItem (result.get (), 0, low_bound.release ()) != 0
 613       || PyTuple_SetItem (result.get (), 1, high_bound.release ()) != 0)
 614     return NULL;
 615   return result.release ();
 616 }
 617
 618 /* Return a Type object which represents a reference to SELF.  */
 619 static PyObject *
 620 typy_reference (PyObject *self, PyObject *args)
 621 {
 622   struct type *type = ((type_object *) self)->type;
 623
 624   try
 625     {
 626       type = lookup_lvalue_reference_type (type);
 627     }
 628   catch (const gdb_exception &except)
 629     {
 630       GDB_PY_HANDLE_EXCEPTION (except);
 631     }
 632
 633   return type_to_type_object (type);
 634 }
 635
 636 /* Return a Type object which represents the target type of SELF.  */
 637 static PyObject *
 638 typy_target (PyObject *self, PyObject *args)
 639 {
 640   struct type *type = ((type_object *) self)->type;
 641
 642   if (!TYPE_TARGET_TYPE (type))
 643     {
 644       PyErr_SetString (PyExc_RuntimeError,
 645                        _("Type does not have a target."));
 646       return NULL;
 647     }
 648
 649   return type_to_type_object (TYPE_TARGET_TYPE (type));
 650 }
 651
 652 /* Return a const-qualified type variant.  */
 653 static PyObject *
 654 typy_const (PyObject *self, PyObject *args)
 655 {
 656   struct type *type = ((type_object *) self)->type;
 657
 658   try
 659     {
 660       type = make_cv_type (1, 0, type, NULL);
 661     }
 662   catch (const gdb_exception &except)
 663     {
 664       GDB_PY_HANDLE_EXCEPTION (except);
 665     }
 666
 667   return type_to_type_object (type);
 668 }
 669
 670 /* Return a volatile-qualified type variant.  */
 671 static PyObject *
 672 typy_volatile (PyObject *self, PyObject *args)
 673 {
 674   struct type *type = ((type_object *) self)->type;
 675
 676   try
 677     {
 678       type = make_cv_type (0, 1, type, NULL);
 679     }
 680   catch (const gdb_exception &except)
 681     {
 682       GDB_PY_HANDLE_EXCEPTION (except);
 683     }
 684
 685   return type_to_type_object (type);
 686 }
 687
 688 /* Return an unqualified type variant.  */
 689 static PyObject *
 690 typy_unqualified (PyObject *self, PyObject *args)
 691 {
 692   struct type *type = ((type_object *) self)->type;
 693
 694   try
 695     {
 696       type = make_cv_type (0, 0, type, NULL);
 697     }
 698   catch (const gdb_exception &except)
 699     {
 700       GDB_PY_HANDLE_EXCEPTION (except);
 701     }
 702
 703   return type_to_type_object (type);
 704 }
 705
 706 /* Return the size of the type represented by SELF, in bytes.  */
 707 static PyObject *
 708 typy_get_sizeof (PyObject *self, void *closure)
 709 {
 710   struct type *type = ((type_object *) self)->type;
 711
 712   bool size_varies = false;
 713   try
 714     {
 715       check_typedef (type);
 716
 717       size_varies = TYPE_HAS_DYNAMIC_LENGTH (type);
 718     }
 719   catch (const gdb_exception &except)
 720     {
 721     }
 722
 723   /* Ignore exceptions.  */
 724
 725   if (size_varies)
 726     Py_RETURN_NONE;
 727   return gdb_py_object_from_longest (TYPE_LENGTH (type)).release ();
 728 }
 729
 730 /* Return the alignment of the type represented by SELF, in bytes.  */
 731 static PyObject *
 732 typy_get_alignof (PyObject *self, void *closure)
 733 {
 734   struct type *type = ((type_object *) self)->type;
 735
 736   ULONGEST align = 0;
 737   try
 738     {
 739       align = type_align (type);
 740     }
 741   catch (const gdb_exception &except)
 742     {
 743       align = 0;
 744     }
 745
 746   /* Ignore exceptions.  */
 747
 748   return gdb_py_object_from_ulongest (align).release ();
 749 }
 750
 751 /* Return whether or not the type is dynamic.  */
 752 static PyObject *
 753 typy_get_dynamic (PyObject *self, void *closure)
 754 {
 755   struct type *type = ((type_object *) self)->type;
 756
 757   bool result = false;
 758   try
 759     {
 760       result = is_dynamic_type (type);
 761     }
 762   catch (const gdb_exception &except)
 763     {
 764       /* Ignore exceptions.  */
 765     }
 766
 767   if (result)
 768     Py_RETURN_TRUE;
 769   Py_RETURN_FALSE;
 770 }
 771
 772 static struct type *
 773 typy_lookup_typename (const char *type_name, const struct block *block)
 774 {
 775   struct type *type = NULL;
 776
 777   try
 778     {
 779       if (startswith (type_name, "struct "))
 780         type = lookup_struct (type_name + 7, NULL);
 781       else if (startswith (type_name, "union "))
 782         type = lookup_union (type_name + 6, NULL);
 783       else if (startswith (type_name, "enum "))
 784         type = lookup_enum (type_name + 5, NULL);
 785       else
 786         type = lookup_typename (python_language,
 787                                 type_name, block, 0);
 788     }
 789   catch (const gdb_exception &except)
 790     {
 791       GDB_PY_HANDLE_EXCEPTION (except);
 792     }
 793
 794   return type;
 795 }
 796
 797 static struct type *
 798 typy_lookup_type (struct demangle_component *demangled,
 799                   const struct block *block)
 800 {
 801   struct type *type, *rtype = NULL;
 802   enum demangle_component_type demangled_type;
 803
 804   /* Save the type: typy_lookup_type() may (indirectly) overwrite
 805      memory pointed by demangled.  */
 806   demangled_type = demangled->type;
 807
 808   if (demangled_type == DEMANGLE_COMPONENT_POINTER
 809       || demangled_type == DEMANGLE_COMPONENT_REFERENCE
 810       || demangled_type == DEMANGLE_COMPONENT_RVALUE_REFERENCE
 811       || demangled_type == DEMANGLE_COMPONENT_CONST
 812       || demangled_type == DEMANGLE_COMPONENT_VOLATILE)
 813     {
 814       type = typy_lookup_type (demangled->u.s_binary.left, block);
 815       if (! type)
 816         return NULL;
 817
 818       try
 819         {
 820           /* If the demangled_type matches with one of the types
 821              below, run the corresponding function and save the type
 822              to return later.  We cannot just return here as we are in
 823              an exception handler.  */
 824           switch (demangled_type)
 825             {
 826             case DEMANGLE_COMPONENT_REFERENCE:
 827               rtype = lookup_lvalue_reference_type (type);
 828               break;
 829             case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
 830               rtype = lookup_rvalue_reference_type (type);
 831               break;
 832             case DEMANGLE_COMPONENT_POINTER:
 833               rtype = lookup_pointer_type (type);
 834               break;
 835             case DEMANGLE_COMPONENT_CONST:
 836               rtype = make_cv_type (1, 0, type, NULL);
 837               break;
 838             case DEMANGLE_COMPONENT_VOLATILE:
 839               rtype = make_cv_type (0, 1, type, NULL);
 840               break;
 841             }
 842         }
 843       catch (const gdb_exception &except)
 844         {
 845           GDB_PY_HANDLE_EXCEPTION (except);
 846         }
 847     }
 848
 849   /* If we have a type from the switch statement above, just return
 850      that.  */
 851   if (rtype)
 852     return rtype;
 853
 854   /* We don't have a type, so lookup the type.  */
 855   gdb::unique_xmalloc_ptr<char> type_name = cp_comp_to_string (demangled, 10);
 856   return typy_lookup_typename (type_name.get (), block);
 857 }
 858
 859 /* This is a helper function for typy_template_argument that is used
 860    when the type does not have template symbols attached.  It works by
 861    parsing the type name.  This happens with compilers, like older
 862    versions of GCC, that do not emit DW_TAG_template_*.  */
 863
 864 static PyObject *
 865 typy_legacy_template_argument (struct type *type, const struct block *block,
 866                                int argno)
 867 {
 868   int i;
 869   struct demangle_component *demangled;
 870   std::unique_ptr<demangle_parse_info> info;
 871   std::string err;
 872   struct type *argtype;
 873
 874   if (type->name () == NULL)
 875     {
 876       PyErr_SetString (PyExc_RuntimeError, _("Null type name."));
 877       return NULL;
 878     }
 879
 880   try
 881     {
 882       /* Note -- this is not thread-safe.  */
 883       info = cp_demangled_name_to_comp (type->name (), &err);
 884     }
 885   catch (const gdb_exception &except)
 886     {
 887       GDB_PY_HANDLE_EXCEPTION (except);
 888     }
 889
 890   if (! info)
 891     {
 892       PyErr_SetString (PyExc_RuntimeError, err.c_str ());
 893       return NULL;
 894     }
 895   demangled = info->tree;
 896
 897   /* Strip off component names.  */
 898   while (demangled->type == DEMANGLE_COMPONENT_QUAL_NAME
 899          || demangled->type == DEMANGLE_COMPONENT_LOCAL_NAME)
 900     demangled = demangled->u.s_binary.right;
 901
 902   if (demangled->type != DEMANGLE_COMPONENT_TEMPLATE)
 903     {
 904       PyErr_SetString (PyExc_RuntimeError, _("Type is not a template."));
 905       return NULL;
 906     }
 907
 908   /* Skip from the template to the arguments.  */
 909   demangled = demangled->u.s_binary.right;
 910
 911   for (i = 0; demangled && i < argno; ++i)
 912     demangled = demangled->u.s_binary.right;
 913
 914   if (! demangled)
 915     {
 916       PyErr_Format (PyExc_RuntimeError, _("No argument %d in template."),
 917                     argno);
 918       return NULL;
 919     }
 920
 921   argtype = typy_lookup_type (demangled->u.s_binary.left, block);
 922   if (! argtype)
 923     return NULL;
 924
 925   return type_to_type_object (argtype);
 926 }
 927
 928 static PyObject *
 929 typy_template_argument (PyObject *self, PyObject *args)
 930 {
 931   int argno;
 932   struct type *type = ((type_object *) self)->type;
 933   const struct block *block = NULL;
 934   PyObject *block_obj = NULL;
 935   struct symbol *sym;
 936   struct value *val = NULL;
 937
 938   if (! PyArg_ParseTuple (args, "i|O", &argno, &block_obj))
 939     return NULL;
 940
 941   if (argno < 0)
 942     {
 943       PyErr_SetString (PyExc_RuntimeError,
 944                        _("Template argument number must be non-negative"));
 945       return NULL;
 946     }
 947
 948   if (block_obj)
 949     {
 950       block = block_object_to_block (block_obj);
 951       if (! block)
 952         {
 953           PyErr_SetString (PyExc_RuntimeError,
 954                            _("Second argument must be block."));
 955           return NULL;
 956         }
 957     }
 958
 959   try
 960     {
 961       type = check_typedef (type);
 962       if (TYPE_IS_REFERENCE (type))
 963         type = check_typedef (TYPE_TARGET_TYPE (type));
 964     }
 965   catch (const gdb_exception &except)
 966     {
 967       GDB_PY_HANDLE_EXCEPTION (except);
 968     }
 969
 970   /* We might not have DW_TAG_template_*, so try to parse the type's
 971      name.  This is inefficient if we do not have a template type --
 972      but that is going to wind up as an error anyhow.  */
 973   if (! TYPE_N_TEMPLATE_ARGUMENTS (type))
 974     return typy_legacy_template_argument (type, block, argno);
 975
 976   if (argno >= TYPE_N_TEMPLATE_ARGUMENTS (type))
 977     {
 978       PyErr_Format (PyExc_RuntimeError, _("No argument %d in template."),
 979                     argno);
 980       return NULL;
 981     }
 982
 983   sym = TYPE_TEMPLATE_ARGUMENT (type, argno);
 984   if (SYMBOL_CLASS (sym) == LOC_TYPEDEF)
 985     return type_to_type_object (SYMBOL_TYPE (sym));
 986   else if (SYMBOL_CLASS (sym) == LOC_OPTIMIZED_OUT)
 987     {
 988       PyErr_Format (PyExc_RuntimeError,
 989                     _("Template argument is optimized out"));
 990       return NULL;
 991     }
 992
 993   try
 994     {
 995       val = value_of_variable (sym, block);
 996     }
 997   catch (const gdb_exception &except)
 998     {
 999       GDB_PY_HANDLE_EXCEPTION (except);
1000     }
1001
1002   return value_to_value_object (val);
1003 }
1004
1005 static PyObject *
1006 typy_str (PyObject *self)
1007 {
1008   string_file thetype;
1009
1010   try
1011     {
1012       LA_PRINT_TYPE (type_object_to_type (self), "", &thetype, -1, 0,
1013                      &type_print_raw_options);
1014     }
1015   catch (const gdb_exception &except)
1016     {
1017       GDB_PY_HANDLE_EXCEPTION (except);
1018     }
1019
1020   return PyUnicode_Decode (thetype.c_str (), thetype.size (),
1021                            host_charset (), NULL);
1022 }
1023
1024 /* Implement the richcompare method.  */
1025
1026 static PyObject *
1027 typy_richcompare (PyObject *self, PyObject *other, int op)
1028 {
1029   bool result = false;
1030   struct type *type1 = type_object_to_type (self);
1031   struct type *type2 = type_object_to_type (other);
1032
1033   /* We can only compare ourselves to another Type object, and only
1034      for equality or inequality.  */
1035   if (type2 == NULL || (op != Py_EQ && op != Py_NE))
1036     {
1037       Py_INCREF (Py_NotImplemented);
1038       return Py_NotImplemented;
1039     }
1040
1041   if (type1 == type2)
1042     result = true;
1043   else
1044     {
1045       try
1046         {
1047           result = types_deeply_equal (type1, type2);
1048         }
1049       catch (const gdb_exception &except)
1050         {
1051           /* If there is a GDB exception, a comparison is not capable
1052              (or trusted), so exit.  */
1053           GDB_PY_HANDLE_EXCEPTION (except);
1054         }
1055     }
1056
1057   if (op == (result ? Py_EQ : Py_NE))
1058     Py_RETURN_TRUE;
1059   Py_RETURN_FALSE;
1060 }
1061
1062 \f
1063
1064 static const struct objfile_data *typy_objfile_data_key;
1065
1066 static void
1067 save_objfile_types (struct objfile *objfile, void *datum)
1068 {
1069   type_object *obj = (type_object *) datum;
1070
1071   if (!gdb_python_initialized)
1072     return;
1073
1074   /* This prevents another thread from freeing the objects we're
1075      operating on.  */
1076   gdbpy_enter enter_py (objfile->arch (), current_language);
1077
1078   htab_up copied_types = create_copied_types_hash (objfile);
1079
1080   while (obj)
1081     {
1082       type_object *next = obj->next;
1083
1084       htab_empty (copied_types.get ());
1085
1086       obj->type = copy_type_recursive (objfile, obj->type,
1087                                        copied_types.get ());
1088
1089       obj->next = NULL;
1090       obj->prev = NULL;
1091
1092       obj = next;
1093     }
1094 }
1095
1096 static void
1097 set_type (type_object *obj, struct type *type)
1098 {
1099   obj->type = type;
1100   obj->prev = NULL;
1101   if (type && TYPE_OBJFILE (type))
1102     {
1103       struct objfile *objfile = TYPE_OBJFILE (type);
1104
1105       obj->next = ((type_object *)
1106                    objfile_data (objfile, typy_objfile_data_key));
1107       if (obj->next)
1108         obj->next->prev = obj;
1109       set_objfile_data (objfile, typy_objfile_data_key, obj);
1110     }
1111   else
1112     obj->next = NULL;
1113 }
1114
1115 static void
1116 typy_dealloc (PyObject *obj)
1117 {
1118   type_object *type = (type_object *) obj;
1119
1120   if (type->prev)
1121     type->prev->next = type->next;
1122   else if (type->type && TYPE_OBJFILE (type->type))
1123     {
1124       /* Must reset head of list.  */
1125       struct objfile *objfile = TYPE_OBJFILE (type->type);
1126
1127       if (objfile)
1128         set_objfile_data (objfile, typy_objfile_data_key, type->next);
1129     }
1130   if (type->next)
1131     type->next->prev = type->prev;
1132
1133   Py_TYPE (type)->tp_free (type);
1134 }
1135
1136 /* Return number of fields ("length" of the field dictionary).  */
1137
1138 static Py_ssize_t
1139 typy_length (PyObject *self)
1140 {
1141   struct type *type = ((type_object *) self)->type;
1142
1143   type = typy_get_composite (type);
1144   if (type == NULL)
1145     return -1;
1146
1147   return type->num_fields ();
1148 }
1149
1150 /* Implements boolean evaluation of gdb.Type.  Handle this like other
1151    Python objects that don't have a meaningful truth value -- all
1152    values are true.  */
1153
1154 static int
1155 typy_nonzero (PyObject *self)
1156 {
1157   return 1;
1158 }
1159
1160 /* Return optimized out value of this type.  */
1161
1162 static PyObject *
1163 typy_optimized_out (PyObject *self, PyObject *args)
1164 {
1165   struct type *type = ((type_object *) self)->type;
1166
1167   return value_to_value_object (allocate_optimized_out_value (type));
1168 }
1169
1170 /* Return a gdb.Field object for the field named by the argument.  */
1171
1172 static PyObject *
1173 typy_getitem (PyObject *self, PyObject *key)
1174 {
1175   struct type *type = ((type_object *) self)->type;
1176   int i;
1177
1178   gdb::unique_xmalloc_ptr<char> field = python_string_to_host_string (key);
1179   if (field == NULL)
1180     return NULL;
1181
1182   /* We want just fields of this type, not of base types, so instead of
1183      using lookup_struct_elt_type, portions of that function are
1184      copied here.  */
1185
1186   type = typy_get_composite (type);
1187   if (type == NULL)
1188     return NULL;
1189
1190   for (i = 0; i < type->num_fields (); i++)
1191     {
1192       const char *t_field_name = TYPE_FIELD_NAME (type, i);
1193
1194       if (t_field_name && (strcmp_iw (t_field_name, field.get ()) == 0))
1195         return convert_field (type, i).release ();
1196     }
1197   PyErr_SetObject (PyExc_KeyError, key);
1198   return NULL;
1199 }
1200
1201 /* Implement the "get" method on the type object.  This is the
1202    same as getitem if the key is present, but returns the supplied
1203    default value or None if the key is not found.  */
1204
1205 static PyObject *
1206 typy_get (PyObject *self, PyObject *args)
1207 {
1208   PyObject *key, *defval = Py_None, *result;
1209
1210   if (!PyArg_UnpackTuple (args, "get", 1, 2, &key, &defval))
1211     return NULL;
1212
1213   result = typy_getitem (self, key);
1214   if (result != NULL)
1215     return result;
1216
1217   /* typy_getitem returned error status.  If the exception is
1218      KeyError, clear the exception status and return the defval
1219      instead.  Otherwise return the exception unchanged.  */
1220   if (!PyErr_ExceptionMatches (PyExc_KeyError))
1221     return NULL;
1222
1223   PyErr_Clear ();
1224   Py_INCREF (defval);
1225   return defval;
1226 }
1227
1228 /* Implement the "has_key" method on the type object.  */
1229
1230 static PyObject *
1231 typy_has_key (PyObject *self, PyObject *args)
1232 {
1233   struct type *type = ((type_object *) self)->type;
1234   const char *field;
1235   int i;
1236
1237   if (!PyArg_ParseTuple (args, "s", &field))
1238     return NULL;
1239
1240   /* We want just fields of this type, not of base types, so instead of
1241      using lookup_struct_elt_type, portions of that function are
1242      copied here.  */
1243
1244   type = typy_get_composite (type);
1245   if (type == NULL)
1246     return NULL;
1247
1248   for (i = 0; i < type->num_fields (); i++)
1249     {
1250       const char *t_field_name = TYPE_FIELD_NAME (type, i);
1251
1252       if (t_field_name && (strcmp_iw (t_field_name, field) == 0))
1253         Py_RETURN_TRUE;
1254     }
1255   Py_RETURN_FALSE;
1256 }
1257
1258 /* Make an iterator object to iterate over keys, values, or items.  */
1259
1260 static PyObject *
1261 typy_make_iter (PyObject *self, enum gdbpy_iter_kind kind)
1262 {
1263   typy_iterator_object *typy_iter_obj;
1264
1265   /* Check that "self" is a structure or union type.  */
1266   if (typy_get_composite (((type_object *) self)->type) == NULL)
1267     return NULL;
1268
1269   typy_iter_obj = PyObject_New (typy_iterator_object,
1270                                 &type_iterator_object_type);
1271   if (typy_iter_obj == NULL)
1272       return NULL;
1273
1274   typy_iter_obj->field = 0;
1275   typy_iter_obj->kind = kind;
1276   Py_INCREF (self);
1277   typy_iter_obj->source = (type_object *) self;
1278
1279   return (PyObject *) typy_iter_obj;
1280 }
1281
1282 /* iteritems() method.  */
1283
1284 static PyObject *
1285 typy_iteritems (PyObject *self, PyObject *args)
1286 {
1287   return typy_make_iter (self, iter_items);
1288 }
1289
1290 /* iterkeys() method.  */
1291
1292 static PyObject *
1293 typy_iterkeys (PyObject *self, PyObject *args)
1294 {
1295   return typy_make_iter (self, iter_keys);
1296 }
1297
1298 /* Iterating over the class, same as iterkeys except for the function
1299    signature.  */
1300
1301 static PyObject *
1302 typy_iter (PyObject *self)
1303 {
1304   return typy_make_iter (self, iter_keys);
1305 }
1306
1307 /* itervalues() method.  */
1308
1309 static PyObject *
1310 typy_itervalues (PyObject *self, PyObject *args)
1311 {
1312   return typy_make_iter (self, iter_values);
1313 }
1314
1315 /* Return a reference to the type iterator.  */
1316
1317 static PyObject *
1318 typy_iterator_iter (PyObject *self)
1319 {
1320   Py_INCREF (self);
1321   return self;
1322 }
1323
1324 /* Return the next field in the iteration through the list of fields
1325    of the type.  */
1326
1327 static PyObject *
1328 typy_iterator_iternext (PyObject *self)
1329 {
1330   typy_iterator_object *iter_obj = (typy_iterator_object *) self;
1331   struct type *type = iter_obj->source->type;
1332
1333   if (iter_obj->field < type->num_fields ())
1334     {
1335       gdbpy_ref<> result = make_fielditem (type, iter_obj->field,
1336                                            iter_obj->kind);
1337       if (result != NULL)
1338         iter_obj->field++;
1339       return result.release ();
1340     }
1341
1342   return NULL;
1343 }
1344
1345 static void
1346 typy_iterator_dealloc (PyObject *obj)
1347 {
1348   typy_iterator_object *iter_obj = (typy_iterator_object *) obj;
1349
1350   Py_DECREF (iter_obj->source);
1351   Py_TYPE (obj)->tp_free (obj);
1352 }
1353
1354 /* Create a new Type referring to TYPE.  */
1355 PyObject *
1356 type_to_type_object (struct type *type)
1357 {
1358   type_object *type_obj;
1359
1360   try
1361     {
1362       /* Try not to let stub types leak out to Python.  */
1363       if (type->is_stub ())
1364         type = check_typedef (type);
1365     }
1366   catch (...)
1367     {
1368       /* Just ignore failures in check_typedef.  */
1369     }
1370
1371   type_obj = PyObject_New (type_object, &type_object_type);
1372   if (type_obj)
1373     set_type (type_obj, type);
1374
1375   return (PyObject *) type_obj;
1376 }
1377
1378 struct type *
1379 type_object_to_type (PyObject *obj)
1380 {
1381   if (! PyObject_TypeCheck (obj, &type_object_type))
1382     return NULL;
1383   return ((type_object *) obj)->type;
1384 }
1385
1386 \f
1387
1388 /* Implementation of gdb.lookup_type.  */
1389 PyObject *
1390 gdbpy_lookup_type (PyObject *self, PyObject *args, PyObject *kw)
1391 {
1392   static const char *keywords[] = { "name", "block", NULL };
1393   const char *type_name = NULL;
1394   struct type *type = NULL;
1395   PyObject *block_obj = NULL;
1396   const struct block *block = NULL;
1397
1398   if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "s|O", keywords,
1399                                         &type_name, &block_obj))
1400     return NULL;
1401
1402   if (block_obj)
1403     {
1404       block = block_object_to_block (block_obj);
1405       if (! block)
1406         {
1407           PyErr_SetString (PyExc_RuntimeError,
1408                            _("'block' argument must be a Block."));
1409           return NULL;
1410         }
1411     }
1412
1413   type = typy_lookup_typename (type_name, block);
1414   if (! type)
1415     return NULL;
1416
1417   return type_to_type_object (type);
1418 }
1419
1420 int
1421 gdbpy_initialize_types (void)
1422 {
1423   int i;
1424
1425   typy_objfile_data_key
1426     = register_objfile_data_with_cleanup (save_objfile_types, NULL);
1427
1428   if (PyType_Ready (&type_object_type) < 0)
1429     return -1;
1430   if (PyType_Ready (&field_object_type) < 0)
1431     return -1;
1432   if (PyType_Ready (&type_iterator_object_type) < 0)
1433     return -1;
1434
1435   for (i = 0; pyty_codes[i].name; ++i)
1436     {
1437       if (PyModule_AddIntConstant (gdb_module, pyty_codes[i].name,
1438                                    pyty_codes[i].code) < 0)
1439         return -1;
1440     }
1441
1442   if (gdb_pymodule_addobject (gdb_module, "Type",
1443                               (PyObject *) &type_object_type) < 0)
1444     return -1;
1445
1446   if (gdb_pymodule_addobject (gdb_module, "TypeIterator",
1447                               (PyObject *) &type_iterator_object_type) < 0)
1448     return -1;
1449
1450   return gdb_pymodule_addobject (gdb_module, "Field",
1451                                  (PyObject *) &field_object_type);
1452 }
1453
1454 \f
1455
1456 static gdb_PyGetSetDef type_object_getset[] =
1457 {
1458   { "alignof", typy_get_alignof, NULL,
1459     "The alignment of this type, in bytes.", NULL },
1460   { "code", typy_get_code, NULL,
1461     "The code for this type.", NULL },
1462   { "dynamic", typy_get_dynamic, NULL,
1463     "Whether this type is dynamic.", NULL },
1464   { "name", typy_get_name, NULL,
1465     "The name for this type, or None.", NULL },
1466   { "sizeof", typy_get_sizeof, NULL,
1467     "The size of this type, in bytes.", NULL },
1468   { "tag", typy_get_tag, NULL,
1469     "The tag name for this type, or None.", NULL },
1470   { "objfile", typy_get_objfile, NULL,
1471     "The objfile this type was defined in, or None.", NULL },
1472   { NULL }
1473 };
1474
1475 static PyMethodDef type_object_methods[] =
1476 {
1477   { "array", typy_array, METH_VARARGS,
1478     "array ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1479 Return a type which represents an array of objects of this type.\n\
1480 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1481 If LOW_BOUND is omitted, a value of zero is used." },
1482   { "vector", typy_vector, METH_VARARGS,
1483     "vector ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1484 Return a type which represents a vector of objects of this type.\n\
1485 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1486 If LOW_BOUND is omitted, a value of zero is used.\n\
1487 Vectors differ from arrays in that if the current language has C-style\n\
1488 arrays, vectors don't decay to a pointer to the first element.\n\
1489 They are first class values." },
1490    { "__contains__", typy_has_key, METH_VARARGS,
1491      "T.__contains__(k) -> True if T has a field named k, else False" },
1492   { "const", typy_const, METH_NOARGS,
1493     "const () -> Type\n\
1494 Return a const variant of this type." },
1495   { "optimized_out", typy_optimized_out, METH_NOARGS,
1496     "optimized_out() -> Value\n\
1497 Return optimized out value of this type." },
1498   { "fields", typy_fields, METH_NOARGS,
1499     "fields () -> list\n\
1500 Return a list holding all the fields of this type.\n\
1501 Each field is a gdb.Field object." },
1502   { "get", typy_get, METH_VARARGS,
1503     "T.get(k[,default]) -> returns field named k in T, if it exists;\n\
1504 otherwise returns default, if supplied, or None if not." },
1505   { "has_key", typy_has_key, METH_VARARGS,
1506     "T.has_key(k) -> True if T has a field named k, else False" },
1507   { "items", typy_items, METH_NOARGS,
1508     "items () -> list\n\
1509 Return a list of (name, field) pairs of this type.\n\
1510 Each field is a gdb.Field object." },
1511   { "iteritems", typy_iteritems, METH_NOARGS,
1512     "iteritems () -> an iterator over the (name, field)\n\
1513 pairs of this type.  Each field is a gdb.Field object." },
1514   { "iterkeys", typy_iterkeys, METH_NOARGS,
1515     "iterkeys () -> an iterator over the field names of this type." },
1516   { "itervalues", typy_itervalues, METH_NOARGS,
1517     "itervalues () -> an iterator over the fields of this type.\n\
1518 Each field is a gdb.Field object." },
1519   { "keys", typy_field_names, METH_NOARGS,
1520     "keys () -> list\n\
1521 Return a list holding all the fields names of this type." },
1522   { "pointer", typy_pointer, METH_NOARGS,
1523     "pointer () -> Type\n\
1524 Return a type of pointer to this type." },
1525   { "range", typy_range, METH_NOARGS,
1526     "range () -> tuple\n\
1527 Return a tuple containing the lower and upper range for this type."},
1528   { "reference", typy_reference, METH_NOARGS,
1529     "reference () -> Type\n\
1530 Return a type of reference to this type." },
1531   { "strip_typedefs", typy_strip_typedefs, METH_NOARGS,
1532     "strip_typedefs () -> Type\n\
1533 Return a type formed by stripping this type of all typedefs."},
1534   { "target", typy_target, METH_NOARGS,
1535     "target () -> Type\n\
1536 Return the target type of this type." },
1537   { "template_argument", typy_template_argument, METH_VARARGS,
1538     "template_argument (arg, [block]) -> Type\n\
1539 Return the type of a template argument." },
1540   { "unqualified", typy_unqualified, METH_NOARGS,
1541     "unqualified () -> Type\n\
1542 Return a variant of this type without const or volatile attributes." },
1543   { "values", typy_values, METH_NOARGS,
1544     "values () -> list\n\
1545 Return a list holding all the fields of this type.\n\
1546 Each field is a gdb.Field object." },
1547   { "volatile", typy_volatile, METH_NOARGS,
1548     "volatile () -> Type\n\
1549 Return a volatile variant of this type" },
1550   { NULL }
1551 };
1552
1553 static PyNumberMethods type_object_as_number = {
1554   NULL,                       /* nb_add */
1555   NULL,                       /* nb_subtract */
1556   NULL,                       /* nb_multiply */
1557 #ifndef IS_PY3K
1558   NULL,                       /* nb_divide */
1559 #endif
1560   NULL,                       /* nb_remainder */
1561   NULL,                       /* nb_divmod */
1562   NULL,                       /* nb_power */
1563   NULL,                       /* nb_negative */
1564   NULL,                       /* nb_positive */
1565   NULL,                       /* nb_absolute */
1566   typy_nonzero,               /* nb_nonzero */
1567   NULL,                       /* nb_invert */
1568   NULL,                       /* nb_lshift */
1569   NULL,                       /* nb_rshift */
1570   NULL,                       /* nb_and */
1571   NULL,                       /* nb_xor */
1572   NULL,                       /* nb_or */
1573 #ifdef IS_PY3K
1574   NULL,                       /* nb_int */
1575   NULL,                       /* reserved */
1576 #else
1577   NULL,                       /* nb_coerce */
1578   NULL,                       /* nb_int */
1579   NULL,                       /* nb_long */
1580 #endif
1581   NULL,                       /* nb_float */
1582 #ifndef IS_PY3K
1583   NULL,                       /* nb_oct */
1584   NULL                        /* nb_hex */
1585 #endif
1586 };
1587
1588 static PyMappingMethods typy_mapping = {
1589   typy_length,
1590   typy_getitem,
1591   NULL                            /* no "set" method */
1592 };
1593
1594 PyTypeObject type_object_type =
1595 {
1596   PyVarObject_HEAD_INIT (NULL, 0)
1597   "gdb.Type",                     /*tp_name*/
1598   sizeof (type_object),           /*tp_basicsize*/
1599   0,                              /*tp_itemsize*/
1600   typy_dealloc,                   /*tp_dealloc*/
1601   0,                              /*tp_print*/
1602   0,                              /*tp_getattr*/
1603   0,                              /*tp_setattr*/
1604   0,                              /*tp_compare*/
1605   0,                              /*tp_repr*/
1606   &type_object_as_number,         /*tp_as_number*/
1607   0,                              /*tp_as_sequence*/
1608   &typy_mapping,                  /*tp_as_mapping*/
1609   0,                              /*tp_hash */
1610   0,                              /*tp_call*/
1611   typy_str,                       /*tp_str*/
1612   0,                              /*tp_getattro*/
1613   0,                              /*tp_setattro*/
1614   0,                              /*tp_as_buffer*/
1615   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER,  /*tp_flags*/
1616   "GDB type object",              /* tp_doc */
1617   0,                              /* tp_traverse */
1618   0,                              /* tp_clear */
1619   typy_richcompare,               /* tp_richcompare */
1620   0,                              /* tp_weaklistoffset */
1621   typy_iter,                      /* tp_iter */
1622   0,                              /* tp_iternext */
1623   type_object_methods,            /* tp_methods */
1624   0,                              /* tp_members */
1625   type_object_getset,             /* tp_getset */
1626   0,                              /* tp_base */
1627   0,                              /* tp_dict */
1628   0,                              /* tp_descr_get */
1629   0,                              /* tp_descr_set */
1630   0,                              /* tp_dictoffset */
1631   0,                              /* tp_init */
1632   0,                              /* tp_alloc */
1633   0,                              /* tp_new */
1634 };
1635
1636 static gdb_PyGetSetDef field_object_getset[] =
1637 {
1638   { "__dict__", gdb_py_generic_dict, NULL,
1639     "The __dict__ for this field.", &field_object_type },
1640   { NULL }
1641 };
1642
1643 PyTypeObject field_object_type =
1644 {
1645   PyVarObject_HEAD_INIT (NULL, 0)
1646   "gdb.Field",                    /*tp_name*/
1647   sizeof (field_object),          /*tp_basicsize*/
1648   0,                              /*tp_itemsize*/
1649   field_dealloc,                  /*tp_dealloc*/
1650   0,                              /*tp_print*/
1651   0,                              /*tp_getattr*/
1652   0,                              /*tp_setattr*/
1653   0,                              /*tp_compare*/
1654   0,                              /*tp_repr*/
1655   0,                              /*tp_as_number*/
1656   0,                              /*tp_as_sequence*/
1657   0,                              /*tp_as_mapping*/
1658   0,                              /*tp_hash */
1659   0,                              /*tp_call*/
1660   0,                              /*tp_str*/
1661   0,                              /*tp_getattro*/
1662   0,                              /*tp_setattro*/
1663   0,                              /*tp_as_buffer*/
1664   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER,  /*tp_flags*/
1665   "GDB field object",             /* tp_doc */
1666   0,                              /* tp_traverse */
1667   0,                              /* tp_clear */
1668   0,                              /* tp_richcompare */
1669   0,                              /* tp_weaklistoffset */
1670   0,                              /* tp_iter */
1671   0,                              /* tp_iternext */
1672   0,                              /* tp_methods */
1673   0,                              /* tp_members */
1674   field_object_getset,            /* tp_getset */
1675   0,                              /* tp_base */
1676   0,                              /* tp_dict */
1677   0,                              /* tp_descr_get */
1678   0,                              /* tp_descr_set */
1679   offsetof (field_object, dict),  /* tp_dictoffset */
1680   0,                              /* tp_init */
1681   0,                              /* tp_alloc */
1682   0,                              /* tp_new */
1683 };
1684
1685 PyTypeObject type_iterator_object_type = {
1686   PyVarObject_HEAD_INIT (NULL, 0)
1687   "gdb.TypeIterator",             /*tp_name*/
1688   sizeof (typy_iterator_object),  /*tp_basicsize*/
1689   0,                              /*tp_itemsize*/
1690   typy_iterator_dealloc,          /*tp_dealloc*/
1691   0,                              /*tp_print*/
1692   0,                              /*tp_getattr*/
1693   0,                              /*tp_setattr*/
1694   0,                              /*tp_compare*/
1695   0,                              /*tp_repr*/
1696   0,                              /*tp_as_number*/
1697   0,                              /*tp_as_sequence*/
1698   0,                              /*tp_as_mapping*/
1699   0,                              /*tp_hash */
1700   0,                              /*tp_call*/
1701   0,                              /*tp_str*/
1702   0,                              /*tp_getattro*/
1703   0,                              /*tp_setattro*/
1704   0,                              /*tp_as_buffer*/
1705   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER,  /*tp_flags*/
1706   "GDB type iterator object",     /*tp_doc */
1707   0,                              /*tp_traverse */
1708   0,                              /*tp_clear */
1709   0,                              /*tp_richcompare */
1710   0,                              /*tp_weaklistoffset */
1711   typy_iterator_iter,             /*tp_iter */
1712   typy_iterator_iternext,         /*tp_iternext */
1713   0                               /*tp_methods */
1714 };