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