GDB (xrefs)
Loading...
Searching...
No Matches
varobj.c
Go to the documentation of this file.
1/* Implementation of the GDB variable objects API.
2
3 Copyright (C) 1999-2023 Free Software Foundation, Inc.
4
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.
9
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.
14
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/>. */
17
18#include "defs.h"
19#include "value.h"
20#include "expression.h"
21#include "frame.h"
22#include "language.h"
23#include "gdbcmd.h"
24#include "block.h"
25#include "valprint.h"
26#include "gdbsupport/gdb_regex.h"
27
28#include "varobj.h"
29#include "gdbthread.h"
30#include "inferior.h"
31#include "varobj-iter.h"
32#include "parser-defs.h"
33#include "gdbarch.h"
34#include <algorithm>
35#include "observable.h"
36
37#if HAVE_PYTHON
38#include "python/python.h"
40#else
41typedef int PyObject;
42#endif
43
44/* See varobj.h. */
45
46unsigned int varobjdebug = 0;
47static void
48show_varobjdebug (struct ui_file *file, int from_tty,
49 struct cmd_list_element *c, const char *value)
50{
51 gdb_printf (file, _("Varobj debugging is %s.\n"), value);
52}
53
54/* String representations of gdb's format codes. */
55const char *varobj_format_string[] =
56 { "natural", "binary", "decimal", "hexadecimal", "octal", "zero-hexadecimal" };
57
58/* True if we want to allow Python-based pretty-printing. */
59static bool pretty_printing = false;
60
61void
66
67/* Data structures */
68
69/* Every root variable has one of these structures saved in its
70 varobj. */
72{
73 /* The expression for this parent. */
75
76 /* Cached arch from exp, for use in case exp gets invalidated. */
77 struct gdbarch *gdbarch = nullptr;
78
79 /* Cached language from exp, for use in case exp gets invalidated. */
80 const struct language_defn *language_defn = nullptr;
81
82 /* Block for which this expression is valid. */
83 const struct block *valid_block = NULL;
84
85 /* The frame for this expression. This field is set iff valid_block is
86 not NULL. */
88
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
93 was created. */
94 int thread_id = 0;
95
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;
100
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;
104
105 /* Set to true if the varobj was created as tracking a global. */
106 bool global = false;
107
108 /* Language-related operations for this variable and its
109 children. */
110 const struct lang_varobj_ops *lang_ops = NULL;
111
112 /* The varobj for this root node. */
113 struct varobj *rootvar = NULL;
114};
115
116/* Dynamic part of varobj. */
117
119{
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
123 can avoid that. */
124 bool children_requested = false;
125
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. */
130
131 /* The pretty-printer that has been constructed. If NULL, then a
132 new printer object is needed, and one will be constructed. */
134
135 /* The iterator returned by the printer's 'children' method, or NULL
136 if not available. */
137 std::unique_ptr<varobj_iter> child_iter;
138
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;
145};
146
147/* Private function prototypes */
148
149/* Helper functions for the above subcommands. */
150
151static int delete_variable (struct varobj *, bool);
152
153static void delete_variable_1 (int *, struct varobj *, bool, bool);
154
155static void install_variable (struct varobj *);
156
157static void uninstall_variable (struct varobj *);
158
159static struct varobj *create_child (struct varobj *, int, std::string &);
160
161static struct varobj *
163 struct varobj_item *item);
164
165/* Utility routines */
166
167static bool update_type_if_necessary (struct varobj *var,
168 struct value *new_value);
169
170static bool install_new_value (struct varobj *var, struct value *value,
171 bool initial);
172
173/* Language-specific routines. */
174
175static int number_of_children (const struct varobj *);
176
177static std::string name_of_variable (const struct varobj *);
178
179static std::string name_of_child (struct varobj *, int);
180
181static struct value *value_of_root (struct varobj **var_handle, bool *);
182
183static struct value *value_of_child (const struct varobj *parent, int index);
184
185static std::string my_value_of_variable (struct varobj *var,
186 enum varobj_display_formats format);
187
188static bool is_root_p (const struct varobj *var);
189
190static struct varobj *varobj_add_child (struct varobj *var,
191 struct varobj_item *item);
192
193/* Private data */
194
195/* Mappings of varobj_display_formats enums to gdb's format codes. */
196static int format_code[] = { 0, 't', 'd', 'x', 'o', 'z' };
197
198/* List of root variable objects. */
199static std::list<struct varobj_root *> rootlist;
200
201/* Pointer to the varobj hash table (built at run time). */
202static htab_t varobj_table;
203
204
205
206/* API Implementation */
207static bool
208is_root_p (const struct varobj *var)
209{
210 return (var->root->rootvar == var);
211}
212
213#ifdef HAVE_PYTHON
214
215/* See python-internal.h. */
218{
219}
220
221#endif
222
223/* Return the full FRAME which corresponds to the given CORE_ADDR
224 or NULL if no FRAME on the chain corresponds to CORE_ADDR. */
225
226static frame_info_ptr
227find_frame_addr_in_frame_chain (CORE_ADDR frame_addr)
228{
229 frame_info_ptr frame = NULL;
230
231 if (frame_addr == (CORE_ADDR) 0)
232 return NULL;
233
234 for (frame = get_current_frame ();
235 frame != NULL;
236 frame = get_prev_frame (frame))
237 {
238 /* The CORE_ADDR we get as argument was parsed from a string GDB
239 output as $fp. This output got truncated to gdbarch_addr_bit.
240 Truncate the frame base address in the same manner before
241 comparing it against our argument. */
242 CORE_ADDR frame_base = get_frame_base_address (frame);
243 int addr_bit = gdbarch_addr_bit (get_frame_arch (frame));
244
245 if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
246 frame_base &= ((CORE_ADDR) 1 << addr_bit) - 1;
247
248 if (frame_base == frame_addr)
249 return frame;
250 }
251
252 return NULL;
253}
254
255/* Creates a varobj (not its children). */
256
257struct varobj *
258varobj_create (const char *objname,
259 const char *expression, CORE_ADDR frame, enum varobj_type type)
260{
261 /* Fill out a varobj structure for the (root) variable being constructed. */
262 auto var = gdb::make_unique<varobj> (new varobj_root);
263
264 if (expression != NULL)
265 {
267 struct frame_id old_id = null_frame_id;
268 const struct block *block;
269 const char *p;
270 struct value *value = NULL;
271 CORE_ADDR pc;
272
273 /* Parse and evaluate the expression, filling in as much of the
274 variable's data as possible. */
275
276 if (has_stack_frames ())
277 {
278 /* Allow creator to specify context of variable. */
280 fi = get_selected_frame (NULL);
281 else
282 /* FIXME: cagney/2002-11-23: This code should be doing a
283 lookup using the frame ID and not just the frame's
284 ``address''. This, of course, means an interface
285 change. However, with out that interface change ISAs,
286 such as the ia64 with its two stacks, won't work.
287 Similar goes for the case where there is a frameless
288 function. */
290 }
291 else
292 fi = NULL;
293
295 var->root->floating = true;
296
297 pc = 0;
298 block = NULL;
299 if (fi != NULL)
300 {
301 block = get_frame_block (fi, 0);
302 pc = get_frame_pc (fi);
303 }
304
305 p = expression;
306
309 /* Wrap the call to parse expression, so we can
310 return a sensible error. */
311 try
312 {
313 var->root->exp = parse_exp_1 (&p, pc, block, 0, &tracker);
314
315 /* Cache gdbarch and language_defn as they might be used even
316 after var is invalidated and var->root->exp cleared. */
317 var->root->gdbarch = var->root->exp->gdbarch;
318 var->root->language_defn = var->root->exp->language_defn;
319 }
320
321 catch (const gdb_exception_error &except)
322 {
323 return NULL;
324 }
325
326 /* Don't allow variables to be created for types. */
327 enum exp_opcode opcode = var->root->exp->first_opcode ();
328 if (opcode == OP_TYPE
329 || opcode == OP_TYPEOF
330 || opcode == OP_DECLTYPE)
331 {
332 gdb_printf (gdb_stderr, "Attempt to use a type name"
333 " as an expression.\n");
334 return NULL;
335 }
336
337 var->format = FORMAT_NATURAL;
338 var->root->valid_block =
339 var->root->floating ? NULL : tracker.block ();
340 var->root->global
341 = var->root->floating ? false : var->root->valid_block == nullptr;
342 var->name = expression;
343 /* For a root var, the name and the expr are the same. */
344 var->path_expr = expression;
345
346 /* When the frame is different from the current frame,
347 we must select the appropriate frame before parsing
348 the expression, otherwise the value will not be current.
349 Since select_frame is so benign, just call it for all cases. */
350 if (var->root->valid_block)
351 {
352 /* User could specify explicit FRAME-ADDR which was not found but
353 EXPRESSION is frame specific and we would not be able to evaluate
354 it correctly next time. With VALID_BLOCK set we must also set
355 FRAME and THREAD_ID. */
356 if (fi == NULL)
357 error (_("Failed to find the specified frame"));
358
359 var->root->frame = get_frame_id (fi);
361 old_id = get_frame_id (get_selected_frame (NULL));
362 select_frame (fi);
363 }
364
365 /* We definitely need to catch errors here. If evaluation of
366 the expression succeeds, we got the value we wanted. But if
367 it fails, we still go on with a call to evaluate_type(). */
368 try
369 {
370 value = var->root->exp->evaluate ();
371 }
372 catch (const gdb_exception_error &except)
373 {
374 /* Error getting the value. Try to at least get the
375 right type. */
376 struct value *type_only_value = var->root->exp->evaluate_type ();
377
378 var->type = type_only_value->type ();
379 }
380
381 if (value != NULL)
382 {
383 int real_type_found = 0;
384
385 var->type = value_actual_type (value, 0, &real_type_found);
386 if (real_type_found)
387 value = value_cast (var->type, value);
388 }
389
390 /* Set language info */
391 var->root->lang_ops = var->root->exp->language_defn->varobj_ops ();
392
393 install_new_value (var.get (), value, 1 /* Initial assignment */);
394
395 /* Set ourselves as our root. */
396 var->root->rootvar = var.get ();
397
398 /* Reset the selected frame. */
399 if (frame_id_p (old_id))
401 }
402
403 /* If the variable object name is null, that means this
404 is a temporary variable, so don't install it. */
405
406 if ((var != NULL) && (objname != NULL))
407 {
408 var->obj_name = objname;
409 install_variable (var.get ());
410 }
411
412 return var.release ();
413}
414
415/* Generates an unique name that can be used for a varobj. */
416
417std::string
419{
420 static int id = 0;
421
422 /* Generate a name for this object. */
423 id++;
424 return string_printf ("var%d", id);
425}
426
427/* Given an OBJNAME, returns the pointer to the corresponding varobj. Call
428 error if OBJNAME cannot be found. */
429
430struct varobj *
431varobj_get_handle (const char *objname)
432{
433 varobj *var = (varobj *) htab_find_with_hash (varobj_table, objname,
434 htab_hash_string (objname));
435
436 if (var == NULL)
437 error (_("Variable object not found"));
438
439 return var;
440}
441
442/* Given the handle, return the name of the object. */
443
444const char *
445varobj_get_objname (const struct varobj *var)
446{
447 return var->obj_name.c_str ();
448}
449
450/* Given the handle, return the expression represented by the
451 object. */
452
453std::string
454varobj_get_expression (const struct varobj *var)
455{
456 return name_of_variable (var);
457}
458
459/* See varobj.h. */
460
461int
462varobj_delete (struct varobj *var, bool only_children)
463{
464 return delete_variable (var, only_children);
465}
466
467#if HAVE_PYTHON
468
469/* Convenience function for varobj_set_visualizer. Instantiate a
470 pretty-printer for a given value. */
471static PyObject *
472instantiate_pretty_printer (PyObject *constructor, struct value *value)
473{
475 if (val_obj == nullptr)
476 return NULL;
477
478 return PyObject_CallFunctionObjArgs (constructor, val_obj.get (), NULL);
479}
480
481#endif
482
483/* Set/Get variable object display format. */
484
488{
489 var->format = format;
490
492 && var->value != nullptr && !var->value->lazy ())
493 {
495 var->format, var);
496 }
497
498 return var->format;
499}
500
503{
504 return var->format;
505}
506
507gdb::unique_xmalloc_ptr<char>
509{
510 gdb::unique_xmalloc_ptr<char> result;
511
512#if HAVE_PYTHON
514 return NULL;
515
516 gdbpy_enter_varobj enter_py (var);
517
518 if (var->dynamic->pretty_printer != NULL)
520#endif
521
522 return result;
523}
524
525/* Return true if the varobj has items after TO, false otherwise. */
526
527bool
528varobj_has_more (const struct varobj *var, int to)
529{
530 if (var->children.size () > to)
531 return true;
532
533 return ((to == -1 || var->children.size () == to)
534 && (var->dynamic->saved_item != NULL));
535}
536
537/* If the variable object is bound to a specific thread, that
538 is its evaluation can always be done in context of a frame
539 inside that thread, returns GDB id of the thread -- which
540 is always positive. Otherwise, returns -1. */
541int
542varobj_get_thread_id (const struct varobj *var)
543{
544 if (var->root->valid_block && var->root->thread_id > 0)
545 return var->root->thread_id;
546 else
547 return -1;
548}
549
550void
551varobj_set_frozen (struct varobj *var, bool frozen)
552{
553 /* When a variable is unfrozen, we don't fetch its value.
554 The 'not_fetched' flag remains set, so next -var-update
555 won't complain.
556
557 We don't fetch the value, because for structures the client
558 should do -var-update anyway. It would be bad to have different
559 client-size logic for structure and other types. */
560 var->frozen = frozen;
561}
562
563bool
564varobj_get_frozen (const struct varobj *var)
565{
566 return var->frozen;
567}
568
569/* A helper function that updates the contents of FROM and TO based on the
570 size of the vector CHILDREN. If the contents of either FROM or TO are
571 negative the entire range is used. */
572
573void
574varobj_restrict_range (const std::vector<varobj *> &children,
575 int *from, int *to)
576{
577 int len = children.size ();
578
579 if (*from < 0 || *to < 0)
580 {
581 *from = 0;
582 *to = len;
583 }
584 else
585 {
586 if (*from > len)
587 *from = len;
588 if (*to > len)
589 *to = len;
590 if (*from > *to)
591 *from = *to;
592 }
593}
594
595/* A helper for update_dynamic_varobj_children that installs a new
596 child when needed. */
597
598static void
600 std::vector<varobj *> *changed,
601 std::vector<varobj *> *type_changed,
602 std::vector<varobj *> *newobj,
603 std::vector<varobj *> *unchanged,
604 bool *cchanged,
605 int index,
606 struct varobj_item *item)
607{
608 if (var->children.size () < index + 1)
609 {
610 /* There's no child yet. */
611 struct varobj *child = varobj_add_child (var, item);
612
613 if (newobj != NULL)
614 {
615 newobj->push_back (child);
616 *cchanged = true;
617 }
618 }
619 else
620 {
621 varobj *existing = var->children[index];
622 bool type_updated = update_type_if_necessary (existing,
623 item->value.get ());
624
625 if (type_updated)
626 {
627 if (type_changed != NULL)
628 type_changed->push_back (existing);
629 }
630 if (install_new_value (existing, item->value.get (), 0))
631 {
632 if (!type_updated && changed != NULL)
633 changed->push_back (existing);
634 }
635 else if (!type_updated && unchanged != NULL)
636 unchanged->push_back (existing);
637 }
638}
639
640/* A factory for creating dynamic varobj's iterators. Returns an
641 iterator object suitable for iterating over VAR's children. */
642
643static std::unique_ptr<varobj_iter>
645{
646#if HAVE_PYTHON
647 if (var->dynamic->pretty_printer)
648 {
651 return py_varobj_get_iterator (var, var->dynamic->pretty_printer, &opts);
652 }
653#endif
654
655 gdb_assert_not_reached ("requested an iterator from a non-dynamic varobj");
656}
657
658static bool
660 std::vector<varobj *> *changed,
661 std::vector<varobj *> *type_changed,
662 std::vector<varobj *> *newobj,
663 std::vector<varobj *> *unchanged,
664 bool *cchanged,
665 bool update_children,
666 int from,
667 int to)
668{
669 int i;
670
671 *cchanged = false;
672
673 if (update_children || var->dynamic->child_iter == NULL)
674 {
676 var->dynamic->saved_item.reset (nullptr);
677
678 i = 0;
679
680 if (var->dynamic->child_iter == NULL)
681 return false;
682 }
683 else
684 i = var->children.size ();
685
686 /* We ask for one extra child, so that MI can report whether there
687 are more children. */
688 for (; to < 0 || i < to + 1; ++i)
689 {
690 std::unique_ptr<varobj_item> item;
691
692 /* See if there was a leftover from last time. */
693 if (var->dynamic->saved_item != NULL)
694 item = std::move (var->dynamic->saved_item);
695 else
696 item = var->dynamic->child_iter->next ();
697
698 if (item == NULL)
699 {
700 /* Iteration is done. Remove iterator from VAR. */
701 var->dynamic->child_iter.reset (nullptr);
702 break;
703 }
704 /* We don't want to push the extra child on any report list. */
705 if (to < 0 || i < to)
706 {
707 bool can_mention = from < 0 || i >= from;
708
709 install_dynamic_child (var, can_mention ? changed : NULL,
710 can_mention ? type_changed : NULL,
711 can_mention ? newobj : NULL,
712 can_mention ? unchanged : NULL,
713 can_mention ? cchanged : NULL, i,
714 item.get ());
715 }
716 else
717 {
718 var->dynamic->saved_item = std::move (item);
719
720 /* We want to truncate the child list just before this
721 element. */
722 break;
723 }
724 }
725
726 if (i < var->children.size ())
727 {
728 *cchanged = true;
729 for (int j = i; j < var->children.size (); ++j)
730 varobj_delete (var->children[j], 0);
731
732 var->children.resize (i);
733 }
734
735 /* If there are fewer children than requested, note that the list of
736 children changed. */
737 if (to >= 0 && var->children.size () < to)
738 *cchanged = true;
739
740 var->num_children = var->children.size ();
741
742 return true;
743}
744
745int
747{
748 if (var->num_children == -1)
749 {
750 if (varobj_is_dynamic_p (var))
751 {
752 bool dummy;
753
754 /* If we have a dynamic varobj, don't report -1 children.
755 So, try to fetch some children first. */
756 update_dynamic_varobj_children (var, NULL, NULL, NULL, NULL, &dummy,
757 false, 0, 0);
758 }
759 else
760 var->num_children = number_of_children (var);
761 }
762
763 return var->num_children >= 0 ? var->num_children : 0;
764}
765
766/* Creates a list of the immediate children of a variable object;
767 the return code is the number of such children or -1 on error. */
768
769const std::vector<varobj *> &
770varobj_list_children (struct varobj *var, int *from, int *to)
771{
772 var->dynamic->children_requested = true;
773
774 if (varobj_is_dynamic_p (var))
775 {
776 bool children_changed;
777
778 /* This, in theory, can result in the number of children changing without
779 frontend noticing. But well, calling -var-list-children on the same
780 varobj twice is not something a sane frontend would do. */
781 update_dynamic_varobj_children (var, NULL, NULL, NULL, NULL,
782 &children_changed, false, 0, *to);
784 return var->children;
785 }
786
787 if (var->num_children == -1)
788 var->num_children = number_of_children (var);
789
790 /* If that failed, give up. */
791 if (var->num_children == -1)
792 return var->children;
793
794 /* If we're called when the list of children is not yet initialized,
795 allocate enough elements in it. */
796 while (var->children.size () < var->num_children)
797 var->children.push_back (NULL);
798
799 for (int i = 0; i < var->num_children; i++)
800 {
801 if (var->children[i] == NULL)
802 {
803 /* Either it's the first call to varobj_list_children for
804 this variable object, and the child was never created,
805 or it was explicitly deleted by the client. */
806 std::string name = name_of_child (var, i);
807 var->children[i] = create_child (var, i, name);
808 }
809 }
810
812 return var->children;
813}
814
815static struct varobj *
816varobj_add_child (struct varobj *var, struct varobj_item *item)
817{
818 varobj *v = create_child_with_value (var, var->children.size (), item);
819
820 var->children.push_back (v);
821
822 return v;
823}
824
825/* Obtain the type of an object Variable as a string similar to the one gdb
826 prints on the console. The caller is responsible for freeing the string.
827 */
828
829std::string
831{
832 /* For the "fake" variables, do not return a type. (Its type is
833 NULL, too.)
834 Do not return a type for invalid variables as well. */
835 if (CPLUS_FAKE_CHILD (var) || !var->root->is_valid)
836 return std::string ();
837
838 return type_to_string (var->type);
839}
840
841/* Obtain the type of an object variable. */
842
843struct type *
844varobj_get_gdb_type (const struct varobj *var)
845{
846 return var->type;
847}
848
849/* Is VAR a path expression parent, i.e., can it be used to construct
850 a valid path expression? */
851
852static bool
853is_path_expr_parent (const struct varobj *var)
854{
855 gdb_assert (var->root->lang_ops->is_path_expr_parent != NULL);
856 return var->root->lang_ops->is_path_expr_parent (var);
857}
858
859/* Is VAR a path expression parent, i.e., can it be used to construct
860 a valid path expression? By default we assume any VAR can be a path
861 parent. */
862
863bool
865{
866 return true;
867}
868
869/* Return the path expression parent for VAR. */
870
871const struct varobj *
873{
874 const struct varobj *parent = var;
875
878
879 /* Computation of full rooted expression for children of dynamic
880 varobjs is not supported. */
882 error (_("Invalid variable object (child of a dynamic varobj)"));
883
884 return parent;
885}
886
887/* Return a pointer to the full rooted expression of varobj VAR.
888 If it has not been computed yet, compute it. */
889
890const char *
891varobj_get_path_expr (const struct varobj *var)
892{
893 if (var->path_expr.empty ())
894 {
895 /* For root varobjs, we initialize path_expr
896 when creating varobj, so here it should be
897 child varobj. */
898 struct varobj *mutable_var = (struct varobj *) var;
899 gdb_assert (!is_root_p (var));
900
901 mutable_var->path_expr = (*var->root->lang_ops->path_expr_of_child) (var);
902 }
903
904 return var->path_expr.c_str ();
905}
906
907const struct language_defn *
908varobj_get_language (const struct varobj *var)
909{
910 return var->root->exp->language_defn;
911}
912
913int
914varobj_get_attributes (const struct varobj *var)
915{
916 int attributes = 0;
917
918 if (varobj_editable_p (var))
919 /* FIXME: define masks for attributes. */
920 attributes |= 0x00000001; /* Editable */
921
922 return attributes;
923}
924
925/* Return true if VAR is a dynamic varobj. */
926
927bool
928varobj_is_dynamic_p (const struct varobj *var)
929{
930 return var->dynamic->pretty_printer != NULL;
931}
932
933std::string
935 enum varobj_display_formats format)
936{
937 return my_value_of_variable (var, format);
938}
939
940std::string
942{
943 return my_value_of_variable (var, var->format);
944}
945
946/* Set the value of an object variable (if it is editable) to the
947 value of the given expression. */
948/* Note: Invokes functions that can call error(). */
949
950bool
951varobj_set_value (struct varobj *var, const char *expression)
952{
953 struct value *val = NULL; /* Initialize to keep gcc happy. */
954 /* The argument "expression" contains the variable's new value.
955 We need to first construct a legal expression for this -- ugh! */
956 /* Does this cover all the bases? */
957 struct value *value = NULL; /* Initialize to keep gcc happy. */
958 const char *s = expression;
959
960 gdb_assert (varobj_editable_p (var));
961
962 /* ALWAYS reset to decimal temporarily. */
963 auto save_input_radix = make_scoped_restore (&input_radix, 10);
964 expression_up exp = parse_exp_1 (&s, 0, 0, 0);
965 try
966 {
967 value = exp->evaluate ();
968 }
969
970 catch (const gdb_exception_error &except)
971 {
972 /* We cannot proceed without a valid expression. */
973 return false;
974 }
975
976 /* All types that are editable must also be changeable. */
977 gdb_assert (varobj_value_is_changeable_p (var));
978
979 /* The value of a changeable variable object must not be lazy. */
980 gdb_assert (!var->value->lazy ());
981
982 /* Need to coerce the input. We want to check if the
983 value of the variable object will be different
984 after assignment, and the first thing value_assign
985 does is coerce the input.
986 For example, if we are assigning an array to a pointer variable we
987 should compare the pointer with the array's address, not with the
988 array's content. */
990
991 /* The new value may be lazy. value_assign, or
992 rather value_contents, will take care of this. */
993 try
994 {
995 val = value_assign (var->value.get (), value);
996 }
997
998 catch (const gdb_exception_error &except)
999 {
1000 return false;
1001 }
1002
1003 /* If the value has changed, record it, so that next -var-update can
1004 report this change. If a variable had a value of '1', we've set it
1005 to '333' and then set again to '1', when -var-update will report this
1006 variable as changed -- because the first assignment has set the
1007 'updated' flag. There's no need to optimize that, because return value
1008 of -var-update should be considered an approximation. */
1009 var->updated = install_new_value (var, val, false /* Compare values. */);
1010 return true;
1011}
1012
1013#if HAVE_PYTHON
1014
1015/* A helper function to install a constructor function and visualizer
1016 in a varobj_dynamic. */
1017
1018static void
1019install_visualizer (struct varobj_dynamic *var, PyObject *constructor,
1020 PyObject *visualizer)
1021{
1022 Py_XDECREF (var->constructor);
1023 var->constructor = constructor;
1024
1025 Py_XDECREF (var->pretty_printer);
1026 var->pretty_printer = visualizer;
1027
1028 var->child_iter.reset (nullptr);
1029}
1030
1031/* Install the default visualizer for VAR. */
1032
1033static void
1034install_default_visualizer (struct varobj *var)
1035{
1036 /* Do not install a visualizer on a CPLUS_FAKE_CHILD. */
1037 if (CPLUS_FAKE_CHILD (var))
1038 return;
1039
1040 if (pretty_printing)
1041 {
1042 gdbpy_ref<> pretty_printer;
1043
1044 if (var->value != nullptr)
1045 {
1046 pretty_printer = gdbpy_get_varobj_pretty_printer (var->value.get ());
1047 if (pretty_printer == nullptr)
1048 {
1050 error (_("Cannot instantiate printer for default visualizer"));
1051 }
1052 }
1053
1054 if (pretty_printer == Py_None)
1055 pretty_printer.reset (nullptr);
1056
1057 install_visualizer (var->dynamic, NULL, pretty_printer.release ());
1058 }
1059}
1060
1061/* Instantiate and install a visualizer for VAR using CONSTRUCTOR to
1062 make a new object. */
1063
1064static void
1065construct_visualizer (struct varobj *var, PyObject *constructor)
1066{
1067 PyObject *pretty_printer;
1068
1069 /* Do not install a visualizer on a CPLUS_FAKE_CHILD. */
1070 if (CPLUS_FAKE_CHILD (var))
1071 return;
1072
1073 Py_INCREF (constructor);
1074 if (constructor == Py_None)
1075 pretty_printer = NULL;
1076 else
1077 {
1078 pretty_printer = instantiate_pretty_printer (constructor,
1079 var->value.get ());
1080 if (! pretty_printer)
1081 {
1083 Py_DECREF (constructor);
1084 constructor = Py_None;
1085 Py_INCREF (constructor);
1086 }
1087
1088 if (pretty_printer == Py_None)
1089 {
1090 Py_DECREF (pretty_printer);
1091 pretty_printer = NULL;
1092 }
1093 }
1094
1095 install_visualizer (var->dynamic, constructor, pretty_printer);
1096}
1097
1098#endif /* HAVE_PYTHON */
1099
1100/* A helper function for install_new_value. This creates and installs
1101 a visualizer for VAR, if appropriate. */
1102
1103static void
1105{
1106#if HAVE_PYTHON
1107 /* If the constructor is None, then we want the raw value. If VAR
1108 does not have a value, just skip this. */
1110 return;
1111
1112 if (var->dynamic->constructor != Py_None && var->value != NULL)
1113 {
1114 gdbpy_enter_varobj enter_py (var);
1115
1116 if (var->dynamic->constructor == NULL)
1117 install_default_visualizer (var);
1118 else
1119 construct_visualizer (var, var->dynamic->constructor);
1120 }
1121#else
1122 /* Do nothing. */
1123#endif
1124}
1125
1126/* When using RTTI to determine variable type it may be changed in runtime when
1127 the variable value is changed. This function checks whether type of varobj
1128 VAR will change when a new value NEW_VALUE is assigned and if it is so
1129 updates the type of VAR. */
1130
1131static bool
1132update_type_if_necessary (struct varobj *var, struct value *new_value)
1133{
1134 if (new_value)
1135 {
1136 struct value_print_options opts;
1137
1138 get_user_print_options (&opts);
1139 if (opts.objectprint)
1140 {
1141 struct type *new_type = value_actual_type (new_value, 0, 0);
1142 std::string new_type_str = type_to_string (new_type);
1143 std::string curr_type_str = varobj_get_type (var);
1144
1145 /* Did the type name change? */
1146 if (curr_type_str != new_type_str)
1147 {
1148 var->type = new_type;
1149
1150 /* This information may be not valid for a new type. */
1151 varobj_delete (var, 1);
1152 var->children.clear ();
1153 var->num_children = -1;
1154 return true;
1155 }
1156 }
1157 }
1158
1159 return false;
1160}
1161
1162/* Assign a new value to a variable object. If INITIAL is true,
1163 this is the first assignment after the variable object was just
1164 created, or changed type. In that case, just assign the value
1165 and return false.
1166 Otherwise, assign the new value, and return true if the value is
1167 different from the current one, false otherwise. The comparison is
1168 done on textual representation of value. Therefore, some types
1169 need not be compared. E.g. for structures the reported value is
1170 always "{...}", so no comparison is necessary here. If the old
1171 value was NULL and new one is not, or vice versa, we always return true.
1172
1173 The VALUE parameter should not be released -- the function will
1174 take care of releasing it when needed. */
1175static bool
1176install_new_value (struct varobj *var, struct value *value, bool initial)
1177{
1178 bool changeable;
1179 bool need_to_fetch;
1180 bool changed = false;
1181 bool intentionally_not_fetched = false;
1182
1183 /* We need to know the varobj's type to decide if the value should
1184 be fetched or not. C++ fake children (public/protected/private)
1185 don't have a type. */
1186 gdb_assert (var->type || CPLUS_FAKE_CHILD (var));
1187 changeable = varobj_value_is_changeable_p (var);
1188
1189 /* If the type has custom visualizer, we consider it to be always
1190 changeable. FIXME: need to make sure this behaviour will not
1191 mess up read-sensitive values. */
1192 if (var->dynamic->pretty_printer != NULL)
1193 changeable = true;
1194
1195 need_to_fetch = changeable;
1196
1197 /* We are not interested in the address of references, and given
1198 that in C++ a reference is not rebindable, it cannot
1199 meaningfully change. So, get hold of the real value. */
1200 if (value)
1202
1203 if (var->type && var->type->code () == TYPE_CODE_UNION)
1204 /* For unions, we need to fetch the value implicitly because
1205 of implementation of union member fetch. When gdb
1206 creates a value for a field and the value of the enclosing
1207 structure is not lazy, it immediately copies the necessary
1208 bytes from the enclosing values. If the enclosing value is
1209 lazy, the call to value_fetch_lazy on the field will read
1210 the data from memory. For unions, that means we'll read the
1211 same memory more than once, which is not desirable. So
1212 fetch now. */
1213 need_to_fetch = true;
1214
1215 /* The new value might be lazy. If the type is changeable,
1216 that is we'll be comparing values of this type, fetch the
1217 value now. Otherwise, on the next update the old value
1218 will be lazy, which means we've lost that old value. */
1219 if (need_to_fetch && value && value->lazy ())
1220 {
1221 const struct varobj *parent = var->parent;
1222 bool frozen = var->frozen;
1223
1224 for (; !frozen && parent; parent = parent->parent)
1225 frozen |= parent->frozen;
1226
1227 if (frozen && initial)
1228 {
1229 /* For variables that are frozen, or are children of frozen
1230 variables, we don't do fetch on initial assignment.
1231 For non-initial assignment we do the fetch, since it means we're
1232 explicitly asked to compare the new value with the old one. */
1233 intentionally_not_fetched = true;
1234 }
1235 else
1236 {
1237
1238 try
1239 {
1240 value->fetch_lazy ();
1241 }
1242
1243 catch (const gdb_exception_error &except)
1244 {
1245 /* Set the value to NULL, so that for the next -var-update,
1246 we don't try to compare the new value with this value,
1247 that we couldn't even read. */
1248 value = NULL;
1249 }
1250 }
1251 }
1252
1253 /* Get a reference now, before possibly passing it to any Python
1254 code that might release it. */
1255 value_ref_ptr value_holder;
1256 if (value != NULL)
1257 value_holder = value_ref_ptr::new_reference (value);
1258
1259 /* Below, we'll be comparing string rendering of old and new
1260 values. Don't get string rendering if the value is
1261 lazy -- if it is, the code above has decided that the value
1262 should not be fetched. */
1263 std::string print_value;
1264 if (value != NULL && !value->lazy ()
1265 && var->dynamic->pretty_printer == NULL)
1267
1268 /* If the type is changeable, compare the old and the new values.
1269 If this is the initial assignment, we don't have any old value
1270 to compare with. */
1271 if (!initial && changeable)
1272 {
1273 /* If the value of the varobj was changed by -var-set-value,
1274 then the value in the varobj and in the target is the same.
1275 However, that value is different from the value that the
1276 varobj had after the previous -var-update. So need to the
1277 varobj as changed. */
1278 if (var->updated)
1279 changed = true;
1280 else if (var->dynamic->pretty_printer == NULL)
1281 {
1282 /* Try to compare the values. That requires that both
1283 values are non-lazy. */
1284 if (var->not_fetched && var->value->lazy ())
1285 {
1286 /* This is a frozen varobj and the value was never read.
1287 Presumably, UI shows some "never read" indicator.
1288 Now that we've fetched the real value, we need to report
1289 this varobj as changed so that UI can show the real
1290 value. */
1291 changed = true;
1292 }
1293 else if (var->value == NULL && value == NULL)
1294 /* Equal. */
1295 ;
1296 else if (var->value == NULL || value == NULL)
1297 {
1298 changed = true;
1299 }
1300 else
1301 {
1302 gdb_assert (!var->value->lazy ());
1303 gdb_assert (!value->lazy ());
1304
1305 gdb_assert (!var->print_value.empty () && !print_value.empty ());
1306 if (var->print_value != print_value)
1307 changed = true;
1308 }
1309 }
1310 }
1311
1312 if (!initial && !changeable)
1313 {
1314 /* For values that are not changeable, we don't compare the values.
1315 However, we want to notice if a value was not NULL and now is NULL,
1316 or vise versa, so that we report when top-level varobjs come in scope
1317 and leave the scope. */
1318 changed = (var->value != NULL) != (value != NULL);
1319 }
1320
1321 /* We must always keep the new value, since children depend on it. */
1322 var->value = value_holder;
1323 if (value && value->lazy () && intentionally_not_fetched)
1324 var->not_fetched = true;
1325 else
1326 var->not_fetched = false;
1327 var->updated = false;
1328
1330
1331 /* If we installed a pretty-printer, re-compare the printed version
1332 to see if the variable changed. */
1333 if (var->dynamic->pretty_printer != NULL)
1334 {
1336 var->format, var);
1337 if (var->print_value != print_value)
1338 changed = true;
1339 }
1340 var->print_value = print_value;
1341
1342 gdb_assert (var->value == nullptr || var->value->type ());
1343
1344 return changed;
1345}
1346
1347/* Return the requested range for a varobj. VAR is the varobj. FROM
1348 and TO are out parameters; *FROM and *TO will be set to the
1349 selected sub-range of VAR. If no range was selected using
1350 -var-set-update-range, then both will be -1. */
1351void
1352varobj_get_child_range (const struct varobj *var, int *from, int *to)
1353{
1354 *from = var->from;
1355 *to = var->to;
1356}
1357
1358/* Set the selected sub-range of children of VAR to start at index
1359 FROM and end at index TO. If either FROM or TO is less than zero,
1360 this is interpreted as a request for all children. */
1361void
1362varobj_set_child_range (struct varobj *var, int from, int to)
1363{
1364 var->from = from;
1365 var->to = to;
1366}
1367
1368void
1369varobj_set_visualizer (struct varobj *var, const char *visualizer)
1370{
1371#if HAVE_PYTHON
1372 PyObject *mainmod;
1373
1375 return;
1376
1377 gdbpy_enter_varobj enter_py (var);
1378
1379 mainmod = PyImport_AddModule ("__main__");
1380 gdbpy_ref<> globals
1381 = gdbpy_ref<>::new_reference (PyModule_GetDict (mainmod));
1382 gdbpy_ref<> constructor (PyRun_String (visualizer, Py_eval_input,
1383 globals.get (), globals.get ()));
1384
1385 if (constructor == NULL)
1386 {
1388 error (_("Could not evaluate visualizer expression: %s"), visualizer);
1389 }
1390
1391 construct_visualizer (var, constructor.get ());
1392
1393 /* If there are any children now, wipe them. */
1394 varobj_delete (var, 1 /* children only */);
1395 var->num_children = -1;
1396
1397 /* Also be sure to reset the print value. */
1399#else
1400 error (_("Python support required"));
1401#endif
1402}
1403
1404/* If NEW_VALUE is the new value of the given varobj (var), return
1405 true if var has mutated. In other words, if the type of
1406 the new value is different from the type of the varobj's old
1407 value.
1408
1409 NEW_VALUE may be NULL, if the varobj is now out of scope. */
1410
1411static bool
1412varobj_value_has_mutated (const struct varobj *var, struct value *new_value,
1413 struct type *new_type)
1414{
1415 /* If we haven't previously computed the number of children in var,
1416 it does not matter from the front-end's perspective whether
1417 the type has mutated or not. For all intents and purposes,
1418 it has not mutated. */
1419 if (var->num_children < 0)
1420 return false;
1421
1422 if (var->root->lang_ops->value_has_mutated != NULL)
1423 {
1424 /* The varobj module, when installing new values, explicitly strips
1425 references, saying that we're not interested in those addresses.
1426 But detection of mutation happens before installing the new
1427 value, so our value may be a reference that we need to strip
1428 in order to remain consistent. */
1429 if (new_value != NULL)
1430 new_value = coerce_ref (new_value);
1431 return var->root->lang_ops->value_has_mutated (var, new_value, new_type);
1432 }
1433 else
1434 return false;
1435}
1436
1437/* Update the values for a variable and its children. This is a
1438 two-pronged attack. First, re-parse the value for the root's
1439 expression to see if it's changed. Then go all the way
1440 through its children, reconstructing them and noting if they've
1441 changed.
1442
1443 The IS_EXPLICIT parameter specifies if this call is result
1444 of MI request to update this specific variable, or
1445 result of implicit -var-update *. For implicit request, we don't
1446 update frozen variables.
1447
1448 NOTE: This function may delete the caller's varobj. If it
1449 returns TYPE_CHANGED, then it has done this and VARP will be modified
1450 to point to the new varobj. */
1451
1452std::vector<varobj_update_result>
1453varobj_update (struct varobj **varp, bool is_explicit)
1454{
1455 bool type_changed = false;
1456 struct value *newobj;
1457 std::vector<varobj_update_result> stack;
1458 std::vector<varobj_update_result> result;
1459
1460 /* Frozen means frozen -- we don't check for any change in
1461 this varobj, including its going out of scope, or
1462 changing type. One use case for frozen varobjs is
1463 retaining previously evaluated expressions, and we don't
1464 want them to be reevaluated at all. */
1465 if (!is_explicit && (*varp)->frozen)
1466 return result;
1467
1468 if (!(*varp)->root->is_valid)
1469 {
1470 result.emplace_back (*varp, VAROBJ_INVALID);
1471 return result;
1472 }
1473
1474 if ((*varp)->root->rootvar == *varp)
1475 {
1476 varobj_update_result r (*varp);
1477
1478 /* Update the root variable. value_of_root can return NULL
1479 if the variable is no longer around, i.e. we stepped out of
1480 the frame in which a local existed. We are letting the
1481 value_of_root variable dispose of the varobj if the type
1482 has changed. */
1483 newobj = value_of_root (varp, &type_changed);
1484 if (update_type_if_necessary (*varp, newobj))
1485 type_changed = true;
1486 r.varobj = *varp;
1487 r.type_changed = type_changed;
1488 if (install_new_value ((*varp), newobj, type_changed))
1489 r.changed = true;
1490
1491 if (newobj == NULL)
1493 r.value_installed = true;
1494
1495 if (r.status == VAROBJ_NOT_IN_SCOPE)
1496 {
1497 if (r.type_changed || r.changed)
1498 result.push_back (std::move (r));
1499
1500 return result;
1501 }
1502
1503 stack.push_back (std::move (r));
1504 }
1505 else
1506 stack.emplace_back (*varp);
1507
1508 /* Walk through the children, reconstructing them all. */
1509 while (!stack.empty ())
1510 {
1511 varobj_update_result r = std::move (stack.back ());
1512 stack.pop_back ();
1513 struct varobj *v = r.varobj;
1514
1515 /* Update this variable, unless it's a root, which is already
1516 updated. */
1517 if (!r.value_installed)
1518 {
1519 struct type *new_type;
1520
1521 newobj = value_of_child (v->parent, v->index);
1522 if (update_type_if_necessary (v, newobj))
1523 r.type_changed = true;
1524 if (newobj)
1525 new_type = newobj->type ();
1526 else
1528
1529 if (varobj_value_has_mutated (v, newobj, new_type))
1530 {
1531 /* The children are no longer valid; delete them now.
1532 Report the fact that its type changed as well. */
1533 varobj_delete (v, 1 /* only_children */);
1534 v->num_children = -1;
1535 v->to = -1;
1536 v->from = -1;
1537 v->type = new_type;
1538 r.type_changed = true;
1539 }
1540
1541 if (install_new_value (v, newobj, r.type_changed))
1542 {
1543 r.changed = true;
1544 v->updated = false;
1545 }
1546 }
1547
1548 /* We probably should not get children of a dynamic varobj, but
1549 for which -var-list-children was never invoked. */
1550 if (varobj_is_dynamic_p (v))
1551 {
1552 std::vector<varobj *> changed, type_changed_vec, unchanged, newobj_vec;
1553 bool children_changed = false;
1554
1555 if (v->frozen)
1556 continue;
1557
1558 if (!v->dynamic->children_requested)
1559 {
1560 bool dummy;
1561
1562 /* If we initially did not have potential children, but
1563 now we do, consider the varobj as changed.
1564 Otherwise, if children were never requested, consider
1565 it as unchanged -- presumably, such varobj is not yet
1566 expanded in the UI, so we need not bother getting
1567 it. */
1568 if (!varobj_has_more (v, 0))
1569 {
1570 update_dynamic_varobj_children (v, NULL, NULL, NULL, NULL,
1571 &dummy, false, 0, 0);
1572 if (varobj_has_more (v, 0))
1573 r.changed = true;
1574 }
1575
1576 if (r.changed)
1577 result.push_back (std::move (r));
1578
1579 continue;
1580 }
1581
1582 /* If update_dynamic_varobj_children returns false, then we have
1583 a non-conforming pretty-printer, so we skip it. */
1584 if (update_dynamic_varobj_children (v, &changed, &type_changed_vec,
1585 &newobj_vec,
1586 &unchanged, &children_changed,
1587 true, v->from, v->to))
1588 {
1589 if (children_changed || !newobj_vec.empty ())
1590 {
1591 r.children_changed = true;
1592 r.newobj = std::move (newobj_vec);
1593 }
1594 /* Push in reverse order so that the first child is
1595 popped from the work stack first, and so will be
1596 added to result first. This does not affect
1597 correctness, just "nicer". */
1598 for (int i = type_changed_vec.size () - 1; i >= 0; --i)
1599 {
1600 varobj_update_result item (type_changed_vec[i]);
1601
1602 /* Type may change only if value was changed. */
1603 item.changed = true;
1604 item.type_changed = true;
1605 item.value_installed = true;
1606
1607 stack.push_back (std::move (item));
1608 }
1609 for (int i = changed.size () - 1; i >= 0; --i)
1610 {
1611 varobj_update_result item (changed[i]);
1612
1613 item.changed = true;
1614 item.value_installed = true;
1615
1616 stack.push_back (std::move (item));
1617 }
1618 for (int i = unchanged.size () - 1; i >= 0; --i)
1619 {
1620 if (!unchanged[i]->frozen)
1621 {
1622 varobj_update_result item (unchanged[i]);
1623
1624 item.value_installed = true;
1625
1626 stack.push_back (std::move (item));
1627 }
1628 }
1629 if (r.changed || r.children_changed)
1630 result.push_back (std::move (r));
1631
1632 continue;
1633 }
1634 }
1635
1636 /* Push any children. Use reverse order so that the first
1637 child is popped from the work stack first, and so
1638 will be added to result first. This does not
1639 affect correctness, just "nicer". */
1640 for (int i = v->children.size () - 1; i >= 0; --i)
1641 {
1642 varobj *c = v->children[i];
1643
1644 /* Child may be NULL if explicitly deleted by -var-delete. */
1645 if (c != NULL && !c->frozen)
1646 stack.emplace_back (c);
1647 }
1648
1649 if (r.changed || r.type_changed)
1650 result.push_back (std::move (r));
1651 }
1652
1653 return result;
1654}
1655
1656/* Helper functions */
1657
1658/*
1659 * Variable object construction/destruction
1660 */
1661
1662static int
1663delete_variable (struct varobj *var, bool only_children_p)
1664{
1665 int delcount = 0;
1666
1667 delete_variable_1 (&delcount, var, only_children_p,
1668 true /* remove_from_parent_p */ );
1669
1670 return delcount;
1671}
1672
1673/* Delete the variable object VAR and its children. */
1674/* IMPORTANT NOTE: If we delete a variable which is a child
1675 and the parent is not removed we dump core. It must be always
1676 initially called with remove_from_parent_p set. */
1677static void
1678delete_variable_1 (int *delcountp, struct varobj *var, bool only_children_p,
1679 bool remove_from_parent_p)
1680{
1681 /* Delete any children of this variable, too. */
1682 for (varobj *child : var->children)
1683 {
1684 if (!child)
1685 continue;
1686
1687 if (!remove_from_parent_p)
1688 child->parent = NULL;
1689
1690 delete_variable_1 (delcountp, child, false, only_children_p);
1691 }
1692 var->children.clear ();
1693
1694 /* if we were called to delete only the children we are done here. */
1695 if (only_children_p)
1696 return;
1697
1698 /* Otherwise, add it to the list of deleted ones and proceed to do so. */
1699 /* If the name is empty, this is a temporary variable, that has not
1700 yet been installed, don't report it, it belongs to the caller... */
1701 if (!var->obj_name.empty ())
1702 {
1703 *delcountp = *delcountp + 1;
1704 }
1705
1706 /* If this variable has a parent, remove it from its parent's list. */
1707 /* OPTIMIZATION: if the parent of this variable is also being deleted,
1708 (as indicated by remove_from_parent_p) we don't bother doing an
1709 expensive list search to find the element to remove when we are
1710 discarding the list afterwards. */
1711 if ((remove_from_parent_p) && (var->parent != NULL))
1712 var->parent->children[var->index] = NULL;
1713
1714 if (!var->obj_name.empty ())
1715 uninstall_variable (var);
1716
1717 /* Free memory associated with this variable. */
1718 delete var;
1719}
1720
1721/* Install the given variable VAR with the object name VAR->OBJ_NAME. */
1722static void
1724{
1725 hashval_t hash = htab_hash_string (var->obj_name.c_str ());
1726 void **slot = htab_find_slot_with_hash (varobj_table,
1727 var->obj_name.c_str (),
1728 hash, INSERT);
1729 if (*slot != nullptr)
1730 error (_("Duplicate variable object name"));
1731
1732 /* Add varobj to hash table. */
1733 *slot = var;
1734
1735 /* If root, add varobj to root list. */
1736 if (is_root_p (var))
1737 rootlist.push_front (var->root);
1738}
1739
1740/* Uninstall the object VAR. */
1741static void
1743{
1744 hashval_t hash = htab_hash_string (var->obj_name.c_str ());
1745 htab_remove_elt_with_hash (varobj_table, var->obj_name.c_str (), hash);
1746
1747 if (varobjdebug)
1748 gdb_printf (gdb_stdlog, "Deleting %s\n", var->obj_name.c_str ());
1749
1750 /* If root, remove varobj from root list. */
1751 if (is_root_p (var))
1752 {
1753 auto iter = std::find (rootlist.begin (), rootlist.end (), var->root);
1754 rootlist.erase (iter);
1755 }
1756}
1757
1758/* Create and install a child of the parent of the given name.
1759
1760 The created VAROBJ takes ownership of the allocated NAME. */
1761
1762static struct varobj *
1763create_child (struct varobj *parent, int index, std::string &name)
1764{
1765 struct varobj_item item;
1766
1767 std::swap (item.name, name);
1768 item.value = release_value (value_of_child (parent, index));
1769
1770 return create_child_with_value (parent, index, &item);
1771}
1772
1773static struct varobj *
1775 struct varobj_item *item)
1776{
1777 varobj *child = new varobj (parent->root);
1778
1779 /* NAME is allocated by caller. */
1780 std::swap (child->name, item->name);
1781 child->index = index;
1782 child->parent = parent;
1783
1784 if (varobj_is_anonymous_child (child))
1785 child->obj_name = string_printf ("%s.%d_anonymous",
1786 parent->obj_name.c_str (), index);
1787 else
1788 child->obj_name = string_printf ("%s.%s",
1789 parent->obj_name.c_str (),
1790 child->name.c_str ());
1791
1792 install_variable (child);
1793
1794 /* Compute the type of the child. Must do this before
1795 calling install_new_value. */
1796 if (item->value != NULL)
1797 /* If the child had no evaluation errors, var->value
1798 will be non-NULL and contain a valid type. */
1799 child->type = value_actual_type (item->value.get (), 0, NULL);
1800 else
1801 /* Otherwise, we must compute the type. */
1802 child->type = (*child->root->lang_ops->type_of_child) (child->parent,
1803 child->index);
1804 install_new_value (child, item->value.get (), 1);
1805
1806 return child;
1807}
1808
1809
1810/*
1811 * Miscellaneous utility functions.
1812 */
1813
1814/* Allocate memory and initialize a new variable. */
1816: root (root_), dynamic (new varobj_dynamic)
1817{
1818}
1819
1820/* Free any allocated memory associated with VAR. */
1821
1823{
1824 varobj *var = this;
1825
1826#if HAVE_PYTHON
1827 if (var->dynamic->pretty_printer != NULL)
1828 {
1829 gdbpy_enter_varobj enter_py (var);
1830
1831 Py_XDECREF (var->dynamic->constructor);
1832 Py_XDECREF (var->dynamic->pretty_printer);
1833 }
1834#endif
1835
1836 /* This must be deleted before the root object, because Python-based
1837 destructors need access to some components. */
1838 delete var->dynamic;
1839
1840 if (is_root_p (var))
1841 delete var->root;
1842}
1843
1844/* Return the type of the value that's stored in VAR,
1845 or that would have being stored there if the
1846 value were accessible.
1847
1848 This differs from VAR->type in that VAR->type is always
1849 the true type of the expression in the source language.
1850 The return value of this function is the type we're
1851 actually storing in varobj, and using for displaying
1852 the values and for comparing previous and new values.
1853
1854 For example, top-level references are always stripped. */
1855struct type *
1857{
1858 struct type *type;
1859
1860 if (var->value != nullptr)
1861 type = var->value->type ();
1862 else
1863 type = var->type;
1864
1866
1867 if (TYPE_IS_REFERENCE (type))
1869
1871
1872 return type;
1873}
1874
1875/*
1876 * Language-dependencies
1877 */
1878
1879/* Common entry points */
1880
1881/* Return the number of children for a given variable.
1882 The result of this function is defined by the language
1883 implementation. The number of children returned by this function
1884 is the number of children that the user will see in the variable
1885 display. */
1886static int
1887number_of_children (const struct varobj *var)
1888{
1889 return (*var->root->lang_ops->number_of_children) (var);
1890}
1891
1892/* What is the expression for the root varobj VAR? */
1893
1894static std::string
1895name_of_variable (const struct varobj *var)
1896{
1897 return (*var->root->lang_ops->name_of_variable) (var);
1898}
1899
1900/* What is the name of the INDEX'th child of VAR? */
1901
1902static std::string
1903name_of_child (struct varobj *var, int index)
1904{
1905 return (*var->root->lang_ops->name_of_child) (var, index);
1906}
1907
1908/* If frame associated with VAR can be found, switch
1909 to it and return true. Otherwise, return false. */
1910
1911static bool
1912check_scope (const struct varobj *var)
1913{
1914 frame_info_ptr fi;
1915 bool scope;
1916
1917 fi = frame_find_by_id (var->root->frame);
1918 scope = fi != NULL;
1919
1920 if (fi)
1921 {
1922 CORE_ADDR pc = get_frame_pc (fi);
1923
1924 if (pc < var->root->valid_block->start () ||
1925 pc >= var->root->valid_block->end ())
1926 scope = false;
1927 else
1928 select_frame (fi);
1929 }
1930 return scope;
1931}
1932
1933/* Helper function to value_of_root. */
1934
1935static struct value *
1936value_of_root_1 (struct varobj **var_handle)
1937{
1938 struct value *new_val = NULL;
1939 struct varobj *var = *var_handle;
1940 bool within_scope = false;
1941
1942 /* Only root variables can be updated... */
1943 if (!is_root_p (var))
1944 /* Not a root var. */
1945 return NULL;
1946
1947 scoped_restore_current_thread restore_thread;
1948
1949 /* Determine whether the variable is still around. */
1950 if (var->root->valid_block == NULL || var->root->floating)
1951 within_scope = true;
1952 else if (var->root->thread_id == 0)
1953 {
1954 /* The program was single-threaded when the variable object was
1955 created. Technically, it's possible that the program became
1956 multi-threaded since then, but we don't support such
1957 scenario yet. */
1958 within_scope = check_scope (var);
1959 }
1960 else
1961 {
1963
1964 if (thread != NULL)
1965 {
1966 switch_to_thread (thread);
1967 within_scope = check_scope (var);
1968 }
1969 }
1970
1971 if (within_scope)
1972 {
1973
1974 /* We need to catch errors here, because if evaluate
1975 expression fails we want to just return NULL. */
1976 try
1977 {
1978 new_val = var->root->exp->evaluate ();
1979 }
1980 catch (const gdb_exception_error &except)
1981 {
1982 }
1983 }
1984
1985 return new_val;
1986}
1987
1988/* What is the ``struct value *'' of the root variable VAR?
1989 For floating variable object, evaluation can get us a value
1990 of different type from what is stored in varobj already. In
1991 that case:
1992 - *type_changed will be set to 1
1993 - old varobj will be freed, and new one will be
1994 created, with the same name.
1995 - *var_handle will be set to the new varobj
1996 Otherwise, *type_changed will be set to 0. */
1997static struct value *
1998value_of_root (struct varobj **var_handle, bool *type_changed)
1999{
2000 struct varobj *var;
2001
2002 if (var_handle == NULL)
2003 return NULL;
2004
2005 var = *var_handle;
2006
2007 /* This should really be an exception, since this should
2008 only get called with a root variable. */
2009
2010 if (!is_root_p (var))
2011 return NULL;
2012
2013 if (var->root->floating)
2014 {
2015 struct varobj *tmp_var;
2016
2017 tmp_var = varobj_create (NULL, var->name.c_str (), (CORE_ADDR) 0,
2019 if (tmp_var == NULL)
2020 {
2021 return NULL;
2022 }
2023 std::string old_type = varobj_get_type (var);
2024 std::string new_type = varobj_get_type (tmp_var);
2025 if (old_type == new_type)
2026 {
2027 /* The expression presently stored inside var->root->exp
2028 remembers the locations of local variables relatively to
2029 the frame where the expression was created (in DWARF location
2030 button, for example). Naturally, those locations are not
2031 correct in other frames, so update the expression. */
2032
2033 std::swap (var->root->exp, tmp_var->root->exp);
2034
2035 varobj_delete (tmp_var, 0);
2036 *type_changed = 0;
2037 }
2038 else
2039 {
2040 tmp_var->obj_name = var->obj_name;
2041 tmp_var->from = var->from;
2042 tmp_var->to = var->to;
2043 varobj_delete (var, 0);
2044
2045 install_variable (tmp_var);
2046 *var_handle = tmp_var;
2047 var = *var_handle;
2048 *type_changed = true;
2049 }
2050 }
2051 else
2052 {
2053 *type_changed = 0;
2054 }
2055
2056 {
2057 struct value *value;
2058
2059 value = value_of_root_1 (var_handle);
2060 if (var->value == NULL || value == NULL)
2061 {
2062 /* For root varobj-s, a NULL value indicates a scoping issue.
2063 So, nothing to do in terms of checking for mutations. */
2064 }
2065 else if (varobj_value_has_mutated (var, value, value->type ()))
2066 {
2067 /* The type has mutated, so the children are no longer valid.
2068 Just delete them, and tell our caller that the type has
2069 changed. */
2070 varobj_delete (var, 1 /* only_children */);
2071 var->num_children = -1;
2072 var->to = -1;
2073 var->from = -1;
2074 *type_changed = true;
2075 }
2076 return value;
2077 }
2078}
2079
2080/* What is the ``struct value *'' for the INDEX'th child of PARENT? */
2081static struct value *
2082value_of_child (const struct varobj *parent, int index)
2083{
2084 struct value *value;
2085
2086 value = (*parent->root->lang_ops->value_of_child) (parent, index);
2087
2088 return value;
2089}
2090
2091/* GDB already has a command called "value_of_variable". Sigh. */
2092static std::string
2094{
2095 if (var->root->is_valid)
2096 {
2097 if (var->dynamic->pretty_printer != NULL)
2098 return varobj_value_get_print_value (var->value.get (), var->format,
2099 var);
2100 else if (var->parent != nullptr && varobj_is_dynamic_p (var->parent))
2101 return var->print_value;
2102
2103 return (*var->root->lang_ops->value_of_variable) (var, format);
2104 }
2105 else
2106 return std::string ();
2107}
2108
2109void
2111 enum varobj_display_formats format)
2112{
2113 get_formatted_print_options (opts, format_code[(int) format]);
2114 opts->deref_ref = false;
2115 opts->raw = !pretty_printing;
2116}
2117
2118std::string
2120 enum varobj_display_formats format,
2121 const struct varobj *var)
2122{
2123 struct value_print_options opts;
2124 struct type *type = NULL;
2125 long len = 0;
2126 gdb::unique_xmalloc_ptr<char> encoding;
2127 /* Initialize it just to avoid a GCC false warning. */
2128 CORE_ADDR str_addr = 0;
2129 bool string_print = false;
2130
2131 if (value == NULL)
2132 return std::string ();
2133
2134 string_file stb;
2135 std::string thevalue;
2136
2137 varobj_formatted_print_options (&opts, format);
2138
2139#if HAVE_PYTHON
2141 {
2142 PyObject *value_formatter = var->dynamic->pretty_printer;
2143
2144 gdbpy_enter_varobj enter_py (var);
2145
2146 if (value_formatter)
2147 {
2148 if (PyObject_HasAttr (value_formatter, gdbpy_to_string_cst))
2149 {
2150 struct value *replacement;
2151
2152 gdbpy_ref<> output = apply_varobj_pretty_printer (value_formatter,
2153 &replacement,
2154 &stb,
2155 &opts);
2156
2157 /* If we have string like output ... */
2158 if (output != nullptr && output != Py_None)
2159 {
2160 /* If this is a lazy string, extract it. For lazy
2161 strings we always print as a string, so set
2162 string_print. */
2163 if (gdbpy_is_lazy_string (output.get ()))
2164 {
2165 gdbpy_extract_lazy_string (output.get (), &str_addr,
2166 &type, &len, &encoding);
2167 string_print = true;
2168 }
2169 else
2170 {
2171 /* If it is a regular (non-lazy) string, extract
2172 it and copy the contents into THEVALUE. If the
2173 hint says to print it as a string, set
2174 string_print. Otherwise just return the extracted
2175 string as a value. */
2176
2177 gdb::unique_xmalloc_ptr<char> s
2178 = python_string_to_target_string (output.get ());
2179
2180 if (s)
2181 {
2182 struct gdbarch *gdbarch;
2183
2184 gdb::unique_xmalloc_ptr<char> hint
2185 = gdbpy_get_display_hint (value_formatter);
2186 if (hint)
2187 {
2188 if (!strcmp (hint.get (), "string"))
2189 string_print = true;
2190 }
2191
2192 thevalue = std::string (s.get ());
2193 len = thevalue.size ();
2194 gdbarch = value->type ()->arch ();
2196
2197 if (!string_print)
2198 return thevalue;
2199 }
2200 else
2202 }
2203 }
2204 /* If the printer returned a replacement value, set VALUE
2205 to REPLACEMENT. If there is not a replacement value,
2206 just use the value passed to this function. */
2207 if (replacement)
2208 value = replacement;
2209 }
2210 else
2211 {
2212 /* No to_string method, so if there is a 'children'
2213 method, return the default. */
2214 if (PyObject_HasAttr (value_formatter, gdbpy_children_cst))
2215 return "{...}";
2216 }
2217 }
2218 else
2219 {
2220 /* If we've made it here, we don't want a pretty-printer --
2221 if we had one, it would already have been used. */
2222 opts.raw = true;
2223 }
2224 }
2225#endif
2226
2227 /* If the THEVALUE has contents, it is a regular string. */
2228 if (!thevalue.empty ())
2229 current_language->printstr (&stb, type, (gdb_byte *) thevalue.c_str (),
2230 len, encoding.get (), 0, &opts);
2231 else if (string_print)
2232 /* Otherwise, if string_print is set, and it is not a regular
2233 string, it is a lazy string. */
2234 val_print_string (type, encoding.get (), str_addr, len, &stb, &opts);
2235 else
2236 /* All other cases. */
2237 common_val_print (value, &stb, 0, &opts, current_language);
2238
2239 return stb.release ();
2240}
2241
2242bool
2243varobj_editable_p (const struct varobj *var)
2244{
2245 struct type *type;
2246
2247 if (!(var->root->is_valid && var->value != nullptr
2248 && var->value->lval ()))
2249 return false;
2250
2252
2253 switch (type->code ())
2254 {
2255 case TYPE_CODE_STRUCT:
2256 case TYPE_CODE_UNION:
2257 case TYPE_CODE_ARRAY:
2258 case TYPE_CODE_FUNC:
2259 case TYPE_CODE_METHOD:
2260 return false;
2261 break;
2262
2263 default:
2264 return true;
2265 break;
2266 }
2267}
2268
2269/* Call VAR's value_is_changeable_p language-specific callback. */
2270
2271bool
2273{
2274 return var->root->lang_ops->value_is_changeable_p (var);
2275}
2276
2277/* Return true if that varobj is floating, that is is always evaluated in the
2278 selected frame, and not bound to thread/frame. Such variable objects
2279 are created using '@' as frame specifier to -var-create. */
2280bool
2281varobj_floating_p (const struct varobj *var)
2282{
2283 return var->root->floating;
2284}
2285
2286/* Implement the "value_is_changeable_p" varobj callback for most
2287 languages. */
2288
2289bool
2291{
2292 bool r;
2293 struct type *type;
2294
2295 if (CPLUS_FAKE_CHILD (var))
2296 return false;
2297
2299
2300 switch (type->code ())
2301 {
2302 case TYPE_CODE_STRUCT:
2303 case TYPE_CODE_UNION:
2304 case TYPE_CODE_ARRAY:
2305 r = false;
2306 break;
2307
2308 default:
2309 r = true;
2310 }
2311
2312 return r;
2313}
2314
2315/* Iterate all the existing _root_ VAROBJs and call the FUNC callback
2316 for each one. */
2317
2318void
2319all_root_varobjs (gdb::function_view<void (struct varobj *var)> func)
2320{
2321 /* Iterate "safely" - handle if the callee deletes its passed VAROBJ. */
2322 auto iter = rootlist.begin ();
2323 auto end = rootlist.end ();
2324 while (iter != end)
2325 {
2326 auto self = iter++;
2327 func ((*self)->rootvar);
2328 }
2329}
2330
2331/* Try to recreate the varobj VAR if it is a global or floating. This is a
2332 helper function for varobj_re_set. */
2333
2334static void
2336{
2337 /* Invalidated global varobjs must be re-evaluated. */
2338 if (!var->root->is_valid && var->root->global)
2339 {
2340 struct varobj *tmp_var;
2341
2342 /* Try to create a varobj with same expression. If we succeed
2343 and have a global replace the old varobj. */
2344 tmp_var = varobj_create (nullptr, var->name.c_str (), (CORE_ADDR) 0,
2346 if (tmp_var != nullptr && tmp_var->root->global)
2347 {
2348 tmp_var->obj_name = var->obj_name;
2349 varobj_delete (var, 0);
2350 install_variable (tmp_var);
2351 }
2352 }
2353}
2354
2355/* See varobj.h. */
2356
2357void
2362
2363/* Ensure that no varobj keep references to OBJFILE. */
2364
2365static void
2367{
2370
2371 all_root_varobjs ([objfile] (struct varobj *var)
2372 {
2373 if (var->root->valid_block != nullptr)
2374 {
2375 struct objfile *bl_objfile = var->root->valid_block->objfile ();
2376 if (bl_objfile->separate_debug_objfile_backlink != nullptr)
2377 bl_objfile = bl_objfile->separate_debug_objfile_backlink;
2378
2379 if (bl_objfile == objfile)
2380 {
2381 /* The varobj is tied to a block which is going away. There is
2382 no way to reconstruct something later, so invalidate the
2383 varobj completely and drop the reference to the block which is
2384 being freed. */
2385 var->root->is_valid = false;
2386 var->root->valid_block = nullptr;
2387 }
2388 }
2389
2390 if (var->root->exp != nullptr && var->root->exp->uses_objfile (objfile))
2391 {
2392 /* The varobj's current expression references the objfile. For
2393 globals and floating, it is possible that when we try to
2394 re-evaluate the expression later it is still valid with
2395 whatever is in scope at that moment. Just invalidate the
2396 expression for now. */
2397 var->root->exp.reset ();
2398
2399 /* It only makes sense to keep a floating varobj around. */
2400 if (!var->root->floating)
2401 var->root->is_valid = false;
2402 }
2403
2404 /* var->value->type and var->type might also reference the objfile.
2405 This is taken care of in value.c:preserve_values which deals with
2406 making sure that objfile-owned types are replaced with
2407 gdbarch-owned equivalents. */
2408 });
2409}
2410
2411/* A hash function for a varobj. */
2412
2413static hashval_t
2414hash_varobj (const void *a)
2415{
2416 const varobj *obj = (const varobj *) a;
2417 return htab_hash_string (obj->obj_name.c_str ());
2418}
2419
2420/* A hash table equality function for varobjs. */
2421
2422static int
2423eq_varobj_and_string (const void *a, const void *b)
2424{
2425 const varobj *obj = (const varobj *) a;
2426 const char *name = (const char *) b;
2427
2428 return obj->obj_name == name;
2429}
2430
2431void _initialize_varobj ();
2432void
2434{
2435 varobj_table = htab_create_alloc (5, hash_varobj, eq_varobj_and_string,
2436 nullptr, xcalloc, xfree);
2437
2439 &varobjdebug,
2440 _("Set varobj debugging."),
2441 _("Show varobj debugging."),
2442 _("When non-zero, varobj debugging is enabled."),
2443 NULL, show_varobjdebug,
2445
2447 "varobj");
2448}
const char *const name
void xfree(void *)
static struct @5 attributes[]
void * xcalloc(size_t number, size_t size)
Definition alloc.c:85
const struct block * get_frame_block(frame_info_ptr frame, CORE_ADDR *addr_in_block)
Definition blockframe.c:55
bool varobj_is_anonymous_child(const struct varobj *child)
Definition c-varobj.c:38
gdbpy_enter_varobj(const struct varobj *var)
const struct block * block() const
Definition expression.h:272
std::string release()
Definition ui-file.h:204
struct cmd_list_element * showdebuglist
Definition cli-cmds.c:167
struct cmd_list_element * setdebuglist
Definition cli-cmds.c:165
set_show_commands add_setshow_zuinteger_cmd(const char *name, enum command_class theclass, unsigned int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
@ class_maintenance
Definition command.h:65
unsigned input_radix
Definition valprint.c:186
std::unique_ptr< expression > expression_up
Definition expression.h:241
exp_opcode
Definition expression.h:45
@ INNERMOST_BLOCK_FOR_REGISTERS
Definition expression.h:39
@ INNERMOST_BLOCK_FOR_SYMBOLS
Definition expression.h:36
expression_up parse_exp_1(const char **, CORE_ADDR pc, const struct block *, parser_flags flags, innermost_block_tracker *=nullptr)
Definition parse.c:446
const struct frame_id null_frame_id
Definition frame.c:688
void select_frame(frame_info_ptr fi)
Definition frame.c:1927
CORE_ADDR get_frame_pc(frame_info_ptr frame)
Definition frame.c:2712
CORE_ADDR get_frame_base_address(frame_info_ptr fi)
Definition frame.c:2887
bool frame_id_p(frame_id l)
Definition frame.c:781
struct gdbarch * get_frame_arch(frame_info_ptr this_frame)
Definition frame.c:3027
bool has_stack_frames()
Definition frame.c:1859
frame_info_ptr get_selected_frame(const char *message)
Definition frame.c:1888
frame_info_ptr frame_find_by_id(struct frame_id id)
Definition frame.c:916
frame_info_ptr get_current_frame(void)
Definition frame.c:1670
struct frame_id get_frame_id(frame_info_ptr fi)
Definition frame.c:631
frame_info_ptr get_prev_frame(frame_info_ptr this_frame)
Definition frame.c:2614
int gdbarch_addr_bit(struct gdbarch *gdbarch)
Definition gdbarch.c:1739
struct thread_info * find_thread_global_id(int global_id)
Definition thread.c:539
struct thread_info * inferior_thread(void)
Definition thread.c:85
void switch_to_thread(struct thread_info *thr)
Definition thread.c:1360
struct type * get_target_type(struct type *type)
Definition gdbtypes.c:293
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition gdbtypes.c:6168
struct type * check_typedef(struct type *type)
Definition gdbtypes.c:2966
#define TYPE_IS_REFERENCE(t)
Definition gdbtypes.h:139
unsigned dummy
Definition go32-nat.c:8
const struct language_defn * current_language
Definition language.c:82
static struct type * new_type(char *)
observable< struct objfile * > free_objfile
void print_value(value *val, const value_print_options &opts)
Definition printcmd.c:1245
void gdbpy_extract_lazy_string(PyObject *string, CORE_ADDR *addr, struct type **str_elt_type, long *length, gdb::unique_xmalloc_ptr< char > *encoding)
int gdbpy_is_lazy_string(PyObject *result)
int value
Definition py-param.c:79
gdbpy_ref apply_varobj_pretty_printer(PyObject *printer_obj, struct value **replacement, struct ui_file *stream, const value_print_options *opts)
gdb::unique_xmalloc_ptr< char > gdbpy_get_display_hint(PyObject *printer)
gdbpy_ref gdbpy_get_varobj_pretty_printer(struct value *value)
gdb::ref_ptr< T, gdbpy_ref_policy< T > > gdbpy_ref
Definition py-ref.h:42
gdb::unique_xmalloc_ptr< char > python_string_to_target_string(PyObject *obj)
Definition py-utils.c:114
PyObject * value_to_value_object(struct value *val)
Definition py-value.c:1854
std::unique_ptr< varobj_iter > py_varobj_get_iterator(struct varobj *var, PyObject *printer, const value_print_options *opts)
Definition py-varobj.c:147
void gdbpy_print_stack(void)
int gdb_python_initialized
PyObject * gdbpy_children_cst
PyObject * gdbpy_to_string_cst
void(* func)(remote_target *remote, char *)
enum var_types type
Definition scm-param.c:142
Definition block.h:109
CORE_ADDR end() const
Definition block.h:119
struct type * builtin_char
Definition gdbtypes.h:2078
std::string(* name_of_child)(const struct varobj *parent, int index)
Definition varobj.h:184
std::string(* value_of_variable)(const struct varobj *var, enum varobj_display_formats format)
Definition varobj.h:197
int(* number_of_children)(const struct varobj *parent)
Definition varobj.h:178
struct type *(* type_of_child)(const struct varobj *parent, int index)
Definition varobj.h:194
std::string(* path_expr_of_child)(const struct varobj *child)
Definition varobj.h:188
bool(* value_is_changeable_p)(const struct varobj *var)
Definition varobj.h:208
bool(* value_has_mutated)(const struct varobj *var, struct value *new_value, struct type *new_type)
Definition varobj.h:222
bool(* is_path_expr_parent)(const struct varobj *var)
Definition varobj.h:229
std::string(* name_of_variable)(const struct varobj *parent)
Definition varobj.h:181
virtual void printstr(struct ui_file *stream, struct type *elttype, const gdb_byte *string, unsigned int length, const char *encoding, int force_ellipses, const struct value_print_options *options) const
Definition c-lang.c:192
struct objfile * separate_debug_objfile_backlink
Definition objfiles.h:830
type_code code() const
Definition gdbtypes.h:956
gdbarch * arch() const
Definition gdbtypes.c:273
Definition value.h:130
bool lazy() const
Definition value.h:265
struct type * type() const
Definition value.h:180
value * parent() const
Definition value.h:211
void fetch_lazy()
Definition value.c:4001
bool stack() const
Definition value.h:317
bool children_requested
Definition varobj.c:124
PyObject * pretty_printer
Definition varobj.c:133
PyObject * constructor
Definition varobj.c:129
std::unique_ptr< varobj_iter > child_iter
Definition varobj.c:137
std::unique_ptr< varobj_item > saved_item
Definition varobj.c:144
value_ref_ptr value
Definition varobj-iter.h:28
std::string name
Definition varobj-iter.h:25
int thread_id
Definition varobj.c:94
bool is_valid
Definition varobj.c:103
bool global
Definition varobj.c:106
const struct language_defn * language_defn
Definition varobj.c:80
struct frame_id frame
Definition varobj.c:87
const struct block * valid_block
Definition varobj.c:83
expression_up exp
Definition varobj.c:74
bool floating
Definition varobj.c:99
const struct lang_varobj_ops * lang_ops
Definition varobj.c:110
struct varobj * rootvar
Definition varobj.c:113
struct gdbarch * gdbarch
Definition varobj.c:77
struct varobj * varobj
Definition varobj.h:71
enum varobj_scope_status status
Definition varobj.h:75
std::vector< struct varobj * > newobj
Definition varobj.h:85
~varobj()
Definition varobj.c:1822
std::string print_value
Definition varobj.h:147
bool not_fetched
Definition varobj.h:157
varobj(varobj_root *root_)
Definition varobj.c:1815
int num_children
Definition varobj.h:128
int index
Definition varobj.h:114
bool updated
Definition varobj.h:144
std::string obj_name
Definition varobj.h:111
int to
Definition varobj.h:163
enum varobj_display_formats format
Definition varobj.h:141
struct varobj_dynamic * dynamic
Definition varobj.h:166
value_ref_ptr value
Definition varobj.h:125
std::vector< varobj * > children
Definition varobj.h:134
bool frozen
Definition varobj.h:152
int from
Definition varobj.h:162
std::string name
Definition varobj.h:103
struct type * type
Definition varobj.h:119
std::string path_expr
Definition varobj.h:107
struct varobj * parent
Definition varobj.h:131
struct varobj_root * root
Definition varobj.h:138
std::string type_to_string(struct type *type)
Definition typeprint.c:399
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition utils.c:1886
#define gdb_stderr
Definition utils.h:187
#define gdb_stdlog
Definition utils.h:190
struct value * value_cast(struct type *type, struct value *arg2)
Definition valops.c:403
struct value * value_assign(struct value *toval, struct value *fromval)
Definition valops.c:1085
void get_formatted_print_options(struct value_print_options *opts, char format)
Definition valprint.c:152
int val_print_string(struct type *elttype, const char *encoding, CORE_ADDR addr, int len, struct ui_file *stream, const struct value_print_options *options)
Definition valprint.c:2643
void get_user_print_options(struct value_print_options *opts)
Definition valprint.c:135
void common_val_print(struct value *value, struct ui_file *stream, int recurse, const struct value_print_options *options, const struct language_defn *language)
Definition valprint.c:1033
struct value * coerce_ref(struct value *arg)
Definition value.c:3752
struct value * coerce_array(struct value *arg)
Definition value.c:3776
struct type * value_actual_type(struct value *value, int resolve_simple_types, int *real_type_found)
Definition value.c:1032
value_ref_ptr release_value(struct value *val)
Definition value.c:1450
gdb::ref_ptr< struct value, value_ref_policy > value_ref_ptr
Definition value.h:124
static struct value * value_of_root_1(struct varobj **var_handle)
Definition varobj.c:1936
int varobj_get_thread_id(const struct varobj *var)
Definition varobj.c:542
static bool install_new_value(struct varobj *var, struct value *value, bool initial)
Definition varobj.c:1176
static std::list< struct varobj_root * > rootlist
Definition varobj.c:199
static struct varobj * varobj_add_child(struct varobj *var, struct varobj_item *item)
Definition varobj.c:816
static std::unique_ptr< varobj_iter > varobj_get_iterator(struct varobj *var)
Definition varobj.c:644
static void uninstall_variable(struct varobj *)
Definition varobj.c:1742
static bool update_type_if_necessary(struct varobj *var, struct value *new_value)
Definition varobj.c:1132
static struct value * value_of_root(struct varobj **var_handle, bool *)
Definition varobj.c:1998
enum varobj_display_formats varobj_get_display_format(const struct varobj *var)
Definition varobj.c:502
static int delete_variable(struct varobj *, bool)
Definition varobj.c:1663
static void install_variable(struct varobj *)
Definition varobj.c:1723
void _initialize_varobj()
Definition varobj.c:2433
static hashval_t hash_varobj(const void *a)
Definition varobj.c:2414
bool varobj_floating_p(const struct varobj *var)
Definition varobj.c:2281
int varobj_get_attributes(const struct varobj *var)
Definition varobj.c:914
void varobj_enable_pretty_printing(void)
Definition varobj.c:62
const char * varobj_get_path_expr(const struct varobj *var)
Definition varobj.c:891
struct varobj * varobj_create(const char *objname, const char *expression, CORE_ADDR frame, enum varobj_type type)
Definition varobj.c:258
static frame_info_ptr find_frame_addr_in_frame_chain(CORE_ADDR frame_addr)
Definition varobj.c:227
static bool is_path_expr_parent(const struct varobj *var)
Definition varobj.c:853
static htab_t varobj_table
Definition varobj.c:202
void varobj_set_child_range(struct varobj *var, int from, int to)
Definition varobj.c:1362
static struct varobj * create_child_with_value(struct varobj *parent, int index, struct varobj_item *item)
Definition varobj.c:1774
void varobj_get_child_range(const struct varobj *var, int *from, int *to)
Definition varobj.c:1352
struct type * varobj_get_value_type(const struct varobj *var)
Definition varobj.c:1856
const struct varobj * varobj_get_path_expr_parent(const struct varobj *var)
Definition varobj.c:872
bool varobj_value_is_changeable_p(const struct varobj *var)
Definition varobj.c:2272
bool varobj_editable_p(const struct varobj *var)
Definition varobj.c:2243
static bool check_scope(const struct varobj *var)
Definition varobj.c:1912
static void install_dynamic_child(struct varobj *var, std::vector< varobj * > *changed, std::vector< varobj * > *type_changed, std::vector< varobj * > *newobj, std::vector< varobj * > *unchanged, bool *cchanged, int index, struct varobj_item *item)
Definition varobj.c:599
static std::string my_value_of_variable(struct varobj *var, enum varobj_display_formats format)
Definition varobj.c:2093
static void delete_variable_1(int *, struct varobj *, bool, bool)
Definition varobj.c:1678
static std::string name_of_child(struct varobj *, int)
Definition varobj.c:1903
static std::string name_of_variable(const struct varobj *)
Definition varobj.c:1895
const std::vector< varobj * > & varobj_list_children(struct varobj *var, int *from, int *to)
Definition varobj.c:770
std::string varobj_gen_name(void)
Definition varobj.c:418
const struct language_defn * varobj_get_language(const struct varobj *var)
Definition varobj.c:908
std::string varobj_get_formatted_value(struct varobj *var, enum varobj_display_formats format)
Definition varobj.c:934
bool varobj_default_value_is_changeable_p(const struct varobj *var)
Definition varobj.c:2290
static void show_varobjdebug(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition varobj.c:48
struct type * varobj_get_gdb_type(const struct varobj *var)
Definition varobj.c:844
static int number_of_children(const struct varobj *)
Definition varobj.c:1887
gdb::unique_xmalloc_ptr< char > varobj_get_display_hint(const struct varobj *var)
Definition varobj.c:508
const char * varobj_get_objname(const struct varobj *var)
Definition varobj.c:445
void varobj_set_visualizer(struct varobj *var, const char *visualizer)
Definition varobj.c:1369
static int eq_varobj_and_string(const void *a, const void *b)
Definition varobj.c:2423
bool varobj_default_is_path_expr_parent(const struct varobj *var)
Definition varobj.c:864
void varobj_re_set(void)
Definition varobj.c:2358
const char * varobj_format_string[]
Definition varobj.c:55
static struct value * value_of_child(const struct varobj *parent, int index)
Definition varobj.c:2082
void varobj_set_frozen(struct varobj *var, bool frozen)
Definition varobj.c:551
std::string varobj_get_value(struct varobj *var)
Definition varobj.c:941
struct varobj * varobj_get_handle(const char *objname)
Definition varobj.c:431
static void install_new_value_visualizer(struct varobj *var)
Definition varobj.c:1104
void varobj_formatted_print_options(struct value_print_options *opts, enum varobj_display_formats format)
Definition varobj.c:2110
static void varobj_re_set_iter(struct varobj *var)
Definition varobj.c:2335
bool varobj_set_value(struct varobj *var, const char *expression)
Definition varobj.c:951
static bool pretty_printing
Definition varobj.c:59
void varobj_restrict_range(const std::vector< varobj * > &children, int *from, int *to)
Definition varobj.c:574
int varobj_get_num_children(struct varobj *var)
Definition varobj.c:746
static bool varobj_value_has_mutated(const struct varobj *var, struct value *new_value, struct type *new_type)
Definition varobj.c:1412
bool varobj_get_frozen(const struct varobj *var)
Definition varobj.c:564
int PyObject
Definition varobj.c:41
static void varobj_invalidate_if_uses_objfile(struct objfile *objfile)
Definition varobj.c:2366
static bool is_root_p(const struct varobj *var)
Definition varobj.c:208
bool varobj_is_dynamic_p(const struct varobj *var)
Definition varobj.c:928
static int format_code[]
Definition varobj.c:196
std::string varobj_value_get_print_value(struct value *value, enum varobj_display_formats format, const struct varobj *var)
Definition varobj.c:2119
std::vector< varobj_update_result > varobj_update(struct varobj **varp, bool is_explicit)
Definition varobj.c:1453
std::string varobj_get_type(struct varobj *var)
Definition varobj.c:830
int varobj_delete(struct varobj *var, bool only_children)
Definition varobj.c:462
void all_root_varobjs(gdb::function_view< void(struct varobj *var)> func)
Definition varobj.c:2319
bool varobj_has_more(const struct varobj *var, int to)
Definition varobj.c:528
std::string varobj_get_expression(const struct varobj *var)
Definition varobj.c:454
enum varobj_display_formats varobj_set_display_format(struct varobj *var, enum varobj_display_formats format)
Definition varobj.c:486
static bool update_dynamic_varobj_children(struct varobj *var, std::vector< varobj * > *changed, std::vector< varobj * > *type_changed, std::vector< varobj * > *newobj, std::vector< varobj * > *unchanged, bool *cchanged, bool update_children, int from, int to)
Definition varobj.c:659
static struct varobj * create_child(struct varobj *, int, std::string &)
Definition varobj.c:1763
unsigned int varobjdebug
Definition varobj.c:46
varobj_display_formats
Definition varobj.h:26
@ FORMAT_NATURAL
Definition varobj.h:27
#define CPLUS_FAKE_CHILD(x)
Definition varobj.h:170
varobj_type
Definition varobj.h:36
@ USE_CURRENT_FRAME
Definition varobj.h:38
@ USE_SELECTED_FRAME
Definition varobj.h:39
@ VAROBJ_NOT_IN_SCOPE
Definition varobj.h:46
@ VAROBJ_INVALID
Definition varobj.h:49