1 /* Implementation of the GDB variable objects API.
3 Copyright (C) 1999-2020 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"
29 #include "gdbthread.h"
31 #include "varobj-iter.h"
32 #include "parser-defs.h"
37 #include "python/python.h"
38 #include "python/python-internal.h"
45 unsigned int varobjdebug
= 0;
47 show_varobjdebug (struct ui_file
*file
, int from_tty
,
48 struct cmd_list_element
*c
, const char *value
)
50 fprintf_filtered (file
, _("Varobj debugging is %s.\n"), value
);
53 /* String representations of gdb's format codes. */
54 const char *varobj_format_string
[] =
55 { "natural", "binary", "decimal", "hexadecimal", "octal", "zero-hexadecimal" };
57 /* True if we want to allow Python-based pretty-printing. */
58 static bool pretty_printing
= false;
61 varobj_enable_pretty_printing (void)
63 pretty_printing
= true;
68 /* Every root variable has one of these structures saved in its
72 /* The expression for this parent. */
75 /* Block for which this expression is valid. */
76 const struct block
*valid_block
= NULL
;
78 /* The frame for this expression. This field is set iff valid_block is
80 struct frame_id frame
= null_frame_id
;
82 /* The global thread ID that this varobj_root belongs to. This field
83 is only valid if valid_block is not NULL.
84 When not 0, indicates which thread 'frame' belongs to.
85 When 0, indicates that the thread list was empty when the varobj_root
89 /* If true, the -var-update always recomputes the value in the
90 current thread and frame. Otherwise, variable object is
91 always updated in the specific scope/thread/frame. */
92 bool floating
= false;
94 /* Flag that indicates validity: set to false when this varobj_root refers
95 to symbols that do not exist anymore. */
98 /* Language-related operations for this variable and its
100 const struct lang_varobj_ops
*lang_ops
= NULL
;
102 /* The varobj for this root node. */
103 struct varobj
*rootvar
= NULL
;
106 /* Dynamic part of varobj. */
108 struct varobj_dynamic
110 /* Whether the children of this varobj were requested. This field is
111 used to decide if dynamic varobj should recompute their children.
112 In the event that the frontend never asked for the children, we
114 bool children_requested
= false;
116 /* The pretty-printer constructor. If NULL, then the default
117 pretty-printer will be looked up. If None, then no
118 pretty-printer will be installed. */
119 PyObject
*constructor
= NULL
;
121 /* The pretty-printer that has been constructed. If NULL, then a
122 new printer object is needed, and one will be constructed. */
123 PyObject
*pretty_printer
= NULL
;
125 /* The iterator returned by the printer's 'children' method, or NULL
127 struct varobj_iter
*child_iter
= NULL
;
129 /* We request one extra item from the iterator, so that we can
130 report to the caller whether there are more items than we have
131 already reported. However, we don't want to install this value
132 when we read it, because that will mess up future updates. So,
133 we stash it here instead. */
134 std::unique_ptr
<varobj_item
> saved_item
;
137 /* Private function prototypes */
139 /* Helper functions for the above subcommands. */
141 static int delete_variable (struct varobj
*, bool);
143 static void delete_variable_1 (int *, struct varobj
*, bool, bool);
145 static bool install_variable (struct varobj
*);
147 static void uninstall_variable (struct varobj
*);
149 static struct varobj
*create_child (struct varobj
*, int, std::string
&);
151 static struct varobj
*
152 create_child_with_value (struct varobj
*parent
, int index
,
153 struct varobj_item
*item
);
155 /* Utility routines */
157 static enum varobj_display_formats
variable_default_display (struct varobj
*);
159 static bool update_type_if_necessary (struct varobj
*var
,
160 struct value
*new_value
);
162 static bool install_new_value (struct varobj
*var
, struct value
*value
,
165 /* Language-specific routines. */
167 static int number_of_children (const struct varobj
*);
169 static std::string
name_of_variable (const struct varobj
*);
171 static std::string
name_of_child (struct varobj
*, int);
173 static struct value
*value_of_root (struct varobj
**var_handle
, bool *);
175 static struct value
*value_of_child (const struct varobj
*parent
, int index
);
177 static std::string
my_value_of_variable (struct varobj
*var
,
178 enum varobj_display_formats format
);
180 static bool is_root_p (const struct varobj
*var
);
182 static struct varobj
*varobj_add_child (struct varobj
*var
,
183 struct varobj_item
*item
);
187 /* Mappings of varobj_display_formats enums to gdb's format codes. */
188 static int format_code
[] = { 0, 't', 'd', 'x', 'o', 'z' };
190 /* List of root variable objects. */
191 static std::list
<struct varobj_root
*> rootlist
;
193 /* Pointer to the varobj hash table (built at run time). */
194 static htab_t varobj_table
;
198 /* API Implementation */
200 is_root_p (const struct varobj
*var
)
202 return (var
->root
->rootvar
== var
);
207 /* See python-internal.h. */
208 gdbpy_enter_varobj::gdbpy_enter_varobj (const struct varobj
*var
)
209 : gdbpy_enter (var
->root
->exp
->gdbarch
, var
->root
->exp
->language_defn
)
215 /* Return the full FRAME which corresponds to the given CORE_ADDR
216 or NULL if no FRAME on the chain corresponds to CORE_ADDR. */
218 static struct frame_info
*
219 find_frame_addr_in_frame_chain (CORE_ADDR frame_addr
)
221 struct frame_info
*frame
= NULL
;
223 if (frame_addr
== (CORE_ADDR
) 0)
226 for (frame
= get_current_frame ();
228 frame
= get_prev_frame (frame
))
230 /* The CORE_ADDR we get as argument was parsed from a string GDB
231 output as $fp. This output got truncated to gdbarch_addr_bit.
232 Truncate the frame base address in the same manner before
233 comparing it against our argument. */
234 CORE_ADDR frame_base
= get_frame_base_address (frame
);
235 int addr_bit
= gdbarch_addr_bit (get_frame_arch (frame
));
237 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
238 frame_base
&= ((CORE_ADDR
) 1 << addr_bit
) - 1;
240 if (frame_base
== frame_addr
)
247 /* Creates a varobj (not its children). */
250 varobj_create (const char *objname
,
251 const char *expression
, CORE_ADDR frame
, enum varobj_type type
)
253 /* Fill out a varobj structure for the (root) variable being constructed. */
254 std::unique_ptr
<varobj
> var (new varobj (new varobj_root
));
256 if (expression
!= NULL
)
258 struct frame_info
*fi
;
259 struct frame_id old_id
= null_frame_id
;
260 const struct block
*block
;
262 struct value
*value
= NULL
;
265 /* Parse and evaluate the expression, filling in as much of the
266 variable's data as possible. */
268 if (has_stack_frames ())
270 /* Allow creator to specify context of variable. */
271 if ((type
== USE_CURRENT_FRAME
) || (type
== USE_SELECTED_FRAME
))
272 fi
= get_selected_frame (NULL
);
274 /* FIXME: cagney/2002-11-23: This code should be doing a
275 lookup using the frame ID and not just the frame's
276 ``address''. This, of course, means an interface
277 change. However, with out that interface change ISAs,
278 such as the ia64 with its two stacks, won't work.
279 Similar goes for the case where there is a frameless
281 fi
= find_frame_addr_in_frame_chain (frame
);
286 if (type
== USE_SELECTED_FRAME
)
287 var
->root
->floating
= true;
293 block
= get_frame_block (fi
, 0);
294 pc
= get_frame_pc (fi
);
299 innermost_block_tracker
tracker (INNERMOST_BLOCK_FOR_SYMBOLS
300 | INNERMOST_BLOCK_FOR_REGISTERS
);
301 /* Wrap the call to parse expression, so we can
302 return a sensible error. */
305 var
->root
->exp
= parse_exp_1 (&p
, pc
, block
, 0, &tracker
);
308 catch (const gdb_exception_error
&except
)
313 /* Don't allow variables to be created for types. */
314 if (var
->root
->exp
->elts
[0].opcode
== OP_TYPE
315 || var
->root
->exp
->elts
[0].opcode
== OP_TYPEOF
316 || var
->root
->exp
->elts
[0].opcode
== OP_DECLTYPE
)
318 fprintf_unfiltered (gdb_stderr
, "Attempt to use a type name"
319 " as an expression.\n");
323 var
->format
= variable_default_display (var
.get ());
324 var
->root
->valid_block
=
325 var
->root
->floating
? NULL
: tracker
.block ();
326 var
->name
= expression
;
327 /* For a root var, the name and the expr are the same. */
328 var
->path_expr
= expression
;
330 /* When the frame is different from the current frame,
331 we must select the appropriate frame before parsing
332 the expression, otherwise the value will not be current.
333 Since select_frame is so benign, just call it for all cases. */
334 if (var
->root
->valid_block
)
336 /* User could specify explicit FRAME-ADDR which was not found but
337 EXPRESSION is frame specific and we would not be able to evaluate
338 it correctly next time. With VALID_BLOCK set we must also set
339 FRAME and THREAD_ID. */
341 error (_("Failed to find the specified frame"));
343 var
->root
->frame
= get_frame_id (fi
);
344 var
->root
->thread_id
= inferior_thread ()->global_num
;
345 old_id
= get_frame_id (get_selected_frame (NULL
));
349 /* We definitely need to catch errors here.
350 If evaluate_expression succeeds we got the value we wanted.
351 But if it fails, we still go on with a call to evaluate_type(). */
354 value
= evaluate_expression (var
->root
->exp
.get ());
356 catch (const gdb_exception_error
&except
)
358 /* Error getting the value. Try to at least get the
360 struct value
*type_only_value
= evaluate_type (var
->root
->exp
.get ());
362 var
->type
= value_type (type_only_value
);
367 int real_type_found
= 0;
369 var
->type
= value_actual_type (value
, 0, &real_type_found
);
371 value
= value_cast (var
->type
, value
);
374 /* Set language info */
375 var
->root
->lang_ops
= var
->root
->exp
->language_defn
->varobj_ops ();
377 install_new_value (var
.get (), value
, 1 /* Initial assignment */);
379 /* Set ourselves as our root. */
380 var
->root
->rootvar
= var
.get ();
382 /* Reset the selected frame. */
383 if (frame_id_p (old_id
))
384 select_frame (frame_find_by_id (old_id
));
387 /* If the variable object name is null, that means this
388 is a temporary variable, so don't install it. */
390 if ((var
!= NULL
) && (objname
!= NULL
))
392 var
->obj_name
= objname
;
394 /* If a varobj name is duplicated, the install will fail so
396 if (!install_variable (var
.get ()))
400 return var
.release ();
403 /* Generates an unique name that can be used for a varobj. */
406 varobj_gen_name (void)
410 /* Generate a name for this object. */
412 return string_printf ("var%d", id
);
415 /* Given an OBJNAME, returns the pointer to the corresponding varobj. Call
416 error if OBJNAME cannot be found. */
419 varobj_get_handle (const char *objname
)
421 varobj
*var
= (varobj
*) htab_find_with_hash (varobj_table
, objname
,
422 htab_hash_string (objname
));
425 error (_("Variable object not found"));
430 /* Given the handle, return the name of the object. */
433 varobj_get_objname (const struct varobj
*var
)
435 return var
->obj_name
.c_str ();
438 /* Given the handle, return the expression represented by the
442 varobj_get_expression (const struct varobj
*var
)
444 return name_of_variable (var
);
450 varobj_delete (struct varobj
*var
, bool only_children
)
452 return delete_variable (var
, only_children
);
457 /* Convenience function for varobj_set_visualizer. Instantiate a
458 pretty-printer for a given value. */
460 instantiate_pretty_printer (PyObject
*constructor
, struct value
*value
)
462 PyObject
*val_obj
= NULL
;
465 val_obj
= value_to_value_object (value
);
469 printer
= PyObject_CallFunctionObjArgs (constructor
, val_obj
, NULL
);
476 /* Set/Get variable object display format. */
478 enum varobj_display_formats
479 varobj_set_display_format (struct varobj
*var
,
480 enum varobj_display_formats format
)
487 case FORMAT_HEXADECIMAL
:
489 case FORMAT_ZHEXADECIMAL
:
490 var
->format
= format
;
494 var
->format
= variable_default_display (var
);
497 if (varobj_value_is_changeable_p (var
)
498 && var
->value
!= nullptr && !value_lazy (var
->value
.get ()))
500 var
->print_value
= varobj_value_get_print_value (var
->value
.get (),
507 enum varobj_display_formats
508 varobj_get_display_format (const struct varobj
*var
)
513 gdb::unique_xmalloc_ptr
<char>
514 varobj_get_display_hint (const struct varobj
*var
)
516 gdb::unique_xmalloc_ptr
<char> result
;
519 if (!gdb_python_initialized
)
522 gdbpy_enter_varobj
enter_py (var
);
524 if (var
->dynamic
->pretty_printer
!= NULL
)
525 result
= gdbpy_get_display_hint (var
->dynamic
->pretty_printer
);
531 /* Return true if the varobj has items after TO, false otherwise. */
534 varobj_has_more (const struct varobj
*var
, int to
)
536 if (var
->children
.size () > to
)
539 return ((to
== -1 || var
->children
.size () == to
)
540 && (var
->dynamic
->saved_item
!= NULL
));
543 /* If the variable object is bound to a specific thread, that
544 is its evaluation can always be done in context of a frame
545 inside that thread, returns GDB id of the thread -- which
546 is always positive. Otherwise, returns -1. */
548 varobj_get_thread_id (const struct varobj
*var
)
550 if (var
->root
->valid_block
&& var
->root
->thread_id
> 0)
551 return var
->root
->thread_id
;
557 varobj_set_frozen (struct varobj
*var
, bool frozen
)
559 /* When a variable is unfrozen, we don't fetch its value.
560 The 'not_fetched' flag remains set, so next -var-update
563 We don't fetch the value, because for structures the client
564 should do -var-update anyway. It would be bad to have different
565 client-size logic for structure and other types. */
566 var
->frozen
= frozen
;
570 varobj_get_frozen (const struct varobj
*var
)
575 /* A helper function that updates the contents of FROM and TO based on the
576 size of the vector CHILDREN. If the contents of either FROM or TO are
577 negative the entire range is used. */
580 varobj_restrict_range (const std::vector
<varobj
*> &children
,
583 int len
= children
.size ();
585 if (*from
< 0 || *to
< 0)
601 /* A helper for update_dynamic_varobj_children that installs a new
602 child when needed. */
605 install_dynamic_child (struct varobj
*var
,
606 std::vector
<varobj
*> *changed
,
607 std::vector
<varobj
*> *type_changed
,
608 std::vector
<varobj
*> *newobj
,
609 std::vector
<varobj
*> *unchanged
,
612 struct varobj_item
*item
)
614 if (var
->children
.size () < index
+ 1)
616 /* There's no child yet. */
617 struct varobj
*child
= varobj_add_child (var
, item
);
621 newobj
->push_back (child
);
627 varobj
*existing
= var
->children
[index
];
628 bool type_updated
= update_type_if_necessary (existing
, item
->value
);
632 if (type_changed
!= NULL
)
633 type_changed
->push_back (existing
);
635 if (install_new_value (existing
, item
->value
, 0))
637 if (!type_updated
&& changed
!= NULL
)
638 changed
->push_back (existing
);
640 else if (!type_updated
&& unchanged
!= NULL
)
641 unchanged
->push_back (existing
);
648 dynamic_varobj_has_child_method (const struct varobj
*var
)
650 PyObject
*printer
= var
->dynamic
->pretty_printer
;
652 if (!gdb_python_initialized
)
655 gdbpy_enter_varobj
enter_py (var
);
656 return PyObject_HasAttr (printer
, gdbpy_children_cst
);
660 /* A factory for creating dynamic varobj's iterators. Returns an
661 iterator object suitable for iterating over VAR's children. */
663 static struct varobj_iter
*
664 varobj_get_iterator (struct varobj
*var
)
667 if (var
->dynamic
->pretty_printer
)
668 return py_varobj_get_iterator (var
, var
->dynamic
->pretty_printer
);
671 gdb_assert_not_reached (_("\
672 requested an iterator from a non-dynamic varobj"));
675 /* Release and clear VAR's saved item, if any. */
678 varobj_clear_saved_item (struct varobj_dynamic
*var
)
680 if (var
->saved_item
!= NULL
)
682 value_decref (var
->saved_item
->value
);
683 var
->saved_item
.reset (nullptr);
688 update_dynamic_varobj_children (struct varobj
*var
,
689 std::vector
<varobj
*> *changed
,
690 std::vector
<varobj
*> *type_changed
,
691 std::vector
<varobj
*> *newobj
,
692 std::vector
<varobj
*> *unchanged
,
694 bool update_children
,
702 if (update_children
|| var
->dynamic
->child_iter
== NULL
)
704 delete var
->dynamic
->child_iter
;
705 var
->dynamic
->child_iter
= varobj_get_iterator (var
);
707 varobj_clear_saved_item (var
->dynamic
);
711 if (var
->dynamic
->child_iter
== NULL
)
715 i
= var
->children
.size ();
717 /* We ask for one extra child, so that MI can report whether there
718 are more children. */
719 for (; to
< 0 || i
< to
+ 1; ++i
)
721 std::unique_ptr
<varobj_item
> item
;
723 /* See if there was a leftover from last time. */
724 if (var
->dynamic
->saved_item
!= NULL
)
725 item
= std::move (var
->dynamic
->saved_item
);
728 item
= var
->dynamic
->child_iter
->next ();
729 /* Release vitem->value so its lifetime is not bound to the
730 execution of a command. */
731 if (item
!= NULL
&& item
->value
!= NULL
)
732 item
->value
= release_value (item
->value
).release ();
737 /* Iteration is done. Remove iterator from VAR. */
738 delete var
->dynamic
->child_iter
;
739 var
->dynamic
->child_iter
= NULL
;
742 /* We don't want to push the extra child on any report list. */
743 if (to
< 0 || i
< to
)
745 bool can_mention
= from
< 0 || i
>= from
;
747 install_dynamic_child (var
, can_mention
? changed
: NULL
,
748 can_mention
? type_changed
: NULL
,
749 can_mention
? newobj
: NULL
,
750 can_mention
? unchanged
: NULL
,
751 can_mention
? cchanged
: NULL
, i
,
756 var
->dynamic
->saved_item
= std::move (item
);
758 /* We want to truncate the child list just before this
764 if (i
< var
->children
.size ())
767 for (int j
= i
; j
< var
->children
.size (); ++j
)
768 varobj_delete (var
->children
[j
], 0);
770 var
->children
.resize (i
);
773 /* If there are fewer children than requested, note that the list of
775 if (to
>= 0 && var
->children
.size () < to
)
778 var
->num_children
= var
->children
.size ();
784 varobj_get_num_children (struct varobj
*var
)
786 if (var
->num_children
== -1)
788 if (varobj_is_dynamic_p (var
))
792 /* If we have a dynamic varobj, don't report -1 children.
793 So, try to fetch some children first. */
794 update_dynamic_varobj_children (var
, NULL
, NULL
, NULL
, NULL
, &dummy
,
798 var
->num_children
= number_of_children (var
);
801 return var
->num_children
>= 0 ? var
->num_children
: 0;
804 /* Creates a list of the immediate children of a variable object;
805 the return code is the number of such children or -1 on error. */
807 const std::vector
<varobj
*> &
808 varobj_list_children (struct varobj
*var
, int *from
, int *to
)
810 var
->dynamic
->children_requested
= true;
812 if (varobj_is_dynamic_p (var
))
814 bool children_changed
;
816 /* This, in theory, can result in the number of children changing without
817 frontend noticing. But well, calling -var-list-children on the same
818 varobj twice is not something a sane frontend would do. */
819 update_dynamic_varobj_children (var
, NULL
, NULL
, NULL
, NULL
,
820 &children_changed
, false, 0, *to
);
821 varobj_restrict_range (var
->children
, from
, to
);
822 return var
->children
;
825 if (var
->num_children
== -1)
826 var
->num_children
= number_of_children (var
);
828 /* If that failed, give up. */
829 if (var
->num_children
== -1)
830 return var
->children
;
832 /* If we're called when the list of children is not yet initialized,
833 allocate enough elements in it. */
834 while (var
->children
.size () < var
->num_children
)
835 var
->children
.push_back (NULL
);
837 for (int i
= 0; i
< var
->num_children
; i
++)
839 if (var
->children
[i
] == NULL
)
841 /* Either it's the first call to varobj_list_children for
842 this variable object, and the child was never created,
843 or it was explicitly deleted by the client. */
844 std::string name
= name_of_child (var
, i
);
845 var
->children
[i
] = create_child (var
, i
, name
);
849 varobj_restrict_range (var
->children
, from
, to
);
850 return var
->children
;
853 static struct varobj
*
854 varobj_add_child (struct varobj
*var
, struct varobj_item
*item
)
856 varobj
*v
= create_child_with_value (var
, var
->children
.size (), item
);
858 var
->children
.push_back (v
);
863 /* Obtain the type of an object Variable as a string similar to the one gdb
864 prints on the console. The caller is responsible for freeing the string.
868 varobj_get_type (struct varobj
*var
)
870 /* For the "fake" variables, do not return a type. (Its type is
872 Do not return a type for invalid variables as well. */
873 if (CPLUS_FAKE_CHILD (var
) || !var
->root
->is_valid
)
874 return std::string ();
876 return type_to_string (var
->type
);
879 /* Obtain the type of an object variable. */
882 varobj_get_gdb_type (const struct varobj
*var
)
887 /* Is VAR a path expression parent, i.e., can it be used to construct
888 a valid path expression? */
891 is_path_expr_parent (const struct varobj
*var
)
893 gdb_assert (var
->root
->lang_ops
->is_path_expr_parent
!= NULL
);
894 return var
->root
->lang_ops
->is_path_expr_parent (var
);
897 /* Is VAR a path expression parent, i.e., can it be used to construct
898 a valid path expression? By default we assume any VAR can be a path
902 varobj_default_is_path_expr_parent (const struct varobj
*var
)
907 /* Return the path expression parent for VAR. */
909 const struct varobj
*
910 varobj_get_path_expr_parent (const struct varobj
*var
)
912 const struct varobj
*parent
= var
;
914 while (!is_root_p (parent
) && !is_path_expr_parent (parent
))
915 parent
= parent
->parent
;
917 /* Computation of full rooted expression for children of dynamic
918 varobjs is not supported. */
919 if (varobj_is_dynamic_p (parent
))
920 error (_("Invalid variable object (child of a dynamic varobj)"));
925 /* Return a pointer to the full rooted expression of varobj VAR.
926 If it has not been computed yet, compute it. */
929 varobj_get_path_expr (const struct varobj
*var
)
931 if (var
->path_expr
.empty ())
933 /* For root varobjs, we initialize path_expr
934 when creating varobj, so here it should be
936 struct varobj
*mutable_var
= (struct varobj
*) var
;
937 gdb_assert (!is_root_p (var
));
939 mutable_var
->path_expr
= (*var
->root
->lang_ops
->path_expr_of_child
) (var
);
942 return var
->path_expr
.c_str ();
945 const struct language_defn
*
946 varobj_get_language (const struct varobj
*var
)
948 return var
->root
->exp
->language_defn
;
952 varobj_get_attributes (const struct varobj
*var
)
956 if (varobj_editable_p (var
))
957 /* FIXME: define masks for attributes. */
958 attributes
|= 0x00000001; /* Editable */
963 /* Return true if VAR is a dynamic varobj. */
966 varobj_is_dynamic_p (const struct varobj
*var
)
968 return var
->dynamic
->pretty_printer
!= NULL
;
972 varobj_get_formatted_value (struct varobj
*var
,
973 enum varobj_display_formats format
)
975 return my_value_of_variable (var
, format
);
979 varobj_get_value (struct varobj
*var
)
981 return my_value_of_variable (var
, var
->format
);
984 /* Set the value of an object variable (if it is editable) to the
985 value of the given expression. */
986 /* Note: Invokes functions that can call error(). */
989 varobj_set_value (struct varobj
*var
, const char *expression
)
991 struct value
*val
= NULL
; /* Initialize to keep gcc happy. */
992 /* The argument "expression" contains the variable's new value.
993 We need to first construct a legal expression for this -- ugh! */
994 /* Does this cover all the bases? */
995 struct value
*value
= NULL
; /* Initialize to keep gcc happy. */
996 int saved_input_radix
= input_radix
;
997 const char *s
= expression
;
999 gdb_assert (varobj_editable_p (var
));
1001 input_radix
= 10; /* ALWAYS reset to decimal temporarily. */
1002 expression_up exp
= parse_exp_1 (&s
, 0, 0, 0);
1005 value
= evaluate_expression (exp
.get ());
1008 catch (const gdb_exception_error
&except
)
1010 /* We cannot proceed without a valid expression. */
1014 /* All types that are editable must also be changeable. */
1015 gdb_assert (varobj_value_is_changeable_p (var
));
1017 /* The value of a changeable variable object must not be lazy. */
1018 gdb_assert (!value_lazy (var
->value
.get ()));
1020 /* Need to coerce the input. We want to check if the
1021 value of the variable object will be different
1022 after assignment, and the first thing value_assign
1023 does is coerce the input.
1024 For example, if we are assigning an array to a pointer variable we
1025 should compare the pointer with the array's address, not with the
1027 value
= coerce_array (value
);
1029 /* The new value may be lazy. value_assign, or
1030 rather value_contents, will take care of this. */
1033 val
= value_assign (var
->value
.get (), value
);
1036 catch (const gdb_exception_error
&except
)
1041 /* If the value has changed, record it, so that next -var-update can
1042 report this change. If a variable had a value of '1', we've set it
1043 to '333' and then set again to '1', when -var-update will report this
1044 variable as changed -- because the first assignment has set the
1045 'updated' flag. There's no need to optimize that, because return value
1046 of -var-update should be considered an approximation. */
1047 var
->updated
= install_new_value (var
, val
, false /* Compare values. */);
1048 input_radix
= saved_input_radix
;
1054 /* A helper function to install a constructor function and visualizer
1055 in a varobj_dynamic. */
1058 install_visualizer (struct varobj_dynamic
*var
, PyObject
*constructor
,
1059 PyObject
*visualizer
)
1061 Py_XDECREF (var
->constructor
);
1062 var
->constructor
= constructor
;
1064 Py_XDECREF (var
->pretty_printer
);
1065 var
->pretty_printer
= visualizer
;
1067 delete var
->child_iter
;
1068 var
->child_iter
= NULL
;
1071 /* Install the default visualizer for VAR. */
1074 install_default_visualizer (struct varobj
*var
)
1076 /* Do not install a visualizer on a CPLUS_FAKE_CHILD. */
1077 if (CPLUS_FAKE_CHILD (var
))
1080 if (pretty_printing
)
1082 gdbpy_ref
<> pretty_printer
;
1084 if (var
->value
!= nullptr)
1086 pretty_printer
= gdbpy_get_varobj_pretty_printer (var
->value
.get ());
1087 if (pretty_printer
== nullptr)
1089 gdbpy_print_stack ();
1090 error (_("Cannot instantiate printer for default visualizer"));
1094 if (pretty_printer
== Py_None
)
1095 pretty_printer
.reset (nullptr);
1097 install_visualizer (var
->dynamic
, NULL
, pretty_printer
.release ());
1101 /* Instantiate and install a visualizer for VAR using CONSTRUCTOR to
1102 make a new object. */
1105 construct_visualizer (struct varobj
*var
, PyObject
*constructor
)
1107 PyObject
*pretty_printer
;
1109 /* Do not install a visualizer on a CPLUS_FAKE_CHILD. */
1110 if (CPLUS_FAKE_CHILD (var
))
1113 Py_INCREF (constructor
);
1114 if (constructor
== Py_None
)
1115 pretty_printer
= NULL
;
1118 pretty_printer
= instantiate_pretty_printer (constructor
,
1120 if (! pretty_printer
)
1122 gdbpy_print_stack ();
1123 Py_DECREF (constructor
);
1124 constructor
= Py_None
;
1125 Py_INCREF (constructor
);
1128 if (pretty_printer
== Py_None
)
1130 Py_DECREF (pretty_printer
);
1131 pretty_printer
= NULL
;
1135 install_visualizer (var
->dynamic
, constructor
, pretty_printer
);
1138 #endif /* HAVE_PYTHON */
1140 /* A helper function for install_new_value. This creates and installs
1141 a visualizer for VAR, if appropriate. */
1144 install_new_value_visualizer (struct varobj
*var
)
1147 /* If the constructor is None, then we want the raw value. If VAR
1148 does not have a value, just skip this. */
1149 if (!gdb_python_initialized
)
1152 if (var
->dynamic
->constructor
!= Py_None
&& var
->value
!= NULL
)
1154 gdbpy_enter_varobj
enter_py (var
);
1156 if (var
->dynamic
->constructor
== NULL
)
1157 install_default_visualizer (var
);
1159 construct_visualizer (var
, var
->dynamic
->constructor
);
1166 /* When using RTTI to determine variable type it may be changed in runtime when
1167 the variable value is changed. This function checks whether type of varobj
1168 VAR will change when a new value NEW_VALUE is assigned and if it is so
1169 updates the type of VAR. */
1172 update_type_if_necessary (struct varobj
*var
, struct value
*new_value
)
1176 struct value_print_options opts
;
1178 get_user_print_options (&opts
);
1179 if (opts
.objectprint
)
1181 struct type
*new_type
= value_actual_type (new_value
, 0, 0);
1182 std::string new_type_str
= type_to_string (new_type
);
1183 std::string curr_type_str
= varobj_get_type (var
);
1185 /* Did the type name change? */
1186 if (curr_type_str
!= new_type_str
)
1188 var
->type
= new_type
;
1190 /* This information may be not valid for a new type. */
1191 varobj_delete (var
, 1);
1192 var
->children
.clear ();
1193 var
->num_children
= -1;
1202 /* Assign a new value to a variable object. If INITIAL is true,
1203 this is the first assignment after the variable object was just
1204 created, or changed type. In that case, just assign the value
1206 Otherwise, assign the new value, and return true if the value is
1207 different from the current one, false otherwise. The comparison is
1208 done on textual representation of value. Therefore, some types
1209 need not be compared. E.g. for structures the reported value is
1210 always "{...}", so no comparison is necessary here. If the old
1211 value was NULL and new one is not, or vice versa, we always return true.
1213 The VALUE parameter should not be released -- the function will
1214 take care of releasing it when needed. */
1216 install_new_value (struct varobj
*var
, struct value
*value
, bool initial
)
1220 bool changed
= false;
1221 bool intentionally_not_fetched
= false;
1223 /* We need to know the varobj's type to decide if the value should
1224 be fetched or not. C++ fake children (public/protected/private)
1225 don't have a type. */
1226 gdb_assert (var
->type
|| CPLUS_FAKE_CHILD (var
));
1227 changeable
= varobj_value_is_changeable_p (var
);
1229 /* If the type has custom visualizer, we consider it to be always
1230 changeable. FIXME: need to make sure this behaviour will not
1231 mess up read-sensitive values. */
1232 if (var
->dynamic
->pretty_printer
!= NULL
)
1235 need_to_fetch
= changeable
;
1237 /* We are not interested in the address of references, and given
1238 that in C++ a reference is not rebindable, it cannot
1239 meaningfully change. So, get hold of the real value. */
1241 value
= coerce_ref (value
);
1243 if (var
->type
&& var
->type
->code () == TYPE_CODE_UNION
)
1244 /* For unions, we need to fetch the value implicitly because
1245 of implementation of union member fetch. When gdb
1246 creates a value for a field and the value of the enclosing
1247 structure is not lazy, it immediately copies the necessary
1248 bytes from the enclosing values. If the enclosing value is
1249 lazy, the call to value_fetch_lazy on the field will read
1250 the data from memory. For unions, that means we'll read the
1251 same memory more than once, which is not desirable. So
1253 need_to_fetch
= true;
1255 /* The new value might be lazy. If the type is changeable,
1256 that is we'll be comparing values of this type, fetch the
1257 value now. Otherwise, on the next update the old value
1258 will be lazy, which means we've lost that old value. */
1259 if (need_to_fetch
&& value
&& value_lazy (value
))
1261 const struct varobj
*parent
= var
->parent
;
1262 bool frozen
= var
->frozen
;
1264 for (; !frozen
&& parent
; parent
= parent
->parent
)
1265 frozen
|= parent
->frozen
;
1267 if (frozen
&& initial
)
1269 /* For variables that are frozen, or are children of frozen
1270 variables, we don't do fetch on initial assignment.
1271 For non-initial assignment we do the fetch, since it means we're
1272 explicitly asked to compare the new value with the old one. */
1273 intentionally_not_fetched
= true;
1280 value_fetch_lazy (value
);
1283 catch (const gdb_exception_error
&except
)
1285 /* Set the value to NULL, so that for the next -var-update,
1286 we don't try to compare the new value with this value,
1287 that we couldn't even read. */
1293 /* Get a reference now, before possibly passing it to any Python
1294 code that might release it. */
1295 value_ref_ptr value_holder
;
1297 value_holder
= value_ref_ptr::new_reference (value
);
1299 /* Below, we'll be comparing string rendering of old and new
1300 values. Don't get string rendering if the value is
1301 lazy -- if it is, the code above has decided that the value
1302 should not be fetched. */
1303 std::string print_value
;
1304 if (value
!= NULL
&& !value_lazy (value
)
1305 && var
->dynamic
->pretty_printer
== NULL
)
1306 print_value
= varobj_value_get_print_value (value
, var
->format
, var
);
1308 /* If the type is changeable, compare the old and the new values.
1309 If this is the initial assignment, we don't have any old value
1311 if (!initial
&& changeable
)
1313 /* If the value of the varobj was changed by -var-set-value,
1314 then the value in the varobj and in the target is the same.
1315 However, that value is different from the value that the
1316 varobj had after the previous -var-update. So need to the
1317 varobj as changed. */
1320 else if (var
->dynamic
->pretty_printer
== NULL
)
1322 /* Try to compare the values. That requires that both
1323 values are non-lazy. */
1324 if (var
->not_fetched
&& value_lazy (var
->value
.get ()))
1326 /* This is a frozen varobj and the value was never read.
1327 Presumably, UI shows some "never read" indicator.
1328 Now that we've fetched the real value, we need to report
1329 this varobj as changed so that UI can show the real
1333 else if (var
->value
== NULL
&& value
== NULL
)
1336 else if (var
->value
== NULL
|| value
== NULL
)
1342 gdb_assert (!value_lazy (var
->value
.get ()));
1343 gdb_assert (!value_lazy (value
));
1345 gdb_assert (!var
->print_value
.empty () && !print_value
.empty ());
1346 if (var
->print_value
!= print_value
)
1352 if (!initial
&& !changeable
)
1354 /* For values that are not changeable, we don't compare the values.
1355 However, we want to notice if a value was not NULL and now is NULL,
1356 or vise versa, so that we report when top-level varobjs come in scope
1357 and leave the scope. */
1358 changed
= (var
->value
!= NULL
) != (value
!= NULL
);
1361 /* We must always keep the new value, since children depend on it. */
1362 var
->value
= value_holder
;
1363 if (value
&& value_lazy (value
) && intentionally_not_fetched
)
1364 var
->not_fetched
= true;
1366 var
->not_fetched
= false;
1367 var
->updated
= false;
1369 install_new_value_visualizer (var
);
1371 /* If we installed a pretty-printer, re-compare the printed version
1372 to see if the variable changed. */
1373 if (var
->dynamic
->pretty_printer
!= NULL
)
1375 print_value
= varobj_value_get_print_value (var
->value
.get (),
1377 if ((var
->print_value
.empty () && !print_value
.empty ())
1378 || (!var
->print_value
.empty () && print_value
.empty ())
1379 || (!var
->print_value
.empty () && !print_value
.empty ()
1380 && var
->print_value
!= print_value
))
1383 var
->print_value
= print_value
;
1385 gdb_assert (var
->value
== nullptr || value_type (var
->value
.get ()));
1390 /* Return the requested range for a varobj. VAR is the varobj. FROM
1391 and TO are out parameters; *FROM and *TO will be set to the
1392 selected sub-range of VAR. If no range was selected using
1393 -var-set-update-range, then both will be -1. */
1395 varobj_get_child_range (const struct varobj
*var
, int *from
, int *to
)
1401 /* Set the selected sub-range of children of VAR to start at index
1402 FROM and end at index TO. If either FROM or TO is less than zero,
1403 this is interpreted as a request for all children. */
1405 varobj_set_child_range (struct varobj
*var
, int from
, int to
)
1412 varobj_set_visualizer (struct varobj
*var
, const char *visualizer
)
1417 if (!gdb_python_initialized
)
1420 gdbpy_enter_varobj
enter_py (var
);
1422 mainmod
= PyImport_AddModule ("__main__");
1424 = gdbpy_ref
<>::new_reference (PyModule_GetDict (mainmod
));
1425 gdbpy_ref
<> constructor (PyRun_String (visualizer
, Py_eval_input
,
1426 globals
.get (), globals
.get ()));
1428 if (constructor
== NULL
)
1430 gdbpy_print_stack ();
1431 error (_("Could not evaluate visualizer expression: %s"), visualizer
);
1434 construct_visualizer (var
, constructor
.get ());
1436 /* If there are any children now, wipe them. */
1437 varobj_delete (var
, 1 /* children only */);
1438 var
->num_children
= -1;
1440 error (_("Python support required"));
1444 /* If NEW_VALUE is the new value of the given varobj (var), return
1445 true if var has mutated. In other words, if the type of
1446 the new value is different from the type of the varobj's old
1449 NEW_VALUE may be NULL, if the varobj is now out of scope. */
1452 varobj_value_has_mutated (const struct varobj
*var
, struct value
*new_value
,
1453 struct type
*new_type
)
1455 /* If we haven't previously computed the number of children in var,
1456 it does not matter from the front-end's perspective whether
1457 the type has mutated or not. For all intents and purposes,
1458 it has not mutated. */
1459 if (var
->num_children
< 0)
1462 if (var
->root
->lang_ops
->value_has_mutated
!= NULL
)
1464 /* The varobj module, when installing new values, explicitly strips
1465 references, saying that we're not interested in those addresses.
1466 But detection of mutation happens before installing the new
1467 value, so our value may be a reference that we need to strip
1468 in order to remain consistent. */
1469 if (new_value
!= NULL
)
1470 new_value
= coerce_ref (new_value
);
1471 return var
->root
->lang_ops
->value_has_mutated (var
, new_value
, new_type
);
1477 /* Update the values for a variable and its children. This is a
1478 two-pronged attack. First, re-parse the value for the root's
1479 expression to see if it's changed. Then go all the way
1480 through its children, reconstructing them and noting if they've
1483 The IS_EXPLICIT parameter specifies if this call is result
1484 of MI request to update this specific variable, or
1485 result of implicit -var-update *. For implicit request, we don't
1486 update frozen variables.
1488 NOTE: This function may delete the caller's varobj. If it
1489 returns TYPE_CHANGED, then it has done this and VARP will be modified
1490 to point to the new varobj. */
1492 std::vector
<varobj_update_result
>
1493 varobj_update (struct varobj
**varp
, bool is_explicit
)
1495 bool type_changed
= false;
1496 struct value
*newobj
;
1497 std::vector
<varobj_update_result
> stack
;
1498 std::vector
<varobj_update_result
> result
;
1500 /* Frozen means frozen -- we don't check for any change in
1501 this varobj, including its going out of scope, or
1502 changing type. One use case for frozen varobjs is
1503 retaining previously evaluated expressions, and we don't
1504 want them to be reevaluated at all. */
1505 if (!is_explicit
&& (*varp
)->frozen
)
1508 if (!(*varp
)->root
->is_valid
)
1510 result
.emplace_back (*varp
, VAROBJ_INVALID
);
1514 if ((*varp
)->root
->rootvar
== *varp
)
1516 varobj_update_result
r (*varp
);
1518 /* Update the root variable. value_of_root can return NULL
1519 if the variable is no longer around, i.e. we stepped out of
1520 the frame in which a local existed. We are letting the
1521 value_of_root variable dispose of the varobj if the type
1523 newobj
= value_of_root (varp
, &type_changed
);
1524 if (update_type_if_necessary (*varp
, newobj
))
1525 type_changed
= true;
1527 r
.type_changed
= type_changed
;
1528 if (install_new_value ((*varp
), newobj
, type_changed
))
1532 r
.status
= VAROBJ_NOT_IN_SCOPE
;
1533 r
.value_installed
= true;
1535 if (r
.status
== VAROBJ_NOT_IN_SCOPE
)
1537 if (r
.type_changed
|| r
.changed
)
1538 result
.push_back (std::move (r
));
1543 stack
.push_back (std::move (r
));
1546 stack
.emplace_back (*varp
);
1548 /* Walk through the children, reconstructing them all. */
1549 while (!stack
.empty ())
1551 varobj_update_result r
= std::move (stack
.back ());
1553 struct varobj
*v
= r
.varobj
;
1555 /* Update this variable, unless it's a root, which is already
1557 if (!r
.value_installed
)
1559 struct type
*new_type
;
1561 newobj
= value_of_child (v
->parent
, v
->index
);
1562 if (update_type_if_necessary (v
, newobj
))
1563 r
.type_changed
= true;
1565 new_type
= value_type (newobj
);
1567 new_type
= v
->root
->lang_ops
->type_of_child (v
->parent
, v
->index
);
1569 if (varobj_value_has_mutated (v
, newobj
, new_type
))
1571 /* The children are no longer valid; delete them now.
1572 Report the fact that its type changed as well. */
1573 varobj_delete (v
, 1 /* only_children */);
1574 v
->num_children
= -1;
1578 r
.type_changed
= true;
1581 if (install_new_value (v
, newobj
, r
.type_changed
))
1588 /* We probably should not get children of a dynamic varobj, but
1589 for which -var-list-children was never invoked. */
1590 if (varobj_is_dynamic_p (v
))
1592 std::vector
<varobj
*> changed
, type_changed_vec
, unchanged
, newobj_vec
;
1593 bool children_changed
= false;
1598 if (!v
->dynamic
->children_requested
)
1602 /* If we initially did not have potential children, but
1603 now we do, consider the varobj as changed.
1604 Otherwise, if children were never requested, consider
1605 it as unchanged -- presumably, such varobj is not yet
1606 expanded in the UI, so we need not bother getting
1608 if (!varobj_has_more (v
, 0))
1610 update_dynamic_varobj_children (v
, NULL
, NULL
, NULL
, NULL
,
1611 &dummy
, false, 0, 0);
1612 if (varobj_has_more (v
, 0))
1617 result
.push_back (std::move (r
));
1622 /* If update_dynamic_varobj_children returns false, then we have
1623 a non-conforming pretty-printer, so we skip it. */
1624 if (update_dynamic_varobj_children (v
, &changed
, &type_changed_vec
,
1626 &unchanged
, &children_changed
,
1627 true, v
->from
, v
->to
))
1629 if (children_changed
|| !newobj_vec
.empty ())
1631 r
.children_changed
= true;
1632 r
.newobj
= std::move (newobj_vec
);
1634 /* Push in reverse order so that the first child is
1635 popped from the work stack first, and so will be
1636 added to result first. This does not affect
1637 correctness, just "nicer". */
1638 for (int i
= type_changed_vec
.size () - 1; i
>= 0; --i
)
1640 varobj_update_result
item (type_changed_vec
[i
]);
1642 /* Type may change only if value was changed. */
1643 item
.changed
= true;
1644 item
.type_changed
= true;
1645 item
.value_installed
= true;
1647 stack
.push_back (std::move (item
));
1649 for (int i
= changed
.size () - 1; i
>= 0; --i
)
1651 varobj_update_result
item (changed
[i
]);
1653 item
.changed
= true;
1654 item
.value_installed
= true;
1656 stack
.push_back (std::move (item
));
1658 for (int i
= unchanged
.size () - 1; i
>= 0; --i
)
1660 if (!unchanged
[i
]->frozen
)
1662 varobj_update_result
item (unchanged
[i
]);
1664 item
.value_installed
= true;
1666 stack
.push_back (std::move (item
));
1669 if (r
.changed
|| r
.children_changed
)
1670 result
.push_back (std::move (r
));
1676 /* Push any children. Use reverse order so that the first
1677 child is popped from the work stack first, and so
1678 will be added to result first. This does not
1679 affect correctness, just "nicer". */
1680 for (int i
= v
->children
.size () - 1; i
>= 0; --i
)
1682 varobj
*c
= v
->children
[i
];
1684 /* Child may be NULL if explicitly deleted by -var-delete. */
1685 if (c
!= NULL
&& !c
->frozen
)
1686 stack
.emplace_back (c
);
1689 if (r
.changed
|| r
.type_changed
)
1690 result
.push_back (std::move (r
));
1696 /* Helper functions */
1699 * Variable object construction/destruction
1703 delete_variable (struct varobj
*var
, bool only_children_p
)
1707 delete_variable_1 (&delcount
, var
, only_children_p
,
1708 true /* remove_from_parent_p */ );
1713 /* Delete the variable object VAR and its children. */
1714 /* IMPORTANT NOTE: If we delete a variable which is a child
1715 and the parent is not removed we dump core. It must be always
1716 initially called with remove_from_parent_p set. */
1718 delete_variable_1 (int *delcountp
, struct varobj
*var
, bool only_children_p
,
1719 bool remove_from_parent_p
)
1721 /* Delete any children of this variable, too. */
1722 for (varobj
*child
: var
->children
)
1727 if (!remove_from_parent_p
)
1728 child
->parent
= NULL
;
1730 delete_variable_1 (delcountp
, child
, false, only_children_p
);
1732 var
->children
.clear ();
1734 /* if we were called to delete only the children we are done here. */
1735 if (only_children_p
)
1738 /* Otherwise, add it to the list of deleted ones and proceed to do so. */
1739 /* If the name is empty, this is a temporary variable, that has not
1740 yet been installed, don't report it, it belongs to the caller... */
1741 if (!var
->obj_name
.empty ())
1743 *delcountp
= *delcountp
+ 1;
1746 /* If this variable has a parent, remove it from its parent's list. */
1747 /* OPTIMIZATION: if the parent of this variable is also being deleted,
1748 (as indicated by remove_from_parent_p) we don't bother doing an
1749 expensive list search to find the element to remove when we are
1750 discarding the list afterwards. */
1751 if ((remove_from_parent_p
) && (var
->parent
!= NULL
))
1752 var
->parent
->children
[var
->index
] = NULL
;
1754 if (!var
->obj_name
.empty ())
1755 uninstall_variable (var
);
1757 /* Free memory associated with this variable. */
1761 /* Install the given variable VAR with the object name VAR->OBJ_NAME. */
1763 install_variable (struct varobj
*var
)
1765 hashval_t hash
= htab_hash_string (var
->obj_name
.c_str ());
1766 void **slot
= htab_find_slot_with_hash (varobj_table
,
1767 var
->obj_name
.c_str (),
1769 if (*slot
!= nullptr)
1770 error (_("Duplicate variable object name"));
1772 /* Add varobj to hash table. */
1775 /* If root, add varobj to root list. */
1776 if (is_root_p (var
))
1777 rootlist
.push_front (var
->root
);
1779 return true; /* OK */
1782 /* Uninstall the object VAR. */
1784 uninstall_variable (struct varobj
*var
)
1786 hashval_t hash
= htab_hash_string (var
->obj_name
.c_str ());
1787 htab_remove_elt_with_hash (varobj_table
, var
->obj_name
.c_str (), hash
);
1790 fprintf_unfiltered (gdb_stdlog
, "Deleting %s\n", var
->obj_name
.c_str ());
1792 /* If root, remove varobj from root list. */
1793 if (is_root_p (var
))
1795 auto iter
= std::find (rootlist
.begin (), rootlist
.end (), var
->root
);
1796 rootlist
.erase (iter
);
1800 /* Create and install a child of the parent of the given name.
1802 The created VAROBJ takes ownership of the allocated NAME. */
1804 static struct varobj
*
1805 create_child (struct varobj
*parent
, int index
, std::string
&name
)
1807 struct varobj_item item
;
1809 std::swap (item
.name
, name
);
1810 item
.value
= value_of_child (parent
, index
);
1812 return create_child_with_value (parent
, index
, &item
);
1815 static struct varobj
*
1816 create_child_with_value (struct varobj
*parent
, int index
,
1817 struct varobj_item
*item
)
1819 varobj
*child
= new varobj (parent
->root
);
1821 /* NAME is allocated by caller. */
1822 std::swap (child
->name
, item
->name
);
1823 child
->index
= index
;
1824 child
->parent
= parent
;
1826 if (varobj_is_anonymous_child (child
))
1827 child
->obj_name
= string_printf ("%s.%d_anonymous",
1828 parent
->obj_name
.c_str (), index
);
1830 child
->obj_name
= string_printf ("%s.%s",
1831 parent
->obj_name
.c_str (),
1832 child
->name
.c_str ());
1834 install_variable (child
);
1836 /* Compute the type of the child. Must do this before
1837 calling install_new_value. */
1838 if (item
->value
!= NULL
)
1839 /* If the child had no evaluation errors, var->value
1840 will be non-NULL and contain a valid type. */
1841 child
->type
= value_actual_type (item
->value
, 0, NULL
);
1843 /* Otherwise, we must compute the type. */
1844 child
->type
= (*child
->root
->lang_ops
->type_of_child
) (child
->parent
,
1846 install_new_value (child
, item
->value
, 1);
1853 * Miscellaneous utility functions.
1856 /* Allocate memory and initialize a new variable. */
1857 varobj::varobj (varobj_root
*root_
)
1858 : root (root_
), dynamic (new varobj_dynamic
)
1862 /* Free any allocated memory associated with VAR. */
1869 if (var
->dynamic
->pretty_printer
!= NULL
)
1871 gdbpy_enter_varobj
enter_py (var
);
1873 Py_XDECREF (var
->dynamic
->constructor
);
1874 Py_XDECREF (var
->dynamic
->pretty_printer
);
1878 delete var
->dynamic
->child_iter
;
1879 varobj_clear_saved_item (var
->dynamic
);
1881 if (is_root_p (var
))
1884 delete var
->dynamic
;
1887 /* Return the type of the value that's stored in VAR,
1888 or that would have being stored there if the
1889 value were accessible.
1891 This differs from VAR->type in that VAR->type is always
1892 the true type of the expression in the source language.
1893 The return value of this function is the type we're
1894 actually storing in varobj, and using for displaying
1895 the values and for comparing previous and new values.
1897 For example, top-level references are always stripped. */
1899 varobj_get_value_type (const struct varobj
*var
)
1903 if (var
->value
!= nullptr)
1904 type
= value_type (var
->value
.get ());
1908 type
= check_typedef (type
);
1910 if (TYPE_IS_REFERENCE (type
))
1911 type
= get_target_type (type
);
1913 type
= check_typedef (type
);
1918 /* What is the default display for this variable? We assume that
1919 everything is "natural". Any exceptions? */
1920 static enum varobj_display_formats
1921 variable_default_display (struct varobj
*var
)
1923 return FORMAT_NATURAL
;
1927 * Language-dependencies
1930 /* Common entry points */
1932 /* Return the number of children for a given variable.
1933 The result of this function is defined by the language
1934 implementation. The number of children returned by this function
1935 is the number of children that the user will see in the variable
1938 number_of_children (const struct varobj
*var
)
1940 return (*var
->root
->lang_ops
->number_of_children
) (var
);
1943 /* What is the expression for the root varobj VAR? */
1946 name_of_variable (const struct varobj
*var
)
1948 return (*var
->root
->lang_ops
->name_of_variable
) (var
);
1951 /* What is the name of the INDEX'th child of VAR? */
1954 name_of_child (struct varobj
*var
, int index
)
1956 return (*var
->root
->lang_ops
->name_of_child
) (var
, index
);
1959 /* If frame associated with VAR can be found, switch
1960 to it and return true. Otherwise, return false. */
1963 check_scope (const struct varobj
*var
)
1965 struct frame_info
*fi
;
1968 fi
= frame_find_by_id (var
->root
->frame
);
1973 CORE_ADDR pc
= get_frame_pc (fi
);
1975 if (pc
< BLOCK_START (var
->root
->valid_block
) ||
1976 pc
>= BLOCK_END (var
->root
->valid_block
))
1984 /* Helper function to value_of_root. */
1986 static struct value
*
1987 value_of_root_1 (struct varobj
**var_handle
)
1989 struct value
*new_val
= NULL
;
1990 struct varobj
*var
= *var_handle
;
1991 bool within_scope
= false;
1993 /* Only root variables can be updated... */
1994 if (!is_root_p (var
))
1995 /* Not a root var. */
1998 scoped_restore_current_thread restore_thread
;
2000 /* Determine whether the variable is still around. */
2001 if (var
->root
->valid_block
== NULL
|| var
->root
->floating
)
2002 within_scope
= true;
2003 else if (var
->root
->thread_id
== 0)
2005 /* The program was single-threaded when the variable object was
2006 created. Technically, it's possible that the program became
2007 multi-threaded since then, but we don't support such
2009 within_scope
= check_scope (var
);
2013 thread_info
*thread
= find_thread_global_id (var
->root
->thread_id
);
2017 switch_to_thread (thread
);
2018 within_scope
= check_scope (var
);
2025 /* We need to catch errors here, because if evaluate
2026 expression fails we want to just return NULL. */
2029 new_val
= evaluate_expression (var
->root
->exp
.get ());
2031 catch (const gdb_exception_error
&except
)
2039 /* What is the ``struct value *'' of the root variable VAR?
2040 For floating variable object, evaluation can get us a value
2041 of different type from what is stored in varobj already. In
2043 - *type_changed will be set to 1
2044 - old varobj will be freed, and new one will be
2045 created, with the same name.
2046 - *var_handle will be set to the new varobj
2047 Otherwise, *type_changed will be set to 0. */
2048 static struct value
*
2049 value_of_root (struct varobj
**var_handle
, bool *type_changed
)
2053 if (var_handle
== NULL
)
2058 /* This should really be an exception, since this should
2059 only get called with a root variable. */
2061 if (!is_root_p (var
))
2064 if (var
->root
->floating
)
2066 struct varobj
*tmp_var
;
2068 tmp_var
= varobj_create (NULL
, var
->name
.c_str (), (CORE_ADDR
) 0,
2069 USE_SELECTED_FRAME
);
2070 if (tmp_var
== NULL
)
2074 std::string old_type
= varobj_get_type (var
);
2075 std::string new_type
= varobj_get_type (tmp_var
);
2076 if (old_type
== new_type
)
2078 /* The expression presently stored inside var->root->exp
2079 remembers the locations of local variables relatively to
2080 the frame where the expression was created (in DWARF location
2081 button, for example). Naturally, those locations are not
2082 correct in other frames, so update the expression. */
2084 std::swap (var
->root
->exp
, tmp_var
->root
->exp
);
2086 varobj_delete (tmp_var
, 0);
2091 tmp_var
->obj_name
= var
->obj_name
;
2092 tmp_var
->from
= var
->from
;
2093 tmp_var
->to
= var
->to
;
2094 varobj_delete (var
, 0);
2096 install_variable (tmp_var
);
2097 *var_handle
= tmp_var
;
2099 *type_changed
= true;
2108 struct value
*value
;
2110 value
= value_of_root_1 (var_handle
);
2111 if (var
->value
== NULL
|| value
== NULL
)
2113 /* For root varobj-s, a NULL value indicates a scoping issue.
2114 So, nothing to do in terms of checking for mutations. */
2116 else if (varobj_value_has_mutated (var
, value
, value_type (value
)))
2118 /* The type has mutated, so the children are no longer valid.
2119 Just delete them, and tell our caller that the type has
2121 varobj_delete (var
, 1 /* only_children */);
2122 var
->num_children
= -1;
2125 *type_changed
= true;
2131 /* What is the ``struct value *'' for the INDEX'th child of PARENT? */
2132 static struct value
*
2133 value_of_child (const struct varobj
*parent
, int index
)
2135 struct value
*value
;
2137 value
= (*parent
->root
->lang_ops
->value_of_child
) (parent
, index
);
2142 /* GDB already has a command called "value_of_variable". Sigh. */
2144 my_value_of_variable (struct varobj
*var
, enum varobj_display_formats format
)
2146 if (var
->root
->is_valid
)
2148 if (var
->dynamic
->pretty_printer
!= NULL
)
2149 return varobj_value_get_print_value (var
->value
.get (), var
->format
,
2151 return (*var
->root
->lang_ops
->value_of_variable
) (var
, format
);
2154 return std::string ();
2158 varobj_formatted_print_options (struct value_print_options
*opts
,
2159 enum varobj_display_formats format
)
2161 get_formatted_print_options (opts
, format_code
[(int) format
]);
2162 opts
->deref_ref
= 0;
2163 opts
->raw
= !pretty_printing
;
2167 varobj_value_get_print_value (struct value
*value
,
2168 enum varobj_display_formats format
,
2169 const struct varobj
*var
)
2171 struct value_print_options opts
;
2172 struct type
*type
= NULL
;
2174 gdb::unique_xmalloc_ptr
<char> encoding
;
2175 /* Initialize it just to avoid a GCC false warning. */
2176 CORE_ADDR str_addr
= 0;
2177 bool string_print
= false;
2180 return std::string ();
2183 std::string thevalue
;
2186 if (gdb_python_initialized
)
2188 PyObject
*value_formatter
= var
->dynamic
->pretty_printer
;
2190 gdbpy_enter_varobj
enter_py (var
);
2192 if (value_formatter
)
2194 /* First check to see if we have any children at all. If so,
2195 we simply return {...}. */
2196 if (dynamic_varobj_has_child_method (var
))
2199 if (PyObject_HasAttr (value_formatter
, gdbpy_to_string_cst
))
2201 struct value
*replacement
;
2203 gdbpy_ref
<> output
= apply_varobj_pretty_printer (value_formatter
,
2207 /* If we have string like output ... */
2210 /* If this is a lazy string, extract it. For lazy
2211 strings we always print as a string, so set
2213 if (gdbpy_is_lazy_string (output
.get ()))
2215 gdbpy_extract_lazy_string (output
.get (), &str_addr
,
2216 &type
, &len
, &encoding
);
2217 string_print
= true;
2221 /* If it is a regular (non-lazy) string, extract
2222 it and copy the contents into THEVALUE. If the
2223 hint says to print it as a string, set
2224 string_print. Otherwise just return the extracted
2225 string as a value. */
2227 gdb::unique_xmalloc_ptr
<char> s
2228 = python_string_to_target_string (output
.get ());
2232 struct gdbarch
*gdbarch
;
2234 gdb::unique_xmalloc_ptr
<char> hint
2235 = gdbpy_get_display_hint (value_formatter
);
2238 if (!strcmp (hint
.get (), "string"))
2239 string_print
= true;
2242 thevalue
= std::string (s
.get ());
2243 len
= thevalue
.size ();
2244 gdbarch
= get_type_arch (value_type (value
));
2245 type
= builtin_type (gdbarch
)->builtin_char
;
2251 gdbpy_print_stack ();
2254 /* If the printer returned a replacement value, set VALUE
2255 to REPLACEMENT. If there is not a replacement value,
2256 just use the value passed to this function. */
2258 value
= replacement
;
2264 varobj_formatted_print_options (&opts
, format
);
2266 /* If the THEVALUE has contents, it is a regular string. */
2267 if (!thevalue
.empty ())
2268 LA_PRINT_STRING (&stb
, type
, (gdb_byte
*) thevalue
.c_str (),
2269 len
, encoding
.get (), 0, &opts
);
2270 else if (string_print
)
2271 /* Otherwise, if string_print is set, and it is not a regular
2272 string, it is a lazy string. */
2273 val_print_string (type
, encoding
.get (), str_addr
, len
, &stb
, &opts
);
2275 /* All other cases. */
2276 common_val_print (value
, &stb
, 0, &opts
, current_language
);
2278 return std::move (stb
.string ());
2282 varobj_editable_p (const struct varobj
*var
)
2286 if (!(var
->root
->is_valid
&& var
->value
!= nullptr
2287 && VALUE_LVAL (var
->value
.get ())))
2290 type
= varobj_get_value_type (var
);
2292 switch (type
->code ())
2294 case TYPE_CODE_STRUCT
:
2295 case TYPE_CODE_UNION
:
2296 case TYPE_CODE_ARRAY
:
2297 case TYPE_CODE_FUNC
:
2298 case TYPE_CODE_METHOD
:
2308 /* Call VAR's value_is_changeable_p language-specific callback. */
2311 varobj_value_is_changeable_p (const struct varobj
*var
)
2313 return var
->root
->lang_ops
->value_is_changeable_p (var
);
2316 /* Return true if that varobj is floating, that is is always evaluated in the
2317 selected frame, and not bound to thread/frame. Such variable objects
2318 are created using '@' as frame specifier to -var-create. */
2320 varobj_floating_p (const struct varobj
*var
)
2322 return var
->root
->floating
;
2325 /* Implement the "value_is_changeable_p" varobj callback for most
2329 varobj_default_value_is_changeable_p (const struct varobj
*var
)
2334 if (CPLUS_FAKE_CHILD (var
))
2337 type
= varobj_get_value_type (var
);
2339 switch (type
->code ())
2341 case TYPE_CODE_STRUCT
:
2342 case TYPE_CODE_UNION
:
2343 case TYPE_CODE_ARRAY
:
2354 /* Iterate all the existing _root_ VAROBJs and call the FUNC callback
2358 all_root_varobjs (gdb::function_view
<void (struct varobj
*var
)> func
)
2360 /* Iterate "safely" - handle if the callee deletes its passed VAROBJ. */
2361 auto iter
= rootlist
.begin ();
2362 auto end
= rootlist
.end ();
2366 func ((*self
)->rootvar
);
2370 /* Invalidate varobj VAR if it is tied to locals and re-create it if it is
2371 defined on globals. It is a helper for varobj_invalidate.
2373 This function is called after changing the symbol file, in this case the
2374 pointers to "struct type" stored by the varobj are no longer valid. All
2375 varobj must be either re-evaluated, or marked as invalid here. */
2378 varobj_invalidate_iter (struct varobj
*var
)
2380 /* global and floating var must be re-evaluated. */
2381 if (var
->root
->floating
|| var
->root
->valid_block
== NULL
)
2383 struct varobj
*tmp_var
;
2385 /* Try to create a varobj with same expression. If we succeed
2386 replace the old varobj, otherwise invalidate it. */
2387 tmp_var
= varobj_create (NULL
, var
->name
.c_str (), (CORE_ADDR
) 0,
2389 if (tmp_var
!= NULL
)
2391 tmp_var
->obj_name
= var
->obj_name
;
2392 varobj_delete (var
, 0);
2393 install_variable (tmp_var
);
2396 var
->root
->is_valid
= false;
2398 else /* locals must be invalidated. */
2399 var
->root
->is_valid
= false;
2402 /* Invalidate the varobjs that are tied to locals and re-create the ones that
2403 are defined on globals.
2404 Invalidated varobjs will be always printed in_scope="invalid". */
2407 varobj_invalidate (void)
2409 all_root_varobjs (varobj_invalidate_iter
);
2412 /* A hash function for a varobj. */
2415 hash_varobj (const void *a
)
2417 const varobj
*obj
= (const varobj
*) a
;
2418 return htab_hash_string (obj
->obj_name
.c_str ());
2421 /* A hash table equality function for varobjs. */
2424 eq_varobj_and_string (const void *a
, const void *b
)
2426 const varobj
*obj
= (const varobj
*) a
;
2427 const char *name
= (const char *) b
;
2429 return obj
->obj_name
== name
;
2432 void _initialize_varobj ();
2434 _initialize_varobj ()
2436 varobj_table
= htab_create_alloc (5, hash_varobj
, eq_varobj_and_string
,
2437 nullptr, xcalloc
, xfree
);
2439 add_setshow_zuinteger_cmd ("varobj", class_maintenance
,
2441 _("Set varobj debugging."),
2442 _("Show varobj debugging."),
2443 _("When non-zero, varobj debugging is enabled."),
2444 NULL
, show_varobjdebug
,
2445 &setdebuglist
, &showdebuglist
);