GDB (xrefs)
/tmp/gdb-7.10/gdb/varobj.c
Go to the documentation of this file.
1 /* Implementation of the GDB variable objects API.
2 
3  Copyright (C) 1999-2015 Free Software Foundation, Inc.
4 
5  This program is free software; you can redistribute it and/or modify
6  it under the terms of the GNU General Public License as published by
7  the Free Software Foundation; either version 3 of the License, or
8  (at your option) any later version.
9 
10  This program is distributed in the hope that it will be useful,
11  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13  GNU General Public License for more details.
14 
15  You should have received a copy of the GNU General Public License
16  along with this program. If not, see <http://www.gnu.org/licenses/>. */
17 
18 #include "defs.h"
19 #include "value.h"
20 #include "expression.h"
21 #include "frame.h"
22 #include "language.h"
23 #include "gdbcmd.h"
24 #include "block.h"
25 #include "valprint.h"
26 #include "gdb_regex.h"
27 
28 #include "varobj.h"
29 #include "vec.h"
30 #include "gdbthread.h"
31 #include "inferior.h"
32 #include "varobj-iter.h"
33 
34 #if HAVE_PYTHON
35 #include "python/python.h"
36 #include "python/python-internal.h"
37 #else
38 typedef int PyObject;
39 #endif
40 
41 /* Non-zero if we want to see trace of varobj level stuff. */
42 
43 unsigned int varobjdebug = 0;
44 static void
45 show_varobjdebug (struct ui_file *file, int from_tty,
46  struct cmd_list_element *c, const char *value)
47 {
48  fprintf_filtered (file, _("Varobj debugging is %s.\n"), value);
49 }
50 
51 /* String representations of gdb's format codes. */
53  { "natural", "binary", "decimal", "hexadecimal", "octal" };
54 
55 /* True if we want to allow Python-based pretty-printing. */
56 static int pretty_printing = 0;
57 
58 void
60 {
61  pretty_printing = 1;
62 }
63 
64 /* Data structures */
65 
66 /* Every root variable has one of these structures saved in its
67  varobj. Members which must be free'd are noted. */
69 {
70 
71  /* Alloc'd expression for this parent. */
72  struct expression *exp;
73 
74  /* Block for which this expression is valid. */
75  const struct block *valid_block;
76 
77  /* The frame for this expression. This field is set iff valid_block is
78  not NULL. */
79  struct frame_id frame;
80 
81  /* The thread ID that this varobj_root belong to. This field
82  is only valid if valid_block is not NULL.
83  When not 0, indicates which thread 'frame' belongs to.
84  When 0, indicates that the thread list was empty when the varobj_root
85  was created. */
86  int thread_id;
87 
88  /* If 1, the -var-update always recomputes the value in the
89  current thread and frame. Otherwise, variable object is
90  always updated in the specific scope/thread/frame. */
91  int floating;
92 
93  /* Flag that indicates validity: set to 0 when this varobj_root refers
94  to symbols that do not exist anymore. */
95  int is_valid;
96 
97  /* Language-related operations for this variable and its
98  children. */
99  const struct lang_varobj_ops *lang_ops;
100 
101  /* The varobj for this root node. */
102  struct varobj *rootvar;
103 
104  /* Next root variable */
105  struct varobj_root *next;
106 };
107 
108 /* Dynamic part of varobj. */
109 
111 {
112  /* Whether the children of this varobj were requested. This field is
113  used to decide if dynamic varobj should recompute their children.
114  In the event that the frontend never asked for the children, we
115  can avoid that. */
117 
118  /* The pretty-printer constructor. If NULL, then the default
119  pretty-printer will be looked up. If None, then no
120  pretty-printer will be installed. */
121  PyObject *constructor;
122 
123  /* The pretty-printer that has been constructed. If NULL, then a
124  new printer object is needed, and one will be constructed. */
125  PyObject *pretty_printer;
126 
127  /* The iterator returned by the printer's 'children' method, or NULL
128  if not available. */
130 
131  /* We request one extra item from the iterator, so that we can
132  report to the caller whether there are more items than we have
133  already reported. However, we don't want to install this value
134  when we read it, because that will mess up future updates. So,
135  we stash it here instead. */
137 };
138 
139 struct cpstack
140 {
141  char *name;
142  struct cpstack *next;
143 };
144 
145 /* A list of varobjs */
146 
147 struct vlist
148 {
149  struct varobj *var;
150  struct vlist *next;
151 };
152 
153 /* Private function prototypes */
154 
155 /* Helper functions for the above subcommands. */
156 
157 static int delete_variable (struct cpstack **, struct varobj *, int);
158 
159 static void delete_variable_1 (struct cpstack **, int *,
160  struct varobj *, int, int);
161 
162 static int install_variable (struct varobj *);
163 
164 static void uninstall_variable (struct varobj *);
165 
166 static struct varobj *create_child (struct varobj *, int, char *);
167 
168 static struct varobj *
170  struct varobj_item *item);
171 
172 /* Utility routines */
173 
174 static struct varobj *new_variable (void);
175 
176 static struct varobj *new_root_variable (void);
177 
178 static void free_variable (struct varobj *var);
179 
180 static struct cleanup *make_cleanup_free_variable (struct varobj *var);
181 
183 
184 static void cppush (struct cpstack **pstack, char *name);
185 
186 static char *cppop (struct cpstack **pstack);
187 
188 static int update_type_if_necessary (struct varobj *var,
189  struct value *new_value);
190 
191 static int install_new_value (struct varobj *var, struct value *value,
192  int initial);
193 
194 /* Language-specific routines. */
195 
196 static int number_of_children (const struct varobj *);
197 
198 static char *name_of_variable (const struct varobj *);
199 
200 static char *name_of_child (struct varobj *, int);
201 
202 static struct value *value_of_root (struct varobj **var_handle, int *);
203 
204 static struct value *value_of_child (const struct varobj *parent, int index);
205 
206 static char *my_value_of_variable (struct varobj *var,
207  enum varobj_display_formats format);
208 
209 static int is_root_p (const struct varobj *var);
210 
211 static struct varobj *varobj_add_child (struct varobj *var,
212  struct varobj_item *item);
213 
214 /* Private data */
215 
216 /* Mappings of varobj_display_formats enums to gdb's format codes. */
217 static int format_code[] = { 0, 't', 'd', 'x', 'o' };
218 
219 /* Header of the list of root variable objects. */
220 static struct varobj_root *rootlist;
221 
222 /* Prime number indicating the number of buckets in the hash table. */
223 /* A prime large enough to avoid too many colisions. */
224 #define VAROBJ_TABLE_SIZE 227
225 
226 /* Pointer to the varobj hash table (built at run time). */
227 static struct vlist **varobj_table;
228 
229 
230 
231 /* API Implementation */
232 static int
233 is_root_p (const struct varobj *var)
234 {
235  return (var->root->rootvar == var);
236 }
237 
238 #ifdef HAVE_PYTHON
239 /* Helper function to install a Python environment suitable for
240  use during operations on VAR. */
241 struct cleanup *
242 varobj_ensure_python_env (const struct varobj *var)
243 {
244  return ensure_python_env (var->root->exp->gdbarch,
245  var->root->exp->language_defn);
246 }
247 #endif
248 
249 /* Creates a varobj (not its children). */
250 
251 /* Return the full FRAME which corresponds to the given CORE_ADDR
252  or NULL if no FRAME on the chain corresponds to CORE_ADDR. */
253 
254 static struct frame_info *
256 {
257  struct frame_info *frame = NULL;
258 
259  if (frame_addr == (CORE_ADDR) 0)
260  return NULL;
261 
262  for (frame = get_current_frame ();
263  frame != NULL;
264  frame = get_prev_frame (frame))
265  {
266  /* The CORE_ADDR we get as argument was parsed from a string GDB
267  output as $fp. This output got truncated to gdbarch_addr_bit.
268  Truncate the frame base address in the same manner before
269  comparing it against our argument. */
271  int addr_bit = gdbarch_addr_bit (get_frame_arch (frame));
272 
273  if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
274  frame_base &= ((CORE_ADDR) 1 << addr_bit) - 1;
275 
276  if (frame_base == frame_addr)
277  return frame;
278  }
279 
280  return NULL;
281 }
282 
283 struct varobj *
284 varobj_create (char *objname,
285  char *expression, CORE_ADDR frame, enum varobj_type type)
286 {
287  struct varobj *var;
288  struct cleanup *old_chain;
289 
290  /* Fill out a varobj structure for the (root) variable being constructed. */
291  var = new_root_variable ();
292  old_chain = make_cleanup_free_variable (var);
293 
294  if (expression != NULL)
295  {
296  struct frame_info *fi;
297  struct frame_id old_id = null_frame_id;
298  const struct block *block;
299  const char *p;
300  struct value *value = NULL;
301  CORE_ADDR pc;
302 
303  /* Parse and evaluate the expression, filling in as much of the
304  variable's data as possible. */
305 
306  if (has_stack_frames ())
307  {
308  /* Allow creator to specify context of variable. */
309  if ((type == USE_CURRENT_FRAME) || (type == USE_SELECTED_FRAME))
310  fi = get_selected_frame (NULL);
311  else
312  /* FIXME: cagney/2002-11-23: This code should be doing a
313  lookup using the frame ID and not just the frame's
314  ``address''. This, of course, means an interface
315  change. However, with out that interface change ISAs,
316  such as the ia64 with its two stacks, won't work.
317  Similar goes for the case where there is a frameless
318  function. */
319  fi = find_frame_addr_in_frame_chain (frame);
320  }
321  else
322  fi = NULL;
323 
324  /* frame = -2 means always use selected frame. */
325  if (type == USE_SELECTED_FRAME)
326  var->root->floating = 1;
327 
328  pc = 0;
329  block = NULL;
330  if (fi != NULL)
331  {
332  block = get_frame_block (fi, 0);
333  pc = get_frame_pc (fi);
334  }
335 
336  p = expression;
337  innermost_block = NULL;
338  /* Wrap the call to parse expression, so we can
339  return a sensible error. */
340  TRY
341  {
342  var->root->exp = parse_exp_1 (&p, pc, block, 0);
343  }
344 
345  CATCH (except, RETURN_MASK_ERROR)
346  {
347  do_cleanups (old_chain);
348  return NULL;
349  }
350  END_CATCH
351 
352  /* Don't allow variables to be created for types. */
353  if (var->root->exp->elts[0].opcode == OP_TYPE
354  || var->root->exp->elts[0].opcode == OP_TYPEOF
355  || var->root->exp->elts[0].opcode == OP_DECLTYPE)
356  {
357  do_cleanups (old_chain);
358  fprintf_unfiltered (gdb_stderr, "Attempt to use a type name"
359  " as an expression.\n");
360  return NULL;
361  }
362 
363  var->format = variable_default_display (var);
365  var->name = xstrdup (expression);
366  /* For a root var, the name and the expr are the same. */
367  var->path_expr = xstrdup (expression);
368 
369  /* When the frame is different from the current frame,
370  we must select the appropriate frame before parsing
371  the expression, otherwise the value will not be current.
372  Since select_frame is so benign, just call it for all cases. */
373  if (innermost_block)
374  {
375  /* User could specify explicit FRAME-ADDR which was not found but
376  EXPRESSION is frame specific and we would not be able to evaluate
377  it correctly next time. With VALID_BLOCK set we must also set
378  FRAME and THREAD_ID. */
379  if (fi == NULL)
380  error (_("Failed to find the specified frame"));
381 
382  var->root->frame = get_frame_id (fi);
384  old_id = get_frame_id (get_selected_frame (NULL));
385  select_frame (fi);
386  }
387 
388  /* We definitely need to catch errors here.
389  If evaluate_expression succeeds we got the value we wanted.
390  But if it fails, we still go on with a call to evaluate_type(). */
391  TRY
392  {
393  value = evaluate_expression (var->root->exp);
394  }
395  CATCH (except, RETURN_MASK_ERROR)
396  {
397  /* Error getting the value. Try to at least get the
398  right type. */
399  struct value *type_only_value = evaluate_type (var->root->exp);
400 
401  var->type = value_type (type_only_value);
402  }
403  END_CATCH
404 
405  if (value != NULL)
406  {
407  int real_type_found = 0;
408 
409  var->type = value_actual_type (value, 0, &real_type_found);
410  if (real_type_found)
411  value = value_cast (var->type, value);
412  }
413 
414  /* Set language info */
416 
417  install_new_value (var, value, 1 /* Initial assignment */);
418 
419  /* Set ourselves as our root. */
420  var->root->rootvar = var;
421 
422  /* Reset the selected frame. */
423  if (frame_id_p (old_id))
424  select_frame (frame_find_by_id (old_id));
425  }
426 
427  /* If the variable object name is null, that means this
428  is a temporary variable, so don't install it. */
429 
430  if ((var != NULL) && (objname != NULL))
431  {
432  var->obj_name = xstrdup (objname);
433 
434  /* If a varobj name is duplicated, the install will fail so
435  we must cleanup. */
436  if (!install_variable (var))
437  {
438  do_cleanups (old_chain);
439  return NULL;
440  }
441  }
442 
443  discard_cleanups (old_chain);
444  return var;
445 }
446 
447 /* Generates an unique name that can be used for a varobj. */
448 
449 char *
451 {
452  static int id = 0;
453  char *obj_name;
454 
455  /* Generate a name for this object. */
456  id++;
457  obj_name = xstrprintf ("var%d", id);
458 
459  return obj_name;
460 }
461 
462 /* Given an OBJNAME, returns the pointer to the corresponding varobj. Call
463  error if OBJNAME cannot be found. */
464 
465 struct varobj *
466 varobj_get_handle (char *objname)
467 {
468  struct vlist *cv;
469  const char *chp;
470  unsigned int index = 0;
471  unsigned int i = 1;
472 
473  for (chp = objname; *chp; chp++)
474  {
475  index = (index + (i++ * (unsigned int) *chp)) % VAROBJ_TABLE_SIZE;
476  }
477 
478  cv = *(varobj_table + index);
479  while ((cv != NULL) && (strcmp (cv->var->obj_name, objname) != 0))
480  cv = cv->next;
481 
482  if (cv == NULL)
483  error (_("Variable object not found"));
484 
485  return cv->var;
486 }
487 
488 /* Given the handle, return the name of the object. */
489 
490 char *
491 varobj_get_objname (const struct varobj *var)
492 {
493  return var->obj_name;
494 }
495 
496 /* Given the handle, return the expression represented by the object. The
497  result must be freed by the caller. */
498 
499 char *
500 varobj_get_expression (const struct varobj *var)
501 {
502  return name_of_variable (var);
503 }
504 
505 /* Deletes a varobj and all its children if only_children == 0,
506  otherwise deletes only the children. If DELLIST is non-NULL, it is
507  assigned a malloc'ed list of all the (malloc'ed) names of the variables
508  that have been deleted (NULL terminated). Returns the number of deleted
509  variables. */
510 
511 int
512 varobj_delete (struct varobj *var, char ***dellist, int only_children)
513 {
514  int delcount;
515  int mycount;
516  struct cpstack *result = NULL;
517  char **cp;
518 
519  /* Initialize a stack for temporary results. */
520  cppush (&result, NULL);
521 
522  if (only_children)
523  /* Delete only the variable children. */
524  delcount = delete_variable (&result, var, 1 /* only the children */ );
525  else
526  /* Delete the variable and all its children. */
527  delcount = delete_variable (&result, var, 0 /* parent+children */ );
528 
529  /* We may have been asked to return a list of what has been deleted. */
530  if (dellist != NULL)
531  {
532  *dellist = xmalloc ((delcount + 1) * sizeof (char *));
533 
534  cp = *dellist;
535  mycount = delcount;
536  *cp = cppop (&result);
537  while ((*cp != NULL) && (mycount > 0))
538  {
539  mycount--;
540  cp++;
541  *cp = cppop (&result);
542  }
543 
544  if (mycount || (*cp != NULL))
545  warning (_("varobj_delete: assertion failed - mycount(=%d) <> 0"),
546  mycount);
547  }
548 
549  return delcount;
550 }
551 
552 #if HAVE_PYTHON
553 
554 /* Convenience function for varobj_set_visualizer. Instantiate a
555  pretty-printer for a given value. */
556 static PyObject *
557 instantiate_pretty_printer (PyObject *constructor, struct value *value)
558 {
559  PyObject *val_obj = NULL;
560  PyObject *printer;
561 
562  val_obj = value_to_value_object (value);
563  if (! val_obj)
564  return NULL;
565 
566  printer = PyObject_CallFunctionObjArgs (constructor, val_obj, NULL);
567  Py_DECREF (val_obj);
568  return printer;
569 }
570 
571 #endif
572 
573 /* Set/Get variable object display format. */
574 
577  enum varobj_display_formats format)
578 {
579  switch (format)
580  {
581  case FORMAT_NATURAL:
582  case FORMAT_BINARY:
583  case FORMAT_DECIMAL:
584  case FORMAT_HEXADECIMAL:
585  case FORMAT_OCTAL:
586  var->format = format;
587  break;
588 
589  default:
590  var->format = variable_default_display (var);
591  }
592 
594  && var->value && !value_lazy (var->value))
595  {
596  xfree (var->print_value);
598  var->format, var);
599  }
600 
601  return var->format;
602 }
603 
606 {
607  return var->format;
608 }
609 
610 char *
611 varobj_get_display_hint (const struct varobj *var)
612 {
613  char *result = NULL;
614 
615 #if HAVE_PYTHON
616  struct cleanup *back_to;
617 
619  return NULL;
620 
621  back_to = varobj_ensure_python_env (var);
622 
623  if (var->dynamic->pretty_printer != NULL)
625 
626  do_cleanups (back_to);
627 #endif
628 
629  return result;
630 }
631 
632 /* Return true if the varobj has items after TO, false otherwise. */
633 
634 int
635 varobj_has_more (const struct varobj *var, int to)
636 {
637  if (VEC_length (varobj_p, var->children) > to)
638  return 1;
639  return ((to == -1 || VEC_length (varobj_p, var->children) == to)
640  && (var->dynamic->saved_item != NULL));
641 }
642 
643 /* If the variable object is bound to a specific thread, that
644  is its evaluation can always be done in context of a frame
645  inside that thread, returns GDB id of the thread -- which
646  is always positive. Otherwise, returns -1. */
647 int
648 varobj_get_thread_id (const struct varobj *var)
649 {
650  if (var->root->valid_block && var->root->thread_id > 0)
651  return var->root->thread_id;
652  else
653  return -1;
654 }
655 
656 void
657 varobj_set_frozen (struct varobj *var, int frozen)
658 {
659  /* When a variable is unfrozen, we don't fetch its value.
660  The 'not_fetched' flag remains set, so next -var-update
661  won't complain.
662 
663  We don't fetch the value, because for structures the client
664  should do -var-update anyway. It would be bad to have different
665  client-size logic for structure and other types. */
666  var->frozen = frozen;
667 }
668 
669 int
670 varobj_get_frozen (const struct varobj *var)
671 {
672  return var->frozen;
673 }
674 
675 /* A helper function that restricts a range to what is actually
676  available in a VEC. This follows the usual rules for the meaning
677  of FROM and TO -- if either is negative, the entire range is
678  used. */
679 
680 void
681 varobj_restrict_range (VEC (varobj_p) *children, int *from, int *to)
682 {
683  if (*from < 0 || *to < 0)
684  {
685  *from = 0;
686  *to = VEC_length (varobj_p, children);
687  }
688  else
689  {
690  if (*from > VEC_length (varobj_p, children))
691  *from = VEC_length (varobj_p, children);
692  if (*to > VEC_length (varobj_p, children))
693  *to = VEC_length (varobj_p, children);
694  if (*from > *to)
695  *from = *to;
696  }
697 }
698 
699 /* A helper for update_dynamic_varobj_children that installs a new
700  child when needed. */
701 
702 static void
704  VEC (varobj_p) **changed,
705  VEC (varobj_p) **type_changed,
706  VEC (varobj_p) **newobj,
707  VEC (varobj_p) **unchanged,
708  int *cchanged,
709  int index,
710  struct varobj_item *item)
711 {
712  if (VEC_length (varobj_p, var->children) < index + 1)
713  {
714  /* There's no child yet. */
715  struct varobj *child = varobj_add_child (var, item);
716 
717  if (newobj)
718  {
719  VEC_safe_push (varobj_p, *newobj, child);
720  *cchanged = 1;
721  }
722  }
723  else
724  {
725  varobj_p existing = VEC_index (varobj_p, var->children, index);
726  int type_updated = update_type_if_necessary (existing, item->value);
727 
728  if (type_updated)
729  {
730  if (type_changed)
731  VEC_safe_push (varobj_p, *type_changed, existing);
732  }
733  if (install_new_value (existing, item->value, 0))
734  {
735  if (!type_updated && changed)
736  VEC_safe_push (varobj_p, *changed, existing);
737  }
738  else if (!type_updated && unchanged)
739  VEC_safe_push (varobj_p, *unchanged, existing);
740  }
741 }
742 
743 #if HAVE_PYTHON
744 
745 static int
747 {
748  struct cleanup *back_to;
749  PyObject *printer = var->dynamic->pretty_printer;
750  int result;
751 
753  return 0;
754 
755  back_to = varobj_ensure_python_env (var);
756  result = PyObject_HasAttr (printer, gdbpy_children_cst);
757  do_cleanups (back_to);
758  return result;
759 }
760 #endif
761 
762 /* A factory for creating dynamic varobj's iterators. Returns an
763  iterator object suitable for iterating over VAR's children. */
764 
765 static struct varobj_iter *
767 {
768 #if HAVE_PYTHON
769  if (var->dynamic->pretty_printer)
770  return py_varobj_get_iterator (var, var->dynamic->pretty_printer);
771 #endif
772 
774 requested an iterator from a non-dynamic varobj"));
775 }
776 
777 /* Release and clear VAR's saved item, if any. */
778 
779 static void
781 {
782  if (var->saved_item != NULL)
783  {
784  value_free (var->saved_item->value);
785  xfree (var->saved_item);
786  var->saved_item = NULL;
787  }
788 }
789 
790 static int
792  VEC (varobj_p) **changed,
793  VEC (varobj_p) **type_changed,
794  VEC (varobj_p) **newobj,
795  VEC (varobj_p) **unchanged,
796  int *cchanged,
797  int update_children,
798  int from,
799  int to)
800 {
801  int i;
802 
803  *cchanged = 0;
804 
805  if (update_children || var->dynamic->child_iter == NULL)
806  {
808  var->dynamic->child_iter = varobj_get_iterator (var);
809 
811 
812  i = 0;
813 
814  if (var->dynamic->child_iter == NULL)
815  return 0;
816  }
817  else
818  i = VEC_length (varobj_p, var->children);
819 
820  /* We ask for one extra child, so that MI can report whether there
821  are more children. */
822  for (; to < 0 || i < to + 1; ++i)
823  {
824  varobj_item *item;
825 
826  /* See if there was a leftover from last time. */
827  if (var->dynamic->saved_item != NULL)
828  {
829  item = var->dynamic->saved_item;
830  var->dynamic->saved_item = NULL;
831  }
832  else
833  {
834  item = varobj_iter_next (var->dynamic->child_iter);
835  /* Release vitem->value so its lifetime is not bound to the
836  execution of a command. */
837  if (item != NULL && item->value != NULL)
839  }
840 
841  if (item == NULL)
842  {
843  /* Iteration is done. Remove iterator from VAR. */
845  var->dynamic->child_iter = NULL;
846  break;
847  }
848  /* We don't want to push the extra child on any report list. */
849  if (to < 0 || i < to)
850  {
851  int can_mention = from < 0 || i >= from;
852 
853  install_dynamic_child (var, can_mention ? changed : NULL,
854  can_mention ? type_changed : NULL,
855  can_mention ? newobj : NULL,
856  can_mention ? unchanged : NULL,
857  can_mention ? cchanged : NULL, i,
858  item);
859 
860  xfree (item);
861  }
862  else
863  {
864  var->dynamic->saved_item = item;
865 
866  /* We want to truncate the child list just before this
867  element. */
868  break;
869  }
870  }
871 
872  if (i < VEC_length (varobj_p, var->children))
873  {
874  int j;
875 
876  *cchanged = 1;
877  for (j = i; j < VEC_length (varobj_p, var->children); ++j)
878  varobj_delete (VEC_index (varobj_p, var->children, j), NULL, 0);
879  VEC_truncate (varobj_p, var->children, i);
880  }
881 
882  /* If there are fewer children than requested, note that the list of
883  children changed. */
884  if (to >= 0 && VEC_length (varobj_p, var->children) < to)
885  *cchanged = 1;
886 
887  var->num_children = VEC_length (varobj_p, var->children);
888 
889  return 1;
890 }
891 
892 int
894 {
895  if (var->num_children == -1)
896  {
897  if (varobj_is_dynamic_p (var))
898  {
899  int dummy;
900 
901  /* If we have a dynamic varobj, don't report -1 children.
902  So, try to fetch some children first. */
903  update_dynamic_varobj_children (var, NULL, NULL, NULL, NULL, &dummy,
904  0, 0, 0);
905  }
906  else
907  var->num_children = number_of_children (var);
908  }
909 
910  return var->num_children >= 0 ? var->num_children : 0;
911 }
912 
913 /* Creates a list of the immediate children of a variable object;
914  the return code is the number of such children or -1 on error. */
915 
917 varobj_list_children (struct varobj *var, int *from, int *to)
918 {
919  char *name;
920  int i, children_changed;
921 
922  var->dynamic->children_requested = 1;
923 
924  if (varobj_is_dynamic_p (var))
925  {
926  /* This, in theory, can result in the number of children changing without
927  frontend noticing. But well, calling -var-list-children on the same
928  varobj twice is not something a sane frontend would do. */
929  update_dynamic_varobj_children (var, NULL, NULL, NULL, NULL,
930  &children_changed, 0, 0, *to);
931  varobj_restrict_range (var->children, from, to);
932  return var->children;
933  }
934 
935  if (var->num_children == -1)
936  var->num_children = number_of_children (var);
937 
938  /* If that failed, give up. */
939  if (var->num_children == -1)
940  return var->children;
941 
942  /* If we're called when the list of children is not yet initialized,
943  allocate enough elements in it. */
944  while (VEC_length (varobj_p, var->children) < var->num_children)
945  VEC_safe_push (varobj_p, var->children, NULL);
946 
947  for (i = 0; i < var->num_children; i++)
948  {
949  varobj_p existing = VEC_index (varobj_p, var->children, i);
950 
951  if (existing == NULL)
952  {
953  /* Either it's the first call to varobj_list_children for
954  this variable object, and the child was never created,
955  or it was explicitly deleted by the client. */
956  name = name_of_child (var, i);
957  existing = create_child (var, i, name);
958  VEC_replace (varobj_p, var->children, i, existing);
959  }
960  }
961 
962  varobj_restrict_range (var->children, from, to);
963  return var->children;
964 }
965 
966 static struct varobj *
967 varobj_add_child (struct varobj *var, struct varobj_item *item)
968 {
970  VEC_length (varobj_p, var->children),
971  item);
972 
973  VEC_safe_push (varobj_p, var->children, v);
974  return v;
975 }
976 
977 /* Obtain the type of an object Variable as a string similar to the one gdb
978  prints on the console. The caller is responsible for freeing the string.
979  */
980 
981 char *
982 varobj_get_type (struct varobj *var)
983 {
984  /* For the "fake" variables, do not return a type. (Its type is
985  NULL, too.)
986  Do not return a type for invalid variables as well. */
987  if (CPLUS_FAKE_CHILD (var) || !var->root->is_valid)
988  return NULL;
989 
990  return type_to_string (var->type);
991 }
992 
993 /* Obtain the type of an object variable. */
994 
995 struct type *
996 varobj_get_gdb_type (const struct varobj *var)
997 {
998  return var->type;
999 }
1000 
1001 /* Is VAR a path expression parent, i.e., can it be used to construct
1002  a valid path expression? */
1003 
1004 static int
1005 is_path_expr_parent (const struct varobj *var)
1006 {
1007  gdb_assert (var->root->lang_ops->is_path_expr_parent != NULL);
1008  return var->root->lang_ops->is_path_expr_parent (var);
1009 }
1010 
1011 /* Is VAR a path expression parent, i.e., can it be used to construct
1012  a valid path expression? By default we assume any VAR can be a path
1013  parent. */
1014 
1015 int
1017 {
1018  return 1;
1019 }
1020 
1021 /* Return the path expression parent for VAR. */
1022 
1023 const struct varobj *
1025 {
1026  const struct varobj *parent = var;
1027 
1028  while (!is_root_p (parent) && !is_path_expr_parent (parent))
1029  parent = parent->parent;
1030 
1031  return parent;
1032 }
1033 
1034 /* Return a pointer to the full rooted expression of varobj VAR.
1035  If it has not been computed yet, compute it. */
1036 char *
1037 varobj_get_path_expr (const struct varobj *var)
1038 {
1039  if (var->path_expr == NULL)
1040  {
1041  /* For root varobjs, we initialize path_expr
1042  when creating varobj, so here it should be
1043  child varobj. */
1044  struct varobj *mutable_var = (struct varobj *) var;
1045  gdb_assert (!is_root_p (var));
1046 
1047  mutable_var->path_expr = (*var->root->lang_ops->path_expr_of_child) (var);
1048  }
1049 
1050  return var->path_expr;
1051 }
1052 
1053 const struct language_defn *
1054 varobj_get_language (const struct varobj *var)
1055 {
1056  return var->root->exp->language_defn;
1057 }
1058 
1059 int
1060 varobj_get_attributes (const struct varobj *var)
1061 {
1062  int attributes = 0;
1063 
1064  if (varobj_editable_p (var))
1065  /* FIXME: define masks for attributes. */
1066  attributes |= 0x00000001; /* Editable */
1067 
1068  return attributes;
1069 }
1070 
1071 /* Return true if VAR is a dynamic varobj. */
1072 
1073 int
1074 varobj_is_dynamic_p (const struct varobj *var)
1075 {
1076  return var->dynamic->pretty_printer != NULL;
1077 }
1078 
1079 char *
1081  enum varobj_display_formats format)
1082 {
1083  return my_value_of_variable (var, format);
1084 }
1085 
1086 char *
1088 {
1089  return my_value_of_variable (var, var->format);
1090 }
1091 
1092 /* Set the value of an object variable (if it is editable) to the
1093  value of the given expression. */
1094 /* Note: Invokes functions that can call error(). */
1095 
1096 int
1097 varobj_set_value (struct varobj *var, char *expression)
1098 {
1099  struct value *val = NULL; /* Initialize to keep gcc happy. */
1100  /* The argument "expression" contains the variable's new value.
1101  We need to first construct a legal expression for this -- ugh! */
1102  /* Does this cover all the bases? */
1103  struct expression *exp;
1104  struct value *value = NULL; /* Initialize to keep gcc happy. */
1105  int saved_input_radix = input_radix;
1106  const char *s = expression;
1107 
1108  gdb_assert (varobj_editable_p (var));
1109 
1110  input_radix = 10; /* ALWAYS reset to decimal temporarily. */
1111  exp = parse_exp_1 (&s, 0, 0, 0);
1112  TRY
1113  {
1114  value = evaluate_expression (exp);
1115  }
1116 
1117  CATCH (except, RETURN_MASK_ERROR)
1118  {
1119  /* We cannot proceed without a valid expression. */
1120  xfree (exp);
1121  return 0;
1122  }
1123  END_CATCH
1124 
1125  /* All types that are editable must also be changeable. */
1127 
1128  /* The value of a changeable variable object must not be lazy. */
1129  gdb_assert (!value_lazy (var->value));
1130 
1131  /* Need to coerce the input. We want to check if the
1132  value of the variable object will be different
1133  after assignment, and the first thing value_assign
1134  does is coerce the input.
1135  For example, if we are assigning an array to a pointer variable we
1136  should compare the pointer with the array's address, not with the
1137  array's content. */
1138  value = coerce_array (value);
1139 
1140  /* The new value may be lazy. value_assign, or
1141  rather value_contents, will take care of this. */
1142  TRY
1143  {
1144  val = value_assign (var->value, value);
1145  }
1146 
1147  CATCH (except, RETURN_MASK_ERROR)
1148  {
1149  return 0;
1150  }
1151  END_CATCH
1152 
1153  /* If the value has changed, record it, so that next -var-update can
1154  report this change. If a variable had a value of '1', we've set it
1155  to '333' and then set again to '1', when -var-update will report this
1156  variable as changed -- because the first assignment has set the
1157  'updated' flag. There's no need to optimize that, because return value
1158  of -var-update should be considered an approximation. */
1159  var->updated = install_new_value (var, val, 0 /* Compare values. */);
1160  input_radix = saved_input_radix;
1161  return 1;
1162 }
1163 
1164 #if HAVE_PYTHON
1165 
1166 /* A helper function to install a constructor function and visualizer
1167  in a varobj_dynamic. */
1168 
1169 static void
1170 install_visualizer (struct varobj_dynamic *var, PyObject *constructor,
1171  PyObject *visualizer)
1172 {
1173  Py_XDECREF (var->constructor);
1174  var->constructor = constructor;
1175 
1176  Py_XDECREF (var->pretty_printer);
1177  var->pretty_printer = visualizer;
1178 
1180  var->child_iter = NULL;
1181 }
1182 
1183 /* Install the default visualizer for VAR. */
1184 
1185 static void
1187 {
1188  /* Do not install a visualizer on a CPLUS_FAKE_CHILD. */
1189  if (CPLUS_FAKE_CHILD (var))
1190  return;
1191 
1192  if (pretty_printing)
1193  {
1194  PyObject *pretty_printer = NULL;
1195 
1196  if (var->value)
1197  {
1198  pretty_printer = gdbpy_get_varobj_pretty_printer (var->value);
1199  if (! pretty_printer)
1200  {
1201  gdbpy_print_stack ();
1202  error (_("Cannot instantiate printer for default visualizer"));
1203  }
1204  }
1205 
1206  if (pretty_printer == Py_None)
1207  {
1208  Py_DECREF (pretty_printer);
1209  pretty_printer = NULL;
1210  }
1211 
1212  install_visualizer (var->dynamic, NULL, pretty_printer);
1213  }
1214 }
1215 
1216 /* Instantiate and install a visualizer for VAR using CONSTRUCTOR to
1217  make a new object. */
1218 
1219 static void
1220 construct_visualizer (struct varobj *var, PyObject *constructor)
1221 {
1222  PyObject *pretty_printer;
1223 
1224  /* Do not install a visualizer on a CPLUS_FAKE_CHILD. */
1225  if (CPLUS_FAKE_CHILD (var))
1226  return;
1227 
1228  Py_INCREF (constructor);
1229  if (constructor == Py_None)
1230  pretty_printer = NULL;
1231  else
1232  {
1233  pretty_printer = instantiate_pretty_printer (constructor, var->value);
1234  if (! pretty_printer)
1235  {
1236  gdbpy_print_stack ();
1237  Py_DECREF (constructor);
1238  constructor = Py_None;
1239  Py_INCREF (constructor);
1240  }
1241 
1242  if (pretty_printer == Py_None)
1243  {
1244  Py_DECREF (pretty_printer);
1245  pretty_printer = NULL;
1246  }
1247  }
1248 
1249  install_visualizer (var->dynamic, constructor, pretty_printer);
1250 }
1251 
1252 #endif /* HAVE_PYTHON */
1253 
1254 /* A helper function for install_new_value. This creates and installs
1255  a visualizer for VAR, if appropriate. */
1256 
1257 static void
1259 {
1260 #if HAVE_PYTHON
1261  /* If the constructor is None, then we want the raw value. If VAR
1262  does not have a value, just skip this. */
1264  return;
1265 
1266  if (var->dynamic->constructor != Py_None && var->value != NULL)
1267  {
1268  struct cleanup *cleanup;
1269 
1270  cleanup = varobj_ensure_python_env (var);
1271 
1272  if (var->dynamic->constructor == NULL)
1274  else
1276 
1277  do_cleanups (cleanup);
1278  }
1279 #else
1280  /* Do nothing. */
1281 #endif
1282 }
1283 
1284 /* When using RTTI to determine variable type it may be changed in runtime when
1285  the variable value is changed. This function checks whether type of varobj
1286  VAR will change when a new value NEW_VALUE is assigned and if it is so
1287  updates the type of VAR. */
1288 
1289 static int
1290 update_type_if_necessary (struct varobj *var, struct value *new_value)
1291 {
1292  if (new_value)
1293  {
1294  struct value_print_options opts;
1295 
1296  get_user_print_options (&opts);
1297  if (opts.objectprint)
1298  {
1299  struct type *new_type;
1300  char *curr_type_str, *new_type_str;
1301  int type_name_changed;
1302 
1303  new_type = value_actual_type (new_value, 0, 0);
1304  new_type_str = type_to_string (new_type);
1305  curr_type_str = varobj_get_type (var);
1306  type_name_changed = strcmp (curr_type_str, new_type_str) != 0;
1307  xfree (curr_type_str);
1308  xfree (new_type_str);
1309 
1310  if (type_name_changed)
1311  {
1312  var->type = new_type;
1313 
1314  /* This information may be not valid for a new type. */
1315  varobj_delete (var, NULL, 1);
1316  VEC_free (varobj_p, var->children);
1317  var->num_children = -1;
1318  return 1;
1319  }
1320  }
1321  }
1322 
1323  return 0;
1324 }
1325 
1326 /* Assign a new value to a variable object. If INITIAL is non-zero,
1327  this is the first assignement after the variable object was just
1328  created, or changed type. In that case, just assign the value
1329  and return 0.
1330  Otherwise, assign the new value, and return 1 if the value is
1331  different from the current one, 0 otherwise. The comparison is
1332  done on textual representation of value. Therefore, some types
1333  need not be compared. E.g. for structures the reported value is
1334  always "{...}", so no comparison is necessary here. If the old
1335  value was NULL and new one is not, or vice versa, we always return 1.
1336 
1337  The VALUE parameter should not be released -- the function will
1338  take care of releasing it when needed. */
1339 static int
1340 install_new_value (struct varobj *var, struct value *value, int initial)
1341 {
1342  int changeable;
1343  int need_to_fetch;
1344  int changed = 0;
1345  int intentionally_not_fetched = 0;
1346  char *print_value = NULL;
1347 
1348  /* We need to know the varobj's type to decide if the value should
1349  be fetched or not. C++ fake children (public/protected/private)
1350  don't have a type. */
1351  gdb_assert (var->type || CPLUS_FAKE_CHILD (var));
1352  changeable = varobj_value_is_changeable_p (var);
1353 
1354  /* If the type has custom visualizer, we consider it to be always
1355  changeable. FIXME: need to make sure this behaviour will not
1356  mess up read-sensitive values. */
1357  if (var->dynamic->pretty_printer != NULL)
1358  changeable = 1;
1359 
1360  need_to_fetch = changeable;
1361 
1362  /* We are not interested in the address of references, and given
1363  that in C++ a reference is not rebindable, it cannot
1364  meaningfully change. So, get hold of the real value. */
1365  if (value)
1366  value = coerce_ref (value);
1367 
1368  if (var->type && TYPE_CODE (var->type) == TYPE_CODE_UNION)
1369  /* For unions, we need to fetch the value implicitly because
1370  of implementation of union member fetch. When gdb
1371  creates a value for a field and the value of the enclosing
1372  structure is not lazy, it immediately copies the necessary
1373  bytes from the enclosing values. If the enclosing value is
1374  lazy, the call to value_fetch_lazy on the field will read
1375  the data from memory. For unions, that means we'll read the
1376  same memory more than once, which is not desirable. So
1377  fetch now. */
1378  need_to_fetch = 1;
1379 
1380  /* The new value might be lazy. If the type is changeable,
1381  that is we'll be comparing values of this type, fetch the
1382  value now. Otherwise, on the next update the old value
1383  will be lazy, which means we've lost that old value. */
1384  if (need_to_fetch && value && value_lazy (value))
1385  {
1386  const struct varobj *parent = var->parent;
1387  int frozen = var->frozen;
1388 
1389  for (; !frozen && parent; parent = parent->parent)
1390  frozen |= parent->frozen;
1391 
1392  if (frozen && initial)
1393  {
1394  /* For variables that are frozen, or are children of frozen
1395  variables, we don't do fetch on initial assignment.
1396  For non-initial assignemnt we do the fetch, since it means we're
1397  explicitly asked to compare the new value with the old one. */
1398  intentionally_not_fetched = 1;
1399  }
1400  else
1401  {
1402 
1403  TRY
1404  {
1405  value_fetch_lazy (value);
1406  }
1407 
1408  CATCH (except, RETURN_MASK_ERROR)
1409  {
1410  /* Set the value to NULL, so that for the next -var-update,
1411  we don't try to compare the new value with this value,
1412  that we couldn't even read. */
1413  value = NULL;
1414  }
1415  END_CATCH
1416  }
1417  }
1418 
1419  /* Get a reference now, before possibly passing it to any Python
1420  code that might release it. */
1421  if (value != NULL)
1422  value_incref (value);
1423 
1424  /* Below, we'll be comparing string rendering of old and new
1425  values. Don't get string rendering if the value is
1426  lazy -- if it is, the code above has decided that the value
1427  should not be fetched. */
1428  if (value != NULL && !value_lazy (value)
1429  && var->dynamic->pretty_printer == NULL)
1430  print_value = varobj_value_get_print_value (value, var->format, var);
1431 
1432  /* If the type is changeable, compare the old and the new values.
1433  If this is the initial assignment, we don't have any old value
1434  to compare with. */
1435  if (!initial && changeable)
1436  {
1437  /* If the value of the varobj was changed by -var-set-value,
1438  then the value in the varobj and in the target is the same.
1439  However, that value is different from the value that the
1440  varobj had after the previous -var-update. So need to the
1441  varobj as changed. */
1442  if (var->updated)
1443  {
1444  changed = 1;
1445  }
1446  else if (var->dynamic->pretty_printer == NULL)
1447  {
1448  /* Try to compare the values. That requires that both
1449  values are non-lazy. */
1450  if (var->not_fetched && value_lazy (var->value))
1451  {
1452  /* This is a frozen varobj and the value was never read.
1453  Presumably, UI shows some "never read" indicator.
1454  Now that we've fetched the real value, we need to report
1455  this varobj as changed so that UI can show the real
1456  value. */
1457  changed = 1;
1458  }
1459  else if (var->value == NULL && value == NULL)
1460  /* Equal. */
1461  ;
1462  else if (var->value == NULL || value == NULL)
1463  {
1464  changed = 1;
1465  }
1466  else
1467  {
1468  gdb_assert (!value_lazy (var->value));
1469  gdb_assert (!value_lazy (value));
1470 
1471  gdb_assert (var->print_value != NULL && print_value != NULL);
1472  if (strcmp (var->print_value, print_value) != 0)
1473  changed = 1;
1474  }
1475  }
1476  }
1477 
1478  if (!initial && !changeable)
1479  {
1480  /* For values that are not changeable, we don't compare the values.
1481  However, we want to notice if a value was not NULL and now is NULL,
1482  or vise versa, so that we report when top-level varobjs come in scope
1483  and leave the scope. */
1484  changed = (var->value != NULL) != (value != NULL);
1485  }
1486 
1487  /* We must always keep the new value, since children depend on it. */
1488  if (var->value != NULL && var->value != value)
1489  value_free (var->value);
1490  var->value = value;
1491  if (value && value_lazy (value) && intentionally_not_fetched)
1492  var->not_fetched = 1;
1493  else
1494  var->not_fetched = 0;
1495  var->updated = 0;
1496 
1498 
1499  /* If we installed a pretty-printer, re-compare the printed version
1500  to see if the variable changed. */
1501  if (var->dynamic->pretty_printer != NULL)
1502  {
1503  xfree (print_value);
1504  print_value = varobj_value_get_print_value (var->value, var->format,
1505  var);
1506  if ((var->print_value == NULL && print_value != NULL)
1507  || (var->print_value != NULL && print_value == NULL)
1508  || (var->print_value != NULL && print_value != NULL
1509  && strcmp (var->print_value, print_value) != 0))
1510  changed = 1;
1511  }
1512  if (var->print_value)
1513  xfree (var->print_value);
1514  var->print_value = print_value;
1515 
1516  gdb_assert (!var->value || value_type (var->value));
1517 
1518  return changed;
1519 }
1520 
1521 /* Return the requested range for a varobj. VAR is the varobj. FROM
1522  and TO are out parameters; *FROM and *TO will be set to the
1523  selected sub-range of VAR. If no range was selected using
1524  -var-set-update-range, then both will be -1. */
1525 void
1526 varobj_get_child_range (const struct varobj *var, int *from, int *to)
1527 {
1528  *from = var->from;
1529  *to = var->to;
1530 }
1531 
1532 /* Set the selected sub-range of children of VAR to start at index
1533  FROM and end at index TO. If either FROM or TO is less than zero,
1534  this is interpreted as a request for all children. */
1535 void
1536 varobj_set_child_range (struct varobj *var, int from, int to)
1537 {
1538  var->from = from;
1539  var->to = to;
1540 }
1541 
1542 void
1543 varobj_set_visualizer (struct varobj *var, const char *visualizer)
1544 {
1545 #if HAVE_PYTHON
1546  PyObject *mainmod, *globals, *constructor;
1547  struct cleanup *back_to;
1548 
1550  return;
1551 
1552  back_to = varobj_ensure_python_env (var);
1553 
1554  mainmod = PyImport_AddModule ("__main__");
1555  globals = PyModule_GetDict (mainmod);
1556  Py_INCREF (globals);
1557  make_cleanup_py_decref (globals);
1558 
1559  constructor = PyRun_String (visualizer, Py_eval_input, globals, globals);
1560 
1561  if (! constructor)
1562  {
1563  gdbpy_print_stack ();
1564  error (_("Could not evaluate visualizer expression: %s"), visualizer);
1565  }
1566 
1567  construct_visualizer (var, constructor);
1568  Py_XDECREF (constructor);
1569 
1570  /* If there are any children now, wipe them. */
1571  varobj_delete (var, NULL, 1 /* children only */);
1572  var->num_children = -1;
1573 
1574  do_cleanups (back_to);
1575 #else
1576  error (_("Python support required"));
1577 #endif
1578 }
1579 
1580 /* If NEW_VALUE is the new value of the given varobj (var), return
1581  non-zero if var has mutated. In other words, if the type of
1582  the new value is different from the type of the varobj's old
1583  value.
1584 
1585  NEW_VALUE may be NULL, if the varobj is now out of scope. */
1586 
1587 static int
1588 varobj_value_has_mutated (const struct varobj *var, struct value *new_value,
1589  struct type *new_type)
1590 {
1591  /* If we haven't previously computed the number of children in var,
1592  it does not matter from the front-end's perspective whether
1593  the type has mutated or not. For all intents and purposes,
1594  it has not mutated. */
1595  if (var->num_children < 0)
1596  return 0;
1597 
1598  if (var->root->lang_ops->value_has_mutated)
1599  {
1600  /* The varobj module, when installing new values, explicitly strips
1601  references, saying that we're not interested in those addresses.
1602  But detection of mutation happens before installing the new
1603  value, so our value may be a reference that we need to strip
1604  in order to remain consistent. */
1605  if (new_value != NULL)
1606  new_value = coerce_ref (new_value);
1607  return var->root->lang_ops->value_has_mutated (var, new_value, new_type);
1608  }
1609  else
1610  return 0;
1611 }
1612 
1613 /* Update the values for a variable and its children. This is a
1614  two-pronged attack. First, re-parse the value for the root's
1615  expression to see if it's changed. Then go all the way
1616  through its children, reconstructing them and noting if they've
1617  changed.
1618 
1619  The EXPLICIT parameter specifies if this call is result
1620  of MI request to update this specific variable, or
1621  result of implicit -var-update *. For implicit request, we don't
1622  update frozen variables.
1623 
1624  NOTE: This function may delete the caller's varobj. If it
1625  returns TYPE_CHANGED, then it has done this and VARP will be modified
1626  to point to the new varobj. */
1627 
1629 varobj_update (struct varobj **varp, int is_explicit)
1630 {
1631  int type_changed = 0;
1632  int i;
1633  struct value *newobj;
1634  VEC (varobj_update_result) *stack = NULL;
1635  VEC (varobj_update_result) *result = NULL;
1636 
1637  /* Frozen means frozen -- we don't check for any change in
1638  this varobj, including its going out of scope, or
1639  changing type. One use case for frozen varobjs is
1640  retaining previously evaluated expressions, and we don't
1641  want them to be reevaluated at all. */
1642  if (!is_explicit && (*varp)->frozen)
1643  return result;
1644 
1645  if (!(*varp)->root->is_valid)
1646  {
1647  varobj_update_result r = {0};
1648 
1649  r.varobj = *varp;
1650  r.status = VAROBJ_INVALID;
1651  VEC_safe_push (varobj_update_result, result, &r);
1652  return result;
1653  }
1654 
1655  if ((*varp)->root->rootvar == *varp)
1656  {
1657  varobj_update_result r = {0};
1658 
1659  r.varobj = *varp;
1660  r.status = VAROBJ_IN_SCOPE;
1661 
1662  /* Update the root variable. value_of_root can return NULL
1663  if the variable is no longer around, i.e. we stepped out of
1664  the frame in which a local existed. We are letting the
1665  value_of_root variable dispose of the varobj if the type
1666  has changed. */
1667  newobj = value_of_root (varp, &type_changed);
1668  if (update_type_if_necessary(*varp, newobj))
1669  type_changed = 1;
1670  r.varobj = *varp;
1671  r.type_changed = type_changed;
1672  if (install_new_value ((*varp), newobj, type_changed))
1673  r.changed = 1;
1674 
1675  if (newobj == NULL)
1677  r.value_installed = 1;
1678 
1679  if (r.status == VAROBJ_NOT_IN_SCOPE)
1680  {
1681  if (r.type_changed || r.changed)
1682  VEC_safe_push (varobj_update_result, result, &r);
1683  return result;
1684  }
1685 
1687  }
1688  else
1689  {
1690  varobj_update_result r = {0};
1691 
1692  r.varobj = *varp;
1694  }
1695 
1696  /* Walk through the children, reconstructing them all. */
1698  {
1700  struct varobj *v = r.varobj;
1701 
1702  VEC_pop (varobj_update_result, stack);
1703 
1704  /* Update this variable, unless it's a root, which is already
1705  updated. */
1706  if (!r.value_installed)
1707  {
1708  struct type *new_type;
1709 
1710  newobj = value_of_child (v->parent, v->index);
1711  if (update_type_if_necessary(v, newobj))
1712  r.type_changed = 1;
1713  if (newobj)
1714  new_type = value_type (newobj);
1715  else
1716  new_type = v->root->lang_ops->type_of_child (v->parent, v->index);
1717 
1718  if (varobj_value_has_mutated (v, newobj, new_type))
1719  {
1720  /* The children are no longer valid; delete them now.
1721  Report the fact that its type changed as well. */
1722  varobj_delete (v, NULL, 1 /* only_children */);
1723  v->num_children = -1;
1724  v->to = -1;
1725  v->from = -1;
1726  v->type = new_type;
1727  r.type_changed = 1;
1728  }
1729 
1730  if (install_new_value (v, newobj, r.type_changed))
1731  {
1732  r.changed = 1;
1733  v->updated = 0;
1734  }
1735  }
1736 
1737  /* We probably should not get children of a dynamic varobj, but
1738  for which -var-list-children was never invoked. */
1739  if (varobj_is_dynamic_p (v))
1740  {
1741  VEC (varobj_p) *changed = 0, *type_changed = 0, *unchanged = 0;
1742  VEC (varobj_p) *newobj = 0;
1743  int i, children_changed = 0;
1744 
1745  if (v->frozen)
1746  continue;
1747 
1748  if (!v->dynamic->children_requested)
1749  {
1750  int dummy;
1751 
1752  /* If we initially did not have potential children, but
1753  now we do, consider the varobj as changed.
1754  Otherwise, if children were never requested, consider
1755  it as unchanged -- presumably, such varobj is not yet
1756  expanded in the UI, so we need not bother getting
1757  it. */
1758  if (!varobj_has_more (v, 0))
1759  {
1760  update_dynamic_varobj_children (v, NULL, NULL, NULL, NULL,
1761  &dummy, 0, 0, 0);
1762  if (varobj_has_more (v, 0))
1763  r.changed = 1;
1764  }
1765 
1766  if (r.changed)
1767  VEC_safe_push (varobj_update_result, result, &r);
1768 
1769  continue;
1770  }
1771 
1772  /* If update_dynamic_varobj_children returns 0, then we have
1773  a non-conforming pretty-printer, so we skip it. */
1774  if (update_dynamic_varobj_children (v, &changed, &type_changed, &newobj,
1775  &unchanged, &children_changed, 1,
1776  v->from, v->to))
1777  {
1778  if (children_changed || newobj)
1779  {
1780  r.children_changed = 1;
1781  r.newobj = newobj;
1782  }
1783  /* Push in reverse order so that the first child is
1784  popped from the work stack first, and so will be
1785  added to result first. This does not affect
1786  correctness, just "nicer". */
1787  for (i = VEC_length (varobj_p, type_changed) - 1; i >= 0; --i)
1788  {
1789  varobj_p tmp = VEC_index (varobj_p, type_changed, i);
1790  varobj_update_result r = {0};
1791 
1792  /* Type may change only if value was changed. */
1793  r.varobj = tmp;
1794  r.changed = 1;
1795  r.type_changed = 1;
1796  r.value_installed = 1;
1797  VEC_safe_push (varobj_update_result, stack, &r);
1798  }
1799  for (i = VEC_length (varobj_p, changed) - 1; i >= 0; --i)
1800  {
1801  varobj_p tmp = VEC_index (varobj_p, changed, i);
1802  varobj_update_result r = {0};
1803 
1804  r.varobj = tmp;
1805  r.changed = 1;
1806  r.value_installed = 1;
1807  VEC_safe_push (varobj_update_result, stack, &r);
1808  }
1809  for (i = VEC_length (varobj_p, unchanged) - 1; i >= 0; --i)
1810  {
1811  varobj_p tmp = VEC_index (varobj_p, unchanged, i);
1812 
1813  if (!tmp->frozen)
1814  {
1815  varobj_update_result r = {0};
1816 
1817  r.varobj = tmp;
1818  r.value_installed = 1;
1819  VEC_safe_push (varobj_update_result, stack, &r);
1820  }
1821  }
1822  if (r.changed || r.children_changed)
1823  VEC_safe_push (varobj_update_result, result, &r);
1824 
1825  /* Free CHANGED, TYPE_CHANGED and UNCHANGED, but not NEW,
1826  because NEW has been put into the result vector. */
1827  VEC_free (varobj_p, changed);
1828  VEC_free (varobj_p, type_changed);
1829  VEC_free (varobj_p, unchanged);
1830 
1831  continue;
1832  }
1833  }
1834 
1835  /* Push any children. Use reverse order so that the first
1836  child is popped from the work stack first, and so
1837  will be added to result first. This does not
1838  affect correctness, just "nicer". */
1839  for (i = VEC_length (varobj_p, v->children)-1; i >= 0; --i)
1840  {
1841  varobj_p c = VEC_index (varobj_p, v->children, i);
1842 
1843  /* Child may be NULL if explicitly deleted by -var-delete. */
1844  if (c != NULL && !c->frozen)
1845  {
1846  varobj_update_result r = {0};
1847 
1848  r.varobj = c;
1849  VEC_safe_push (varobj_update_result, stack, &r);
1850  }
1851  }
1852 
1853  if (r.changed || r.type_changed)
1854  VEC_safe_push (varobj_update_result, result, &r);
1855  }
1856 
1857  VEC_free (varobj_update_result, stack);
1858 
1859  return result;
1860 }
1861 
1862 
1863 /* Helper functions */
1864 
1865 /*
1866  * Variable object construction/destruction
1867  */
1868 
1869 static int
1870 delete_variable (struct cpstack **resultp, struct varobj *var,
1871  int only_children_p)
1872 {
1873  int delcount = 0;
1874 
1875  delete_variable_1 (resultp, &delcount, var,
1876  only_children_p, 1 /* remove_from_parent_p */ );
1877 
1878  return delcount;
1879 }
1880 
1881 /* Delete the variable object VAR and its children. */
1882 /* IMPORTANT NOTE: If we delete a variable which is a child
1883  and the parent is not removed we dump core. It must be always
1884  initially called with remove_from_parent_p set. */
1885 static void
1886 delete_variable_1 (struct cpstack **resultp, int *delcountp,
1887  struct varobj *var, int only_children_p,
1888  int remove_from_parent_p)
1889 {
1890  int i;
1891 
1892  /* Delete any children of this variable, too. */
1893  for (i = 0; i < VEC_length (varobj_p, var->children); ++i)
1894  {
1895  varobj_p child = VEC_index (varobj_p, var->children, i);
1896 
1897  if (!child)
1898  continue;
1899  if (!remove_from_parent_p)
1900  child->parent = NULL;
1901  delete_variable_1 (resultp, delcountp, child, 0, only_children_p);
1902  }
1903  VEC_free (varobj_p, var->children);
1904 
1905  /* if we were called to delete only the children we are done here. */
1906  if (only_children_p)
1907  return;
1908 
1909  /* Otherwise, add it to the list of deleted ones and proceed to do so. */
1910  /* If the name is null, this is a temporary variable, that has not
1911  yet been installed, don't report it, it belongs to the caller... */
1912  if (var->obj_name != NULL)
1913  {
1914  cppush (resultp, xstrdup (var->obj_name));
1915  *delcountp = *delcountp + 1;
1916  }
1917 
1918  /* If this variable has a parent, remove it from its parent's list. */
1919  /* OPTIMIZATION: if the parent of this variable is also being deleted,
1920  (as indicated by remove_from_parent_p) we don't bother doing an
1921  expensive list search to find the element to remove when we are
1922  discarding the list afterwards. */
1923  if ((remove_from_parent_p) && (var->parent != NULL))
1924  {
1925  VEC_replace (varobj_p, var->parent->children, var->index, NULL);
1926  }
1927 
1928  if (var->obj_name != NULL)
1929  uninstall_variable (var);
1930 
1931  /* Free memory associated with this variable. */
1932  free_variable (var);
1933 }
1934 
1935 /* Install the given variable VAR with the object name VAR->OBJ_NAME. */
1936 static int
1938 {
1939  struct vlist *cv;
1940  struct vlist *newvl;
1941  const char *chp;
1942  unsigned int index = 0;
1943  unsigned int i = 1;
1944 
1945  for (chp = var->obj_name; *chp; chp++)
1946  {
1947  index = (index + (i++ * (unsigned int) *chp)) % VAROBJ_TABLE_SIZE;
1948  }
1949 
1950  cv = *(varobj_table + index);
1951  while ((cv != NULL) && (strcmp (cv->var->obj_name, var->obj_name) != 0))
1952  cv = cv->next;
1953 
1954  if (cv != NULL)
1955  error (_("Duplicate variable object name"));
1956 
1957  /* Add varobj to hash table. */
1958  newvl = xmalloc (sizeof (struct vlist));
1959  newvl->next = *(varobj_table + index);
1960  newvl->var = var;
1961  *(varobj_table + index) = newvl;
1962 
1963  /* If root, add varobj to root list. */
1964  if (is_root_p (var))
1965  {
1966  /* Add to list of root variables. */
1967  if (rootlist == NULL)
1968  var->root->next = NULL;
1969  else
1970  var->root->next = rootlist;
1971  rootlist = var->root;
1972  }
1973 
1974  return 1; /* OK */
1975 }
1976 
1977 /* Unistall the object VAR. */
1978 static void
1980 {
1981  struct vlist *cv;
1982  struct vlist *prev;
1983  struct varobj_root *cr;
1984  struct varobj_root *prer;
1985  const char *chp;
1986  unsigned int index = 0;
1987  unsigned int i = 1;
1988 
1989  /* Remove varobj from hash table. */
1990  for (chp = var->obj_name; *chp; chp++)
1991  {
1992  index = (index + (i++ * (unsigned int) *chp)) % VAROBJ_TABLE_SIZE;
1993  }
1994 
1995  cv = *(varobj_table + index);
1996  prev = NULL;
1997  while ((cv != NULL) && (strcmp (cv->var->obj_name, var->obj_name) != 0))
1998  {
1999  prev = cv;
2000  cv = cv->next;
2001  }
2002 
2003  if (varobjdebug)
2004  fprintf_unfiltered (gdb_stdlog, "Deleting %s\n", var->obj_name);
2005 
2006  if (cv == NULL)
2007  {
2008  warning
2009  ("Assertion failed: Could not find variable object \"%s\" to delete",
2010  var->obj_name);
2011  return;
2012  }
2013 
2014  if (prev == NULL)
2015  *(varobj_table + index) = cv->next;
2016  else
2017  prev->next = cv->next;
2018 
2019  xfree (cv);
2020 
2021  /* If root, remove varobj from root list. */
2022  if (is_root_p (var))
2023  {
2024  /* Remove from list of root variables. */
2025  if (rootlist == var->root)
2026  rootlist = var->root->next;
2027  else
2028  {
2029  prer = NULL;
2030  cr = rootlist;
2031  while ((cr != NULL) && (cr->rootvar != var))
2032  {
2033  prer = cr;
2034  cr = cr->next;
2035  }
2036  if (cr == NULL)
2037  {
2038  warning (_("Assertion failed: Could not find "
2039  "varobj \"%s\" in root list"),
2040  var->obj_name);
2041  return;
2042  }
2043  if (prer == NULL)
2044  rootlist = NULL;
2045  else
2046  prer->next = cr->next;
2047  }
2048  }
2049 
2050 }
2051 
2052 /* Create and install a child of the parent of the given name.
2053 
2054  The created VAROBJ takes ownership of the allocated NAME. */
2055 
2056 static struct varobj *
2057 create_child (struct varobj *parent, int index, char *name)
2058 {
2059  struct varobj_item item;
2060 
2061  item.name = name;
2062  item.value = value_of_child (parent, index);
2063 
2064  return create_child_with_value (parent, index, &item);
2065 }
2066 
2067 static struct varobj *
2069  struct varobj_item *item)
2070 {
2071  struct varobj *child;
2072  char *childs_name;
2073 
2074  child = new_variable ();
2075 
2076  /* NAME is allocated by caller. */
2077  child->name = item->name;
2078  child->index = index;
2079  child->parent = parent;
2080  child->root = parent->root;
2081 
2082  if (varobj_is_anonymous_child (child))
2083  childs_name = xstrprintf ("%s.%d_anonymous", parent->obj_name, index);
2084  else
2085  childs_name = xstrprintf ("%s.%s", parent->obj_name, item->name);
2086  child->obj_name = childs_name;
2087 
2088  install_variable (child);
2089 
2090  /* Compute the type of the child. Must do this before
2091  calling install_new_value. */
2092  if (item->value != NULL)
2093  /* If the child had no evaluation errors, var->value
2094  will be non-NULL and contain a valid type. */
2095  child->type = value_actual_type (item->value, 0, NULL);
2096  else
2097  /* Otherwise, we must compute the type. */
2098  child->type = (*child->root->lang_ops->type_of_child) (child->parent,
2099  child->index);
2100  install_new_value (child, item->value, 1);
2101 
2102  return child;
2103 }
2104 
2105 
2106 /*
2107  * Miscellaneous utility functions.
2108  */
2109 
2110 /* Allocate memory and initialize a new variable. */
2111 static struct varobj *
2113 {
2114  struct varobj *var;
2115 
2116  var = (struct varobj *) xmalloc (sizeof (struct varobj));
2117  var->name = NULL;
2118  var->path_expr = NULL;
2119  var->obj_name = NULL;
2120  var->index = -1;
2121  var->type = NULL;
2122  var->value = NULL;
2123  var->num_children = -1;
2124  var->parent = NULL;
2125  var->children = NULL;
2126  var->format = 0;
2127  var->root = NULL;
2128  var->updated = 0;
2129  var->print_value = NULL;
2130  var->frozen = 0;
2131  var->not_fetched = 0;
2132  var->dynamic
2133  = (struct varobj_dynamic *) xmalloc (sizeof (struct varobj_dynamic));
2134  var->dynamic->children_requested = 0;
2135  var->from = -1;
2136  var->to = -1;
2137  var->dynamic->constructor = 0;
2138  var->dynamic->pretty_printer = 0;
2139  var->dynamic->child_iter = 0;
2140  var->dynamic->saved_item = 0;
2141 
2142  return var;
2143 }
2144 
2145 /* Allocate memory and initialize a new root variable. */
2146 static struct varobj *
2148 {
2149  struct varobj *var = new_variable ();
2150 
2151  var->root = (struct varobj_root *) xmalloc (sizeof (struct varobj_root));
2152  var->root->lang_ops = NULL;
2153  var->root->exp = NULL;
2154  var->root->valid_block = NULL;
2155  var->root->frame = null_frame_id;
2156  var->root->floating = 0;
2157  var->root->rootvar = NULL;
2158  var->root->is_valid = 1;
2159 
2160  return var;
2161 }
2162 
2163 /* Free any allocated memory associated with VAR. */
2164 static void
2165 free_variable (struct varobj *var)
2166 {
2167 #if HAVE_PYTHON
2168  if (var->dynamic->pretty_printer != NULL)
2169  {
2170  struct cleanup *cleanup = varobj_ensure_python_env (var);
2171 
2172  Py_XDECREF (var->dynamic->constructor);
2173  Py_XDECREF (var->dynamic->pretty_printer);
2174  do_cleanups (cleanup);
2175  }
2176 #endif
2177 
2180  value_free (var->value);
2181 
2182  /* Free the expression if this is a root variable. */
2183  if (is_root_p (var))
2184  {
2185  xfree (var->root->exp);
2186  xfree (var->root);
2187  }
2188 
2189  xfree (var->name);
2190  xfree (var->obj_name);
2191  xfree (var->print_value);
2192  xfree (var->path_expr);
2193  xfree (var->dynamic);
2194  xfree (var);
2195 }
2196 
2197 static void
2199 {
2200  free_variable (var);
2201 }
2202 
2203 static struct cleanup *
2205 {
2206  return make_cleanup (do_free_variable_cleanup, var);
2207 }
2208 
2209 /* Return the type of the value that's stored in VAR,
2210  or that would have being stored there if the
2211  value were accessible.
2212 
2213  This differs from VAR->type in that VAR->type is always
2214  the true type of the expession in the source language.
2215  The return value of this function is the type we're
2216  actually storing in varobj, and using for displaying
2217  the values and for comparing previous and new values.
2218 
2219  For example, top-level references are always stripped. */
2220 struct type *
2221 varobj_get_value_type (const struct varobj *var)
2222 {
2223  struct type *type;
2224 
2225  if (var->value)
2226  type = value_type (var->value);
2227  else
2228  type = var->type;
2229 
2230  type = check_typedef (type);
2231 
2232  if (TYPE_CODE (type) == TYPE_CODE_REF)
2233  type = get_target_type (type);
2234 
2235  type = check_typedef (type);
2236 
2237  return type;
2238 }
2239 
2240 /* What is the default display for this variable? We assume that
2241  everything is "natural". Any exceptions? */
2242 static enum varobj_display_formats
2244 {
2245  return FORMAT_NATURAL;
2246 }
2247 
2248 /* FIXME: The following should be generic for any pointer. */
2249 static void
2250 cppush (struct cpstack **pstack, char *name)
2251 {
2252  struct cpstack *s;
2253 
2254  s = (struct cpstack *) xmalloc (sizeof (struct cpstack));
2255  s->name = name;
2256  s->next = *pstack;
2257  *pstack = s;
2258 }
2259 
2260 /* FIXME: The following should be generic for any pointer. */
2261 static char *
2262 cppop (struct cpstack **pstack)
2263 {
2264  struct cpstack *s;
2265  char *v;
2266 
2267  if ((*pstack)->name == NULL && (*pstack)->next == NULL)
2268  return NULL;
2269 
2270  s = *pstack;
2271  v = s->name;
2272  *pstack = (*pstack)->next;
2273  xfree (s);
2274 
2275  return v;
2276 }
2277 
2278 /*
2279  * Language-dependencies
2280  */
2281 
2282 /* Common entry points */
2283 
2284 /* Return the number of children for a given variable.
2285  The result of this function is defined by the language
2286  implementation. The number of children returned by this function
2287  is the number of children that the user will see in the variable
2288  display. */
2289 static int
2290 number_of_children (const struct varobj *var)
2291 {
2292  return (*var->root->lang_ops->number_of_children) (var);
2293 }
2294 
2295 /* What is the expression for the root varobj VAR? Returns a malloc'd
2296  string. */
2297 static char *
2298 name_of_variable (const struct varobj *var)
2299 {
2300  return (*var->root->lang_ops->name_of_variable) (var);
2301 }
2302 
2303 /* What is the name of the INDEX'th child of VAR? Returns a malloc'd
2304  string. */
2305 static char *
2306 name_of_child (struct varobj *var, int index)
2307 {
2308  return (*var->root->lang_ops->name_of_child) (var, index);
2309 }
2310 
2311 /* If frame associated with VAR can be found, switch
2312  to it and return 1. Otherwise, return 0. */
2313 
2314 static int
2315 check_scope (const struct varobj *var)
2316 {
2317  struct frame_info *fi;
2318  int scope;
2319 
2320  fi = frame_find_by_id (var->root->frame);
2321  scope = fi != NULL;
2322 
2323  if (fi)
2324  {
2325  CORE_ADDR pc = get_frame_pc (fi);
2326 
2327  if (pc < BLOCK_START (var->root->valid_block) ||
2328  pc >= BLOCK_END (var->root->valid_block))
2329  scope = 0;
2330  else
2331  select_frame (fi);
2332  }
2333  return scope;
2334 }
2335 
2336 /* Helper function to value_of_root. */
2337 
2338 static struct value *
2339 value_of_root_1 (struct varobj **var_handle)
2340 {
2341  struct value *new_val = NULL;
2342  struct varobj *var = *var_handle;
2343  int within_scope = 0;
2344  struct cleanup *back_to;
2345 
2346  /* Only root variables can be updated... */
2347  if (!is_root_p (var))
2348  /* Not a root var. */
2349  return NULL;
2350 
2352 
2353  /* Determine whether the variable is still around. */
2354  if (var->root->valid_block == NULL || var->root->floating)
2355  within_scope = 1;
2356  else if (var->root->thread_id == 0)
2357  {
2358  /* The program was single-threaded when the variable object was
2359  created. Technically, it's possible that the program became
2360  multi-threaded since then, but we don't support such
2361  scenario yet. */
2362  within_scope = check_scope (var);
2363  }
2364  else
2365  {
2367  if (in_thread_list (ptid))
2368  {
2369  switch_to_thread (ptid);
2370  within_scope = check_scope (var);
2371  }
2372  }
2373 
2374  if (within_scope)
2375  {
2376 
2377  /* We need to catch errors here, because if evaluate
2378  expression fails we want to just return NULL. */
2379  TRY
2380  {
2381  new_val = evaluate_expression (var->root->exp);
2382  }
2383  CATCH (except, RETURN_MASK_ERROR)
2384  {
2385  }
2386  END_CATCH
2387  }
2388 
2389  do_cleanups (back_to);
2390 
2391  return new_val;
2392 }
2393 
2394 /* What is the ``struct value *'' of the root variable VAR?
2395  For floating variable object, evaluation can get us a value
2396  of different type from what is stored in varobj already. In
2397  that case:
2398  - *type_changed will be set to 1
2399  - old varobj will be freed, and new one will be
2400  created, with the same name.
2401  - *var_handle will be set to the new varobj
2402  Otherwise, *type_changed will be set to 0. */
2403 static struct value *
2404 value_of_root (struct varobj **var_handle, int *type_changed)
2405 {
2406  struct varobj *var;
2407 
2408  if (var_handle == NULL)
2409  return NULL;
2410 
2411  var = *var_handle;
2412 
2413  /* This should really be an exception, since this should
2414  only get called with a root variable. */
2415 
2416  if (!is_root_p (var))
2417  return NULL;
2418 
2419  if (var->root->floating)
2420  {
2421  struct varobj *tmp_var;
2422  char *old_type, *new_type;
2423 
2424  tmp_var = varobj_create (NULL, var->name, (CORE_ADDR) 0,
2426  if (tmp_var == NULL)
2427  {
2428  return NULL;
2429  }
2430  old_type = varobj_get_type (var);
2431  new_type = varobj_get_type (tmp_var);
2432  if (strcmp (old_type, new_type) == 0)
2433  {
2434  /* The expression presently stored inside var->root->exp
2435  remembers the locations of local variables relatively to
2436  the frame where the expression was created (in DWARF location
2437  button, for example). Naturally, those locations are not
2438  correct in other frames, so update the expression. */
2439 
2440  struct expression *tmp_exp = var->root->exp;
2441 
2442  var->root->exp = tmp_var->root->exp;
2443  tmp_var->root->exp = tmp_exp;
2444 
2445  varobj_delete (tmp_var, NULL, 0);
2446  *type_changed = 0;
2447  }
2448  else
2449  {
2450  tmp_var->obj_name = xstrdup (var->obj_name);
2451  tmp_var->from = var->from;
2452  tmp_var->to = var->to;
2453  varobj_delete (var, NULL, 0);
2454 
2455  install_variable (tmp_var);
2456  *var_handle = tmp_var;
2457  var = *var_handle;
2458  *type_changed = 1;
2459  }
2460  xfree (old_type);
2461  xfree (new_type);
2462  }
2463  else
2464  {
2465  *type_changed = 0;
2466  }
2467 
2468  {
2469  struct value *value;
2470 
2471  value = value_of_root_1 (var_handle);
2472  if (var->value == NULL || value == NULL)
2473  {
2474  /* For root varobj-s, a NULL value indicates a scoping issue.
2475  So, nothing to do in terms of checking for mutations. */
2476  }
2477  else if (varobj_value_has_mutated (var, value, value_type (value)))
2478  {
2479  /* The type has mutated, so the children are no longer valid.
2480  Just delete them, and tell our caller that the type has
2481  changed. */
2482  varobj_delete (var, NULL, 1 /* only_children */);
2483  var->num_children = -1;
2484  var->to = -1;
2485  var->from = -1;
2486  *type_changed = 1;
2487  }
2488  return value;
2489  }
2490 }
2491 
2492 /* What is the ``struct value *'' for the INDEX'th child of PARENT? */
2493 static struct value *
2494 value_of_child (const struct varobj *parent, int index)
2495 {
2496  struct value *value;
2497 
2498  value = (*parent->root->lang_ops->value_of_child) (parent, index);
2499 
2500  return value;
2501 }
2502 
2503 /* GDB already has a command called "value_of_variable". Sigh. */
2504 static char *
2506 {
2507  if (var->root->is_valid)
2508  {
2509  if (var->dynamic->pretty_printer != NULL)
2510  return varobj_value_get_print_value (var->value, var->format, var);
2511  return (*var->root->lang_ops->value_of_variable) (var, format);
2512  }
2513  else
2514  return NULL;
2515 }
2516 
2517 void
2519  enum varobj_display_formats format)
2520 {
2521  get_formatted_print_options (opts, format_code[(int) format]);
2522  opts->deref_ref = 0;
2523  opts->raw = 1;
2524 }
2525 
2526 char *
2528  enum varobj_display_formats format,
2529  const struct varobj *var)
2530 {
2531  struct ui_file *stb;
2532  struct cleanup *old_chain;
2533  char *thevalue = NULL;
2534  struct value_print_options opts;
2535  struct type *type = NULL;
2536  long len = 0;
2537  char *encoding = NULL;
2538  struct gdbarch *gdbarch = NULL;
2539  /* Initialize it just to avoid a GCC false warning. */
2540  CORE_ADDR str_addr = 0;
2541  int string_print = 0;
2542 
2543  if (value == NULL)
2544  return NULL;
2545 
2546  stb = mem_fileopen ();
2547  old_chain = make_cleanup_ui_file_delete (stb);
2548 
2549  gdbarch = get_type_arch (value_type (value));
2550 #if HAVE_PYTHON
2552  {
2553  PyObject *value_formatter = var->dynamic->pretty_printer;
2554 
2556 
2557  if (value_formatter)
2558  {
2559  /* First check to see if we have any children at all. If so,
2560  we simply return {...}. */
2562  {
2563  do_cleanups (old_chain);
2564  return xstrdup ("{...}");
2565  }
2566 
2567  if (PyObject_HasAttr (value_formatter, gdbpy_to_string_cst))
2568  {
2569  struct value *replacement;
2570  PyObject *output = NULL;
2571 
2572  output = apply_varobj_pretty_printer (value_formatter,
2573  &replacement,
2574  stb);
2575 
2576  /* If we have string like output ... */
2577  if (output)
2578  {
2579  make_cleanup_py_decref (output);
2580 
2581  /* If this is a lazy string, extract it. For lazy
2582  strings we always print as a string, so set
2583  string_print. */
2584  if (gdbpy_is_lazy_string (output))
2585  {
2586  gdbpy_extract_lazy_string (output, &str_addr, &type,
2587  &len, &encoding);
2588  make_cleanup (free_current_contents, &encoding);
2589  string_print = 1;
2590  }
2591  else
2592  {
2593  /* If it is a regular (non-lazy) string, extract
2594  it and copy the contents into THEVALUE. If the
2595  hint says to print it as a string, set
2596  string_print. Otherwise just return the extracted
2597  string as a value. */
2598 
2599  char *s = python_string_to_target_string (output);
2600 
2601  if (s)
2602  {
2603  char *hint;
2604 
2605  hint = gdbpy_get_display_hint (value_formatter);
2606  if (hint)
2607  {
2608  if (!strcmp (hint, "string"))
2609  string_print = 1;
2610  xfree (hint);
2611  }
2612 
2613  len = strlen (s);
2614  thevalue = xmemdup (s, len + 1, len + 1);
2615  type = builtin_type (gdbarch)->builtin_char;
2616  xfree (s);
2617 
2618  if (!string_print)
2619  {
2620  do_cleanups (old_chain);
2621  return thevalue;
2622  }
2623 
2624  make_cleanup (xfree, thevalue);
2625  }
2626  else
2627  gdbpy_print_stack ();
2628  }
2629  }
2630  /* If the printer returned a replacement value, set VALUE
2631  to REPLACEMENT. If there is not a replacement value,
2632  just use the value passed to this function. */
2633  if (replacement)
2634  value = replacement;
2635  }
2636  }
2637  }
2638 #endif
2639 
2640  varobj_formatted_print_options (&opts, format);
2641 
2642  /* If the THEVALUE has contents, it is a regular string. */
2643  if (thevalue)
2644  LA_PRINT_STRING (stb, type, (gdb_byte *) thevalue, len, encoding, 0, &opts);
2645  else if (string_print)
2646  /* Otherwise, if string_print is set, and it is not a regular
2647  string, it is a lazy string. */
2648  val_print_string (type, encoding, str_addr, len, stb, &opts);
2649  else
2650  /* All other cases. */
2651  common_val_print (value, stb, 0, &opts, current_language);
2652 
2653  thevalue = ui_file_xstrdup (stb, NULL);
2654 
2655  do_cleanups (old_chain);
2656  return thevalue;
2657 }
2658 
2659 int
2660 varobj_editable_p (const struct varobj *var)
2661 {
2662  struct type *type;
2663 
2664  if (!(var->root->is_valid && var->value && VALUE_LVAL (var->value)))
2665  return 0;
2666 
2667  type = varobj_get_value_type (var);
2668 
2669  switch (TYPE_CODE (type))
2670  {
2671  case TYPE_CODE_STRUCT:
2672  case TYPE_CODE_UNION:
2673  case TYPE_CODE_ARRAY:
2674  case TYPE_CODE_FUNC:
2675  case TYPE_CODE_METHOD:
2676  return 0;
2677  break;
2678 
2679  default:
2680  return 1;
2681  break;
2682  }
2683 }
2684 
2685 /* Call VAR's value_is_changeable_p language-specific callback. */
2686 
2687 int
2689 {
2690  return var->root->lang_ops->value_is_changeable_p (var);
2691 }
2692 
2693 /* Return 1 if that varobj is floating, that is is always evaluated in the
2694  selected frame, and not bound to thread/frame. Such variable objects
2695  are created using '@' as frame specifier to -var-create. */
2696 int
2697 varobj_floating_p (const struct varobj *var)
2698 {
2699  return var->root->floating;
2700 }
2701 
2702 /* Implement the "value_is_changeable_p" varobj callback for most
2703  languages. */
2704 
2705 int
2707 {
2708  int r;
2709  struct type *type;
2710 
2711  if (CPLUS_FAKE_CHILD (var))
2712  return 0;
2713 
2714  type = varobj_get_value_type (var);
2715 
2716  switch (TYPE_CODE (type))
2717  {
2718  case TYPE_CODE_STRUCT:
2719  case TYPE_CODE_UNION:
2720  case TYPE_CODE_ARRAY:
2721  r = 0;
2722  break;
2723 
2724  default:
2725  r = 1;
2726  }
2727 
2728  return r;
2729 }
2730 
2731 /* Iterate all the existing _root_ VAROBJs and call the FUNC callback for them
2732  with an arbitrary caller supplied DATA pointer. */
2733 
2734 void
2735 all_root_varobjs (void (*func) (struct varobj *var, void *data), void *data)
2736 {
2737  struct varobj_root *var_root, *var_root_next;
2738 
2739  /* Iterate "safely" - handle if the callee deletes its passed VAROBJ. */
2740 
2741  for (var_root = rootlist; var_root != NULL; var_root = var_root_next)
2742  {
2743  var_root_next = var_root->next;
2744 
2745  (*func) (var_root->rootvar, data);
2746  }
2747 }
2748 
2749 /* Invalidate varobj VAR if it is tied to locals and re-create it if it is
2750  defined on globals. It is a helper for varobj_invalidate.
2751 
2752  This function is called after changing the symbol file, in this case the
2753  pointers to "struct type" stored by the varobj are no longer valid. All
2754  varobj must be either re-evaluated, or marked as invalid here. */
2755 
2756 static void
2757 varobj_invalidate_iter (struct varobj *var, void *unused)
2758 {
2759  /* global and floating var must be re-evaluated. */
2760  if (var->root->floating || var->root->valid_block == NULL)
2761  {
2762  struct varobj *tmp_var;
2763 
2764  /* Try to create a varobj with same expression. If we succeed
2765  replace the old varobj, otherwise invalidate it. */
2766  tmp_var = varobj_create (NULL, var->name, (CORE_ADDR) 0,
2768  if (tmp_var != NULL)
2769  {
2770  tmp_var->obj_name = xstrdup (var->obj_name);
2771  varobj_delete (var, NULL, 0);
2772  install_variable (tmp_var);
2773  }
2774  else
2775  var->root->is_valid = 0;
2776  }
2777  else /* locals must be invalidated. */
2778  var->root->is_valid = 0;
2779 }
2780 
2781 /* Invalidate the varobjs that are tied to locals and re-create the ones that
2782  are defined on globals.
2783  Invalidated varobjs will be always printed in_scope="invalid". */
2784 
2785 void
2787 {
2789 }
2790 
2791 extern void _initialize_varobj (void);
2792 void
2794 {
2795  int sizeof_table = sizeof (struct vlist *) * VAROBJ_TABLE_SIZE;
2796 
2797  varobj_table = xmalloc (sizeof_table);
2798  memset (varobj_table, 0, sizeof_table);
2799 
2801  &varobjdebug,
2802  _("Set varobj debugging."),
2803  _("Show varobj debugging."),
2804  _("When non-zero, varobj debugging is enabled."),
2805  NULL, show_varobjdebug,
2807 }
int frame_id_p(struct frame_id l)
Definition: frame.c:576
struct frame_info * frame_find_by_id(struct frame_id id)
Definition: frame.c:733
int varobj_delete(struct varobj *var, char ***dellist, int only_children)
Definition: varobj.c:512
int varobj_get_frozen(const struct varobj *var)
Definition: varobj.c:670
#define Py_DECREF(op)
varobj_item * saved_item
Definition: varobj.c:136
union exp_element elts[1]
Definition: expression.h:85
char * gdbpy_get_display_hint(PyObject *printer)
char * name
Definition: varobj.c:141
void all_root_varobjs(void(*func)(struct varobj *var, void *data), void *data)
Definition: varobj.c:2735
int index
Definition: varobj.h:106
Definition: varobj.h:89
static struct value * value_of_root_1(struct varobj **var_handle)
Definition: varobj.c:2339
VEC(varobj_p)
Definition: varobj.c:916
struct frame_info * get_selected_frame(const char *message)
Definition: frame.c:1535
#define VEC_replace(T, V, I, O)
Definition: vec.h:302
CORE_ADDR get_frame_pc(struct frame_info *frame)
Definition: frame.c:2217
void add_setshow_zuinteger_cmd(const char *name, enum command_class theclass, unsigned int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:763
enum exp_opcode opcode
Definition: expression.h:65
char *(* value_of_variable)(const struct varobj *var, enum varobj_display_formats format)
Definition: varobj.h:193
struct frame_info * get_current_frame(void)
Definition: frame.c:1461
bfd_vma CORE_ADDR
Definition: common-types.h:41
PyObject * pretty_printer
Definition: varobj.c:125
int varobj_default_value_is_changeable_p(const struct varobj *var)
Definition: varobj.c:2706
char * varobj_gen_name(void)
Definition: varobj.c:450
int is_explicit
Definition: varobj.h:306
void xfree(void *)
Definition: common-utils.c:97
PyObject * constructor
Definition: varobj.c:121
struct frame_info * get_prev_frame(struct frame_info *this_frame)
Definition: frame.c:2122
void(* func)(char *)
if(!(yy_init))
Definition: ada-lex.c:1072
void warning(const char *fmt,...)
Definition: errors.c:26
static void install_default_visualizer(struct varobj *var)
Definition: varobj.c:1186
int varobj_is_anonymous_child(const struct varobj *child)
Definition: c-varobj.c:38
void value_incref(struct value *val)
Definition: value.c:1508
char * ui_file_xstrdup(struct ui_file *file, long *length)
Definition: ui-file.c:345
static void uninstall_variable(struct varobj *)
Definition: varobj.c:1979
void get_formatted_print_options(struct value_print_options *opts, char format)
Definition: valprint.c:146
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition: gdbtypes.c:4766
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
PyObject * gdbpy_to_string_cst
Definition: python.c:116
enum varobj_display_formats varobj_set_display_format(struct varobj *var, enum varobj_display_formats format)
Definition: varobj.c:576
char * varobj_get_formatted_value(struct varobj *var, enum varobj_display_formats format)
Definition: varobj.c:1080
void select_frame(struct frame_info *fi)
Definition: frame.c:1574
static void delete_variable_1(struct cpstack **, int *, struct varobj *, int, int)
Definition: varobj.c:1886
const struct frame_id null_frame_id
Definition: frame.c:506
const struct language_defn * language_defn
Definition: expression.h:81
void varobj_set_child_range(struct varobj *var, int from, int to)
Definition: varobj.c:1536
PyObject * apply_varobj_pretty_printer(PyObject *printer_obj, struct value **replacement, struct ui_file *stream)
const struct lang_varobj_ops * lang_ops
Definition: varobj.c:99
void switch_to_thread(ptid_t ptid)
Definition: thread.c:1185
static void install_visualizer(struct varobj_dynamic *var, PyObject *constructor, PyObject *visualizer)
Definition: varobj.c:1170
int floating
Definition: varobj.c:91
struct value * coerce_ref(struct value *arg)
Definition: value.c:3688
void value_free(struct value *val)
Definition: value.c:1518
static char * cppop(struct cpstack **pstack)
Definition: varobj.c:2262
static struct varobj * new_root_variable(void)
Definition: varobj.c:2147
const struct block * innermost_block
Definition: parse.c:69
#define CPLUS_FAKE_CHILD(x)
Definition: varobj.h:162
int(* is_path_expr_parent)(const struct varobj *var)
Definition: varobj.h:225
#define VEC_safe_push(T, V, O)
Definition: vec.h:260
struct varobj_root * next
Definition: varobj.c:105
void varobj_set_visualizer(struct varobj *var, const char *visualizer)
Definition: varobj.c:1543
char *(* path_expr_of_child)(const struct varobj *child)
Definition: varobj.h:183
void varobj_invalidate(void)
Definition: varobj.c:2786
#define _(String)
Definition: gdb_locale.h:40
char * python_string_to_target_string(PyObject *obj)
Definition: py-utils.c:171
void varobj_restrict_range(VEC(varobj_p)*children, int *from, int *to)
Definition: varobj.c:681
#define BLOCK_START(bl)
Definition: block.h:116
int not_fetched
Definition: varobj.h:149
#define END_CATCH
static int is_path_expr_parent(const struct varobj *var)
Definition: varobj.c:1005
#define VALUE_LVAL(val)
Definition: value.h:411
static int install_new_value(struct varobj *var, struct value *value, int initial)
Definition: varobj.c:1340
char *(* name_of_child)(const struct varobj *parent, int index)
Definition: varobj.h:178
static void do_free_variable_cleanup(void *var)
Definition: varobj.c:2198
static struct varobj_iter * varobj_get_iterator(struct varobj *var)
Definition: varobj.c:766
Definition: ptid.h:35
static struct type * new_type(char *)
Definition: mdebugread.c:4864
int(* value_has_mutated)(const struct varobj *var, struct value *new_value, struct type *new_type)
Definition: varobj.h:218
unsigned input_radix
Definition: valprint.c:166
static int varobj_value_has_mutated(const struct varobj *var, struct value *new_value, struct type *new_type)
Definition: varobj.c:1588
const struct varobj * parent
Definition: varobj.h:123
unsigned int varobjdebug
Definition: varobj.c:43
struct value * evaluate_expression(struct expression *exp)
Definition: eval.c:159
#define TRY
int in_thread_list(ptid_t ptid)
Definition: thread.c:482
int(* number_of_children)(const struct varobj *parent)
Definition: varobj.h:170
static PyObject * instantiate_pretty_printer(PyObject *constructor, struct value *value)
Definition: varobj.c:557
static int number_of_children(const struct varobj *)
Definition: varobj.c:2290
int varobj_get_thread_id(const struct varobj *var)
Definition: varobj.c:648
const char *const name
Definition: aarch64-tdep.c:68
int * from
Definition: varobj.h:282
struct value *(* value_of_child)(const struct varobj *parent, int index)
Definition: varobj.h:186
static void varobj_clear_saved_item(struct varobj_dynamic *var)
Definition: varobj.c:780
struct frame_id get_frame_id(struct frame_info *fi)
Definition: frame.c:473
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2217
enum varobj_scope_status status
Definition: varobj.h:68
struct varobj_iter * child_iter
Definition: varobj.c:129
ptid_t thread_id_to_pid(int)
Definition: thread.c:471
#define CATCH(EXCEPTION, MASK)
const struct language_defn * varobj_get_language(const struct varobj *var)
Definition: varobj.c:1054
struct varobj * var
Definition: varobj.c:149
static struct value * value_of_root(struct varobj **var_handle, int *)
Definition: varobj.c:2404
void print_value(struct value *val, const struct format_data *fmtp)
Definition: printcmd.c:962
void varobj_formatted_print_options(struct value_print_options *opts, enum varobj_display_formats format)
Definition: varobj.c:2518
int varobj_default_is_path_expr_parent(const struct varobj *var)
Definition: varobj.c:1016
int value_lazy(struct value *value)
Definition: value.c:1305
static enum varobj_display_formats variable_default_display(struct varobj *)
Definition: varobj.c:2243
static void install_dynamic_child(struct varobj *var, VEC(varobj_p)**changed, VEC(varobj_p)**type_changed, VEC(varobj_p)**newobj, VEC(varobj_p)**unchanged, int *cchanged, int index, struct varobj_item *item)
Definition: varobj.c:703
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2351
#define VAROBJ_TABLE_SIZE
Definition: varobj.c:224
char * varobj_get_type(struct varobj *var)
Definition: varobj.c:982
const struct block * get_frame_block(struct frame_info *frame, CORE_ADDR *addr_in_block)
Definition: blockframe.c:55
const struct lang_varobj_ops * la_varobj_ops
Definition: language.h:363
struct varobj * rootvar
Definition: varobj.c:102
struct varobj_iter * py_varobj_get_iterator(struct varobj *var, PyObject *printer)
Definition: py-varobj.c:168
#define varobj_iter_delete(ITER)
Definition: varobj-iter.h:64
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2361
static int pretty_printing
Definition: varobj.c:56
int children_requested
Definition: varobj.c:116
struct expression * parse_exp_1(const char **, CORE_ADDR pc, const struct block *, int)
Definition: parse.c:1109
#define gdb_assert_not_reached(message)
Definition: gdb_assert.h:56
void free_current_contents(void *ptr)
Definition: utils.c:476
static struct frame_info * find_frame_addr_in_frame_chain(CORE_ADDR frame_addr)
Definition: varobj.c:255
static int dynamic_varobj_has_child_method(const struct varobj *var)
Definition: varobj.c:746
#define VEC_length(T, V)
Definition: vec.h:124
char * name
Definition: varobj-iter.h:22
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
static char * name_of_child(struct varobj *, int)
Definition: varobj.c:2306
struct type * type
Definition: varobj.h:111
static void varobj_invalidate_iter(struct varobj *var, void *unused)
Definition: varobj.c:2757
Definition: gdbtypes.h:749
static struct varobj * varobj_add_child(struct varobj *var, struct varobj_item *item)
Definition: varobj.c:967
int is_valid
Definition: varobj.c:95
#define VEC_index(T, V, I)
Definition: vec.h:151
int from
Definition: varobj.h:154
char * varobj_format_string[]
Definition: varobj.c:52
struct value * parent
Definition: value.c:262
struct gdbarch * get_type_arch(const struct type *type)
Definition: gdbtypes.c:232
struct value * coerce_array(struct value *arg)
Definition: value.c:3713
int varobj_value_is_changeable_p(const struct varobj *var)
Definition: varobj.c:2688
struct value * value_assign(struct value *toval, struct value *fromval)
Definition: valops.c:993
static const char * type
Definition: language.c:103
struct cpstack * next
Definition: varobj.c:142
struct cleanup * ensure_python_env(struct gdbarch *gdbarch, const struct language_defn *language)
Definition: python.c:247
#define gdb_assert(expr)
Definition: gdb_assert.h:33
char * varobj_get_expression(const struct varobj *var)
Definition: varobj.c:500
struct value * value
Definition: varobj.h:117
unsigned dummy
Definition: go32-nat.c:1071
PyObject * value_to_value_object(struct value *val)
Definition: py-value.c:1523
#define VEC_pop(T, V)
Definition: vec.h:270
struct value * value_cast(struct type *type, struct value *arg2)
Definition: valops.c:351
int varobj_has_more(const struct varobj *var, int to)
Definition: varobj.c:635
#define BLOCK_END(bl)
Definition: block.h:117
int gdb_python_initialized
Definition: python.c:104
int gdbarch_addr_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1707
static char * my_value_of_variable(struct varobj *var, enum varobj_display_formats format)
Definition: varobj.c:2505
struct varobj_dynamic * dynamic
Definition: varobj.h:158
char * xstrprintf(const char *format,...)
Definition: common-utils.c:107
struct cmd_list_element * setdebuglist
Definition: cli-cmds.c:173
static struct varobj * create_child(struct varobj *, int, char *)
Definition: varobj.c:2057
struct varobj * varobj_create(char *objname, char *expression, CORE_ADDR frame, enum varobj_type type)
Definition: varobj.c:284
static char encoding[]
Definition: remote-mips.c:2988
void * xmalloc(YYSIZE_T)
struct ui_file * gdb_stdlog
Definition: main.c:73
struct ui_file * mem_fileopen(void)
Definition: ui-file.c:427
struct varobj_root * root
Definition: varobj.h:130
static int check_scope(const struct varobj *var)
Definition: varobj.c:2315
#define VEC_last(T, V)
Definition: vec.h:142
Definition: block.h:60
#define VEC_empty(T, V)
Definition: vec.h:132
Definition: value.c:172
CORE_ADDR get_frame_base_address(struct frame_info *fi)
Definition: frame.c:2396
struct type * get_target_type(struct type *type)
Definition: gdbtypes.c:243
static struct varobj * create_child_with_value(struct varobj *parent, int index, struct varobj_item *item)
Definition: varobj.c:2068
int thread_id
Definition: varobj.c:86
struct value * value
Definition: varobj-iter.h:25
int num_children
Definition: varobj.h:120
#define VEC_truncate(T, V, I)
Definition: vec.h:278
char *(* name_of_variable)(const struct varobj *parent)
Definition: varobj.h:174
const char const char int
Definition: command.h:229
void release_value_or_incref(struct value *val)
Definition: value.c:1633
bfd_byte gdb_byte
Definition: common-types.h:38
enum varobj_display_formats varobj_get_display_format(const struct varobj *var)
Definition: varobj.c:605
struct varobj * varobj
Definition: varobj.h:64
char * obj_name
Definition: varobj.h:103
void discard_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:213
struct type * builtin_char
Definition: gdbtypes.h:1481
void varobj_enable_pretty_printing(void)
Definition: varobj.c:59
int varobj_is_dynamic_p(const struct varobj *var)
Definition: varobj.c:1074
const struct language_defn * current_language
Definition: language.c:85
int updated
Definition: varobj.h:136
PyObject * gdbpy_children_cst
Definition: python.c:117
void _initialize_varobj(void)
Definition: varobj.c:2793
void value_fetch_lazy(struct value *val)
Definition: value.c:3793
struct cleanup * make_cleanup_ui_file_delete(struct ui_file *arg)
Definition: utils.c:237
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1240
int(* value_is_changeable_p)(const struct varobj *var)
Definition: varobj.h:204
static void cppush(struct cpstack **pstack, char *name)
Definition: varobj.c:2250
struct varobj * varobj_get_handle(char *objname)
Definition: varobj.c:466
char * path_expr
Definition: varobj.h:99
struct ui_file * gdb_stderr
Definition: main.c:72
static void free_variable(struct varobj *var)
Definition: varobj.c:2165
static struct value * value_of_child(const struct varobj *parent, int index)
Definition: varobj.c:2494
ptid_t inferior_ptid
Definition: infcmd.c:124
const struct block * valid_block
Definition: varobj.c:75
static char * name_of_variable(const struct varobj *)
Definition: varobj.c:2298
int varobj_get_num_children(struct varobj *var)
Definition: varobj.c:893
struct cleanup * make_cleanup_restore_current_thread(void)
Definition: thread.c:1354
static void install_new_value_visualizer(struct varobj *var)
Definition: varobj.c:1258
int varobj_set_value(struct varobj *var, char *expression)
Definition: varobj.c:1097
void gdbpy_print_stack(void)
Definition: python.c:1199
void get_user_print_options(struct value_print_options *opts)
Definition: valprint.c:129
char * varobj_get_value(struct varobj *var)
Definition: varobj.c:1087
static int is_root_p(const struct varobj *var)
Definition: varobj.c:233
unsigned int stack
Definition: value.c:202
char * varobj_value_get_print_value(struct value *value, enum varobj_display_formats format, const struct varobj *var)
Definition: varobj.c:2527
#define VEC_free(T, V)
Definition: vec.h:180
static int update_dynamic_varobj_children(struct varobj *var, VEC(varobj_p)**changed, VEC(varobj_p)**type_changed, VEC(varobj_p)**newobj, VEC(varobj_p)**unchanged, int *cchanged, int update_children, int from, int to)
Definition: varobj.c:791
int gdbpy_is_lazy_string(PyObject *result)
static struct cleanup * make_cleanup_free_variable(struct varobj *var)
Definition: varobj.c:2204
char * varobj_get_objname(const struct varobj *var)
Definition: varobj.c:491
struct type * varobj_get_gdb_type(const struct varobj *var)
Definition: varobj.c:996
#define varobj_iter_next(ITER)
Definition: varobj-iter.h:60
struct expression * exp
Definition: varobj.c:72
static int format_code[]
Definition: varobj.c:217
int pid_to_thread_id(ptid_t ptid)
Definition: thread.c:459
static struct vlist ** varobj_table
Definition: varobj.c:227
struct gdbarch * gdbarch
Definition: expression.h:83
struct type * value_type(const struct value *value)
Definition: value.c:1021
char * varobj_get_path_expr(const struct varobj *var)
Definition: varobj.c:1037
struct cmd_list_element * showdebuglist
Definition: cli-cmds.c:175
struct value * evaluate_type(struct expression *exp)
Definition: eval.c:170
struct type *(* type_of_child)(const struct varobj *parent, int index)
Definition: varobj.h:189
#define LA_PRINT_STRING(stream, elttype, string, length, encoding, force_ellipses, options)
Definition: language.h:496
struct vlist * next
Definition: varobj.c:150
struct type * varobj_get_value_type(const struct varobj *var)
Definition: varobj.c:2221
struct cleanup * varobj_ensure_python_env(const struct varobj *var)
Definition: varobj.c:242
char * print_value
Definition: varobj.h:139
varobj_type
Definition: varobj.h:34
static int update_type_if_necessary(struct varobj *var, struct value *new_value)
Definition: varobj.c:1290
int int * to
Definition: varobj.h:282
char * varobj_get_display_hint(const struct varobj *var)
Definition: varobj.c:611
#define HOST_CHAR_BIT
Definition: host-defs.h:40
int val_print_string(struct type *elttype, const char *encoding, CORE_ADDR addr, int len, struct ui_file *stream, const struct value_print_options *options)
Definition: valprint.c:2496
struct cleanup * make_cleanup_py_decref(PyObject *py)
Definition: py-utils.c:41
static int install_variable(struct varobj *)
Definition: varobj.c:1937
int frozen
Definition: varobj.h:144
void gdbpy_extract_lazy_string(PyObject *string, CORE_ADDR *addr, struct type **str_type, long *length, char **encoding)
void varobj_get_child_range(const struct varobj *var, int *from, int *to)
Definition: varobj.c:1526
static struct varobj * new_variable(void)
Definition: varobj.c:2112
char * type_to_string(struct type *type)
Definition: typeprint.c:370
const struct varobj * varobj_get_path_expr_parent(const struct varobj *var)
Definition: varobj.c:1024
PyObject * gdbpy_get_varobj_pretty_printer(struct value *value)
struct frame_id frame
Definition: varobj.c:79
enum varobj_display_formats format
Definition: varobj.h:133
int varobj_floating_p(const struct varobj *var)
Definition: varobj.c:2697
int has_stack_frames(void)
Definition: frame.c:1506
int varobj_get_attributes(const struct varobj *var)
Definition: varobj.c:1060
Definition: varobj.c:147
struct type * value_actual_type(struct value *value, int resolve_simple_types, int *real_type_found)
Definition: value.c:1106
void error(const char *fmt,...)
Definition: errors.c:38
char * name
Definition: varobj.h:95
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
Definition: frame.c:2535
static void construct_visualizer(struct varobj *var, PyObject *constructor)
Definition: varobj.c:1220
int varobj_editable_p(const struct varobj *var)
Definition: varobj.c:2660
static void show_varobjdebug(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: varobj.c:45
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
int to
Definition: varobj.h:155
void varobj_set_frozen(struct varobj *var, int frozen)
Definition: varobj.c:657
static struct varobj_root * rootlist
Definition: varobj.c:220
const ULONGEST const LONGEST len
Definition: target.h:309
varobj_display_formats
Definition: varobj.h:25
static int delete_variable(struct cpstack **, struct varobj *, int)
Definition: varobj.c:1870