1 /* Implementation of the GDB variable objects API.
3 Copyright (C) 1999-2023 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 "gdbsupport/gdb_regex.h"
29 #include "gdbthread.h"
31 #include "varobj-iter.h"
32 #include "parser-defs.h"
35 #include "observable.h"
38 #include "python/python.h"
39 #include "python/python-internal.h"
46 unsigned int varobjdebug
= 0;
48 show_varobjdebug (struct ui_file
*file
, int from_tty
,
49 struct cmd_list_element
*c
, const char *value
)
51 gdb_printf (file
, _("Varobj debugging is %s.\n"), value
);
54 /* String representations of gdb's format codes. */
55 const char *varobj_format_string
[] =
56 { "natural", "binary", "decimal", "hexadecimal", "octal", "zero-hexadecimal" };
58 /* True if we want to allow Python-based pretty-printing. */
59 static bool pretty_printing
= false;
62 varobj_enable_pretty_printing (void)
64 pretty_printing
= true;
69 /* Every root variable has one of these structures saved in its
73 /* The expression for this parent. */
76 /* Cached arch from exp, for use in case exp gets invalidated. */
77 struct gdbarch
*gdbarch
= nullptr;
79 /* Cached language from exp, for use in case exp gets invalidated. */
80 const struct language_defn
*language_defn
= nullptr;
82 /* Block for which this expression is valid. */
83 const struct block
*valid_block
= NULL
;
85 /* The frame for this expression. This field is set iff valid_block is
87 struct frame_id frame
= null_frame_id
;
89 /* The global thread ID that this varobj_root belongs to. This field
90 is only valid if valid_block is not NULL.
91 When not 0, indicates which thread 'frame' belongs to.
92 When 0, indicates that the thread list was empty when the varobj_root
96 /* If true, the -var-update always recomputes the value in the
97 current thread and frame. Otherwise, variable object is
98 always updated in the specific scope/thread/frame. */
99 bool floating
= false;
101 /* Flag that indicates validity: set to false when this varobj_root refers
102 to symbols that do not exist anymore. */
103 bool is_valid
= true;
105 /* Set to true if the varobj was created as tracking a global. */
108 /* Language-related operations for this variable and its
110 const struct lang_varobj_ops
*lang_ops
= NULL
;
112 /* The varobj for this root node. */
113 struct varobj
*rootvar
= NULL
;
116 /* Dynamic part of varobj. */
118 struct varobj_dynamic
120 /* Whether the children of this varobj were requested. This field is
121 used to decide if dynamic varobj should recompute their children.
122 In the event that the frontend never asked for the children, we
124 bool children_requested
= false;
126 /* The pretty-printer constructor. If NULL, then the default
127 pretty-printer will be looked up. If None, then no
128 pretty-printer will be installed. */
129 PyObject
*constructor
= NULL
;
131 /* The pretty-printer that has been constructed. If NULL, then a
132 new printer object is needed, and one will be constructed. */
133 PyObject
*pretty_printer
= NULL
;
135 /* The iterator returned by the printer's 'children' method, or NULL
137 std::unique_ptr
<varobj_iter
> child_iter
;
139 /* We request one extra item from the iterator, so that we can
140 report to the caller whether there are more items than we have
141 already reported. However, we don't want to install this value
142 when we read it, because that will mess up future updates. So,
143 we stash it here instead. */
144 std::unique_ptr
<varobj_item
> saved_item
;
147 /* Private function prototypes */
149 /* Helper functions for the above subcommands. */
151 static int delete_variable (struct varobj
*, bool);
153 static void delete_variable_1 (int *, struct varobj
*, bool, bool);
155 static void install_variable (struct varobj
*);
157 static void uninstall_variable (struct varobj
*);
159 static struct varobj
*create_child (struct varobj
*, int, std::string
&);
161 static struct varobj
*
162 create_child_with_value (struct varobj
*parent
, int index
,
163 struct varobj_item
*item
);
165 /* Utility routines */
167 static enum varobj_display_formats
variable_default_display (struct varobj
*);
169 static bool update_type_if_necessary (struct varobj
*var
,
170 struct value
*new_value
);
172 static bool install_new_value (struct varobj
*var
, struct value
*value
,
175 /* Language-specific routines. */
177 static int number_of_children (const struct varobj
*);
179 static std::string
name_of_variable (const struct varobj
*);
181 static std::string
name_of_child (struct varobj
*, int);
183 static struct value
*value_of_root (struct varobj
**var_handle
, bool *);
185 static struct value
*value_of_child (const struct varobj
*parent
, int index
);
187 static std::string
my_value_of_variable (struct varobj
*var
,
188 enum varobj_display_formats format
);
190 static bool is_root_p (const struct varobj
*var
);
192 static struct varobj
*varobj_add_child (struct varobj
*var
,
193 struct varobj_item
*item
);
197 /* Mappings of varobj_display_formats enums to gdb's format codes. */
198 static int format_code
[] = { 0, 't', 'd', 'x', 'o', 'z' };
200 /* List of root variable objects. */
201 static std::list
<struct varobj_root
*> rootlist
;
203 /* Pointer to the varobj hash table (built at run time). */
204 static htab_t varobj_table
;
208 /* API Implementation */
210 is_root_p (const struct varobj
*var
)
212 return (var
->root
->rootvar
== var
);
217 /* See python-internal.h. */
218 gdbpy_enter_varobj::gdbpy_enter_varobj (const struct varobj
*var
)
219 : gdbpy_enter (var
->root
->gdbarch
, var
->root
->language_defn
)
225 /* Return the full FRAME which corresponds to the given CORE_ADDR
226 or NULL if no FRAME on the chain corresponds to CORE_ADDR. */
228 static frame_info_ptr
229 find_frame_addr_in_frame_chain (CORE_ADDR frame_addr
)
231 frame_info_ptr frame
= NULL
;
233 if (frame_addr
== (CORE_ADDR
) 0)
236 for (frame
= get_current_frame ();
238 frame
= get_prev_frame (frame
))
240 /* The CORE_ADDR we get as argument was parsed from a string GDB
241 output as $fp. This output got truncated to gdbarch_addr_bit.
242 Truncate the frame base address in the same manner before
243 comparing it against our argument. */
244 CORE_ADDR frame_base
= get_frame_base_address (frame
);
245 int addr_bit
= gdbarch_addr_bit (get_frame_arch (frame
));
247 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
248 frame_base
&= ((CORE_ADDR
) 1 << addr_bit
) - 1;
250 if (frame_base
== frame_addr
)
257 /* Creates a varobj (not its children). */
260 varobj_create (const char *objname
,
261 const char *expression
, CORE_ADDR frame
, enum varobj_type type
)
263 /* Fill out a varobj structure for the (root) variable being constructed. */
264 std::unique_ptr
<varobj
> var (new varobj (new varobj_root
));
266 if (expression
!= NULL
)
269 struct frame_id old_id
= null_frame_id
;
270 const struct block
*block
;
272 struct value
*value
= NULL
;
275 /* Parse and evaluate the expression, filling in as much of the
276 variable's data as possible. */
278 if (has_stack_frames ())
280 /* Allow creator to specify context of variable. */
281 if ((type
== USE_CURRENT_FRAME
) || (type
== USE_SELECTED_FRAME
))
282 fi
= get_selected_frame (NULL
);
284 /* FIXME: cagney/2002-11-23: This code should be doing a
285 lookup using the frame ID and not just the frame's
286 ``address''. This, of course, means an interface
287 change. However, with out that interface change ISAs,
288 such as the ia64 with its two stacks, won't work.
289 Similar goes for the case where there is a frameless
291 fi
= find_frame_addr_in_frame_chain (frame
);
296 if (type
== USE_SELECTED_FRAME
)
297 var
->root
->floating
= true;
303 block
= get_frame_block (fi
, 0);
304 pc
= get_frame_pc (fi
);
309 innermost_block_tracker
tracker (INNERMOST_BLOCK_FOR_SYMBOLS
310 | INNERMOST_BLOCK_FOR_REGISTERS
);
311 /* Wrap the call to parse expression, so we can
312 return a sensible error. */
315 var
->root
->exp
= parse_exp_1 (&p
, pc
, block
, 0, &tracker
);
317 /* Cache gdbarch and language_defn as they might be used even
318 after var is invalidated and var->root->exp cleared. */
319 var
->root
->gdbarch
= var
->root
->exp
->gdbarch
;
320 var
->root
->language_defn
= var
->root
->exp
->language_defn
;
323 catch (const gdb_exception_error
&except
)
328 /* Don't allow variables to be created for types. */
329 enum exp_opcode opcode
= var
->root
->exp
->first_opcode ();
330 if (opcode
== OP_TYPE
331 || opcode
== OP_TYPEOF
332 || opcode
== OP_DECLTYPE
)
334 gdb_printf (gdb_stderr
, "Attempt to use a type name"
335 " as an expression.\n");
339 var
->format
= variable_default_display (var
.get ());
340 var
->root
->valid_block
=
341 var
->root
->floating
? NULL
: tracker
.block ();
343 = var
->root
->floating
? false : var
->root
->valid_block
== nullptr;
344 var
->name
= expression
;
345 /* For a root var, the name and the expr are the same. */
346 var
->path_expr
= expression
;
348 /* When the frame is different from the current frame,
349 we must select the appropriate frame before parsing
350 the expression, otherwise the value will not be current.
351 Since select_frame is so benign, just call it for all cases. */
352 if (var
->root
->valid_block
)
354 /* User could specify explicit FRAME-ADDR which was not found but
355 EXPRESSION is frame specific and we would not be able to evaluate
356 it correctly next time. With VALID_BLOCK set we must also set
357 FRAME and THREAD_ID. */
359 error (_("Failed to find the specified frame"));
361 var
->root
->frame
= get_frame_id (fi
);
362 var
->root
->thread_id
= inferior_thread ()->global_num
;
363 old_id
= get_frame_id (get_selected_frame (NULL
));
367 /* We definitely need to catch errors here. If evaluation of
368 the expression succeeds, we got the value we wanted. But if
369 it fails, we still go on with a call to evaluate_type(). */
372 value
= var
->root
->exp
->evaluate ();
374 catch (const gdb_exception_error
&except
)
376 /* Error getting the value. Try to at least get the
378 struct value
*type_only_value
= var
->root
->exp
->evaluate_type ();
380 var
->type
= type_only_value
->type ();
385 int real_type_found
= 0;
387 var
->type
= value_actual_type (value
, 0, &real_type_found
);
389 value
= value_cast (var
->type
, value
);
392 /* Set language info */
393 var
->root
->lang_ops
= var
->root
->exp
->language_defn
->varobj_ops ();
395 install_new_value (var
.get (), value
, 1 /* Initial assignment */);
397 /* Set ourselves as our root. */
398 var
->root
->rootvar
= var
.get ();
400 /* Reset the selected frame. */
401 if (frame_id_p (old_id
))
402 select_frame (frame_find_by_id (old_id
));
405 /* If the variable object name is null, that means this
406 is a temporary variable, so don't install it. */
408 if ((var
!= NULL
) && (objname
!= NULL
))
410 var
->obj_name
= objname
;
411 install_variable (var
.get ());
414 return var
.release ();
417 /* Generates an unique name that can be used for a varobj. */
420 varobj_gen_name (void)
424 /* Generate a name for this object. */
426 return string_printf ("var%d", id
);
429 /* Given an OBJNAME, returns the pointer to the corresponding varobj. Call
430 error if OBJNAME cannot be found. */
433 varobj_get_handle (const char *objname
)
435 varobj
*var
= (varobj
*) htab_find_with_hash (varobj_table
, objname
,
436 htab_hash_string (objname
));
439 error (_("Variable object not found"));
444 /* Given the handle, return the name of the object. */
447 varobj_get_objname (const struct varobj
*var
)
449 return var
->obj_name
.c_str ();
452 /* Given the handle, return the expression represented by the
456 varobj_get_expression (const struct varobj
*var
)
458 return name_of_variable (var
);
464 varobj_delete (struct varobj
*var
, bool only_children
)
466 return delete_variable (var
, only_children
);
471 /* Convenience function for varobj_set_visualizer. Instantiate a
472 pretty-printer for a given value. */
474 instantiate_pretty_printer (PyObject
*constructor
, struct value
*value
)
476 gdbpy_ref
<> val_obj (value_to_value_object (value
));
477 if (val_obj
== nullptr)
480 return PyObject_CallFunctionObjArgs (constructor
, val_obj
.get (), NULL
);
485 /* Set/Get variable object display format. */
487 enum varobj_display_formats
488 varobj_set_display_format (struct varobj
*var
,
489 enum varobj_display_formats format
)
496 case FORMAT_HEXADECIMAL
:
498 case FORMAT_ZHEXADECIMAL
:
499 var
->format
= format
;
503 var
->format
= variable_default_display (var
);
506 if (varobj_value_is_changeable_p (var
)
507 && var
->value
!= nullptr && !var
->value
->lazy ())
509 var
->print_value
= varobj_value_get_print_value (var
->value
.get (),
516 enum varobj_display_formats
517 varobj_get_display_format (const struct varobj
*var
)
522 gdb::unique_xmalloc_ptr
<char>
523 varobj_get_display_hint (const struct varobj
*var
)
525 gdb::unique_xmalloc_ptr
<char> result
;
528 if (!gdb_python_initialized
)
531 gdbpy_enter_varobj
enter_py (var
);
533 if (var
->dynamic
->pretty_printer
!= NULL
)
534 result
= gdbpy_get_display_hint (var
->dynamic
->pretty_printer
);
540 /* Return true if the varobj has items after TO, false otherwise. */
543 varobj_has_more (const struct varobj
*var
, int to
)
545 if (var
->children
.size () > to
)
548 return ((to
== -1 || var
->children
.size () == to
)
549 && (var
->dynamic
->saved_item
!= NULL
));
552 /* If the variable object is bound to a specific thread, that
553 is its evaluation can always be done in context of a frame
554 inside that thread, returns GDB id of the thread -- which
555 is always positive. Otherwise, returns -1. */
557 varobj_get_thread_id (const struct varobj
*var
)
559 if (var
->root
->valid_block
&& var
->root
->thread_id
> 0)
560 return var
->root
->thread_id
;
566 varobj_set_frozen (struct varobj
*var
, bool frozen
)
568 /* When a variable is unfrozen, we don't fetch its value.
569 The 'not_fetched' flag remains set, so next -var-update
572 We don't fetch the value, because for structures the client
573 should do -var-update anyway. It would be bad to have different
574 client-size logic for structure and other types. */
575 var
->frozen
= frozen
;
579 varobj_get_frozen (const struct varobj
*var
)
584 /* A helper function that updates the contents of FROM and TO based on the
585 size of the vector CHILDREN. If the contents of either FROM or TO are
586 negative the entire range is used. */
589 varobj_restrict_range (const std::vector
<varobj
*> &children
,
592 int len
= children
.size ();
594 if (*from
< 0 || *to
< 0)
610 /* A helper for update_dynamic_varobj_children that installs a new
611 child when needed. */
614 install_dynamic_child (struct varobj
*var
,
615 std::vector
<varobj
*> *changed
,
616 std::vector
<varobj
*> *type_changed
,
617 std::vector
<varobj
*> *newobj
,
618 std::vector
<varobj
*> *unchanged
,
621 struct varobj_item
*item
)
623 if (var
->children
.size () < index
+ 1)
625 /* There's no child yet. */
626 struct varobj
*child
= varobj_add_child (var
, item
);
630 newobj
->push_back (child
);
636 varobj
*existing
= var
->children
[index
];
637 bool type_updated
= update_type_if_necessary (existing
,
642 if (type_changed
!= NULL
)
643 type_changed
->push_back (existing
);
645 if (install_new_value (existing
, item
->value
.get (), 0))
647 if (!type_updated
&& changed
!= NULL
)
648 changed
->push_back (existing
);
650 else if (!type_updated
&& unchanged
!= NULL
)
651 unchanged
->push_back (existing
);
655 /* A factory for creating dynamic varobj's iterators. Returns an
656 iterator object suitable for iterating over VAR's children. */
658 static std::unique_ptr
<varobj_iter
>
659 varobj_get_iterator (struct varobj
*var
)
662 if (var
->dynamic
->pretty_printer
)
664 value_print_options opts
;
665 varobj_formatted_print_options (&opts
, var
->format
);
666 return py_varobj_get_iterator (var
, var
->dynamic
->pretty_printer
, &opts
);
670 gdb_assert_not_reached ("requested an iterator from a non-dynamic varobj");
674 update_dynamic_varobj_children (struct varobj
*var
,
675 std::vector
<varobj
*> *changed
,
676 std::vector
<varobj
*> *type_changed
,
677 std::vector
<varobj
*> *newobj
,
678 std::vector
<varobj
*> *unchanged
,
680 bool update_children
,
688 if (update_children
|| var
->dynamic
->child_iter
== NULL
)
690 var
->dynamic
->child_iter
= varobj_get_iterator (var
);
691 var
->dynamic
->saved_item
.reset (nullptr);
695 if (var
->dynamic
->child_iter
== NULL
)
699 i
= var
->children
.size ();
701 /* We ask for one extra child, so that MI can report whether there
702 are more children. */
703 for (; to
< 0 || i
< to
+ 1; ++i
)
705 std::unique_ptr
<varobj_item
> item
;
707 /* See if there was a leftover from last time. */
708 if (var
->dynamic
->saved_item
!= NULL
)
709 item
= std::move (var
->dynamic
->saved_item
);
711 item
= var
->dynamic
->child_iter
->next ();
715 /* Iteration is done. Remove iterator from VAR. */
716 var
->dynamic
->child_iter
.reset (nullptr);
719 /* We don't want to push the extra child on any report list. */
720 if (to
< 0 || i
< to
)
722 bool can_mention
= from
< 0 || i
>= from
;
724 install_dynamic_child (var
, can_mention
? changed
: NULL
,
725 can_mention
? type_changed
: NULL
,
726 can_mention
? newobj
: NULL
,
727 can_mention
? unchanged
: NULL
,
728 can_mention
? cchanged
: NULL
, i
,
733 var
->dynamic
->saved_item
= std::move (item
);
735 /* We want to truncate the child list just before this
741 if (i
< var
->children
.size ())
744 for (int j
= i
; j
< var
->children
.size (); ++j
)
745 varobj_delete (var
->children
[j
], 0);
747 var
->children
.resize (i
);
750 /* If there are fewer children than requested, note that the list of
752 if (to
>= 0 && var
->children
.size () < to
)
755 var
->num_children
= var
->children
.size ();
761 varobj_get_num_children (struct varobj
*var
)
763 if (var
->num_children
== -1)
765 if (varobj_is_dynamic_p (var
))
769 /* If we have a dynamic varobj, don't report -1 children.
770 So, try to fetch some children first. */
771 update_dynamic_varobj_children (var
, NULL
, NULL
, NULL
, NULL
, &dummy
,
775 var
->num_children
= number_of_children (var
);
778 return var
->num_children
>= 0 ? var
->num_children
: 0;
781 /* Creates a list of the immediate children of a variable object;
782 the return code is the number of such children or -1 on error. */
784 const std::vector
<varobj
*> &
785 varobj_list_children (struct varobj
*var
, int *from
, int *to
)
787 var
->dynamic
->children_requested
= true;
789 if (varobj_is_dynamic_p (var
))
791 bool children_changed
;
793 /* This, in theory, can result in the number of children changing without
794 frontend noticing. But well, calling -var-list-children on the same
795 varobj twice is not something a sane frontend would do. */
796 update_dynamic_varobj_children (var
, NULL
, NULL
, NULL
, NULL
,
797 &children_changed
, false, 0, *to
);
798 varobj_restrict_range (var
->children
, from
, to
);
799 return var
->children
;
802 if (var
->num_children
== -1)
803 var
->num_children
= number_of_children (var
);
805 /* If that failed, give up. */
806 if (var
->num_children
== -1)
807 return var
->children
;
809 /* If we're called when the list of children is not yet initialized,
810 allocate enough elements in it. */
811 while (var
->children
.size () < var
->num_children
)
812 var
->children
.push_back (NULL
);
814 for (int i
= 0; i
< var
->num_children
; i
++)
816 if (var
->children
[i
] == NULL
)
818 /* Either it's the first call to varobj_list_children for
819 this variable object, and the child was never created,
820 or it was explicitly deleted by the client. */
821 std::string name
= name_of_child (var
, i
);
822 var
->children
[i
] = create_child (var
, i
, name
);
826 varobj_restrict_range (var
->children
, from
, to
);
827 return var
->children
;
830 static struct varobj
*
831 varobj_add_child (struct varobj
*var
, struct varobj_item
*item
)
833 varobj
*v
= create_child_with_value (var
, var
->children
.size (), item
);
835 var
->children
.push_back (v
);
840 /* Obtain the type of an object Variable as a string similar to the one gdb
841 prints on the console. The caller is responsible for freeing the string.
845 varobj_get_type (struct varobj
*var
)
847 /* For the "fake" variables, do not return a type. (Its type is
849 Do not return a type for invalid variables as well. */
850 if (CPLUS_FAKE_CHILD (var
) || !var
->root
->is_valid
)
851 return std::string ();
853 return type_to_string (var
->type
);
856 /* Obtain the type of an object variable. */
859 varobj_get_gdb_type (const struct varobj
*var
)
864 /* Is VAR a path expression parent, i.e., can it be used to construct
865 a valid path expression? */
868 is_path_expr_parent (const struct varobj
*var
)
870 gdb_assert (var
->root
->lang_ops
->is_path_expr_parent
!= NULL
);
871 return var
->root
->lang_ops
->is_path_expr_parent (var
);
874 /* Is VAR a path expression parent, i.e., can it be used to construct
875 a valid path expression? By default we assume any VAR can be a path
879 varobj_default_is_path_expr_parent (const struct varobj
*var
)
884 /* Return the path expression parent for VAR. */
886 const struct varobj
*
887 varobj_get_path_expr_parent (const struct varobj
*var
)
889 const struct varobj
*parent
= var
;
891 while (!is_root_p (parent
) && !is_path_expr_parent (parent
))
892 parent
= parent
->parent
;
894 /* Computation of full rooted expression for children of dynamic
895 varobjs is not supported. */
896 if (varobj_is_dynamic_p (parent
))
897 error (_("Invalid variable object (child of a dynamic varobj)"));
902 /* Return a pointer to the full rooted expression of varobj VAR.
903 If it has not been computed yet, compute it. */
906 varobj_get_path_expr (const struct varobj
*var
)
908 if (var
->path_expr
.empty ())
910 /* For root varobjs, we initialize path_expr
911 when creating varobj, so here it should be
913 struct varobj
*mutable_var
= (struct varobj
*) var
;
914 gdb_assert (!is_root_p (var
));
916 mutable_var
->path_expr
= (*var
->root
->lang_ops
->path_expr_of_child
) (var
);
919 return var
->path_expr
.c_str ();
922 const struct language_defn
*
923 varobj_get_language (const struct varobj
*var
)
925 return var
->root
->exp
->language_defn
;
929 varobj_get_attributes (const struct varobj
*var
)
933 if (varobj_editable_p (var
))
934 /* FIXME: define masks for attributes. */
935 attributes
|= 0x00000001; /* Editable */
940 /* Return true if VAR is a dynamic varobj. */
943 varobj_is_dynamic_p (const struct varobj
*var
)
945 return var
->dynamic
->pretty_printer
!= NULL
;
949 varobj_get_formatted_value (struct varobj
*var
,
950 enum varobj_display_formats format
)
952 return my_value_of_variable (var
, format
);
956 varobj_get_value (struct varobj
*var
)
958 return my_value_of_variable (var
, var
->format
);
961 /* Set the value of an object variable (if it is editable) to the
962 value of the given expression. */
963 /* Note: Invokes functions that can call error(). */
966 varobj_set_value (struct varobj
*var
, const char *expression
)
968 struct value
*val
= NULL
; /* Initialize to keep gcc happy. */
969 /* The argument "expression" contains the variable's new value.
970 We need to first construct a legal expression for this -- ugh! */
971 /* Does this cover all the bases? */
972 struct value
*value
= NULL
; /* Initialize to keep gcc happy. */
973 const char *s
= expression
;
975 gdb_assert (varobj_editable_p (var
));
977 /* ALWAYS reset to decimal temporarily. */
978 auto save_input_radix
= make_scoped_restore (&input_radix
, 10);
979 expression_up exp
= parse_exp_1 (&s
, 0, 0, 0);
982 value
= exp
->evaluate ();
985 catch (const gdb_exception_error
&except
)
987 /* We cannot proceed without a valid expression. */
991 /* All types that are editable must also be changeable. */
992 gdb_assert (varobj_value_is_changeable_p (var
));
994 /* The value of a changeable variable object must not be lazy. */
995 gdb_assert (!var
->value
->lazy ());
997 /* Need to coerce the input. We want to check if the
998 value of the variable object will be different
999 after assignment, and the first thing value_assign
1000 does is coerce the input.
1001 For example, if we are assigning an array to a pointer variable we
1002 should compare the pointer with the array's address, not with the
1004 value
= coerce_array (value
);
1006 /* The new value may be lazy. value_assign, or
1007 rather value_contents, will take care of this. */
1010 val
= value_assign (var
->value
.get (), value
);
1013 catch (const gdb_exception_error
&except
)
1018 /* If the value has changed, record it, so that next -var-update can
1019 report this change. If a variable had a value of '1', we've set it
1020 to '333' and then set again to '1', when -var-update will report this
1021 variable as changed -- because the first assignment has set the
1022 'updated' flag. There's no need to optimize that, because return value
1023 of -var-update should be considered an approximation. */
1024 var
->updated
= install_new_value (var
, val
, false /* Compare values. */);
1030 /* A helper function to install a constructor function and visualizer
1031 in a varobj_dynamic. */
1034 install_visualizer (struct varobj_dynamic
*var
, PyObject
*constructor
,
1035 PyObject
*visualizer
)
1037 Py_XDECREF (var
->constructor
);
1038 var
->constructor
= constructor
;
1040 Py_XDECREF (var
->pretty_printer
);
1041 var
->pretty_printer
= visualizer
;
1043 var
->child_iter
.reset (nullptr);
1046 /* Install the default visualizer for VAR. */
1049 install_default_visualizer (struct varobj
*var
)
1051 /* Do not install a visualizer on a CPLUS_FAKE_CHILD. */
1052 if (CPLUS_FAKE_CHILD (var
))
1055 if (pretty_printing
)
1057 gdbpy_ref
<> pretty_printer
;
1059 if (var
->value
!= nullptr)
1061 pretty_printer
= gdbpy_get_varobj_pretty_printer (var
->value
.get ());
1062 if (pretty_printer
== nullptr)
1064 gdbpy_print_stack ();
1065 error (_("Cannot instantiate printer for default visualizer"));
1069 if (pretty_printer
== Py_None
)
1070 pretty_printer
.reset (nullptr);
1072 install_visualizer (var
->dynamic
, NULL
, pretty_printer
.release ());
1076 /* Instantiate and install a visualizer for VAR using CONSTRUCTOR to
1077 make a new object. */
1080 construct_visualizer (struct varobj
*var
, PyObject
*constructor
)
1082 PyObject
*pretty_printer
;
1084 /* Do not install a visualizer on a CPLUS_FAKE_CHILD. */
1085 if (CPLUS_FAKE_CHILD (var
))
1088 Py_INCREF (constructor
);
1089 if (constructor
== Py_None
)
1090 pretty_printer
= NULL
;
1093 pretty_printer
= instantiate_pretty_printer (constructor
,
1095 if (! pretty_printer
)
1097 gdbpy_print_stack ();
1098 Py_DECREF (constructor
);
1099 constructor
= Py_None
;
1100 Py_INCREF (constructor
);
1103 if (pretty_printer
== Py_None
)
1105 Py_DECREF (pretty_printer
);
1106 pretty_printer
= NULL
;
1110 install_visualizer (var
->dynamic
, constructor
, pretty_printer
);
1113 #endif /* HAVE_PYTHON */
1115 /* A helper function for install_new_value. This creates and installs
1116 a visualizer for VAR, if appropriate. */
1119 install_new_value_visualizer (struct varobj
*var
)
1122 /* If the constructor is None, then we want the raw value. If VAR
1123 does not have a value, just skip this. */
1124 if (!gdb_python_initialized
)
1127 if (var
->dynamic
->constructor
!= Py_None
&& var
->value
!= NULL
)
1129 gdbpy_enter_varobj
enter_py (var
);
1131 if (var
->dynamic
->constructor
== NULL
)
1132 install_default_visualizer (var
);
1134 construct_visualizer (var
, var
->dynamic
->constructor
);
1141 /* When using RTTI to determine variable type it may be changed in runtime when
1142 the variable value is changed. This function checks whether type of varobj
1143 VAR will change when a new value NEW_VALUE is assigned and if it is so
1144 updates the type of VAR. */
1147 update_type_if_necessary (struct varobj
*var
, struct value
*new_value
)
1151 struct value_print_options opts
;
1153 get_user_print_options (&opts
);
1154 if (opts
.objectprint
)
1156 struct type
*new_type
= value_actual_type (new_value
, 0, 0);
1157 std::string new_type_str
= type_to_string (new_type
);
1158 std::string curr_type_str
= varobj_get_type (var
);
1160 /* Did the type name change? */
1161 if (curr_type_str
!= new_type_str
)
1163 var
->type
= new_type
;
1165 /* This information may be not valid for a new type. */
1166 varobj_delete (var
, 1);
1167 var
->children
.clear ();
1168 var
->num_children
= -1;
1177 /* Assign a new value to a variable object. If INITIAL is true,
1178 this is the first assignment after the variable object was just
1179 created, or changed type. In that case, just assign the value
1181 Otherwise, assign the new value, and return true if the value is
1182 different from the current one, false otherwise. The comparison is
1183 done on textual representation of value. Therefore, some types
1184 need not be compared. E.g. for structures the reported value is
1185 always "{...}", so no comparison is necessary here. If the old
1186 value was NULL and new one is not, or vice versa, we always return true.
1188 The VALUE parameter should not be released -- the function will
1189 take care of releasing it when needed. */
1191 install_new_value (struct varobj
*var
, struct value
*value
, bool initial
)
1195 bool changed
= false;
1196 bool intentionally_not_fetched
= false;
1198 /* We need to know the varobj's type to decide if the value should
1199 be fetched or not. C++ fake children (public/protected/private)
1200 don't have a type. */
1201 gdb_assert (var
->type
|| CPLUS_FAKE_CHILD (var
));
1202 changeable
= varobj_value_is_changeable_p (var
);
1204 /* If the type has custom visualizer, we consider it to be always
1205 changeable. FIXME: need to make sure this behaviour will not
1206 mess up read-sensitive values. */
1207 if (var
->dynamic
->pretty_printer
!= NULL
)
1210 need_to_fetch
= changeable
;
1212 /* We are not interested in the address of references, and given
1213 that in C++ a reference is not rebindable, it cannot
1214 meaningfully change. So, get hold of the real value. */
1216 value
= coerce_ref (value
);
1218 if (var
->type
&& var
->type
->code () == TYPE_CODE_UNION
)
1219 /* For unions, we need to fetch the value implicitly because
1220 of implementation of union member fetch. When gdb
1221 creates a value for a field and the value of the enclosing
1222 structure is not lazy, it immediately copies the necessary
1223 bytes from the enclosing values. If the enclosing value is
1224 lazy, the call to value_fetch_lazy on the field will read
1225 the data from memory. For unions, that means we'll read the
1226 same memory more than once, which is not desirable. So
1228 need_to_fetch
= true;
1230 /* The new value might be lazy. If the type is changeable,
1231 that is we'll be comparing values of this type, fetch the
1232 value now. Otherwise, on the next update the old value
1233 will be lazy, which means we've lost that old value. */
1234 if (need_to_fetch
&& value
&& value
->lazy ())
1236 const struct varobj
*parent
= var
->parent
;
1237 bool frozen
= var
->frozen
;
1239 for (; !frozen
&& parent
; parent
= parent
->parent
)
1240 frozen
|= parent
->frozen
;
1242 if (frozen
&& initial
)
1244 /* For variables that are frozen, or are children of frozen
1245 variables, we don't do fetch on initial assignment.
1246 For non-initial assignment we do the fetch, since it means we're
1247 explicitly asked to compare the new value with the old one. */
1248 intentionally_not_fetched
= true;
1255 value
->fetch_lazy ();
1258 catch (const gdb_exception_error
&except
)
1260 /* Set the value to NULL, so that for the next -var-update,
1261 we don't try to compare the new value with this value,
1262 that we couldn't even read. */
1268 /* Get a reference now, before possibly passing it to any Python
1269 code that might release it. */
1270 value_ref_ptr value_holder
;
1272 value_holder
= value_ref_ptr::new_reference (value
);
1274 /* Below, we'll be comparing string rendering of old and new
1275 values. Don't get string rendering if the value is
1276 lazy -- if it is, the code above has decided that the value
1277 should not be fetched. */
1278 std::string print_value
;
1279 if (value
!= NULL
&& !value
->lazy ()
1280 && var
->dynamic
->pretty_printer
== NULL
)
1281 print_value
= varobj_value_get_print_value (value
, var
->format
, var
);
1283 /* If the type is changeable, compare the old and the new values.
1284 If this is the initial assignment, we don't have any old value
1286 if (!initial
&& changeable
)
1288 /* If the value of the varobj was changed by -var-set-value,
1289 then the value in the varobj and in the target is the same.
1290 However, that value is different from the value that the
1291 varobj had after the previous -var-update. So need to the
1292 varobj as changed. */
1295 else if (var
->dynamic
->pretty_printer
== NULL
)
1297 /* Try to compare the values. That requires that both
1298 values are non-lazy. */
1299 if (var
->not_fetched
&& var
->value
->lazy ())
1301 /* This is a frozen varobj and the value was never read.
1302 Presumably, UI shows some "never read" indicator.
1303 Now that we've fetched the real value, we need to report
1304 this varobj as changed so that UI can show the real
1308 else if (var
->value
== NULL
&& value
== NULL
)
1311 else if (var
->value
== NULL
|| value
== NULL
)
1317 gdb_assert (!var
->value
->lazy ());
1318 gdb_assert (!value
->lazy ());
1320 gdb_assert (!var
->print_value
.empty () && !print_value
.empty ());
1321 if (var
->print_value
!= print_value
)
1327 if (!initial
&& !changeable
)
1329 /* For values that are not changeable, we don't compare the values.
1330 However, we want to notice if a value was not NULL and now is NULL,
1331 or vise versa, so that we report when top-level varobjs come in scope
1332 and leave the scope. */
1333 changed
= (var
->value
!= NULL
) != (value
!= NULL
);
1336 /* We must always keep the new value, since children depend on it. */
1337 var
->value
= value_holder
;
1338 if (value
&& value
->lazy () && intentionally_not_fetched
)
1339 var
->not_fetched
= true;
1341 var
->not_fetched
= false;
1342 var
->updated
= false;
1344 install_new_value_visualizer (var
);
1346 /* If we installed a pretty-printer, re-compare the printed version
1347 to see if the variable changed. */
1348 if (var
->dynamic
->pretty_printer
!= NULL
)
1350 print_value
= varobj_value_get_print_value (var
->value
.get (),
1352 if (var
->print_value
!= print_value
)
1355 var
->print_value
= print_value
;
1357 gdb_assert (var
->value
== nullptr || var
->value
->type ());
1362 /* Return the requested range for a varobj. VAR is the varobj. FROM
1363 and TO are out parameters; *FROM and *TO will be set to the
1364 selected sub-range of VAR. If no range was selected using
1365 -var-set-update-range, then both will be -1. */
1367 varobj_get_child_range (const struct varobj
*var
, int *from
, int *to
)
1373 /* Set the selected sub-range of children of VAR to start at index
1374 FROM and end at index TO. If either FROM or TO is less than zero,
1375 this is interpreted as a request for all children. */
1377 varobj_set_child_range (struct varobj
*var
, int from
, int to
)
1384 varobj_set_visualizer (struct varobj
*var
, const char *visualizer
)
1389 if (!gdb_python_initialized
)
1392 gdbpy_enter_varobj
enter_py (var
);
1394 mainmod
= PyImport_AddModule ("__main__");
1396 = gdbpy_ref
<>::new_reference (PyModule_GetDict (mainmod
));
1397 gdbpy_ref
<> constructor (PyRun_String (visualizer
, Py_eval_input
,
1398 globals
.get (), globals
.get ()));
1400 if (constructor
== NULL
)
1402 gdbpy_print_stack ();
1403 error (_("Could not evaluate visualizer expression: %s"), visualizer
);
1406 construct_visualizer (var
, constructor
.get ());
1408 /* If there are any children now, wipe them. */
1409 varobj_delete (var
, 1 /* children only */);
1410 var
->num_children
= -1;
1412 error (_("Python support required"));
1416 /* If NEW_VALUE is the new value of the given varobj (var), return
1417 true if var has mutated. In other words, if the type of
1418 the new value is different from the type of the varobj's old
1421 NEW_VALUE may be NULL, if the varobj is now out of scope. */
1424 varobj_value_has_mutated (const struct varobj
*var
, struct value
*new_value
,
1425 struct type
*new_type
)
1427 /* If we haven't previously computed the number of children in var,
1428 it does not matter from the front-end's perspective whether
1429 the type has mutated or not. For all intents and purposes,
1430 it has not mutated. */
1431 if (var
->num_children
< 0)
1434 if (var
->root
->lang_ops
->value_has_mutated
!= NULL
)
1436 /* The varobj module, when installing new values, explicitly strips
1437 references, saying that we're not interested in those addresses.
1438 But detection of mutation happens before installing the new
1439 value, so our value may be a reference that we need to strip
1440 in order to remain consistent. */
1441 if (new_value
!= NULL
)
1442 new_value
= coerce_ref (new_value
);
1443 return var
->root
->lang_ops
->value_has_mutated (var
, new_value
, new_type
);
1449 /* Update the values for a variable and its children. This is a
1450 two-pronged attack. First, re-parse the value for the root's
1451 expression to see if it's changed. Then go all the way
1452 through its children, reconstructing them and noting if they've
1455 The IS_EXPLICIT parameter specifies if this call is result
1456 of MI request to update this specific variable, or
1457 result of implicit -var-update *. For implicit request, we don't
1458 update frozen variables.
1460 NOTE: This function may delete the caller's varobj. If it
1461 returns TYPE_CHANGED, then it has done this and VARP will be modified
1462 to point to the new varobj. */
1464 std::vector
<varobj_update_result
>
1465 varobj_update (struct varobj
**varp
, bool is_explicit
)
1467 bool type_changed
= false;
1468 struct value
*newobj
;
1469 std::vector
<varobj_update_result
> stack
;
1470 std::vector
<varobj_update_result
> result
;
1472 /* Frozen means frozen -- we don't check for any change in
1473 this varobj, including its going out of scope, or
1474 changing type. One use case for frozen varobjs is
1475 retaining previously evaluated expressions, and we don't
1476 want them to be reevaluated at all. */
1477 if (!is_explicit
&& (*varp
)->frozen
)
1480 if (!(*varp
)->root
->is_valid
)
1482 result
.emplace_back (*varp
, VAROBJ_INVALID
);
1486 if ((*varp
)->root
->rootvar
== *varp
)
1488 varobj_update_result
r (*varp
);
1490 /* Update the root variable. value_of_root can return NULL
1491 if the variable is no longer around, i.e. we stepped out of
1492 the frame in which a local existed. We are letting the
1493 value_of_root variable dispose of the varobj if the type
1495 newobj
= value_of_root (varp
, &type_changed
);
1496 if (update_type_if_necessary (*varp
, newobj
))
1497 type_changed
= true;
1499 r
.type_changed
= type_changed
;
1500 if (install_new_value ((*varp
), newobj
, type_changed
))
1504 r
.status
= VAROBJ_NOT_IN_SCOPE
;
1505 r
.value_installed
= true;
1507 if (r
.status
== VAROBJ_NOT_IN_SCOPE
)
1509 if (r
.type_changed
|| r
.changed
)
1510 result
.push_back (std::move (r
));
1515 stack
.push_back (std::move (r
));
1518 stack
.emplace_back (*varp
);
1520 /* Walk through the children, reconstructing them all. */
1521 while (!stack
.empty ())
1523 varobj_update_result r
= std::move (stack
.back ());
1525 struct varobj
*v
= r
.varobj
;
1527 /* Update this variable, unless it's a root, which is already
1529 if (!r
.value_installed
)
1531 struct type
*new_type
;
1533 newobj
= value_of_child (v
->parent
, v
->index
);
1534 if (update_type_if_necessary (v
, newobj
))
1535 r
.type_changed
= true;
1537 new_type
= newobj
->type ();
1539 new_type
= v
->root
->lang_ops
->type_of_child (v
->parent
, v
->index
);
1541 if (varobj_value_has_mutated (v
, newobj
, new_type
))
1543 /* The children are no longer valid; delete them now.
1544 Report the fact that its type changed as well. */
1545 varobj_delete (v
, 1 /* only_children */);
1546 v
->num_children
= -1;
1550 r
.type_changed
= true;
1553 if (install_new_value (v
, newobj
, r
.type_changed
))
1560 /* We probably should not get children of a dynamic varobj, but
1561 for which -var-list-children was never invoked. */
1562 if (varobj_is_dynamic_p (v
))
1564 std::vector
<varobj
*> changed
, type_changed_vec
, unchanged
, newobj_vec
;
1565 bool children_changed
= false;
1570 if (!v
->dynamic
->children_requested
)
1574 /* If we initially did not have potential children, but
1575 now we do, consider the varobj as changed.
1576 Otherwise, if children were never requested, consider
1577 it as unchanged -- presumably, such varobj is not yet
1578 expanded in the UI, so we need not bother getting
1580 if (!varobj_has_more (v
, 0))
1582 update_dynamic_varobj_children (v
, NULL
, NULL
, NULL
, NULL
,
1583 &dummy
, false, 0, 0);
1584 if (varobj_has_more (v
, 0))
1589 result
.push_back (std::move (r
));
1594 /* If update_dynamic_varobj_children returns false, then we have
1595 a non-conforming pretty-printer, so we skip it. */
1596 if (update_dynamic_varobj_children (v
, &changed
, &type_changed_vec
,
1598 &unchanged
, &children_changed
,
1599 true, v
->from
, v
->to
))
1601 if (children_changed
|| !newobj_vec
.empty ())
1603 r
.children_changed
= true;
1604 r
.newobj
= std::move (newobj_vec
);
1606 /* Push in reverse order so that the first child is
1607 popped from the work stack first, and so will be
1608 added to result first. This does not affect
1609 correctness, just "nicer". */
1610 for (int i
= type_changed_vec
.size () - 1; i
>= 0; --i
)
1612 varobj_update_result
item (type_changed_vec
[i
]);
1614 /* Type may change only if value was changed. */
1615 item
.changed
= true;
1616 item
.type_changed
= true;
1617 item
.value_installed
= true;
1619 stack
.push_back (std::move (item
));
1621 for (int i
= changed
.size () - 1; i
>= 0; --i
)
1623 varobj_update_result
item (changed
[i
]);
1625 item
.changed
= true;
1626 item
.value_installed
= true;
1628 stack
.push_back (std::move (item
));
1630 for (int i
= unchanged
.size () - 1; i
>= 0; --i
)
1632 if (!unchanged
[i
]->frozen
)
1634 varobj_update_result
item (unchanged
[i
]);
1636 item
.value_installed
= true;
1638 stack
.push_back (std::move (item
));
1641 if (r
.changed
|| r
.children_changed
)
1642 result
.push_back (std::move (r
));
1648 /* Push any children. Use reverse order so that the first
1649 child is popped from the work stack first, and so
1650 will be added to result first. This does not
1651 affect correctness, just "nicer". */
1652 for (int i
= v
->children
.size () - 1; i
>= 0; --i
)
1654 varobj
*c
= v
->children
[i
];
1656 /* Child may be NULL if explicitly deleted by -var-delete. */
1657 if (c
!= NULL
&& !c
->frozen
)
1658 stack
.emplace_back (c
);
1661 if (r
.changed
|| r
.type_changed
)
1662 result
.push_back (std::move (r
));
1668 /* Helper functions */
1671 * Variable object construction/destruction
1675 delete_variable (struct varobj
*var
, bool only_children_p
)
1679 delete_variable_1 (&delcount
, var
, only_children_p
,
1680 true /* remove_from_parent_p */ );
1685 /* Delete the variable object VAR and its children. */
1686 /* IMPORTANT NOTE: If we delete a variable which is a child
1687 and the parent is not removed we dump core. It must be always
1688 initially called with remove_from_parent_p set. */
1690 delete_variable_1 (int *delcountp
, struct varobj
*var
, bool only_children_p
,
1691 bool remove_from_parent_p
)
1693 /* Delete any children of this variable, too. */
1694 for (varobj
*child
: var
->children
)
1699 if (!remove_from_parent_p
)
1700 child
->parent
= NULL
;
1702 delete_variable_1 (delcountp
, child
, false, only_children_p
);
1704 var
->children
.clear ();
1706 /* if we were called to delete only the children we are done here. */
1707 if (only_children_p
)
1710 /* Otherwise, add it to the list of deleted ones and proceed to do so. */
1711 /* If the name is empty, this is a temporary variable, that has not
1712 yet been installed, don't report it, it belongs to the caller... */
1713 if (!var
->obj_name
.empty ())
1715 *delcountp
= *delcountp
+ 1;
1718 /* If this variable has a parent, remove it from its parent's list. */
1719 /* OPTIMIZATION: if the parent of this variable is also being deleted,
1720 (as indicated by remove_from_parent_p) we don't bother doing an
1721 expensive list search to find the element to remove when we are
1722 discarding the list afterwards. */
1723 if ((remove_from_parent_p
) && (var
->parent
!= NULL
))
1724 var
->parent
->children
[var
->index
] = NULL
;
1726 if (!var
->obj_name
.empty ())
1727 uninstall_variable (var
);
1729 /* Free memory associated with this variable. */
1733 /* Install the given variable VAR with the object name VAR->OBJ_NAME. */
1735 install_variable (struct varobj
*var
)
1737 hashval_t hash
= htab_hash_string (var
->obj_name
.c_str ());
1738 void **slot
= htab_find_slot_with_hash (varobj_table
,
1739 var
->obj_name
.c_str (),
1741 if (*slot
!= nullptr)
1742 error (_("Duplicate variable object name"));
1744 /* Add varobj to hash table. */
1747 /* If root, add varobj to root list. */
1748 if (is_root_p (var
))
1749 rootlist
.push_front (var
->root
);
1752 /* Uninstall the object VAR. */
1754 uninstall_variable (struct varobj
*var
)
1756 hashval_t hash
= htab_hash_string (var
->obj_name
.c_str ());
1757 htab_remove_elt_with_hash (varobj_table
, var
->obj_name
.c_str (), hash
);
1760 gdb_printf (gdb_stdlog
, "Deleting %s\n", var
->obj_name
.c_str ());
1762 /* If root, remove varobj from root list. */
1763 if (is_root_p (var
))
1765 auto iter
= std::find (rootlist
.begin (), rootlist
.end (), var
->root
);
1766 rootlist
.erase (iter
);
1770 /* Create and install a child of the parent of the given name.
1772 The created VAROBJ takes ownership of the allocated NAME. */
1774 static struct varobj
*
1775 create_child (struct varobj
*parent
, int index
, std::string
&name
)
1777 struct varobj_item item
;
1779 std::swap (item
.name
, name
);
1780 item
.value
= release_value (value_of_child (parent
, index
));
1782 return create_child_with_value (parent
, index
, &item
);
1785 static struct varobj
*
1786 create_child_with_value (struct varobj
*parent
, int index
,
1787 struct varobj_item
*item
)
1789 varobj
*child
= new varobj (parent
->root
);
1791 /* NAME is allocated by caller. */
1792 std::swap (child
->name
, item
->name
);
1793 child
->index
= index
;
1794 child
->parent
= parent
;
1796 if (varobj_is_anonymous_child (child
))
1797 child
->obj_name
= string_printf ("%s.%d_anonymous",
1798 parent
->obj_name
.c_str (), index
);
1800 child
->obj_name
= string_printf ("%s.%s",
1801 parent
->obj_name
.c_str (),
1802 child
->name
.c_str ());
1804 install_variable (child
);
1806 /* Compute the type of the child. Must do this before
1807 calling install_new_value. */
1808 if (item
->value
!= NULL
)
1809 /* If the child had no evaluation errors, var->value
1810 will be non-NULL and contain a valid type. */
1811 child
->type
= value_actual_type (item
->value
.get (), 0, NULL
);
1813 /* Otherwise, we must compute the type. */
1814 child
->type
= (*child
->root
->lang_ops
->type_of_child
) (child
->parent
,
1816 install_new_value (child
, item
->value
.get (), 1);
1823 * Miscellaneous utility functions.
1826 /* Allocate memory and initialize a new variable. */
1827 varobj::varobj (varobj_root
*root_
)
1828 : root (root_
), dynamic (new varobj_dynamic
)
1832 /* Free any allocated memory associated with VAR. */
1839 if (var
->dynamic
->pretty_printer
!= NULL
)
1841 gdbpy_enter_varobj
enter_py (var
);
1843 Py_XDECREF (var
->dynamic
->constructor
);
1844 Py_XDECREF (var
->dynamic
->pretty_printer
);
1848 /* This must be deleted before the root object, because Python-based
1849 destructors need access to some components. */
1850 delete var
->dynamic
;
1852 if (is_root_p (var
))
1856 /* Return the type of the value that's stored in VAR,
1857 or that would have being stored there if the
1858 value were accessible.
1860 This differs from VAR->type in that VAR->type is always
1861 the true type of the expression in the source language.
1862 The return value of this function is the type we're
1863 actually storing in varobj, and using for displaying
1864 the values and for comparing previous and new values.
1866 For example, top-level references are always stripped. */
1868 varobj_get_value_type (const struct varobj
*var
)
1872 if (var
->value
!= nullptr)
1873 type
= var
->value
->type ();
1877 type
= check_typedef (type
);
1879 if (TYPE_IS_REFERENCE (type
))
1880 type
= get_target_type (type
);
1882 type
= check_typedef (type
);
1887 /* What is the default display for this variable? We assume that
1888 everything is "natural". Any exceptions? */
1889 static enum varobj_display_formats
1890 variable_default_display (struct varobj
*var
)
1892 return FORMAT_NATURAL
;
1896 * Language-dependencies
1899 /* Common entry points */
1901 /* Return the number of children for a given variable.
1902 The result of this function is defined by the language
1903 implementation. The number of children returned by this function
1904 is the number of children that the user will see in the variable
1907 number_of_children (const struct varobj
*var
)
1909 return (*var
->root
->lang_ops
->number_of_children
) (var
);
1912 /* What is the expression for the root varobj VAR? */
1915 name_of_variable (const struct varobj
*var
)
1917 return (*var
->root
->lang_ops
->name_of_variable
) (var
);
1920 /* What is the name of the INDEX'th child of VAR? */
1923 name_of_child (struct varobj
*var
, int index
)
1925 return (*var
->root
->lang_ops
->name_of_child
) (var
, index
);
1928 /* If frame associated with VAR can be found, switch
1929 to it and return true. Otherwise, return false. */
1932 check_scope (const struct varobj
*var
)
1937 fi
= frame_find_by_id (var
->root
->frame
);
1942 CORE_ADDR pc
= get_frame_pc (fi
);
1944 if (pc
< var
->root
->valid_block
->start () ||
1945 pc
>= var
->root
->valid_block
->end ())
1953 /* Helper function to value_of_root. */
1955 static struct value
*
1956 value_of_root_1 (struct varobj
**var_handle
)
1958 struct value
*new_val
= NULL
;
1959 struct varobj
*var
= *var_handle
;
1960 bool within_scope
= false;
1962 /* Only root variables can be updated... */
1963 if (!is_root_p (var
))
1964 /* Not a root var. */
1967 scoped_restore_current_thread restore_thread
;
1969 /* Determine whether the variable is still around. */
1970 if (var
->root
->valid_block
== NULL
|| var
->root
->floating
)
1971 within_scope
= true;
1972 else if (var
->root
->thread_id
== 0)
1974 /* The program was single-threaded when the variable object was
1975 created. Technically, it's possible that the program became
1976 multi-threaded since then, but we don't support such
1978 within_scope
= check_scope (var
);
1982 thread_info
*thread
= find_thread_global_id (var
->root
->thread_id
);
1986 switch_to_thread (thread
);
1987 within_scope
= check_scope (var
);
1994 /* We need to catch errors here, because if evaluate
1995 expression fails we want to just return NULL. */
1998 new_val
= var
->root
->exp
->evaluate ();
2000 catch (const gdb_exception_error
&except
)
2008 /* What is the ``struct value *'' of the root variable VAR?
2009 For floating variable object, evaluation can get us a value
2010 of different type from what is stored in varobj already. In
2012 - *type_changed will be set to 1
2013 - old varobj will be freed, and new one will be
2014 created, with the same name.
2015 - *var_handle will be set to the new varobj
2016 Otherwise, *type_changed will be set to 0. */
2017 static struct value
*
2018 value_of_root (struct varobj
**var_handle
, bool *type_changed
)
2022 if (var_handle
== NULL
)
2027 /* This should really be an exception, since this should
2028 only get called with a root variable. */
2030 if (!is_root_p (var
))
2033 if (var
->root
->floating
)
2035 struct varobj
*tmp_var
;
2037 tmp_var
= varobj_create (NULL
, var
->name
.c_str (), (CORE_ADDR
) 0,
2038 USE_SELECTED_FRAME
);
2039 if (tmp_var
== NULL
)
2043 std::string old_type
= varobj_get_type (var
);
2044 std::string new_type
= varobj_get_type (tmp_var
);
2045 if (old_type
== new_type
)
2047 /* The expression presently stored inside var->root->exp
2048 remembers the locations of local variables relatively to
2049 the frame where the expression was created (in DWARF location
2050 button, for example). Naturally, those locations are not
2051 correct in other frames, so update the expression. */
2053 std::swap (var
->root
->exp
, tmp_var
->root
->exp
);
2055 varobj_delete (tmp_var
, 0);
2060 tmp_var
->obj_name
= var
->obj_name
;
2061 tmp_var
->from
= var
->from
;
2062 tmp_var
->to
= var
->to
;
2063 varobj_delete (var
, 0);
2065 install_variable (tmp_var
);
2066 *var_handle
= tmp_var
;
2068 *type_changed
= true;
2077 struct value
*value
;
2079 value
= value_of_root_1 (var_handle
);
2080 if (var
->value
== NULL
|| value
== NULL
)
2082 /* For root varobj-s, a NULL value indicates a scoping issue.
2083 So, nothing to do in terms of checking for mutations. */
2085 else if (varobj_value_has_mutated (var
, value
, value
->type ()))
2087 /* The type has mutated, so the children are no longer valid.
2088 Just delete them, and tell our caller that the type has
2090 varobj_delete (var
, 1 /* only_children */);
2091 var
->num_children
= -1;
2094 *type_changed
= true;
2100 /* What is the ``struct value *'' for the INDEX'th child of PARENT? */
2101 static struct value
*
2102 value_of_child (const struct varobj
*parent
, int index
)
2104 struct value
*value
;
2106 value
= (*parent
->root
->lang_ops
->value_of_child
) (parent
, index
);
2111 /* GDB already has a command called "value_of_variable". Sigh. */
2113 my_value_of_variable (struct varobj
*var
, enum varobj_display_formats format
)
2115 if (var
->root
->is_valid
)
2117 if (var
->dynamic
->pretty_printer
!= NULL
)
2118 return varobj_value_get_print_value (var
->value
.get (), var
->format
,
2120 return (*var
->root
->lang_ops
->value_of_variable
) (var
, format
);
2123 return std::string ();
2127 varobj_formatted_print_options (struct value_print_options
*opts
,
2128 enum varobj_display_formats format
)
2130 get_formatted_print_options (opts
, format_code
[(int) format
]);
2131 opts
->deref_ref
= false;
2132 opts
->raw
= !pretty_printing
;
2136 varobj_value_get_print_value (struct value
*value
,
2137 enum varobj_display_formats format
,
2138 const struct varobj
*var
)
2140 struct value_print_options opts
;
2141 struct type
*type
= NULL
;
2143 gdb::unique_xmalloc_ptr
<char> encoding
;
2144 /* Initialize it just to avoid a GCC false warning. */
2145 CORE_ADDR str_addr
= 0;
2146 bool string_print
= false;
2149 return std::string ();
2152 std::string thevalue
;
2154 varobj_formatted_print_options (&opts
, format
);
2157 if (gdb_python_initialized
)
2159 PyObject
*value_formatter
= var
->dynamic
->pretty_printer
;
2161 gdbpy_enter_varobj
enter_py (var
);
2163 if (value_formatter
)
2165 if (PyObject_HasAttr (value_formatter
, gdbpy_to_string_cst
))
2167 struct value
*replacement
;
2169 gdbpy_ref
<> output
= apply_varobj_pretty_printer (value_formatter
,
2174 /* If we have string like output ... */
2175 if (output
!= nullptr && output
!= Py_None
)
2177 /* If this is a lazy string, extract it. For lazy
2178 strings we always print as a string, so set
2180 if (gdbpy_is_lazy_string (output
.get ()))
2182 gdbpy_extract_lazy_string (output
.get (), &str_addr
,
2183 &type
, &len
, &encoding
);
2184 string_print
= true;
2188 /* If it is a regular (non-lazy) string, extract
2189 it and copy the contents into THEVALUE. If the
2190 hint says to print it as a string, set
2191 string_print. Otherwise just return the extracted
2192 string as a value. */
2194 gdb::unique_xmalloc_ptr
<char> s
2195 = python_string_to_target_string (output
.get ());
2199 struct gdbarch
*gdbarch
;
2201 gdb::unique_xmalloc_ptr
<char> hint
2202 = gdbpy_get_display_hint (value_formatter
);
2205 if (!strcmp (hint
.get (), "string"))
2206 string_print
= true;
2209 thevalue
= std::string (s
.get ());
2210 len
= thevalue
.size ();
2211 gdbarch
= value
->type ()->arch ();
2212 type
= builtin_type (gdbarch
)->builtin_char
;
2218 gdbpy_print_stack ();
2221 /* If the printer returned a replacement value, set VALUE
2222 to REPLACEMENT. If there is not a replacement value,
2223 just use the value passed to this function. */
2225 value
= replacement
;
2229 /* No to_string method, so if there is a 'children'
2230 method, return the default. */
2231 if (PyObject_HasAttr (value_formatter
, gdbpy_children_cst
))
2238 /* If the THEVALUE has contents, it is a regular string. */
2239 if (!thevalue
.empty ())
2240 current_language
->printstr (&stb
, type
, (gdb_byte
*) thevalue
.c_str (),
2241 len
, encoding
.get (), 0, &opts
);
2242 else if (string_print
)
2243 /* Otherwise, if string_print is set, and it is not a regular
2244 string, it is a lazy string. */
2245 val_print_string (type
, encoding
.get (), str_addr
, len
, &stb
, &opts
);
2247 /* All other cases. */
2248 common_val_print (value
, &stb
, 0, &opts
, current_language
);
2250 return stb
.release ();
2254 varobj_editable_p (const struct varobj
*var
)
2258 if (!(var
->root
->is_valid
&& var
->value
!= nullptr
2259 && var
->value
->lval ()))
2262 type
= varobj_get_value_type (var
);
2264 switch (type
->code ())
2266 case TYPE_CODE_STRUCT
:
2267 case TYPE_CODE_UNION
:
2268 case TYPE_CODE_ARRAY
:
2269 case TYPE_CODE_FUNC
:
2270 case TYPE_CODE_METHOD
:
2280 /* Call VAR's value_is_changeable_p language-specific callback. */
2283 varobj_value_is_changeable_p (const struct varobj
*var
)
2285 return var
->root
->lang_ops
->value_is_changeable_p (var
);
2288 /* Return true if that varobj is floating, that is is always evaluated in the
2289 selected frame, and not bound to thread/frame. Such variable objects
2290 are created using '@' as frame specifier to -var-create. */
2292 varobj_floating_p (const struct varobj
*var
)
2294 return var
->root
->floating
;
2297 /* Implement the "value_is_changeable_p" varobj callback for most
2301 varobj_default_value_is_changeable_p (const struct varobj
*var
)
2306 if (CPLUS_FAKE_CHILD (var
))
2309 type
= varobj_get_value_type (var
);
2311 switch (type
->code ())
2313 case TYPE_CODE_STRUCT
:
2314 case TYPE_CODE_UNION
:
2315 case TYPE_CODE_ARRAY
:
2326 /* Iterate all the existing _root_ VAROBJs and call the FUNC callback
2330 all_root_varobjs (gdb::function_view
<void (struct varobj
*var
)> func
)
2332 /* Iterate "safely" - handle if the callee deletes its passed VAROBJ. */
2333 auto iter
= rootlist
.begin ();
2334 auto end
= rootlist
.end ();
2338 func ((*self
)->rootvar
);
2342 /* Try to recreate the varobj VAR if it is a global or floating. This is a
2343 helper function for varobj_re_set. */
2346 varobj_re_set_iter (struct varobj
*var
)
2348 /* Invalidated global varobjs must be re-evaluated. */
2349 if (!var
->root
->is_valid
&& var
->root
->global
)
2351 struct varobj
*tmp_var
;
2353 /* Try to create a varobj with same expression. If we succeed
2354 and have a global replace the old varobj. */
2355 tmp_var
= varobj_create (nullptr, var
->name
.c_str (), (CORE_ADDR
) 0,
2357 if (tmp_var
!= nullptr && tmp_var
->root
->global
)
2359 tmp_var
->obj_name
= var
->obj_name
;
2360 varobj_delete (var
, 0);
2361 install_variable (tmp_var
);
2369 varobj_re_set (void)
2371 all_root_varobjs (varobj_re_set_iter
);
2374 /* Ensure that no varobj keep references to OBJFILE. */
2377 varobj_invalidate_if_uses_objfile (struct objfile
*objfile
)
2379 if (objfile
->separate_debug_objfile_backlink
!= nullptr)
2380 objfile
= objfile
->separate_debug_objfile_backlink
;
2382 all_root_varobjs ([objfile
] (struct varobj
*var
)
2384 if (var
->root
->valid_block
!= nullptr)
2386 struct objfile
*bl_objfile
= var
->root
->valid_block
->objfile ();
2387 if (bl_objfile
->separate_debug_objfile_backlink
!= nullptr)
2388 bl_objfile
= bl_objfile
->separate_debug_objfile_backlink
;
2390 if (bl_objfile
== objfile
)
2392 /* The varobj is tied to a block which is going away. There is
2393 no way to reconstruct something later, so invalidate the
2394 varobj completely and drop the reference to the block which is
2396 var
->root
->is_valid
= false;
2397 var
->root
->valid_block
= nullptr;
2401 if (var
->root
->exp
!= nullptr && var
->root
->exp
->uses_objfile (objfile
))
2403 /* The varobj's current expression references the objfile. For
2404 globals and floating, it is possible that when we try to
2405 re-evaluate the expression later it is still valid with
2406 whatever is in scope at that moment. Just invalidate the
2407 expression for now. */
2408 var
->root
->exp
.reset ();
2410 /* It only makes sense to keep a floating varobj around. */
2411 if (!var
->root
->floating
)
2412 var
->root
->is_valid
= false;
2415 /* var->value->type and var->type might also reference the objfile.
2416 This is taken care of in value.c:preserve_values which deals with
2417 making sure that objfile-owned types are replaced with
2418 gdbarch-owned equivalents. */
2422 /* A hash function for a varobj. */
2425 hash_varobj (const void *a
)
2427 const varobj
*obj
= (const varobj
*) a
;
2428 return htab_hash_string (obj
->obj_name
.c_str ());
2431 /* A hash table equality function for varobjs. */
2434 eq_varobj_and_string (const void *a
, const void *b
)
2436 const varobj
*obj
= (const varobj
*) a
;
2437 const char *name
= (const char *) b
;
2439 return obj
->obj_name
== name
;
2442 void _initialize_varobj ();
2444 _initialize_varobj ()
2446 varobj_table
= htab_create_alloc (5, hash_varobj
, eq_varobj_and_string
,
2447 nullptr, xcalloc
, xfree
);
2449 add_setshow_zuinteger_cmd ("varobj", class_maintenance
,
2451 _("Set varobj debugging."),
2452 _("Show varobj debugging."),
2453 _("When non-zero, varobj debugging is enabled."),
2454 NULL
, show_varobjdebug
,
2455 &setdebuglist
, &showdebuglist
);
2457 gdb::observers::free_objfile
.attach (varobj_invalidate_if_uses_objfile
,