1 /* Implementation of the GDB variable objects API.
3 Copyright (C) 1999-2014 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"
30 #include "gdb_regex.h"
34 #include "gdbthread.h"
38 #include "python/python.h"
39 #include "python/python-internal.h"
44 /* Non-zero if we want to see trace of varobj level stuff. */
46 unsigned int varobjdebug = 0;
48 show_varobjdebug (struct ui_file *file, int from_tty,
49 struct cmd_list_element *c, const char *value)
51 fprintf_filtered (file, _("Varobj debugging is %s.\n"), value);
54 /* String representations of gdb's format codes. */
55 char *varobj_format_string[] =
56 { "natural", "binary", "decimal", "hexadecimal", "octal" };
58 /* True if we want to allow Python-based pretty-printing. */
59 static int pretty_printing = 0;
62 varobj_enable_pretty_printing (void)
69 /* Every root variable has one of these structures saved in its
70 varobj. Members which must be free'd are noted. */
74 /* Alloc'd expression for this parent. */
75 struct expression *exp;
77 /* Block for which this expression is valid. */
78 const struct block *valid_block;
80 /* The frame for this expression. This field is set iff valid_block is
82 struct frame_id frame;
84 /* The thread ID that this varobj_root belong to. This field
85 is only valid if valid_block is not NULL.
86 When not 0, indicates which thread 'frame' belongs to.
87 When 0, indicates that the thread list was empty when the varobj_root
91 /* If 1, the -var-update always recomputes the value in the
92 current thread and frame. Otherwise, variable object is
93 always updated in the specific scope/thread/frame. */
96 /* Flag that indicates validity: set to 0 when this varobj_root refers
97 to symbols that do not exist anymore. */
100 /* Language-related operations for this variable and its
102 const struct lang_varobj_ops *lang_ops;
104 /* The varobj for this root node. */
105 struct varobj *rootvar;
107 /* Next root variable */
108 struct varobj_root *next;
111 /* A node or item of varobj, composed of the name and the value. */
115 /* Name of this item. */
118 /* Value of this item. */
122 /* Dynamic part of varobj. */
124 struct varobj_dynamic
126 /* Whether the children of this varobj were requested. This field is
127 used to decide if dynamic varobj should recompute their children.
128 In the event that the frontend never asked for the children, we
130 int children_requested;
132 /* The pretty-printer constructor. If NULL, then the default
133 pretty-printer will be looked up. If None, then no
134 pretty-printer will be installed. */
135 PyObject *constructor;
137 /* The pretty-printer that has been constructed. If NULL, then a
138 new printer object is needed, and one will be constructed. */
139 PyObject *pretty_printer;
141 /* The iterator returned by the printer's 'children' method, or NULL
143 PyObject *child_iter;
145 /* We request one extra item from the iterator, so that we can
146 report to the caller whether there are more items than we have
147 already reported. However, we don't want to install this value
148 when we read it, because that will mess up future updates. So,
149 we stash it here instead. */
150 PyObject *saved_item;
156 struct cpstack *next;
159 /* A list of varobjs */
167 /* Private function prototypes */
169 /* Helper functions for the above subcommands. */
171 static int delete_variable (struct cpstack **, struct varobj *, int);
173 static void delete_variable_1 (struct cpstack **, int *,
174 struct varobj *, int, int);
176 static int install_variable (struct varobj *);
178 static void uninstall_variable (struct varobj *);
180 static struct varobj *create_child (struct varobj *, int, char *);
182 static struct varobj *
183 create_child_with_value (struct varobj *parent, int index,
184 struct varobj_item *item);
186 /* Utility routines */
188 static struct varobj *new_variable (void);
190 static struct varobj *new_root_variable (void);
192 static void free_variable (struct varobj *var);
194 static struct cleanup *make_cleanup_free_variable (struct varobj *var);
196 static enum varobj_display_formats variable_default_display (struct varobj *);
198 static void cppush (struct cpstack **pstack, char *name);
200 static char *cppop (struct cpstack **pstack);
202 static int update_type_if_necessary (struct varobj *var,
203 struct value *new_value);
205 static int install_new_value (struct varobj *var, struct value *value,
208 /* Language-specific routines. */
210 static int number_of_children (struct varobj *);
212 static char *name_of_variable (struct varobj *);
214 static char *name_of_child (struct varobj *, int);
216 static struct value *value_of_root (struct varobj **var_handle, int *);
218 static struct value *value_of_child (struct varobj *parent, int index);
220 static char *my_value_of_variable (struct varobj *var,
221 enum varobj_display_formats format);
223 static int is_root_p (struct varobj *var);
227 static struct varobj *varobj_add_child (struct varobj *var,
228 struct varobj_item *item);
230 #endif /* HAVE_PYTHON */
234 /* Mappings of varobj_display_formats enums to gdb's format codes. */
235 static int format_code[] = { 0, 't', 'd', 'x', 'o' };
237 /* Header of the list of root variable objects. */
238 static struct varobj_root *rootlist;
240 /* Prime number indicating the number of buckets in the hash table. */
241 /* A prime large enough to avoid too many colisions. */
242 #define VAROBJ_TABLE_SIZE 227
244 /* Pointer to the varobj hash table (built at run time). */
245 static struct vlist **varobj_table;
249 /* API Implementation */
251 is_root_p (struct varobj *var)
253 return (var->root->rootvar == var);
257 /* Helper function to install a Python environment suitable for
258 use during operations on VAR. */
259 static struct cleanup *
260 varobj_ensure_python_env (struct varobj *var)
262 return ensure_python_env (var->root->exp->gdbarch,
263 var->root->exp->language_defn);
267 /* Creates a varobj (not its children). */
269 /* Return the full FRAME which corresponds to the given CORE_ADDR
270 or NULL if no FRAME on the chain corresponds to CORE_ADDR. */
272 static struct frame_info *
273 find_frame_addr_in_frame_chain (CORE_ADDR frame_addr)
275 struct frame_info *frame = NULL;
277 if (frame_addr == (CORE_ADDR) 0)
280 for (frame = get_current_frame ();
282 frame = get_prev_frame (frame))
284 /* The CORE_ADDR we get as argument was parsed from a string GDB
285 output as $fp. This output got truncated to gdbarch_addr_bit.
286 Truncate the frame base address in the same manner before
287 comparing it against our argument. */
288 CORE_ADDR frame_base = get_frame_base_address (frame);
289 int addr_bit = gdbarch_addr_bit (get_frame_arch (frame));
291 if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
292 frame_base &= ((CORE_ADDR) 1 << addr_bit) - 1;
294 if (frame_base == frame_addr)
302 varobj_create (char *objname,
303 char *expression, CORE_ADDR frame, enum varobj_type type)
306 struct cleanup *old_chain;
308 /* Fill out a varobj structure for the (root) variable being constructed. */
309 var = new_root_variable ();
310 old_chain = make_cleanup_free_variable (var);
312 if (expression != NULL)
314 struct frame_info *fi;
315 struct frame_id old_id = null_frame_id;
318 struct value *value = NULL;
319 volatile struct gdb_exception except;
322 /* Parse and evaluate the expression, filling in as much of the
323 variable's data as possible. */
325 if (has_stack_frames ())
327 /* Allow creator to specify context of variable. */
328 if ((type == USE_CURRENT_FRAME) || (type == USE_SELECTED_FRAME))
329 fi = get_selected_frame (NULL);
331 /* FIXME: cagney/2002-11-23: This code should be doing a
332 lookup using the frame ID and not just the frame's
333 ``address''. This, of course, means an interface
334 change. However, with out that interface change ISAs,
335 such as the ia64 with its two stacks, won't work.
336 Similar goes for the case where there is a frameless
338 fi = find_frame_addr_in_frame_chain (frame);
343 /* frame = -2 means always use selected frame. */
344 if (type == USE_SELECTED_FRAME)
345 var->root->floating = 1;
351 block = get_frame_block (fi, 0);
352 pc = get_frame_pc (fi);
356 innermost_block = NULL;
357 /* Wrap the call to parse expression, so we can
358 return a sensible error. */
359 TRY_CATCH (except, RETURN_MASK_ERROR)
361 var->root->exp = parse_exp_1 (&p, pc, block, 0);
364 if (except.reason < 0)
366 do_cleanups (old_chain);
370 /* Don't allow variables to be created for types. */
371 if (var->root->exp->elts[0].opcode == OP_TYPE
372 || var->root->exp->elts[0].opcode == OP_TYPEOF
373 || var->root->exp->elts[0].opcode == OP_DECLTYPE)
375 do_cleanups (old_chain);
376 fprintf_unfiltered (gdb_stderr, "Attempt to use a type name"
377 " as an expression.\n");
381 var->format = variable_default_display (var);
382 var->root->valid_block = innermost_block;
383 var->name = xstrdup (expression);
384 /* For a root var, the name and the expr are the same. */
385 var->path_expr = xstrdup (expression);
387 /* When the frame is different from the current frame,
388 we must select the appropriate frame before parsing
389 the expression, otherwise the value will not be current.
390 Since select_frame is so benign, just call it for all cases. */
393 /* User could specify explicit FRAME-ADDR which was not found but
394 EXPRESSION is frame specific and we would not be able to evaluate
395 it correctly next time. With VALID_BLOCK set we must also set
396 FRAME and THREAD_ID. */
398 error (_("Failed to find the specified frame"));
400 var->root->frame = get_frame_id (fi);
401 var->root->thread_id = pid_to_thread_id (inferior_ptid);
402 old_id = get_frame_id (get_selected_frame (NULL));
406 /* We definitely need to catch errors here.
407 If evaluate_expression succeeds we got the value we wanted.
408 But if it fails, we still go on with a call to evaluate_type(). */
409 TRY_CATCH (except, RETURN_MASK_ERROR)
411 value = evaluate_expression (var->root->exp);
414 if (except.reason < 0)
416 /* Error getting the value. Try to at least get the
418 struct value *type_only_value = evaluate_type (var->root->exp);
420 var->type = value_type (type_only_value);
424 int real_type_found = 0;
426 var->type = value_actual_type (value, 0, &real_type_found);
428 value = value_cast (var->type, value);
431 /* Set language info */
432 var->root->lang_ops = var->root->exp->language_defn->la_varobj_ops;
434 install_new_value (var, value, 1 /* Initial assignment */);
436 /* Set ourselves as our root. */
437 var->root->rootvar = var;
439 /* Reset the selected frame. */
440 if (frame_id_p (old_id))
441 select_frame (frame_find_by_id (old_id));
444 /* If the variable object name is null, that means this
445 is a temporary variable, so don't install it. */
447 if ((var != NULL) && (objname != NULL))
449 var->obj_name = xstrdup (objname);
451 /* If a varobj name is duplicated, the install will fail so
453 if (!install_variable (var))
455 do_cleanups (old_chain);
460 discard_cleanups (old_chain);
464 /* Generates an unique name that can be used for a varobj. */
467 varobj_gen_name (void)
472 /* Generate a name for this object. */
474 obj_name = xstrprintf ("var%d", id);
479 /* Given an OBJNAME, returns the pointer to the corresponding varobj. Call
480 error if OBJNAME cannot be found. */
483 varobj_get_handle (char *objname)
487 unsigned int index = 0;
490 for (chp = objname; *chp; chp++)
492 index = (index + (i++ * (unsigned int) *chp)) % VAROBJ_TABLE_SIZE;
495 cv = *(varobj_table + index);
496 while ((cv != NULL) && (strcmp (cv->var->obj_name, objname) != 0))
500 error (_("Variable object not found"));
505 /* Given the handle, return the name of the object. */
508 varobj_get_objname (struct varobj *var)
510 return var->obj_name;
513 /* Given the handle, return the expression represented by the object. */
516 varobj_get_expression (struct varobj *var)
518 return name_of_variable (var);
521 /* Deletes a varobj and all its children if only_children == 0,
522 otherwise deletes only the children; returns a malloc'ed list of
523 all the (malloc'ed) names of the variables that have been deleted
524 (NULL terminated). */
527 varobj_delete (struct varobj *var, char ***dellist, int only_children)
531 struct cpstack *result = NULL;
534 /* Initialize a stack for temporary results. */
535 cppush (&result, NULL);
538 /* Delete only the variable children. */
539 delcount = delete_variable (&result, var, 1 /* only the children */ );
541 /* Delete the variable and all its children. */
542 delcount = delete_variable (&result, var, 0 /* parent+children */ );
544 /* We may have been asked to return a list of what has been deleted. */
547 *dellist = xmalloc ((delcount + 1) * sizeof (char *));
551 *cp = cppop (&result);
552 while ((*cp != NULL) && (mycount > 0))
556 *cp = cppop (&result);
559 if (mycount || (*cp != NULL))
560 warning (_("varobj_delete: assertion failed - mycount(=%d) <> 0"),
569 /* Convenience function for varobj_set_visualizer. Instantiate a
570 pretty-printer for a given value. */
572 instantiate_pretty_printer (PyObject *constructor, struct value *value)
574 PyObject *val_obj = NULL;
577 val_obj = value_to_value_object (value);
581 printer = PyObject_CallFunctionObjArgs (constructor, val_obj, NULL);
588 /* Set/Get variable object display format. */
590 enum varobj_display_formats
591 varobj_set_display_format (struct varobj *var,
592 enum varobj_display_formats format)
599 case FORMAT_HEXADECIMAL:
601 var->format = format;
605 var->format = variable_default_display (var);
608 if (varobj_value_is_changeable_p (var)
609 && var->value && !value_lazy (var->value))
611 xfree (var->print_value);
612 var->print_value = varobj_value_get_print_value (var->value,
619 enum varobj_display_formats
620 varobj_get_display_format (struct varobj *var)
626 varobj_get_display_hint (struct varobj *var)
631 struct cleanup *back_to;
633 if (!gdb_python_initialized)
636 back_to = varobj_ensure_python_env (var);
638 if (var->dynamic->pretty_printer != NULL)
639 result = gdbpy_get_display_hint (var->dynamic->pretty_printer);
641 do_cleanups (back_to);
647 /* Return true if the varobj has items after TO, false otherwise. */
650 varobj_has_more (struct varobj *var, int to)
652 if (VEC_length (varobj_p, var->children) > to)
654 return ((to == -1 || VEC_length (varobj_p, var->children) == to)
655 && (var->dynamic->saved_item != NULL));
658 /* If the variable object is bound to a specific thread, that
659 is its evaluation can always be done in context of a frame
660 inside that thread, returns GDB id of the thread -- which
661 is always positive. Otherwise, returns -1. */
663 varobj_get_thread_id (struct varobj *var)
665 if (var->root->valid_block && var->root->thread_id > 0)
666 return var->root->thread_id;
672 varobj_set_frozen (struct varobj *var, int frozen)
674 /* When a variable is unfrozen, we don't fetch its value.
675 The 'not_fetched' flag remains set, so next -var-update
678 We don't fetch the value, because for structures the client
679 should do -var-update anyway. It would be bad to have different
680 client-size logic for structure and other types. */
681 var->frozen = frozen;
685 varobj_get_frozen (struct varobj *var)
690 /* A helper function that restricts a range to what is actually
691 available in a VEC. This follows the usual rules for the meaning
692 of FROM and TO -- if either is negative, the entire range is
696 varobj_restrict_range (VEC (varobj_p) *children, int *from, int *to)
698 if (*from < 0 || *to < 0)
701 *to = VEC_length (varobj_p, children);
705 if (*from > VEC_length (varobj_p, children))
706 *from = VEC_length (varobj_p, children);
707 if (*to > VEC_length (varobj_p, children))
708 *to = VEC_length (varobj_p, children);
716 /* A helper for update_dynamic_varobj_children that installs a new
717 child when needed. */
720 install_dynamic_child (struct varobj *var,
721 VEC (varobj_p) **changed,
722 VEC (varobj_p) **type_changed,
723 VEC (varobj_p) **new,
724 VEC (varobj_p) **unchanged,
727 struct varobj_item *item)
729 if (VEC_length (varobj_p, var->children) < index + 1)
731 /* There's no child yet. */
732 struct varobj *child = varobj_add_child (var, item);
736 VEC_safe_push (varobj_p, *new, child);
742 varobj_p existing = VEC_index (varobj_p, var->children, index);
743 int type_updated = update_type_if_necessary (existing, item->value);
748 VEC_safe_push (varobj_p, *type_changed, existing);
750 if (install_new_value (existing, item->value, 0))
752 if (!type_updated && changed)
753 VEC_safe_push (varobj_p, *changed, existing);
755 else if (!type_updated && unchanged)
756 VEC_safe_push (varobj_p, *unchanged, existing);
761 dynamic_varobj_has_child_method (struct varobj *var)
763 struct cleanup *back_to;
764 PyObject *printer = var->dynamic->pretty_printer;
767 if (!gdb_python_initialized)
770 back_to = varobj_ensure_python_env (var);
771 result = PyObject_HasAttr (printer, gdbpy_children_cst);
772 do_cleanups (back_to);
779 update_dynamic_varobj_children (struct varobj *var,
780 VEC (varobj_p) **changed,
781 VEC (varobj_p) **type_changed,
782 VEC (varobj_p) **new,
783 VEC (varobj_p) **unchanged,
790 struct cleanup *back_to;
793 PyObject *printer = var->dynamic->pretty_printer;
795 if (!gdb_python_initialized)
798 back_to = varobj_ensure_python_env (var);
801 if (!PyObject_HasAttr (printer, gdbpy_children_cst))
803 do_cleanups (back_to);
807 if (update_children || var->dynamic->child_iter == NULL)
809 children = PyObject_CallMethodObjArgs (printer, gdbpy_children_cst,
814 gdbpy_print_stack ();
815 error (_("Null value returned for children"));
818 make_cleanup_py_decref (children);
820 Py_XDECREF (var->dynamic->child_iter);
821 var->dynamic->child_iter = PyObject_GetIter (children);
822 if (var->dynamic->child_iter == NULL)
824 gdbpy_print_stack ();
825 error (_("Could not get children iterator"));
828 Py_XDECREF (var->dynamic->saved_item);
829 var->dynamic->saved_item = NULL;
834 i = VEC_length (varobj_p, var->children);
836 /* We ask for one extra child, so that MI can report whether there
837 are more children. */
838 for (; to < 0 || i < to + 1; ++i)
843 /* See if there was a leftover from last time. */
844 if (var->dynamic->saved_item)
846 item = var->dynamic->saved_item;
847 var->dynamic->saved_item = NULL;
850 item = PyIter_Next (var->dynamic->child_iter);
854 /* Normal end of iteration. */
855 if (!PyErr_Occurred ())
858 /* If we got a memory error, just use the text as the
860 if (PyErr_ExceptionMatches (gdbpy_gdb_memory_error))
862 PyObject *type, *value, *trace;
863 char *name_str, *value_str;
865 PyErr_Fetch (&type, &value, &trace);
866 value_str = gdbpy_exception_to_string (type, value);
872 gdbpy_print_stack ();
876 name_str = xstrprintf ("<error at %d>", i);
877 item = Py_BuildValue ("(ss)", name_str, value_str);
882 gdbpy_print_stack ();
890 /* Any other kind of error. */
891 gdbpy_print_stack ();
896 /* We don't want to push the extra child on any report list. */
897 if (to < 0 || i < to)
901 struct varobj_item varobj_item;
902 struct cleanup *inner;
903 int can_mention = from < 0 || i >= from;
905 inner = make_cleanup_py_decref (item);
907 if (!PyArg_ParseTuple (item, "sO", &name, &py_v))
909 gdbpy_print_stack ();
910 error (_("Invalid item from the child list"));
913 varobj_item.value = convert_value_from_python (py_v);
914 if (varobj_item.value == NULL)
915 gdbpy_print_stack ();
916 varobj_item.name = xstrdup (name);
918 install_dynamic_child (var, can_mention ? changed : NULL,
919 can_mention ? type_changed : NULL,
920 can_mention ? new : NULL,
921 can_mention ? unchanged : NULL,
922 can_mention ? cchanged : NULL, i,
928 Py_XDECREF (var->dynamic->saved_item);
929 var->dynamic->saved_item = item;
931 /* We want to truncate the child list just before this
940 if (i < VEC_length (varobj_p, var->children))
945 for (j = i; j < VEC_length (varobj_p, var->children); ++j)
946 varobj_delete (VEC_index (varobj_p, var->children, j), NULL, 0);
947 VEC_truncate (varobj_p, var->children, i);
950 /* If there are fewer children than requested, note that the list of
952 if (to >= 0 && VEC_length (varobj_p, var->children) < to)
955 var->num_children = VEC_length (varobj_p, var->children);
957 do_cleanups (back_to);
961 gdb_assert_not_reached ("should never be called if Python is not enabled");
966 varobj_get_num_children (struct varobj *var)
968 if (var->num_children == -1)
970 if (var->dynamic->pretty_printer != NULL)
974 /* If we have a dynamic varobj, don't report -1 children.
975 So, try to fetch some children first. */
976 update_dynamic_varobj_children (var, NULL, NULL, NULL, NULL, &dummy,
980 var->num_children = number_of_children (var);
983 return var->num_children >= 0 ? var->num_children : 0;
986 /* Creates a list of the immediate children of a variable object;
987 the return code is the number of such children or -1 on error. */
990 varobj_list_children (struct varobj *var, int *from, int *to)
993 int i, children_changed;
995 var->dynamic->children_requested = 1;
997 if (var->dynamic->pretty_printer != NULL)
999 /* This, in theory, can result in the number of children changing without
1000 frontend noticing. But well, calling -var-list-children on the same
1001 varobj twice is not something a sane frontend would do. */
1002 update_dynamic_varobj_children (var, NULL, NULL, NULL, NULL,
1003 &children_changed, 0, 0, *to);
1004 varobj_restrict_range (var->children, from, to);
1005 return var->children;
1008 if (var->num_children == -1)
1009 var->num_children = number_of_children (var);
1011 /* If that failed, give up. */
1012 if (var->num_children == -1)
1013 return var->children;
1015 /* If we're called when the list of children is not yet initialized,
1016 allocate enough elements in it. */
1017 while (VEC_length (varobj_p, var->children) < var->num_children)
1018 VEC_safe_push (varobj_p, var->children, NULL);
1020 for (i = 0; i < var->num_children; i++)
1022 varobj_p existing = VEC_index (varobj_p, var->children, i);
1024 if (existing == NULL)
1026 /* Either it's the first call to varobj_list_children for
1027 this variable object, and the child was never created,
1028 or it was explicitly deleted by the client. */
1029 name = name_of_child (var, i);
1030 existing = create_child (var, i, name);
1031 VEC_replace (varobj_p, var->children, i, existing);
1035 varobj_restrict_range (var->children, from, to);
1036 return var->children;
1041 static struct varobj *
1042 varobj_add_child (struct varobj *var, struct varobj_item *item)
1044 varobj_p v = create_child_with_value (var,
1045 VEC_length (varobj_p, var->children),
1048 VEC_safe_push (varobj_p, var->children, v);
1052 #endif /* HAVE_PYTHON */
1054 /* Obtain the type of an object Variable as a string similar to the one gdb
1055 prints on the console. */
1058 varobj_get_type (struct varobj *var)
1060 /* For the "fake" variables, do not return a type. (Its type is
1062 Do not return a type for invalid variables as well. */
1063 if (CPLUS_FAKE_CHILD (var) || !var->root->is_valid)
1066 return type_to_string (var->type);
1069 /* Obtain the type of an object variable. */
1072 varobj_get_gdb_type (struct varobj *var)
1077 /* Is VAR a path expression parent, i.e., can it be used to construct
1078 a valid path expression? */
1081 is_path_expr_parent (struct varobj *var)
1085 /* "Fake" children are not path_expr parents. */
1086 if (CPLUS_FAKE_CHILD (var))
1089 type = varobj_get_value_type (var);
1091 /* Anonymous unions and structs are also not path_expr parents. */
1092 return !((TYPE_CODE (type) == TYPE_CODE_STRUCT
1093 || TYPE_CODE (type) == TYPE_CODE_UNION)
1094 && TYPE_NAME (type) == NULL);
1097 /* Return the path expression parent for VAR. */
1100 varobj_get_path_expr_parent (struct varobj *var)
1102 struct varobj *parent = var;
1104 while (!is_root_p (parent) && !is_path_expr_parent (parent))
1105 parent = parent->parent;
1110 /* Return a pointer to the full rooted expression of varobj VAR.
1111 If it has not been computed yet, compute it. */
1113 varobj_get_path_expr (struct varobj *var)
1115 if (var->path_expr != NULL)
1116 return var->path_expr;
1119 /* For root varobjs, we initialize path_expr
1120 when creating varobj, so here it should be
1122 gdb_assert (!is_root_p (var));
1123 return (*var->root->lang_ops->path_expr_of_child) (var);
1127 const struct language_defn *
1128 varobj_get_language (struct varobj *var)
1130 return var->root->exp->language_defn;
1134 varobj_get_attributes (struct varobj *var)
1138 if (varobj_editable_p (var))
1139 /* FIXME: define masks for attributes. */
1140 attributes |= 0x00000001; /* Editable */
1146 varobj_pretty_printed_p (struct varobj *var)
1148 return var->dynamic->pretty_printer != NULL;
1152 varobj_get_formatted_value (struct varobj *var,
1153 enum varobj_display_formats format)
1155 return my_value_of_variable (var, format);
1159 varobj_get_value (struct varobj *var)
1161 return my_value_of_variable (var, var->format);
1164 /* Set the value of an object variable (if it is editable) to the
1165 value of the given expression. */
1166 /* Note: Invokes functions that can call error(). */
1169 varobj_set_value (struct varobj *var, char *expression)
1171 struct value *val = NULL; /* Initialize to keep gcc happy. */
1172 /* The argument "expression" contains the variable's new value.
1173 We need to first construct a legal expression for this -- ugh! */
1174 /* Does this cover all the bases? */
1175 struct expression *exp;
1176 struct value *value = NULL; /* Initialize to keep gcc happy. */
1177 int saved_input_radix = input_radix;
1178 const char *s = expression;
1179 volatile struct gdb_exception except;
1181 gdb_assert (varobj_editable_p (var));
1183 input_radix = 10; /* ALWAYS reset to decimal temporarily. */
1184 exp = parse_exp_1 (&s, 0, 0, 0);
1185 TRY_CATCH (except, RETURN_MASK_ERROR)
1187 value = evaluate_expression (exp);
1190 if (except.reason < 0)
1192 /* We cannot proceed without a valid expression. */
1197 /* All types that are editable must also be changeable. */
1198 gdb_assert (varobj_value_is_changeable_p (var));
1200 /* The value of a changeable variable object must not be lazy. */
1201 gdb_assert (!value_lazy (var->value));
1203 /* Need to coerce the input. We want to check if the
1204 value of the variable object will be different
1205 after assignment, and the first thing value_assign
1206 does is coerce the input.
1207 For example, if we are assigning an array to a pointer variable we
1208 should compare the pointer with the array's address, not with the
1210 value = coerce_array (value);
1212 /* The new value may be lazy. value_assign, or
1213 rather value_contents, will take care of this. */
1214 TRY_CATCH (except, RETURN_MASK_ERROR)
1216 val = value_assign (var->value, value);
1219 if (except.reason < 0)
1222 /* If the value has changed, record it, so that next -var-update can
1223 report this change. If a variable had a value of '1', we've set it
1224 to '333' and then set again to '1', when -var-update will report this
1225 variable as changed -- because the first assignment has set the
1226 'updated' flag. There's no need to optimize that, because return value
1227 of -var-update should be considered an approximation. */
1228 var->updated = install_new_value (var, val, 0 /* Compare values. */);
1229 input_radix = saved_input_radix;
1235 /* A helper function to install a constructor function and visualizer
1236 in a varobj_dynamic. */
1239 install_visualizer (struct varobj_dynamic *var, PyObject *constructor,
1240 PyObject *visualizer)
1242 Py_XDECREF (var->constructor);
1243 var->constructor = constructor;
1245 Py_XDECREF (var->pretty_printer);
1246 var->pretty_printer = visualizer;
1248 Py_XDECREF (var->child_iter);
1249 var->child_iter = NULL;
1252 /* Install the default visualizer for VAR. */
1255 install_default_visualizer (struct varobj *var)
1257 /* Do not install a visualizer on a CPLUS_FAKE_CHILD. */
1258 if (CPLUS_FAKE_CHILD (var))
1261 if (pretty_printing)
1263 PyObject *pretty_printer = NULL;
1267 pretty_printer = gdbpy_get_varobj_pretty_printer (var->value);
1268 if (! pretty_printer)
1270 gdbpy_print_stack ();
1271 error (_("Cannot instantiate printer for default visualizer"));
1275 if (pretty_printer == Py_None)
1277 Py_DECREF (pretty_printer);
1278 pretty_printer = NULL;
1281 install_visualizer (var->dynamic, NULL, pretty_printer);
1285 /* Instantiate and install a visualizer for VAR using CONSTRUCTOR to
1286 make a new object. */
1289 construct_visualizer (struct varobj *var, PyObject *constructor)
1291 PyObject *pretty_printer;
1293 /* Do not install a visualizer on a CPLUS_FAKE_CHILD. */
1294 if (CPLUS_FAKE_CHILD (var))
1297 Py_INCREF (constructor);
1298 if (constructor == Py_None)
1299 pretty_printer = NULL;
1302 pretty_printer = instantiate_pretty_printer (constructor, var->value);
1303 if (! pretty_printer)
1305 gdbpy_print_stack ();
1306 Py_DECREF (constructor);
1307 constructor = Py_None;
1308 Py_INCREF (constructor);
1311 if (pretty_printer == Py_None)
1313 Py_DECREF (pretty_printer);
1314 pretty_printer = NULL;
1318 install_visualizer (var->dynamic, constructor, pretty_printer);
1321 #endif /* HAVE_PYTHON */
1323 /* A helper function for install_new_value. This creates and installs
1324 a visualizer for VAR, if appropriate. */
1327 install_new_value_visualizer (struct varobj *var)
1330 /* If the constructor is None, then we want the raw value. If VAR
1331 does not have a value, just skip this. */
1332 if (!gdb_python_initialized)
1335 if (var->dynamic->constructor != Py_None && var->value != NULL)
1337 struct cleanup *cleanup;
1339 cleanup = varobj_ensure_python_env (var);
1341 if (var->dynamic->constructor == NULL)
1342 install_default_visualizer (var);
1344 construct_visualizer (var, var->dynamic->constructor);
1346 do_cleanups (cleanup);
1353 /* When using RTTI to determine variable type it may be changed in runtime when
1354 the variable value is changed. This function checks whether type of varobj
1355 VAR will change when a new value NEW_VALUE is assigned and if it is so
1356 updates the type of VAR. */
1359 update_type_if_necessary (struct varobj *var, struct value *new_value)
1363 struct value_print_options opts;
1365 get_user_print_options (&opts);
1366 if (opts.objectprint)
1368 struct type *new_type;
1369 char *curr_type_str, *new_type_str;
1371 new_type = value_actual_type (new_value, 0, 0);
1372 new_type_str = type_to_string (new_type);
1373 curr_type_str = varobj_get_type (var);
1374 if (strcmp (curr_type_str, new_type_str) != 0)
1376 var->type = new_type;
1378 /* This information may be not valid for a new type. */
1379 varobj_delete (var, NULL, 1);
1380 VEC_free (varobj_p, var->children);
1381 var->num_children = -1;
1390 /* Assign a new value to a variable object. If INITIAL is non-zero,
1391 this is the first assignement after the variable object was just
1392 created, or changed type. In that case, just assign the value
1394 Otherwise, assign the new value, and return 1 if the value is
1395 different from the current one, 0 otherwise. The comparison is
1396 done on textual representation of value. Therefore, some types
1397 need not be compared. E.g. for structures the reported value is
1398 always "{...}", so no comparison is necessary here. If the old
1399 value was NULL and new one is not, or vice versa, we always return 1.
1401 The VALUE parameter should not be released -- the function will
1402 take care of releasing it when needed. */
1404 install_new_value (struct varobj *var, struct value *value, int initial)
1409 int intentionally_not_fetched = 0;
1410 char *print_value = NULL;
1412 /* We need to know the varobj's type to decide if the value should
1413 be fetched or not. C++ fake children (public/protected/private)
1414 don't have a type. */
1415 gdb_assert (var->type || CPLUS_FAKE_CHILD (var));
1416 changeable = varobj_value_is_changeable_p (var);
1418 /* If the type has custom visualizer, we consider it to be always
1419 changeable. FIXME: need to make sure this behaviour will not
1420 mess up read-sensitive values. */
1421 if (var->dynamic->pretty_printer != NULL)
1424 need_to_fetch = changeable;
1426 /* We are not interested in the address of references, and given
1427 that in C++ a reference is not rebindable, it cannot
1428 meaningfully change. So, get hold of the real value. */
1430 value = coerce_ref (value);
1432 if (var->type && TYPE_CODE (var->type) == TYPE_CODE_UNION)
1433 /* For unions, we need to fetch the value implicitly because
1434 of implementation of union member fetch. When gdb
1435 creates a value for a field and the value of the enclosing
1436 structure is not lazy, it immediately copies the necessary
1437 bytes from the enclosing values. If the enclosing value is
1438 lazy, the call to value_fetch_lazy on the field will read
1439 the data from memory. For unions, that means we'll read the
1440 same memory more than once, which is not desirable. So
1444 /* The new value might be lazy. If the type is changeable,
1445 that is we'll be comparing values of this type, fetch the
1446 value now. Otherwise, on the next update the old value
1447 will be lazy, which means we've lost that old value. */
1448 if (need_to_fetch && value && value_lazy (value))
1450 struct varobj *parent = var->parent;
1451 int frozen = var->frozen;
1453 for (; !frozen && parent; parent = parent->parent)
1454 frozen |= parent->frozen;
1456 if (frozen && initial)
1458 /* For variables that are frozen, or are children of frozen
1459 variables, we don't do fetch on initial assignment.
1460 For non-initial assignemnt we do the fetch, since it means we're
1461 explicitly asked to compare the new value with the old one. */
1462 intentionally_not_fetched = 1;
1466 volatile struct gdb_exception except;
1468 TRY_CATCH (except, RETURN_MASK_ERROR)
1470 value_fetch_lazy (value);
1473 if (except.reason < 0)
1475 /* Set the value to NULL, so that for the next -var-update,
1476 we don't try to compare the new value with this value,
1477 that we couldn't even read. */
1483 /* Get a reference now, before possibly passing it to any Python
1484 code that might release it. */
1486 value_incref (value);
1488 /* Below, we'll be comparing string rendering of old and new
1489 values. Don't get string rendering if the value is
1490 lazy -- if it is, the code above has decided that the value
1491 should not be fetched. */
1492 if (value != NULL && !value_lazy (value)
1493 && var->dynamic->pretty_printer == NULL)
1494 print_value = varobj_value_get_print_value (value, var->format, var);
1496 /* If the type is changeable, compare the old and the new values.
1497 If this is the initial assignment, we don't have any old value
1499 if (!initial && changeable)
1501 /* If the value of the varobj was changed by -var-set-value,
1502 then the value in the varobj and in the target is the same.
1503 However, that value is different from the value that the
1504 varobj had after the previous -var-update. So need to the
1505 varobj as changed. */
1510 else if (var->dynamic->pretty_printer == NULL)
1512 /* Try to compare the values. That requires that both
1513 values are non-lazy. */
1514 if (var->not_fetched && value_lazy (var->value))
1516 /* This is a frozen varobj and the value was never read.
1517 Presumably, UI shows some "never read" indicator.
1518 Now that we've fetched the real value, we need to report
1519 this varobj as changed so that UI can show the real
1523 else if (var->value == NULL && value == NULL)
1526 else if (var->value == NULL || value == NULL)
1532 gdb_assert (!value_lazy (var->value));
1533 gdb_assert (!value_lazy (value));
1535 gdb_assert (var->print_value != NULL && print_value != NULL);
1536 if (strcmp (var->print_value, print_value) != 0)
1542 if (!initial && !changeable)
1544 /* For values that are not changeable, we don't compare the values.
1545 However, we want to notice if a value was not NULL and now is NULL,
1546 or vise versa, so that we report when top-level varobjs come in scope
1547 and leave the scope. */
1548 changed = (var->value != NULL) != (value != NULL);
1551 /* We must always keep the new value, since children depend on it. */
1552 if (var->value != NULL && var->value != value)
1553 value_free (var->value);
1555 if (value && value_lazy (value) && intentionally_not_fetched)
1556 var->not_fetched = 1;
1558 var->not_fetched = 0;
1561 install_new_value_visualizer (var);
1563 /* If we installed a pretty-printer, re-compare the printed version
1564 to see if the variable changed. */
1565 if (var->dynamic->pretty_printer != NULL)
1567 xfree (print_value);
1568 print_value = varobj_value_get_print_value (var->value, var->format,
1570 if ((var->print_value == NULL && print_value != NULL)
1571 || (var->print_value != NULL && print_value == NULL)
1572 || (var->print_value != NULL && print_value != NULL
1573 && strcmp (var->print_value, print_value) != 0))
1576 if (var->print_value)
1577 xfree (var->print_value);
1578 var->print_value = print_value;
1580 gdb_assert (!var->value || value_type (var->value));
1585 /* Return the requested range for a varobj. VAR is the varobj. FROM
1586 and TO are out parameters; *FROM and *TO will be set to the
1587 selected sub-range of VAR. If no range was selected using
1588 -var-set-update-range, then both will be -1. */
1590 varobj_get_child_range (struct varobj *var, int *from, int *to)
1596 /* Set the selected sub-range of children of VAR to start at index
1597 FROM and end at index TO. If either FROM or TO is less than zero,
1598 this is interpreted as a request for all children. */
1600 varobj_set_child_range (struct varobj *var, int from, int to)
1607 varobj_set_visualizer (struct varobj *var, const char *visualizer)
1610 PyObject *mainmod, *globals, *constructor;
1611 struct cleanup *back_to;
1613 if (!gdb_python_initialized)
1616 back_to = varobj_ensure_python_env (var);
1618 mainmod = PyImport_AddModule ("__main__");
1619 globals = PyModule_GetDict (mainmod);
1620 Py_INCREF (globals);
1621 make_cleanup_py_decref (globals);
1623 constructor = PyRun_String (visualizer, Py_eval_input, globals, globals);
1627 gdbpy_print_stack ();
1628 error (_("Could not evaluate visualizer expression: %s"), visualizer);
1631 construct_visualizer (var, constructor);
1632 Py_XDECREF (constructor);
1634 /* If there are any children now, wipe them. */
1635 varobj_delete (var, NULL, 1 /* children only */);
1636 var->num_children = -1;
1638 do_cleanups (back_to);
1640 error (_("Python support required"));
1644 /* If NEW_VALUE is the new value of the given varobj (var), return
1645 non-zero if var has mutated. In other words, if the type of
1646 the new value is different from the type of the varobj's old
1649 NEW_VALUE may be NULL, if the varobj is now out of scope. */
1652 varobj_value_has_mutated (struct varobj *var, struct value *new_value,
1653 struct type *new_type)
1655 /* If we haven't previously computed the number of children in var,
1656 it does not matter from the front-end's perspective whether
1657 the type has mutated or not. For all intents and purposes,
1658 it has not mutated. */
1659 if (var->num_children < 0)
1662 if (var->root->lang_ops->value_has_mutated)
1664 /* The varobj module, when installing new values, explicitly strips
1665 references, saying that we're not interested in those addresses.
1666 But detection of mutation happens before installing the new
1667 value, so our value may be a reference that we need to strip
1668 in order to remain consistent. */
1669 if (new_value != NULL)
1670 new_value = coerce_ref (new_value);
1671 return var->root->lang_ops->value_has_mutated (var, new_value, new_type);
1677 /* Update the values for a variable and its children. This is a
1678 two-pronged attack. First, re-parse the value for the root's
1679 expression to see if it's changed. Then go all the way
1680 through its children, reconstructing them and noting if they've
1683 The EXPLICIT parameter specifies if this call is result
1684 of MI request to update this specific variable, or
1685 result of implicit -var-update *. For implicit request, we don't
1686 update frozen variables.
1688 NOTE: This function may delete the caller's varobj. If it
1689 returns TYPE_CHANGED, then it has done this and VARP will be modified
1690 to point to the new varobj. */
1692 VEC(varobj_update_result) *
1693 varobj_update (struct varobj **varp, int explicit)
1695 int type_changed = 0;
1698 VEC (varobj_update_result) *stack = NULL;
1699 VEC (varobj_update_result) *result = NULL;
1701 /* Frozen means frozen -- we don't check for any change in
1702 this varobj, including its going out of scope, or
1703 changing type. One use case for frozen varobjs is
1704 retaining previously evaluated expressions, and we don't
1705 want them to be reevaluated at all. */
1706 if (!explicit && (*varp)->frozen)
1709 if (!(*varp)->root->is_valid)
1711 varobj_update_result r = {0};
1714 r.status = VAROBJ_INVALID;
1715 VEC_safe_push (varobj_update_result, result, &r);
1719 if ((*varp)->root->rootvar == *varp)
1721 varobj_update_result r = {0};
1724 r.status = VAROBJ_IN_SCOPE;
1726 /* Update the root variable. value_of_root can return NULL
1727 if the variable is no longer around, i.e. we stepped out of
1728 the frame in which a local existed. We are letting the
1729 value_of_root variable dispose of the varobj if the type
1731 new = value_of_root (varp, &type_changed);
1732 if (update_type_if_necessary(*varp, new))
1735 r.type_changed = type_changed;
1736 if (install_new_value ((*varp), new, type_changed))
1740 r.status = VAROBJ_NOT_IN_SCOPE;
1741 r.value_installed = 1;
1743 if (r.status == VAROBJ_NOT_IN_SCOPE)
1745 if (r.type_changed || r.changed)
1746 VEC_safe_push (varobj_update_result, result, &r);
1750 VEC_safe_push (varobj_update_result, stack, &r);
1754 varobj_update_result r = {0};
1757 VEC_safe_push (varobj_update_result, stack, &r);
1760 /* Walk through the children, reconstructing them all. */
1761 while (!VEC_empty (varobj_update_result, stack))
1763 varobj_update_result r = *(VEC_last (varobj_update_result, stack));
1764 struct varobj *v = r.varobj;
1766 VEC_pop (varobj_update_result, stack);
1768 /* Update this variable, unless it's a root, which is already
1770 if (!r.value_installed)
1772 struct type *new_type;
1774 new = value_of_child (v->parent, v->index);
1775 if (update_type_if_necessary(v, new))
1778 new_type = value_type (new);
1780 new_type = v->root->lang_ops->type_of_child (v->parent, v->index);
1782 if (varobj_value_has_mutated (v, new, new_type))
1784 /* The children are no longer valid; delete them now.
1785 Report the fact that its type changed as well. */
1786 varobj_delete (v, NULL, 1 /* only_children */);
1787 v->num_children = -1;
1794 if (install_new_value (v, new, r.type_changed))
1801 /* We probably should not get children of a varobj that has a
1802 pretty-printer, but for which -var-list-children was never
1804 if (v->dynamic->pretty_printer != NULL)
1806 VEC (varobj_p) *changed = 0, *type_changed = 0, *unchanged = 0;
1807 VEC (varobj_p) *new = 0;
1808 int i, children_changed = 0;
1813 if (!v->dynamic->children_requested)
1817 /* If we initially did not have potential children, but
1818 now we do, consider the varobj as changed.
1819 Otherwise, if children were never requested, consider
1820 it as unchanged -- presumably, such varobj is not yet
1821 expanded in the UI, so we need not bother getting
1823 if (!varobj_has_more (v, 0))
1825 update_dynamic_varobj_children (v, NULL, NULL, NULL, NULL,
1827 if (varobj_has_more (v, 0))
1832 VEC_safe_push (varobj_update_result, result, &r);
1837 /* If update_dynamic_varobj_children returns 0, then we have
1838 a non-conforming pretty-printer, so we skip it. */
1839 if (update_dynamic_varobj_children (v, &changed, &type_changed, &new,
1840 &unchanged, &children_changed, 1,
1843 if (children_changed || new)
1845 r.children_changed = 1;
1848 /* Push in reverse order so that the first child is
1849 popped from the work stack first, and so will be
1850 added to result first. This does not affect
1851 correctness, just "nicer". */
1852 for (i = VEC_length (varobj_p, type_changed) - 1; i >= 0; --i)
1854 varobj_p tmp = VEC_index (varobj_p, type_changed, i);
1855 varobj_update_result r = {0};
1857 /* Type may change only if value was changed. */
1861 r.value_installed = 1;
1862 VEC_safe_push (varobj_update_result, stack, &r);
1864 for (i = VEC_length (varobj_p, changed) - 1; i >= 0; --i)
1866 varobj_p tmp = VEC_index (varobj_p, changed, i);
1867 varobj_update_result r = {0};
1871 r.value_installed = 1;
1872 VEC_safe_push (varobj_update_result, stack, &r);
1874 for (i = VEC_length (varobj_p, unchanged) - 1; i >= 0; --i)
1876 varobj_p tmp = VEC_index (varobj_p, unchanged, i);
1880 varobj_update_result r = {0};
1883 r.value_installed = 1;
1884 VEC_safe_push (varobj_update_result, stack, &r);
1887 if (r.changed || r.children_changed)
1888 VEC_safe_push (varobj_update_result, result, &r);
1890 /* Free CHANGED, TYPE_CHANGED and UNCHANGED, but not NEW,
1891 because NEW has been put into the result vector. */
1892 VEC_free (varobj_p, changed);
1893 VEC_free (varobj_p, type_changed);
1894 VEC_free (varobj_p, unchanged);
1900 /* Push any children. Use reverse order so that the first
1901 child is popped from the work stack first, and so
1902 will be added to result first. This does not
1903 affect correctness, just "nicer". */
1904 for (i = VEC_length (varobj_p, v->children)-1; i >= 0; --i)
1906 varobj_p c = VEC_index (varobj_p, v->children, i);
1908 /* Child may be NULL if explicitly deleted by -var-delete. */
1909 if (c != NULL && !c->frozen)
1911 varobj_update_result r = {0};
1914 VEC_safe_push (varobj_update_result, stack, &r);
1918 if (r.changed || r.type_changed)
1919 VEC_safe_push (varobj_update_result, result, &r);
1922 VEC_free (varobj_update_result, stack);
1928 /* Helper functions */
1931 * Variable object construction/destruction
1935 delete_variable (struct cpstack **resultp, struct varobj *var,
1936 int only_children_p)
1940 delete_variable_1 (resultp, &delcount, var,
1941 only_children_p, 1 /* remove_from_parent_p */ );
1946 /* Delete the variable object VAR and its children. */
1947 /* IMPORTANT NOTE: If we delete a variable which is a child
1948 and the parent is not removed we dump core. It must be always
1949 initially called with remove_from_parent_p set. */
1951 delete_variable_1 (struct cpstack **resultp, int *delcountp,
1952 struct varobj *var, int only_children_p,
1953 int remove_from_parent_p)
1957 /* Delete any children of this variable, too. */
1958 for (i = 0; i < VEC_length (varobj_p, var->children); ++i)
1960 varobj_p child = VEC_index (varobj_p, var->children, i);
1964 if (!remove_from_parent_p)
1965 child->parent = NULL;
1966 delete_variable_1 (resultp, delcountp, child, 0, only_children_p);
1968 VEC_free (varobj_p, var->children);
1970 /* if we were called to delete only the children we are done here. */
1971 if (only_children_p)
1974 /* Otherwise, add it to the list of deleted ones and proceed to do so. */
1975 /* If the name is null, this is a temporary variable, that has not
1976 yet been installed, don't report it, it belongs to the caller... */
1977 if (var->obj_name != NULL)
1979 cppush (resultp, xstrdup (var->obj_name));
1980 *delcountp = *delcountp + 1;
1983 /* If this variable has a parent, remove it from its parent's list. */
1984 /* OPTIMIZATION: if the parent of this variable is also being deleted,
1985 (as indicated by remove_from_parent_p) we don't bother doing an
1986 expensive list search to find the element to remove when we are
1987 discarding the list afterwards. */
1988 if ((remove_from_parent_p) && (var->parent != NULL))
1990 VEC_replace (varobj_p, var->parent->children, var->index, NULL);
1993 if (var->obj_name != NULL)
1994 uninstall_variable (var);
1996 /* Free memory associated with this variable. */
1997 free_variable (var);
2000 /* Install the given variable VAR with the object name VAR->OBJ_NAME. */
2002 install_variable (struct varobj *var)
2005 struct vlist *newvl;
2007 unsigned int index = 0;
2010 for (chp = var->obj_name; *chp; chp++)
2012 index = (index + (i++ * (unsigned int) *chp)) % VAROBJ_TABLE_SIZE;
2015 cv = *(varobj_table + index);
2016 while ((cv != NULL) && (strcmp (cv->var->obj_name, var->obj_name) != 0))
2020 error (_("Duplicate variable object name"));
2022 /* Add varobj to hash table. */
2023 newvl = xmalloc (sizeof (struct vlist));
2024 newvl->next = *(varobj_table + index);
2026 *(varobj_table + index) = newvl;
2028 /* If root, add varobj to root list. */
2029 if (is_root_p (var))
2031 /* Add to list of root variables. */
2032 if (rootlist == NULL)
2033 var->root->next = NULL;
2035 var->root->next = rootlist;
2036 rootlist = var->root;
2042 /* Unistall the object VAR. */
2044 uninstall_variable (struct varobj *var)
2048 struct varobj_root *cr;
2049 struct varobj_root *prer;
2051 unsigned int index = 0;
2054 /* Remove varobj from hash table. */
2055 for (chp = var->obj_name; *chp; chp++)
2057 index = (index + (i++ * (unsigned int) *chp)) % VAROBJ_TABLE_SIZE;
2060 cv = *(varobj_table + index);
2062 while ((cv != NULL) && (strcmp (cv->var->obj_name, var->obj_name) != 0))
2069 fprintf_unfiltered (gdb_stdlog, "Deleting %s\n", var->obj_name);
2074 ("Assertion failed: Could not find variable object \"%s\" to delete",
2080 *(varobj_table + index) = cv->next;
2082 prev->next = cv->next;
2086 /* If root, remove varobj from root list. */
2087 if (is_root_p (var))
2089 /* Remove from list of root variables. */
2090 if (rootlist == var->root)
2091 rootlist = var->root->next;
2096 while ((cr != NULL) && (cr->rootvar != var))
2103 warning (_("Assertion failed: Could not find "
2104 "varobj \"%s\" in root list"),
2111 prer->next = cr->next;
2117 /* Create and install a child of the parent of the given name. */
2118 static struct varobj *
2119 create_child (struct varobj *parent, int index, char *name)
2121 struct varobj_item item;
2124 item.value = value_of_child (parent, index);
2126 return create_child_with_value (parent, index, &item);
2129 static struct varobj *
2130 create_child_with_value (struct varobj *parent, int index,
2131 struct varobj_item *item)
2133 struct varobj *child;
2136 child = new_variable ();
2138 /* NAME is allocated by caller. */
2139 child->name = item->name;
2140 child->index = index;
2141 child->parent = parent;
2142 child->root = parent->root;
2144 if (varobj_is_anonymous_child (child))
2145 childs_name = xstrprintf ("%s.%d_anonymous", parent->obj_name, index);
2147 childs_name = xstrprintf ("%s.%s", parent->obj_name, item->name);
2148 child->obj_name = childs_name;
2150 install_variable (child);
2152 /* Compute the type of the child. Must do this before
2153 calling install_new_value. */
2154 if (item->value != NULL)
2155 /* If the child had no evaluation errors, var->value
2156 will be non-NULL and contain a valid type. */
2157 child->type = value_actual_type (item->value, 0, NULL);
2159 /* Otherwise, we must compute the type. */
2160 child->type = (*child->root->lang_ops->type_of_child) (child->parent,
2162 install_new_value (child, item->value, 1);
2169 * Miscellaneous utility functions.
2172 /* Allocate memory and initialize a new variable. */
2173 static struct varobj *
2178 var = (struct varobj *) xmalloc (sizeof (struct varobj));
2180 var->path_expr = NULL;
2181 var->obj_name = NULL;
2185 var->num_children = -1;
2187 var->children = NULL;
2191 var->print_value = NULL;
2193 var->not_fetched = 0;
2195 = (struct varobj_dynamic *) xmalloc (sizeof (struct varobj_dynamic));
2196 var->dynamic->children_requested = 0;
2199 var->dynamic->constructor = 0;
2200 var->dynamic->pretty_printer = 0;
2201 var->dynamic->child_iter = 0;
2202 var->dynamic->saved_item = 0;
2207 /* Allocate memory and initialize a new root variable. */
2208 static struct varobj *
2209 new_root_variable (void)
2211 struct varobj *var = new_variable ();
2213 var->root = (struct varobj_root *) xmalloc (sizeof (struct varobj_root));
2214 var->root->lang_ops = NULL;
2215 var->root->exp = NULL;
2216 var->root->valid_block = NULL;
2217 var->root->frame = null_frame_id;
2218 var->root->floating = 0;
2219 var->root->rootvar = NULL;
2220 var->root->is_valid = 1;
2225 /* Free any allocated memory associated with VAR. */
2227 free_variable (struct varobj *var)
2230 if (var->dynamic->pretty_printer != NULL)
2232 struct cleanup *cleanup = varobj_ensure_python_env (var);
2234 Py_XDECREF (var->dynamic->constructor);
2235 Py_XDECREF (var->dynamic->pretty_printer);
2236 Py_XDECREF (var->dynamic->child_iter);
2237 Py_XDECREF (var->dynamic->saved_item);
2238 do_cleanups (cleanup);
2242 value_free (var->value);
2244 /* Free the expression if this is a root variable. */
2245 if (is_root_p (var))
2247 xfree (var->root->exp);
2252 xfree (var->obj_name);
2253 xfree (var->print_value);
2254 xfree (var->path_expr);
2255 xfree (var->dynamic);
2260 do_free_variable_cleanup (void *var)
2262 free_variable (var);
2265 static struct cleanup *
2266 make_cleanup_free_variable (struct varobj *var)
2268 return make_cleanup (do_free_variable_cleanup, var);
2271 /* Return the type of the value that's stored in VAR,
2272 or that would have being stored there if the
2273 value were accessible.
2275 This differs from VAR->type in that VAR->type is always
2276 the true type of the expession in the source language.
2277 The return value of this function is the type we're
2278 actually storing in varobj, and using for displaying
2279 the values and for comparing previous and new values.
2281 For example, top-level references are always stripped. */
2283 varobj_get_value_type (struct varobj *var)
2288 type = value_type (var->value);
2292 type = check_typedef (type);
2294 if (TYPE_CODE (type) == TYPE_CODE_REF)
2295 type = get_target_type (type);
2297 type = check_typedef (type);
2302 /* What is the default display for this variable? We assume that
2303 everything is "natural". Any exceptions? */
2304 static enum varobj_display_formats
2305 variable_default_display (struct varobj *var)
2307 return FORMAT_NATURAL;
2310 /* FIXME: The following should be generic for any pointer. */
2312 cppush (struct cpstack **pstack, char *name)
2316 s = (struct cpstack *) xmalloc (sizeof (struct cpstack));
2322 /* FIXME: The following should be generic for any pointer. */
2324 cppop (struct cpstack **pstack)
2329 if ((*pstack)->name == NULL && (*pstack)->next == NULL)
2334 *pstack = (*pstack)->next;
2341 * Language-dependencies
2344 /* Common entry points */
2346 /* Return the number of children for a given variable.
2347 The result of this function is defined by the language
2348 implementation. The number of children returned by this function
2349 is the number of children that the user will see in the variable
2352 number_of_children (struct varobj *var)
2354 return (*var->root->lang_ops->number_of_children) (var);
2357 /* What is the expression for the root varobj VAR? Returns a malloc'd
2360 name_of_variable (struct varobj *var)
2362 return (*var->root->lang_ops->name_of_variable) (var);
2365 /* What is the name of the INDEX'th child of VAR? Returns a malloc'd
2368 name_of_child (struct varobj *var, int index)
2370 return (*var->root->lang_ops->name_of_child) (var, index);
2373 /* If frame associated with VAR can be found, switch
2374 to it and return 1. Otherwise, return 0. */
2377 check_scope (struct varobj *var)
2379 struct frame_info *fi;
2382 fi = frame_find_by_id (var->root->frame);
2387 CORE_ADDR pc = get_frame_pc (fi);
2389 if (pc < BLOCK_START (var->root->valid_block) ||
2390 pc >= BLOCK_END (var->root->valid_block))
2398 /* Helper function to value_of_root. */
2400 static struct value *
2401 value_of_root_1 (struct varobj **var_handle)
2403 struct value *new_val = NULL;
2404 struct varobj *var = *var_handle;
2405 int within_scope = 0;
2406 struct cleanup *back_to;
2408 /* Only root variables can be updated... */
2409 if (!is_root_p (var))
2410 /* Not a root var. */
2413 back_to = make_cleanup_restore_current_thread ();
2415 /* Determine whether the variable is still around. */
2416 if (var->root->valid_block == NULL || var->root->floating)
2418 else if (var->root->thread_id == 0)
2420 /* The program was single-threaded when the variable object was
2421 created. Technically, it's possible that the program became
2422 multi-threaded since then, but we don't support such
2424 within_scope = check_scope (var);
2428 ptid_t ptid = thread_id_to_pid (var->root->thread_id);
2429 if (in_thread_list (ptid))
2431 switch_to_thread (ptid);
2432 within_scope = check_scope (var);
2438 volatile struct gdb_exception except;
2440 /* We need to catch errors here, because if evaluate
2441 expression fails we want to just return NULL. */
2442 TRY_CATCH (except, RETURN_MASK_ERROR)
2444 new_val = evaluate_expression (var->root->exp);
2448 do_cleanups (back_to);
2453 /* What is the ``struct value *'' of the root variable VAR?
2454 For floating variable object, evaluation can get us a value
2455 of different type from what is stored in varobj already. In
2457 - *type_changed will be set to 1
2458 - old varobj will be freed, and new one will be
2459 created, with the same name.
2460 - *var_handle will be set to the new varobj
2461 Otherwise, *type_changed will be set to 0. */
2462 static struct value *
2463 value_of_root (struct varobj **var_handle, int *type_changed)
2467 if (var_handle == NULL)
2472 /* This should really be an exception, since this should
2473 only get called with a root variable. */
2475 if (!is_root_p (var))
2478 if (var->root->floating)
2480 struct varobj *tmp_var;
2481 char *old_type, *new_type;
2483 tmp_var = varobj_create (NULL, var->name, (CORE_ADDR) 0,
2484 USE_SELECTED_FRAME);
2485 if (tmp_var == NULL)
2489 old_type = varobj_get_type (var);
2490 new_type = varobj_get_type (tmp_var);
2491 if (strcmp (old_type, new_type) == 0)
2493 /* The expression presently stored inside var->root->exp
2494 remembers the locations of local variables relatively to
2495 the frame where the expression was created (in DWARF location
2496 button, for example). Naturally, those locations are not
2497 correct in other frames, so update the expression. */
2499 struct expression *tmp_exp = var->root->exp;
2501 var->root->exp = tmp_var->root->exp;
2502 tmp_var->root->exp = tmp_exp;
2504 varobj_delete (tmp_var, NULL, 0);
2509 tmp_var->obj_name = xstrdup (var->obj_name);
2510 tmp_var->from = var->from;
2511 tmp_var->to = var->to;
2512 varobj_delete (var, NULL, 0);
2514 install_variable (tmp_var);
2515 *var_handle = tmp_var;
2528 struct value *value;
2530 value = value_of_root_1 (var_handle);
2531 if (var->value == NULL || value == NULL)
2533 /* For root varobj-s, a NULL value indicates a scoping issue.
2534 So, nothing to do in terms of checking for mutations. */
2536 else if (varobj_value_has_mutated (var, value, value_type (value)))
2538 /* The type has mutated, so the children are no longer valid.
2539 Just delete them, and tell our caller that the type has
2541 varobj_delete (var, NULL, 1 /* only_children */);
2542 var->num_children = -1;
2551 /* What is the ``struct value *'' for the INDEX'th child of PARENT? */
2552 static struct value *
2553 value_of_child (struct varobj *parent, int index)
2555 struct value *value;
2557 value = (*parent->root->lang_ops->value_of_child) (parent, index);
2562 /* GDB already has a command called "value_of_variable". Sigh. */
2564 my_value_of_variable (struct varobj *var, enum varobj_display_formats format)
2566 if (var->root->is_valid)
2568 if (var->dynamic->pretty_printer != NULL)
2569 return varobj_value_get_print_value (var->value, var->format, var);
2570 return (*var->root->lang_ops->value_of_variable) (var, format);
2577 varobj_formatted_print_options (struct value_print_options *opts,
2578 enum varobj_display_formats format)
2580 get_formatted_print_options (opts, format_code[(int) format]);
2581 opts->deref_ref = 0;
2586 varobj_value_get_print_value (struct value *value,
2587 enum varobj_display_formats format,
2590 struct ui_file *stb;
2591 struct cleanup *old_chain;
2592 char *thevalue = NULL;
2593 struct value_print_options opts;
2594 struct type *type = NULL;
2596 char *encoding = NULL;
2597 struct gdbarch *gdbarch = NULL;
2598 /* Initialize it just to avoid a GCC false warning. */
2599 CORE_ADDR str_addr = 0;
2600 int string_print = 0;
2605 stb = mem_fileopen ();
2606 old_chain = make_cleanup_ui_file_delete (stb);
2608 gdbarch = get_type_arch (value_type (value));
2610 if (gdb_python_initialized)
2612 PyObject *value_formatter = var->dynamic->pretty_printer;
2614 varobj_ensure_python_env (var);
2616 if (value_formatter)
2618 /* First check to see if we have any children at all. If so,
2619 we simply return {...}. */
2620 if (dynamic_varobj_has_child_method (var))
2622 do_cleanups (old_chain);
2623 return xstrdup ("{...}");
2626 if (PyObject_HasAttr (value_formatter, gdbpy_to_string_cst))
2628 struct value *replacement;
2629 PyObject *output = NULL;
2631 output = apply_varobj_pretty_printer (value_formatter,
2635 /* If we have string like output ... */
2638 make_cleanup_py_decref (output);
2640 /* If this is a lazy string, extract it. For lazy
2641 strings we always print as a string, so set
2643 if (gdbpy_is_lazy_string (output))
2645 gdbpy_extract_lazy_string (output, &str_addr, &type,
2647 make_cleanup (free_current_contents, &encoding);
2652 /* If it is a regular (non-lazy) string, extract
2653 it and copy the contents into THEVALUE. If the
2654 hint says to print it as a string, set
2655 string_print. Otherwise just return the extracted
2656 string as a value. */
2658 char *s = python_string_to_target_string (output);
2664 hint = gdbpy_get_display_hint (value_formatter);
2667 if (!strcmp (hint, "string"))
2673 thevalue = xmemdup (s, len + 1, len + 1);
2674 type = builtin_type (gdbarch)->builtin_char;
2679 do_cleanups (old_chain);
2683 make_cleanup (xfree, thevalue);
2686 gdbpy_print_stack ();
2689 /* If the printer returned a replacement value, set VALUE
2690 to REPLACEMENT. If there is not a replacement value,
2691 just use the value passed to this function. */
2693 value = replacement;
2699 varobj_formatted_print_options (&opts, format);
2701 /* If the THEVALUE has contents, it is a regular string. */
2703 LA_PRINT_STRING (stb, type, (gdb_byte *) thevalue, len, encoding, 0, &opts);
2704 else if (string_print)
2705 /* Otherwise, if string_print is set, and it is not a regular
2706 string, it is a lazy string. */
2707 val_print_string (type, encoding, str_addr, len, stb, &opts);
2709 /* All other cases. */
2710 common_val_print (value, stb, 0, &opts, current_language);
2712 thevalue = ui_file_xstrdup (stb, NULL);
2714 do_cleanups (old_chain);
2719 varobj_editable_p (struct varobj *var)
2723 if (!(var->root->is_valid && var->value && VALUE_LVAL (var->value)))
2726 type = varobj_get_value_type (var);
2728 switch (TYPE_CODE (type))
2730 case TYPE_CODE_STRUCT:
2731 case TYPE_CODE_UNION:
2732 case TYPE_CODE_ARRAY:
2733 case TYPE_CODE_FUNC:
2734 case TYPE_CODE_METHOD:
2744 /* Call VAR's value_is_changeable_p language-specific callback. */
2747 varobj_value_is_changeable_p (struct varobj *var)
2749 return var->root->lang_ops->value_is_changeable_p (var);
2752 /* Return 1 if that varobj is floating, that is is always evaluated in the
2753 selected frame, and not bound to thread/frame. Such variable objects
2754 are created using '@' as frame specifier to -var-create. */
2756 varobj_floating_p (struct varobj *var)
2758 return var->root->floating;
2761 /* Implement the "value_is_changeable_p" varobj callback for most
2765 varobj_default_value_is_changeable_p (struct varobj *var)
2770 if (CPLUS_FAKE_CHILD (var))
2773 type = varobj_get_value_type (var);
2775 switch (TYPE_CODE (type))
2777 case TYPE_CODE_STRUCT:
2778 case TYPE_CODE_UNION:
2779 case TYPE_CODE_ARRAY:
2790 /* Iterate all the existing _root_ VAROBJs and call the FUNC callback for them
2791 with an arbitrary caller supplied DATA pointer. */
2794 all_root_varobjs (void (*func) (struct varobj *var, void *data), void *data)
2796 struct varobj_root *var_root, *var_root_next;
2798 /* Iterate "safely" - handle if the callee deletes its passed VAROBJ. */
2800 for (var_root = rootlist; var_root != NULL; var_root = var_root_next)
2802 var_root_next = var_root->next;
2804 (*func) (var_root->rootvar, data);
2808 extern void _initialize_varobj (void);
2810 _initialize_varobj (void)
2812 int sizeof_table = sizeof (struct vlist *) * VAROBJ_TABLE_SIZE;
2814 varobj_table = xmalloc (sizeof_table);
2815 memset (varobj_table, 0, sizeof_table);
2817 add_setshow_zuinteger_cmd ("varobj", class_maintenance,
2819 _("Set varobj debugging."),
2820 _("Show varobj debugging."),
2821 _("When non-zero, varobj debugging is enabled."),
2822 NULL, show_varobjdebug,
2823 &setdebuglist, &showdebuglist);
2826 /* Invalidate varobj VAR if it is tied to locals and re-create it if it is
2827 defined on globals. It is a helper for varobj_invalidate.
2829 This function is called after changing the symbol file, in this case the
2830 pointers to "struct type" stored by the varobj are no longer valid. All
2831 varobj must be either re-evaluated, or marked as invalid here. */
2834 varobj_invalidate_iter (struct varobj *var, void *unused)
2836 /* global and floating var must be re-evaluated. */
2837 if (var->root->floating || var->root->valid_block == NULL)
2839 struct varobj *tmp_var;
2841 /* Try to create a varobj with same expression. If we succeed
2842 replace the old varobj, otherwise invalidate it. */
2843 tmp_var = varobj_create (NULL, var->name, (CORE_ADDR) 0,
2845 if (tmp_var != NULL)
2847 tmp_var->obj_name = xstrdup (var->obj_name);
2848 varobj_delete (var, NULL, 0);
2849 install_variable (tmp_var);
2852 var->root->is_valid = 0;
2854 else /* locals must be invalidated. */
2855 var->root->is_valid = 0;
2858 /* Invalidate the varobjs that are tied to locals and re-create the ones that
2859 are defined on globals.
2860 Invalidated varobjs will be always printed in_scope="invalid". */
2863 varobj_invalidate (void)
2865 all_root_varobjs (varobj_invalidate_iter, NULL);