1 /* Implementation of the GDB variable objects API.
3 Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
4 2009, 2010, 2011 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"
32 #include "gdb_regex.h"
36 #include "gdbthread.h"
40 #include "python/python.h"
41 #include "python/python-internal.h"
46 /* Non-zero if we want to see trace of varobj level stuff. */
50 show_varobjdebug (struct ui_file
*file
, int from_tty
,
51 struct cmd_list_element
*c
, const char *value
)
53 fprintf_filtered (file
, _("Varobj debugging is %s.\n"), value
);
56 /* String representations of gdb's format codes. */
57 char *varobj_format_string
[] =
58 { "natural", "binary", "decimal", "hexadecimal", "octal" };
60 /* String representations of gdb's known languages. */
61 char *varobj_language_string
[] = { "unknown", "C", "C++", "Java" };
63 /* True if we want to allow Python-based pretty-printing. */
64 static int pretty_printing
= 0;
67 varobj_enable_pretty_printing (void)
74 /* Every root variable has one of these structures saved in its
75 varobj. Members which must be free'd are noted. */
79 /* Alloc'd expression for this parent. */
80 struct expression
*exp
;
82 /* Block for which this expression is valid. */
83 struct block
*valid_block
;
85 /* The frame for this expression. This field is set iff valid_block is
87 struct frame_id frame
;
89 /* The thread ID that this varobj_root belong to. This field
90 is only valid if valid_block is not NULL.
91 When not 0, indicates which thread 'frame' belongs to.
92 When 0, indicates that the thread list was empty when the varobj_root
96 /* If 1, the -var-update always recomputes the value in the
97 current thread and frame. Otherwise, variable object is
98 always updated in the specific scope/thread/frame. */
101 /* Flag that indicates validity: set to 0 when this varobj_root refers
102 to symbols that do not exist anymore. */
105 /* Language info for this variable and its children. */
106 struct language_specific
*lang
;
108 /* The varobj for this root node. */
109 struct varobj
*rootvar
;
111 /* Next root variable */
112 struct varobj_root
*next
;
115 /* Every variable in the system has a structure of this type defined
116 for it. This structure holds all information necessary to manipulate
117 a particular object variable. Members which must be freed are noted. */
121 /* Alloc'd name of the variable for this object. If this variable is a
122 child, then this name will be the child's source name.
123 (bar, not foo.bar). */
124 /* NOTE: This is the "expression". */
127 /* Alloc'd expression for this child. Can be used to create a
128 root variable corresponding to this child. */
131 /* The alloc'd name for this variable's object. This is here for
132 convenience when constructing this object's children. */
135 /* Index of this variable in its parent or -1. */
138 /* The type of this variable. This can be NULL
139 for artifial variable objects -- currently, the "accessibility"
140 variable objects in C++. */
143 /* The value of this expression or subexpression. A NULL value
144 indicates there was an error getting this value.
145 Invariant: if varobj_value_is_changeable_p (this) is non-zero,
146 the value is either NULL, or not lazy. */
149 /* The number of (immediate) children this variable has. */
152 /* If this object is a child, this points to its immediate parent. */
153 struct varobj
*parent
;
155 /* Children of this object. */
156 VEC (varobj_p
) *children
;
158 /* Whether the children of this varobj were requested. This field is
159 used to decide if dynamic varobj should recompute their children.
160 In the event that the frontend never asked for the children, we
162 int children_requested
;
164 /* Description of the root variable. Points to root variable for
166 struct varobj_root
*root
;
168 /* The format of the output for this object. */
169 enum varobj_display_formats format
;
171 /* Was this variable updated via a varobj_set_value operation. */
174 /* Last print value. */
177 /* Is this variable frozen. Frozen variables are never implicitly
178 updated by -var-update *
179 or -var-update <direct-or-indirect-parent>. */
182 /* Is the value of this variable intentionally not fetched? It is
183 not fetched if either the variable is frozen, or any parents is
187 /* Sub-range of children which the MI consumer has requested. If
188 FROM < 0 or TO < 0, means that all children have been
193 /* The pretty-printer constructor. If NULL, then the default
194 pretty-printer will be looked up. If None, then no
195 pretty-printer will be installed. */
196 PyObject
*constructor
;
198 /* The pretty-printer that has been constructed. If NULL, then a
199 new printer object is needed, and one will be constructed. */
200 PyObject
*pretty_printer
;
202 /* The iterator returned by the printer's 'children' method, or NULL
204 PyObject
*child_iter
;
206 /* We request one extra item from the iterator, so that we can
207 report to the caller whether there are more items than we have
208 already reported. However, we don't want to install this value
209 when we read it, because that will mess up future updates. So,
210 we stash it here instead. */
211 PyObject
*saved_item
;
217 struct cpstack
*next
;
220 /* A list of varobjs */
228 /* Private function prototypes */
230 /* Helper functions for the above subcommands. */
232 static int delete_variable (struct cpstack
**, struct varobj
*, int);
234 static void delete_variable_1 (struct cpstack
**, int *,
235 struct varobj
*, int, int);
237 static int install_variable (struct varobj
*);
239 static void uninstall_variable (struct varobj
*);
241 static struct varobj
*create_child (struct varobj
*, int, char *);
243 static struct varobj
*
244 create_child_with_value (struct varobj
*parent
, int index
, const char *name
,
245 struct value
*value
);
247 /* Utility routines */
249 static struct varobj
*new_variable (void);
251 static struct varobj
*new_root_variable (void);
253 static void free_variable (struct varobj
*var
);
255 static struct cleanup
*make_cleanup_free_variable (struct varobj
*var
);
257 static struct type
*get_type (struct varobj
*var
);
259 static struct type
*get_value_type (struct varobj
*var
);
261 static struct type
*get_target_type (struct type
*);
263 static enum varobj_display_formats
variable_default_display (struct varobj
*);
265 static void cppush (struct cpstack
**pstack
, char *name
);
267 static char *cppop (struct cpstack
**pstack
);
269 static int install_new_value (struct varobj
*var
, struct value
*value
,
272 /* Language-specific routines. */
274 static enum varobj_languages
variable_language (struct varobj
*var
);
276 static int number_of_children (struct varobj
*);
278 static char *name_of_variable (struct varobj
*);
280 static char *name_of_child (struct varobj
*, int);
282 static struct value
*value_of_root (struct varobj
**var_handle
, int *);
284 static struct value
*value_of_child (struct varobj
*parent
, int index
);
286 static char *my_value_of_variable (struct varobj
*var
,
287 enum varobj_display_formats format
);
289 static char *value_get_print_value (struct value
*value
,
290 enum varobj_display_formats format
,
293 static int varobj_value_is_changeable_p (struct varobj
*var
);
295 static int is_root_p (struct varobj
*var
);
299 static struct varobj
*
300 varobj_add_child (struct varobj
*var
, const char *name
, struct value
*value
);
302 #endif /* HAVE_PYTHON */
304 /* C implementation */
306 static int c_number_of_children (struct varobj
*var
);
308 static char *c_name_of_variable (struct varobj
*parent
);
310 static char *c_name_of_child (struct varobj
*parent
, int index
);
312 static char *c_path_expr_of_child (struct varobj
*child
);
314 static struct value
*c_value_of_root (struct varobj
**var_handle
);
316 static struct value
*c_value_of_child (struct varobj
*parent
, int index
);
318 static struct type
*c_type_of_child (struct varobj
*parent
, int index
);
320 static char *c_value_of_variable (struct varobj
*var
,
321 enum varobj_display_formats format
);
323 /* C++ implementation */
325 static int cplus_number_of_children (struct varobj
*var
);
327 static void cplus_class_num_children (struct type
*type
, int children
[3]);
329 static char *cplus_name_of_variable (struct varobj
*parent
);
331 static char *cplus_name_of_child (struct varobj
*parent
, int index
);
333 static char *cplus_path_expr_of_child (struct varobj
*child
);
335 static struct value
*cplus_value_of_root (struct varobj
**var_handle
);
337 static struct value
*cplus_value_of_child (struct varobj
*parent
, int index
);
339 static struct type
*cplus_type_of_child (struct varobj
*parent
, int index
);
341 static char *cplus_value_of_variable (struct varobj
*var
,
342 enum varobj_display_formats format
);
344 /* Java implementation */
346 static int java_number_of_children (struct varobj
*var
);
348 static char *java_name_of_variable (struct varobj
*parent
);
350 static char *java_name_of_child (struct varobj
*parent
, int index
);
352 static char *java_path_expr_of_child (struct varobj
*child
);
354 static struct value
*java_value_of_root (struct varobj
**var_handle
);
356 static struct value
*java_value_of_child (struct varobj
*parent
, int index
);
358 static struct type
*java_type_of_child (struct varobj
*parent
, int index
);
360 static char *java_value_of_variable (struct varobj
*var
,
361 enum varobj_display_formats format
);
363 /* The language specific vector */
365 struct language_specific
368 /* The language of this variable. */
369 enum varobj_languages language
;
371 /* The number of children of PARENT. */
372 int (*number_of_children
) (struct varobj
* parent
);
374 /* The name (expression) of a root varobj. */
375 char *(*name_of_variable
) (struct varobj
* parent
);
377 /* The name of the INDEX'th child of PARENT. */
378 char *(*name_of_child
) (struct varobj
* parent
, int index
);
380 /* Returns the rooted expression of CHILD, which is a variable
381 obtain that has some parent. */
382 char *(*path_expr_of_child
) (struct varobj
* child
);
384 /* The ``struct value *'' of the root variable ROOT. */
385 struct value
*(*value_of_root
) (struct varobj
** root_handle
);
387 /* The ``struct value *'' of the INDEX'th child of PARENT. */
388 struct value
*(*value_of_child
) (struct varobj
* parent
, int index
);
390 /* The type of the INDEX'th child of PARENT. */
391 struct type
*(*type_of_child
) (struct varobj
* parent
, int index
);
393 /* The current value of VAR. */
394 char *(*value_of_variable
) (struct varobj
* var
,
395 enum varobj_display_formats format
);
398 /* Array of known source language routines. */
399 static struct language_specific languages
[vlang_end
] = {
400 /* Unknown (try treating as C). */
403 c_number_of_children
,
406 c_path_expr_of_child
,
415 c_number_of_children
,
418 c_path_expr_of_child
,
427 cplus_number_of_children
,
428 cplus_name_of_variable
,
430 cplus_path_expr_of_child
,
432 cplus_value_of_child
,
434 cplus_value_of_variable
}
439 java_number_of_children
,
440 java_name_of_variable
,
442 java_path_expr_of_child
,
446 java_value_of_variable
}
449 /* A little convenience enum for dealing with C++/Java. */
452 v_public
= 0, v_private
, v_protected
457 /* Mappings of varobj_display_formats enums to gdb's format codes. */
458 static int format_code
[] = { 0, 't', 'd', 'x', 'o' };
460 /* Header of the list of root variable objects. */
461 static struct varobj_root
*rootlist
;
463 /* Prime number indicating the number of buckets in the hash table. */
464 /* A prime large enough to avoid too many colisions. */
465 #define VAROBJ_TABLE_SIZE 227
467 /* Pointer to the varobj hash table (built at run time). */
468 static struct vlist
**varobj_table
;
470 /* Is the variable X one of our "fake" children? */
471 #define CPLUS_FAKE_CHILD(x) \
472 ((x) != NULL && (x)->type == NULL && (x)->value == NULL)
475 /* API Implementation */
477 is_root_p (struct varobj
*var
)
479 return (var
->root
->rootvar
== var
);
483 /* Helper function to install a Python environment suitable for
484 use during operations on VAR. */
486 varobj_ensure_python_env (struct varobj
*var
)
488 return ensure_python_env (var
->root
->exp
->gdbarch
,
489 var
->root
->exp
->language_defn
);
493 /* Creates a varobj (not its children). */
495 /* Return the full FRAME which corresponds to the given CORE_ADDR
496 or NULL if no FRAME on the chain corresponds to CORE_ADDR. */
498 static struct frame_info
*
499 find_frame_addr_in_frame_chain (CORE_ADDR frame_addr
)
501 struct frame_info
*frame
= NULL
;
503 if (frame_addr
== (CORE_ADDR
) 0)
506 for (frame
= get_current_frame ();
508 frame
= get_prev_frame (frame
))
510 /* The CORE_ADDR we get as argument was parsed from a string GDB
511 output as $fp. This output got truncated to gdbarch_addr_bit.
512 Truncate the frame base address in the same manner before
513 comparing it against our argument. */
514 CORE_ADDR frame_base
= get_frame_base_address (frame
);
515 int addr_bit
= gdbarch_addr_bit (get_frame_arch (frame
));
517 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
518 frame_base
&= ((CORE_ADDR
) 1 << addr_bit
) - 1;
520 if (frame_base
== frame_addr
)
528 varobj_create (char *objname
,
529 char *expression
, CORE_ADDR frame
, enum varobj_type type
)
532 struct cleanup
*old_chain
;
534 /* Fill out a varobj structure for the (root) variable being constructed. */
535 var
= new_root_variable ();
536 old_chain
= make_cleanup_free_variable (var
);
538 if (expression
!= NULL
)
540 struct frame_info
*fi
;
541 struct frame_id old_id
= null_frame_id
;
544 enum varobj_languages lang
;
545 struct value
*value
= NULL
;
547 /* Parse and evaluate the expression, filling in as much of the
548 variable's data as possible. */
550 if (has_stack_frames ())
552 /* Allow creator to specify context of variable. */
553 if ((type
== USE_CURRENT_FRAME
) || (type
== USE_SELECTED_FRAME
))
554 fi
= get_selected_frame (NULL
);
556 /* FIXME: cagney/2002-11-23: This code should be doing a
557 lookup using the frame ID and not just the frame's
558 ``address''. This, of course, means an interface
559 change. However, with out that interface change ISAs,
560 such as the ia64 with its two stacks, won't work.
561 Similar goes for the case where there is a frameless
563 fi
= find_frame_addr_in_frame_chain (frame
);
568 /* frame = -2 means always use selected frame. */
569 if (type
== USE_SELECTED_FRAME
)
570 var
->root
->floating
= 1;
574 block
= get_frame_block (fi
, 0);
577 innermost_block
= NULL
;
578 /* Wrap the call to parse expression, so we can
579 return a sensible error. */
580 if (!gdb_parse_exp_1 (&p
, block
, 0, &var
->root
->exp
))
585 /* Don't allow variables to be created for types. */
586 if (var
->root
->exp
->elts
[0].opcode
== OP_TYPE
)
588 do_cleanups (old_chain
);
589 fprintf_unfiltered (gdb_stderr
, "Attempt to use a type name"
590 " as an expression.\n");
594 var
->format
= variable_default_display (var
);
595 var
->root
->valid_block
= innermost_block
;
596 var
->name
= xstrdup (expression
);
597 /* For a root var, the name and the expr are the same. */
598 var
->path_expr
= xstrdup (expression
);
600 /* When the frame is different from the current frame,
601 we must select the appropriate frame before parsing
602 the expression, otherwise the value will not be current.
603 Since select_frame is so benign, just call it for all cases. */
606 /* User could specify explicit FRAME-ADDR which was not found but
607 EXPRESSION is frame specific and we would not be able to evaluate
608 it correctly next time. With VALID_BLOCK set we must also set
609 FRAME and THREAD_ID. */
611 error (_("Failed to find the specified frame"));
613 var
->root
->frame
= get_frame_id (fi
);
614 var
->root
->thread_id
= pid_to_thread_id (inferior_ptid
);
615 old_id
= get_frame_id (get_selected_frame (NULL
));
619 /* We definitely need to catch errors here.
620 If evaluate_expression succeeds we got the value we wanted.
621 But if it fails, we still go on with a call to evaluate_type(). */
622 if (!gdb_evaluate_expression (var
->root
->exp
, &value
))
624 /* Error getting the value. Try to at least get the
626 struct value
*type_only_value
= evaluate_type (var
->root
->exp
);
628 var
->type
= value_type (type_only_value
);
631 var
->type
= value_type (value
);
633 install_new_value (var
, value
, 1 /* Initial assignment */);
635 /* Set language info */
636 lang
= variable_language (var
);
637 var
->root
->lang
= &languages
[lang
];
639 /* Set ourselves as our root. */
640 var
->root
->rootvar
= var
;
642 /* Reset the selected frame. */
643 if (frame_id_p (old_id
))
644 select_frame (frame_find_by_id (old_id
));
647 /* If the variable object name is null, that means this
648 is a temporary variable, so don't install it. */
650 if ((var
!= NULL
) && (objname
!= NULL
))
652 var
->obj_name
= xstrdup (objname
);
654 /* If a varobj name is duplicated, the install will fail so
656 if (!install_variable (var
))
658 do_cleanups (old_chain
);
663 discard_cleanups (old_chain
);
667 /* Generates an unique name that can be used for a varobj. */
670 varobj_gen_name (void)
675 /* Generate a name for this object. */
677 obj_name
= xstrprintf ("var%d", id
);
682 /* Given an OBJNAME, returns the pointer to the corresponding varobj. Call
683 error if OBJNAME cannot be found. */
686 varobj_get_handle (char *objname
)
690 unsigned int index
= 0;
693 for (chp
= objname
; *chp
; chp
++)
695 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
698 cv
= *(varobj_table
+ index
);
699 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, objname
) != 0))
703 error (_("Variable object not found"));
708 /* Given the handle, return the name of the object. */
711 varobj_get_objname (struct varobj
*var
)
713 return var
->obj_name
;
716 /* Given the handle, return the expression represented by the object. */
719 varobj_get_expression (struct varobj
*var
)
721 return name_of_variable (var
);
724 /* Deletes a varobj and all its children if only_children == 0,
725 otherwise deletes only the children; returns a malloc'ed list of
726 all the (malloc'ed) names of the variables that have been deleted
727 (NULL terminated). */
730 varobj_delete (struct varobj
*var
, char ***dellist
, int only_children
)
734 struct cpstack
*result
= NULL
;
737 /* Initialize a stack for temporary results. */
738 cppush (&result
, NULL
);
741 /* Delete only the variable children. */
742 delcount
= delete_variable (&result
, var
, 1 /* only the children */ );
744 /* Delete the variable and all its children. */
745 delcount
= delete_variable (&result
, var
, 0 /* parent+children */ );
747 /* We may have been asked to return a list of what has been deleted. */
750 *dellist
= xmalloc ((delcount
+ 1) * sizeof (char *));
754 *cp
= cppop (&result
);
755 while ((*cp
!= NULL
) && (mycount
> 0))
759 *cp
= cppop (&result
);
762 if (mycount
|| (*cp
!= NULL
))
763 warning (_("varobj_delete: assertion failed - mycount(=%d) <> 0"),
772 /* Convenience function for varobj_set_visualizer. Instantiate a
773 pretty-printer for a given value. */
775 instantiate_pretty_printer (PyObject
*constructor
, struct value
*value
)
777 PyObject
*val_obj
= NULL
;
780 val_obj
= value_to_value_object (value
);
784 printer
= PyObject_CallFunctionObjArgs (constructor
, val_obj
, NULL
);
792 /* Set/Get variable object display format. */
794 enum varobj_display_formats
795 varobj_set_display_format (struct varobj
*var
,
796 enum varobj_display_formats format
)
803 case FORMAT_HEXADECIMAL
:
805 var
->format
= format
;
809 var
->format
= variable_default_display (var
);
812 if (varobj_value_is_changeable_p (var
)
813 && var
->value
&& !value_lazy (var
->value
))
815 xfree (var
->print_value
);
816 var
->print_value
= value_get_print_value (var
->value
, var
->format
, var
);
822 enum varobj_display_formats
823 varobj_get_display_format (struct varobj
*var
)
829 varobj_get_display_hint (struct varobj
*var
)
834 struct cleanup
*back_to
= varobj_ensure_python_env (var
);
836 if (var
->pretty_printer
)
837 result
= gdbpy_get_display_hint (var
->pretty_printer
);
839 do_cleanups (back_to
);
845 /* Return true if the varobj has items after TO, false otherwise. */
848 varobj_has_more (struct varobj
*var
, int to
)
850 if (VEC_length (varobj_p
, var
->children
) > to
)
852 return ((to
== -1 || VEC_length (varobj_p
, var
->children
) == to
)
853 && var
->saved_item
!= NULL
);
856 /* If the variable object is bound to a specific thread, that
857 is its evaluation can always be done in context of a frame
858 inside that thread, returns GDB id of the thread -- which
859 is always positive. Otherwise, returns -1. */
861 varobj_get_thread_id (struct varobj
*var
)
863 if (var
->root
->valid_block
&& var
->root
->thread_id
> 0)
864 return var
->root
->thread_id
;
870 varobj_set_frozen (struct varobj
*var
, int frozen
)
872 /* When a variable is unfrozen, we don't fetch its value.
873 The 'not_fetched' flag remains set, so next -var-update
876 We don't fetch the value, because for structures the client
877 should do -var-update anyway. It would be bad to have different
878 client-size logic for structure and other types. */
879 var
->frozen
= frozen
;
883 varobj_get_frozen (struct varobj
*var
)
888 /* A helper function that restricts a range to what is actually
889 available in a VEC. This follows the usual rules for the meaning
890 of FROM and TO -- if either is negative, the entire range is
894 restrict_range (VEC (varobj_p
) *children
, int *from
, int *to
)
896 if (*from
< 0 || *to
< 0)
899 *to
= VEC_length (varobj_p
, children
);
903 if (*from
> VEC_length (varobj_p
, children
))
904 *from
= VEC_length (varobj_p
, children
);
905 if (*to
> VEC_length (varobj_p
, children
))
906 *to
= VEC_length (varobj_p
, children
);
914 /* A helper for update_dynamic_varobj_children that installs a new
915 child when needed. */
918 install_dynamic_child (struct varobj
*var
,
919 VEC (varobj_p
) **changed
,
920 VEC (varobj_p
) **new,
921 VEC (varobj_p
) **unchanged
,
927 if (VEC_length (varobj_p
, var
->children
) < index
+ 1)
929 /* There's no child yet. */
930 struct varobj
*child
= varobj_add_child (var
, name
, value
);
934 VEC_safe_push (varobj_p
, *new, child
);
940 varobj_p existing
= VEC_index (varobj_p
, var
->children
, index
);
942 if (install_new_value (existing
, value
, 0))
945 VEC_safe_push (varobj_p
, *changed
, existing
);
948 VEC_safe_push (varobj_p
, *unchanged
, existing
);
953 dynamic_varobj_has_child_method (struct varobj
*var
)
955 struct cleanup
*back_to
;
956 PyObject
*printer
= var
->pretty_printer
;
959 back_to
= varobj_ensure_python_env (var
);
960 result
= PyObject_HasAttr (printer
, gdbpy_children_cst
);
961 do_cleanups (back_to
);
968 update_dynamic_varobj_children (struct varobj
*var
,
969 VEC (varobj_p
) **changed
,
970 VEC (varobj_p
) **new,
971 VEC (varobj_p
) **unchanged
,
978 struct cleanup
*back_to
;
981 PyObject
*printer
= var
->pretty_printer
;
983 back_to
= varobj_ensure_python_env (var
);
986 if (!PyObject_HasAttr (printer
, gdbpy_children_cst
))
988 do_cleanups (back_to
);
992 if (update_children
|| !var
->child_iter
)
994 children
= PyObject_CallMethodObjArgs (printer
, gdbpy_children_cst
,
999 gdbpy_print_stack ();
1000 error (_("Null value returned for children"));
1003 make_cleanup_py_decref (children
);
1005 if (!PyIter_Check (children
))
1006 error (_("Returned value is not iterable"));
1008 Py_XDECREF (var
->child_iter
);
1009 var
->child_iter
= PyObject_GetIter (children
);
1010 if (!var
->child_iter
)
1012 gdbpy_print_stack ();
1013 error (_("Could not get children iterator"));
1016 Py_XDECREF (var
->saved_item
);
1017 var
->saved_item
= NULL
;
1022 i
= VEC_length (varobj_p
, var
->children
);
1024 /* We ask for one extra child, so that MI can report whether there
1025 are more children. */
1026 for (; to
< 0 || i
< to
+ 1; ++i
)
1030 /* See if there was a leftover from last time. */
1031 if (var
->saved_item
)
1033 item
= var
->saved_item
;
1034 var
->saved_item
= NULL
;
1037 item
= PyIter_Next (var
->child_iter
);
1042 /* We don't want to push the extra child on any report list. */
1043 if (to
< 0 || i
< to
)
1048 struct cleanup
*inner
;
1049 int can_mention
= from
< 0 || i
>= from
;
1051 inner
= make_cleanup_py_decref (item
);
1053 if (!PyArg_ParseTuple (item
, "sO", &name
, &py_v
))
1054 error (_("Invalid item from the child list"));
1056 v
= convert_value_from_python (py_v
);
1058 gdbpy_print_stack ();
1059 install_dynamic_child (var
, can_mention
? changed
: NULL
,
1060 can_mention
? new : NULL
,
1061 can_mention
? unchanged
: NULL
,
1062 can_mention
? cchanged
: NULL
, i
, name
, v
);
1063 do_cleanups (inner
);
1067 Py_XDECREF (var
->saved_item
);
1068 var
->saved_item
= item
;
1070 /* We want to truncate the child list just before this
1076 if (i
< VEC_length (varobj_p
, var
->children
))
1081 for (j
= i
; j
< VEC_length (varobj_p
, var
->children
); ++j
)
1082 varobj_delete (VEC_index (varobj_p
, var
->children
, j
), NULL
, 0);
1083 VEC_truncate (varobj_p
, var
->children
, i
);
1086 /* If there are fewer children than requested, note that the list of
1087 children changed. */
1088 if (to
>= 0 && VEC_length (varobj_p
, var
->children
) < to
)
1091 var
->num_children
= VEC_length (varobj_p
, var
->children
);
1093 do_cleanups (back_to
);
1097 gdb_assert (0 && "should never be called if Python is not enabled");
1102 varobj_get_num_children (struct varobj
*var
)
1104 if (var
->num_children
== -1)
1106 if (var
->pretty_printer
)
1110 /* If we have a dynamic varobj, don't report -1 children.
1111 So, try to fetch some children first. */
1112 update_dynamic_varobj_children (var
, NULL
, NULL
, NULL
, &dummy
,
1116 var
->num_children
= number_of_children (var
);
1119 return var
->num_children
>= 0 ? var
->num_children
: 0;
1122 /* Creates a list of the immediate children of a variable object;
1123 the return code is the number of such children or -1 on error. */
1126 varobj_list_children (struct varobj
*var
, int *from
, int *to
)
1129 int i
, children_changed
;
1131 var
->children_requested
= 1;
1133 if (var
->pretty_printer
)
1135 /* This, in theory, can result in the number of children changing without
1136 frontend noticing. But well, calling -var-list-children on the same
1137 varobj twice is not something a sane frontend would do. */
1138 update_dynamic_varobj_children (var
, NULL
, NULL
, NULL
, &children_changed
,
1140 restrict_range (var
->children
, from
, to
);
1141 return var
->children
;
1144 if (var
->num_children
== -1)
1145 var
->num_children
= number_of_children (var
);
1147 /* If that failed, give up. */
1148 if (var
->num_children
== -1)
1149 return var
->children
;
1151 /* If we're called when the list of children is not yet initialized,
1152 allocate enough elements in it. */
1153 while (VEC_length (varobj_p
, var
->children
) < var
->num_children
)
1154 VEC_safe_push (varobj_p
, var
->children
, NULL
);
1156 for (i
= 0; i
< var
->num_children
; i
++)
1158 varobj_p existing
= VEC_index (varobj_p
, var
->children
, i
);
1160 if (existing
== NULL
)
1162 /* Either it's the first call to varobj_list_children for
1163 this variable object, and the child was never created,
1164 or it was explicitly deleted by the client. */
1165 name
= name_of_child (var
, i
);
1166 existing
= create_child (var
, i
, name
);
1167 VEC_replace (varobj_p
, var
->children
, i
, existing
);
1171 restrict_range (var
->children
, from
, to
);
1172 return var
->children
;
1177 static struct varobj
*
1178 varobj_add_child (struct varobj
*var
, const char *name
, struct value
*value
)
1180 varobj_p v
= create_child_with_value (var
,
1181 VEC_length (varobj_p
, var
->children
),
1184 VEC_safe_push (varobj_p
, var
->children
, v
);
1188 #endif /* HAVE_PYTHON */
1190 /* Obtain the type of an object Variable as a string similar to the one gdb
1191 prints on the console. */
1194 varobj_get_type (struct varobj
*var
)
1196 /* For the "fake" variables, do not return a type. (It's type is
1198 Do not return a type for invalid variables as well. */
1199 if (CPLUS_FAKE_CHILD (var
) || !var
->root
->is_valid
)
1202 return type_to_string (var
->type
);
1205 /* Obtain the type of an object variable. */
1208 varobj_get_gdb_type (struct varobj
*var
)
1213 /* Return a pointer to the full rooted expression of varobj VAR.
1214 If it has not been computed yet, compute it. */
1216 varobj_get_path_expr (struct varobj
*var
)
1218 if (var
->path_expr
!= NULL
)
1219 return var
->path_expr
;
1222 /* For root varobjs, we initialize path_expr
1223 when creating varobj, so here it should be
1225 gdb_assert (!is_root_p (var
));
1226 return (*var
->root
->lang
->path_expr_of_child
) (var
);
1230 enum varobj_languages
1231 varobj_get_language (struct varobj
*var
)
1233 return variable_language (var
);
1237 varobj_get_attributes (struct varobj
*var
)
1241 if (varobj_editable_p (var
))
1242 /* FIXME: define masks for attributes. */
1243 attributes
|= 0x00000001; /* Editable */
1249 varobj_pretty_printed_p (struct varobj
*var
)
1251 return var
->pretty_printer
!= NULL
;
1255 varobj_get_formatted_value (struct varobj
*var
,
1256 enum varobj_display_formats format
)
1258 return my_value_of_variable (var
, format
);
1262 varobj_get_value (struct varobj
*var
)
1264 return my_value_of_variable (var
, var
->format
);
1267 /* Set the value of an object variable (if it is editable) to the
1268 value of the given expression. */
1269 /* Note: Invokes functions that can call error(). */
1272 varobj_set_value (struct varobj
*var
, char *expression
)
1276 /* The argument "expression" contains the variable's new value.
1277 We need to first construct a legal expression for this -- ugh! */
1278 /* Does this cover all the bases? */
1279 struct expression
*exp
;
1280 struct value
*value
;
1281 int saved_input_radix
= input_radix
;
1282 char *s
= expression
;
1284 gdb_assert (varobj_editable_p (var
));
1286 input_radix
= 10; /* ALWAYS reset to decimal temporarily. */
1287 exp
= parse_exp_1 (&s
, 0, 0);
1288 if (!gdb_evaluate_expression (exp
, &value
))
1290 /* We cannot proceed without a valid expression. */
1295 /* All types that are editable must also be changeable. */
1296 gdb_assert (varobj_value_is_changeable_p (var
));
1298 /* The value of a changeable variable object must not be lazy. */
1299 gdb_assert (!value_lazy (var
->value
));
1301 /* Need to coerce the input. We want to check if the
1302 value of the variable object will be different
1303 after assignment, and the first thing value_assign
1304 does is coerce the input.
1305 For example, if we are assigning an array to a pointer variable we
1306 should compare the pointer with the array's address, not with the
1308 value
= coerce_array (value
);
1310 /* The new value may be lazy. gdb_value_assign, or
1311 rather value_contents, will take care of this.
1312 If fetching of the new value will fail, gdb_value_assign
1313 with catch the exception. */
1314 if (!gdb_value_assign (var
->value
, value
, &val
))
1317 /* If the value has changed, record it, so that next -var-update can
1318 report this change. If a variable had a value of '1', we've set it
1319 to '333' and then set again to '1', when -var-update will report this
1320 variable as changed -- because the first assignment has set the
1321 'updated' flag. There's no need to optimize that, because return value
1322 of -var-update should be considered an approximation. */
1323 var
->updated
= install_new_value (var
, val
, 0 /* Compare values. */);
1324 input_radix
= saved_input_radix
;
1330 /* A helper function to install a constructor function and visualizer
1334 install_visualizer (struct varobj
*var
, PyObject
*constructor
,
1335 PyObject
*visualizer
)
1337 Py_XDECREF (var
->constructor
);
1338 var
->constructor
= constructor
;
1340 Py_XDECREF (var
->pretty_printer
);
1341 var
->pretty_printer
= visualizer
;
1343 Py_XDECREF (var
->child_iter
);
1344 var
->child_iter
= NULL
;
1347 /* Install the default visualizer for VAR. */
1350 install_default_visualizer (struct varobj
*var
)
1352 if (pretty_printing
)
1354 PyObject
*pretty_printer
= NULL
;
1358 pretty_printer
= gdbpy_get_varobj_pretty_printer (var
->value
);
1359 if (! pretty_printer
)
1361 gdbpy_print_stack ();
1362 error (_("Cannot instantiate printer for default visualizer"));
1366 if (pretty_printer
== Py_None
)
1368 Py_DECREF (pretty_printer
);
1369 pretty_printer
= NULL
;
1372 install_visualizer (var
, NULL
, pretty_printer
);
1376 /* Instantiate and install a visualizer for VAR using CONSTRUCTOR to
1377 make a new object. */
1380 construct_visualizer (struct varobj
*var
, PyObject
*constructor
)
1382 PyObject
*pretty_printer
;
1384 Py_INCREF (constructor
);
1385 if (constructor
== Py_None
)
1386 pretty_printer
= NULL
;
1389 pretty_printer
= instantiate_pretty_printer (constructor
, var
->value
);
1390 if (! pretty_printer
)
1392 gdbpy_print_stack ();
1393 Py_DECREF (constructor
);
1394 constructor
= Py_None
;
1395 Py_INCREF (constructor
);
1398 if (pretty_printer
== Py_None
)
1400 Py_DECREF (pretty_printer
);
1401 pretty_printer
= NULL
;
1405 install_visualizer (var
, constructor
, pretty_printer
);
1408 #endif /* HAVE_PYTHON */
1410 /* A helper function for install_new_value. This creates and installs
1411 a visualizer for VAR, if appropriate. */
1414 install_new_value_visualizer (struct varobj
*var
)
1417 /* If the constructor is None, then we want the raw value. If VAR
1418 does not have a value, just skip this. */
1419 if (var
->constructor
!= Py_None
&& var
->value
)
1421 struct cleanup
*cleanup
;
1423 cleanup
= varobj_ensure_python_env (var
);
1425 if (!var
->constructor
)
1426 install_default_visualizer (var
);
1428 construct_visualizer (var
, var
->constructor
);
1430 do_cleanups (cleanup
);
1437 /* Assign a new value to a variable object. If INITIAL is non-zero,
1438 this is the first assignement after the variable object was just
1439 created, or changed type. In that case, just assign the value
1441 Otherwise, assign the new value, and return 1 if the value is
1442 different from the current one, 0 otherwise. The comparison is
1443 done on textual representation of value. Therefore, some types
1444 need not be compared. E.g. for structures the reported value is
1445 always "{...}", so no comparison is necessary here. If the old
1446 value was NULL and new one is not, or vice versa, we always return 1.
1448 The VALUE parameter should not be released -- the function will
1449 take care of releasing it when needed. */
1451 install_new_value (struct varobj
*var
, struct value
*value
, int initial
)
1456 int intentionally_not_fetched
= 0;
1457 char *print_value
= NULL
;
1459 /* We need to know the varobj's type to decide if the value should
1460 be fetched or not. C++ fake children (public/protected/private)
1461 don't have a type. */
1462 gdb_assert (var
->type
|| CPLUS_FAKE_CHILD (var
));
1463 changeable
= varobj_value_is_changeable_p (var
);
1465 /* If the type has custom visualizer, we consider it to be always
1466 changeable. FIXME: need to make sure this behaviour will not
1467 mess up read-sensitive values. */
1468 if (var
->pretty_printer
)
1471 need_to_fetch
= changeable
;
1473 /* We are not interested in the address of references, and given
1474 that in C++ a reference is not rebindable, it cannot
1475 meaningfully change. So, get hold of the real value. */
1477 value
= coerce_ref (value
);
1479 if (var
->type
&& TYPE_CODE (var
->type
) == TYPE_CODE_UNION
)
1480 /* For unions, we need to fetch the value implicitly because
1481 of implementation of union member fetch. When gdb
1482 creates a value for a field and the value of the enclosing
1483 structure is not lazy, it immediately copies the necessary
1484 bytes from the enclosing values. If the enclosing value is
1485 lazy, the call to value_fetch_lazy on the field will read
1486 the data from memory. For unions, that means we'll read the
1487 same memory more than once, which is not desirable. So
1491 /* The new value might be lazy. If the type is changeable,
1492 that is we'll be comparing values of this type, fetch the
1493 value now. Otherwise, on the next update the old value
1494 will be lazy, which means we've lost that old value. */
1495 if (need_to_fetch
&& value
&& value_lazy (value
))
1497 struct varobj
*parent
= var
->parent
;
1498 int frozen
= var
->frozen
;
1500 for (; !frozen
&& parent
; parent
= parent
->parent
)
1501 frozen
|= parent
->frozen
;
1503 if (frozen
&& initial
)
1505 /* For variables that are frozen, or are children of frozen
1506 variables, we don't do fetch on initial assignment.
1507 For non-initial assignemnt we do the fetch, since it means we're
1508 explicitly asked to compare the new value with the old one. */
1509 intentionally_not_fetched
= 1;
1511 else if (!gdb_value_fetch_lazy (value
))
1513 /* Set the value to NULL, so that for the next -var-update,
1514 we don't try to compare the new value with this value,
1515 that we couldn't even read. */
1521 /* Below, we'll be comparing string rendering of old and new
1522 values. Don't get string rendering if the value is
1523 lazy -- if it is, the code above has decided that the value
1524 should not be fetched. */
1525 if (value
&& !value_lazy (value
) && !var
->pretty_printer
)
1526 print_value
= value_get_print_value (value
, var
->format
, var
);
1528 /* If the type is changeable, compare the old and the new values.
1529 If this is the initial assignment, we don't have any old value
1531 if (!initial
&& changeable
)
1533 /* If the value of the varobj was changed by -var-set-value,
1534 then the value in the varobj and in the target is the same.
1535 However, that value is different from the value that the
1536 varobj had after the previous -var-update. So need to the
1537 varobj as changed. */
1542 else if (! var
->pretty_printer
)
1544 /* Try to compare the values. That requires that both
1545 values are non-lazy. */
1546 if (var
->not_fetched
&& value_lazy (var
->value
))
1548 /* This is a frozen varobj and the value was never read.
1549 Presumably, UI shows some "never read" indicator.
1550 Now that we've fetched the real value, we need to report
1551 this varobj as changed so that UI can show the real
1555 else if (var
->value
== NULL
&& value
== NULL
)
1558 else if (var
->value
== NULL
|| value
== NULL
)
1564 gdb_assert (!value_lazy (var
->value
));
1565 gdb_assert (!value_lazy (value
));
1567 gdb_assert (var
->print_value
!= NULL
&& print_value
!= NULL
);
1568 if (strcmp (var
->print_value
, print_value
) != 0)
1574 if (!initial
&& !changeable
)
1576 /* For values that are not changeable, we don't compare the values.
1577 However, we want to notice if a value was not NULL and now is NULL,
1578 or vise versa, so that we report when top-level varobjs come in scope
1579 and leave the scope. */
1580 changed
= (var
->value
!= NULL
) != (value
!= NULL
);
1583 /* We must always keep the new value, since children depend on it. */
1584 if (var
->value
!= NULL
&& var
->value
!= value
)
1585 value_free (var
->value
);
1588 value_incref (value
);
1589 if (value
&& value_lazy (value
) && intentionally_not_fetched
)
1590 var
->not_fetched
= 1;
1592 var
->not_fetched
= 0;
1595 install_new_value_visualizer (var
);
1597 /* If we installed a pretty-printer, re-compare the printed version
1598 to see if the variable changed. */
1599 if (var
->pretty_printer
)
1601 xfree (print_value
);
1602 print_value
= value_get_print_value (var
->value
, var
->format
, var
);
1603 if ((var
->print_value
== NULL
&& print_value
!= NULL
)
1604 || (var
->print_value
!= NULL
&& print_value
== NULL
)
1605 || (var
->print_value
!= NULL
&& print_value
!= NULL
1606 && strcmp (var
->print_value
, print_value
) != 0))
1609 if (var
->print_value
)
1610 xfree (var
->print_value
);
1611 var
->print_value
= print_value
;
1613 gdb_assert (!var
->value
|| value_type (var
->value
));
1618 /* Return the requested range for a varobj. VAR is the varobj. FROM
1619 and TO are out parameters; *FROM and *TO will be set to the
1620 selected sub-range of VAR. If no range was selected using
1621 -var-set-update-range, then both will be -1. */
1623 varobj_get_child_range (struct varobj
*var
, int *from
, int *to
)
1629 /* Set the selected sub-range of children of VAR to start at index
1630 FROM and end at index TO. If either FROM or TO is less than zero,
1631 this is interpreted as a request for all children. */
1633 varobj_set_child_range (struct varobj
*var
, int from
, int to
)
1640 varobj_set_visualizer (struct varobj
*var
, const char *visualizer
)
1643 PyObject
*mainmod
, *globals
, *constructor
;
1644 struct cleanup
*back_to
;
1646 back_to
= varobj_ensure_python_env (var
);
1648 mainmod
= PyImport_AddModule ("__main__");
1649 globals
= PyModule_GetDict (mainmod
);
1650 Py_INCREF (globals
);
1651 make_cleanup_py_decref (globals
);
1653 constructor
= PyRun_String (visualizer
, Py_eval_input
, globals
, globals
);
1657 gdbpy_print_stack ();
1658 error (_("Could not evaluate visualizer expression: %s"), visualizer
);
1661 construct_visualizer (var
, constructor
);
1662 Py_XDECREF (constructor
);
1664 /* If there are any children now, wipe them. */
1665 varobj_delete (var
, NULL
, 1 /* children only */);
1666 var
->num_children
= -1;
1668 do_cleanups (back_to
);
1670 error (_("Python support required"));
1674 /* Update the values for a variable and its children. This is a
1675 two-pronged attack. First, re-parse the value for the root's
1676 expression to see if it's changed. Then go all the way
1677 through its children, reconstructing them and noting if they've
1680 The EXPLICIT parameter specifies if this call is result
1681 of MI request to update this specific variable, or
1682 result of implicit -var-update *. For implicit request, we don't
1683 update frozen variables.
1685 NOTE: This function may delete the caller's varobj. If it
1686 returns TYPE_CHANGED, then it has done this and VARP will be modified
1687 to point to the new varobj. */
1689 VEC(varobj_update_result
) *varobj_update (struct varobj
**varp
, int explicit)
1692 int type_changed
= 0;
1695 VEC (varobj_update_result
) *stack
= NULL
;
1696 VEC (varobj_update_result
) *result
= NULL
;
1698 /* Frozen means frozen -- we don't check for any change in
1699 this varobj, including its going out of scope, or
1700 changing type. One use case for frozen varobjs is
1701 retaining previously evaluated expressions, and we don't
1702 want them to be reevaluated at all. */
1703 if (!explicit && (*varp
)->frozen
)
1706 if (!(*varp
)->root
->is_valid
)
1708 varobj_update_result r
= {0};
1711 r
.status
= VAROBJ_INVALID
;
1712 VEC_safe_push (varobj_update_result
, result
, &r
);
1716 if ((*varp
)->root
->rootvar
== *varp
)
1718 varobj_update_result r
= {0};
1721 r
.status
= VAROBJ_IN_SCOPE
;
1723 /* Update the root variable. value_of_root can return NULL
1724 if the variable is no longer around, i.e. we stepped out of
1725 the frame in which a local existed. We are letting the
1726 value_of_root variable dispose of the varobj if the type
1728 new = value_of_root (varp
, &type_changed
);
1731 r
.type_changed
= type_changed
;
1732 if (install_new_value ((*varp
), new, type_changed
))
1736 r
.status
= VAROBJ_NOT_IN_SCOPE
;
1737 r
.value_installed
= 1;
1739 if (r
.status
== VAROBJ_NOT_IN_SCOPE
)
1741 if (r
.type_changed
|| r
.changed
)
1742 VEC_safe_push (varobj_update_result
, result
, &r
);
1746 VEC_safe_push (varobj_update_result
, stack
, &r
);
1750 varobj_update_result r
= {0};
1753 VEC_safe_push (varobj_update_result
, stack
, &r
);
1756 /* Walk through the children, reconstructing them all. */
1757 while (!VEC_empty (varobj_update_result
, stack
))
1759 varobj_update_result r
= *(VEC_last (varobj_update_result
, stack
));
1760 struct varobj
*v
= r
.varobj
;
1762 VEC_pop (varobj_update_result
, stack
);
1764 /* Update this variable, unless it's a root, which is already
1766 if (!r
.value_installed
)
1768 new = value_of_child (v
->parent
, v
->index
);
1769 if (install_new_value (v
, new, 0 /* type not changed */))
1776 /* We probably should not get children of a varobj that has a
1777 pretty-printer, but for which -var-list-children was never
1779 if (v
->pretty_printer
)
1781 VEC (varobj_p
) *changed
= 0, *new = 0, *unchanged
= 0;
1782 int i
, children_changed
= 0;
1787 if (!v
->children_requested
)
1791 /* If we initially did not have potential children, but
1792 now we do, consider the varobj as changed.
1793 Otherwise, if children were never requested, consider
1794 it as unchanged -- presumably, such varobj is not yet
1795 expanded in the UI, so we need not bother getting
1797 if (!varobj_has_more (v
, 0))
1799 update_dynamic_varobj_children (v
, NULL
, NULL
, NULL
,
1801 if (varobj_has_more (v
, 0))
1806 VEC_safe_push (varobj_update_result
, result
, &r
);
1811 /* If update_dynamic_varobj_children returns 0, then we have
1812 a non-conforming pretty-printer, so we skip it. */
1813 if (update_dynamic_varobj_children (v
, &changed
, &new, &unchanged
,
1814 &children_changed
, 1,
1817 if (children_changed
|| new)
1819 r
.children_changed
= 1;
1822 /* Push in reverse order so that the first child is
1823 popped from the work stack first, and so will be
1824 added to result first. This does not affect
1825 correctness, just "nicer". */
1826 for (i
= VEC_length (varobj_p
, changed
) - 1; i
>= 0; --i
)
1828 varobj_p tmp
= VEC_index (varobj_p
, changed
, i
);
1829 varobj_update_result r
= {0};
1833 r
.value_installed
= 1;
1834 VEC_safe_push (varobj_update_result
, stack
, &r
);
1836 for (i
= VEC_length (varobj_p
, unchanged
) - 1; i
>= 0; --i
)
1838 varobj_p tmp
= VEC_index (varobj_p
, unchanged
, i
);
1842 varobj_update_result r
= {0};
1845 r
.value_installed
= 1;
1846 VEC_safe_push (varobj_update_result
, stack
, &r
);
1849 if (r
.changed
|| r
.children_changed
)
1850 VEC_safe_push (varobj_update_result
, result
, &r
);
1852 /* Free CHANGED and UNCHANGED, but not NEW, because NEW
1853 has been put into the result vector. */
1854 VEC_free (varobj_p
, changed
);
1855 VEC_free (varobj_p
, unchanged
);
1861 /* Push any children. Use reverse order so that the first
1862 child is popped from the work stack first, and so
1863 will be added to result first. This does not
1864 affect correctness, just "nicer". */
1865 for (i
= VEC_length (varobj_p
, v
->children
)-1; i
>= 0; --i
)
1867 varobj_p c
= VEC_index (varobj_p
, v
->children
, i
);
1869 /* Child may be NULL if explicitly deleted by -var-delete. */
1870 if (c
!= NULL
&& !c
->frozen
)
1872 varobj_update_result r
= {0};
1875 VEC_safe_push (varobj_update_result
, stack
, &r
);
1879 if (r
.changed
|| r
.type_changed
)
1880 VEC_safe_push (varobj_update_result
, result
, &r
);
1883 VEC_free (varobj_update_result
, stack
);
1889 /* Helper functions */
1892 * Variable object construction/destruction
1896 delete_variable (struct cpstack
**resultp
, struct varobj
*var
,
1897 int only_children_p
)
1901 delete_variable_1 (resultp
, &delcount
, var
,
1902 only_children_p
, 1 /* remove_from_parent_p */ );
1907 /* Delete the variable object VAR and its children. */
1908 /* IMPORTANT NOTE: If we delete a variable which is a child
1909 and the parent is not removed we dump core. It must be always
1910 initially called with remove_from_parent_p set. */
1912 delete_variable_1 (struct cpstack
**resultp
, int *delcountp
,
1913 struct varobj
*var
, int only_children_p
,
1914 int remove_from_parent_p
)
1918 /* Delete any children of this variable, too. */
1919 for (i
= 0; i
< VEC_length (varobj_p
, var
->children
); ++i
)
1921 varobj_p child
= VEC_index (varobj_p
, var
->children
, i
);
1925 if (!remove_from_parent_p
)
1926 child
->parent
= NULL
;
1927 delete_variable_1 (resultp
, delcountp
, child
, 0, only_children_p
);
1929 VEC_free (varobj_p
, var
->children
);
1931 /* if we were called to delete only the children we are done here. */
1932 if (only_children_p
)
1935 /* Otherwise, add it to the list of deleted ones and proceed to do so. */
1936 /* If the name is null, this is a temporary variable, that has not
1937 yet been installed, don't report it, it belongs to the caller... */
1938 if (var
->obj_name
!= NULL
)
1940 cppush (resultp
, xstrdup (var
->obj_name
));
1941 *delcountp
= *delcountp
+ 1;
1944 /* If this variable has a parent, remove it from its parent's list. */
1945 /* OPTIMIZATION: if the parent of this variable is also being deleted,
1946 (as indicated by remove_from_parent_p) we don't bother doing an
1947 expensive list search to find the element to remove when we are
1948 discarding the list afterwards. */
1949 if ((remove_from_parent_p
) && (var
->parent
!= NULL
))
1951 VEC_replace (varobj_p
, var
->parent
->children
, var
->index
, NULL
);
1954 if (var
->obj_name
!= NULL
)
1955 uninstall_variable (var
);
1957 /* Free memory associated with this variable. */
1958 free_variable (var
);
1961 /* Install the given variable VAR with the object name VAR->OBJ_NAME. */
1963 install_variable (struct varobj
*var
)
1966 struct vlist
*newvl
;
1968 unsigned int index
= 0;
1971 for (chp
= var
->obj_name
; *chp
; chp
++)
1973 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
1976 cv
= *(varobj_table
+ index
);
1977 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, var
->obj_name
) != 0))
1981 error (_("Duplicate variable object name"));
1983 /* Add varobj to hash table. */
1984 newvl
= xmalloc (sizeof (struct vlist
));
1985 newvl
->next
= *(varobj_table
+ index
);
1987 *(varobj_table
+ index
) = newvl
;
1989 /* If root, add varobj to root list. */
1990 if (is_root_p (var
))
1992 /* Add to list of root variables. */
1993 if (rootlist
== NULL
)
1994 var
->root
->next
= NULL
;
1996 var
->root
->next
= rootlist
;
1997 rootlist
= var
->root
;
2003 /* Unistall the object VAR. */
2005 uninstall_variable (struct varobj
*var
)
2009 struct varobj_root
*cr
;
2010 struct varobj_root
*prer
;
2012 unsigned int index
= 0;
2015 /* Remove varobj from hash table. */
2016 for (chp
= var
->obj_name
; *chp
; chp
++)
2018 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
2021 cv
= *(varobj_table
+ index
);
2023 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, var
->obj_name
) != 0))
2030 fprintf_unfiltered (gdb_stdlog
, "Deleting %s\n", var
->obj_name
);
2035 ("Assertion failed: Could not find variable object \"%s\" to delete",
2041 *(varobj_table
+ index
) = cv
->next
;
2043 prev
->next
= cv
->next
;
2047 /* If root, remove varobj from root list. */
2048 if (is_root_p (var
))
2050 /* Remove from list of root variables. */
2051 if (rootlist
== var
->root
)
2052 rootlist
= var
->root
->next
;
2057 while ((cr
!= NULL
) && (cr
->rootvar
!= var
))
2064 warning (_("Assertion failed: Could not find "
2065 "varobj \"%s\" in root list"),
2072 prer
->next
= cr
->next
;
2078 /* Create and install a child of the parent of the given name. */
2079 static struct varobj
*
2080 create_child (struct varobj
*parent
, int index
, char *name
)
2082 return create_child_with_value (parent
, index
, name
,
2083 value_of_child (parent
, index
));
2086 static struct varobj
*
2087 create_child_with_value (struct varobj
*parent
, int index
, const char *name
,
2088 struct value
*value
)
2090 struct varobj
*child
;
2093 child
= new_variable ();
2095 /* Name is allocated by name_of_child. */
2096 /* FIXME: xstrdup should not be here. */
2097 child
->name
= xstrdup (name
);
2098 child
->index
= index
;
2099 child
->parent
= parent
;
2100 child
->root
= parent
->root
;
2101 childs_name
= xstrprintf ("%s.%s", parent
->obj_name
, name
);
2102 child
->obj_name
= childs_name
;
2103 install_variable (child
);
2105 /* Compute the type of the child. Must do this before
2106 calling install_new_value. */
2108 /* If the child had no evaluation errors, var->value
2109 will be non-NULL and contain a valid type. */
2110 child
->type
= value_type (value
);
2112 /* Otherwise, we must compute the type. */
2113 child
->type
= (*child
->root
->lang
->type_of_child
) (child
->parent
,
2115 install_new_value (child
, value
, 1);
2122 * Miscellaneous utility functions.
2125 /* Allocate memory and initialize a new variable. */
2126 static struct varobj
*
2131 var
= (struct varobj
*) xmalloc (sizeof (struct varobj
));
2133 var
->path_expr
= NULL
;
2134 var
->obj_name
= NULL
;
2138 var
->num_children
= -1;
2140 var
->children
= NULL
;
2144 var
->print_value
= NULL
;
2146 var
->not_fetched
= 0;
2147 var
->children_requested
= 0;
2150 var
->constructor
= 0;
2151 var
->pretty_printer
= 0;
2152 var
->child_iter
= 0;
2153 var
->saved_item
= 0;
2158 /* Allocate memory and initialize a new root variable. */
2159 static struct varobj
*
2160 new_root_variable (void)
2162 struct varobj
*var
= new_variable ();
2164 var
->root
= (struct varobj_root
*) xmalloc (sizeof (struct varobj_root
));
2165 var
->root
->lang
= NULL
;
2166 var
->root
->exp
= NULL
;
2167 var
->root
->valid_block
= NULL
;
2168 var
->root
->frame
= null_frame_id
;
2169 var
->root
->floating
= 0;
2170 var
->root
->rootvar
= NULL
;
2171 var
->root
->is_valid
= 1;
2176 /* Free any allocated memory associated with VAR. */
2178 free_variable (struct varobj
*var
)
2181 if (var
->pretty_printer
)
2183 struct cleanup
*cleanup
= varobj_ensure_python_env (var
);
2184 Py_XDECREF (var
->constructor
);
2185 Py_XDECREF (var
->pretty_printer
);
2186 Py_XDECREF (var
->child_iter
);
2187 Py_XDECREF (var
->saved_item
);
2188 do_cleanups (cleanup
);
2192 value_free (var
->value
);
2194 /* Free the expression if this is a root variable. */
2195 if (is_root_p (var
))
2197 xfree (var
->root
->exp
);
2202 xfree (var
->obj_name
);
2203 xfree (var
->print_value
);
2204 xfree (var
->path_expr
);
2209 do_free_variable_cleanup (void *var
)
2211 free_variable (var
);
2214 static struct cleanup
*
2215 make_cleanup_free_variable (struct varobj
*var
)
2217 return make_cleanup (do_free_variable_cleanup
, var
);
2220 /* This returns the type of the variable. It also skips past typedefs
2221 to return the real type of the variable.
2223 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
2224 except within get_target_type and get_type. */
2225 static struct type
*
2226 get_type (struct varobj
*var
)
2232 type
= check_typedef (type
);
2237 /* Return the type of the value that's stored in VAR,
2238 or that would have being stored there if the
2239 value were accessible.
2241 This differs from VAR->type in that VAR->type is always
2242 the true type of the expession in the source language.
2243 The return value of this function is the type we're
2244 actually storing in varobj, and using for displaying
2245 the values and for comparing previous and new values.
2247 For example, top-level references are always stripped. */
2248 static struct type
*
2249 get_value_type (struct varobj
*var
)
2254 type
= value_type (var
->value
);
2258 type
= check_typedef (type
);
2260 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
2261 type
= get_target_type (type
);
2263 type
= check_typedef (type
);
2268 /* This returns the target type (or NULL) of TYPE, also skipping
2269 past typedefs, just like get_type ().
2271 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
2272 except within get_target_type and get_type. */
2273 static struct type
*
2274 get_target_type (struct type
*type
)
2278 type
= TYPE_TARGET_TYPE (type
);
2280 type
= check_typedef (type
);
2286 /* What is the default display for this variable? We assume that
2287 everything is "natural". Any exceptions? */
2288 static enum varobj_display_formats
2289 variable_default_display (struct varobj
*var
)
2291 return FORMAT_NATURAL
;
2294 /* FIXME: The following should be generic for any pointer. */
2296 cppush (struct cpstack
**pstack
, char *name
)
2300 s
= (struct cpstack
*) xmalloc (sizeof (struct cpstack
));
2306 /* FIXME: The following should be generic for any pointer. */
2308 cppop (struct cpstack
**pstack
)
2313 if ((*pstack
)->name
== NULL
&& (*pstack
)->next
== NULL
)
2318 *pstack
= (*pstack
)->next
;
2325 * Language-dependencies
2328 /* Common entry points */
2330 /* Get the language of variable VAR. */
2331 static enum varobj_languages
2332 variable_language (struct varobj
*var
)
2334 enum varobj_languages lang
;
2336 switch (var
->root
->exp
->language_defn
->la_language
)
2342 case language_cplus
:
2353 /* Return the number of children for a given variable.
2354 The result of this function is defined by the language
2355 implementation. The number of children returned by this function
2356 is the number of children that the user will see in the variable
2359 number_of_children (struct varobj
*var
)
2361 return (*var
->root
->lang
->number_of_children
) (var
);;
2364 /* What is the expression for the root varobj VAR? Returns a malloc'd
2367 name_of_variable (struct varobj
*var
)
2369 return (*var
->root
->lang
->name_of_variable
) (var
);
2372 /* What is the name of the INDEX'th child of VAR? Returns a malloc'd
2375 name_of_child (struct varobj
*var
, int index
)
2377 return (*var
->root
->lang
->name_of_child
) (var
, index
);
2380 /* What is the ``struct value *'' of the root variable VAR?
2381 For floating variable object, evaluation can get us a value
2382 of different type from what is stored in varobj already. In
2384 - *type_changed will be set to 1
2385 - old varobj will be freed, and new one will be
2386 created, with the same name.
2387 - *var_handle will be set to the new varobj
2388 Otherwise, *type_changed will be set to 0. */
2389 static struct value
*
2390 value_of_root (struct varobj
**var_handle
, int *type_changed
)
2394 if (var_handle
== NULL
)
2399 /* This should really be an exception, since this should
2400 only get called with a root variable. */
2402 if (!is_root_p (var
))
2405 if (var
->root
->floating
)
2407 struct varobj
*tmp_var
;
2408 char *old_type
, *new_type
;
2410 tmp_var
= varobj_create (NULL
, var
->name
, (CORE_ADDR
) 0,
2411 USE_SELECTED_FRAME
);
2412 if (tmp_var
== NULL
)
2416 old_type
= varobj_get_type (var
);
2417 new_type
= varobj_get_type (tmp_var
);
2418 if (strcmp (old_type
, new_type
) == 0)
2420 /* The expression presently stored inside var->root->exp
2421 remembers the locations of local variables relatively to
2422 the frame where the expression was created (in DWARF location
2423 button, for example). Naturally, those locations are not
2424 correct in other frames, so update the expression. */
2426 struct expression
*tmp_exp
= var
->root
->exp
;
2428 var
->root
->exp
= tmp_var
->root
->exp
;
2429 tmp_var
->root
->exp
= tmp_exp
;
2431 varobj_delete (tmp_var
, NULL
, 0);
2436 tmp_var
->obj_name
= xstrdup (var
->obj_name
);
2437 tmp_var
->from
= var
->from
;
2438 tmp_var
->to
= var
->to
;
2439 varobj_delete (var
, NULL
, 0);
2441 install_variable (tmp_var
);
2442 *var_handle
= tmp_var
;
2454 return (*var
->root
->lang
->value_of_root
) (var_handle
);
2457 /* What is the ``struct value *'' for the INDEX'th child of PARENT? */
2458 static struct value
*
2459 value_of_child (struct varobj
*parent
, int index
)
2461 struct value
*value
;
2463 value
= (*parent
->root
->lang
->value_of_child
) (parent
, index
);
2468 /* GDB already has a command called "value_of_variable". Sigh. */
2470 my_value_of_variable (struct varobj
*var
, enum varobj_display_formats format
)
2472 if (var
->root
->is_valid
)
2474 if (var
->pretty_printer
)
2475 return value_get_print_value (var
->value
, var
->format
, var
);
2476 return (*var
->root
->lang
->value_of_variable
) (var
, format
);
2483 value_get_print_value (struct value
*value
, enum varobj_display_formats format
,
2486 struct ui_file
*stb
;
2487 struct cleanup
*old_chain
;
2488 gdb_byte
*thevalue
= NULL
;
2489 struct value_print_options opts
;
2490 struct type
*type
= NULL
;
2492 char *encoding
= NULL
;
2493 struct gdbarch
*gdbarch
= NULL
;
2494 /* Initialize it just to avoid a GCC false warning. */
2495 CORE_ADDR str_addr
= 0;
2496 int string_print
= 0;
2501 stb
= mem_fileopen ();
2502 old_chain
= make_cleanup_ui_file_delete (stb
);
2504 gdbarch
= get_type_arch (value_type (value
));
2507 PyObject
*value_formatter
= var
->pretty_printer
;
2509 varobj_ensure_python_env (var
);
2511 if (value_formatter
)
2513 /* First check to see if we have any children at all. If so,
2514 we simply return {...}. */
2515 if (dynamic_varobj_has_child_method (var
))
2517 do_cleanups (old_chain
);
2518 return xstrdup ("{...}");
2521 if (PyObject_HasAttr (value_formatter
, gdbpy_to_string_cst
))
2524 struct value
*replacement
;
2525 PyObject
*output
= NULL
;
2527 hint
= gdbpy_get_display_hint (value_formatter
);
2530 if (!strcmp (hint
, "string"))
2535 output
= apply_varobj_pretty_printer (value_formatter
,
2540 make_cleanup_py_decref (output
);
2542 if (gdbpy_is_lazy_string (output
))
2544 gdbpy_extract_lazy_string (output
, &str_addr
, &type
,
2546 make_cleanup (free_current_contents
, &encoding
);
2552 = python_string_to_target_python_string (output
);
2556 char *s
= PyString_AsString (py_str
);
2558 len
= PyString_Size (py_str
);
2559 thevalue
= xmemdup (s
, len
+ 1, len
+ 1);
2560 type
= builtin_type (gdbarch
)->builtin_char
;
2565 do_cleanups (old_chain
);
2569 make_cleanup (xfree
, thevalue
);
2572 gdbpy_print_stack ();
2576 value
= replacement
;
2582 get_formatted_print_options (&opts
, format_code
[(int) format
]);
2586 LA_PRINT_STRING (stb
, type
, thevalue
, len
, encoding
, 0, &opts
);
2587 else if (string_print
)
2588 val_print_string (type
, encoding
, str_addr
, len
, stb
, &opts
);
2590 common_val_print (value
, stb
, 0, &opts
, current_language
);
2591 thevalue
= ui_file_xstrdup (stb
, NULL
);
2593 do_cleanups (old_chain
);
2598 varobj_editable_p (struct varobj
*var
)
2602 if (!(var
->root
->is_valid
&& var
->value
&& VALUE_LVAL (var
->value
)))
2605 type
= get_value_type (var
);
2607 switch (TYPE_CODE (type
))
2609 case TYPE_CODE_STRUCT
:
2610 case TYPE_CODE_UNION
:
2611 case TYPE_CODE_ARRAY
:
2612 case TYPE_CODE_FUNC
:
2613 case TYPE_CODE_METHOD
:
2623 /* Return non-zero if changes in value of VAR
2624 must be detected and reported by -var-update.
2625 Return zero is -var-update should never report
2626 changes of such values. This makes sense for structures
2627 (since the changes in children values will be reported separately),
2628 or for artifical objects (like 'public' pseudo-field in C++).
2630 Return value of 0 means that gdb need not call value_fetch_lazy
2631 for the value of this variable object. */
2633 varobj_value_is_changeable_p (struct varobj
*var
)
2638 if (CPLUS_FAKE_CHILD (var
))
2641 type
= get_value_type (var
);
2643 switch (TYPE_CODE (type
))
2645 case TYPE_CODE_STRUCT
:
2646 case TYPE_CODE_UNION
:
2647 case TYPE_CODE_ARRAY
:
2658 /* Return 1 if that varobj is floating, that is is always evaluated in the
2659 selected frame, and not bound to thread/frame. Such variable objects
2660 are created using '@' as frame specifier to -var-create. */
2662 varobj_floating_p (struct varobj
*var
)
2664 return var
->root
->floating
;
2667 /* Given the value and the type of a variable object,
2668 adjust the value and type to those necessary
2669 for getting children of the variable object.
2670 This includes dereferencing top-level references
2671 to all types and dereferencing pointers to
2674 Both TYPE and *TYPE should be non-null. VALUE
2675 can be null if we want to only translate type.
2676 *VALUE can be null as well -- if the parent
2679 If WAS_PTR is not NULL, set *WAS_PTR to 0 or 1
2680 depending on whether pointer was dereferenced
2681 in this function. */
2683 adjust_value_for_child_access (struct value
**value
,
2687 gdb_assert (type
&& *type
);
2692 *type
= check_typedef (*type
);
2694 /* The type of value stored in varobj, that is passed
2695 to us, is already supposed to be
2696 reference-stripped. */
2698 gdb_assert (TYPE_CODE (*type
) != TYPE_CODE_REF
);
2700 /* Pointers to structures are treated just like
2701 structures when accessing children. Don't
2702 dererences pointers to other types. */
2703 if (TYPE_CODE (*type
) == TYPE_CODE_PTR
)
2705 struct type
*target_type
= get_target_type (*type
);
2706 if (TYPE_CODE (target_type
) == TYPE_CODE_STRUCT
2707 || TYPE_CODE (target_type
) == TYPE_CODE_UNION
)
2709 if (value
&& *value
)
2711 int success
= gdb_value_ind (*value
, value
);
2716 *type
= target_type
;
2722 /* The 'get_target_type' function calls check_typedef on
2723 result, so we can immediately check type code. No
2724 need to call check_typedef here. */
2729 c_number_of_children (struct varobj
*var
)
2731 struct type
*type
= get_value_type (var
);
2733 struct type
*target
;
2735 adjust_value_for_child_access (NULL
, &type
, NULL
);
2736 target
= get_target_type (type
);
2738 switch (TYPE_CODE (type
))
2740 case TYPE_CODE_ARRAY
:
2741 if (TYPE_LENGTH (type
) > 0 && TYPE_LENGTH (target
) > 0
2742 && !TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type
))
2743 children
= TYPE_LENGTH (type
) / TYPE_LENGTH (target
);
2745 /* If we don't know how many elements there are, don't display
2750 case TYPE_CODE_STRUCT
:
2751 case TYPE_CODE_UNION
:
2752 children
= TYPE_NFIELDS (type
);
2756 /* The type here is a pointer to non-struct. Typically, pointers
2757 have one child, except for function ptrs, which have no children,
2758 and except for void*, as we don't know what to show.
2760 We can show char* so we allow it to be dereferenced. If you decide
2761 to test for it, please mind that a little magic is necessary to
2762 properly identify it: char* has TYPE_CODE == TYPE_CODE_INT and
2763 TYPE_NAME == "char". */
2764 if (TYPE_CODE (target
) == TYPE_CODE_FUNC
2765 || TYPE_CODE (target
) == TYPE_CODE_VOID
)
2772 /* Other types have no children. */
2780 c_name_of_variable (struct varobj
*parent
)
2782 return xstrdup (parent
->name
);
2785 /* Return the value of element TYPE_INDEX of a structure
2786 value VALUE. VALUE's type should be a structure,
2787 or union, or a typedef to struct/union.
2789 Returns NULL if getting the value fails. Never throws. */
2790 static struct value
*
2791 value_struct_element_index (struct value
*value
, int type_index
)
2793 struct value
*result
= NULL
;
2794 volatile struct gdb_exception e
;
2795 struct type
*type
= value_type (value
);
2797 type
= check_typedef (type
);
2799 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
2800 || TYPE_CODE (type
) == TYPE_CODE_UNION
);
2802 TRY_CATCH (e
, RETURN_MASK_ERROR
)
2804 if (field_is_static (&TYPE_FIELD (type
, type_index
)))
2805 result
= value_static_field (type
, type_index
);
2807 result
= value_primitive_field (value
, 0, type_index
, type
);
2819 /* Obtain the information about child INDEX of the variable
2821 If CNAME is not null, sets *CNAME to the name of the child relative
2823 If CVALUE is not null, sets *CVALUE to the value of the child.
2824 If CTYPE is not null, sets *CTYPE to the type of the child.
2826 If any of CNAME, CVALUE, or CTYPE is not null, but the corresponding
2827 information cannot be determined, set *CNAME, *CVALUE, or *CTYPE
2830 c_describe_child (struct varobj
*parent
, int index
,
2831 char **cname
, struct value
**cvalue
, struct type
**ctype
,
2832 char **cfull_expression
)
2834 struct value
*value
= parent
->value
;
2835 struct type
*type
= get_value_type (parent
);
2836 char *parent_expression
= NULL
;
2845 if (cfull_expression
)
2847 *cfull_expression
= NULL
;
2848 parent_expression
= varobj_get_path_expr (parent
);
2850 adjust_value_for_child_access (&value
, &type
, &was_ptr
);
2852 switch (TYPE_CODE (type
))
2854 case TYPE_CODE_ARRAY
:
2857 = xstrdup (int_string (index
2858 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
)),
2861 if (cvalue
&& value
)
2863 int real_index
= index
+ TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
));
2865 gdb_value_subscript (value
, real_index
, cvalue
);
2869 *ctype
= get_target_type (type
);
2871 if (cfull_expression
)
2873 xstrprintf ("(%s)[%s]", parent_expression
,
2875 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
)),
2881 case TYPE_CODE_STRUCT
:
2882 case TYPE_CODE_UNION
:
2884 *cname
= xstrdup (TYPE_FIELD_NAME (type
, index
));
2886 if (cvalue
&& value
)
2888 /* For C, varobj index is the same as type index. */
2889 *cvalue
= value_struct_element_index (value
, index
);
2893 *ctype
= TYPE_FIELD_TYPE (type
, index
);
2895 if (cfull_expression
)
2897 char *join
= was_ptr
? "->" : ".";
2899 *cfull_expression
= xstrprintf ("(%s)%s%s", parent_expression
, join
,
2900 TYPE_FIELD_NAME (type
, index
));
2907 *cname
= xstrprintf ("*%s", parent
->name
);
2909 if (cvalue
&& value
)
2911 int success
= gdb_value_ind (value
, cvalue
);
2917 /* Don't use get_target_type because it calls
2918 check_typedef and here, we want to show the true
2919 declared type of the variable. */
2921 *ctype
= TYPE_TARGET_TYPE (type
);
2923 if (cfull_expression
)
2924 *cfull_expression
= xstrprintf ("*(%s)", parent_expression
);
2929 /* This should not happen. */
2931 *cname
= xstrdup ("???");
2932 if (cfull_expression
)
2933 *cfull_expression
= xstrdup ("???");
2934 /* Don't set value and type, we don't know then. */
2939 c_name_of_child (struct varobj
*parent
, int index
)
2943 c_describe_child (parent
, index
, &name
, NULL
, NULL
, NULL
);
2948 c_path_expr_of_child (struct varobj
*child
)
2950 c_describe_child (child
->parent
, child
->index
, NULL
, NULL
, NULL
,
2952 return child
->path_expr
;
2955 /* If frame associated with VAR can be found, switch
2956 to it and return 1. Otherwise, return 0. */
2958 check_scope (struct varobj
*var
)
2960 struct frame_info
*fi
;
2963 fi
= frame_find_by_id (var
->root
->frame
);
2968 CORE_ADDR pc
= get_frame_pc (fi
);
2970 if (pc
< BLOCK_START (var
->root
->valid_block
) ||
2971 pc
>= BLOCK_END (var
->root
->valid_block
))
2979 static struct value
*
2980 c_value_of_root (struct varobj
**var_handle
)
2982 struct value
*new_val
= NULL
;
2983 struct varobj
*var
= *var_handle
;
2984 int within_scope
= 0;
2985 struct cleanup
*back_to
;
2987 /* Only root variables can be updated... */
2988 if (!is_root_p (var
))
2989 /* Not a root var. */
2992 back_to
= make_cleanup_restore_current_thread ();
2994 /* Determine whether the variable is still around. */
2995 if (var
->root
->valid_block
== NULL
|| var
->root
->floating
)
2997 else if (var
->root
->thread_id
== 0)
2999 /* The program was single-threaded when the variable object was
3000 created. Technically, it's possible that the program became
3001 multi-threaded since then, but we don't support such
3003 within_scope
= check_scope (var
);
3007 ptid_t ptid
= thread_id_to_pid (var
->root
->thread_id
);
3008 if (in_thread_list (ptid
))
3010 switch_to_thread (ptid
);
3011 within_scope
= check_scope (var
);
3017 /* We need to catch errors here, because if evaluate
3018 expression fails we want to just return NULL. */
3019 gdb_evaluate_expression (var
->root
->exp
, &new_val
);
3023 do_cleanups (back_to
);
3028 static struct value
*
3029 c_value_of_child (struct varobj
*parent
, int index
)
3031 struct value
*value
= NULL
;
3033 c_describe_child (parent
, index
, NULL
, &value
, NULL
, NULL
);
3037 static struct type
*
3038 c_type_of_child (struct varobj
*parent
, int index
)
3040 struct type
*type
= NULL
;
3042 c_describe_child (parent
, index
, NULL
, NULL
, &type
, NULL
);
3047 c_value_of_variable (struct varobj
*var
, enum varobj_display_formats format
)
3049 /* BOGUS: if val_print sees a struct/class, or a reference to one,
3050 it will print out its children instead of "{...}". So we need to
3051 catch that case explicitly. */
3052 struct type
*type
= get_type (var
);
3054 /* If we have a custom formatter, return whatever string it has
3056 if (var
->pretty_printer
&& var
->print_value
)
3057 return xstrdup (var
->print_value
);
3059 /* Strip top-level references. */
3060 while (TYPE_CODE (type
) == TYPE_CODE_REF
)
3061 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3063 switch (TYPE_CODE (type
))
3065 case TYPE_CODE_STRUCT
:
3066 case TYPE_CODE_UNION
:
3067 return xstrdup ("{...}");
3070 case TYPE_CODE_ARRAY
:
3074 number
= xstrprintf ("[%d]", var
->num_children
);
3081 if (var
->value
== NULL
)
3083 /* This can happen if we attempt to get the value of a struct
3084 member when the parent is an invalid pointer. This is an
3085 error condition, so we should tell the caller. */
3090 if (var
->not_fetched
&& value_lazy (var
->value
))
3091 /* Frozen variable and no value yet. We don't
3092 implicitly fetch the value. MI response will
3093 use empty string for the value, which is OK. */
3096 gdb_assert (varobj_value_is_changeable_p (var
));
3097 gdb_assert (!value_lazy (var
->value
));
3099 /* If the specified format is the current one,
3100 we can reuse print_value. */
3101 if (format
== var
->format
)
3102 return xstrdup (var
->print_value
);
3104 return value_get_print_value (var
->value
, format
, var
);
3114 cplus_number_of_children (struct varobj
*var
)
3117 int children
, dont_know
;
3122 if (!CPLUS_FAKE_CHILD (var
))
3124 type
= get_value_type (var
);
3125 adjust_value_for_child_access (NULL
, &type
, NULL
);
3127 if (((TYPE_CODE (type
)) == TYPE_CODE_STRUCT
) ||
3128 ((TYPE_CODE (type
)) == TYPE_CODE_UNION
))
3132 cplus_class_num_children (type
, kids
);
3133 if (kids
[v_public
] != 0)
3135 if (kids
[v_private
] != 0)
3137 if (kids
[v_protected
] != 0)
3140 /* Add any baseclasses. */
3141 children
+= TYPE_N_BASECLASSES (type
);
3144 /* FIXME: save children in var. */
3151 type
= get_value_type (var
->parent
);
3152 adjust_value_for_child_access (NULL
, &type
, NULL
);
3154 cplus_class_num_children (type
, kids
);
3155 if (strcmp (var
->name
, "public") == 0)
3156 children
= kids
[v_public
];
3157 else if (strcmp (var
->name
, "private") == 0)
3158 children
= kids
[v_private
];
3160 children
= kids
[v_protected
];
3165 children
= c_number_of_children (var
);
3170 /* Compute # of public, private, and protected variables in this class.
3171 That means we need to descend into all baseclasses and find out
3172 how many are there, too. */
3174 cplus_class_num_children (struct type
*type
, int children
[3])
3176 int i
, vptr_fieldno
;
3177 struct type
*basetype
= NULL
;
3179 children
[v_public
] = 0;
3180 children
[v_private
] = 0;
3181 children
[v_protected
] = 0;
3183 vptr_fieldno
= get_vptr_fieldno (type
, &basetype
);
3184 for (i
= TYPE_N_BASECLASSES (type
); i
< TYPE_NFIELDS (type
); i
++)
3186 /* If we have a virtual table pointer, omit it. Even if virtual
3187 table pointers are not specifically marked in the debug info,
3188 they should be artificial. */
3189 if ((type
== basetype
&& i
== vptr_fieldno
)
3190 || TYPE_FIELD_ARTIFICIAL (type
, i
))
3193 if (TYPE_FIELD_PROTECTED (type
, i
))
3194 children
[v_protected
]++;
3195 else if (TYPE_FIELD_PRIVATE (type
, i
))
3196 children
[v_private
]++;
3198 children
[v_public
]++;
3203 cplus_name_of_variable (struct varobj
*parent
)
3205 return c_name_of_variable (parent
);
3208 enum accessibility
{ private_field
, protected_field
, public_field
};
3210 /* Check if field INDEX of TYPE has the specified accessibility.
3211 Return 0 if so and 1 otherwise. */
3213 match_accessibility (struct type
*type
, int index
, enum accessibility acc
)
3215 if (acc
== private_field
&& TYPE_FIELD_PRIVATE (type
, index
))
3217 else if (acc
== protected_field
&& TYPE_FIELD_PROTECTED (type
, index
))
3219 else if (acc
== public_field
&& !TYPE_FIELD_PRIVATE (type
, index
)
3220 && !TYPE_FIELD_PROTECTED (type
, index
))
3227 cplus_describe_child (struct varobj
*parent
, int index
,
3228 char **cname
, struct value
**cvalue
, struct type
**ctype
,
3229 char **cfull_expression
)
3231 struct value
*value
;
3234 char *parent_expression
= NULL
;
3242 if (cfull_expression
)
3243 *cfull_expression
= NULL
;
3245 if (CPLUS_FAKE_CHILD (parent
))
3247 value
= parent
->parent
->value
;
3248 type
= get_value_type (parent
->parent
);
3249 if (cfull_expression
)
3250 parent_expression
= varobj_get_path_expr (parent
->parent
);
3254 value
= parent
->value
;
3255 type
= get_value_type (parent
);
3256 if (cfull_expression
)
3257 parent_expression
= varobj_get_path_expr (parent
);
3260 adjust_value_for_child_access (&value
, &type
, &was_ptr
);
3262 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
3263 || TYPE_CODE (type
) == TYPE_CODE_UNION
)
3265 char *join
= was_ptr
? "->" : ".";
3267 if (CPLUS_FAKE_CHILD (parent
))
3269 /* The fields of the class type are ordered as they
3270 appear in the class. We are given an index for a
3271 particular access control type ("public","protected",
3272 or "private"). We must skip over fields that don't
3273 have the access control we are looking for to properly
3274 find the indexed field. */
3275 int type_index
= TYPE_N_BASECLASSES (type
);
3276 enum accessibility acc
= public_field
;
3278 struct type
*basetype
= NULL
;
3280 vptr_fieldno
= get_vptr_fieldno (type
, &basetype
);
3281 if (strcmp (parent
->name
, "private") == 0)
3282 acc
= private_field
;
3283 else if (strcmp (parent
->name
, "protected") == 0)
3284 acc
= protected_field
;
3288 if ((type
== basetype
&& type_index
== vptr_fieldno
)
3289 || TYPE_FIELD_ARTIFICIAL (type
, type_index
))
3291 else if (match_accessibility (type
, type_index
, acc
))
3298 *cname
= xstrdup (TYPE_FIELD_NAME (type
, type_index
));
3300 if (cvalue
&& value
)
3301 *cvalue
= value_struct_element_index (value
, type_index
);
3304 *ctype
= TYPE_FIELD_TYPE (type
, type_index
);
3306 if (cfull_expression
)
3308 = xstrprintf ("((%s)%s%s)", parent_expression
,
3310 TYPE_FIELD_NAME (type
, type_index
));
3312 else if (index
< TYPE_N_BASECLASSES (type
))
3314 /* This is a baseclass. */
3316 *cname
= xstrdup (TYPE_FIELD_NAME (type
, index
));
3318 if (cvalue
&& value
)
3319 *cvalue
= value_cast (TYPE_FIELD_TYPE (type
, index
), value
);
3323 *ctype
= TYPE_FIELD_TYPE (type
, index
);
3326 if (cfull_expression
)
3328 char *ptr
= was_ptr
? "*" : "";
3330 /* Cast the parent to the base' type. Note that in gdb,
3333 will create an lvalue, for all appearences, so we don't
3334 need to use more fancy:
3337 *cfull_expression
= xstrprintf ("(%s(%s%s) %s)",
3339 TYPE_FIELD_NAME (type
, index
),
3346 char *access
= NULL
;
3349 cplus_class_num_children (type
, children
);
3351 /* Everything beyond the baseclasses can
3352 only be "public", "private", or "protected"
3354 The special "fake" children are always output by varobj in
3355 this order. So if INDEX == 2, it MUST be "protected". */
3356 index
-= TYPE_N_BASECLASSES (type
);
3360 if (children
[v_public
] > 0)
3362 else if (children
[v_private
] > 0)
3365 access
= "protected";
3368 if (children
[v_public
] > 0)
3370 if (children
[v_private
] > 0)
3373 access
= "protected";
3375 else if (children
[v_private
] > 0)
3376 access
= "protected";
3379 /* Must be protected. */
3380 access
= "protected";
3387 gdb_assert (access
);
3389 *cname
= xstrdup (access
);
3391 /* Value and type and full expression are null here. */
3396 c_describe_child (parent
, index
, cname
, cvalue
, ctype
, cfull_expression
);
3401 cplus_name_of_child (struct varobj
*parent
, int index
)
3405 cplus_describe_child (parent
, index
, &name
, NULL
, NULL
, NULL
);
3410 cplus_path_expr_of_child (struct varobj
*child
)
3412 cplus_describe_child (child
->parent
, child
->index
, NULL
, NULL
, NULL
,
3414 return child
->path_expr
;
3417 static struct value
*
3418 cplus_value_of_root (struct varobj
**var_handle
)
3420 return c_value_of_root (var_handle
);
3423 static struct value
*
3424 cplus_value_of_child (struct varobj
*parent
, int index
)
3426 struct value
*value
= NULL
;
3428 cplus_describe_child (parent
, index
, NULL
, &value
, NULL
, NULL
);
3432 static struct type
*
3433 cplus_type_of_child (struct varobj
*parent
, int index
)
3435 struct type
*type
= NULL
;
3437 cplus_describe_child (parent
, index
, NULL
, NULL
, &type
, NULL
);
3442 cplus_value_of_variable (struct varobj
*var
,
3443 enum varobj_display_formats format
)
3446 /* If we have one of our special types, don't print out
3448 if (CPLUS_FAKE_CHILD (var
))
3449 return xstrdup ("");
3451 return c_value_of_variable (var
, format
);
3457 java_number_of_children (struct varobj
*var
)
3459 return cplus_number_of_children (var
);
3463 java_name_of_variable (struct varobj
*parent
)
3467 name
= cplus_name_of_variable (parent
);
3468 /* If the name has "-" in it, it is because we
3469 needed to escape periods in the name... */
3472 while (*p
!= '\000')
3483 java_name_of_child (struct varobj
*parent
, int index
)
3487 name
= cplus_name_of_child (parent
, index
);
3488 /* Escape any periods in the name... */
3491 while (*p
!= '\000')
3502 java_path_expr_of_child (struct varobj
*child
)
3507 static struct value
*
3508 java_value_of_root (struct varobj
**var_handle
)
3510 return cplus_value_of_root (var_handle
);
3513 static struct value
*
3514 java_value_of_child (struct varobj
*parent
, int index
)
3516 return cplus_value_of_child (parent
, index
);
3519 static struct type
*
3520 java_type_of_child (struct varobj
*parent
, int index
)
3522 return cplus_type_of_child (parent
, index
);
3526 java_value_of_variable (struct varobj
*var
, enum varobj_display_formats format
)
3528 return cplus_value_of_variable (var
, format
);
3531 /* Iterate all the existing _root_ VAROBJs and call the FUNC callback for them
3532 with an arbitrary caller supplied DATA pointer. */
3535 all_root_varobjs (void (*func
) (struct varobj
*var
, void *data
), void *data
)
3537 struct varobj_root
*var_root
, *var_root_next
;
3539 /* Iterate "safely" - handle if the callee deletes its passed VAROBJ. */
3541 for (var_root
= rootlist
; var_root
!= NULL
; var_root
= var_root_next
)
3543 var_root_next
= var_root
->next
;
3545 (*func
) (var_root
->rootvar
, data
);
3549 extern void _initialize_varobj (void);
3551 _initialize_varobj (void)
3553 int sizeof_table
= sizeof (struct vlist
*) * VAROBJ_TABLE_SIZE
;
3555 varobj_table
= xmalloc (sizeof_table
);
3556 memset (varobj_table
, 0, sizeof_table
);
3558 add_setshow_zinteger_cmd ("debugvarobj", class_maintenance
,
3560 _("Set varobj debugging."),
3561 _("Show varobj debugging."),
3562 _("When non-zero, varobj debugging is enabled."),
3563 NULL
, show_varobjdebug
,
3564 &setlist
, &showlist
);
3567 /* Invalidate varobj VAR if it is tied to locals and re-create it if it is
3568 defined on globals. It is a helper for varobj_invalidate. */
3571 varobj_invalidate_iter (struct varobj
*var
, void *unused
)
3573 /* Floating varobjs are reparsed on each stop, so we don't care if the
3574 presently parsed expression refers to something that's gone. */
3575 if (var
->root
->floating
)
3578 /* global var must be re-evaluated. */
3579 if (var
->root
->valid_block
== NULL
)
3581 struct varobj
*tmp_var
;
3583 /* Try to create a varobj with same expression. If we succeed
3584 replace the old varobj, otherwise invalidate it. */
3585 tmp_var
= varobj_create (NULL
, var
->name
, (CORE_ADDR
) 0,
3587 if (tmp_var
!= NULL
)
3589 tmp_var
->obj_name
= xstrdup (var
->obj_name
);
3590 varobj_delete (var
, NULL
, 0);
3591 install_variable (tmp_var
);
3594 var
->root
->is_valid
= 0;
3596 else /* locals must be invalidated. */
3597 var
->root
->is_valid
= 0;
3600 /* Invalidate the varobjs that are tied to locals and re-create the ones that
3601 are defined on globals.
3602 Invalidated varobjs will be always printed in_scope="invalid". */
3605 varobj_invalidate (void)
3607 all_root_varobjs (varobj_invalidate_iter
, NULL
);