1 /* Implementation of the GDB variable objects API.
3 Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
4 Free Software Foundation, Inc.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 #include "exceptions.h"
22 #include "expression.h"
29 #include "gdb_assert.h"
30 #include "gdb_string.h"
34 #include "gdbthread.h"
37 /* Non-zero if we want to see trace of varobj level stuff. */
41 show_varobjdebug (struct ui_file *file, int from_tty,
42 struct cmd_list_element *c, const char *value)
44 fprintf_filtered (file, _("Varobj debugging is %s.\n"), value);
47 /* String representations of gdb's format codes */
48 char *varobj_format_string[] =
49 { "natural", "binary", "decimal", "hexadecimal", "octal" };
51 /* String representations of gdb's known languages */
52 char *varobj_language_string[] = { "unknown", "C", "C++", "Java" };
56 /* Every root variable has one of these structures saved in its
57 varobj. Members which must be free'd are noted. */
61 /* Alloc'd expression for this parent. */
62 struct expression *exp;
64 /* Block for which this expression is valid */
65 struct block *valid_block;
67 /* The frame for this expression. This field is set iff valid_block is
69 struct frame_id frame;
71 /* The thread ID that this varobj_root belong to. This field
72 is only valid if valid_block is not NULL.
73 When not 0, indicates which thread 'frame' belongs to.
74 When 0, indicates that the thread list was empty when the varobj_root
78 /* If 1, the -var-update always recomputes the value in the
79 current thread and frame. Otherwise, variable object is
80 always updated in the specific scope/thread/frame */
83 /* Flag that indicates validity: set to 0 when this varobj_root refers
84 to symbols that do not exist anymore. */
87 /* Language info for this variable and its children */
88 struct language_specific *lang;
90 /* The varobj for this root node. */
91 struct varobj *rootvar;
93 /* Next root variable */
94 struct varobj_root *next;
97 /* Every variable in the system has a structure of this type defined
98 for it. This structure holds all information necessary to manipulate
99 a particular object variable. Members which must be freed are noted. */
103 /* Alloc'd name of the variable for this object.. If this variable is a
104 child, then this name will be the child's source name.
105 (bar, not foo.bar) */
106 /* NOTE: This is the "expression" */
109 /* Alloc'd expression for this child. Can be used to create a
110 root variable corresponding to this child. */
113 /* The alloc'd name for this variable's object. This is here for
114 convenience when constructing this object's children. */
117 /* Index of this variable in its parent or -1 */
120 /* The type of this variable. This can be NULL
121 for artifial variable objects -- currently, the "accessibility"
122 variable objects in C++. */
125 /* The value of this expression or subexpression. A NULL value
126 indicates there was an error getting this value.
127 Invariant: if varobj_value_is_changeable_p (this) is non-zero,
128 the value is either NULL, or not lazy. */
131 /* The number of (immediate) children this variable has */
134 /* If this object is a child, this points to its immediate parent. */
135 struct varobj *parent;
137 /* Children of this object. */
138 VEC (varobj_p) *children;
140 /* Description of the root variable. Points to root variable for children. */
141 struct varobj_root *root;
143 /* The format of the output for this object */
144 enum varobj_display_formats format;
146 /* Was this variable updated via a varobj_set_value operation */
149 /* Last print value. */
152 /* Is this variable frozen. Frozen variables are never implicitly
153 updated by -var-update *
154 or -var-update <direct-or-indirect-parent>. */
157 /* Is the value of this variable intentionally not fetched? It is
158 not fetched if either the variable is frozen, or any parents is
166 struct cpstack *next;
169 /* A list of varobjs */
177 /* Private function prototypes */
179 /* Helper functions for the above subcommands. */
181 static int delete_variable (struct cpstack **, struct varobj *, int);
183 static void delete_variable_1 (struct cpstack **, int *,
184 struct varobj *, int, int);
186 static int install_variable (struct varobj *);
188 static void uninstall_variable (struct varobj *);
190 static struct varobj *create_child (struct varobj *, int, char *);
192 /* Utility routines */
194 static struct varobj *new_variable (void);
196 static struct varobj *new_root_variable (void);
198 static void free_variable (struct varobj *var);
200 static struct cleanup *make_cleanup_free_variable (struct varobj *var);
202 static struct type *get_type (struct varobj *var);
204 static struct type *get_value_type (struct varobj *var);
206 static struct type *get_target_type (struct type *);
208 static enum varobj_display_formats variable_default_display (struct varobj *);
210 static void cppush (struct cpstack **pstack, char *name);
212 static char *cppop (struct cpstack **pstack);
214 static int install_new_value (struct varobj *var, struct value *value,
217 /* Language-specific routines. */
219 static enum varobj_languages variable_language (struct varobj *var);
221 static int number_of_children (struct varobj *);
223 static char *name_of_variable (struct varobj *);
225 static char *name_of_child (struct varobj *, int);
227 static struct value *value_of_root (struct varobj **var_handle, int *);
229 static struct value *value_of_child (struct varobj *parent, int index);
231 static char *my_value_of_variable (struct varobj *var,
232 enum varobj_display_formats format);
234 static char *value_get_print_value (struct value *value,
235 enum varobj_display_formats format);
237 static int varobj_value_is_changeable_p (struct varobj *var);
239 static int is_root_p (struct varobj *var);
241 /* C implementation */
243 static int c_number_of_children (struct varobj *var);
245 static char *c_name_of_variable (struct varobj *parent);
247 static char *c_name_of_child (struct varobj *parent, int index);
249 static char *c_path_expr_of_child (struct varobj *child);
251 static struct value *c_value_of_root (struct varobj **var_handle);
253 static struct value *c_value_of_child (struct varobj *parent, int index);
255 static struct type *c_type_of_child (struct varobj *parent, int index);
257 static char *c_value_of_variable (struct varobj *var,
258 enum varobj_display_formats format);
260 /* C++ implementation */
262 static int cplus_number_of_children (struct varobj *var);
264 static void cplus_class_num_children (struct type *type, int children[3]);
266 static char *cplus_name_of_variable (struct varobj *parent);
268 static char *cplus_name_of_child (struct varobj *parent, int index);
270 static char *cplus_path_expr_of_child (struct varobj *child);
272 static struct value *cplus_value_of_root (struct varobj **var_handle);
274 static struct value *cplus_value_of_child (struct varobj *parent, int index);
276 static struct type *cplus_type_of_child (struct varobj *parent, int index);
278 static char *cplus_value_of_variable (struct varobj *var,
279 enum varobj_display_formats format);
281 /* Java implementation */
283 static int java_number_of_children (struct varobj *var);
285 static char *java_name_of_variable (struct varobj *parent);
287 static char *java_name_of_child (struct varobj *parent, int index);
289 static char *java_path_expr_of_child (struct varobj *child);
291 static struct value *java_value_of_root (struct varobj **var_handle);
293 static struct value *java_value_of_child (struct varobj *parent, int index);
295 static struct type *java_type_of_child (struct varobj *parent, int index);
297 static char *java_value_of_variable (struct varobj *var,
298 enum varobj_display_formats format);
300 /* The language specific vector */
302 struct language_specific
305 /* The language of this variable */
306 enum varobj_languages language;
308 /* The number of children of PARENT. */
309 int (*number_of_children) (struct varobj * parent);
311 /* The name (expression) of a root varobj. */
312 char *(*name_of_variable) (struct varobj * parent);
314 /* The name of the INDEX'th child of PARENT. */
315 char *(*name_of_child) (struct varobj * parent, int index);
317 /* Returns the rooted expression of CHILD, which is a variable
318 obtain that has some parent. */
319 char *(*path_expr_of_child) (struct varobj * child);
321 /* The ``struct value *'' of the root variable ROOT. */
322 struct value *(*value_of_root) (struct varobj ** root_handle);
324 /* The ``struct value *'' of the INDEX'th child of PARENT. */
325 struct value *(*value_of_child) (struct varobj * parent, int index);
327 /* The type of the INDEX'th child of PARENT. */
328 struct type *(*type_of_child) (struct varobj * parent, int index);
330 /* The current value of VAR. */
331 char *(*value_of_variable) (struct varobj * var,
332 enum varobj_display_formats format);
335 /* Array of known source language routines. */
336 static struct language_specific languages[vlang_end] = {
337 /* Unknown (try treating as C */
340 c_number_of_children,
343 c_path_expr_of_child,
352 c_number_of_children,
355 c_path_expr_of_child,
364 cplus_number_of_children,
365 cplus_name_of_variable,
367 cplus_path_expr_of_child,
369 cplus_value_of_child,
371 cplus_value_of_variable}
376 java_number_of_children,
377 java_name_of_variable,
379 java_path_expr_of_child,
383 java_value_of_variable}
386 /* A little convenience enum for dealing with C++/Java */
389 v_public = 0, v_private, v_protected
394 /* Mappings of varobj_display_formats enums to gdb's format codes */
395 static int format_code[] = { 0, 't', 'd', 'x', 'o' };
397 /* Header of the list of root variable objects */
398 static struct varobj_root *rootlist;
399 static int rootcount = 0; /* number of root varobjs in the list */
401 /* Prime number indicating the number of buckets in the hash table */
402 /* A prime large enough to avoid too many colisions */
403 #define VAROBJ_TABLE_SIZE 227
405 /* Pointer to the varobj hash table (built at run time) */
406 static struct vlist **varobj_table;
408 /* Is the variable X one of our "fake" children? */
409 #define CPLUS_FAKE_CHILD(x) \
410 ((x) != NULL && (x)->type == NULL && (x)->value == NULL)
413 /* API Implementation */
415 is_root_p (struct varobj *var)
417 return (var->root->rootvar == var);
420 /* Creates a varobj (not its children) */
422 /* Return the full FRAME which corresponds to the given CORE_ADDR
423 or NULL if no FRAME on the chain corresponds to CORE_ADDR. */
425 static struct frame_info *
426 find_frame_addr_in_frame_chain (CORE_ADDR frame_addr)
428 struct frame_info *frame = NULL;
430 if (frame_addr == (CORE_ADDR) 0)
435 frame = get_prev_frame (frame);
438 if (get_frame_base_address (frame) == frame_addr)
444 varobj_create (char *objname,
445 char *expression, CORE_ADDR frame, enum varobj_type type)
448 struct frame_info *fi;
449 struct frame_info *old_fi = NULL;
451 struct cleanup *old_chain;
453 /* Fill out a varobj structure for the (root) variable being constructed. */
454 var = new_root_variable ();
455 old_chain = make_cleanup_free_variable (var);
457 if (expression != NULL)
460 enum varobj_languages lang;
461 struct value *value = NULL;
464 /* Parse and evaluate the expression, filling in as much
465 of the variable's data as possible */
467 /* Allow creator to specify context of variable */
468 if ((type == USE_CURRENT_FRAME) || (type == USE_SELECTED_FRAME))
469 fi = deprecated_safe_get_selected_frame ();
471 /* FIXME: cagney/2002-11-23: This code should be doing a
472 lookup using the frame ID and not just the frame's
473 ``address''. This, of course, means an interface change.
474 However, with out that interface change ISAs, such as the
475 ia64 with its two stacks, won't work. Similar goes for the
476 case where there is a frameless function. */
477 fi = find_frame_addr_in_frame_chain (frame);
479 /* frame = -2 means always use selected frame */
480 if (type == USE_SELECTED_FRAME)
481 var->root->floating = 1;
485 block = get_frame_block (fi, 0);
488 innermost_block = NULL;
489 /* Wrap the call to parse expression, so we can
490 return a sensible error. */
491 if (!gdb_parse_exp_1 (&p, block, 0, &var->root->exp))
496 /* Don't allow variables to be created for types. */
497 if (var->root->exp->elts[0].opcode == OP_TYPE)
499 do_cleanups (old_chain);
500 fprintf_unfiltered (gdb_stderr, "Attempt to use a type name"
501 " as an expression.\n");
505 var->format = variable_default_display (var);
506 var->root->valid_block = innermost_block;
507 expr_len = strlen (expression);
508 var->name = savestring (expression, expr_len);
509 /* For a root var, the name and the expr are the same. */
510 var->path_expr = savestring (expression, expr_len);
512 /* When the frame is different from the current frame,
513 we must select the appropriate frame before parsing
514 the expression, otherwise the value will not be current.
515 Since select_frame is so benign, just call it for all cases. */
516 if (innermost_block && fi != NULL)
518 var->root->frame = get_frame_id (fi);
519 var->root->thread_id = pid_to_thread_id (inferior_ptid);
520 old_fi = get_selected_frame (NULL);
524 /* We definitely need to catch errors here.
525 If evaluate_expression succeeds we got the value we wanted.
526 But if it fails, we still go on with a call to evaluate_type() */
527 if (!gdb_evaluate_expression (var->root->exp, &value))
529 /* Error getting the value. Try to at least get the
531 struct value *type_only_value = evaluate_type (var->root->exp);
532 var->type = value_type (type_only_value);
535 var->type = value_type (value);
537 install_new_value (var, value, 1 /* Initial assignment */);
539 /* Set language info */
540 lang = variable_language (var);
541 var->root->lang = &languages[lang];
543 /* Set ourselves as our root */
544 var->root->rootvar = var;
546 /* Reset the selected frame */
548 select_frame (old_fi);
551 /* If the variable object name is null, that means this
552 is a temporary variable, so don't install it. */
554 if ((var != NULL) && (objname != NULL))
556 var->obj_name = savestring (objname, strlen (objname));
558 /* If a varobj name is duplicated, the install will fail so
560 if (!install_variable (var))
562 do_cleanups (old_chain);
567 discard_cleanups (old_chain);
571 /* Generates an unique name that can be used for a varobj */
574 varobj_gen_name (void)
579 /* generate a name for this object */
581 obj_name = xstrprintf ("var%d", id);
586 /* Given an "objname", returns the pointer to the corresponding varobj
587 or NULL if not found */
590 varobj_get_handle (char *objname)
594 unsigned int index = 0;
597 for (chp = objname; *chp; chp++)
599 index = (index + (i++ * (unsigned int) *chp)) % VAROBJ_TABLE_SIZE;
602 cv = *(varobj_table + index);
603 while ((cv != NULL) && (strcmp (cv->var->obj_name, objname) != 0))
607 error (_("Variable object not found"));
612 /* Given the handle, return the name of the object */
615 varobj_get_objname (struct varobj *var)
617 return var->obj_name;
620 /* Given the handle, return the expression represented by the object */
623 varobj_get_expression (struct varobj *var)
625 return name_of_variable (var);
628 /* Deletes a varobj and all its children if only_children == 0,
629 otherwise deletes only the children; returns a malloc'ed list of all the
630 (malloc'ed) names of the variables that have been deleted (NULL terminated) */
633 varobj_delete (struct varobj *var, char ***dellist, int only_children)
637 struct cpstack *result = NULL;
640 /* Initialize a stack for temporary results */
641 cppush (&result, NULL);
644 /* Delete only the variable children */
645 delcount = delete_variable (&result, var, 1 /* only the children */ );
647 /* Delete the variable and all its children */
648 delcount = delete_variable (&result, var, 0 /* parent+children */ );
650 /* We may have been asked to return a list of what has been deleted */
653 *dellist = xmalloc ((delcount + 1) * sizeof (char *));
657 *cp = cppop (&result);
658 while ((*cp != NULL) && (mycount > 0))
662 *cp = cppop (&result);
665 if (mycount || (*cp != NULL))
666 warning (_("varobj_delete: assertion failed - mycount(=%d) <> 0"),
673 /* Set/Get variable object display format */
675 enum varobj_display_formats
676 varobj_set_display_format (struct varobj *var,
677 enum varobj_display_formats format)
684 case FORMAT_HEXADECIMAL:
686 var->format = format;
690 var->format = variable_default_display (var);
693 if (varobj_value_is_changeable_p (var)
694 && var->value && !value_lazy (var->value))
696 free (var->print_value);
697 var->print_value = value_get_print_value (var->value, var->format);
703 enum varobj_display_formats
704 varobj_get_display_format (struct varobj *var)
709 /* If the variable object is bound to a specific thread, that
710 is its evaluation can always be done in context of a frame
711 inside that thread, returns GDB id of the thread -- which
712 is always positive. Otherwise, returns -1. */
714 varobj_get_thread_id (struct varobj *var)
716 if (var->root->valid_block && var->root->thread_id > 0)
717 return var->root->thread_id;
723 varobj_set_frozen (struct varobj *var, int frozen)
725 /* When a variable is unfrozen, we don't fetch its value.
726 The 'not_fetched' flag remains set, so next -var-update
729 We don't fetch the value, because for structures the client
730 should do -var-update anyway. It would be bad to have different
731 client-size logic for structure and other types. */
732 var->frozen = frozen;
736 varobj_get_frozen (struct varobj *var)
743 varobj_get_num_children (struct varobj *var)
745 if (var->num_children == -1)
746 var->num_children = number_of_children (var);
748 return var->num_children;
751 /* Creates a list of the immediate children of a variable object;
752 the return code is the number of such children or -1 on error */
755 varobj_list_children (struct varobj *var)
757 struct varobj *child;
761 if (var->num_children == -1)
762 var->num_children = number_of_children (var);
764 /* If that failed, give up. */
765 if (var->num_children == -1)
766 return var->children;
768 /* If we're called when the list of children is not yet initialized,
769 allocate enough elements in it. */
770 while (VEC_length (varobj_p, var->children) < var->num_children)
771 VEC_safe_push (varobj_p, var->children, NULL);
773 for (i = 0; i < var->num_children; i++)
775 varobj_p existing = VEC_index (varobj_p, var->children, i);
777 if (existing == NULL)
779 /* Either it's the first call to varobj_list_children for
780 this variable object, and the child was never created,
781 or it was explicitly deleted by the client. */
782 name = name_of_child (var, i);
783 existing = create_child (var, i, name);
784 VEC_replace (varobj_p, var->children, i, existing);
788 return var->children;
791 /* Obtain the type of an object Variable as a string similar to the one gdb
792 prints on the console */
795 varobj_get_type (struct varobj *var)
798 struct cleanup *old_chain;
803 /* For the "fake" variables, do not return a type. (It's type is
805 Do not return a type for invalid variables as well. */
806 if (CPLUS_FAKE_CHILD (var) || !var->root->is_valid)
809 stb = mem_fileopen ();
810 old_chain = make_cleanup_ui_file_delete (stb);
812 /* To print the type, we simply create a zero ``struct value *'' and
813 cast it to our type. We then typeprint this variable. */
814 val = value_zero (var->type, not_lval);
815 type_print (value_type (val), "", stb, -1);
817 thetype = ui_file_xstrdup (stb, &length);
818 do_cleanups (old_chain);
822 /* Obtain the type of an object variable. */
825 varobj_get_gdb_type (struct varobj *var)
830 /* Return a pointer to the full rooted expression of varobj VAR.
831 If it has not been computed yet, compute it. */
833 varobj_get_path_expr (struct varobj *var)
835 if (var->path_expr != NULL)
836 return var->path_expr;
839 /* For root varobjs, we initialize path_expr
840 when creating varobj, so here it should be
842 gdb_assert (!is_root_p (var));
843 return (*var->root->lang->path_expr_of_child) (var);
847 enum varobj_languages
848 varobj_get_language (struct varobj *var)
850 return variable_language (var);
854 varobj_get_attributes (struct varobj *var)
858 if (varobj_editable_p (var))
859 /* FIXME: define masks for attributes */
860 attributes |= 0x00000001; /* Editable */
866 varobj_get_formatted_value (struct varobj *var,
867 enum varobj_display_formats format)
869 return my_value_of_variable (var, format);
873 varobj_get_value (struct varobj *var)
875 return my_value_of_variable (var, var->format);
878 /* Set the value of an object variable (if it is editable) to the
879 value of the given expression */
880 /* Note: Invokes functions that can call error() */
883 varobj_set_value (struct varobj *var, char *expression)
889 /* The argument "expression" contains the variable's new value.
890 We need to first construct a legal expression for this -- ugh! */
891 /* Does this cover all the bases? */
892 struct expression *exp;
894 int saved_input_radix = input_radix;
895 char *s = expression;
898 gdb_assert (varobj_editable_p (var));
900 input_radix = 10; /* ALWAYS reset to decimal temporarily */
901 exp = parse_exp_1 (&s, 0, 0);
902 if (!gdb_evaluate_expression (exp, &value))
904 /* We cannot proceed without a valid expression. */
909 /* All types that are editable must also be changeable. */
910 gdb_assert (varobj_value_is_changeable_p (var));
912 /* The value of a changeable variable object must not be lazy. */
913 gdb_assert (!value_lazy (var->value));
915 /* Need to coerce the input. We want to check if the
916 value of the variable object will be different
917 after assignment, and the first thing value_assign
918 does is coerce the input.
919 For example, if we are assigning an array to a pointer variable we
920 should compare the pointer with the the array's address, not with the
922 value = coerce_array (value);
924 /* The new value may be lazy. gdb_value_assign, or
925 rather value_contents, will take care of this.
926 If fetching of the new value will fail, gdb_value_assign
927 with catch the exception. */
928 if (!gdb_value_assign (var->value, value, &val))
931 /* If the value has changed, record it, so that next -var-update can
932 report this change. If a variable had a value of '1', we've set it
933 to '333' and then set again to '1', when -var-update will report this
934 variable as changed -- because the first assignment has set the
935 'updated' flag. There's no need to optimize that, because return value
936 of -var-update should be considered an approximation. */
937 var->updated = install_new_value (var, val, 0 /* Compare values. */);
938 input_radix = saved_input_radix;
942 /* Returns a malloc'ed list with all root variable objects */
944 varobj_list (struct varobj ***varlist)
947 struct varobj_root *croot;
948 int mycount = rootcount;
950 /* Alloc (rootcount + 1) entries for the result */
951 *varlist = xmalloc ((rootcount + 1) * sizeof (struct varobj *));
955 while ((croot != NULL) && (mycount > 0))
957 *cv = croot->rootvar;
962 /* Mark the end of the list */
965 if (mycount || (croot != NULL))
967 ("varobj_list: assertion failed - wrong tally of root vars (%d:%d)",
973 /* Assign a new value to a variable object. If INITIAL is non-zero,
974 this is the first assignement after the variable object was just
975 created, or changed type. In that case, just assign the value
977 Otherwise, assign the value and if type_changeable returns non-zero,
978 find if the new value is different from the current value.
979 Return 1 if so, and 0 if the values are equal.
981 The VALUE parameter should not be released -- the function will
982 take care of releasing it when needed. */
984 install_new_value (struct varobj *var, struct value *value, int initial)
989 int intentionally_not_fetched = 0;
990 char *print_value = NULL;
992 /* We need to know the varobj's type to decide if the value should
993 be fetched or not. C++ fake children (public/protected/private) don't have
995 gdb_assert (var->type || CPLUS_FAKE_CHILD (var));
996 changeable = varobj_value_is_changeable_p (var);
997 need_to_fetch = changeable;
999 /* We are not interested in the address of references, and given
1000 that in C++ a reference is not rebindable, it cannot
1001 meaningfully change. So, get hold of the real value. */
1004 value = coerce_ref (value);
1005 release_value (value);
1008 if (var->type && TYPE_CODE (var->type) == TYPE_CODE_UNION)
1009 /* For unions, we need to fetch the value implicitly because
1010 of implementation of union member fetch. When gdb
1011 creates a value for a field and the value of the enclosing
1012 structure is not lazy, it immediately copies the necessary
1013 bytes from the enclosing values. If the enclosing value is
1014 lazy, the call to value_fetch_lazy on the field will read
1015 the data from memory. For unions, that means we'll read the
1016 same memory more than once, which is not desirable. So
1020 /* The new value might be lazy. If the type is changeable,
1021 that is we'll be comparing values of this type, fetch the
1022 value now. Otherwise, on the next update the old value
1023 will be lazy, which means we've lost that old value. */
1024 if (need_to_fetch && value && value_lazy (value))
1026 struct varobj *parent = var->parent;
1027 int frozen = var->frozen;
1028 for (; !frozen && parent; parent = parent->parent)
1029 frozen |= parent->frozen;
1031 if (frozen && initial)
1033 /* For variables that are frozen, or are children of frozen
1034 variables, we don't do fetch on initial assignment.
1035 For non-initial assignemnt we do the fetch, since it means we're
1036 explicitly asked to compare the new value with the old one. */
1037 intentionally_not_fetched = 1;
1039 else if (!gdb_value_fetch_lazy (value))
1041 /* Set the value to NULL, so that for the next -var-update,
1042 we don't try to compare the new value with this value,
1043 that we couldn't even read. */
1048 /* Below, we'll be comparing string rendering of old and new
1049 values. Don't get string rendering if the value is
1050 lazy -- if it is, the code above has decided that the value
1051 should not be fetched. */
1052 if (value && !value_lazy (value))
1053 print_value = value_get_print_value (value, var->format);
1055 /* If the type is changeable, compare the old and the new values.
1056 If this is the initial assignment, we don't have any old value
1058 if (!initial && changeable)
1060 /* If the value of the varobj was changed by -var-set-value, then the
1061 value in the varobj and in the target is the same. However, that value
1062 is different from the value that the varobj had after the previous
1063 -var-update. So need to the varobj as changed. */
1070 /* Try to compare the values. That requires that both
1071 values are non-lazy. */
1072 if (var->not_fetched && value_lazy (var->value))
1074 /* This is a frozen varobj and the value was never read.
1075 Presumably, UI shows some "never read" indicator.
1076 Now that we've fetched the real value, we need to report
1077 this varobj as changed so that UI can show the real
1081 else if (var->value == NULL && value == NULL)
1084 else if (var->value == NULL || value == NULL)
1090 gdb_assert (!value_lazy (var->value));
1091 gdb_assert (!value_lazy (value));
1093 gdb_assert (var->print_value != NULL && print_value != NULL);
1094 if (strcmp (var->print_value, print_value) != 0)
1100 /* We must always keep the new value, since children depend on it. */
1101 if (var->value != NULL && var->value != value)
1102 value_free (var->value);
1104 if (var->print_value)
1105 xfree (var->print_value);
1106 var->print_value = print_value;
1107 if (value && value_lazy (value) && intentionally_not_fetched)
1108 var->not_fetched = 1;
1110 var->not_fetched = 0;
1113 gdb_assert (!var->value || value_type (var->value));
1118 /* Update the values for a variable and its children. This is a
1119 two-pronged attack. First, re-parse the value for the root's
1120 expression to see if it's changed. Then go all the way
1121 through its children, reconstructing them and noting if they've
1124 The EXPLICIT parameter specifies if this call is result
1125 of MI request to update this specific variable, or
1126 result of implicit -var-update *. For implicit request, we don't
1127 update frozen variables.
1129 NOTE: This function may delete the caller's varobj. If it
1130 returns TYPE_CHANGED, then it has done this and VARP will be modified
1131 to point to the new varobj. */
1133 VEC(varobj_update_result) *varobj_update (struct varobj **varp, int explicit)
1136 int type_changed = 0;
1141 struct varobj **templist = NULL;
1143 VEC (varobj_p) *stack = NULL;
1144 VEC (varobj_update_result) *result = NULL;
1145 struct frame_info *fi;
1147 /* Frozen means frozen -- we don't check for any change in
1148 this varobj, including its going out of scope, or
1149 changing type. One use case for frozen varobjs is
1150 retaining previously evaluated expressions, and we don't
1151 want them to be reevaluated at all. */
1152 if (!explicit && (*varp)->frozen)
1155 if (!(*varp)->root->is_valid)
1157 varobj_update_result r = {*varp};
1158 r.status = VAROBJ_INVALID;
1159 VEC_safe_push (varobj_update_result, result, &r);
1163 if ((*varp)->root->rootvar == *varp)
1165 varobj_update_result r = {*varp};
1166 r.status = VAROBJ_IN_SCOPE;
1168 /* Update the root variable. value_of_root can return NULL
1169 if the variable is no longer around, i.e. we stepped out of
1170 the frame in which a local existed. We are letting the
1171 value_of_root variable dispose of the varobj if the type
1173 new = value_of_root (varp, &type_changed);
1176 r.type_changed = type_changed;
1177 if (install_new_value ((*varp), new, type_changed))
1181 r.status = VAROBJ_NOT_IN_SCOPE;
1183 if (r.type_changed || r.changed)
1184 VEC_safe_push (varobj_update_result, result, &r);
1186 if (r.status == VAROBJ_NOT_IN_SCOPE)
1190 VEC_safe_push (varobj_p, stack, *varp);
1192 /* Walk through the children, reconstructing them all. */
1193 while (!VEC_empty (varobj_p, stack))
1195 v = VEC_pop (varobj_p, stack);
1197 /* Push any children. Use reverse order so that the first
1198 child is popped from the work stack first, and so
1199 will be added to result first. This does not
1200 affect correctness, just "nicer". */
1201 for (i = VEC_length (varobj_p, v->children)-1; i >= 0; --i)
1203 varobj_p c = VEC_index (varobj_p, v->children, i);
1204 /* Child may be NULL if explicitly deleted by -var-delete. */
1205 if (c != NULL && !c->frozen)
1206 VEC_safe_push (varobj_p, stack, c);
1209 /* Update this variable, unless it's a root, which is already
1211 if (v->root->rootvar != v)
1213 new = value_of_child (v->parent, v->index);
1214 if (install_new_value (v, new, 0 /* type not changed */))
1216 /* Note that it's changed */
1217 varobj_update_result r = {v};
1219 VEC_safe_push (varobj_update_result, result, &r);
1225 VEC_free (varobj_p, stack);
1230 /* Helper functions */
1233 * Variable object construction/destruction
1237 delete_variable (struct cpstack **resultp, struct varobj *var,
1238 int only_children_p)
1242 delete_variable_1 (resultp, &delcount, var,
1243 only_children_p, 1 /* remove_from_parent_p */ );
1248 /* Delete the variable object VAR and its children */
1249 /* IMPORTANT NOTE: If we delete a variable which is a child
1250 and the parent is not removed we dump core. It must be always
1251 initially called with remove_from_parent_p set */
1253 delete_variable_1 (struct cpstack **resultp, int *delcountp,
1254 struct varobj *var, int only_children_p,
1255 int remove_from_parent_p)
1259 /* Delete any children of this variable, too. */
1260 for (i = 0; i < VEC_length (varobj_p, var->children); ++i)
1262 varobj_p child = VEC_index (varobj_p, var->children, i);
1265 if (!remove_from_parent_p)
1266 child->parent = NULL;
1267 delete_variable_1 (resultp, delcountp, child, 0, only_children_p);
1269 VEC_free (varobj_p, var->children);
1271 /* if we were called to delete only the children we are done here */
1272 if (only_children_p)
1275 /* Otherwise, add it to the list of deleted ones and proceed to do so */
1276 /* If the name is null, this is a temporary variable, that has not
1277 yet been installed, don't report it, it belongs to the caller... */
1278 if (var->obj_name != NULL)
1280 cppush (resultp, xstrdup (var->obj_name));
1281 *delcountp = *delcountp + 1;
1284 /* If this variable has a parent, remove it from its parent's list */
1285 /* OPTIMIZATION: if the parent of this variable is also being deleted,
1286 (as indicated by remove_from_parent_p) we don't bother doing an
1287 expensive list search to find the element to remove when we are
1288 discarding the list afterwards */
1289 if ((remove_from_parent_p) && (var->parent != NULL))
1291 VEC_replace (varobj_p, var->parent->children, var->index, NULL);
1294 if (var->obj_name != NULL)
1295 uninstall_variable (var);
1297 /* Free memory associated with this variable */
1298 free_variable (var);
1301 /* Install the given variable VAR with the object name VAR->OBJ_NAME. */
1303 install_variable (struct varobj *var)
1306 struct vlist *newvl;
1308 unsigned int index = 0;
1311 for (chp = var->obj_name; *chp; chp++)
1313 index = (index + (i++ * (unsigned int) *chp)) % VAROBJ_TABLE_SIZE;
1316 cv = *(varobj_table + index);
1317 while ((cv != NULL) && (strcmp (cv->var->obj_name, var->obj_name) != 0))
1321 error (_("Duplicate variable object name"));
1323 /* Add varobj to hash table */
1324 newvl = xmalloc (sizeof (struct vlist));
1325 newvl->next = *(varobj_table + index);
1327 *(varobj_table + index) = newvl;
1329 /* If root, add varobj to root list */
1330 if (is_root_p (var))
1332 /* Add to list of root variables */
1333 if (rootlist == NULL)
1334 var->root->next = NULL;
1336 var->root->next = rootlist;
1337 rootlist = var->root;
1344 /* Unistall the object VAR. */
1346 uninstall_variable (struct varobj *var)
1350 struct varobj_root *cr;
1351 struct varobj_root *prer;
1353 unsigned int index = 0;
1356 /* Remove varobj from hash table */
1357 for (chp = var->obj_name; *chp; chp++)
1359 index = (index + (i++ * (unsigned int) *chp)) % VAROBJ_TABLE_SIZE;
1362 cv = *(varobj_table + index);
1364 while ((cv != NULL) && (strcmp (cv->var->obj_name, var->obj_name) != 0))
1371 fprintf_unfiltered (gdb_stdlog, "Deleting %s\n", var->obj_name);
1376 ("Assertion failed: Could not find variable object \"%s\" to delete",
1382 *(varobj_table + index) = cv->next;
1384 prev->next = cv->next;
1388 /* If root, remove varobj from root list */
1389 if (is_root_p (var))
1391 /* Remove from list of root variables */
1392 if (rootlist == var->root)
1393 rootlist = var->root->next;
1398 while ((cr != NULL) && (cr->rootvar != var))
1406 ("Assertion failed: Could not find varobj \"%s\" in root list",
1413 prer->next = cr->next;
1420 /* Create and install a child of the parent of the given name */
1421 static struct varobj *
1422 create_child (struct varobj *parent, int index, char *name)
1424 struct varobj *child;
1426 struct value *value;
1428 child = new_variable ();
1430 /* name is allocated by name_of_child */
1432 child->index = index;
1433 value = value_of_child (parent, index);
1434 child->parent = parent;
1435 child->root = parent->root;
1436 childs_name = xstrprintf ("%s.%s", parent->obj_name, name);
1437 child->obj_name = childs_name;
1438 install_variable (child);
1440 /* Compute the type of the child. Must do this before
1441 calling install_new_value. */
1443 /* If the child had no evaluation errors, var->value
1444 will be non-NULL and contain a valid type. */
1445 child->type = value_type (value);
1447 /* Otherwise, we must compute the type. */
1448 child->type = (*child->root->lang->type_of_child) (child->parent,
1450 install_new_value (child, value, 1);
1457 * Miscellaneous utility functions.
1460 /* Allocate memory and initialize a new variable */
1461 static struct varobj *
1466 var = (struct varobj *) xmalloc (sizeof (struct varobj));
1468 var->path_expr = NULL;
1469 var->obj_name = NULL;
1473 var->num_children = -1;
1475 var->children = NULL;
1479 var->print_value = NULL;
1481 var->not_fetched = 0;
1486 /* Allocate memory and initialize a new root variable */
1487 static struct varobj *
1488 new_root_variable (void)
1490 struct varobj *var = new_variable ();
1491 var->root = (struct varobj_root *) xmalloc (sizeof (struct varobj_root));;
1492 var->root->lang = NULL;
1493 var->root->exp = NULL;
1494 var->root->valid_block = NULL;
1495 var->root->frame = null_frame_id;
1496 var->root->floating = 0;
1497 var->root->rootvar = NULL;
1498 var->root->is_valid = 1;
1503 /* Free any allocated memory associated with VAR. */
1505 free_variable (struct varobj *var)
1507 /* Free the expression if this is a root variable. */
1508 if (is_root_p (var))
1510 free_current_contents (&var->root->exp);
1515 xfree (var->obj_name);
1516 xfree (var->print_value);
1517 xfree (var->path_expr);
1522 do_free_variable_cleanup (void *var)
1524 free_variable (var);
1527 static struct cleanup *
1528 make_cleanup_free_variable (struct varobj *var)
1530 return make_cleanup (do_free_variable_cleanup, var);
1533 /* This returns the type of the variable. It also skips past typedefs
1534 to return the real type of the variable.
1536 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
1537 except within get_target_type and get_type. */
1538 static struct type *
1539 get_type (struct varobj *var)
1545 type = check_typedef (type);
1550 /* Return the type of the value that's stored in VAR,
1551 or that would have being stored there if the
1552 value were accessible.
1554 This differs from VAR->type in that VAR->type is always
1555 the true type of the expession in the source language.
1556 The return value of this function is the type we're
1557 actually storing in varobj, and using for displaying
1558 the values and for comparing previous and new values.
1560 For example, top-level references are always stripped. */
1561 static struct type *
1562 get_value_type (struct varobj *var)
1567 type = value_type (var->value);
1571 type = check_typedef (type);
1573 if (TYPE_CODE (type) == TYPE_CODE_REF)
1574 type = get_target_type (type);
1576 type = check_typedef (type);
1581 /* This returns the target type (or NULL) of TYPE, also skipping
1582 past typedefs, just like get_type ().
1584 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
1585 except within get_target_type and get_type. */
1586 static struct type *
1587 get_target_type (struct type *type)
1591 type = TYPE_TARGET_TYPE (type);
1593 type = check_typedef (type);
1599 /* What is the default display for this variable? We assume that
1600 everything is "natural". Any exceptions? */
1601 static enum varobj_display_formats
1602 variable_default_display (struct varobj *var)
1604 return FORMAT_NATURAL;
1607 /* FIXME: The following should be generic for any pointer */
1609 cppush (struct cpstack **pstack, char *name)
1613 s = (struct cpstack *) xmalloc (sizeof (struct cpstack));
1619 /* FIXME: The following should be generic for any pointer */
1621 cppop (struct cpstack **pstack)
1626 if ((*pstack)->name == NULL && (*pstack)->next == NULL)
1631 *pstack = (*pstack)->next;
1638 * Language-dependencies
1641 /* Common entry points */
1643 /* Get the language of variable VAR. */
1644 static enum varobj_languages
1645 variable_language (struct varobj *var)
1647 enum varobj_languages lang;
1649 switch (var->root->exp->language_defn->la_language)
1655 case language_cplus:
1666 /* Return the number of children for a given variable.
1667 The result of this function is defined by the language
1668 implementation. The number of children returned by this function
1669 is the number of children that the user will see in the variable
1672 number_of_children (struct varobj *var)
1674 return (*var->root->lang->number_of_children) (var);;
1677 /* What is the expression for the root varobj VAR? Returns a malloc'd string. */
1679 name_of_variable (struct varobj *var)
1681 return (*var->root->lang->name_of_variable) (var);
1684 /* What is the name of the INDEX'th child of VAR? Returns a malloc'd string. */
1686 name_of_child (struct varobj *var, int index)
1688 return (*var->root->lang->name_of_child) (var, index);
1691 /* What is the ``struct value *'' of the root variable VAR?
1692 For floating variable object, evaluation can get us a value
1693 of different type from what is stored in varobj already. In
1695 - *type_changed will be set to 1
1696 - old varobj will be freed, and new one will be
1697 created, with the same name.
1698 - *var_handle will be set to the new varobj
1699 Otherwise, *type_changed will be set to 0. */
1700 static struct value *
1701 value_of_root (struct varobj **var_handle, int *type_changed)
1705 if (var_handle == NULL)
1710 /* This should really be an exception, since this should
1711 only get called with a root variable. */
1713 if (!is_root_p (var))
1716 if (var->root->floating)
1718 struct varobj *tmp_var;
1719 char *old_type, *new_type;
1721 tmp_var = varobj_create (NULL, var->name, (CORE_ADDR) 0,
1722 USE_SELECTED_FRAME);
1723 if (tmp_var == NULL)
1727 old_type = varobj_get_type (var);
1728 new_type = varobj_get_type (tmp_var);
1729 if (strcmp (old_type, new_type) == 0)
1731 /* The expression presently stored inside var->root->exp
1732 remembers the locations of local variables relatively to
1733 the frame where the expression was created (in DWARF location
1734 button, for example). Naturally, those locations are not
1735 correct in other frames, so update the expression. */
1737 struct expression *tmp_exp = var->root->exp;
1738 var->root->exp = tmp_var->root->exp;
1739 tmp_var->root->exp = tmp_exp;
1741 varobj_delete (tmp_var, NULL, 0);
1747 savestring (var->obj_name, strlen (var->obj_name));
1748 varobj_delete (var, NULL, 0);
1750 install_variable (tmp_var);
1751 *var_handle = tmp_var;
1763 return (*var->root->lang->value_of_root) (var_handle);
1766 /* What is the ``struct value *'' for the INDEX'th child of PARENT? */
1767 static struct value *
1768 value_of_child (struct varobj *parent, int index)
1770 struct value *value;
1772 value = (*parent->root->lang->value_of_child) (parent, index);
1777 /* GDB already has a command called "value_of_variable". Sigh. */
1779 my_value_of_variable (struct varobj *var, enum varobj_display_formats format)
1781 if (var->root->is_valid)
1782 return (*var->root->lang->value_of_variable) (var, format);
1788 value_get_print_value (struct value *value, enum varobj_display_formats format)
1791 struct ui_file *stb;
1792 struct cleanup *old_chain;
1798 stb = mem_fileopen ();
1799 old_chain = make_cleanup_ui_file_delete (stb);
1801 common_val_print (value, stb, format_code[(int) format], 1, 0, 0,
1803 thevalue = ui_file_xstrdup (stb, &dummy);
1805 do_cleanups (old_chain);
1810 varobj_editable_p (struct varobj *var)
1813 struct value *value;
1815 if (!(var->root->is_valid && var->value && VALUE_LVAL (var->value)))
1818 type = get_value_type (var);
1820 switch (TYPE_CODE (type))
1822 case TYPE_CODE_STRUCT:
1823 case TYPE_CODE_UNION:
1824 case TYPE_CODE_ARRAY:
1825 case TYPE_CODE_FUNC:
1826 case TYPE_CODE_METHOD:
1836 /* Return non-zero if changes in value of VAR
1837 must be detected and reported by -var-update.
1838 Return zero is -var-update should never report
1839 changes of such values. This makes sense for structures
1840 (since the changes in children values will be reported separately),
1841 or for artifical objects (like 'public' pseudo-field in C++).
1843 Return value of 0 means that gdb need not call value_fetch_lazy
1844 for the value of this variable object. */
1846 varobj_value_is_changeable_p (struct varobj *var)
1851 if (CPLUS_FAKE_CHILD (var))
1854 type = get_value_type (var);
1856 switch (TYPE_CODE (type))
1858 case TYPE_CODE_STRUCT:
1859 case TYPE_CODE_UNION:
1860 case TYPE_CODE_ARRAY:
1871 /* Return 1 if that varobj is floating, that is is always evaluated in the
1872 selected frame, and not bound to thread/frame. Such variable objects
1873 are created using '@' as frame specifier to -var-create. */
1875 varobj_floating_p (struct varobj *var)
1877 return var->root->floating;
1880 /* Given the value and the type of a variable object,
1881 adjust the value and type to those necessary
1882 for getting children of the variable object.
1883 This includes dereferencing top-level references
1884 to all types and dereferencing pointers to
1887 Both TYPE and *TYPE should be non-null. VALUE
1888 can be null if we want to only translate type.
1889 *VALUE can be null as well -- if the parent
1892 If WAS_PTR is not NULL, set *WAS_PTR to 0 or 1
1893 depending on whether pointer was deferenced
1894 in this function. */
1896 adjust_value_for_child_access (struct value **value,
1900 gdb_assert (type && *type);
1905 *type = check_typedef (*type);
1907 /* The type of value stored in varobj, that is passed
1908 to us, is already supposed to be
1909 reference-stripped. */
1911 gdb_assert (TYPE_CODE (*type) != TYPE_CODE_REF);
1913 /* Pointers to structures are treated just like
1914 structures when accessing children. Don't
1915 dererences pointers to other types. */
1916 if (TYPE_CODE (*type) == TYPE_CODE_PTR)
1918 struct type *target_type = get_target_type (*type);
1919 if (TYPE_CODE (target_type) == TYPE_CODE_STRUCT
1920 || TYPE_CODE (target_type) == TYPE_CODE_UNION)
1922 if (value && *value)
1924 int success = gdb_value_ind (*value, value);
1928 *type = target_type;
1934 /* The 'get_target_type' function calls check_typedef on
1935 result, so we can immediately check type code. No
1936 need to call check_typedef here. */
1941 c_number_of_children (struct varobj *var)
1943 struct type *type = get_value_type (var);
1945 struct type *target;
1947 adjust_value_for_child_access (NULL, &type, NULL);
1948 target = get_target_type (type);
1950 switch (TYPE_CODE (type))
1952 case TYPE_CODE_ARRAY:
1953 if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (target) > 0
1954 && TYPE_ARRAY_UPPER_BOUND_TYPE (type) != BOUND_CANNOT_BE_DETERMINED)
1955 children = TYPE_LENGTH (type) / TYPE_LENGTH (target);
1957 /* If we don't know how many elements there are, don't display
1962 case TYPE_CODE_STRUCT:
1963 case TYPE_CODE_UNION:
1964 children = TYPE_NFIELDS (type);
1968 /* The type here is a pointer to non-struct. Typically, pointers
1969 have one child, except for function ptrs, which have no children,
1970 and except for void*, as we don't know what to show.
1972 We can show char* so we allow it to be dereferenced. If you decide
1973 to test for it, please mind that a little magic is necessary to
1974 properly identify it: char* has TYPE_CODE == TYPE_CODE_INT and
1975 TYPE_NAME == "char" */
1976 if (TYPE_CODE (target) == TYPE_CODE_FUNC
1977 || TYPE_CODE (target) == TYPE_CODE_VOID)
1984 /* Other types have no children */
1992 c_name_of_variable (struct varobj *parent)
1994 return savestring (parent->name, strlen (parent->name));
1997 /* Return the value of element TYPE_INDEX of a structure
1998 value VALUE. VALUE's type should be a structure,
1999 or union, or a typedef to struct/union.
2001 Returns NULL if getting the value fails. Never throws. */
2002 static struct value *
2003 value_struct_element_index (struct value *value, int type_index)
2005 struct value *result = NULL;
2006 volatile struct gdb_exception e;
2008 struct type *type = value_type (value);
2009 type = check_typedef (type);
2011 gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
2012 || TYPE_CODE (type) == TYPE_CODE_UNION);
2014 TRY_CATCH (e, RETURN_MASK_ERROR)
2016 if (TYPE_FIELD_STATIC (type, type_index))
2017 result = value_static_field (type, type_index);
2019 result = value_primitive_field (value, 0, type_index, type);
2031 /* Obtain the information about child INDEX of the variable
2033 If CNAME is not null, sets *CNAME to the name of the child relative
2035 If CVALUE is not null, sets *CVALUE to the value of the child.
2036 If CTYPE is not null, sets *CTYPE to the type of the child.
2038 If any of CNAME, CVALUE, or CTYPE is not null, but the corresponding
2039 information cannot be determined, set *CNAME, *CVALUE, or *CTYPE
2042 c_describe_child (struct varobj *parent, int index,
2043 char **cname, struct value **cvalue, struct type **ctype,
2044 char **cfull_expression)
2046 struct value *value = parent->value;
2047 struct type *type = get_value_type (parent);
2048 char *parent_expression = NULL;
2057 if (cfull_expression)
2059 *cfull_expression = NULL;
2060 parent_expression = varobj_get_path_expr (parent);
2062 adjust_value_for_child_access (&value, &type, &was_ptr);
2064 switch (TYPE_CODE (type))
2066 case TYPE_CODE_ARRAY:
2068 *cname = xstrprintf ("%d", index
2069 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)));
2071 if (cvalue && value)
2073 int real_index = index + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type));
2074 struct value *indval =
2075 value_from_longest (builtin_type_int, (LONGEST) real_index);
2076 gdb_value_subscript (value, indval, cvalue);
2080 *ctype = get_target_type (type);
2082 if (cfull_expression)
2083 *cfull_expression = xstrprintf ("(%s)[%d]", parent_expression,
2085 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)));
2090 case TYPE_CODE_STRUCT:
2091 case TYPE_CODE_UNION:
2094 char *string = TYPE_FIELD_NAME (type, index);
2095 *cname = savestring (string, strlen (string));
2098 if (cvalue && value)
2100 /* For C, varobj index is the same as type index. */
2101 *cvalue = value_struct_element_index (value, index);
2105 *ctype = TYPE_FIELD_TYPE (type, index);
2107 if (cfull_expression)
2109 char *join = was_ptr ? "->" : ".";
2110 *cfull_expression = xstrprintf ("(%s)%s%s", parent_expression, join,
2111 TYPE_FIELD_NAME (type, index));
2118 *cname = xstrprintf ("*%s", parent->name);
2120 if (cvalue && value)
2122 int success = gdb_value_ind (value, cvalue);
2127 /* Don't use get_target_type because it calls
2128 check_typedef and here, we want to show the true
2129 declared type of the variable. */
2131 *ctype = TYPE_TARGET_TYPE (type);
2133 if (cfull_expression)
2134 *cfull_expression = xstrprintf ("*(%s)", parent_expression);
2139 /* This should not happen */
2141 *cname = xstrdup ("???");
2142 if (cfull_expression)
2143 *cfull_expression = xstrdup ("???");
2144 /* Don't set value and type, we don't know then. */
2149 c_name_of_child (struct varobj *parent, int index)
2152 c_describe_child (parent, index, &name, NULL, NULL, NULL);
2157 c_path_expr_of_child (struct varobj *child)
2159 c_describe_child (child->parent, child->index, NULL, NULL, NULL,
2161 return child->path_expr;
2164 /* If frame associated with VAR can be found, switch
2165 to it and return 1. Otherwise, return 0. */
2167 check_scope (struct varobj *var)
2169 struct frame_info *fi;
2172 fi = frame_find_by_id (var->root->frame);
2177 CORE_ADDR pc = get_frame_pc (fi);
2178 if (pc < BLOCK_START (var->root->valid_block) ||
2179 pc >= BLOCK_END (var->root->valid_block))
2187 static struct value *
2188 c_value_of_root (struct varobj **var_handle)
2190 struct value *new_val = NULL;
2191 struct varobj *var = *var_handle;
2192 struct frame_info *fi;
2193 int within_scope = 0;
2194 struct cleanup *back_to;
2196 /* Only root variables can be updated... */
2197 if (!is_root_p (var))
2198 /* Not a root var */
2201 back_to = make_cleanup_restore_current_thread ();
2203 /* Determine whether the variable is still around. */
2204 if (var->root->valid_block == NULL || var->root->floating)
2206 else if (var->root->thread_id == 0)
2208 /* The program was single-threaded when the variable object was
2209 created. Technically, it's possible that the program became
2210 multi-threaded since then, but we don't support such
2212 within_scope = check_scope (var);
2216 ptid_t ptid = thread_id_to_pid (var->root->thread_id);
2217 if (in_thread_list (ptid))
2219 switch_to_thread (ptid);
2220 within_scope = check_scope (var);
2226 /* We need to catch errors here, because if evaluate
2227 expression fails we want to just return NULL. */
2228 gdb_evaluate_expression (var->root->exp, &new_val);
2232 do_cleanups (back_to);
2237 static struct value *
2238 c_value_of_child (struct varobj *parent, int index)
2240 struct value *value = NULL;
2241 c_describe_child (parent, index, NULL, &value, NULL, NULL);
2246 static struct type *
2247 c_type_of_child (struct varobj *parent, int index)
2249 struct type *type = NULL;
2250 c_describe_child (parent, index, NULL, NULL, &type, NULL);
2255 c_value_of_variable (struct varobj *var, enum varobj_display_formats format)
2257 /* BOGUS: if val_print sees a struct/class, or a reference to one,
2258 it will print out its children instead of "{...}". So we need to
2259 catch that case explicitly. */
2260 struct type *type = get_type (var);
2262 /* Strip top-level references. */
2263 while (TYPE_CODE (type) == TYPE_CODE_REF)
2264 type = check_typedef (TYPE_TARGET_TYPE (type));
2266 switch (TYPE_CODE (type))
2268 case TYPE_CODE_STRUCT:
2269 case TYPE_CODE_UNION:
2270 return xstrdup ("{...}");
2273 case TYPE_CODE_ARRAY:
2276 number = xstrprintf ("[%d]", var->num_children);
2283 if (var->value == NULL)
2285 /* This can happen if we attempt to get the value of a struct
2286 member when the parent is an invalid pointer. This is an
2287 error condition, so we should tell the caller. */
2292 if (var->not_fetched && value_lazy (var->value))
2293 /* Frozen variable and no value yet. We don't
2294 implicitly fetch the value. MI response will
2295 use empty string for the value, which is OK. */
2298 gdb_assert (varobj_value_is_changeable_p (var));
2299 gdb_assert (!value_lazy (var->value));
2301 /* If the specified format is the current one,
2302 we can reuse print_value */
2303 if (format == var->format)
2304 return xstrdup (var->print_value);
2306 return value_get_print_value (var->value, format);
2316 cplus_number_of_children (struct varobj *var)
2319 int children, dont_know;
2324 if (!CPLUS_FAKE_CHILD (var))
2326 type = get_value_type (var);
2327 adjust_value_for_child_access (NULL, &type, NULL);
2329 if (((TYPE_CODE (type)) == TYPE_CODE_STRUCT) ||
2330 ((TYPE_CODE (type)) == TYPE_CODE_UNION))
2334 cplus_class_num_children (type, kids);
2335 if (kids[v_public] != 0)
2337 if (kids[v_private] != 0)
2339 if (kids[v_protected] != 0)
2342 /* Add any baseclasses */
2343 children += TYPE_N_BASECLASSES (type);
2346 /* FIXME: save children in var */
2353 type = get_value_type (var->parent);
2354 adjust_value_for_child_access (NULL, &type, NULL);
2356 cplus_class_num_children (type, kids);
2357 if (strcmp (var->name, "public") == 0)
2358 children = kids[v_public];
2359 else if (strcmp (var->name, "private") == 0)
2360 children = kids[v_private];
2362 children = kids[v_protected];
2367 children = c_number_of_children (var);
2372 /* Compute # of public, private, and protected variables in this class.
2373 That means we need to descend into all baseclasses and find out
2374 how many are there, too. */
2376 cplus_class_num_children (struct type *type, int children[3])
2380 children[v_public] = 0;
2381 children[v_private] = 0;
2382 children[v_protected] = 0;
2384 for (i = TYPE_N_BASECLASSES (type); i < TYPE_NFIELDS (type); i++)
2386 /* If we have a virtual table pointer, omit it. */
2387 if (TYPE_VPTR_BASETYPE (type) == type && TYPE_VPTR_FIELDNO (type) == i)
2390 if (TYPE_FIELD_PROTECTED (type, i))
2391 children[v_protected]++;
2392 else if (TYPE_FIELD_PRIVATE (type, i))
2393 children[v_private]++;
2395 children[v_public]++;
2400 cplus_name_of_variable (struct varobj *parent)
2402 return c_name_of_variable (parent);
2405 enum accessibility { private_field, protected_field, public_field };
2407 /* Check if field INDEX of TYPE has the specified accessibility.
2408 Return 0 if so and 1 otherwise. */
2410 match_accessibility (struct type *type, int index, enum accessibility acc)
2412 if (acc == private_field && TYPE_FIELD_PRIVATE (type, index))
2414 else if (acc == protected_field && TYPE_FIELD_PROTECTED (type, index))
2416 else if (acc == public_field && !TYPE_FIELD_PRIVATE (type, index)
2417 && !TYPE_FIELD_PROTECTED (type, index))
2424 cplus_describe_child (struct varobj *parent, int index,
2425 char **cname, struct value **cvalue, struct type **ctype,
2426 char **cfull_expression)
2429 struct value *value;
2432 char *parent_expression = NULL;
2440 if (cfull_expression)
2441 *cfull_expression = NULL;
2443 if (CPLUS_FAKE_CHILD (parent))
2445 value = parent->parent->value;
2446 type = get_value_type (parent->parent);
2447 if (cfull_expression)
2448 parent_expression = varobj_get_path_expr (parent->parent);
2452 value = parent->value;
2453 type = get_value_type (parent);
2454 if (cfull_expression)
2455 parent_expression = varobj_get_path_expr (parent);
2458 adjust_value_for_child_access (&value, &type, &was_ptr);
2460 if (TYPE_CODE (type) == TYPE_CODE_STRUCT
2461 || TYPE_CODE (type) == TYPE_CODE_UNION)
2463 char *join = was_ptr ? "->" : ".";
2464 if (CPLUS_FAKE_CHILD (parent))
2466 /* The fields of the class type are ordered as they
2467 appear in the class. We are given an index for a
2468 particular access control type ("public","protected",
2469 or "private"). We must skip over fields that don't
2470 have the access control we are looking for to properly
2471 find the indexed field. */
2472 int type_index = TYPE_N_BASECLASSES (type);
2473 enum accessibility acc = public_field;
2474 if (strcmp (parent->name, "private") == 0)
2475 acc = private_field;
2476 else if (strcmp (parent->name, "protected") == 0)
2477 acc = protected_field;
2481 if (TYPE_VPTR_BASETYPE (type) == type
2482 && type_index == TYPE_VPTR_FIELDNO (type))
2484 else if (match_accessibility (type, type_index, acc))
2491 *cname = xstrdup (TYPE_FIELD_NAME (type, type_index));
2493 if (cvalue && value)
2494 *cvalue = value_struct_element_index (value, type_index);
2497 *ctype = TYPE_FIELD_TYPE (type, type_index);
2499 if (cfull_expression)
2500 *cfull_expression = xstrprintf ("((%s)%s%s)", parent_expression,
2502 TYPE_FIELD_NAME (type, type_index));
2504 else if (index < TYPE_N_BASECLASSES (type))
2506 /* This is a baseclass. */
2508 *cname = xstrdup (TYPE_FIELD_NAME (type, index));
2510 if (cvalue && value)
2512 *cvalue = value_cast (TYPE_FIELD_TYPE (type, index), value);
2513 release_value (*cvalue);
2518 *ctype = TYPE_FIELD_TYPE (type, index);
2521 if (cfull_expression)
2523 char *ptr = was_ptr ? "*" : "";
2524 /* Cast the parent to the base' type. Note that in gdb,
2527 will create an lvalue, for all appearences, so we don't
2528 need to use more fancy:
2531 *cfull_expression = xstrprintf ("(%s(%s%s) %s)",
2533 TYPE_FIELD_NAME (type, index),
2540 char *access = NULL;
2542 cplus_class_num_children (type, children);
2544 /* Everything beyond the baseclasses can
2545 only be "public", "private", or "protected"
2547 The special "fake" children are always output by varobj in
2548 this order. So if INDEX == 2, it MUST be "protected". */
2549 index -= TYPE_N_BASECLASSES (type);
2553 if (children[v_public] > 0)
2555 else if (children[v_private] > 0)
2558 access = "protected";
2561 if (children[v_public] > 0)
2563 if (children[v_private] > 0)
2566 access = "protected";
2568 else if (children[v_private] > 0)
2569 access = "protected";
2572 /* Must be protected */
2573 access = "protected";
2580 gdb_assert (access);
2582 *cname = xstrdup (access);
2584 /* Value and type and full expression are null here. */
2589 c_describe_child (parent, index, cname, cvalue, ctype, cfull_expression);
2594 cplus_name_of_child (struct varobj *parent, int index)
2597 cplus_describe_child (parent, index, &name, NULL, NULL, NULL);
2602 cplus_path_expr_of_child (struct varobj *child)
2604 cplus_describe_child (child->parent, child->index, NULL, NULL, NULL,
2606 return child->path_expr;
2609 static struct value *
2610 cplus_value_of_root (struct varobj **var_handle)
2612 return c_value_of_root (var_handle);
2615 static struct value *
2616 cplus_value_of_child (struct varobj *parent, int index)
2618 struct value *value = NULL;
2619 cplus_describe_child (parent, index, NULL, &value, NULL, NULL);
2623 static struct type *
2624 cplus_type_of_child (struct varobj *parent, int index)
2626 struct type *type = NULL;
2627 cplus_describe_child (parent, index, NULL, NULL, &type, NULL);
2632 cplus_value_of_variable (struct varobj *var, enum varobj_display_formats format)
2635 /* If we have one of our special types, don't print out
2637 if (CPLUS_FAKE_CHILD (var))
2638 return xstrdup ("");
2640 return c_value_of_variable (var, format);
2646 java_number_of_children (struct varobj *var)
2648 return cplus_number_of_children (var);
2652 java_name_of_variable (struct varobj *parent)
2656 name = cplus_name_of_variable (parent);
2657 /* If the name has "-" in it, it is because we
2658 needed to escape periods in the name... */
2661 while (*p != '\000')
2672 java_name_of_child (struct varobj *parent, int index)
2676 name = cplus_name_of_child (parent, index);
2677 /* Escape any periods in the name... */
2680 while (*p != '\000')
2691 java_path_expr_of_child (struct varobj *child)
2696 static struct value *
2697 java_value_of_root (struct varobj **var_handle)
2699 return cplus_value_of_root (var_handle);
2702 static struct value *
2703 java_value_of_child (struct varobj *parent, int index)
2705 return cplus_value_of_child (parent, index);
2708 static struct type *
2709 java_type_of_child (struct varobj *parent, int index)
2711 return cplus_type_of_child (parent, index);
2715 java_value_of_variable (struct varobj *var, enum varobj_display_formats format)
2717 return cplus_value_of_variable (var, format);
2720 extern void _initialize_varobj (void);
2722 _initialize_varobj (void)
2724 int sizeof_table = sizeof (struct vlist *) * VAROBJ_TABLE_SIZE;
2726 varobj_table = xmalloc (sizeof_table);
2727 memset (varobj_table, 0, sizeof_table);
2729 add_setshow_zinteger_cmd ("debugvarobj", class_maintenance,
2731 Set varobj debugging."), _("\
2732 Show varobj debugging."), _("\
2733 When non-zero, varobj debugging is enabled."),
2736 &setlist, &showlist);
2739 /* Invalidate the varobjs that are tied to locals and re-create the ones that
2740 are defined on globals.
2741 Invalidated varobjs will be always printed in_scope="invalid". */
2743 varobj_invalidate (void)
2745 struct varobj **all_rootvarobj;
2746 struct varobj **varp;
2748 if (varobj_list (&all_rootvarobj) > 0)
2750 varp = all_rootvarobj;
2751 while (*varp != NULL)
2753 /* Floating varobjs are reparsed on each stop, so we don't care if
2754 the presently parsed expression refers to something that's gone. */
2755 if ((*varp)->root->floating)
2758 /* global var must be re-evaluated. */
2759 if ((*varp)->root->valid_block == NULL)
2761 struct varobj *tmp_var;
2763 /* Try to create a varobj with same expression. If we succeed replace
2764 the old varobj, otherwise invalidate it. */
2765 tmp_var = varobj_create (NULL, (*varp)->name, (CORE_ADDR) 0, USE_CURRENT_FRAME);
2766 if (tmp_var != NULL)
2768 tmp_var->obj_name = xstrdup ((*varp)->obj_name);
2769 varobj_delete (*varp, NULL, 0);
2770 install_variable (tmp_var);
2773 (*varp)->root->is_valid = 0;
2775 else /* locals must be invalidated. */
2776 (*varp)->root->is_valid = 0;
2780 xfree (all_rootvarobj);