1 /* Implementation of the GDB variable objects API.
3 Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
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"
35 /* Non-zero if we want to see trace of varobj level stuff. */
39 show_varobjdebug (struct ui_file
*file
, int from_tty
,
40 struct cmd_list_element
*c
, const char *value
)
42 fprintf_filtered (file
, _("Varobj debugging is %s.\n"), value
);
45 /* String representations of gdb's format codes */
46 char *varobj_format_string
[] =
47 { "natural", "binary", "decimal", "hexadecimal", "octal" };
49 /* String representations of gdb's known languages */
50 char *varobj_language_string
[] = { "unknown", "C", "C++", "Java" };
54 /* Every root variable has one of these structures saved in its
55 varobj. Members which must be free'd are noted. */
59 /* Alloc'd expression for this parent. */
60 struct expression
*exp
;
62 /* Block for which this expression is valid */
63 struct block
*valid_block
;
65 /* The frame for this expression */
66 struct frame_id frame
;
68 /* If 1, "update" always recomputes the frame & valid block
69 using the currently selected frame. */
70 int use_selected_frame
;
72 /* Flag that indicates validity: set to 0 when this varobj_root refers
73 to symbols that do not exist anymore. */
76 /* Language info for this variable and its children */
77 struct language_specific
*lang
;
79 /* The varobj for this root node. */
80 struct varobj
*rootvar
;
82 /* Next root variable */
83 struct varobj_root
*next
;
86 typedef struct varobj
*varobj_p
;
90 /* Every variable in the system has a structure of this type defined
91 for it. This structure holds all information necessary to manipulate
92 a particular object variable. Members which must be freed are noted. */
96 /* Alloc'd name of the variable for this object.. If this variable is a
97 child, then this name will be the child's source name.
99 /* NOTE: This is the "expression" */
102 /* Alloc'd expression for this child. Can be used to create a
103 root variable corresponding to this child. */
106 /* The alloc'd name for this variable's object. This is here for
107 convenience when constructing this object's children. */
110 /* Index of this variable in its parent or -1 */
113 /* The type of this variable. This may NEVER be NULL. */
116 /* The value of this expression or subexpression. A NULL value
117 indicates there was an error getting this value.
118 Invariant: if varobj_value_is_changeable_p (this) is non-zero,
119 the value is either NULL, or not lazy. */
122 /* The number of (immediate) children this variable has */
125 /* If this object is a child, this points to its immediate parent. */
126 struct varobj
*parent
;
128 /* Children of this object. */
129 VEC (varobj_p
) *children
;
131 /* Description of the root variable. Points to root variable for children. */
132 struct varobj_root
*root
;
134 /* The format of the output for this object */
135 enum varobj_display_formats format
;
137 /* Was this variable updated via a varobj_set_value operation */
140 /* Last print value. */
143 /* Is this variable frozen. Frozen variables are never implicitly
144 updated by -var-update *
145 or -var-update <direct-or-indirect-parent>. */
148 /* Is the value of this variable intentionally not fetched? It is
149 not fetched if either the variable is frozen, or any parents is
157 struct cpstack
*next
;
160 /* A list of varobjs */
168 /* Private function prototypes */
170 /* Helper functions for the above subcommands. */
172 static int delete_variable (struct cpstack
**, struct varobj
*, int);
174 static void delete_variable_1 (struct cpstack
**, int *,
175 struct varobj
*, int, int);
177 static int install_variable (struct varobj
*);
179 static void uninstall_variable (struct varobj
*);
181 static struct varobj
*create_child (struct varobj
*, int, char *);
183 /* Utility routines */
185 static struct varobj
*new_variable (void);
187 static struct varobj
*new_root_variable (void);
189 static void free_variable (struct varobj
*var
);
191 static struct cleanup
*make_cleanup_free_variable (struct varobj
*var
);
193 static struct type
*get_type (struct varobj
*var
);
195 static struct type
*get_value_type (struct varobj
*var
);
197 static struct type
*get_target_type (struct type
*);
199 static enum varobj_display_formats
variable_default_display (struct varobj
*);
201 static void cppush (struct cpstack
**pstack
, char *name
);
203 static char *cppop (struct cpstack
**pstack
);
205 static int install_new_value (struct varobj
*var
, struct value
*value
,
208 /* Language-specific routines. */
210 static enum varobj_languages
variable_language (struct varobj
*var
);
212 static int number_of_children (struct varobj
*);
214 static char *name_of_variable (struct varobj
*);
216 static char *name_of_child (struct varobj
*, int);
218 static struct value
*value_of_root (struct varobj
**var_handle
, int *);
220 static struct value
*value_of_child (struct varobj
*parent
, int index
);
222 static int variable_editable (struct varobj
*var
);
224 static char *my_value_of_variable (struct varobj
*var
);
226 static char *value_get_print_value (struct value
*value
,
227 enum varobj_display_formats format
);
229 static int varobj_value_is_changeable_p (struct varobj
*var
);
231 static int is_root_p (struct varobj
*var
);
233 /* C implementation */
235 static int c_number_of_children (struct varobj
*var
);
237 static char *c_name_of_variable (struct varobj
*parent
);
239 static char *c_name_of_child (struct varobj
*parent
, int index
);
241 static char *c_path_expr_of_child (struct varobj
*child
);
243 static struct value
*c_value_of_root (struct varobj
**var_handle
);
245 static struct value
*c_value_of_child (struct varobj
*parent
, int index
);
247 static struct type
*c_type_of_child (struct varobj
*parent
, int index
);
249 static int c_variable_editable (struct varobj
*var
);
251 static char *c_value_of_variable (struct varobj
*var
);
253 /* C++ implementation */
255 static int cplus_number_of_children (struct varobj
*var
);
257 static void cplus_class_num_children (struct type
*type
, int children
[3]);
259 static char *cplus_name_of_variable (struct varobj
*parent
);
261 static char *cplus_name_of_child (struct varobj
*parent
, int index
);
263 static char *cplus_path_expr_of_child (struct varobj
*child
);
265 static struct value
*cplus_value_of_root (struct varobj
**var_handle
);
267 static struct value
*cplus_value_of_child (struct varobj
*parent
, int index
);
269 static struct type
*cplus_type_of_child (struct varobj
*parent
, int index
);
271 static int cplus_variable_editable (struct varobj
*var
);
273 static char *cplus_value_of_variable (struct varobj
*var
);
275 /* Java implementation */
277 static int java_number_of_children (struct varobj
*var
);
279 static char *java_name_of_variable (struct varobj
*parent
);
281 static char *java_name_of_child (struct varobj
*parent
, int index
);
283 static char *java_path_expr_of_child (struct varobj
*child
);
285 static struct value
*java_value_of_root (struct varobj
**var_handle
);
287 static struct value
*java_value_of_child (struct varobj
*parent
, int index
);
289 static struct type
*java_type_of_child (struct varobj
*parent
, int index
);
291 static int java_variable_editable (struct varobj
*var
);
293 static char *java_value_of_variable (struct varobj
*var
);
295 /* The language specific vector */
297 struct language_specific
300 /* The language of this variable */
301 enum varobj_languages language
;
303 /* The number of children of PARENT. */
304 int (*number_of_children
) (struct varobj
* parent
);
306 /* The name (expression) of a root varobj. */
307 char *(*name_of_variable
) (struct varobj
* parent
);
309 /* The name of the INDEX'th child of PARENT. */
310 char *(*name_of_child
) (struct varobj
* parent
, int index
);
312 /* Returns the rooted expression of CHILD, which is a variable
313 obtain that has some parent. */
314 char *(*path_expr_of_child
) (struct varobj
* child
);
316 /* The ``struct value *'' of the root variable ROOT. */
317 struct value
*(*value_of_root
) (struct varobj
** root_handle
);
319 /* The ``struct value *'' of the INDEX'th child of PARENT. */
320 struct value
*(*value_of_child
) (struct varobj
* parent
, int index
);
322 /* The type of the INDEX'th child of PARENT. */
323 struct type
*(*type_of_child
) (struct varobj
* parent
, int index
);
325 /* Is VAR editable? */
326 int (*variable_editable
) (struct varobj
* var
);
328 /* The current value of VAR. */
329 char *(*value_of_variable
) (struct varobj
* var
);
332 /* Array of known source language routines. */
333 static struct language_specific languages
[vlang_end
] = {
334 /* Unknown (try treating as C */
337 c_number_of_children
,
340 c_path_expr_of_child
,
350 c_number_of_children
,
353 c_path_expr_of_child
,
363 cplus_number_of_children
,
364 cplus_name_of_variable
,
366 cplus_path_expr_of_child
,
368 cplus_value_of_child
,
370 cplus_variable_editable
,
371 cplus_value_of_variable
}
376 java_number_of_children
,
377 java_name_of_variable
,
379 java_path_expr_of_child
,
383 java_variable_editable
,
384 java_value_of_variable
}
387 /* A little convenience enum for dealing with C++/Java */
390 v_public
= 0, v_private
, v_protected
395 /* Mappings of varobj_display_formats enums to gdb's format codes */
396 static int format_code
[] = { 0, 't', 'd', 'x', 'o' };
398 /* Header of the list of root variable objects */
399 static struct varobj_root
*rootlist
;
400 static int rootcount
= 0; /* number of root varobjs in the list */
402 /* Prime number indicating the number of buckets in the hash table */
403 /* A prime large enough to avoid too many colisions */
404 #define VAROBJ_TABLE_SIZE 227
406 /* Pointer to the varobj hash table (built at run time) */
407 static struct vlist
**varobj_table
;
409 /* Is the variable X one of our "fake" children? */
410 #define CPLUS_FAKE_CHILD(x) \
411 ((x) != NULL && (x)->type == NULL && (x)->value == NULL)
414 /* API Implementation */
416 is_root_p (struct varobj
*var
)
418 return (var
->root
->rootvar
== var
);
421 /* Creates a varobj (not its children) */
423 /* Return the full FRAME which corresponds to the given CORE_ADDR
424 or NULL if no FRAME on the chain corresponds to CORE_ADDR. */
426 static struct frame_info
*
427 find_frame_addr_in_frame_chain (CORE_ADDR frame_addr
)
429 struct frame_info
*frame
= NULL
;
431 if (frame_addr
== (CORE_ADDR
) 0)
436 frame
= get_prev_frame (frame
);
439 if (get_frame_base_address (frame
) == frame_addr
)
445 varobj_create (char *objname
,
446 char *expression
, CORE_ADDR frame
, enum varobj_type type
)
449 struct frame_info
*fi
;
450 struct frame_info
*old_fi
= NULL
;
452 struct cleanup
*old_chain
;
454 /* Fill out a varobj structure for the (root) variable being constructed. */
455 var
= new_root_variable ();
456 old_chain
= make_cleanup_free_variable (var
);
458 if (expression
!= NULL
)
461 enum varobj_languages lang
;
462 struct value
*value
= NULL
;
465 /* Parse and evaluate the expression, filling in as much
466 of the variable's data as possible */
468 /* Allow creator to specify context of variable */
469 if ((type
== USE_CURRENT_FRAME
) || (type
== USE_SELECTED_FRAME
))
470 fi
= deprecated_safe_get_selected_frame ();
472 /* FIXME: cagney/2002-11-23: This code should be doing a
473 lookup using the frame ID and not just the frame's
474 ``address''. This, of course, means an interface change.
475 However, with out that interface change ISAs, such as the
476 ia64 with its two stacks, won't work. Similar goes for the
477 case where there is a frameless function. */
478 fi
= find_frame_addr_in_frame_chain (frame
);
480 /* frame = -2 means always use selected frame */
481 if (type
== USE_SELECTED_FRAME
)
482 var
->root
->use_selected_frame
= 1;
486 block
= get_frame_block (fi
, 0);
489 innermost_block
= NULL
;
490 /* Wrap the call to parse expression, so we can
491 return a sensible error. */
492 if (!gdb_parse_exp_1 (&p
, block
, 0, &var
->root
->exp
))
497 /* Don't allow variables to be created for types. */
498 if (var
->root
->exp
->elts
[0].opcode
== OP_TYPE
)
500 do_cleanups (old_chain
);
501 fprintf_unfiltered (gdb_stderr
, "Attempt to use a type name"
502 " as an expression.\n");
506 var
->format
= variable_default_display (var
);
507 var
->root
->valid_block
= innermost_block
;
508 expr_len
= strlen (expression
);
509 var
->name
= savestring (expression
, expr_len
);
510 /* For a root var, the name and the expr are the same. */
511 var
->path_expr
= savestring (expression
, expr_len
);
513 /* When the frame is different from the current frame,
514 we must select the appropriate frame before parsing
515 the expression, otherwise the value will not be current.
516 Since select_frame is so benign, just call it for all cases. */
519 var
->root
->frame
= get_frame_id (fi
);
520 old_fi
= get_selected_frame (NULL
);
524 /* We definitively 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
);
696 enum varobj_display_formats
697 varobj_get_display_format (struct varobj
*var
)
703 varobj_set_frozen (struct varobj
*var
, int frozen
)
705 /* When a variable is unfrozen, we don't fetch its value.
706 The 'not_fetched' flag remains set, so next -var-update
709 We don't fetch the value, because for structures the client
710 should do -var-update anyway. It would be bad to have different
711 client-size logic for structure and other types. */
712 var
->frozen
= frozen
;
716 varobj_get_frozen (struct varobj
*var
)
723 varobj_get_num_children (struct varobj
*var
)
725 if (var
->num_children
== -1)
726 var
->num_children
= number_of_children (var
);
728 return var
->num_children
;
731 /* Creates a list of the immediate children of a variable object;
732 the return code is the number of such children or -1 on error */
735 varobj_list_children (struct varobj
*var
, struct varobj
***childlist
)
737 struct varobj
*child
;
741 /* sanity check: have we been passed a pointer? */
742 if (childlist
== NULL
)
747 if (var
->num_children
== -1)
748 var
->num_children
= number_of_children (var
);
750 /* If that failed, give up. */
751 if (var
->num_children
== -1)
754 /* If we're called when the list of children is not yet initialized,
755 allocate enough elements in it. */
756 while (VEC_length (varobj_p
, var
->children
) < var
->num_children
)
757 VEC_safe_push (varobj_p
, var
->children
, NULL
);
759 /* List of children */
760 *childlist
= xmalloc ((var
->num_children
+ 1) * sizeof (struct varobj
*));
762 for (i
= 0; i
< var
->num_children
; i
++)
766 /* Mark as the end in case we bail out */
767 *((*childlist
) + i
) = NULL
;
769 existing
= VEC_index (varobj_p
, var
->children
, i
);
771 if (existing
== NULL
)
773 /* Either it's the first call to varobj_list_children for
774 this variable object, and the child was never created,
775 or it was explicitly deleted by the client. */
776 name
= name_of_child (var
, i
);
777 existing
= create_child (var
, i
, name
);
778 VEC_replace (varobj_p
, var
->children
, i
, existing
);
781 *((*childlist
) + i
) = existing
;
784 /* End of list is marked by a NULL pointer */
785 *((*childlist
) + i
) = NULL
;
787 return var
->num_children
;
790 /* Obtain the type of an object Variable as a string similar to the one gdb
791 prints on the console */
794 varobj_get_type (struct varobj
*var
)
797 struct cleanup
*old_chain
;
802 /* For the "fake" variables, do not return a type. (It's type is
804 Do not return a type for invalid variables as well. */
805 if (CPLUS_FAKE_CHILD (var
) || !var
->root
->is_valid
)
808 stb
= mem_fileopen ();
809 old_chain
= make_cleanup_ui_file_delete (stb
);
811 /* To print the type, we simply create a zero ``struct value *'' and
812 cast it to our type. We then typeprint this variable. */
813 val
= value_zero (var
->type
, not_lval
);
814 type_print (value_type (val
), "", stb
, -1);
816 thetype
= ui_file_xstrdup (stb
, &length
);
817 do_cleanups (old_chain
);
821 /* Obtain the type of an object variable. */
824 varobj_get_gdb_type (struct varobj
*var
)
829 /* Return a pointer to the full rooted expression of varobj VAR.
830 If it has not been computed yet, compute it. */
832 varobj_get_path_expr (struct varobj
*var
)
834 if (var
->path_expr
!= NULL
)
835 return var
->path_expr
;
838 /* For root varobjs, we initialize path_expr
839 when creating varobj, so here it should be
841 gdb_assert (!is_root_p (var
));
842 return (*var
->root
->lang
->path_expr_of_child
) (var
);
846 enum varobj_languages
847 varobj_get_language (struct varobj
*var
)
849 return variable_language (var
);
853 varobj_get_attributes (struct varobj
*var
)
857 if (var
->root
->is_valid
&& variable_editable (var
))
858 /* FIXME: define masks for attributes */
859 attributes
|= 0x00000001; /* Editable */
865 varobj_get_value (struct varobj
*var
)
867 return my_value_of_variable (var
);
870 /* Set the value of an object variable (if it is editable) to the
871 value of the given expression */
872 /* Note: Invokes functions that can call error() */
875 varobj_set_value (struct varobj
*var
, char *expression
)
881 /* The argument "expression" contains the variable's new value.
882 We need to first construct a legal expression for this -- ugh! */
883 /* Does this cover all the bases? */
884 struct expression
*exp
;
886 int saved_input_radix
= input_radix
;
888 if (var
->value
!= NULL
&& variable_editable (var
))
890 char *s
= expression
;
893 input_radix
= 10; /* ALWAYS reset to decimal temporarily */
894 exp
= parse_exp_1 (&s
, 0, 0);
895 if (!gdb_evaluate_expression (exp
, &value
))
897 /* We cannot proceed without a valid expression. */
902 /* All types that are editable must also be changeable. */
903 gdb_assert (varobj_value_is_changeable_p (var
));
905 /* The value of a changeable variable object must not be lazy. */
906 gdb_assert (!value_lazy (var
->value
));
908 /* Need to coerce the input. We want to check if the
909 value of the variable object will be different
910 after assignment, and the first thing value_assign
911 does is coerce the input.
912 For example, if we are assigning an array to a pointer variable we
913 should compare the pointer with the the array's address, not with the
915 value
= coerce_array (value
);
917 /* The new value may be lazy. gdb_value_assign, or
918 rather value_contents, will take care of this.
919 If fetching of the new value will fail, gdb_value_assign
920 with catch the exception. */
921 if (!gdb_value_assign (var
->value
, value
, &val
))
924 /* If the value has changed, record it, so that next -var-update can
925 report this change. If a variable had a value of '1', we've set it
926 to '333' and then set again to '1', when -var-update will report this
927 variable as changed -- because the first assignment has set the
928 'updated' flag. There's no need to optimize that, because return value
929 of -var-update should be considered an approximation. */
930 var
->updated
= install_new_value (var
, val
, 0 /* Compare values. */);
931 input_radix
= saved_input_radix
;
938 /* Returns a malloc'ed list with all root variable objects */
940 varobj_list (struct varobj
***varlist
)
943 struct varobj_root
*croot
;
944 int mycount
= rootcount
;
946 /* Alloc (rootcount + 1) entries for the result */
947 *varlist
= xmalloc ((rootcount
+ 1) * sizeof (struct varobj
*));
951 while ((croot
!= NULL
) && (mycount
> 0))
953 *cv
= croot
->rootvar
;
958 /* Mark the end of the list */
961 if (mycount
|| (croot
!= NULL
))
963 ("varobj_list: assertion failed - wrong tally of root vars (%d:%d)",
969 /* Assign a new value to a variable object. If INITIAL is non-zero,
970 this is the first assignement after the variable object was just
971 created, or changed type. In that case, just assign the value
973 Otherwise, assign the value and if type_changeable returns non-zero,
974 find if the new value is different from the current value.
975 Return 1 if so, and 0 if the values are equal.
977 The VALUE parameter should not be released -- the function will
978 take care of releasing it when needed. */
980 install_new_value (struct varobj
*var
, struct value
*value
, int initial
)
985 int intentionally_not_fetched
= 0;
987 /* We need to know the varobj's type to decide if the value should
988 be fetched or not. C++ fake children (public/protected/private) don't have
990 gdb_assert (var
->type
|| CPLUS_FAKE_CHILD (var
));
991 changeable
= varobj_value_is_changeable_p (var
);
992 need_to_fetch
= changeable
;
994 /* We are not interested in the address of references, and given
995 that in C++ a reference is not rebindable, it cannot
996 meaningfully change. So, get hold of the real value. */
999 value
= coerce_ref (value
);
1000 release_value (value
);
1003 if (var
->type
&& TYPE_CODE (var
->type
) == TYPE_CODE_UNION
)
1004 /* For unions, we need to fetch the value implicitly because
1005 of implementation of union member fetch. When gdb
1006 creates a value for a field and the value of the enclosing
1007 structure is not lazy, it immediately copies the necessary
1008 bytes from the enclosing values. If the enclosing value is
1009 lazy, the call to value_fetch_lazy on the field will read
1010 the data from memory. For unions, that means we'll read the
1011 same memory more than once, which is not desirable. So
1015 /* The new value might be lazy. If the type is changeable,
1016 that is we'll be comparing values of this type, fetch the
1017 value now. Otherwise, on the next update the old value
1018 will be lazy, which means we've lost that old value. */
1019 if (need_to_fetch
&& value
&& value_lazy (value
))
1021 struct varobj
*parent
= var
->parent
;
1022 int frozen
= var
->frozen
;
1023 for (; !frozen
&& parent
; parent
= parent
->parent
)
1024 frozen
|= parent
->frozen
;
1026 if (frozen
&& initial
)
1028 /* For variables that are frozen, or are children of frozen
1029 variables, we don't do fetch on initial assignment.
1030 For non-initial assignemnt we do the fetch, since it means we're
1031 explicitly asked to compare the new value with the old one. */
1032 intentionally_not_fetched
= 1;
1034 else if (!gdb_value_fetch_lazy (value
))
1036 /* Set the value to NULL, so that for the next -var-update,
1037 we don't try to compare the new value with this value,
1038 that we couldn't even read. */
1043 /* If the type is changeable, compare the old and the new values.
1044 If this is the initial assignment, we don't have any old value
1046 if (initial
&& changeable
)
1047 var
->print_value
= value_get_print_value (value
, var
->format
);
1048 else if (changeable
)
1050 /* If the value of the varobj was changed by -var-set-value, then the
1051 value in the varobj and in the target is the same. However, that value
1052 is different from the value that the varobj had after the previous
1053 -var-update. So need to the varobj as changed. */
1056 xfree (var
->print_value
);
1057 var
->print_value
= value_get_print_value (value
, var
->format
);
1062 /* Try to compare the values. That requires that both
1063 values are non-lazy. */
1064 if (var
->not_fetched
&& value_lazy (var
->value
))
1066 /* This is a frozen varobj and the value was never read.
1067 Presumably, UI shows some "never read" indicator.
1068 Now that we've fetched the real value, we need to report
1069 this varobj as changed so that UI can show the real
1073 else if (var
->value
== NULL
&& value
== NULL
)
1076 else if (var
->value
== NULL
|| value
== NULL
)
1078 xfree (var
->print_value
);
1079 var
->print_value
= value_get_print_value (value
, var
->format
);
1085 gdb_assert (!value_lazy (var
->value
));
1086 gdb_assert (!value_lazy (value
));
1087 print_value
= value_get_print_value (value
, var
->format
);
1089 gdb_assert (var
->print_value
!= NULL
&& print_value
!= NULL
);
1090 if (strcmp (var
->print_value
, print_value
) != 0)
1092 xfree (var
->print_value
);
1093 var
->print_value
= print_value
;
1097 xfree (print_value
);
1102 /* We must always keep the new value, since children depend on it. */
1103 if (var
->value
!= NULL
&& var
->value
!= value
)
1104 value_free (var
->value
);
1106 if (value
&& value_lazy (value
) && intentionally_not_fetched
)
1107 var
->not_fetched
= 1;
1109 var
->not_fetched
= 0;
1112 gdb_assert (!var
->value
|| value_type (var
->value
));
1117 /* Update the values for a variable and its children. This is a
1118 two-pronged attack. First, re-parse the value for the root's
1119 expression to see if it's changed. Then go all the way
1120 through its children, reconstructing them and noting if they've
1123 < 0 for error values, see varobj.h.
1124 Otherwise it is the number of children + parent changed.
1126 The EXPLICIT parameter specifies if this call is result
1127 of MI request to update this specific variable, or
1128 result of implicit -var-update *. For implicit request, we don't
1129 update frozen variables.
1131 NOTE: This function may delete the caller's varobj. If it
1132 returns TYPE_CHANGED, then it has done this and VARP will be modified
1133 to point to the new varobj. */
1136 varobj_update (struct varobj
**varp
, struct varobj
***changelist
,
1140 int type_changed
= 0;
1145 struct varobj
**templist
= NULL
;
1147 VEC (varobj_p
) *stack
= NULL
;
1148 VEC (varobj_p
) *result
= NULL
;
1149 struct frame_id old_fid
;
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 /* Save the selected stack frame, since we will need to change it
1169 in order to evaluate expressions. */
1170 old_fid
= get_frame_id (deprecated_safe_get_selected_frame ());
1172 /* Update the root variable. value_of_root can return NULL
1173 if the variable is no longer around, i.e. we stepped out of
1174 the frame in which a local existed. We are letting the
1175 value_of_root variable dispose of the varobj if the type
1178 new = value_of_root (varp
, &type_changed
);
1180 /* Restore selected frame. */
1181 fi
= frame_find_by_id (old_fid
);
1185 /* If this is a "use_selected_frame" varobj, and its type has changed,
1186 them note that it's changed. */
1188 VEC_safe_push (varobj_p
, result
, *varp
);
1190 if (install_new_value ((*varp
), new, type_changed
))
1192 /* If type_changed is 1, install_new_value will never return
1193 non-zero, so we'll never report the same variable twice. */
1194 gdb_assert (!type_changed
);
1195 VEC_safe_push (varobj_p
, result
, *varp
);
1200 /* This means the varobj itself is out of scope.
1202 VEC_free (varobj_p
, result
);
1203 return NOT_IN_SCOPE
;
1207 VEC_safe_push (varobj_p
, stack
, *varp
);
1209 /* Walk through the children, reconstructing them all. */
1210 while (!VEC_empty (varobj_p
, stack
))
1212 v
= VEC_pop (varobj_p
, stack
);
1214 /* Push any children. Use reverse order so that the first
1215 child is popped from the work stack first, and so
1216 will be added to result first. This does not
1217 affect correctness, just "nicer". */
1218 for (i
= VEC_length (varobj_p
, v
->children
)-1; i
>= 0; --i
)
1220 varobj_p c
= VEC_index (varobj_p
, v
->children
, i
);
1221 /* Child may be NULL if explicitly deleted by -var-delete. */
1222 if (c
!= NULL
&& !c
->frozen
)
1223 VEC_safe_push (varobj_p
, stack
, c
);
1226 /* Update this variable, unless it's a root, which is already
1228 if (v
->root
->rootvar
!= v
)
1230 new = value_of_child (v
->parent
, v
->index
);
1231 if (install_new_value (v
, new, 0 /* type not changed */))
1233 /* Note that it's changed */
1234 VEC_safe_push (varobj_p
, result
, v
);
1240 /* Alloc (changed + 1) list entries. */
1241 changed
= VEC_length (varobj_p
, result
);
1242 *changelist
= xmalloc ((changed
+ 1) * sizeof (struct varobj
*));
1245 for (i
= 0; i
< changed
; ++i
)
1247 *cv
= VEC_index (varobj_p
, result
, i
);
1248 gdb_assert (*cv
!= NULL
);
1253 VEC_free (varobj_p
, stack
);
1254 VEC_free (varobj_p
, result
);
1257 return TYPE_CHANGED
;
1263 /* Helper functions */
1266 * Variable object construction/destruction
1270 delete_variable (struct cpstack
**resultp
, struct varobj
*var
,
1271 int only_children_p
)
1275 delete_variable_1 (resultp
, &delcount
, var
,
1276 only_children_p
, 1 /* remove_from_parent_p */ );
1281 /* Delete the variable object VAR and its children */
1282 /* IMPORTANT NOTE: If we delete a variable which is a child
1283 and the parent is not removed we dump core. It must be always
1284 initially called with remove_from_parent_p set */
1286 delete_variable_1 (struct cpstack
**resultp
, int *delcountp
,
1287 struct varobj
*var
, int only_children_p
,
1288 int remove_from_parent_p
)
1292 /* Delete any children of this variable, too. */
1293 for (i
= 0; i
< VEC_length (varobj_p
, var
->children
); ++i
)
1295 varobj_p child
= VEC_index (varobj_p
, var
->children
, i
);
1296 if (!remove_from_parent_p
)
1297 child
->parent
= NULL
;
1298 delete_variable_1 (resultp
, delcountp
, child
, 0, only_children_p
);
1300 VEC_free (varobj_p
, var
->children
);
1302 /* if we were called to delete only the children we are done here */
1303 if (only_children_p
)
1306 /* Otherwise, add it to the list of deleted ones and proceed to do so */
1307 /* If the name is null, this is a temporary variable, that has not
1308 yet been installed, don't report it, it belongs to the caller... */
1309 if (var
->obj_name
!= NULL
)
1311 cppush (resultp
, xstrdup (var
->obj_name
));
1312 *delcountp
= *delcountp
+ 1;
1315 /* If this variable has a parent, remove it from its parent's list */
1316 /* OPTIMIZATION: if the parent of this variable is also being deleted,
1317 (as indicated by remove_from_parent_p) we don't bother doing an
1318 expensive list search to find the element to remove when we are
1319 discarding the list afterwards */
1320 if ((remove_from_parent_p
) && (var
->parent
!= NULL
))
1322 VEC_replace (varobj_p
, var
->parent
->children
, var
->index
, NULL
);
1325 if (var
->obj_name
!= NULL
)
1326 uninstall_variable (var
);
1328 /* Free memory associated with this variable */
1329 free_variable (var
);
1332 /* Install the given variable VAR with the object name VAR->OBJ_NAME. */
1334 install_variable (struct varobj
*var
)
1337 struct vlist
*newvl
;
1339 unsigned int index
= 0;
1342 for (chp
= var
->obj_name
; *chp
; chp
++)
1344 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
1347 cv
= *(varobj_table
+ index
);
1348 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, var
->obj_name
) != 0))
1352 error (_("Duplicate variable object name"));
1354 /* Add varobj to hash table */
1355 newvl
= xmalloc (sizeof (struct vlist
));
1356 newvl
->next
= *(varobj_table
+ index
);
1358 *(varobj_table
+ index
) = newvl
;
1360 /* If root, add varobj to root list */
1361 if (is_root_p (var
))
1363 /* Add to list of root variables */
1364 if (rootlist
== NULL
)
1365 var
->root
->next
= NULL
;
1367 var
->root
->next
= rootlist
;
1368 rootlist
= var
->root
;
1375 /* Unistall the object VAR. */
1377 uninstall_variable (struct varobj
*var
)
1381 struct varobj_root
*cr
;
1382 struct varobj_root
*prer
;
1384 unsigned int index
= 0;
1387 /* Remove varobj from hash table */
1388 for (chp
= var
->obj_name
; *chp
; chp
++)
1390 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
1393 cv
= *(varobj_table
+ index
);
1395 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, var
->obj_name
) != 0))
1402 fprintf_unfiltered (gdb_stdlog
, "Deleting %s\n", var
->obj_name
);
1407 ("Assertion failed: Could not find variable object \"%s\" to delete",
1413 *(varobj_table
+ index
) = cv
->next
;
1415 prev
->next
= cv
->next
;
1419 /* If root, remove varobj from root list */
1420 if (is_root_p (var
))
1422 /* Remove from list of root variables */
1423 if (rootlist
== var
->root
)
1424 rootlist
= var
->root
->next
;
1429 while ((cr
!= NULL
) && (cr
->rootvar
!= var
))
1437 ("Assertion failed: Could not find varobj \"%s\" in root list",
1444 prer
->next
= cr
->next
;
1451 /* Create and install a child of the parent of the given name */
1452 static struct varobj
*
1453 create_child (struct varobj
*parent
, int index
, char *name
)
1455 struct varobj
*child
;
1457 struct value
*value
;
1459 child
= new_variable ();
1461 /* name is allocated by name_of_child */
1463 child
->index
= index
;
1464 value
= value_of_child (parent
, index
);
1465 child
->parent
= parent
;
1466 child
->root
= parent
->root
;
1467 childs_name
= xstrprintf ("%s.%s", parent
->obj_name
, name
);
1468 child
->obj_name
= childs_name
;
1469 install_variable (child
);
1471 /* Compute the type of the child. Must do this before
1472 calling install_new_value. */
1474 /* If the child had no evaluation errors, var->value
1475 will be non-NULL and contain a valid type. */
1476 child
->type
= value_type (value
);
1478 /* Otherwise, we must compute the type. */
1479 child
->type
= (*child
->root
->lang
->type_of_child
) (child
->parent
,
1481 install_new_value (child
, value
, 1);
1488 * Miscellaneous utility functions.
1491 /* Allocate memory and initialize a new variable */
1492 static struct varobj
*
1497 var
= (struct varobj
*) xmalloc (sizeof (struct varobj
));
1499 var
->path_expr
= NULL
;
1500 var
->obj_name
= NULL
;
1504 var
->num_children
= -1;
1506 var
->children
= NULL
;
1510 var
->print_value
= NULL
;
1512 var
->not_fetched
= 0;
1517 /* Allocate memory and initialize a new root variable */
1518 static struct varobj
*
1519 new_root_variable (void)
1521 struct varobj
*var
= new_variable ();
1522 var
->root
= (struct varobj_root
*) xmalloc (sizeof (struct varobj_root
));;
1523 var
->root
->lang
= NULL
;
1524 var
->root
->exp
= NULL
;
1525 var
->root
->valid_block
= NULL
;
1526 var
->root
->frame
= null_frame_id
;
1527 var
->root
->use_selected_frame
= 0;
1528 var
->root
->rootvar
= NULL
;
1529 var
->root
->is_valid
= 1;
1534 /* Free any allocated memory associated with VAR. */
1536 free_variable (struct varobj
*var
)
1538 /* Free the expression if this is a root variable. */
1539 if (is_root_p (var
))
1541 free_current_contents (&var
->root
->exp
);
1546 xfree (var
->obj_name
);
1547 xfree (var
->print_value
);
1548 xfree (var
->path_expr
);
1553 do_free_variable_cleanup (void *var
)
1555 free_variable (var
);
1558 static struct cleanup
*
1559 make_cleanup_free_variable (struct varobj
*var
)
1561 return make_cleanup (do_free_variable_cleanup
, var
);
1564 /* This returns the type of the variable. It also skips past typedefs
1565 to return the real type of the variable.
1567 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
1568 except within get_target_type and get_type. */
1569 static struct type
*
1570 get_type (struct varobj
*var
)
1576 type
= check_typedef (type
);
1581 /* Return the type of the value that's stored in VAR,
1582 or that would have being stored there if the
1583 value were accessible.
1585 This differs from VAR->type in that VAR->type is always
1586 the true type of the expession in the source language.
1587 The return value of this function is the type we're
1588 actually storing in varobj, and using for displaying
1589 the values and for comparing previous and new values.
1591 For example, top-level references are always stripped. */
1592 static struct type
*
1593 get_value_type (struct varobj
*var
)
1598 type
= value_type (var
->value
);
1602 type
= check_typedef (type
);
1604 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
1605 type
= get_target_type (type
);
1607 type
= check_typedef (type
);
1612 /* This returns the target type (or NULL) of TYPE, also skipping
1613 past typedefs, just like get_type ().
1615 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
1616 except within get_target_type and get_type. */
1617 static struct type
*
1618 get_target_type (struct type
*type
)
1622 type
= TYPE_TARGET_TYPE (type
);
1624 type
= check_typedef (type
);
1630 /* What is the default display for this variable? We assume that
1631 everything is "natural". Any exceptions? */
1632 static enum varobj_display_formats
1633 variable_default_display (struct varobj
*var
)
1635 return FORMAT_NATURAL
;
1638 /* FIXME: The following should be generic for any pointer */
1640 cppush (struct cpstack
**pstack
, char *name
)
1644 s
= (struct cpstack
*) xmalloc (sizeof (struct cpstack
));
1650 /* FIXME: The following should be generic for any pointer */
1652 cppop (struct cpstack
**pstack
)
1657 if ((*pstack
)->name
== NULL
&& (*pstack
)->next
== NULL
)
1662 *pstack
= (*pstack
)->next
;
1669 * Language-dependencies
1672 /* Common entry points */
1674 /* Get the language of variable VAR. */
1675 static enum varobj_languages
1676 variable_language (struct varobj
*var
)
1678 enum varobj_languages lang
;
1680 switch (var
->root
->exp
->language_defn
->la_language
)
1686 case language_cplus
:
1697 /* Return the number of children for a given variable.
1698 The result of this function is defined by the language
1699 implementation. The number of children returned by this function
1700 is the number of children that the user will see in the variable
1703 number_of_children (struct varobj
*var
)
1705 return (*var
->root
->lang
->number_of_children
) (var
);;
1708 /* What is the expression for the root varobj VAR? Returns a malloc'd string. */
1710 name_of_variable (struct varobj
*var
)
1712 return (*var
->root
->lang
->name_of_variable
) (var
);
1715 /* What is the name of the INDEX'th child of VAR? Returns a malloc'd string. */
1717 name_of_child (struct varobj
*var
, int index
)
1719 return (*var
->root
->lang
->name_of_child
) (var
, index
);
1722 /* What is the ``struct value *'' of the root variable VAR?
1723 TYPE_CHANGED controls what to do if the type of a
1724 use_selected_frame = 1 variable changes. On input,
1725 TYPE_CHANGED = 1 means discard the old varobj, and replace
1726 it with this one. TYPE_CHANGED = 0 means leave it around.
1727 NB: In both cases, var_handle will point to the new varobj,
1728 so if you use TYPE_CHANGED = 0, you will have to stash the
1729 old varobj pointer away somewhere before calling this.
1730 On return, TYPE_CHANGED will be 1 if the type has changed, and
1732 static struct value
*
1733 value_of_root (struct varobj
**var_handle
, int *type_changed
)
1737 if (var_handle
== NULL
)
1742 /* This should really be an exception, since this should
1743 only get called with a root variable. */
1745 if (!is_root_p (var
))
1748 if (var
->root
->use_selected_frame
)
1750 struct varobj
*tmp_var
;
1751 char *old_type
, *new_type
;
1753 tmp_var
= varobj_create (NULL
, var
->name
, (CORE_ADDR
) 0,
1754 USE_SELECTED_FRAME
);
1755 if (tmp_var
== NULL
)
1759 old_type
= varobj_get_type (var
);
1760 new_type
= varobj_get_type (tmp_var
);
1761 if (strcmp (old_type
, new_type
) == 0)
1763 varobj_delete (tmp_var
, NULL
, 0);
1771 savestring (var
->obj_name
, strlen (var
->obj_name
));
1772 varobj_delete (var
, NULL
, 0);
1776 tmp_var
->obj_name
= varobj_gen_name ();
1778 install_variable (tmp_var
);
1779 *var_handle
= tmp_var
;
1791 return (*var
->root
->lang
->value_of_root
) (var_handle
);
1794 /* What is the ``struct value *'' for the INDEX'th child of PARENT? */
1795 static struct value
*
1796 value_of_child (struct varobj
*parent
, int index
)
1798 struct value
*value
;
1800 value
= (*parent
->root
->lang
->value_of_child
) (parent
, index
);
1805 /* Is this variable editable? Use the variable's type to make
1806 this determination. */
1808 variable_editable (struct varobj
*var
)
1810 return (*var
->root
->lang
->variable_editable
) (var
);
1813 /* GDB already has a command called "value_of_variable". Sigh. */
1815 my_value_of_variable (struct varobj
*var
)
1817 if (var
->root
->is_valid
)
1818 return (*var
->root
->lang
->value_of_variable
) (var
);
1824 value_get_print_value (struct value
*value
, enum varobj_display_formats format
)
1827 struct ui_file
*stb
;
1828 struct cleanup
*old_chain
;
1834 stb
= mem_fileopen ();
1835 old_chain
= make_cleanup_ui_file_delete (stb
);
1837 common_val_print (value
, stb
, format_code
[(int) format
], 1, 0, 0);
1838 thevalue
= ui_file_xstrdup (stb
, &dummy
);
1840 do_cleanups (old_chain
);
1844 /* Return non-zero if changes in value of VAR
1845 must be detected and reported by -var-update.
1846 Return zero is -var-update should never report
1847 changes of such values. This makes sense for structures
1848 (since the changes in children values will be reported separately),
1849 or for artifical objects (like 'public' pseudo-field in C++).
1851 Return value of 0 means that gdb need not call value_fetch_lazy
1852 for the value of this variable object. */
1854 varobj_value_is_changeable_p (struct varobj
*var
)
1859 if (CPLUS_FAKE_CHILD (var
))
1862 type
= get_value_type (var
);
1864 switch (TYPE_CODE (type
))
1866 case TYPE_CODE_STRUCT
:
1867 case TYPE_CODE_UNION
:
1868 case TYPE_CODE_ARRAY
:
1879 /* Given the value and the type of a variable object,
1880 adjust the value and type to those necessary
1881 for getting children of the variable object.
1882 This includes dereferencing top-level references
1883 to all types and dereferencing pointers to
1886 Both TYPE and *TYPE should be non-null. VALUE
1887 can be null if we want to only translate type.
1888 *VALUE can be null as well -- if the parent
1891 If WAS_PTR is not NULL, set *WAS_PTR to 0 or 1
1892 depending on whether pointer was deferenced
1893 in this function. */
1895 adjust_value_for_child_access (struct value
**value
,
1899 gdb_assert (type
&& *type
);
1904 *type
= check_typedef (*type
);
1906 /* The type of value stored in varobj, that is passed
1907 to us, is already supposed to be
1908 reference-stripped. */
1910 gdb_assert (TYPE_CODE (*type
) != TYPE_CODE_REF
);
1912 /* Pointers to structures are treated just like
1913 structures when accessing children. Don't
1914 dererences pointers to other types. */
1915 if (TYPE_CODE (*type
) == TYPE_CODE_PTR
)
1917 struct type
*target_type
= get_target_type (*type
);
1918 if (TYPE_CODE (target_type
) == TYPE_CODE_STRUCT
1919 || TYPE_CODE (target_type
) == TYPE_CODE_UNION
)
1921 if (value
&& *value
)
1922 gdb_value_ind (*value
, value
);
1923 *type
= target_type
;
1929 /* The 'get_target_type' function calls check_typedef on
1930 result, so we can immediately check type code. No
1931 need to call check_typedef here. */
1936 c_number_of_children (struct varobj
*var
)
1938 struct type
*type
= get_value_type (var
);
1940 struct type
*target
;
1942 adjust_value_for_child_access (NULL
, &type
, NULL
);
1943 target
= get_target_type (type
);
1945 switch (TYPE_CODE (type
))
1947 case TYPE_CODE_ARRAY
:
1948 if (TYPE_LENGTH (type
) > 0 && TYPE_LENGTH (target
) > 0
1949 && TYPE_ARRAY_UPPER_BOUND_TYPE (type
) != BOUND_CANNOT_BE_DETERMINED
)
1950 children
= TYPE_LENGTH (type
) / TYPE_LENGTH (target
);
1952 /* If we don't know how many elements there are, don't display
1957 case TYPE_CODE_STRUCT
:
1958 case TYPE_CODE_UNION
:
1959 children
= TYPE_NFIELDS (type
);
1963 /* The type here is a pointer to non-struct. Typically, pointers
1964 have one child, except for function ptrs, which have no children,
1965 and except for void*, as we don't know what to show.
1967 We can show char* so we allow it to be dereferenced. If you decide
1968 to test for it, please mind that a little magic is necessary to
1969 properly identify it: char* has TYPE_CODE == TYPE_CODE_INT and
1970 TYPE_NAME == "char" */
1971 if (TYPE_CODE (target
) == TYPE_CODE_FUNC
1972 || TYPE_CODE (target
) == TYPE_CODE_VOID
)
1979 /* Other types have no children */
1987 c_name_of_variable (struct varobj
*parent
)
1989 return savestring (parent
->name
, strlen (parent
->name
));
1992 /* Return the value of element TYPE_INDEX of a structure
1993 value VALUE. VALUE's type should be a structure,
1994 or union, or a typedef to struct/union.
1996 Returns NULL if getting the value fails. Never throws. */
1997 static struct value
*
1998 value_struct_element_index (struct value
*value
, int type_index
)
2000 struct value
*result
= NULL
;
2001 volatile struct gdb_exception e
;
2003 struct type
*type
= value_type (value
);
2004 type
= check_typedef (type
);
2006 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
2007 || TYPE_CODE (type
) == TYPE_CODE_UNION
);
2009 TRY_CATCH (e
, RETURN_MASK_ERROR
)
2011 if (TYPE_FIELD_STATIC (type
, type_index
))
2012 result
= value_static_field (type
, type_index
);
2014 result
= value_primitive_field (value
, 0, type_index
, type
);
2026 /* Obtain the information about child INDEX of the variable
2028 If CNAME is not null, sets *CNAME to the name of the child relative
2030 If CVALUE is not null, sets *CVALUE to the value of the child.
2031 If CTYPE is not null, sets *CTYPE to the type of the child.
2033 If any of CNAME, CVALUE, or CTYPE is not null, but the corresponding
2034 information cannot be determined, set *CNAME, *CVALUE, or *CTYPE
2037 c_describe_child (struct varobj
*parent
, int index
,
2038 char **cname
, struct value
**cvalue
, struct type
**ctype
,
2039 char **cfull_expression
)
2041 struct value
*value
= parent
->value
;
2042 struct type
*type
= get_value_type (parent
);
2043 char *parent_expression
= NULL
;
2052 if (cfull_expression
)
2054 *cfull_expression
= NULL
;
2055 parent_expression
= varobj_get_path_expr (parent
);
2057 adjust_value_for_child_access (&value
, &type
, &was_ptr
);
2059 switch (TYPE_CODE (type
))
2061 case TYPE_CODE_ARRAY
:
2063 *cname
= xstrprintf ("%d", index
2064 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
)));
2066 if (cvalue
&& value
)
2068 int real_index
= index
+ TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
));
2069 struct value
*indval
=
2070 value_from_longest (builtin_type_int
, (LONGEST
) real_index
);
2071 gdb_value_subscript (value
, indval
, cvalue
);
2075 *ctype
= get_target_type (type
);
2077 if (cfull_expression
)
2078 *cfull_expression
= xstrprintf ("(%s)[%d]", parent_expression
,
2080 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
)));
2085 case TYPE_CODE_STRUCT
:
2086 case TYPE_CODE_UNION
:
2089 char *string
= TYPE_FIELD_NAME (type
, index
);
2090 *cname
= savestring (string
, strlen (string
));
2093 if (cvalue
&& value
)
2095 /* For C, varobj index is the same as type index. */
2096 *cvalue
= value_struct_element_index (value
, index
);
2100 *ctype
= TYPE_FIELD_TYPE (type
, index
);
2102 if (cfull_expression
)
2104 char *join
= was_ptr
? "->" : ".";
2105 *cfull_expression
= xstrprintf ("(%s)%s%s", parent_expression
, join
,
2106 TYPE_FIELD_NAME (type
, index
));
2113 *cname
= xstrprintf ("*%s", parent
->name
);
2115 if (cvalue
&& value
)
2116 gdb_value_ind (value
, cvalue
);
2118 /* Don't use get_target_type because it calls
2119 check_typedef and here, we want to show the true
2120 declared type of the variable. */
2122 *ctype
= TYPE_TARGET_TYPE (type
);
2124 if (cfull_expression
)
2125 *cfull_expression
= xstrprintf ("*(%s)", parent_expression
);
2130 /* This should not happen */
2132 *cname
= xstrdup ("???");
2133 if (cfull_expression
)
2134 *cfull_expression
= xstrdup ("???");
2135 /* Don't set value and type, we don't know then. */
2140 c_name_of_child (struct varobj
*parent
, int index
)
2143 c_describe_child (parent
, index
, &name
, NULL
, NULL
, NULL
);
2148 c_path_expr_of_child (struct varobj
*child
)
2150 c_describe_child (child
->parent
, child
->index
, NULL
, NULL
, NULL
,
2152 return child
->path_expr
;
2155 static struct value
*
2156 c_value_of_root (struct varobj
**var_handle
)
2158 struct value
*new_val
= NULL
;
2159 struct varobj
*var
= *var_handle
;
2160 struct frame_info
*fi
;
2163 /* Only root variables can be updated... */
2164 if (!is_root_p (var
))
2165 /* Not a root var */
2169 /* Determine whether the variable is still around. */
2170 if (var
->root
->valid_block
== NULL
|| var
->root
->use_selected_frame
)
2174 fi
= frame_find_by_id (var
->root
->frame
);
2175 within_scope
= fi
!= NULL
;
2176 /* FIXME: select_frame could fail */
2179 CORE_ADDR pc
= get_frame_pc (fi
);
2180 if (pc
< BLOCK_START (var
->root
->valid_block
) ||
2181 pc
>= BLOCK_END (var
->root
->valid_block
))
2190 /* We need to catch errors here, because if evaluate
2191 expression fails we want to just return NULL. */
2192 gdb_evaluate_expression (var
->root
->exp
, &new_val
);
2199 static struct value
*
2200 c_value_of_child (struct varobj
*parent
, int index
)
2202 struct value
*value
= NULL
;
2203 c_describe_child (parent
, index
, NULL
, &value
, NULL
, NULL
);
2208 static struct type
*
2209 c_type_of_child (struct varobj
*parent
, int index
)
2211 struct type
*type
= NULL
;
2212 c_describe_child (parent
, index
, NULL
, NULL
, &type
, NULL
);
2217 c_variable_editable (struct varobj
*var
)
2219 switch (TYPE_CODE (get_value_type (var
)))
2221 case TYPE_CODE_STRUCT
:
2222 case TYPE_CODE_UNION
:
2223 case TYPE_CODE_ARRAY
:
2224 case TYPE_CODE_FUNC
:
2225 case TYPE_CODE_METHOD
:
2236 c_value_of_variable (struct varobj
*var
)
2238 /* BOGUS: if val_print sees a struct/class, or a reference to one,
2239 it will print out its children instead of "{...}". So we need to
2240 catch that case explicitly. */
2241 struct type
*type
= get_type (var
);
2243 /* Strip top-level references. */
2244 while (TYPE_CODE (type
) == TYPE_CODE_REF
)
2245 type
= check_typedef (TYPE_TARGET_TYPE (type
));
2247 switch (TYPE_CODE (type
))
2249 case TYPE_CODE_STRUCT
:
2250 case TYPE_CODE_UNION
:
2251 return xstrdup ("{...}");
2254 case TYPE_CODE_ARRAY
:
2257 number
= xstrprintf ("[%d]", var
->num_children
);
2264 if (var
->value
== NULL
)
2266 /* This can happen if we attempt to get the value of a struct
2267 member when the parent is an invalid pointer. This is an
2268 error condition, so we should tell the caller. */
2273 if (var
->not_fetched
&& value_lazy (var
->value
))
2274 /* Frozen variable and no value yet. We don't
2275 implicitly fetch the value. MI response will
2276 use empty string for the value, which is OK. */
2279 gdb_assert (varobj_value_is_changeable_p (var
));
2280 gdb_assert (!value_lazy (var
->value
));
2281 return value_get_print_value (var
->value
, var
->format
);
2291 cplus_number_of_children (struct varobj
*var
)
2294 int children
, dont_know
;
2299 if (!CPLUS_FAKE_CHILD (var
))
2301 type
= get_value_type (var
);
2302 adjust_value_for_child_access (NULL
, &type
, NULL
);
2304 if (((TYPE_CODE (type
)) == TYPE_CODE_STRUCT
) ||
2305 ((TYPE_CODE (type
)) == TYPE_CODE_UNION
))
2309 cplus_class_num_children (type
, kids
);
2310 if (kids
[v_public
] != 0)
2312 if (kids
[v_private
] != 0)
2314 if (kids
[v_protected
] != 0)
2317 /* Add any baseclasses */
2318 children
+= TYPE_N_BASECLASSES (type
);
2321 /* FIXME: save children in var */
2328 type
= get_value_type (var
->parent
);
2329 adjust_value_for_child_access (NULL
, &type
, NULL
);
2331 cplus_class_num_children (type
, kids
);
2332 if (strcmp (var
->name
, "public") == 0)
2333 children
= kids
[v_public
];
2334 else if (strcmp (var
->name
, "private") == 0)
2335 children
= kids
[v_private
];
2337 children
= kids
[v_protected
];
2342 children
= c_number_of_children (var
);
2347 /* Compute # of public, private, and protected variables in this class.
2348 That means we need to descend into all baseclasses and find out
2349 how many are there, too. */
2351 cplus_class_num_children (struct type
*type
, int children
[3])
2355 children
[v_public
] = 0;
2356 children
[v_private
] = 0;
2357 children
[v_protected
] = 0;
2359 for (i
= TYPE_N_BASECLASSES (type
); i
< TYPE_NFIELDS (type
); i
++)
2361 /* If we have a virtual table pointer, omit it. */
2362 if (TYPE_VPTR_BASETYPE (type
) == type
&& TYPE_VPTR_FIELDNO (type
) == i
)
2365 if (TYPE_FIELD_PROTECTED (type
, i
))
2366 children
[v_protected
]++;
2367 else if (TYPE_FIELD_PRIVATE (type
, i
))
2368 children
[v_private
]++;
2370 children
[v_public
]++;
2375 cplus_name_of_variable (struct varobj
*parent
)
2377 return c_name_of_variable (parent
);
2380 enum accessibility
{ private_field
, protected_field
, public_field
};
2382 /* Check if field INDEX of TYPE has the specified accessibility.
2383 Return 0 if so and 1 otherwise. */
2385 match_accessibility (struct type
*type
, int index
, enum accessibility acc
)
2387 if (acc
== private_field
&& TYPE_FIELD_PRIVATE (type
, index
))
2389 else if (acc
== protected_field
&& TYPE_FIELD_PROTECTED (type
, index
))
2391 else if (acc
== public_field
&& !TYPE_FIELD_PRIVATE (type
, index
)
2392 && !TYPE_FIELD_PROTECTED (type
, index
))
2399 cplus_describe_child (struct varobj
*parent
, int index
,
2400 char **cname
, struct value
**cvalue
, struct type
**ctype
,
2401 char **cfull_expression
)
2404 struct value
*value
;
2407 char *parent_expression
= NULL
;
2415 if (cfull_expression
)
2416 *cfull_expression
= NULL
;
2418 if (CPLUS_FAKE_CHILD (parent
))
2420 value
= parent
->parent
->value
;
2421 type
= get_value_type (parent
->parent
);
2422 if (cfull_expression
)
2423 parent_expression
= varobj_get_path_expr (parent
->parent
);
2427 value
= parent
->value
;
2428 type
= get_value_type (parent
);
2429 if (cfull_expression
)
2430 parent_expression
= varobj_get_path_expr (parent
);
2433 adjust_value_for_child_access (&value
, &type
, &was_ptr
);
2435 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
2436 || TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
2438 char *join
= was_ptr
? "->" : ".";
2439 if (CPLUS_FAKE_CHILD (parent
))
2441 /* The fields of the class type are ordered as they
2442 appear in the class. We are given an index for a
2443 particular access control type ("public","protected",
2444 or "private"). We must skip over fields that don't
2445 have the access control we are looking for to properly
2446 find the indexed field. */
2447 int type_index
= TYPE_N_BASECLASSES (type
);
2448 enum accessibility acc
= public_field
;
2449 if (strcmp (parent
->name
, "private") == 0)
2450 acc
= private_field
;
2451 else if (strcmp (parent
->name
, "protected") == 0)
2452 acc
= protected_field
;
2456 if (TYPE_VPTR_BASETYPE (type
) == type
2457 && type_index
== TYPE_VPTR_FIELDNO (type
))
2459 else if (match_accessibility (type
, type_index
, acc
))
2466 *cname
= xstrdup (TYPE_FIELD_NAME (type
, type_index
));
2468 if (cvalue
&& value
)
2469 *cvalue
= value_struct_element_index (value
, type_index
);
2472 *ctype
= TYPE_FIELD_TYPE (type
, type_index
);
2474 if (cfull_expression
)
2475 *cfull_expression
= xstrprintf ("((%s)%s%s)", parent_expression
,
2477 TYPE_FIELD_NAME (type
, type_index
));
2479 else if (index
< TYPE_N_BASECLASSES (type
))
2481 /* This is a baseclass. */
2483 *cname
= xstrdup (TYPE_FIELD_NAME (type
, index
));
2485 if (cvalue
&& value
)
2487 *cvalue
= value_cast (TYPE_FIELD_TYPE (type
, index
), value
);
2488 release_value (*cvalue
);
2493 *ctype
= TYPE_FIELD_TYPE (type
, index
);
2496 if (cfull_expression
)
2498 char *ptr
= was_ptr
? "*" : "";
2499 /* Cast the parent to the base' type. Note that in gdb,
2502 will create an lvalue, for all appearences, so we don't
2503 need to use more fancy:
2506 *cfull_expression
= xstrprintf ("(%s(%s%s) %s)",
2508 TYPE_FIELD_NAME (type
, index
),
2515 char *access
= NULL
;
2517 cplus_class_num_children (type
, children
);
2519 /* Everything beyond the baseclasses can
2520 only be "public", "private", or "protected"
2522 The special "fake" children are always output by varobj in
2523 this order. So if INDEX == 2, it MUST be "protected". */
2524 index
-= TYPE_N_BASECLASSES (type
);
2528 if (children
[v_public
] > 0)
2530 else if (children
[v_private
] > 0)
2533 access
= "protected";
2536 if (children
[v_public
] > 0)
2538 if (children
[v_private
] > 0)
2541 access
= "protected";
2543 else if (children
[v_private
] > 0)
2544 access
= "protected";
2547 /* Must be protected */
2548 access
= "protected";
2555 gdb_assert (access
);
2557 *cname
= xstrdup (access
);
2559 /* Value and type and full expression are null here. */
2564 c_describe_child (parent
, index
, cname
, cvalue
, ctype
, cfull_expression
);
2569 cplus_name_of_child (struct varobj
*parent
, int index
)
2572 cplus_describe_child (parent
, index
, &name
, NULL
, NULL
, NULL
);
2577 cplus_path_expr_of_child (struct varobj
*child
)
2579 cplus_describe_child (child
->parent
, child
->index
, NULL
, NULL
, NULL
,
2581 return child
->path_expr
;
2584 static struct value
*
2585 cplus_value_of_root (struct varobj
**var_handle
)
2587 return c_value_of_root (var_handle
);
2590 static struct value
*
2591 cplus_value_of_child (struct varobj
*parent
, int index
)
2593 struct value
*value
= NULL
;
2594 cplus_describe_child (parent
, index
, NULL
, &value
, NULL
, NULL
);
2598 static struct type
*
2599 cplus_type_of_child (struct varobj
*parent
, int index
)
2601 struct type
*type
= NULL
;
2602 cplus_describe_child (parent
, index
, NULL
, NULL
, &type
, NULL
);
2607 cplus_variable_editable (struct varobj
*var
)
2609 if (CPLUS_FAKE_CHILD (var
))
2612 return c_variable_editable (var
);
2616 cplus_value_of_variable (struct varobj
*var
)
2619 /* If we have one of our special types, don't print out
2621 if (CPLUS_FAKE_CHILD (var
))
2622 return xstrdup ("");
2624 return c_value_of_variable (var
);
2630 java_number_of_children (struct varobj
*var
)
2632 return cplus_number_of_children (var
);
2636 java_name_of_variable (struct varobj
*parent
)
2640 name
= cplus_name_of_variable (parent
);
2641 /* If the name has "-" in it, it is because we
2642 needed to escape periods in the name... */
2645 while (*p
!= '\000')
2656 java_name_of_child (struct varobj
*parent
, int index
)
2660 name
= cplus_name_of_child (parent
, index
);
2661 /* Escape any periods in the name... */
2664 while (*p
!= '\000')
2675 java_path_expr_of_child (struct varobj
*child
)
2680 static struct value
*
2681 java_value_of_root (struct varobj
**var_handle
)
2683 return cplus_value_of_root (var_handle
);
2686 static struct value
*
2687 java_value_of_child (struct varobj
*parent
, int index
)
2689 return cplus_value_of_child (parent
, index
);
2692 static struct type
*
2693 java_type_of_child (struct varobj
*parent
, int index
)
2695 return cplus_type_of_child (parent
, index
);
2699 java_variable_editable (struct varobj
*var
)
2701 return cplus_variable_editable (var
);
2705 java_value_of_variable (struct varobj
*var
)
2707 return cplus_value_of_variable (var
);
2710 extern void _initialize_varobj (void);
2712 _initialize_varobj (void)
2714 int sizeof_table
= sizeof (struct vlist
*) * VAROBJ_TABLE_SIZE
;
2716 varobj_table
= xmalloc (sizeof_table
);
2717 memset (varobj_table
, 0, sizeof_table
);
2719 add_setshow_zinteger_cmd ("debugvarobj", class_maintenance
,
2721 Set varobj debugging."), _("\
2722 Show varobj debugging."), _("\
2723 When non-zero, varobj debugging is enabled."),
2726 &setlist
, &showlist
);
2729 /* Invalidate the varobjs that are tied to locals and re-create the ones that
2730 are defined on globals.
2731 Invalidated varobjs will be always printed in_scope="invalid". */
2733 varobj_invalidate (void)
2735 struct varobj
**all_rootvarobj
;
2736 struct varobj
**varp
;
2738 if (varobj_list (&all_rootvarobj
) > 0)
2740 varp
= all_rootvarobj
;
2741 while (*varp
!= NULL
)
2743 /* global var must be re-evaluated. */
2744 if ((*varp
)->root
->valid_block
== NULL
)
2746 struct varobj
*tmp_var
;
2748 /* Try to create a varobj with same expression. If we succeed replace
2749 the old varobj, otherwise invalidate it. */
2750 tmp_var
= varobj_create (NULL
, (*varp
)->name
, (CORE_ADDR
) 0, USE_CURRENT_FRAME
);
2751 if (tmp_var
!= NULL
)
2753 tmp_var
->obj_name
= xstrdup ((*varp
)->obj_name
);
2754 varobj_delete (*varp
, NULL
, 0);
2755 install_variable (tmp_var
);
2758 (*varp
)->root
->is_valid
= 0;
2760 else /* locals must be invalidated. */
2761 (*varp
)->root
->is_valid
= 0;
2765 xfree (all_rootvarobj
);