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"
28 #include "gdb_assert.h"
29 #include "gdb_string.h"
30 #include "gdb_regex.h"
34 #include "gdbthread.h"
38 #include "python/python.h"
39 #include "python/python-internal.h"
44 /* Non-zero if we want to see trace of varobj level stuff. */
48 show_varobjdebug (struct ui_file
*file
, int from_tty
,
49 struct cmd_list_element
*c
, const char *value
)
51 fprintf_filtered (file
, _("Varobj debugging is %s.\n"), value
);
54 /* String representations of gdb's format codes. */
55 char *varobj_format_string
[] =
56 { "natural", "binary", "decimal", "hexadecimal", "octal" };
58 /* String representations of gdb's known languages. */
59 char *varobj_language_string
[] = { "unknown", "C", "C++", "Java" };
61 /* True if we want to allow Python-based pretty-printing. */
62 static int pretty_printing
= 0;
65 varobj_enable_pretty_printing (void)
72 /* Every root variable has one of these structures saved in its
73 varobj. Members which must be free'd are noted. */
77 /* Alloc'd expression for this parent. */
78 struct expression
*exp
;
80 /* Block for which this expression is valid. */
81 struct block
*valid_block
;
83 /* The frame for this expression. This field is set iff valid_block is
85 struct frame_id frame
;
87 /* The thread ID that this varobj_root belong to. This field
88 is only valid if valid_block is not NULL.
89 When not 0, indicates which thread 'frame' belongs to.
90 When 0, indicates that the thread list was empty when the varobj_root
94 /* If 1, the -var-update always recomputes the value in the
95 current thread and frame. Otherwise, variable object is
96 always updated in the specific scope/thread/frame. */
99 /* Flag that indicates validity: set to 0 when this varobj_root refers
100 to symbols that do not exist anymore. */
103 /* Language info for this variable and its children. */
104 struct language_specific
*lang
;
106 /* The varobj for this root node. */
107 struct varobj
*rootvar
;
109 /* Next root variable */
110 struct varobj_root
*next
;
113 /* Every variable in the system has a structure of this type defined
114 for it. This structure holds all information necessary to manipulate
115 a particular object variable. Members which must be freed are noted. */
119 /* Alloc'd name of the variable for this object. If this variable is a
120 child, then this name will be the child's source name.
121 (bar, not foo.bar). */
122 /* NOTE: This is the "expression". */
125 /* Alloc'd expression for this child. Can be used to create a
126 root variable corresponding to this child. */
129 /* The alloc'd name for this variable's object. This is here for
130 convenience when constructing this object's children. */
133 /* Index of this variable in its parent or -1. */
136 /* The type of this variable. This can be NULL
137 for artifial variable objects -- currently, the "accessibility"
138 variable objects in C++. */
141 /* The value of this expression or subexpression. A NULL value
142 indicates there was an error getting this value.
143 Invariant: if varobj_value_is_changeable_p (this) is non-zero,
144 the value is either NULL, or not lazy. */
147 /* The number of (immediate) children this variable has. */
150 /* If this object is a child, this points to its immediate parent. */
151 struct varobj
*parent
;
153 /* Children of this object. */
154 VEC (varobj_p
) *children
;
156 /* Whether the children of this varobj were requested. This field is
157 used to decide if dynamic varobj should recompute their children.
158 In the event that the frontend never asked for the children, we
160 int children_requested
;
162 /* Description of the root variable. Points to root variable for
164 struct varobj_root
*root
;
166 /* The format of the output for this object. */
167 enum varobj_display_formats format
;
169 /* Was this variable updated via a varobj_set_value operation. */
172 /* Last print value. */
175 /* Is this variable frozen. Frozen variables are never implicitly
176 updated by -var-update *
177 or -var-update <direct-or-indirect-parent>. */
180 /* Is the value of this variable intentionally not fetched? It is
181 not fetched if either the variable is frozen, or any parents is
185 /* Sub-range of children which the MI consumer has requested. If
186 FROM < 0 or TO < 0, means that all children have been
191 /* The pretty-printer constructor. If NULL, then the default
192 pretty-printer will be looked up. If None, then no
193 pretty-printer will be installed. */
194 PyObject
*constructor
;
196 /* The pretty-printer that has been constructed. If NULL, then a
197 new printer object is needed, and one will be constructed. */
198 PyObject
*pretty_printer
;
200 /* The iterator returned by the printer's 'children' method, or NULL
202 PyObject
*child_iter
;
204 /* We request one extra item from the iterator, so that we can
205 report to the caller whether there are more items than we have
206 already reported. However, we don't want to install this value
207 when we read it, because that will mess up future updates. So,
208 we stash it here instead. */
209 PyObject
*saved_item
;
215 struct cpstack
*next
;
218 /* A list of varobjs */
226 /* Private function prototypes */
228 /* Helper functions for the above subcommands. */
230 static int delete_variable (struct cpstack
**, struct varobj
*, int);
232 static void delete_variable_1 (struct cpstack
**, int *,
233 struct varobj
*, int, int);
235 static int install_variable (struct varobj
*);
237 static void uninstall_variable (struct varobj
*);
239 static struct varobj
*create_child (struct varobj
*, int, char *);
241 static struct varobj
*
242 create_child_with_value (struct varobj
*parent
, int index
, const char *name
,
243 struct value
*value
);
245 /* Utility routines */
247 static struct varobj
*new_variable (void);
249 static struct varobj
*new_root_variable (void);
251 static void free_variable (struct varobj
*var
);
253 static struct cleanup
*make_cleanup_free_variable (struct varobj
*var
);
255 static struct type
*get_type (struct varobj
*var
);
257 static struct type
*get_value_type (struct varobj
*var
);
259 static struct type
*get_target_type (struct type
*);
261 static enum varobj_display_formats
variable_default_display (struct varobj
*);
263 static void cppush (struct cpstack
**pstack
, char *name
);
265 static char *cppop (struct cpstack
**pstack
);
267 static int install_new_value (struct varobj
*var
, struct value
*value
,
270 /* Language-specific routines. */
272 static enum varobj_languages
variable_language (struct varobj
*var
);
274 static int number_of_children (struct varobj
*);
276 static char *name_of_variable (struct varobj
*);
278 static char *name_of_child (struct varobj
*, int);
280 static struct value
*value_of_root (struct varobj
**var_handle
, int *);
282 static struct value
*value_of_child (struct varobj
*parent
, int index
);
284 static char *my_value_of_variable (struct varobj
*var
,
285 enum varobj_display_formats format
);
287 static char *value_get_print_value (struct value
*value
,
288 enum varobj_display_formats format
,
291 static int varobj_value_is_changeable_p (struct varobj
*var
);
293 static int is_root_p (struct varobj
*var
);
297 static struct varobj
*varobj_add_child (struct varobj
*var
,
299 struct value
*value
);
301 #endif /* HAVE_PYTHON */
303 /* C implementation */
305 static int c_number_of_children (struct varobj
*var
);
307 static char *c_name_of_variable (struct varobj
*parent
);
309 static char *c_name_of_child (struct varobj
*parent
, int index
);
311 static char *c_path_expr_of_child (struct varobj
*child
);
313 static struct value
*c_value_of_root (struct varobj
**var_handle
);
315 static struct value
*c_value_of_child (struct varobj
*parent
, int index
);
317 static struct type
*c_type_of_child (struct varobj
*parent
, int index
);
319 static char *c_value_of_variable (struct varobj
*var
,
320 enum varobj_display_formats format
);
322 /* C++ implementation */
324 static int cplus_number_of_children (struct varobj
*var
);
326 static void cplus_class_num_children (struct type
*type
, int children
[3]);
328 static char *cplus_name_of_variable (struct varobj
*parent
);
330 static char *cplus_name_of_child (struct varobj
*parent
, int index
);
332 static char *cplus_path_expr_of_child (struct varobj
*child
);
334 static struct value
*cplus_value_of_root (struct varobj
**var_handle
);
336 static struct value
*cplus_value_of_child (struct varobj
*parent
, int index
);
338 static struct type
*cplus_type_of_child (struct varobj
*parent
, int index
);
340 static char *cplus_value_of_variable (struct varobj
*var
,
341 enum varobj_display_formats format
);
343 /* Java implementation */
345 static int java_number_of_children (struct varobj
*var
);
347 static char *java_name_of_variable (struct varobj
*parent
);
349 static char *java_name_of_child (struct varobj
*parent
, int index
);
351 static char *java_path_expr_of_child (struct varobj
*child
);
353 static struct value
*java_value_of_root (struct varobj
**var_handle
);
355 static struct value
*java_value_of_child (struct varobj
*parent
, int index
);
357 static struct type
*java_type_of_child (struct varobj
*parent
, int index
);
359 static char *java_value_of_variable (struct varobj
*var
,
360 enum varobj_display_formats format
);
362 /* Ada implementation */
364 static int ada_number_of_children (struct varobj
*var
);
366 static char *ada_name_of_variable (struct varobj
*parent
);
368 static char *ada_name_of_child (struct varobj
*parent
, int index
);
370 static char *ada_path_expr_of_child (struct varobj
*child
);
372 static struct value
*ada_value_of_root (struct varobj
**var_handle
);
374 static struct value
*ada_value_of_child (struct varobj
*parent
, int index
);
376 static struct type
*ada_type_of_child (struct varobj
*parent
, int index
);
378 static char *ada_value_of_variable (struct varobj
*var
,
379 enum varobj_display_formats format
);
381 /* The language specific vector */
383 struct language_specific
386 /* The language of this variable. */
387 enum varobj_languages language
;
389 /* The number of children of PARENT. */
390 int (*number_of_children
) (struct varobj
* parent
);
392 /* The name (expression) of a root varobj. */
393 char *(*name_of_variable
) (struct varobj
* parent
);
395 /* The name of the INDEX'th child of PARENT. */
396 char *(*name_of_child
) (struct varobj
* parent
, int index
);
398 /* Returns the rooted expression of CHILD, which is a variable
399 obtain that has some parent. */
400 char *(*path_expr_of_child
) (struct varobj
* child
);
402 /* The ``struct value *'' of the root variable ROOT. */
403 struct value
*(*value_of_root
) (struct varobj
** root_handle
);
405 /* The ``struct value *'' of the INDEX'th child of PARENT. */
406 struct value
*(*value_of_child
) (struct varobj
* parent
, int index
);
408 /* The type of the INDEX'th child of PARENT. */
409 struct type
*(*type_of_child
) (struct varobj
* parent
, int index
);
411 /* The current value of VAR. */
412 char *(*value_of_variable
) (struct varobj
* var
,
413 enum varobj_display_formats format
);
416 /* Array of known source language routines. */
417 static struct language_specific languages
[vlang_end
] = {
418 /* Unknown (try treating as C). */
421 c_number_of_children
,
424 c_path_expr_of_child
,
433 c_number_of_children
,
436 c_path_expr_of_child
,
445 cplus_number_of_children
,
446 cplus_name_of_variable
,
448 cplus_path_expr_of_child
,
450 cplus_value_of_child
,
452 cplus_value_of_variable
}
457 java_number_of_children
,
458 java_name_of_variable
,
460 java_path_expr_of_child
,
464 java_value_of_variable
},
468 ada_number_of_children
,
469 ada_name_of_variable
,
471 ada_path_expr_of_child
,
475 ada_value_of_variable
}
478 /* A little convenience enum for dealing with C++/Java. */
481 v_public
= 0, v_private
, v_protected
486 /* Mappings of varobj_display_formats enums to gdb's format codes. */
487 static int format_code
[] = { 0, 't', 'd', 'x', 'o' };
489 /* Header of the list of root variable objects. */
490 static struct varobj_root
*rootlist
;
492 /* Prime number indicating the number of buckets in the hash table. */
493 /* A prime large enough to avoid too many colisions. */
494 #define VAROBJ_TABLE_SIZE 227
496 /* Pointer to the varobj hash table (built at run time). */
497 static struct vlist
**varobj_table
;
499 /* Is the variable X one of our "fake" children? */
500 #define CPLUS_FAKE_CHILD(x) \
501 ((x) != NULL && (x)->type == NULL && (x)->value == NULL)
504 /* API Implementation */
506 is_root_p (struct varobj
*var
)
508 return (var
->root
->rootvar
== var
);
512 /* Helper function to install a Python environment suitable for
513 use during operations on VAR. */
515 varobj_ensure_python_env (struct varobj
*var
)
517 return ensure_python_env (var
->root
->exp
->gdbarch
,
518 var
->root
->exp
->language_defn
);
522 /* Creates a varobj (not its children). */
524 /* Return the full FRAME which corresponds to the given CORE_ADDR
525 or NULL if no FRAME on the chain corresponds to CORE_ADDR. */
527 static struct frame_info
*
528 find_frame_addr_in_frame_chain (CORE_ADDR frame_addr
)
530 struct frame_info
*frame
= NULL
;
532 if (frame_addr
== (CORE_ADDR
) 0)
535 for (frame
= get_current_frame ();
537 frame
= get_prev_frame (frame
))
539 /* The CORE_ADDR we get as argument was parsed from a string GDB
540 output as $fp. This output got truncated to gdbarch_addr_bit.
541 Truncate the frame base address in the same manner before
542 comparing it against our argument. */
543 CORE_ADDR frame_base
= get_frame_base_address (frame
);
544 int addr_bit
= gdbarch_addr_bit (get_frame_arch (frame
));
546 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
547 frame_base
&= ((CORE_ADDR
) 1 << addr_bit
) - 1;
549 if (frame_base
== frame_addr
)
557 varobj_create (char *objname
,
558 char *expression
, CORE_ADDR frame
, enum varobj_type type
)
561 struct cleanup
*old_chain
;
563 /* Fill out a varobj structure for the (root) variable being constructed. */
564 var
= new_root_variable ();
565 old_chain
= make_cleanup_free_variable (var
);
567 if (expression
!= NULL
)
569 struct frame_info
*fi
;
570 struct frame_id old_id
= null_frame_id
;
573 enum varobj_languages lang
;
574 struct value
*value
= NULL
;
575 volatile struct gdb_exception except
;
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 TRY_CATCH (except
, RETURN_MASK_ERROR
)
612 var
->root
->exp
= parse_exp_1 (&p
, block
, 0);
615 if (except
.reason
< 0)
617 do_cleanups (old_chain
);
621 /* Don't allow variables to be created for types. */
622 if (var
->root
->exp
->elts
[0].opcode
== OP_TYPE
)
624 do_cleanups (old_chain
);
625 fprintf_unfiltered (gdb_stderr
, "Attempt to use a type name"
626 " as an expression.\n");
630 var
->format
= variable_default_display (var
);
631 var
->root
->valid_block
= innermost_block
;
632 var
->name
= xstrdup (expression
);
633 /* For a root var, the name and the expr are the same. */
634 var
->path_expr
= xstrdup (expression
);
636 /* When the frame is different from the current frame,
637 we must select the appropriate frame before parsing
638 the expression, otherwise the value will not be current.
639 Since select_frame is so benign, just call it for all cases. */
642 /* User could specify explicit FRAME-ADDR which was not found but
643 EXPRESSION is frame specific and we would not be able to evaluate
644 it correctly next time. With VALID_BLOCK set we must also set
645 FRAME and THREAD_ID. */
647 error (_("Failed to find the specified frame"));
649 var
->root
->frame
= get_frame_id (fi
);
650 var
->root
->thread_id
= pid_to_thread_id (inferior_ptid
);
651 old_id
= get_frame_id (get_selected_frame (NULL
));
655 /* We definitely need to catch errors here.
656 If evaluate_expression succeeds we got the value we wanted.
657 But if it fails, we still go on with a call to evaluate_type(). */
658 TRY_CATCH (except
, RETURN_MASK_ERROR
)
660 value
= evaluate_expression (var
->root
->exp
);
663 if (except
.reason
< 0)
665 /* Error getting the value. Try to at least get the
667 struct value
*type_only_value
= evaluate_type (var
->root
->exp
);
669 var
->type
= value_type (type_only_value
);
672 var
->type
= value_type (value
);
674 install_new_value (var
, value
, 1 /* Initial assignment */);
676 /* Set language info */
677 lang
= variable_language (var
);
678 var
->root
->lang
= &languages
[lang
];
680 /* Set ourselves as our root. */
681 var
->root
->rootvar
= var
;
683 /* Reset the selected frame. */
684 if (frame_id_p (old_id
))
685 select_frame (frame_find_by_id (old_id
));
688 /* If the variable object name is null, that means this
689 is a temporary variable, so don't install it. */
691 if ((var
!= NULL
) && (objname
!= NULL
))
693 var
->obj_name
= xstrdup (objname
);
695 /* If a varobj name is duplicated, the install will fail so
697 if (!install_variable (var
))
699 do_cleanups (old_chain
);
704 discard_cleanups (old_chain
);
708 /* Generates an unique name that can be used for a varobj. */
711 varobj_gen_name (void)
716 /* Generate a name for this object. */
718 obj_name
= xstrprintf ("var%d", id
);
723 /* Given an OBJNAME, returns the pointer to the corresponding varobj. Call
724 error if OBJNAME cannot be found. */
727 varobj_get_handle (char *objname
)
731 unsigned int index
= 0;
734 for (chp
= objname
; *chp
; chp
++)
736 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
739 cv
= *(varobj_table
+ index
);
740 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, objname
) != 0))
744 error (_("Variable object not found"));
749 /* Given the handle, return the name of the object. */
752 varobj_get_objname (struct varobj
*var
)
754 return var
->obj_name
;
757 /* Given the handle, return the expression represented by the object. */
760 varobj_get_expression (struct varobj
*var
)
762 return name_of_variable (var
);
765 /* Deletes a varobj and all its children if only_children == 0,
766 otherwise deletes only the children; returns a malloc'ed list of
767 all the (malloc'ed) names of the variables that have been deleted
768 (NULL terminated). */
771 varobj_delete (struct varobj
*var
, char ***dellist
, int only_children
)
775 struct cpstack
*result
= NULL
;
778 /* Initialize a stack for temporary results. */
779 cppush (&result
, NULL
);
782 /* Delete only the variable children. */
783 delcount
= delete_variable (&result
, var
, 1 /* only the children */ );
785 /* Delete the variable and all its children. */
786 delcount
= delete_variable (&result
, var
, 0 /* parent+children */ );
788 /* We may have been asked to return a list of what has been deleted. */
791 *dellist
= xmalloc ((delcount
+ 1) * sizeof (char *));
795 *cp
= cppop (&result
);
796 while ((*cp
!= NULL
) && (mycount
> 0))
800 *cp
= cppop (&result
);
803 if (mycount
|| (*cp
!= NULL
))
804 warning (_("varobj_delete: assertion failed - mycount(=%d) <> 0"),
813 /* Convenience function for varobj_set_visualizer. Instantiate a
814 pretty-printer for a given value. */
816 instantiate_pretty_printer (PyObject
*constructor
, struct value
*value
)
818 PyObject
*val_obj
= NULL
;
821 val_obj
= value_to_value_object (value
);
825 printer
= PyObject_CallFunctionObjArgs (constructor
, val_obj
, NULL
);
832 /* Set/Get variable object display format. */
834 enum varobj_display_formats
835 varobj_set_display_format (struct varobj
*var
,
836 enum varobj_display_formats format
)
843 case FORMAT_HEXADECIMAL
:
845 var
->format
= format
;
849 var
->format
= variable_default_display (var
);
852 if (varobj_value_is_changeable_p (var
)
853 && var
->value
&& !value_lazy (var
->value
))
855 xfree (var
->print_value
);
856 var
->print_value
= value_get_print_value (var
->value
, var
->format
, var
);
862 enum varobj_display_formats
863 varobj_get_display_format (struct varobj
*var
)
869 varobj_get_display_hint (struct varobj
*var
)
874 struct cleanup
*back_to
= varobj_ensure_python_env (var
);
876 if (var
->pretty_printer
)
877 result
= gdbpy_get_display_hint (var
->pretty_printer
);
879 do_cleanups (back_to
);
885 /* Return true if the varobj has items after TO, false otherwise. */
888 varobj_has_more (struct varobj
*var
, int to
)
890 if (VEC_length (varobj_p
, var
->children
) > to
)
892 return ((to
== -1 || VEC_length (varobj_p
, var
->children
) == to
)
893 && var
->saved_item
!= NULL
);
896 /* If the variable object is bound to a specific thread, that
897 is its evaluation can always be done in context of a frame
898 inside that thread, returns GDB id of the thread -- which
899 is always positive. Otherwise, returns -1. */
901 varobj_get_thread_id (struct varobj
*var
)
903 if (var
->root
->valid_block
&& var
->root
->thread_id
> 0)
904 return var
->root
->thread_id
;
910 varobj_set_frozen (struct varobj
*var
, int frozen
)
912 /* When a variable is unfrozen, we don't fetch its value.
913 The 'not_fetched' flag remains set, so next -var-update
916 We don't fetch the value, because for structures the client
917 should do -var-update anyway. It would be bad to have different
918 client-size logic for structure and other types. */
919 var
->frozen
= frozen
;
923 varobj_get_frozen (struct varobj
*var
)
928 /* A helper function that restricts a range to what is actually
929 available in a VEC. This follows the usual rules for the meaning
930 of FROM and TO -- if either is negative, the entire range is
934 restrict_range (VEC (varobj_p
) *children
, int *from
, int *to
)
936 if (*from
< 0 || *to
< 0)
939 *to
= VEC_length (varobj_p
, children
);
943 if (*from
> VEC_length (varobj_p
, children
))
944 *from
= VEC_length (varobj_p
, children
);
945 if (*to
> VEC_length (varobj_p
, children
))
946 *to
= VEC_length (varobj_p
, children
);
954 /* A helper for update_dynamic_varobj_children that installs a new
955 child when needed. */
958 install_dynamic_child (struct varobj
*var
,
959 VEC (varobj_p
) **changed
,
960 VEC (varobj_p
) **new,
961 VEC (varobj_p
) **unchanged
,
967 if (VEC_length (varobj_p
, var
->children
) < index
+ 1)
969 /* There's no child yet. */
970 struct varobj
*child
= varobj_add_child (var
, name
, value
);
974 VEC_safe_push (varobj_p
, *new, child
);
980 varobj_p existing
= VEC_index (varobj_p
, var
->children
, index
);
982 if (install_new_value (existing
, value
, 0))
985 VEC_safe_push (varobj_p
, *changed
, existing
);
988 VEC_safe_push (varobj_p
, *unchanged
, existing
);
993 dynamic_varobj_has_child_method (struct varobj
*var
)
995 struct cleanup
*back_to
;
996 PyObject
*printer
= var
->pretty_printer
;
999 back_to
= varobj_ensure_python_env (var
);
1000 result
= PyObject_HasAttr (printer
, gdbpy_children_cst
);
1001 do_cleanups (back_to
);
1008 update_dynamic_varobj_children (struct varobj
*var
,
1009 VEC (varobj_p
) **changed
,
1010 VEC (varobj_p
) **new,
1011 VEC (varobj_p
) **unchanged
,
1013 int update_children
,
1018 struct cleanup
*back_to
;
1021 PyObject
*printer
= var
->pretty_printer
;
1023 back_to
= varobj_ensure_python_env (var
);
1026 if (!PyObject_HasAttr (printer
, gdbpy_children_cst
))
1028 do_cleanups (back_to
);
1032 if (update_children
|| !var
->child_iter
)
1034 children
= PyObject_CallMethodObjArgs (printer
, gdbpy_children_cst
,
1039 gdbpy_print_stack ();
1040 error (_("Null value returned for children"));
1043 make_cleanup_py_decref (children
);
1045 if (!PyIter_Check (children
))
1046 error (_("Returned value is not iterable"));
1048 Py_XDECREF (var
->child_iter
);
1049 var
->child_iter
= PyObject_GetIter (children
);
1050 if (!var
->child_iter
)
1052 gdbpy_print_stack ();
1053 error (_("Could not get children iterator"));
1056 Py_XDECREF (var
->saved_item
);
1057 var
->saved_item
= NULL
;
1062 i
= VEC_length (varobj_p
, var
->children
);
1064 /* We ask for one extra child, so that MI can report whether there
1065 are more children. */
1066 for (; to
< 0 || i
< to
+ 1; ++i
)
1071 /* See if there was a leftover from last time. */
1072 if (var
->saved_item
)
1074 item
= var
->saved_item
;
1075 var
->saved_item
= NULL
;
1078 item
= PyIter_Next (var
->child_iter
);
1082 /* Normal end of iteration. */
1083 if (!PyErr_Occurred ())
1086 /* If we got a memory error, just use the text as the
1088 if (PyErr_ExceptionMatches (gdbpy_gdb_memory_error
))
1090 PyObject
*type
, *value
, *trace
;
1091 char *name_str
, *value_str
;
1093 PyErr_Fetch (&type
, &value
, &trace
);
1094 value_str
= gdbpy_exception_to_string (type
, value
);
1100 gdbpy_print_stack ();
1104 name_str
= xstrprintf ("<error at %d>", i
);
1105 item
= Py_BuildValue ("(ss)", name_str
, value_str
);
1110 gdbpy_print_stack ();
1118 /* Any other kind of error. */
1119 gdbpy_print_stack ();
1124 /* We don't want to push the extra child on any report list. */
1125 if (to
< 0 || i
< to
)
1130 struct cleanup
*inner
;
1131 int can_mention
= from
< 0 || i
>= from
;
1133 inner
= make_cleanup_py_decref (item
);
1135 if (!PyArg_ParseTuple (item
, "sO", &name
, &py_v
))
1137 gdbpy_print_stack ();
1138 error (_("Invalid item from the child list"));
1141 v
= convert_value_from_python (py_v
);
1143 gdbpy_print_stack ();
1144 install_dynamic_child (var
, can_mention
? changed
: NULL
,
1145 can_mention
? new : NULL
,
1146 can_mention
? unchanged
: NULL
,
1147 can_mention
? cchanged
: NULL
, i
, name
, v
);
1148 do_cleanups (inner
);
1152 Py_XDECREF (var
->saved_item
);
1153 var
->saved_item
= item
;
1155 /* We want to truncate the child list just before this
1164 if (i
< VEC_length (varobj_p
, var
->children
))
1169 for (j
= i
; j
< VEC_length (varobj_p
, var
->children
); ++j
)
1170 varobj_delete (VEC_index (varobj_p
, var
->children
, j
), NULL
, 0);
1171 VEC_truncate (varobj_p
, var
->children
, i
);
1174 /* If there are fewer children than requested, note that the list of
1175 children changed. */
1176 if (to
>= 0 && VEC_length (varobj_p
, var
->children
) < to
)
1179 var
->num_children
= VEC_length (varobj_p
, var
->children
);
1181 do_cleanups (back_to
);
1185 gdb_assert (0 && "should never be called if Python is not enabled");
1190 varobj_get_num_children (struct varobj
*var
)
1192 if (var
->num_children
== -1)
1194 if (var
->pretty_printer
)
1198 /* If we have a dynamic varobj, don't report -1 children.
1199 So, try to fetch some children first. */
1200 update_dynamic_varobj_children (var
, NULL
, NULL
, NULL
, &dummy
,
1204 var
->num_children
= number_of_children (var
);
1207 return var
->num_children
>= 0 ? var
->num_children
: 0;
1210 /* Creates a list of the immediate children of a variable object;
1211 the return code is the number of such children or -1 on error. */
1214 varobj_list_children (struct varobj
*var
, int *from
, int *to
)
1217 int i
, children_changed
;
1219 var
->children_requested
= 1;
1221 if (var
->pretty_printer
)
1223 /* This, in theory, can result in the number of children changing without
1224 frontend noticing. But well, calling -var-list-children on the same
1225 varobj twice is not something a sane frontend would do. */
1226 update_dynamic_varobj_children (var
, NULL
, NULL
, NULL
, &children_changed
,
1228 restrict_range (var
->children
, from
, to
);
1229 return var
->children
;
1232 if (var
->num_children
== -1)
1233 var
->num_children
= number_of_children (var
);
1235 /* If that failed, give up. */
1236 if (var
->num_children
== -1)
1237 return var
->children
;
1239 /* If we're called when the list of children is not yet initialized,
1240 allocate enough elements in it. */
1241 while (VEC_length (varobj_p
, var
->children
) < var
->num_children
)
1242 VEC_safe_push (varobj_p
, var
->children
, NULL
);
1244 for (i
= 0; i
< var
->num_children
; i
++)
1246 varobj_p existing
= VEC_index (varobj_p
, var
->children
, i
);
1248 if (existing
== NULL
)
1250 /* Either it's the first call to varobj_list_children for
1251 this variable object, and the child was never created,
1252 or it was explicitly deleted by the client. */
1253 name
= name_of_child (var
, i
);
1254 existing
= create_child (var
, i
, name
);
1255 VEC_replace (varobj_p
, var
->children
, i
, existing
);
1259 restrict_range (var
->children
, from
, to
);
1260 return var
->children
;
1265 static struct varobj
*
1266 varobj_add_child (struct varobj
*var
, const char *name
, struct value
*value
)
1268 varobj_p v
= create_child_with_value (var
,
1269 VEC_length (varobj_p
, var
->children
),
1272 VEC_safe_push (varobj_p
, var
->children
, v
);
1276 #endif /* HAVE_PYTHON */
1278 /* Obtain the type of an object Variable as a string similar to the one gdb
1279 prints on the console. */
1282 varobj_get_type (struct varobj
*var
)
1284 /* For the "fake" variables, do not return a type. (It's type is
1286 Do not return a type for invalid variables as well. */
1287 if (CPLUS_FAKE_CHILD (var
) || !var
->root
->is_valid
)
1290 return type_to_string (var
->type
);
1293 /* Obtain the type of an object variable. */
1296 varobj_get_gdb_type (struct varobj
*var
)
1301 /* Return a pointer to the full rooted expression of varobj VAR.
1302 If it has not been computed yet, compute it. */
1304 varobj_get_path_expr (struct varobj
*var
)
1306 if (var
->path_expr
!= NULL
)
1307 return var
->path_expr
;
1310 /* For root varobjs, we initialize path_expr
1311 when creating varobj, so here it should be
1313 gdb_assert (!is_root_p (var
));
1314 return (*var
->root
->lang
->path_expr_of_child
) (var
);
1318 enum varobj_languages
1319 varobj_get_language (struct varobj
*var
)
1321 return variable_language (var
);
1325 varobj_get_attributes (struct varobj
*var
)
1329 if (varobj_editable_p (var
))
1330 /* FIXME: define masks for attributes. */
1331 attributes
|= 0x00000001; /* Editable */
1337 varobj_pretty_printed_p (struct varobj
*var
)
1339 return var
->pretty_printer
!= NULL
;
1343 varobj_get_formatted_value (struct varobj
*var
,
1344 enum varobj_display_formats format
)
1346 return my_value_of_variable (var
, format
);
1350 varobj_get_value (struct varobj
*var
)
1352 return my_value_of_variable (var
, var
->format
);
1355 /* Set the value of an object variable (if it is editable) to the
1356 value of the given expression. */
1357 /* Note: Invokes functions that can call error(). */
1360 varobj_set_value (struct varobj
*var
, char *expression
)
1362 struct value
*val
= NULL
; /* Initialize to keep gcc happy. */
1363 /* The argument "expression" contains the variable's new value.
1364 We need to first construct a legal expression for this -- ugh! */
1365 /* Does this cover all the bases? */
1366 struct expression
*exp
;
1367 struct value
*value
= NULL
; /* Initialize to keep gcc happy. */
1368 int saved_input_radix
= input_radix
;
1369 char *s
= expression
;
1370 volatile struct gdb_exception except
;
1372 gdb_assert (varobj_editable_p (var
));
1374 input_radix
= 10; /* ALWAYS reset to decimal temporarily. */
1375 exp
= parse_exp_1 (&s
, 0, 0);
1376 TRY_CATCH (except
, RETURN_MASK_ERROR
)
1378 value
= evaluate_expression (exp
);
1381 if (except
.reason
< 0)
1383 /* We cannot proceed without a valid expression. */
1388 /* All types that are editable must also be changeable. */
1389 gdb_assert (varobj_value_is_changeable_p (var
));
1391 /* The value of a changeable variable object must not be lazy. */
1392 gdb_assert (!value_lazy (var
->value
));
1394 /* Need to coerce the input. We want to check if the
1395 value of the variable object will be different
1396 after assignment, and the first thing value_assign
1397 does is coerce the input.
1398 For example, if we are assigning an array to a pointer variable we
1399 should compare the pointer with the array's address, not with the
1401 value
= coerce_array (value
);
1403 /* The new value may be lazy. value_assign, or
1404 rather value_contents, will take care of this. */
1405 TRY_CATCH (except
, RETURN_MASK_ERROR
)
1407 val
= value_assign (var
->value
, value
);
1410 if (except
.reason
< 0)
1413 /* If the value has changed, record it, so that next -var-update can
1414 report this change. If a variable had a value of '1', we've set it
1415 to '333' and then set again to '1', when -var-update will report this
1416 variable as changed -- because the first assignment has set the
1417 'updated' flag. There's no need to optimize that, because return value
1418 of -var-update should be considered an approximation. */
1419 var
->updated
= install_new_value (var
, val
, 0 /* Compare values. */);
1420 input_radix
= saved_input_radix
;
1426 /* A helper function to install a constructor function and visualizer
1430 install_visualizer (struct varobj
*var
, PyObject
*constructor
,
1431 PyObject
*visualizer
)
1433 Py_XDECREF (var
->constructor
);
1434 var
->constructor
= constructor
;
1436 Py_XDECREF (var
->pretty_printer
);
1437 var
->pretty_printer
= visualizer
;
1439 Py_XDECREF (var
->child_iter
);
1440 var
->child_iter
= NULL
;
1443 /* Install the default visualizer for VAR. */
1446 install_default_visualizer (struct varobj
*var
)
1448 /* Do not install a visualizer on a CPLUS_FAKE_CHILD. */
1449 if (CPLUS_FAKE_CHILD (var
))
1452 if (pretty_printing
)
1454 PyObject
*pretty_printer
= NULL
;
1458 pretty_printer
= gdbpy_get_varobj_pretty_printer (var
->value
);
1459 if (! pretty_printer
)
1461 gdbpy_print_stack ();
1462 error (_("Cannot instantiate printer for default visualizer"));
1466 if (pretty_printer
== Py_None
)
1468 Py_DECREF (pretty_printer
);
1469 pretty_printer
= NULL
;
1472 install_visualizer (var
, NULL
, pretty_printer
);
1476 /* Instantiate and install a visualizer for VAR using CONSTRUCTOR to
1477 make a new object. */
1480 construct_visualizer (struct varobj
*var
, PyObject
*constructor
)
1482 PyObject
*pretty_printer
;
1484 /* Do not install a visualizer on a CPLUS_FAKE_CHILD. */
1485 if (CPLUS_FAKE_CHILD (var
))
1488 Py_INCREF (constructor
);
1489 if (constructor
== Py_None
)
1490 pretty_printer
= NULL
;
1493 pretty_printer
= instantiate_pretty_printer (constructor
, var
->value
);
1494 if (! pretty_printer
)
1496 gdbpy_print_stack ();
1497 Py_DECREF (constructor
);
1498 constructor
= Py_None
;
1499 Py_INCREF (constructor
);
1502 if (pretty_printer
== Py_None
)
1504 Py_DECREF (pretty_printer
);
1505 pretty_printer
= NULL
;
1509 install_visualizer (var
, constructor
, pretty_printer
);
1512 #endif /* HAVE_PYTHON */
1514 /* A helper function for install_new_value. This creates and installs
1515 a visualizer for VAR, if appropriate. */
1518 install_new_value_visualizer (struct varobj
*var
)
1521 /* If the constructor is None, then we want the raw value. If VAR
1522 does not have a value, just skip this. */
1523 if (var
->constructor
!= Py_None
&& var
->value
)
1525 struct cleanup
*cleanup
;
1527 cleanup
= varobj_ensure_python_env (var
);
1529 if (!var
->constructor
)
1530 install_default_visualizer (var
);
1532 construct_visualizer (var
, var
->constructor
);
1534 do_cleanups (cleanup
);
1541 /* Assign a new value to a variable object. If INITIAL is non-zero,
1542 this is the first assignement after the variable object was just
1543 created, or changed type. In that case, just assign the value
1545 Otherwise, assign the new value, and return 1 if the value is
1546 different from the current one, 0 otherwise. The comparison is
1547 done on textual representation of value. Therefore, some types
1548 need not be compared. E.g. for structures the reported value is
1549 always "{...}", so no comparison is necessary here. If the old
1550 value was NULL and new one is not, or vice versa, we always return 1.
1552 The VALUE parameter should not be released -- the function will
1553 take care of releasing it when needed. */
1555 install_new_value (struct varobj
*var
, struct value
*value
, int initial
)
1560 int intentionally_not_fetched
= 0;
1561 char *print_value
= NULL
;
1563 /* We need to know the varobj's type to decide if the value should
1564 be fetched or not. C++ fake children (public/protected/private)
1565 don't have a type. */
1566 gdb_assert (var
->type
|| CPLUS_FAKE_CHILD (var
));
1567 changeable
= varobj_value_is_changeable_p (var
);
1569 /* If the type has custom visualizer, we consider it to be always
1570 changeable. FIXME: need to make sure this behaviour will not
1571 mess up read-sensitive values. */
1572 if (var
->pretty_printer
)
1575 need_to_fetch
= changeable
;
1577 /* We are not interested in the address of references, and given
1578 that in C++ a reference is not rebindable, it cannot
1579 meaningfully change. So, get hold of the real value. */
1581 value
= coerce_ref (value
);
1583 if (var
->type
&& TYPE_CODE (var
->type
) == TYPE_CODE_UNION
)
1584 /* For unions, we need to fetch the value implicitly because
1585 of implementation of union member fetch. When gdb
1586 creates a value for a field and the value of the enclosing
1587 structure is not lazy, it immediately copies the necessary
1588 bytes from the enclosing values. If the enclosing value is
1589 lazy, the call to value_fetch_lazy on the field will read
1590 the data from memory. For unions, that means we'll read the
1591 same memory more than once, which is not desirable. So
1595 /* The new value might be lazy. If the type is changeable,
1596 that is we'll be comparing values of this type, fetch the
1597 value now. Otherwise, on the next update the old value
1598 will be lazy, which means we've lost that old value. */
1599 if (need_to_fetch
&& value
&& value_lazy (value
))
1601 struct varobj
*parent
= var
->parent
;
1602 int frozen
= var
->frozen
;
1604 for (; !frozen
&& parent
; parent
= parent
->parent
)
1605 frozen
|= parent
->frozen
;
1607 if (frozen
&& initial
)
1609 /* For variables that are frozen, or are children of frozen
1610 variables, we don't do fetch on initial assignment.
1611 For non-initial assignemnt we do the fetch, since it means we're
1612 explicitly asked to compare the new value with the old one. */
1613 intentionally_not_fetched
= 1;
1617 volatile struct gdb_exception except
;
1619 TRY_CATCH (except
, RETURN_MASK_ERROR
)
1621 value_fetch_lazy (value
);
1624 if (except
.reason
< 0)
1626 /* Set the value to NULL, so that for the next -var-update,
1627 we don't try to compare the new value with this value,
1628 that we couldn't even read. */
1634 /* Get a reference now, before possibly passing it to any Python
1635 code that might release it. */
1637 value_incref (value
);
1639 /* Below, we'll be comparing string rendering of old and new
1640 values. Don't get string rendering if the value is
1641 lazy -- if it is, the code above has decided that the value
1642 should not be fetched. */
1643 if (value
&& !value_lazy (value
) && !var
->pretty_printer
)
1644 print_value
= value_get_print_value (value
, var
->format
, var
);
1646 /* If the type is changeable, compare the old and the new values.
1647 If this is the initial assignment, we don't have any old value
1649 if (!initial
&& changeable
)
1651 /* If the value of the varobj was changed by -var-set-value,
1652 then the value in the varobj and in the target is the same.
1653 However, that value is different from the value that the
1654 varobj had after the previous -var-update. So need to the
1655 varobj as changed. */
1660 else if (! var
->pretty_printer
)
1662 /* Try to compare the values. That requires that both
1663 values are non-lazy. */
1664 if (var
->not_fetched
&& value_lazy (var
->value
))
1666 /* This is a frozen varobj and the value was never read.
1667 Presumably, UI shows some "never read" indicator.
1668 Now that we've fetched the real value, we need to report
1669 this varobj as changed so that UI can show the real
1673 else if (var
->value
== NULL
&& value
== NULL
)
1676 else if (var
->value
== NULL
|| value
== NULL
)
1682 gdb_assert (!value_lazy (var
->value
));
1683 gdb_assert (!value_lazy (value
));
1685 gdb_assert (var
->print_value
!= NULL
&& print_value
!= NULL
);
1686 if (strcmp (var
->print_value
, print_value
) != 0)
1692 if (!initial
&& !changeable
)
1694 /* For values that are not changeable, we don't compare the values.
1695 However, we want to notice if a value was not NULL and now is NULL,
1696 or vise versa, so that we report when top-level varobjs come in scope
1697 and leave the scope. */
1698 changed
= (var
->value
!= NULL
) != (value
!= NULL
);
1701 /* We must always keep the new value, since children depend on it. */
1702 if (var
->value
!= NULL
&& var
->value
!= value
)
1703 value_free (var
->value
);
1705 if (value
&& value_lazy (value
) && intentionally_not_fetched
)
1706 var
->not_fetched
= 1;
1708 var
->not_fetched
= 0;
1711 install_new_value_visualizer (var
);
1713 /* If we installed a pretty-printer, re-compare the printed version
1714 to see if the variable changed. */
1715 if (var
->pretty_printer
)
1717 xfree (print_value
);
1718 print_value
= value_get_print_value (var
->value
, var
->format
, var
);
1719 if ((var
->print_value
== NULL
&& print_value
!= NULL
)
1720 || (var
->print_value
!= NULL
&& print_value
== NULL
)
1721 || (var
->print_value
!= NULL
&& print_value
!= NULL
1722 && strcmp (var
->print_value
, print_value
) != 0))
1725 if (var
->print_value
)
1726 xfree (var
->print_value
);
1727 var
->print_value
= print_value
;
1729 gdb_assert (!var
->value
|| value_type (var
->value
));
1734 /* Return the requested range for a varobj. VAR is the varobj. FROM
1735 and TO are out parameters; *FROM and *TO will be set to the
1736 selected sub-range of VAR. If no range was selected using
1737 -var-set-update-range, then both will be -1. */
1739 varobj_get_child_range (struct varobj
*var
, int *from
, int *to
)
1745 /* Set the selected sub-range of children of VAR to start at index
1746 FROM and end at index TO. If either FROM or TO is less than zero,
1747 this is interpreted as a request for all children. */
1749 varobj_set_child_range (struct varobj
*var
, int from
, int to
)
1756 varobj_set_visualizer (struct varobj
*var
, const char *visualizer
)
1759 PyObject
*mainmod
, *globals
, *constructor
;
1760 struct cleanup
*back_to
;
1762 back_to
= varobj_ensure_python_env (var
);
1764 mainmod
= PyImport_AddModule ("__main__");
1765 globals
= PyModule_GetDict (mainmod
);
1766 Py_INCREF (globals
);
1767 make_cleanup_py_decref (globals
);
1769 constructor
= PyRun_String (visualizer
, Py_eval_input
, globals
, globals
);
1773 gdbpy_print_stack ();
1774 error (_("Could not evaluate visualizer expression: %s"), visualizer
);
1777 construct_visualizer (var
, constructor
);
1778 Py_XDECREF (constructor
);
1780 /* If there are any children now, wipe them. */
1781 varobj_delete (var
, NULL
, 1 /* children only */);
1782 var
->num_children
= -1;
1784 do_cleanups (back_to
);
1786 error (_("Python support required"));
1790 /* Update the values for a variable and its children. This is a
1791 two-pronged attack. First, re-parse the value for the root's
1792 expression to see if it's changed. Then go all the way
1793 through its children, reconstructing them and noting if they've
1796 The EXPLICIT parameter specifies if this call is result
1797 of MI request to update this specific variable, or
1798 result of implicit -var-update *. For implicit request, we don't
1799 update frozen variables.
1801 NOTE: This function may delete the caller's varobj. If it
1802 returns TYPE_CHANGED, then it has done this and VARP will be modified
1803 to point to the new varobj. */
1805 VEC(varobj_update_result
) *
1806 varobj_update (struct varobj
**varp
, int explicit)
1809 int type_changed
= 0;
1812 VEC (varobj_update_result
) *stack
= NULL
;
1813 VEC (varobj_update_result
) *result
= NULL
;
1815 /* Frozen means frozen -- we don't check for any change in
1816 this varobj, including its going out of scope, or
1817 changing type. One use case for frozen varobjs is
1818 retaining previously evaluated expressions, and we don't
1819 want them to be reevaluated at all. */
1820 if (!explicit && (*varp
)->frozen
)
1823 if (!(*varp
)->root
->is_valid
)
1825 varobj_update_result r
= {0};
1828 r
.status
= VAROBJ_INVALID
;
1829 VEC_safe_push (varobj_update_result
, result
, &r
);
1833 if ((*varp
)->root
->rootvar
== *varp
)
1835 varobj_update_result r
= {0};
1838 r
.status
= VAROBJ_IN_SCOPE
;
1840 /* Update the root variable. value_of_root can return NULL
1841 if the variable is no longer around, i.e. we stepped out of
1842 the frame in which a local existed. We are letting the
1843 value_of_root variable dispose of the varobj if the type
1845 new = value_of_root (varp
, &type_changed
);
1848 r
.type_changed
= type_changed
;
1849 if (install_new_value ((*varp
), new, type_changed
))
1853 r
.status
= VAROBJ_NOT_IN_SCOPE
;
1854 r
.value_installed
= 1;
1856 if (r
.status
== VAROBJ_NOT_IN_SCOPE
)
1858 if (r
.type_changed
|| r
.changed
)
1859 VEC_safe_push (varobj_update_result
, result
, &r
);
1863 VEC_safe_push (varobj_update_result
, stack
, &r
);
1867 varobj_update_result r
= {0};
1870 VEC_safe_push (varobj_update_result
, stack
, &r
);
1873 /* Walk through the children, reconstructing them all. */
1874 while (!VEC_empty (varobj_update_result
, stack
))
1876 varobj_update_result r
= *(VEC_last (varobj_update_result
, stack
));
1877 struct varobj
*v
= r
.varobj
;
1879 VEC_pop (varobj_update_result
, stack
);
1881 /* Update this variable, unless it's a root, which is already
1883 if (!r
.value_installed
)
1885 new = value_of_child (v
->parent
, v
->index
);
1886 if (install_new_value (v
, new, 0 /* type not changed */))
1893 /* We probably should not get children of a varobj that has a
1894 pretty-printer, but for which -var-list-children was never
1896 if (v
->pretty_printer
)
1898 VEC (varobj_p
) *changed
= 0, *new = 0, *unchanged
= 0;
1899 int i
, children_changed
= 0;
1904 if (!v
->children_requested
)
1908 /* If we initially did not have potential children, but
1909 now we do, consider the varobj as changed.
1910 Otherwise, if children were never requested, consider
1911 it as unchanged -- presumably, such varobj is not yet
1912 expanded in the UI, so we need not bother getting
1914 if (!varobj_has_more (v
, 0))
1916 update_dynamic_varobj_children (v
, NULL
, NULL
, NULL
,
1918 if (varobj_has_more (v
, 0))
1923 VEC_safe_push (varobj_update_result
, result
, &r
);
1928 /* If update_dynamic_varobj_children returns 0, then we have
1929 a non-conforming pretty-printer, so we skip it. */
1930 if (update_dynamic_varobj_children (v
, &changed
, &new, &unchanged
,
1931 &children_changed
, 1,
1934 if (children_changed
|| new)
1936 r
.children_changed
= 1;
1939 /* Push in reverse order so that the first child is
1940 popped from the work stack first, and so will be
1941 added to result first. This does not affect
1942 correctness, just "nicer". */
1943 for (i
= VEC_length (varobj_p
, changed
) - 1; i
>= 0; --i
)
1945 varobj_p tmp
= VEC_index (varobj_p
, changed
, i
);
1946 varobj_update_result r
= {0};
1950 r
.value_installed
= 1;
1951 VEC_safe_push (varobj_update_result
, stack
, &r
);
1953 for (i
= VEC_length (varobj_p
, unchanged
) - 1; i
>= 0; --i
)
1955 varobj_p tmp
= VEC_index (varobj_p
, unchanged
, i
);
1959 varobj_update_result r
= {0};
1962 r
.value_installed
= 1;
1963 VEC_safe_push (varobj_update_result
, stack
, &r
);
1966 if (r
.changed
|| r
.children_changed
)
1967 VEC_safe_push (varobj_update_result
, result
, &r
);
1969 /* Free CHANGED and UNCHANGED, but not NEW, because NEW
1970 has been put into the result vector. */
1971 VEC_free (varobj_p
, changed
);
1972 VEC_free (varobj_p
, unchanged
);
1978 /* Push any children. Use reverse order so that the first
1979 child is popped from the work stack first, and so
1980 will be added to result first. This does not
1981 affect correctness, just "nicer". */
1982 for (i
= VEC_length (varobj_p
, v
->children
)-1; i
>= 0; --i
)
1984 varobj_p c
= VEC_index (varobj_p
, v
->children
, i
);
1986 /* Child may be NULL if explicitly deleted by -var-delete. */
1987 if (c
!= NULL
&& !c
->frozen
)
1989 varobj_update_result r
= {0};
1992 VEC_safe_push (varobj_update_result
, stack
, &r
);
1996 if (r
.changed
|| r
.type_changed
)
1997 VEC_safe_push (varobj_update_result
, result
, &r
);
2000 VEC_free (varobj_update_result
, stack
);
2006 /* Helper functions */
2009 * Variable object construction/destruction
2013 delete_variable (struct cpstack
**resultp
, struct varobj
*var
,
2014 int only_children_p
)
2018 delete_variable_1 (resultp
, &delcount
, var
,
2019 only_children_p
, 1 /* remove_from_parent_p */ );
2024 /* Delete the variable object VAR and its children. */
2025 /* IMPORTANT NOTE: If we delete a variable which is a child
2026 and the parent is not removed we dump core. It must be always
2027 initially called with remove_from_parent_p set. */
2029 delete_variable_1 (struct cpstack
**resultp
, int *delcountp
,
2030 struct varobj
*var
, int only_children_p
,
2031 int remove_from_parent_p
)
2035 /* Delete any children of this variable, too. */
2036 for (i
= 0; i
< VEC_length (varobj_p
, var
->children
); ++i
)
2038 varobj_p child
= VEC_index (varobj_p
, var
->children
, i
);
2042 if (!remove_from_parent_p
)
2043 child
->parent
= NULL
;
2044 delete_variable_1 (resultp
, delcountp
, child
, 0, only_children_p
);
2046 VEC_free (varobj_p
, var
->children
);
2048 /* if we were called to delete only the children we are done here. */
2049 if (only_children_p
)
2052 /* Otherwise, add it to the list of deleted ones and proceed to do so. */
2053 /* If the name is null, this is a temporary variable, that has not
2054 yet been installed, don't report it, it belongs to the caller... */
2055 if (var
->obj_name
!= NULL
)
2057 cppush (resultp
, xstrdup (var
->obj_name
));
2058 *delcountp
= *delcountp
+ 1;
2061 /* If this variable has a parent, remove it from its parent's list. */
2062 /* OPTIMIZATION: if the parent of this variable is also being deleted,
2063 (as indicated by remove_from_parent_p) we don't bother doing an
2064 expensive list search to find the element to remove when we are
2065 discarding the list afterwards. */
2066 if ((remove_from_parent_p
) && (var
->parent
!= NULL
))
2068 VEC_replace (varobj_p
, var
->parent
->children
, var
->index
, NULL
);
2071 if (var
->obj_name
!= NULL
)
2072 uninstall_variable (var
);
2074 /* Free memory associated with this variable. */
2075 free_variable (var
);
2078 /* Install the given variable VAR with the object name VAR->OBJ_NAME. */
2080 install_variable (struct varobj
*var
)
2083 struct vlist
*newvl
;
2085 unsigned int index
= 0;
2088 for (chp
= var
->obj_name
; *chp
; chp
++)
2090 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
2093 cv
= *(varobj_table
+ index
);
2094 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, var
->obj_name
) != 0))
2098 error (_("Duplicate variable object name"));
2100 /* Add varobj to hash table. */
2101 newvl
= xmalloc (sizeof (struct vlist
));
2102 newvl
->next
= *(varobj_table
+ index
);
2104 *(varobj_table
+ index
) = newvl
;
2106 /* If root, add varobj to root list. */
2107 if (is_root_p (var
))
2109 /* Add to list of root variables. */
2110 if (rootlist
== NULL
)
2111 var
->root
->next
= NULL
;
2113 var
->root
->next
= rootlist
;
2114 rootlist
= var
->root
;
2120 /* Unistall the object VAR. */
2122 uninstall_variable (struct varobj
*var
)
2126 struct varobj_root
*cr
;
2127 struct varobj_root
*prer
;
2129 unsigned int index
= 0;
2132 /* Remove varobj from hash table. */
2133 for (chp
= var
->obj_name
; *chp
; chp
++)
2135 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
2138 cv
= *(varobj_table
+ index
);
2140 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, var
->obj_name
) != 0))
2147 fprintf_unfiltered (gdb_stdlog
, "Deleting %s\n", var
->obj_name
);
2152 ("Assertion failed: Could not find variable object \"%s\" to delete",
2158 *(varobj_table
+ index
) = cv
->next
;
2160 prev
->next
= cv
->next
;
2164 /* If root, remove varobj from root list. */
2165 if (is_root_p (var
))
2167 /* Remove from list of root variables. */
2168 if (rootlist
== var
->root
)
2169 rootlist
= var
->root
->next
;
2174 while ((cr
!= NULL
) && (cr
->rootvar
!= var
))
2181 warning (_("Assertion failed: Could not find "
2182 "varobj \"%s\" in root list"),
2189 prer
->next
= cr
->next
;
2195 /* Create and install a child of the parent of the given name. */
2196 static struct varobj
*
2197 create_child (struct varobj
*parent
, int index
, char *name
)
2199 return create_child_with_value (parent
, index
, name
,
2200 value_of_child (parent
, index
));
2203 static struct varobj
*
2204 create_child_with_value (struct varobj
*parent
, int index
, const char *name
,
2205 struct value
*value
)
2207 struct varobj
*child
;
2210 child
= new_variable ();
2212 /* Name is allocated by name_of_child. */
2213 /* FIXME: xstrdup should not be here. */
2214 child
->name
= xstrdup (name
);
2215 child
->index
= index
;
2216 child
->parent
= parent
;
2217 child
->root
= parent
->root
;
2218 childs_name
= xstrprintf ("%s.%s", parent
->obj_name
, name
);
2219 child
->obj_name
= childs_name
;
2220 install_variable (child
);
2222 /* Compute the type of the child. Must do this before
2223 calling install_new_value. */
2225 /* If the child had no evaluation errors, var->value
2226 will be non-NULL and contain a valid type. */
2227 child
->type
= value_type (value
);
2229 /* Otherwise, we must compute the type. */
2230 child
->type
= (*child
->root
->lang
->type_of_child
) (child
->parent
,
2232 install_new_value (child
, value
, 1);
2239 * Miscellaneous utility functions.
2242 /* Allocate memory and initialize a new variable. */
2243 static struct varobj
*
2248 var
= (struct varobj
*) xmalloc (sizeof (struct varobj
));
2250 var
->path_expr
= NULL
;
2251 var
->obj_name
= NULL
;
2255 var
->num_children
= -1;
2257 var
->children
= NULL
;
2261 var
->print_value
= NULL
;
2263 var
->not_fetched
= 0;
2264 var
->children_requested
= 0;
2267 var
->constructor
= 0;
2268 var
->pretty_printer
= 0;
2269 var
->child_iter
= 0;
2270 var
->saved_item
= 0;
2275 /* Allocate memory and initialize a new root variable. */
2276 static struct varobj
*
2277 new_root_variable (void)
2279 struct varobj
*var
= new_variable ();
2281 var
->root
= (struct varobj_root
*) xmalloc (sizeof (struct varobj_root
));
2282 var
->root
->lang
= NULL
;
2283 var
->root
->exp
= NULL
;
2284 var
->root
->valid_block
= NULL
;
2285 var
->root
->frame
= null_frame_id
;
2286 var
->root
->floating
= 0;
2287 var
->root
->rootvar
= NULL
;
2288 var
->root
->is_valid
= 1;
2293 /* Free any allocated memory associated with VAR. */
2295 free_variable (struct varobj
*var
)
2298 if (var
->pretty_printer
)
2300 struct cleanup
*cleanup
= varobj_ensure_python_env (var
);
2301 Py_XDECREF (var
->constructor
);
2302 Py_XDECREF (var
->pretty_printer
);
2303 Py_XDECREF (var
->child_iter
);
2304 Py_XDECREF (var
->saved_item
);
2305 do_cleanups (cleanup
);
2309 value_free (var
->value
);
2311 /* Free the expression if this is a root variable. */
2312 if (is_root_p (var
))
2314 xfree (var
->root
->exp
);
2319 xfree (var
->obj_name
);
2320 xfree (var
->print_value
);
2321 xfree (var
->path_expr
);
2326 do_free_variable_cleanup (void *var
)
2328 free_variable (var
);
2331 static struct cleanup
*
2332 make_cleanup_free_variable (struct varobj
*var
)
2334 return make_cleanup (do_free_variable_cleanup
, var
);
2337 /* This returns the type of the variable. It also skips past typedefs
2338 to return the real type of the variable.
2340 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
2341 except within get_target_type and get_type. */
2342 static struct type
*
2343 get_type (struct varobj
*var
)
2349 type
= check_typedef (type
);
2354 /* Return the type of the value that's stored in VAR,
2355 or that would have being stored there if the
2356 value were accessible.
2358 This differs from VAR->type in that VAR->type is always
2359 the true type of the expession in the source language.
2360 The return value of this function is the type we're
2361 actually storing in varobj, and using for displaying
2362 the values and for comparing previous and new values.
2364 For example, top-level references are always stripped. */
2365 static struct type
*
2366 get_value_type (struct varobj
*var
)
2371 type
= value_type (var
->value
);
2375 type
= check_typedef (type
);
2377 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
2378 type
= get_target_type (type
);
2380 type
= check_typedef (type
);
2385 /* This returns the target type (or NULL) of TYPE, also skipping
2386 past typedefs, just like get_type ().
2388 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
2389 except within get_target_type and get_type. */
2390 static struct type
*
2391 get_target_type (struct type
*type
)
2395 type
= TYPE_TARGET_TYPE (type
);
2397 type
= check_typedef (type
);
2403 /* What is the default display for this variable? We assume that
2404 everything is "natural". Any exceptions? */
2405 static enum varobj_display_formats
2406 variable_default_display (struct varobj
*var
)
2408 return FORMAT_NATURAL
;
2411 /* FIXME: The following should be generic for any pointer. */
2413 cppush (struct cpstack
**pstack
, char *name
)
2417 s
= (struct cpstack
*) xmalloc (sizeof (struct cpstack
));
2423 /* FIXME: The following should be generic for any pointer. */
2425 cppop (struct cpstack
**pstack
)
2430 if ((*pstack
)->name
== NULL
&& (*pstack
)->next
== NULL
)
2435 *pstack
= (*pstack
)->next
;
2442 * Language-dependencies
2445 /* Common entry points */
2447 /* Get the language of variable VAR. */
2448 static enum varobj_languages
2449 variable_language (struct varobj
*var
)
2451 enum varobj_languages lang
;
2453 switch (var
->root
->exp
->language_defn
->la_language
)
2459 case language_cplus
:
2473 /* Return the number of children for a given variable.
2474 The result of this function is defined by the language
2475 implementation. The number of children returned by this function
2476 is the number of children that the user will see in the variable
2479 number_of_children (struct varobj
*var
)
2481 return (*var
->root
->lang
->number_of_children
) (var
);
2484 /* What is the expression for the root varobj VAR? Returns a malloc'd
2487 name_of_variable (struct varobj
*var
)
2489 return (*var
->root
->lang
->name_of_variable
) (var
);
2492 /* What is the name of the INDEX'th child of VAR? Returns a malloc'd
2495 name_of_child (struct varobj
*var
, int index
)
2497 return (*var
->root
->lang
->name_of_child
) (var
, index
);
2500 /* What is the ``struct value *'' of the root variable VAR?
2501 For floating variable object, evaluation can get us a value
2502 of different type from what is stored in varobj already. In
2504 - *type_changed will be set to 1
2505 - old varobj will be freed, and new one will be
2506 created, with the same name.
2507 - *var_handle will be set to the new varobj
2508 Otherwise, *type_changed will be set to 0. */
2509 static struct value
*
2510 value_of_root (struct varobj
**var_handle
, int *type_changed
)
2514 if (var_handle
== NULL
)
2519 /* This should really be an exception, since this should
2520 only get called with a root variable. */
2522 if (!is_root_p (var
))
2525 if (var
->root
->floating
)
2527 struct varobj
*tmp_var
;
2528 char *old_type
, *new_type
;
2530 tmp_var
= varobj_create (NULL
, var
->name
, (CORE_ADDR
) 0,
2531 USE_SELECTED_FRAME
);
2532 if (tmp_var
== NULL
)
2536 old_type
= varobj_get_type (var
);
2537 new_type
= varobj_get_type (tmp_var
);
2538 if (strcmp (old_type
, new_type
) == 0)
2540 /* The expression presently stored inside var->root->exp
2541 remembers the locations of local variables relatively to
2542 the frame where the expression was created (in DWARF location
2543 button, for example). Naturally, those locations are not
2544 correct in other frames, so update the expression. */
2546 struct expression
*tmp_exp
= var
->root
->exp
;
2548 var
->root
->exp
= tmp_var
->root
->exp
;
2549 tmp_var
->root
->exp
= tmp_exp
;
2551 varobj_delete (tmp_var
, NULL
, 0);
2556 tmp_var
->obj_name
= xstrdup (var
->obj_name
);
2557 tmp_var
->from
= var
->from
;
2558 tmp_var
->to
= var
->to
;
2559 varobj_delete (var
, NULL
, 0);
2561 install_variable (tmp_var
);
2562 *var_handle
= tmp_var
;
2574 return (*var
->root
->lang
->value_of_root
) (var_handle
);
2577 /* What is the ``struct value *'' for the INDEX'th child of PARENT? */
2578 static struct value
*
2579 value_of_child (struct varobj
*parent
, int index
)
2581 struct value
*value
;
2583 value
= (*parent
->root
->lang
->value_of_child
) (parent
, index
);
2588 /* GDB already has a command called "value_of_variable". Sigh. */
2590 my_value_of_variable (struct varobj
*var
, enum varobj_display_formats format
)
2592 if (var
->root
->is_valid
)
2594 if (var
->pretty_printer
)
2595 return value_get_print_value (var
->value
, var
->format
, var
);
2596 return (*var
->root
->lang
->value_of_variable
) (var
, format
);
2603 value_get_print_value (struct value
*value
, enum varobj_display_formats format
,
2606 struct ui_file
*stb
;
2607 struct cleanup
*old_chain
;
2608 gdb_byte
*thevalue
= NULL
;
2609 struct value_print_options opts
;
2610 struct type
*type
= NULL
;
2612 char *encoding
= NULL
;
2613 struct gdbarch
*gdbarch
= NULL
;
2614 /* Initialize it just to avoid a GCC false warning. */
2615 CORE_ADDR str_addr
= 0;
2616 int string_print
= 0;
2621 stb
= mem_fileopen ();
2622 old_chain
= make_cleanup_ui_file_delete (stb
);
2624 gdbarch
= get_type_arch (value_type (value
));
2627 PyObject
*value_formatter
= var
->pretty_printer
;
2629 varobj_ensure_python_env (var
);
2631 if (value_formatter
)
2633 /* First check to see if we have any children at all. If so,
2634 we simply return {...}. */
2635 if (dynamic_varobj_has_child_method (var
))
2637 do_cleanups (old_chain
);
2638 return xstrdup ("{...}");
2641 if (PyObject_HasAttr (value_formatter
, gdbpy_to_string_cst
))
2643 struct value
*replacement
;
2644 PyObject
*output
= NULL
;
2646 output
= apply_varobj_pretty_printer (value_formatter
,
2650 /* If we have string like output ... */
2653 make_cleanup_py_decref (output
);
2655 /* If this is a lazy string, extract it. For lazy
2656 strings we always print as a string, so set
2658 if (gdbpy_is_lazy_string (output
))
2660 gdbpy_extract_lazy_string (output
, &str_addr
, &type
,
2662 make_cleanup (free_current_contents
, &encoding
);
2667 /* If it is a regular (non-lazy) string, extract
2668 it and copy the contents into THEVALUE. If the
2669 hint says to print it as a string, set
2670 string_print. Otherwise just return the extracted
2671 string as a value. */
2674 = python_string_to_target_python_string (output
);
2678 char *s
= PyString_AsString (py_str
);
2681 hint
= gdbpy_get_display_hint (value_formatter
);
2684 if (!strcmp (hint
, "string"))
2689 len
= PyString_Size (py_str
);
2690 thevalue
= xmemdup (s
, len
+ 1, len
+ 1);
2691 type
= builtin_type (gdbarch
)->builtin_char
;
2696 do_cleanups (old_chain
);
2700 make_cleanup (xfree
, thevalue
);
2703 gdbpy_print_stack ();
2706 /* If the printer returned a replacement value, set VALUE
2707 to REPLACEMENT. If there is not a replacement value,
2708 just use the value passed to this function. */
2710 value
= replacement
;
2716 get_formatted_print_options (&opts
, format_code
[(int) format
]);
2720 /* If the THEVALUE has contents, it is a regular string. */
2722 LA_PRINT_STRING (stb
, type
, thevalue
, len
, encoding
, 0, &opts
);
2723 else if (string_print
)
2724 /* Otherwise, if string_print is set, and it is not a regular
2725 string, it is a lazy string. */
2726 val_print_string (type
, encoding
, str_addr
, len
, stb
, &opts
);
2728 /* All other cases. */
2729 common_val_print (value
, stb
, 0, &opts
, current_language
);
2731 thevalue
= ui_file_xstrdup (stb
, NULL
);
2733 do_cleanups (old_chain
);
2738 varobj_editable_p (struct varobj
*var
)
2742 if (!(var
->root
->is_valid
&& var
->value
&& VALUE_LVAL (var
->value
)))
2745 type
= get_value_type (var
);
2747 switch (TYPE_CODE (type
))
2749 case TYPE_CODE_STRUCT
:
2750 case TYPE_CODE_UNION
:
2751 case TYPE_CODE_ARRAY
:
2752 case TYPE_CODE_FUNC
:
2753 case TYPE_CODE_METHOD
:
2763 /* Return non-zero if changes in value of VAR
2764 must be detected and reported by -var-update.
2765 Return zero is -var-update should never report
2766 changes of such values. This makes sense for structures
2767 (since the changes in children values will be reported separately),
2768 or for artifical objects (like 'public' pseudo-field in C++).
2770 Return value of 0 means that gdb need not call value_fetch_lazy
2771 for the value of this variable object. */
2773 varobj_value_is_changeable_p (struct varobj
*var
)
2778 if (CPLUS_FAKE_CHILD (var
))
2781 type
= get_value_type (var
);
2783 switch (TYPE_CODE (type
))
2785 case TYPE_CODE_STRUCT
:
2786 case TYPE_CODE_UNION
:
2787 case TYPE_CODE_ARRAY
:
2798 /* Return 1 if that varobj is floating, that is is always evaluated in the
2799 selected frame, and not bound to thread/frame. Such variable objects
2800 are created using '@' as frame specifier to -var-create. */
2802 varobj_floating_p (struct varobj
*var
)
2804 return var
->root
->floating
;
2807 /* Given the value and the type of a variable object,
2808 adjust the value and type to those necessary
2809 for getting children of the variable object.
2810 This includes dereferencing top-level references
2811 to all types and dereferencing pointers to
2814 Both TYPE and *TYPE should be non-null. VALUE
2815 can be null if we want to only translate type.
2816 *VALUE can be null as well -- if the parent
2819 If WAS_PTR is not NULL, set *WAS_PTR to 0 or 1
2820 depending on whether pointer was dereferenced
2821 in this function. */
2823 adjust_value_for_child_access (struct value
**value
,
2827 gdb_assert (type
&& *type
);
2832 *type
= check_typedef (*type
);
2834 /* The type of value stored in varobj, that is passed
2835 to us, is already supposed to be
2836 reference-stripped. */
2838 gdb_assert (TYPE_CODE (*type
) != TYPE_CODE_REF
);
2840 /* Pointers to structures are treated just like
2841 structures when accessing children. Don't
2842 dererences pointers to other types. */
2843 if (TYPE_CODE (*type
) == TYPE_CODE_PTR
)
2845 struct type
*target_type
= get_target_type (*type
);
2846 if (TYPE_CODE (target_type
) == TYPE_CODE_STRUCT
2847 || TYPE_CODE (target_type
) == TYPE_CODE_UNION
)
2849 if (value
&& *value
)
2851 volatile struct gdb_exception except
;
2853 TRY_CATCH (except
, RETURN_MASK_ERROR
)
2855 *value
= value_ind (*value
);
2858 if (except
.reason
< 0)
2861 *type
= target_type
;
2867 /* The 'get_target_type' function calls check_typedef on
2868 result, so we can immediately check type code. No
2869 need to call check_typedef here. */
2874 c_number_of_children (struct varobj
*var
)
2876 struct type
*type
= get_value_type (var
);
2878 struct type
*target
;
2880 adjust_value_for_child_access (NULL
, &type
, NULL
);
2881 target
= get_target_type (type
);
2883 switch (TYPE_CODE (type
))
2885 case TYPE_CODE_ARRAY
:
2886 if (TYPE_LENGTH (type
) > 0 && TYPE_LENGTH (target
) > 0
2887 && !TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type
))
2888 children
= TYPE_LENGTH (type
) / TYPE_LENGTH (target
);
2890 /* If we don't know how many elements there are, don't display
2895 case TYPE_CODE_STRUCT
:
2896 case TYPE_CODE_UNION
:
2897 children
= TYPE_NFIELDS (type
);
2901 /* The type here is a pointer to non-struct. Typically, pointers
2902 have one child, except for function ptrs, which have no children,
2903 and except for void*, as we don't know what to show.
2905 We can show char* so we allow it to be dereferenced. If you decide
2906 to test for it, please mind that a little magic is necessary to
2907 properly identify it: char* has TYPE_CODE == TYPE_CODE_INT and
2908 TYPE_NAME == "char". */
2909 if (TYPE_CODE (target
) == TYPE_CODE_FUNC
2910 || TYPE_CODE (target
) == TYPE_CODE_VOID
)
2917 /* Other types have no children. */
2925 c_name_of_variable (struct varobj
*parent
)
2927 return xstrdup (parent
->name
);
2930 /* Return the value of element TYPE_INDEX of a structure
2931 value VALUE. VALUE's type should be a structure,
2932 or union, or a typedef to struct/union.
2934 Returns NULL if getting the value fails. Never throws. */
2935 static struct value
*
2936 value_struct_element_index (struct value
*value
, int type_index
)
2938 struct value
*result
= NULL
;
2939 volatile struct gdb_exception e
;
2940 struct type
*type
= value_type (value
);
2942 type
= check_typedef (type
);
2944 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
2945 || TYPE_CODE (type
) == TYPE_CODE_UNION
);
2947 TRY_CATCH (e
, RETURN_MASK_ERROR
)
2949 if (field_is_static (&TYPE_FIELD (type
, type_index
)))
2950 result
= value_static_field (type
, type_index
);
2952 result
= value_primitive_field (value
, 0, type_index
, type
);
2964 /* Obtain the information about child INDEX of the variable
2966 If CNAME is not null, sets *CNAME to the name of the child relative
2968 If CVALUE is not null, sets *CVALUE to the value of the child.
2969 If CTYPE is not null, sets *CTYPE to the type of the child.
2971 If any of CNAME, CVALUE, or CTYPE is not null, but the corresponding
2972 information cannot be determined, set *CNAME, *CVALUE, or *CTYPE
2975 c_describe_child (struct varobj
*parent
, int index
,
2976 char **cname
, struct value
**cvalue
, struct type
**ctype
,
2977 char **cfull_expression
)
2979 struct value
*value
= parent
->value
;
2980 struct type
*type
= get_value_type (parent
);
2981 char *parent_expression
= NULL
;
2983 volatile struct gdb_exception except
;
2991 if (cfull_expression
)
2993 *cfull_expression
= NULL
;
2994 parent_expression
= varobj_get_path_expr (parent
);
2996 adjust_value_for_child_access (&value
, &type
, &was_ptr
);
2998 switch (TYPE_CODE (type
))
3000 case TYPE_CODE_ARRAY
:
3003 = xstrdup (int_string (index
3004 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
)),
3007 if (cvalue
&& value
)
3009 int real_index
= index
+ TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
));
3011 TRY_CATCH (except
, RETURN_MASK_ERROR
)
3013 *cvalue
= value_subscript (value
, real_index
);
3018 *ctype
= get_target_type (type
);
3020 if (cfull_expression
)
3022 xstrprintf ("(%s)[%s]", parent_expression
,
3024 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
)),
3030 case TYPE_CODE_STRUCT
:
3031 case TYPE_CODE_UNION
:
3033 *cname
= xstrdup (TYPE_FIELD_NAME (type
, index
));
3035 if (cvalue
&& value
)
3037 /* For C, varobj index is the same as type index. */
3038 *cvalue
= value_struct_element_index (value
, index
);
3042 *ctype
= TYPE_FIELD_TYPE (type
, index
);
3044 if (cfull_expression
)
3046 char *join
= was_ptr
? "->" : ".";
3048 *cfull_expression
= xstrprintf ("(%s)%s%s", parent_expression
, join
,
3049 TYPE_FIELD_NAME (type
, index
));
3056 *cname
= xstrprintf ("*%s", parent
->name
);
3058 if (cvalue
&& value
)
3060 TRY_CATCH (except
, RETURN_MASK_ERROR
)
3062 *cvalue
= value_ind (value
);
3065 if (except
.reason
< 0)
3069 /* Don't use get_target_type because it calls
3070 check_typedef and here, we want to show the true
3071 declared type of the variable. */
3073 *ctype
= TYPE_TARGET_TYPE (type
);
3075 if (cfull_expression
)
3076 *cfull_expression
= xstrprintf ("*(%s)", parent_expression
);
3081 /* This should not happen. */
3083 *cname
= xstrdup ("???");
3084 if (cfull_expression
)
3085 *cfull_expression
= xstrdup ("???");
3086 /* Don't set value and type, we don't know then. */
3091 c_name_of_child (struct varobj
*parent
, int index
)
3095 c_describe_child (parent
, index
, &name
, NULL
, NULL
, NULL
);
3100 c_path_expr_of_child (struct varobj
*child
)
3102 c_describe_child (child
->parent
, child
->index
, NULL
, NULL
, NULL
,
3104 return child
->path_expr
;
3107 /* If frame associated with VAR can be found, switch
3108 to it and return 1. Otherwise, return 0. */
3110 check_scope (struct varobj
*var
)
3112 struct frame_info
*fi
;
3115 fi
= frame_find_by_id (var
->root
->frame
);
3120 CORE_ADDR pc
= get_frame_pc (fi
);
3122 if (pc
< BLOCK_START (var
->root
->valid_block
) ||
3123 pc
>= BLOCK_END (var
->root
->valid_block
))
3131 static struct value
*
3132 c_value_of_root (struct varobj
**var_handle
)
3134 struct value
*new_val
= NULL
;
3135 struct varobj
*var
= *var_handle
;
3136 int within_scope
= 0;
3137 struct cleanup
*back_to
;
3139 /* Only root variables can be updated... */
3140 if (!is_root_p (var
))
3141 /* Not a root var. */
3144 back_to
= make_cleanup_restore_current_thread ();
3146 /* Determine whether the variable is still around. */
3147 if (var
->root
->valid_block
== NULL
|| var
->root
->floating
)
3149 else if (var
->root
->thread_id
== 0)
3151 /* The program was single-threaded when the variable object was
3152 created. Technically, it's possible that the program became
3153 multi-threaded since then, but we don't support such
3155 within_scope
= check_scope (var
);
3159 ptid_t ptid
= thread_id_to_pid (var
->root
->thread_id
);
3160 if (in_thread_list (ptid
))
3162 switch_to_thread (ptid
);
3163 within_scope
= check_scope (var
);
3169 volatile struct gdb_exception except
;
3171 /* We need to catch errors here, because if evaluate
3172 expression fails we want to just return NULL. */
3173 TRY_CATCH (except
, RETURN_MASK_ERROR
)
3175 new_val
= evaluate_expression (var
->root
->exp
);
3181 do_cleanups (back_to
);
3186 static struct value
*
3187 c_value_of_child (struct varobj
*parent
, int index
)
3189 struct value
*value
= NULL
;
3191 c_describe_child (parent
, index
, NULL
, &value
, NULL
, NULL
);
3195 static struct type
*
3196 c_type_of_child (struct varobj
*parent
, int index
)
3198 struct type
*type
= NULL
;
3200 c_describe_child (parent
, index
, NULL
, NULL
, &type
, NULL
);
3205 c_value_of_variable (struct varobj
*var
, enum varobj_display_formats format
)
3207 /* BOGUS: if val_print sees a struct/class, or a reference to one,
3208 it will print out its children instead of "{...}". So we need to
3209 catch that case explicitly. */
3210 struct type
*type
= get_type (var
);
3212 /* If we have a custom formatter, return whatever string it has
3214 if (var
->pretty_printer
&& var
->print_value
)
3215 return xstrdup (var
->print_value
);
3217 /* Strip top-level references. */
3218 while (TYPE_CODE (type
) == TYPE_CODE_REF
)
3219 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3221 switch (TYPE_CODE (type
))
3223 case TYPE_CODE_STRUCT
:
3224 case TYPE_CODE_UNION
:
3225 return xstrdup ("{...}");
3228 case TYPE_CODE_ARRAY
:
3232 number
= xstrprintf ("[%d]", var
->num_children
);
3239 if (var
->value
== NULL
)
3241 /* This can happen if we attempt to get the value of a struct
3242 member when the parent is an invalid pointer. This is an
3243 error condition, so we should tell the caller. */
3248 if (var
->not_fetched
&& value_lazy (var
->value
))
3249 /* Frozen variable and no value yet. We don't
3250 implicitly fetch the value. MI response will
3251 use empty string for the value, which is OK. */
3254 gdb_assert (varobj_value_is_changeable_p (var
));
3255 gdb_assert (!value_lazy (var
->value
));
3257 /* If the specified format is the current one,
3258 we can reuse print_value. */
3259 if (format
== var
->format
)
3260 return xstrdup (var
->print_value
);
3262 return value_get_print_value (var
->value
, format
, var
);
3272 cplus_number_of_children (struct varobj
*var
)
3275 int children
, dont_know
;
3280 if (!CPLUS_FAKE_CHILD (var
))
3282 type
= get_value_type (var
);
3283 adjust_value_for_child_access (NULL
, &type
, NULL
);
3285 if (((TYPE_CODE (type
)) == TYPE_CODE_STRUCT
) ||
3286 ((TYPE_CODE (type
)) == TYPE_CODE_UNION
))
3290 cplus_class_num_children (type
, kids
);
3291 if (kids
[v_public
] != 0)
3293 if (kids
[v_private
] != 0)
3295 if (kids
[v_protected
] != 0)
3298 /* Add any baseclasses. */
3299 children
+= TYPE_N_BASECLASSES (type
);
3302 /* FIXME: save children in var. */
3309 type
= get_value_type (var
->parent
);
3310 adjust_value_for_child_access (NULL
, &type
, NULL
);
3312 cplus_class_num_children (type
, kids
);
3313 if (strcmp (var
->name
, "public") == 0)
3314 children
= kids
[v_public
];
3315 else if (strcmp (var
->name
, "private") == 0)
3316 children
= kids
[v_private
];
3318 children
= kids
[v_protected
];
3323 children
= c_number_of_children (var
);
3328 /* Compute # of public, private, and protected variables in this class.
3329 That means we need to descend into all baseclasses and find out
3330 how many are there, too. */
3332 cplus_class_num_children (struct type
*type
, int children
[3])
3334 int i
, vptr_fieldno
;
3335 struct type
*basetype
= NULL
;
3337 children
[v_public
] = 0;
3338 children
[v_private
] = 0;
3339 children
[v_protected
] = 0;
3341 vptr_fieldno
= get_vptr_fieldno (type
, &basetype
);
3342 for (i
= TYPE_N_BASECLASSES (type
); i
< TYPE_NFIELDS (type
); i
++)
3344 /* If we have a virtual table pointer, omit it. Even if virtual
3345 table pointers are not specifically marked in the debug info,
3346 they should be artificial. */
3347 if ((type
== basetype
&& i
== vptr_fieldno
)
3348 || TYPE_FIELD_ARTIFICIAL (type
, i
))
3351 if (TYPE_FIELD_PROTECTED (type
, i
))
3352 children
[v_protected
]++;
3353 else if (TYPE_FIELD_PRIVATE (type
, i
))
3354 children
[v_private
]++;
3356 children
[v_public
]++;
3361 cplus_name_of_variable (struct varobj
*parent
)
3363 return c_name_of_variable (parent
);
3366 enum accessibility
{ private_field
, protected_field
, public_field
};
3368 /* Check if field INDEX of TYPE has the specified accessibility.
3369 Return 0 if so and 1 otherwise. */
3371 match_accessibility (struct type
*type
, int index
, enum accessibility acc
)
3373 if (acc
== private_field
&& TYPE_FIELD_PRIVATE (type
, index
))
3375 else if (acc
== protected_field
&& TYPE_FIELD_PROTECTED (type
, index
))
3377 else if (acc
== public_field
&& !TYPE_FIELD_PRIVATE (type
, index
)
3378 && !TYPE_FIELD_PROTECTED (type
, index
))
3385 cplus_describe_child (struct varobj
*parent
, int index
,
3386 char **cname
, struct value
**cvalue
, struct type
**ctype
,
3387 char **cfull_expression
)
3389 struct value
*value
;
3392 char *parent_expression
= NULL
;
3400 if (cfull_expression
)
3401 *cfull_expression
= NULL
;
3403 if (CPLUS_FAKE_CHILD (parent
))
3405 value
= parent
->parent
->value
;
3406 type
= get_value_type (parent
->parent
);
3407 if (cfull_expression
)
3408 parent_expression
= varobj_get_path_expr (parent
->parent
);
3412 value
= parent
->value
;
3413 type
= get_value_type (parent
);
3414 if (cfull_expression
)
3415 parent_expression
= varobj_get_path_expr (parent
);
3418 adjust_value_for_child_access (&value
, &type
, &was_ptr
);
3420 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
3421 || TYPE_CODE (type
) == TYPE_CODE_UNION
)
3423 char *join
= was_ptr
? "->" : ".";
3425 if (CPLUS_FAKE_CHILD (parent
))
3427 /* The fields of the class type are ordered as they
3428 appear in the class. We are given an index for a
3429 particular access control type ("public","protected",
3430 or "private"). We must skip over fields that don't
3431 have the access control we are looking for to properly
3432 find the indexed field. */
3433 int type_index
= TYPE_N_BASECLASSES (type
);
3434 enum accessibility acc
= public_field
;
3436 struct type
*basetype
= NULL
;
3438 vptr_fieldno
= get_vptr_fieldno (type
, &basetype
);
3439 if (strcmp (parent
->name
, "private") == 0)
3440 acc
= private_field
;
3441 else if (strcmp (parent
->name
, "protected") == 0)
3442 acc
= protected_field
;
3446 if ((type
== basetype
&& type_index
== vptr_fieldno
)
3447 || TYPE_FIELD_ARTIFICIAL (type
, type_index
))
3449 else if (match_accessibility (type
, type_index
, acc
))
3456 *cname
= xstrdup (TYPE_FIELD_NAME (type
, type_index
));
3458 if (cvalue
&& value
)
3459 *cvalue
= value_struct_element_index (value
, type_index
);
3462 *ctype
= TYPE_FIELD_TYPE (type
, type_index
);
3464 if (cfull_expression
)
3466 = xstrprintf ("((%s)%s%s)", parent_expression
,
3468 TYPE_FIELD_NAME (type
, type_index
));
3470 else if (index
< TYPE_N_BASECLASSES (type
))
3472 /* This is a baseclass. */
3474 *cname
= xstrdup (TYPE_FIELD_NAME (type
, index
));
3476 if (cvalue
&& value
)
3477 *cvalue
= value_cast (TYPE_FIELD_TYPE (type
, index
), value
);
3481 *ctype
= TYPE_FIELD_TYPE (type
, index
);
3484 if (cfull_expression
)
3486 char *ptr
= was_ptr
? "*" : "";
3488 /* Cast the parent to the base' type. Note that in gdb,
3491 will create an lvalue, for all appearences, so we don't
3492 need to use more fancy:
3496 When we are in the scope of the base class or of one
3497 of its children, the type field name will be interpreted
3498 as a constructor, if it exists. Therefore, we must
3499 indicate that the name is a class name by using the
3500 'class' keyword. See PR mi/11912 */
3501 *cfull_expression
= xstrprintf ("(%s(class %s%s) %s)",
3503 TYPE_FIELD_NAME (type
, index
),
3510 char *access
= NULL
;
3513 cplus_class_num_children (type
, children
);
3515 /* Everything beyond the baseclasses can
3516 only be "public", "private", or "protected"
3518 The special "fake" children are always output by varobj in
3519 this order. So if INDEX == 2, it MUST be "protected". */
3520 index
-= TYPE_N_BASECLASSES (type
);
3524 if (children
[v_public
] > 0)
3526 else if (children
[v_private
] > 0)
3529 access
= "protected";
3532 if (children
[v_public
] > 0)
3534 if (children
[v_private
] > 0)
3537 access
= "protected";
3539 else if (children
[v_private
] > 0)
3540 access
= "protected";
3543 /* Must be protected. */
3544 access
= "protected";
3551 gdb_assert (access
);
3553 *cname
= xstrdup (access
);
3555 /* Value and type and full expression are null here. */
3560 c_describe_child (parent
, index
, cname
, cvalue
, ctype
, cfull_expression
);
3565 cplus_name_of_child (struct varobj
*parent
, int index
)
3569 cplus_describe_child (parent
, index
, &name
, NULL
, NULL
, NULL
);
3574 cplus_path_expr_of_child (struct varobj
*child
)
3576 cplus_describe_child (child
->parent
, child
->index
, NULL
, NULL
, NULL
,
3578 return child
->path_expr
;
3581 static struct value
*
3582 cplus_value_of_root (struct varobj
**var_handle
)
3584 return c_value_of_root (var_handle
);
3587 static struct value
*
3588 cplus_value_of_child (struct varobj
*parent
, int index
)
3590 struct value
*value
= NULL
;
3592 cplus_describe_child (parent
, index
, NULL
, &value
, NULL
, NULL
);
3596 static struct type
*
3597 cplus_type_of_child (struct varobj
*parent
, int index
)
3599 struct type
*type
= NULL
;
3601 cplus_describe_child (parent
, index
, NULL
, NULL
, &type
, NULL
);
3606 cplus_value_of_variable (struct varobj
*var
,
3607 enum varobj_display_formats format
)
3610 /* If we have one of our special types, don't print out
3612 if (CPLUS_FAKE_CHILD (var
))
3613 return xstrdup ("");
3615 return c_value_of_variable (var
, format
);
3621 java_number_of_children (struct varobj
*var
)
3623 return cplus_number_of_children (var
);
3627 java_name_of_variable (struct varobj
*parent
)
3631 name
= cplus_name_of_variable (parent
);
3632 /* If the name has "-" in it, it is because we
3633 needed to escape periods in the name... */
3636 while (*p
!= '\000')
3647 java_name_of_child (struct varobj
*parent
, int index
)
3651 name
= cplus_name_of_child (parent
, index
);
3652 /* Escape any periods in the name... */
3655 while (*p
!= '\000')
3666 java_path_expr_of_child (struct varobj
*child
)
3671 static struct value
*
3672 java_value_of_root (struct varobj
**var_handle
)
3674 return cplus_value_of_root (var_handle
);
3677 static struct value
*
3678 java_value_of_child (struct varobj
*parent
, int index
)
3680 return cplus_value_of_child (parent
, index
);
3683 static struct type
*
3684 java_type_of_child (struct varobj
*parent
, int index
)
3686 return cplus_type_of_child (parent
, index
);
3690 java_value_of_variable (struct varobj
*var
, enum varobj_display_formats format
)
3692 return cplus_value_of_variable (var
, format
);
3695 /* Ada specific callbacks for VAROBJs. */
3698 ada_number_of_children (struct varobj
*var
)
3700 return c_number_of_children (var
);
3704 ada_name_of_variable (struct varobj
*parent
)
3706 return c_name_of_variable (parent
);
3710 ada_name_of_child (struct varobj
*parent
, int index
)
3712 return c_name_of_child (parent
, index
);
3716 ada_path_expr_of_child (struct varobj
*child
)
3718 return c_path_expr_of_child (child
);
3721 static struct value
*
3722 ada_value_of_root (struct varobj
**var_handle
)
3724 return c_value_of_root (var_handle
);
3727 static struct value
*
3728 ada_value_of_child (struct varobj
*parent
, int index
)
3730 return c_value_of_child (parent
, index
);
3733 static struct type
*
3734 ada_type_of_child (struct varobj
*parent
, int index
)
3736 return c_type_of_child (parent
, index
);
3740 ada_value_of_variable (struct varobj
*var
, enum varobj_display_formats format
)
3742 return c_value_of_variable (var
, format
);
3745 /* Iterate all the existing _root_ VAROBJs and call the FUNC callback for them
3746 with an arbitrary caller supplied DATA pointer. */
3749 all_root_varobjs (void (*func
) (struct varobj
*var
, void *data
), void *data
)
3751 struct varobj_root
*var_root
, *var_root_next
;
3753 /* Iterate "safely" - handle if the callee deletes its passed VAROBJ. */
3755 for (var_root
= rootlist
; var_root
!= NULL
; var_root
= var_root_next
)
3757 var_root_next
= var_root
->next
;
3759 (*func
) (var_root
->rootvar
, data
);
3763 extern void _initialize_varobj (void);
3765 _initialize_varobj (void)
3767 int sizeof_table
= sizeof (struct vlist
*) * VAROBJ_TABLE_SIZE
;
3769 varobj_table
= xmalloc (sizeof_table
);
3770 memset (varobj_table
, 0, sizeof_table
);
3772 add_setshow_zinteger_cmd ("debugvarobj", class_maintenance
,
3774 _("Set varobj debugging."),
3775 _("Show varobj debugging."),
3776 _("When non-zero, varobj debugging is enabled."),
3777 NULL
, show_varobjdebug
,
3778 &setlist
, &showlist
);
3781 /* Invalidate varobj VAR if it is tied to locals and re-create it if it is
3782 defined on globals. It is a helper for varobj_invalidate. */
3785 varobj_invalidate_iter (struct varobj
*var
, void *unused
)
3787 /* Floating varobjs are reparsed on each stop, so we don't care if the
3788 presently parsed expression refers to something that's gone. */
3789 if (var
->root
->floating
)
3792 /* global var must be re-evaluated. */
3793 if (var
->root
->valid_block
== NULL
)
3795 struct varobj
*tmp_var
;
3797 /* Try to create a varobj with same expression. If we succeed
3798 replace the old varobj, otherwise invalidate it. */
3799 tmp_var
= varobj_create (NULL
, var
->name
, (CORE_ADDR
) 0,
3801 if (tmp_var
!= NULL
)
3803 tmp_var
->obj_name
= xstrdup (var
->obj_name
);
3804 varobj_delete (var
, NULL
, 0);
3805 install_variable (tmp_var
);
3808 var
->root
->is_valid
= 0;
3810 else /* locals must be invalidated. */
3811 var
->root
->is_valid
= 0;
3814 /* Invalidate the varobjs that are tied to locals and re-create the ones that
3815 are defined on globals.
3816 Invalidated varobjs will be always printed in_scope="invalid". */
3819 varobj_invalidate (void)
3821 all_root_varobjs (varobj_invalidate_iter
, NULL
);