1 /* Implementation of the GDB variable objects API.
3 Copyright (C) 1999-2013 Free Software Foundation, Inc.
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.
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.
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/>. */
19 #include "exceptions.h"
21 #include "expression.h"
28 #include "gdb_assert.h"
29 #include "gdb_string.h"
30 #include "gdb_regex.h"
34 #include "gdbthread.h"
36 #include "ada-varobj.h"
40 #include "python/python.h"
41 #include "python/python-internal.h"
46 /* The names of varobjs representing anonymous structs or unions. */
47 #define ANONYMOUS_STRUCT_NAME _("<anonymous struct>")
48 #define ANONYMOUS_UNION_NAME _("<anonymous union>")
50 /* Non-zero if we want to see trace of varobj level stuff. */
52 unsigned int varobjdebug = 0;
54 show_varobjdebug (struct ui_file *file, int from_tty,
55 struct cmd_list_element *c, const char *value)
57 fprintf_filtered (file, _("Varobj debugging is %s.\n"), value);
60 /* String representations of gdb's format codes. */
61 char *varobj_format_string[] =
62 { "natural", "binary", "decimal", "hexadecimal", "octal" };
64 /* String representations of gdb's known languages. */
65 char *varobj_language_string[] = { "C", "C++", "Java" };
67 /* True if we want to allow Python-based pretty-printing. */
68 static int pretty_printing = 0;
71 varobj_enable_pretty_printing (void)
78 /* Every root variable has one of these structures saved in its
79 varobj. Members which must be free'd are noted. */
83 /* Alloc'd expression for this parent. */
84 struct expression *exp;
86 /* Block for which this expression is valid. */
87 const struct block *valid_block;
89 /* The frame for this expression. This field is set iff valid_block is
91 struct frame_id frame;
93 /* The thread ID that this varobj_root belong to. This field
94 is only valid if valid_block is not NULL.
95 When not 0, indicates which thread 'frame' belongs to.
96 When 0, indicates that the thread list was empty when the varobj_root
100 /* If 1, the -var-update always recomputes the value in the
101 current thread and frame. Otherwise, variable object is
102 always updated in the specific scope/thread/frame. */
105 /* Flag that indicates validity: set to 0 when this varobj_root refers
106 to symbols that do not exist anymore. */
109 /* Language info for this variable and its children. */
110 struct language_specific *lang;
112 /* The varobj for this root node. */
113 struct varobj *rootvar;
115 /* Next root variable */
116 struct varobj_root *next;
119 /* Every variable in the system has a structure of this type defined
120 for it. This structure holds all information necessary to manipulate
121 a particular object variable. Members which must be freed are noted. */
125 /* Alloc'd name of the variable for this object. If this variable is a
126 child, then this name will be the child's source name.
127 (bar, not foo.bar). */
128 /* NOTE: This is the "expression". */
131 /* Alloc'd expression for this child. Can be used to create a
132 root variable corresponding to this child. */
135 /* The alloc'd name for this variable's object. This is here for
136 convenience when constructing this object's children. */
139 /* Index of this variable in its parent or -1. */
142 /* The type of this variable. This can be NULL
143 for artifial variable objects -- currently, the "accessibility"
144 variable objects in C++. */
147 /* The value of this expression or subexpression. A NULL value
148 indicates there was an error getting this value.
149 Invariant: if varobj_value_is_changeable_p (this) is non-zero,
150 the value is either NULL, or not lazy. */
153 /* The number of (immediate) children this variable has. */
156 /* If this object is a child, this points to its immediate parent. */
157 struct varobj *parent;
159 /* Children of this object. */
160 VEC (varobj_p) *children;
162 /* Whether the children of this varobj were requested. This field is
163 used to decide if dynamic varobj should recompute their children.
164 In the event that the frontend never asked for the children, we
166 int children_requested;
168 /* Description of the root variable. Points to root variable for
170 struct varobj_root *root;
172 /* The format of the output for this object. */
173 enum varobj_display_formats format;
175 /* Was this variable updated via a varobj_set_value operation. */
178 /* Last print value. */
181 /* Is this variable frozen. Frozen variables are never implicitly
182 updated by -var-update *
183 or -var-update <direct-or-indirect-parent>. */
186 /* Is the value of this variable intentionally not fetched? It is
187 not fetched if either the variable is frozen, or any parents is
191 /* Sub-range of children which the MI consumer has requested. If
192 FROM < 0 or TO < 0, means that all children have been
197 /* The pretty-printer constructor. If NULL, then the default
198 pretty-printer will be looked up. If None, then no
199 pretty-printer will be installed. */
200 PyObject *constructor;
202 /* The pretty-printer that has been constructed. If NULL, then a
203 new printer object is needed, and one will be constructed. */
204 PyObject *pretty_printer;
206 /* The iterator returned by the printer's 'children' method, or NULL
208 PyObject *child_iter;
210 /* We request one extra item from the iterator, so that we can
211 report to the caller whether there are more items than we have
212 already reported. However, we don't want to install this value
213 when we read it, because that will mess up future updates. So,
214 we stash it here instead. */
215 PyObject *saved_item;
221 struct cpstack *next;
224 /* A list of varobjs */
232 /* Private function prototypes */
234 /* Helper functions for the above subcommands. */
236 static int delete_variable (struct cpstack **, struct varobj *, int);
238 static void delete_variable_1 (struct cpstack **, int *,
239 struct varobj *, int, int);
241 static int install_variable (struct varobj *);
243 static void uninstall_variable (struct varobj *);
245 static struct varobj *create_child (struct varobj *, int, char *);
247 static struct varobj *
248 create_child_with_value (struct varobj *parent, int index, const char *name,
249 struct value *value);
251 /* Utility routines */
253 static struct varobj *new_variable (void);
255 static struct varobj *new_root_variable (void);
257 static void free_variable (struct varobj *var);
259 static struct cleanup *make_cleanup_free_variable (struct varobj *var);
261 static struct type *get_type (struct varobj *var);
263 static struct type *get_value_type (struct varobj *var);
265 static struct type *get_target_type (struct type *);
267 static enum varobj_display_formats variable_default_display (struct varobj *);
269 static void cppush (struct cpstack **pstack, char *name);
271 static char *cppop (struct cpstack **pstack);
273 static int update_type_if_necessary (struct varobj *var,
274 struct value *new_value);
276 static int install_new_value (struct varobj *var, struct value *value,
279 /* Language-specific routines. */
281 static enum varobj_languages variable_language (struct varobj *var);
283 static int number_of_children (struct varobj *);
285 static char *name_of_variable (struct varobj *);
287 static char *name_of_child (struct varobj *, int);
289 static struct value *value_of_root (struct varobj **var_handle, int *);
291 static struct value *value_of_child (struct varobj *parent, int index);
293 static char *my_value_of_variable (struct varobj *var,
294 enum varobj_display_formats format);
296 static char *value_get_print_value (struct value *value,
297 enum varobj_display_formats format,
300 static int varobj_value_is_changeable_p (struct varobj *var);
302 static int is_root_p (struct varobj *var);
306 static struct varobj *varobj_add_child (struct varobj *var,
308 struct value *value);
310 #endif /* HAVE_PYTHON */
312 static int default_value_is_changeable_p (struct varobj *var);
314 /* C implementation */
316 static int c_number_of_children (struct varobj *var);
318 static char *c_name_of_variable (struct varobj *parent);
320 static char *c_name_of_child (struct varobj *parent, int index);
322 static char *c_path_expr_of_child (struct varobj *child);
324 static struct value *c_value_of_root (struct varobj **var_handle);
326 static struct value *c_value_of_child (struct varobj *parent, int index);
328 static struct type *c_type_of_child (struct varobj *parent, int index);
330 static char *c_value_of_variable (struct varobj *var,
331 enum varobj_display_formats format);
333 /* C++ implementation */
335 static int cplus_number_of_children (struct varobj *var);
337 static void cplus_class_num_children (struct type *type, int children[3]);
339 static char *cplus_name_of_variable (struct varobj *parent);
341 static char *cplus_name_of_child (struct varobj *parent, int index);
343 static char *cplus_path_expr_of_child (struct varobj *child);
345 static struct value *cplus_value_of_root (struct varobj **var_handle);
347 static struct value *cplus_value_of_child (struct varobj *parent, int index);
349 static struct type *cplus_type_of_child (struct varobj *parent, int index);
351 static char *cplus_value_of_variable (struct varobj *var,
352 enum varobj_display_formats format);
354 /* Java implementation */
356 static int java_number_of_children (struct varobj *var);
358 static char *java_name_of_variable (struct varobj *parent);
360 static char *java_name_of_child (struct varobj *parent, int index);
362 static char *java_path_expr_of_child (struct varobj *child);
364 static struct value *java_value_of_root (struct varobj **var_handle);
366 static struct value *java_value_of_child (struct varobj *parent, int index);
368 static struct type *java_type_of_child (struct varobj *parent, int index);
370 static char *java_value_of_variable (struct varobj *var,
371 enum varobj_display_formats format);
373 /* Ada implementation */
375 static int ada_number_of_children (struct varobj *var);
377 static char *ada_name_of_variable (struct varobj *parent);
379 static char *ada_name_of_child (struct varobj *parent, int index);
381 static char *ada_path_expr_of_child (struct varobj *child);
383 static struct value *ada_value_of_root (struct varobj **var_handle);
385 static struct value *ada_value_of_child (struct varobj *parent, int index);
387 static struct type *ada_type_of_child (struct varobj *parent, int index);
389 static char *ada_value_of_variable (struct varobj *var,
390 enum varobj_display_formats format);
392 static int ada_value_is_changeable_p (struct varobj *var);
394 static int ada_value_has_mutated (struct varobj *var, struct value *new_val,
395 struct type *new_type);
397 /* The language specific vector */
399 struct language_specific
401 /* The number of children of PARENT. */
402 int (*number_of_children) (struct varobj * parent);
404 /* The name (expression) of a root varobj. */
405 char *(*name_of_variable) (struct varobj * parent);
407 /* The name of the INDEX'th child of PARENT. */
408 char *(*name_of_child) (struct varobj * parent, int index);
410 /* Returns the rooted expression of CHILD, which is a variable
411 obtain that has some parent. */
412 char *(*path_expr_of_child) (struct varobj * child);
414 /* The ``struct value *'' of the root variable ROOT. */
415 struct value *(*value_of_root) (struct varobj ** root_handle);
417 /* The ``struct value *'' of the INDEX'th child of PARENT. */
418 struct value *(*value_of_child) (struct varobj * parent, int index);
420 /* The type of the INDEX'th child of PARENT. */
421 struct type *(*type_of_child) (struct varobj * parent, int index);
423 /* The current value of VAR. */
424 char *(*value_of_variable) (struct varobj * var,
425 enum varobj_display_formats format);
427 /* Return non-zero if changes in value of VAR must be detected and
428 reported by -var-update. Return zero if -var-update should never
429 report changes of such values. This makes sense for structures
430 (since the changes in children values will be reported separately),
431 or for artifical objects (like 'public' pseudo-field in C++).
433 Return value of 0 means that gdb need not call value_fetch_lazy
434 for the value of this variable object. */
435 int (*value_is_changeable_p) (struct varobj *var);
437 /* Return nonzero if the type of VAR has mutated.
439 VAR's value is still the varobj's previous value, while NEW_VALUE
440 is VAR's new value and NEW_TYPE is the var's new type. NEW_VALUE
441 may be NULL indicating that there is no value available (the varobj
442 may be out of scope, of may be the child of a null pointer, for
443 instance). NEW_TYPE, on the other hand, must never be NULL.
445 This function should also be able to assume that var's number of
446 children is set (not < 0).
448 Languages where types do not mutate can set this to NULL. */
449 int (*value_has_mutated) (struct varobj *var, struct value *new_value,
450 struct type *new_type);
453 /* Array of known source language routines. */
454 static struct language_specific languages[vlang_end] = {
457 c_number_of_children,
460 c_path_expr_of_child,
465 default_value_is_changeable_p,
466 NULL /* value_has_mutated */}
470 cplus_number_of_children,
471 cplus_name_of_variable,
473 cplus_path_expr_of_child,
475 cplus_value_of_child,
477 cplus_value_of_variable,
478 default_value_is_changeable_p,
479 NULL /* value_has_mutated */}
483 java_number_of_children,
484 java_name_of_variable,
486 java_path_expr_of_child,
490 java_value_of_variable,
491 default_value_is_changeable_p,
492 NULL /* value_has_mutated */},
495 ada_number_of_children,
496 ada_name_of_variable,
498 ada_path_expr_of_child,
502 ada_value_of_variable,
503 ada_value_is_changeable_p,
504 ada_value_has_mutated}
507 /* A little convenience enum for dealing with C++/Java. */
510 v_public = 0, v_private, v_protected
515 /* Mappings of varobj_display_formats enums to gdb's format codes. */
516 static int format_code[] = { 0, 't', 'd', 'x', 'o' };
518 /* Header of the list of root variable objects. */
519 static struct varobj_root *rootlist;
521 /* Prime number indicating the number of buckets in the hash table. */
522 /* A prime large enough to avoid too many colisions. */
523 #define VAROBJ_TABLE_SIZE 227
525 /* Pointer to the varobj hash table (built at run time). */
526 static struct vlist **varobj_table;
528 /* Is the variable X one of our "fake" children? */
529 #define CPLUS_FAKE_CHILD(x) \
530 ((x) != NULL && (x)->type == NULL && (x)->value == NULL)
533 /* API Implementation */
535 is_root_p (struct varobj *var)
537 return (var->root->rootvar == var);
541 /* Helper function to install a Python environment suitable for
542 use during operations on VAR. */
543 static struct cleanup *
544 varobj_ensure_python_env (struct varobj *var)
546 return ensure_python_env (var->root->exp->gdbarch,
547 var->root->exp->language_defn);
551 /* Creates a varobj (not its children). */
553 /* Return the full FRAME which corresponds to the given CORE_ADDR
554 or NULL if no FRAME on the chain corresponds to CORE_ADDR. */
556 static struct frame_info *
557 find_frame_addr_in_frame_chain (CORE_ADDR frame_addr)
559 struct frame_info *frame = NULL;
561 if (frame_addr == (CORE_ADDR) 0)
564 for (frame = get_current_frame ();
566 frame = get_prev_frame (frame))
568 /* The CORE_ADDR we get as argument was parsed from a string GDB
569 output as $fp. This output got truncated to gdbarch_addr_bit.
570 Truncate the frame base address in the same manner before
571 comparing it against our argument. */
572 CORE_ADDR frame_base = get_frame_base_address (frame);
573 int addr_bit = gdbarch_addr_bit (get_frame_arch (frame));
575 if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
576 frame_base &= ((CORE_ADDR) 1 << addr_bit) - 1;
578 if (frame_base == frame_addr)
586 varobj_create (char *objname,
587 char *expression, CORE_ADDR frame, enum varobj_type type)
590 struct cleanup *old_chain;
592 /* Fill out a varobj structure for the (root) variable being constructed. */
593 var = new_root_variable ();
594 old_chain = make_cleanup_free_variable (var);
596 if (expression != NULL)
598 struct frame_info *fi;
599 struct frame_id old_id = null_frame_id;
602 enum varobj_languages lang;
603 struct value *value = NULL;
604 volatile struct gdb_exception except;
607 /* Parse and evaluate the expression, filling in as much of the
608 variable's data as possible. */
610 if (has_stack_frames ())
612 /* Allow creator to specify context of variable. */
613 if ((type == USE_CURRENT_FRAME) || (type == USE_SELECTED_FRAME))
614 fi = get_selected_frame (NULL);
616 /* FIXME: cagney/2002-11-23: This code should be doing a
617 lookup using the frame ID and not just the frame's
618 ``address''. This, of course, means an interface
619 change. However, with out that interface change ISAs,
620 such as the ia64 with its two stacks, won't work.
621 Similar goes for the case where there is a frameless
623 fi = find_frame_addr_in_frame_chain (frame);
628 /* frame = -2 means always use selected frame. */
629 if (type == USE_SELECTED_FRAME)
630 var->root->floating = 1;
636 block = get_frame_block (fi, 0);
637 pc = get_frame_pc (fi);
641 innermost_block = NULL;
642 /* Wrap the call to parse expression, so we can
643 return a sensible error. */
644 TRY_CATCH (except, RETURN_MASK_ERROR)
646 var->root->exp = parse_exp_1 (&p, pc, block, 0);
649 if (except.reason < 0)
651 do_cleanups (old_chain);
655 /* Don't allow variables to be created for types. */
656 if (var->root->exp->elts[0].opcode == OP_TYPE
657 || var->root->exp->elts[0].opcode == OP_TYPEOF
658 || var->root->exp->elts[0].opcode == OP_DECLTYPE)
660 do_cleanups (old_chain);
661 fprintf_unfiltered (gdb_stderr, "Attempt to use a type name"
662 " as an expression.\n");
666 var->format = variable_default_display (var);
667 var->root->valid_block = innermost_block;
668 var->name = xstrdup (expression);
669 /* For a root var, the name and the expr are the same. */
670 var->path_expr = xstrdup (expression);
672 /* When the frame is different from the current frame,
673 we must select the appropriate frame before parsing
674 the expression, otherwise the value will not be current.
675 Since select_frame is so benign, just call it for all cases. */
678 /* User could specify explicit FRAME-ADDR which was not found but
679 EXPRESSION is frame specific and we would not be able to evaluate
680 it correctly next time. With VALID_BLOCK set we must also set
681 FRAME and THREAD_ID. */
683 error (_("Failed to find the specified frame"));
685 var->root->frame = get_frame_id (fi);
686 var->root->thread_id = pid_to_thread_id (inferior_ptid);
687 old_id = get_frame_id (get_selected_frame (NULL));
691 /* We definitely need to catch errors here.
692 If evaluate_expression succeeds we got the value we wanted.
693 But if it fails, we still go on with a call to evaluate_type(). */
694 TRY_CATCH (except, RETURN_MASK_ERROR)
696 value = evaluate_expression (var->root->exp);
699 if (except.reason < 0)
701 /* Error getting the value. Try to at least get the
703 struct value *type_only_value = evaluate_type (var->root->exp);
705 var->type = value_type (type_only_value);
709 int real_type_found = 0;
711 var->type = value_actual_type (value, 0, &real_type_found);
713 value = value_cast (var->type, value);
716 /* Set language info */
717 lang = variable_language (var);
718 var->root->lang = &languages[lang];
720 install_new_value (var, value, 1 /* Initial assignment */);
722 /* Set ourselves as our root. */
723 var->root->rootvar = var;
725 /* Reset the selected frame. */
726 if (frame_id_p (old_id))
727 select_frame (frame_find_by_id (old_id));
730 /* If the variable object name is null, that means this
731 is a temporary variable, so don't install it. */
733 if ((var != NULL) && (objname != NULL))
735 var->obj_name = xstrdup (objname);
737 /* If a varobj name is duplicated, the install will fail so
739 if (!install_variable (var))
741 do_cleanups (old_chain);
746 discard_cleanups (old_chain);
750 /* Generates an unique name that can be used for a varobj. */
753 varobj_gen_name (void)
758 /* Generate a name for this object. */
760 obj_name = xstrprintf ("var%d", id);
765 /* Given an OBJNAME, returns the pointer to the corresponding varobj. Call
766 error if OBJNAME cannot be found. */
769 varobj_get_handle (char *objname)
773 unsigned int index = 0;
776 for (chp = objname; *chp; chp++)
778 index = (index + (i++ * (unsigned int) *chp)) % VAROBJ_TABLE_SIZE;
781 cv = *(varobj_table + index);
782 while ((cv != NULL) && (strcmp (cv->var->obj_name, objname) != 0))
786 error (_("Variable object not found"));
791 /* Given the handle, return the name of the object. */
794 varobj_get_objname (struct varobj *var)
796 return var->obj_name;
799 /* Given the handle, return the expression represented by the object. */
802 varobj_get_expression (struct varobj *var)
804 return name_of_variable (var);
807 /* Deletes a varobj and all its children if only_children == 0,
808 otherwise deletes only the children; returns a malloc'ed list of
809 all the (malloc'ed) names of the variables that have been deleted
810 (NULL terminated). */
813 varobj_delete (struct varobj *var, char ***dellist, int only_children)
817 struct cpstack *result = NULL;
820 /* Initialize a stack for temporary results. */
821 cppush (&result, NULL);
824 /* Delete only the variable children. */
825 delcount = delete_variable (&result, var, 1 /* only the children */ );
827 /* Delete the variable and all its children. */
828 delcount = delete_variable (&result, var, 0 /* parent+children */ );
830 /* We may have been asked to return a list of what has been deleted. */
833 *dellist = xmalloc ((delcount + 1) * sizeof (char *));
837 *cp = cppop (&result);
838 while ((*cp != NULL) && (mycount > 0))
842 *cp = cppop (&result);
845 if (mycount || (*cp != NULL))
846 warning (_("varobj_delete: assertion failed - mycount(=%d) <> 0"),
855 /* Convenience function for varobj_set_visualizer. Instantiate a
856 pretty-printer for a given value. */
858 instantiate_pretty_printer (PyObject *constructor, struct value *value)
860 PyObject *val_obj = NULL;
863 val_obj = value_to_value_object (value);
867 printer = PyObject_CallFunctionObjArgs (constructor, val_obj, NULL);
874 /* Set/Get variable object display format. */
876 enum varobj_display_formats
877 varobj_set_display_format (struct varobj *var,
878 enum varobj_display_formats format)
885 case FORMAT_HEXADECIMAL:
887 var->format = format;
891 var->format = variable_default_display (var);
894 if (varobj_value_is_changeable_p (var)
895 && var->value && !value_lazy (var->value))
897 xfree (var->print_value);
898 var->print_value = value_get_print_value (var->value, var->format, var);
904 enum varobj_display_formats
905 varobj_get_display_format (struct varobj *var)
911 varobj_get_display_hint (struct varobj *var)
916 struct cleanup *back_to;
918 if (!gdb_python_initialized)
921 back_to = varobj_ensure_python_env (var);
923 if (var->pretty_printer)
924 result = gdbpy_get_display_hint (var->pretty_printer);
926 do_cleanups (back_to);
932 /* Return true if the varobj has items after TO, false otherwise. */
935 varobj_has_more (struct varobj *var, int to)
937 if (VEC_length (varobj_p, var->children) > to)
939 return ((to == -1 || VEC_length (varobj_p, var->children) == to)
940 && var->saved_item != NULL);
943 /* If the variable object is bound to a specific thread, that
944 is its evaluation can always be done in context of a frame
945 inside that thread, returns GDB id of the thread -- which
946 is always positive. Otherwise, returns -1. */
948 varobj_get_thread_id (struct varobj *var)
950 if (var->root->valid_block && var->root->thread_id > 0)
951 return var->root->thread_id;
957 varobj_set_frozen (struct varobj *var, int frozen)
959 /* When a variable is unfrozen, we don't fetch its value.
960 The 'not_fetched' flag remains set, so next -var-update
963 We don't fetch the value, because for structures the client
964 should do -var-update anyway. It would be bad to have different
965 client-size logic for structure and other types. */
966 var->frozen = frozen;
970 varobj_get_frozen (struct varobj *var)
975 /* A helper function that restricts a range to what is actually
976 available in a VEC. This follows the usual rules for the meaning
977 of FROM and TO -- if either is negative, the entire range is
981 restrict_range (VEC (varobj_p) *children, int *from, int *to)
983 if (*from < 0 || *to < 0)
986 *to = VEC_length (varobj_p, children);
990 if (*from > VEC_length (varobj_p, children))
991 *from = VEC_length (varobj_p, children);
992 if (*to > VEC_length (varobj_p, children))
993 *to = VEC_length (varobj_p, children);
1001 /* A helper for update_dynamic_varobj_children that installs a new
1002 child when needed. */
1005 install_dynamic_child (struct varobj *var,
1006 VEC (varobj_p) **changed,
1007 VEC (varobj_p) **type_changed,
1008 VEC (varobj_p) **new,
1009 VEC (varobj_p) **unchanged,
1013 struct value *value)
1015 if (VEC_length (varobj_p, var->children) < index + 1)
1017 /* There's no child yet. */
1018 struct varobj *child = varobj_add_child (var, name, value);
1022 VEC_safe_push (varobj_p, *new, child);
1028 varobj_p existing = VEC_index (varobj_p, var->children, index);
1029 int type_updated = update_type_if_necessary (existing, value);
1034 VEC_safe_push (varobj_p, *type_changed, existing);
1036 if (install_new_value (existing, value, 0))
1038 if (!type_updated && changed)
1039 VEC_safe_push (varobj_p, *changed, existing);
1041 else if (!type_updated && unchanged)
1042 VEC_safe_push (varobj_p, *unchanged, existing);
1047 dynamic_varobj_has_child_method (struct varobj *var)
1049 struct cleanup *back_to;
1050 PyObject *printer = var->pretty_printer;
1053 if (!gdb_python_initialized)
1056 back_to = varobj_ensure_python_env (var);
1057 result = PyObject_HasAttr (printer, gdbpy_children_cst);
1058 do_cleanups (back_to);
1065 update_dynamic_varobj_children (struct varobj *var,
1066 VEC (varobj_p) **changed,
1067 VEC (varobj_p) **type_changed,
1068 VEC (varobj_p) **new,
1069 VEC (varobj_p) **unchanged,
1071 int update_children,
1076 struct cleanup *back_to;
1079 PyObject *printer = var->pretty_printer;
1081 if (!gdb_python_initialized)
1084 back_to = varobj_ensure_python_env (var);
1087 if (!PyObject_HasAttr (printer, gdbpy_children_cst))
1089 do_cleanups (back_to);
1093 if (update_children || !var->child_iter)
1095 children = PyObject_CallMethodObjArgs (printer, gdbpy_children_cst,
1100 gdbpy_print_stack ();
1101 error (_("Null value returned for children"));
1104 make_cleanup_py_decref (children);
1106 Py_XDECREF (var->child_iter);
1107 var->child_iter = PyObject_GetIter (children);
1108 if (!var->child_iter)
1110 gdbpy_print_stack ();
1111 error (_("Could not get children iterator"));
1114 Py_XDECREF (var->saved_item);
1115 var->saved_item = NULL;
1120 i = VEC_length (varobj_p, var->children);
1122 /* We ask for one extra child, so that MI can report whether there
1123 are more children. */
1124 for (; to < 0 || i < to + 1; ++i)
1129 /* See if there was a leftover from last time. */
1130 if (var->saved_item)
1132 item = var->saved_item;
1133 var->saved_item = NULL;
1136 item = PyIter_Next (var->child_iter);
1140 /* Normal end of iteration. */
1141 if (!PyErr_Occurred ())
1144 /* If we got a memory error, just use the text as the
1146 if (PyErr_ExceptionMatches (gdbpy_gdb_memory_error))
1148 PyObject *type, *value, *trace;
1149 char *name_str, *value_str;
1151 PyErr_Fetch (&type, &value, &trace);
1152 value_str = gdbpy_exception_to_string (type, value);
1158 gdbpy_print_stack ();
1162 name_str = xstrprintf ("<error at %d>", i);
1163 item = Py_BuildValue ("(ss)", name_str, value_str);
1168 gdbpy_print_stack ();
1176 /* Any other kind of error. */
1177 gdbpy_print_stack ();
1182 /* We don't want to push the extra child on any report list. */
1183 if (to < 0 || i < to)
1188 struct cleanup *inner;
1189 int can_mention = from < 0 || i >= from;
1191 inner = make_cleanup_py_decref (item);
1193 if (!PyArg_ParseTuple (item, "sO", &name, &py_v))
1195 gdbpy_print_stack ();
1196 error (_("Invalid item from the child list"));
1199 v = convert_value_from_python (py_v);
1201 gdbpy_print_stack ();
1202 install_dynamic_child (var, can_mention ? changed : NULL,
1203 can_mention ? type_changed : NULL,
1204 can_mention ? new : NULL,
1205 can_mention ? unchanged : NULL,
1206 can_mention ? cchanged : NULL, i, name, v);
1207 do_cleanups (inner);
1211 Py_XDECREF (var->saved_item);
1212 var->saved_item = item;
1214 /* We want to truncate the child list just before this
1223 if (i < VEC_length (varobj_p, var->children))
1228 for (j = i; j < VEC_length (varobj_p, var->children); ++j)
1229 varobj_delete (VEC_index (varobj_p, var->children, j), NULL, 0);
1230 VEC_truncate (varobj_p, var->children, i);
1233 /* If there are fewer children than requested, note that the list of
1234 children changed. */
1235 if (to >= 0 && VEC_length (varobj_p, var->children) < to)
1238 var->num_children = VEC_length (varobj_p, var->children);
1240 do_cleanups (back_to);
1244 gdb_assert_not_reached ("should never be called if Python is not enabled");
1249 varobj_get_num_children (struct varobj *var)
1251 if (var->num_children == -1)
1253 if (var->pretty_printer)
1257 /* If we have a dynamic varobj, don't report -1 children.
1258 So, try to fetch some children first. */
1259 update_dynamic_varobj_children (var, NULL, NULL, NULL, NULL, &dummy,
1263 var->num_children = number_of_children (var);
1266 return var->num_children >= 0 ? var->num_children : 0;
1269 /* Creates a list of the immediate children of a variable object;
1270 the return code is the number of such children or -1 on error. */
1273 varobj_list_children (struct varobj *var, int *from, int *to)
1276 int i, children_changed;
1278 var->children_requested = 1;
1280 if (var->pretty_printer)
1282 /* This, in theory, can result in the number of children changing without
1283 frontend noticing. But well, calling -var-list-children on the same
1284 varobj twice is not something a sane frontend would do. */
1285 update_dynamic_varobj_children (var, NULL, NULL, NULL, NULL,
1286 &children_changed, 0, 0, *to);
1287 restrict_range (var->children, from, to);
1288 return var->children;
1291 if (var->num_children == -1)
1292 var->num_children = number_of_children (var);
1294 /* If that failed, give up. */
1295 if (var->num_children == -1)
1296 return var->children;
1298 /* If we're called when the list of children is not yet initialized,
1299 allocate enough elements in it. */
1300 while (VEC_length (varobj_p, var->children) < var->num_children)
1301 VEC_safe_push (varobj_p, var->children, NULL);
1303 for (i = 0; i < var->num_children; i++)
1305 varobj_p existing = VEC_index (varobj_p, var->children, i);
1307 if (existing == NULL)
1309 /* Either it's the first call to varobj_list_children for
1310 this variable object, and the child was never created,
1311 or it was explicitly deleted by the client. */
1312 name = name_of_child (var, i);
1313 existing = create_child (var, i, name);
1314 VEC_replace (varobj_p, var->children, i, existing);
1318 restrict_range (var->children, from, to);
1319 return var->children;
1324 static struct varobj *
1325 varobj_add_child (struct varobj *var, const char *name, struct value *value)
1327 varobj_p v = create_child_with_value (var,
1328 VEC_length (varobj_p, var->children),
1331 VEC_safe_push (varobj_p, var->children, v);
1335 #endif /* HAVE_PYTHON */
1337 /* Obtain the type of an object Variable as a string similar to the one gdb
1338 prints on the console. */
1341 varobj_get_type (struct varobj *var)
1343 /* For the "fake" variables, do not return a type. (It's type is
1345 Do not return a type for invalid variables as well. */
1346 if (CPLUS_FAKE_CHILD (var) || !var->root->is_valid)
1349 return type_to_string (var->type);
1352 /* Obtain the type of an object variable. */
1355 varobj_get_gdb_type (struct varobj *var)
1360 /* Is VAR a path expression parent, i.e., can it be used to construct
1361 a valid path expression? */
1364 is_path_expr_parent (struct varobj *var)
1368 /* "Fake" children are not path_expr parents. */
1369 if (CPLUS_FAKE_CHILD (var))
1372 type = get_value_type (var);
1374 /* Anonymous unions and structs are also not path_expr parents. */
1375 return !((TYPE_CODE (type) == TYPE_CODE_STRUCT
1376 || TYPE_CODE (type) == TYPE_CODE_UNION)
1377 && TYPE_NAME (type) == NULL);
1380 /* Return the path expression parent for VAR. */
1382 static struct varobj *
1383 get_path_expr_parent (struct varobj *var)
1385 struct varobj *parent = var;
1387 while (!is_root_p (parent) && !is_path_expr_parent (parent))
1388 parent = parent->parent;
1393 /* Return a pointer to the full rooted expression of varobj VAR.
1394 If it has not been computed yet, compute it. */
1396 varobj_get_path_expr (struct varobj *var)
1398 if (var->path_expr != NULL)
1399 return var->path_expr;
1402 /* For root varobjs, we initialize path_expr
1403 when creating varobj, so here it should be
1405 gdb_assert (!is_root_p (var));
1406 return (*var->root->lang->path_expr_of_child) (var);
1410 enum varobj_languages
1411 varobj_get_language (struct varobj *var)
1413 return variable_language (var);
1417 varobj_get_attributes (struct varobj *var)
1421 if (varobj_editable_p (var))
1422 /* FIXME: define masks for attributes. */
1423 attributes |= 0x00000001; /* Editable */
1429 varobj_pretty_printed_p (struct varobj *var)
1431 return var->pretty_printer != NULL;
1435 varobj_get_formatted_value (struct varobj *var,
1436 enum varobj_display_formats format)
1438 return my_value_of_variable (var, format);
1442 varobj_get_value (struct varobj *var)
1444 return my_value_of_variable (var, var->format);
1447 /* Set the value of an object variable (if it is editable) to the
1448 value of the given expression. */
1449 /* Note: Invokes functions that can call error(). */
1452 varobj_set_value (struct varobj *var, char *expression)
1454 struct value *val = NULL; /* Initialize to keep gcc happy. */
1455 /* The argument "expression" contains the variable's new value.
1456 We need to first construct a legal expression for this -- ugh! */
1457 /* Does this cover all the bases? */
1458 struct expression *exp;
1459 struct value *value = NULL; /* Initialize to keep gcc happy. */
1460 int saved_input_radix = input_radix;
1461 const char *s = expression;
1462 volatile struct gdb_exception except;
1464 gdb_assert (varobj_editable_p (var));
1466 input_radix = 10; /* ALWAYS reset to decimal temporarily. */
1467 exp = parse_exp_1 (&s, 0, 0, 0);
1468 TRY_CATCH (except, RETURN_MASK_ERROR)
1470 value = evaluate_expression (exp);
1473 if (except.reason < 0)
1475 /* We cannot proceed without a valid expression. */
1480 /* All types that are editable must also be changeable. */
1481 gdb_assert (varobj_value_is_changeable_p (var));
1483 /* The value of a changeable variable object must not be lazy. */
1484 gdb_assert (!value_lazy (var->value));
1486 /* Need to coerce the input. We want to check if the
1487 value of the variable object will be different
1488 after assignment, and the first thing value_assign
1489 does is coerce the input.
1490 For example, if we are assigning an array to a pointer variable we
1491 should compare the pointer with the array's address, not with the
1493 value = coerce_array (value);
1495 /* The new value may be lazy. value_assign, or
1496 rather value_contents, will take care of this. */
1497 TRY_CATCH (except, RETURN_MASK_ERROR)
1499 val = value_assign (var->value, value);
1502 if (except.reason < 0)
1505 /* If the value has changed, record it, so that next -var-update can
1506 report this change. If a variable had a value of '1', we've set it
1507 to '333' and then set again to '1', when -var-update will report this
1508 variable as changed -- because the first assignment has set the
1509 'updated' flag. There's no need to optimize that, because return value
1510 of -var-update should be considered an approximation. */
1511 var->updated = install_new_value (var, val, 0 /* Compare values. */);
1512 input_radix = saved_input_radix;
1518 /* A helper function to install a constructor function and visualizer
1522 install_visualizer (struct varobj *var, PyObject *constructor,
1523 PyObject *visualizer)
1525 Py_XDECREF (var->constructor);
1526 var->constructor = constructor;
1528 Py_XDECREF (var->pretty_printer);
1529 var->pretty_printer = visualizer;
1531 Py_XDECREF (var->child_iter);
1532 var->child_iter = NULL;
1535 /* Install the default visualizer for VAR. */
1538 install_default_visualizer (struct varobj *var)
1540 /* Do not install a visualizer on a CPLUS_FAKE_CHILD. */
1541 if (CPLUS_FAKE_CHILD (var))
1544 if (pretty_printing)
1546 PyObject *pretty_printer = NULL;
1550 pretty_printer = gdbpy_get_varobj_pretty_printer (var->value);
1551 if (! pretty_printer)
1553 gdbpy_print_stack ();
1554 error (_("Cannot instantiate printer for default visualizer"));
1558 if (pretty_printer == Py_None)
1560 Py_DECREF (pretty_printer);
1561 pretty_printer = NULL;
1564 install_visualizer (var, NULL, pretty_printer);
1568 /* Instantiate and install a visualizer for VAR using CONSTRUCTOR to
1569 make a new object. */
1572 construct_visualizer (struct varobj *var, PyObject *constructor)
1574 PyObject *pretty_printer;
1576 /* Do not install a visualizer on a CPLUS_FAKE_CHILD. */
1577 if (CPLUS_FAKE_CHILD (var))
1580 Py_INCREF (constructor);
1581 if (constructor == Py_None)
1582 pretty_printer = NULL;
1585 pretty_printer = instantiate_pretty_printer (constructor, var->value);
1586 if (! pretty_printer)
1588 gdbpy_print_stack ();
1589 Py_DECREF (constructor);
1590 constructor = Py_None;
1591 Py_INCREF (constructor);
1594 if (pretty_printer == Py_None)
1596 Py_DECREF (pretty_printer);
1597 pretty_printer = NULL;
1601 install_visualizer (var, constructor, pretty_printer);
1604 #endif /* HAVE_PYTHON */
1606 /* A helper function for install_new_value. This creates and installs
1607 a visualizer for VAR, if appropriate. */
1610 install_new_value_visualizer (struct varobj *var)
1613 /* If the constructor is None, then we want the raw value. If VAR
1614 does not have a value, just skip this. */
1615 if (!gdb_python_initialized)
1618 if (var->constructor != Py_None && var->value)
1620 struct cleanup *cleanup;
1622 cleanup = varobj_ensure_python_env (var);
1624 if (!var->constructor)
1625 install_default_visualizer (var);
1627 construct_visualizer (var, var->constructor);
1629 do_cleanups (cleanup);
1636 /* When using RTTI to determine variable type it may be changed in runtime when
1637 the variable value is changed. This function checks whether type of varobj
1638 VAR will change when a new value NEW_VALUE is assigned and if it is so
1639 updates the type of VAR. */
1642 update_type_if_necessary (struct varobj *var, struct value *new_value)
1646 struct value_print_options opts;
1648 get_user_print_options (&opts);
1649 if (opts.objectprint)
1651 struct type *new_type;
1652 char *curr_type_str, *new_type_str;
1654 new_type = value_actual_type (new_value, 0, 0);
1655 new_type_str = type_to_string (new_type);
1656 curr_type_str = varobj_get_type (var);
1657 if (strcmp (curr_type_str, new_type_str) != 0)
1659 var->type = new_type;
1661 /* This information may be not valid for a new type. */
1662 varobj_delete (var, NULL, 1);
1663 VEC_free (varobj_p, var->children);
1664 var->num_children = -1;
1673 /* Assign a new value to a variable object. If INITIAL is non-zero,
1674 this is the first assignement after the variable object was just
1675 created, or changed type. In that case, just assign the value
1677 Otherwise, assign the new value, and return 1 if the value is
1678 different from the current one, 0 otherwise. The comparison is
1679 done on textual representation of value. Therefore, some types
1680 need not be compared. E.g. for structures the reported value is
1681 always "{...}", so no comparison is necessary here. If the old
1682 value was NULL and new one is not, or vice versa, we always return 1.
1684 The VALUE parameter should not be released -- the function will
1685 take care of releasing it when needed. */
1687 install_new_value (struct varobj *var, struct value *value, int initial)
1692 int intentionally_not_fetched = 0;
1693 char *print_value = NULL;
1695 /* We need to know the varobj's type to decide if the value should
1696 be fetched or not. C++ fake children (public/protected/private)
1697 don't have a type. */
1698 gdb_assert (var->type || CPLUS_FAKE_CHILD (var));
1699 changeable = varobj_value_is_changeable_p (var);
1701 /* If the type has custom visualizer, we consider it to be always
1702 changeable. FIXME: need to make sure this behaviour will not
1703 mess up read-sensitive values. */
1704 if (var->pretty_printer)
1707 need_to_fetch = changeable;
1709 /* We are not interested in the address of references, and given
1710 that in C++ a reference is not rebindable, it cannot
1711 meaningfully change. So, get hold of the real value. */
1713 value = coerce_ref (value);
1715 if (var->type && TYPE_CODE (var->type) == TYPE_CODE_UNION)
1716 /* For unions, we need to fetch the value implicitly because
1717 of implementation of union member fetch. When gdb
1718 creates a value for a field and the value of the enclosing
1719 structure is not lazy, it immediately copies the necessary
1720 bytes from the enclosing values. If the enclosing value is
1721 lazy, the call to value_fetch_lazy on the field will read
1722 the data from memory. For unions, that means we'll read the
1723 same memory more than once, which is not desirable. So
1727 /* The new value might be lazy. If the type is changeable,
1728 that is we'll be comparing values of this type, fetch the
1729 value now. Otherwise, on the next update the old value
1730 will be lazy, which means we've lost that old value. */
1731 if (need_to_fetch && value && value_lazy (value))
1733 struct varobj *parent = var->parent;
1734 int frozen = var->frozen;
1736 for (; !frozen && parent; parent = parent->parent)
1737 frozen |= parent->frozen;
1739 if (frozen && initial)
1741 /* For variables that are frozen, or are children of frozen
1742 variables, we don't do fetch on initial assignment.
1743 For non-initial assignemnt we do the fetch, since it means we're
1744 explicitly asked to compare the new value with the old one. */
1745 intentionally_not_fetched = 1;
1749 volatile struct gdb_exception except;
1751 TRY_CATCH (except, RETURN_MASK_ERROR)
1753 value_fetch_lazy (value);
1756 if (except.reason < 0)
1758 /* Set the value to NULL, so that for the next -var-update,
1759 we don't try to compare the new value with this value,
1760 that we couldn't even read. */
1766 /* Get a reference now, before possibly passing it to any Python
1767 code that might release it. */
1769 value_incref (value);
1771 /* Below, we'll be comparing string rendering of old and new
1772 values. Don't get string rendering if the value is
1773 lazy -- if it is, the code above has decided that the value
1774 should not be fetched. */
1775 if (value && !value_lazy (value) && !var->pretty_printer)
1776 print_value = value_get_print_value (value, var->format, var);
1778 /* If the type is changeable, compare the old and the new values.
1779 If this is the initial assignment, we don't have any old value
1781 if (!initial && changeable)
1783 /* If the value of the varobj was changed by -var-set-value,
1784 then the value in the varobj and in the target is the same.
1785 However, that value is different from the value that the
1786 varobj had after the previous -var-update. So need to the
1787 varobj as changed. */
1792 else if (! var->pretty_printer)
1794 /* Try to compare the values. That requires that both
1795 values are non-lazy. */
1796 if (var->not_fetched && value_lazy (var->value))
1798 /* This is a frozen varobj and the value was never read.
1799 Presumably, UI shows some "never read" indicator.
1800 Now that we've fetched the real value, we need to report
1801 this varobj as changed so that UI can show the real
1805 else if (var->value == NULL && value == NULL)
1808 else if (var->value == NULL || value == NULL)
1814 gdb_assert (!value_lazy (var->value));
1815 gdb_assert (!value_lazy (value));
1817 gdb_assert (var->print_value != NULL && print_value != NULL);
1818 if (strcmp (var->print_value, print_value) != 0)
1824 if (!initial && !changeable)
1826 /* For values that are not changeable, we don't compare the values.
1827 However, we want to notice if a value was not NULL and now is NULL,
1828 or vise versa, so that we report when top-level varobjs come in scope
1829 and leave the scope. */
1830 changed = (var->value != NULL) != (value != NULL);
1833 /* We must always keep the new value, since children depend on it. */
1834 if (var->value != NULL && var->value != value)
1835 value_free (var->value);
1837 if (value && value_lazy (value) && intentionally_not_fetched)
1838 var->not_fetched = 1;
1840 var->not_fetched = 0;
1843 install_new_value_visualizer (var);
1845 /* If we installed a pretty-printer, re-compare the printed version
1846 to see if the variable changed. */
1847 if (var->pretty_printer)
1849 xfree (print_value);
1850 print_value = value_get_print_value (var->value, var->format, var);
1851 if ((var->print_value == NULL && print_value != NULL)
1852 || (var->print_value != NULL && print_value == NULL)
1853 || (var->print_value != NULL && print_value != NULL
1854 && strcmp (var->print_value, print_value) != 0))
1857 if (var->print_value)
1858 xfree (var->print_value);
1859 var->print_value = print_value;
1861 gdb_assert (!var->value || value_type (var->value));
1866 /* Return the requested range for a varobj. VAR is the varobj. FROM
1867 and TO are out parameters; *FROM and *TO will be set to the
1868 selected sub-range of VAR. If no range was selected using
1869 -var-set-update-range, then both will be -1. */
1871 varobj_get_child_range (struct varobj *var, int *from, int *to)
1877 /* Set the selected sub-range of children of VAR to start at index
1878 FROM and end at index TO. If either FROM or TO is less than zero,
1879 this is interpreted as a request for all children. */
1881 varobj_set_child_range (struct varobj *var, int from, int to)
1888 varobj_set_visualizer (struct varobj *var, const char *visualizer)
1891 PyObject *mainmod, *globals, *constructor;
1892 struct cleanup *back_to;
1894 if (!gdb_python_initialized)
1897 back_to = varobj_ensure_python_env (var);
1899 mainmod = PyImport_AddModule ("__main__");
1900 globals = PyModule_GetDict (mainmod);
1901 Py_INCREF (globals);
1902 make_cleanup_py_decref (globals);
1904 constructor = PyRun_String (visualizer, Py_eval_input, globals, globals);
1908 gdbpy_print_stack ();
1909 error (_("Could not evaluate visualizer expression: %s"), visualizer);
1912 construct_visualizer (var, constructor);
1913 Py_XDECREF (constructor);
1915 /* If there are any children now, wipe them. */
1916 varobj_delete (var, NULL, 1 /* children only */);
1917 var->num_children = -1;
1919 do_cleanups (back_to);
1921 error (_("Python support required"));
1925 /* If NEW_VALUE is the new value of the given varobj (var), return
1926 non-zero if var has mutated. In other words, if the type of
1927 the new value is different from the type of the varobj's old
1930 NEW_VALUE may be NULL, if the varobj is now out of scope. */
1933 varobj_value_has_mutated (struct varobj *var, struct value *new_value,
1934 struct type *new_type)
1936 /* If we haven't previously computed the number of children in var,
1937 it does not matter from the front-end's perspective whether
1938 the type has mutated or not. For all intents and purposes,
1939 it has not mutated. */
1940 if (var->num_children < 0)
1943 if (var->root->lang->value_has_mutated)
1944 return var->root->lang->value_has_mutated (var, new_value, new_type);
1949 /* Update the values for a variable and its children. This is a
1950 two-pronged attack. First, re-parse the value for the root's
1951 expression to see if it's changed. Then go all the way
1952 through its children, reconstructing them and noting if they've
1955 The EXPLICIT parameter specifies if this call is result
1956 of MI request to update this specific variable, or
1957 result of implicit -var-update *. For implicit request, we don't
1958 update frozen variables.
1960 NOTE: This function may delete the caller's varobj. If it
1961 returns TYPE_CHANGED, then it has done this and VARP will be modified
1962 to point to the new varobj. */
1964 VEC(varobj_update_result) *
1965 varobj_update (struct varobj **varp, int explicit)
1967 int type_changed = 0;
1970 VEC (varobj_update_result) *stack = NULL;
1971 VEC (varobj_update_result) *result = NULL;
1973 /* Frozen means frozen -- we don't check for any change in
1974 this varobj, including its going out of scope, or
1975 changing type. One use case for frozen varobjs is
1976 retaining previously evaluated expressions, and we don't
1977 want them to be reevaluated at all. */
1978 if (!explicit && (*varp)->frozen)
1981 if (!(*varp)->root->is_valid)
1983 varobj_update_result r = {0};
1986 r.status = VAROBJ_INVALID;
1987 VEC_safe_push (varobj_update_result, result, &r);
1991 if ((*varp)->root->rootvar == *varp)
1993 varobj_update_result r = {0};
1996 r.status = VAROBJ_IN_SCOPE;
1998 /* Update the root variable. value_of_root can return NULL
1999 if the variable is no longer around, i.e. we stepped out of
2000 the frame in which a local existed. We are letting the
2001 value_of_root variable dispose of the varobj if the type
2003 new = value_of_root (varp, &type_changed);
2004 if (update_type_if_necessary(*varp, new))
2007 r.type_changed = type_changed;
2008 if (install_new_value ((*varp), new, type_changed))
2012 r.status = VAROBJ_NOT_IN_SCOPE;
2013 r.value_installed = 1;
2015 if (r.status == VAROBJ_NOT_IN_SCOPE)
2017 if (r.type_changed || r.changed)
2018 VEC_safe_push (varobj_update_result, result, &r);
2022 VEC_safe_push (varobj_update_result, stack, &r);
2026 varobj_update_result r = {0};
2029 VEC_safe_push (varobj_update_result, stack, &r);
2032 /* Walk through the children, reconstructing them all. */
2033 while (!VEC_empty (varobj_update_result, stack))
2035 varobj_update_result r = *(VEC_last (varobj_update_result, stack));
2036 struct varobj *v = r.varobj;
2038 VEC_pop (varobj_update_result, stack);
2040 /* Update this variable, unless it's a root, which is already
2042 if (!r.value_installed)
2044 struct type *new_type;
2046 new = value_of_child (v->parent, v->index);
2047 if (update_type_if_necessary(v, new))
2050 new_type = value_type (new);
2052 new_type = v->root->lang->type_of_child (v->parent, v->index);
2054 if (varobj_value_has_mutated (v, new, new_type))
2056 /* The children are no longer valid; delete them now.
2057 Report the fact that its type changed as well. */
2058 varobj_delete (v, NULL, 1 /* only_children */);
2059 v->num_children = -1;
2066 if (install_new_value (v, new, r.type_changed))
2073 /* We probably should not get children of a varobj that has a
2074 pretty-printer, but for which -var-list-children was never
2076 if (v->pretty_printer)
2078 VEC (varobj_p) *changed = 0, *type_changed = 0, *unchanged = 0;
2079 VEC (varobj_p) *new = 0;
2080 int i, children_changed = 0;
2085 if (!v->children_requested)
2089 /* If we initially did not have potential children, but
2090 now we do, consider the varobj as changed.
2091 Otherwise, if children were never requested, consider
2092 it as unchanged -- presumably, such varobj is not yet
2093 expanded in the UI, so we need not bother getting
2095 if (!varobj_has_more (v, 0))
2097 update_dynamic_varobj_children (v, NULL, NULL, NULL, NULL,
2099 if (varobj_has_more (v, 0))
2104 VEC_safe_push (varobj_update_result, result, &r);
2109 /* If update_dynamic_varobj_children returns 0, then we have
2110 a non-conforming pretty-printer, so we skip it. */
2111 if (update_dynamic_varobj_children (v, &changed, &type_changed, &new,
2112 &unchanged, &children_changed, 1,
2115 if (children_changed || new)
2117 r.children_changed = 1;
2120 /* Push in reverse order so that the first child is
2121 popped from the work stack first, and so will be
2122 added to result first. This does not affect
2123 correctness, just "nicer". */
2124 for (i = VEC_length (varobj_p, type_changed) - 1; i >= 0; --i)
2126 varobj_p tmp = VEC_index (varobj_p, type_changed, i);
2127 varobj_update_result r = {0};
2129 /* Type may change only if value was changed. */
2133 r.value_installed = 1;
2134 VEC_safe_push (varobj_update_result, stack, &r);
2136 for (i = VEC_length (varobj_p, changed) - 1; i >= 0; --i)
2138 varobj_p tmp = VEC_index (varobj_p, changed, i);
2139 varobj_update_result r = {0};
2143 r.value_installed = 1;
2144 VEC_safe_push (varobj_update_result, stack, &r);
2146 for (i = VEC_length (varobj_p, unchanged) - 1; i >= 0; --i)
2148 varobj_p tmp = VEC_index (varobj_p, unchanged, i);
2152 varobj_update_result r = {0};
2155 r.value_installed = 1;
2156 VEC_safe_push (varobj_update_result, stack, &r);
2159 if (r.changed || r.children_changed)
2160 VEC_safe_push (varobj_update_result, result, &r);
2162 /* Free CHANGED, TYPE_CHANGED and UNCHANGED, but not NEW,
2163 because NEW has been put into the result vector. */
2164 VEC_free (varobj_p, changed);
2165 VEC_free (varobj_p, type_changed);
2166 VEC_free (varobj_p, unchanged);
2172 /* Push any children. Use reverse order so that the first
2173 child is popped from the work stack first, and so
2174 will be added to result first. This does not
2175 affect correctness, just "nicer". */
2176 for (i = VEC_length (varobj_p, v->children)-1; i >= 0; --i)
2178 varobj_p c = VEC_index (varobj_p, v->children, i);
2180 /* Child may be NULL if explicitly deleted by -var-delete. */
2181 if (c != NULL && !c->frozen)
2183 varobj_update_result r = {0};
2186 VEC_safe_push (varobj_update_result, stack, &r);
2190 if (r.changed || r.type_changed)
2191 VEC_safe_push (varobj_update_result, result, &r);
2194 VEC_free (varobj_update_result, stack);
2200 /* Helper functions */
2203 * Variable object construction/destruction
2207 delete_variable (struct cpstack **resultp, struct varobj *var,
2208 int only_children_p)
2212 delete_variable_1 (resultp, &delcount, var,
2213 only_children_p, 1 /* remove_from_parent_p */ );
2218 /* Delete the variable object VAR and its children. */
2219 /* IMPORTANT NOTE: If we delete a variable which is a child
2220 and the parent is not removed we dump core. It must be always
2221 initially called with remove_from_parent_p set. */
2223 delete_variable_1 (struct cpstack **resultp, int *delcountp,
2224 struct varobj *var, int only_children_p,
2225 int remove_from_parent_p)
2229 /* Delete any children of this variable, too. */
2230 for (i = 0; i < VEC_length (varobj_p, var->children); ++i)
2232 varobj_p child = VEC_index (varobj_p, var->children, i);
2236 if (!remove_from_parent_p)
2237 child->parent = NULL;
2238 delete_variable_1 (resultp, delcountp, child, 0, only_children_p);
2240 VEC_free (varobj_p, var->children);
2242 /* if we were called to delete only the children we are done here. */
2243 if (only_children_p)
2246 /* Otherwise, add it to the list of deleted ones and proceed to do so. */
2247 /* If the name is null, this is a temporary variable, that has not
2248 yet been installed, don't report it, it belongs to the caller... */
2249 if (var->obj_name != NULL)
2251 cppush (resultp, xstrdup (var->obj_name));
2252 *delcountp = *delcountp + 1;
2255 /* If this variable has a parent, remove it from its parent's list. */
2256 /* OPTIMIZATION: if the parent of this variable is also being deleted,
2257 (as indicated by remove_from_parent_p) we don't bother doing an
2258 expensive list search to find the element to remove when we are
2259 discarding the list afterwards. */
2260 if ((remove_from_parent_p) && (var->parent != NULL))
2262 VEC_replace (varobj_p, var->parent->children, var->index, NULL);
2265 if (var->obj_name != NULL)
2266 uninstall_variable (var);
2268 /* Free memory associated with this variable. */
2269 free_variable (var);
2272 /* Install the given variable VAR with the object name VAR->OBJ_NAME. */
2274 install_variable (struct varobj *var)
2277 struct vlist *newvl;
2279 unsigned int index = 0;
2282 for (chp = var->obj_name; *chp; chp++)
2284 index = (index + (i++ * (unsigned int) *chp)) % VAROBJ_TABLE_SIZE;
2287 cv = *(varobj_table + index);
2288 while ((cv != NULL) && (strcmp (cv->var->obj_name, var->obj_name) != 0))
2292 error (_("Duplicate variable object name"));
2294 /* Add varobj to hash table. */
2295 newvl = xmalloc (sizeof (struct vlist));
2296 newvl->next = *(varobj_table + index);
2298 *(varobj_table + index) = newvl;
2300 /* If root, add varobj to root list. */
2301 if (is_root_p (var))
2303 /* Add to list of root variables. */
2304 if (rootlist == NULL)
2305 var->root->next = NULL;
2307 var->root->next = rootlist;
2308 rootlist = var->root;
2314 /* Unistall the object VAR. */
2316 uninstall_variable (struct varobj *var)
2320 struct varobj_root *cr;
2321 struct varobj_root *prer;
2323 unsigned int index = 0;
2326 /* Remove varobj from hash table. */
2327 for (chp = var->obj_name; *chp; chp++)
2329 index = (index + (i++ * (unsigned int) *chp)) % VAROBJ_TABLE_SIZE;
2332 cv = *(varobj_table + index);
2334 while ((cv != NULL) && (strcmp (cv->var->obj_name, var->obj_name) != 0))
2341 fprintf_unfiltered (gdb_stdlog, "Deleting %s\n", var->obj_name);
2346 ("Assertion failed: Could not find variable object \"%s\" to delete",
2352 *(varobj_table + index) = cv->next;
2354 prev->next = cv->next;
2358 /* If root, remove varobj from root list. */
2359 if (is_root_p (var))
2361 /* Remove from list of root variables. */
2362 if (rootlist == var->root)
2363 rootlist = var->root->next;
2368 while ((cr != NULL) && (cr->rootvar != var))
2375 warning (_("Assertion failed: Could not find "
2376 "varobj \"%s\" in root list"),
2383 prer->next = cr->next;
2389 /* Create and install a child of the parent of the given name. */
2390 static struct varobj *
2391 create_child (struct varobj *parent, int index, char *name)
2393 return create_child_with_value (parent, index, name,
2394 value_of_child (parent, index));
2397 /* Does CHILD represent a child with no name? This happens when
2398 the child is an anonmous struct or union and it has no field name
2399 in its parent variable.
2401 This has already been determined by *_describe_child. The easiest
2402 thing to do is to compare the child's name with ANONYMOUS_*_NAME. */
2405 is_anonymous_child (struct varobj *child)
2407 return (strcmp (child->name, ANONYMOUS_STRUCT_NAME) == 0
2408 || strcmp (child->name, ANONYMOUS_UNION_NAME) == 0);
2411 static struct varobj *
2412 create_child_with_value (struct varobj *parent, int index, const char *name,
2413 struct value *value)
2415 struct varobj *child;
2418 child = new_variable ();
2420 /* Name is allocated by name_of_child. */
2421 /* FIXME: xstrdup should not be here. */
2422 child->name = xstrdup (name);
2423 child->index = index;
2424 child->parent = parent;
2425 child->root = parent->root;
2427 if (is_anonymous_child (child))
2428 childs_name = xstrprintf ("%s.%d_anonymous", parent->obj_name, index);
2430 childs_name = xstrprintf ("%s.%s", parent->obj_name, name);
2431 child->obj_name = childs_name;
2433 install_variable (child);
2435 /* Compute the type of the child. Must do this before
2436 calling install_new_value. */
2438 /* If the child had no evaluation errors, var->value
2439 will be non-NULL and contain a valid type. */
2440 child->type = value_actual_type (value, 0, NULL);
2442 /* Otherwise, we must compute the type. */
2443 child->type = (*child->root->lang->type_of_child) (child->parent,
2445 install_new_value (child, value, 1);
2452 * Miscellaneous utility functions.
2455 /* Allocate memory and initialize a new variable. */
2456 static struct varobj *
2461 var = (struct varobj *) xmalloc (sizeof (struct varobj));
2463 var->path_expr = NULL;
2464 var->obj_name = NULL;
2468 var->num_children = -1;
2470 var->children = NULL;
2474 var->print_value = NULL;
2476 var->not_fetched = 0;
2477 var->children_requested = 0;
2480 var->constructor = 0;
2481 var->pretty_printer = 0;
2482 var->child_iter = 0;
2483 var->saved_item = 0;
2488 /* Allocate memory and initialize a new root variable. */
2489 static struct varobj *
2490 new_root_variable (void)
2492 struct varobj *var = new_variable ();
2494 var->root = (struct varobj_root *) xmalloc (sizeof (struct varobj_root));
2495 var->root->lang = NULL;
2496 var->root->exp = NULL;
2497 var->root->valid_block = NULL;
2498 var->root->frame = null_frame_id;
2499 var->root->floating = 0;
2500 var->root->rootvar = NULL;
2501 var->root->is_valid = 1;
2506 /* Free any allocated memory associated with VAR. */
2508 free_variable (struct varobj *var)
2511 if (var->pretty_printer)
2513 struct cleanup *cleanup = varobj_ensure_python_env (var);
2514 Py_XDECREF (var->constructor);
2515 Py_XDECREF (var->pretty_printer);
2516 Py_XDECREF (var->child_iter);
2517 Py_XDECREF (var->saved_item);
2518 do_cleanups (cleanup);
2522 value_free (var->value);
2524 /* Free the expression if this is a root variable. */
2525 if (is_root_p (var))
2527 xfree (var->root->exp);
2532 xfree (var->obj_name);
2533 xfree (var->print_value);
2534 xfree (var->path_expr);
2539 do_free_variable_cleanup (void *var)
2541 free_variable (var);
2544 static struct cleanup *
2545 make_cleanup_free_variable (struct varobj *var)
2547 return make_cleanup (do_free_variable_cleanup, var);
2550 /* This returns the type of the variable. It also skips past typedefs
2551 to return the real type of the variable.
2553 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
2554 except within get_target_type and get_type. */
2555 static struct type *
2556 get_type (struct varobj *var)
2562 type = check_typedef (type);
2567 /* Return the type of the value that's stored in VAR,
2568 or that would have being stored there if the
2569 value were accessible.
2571 This differs from VAR->type in that VAR->type is always
2572 the true type of the expession in the source language.
2573 The return value of this function is the type we're
2574 actually storing in varobj, and using for displaying
2575 the values and for comparing previous and new values.
2577 For example, top-level references are always stripped. */
2578 static struct type *
2579 get_value_type (struct varobj *var)
2584 type = value_type (var->value);
2588 type = check_typedef (type);
2590 if (TYPE_CODE (type) == TYPE_CODE_REF)
2591 type = get_target_type (type);
2593 type = check_typedef (type);
2598 /* This returns the target type (or NULL) of TYPE, also skipping
2599 past typedefs, just like get_type ().
2601 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
2602 except within get_target_type and get_type. */
2603 static struct type *
2604 get_target_type (struct type *type)
2608 type = TYPE_TARGET_TYPE (type);
2610 type = check_typedef (type);
2616 /* What is the default display for this variable? We assume that
2617 everything is "natural". Any exceptions? */
2618 static enum varobj_display_formats
2619 variable_default_display (struct varobj *var)
2621 return FORMAT_NATURAL;
2624 /* FIXME: The following should be generic for any pointer. */
2626 cppush (struct cpstack **pstack, char *name)
2630 s = (struct cpstack *) xmalloc (sizeof (struct cpstack));
2636 /* FIXME: The following should be generic for any pointer. */
2638 cppop (struct cpstack **pstack)
2643 if ((*pstack)->name == NULL && (*pstack)->next == NULL)
2648 *pstack = (*pstack)->next;
2655 * Language-dependencies
2658 /* Common entry points */
2660 /* Get the language of variable VAR. */
2661 static enum varobj_languages
2662 variable_language (struct varobj *var)
2664 enum varobj_languages lang;
2666 switch (var->root->exp->language_defn->la_language)
2672 case language_cplus:
2686 /* Return the number of children for a given variable.
2687 The result of this function is defined by the language
2688 implementation. The number of children returned by this function
2689 is the number of children that the user will see in the variable
2692 number_of_children (struct varobj *var)
2694 return (*var->root->lang->number_of_children) (var);
2697 /* What is the expression for the root varobj VAR? Returns a malloc'd
2700 name_of_variable (struct varobj *var)
2702 return (*var->root->lang->name_of_variable) (var);
2705 /* What is the name of the INDEX'th child of VAR? Returns a malloc'd
2708 name_of_child (struct varobj *var, int index)
2710 return (*var->root->lang->name_of_child) (var, index);
2713 /* What is the ``struct value *'' of the root variable VAR?
2714 For floating variable object, evaluation can get us a value
2715 of different type from what is stored in varobj already. In
2717 - *type_changed will be set to 1
2718 - old varobj will be freed, and new one will be
2719 created, with the same name.
2720 - *var_handle will be set to the new varobj
2721 Otherwise, *type_changed will be set to 0. */
2722 static struct value *
2723 value_of_root (struct varobj **var_handle, int *type_changed)
2727 if (var_handle == NULL)
2732 /* This should really be an exception, since this should
2733 only get called with a root variable. */
2735 if (!is_root_p (var))
2738 if (var->root->floating)
2740 struct varobj *tmp_var;
2741 char *old_type, *new_type;
2743 tmp_var = varobj_create (NULL, var->name, (CORE_ADDR) 0,
2744 USE_SELECTED_FRAME);
2745 if (tmp_var == NULL)
2749 old_type = varobj_get_type (var);
2750 new_type = varobj_get_type (tmp_var);
2751 if (strcmp (old_type, new_type) == 0)
2753 /* The expression presently stored inside var->root->exp
2754 remembers the locations of local variables relatively to
2755 the frame where the expression was created (in DWARF location
2756 button, for example). Naturally, those locations are not
2757 correct in other frames, so update the expression. */
2759 struct expression *tmp_exp = var->root->exp;
2761 var->root->exp = tmp_var->root->exp;
2762 tmp_var->root->exp = tmp_exp;
2764 varobj_delete (tmp_var, NULL, 0);
2769 tmp_var->obj_name = xstrdup (var->obj_name);
2770 tmp_var->from = var->from;
2771 tmp_var->to = var->to;
2772 varobj_delete (var, NULL, 0);
2774 install_variable (tmp_var);
2775 *var_handle = tmp_var;
2788 struct value *value;
2790 value = (*var->root->lang->value_of_root) (var_handle);
2791 if (var->value == NULL || value == NULL)
2793 /* For root varobj-s, a NULL value indicates a scoping issue.
2794 So, nothing to do in terms of checking for mutations. */
2796 else if (varobj_value_has_mutated (var, value, value_type (value)))
2798 /* The type has mutated, so the children are no longer valid.
2799 Just delete them, and tell our caller that the type has
2801 varobj_delete (var, NULL, 1 /* only_children */);
2802 var->num_children = -1;
2811 /* What is the ``struct value *'' for the INDEX'th child of PARENT? */
2812 static struct value *
2813 value_of_child (struct varobj *parent, int index)
2815 struct value *value;
2817 value = (*parent->root->lang->value_of_child) (parent, index);
2822 /* GDB already has a command called "value_of_variable". Sigh. */
2824 my_value_of_variable (struct varobj *var, enum varobj_display_formats format)
2826 if (var->root->is_valid)
2828 if (var->pretty_printer)
2829 return value_get_print_value (var->value, var->format, var);
2830 return (*var->root->lang->value_of_variable) (var, format);
2837 value_get_print_value (struct value *value, enum varobj_display_formats format,
2840 struct ui_file *stb;
2841 struct cleanup *old_chain;
2842 char *thevalue = NULL;
2843 struct value_print_options opts;
2844 struct type *type = NULL;
2846 char *encoding = NULL;
2847 struct gdbarch *gdbarch = NULL;
2848 /* Initialize it just to avoid a GCC false warning. */
2849 CORE_ADDR str_addr = 0;
2850 int string_print = 0;
2855 stb = mem_fileopen ();
2856 old_chain = make_cleanup_ui_file_delete (stb);
2858 gdbarch = get_type_arch (value_type (value));
2860 if (gdb_python_initialized)
2862 PyObject *value_formatter = var->pretty_printer;
2864 varobj_ensure_python_env (var);
2866 if (value_formatter)
2868 /* First check to see if we have any children at all. If so,
2869 we simply return {...}. */
2870 if (dynamic_varobj_has_child_method (var))
2872 do_cleanups (old_chain);
2873 return xstrdup ("{...}");
2876 if (PyObject_HasAttr (value_formatter, gdbpy_to_string_cst))
2878 struct value *replacement;
2879 PyObject *output = NULL;
2881 output = apply_varobj_pretty_printer (value_formatter,
2885 /* If we have string like output ... */
2888 make_cleanup_py_decref (output);
2890 /* If this is a lazy string, extract it. For lazy
2891 strings we always print as a string, so set
2893 if (gdbpy_is_lazy_string (output))
2895 gdbpy_extract_lazy_string (output, &str_addr, &type,
2897 make_cleanup (free_current_contents, &encoding);
2902 /* If it is a regular (non-lazy) string, extract
2903 it and copy the contents into THEVALUE. If the
2904 hint says to print it as a string, set
2905 string_print. Otherwise just return the extracted
2906 string as a value. */
2908 char *s = python_string_to_target_string (output);
2914 hint = gdbpy_get_display_hint (value_formatter);
2917 if (!strcmp (hint, "string"))
2923 thevalue = xmemdup (s, len + 1, len + 1);
2924 type = builtin_type (gdbarch)->builtin_char;
2929 do_cleanups (old_chain);
2933 make_cleanup (xfree, thevalue);
2936 gdbpy_print_stack ();
2939 /* If the printer returned a replacement value, set VALUE
2940 to REPLACEMENT. If there is not a replacement value,
2941 just use the value passed to this function. */
2943 value = replacement;
2949 get_formatted_print_options (&opts, format_code[(int) format]);
2953 /* If the THEVALUE has contents, it is a regular string. */
2955 LA_PRINT_STRING (stb, type, (gdb_byte *) thevalue, len, encoding, 0, &opts);
2956 else if (string_print)
2957 /* Otherwise, if string_print is set, and it is not a regular
2958 string, it is a lazy string. */
2959 val_print_string (type, encoding, str_addr, len, stb, &opts);
2961 /* All other cases. */
2962 common_val_print (value, stb, 0, &opts, current_language);
2964 thevalue = ui_file_xstrdup (stb, NULL);
2966 do_cleanups (old_chain);
2971 varobj_editable_p (struct varobj *var)
2975 if (!(var->root->is_valid && var->value && VALUE_LVAL (var->value)))
2978 type = get_value_type (var);
2980 switch (TYPE_CODE (type))
2982 case TYPE_CODE_STRUCT:
2983 case TYPE_CODE_UNION:
2984 case TYPE_CODE_ARRAY:
2985 case TYPE_CODE_FUNC:
2986 case TYPE_CODE_METHOD:
2996 /* Call VAR's value_is_changeable_p language-specific callback. */
2999 varobj_value_is_changeable_p (struct varobj *var)
3001 return var->root->lang->value_is_changeable_p (var);
3004 /* Return 1 if that varobj is floating, that is is always evaluated in the
3005 selected frame, and not bound to thread/frame. Such variable objects
3006 are created using '@' as frame specifier to -var-create. */
3008 varobj_floating_p (struct varobj *var)
3010 return var->root->floating;
3013 /* Given the value and the type of a variable object,
3014 adjust the value and type to those necessary
3015 for getting children of the variable object.
3016 This includes dereferencing top-level references
3017 to all types and dereferencing pointers to
3020 If LOOKUP_ACTUAL_TYPE is set the enclosing type of the
3021 value will be fetched and if it differs from static type
3022 the value will be casted to it.
3024 Both TYPE and *TYPE should be non-null. VALUE
3025 can be null if we want to only translate type.
3026 *VALUE can be null as well -- if the parent
3029 If WAS_PTR is not NULL, set *WAS_PTR to 0 or 1
3030 depending on whether pointer was dereferenced
3031 in this function. */
3033 adjust_value_for_child_access (struct value **value,
3036 int lookup_actual_type)
3038 gdb_assert (type && *type);
3043 *type = check_typedef (*type);
3045 /* The type of value stored in varobj, that is passed
3046 to us, is already supposed to be
3047 reference-stripped. */
3049 gdb_assert (TYPE_CODE (*type) != TYPE_CODE_REF);
3051 /* Pointers to structures are treated just like
3052 structures when accessing children. Don't
3053 dererences pointers to other types. */
3054 if (TYPE_CODE (*type) == TYPE_CODE_PTR)
3056 struct type *target_type = get_target_type (*type);
3057 if (TYPE_CODE (target_type) == TYPE_CODE_STRUCT
3058 || TYPE_CODE (target_type) == TYPE_CODE_UNION)
3060 if (value && *value)
3062 volatile struct gdb_exception except;
3064 TRY_CATCH (except, RETURN_MASK_ERROR)
3066 *value = value_ind (*value);
3069 if (except.reason < 0)
3072 *type = target_type;
3078 /* The 'get_target_type' function calls check_typedef on
3079 result, so we can immediately check type code. No
3080 need to call check_typedef here. */
3082 /* Access a real type of the value (if necessary and possible). */
3083 if (value && *value && lookup_actual_type)
3085 struct type *enclosing_type;
3086 int real_type_found = 0;
3088 enclosing_type = value_actual_type (*value, 1, &real_type_found);
3089 if (real_type_found)
3091 *type = enclosing_type;
3092 *value = value_cast (enclosing_type, *value);
3097 /* Implement the "value_is_changeable_p" varobj callback for most
3101 default_value_is_changeable_p (struct varobj *var)
3106 if (CPLUS_FAKE_CHILD (var))
3109 type = get_value_type (var);
3111 switch (TYPE_CODE (type))
3113 case TYPE_CODE_STRUCT:
3114 case TYPE_CODE_UNION:
3115 case TYPE_CODE_ARRAY:
3129 c_number_of_children (struct varobj *var)
3131 struct type *type = get_value_type (var);
3133 struct type *target;
3135 adjust_value_for_child_access (NULL, &type, NULL, 0);
3136 target = get_target_type (type);
3138 switch (TYPE_CODE (type))
3140 case TYPE_CODE_ARRAY:
3141 if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (target) > 0
3142 && !TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type))
3143 children = TYPE_LENGTH (type) / TYPE_LENGTH (target);
3145 /* If we don't know how many elements there are, don't display
3150 case TYPE_CODE_STRUCT:
3151 case TYPE_CODE_UNION:
3152 children = TYPE_NFIELDS (type);
3156 /* The type here is a pointer to non-struct. Typically, pointers
3157 have one child, except for function ptrs, which have no children,
3158 and except for void*, as we don't know what to show.
3160 We can show char* so we allow it to be dereferenced. If you decide
3161 to test for it, please mind that a little magic is necessary to
3162 properly identify it: char* has TYPE_CODE == TYPE_CODE_INT and
3163 TYPE_NAME == "char". */
3164 if (TYPE_CODE (target) == TYPE_CODE_FUNC
3165 || TYPE_CODE (target) == TYPE_CODE_VOID)
3172 /* Other types have no children. */
3180 c_name_of_variable (struct varobj *parent)
3182 return xstrdup (parent->name);
3185 /* Return the value of element TYPE_INDEX of a structure
3186 value VALUE. VALUE's type should be a structure,
3187 or union, or a typedef to struct/union.
3189 Returns NULL if getting the value fails. Never throws. */
3190 static struct value *
3191 value_struct_element_index (struct value *value, int type_index)
3193 struct value *result = NULL;
3194 volatile struct gdb_exception e;
3195 struct type *type = value_type (value);
3197 type = check_typedef (type);
3199 gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
3200 || TYPE_CODE (type) == TYPE_CODE_UNION);
3202 TRY_CATCH (e, RETURN_MASK_ERROR)
3204 if (field_is_static (&TYPE_FIELD (type, type_index)))
3205 result = value_static_field (type, type_index);
3207 result = value_primitive_field (value, 0, type_index, type);
3219 /* Obtain the information about child INDEX of the variable
3221 If CNAME is not null, sets *CNAME to the name of the child relative
3223 If CVALUE is not null, sets *CVALUE to the value of the child.
3224 If CTYPE is not null, sets *CTYPE to the type of the child.
3226 If any of CNAME, CVALUE, or CTYPE is not null, but the corresponding
3227 information cannot be determined, set *CNAME, *CVALUE, or *CTYPE
3230 c_describe_child (struct varobj *parent, int index,
3231 char **cname, struct value **cvalue, struct type **ctype,
3232 char **cfull_expression)
3234 struct value *value = parent->value;
3235 struct type *type = get_value_type (parent);
3236 char *parent_expression = NULL;
3238 volatile struct gdb_exception except;
3246 if (cfull_expression)
3248 *cfull_expression = NULL;
3249 parent_expression = varobj_get_path_expr (get_path_expr_parent (parent));
3251 adjust_value_for_child_access (&value, &type, &was_ptr, 0);
3253 switch (TYPE_CODE (type))
3255 case TYPE_CODE_ARRAY:
3258 = xstrdup (int_string (index
3259 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)),
3262 if (cvalue && value)
3264 int real_index = index + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type));
3266 TRY_CATCH (except, RETURN_MASK_ERROR)
3268 *cvalue = value_subscript (value, real_index);
3273 *ctype = get_target_type (type);
3275 if (cfull_expression)
3277 xstrprintf ("(%s)[%s]", parent_expression,
3279 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)),
3285 case TYPE_CODE_STRUCT:
3286 case TYPE_CODE_UNION:
3288 const char *field_name;
3290 /* If the type is anonymous and the field has no name,
3291 set an appropriate name. */
3292 field_name = TYPE_FIELD_NAME (type, index);
3293 if (field_name == NULL || *field_name == '\0')
3297 if (TYPE_CODE (TYPE_FIELD_TYPE (type, index))
3298 == TYPE_CODE_STRUCT)
3299 *cname = xstrdup (ANONYMOUS_STRUCT_NAME);
3301 *cname = xstrdup (ANONYMOUS_UNION_NAME);
3304 if (cfull_expression)
3305 *cfull_expression = xstrdup ("");
3310 *cname = xstrdup (field_name);
3312 if (cfull_expression)
3314 char *join = was_ptr ? "->" : ".";
3316 *cfull_expression = xstrprintf ("(%s)%s%s", parent_expression,
3321 if (cvalue && value)
3323 /* For C, varobj index is the same as type index. */
3324 *cvalue = value_struct_element_index (value, index);
3328 *ctype = TYPE_FIELD_TYPE (type, index);
3334 *cname = xstrprintf ("*%s", parent->name);
3336 if (cvalue && value)
3338 TRY_CATCH (except, RETURN_MASK_ERROR)
3340 *cvalue = value_ind (value);
3343 if (except.reason < 0)
3347 /* Don't use get_target_type because it calls
3348 check_typedef and here, we want to show the true
3349 declared type of the variable. */
3351 *ctype = TYPE_TARGET_TYPE (type);
3353 if (cfull_expression)
3354 *cfull_expression = xstrprintf ("*(%s)", parent_expression);
3359 /* This should not happen. */
3361 *cname = xstrdup ("???");
3362 if (cfull_expression)
3363 *cfull_expression = xstrdup ("???");
3364 /* Don't set value and type, we don't know then. */
3369 c_name_of_child (struct varobj *parent, int index)
3373 c_describe_child (parent, index, &name, NULL, NULL, NULL);
3378 c_path_expr_of_child (struct varobj *child)
3380 c_describe_child (child->parent, child->index, NULL, NULL, NULL,
3382 return child->path_expr;
3385 /* If frame associated with VAR can be found, switch
3386 to it and return 1. Otherwise, return 0. */
3388 check_scope (struct varobj *var)
3390 struct frame_info *fi;
3393 fi = frame_find_by_id (var->root->frame);
3398 CORE_ADDR pc = get_frame_pc (fi);
3400 if (pc < BLOCK_START (var->root->valid_block) ||
3401 pc >= BLOCK_END (var->root->valid_block))
3409 static struct value *
3410 c_value_of_root (struct varobj **var_handle)
3412 struct value *new_val = NULL;
3413 struct varobj *var = *var_handle;
3414 int within_scope = 0;
3415 struct cleanup *back_to;
3417 /* Only root variables can be updated... */
3418 if (!is_root_p (var))
3419 /* Not a root var. */
3422 back_to = make_cleanup_restore_current_thread ();
3424 /* Determine whether the variable is still around. */
3425 if (var->root->valid_block == NULL || var->root->floating)
3427 else if (var->root->thread_id == 0)
3429 /* The program was single-threaded when the variable object was
3430 created. Technically, it's possible that the program became
3431 multi-threaded since then, but we don't support such
3433 within_scope = check_scope (var);
3437 ptid_t ptid = thread_id_to_pid (var->root->thread_id);
3438 if (in_thread_list (ptid))
3440 switch_to_thread (ptid);
3441 within_scope = check_scope (var);
3447 volatile struct gdb_exception except;
3449 /* We need to catch errors here, because if evaluate
3450 expression fails we want to just return NULL. */
3451 TRY_CATCH (except, RETURN_MASK_ERROR)
3453 new_val = evaluate_expression (var->root->exp);
3457 do_cleanups (back_to);
3462 static struct value *
3463 c_value_of_child (struct varobj *parent, int index)
3465 struct value *value = NULL;
3467 c_describe_child (parent, index, NULL, &value, NULL, NULL);
3471 static struct type *
3472 c_type_of_child (struct varobj *parent, int index)
3474 struct type *type = NULL;
3476 c_describe_child (parent, index, NULL, NULL, &type, NULL);
3481 c_value_of_variable (struct varobj *var, enum varobj_display_formats format)
3483 /* BOGUS: if val_print sees a struct/class, or a reference to one,
3484 it will print out its children instead of "{...}". So we need to
3485 catch that case explicitly. */
3486 struct type *type = get_type (var);
3488 /* Strip top-level references. */
3489 while (TYPE_CODE (type) == TYPE_CODE_REF)
3490 type = check_typedef (TYPE_TARGET_TYPE (type));
3492 switch (TYPE_CODE (type))
3494 case TYPE_CODE_STRUCT:
3495 case TYPE_CODE_UNION:
3496 return xstrdup ("{...}");
3499 case TYPE_CODE_ARRAY:
3503 number = xstrprintf ("[%d]", var->num_children);
3510 if (var->value == NULL)
3512 /* This can happen if we attempt to get the value of a struct
3513 member when the parent is an invalid pointer. This is an
3514 error condition, so we should tell the caller. */
3519 if (var->not_fetched && value_lazy (var->value))
3520 /* Frozen variable and no value yet. We don't
3521 implicitly fetch the value. MI response will
3522 use empty string for the value, which is OK. */
3525 gdb_assert (varobj_value_is_changeable_p (var));
3526 gdb_assert (!value_lazy (var->value));
3528 /* If the specified format is the current one,
3529 we can reuse print_value. */
3530 if (format == var->format)
3531 return xstrdup (var->print_value);
3533 return value_get_print_value (var->value, format, var);
3543 cplus_number_of_children (struct varobj *var)
3545 struct value *value = NULL;
3547 int children, dont_know;
3548 int lookup_actual_type = 0;
3549 struct value_print_options opts;
3554 get_user_print_options (&opts);
3556 if (!CPLUS_FAKE_CHILD (var))
3558 type = get_value_type (var);
3560 /* It is necessary to access a real type (via RTTI). */
3561 if (opts.objectprint)
3564 lookup_actual_type = (TYPE_CODE (var->type) == TYPE_CODE_REF
3565 || TYPE_CODE (var->type) == TYPE_CODE_PTR);
3567 adjust_value_for_child_access (&value, &type, NULL, lookup_actual_type);
3569 if (((TYPE_CODE (type)) == TYPE_CODE_STRUCT) ||
3570 ((TYPE_CODE (type)) == TYPE_CODE_UNION))
3574 cplus_class_num_children (type, kids);
3575 if (kids[v_public] != 0)
3577 if (kids[v_private] != 0)
3579 if (kids[v_protected] != 0)
3582 /* Add any baseclasses. */
3583 children += TYPE_N_BASECLASSES (type);
3586 /* FIXME: save children in var. */
3593 type = get_value_type (var->parent);
3595 /* It is necessary to access a real type (via RTTI). */
3596 if (opts.objectprint)
3598 struct varobj *parent = var->parent;
3600 value = parent->value;
3601 lookup_actual_type = (TYPE_CODE (parent->type) == TYPE_CODE_REF
3602 || TYPE_CODE (parent->type) == TYPE_CODE_PTR);
3604 adjust_value_for_child_access (&value, &type, NULL, lookup_actual_type);
3606 cplus_class_num_children (type, kids);
3607 if (strcmp (var->name, "public") == 0)
3608 children = kids[v_public];
3609 else if (strcmp (var->name, "private") == 0)
3610 children = kids[v_private];
3612 children = kids[v_protected];
3617 children = c_number_of_children (var);
3622 /* Compute # of public, private, and protected variables in this class.
3623 That means we need to descend into all baseclasses and find out
3624 how many are there, too. */
3626 cplus_class_num_children (struct type *type, int children[3])
3628 int i, vptr_fieldno;
3629 struct type *basetype = NULL;
3631 children[v_public] = 0;
3632 children[v_private] = 0;
3633 children[v_protected] = 0;
3635 vptr_fieldno = get_vptr_fieldno (type, &basetype);
3636 for (i = TYPE_N_BASECLASSES (type); i < TYPE_NFIELDS (type); i++)
3638 /* If we have a virtual table pointer, omit it. Even if virtual
3639 table pointers are not specifically marked in the debug info,
3640 they should be artificial. */
3641 if ((type == basetype && i == vptr_fieldno)
3642 || TYPE_FIELD_ARTIFICIAL (type, i))
3645 if (TYPE_FIELD_PROTECTED (type, i))
3646 children[v_protected]++;
3647 else if (TYPE_FIELD_PRIVATE (type, i))
3648 children[v_private]++;
3650 children[v_public]++;
3655 cplus_name_of_variable (struct varobj *parent)
3657 return c_name_of_variable (parent);
3660 enum accessibility { private_field, protected_field, public_field };
3662 /* Check if field INDEX of TYPE has the specified accessibility.
3663 Return 0 if so and 1 otherwise. */
3665 match_accessibility (struct type *type, int index, enum accessibility acc)
3667 if (acc == private_field && TYPE_FIELD_PRIVATE (type, index))
3669 else if (acc == protected_field && TYPE_FIELD_PROTECTED (type, index))
3671 else if (acc == public_field && !TYPE_FIELD_PRIVATE (type, index)
3672 && !TYPE_FIELD_PROTECTED (type, index))
3679 cplus_describe_child (struct varobj *parent, int index,
3680 char **cname, struct value **cvalue, struct type **ctype,
3681 char **cfull_expression)
3683 struct value *value;
3686 int lookup_actual_type = 0;
3687 char *parent_expression = NULL;
3689 struct value_print_options opts;
3697 if (cfull_expression)
3698 *cfull_expression = NULL;
3700 get_user_print_options (&opts);
3702 var = (CPLUS_FAKE_CHILD (parent)) ? parent->parent : parent;
3703 if (opts.objectprint)
3704 lookup_actual_type = (TYPE_CODE (var->type) == TYPE_CODE_REF
3705 || TYPE_CODE (var->type) == TYPE_CODE_PTR);
3707 type = get_value_type (var);
3708 if (cfull_expression)
3709 parent_expression = varobj_get_path_expr (get_path_expr_parent (var));
3711 adjust_value_for_child_access (&value, &type, &was_ptr, lookup_actual_type);
3713 if (TYPE_CODE (type) == TYPE_CODE_STRUCT
3714 || TYPE_CODE (type) == TYPE_CODE_UNION)
3716 char *join = was_ptr ? "->" : ".";
3718 if (CPLUS_FAKE_CHILD (parent))
3720 /* The fields of the class type are ordered as they
3721 appear in the class. We are given an index for a
3722 particular access control type ("public","protected",
3723 or "private"). We must skip over fields that don't
3724 have the access control we are looking for to properly
3725 find the indexed field. */
3726 int type_index = TYPE_N_BASECLASSES (type);
3727 enum accessibility acc = public_field;
3729 struct type *basetype = NULL;
3730 const char *field_name;
3732 vptr_fieldno = get_vptr_fieldno (type, &basetype);
3733 if (strcmp (parent->name, "private") == 0)
3734 acc = private_field;
3735 else if (strcmp (parent->name, "protected") == 0)
3736 acc = protected_field;
3740 if ((type == basetype && type_index == vptr_fieldno)
3741 || TYPE_FIELD_ARTIFICIAL (type, type_index))
3743 else if (match_accessibility (type, type_index, acc))
3749 /* If the type is anonymous and the field has no name,
3750 set an appopriate name. */
3751 field_name = TYPE_FIELD_NAME (type, type_index);
3752 if (field_name == NULL || *field_name == '\0')
3756 if (TYPE_CODE (TYPE_FIELD_TYPE (type, type_index))
3757 == TYPE_CODE_STRUCT)
3758 *cname = xstrdup (ANONYMOUS_STRUCT_NAME);
3759 else if (TYPE_CODE (TYPE_FIELD_TYPE (type, type_index))
3761 *cname = xstrdup (ANONYMOUS_UNION_NAME);
3764 if (cfull_expression)
3765 *cfull_expression = xstrdup ("");
3770 *cname = xstrdup (TYPE_FIELD_NAME (type, type_index));
3772 if (cfull_expression)
3774 = xstrprintf ("((%s)%s%s)", parent_expression, join,
3778 if (cvalue && value)
3779 *cvalue = value_struct_element_index (value, type_index);
3782 *ctype = TYPE_FIELD_TYPE (type, type_index);
3784 else if (index < TYPE_N_BASECLASSES (type))
3786 /* This is a baseclass. */
3788 *cname = xstrdup (TYPE_FIELD_NAME (type, index));
3790 if (cvalue && value)
3791 *cvalue = value_cast (TYPE_FIELD_TYPE (type, index), value);
3795 *ctype = TYPE_FIELD_TYPE (type, index);
3798 if (cfull_expression)
3800 char *ptr = was_ptr ? "*" : "";
3802 /* Cast the parent to the base' type. Note that in gdb,
3805 will create an lvalue, for all appearences, so we don't
3806 need to use more fancy:
3810 When we are in the scope of the base class or of one
3811 of its children, the type field name will be interpreted
3812 as a constructor, if it exists. Therefore, we must
3813 indicate that the name is a class name by using the
3814 'class' keyword. See PR mi/11912 */
3815 *cfull_expression = xstrprintf ("(%s(class %s%s) %s)",
3817 TYPE_FIELD_NAME (type, index),
3824 char *access = NULL;
3827 cplus_class_num_children (type, children);
3829 /* Everything beyond the baseclasses can
3830 only be "public", "private", or "protected"
3832 The special "fake" children are always output by varobj in
3833 this order. So if INDEX == 2, it MUST be "protected". */
3834 index -= TYPE_N_BASECLASSES (type);
3838 if (children[v_public] > 0)
3840 else if (children[v_private] > 0)
3843 access = "protected";
3846 if (children[v_public] > 0)
3848 if (children[v_private] > 0)
3851 access = "protected";
3853 else if (children[v_private] > 0)
3854 access = "protected";
3857 /* Must be protected. */
3858 access = "protected";
3865 gdb_assert (access);
3867 *cname = xstrdup (access);
3869 /* Value and type and full expression are null here. */
3874 c_describe_child (parent, index, cname, cvalue, ctype, cfull_expression);
3879 cplus_name_of_child (struct varobj *parent, int index)
3883 cplus_describe_child (parent, index, &name, NULL, NULL, NULL);
3888 cplus_path_expr_of_child (struct varobj *child)
3890 cplus_describe_child (child->parent, child->index, NULL, NULL, NULL,
3892 return child->path_expr;
3895 static struct value *
3896 cplus_value_of_root (struct varobj **var_handle)
3898 return c_value_of_root (var_handle);
3901 static struct value *
3902 cplus_value_of_child (struct varobj *parent, int index)
3904 struct value *value = NULL;
3906 cplus_describe_child (parent, index, NULL, &value, NULL, NULL);
3910 static struct type *
3911 cplus_type_of_child (struct varobj *parent, int index)
3913 struct type *type = NULL;
3915 cplus_describe_child (parent, index, NULL, NULL, &type, NULL);
3920 cplus_value_of_variable (struct varobj *var,
3921 enum varobj_display_formats format)
3924 /* If we have one of our special types, don't print out
3926 if (CPLUS_FAKE_CHILD (var))
3927 return xstrdup ("");
3929 return c_value_of_variable (var, format);
3935 java_number_of_children (struct varobj *var)
3937 return cplus_number_of_children (var);
3941 java_name_of_variable (struct varobj *parent)
3945 name = cplus_name_of_variable (parent);
3946 /* If the name has "-" in it, it is because we
3947 needed to escape periods in the name... */
3950 while (*p != '\000')
3961 java_name_of_child (struct varobj *parent, int index)
3965 name = cplus_name_of_child (parent, index);
3966 /* Escape any periods in the name... */
3969 while (*p != '\000')
3980 java_path_expr_of_child (struct varobj *child)
3985 static struct value *
3986 java_value_of_root (struct varobj **var_handle)
3988 return cplus_value_of_root (var_handle);
3991 static struct value *
3992 java_value_of_child (struct varobj *parent, int index)
3994 return cplus_value_of_child (parent, index);
3997 static struct type *
3998 java_type_of_child (struct varobj *parent, int index)
4000 return cplus_type_of_child (parent, index);
4004 java_value_of_variable (struct varobj *var, enum varobj_display_formats format)
4006 return cplus_value_of_variable (var, format);
4009 /* Ada specific callbacks for VAROBJs. */
4012 ada_number_of_children (struct varobj *var)
4014 return ada_varobj_get_number_of_children (var->value, var->type);
4018 ada_name_of_variable (struct varobj *parent)
4020 return c_name_of_variable (parent);
4024 ada_name_of_child (struct varobj *parent, int index)
4026 return ada_varobj_get_name_of_child (parent->value, parent->type,
4027 parent->name, index);
4031 ada_path_expr_of_child (struct varobj *child)
4033 struct varobj *parent = child->parent;
4034 const char *parent_path_expr = varobj_get_path_expr (parent);
4036 return ada_varobj_get_path_expr_of_child (parent->value,
4043 static struct value *
4044 ada_value_of_root (struct varobj **var_handle)
4046 return c_value_of_root (var_handle);
4049 static struct value *
4050 ada_value_of_child (struct varobj *parent, int index)
4052 return ada_varobj_get_value_of_child (parent->value, parent->type,
4053 parent->name, index);
4056 static struct type *
4057 ada_type_of_child (struct varobj *parent, int index)
4059 return ada_varobj_get_type_of_child (parent->value, parent->type,
4064 ada_value_of_variable (struct varobj *var, enum varobj_display_formats format)
4066 struct value_print_options opts;
4068 get_formatted_print_options (&opts, format_code[(int) format]);
4072 return ada_varobj_get_value_of_variable (var->value, var->type, &opts);
4075 /* Implement the "value_is_changeable_p" routine for Ada. */
4078 ada_value_is_changeable_p (struct varobj *var)
4080 struct type *type = var->value ? value_type (var->value) : var->type;
4082 if (ada_is_array_descriptor_type (type)
4083 && TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
4085 /* This is in reality a pointer to an unconstrained array.
4086 its value is changeable. */
4090 if (ada_is_string_type (type))
4092 /* We display the contents of the string in the array's
4093 "value" field. The contents can change, so consider
4094 that the array is changeable. */
4098 return default_value_is_changeable_p (var);
4101 /* Implement the "value_has_mutated" routine for Ada. */
4104 ada_value_has_mutated (struct varobj *var, struct value *new_val,
4105 struct type *new_type)
4111 /* If the number of fields have changed, then for sure the type
4113 if (ada_varobj_get_number_of_children (new_val, new_type)
4114 != var->num_children)
4117 /* If the number of fields have remained the same, then we need
4118 to check the name of each field. If they remain the same,
4119 then chances are the type hasn't mutated. This is technically
4120 an incomplete test, as the child's type might have changed
4121 despite the fact that the name remains the same. But we'll
4122 handle this situation by saying that the child has mutated,
4125 If only part (or none!) of the children have been fetched,
4126 then only check the ones we fetched. It does not matter
4127 to the frontend whether a child that it has not fetched yet
4128 has mutated or not. So just assume it hasn't. */
4130 restrict_range (var->children, &from, &to);
4131 for (i = from; i < to; i++)
4132 if (strcmp (ada_varobj_get_name_of_child (new_val, new_type,
4134 VEC_index (varobj_p, var->children, i)->name) != 0)
4140 /* Iterate all the existing _root_ VAROBJs and call the FUNC callback for them
4141 with an arbitrary caller supplied DATA pointer. */
4144 all_root_varobjs (void (*func) (struct varobj *var, void *data), void *data)
4146 struct varobj_root *var_root, *var_root_next;
4148 /* Iterate "safely" - handle if the callee deletes its passed VAROBJ. */
4150 for (var_root = rootlist; var_root != NULL; var_root = var_root_next)
4152 var_root_next = var_root->next;
4154 (*func) (var_root->rootvar, data);
4158 extern void _initialize_varobj (void);
4160 _initialize_varobj (void)
4162 int sizeof_table = sizeof (struct vlist *) * VAROBJ_TABLE_SIZE;
4164 varobj_table = xmalloc (sizeof_table);
4165 memset (varobj_table, 0, sizeof_table);
4167 add_setshow_zuinteger_cmd ("debugvarobj", class_maintenance,
4169 _("Set varobj debugging."),
4170 _("Show varobj debugging."),
4171 _("When non-zero, varobj debugging is enabled."),
4172 NULL, show_varobjdebug,
4173 &setlist, &showlist);
4176 /* Invalidate varobj VAR if it is tied to locals and re-create it if it is
4177 defined on globals. It is a helper for varobj_invalidate.
4179 This function is called after changing the symbol file, in this case the
4180 pointers to "struct type" stored by the varobj are no longer valid. All
4181 varobj must be either re-evaluated, or marked as invalid here. */
4184 varobj_invalidate_iter (struct varobj *var, void *unused)
4186 /* global and floating var must be re-evaluated. */
4187 if (var->root->floating || var->root->valid_block == NULL)
4189 struct varobj *tmp_var;
4191 /* Try to create a varobj with same expression. If we succeed
4192 replace the old varobj, otherwise invalidate it. */
4193 tmp_var = varobj_create (NULL, var->name, (CORE_ADDR) 0,
4195 if (tmp_var != NULL)
4197 tmp_var->obj_name = xstrdup (var->obj_name);
4198 varobj_delete (var, NULL, 0);
4199 install_variable (tmp_var);
4202 var->root->is_valid = 0;
4204 else /* locals must be invalidated. */
4205 var->root->is_valid = 0;
4208 /* Invalidate the varobjs that are tied to locals and re-create the ones that
4209 are defined on globals.
4210 Invalidated varobjs will be always printed in_scope="invalid". */
4213 varobj_invalidate (void)
4215 all_root_varobjs (varobj_invalidate_iter, NULL);