1 /* Implementation of the GDB variable objects API.
3 Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
4 Free Software Foundation, Inc.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 #include "exceptions.h"
22 #include "expression.h"
29 #include "gdb_assert.h"
30 #include "gdb_string.h"
34 #include "gdbthread.h"
37 /* Non-zero if we want to see trace of varobj level stuff. */
41 show_varobjdebug (struct ui_file
*file
, int from_tty
,
42 struct cmd_list_element
*c
, const char *value
)
44 fprintf_filtered (file
, _("Varobj debugging is %s.\n"), value
);
47 /* String representations of gdb's format codes */
48 char *varobj_format_string
[] =
49 { "natural", "binary", "decimal", "hexadecimal", "octal" };
51 /* String representations of gdb's known languages */
52 char *varobj_language_string
[] = { "unknown", "C", "C++", "Java" };
56 /* Every root variable has one of these structures saved in its
57 varobj. Members which must be free'd are noted. */
61 /* Alloc'd expression for this parent. */
62 struct expression
*exp
;
64 /* Block for which this expression is valid */
65 struct block
*valid_block
;
67 /* The frame for this expression. This field is set iff valid_block is
69 struct frame_id frame
;
71 /* The thread ID that this varobj_root belong to. This field
72 is only valid if valid_block is not NULL.
73 When not 0, indicates which thread 'frame' belongs to.
74 When 0, indicates that the thread list was empty when the varobj_root
78 /* If 1, the -var-update always recomputes the value in the
79 current thread and frame. Otherwise, variable object is
80 always updated in the specific scope/thread/frame */
83 /* Flag that indicates validity: set to 0 when this varobj_root refers
84 to symbols that do not exist anymore. */
87 /* Language info for this variable and its children */
88 struct language_specific
*lang
;
90 /* The varobj for this root node. */
91 struct varobj
*rootvar
;
93 /* Next root variable */
94 struct varobj_root
*next
;
97 /* Every variable in the system has a structure of this type defined
98 for it. This structure holds all information necessary to manipulate
99 a particular object variable. Members which must be freed are noted. */
103 /* Alloc'd name of the variable for this object.. If this variable is a
104 child, then this name will be the child's source name.
105 (bar, not foo.bar) */
106 /* NOTE: This is the "expression" */
109 /* Alloc'd expression for this child. Can be used to create a
110 root variable corresponding to this child. */
113 /* The alloc'd name for this variable's object. This is here for
114 convenience when constructing this object's children. */
117 /* Index of this variable in its parent or -1 */
120 /* The type of this variable. This can be NULL
121 for artifial variable objects -- currently, the "accessibility"
122 variable objects in C++. */
125 /* The value of this expression or subexpression. A NULL value
126 indicates there was an error getting this value.
127 Invariant: if varobj_value_is_changeable_p (this) is non-zero,
128 the value is either NULL, or not lazy. */
131 /* The number of (immediate) children this variable has */
134 /* If this object is a child, this points to its immediate parent. */
135 struct varobj
*parent
;
137 /* Children of this object. */
138 VEC (varobj_p
) *children
;
140 /* Description of the root variable. Points to root variable for children. */
141 struct varobj_root
*root
;
143 /* The format of the output for this object */
144 enum varobj_display_formats format
;
146 /* Was this variable updated via a varobj_set_value operation */
149 /* Last print value. */
152 /* Is this variable frozen. Frozen variables are never implicitly
153 updated by -var-update *
154 or -var-update <direct-or-indirect-parent>. */
157 /* Is the value of this variable intentionally not fetched? It is
158 not fetched if either the variable is frozen, or any parents is
166 struct cpstack
*next
;
169 /* A list of varobjs */
177 /* Private function prototypes */
179 /* Helper functions for the above subcommands. */
181 static int delete_variable (struct cpstack
**, struct varobj
*, int);
183 static void delete_variable_1 (struct cpstack
**, int *,
184 struct varobj
*, int, int);
186 static int install_variable (struct varobj
*);
188 static void uninstall_variable (struct varobj
*);
190 static struct varobj
*create_child (struct varobj
*, int, char *);
192 /* Utility routines */
194 static struct varobj
*new_variable (void);
196 static struct varobj
*new_root_variable (void);
198 static void free_variable (struct varobj
*var
);
200 static struct cleanup
*make_cleanup_free_variable (struct varobj
*var
);
202 static struct type
*get_type (struct varobj
*var
);
204 static struct type
*get_value_type (struct varobj
*var
);
206 static struct type
*get_target_type (struct type
*);
208 static enum varobj_display_formats
variable_default_display (struct varobj
*);
210 static void cppush (struct cpstack
**pstack
, char *name
);
212 static char *cppop (struct cpstack
**pstack
);
214 static int install_new_value (struct varobj
*var
, struct value
*value
,
217 /* Language-specific routines. */
219 static enum varobj_languages
variable_language (struct varobj
*var
);
221 static int number_of_children (struct varobj
*);
223 static char *name_of_variable (struct varobj
*);
225 static char *name_of_child (struct varobj
*, int);
227 static struct value
*value_of_root (struct varobj
**var_handle
, int *);
229 static struct value
*value_of_child (struct varobj
*parent
, int index
);
231 static char *my_value_of_variable (struct varobj
*var
,
232 enum varobj_display_formats format
);
234 static char *value_get_print_value (struct value
*value
,
235 enum varobj_display_formats format
);
237 static int varobj_value_is_changeable_p (struct varobj
*var
);
239 static int is_root_p (struct varobj
*var
);
241 /* C implementation */
243 static int c_number_of_children (struct varobj
*var
);
245 static char *c_name_of_variable (struct varobj
*parent
);
247 static char *c_name_of_child (struct varobj
*parent
, int index
);
249 static char *c_path_expr_of_child (struct varobj
*child
);
251 static struct value
*c_value_of_root (struct varobj
**var_handle
);
253 static struct value
*c_value_of_child (struct varobj
*parent
, int index
);
255 static struct type
*c_type_of_child (struct varobj
*parent
, int index
);
257 static char *c_value_of_variable (struct varobj
*var
,
258 enum varobj_display_formats format
);
260 /* C++ implementation */
262 static int cplus_number_of_children (struct varobj
*var
);
264 static void cplus_class_num_children (struct type
*type
, int children
[3]);
266 static char *cplus_name_of_variable (struct varobj
*parent
);
268 static char *cplus_name_of_child (struct varobj
*parent
, int index
);
270 static char *cplus_path_expr_of_child (struct varobj
*child
);
272 static struct value
*cplus_value_of_root (struct varobj
**var_handle
);
274 static struct value
*cplus_value_of_child (struct varobj
*parent
, int index
);
276 static struct type
*cplus_type_of_child (struct varobj
*parent
, int index
);
278 static char *cplus_value_of_variable (struct varobj
*var
,
279 enum varobj_display_formats format
);
281 /* Java implementation */
283 static int java_number_of_children (struct varobj
*var
);
285 static char *java_name_of_variable (struct varobj
*parent
);
287 static char *java_name_of_child (struct varobj
*parent
, int index
);
289 static char *java_path_expr_of_child (struct varobj
*child
);
291 static struct value
*java_value_of_root (struct varobj
**var_handle
);
293 static struct value
*java_value_of_child (struct varobj
*parent
, int index
);
295 static struct type
*java_type_of_child (struct varobj
*parent
, int index
);
297 static char *java_value_of_variable (struct varobj
*var
,
298 enum varobj_display_formats format
);
300 /* The language specific vector */
302 struct language_specific
305 /* The language of this variable */
306 enum varobj_languages language
;
308 /* The number of children of PARENT. */
309 int (*number_of_children
) (struct varobj
* parent
);
311 /* The name (expression) of a root varobj. */
312 char *(*name_of_variable
) (struct varobj
* parent
);
314 /* The name of the INDEX'th child of PARENT. */
315 char *(*name_of_child
) (struct varobj
* parent
, int index
);
317 /* Returns the rooted expression of CHILD, which is a variable
318 obtain that has some parent. */
319 char *(*path_expr_of_child
) (struct varobj
* child
);
321 /* The ``struct value *'' of the root variable ROOT. */
322 struct value
*(*value_of_root
) (struct varobj
** root_handle
);
324 /* The ``struct value *'' of the INDEX'th child of PARENT. */
325 struct value
*(*value_of_child
) (struct varobj
* parent
, int index
);
327 /* The type of the INDEX'th child of PARENT. */
328 struct type
*(*type_of_child
) (struct varobj
* parent
, int index
);
330 /* The current value of VAR. */
331 char *(*value_of_variable
) (struct varobj
* var
,
332 enum varobj_display_formats format
);
335 /* Array of known source language routines. */
336 static struct language_specific languages
[vlang_end
] = {
337 /* Unknown (try treating as C */
340 c_number_of_children
,
343 c_path_expr_of_child
,
352 c_number_of_children
,
355 c_path_expr_of_child
,
364 cplus_number_of_children
,
365 cplus_name_of_variable
,
367 cplus_path_expr_of_child
,
369 cplus_value_of_child
,
371 cplus_value_of_variable
}
376 java_number_of_children
,
377 java_name_of_variable
,
379 java_path_expr_of_child
,
383 java_value_of_variable
}
386 /* A little convenience enum for dealing with C++/Java */
389 v_public
= 0, v_private
, v_protected
394 /* Mappings of varobj_display_formats enums to gdb's format codes */
395 static int format_code
[] = { 0, 't', 'd', 'x', 'o' };
397 /* Header of the list of root variable objects */
398 static struct varobj_root
*rootlist
;
399 static int rootcount
= 0; /* number of root varobjs in the list */
401 /* Prime number indicating the number of buckets in the hash table */
402 /* A prime large enough to avoid too many colisions */
403 #define VAROBJ_TABLE_SIZE 227
405 /* Pointer to the varobj hash table (built at run time) */
406 static struct vlist
**varobj_table
;
408 /* Is the variable X one of our "fake" children? */
409 #define CPLUS_FAKE_CHILD(x) \
410 ((x) != NULL && (x)->type == NULL && (x)->value == NULL)
413 /* API Implementation */
415 is_root_p (struct varobj
*var
)
417 return (var
->root
->rootvar
== var
);
420 /* Creates a varobj (not its children) */
422 /* Return the full FRAME which corresponds to the given CORE_ADDR
423 or NULL if no FRAME on the chain corresponds to CORE_ADDR. */
425 static struct frame_info
*
426 find_frame_addr_in_frame_chain (CORE_ADDR frame_addr
)
428 struct frame_info
*frame
= NULL
;
430 if (frame_addr
== (CORE_ADDR
) 0)
435 frame
= get_prev_frame (frame
);
438 if (get_frame_base_address (frame
) == frame_addr
)
444 varobj_create (char *objname
,
445 char *expression
, CORE_ADDR frame
, enum varobj_type type
)
448 struct frame_info
*fi
;
449 struct frame_info
*old_fi
= NULL
;
451 struct cleanup
*old_chain
;
453 /* Fill out a varobj structure for the (root) variable being constructed. */
454 var
= new_root_variable ();
455 old_chain
= make_cleanup_free_variable (var
);
457 if (expression
!= NULL
)
460 enum varobj_languages lang
;
461 struct value
*value
= NULL
;
464 /* Parse and evaluate the expression, filling in as much
465 of the variable's data as possible */
467 /* Allow creator to specify context of variable */
468 if ((type
== USE_CURRENT_FRAME
) || (type
== USE_SELECTED_FRAME
))
469 fi
= deprecated_safe_get_selected_frame ();
471 /* FIXME: cagney/2002-11-23: This code should be doing a
472 lookup using the frame ID and not just the frame's
473 ``address''. This, of course, means an interface change.
474 However, with out that interface change ISAs, such as the
475 ia64 with its two stacks, won't work. Similar goes for the
476 case where there is a frameless function. */
477 fi
= find_frame_addr_in_frame_chain (frame
);
479 /* frame = -2 means always use selected frame */
480 if (type
== USE_SELECTED_FRAME
)
481 var
->root
->floating
= 1;
485 block
= get_frame_block (fi
, 0);
488 innermost_block
= NULL
;
489 /* Wrap the call to parse expression, so we can
490 return a sensible error. */
491 if (!gdb_parse_exp_1 (&p
, block
, 0, &var
->root
->exp
))
496 /* Don't allow variables to be created for types. */
497 if (var
->root
->exp
->elts
[0].opcode
== OP_TYPE
)
499 do_cleanups (old_chain
);
500 fprintf_unfiltered (gdb_stderr
, "Attempt to use a type name"
501 " as an expression.\n");
505 var
->format
= variable_default_display (var
);
506 var
->root
->valid_block
= innermost_block
;
507 expr_len
= strlen (expression
);
508 var
->name
= savestring (expression
, expr_len
);
509 /* For a root var, the name and the expr are the same. */
510 var
->path_expr
= savestring (expression
, expr_len
);
512 /* When the frame is different from the current frame,
513 we must select the appropriate frame before parsing
514 the expression, otherwise the value will not be current.
515 Since select_frame is so benign, just call it for all cases. */
516 if (innermost_block
&& fi
!= NULL
)
518 var
->root
->frame
= get_frame_id (fi
);
519 var
->root
->thread_id
= pid_to_thread_id (inferior_ptid
);
520 old_fi
= get_selected_frame (NULL
);
524 /* We definitely need to catch errors here.
525 If evaluate_expression succeeds we got the value we wanted.
526 But if it fails, we still go on with a call to evaluate_type() */
527 if (!gdb_evaluate_expression (var
->root
->exp
, &value
))
529 /* Error getting the value. Try to at least get the
531 struct value
*type_only_value
= evaluate_type (var
->root
->exp
);
532 var
->type
= value_type (type_only_value
);
535 var
->type
= value_type (value
);
537 install_new_value (var
, value
, 1 /* Initial assignment */);
539 /* Set language info */
540 lang
= variable_language (var
);
541 var
->root
->lang
= &languages
[lang
];
543 /* Set ourselves as our root */
544 var
->root
->rootvar
= var
;
546 /* Reset the selected frame */
548 select_frame (old_fi
);
551 /* If the variable object name is null, that means this
552 is a temporary variable, so don't install it. */
554 if ((var
!= NULL
) && (objname
!= NULL
))
556 var
->obj_name
= savestring (objname
, strlen (objname
));
558 /* If a varobj name is duplicated, the install will fail so
560 if (!install_variable (var
))
562 do_cleanups (old_chain
);
567 discard_cleanups (old_chain
);
571 /* Generates an unique name that can be used for a varobj */
574 varobj_gen_name (void)
579 /* generate a name for this object */
581 obj_name
= xstrprintf ("var%d", id
);
586 /* Given an "objname", returns the pointer to the corresponding varobj
587 or NULL if not found */
590 varobj_get_handle (char *objname
)
594 unsigned int index
= 0;
597 for (chp
= objname
; *chp
; chp
++)
599 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
602 cv
= *(varobj_table
+ index
);
603 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, objname
) != 0))
607 error (_("Variable object not found"));
612 /* Given the handle, return the name of the object */
615 varobj_get_objname (struct varobj
*var
)
617 return var
->obj_name
;
620 /* Given the handle, return the expression represented by the object */
623 varobj_get_expression (struct varobj
*var
)
625 return name_of_variable (var
);
628 /* Deletes a varobj and all its children if only_children == 0,
629 otherwise deletes only the children; returns a malloc'ed list of all the
630 (malloc'ed) names of the variables that have been deleted (NULL terminated) */
633 varobj_delete (struct varobj
*var
, char ***dellist
, int only_children
)
637 struct cpstack
*result
= NULL
;
640 /* Initialize a stack for temporary results */
641 cppush (&result
, NULL
);
644 /* Delete only the variable children */
645 delcount
= delete_variable (&result
, var
, 1 /* only the children */ );
647 /* Delete the variable and all its children */
648 delcount
= delete_variable (&result
, var
, 0 /* parent+children */ );
650 /* We may have been asked to return a list of what has been deleted */
653 *dellist
= xmalloc ((delcount
+ 1) * sizeof (char *));
657 *cp
= cppop (&result
);
658 while ((*cp
!= NULL
) && (mycount
> 0))
662 *cp
= cppop (&result
);
665 if (mycount
|| (*cp
!= NULL
))
666 warning (_("varobj_delete: assertion failed - mycount(=%d) <> 0"),
673 /* Set/Get variable object display format */
675 enum varobj_display_formats
676 varobj_set_display_format (struct varobj
*var
,
677 enum varobj_display_formats format
)
684 case FORMAT_HEXADECIMAL
:
686 var
->format
= format
;
690 var
->format
= variable_default_display (var
);
693 if (varobj_value_is_changeable_p (var
)
694 && var
->value
&& !value_lazy (var
->value
))
696 free (var
->print_value
);
697 var
->print_value
= value_get_print_value (var
->value
, var
->format
);
703 enum varobj_display_formats
704 varobj_get_display_format (struct varobj
*var
)
709 /* If the variable object is bound to a specific thread, that
710 is its evaluation can always be done in context of a frame
711 inside that thread, returns GDB id of the thread -- which
712 is always positive. Otherwise, returns -1. */
714 varobj_get_thread_id (struct varobj
*var
)
716 if (var
->root
->valid_block
&& var
->root
->thread_id
> 0)
717 return var
->root
->thread_id
;
723 varobj_set_frozen (struct varobj
*var
, int frozen
)
725 /* When a variable is unfrozen, we don't fetch its value.
726 The 'not_fetched' flag remains set, so next -var-update
729 We don't fetch the value, because for structures the client
730 should do -var-update anyway. It would be bad to have different
731 client-size logic for structure and other types. */
732 var
->frozen
= frozen
;
736 varobj_get_frozen (struct varobj
*var
)
743 varobj_get_num_children (struct varobj
*var
)
745 if (var
->num_children
== -1)
746 var
->num_children
= number_of_children (var
);
748 return var
->num_children
;
751 /* Creates a list of the immediate children of a variable object;
752 the return code is the number of such children or -1 on error */
755 varobj_list_children (struct varobj
*var
)
757 struct varobj
*child
;
761 if (var
->num_children
== -1)
762 var
->num_children
= number_of_children (var
);
764 /* If that failed, give up. */
765 if (var
->num_children
== -1)
766 return var
->children
;
768 /* If we're called when the list of children is not yet initialized,
769 allocate enough elements in it. */
770 while (VEC_length (varobj_p
, var
->children
) < var
->num_children
)
771 VEC_safe_push (varobj_p
, var
->children
, NULL
);
773 for (i
= 0; i
< var
->num_children
; i
++)
775 varobj_p existing
= VEC_index (varobj_p
, var
->children
, i
);
777 if (existing
== NULL
)
779 /* Either it's the first call to varobj_list_children for
780 this variable object, and the child was never created,
781 or it was explicitly deleted by the client. */
782 name
= name_of_child (var
, i
);
783 existing
= create_child (var
, i
, name
);
784 VEC_replace (varobj_p
, var
->children
, i
, existing
);
788 return var
->children
;
791 /* Obtain the type of an object Variable as a string similar to the one gdb
792 prints on the console */
795 varobj_get_type (struct varobj
*var
)
798 struct cleanup
*old_chain
;
803 /* For the "fake" variables, do not return a type. (It's type is
805 Do not return a type for invalid variables as well. */
806 if (CPLUS_FAKE_CHILD (var
) || !var
->root
->is_valid
)
809 stb
= mem_fileopen ();
810 old_chain
= make_cleanup_ui_file_delete (stb
);
812 /* To print the type, we simply create a zero ``struct value *'' and
813 cast it to our type. We then typeprint this variable. */
814 val
= value_zero (var
->type
, not_lval
);
815 type_print (value_type (val
), "", stb
, -1);
817 thetype
= ui_file_xstrdup (stb
, &length
);
818 do_cleanups (old_chain
);
822 /* Obtain the type of an object variable. */
825 varobj_get_gdb_type (struct varobj
*var
)
830 /* Return a pointer to the full rooted expression of varobj VAR.
831 If it has not been computed yet, compute it. */
833 varobj_get_path_expr (struct varobj
*var
)
835 if (var
->path_expr
!= NULL
)
836 return var
->path_expr
;
839 /* For root varobjs, we initialize path_expr
840 when creating varobj, so here it should be
842 gdb_assert (!is_root_p (var
));
843 return (*var
->root
->lang
->path_expr_of_child
) (var
);
847 enum varobj_languages
848 varobj_get_language (struct varobj
*var
)
850 return variable_language (var
);
854 varobj_get_attributes (struct varobj
*var
)
858 if (varobj_editable_p (var
))
859 /* FIXME: define masks for attributes */
860 attributes
|= 0x00000001; /* Editable */
866 varobj_get_formatted_value (struct varobj
*var
,
867 enum varobj_display_formats format
)
869 return my_value_of_variable (var
, format
);
873 varobj_get_value (struct varobj
*var
)
875 return my_value_of_variable (var
, var
->format
);
878 /* Set the value of an object variable (if it is editable) to the
879 value of the given expression */
880 /* Note: Invokes functions that can call error() */
883 varobj_set_value (struct varobj
*var
, char *expression
)
889 /* The argument "expression" contains the variable's new value.
890 We need to first construct a legal expression for this -- ugh! */
891 /* Does this cover all the bases? */
892 struct expression
*exp
;
894 int saved_input_radix
= input_radix
;
895 char *s
= expression
;
898 gdb_assert (varobj_editable_p (var
));
900 input_radix
= 10; /* ALWAYS reset to decimal temporarily */
901 exp
= parse_exp_1 (&s
, 0, 0);
902 if (!gdb_evaluate_expression (exp
, &value
))
904 /* We cannot proceed without a valid expression. */
909 /* All types that are editable must also be changeable. */
910 gdb_assert (varobj_value_is_changeable_p (var
));
912 /* The value of a changeable variable object must not be lazy. */
913 gdb_assert (!value_lazy (var
->value
));
915 /* Need to coerce the input. We want to check if the
916 value of the variable object will be different
917 after assignment, and the first thing value_assign
918 does is coerce the input.
919 For example, if we are assigning an array to a pointer variable we
920 should compare the pointer with the the array's address, not with the
922 value
= coerce_array (value
);
924 /* The new value may be lazy. gdb_value_assign, or
925 rather value_contents, will take care of this.
926 If fetching of the new value will fail, gdb_value_assign
927 with catch the exception. */
928 if (!gdb_value_assign (var
->value
, value
, &val
))
931 /* If the value has changed, record it, so that next -var-update can
932 report this change. If a variable had a value of '1', we've set it
933 to '333' and then set again to '1', when -var-update will report this
934 variable as changed -- because the first assignment has set the
935 'updated' flag. There's no need to optimize that, because return value
936 of -var-update should be considered an approximation. */
937 var
->updated
= install_new_value (var
, val
, 0 /* Compare values. */);
938 input_radix
= saved_input_radix
;
942 /* Returns a malloc'ed list with all root variable objects */
944 varobj_list (struct varobj
***varlist
)
947 struct varobj_root
*croot
;
948 int mycount
= rootcount
;
950 /* Alloc (rootcount + 1) entries for the result */
951 *varlist
= xmalloc ((rootcount
+ 1) * sizeof (struct varobj
*));
955 while ((croot
!= NULL
) && (mycount
> 0))
957 *cv
= croot
->rootvar
;
962 /* Mark the end of the list */
965 if (mycount
|| (croot
!= NULL
))
967 ("varobj_list: assertion failed - wrong tally of root vars (%d:%d)",
973 /* Assign a new value to a variable object. If INITIAL is non-zero,
974 this is the first assignement after the variable object was just
975 created, or changed type. In that case, just assign the value
977 Otherwise, assign the value and if type_changeable returns non-zero,
978 find if the new value is different from the current value.
979 Return 1 if so, and 0 if the values are equal.
981 The VALUE parameter should not be released -- the function will
982 take care of releasing it when needed. */
984 install_new_value (struct varobj
*var
, struct value
*value
, int initial
)
989 int intentionally_not_fetched
= 0;
990 char *print_value
= NULL
;
992 /* We need to know the varobj's type to decide if the value should
993 be fetched or not. C++ fake children (public/protected/private) don't have
995 gdb_assert (var
->type
|| CPLUS_FAKE_CHILD (var
));
996 changeable
= varobj_value_is_changeable_p (var
);
997 need_to_fetch
= changeable
;
999 /* We are not interested in the address of references, and given
1000 that in C++ a reference is not rebindable, it cannot
1001 meaningfully change. So, get hold of the real value. */
1004 value
= coerce_ref (value
);
1005 release_value (value
);
1008 if (var
->type
&& TYPE_CODE (var
->type
) == TYPE_CODE_UNION
)
1009 /* For unions, we need to fetch the value implicitly because
1010 of implementation of union member fetch. When gdb
1011 creates a value for a field and the value of the enclosing
1012 structure is not lazy, it immediately copies the necessary
1013 bytes from the enclosing values. If the enclosing value is
1014 lazy, the call to value_fetch_lazy on the field will read
1015 the data from memory. For unions, that means we'll read the
1016 same memory more than once, which is not desirable. So
1020 /* The new value might be lazy. If the type is changeable,
1021 that is we'll be comparing values of this type, fetch the
1022 value now. Otherwise, on the next update the old value
1023 will be lazy, which means we've lost that old value. */
1024 if (need_to_fetch
&& value
&& value_lazy (value
))
1026 struct varobj
*parent
= var
->parent
;
1027 int frozen
= var
->frozen
;
1028 for (; !frozen
&& parent
; parent
= parent
->parent
)
1029 frozen
|= parent
->frozen
;
1031 if (frozen
&& initial
)
1033 /* For variables that are frozen, or are children of frozen
1034 variables, we don't do fetch on initial assignment.
1035 For non-initial assignemnt we do the fetch, since it means we're
1036 explicitly asked to compare the new value with the old one. */
1037 intentionally_not_fetched
= 1;
1039 else if (!gdb_value_fetch_lazy (value
))
1041 /* Set the value to NULL, so that for the next -var-update,
1042 we don't try to compare the new value with this value,
1043 that we couldn't even read. */
1048 /* Below, we'll be comparing string rendering of old and new
1049 values. Don't get string rendering if the value is
1050 lazy -- if it is, the code above has decided that the value
1051 should not be fetched. */
1052 if (value
&& !value_lazy (value
))
1053 print_value
= value_get_print_value (value
, var
->format
);
1055 /* If the type is changeable, compare the old and the new values.
1056 If this is the initial assignment, we don't have any old value
1058 if (!initial
&& changeable
)
1060 /* If the value of the varobj was changed by -var-set-value, then the
1061 value in the varobj and in the target is the same. However, that value
1062 is different from the value that the varobj had after the previous
1063 -var-update. So need to the varobj as changed. */
1070 /* Try to compare the values. That requires that both
1071 values are non-lazy. */
1072 if (var
->not_fetched
&& value_lazy (var
->value
))
1074 /* This is a frozen varobj and the value was never read.
1075 Presumably, UI shows some "never read" indicator.
1076 Now that we've fetched the real value, we need to report
1077 this varobj as changed so that UI can show the real
1081 else if (var
->value
== NULL
&& value
== NULL
)
1084 else if (var
->value
== NULL
|| value
== NULL
)
1090 gdb_assert (!value_lazy (var
->value
));
1091 gdb_assert (!value_lazy (value
));
1093 gdb_assert (var
->print_value
!= NULL
&& print_value
!= NULL
);
1094 if (strcmp (var
->print_value
, print_value
) != 0)
1100 /* We must always keep the new value, since children depend on it. */
1101 if (var
->value
!= NULL
&& var
->value
!= value
)
1102 value_free (var
->value
);
1104 if (var
->print_value
)
1105 xfree (var
->print_value
);
1106 var
->print_value
= print_value
;
1107 if (value
&& value_lazy (value
) && intentionally_not_fetched
)
1108 var
->not_fetched
= 1;
1110 var
->not_fetched
= 0;
1113 gdb_assert (!var
->value
|| value_type (var
->value
));
1118 /* Update the values for a variable and its children. This is a
1119 two-pronged attack. First, re-parse the value for the root's
1120 expression to see if it's changed. Then go all the way
1121 through its children, reconstructing them and noting if they've
1124 < 0 for error values, see varobj.h.
1125 Otherwise it is the number of children + parent changed.
1127 The EXPLICIT parameter specifies if this call is result
1128 of MI request to update this specific variable, or
1129 result of implicit -var-update *. For implicit request, we don't
1130 update frozen variables.
1132 NOTE: This function may delete the caller's varobj. If it
1133 returns TYPE_CHANGED, then it has done this and VARP will be modified
1134 to point to the new varobj. */
1137 varobj_update (struct varobj
**varp
, struct varobj
***changelist
,
1141 int type_changed
= 0;
1146 struct varobj
**templist
= NULL
;
1148 VEC (varobj_p
) *stack
= NULL
;
1149 VEC (varobj_p
) *result
= NULL
;
1150 struct frame_info
*fi
;
1152 /* sanity check: have we been passed a pointer? */
1153 gdb_assert (changelist
);
1155 /* Frozen means frozen -- we don't check for any change in
1156 this varobj, including its going out of scope, or
1157 changing type. One use case for frozen varobjs is
1158 retaining previously evaluated expressions, and we don't
1159 want them to be reevaluated at all. */
1160 if (!explicit && (*varp
)->frozen
)
1163 if (!(*varp
)->root
->is_valid
)
1166 if ((*varp
)->root
->rootvar
== *varp
)
1168 /* Update the root variable. value_of_root can return NULL
1169 if the variable is no longer around, i.e. we stepped out of
1170 the frame in which a local existed. We are letting the
1171 value_of_root variable dispose of the varobj if the type
1173 new = value_of_root (varp
, &type_changed
);
1175 /* If this is a floating varobj, and its type has changed,
1176 them note that it's changed. */
1178 VEC_safe_push (varobj_p
, result
, *varp
);
1180 if (install_new_value ((*varp
), new, type_changed
))
1182 /* If type_changed is 1, install_new_value will never return
1183 non-zero, so we'll never report the same variable twice. */
1184 gdb_assert (!type_changed
);
1185 VEC_safe_push (varobj_p
, result
, *varp
);
1190 /* This means the varobj itself is out of scope.
1192 VEC_free (varobj_p
, result
);
1193 return NOT_IN_SCOPE
;
1197 VEC_safe_push (varobj_p
, stack
, *varp
);
1199 /* Walk through the children, reconstructing them all. */
1200 while (!VEC_empty (varobj_p
, stack
))
1202 v
= VEC_pop (varobj_p
, stack
);
1204 /* Push any children. Use reverse order so that the first
1205 child is popped from the work stack first, and so
1206 will be added to result first. This does not
1207 affect correctness, just "nicer". */
1208 for (i
= VEC_length (varobj_p
, v
->children
)-1; i
>= 0; --i
)
1210 varobj_p c
= VEC_index (varobj_p
, v
->children
, i
);
1211 /* Child may be NULL if explicitly deleted by -var-delete. */
1212 if (c
!= NULL
&& !c
->frozen
)
1213 VEC_safe_push (varobj_p
, stack
, c
);
1216 /* Update this variable, unless it's a root, which is already
1218 if (v
->root
->rootvar
!= v
)
1220 new = value_of_child (v
->parent
, v
->index
);
1221 if (install_new_value (v
, new, 0 /* type not changed */))
1223 /* Note that it's changed */
1224 VEC_safe_push (varobj_p
, result
, v
);
1230 /* Alloc (changed + 1) list entries. */
1231 changed
= VEC_length (varobj_p
, result
);
1232 *changelist
= xmalloc ((changed
+ 1) * sizeof (struct varobj
*));
1235 for (i
= 0; i
< changed
; ++i
)
1237 *cv
= VEC_index (varobj_p
, result
, i
);
1238 gdb_assert (*cv
!= NULL
);
1243 VEC_free (varobj_p
, stack
);
1244 VEC_free (varobj_p
, result
);
1247 return TYPE_CHANGED
;
1253 /* Helper functions */
1256 * Variable object construction/destruction
1260 delete_variable (struct cpstack
**resultp
, struct varobj
*var
,
1261 int only_children_p
)
1265 delete_variable_1 (resultp
, &delcount
, var
,
1266 only_children_p
, 1 /* remove_from_parent_p */ );
1271 /* Delete the variable object VAR and its children */
1272 /* IMPORTANT NOTE: If we delete a variable which is a child
1273 and the parent is not removed we dump core. It must be always
1274 initially called with remove_from_parent_p set */
1276 delete_variable_1 (struct cpstack
**resultp
, int *delcountp
,
1277 struct varobj
*var
, int only_children_p
,
1278 int remove_from_parent_p
)
1282 /* Delete any children of this variable, too. */
1283 for (i
= 0; i
< VEC_length (varobj_p
, var
->children
); ++i
)
1285 varobj_p child
= VEC_index (varobj_p
, var
->children
, i
);
1288 if (!remove_from_parent_p
)
1289 child
->parent
= NULL
;
1290 delete_variable_1 (resultp
, delcountp
, child
, 0, only_children_p
);
1292 VEC_free (varobj_p
, var
->children
);
1294 /* if we were called to delete only the children we are done here */
1295 if (only_children_p
)
1298 /* Otherwise, add it to the list of deleted ones and proceed to do so */
1299 /* If the name is null, this is a temporary variable, that has not
1300 yet been installed, don't report it, it belongs to the caller... */
1301 if (var
->obj_name
!= NULL
)
1303 cppush (resultp
, xstrdup (var
->obj_name
));
1304 *delcountp
= *delcountp
+ 1;
1307 /* If this variable has a parent, remove it from its parent's list */
1308 /* OPTIMIZATION: if the parent of this variable is also being deleted,
1309 (as indicated by remove_from_parent_p) we don't bother doing an
1310 expensive list search to find the element to remove when we are
1311 discarding the list afterwards */
1312 if ((remove_from_parent_p
) && (var
->parent
!= NULL
))
1314 VEC_replace (varobj_p
, var
->parent
->children
, var
->index
, NULL
);
1317 if (var
->obj_name
!= NULL
)
1318 uninstall_variable (var
);
1320 /* Free memory associated with this variable */
1321 free_variable (var
);
1324 /* Install the given variable VAR with the object name VAR->OBJ_NAME. */
1326 install_variable (struct varobj
*var
)
1329 struct vlist
*newvl
;
1331 unsigned int index
= 0;
1334 for (chp
= var
->obj_name
; *chp
; chp
++)
1336 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
1339 cv
= *(varobj_table
+ index
);
1340 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, var
->obj_name
) != 0))
1344 error (_("Duplicate variable object name"));
1346 /* Add varobj to hash table */
1347 newvl
= xmalloc (sizeof (struct vlist
));
1348 newvl
->next
= *(varobj_table
+ index
);
1350 *(varobj_table
+ index
) = newvl
;
1352 /* If root, add varobj to root list */
1353 if (is_root_p (var
))
1355 /* Add to list of root variables */
1356 if (rootlist
== NULL
)
1357 var
->root
->next
= NULL
;
1359 var
->root
->next
= rootlist
;
1360 rootlist
= var
->root
;
1367 /* Unistall the object VAR. */
1369 uninstall_variable (struct varobj
*var
)
1373 struct varobj_root
*cr
;
1374 struct varobj_root
*prer
;
1376 unsigned int index
= 0;
1379 /* Remove varobj from hash table */
1380 for (chp
= var
->obj_name
; *chp
; chp
++)
1382 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
1385 cv
= *(varobj_table
+ index
);
1387 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, var
->obj_name
) != 0))
1394 fprintf_unfiltered (gdb_stdlog
, "Deleting %s\n", var
->obj_name
);
1399 ("Assertion failed: Could not find variable object \"%s\" to delete",
1405 *(varobj_table
+ index
) = cv
->next
;
1407 prev
->next
= cv
->next
;
1411 /* If root, remove varobj from root list */
1412 if (is_root_p (var
))
1414 /* Remove from list of root variables */
1415 if (rootlist
== var
->root
)
1416 rootlist
= var
->root
->next
;
1421 while ((cr
!= NULL
) && (cr
->rootvar
!= var
))
1429 ("Assertion failed: Could not find varobj \"%s\" in root list",
1436 prer
->next
= cr
->next
;
1443 /* Create and install a child of the parent of the given name */
1444 static struct varobj
*
1445 create_child (struct varobj
*parent
, int index
, char *name
)
1447 struct varobj
*child
;
1449 struct value
*value
;
1451 child
= new_variable ();
1453 /* name is allocated by name_of_child */
1455 child
->index
= index
;
1456 value
= value_of_child (parent
, index
);
1457 child
->parent
= parent
;
1458 child
->root
= parent
->root
;
1459 childs_name
= xstrprintf ("%s.%s", parent
->obj_name
, name
);
1460 child
->obj_name
= childs_name
;
1461 install_variable (child
);
1463 /* Compute the type of the child. Must do this before
1464 calling install_new_value. */
1466 /* If the child had no evaluation errors, var->value
1467 will be non-NULL and contain a valid type. */
1468 child
->type
= value_type (value
);
1470 /* Otherwise, we must compute the type. */
1471 child
->type
= (*child
->root
->lang
->type_of_child
) (child
->parent
,
1473 install_new_value (child
, value
, 1);
1480 * Miscellaneous utility functions.
1483 /* Allocate memory and initialize a new variable */
1484 static struct varobj
*
1489 var
= (struct varobj
*) xmalloc (sizeof (struct varobj
));
1491 var
->path_expr
= NULL
;
1492 var
->obj_name
= NULL
;
1496 var
->num_children
= -1;
1498 var
->children
= NULL
;
1502 var
->print_value
= NULL
;
1504 var
->not_fetched
= 0;
1509 /* Allocate memory and initialize a new root variable */
1510 static struct varobj
*
1511 new_root_variable (void)
1513 struct varobj
*var
= new_variable ();
1514 var
->root
= (struct varobj_root
*) xmalloc (sizeof (struct varobj_root
));;
1515 var
->root
->lang
= NULL
;
1516 var
->root
->exp
= NULL
;
1517 var
->root
->valid_block
= NULL
;
1518 var
->root
->frame
= null_frame_id
;
1519 var
->root
->floating
= 0;
1520 var
->root
->rootvar
= NULL
;
1521 var
->root
->is_valid
= 1;
1526 /* Free any allocated memory associated with VAR. */
1528 free_variable (struct varobj
*var
)
1530 /* Free the expression if this is a root variable. */
1531 if (is_root_p (var
))
1533 free_current_contents (&var
->root
->exp
);
1538 xfree (var
->obj_name
);
1539 xfree (var
->print_value
);
1540 xfree (var
->path_expr
);
1545 do_free_variable_cleanup (void *var
)
1547 free_variable (var
);
1550 static struct cleanup
*
1551 make_cleanup_free_variable (struct varobj
*var
)
1553 return make_cleanup (do_free_variable_cleanup
, var
);
1556 /* This returns the type of the variable. It also skips past typedefs
1557 to return the real type of the variable.
1559 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
1560 except within get_target_type and get_type. */
1561 static struct type
*
1562 get_type (struct varobj
*var
)
1568 type
= check_typedef (type
);
1573 /* Return the type of the value that's stored in VAR,
1574 or that would have being stored there if the
1575 value were accessible.
1577 This differs from VAR->type in that VAR->type is always
1578 the true type of the expession in the source language.
1579 The return value of this function is the type we're
1580 actually storing in varobj, and using for displaying
1581 the values and for comparing previous and new values.
1583 For example, top-level references are always stripped. */
1584 static struct type
*
1585 get_value_type (struct varobj
*var
)
1590 type
= value_type (var
->value
);
1594 type
= check_typedef (type
);
1596 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
1597 type
= get_target_type (type
);
1599 type
= check_typedef (type
);
1604 /* This returns the target type (or NULL) of TYPE, also skipping
1605 past typedefs, just like get_type ().
1607 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
1608 except within get_target_type and get_type. */
1609 static struct type
*
1610 get_target_type (struct type
*type
)
1614 type
= TYPE_TARGET_TYPE (type
);
1616 type
= check_typedef (type
);
1622 /* What is the default display for this variable? We assume that
1623 everything is "natural". Any exceptions? */
1624 static enum varobj_display_formats
1625 variable_default_display (struct varobj
*var
)
1627 return FORMAT_NATURAL
;
1630 /* FIXME: The following should be generic for any pointer */
1632 cppush (struct cpstack
**pstack
, char *name
)
1636 s
= (struct cpstack
*) xmalloc (sizeof (struct cpstack
));
1642 /* FIXME: The following should be generic for any pointer */
1644 cppop (struct cpstack
**pstack
)
1649 if ((*pstack
)->name
== NULL
&& (*pstack
)->next
== NULL
)
1654 *pstack
= (*pstack
)->next
;
1661 * Language-dependencies
1664 /* Common entry points */
1666 /* Get the language of variable VAR. */
1667 static enum varobj_languages
1668 variable_language (struct varobj
*var
)
1670 enum varobj_languages lang
;
1672 switch (var
->root
->exp
->language_defn
->la_language
)
1678 case language_cplus
:
1689 /* Return the number of children for a given variable.
1690 The result of this function is defined by the language
1691 implementation. The number of children returned by this function
1692 is the number of children that the user will see in the variable
1695 number_of_children (struct varobj
*var
)
1697 return (*var
->root
->lang
->number_of_children
) (var
);;
1700 /* What is the expression for the root varobj VAR? Returns a malloc'd string. */
1702 name_of_variable (struct varobj
*var
)
1704 return (*var
->root
->lang
->name_of_variable
) (var
);
1707 /* What is the name of the INDEX'th child of VAR? Returns a malloc'd string. */
1709 name_of_child (struct varobj
*var
, int index
)
1711 return (*var
->root
->lang
->name_of_child
) (var
, index
);
1714 /* What is the ``struct value *'' of the root variable VAR?
1715 For floating variable object, evaluation can get us a value
1716 of different type from what is stored in varobj already. In
1718 - *type_changed will be set to 1
1719 - old varobj will be freed, and new one will be
1720 created, with the same name.
1721 - *var_handle will be set to the new varobj
1722 Otherwise, *type_changed will be set to 0. */
1723 static struct value
*
1724 value_of_root (struct varobj
**var_handle
, int *type_changed
)
1728 if (var_handle
== NULL
)
1733 /* This should really be an exception, since this should
1734 only get called with a root variable. */
1736 if (!is_root_p (var
))
1739 if (var
->root
->floating
)
1741 struct varobj
*tmp_var
;
1742 char *old_type
, *new_type
;
1744 tmp_var
= varobj_create (NULL
, var
->name
, (CORE_ADDR
) 0,
1745 USE_SELECTED_FRAME
);
1746 if (tmp_var
== NULL
)
1750 old_type
= varobj_get_type (var
);
1751 new_type
= varobj_get_type (tmp_var
);
1752 if (strcmp (old_type
, new_type
) == 0)
1754 varobj_delete (tmp_var
, NULL
, 0);
1760 savestring (var
->obj_name
, strlen (var
->obj_name
));
1761 varobj_delete (var
, NULL
, 0);
1763 install_variable (tmp_var
);
1764 *var_handle
= tmp_var
;
1776 return (*var
->root
->lang
->value_of_root
) (var_handle
);
1779 /* What is the ``struct value *'' for the INDEX'th child of PARENT? */
1780 static struct value
*
1781 value_of_child (struct varobj
*parent
, int index
)
1783 struct value
*value
;
1785 value
= (*parent
->root
->lang
->value_of_child
) (parent
, index
);
1790 /* GDB already has a command called "value_of_variable". Sigh. */
1792 my_value_of_variable (struct varobj
*var
, enum varobj_display_formats format
)
1794 if (var
->root
->is_valid
)
1795 return (*var
->root
->lang
->value_of_variable
) (var
, format
);
1801 value_get_print_value (struct value
*value
, enum varobj_display_formats format
)
1804 struct ui_file
*stb
;
1805 struct cleanup
*old_chain
;
1811 stb
= mem_fileopen ();
1812 old_chain
= make_cleanup_ui_file_delete (stb
);
1814 common_val_print (value
, stb
, format_code
[(int) format
], 1, 0, 0);
1815 thevalue
= ui_file_xstrdup (stb
, &dummy
);
1817 do_cleanups (old_chain
);
1822 varobj_editable_p (struct varobj
*var
)
1825 struct value
*value
;
1827 if (!(var
->root
->is_valid
&& var
->value
&& VALUE_LVAL (var
->value
)))
1830 type
= get_value_type (var
);
1832 switch (TYPE_CODE (type
))
1834 case TYPE_CODE_STRUCT
:
1835 case TYPE_CODE_UNION
:
1836 case TYPE_CODE_ARRAY
:
1837 case TYPE_CODE_FUNC
:
1838 case TYPE_CODE_METHOD
:
1848 /* Return non-zero if changes in value of VAR
1849 must be detected and reported by -var-update.
1850 Return zero is -var-update should never report
1851 changes of such values. This makes sense for structures
1852 (since the changes in children values will be reported separately),
1853 or for artifical objects (like 'public' pseudo-field in C++).
1855 Return value of 0 means that gdb need not call value_fetch_lazy
1856 for the value of this variable object. */
1858 varobj_value_is_changeable_p (struct varobj
*var
)
1863 if (CPLUS_FAKE_CHILD (var
))
1866 type
= get_value_type (var
);
1868 switch (TYPE_CODE (type
))
1870 case TYPE_CODE_STRUCT
:
1871 case TYPE_CODE_UNION
:
1872 case TYPE_CODE_ARRAY
:
1883 /* Return 1 if that varobj is floating, that is is always evaluated in the
1884 selected frame, and not bound to thread/frame. Such variable objects
1885 are created using '@' as frame specifier to -var-create. */
1887 varobj_floating_p (struct varobj
*var
)
1889 return var
->root
->floating
;
1892 /* Given the value and the type of a variable object,
1893 adjust the value and type to those necessary
1894 for getting children of the variable object.
1895 This includes dereferencing top-level references
1896 to all types and dereferencing pointers to
1899 Both TYPE and *TYPE should be non-null. VALUE
1900 can be null if we want to only translate type.
1901 *VALUE can be null as well -- if the parent
1904 If WAS_PTR is not NULL, set *WAS_PTR to 0 or 1
1905 depending on whether pointer was deferenced
1906 in this function. */
1908 adjust_value_for_child_access (struct value
**value
,
1912 gdb_assert (type
&& *type
);
1917 *type
= check_typedef (*type
);
1919 /* The type of value stored in varobj, that is passed
1920 to us, is already supposed to be
1921 reference-stripped. */
1923 gdb_assert (TYPE_CODE (*type
) != TYPE_CODE_REF
);
1925 /* Pointers to structures are treated just like
1926 structures when accessing children. Don't
1927 dererences pointers to other types. */
1928 if (TYPE_CODE (*type
) == TYPE_CODE_PTR
)
1930 struct type
*target_type
= get_target_type (*type
);
1931 if (TYPE_CODE (target_type
) == TYPE_CODE_STRUCT
1932 || TYPE_CODE (target_type
) == TYPE_CODE_UNION
)
1934 if (value
&& *value
)
1936 int success
= gdb_value_ind (*value
, value
);
1940 *type
= target_type
;
1946 /* The 'get_target_type' function calls check_typedef on
1947 result, so we can immediately check type code. No
1948 need to call check_typedef here. */
1953 c_number_of_children (struct varobj
*var
)
1955 struct type
*type
= get_value_type (var
);
1957 struct type
*target
;
1959 adjust_value_for_child_access (NULL
, &type
, NULL
);
1960 target
= get_target_type (type
);
1962 switch (TYPE_CODE (type
))
1964 case TYPE_CODE_ARRAY
:
1965 if (TYPE_LENGTH (type
) > 0 && TYPE_LENGTH (target
) > 0
1966 && TYPE_ARRAY_UPPER_BOUND_TYPE (type
) != BOUND_CANNOT_BE_DETERMINED
)
1967 children
= TYPE_LENGTH (type
) / TYPE_LENGTH (target
);
1969 /* If we don't know how many elements there are, don't display
1974 case TYPE_CODE_STRUCT
:
1975 case TYPE_CODE_UNION
:
1976 children
= TYPE_NFIELDS (type
);
1980 /* The type here is a pointer to non-struct. Typically, pointers
1981 have one child, except for function ptrs, which have no children,
1982 and except for void*, as we don't know what to show.
1984 We can show char* so we allow it to be dereferenced. If you decide
1985 to test for it, please mind that a little magic is necessary to
1986 properly identify it: char* has TYPE_CODE == TYPE_CODE_INT and
1987 TYPE_NAME == "char" */
1988 if (TYPE_CODE (target
) == TYPE_CODE_FUNC
1989 || TYPE_CODE (target
) == TYPE_CODE_VOID
)
1996 /* Other types have no children */
2004 c_name_of_variable (struct varobj
*parent
)
2006 return savestring (parent
->name
, strlen (parent
->name
));
2009 /* Return the value of element TYPE_INDEX of a structure
2010 value VALUE. VALUE's type should be a structure,
2011 or union, or a typedef to struct/union.
2013 Returns NULL if getting the value fails. Never throws. */
2014 static struct value
*
2015 value_struct_element_index (struct value
*value
, int type_index
)
2017 struct value
*result
= NULL
;
2018 volatile struct gdb_exception e
;
2020 struct type
*type
= value_type (value
);
2021 type
= check_typedef (type
);
2023 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
2024 || TYPE_CODE (type
) == TYPE_CODE_UNION
);
2026 TRY_CATCH (e
, RETURN_MASK_ERROR
)
2028 if (TYPE_FIELD_STATIC (type
, type_index
))
2029 result
= value_static_field (type
, type_index
);
2031 result
= value_primitive_field (value
, 0, type_index
, type
);
2043 /* Obtain the information about child INDEX of the variable
2045 If CNAME is not null, sets *CNAME to the name of the child relative
2047 If CVALUE is not null, sets *CVALUE to the value of the child.
2048 If CTYPE is not null, sets *CTYPE to the type of the child.
2050 If any of CNAME, CVALUE, or CTYPE is not null, but the corresponding
2051 information cannot be determined, set *CNAME, *CVALUE, or *CTYPE
2054 c_describe_child (struct varobj
*parent
, int index
,
2055 char **cname
, struct value
**cvalue
, struct type
**ctype
,
2056 char **cfull_expression
)
2058 struct value
*value
= parent
->value
;
2059 struct type
*type
= get_value_type (parent
);
2060 char *parent_expression
= NULL
;
2069 if (cfull_expression
)
2071 *cfull_expression
= NULL
;
2072 parent_expression
= varobj_get_path_expr (parent
);
2074 adjust_value_for_child_access (&value
, &type
, &was_ptr
);
2076 switch (TYPE_CODE (type
))
2078 case TYPE_CODE_ARRAY
:
2080 *cname
= xstrprintf ("%d", index
2081 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
)));
2083 if (cvalue
&& value
)
2085 int real_index
= index
+ TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
));
2086 struct value
*indval
=
2087 value_from_longest (builtin_type_int
, (LONGEST
) real_index
);
2088 gdb_value_subscript (value
, indval
, cvalue
);
2092 *ctype
= get_target_type (type
);
2094 if (cfull_expression
)
2095 *cfull_expression
= xstrprintf ("(%s)[%d]", parent_expression
,
2097 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
)));
2102 case TYPE_CODE_STRUCT
:
2103 case TYPE_CODE_UNION
:
2106 char *string
= TYPE_FIELD_NAME (type
, index
);
2107 *cname
= savestring (string
, strlen (string
));
2110 if (cvalue
&& value
)
2112 /* For C, varobj index is the same as type index. */
2113 *cvalue
= value_struct_element_index (value
, index
);
2117 *ctype
= TYPE_FIELD_TYPE (type
, index
);
2119 if (cfull_expression
)
2121 char *join
= was_ptr
? "->" : ".";
2122 *cfull_expression
= xstrprintf ("(%s)%s%s", parent_expression
, join
,
2123 TYPE_FIELD_NAME (type
, index
));
2130 *cname
= xstrprintf ("*%s", parent
->name
);
2132 if (cvalue
&& value
)
2134 int success
= gdb_value_ind (value
, cvalue
);
2139 /* Don't use get_target_type because it calls
2140 check_typedef and here, we want to show the true
2141 declared type of the variable. */
2143 *ctype
= TYPE_TARGET_TYPE (type
);
2145 if (cfull_expression
)
2146 *cfull_expression
= xstrprintf ("*(%s)", parent_expression
);
2151 /* This should not happen */
2153 *cname
= xstrdup ("???");
2154 if (cfull_expression
)
2155 *cfull_expression
= xstrdup ("???");
2156 /* Don't set value and type, we don't know then. */
2161 c_name_of_child (struct varobj
*parent
, int index
)
2164 c_describe_child (parent
, index
, &name
, NULL
, NULL
, NULL
);
2169 c_path_expr_of_child (struct varobj
*child
)
2171 c_describe_child (child
->parent
, child
->index
, NULL
, NULL
, NULL
,
2173 return child
->path_expr
;
2176 /* If frame associated with VAR can be found, switch
2177 to it and return 1. Otherwise, return 0. */
2179 check_scope (struct varobj
*var
)
2181 struct frame_info
*fi
;
2184 fi
= frame_find_by_id (var
->root
->frame
);
2189 CORE_ADDR pc
= get_frame_pc (fi
);
2190 if (pc
< BLOCK_START (var
->root
->valid_block
) ||
2191 pc
>= BLOCK_END (var
->root
->valid_block
))
2199 static struct value
*
2200 c_value_of_root (struct varobj
**var_handle
)
2202 struct value
*new_val
= NULL
;
2203 struct varobj
*var
= *var_handle
;
2204 struct frame_info
*fi
;
2205 int within_scope
= 0;
2206 struct cleanup
*back_to
;
2208 /* Only root variables can be updated... */
2209 if (!is_root_p (var
))
2210 /* Not a root var */
2213 back_to
= make_cleanup_restore_current_thread (
2214 inferior_ptid
, get_frame_id (deprecated_safe_get_selected_frame ()));
2216 /* Determine whether the variable is still around. */
2217 if (var
->root
->valid_block
== NULL
|| var
->root
->floating
)
2219 else if (var
->root
->thread_id
== 0)
2221 /* The program was single-threaded when the variable object was
2222 created. Technically, it's possible that the program became
2223 multi-threaded since then, but we don't support such
2225 within_scope
= check_scope (var
);
2229 ptid_t ptid
= thread_id_to_pid (var
->root
->thread_id
);
2230 if (in_thread_list (ptid
))
2232 switch_to_thread (ptid
);
2233 within_scope
= check_scope (var
);
2239 /* We need to catch errors here, because if evaluate
2240 expression fails we want to just return NULL. */
2241 gdb_evaluate_expression (var
->root
->exp
, &new_val
);
2245 do_cleanups (back_to
);
2250 static struct value
*
2251 c_value_of_child (struct varobj
*parent
, int index
)
2253 struct value
*value
= NULL
;
2254 c_describe_child (parent
, index
, NULL
, &value
, NULL
, NULL
);
2259 static struct type
*
2260 c_type_of_child (struct varobj
*parent
, int index
)
2262 struct type
*type
= NULL
;
2263 c_describe_child (parent
, index
, NULL
, NULL
, &type
, NULL
);
2268 c_value_of_variable (struct varobj
*var
, enum varobj_display_formats format
)
2270 /* BOGUS: if val_print sees a struct/class, or a reference to one,
2271 it will print out its children instead of "{...}". So we need to
2272 catch that case explicitly. */
2273 struct type
*type
= get_type (var
);
2275 /* Strip top-level references. */
2276 while (TYPE_CODE (type
) == TYPE_CODE_REF
)
2277 type
= check_typedef (TYPE_TARGET_TYPE (type
));
2279 switch (TYPE_CODE (type
))
2281 case TYPE_CODE_STRUCT
:
2282 case TYPE_CODE_UNION
:
2283 return xstrdup ("{...}");
2286 case TYPE_CODE_ARRAY
:
2289 number
= xstrprintf ("[%d]", var
->num_children
);
2296 if (var
->value
== NULL
)
2298 /* This can happen if we attempt to get the value of a struct
2299 member when the parent is an invalid pointer. This is an
2300 error condition, so we should tell the caller. */
2305 if (var
->not_fetched
&& value_lazy (var
->value
))
2306 /* Frozen variable and no value yet. We don't
2307 implicitly fetch the value. MI response will
2308 use empty string for the value, which is OK. */
2311 gdb_assert (varobj_value_is_changeable_p (var
));
2312 gdb_assert (!value_lazy (var
->value
));
2314 /* If the specified format is the current one,
2315 we can reuse print_value */
2316 if (format
== var
->format
)
2317 return xstrdup (var
->print_value
);
2319 return value_get_print_value (var
->value
, format
);
2329 cplus_number_of_children (struct varobj
*var
)
2332 int children
, dont_know
;
2337 if (!CPLUS_FAKE_CHILD (var
))
2339 type
= get_value_type (var
);
2340 adjust_value_for_child_access (NULL
, &type
, NULL
);
2342 if (((TYPE_CODE (type
)) == TYPE_CODE_STRUCT
) ||
2343 ((TYPE_CODE (type
)) == TYPE_CODE_UNION
))
2347 cplus_class_num_children (type
, kids
);
2348 if (kids
[v_public
] != 0)
2350 if (kids
[v_private
] != 0)
2352 if (kids
[v_protected
] != 0)
2355 /* Add any baseclasses */
2356 children
+= TYPE_N_BASECLASSES (type
);
2359 /* FIXME: save children in var */
2366 type
= get_value_type (var
->parent
);
2367 adjust_value_for_child_access (NULL
, &type
, NULL
);
2369 cplus_class_num_children (type
, kids
);
2370 if (strcmp (var
->name
, "public") == 0)
2371 children
= kids
[v_public
];
2372 else if (strcmp (var
->name
, "private") == 0)
2373 children
= kids
[v_private
];
2375 children
= kids
[v_protected
];
2380 children
= c_number_of_children (var
);
2385 /* Compute # of public, private, and protected variables in this class.
2386 That means we need to descend into all baseclasses and find out
2387 how many are there, too. */
2389 cplus_class_num_children (struct type
*type
, int children
[3])
2393 children
[v_public
] = 0;
2394 children
[v_private
] = 0;
2395 children
[v_protected
] = 0;
2397 for (i
= TYPE_N_BASECLASSES (type
); i
< TYPE_NFIELDS (type
); i
++)
2399 /* If we have a virtual table pointer, omit it. */
2400 if (TYPE_VPTR_BASETYPE (type
) == type
&& TYPE_VPTR_FIELDNO (type
) == i
)
2403 if (TYPE_FIELD_PROTECTED (type
, i
))
2404 children
[v_protected
]++;
2405 else if (TYPE_FIELD_PRIVATE (type
, i
))
2406 children
[v_private
]++;
2408 children
[v_public
]++;
2413 cplus_name_of_variable (struct varobj
*parent
)
2415 return c_name_of_variable (parent
);
2418 enum accessibility
{ private_field
, protected_field
, public_field
};
2420 /* Check if field INDEX of TYPE has the specified accessibility.
2421 Return 0 if so and 1 otherwise. */
2423 match_accessibility (struct type
*type
, int index
, enum accessibility acc
)
2425 if (acc
== private_field
&& TYPE_FIELD_PRIVATE (type
, index
))
2427 else if (acc
== protected_field
&& TYPE_FIELD_PROTECTED (type
, index
))
2429 else if (acc
== public_field
&& !TYPE_FIELD_PRIVATE (type
, index
)
2430 && !TYPE_FIELD_PROTECTED (type
, index
))
2437 cplus_describe_child (struct varobj
*parent
, int index
,
2438 char **cname
, struct value
**cvalue
, struct type
**ctype
,
2439 char **cfull_expression
)
2442 struct value
*value
;
2445 char *parent_expression
= NULL
;
2453 if (cfull_expression
)
2454 *cfull_expression
= NULL
;
2456 if (CPLUS_FAKE_CHILD (parent
))
2458 value
= parent
->parent
->value
;
2459 type
= get_value_type (parent
->parent
);
2460 if (cfull_expression
)
2461 parent_expression
= varobj_get_path_expr (parent
->parent
);
2465 value
= parent
->value
;
2466 type
= get_value_type (parent
);
2467 if (cfull_expression
)
2468 parent_expression
= varobj_get_path_expr (parent
);
2471 adjust_value_for_child_access (&value
, &type
, &was_ptr
);
2473 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
2474 || TYPE_CODE (type
) == TYPE_CODE_UNION
)
2476 char *join
= was_ptr
? "->" : ".";
2477 if (CPLUS_FAKE_CHILD (parent
))
2479 /* The fields of the class type are ordered as they
2480 appear in the class. We are given an index for a
2481 particular access control type ("public","protected",
2482 or "private"). We must skip over fields that don't
2483 have the access control we are looking for to properly
2484 find the indexed field. */
2485 int type_index
= TYPE_N_BASECLASSES (type
);
2486 enum accessibility acc
= public_field
;
2487 if (strcmp (parent
->name
, "private") == 0)
2488 acc
= private_field
;
2489 else if (strcmp (parent
->name
, "protected") == 0)
2490 acc
= protected_field
;
2494 if (TYPE_VPTR_BASETYPE (type
) == type
2495 && type_index
== TYPE_VPTR_FIELDNO (type
))
2497 else if (match_accessibility (type
, type_index
, acc
))
2504 *cname
= xstrdup (TYPE_FIELD_NAME (type
, type_index
));
2506 if (cvalue
&& value
)
2507 *cvalue
= value_struct_element_index (value
, type_index
);
2510 *ctype
= TYPE_FIELD_TYPE (type
, type_index
);
2512 if (cfull_expression
)
2513 *cfull_expression
= xstrprintf ("((%s)%s%s)", parent_expression
,
2515 TYPE_FIELD_NAME (type
, type_index
));
2517 else if (index
< TYPE_N_BASECLASSES (type
))
2519 /* This is a baseclass. */
2521 *cname
= xstrdup (TYPE_FIELD_NAME (type
, index
));
2523 if (cvalue
&& value
)
2525 *cvalue
= value_cast (TYPE_FIELD_TYPE (type
, index
), value
);
2526 release_value (*cvalue
);
2531 *ctype
= TYPE_FIELD_TYPE (type
, index
);
2534 if (cfull_expression
)
2536 char *ptr
= was_ptr
? "*" : "";
2537 /* Cast the parent to the base' type. Note that in gdb,
2540 will create an lvalue, for all appearences, so we don't
2541 need to use more fancy:
2544 *cfull_expression
= xstrprintf ("(%s(%s%s) %s)",
2546 TYPE_FIELD_NAME (type
, index
),
2553 char *access
= NULL
;
2555 cplus_class_num_children (type
, children
);
2557 /* Everything beyond the baseclasses can
2558 only be "public", "private", or "protected"
2560 The special "fake" children are always output by varobj in
2561 this order. So if INDEX == 2, it MUST be "protected". */
2562 index
-= TYPE_N_BASECLASSES (type
);
2566 if (children
[v_public
] > 0)
2568 else if (children
[v_private
] > 0)
2571 access
= "protected";
2574 if (children
[v_public
] > 0)
2576 if (children
[v_private
] > 0)
2579 access
= "protected";
2581 else if (children
[v_private
] > 0)
2582 access
= "protected";
2585 /* Must be protected */
2586 access
= "protected";
2593 gdb_assert (access
);
2595 *cname
= xstrdup (access
);
2597 /* Value and type and full expression are null here. */
2602 c_describe_child (parent
, index
, cname
, cvalue
, ctype
, cfull_expression
);
2607 cplus_name_of_child (struct varobj
*parent
, int index
)
2610 cplus_describe_child (parent
, index
, &name
, NULL
, NULL
, NULL
);
2615 cplus_path_expr_of_child (struct varobj
*child
)
2617 cplus_describe_child (child
->parent
, child
->index
, NULL
, NULL
, NULL
,
2619 return child
->path_expr
;
2622 static struct value
*
2623 cplus_value_of_root (struct varobj
**var_handle
)
2625 return c_value_of_root (var_handle
);
2628 static struct value
*
2629 cplus_value_of_child (struct varobj
*parent
, int index
)
2631 struct value
*value
= NULL
;
2632 cplus_describe_child (parent
, index
, NULL
, &value
, NULL
, NULL
);
2636 static struct type
*
2637 cplus_type_of_child (struct varobj
*parent
, int index
)
2639 struct type
*type
= NULL
;
2640 cplus_describe_child (parent
, index
, NULL
, NULL
, &type
, NULL
);
2645 cplus_value_of_variable (struct varobj
*var
, enum varobj_display_formats format
)
2648 /* If we have one of our special types, don't print out
2650 if (CPLUS_FAKE_CHILD (var
))
2651 return xstrdup ("");
2653 return c_value_of_variable (var
, format
);
2659 java_number_of_children (struct varobj
*var
)
2661 return cplus_number_of_children (var
);
2665 java_name_of_variable (struct varobj
*parent
)
2669 name
= cplus_name_of_variable (parent
);
2670 /* If the name has "-" in it, it is because we
2671 needed to escape periods in the name... */
2674 while (*p
!= '\000')
2685 java_name_of_child (struct varobj
*parent
, int index
)
2689 name
= cplus_name_of_child (parent
, index
);
2690 /* Escape any periods in the name... */
2693 while (*p
!= '\000')
2704 java_path_expr_of_child (struct varobj
*child
)
2709 static struct value
*
2710 java_value_of_root (struct varobj
**var_handle
)
2712 return cplus_value_of_root (var_handle
);
2715 static struct value
*
2716 java_value_of_child (struct varobj
*parent
, int index
)
2718 return cplus_value_of_child (parent
, index
);
2721 static struct type
*
2722 java_type_of_child (struct varobj
*parent
, int index
)
2724 return cplus_type_of_child (parent
, index
);
2728 java_value_of_variable (struct varobj
*var
, enum varobj_display_formats format
)
2730 return cplus_value_of_variable (var
, format
);
2733 extern void _initialize_varobj (void);
2735 _initialize_varobj (void)
2737 int sizeof_table
= sizeof (struct vlist
*) * VAROBJ_TABLE_SIZE
;
2739 varobj_table
= xmalloc (sizeof_table
);
2740 memset (varobj_table
, 0, sizeof_table
);
2742 add_setshow_zinteger_cmd ("debugvarobj", class_maintenance
,
2744 Set varobj debugging."), _("\
2745 Show varobj debugging."), _("\
2746 When non-zero, varobj debugging is enabled."),
2749 &setlist
, &showlist
);
2752 /* Invalidate the varobjs that are tied to locals and re-create the ones that
2753 are defined on globals.
2754 Invalidated varobjs will be always printed in_scope="invalid". */
2756 varobj_invalidate (void)
2758 struct varobj
**all_rootvarobj
;
2759 struct varobj
**varp
;
2761 if (varobj_list (&all_rootvarobj
) > 0)
2763 varp
= all_rootvarobj
;
2764 while (*varp
!= NULL
)
2766 /* global var must be re-evaluated. */
2767 if ((*varp
)->root
->valid_block
== NULL
)
2769 struct varobj
*tmp_var
;
2771 /* Try to create a varobj with same expression. If we succeed replace
2772 the old varobj, otherwise invalidate it. */
2773 tmp_var
= varobj_create (NULL
, (*varp
)->name
, (CORE_ADDR
) 0, USE_CURRENT_FRAME
);
2774 if (tmp_var
!= NULL
)
2776 tmp_var
->obj_name
= xstrdup ((*varp
)->obj_name
);
2777 varobj_delete (*varp
, NULL
, 0);
2778 install_variable (tmp_var
);
2781 (*varp
)->root
->is_valid
= 0;
2783 else /* locals must be invalidated. */
2784 (*varp
)->root
->is_valid
= 0;
2788 xfree (all_rootvarobj
);