1 /* Implementation of the GDB variable objects API.
3 Copyright (C) 1999-2012 Free Software Foundation, Inc.
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 3 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19 #include "exceptions.h"
21 #include "expression.h"
29 #include "gdb_assert.h"
30 #include "gdb_string.h"
31 #include "gdb_regex.h"
35 #include "gdbthread.h"
39 #include "python/python.h"
40 #include "python/python-internal.h"
45 /* Non-zero if we want to see trace of varobj level stuff. */
49 show_varobjdebug (struct ui_file
*file
, int from_tty
,
50 struct cmd_list_element
*c
, const char *value
)
52 fprintf_filtered (file
, _("Varobj debugging is %s.\n"), value
);
55 /* String representations of gdb's format codes. */
56 char *varobj_format_string
[] =
57 { "natural", "binary", "decimal", "hexadecimal", "octal" };
59 /* String representations of gdb's known languages. */
60 char *varobj_language_string
[] = { "unknown", "C", "C++", "Java" };
62 /* True if we want to allow Python-based pretty-printing. */
63 static int pretty_printing
= 0;
66 varobj_enable_pretty_printing (void)
73 /* Every root variable has one of these structures saved in its
74 varobj. Members which must be free'd are noted. */
78 /* Alloc'd expression for this parent. */
79 struct expression
*exp
;
81 /* Block for which this expression is valid. */
82 struct block
*valid_block
;
84 /* The frame for this expression. This field is set iff valid_block is
86 struct frame_id frame
;
88 /* The thread ID that this varobj_root belong to. This field
89 is only valid if valid_block is not NULL.
90 When not 0, indicates which thread 'frame' belongs to.
91 When 0, indicates that the thread list was empty when the varobj_root
95 /* If 1, the -var-update always recomputes the value in the
96 current thread and frame. Otherwise, variable object is
97 always updated in the specific scope/thread/frame. */
100 /* Flag that indicates validity: set to 0 when this varobj_root refers
101 to symbols that do not exist anymore. */
104 /* Language info for this variable and its children. */
105 struct language_specific
*lang
;
107 /* The varobj for this root node. */
108 struct varobj
*rootvar
;
110 /* Next root variable */
111 struct varobj_root
*next
;
114 /* Every variable in the system has a structure of this type defined
115 for it. This structure holds all information necessary to manipulate
116 a particular object variable. Members which must be freed are noted. */
120 /* Alloc'd name of the variable for this object. If this variable is a
121 child, then this name will be the child's source name.
122 (bar, not foo.bar). */
123 /* NOTE: This is the "expression". */
126 /* Alloc'd expression for this child. Can be used to create a
127 root variable corresponding to this child. */
130 /* The alloc'd name for this variable's object. This is here for
131 convenience when constructing this object's children. */
134 /* Index of this variable in its parent or -1. */
137 /* The type of this variable. This can be NULL
138 for artifial variable objects -- currently, the "accessibility"
139 variable objects in C++. */
142 /* The value of this expression or subexpression. A NULL value
143 indicates there was an error getting this value.
144 Invariant: if varobj_value_is_changeable_p (this) is non-zero,
145 the value is either NULL, or not lazy. */
148 /* The number of (immediate) children this variable has. */
151 /* If this object is a child, this points to its immediate parent. */
152 struct varobj
*parent
;
154 /* Children of this object. */
155 VEC (varobj_p
) *children
;
157 /* Whether the children of this varobj were requested. This field is
158 used to decide if dynamic varobj should recompute their children.
159 In the event that the frontend never asked for the children, we
161 int children_requested
;
163 /* Description of the root variable. Points to root variable for
165 struct varobj_root
*root
;
167 /* The format of the output for this object. */
168 enum varobj_display_formats format
;
170 /* Was this variable updated via a varobj_set_value operation. */
173 /* Last print value. */
176 /* Is this variable frozen. Frozen variables are never implicitly
177 updated by -var-update *
178 or -var-update <direct-or-indirect-parent>. */
181 /* Is the value of this variable intentionally not fetched? It is
182 not fetched if either the variable is frozen, or any parents is
186 /* Sub-range of children which the MI consumer has requested. If
187 FROM < 0 or TO < 0, means that all children have been
192 /* The pretty-printer constructor. If NULL, then the default
193 pretty-printer will be looked up. If None, then no
194 pretty-printer will be installed. */
195 PyObject
*constructor
;
197 /* The pretty-printer that has been constructed. If NULL, then a
198 new printer object is needed, and one will be constructed. */
199 PyObject
*pretty_printer
;
201 /* The iterator returned by the printer's 'children' method, or NULL
203 PyObject
*child_iter
;
205 /* We request one extra item from the iterator, so that we can
206 report to the caller whether there are more items than we have
207 already reported. However, we don't want to install this value
208 when we read it, because that will mess up future updates. So,
209 we stash it here instead. */
210 PyObject
*saved_item
;
216 struct cpstack
*next
;
219 /* A list of varobjs */
227 /* Private function prototypes */
229 /* Helper functions for the above subcommands. */
231 static int delete_variable (struct cpstack
**, struct varobj
*, int);
233 static void delete_variable_1 (struct cpstack
**, int *,
234 struct varobj
*, int, int);
236 static int install_variable (struct varobj
*);
238 static void uninstall_variable (struct varobj
*);
240 static struct varobj
*create_child (struct varobj
*, int, char *);
242 static struct varobj
*
243 create_child_with_value (struct varobj
*parent
, int index
, const char *name
,
244 struct value
*value
);
246 /* Utility routines */
248 static struct varobj
*new_variable (void);
250 static struct varobj
*new_root_variable (void);
252 static void free_variable (struct varobj
*var
);
254 static struct cleanup
*make_cleanup_free_variable (struct varobj
*var
);
256 static struct type
*get_type (struct varobj
*var
);
258 static struct type
*get_value_type (struct varobj
*var
);
260 static struct type
*get_target_type (struct type
*);
262 static enum varobj_display_formats
variable_default_display (struct varobj
*);
264 static void cppush (struct cpstack
**pstack
, char *name
);
266 static char *cppop (struct cpstack
**pstack
);
268 static int install_new_value (struct varobj
*var
, struct value
*value
,
271 /* Language-specific routines. */
273 static enum varobj_languages
variable_language (struct varobj
*var
);
275 static int number_of_children (struct varobj
*);
277 static char *name_of_variable (struct varobj
*);
279 static char *name_of_child (struct varobj
*, int);
281 static struct value
*value_of_root (struct varobj
**var_handle
, int *);
283 static struct value
*value_of_child (struct varobj
*parent
, int index
);
285 static char *my_value_of_variable (struct varobj
*var
,
286 enum varobj_display_formats format
);
288 static char *value_get_print_value (struct value
*value
,
289 enum varobj_display_formats format
,
292 static int varobj_value_is_changeable_p (struct varobj
*var
);
294 static int is_root_p (struct varobj
*var
);
298 static struct varobj
*varobj_add_child (struct varobj
*var
,
300 struct value
*value
);
302 #endif /* HAVE_PYTHON */
304 /* C implementation */
306 static int c_number_of_children (struct varobj
*var
);
308 static char *c_name_of_variable (struct varobj
*parent
);
310 static char *c_name_of_child (struct varobj
*parent
, int index
);
312 static char *c_path_expr_of_child (struct varobj
*child
);
314 static struct value
*c_value_of_root (struct varobj
**var_handle
);
316 static struct value
*c_value_of_child (struct varobj
*parent
, int index
);
318 static struct type
*c_type_of_child (struct varobj
*parent
, int index
);
320 static char *c_value_of_variable (struct varobj
*var
,
321 enum varobj_display_formats format
);
323 /* C++ implementation */
325 static int cplus_number_of_children (struct varobj
*var
);
327 static void cplus_class_num_children (struct type
*type
, int children
[3]);
329 static char *cplus_name_of_variable (struct varobj
*parent
);
331 static char *cplus_name_of_child (struct varobj
*parent
, int index
);
333 static char *cplus_path_expr_of_child (struct varobj
*child
);
335 static struct value
*cplus_value_of_root (struct varobj
**var_handle
);
337 static struct value
*cplus_value_of_child (struct varobj
*parent
, int index
);
339 static struct type
*cplus_type_of_child (struct varobj
*parent
, int index
);
341 static char *cplus_value_of_variable (struct varobj
*var
,
342 enum varobj_display_formats format
);
344 /* Java implementation */
346 static int java_number_of_children (struct varobj
*var
);
348 static char *java_name_of_variable (struct varobj
*parent
);
350 static char *java_name_of_child (struct varobj
*parent
, int index
);
352 static char *java_path_expr_of_child (struct varobj
*child
);
354 static struct value
*java_value_of_root (struct varobj
**var_handle
);
356 static struct value
*java_value_of_child (struct varobj
*parent
, int index
);
358 static struct type
*java_type_of_child (struct varobj
*parent
, int index
);
360 static char *java_value_of_variable (struct varobj
*var
,
361 enum varobj_display_formats format
);
363 /* Ada implementation */
365 static int ada_number_of_children (struct varobj
*var
);
367 static char *ada_name_of_variable (struct varobj
*parent
);
369 static char *ada_name_of_child (struct varobj
*parent
, int index
);
371 static char *ada_path_expr_of_child (struct varobj
*child
);
373 static struct value
*ada_value_of_root (struct varobj
**var_handle
);
375 static struct value
*ada_value_of_child (struct varobj
*parent
, int index
);
377 static struct type
*ada_type_of_child (struct varobj
*parent
, int index
);
379 static char *ada_value_of_variable (struct varobj
*var
,
380 enum varobj_display_formats format
);
382 /* The language specific vector */
384 struct language_specific
387 /* The language of this variable. */
388 enum varobj_languages language
;
390 /* The number of children of PARENT. */
391 int (*number_of_children
) (struct varobj
* parent
);
393 /* The name (expression) of a root varobj. */
394 char *(*name_of_variable
) (struct varobj
* parent
);
396 /* The name of the INDEX'th child of PARENT. */
397 char *(*name_of_child
) (struct varobj
* parent
, int index
);
399 /* Returns the rooted expression of CHILD, which is a variable
400 obtain that has some parent. */
401 char *(*path_expr_of_child
) (struct varobj
* child
);
403 /* The ``struct value *'' of the root variable ROOT. */
404 struct value
*(*value_of_root
) (struct varobj
** root_handle
);
406 /* The ``struct value *'' of the INDEX'th child of PARENT. */
407 struct value
*(*value_of_child
) (struct varobj
* parent
, int index
);
409 /* The type of the INDEX'th child of PARENT. */
410 struct type
*(*type_of_child
) (struct varobj
* parent
, int index
);
412 /* The current value of VAR. */
413 char *(*value_of_variable
) (struct varobj
* var
,
414 enum varobj_display_formats format
);
417 /* Array of known source language routines. */
418 static struct language_specific languages
[vlang_end
] = {
419 /* Unknown (try treating as C). */
422 c_number_of_children
,
425 c_path_expr_of_child
,
434 c_number_of_children
,
437 c_path_expr_of_child
,
446 cplus_number_of_children
,
447 cplus_name_of_variable
,
449 cplus_path_expr_of_child
,
451 cplus_value_of_child
,
453 cplus_value_of_variable
}
458 java_number_of_children
,
459 java_name_of_variable
,
461 java_path_expr_of_child
,
465 java_value_of_variable
},
469 ada_number_of_children
,
470 ada_name_of_variable
,
472 ada_path_expr_of_child
,
476 ada_value_of_variable
}
479 /* A little convenience enum for dealing with C++/Java. */
482 v_public
= 0, v_private
, v_protected
487 /* Mappings of varobj_display_formats enums to gdb's format codes. */
488 static int format_code
[] = { 0, 't', 'd', 'x', 'o' };
490 /* Header of the list of root variable objects. */
491 static struct varobj_root
*rootlist
;
493 /* Prime number indicating the number of buckets in the hash table. */
494 /* A prime large enough to avoid too many colisions. */
495 #define VAROBJ_TABLE_SIZE 227
497 /* Pointer to the varobj hash table (built at run time). */
498 static struct vlist
**varobj_table
;
500 /* Is the variable X one of our "fake" children? */
501 #define CPLUS_FAKE_CHILD(x) \
502 ((x) != NULL && (x)->type == NULL && (x)->value == NULL)
505 /* API Implementation */
507 is_root_p (struct varobj
*var
)
509 return (var
->root
->rootvar
== var
);
513 /* Helper function to install a Python environment suitable for
514 use during operations on VAR. */
516 varobj_ensure_python_env (struct varobj
*var
)
518 return ensure_python_env (var
->root
->exp
->gdbarch
,
519 var
->root
->exp
->language_defn
);
523 /* Creates a varobj (not its children). */
525 /* Return the full FRAME which corresponds to the given CORE_ADDR
526 or NULL if no FRAME on the chain corresponds to CORE_ADDR. */
528 static struct frame_info
*
529 find_frame_addr_in_frame_chain (CORE_ADDR frame_addr
)
531 struct frame_info
*frame
= NULL
;
533 if (frame_addr
== (CORE_ADDR
) 0)
536 for (frame
= get_current_frame ();
538 frame
= get_prev_frame (frame
))
540 /* The CORE_ADDR we get as argument was parsed from a string GDB
541 output as $fp. This output got truncated to gdbarch_addr_bit.
542 Truncate the frame base address in the same manner before
543 comparing it against our argument. */
544 CORE_ADDR frame_base
= get_frame_base_address (frame
);
545 int addr_bit
= gdbarch_addr_bit (get_frame_arch (frame
));
547 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
548 frame_base
&= ((CORE_ADDR
) 1 << addr_bit
) - 1;
550 if (frame_base
== frame_addr
)
558 varobj_create (char *objname
,
559 char *expression
, CORE_ADDR frame
, enum varobj_type type
)
562 struct cleanup
*old_chain
;
564 /* Fill out a varobj structure for the (root) variable being constructed. */
565 var
= new_root_variable ();
566 old_chain
= make_cleanup_free_variable (var
);
568 if (expression
!= NULL
)
570 struct frame_info
*fi
;
571 struct frame_id old_id
= null_frame_id
;
574 enum varobj_languages lang
;
575 struct value
*value
= NULL
;
577 /* Parse and evaluate the expression, filling in as much of the
578 variable's data as possible. */
580 if (has_stack_frames ())
582 /* Allow creator to specify context of variable. */
583 if ((type
== USE_CURRENT_FRAME
) || (type
== USE_SELECTED_FRAME
))
584 fi
= get_selected_frame (NULL
);
586 /* FIXME: cagney/2002-11-23: This code should be doing a
587 lookup using the frame ID and not just the frame's
588 ``address''. This, of course, means an interface
589 change. However, with out that interface change ISAs,
590 such as the ia64 with its two stacks, won't work.
591 Similar goes for the case where there is a frameless
593 fi
= find_frame_addr_in_frame_chain (frame
);
598 /* frame = -2 means always use selected frame. */
599 if (type
== USE_SELECTED_FRAME
)
600 var
->root
->floating
= 1;
604 block
= get_frame_block (fi
, 0);
607 innermost_block
= NULL
;
608 /* Wrap the call to parse expression, so we can
609 return a sensible error. */
610 if (!gdb_parse_exp_1 (&p
, block
, 0, &var
->root
->exp
))
612 do_cleanups (old_chain
);
616 /* Don't allow variables to be created for types. */
617 if (var
->root
->exp
->elts
[0].opcode
== OP_TYPE
)
619 do_cleanups (old_chain
);
620 fprintf_unfiltered (gdb_stderr
, "Attempt to use a type name"
621 " as an expression.\n");
625 var
->format
= variable_default_display (var
);
626 var
->root
->valid_block
= innermost_block
;
627 var
->name
= xstrdup (expression
);
628 /* For a root var, the name and the expr are the same. */
629 var
->path_expr
= xstrdup (expression
);
631 /* When the frame is different from the current frame,
632 we must select the appropriate frame before parsing
633 the expression, otherwise the value will not be current.
634 Since select_frame is so benign, just call it for all cases. */
637 /* User could specify explicit FRAME-ADDR which was not found but
638 EXPRESSION is frame specific and we would not be able to evaluate
639 it correctly next time. With VALID_BLOCK set we must also set
640 FRAME and THREAD_ID. */
642 error (_("Failed to find the specified frame"));
644 var
->root
->frame
= get_frame_id (fi
);
645 var
->root
->thread_id
= pid_to_thread_id (inferior_ptid
);
646 old_id
= get_frame_id (get_selected_frame (NULL
));
650 /* We definitely need to catch errors here.
651 If evaluate_expression succeeds we got the value we wanted.
652 But if it fails, we still go on with a call to evaluate_type(). */
653 if (!gdb_evaluate_expression (var
->root
->exp
, &value
))
655 /* Error getting the value. Try to at least get the
657 struct value
*type_only_value
= evaluate_type (var
->root
->exp
);
659 var
->type
= value_type (type_only_value
);
662 var
->type
= value_type (value
);
664 install_new_value (var
, value
, 1 /* Initial assignment */);
666 /* Set language info */
667 lang
= variable_language (var
);
668 var
->root
->lang
= &languages
[lang
];
670 /* Set ourselves as our root. */
671 var
->root
->rootvar
= var
;
673 /* Reset the selected frame. */
674 if (frame_id_p (old_id
))
675 select_frame (frame_find_by_id (old_id
));
678 /* If the variable object name is null, that means this
679 is a temporary variable, so don't install it. */
681 if ((var
!= NULL
) && (objname
!= NULL
))
683 var
->obj_name
= xstrdup (objname
);
685 /* If a varobj name is duplicated, the install will fail so
687 if (!install_variable (var
))
689 do_cleanups (old_chain
);
694 discard_cleanups (old_chain
);
698 /* Generates an unique name that can be used for a varobj. */
701 varobj_gen_name (void)
706 /* Generate a name for this object. */
708 obj_name
= xstrprintf ("var%d", id
);
713 /* Given an OBJNAME, returns the pointer to the corresponding varobj. Call
714 error if OBJNAME cannot be found. */
717 varobj_get_handle (char *objname
)
721 unsigned int index
= 0;
724 for (chp
= objname
; *chp
; chp
++)
726 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
729 cv
= *(varobj_table
+ index
);
730 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, objname
) != 0))
734 error (_("Variable object not found"));
739 /* Given the handle, return the name of the object. */
742 varobj_get_objname (struct varobj
*var
)
744 return var
->obj_name
;
747 /* Given the handle, return the expression represented by the object. */
750 varobj_get_expression (struct varobj
*var
)
752 return name_of_variable (var
);
755 /* Deletes a varobj and all its children if only_children == 0,
756 otherwise deletes only the children; returns a malloc'ed list of
757 all the (malloc'ed) names of the variables that have been deleted
758 (NULL terminated). */
761 varobj_delete (struct varobj
*var
, char ***dellist
, int only_children
)
765 struct cpstack
*result
= NULL
;
768 /* Initialize a stack for temporary results. */
769 cppush (&result
, NULL
);
772 /* Delete only the variable children. */
773 delcount
= delete_variable (&result
, var
, 1 /* only the children */ );
775 /* Delete the variable and all its children. */
776 delcount
= delete_variable (&result
, var
, 0 /* parent+children */ );
778 /* We may have been asked to return a list of what has been deleted. */
781 *dellist
= xmalloc ((delcount
+ 1) * sizeof (char *));
785 *cp
= cppop (&result
);
786 while ((*cp
!= NULL
) && (mycount
> 0))
790 *cp
= cppop (&result
);
793 if (mycount
|| (*cp
!= NULL
))
794 warning (_("varobj_delete: assertion failed - mycount(=%d) <> 0"),
803 /* Convenience function for varobj_set_visualizer. Instantiate a
804 pretty-printer for a given value. */
806 instantiate_pretty_printer (PyObject
*constructor
, struct value
*value
)
808 PyObject
*val_obj
= NULL
;
811 val_obj
= value_to_value_object (value
);
815 printer
= PyObject_CallFunctionObjArgs (constructor
, val_obj
, NULL
);
822 /* Set/Get variable object display format. */
824 enum varobj_display_formats
825 varobj_set_display_format (struct varobj
*var
,
826 enum varobj_display_formats format
)
833 case FORMAT_HEXADECIMAL
:
835 var
->format
= format
;
839 var
->format
= variable_default_display (var
);
842 if (varobj_value_is_changeable_p (var
)
843 && var
->value
&& !value_lazy (var
->value
))
845 xfree (var
->print_value
);
846 var
->print_value
= value_get_print_value (var
->value
, var
->format
, var
);
852 enum varobj_display_formats
853 varobj_get_display_format (struct varobj
*var
)
859 varobj_get_display_hint (struct varobj
*var
)
864 struct cleanup
*back_to
= varobj_ensure_python_env (var
);
866 if (var
->pretty_printer
)
867 result
= gdbpy_get_display_hint (var
->pretty_printer
);
869 do_cleanups (back_to
);
875 /* Return true if the varobj has items after TO, false otherwise. */
878 varobj_has_more (struct varobj
*var
, int to
)
880 if (VEC_length (varobj_p
, var
->children
) > to
)
882 return ((to
== -1 || VEC_length (varobj_p
, var
->children
) == to
)
883 && var
->saved_item
!= NULL
);
886 /* If the variable object is bound to a specific thread, that
887 is its evaluation can always be done in context of a frame
888 inside that thread, returns GDB id of the thread -- which
889 is always positive. Otherwise, returns -1. */
891 varobj_get_thread_id (struct varobj
*var
)
893 if (var
->root
->valid_block
&& var
->root
->thread_id
> 0)
894 return var
->root
->thread_id
;
900 varobj_set_frozen (struct varobj
*var
, int frozen
)
902 /* When a variable is unfrozen, we don't fetch its value.
903 The 'not_fetched' flag remains set, so next -var-update
906 We don't fetch the value, because for structures the client
907 should do -var-update anyway. It would be bad to have different
908 client-size logic for structure and other types. */
909 var
->frozen
= frozen
;
913 varobj_get_frozen (struct varobj
*var
)
918 /* A helper function that restricts a range to what is actually
919 available in a VEC. This follows the usual rules for the meaning
920 of FROM and TO -- if either is negative, the entire range is
924 restrict_range (VEC (varobj_p
) *children
, int *from
, int *to
)
926 if (*from
< 0 || *to
< 0)
929 *to
= VEC_length (varobj_p
, children
);
933 if (*from
> VEC_length (varobj_p
, children
))
934 *from
= VEC_length (varobj_p
, children
);
935 if (*to
> VEC_length (varobj_p
, children
))
936 *to
= VEC_length (varobj_p
, children
);
944 /* A helper for update_dynamic_varobj_children that installs a new
945 child when needed. */
948 install_dynamic_child (struct varobj
*var
,
949 VEC (varobj_p
) **changed
,
950 VEC (varobj_p
) **new,
951 VEC (varobj_p
) **unchanged
,
957 if (VEC_length (varobj_p
, var
->children
) < index
+ 1)
959 /* There's no child yet. */
960 struct varobj
*child
= varobj_add_child (var
, name
, value
);
964 VEC_safe_push (varobj_p
, *new, child
);
970 varobj_p existing
= VEC_index (varobj_p
, var
->children
, index
);
972 if (install_new_value (existing
, value
, 0))
975 VEC_safe_push (varobj_p
, *changed
, existing
);
978 VEC_safe_push (varobj_p
, *unchanged
, existing
);
983 dynamic_varobj_has_child_method (struct varobj
*var
)
985 struct cleanup
*back_to
;
986 PyObject
*printer
= var
->pretty_printer
;
989 back_to
= varobj_ensure_python_env (var
);
990 result
= PyObject_HasAttr (printer
, gdbpy_children_cst
);
991 do_cleanups (back_to
);
998 update_dynamic_varobj_children (struct varobj
*var
,
999 VEC (varobj_p
) **changed
,
1000 VEC (varobj_p
) **new,
1001 VEC (varobj_p
) **unchanged
,
1003 int update_children
,
1008 struct cleanup
*back_to
;
1011 PyObject
*printer
= var
->pretty_printer
;
1013 back_to
= varobj_ensure_python_env (var
);
1016 if (!PyObject_HasAttr (printer
, gdbpy_children_cst
))
1018 do_cleanups (back_to
);
1022 if (update_children
|| !var
->child_iter
)
1024 children
= PyObject_CallMethodObjArgs (printer
, gdbpy_children_cst
,
1029 gdbpy_print_stack ();
1030 error (_("Null value returned for children"));
1033 make_cleanup_py_decref (children
);
1035 if (!PyIter_Check (children
))
1036 error (_("Returned value is not iterable"));
1038 Py_XDECREF (var
->child_iter
);
1039 var
->child_iter
= PyObject_GetIter (children
);
1040 if (!var
->child_iter
)
1042 gdbpy_print_stack ();
1043 error (_("Could not get children iterator"));
1046 Py_XDECREF (var
->saved_item
);
1047 var
->saved_item
= NULL
;
1052 i
= VEC_length (varobj_p
, var
->children
);
1054 /* We ask for one extra child, so that MI can report whether there
1055 are more children. */
1056 for (; to
< 0 || i
< to
+ 1; ++i
)
1061 /* See if there was a leftover from last time. */
1062 if (var
->saved_item
)
1064 item
= var
->saved_item
;
1065 var
->saved_item
= NULL
;
1068 item
= PyIter_Next (var
->child_iter
);
1072 /* Normal end of iteration. */
1073 if (!PyErr_Occurred ())
1076 /* If we got a memory error, just use the text as the
1078 if (PyErr_ExceptionMatches (gdbpy_gdb_memory_error
))
1080 PyObject
*type
, *value
, *trace
;
1081 char *name_str
, *value_str
;
1083 PyErr_Fetch (&type
, &value
, &trace
);
1084 value_str
= gdbpy_exception_to_string (type
, value
);
1090 gdbpy_print_stack ();
1094 name_str
= xstrprintf ("<error at %d>", i
);
1095 item
= Py_BuildValue ("(ss)", name_str
, value_str
);
1100 gdbpy_print_stack ();
1108 /* Any other kind of error. */
1109 gdbpy_print_stack ();
1114 /* We don't want to push the extra child on any report list. */
1115 if (to
< 0 || i
< to
)
1120 struct cleanup
*inner
;
1121 int can_mention
= from
< 0 || i
>= from
;
1123 inner
= make_cleanup_py_decref (item
);
1125 if (!PyArg_ParseTuple (item
, "sO", &name
, &py_v
))
1127 gdbpy_print_stack ();
1128 error (_("Invalid item from the child list"));
1131 v
= convert_value_from_python (py_v
);
1133 gdbpy_print_stack ();
1134 install_dynamic_child (var
, can_mention
? changed
: NULL
,
1135 can_mention
? new : NULL
,
1136 can_mention
? unchanged
: NULL
,
1137 can_mention
? cchanged
: NULL
, i
, name
, v
);
1138 do_cleanups (inner
);
1142 Py_XDECREF (var
->saved_item
);
1143 var
->saved_item
= item
;
1145 /* We want to truncate the child list just before this
1154 if (i
< VEC_length (varobj_p
, var
->children
))
1159 for (j
= i
; j
< VEC_length (varobj_p
, var
->children
); ++j
)
1160 varobj_delete (VEC_index (varobj_p
, var
->children
, j
), NULL
, 0);
1161 VEC_truncate (varobj_p
, var
->children
, i
);
1164 /* If there are fewer children than requested, note that the list of
1165 children changed. */
1166 if (to
>= 0 && VEC_length (varobj_p
, var
->children
) < to
)
1169 var
->num_children
= VEC_length (varobj_p
, var
->children
);
1171 do_cleanups (back_to
);
1175 gdb_assert (0 && "should never be called if Python is not enabled");
1180 varobj_get_num_children (struct varobj
*var
)
1182 if (var
->num_children
== -1)
1184 if (var
->pretty_printer
)
1188 /* If we have a dynamic varobj, don't report -1 children.
1189 So, try to fetch some children first. */
1190 update_dynamic_varobj_children (var
, NULL
, NULL
, NULL
, &dummy
,
1194 var
->num_children
= number_of_children (var
);
1197 return var
->num_children
>= 0 ? var
->num_children
: 0;
1200 /* Creates a list of the immediate children of a variable object;
1201 the return code is the number of such children or -1 on error. */
1204 varobj_list_children (struct varobj
*var
, int *from
, int *to
)
1207 int i
, children_changed
;
1209 var
->children_requested
= 1;
1211 if (var
->pretty_printer
)
1213 /* This, in theory, can result in the number of children changing without
1214 frontend noticing. But well, calling -var-list-children on the same
1215 varobj twice is not something a sane frontend would do. */
1216 update_dynamic_varobj_children (var
, NULL
, NULL
, NULL
, &children_changed
,
1218 restrict_range (var
->children
, from
, to
);
1219 return var
->children
;
1222 if (var
->num_children
== -1)
1223 var
->num_children
= number_of_children (var
);
1225 /* If that failed, give up. */
1226 if (var
->num_children
== -1)
1227 return var
->children
;
1229 /* If we're called when the list of children is not yet initialized,
1230 allocate enough elements in it. */
1231 while (VEC_length (varobj_p
, var
->children
) < var
->num_children
)
1232 VEC_safe_push (varobj_p
, var
->children
, NULL
);
1234 for (i
= 0; i
< var
->num_children
; i
++)
1236 varobj_p existing
= VEC_index (varobj_p
, var
->children
, i
);
1238 if (existing
== NULL
)
1240 /* Either it's the first call to varobj_list_children for
1241 this variable object, and the child was never created,
1242 or it was explicitly deleted by the client. */
1243 name
= name_of_child (var
, i
);
1244 existing
= create_child (var
, i
, name
);
1245 VEC_replace (varobj_p
, var
->children
, i
, existing
);
1249 restrict_range (var
->children
, from
, to
);
1250 return var
->children
;
1255 static struct varobj
*
1256 varobj_add_child (struct varobj
*var
, const char *name
, struct value
*value
)
1258 varobj_p v
= create_child_with_value (var
,
1259 VEC_length (varobj_p
, var
->children
),
1262 VEC_safe_push (varobj_p
, var
->children
, v
);
1266 #endif /* HAVE_PYTHON */
1268 /* Obtain the type of an object Variable as a string similar to the one gdb
1269 prints on the console. */
1272 varobj_get_type (struct varobj
*var
)
1274 /* For the "fake" variables, do not return a type. (It's type is
1276 Do not return a type for invalid variables as well. */
1277 if (CPLUS_FAKE_CHILD (var
) || !var
->root
->is_valid
)
1280 return type_to_string (var
->type
);
1283 /* Obtain the type of an object variable. */
1286 varobj_get_gdb_type (struct varobj
*var
)
1291 /* Return a pointer to the full rooted expression of varobj VAR.
1292 If it has not been computed yet, compute it. */
1294 varobj_get_path_expr (struct varobj
*var
)
1296 if (var
->path_expr
!= NULL
)
1297 return var
->path_expr
;
1300 /* For root varobjs, we initialize path_expr
1301 when creating varobj, so here it should be
1303 gdb_assert (!is_root_p (var
));
1304 return (*var
->root
->lang
->path_expr_of_child
) (var
);
1308 enum varobj_languages
1309 varobj_get_language (struct varobj
*var
)
1311 return variable_language (var
);
1315 varobj_get_attributes (struct varobj
*var
)
1319 if (varobj_editable_p (var
))
1320 /* FIXME: define masks for attributes. */
1321 attributes
|= 0x00000001; /* Editable */
1327 varobj_pretty_printed_p (struct varobj
*var
)
1329 return var
->pretty_printer
!= NULL
;
1333 varobj_get_formatted_value (struct varobj
*var
,
1334 enum varobj_display_formats format
)
1336 return my_value_of_variable (var
, format
);
1340 varobj_get_value (struct varobj
*var
)
1342 return my_value_of_variable (var
, var
->format
);
1345 /* Set the value of an object variable (if it is editable) to the
1346 value of the given expression. */
1347 /* Note: Invokes functions that can call error(). */
1350 varobj_set_value (struct varobj
*var
, char *expression
)
1354 /* The argument "expression" contains the variable's new value.
1355 We need to first construct a legal expression for this -- ugh! */
1356 /* Does this cover all the bases? */
1357 struct expression
*exp
;
1358 struct value
*value
;
1359 int saved_input_radix
= input_radix
;
1360 char *s
= expression
;
1362 gdb_assert (varobj_editable_p (var
));
1364 input_radix
= 10; /* ALWAYS reset to decimal temporarily. */
1365 exp
= parse_exp_1 (&s
, 0, 0);
1366 if (!gdb_evaluate_expression (exp
, &value
))
1368 /* We cannot proceed without a valid expression. */
1373 /* All types that are editable must also be changeable. */
1374 gdb_assert (varobj_value_is_changeable_p (var
));
1376 /* The value of a changeable variable object must not be lazy. */
1377 gdb_assert (!value_lazy (var
->value
));
1379 /* Need to coerce the input. We want to check if the
1380 value of the variable object will be different
1381 after assignment, and the first thing value_assign
1382 does is coerce the input.
1383 For example, if we are assigning an array to a pointer variable we
1384 should compare the pointer with the array's address, not with the
1386 value
= coerce_array (value
);
1388 /* The new value may be lazy. gdb_value_assign, or
1389 rather value_contents, will take care of this.
1390 If fetching of the new value will fail, gdb_value_assign
1391 with catch the exception. */
1392 if (!gdb_value_assign (var
->value
, value
, &val
))
1395 /* If the value has changed, record it, so that next -var-update can
1396 report this change. If a variable had a value of '1', we've set it
1397 to '333' and then set again to '1', when -var-update will report this
1398 variable as changed -- because the first assignment has set the
1399 'updated' flag. There's no need to optimize that, because return value
1400 of -var-update should be considered an approximation. */
1401 var
->updated
= install_new_value (var
, val
, 0 /* Compare values. */);
1402 input_radix
= saved_input_radix
;
1408 /* A helper function to install a constructor function and visualizer
1412 install_visualizer (struct varobj
*var
, PyObject
*constructor
,
1413 PyObject
*visualizer
)
1415 Py_XDECREF (var
->constructor
);
1416 var
->constructor
= constructor
;
1418 Py_XDECREF (var
->pretty_printer
);
1419 var
->pretty_printer
= visualizer
;
1421 Py_XDECREF (var
->child_iter
);
1422 var
->child_iter
= NULL
;
1425 /* Install the default visualizer for VAR. */
1428 install_default_visualizer (struct varobj
*var
)
1430 /* Do not install a visualizer on a CPLUS_FAKE_CHILD. */
1431 if (CPLUS_FAKE_CHILD (var
))
1434 if (pretty_printing
)
1436 PyObject
*pretty_printer
= NULL
;
1440 pretty_printer
= gdbpy_get_varobj_pretty_printer (var
->value
);
1441 if (! pretty_printer
)
1443 gdbpy_print_stack ();
1444 error (_("Cannot instantiate printer for default visualizer"));
1448 if (pretty_printer
== Py_None
)
1450 Py_DECREF (pretty_printer
);
1451 pretty_printer
= NULL
;
1454 install_visualizer (var
, NULL
, pretty_printer
);
1458 /* Instantiate and install a visualizer for VAR using CONSTRUCTOR to
1459 make a new object. */
1462 construct_visualizer (struct varobj
*var
, PyObject
*constructor
)
1464 PyObject
*pretty_printer
;
1466 /* Do not install a visualizer on a CPLUS_FAKE_CHILD. */
1467 if (CPLUS_FAKE_CHILD (var
))
1470 Py_INCREF (constructor
);
1471 if (constructor
== Py_None
)
1472 pretty_printer
= NULL
;
1475 pretty_printer
= instantiate_pretty_printer (constructor
, var
->value
);
1476 if (! pretty_printer
)
1478 gdbpy_print_stack ();
1479 Py_DECREF (constructor
);
1480 constructor
= Py_None
;
1481 Py_INCREF (constructor
);
1484 if (pretty_printer
== Py_None
)
1486 Py_DECREF (pretty_printer
);
1487 pretty_printer
= NULL
;
1491 install_visualizer (var
, constructor
, pretty_printer
);
1494 #endif /* HAVE_PYTHON */
1496 /* A helper function for install_new_value. This creates and installs
1497 a visualizer for VAR, if appropriate. */
1500 install_new_value_visualizer (struct varobj
*var
)
1503 /* If the constructor is None, then we want the raw value. If VAR
1504 does not have a value, just skip this. */
1505 if (var
->constructor
!= Py_None
&& var
->value
)
1507 struct cleanup
*cleanup
;
1509 cleanup
= varobj_ensure_python_env (var
);
1511 if (!var
->constructor
)
1512 install_default_visualizer (var
);
1514 construct_visualizer (var
, var
->constructor
);
1516 do_cleanups (cleanup
);
1523 /* Assign a new value to a variable object. If INITIAL is non-zero,
1524 this is the first assignement after the variable object was just
1525 created, or changed type. In that case, just assign the value
1527 Otherwise, assign the new value, and return 1 if the value is
1528 different from the current one, 0 otherwise. The comparison is
1529 done on textual representation of value. Therefore, some types
1530 need not be compared. E.g. for structures the reported value is
1531 always "{...}", so no comparison is necessary here. If the old
1532 value was NULL and new one is not, or vice versa, we always return 1.
1534 The VALUE parameter should not be released -- the function will
1535 take care of releasing it when needed. */
1537 install_new_value (struct varobj
*var
, struct value
*value
, int initial
)
1542 int intentionally_not_fetched
= 0;
1543 char *print_value
= NULL
;
1545 /* We need to know the varobj's type to decide if the value should
1546 be fetched or not. C++ fake children (public/protected/private)
1547 don't have a type. */
1548 gdb_assert (var
->type
|| CPLUS_FAKE_CHILD (var
));
1549 changeable
= varobj_value_is_changeable_p (var
);
1551 /* If the type has custom visualizer, we consider it to be always
1552 changeable. FIXME: need to make sure this behaviour will not
1553 mess up read-sensitive values. */
1554 if (var
->pretty_printer
)
1557 need_to_fetch
= changeable
;
1559 /* We are not interested in the address of references, and given
1560 that in C++ a reference is not rebindable, it cannot
1561 meaningfully change. So, get hold of the real value. */
1563 value
= coerce_ref (value
);
1565 if (var
->type
&& TYPE_CODE (var
->type
) == TYPE_CODE_UNION
)
1566 /* For unions, we need to fetch the value implicitly because
1567 of implementation of union member fetch. When gdb
1568 creates a value for a field and the value of the enclosing
1569 structure is not lazy, it immediately copies the necessary
1570 bytes from the enclosing values. If the enclosing value is
1571 lazy, the call to value_fetch_lazy on the field will read
1572 the data from memory. For unions, that means we'll read the
1573 same memory more than once, which is not desirable. So
1577 /* The new value might be lazy. If the type is changeable,
1578 that is we'll be comparing values of this type, fetch the
1579 value now. Otherwise, on the next update the old value
1580 will be lazy, which means we've lost that old value. */
1581 if (need_to_fetch
&& value
&& value_lazy (value
))
1583 struct varobj
*parent
= var
->parent
;
1584 int frozen
= var
->frozen
;
1586 for (; !frozen
&& parent
; parent
= parent
->parent
)
1587 frozen
|= parent
->frozen
;
1589 if (frozen
&& initial
)
1591 /* For variables that are frozen, or are children of frozen
1592 variables, we don't do fetch on initial assignment.
1593 For non-initial assignemnt we do the fetch, since it means we're
1594 explicitly asked to compare the new value with the old one. */
1595 intentionally_not_fetched
= 1;
1597 else if (!gdb_value_fetch_lazy (value
))
1599 /* Set the value to NULL, so that for the next -var-update,
1600 we don't try to compare the new value with this value,
1601 that we couldn't even read. */
1606 /* Get a reference now, before possibly passing it to any Python
1607 code that might release it. */
1609 value_incref (value
);
1611 /* Below, we'll be comparing string rendering of old and new
1612 values. Don't get string rendering if the value is
1613 lazy -- if it is, the code above has decided that the value
1614 should not be fetched. */
1615 if (value
&& !value_lazy (value
) && !var
->pretty_printer
)
1616 print_value
= value_get_print_value (value
, var
->format
, var
);
1618 /* If the type is changeable, compare the old and the new values.
1619 If this is the initial assignment, we don't have any old value
1621 if (!initial
&& changeable
)
1623 /* If the value of the varobj was changed by -var-set-value,
1624 then the value in the varobj and in the target is the same.
1625 However, that value is different from the value that the
1626 varobj had after the previous -var-update. So need to the
1627 varobj as changed. */
1632 else if (! var
->pretty_printer
)
1634 /* Try to compare the values. That requires that both
1635 values are non-lazy. */
1636 if (var
->not_fetched
&& value_lazy (var
->value
))
1638 /* This is a frozen varobj and the value was never read.
1639 Presumably, UI shows some "never read" indicator.
1640 Now that we've fetched the real value, we need to report
1641 this varobj as changed so that UI can show the real
1645 else if (var
->value
== NULL
&& value
== NULL
)
1648 else if (var
->value
== NULL
|| value
== NULL
)
1654 gdb_assert (!value_lazy (var
->value
));
1655 gdb_assert (!value_lazy (value
));
1657 gdb_assert (var
->print_value
!= NULL
&& print_value
!= NULL
);
1658 if (strcmp (var
->print_value
, print_value
) != 0)
1664 if (!initial
&& !changeable
)
1666 /* For values that are not changeable, we don't compare the values.
1667 However, we want to notice if a value was not NULL and now is NULL,
1668 or vise versa, so that we report when top-level varobjs come in scope
1669 and leave the scope. */
1670 changed
= (var
->value
!= NULL
) != (value
!= NULL
);
1673 /* We must always keep the new value, since children depend on it. */
1674 if (var
->value
!= NULL
&& var
->value
!= value
)
1675 value_free (var
->value
);
1677 if (value
&& value_lazy (value
) && intentionally_not_fetched
)
1678 var
->not_fetched
= 1;
1680 var
->not_fetched
= 0;
1683 install_new_value_visualizer (var
);
1685 /* If we installed a pretty-printer, re-compare the printed version
1686 to see if the variable changed. */
1687 if (var
->pretty_printer
)
1689 xfree (print_value
);
1690 print_value
= value_get_print_value (var
->value
, var
->format
, var
);
1691 if ((var
->print_value
== NULL
&& print_value
!= NULL
)
1692 || (var
->print_value
!= NULL
&& print_value
== NULL
)
1693 || (var
->print_value
!= NULL
&& print_value
!= NULL
1694 && strcmp (var
->print_value
, print_value
) != 0))
1697 if (var
->print_value
)
1698 xfree (var
->print_value
);
1699 var
->print_value
= print_value
;
1701 gdb_assert (!var
->value
|| value_type (var
->value
));
1706 /* Return the requested range for a varobj. VAR is the varobj. FROM
1707 and TO are out parameters; *FROM and *TO will be set to the
1708 selected sub-range of VAR. If no range was selected using
1709 -var-set-update-range, then both will be -1. */
1711 varobj_get_child_range (struct varobj
*var
, int *from
, int *to
)
1717 /* Set the selected sub-range of children of VAR to start at index
1718 FROM and end at index TO. If either FROM or TO is less than zero,
1719 this is interpreted as a request for all children. */
1721 varobj_set_child_range (struct varobj
*var
, int from
, int to
)
1728 varobj_set_visualizer (struct varobj
*var
, const char *visualizer
)
1731 PyObject
*mainmod
, *globals
, *constructor
;
1732 struct cleanup
*back_to
;
1734 back_to
= varobj_ensure_python_env (var
);
1736 mainmod
= PyImport_AddModule ("__main__");
1737 globals
= PyModule_GetDict (mainmod
);
1738 Py_INCREF (globals
);
1739 make_cleanup_py_decref (globals
);
1741 constructor
= PyRun_String (visualizer
, Py_eval_input
, globals
, globals
);
1745 gdbpy_print_stack ();
1746 error (_("Could not evaluate visualizer expression: %s"), visualizer
);
1749 construct_visualizer (var
, constructor
);
1750 Py_XDECREF (constructor
);
1752 /* If there are any children now, wipe them. */
1753 varobj_delete (var
, NULL
, 1 /* children only */);
1754 var
->num_children
= -1;
1756 do_cleanups (back_to
);
1758 error (_("Python support required"));
1762 /* Update the values for a variable and its children. This is a
1763 two-pronged attack. First, re-parse the value for the root's
1764 expression to see if it's changed. Then go all the way
1765 through its children, reconstructing them and noting if they've
1768 The EXPLICIT parameter specifies if this call is result
1769 of MI request to update this specific variable, or
1770 result of implicit -var-update *. For implicit request, we don't
1771 update frozen variables.
1773 NOTE: This function may delete the caller's varobj. If it
1774 returns TYPE_CHANGED, then it has done this and VARP will be modified
1775 to point to the new varobj. */
1777 VEC(varobj_update_result
) *
1778 varobj_update (struct varobj
**varp
, int explicit)
1781 int type_changed
= 0;
1784 VEC (varobj_update_result
) *stack
= NULL
;
1785 VEC (varobj_update_result
) *result
= NULL
;
1787 /* Frozen means frozen -- we don't check for any change in
1788 this varobj, including its going out of scope, or
1789 changing type. One use case for frozen varobjs is
1790 retaining previously evaluated expressions, and we don't
1791 want them to be reevaluated at all. */
1792 if (!explicit && (*varp
)->frozen
)
1795 if (!(*varp
)->root
->is_valid
)
1797 varobj_update_result r
= {0};
1800 r
.status
= VAROBJ_INVALID
;
1801 VEC_safe_push (varobj_update_result
, result
, &r
);
1805 if ((*varp
)->root
->rootvar
== *varp
)
1807 varobj_update_result r
= {0};
1810 r
.status
= VAROBJ_IN_SCOPE
;
1812 /* Update the root variable. value_of_root can return NULL
1813 if the variable is no longer around, i.e. we stepped out of
1814 the frame in which a local existed. We are letting the
1815 value_of_root variable dispose of the varobj if the type
1817 new = value_of_root (varp
, &type_changed
);
1820 r
.type_changed
= type_changed
;
1821 if (install_new_value ((*varp
), new, type_changed
))
1825 r
.status
= VAROBJ_NOT_IN_SCOPE
;
1826 r
.value_installed
= 1;
1828 if (r
.status
== VAROBJ_NOT_IN_SCOPE
)
1830 if (r
.type_changed
|| r
.changed
)
1831 VEC_safe_push (varobj_update_result
, result
, &r
);
1835 VEC_safe_push (varobj_update_result
, stack
, &r
);
1839 varobj_update_result r
= {0};
1842 VEC_safe_push (varobj_update_result
, stack
, &r
);
1845 /* Walk through the children, reconstructing them all. */
1846 while (!VEC_empty (varobj_update_result
, stack
))
1848 varobj_update_result r
= *(VEC_last (varobj_update_result
, stack
));
1849 struct varobj
*v
= r
.varobj
;
1851 VEC_pop (varobj_update_result
, stack
);
1853 /* Update this variable, unless it's a root, which is already
1855 if (!r
.value_installed
)
1857 new = value_of_child (v
->parent
, v
->index
);
1858 if (install_new_value (v
, new, 0 /* type not changed */))
1865 /* We probably should not get children of a varobj that has a
1866 pretty-printer, but for which -var-list-children was never
1868 if (v
->pretty_printer
)
1870 VEC (varobj_p
) *changed
= 0, *new = 0, *unchanged
= 0;
1871 int i
, children_changed
= 0;
1876 if (!v
->children_requested
)
1880 /* If we initially did not have potential children, but
1881 now we do, consider the varobj as changed.
1882 Otherwise, if children were never requested, consider
1883 it as unchanged -- presumably, such varobj is not yet
1884 expanded in the UI, so we need not bother getting
1886 if (!varobj_has_more (v
, 0))
1888 update_dynamic_varobj_children (v
, NULL
, NULL
, NULL
,
1890 if (varobj_has_more (v
, 0))
1895 VEC_safe_push (varobj_update_result
, result
, &r
);
1900 /* If update_dynamic_varobj_children returns 0, then we have
1901 a non-conforming pretty-printer, so we skip it. */
1902 if (update_dynamic_varobj_children (v
, &changed
, &new, &unchanged
,
1903 &children_changed
, 1,
1906 if (children_changed
|| new)
1908 r
.children_changed
= 1;
1911 /* Push in reverse order so that the first child is
1912 popped from the work stack first, and so will be
1913 added to result first. This does not affect
1914 correctness, just "nicer". */
1915 for (i
= VEC_length (varobj_p
, changed
) - 1; i
>= 0; --i
)
1917 varobj_p tmp
= VEC_index (varobj_p
, changed
, i
);
1918 varobj_update_result r
= {0};
1922 r
.value_installed
= 1;
1923 VEC_safe_push (varobj_update_result
, stack
, &r
);
1925 for (i
= VEC_length (varobj_p
, unchanged
) - 1; i
>= 0; --i
)
1927 varobj_p tmp
= VEC_index (varobj_p
, unchanged
, i
);
1931 varobj_update_result r
= {0};
1934 r
.value_installed
= 1;
1935 VEC_safe_push (varobj_update_result
, stack
, &r
);
1938 if (r
.changed
|| r
.children_changed
)
1939 VEC_safe_push (varobj_update_result
, result
, &r
);
1941 /* Free CHANGED and UNCHANGED, but not NEW, because NEW
1942 has been put into the result vector. */
1943 VEC_free (varobj_p
, changed
);
1944 VEC_free (varobj_p
, unchanged
);
1950 /* Push any children. Use reverse order so that the first
1951 child is popped from the work stack first, and so
1952 will be added to result first. This does not
1953 affect correctness, just "nicer". */
1954 for (i
= VEC_length (varobj_p
, v
->children
)-1; i
>= 0; --i
)
1956 varobj_p c
= VEC_index (varobj_p
, v
->children
, i
);
1958 /* Child may be NULL if explicitly deleted by -var-delete. */
1959 if (c
!= NULL
&& !c
->frozen
)
1961 varobj_update_result r
= {0};
1964 VEC_safe_push (varobj_update_result
, stack
, &r
);
1968 if (r
.changed
|| r
.type_changed
)
1969 VEC_safe_push (varobj_update_result
, result
, &r
);
1972 VEC_free (varobj_update_result
, stack
);
1978 /* Helper functions */
1981 * Variable object construction/destruction
1985 delete_variable (struct cpstack
**resultp
, struct varobj
*var
,
1986 int only_children_p
)
1990 delete_variable_1 (resultp
, &delcount
, var
,
1991 only_children_p
, 1 /* remove_from_parent_p */ );
1996 /* Delete the variable object VAR and its children. */
1997 /* IMPORTANT NOTE: If we delete a variable which is a child
1998 and the parent is not removed we dump core. It must be always
1999 initially called with remove_from_parent_p set. */
2001 delete_variable_1 (struct cpstack
**resultp
, int *delcountp
,
2002 struct varobj
*var
, int only_children_p
,
2003 int remove_from_parent_p
)
2007 /* Delete any children of this variable, too. */
2008 for (i
= 0; i
< VEC_length (varobj_p
, var
->children
); ++i
)
2010 varobj_p child
= VEC_index (varobj_p
, var
->children
, i
);
2014 if (!remove_from_parent_p
)
2015 child
->parent
= NULL
;
2016 delete_variable_1 (resultp
, delcountp
, child
, 0, only_children_p
);
2018 VEC_free (varobj_p
, var
->children
);
2020 /* if we were called to delete only the children we are done here. */
2021 if (only_children_p
)
2024 /* Otherwise, add it to the list of deleted ones and proceed to do so. */
2025 /* If the name is null, this is a temporary variable, that has not
2026 yet been installed, don't report it, it belongs to the caller... */
2027 if (var
->obj_name
!= NULL
)
2029 cppush (resultp
, xstrdup (var
->obj_name
));
2030 *delcountp
= *delcountp
+ 1;
2033 /* If this variable has a parent, remove it from its parent's list. */
2034 /* OPTIMIZATION: if the parent of this variable is also being deleted,
2035 (as indicated by remove_from_parent_p) we don't bother doing an
2036 expensive list search to find the element to remove when we are
2037 discarding the list afterwards. */
2038 if ((remove_from_parent_p
) && (var
->parent
!= NULL
))
2040 VEC_replace (varobj_p
, var
->parent
->children
, var
->index
, NULL
);
2043 if (var
->obj_name
!= NULL
)
2044 uninstall_variable (var
);
2046 /* Free memory associated with this variable. */
2047 free_variable (var
);
2050 /* Install the given variable VAR with the object name VAR->OBJ_NAME. */
2052 install_variable (struct varobj
*var
)
2055 struct vlist
*newvl
;
2057 unsigned int index
= 0;
2060 for (chp
= var
->obj_name
; *chp
; chp
++)
2062 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
2065 cv
= *(varobj_table
+ index
);
2066 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, var
->obj_name
) != 0))
2070 error (_("Duplicate variable object name"));
2072 /* Add varobj to hash table. */
2073 newvl
= xmalloc (sizeof (struct vlist
));
2074 newvl
->next
= *(varobj_table
+ index
);
2076 *(varobj_table
+ index
) = newvl
;
2078 /* If root, add varobj to root list. */
2079 if (is_root_p (var
))
2081 /* Add to list of root variables. */
2082 if (rootlist
== NULL
)
2083 var
->root
->next
= NULL
;
2085 var
->root
->next
= rootlist
;
2086 rootlist
= var
->root
;
2092 /* Unistall the object VAR. */
2094 uninstall_variable (struct varobj
*var
)
2098 struct varobj_root
*cr
;
2099 struct varobj_root
*prer
;
2101 unsigned int index
= 0;
2104 /* Remove varobj from hash table. */
2105 for (chp
= var
->obj_name
; *chp
; chp
++)
2107 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
2110 cv
= *(varobj_table
+ index
);
2112 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, var
->obj_name
) != 0))
2119 fprintf_unfiltered (gdb_stdlog
, "Deleting %s\n", var
->obj_name
);
2124 ("Assertion failed: Could not find variable object \"%s\" to delete",
2130 *(varobj_table
+ index
) = cv
->next
;
2132 prev
->next
= cv
->next
;
2136 /* If root, remove varobj from root list. */
2137 if (is_root_p (var
))
2139 /* Remove from list of root variables. */
2140 if (rootlist
== var
->root
)
2141 rootlist
= var
->root
->next
;
2146 while ((cr
!= NULL
) && (cr
->rootvar
!= var
))
2153 warning (_("Assertion failed: Could not find "
2154 "varobj \"%s\" in root list"),
2161 prer
->next
= cr
->next
;
2167 /* Create and install a child of the parent of the given name. */
2168 static struct varobj
*
2169 create_child (struct varobj
*parent
, int index
, char *name
)
2171 return create_child_with_value (parent
, index
, name
,
2172 value_of_child (parent
, index
));
2175 static struct varobj
*
2176 create_child_with_value (struct varobj
*parent
, int index
, const char *name
,
2177 struct value
*value
)
2179 struct varobj
*child
;
2182 child
= new_variable ();
2184 /* Name is allocated by name_of_child. */
2185 /* FIXME: xstrdup should not be here. */
2186 child
->name
= xstrdup (name
);
2187 child
->index
= index
;
2188 child
->parent
= parent
;
2189 child
->root
= parent
->root
;
2190 childs_name
= xstrprintf ("%s.%s", parent
->obj_name
, name
);
2191 child
->obj_name
= childs_name
;
2192 install_variable (child
);
2194 /* Compute the type of the child. Must do this before
2195 calling install_new_value. */
2197 /* If the child had no evaluation errors, var->value
2198 will be non-NULL and contain a valid type. */
2199 child
->type
= value_type (value
);
2201 /* Otherwise, we must compute the type. */
2202 child
->type
= (*child
->root
->lang
->type_of_child
) (child
->parent
,
2204 install_new_value (child
, value
, 1);
2211 * Miscellaneous utility functions.
2214 /* Allocate memory and initialize a new variable. */
2215 static struct varobj
*
2220 var
= (struct varobj
*) xmalloc (sizeof (struct varobj
));
2222 var
->path_expr
= NULL
;
2223 var
->obj_name
= NULL
;
2227 var
->num_children
= -1;
2229 var
->children
= NULL
;
2233 var
->print_value
= NULL
;
2235 var
->not_fetched
= 0;
2236 var
->children_requested
= 0;
2239 var
->constructor
= 0;
2240 var
->pretty_printer
= 0;
2241 var
->child_iter
= 0;
2242 var
->saved_item
= 0;
2247 /* Allocate memory and initialize a new root variable. */
2248 static struct varobj
*
2249 new_root_variable (void)
2251 struct varobj
*var
= new_variable ();
2253 var
->root
= (struct varobj_root
*) xmalloc (sizeof (struct varobj_root
));
2254 var
->root
->lang
= NULL
;
2255 var
->root
->exp
= NULL
;
2256 var
->root
->valid_block
= NULL
;
2257 var
->root
->frame
= null_frame_id
;
2258 var
->root
->floating
= 0;
2259 var
->root
->rootvar
= NULL
;
2260 var
->root
->is_valid
= 1;
2265 /* Free any allocated memory associated with VAR. */
2267 free_variable (struct varobj
*var
)
2270 if (var
->pretty_printer
)
2272 struct cleanup
*cleanup
= varobj_ensure_python_env (var
);
2273 Py_XDECREF (var
->constructor
);
2274 Py_XDECREF (var
->pretty_printer
);
2275 Py_XDECREF (var
->child_iter
);
2276 Py_XDECREF (var
->saved_item
);
2277 do_cleanups (cleanup
);
2281 value_free (var
->value
);
2283 /* Free the expression if this is a root variable. */
2284 if (is_root_p (var
))
2286 xfree (var
->root
->exp
);
2291 xfree (var
->obj_name
);
2292 xfree (var
->print_value
);
2293 xfree (var
->path_expr
);
2298 do_free_variable_cleanup (void *var
)
2300 free_variable (var
);
2303 static struct cleanup
*
2304 make_cleanup_free_variable (struct varobj
*var
)
2306 return make_cleanup (do_free_variable_cleanup
, var
);
2309 /* This returns the type of the variable. It also skips past typedefs
2310 to return the real type of the variable.
2312 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
2313 except within get_target_type and get_type. */
2314 static struct type
*
2315 get_type (struct varobj
*var
)
2321 type
= check_typedef (type
);
2326 /* Return the type of the value that's stored in VAR,
2327 or that would have being stored there if the
2328 value were accessible.
2330 This differs from VAR->type in that VAR->type is always
2331 the true type of the expession in the source language.
2332 The return value of this function is the type we're
2333 actually storing in varobj, and using for displaying
2334 the values and for comparing previous and new values.
2336 For example, top-level references are always stripped. */
2337 static struct type
*
2338 get_value_type (struct varobj
*var
)
2343 type
= value_type (var
->value
);
2347 type
= check_typedef (type
);
2349 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
2350 type
= get_target_type (type
);
2352 type
= check_typedef (type
);
2357 /* This returns the target type (or NULL) of TYPE, also skipping
2358 past typedefs, just like get_type ().
2360 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
2361 except within get_target_type and get_type. */
2362 static struct type
*
2363 get_target_type (struct type
*type
)
2367 type
= TYPE_TARGET_TYPE (type
);
2369 type
= check_typedef (type
);
2375 /* What is the default display for this variable? We assume that
2376 everything is "natural". Any exceptions? */
2377 static enum varobj_display_formats
2378 variable_default_display (struct varobj
*var
)
2380 return FORMAT_NATURAL
;
2383 /* FIXME: The following should be generic for any pointer. */
2385 cppush (struct cpstack
**pstack
, char *name
)
2389 s
= (struct cpstack
*) xmalloc (sizeof (struct cpstack
));
2395 /* FIXME: The following should be generic for any pointer. */
2397 cppop (struct cpstack
**pstack
)
2402 if ((*pstack
)->name
== NULL
&& (*pstack
)->next
== NULL
)
2407 *pstack
= (*pstack
)->next
;
2414 * Language-dependencies
2417 /* Common entry points */
2419 /* Get the language of variable VAR. */
2420 static enum varobj_languages
2421 variable_language (struct varobj
*var
)
2423 enum varobj_languages lang
;
2425 switch (var
->root
->exp
->language_defn
->la_language
)
2431 case language_cplus
:
2445 /* Return the number of children for a given variable.
2446 The result of this function is defined by the language
2447 implementation. The number of children returned by this function
2448 is the number of children that the user will see in the variable
2451 number_of_children (struct varobj
*var
)
2453 return (*var
->root
->lang
->number_of_children
) (var
);
2456 /* What is the expression for the root varobj VAR? Returns a malloc'd
2459 name_of_variable (struct varobj
*var
)
2461 return (*var
->root
->lang
->name_of_variable
) (var
);
2464 /* What is the name of the INDEX'th child of VAR? Returns a malloc'd
2467 name_of_child (struct varobj
*var
, int index
)
2469 return (*var
->root
->lang
->name_of_child
) (var
, index
);
2472 /* What is the ``struct value *'' of the root variable VAR?
2473 For floating variable object, evaluation can get us a value
2474 of different type from what is stored in varobj already. In
2476 - *type_changed will be set to 1
2477 - old varobj will be freed, and new one will be
2478 created, with the same name.
2479 - *var_handle will be set to the new varobj
2480 Otherwise, *type_changed will be set to 0. */
2481 static struct value
*
2482 value_of_root (struct varobj
**var_handle
, int *type_changed
)
2486 if (var_handle
== NULL
)
2491 /* This should really be an exception, since this should
2492 only get called with a root variable. */
2494 if (!is_root_p (var
))
2497 if (var
->root
->floating
)
2499 struct varobj
*tmp_var
;
2500 char *old_type
, *new_type
;
2502 tmp_var
= varobj_create (NULL
, var
->name
, (CORE_ADDR
) 0,
2503 USE_SELECTED_FRAME
);
2504 if (tmp_var
== NULL
)
2508 old_type
= varobj_get_type (var
);
2509 new_type
= varobj_get_type (tmp_var
);
2510 if (strcmp (old_type
, new_type
) == 0)
2512 /* The expression presently stored inside var->root->exp
2513 remembers the locations of local variables relatively to
2514 the frame where the expression was created (in DWARF location
2515 button, for example). Naturally, those locations are not
2516 correct in other frames, so update the expression. */
2518 struct expression
*tmp_exp
= var
->root
->exp
;
2520 var
->root
->exp
= tmp_var
->root
->exp
;
2521 tmp_var
->root
->exp
= tmp_exp
;
2523 varobj_delete (tmp_var
, NULL
, 0);
2528 tmp_var
->obj_name
= xstrdup (var
->obj_name
);
2529 tmp_var
->from
= var
->from
;
2530 tmp_var
->to
= var
->to
;
2531 varobj_delete (var
, NULL
, 0);
2533 install_variable (tmp_var
);
2534 *var_handle
= tmp_var
;
2546 return (*var
->root
->lang
->value_of_root
) (var_handle
);
2549 /* What is the ``struct value *'' for the INDEX'th child of PARENT? */
2550 static struct value
*
2551 value_of_child (struct varobj
*parent
, int index
)
2553 struct value
*value
;
2555 value
= (*parent
->root
->lang
->value_of_child
) (parent
, index
);
2560 /* GDB already has a command called "value_of_variable". Sigh. */
2562 my_value_of_variable (struct varobj
*var
, enum varobj_display_formats format
)
2564 if (var
->root
->is_valid
)
2566 if (var
->pretty_printer
)
2567 return value_get_print_value (var
->value
, var
->format
, var
);
2568 return (*var
->root
->lang
->value_of_variable
) (var
, format
);
2575 value_get_print_value (struct value
*value
, enum varobj_display_formats format
,
2578 struct ui_file
*stb
;
2579 struct cleanup
*old_chain
;
2580 gdb_byte
*thevalue
= NULL
;
2581 struct value_print_options opts
;
2582 struct type
*type
= NULL
;
2584 char *encoding
= NULL
;
2585 struct gdbarch
*gdbarch
= NULL
;
2586 /* Initialize it just to avoid a GCC false warning. */
2587 CORE_ADDR str_addr
= 0;
2588 int string_print
= 0;
2593 stb
= mem_fileopen ();
2594 old_chain
= make_cleanup_ui_file_delete (stb
);
2596 gdbarch
= get_type_arch (value_type (value
));
2599 PyObject
*value_formatter
= var
->pretty_printer
;
2601 varobj_ensure_python_env (var
);
2603 if (value_formatter
)
2605 /* First check to see if we have any children at all. If so,
2606 we simply return {...}. */
2607 if (dynamic_varobj_has_child_method (var
))
2609 do_cleanups (old_chain
);
2610 return xstrdup ("{...}");
2613 if (PyObject_HasAttr (value_formatter
, gdbpy_to_string_cst
))
2615 struct value
*replacement
;
2616 PyObject
*output
= NULL
;
2618 output
= apply_varobj_pretty_printer (value_formatter
,
2622 /* If we have string like output ... */
2625 make_cleanup_py_decref (output
);
2627 /* If this is a lazy string, extract it. For lazy
2628 strings we always print as a string, so set
2630 if (gdbpy_is_lazy_string (output
))
2632 gdbpy_extract_lazy_string (output
, &str_addr
, &type
,
2634 make_cleanup (free_current_contents
, &encoding
);
2639 /* If it is a regular (non-lazy) string, extract
2640 it and copy the contents into THEVALUE. If the
2641 hint says to print it as a string, set
2642 string_print. Otherwise just return the extracted
2643 string as a value. */
2646 = python_string_to_target_python_string (output
);
2650 char *s
= PyString_AsString (py_str
);
2653 hint
= gdbpy_get_display_hint (value_formatter
);
2656 if (!strcmp (hint
, "string"))
2661 len
= PyString_Size (py_str
);
2662 thevalue
= xmemdup (s
, len
+ 1, len
+ 1);
2663 type
= builtin_type (gdbarch
)->builtin_char
;
2668 do_cleanups (old_chain
);
2672 make_cleanup (xfree
, thevalue
);
2675 gdbpy_print_stack ();
2678 /* If the printer returned a replacement value, set VALUE
2679 to REPLACEMENT. If there is not a replacement value,
2680 just use the value passed to this function. */
2682 value
= replacement
;
2688 get_formatted_print_options (&opts
, format_code
[(int) format
]);
2692 /* If the THEVALUE has contents, it is a regular string. */
2694 LA_PRINT_STRING (stb
, type
, thevalue
, len
, encoding
, 0, &opts
);
2695 else if (string_print
)
2696 /* Otherwise, if string_print is set, and it is not a regular
2697 string, it is a lazy string. */
2698 val_print_string (type
, encoding
, str_addr
, len
, stb
, &opts
);
2700 /* All other cases. */
2701 common_val_print (value
, stb
, 0, &opts
, current_language
);
2703 thevalue
= ui_file_xstrdup (stb
, NULL
);
2705 do_cleanups (old_chain
);
2710 varobj_editable_p (struct varobj
*var
)
2714 if (!(var
->root
->is_valid
&& var
->value
&& VALUE_LVAL (var
->value
)))
2717 type
= get_value_type (var
);
2719 switch (TYPE_CODE (type
))
2721 case TYPE_CODE_STRUCT
:
2722 case TYPE_CODE_UNION
:
2723 case TYPE_CODE_ARRAY
:
2724 case TYPE_CODE_FUNC
:
2725 case TYPE_CODE_METHOD
:
2735 /* Return non-zero if changes in value of VAR
2736 must be detected and reported by -var-update.
2737 Return zero is -var-update should never report
2738 changes of such values. This makes sense for structures
2739 (since the changes in children values will be reported separately),
2740 or for artifical objects (like 'public' pseudo-field in C++).
2742 Return value of 0 means that gdb need not call value_fetch_lazy
2743 for the value of this variable object. */
2745 varobj_value_is_changeable_p (struct varobj
*var
)
2750 if (CPLUS_FAKE_CHILD (var
))
2753 type
= get_value_type (var
);
2755 switch (TYPE_CODE (type
))
2757 case TYPE_CODE_STRUCT
:
2758 case TYPE_CODE_UNION
:
2759 case TYPE_CODE_ARRAY
:
2770 /* Return 1 if that varobj is floating, that is is always evaluated in the
2771 selected frame, and not bound to thread/frame. Such variable objects
2772 are created using '@' as frame specifier to -var-create. */
2774 varobj_floating_p (struct varobj
*var
)
2776 return var
->root
->floating
;
2779 /* Given the value and the type of a variable object,
2780 adjust the value and type to those necessary
2781 for getting children of the variable object.
2782 This includes dereferencing top-level references
2783 to all types and dereferencing pointers to
2786 Both TYPE and *TYPE should be non-null. VALUE
2787 can be null if we want to only translate type.
2788 *VALUE can be null as well -- if the parent
2791 If WAS_PTR is not NULL, set *WAS_PTR to 0 or 1
2792 depending on whether pointer was dereferenced
2793 in this function. */
2795 adjust_value_for_child_access (struct value
**value
,
2799 gdb_assert (type
&& *type
);
2804 *type
= check_typedef (*type
);
2806 /* The type of value stored in varobj, that is passed
2807 to us, is already supposed to be
2808 reference-stripped. */
2810 gdb_assert (TYPE_CODE (*type
) != TYPE_CODE_REF
);
2812 /* Pointers to structures are treated just like
2813 structures when accessing children. Don't
2814 dererences pointers to other types. */
2815 if (TYPE_CODE (*type
) == TYPE_CODE_PTR
)
2817 struct type
*target_type
= get_target_type (*type
);
2818 if (TYPE_CODE (target_type
) == TYPE_CODE_STRUCT
2819 || TYPE_CODE (target_type
) == TYPE_CODE_UNION
)
2821 if (value
&& *value
)
2823 int success
= gdb_value_ind (*value
, value
);
2828 *type
= target_type
;
2834 /* The 'get_target_type' function calls check_typedef on
2835 result, so we can immediately check type code. No
2836 need to call check_typedef here. */
2841 c_number_of_children (struct varobj
*var
)
2843 struct type
*type
= get_value_type (var
);
2845 struct type
*target
;
2847 adjust_value_for_child_access (NULL
, &type
, NULL
);
2848 target
= get_target_type (type
);
2850 switch (TYPE_CODE (type
))
2852 case TYPE_CODE_ARRAY
:
2853 if (TYPE_LENGTH (type
) > 0 && TYPE_LENGTH (target
) > 0
2854 && !TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type
))
2855 children
= TYPE_LENGTH (type
) / TYPE_LENGTH (target
);
2857 /* If we don't know how many elements there are, don't display
2862 case TYPE_CODE_STRUCT
:
2863 case TYPE_CODE_UNION
:
2864 children
= TYPE_NFIELDS (type
);
2868 /* The type here is a pointer to non-struct. Typically, pointers
2869 have one child, except for function ptrs, which have no children,
2870 and except for void*, as we don't know what to show.
2872 We can show char* so we allow it to be dereferenced. If you decide
2873 to test for it, please mind that a little magic is necessary to
2874 properly identify it: char* has TYPE_CODE == TYPE_CODE_INT and
2875 TYPE_NAME == "char". */
2876 if (TYPE_CODE (target
) == TYPE_CODE_FUNC
2877 || TYPE_CODE (target
) == TYPE_CODE_VOID
)
2884 /* Other types have no children. */
2892 c_name_of_variable (struct varobj
*parent
)
2894 return xstrdup (parent
->name
);
2897 /* Return the value of element TYPE_INDEX of a structure
2898 value VALUE. VALUE's type should be a structure,
2899 or union, or a typedef to struct/union.
2901 Returns NULL if getting the value fails. Never throws. */
2902 static struct value
*
2903 value_struct_element_index (struct value
*value
, int type_index
)
2905 struct value
*result
= NULL
;
2906 volatile struct gdb_exception e
;
2907 struct type
*type
= value_type (value
);
2909 type
= check_typedef (type
);
2911 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
2912 || TYPE_CODE (type
) == TYPE_CODE_UNION
);
2914 TRY_CATCH (e
, RETURN_MASK_ERROR
)
2916 if (field_is_static (&TYPE_FIELD (type
, type_index
)))
2917 result
= value_static_field (type
, type_index
);
2919 result
= value_primitive_field (value
, 0, type_index
, type
);
2931 /* Obtain the information about child INDEX of the variable
2933 If CNAME is not null, sets *CNAME to the name of the child relative
2935 If CVALUE is not null, sets *CVALUE to the value of the child.
2936 If CTYPE is not null, sets *CTYPE to the type of the child.
2938 If any of CNAME, CVALUE, or CTYPE is not null, but the corresponding
2939 information cannot be determined, set *CNAME, *CVALUE, or *CTYPE
2942 c_describe_child (struct varobj
*parent
, int index
,
2943 char **cname
, struct value
**cvalue
, struct type
**ctype
,
2944 char **cfull_expression
)
2946 struct value
*value
= parent
->value
;
2947 struct type
*type
= get_value_type (parent
);
2948 char *parent_expression
= NULL
;
2957 if (cfull_expression
)
2959 *cfull_expression
= NULL
;
2960 parent_expression
= varobj_get_path_expr (parent
);
2962 adjust_value_for_child_access (&value
, &type
, &was_ptr
);
2964 switch (TYPE_CODE (type
))
2966 case TYPE_CODE_ARRAY
:
2969 = xstrdup (int_string (index
2970 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
)),
2973 if (cvalue
&& value
)
2975 int real_index
= index
+ TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
));
2977 gdb_value_subscript (value
, real_index
, cvalue
);
2981 *ctype
= get_target_type (type
);
2983 if (cfull_expression
)
2985 xstrprintf ("(%s)[%s]", parent_expression
,
2987 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
)),
2993 case TYPE_CODE_STRUCT
:
2994 case TYPE_CODE_UNION
:
2996 *cname
= xstrdup (TYPE_FIELD_NAME (type
, index
));
2998 if (cvalue
&& value
)
3000 /* For C, varobj index is the same as type index. */
3001 *cvalue
= value_struct_element_index (value
, index
);
3005 *ctype
= TYPE_FIELD_TYPE (type
, index
);
3007 if (cfull_expression
)
3009 char *join
= was_ptr
? "->" : ".";
3011 *cfull_expression
= xstrprintf ("(%s)%s%s", parent_expression
, join
,
3012 TYPE_FIELD_NAME (type
, index
));
3019 *cname
= xstrprintf ("*%s", parent
->name
);
3021 if (cvalue
&& value
)
3023 int success
= gdb_value_ind (value
, cvalue
);
3029 /* Don't use get_target_type because it calls
3030 check_typedef and here, we want to show the true
3031 declared type of the variable. */
3033 *ctype
= TYPE_TARGET_TYPE (type
);
3035 if (cfull_expression
)
3036 *cfull_expression
= xstrprintf ("*(%s)", parent_expression
);
3041 /* This should not happen. */
3043 *cname
= xstrdup ("???");
3044 if (cfull_expression
)
3045 *cfull_expression
= xstrdup ("???");
3046 /* Don't set value and type, we don't know then. */
3051 c_name_of_child (struct varobj
*parent
, int index
)
3055 c_describe_child (parent
, index
, &name
, NULL
, NULL
, NULL
);
3060 c_path_expr_of_child (struct varobj
*child
)
3062 c_describe_child (child
->parent
, child
->index
, NULL
, NULL
, NULL
,
3064 return child
->path_expr
;
3067 /* If frame associated with VAR can be found, switch
3068 to it and return 1. Otherwise, return 0. */
3070 check_scope (struct varobj
*var
)
3072 struct frame_info
*fi
;
3075 fi
= frame_find_by_id (var
->root
->frame
);
3080 CORE_ADDR pc
= get_frame_pc (fi
);
3082 if (pc
< BLOCK_START (var
->root
->valid_block
) ||
3083 pc
>= BLOCK_END (var
->root
->valid_block
))
3091 static struct value
*
3092 c_value_of_root (struct varobj
**var_handle
)
3094 struct value
*new_val
= NULL
;
3095 struct varobj
*var
= *var_handle
;
3096 int within_scope
= 0;
3097 struct cleanup
*back_to
;
3099 /* Only root variables can be updated... */
3100 if (!is_root_p (var
))
3101 /* Not a root var. */
3104 back_to
= make_cleanup_restore_current_thread ();
3106 /* Determine whether the variable is still around. */
3107 if (var
->root
->valid_block
== NULL
|| var
->root
->floating
)
3109 else if (var
->root
->thread_id
== 0)
3111 /* The program was single-threaded when the variable object was
3112 created. Technically, it's possible that the program became
3113 multi-threaded since then, but we don't support such
3115 within_scope
= check_scope (var
);
3119 ptid_t ptid
= thread_id_to_pid (var
->root
->thread_id
);
3120 if (in_thread_list (ptid
))
3122 switch_to_thread (ptid
);
3123 within_scope
= check_scope (var
);
3129 /* We need to catch errors here, because if evaluate
3130 expression fails we want to just return NULL. */
3131 gdb_evaluate_expression (var
->root
->exp
, &new_val
);
3135 do_cleanups (back_to
);
3140 static struct value
*
3141 c_value_of_child (struct varobj
*parent
, int index
)
3143 struct value
*value
= NULL
;
3145 c_describe_child (parent
, index
, NULL
, &value
, NULL
, NULL
);
3149 static struct type
*
3150 c_type_of_child (struct varobj
*parent
, int index
)
3152 struct type
*type
= NULL
;
3154 c_describe_child (parent
, index
, NULL
, NULL
, &type
, NULL
);
3159 c_value_of_variable (struct varobj
*var
, enum varobj_display_formats format
)
3161 /* BOGUS: if val_print sees a struct/class, or a reference to one,
3162 it will print out its children instead of "{...}". So we need to
3163 catch that case explicitly. */
3164 struct type
*type
= get_type (var
);
3166 /* If we have a custom formatter, return whatever string it has
3168 if (var
->pretty_printer
&& var
->print_value
)
3169 return xstrdup (var
->print_value
);
3171 /* Strip top-level references. */
3172 while (TYPE_CODE (type
) == TYPE_CODE_REF
)
3173 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3175 switch (TYPE_CODE (type
))
3177 case TYPE_CODE_STRUCT
:
3178 case TYPE_CODE_UNION
:
3179 return xstrdup ("{...}");
3182 case TYPE_CODE_ARRAY
:
3186 number
= xstrprintf ("[%d]", var
->num_children
);
3193 if (var
->value
== NULL
)
3195 /* This can happen if we attempt to get the value of a struct
3196 member when the parent is an invalid pointer. This is an
3197 error condition, so we should tell the caller. */
3202 if (var
->not_fetched
&& value_lazy (var
->value
))
3203 /* Frozen variable and no value yet. We don't
3204 implicitly fetch the value. MI response will
3205 use empty string for the value, which is OK. */
3208 gdb_assert (varobj_value_is_changeable_p (var
));
3209 gdb_assert (!value_lazy (var
->value
));
3211 /* If the specified format is the current one,
3212 we can reuse print_value. */
3213 if (format
== var
->format
)
3214 return xstrdup (var
->print_value
);
3216 return value_get_print_value (var
->value
, format
, var
);
3226 cplus_number_of_children (struct varobj
*var
)
3229 int children
, dont_know
;
3234 if (!CPLUS_FAKE_CHILD (var
))
3236 type
= get_value_type (var
);
3237 adjust_value_for_child_access (NULL
, &type
, NULL
);
3239 if (((TYPE_CODE (type
)) == TYPE_CODE_STRUCT
) ||
3240 ((TYPE_CODE (type
)) == TYPE_CODE_UNION
))
3244 cplus_class_num_children (type
, kids
);
3245 if (kids
[v_public
] != 0)
3247 if (kids
[v_private
] != 0)
3249 if (kids
[v_protected
] != 0)
3252 /* Add any baseclasses. */
3253 children
+= TYPE_N_BASECLASSES (type
);
3256 /* FIXME: save children in var. */
3263 type
= get_value_type (var
->parent
);
3264 adjust_value_for_child_access (NULL
, &type
, NULL
);
3266 cplus_class_num_children (type
, kids
);
3267 if (strcmp (var
->name
, "public") == 0)
3268 children
= kids
[v_public
];
3269 else if (strcmp (var
->name
, "private") == 0)
3270 children
= kids
[v_private
];
3272 children
= kids
[v_protected
];
3277 children
= c_number_of_children (var
);
3282 /* Compute # of public, private, and protected variables in this class.
3283 That means we need to descend into all baseclasses and find out
3284 how many are there, too. */
3286 cplus_class_num_children (struct type
*type
, int children
[3])
3288 int i
, vptr_fieldno
;
3289 struct type
*basetype
= NULL
;
3291 children
[v_public
] = 0;
3292 children
[v_private
] = 0;
3293 children
[v_protected
] = 0;
3295 vptr_fieldno
= get_vptr_fieldno (type
, &basetype
);
3296 for (i
= TYPE_N_BASECLASSES (type
); i
< TYPE_NFIELDS (type
); i
++)
3298 /* If we have a virtual table pointer, omit it. Even if virtual
3299 table pointers are not specifically marked in the debug info,
3300 they should be artificial. */
3301 if ((type
== basetype
&& i
== vptr_fieldno
)
3302 || TYPE_FIELD_ARTIFICIAL (type
, i
))
3305 if (TYPE_FIELD_PROTECTED (type
, i
))
3306 children
[v_protected
]++;
3307 else if (TYPE_FIELD_PRIVATE (type
, i
))
3308 children
[v_private
]++;
3310 children
[v_public
]++;
3315 cplus_name_of_variable (struct varobj
*parent
)
3317 return c_name_of_variable (parent
);
3320 enum accessibility
{ private_field
, protected_field
, public_field
};
3322 /* Check if field INDEX of TYPE has the specified accessibility.
3323 Return 0 if so and 1 otherwise. */
3325 match_accessibility (struct type
*type
, int index
, enum accessibility acc
)
3327 if (acc
== private_field
&& TYPE_FIELD_PRIVATE (type
, index
))
3329 else if (acc
== protected_field
&& TYPE_FIELD_PROTECTED (type
, index
))
3331 else if (acc
== public_field
&& !TYPE_FIELD_PRIVATE (type
, index
)
3332 && !TYPE_FIELD_PROTECTED (type
, index
))
3339 cplus_describe_child (struct varobj
*parent
, int index
,
3340 char **cname
, struct value
**cvalue
, struct type
**ctype
,
3341 char **cfull_expression
)
3343 struct value
*value
;
3346 char *parent_expression
= NULL
;
3354 if (cfull_expression
)
3355 *cfull_expression
= NULL
;
3357 if (CPLUS_FAKE_CHILD (parent
))
3359 value
= parent
->parent
->value
;
3360 type
= get_value_type (parent
->parent
);
3361 if (cfull_expression
)
3362 parent_expression
= varobj_get_path_expr (parent
->parent
);
3366 value
= parent
->value
;
3367 type
= get_value_type (parent
);
3368 if (cfull_expression
)
3369 parent_expression
= varobj_get_path_expr (parent
);
3372 adjust_value_for_child_access (&value
, &type
, &was_ptr
);
3374 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
3375 || TYPE_CODE (type
) == TYPE_CODE_UNION
)
3377 char *join
= was_ptr
? "->" : ".";
3379 if (CPLUS_FAKE_CHILD (parent
))
3381 /* The fields of the class type are ordered as they
3382 appear in the class. We are given an index for a
3383 particular access control type ("public","protected",
3384 or "private"). We must skip over fields that don't
3385 have the access control we are looking for to properly
3386 find the indexed field. */
3387 int type_index
= TYPE_N_BASECLASSES (type
);
3388 enum accessibility acc
= public_field
;
3390 struct type
*basetype
= NULL
;
3392 vptr_fieldno
= get_vptr_fieldno (type
, &basetype
);
3393 if (strcmp (parent
->name
, "private") == 0)
3394 acc
= private_field
;
3395 else if (strcmp (parent
->name
, "protected") == 0)
3396 acc
= protected_field
;
3400 if ((type
== basetype
&& type_index
== vptr_fieldno
)
3401 || TYPE_FIELD_ARTIFICIAL (type
, type_index
))
3403 else if (match_accessibility (type
, type_index
, acc
))
3410 *cname
= xstrdup (TYPE_FIELD_NAME (type
, type_index
));
3412 if (cvalue
&& value
)
3413 *cvalue
= value_struct_element_index (value
, type_index
);
3416 *ctype
= TYPE_FIELD_TYPE (type
, type_index
);
3418 if (cfull_expression
)
3420 = xstrprintf ("((%s)%s%s)", parent_expression
,
3422 TYPE_FIELD_NAME (type
, type_index
));
3424 else if (index
< TYPE_N_BASECLASSES (type
))
3426 /* This is a baseclass. */
3428 *cname
= xstrdup (TYPE_FIELD_NAME (type
, index
));
3430 if (cvalue
&& value
)
3431 *cvalue
= value_cast (TYPE_FIELD_TYPE (type
, index
), value
);
3435 *ctype
= TYPE_FIELD_TYPE (type
, index
);
3438 if (cfull_expression
)
3440 char *ptr
= was_ptr
? "*" : "";
3442 /* Cast the parent to the base' type. Note that in gdb,
3445 will create an lvalue, for all appearences, so we don't
3446 need to use more fancy:
3450 When we are in the scope of the base class or of one
3451 of its children, the type field name will be interpreted
3452 as a constructor, if it exists. Therefore, we must
3453 indicate that the name is a class name by using the
3454 'class' keyword. See PR mi/11912 */
3455 *cfull_expression
= xstrprintf ("(%s(class %s%s) %s)",
3457 TYPE_FIELD_NAME (type
, index
),
3464 char *access
= NULL
;
3467 cplus_class_num_children (type
, children
);
3469 /* Everything beyond the baseclasses can
3470 only be "public", "private", or "protected"
3472 The special "fake" children are always output by varobj in
3473 this order. So if INDEX == 2, it MUST be "protected". */
3474 index
-= TYPE_N_BASECLASSES (type
);
3478 if (children
[v_public
] > 0)
3480 else if (children
[v_private
] > 0)
3483 access
= "protected";
3486 if (children
[v_public
] > 0)
3488 if (children
[v_private
] > 0)
3491 access
= "protected";
3493 else if (children
[v_private
] > 0)
3494 access
= "protected";
3497 /* Must be protected. */
3498 access
= "protected";
3505 gdb_assert (access
);
3507 *cname
= xstrdup (access
);
3509 /* Value and type and full expression are null here. */
3514 c_describe_child (parent
, index
, cname
, cvalue
, ctype
, cfull_expression
);
3519 cplus_name_of_child (struct varobj
*parent
, int index
)
3523 cplus_describe_child (parent
, index
, &name
, NULL
, NULL
, NULL
);
3528 cplus_path_expr_of_child (struct varobj
*child
)
3530 cplus_describe_child (child
->parent
, child
->index
, NULL
, NULL
, NULL
,
3532 return child
->path_expr
;
3535 static struct value
*
3536 cplus_value_of_root (struct varobj
**var_handle
)
3538 return c_value_of_root (var_handle
);
3541 static struct value
*
3542 cplus_value_of_child (struct varobj
*parent
, int index
)
3544 struct value
*value
= NULL
;
3546 cplus_describe_child (parent
, index
, NULL
, &value
, NULL
, NULL
);
3550 static struct type
*
3551 cplus_type_of_child (struct varobj
*parent
, int index
)
3553 struct type
*type
= NULL
;
3555 cplus_describe_child (parent
, index
, NULL
, NULL
, &type
, NULL
);
3560 cplus_value_of_variable (struct varobj
*var
,
3561 enum varobj_display_formats format
)
3564 /* If we have one of our special types, don't print out
3566 if (CPLUS_FAKE_CHILD (var
))
3567 return xstrdup ("");
3569 return c_value_of_variable (var
, format
);
3575 java_number_of_children (struct varobj
*var
)
3577 return cplus_number_of_children (var
);
3581 java_name_of_variable (struct varobj
*parent
)
3585 name
= cplus_name_of_variable (parent
);
3586 /* If the name has "-" in it, it is because we
3587 needed to escape periods in the name... */
3590 while (*p
!= '\000')
3601 java_name_of_child (struct varobj
*parent
, int index
)
3605 name
= cplus_name_of_child (parent
, index
);
3606 /* Escape any periods in the name... */
3609 while (*p
!= '\000')
3620 java_path_expr_of_child (struct varobj
*child
)
3625 static struct value
*
3626 java_value_of_root (struct varobj
**var_handle
)
3628 return cplus_value_of_root (var_handle
);
3631 static struct value
*
3632 java_value_of_child (struct varobj
*parent
, int index
)
3634 return cplus_value_of_child (parent
, index
);
3637 static struct type
*
3638 java_type_of_child (struct varobj
*parent
, int index
)
3640 return cplus_type_of_child (parent
, index
);
3644 java_value_of_variable (struct varobj
*var
, enum varobj_display_formats format
)
3646 return cplus_value_of_variable (var
, format
);
3649 /* Ada specific callbacks for VAROBJs. */
3652 ada_number_of_children (struct varobj
*var
)
3654 return c_number_of_children (var
);
3658 ada_name_of_variable (struct varobj
*parent
)
3660 return c_name_of_variable (parent
);
3664 ada_name_of_child (struct varobj
*parent
, int index
)
3666 return c_name_of_child (parent
, index
);
3670 ada_path_expr_of_child (struct varobj
*child
)
3672 return c_path_expr_of_child (child
);
3675 static struct value
*
3676 ada_value_of_root (struct varobj
**var_handle
)
3678 return c_value_of_root (var_handle
);
3681 static struct value
*
3682 ada_value_of_child (struct varobj
*parent
, int index
)
3684 return c_value_of_child (parent
, index
);
3687 static struct type
*
3688 ada_type_of_child (struct varobj
*parent
, int index
)
3690 return c_type_of_child (parent
, index
);
3694 ada_value_of_variable (struct varobj
*var
, enum varobj_display_formats format
)
3696 return c_value_of_variable (var
, format
);
3699 /* Iterate all the existing _root_ VAROBJs and call the FUNC callback for them
3700 with an arbitrary caller supplied DATA pointer. */
3703 all_root_varobjs (void (*func
) (struct varobj
*var
, void *data
), void *data
)
3705 struct varobj_root
*var_root
, *var_root_next
;
3707 /* Iterate "safely" - handle if the callee deletes its passed VAROBJ. */
3709 for (var_root
= rootlist
; var_root
!= NULL
; var_root
= var_root_next
)
3711 var_root_next
= var_root
->next
;
3713 (*func
) (var_root
->rootvar
, data
);
3717 extern void _initialize_varobj (void);
3719 _initialize_varobj (void)
3721 int sizeof_table
= sizeof (struct vlist
*) * VAROBJ_TABLE_SIZE
;
3723 varobj_table
= xmalloc (sizeof_table
);
3724 memset (varobj_table
, 0, sizeof_table
);
3726 add_setshow_zinteger_cmd ("debugvarobj", class_maintenance
,
3728 _("Set varobj debugging."),
3729 _("Show varobj debugging."),
3730 _("When non-zero, varobj debugging is enabled."),
3731 NULL
, show_varobjdebug
,
3732 &setlist
, &showlist
);
3735 /* Invalidate varobj VAR if it is tied to locals and re-create it if it is
3736 defined on globals. It is a helper for varobj_invalidate. */
3739 varobj_invalidate_iter (struct varobj
*var
, void *unused
)
3741 /* Floating varobjs are reparsed on each stop, so we don't care if the
3742 presently parsed expression refers to something that's gone. */
3743 if (var
->root
->floating
)
3746 /* global var must be re-evaluated. */
3747 if (var
->root
->valid_block
== NULL
)
3749 struct varobj
*tmp_var
;
3751 /* Try to create a varobj with same expression. If we succeed
3752 replace the old varobj, otherwise invalidate it. */
3753 tmp_var
= varobj_create (NULL
, var
->name
, (CORE_ADDR
) 0,
3755 if (tmp_var
!= NULL
)
3757 tmp_var
->obj_name
= xstrdup (var
->obj_name
);
3758 varobj_delete (var
, NULL
, 0);
3759 install_variable (tmp_var
);
3762 var
->root
->is_valid
= 0;
3764 else /* locals must be invalidated. */
3765 var
->root
->is_valid
= 0;
3768 /* Invalidate the varobjs that are tied to locals and re-create the ones that
3769 are defined on globals.
3770 Invalidated varobjs will be always printed in_scope="invalid". */
3773 varobj_invalidate (void)
3775 all_root_varobjs (varobj_invalidate_iter
, NULL
);