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 /* Dynamic part of varobj. */
113 struct varobj_dynamic
115 /* Whether the children of this varobj were requested. This field is
116 used to decide if dynamic varobj should recompute their children.
117 In the event that the frontend never asked for the children, we
119 int children_requested;
121 /* The pretty-printer constructor. If NULL, then the default
122 pretty-printer will be looked up. If None, then no
123 pretty-printer will be installed. */
124 PyObject *constructor;
126 /* The pretty-printer that has been constructed. If NULL, then a
127 new printer object is needed, and one will be constructed. */
128 PyObject *pretty_printer;
130 /* The iterator returned by the printer's 'children' method, or NULL
132 PyObject *child_iter;
134 /* We request one extra item from the iterator, so that we can
135 report to the caller whether there are more items than we have
136 already reported. However, we don't want to install this value
137 when we read it, because that will mess up future updates. So,
138 we stash it here instead. */
139 PyObject *saved_item;
145 struct cpstack *next;
148 /* A list of varobjs */
156 /* Private function prototypes */
158 /* Helper functions for the above subcommands. */
160 static int delete_variable (struct cpstack **, struct varobj *, int);
162 static void delete_variable_1 (struct cpstack **, int *,
163 struct varobj *, int, int);
165 static int install_variable (struct varobj *);
167 static void uninstall_variable (struct varobj *);
169 static struct varobj *create_child (struct varobj *, int, char *);
171 static struct varobj *
172 create_child_with_value (struct varobj *parent, int index, char *name,
173 struct value *value);
175 /* Utility routines */
177 static struct varobj *new_variable (void);
179 static struct varobj *new_root_variable (void);
181 static void free_variable (struct varobj *var);
183 static struct cleanup *make_cleanup_free_variable (struct varobj *var);
185 static enum varobj_display_formats variable_default_display (struct varobj *);
187 static void cppush (struct cpstack **pstack, char *name);
189 static char *cppop (struct cpstack **pstack);
191 static int update_type_if_necessary (struct varobj *var,
192 struct value *new_value);
194 static int install_new_value (struct varobj *var, struct value *value,
197 /* Language-specific routines. */
199 static int number_of_children (struct varobj *);
201 static char *name_of_variable (struct varobj *);
203 static char *name_of_child (struct varobj *, int);
205 static struct value *value_of_root (struct varobj **var_handle, int *);
207 static struct value *value_of_child (struct varobj *parent, int index);
209 static char *my_value_of_variable (struct varobj *var,
210 enum varobj_display_formats format);
212 static int is_root_p (struct varobj *var);
216 static struct varobj *varobj_add_child (struct varobj *var,
218 struct value *value);
220 #endif /* HAVE_PYTHON */
224 /* Mappings of varobj_display_formats enums to gdb's format codes. */
225 static int format_code[] = { 0, 't', 'd', 'x', 'o' };
227 /* Header of the list of root variable objects. */
228 static struct varobj_root *rootlist;
230 /* Prime number indicating the number of buckets in the hash table. */
231 /* A prime large enough to avoid too many colisions. */
232 #define VAROBJ_TABLE_SIZE 227
234 /* Pointer to the varobj hash table (built at run time). */
235 static struct vlist **varobj_table;
239 /* API Implementation */
241 is_root_p (struct varobj *var)
243 return (var->root->rootvar == var);
247 /* Helper function to install a Python environment suitable for
248 use during operations on VAR. */
249 static struct cleanup *
250 varobj_ensure_python_env (struct varobj *var)
252 return ensure_python_env (var->root->exp->gdbarch,
253 var->root->exp->language_defn);
257 /* Creates a varobj (not its children). */
259 /* Return the full FRAME which corresponds to the given CORE_ADDR
260 or NULL if no FRAME on the chain corresponds to CORE_ADDR. */
262 static struct frame_info *
263 find_frame_addr_in_frame_chain (CORE_ADDR frame_addr)
265 struct frame_info *frame = NULL;
267 if (frame_addr == (CORE_ADDR) 0)
270 for (frame = get_current_frame ();
272 frame = get_prev_frame (frame))
274 /* The CORE_ADDR we get as argument was parsed from a string GDB
275 output as $fp. This output got truncated to gdbarch_addr_bit.
276 Truncate the frame base address in the same manner before
277 comparing it against our argument. */
278 CORE_ADDR frame_base = get_frame_base_address (frame);
279 int addr_bit = gdbarch_addr_bit (get_frame_arch (frame));
281 if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
282 frame_base &= ((CORE_ADDR) 1 << addr_bit) - 1;
284 if (frame_base == frame_addr)
292 varobj_create (char *objname,
293 char *expression, CORE_ADDR frame, enum varobj_type type)
296 struct cleanup *old_chain;
298 /* Fill out a varobj structure for the (root) variable being constructed. */
299 var = new_root_variable ();
300 old_chain = make_cleanup_free_variable (var);
302 if (expression != NULL)
304 struct frame_info *fi;
305 struct frame_id old_id = null_frame_id;
308 struct value *value = NULL;
309 volatile struct gdb_exception except;
312 /* Parse and evaluate the expression, filling in as much of the
313 variable's data as possible. */
315 if (has_stack_frames ())
317 /* Allow creator to specify context of variable. */
318 if ((type == USE_CURRENT_FRAME) || (type == USE_SELECTED_FRAME))
319 fi = get_selected_frame (NULL);
321 /* FIXME: cagney/2002-11-23: This code should be doing a
322 lookup using the frame ID and not just the frame's
323 ``address''. This, of course, means an interface
324 change. However, with out that interface change ISAs,
325 such as the ia64 with its two stacks, won't work.
326 Similar goes for the case where there is a frameless
328 fi = find_frame_addr_in_frame_chain (frame);
333 /* frame = -2 means always use selected frame. */
334 if (type == USE_SELECTED_FRAME)
335 var->root->floating = 1;
341 block = get_frame_block (fi, 0);
342 pc = get_frame_pc (fi);
346 innermost_block = NULL;
347 /* Wrap the call to parse expression, so we can
348 return a sensible error. */
349 TRY_CATCH (except, RETURN_MASK_ERROR)
351 var->root->exp = parse_exp_1 (&p, pc, block, 0);
354 if (except.reason < 0)
356 do_cleanups (old_chain);
360 /* Don't allow variables to be created for types. */
361 if (var->root->exp->elts[0].opcode == OP_TYPE
362 || var->root->exp->elts[0].opcode == OP_TYPEOF
363 || var->root->exp->elts[0].opcode == OP_DECLTYPE)
365 do_cleanups (old_chain);
366 fprintf_unfiltered (gdb_stderr, "Attempt to use a type name"
367 " as an expression.\n");
371 var->format = variable_default_display (var);
372 var->root->valid_block = innermost_block;
373 var->name = xstrdup (expression);
374 /* For a root var, the name and the expr are the same. */
375 var->path_expr = xstrdup (expression);
377 /* When the frame is different from the current frame,
378 we must select the appropriate frame before parsing
379 the expression, otherwise the value will not be current.
380 Since select_frame is so benign, just call it for all cases. */
383 /* User could specify explicit FRAME-ADDR which was not found but
384 EXPRESSION is frame specific and we would not be able to evaluate
385 it correctly next time. With VALID_BLOCK set we must also set
386 FRAME and THREAD_ID. */
388 error (_("Failed to find the specified frame"));
390 var->root->frame = get_frame_id (fi);
391 var->root->thread_id = pid_to_thread_id (inferior_ptid);
392 old_id = get_frame_id (get_selected_frame (NULL));
396 /* We definitely need to catch errors here.
397 If evaluate_expression succeeds we got the value we wanted.
398 But if it fails, we still go on with a call to evaluate_type(). */
399 TRY_CATCH (except, RETURN_MASK_ERROR)
401 value = evaluate_expression (var->root->exp);
404 if (except.reason < 0)
406 /* Error getting the value. Try to at least get the
408 struct value *type_only_value = evaluate_type (var->root->exp);
410 var->type = value_type (type_only_value);
414 int real_type_found = 0;
416 var->type = value_actual_type (value, 0, &real_type_found);
418 value = value_cast (var->type, value);
421 /* Set language info */
422 var->root->lang_ops = var->root->exp->language_defn->la_varobj_ops;
424 install_new_value (var, value, 1 /* Initial assignment */);
426 /* Set ourselves as our root. */
427 var->root->rootvar = var;
429 /* Reset the selected frame. */
430 if (frame_id_p (old_id))
431 select_frame (frame_find_by_id (old_id));
434 /* If the variable object name is null, that means this
435 is a temporary variable, so don't install it. */
437 if ((var != NULL) && (objname != NULL))
439 var->obj_name = xstrdup (objname);
441 /* If a varobj name is duplicated, the install will fail so
443 if (!install_variable (var))
445 do_cleanups (old_chain);
450 discard_cleanups (old_chain);
454 /* Generates an unique name that can be used for a varobj. */
457 varobj_gen_name (void)
462 /* Generate a name for this object. */
464 obj_name = xstrprintf ("var%d", id);
469 /* Given an OBJNAME, returns the pointer to the corresponding varobj. Call
470 error if OBJNAME cannot be found. */
473 varobj_get_handle (char *objname)
477 unsigned int index = 0;
480 for (chp = objname; *chp; chp++)
482 index = (index + (i++ * (unsigned int) *chp)) % VAROBJ_TABLE_SIZE;
485 cv = *(varobj_table + index);
486 while ((cv != NULL) && (strcmp (cv->var->obj_name, objname) != 0))
490 error (_("Variable object not found"));
495 /* Given the handle, return the name of the object. */
498 varobj_get_objname (struct varobj *var)
500 return var->obj_name;
503 /* Given the handle, return the expression represented by the object. */
506 varobj_get_expression (struct varobj *var)
508 return name_of_variable (var);
511 /* Deletes a varobj and all its children if only_children == 0,
512 otherwise deletes only the children; returns a malloc'ed list of
513 all the (malloc'ed) names of the variables that have been deleted
514 (NULL terminated). */
517 varobj_delete (struct varobj *var, char ***dellist, int only_children)
521 struct cpstack *result = NULL;
524 /* Initialize a stack for temporary results. */
525 cppush (&result, NULL);
528 /* Delete only the variable children. */
529 delcount = delete_variable (&result, var, 1 /* only the children */ );
531 /* Delete the variable and all its children. */
532 delcount = delete_variable (&result, var, 0 /* parent+children */ );
534 /* We may have been asked to return a list of what has been deleted. */
537 *dellist = xmalloc ((delcount + 1) * sizeof (char *));
541 *cp = cppop (&result);
542 while ((*cp != NULL) && (mycount > 0))
546 *cp = cppop (&result);
549 if (mycount || (*cp != NULL))
550 warning (_("varobj_delete: assertion failed - mycount(=%d) <> 0"),
559 /* Convenience function for varobj_set_visualizer. Instantiate a
560 pretty-printer for a given value. */
562 instantiate_pretty_printer (PyObject *constructor, struct value *value)
564 PyObject *val_obj = NULL;
567 val_obj = value_to_value_object (value);
571 printer = PyObject_CallFunctionObjArgs (constructor, val_obj, NULL);
578 /* Set/Get variable object display format. */
580 enum varobj_display_formats
581 varobj_set_display_format (struct varobj *var,
582 enum varobj_display_formats format)
589 case FORMAT_HEXADECIMAL:
591 var->format = format;
595 var->format = variable_default_display (var);
598 if (varobj_value_is_changeable_p (var)
599 && var->value && !value_lazy (var->value))
601 xfree (var->print_value);
602 var->print_value = varobj_value_get_print_value (var->value,
609 enum varobj_display_formats
610 varobj_get_display_format (struct varobj *var)
616 varobj_get_display_hint (struct varobj *var)
621 struct cleanup *back_to;
623 if (!gdb_python_initialized)
626 back_to = varobj_ensure_python_env (var);
628 if (var->dynamic->pretty_printer != NULL)
629 result = gdbpy_get_display_hint (var->dynamic->pretty_printer);
631 do_cleanups (back_to);
637 /* Return true if the varobj has items after TO, false otherwise. */
640 varobj_has_more (struct varobj *var, int to)
642 if (VEC_length (varobj_p, var->children) > to)
644 return ((to == -1 || VEC_length (varobj_p, var->children) == to)
645 && (var->dynamic->saved_item != NULL));
648 /* If the variable object is bound to a specific thread, that
649 is its evaluation can always be done in context of a frame
650 inside that thread, returns GDB id of the thread -- which
651 is always positive. Otherwise, returns -1. */
653 varobj_get_thread_id (struct varobj *var)
655 if (var->root->valid_block && var->root->thread_id > 0)
656 return var->root->thread_id;
662 varobj_set_frozen (struct varobj *var, int frozen)
664 /* When a variable is unfrozen, we don't fetch its value.
665 The 'not_fetched' flag remains set, so next -var-update
668 We don't fetch the value, because for structures the client
669 should do -var-update anyway. It would be bad to have different
670 client-size logic for structure and other types. */
671 var->frozen = frozen;
675 varobj_get_frozen (struct varobj *var)
680 /* A helper function that restricts a range to what is actually
681 available in a VEC. This follows the usual rules for the meaning
682 of FROM and TO -- if either is negative, the entire range is
686 varobj_restrict_range (VEC (varobj_p) *children, int *from, int *to)
688 if (*from < 0 || *to < 0)
691 *to = VEC_length (varobj_p, children);
695 if (*from > VEC_length (varobj_p, children))
696 *from = VEC_length (varobj_p, children);
697 if (*to > VEC_length (varobj_p, children))
698 *to = VEC_length (varobj_p, children);
706 /* A helper for update_dynamic_varobj_children that installs a new
707 child when needed. */
710 install_dynamic_child (struct varobj *var,
711 VEC (varobj_p) **changed,
712 VEC (varobj_p) **type_changed,
713 VEC (varobj_p) **new,
714 VEC (varobj_p) **unchanged,
720 if (VEC_length (varobj_p, var->children) < index + 1)
722 /* There's no child yet. */
723 struct varobj *child = varobj_add_child (var, name, value);
727 VEC_safe_push (varobj_p, *new, child);
733 varobj_p existing = VEC_index (varobj_p, var->children, index);
734 int type_updated = update_type_if_necessary (existing, value);
739 VEC_safe_push (varobj_p, *type_changed, existing);
741 if (install_new_value (existing, value, 0))
743 if (!type_updated && changed)
744 VEC_safe_push (varobj_p, *changed, existing);
746 else if (!type_updated && unchanged)
747 VEC_safe_push (varobj_p, *unchanged, existing);
752 dynamic_varobj_has_child_method (struct varobj *var)
754 struct cleanup *back_to;
755 PyObject *printer = var->dynamic->pretty_printer;
758 if (!gdb_python_initialized)
761 back_to = varobj_ensure_python_env (var);
762 result = PyObject_HasAttr (printer, gdbpy_children_cst);
763 do_cleanups (back_to);
770 update_dynamic_varobj_children (struct varobj *var,
771 VEC (varobj_p) **changed,
772 VEC (varobj_p) **type_changed,
773 VEC (varobj_p) **new,
774 VEC (varobj_p) **unchanged,
781 struct cleanup *back_to;
784 PyObject *printer = var->dynamic->pretty_printer;
786 if (!gdb_python_initialized)
789 back_to = varobj_ensure_python_env (var);
792 if (!PyObject_HasAttr (printer, gdbpy_children_cst))
794 do_cleanups (back_to);
798 if (update_children || var->dynamic->child_iter == NULL)
800 children = PyObject_CallMethodObjArgs (printer, gdbpy_children_cst,
805 gdbpy_print_stack ();
806 error (_("Null value returned for children"));
809 make_cleanup_py_decref (children);
811 Py_XDECREF (var->dynamic->child_iter);
812 var->dynamic->child_iter = PyObject_GetIter (children);
813 if (var->dynamic->child_iter == NULL)
815 gdbpy_print_stack ();
816 error (_("Could not get children iterator"));
819 Py_XDECREF (var->dynamic->saved_item);
820 var->dynamic->saved_item = NULL;
825 i = VEC_length (varobj_p, var->children);
827 /* We ask for one extra child, so that MI can report whether there
828 are more children. */
829 for (; to < 0 || i < to + 1; ++i)
834 /* See if there was a leftover from last time. */
835 if (var->dynamic->saved_item)
837 item = var->dynamic->saved_item;
838 var->dynamic->saved_item = NULL;
841 item = PyIter_Next (var->dynamic->child_iter);
845 /* Normal end of iteration. */
846 if (!PyErr_Occurred ())
849 /* If we got a memory error, just use the text as the
851 if (PyErr_ExceptionMatches (gdbpy_gdb_memory_error))
853 PyObject *type, *value, *trace;
854 char *name_str, *value_str;
856 PyErr_Fetch (&type, &value, &trace);
857 value_str = gdbpy_exception_to_string (type, value);
863 gdbpy_print_stack ();
867 name_str = xstrprintf ("<error at %d>", i);
868 item = Py_BuildValue ("(ss)", name_str, value_str);
873 gdbpy_print_stack ();
881 /* Any other kind of error. */
882 gdbpy_print_stack ();
887 /* We don't want to push the extra child on any report list. */
888 if (to < 0 || i < to)
893 struct cleanup *inner;
894 int can_mention = from < 0 || i >= from;
896 inner = make_cleanup_py_decref (item);
898 if (!PyArg_ParseTuple (item, "sO", &name, &py_v))
900 gdbpy_print_stack ();
901 error (_("Invalid item from the child list"));
904 v = convert_value_from_python (py_v);
906 gdbpy_print_stack ();
907 install_dynamic_child (var, can_mention ? changed : NULL,
908 can_mention ? type_changed : NULL,
909 can_mention ? new : NULL,
910 can_mention ? unchanged : NULL,
911 can_mention ? cchanged : NULL, i,
917 Py_XDECREF (var->dynamic->saved_item);
918 var->dynamic->saved_item = item;
920 /* We want to truncate the child list just before this
929 if (i < VEC_length (varobj_p, var->children))
934 for (j = i; j < VEC_length (varobj_p, var->children); ++j)
935 varobj_delete (VEC_index (varobj_p, var->children, j), NULL, 0);
936 VEC_truncate (varobj_p, var->children, i);
939 /* If there are fewer children than requested, note that the list of
941 if (to >= 0 && VEC_length (varobj_p, var->children) < to)
944 var->num_children = VEC_length (varobj_p, var->children);
946 do_cleanups (back_to);
950 gdb_assert_not_reached ("should never be called if Python is not enabled");
955 varobj_get_num_children (struct varobj *var)
957 if (var->num_children == -1)
959 if (var->dynamic->pretty_printer != NULL)
963 /* If we have a dynamic varobj, don't report -1 children.
964 So, try to fetch some children first. */
965 update_dynamic_varobj_children (var, NULL, NULL, NULL, NULL, &dummy,
969 var->num_children = number_of_children (var);
972 return var->num_children >= 0 ? var->num_children : 0;
975 /* Creates a list of the immediate children of a variable object;
976 the return code is the number of such children or -1 on error. */
979 varobj_list_children (struct varobj *var, int *from, int *to)
982 int i, children_changed;
984 var->dynamic->children_requested = 1;
986 if (var->dynamic->pretty_printer != NULL)
988 /* This, in theory, can result in the number of children changing without
989 frontend noticing. But well, calling -var-list-children on the same
990 varobj twice is not something a sane frontend would do. */
991 update_dynamic_varobj_children (var, NULL, NULL, NULL, NULL,
992 &children_changed, 0, 0, *to);
993 varobj_restrict_range (var->children, from, to);
994 return var->children;
997 if (var->num_children == -1)
998 var->num_children = number_of_children (var);
1000 /* If that failed, give up. */
1001 if (var->num_children == -1)
1002 return var->children;
1004 /* If we're called when the list of children is not yet initialized,
1005 allocate enough elements in it. */
1006 while (VEC_length (varobj_p, var->children) < var->num_children)
1007 VEC_safe_push (varobj_p, var->children, NULL);
1009 for (i = 0; i < var->num_children; i++)
1011 varobj_p existing = VEC_index (varobj_p, var->children, i);
1013 if (existing == NULL)
1015 /* Either it's the first call to varobj_list_children for
1016 this variable object, and the child was never created,
1017 or it was explicitly deleted by the client. */
1018 name = name_of_child (var, i);
1019 existing = create_child (var, i, name);
1020 VEC_replace (varobj_p, var->children, i, existing);
1024 varobj_restrict_range (var->children, from, to);
1025 return var->children;
1030 static struct varobj *
1031 varobj_add_child (struct varobj *var, char *name, struct value *value)
1033 varobj_p v = create_child_with_value (var,
1034 VEC_length (varobj_p, var->children),
1037 VEC_safe_push (varobj_p, var->children, v);
1041 #endif /* HAVE_PYTHON */
1043 /* Obtain the type of an object Variable as a string similar to the one gdb
1044 prints on the console. */
1047 varobj_get_type (struct varobj *var)
1049 /* For the "fake" variables, do not return a type. (Its type is
1051 Do not return a type for invalid variables as well. */
1052 if (CPLUS_FAKE_CHILD (var) || !var->root->is_valid)
1055 return type_to_string (var->type);
1058 /* Obtain the type of an object variable. */
1061 varobj_get_gdb_type (struct varobj *var)
1066 /* Is VAR a path expression parent, i.e., can it be used to construct
1067 a valid path expression? */
1070 is_path_expr_parent (struct varobj *var)
1074 /* "Fake" children are not path_expr parents. */
1075 if (CPLUS_FAKE_CHILD (var))
1078 type = varobj_get_value_type (var);
1080 /* Anonymous unions and structs are also not path_expr parents. */
1081 return !((TYPE_CODE (type) == TYPE_CODE_STRUCT
1082 || TYPE_CODE (type) == TYPE_CODE_UNION)
1083 && TYPE_NAME (type) == NULL);
1086 /* Return the path expression parent for VAR. */
1089 varobj_get_path_expr_parent (struct varobj *var)
1091 struct varobj *parent = var;
1093 while (!is_root_p (parent) && !is_path_expr_parent (parent))
1094 parent = parent->parent;
1099 /* Return a pointer to the full rooted expression of varobj VAR.
1100 If it has not been computed yet, compute it. */
1102 varobj_get_path_expr (struct varobj *var)
1104 if (var->path_expr != NULL)
1105 return var->path_expr;
1108 /* For root varobjs, we initialize path_expr
1109 when creating varobj, so here it should be
1111 gdb_assert (!is_root_p (var));
1112 return (*var->root->lang_ops->path_expr_of_child) (var);
1116 const struct language_defn *
1117 varobj_get_language (struct varobj *var)
1119 return var->root->exp->language_defn;
1123 varobj_get_attributes (struct varobj *var)
1127 if (varobj_editable_p (var))
1128 /* FIXME: define masks for attributes. */
1129 attributes |= 0x00000001; /* Editable */
1135 varobj_pretty_printed_p (struct varobj *var)
1137 return var->dynamic->pretty_printer != NULL;
1141 varobj_get_formatted_value (struct varobj *var,
1142 enum varobj_display_formats format)
1144 return my_value_of_variable (var, format);
1148 varobj_get_value (struct varobj *var)
1150 return my_value_of_variable (var, var->format);
1153 /* Set the value of an object variable (if it is editable) to the
1154 value of the given expression. */
1155 /* Note: Invokes functions that can call error(). */
1158 varobj_set_value (struct varobj *var, char *expression)
1160 struct value *val = NULL; /* Initialize to keep gcc happy. */
1161 /* The argument "expression" contains the variable's new value.
1162 We need to first construct a legal expression for this -- ugh! */
1163 /* Does this cover all the bases? */
1164 struct expression *exp;
1165 struct value *value = NULL; /* Initialize to keep gcc happy. */
1166 int saved_input_radix = input_radix;
1167 const char *s = expression;
1168 volatile struct gdb_exception except;
1170 gdb_assert (varobj_editable_p (var));
1172 input_radix = 10; /* ALWAYS reset to decimal temporarily. */
1173 exp = parse_exp_1 (&s, 0, 0, 0);
1174 TRY_CATCH (except, RETURN_MASK_ERROR)
1176 value = evaluate_expression (exp);
1179 if (except.reason < 0)
1181 /* We cannot proceed without a valid expression. */
1186 /* All types that are editable must also be changeable. */
1187 gdb_assert (varobj_value_is_changeable_p (var));
1189 /* The value of a changeable variable object must not be lazy. */
1190 gdb_assert (!value_lazy (var->value));
1192 /* Need to coerce the input. We want to check if the
1193 value of the variable object will be different
1194 after assignment, and the first thing value_assign
1195 does is coerce the input.
1196 For example, if we are assigning an array to a pointer variable we
1197 should compare the pointer with the array's address, not with the
1199 value = coerce_array (value);
1201 /* The new value may be lazy. value_assign, or
1202 rather value_contents, will take care of this. */
1203 TRY_CATCH (except, RETURN_MASK_ERROR)
1205 val = value_assign (var->value, value);
1208 if (except.reason < 0)
1211 /* If the value has changed, record it, so that next -var-update can
1212 report this change. If a variable had a value of '1', we've set it
1213 to '333' and then set again to '1', when -var-update will report this
1214 variable as changed -- because the first assignment has set the
1215 'updated' flag. There's no need to optimize that, because return value
1216 of -var-update should be considered an approximation. */
1217 var->updated = install_new_value (var, val, 0 /* Compare values. */);
1218 input_radix = saved_input_radix;
1224 /* A helper function to install a constructor function and visualizer
1225 in a varobj_dynamic. */
1228 install_visualizer (struct varobj_dynamic *var, PyObject *constructor,
1229 PyObject *visualizer)
1231 Py_XDECREF (var->constructor);
1232 var->constructor = constructor;
1234 Py_XDECREF (var->pretty_printer);
1235 var->pretty_printer = visualizer;
1237 Py_XDECREF (var->child_iter);
1238 var->child_iter = NULL;
1241 /* Install the default visualizer for VAR. */
1244 install_default_visualizer (struct varobj *var)
1246 /* Do not install a visualizer on a CPLUS_FAKE_CHILD. */
1247 if (CPLUS_FAKE_CHILD (var))
1250 if (pretty_printing)
1252 PyObject *pretty_printer = NULL;
1256 pretty_printer = gdbpy_get_varobj_pretty_printer (var->value);
1257 if (! pretty_printer)
1259 gdbpy_print_stack ();
1260 error (_("Cannot instantiate printer for default visualizer"));
1264 if (pretty_printer == Py_None)
1266 Py_DECREF (pretty_printer);
1267 pretty_printer = NULL;
1270 install_visualizer (var->dynamic, NULL, pretty_printer);
1274 /* Instantiate and install a visualizer for VAR using CONSTRUCTOR to
1275 make a new object. */
1278 construct_visualizer (struct varobj *var, PyObject *constructor)
1280 PyObject *pretty_printer;
1282 /* Do not install a visualizer on a CPLUS_FAKE_CHILD. */
1283 if (CPLUS_FAKE_CHILD (var))
1286 Py_INCREF (constructor);
1287 if (constructor == Py_None)
1288 pretty_printer = NULL;
1291 pretty_printer = instantiate_pretty_printer (constructor, var->value);
1292 if (! pretty_printer)
1294 gdbpy_print_stack ();
1295 Py_DECREF (constructor);
1296 constructor = Py_None;
1297 Py_INCREF (constructor);
1300 if (pretty_printer == Py_None)
1302 Py_DECREF (pretty_printer);
1303 pretty_printer = NULL;
1307 install_visualizer (var->dynamic, constructor, pretty_printer);
1310 #endif /* HAVE_PYTHON */
1312 /* A helper function for install_new_value. This creates and installs
1313 a visualizer for VAR, if appropriate. */
1316 install_new_value_visualizer (struct varobj *var)
1319 /* If the constructor is None, then we want the raw value. If VAR
1320 does not have a value, just skip this. */
1321 if (!gdb_python_initialized)
1324 if (var->dynamic->constructor != Py_None && var->value != NULL)
1326 struct cleanup *cleanup;
1328 cleanup = varobj_ensure_python_env (var);
1330 if (var->dynamic->constructor == NULL)
1331 install_default_visualizer (var);
1333 construct_visualizer (var, var->dynamic->constructor);
1335 do_cleanups (cleanup);
1342 /* When using RTTI to determine variable type it may be changed in runtime when
1343 the variable value is changed. This function checks whether type of varobj
1344 VAR will change when a new value NEW_VALUE is assigned and if it is so
1345 updates the type of VAR. */
1348 update_type_if_necessary (struct varobj *var, struct value *new_value)
1352 struct value_print_options opts;
1354 get_user_print_options (&opts);
1355 if (opts.objectprint)
1357 struct type *new_type;
1358 char *curr_type_str, *new_type_str;
1360 new_type = value_actual_type (new_value, 0, 0);
1361 new_type_str = type_to_string (new_type);
1362 curr_type_str = varobj_get_type (var);
1363 if (strcmp (curr_type_str, new_type_str) != 0)
1365 var->type = new_type;
1367 /* This information may be not valid for a new type. */
1368 varobj_delete (var, NULL, 1);
1369 VEC_free (varobj_p, var->children);
1370 var->num_children = -1;
1379 /* Assign a new value to a variable object. If INITIAL is non-zero,
1380 this is the first assignement after the variable object was just
1381 created, or changed type. In that case, just assign the value
1383 Otherwise, assign the new value, and return 1 if the value is
1384 different from the current one, 0 otherwise. The comparison is
1385 done on textual representation of value. Therefore, some types
1386 need not be compared. E.g. for structures the reported value is
1387 always "{...}", so no comparison is necessary here. If the old
1388 value was NULL and new one is not, or vice versa, we always return 1.
1390 The VALUE parameter should not be released -- the function will
1391 take care of releasing it when needed. */
1393 install_new_value (struct varobj *var, struct value *value, int initial)
1398 int intentionally_not_fetched = 0;
1399 char *print_value = NULL;
1401 /* We need to know the varobj's type to decide if the value should
1402 be fetched or not. C++ fake children (public/protected/private)
1403 don't have a type. */
1404 gdb_assert (var->type || CPLUS_FAKE_CHILD (var));
1405 changeable = varobj_value_is_changeable_p (var);
1407 /* If the type has custom visualizer, we consider it to be always
1408 changeable. FIXME: need to make sure this behaviour will not
1409 mess up read-sensitive values. */
1410 if (var->dynamic->pretty_printer != NULL)
1413 need_to_fetch = changeable;
1415 /* We are not interested in the address of references, and given
1416 that in C++ a reference is not rebindable, it cannot
1417 meaningfully change. So, get hold of the real value. */
1419 value = coerce_ref (value);
1421 if (var->type && TYPE_CODE (var->type) == TYPE_CODE_UNION)
1422 /* For unions, we need to fetch the value implicitly because
1423 of implementation of union member fetch. When gdb
1424 creates a value for a field and the value of the enclosing
1425 structure is not lazy, it immediately copies the necessary
1426 bytes from the enclosing values. If the enclosing value is
1427 lazy, the call to value_fetch_lazy on the field will read
1428 the data from memory. For unions, that means we'll read the
1429 same memory more than once, which is not desirable. So
1433 /* The new value might be lazy. If the type is changeable,
1434 that is we'll be comparing values of this type, fetch the
1435 value now. Otherwise, on the next update the old value
1436 will be lazy, which means we've lost that old value. */
1437 if (need_to_fetch && value && value_lazy (value))
1439 struct varobj *parent = var->parent;
1440 int frozen = var->frozen;
1442 for (; !frozen && parent; parent = parent->parent)
1443 frozen |= parent->frozen;
1445 if (frozen && initial)
1447 /* For variables that are frozen, or are children of frozen
1448 variables, we don't do fetch on initial assignment.
1449 For non-initial assignemnt we do the fetch, since it means we're
1450 explicitly asked to compare the new value with the old one. */
1451 intentionally_not_fetched = 1;
1455 volatile struct gdb_exception except;
1457 TRY_CATCH (except, RETURN_MASK_ERROR)
1459 value_fetch_lazy (value);
1462 if (except.reason < 0)
1464 /* Set the value to NULL, so that for the next -var-update,
1465 we don't try to compare the new value with this value,
1466 that we couldn't even read. */
1472 /* Get a reference now, before possibly passing it to any Python
1473 code that might release it. */
1475 value_incref (value);
1477 /* Below, we'll be comparing string rendering of old and new
1478 values. Don't get string rendering if the value is
1479 lazy -- if it is, the code above has decided that the value
1480 should not be fetched. */
1481 if (value != NULL && !value_lazy (value)
1482 && var->dynamic->pretty_printer == NULL)
1483 print_value = varobj_value_get_print_value (value, var->format, var);
1485 /* If the type is changeable, compare the old and the new values.
1486 If this is the initial assignment, we don't have any old value
1488 if (!initial && changeable)
1490 /* If the value of the varobj was changed by -var-set-value,
1491 then the value in the varobj and in the target is the same.
1492 However, that value is different from the value that the
1493 varobj had after the previous -var-update. So need to the
1494 varobj as changed. */
1499 else if (var->dynamic->pretty_printer == NULL)
1501 /* Try to compare the values. That requires that both
1502 values are non-lazy. */
1503 if (var->not_fetched && value_lazy (var->value))
1505 /* This is a frozen varobj and the value was never read.
1506 Presumably, UI shows some "never read" indicator.
1507 Now that we've fetched the real value, we need to report
1508 this varobj as changed so that UI can show the real
1512 else if (var->value == NULL && value == NULL)
1515 else if (var->value == NULL || value == NULL)
1521 gdb_assert (!value_lazy (var->value));
1522 gdb_assert (!value_lazy (value));
1524 gdb_assert (var->print_value != NULL && print_value != NULL);
1525 if (strcmp (var->print_value, print_value) != 0)
1531 if (!initial && !changeable)
1533 /* For values that are not changeable, we don't compare the values.
1534 However, we want to notice if a value was not NULL and now is NULL,
1535 or vise versa, so that we report when top-level varobjs come in scope
1536 and leave the scope. */
1537 changed = (var->value != NULL) != (value != NULL);
1540 /* We must always keep the new value, since children depend on it. */
1541 if (var->value != NULL && var->value != value)
1542 value_free (var->value);
1544 if (value && value_lazy (value) && intentionally_not_fetched)
1545 var->not_fetched = 1;
1547 var->not_fetched = 0;
1550 install_new_value_visualizer (var);
1552 /* If we installed a pretty-printer, re-compare the printed version
1553 to see if the variable changed. */
1554 if (var->dynamic->pretty_printer != NULL)
1556 xfree (print_value);
1557 print_value = varobj_value_get_print_value (var->value, var->format,
1559 if ((var->print_value == NULL && print_value != NULL)
1560 || (var->print_value != NULL && print_value == NULL)
1561 || (var->print_value != NULL && print_value != NULL
1562 && strcmp (var->print_value, print_value) != 0))
1565 if (var->print_value)
1566 xfree (var->print_value);
1567 var->print_value = print_value;
1569 gdb_assert (!var->value || value_type (var->value));
1574 /* Return the requested range for a varobj. VAR is the varobj. FROM
1575 and TO are out parameters; *FROM and *TO will be set to the
1576 selected sub-range of VAR. If no range was selected using
1577 -var-set-update-range, then both will be -1. */
1579 varobj_get_child_range (struct varobj *var, int *from, int *to)
1585 /* Set the selected sub-range of children of VAR to start at index
1586 FROM and end at index TO. If either FROM or TO is less than zero,
1587 this is interpreted as a request for all children. */
1589 varobj_set_child_range (struct varobj *var, int from, int to)
1596 varobj_set_visualizer (struct varobj *var, const char *visualizer)
1599 PyObject *mainmod, *globals, *constructor;
1600 struct cleanup *back_to;
1602 if (!gdb_python_initialized)
1605 back_to = varobj_ensure_python_env (var);
1607 mainmod = PyImport_AddModule ("__main__");
1608 globals = PyModule_GetDict (mainmod);
1609 Py_INCREF (globals);
1610 make_cleanup_py_decref (globals);
1612 constructor = PyRun_String (visualizer, Py_eval_input, globals, globals);
1616 gdbpy_print_stack ();
1617 error (_("Could not evaluate visualizer expression: %s"), visualizer);
1620 construct_visualizer (var, constructor);
1621 Py_XDECREF (constructor);
1623 /* If there are any children now, wipe them. */
1624 varobj_delete (var, NULL, 1 /* children only */);
1625 var->num_children = -1;
1627 do_cleanups (back_to);
1629 error (_("Python support required"));
1633 /* If NEW_VALUE is the new value of the given varobj (var), return
1634 non-zero if var has mutated. In other words, if the type of
1635 the new value is different from the type of the varobj's old
1638 NEW_VALUE may be NULL, if the varobj is now out of scope. */
1641 varobj_value_has_mutated (struct varobj *var, struct value *new_value,
1642 struct type *new_type)
1644 /* If we haven't previously computed the number of children in var,
1645 it does not matter from the front-end's perspective whether
1646 the type has mutated or not. For all intents and purposes,
1647 it has not mutated. */
1648 if (var->num_children < 0)
1651 if (var->root->lang_ops->value_has_mutated)
1653 /* The varobj module, when installing new values, explicitly strips
1654 references, saying that we're not interested in those addresses.
1655 But detection of mutation happens before installing the new
1656 value, so our value may be a reference that we need to strip
1657 in order to remain consistent. */
1658 if (new_value != NULL)
1659 new_value = coerce_ref (new_value);
1660 return var->root->lang_ops->value_has_mutated (var, new_value, new_type);
1666 /* Update the values for a variable and its children. This is a
1667 two-pronged attack. First, re-parse the value for the root's
1668 expression to see if it's changed. Then go all the way
1669 through its children, reconstructing them and noting if they've
1672 The EXPLICIT parameter specifies if this call is result
1673 of MI request to update this specific variable, or
1674 result of implicit -var-update *. For implicit request, we don't
1675 update frozen variables.
1677 NOTE: This function may delete the caller's varobj. If it
1678 returns TYPE_CHANGED, then it has done this and VARP will be modified
1679 to point to the new varobj. */
1681 VEC(varobj_update_result) *
1682 varobj_update (struct varobj **varp, int explicit)
1684 int type_changed = 0;
1687 VEC (varobj_update_result) *stack = NULL;
1688 VEC (varobj_update_result) *result = NULL;
1690 /* Frozen means frozen -- we don't check for any change in
1691 this varobj, including its going out of scope, or
1692 changing type. One use case for frozen varobjs is
1693 retaining previously evaluated expressions, and we don't
1694 want them to be reevaluated at all. */
1695 if (!explicit && (*varp)->frozen)
1698 if (!(*varp)->root->is_valid)
1700 varobj_update_result r = {0};
1703 r.status = VAROBJ_INVALID;
1704 VEC_safe_push (varobj_update_result, result, &r);
1708 if ((*varp)->root->rootvar == *varp)
1710 varobj_update_result r = {0};
1713 r.status = VAROBJ_IN_SCOPE;
1715 /* Update the root variable. value_of_root can return NULL
1716 if the variable is no longer around, i.e. we stepped out of
1717 the frame in which a local existed. We are letting the
1718 value_of_root variable dispose of the varobj if the type
1720 new = value_of_root (varp, &type_changed);
1721 if (update_type_if_necessary(*varp, new))
1724 r.type_changed = type_changed;
1725 if (install_new_value ((*varp), new, type_changed))
1729 r.status = VAROBJ_NOT_IN_SCOPE;
1730 r.value_installed = 1;
1732 if (r.status == VAROBJ_NOT_IN_SCOPE)
1734 if (r.type_changed || r.changed)
1735 VEC_safe_push (varobj_update_result, result, &r);
1739 VEC_safe_push (varobj_update_result, stack, &r);
1743 varobj_update_result r = {0};
1746 VEC_safe_push (varobj_update_result, stack, &r);
1749 /* Walk through the children, reconstructing them all. */
1750 while (!VEC_empty (varobj_update_result, stack))
1752 varobj_update_result r = *(VEC_last (varobj_update_result, stack));
1753 struct varobj *v = r.varobj;
1755 VEC_pop (varobj_update_result, stack);
1757 /* Update this variable, unless it's a root, which is already
1759 if (!r.value_installed)
1761 struct type *new_type;
1763 new = value_of_child (v->parent, v->index);
1764 if (update_type_if_necessary(v, new))
1767 new_type = value_type (new);
1769 new_type = v->root->lang_ops->type_of_child (v->parent, v->index);
1771 if (varobj_value_has_mutated (v, new, new_type))
1773 /* The children are no longer valid; delete them now.
1774 Report the fact that its type changed as well. */
1775 varobj_delete (v, NULL, 1 /* only_children */);
1776 v->num_children = -1;
1783 if (install_new_value (v, new, r.type_changed))
1790 /* We probably should not get children of a varobj that has a
1791 pretty-printer, but for which -var-list-children was never
1793 if (v->dynamic->pretty_printer != NULL)
1795 VEC (varobj_p) *changed = 0, *type_changed = 0, *unchanged = 0;
1796 VEC (varobj_p) *new = 0;
1797 int i, children_changed = 0;
1802 if (!v->dynamic->children_requested)
1806 /* If we initially did not have potential children, but
1807 now we do, consider the varobj as changed.
1808 Otherwise, if children were never requested, consider
1809 it as unchanged -- presumably, such varobj is not yet
1810 expanded in the UI, so we need not bother getting
1812 if (!varobj_has_more (v, 0))
1814 update_dynamic_varobj_children (v, NULL, NULL, NULL, NULL,
1816 if (varobj_has_more (v, 0))
1821 VEC_safe_push (varobj_update_result, result, &r);
1826 /* If update_dynamic_varobj_children returns 0, then we have
1827 a non-conforming pretty-printer, so we skip it. */
1828 if (update_dynamic_varobj_children (v, &changed, &type_changed, &new,
1829 &unchanged, &children_changed, 1,
1832 if (children_changed || new)
1834 r.children_changed = 1;
1837 /* Push in reverse order so that the first child is
1838 popped from the work stack first, and so will be
1839 added to result first. This does not affect
1840 correctness, just "nicer". */
1841 for (i = VEC_length (varobj_p, type_changed) - 1; i >= 0; --i)
1843 varobj_p tmp = VEC_index (varobj_p, type_changed, i);
1844 varobj_update_result r = {0};
1846 /* Type may change only if value was changed. */
1850 r.value_installed = 1;
1851 VEC_safe_push (varobj_update_result, stack, &r);
1853 for (i = VEC_length (varobj_p, changed) - 1; i >= 0; --i)
1855 varobj_p tmp = VEC_index (varobj_p, changed, i);
1856 varobj_update_result r = {0};
1860 r.value_installed = 1;
1861 VEC_safe_push (varobj_update_result, stack, &r);
1863 for (i = VEC_length (varobj_p, unchanged) - 1; i >= 0; --i)
1865 varobj_p tmp = VEC_index (varobj_p, unchanged, i);
1869 varobj_update_result r = {0};
1872 r.value_installed = 1;
1873 VEC_safe_push (varobj_update_result, stack, &r);
1876 if (r.changed || r.children_changed)
1877 VEC_safe_push (varobj_update_result, result, &r);
1879 /* Free CHANGED, TYPE_CHANGED and UNCHANGED, but not NEW,
1880 because NEW has been put into the result vector. */
1881 VEC_free (varobj_p, changed);
1882 VEC_free (varobj_p, type_changed);
1883 VEC_free (varobj_p, unchanged);
1889 /* Push any children. Use reverse order so that the first
1890 child is popped from the work stack first, and so
1891 will be added to result first. This does not
1892 affect correctness, just "nicer". */
1893 for (i = VEC_length (varobj_p, v->children)-1; i >= 0; --i)
1895 varobj_p c = VEC_index (varobj_p, v->children, i);
1897 /* Child may be NULL if explicitly deleted by -var-delete. */
1898 if (c != NULL && !c->frozen)
1900 varobj_update_result r = {0};
1903 VEC_safe_push (varobj_update_result, stack, &r);
1907 if (r.changed || r.type_changed)
1908 VEC_safe_push (varobj_update_result, result, &r);
1911 VEC_free (varobj_update_result, stack);
1917 /* Helper functions */
1920 * Variable object construction/destruction
1924 delete_variable (struct cpstack **resultp, struct varobj *var,
1925 int only_children_p)
1929 delete_variable_1 (resultp, &delcount, var,
1930 only_children_p, 1 /* remove_from_parent_p */ );
1935 /* Delete the variable object VAR and its children. */
1936 /* IMPORTANT NOTE: If we delete a variable which is a child
1937 and the parent is not removed we dump core. It must be always
1938 initially called with remove_from_parent_p set. */
1940 delete_variable_1 (struct cpstack **resultp, int *delcountp,
1941 struct varobj *var, int only_children_p,
1942 int remove_from_parent_p)
1946 /* Delete any children of this variable, too. */
1947 for (i = 0; i < VEC_length (varobj_p, var->children); ++i)
1949 varobj_p child = VEC_index (varobj_p, var->children, i);
1953 if (!remove_from_parent_p)
1954 child->parent = NULL;
1955 delete_variable_1 (resultp, delcountp, child, 0, only_children_p);
1957 VEC_free (varobj_p, var->children);
1959 /* if we were called to delete only the children we are done here. */
1960 if (only_children_p)
1963 /* Otherwise, add it to the list of deleted ones and proceed to do so. */
1964 /* If the name is null, this is a temporary variable, that has not
1965 yet been installed, don't report it, it belongs to the caller... */
1966 if (var->obj_name != NULL)
1968 cppush (resultp, xstrdup (var->obj_name));
1969 *delcountp = *delcountp + 1;
1972 /* If this variable has a parent, remove it from its parent's list. */
1973 /* OPTIMIZATION: if the parent of this variable is also being deleted,
1974 (as indicated by remove_from_parent_p) we don't bother doing an
1975 expensive list search to find the element to remove when we are
1976 discarding the list afterwards. */
1977 if ((remove_from_parent_p) && (var->parent != NULL))
1979 VEC_replace (varobj_p, var->parent->children, var->index, NULL);
1982 if (var->obj_name != NULL)
1983 uninstall_variable (var);
1985 /* Free memory associated with this variable. */
1986 free_variable (var);
1989 /* Install the given variable VAR with the object name VAR->OBJ_NAME. */
1991 install_variable (struct varobj *var)
1994 struct vlist *newvl;
1996 unsigned int index = 0;
1999 for (chp = var->obj_name; *chp; chp++)
2001 index = (index + (i++ * (unsigned int) *chp)) % VAROBJ_TABLE_SIZE;
2004 cv = *(varobj_table + index);
2005 while ((cv != NULL) && (strcmp (cv->var->obj_name, var->obj_name) != 0))
2009 error (_("Duplicate variable object name"));
2011 /* Add varobj to hash table. */
2012 newvl = xmalloc (sizeof (struct vlist));
2013 newvl->next = *(varobj_table + index);
2015 *(varobj_table + index) = newvl;
2017 /* If root, add varobj to root list. */
2018 if (is_root_p (var))
2020 /* Add to list of root variables. */
2021 if (rootlist == NULL)
2022 var->root->next = NULL;
2024 var->root->next = rootlist;
2025 rootlist = var->root;
2031 /* Unistall the object VAR. */
2033 uninstall_variable (struct varobj *var)
2037 struct varobj_root *cr;
2038 struct varobj_root *prer;
2040 unsigned int index = 0;
2043 /* Remove varobj from hash table. */
2044 for (chp = var->obj_name; *chp; chp++)
2046 index = (index + (i++ * (unsigned int) *chp)) % VAROBJ_TABLE_SIZE;
2049 cv = *(varobj_table + index);
2051 while ((cv != NULL) && (strcmp (cv->var->obj_name, var->obj_name) != 0))
2058 fprintf_unfiltered (gdb_stdlog, "Deleting %s\n", var->obj_name);
2063 ("Assertion failed: Could not find variable object \"%s\" to delete",
2069 *(varobj_table + index) = cv->next;
2071 prev->next = cv->next;
2075 /* If root, remove varobj from root list. */
2076 if (is_root_p (var))
2078 /* Remove from list of root variables. */
2079 if (rootlist == var->root)
2080 rootlist = var->root->next;
2085 while ((cr != NULL) && (cr->rootvar != var))
2092 warning (_("Assertion failed: Could not find "
2093 "varobj \"%s\" in root list"),
2100 prer->next = cr->next;
2106 /* Create and install a child of the parent of the given name. */
2107 static struct varobj *
2108 create_child (struct varobj *parent, int index, char *name)
2110 return create_child_with_value (parent, index, name,
2111 value_of_child (parent, index));
2114 static struct varobj *
2115 create_child_with_value (struct varobj *parent, int index, char *name,
2116 struct value *value)
2118 struct varobj *child;
2121 child = new_variable ();
2123 /* NAME is allocated by caller. */
2125 child->index = index;
2126 child->parent = parent;
2127 child->root = parent->root;
2129 if (varobj_is_anonymous_child (child))
2130 childs_name = xstrprintf ("%s.%d_anonymous", parent->obj_name, index);
2132 childs_name = xstrprintf ("%s.%s", parent->obj_name, name);
2133 child->obj_name = childs_name;
2135 install_variable (child);
2137 /* Compute the type of the child. Must do this before
2138 calling install_new_value. */
2140 /* If the child had no evaluation errors, var->value
2141 will be non-NULL and contain a valid type. */
2142 child->type = value_actual_type (value, 0, NULL);
2144 /* Otherwise, we must compute the type. */
2145 child->type = (*child->root->lang_ops->type_of_child) (child->parent,
2147 install_new_value (child, value, 1);
2154 * Miscellaneous utility functions.
2157 /* Allocate memory and initialize a new variable. */
2158 static struct varobj *
2163 var = (struct varobj *) xmalloc (sizeof (struct varobj));
2165 var->path_expr = NULL;
2166 var->obj_name = NULL;
2170 var->num_children = -1;
2172 var->children = NULL;
2176 var->print_value = NULL;
2178 var->not_fetched = 0;
2180 = (struct varobj_dynamic *) xmalloc (sizeof (struct varobj_dynamic));
2181 var->dynamic->children_requested = 0;
2184 var->dynamic->constructor = 0;
2185 var->dynamic->pretty_printer = 0;
2186 var->dynamic->child_iter = 0;
2187 var->dynamic->saved_item = 0;
2192 /* Allocate memory and initialize a new root variable. */
2193 static struct varobj *
2194 new_root_variable (void)
2196 struct varobj *var = new_variable ();
2198 var->root = (struct varobj_root *) xmalloc (sizeof (struct varobj_root));
2199 var->root->lang_ops = NULL;
2200 var->root->exp = NULL;
2201 var->root->valid_block = NULL;
2202 var->root->frame = null_frame_id;
2203 var->root->floating = 0;
2204 var->root->rootvar = NULL;
2205 var->root->is_valid = 1;
2210 /* Free any allocated memory associated with VAR. */
2212 free_variable (struct varobj *var)
2215 if (var->dynamic->pretty_printer != NULL)
2217 struct cleanup *cleanup = varobj_ensure_python_env (var);
2219 Py_XDECREF (var->dynamic->constructor);
2220 Py_XDECREF (var->dynamic->pretty_printer);
2221 Py_XDECREF (var->dynamic->child_iter);
2222 Py_XDECREF (var->dynamic->saved_item);
2223 do_cleanups (cleanup);
2227 value_free (var->value);
2229 /* Free the expression if this is a root variable. */
2230 if (is_root_p (var))
2232 xfree (var->root->exp);
2237 xfree (var->obj_name);
2238 xfree (var->print_value);
2239 xfree (var->path_expr);
2240 xfree (var->dynamic);
2245 do_free_variable_cleanup (void *var)
2247 free_variable (var);
2250 static struct cleanup *
2251 make_cleanup_free_variable (struct varobj *var)
2253 return make_cleanup (do_free_variable_cleanup, var);
2256 /* Return the type of the value that's stored in VAR,
2257 or that would have being stored there if the
2258 value were accessible.
2260 This differs from VAR->type in that VAR->type is always
2261 the true type of the expession in the source language.
2262 The return value of this function is the type we're
2263 actually storing in varobj, and using for displaying
2264 the values and for comparing previous and new values.
2266 For example, top-level references are always stripped. */
2268 varobj_get_value_type (struct varobj *var)
2273 type = value_type (var->value);
2277 type = check_typedef (type);
2279 if (TYPE_CODE (type) == TYPE_CODE_REF)
2280 type = get_target_type (type);
2282 type = check_typedef (type);
2287 /* What is the default display for this variable? We assume that
2288 everything is "natural". Any exceptions? */
2289 static enum varobj_display_formats
2290 variable_default_display (struct varobj *var)
2292 return FORMAT_NATURAL;
2295 /* FIXME: The following should be generic for any pointer. */
2297 cppush (struct cpstack **pstack, char *name)
2301 s = (struct cpstack *) xmalloc (sizeof (struct cpstack));
2307 /* FIXME: The following should be generic for any pointer. */
2309 cppop (struct cpstack **pstack)
2314 if ((*pstack)->name == NULL && (*pstack)->next == NULL)
2319 *pstack = (*pstack)->next;
2326 * Language-dependencies
2329 /* Common entry points */
2331 /* Return the number of children for a given variable.
2332 The result of this function is defined by the language
2333 implementation. The number of children returned by this function
2334 is the number of children that the user will see in the variable
2337 number_of_children (struct varobj *var)
2339 return (*var->root->lang_ops->number_of_children) (var);
2342 /* What is the expression for the root varobj VAR? Returns a malloc'd
2345 name_of_variable (struct varobj *var)
2347 return (*var->root->lang_ops->name_of_variable) (var);
2350 /* What is the name of the INDEX'th child of VAR? Returns a malloc'd
2353 name_of_child (struct varobj *var, int index)
2355 return (*var->root->lang_ops->name_of_child) (var, index);
2358 /* If frame associated with VAR can be found, switch
2359 to it and return 1. Otherwise, return 0. */
2362 check_scope (struct varobj *var)
2364 struct frame_info *fi;
2367 fi = frame_find_by_id (var->root->frame);
2372 CORE_ADDR pc = get_frame_pc (fi);
2374 if (pc < BLOCK_START (var->root->valid_block) ||
2375 pc >= BLOCK_END (var->root->valid_block))
2383 /* Helper function to value_of_root. */
2385 static struct value *
2386 value_of_root_1 (struct varobj **var_handle)
2388 struct value *new_val = NULL;
2389 struct varobj *var = *var_handle;
2390 int within_scope = 0;
2391 struct cleanup *back_to;
2393 /* Only root variables can be updated... */
2394 if (!is_root_p (var))
2395 /* Not a root var. */
2398 back_to = make_cleanup_restore_current_thread ();
2400 /* Determine whether the variable is still around. */
2401 if (var->root->valid_block == NULL || var->root->floating)
2403 else if (var->root->thread_id == 0)
2405 /* The program was single-threaded when the variable object was
2406 created. Technically, it's possible that the program became
2407 multi-threaded since then, but we don't support such
2409 within_scope = check_scope (var);
2413 ptid_t ptid = thread_id_to_pid (var->root->thread_id);
2414 if (in_thread_list (ptid))
2416 switch_to_thread (ptid);
2417 within_scope = check_scope (var);
2423 volatile struct gdb_exception except;
2425 /* We need to catch errors here, because if evaluate
2426 expression fails we want to just return NULL. */
2427 TRY_CATCH (except, RETURN_MASK_ERROR)
2429 new_val = evaluate_expression (var->root->exp);
2433 do_cleanups (back_to);
2438 /* What is the ``struct value *'' of the root variable VAR?
2439 For floating variable object, evaluation can get us a value
2440 of different type from what is stored in varobj already. In
2442 - *type_changed will be set to 1
2443 - old varobj will be freed, and new one will be
2444 created, with the same name.
2445 - *var_handle will be set to the new varobj
2446 Otherwise, *type_changed will be set to 0. */
2447 static struct value *
2448 value_of_root (struct varobj **var_handle, int *type_changed)
2452 if (var_handle == NULL)
2457 /* This should really be an exception, since this should
2458 only get called with a root variable. */
2460 if (!is_root_p (var))
2463 if (var->root->floating)
2465 struct varobj *tmp_var;
2466 char *old_type, *new_type;
2468 tmp_var = varobj_create (NULL, var->name, (CORE_ADDR) 0,
2469 USE_SELECTED_FRAME);
2470 if (tmp_var == NULL)
2474 old_type = varobj_get_type (var);
2475 new_type = varobj_get_type (tmp_var);
2476 if (strcmp (old_type, new_type) == 0)
2478 /* The expression presently stored inside var->root->exp
2479 remembers the locations of local variables relatively to
2480 the frame where the expression was created (in DWARF location
2481 button, for example). Naturally, those locations are not
2482 correct in other frames, so update the expression. */
2484 struct expression *tmp_exp = var->root->exp;
2486 var->root->exp = tmp_var->root->exp;
2487 tmp_var->root->exp = tmp_exp;
2489 varobj_delete (tmp_var, NULL, 0);
2494 tmp_var->obj_name = xstrdup (var->obj_name);
2495 tmp_var->from = var->from;
2496 tmp_var->to = var->to;
2497 varobj_delete (var, NULL, 0);
2499 install_variable (tmp_var);
2500 *var_handle = tmp_var;
2513 struct value *value;
2515 value = value_of_root_1 (var_handle);
2516 if (var->value == NULL || value == NULL)
2518 /* For root varobj-s, a NULL value indicates a scoping issue.
2519 So, nothing to do in terms of checking for mutations. */
2521 else if (varobj_value_has_mutated (var, value, value_type (value)))
2523 /* The type has mutated, so the children are no longer valid.
2524 Just delete them, and tell our caller that the type has
2526 varobj_delete (var, NULL, 1 /* only_children */);
2527 var->num_children = -1;
2536 /* What is the ``struct value *'' for the INDEX'th child of PARENT? */
2537 static struct value *
2538 value_of_child (struct varobj *parent, int index)
2540 struct value *value;
2542 value = (*parent->root->lang_ops->value_of_child) (parent, index);
2547 /* GDB already has a command called "value_of_variable". Sigh. */
2549 my_value_of_variable (struct varobj *var, enum varobj_display_formats format)
2551 if (var->root->is_valid)
2553 if (var->dynamic->pretty_printer != NULL)
2554 return varobj_value_get_print_value (var->value, var->format, var);
2555 return (*var->root->lang_ops->value_of_variable) (var, format);
2562 varobj_formatted_print_options (struct value_print_options *opts,
2563 enum varobj_display_formats format)
2565 get_formatted_print_options (opts, format_code[(int) format]);
2566 opts->deref_ref = 0;
2571 varobj_value_get_print_value (struct value *value,
2572 enum varobj_display_formats format,
2575 struct ui_file *stb;
2576 struct cleanup *old_chain;
2577 char *thevalue = NULL;
2578 struct value_print_options opts;
2579 struct type *type = NULL;
2581 char *encoding = NULL;
2582 struct gdbarch *gdbarch = NULL;
2583 /* Initialize it just to avoid a GCC false warning. */
2584 CORE_ADDR str_addr = 0;
2585 int string_print = 0;
2590 stb = mem_fileopen ();
2591 old_chain = make_cleanup_ui_file_delete (stb);
2593 gdbarch = get_type_arch (value_type (value));
2595 if (gdb_python_initialized)
2597 PyObject *value_formatter = var->dynamic->pretty_printer;
2599 varobj_ensure_python_env (var);
2601 if (value_formatter)
2603 /* First check to see if we have any children at all. If so,
2604 we simply return {...}. */
2605 if (dynamic_varobj_has_child_method (var))
2607 do_cleanups (old_chain);
2608 return xstrdup ("{...}");
2611 if (PyObject_HasAttr (value_formatter, gdbpy_to_string_cst))
2613 struct value *replacement;
2614 PyObject *output = NULL;
2616 output = apply_varobj_pretty_printer (value_formatter,
2620 /* If we have string like output ... */
2623 make_cleanup_py_decref (output);
2625 /* If this is a lazy string, extract it. For lazy
2626 strings we always print as a string, so set
2628 if (gdbpy_is_lazy_string (output))
2630 gdbpy_extract_lazy_string (output, &str_addr, &type,
2632 make_cleanup (free_current_contents, &encoding);
2637 /* If it is a regular (non-lazy) string, extract
2638 it and copy the contents into THEVALUE. If the
2639 hint says to print it as a string, set
2640 string_print. Otherwise just return the extracted
2641 string as a value. */
2643 char *s = python_string_to_target_string (output);
2649 hint = gdbpy_get_display_hint (value_formatter);
2652 if (!strcmp (hint, "string"))
2658 thevalue = xmemdup (s, len + 1, len + 1);
2659 type = builtin_type (gdbarch)->builtin_char;
2664 do_cleanups (old_chain);
2668 make_cleanup (xfree, thevalue);
2671 gdbpy_print_stack ();
2674 /* If the printer returned a replacement value, set VALUE
2675 to REPLACEMENT. If there is not a replacement value,
2676 just use the value passed to this function. */
2678 value = replacement;
2684 varobj_formatted_print_options (&opts, format);
2686 /* If the THEVALUE has contents, it is a regular string. */
2688 LA_PRINT_STRING (stb, type, (gdb_byte *) thevalue, len, encoding, 0, &opts);
2689 else if (string_print)
2690 /* Otherwise, if string_print is set, and it is not a regular
2691 string, it is a lazy string. */
2692 val_print_string (type, encoding, str_addr, len, stb, &opts);
2694 /* All other cases. */
2695 common_val_print (value, stb, 0, &opts, current_language);
2697 thevalue = ui_file_xstrdup (stb, NULL);
2699 do_cleanups (old_chain);
2704 varobj_editable_p (struct varobj *var)
2708 if (!(var->root->is_valid && var->value && VALUE_LVAL (var->value)))
2711 type = varobj_get_value_type (var);
2713 switch (TYPE_CODE (type))
2715 case TYPE_CODE_STRUCT:
2716 case TYPE_CODE_UNION:
2717 case TYPE_CODE_ARRAY:
2718 case TYPE_CODE_FUNC:
2719 case TYPE_CODE_METHOD:
2729 /* Call VAR's value_is_changeable_p language-specific callback. */
2732 varobj_value_is_changeable_p (struct varobj *var)
2734 return var->root->lang_ops->value_is_changeable_p (var);
2737 /* Return 1 if that varobj is floating, that is is always evaluated in the
2738 selected frame, and not bound to thread/frame. Such variable objects
2739 are created using '@' as frame specifier to -var-create. */
2741 varobj_floating_p (struct varobj *var)
2743 return var->root->floating;
2746 /* Implement the "value_is_changeable_p" varobj callback for most
2750 varobj_default_value_is_changeable_p (struct varobj *var)
2755 if (CPLUS_FAKE_CHILD (var))
2758 type = varobj_get_value_type (var);
2760 switch (TYPE_CODE (type))
2762 case TYPE_CODE_STRUCT:
2763 case TYPE_CODE_UNION:
2764 case TYPE_CODE_ARRAY:
2775 /* Iterate all the existing _root_ VAROBJs and call the FUNC callback for them
2776 with an arbitrary caller supplied DATA pointer. */
2779 all_root_varobjs (void (*func) (struct varobj *var, void *data), void *data)
2781 struct varobj_root *var_root, *var_root_next;
2783 /* Iterate "safely" - handle if the callee deletes its passed VAROBJ. */
2785 for (var_root = rootlist; var_root != NULL; var_root = var_root_next)
2787 var_root_next = var_root->next;
2789 (*func) (var_root->rootvar, data);
2793 extern void _initialize_varobj (void);
2795 _initialize_varobj (void)
2797 int sizeof_table = sizeof (struct vlist *) * VAROBJ_TABLE_SIZE;
2799 varobj_table = xmalloc (sizeof_table);
2800 memset (varobj_table, 0, sizeof_table);
2802 add_setshow_zuinteger_cmd ("varobj", class_maintenance,
2804 _("Set varobj debugging."),
2805 _("Show varobj debugging."),
2806 _("When non-zero, varobj debugging is enabled."),
2807 NULL, show_varobjdebug,
2808 &setdebuglist, &showdebuglist);
2811 /* Invalidate varobj VAR if it is tied to locals and re-create it if it is
2812 defined on globals. It is a helper for varobj_invalidate.
2814 This function is called after changing the symbol file, in this case the
2815 pointers to "struct type" stored by the varobj are no longer valid. All
2816 varobj must be either re-evaluated, or marked as invalid here. */
2819 varobj_invalidate_iter (struct varobj *var, void *unused)
2821 /* global and floating var must be re-evaluated. */
2822 if (var->root->floating || var->root->valid_block == NULL)
2824 struct varobj *tmp_var;
2826 /* Try to create a varobj with same expression. If we succeed
2827 replace the old varobj, otherwise invalidate it. */
2828 tmp_var = varobj_create (NULL, var->name, (CORE_ADDR) 0,
2830 if (tmp_var != NULL)
2832 tmp_var->obj_name = xstrdup (var->obj_name);
2833 varobj_delete (var, NULL, 0);
2834 install_variable (tmp_var);
2837 var->root->is_valid = 0;
2839 else /* locals must be invalidated. */
2840 var->root->is_valid = 0;
2843 /* Invalidate the varobjs that are tied to locals and re-create the ones that
2844 are defined on globals.
2845 Invalidated varobjs will be always printed in_scope="invalid". */
2848 varobj_invalidate (void)
2850 all_root_varobjs (varobj_invalidate_iter, NULL);