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 /* If 1, "update" always recomputes the frame & valid block
72 using the currently selected frame. */
73 int use_selected_frame
;
75 /* Flag that indicates validity: set to 0 when this varobj_root refers
76 to symbols that do not exist anymore. */
79 /* Language info for this variable and its children */
80 struct language_specific
*lang
;
82 /* The varobj for this root node. */
83 struct varobj
*rootvar
;
85 /* Next root variable */
86 struct varobj_root
*next
;
89 /* Every variable in the system has a structure of this type defined
90 for it. This structure holds all information necessary to manipulate
91 a particular object variable. Members which must be freed are noted. */
95 /* Alloc'd name of the variable for this object.. If this variable is a
96 child, then this name will be the child's source name.
98 /* NOTE: This is the "expression" */
101 /* Alloc'd expression for this child. Can be used to create a
102 root variable corresponding to this child. */
105 /* The alloc'd name for this variable's object. This is here for
106 convenience when constructing this object's children. */
109 /* Index of this variable in its parent or -1 */
112 /* The type of this variable. This can be NULL
113 for artifial variable objects -- currently, the "accessibility"
114 variable objects in C++. */
117 /* The value of this expression or subexpression. A NULL value
118 indicates there was an error getting this value.
119 Invariant: if varobj_value_is_changeable_p (this) is non-zero,
120 the value is either NULL, or not lazy. */
123 /* The number of (immediate) children this variable has */
126 /* If this object is a child, this points to its immediate parent. */
127 struct varobj
*parent
;
129 /* Children of this object. */
130 VEC (varobj_p
) *children
;
132 /* Description of the root variable. Points to root variable for children. */
133 struct varobj_root
*root
;
135 /* The format of the output for this object */
136 enum varobj_display_formats format
;
138 /* Was this variable updated via a varobj_set_value operation */
141 /* Last print value. */
144 /* Is this variable frozen. Frozen variables are never implicitly
145 updated by -var-update *
146 or -var-update <direct-or-indirect-parent>. */
149 /* Is the value of this variable intentionally not fetched? It is
150 not fetched if either the variable is frozen, or any parents is
158 struct cpstack
*next
;
161 /* A list of varobjs */
169 /* Private function prototypes */
171 /* Helper functions for the above subcommands. */
173 static int delete_variable (struct cpstack
**, struct varobj
*, int);
175 static void delete_variable_1 (struct cpstack
**, int *,
176 struct varobj
*, int, int);
178 static int install_variable (struct varobj
*);
180 static void uninstall_variable (struct varobj
*);
182 static struct varobj
*create_child (struct varobj
*, int, char *);
184 /* Utility routines */
186 static struct varobj
*new_variable (void);
188 static struct varobj
*new_root_variable (void);
190 static void free_variable (struct varobj
*var
);
192 static struct cleanup
*make_cleanup_free_variable (struct varobj
*var
);
194 static struct type
*get_type (struct varobj
*var
);
196 static struct type
*get_value_type (struct varobj
*var
);
198 static struct type
*get_target_type (struct type
*);
200 static enum varobj_display_formats
variable_default_display (struct varobj
*);
202 static void cppush (struct cpstack
**pstack
, char *name
);
204 static char *cppop (struct cpstack
**pstack
);
206 static int install_new_value (struct varobj
*var
, struct value
*value
,
209 /* Language-specific routines. */
211 static enum varobj_languages
variable_language (struct varobj
*var
);
213 static int number_of_children (struct varobj
*);
215 static char *name_of_variable (struct varobj
*);
217 static char *name_of_child (struct varobj
*, int);
219 static struct value
*value_of_root (struct varobj
**var_handle
, int *);
221 static struct value
*value_of_child (struct varobj
*parent
, int index
);
223 static char *my_value_of_variable (struct varobj
*var
);
225 static char *value_get_print_value (struct value
*value
,
226 enum varobj_display_formats format
);
228 static int varobj_value_is_changeable_p (struct varobj
*var
);
230 static int is_root_p (struct varobj
*var
);
232 /* C implementation */
234 static int c_number_of_children (struct varobj
*var
);
236 static char *c_name_of_variable (struct varobj
*parent
);
238 static char *c_name_of_child (struct varobj
*parent
, int index
);
240 static char *c_path_expr_of_child (struct varobj
*child
);
242 static struct value
*c_value_of_root (struct varobj
**var_handle
);
244 static struct value
*c_value_of_child (struct varobj
*parent
, int index
);
246 static struct type
*c_type_of_child (struct varobj
*parent
, int index
);
248 static char *c_value_of_variable (struct varobj
*var
);
250 /* C++ implementation */
252 static int cplus_number_of_children (struct varobj
*var
);
254 static void cplus_class_num_children (struct type
*type
, int children
[3]);
256 static char *cplus_name_of_variable (struct varobj
*parent
);
258 static char *cplus_name_of_child (struct varobj
*parent
, int index
);
260 static char *cplus_path_expr_of_child (struct varobj
*child
);
262 static struct value
*cplus_value_of_root (struct varobj
**var_handle
);
264 static struct value
*cplus_value_of_child (struct varobj
*parent
, int index
);
266 static struct type
*cplus_type_of_child (struct varobj
*parent
, int index
);
268 static char *cplus_value_of_variable (struct varobj
*var
);
270 /* Java implementation */
272 static int java_number_of_children (struct varobj
*var
);
274 static char *java_name_of_variable (struct varobj
*parent
);
276 static char *java_name_of_child (struct varobj
*parent
, int index
);
278 static char *java_path_expr_of_child (struct varobj
*child
);
280 static struct value
*java_value_of_root (struct varobj
**var_handle
);
282 static struct value
*java_value_of_child (struct varobj
*parent
, int index
);
284 static struct type
*java_type_of_child (struct varobj
*parent
, int index
);
286 static char *java_value_of_variable (struct varobj
*var
);
288 /* The language specific vector */
290 struct language_specific
293 /* The language of this variable */
294 enum varobj_languages language
;
296 /* The number of children of PARENT. */
297 int (*number_of_children
) (struct varobj
* parent
);
299 /* The name (expression) of a root varobj. */
300 char *(*name_of_variable
) (struct varobj
* parent
);
302 /* The name of the INDEX'th child of PARENT. */
303 char *(*name_of_child
) (struct varobj
* parent
, int index
);
305 /* Returns the rooted expression of CHILD, which is a variable
306 obtain that has some parent. */
307 char *(*path_expr_of_child
) (struct varobj
* child
);
309 /* The ``struct value *'' of the root variable ROOT. */
310 struct value
*(*value_of_root
) (struct varobj
** root_handle
);
312 /* The ``struct value *'' of the INDEX'th child of PARENT. */
313 struct value
*(*value_of_child
) (struct varobj
* parent
, int index
);
315 /* The type of the INDEX'th child of PARENT. */
316 struct type
*(*type_of_child
) (struct varobj
* parent
, int index
);
318 /* The current value of VAR. */
319 char *(*value_of_variable
) (struct varobj
* var
);
322 /* Array of known source language routines. */
323 static struct language_specific languages
[vlang_end
] = {
324 /* Unknown (try treating as C */
327 c_number_of_children
,
330 c_path_expr_of_child
,
339 c_number_of_children
,
342 c_path_expr_of_child
,
351 cplus_number_of_children
,
352 cplus_name_of_variable
,
354 cplus_path_expr_of_child
,
356 cplus_value_of_child
,
358 cplus_value_of_variable
}
363 java_number_of_children
,
364 java_name_of_variable
,
366 java_path_expr_of_child
,
370 java_value_of_variable
}
373 /* A little convenience enum for dealing with C++/Java */
376 v_public
= 0, v_private
, v_protected
381 /* Mappings of varobj_display_formats enums to gdb's format codes */
382 static int format_code
[] = { 0, 't', 'd', 'x', 'o' };
384 /* Header of the list of root variable objects */
385 static struct varobj_root
*rootlist
;
386 static int rootcount
= 0; /* number of root varobjs in the list */
388 /* Prime number indicating the number of buckets in the hash table */
389 /* A prime large enough to avoid too many colisions */
390 #define VAROBJ_TABLE_SIZE 227
392 /* Pointer to the varobj hash table (built at run time) */
393 static struct vlist
**varobj_table
;
395 /* Is the variable X one of our "fake" children? */
396 #define CPLUS_FAKE_CHILD(x) \
397 ((x) != NULL && (x)->type == NULL && (x)->value == NULL)
400 /* API Implementation */
402 is_root_p (struct varobj
*var
)
404 return (var
->root
->rootvar
== var
);
407 /* Creates a varobj (not its children) */
409 /* Return the full FRAME which corresponds to the given CORE_ADDR
410 or NULL if no FRAME on the chain corresponds to CORE_ADDR. */
412 static struct frame_info
*
413 find_frame_addr_in_frame_chain (CORE_ADDR frame_addr
)
415 struct frame_info
*frame
= NULL
;
417 if (frame_addr
== (CORE_ADDR
) 0)
422 frame
= get_prev_frame (frame
);
425 if (get_frame_base_address (frame
) == frame_addr
)
431 varobj_create (char *objname
,
432 char *expression
, CORE_ADDR frame
, enum varobj_type type
)
435 struct frame_info
*fi
;
436 struct frame_info
*old_fi
= NULL
;
438 struct cleanup
*old_chain
;
440 /* Fill out a varobj structure for the (root) variable being constructed. */
441 var
= new_root_variable ();
442 old_chain
= make_cleanup_free_variable (var
);
444 if (expression
!= NULL
)
447 enum varobj_languages lang
;
448 struct value
*value
= NULL
;
451 /* Parse and evaluate the expression, filling in as much
452 of the variable's data as possible */
454 /* Allow creator to specify context of variable */
455 if ((type
== USE_CURRENT_FRAME
) || (type
== USE_SELECTED_FRAME
))
456 fi
= deprecated_safe_get_selected_frame ();
458 /* FIXME: cagney/2002-11-23: This code should be doing a
459 lookup using the frame ID and not just the frame's
460 ``address''. This, of course, means an interface change.
461 However, with out that interface change ISAs, such as the
462 ia64 with its two stacks, won't work. Similar goes for the
463 case where there is a frameless function. */
464 fi
= find_frame_addr_in_frame_chain (frame
);
466 /* frame = -2 means always use selected frame */
467 if (type
== USE_SELECTED_FRAME
)
468 var
->root
->use_selected_frame
= 1;
472 block
= get_frame_block (fi
, 0);
475 innermost_block
= NULL
;
476 /* Wrap the call to parse expression, so we can
477 return a sensible error. */
478 if (!gdb_parse_exp_1 (&p
, block
, 0, &var
->root
->exp
))
483 /* Don't allow variables to be created for types. */
484 if (var
->root
->exp
->elts
[0].opcode
== OP_TYPE
)
486 do_cleanups (old_chain
);
487 fprintf_unfiltered (gdb_stderr
, "Attempt to use a type name"
488 " as an expression.\n");
492 var
->format
= variable_default_display (var
);
493 var
->root
->valid_block
= innermost_block
;
494 expr_len
= strlen (expression
);
495 var
->name
= savestring (expression
, expr_len
);
496 /* For a root var, the name and the expr are the same. */
497 var
->path_expr
= savestring (expression
, expr_len
);
499 /* When the frame is different from the current frame,
500 we must select the appropriate frame before parsing
501 the expression, otherwise the value will not be current.
502 Since select_frame is so benign, just call it for all cases. */
503 if (innermost_block
&& fi
!= NULL
)
505 var
->root
->frame
= get_frame_id (fi
);
506 old_fi
= get_selected_frame (NULL
);
510 /* We definitely need to catch errors here.
511 If evaluate_expression succeeds we got the value we wanted.
512 But if it fails, we still go on with a call to evaluate_type() */
513 if (!gdb_evaluate_expression (var
->root
->exp
, &value
))
515 /* Error getting the value. Try to at least get the
517 struct value
*type_only_value
= evaluate_type (var
->root
->exp
);
518 var
->type
= value_type (type_only_value
);
521 var
->type
= value_type (value
);
523 install_new_value (var
, value
, 1 /* Initial assignment */);
525 /* Set language info */
526 lang
= variable_language (var
);
527 var
->root
->lang
= &languages
[lang
];
529 /* Set ourselves as our root */
530 var
->root
->rootvar
= var
;
532 /* Reset the selected frame */
534 select_frame (old_fi
);
537 /* If the variable object name is null, that means this
538 is a temporary variable, so don't install it. */
540 if ((var
!= NULL
) && (objname
!= NULL
))
542 var
->obj_name
= savestring (objname
, strlen (objname
));
544 /* If a varobj name is duplicated, the install will fail so
546 if (!install_variable (var
))
548 do_cleanups (old_chain
);
553 discard_cleanups (old_chain
);
557 /* Generates an unique name that can be used for a varobj */
560 varobj_gen_name (void)
565 /* generate a name for this object */
567 obj_name
= xstrprintf ("var%d", id
);
572 /* Given an "objname", returns the pointer to the corresponding varobj
573 or NULL if not found */
576 varobj_get_handle (char *objname
)
580 unsigned int index
= 0;
583 for (chp
= objname
; *chp
; chp
++)
585 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
588 cv
= *(varobj_table
+ index
);
589 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, objname
) != 0))
593 error (_("Variable object not found"));
598 /* Given the handle, return the name of the object */
601 varobj_get_objname (struct varobj
*var
)
603 return var
->obj_name
;
606 /* Given the handle, return the expression represented by the object */
609 varobj_get_expression (struct varobj
*var
)
611 return name_of_variable (var
);
614 /* Deletes a varobj and all its children if only_children == 0,
615 otherwise deletes only the children; returns a malloc'ed list of all the
616 (malloc'ed) names of the variables that have been deleted (NULL terminated) */
619 varobj_delete (struct varobj
*var
, char ***dellist
, int only_children
)
623 struct cpstack
*result
= NULL
;
626 /* Initialize a stack for temporary results */
627 cppush (&result
, NULL
);
630 /* Delete only the variable children */
631 delcount
= delete_variable (&result
, var
, 1 /* only the children */ );
633 /* Delete the variable and all its children */
634 delcount
= delete_variable (&result
, var
, 0 /* parent+children */ );
636 /* We may have been asked to return a list of what has been deleted */
639 *dellist
= xmalloc ((delcount
+ 1) * sizeof (char *));
643 *cp
= cppop (&result
);
644 while ((*cp
!= NULL
) && (mycount
> 0))
648 *cp
= cppop (&result
);
651 if (mycount
|| (*cp
!= NULL
))
652 warning (_("varobj_delete: assertion failed - mycount(=%d) <> 0"),
659 /* Set/Get variable object display format */
661 enum varobj_display_formats
662 varobj_set_display_format (struct varobj
*var
,
663 enum varobj_display_formats format
)
670 case FORMAT_HEXADECIMAL
:
672 var
->format
= format
;
676 var
->format
= variable_default_display (var
);
679 if (varobj_value_is_changeable_p (var
)
680 && var
->value
&& !value_lazy (var
->value
))
682 free (var
->print_value
);
683 var
->print_value
= value_get_print_value (var
->value
, var
->format
);
689 enum varobj_display_formats
690 varobj_get_display_format (struct varobj
*var
)
696 varobj_set_frozen (struct varobj
*var
, int frozen
)
698 /* When a variable is unfrozen, we don't fetch its value.
699 The 'not_fetched' flag remains set, so next -var-update
702 We don't fetch the value, because for structures the client
703 should do -var-update anyway. It would be bad to have different
704 client-size logic for structure and other types. */
705 var
->frozen
= frozen
;
709 varobj_get_frozen (struct varobj
*var
)
716 varobj_get_num_children (struct varobj
*var
)
718 if (var
->num_children
== -1)
719 var
->num_children
= number_of_children (var
);
721 return var
->num_children
;
724 /* Creates a list of the immediate children of a variable object;
725 the return code is the number of such children or -1 on error */
728 varobj_list_children (struct varobj
*var
)
730 struct varobj
*child
;
734 if (var
->num_children
== -1)
735 var
->num_children
= number_of_children (var
);
737 /* If that failed, give up. */
738 if (var
->num_children
== -1)
739 return var
->children
;
741 /* If we're called when the list of children is not yet initialized,
742 allocate enough elements in it. */
743 while (VEC_length (varobj_p
, var
->children
) < var
->num_children
)
744 VEC_safe_push (varobj_p
, var
->children
, NULL
);
746 for (i
= 0; i
< var
->num_children
; i
++)
748 varobj_p existing
= VEC_index (varobj_p
, var
->children
, i
);
750 if (existing
== NULL
)
752 /* Either it's the first call to varobj_list_children for
753 this variable object, and the child was never created,
754 or it was explicitly deleted by the client. */
755 name
= name_of_child (var
, i
);
756 existing
= create_child (var
, i
, name
);
757 VEC_replace (varobj_p
, var
->children
, i
, existing
);
761 return var
->children
;
764 /* Obtain the type of an object Variable as a string similar to the one gdb
765 prints on the console */
768 varobj_get_type (struct varobj
*var
)
771 struct cleanup
*old_chain
;
776 /* For the "fake" variables, do not return a type. (It's type is
778 Do not return a type for invalid variables as well. */
779 if (CPLUS_FAKE_CHILD (var
) || !var
->root
->is_valid
)
782 stb
= mem_fileopen ();
783 old_chain
= make_cleanup_ui_file_delete (stb
);
785 /* To print the type, we simply create a zero ``struct value *'' and
786 cast it to our type. We then typeprint this variable. */
787 val
= value_zero (var
->type
, not_lval
);
788 type_print (value_type (val
), "", stb
, -1);
790 thetype
= ui_file_xstrdup (stb
, &length
);
791 do_cleanups (old_chain
);
795 /* Obtain the type of an object variable. */
798 varobj_get_gdb_type (struct varobj
*var
)
803 /* Return a pointer to the full rooted expression of varobj VAR.
804 If it has not been computed yet, compute it. */
806 varobj_get_path_expr (struct varobj
*var
)
808 if (var
->path_expr
!= NULL
)
809 return var
->path_expr
;
812 /* For root varobjs, we initialize path_expr
813 when creating varobj, so here it should be
815 gdb_assert (!is_root_p (var
));
816 return (*var
->root
->lang
->path_expr_of_child
) (var
);
820 enum varobj_languages
821 varobj_get_language (struct varobj
*var
)
823 return variable_language (var
);
827 varobj_get_attributes (struct varobj
*var
)
831 if (varobj_editable_p (var
))
832 /* FIXME: define masks for attributes */
833 attributes
|= 0x00000001; /* Editable */
839 varobj_get_value (struct varobj
*var
)
841 return my_value_of_variable (var
);
844 /* Set the value of an object variable (if it is editable) to the
845 value of the given expression */
846 /* Note: Invokes functions that can call error() */
849 varobj_set_value (struct varobj
*var
, char *expression
)
855 /* The argument "expression" contains the variable's new value.
856 We need to first construct a legal expression for this -- ugh! */
857 /* Does this cover all the bases? */
858 struct expression
*exp
;
860 int saved_input_radix
= input_radix
;
861 char *s
= expression
;
864 gdb_assert (varobj_editable_p (var
));
866 input_radix
= 10; /* ALWAYS reset to decimal temporarily */
867 exp
= parse_exp_1 (&s
, 0, 0);
868 if (!gdb_evaluate_expression (exp
, &value
))
870 /* We cannot proceed without a valid expression. */
875 /* All types that are editable must also be changeable. */
876 gdb_assert (varobj_value_is_changeable_p (var
));
878 /* The value of a changeable variable object must not be lazy. */
879 gdb_assert (!value_lazy (var
->value
));
881 /* Need to coerce the input. We want to check if the
882 value of the variable object will be different
883 after assignment, and the first thing value_assign
884 does is coerce the input.
885 For example, if we are assigning an array to a pointer variable we
886 should compare the pointer with the the array's address, not with the
888 value
= coerce_array (value
);
890 /* The new value may be lazy. gdb_value_assign, or
891 rather value_contents, will take care of this.
892 If fetching of the new value will fail, gdb_value_assign
893 with catch the exception. */
894 if (!gdb_value_assign (var
->value
, value
, &val
))
897 /* If the value has changed, record it, so that next -var-update can
898 report this change. If a variable had a value of '1', we've set it
899 to '333' and then set again to '1', when -var-update will report this
900 variable as changed -- because the first assignment has set the
901 'updated' flag. There's no need to optimize that, because return value
902 of -var-update should be considered an approximation. */
903 var
->updated
= install_new_value (var
, val
, 0 /* Compare values. */);
904 input_radix
= saved_input_radix
;
908 /* Returns a malloc'ed list with all root variable objects */
910 varobj_list (struct varobj
***varlist
)
913 struct varobj_root
*croot
;
914 int mycount
= rootcount
;
916 /* Alloc (rootcount + 1) entries for the result */
917 *varlist
= xmalloc ((rootcount
+ 1) * sizeof (struct varobj
*));
921 while ((croot
!= NULL
) && (mycount
> 0))
923 *cv
= croot
->rootvar
;
928 /* Mark the end of the list */
931 if (mycount
|| (croot
!= NULL
))
933 ("varobj_list: assertion failed - wrong tally of root vars (%d:%d)",
939 /* Assign a new value to a variable object. If INITIAL is non-zero,
940 this is the first assignement after the variable object was just
941 created, or changed type. In that case, just assign the value
943 Otherwise, assign the value and if type_changeable returns non-zero,
944 find if the new value is different from the current value.
945 Return 1 if so, and 0 if the values are equal.
947 The VALUE parameter should not be released -- the function will
948 take care of releasing it when needed. */
950 install_new_value (struct varobj
*var
, struct value
*value
, int initial
)
955 int intentionally_not_fetched
= 0;
956 char *print_value
= NULL
;
958 /* We need to know the varobj's type to decide if the value should
959 be fetched or not. C++ fake children (public/protected/private) don't have
961 gdb_assert (var
->type
|| CPLUS_FAKE_CHILD (var
));
962 changeable
= varobj_value_is_changeable_p (var
);
963 need_to_fetch
= changeable
;
965 /* We are not interested in the address of references, and given
966 that in C++ a reference is not rebindable, it cannot
967 meaningfully change. So, get hold of the real value. */
970 value
= coerce_ref (value
);
971 release_value (value
);
974 if (var
->type
&& TYPE_CODE (var
->type
) == TYPE_CODE_UNION
)
975 /* For unions, we need to fetch the value implicitly because
976 of implementation of union member fetch. When gdb
977 creates a value for a field and the value of the enclosing
978 structure is not lazy, it immediately copies the necessary
979 bytes from the enclosing values. If the enclosing value is
980 lazy, the call to value_fetch_lazy on the field will read
981 the data from memory. For unions, that means we'll read the
982 same memory more than once, which is not desirable. So
986 /* The new value might be lazy. If the type is changeable,
987 that is we'll be comparing values of this type, fetch the
988 value now. Otherwise, on the next update the old value
989 will be lazy, which means we've lost that old value. */
990 if (need_to_fetch
&& value
&& value_lazy (value
))
992 struct varobj
*parent
= var
->parent
;
993 int frozen
= var
->frozen
;
994 for (; !frozen
&& parent
; parent
= parent
->parent
)
995 frozen
|= parent
->frozen
;
997 if (frozen
&& initial
)
999 /* For variables that are frozen, or are children of frozen
1000 variables, we don't do fetch on initial assignment.
1001 For non-initial assignemnt we do the fetch, since it means we're
1002 explicitly asked to compare the new value with the old one. */
1003 intentionally_not_fetched
= 1;
1005 else if (!gdb_value_fetch_lazy (value
))
1007 /* Set the value to NULL, so that for the next -var-update,
1008 we don't try to compare the new value with this value,
1009 that we couldn't even read. */
1014 /* Below, we'll be comparing string rendering of old and new
1015 values. Don't get string rendering if the value is
1016 lazy -- if it is, the code above has decided that the value
1017 should not be fetched. */
1018 if (value
&& !value_lazy (value
))
1019 print_value
= value_get_print_value (value
, var
->format
);
1021 /* If the type is changeable, compare the old and the new values.
1022 If this is the initial assignment, we don't have any old value
1024 if (!initial
&& changeable
)
1026 /* If the value of the varobj was changed by -var-set-value, then the
1027 value in the varobj and in the target is the same. However, that value
1028 is different from the value that the varobj had after the previous
1029 -var-update. So need to the varobj as changed. */
1036 /* Try to compare the values. That requires that both
1037 values are non-lazy. */
1038 if (var
->not_fetched
&& value_lazy (var
->value
))
1040 /* This is a frozen varobj and the value was never read.
1041 Presumably, UI shows some "never read" indicator.
1042 Now that we've fetched the real value, we need to report
1043 this varobj as changed so that UI can show the real
1047 else if (var
->value
== NULL
&& value
== NULL
)
1050 else if (var
->value
== NULL
|| value
== NULL
)
1056 gdb_assert (!value_lazy (var
->value
));
1057 gdb_assert (!value_lazy (value
));
1059 gdb_assert (var
->print_value
!= NULL
&& print_value
!= NULL
);
1060 if (strcmp (var
->print_value
, print_value
) != 0)
1066 /* We must always keep the new value, since children depend on it. */
1067 if (var
->value
!= NULL
&& var
->value
!= value
)
1068 value_free (var
->value
);
1070 if (var
->print_value
)
1071 xfree (var
->print_value
);
1072 var
->print_value
= print_value
;
1073 if (value
&& value_lazy (value
) && intentionally_not_fetched
)
1074 var
->not_fetched
= 1;
1076 var
->not_fetched
= 0;
1079 gdb_assert (!var
->value
|| value_type (var
->value
));
1084 /* Update the values for a variable and its children. This is a
1085 two-pronged attack. First, re-parse the value for the root's
1086 expression to see if it's changed. Then go all the way
1087 through its children, reconstructing them and noting if they've
1090 < 0 for error values, see varobj.h.
1091 Otherwise it is the number of children + parent changed.
1093 The EXPLICIT parameter specifies if this call is result
1094 of MI request to update this specific variable, or
1095 result of implicit -var-update *. For implicit request, we don't
1096 update frozen variables.
1098 NOTE: This function may delete the caller's varobj. If it
1099 returns TYPE_CHANGED, then it has done this and VARP will be modified
1100 to point to the new varobj. */
1103 varobj_update (struct varobj
**varp
, struct varobj
***changelist
,
1107 int type_changed
= 0;
1112 struct varobj
**templist
= NULL
;
1114 VEC (varobj_p
) *stack
= NULL
;
1115 VEC (varobj_p
) *result
= NULL
;
1116 struct frame_info
*fi
;
1118 /* sanity check: have we been passed a pointer? */
1119 gdb_assert (changelist
);
1121 /* Frozen means frozen -- we don't check for any change in
1122 this varobj, including its going out of scope, or
1123 changing type. One use case for frozen varobjs is
1124 retaining previously evaluated expressions, and we don't
1125 want them to be reevaluated at all. */
1126 if (!explicit && (*varp
)->frozen
)
1129 if (!(*varp
)->root
->is_valid
)
1132 if ((*varp
)->root
->rootvar
== *varp
)
1134 /* Update the root variable. value_of_root can return NULL
1135 if the variable is no longer around, i.e. we stepped out of
1136 the frame in which a local existed. We are letting the
1137 value_of_root variable dispose of the varobj if the type
1140 new = value_of_root (varp
, &type_changed
);
1142 /* If this is a "use_selected_frame" varobj, and its type has changed,
1143 them note that it's changed. */
1145 VEC_safe_push (varobj_p
, result
, *varp
);
1147 if (install_new_value ((*varp
), new, type_changed
))
1149 /* If type_changed is 1, install_new_value will never return
1150 non-zero, so we'll never report the same variable twice. */
1151 gdb_assert (!type_changed
);
1152 VEC_safe_push (varobj_p
, result
, *varp
);
1157 /* This means the varobj itself is out of scope.
1159 VEC_free (varobj_p
, result
);
1160 return NOT_IN_SCOPE
;
1164 VEC_safe_push (varobj_p
, stack
, *varp
);
1166 /* Walk through the children, reconstructing them all. */
1167 while (!VEC_empty (varobj_p
, stack
))
1169 v
= VEC_pop (varobj_p
, stack
);
1171 /* Push any children. Use reverse order so that the first
1172 child is popped from the work stack first, and so
1173 will be added to result first. This does not
1174 affect correctness, just "nicer". */
1175 for (i
= VEC_length (varobj_p
, v
->children
)-1; i
>= 0; --i
)
1177 varobj_p c
= VEC_index (varobj_p
, v
->children
, i
);
1178 /* Child may be NULL if explicitly deleted by -var-delete. */
1179 if (c
!= NULL
&& !c
->frozen
)
1180 VEC_safe_push (varobj_p
, stack
, c
);
1183 /* Update this variable, unless it's a root, which is already
1185 if (v
->root
->rootvar
!= v
)
1187 new = value_of_child (v
->parent
, v
->index
);
1188 if (install_new_value (v
, new, 0 /* type not changed */))
1190 /* Note that it's changed */
1191 VEC_safe_push (varobj_p
, result
, v
);
1197 /* Alloc (changed + 1) list entries. */
1198 changed
= VEC_length (varobj_p
, result
);
1199 *changelist
= xmalloc ((changed
+ 1) * sizeof (struct varobj
*));
1202 for (i
= 0; i
< changed
; ++i
)
1204 *cv
= VEC_index (varobj_p
, result
, i
);
1205 gdb_assert (*cv
!= NULL
);
1210 VEC_free (varobj_p
, stack
);
1211 VEC_free (varobj_p
, result
);
1214 return TYPE_CHANGED
;
1220 /* Helper functions */
1223 * Variable object construction/destruction
1227 delete_variable (struct cpstack
**resultp
, struct varobj
*var
,
1228 int only_children_p
)
1232 delete_variable_1 (resultp
, &delcount
, var
,
1233 only_children_p
, 1 /* remove_from_parent_p */ );
1238 /* Delete the variable object VAR and its children */
1239 /* IMPORTANT NOTE: If we delete a variable which is a child
1240 and the parent is not removed we dump core. It must be always
1241 initially called with remove_from_parent_p set */
1243 delete_variable_1 (struct cpstack
**resultp
, int *delcountp
,
1244 struct varobj
*var
, int only_children_p
,
1245 int remove_from_parent_p
)
1249 /* Delete any children of this variable, too. */
1250 for (i
= 0; i
< VEC_length (varobj_p
, var
->children
); ++i
)
1252 varobj_p child
= VEC_index (varobj_p
, var
->children
, i
);
1255 if (!remove_from_parent_p
)
1256 child
->parent
= NULL
;
1257 delete_variable_1 (resultp
, delcountp
, child
, 0, only_children_p
);
1259 VEC_free (varobj_p
, var
->children
);
1261 /* if we were called to delete only the children we are done here */
1262 if (only_children_p
)
1265 /* Otherwise, add it to the list of deleted ones and proceed to do so */
1266 /* If the name is null, this is a temporary variable, that has not
1267 yet been installed, don't report it, it belongs to the caller... */
1268 if (var
->obj_name
!= NULL
)
1270 cppush (resultp
, xstrdup (var
->obj_name
));
1271 *delcountp
= *delcountp
+ 1;
1274 /* If this variable has a parent, remove it from its parent's list */
1275 /* OPTIMIZATION: if the parent of this variable is also being deleted,
1276 (as indicated by remove_from_parent_p) we don't bother doing an
1277 expensive list search to find the element to remove when we are
1278 discarding the list afterwards */
1279 if ((remove_from_parent_p
) && (var
->parent
!= NULL
))
1281 VEC_replace (varobj_p
, var
->parent
->children
, var
->index
, NULL
);
1284 if (var
->obj_name
!= NULL
)
1285 uninstall_variable (var
);
1287 /* Free memory associated with this variable */
1288 free_variable (var
);
1291 /* Install the given variable VAR with the object name VAR->OBJ_NAME. */
1293 install_variable (struct varobj
*var
)
1296 struct vlist
*newvl
;
1298 unsigned int index
= 0;
1301 for (chp
= var
->obj_name
; *chp
; chp
++)
1303 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
1306 cv
= *(varobj_table
+ index
);
1307 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, var
->obj_name
) != 0))
1311 error (_("Duplicate variable object name"));
1313 /* Add varobj to hash table */
1314 newvl
= xmalloc (sizeof (struct vlist
));
1315 newvl
->next
= *(varobj_table
+ index
);
1317 *(varobj_table
+ index
) = newvl
;
1319 /* If root, add varobj to root list */
1320 if (is_root_p (var
))
1322 /* Add to list of root variables */
1323 if (rootlist
== NULL
)
1324 var
->root
->next
= NULL
;
1326 var
->root
->next
= rootlist
;
1327 rootlist
= var
->root
;
1334 /* Unistall the object VAR. */
1336 uninstall_variable (struct varobj
*var
)
1340 struct varobj_root
*cr
;
1341 struct varobj_root
*prer
;
1343 unsigned int index
= 0;
1346 /* Remove varobj from hash table */
1347 for (chp
= var
->obj_name
; *chp
; chp
++)
1349 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
1352 cv
= *(varobj_table
+ index
);
1354 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, var
->obj_name
) != 0))
1361 fprintf_unfiltered (gdb_stdlog
, "Deleting %s\n", var
->obj_name
);
1366 ("Assertion failed: Could not find variable object \"%s\" to delete",
1372 *(varobj_table
+ index
) = cv
->next
;
1374 prev
->next
= cv
->next
;
1378 /* If root, remove varobj from root list */
1379 if (is_root_p (var
))
1381 /* Remove from list of root variables */
1382 if (rootlist
== var
->root
)
1383 rootlist
= var
->root
->next
;
1388 while ((cr
!= NULL
) && (cr
->rootvar
!= var
))
1396 ("Assertion failed: Could not find varobj \"%s\" in root list",
1403 prer
->next
= cr
->next
;
1410 /* Create and install a child of the parent of the given name */
1411 static struct varobj
*
1412 create_child (struct varobj
*parent
, int index
, char *name
)
1414 struct varobj
*child
;
1416 struct value
*value
;
1418 child
= new_variable ();
1420 /* name is allocated by name_of_child */
1422 child
->index
= index
;
1423 value
= value_of_child (parent
, index
);
1424 child
->parent
= parent
;
1425 child
->root
= parent
->root
;
1426 childs_name
= xstrprintf ("%s.%s", parent
->obj_name
, name
);
1427 child
->obj_name
= childs_name
;
1428 install_variable (child
);
1430 /* Compute the type of the child. Must do this before
1431 calling install_new_value. */
1433 /* If the child had no evaluation errors, var->value
1434 will be non-NULL and contain a valid type. */
1435 child
->type
= value_type (value
);
1437 /* Otherwise, we must compute the type. */
1438 child
->type
= (*child
->root
->lang
->type_of_child
) (child
->parent
,
1440 install_new_value (child
, value
, 1);
1447 * Miscellaneous utility functions.
1450 /* Allocate memory and initialize a new variable */
1451 static struct varobj
*
1456 var
= (struct varobj
*) xmalloc (sizeof (struct varobj
));
1458 var
->path_expr
= NULL
;
1459 var
->obj_name
= NULL
;
1463 var
->num_children
= -1;
1465 var
->children
= NULL
;
1469 var
->print_value
= NULL
;
1471 var
->not_fetched
= 0;
1476 /* Allocate memory and initialize a new root variable */
1477 static struct varobj
*
1478 new_root_variable (void)
1480 struct varobj
*var
= new_variable ();
1481 var
->root
= (struct varobj_root
*) xmalloc (sizeof (struct varobj_root
));;
1482 var
->root
->lang
= NULL
;
1483 var
->root
->exp
= NULL
;
1484 var
->root
->valid_block
= NULL
;
1485 var
->root
->frame
= null_frame_id
;
1486 var
->root
->use_selected_frame
= 0;
1487 var
->root
->rootvar
= NULL
;
1488 var
->root
->is_valid
= 1;
1493 /* Free any allocated memory associated with VAR. */
1495 free_variable (struct varobj
*var
)
1497 /* Free the expression if this is a root variable. */
1498 if (is_root_p (var
))
1500 free_current_contents (&var
->root
->exp
);
1505 xfree (var
->obj_name
);
1506 xfree (var
->print_value
);
1507 xfree (var
->path_expr
);
1512 do_free_variable_cleanup (void *var
)
1514 free_variable (var
);
1517 static struct cleanup
*
1518 make_cleanup_free_variable (struct varobj
*var
)
1520 return make_cleanup (do_free_variable_cleanup
, var
);
1523 /* This returns the type of the variable. It also skips past typedefs
1524 to return the real type of the variable.
1526 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
1527 except within get_target_type and get_type. */
1528 static struct type
*
1529 get_type (struct varobj
*var
)
1535 type
= check_typedef (type
);
1540 /* Return the type of the value that's stored in VAR,
1541 or that would have being stored there if the
1542 value were accessible.
1544 This differs from VAR->type in that VAR->type is always
1545 the true type of the expession in the source language.
1546 The return value of this function is the type we're
1547 actually storing in varobj, and using for displaying
1548 the values and for comparing previous and new values.
1550 For example, top-level references are always stripped. */
1551 static struct type
*
1552 get_value_type (struct varobj
*var
)
1557 type
= value_type (var
->value
);
1561 type
= check_typedef (type
);
1563 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
1564 type
= get_target_type (type
);
1566 type
= check_typedef (type
);
1571 /* This returns the target type (or NULL) of TYPE, also skipping
1572 past typedefs, just like get_type ().
1574 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
1575 except within get_target_type and get_type. */
1576 static struct type
*
1577 get_target_type (struct type
*type
)
1581 type
= TYPE_TARGET_TYPE (type
);
1583 type
= check_typedef (type
);
1589 /* What is the default display for this variable? We assume that
1590 everything is "natural". Any exceptions? */
1591 static enum varobj_display_formats
1592 variable_default_display (struct varobj
*var
)
1594 return FORMAT_NATURAL
;
1597 /* FIXME: The following should be generic for any pointer */
1599 cppush (struct cpstack
**pstack
, char *name
)
1603 s
= (struct cpstack
*) xmalloc (sizeof (struct cpstack
));
1609 /* FIXME: The following should be generic for any pointer */
1611 cppop (struct cpstack
**pstack
)
1616 if ((*pstack
)->name
== NULL
&& (*pstack
)->next
== NULL
)
1621 *pstack
= (*pstack
)->next
;
1628 * Language-dependencies
1631 /* Common entry points */
1633 /* Get the language of variable VAR. */
1634 static enum varobj_languages
1635 variable_language (struct varobj
*var
)
1637 enum varobj_languages lang
;
1639 switch (var
->root
->exp
->language_defn
->la_language
)
1645 case language_cplus
:
1656 /* Return the number of children for a given variable.
1657 The result of this function is defined by the language
1658 implementation. The number of children returned by this function
1659 is the number of children that the user will see in the variable
1662 number_of_children (struct varobj
*var
)
1664 return (*var
->root
->lang
->number_of_children
) (var
);;
1667 /* What is the expression for the root varobj VAR? Returns a malloc'd string. */
1669 name_of_variable (struct varobj
*var
)
1671 return (*var
->root
->lang
->name_of_variable
) (var
);
1674 /* What is the name of the INDEX'th child of VAR? Returns a malloc'd string. */
1676 name_of_child (struct varobj
*var
, int index
)
1678 return (*var
->root
->lang
->name_of_child
) (var
, index
);
1681 /* What is the ``struct value *'' of the root variable VAR?
1682 TYPE_CHANGED controls what to do if the type of a
1683 use_selected_frame = 1 variable changes. On input,
1684 TYPE_CHANGED = 1 means discard the old varobj, and replace
1685 it with this one. TYPE_CHANGED = 0 means leave it around.
1686 NB: In both cases, var_handle will point to the new varobj,
1687 so if you use TYPE_CHANGED = 0, you will have to stash the
1688 old varobj pointer away somewhere before calling this.
1689 On return, TYPE_CHANGED will be 1 if the type has changed, and
1691 static struct value
*
1692 value_of_root (struct varobj
**var_handle
, int *type_changed
)
1696 if (var_handle
== NULL
)
1701 /* This should really be an exception, since this should
1702 only get called with a root variable. */
1704 if (!is_root_p (var
))
1707 if (var
->root
->use_selected_frame
)
1709 struct varobj
*tmp_var
;
1710 char *old_type
, *new_type
;
1712 tmp_var
= varobj_create (NULL
, var
->name
, (CORE_ADDR
) 0,
1713 USE_SELECTED_FRAME
);
1714 if (tmp_var
== NULL
)
1718 old_type
= varobj_get_type (var
);
1719 new_type
= varobj_get_type (tmp_var
);
1720 if (strcmp (old_type
, new_type
) == 0)
1722 varobj_delete (tmp_var
, NULL
, 0);
1730 savestring (var
->obj_name
, strlen (var
->obj_name
));
1731 varobj_delete (var
, NULL
, 0);
1735 tmp_var
->obj_name
= varobj_gen_name ();
1737 install_variable (tmp_var
);
1738 *var_handle
= tmp_var
;
1750 return (*var
->root
->lang
->value_of_root
) (var_handle
);
1753 /* What is the ``struct value *'' for the INDEX'th child of PARENT? */
1754 static struct value
*
1755 value_of_child (struct varobj
*parent
, int index
)
1757 struct value
*value
;
1759 value
= (*parent
->root
->lang
->value_of_child
) (parent
, index
);
1764 /* GDB already has a command called "value_of_variable". Sigh. */
1766 my_value_of_variable (struct varobj
*var
)
1768 if (var
->root
->is_valid
)
1769 return (*var
->root
->lang
->value_of_variable
) (var
);
1775 value_get_print_value (struct value
*value
, enum varobj_display_formats format
)
1778 struct ui_file
*stb
;
1779 struct cleanup
*old_chain
;
1785 stb
= mem_fileopen ();
1786 old_chain
= make_cleanup_ui_file_delete (stb
);
1788 common_val_print (value
, stb
, format_code
[(int) format
], 1, 0, 0);
1789 thevalue
= ui_file_xstrdup (stb
, &dummy
);
1791 do_cleanups (old_chain
);
1796 varobj_editable_p (struct varobj
*var
)
1799 struct value
*value
;
1801 if (!(var
->root
->is_valid
&& var
->value
&& VALUE_LVAL (var
->value
)))
1804 type
= get_value_type (var
);
1806 switch (TYPE_CODE (type
))
1808 case TYPE_CODE_STRUCT
:
1809 case TYPE_CODE_UNION
:
1810 case TYPE_CODE_ARRAY
:
1811 case TYPE_CODE_FUNC
:
1812 case TYPE_CODE_METHOD
:
1822 /* Return non-zero if changes in value of VAR
1823 must be detected and reported by -var-update.
1824 Return zero is -var-update should never report
1825 changes of such values. This makes sense for structures
1826 (since the changes in children values will be reported separately),
1827 or for artifical objects (like 'public' pseudo-field in C++).
1829 Return value of 0 means that gdb need not call value_fetch_lazy
1830 for the value of this variable object. */
1832 varobj_value_is_changeable_p (struct varobj
*var
)
1837 if (CPLUS_FAKE_CHILD (var
))
1840 type
= get_value_type (var
);
1842 switch (TYPE_CODE (type
))
1844 case TYPE_CODE_STRUCT
:
1845 case TYPE_CODE_UNION
:
1846 case TYPE_CODE_ARRAY
:
1857 /* Given the value and the type of a variable object,
1858 adjust the value and type to those necessary
1859 for getting children of the variable object.
1860 This includes dereferencing top-level references
1861 to all types and dereferencing pointers to
1864 Both TYPE and *TYPE should be non-null. VALUE
1865 can be null if we want to only translate type.
1866 *VALUE can be null as well -- if the parent
1869 If WAS_PTR is not NULL, set *WAS_PTR to 0 or 1
1870 depending on whether pointer was deferenced
1871 in this function. */
1873 adjust_value_for_child_access (struct value
**value
,
1877 gdb_assert (type
&& *type
);
1882 *type
= check_typedef (*type
);
1884 /* The type of value stored in varobj, that is passed
1885 to us, is already supposed to be
1886 reference-stripped. */
1888 gdb_assert (TYPE_CODE (*type
) != TYPE_CODE_REF
);
1890 /* Pointers to structures are treated just like
1891 structures when accessing children. Don't
1892 dererences pointers to other types. */
1893 if (TYPE_CODE (*type
) == TYPE_CODE_PTR
)
1895 struct type
*target_type
= get_target_type (*type
);
1896 if (TYPE_CODE (target_type
) == TYPE_CODE_STRUCT
1897 || TYPE_CODE (target_type
) == TYPE_CODE_UNION
)
1899 if (value
&& *value
)
1901 int success
= gdb_value_ind (*value
, value
);
1905 *type
= target_type
;
1911 /* The 'get_target_type' function calls check_typedef on
1912 result, so we can immediately check type code. No
1913 need to call check_typedef here. */
1918 c_number_of_children (struct varobj
*var
)
1920 struct type
*type
= get_value_type (var
);
1922 struct type
*target
;
1924 adjust_value_for_child_access (NULL
, &type
, NULL
);
1925 target
= get_target_type (type
);
1927 switch (TYPE_CODE (type
))
1929 case TYPE_CODE_ARRAY
:
1930 if (TYPE_LENGTH (type
) > 0 && TYPE_LENGTH (target
) > 0
1931 && TYPE_ARRAY_UPPER_BOUND_TYPE (type
) != BOUND_CANNOT_BE_DETERMINED
)
1932 children
= TYPE_LENGTH (type
) / TYPE_LENGTH (target
);
1934 /* If we don't know how many elements there are, don't display
1939 case TYPE_CODE_STRUCT
:
1940 case TYPE_CODE_UNION
:
1941 children
= TYPE_NFIELDS (type
);
1945 /* The type here is a pointer to non-struct. Typically, pointers
1946 have one child, except for function ptrs, which have no children,
1947 and except for void*, as we don't know what to show.
1949 We can show char* so we allow it to be dereferenced. If you decide
1950 to test for it, please mind that a little magic is necessary to
1951 properly identify it: char* has TYPE_CODE == TYPE_CODE_INT and
1952 TYPE_NAME == "char" */
1953 if (TYPE_CODE (target
) == TYPE_CODE_FUNC
1954 || TYPE_CODE (target
) == TYPE_CODE_VOID
)
1961 /* Other types have no children */
1969 c_name_of_variable (struct varobj
*parent
)
1971 return savestring (parent
->name
, strlen (parent
->name
));
1974 /* Return the value of element TYPE_INDEX of a structure
1975 value VALUE. VALUE's type should be a structure,
1976 or union, or a typedef to struct/union.
1978 Returns NULL if getting the value fails. Never throws. */
1979 static struct value
*
1980 value_struct_element_index (struct value
*value
, int type_index
)
1982 struct value
*result
= NULL
;
1983 volatile struct gdb_exception e
;
1985 struct type
*type
= value_type (value
);
1986 type
= check_typedef (type
);
1988 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
1989 || TYPE_CODE (type
) == TYPE_CODE_UNION
);
1991 TRY_CATCH (e
, RETURN_MASK_ERROR
)
1993 if (TYPE_FIELD_STATIC (type
, type_index
))
1994 result
= value_static_field (type
, type_index
);
1996 result
= value_primitive_field (value
, 0, type_index
, type
);
2008 /* Obtain the information about child INDEX of the variable
2010 If CNAME is not null, sets *CNAME to the name of the child relative
2012 If CVALUE is not null, sets *CVALUE to the value of the child.
2013 If CTYPE is not null, sets *CTYPE to the type of the child.
2015 If any of CNAME, CVALUE, or CTYPE is not null, but the corresponding
2016 information cannot be determined, set *CNAME, *CVALUE, or *CTYPE
2019 c_describe_child (struct varobj
*parent
, int index
,
2020 char **cname
, struct value
**cvalue
, struct type
**ctype
,
2021 char **cfull_expression
)
2023 struct value
*value
= parent
->value
;
2024 struct type
*type
= get_value_type (parent
);
2025 char *parent_expression
= NULL
;
2034 if (cfull_expression
)
2036 *cfull_expression
= NULL
;
2037 parent_expression
= varobj_get_path_expr (parent
);
2039 adjust_value_for_child_access (&value
, &type
, &was_ptr
);
2041 switch (TYPE_CODE (type
))
2043 case TYPE_CODE_ARRAY
:
2045 *cname
= xstrprintf ("%d", index
2046 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
)));
2048 if (cvalue
&& value
)
2050 int real_index
= index
+ TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
));
2051 struct value
*indval
=
2052 value_from_longest (builtin_type_int
, (LONGEST
) real_index
);
2053 gdb_value_subscript (value
, indval
, cvalue
);
2057 *ctype
= get_target_type (type
);
2059 if (cfull_expression
)
2060 *cfull_expression
= xstrprintf ("(%s)[%d]", parent_expression
,
2062 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
)));
2067 case TYPE_CODE_STRUCT
:
2068 case TYPE_CODE_UNION
:
2071 char *string
= TYPE_FIELD_NAME (type
, index
);
2072 *cname
= savestring (string
, strlen (string
));
2075 if (cvalue
&& value
)
2077 /* For C, varobj index is the same as type index. */
2078 *cvalue
= value_struct_element_index (value
, index
);
2082 *ctype
= TYPE_FIELD_TYPE (type
, index
);
2084 if (cfull_expression
)
2086 char *join
= was_ptr
? "->" : ".";
2087 *cfull_expression
= xstrprintf ("(%s)%s%s", parent_expression
, join
,
2088 TYPE_FIELD_NAME (type
, index
));
2095 *cname
= xstrprintf ("*%s", parent
->name
);
2097 if (cvalue
&& value
)
2099 int success
= gdb_value_ind (value
, cvalue
);
2104 /* Don't use get_target_type because it calls
2105 check_typedef and here, we want to show the true
2106 declared type of the variable. */
2108 *ctype
= TYPE_TARGET_TYPE (type
);
2110 if (cfull_expression
)
2111 *cfull_expression
= xstrprintf ("*(%s)", parent_expression
);
2116 /* This should not happen */
2118 *cname
= xstrdup ("???");
2119 if (cfull_expression
)
2120 *cfull_expression
= xstrdup ("???");
2121 /* Don't set value and type, we don't know then. */
2126 c_name_of_child (struct varobj
*parent
, int index
)
2129 c_describe_child (parent
, index
, &name
, NULL
, NULL
, NULL
);
2134 c_path_expr_of_child (struct varobj
*child
)
2136 c_describe_child (child
->parent
, child
->index
, NULL
, NULL
, NULL
,
2138 return child
->path_expr
;
2141 static struct value
*
2142 c_value_of_root (struct varobj
**var_handle
)
2144 struct value
*new_val
= NULL
;
2145 struct varobj
*var
= *var_handle
;
2146 struct frame_info
*fi
;
2148 struct cleanup
*back_to
;
2150 /* Only root variables can be updated... */
2151 if (!is_root_p (var
))
2152 /* Not a root var */
2155 back_to
= make_cleanup_restore_current_thread (
2156 inferior_ptid
, get_frame_id (deprecated_safe_get_selected_frame ()));
2158 /* Determine whether the variable is still around. */
2159 if (var
->root
->valid_block
== NULL
|| var
->root
->use_selected_frame
)
2163 fi
= frame_find_by_id (var
->root
->frame
);
2164 within_scope
= fi
!= NULL
;
2165 /* FIXME: select_frame could fail */
2168 CORE_ADDR pc
= get_frame_pc (fi
);
2169 if (pc
< BLOCK_START (var
->root
->valid_block
) ||
2170 pc
>= BLOCK_END (var
->root
->valid_block
))
2179 /* We need to catch errors here, because if evaluate
2180 expression fails we want to just return NULL. */
2181 gdb_evaluate_expression (var
->root
->exp
, &new_val
);
2185 do_cleanups (back_to
);
2190 static struct value
*
2191 c_value_of_child (struct varobj
*parent
, int index
)
2193 struct value
*value
= NULL
;
2194 c_describe_child (parent
, index
, NULL
, &value
, NULL
, NULL
);
2199 static struct type
*
2200 c_type_of_child (struct varobj
*parent
, int index
)
2202 struct type
*type
= NULL
;
2203 c_describe_child (parent
, index
, NULL
, NULL
, &type
, NULL
);
2208 c_value_of_variable (struct varobj
*var
)
2210 /* BOGUS: if val_print sees a struct/class, or a reference to one,
2211 it will print out its children instead of "{...}". So we need to
2212 catch that case explicitly. */
2213 struct type
*type
= get_type (var
);
2215 /* Strip top-level references. */
2216 while (TYPE_CODE (type
) == TYPE_CODE_REF
)
2217 type
= check_typedef (TYPE_TARGET_TYPE (type
));
2219 switch (TYPE_CODE (type
))
2221 case TYPE_CODE_STRUCT
:
2222 case TYPE_CODE_UNION
:
2223 return xstrdup ("{...}");
2226 case TYPE_CODE_ARRAY
:
2229 number
= xstrprintf ("[%d]", var
->num_children
);
2236 if (var
->value
== NULL
)
2238 /* This can happen if we attempt to get the value of a struct
2239 member when the parent is an invalid pointer. This is an
2240 error condition, so we should tell the caller. */
2245 if (var
->not_fetched
&& value_lazy (var
->value
))
2246 /* Frozen variable and no value yet. We don't
2247 implicitly fetch the value. MI response will
2248 use empty string for the value, which is OK. */
2251 gdb_assert (varobj_value_is_changeable_p (var
));
2252 gdb_assert (!value_lazy (var
->value
));
2253 return xstrdup (var
->print_value
);
2263 cplus_number_of_children (struct varobj
*var
)
2266 int children
, dont_know
;
2271 if (!CPLUS_FAKE_CHILD (var
))
2273 type
= get_value_type (var
);
2274 adjust_value_for_child_access (NULL
, &type
, NULL
);
2276 if (((TYPE_CODE (type
)) == TYPE_CODE_STRUCT
) ||
2277 ((TYPE_CODE (type
)) == TYPE_CODE_UNION
))
2281 cplus_class_num_children (type
, kids
);
2282 if (kids
[v_public
] != 0)
2284 if (kids
[v_private
] != 0)
2286 if (kids
[v_protected
] != 0)
2289 /* Add any baseclasses */
2290 children
+= TYPE_N_BASECLASSES (type
);
2293 /* FIXME: save children in var */
2300 type
= get_value_type (var
->parent
);
2301 adjust_value_for_child_access (NULL
, &type
, NULL
);
2303 cplus_class_num_children (type
, kids
);
2304 if (strcmp (var
->name
, "public") == 0)
2305 children
= kids
[v_public
];
2306 else if (strcmp (var
->name
, "private") == 0)
2307 children
= kids
[v_private
];
2309 children
= kids
[v_protected
];
2314 children
= c_number_of_children (var
);
2319 /* Compute # of public, private, and protected variables in this class.
2320 That means we need to descend into all baseclasses and find out
2321 how many are there, too. */
2323 cplus_class_num_children (struct type
*type
, int children
[3])
2327 children
[v_public
] = 0;
2328 children
[v_private
] = 0;
2329 children
[v_protected
] = 0;
2331 for (i
= TYPE_N_BASECLASSES (type
); i
< TYPE_NFIELDS (type
); i
++)
2333 /* If we have a virtual table pointer, omit it. */
2334 if (TYPE_VPTR_BASETYPE (type
) == type
&& TYPE_VPTR_FIELDNO (type
) == i
)
2337 if (TYPE_FIELD_PROTECTED (type
, i
))
2338 children
[v_protected
]++;
2339 else if (TYPE_FIELD_PRIVATE (type
, i
))
2340 children
[v_private
]++;
2342 children
[v_public
]++;
2347 cplus_name_of_variable (struct varobj
*parent
)
2349 return c_name_of_variable (parent
);
2352 enum accessibility
{ private_field
, protected_field
, public_field
};
2354 /* Check if field INDEX of TYPE has the specified accessibility.
2355 Return 0 if so and 1 otherwise. */
2357 match_accessibility (struct type
*type
, int index
, enum accessibility acc
)
2359 if (acc
== private_field
&& TYPE_FIELD_PRIVATE (type
, index
))
2361 else if (acc
== protected_field
&& TYPE_FIELD_PROTECTED (type
, index
))
2363 else if (acc
== public_field
&& !TYPE_FIELD_PRIVATE (type
, index
)
2364 && !TYPE_FIELD_PROTECTED (type
, index
))
2371 cplus_describe_child (struct varobj
*parent
, int index
,
2372 char **cname
, struct value
**cvalue
, struct type
**ctype
,
2373 char **cfull_expression
)
2376 struct value
*value
;
2379 char *parent_expression
= NULL
;
2387 if (cfull_expression
)
2388 *cfull_expression
= NULL
;
2390 if (CPLUS_FAKE_CHILD (parent
))
2392 value
= parent
->parent
->value
;
2393 type
= get_value_type (parent
->parent
);
2394 if (cfull_expression
)
2395 parent_expression
= varobj_get_path_expr (parent
->parent
);
2399 value
= parent
->value
;
2400 type
= get_value_type (parent
);
2401 if (cfull_expression
)
2402 parent_expression
= varobj_get_path_expr (parent
);
2405 adjust_value_for_child_access (&value
, &type
, &was_ptr
);
2407 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
2408 || TYPE_CODE (type
) == TYPE_CODE_UNION
)
2410 char *join
= was_ptr
? "->" : ".";
2411 if (CPLUS_FAKE_CHILD (parent
))
2413 /* The fields of the class type are ordered as they
2414 appear in the class. We are given an index for a
2415 particular access control type ("public","protected",
2416 or "private"). We must skip over fields that don't
2417 have the access control we are looking for to properly
2418 find the indexed field. */
2419 int type_index
= TYPE_N_BASECLASSES (type
);
2420 enum accessibility acc
= public_field
;
2421 if (strcmp (parent
->name
, "private") == 0)
2422 acc
= private_field
;
2423 else if (strcmp (parent
->name
, "protected") == 0)
2424 acc
= protected_field
;
2428 if (TYPE_VPTR_BASETYPE (type
) == type
2429 && type_index
== TYPE_VPTR_FIELDNO (type
))
2431 else if (match_accessibility (type
, type_index
, acc
))
2438 *cname
= xstrdup (TYPE_FIELD_NAME (type
, type_index
));
2440 if (cvalue
&& value
)
2441 *cvalue
= value_struct_element_index (value
, type_index
);
2444 *ctype
= TYPE_FIELD_TYPE (type
, type_index
);
2446 if (cfull_expression
)
2447 *cfull_expression
= xstrprintf ("((%s)%s%s)", parent_expression
,
2449 TYPE_FIELD_NAME (type
, type_index
));
2451 else if (index
< TYPE_N_BASECLASSES (type
))
2453 /* This is a baseclass. */
2455 *cname
= xstrdup (TYPE_FIELD_NAME (type
, index
));
2457 if (cvalue
&& value
)
2459 *cvalue
= value_cast (TYPE_FIELD_TYPE (type
, index
), value
);
2460 release_value (*cvalue
);
2465 *ctype
= TYPE_FIELD_TYPE (type
, index
);
2468 if (cfull_expression
)
2470 char *ptr
= was_ptr
? "*" : "";
2471 /* Cast the parent to the base' type. Note that in gdb,
2474 will create an lvalue, for all appearences, so we don't
2475 need to use more fancy:
2478 *cfull_expression
= xstrprintf ("(%s(%s%s) %s)",
2480 TYPE_FIELD_NAME (type
, index
),
2487 char *access
= NULL
;
2489 cplus_class_num_children (type
, children
);
2491 /* Everything beyond the baseclasses can
2492 only be "public", "private", or "protected"
2494 The special "fake" children are always output by varobj in
2495 this order. So if INDEX == 2, it MUST be "protected". */
2496 index
-= TYPE_N_BASECLASSES (type
);
2500 if (children
[v_public
] > 0)
2502 else if (children
[v_private
] > 0)
2505 access
= "protected";
2508 if (children
[v_public
] > 0)
2510 if (children
[v_private
] > 0)
2513 access
= "protected";
2515 else if (children
[v_private
] > 0)
2516 access
= "protected";
2519 /* Must be protected */
2520 access
= "protected";
2527 gdb_assert (access
);
2529 *cname
= xstrdup (access
);
2531 /* Value and type and full expression are null here. */
2536 c_describe_child (parent
, index
, cname
, cvalue
, ctype
, cfull_expression
);
2541 cplus_name_of_child (struct varobj
*parent
, int index
)
2544 cplus_describe_child (parent
, index
, &name
, NULL
, NULL
, NULL
);
2549 cplus_path_expr_of_child (struct varobj
*child
)
2551 cplus_describe_child (child
->parent
, child
->index
, NULL
, NULL
, NULL
,
2553 return child
->path_expr
;
2556 static struct value
*
2557 cplus_value_of_root (struct varobj
**var_handle
)
2559 return c_value_of_root (var_handle
);
2562 static struct value
*
2563 cplus_value_of_child (struct varobj
*parent
, int index
)
2565 struct value
*value
= NULL
;
2566 cplus_describe_child (parent
, index
, NULL
, &value
, NULL
, NULL
);
2570 static struct type
*
2571 cplus_type_of_child (struct varobj
*parent
, int index
)
2573 struct type
*type
= NULL
;
2574 cplus_describe_child (parent
, index
, NULL
, NULL
, &type
, NULL
);
2579 cplus_value_of_variable (struct varobj
*var
)
2582 /* If we have one of our special types, don't print out
2584 if (CPLUS_FAKE_CHILD (var
))
2585 return xstrdup ("");
2587 return c_value_of_variable (var
);
2593 java_number_of_children (struct varobj
*var
)
2595 return cplus_number_of_children (var
);
2599 java_name_of_variable (struct varobj
*parent
)
2603 name
= cplus_name_of_variable (parent
);
2604 /* If the name has "-" in it, it is because we
2605 needed to escape periods in the name... */
2608 while (*p
!= '\000')
2619 java_name_of_child (struct varobj
*parent
, int index
)
2623 name
= cplus_name_of_child (parent
, index
);
2624 /* Escape any periods in the name... */
2627 while (*p
!= '\000')
2638 java_path_expr_of_child (struct varobj
*child
)
2643 static struct value
*
2644 java_value_of_root (struct varobj
**var_handle
)
2646 return cplus_value_of_root (var_handle
);
2649 static struct value
*
2650 java_value_of_child (struct varobj
*parent
, int index
)
2652 return cplus_value_of_child (parent
, index
);
2655 static struct type
*
2656 java_type_of_child (struct varobj
*parent
, int index
)
2658 return cplus_type_of_child (parent
, index
);
2662 java_value_of_variable (struct varobj
*var
)
2664 return cplus_value_of_variable (var
);
2667 extern void _initialize_varobj (void);
2669 _initialize_varobj (void)
2671 int sizeof_table
= sizeof (struct vlist
*) * VAROBJ_TABLE_SIZE
;
2673 varobj_table
= xmalloc (sizeof_table
);
2674 memset (varobj_table
, 0, sizeof_table
);
2676 add_setshow_zinteger_cmd ("debugvarobj", class_maintenance
,
2678 Set varobj debugging."), _("\
2679 Show varobj debugging."), _("\
2680 When non-zero, varobj debugging is enabled."),
2683 &setlist
, &showlist
);
2686 /* Invalidate the varobjs that are tied to locals and re-create the ones that
2687 are defined on globals.
2688 Invalidated varobjs will be always printed in_scope="invalid". */
2690 varobj_invalidate (void)
2692 struct varobj
**all_rootvarobj
;
2693 struct varobj
**varp
;
2695 if (varobj_list (&all_rootvarobj
) > 0)
2697 varp
= all_rootvarobj
;
2698 while (*varp
!= NULL
)
2700 /* global var must be re-evaluated. */
2701 if ((*varp
)->root
->valid_block
== NULL
)
2703 struct varobj
*tmp_var
;
2705 /* Try to create a varobj with same expression. If we succeed replace
2706 the old varobj, otherwise invalidate it. */
2707 tmp_var
= varobj_create (NULL
, (*varp
)->name
, (CORE_ADDR
) 0, USE_CURRENT_FRAME
);
2708 if (tmp_var
!= NULL
)
2710 tmp_var
->obj_name
= xstrdup ((*varp
)->obj_name
);
2711 varobj_delete (*varp
, NULL
, 0);
2712 install_variable (tmp_var
);
2715 (*varp
)->root
->is_valid
= 0;
2717 else /* locals must be invalidated. */
2718 (*varp
)->root
->is_valid
= 0;
2722 xfree (all_rootvarobj
);