1 /* Implementation of the GDB variable objects API.
3 Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
4 2009 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"
30 #include "gdb_assert.h"
31 #include "gdb_string.h"
35 #include "gdbthread.h"
38 /* Non-zero if we want to see trace of varobj level stuff. */
42 show_varobjdebug (struct ui_file
*file
, int from_tty
,
43 struct cmd_list_element
*c
, const char *value
)
45 fprintf_filtered (file
, _("Varobj debugging is %s.\n"), value
);
48 /* String representations of gdb's format codes */
49 char *varobj_format_string
[] =
50 { "natural", "binary", "decimal", "hexadecimal", "octal" };
52 /* String representations of gdb's known languages */
53 char *varobj_language_string
[] = { "unknown", "C", "C++", "Java" };
57 /* Every root variable has one of these structures saved in its
58 varobj. Members which must be free'd are noted. */
62 /* Alloc'd expression for this parent. */
63 struct expression
*exp
;
65 /* Block for which this expression is valid */
66 struct block
*valid_block
;
68 /* The frame for this expression. This field is set iff valid_block is
70 struct frame_id frame
;
72 /* The thread ID that this varobj_root belong to. This field
73 is only valid if valid_block is not NULL.
74 When not 0, indicates which thread 'frame' belongs to.
75 When 0, indicates that the thread list was empty when the varobj_root
79 /* If 1, the -var-update always recomputes the value in the
80 current thread and frame. Otherwise, variable object is
81 always updated in the specific scope/thread/frame */
84 /* Flag that indicates validity: set to 0 when this varobj_root refers
85 to symbols that do not exist anymore. */
88 /* Language info for this variable and its children */
89 struct language_specific
*lang
;
91 /* The varobj for this root node. */
92 struct varobj
*rootvar
;
94 /* Next root variable */
95 struct varobj_root
*next
;
98 /* Every variable in the system has a structure of this type defined
99 for it. This structure holds all information necessary to manipulate
100 a particular object variable. Members which must be freed are noted. */
104 /* Alloc'd name of the variable for this object.. If this variable is a
105 child, then this name will be the child's source name.
106 (bar, not foo.bar) */
107 /* NOTE: This is the "expression" */
110 /* Alloc'd expression for this child. Can be used to create a
111 root variable corresponding to this child. */
114 /* The alloc'd name for this variable's object. This is here for
115 convenience when constructing this object's children. */
118 /* Index of this variable in its parent or -1 */
121 /* The type of this variable. This can be NULL
122 for artifial variable objects -- currently, the "accessibility"
123 variable objects in C++. */
126 /* The value of this expression or subexpression. A NULL value
127 indicates there was an error getting this value.
128 Invariant: if varobj_value_is_changeable_p (this) is non-zero,
129 the value is either NULL, or not lazy. */
132 /* The number of (immediate) children this variable has */
135 /* If this object is a child, this points to its immediate parent. */
136 struct varobj
*parent
;
138 /* Children of this object. */
139 VEC (varobj_p
) *children
;
141 /* Description of the root variable. Points to root variable for children. */
142 struct varobj_root
*root
;
144 /* The format of the output for this object */
145 enum varobj_display_formats format
;
147 /* Was this variable updated via a varobj_set_value operation */
150 /* Last print value. */
153 /* Is this variable frozen. Frozen variables are never implicitly
154 updated by -var-update *
155 or -var-update <direct-or-indirect-parent>. */
158 /* Is the value of this variable intentionally not fetched? It is
159 not fetched if either the variable is frozen, or any parents is
167 struct cpstack
*next
;
170 /* A list of varobjs */
178 /* Private function prototypes */
180 /* Helper functions for the above subcommands. */
182 static int delete_variable (struct cpstack
**, struct varobj
*, int);
184 static void delete_variable_1 (struct cpstack
**, int *,
185 struct varobj
*, int, int);
187 static int install_variable (struct varobj
*);
189 static void uninstall_variable (struct varobj
*);
191 static struct varobj
*create_child (struct varobj
*, int, char *);
193 /* Utility routines */
195 static struct varobj
*new_variable (void);
197 static struct varobj
*new_root_variable (void);
199 static void free_variable (struct varobj
*var
);
201 static struct cleanup
*make_cleanup_free_variable (struct varobj
*var
);
203 static struct type
*get_type (struct varobj
*var
);
205 static struct type
*get_value_type (struct varobj
*var
);
207 static struct type
*get_target_type (struct type
*);
209 static enum varobj_display_formats
variable_default_display (struct varobj
*);
211 static void cppush (struct cpstack
**pstack
, char *name
);
213 static char *cppop (struct cpstack
**pstack
);
215 static int install_new_value (struct varobj
*var
, struct value
*value
,
218 /* Language-specific routines. */
220 static enum varobj_languages
variable_language (struct varobj
*var
);
222 static int number_of_children (struct varobj
*);
224 static char *name_of_variable (struct varobj
*);
226 static char *name_of_child (struct varobj
*, int);
228 static struct value
*value_of_root (struct varobj
**var_handle
, int *);
230 static struct value
*value_of_child (struct varobj
*parent
, int index
);
232 static char *my_value_of_variable (struct varobj
*var
,
233 enum varobj_display_formats format
);
235 static char *value_get_print_value (struct value
*value
,
236 enum varobj_display_formats format
);
238 static int varobj_value_is_changeable_p (struct varobj
*var
);
240 static int is_root_p (struct varobj
*var
);
242 /* C implementation */
244 static int c_number_of_children (struct varobj
*var
);
246 static char *c_name_of_variable (struct varobj
*parent
);
248 static char *c_name_of_child (struct varobj
*parent
, int index
);
250 static char *c_path_expr_of_child (struct varobj
*child
);
252 static struct value
*c_value_of_root (struct varobj
**var_handle
);
254 static struct value
*c_value_of_child (struct varobj
*parent
, int index
);
256 static struct type
*c_type_of_child (struct varobj
*parent
, int index
);
258 static char *c_value_of_variable (struct varobj
*var
,
259 enum varobj_display_formats format
);
261 /* C++ implementation */
263 static int cplus_number_of_children (struct varobj
*var
);
265 static void cplus_class_num_children (struct type
*type
, int children
[3]);
267 static char *cplus_name_of_variable (struct varobj
*parent
);
269 static char *cplus_name_of_child (struct varobj
*parent
, int index
);
271 static char *cplus_path_expr_of_child (struct varobj
*child
);
273 static struct value
*cplus_value_of_root (struct varobj
**var_handle
);
275 static struct value
*cplus_value_of_child (struct varobj
*parent
, int index
);
277 static struct type
*cplus_type_of_child (struct varobj
*parent
, int index
);
279 static char *cplus_value_of_variable (struct varobj
*var
,
280 enum varobj_display_formats format
);
282 /* Java implementation */
284 static int java_number_of_children (struct varobj
*var
);
286 static char *java_name_of_variable (struct varobj
*parent
);
288 static char *java_name_of_child (struct varobj
*parent
, int index
);
290 static char *java_path_expr_of_child (struct varobj
*child
);
292 static struct value
*java_value_of_root (struct varobj
**var_handle
);
294 static struct value
*java_value_of_child (struct varobj
*parent
, int index
);
296 static struct type
*java_type_of_child (struct varobj
*parent
, int index
);
298 static char *java_value_of_variable (struct varobj
*var
,
299 enum varobj_display_formats format
);
301 /* The language specific vector */
303 struct language_specific
306 /* The language of this variable */
307 enum varobj_languages language
;
309 /* The number of children of PARENT. */
310 int (*number_of_children
) (struct varobj
* parent
);
312 /* The name (expression) of a root varobj. */
313 char *(*name_of_variable
) (struct varobj
* parent
);
315 /* The name of the INDEX'th child of PARENT. */
316 char *(*name_of_child
) (struct varobj
* parent
, int index
);
318 /* Returns the rooted expression of CHILD, which is a variable
319 obtain that has some parent. */
320 char *(*path_expr_of_child
) (struct varobj
* child
);
322 /* The ``struct value *'' of the root variable ROOT. */
323 struct value
*(*value_of_root
) (struct varobj
** root_handle
);
325 /* The ``struct value *'' of the INDEX'th child of PARENT. */
326 struct value
*(*value_of_child
) (struct varobj
* parent
, int index
);
328 /* The type of the INDEX'th child of PARENT. */
329 struct type
*(*type_of_child
) (struct varobj
* parent
, int index
);
331 /* The current value of VAR. */
332 char *(*value_of_variable
) (struct varobj
* var
,
333 enum varobj_display_formats format
);
336 /* Array of known source language routines. */
337 static struct language_specific languages
[vlang_end
] = {
338 /* Unknown (try treating as C */
341 c_number_of_children
,
344 c_path_expr_of_child
,
353 c_number_of_children
,
356 c_path_expr_of_child
,
365 cplus_number_of_children
,
366 cplus_name_of_variable
,
368 cplus_path_expr_of_child
,
370 cplus_value_of_child
,
372 cplus_value_of_variable
}
377 java_number_of_children
,
378 java_name_of_variable
,
380 java_path_expr_of_child
,
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)
434 for (frame
= get_current_frame ();
436 frame
= get_prev_frame (frame
))
438 if (get_frame_base_address (frame
) == frame_addr
)
446 varobj_create (char *objname
,
447 char *expression
, CORE_ADDR frame
, enum varobj_type type
)
450 struct frame_info
*fi
;
451 struct frame_info
*old_fi
= NULL
;
453 struct cleanup
*old_chain
;
455 /* Fill out a varobj structure for the (root) variable being constructed. */
456 var
= new_root_variable ();
457 old_chain
= make_cleanup_free_variable (var
);
459 if (expression
!= NULL
)
462 enum varobj_languages lang
;
463 struct value
*value
= NULL
;
465 /* Parse and evaluate the expression, filling in as much of the
466 variable's data as possible. */
468 if (has_stack_frames ())
470 /* Allow creator to specify context of variable */
471 if ((type
== USE_CURRENT_FRAME
) || (type
== USE_SELECTED_FRAME
))
472 fi
= get_selected_frame (NULL
);
474 /* FIXME: cagney/2002-11-23: This code should be doing a
475 lookup using the frame ID and not just the frame's
476 ``address''. This, of course, means an interface
477 change. However, with out that interface change ISAs,
478 such as the ia64 with its two stacks, won't work.
479 Similar goes for the case where there is a frameless
481 fi
= find_frame_addr_in_frame_chain (frame
);
486 /* frame = -2 means always use selected frame */
487 if (type
== USE_SELECTED_FRAME
)
488 var
->root
->floating
= 1;
492 block
= get_frame_block (fi
, 0);
495 innermost_block
= NULL
;
496 /* Wrap the call to parse expression, so we can
497 return a sensible error. */
498 if (!gdb_parse_exp_1 (&p
, block
, 0, &var
->root
->exp
))
503 /* Don't allow variables to be created for types. */
504 if (var
->root
->exp
->elts
[0].opcode
== OP_TYPE
)
506 do_cleanups (old_chain
);
507 fprintf_unfiltered (gdb_stderr
, "Attempt to use a type name"
508 " as an expression.\n");
512 var
->format
= variable_default_display (var
);
513 var
->root
->valid_block
= innermost_block
;
514 var
->name
= xstrdup (expression
);
515 /* For a root var, the name and the expr are the same. */
516 var
->path_expr
= xstrdup (expression
);
518 /* When the frame is different from the current frame,
519 we must select the appropriate frame before parsing
520 the expression, otherwise the value will not be current.
521 Since select_frame is so benign, just call it for all cases. */
522 if (innermost_block
&& fi
!= NULL
)
524 var
->root
->frame
= get_frame_id (fi
);
525 var
->root
->thread_id
= pid_to_thread_id (inferior_ptid
);
526 old_fi
= get_selected_frame (NULL
);
530 /* We definitely need to catch errors here.
531 If evaluate_expression succeeds we got the value we wanted.
532 But if it fails, we still go on with a call to evaluate_type() */
533 if (!gdb_evaluate_expression (var
->root
->exp
, &value
))
535 /* Error getting the value. Try to at least get the
537 struct value
*type_only_value
= evaluate_type (var
->root
->exp
);
538 var
->type
= value_type (type_only_value
);
541 var
->type
= value_type (value
);
543 install_new_value (var
, value
, 1 /* Initial assignment */);
545 /* Set language info */
546 lang
= variable_language (var
);
547 var
->root
->lang
= &languages
[lang
];
549 /* Set ourselves as our root */
550 var
->root
->rootvar
= var
;
552 /* Reset the selected frame */
554 select_frame (old_fi
);
557 /* If the variable object name is null, that means this
558 is a temporary variable, so don't install it. */
560 if ((var
!= NULL
) && (objname
!= NULL
))
562 var
->obj_name
= xstrdup (objname
);
564 /* If a varobj name is duplicated, the install will fail so
566 if (!install_variable (var
))
568 do_cleanups (old_chain
);
573 discard_cleanups (old_chain
);
577 /* Generates an unique name that can be used for a varobj */
580 varobj_gen_name (void)
585 /* generate a name for this object */
587 obj_name
= xstrprintf ("var%d", id
);
592 /* Given an OBJNAME, returns the pointer to the corresponding varobj. Call
593 error if OBJNAME cannot be found. */
596 varobj_get_handle (char *objname
)
600 unsigned int index
= 0;
603 for (chp
= objname
; *chp
; chp
++)
605 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
608 cv
= *(varobj_table
+ index
);
609 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, objname
) != 0))
613 error (_("Variable object not found"));
618 /* Given the handle, return the name of the object */
621 varobj_get_objname (struct varobj
*var
)
623 return var
->obj_name
;
626 /* Given the handle, return the expression represented by the object */
629 varobj_get_expression (struct varobj
*var
)
631 return name_of_variable (var
);
634 /* Deletes a varobj and all its children if only_children == 0,
635 otherwise deletes only the children; returns a malloc'ed list of all the
636 (malloc'ed) names of the variables that have been deleted (NULL terminated) */
639 varobj_delete (struct varobj
*var
, char ***dellist
, int only_children
)
643 struct cpstack
*result
= NULL
;
646 /* Initialize a stack for temporary results */
647 cppush (&result
, NULL
);
650 /* Delete only the variable children */
651 delcount
= delete_variable (&result
, var
, 1 /* only the children */ );
653 /* Delete the variable and all its children */
654 delcount
= delete_variable (&result
, var
, 0 /* parent+children */ );
656 /* We may have been asked to return a list of what has been deleted */
659 *dellist
= xmalloc ((delcount
+ 1) * sizeof (char *));
663 *cp
= cppop (&result
);
664 while ((*cp
!= NULL
) && (mycount
> 0))
668 *cp
= cppop (&result
);
671 if (mycount
|| (*cp
!= NULL
))
672 warning (_("varobj_delete: assertion failed - mycount(=%d) <> 0"),
679 /* Set/Get variable object display format */
681 enum varobj_display_formats
682 varobj_set_display_format (struct varobj
*var
,
683 enum varobj_display_formats format
)
690 case FORMAT_HEXADECIMAL
:
692 var
->format
= format
;
696 var
->format
= variable_default_display (var
);
699 if (varobj_value_is_changeable_p (var
)
700 && var
->value
&& !value_lazy (var
->value
))
702 xfree (var
->print_value
);
703 var
->print_value
= value_get_print_value (var
->value
, var
->format
);
709 enum varobj_display_formats
710 varobj_get_display_format (struct varobj
*var
)
715 /* If the variable object is bound to a specific thread, that
716 is its evaluation can always be done in context of a frame
717 inside that thread, returns GDB id of the thread -- which
718 is always positive. Otherwise, returns -1. */
720 varobj_get_thread_id (struct varobj
*var
)
722 if (var
->root
->valid_block
&& var
->root
->thread_id
> 0)
723 return var
->root
->thread_id
;
729 varobj_set_frozen (struct varobj
*var
, int frozen
)
731 /* When a variable is unfrozen, we don't fetch its value.
732 The 'not_fetched' flag remains set, so next -var-update
735 We don't fetch the value, because for structures the client
736 should do -var-update anyway. It would be bad to have different
737 client-size logic for structure and other types. */
738 var
->frozen
= frozen
;
742 varobj_get_frozen (struct varobj
*var
)
749 varobj_get_num_children (struct varobj
*var
)
751 if (var
->num_children
== -1)
752 var
->num_children
= number_of_children (var
);
754 return var
->num_children
;
757 /* Creates a list of the immediate children of a variable object;
758 the return code is the number of such children or -1 on error */
761 varobj_list_children (struct varobj
*var
)
763 struct varobj
*child
;
767 if (var
->num_children
== -1)
768 var
->num_children
= number_of_children (var
);
770 /* If that failed, give up. */
771 if (var
->num_children
== -1)
772 return var
->children
;
774 /* If we're called when the list of children is not yet initialized,
775 allocate enough elements in it. */
776 while (VEC_length (varobj_p
, var
->children
) < var
->num_children
)
777 VEC_safe_push (varobj_p
, var
->children
, NULL
);
779 for (i
= 0; i
< var
->num_children
; i
++)
781 varobj_p existing
= VEC_index (varobj_p
, var
->children
, i
);
783 if (existing
== NULL
)
785 /* Either it's the first call to varobj_list_children for
786 this variable object, and the child was never created,
787 or it was explicitly deleted by the client. */
788 name
= name_of_child (var
, i
);
789 existing
= create_child (var
, i
, name
);
790 VEC_replace (varobj_p
, var
->children
, i
, existing
);
794 return var
->children
;
797 /* Obtain the type of an object Variable as a string similar to the one gdb
798 prints on the console */
801 varobj_get_type (struct varobj
*var
)
804 struct cleanup
*old_chain
;
809 /* For the "fake" variables, do not return a type. (It's type is
811 Do not return a type for invalid variables as well. */
812 if (CPLUS_FAKE_CHILD (var
) || !var
->root
->is_valid
)
815 stb
= mem_fileopen ();
816 old_chain
= make_cleanup_ui_file_delete (stb
);
818 /* To print the type, we simply create a zero ``struct value *'' and
819 cast it to our type. We then typeprint this variable. */
820 val
= value_zero (var
->type
, not_lval
);
821 type_print (value_type (val
), "", stb
, -1);
823 thetype
= ui_file_xstrdup (stb
, &length
);
824 do_cleanups (old_chain
);
828 /* Obtain the type of an object variable. */
831 varobj_get_gdb_type (struct varobj
*var
)
836 /* Return a pointer to the full rooted expression of varobj VAR.
837 If it has not been computed yet, compute it. */
839 varobj_get_path_expr (struct varobj
*var
)
841 if (var
->path_expr
!= NULL
)
842 return var
->path_expr
;
845 /* For root varobjs, we initialize path_expr
846 when creating varobj, so here it should be
848 gdb_assert (!is_root_p (var
));
849 return (*var
->root
->lang
->path_expr_of_child
) (var
);
853 enum varobj_languages
854 varobj_get_language (struct varobj
*var
)
856 return variable_language (var
);
860 varobj_get_attributes (struct varobj
*var
)
864 if (varobj_editable_p (var
))
865 /* FIXME: define masks for attributes */
866 attributes
|= 0x00000001; /* Editable */
872 varobj_get_formatted_value (struct varobj
*var
,
873 enum varobj_display_formats format
)
875 return my_value_of_variable (var
, format
);
879 varobj_get_value (struct varobj
*var
)
881 return my_value_of_variable (var
, var
->format
);
884 /* Set the value of an object variable (if it is editable) to the
885 value of the given expression */
886 /* Note: Invokes functions that can call error() */
889 varobj_set_value (struct varobj
*var
, char *expression
)
895 /* The argument "expression" contains the variable's new value.
896 We need to first construct a legal expression for this -- ugh! */
897 /* Does this cover all the bases? */
898 struct expression
*exp
;
900 int saved_input_radix
= input_radix
;
901 char *s
= expression
;
904 gdb_assert (varobj_editable_p (var
));
906 input_radix
= 10; /* ALWAYS reset to decimal temporarily */
907 exp
= parse_exp_1 (&s
, 0, 0);
908 if (!gdb_evaluate_expression (exp
, &value
))
910 /* We cannot proceed without a valid expression. */
915 /* All types that are editable must also be changeable. */
916 gdb_assert (varobj_value_is_changeable_p (var
));
918 /* The value of a changeable variable object must not be lazy. */
919 gdb_assert (!value_lazy (var
->value
));
921 /* Need to coerce the input. We want to check if the
922 value of the variable object will be different
923 after assignment, and the first thing value_assign
924 does is coerce the input.
925 For example, if we are assigning an array to a pointer variable we
926 should compare the pointer with the the array's address, not with the
928 value
= coerce_array (value
);
930 /* The new value may be lazy. gdb_value_assign, or
931 rather value_contents, will take care of this.
932 If fetching of the new value will fail, gdb_value_assign
933 with catch the exception. */
934 if (!gdb_value_assign (var
->value
, value
, &val
))
937 /* If the value has changed, record it, so that next -var-update can
938 report this change. If a variable had a value of '1', we've set it
939 to '333' and then set again to '1', when -var-update will report this
940 variable as changed -- because the first assignment has set the
941 'updated' flag. There's no need to optimize that, because return value
942 of -var-update should be considered an approximation. */
943 var
->updated
= install_new_value (var
, val
, 0 /* Compare values. */);
944 input_radix
= saved_input_radix
;
948 /* Returns a malloc'ed list with all root variable objects */
950 varobj_list (struct varobj
***varlist
)
953 struct varobj_root
*croot
;
954 int mycount
= rootcount
;
956 /* Alloc (rootcount + 1) entries for the result */
957 *varlist
= xmalloc ((rootcount
+ 1) * sizeof (struct varobj
*));
961 while ((croot
!= NULL
) && (mycount
> 0))
963 *cv
= croot
->rootvar
;
968 /* Mark the end of the list */
971 if (mycount
|| (croot
!= NULL
))
973 ("varobj_list: assertion failed - wrong tally of root vars (%d:%d)",
979 /* Assign a new value to a variable object. If INITIAL is non-zero,
980 this is the first assignement after the variable object was just
981 created, or changed type. In that case, just assign the value
983 Otherwise, assign the new value, and return 1 if the value is different
984 from the current one, 0 otherwise. The comparison is done on textual
985 representation of value. Therefore, some types need not be compared. E.g.
986 for structures the reported value is always "{...}", so no comparison is
987 necessary here. If the old value was NULL and new one is not, or vice versa,
990 The VALUE parameter should not be released -- the function will
991 take care of releasing it when needed. */
993 install_new_value (struct varobj
*var
, struct value
*value
, int initial
)
998 int intentionally_not_fetched
= 0;
999 char *print_value
= NULL
;
1001 /* We need to know the varobj's type to decide if the value should
1002 be fetched or not. C++ fake children (public/protected/private) don't have
1004 gdb_assert (var
->type
|| CPLUS_FAKE_CHILD (var
));
1005 changeable
= varobj_value_is_changeable_p (var
);
1006 need_to_fetch
= changeable
;
1008 /* We are not interested in the address of references, and given
1009 that in C++ a reference is not rebindable, it cannot
1010 meaningfully change. So, get hold of the real value. */
1013 value
= coerce_ref (value
);
1014 release_value (value
);
1017 if (var
->type
&& TYPE_CODE (var
->type
) == TYPE_CODE_UNION
)
1018 /* For unions, we need to fetch the value implicitly because
1019 of implementation of union member fetch. When gdb
1020 creates a value for a field and the value of the enclosing
1021 structure is not lazy, it immediately copies the necessary
1022 bytes from the enclosing values. If the enclosing value is
1023 lazy, the call to value_fetch_lazy on the field will read
1024 the data from memory. For unions, that means we'll read the
1025 same memory more than once, which is not desirable. So
1029 /* The new value might be lazy. If the type is changeable,
1030 that is we'll be comparing values of this type, fetch the
1031 value now. Otherwise, on the next update the old value
1032 will be lazy, which means we've lost that old value. */
1033 if (need_to_fetch
&& value
&& value_lazy (value
))
1035 struct varobj
*parent
= var
->parent
;
1036 int frozen
= var
->frozen
;
1037 for (; !frozen
&& parent
; parent
= parent
->parent
)
1038 frozen
|= parent
->frozen
;
1040 if (frozen
&& initial
)
1042 /* For variables that are frozen, or are children of frozen
1043 variables, we don't do fetch on initial assignment.
1044 For non-initial assignemnt we do the fetch, since it means we're
1045 explicitly asked to compare the new value with the old one. */
1046 intentionally_not_fetched
= 1;
1048 else if (!gdb_value_fetch_lazy (value
))
1050 /* Set the value to NULL, so that for the next -var-update,
1051 we don't try to compare the new value with this value,
1052 that we couldn't even read. */
1057 /* Below, we'll be comparing string rendering of old and new
1058 values. Don't get string rendering if the value is
1059 lazy -- if it is, the code above has decided that the value
1060 should not be fetched. */
1061 if (value
&& !value_lazy (value
))
1062 print_value
= value_get_print_value (value
, var
->format
);
1064 /* If the type is changeable, compare the old and the new values.
1065 If this is the initial assignment, we don't have any old value
1067 if (!initial
&& changeable
)
1069 /* If the value of the varobj was changed by -var-set-value, then the
1070 value in the varobj and in the target is the same. However, that value
1071 is different from the value that the varobj had after the previous
1072 -var-update. So need to the varobj as changed. */
1079 /* Try to compare the values. That requires that both
1080 values are non-lazy. */
1081 if (var
->not_fetched
&& value_lazy (var
->value
))
1083 /* This is a frozen varobj and the value was never read.
1084 Presumably, UI shows some "never read" indicator.
1085 Now that we've fetched the real value, we need to report
1086 this varobj as changed so that UI can show the real
1090 else if (var
->value
== NULL
&& value
== NULL
)
1093 else if (var
->value
== NULL
|| value
== NULL
)
1099 gdb_assert (!value_lazy (var
->value
));
1100 gdb_assert (!value_lazy (value
));
1102 gdb_assert (var
->print_value
!= NULL
&& print_value
!= NULL
);
1103 if (strcmp (var
->print_value
, print_value
) != 0)
1109 if (!initial
&& !changeable
)
1111 /* For values that are not changeable, we don't compare the values.
1112 However, we want to notice if a value was not NULL and now is NULL,
1113 or vise versa, so that we report when top-level varobjs come in scope
1114 and leave the scope. */
1115 changed
= (var
->value
!= NULL
) != (value
!= NULL
);
1118 /* We must always keep the new value, since children depend on it. */
1119 if (var
->value
!= NULL
&& var
->value
!= value
)
1120 value_free (var
->value
);
1122 if (var
->print_value
)
1123 xfree (var
->print_value
);
1124 var
->print_value
= print_value
;
1125 if (value
&& value_lazy (value
) && intentionally_not_fetched
)
1126 var
->not_fetched
= 1;
1128 var
->not_fetched
= 0;
1131 gdb_assert (!var
->value
|| value_type (var
->value
));
1136 /* Update the values for a variable and its children. This is a
1137 two-pronged attack. First, re-parse the value for the root's
1138 expression to see if it's changed. Then go all the way
1139 through its children, reconstructing them and noting if they've
1142 The EXPLICIT parameter specifies if this call is result
1143 of MI request to update this specific variable, or
1144 result of implicit -var-update *. For implicit request, we don't
1145 update frozen variables.
1147 NOTE: This function may delete the caller's varobj. If it
1148 returns TYPE_CHANGED, then it has done this and VARP will be modified
1149 to point to the new varobj. */
1151 VEC(varobj_update_result
) *varobj_update (struct varobj
**varp
, int explicit)
1154 int type_changed
= 0;
1159 struct varobj
**templist
= NULL
;
1161 VEC (varobj_p
) *stack
= NULL
;
1162 VEC (varobj_update_result
) *result
= NULL
;
1163 struct frame_info
*fi
;
1165 /* Frozen means frozen -- we don't check for any change in
1166 this varobj, including its going out of scope, or
1167 changing type. One use case for frozen varobjs is
1168 retaining previously evaluated expressions, and we don't
1169 want them to be reevaluated at all. */
1170 if (!explicit && (*varp
)->frozen
)
1173 if (!(*varp
)->root
->is_valid
)
1175 varobj_update_result r
= {*varp
};
1176 r
.status
= VAROBJ_INVALID
;
1177 VEC_safe_push (varobj_update_result
, result
, &r
);
1181 if ((*varp
)->root
->rootvar
== *varp
)
1183 varobj_update_result r
= {*varp
};
1184 r
.status
= VAROBJ_IN_SCOPE
;
1186 /* Update the root variable. value_of_root can return NULL
1187 if the variable is no longer around, i.e. we stepped out of
1188 the frame in which a local existed. We are letting the
1189 value_of_root variable dispose of the varobj if the type
1191 new = value_of_root (varp
, &type_changed
);
1194 r
.type_changed
= type_changed
;
1195 if (install_new_value ((*varp
), new, type_changed
))
1199 r
.status
= VAROBJ_NOT_IN_SCOPE
;
1201 if (r
.type_changed
|| r
.changed
)
1202 VEC_safe_push (varobj_update_result
, result
, &r
);
1204 if (r
.status
== VAROBJ_NOT_IN_SCOPE
)
1208 VEC_safe_push (varobj_p
, stack
, *varp
);
1210 /* Walk through the children, reconstructing them all. */
1211 while (!VEC_empty (varobj_p
, stack
))
1213 v
= VEC_pop (varobj_p
, stack
);
1215 /* Push any children. Use reverse order so that the first
1216 child is popped from the work stack first, and so
1217 will be added to result first. This does not
1218 affect correctness, just "nicer". */
1219 for (i
= VEC_length (varobj_p
, v
->children
)-1; i
>= 0; --i
)
1221 varobj_p c
= VEC_index (varobj_p
, v
->children
, i
);
1222 /* Child may be NULL if explicitly deleted by -var-delete. */
1223 if (c
!= NULL
&& !c
->frozen
)
1224 VEC_safe_push (varobj_p
, stack
, c
);
1227 /* Update this variable, unless it's a root, which is already
1229 if (v
->root
->rootvar
!= v
)
1231 new = value_of_child (v
->parent
, v
->index
);
1232 if (install_new_value (v
, new, 0 /* type not changed */))
1234 /* Note that it's changed */
1235 varobj_update_result r
= {v
};
1237 VEC_safe_push (varobj_update_result
, result
, &r
);
1243 VEC_free (varobj_p
, stack
);
1248 /* Helper functions */
1251 * Variable object construction/destruction
1255 delete_variable (struct cpstack
**resultp
, struct varobj
*var
,
1256 int only_children_p
)
1260 delete_variable_1 (resultp
, &delcount
, var
,
1261 only_children_p
, 1 /* remove_from_parent_p */ );
1266 /* Delete the variable object VAR and its children */
1267 /* IMPORTANT NOTE: If we delete a variable which is a child
1268 and the parent is not removed we dump core. It must be always
1269 initially called with remove_from_parent_p set */
1271 delete_variable_1 (struct cpstack
**resultp
, int *delcountp
,
1272 struct varobj
*var
, int only_children_p
,
1273 int remove_from_parent_p
)
1277 /* Delete any children of this variable, too. */
1278 for (i
= 0; i
< VEC_length (varobj_p
, var
->children
); ++i
)
1280 varobj_p child
= VEC_index (varobj_p
, var
->children
, i
);
1283 if (!remove_from_parent_p
)
1284 child
->parent
= NULL
;
1285 delete_variable_1 (resultp
, delcountp
, child
, 0, only_children_p
);
1287 VEC_free (varobj_p
, var
->children
);
1289 /* if we were called to delete only the children we are done here */
1290 if (only_children_p
)
1293 /* Otherwise, add it to the list of deleted ones and proceed to do so */
1294 /* If the name is null, this is a temporary variable, that has not
1295 yet been installed, don't report it, it belongs to the caller... */
1296 if (var
->obj_name
!= NULL
)
1298 cppush (resultp
, xstrdup (var
->obj_name
));
1299 *delcountp
= *delcountp
+ 1;
1302 /* If this variable has a parent, remove it from its parent's list */
1303 /* OPTIMIZATION: if the parent of this variable is also being deleted,
1304 (as indicated by remove_from_parent_p) we don't bother doing an
1305 expensive list search to find the element to remove when we are
1306 discarding the list afterwards */
1307 if ((remove_from_parent_p
) && (var
->parent
!= NULL
))
1309 VEC_replace (varobj_p
, var
->parent
->children
, var
->index
, NULL
);
1312 if (var
->obj_name
!= NULL
)
1313 uninstall_variable (var
);
1315 /* Free memory associated with this variable */
1316 free_variable (var
);
1319 /* Install the given variable VAR with the object name VAR->OBJ_NAME. */
1321 install_variable (struct varobj
*var
)
1324 struct vlist
*newvl
;
1326 unsigned int index
= 0;
1329 for (chp
= var
->obj_name
; *chp
; chp
++)
1331 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
1334 cv
= *(varobj_table
+ index
);
1335 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, var
->obj_name
) != 0))
1339 error (_("Duplicate variable object name"));
1341 /* Add varobj to hash table */
1342 newvl
= xmalloc (sizeof (struct vlist
));
1343 newvl
->next
= *(varobj_table
+ index
);
1345 *(varobj_table
+ index
) = newvl
;
1347 /* If root, add varobj to root list */
1348 if (is_root_p (var
))
1350 /* Add to list of root variables */
1351 if (rootlist
== NULL
)
1352 var
->root
->next
= NULL
;
1354 var
->root
->next
= rootlist
;
1355 rootlist
= var
->root
;
1362 /* Unistall the object VAR. */
1364 uninstall_variable (struct varobj
*var
)
1368 struct varobj_root
*cr
;
1369 struct varobj_root
*prer
;
1371 unsigned int index
= 0;
1374 /* Remove varobj from hash table */
1375 for (chp
= var
->obj_name
; *chp
; chp
++)
1377 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
1380 cv
= *(varobj_table
+ index
);
1382 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, var
->obj_name
) != 0))
1389 fprintf_unfiltered (gdb_stdlog
, "Deleting %s\n", var
->obj_name
);
1394 ("Assertion failed: Could not find variable object \"%s\" to delete",
1400 *(varobj_table
+ index
) = cv
->next
;
1402 prev
->next
= cv
->next
;
1406 /* If root, remove varobj from root list */
1407 if (is_root_p (var
))
1409 /* Remove from list of root variables */
1410 if (rootlist
== var
->root
)
1411 rootlist
= var
->root
->next
;
1416 while ((cr
!= NULL
) && (cr
->rootvar
!= var
))
1424 ("Assertion failed: Could not find varobj \"%s\" in root list",
1431 prer
->next
= cr
->next
;
1438 /* Create and install a child of the parent of the given name */
1439 static struct varobj
*
1440 create_child (struct varobj
*parent
, int index
, char *name
)
1442 struct varobj
*child
;
1444 struct value
*value
;
1446 child
= new_variable ();
1448 /* name is allocated by name_of_child */
1450 child
->index
= index
;
1451 value
= value_of_child (parent
, index
);
1452 child
->parent
= parent
;
1453 child
->root
= parent
->root
;
1454 childs_name
= xstrprintf ("%s.%s", parent
->obj_name
, name
);
1455 child
->obj_name
= childs_name
;
1456 install_variable (child
);
1458 /* Compute the type of the child. Must do this before
1459 calling install_new_value. */
1461 /* If the child had no evaluation errors, var->value
1462 will be non-NULL and contain a valid type. */
1463 child
->type
= value_type (value
);
1465 /* Otherwise, we must compute the type. */
1466 child
->type
= (*child
->root
->lang
->type_of_child
) (child
->parent
,
1468 install_new_value (child
, value
, 1);
1475 * Miscellaneous utility functions.
1478 /* Allocate memory and initialize a new variable */
1479 static struct varobj
*
1484 var
= (struct varobj
*) xmalloc (sizeof (struct varobj
));
1486 var
->path_expr
= NULL
;
1487 var
->obj_name
= NULL
;
1491 var
->num_children
= -1;
1493 var
->children
= NULL
;
1497 var
->print_value
= NULL
;
1499 var
->not_fetched
= 0;
1504 /* Allocate memory and initialize a new root variable */
1505 static struct varobj
*
1506 new_root_variable (void)
1508 struct varobj
*var
= new_variable ();
1509 var
->root
= (struct varobj_root
*) xmalloc (sizeof (struct varobj_root
));;
1510 var
->root
->lang
= NULL
;
1511 var
->root
->exp
= NULL
;
1512 var
->root
->valid_block
= NULL
;
1513 var
->root
->frame
= null_frame_id
;
1514 var
->root
->floating
= 0;
1515 var
->root
->rootvar
= NULL
;
1516 var
->root
->is_valid
= 1;
1521 /* Free any allocated memory associated with VAR. */
1523 free_variable (struct varobj
*var
)
1525 value_free (var
->value
);
1527 /* Free the expression if this is a root variable. */
1528 if (is_root_p (var
))
1530 xfree (var
->root
->exp
);
1535 xfree (var
->obj_name
);
1536 xfree (var
->print_value
);
1537 xfree (var
->path_expr
);
1542 do_free_variable_cleanup (void *var
)
1544 free_variable (var
);
1547 static struct cleanup
*
1548 make_cleanup_free_variable (struct varobj
*var
)
1550 return make_cleanup (do_free_variable_cleanup
, var
);
1553 /* This returns the type of the variable. It also skips past typedefs
1554 to return the real type of the variable.
1556 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
1557 except within get_target_type and get_type. */
1558 static struct type
*
1559 get_type (struct varobj
*var
)
1565 type
= check_typedef (type
);
1570 /* Return the type of the value that's stored in VAR,
1571 or that would have being stored there if the
1572 value were accessible.
1574 This differs from VAR->type in that VAR->type is always
1575 the true type of the expession in the source language.
1576 The return value of this function is the type we're
1577 actually storing in varobj, and using for displaying
1578 the values and for comparing previous and new values.
1580 For example, top-level references are always stripped. */
1581 static struct type
*
1582 get_value_type (struct varobj
*var
)
1587 type
= value_type (var
->value
);
1591 type
= check_typedef (type
);
1593 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
1594 type
= get_target_type (type
);
1596 type
= check_typedef (type
);
1601 /* This returns the target type (or NULL) of TYPE, also skipping
1602 past typedefs, just like get_type ().
1604 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
1605 except within get_target_type and get_type. */
1606 static struct type
*
1607 get_target_type (struct type
*type
)
1611 type
= TYPE_TARGET_TYPE (type
);
1613 type
= check_typedef (type
);
1619 /* What is the default display for this variable? We assume that
1620 everything is "natural". Any exceptions? */
1621 static enum varobj_display_formats
1622 variable_default_display (struct varobj
*var
)
1624 return FORMAT_NATURAL
;
1627 /* FIXME: The following should be generic for any pointer */
1629 cppush (struct cpstack
**pstack
, char *name
)
1633 s
= (struct cpstack
*) xmalloc (sizeof (struct cpstack
));
1639 /* FIXME: The following should be generic for any pointer */
1641 cppop (struct cpstack
**pstack
)
1646 if ((*pstack
)->name
== NULL
&& (*pstack
)->next
== NULL
)
1651 *pstack
= (*pstack
)->next
;
1658 * Language-dependencies
1661 /* Common entry points */
1663 /* Get the language of variable VAR. */
1664 static enum varobj_languages
1665 variable_language (struct varobj
*var
)
1667 enum varobj_languages lang
;
1669 switch (var
->root
->exp
->language_defn
->la_language
)
1675 case language_cplus
:
1686 /* Return the number of children for a given variable.
1687 The result of this function is defined by the language
1688 implementation. The number of children returned by this function
1689 is the number of children that the user will see in the variable
1692 number_of_children (struct varobj
*var
)
1694 return (*var
->root
->lang
->number_of_children
) (var
);;
1697 /* What is the expression for the root varobj VAR? Returns a malloc'd string. */
1699 name_of_variable (struct varobj
*var
)
1701 return (*var
->root
->lang
->name_of_variable
) (var
);
1704 /* What is the name of the INDEX'th child of VAR? Returns a malloc'd string. */
1706 name_of_child (struct varobj
*var
, int index
)
1708 return (*var
->root
->lang
->name_of_child
) (var
, index
);
1711 /* What is the ``struct value *'' of the root variable VAR?
1712 For floating variable object, evaluation can get us a value
1713 of different type from what is stored in varobj already. In
1715 - *type_changed will be set to 1
1716 - old varobj will be freed, and new one will be
1717 created, with the same name.
1718 - *var_handle will be set to the new varobj
1719 Otherwise, *type_changed will be set to 0. */
1720 static struct value
*
1721 value_of_root (struct varobj
**var_handle
, int *type_changed
)
1725 if (var_handle
== NULL
)
1730 /* This should really be an exception, since this should
1731 only get called with a root variable. */
1733 if (!is_root_p (var
))
1736 if (var
->root
->floating
)
1738 struct varobj
*tmp_var
;
1739 char *old_type
, *new_type
;
1741 tmp_var
= varobj_create (NULL
, var
->name
, (CORE_ADDR
) 0,
1742 USE_SELECTED_FRAME
);
1743 if (tmp_var
== NULL
)
1747 old_type
= varobj_get_type (var
);
1748 new_type
= varobj_get_type (tmp_var
);
1749 if (strcmp (old_type
, new_type
) == 0)
1751 /* The expression presently stored inside var->root->exp
1752 remembers the locations of local variables relatively to
1753 the frame where the expression was created (in DWARF location
1754 button, for example). Naturally, those locations are not
1755 correct in other frames, so update the expression. */
1757 struct expression
*tmp_exp
= var
->root
->exp
;
1758 var
->root
->exp
= tmp_var
->root
->exp
;
1759 tmp_var
->root
->exp
= tmp_exp
;
1761 varobj_delete (tmp_var
, NULL
, 0);
1766 tmp_var
->obj_name
= xstrdup (var
->obj_name
);
1767 varobj_delete (var
, NULL
, 0);
1769 install_variable (tmp_var
);
1770 *var_handle
= tmp_var
;
1782 return (*var
->root
->lang
->value_of_root
) (var_handle
);
1785 /* What is the ``struct value *'' for the INDEX'th child of PARENT? */
1786 static struct value
*
1787 value_of_child (struct varobj
*parent
, int index
)
1789 struct value
*value
;
1791 value
= (*parent
->root
->lang
->value_of_child
) (parent
, index
);
1796 /* GDB already has a command called "value_of_variable". Sigh. */
1798 my_value_of_variable (struct varobj
*var
, enum varobj_display_formats format
)
1800 if (var
->root
->is_valid
)
1801 return (*var
->root
->lang
->value_of_variable
) (var
, format
);
1807 value_get_print_value (struct value
*value
, enum varobj_display_formats format
)
1810 struct ui_file
*stb
;
1811 struct cleanup
*old_chain
;
1813 struct value_print_options opts
;
1818 stb
= mem_fileopen ();
1819 old_chain
= make_cleanup_ui_file_delete (stb
);
1821 get_formatted_print_options (&opts
, format_code
[(int) format
]);
1823 common_val_print (value
, stb
, 0, &opts
, current_language
);
1824 thevalue
= ui_file_xstrdup (stb
, &dummy
);
1826 do_cleanups (old_chain
);
1831 varobj_editable_p (struct varobj
*var
)
1834 struct value
*value
;
1836 if (!(var
->root
->is_valid
&& var
->value
&& VALUE_LVAL (var
->value
)))
1839 type
= get_value_type (var
);
1841 switch (TYPE_CODE (type
))
1843 case TYPE_CODE_STRUCT
:
1844 case TYPE_CODE_UNION
:
1845 case TYPE_CODE_ARRAY
:
1846 case TYPE_CODE_FUNC
:
1847 case TYPE_CODE_METHOD
:
1857 /* Return non-zero if changes in value of VAR
1858 must be detected and reported by -var-update.
1859 Return zero is -var-update should never report
1860 changes of such values. This makes sense for structures
1861 (since the changes in children values will be reported separately),
1862 or for artifical objects (like 'public' pseudo-field in C++).
1864 Return value of 0 means that gdb need not call value_fetch_lazy
1865 for the value of this variable object. */
1867 varobj_value_is_changeable_p (struct varobj
*var
)
1872 if (CPLUS_FAKE_CHILD (var
))
1875 type
= get_value_type (var
);
1877 switch (TYPE_CODE (type
))
1879 case TYPE_CODE_STRUCT
:
1880 case TYPE_CODE_UNION
:
1881 case TYPE_CODE_ARRAY
:
1892 /* Return 1 if that varobj is floating, that is is always evaluated in the
1893 selected frame, and not bound to thread/frame. Such variable objects
1894 are created using '@' as frame specifier to -var-create. */
1896 varobj_floating_p (struct varobj
*var
)
1898 return var
->root
->floating
;
1901 /* Given the value and the type of a variable object,
1902 adjust the value and type to those necessary
1903 for getting children of the variable object.
1904 This includes dereferencing top-level references
1905 to all types and dereferencing pointers to
1908 Both TYPE and *TYPE should be non-null. VALUE
1909 can be null if we want to only translate type.
1910 *VALUE can be null as well -- if the parent
1913 If WAS_PTR is not NULL, set *WAS_PTR to 0 or 1
1914 depending on whether pointer was deferenced
1915 in this function. */
1917 adjust_value_for_child_access (struct value
**value
,
1921 gdb_assert (type
&& *type
);
1926 *type
= check_typedef (*type
);
1928 /* The type of value stored in varobj, that is passed
1929 to us, is already supposed to be
1930 reference-stripped. */
1932 gdb_assert (TYPE_CODE (*type
) != TYPE_CODE_REF
);
1934 /* Pointers to structures are treated just like
1935 structures when accessing children. Don't
1936 dererences pointers to other types. */
1937 if (TYPE_CODE (*type
) == TYPE_CODE_PTR
)
1939 struct type
*target_type
= get_target_type (*type
);
1940 if (TYPE_CODE (target_type
) == TYPE_CODE_STRUCT
1941 || TYPE_CODE (target_type
) == TYPE_CODE_UNION
)
1943 if (value
&& *value
)
1945 int success
= gdb_value_ind (*value
, value
);
1949 *type
= target_type
;
1955 /* The 'get_target_type' function calls check_typedef on
1956 result, so we can immediately check type code. No
1957 need to call check_typedef here. */
1962 c_number_of_children (struct varobj
*var
)
1964 struct type
*type
= get_value_type (var
);
1966 struct type
*target
;
1968 adjust_value_for_child_access (NULL
, &type
, NULL
);
1969 target
= get_target_type (type
);
1971 switch (TYPE_CODE (type
))
1973 case TYPE_CODE_ARRAY
:
1974 if (TYPE_LENGTH (type
) > 0 && TYPE_LENGTH (target
) > 0
1975 && !TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type
))
1976 children
= TYPE_LENGTH (type
) / TYPE_LENGTH (target
);
1978 /* If we don't know how many elements there are, don't display
1983 case TYPE_CODE_STRUCT
:
1984 case TYPE_CODE_UNION
:
1985 children
= TYPE_NFIELDS (type
);
1989 /* The type here is a pointer to non-struct. Typically, pointers
1990 have one child, except for function ptrs, which have no children,
1991 and except for void*, as we don't know what to show.
1993 We can show char* so we allow it to be dereferenced. If you decide
1994 to test for it, please mind that a little magic is necessary to
1995 properly identify it: char* has TYPE_CODE == TYPE_CODE_INT and
1996 TYPE_NAME == "char" */
1997 if (TYPE_CODE (target
) == TYPE_CODE_FUNC
1998 || TYPE_CODE (target
) == TYPE_CODE_VOID
)
2005 /* Other types have no children */
2013 c_name_of_variable (struct varobj
*parent
)
2015 return xstrdup (parent
->name
);
2018 /* Return the value of element TYPE_INDEX of a structure
2019 value VALUE. VALUE's type should be a structure,
2020 or union, or a typedef to struct/union.
2022 Returns NULL if getting the value fails. Never throws. */
2023 static struct value
*
2024 value_struct_element_index (struct value
*value
, int type_index
)
2026 struct value
*result
= NULL
;
2027 volatile struct gdb_exception e
;
2029 struct type
*type
= value_type (value
);
2030 type
= check_typedef (type
);
2032 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
2033 || TYPE_CODE (type
) == TYPE_CODE_UNION
);
2035 TRY_CATCH (e
, RETURN_MASK_ERROR
)
2037 if (field_is_static (&TYPE_FIELD (type
, type_index
)))
2038 result
= value_static_field (type
, type_index
);
2040 result
= value_primitive_field (value
, 0, type_index
, type
);
2052 /* Obtain the information about child INDEX of the variable
2054 If CNAME is not null, sets *CNAME to the name of the child relative
2056 If CVALUE is not null, sets *CVALUE to the value of the child.
2057 If CTYPE is not null, sets *CTYPE to the type of the child.
2059 If any of CNAME, CVALUE, or CTYPE is not null, but the corresponding
2060 information cannot be determined, set *CNAME, *CVALUE, or *CTYPE
2063 c_describe_child (struct varobj
*parent
, int index
,
2064 char **cname
, struct value
**cvalue
, struct type
**ctype
,
2065 char **cfull_expression
)
2067 struct value
*value
= parent
->value
;
2068 struct type
*type
= get_value_type (parent
);
2069 char *parent_expression
= NULL
;
2078 if (cfull_expression
)
2080 *cfull_expression
= NULL
;
2081 parent_expression
= varobj_get_path_expr (parent
);
2083 adjust_value_for_child_access (&value
, &type
, &was_ptr
);
2085 switch (TYPE_CODE (type
))
2087 case TYPE_CODE_ARRAY
:
2089 *cname
= xstrprintf ("%d", index
2090 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
)));
2092 if (cvalue
&& value
)
2094 int real_index
= index
+ TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
));
2095 struct value
*indval
=
2096 value_from_longest (builtin_type_int32
, (LONGEST
) real_index
);
2097 gdb_value_subscript (value
, indval
, cvalue
);
2101 *ctype
= get_target_type (type
);
2103 if (cfull_expression
)
2104 *cfull_expression
= xstrprintf ("(%s)[%d]", parent_expression
,
2106 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
)));
2111 case TYPE_CODE_STRUCT
:
2112 case TYPE_CODE_UNION
:
2114 *cname
= xstrdup (TYPE_FIELD_NAME (type
, index
));
2116 if (cvalue
&& value
)
2118 /* For C, varobj index is the same as type index. */
2119 *cvalue
= value_struct_element_index (value
, index
);
2123 *ctype
= TYPE_FIELD_TYPE (type
, index
);
2125 if (cfull_expression
)
2127 char *join
= was_ptr
? "->" : ".";
2128 *cfull_expression
= xstrprintf ("(%s)%s%s", parent_expression
, join
,
2129 TYPE_FIELD_NAME (type
, index
));
2136 *cname
= xstrprintf ("*%s", parent
->name
);
2138 if (cvalue
&& value
)
2140 int success
= gdb_value_ind (value
, cvalue
);
2145 /* Don't use get_target_type because it calls
2146 check_typedef and here, we want to show the true
2147 declared type of the variable. */
2149 *ctype
= TYPE_TARGET_TYPE (type
);
2151 if (cfull_expression
)
2152 *cfull_expression
= xstrprintf ("*(%s)", parent_expression
);
2157 /* This should not happen */
2159 *cname
= xstrdup ("???");
2160 if (cfull_expression
)
2161 *cfull_expression
= xstrdup ("???");
2162 /* Don't set value and type, we don't know then. */
2167 c_name_of_child (struct varobj
*parent
, int index
)
2170 c_describe_child (parent
, index
, &name
, NULL
, NULL
, NULL
);
2175 c_path_expr_of_child (struct varobj
*child
)
2177 c_describe_child (child
->parent
, child
->index
, NULL
, NULL
, NULL
,
2179 return child
->path_expr
;
2182 /* If frame associated with VAR can be found, switch
2183 to it and return 1. Otherwise, return 0. */
2185 check_scope (struct varobj
*var
)
2187 struct frame_info
*fi
;
2190 fi
= frame_find_by_id (var
->root
->frame
);
2195 CORE_ADDR pc
= get_frame_pc (fi
);
2196 if (pc
< BLOCK_START (var
->root
->valid_block
) ||
2197 pc
>= BLOCK_END (var
->root
->valid_block
))
2205 static struct value
*
2206 c_value_of_root (struct varobj
**var_handle
)
2208 struct value
*new_val
= NULL
;
2209 struct varobj
*var
= *var_handle
;
2210 struct frame_info
*fi
;
2211 int within_scope
= 0;
2212 struct cleanup
*back_to
;
2214 /* Only root variables can be updated... */
2215 if (!is_root_p (var
))
2216 /* Not a root var */
2219 back_to
= make_cleanup_restore_current_thread ();
2221 /* Determine whether the variable is still around. */
2222 if (var
->root
->valid_block
== NULL
|| var
->root
->floating
)
2224 else if (var
->root
->thread_id
== 0)
2226 /* The program was single-threaded when the variable object was
2227 created. Technically, it's possible that the program became
2228 multi-threaded since then, but we don't support such
2230 within_scope
= check_scope (var
);
2234 ptid_t ptid
= thread_id_to_pid (var
->root
->thread_id
);
2235 if (in_thread_list (ptid
))
2237 switch_to_thread (ptid
);
2238 within_scope
= check_scope (var
);
2244 /* We need to catch errors here, because if evaluate
2245 expression fails we want to just return NULL. */
2246 gdb_evaluate_expression (var
->root
->exp
, &new_val
);
2250 do_cleanups (back_to
);
2255 static struct value
*
2256 c_value_of_child (struct varobj
*parent
, int index
)
2258 struct value
*value
= NULL
;
2259 c_describe_child (parent
, index
, NULL
, &value
, NULL
, NULL
);
2264 static struct type
*
2265 c_type_of_child (struct varobj
*parent
, int index
)
2267 struct type
*type
= NULL
;
2268 c_describe_child (parent
, index
, NULL
, NULL
, &type
, NULL
);
2273 c_value_of_variable (struct varobj
*var
, enum varobj_display_formats format
)
2275 /* BOGUS: if val_print sees a struct/class, or a reference to one,
2276 it will print out its children instead of "{...}". So we need to
2277 catch that case explicitly. */
2278 struct type
*type
= get_type (var
);
2280 /* Strip top-level references. */
2281 while (TYPE_CODE (type
) == TYPE_CODE_REF
)
2282 type
= check_typedef (TYPE_TARGET_TYPE (type
));
2284 switch (TYPE_CODE (type
))
2286 case TYPE_CODE_STRUCT
:
2287 case TYPE_CODE_UNION
:
2288 return xstrdup ("{...}");
2291 case TYPE_CODE_ARRAY
:
2294 number
= xstrprintf ("[%d]", var
->num_children
);
2301 if (var
->value
== NULL
)
2303 /* This can happen if we attempt to get the value of a struct
2304 member when the parent is an invalid pointer. This is an
2305 error condition, so we should tell the caller. */
2310 if (var
->not_fetched
&& value_lazy (var
->value
))
2311 /* Frozen variable and no value yet. We don't
2312 implicitly fetch the value. MI response will
2313 use empty string for the value, which is OK. */
2316 gdb_assert (varobj_value_is_changeable_p (var
));
2317 gdb_assert (!value_lazy (var
->value
));
2319 /* If the specified format is the current one,
2320 we can reuse print_value */
2321 if (format
== var
->format
)
2322 return xstrdup (var
->print_value
);
2324 return value_get_print_value (var
->value
, format
);
2334 cplus_number_of_children (struct varobj
*var
)
2337 int children
, dont_know
;
2342 if (!CPLUS_FAKE_CHILD (var
))
2344 type
= get_value_type (var
);
2345 adjust_value_for_child_access (NULL
, &type
, NULL
);
2347 if (((TYPE_CODE (type
)) == TYPE_CODE_STRUCT
) ||
2348 ((TYPE_CODE (type
)) == TYPE_CODE_UNION
))
2352 cplus_class_num_children (type
, kids
);
2353 if (kids
[v_public
] != 0)
2355 if (kids
[v_private
] != 0)
2357 if (kids
[v_protected
] != 0)
2360 /* Add any baseclasses */
2361 children
+= TYPE_N_BASECLASSES (type
);
2364 /* FIXME: save children in var */
2371 type
= get_value_type (var
->parent
);
2372 adjust_value_for_child_access (NULL
, &type
, NULL
);
2374 cplus_class_num_children (type
, kids
);
2375 if (strcmp (var
->name
, "public") == 0)
2376 children
= kids
[v_public
];
2377 else if (strcmp (var
->name
, "private") == 0)
2378 children
= kids
[v_private
];
2380 children
= kids
[v_protected
];
2385 children
= c_number_of_children (var
);
2390 /* Compute # of public, private, and protected variables in this class.
2391 That means we need to descend into all baseclasses and find out
2392 how many are there, too. */
2394 cplus_class_num_children (struct type
*type
, int children
[3])
2398 children
[v_public
] = 0;
2399 children
[v_private
] = 0;
2400 children
[v_protected
] = 0;
2402 for (i
= TYPE_N_BASECLASSES (type
); i
< TYPE_NFIELDS (type
); i
++)
2404 /* If we have a virtual table pointer, omit it. */
2405 if (TYPE_VPTR_BASETYPE (type
) == type
&& TYPE_VPTR_FIELDNO (type
) == i
)
2408 if (TYPE_FIELD_PROTECTED (type
, i
))
2409 children
[v_protected
]++;
2410 else if (TYPE_FIELD_PRIVATE (type
, i
))
2411 children
[v_private
]++;
2413 children
[v_public
]++;
2418 cplus_name_of_variable (struct varobj
*parent
)
2420 return c_name_of_variable (parent
);
2423 enum accessibility
{ private_field
, protected_field
, public_field
};
2425 /* Check if field INDEX of TYPE has the specified accessibility.
2426 Return 0 if so and 1 otherwise. */
2428 match_accessibility (struct type
*type
, int index
, enum accessibility acc
)
2430 if (acc
== private_field
&& TYPE_FIELD_PRIVATE (type
, index
))
2432 else if (acc
== protected_field
&& TYPE_FIELD_PROTECTED (type
, index
))
2434 else if (acc
== public_field
&& !TYPE_FIELD_PRIVATE (type
, index
)
2435 && !TYPE_FIELD_PROTECTED (type
, index
))
2442 cplus_describe_child (struct varobj
*parent
, int index
,
2443 char **cname
, struct value
**cvalue
, struct type
**ctype
,
2444 char **cfull_expression
)
2447 struct value
*value
;
2450 char *parent_expression
= NULL
;
2458 if (cfull_expression
)
2459 *cfull_expression
= NULL
;
2461 if (CPLUS_FAKE_CHILD (parent
))
2463 value
= parent
->parent
->value
;
2464 type
= get_value_type (parent
->parent
);
2465 if (cfull_expression
)
2466 parent_expression
= varobj_get_path_expr (parent
->parent
);
2470 value
= parent
->value
;
2471 type
= get_value_type (parent
);
2472 if (cfull_expression
)
2473 parent_expression
= varobj_get_path_expr (parent
);
2476 adjust_value_for_child_access (&value
, &type
, &was_ptr
);
2478 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
2479 || TYPE_CODE (type
) == TYPE_CODE_UNION
)
2481 char *join
= was_ptr
? "->" : ".";
2482 if (CPLUS_FAKE_CHILD (parent
))
2484 /* The fields of the class type are ordered as they
2485 appear in the class. We are given an index for a
2486 particular access control type ("public","protected",
2487 or "private"). We must skip over fields that don't
2488 have the access control we are looking for to properly
2489 find the indexed field. */
2490 int type_index
= TYPE_N_BASECLASSES (type
);
2491 enum accessibility acc
= public_field
;
2492 if (strcmp (parent
->name
, "private") == 0)
2493 acc
= private_field
;
2494 else if (strcmp (parent
->name
, "protected") == 0)
2495 acc
= protected_field
;
2499 if (TYPE_VPTR_BASETYPE (type
) == type
2500 && type_index
== TYPE_VPTR_FIELDNO (type
))
2502 else if (match_accessibility (type
, type_index
, acc
))
2509 *cname
= xstrdup (TYPE_FIELD_NAME (type
, type_index
));
2511 if (cvalue
&& value
)
2512 *cvalue
= value_struct_element_index (value
, type_index
);
2515 *ctype
= TYPE_FIELD_TYPE (type
, type_index
);
2517 if (cfull_expression
)
2518 *cfull_expression
= xstrprintf ("((%s)%s%s)", parent_expression
,
2520 TYPE_FIELD_NAME (type
, type_index
));
2522 else if (index
< TYPE_N_BASECLASSES (type
))
2524 /* This is a baseclass. */
2526 *cname
= xstrdup (TYPE_FIELD_NAME (type
, index
));
2528 if (cvalue
&& value
)
2530 *cvalue
= value_cast (TYPE_FIELD_TYPE (type
, index
), value
);
2531 release_value (*cvalue
);
2536 *ctype
= TYPE_FIELD_TYPE (type
, index
);
2539 if (cfull_expression
)
2541 char *ptr
= was_ptr
? "*" : "";
2542 /* Cast the parent to the base' type. Note that in gdb,
2545 will create an lvalue, for all appearences, so we don't
2546 need to use more fancy:
2549 *cfull_expression
= xstrprintf ("(%s(%s%s) %s)",
2551 TYPE_FIELD_NAME (type
, index
),
2558 char *access
= NULL
;
2560 cplus_class_num_children (type
, children
);
2562 /* Everything beyond the baseclasses can
2563 only be "public", "private", or "protected"
2565 The special "fake" children are always output by varobj in
2566 this order. So if INDEX == 2, it MUST be "protected". */
2567 index
-= TYPE_N_BASECLASSES (type
);
2571 if (children
[v_public
] > 0)
2573 else if (children
[v_private
] > 0)
2576 access
= "protected";
2579 if (children
[v_public
] > 0)
2581 if (children
[v_private
] > 0)
2584 access
= "protected";
2586 else if (children
[v_private
] > 0)
2587 access
= "protected";
2590 /* Must be protected */
2591 access
= "protected";
2598 gdb_assert (access
);
2600 *cname
= xstrdup (access
);
2602 /* Value and type and full expression are null here. */
2607 c_describe_child (parent
, index
, cname
, cvalue
, ctype
, cfull_expression
);
2612 cplus_name_of_child (struct varobj
*parent
, int index
)
2615 cplus_describe_child (parent
, index
, &name
, NULL
, NULL
, NULL
);
2620 cplus_path_expr_of_child (struct varobj
*child
)
2622 cplus_describe_child (child
->parent
, child
->index
, NULL
, NULL
, NULL
,
2624 return child
->path_expr
;
2627 static struct value
*
2628 cplus_value_of_root (struct varobj
**var_handle
)
2630 return c_value_of_root (var_handle
);
2633 static struct value
*
2634 cplus_value_of_child (struct varobj
*parent
, int index
)
2636 struct value
*value
= NULL
;
2637 cplus_describe_child (parent
, index
, NULL
, &value
, NULL
, NULL
);
2641 static struct type
*
2642 cplus_type_of_child (struct varobj
*parent
, int index
)
2644 struct type
*type
= NULL
;
2645 cplus_describe_child (parent
, index
, NULL
, NULL
, &type
, NULL
);
2650 cplus_value_of_variable (struct varobj
*var
, enum varobj_display_formats format
)
2653 /* If we have one of our special types, don't print out
2655 if (CPLUS_FAKE_CHILD (var
))
2656 return xstrdup ("");
2658 return c_value_of_variable (var
, format
);
2664 java_number_of_children (struct varobj
*var
)
2666 return cplus_number_of_children (var
);
2670 java_name_of_variable (struct varobj
*parent
)
2674 name
= cplus_name_of_variable (parent
);
2675 /* If the name has "-" in it, it is because we
2676 needed to escape periods in the name... */
2679 while (*p
!= '\000')
2690 java_name_of_child (struct varobj
*parent
, int index
)
2694 name
= cplus_name_of_child (parent
, index
);
2695 /* Escape any periods in the name... */
2698 while (*p
!= '\000')
2709 java_path_expr_of_child (struct varobj
*child
)
2714 static struct value
*
2715 java_value_of_root (struct varobj
**var_handle
)
2717 return cplus_value_of_root (var_handle
);
2720 static struct value
*
2721 java_value_of_child (struct varobj
*parent
, int index
)
2723 return cplus_value_of_child (parent
, index
);
2726 static struct type
*
2727 java_type_of_child (struct varobj
*parent
, int index
)
2729 return cplus_type_of_child (parent
, index
);
2733 java_value_of_variable (struct varobj
*var
, enum varobj_display_formats format
)
2735 return cplus_value_of_variable (var
, format
);
2738 extern void _initialize_varobj (void);
2740 _initialize_varobj (void)
2742 int sizeof_table
= sizeof (struct vlist
*) * VAROBJ_TABLE_SIZE
;
2744 varobj_table
= xmalloc (sizeof_table
);
2745 memset (varobj_table
, 0, sizeof_table
);
2747 add_setshow_zinteger_cmd ("debugvarobj", class_maintenance
,
2749 Set varobj debugging."), _("\
2750 Show varobj debugging."), _("\
2751 When non-zero, varobj debugging is enabled."),
2754 &setlist
, &showlist
);
2757 /* Invalidate the varobjs that are tied to locals and re-create the ones that
2758 are defined on globals.
2759 Invalidated varobjs will be always printed in_scope="invalid". */
2762 varobj_invalidate (void)
2764 struct varobj
**all_rootvarobj
;
2765 struct varobj
**varp
;
2767 if (varobj_list (&all_rootvarobj
) > 0)
2769 varp
= all_rootvarobj
;
2770 while (*varp
!= NULL
)
2772 /* Floating varobjs are reparsed on each stop, so we don't care if
2773 the presently parsed expression refers to something that's gone.
2775 if ((*varp
)->root
->floating
)
2778 /* global var must be re-evaluated. */
2779 if ((*varp
)->root
->valid_block
== NULL
)
2781 struct varobj
*tmp_var
;
2783 /* Try to create a varobj with same expression. If we succeed
2784 replace the old varobj, otherwise invalidate it. */
2785 tmp_var
= varobj_create (NULL
, (*varp
)->name
, (CORE_ADDR
) 0,
2787 if (tmp_var
!= NULL
)
2789 tmp_var
->obj_name
= xstrdup ((*varp
)->obj_name
);
2790 varobj_delete (*varp
, NULL
, 0);
2791 install_variable (tmp_var
);
2794 (*varp
)->root
->is_valid
= 0;
2796 else /* locals must be invalidated. */
2797 (*varp
)->root
->is_valid
= 0;
2802 xfree (all_rootvarobj
);