1 /* Implementation of the GDB variable objects API.
3 Copyright (C) 1999-2016 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/>. */
20 #include "expression.h"
26 #include "gdb_regex.h"
30 #include "gdbthread.h"
32 #include "varobj-iter.h"
35 #include "python/python.h"
36 #include "python/python-internal.h"
41 /* Non-zero if we want to see trace of varobj level stuff. */
43 unsigned int varobjdebug
= 0;
45 show_varobjdebug (struct ui_file
*file
, int from_tty
,
46 struct cmd_list_element
*c
, const char *value
)
48 fprintf_filtered (file
, _("Varobj debugging is %s.\n"), value
);
51 /* String representations of gdb's format codes. */
52 char *varobj_format_string
[] =
53 { "natural", "binary", "decimal", "hexadecimal", "octal", "zero-hexadecimal" };
55 /* True if we want to allow Python-based pretty-printing. */
56 static int pretty_printing
= 0;
59 varobj_enable_pretty_printing (void)
66 /* Every root variable has one of these structures saved in its
71 /* The expression for this parent. */
74 /* Block for which this expression is valid. */
75 const struct block
*valid_block
;
77 /* The frame for this expression. This field is set iff valid_block is
79 struct frame_id frame
;
81 /* The global thread ID that this varobj_root belongs to. This field
82 is only valid if valid_block is not NULL.
83 When not 0, indicates which thread 'frame' belongs to.
84 When 0, indicates that the thread list was empty when the varobj_root
88 /* If 1, the -var-update always recomputes the value in the
89 current thread and frame. Otherwise, variable object is
90 always updated in the specific scope/thread/frame. */
93 /* Flag that indicates validity: set to 0 when this varobj_root refers
94 to symbols that do not exist anymore. */
97 /* Language-related operations for this variable and its
99 const struct lang_varobj_ops
*lang_ops
;
101 /* The varobj for this root node. */
102 struct varobj
*rootvar
;
104 /* Next root variable */
105 struct varobj_root
*next
;
108 /* Dynamic part of varobj. */
110 struct varobj_dynamic
112 /* Whether the children of this varobj were requested. This field is
113 used to decide if dynamic varobj should recompute their children.
114 In the event that the frontend never asked for the children, we
116 int children_requested
;
118 /* The pretty-printer constructor. If NULL, then the default
119 pretty-printer will be looked up. If None, then no
120 pretty-printer will be installed. */
121 PyObject
*constructor
;
123 /* The pretty-printer that has been constructed. If NULL, then a
124 new printer object is needed, and one will be constructed. */
125 PyObject
*pretty_printer
;
127 /* The iterator returned by the printer's 'children' method, or NULL
129 struct varobj_iter
*child_iter
;
131 /* We request one extra item from the iterator, so that we can
132 report to the caller whether there are more items than we have
133 already reported. However, we don't want to install this value
134 when we read it, because that will mess up future updates. So,
135 we stash it here instead. */
136 varobj_item
*saved_item
;
139 /* A list of varobjs */
147 /* Private function prototypes */
149 /* Helper functions for the above subcommands. */
151 static int delete_variable (struct varobj
*, int);
153 static void delete_variable_1 (int *, struct varobj
*, int, int);
155 static int install_variable (struct varobj
*);
157 static void uninstall_variable (struct varobj
*);
159 static struct varobj
*create_child (struct varobj
*, int, char *);
161 static struct varobj
*
162 create_child_with_value (struct varobj
*parent
, int index
,
163 struct varobj_item
*item
);
165 /* Utility routines */
167 static struct varobj
*new_variable (void);
169 static struct varobj
*new_root_variable (void);
171 static void free_variable (struct varobj
*var
);
173 static struct cleanup
*make_cleanup_free_variable (struct varobj
*var
);
175 static enum varobj_display_formats
variable_default_display (struct varobj
*);
177 static int update_type_if_necessary (struct varobj
*var
,
178 struct value
*new_value
);
180 static int install_new_value (struct varobj
*var
, struct value
*value
,
183 /* Language-specific routines. */
185 static int number_of_children (const struct varobj
*);
187 static char *name_of_variable (const struct varobj
*);
189 static char *name_of_child (struct varobj
*, int);
191 static struct value
*value_of_root (struct varobj
**var_handle
, int *);
193 static struct value
*value_of_child (const struct varobj
*parent
, int index
);
195 static char *my_value_of_variable (struct varobj
*var
,
196 enum varobj_display_formats format
);
198 static int is_root_p (const struct varobj
*var
);
200 static struct varobj
*varobj_add_child (struct varobj
*var
,
201 struct varobj_item
*item
);
205 /* Mappings of varobj_display_formats enums to gdb's format codes. */
206 static int format_code
[] = { 0, 't', 'd', 'x', 'o', 'z' };
208 /* Header of the list of root variable objects. */
209 static struct varobj_root
*rootlist
;
211 /* Prime number indicating the number of buckets in the hash table. */
212 /* A prime large enough to avoid too many collisions. */
213 #define VAROBJ_TABLE_SIZE 227
215 /* Pointer to the varobj hash table (built at run time). */
216 static struct vlist
**varobj_table
;
220 /* API Implementation */
222 is_root_p (const struct varobj
*var
)
224 return (var
->root
->rootvar
== var
);
228 /* Helper function to install a Python environment suitable for
229 use during operations on VAR. */
231 varobj_ensure_python_env (const struct varobj
*var
)
233 return ensure_python_env (var
->root
->exp
->gdbarch
,
234 var
->root
->exp
->language_defn
);
238 /* Return the full FRAME which corresponds to the given CORE_ADDR
239 or NULL if no FRAME on the chain corresponds to CORE_ADDR. */
241 static struct frame_info
*
242 find_frame_addr_in_frame_chain (CORE_ADDR frame_addr
)
244 struct frame_info
*frame
= NULL
;
246 if (frame_addr
== (CORE_ADDR
) 0)
249 for (frame
= get_current_frame ();
251 frame
= get_prev_frame (frame
))
253 /* The CORE_ADDR we get as argument was parsed from a string GDB
254 output as $fp. This output got truncated to gdbarch_addr_bit.
255 Truncate the frame base address in the same manner before
256 comparing it against our argument. */
257 CORE_ADDR frame_base
= get_frame_base_address (frame
);
258 int addr_bit
= gdbarch_addr_bit (get_frame_arch (frame
));
260 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
261 frame_base
&= ((CORE_ADDR
) 1 << addr_bit
) - 1;
263 if (frame_base
== frame_addr
)
270 /* Creates a varobj (not its children). */
273 varobj_create (char *objname
,
274 char *expression
, CORE_ADDR frame
, enum varobj_type type
)
277 struct cleanup
*old_chain
;
279 /* Fill out a varobj structure for the (root) variable being constructed. */
280 var
= new_root_variable ();
281 old_chain
= make_cleanup_free_variable (var
);
283 if (expression
!= NULL
)
285 struct frame_info
*fi
;
286 struct frame_id old_id
= null_frame_id
;
287 const struct block
*block
;
289 struct value
*value
= NULL
;
292 /* Parse and evaluate the expression, filling in as much of the
293 variable's data as possible. */
295 if (has_stack_frames ())
297 /* Allow creator to specify context of variable. */
298 if ((type
== USE_CURRENT_FRAME
) || (type
== USE_SELECTED_FRAME
))
299 fi
= get_selected_frame (NULL
);
301 /* FIXME: cagney/2002-11-23: This code should be doing a
302 lookup using the frame ID and not just the frame's
303 ``address''. This, of course, means an interface
304 change. However, with out that interface change ISAs,
305 such as the ia64 with its two stacks, won't work.
306 Similar goes for the case where there is a frameless
308 fi
= find_frame_addr_in_frame_chain (frame
);
313 /* frame = -2 means always use selected frame. */
314 if (type
== USE_SELECTED_FRAME
)
315 var
->root
->floating
= 1;
321 block
= get_frame_block (fi
, 0);
322 pc
= get_frame_pc (fi
);
326 innermost_block
= NULL
;
327 /* Wrap the call to parse expression, so we can
328 return a sensible error. */
331 var
->root
->exp
= parse_exp_1 (&p
, pc
, block
, 0);
334 CATCH (except
, RETURN_MASK_ERROR
)
336 do_cleanups (old_chain
);
341 /* Don't allow variables to be created for types. */
342 if (var
->root
->exp
->elts
[0].opcode
== OP_TYPE
343 || var
->root
->exp
->elts
[0].opcode
== OP_TYPEOF
344 || var
->root
->exp
->elts
[0].opcode
== OP_DECLTYPE
)
346 do_cleanups (old_chain
);
347 fprintf_unfiltered (gdb_stderr
, "Attempt to use a type name"
348 " as an expression.\n");
352 var
->format
= variable_default_display (var
);
353 var
->root
->valid_block
= innermost_block
;
354 var
->name
= xstrdup (expression
);
355 /* For a root var, the name and the expr are the same. */
356 var
->path_expr
= xstrdup (expression
);
358 /* When the frame is different from the current frame,
359 we must select the appropriate frame before parsing
360 the expression, otherwise the value will not be current.
361 Since select_frame is so benign, just call it for all cases. */
364 /* User could specify explicit FRAME-ADDR which was not found but
365 EXPRESSION is frame specific and we would not be able to evaluate
366 it correctly next time. With VALID_BLOCK set we must also set
367 FRAME and THREAD_ID. */
369 error (_("Failed to find the specified frame"));
371 var
->root
->frame
= get_frame_id (fi
);
372 var
->root
->thread_id
= ptid_to_global_thread_id (inferior_ptid
);
373 old_id
= get_frame_id (get_selected_frame (NULL
));
377 /* We definitely need to catch errors here.
378 If evaluate_expression succeeds we got the value we wanted.
379 But if it fails, we still go on with a call to evaluate_type(). */
382 value
= evaluate_expression (var
->root
->exp
.get ());
384 CATCH (except
, RETURN_MASK_ERROR
)
386 /* Error getting the value. Try to at least get the
388 struct value
*type_only_value
= evaluate_type (var
->root
->exp
.get ());
390 var
->type
= value_type (type_only_value
);
396 int real_type_found
= 0;
398 var
->type
= value_actual_type (value
, 0, &real_type_found
);
400 value
= value_cast (var
->type
, value
);
403 /* Set language info */
404 var
->root
->lang_ops
= var
->root
->exp
->language_defn
->la_varobj_ops
;
406 install_new_value (var
, value
, 1 /* Initial assignment */);
408 /* Set ourselves as our root. */
409 var
->root
->rootvar
= var
;
411 /* Reset the selected frame. */
412 if (frame_id_p (old_id
))
413 select_frame (frame_find_by_id (old_id
));
416 /* If the variable object name is null, that means this
417 is a temporary variable, so don't install it. */
419 if ((var
!= NULL
) && (objname
!= NULL
))
421 var
->obj_name
= xstrdup (objname
);
423 /* If a varobj name is duplicated, the install will fail so
425 if (!install_variable (var
))
427 do_cleanups (old_chain
);
432 discard_cleanups (old_chain
);
436 /* Generates an unique name that can be used for a varobj. */
439 varobj_gen_name (void)
444 /* Generate a name for this object. */
446 obj_name
= xstrprintf ("var%d", id
);
451 /* Given an OBJNAME, returns the pointer to the corresponding varobj. Call
452 error if OBJNAME cannot be found. */
455 varobj_get_handle (char *objname
)
459 unsigned int index
= 0;
462 for (chp
= objname
; *chp
; chp
++)
464 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
467 cv
= *(varobj_table
+ index
);
468 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, objname
) != 0))
472 error (_("Variable object not found"));
477 /* Given the handle, return the name of the object. */
480 varobj_get_objname (const struct varobj
*var
)
482 return var
->obj_name
;
485 /* Given the handle, return the expression represented by the object. The
486 result must be freed by the caller. */
489 varobj_get_expression (const struct varobj
*var
)
491 return name_of_variable (var
);
497 varobj_delete (struct varobj
*var
, int only_children
)
499 return delete_variable (var
, only_children
);
504 /* Convenience function for varobj_set_visualizer. Instantiate a
505 pretty-printer for a given value. */
507 instantiate_pretty_printer (PyObject
*constructor
, struct value
*value
)
509 PyObject
*val_obj
= NULL
;
512 val_obj
= value_to_value_object (value
);
516 printer
= PyObject_CallFunctionObjArgs (constructor
, val_obj
, NULL
);
523 /* Set/Get variable object display format. */
525 enum varobj_display_formats
526 varobj_set_display_format (struct varobj
*var
,
527 enum varobj_display_formats format
)
534 case FORMAT_HEXADECIMAL
:
536 case FORMAT_ZHEXADECIMAL
:
537 var
->format
= format
;
541 var
->format
= variable_default_display (var
);
544 if (varobj_value_is_changeable_p (var
)
545 && var
->value
&& !value_lazy (var
->value
))
547 xfree (var
->print_value
);
548 var
->print_value
= varobj_value_get_print_value (var
->value
,
555 enum varobj_display_formats
556 varobj_get_display_format (const struct varobj
*var
)
562 varobj_get_display_hint (const struct varobj
*var
)
567 struct cleanup
*back_to
;
569 if (!gdb_python_initialized
)
572 back_to
= varobj_ensure_python_env (var
);
574 if (var
->dynamic
->pretty_printer
!= NULL
)
575 result
= gdbpy_get_display_hint (var
->dynamic
->pretty_printer
);
577 do_cleanups (back_to
);
583 /* Return true if the varobj has items after TO, false otherwise. */
586 varobj_has_more (const struct varobj
*var
, int to
)
588 if (VEC_length (varobj_p
, var
->children
) > to
)
590 return ((to
== -1 || VEC_length (varobj_p
, var
->children
) == to
)
591 && (var
->dynamic
->saved_item
!= NULL
));
594 /* If the variable object is bound to a specific thread, that
595 is its evaluation can always be done in context of a frame
596 inside that thread, returns GDB id of the thread -- which
597 is always positive. Otherwise, returns -1. */
599 varobj_get_thread_id (const struct varobj
*var
)
601 if (var
->root
->valid_block
&& var
->root
->thread_id
> 0)
602 return var
->root
->thread_id
;
608 varobj_set_frozen (struct varobj
*var
, int frozen
)
610 /* When a variable is unfrozen, we don't fetch its value.
611 The 'not_fetched' flag remains set, so next -var-update
614 We don't fetch the value, because for structures the client
615 should do -var-update anyway. It would be bad to have different
616 client-size logic for structure and other types. */
617 var
->frozen
= frozen
;
621 varobj_get_frozen (const struct varobj
*var
)
626 /* A helper function that restricts a range to what is actually
627 available in a VEC. This follows the usual rules for the meaning
628 of FROM and TO -- if either is negative, the entire range is
632 varobj_restrict_range (VEC (varobj_p
) *children
, int *from
, int *to
)
634 if (*from
< 0 || *to
< 0)
637 *to
= VEC_length (varobj_p
, children
);
641 if (*from
> VEC_length (varobj_p
, children
))
642 *from
= VEC_length (varobj_p
, children
);
643 if (*to
> VEC_length (varobj_p
, children
))
644 *to
= VEC_length (varobj_p
, children
);
650 /* A helper for update_dynamic_varobj_children that installs a new
651 child when needed. */
654 install_dynamic_child (struct varobj
*var
,
655 VEC (varobj_p
) **changed
,
656 VEC (varobj_p
) **type_changed
,
657 VEC (varobj_p
) **newobj
,
658 VEC (varobj_p
) **unchanged
,
661 struct varobj_item
*item
)
663 if (VEC_length (varobj_p
, var
->children
) < index
+ 1)
665 /* There's no child yet. */
666 struct varobj
*child
= varobj_add_child (var
, item
);
670 VEC_safe_push (varobj_p
, *newobj
, child
);
676 varobj_p existing
= VEC_index (varobj_p
, var
->children
, index
);
677 int type_updated
= update_type_if_necessary (existing
, item
->value
);
682 VEC_safe_push (varobj_p
, *type_changed
, existing
);
684 if (install_new_value (existing
, item
->value
, 0))
686 if (!type_updated
&& changed
)
687 VEC_safe_push (varobj_p
, *changed
, existing
);
689 else if (!type_updated
&& unchanged
)
690 VEC_safe_push (varobj_p
, *unchanged
, existing
);
697 dynamic_varobj_has_child_method (const struct varobj
*var
)
699 struct cleanup
*back_to
;
700 PyObject
*printer
= var
->dynamic
->pretty_printer
;
703 if (!gdb_python_initialized
)
706 back_to
= varobj_ensure_python_env (var
);
707 result
= PyObject_HasAttr (printer
, gdbpy_children_cst
);
708 do_cleanups (back_to
);
713 /* A factory for creating dynamic varobj's iterators. Returns an
714 iterator object suitable for iterating over VAR's children. */
716 static struct varobj_iter
*
717 varobj_get_iterator (struct varobj
*var
)
720 if (var
->dynamic
->pretty_printer
)
721 return py_varobj_get_iterator (var
, var
->dynamic
->pretty_printer
);
724 gdb_assert_not_reached (_("\
725 requested an iterator from a non-dynamic varobj"));
728 /* Release and clear VAR's saved item, if any. */
731 varobj_clear_saved_item (struct varobj_dynamic
*var
)
733 if (var
->saved_item
!= NULL
)
735 value_free (var
->saved_item
->value
);
736 xfree (var
->saved_item
);
737 var
->saved_item
= NULL
;
742 update_dynamic_varobj_children (struct varobj
*var
,
743 VEC (varobj_p
) **changed
,
744 VEC (varobj_p
) **type_changed
,
745 VEC (varobj_p
) **newobj
,
746 VEC (varobj_p
) **unchanged
,
756 if (update_children
|| var
->dynamic
->child_iter
== NULL
)
758 varobj_iter_delete (var
->dynamic
->child_iter
);
759 var
->dynamic
->child_iter
= varobj_get_iterator (var
);
761 varobj_clear_saved_item (var
->dynamic
);
765 if (var
->dynamic
->child_iter
== NULL
)
769 i
= VEC_length (varobj_p
, var
->children
);
771 /* We ask for one extra child, so that MI can report whether there
772 are more children. */
773 for (; to
< 0 || i
< to
+ 1; ++i
)
777 /* See if there was a leftover from last time. */
778 if (var
->dynamic
->saved_item
!= NULL
)
780 item
= var
->dynamic
->saved_item
;
781 var
->dynamic
->saved_item
= NULL
;
785 item
= varobj_iter_next (var
->dynamic
->child_iter
);
786 /* Release vitem->value so its lifetime is not bound to the
787 execution of a command. */
788 if (item
!= NULL
&& item
->value
!= NULL
)
789 release_value_or_incref (item
->value
);
794 /* Iteration is done. Remove iterator from VAR. */
795 varobj_iter_delete (var
->dynamic
->child_iter
);
796 var
->dynamic
->child_iter
= NULL
;
799 /* We don't want to push the extra child on any report list. */
800 if (to
< 0 || i
< to
)
802 int can_mention
= from
< 0 || i
>= from
;
804 install_dynamic_child (var
, can_mention
? changed
: NULL
,
805 can_mention
? type_changed
: NULL
,
806 can_mention
? newobj
: NULL
,
807 can_mention
? unchanged
: NULL
,
808 can_mention
? cchanged
: NULL
, i
,
815 var
->dynamic
->saved_item
= item
;
817 /* We want to truncate the child list just before this
823 if (i
< VEC_length (varobj_p
, var
->children
))
828 for (j
= i
; j
< VEC_length (varobj_p
, var
->children
); ++j
)
829 varobj_delete (VEC_index (varobj_p
, var
->children
, j
), 0);
830 VEC_truncate (varobj_p
, var
->children
, i
);
833 /* If there are fewer children than requested, note that the list of
835 if (to
>= 0 && VEC_length (varobj_p
, var
->children
) < to
)
838 var
->num_children
= VEC_length (varobj_p
, var
->children
);
844 varobj_get_num_children (struct varobj
*var
)
846 if (var
->num_children
== -1)
848 if (varobj_is_dynamic_p (var
))
852 /* If we have a dynamic varobj, don't report -1 children.
853 So, try to fetch some children first. */
854 update_dynamic_varobj_children (var
, NULL
, NULL
, NULL
, NULL
, &dummy
,
858 var
->num_children
= number_of_children (var
);
861 return var
->num_children
>= 0 ? var
->num_children
: 0;
864 /* Creates a list of the immediate children of a variable object;
865 the return code is the number of such children or -1 on error. */
868 varobj_list_children (struct varobj
*var
, int *from
, int *to
)
871 int i
, children_changed
;
873 var
->dynamic
->children_requested
= 1;
875 if (varobj_is_dynamic_p (var
))
877 /* This, in theory, can result in the number of children changing without
878 frontend noticing. But well, calling -var-list-children on the same
879 varobj twice is not something a sane frontend would do. */
880 update_dynamic_varobj_children (var
, NULL
, NULL
, NULL
, NULL
,
881 &children_changed
, 0, 0, *to
);
882 varobj_restrict_range (var
->children
, from
, to
);
883 return var
->children
;
886 if (var
->num_children
== -1)
887 var
->num_children
= number_of_children (var
);
889 /* If that failed, give up. */
890 if (var
->num_children
== -1)
891 return var
->children
;
893 /* If we're called when the list of children is not yet initialized,
894 allocate enough elements in it. */
895 while (VEC_length (varobj_p
, var
->children
) < var
->num_children
)
896 VEC_safe_push (varobj_p
, var
->children
, NULL
);
898 for (i
= 0; i
< var
->num_children
; i
++)
900 varobj_p existing
= VEC_index (varobj_p
, var
->children
, i
);
902 if (existing
== NULL
)
904 /* Either it's the first call to varobj_list_children for
905 this variable object, and the child was never created,
906 or it was explicitly deleted by the client. */
907 name
= name_of_child (var
, i
);
908 existing
= create_child (var
, i
, name
);
909 VEC_replace (varobj_p
, var
->children
, i
, existing
);
913 varobj_restrict_range (var
->children
, from
, to
);
914 return var
->children
;
917 static struct varobj
*
918 varobj_add_child (struct varobj
*var
, struct varobj_item
*item
)
920 varobj_p v
= create_child_with_value (var
,
921 VEC_length (varobj_p
, var
->children
),
924 VEC_safe_push (varobj_p
, var
->children
, v
);
928 /* Obtain the type of an object Variable as a string similar to the one gdb
929 prints on the console. The caller is responsible for freeing the string.
933 varobj_get_type (struct varobj
*var
)
935 /* For the "fake" variables, do not return a type. (Its type is
937 Do not return a type for invalid variables as well. */
938 if (CPLUS_FAKE_CHILD (var
) || !var
->root
->is_valid
)
941 return type_to_string (var
->type
);
944 /* Obtain the type of an object variable. */
947 varobj_get_gdb_type (const struct varobj
*var
)
952 /* Is VAR a path expression parent, i.e., can it be used to construct
953 a valid path expression? */
956 is_path_expr_parent (const struct varobj
*var
)
958 gdb_assert (var
->root
->lang_ops
->is_path_expr_parent
!= NULL
);
959 return var
->root
->lang_ops
->is_path_expr_parent (var
);
962 /* Is VAR a path expression parent, i.e., can it be used to construct
963 a valid path expression? By default we assume any VAR can be a path
967 varobj_default_is_path_expr_parent (const struct varobj
*var
)
972 /* Return the path expression parent for VAR. */
974 const struct varobj
*
975 varobj_get_path_expr_parent (const struct varobj
*var
)
977 const struct varobj
*parent
= var
;
979 while (!is_root_p (parent
) && !is_path_expr_parent (parent
))
980 parent
= parent
->parent
;
985 /* Return a pointer to the full rooted expression of varobj VAR.
986 If it has not been computed yet, compute it. */
988 varobj_get_path_expr (const struct varobj
*var
)
990 if (var
->path_expr
== NULL
)
992 /* For root varobjs, we initialize path_expr
993 when creating varobj, so here it should be
995 struct varobj
*mutable_var
= (struct varobj
*) var
;
996 gdb_assert (!is_root_p (var
));
998 mutable_var
->path_expr
= (*var
->root
->lang_ops
->path_expr_of_child
) (var
);
1001 return var
->path_expr
;
1004 const struct language_defn
*
1005 varobj_get_language (const struct varobj
*var
)
1007 return var
->root
->exp
->language_defn
;
1011 varobj_get_attributes (const struct varobj
*var
)
1015 if (varobj_editable_p (var
))
1016 /* FIXME: define masks for attributes. */
1017 attributes
|= 0x00000001; /* Editable */
1022 /* Return true if VAR is a dynamic varobj. */
1025 varobj_is_dynamic_p (const struct varobj
*var
)
1027 return var
->dynamic
->pretty_printer
!= NULL
;
1031 varobj_get_formatted_value (struct varobj
*var
,
1032 enum varobj_display_formats format
)
1034 return my_value_of_variable (var
, format
);
1038 varobj_get_value (struct varobj
*var
)
1040 return my_value_of_variable (var
, var
->format
);
1043 /* Set the value of an object variable (if it is editable) to the
1044 value of the given expression. */
1045 /* Note: Invokes functions that can call error(). */
1048 varobj_set_value (struct varobj
*var
, char *expression
)
1050 struct value
*val
= NULL
; /* Initialize to keep gcc happy. */
1051 /* The argument "expression" contains the variable's new value.
1052 We need to first construct a legal expression for this -- ugh! */
1053 /* Does this cover all the bases? */
1054 struct value
*value
= NULL
; /* Initialize to keep gcc happy. */
1055 int saved_input_radix
= input_radix
;
1056 const char *s
= expression
;
1058 gdb_assert (varobj_editable_p (var
));
1060 input_radix
= 10; /* ALWAYS reset to decimal temporarily. */
1061 expression_up exp
= parse_exp_1 (&s
, 0, 0, 0);
1064 value
= evaluate_expression (exp
.get ());
1067 CATCH (except
, RETURN_MASK_ERROR
)
1069 /* We cannot proceed without a valid expression. */
1074 /* All types that are editable must also be changeable. */
1075 gdb_assert (varobj_value_is_changeable_p (var
));
1077 /* The value of a changeable variable object must not be lazy. */
1078 gdb_assert (!value_lazy (var
->value
));
1080 /* Need to coerce the input. We want to check if the
1081 value of the variable object will be different
1082 after assignment, and the first thing value_assign
1083 does is coerce the input.
1084 For example, if we are assigning an array to a pointer variable we
1085 should compare the pointer with the array's address, not with the
1087 value
= coerce_array (value
);
1089 /* The new value may be lazy. value_assign, or
1090 rather value_contents, will take care of this. */
1093 val
= value_assign (var
->value
, value
);
1096 CATCH (except
, RETURN_MASK_ERROR
)
1102 /* If the value has changed, record it, so that next -var-update can
1103 report this change. If a variable had a value of '1', we've set it
1104 to '333' and then set again to '1', when -var-update will report this
1105 variable as changed -- because the first assignment has set the
1106 'updated' flag. There's no need to optimize that, because return value
1107 of -var-update should be considered an approximation. */
1108 var
->updated
= install_new_value (var
, val
, 0 /* Compare values. */);
1109 input_radix
= saved_input_radix
;
1115 /* A helper function to install a constructor function and visualizer
1116 in a varobj_dynamic. */
1119 install_visualizer (struct varobj_dynamic
*var
, PyObject
*constructor
,
1120 PyObject
*visualizer
)
1122 Py_XDECREF (var
->constructor
);
1123 var
->constructor
= constructor
;
1125 Py_XDECREF (var
->pretty_printer
);
1126 var
->pretty_printer
= visualizer
;
1128 varobj_iter_delete (var
->child_iter
);
1129 var
->child_iter
= NULL
;
1132 /* Install the default visualizer for VAR. */
1135 install_default_visualizer (struct varobj
*var
)
1137 /* Do not install a visualizer on a CPLUS_FAKE_CHILD. */
1138 if (CPLUS_FAKE_CHILD (var
))
1141 if (pretty_printing
)
1143 PyObject
*pretty_printer
= NULL
;
1147 pretty_printer
= gdbpy_get_varobj_pretty_printer (var
->value
);
1148 if (! pretty_printer
)
1150 gdbpy_print_stack ();
1151 error (_("Cannot instantiate printer for default visualizer"));
1155 if (pretty_printer
== Py_None
)
1157 Py_DECREF (pretty_printer
);
1158 pretty_printer
= NULL
;
1161 install_visualizer (var
->dynamic
, NULL
, pretty_printer
);
1165 /* Instantiate and install a visualizer for VAR using CONSTRUCTOR to
1166 make a new object. */
1169 construct_visualizer (struct varobj
*var
, PyObject
*constructor
)
1171 PyObject
*pretty_printer
;
1173 /* Do not install a visualizer on a CPLUS_FAKE_CHILD. */
1174 if (CPLUS_FAKE_CHILD (var
))
1177 Py_INCREF (constructor
);
1178 if (constructor
== Py_None
)
1179 pretty_printer
= NULL
;
1182 pretty_printer
= instantiate_pretty_printer (constructor
, var
->value
);
1183 if (! pretty_printer
)
1185 gdbpy_print_stack ();
1186 Py_DECREF (constructor
);
1187 constructor
= Py_None
;
1188 Py_INCREF (constructor
);
1191 if (pretty_printer
== Py_None
)
1193 Py_DECREF (pretty_printer
);
1194 pretty_printer
= NULL
;
1198 install_visualizer (var
->dynamic
, constructor
, pretty_printer
);
1201 #endif /* HAVE_PYTHON */
1203 /* A helper function for install_new_value. This creates and installs
1204 a visualizer for VAR, if appropriate. */
1207 install_new_value_visualizer (struct varobj
*var
)
1210 /* If the constructor is None, then we want the raw value. If VAR
1211 does not have a value, just skip this. */
1212 if (!gdb_python_initialized
)
1215 if (var
->dynamic
->constructor
!= Py_None
&& var
->value
!= NULL
)
1217 struct cleanup
*cleanup
;
1219 cleanup
= varobj_ensure_python_env (var
);
1221 if (var
->dynamic
->constructor
== NULL
)
1222 install_default_visualizer (var
);
1224 construct_visualizer (var
, var
->dynamic
->constructor
);
1226 do_cleanups (cleanup
);
1233 /* When using RTTI to determine variable type it may be changed in runtime when
1234 the variable value is changed. This function checks whether type of varobj
1235 VAR will change when a new value NEW_VALUE is assigned and if it is so
1236 updates the type of VAR. */
1239 update_type_if_necessary (struct varobj
*var
, struct value
*new_value
)
1243 struct value_print_options opts
;
1245 get_user_print_options (&opts
);
1246 if (opts
.objectprint
)
1248 struct type
*new_type
;
1249 char *curr_type_str
, *new_type_str
;
1250 int type_name_changed
;
1252 new_type
= value_actual_type (new_value
, 0, 0);
1253 new_type_str
= type_to_string (new_type
);
1254 curr_type_str
= varobj_get_type (var
);
1255 type_name_changed
= strcmp (curr_type_str
, new_type_str
) != 0;
1256 xfree (curr_type_str
);
1257 xfree (new_type_str
);
1259 if (type_name_changed
)
1261 var
->type
= new_type
;
1263 /* This information may be not valid for a new type. */
1264 varobj_delete (var
, 1);
1265 VEC_free (varobj_p
, var
->children
);
1266 var
->num_children
= -1;
1275 /* Assign a new value to a variable object. If INITIAL is non-zero,
1276 this is the first assignement after the variable object was just
1277 created, or changed type. In that case, just assign the value
1279 Otherwise, assign the new value, and return 1 if the value is
1280 different from the current one, 0 otherwise. The comparison is
1281 done on textual representation of value. Therefore, some types
1282 need not be compared. E.g. for structures the reported value is
1283 always "{...}", so no comparison is necessary here. If the old
1284 value was NULL and new one is not, or vice versa, we always return 1.
1286 The VALUE parameter should not be released -- the function will
1287 take care of releasing it when needed. */
1289 install_new_value (struct varobj
*var
, struct value
*value
, int initial
)
1294 int intentionally_not_fetched
= 0;
1295 char *print_value
= NULL
;
1297 /* We need to know the varobj's type to decide if the value should
1298 be fetched or not. C++ fake children (public/protected/private)
1299 don't have a type. */
1300 gdb_assert (var
->type
|| CPLUS_FAKE_CHILD (var
));
1301 changeable
= varobj_value_is_changeable_p (var
);
1303 /* If the type has custom visualizer, we consider it to be always
1304 changeable. FIXME: need to make sure this behaviour will not
1305 mess up read-sensitive values. */
1306 if (var
->dynamic
->pretty_printer
!= NULL
)
1309 need_to_fetch
= changeable
;
1311 /* We are not interested in the address of references, and given
1312 that in C++ a reference is not rebindable, it cannot
1313 meaningfully change. So, get hold of the real value. */
1315 value
= coerce_ref (value
);
1317 if (var
->type
&& TYPE_CODE (var
->type
) == TYPE_CODE_UNION
)
1318 /* For unions, we need to fetch the value implicitly because
1319 of implementation of union member fetch. When gdb
1320 creates a value for a field and the value of the enclosing
1321 structure is not lazy, it immediately copies the necessary
1322 bytes from the enclosing values. If the enclosing value is
1323 lazy, the call to value_fetch_lazy on the field will read
1324 the data from memory. For unions, that means we'll read the
1325 same memory more than once, which is not desirable. So
1329 /* The new value might be lazy. If the type is changeable,
1330 that is we'll be comparing values of this type, fetch the
1331 value now. Otherwise, on the next update the old value
1332 will be lazy, which means we've lost that old value. */
1333 if (need_to_fetch
&& value
&& value_lazy (value
))
1335 const struct varobj
*parent
= var
->parent
;
1336 int frozen
= var
->frozen
;
1338 for (; !frozen
&& parent
; parent
= parent
->parent
)
1339 frozen
|= parent
->frozen
;
1341 if (frozen
&& initial
)
1343 /* For variables that are frozen, or are children of frozen
1344 variables, we don't do fetch on initial assignment.
1345 For non-initial assignemnt we do the fetch, since it means we're
1346 explicitly asked to compare the new value with the old one. */
1347 intentionally_not_fetched
= 1;
1354 value_fetch_lazy (value
);
1357 CATCH (except
, RETURN_MASK_ERROR
)
1359 /* Set the value to NULL, so that for the next -var-update,
1360 we don't try to compare the new value with this value,
1361 that we couldn't even read. */
1368 /* Get a reference now, before possibly passing it to any Python
1369 code that might release it. */
1371 value_incref (value
);
1373 /* Below, we'll be comparing string rendering of old and new
1374 values. Don't get string rendering if the value is
1375 lazy -- if it is, the code above has decided that the value
1376 should not be fetched. */
1377 if (value
!= NULL
&& !value_lazy (value
)
1378 && var
->dynamic
->pretty_printer
== NULL
)
1379 print_value
= varobj_value_get_print_value (value
, var
->format
, var
);
1381 /* If the type is changeable, compare the old and the new values.
1382 If this is the initial assignment, we don't have any old value
1384 if (!initial
&& changeable
)
1386 /* If the value of the varobj was changed by -var-set-value,
1387 then the value in the varobj and in the target is the same.
1388 However, that value is different from the value that the
1389 varobj had after the previous -var-update. So need to the
1390 varobj as changed. */
1395 else if (var
->dynamic
->pretty_printer
== NULL
)
1397 /* Try to compare the values. That requires that both
1398 values are non-lazy. */
1399 if (var
->not_fetched
&& value_lazy (var
->value
))
1401 /* This is a frozen varobj and the value was never read.
1402 Presumably, UI shows some "never read" indicator.
1403 Now that we've fetched the real value, we need to report
1404 this varobj as changed so that UI can show the real
1408 else if (var
->value
== NULL
&& value
== NULL
)
1411 else if (var
->value
== NULL
|| value
== NULL
)
1417 gdb_assert (!value_lazy (var
->value
));
1418 gdb_assert (!value_lazy (value
));
1420 gdb_assert (var
->print_value
!= NULL
&& print_value
!= NULL
);
1421 if (strcmp (var
->print_value
, print_value
) != 0)
1427 if (!initial
&& !changeable
)
1429 /* For values that are not changeable, we don't compare the values.
1430 However, we want to notice if a value was not NULL and now is NULL,
1431 or vise versa, so that we report when top-level varobjs come in scope
1432 and leave the scope. */
1433 changed
= (var
->value
!= NULL
) != (value
!= NULL
);
1436 /* We must always keep the new value, since children depend on it. */
1437 if (var
->value
!= NULL
&& var
->value
!= value
)
1438 value_free (var
->value
);
1440 if (value
&& value_lazy (value
) && intentionally_not_fetched
)
1441 var
->not_fetched
= 1;
1443 var
->not_fetched
= 0;
1446 install_new_value_visualizer (var
);
1448 /* If we installed a pretty-printer, re-compare the printed version
1449 to see if the variable changed. */
1450 if (var
->dynamic
->pretty_printer
!= NULL
)
1452 xfree (print_value
);
1453 print_value
= varobj_value_get_print_value (var
->value
, var
->format
,
1455 if ((var
->print_value
== NULL
&& print_value
!= NULL
)
1456 || (var
->print_value
!= NULL
&& print_value
== NULL
)
1457 || (var
->print_value
!= NULL
&& print_value
!= NULL
1458 && strcmp (var
->print_value
, print_value
) != 0))
1461 if (var
->print_value
)
1462 xfree (var
->print_value
);
1463 var
->print_value
= print_value
;
1465 gdb_assert (!var
->value
|| value_type (var
->value
));
1470 /* Return the requested range for a varobj. VAR is the varobj. FROM
1471 and TO are out parameters; *FROM and *TO will be set to the
1472 selected sub-range of VAR. If no range was selected using
1473 -var-set-update-range, then both will be -1. */
1475 varobj_get_child_range (const struct varobj
*var
, int *from
, int *to
)
1481 /* Set the selected sub-range of children of VAR to start at index
1482 FROM and end at index TO. If either FROM or TO is less than zero,
1483 this is interpreted as a request for all children. */
1485 varobj_set_child_range (struct varobj
*var
, int from
, int to
)
1492 varobj_set_visualizer (struct varobj
*var
, const char *visualizer
)
1495 PyObject
*mainmod
, *globals
, *constructor
;
1496 struct cleanup
*back_to
;
1498 if (!gdb_python_initialized
)
1501 back_to
= varobj_ensure_python_env (var
);
1503 mainmod
= PyImport_AddModule ("__main__");
1504 globals
= PyModule_GetDict (mainmod
);
1505 Py_INCREF (globals
);
1506 make_cleanup_py_decref (globals
);
1508 constructor
= PyRun_String (visualizer
, Py_eval_input
, globals
, globals
);
1512 gdbpy_print_stack ();
1513 error (_("Could not evaluate visualizer expression: %s"), visualizer
);
1516 construct_visualizer (var
, constructor
);
1517 Py_XDECREF (constructor
);
1519 /* If there are any children now, wipe them. */
1520 varobj_delete (var
, 1 /* children only */);
1521 var
->num_children
= -1;
1523 do_cleanups (back_to
);
1525 error (_("Python support required"));
1529 /* If NEW_VALUE is the new value of the given varobj (var), return
1530 non-zero if var has mutated. In other words, if the type of
1531 the new value is different from the type of the varobj's old
1534 NEW_VALUE may be NULL, if the varobj is now out of scope. */
1537 varobj_value_has_mutated (const struct varobj
*var
, struct value
*new_value
,
1538 struct type
*new_type
)
1540 /* If we haven't previously computed the number of children in var,
1541 it does not matter from the front-end's perspective whether
1542 the type has mutated or not. For all intents and purposes,
1543 it has not mutated. */
1544 if (var
->num_children
< 0)
1547 if (var
->root
->lang_ops
->value_has_mutated
)
1549 /* The varobj module, when installing new values, explicitly strips
1550 references, saying that we're not interested in those addresses.
1551 But detection of mutation happens before installing the new
1552 value, so our value may be a reference that we need to strip
1553 in order to remain consistent. */
1554 if (new_value
!= NULL
)
1555 new_value
= coerce_ref (new_value
);
1556 return var
->root
->lang_ops
->value_has_mutated (var
, new_value
, new_type
);
1562 /* Update the values for a variable and its children. This is a
1563 two-pronged attack. First, re-parse the value for the root's
1564 expression to see if it's changed. Then go all the way
1565 through its children, reconstructing them and noting if they've
1568 The EXPLICIT parameter specifies if this call is result
1569 of MI request to update this specific variable, or
1570 result of implicit -var-update *. For implicit request, we don't
1571 update frozen variables.
1573 NOTE: This function may delete the caller's varobj. If it
1574 returns TYPE_CHANGED, then it has done this and VARP will be modified
1575 to point to the new varobj. */
1577 VEC(varobj_update_result
) *
1578 varobj_update (struct varobj
**varp
, int is_explicit
)
1580 int type_changed
= 0;
1582 struct value
*newobj
;
1583 VEC (varobj_update_result
) *stack
= NULL
;
1584 VEC (varobj_update_result
) *result
= NULL
;
1586 /* Frozen means frozen -- we don't check for any change in
1587 this varobj, including its going out of scope, or
1588 changing type. One use case for frozen varobjs is
1589 retaining previously evaluated expressions, and we don't
1590 want them to be reevaluated at all. */
1591 if (!is_explicit
&& (*varp
)->frozen
)
1594 if (!(*varp
)->root
->is_valid
)
1596 varobj_update_result r
= {0};
1599 r
.status
= VAROBJ_INVALID
;
1600 VEC_safe_push (varobj_update_result
, result
, &r
);
1604 if ((*varp
)->root
->rootvar
== *varp
)
1606 varobj_update_result r
= {0};
1609 r
.status
= VAROBJ_IN_SCOPE
;
1611 /* Update the root variable. value_of_root can return NULL
1612 if the variable is no longer around, i.e. we stepped out of
1613 the frame in which a local existed. We are letting the
1614 value_of_root variable dispose of the varobj if the type
1616 newobj
= value_of_root (varp
, &type_changed
);
1617 if (update_type_if_necessary(*varp
, newobj
))
1620 r
.type_changed
= type_changed
;
1621 if (install_new_value ((*varp
), newobj
, type_changed
))
1625 r
.status
= VAROBJ_NOT_IN_SCOPE
;
1626 r
.value_installed
= 1;
1628 if (r
.status
== VAROBJ_NOT_IN_SCOPE
)
1630 if (r
.type_changed
|| r
.changed
)
1631 VEC_safe_push (varobj_update_result
, result
, &r
);
1635 VEC_safe_push (varobj_update_result
, stack
, &r
);
1639 varobj_update_result r
= {0};
1642 VEC_safe_push (varobj_update_result
, stack
, &r
);
1645 /* Walk through the children, reconstructing them all. */
1646 while (!VEC_empty (varobj_update_result
, stack
))
1648 varobj_update_result r
= *(VEC_last (varobj_update_result
, stack
));
1649 struct varobj
*v
= r
.varobj
;
1651 VEC_pop (varobj_update_result
, stack
);
1653 /* Update this variable, unless it's a root, which is already
1655 if (!r
.value_installed
)
1657 struct type
*new_type
;
1659 newobj
= value_of_child (v
->parent
, v
->index
);
1660 if (update_type_if_necessary(v
, newobj
))
1663 new_type
= value_type (newobj
);
1665 new_type
= v
->root
->lang_ops
->type_of_child (v
->parent
, v
->index
);
1667 if (varobj_value_has_mutated (v
, newobj
, new_type
))
1669 /* The children are no longer valid; delete them now.
1670 Report the fact that its type changed as well. */
1671 varobj_delete (v
, 1 /* only_children */);
1672 v
->num_children
= -1;
1679 if (install_new_value (v
, newobj
, r
.type_changed
))
1686 /* We probably should not get children of a dynamic varobj, but
1687 for which -var-list-children was never invoked. */
1688 if (varobj_is_dynamic_p (v
))
1690 VEC (varobj_p
) *changed
= 0, *type_changed
= 0, *unchanged
= 0;
1691 VEC (varobj_p
) *newobj
= 0;
1692 int i
, children_changed
= 0;
1697 if (!v
->dynamic
->children_requested
)
1701 /* If we initially did not have potential children, but
1702 now we do, consider the varobj as changed.
1703 Otherwise, if children were never requested, consider
1704 it as unchanged -- presumably, such varobj is not yet
1705 expanded in the UI, so we need not bother getting
1707 if (!varobj_has_more (v
, 0))
1709 update_dynamic_varobj_children (v
, NULL
, NULL
, NULL
, NULL
,
1711 if (varobj_has_more (v
, 0))
1716 VEC_safe_push (varobj_update_result
, result
, &r
);
1721 /* If update_dynamic_varobj_children returns 0, then we have
1722 a non-conforming pretty-printer, so we skip it. */
1723 if (update_dynamic_varobj_children (v
, &changed
, &type_changed
, &newobj
,
1724 &unchanged
, &children_changed
, 1,
1727 if (children_changed
|| newobj
)
1729 r
.children_changed
= 1;
1732 /* Push in reverse order so that the first child is
1733 popped from the work stack first, and so will be
1734 added to result first. This does not affect
1735 correctness, just "nicer". */
1736 for (i
= VEC_length (varobj_p
, type_changed
) - 1; i
>= 0; --i
)
1738 varobj_p tmp
= VEC_index (varobj_p
, type_changed
, i
);
1739 varobj_update_result r
= {0};
1741 /* Type may change only if value was changed. */
1745 r
.value_installed
= 1;
1746 VEC_safe_push (varobj_update_result
, stack
, &r
);
1748 for (i
= VEC_length (varobj_p
, changed
) - 1; i
>= 0; --i
)
1750 varobj_p tmp
= VEC_index (varobj_p
, changed
, i
);
1751 varobj_update_result r
= {0};
1755 r
.value_installed
= 1;
1756 VEC_safe_push (varobj_update_result
, stack
, &r
);
1758 for (i
= VEC_length (varobj_p
, unchanged
) - 1; i
>= 0; --i
)
1760 varobj_p tmp
= VEC_index (varobj_p
, unchanged
, i
);
1764 varobj_update_result r
= {0};
1767 r
.value_installed
= 1;
1768 VEC_safe_push (varobj_update_result
, stack
, &r
);
1771 if (r
.changed
|| r
.children_changed
)
1772 VEC_safe_push (varobj_update_result
, result
, &r
);
1774 /* Free CHANGED, TYPE_CHANGED and UNCHANGED, but not NEW,
1775 because NEW has been put into the result vector. */
1776 VEC_free (varobj_p
, changed
);
1777 VEC_free (varobj_p
, type_changed
);
1778 VEC_free (varobj_p
, unchanged
);
1784 /* Push any children. Use reverse order so that the first
1785 child is popped from the work stack first, and so
1786 will be added to result first. This does not
1787 affect correctness, just "nicer". */
1788 for (i
= VEC_length (varobj_p
, v
->children
)-1; i
>= 0; --i
)
1790 varobj_p c
= VEC_index (varobj_p
, v
->children
, i
);
1792 /* Child may be NULL if explicitly deleted by -var-delete. */
1793 if (c
!= NULL
&& !c
->frozen
)
1795 varobj_update_result r
= {0};
1798 VEC_safe_push (varobj_update_result
, stack
, &r
);
1802 if (r
.changed
|| r
.type_changed
)
1803 VEC_safe_push (varobj_update_result
, result
, &r
);
1806 VEC_free (varobj_update_result
, stack
);
1812 /* Helper functions */
1815 * Variable object construction/destruction
1819 delete_variable (struct varobj
*var
, int only_children_p
)
1823 delete_variable_1 (&delcount
, var
, only_children_p
,
1824 1 /* remove_from_parent_p */ );
1829 /* Delete the variable object VAR and its children. */
1830 /* IMPORTANT NOTE: If we delete a variable which is a child
1831 and the parent is not removed we dump core. It must be always
1832 initially called with remove_from_parent_p set. */
1834 delete_variable_1 (int *delcountp
, struct varobj
*var
, int only_children_p
,
1835 int remove_from_parent_p
)
1839 /* Delete any children of this variable, too. */
1840 for (i
= 0; i
< VEC_length (varobj_p
, var
->children
); ++i
)
1842 varobj_p child
= VEC_index (varobj_p
, var
->children
, i
);
1846 if (!remove_from_parent_p
)
1847 child
->parent
= NULL
;
1848 delete_variable_1 (delcountp
, child
, 0, only_children_p
);
1850 VEC_free (varobj_p
, var
->children
);
1852 /* if we were called to delete only the children we are done here. */
1853 if (only_children_p
)
1856 /* Otherwise, add it to the list of deleted ones and proceed to do so. */
1857 /* If the name is null, this is a temporary variable, that has not
1858 yet been installed, don't report it, it belongs to the caller... */
1859 if (var
->obj_name
!= NULL
)
1861 *delcountp
= *delcountp
+ 1;
1864 /* If this variable has a parent, remove it from its parent's list. */
1865 /* OPTIMIZATION: if the parent of this variable is also being deleted,
1866 (as indicated by remove_from_parent_p) we don't bother doing an
1867 expensive list search to find the element to remove when we are
1868 discarding the list afterwards. */
1869 if ((remove_from_parent_p
) && (var
->parent
!= NULL
))
1871 VEC_replace (varobj_p
, var
->parent
->children
, var
->index
, NULL
);
1874 if (var
->obj_name
!= NULL
)
1875 uninstall_variable (var
);
1877 /* Free memory associated with this variable. */
1878 free_variable (var
);
1881 /* Install the given variable VAR with the object name VAR->OBJ_NAME. */
1883 install_variable (struct varobj
*var
)
1886 struct vlist
*newvl
;
1888 unsigned int index
= 0;
1891 for (chp
= var
->obj_name
; *chp
; chp
++)
1893 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
1896 cv
= *(varobj_table
+ index
);
1897 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, var
->obj_name
) != 0))
1901 error (_("Duplicate variable object name"));
1903 /* Add varobj to hash table. */
1904 newvl
= XNEW (struct vlist
);
1905 newvl
->next
= *(varobj_table
+ index
);
1907 *(varobj_table
+ index
) = newvl
;
1909 /* If root, add varobj to root list. */
1910 if (is_root_p (var
))
1912 /* Add to list of root variables. */
1913 if (rootlist
== NULL
)
1914 var
->root
->next
= NULL
;
1916 var
->root
->next
= rootlist
;
1917 rootlist
= var
->root
;
1923 /* Unistall the object VAR. */
1925 uninstall_variable (struct varobj
*var
)
1929 struct varobj_root
*cr
;
1930 struct varobj_root
*prer
;
1932 unsigned int index
= 0;
1935 /* Remove varobj from hash table. */
1936 for (chp
= var
->obj_name
; *chp
; chp
++)
1938 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
1941 cv
= *(varobj_table
+ index
);
1943 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, var
->obj_name
) != 0))
1950 fprintf_unfiltered (gdb_stdlog
, "Deleting %s\n", var
->obj_name
);
1955 ("Assertion failed: Could not find variable object \"%s\" to delete",
1961 *(varobj_table
+ index
) = cv
->next
;
1963 prev
->next
= cv
->next
;
1967 /* If root, remove varobj from root list. */
1968 if (is_root_p (var
))
1970 /* Remove from list of root variables. */
1971 if (rootlist
== var
->root
)
1972 rootlist
= var
->root
->next
;
1977 while ((cr
!= NULL
) && (cr
->rootvar
!= var
))
1984 warning (_("Assertion failed: Could not find "
1985 "varobj \"%s\" in root list"),
1992 prer
->next
= cr
->next
;
1998 /* Create and install a child of the parent of the given name.
2000 The created VAROBJ takes ownership of the allocated NAME. */
2002 static struct varobj
*
2003 create_child (struct varobj
*parent
, int index
, char *name
)
2005 struct varobj_item item
;
2008 item
.value
= value_of_child (parent
, index
);
2010 return create_child_with_value (parent
, index
, &item
);
2013 static struct varobj
*
2014 create_child_with_value (struct varobj
*parent
, int index
,
2015 struct varobj_item
*item
)
2017 struct varobj
*child
;
2020 child
= new_variable ();
2022 /* NAME is allocated by caller. */
2023 child
->name
= item
->name
;
2024 child
->index
= index
;
2025 child
->parent
= parent
;
2026 child
->root
= parent
->root
;
2028 if (varobj_is_anonymous_child (child
))
2029 childs_name
= xstrprintf ("%s.%d_anonymous", parent
->obj_name
, index
);
2031 childs_name
= xstrprintf ("%s.%s", parent
->obj_name
, item
->name
);
2032 child
->obj_name
= childs_name
;
2034 install_variable (child
);
2036 /* Compute the type of the child. Must do this before
2037 calling install_new_value. */
2038 if (item
->value
!= NULL
)
2039 /* If the child had no evaluation errors, var->value
2040 will be non-NULL and contain a valid type. */
2041 child
->type
= value_actual_type (item
->value
, 0, NULL
);
2043 /* Otherwise, we must compute the type. */
2044 child
->type
= (*child
->root
->lang_ops
->type_of_child
) (child
->parent
,
2046 install_new_value (child
, item
->value
, 1);
2053 * Miscellaneous utility functions.
2056 /* Allocate memory and initialize a new variable. */
2057 static struct varobj
*
2062 var
= XNEW (struct varobj
);
2064 var
->path_expr
= NULL
;
2065 var
->obj_name
= NULL
;
2069 var
->num_children
= -1;
2071 var
->children
= NULL
;
2072 var
->format
= FORMAT_NATURAL
;
2075 var
->print_value
= NULL
;
2077 var
->not_fetched
= 0;
2078 var
->dynamic
= XNEW (struct varobj_dynamic
);
2079 var
->dynamic
->children_requested
= 0;
2082 var
->dynamic
->constructor
= 0;
2083 var
->dynamic
->pretty_printer
= 0;
2084 var
->dynamic
->child_iter
= 0;
2085 var
->dynamic
->saved_item
= 0;
2090 /* Allocate memory and initialize a new root variable. */
2091 static struct varobj
*
2092 new_root_variable (void)
2094 struct varobj
*var
= new_variable ();
2096 var
->root
= new varobj_root ();
2097 var
->root
->lang_ops
= NULL
;
2098 var
->root
->exp
= NULL
;
2099 var
->root
->valid_block
= NULL
;
2100 var
->root
->frame
= null_frame_id
;
2101 var
->root
->floating
= 0;
2102 var
->root
->rootvar
= NULL
;
2103 var
->root
->is_valid
= 1;
2108 /* Free any allocated memory associated with VAR. */
2110 free_variable (struct varobj
*var
)
2113 if (var
->dynamic
->pretty_printer
!= NULL
)
2115 struct cleanup
*cleanup
= varobj_ensure_python_env (var
);
2117 Py_XDECREF (var
->dynamic
->constructor
);
2118 Py_XDECREF (var
->dynamic
->pretty_printer
);
2119 do_cleanups (cleanup
);
2123 varobj_iter_delete (var
->dynamic
->child_iter
);
2124 varobj_clear_saved_item (var
->dynamic
);
2125 value_free (var
->value
);
2127 if (is_root_p (var
))
2131 xfree (var
->obj_name
);
2132 xfree (var
->print_value
);
2133 xfree (var
->path_expr
);
2134 xfree (var
->dynamic
);
2139 do_free_variable_cleanup (void *var
)
2141 free_variable ((struct varobj
*) var
);
2144 static struct cleanup
*
2145 make_cleanup_free_variable (struct varobj
*var
)
2147 return make_cleanup (do_free_variable_cleanup
, var
);
2150 /* Return the type of the value that's stored in VAR,
2151 or that would have being stored there if the
2152 value were accessible.
2154 This differs from VAR->type in that VAR->type is always
2155 the true type of the expession in the source language.
2156 The return value of this function is the type we're
2157 actually storing in varobj, and using for displaying
2158 the values and for comparing previous and new values.
2160 For example, top-level references are always stripped. */
2162 varobj_get_value_type (const struct varobj
*var
)
2167 type
= value_type (var
->value
);
2171 type
= check_typedef (type
);
2173 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
2174 type
= get_target_type (type
);
2176 type
= check_typedef (type
);
2181 /* What is the default display for this variable? We assume that
2182 everything is "natural". Any exceptions? */
2183 static enum varobj_display_formats
2184 variable_default_display (struct varobj
*var
)
2186 return FORMAT_NATURAL
;
2190 * Language-dependencies
2193 /* Common entry points */
2195 /* Return the number of children for a given variable.
2196 The result of this function is defined by the language
2197 implementation. The number of children returned by this function
2198 is the number of children that the user will see in the variable
2201 number_of_children (const struct varobj
*var
)
2203 return (*var
->root
->lang_ops
->number_of_children
) (var
);
2206 /* What is the expression for the root varobj VAR? Returns a malloc'd
2209 name_of_variable (const struct varobj
*var
)
2211 return (*var
->root
->lang_ops
->name_of_variable
) (var
);
2214 /* What is the name of the INDEX'th child of VAR? Returns a malloc'd
2217 name_of_child (struct varobj
*var
, int index
)
2219 return (*var
->root
->lang_ops
->name_of_child
) (var
, index
);
2222 /* If frame associated with VAR can be found, switch
2223 to it and return 1. Otherwise, return 0. */
2226 check_scope (const struct varobj
*var
)
2228 struct frame_info
*fi
;
2231 fi
= frame_find_by_id (var
->root
->frame
);
2236 CORE_ADDR pc
= get_frame_pc (fi
);
2238 if (pc
< BLOCK_START (var
->root
->valid_block
) ||
2239 pc
>= BLOCK_END (var
->root
->valid_block
))
2247 /* Helper function to value_of_root. */
2249 static struct value
*
2250 value_of_root_1 (struct varobj
**var_handle
)
2252 struct value
*new_val
= NULL
;
2253 struct varobj
*var
= *var_handle
;
2254 int within_scope
= 0;
2255 struct cleanup
*back_to
;
2257 /* Only root variables can be updated... */
2258 if (!is_root_p (var
))
2259 /* Not a root var. */
2262 back_to
= make_cleanup_restore_current_thread ();
2264 /* Determine whether the variable is still around. */
2265 if (var
->root
->valid_block
== NULL
|| var
->root
->floating
)
2267 else if (var
->root
->thread_id
== 0)
2269 /* The program was single-threaded when the variable object was
2270 created. Technically, it's possible that the program became
2271 multi-threaded since then, but we don't support such
2273 within_scope
= check_scope (var
);
2277 ptid_t ptid
= global_thread_id_to_ptid (var
->root
->thread_id
);
2279 if (!ptid_equal (minus_one_ptid
, ptid
))
2281 switch_to_thread (ptid
);
2282 within_scope
= check_scope (var
);
2289 /* We need to catch errors here, because if evaluate
2290 expression fails we want to just return NULL. */
2293 new_val
= evaluate_expression (var
->root
->exp
.get ());
2295 CATCH (except
, RETURN_MASK_ERROR
)
2301 do_cleanups (back_to
);
2306 /* What is the ``struct value *'' of the root variable VAR?
2307 For floating variable object, evaluation can get us a value
2308 of different type from what is stored in varobj already. In
2310 - *type_changed will be set to 1
2311 - old varobj will be freed, and new one will be
2312 created, with the same name.
2313 - *var_handle will be set to the new varobj
2314 Otherwise, *type_changed will be set to 0. */
2315 static struct value
*
2316 value_of_root (struct varobj
**var_handle
, int *type_changed
)
2320 if (var_handle
== NULL
)
2325 /* This should really be an exception, since this should
2326 only get called with a root variable. */
2328 if (!is_root_p (var
))
2331 if (var
->root
->floating
)
2333 struct varobj
*tmp_var
;
2334 char *old_type
, *new_type
;
2336 tmp_var
= varobj_create (NULL
, var
->name
, (CORE_ADDR
) 0,
2337 USE_SELECTED_FRAME
);
2338 if (tmp_var
== NULL
)
2342 old_type
= varobj_get_type (var
);
2343 new_type
= varobj_get_type (tmp_var
);
2344 if (strcmp (old_type
, new_type
) == 0)
2346 /* The expression presently stored inside var->root->exp
2347 remembers the locations of local variables relatively to
2348 the frame where the expression was created (in DWARF location
2349 button, for example). Naturally, those locations are not
2350 correct in other frames, so update the expression. */
2352 std::swap (var
->root
->exp
, tmp_var
->root
->exp
);
2354 varobj_delete (tmp_var
, 0);
2359 tmp_var
->obj_name
= xstrdup (var
->obj_name
);
2360 tmp_var
->from
= var
->from
;
2361 tmp_var
->to
= var
->to
;
2362 varobj_delete (var
, 0);
2364 install_variable (tmp_var
);
2365 *var_handle
= tmp_var
;
2378 struct value
*value
;
2380 value
= value_of_root_1 (var_handle
);
2381 if (var
->value
== NULL
|| value
== NULL
)
2383 /* For root varobj-s, a NULL value indicates a scoping issue.
2384 So, nothing to do in terms of checking for mutations. */
2386 else if (varobj_value_has_mutated (var
, value
, value_type (value
)))
2388 /* The type has mutated, so the children are no longer valid.
2389 Just delete them, and tell our caller that the type has
2391 varobj_delete (var
, 1 /* only_children */);
2392 var
->num_children
= -1;
2401 /* What is the ``struct value *'' for the INDEX'th child of PARENT? */
2402 static struct value
*
2403 value_of_child (const struct varobj
*parent
, int index
)
2405 struct value
*value
;
2407 value
= (*parent
->root
->lang_ops
->value_of_child
) (parent
, index
);
2412 /* GDB already has a command called "value_of_variable". Sigh. */
2414 my_value_of_variable (struct varobj
*var
, enum varobj_display_formats format
)
2416 if (var
->root
->is_valid
)
2418 if (var
->dynamic
->pretty_printer
!= NULL
)
2419 return varobj_value_get_print_value (var
->value
, var
->format
, var
);
2420 return (*var
->root
->lang_ops
->value_of_variable
) (var
, format
);
2427 varobj_formatted_print_options (struct value_print_options
*opts
,
2428 enum varobj_display_formats format
)
2430 get_formatted_print_options (opts
, format_code
[(int) format
]);
2431 opts
->deref_ref
= 0;
2436 varobj_value_get_print_value (struct value
*value
,
2437 enum varobj_display_formats format
,
2438 const struct varobj
*var
)
2440 struct ui_file
*stb
;
2441 struct cleanup
*old_chain
;
2442 char *thevalue
= NULL
;
2443 struct value_print_options opts
;
2444 struct type
*type
= NULL
;
2446 char *encoding
= NULL
;
2447 /* Initialize it just to avoid a GCC false warning. */
2448 CORE_ADDR str_addr
= 0;
2449 int string_print
= 0;
2454 stb
= mem_fileopen ();
2455 old_chain
= make_cleanup_ui_file_delete (stb
);
2458 if (gdb_python_initialized
)
2460 PyObject
*value_formatter
= var
->dynamic
->pretty_printer
;
2462 varobj_ensure_python_env (var
);
2464 if (value_formatter
)
2466 /* First check to see if we have any children at all. If so,
2467 we simply return {...}. */
2468 if (dynamic_varobj_has_child_method (var
))
2470 do_cleanups (old_chain
);
2471 return xstrdup ("{...}");
2474 if (PyObject_HasAttr (value_formatter
, gdbpy_to_string_cst
))
2476 struct value
*replacement
;
2477 PyObject
*output
= NULL
;
2479 output
= apply_varobj_pretty_printer (value_formatter
,
2483 /* If we have string like output ... */
2486 make_cleanup_py_decref (output
);
2488 /* If this is a lazy string, extract it. For lazy
2489 strings we always print as a string, so set
2491 if (gdbpy_is_lazy_string (output
))
2493 gdbpy_extract_lazy_string (output
, &str_addr
, &type
,
2495 make_cleanup (free_current_contents
, &encoding
);
2500 /* If it is a regular (non-lazy) string, extract
2501 it and copy the contents into THEVALUE. If the
2502 hint says to print it as a string, set
2503 string_print. Otherwise just return the extracted
2504 string as a value. */
2506 char *s
= python_string_to_target_string (output
);
2510 struct gdbarch
*gdbarch
;
2513 hint
= gdbpy_get_display_hint (value_formatter
);
2516 if (!strcmp (hint
, "string"))
2522 thevalue
= (char *) xmemdup (s
, len
+ 1, len
+ 1);
2523 gdbarch
= get_type_arch (value_type (value
));
2524 type
= builtin_type (gdbarch
)->builtin_char
;
2529 do_cleanups (old_chain
);
2533 make_cleanup (xfree
, thevalue
);
2536 gdbpy_print_stack ();
2539 /* If the printer returned a replacement value, set VALUE
2540 to REPLACEMENT. If there is not a replacement value,
2541 just use the value passed to this function. */
2543 value
= replacement
;
2549 varobj_formatted_print_options (&opts
, format
);
2551 /* If the THEVALUE has contents, it is a regular string. */
2553 LA_PRINT_STRING (stb
, type
, (gdb_byte
*) thevalue
, len
, encoding
, 0, &opts
);
2554 else if (string_print
)
2555 /* Otherwise, if string_print is set, and it is not a regular
2556 string, it is a lazy string. */
2557 val_print_string (type
, encoding
, str_addr
, len
, stb
, &opts
);
2559 /* All other cases. */
2560 common_val_print (value
, stb
, 0, &opts
, current_language
);
2562 thevalue
= ui_file_xstrdup (stb
, NULL
);
2564 do_cleanups (old_chain
);
2569 varobj_editable_p (const struct varobj
*var
)
2573 if (!(var
->root
->is_valid
&& var
->value
&& VALUE_LVAL (var
->value
)))
2576 type
= varobj_get_value_type (var
);
2578 switch (TYPE_CODE (type
))
2580 case TYPE_CODE_STRUCT
:
2581 case TYPE_CODE_UNION
:
2582 case TYPE_CODE_ARRAY
:
2583 case TYPE_CODE_FUNC
:
2584 case TYPE_CODE_METHOD
:
2594 /* Call VAR's value_is_changeable_p language-specific callback. */
2597 varobj_value_is_changeable_p (const struct varobj
*var
)
2599 return var
->root
->lang_ops
->value_is_changeable_p (var
);
2602 /* Return 1 if that varobj is floating, that is is always evaluated in the
2603 selected frame, and not bound to thread/frame. Such variable objects
2604 are created using '@' as frame specifier to -var-create. */
2606 varobj_floating_p (const struct varobj
*var
)
2608 return var
->root
->floating
;
2611 /* Implement the "value_is_changeable_p" varobj callback for most
2615 varobj_default_value_is_changeable_p (const struct varobj
*var
)
2620 if (CPLUS_FAKE_CHILD (var
))
2623 type
= varobj_get_value_type (var
);
2625 switch (TYPE_CODE (type
))
2627 case TYPE_CODE_STRUCT
:
2628 case TYPE_CODE_UNION
:
2629 case TYPE_CODE_ARRAY
:
2640 /* Iterate all the existing _root_ VAROBJs and call the FUNC callback for them
2641 with an arbitrary caller supplied DATA pointer. */
2644 all_root_varobjs (void (*func
) (struct varobj
*var
, void *data
), void *data
)
2646 struct varobj_root
*var_root
, *var_root_next
;
2648 /* Iterate "safely" - handle if the callee deletes its passed VAROBJ. */
2650 for (var_root
= rootlist
; var_root
!= NULL
; var_root
= var_root_next
)
2652 var_root_next
= var_root
->next
;
2654 (*func
) (var_root
->rootvar
, data
);
2658 /* Invalidate varobj VAR if it is tied to locals and re-create it if it is
2659 defined on globals. It is a helper for varobj_invalidate.
2661 This function is called after changing the symbol file, in this case the
2662 pointers to "struct type" stored by the varobj are no longer valid. All
2663 varobj must be either re-evaluated, or marked as invalid here. */
2666 varobj_invalidate_iter (struct varobj
*var
, void *unused
)
2668 /* global and floating var must be re-evaluated. */
2669 if (var
->root
->floating
|| var
->root
->valid_block
== NULL
)
2671 struct varobj
*tmp_var
;
2673 /* Try to create a varobj with same expression. If we succeed
2674 replace the old varobj, otherwise invalidate it. */
2675 tmp_var
= varobj_create (NULL
, var
->name
, (CORE_ADDR
) 0,
2677 if (tmp_var
!= NULL
)
2679 tmp_var
->obj_name
= xstrdup (var
->obj_name
);
2680 varobj_delete (var
, 0);
2681 install_variable (tmp_var
);
2684 var
->root
->is_valid
= 0;
2686 else /* locals must be invalidated. */
2687 var
->root
->is_valid
= 0;
2690 /* Invalidate the varobjs that are tied to locals and re-create the ones that
2691 are defined on globals.
2692 Invalidated varobjs will be always printed in_scope="invalid". */
2695 varobj_invalidate (void)
2697 all_root_varobjs (varobj_invalidate_iter
, NULL
);
2700 extern void _initialize_varobj (void);
2702 _initialize_varobj (void)
2704 varobj_table
= XCNEWVEC (struct vlist
*, VAROBJ_TABLE_SIZE
);
2706 add_setshow_zuinteger_cmd ("varobj", class_maintenance
,
2708 _("Set varobj debugging."),
2709 _("Show varobj debugging."),
2710 _("When non-zero, varobj debugging is enabled."),
2711 NULL
, show_varobjdebug
,
2712 &setdebuglist
, &showdebuglist
);