gdb/python/py-value.c

   1 /* Python interface to values.
   2
   3    Copyright (C) 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "gdb_assert.h"
  22 #include "charset.h"
  23 #include "value.h"
  24 #include "exceptions.h"
  25 #include "language.h"
  26 #include "dfp.h"
  27 #include "valprint.h"
  28 #include "infcall.h"
  29 #include "expression.h"
  30 #include "cp-abi.h"
  31
  32 #ifdef HAVE_PYTHON
  33
  34 #include "python-internal.h"
  35
  36 /* Even though Python scalar types directly map to host types, we use
  37    target types here to remain consistent with the values system in
  38    GDB (which uses target arithmetic).  */
  39
  40 /* Python's integer type corresponds to C's long type.  */
  41 #define builtin_type_pyint builtin_type (python_gdbarch)->builtin_long
  42
  43 /* Python's float type corresponds to C's double type.  */
  44 #define builtin_type_pyfloat builtin_type (python_gdbarch)->builtin_double
  45
  46 /* Python's long type corresponds to C's long long type.  */
  47 #define builtin_type_pylong builtin_type (python_gdbarch)->builtin_long_long
  48
  49 /* Python's long type corresponds to C's long long type.  Unsigned version.  */
  50 #define builtin_type_upylong builtin_type \
  51   (python_gdbarch)->builtin_unsigned_long_long
  52
  53 #define builtin_type_pybool \
  54   language_bool_type (python_language, python_gdbarch)
  55
  56 #define builtin_type_pychar \
  57   language_string_char_type (python_language, python_gdbarch)
  58
  59 typedef struct value_object {
  60   PyObject_HEAD
  61   struct value_object *next;
  62   struct value_object *prev;
  63   struct value *value;
  64   PyObject *address;
  65   PyObject *type;
  66   PyObject *dynamic_type;
  67 } value_object;
  68
  69 /* List of all values which are currently exposed to Python. It is
  70    maintained so that when an objfile is discarded, preserve_values
  71    can copy the values' types if needed.  */
  72 /* This variable is unnecessarily initialized to NULL in order to
  73    work around a linker bug on MacOS.  */
  74 static value_object *values_in_python = NULL;
  75
  76 /* Called by the Python interpreter when deallocating a value object.  */
  77 static void
  78 valpy_dealloc (PyObject *obj)
  79 {
  80   value_object *self = (value_object *) obj;
  81
  82   /* Remove SELF from the global list.  */
  83   if (self->prev)
  84     self->prev->next = self->next;
  85   else
  86     {
  87       gdb_assert (values_in_python == self);
  88       values_in_python = self->next;
  89     }
  90   if (self->next)
  91     self->next->prev = self->prev;
  92
  93   value_free (self->value);
  94
  95   if (self->address)
  96     /* Use braces to appease gcc warning.  *sigh*  */
  97     {
  98       Py_DECREF (self->address);
  99     }
 100
 101   if (self->type)
 102     {
 103       Py_DECREF (self->type);
 104     }
 105
 106   Py_XDECREF (self->dynamic_type);
 107
 108   self->ob_type->tp_free (self);
 109 }
 110
 111 /* Helper to push a Value object on the global list.  */
 112 static void
 113 note_value (value_object *value_obj)
 114 {
 115   value_obj->next = values_in_python;
 116   if (value_obj->next)
 117     value_obj->next->prev = value_obj;
 118   value_obj->prev = NULL;
 119   values_in_python = value_obj;
 120 }
 121
 122 /* Called when a new gdb.Value object needs to be allocated.  Returns NULL on
 123    error, with a python exception set.  */
 124 static PyObject *
 125 valpy_new (PyTypeObject *subtype, PyObject *args, PyObject *keywords)
 126 {
 127   struct value *value = NULL;   /* Initialize to appease gcc warning.  */
 128   value_object *value_obj;
 129
 130   if (PyTuple_Size (args) != 1)
 131     {
 132       PyErr_SetString (PyExc_TypeError, _("Value object creation takes only "
 133                                           "1 argument"));
 134       return NULL;
 135     }
 136
 137   value_obj = (value_object *) subtype->tp_alloc (subtype, 1);
 138   if (value_obj == NULL)
 139     {
 140       PyErr_SetString (PyExc_MemoryError, _("Could not allocate memory to "
 141                                             "create Value object."));
 142       return NULL;
 143     }
 144
 145   value = convert_value_from_python (PyTuple_GetItem (args, 0));
 146   if (value == NULL)
 147     {
 148       subtype->tp_free (value_obj);
 149       return NULL;
 150     }
 151
 152   value_obj->value = value;
 153   value_incref (value);
 154   value_obj->address = NULL;
 155   value_obj->type = NULL;
 156   value_obj->dynamic_type = NULL;
 157   note_value (value_obj);
 158
 159   return (PyObject *) value_obj;
 160 }
 161
 162 /* Iterate over all the Value objects, calling preserve_one_value on
 163    each.  */
 164 void
 165 preserve_python_values (struct objfile *objfile, htab_t copied_types)
 166 {
 167   value_object *iter;
 168
 169   for (iter = values_in_python; iter; iter = iter->next)
 170     preserve_one_value (iter->value, objfile, copied_types);
 171 }
 172
 173 /* Given a value of a pointer type, apply the C unary * operator to it.  */
 174 static PyObject *
 175 valpy_dereference (PyObject *self, PyObject *args)
 176 {
 177   struct value *res_val = NULL;   /* Initialize to appease gcc warning.  */
 178   volatile struct gdb_exception except;
 179
 180   TRY_CATCH (except, RETURN_MASK_ALL)
 181     {
 182       res_val = value_ind (((value_object *) self)->value);
 183     }
 184   GDB_PY_HANDLE_EXCEPTION (except);
 185
 186   return value_to_value_object (res_val);
 187 }
 188
 189 /* Return "&value".  */
 190 static PyObject *
 191 valpy_get_address (PyObject *self, void *closure)
 192 {
 193   struct value *res_val = NULL;   /* Initialize to appease gcc warning.  */
 194   value_object *val_obj = (value_object *) self;
 195   volatile struct gdb_exception except;
 196
 197   if (!val_obj->address)
 198     {
 199       TRY_CATCH (except, RETURN_MASK_ALL)
 200         {
 201           res_val = value_addr (val_obj->value);
 202         }
 203       if (except.reason < 0)
 204         {
 205           val_obj->address = Py_None;
 206           Py_INCREF (Py_None);
 207         }
 208       else
 209         val_obj->address = value_to_value_object (res_val);
 210     }
 211
 212   Py_XINCREF (val_obj->address);
 213
 214   return val_obj->address;
 215 }
 216
 217 /* Return type of the value.  */
 218 static PyObject *
 219 valpy_get_type (PyObject *self, void *closure)
 220 {
 221   value_object *obj = (value_object *) self;
 222
 223   if (!obj->type)
 224     {
 225       obj->type = type_to_type_object (value_type (obj->value));
 226       if (!obj->type)
 227         return NULL;
 228     }
 229   Py_INCREF (obj->type);
 230   return obj->type;
 231 }
 232
 233 /* Return dynamic type of the value.  */
 234
 235 static PyObject *
 236 valpy_get_dynamic_type (PyObject *self, void *closure)
 237 {
 238   value_object *obj = (value_object *) self;
 239   volatile struct gdb_exception except;
 240   struct type *type = NULL;
 241
 242   if (obj->dynamic_type != NULL)
 243     {
 244       Py_INCREF (obj->dynamic_type);
 245       return obj->dynamic_type;
 246     }
 247
 248   TRY_CATCH (except, RETURN_MASK_ALL)
 249     {
 250       struct value *val = obj->value;
 251
 252       type = value_type (val);
 253       CHECK_TYPEDEF (type);
 254
 255       if (((TYPE_CODE (type) == TYPE_CODE_PTR)
 256            || (TYPE_CODE (type) == TYPE_CODE_REF))
 257           && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
 258         {
 259           struct value *target;
 260           int was_pointer = TYPE_CODE (type) == TYPE_CODE_PTR;
 261
 262           target = value_ind (val);
 263           type = value_rtti_type (target, NULL, NULL, NULL);
 264
 265           if (type)
 266             {
 267               if (was_pointer)
 268                 type = lookup_pointer_type (type);
 269               else
 270                 type = lookup_reference_type (type);
 271             }
 272         }
 273       else if (TYPE_CODE (type) == TYPE_CODE_CLASS)
 274         type = value_rtti_type (val, NULL, NULL, NULL);
 275       else
 276         {
 277           /* Re-use object's static type.  */
 278           type = NULL;
 279         }
 280     }
 281   GDB_PY_HANDLE_EXCEPTION (except);
 282
 283   if (type == NULL)
 284     {
 285       /* Ensure that the TYPE field is ready.  */
 286       if (!valpy_get_type (self, NULL))
 287         return NULL;
 288       /* We don't need to incref here, because valpy_get_type already
 289          did it for us.  */
 290       obj->dynamic_type = obj->type;
 291     }
 292   else
 293     obj->dynamic_type = type_to_type_object (type);
 294
 295   Py_INCREF (obj->dynamic_type);
 296   return obj->dynamic_type;
 297 }
 298
 299 /* Implementation of gdb.Value.lazy_string ([encoding] [, length]) ->
 300    string.  Return a PyObject representing a lazy_string_object type.
 301    A lazy string is a pointer to a string with an optional encoding and
 302    length.  If ENCODING is not given, encoding is set to None.  If an
 303    ENCODING is provided the encoding parameter is set to ENCODING, but
 304    the string is not encoded.  If LENGTH is provided then the length
 305    parameter is set to LENGTH, otherwise length will be set to -1 (first
 306    null of appropriate with).  */
 307 static PyObject *
 308 valpy_lazy_string (PyObject *self, PyObject *args, PyObject *kw)
 309 {
 310   gdb_py_longest length = -1;
 311   struct value *value = ((value_object *) self)->value;
 312   const char *user_encoding = NULL;
 313   static char *keywords[] = { "encoding", "length", NULL };
 314   PyObject *str_obj;
 315   volatile struct gdb_exception except;
 316
 317   if (!PyArg_ParseTupleAndKeywords (args, kw, "|s" GDB_PY_LL_ARG, keywords,
 318                                     &user_encoding, &length))
 319     return NULL;
 320
 321   TRY_CATCH (except, RETURN_MASK_ALL)
 322     {
 323       if (TYPE_CODE (value_type (value)) == TYPE_CODE_PTR)
 324         value = value_ind (value);
 325     }
 326   GDB_PY_HANDLE_EXCEPTION (except);
 327
 328   str_obj = gdbpy_create_lazy_string_object (value_address (value), length,
 329                                              user_encoding,
 330                                              value_type (value));
 331
 332   return (PyObject *) str_obj;
 333 }
 334
 335 /* Implementation of gdb.Value.string ([encoding] [, errors]
 336    [, length]) -> string.  Return Unicode string with value contents.
 337    If ENCODING is not given, the string is assumed to be encoded in
 338    the target's charset.  If LENGTH is provided, only fetch string to
 339    the length provided.  */
 340
 341 static PyObject *
 342 valpy_string (PyObject *self, PyObject *args, PyObject *kw)
 343 {
 344   int length = -1;
 345   gdb_byte *buffer;
 346   struct value *value = ((value_object *) self)->value;
 347   volatile struct gdb_exception except;
 348   PyObject *unicode;
 349   const char *encoding = NULL;
 350   const char *errors = NULL;
 351   const char *user_encoding = NULL;
 352   const char *la_encoding = NULL;
 353   struct type *char_type;
 354   static char *keywords[] = { "encoding", "errors", "length", NULL };
 355
 356   if (!PyArg_ParseTupleAndKeywords (args, kw, "|ssi", keywords,
 357                                     &user_encoding, &errors, &length))
 358     return NULL;
 359
 360   TRY_CATCH (except, RETURN_MASK_ALL)
 361     {
 362       LA_GET_STRING (value, &buffer, &length, &char_type, &la_encoding);
 363     }
 364   GDB_PY_HANDLE_EXCEPTION (except);
 365
 366   encoding = (user_encoding && *user_encoding) ? user_encoding : la_encoding;
 367   unicode = PyUnicode_Decode (buffer, length * TYPE_LENGTH (char_type),
 368                               encoding, errors);
 369   xfree (buffer);
 370
 371   return unicode;
 372 }
 373
 374 /* A helper function that implements the various cast operators.  */
 375
 376 static PyObject *
 377 valpy_do_cast (PyObject *self, PyObject *args, enum exp_opcode op)
 378 {
 379   PyObject *type_obj;
 380   struct type *type;
 381   struct value *res_val = NULL;   /* Initialize to appease gcc warning.  */
 382   volatile struct gdb_exception except;
 383
 384   if (! PyArg_ParseTuple (args, "O", &type_obj))
 385     return NULL;
 386
 387   type = type_object_to_type (type_obj);
 388   if (! type)
 389     {
 390       PyErr_SetString (PyExc_RuntimeError,
 391                        _("Argument must be a type."));
 392       return NULL;
 393     }
 394
 395   TRY_CATCH (except, RETURN_MASK_ALL)
 396     {
 397       struct value *val = ((value_object *) self)->value;
 398
 399       if (op == UNOP_DYNAMIC_CAST)
 400         res_val = value_dynamic_cast (type, val);
 401       else if (op == UNOP_REINTERPRET_CAST)
 402         res_val = value_reinterpret_cast (type, val);
 403       else
 404         {
 405           gdb_assert (op == UNOP_CAST);
 406           res_val = value_cast (type, val);
 407         }
 408     }
 409   GDB_PY_HANDLE_EXCEPTION (except);
 410
 411   return value_to_value_object (res_val);
 412 }
 413
 414 /* Implementation of the "cast" method.  */
 415
 416 static PyObject *
 417 valpy_cast (PyObject *self, PyObject *args)
 418 {
 419   return valpy_do_cast (self, args, UNOP_CAST);
 420 }
 421
 422 /* Implementation of the "dynamic_cast" method.  */
 423
 424 static PyObject *
 425 valpy_dynamic_cast (PyObject *self, PyObject *args)
 426 {
 427   return valpy_do_cast (self, args, UNOP_DYNAMIC_CAST);
 428 }
 429
 430 /* Implementation of the "reinterpret_cast" method.  */
 431
 432 static PyObject *
 433 valpy_reinterpret_cast (PyObject *self, PyObject *args)
 434 {
 435   return valpy_do_cast (self, args, UNOP_REINTERPRET_CAST);
 436 }
 437
 438 static Py_ssize_t
 439 valpy_length (PyObject *self)
 440 {
 441   /* We don't support getting the number of elements in a struct / class.  */
 442   PyErr_SetString (PyExc_NotImplementedError,
 443                    _("Invalid operation on gdb.Value."));
 444   return -1;
 445 }
 446
 447 /* Given string name of an element inside structure, return its value
 448    object.  Returns NULL on error, with a python exception set.  */
 449 static PyObject *
 450 valpy_getitem (PyObject *self, PyObject *key)
 451 {
 452   value_object *self_value = (value_object *) self;
 453   char *field = NULL;
 454   struct value *res_val = NULL;
 455   volatile struct gdb_exception except;
 456
 457   if (gdbpy_is_string (key))
 458     {
 459       field = python_string_to_host_string (key);
 460       if (field == NULL)
 461         return NULL;
 462     }
 463
 464   TRY_CATCH (except, RETURN_MASK_ALL)
 465     {
 466       struct value *tmp = self_value->value;
 467
 468       if (field)
 469         res_val = value_struct_elt (&tmp, NULL, field, 0, NULL);
 470       else
 471         {
 472           /* Assume we are attempting an array access, and let the
 473              value code throw an exception if the index has an invalid
 474              type.  */
 475           struct value *idx = convert_value_from_python (key);
 476
 477           if (idx != NULL)
 478             {
 479               /* Check the value's type is something that can be accessed via
 480                  a subscript.  */
 481               struct type *type;
 482
 483               tmp = coerce_ref (tmp);
 484               type = check_typedef (value_type (tmp));
 485               if (TYPE_CODE (type) != TYPE_CODE_ARRAY
 486                   && TYPE_CODE (type) != TYPE_CODE_PTR)
 487                   error (_("Cannot subscript requested type."));
 488               else
 489                 res_val = value_subscript (tmp, value_as_long (idx));
 490             }
 491         }
 492     }
 493
 494   xfree (field);
 495   GDB_PY_HANDLE_EXCEPTION (except);
 496
 497   return res_val ? value_to_value_object (res_val) : NULL;
 498 }
 499
 500 static int
 501 valpy_setitem (PyObject *self, PyObject *key, PyObject *value)
 502 {
 503   PyErr_Format (PyExc_NotImplementedError,
 504                 _("Setting of struct elements is not currently supported."));
 505   return -1;
 506 }
 507
 508 /* Called by the Python interpreter to perform an inferior function
 509    call on the value.  Returns NULL on error, with a python exception set.  */
 510 static PyObject *
 511 valpy_call (PyObject *self, PyObject *args, PyObject *keywords)
 512 {
 513   struct value *return_value = NULL;
 514   Py_ssize_t args_count;
 515   volatile struct gdb_exception except;
 516   struct value *function = ((value_object *) self)->value;
 517   struct value **vargs = NULL;
 518   struct type *ftype = NULL;
 519
 520   TRY_CATCH (except, RETURN_MASK_ALL)
 521     {
 522       ftype = check_typedef (value_type (function));
 523     }
 524   GDB_PY_HANDLE_EXCEPTION (except);
 525
 526   if (TYPE_CODE (ftype) != TYPE_CODE_FUNC)
 527     {
 528       PyErr_SetString (PyExc_RuntimeError,
 529                        _("Value is not callable (not TYPE_CODE_FUNC)."));
 530       return NULL;
 531     }
 532
 533   if (! PyTuple_Check (args))
 534     {
 535       PyErr_SetString (PyExc_TypeError,
 536                        _("Inferior arguments must be provided in a tuple."));
 537       return NULL;
 538     }
 539
 540   args_count = PyTuple_Size (args);
 541   if (args_count > 0)
 542     {
 543       int i;
 544
 545       vargs = alloca (sizeof (struct value *) * args_count);
 546       for (i = 0; i < args_count; i++)
 547         {
 548           PyObject *item = PyTuple_GetItem (args, i);
 549
 550           if (item == NULL)
 551             return NULL;
 552
 553           vargs[i] = convert_value_from_python (item);
 554           if (vargs[i] == NULL)
 555             return NULL;
 556         }
 557     }
 558
 559   TRY_CATCH (except, RETURN_MASK_ALL)
 560     {
 561       return_value = call_function_by_hand (function, args_count, vargs);
 562     }
 563   GDB_PY_HANDLE_EXCEPTION (except);
 564
 565   return value_to_value_object (return_value);
 566 }
 567
 568 /* Called by the Python interpreter to obtain string representation
 569    of the object.  */
 570 static PyObject *
 571 valpy_str (PyObject *self)
 572 {
 573   char *s = NULL;
 574   PyObject *result;
 575   struct value_print_options opts;
 576   volatile struct gdb_exception except;
 577
 578   get_user_print_options (&opts);
 579   opts.deref_ref = 0;
 580
 581   TRY_CATCH (except, RETURN_MASK_ALL)
 582     {
 583       struct ui_file *stb = mem_fileopen ();
 584       struct cleanup *old_chain = make_cleanup_ui_file_delete (stb);
 585
 586       common_val_print (((value_object *) self)->value, stb, 0,
 587                         &opts, python_language);
 588       s = ui_file_xstrdup (stb, NULL);
 589
 590       do_cleanups (old_chain);
 591     }
 592   GDB_PY_HANDLE_EXCEPTION (except);
 593
 594   result = PyUnicode_Decode (s, strlen (s), host_charset (), NULL);
 595   xfree (s);
 596
 597   return result;
 598 }
 599
 600 /* Implements gdb.Value.is_optimized_out.  */
 601 static PyObject *
 602 valpy_get_is_optimized_out (PyObject *self, void *closure)
 603 {
 604   struct value *value = ((value_object *) self)->value;
 605   int opt = 0;
 606   volatile struct gdb_exception except;
 607
 608   TRY_CATCH (except, RETURN_MASK_ALL)
 609     {
 610       opt = value_optimized_out (value);
 611     }
 612   GDB_PY_HANDLE_EXCEPTION (except);
 613
 614   if (opt)
 615     Py_RETURN_TRUE;
 616
 617   Py_RETURN_FALSE;
 618 }
 619
 620 /* Calculate and return the address of the PyObject as the value of
 621    the builtin __hash__ call.  */
 622 static long
 623 valpy_hash (PyObject *self)
 624 {
 625   return (long) (intptr_t) self;
 626 }
 627
 628 enum valpy_opcode
 629 {
 630   VALPY_ADD,
 631   VALPY_SUB,
 632   VALPY_MUL,
 633   VALPY_DIV,
 634   VALPY_REM,
 635   VALPY_POW,
 636   VALPY_LSH,
 637   VALPY_RSH,
 638   VALPY_BITAND,
 639   VALPY_BITOR,
 640   VALPY_BITXOR
 641 };
 642
 643 /* If TYPE is a reference, return the target; otherwise return TYPE.  */
 644 #define STRIP_REFERENCE(TYPE) \
 645   ((TYPE_CODE (TYPE) == TYPE_CODE_REF) ? (TYPE_TARGET_TYPE (TYPE)) : (TYPE))
 646
 647 /* Returns a value object which is the result of applying the operation
 648    specified by OPCODE to the given arguments.  Returns NULL on error, with
 649    a python exception set.  */
 650 static PyObject *
 651 valpy_binop (enum valpy_opcode opcode, PyObject *self, PyObject *other)
 652 {
 653   struct value *res_val = NULL;   /* Initialize to appease gcc warning.  */
 654   volatile struct gdb_exception except;
 655
 656   TRY_CATCH (except, RETURN_MASK_ALL)
 657     {
 658       struct value *arg1, *arg2;
 659
 660       /* If the gdb.Value object is the second operand, then it will be passed
 661          to us as the OTHER argument, and SELF will be an entirely different
 662          kind of object, altogether.  Because of this, we can't assume self is
 663          a gdb.Value object and need to convert it from python as well.  */
 664       arg1 = convert_value_from_python (self);
 665       if (arg1 == NULL)
 666         break;
 667
 668       arg2 = convert_value_from_python (other);
 669       if (arg2 == NULL)
 670         break;
 671
 672       switch (opcode)
 673         {
 674         case VALPY_ADD:
 675           {
 676             struct type *ltype = value_type (arg1);
 677             struct type *rtype = value_type (arg2);
 678
 679             CHECK_TYPEDEF (ltype);
 680             ltype = STRIP_REFERENCE (ltype);
 681             CHECK_TYPEDEF (rtype);
 682             rtype = STRIP_REFERENCE (rtype);
 683
 684             if (TYPE_CODE (ltype) == TYPE_CODE_PTR
 685                 && is_integral_type (rtype))
 686               res_val = value_ptradd (arg1, value_as_long (arg2));
 687             else if (TYPE_CODE (rtype) == TYPE_CODE_PTR
 688                      && is_integral_type (ltype))
 689               res_val = value_ptradd (arg2, value_as_long (arg1));
 690             else
 691               res_val = value_binop (arg1, arg2, BINOP_ADD);
 692           }
 693           break;
 694         case VALPY_SUB:
 695           {
 696             struct type *ltype = value_type (arg1);
 697             struct type *rtype = value_type (arg2);
 698
 699             CHECK_TYPEDEF (ltype);
 700             ltype = STRIP_REFERENCE (ltype);
 701             CHECK_TYPEDEF (rtype);
 702             rtype = STRIP_REFERENCE (rtype);
 703
 704             if (TYPE_CODE (ltype) == TYPE_CODE_PTR
 705                 && TYPE_CODE (rtype) == TYPE_CODE_PTR)
 706               /* A ptrdiff_t for the target would be preferable here.  */
 707               res_val = value_from_longest (builtin_type_pyint,
 708                                             value_ptrdiff (arg1, arg2));
 709             else if (TYPE_CODE (ltype) == TYPE_CODE_PTR
 710                      && is_integral_type (rtype))
 711               res_val = value_ptradd (arg1, - value_as_long (arg2));
 712             else
 713               res_val = value_binop (arg1, arg2, BINOP_SUB);
 714           }
 715           break;
 716         case VALPY_MUL:
 717           res_val = value_binop (arg1, arg2, BINOP_MUL);
 718           break;
 719         case VALPY_DIV:
 720           res_val = value_binop (arg1, arg2, BINOP_DIV);
 721           break;
 722         case VALPY_REM:
 723           res_val = value_binop (arg1, arg2, BINOP_REM);
 724           break;
 725         case VALPY_POW:
 726           res_val = value_binop (arg1, arg2, BINOP_EXP);
 727           break;
 728         case VALPY_LSH:
 729           res_val = value_binop (arg1, arg2, BINOP_LSH);
 730           break;
 731         case VALPY_RSH:
 732           res_val = value_binop (arg1, arg2, BINOP_RSH);
 733           break;
 734         case VALPY_BITAND:
 735           res_val = value_binop (arg1, arg2, BINOP_BITWISE_AND);
 736           break;
 737         case VALPY_BITOR:
 738           res_val = value_binop (arg1, arg2, BINOP_BITWISE_IOR);
 739           break;
 740         case VALPY_BITXOR:
 741           res_val = value_binop (arg1, arg2, BINOP_BITWISE_XOR);
 742           break;
 743         }
 744     }
 745   GDB_PY_HANDLE_EXCEPTION (except);
 746
 747   return res_val ? value_to_value_object (res_val) : NULL;
 748 }
 749
 750 static PyObject *
 751 valpy_add (PyObject *self, PyObject *other)
 752 {
 753   return valpy_binop (VALPY_ADD, self, other);
 754 }
 755
 756 static PyObject *
 757 valpy_subtract (PyObject *self, PyObject *other)
 758 {
 759   return valpy_binop (VALPY_SUB, self, other);
 760 }
 761
 762 static PyObject *
 763 valpy_multiply (PyObject *self, PyObject *other)
 764 {
 765   return valpy_binop (VALPY_MUL, self, other);
 766 }
 767
 768 static PyObject *
 769 valpy_divide (PyObject *self, PyObject *other)
 770 {
 771   return valpy_binop (VALPY_DIV, self, other);
 772 }
 773
 774 static PyObject *
 775 valpy_remainder (PyObject *self, PyObject *other)
 776 {
 777   return valpy_binop (VALPY_REM, self, other);
 778 }
 779
 780 static PyObject *
 781 valpy_power (PyObject *self, PyObject *other, PyObject *unused)
 782 {
 783   /* We don't support the ternary form of pow.  I don't know how to express
 784      that, so let's just throw NotImplementedError to at least do something
 785      about it.  */
 786   if (unused != Py_None)
 787     {
 788       PyErr_SetString (PyExc_NotImplementedError,
 789                        "Invalid operation on gdb.Value.");
 790       return NULL;
 791     }
 792
 793   return valpy_binop (VALPY_POW, self, other);
 794 }
 795
 796 static PyObject *
 797 valpy_negative (PyObject *self)
 798 {
 799   struct value *val = NULL;
 800   volatile struct gdb_exception except;
 801
 802   TRY_CATCH (except, RETURN_MASK_ALL)
 803     {
 804       val = value_neg (((value_object *) self)->value);
 805     }
 806   GDB_PY_HANDLE_EXCEPTION (except);
 807
 808   return value_to_value_object (val);
 809 }
 810
 811 static PyObject *
 812 valpy_positive (PyObject *self)
 813 {
 814   return value_to_value_object (((value_object *) self)->value);
 815 }
 816
 817 static PyObject *
 818 valpy_absolute (PyObject *self)
 819 {
 820   struct value *value = ((value_object *) self)->value;
 821   volatile struct gdb_exception except;
 822   int isabs = 1;
 823
 824   TRY_CATCH (except, RETURN_MASK_ALL)
 825     {
 826       if (value_less (value, value_zero (value_type (value), not_lval)))
 827         isabs = 0;
 828     }
 829   GDB_PY_HANDLE_EXCEPTION (except);
 830
 831   if (isabs)
 832     return valpy_positive (self);
 833   else
 834     return valpy_negative (self);
 835 }
 836
 837 /* Implements boolean evaluation of gdb.Value.  */
 838 static int
 839 valpy_nonzero (PyObject *self)
 840 {
 841   volatile struct gdb_exception except;
 842   value_object *self_value = (value_object *) self;
 843   struct type *type;
 844   int nonzero = 0; /* Appease GCC warning.  */
 845
 846   type = check_typedef (value_type (self_value->value));
 847
 848   TRY_CATCH (except, RETURN_MASK_ALL)
 849     {
 850       if (is_integral_type (type) || TYPE_CODE (type) == TYPE_CODE_PTR)
 851         nonzero = !!value_as_long (self_value->value);
 852       else if (TYPE_CODE (type) == TYPE_CODE_FLT)
 853         nonzero = value_as_double (self_value->value) != 0;
 854       else if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
 855         nonzero = !decimal_is_zero (value_contents (self_value->value),
 856                                  TYPE_LENGTH (type),
 857                                  gdbarch_byte_order (get_type_arch (type)));
 858       else
 859         /* All other values are True.  */
 860         nonzero = 1;
 861     }
 862   /* This is not documented in the Python documentation, but if this
 863      function fails, return -1 as slot_nb_nonzero does (the default
 864      Python nonzero function).  */
 865   GDB_PY_SET_HANDLE_EXCEPTION (except);
 866
 867   return nonzero;
 868 }
 869
 870 /* Implements ~ for value objects.  */
 871 static PyObject *
 872 valpy_invert (PyObject *self)
 873 {
 874   struct value *val = NULL;
 875   volatile struct gdb_exception except;
 876
 877   TRY_CATCH (except, RETURN_MASK_ALL)
 878     {
 879       val = value_complement (((value_object *) self)->value);
 880     }
 881   GDB_PY_HANDLE_EXCEPTION (except);
 882
 883   return value_to_value_object (val);
 884 }
 885
 886 /* Implements left shift for value objects.  */
 887 static PyObject *
 888 valpy_lsh (PyObject *self, PyObject *other)
 889 {
 890   return valpy_binop (VALPY_LSH, self, other);
 891 }
 892
 893 /* Implements right shift for value objects.  */
 894 static PyObject *
 895 valpy_rsh (PyObject *self, PyObject *other)
 896 {
 897   return valpy_binop (VALPY_RSH, self, other);
 898 }
 899
 900 /* Implements bitwise and for value objects.  */
 901 static PyObject *
 902 valpy_and (PyObject *self, PyObject *other)
 903 {
 904   return valpy_binop (VALPY_BITAND, self, other);
 905 }
 906
 907 /* Implements bitwise or for value objects.  */
 908 static PyObject *
 909 valpy_or (PyObject *self, PyObject *other)
 910 {
 911   return valpy_binop (VALPY_BITOR, self, other);
 912 }
 913
 914 /* Implements bitwise xor for value objects.  */
 915 static PyObject *
 916 valpy_xor (PyObject *self, PyObject *other)
 917 {
 918   return valpy_binop (VALPY_BITXOR, self, other);
 919 }
 920
 921 /* Implements comparison operations for value objects.  Returns NULL on error,
 922    with a python exception set.  */
 923 static PyObject *
 924 valpy_richcompare (PyObject *self, PyObject *other, int op)
 925 {
 926   int result = 0;
 927   struct value *value_other;
 928   volatile struct gdb_exception except;
 929
 930   if (other == Py_None)
 931     /* Comparing with None is special.  From what I can tell, in Python
 932        None is smaller than anything else.  */
 933     switch (op) {
 934       case Py_LT:
 935       case Py_LE:
 936       case Py_EQ:
 937         Py_RETURN_FALSE;
 938       case Py_NE:
 939       case Py_GT:
 940       case Py_GE:
 941         Py_RETURN_TRUE;
 942       default:
 943         /* Can't happen.  */
 944         PyErr_SetString (PyExc_NotImplementedError,
 945                          _("Invalid operation on gdb.Value."));
 946         return NULL;
 947     }
 948
 949   TRY_CATCH (except, RETURN_MASK_ALL)
 950     {
 951       value_other = convert_value_from_python (other);
 952       if (value_other == NULL)
 953         {
 954           result = -1;
 955           break;
 956         }
 957
 958       switch (op) {
 959         case Py_LT:
 960           result = value_less (((value_object *) self)->value, value_other);
 961           break;
 962         case Py_LE:
 963           result = value_less (((value_object *) self)->value, value_other)
 964             || value_equal (((value_object *) self)->value, value_other);
 965           break;
 966         case Py_EQ:
 967           result = value_equal (((value_object *) self)->value, value_other);
 968           break;
 969         case Py_NE:
 970           result = !value_equal (((value_object *) self)->value, value_other);
 971           break;
 972         case Py_GT:
 973           result = value_less (value_other, ((value_object *) self)->value);
 974           break;
 975         case Py_GE:
 976           result = value_less (value_other, ((value_object *) self)->value)
 977             || value_equal (((value_object *) self)->value, value_other);
 978           break;
 979         default:
 980           /* Can't happen.  */
 981           PyErr_SetString (PyExc_NotImplementedError,
 982                            _("Invalid operation on gdb.Value."));
 983           result = -1;
 984           break;
 985       }
 986     }
 987   GDB_PY_HANDLE_EXCEPTION (except);
 988
 989   /* In this case, the Python exception has already been set.  */
 990   if (result < 0)
 991     return NULL;
 992
 993   if (result == 1)
 994     Py_RETURN_TRUE;
 995
 996   Py_RETURN_FALSE;
 997 }
 998
 999 /* Helper function to determine if a type is "int-like".  */
1000 static int
1001 is_intlike (struct type *type, int ptr_ok)
1002 {
1003   return (TYPE_CODE (type) == TYPE_CODE_INT
1004           || TYPE_CODE (type) == TYPE_CODE_ENUM
1005           || TYPE_CODE (type) == TYPE_CODE_BOOL
1006           || TYPE_CODE (type) == TYPE_CODE_CHAR
1007           || (ptr_ok && TYPE_CODE (type) == TYPE_CODE_PTR));
1008 }
1009
1010 /* Implements conversion to int.  */
1011 static PyObject *
1012 valpy_int (PyObject *self)
1013 {
1014   struct value *value = ((value_object *) self)->value;
1015   struct type *type = value_type (value);
1016   LONGEST l = 0;
1017   volatile struct gdb_exception except;
1018
1019   TRY_CATCH (except, RETURN_MASK_ALL)
1020     {
1021       CHECK_TYPEDEF (type);
1022       if (!is_intlike (type, 0))
1023         error (_("Cannot convert value to int."));
1024
1025       l = value_as_long (value);
1026     }
1027   GDB_PY_HANDLE_EXCEPTION (except);
1028
1029   return gdb_py_object_from_longest (l);
1030 }
1031
1032 /* Implements conversion to long.  */
1033 static PyObject *
1034 valpy_long (PyObject *self)
1035 {
1036   struct value *value = ((value_object *) self)->value;
1037   struct type *type = value_type (value);
1038   LONGEST l = 0;
1039   volatile struct gdb_exception except;
1040
1041   TRY_CATCH (except, RETURN_MASK_ALL)
1042     {
1043       CHECK_TYPEDEF (type);
1044
1045       if (!is_intlike (type, 1))
1046         error (_("Cannot convert value to long."));
1047
1048       l = value_as_long (value);
1049     }
1050   GDB_PY_HANDLE_EXCEPTION (except);
1051
1052   return gdb_py_long_from_longest (l);
1053 }
1054
1055 /* Implements conversion to float.  */
1056 static PyObject *
1057 valpy_float (PyObject *self)
1058 {
1059   struct value *value = ((value_object *) self)->value;
1060   struct type *type = value_type (value);
1061   double d = 0;
1062   volatile struct gdb_exception except;
1063
1064   TRY_CATCH (except, RETURN_MASK_ALL)
1065     {
1066       CHECK_TYPEDEF (type);
1067
1068       if (TYPE_CODE (type) != TYPE_CODE_FLT)
1069         error (_("Cannot convert value to float."));
1070
1071       d = value_as_double (value);
1072     }
1073   GDB_PY_HANDLE_EXCEPTION (except);
1074
1075   return PyFloat_FromDouble (d);
1076 }
1077
1078 /* Returns an object for a value which is released from the all_values chain,
1079    so its lifetime is not bound to the execution of a command.  */
1080 PyObject *
1081 value_to_value_object (struct value *val)
1082 {
1083   value_object *val_obj;
1084   volatile struct gdb_exception except;
1085
1086   TRY_CATCH (except, RETURN_MASK_ALL)
1087     {
1088       if (value_lazy (val))
1089         value_fetch_lazy (val);
1090     }
1091   GDB_PY_HANDLE_EXCEPTION (except);
1092
1093   val_obj = PyObject_New (value_object, &value_object_type);
1094   if (val_obj != NULL)
1095     {
1096       val_obj->value = val;
1097       value_incref (val);
1098       val_obj->address = NULL;
1099       val_obj->type = NULL;
1100       val_obj->dynamic_type = NULL;
1101       note_value (val_obj);
1102     }
1103
1104   return (PyObject *) val_obj;
1105 }
1106
1107 /* Returns a borrowed reference to the struct value corresponding to
1108    the given value object.  */
1109 struct value *
1110 value_object_to_value (PyObject *self)
1111 {
1112   value_object *real;
1113
1114   if (! PyObject_TypeCheck (self, &value_object_type))
1115     return NULL;
1116   real = (value_object *) self;
1117   return real->value;
1118 }
1119
1120 /* Try to convert a Python value to a gdb value.  If the value cannot
1121    be converted, set a Python exception and return NULL.  Returns a
1122    reference to a new value on the all_values chain.  */
1123
1124 struct value *
1125 convert_value_from_python (PyObject *obj)
1126 {
1127   struct value *value = NULL; /* -Wall */
1128   struct cleanup *old;
1129   volatile struct gdb_exception except;
1130   int cmp;
1131
1132   gdb_assert (obj != NULL);
1133
1134   TRY_CATCH (except, RETURN_MASK_ALL)
1135     {
1136       if (PyBool_Check (obj))
1137         {
1138           cmp = PyObject_IsTrue (obj);
1139           if (cmp >= 0)
1140             value = value_from_longest (builtin_type_pybool, cmp);
1141         }
1142       else if (PyInt_Check (obj))
1143         {
1144           long l = PyInt_AsLong (obj);
1145
1146           if (! PyErr_Occurred ())
1147             value = value_from_longest (builtin_type_pyint, l);
1148         }
1149       else if (PyLong_Check (obj))
1150         {
1151           LONGEST l = PyLong_AsLongLong (obj);
1152
1153           if (PyErr_Occurred ())
1154             {
1155               /* If the error was an overflow, we can try converting to
1156                  ULONGEST instead.  */
1157               if (PyErr_ExceptionMatches (PyExc_OverflowError))
1158                 {
1159                   PyObject *etype, *evalue, *etraceback, *zero;
1160
1161                   PyErr_Fetch (&etype, &evalue, &etraceback);
1162                   zero = PyInt_FromLong (0);
1163
1164                   /* Check whether obj is positive.  */
1165                   if (PyObject_RichCompareBool (obj, zero, Py_GT) > 0)
1166                     {
1167                       ULONGEST ul;
1168
1169                       ul = PyLong_AsUnsignedLongLong (obj);
1170                       if (! PyErr_Occurred ())
1171                         value = value_from_ulongest (builtin_type_upylong, ul);
1172                     }
1173                   else
1174                     /* There's nothing we can do.  */
1175                     PyErr_Restore (etype, evalue, etraceback);
1176
1177                   Py_DECREF (zero);
1178                 }
1179             }
1180           else
1181             value = value_from_longest (builtin_type_pylong, l);
1182         }
1183       else if (PyFloat_Check (obj))
1184         {
1185           double d = PyFloat_AsDouble (obj);
1186
1187           if (! PyErr_Occurred ())
1188             value = value_from_double (builtin_type_pyfloat, d);
1189         }
1190       else if (gdbpy_is_string (obj))
1191         {
1192           char *s;
1193
1194           s = python_string_to_target_string (obj);
1195           if (s != NULL)
1196             {
1197               old = make_cleanup (xfree, s);
1198               value = value_cstring (s, strlen (s), builtin_type_pychar);
1199               do_cleanups (old);
1200             }
1201         }
1202       else if (PyObject_TypeCheck (obj, &value_object_type))
1203         value = value_copy (((value_object *) obj)->value);
1204       else if (gdbpy_is_lazy_string (obj))
1205         {
1206           PyObject *result;
1207
1208           result = PyObject_CallMethodObjArgs (obj, gdbpy_value_cst,  NULL);
1209           value = value_copy (((value_object *) result)->value);
1210         }
1211       else
1212         PyErr_Format (PyExc_TypeError,
1213                       _("Could not convert Python object: %s."),
1214                       PyString_AsString (PyObject_Str (obj)));
1215     }
1216   if (except.reason < 0)
1217     {
1218       PyErr_Format (except.reason == RETURN_QUIT
1219                     ? PyExc_KeyboardInterrupt : PyExc_RuntimeError,
1220                     "%s", except.message);
1221       return NULL;
1222     }
1223
1224   return value;
1225 }
1226
1227 /* Returns value object in the ARGth position in GDB's history.  */
1228 PyObject *
1229 gdbpy_history (PyObject *self, PyObject *args)
1230 {
1231   int i;
1232   struct value *res_val = NULL;   /* Initialize to appease gcc warning.  */
1233   volatile struct gdb_exception except;
1234
1235   if (!PyArg_ParseTuple (args, "i", &i))
1236     return NULL;
1237
1238   TRY_CATCH (except, RETURN_MASK_ALL)
1239     {
1240       res_val = access_value_history (i);
1241     }
1242   GDB_PY_HANDLE_EXCEPTION (except);
1243
1244   return value_to_value_object (res_val);
1245 }
1246
1247 /* Returns 1 in OBJ is a gdb.Value object, 0 otherwise.  */
1248
1249 int
1250 gdbpy_is_value_object (PyObject *obj)
1251 {
1252   return PyObject_TypeCheck (obj, &value_object_type);
1253 }
1254
1255 void
1256 gdbpy_initialize_values (void)
1257 {
1258   if (PyType_Ready (&value_object_type) < 0)
1259     return;
1260
1261   Py_INCREF (&value_object_type);
1262   PyModule_AddObject (gdb_module, "Value", (PyObject *) &value_object_type);
1263
1264   values_in_python = NULL;
1265 }
1266
1267 \f
1268
1269 static PyGetSetDef value_object_getset[] = {
1270   { "address", valpy_get_address, NULL, "The address of the value.",
1271     NULL },
1272   { "is_optimized_out", valpy_get_is_optimized_out, NULL,
1273     "Boolean telling whether the value is optimized "
1274     "out (i.e., not available).",
1275     NULL },
1276   { "type", valpy_get_type, NULL, "Type of the value.", NULL },
1277   { "dynamic_type", valpy_get_dynamic_type, NULL,
1278     "Dynamic type of the value.", NULL },
1279   {NULL}  /* Sentinel */
1280 };
1281
1282 static PyMethodDef value_object_methods[] = {
1283   { "cast", valpy_cast, METH_VARARGS, "Cast the value to the supplied type." },
1284   { "dynamic_cast", valpy_dynamic_cast, METH_VARARGS,
1285     "dynamic_cast (gdb.Type) -> gdb.Value\n\
1286 Cast the value to the supplied type, as if by the C++ dynamic_cast operator."
1287   },
1288   { "reinterpret_cast", valpy_reinterpret_cast, METH_VARARGS,
1289     "reinterpret_cast (gdb.Type) -> gdb.Value\n\
1290 Cast the value to the supplied type, as if by the C++\n\
1291 reinterpret_cast operator."
1292   },
1293   { "dereference", valpy_dereference, METH_NOARGS, "Dereferences the value." },
1294   { "lazy_string", (PyCFunction) valpy_lazy_string,
1295     METH_VARARGS | METH_KEYWORDS,
1296     "lazy_string ([encoding]  [, length]) -> lazy_string\n\
1297 Return a lazy string representation of the value." },
1298   { "string", (PyCFunction) valpy_string, METH_VARARGS | METH_KEYWORDS,
1299     "string ([encoding] [, errors] [, length]) -> string\n\
1300 Return Unicode string representation of the value." },
1301   {NULL}  /* Sentinel */
1302 };
1303
1304 static PyNumberMethods value_object_as_number = {
1305   valpy_add,
1306   valpy_subtract,
1307   valpy_multiply,
1308   valpy_divide,
1309   valpy_remainder,
1310   NULL,                       /* nb_divmod */
1311   valpy_power,                /* nb_power */
1312   valpy_negative,             /* nb_negative */
1313   valpy_positive,             /* nb_positive */
1314   valpy_absolute,             /* nb_absolute */
1315   valpy_nonzero,              /* nb_nonzero */
1316   valpy_invert,               /* nb_invert */
1317   valpy_lsh,                  /* nb_lshift */
1318   valpy_rsh,                  /* nb_rshift */
1319   valpy_and,                  /* nb_and */
1320   valpy_xor,                  /* nb_xor */
1321   valpy_or,                   /* nb_or */
1322   NULL,                       /* nb_coerce */
1323   valpy_int,                  /* nb_int */
1324   valpy_long,                 /* nb_long */
1325   valpy_float,                /* nb_float */
1326   NULL,                       /* nb_oct */
1327   NULL                        /* nb_hex */
1328 };
1329
1330 static PyMappingMethods value_object_as_mapping = {
1331   valpy_length,
1332   valpy_getitem,
1333   valpy_setitem
1334 };
1335
1336 PyTypeObject value_object_type = {
1337   PyObject_HEAD_INIT (NULL)
1338   0,                              /*ob_size*/
1339   "gdb.Value",                    /*tp_name*/
1340   sizeof (value_object),          /*tp_basicsize*/
1341   0,                              /*tp_itemsize*/
1342   valpy_dealloc,                  /*tp_dealloc*/
1343   0,                              /*tp_print*/
1344   0,                              /*tp_getattr*/
1345   0,                              /*tp_setattr*/
1346   0,                              /*tp_compare*/
1347   0,                              /*tp_repr*/
1348   &value_object_as_number,        /*tp_as_number*/
1349   0,                              /*tp_as_sequence*/
1350   &value_object_as_mapping,       /*tp_as_mapping*/
1351   valpy_hash,                     /*tp_hash*/
1352   valpy_call,                     /*tp_call*/
1353   valpy_str,                      /*tp_str*/
1354   0,                              /*tp_getattro*/
1355   0,                              /*tp_setattro*/
1356   0,                              /*tp_as_buffer*/
1357   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_CHECKTYPES
1358   | Py_TPFLAGS_BASETYPE,          /*tp_flags*/
1359   "GDB value object",             /* tp_doc */
1360   0,                              /* tp_traverse */
1361   0,                              /* tp_clear */
1362   valpy_richcompare,              /* tp_richcompare */
1363   0,                              /* tp_weaklistoffset */
1364   0,                              /* tp_iter */
1365   0,                              /* tp_iternext */
1366   value_object_methods,           /* tp_methods */
1367   0,                              /* tp_members */
1368   value_object_getset,            /* tp_getset */
1369   0,                              /* tp_base */
1370   0,                              /* tp_dict */
1371   0,                              /* tp_descr_get */
1372   0,                              /* tp_descr_set */
1373   0,                              /* tp_dictoffset */
1374   0,                              /* tp_init */
1375   0,                              /* tp_alloc */
1376   valpy_new                       /* tp_new */
1377 };
1378
1379 #else
1380
1381 void
1382 preserve_python_values (struct objfile *objfile, htab_t copied_types)
1383 {
1384   /* Nothing.  */
1385 }
1386
1387 #endif /* HAVE_PYTHON */