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_INCREF (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 316 if (!PyArg_ParseTupleAndKeywords (args, kw, "|s" GDB_PY_LL_ARG, keywords, 317 &user_encoding, &length)) 318 return NULL; 319 320 if (TYPE_CODE (value_type (value)) == TYPE_CODE_PTR) 321 value = value_ind (value); 322 323 str_obj = gdbpy_create_lazy_string_object (value_address (value), length, 324 user_encoding, 325 value_type (value)); 326 327 return (PyObject *) str_obj; 328 } 329 330 /* Implementation of gdb.Value.string ([encoding] [, errors] 331 [, length]) -> string. Return Unicode string with value contents. 332 If ENCODING is not given, the string is assumed to be encoded in 333 the target's charset. If LENGTH is provided, only fetch string to 334 the length provided. */ 335 336 static PyObject * 337 valpy_string (PyObject *self, PyObject *args, PyObject *kw) 338 { 339 int length = -1; 340 gdb_byte *buffer; 341 struct value *value = ((value_object *) self)->value; 342 volatile struct gdb_exception except; 343 PyObject *unicode; 344 const char *encoding = NULL; 345 const char *errors = NULL; 346 const char *user_encoding = NULL; 347 const char *la_encoding = NULL; 348 struct type *char_type; 349 static char *keywords[] = { "encoding", "errors", "length", NULL }; 350 351 if (!PyArg_ParseTupleAndKeywords (args, kw, "|ssi", keywords, 352 &user_encoding, &errors, &length)) 353 return NULL; 354 355 TRY_CATCH (except, RETURN_MASK_ALL) 356 { 357 LA_GET_STRING (value, &buffer, &length, &char_type, &la_encoding); 358 } 359 GDB_PY_HANDLE_EXCEPTION (except); 360 361 encoding = (user_encoding && *user_encoding) ? user_encoding : la_encoding; 362 unicode = PyUnicode_Decode (buffer, length * TYPE_LENGTH (char_type), 363 encoding, errors); 364 xfree (buffer); 365 366 return unicode; 367 } 368 369 /* A helper function that implements the various cast operators. */ 370 371 static PyObject * 372 valpy_do_cast (PyObject *self, PyObject *args, enum exp_opcode op) 373 { 374 PyObject *type_obj; 375 struct type *type; 376 struct value *res_val = NULL; /* Initialize to appease gcc warning. */ 377 volatile struct gdb_exception except; 378 379 if (! PyArg_ParseTuple (args, "O", &type_obj)) 380 return NULL; 381 382 type = type_object_to_type (type_obj); 383 if (! type) 384 { 385 PyErr_SetString (PyExc_RuntimeError, 386 _("Argument must be a type.")); 387 return NULL; 388 } 389 390 TRY_CATCH (except, RETURN_MASK_ALL) 391 { 392 struct value *val = ((value_object *) self)->value; 393 394 if (op == UNOP_DYNAMIC_CAST) 395 res_val = value_dynamic_cast (type, val); 396 else if (op == UNOP_REINTERPRET_CAST) 397 res_val = value_reinterpret_cast (type, val); 398 else 399 { 400 gdb_assert (op == UNOP_CAST); 401 res_val = value_cast (type, val); 402 } 403 } 404 GDB_PY_HANDLE_EXCEPTION (except); 405 406 return value_to_value_object (res_val); 407 } 408 409 /* Implementation of the "cast" method. */ 410 411 static PyObject * 412 valpy_cast (PyObject *self, PyObject *args) 413 { 414 return valpy_do_cast (self, args, UNOP_CAST); 415 } 416 417 /* Implementation of the "dynamic_cast" method. */ 418 419 static PyObject * 420 valpy_dynamic_cast (PyObject *self, PyObject *args) 421 { 422 return valpy_do_cast (self, args, UNOP_DYNAMIC_CAST); 423 } 424 425 /* Implementation of the "reinterpret_cast" method. */ 426 427 static PyObject * 428 valpy_reinterpret_cast (PyObject *self, PyObject *args) 429 { 430 return valpy_do_cast (self, args, UNOP_REINTERPRET_CAST); 431 } 432 433 static Py_ssize_t 434 valpy_length (PyObject *self) 435 { 436 /* We don't support getting the number of elements in a struct / class. */ 437 PyErr_SetString (PyExc_NotImplementedError, 438 _("Invalid operation on gdb.Value.")); 439 return -1; 440 } 441 442 /* Given string name of an element inside structure, return its value 443 object. Returns NULL on error, with a python exception set. */ 444 static PyObject * 445 valpy_getitem (PyObject *self, PyObject *key) 446 { 447 value_object *self_value = (value_object *) self; 448 char *field = NULL; 449 struct value *res_val = NULL; 450 volatile struct gdb_exception except; 451 452 if (gdbpy_is_string (key)) 453 { 454 field = python_string_to_host_string (key); 455 if (field == NULL) 456 return NULL; 457 } 458 459 TRY_CATCH (except, RETURN_MASK_ALL) 460 { 461 struct value *tmp = self_value->value; 462 463 if (field) 464 res_val = value_struct_elt (&tmp, NULL, field, 0, NULL); 465 else 466 { 467 /* Assume we are attempting an array access, and let the 468 value code throw an exception if the index has an invalid 469 type. */ 470 struct value *idx = convert_value_from_python (key); 471 472 if (idx != NULL) 473 { 474 /* Check the value's type is something that can be accessed via 475 a subscript. */ 476 struct type *type; 477 478 tmp = coerce_ref (tmp); 479 type = check_typedef (value_type (tmp)); 480 if (TYPE_CODE (type) != TYPE_CODE_ARRAY 481 && TYPE_CODE (type) != TYPE_CODE_PTR) 482 error (_("Cannot subscript requested type.")); 483 else 484 res_val = value_subscript (tmp, value_as_long (idx)); 485 } 486 } 487 } 488 489 xfree (field); 490 GDB_PY_HANDLE_EXCEPTION (except); 491 492 return res_val ? value_to_value_object (res_val) : NULL; 493 } 494 495 static int 496 valpy_setitem (PyObject *self, PyObject *key, PyObject *value) 497 { 498 PyErr_Format (PyExc_NotImplementedError, 499 _("Setting of struct elements is not currently supported.")); 500 return -1; 501 } 502 503 /* Called by the Python interpreter to perform an inferior function 504 call on the value. Returns NULL on error, with a python exception set. */ 505 static PyObject * 506 valpy_call (PyObject *self, PyObject *args, PyObject *keywords) 507 { 508 struct value *return_value = NULL; 509 Py_ssize_t args_count; 510 volatile struct gdb_exception except; 511 struct value *function = ((value_object *) self)->value; 512 struct value **vargs = NULL; 513 struct type *ftype = check_typedef (value_type (function)); 514 515 if (TYPE_CODE (ftype) != TYPE_CODE_FUNC) 516 { 517 PyErr_SetString (PyExc_RuntimeError, 518 _("Value is not callable (not TYPE_CODE_FUNC).")); 519 return NULL; 520 } 521 522 args_count = PyTuple_Size (args); 523 if (args_count > 0) 524 { 525 int i; 526 527 vargs = alloca (sizeof (struct value *) * args_count); 528 for (i = 0; i < args_count; i++) 529 { 530 PyObject *item = PyTuple_GetItem (args, i); 531 532 if (item == NULL) 533 return NULL; 534 535 vargs[i] = convert_value_from_python (item); 536 if (vargs[i] == NULL) 537 return NULL; 538 } 539 } 540 541 TRY_CATCH (except, RETURN_MASK_ALL) 542 { 543 return_value = call_function_by_hand (function, args_count, vargs); 544 } 545 GDB_PY_HANDLE_EXCEPTION (except); 546 547 return value_to_value_object (return_value); 548 } 549 550 /* Called by the Python interpreter to obtain string representation 551 of the object. */ 552 static PyObject * 553 valpy_str (PyObject *self) 554 { 555 char *s = NULL; 556 struct ui_file *stb; 557 struct cleanup *old_chain; 558 PyObject *result; 559 struct value_print_options opts; 560 volatile struct gdb_exception except; 561 562 get_user_print_options (&opts); 563 opts.deref_ref = 0; 564 565 stb = mem_fileopen (); 566 old_chain = make_cleanup_ui_file_delete (stb); 567 568 TRY_CATCH (except, RETURN_MASK_ALL) 569 { 570 common_val_print (((value_object *) self)->value, stb, 0, 571 &opts, python_language); 572 s = ui_file_xstrdup (stb, NULL); 573 } 574 GDB_PY_HANDLE_EXCEPTION (except); 575 576 do_cleanups (old_chain); 577 578 result = PyUnicode_Decode (s, strlen (s), host_charset (), NULL); 579 xfree (s); 580 581 return result; 582 } 583 584 /* Implements gdb.Value.is_optimized_out. */ 585 static PyObject * 586 valpy_get_is_optimized_out (PyObject *self, void *closure) 587 { 588 struct value *value = ((value_object *) self)->value; 589 590 if (value_optimized_out (value)) 591 Py_RETURN_TRUE; 592 593 Py_RETURN_FALSE; 594 } 595 596 /* Calculate and return the address of the PyObject as the value of 597 the builtin __hash__ call. */ 598 static long 599 valpy_hash (PyObject *self) 600 { 601 return (long) (intptr_t) self; 602 } 603 604 enum valpy_opcode 605 { 606 VALPY_ADD, 607 VALPY_SUB, 608 VALPY_MUL, 609 VALPY_DIV, 610 VALPY_REM, 611 VALPY_POW, 612 VALPY_LSH, 613 VALPY_RSH, 614 VALPY_BITAND, 615 VALPY_BITOR, 616 VALPY_BITXOR 617 }; 618 619 /* If TYPE is a reference, return the target; otherwise return TYPE. */ 620 #define STRIP_REFERENCE(TYPE) \ 621 ((TYPE_CODE (TYPE) == TYPE_CODE_REF) ? (TYPE_TARGET_TYPE (TYPE)) : (TYPE)) 622 623 /* Returns a value object which is the result of applying the operation 624 specified by OPCODE to the given arguments. Returns NULL on error, with 625 a python exception set. */ 626 static PyObject * 627 valpy_binop (enum valpy_opcode opcode, PyObject *self, PyObject *other) 628 { 629 struct value *res_val = NULL; /* Initialize to appease gcc warning. */ 630 volatile struct gdb_exception except; 631 632 TRY_CATCH (except, RETURN_MASK_ALL) 633 { 634 struct value *arg1, *arg2; 635 636 /* If the gdb.Value object is the second operand, then it will be passed 637 to us as the OTHER argument, and SELF will be an entirely different 638 kind of object, altogether. Because of this, we can't assume self is 639 a gdb.Value object and need to convert it from python as well. */ 640 arg1 = convert_value_from_python (self); 641 if (arg1 == NULL) 642 break; 643 644 arg2 = convert_value_from_python (other); 645 if (arg2 == NULL) 646 break; 647 648 switch (opcode) 649 { 650 case VALPY_ADD: 651 { 652 struct type *ltype = value_type (arg1); 653 struct type *rtype = value_type (arg2); 654 655 CHECK_TYPEDEF (ltype); 656 ltype = STRIP_REFERENCE (ltype); 657 CHECK_TYPEDEF (rtype); 658 rtype = STRIP_REFERENCE (rtype); 659 660 if (TYPE_CODE (ltype) == TYPE_CODE_PTR 661 && is_integral_type (rtype)) 662 res_val = value_ptradd (arg1, value_as_long (arg2)); 663 else if (TYPE_CODE (rtype) == TYPE_CODE_PTR 664 && is_integral_type (ltype)) 665 res_val = value_ptradd (arg2, value_as_long (arg1)); 666 else 667 res_val = value_binop (arg1, arg2, BINOP_ADD); 668 } 669 break; 670 case VALPY_SUB: 671 { 672 struct type *ltype = value_type (arg1); 673 struct type *rtype = value_type (arg2); 674 675 CHECK_TYPEDEF (ltype); 676 ltype = STRIP_REFERENCE (ltype); 677 CHECK_TYPEDEF (rtype); 678 rtype = STRIP_REFERENCE (rtype); 679 680 if (TYPE_CODE (ltype) == TYPE_CODE_PTR 681 && TYPE_CODE (rtype) == TYPE_CODE_PTR) 682 /* A ptrdiff_t for the target would be preferable here. */ 683 res_val = value_from_longest (builtin_type_pyint, 684 value_ptrdiff (arg1, arg2)); 685 else if (TYPE_CODE (ltype) == TYPE_CODE_PTR 686 && is_integral_type (rtype)) 687 res_val = value_ptradd (arg1, - value_as_long (arg2)); 688 else 689 res_val = value_binop (arg1, arg2, BINOP_SUB); 690 } 691 break; 692 case VALPY_MUL: 693 res_val = value_binop (arg1, arg2, BINOP_MUL); 694 break; 695 case VALPY_DIV: 696 res_val = value_binop (arg1, arg2, BINOP_DIV); 697 break; 698 case VALPY_REM: 699 res_val = value_binop (arg1, arg2, BINOP_REM); 700 break; 701 case VALPY_POW: 702 res_val = value_binop (arg1, arg2, BINOP_EXP); 703 break; 704 case VALPY_LSH: 705 res_val = value_binop (arg1, arg2, BINOP_LSH); 706 break; 707 case VALPY_RSH: 708 res_val = value_binop (arg1, arg2, BINOP_RSH); 709 break; 710 case VALPY_BITAND: 711 res_val = value_binop (arg1, arg2, BINOP_BITWISE_AND); 712 break; 713 case VALPY_BITOR: 714 res_val = value_binop (arg1, arg2, BINOP_BITWISE_IOR); 715 break; 716 case VALPY_BITXOR: 717 res_val = value_binop (arg1, arg2, BINOP_BITWISE_XOR); 718 break; 719 } 720 } 721 GDB_PY_HANDLE_EXCEPTION (except); 722 723 return res_val ? value_to_value_object (res_val) : NULL; 724 } 725 726 static PyObject * 727 valpy_add (PyObject *self, PyObject *other) 728 { 729 return valpy_binop (VALPY_ADD, self, other); 730 } 731 732 static PyObject * 733 valpy_subtract (PyObject *self, PyObject *other) 734 { 735 return valpy_binop (VALPY_SUB, self, other); 736 } 737 738 static PyObject * 739 valpy_multiply (PyObject *self, PyObject *other) 740 { 741 return valpy_binop (VALPY_MUL, self, other); 742 } 743 744 static PyObject * 745 valpy_divide (PyObject *self, PyObject *other) 746 { 747 return valpy_binop (VALPY_DIV, self, other); 748 } 749 750 static PyObject * 751 valpy_remainder (PyObject *self, PyObject *other) 752 { 753 return valpy_binop (VALPY_REM, self, other); 754 } 755 756 static PyObject * 757 valpy_power (PyObject *self, PyObject *other, PyObject *unused) 758 { 759 /* We don't support the ternary form of pow. I don't know how to express 760 that, so let's just throw NotImplementedError to at least do something 761 about it. */ 762 if (unused != Py_None) 763 { 764 PyErr_SetString (PyExc_NotImplementedError, 765 "Invalid operation on gdb.Value."); 766 return NULL; 767 } 768 769 return valpy_binop (VALPY_POW, self, other); 770 } 771 772 static PyObject * 773 valpy_negative (PyObject *self) 774 { 775 struct value *val = NULL; 776 volatile struct gdb_exception except; 777 778 TRY_CATCH (except, RETURN_MASK_ALL) 779 { 780 val = value_neg (((value_object *) self)->value); 781 } 782 GDB_PY_HANDLE_EXCEPTION (except); 783 784 return value_to_value_object (val); 785 } 786 787 static PyObject * 788 valpy_positive (PyObject *self) 789 { 790 return value_to_value_object (((value_object *) self)->value); 791 } 792 793 static PyObject * 794 valpy_absolute (PyObject *self) 795 { 796 struct value *value = ((value_object *) self)->value; 797 798 if (value_less (value, value_zero (value_type (value), not_lval))) 799 return valpy_negative (self); 800 else 801 return valpy_positive (self); 802 } 803 804 /* Implements boolean evaluation of gdb.Value. */ 805 static int 806 valpy_nonzero (PyObject *self) 807 { 808 value_object *self_value = (value_object *) self; 809 struct type *type; 810 811 type = check_typedef (value_type (self_value->value)); 812 813 if (is_integral_type (type) || TYPE_CODE (type) == TYPE_CODE_PTR) 814 return !!value_as_long (self_value->value); 815 else if (TYPE_CODE (type) == TYPE_CODE_FLT) 816 return value_as_double (self_value->value) != 0; 817 else if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT) 818 return !decimal_is_zero (value_contents (self_value->value), 819 TYPE_LENGTH (type), 820 gdbarch_byte_order (get_type_arch (type))); 821 else 822 /* All other values are True. */ 823 return 1; 824 } 825 826 /* Implements ~ for value objects. */ 827 static PyObject * 828 valpy_invert (PyObject *self) 829 { 830 struct value *val = NULL; 831 volatile struct gdb_exception except; 832 833 TRY_CATCH (except, RETURN_MASK_ALL) 834 { 835 val = value_complement (((value_object *) self)->value); 836 } 837 GDB_PY_HANDLE_EXCEPTION (except); 838 839 return value_to_value_object (val); 840 } 841 842 /* Implements left shift for value objects. */ 843 static PyObject * 844 valpy_lsh (PyObject *self, PyObject *other) 845 { 846 return valpy_binop (VALPY_LSH, self, other); 847 } 848 849 /* Implements right shift for value objects. */ 850 static PyObject * 851 valpy_rsh (PyObject *self, PyObject *other) 852 { 853 return valpy_binop (VALPY_RSH, self, other); 854 } 855 856 /* Implements bitwise and for value objects. */ 857 static PyObject * 858 valpy_and (PyObject *self, PyObject *other) 859 { 860 return valpy_binop (VALPY_BITAND, self, other); 861 } 862 863 /* Implements bitwise or for value objects. */ 864 static PyObject * 865 valpy_or (PyObject *self, PyObject *other) 866 { 867 return valpy_binop (VALPY_BITOR, self, other); 868 } 869 870 /* Implements bitwise xor for value objects. */ 871 static PyObject * 872 valpy_xor (PyObject *self, PyObject *other) 873 { 874 return valpy_binop (VALPY_BITXOR, self, other); 875 } 876 877 /* Implements comparison operations for value objects. Returns NULL on error, 878 with a python exception set. */ 879 static PyObject * 880 valpy_richcompare (PyObject *self, PyObject *other, int op) 881 { 882 int result = 0; 883 struct value *value_other; 884 volatile struct gdb_exception except; 885 886 if (other == Py_None) 887 /* Comparing with None is special. From what I can tell, in Python 888 None is smaller than anything else. */ 889 switch (op) { 890 case Py_LT: 891 case Py_LE: 892 case Py_EQ: 893 Py_RETURN_FALSE; 894 case Py_NE: 895 case Py_GT: 896 case Py_GE: 897 Py_RETURN_TRUE; 898 default: 899 /* Can't happen. */ 900 PyErr_SetString (PyExc_NotImplementedError, 901 _("Invalid operation on gdb.Value.")); 902 return NULL; 903 } 904 905 TRY_CATCH (except, RETURN_MASK_ALL) 906 { 907 value_other = convert_value_from_python (other); 908 if (value_other == NULL) 909 { 910 result = -1; 911 break; 912 } 913 914 switch (op) { 915 case Py_LT: 916 result = value_less (((value_object *) self)->value, value_other); 917 break; 918 case Py_LE: 919 result = value_less (((value_object *) self)->value, value_other) 920 || value_equal (((value_object *) self)->value, value_other); 921 break; 922 case Py_EQ: 923 result = value_equal (((value_object *) self)->value, value_other); 924 break; 925 case Py_NE: 926 result = !value_equal (((value_object *) self)->value, value_other); 927 break; 928 case Py_GT: 929 result = value_less (value_other, ((value_object *) self)->value); 930 break; 931 case Py_GE: 932 result = value_less (value_other, ((value_object *) self)->value) 933 || value_equal (((value_object *) self)->value, value_other); 934 break; 935 default: 936 /* Can't happen. */ 937 PyErr_SetString (PyExc_NotImplementedError, 938 _("Invalid operation on gdb.Value.")); 939 result = -1; 940 break; 941 } 942 } 943 GDB_PY_HANDLE_EXCEPTION (except); 944 945 /* In this case, the Python exception has already been set. */ 946 if (result < 0) 947 return NULL; 948 949 if (result == 1) 950 Py_RETURN_TRUE; 951 952 Py_RETURN_FALSE; 953 } 954 955 /* Helper function to determine if a type is "int-like". */ 956 static int 957 is_intlike (struct type *type, int ptr_ok) 958 { 959 CHECK_TYPEDEF (type); 960 return (TYPE_CODE (type) == TYPE_CODE_INT 961 || TYPE_CODE (type) == TYPE_CODE_ENUM 962 || TYPE_CODE (type) == TYPE_CODE_BOOL 963 || TYPE_CODE (type) == TYPE_CODE_CHAR 964 || (ptr_ok && TYPE_CODE (type) == TYPE_CODE_PTR)); 965 } 966 967 /* Implements conversion to int. */ 968 static PyObject * 969 valpy_int (PyObject *self) 970 { 971 struct value *value = ((value_object *) self)->value; 972 struct type *type = value_type (value); 973 LONGEST l = 0; 974 volatile struct gdb_exception except; 975 976 CHECK_TYPEDEF (type); 977 if (!is_intlike (type, 0)) 978 { 979 PyErr_SetString (PyExc_RuntimeError, 980 _("Cannot convert value to int.")); 981 return NULL; 982 } 983 984 TRY_CATCH (except, RETURN_MASK_ALL) 985 { 986 l = value_as_long (value); 987 } 988 GDB_PY_HANDLE_EXCEPTION (except); 989 990 return gdb_py_object_from_longest (l); 991 } 992 993 /* Implements conversion to long. */ 994 static PyObject * 995 valpy_long (PyObject *self) 996 { 997 struct value *value = ((value_object *) self)->value; 998 struct type *type = value_type (value); 999 LONGEST l = 0; 1000 volatile struct gdb_exception except; 1001 1002 if (!is_intlike (type, 1)) 1003 { 1004 PyErr_SetString (PyExc_RuntimeError, 1005 _("Cannot convert value to long.")); 1006 return NULL; 1007 } 1008 1009 TRY_CATCH (except, RETURN_MASK_ALL) 1010 { 1011 l = value_as_long (value); 1012 } 1013 GDB_PY_HANDLE_EXCEPTION (except); 1014 1015 return gdb_py_long_from_longest (l); 1016 } 1017 1018 /* Implements conversion to float. */ 1019 static PyObject * 1020 valpy_float (PyObject *self) 1021 { 1022 struct value *value = ((value_object *) self)->value; 1023 struct type *type = value_type (value); 1024 double d = 0; 1025 volatile struct gdb_exception except; 1026 1027 CHECK_TYPEDEF (type); 1028 if (TYPE_CODE (type) != TYPE_CODE_FLT) 1029 { 1030 PyErr_SetString (PyExc_RuntimeError, 1031 _("Cannot convert value to float.")); 1032 return NULL; 1033 } 1034 1035 TRY_CATCH (except, RETURN_MASK_ALL) 1036 { 1037 d = value_as_double (value); 1038 } 1039 GDB_PY_HANDLE_EXCEPTION (except); 1040 1041 return PyFloat_FromDouble (d); 1042 } 1043 1044 /* Returns an object for a value which is released from the all_values chain, 1045 so its lifetime is not bound to the execution of a command. */ 1046 PyObject * 1047 value_to_value_object (struct value *val) 1048 { 1049 value_object *val_obj; 1050 1051 val_obj = PyObject_New (value_object, &value_object_type); 1052 if (val_obj != NULL) 1053 { 1054 val_obj->value = val; 1055 value_incref (val); 1056 val_obj->address = NULL; 1057 val_obj->type = NULL; 1058 val_obj->dynamic_type = NULL; 1059 note_value (val_obj); 1060 } 1061 1062 return (PyObject *) val_obj; 1063 } 1064 1065 /* Returns a borrowed reference to the struct value corresponding to 1066 the given value object. */ 1067 struct value * 1068 value_object_to_value (PyObject *self) 1069 { 1070 value_object *real; 1071 1072 if (! PyObject_TypeCheck (self, &value_object_type)) 1073 return NULL; 1074 real = (value_object *) self; 1075 return real->value; 1076 } 1077 1078 /* Try to convert a Python value to a gdb value. If the value cannot 1079 be converted, set a Python exception and return NULL. Returns a 1080 reference to a new value on the all_values chain. */ 1081 1082 struct value * 1083 convert_value_from_python (PyObject *obj) 1084 { 1085 struct value *value = NULL; /* -Wall */ 1086 struct cleanup *old; 1087 volatile struct gdb_exception except; 1088 int cmp; 1089 1090 gdb_assert (obj != NULL); 1091 1092 TRY_CATCH (except, RETURN_MASK_ALL) 1093 { 1094 if (PyBool_Check (obj)) 1095 { 1096 cmp = PyObject_IsTrue (obj); 1097 if (cmp >= 0) 1098 value = value_from_longest (builtin_type_pybool, cmp); 1099 } 1100 else if (PyInt_Check (obj)) 1101 { 1102 long l = PyInt_AsLong (obj); 1103 1104 if (! PyErr_Occurred ()) 1105 value = value_from_longest (builtin_type_pyint, l); 1106 } 1107 else if (PyLong_Check (obj)) 1108 { 1109 LONGEST l = PyLong_AsLongLong (obj); 1110 1111 if (PyErr_Occurred ()) 1112 { 1113 /* If the error was an overflow, we can try converting to 1114 ULONGEST instead. */ 1115 if (PyErr_ExceptionMatches (PyExc_OverflowError)) 1116 { 1117 PyObject *etype, *evalue, *etraceback, *zero; 1118 1119 PyErr_Fetch (&etype, &evalue, &etraceback); 1120 zero = PyInt_FromLong (0); 1121 1122 /* Check whether obj is positive. */ 1123 if (PyObject_RichCompareBool (obj, zero, Py_GT) > 0) 1124 { 1125 ULONGEST ul; 1126 1127 ul = PyLong_AsUnsignedLongLong (obj); 1128 if (! PyErr_Occurred ()) 1129 value = value_from_ulongest (builtin_type_upylong, ul); 1130 } 1131 else 1132 /* There's nothing we can do. */ 1133 PyErr_Restore (etype, evalue, etraceback); 1134 1135 Py_DECREF (zero); 1136 } 1137 } 1138 else 1139 value = value_from_longest (builtin_type_pylong, l); 1140 } 1141 else if (PyFloat_Check (obj)) 1142 { 1143 double d = PyFloat_AsDouble (obj); 1144 1145 if (! PyErr_Occurred ()) 1146 value = value_from_double (builtin_type_pyfloat, d); 1147 } 1148 else if (gdbpy_is_string (obj)) 1149 { 1150 char *s; 1151 1152 s = python_string_to_target_string (obj); 1153 if (s != NULL) 1154 { 1155 old = make_cleanup (xfree, s); 1156 value = value_cstring (s, strlen (s), builtin_type_pychar); 1157 do_cleanups (old); 1158 } 1159 } 1160 else if (PyObject_TypeCheck (obj, &value_object_type)) 1161 value = value_copy (((value_object *) obj)->value); 1162 else if (gdbpy_is_lazy_string (obj)) 1163 { 1164 PyObject *result; 1165 1166 result = PyObject_CallMethodObjArgs (obj, gdbpy_value_cst, NULL); 1167 value = value_copy (((value_object *) result)->value); 1168 } 1169 else 1170 PyErr_Format (PyExc_TypeError, 1171 _("Could not convert Python object: %s."), 1172 PyString_AsString (PyObject_Str (obj))); 1173 } 1174 if (except.reason < 0) 1175 { 1176 PyErr_Format (except.reason == RETURN_QUIT 1177 ? PyExc_KeyboardInterrupt : PyExc_RuntimeError, 1178 "%s", except.message); 1179 return NULL; 1180 } 1181 1182 return value; 1183 } 1184 1185 /* Returns value object in the ARGth position in GDB's history. */ 1186 PyObject * 1187 gdbpy_history (PyObject *self, PyObject *args) 1188 { 1189 int i; 1190 struct value *res_val = NULL; /* Initialize to appease gcc warning. */ 1191 volatile struct gdb_exception except; 1192 1193 if (!PyArg_ParseTuple (args, "i", &i)) 1194 return NULL; 1195 1196 TRY_CATCH (except, RETURN_MASK_ALL) 1197 { 1198 res_val = access_value_history (i); 1199 } 1200 GDB_PY_HANDLE_EXCEPTION (except); 1201 1202 return value_to_value_object (res_val); 1203 } 1204 1205 /* Returns 1 in OBJ is a gdb.Value object, 0 otherwise. */ 1206 1207 int 1208 gdbpy_is_value_object (PyObject *obj) 1209 { 1210 return PyObject_TypeCheck (obj, &value_object_type); 1211 } 1212 1213 void 1214 gdbpy_initialize_values (void) 1215 { 1216 if (PyType_Ready (&value_object_type) < 0) 1217 return; 1218 1219 Py_INCREF (&value_object_type); 1220 PyModule_AddObject (gdb_module, "Value", (PyObject *) &value_object_type); 1221 1222 values_in_python = NULL; 1223 } 1224 1225 1226 1227 static PyGetSetDef value_object_getset[] = { 1228 { "address", valpy_get_address, NULL, "The address of the value.", 1229 NULL }, 1230 { "is_optimized_out", valpy_get_is_optimized_out, NULL, 1231 "Boolean telling whether the value is optimized " 1232 "out (i.e., not available).", 1233 NULL }, 1234 { "type", valpy_get_type, NULL, "Type of the value.", NULL }, 1235 { "dynamic_type", valpy_get_dynamic_type, NULL, 1236 "Dynamic type of the value.", NULL }, 1237 {NULL} /* Sentinel */ 1238 }; 1239 1240 static PyMethodDef value_object_methods[] = { 1241 { "cast", valpy_cast, METH_VARARGS, "Cast the value to the supplied type." }, 1242 { "dynamic_cast", valpy_dynamic_cast, METH_VARARGS, 1243 "dynamic_cast (gdb.Type) -> gdb.Value\n\ 1244 Cast the value to the supplied type, as if by the C++ dynamic_cast operator." 1245 }, 1246 { "reinterpret_cast", valpy_reinterpret_cast, METH_VARARGS, 1247 "reinterpret_cast (gdb.Type) -> gdb.Value\n\ 1248 Cast the value to the supplied type, as if by the C++\n\ 1249 reinterpret_cast operator." 1250 }, 1251 { "dereference", valpy_dereference, METH_NOARGS, "Dereferences the value." }, 1252 { "lazy_string", (PyCFunction) valpy_lazy_string, 1253 METH_VARARGS | METH_KEYWORDS, 1254 "lazy_string ([encoding] [, length]) -> lazy_string\n\ 1255 Return a lazy string representation of the value." }, 1256 { "string", (PyCFunction) valpy_string, METH_VARARGS | METH_KEYWORDS, 1257 "string ([encoding] [, errors] [, length]) -> string\n\ 1258 Return Unicode string representation of the value." }, 1259 {NULL} /* Sentinel */ 1260 }; 1261 1262 static PyNumberMethods value_object_as_number = { 1263 valpy_add, 1264 valpy_subtract, 1265 valpy_multiply, 1266 valpy_divide, 1267 valpy_remainder, 1268 NULL, /* nb_divmod */ 1269 valpy_power, /* nb_power */ 1270 valpy_negative, /* nb_negative */ 1271 valpy_positive, /* nb_positive */ 1272 valpy_absolute, /* nb_absolute */ 1273 valpy_nonzero, /* nb_nonzero */ 1274 valpy_invert, /* nb_invert */ 1275 valpy_lsh, /* nb_lshift */ 1276 valpy_rsh, /* nb_rshift */ 1277 valpy_and, /* nb_and */ 1278 valpy_xor, /* nb_xor */ 1279 valpy_or, /* nb_or */ 1280 NULL, /* nb_coerce */ 1281 valpy_int, /* nb_int */ 1282 valpy_long, /* nb_long */ 1283 valpy_float, /* nb_float */ 1284 NULL, /* nb_oct */ 1285 NULL /* nb_hex */ 1286 }; 1287 1288 static PyMappingMethods value_object_as_mapping = { 1289 valpy_length, 1290 valpy_getitem, 1291 valpy_setitem 1292 }; 1293 1294 PyTypeObject value_object_type = { 1295 PyObject_HEAD_INIT (NULL) 1296 0, /*ob_size*/ 1297 "gdb.Value", /*tp_name*/ 1298 sizeof (value_object), /*tp_basicsize*/ 1299 0, /*tp_itemsize*/ 1300 valpy_dealloc, /*tp_dealloc*/ 1301 0, /*tp_print*/ 1302 0, /*tp_getattr*/ 1303 0, /*tp_setattr*/ 1304 0, /*tp_compare*/ 1305 0, /*tp_repr*/ 1306 &value_object_as_number, /*tp_as_number*/ 1307 0, /*tp_as_sequence*/ 1308 &value_object_as_mapping, /*tp_as_mapping*/ 1309 valpy_hash, /*tp_hash*/ 1310 valpy_call, /*tp_call*/ 1311 valpy_str, /*tp_str*/ 1312 0, /*tp_getattro*/ 1313 0, /*tp_setattro*/ 1314 0, /*tp_as_buffer*/ 1315 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_CHECKTYPES 1316 | Py_TPFLAGS_BASETYPE, /*tp_flags*/ 1317 "GDB value object", /* tp_doc */ 1318 0, /* tp_traverse */ 1319 0, /* tp_clear */ 1320 valpy_richcompare, /* tp_richcompare */ 1321 0, /* tp_weaklistoffset */ 1322 0, /* tp_iter */ 1323 0, /* tp_iternext */ 1324 value_object_methods, /* tp_methods */ 1325 0, /* tp_members */ 1326 value_object_getset, /* tp_getset */ 1327 0, /* tp_base */ 1328 0, /* tp_dict */ 1329 0, /* tp_descr_get */ 1330 0, /* tp_descr_set */ 1331 0, /* tp_dictoffset */ 1332 0, /* tp_init */ 1333 0, /* tp_alloc */ 1334 valpy_new /* tp_new */ 1335 }; 1336 1337 #else 1338 1339 void 1340 preserve_python_values (struct objfile *objfile, htab_t copied_types) 1341 { 1342 /* Nothing. */ 1343 } 1344 1345 #endif /* HAVE_PYTHON */ 1346