gdb/python/py-value.c

   1 /* Python interface to values.
   2
   3    Copyright (C) 2008-2019 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 "charset.h"
  22 #include "value.h"
  23 #include "language.h"
  24 #include "target-float.h"
  25 #include "valprint.h"
  26 #include "infcall.h"
  27 #include "expression.h"
  28 #include "cp-abi.h"
  29 #include "python.h"
  30
  31 #include "python-internal.h"
  32 #include "py-ref.h"
  33
  34 /* Even though Python scalar types directly map to host types, we use
  35    target types here to remain consistent with the values system in
  36    GDB (which uses target arithmetic).  */
  37
  38 /* Python's integer type corresponds to C's long type.  */
  39 #define builtin_type_pyint builtin_type (python_gdbarch)->builtin_long
  40
  41 /* Python's float type corresponds to C's double type.  */
  42 #define builtin_type_pyfloat builtin_type (python_gdbarch)->builtin_double
  43
  44 /* Python's long type corresponds to C's long long type.  */
  45 #define builtin_type_pylong builtin_type (python_gdbarch)->builtin_long_long
  46
  47 /* Python's long type corresponds to C's long long type.  Unsigned version.  */
  48 #define builtin_type_upylong builtin_type \
  49   (python_gdbarch)->builtin_unsigned_long_long
  50
  51 #define builtin_type_pybool \
  52   language_bool_type (python_language, python_gdbarch)
  53
  54 #define builtin_type_pychar \
  55   language_string_char_type (python_language, python_gdbarch)
  56
  57 typedef struct value_object {
  58   PyObject_HEAD
  59   struct value_object *next;
  60   struct value_object *prev;
  61   struct value *value;
  62   PyObject *address;
  63   PyObject *type;
  64   PyObject *dynamic_type;
  65 } value_object;
  66
  67 /* List of all values which are currently exposed to Python. It is
  68    maintained so that when an objfile is discarded, preserve_values
  69    can copy the values' types if needed.  */
  70 /* This variable is unnecessarily initialized to NULL in order to
  71    work around a linker bug on MacOS.  */
  72 static value_object *values_in_python = NULL;
  73
  74 /* Called by the Python interpreter when deallocating a value object.  */
  75 static void
  76 valpy_dealloc (PyObject *obj)
  77 {
  78   value_object *self = (value_object *) obj;
  79
  80   /* Remove SELF from the global list.  */
  81   if (self->prev)
  82     self->prev->next = self->next;
  83   else
  84     {
  85       gdb_assert (values_in_python == self);
  86       values_in_python = self->next;
  87     }
  88   if (self->next)
  89     self->next->prev = self->prev;
  90
  91   value_decref (self->value);
  92
  93   Py_XDECREF (self->address);
  94   Py_XDECREF (self->type);
  95   Py_XDECREF (self->dynamic_type);
  96
  97   Py_TYPE (self)->tp_free (self);
  98 }
  99
 100 /* Helper to push a Value object on the global list.  */
 101 static void
 102 note_value (value_object *value_obj)
 103 {
 104   value_obj->next = values_in_python;
 105   if (value_obj->next)
 106     value_obj->next->prev = value_obj;
 107   value_obj->prev = NULL;
 108   values_in_python = value_obj;
 109 }
 110
 111 /* Called when a new gdb.Value object needs to be allocated.  Returns NULL on
 112    error, with a python exception set.  */
 113 static PyObject *
 114 valpy_new (PyTypeObject *subtype, PyObject *args, PyObject *keywords)
 115 {
 116   struct value *value = NULL;   /* Initialize to appease gcc warning.  */
 117   value_object *value_obj;
 118
 119   if (PyTuple_Size (args) != 1)
 120     {
 121       PyErr_SetString (PyExc_TypeError, _("Value object creation takes only "
 122                                           "1 argument"));
 123       return NULL;
 124     }
 125
 126   value_obj = (value_object *) subtype->tp_alloc (subtype, 1);
 127   if (value_obj == NULL)
 128     {
 129       PyErr_SetString (PyExc_MemoryError, _("Could not allocate memory to "
 130                                             "create Value object."));
 131       return NULL;
 132     }
 133
 134   value = convert_value_from_python (PyTuple_GetItem (args, 0));
 135   if (value == NULL)
 136     {
 137       subtype->tp_free (value_obj);
 138       return NULL;
 139     }
 140
 141   value_obj->value = release_value (value).release ();
 142   value_obj->address = NULL;
 143   value_obj->type = NULL;
 144   value_obj->dynamic_type = NULL;
 145   note_value (value_obj);
 146
 147   return (PyObject *) value_obj;
 148 }
 149
 150 /* Iterate over all the Value objects, calling preserve_one_value on
 151    each.  */
 152 void
 153 gdbpy_preserve_values (const struct extension_language_defn *extlang,
 154                        struct objfile *objfile, htab_t copied_types)
 155 {
 156   value_object *iter;
 157
 158   for (iter = values_in_python; iter; iter = iter->next)
 159     preserve_one_value (iter->value, objfile, copied_types);
 160 }
 161
 162 /* Given a value of a pointer type, apply the C unary * operator to it.  */
 163 static PyObject *
 164 valpy_dereference (PyObject *self, PyObject *args)
 165 {
 166   PyObject *result = NULL;
 167
 168   TRY
 169     {
 170       struct value *res_val;
 171       scoped_value_mark free_values;
 172
 173       res_val = value_ind (((value_object *) self)->value);
 174       result = value_to_value_object (res_val);
 175     }
 176   CATCH (except, RETURN_MASK_ALL)
 177     {
 178       GDB_PY_HANDLE_EXCEPTION (except);
 179     }
 180   END_CATCH
 181
 182   return result;
 183 }
 184
 185 /* Given a value of a pointer type or a reference type, return the value
 186    referenced. The difference between this function and valpy_dereference is
 187    that the latter applies * unary operator to a value, which need not always
 188    result in the value referenced. For example, for a value which is a reference
 189    to an 'int' pointer ('int *'), valpy_dereference will result in a value of
 190    type 'int' while valpy_referenced_value will result in a value of type
 191    'int *'.  */
 192
 193 static PyObject *
 194 valpy_referenced_value (PyObject *self, PyObject *args)
 195 {
 196   PyObject *result = NULL;
 197
 198   TRY
 199     {
 200       struct value *self_val, *res_val;
 201       scoped_value_mark free_values;
 202
 203       self_val = ((value_object *) self)->value;
 204       switch (TYPE_CODE (check_typedef (value_type (self_val))))
 205         {
 206         case TYPE_CODE_PTR:
 207           res_val = value_ind (self_val);
 208           break;
 209         case TYPE_CODE_REF:
 210         case TYPE_CODE_RVALUE_REF:
 211           res_val = coerce_ref (self_val);
 212           break;
 213         default:
 214           error(_("Trying to get the referenced value from a value which is "
 215                   "neither a pointer nor a reference."));
 216         }
 217
 218       result = value_to_value_object (res_val);
 219     }
 220   CATCH (except, RETURN_MASK_ALL)
 221     {
 222       GDB_PY_HANDLE_EXCEPTION (except);
 223     }
 224   END_CATCH
 225
 226   return result;
 227 }
 228
 229 /* Return a value which is a reference to the value.  */
 230
 231 static PyObject *
 232 valpy_reference_value (PyObject *self, PyObject *args, enum type_code refcode)
 233 {
 234   PyObject *result = NULL;
 235
 236   TRY
 237     {
 238       struct value *self_val;
 239       scoped_value_mark free_values;
 240
 241       self_val = ((value_object *) self)->value;
 242       result = value_to_value_object (value_ref (self_val, refcode));
 243     }
 244   CATCH (except, RETURN_MASK_ALL)
 245     {
 246       GDB_PY_HANDLE_EXCEPTION (except);
 247     }
 248   END_CATCH
 249
 250   return result;
 251 }
 252
 253 static PyObject *
 254 valpy_lvalue_reference_value (PyObject *self, PyObject *args)
 255 {
 256   return valpy_reference_value (self, args, TYPE_CODE_REF);
 257 }
 258
 259 static PyObject *
 260 valpy_rvalue_reference_value (PyObject *self, PyObject *args)
 261 {
 262   return valpy_reference_value (self, args, TYPE_CODE_RVALUE_REF);
 263 }
 264
 265 /* Return a "const" qualified version of the value.  */
 266
 267 static PyObject *
 268 valpy_const_value (PyObject *self, PyObject *args)
 269 {
 270   PyObject *result = NULL;
 271
 272   TRY
 273     {
 274       struct value *self_val, *res_val;
 275       scoped_value_mark free_values;
 276
 277       self_val = ((value_object *) self)->value;
 278       res_val = make_cv_value (1, 0, self_val);
 279       result = value_to_value_object (res_val);
 280     }
 281   CATCH (except, RETURN_MASK_ALL)
 282     {
 283       GDB_PY_HANDLE_EXCEPTION (except);
 284     }
 285   END_CATCH
 286
 287   return result;
 288 }
 289
 290 /* Return "&value".  */
 291 static PyObject *
 292 valpy_get_address (PyObject *self, void *closure)
 293 {
 294   value_object *val_obj = (value_object *) self;
 295
 296   if (!val_obj->address)
 297     {
 298       TRY
 299         {
 300           struct value *res_val;
 301           scoped_value_mark free_values;
 302
 303           res_val = value_addr (val_obj->value);
 304           val_obj->address = value_to_value_object (res_val);
 305         }
 306       CATCH (except, RETURN_MASK_ALL)
 307         {
 308           val_obj->address = Py_None;
 309           Py_INCREF (Py_None);
 310         }
 311       END_CATCH
 312     }
 313
 314   Py_XINCREF (val_obj->address);
 315
 316   return val_obj->address;
 317 }
 318
 319 /* Return type of the value.  */
 320 static PyObject *
 321 valpy_get_type (PyObject *self, void *closure)
 322 {
 323   value_object *obj = (value_object *) self;
 324
 325   if (!obj->type)
 326     {
 327       obj->type = type_to_type_object (value_type (obj->value));
 328       if (!obj->type)
 329         return NULL;
 330     }
 331   Py_INCREF (obj->type);
 332   return obj->type;
 333 }
 334
 335 /* Return dynamic type of the value.  */
 336
 337 static PyObject *
 338 valpy_get_dynamic_type (PyObject *self, void *closure)
 339 {
 340   value_object *obj = (value_object *) self;
 341   struct type *type = NULL;
 342
 343   if (obj->dynamic_type != NULL)
 344     {
 345       Py_INCREF (obj->dynamic_type);
 346       return obj->dynamic_type;
 347     }
 348
 349   TRY
 350     {
 351       struct value *val = obj->value;
 352       scoped_value_mark free_values;
 353
 354       type = value_type (val);
 355       type = check_typedef (type);
 356
 357       if (((TYPE_CODE (type) == TYPE_CODE_PTR) || TYPE_IS_REFERENCE (type))
 358           && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_STRUCT))
 359         {
 360           struct value *target;
 361           int was_pointer = TYPE_CODE (type) == TYPE_CODE_PTR;
 362
 363           if (was_pointer)
 364             target = value_ind (val);
 365           else
 366             target = coerce_ref (val);
 367           type = value_rtti_type (target, NULL, NULL, NULL);
 368
 369           if (type)
 370             {
 371               if (was_pointer)
 372                 type = lookup_pointer_type (type);
 373               else
 374                 type = lookup_lvalue_reference_type (type);
 375             }
 376         }
 377       else if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
 378         type = value_rtti_type (val, NULL, NULL, NULL);
 379       else
 380         {
 381           /* Re-use object's static type.  */
 382           type = NULL;
 383         }
 384     }
 385   CATCH (except, RETURN_MASK_ALL)
 386     {
 387       GDB_PY_HANDLE_EXCEPTION (except);
 388     }
 389   END_CATCH
 390
 391   if (type == NULL)
 392     obj->dynamic_type = valpy_get_type (self, NULL);
 393   else
 394     obj->dynamic_type = type_to_type_object (type);
 395
 396   Py_XINCREF (obj->dynamic_type);
 397   return obj->dynamic_type;
 398 }
 399
 400 /* Implementation of gdb.Value.lazy_string ([encoding] [, length]) ->
 401    string.  Return a PyObject representing a lazy_string_object type.
 402    A lazy string is a pointer to a string with an optional encoding and
 403    length.  If ENCODING is not given, encoding is set to None.  If an
 404    ENCODING is provided the encoding parameter is set to ENCODING, but
 405    the string is not encoded.
 406    If LENGTH is provided then the length parameter is set to LENGTH.
 407    Otherwise if the value is an array of known length then the array's length
 408    is used.  Otherwise the length will be set to -1 (meaning first null of
 409    appropriate with).
 410
 411    Note: In order to not break any existing uses this allows creating
 412    lazy strings from anything.  PR 20769.  E.g.,
 413    gdb.parse_and_eval("my_int_variable").lazy_string().
 414    "It's easier to relax restrictions than it is to impose them after the
 415    fact."  So we should be flagging any unintended uses as errors, but it's
 416    perhaps too late for that.  */
 417
 418 static PyObject *
 419 valpy_lazy_string (PyObject *self, PyObject *args, PyObject *kw)
 420 {
 421   gdb_py_longest length = -1;
 422   struct value *value = ((value_object *) self)->value;
 423   const char *user_encoding = NULL;
 424   static const char *keywords[] = { "encoding", "length", NULL };
 425   PyObject *str_obj = NULL;
 426
 427   if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "|s" GDB_PY_LL_ARG,
 428                                         keywords, &user_encoding, &length))
 429     return NULL;
 430
 431   if (length < -1)
 432     {
 433       PyErr_SetString (PyExc_ValueError, _("Invalid length."));
 434       return NULL;
 435     }
 436
 437   TRY
 438     {
 439       scoped_value_mark free_values;
 440       struct type *type, *realtype;
 441       CORE_ADDR addr;
 442
 443       type = value_type (value);
 444       realtype = check_typedef (type);
 445
 446       switch (TYPE_CODE (realtype))
 447         {
 448         case TYPE_CODE_ARRAY:
 449           {
 450             LONGEST array_length = -1;
 451             LONGEST low_bound, high_bound;
 452
 453             /* PR 20786: There's no way to specify an array of length zero.
 454                Record a length of [0,-1] which is how Ada does it.  Anything
 455                we do is broken, but this one possible solution.  */
 456             if (get_array_bounds (realtype, &low_bound, &high_bound))
 457               array_length = high_bound - low_bound + 1;
 458             if (length == -1)
 459               length = array_length;
 460             else if (array_length == -1)
 461               {
 462                 type = lookup_array_range_type (TYPE_TARGET_TYPE (realtype),
 463                                                 0, length - 1);
 464               }
 465             else if (length != array_length)
 466               {
 467                 /* We need to create a new array type with the
 468                    specified length.  */
 469                 if (length > array_length)
 470                   error (_("Length is larger than array size."));
 471                 type = lookup_array_range_type (TYPE_TARGET_TYPE (realtype),
 472                                                 low_bound,
 473                                                 low_bound + length - 1);
 474               }
 475             addr = value_address (value);
 476             break;
 477           }
 478         case TYPE_CODE_PTR:
 479           /* If a length is specified we defer creating an array of the
 480              specified width until we need to.  */
 481           addr = value_as_address (value);
 482           break;
 483         default:
 484           /* Should flag an error here.  PR 20769.  */
 485           addr = value_address (value);
 486           break;
 487         }
 488
 489       str_obj = gdbpy_create_lazy_string_object (addr, length, user_encoding,
 490                                                  type);
 491     }
 492   CATCH (except, RETURN_MASK_ALL)
 493     {
 494       GDB_PY_HANDLE_EXCEPTION (except);
 495     }
 496   END_CATCH
 497
 498   return str_obj;
 499 }
 500
 501 /* Implementation of gdb.Value.string ([encoding] [, errors]
 502    [, length]) -> string.  Return Unicode string with value contents.
 503    If ENCODING is not given, the string is assumed to be encoded in
 504    the target's charset.  If LENGTH is provided, only fetch string to
 505    the length provided.  */
 506
 507 static PyObject *
 508 valpy_string (PyObject *self, PyObject *args, PyObject *kw)
 509 {
 510   int length = -1;
 511   gdb::unique_xmalloc_ptr<gdb_byte> buffer;
 512   struct value *value = ((value_object *) self)->value;
 513   const char *encoding = NULL;
 514   const char *errors = NULL;
 515   const char *user_encoding = NULL;
 516   const char *la_encoding = NULL;
 517   struct type *char_type;
 518   static const char *keywords[] = { "encoding", "errors", "length", NULL };
 519
 520   if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "|ssi", keywords,
 521                                         &user_encoding, &errors, &length))
 522     return NULL;
 523
 524   TRY
 525     {
 526       LA_GET_STRING (value, &buffer, &length, &char_type, &la_encoding);
 527     }
 528   CATCH (except, RETURN_MASK_ALL)
 529     {
 530       GDB_PY_HANDLE_EXCEPTION (except);
 531     }
 532   END_CATCH
 533
 534   encoding = (user_encoding && *user_encoding) ? user_encoding : la_encoding;
 535   return PyUnicode_Decode ((const char *) buffer.get (),
 536                            length * TYPE_LENGTH (char_type),
 537                            encoding, errors);
 538 }
 539
 540 /* A helper function that implements the various cast operators.  */
 541
 542 static PyObject *
 543 valpy_do_cast (PyObject *self, PyObject *args, enum exp_opcode op)
 544 {
 545   PyObject *type_obj, *result = NULL;
 546   struct type *type;
 547
 548   if (! PyArg_ParseTuple (args, "O", &type_obj))
 549     return NULL;
 550
 551   type = type_object_to_type (type_obj);
 552   if (! type)
 553     {
 554       PyErr_SetString (PyExc_RuntimeError,
 555                        _("Argument must be a type."));
 556       return NULL;
 557     }
 558
 559   TRY
 560     {
 561       struct value *val = ((value_object *) self)->value;
 562       struct value *res_val;
 563       scoped_value_mark free_values;
 564
 565       if (op == UNOP_DYNAMIC_CAST)
 566         res_val = value_dynamic_cast (type, val);
 567       else if (op == UNOP_REINTERPRET_CAST)
 568         res_val = value_reinterpret_cast (type, val);
 569       else
 570         {
 571           gdb_assert (op == UNOP_CAST);
 572           res_val = value_cast (type, val);
 573         }
 574
 575       result = value_to_value_object (res_val);
 576     }
 577   CATCH (except, RETURN_MASK_ALL)
 578     {
 579       GDB_PY_HANDLE_EXCEPTION (except);
 580     }
 581   END_CATCH
 582
 583   return result;
 584 }
 585
 586 /* Implementation of the "cast" method.  */
 587
 588 static PyObject *
 589 valpy_cast (PyObject *self, PyObject *args)
 590 {
 591   return valpy_do_cast (self, args, UNOP_CAST);
 592 }
 593
 594 /* Implementation of the "dynamic_cast" method.  */
 595
 596 static PyObject *
 597 valpy_dynamic_cast (PyObject *self, PyObject *args)
 598 {
 599   return valpy_do_cast (self, args, UNOP_DYNAMIC_CAST);
 600 }
 601
 602 /* Implementation of the "reinterpret_cast" method.  */
 603
 604 static PyObject *
 605 valpy_reinterpret_cast (PyObject *self, PyObject *args)
 606 {
 607   return valpy_do_cast (self, args, UNOP_REINTERPRET_CAST);
 608 }
 609
 610 static Py_ssize_t
 611 valpy_length (PyObject *self)
 612 {
 613   /* We don't support getting the number of elements in a struct / class.  */
 614   PyErr_SetString (PyExc_NotImplementedError,
 615                    _("Invalid operation on gdb.Value."));
 616   return -1;
 617 }
 618
 619 /* Return 1 if the gdb.Field object FIELD is present in the value V.
 620    Returns 0 otherwise.  If any Python error occurs, -1 is returned.  */
 621
 622 static int
 623 value_has_field (struct value *v, PyObject *field)
 624 {
 625   struct type *parent_type, *val_type;
 626   enum type_code type_code;
 627   gdbpy_ref<> type_object (PyObject_GetAttrString (field, "parent_type"));
 628   int has_field = 0;
 629
 630   if (type_object == NULL)
 631     return -1;
 632
 633   parent_type = type_object_to_type (type_object.get ());
 634   if (parent_type == NULL)
 635     {
 636       PyErr_SetString (PyExc_TypeError,
 637                        _("'parent_type' attribute of gdb.Field object is not a"
 638                          "gdb.Type object."));
 639       return -1;
 640     }
 641
 642   TRY
 643     {
 644       val_type = value_type (v);
 645       val_type = check_typedef (val_type);
 646       if (TYPE_IS_REFERENCE (val_type) || TYPE_CODE (val_type) == TYPE_CODE_PTR)
 647       val_type = check_typedef (TYPE_TARGET_TYPE (val_type));
 648
 649       type_code = TYPE_CODE (val_type);
 650       if ((type_code == TYPE_CODE_STRUCT || type_code == TYPE_CODE_UNION)
 651           && types_equal (val_type, parent_type))
 652         has_field = 1;
 653       else
 654         has_field = 0;
 655     }
 656   CATCH (except, RETURN_MASK_ALL)
 657     {
 658       GDB_PY_SET_HANDLE_EXCEPTION (except);
 659     }
 660   END_CATCH
 661
 662   return has_field;
 663 }
 664
 665 /* Return the value of a flag FLAG_NAME in a gdb.Field object FIELD.
 666    Returns 1 if the flag value is true, 0 if it is false, and -1 if
 667    a Python error occurs.  */
 668
 669 static int
 670 get_field_flag (PyObject *field, const char *flag_name)
 671 {
 672   gdbpy_ref<> flag_object (PyObject_GetAttrString (field, flag_name));
 673
 674   if (flag_object == NULL)
 675     return -1;
 676
 677   return PyObject_IsTrue (flag_object.get ());
 678 }
 679
 680 /* Return the "type" attribute of a gdb.Field object.
 681    Returns NULL on error, with a Python exception set.  */
 682
 683 static struct type *
 684 get_field_type (PyObject *field)
 685 {
 686   gdbpy_ref<> ftype_obj (PyObject_GetAttrString (field, "type"));
 687   struct type *ftype;
 688
 689   if (ftype_obj == NULL)
 690     return NULL;
 691   ftype = type_object_to_type (ftype_obj.get ());
 692   if (ftype == NULL)
 693     PyErr_SetString (PyExc_TypeError,
 694                      _("'type' attribute of gdb.Field object is not a "
 695                        "gdb.Type object."));
 696
 697   return ftype;
 698 }
 699
 700 /* Given string name or a gdb.Field object corresponding to an element inside
 701    a structure, return its value object.  Returns NULL on error, with a python
 702    exception set.  */
 703
 704 static PyObject *
 705 valpy_getitem (PyObject *self, PyObject *key)
 706 {
 707   struct gdb_exception except = exception_none;
 708   value_object *self_value = (value_object *) self;
 709   gdb::unique_xmalloc_ptr<char> field;
 710   struct type *base_class_type = NULL, *field_type = NULL;
 711   long bitpos = -1;
 712   PyObject *result = NULL;
 713
 714   if (gdbpy_is_string (key))
 715     {
 716       field = python_string_to_host_string (key);
 717       if (field == NULL)
 718         return NULL;
 719     }
 720   else if (gdbpy_is_field (key))
 721     {
 722       int is_base_class, valid_field;
 723
 724       valid_field = value_has_field (self_value->value, key);
 725       if (valid_field < 0)
 726         return NULL;
 727       else if (valid_field == 0)
 728         {
 729           PyErr_SetString (PyExc_TypeError,
 730                            _("Invalid lookup for a field not contained in "
 731                              "the value."));
 732
 733           return NULL;
 734         }
 735
 736       is_base_class = get_field_flag (key, "is_base_class");
 737       if (is_base_class < 0)
 738         return NULL;
 739       else if (is_base_class > 0)
 740         {
 741           base_class_type = get_field_type (key);
 742           if (base_class_type == NULL)
 743             return NULL;
 744         }
 745       else
 746         {
 747           gdbpy_ref<> name_obj (PyObject_GetAttrString (key, "name"));
 748
 749           if (name_obj == NULL)
 750             return NULL;
 751
 752           if (name_obj != Py_None)
 753             {
 754               field = python_string_to_host_string (name_obj.get ());
 755               if (field == NULL)
 756                 return NULL;
 757             }
 758           else
 759             {
 760               if (!PyObject_HasAttrString (key, "bitpos"))
 761                 {
 762                   PyErr_SetString (PyExc_AttributeError,
 763                                    _("gdb.Field object has no name and no "
 764                                      "'bitpos' attribute."));
 765
 766                   return NULL;
 767                 }
 768               gdbpy_ref<> bitpos_obj (PyObject_GetAttrString (key, "bitpos"));
 769               if (bitpos_obj == NULL)
 770                 return NULL;
 771               if (!gdb_py_int_as_long (bitpos_obj.get (), &bitpos))
 772                 return NULL;
 773
 774               field_type = get_field_type (key);
 775               if (field_type == NULL)
 776                 return NULL;
 777             }
 778         }
 779     }
 780
 781   TRY
 782     {
 783       struct value *tmp = self_value->value;
 784       struct value *res_val = NULL;
 785       scoped_value_mark free_values;
 786
 787       if (field)
 788         res_val = value_struct_elt (&tmp, NULL, field.get (), NULL,
 789                                     "struct/class/union");
 790       else if (bitpos >= 0)
 791         res_val = value_struct_elt_bitpos (&tmp, bitpos, field_type,
 792                                            "struct/class/union");
 793       else if (base_class_type != NULL)
 794         {
 795           struct type *val_type;
 796
 797           val_type = check_typedef (value_type (tmp));
 798           if (TYPE_CODE (val_type) == TYPE_CODE_PTR)
 799             res_val = value_cast (lookup_pointer_type (base_class_type), tmp);
 800           else if (TYPE_CODE (val_type) == TYPE_CODE_REF)
 801             res_val = value_cast (lookup_lvalue_reference_type (base_class_type),
 802                                   tmp);
 803           else if (TYPE_CODE (val_type) == TYPE_CODE_RVALUE_REF)
 804             res_val = value_cast (lookup_rvalue_reference_type (base_class_type),
 805                                   tmp);
 806           else
 807             res_val = value_cast (base_class_type, tmp);
 808         }
 809       else
 810         {
 811           /* Assume we are attempting an array access, and let the
 812              value code throw an exception if the index has an invalid
 813              type.  */
 814           struct value *idx = convert_value_from_python (key);
 815
 816           if (idx != NULL)
 817             {
 818               /* Check the value's type is something that can be accessed via
 819                  a subscript.  */
 820               struct type *type;
 821
 822               tmp = coerce_ref (tmp);
 823               type = check_typedef (value_type (tmp));
 824               if (TYPE_CODE (type) != TYPE_CODE_ARRAY
 825                   && TYPE_CODE (type) != TYPE_CODE_PTR)
 826                   error (_("Cannot subscript requested type."));
 827               else
 828                 res_val = value_subscript (tmp, value_as_long (idx));
 829             }
 830         }
 831
 832       if (res_val)
 833         result = value_to_value_object (res_val);
 834     }
 835   CATCH (ex, RETURN_MASK_ALL)
 836     {
 837       except = ex;
 838     }
 839   END_CATCH
 840
 841   GDB_PY_HANDLE_EXCEPTION (except);
 842
 843   return result;
 844 }
 845
 846 static int
 847 valpy_setitem (PyObject *self, PyObject *key, PyObject *value)
 848 {
 849   PyErr_Format (PyExc_NotImplementedError,
 850                 _("Setting of struct elements is not currently supported."));
 851   return -1;
 852 }
 853
 854 /* Called by the Python interpreter to perform an inferior function
 855    call on the value.  Returns NULL on error, with a python exception set.  */
 856 static PyObject *
 857 valpy_call (PyObject *self, PyObject *args, PyObject *keywords)
 858 {
 859   Py_ssize_t args_count;
 860   struct value *function = ((value_object *) self)->value;
 861   struct value **vargs = NULL;
 862   struct type *ftype = NULL;
 863   PyObject *result = NULL;
 864
 865   TRY
 866     {
 867       ftype = check_typedef (value_type (function));
 868     }
 869   CATCH (except, RETURN_MASK_ALL)
 870     {
 871       GDB_PY_HANDLE_EXCEPTION (except);
 872     }
 873   END_CATCH
 874
 875   if (TYPE_CODE (ftype) != TYPE_CODE_FUNC)
 876     {
 877       PyErr_SetString (PyExc_RuntimeError,
 878                        _("Value is not callable (not TYPE_CODE_FUNC)."));
 879       return NULL;
 880     }
 881
 882   if (! PyTuple_Check (args))
 883     {
 884       PyErr_SetString (PyExc_TypeError,
 885                        _("Inferior arguments must be provided in a tuple."));
 886       return NULL;
 887     }
 888
 889   args_count = PyTuple_Size (args);
 890   if (args_count > 0)
 891     {
 892       int i;
 893
 894       vargs = XALLOCAVEC (struct value *, args_count);
 895       for (i = 0; i < args_count; i++)
 896         {
 897           PyObject *item = PyTuple_GetItem (args, i);
 898
 899           if (item == NULL)
 900             return NULL;
 901
 902           vargs[i] = convert_value_from_python (item);
 903           if (vargs[i] == NULL)
 904             return NULL;
 905         }
 906     }
 907
 908   TRY
 909     {
 910       scoped_value_mark free_values;
 911
 912       value *return_value
 913         = call_function_by_hand (function, NULL,
 914                                  gdb::make_array_view (vargs, args_count));
 915       result = value_to_value_object (return_value);
 916     }
 917   CATCH (except, RETURN_MASK_ALL)
 918     {
 919       GDB_PY_HANDLE_EXCEPTION (except);
 920     }
 921   END_CATCH
 922
 923   return result;
 924 }
 925
 926 /* Called by the Python interpreter to obtain string representation
 927    of the object.  */
 928 static PyObject *
 929 valpy_str (PyObject *self)
 930 {
 931   struct value_print_options opts;
 932
 933   get_user_print_options (&opts);
 934   opts.deref_ref = 0;
 935
 936   string_file stb;
 937
 938   TRY
 939     {
 940       common_val_print (((value_object *) self)->value, &stb, 0,
 941                         &opts, python_language);
 942     }
 943   CATCH (except, RETURN_MASK_ALL)
 944     {
 945       GDB_PY_HANDLE_EXCEPTION (except);
 946     }
 947   END_CATCH
 948
 949   return PyUnicode_Decode (stb.c_str (), stb.size (), host_charset (), NULL);
 950 }
 951
 952 /* Implements gdb.Value.is_optimized_out.  */
 953 static PyObject *
 954 valpy_get_is_optimized_out (PyObject *self, void *closure)
 955 {
 956   struct value *value = ((value_object *) self)->value;
 957   int opt = 0;
 958
 959   TRY
 960     {
 961       opt = value_optimized_out (value);
 962     }
 963   CATCH (except, RETURN_MASK_ALL)
 964     {
 965       GDB_PY_HANDLE_EXCEPTION (except);
 966     }
 967   END_CATCH
 968
 969   if (opt)
 970     Py_RETURN_TRUE;
 971
 972   Py_RETURN_FALSE;
 973 }
 974
 975 /* Implements gdb.Value.is_lazy.  */
 976 static PyObject *
 977 valpy_get_is_lazy (PyObject *self, void *closure)
 978 {
 979   struct value *value = ((value_object *) self)->value;
 980   int opt = 0;
 981
 982   TRY
 983     {
 984       opt = value_lazy (value);
 985     }
 986   CATCH (except, RETURN_MASK_ALL)
 987     {
 988       GDB_PY_HANDLE_EXCEPTION (except);
 989     }
 990   END_CATCH
 991
 992   if (opt)
 993     Py_RETURN_TRUE;
 994
 995   Py_RETURN_FALSE;
 996 }
 997
 998 /* Implements gdb.Value.fetch_lazy ().  */
 999 static PyObject *
1000 valpy_fetch_lazy (PyObject *self, PyObject *args)
1001 {
1002   struct value *value = ((value_object *) self)->value;
1003
1004   TRY
1005     {
1006       if (value_lazy (value))
1007         value_fetch_lazy (value);
1008     }
1009   CATCH (except, RETURN_MASK_ALL)
1010     {
1011       GDB_PY_HANDLE_EXCEPTION (except);
1012     }
1013   END_CATCH
1014
1015   Py_RETURN_NONE;
1016 }
1017
1018 /* Calculate and return the address of the PyObject as the value of
1019    the builtin __hash__ call.  */
1020 static Py_hash_t
1021 valpy_hash (PyObject *self)
1022 {
1023   return (intptr_t) self;
1024 }
1025
1026 enum valpy_opcode
1027 {
1028   VALPY_ADD,
1029   VALPY_SUB,
1030   VALPY_MUL,
1031   VALPY_DIV,
1032   VALPY_REM,
1033   VALPY_POW,
1034   VALPY_LSH,
1035   VALPY_RSH,
1036   VALPY_BITAND,
1037   VALPY_BITOR,
1038   VALPY_BITXOR
1039 };
1040
1041 /* If TYPE is a reference, return the target; otherwise return TYPE.  */
1042 #define STRIP_REFERENCE(TYPE) \
1043   (TYPE_IS_REFERENCE (TYPE) ? (TYPE_TARGET_TYPE (TYPE)) : (TYPE))
1044
1045 /* Helper for valpy_binop.  Returns a value object which is the result
1046    of applying the operation specified by OPCODE to the given
1047    arguments.  Throws a GDB exception on error.  */
1048
1049 static PyObject *
1050 valpy_binop_throw (enum valpy_opcode opcode, PyObject *self, PyObject *other)
1051 {
1052   PyObject *result = NULL;
1053
1054   struct value *arg1, *arg2;
1055   struct value *res_val = NULL;
1056   enum exp_opcode op = OP_NULL;
1057   int handled = 0;
1058
1059   scoped_value_mark free_values;
1060
1061   /* If the gdb.Value object is the second operand, then it will be
1062      passed to us as the OTHER argument, and SELF will be an entirely
1063      different kind of object, altogether.  Because of this, we can't
1064      assume self is a gdb.Value object and need to convert it from
1065      python as well.  */
1066   arg1 = convert_value_from_python (self);
1067   if (arg1 == NULL)
1068     return NULL;
1069
1070   arg2 = convert_value_from_python (other);
1071   if (arg2 == NULL)
1072     return NULL;
1073
1074   switch (opcode)
1075     {
1076     case VALPY_ADD:
1077       {
1078         struct type *ltype = value_type (arg1);
1079         struct type *rtype = value_type (arg2);
1080
1081         ltype = check_typedef (ltype);
1082         ltype = STRIP_REFERENCE (ltype);
1083         rtype = check_typedef (rtype);
1084         rtype = STRIP_REFERENCE (rtype);
1085
1086         handled = 1;
1087         if (TYPE_CODE (ltype) == TYPE_CODE_PTR
1088             && is_integral_type (rtype))
1089           res_val = value_ptradd (arg1, value_as_long (arg2));
1090         else if (TYPE_CODE (rtype) == TYPE_CODE_PTR
1091                  && is_integral_type (ltype))
1092           res_val = value_ptradd (arg2, value_as_long (arg1));
1093         else
1094           {
1095             handled = 0;
1096             op = BINOP_ADD;
1097           }
1098       }
1099       break;
1100     case VALPY_SUB:
1101       {
1102         struct type *ltype = value_type (arg1);
1103         struct type *rtype = value_type (arg2);
1104
1105         ltype = check_typedef (ltype);
1106         ltype = STRIP_REFERENCE (ltype);
1107         rtype = check_typedef (rtype);
1108         rtype = STRIP_REFERENCE (rtype);
1109
1110         handled = 1;
1111         if (TYPE_CODE (ltype) == TYPE_CODE_PTR
1112             && TYPE_CODE (rtype) == TYPE_CODE_PTR)
1113           /* A ptrdiff_t for the target would be preferable here.  */
1114           res_val = value_from_longest (builtin_type_pyint,
1115                                         value_ptrdiff (arg1, arg2));
1116         else if (TYPE_CODE (ltype) == TYPE_CODE_PTR
1117                  && is_integral_type (rtype))
1118           res_val = value_ptradd (arg1, - value_as_long (arg2));
1119         else
1120           {
1121             handled = 0;
1122             op = BINOP_SUB;
1123           }
1124       }
1125       break;
1126     case VALPY_MUL:
1127       op = BINOP_MUL;
1128       break;
1129     case VALPY_DIV:
1130       op = BINOP_DIV;
1131       break;
1132     case VALPY_REM:
1133       op = BINOP_REM;
1134       break;
1135     case VALPY_POW:
1136       op = BINOP_EXP;
1137       break;
1138     case VALPY_LSH:
1139       op = BINOP_LSH;
1140       break;
1141     case VALPY_RSH:
1142       op = BINOP_RSH;
1143       break;
1144     case VALPY_BITAND:
1145       op = BINOP_BITWISE_AND;
1146       break;
1147     case VALPY_BITOR:
1148       op = BINOP_BITWISE_IOR;
1149       break;
1150     case VALPY_BITXOR:
1151       op = BINOP_BITWISE_XOR;
1152       break;
1153     }
1154
1155   if (!handled)
1156     {
1157       if (binop_user_defined_p (op, arg1, arg2))
1158         res_val = value_x_binop (arg1, arg2, op, OP_NULL, EVAL_NORMAL);
1159       else
1160         res_val = value_binop (arg1, arg2, op);
1161     }
1162
1163   if (res_val)
1164     result = value_to_value_object (res_val);
1165
1166   return result;
1167 }
1168
1169 /* Returns a value object which is the result of applying the operation
1170    specified by OPCODE to the given arguments.  Returns NULL on error, with
1171    a python exception set.  */
1172 static PyObject *
1173 valpy_binop (enum valpy_opcode opcode, PyObject *self, PyObject *other)
1174 {
1175   PyObject *result = NULL;
1176
1177   TRY
1178     {
1179       result = valpy_binop_throw (opcode, self, other);
1180     }
1181   CATCH (except, RETURN_MASK_ALL)
1182     {
1183       GDB_PY_HANDLE_EXCEPTION (except);
1184     }
1185   END_CATCH
1186
1187   return result;
1188 }
1189
1190 static PyObject *
1191 valpy_add (PyObject *self, PyObject *other)
1192 {
1193   return valpy_binop (VALPY_ADD, self, other);
1194 }
1195
1196 static PyObject *
1197 valpy_subtract (PyObject *self, PyObject *other)
1198 {
1199   return valpy_binop (VALPY_SUB, self, other);
1200 }
1201
1202 static PyObject *
1203 valpy_multiply (PyObject *self, PyObject *other)
1204 {
1205   return valpy_binop (VALPY_MUL, self, other);
1206 }
1207
1208 static PyObject *
1209 valpy_divide (PyObject *self, PyObject *other)
1210 {
1211   return valpy_binop (VALPY_DIV, self, other);
1212 }
1213
1214 static PyObject *
1215 valpy_remainder (PyObject *self, PyObject *other)
1216 {
1217   return valpy_binop (VALPY_REM, self, other);
1218 }
1219
1220 static PyObject *
1221 valpy_power (PyObject *self, PyObject *other, PyObject *unused)
1222 {
1223   /* We don't support the ternary form of pow.  I don't know how to express
1224      that, so let's just throw NotImplementedError to at least do something
1225      about it.  */
1226   if (unused != Py_None)
1227     {
1228       PyErr_SetString (PyExc_NotImplementedError,
1229                        "Invalid operation on gdb.Value.");
1230       return NULL;
1231     }
1232
1233   return valpy_binop (VALPY_POW, self, other);
1234 }
1235
1236 static PyObject *
1237 valpy_negative (PyObject *self)
1238 {
1239   PyObject *result = NULL;
1240
1241   TRY
1242     {
1243       /* Perhaps overkill, but consistency has some virtue.  */
1244       scoped_value_mark free_values;
1245       struct value *val;
1246
1247       val = value_neg (((value_object *) self)->value);
1248       result = value_to_value_object (val);
1249     }
1250   CATCH (except, RETURN_MASK_ALL)
1251     {
1252       GDB_PY_HANDLE_EXCEPTION (except);
1253     }
1254   END_CATCH
1255
1256   return result;
1257 }
1258
1259 static PyObject *
1260 valpy_positive (PyObject *self)
1261 {
1262   return value_to_value_object (((value_object *) self)->value);
1263 }
1264
1265 static PyObject *
1266 valpy_absolute (PyObject *self)
1267 {
1268   struct value *value = ((value_object *) self)->value;
1269   int isabs = 1;
1270
1271   TRY
1272     {
1273       scoped_value_mark free_values;
1274
1275       if (value_less (value, value_zero (value_type (value), not_lval)))
1276         isabs = 0;
1277     }
1278   CATCH (except, RETURN_MASK_ALL)
1279     {
1280       GDB_PY_HANDLE_EXCEPTION (except);
1281     }
1282   END_CATCH
1283
1284   if (isabs)
1285     return valpy_positive (self);
1286   else
1287     return valpy_negative (self);
1288 }
1289
1290 /* Implements boolean evaluation of gdb.Value.  */
1291 static int
1292 valpy_nonzero (PyObject *self)
1293 {
1294   struct gdb_exception except = exception_none;
1295   value_object *self_value = (value_object *) self;
1296   struct type *type;
1297   int nonzero = 0; /* Appease GCC warning.  */
1298
1299   TRY
1300     {
1301       type = check_typedef (value_type (self_value->value));
1302
1303       if (is_integral_type (type) || TYPE_CODE (type) == TYPE_CODE_PTR)
1304         nonzero = !!value_as_long (self_value->value);
1305       else if (is_floating_value (self_value->value))
1306         nonzero = !target_float_is_zero (value_contents (self_value->value),
1307                                          type);
1308       else
1309         /* All other values are True.  */
1310         nonzero = 1;
1311     }
1312   CATCH (ex, RETURN_MASK_ALL)
1313     {
1314       except = ex;
1315     }
1316   END_CATCH
1317
1318   /* This is not documented in the Python documentation, but if this
1319      function fails, return -1 as slot_nb_nonzero does (the default
1320      Python nonzero function).  */
1321   GDB_PY_SET_HANDLE_EXCEPTION (except);
1322
1323   return nonzero;
1324 }
1325
1326 /* Implements ~ for value objects.  */
1327 static PyObject *
1328 valpy_invert (PyObject *self)
1329 {
1330   struct value *val = NULL;
1331
1332   TRY
1333     {
1334       val = value_complement (((value_object *) self)->value);
1335     }
1336   CATCH (except, RETURN_MASK_ALL)
1337     {
1338       GDB_PY_HANDLE_EXCEPTION (except);
1339     }
1340   END_CATCH
1341
1342   return value_to_value_object (val);
1343 }
1344
1345 /* Implements left shift for value objects.  */
1346 static PyObject *
1347 valpy_lsh (PyObject *self, PyObject *other)
1348 {
1349   return valpy_binop (VALPY_LSH, self, other);
1350 }
1351
1352 /* Implements right shift for value objects.  */
1353 static PyObject *
1354 valpy_rsh (PyObject *self, PyObject *other)
1355 {
1356   return valpy_binop (VALPY_RSH, self, other);
1357 }
1358
1359 /* Implements bitwise and for value objects.  */
1360 static PyObject *
1361 valpy_and (PyObject *self, PyObject *other)
1362 {
1363   return valpy_binop (VALPY_BITAND, self, other);
1364 }
1365
1366 /* Implements bitwise or for value objects.  */
1367 static PyObject *
1368 valpy_or (PyObject *self, PyObject *other)
1369 {
1370   return valpy_binop (VALPY_BITOR, self, other);
1371 }
1372
1373 /* Implements bitwise xor for value objects.  */
1374 static PyObject *
1375 valpy_xor (PyObject *self, PyObject *other)
1376 {
1377   return valpy_binop (VALPY_BITXOR, self, other);
1378 }
1379
1380 /* Helper for valpy_richcompare.  Implements comparison operations for
1381    value objects.  Returns true/false on success.  Returns -1 with a
1382    Python exception set if a Python error is detected.  Throws a GDB
1383    exception on other errors (memory error, etc.).  */
1384
1385 static int
1386 valpy_richcompare_throw (PyObject *self, PyObject *other, int op)
1387 {
1388   int result;
1389   struct value *value_other;
1390   struct value *value_self;
1391
1392   scoped_value_mark free_values;
1393
1394   value_other = convert_value_from_python (other);
1395   if (value_other == NULL)
1396     return -1;
1397
1398   value_self = ((value_object *) self)->value;
1399
1400   switch (op)
1401     {
1402     case Py_LT:
1403       result = value_less (value_self, value_other);
1404       break;
1405     case Py_LE:
1406       result = value_less (value_self, value_other)
1407         || value_equal (value_self, value_other);
1408       break;
1409     case Py_EQ:
1410       result = value_equal (value_self, value_other);
1411       break;
1412     case Py_NE:
1413       result = !value_equal (value_self, value_other);
1414       break;
1415     case Py_GT:
1416       result = value_less (value_other, value_self);
1417       break;
1418     case Py_GE:
1419       result = (value_less (value_other, value_self)
1420                 || value_equal (value_self, value_other));
1421       break;
1422     default:
1423       /* Can't happen.  */
1424       PyErr_SetString (PyExc_NotImplementedError,
1425                        _("Invalid operation on gdb.Value."));
1426       result = -1;
1427       break;
1428     }
1429
1430   return result;
1431 }
1432
1433
1434 /* Implements comparison operations for value objects.  Returns NULL on error,
1435    with a python exception set.  */
1436 static PyObject *
1437 valpy_richcompare (PyObject *self, PyObject *other, int op)
1438 {
1439   int result = 0;
1440
1441   if (other == Py_None)
1442     /* Comparing with None is special.  From what I can tell, in Python
1443        None is smaller than anything else.  */
1444     switch (op) {
1445       case Py_LT:
1446       case Py_LE:
1447       case Py_EQ:
1448         Py_RETURN_FALSE;
1449       case Py_NE:
1450       case Py_GT:
1451       case Py_GE:
1452         Py_RETURN_TRUE;
1453       default:
1454         /* Can't happen.  */
1455         PyErr_SetString (PyExc_NotImplementedError,
1456                          _("Invalid operation on gdb.Value."));
1457         return NULL;
1458     }
1459
1460   TRY
1461     {
1462       result = valpy_richcompare_throw (self, other, op);
1463     }
1464   CATCH (except, RETURN_MASK_ALL)
1465     {
1466       GDB_PY_HANDLE_EXCEPTION (except);
1467     }
1468   END_CATCH
1469
1470   /* In this case, the Python exception has already been set.  */
1471   if (result < 0)
1472     return NULL;
1473
1474   if (result == 1)
1475     Py_RETURN_TRUE;
1476
1477   Py_RETURN_FALSE;
1478 }
1479
1480 #ifndef IS_PY3K
1481 /* Implements conversion to int.  */
1482 static PyObject *
1483 valpy_int (PyObject *self)
1484 {
1485   struct value *value = ((value_object *) self)->value;
1486   struct type *type = value_type (value);
1487   LONGEST l = 0;
1488
1489   TRY
1490     {
1491       if (is_floating_value (value))
1492         {
1493           type = builtin_type_pylong;
1494           value = value_cast (type, value);
1495         }
1496
1497       if (!is_integral_type (type)
1498           && TYPE_CODE (type) != TYPE_CODE_PTR)
1499         error (_("Cannot convert value to int."));
1500
1501       l = value_as_long (value);
1502     }
1503   CATCH (except, RETURN_MASK_ALL)
1504     {
1505       GDB_PY_HANDLE_EXCEPTION (except);
1506     }
1507   END_CATCH
1508
1509   if (TYPE_UNSIGNED (type))
1510     return gdb_py_object_from_ulongest (l).release ();
1511   else
1512     return gdb_py_object_from_longest (l).release ();
1513 }
1514 #endif
1515
1516 /* Implements conversion to long.  */
1517 static PyObject *
1518 valpy_long (PyObject *self)
1519 {
1520   struct value *value = ((value_object *) self)->value;
1521   struct type *type = value_type (value);
1522   LONGEST l = 0;
1523
1524   TRY
1525     {
1526       if (is_floating_value (value))
1527         {
1528           type = builtin_type_pylong;
1529           value = value_cast (type, value);
1530         }
1531
1532       type = check_typedef (type);
1533
1534       if (!is_integral_type (type)
1535           && TYPE_CODE (type) != TYPE_CODE_PTR)
1536         error (_("Cannot convert value to long."));
1537
1538       l = value_as_long (value);
1539     }
1540   CATCH (except, RETURN_MASK_ALL)
1541     {
1542       GDB_PY_HANDLE_EXCEPTION (except);
1543     }
1544   END_CATCH
1545
1546   if (TYPE_UNSIGNED (type))
1547     return gdb_py_long_from_ulongest (l);
1548   else
1549     return gdb_py_long_from_longest (l);
1550 }
1551
1552 /* Implements conversion to float.  */
1553 static PyObject *
1554 valpy_float (PyObject *self)
1555 {
1556   struct value *value = ((value_object *) self)->value;
1557   struct type *type = value_type (value);
1558   double d = 0;
1559
1560   TRY
1561     {
1562       type = check_typedef (type);
1563
1564       if (TYPE_CODE (type) == TYPE_CODE_FLT && is_floating_value (value))
1565         d = target_float_to_host_double (value_contents (value), type);
1566       else if (TYPE_CODE (type) == TYPE_CODE_INT)
1567         {
1568           /* Note that valpy_long accepts TYPE_CODE_PTR and some
1569              others here here -- but casting a pointer or bool to a
1570              float seems wrong.  */
1571           d = value_as_long (value);
1572         }
1573       else
1574         error (_("Cannot convert value to float."));
1575     }
1576   CATCH (except, RETURN_MASK_ALL)
1577     {
1578       GDB_PY_HANDLE_EXCEPTION (except);
1579     }
1580   END_CATCH
1581
1582   return PyFloat_FromDouble (d);
1583 }
1584
1585 /* Returns an object for a value which is released from the all_values chain,
1586    so its lifetime is not bound to the execution of a command.  */
1587 PyObject *
1588 value_to_value_object (struct value *val)
1589 {
1590   value_object *val_obj;
1591
1592   val_obj = PyObject_New (value_object, &value_object_type);
1593   if (val_obj != NULL)
1594     {
1595       val_obj->value = release_value (val).release ();
1596       val_obj->address = NULL;
1597       val_obj->type = NULL;
1598       val_obj->dynamic_type = NULL;
1599       note_value (val_obj);
1600     }
1601
1602   return (PyObject *) val_obj;
1603 }
1604
1605 /* Returns a borrowed reference to the struct value corresponding to
1606    the given value object.  */
1607 struct value *
1608 value_object_to_value (PyObject *self)
1609 {
1610   value_object *real;
1611
1612   if (! PyObject_TypeCheck (self, &value_object_type))
1613     return NULL;
1614   real = (value_object *) self;
1615   return real->value;
1616 }
1617
1618 /* Try to convert a Python value to a gdb value.  If the value cannot
1619    be converted, set a Python exception and return NULL.  Returns a
1620    reference to a new value on the all_values chain.  */
1621
1622 struct value *
1623 convert_value_from_python (PyObject *obj)
1624 {
1625   struct value *value = NULL; /* -Wall */
1626   int cmp;
1627
1628   gdb_assert (obj != NULL);
1629
1630   TRY
1631     {
1632       if (PyBool_Check (obj))
1633         {
1634           cmp = PyObject_IsTrue (obj);
1635           if (cmp >= 0)
1636             value = value_from_longest (builtin_type_pybool, cmp);
1637         }
1638       /* Make a long logic check first.  In Python 3.x, internally,
1639          all integers are represented as longs.  In Python 2.x, there
1640          is still a differentiation internally between a PyInt and a
1641          PyLong.  Explicitly do this long check conversion first. In
1642          GDB, for Python 3.x, we #ifdef PyInt = PyLong.  This check has
1643          to be done first to ensure we do not lose information in the
1644          conversion process.  */
1645       else if (PyLong_Check (obj))
1646         {
1647           LONGEST l = PyLong_AsLongLong (obj);
1648
1649           if (PyErr_Occurred ())
1650             {
1651               /* If the error was an overflow, we can try converting to
1652                  ULONGEST instead.  */
1653               if (PyErr_ExceptionMatches (PyExc_OverflowError))
1654                 {
1655                   gdbpy_err_fetch fetched_error;
1656                   gdbpy_ref<> zero (PyInt_FromLong (0));
1657
1658                   /* Check whether obj is positive.  */
1659                   if (PyObject_RichCompareBool (obj, zero.get (), Py_GT) > 0)
1660                     {
1661                       ULONGEST ul;
1662
1663                       ul = PyLong_AsUnsignedLongLong (obj);
1664                       if (! PyErr_Occurred ())
1665                         value = value_from_ulongest (builtin_type_upylong, ul);
1666                     }
1667                   else
1668                     {
1669                       /* There's nothing we can do.  */
1670                       fetched_error.restore ();
1671                     }
1672                 }
1673             }
1674           else
1675             value = value_from_longest (builtin_type_pylong, l);
1676         }
1677 #if PY_MAJOR_VERSION == 2
1678       else if (PyInt_Check (obj))
1679         {
1680           long l = PyInt_AsLong (obj);
1681
1682           if (! PyErr_Occurred ())
1683             value = value_from_longest (builtin_type_pyint, l);
1684         }
1685 #endif
1686       else if (PyFloat_Check (obj))
1687         {
1688           double d = PyFloat_AsDouble (obj);
1689
1690           if (! PyErr_Occurred ())
1691             {
1692               value = allocate_value (builtin_type_pyfloat);
1693               target_float_from_host_double (value_contents_raw (value),
1694                                              value_type (value), d);
1695             }
1696         }
1697       else if (gdbpy_is_string (obj))
1698         {
1699           gdb::unique_xmalloc_ptr<char> s
1700             = python_string_to_target_string (obj);
1701           if (s != NULL)
1702             value = value_cstring (s.get (), strlen (s.get ()),
1703                                    builtin_type_pychar);
1704         }
1705       else if (PyObject_TypeCheck (obj, &value_object_type))
1706         value = value_copy (((value_object *) obj)->value);
1707       else if (gdbpy_is_lazy_string (obj))
1708         {
1709           PyObject *result;
1710
1711           result = PyObject_CallMethodObjArgs (obj, gdbpy_value_cst,  NULL);
1712           value = value_copy (((value_object *) result)->value);
1713         }
1714       else
1715 #ifdef IS_PY3K
1716         PyErr_Format (PyExc_TypeError,
1717                       _("Could not convert Python object: %S."), obj);
1718 #else
1719         PyErr_Format (PyExc_TypeError,
1720                       _("Could not convert Python object: %s."),
1721                       PyString_AsString (PyObject_Str (obj)));
1722 #endif
1723     }
1724   CATCH (except, RETURN_MASK_ALL)
1725     {
1726       gdbpy_convert_exception (except);
1727       return NULL;
1728     }
1729   END_CATCH
1730
1731   return value;
1732 }
1733
1734 /* Returns value object in the ARGth position in GDB's history.  */
1735 PyObject *
1736 gdbpy_history (PyObject *self, PyObject *args)
1737 {
1738   int i;
1739   struct value *res_val = NULL;   /* Initialize to appease gcc warning.  */
1740
1741   if (!PyArg_ParseTuple (args, "i", &i))
1742     return NULL;
1743
1744   TRY
1745     {
1746       res_val = access_value_history (i);
1747     }
1748   CATCH (except, RETURN_MASK_ALL)
1749     {
1750       GDB_PY_HANDLE_EXCEPTION (except);
1751     }
1752   END_CATCH
1753
1754   return value_to_value_object (res_val);
1755 }
1756
1757 /* Return the value of a convenience variable.  */
1758 PyObject *
1759 gdbpy_convenience_variable (PyObject *self, PyObject *args)
1760 {
1761   const char *varname;
1762   struct value *res_val = NULL;
1763
1764   if (!PyArg_ParseTuple (args, "s", &varname))
1765     return NULL;
1766
1767   TRY
1768     {
1769       struct internalvar *var = lookup_only_internalvar (varname);
1770
1771       if (var != NULL)
1772         {
1773           res_val = value_of_internalvar (python_gdbarch, var);
1774           if (TYPE_CODE (value_type (res_val)) == TYPE_CODE_VOID)
1775             res_val = NULL;
1776         }
1777     }
1778   CATCH (except, RETURN_MASK_ALL)
1779     {
1780       GDB_PY_HANDLE_EXCEPTION (except);
1781     }
1782   END_CATCH
1783
1784   if (res_val == NULL)
1785     Py_RETURN_NONE;
1786
1787   return value_to_value_object (res_val);
1788 }
1789
1790 /* Set the value of a convenience variable.  */
1791 PyObject *
1792 gdbpy_set_convenience_variable (PyObject *self, PyObject *args)
1793 {
1794   const char *varname;
1795   PyObject *value_obj;
1796   struct value *value = NULL;
1797
1798   if (!PyArg_ParseTuple (args, "sO", &varname, &value_obj))
1799     return NULL;
1800
1801   /* None means to clear the variable.  */
1802   if (value_obj != Py_None)
1803     {
1804       value = convert_value_from_python (value_obj);
1805       if (value == NULL)
1806         return NULL;
1807     }
1808
1809   TRY
1810     {
1811       if (value == NULL)
1812         {
1813           struct internalvar *var = lookup_only_internalvar (varname);
1814
1815           if (var != NULL)
1816             clear_internalvar (var);
1817         }
1818       else
1819         {
1820           struct internalvar *var = lookup_internalvar (varname);
1821
1822           set_internalvar (var, value);
1823         }
1824     }
1825   CATCH (except, RETURN_MASK_ALL)
1826     {
1827       GDB_PY_HANDLE_EXCEPTION (except);
1828     }
1829   END_CATCH
1830
1831   Py_RETURN_NONE;
1832 }
1833
1834 /* Returns 1 in OBJ is a gdb.Value object, 0 otherwise.  */
1835
1836 int
1837 gdbpy_is_value_object (PyObject *obj)
1838 {
1839   return PyObject_TypeCheck (obj, &value_object_type);
1840 }
1841
1842 int
1843 gdbpy_initialize_values (void)
1844 {
1845   if (PyType_Ready (&value_object_type) < 0)
1846     return -1;
1847
1848   return gdb_pymodule_addobject (gdb_module, "Value",
1849                                  (PyObject *) &value_object_type);
1850 }
1851
1852 \f
1853
1854 static gdb_PyGetSetDef value_object_getset[] = {
1855   { "address", valpy_get_address, NULL, "The address of the value.",
1856     NULL },
1857   { "is_optimized_out", valpy_get_is_optimized_out, NULL,
1858     "Boolean telling whether the value is optimized "
1859     "out (i.e., not available).",
1860     NULL },
1861   { "type", valpy_get_type, NULL, "Type of the value.", NULL },
1862   { "dynamic_type", valpy_get_dynamic_type, NULL,
1863     "Dynamic type of the value.", NULL },
1864   { "is_lazy", valpy_get_is_lazy, NULL,
1865     "Boolean telling whether the value is lazy (not fetched yet\n\
1866 from the inferior).  A lazy value is fetched when needed, or when\n\
1867 the \"fetch_lazy()\" method is called.", NULL },
1868   {NULL}  /* Sentinel */
1869 };
1870
1871 static PyMethodDef value_object_methods[] = {
1872   { "cast", valpy_cast, METH_VARARGS, "Cast the value to the supplied type." },
1873   { "dynamic_cast", valpy_dynamic_cast, METH_VARARGS,
1874     "dynamic_cast (gdb.Type) -> gdb.Value\n\
1875 Cast the value to the supplied type, as if by the C++ dynamic_cast operator."
1876   },
1877   { "reinterpret_cast", valpy_reinterpret_cast, METH_VARARGS,
1878     "reinterpret_cast (gdb.Type) -> gdb.Value\n\
1879 Cast the value to the supplied type, as if by the C++\n\
1880 reinterpret_cast operator."
1881   },
1882   { "dereference", valpy_dereference, METH_NOARGS, "Dereferences the value." },
1883   { "referenced_value", valpy_referenced_value, METH_NOARGS,
1884     "Return the value referenced by a TYPE_CODE_REF or TYPE_CODE_PTR value." },
1885   { "reference_value", valpy_lvalue_reference_value, METH_NOARGS,
1886     "Return a value of type TYPE_CODE_REF referencing this value." },
1887   { "rvalue_reference_value", valpy_rvalue_reference_value, METH_NOARGS,
1888     "Return a value of type TYPE_CODE_RVALUE_REF referencing this value." },
1889   { "const_value", valpy_const_value, METH_NOARGS,
1890     "Return a 'const' qualied version of the same value." },
1891   { "lazy_string", (PyCFunction) valpy_lazy_string,
1892     METH_VARARGS | METH_KEYWORDS,
1893     "lazy_string ([encoding]  [, length]) -> lazy_string\n\
1894 Return a lazy string representation of the value." },
1895   { "string", (PyCFunction) valpy_string, METH_VARARGS | METH_KEYWORDS,
1896     "string ([encoding] [, errors] [, length]) -> string\n\
1897 Return Unicode string representation of the value." },
1898   { "fetch_lazy", valpy_fetch_lazy, METH_NOARGS,
1899     "Fetches the value from the inferior, if it was lazy." },
1900   {NULL}  /* Sentinel */
1901 };
1902
1903 static PyNumberMethods value_object_as_number = {
1904   valpy_add,
1905   valpy_subtract,
1906   valpy_multiply,
1907 #ifndef IS_PY3K
1908   valpy_divide,
1909 #endif
1910   valpy_remainder,
1911   NULL,                       /* nb_divmod */
1912   valpy_power,                /* nb_power */
1913   valpy_negative,             /* nb_negative */
1914   valpy_positive,             /* nb_positive */
1915   valpy_absolute,             /* nb_absolute */
1916   valpy_nonzero,              /* nb_nonzero */
1917   valpy_invert,               /* nb_invert */
1918   valpy_lsh,                  /* nb_lshift */
1919   valpy_rsh,                  /* nb_rshift */
1920   valpy_and,                  /* nb_and */
1921   valpy_xor,                  /* nb_xor */
1922   valpy_or,                   /* nb_or */
1923 #ifdef IS_PY3K
1924   valpy_long,                 /* nb_int */
1925   NULL,                       /* reserved */
1926 #else
1927   NULL,                       /* nb_coerce */
1928   valpy_int,                  /* nb_int */
1929   valpy_long,                 /* nb_long */
1930 #endif
1931   valpy_float,                /* nb_float */
1932 #ifndef IS_PY3K
1933   NULL,                       /* nb_oct */
1934   NULL,                       /* nb_hex */
1935 #endif
1936   NULL,                       /* nb_inplace_add */
1937   NULL,                       /* nb_inplace_subtract */
1938   NULL,                       /* nb_inplace_multiply */
1939 #ifndef IS_PY3K
1940   NULL,                       /* nb_inplace_divide */
1941 #endif
1942   NULL,                       /* nb_inplace_remainder */
1943   NULL,                       /* nb_inplace_power */
1944   NULL,                       /* nb_inplace_lshift */
1945   NULL,                       /* nb_inplace_rshift */
1946   NULL,                       /* nb_inplace_and */
1947   NULL,                       /* nb_inplace_xor */
1948   NULL,                       /* nb_inplace_or */
1949   NULL,                       /* nb_floor_divide */
1950   valpy_divide,               /* nb_true_divide */
1951   NULL,                       /* nb_inplace_floor_divide */
1952   NULL,                       /* nb_inplace_true_divide */
1953 #ifndef HAVE_LIBPYTHON2_4
1954   /* This was added in Python 2.5.  */
1955   valpy_long,                 /* nb_index */
1956 #endif /* HAVE_LIBPYTHON2_4 */
1957 };
1958
1959 static PyMappingMethods value_object_as_mapping = {
1960   valpy_length,
1961   valpy_getitem,
1962   valpy_setitem
1963 };
1964
1965 PyTypeObject value_object_type = {
1966   PyVarObject_HEAD_INIT (NULL, 0)
1967   "gdb.Value",                    /*tp_name*/
1968   sizeof (value_object),          /*tp_basicsize*/
1969   0,                              /*tp_itemsize*/
1970   valpy_dealloc,                  /*tp_dealloc*/
1971   0,                              /*tp_print*/
1972   0,                              /*tp_getattr*/
1973   0,                              /*tp_setattr*/
1974   0,                              /*tp_compare*/
1975   0,                              /*tp_repr*/
1976   &value_object_as_number,        /*tp_as_number*/
1977   0,                              /*tp_as_sequence*/
1978   &value_object_as_mapping,       /*tp_as_mapping*/
1979   valpy_hash,                     /*tp_hash*/
1980   valpy_call,                     /*tp_call*/
1981   valpy_str,                      /*tp_str*/
1982   0,                              /*tp_getattro*/
1983   0,                              /*tp_setattro*/
1984   0,                              /*tp_as_buffer*/
1985   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_CHECKTYPES
1986   | Py_TPFLAGS_BASETYPE,          /*tp_flags*/
1987   "GDB value object",             /* tp_doc */
1988   0,                              /* tp_traverse */
1989   0,                              /* tp_clear */
1990   valpy_richcompare,              /* tp_richcompare */
1991   0,                              /* tp_weaklistoffset */
1992   0,                              /* tp_iter */
1993   0,                              /* tp_iternext */
1994   value_object_methods,           /* tp_methods */
1995   0,                              /* tp_members */
1996   value_object_getset,            /* tp_getset */
1997   0,                              /* tp_base */
1998   0,                              /* tp_dict */
1999   0,                              /* tp_descr_get */
2000   0,                              /* tp_descr_set */
2001   0,                              /* tp_dictoffset */
2002   0,                              /* tp_init */
2003   0,                              /* tp_alloc */
2004   valpy_new                       /* tp_new */
2005 };