1 /* Implementation of the GDB variable objects API.
3 Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
4 2009, 2010 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 children. */
165 struct varobj_root
*root
;
167 /* The format of the output for this object */
168 enum varobj_display_formats format
;
170 /* Was this variable updated via a varobj_set_value operation */
173 /* Last print value. */
176 /* Is this variable frozen. Frozen variables are never implicitly
177 updated by -var-update *
178 or -var-update <direct-or-indirect-parent>. */
181 /* Is the value of this variable intentionally not fetched? It is
182 not fetched if either the variable is frozen, or any parents is
186 /* Sub-range of children which the MI consumer has requested. If
187 FROM < 0 or TO < 0, means that all children have been
192 /* The pretty-printer constructor. If NULL, then the default
193 pretty-printer will be looked up. If None, then no
194 pretty-printer will be installed. */
195 PyObject
*constructor
;
197 /* The pretty-printer that has been constructed. If NULL, then a
198 new printer object is needed, and one will be constructed. */
199 PyObject
*pretty_printer
;
201 /* The iterator returned by the printer's 'children' method, or NULL
203 PyObject
*child_iter
;
205 /* We request one extra item from the iterator, so that we can
206 report to the caller whether there are more items than we have
207 already reported. However, we don't want to install this value
208 when we read it, because that will mess up future updates. So,
209 we stash it here instead. */
210 PyObject
*saved_item
;
216 struct cpstack
*next
;
219 /* A list of varobjs */
227 /* Private function prototypes */
229 /* Helper functions for the above subcommands. */
231 static int delete_variable (struct cpstack
**, struct varobj
*, int);
233 static void delete_variable_1 (struct cpstack
**, int *,
234 struct varobj
*, int, int);
236 static int install_variable (struct varobj
*);
238 static void uninstall_variable (struct varobj
*);
240 static struct varobj
*create_child (struct varobj
*, int, char *);
242 static struct varobj
*
243 create_child_with_value (struct varobj
*parent
, int index
, const char *name
,
244 struct value
*value
);
246 /* Utility routines */
248 static struct varobj
*new_variable (void);
250 static struct varobj
*new_root_variable (void);
252 static void free_variable (struct varobj
*var
);
254 static struct cleanup
*make_cleanup_free_variable (struct varobj
*var
);
256 static struct type
*get_type (struct varobj
*var
);
258 static struct type
*get_value_type (struct varobj
*var
);
260 static struct type
*get_target_type (struct type
*);
262 static enum varobj_display_formats
variable_default_display (struct varobj
*);
264 static void cppush (struct cpstack
**pstack
, char *name
);
266 static char *cppop (struct cpstack
**pstack
);
268 static int install_new_value (struct varobj
*var
, struct value
*value
,
271 /* Language-specific routines. */
273 static enum varobj_languages
variable_language (struct varobj
*var
);
275 static int number_of_children (struct varobj
*);
277 static char *name_of_variable (struct varobj
*);
279 static char *name_of_child (struct varobj
*, int);
281 static struct value
*value_of_root (struct varobj
**var_handle
, int *);
283 static struct value
*value_of_child (struct varobj
*parent
, int index
);
285 static char *my_value_of_variable (struct varobj
*var
,
286 enum varobj_display_formats format
);
288 static char *value_get_print_value (struct value
*value
,
289 enum varobj_display_formats format
,
292 static int varobj_value_is_changeable_p (struct varobj
*var
);
294 static int is_root_p (struct varobj
*var
);
298 static struct varobj
*
299 varobj_add_child (struct varobj
*var
, const char *name
, struct value
*value
);
301 #endif /* HAVE_PYTHON */
303 /* C implementation */
305 static int c_number_of_children (struct varobj
*var
);
307 static char *c_name_of_variable (struct varobj
*parent
);
309 static char *c_name_of_child (struct varobj
*parent
, int index
);
311 static char *c_path_expr_of_child (struct varobj
*child
);
313 static struct value
*c_value_of_root (struct varobj
**var_handle
);
315 static struct value
*c_value_of_child (struct varobj
*parent
, int index
);
317 static struct type
*c_type_of_child (struct varobj
*parent
, int index
);
319 static char *c_value_of_variable (struct varobj
*var
,
320 enum varobj_display_formats format
);
322 /* C++ implementation */
324 static int cplus_number_of_children (struct varobj
*var
);
326 static void cplus_class_num_children (struct type
*type
, int children
[3]);
328 static char *cplus_name_of_variable (struct varobj
*parent
);
330 static char *cplus_name_of_child (struct varobj
*parent
, int index
);
332 static char *cplus_path_expr_of_child (struct varobj
*child
);
334 static struct value
*cplus_value_of_root (struct varobj
**var_handle
);
336 static struct value
*cplus_value_of_child (struct varobj
*parent
, int index
);
338 static struct type
*cplus_type_of_child (struct varobj
*parent
, int index
);
340 static char *cplus_value_of_variable (struct varobj
*var
,
341 enum varobj_display_formats format
);
343 /* Java implementation */
345 static int java_number_of_children (struct varobj
*var
);
347 static char *java_name_of_variable (struct varobj
*parent
);
349 static char *java_name_of_child (struct varobj
*parent
, int index
);
351 static char *java_path_expr_of_child (struct varobj
*child
);
353 static struct value
*java_value_of_root (struct varobj
**var_handle
);
355 static struct value
*java_value_of_child (struct varobj
*parent
, int index
);
357 static struct type
*java_type_of_child (struct varobj
*parent
, int index
);
359 static char *java_value_of_variable (struct varobj
*var
,
360 enum varobj_display_formats format
);
362 /* The language specific vector */
364 struct language_specific
367 /* The language of this variable */
368 enum varobj_languages language
;
370 /* The number of children of PARENT. */
371 int (*number_of_children
) (struct varobj
* parent
);
373 /* The name (expression) of a root varobj. */
374 char *(*name_of_variable
) (struct varobj
* parent
);
376 /* The name of the INDEX'th child of PARENT. */
377 char *(*name_of_child
) (struct varobj
* parent
, int index
);
379 /* Returns the rooted expression of CHILD, which is a variable
380 obtain that has some parent. */
381 char *(*path_expr_of_child
) (struct varobj
* child
);
383 /* The ``struct value *'' of the root variable ROOT. */
384 struct value
*(*value_of_root
) (struct varobj
** root_handle
);
386 /* The ``struct value *'' of the INDEX'th child of PARENT. */
387 struct value
*(*value_of_child
) (struct varobj
* parent
, int index
);
389 /* The type of the INDEX'th child of PARENT. */
390 struct type
*(*type_of_child
) (struct varobj
* parent
, int index
);
392 /* The current value of VAR. */
393 char *(*value_of_variable
) (struct varobj
* var
,
394 enum varobj_display_formats format
);
397 /* Array of known source language routines. */
398 static struct language_specific languages
[vlang_end
] = {
399 /* Unknown (try treating as C */
402 c_number_of_children
,
405 c_path_expr_of_child
,
414 c_number_of_children
,
417 c_path_expr_of_child
,
426 cplus_number_of_children
,
427 cplus_name_of_variable
,
429 cplus_path_expr_of_child
,
431 cplus_value_of_child
,
433 cplus_value_of_variable
}
438 java_number_of_children
,
439 java_name_of_variable
,
441 java_path_expr_of_child
,
445 java_value_of_variable
}
448 /* A little convenience enum for dealing with C++/Java */
451 v_public
= 0, v_private
, v_protected
456 /* Mappings of varobj_display_formats enums to gdb's format codes */
457 static int format_code
[] = { 0, 't', 'd', 'x', 'o' };
459 /* Header of the list of root variable objects */
460 static struct varobj_root
*rootlist
;
462 /* Prime number indicating the number of buckets in the hash table */
463 /* A prime large enough to avoid too many colisions */
464 #define VAROBJ_TABLE_SIZE 227
466 /* Pointer to the varobj hash table (built at run time) */
467 static struct vlist
**varobj_table
;
469 /* Is the variable X one of our "fake" children? */
470 #define CPLUS_FAKE_CHILD(x) \
471 ((x) != NULL && (x)->type == NULL && (x)->value == NULL)
474 /* API Implementation */
476 is_root_p (struct varobj
*var
)
478 return (var
->root
->rootvar
== var
);
482 /* Helper function to install a Python environment suitable for
483 use during operations on VAR. */
485 varobj_ensure_python_env (struct varobj
*var
)
487 return ensure_python_env (var
->root
->exp
->gdbarch
,
488 var
->root
->exp
->language_defn
);
492 /* Creates a varobj (not its children) */
494 /* Return the full FRAME which corresponds to the given CORE_ADDR
495 or NULL if no FRAME on the chain corresponds to CORE_ADDR. */
497 static struct frame_info
*
498 find_frame_addr_in_frame_chain (CORE_ADDR frame_addr
)
500 struct frame_info
*frame
= NULL
;
502 if (frame_addr
== (CORE_ADDR
) 0)
505 for (frame
= get_current_frame ();
507 frame
= get_prev_frame (frame
))
509 /* The CORE_ADDR we get as argument was parsed from a string GDB
510 output as $fp. This output got truncated to gdbarch_addr_bit.
511 Truncate the frame base address in the same manner before
512 comparing it against our argument. */
513 CORE_ADDR frame_base
= get_frame_base_address (frame
);
514 int addr_bit
= gdbarch_addr_bit (get_frame_arch (frame
));
516 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
517 frame_base
&= ((CORE_ADDR
) 1 << addr_bit
) - 1;
519 if (frame_base
== frame_addr
)
527 varobj_create (char *objname
,
528 char *expression
, CORE_ADDR frame
, enum varobj_type type
)
531 struct cleanup
*old_chain
;
533 /* Fill out a varobj structure for the (root) variable being constructed. */
534 var
= new_root_variable ();
535 old_chain
= make_cleanup_free_variable (var
);
537 if (expression
!= NULL
)
539 struct frame_info
*fi
;
540 struct frame_info
*old_fi
= NULL
;
543 enum varobj_languages lang
;
544 struct value
*value
= NULL
;
546 /* Parse and evaluate the expression, filling in as much of the
547 variable's data as possible. */
549 if (has_stack_frames ())
551 /* Allow creator to specify context of variable */
552 if ((type
== USE_CURRENT_FRAME
) || (type
== USE_SELECTED_FRAME
))
553 fi
= get_selected_frame (NULL
);
555 /* FIXME: cagney/2002-11-23: This code should be doing a
556 lookup using the frame ID and not just the frame's
557 ``address''. This, of course, means an interface
558 change. However, with out that interface change ISAs,
559 such as the ia64 with its two stacks, won't work.
560 Similar goes for the case where there is a frameless
562 fi
= find_frame_addr_in_frame_chain (frame
);
567 /* frame = -2 means always use selected frame */
568 if (type
== USE_SELECTED_FRAME
)
569 var
->root
->floating
= 1;
573 block
= get_frame_block (fi
, 0);
576 innermost_block
= NULL
;
577 /* Wrap the call to parse expression, so we can
578 return a sensible error. */
579 if (!gdb_parse_exp_1 (&p
, block
, 0, &var
->root
->exp
))
584 /* Don't allow variables to be created for types. */
585 if (var
->root
->exp
->elts
[0].opcode
== OP_TYPE
)
587 do_cleanups (old_chain
);
588 fprintf_unfiltered (gdb_stderr
, "Attempt to use a type name"
589 " as an expression.\n");
593 var
->format
= variable_default_display (var
);
594 var
->root
->valid_block
= innermost_block
;
595 var
->name
= xstrdup (expression
);
596 /* For a root var, the name and the expr are the same. */
597 var
->path_expr
= xstrdup (expression
);
599 /* When the frame is different from the current frame,
600 we must select the appropriate frame before parsing
601 the expression, otherwise the value will not be current.
602 Since select_frame is so benign, just call it for all cases. */
605 /* User could specify explicit FRAME-ADDR which was not found but
606 EXPRESSION is frame specific and we would not be able to evaluate
607 it correctly next time. With VALID_BLOCK set we must also set
608 FRAME and THREAD_ID. */
610 error (_("Failed to find the specified frame"));
612 var
->root
->frame
= get_frame_id (fi
);
613 var
->root
->thread_id
= pid_to_thread_id (inferior_ptid
);
614 old_fi
= get_selected_frame (NULL
);
618 /* We definitely need to catch errors here.
619 If evaluate_expression succeeds we got the value we wanted.
620 But if it fails, we still go on with a call to evaluate_type() */
621 if (!gdb_evaluate_expression (var
->root
->exp
, &value
))
623 /* Error getting the value. Try to at least get the
625 struct value
*type_only_value
= evaluate_type (var
->root
->exp
);
627 var
->type
= value_type (type_only_value
);
630 var
->type
= value_type (value
);
632 install_new_value (var
, value
, 1 /* Initial assignment */);
634 /* Set language info */
635 lang
= variable_language (var
);
636 var
->root
->lang
= &languages
[lang
];
638 /* Set ourselves as our root */
639 var
->root
->rootvar
= var
;
641 /* Reset the selected frame */
643 select_frame (old_fi
);
646 /* If the variable object name is null, that means this
647 is a temporary variable, so don't install it. */
649 if ((var
!= NULL
) && (objname
!= NULL
))
651 var
->obj_name
= xstrdup (objname
);
653 /* If a varobj name is duplicated, the install will fail so
655 if (!install_variable (var
))
657 do_cleanups (old_chain
);
662 discard_cleanups (old_chain
);
666 /* Generates an unique name that can be used for a varobj */
669 varobj_gen_name (void)
674 /* generate a name for this object */
676 obj_name
= xstrprintf ("var%d", id
);
681 /* Given an OBJNAME, returns the pointer to the corresponding varobj. Call
682 error if OBJNAME cannot be found. */
685 varobj_get_handle (char *objname
)
689 unsigned int index
= 0;
692 for (chp
= objname
; *chp
; chp
++)
694 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
697 cv
= *(varobj_table
+ index
);
698 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, objname
) != 0))
702 error (_("Variable object not found"));
707 /* Given the handle, return the name of the object */
710 varobj_get_objname (struct varobj
*var
)
712 return var
->obj_name
;
715 /* Given the handle, return the expression represented by the object */
718 varobj_get_expression (struct varobj
*var
)
720 return name_of_variable (var
);
723 /* Deletes a varobj and all its children if only_children == 0,
724 otherwise deletes only the children; returns a malloc'ed list of all the
725 (malloc'ed) names of the variables that have been deleted (NULL terminated) */
728 varobj_delete (struct varobj
*var
, char ***dellist
, int only_children
)
732 struct cpstack
*result
= NULL
;
735 /* Initialize a stack for temporary results */
736 cppush (&result
, NULL
);
739 /* Delete only the variable children */
740 delcount
= delete_variable (&result
, var
, 1 /* only the children */ );
742 /* Delete the variable and all its children */
743 delcount
= delete_variable (&result
, var
, 0 /* parent+children */ );
745 /* We may have been asked to return a list of what has been deleted */
748 *dellist
= xmalloc ((delcount
+ 1) * sizeof (char *));
752 *cp
= cppop (&result
);
753 while ((*cp
!= NULL
) && (mycount
> 0))
757 *cp
= cppop (&result
);
760 if (mycount
|| (*cp
!= NULL
))
761 warning (_("varobj_delete: assertion failed - mycount(=%d) <> 0"),
770 /* Convenience function for varobj_set_visualizer. Instantiate a
771 pretty-printer for a given value. */
773 instantiate_pretty_printer (PyObject
*constructor
, struct value
*value
)
775 PyObject
*val_obj
= NULL
;
778 val_obj
= value_to_value_object (value
);
782 printer
= PyObject_CallFunctionObjArgs (constructor
, val_obj
, NULL
);
790 /* Set/Get variable object display format */
792 enum varobj_display_formats
793 varobj_set_display_format (struct varobj
*var
,
794 enum varobj_display_formats format
)
801 case FORMAT_HEXADECIMAL
:
803 var
->format
= format
;
807 var
->format
= variable_default_display (var
);
810 if (varobj_value_is_changeable_p (var
)
811 && var
->value
&& !value_lazy (var
->value
))
813 xfree (var
->print_value
);
814 var
->print_value
= value_get_print_value (var
->value
, var
->format
, var
);
820 enum varobj_display_formats
821 varobj_get_display_format (struct varobj
*var
)
827 varobj_get_display_hint (struct varobj
*var
)
832 struct cleanup
*back_to
= varobj_ensure_python_env (var
);
834 if (var
->pretty_printer
)
835 result
= gdbpy_get_display_hint (var
->pretty_printer
);
837 do_cleanups (back_to
);
843 /* Return true if the varobj has items after TO, false otherwise. */
846 varobj_has_more (struct varobj
*var
, int to
)
848 if (VEC_length (varobj_p
, var
->children
) > to
)
850 return ((to
== -1 || VEC_length (varobj_p
, var
->children
) == to
)
851 && var
->saved_item
!= NULL
);
854 /* If the variable object is bound to a specific thread, that
855 is its evaluation can always be done in context of a frame
856 inside that thread, returns GDB id of the thread -- which
857 is always positive. Otherwise, returns -1. */
859 varobj_get_thread_id (struct varobj
*var
)
861 if (var
->root
->valid_block
&& var
->root
->thread_id
> 0)
862 return var
->root
->thread_id
;
868 varobj_set_frozen (struct varobj
*var
, int frozen
)
870 /* When a variable is unfrozen, we don't fetch its value.
871 The 'not_fetched' flag remains set, so next -var-update
874 We don't fetch the value, because for structures the client
875 should do -var-update anyway. It would be bad to have different
876 client-size logic for structure and other types. */
877 var
->frozen
= frozen
;
881 varobj_get_frozen (struct varobj
*var
)
886 /* A helper function that restricts a range to what is actually
887 available in a VEC. This follows the usual rules for the meaning
888 of FROM and TO -- if either is negative, the entire range is
892 restrict_range (VEC (varobj_p
) *children
, int *from
, int *to
)
894 if (*from
< 0 || *to
< 0)
897 *to
= VEC_length (varobj_p
, children
);
901 if (*from
> VEC_length (varobj_p
, children
))
902 *from
= VEC_length (varobj_p
, children
);
903 if (*to
> VEC_length (varobj_p
, children
))
904 *to
= VEC_length (varobj_p
, children
);
912 /* A helper for update_dynamic_varobj_children that installs a new
913 child when needed. */
916 install_dynamic_child (struct varobj
*var
,
917 VEC (varobj_p
) **changed
,
918 VEC (varobj_p
) **new,
919 VEC (varobj_p
) **unchanged
,
925 if (VEC_length (varobj_p
, var
->children
) < index
+ 1)
927 /* There's no child yet. */
928 struct varobj
*child
= varobj_add_child (var
, name
, value
);
932 VEC_safe_push (varobj_p
, *new, child
);
938 varobj_p existing
= VEC_index (varobj_p
, var
->children
, index
);
940 if (install_new_value (existing
, value
, 0))
943 VEC_safe_push (varobj_p
, *changed
, existing
);
946 VEC_safe_push (varobj_p
, *unchanged
, existing
);
951 dynamic_varobj_has_child_method (struct varobj
*var
)
953 struct cleanup
*back_to
;
954 PyObject
*printer
= var
->pretty_printer
;
957 back_to
= varobj_ensure_python_env (var
);
958 result
= PyObject_HasAttr (printer
, gdbpy_children_cst
);
959 do_cleanups (back_to
);
966 update_dynamic_varobj_children (struct varobj
*var
,
967 VEC (varobj_p
) **changed
,
968 VEC (varobj_p
) **new,
969 VEC (varobj_p
) **unchanged
,
976 struct cleanup
*back_to
;
979 PyObject
*printer
= var
->pretty_printer
;
981 back_to
= varobj_ensure_python_env (var
);
984 if (!PyObject_HasAttr (printer
, gdbpy_children_cst
))
986 do_cleanups (back_to
);
990 if (update_children
|| !var
->child_iter
)
992 children
= PyObject_CallMethodObjArgs (printer
, gdbpy_children_cst
,
997 gdbpy_print_stack ();
998 error (_("Null value returned for children"));
1001 make_cleanup_py_decref (children
);
1003 if (!PyIter_Check (children
))
1004 error (_("Returned value is not iterable"));
1006 Py_XDECREF (var
->child_iter
);
1007 var
->child_iter
= PyObject_GetIter (children
);
1008 if (!var
->child_iter
)
1010 gdbpy_print_stack ();
1011 error (_("Could not get children iterator"));
1014 Py_XDECREF (var
->saved_item
);
1015 var
->saved_item
= NULL
;
1020 i
= VEC_length (varobj_p
, var
->children
);
1022 /* We ask for one extra child, so that MI can report whether there
1023 are more children. */
1024 for (; to
< 0 || i
< to
+ 1; ++i
)
1028 /* See if there was a leftover from last time. */
1029 if (var
->saved_item
)
1031 item
= var
->saved_item
;
1032 var
->saved_item
= NULL
;
1035 item
= PyIter_Next (var
->child_iter
);
1040 /* We don't want to push the extra child on any report list. */
1041 if (to
< 0 || i
< to
)
1046 struct cleanup
*inner
;
1047 int can_mention
= from
< 0 || i
>= from
;
1049 inner
= make_cleanup_py_decref (item
);
1051 if (!PyArg_ParseTuple (item
, "sO", &name
, &py_v
))
1052 error (_("Invalid item from the child list"));
1054 v
= convert_value_from_python (py_v
);
1055 install_dynamic_child (var
, can_mention
? changed
: NULL
,
1056 can_mention
? new : NULL
,
1057 can_mention
? unchanged
: NULL
,
1058 can_mention
? cchanged
: NULL
, i
, name
, v
);
1059 do_cleanups (inner
);
1063 Py_XDECREF (var
->saved_item
);
1064 var
->saved_item
= item
;
1066 /* We want to truncate the child list just before this
1072 if (i
< VEC_length (varobj_p
, var
->children
))
1077 for (j
= i
; j
< VEC_length (varobj_p
, var
->children
); ++j
)
1078 varobj_delete (VEC_index (varobj_p
, var
->children
, j
), NULL
, 0);
1079 VEC_truncate (varobj_p
, var
->children
, i
);
1082 /* If there are fewer children than requested, note that the list of
1083 children changed. */
1084 if (to
>= 0 && VEC_length (varobj_p
, var
->children
) < to
)
1087 var
->num_children
= VEC_length (varobj_p
, var
->children
);
1089 do_cleanups (back_to
);
1093 gdb_assert (0 && "should never be called if Python is not enabled");
1098 varobj_get_num_children (struct varobj
*var
)
1100 if (var
->num_children
== -1)
1102 if (var
->pretty_printer
)
1106 /* If we have a dynamic varobj, don't report -1 children.
1107 So, try to fetch some children first. */
1108 update_dynamic_varobj_children (var
, NULL
, NULL
, NULL
, &dummy
,
1112 var
->num_children
= number_of_children (var
);
1115 return var
->num_children
>= 0 ? var
->num_children
: 0;
1118 /* Creates a list of the immediate children of a variable object;
1119 the return code is the number of such children or -1 on error */
1122 varobj_list_children (struct varobj
*var
, int *from
, int *to
)
1125 int i
, children_changed
;
1127 var
->children_requested
= 1;
1129 if (var
->pretty_printer
)
1131 /* This, in theory, can result in the number of children changing without
1132 frontend noticing. But well, calling -var-list-children on the same
1133 varobj twice is not something a sane frontend would do. */
1134 update_dynamic_varobj_children (var
, NULL
, NULL
, NULL
, &children_changed
,
1136 restrict_range (var
->children
, from
, to
);
1137 return var
->children
;
1140 if (var
->num_children
== -1)
1141 var
->num_children
= number_of_children (var
);
1143 /* If that failed, give up. */
1144 if (var
->num_children
== -1)
1145 return var
->children
;
1147 /* If we're called when the list of children is not yet initialized,
1148 allocate enough elements in it. */
1149 while (VEC_length (varobj_p
, var
->children
) < var
->num_children
)
1150 VEC_safe_push (varobj_p
, var
->children
, NULL
);
1152 for (i
= 0; i
< var
->num_children
; i
++)
1154 varobj_p existing
= VEC_index (varobj_p
, var
->children
, i
);
1156 if (existing
== NULL
)
1158 /* Either it's the first call to varobj_list_children for
1159 this variable object, and the child was never created,
1160 or it was explicitly deleted by the client. */
1161 name
= name_of_child (var
, i
);
1162 existing
= create_child (var
, i
, name
);
1163 VEC_replace (varobj_p
, var
->children
, i
, existing
);
1167 restrict_range (var
->children
, from
, to
);
1168 return var
->children
;
1173 static struct varobj
*
1174 varobj_add_child (struct varobj
*var
, const char *name
, struct value
*value
)
1176 varobj_p v
= create_child_with_value (var
,
1177 VEC_length (varobj_p
, var
->children
),
1180 VEC_safe_push (varobj_p
, var
->children
, v
);
1184 #endif /* HAVE_PYTHON */
1186 /* Obtain the type of an object Variable as a string similar to the one gdb
1187 prints on the console */
1190 varobj_get_type (struct varobj
*var
)
1192 /* For the "fake" variables, do not return a type. (It's type is
1194 Do not return a type for invalid variables as well. */
1195 if (CPLUS_FAKE_CHILD (var
) || !var
->root
->is_valid
)
1198 return type_to_string (var
->type
);
1201 /* Obtain the type of an object variable. */
1204 varobj_get_gdb_type (struct varobj
*var
)
1209 /* Return a pointer to the full rooted expression of varobj VAR.
1210 If it has not been computed yet, compute it. */
1212 varobj_get_path_expr (struct varobj
*var
)
1214 if (var
->path_expr
!= NULL
)
1215 return var
->path_expr
;
1218 /* For root varobjs, we initialize path_expr
1219 when creating varobj, so here it should be
1221 gdb_assert (!is_root_p (var
));
1222 return (*var
->root
->lang
->path_expr_of_child
) (var
);
1226 enum varobj_languages
1227 varobj_get_language (struct varobj
*var
)
1229 return variable_language (var
);
1233 varobj_get_attributes (struct varobj
*var
)
1237 if (varobj_editable_p (var
))
1238 /* FIXME: define masks for attributes */
1239 attributes
|= 0x00000001; /* Editable */
1245 varobj_pretty_printed_p (struct varobj
*var
)
1247 return var
->pretty_printer
!= NULL
;
1251 varobj_get_formatted_value (struct varobj
*var
,
1252 enum varobj_display_formats format
)
1254 return my_value_of_variable (var
, format
);
1258 varobj_get_value (struct varobj
*var
)
1260 return my_value_of_variable (var
, var
->format
);
1263 /* Set the value of an object variable (if it is editable) to the
1264 value of the given expression */
1265 /* Note: Invokes functions that can call error() */
1268 varobj_set_value (struct varobj
*var
, char *expression
)
1272 /* The argument "expression" contains the variable's new value.
1273 We need to first construct a legal expression for this -- ugh! */
1274 /* Does this cover all the bases? */
1275 struct expression
*exp
;
1276 struct value
*value
;
1277 int saved_input_radix
= input_radix
;
1278 char *s
= expression
;
1280 gdb_assert (varobj_editable_p (var
));
1282 input_radix
= 10; /* ALWAYS reset to decimal temporarily */
1283 exp
= parse_exp_1 (&s
, 0, 0);
1284 if (!gdb_evaluate_expression (exp
, &value
))
1286 /* We cannot proceed without a valid expression. */
1291 /* All types that are editable must also be changeable. */
1292 gdb_assert (varobj_value_is_changeable_p (var
));
1294 /* The value of a changeable variable object must not be lazy. */
1295 gdb_assert (!value_lazy (var
->value
));
1297 /* Need to coerce the input. We want to check if the
1298 value of the variable object will be different
1299 after assignment, and the first thing value_assign
1300 does is coerce the input.
1301 For example, if we are assigning an array to a pointer variable we
1302 should compare the pointer with the the array's address, not with the
1304 value
= coerce_array (value
);
1306 /* The new value may be lazy. gdb_value_assign, or
1307 rather value_contents, will take care of this.
1308 If fetching of the new value will fail, gdb_value_assign
1309 with catch the exception. */
1310 if (!gdb_value_assign (var
->value
, value
, &val
))
1313 /* If the value has changed, record it, so that next -var-update can
1314 report this change. If a variable had a value of '1', we've set it
1315 to '333' and then set again to '1', when -var-update will report this
1316 variable as changed -- because the first assignment has set the
1317 'updated' flag. There's no need to optimize that, because return value
1318 of -var-update should be considered an approximation. */
1319 var
->updated
= install_new_value (var
, val
, 0 /* Compare values. */);
1320 input_radix
= saved_input_radix
;
1326 /* A helper function to install a constructor function and visualizer
1330 install_visualizer (struct varobj
*var
, PyObject
*constructor
,
1331 PyObject
*visualizer
)
1333 Py_XDECREF (var
->constructor
);
1334 var
->constructor
= constructor
;
1336 Py_XDECREF (var
->pretty_printer
);
1337 var
->pretty_printer
= visualizer
;
1339 Py_XDECREF (var
->child_iter
);
1340 var
->child_iter
= NULL
;
1343 /* Install the default visualizer for VAR. */
1346 install_default_visualizer (struct varobj
*var
)
1348 if (pretty_printing
)
1350 PyObject
*pretty_printer
= NULL
;
1354 pretty_printer
= gdbpy_get_varobj_pretty_printer (var
->value
);
1355 if (! pretty_printer
)
1357 gdbpy_print_stack ();
1358 error (_("Cannot instantiate printer for default visualizer"));
1362 if (pretty_printer
== Py_None
)
1364 Py_DECREF (pretty_printer
);
1365 pretty_printer
= NULL
;
1368 install_visualizer (var
, NULL
, pretty_printer
);
1372 /* Instantiate and install a visualizer for VAR using CONSTRUCTOR to
1373 make a new object. */
1376 construct_visualizer (struct varobj
*var
, PyObject
*constructor
)
1378 PyObject
*pretty_printer
;
1380 Py_INCREF (constructor
);
1381 if (constructor
== Py_None
)
1382 pretty_printer
= NULL
;
1385 pretty_printer
= instantiate_pretty_printer (constructor
, var
->value
);
1386 if (! pretty_printer
)
1388 gdbpy_print_stack ();
1389 Py_DECREF (constructor
);
1390 constructor
= Py_None
;
1391 Py_INCREF (constructor
);
1394 if (pretty_printer
== Py_None
)
1396 Py_DECREF (pretty_printer
);
1397 pretty_printer
= NULL
;
1401 install_visualizer (var
, constructor
, pretty_printer
);
1404 #endif /* HAVE_PYTHON */
1406 /* A helper function for install_new_value. This creates and installs
1407 a visualizer for VAR, if appropriate. */
1410 install_new_value_visualizer (struct varobj
*var
)
1413 /* If the constructor is None, then we want the raw value. If VAR
1414 does not have a value, just skip this. */
1415 if (var
->constructor
!= Py_None
&& var
->value
)
1417 struct cleanup
*cleanup
;
1419 cleanup
= varobj_ensure_python_env (var
);
1421 if (!var
->constructor
)
1422 install_default_visualizer (var
);
1424 construct_visualizer (var
, var
->constructor
);
1426 do_cleanups (cleanup
);
1433 /* Assign a new value to a variable object. If INITIAL is non-zero,
1434 this is the first assignement after the variable object was just
1435 created, or changed type. In that case, just assign the value
1437 Otherwise, assign the new value, and return 1 if the value is different
1438 from the current one, 0 otherwise. The comparison is done on textual
1439 representation of value. Therefore, some types need not be compared. E.g.
1440 for structures the reported value is always "{...}", so no comparison is
1441 necessary here. If the old value was NULL and new one is not, or vice versa,
1444 The VALUE parameter should not be released -- the function will
1445 take care of releasing it when needed. */
1447 install_new_value (struct varobj
*var
, struct value
*value
, int initial
)
1452 int intentionally_not_fetched
= 0;
1453 char *print_value
= NULL
;
1455 /* We need to know the varobj's type to decide if the value should
1456 be fetched or not. C++ fake children (public/protected/private) don't have
1458 gdb_assert (var
->type
|| CPLUS_FAKE_CHILD (var
));
1459 changeable
= varobj_value_is_changeable_p (var
);
1461 /* If the type has custom visualizer, we consider it to be always
1462 changeable. FIXME: need to make sure this behaviour will not
1463 mess up read-sensitive values. */
1464 if (var
->pretty_printer
)
1467 need_to_fetch
= changeable
;
1469 /* We are not interested in the address of references, and given
1470 that in C++ a reference is not rebindable, it cannot
1471 meaningfully change. So, get hold of the real value. */
1473 value
= coerce_ref (value
);
1475 if (var
->type
&& TYPE_CODE (var
->type
) == TYPE_CODE_UNION
)
1476 /* For unions, we need to fetch the value implicitly because
1477 of implementation of union member fetch. When gdb
1478 creates a value for a field and the value of the enclosing
1479 structure is not lazy, it immediately copies the necessary
1480 bytes from the enclosing values. If the enclosing value is
1481 lazy, the call to value_fetch_lazy on the field will read
1482 the data from memory. For unions, that means we'll read the
1483 same memory more than once, which is not desirable. So
1487 /* The new value might be lazy. If the type is changeable,
1488 that is we'll be comparing values of this type, fetch the
1489 value now. Otherwise, on the next update the old value
1490 will be lazy, which means we've lost that old value. */
1491 if (need_to_fetch
&& value
&& value_lazy (value
))
1493 struct varobj
*parent
= var
->parent
;
1494 int frozen
= var
->frozen
;
1496 for (; !frozen
&& parent
; parent
= parent
->parent
)
1497 frozen
|= parent
->frozen
;
1499 if (frozen
&& initial
)
1501 /* For variables that are frozen, or are children of frozen
1502 variables, we don't do fetch on initial assignment.
1503 For non-initial assignemnt we do the fetch, since it means we're
1504 explicitly asked to compare the new value with the old one. */
1505 intentionally_not_fetched
= 1;
1507 else if (!gdb_value_fetch_lazy (value
))
1509 /* Set the value to NULL, so that for the next -var-update,
1510 we don't try to compare the new value with this value,
1511 that we couldn't even read. */
1517 /* Below, we'll be comparing string rendering of old and new
1518 values. Don't get string rendering if the value is
1519 lazy -- if it is, the code above has decided that the value
1520 should not be fetched. */
1521 if (value
&& !value_lazy (value
) && !var
->pretty_printer
)
1522 print_value
= value_get_print_value (value
, var
->format
, var
);
1524 /* If the type is changeable, compare the old and the new values.
1525 If this is the initial assignment, we don't have any old value
1527 if (!initial
&& changeable
)
1529 /* If the value of the varobj was changed by -var-set-value, then the
1530 value in the varobj and in the target is the same. However, that value
1531 is different from the value that the varobj had after the previous
1532 -var-update. So need to the varobj as changed. */
1537 else if (! var
->pretty_printer
)
1539 /* Try to compare the values. That requires that both
1540 values are non-lazy. */
1541 if (var
->not_fetched
&& value_lazy (var
->value
))
1543 /* This is a frozen varobj and the value was never read.
1544 Presumably, UI shows some "never read" indicator.
1545 Now that we've fetched the real value, we need to report
1546 this varobj as changed so that UI can show the real
1550 else if (var
->value
== NULL
&& value
== NULL
)
1553 else if (var
->value
== NULL
|| value
== NULL
)
1559 gdb_assert (!value_lazy (var
->value
));
1560 gdb_assert (!value_lazy (value
));
1562 gdb_assert (var
->print_value
!= NULL
&& print_value
!= NULL
);
1563 if (strcmp (var
->print_value
, print_value
) != 0)
1569 if (!initial
&& !changeable
)
1571 /* For values that are not changeable, we don't compare the values.
1572 However, we want to notice if a value was not NULL and now is NULL,
1573 or vise versa, so that we report when top-level varobjs come in scope
1574 and leave the scope. */
1575 changed
= (var
->value
!= NULL
) != (value
!= NULL
);
1578 /* We must always keep the new value, since children depend on it. */
1579 if (var
->value
!= NULL
&& var
->value
!= value
)
1580 value_free (var
->value
);
1583 value_incref (value
);
1584 if (value
&& value_lazy (value
) && intentionally_not_fetched
)
1585 var
->not_fetched
= 1;
1587 var
->not_fetched
= 0;
1590 install_new_value_visualizer (var
);
1592 /* If we installed a pretty-printer, re-compare the printed version
1593 to see if the variable changed. */
1594 if (var
->pretty_printer
)
1596 xfree (print_value
);
1597 print_value
= value_get_print_value (var
->value
, var
->format
, var
);
1598 if ((var
->print_value
== NULL
&& print_value
!= NULL
)
1599 || (var
->print_value
!= NULL
&& print_value
== NULL
)
1600 || (var
->print_value
!= NULL
&& print_value
!= NULL
1601 && strcmp (var
->print_value
, print_value
) != 0))
1604 if (var
->print_value
)
1605 xfree (var
->print_value
);
1606 var
->print_value
= print_value
;
1608 gdb_assert (!var
->value
|| value_type (var
->value
));
1613 /* Return the requested range for a varobj. VAR is the varobj. FROM
1614 and TO are out parameters; *FROM and *TO will be set to the
1615 selected sub-range of VAR. If no range was selected using
1616 -var-set-update-range, then both will be -1. */
1618 varobj_get_child_range (struct varobj
*var
, int *from
, int *to
)
1624 /* Set the selected sub-range of children of VAR to start at index
1625 FROM and end at index TO. If either FROM or TO is less than zero,
1626 this is interpreted as a request for all children. */
1628 varobj_set_child_range (struct varobj
*var
, int from
, int to
)
1635 varobj_set_visualizer (struct varobj
*var
, const char *visualizer
)
1638 PyObject
*mainmod
, *globals
, *constructor
;
1639 struct cleanup
*back_to
;
1641 back_to
= varobj_ensure_python_env (var
);
1643 mainmod
= PyImport_AddModule ("__main__");
1644 globals
= PyModule_GetDict (mainmod
);
1645 Py_INCREF (globals
);
1646 make_cleanup_py_decref (globals
);
1648 constructor
= PyRun_String (visualizer
, Py_eval_input
, globals
, globals
);
1652 gdbpy_print_stack ();
1653 error (_("Could not evaluate visualizer expression: %s"), visualizer
);
1656 construct_visualizer (var
, constructor
);
1657 Py_XDECREF (constructor
);
1659 /* If there are any children now, wipe them. */
1660 varobj_delete (var
, NULL
, 1 /* children only */);
1661 var
->num_children
= -1;
1663 do_cleanups (back_to
);
1665 error (_("Python support required"));
1669 /* Update the values for a variable and its children. This is a
1670 two-pronged attack. First, re-parse the value for the root's
1671 expression to see if it's changed. Then go all the way
1672 through its children, reconstructing them and noting if they've
1675 The EXPLICIT parameter specifies if this call is result
1676 of MI request to update this specific variable, or
1677 result of implicit -var-update *. For implicit request, we don't
1678 update frozen variables.
1680 NOTE: This function may delete the caller's varobj. If it
1681 returns TYPE_CHANGED, then it has done this and VARP will be modified
1682 to point to the new varobj. */
1684 VEC(varobj_update_result
) *varobj_update (struct varobj
**varp
, int explicit)
1687 int type_changed
= 0;
1690 VEC (varobj_update_result
) *stack
= NULL
;
1691 VEC (varobj_update_result
) *result
= NULL
;
1693 /* Frozen means frozen -- we don't check for any change in
1694 this varobj, including its going out of scope, or
1695 changing type. One use case for frozen varobjs is
1696 retaining previously evaluated expressions, and we don't
1697 want them to be reevaluated at all. */
1698 if (!explicit && (*varp
)->frozen
)
1701 if (!(*varp
)->root
->is_valid
)
1703 varobj_update_result r
= {0};
1706 r
.status
= VAROBJ_INVALID
;
1707 VEC_safe_push (varobj_update_result
, result
, &r
);
1711 if ((*varp
)->root
->rootvar
== *varp
)
1713 varobj_update_result r
= {0};
1716 r
.status
= VAROBJ_IN_SCOPE
;
1718 /* Update the root variable. value_of_root can return NULL
1719 if the variable is no longer around, i.e. we stepped out of
1720 the frame in which a local existed. We are letting the
1721 value_of_root variable dispose of the varobj if the type
1723 new = value_of_root (varp
, &type_changed
);
1726 r
.type_changed
= type_changed
;
1727 if (install_new_value ((*varp
), new, type_changed
))
1731 r
.status
= VAROBJ_NOT_IN_SCOPE
;
1732 r
.value_installed
= 1;
1734 if (r
.status
== VAROBJ_NOT_IN_SCOPE
)
1736 if (r
.type_changed
|| r
.changed
)
1737 VEC_safe_push (varobj_update_result
, result
, &r
);
1741 VEC_safe_push (varobj_update_result
, stack
, &r
);
1745 varobj_update_result r
= {0};
1748 VEC_safe_push (varobj_update_result
, stack
, &r
);
1751 /* Walk through the children, reconstructing them all. */
1752 while (!VEC_empty (varobj_update_result
, stack
))
1754 varobj_update_result r
= *(VEC_last (varobj_update_result
, stack
));
1755 struct varobj
*v
= r
.varobj
;
1757 VEC_pop (varobj_update_result
, stack
);
1759 /* Update this variable, unless it's a root, which is already
1761 if (!r
.value_installed
)
1763 new = value_of_child (v
->parent
, v
->index
);
1764 if (install_new_value (v
, new, 0 /* type not changed */))
1771 /* We probably should not get children of a varobj that has a
1772 pretty-printer, but for which -var-list-children was never
1774 if (v
->pretty_printer
)
1776 VEC (varobj_p
) *changed
= 0, *new = 0, *unchanged
= 0;
1777 int i
, children_changed
= 0;
1782 if (!v
->children_requested
)
1786 /* If we initially did not have potential children, but
1787 now we do, consider the varobj as changed.
1788 Otherwise, if children were never requested, consider
1789 it as unchanged -- presumably, such varobj is not yet
1790 expanded in the UI, so we need not bother getting
1792 if (!varobj_has_more (v
, 0))
1794 update_dynamic_varobj_children (v
, NULL
, NULL
, NULL
,
1796 if (varobj_has_more (v
, 0))
1801 VEC_safe_push (varobj_update_result
, result
, &r
);
1806 /* If update_dynamic_varobj_children returns 0, then we have
1807 a non-conforming pretty-printer, so we skip it. */
1808 if (update_dynamic_varobj_children (v
, &changed
, &new, &unchanged
,
1809 &children_changed
, 1,
1812 if (children_changed
|| new)
1814 r
.children_changed
= 1;
1817 /* Push in reverse order so that the first child is
1818 popped from the work stack first, and so will be
1819 added to result first. This does not affect
1820 correctness, just "nicer". */
1821 for (i
= VEC_length (varobj_p
, changed
) - 1; i
>= 0; --i
)
1823 varobj_p tmp
= VEC_index (varobj_p
, changed
, i
);
1824 varobj_update_result r
= {0};
1828 r
.value_installed
= 1;
1829 VEC_safe_push (varobj_update_result
, stack
, &r
);
1831 for (i
= VEC_length (varobj_p
, unchanged
) - 1; i
>= 0; --i
)
1833 varobj_p tmp
= VEC_index (varobj_p
, unchanged
, i
);
1837 varobj_update_result r
= {0};
1840 r
.value_installed
= 1;
1841 VEC_safe_push (varobj_update_result
, stack
, &r
);
1844 if (r
.changed
|| r
.children_changed
)
1845 VEC_safe_push (varobj_update_result
, result
, &r
);
1847 /* Free CHANGED and UNCHANGED, but not NEW, because NEW
1848 has been put into the result vector. */
1849 VEC_free (varobj_p
, changed
);
1850 VEC_free (varobj_p
, unchanged
);
1856 /* Push any children. Use reverse order so that the first
1857 child is popped from the work stack first, and so
1858 will be added to result first. This does not
1859 affect correctness, just "nicer". */
1860 for (i
= VEC_length (varobj_p
, v
->children
)-1; i
>= 0; --i
)
1862 varobj_p c
= VEC_index (varobj_p
, v
->children
, i
);
1864 /* Child may be NULL if explicitly deleted by -var-delete. */
1865 if (c
!= NULL
&& !c
->frozen
)
1867 varobj_update_result r
= {0};
1870 VEC_safe_push (varobj_update_result
, stack
, &r
);
1874 if (r
.changed
|| r
.type_changed
)
1875 VEC_safe_push (varobj_update_result
, result
, &r
);
1878 VEC_free (varobj_update_result
, stack
);
1884 /* Helper functions */
1887 * Variable object construction/destruction
1891 delete_variable (struct cpstack
**resultp
, struct varobj
*var
,
1892 int only_children_p
)
1896 delete_variable_1 (resultp
, &delcount
, var
,
1897 only_children_p
, 1 /* remove_from_parent_p */ );
1902 /* Delete the variable object VAR and its children */
1903 /* IMPORTANT NOTE: If we delete a variable which is a child
1904 and the parent is not removed we dump core. It must be always
1905 initially called with remove_from_parent_p set */
1907 delete_variable_1 (struct cpstack
**resultp
, int *delcountp
,
1908 struct varobj
*var
, int only_children_p
,
1909 int remove_from_parent_p
)
1913 /* Delete any children of this variable, too. */
1914 for (i
= 0; i
< VEC_length (varobj_p
, var
->children
); ++i
)
1916 varobj_p child
= VEC_index (varobj_p
, var
->children
, i
);
1920 if (!remove_from_parent_p
)
1921 child
->parent
= NULL
;
1922 delete_variable_1 (resultp
, delcountp
, child
, 0, only_children_p
);
1924 VEC_free (varobj_p
, var
->children
);
1926 /* if we were called to delete only the children we are done here */
1927 if (only_children_p
)
1930 /* Otherwise, add it to the list of deleted ones and proceed to do so */
1931 /* If the name is null, this is a temporary variable, that has not
1932 yet been installed, don't report it, it belongs to the caller... */
1933 if (var
->obj_name
!= NULL
)
1935 cppush (resultp
, xstrdup (var
->obj_name
));
1936 *delcountp
= *delcountp
+ 1;
1939 /* If this variable has a parent, remove it from its parent's list */
1940 /* OPTIMIZATION: if the parent of this variable is also being deleted,
1941 (as indicated by remove_from_parent_p) we don't bother doing an
1942 expensive list search to find the element to remove when we are
1943 discarding the list afterwards */
1944 if ((remove_from_parent_p
) && (var
->parent
!= NULL
))
1946 VEC_replace (varobj_p
, var
->parent
->children
, var
->index
, NULL
);
1949 if (var
->obj_name
!= NULL
)
1950 uninstall_variable (var
);
1952 /* Free memory associated with this variable */
1953 free_variable (var
);
1956 /* Install the given variable VAR with the object name VAR->OBJ_NAME. */
1958 install_variable (struct varobj
*var
)
1961 struct vlist
*newvl
;
1963 unsigned int index
= 0;
1966 for (chp
= var
->obj_name
; *chp
; chp
++)
1968 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
1971 cv
= *(varobj_table
+ index
);
1972 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, var
->obj_name
) != 0))
1976 error (_("Duplicate variable object name"));
1978 /* Add varobj to hash table */
1979 newvl
= xmalloc (sizeof (struct vlist
));
1980 newvl
->next
= *(varobj_table
+ index
);
1982 *(varobj_table
+ index
) = newvl
;
1984 /* If root, add varobj to root list */
1985 if (is_root_p (var
))
1987 /* Add to list of root variables */
1988 if (rootlist
== NULL
)
1989 var
->root
->next
= NULL
;
1991 var
->root
->next
= rootlist
;
1992 rootlist
= var
->root
;
1998 /* Unistall the object VAR. */
2000 uninstall_variable (struct varobj
*var
)
2004 struct varobj_root
*cr
;
2005 struct varobj_root
*prer
;
2007 unsigned int index
= 0;
2010 /* Remove varobj from hash table */
2011 for (chp
= var
->obj_name
; *chp
; chp
++)
2013 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
2016 cv
= *(varobj_table
+ index
);
2018 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, var
->obj_name
) != 0))
2025 fprintf_unfiltered (gdb_stdlog
, "Deleting %s\n", var
->obj_name
);
2030 ("Assertion failed: Could not find variable object \"%s\" to delete",
2036 *(varobj_table
+ index
) = cv
->next
;
2038 prev
->next
= cv
->next
;
2042 /* If root, remove varobj from root list */
2043 if (is_root_p (var
))
2045 /* Remove from list of root variables */
2046 if (rootlist
== var
->root
)
2047 rootlist
= var
->root
->next
;
2052 while ((cr
!= NULL
) && (cr
->rootvar
!= var
))
2060 ("Assertion failed: Could not find varobj \"%s\" in root list",
2067 prer
->next
= cr
->next
;
2073 /* Create and install a child of the parent of the given name */
2074 static struct varobj
*
2075 create_child (struct varobj
*parent
, int index
, char *name
)
2077 return create_child_with_value (parent
, index
, name
,
2078 value_of_child (parent
, index
));
2081 static struct varobj
*
2082 create_child_with_value (struct varobj
*parent
, int index
, const char *name
,
2083 struct value
*value
)
2085 struct varobj
*child
;
2088 child
= new_variable ();
2090 /* name is allocated by name_of_child */
2091 /* FIXME: xstrdup should not be here. */
2092 child
->name
= xstrdup (name
);
2093 child
->index
= index
;
2094 child
->parent
= parent
;
2095 child
->root
= parent
->root
;
2096 childs_name
= xstrprintf ("%s.%s", parent
->obj_name
, name
);
2097 child
->obj_name
= childs_name
;
2098 install_variable (child
);
2100 /* Compute the type of the child. Must do this before
2101 calling install_new_value. */
2103 /* If the child had no evaluation errors, var->value
2104 will be non-NULL and contain a valid type. */
2105 child
->type
= value_type (value
);
2107 /* Otherwise, we must compute the type. */
2108 child
->type
= (*child
->root
->lang
->type_of_child
) (child
->parent
,
2110 install_new_value (child
, value
, 1);
2117 * Miscellaneous utility functions.
2120 /* Allocate memory and initialize a new variable */
2121 static struct varobj
*
2126 var
= (struct varobj
*) xmalloc (sizeof (struct varobj
));
2128 var
->path_expr
= NULL
;
2129 var
->obj_name
= NULL
;
2133 var
->num_children
= -1;
2135 var
->children
= NULL
;
2139 var
->print_value
= NULL
;
2141 var
->not_fetched
= 0;
2142 var
->children_requested
= 0;
2145 var
->constructor
= 0;
2146 var
->pretty_printer
= 0;
2147 var
->child_iter
= 0;
2148 var
->saved_item
= 0;
2153 /* Allocate memory and initialize a new root variable */
2154 static struct varobj
*
2155 new_root_variable (void)
2157 struct varobj
*var
= new_variable ();
2159 var
->root
= (struct varobj_root
*) xmalloc (sizeof (struct varobj_root
));;
2160 var
->root
->lang
= NULL
;
2161 var
->root
->exp
= NULL
;
2162 var
->root
->valid_block
= NULL
;
2163 var
->root
->frame
= null_frame_id
;
2164 var
->root
->floating
= 0;
2165 var
->root
->rootvar
= NULL
;
2166 var
->root
->is_valid
= 1;
2171 /* Free any allocated memory associated with VAR. */
2173 free_variable (struct varobj
*var
)
2176 if (var
->pretty_printer
)
2178 struct cleanup
*cleanup
= varobj_ensure_python_env (var
);
2179 Py_XDECREF (var
->constructor
);
2180 Py_XDECREF (var
->pretty_printer
);
2181 Py_XDECREF (var
->child_iter
);
2182 Py_XDECREF (var
->saved_item
);
2183 do_cleanups (cleanup
);
2187 value_free (var
->value
);
2189 /* Free the expression if this is a root variable. */
2190 if (is_root_p (var
))
2192 xfree (var
->root
->exp
);
2197 xfree (var
->obj_name
);
2198 xfree (var
->print_value
);
2199 xfree (var
->path_expr
);
2204 do_free_variable_cleanup (void *var
)
2206 free_variable (var
);
2209 static struct cleanup
*
2210 make_cleanup_free_variable (struct varobj
*var
)
2212 return make_cleanup (do_free_variable_cleanup
, var
);
2215 /* This returns the type of the variable. It also skips past typedefs
2216 to return the real type of the variable.
2218 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
2219 except within get_target_type and get_type. */
2220 static struct type
*
2221 get_type (struct varobj
*var
)
2227 type
= check_typedef (type
);
2232 /* Return the type of the value that's stored in VAR,
2233 or that would have being stored there if the
2234 value were accessible.
2236 This differs from VAR->type in that VAR->type is always
2237 the true type of the expession in the source language.
2238 The return value of this function is the type we're
2239 actually storing in varobj, and using for displaying
2240 the values and for comparing previous and new values.
2242 For example, top-level references are always stripped. */
2243 static struct type
*
2244 get_value_type (struct varobj
*var
)
2249 type
= value_type (var
->value
);
2253 type
= check_typedef (type
);
2255 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
2256 type
= get_target_type (type
);
2258 type
= check_typedef (type
);
2263 /* This returns the target type (or NULL) of TYPE, also skipping
2264 past typedefs, just like get_type ().
2266 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
2267 except within get_target_type and get_type. */
2268 static struct type
*
2269 get_target_type (struct type
*type
)
2273 type
= TYPE_TARGET_TYPE (type
);
2275 type
= check_typedef (type
);
2281 /* What is the default display for this variable? We assume that
2282 everything is "natural". Any exceptions? */
2283 static enum varobj_display_formats
2284 variable_default_display (struct varobj
*var
)
2286 return FORMAT_NATURAL
;
2289 /* FIXME: The following should be generic for any pointer */
2291 cppush (struct cpstack
**pstack
, char *name
)
2295 s
= (struct cpstack
*) xmalloc (sizeof (struct cpstack
));
2301 /* FIXME: The following should be generic for any pointer */
2303 cppop (struct cpstack
**pstack
)
2308 if ((*pstack
)->name
== NULL
&& (*pstack
)->next
== NULL
)
2313 *pstack
= (*pstack
)->next
;
2320 * Language-dependencies
2323 /* Common entry points */
2325 /* Get the language of variable VAR. */
2326 static enum varobj_languages
2327 variable_language (struct varobj
*var
)
2329 enum varobj_languages lang
;
2331 switch (var
->root
->exp
->language_defn
->la_language
)
2337 case language_cplus
:
2348 /* Return the number of children for a given variable.
2349 The result of this function is defined by the language
2350 implementation. The number of children returned by this function
2351 is the number of children that the user will see in the variable
2354 number_of_children (struct varobj
*var
)
2356 return (*var
->root
->lang
->number_of_children
) (var
);;
2359 /* What is the expression for the root varobj VAR? Returns a malloc'd string. */
2361 name_of_variable (struct varobj
*var
)
2363 return (*var
->root
->lang
->name_of_variable
) (var
);
2366 /* What is the name of the INDEX'th child of VAR? Returns a malloc'd string. */
2368 name_of_child (struct varobj
*var
, int index
)
2370 return (*var
->root
->lang
->name_of_child
) (var
, index
);
2373 /* What is the ``struct value *'' of the root variable VAR?
2374 For floating variable object, evaluation can get us a value
2375 of different type from what is stored in varobj already. In
2377 - *type_changed will be set to 1
2378 - old varobj will be freed, and new one will be
2379 created, with the same name.
2380 - *var_handle will be set to the new varobj
2381 Otherwise, *type_changed will be set to 0. */
2382 static struct value
*
2383 value_of_root (struct varobj
**var_handle
, int *type_changed
)
2387 if (var_handle
== NULL
)
2392 /* This should really be an exception, since this should
2393 only get called with a root variable. */
2395 if (!is_root_p (var
))
2398 if (var
->root
->floating
)
2400 struct varobj
*tmp_var
;
2401 char *old_type
, *new_type
;
2403 tmp_var
= varobj_create (NULL
, var
->name
, (CORE_ADDR
) 0,
2404 USE_SELECTED_FRAME
);
2405 if (tmp_var
== NULL
)
2409 old_type
= varobj_get_type (var
);
2410 new_type
= varobj_get_type (tmp_var
);
2411 if (strcmp (old_type
, new_type
) == 0)
2413 /* The expression presently stored inside var->root->exp
2414 remembers the locations of local variables relatively to
2415 the frame where the expression was created (in DWARF location
2416 button, for example). Naturally, those locations are not
2417 correct in other frames, so update the expression. */
2419 struct expression
*tmp_exp
= var
->root
->exp
;
2421 var
->root
->exp
= tmp_var
->root
->exp
;
2422 tmp_var
->root
->exp
= tmp_exp
;
2424 varobj_delete (tmp_var
, NULL
, 0);
2429 tmp_var
->obj_name
= xstrdup (var
->obj_name
);
2430 tmp_var
->from
= var
->from
;
2431 tmp_var
->to
= var
->to
;
2432 varobj_delete (var
, NULL
, 0);
2434 install_variable (tmp_var
);
2435 *var_handle
= tmp_var
;
2447 return (*var
->root
->lang
->value_of_root
) (var_handle
);
2450 /* What is the ``struct value *'' for the INDEX'th child of PARENT? */
2451 static struct value
*
2452 value_of_child (struct varobj
*parent
, int index
)
2454 struct value
*value
;
2456 value
= (*parent
->root
->lang
->value_of_child
) (parent
, index
);
2461 /* GDB already has a command called "value_of_variable". Sigh. */
2463 my_value_of_variable (struct varobj
*var
, enum varobj_display_formats format
)
2465 if (var
->root
->is_valid
)
2467 if (var
->pretty_printer
)
2468 return value_get_print_value (var
->value
, var
->format
, var
);
2469 return (*var
->root
->lang
->value_of_variable
) (var
, format
);
2476 value_get_print_value (struct value
*value
, enum varobj_display_formats format
,
2479 struct ui_file
*stb
;
2480 struct cleanup
*old_chain
;
2481 gdb_byte
*thevalue
= NULL
;
2482 struct value_print_options opts
;
2483 struct type
*type
= NULL
;
2485 char *encoding
= NULL
;
2486 struct gdbarch
*gdbarch
= NULL
;
2491 gdbarch
= get_type_arch (value_type (value
));
2494 struct cleanup
*back_to
= varobj_ensure_python_env (var
);
2495 PyObject
*value_formatter
= var
->pretty_printer
;
2497 if (value_formatter
)
2499 /* First check to see if we have any children at all. If so,
2500 we simply return {...}. */
2501 if (dynamic_varobj_has_child_method (var
))
2502 return xstrdup ("{...}");
2504 if (PyObject_HasAttr (value_formatter
, gdbpy_to_string_cst
))
2507 struct value
*replacement
;
2508 int string_print
= 0;
2509 PyObject
*output
= NULL
;
2511 hint
= gdbpy_get_display_hint (value_formatter
);
2514 if (!strcmp (hint
, "string"))
2519 output
= apply_varobj_pretty_printer (value_formatter
,
2523 if (gdbpy_is_lazy_string (output
))
2525 thevalue
= gdbpy_extract_lazy_string (output
, &type
,
2532 = python_string_to_target_python_string (output
);
2536 char *s
= PyString_AsString (py_str
);
2538 len
= PyString_Size (py_str
);
2539 thevalue
= xmemdup (s
, len
+ 1, len
+ 1);
2540 type
= builtin_type (gdbarch
)->builtin_char
;
2546 if (thevalue
&& !string_print
)
2548 do_cleanups (back_to
);
2553 value
= replacement
;
2556 do_cleanups (back_to
);
2560 stb
= mem_fileopen ();
2561 old_chain
= make_cleanup_ui_file_delete (stb
);
2563 get_formatted_print_options (&opts
, format_code
[(int) format
]);
2568 make_cleanup (xfree
, thevalue
);
2569 make_cleanup (xfree
, encoding
);
2570 LA_PRINT_STRING (stb
, type
, thevalue
, len
, encoding
, 0, &opts
);
2573 common_val_print (value
, stb
, 0, &opts
, current_language
);
2574 thevalue
= ui_file_xstrdup (stb
, NULL
);
2576 do_cleanups (old_chain
);
2581 varobj_editable_p (struct varobj
*var
)
2585 if (!(var
->root
->is_valid
&& var
->value
&& VALUE_LVAL (var
->value
)))
2588 type
= get_value_type (var
);
2590 switch (TYPE_CODE (type
))
2592 case TYPE_CODE_STRUCT
:
2593 case TYPE_CODE_UNION
:
2594 case TYPE_CODE_ARRAY
:
2595 case TYPE_CODE_FUNC
:
2596 case TYPE_CODE_METHOD
:
2606 /* Return non-zero if changes in value of VAR
2607 must be detected and reported by -var-update.
2608 Return zero is -var-update should never report
2609 changes of such values. This makes sense for structures
2610 (since the changes in children values will be reported separately),
2611 or for artifical objects (like 'public' pseudo-field in C++).
2613 Return value of 0 means that gdb need not call value_fetch_lazy
2614 for the value of this variable object. */
2616 varobj_value_is_changeable_p (struct varobj
*var
)
2621 if (CPLUS_FAKE_CHILD (var
))
2624 type
= get_value_type (var
);
2626 switch (TYPE_CODE (type
))
2628 case TYPE_CODE_STRUCT
:
2629 case TYPE_CODE_UNION
:
2630 case TYPE_CODE_ARRAY
:
2641 /* Return 1 if that varobj is floating, that is is always evaluated in the
2642 selected frame, and not bound to thread/frame. Such variable objects
2643 are created using '@' as frame specifier to -var-create. */
2645 varobj_floating_p (struct varobj
*var
)
2647 return var
->root
->floating
;
2650 /* Given the value and the type of a variable object,
2651 adjust the value and type to those necessary
2652 for getting children of the variable object.
2653 This includes dereferencing top-level references
2654 to all types and dereferencing pointers to
2657 Both TYPE and *TYPE should be non-null. VALUE
2658 can be null if we want to only translate type.
2659 *VALUE can be null as well -- if the parent
2662 If WAS_PTR is not NULL, set *WAS_PTR to 0 or 1
2663 depending on whether pointer was dereferenced
2664 in this function. */
2666 adjust_value_for_child_access (struct value
**value
,
2670 gdb_assert (type
&& *type
);
2675 *type
= check_typedef (*type
);
2677 /* The type of value stored in varobj, that is passed
2678 to us, is already supposed to be
2679 reference-stripped. */
2681 gdb_assert (TYPE_CODE (*type
) != TYPE_CODE_REF
);
2683 /* Pointers to structures are treated just like
2684 structures when accessing children. Don't
2685 dererences pointers to other types. */
2686 if (TYPE_CODE (*type
) == TYPE_CODE_PTR
)
2688 struct type
*target_type
= get_target_type (*type
);
2689 if (TYPE_CODE (target_type
) == TYPE_CODE_STRUCT
2690 || TYPE_CODE (target_type
) == TYPE_CODE_UNION
)
2692 if (value
&& *value
)
2694 int success
= gdb_value_ind (*value
, value
);
2699 *type
= target_type
;
2705 /* The 'get_target_type' function calls check_typedef on
2706 result, so we can immediately check type code. No
2707 need to call check_typedef here. */
2712 c_number_of_children (struct varobj
*var
)
2714 struct type
*type
= get_value_type (var
);
2716 struct type
*target
;
2718 adjust_value_for_child_access (NULL
, &type
, NULL
);
2719 target
= get_target_type (type
);
2721 switch (TYPE_CODE (type
))
2723 case TYPE_CODE_ARRAY
:
2724 if (TYPE_LENGTH (type
) > 0 && TYPE_LENGTH (target
) > 0
2725 && !TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type
))
2726 children
= TYPE_LENGTH (type
) / TYPE_LENGTH (target
);
2728 /* If we don't know how many elements there are, don't display
2733 case TYPE_CODE_STRUCT
:
2734 case TYPE_CODE_UNION
:
2735 children
= TYPE_NFIELDS (type
);
2739 /* The type here is a pointer to non-struct. Typically, pointers
2740 have one child, except for function ptrs, which have no children,
2741 and except for void*, as we don't know what to show.
2743 We can show char* so we allow it to be dereferenced. If you decide
2744 to test for it, please mind that a little magic is necessary to
2745 properly identify it: char* has TYPE_CODE == TYPE_CODE_INT and
2746 TYPE_NAME == "char" */
2747 if (TYPE_CODE (target
) == TYPE_CODE_FUNC
2748 || TYPE_CODE (target
) == TYPE_CODE_VOID
)
2755 /* Other types have no children */
2763 c_name_of_variable (struct varobj
*parent
)
2765 return xstrdup (parent
->name
);
2768 /* Return the value of element TYPE_INDEX of a structure
2769 value VALUE. VALUE's type should be a structure,
2770 or union, or a typedef to struct/union.
2772 Returns NULL if getting the value fails. Never throws. */
2773 static struct value
*
2774 value_struct_element_index (struct value
*value
, int type_index
)
2776 struct value
*result
= NULL
;
2777 volatile struct gdb_exception e
;
2778 struct type
*type
= value_type (value
);
2780 type
= check_typedef (type
);
2782 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
2783 || TYPE_CODE (type
) == TYPE_CODE_UNION
);
2785 TRY_CATCH (e
, RETURN_MASK_ERROR
)
2787 if (field_is_static (&TYPE_FIELD (type
, type_index
)))
2788 result
= value_static_field (type
, type_index
);
2790 result
= value_primitive_field (value
, 0, type_index
, type
);
2802 /* Obtain the information about child INDEX of the variable
2804 If CNAME is not null, sets *CNAME to the name of the child relative
2806 If CVALUE is not null, sets *CVALUE to the value of the child.
2807 If CTYPE is not null, sets *CTYPE to the type of the child.
2809 If any of CNAME, CVALUE, or CTYPE is not null, but the corresponding
2810 information cannot be determined, set *CNAME, *CVALUE, or *CTYPE
2813 c_describe_child (struct varobj
*parent
, int index
,
2814 char **cname
, struct value
**cvalue
, struct type
**ctype
,
2815 char **cfull_expression
)
2817 struct value
*value
= parent
->value
;
2818 struct type
*type
= get_value_type (parent
);
2819 char *parent_expression
= NULL
;
2828 if (cfull_expression
)
2830 *cfull_expression
= NULL
;
2831 parent_expression
= varobj_get_path_expr (parent
);
2833 adjust_value_for_child_access (&value
, &type
, &was_ptr
);
2835 switch (TYPE_CODE (type
))
2837 case TYPE_CODE_ARRAY
:
2839 *cname
= xstrdup (int_string (index
2840 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
)),
2843 if (cvalue
&& value
)
2845 int real_index
= index
+ TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
));
2847 gdb_value_subscript (value
, real_index
, cvalue
);
2851 *ctype
= get_target_type (type
);
2853 if (cfull_expression
)
2855 xstrprintf ("(%s)[%s]", parent_expression
,
2857 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
)),
2863 case TYPE_CODE_STRUCT
:
2864 case TYPE_CODE_UNION
:
2866 *cname
= xstrdup (TYPE_FIELD_NAME (type
, index
));
2868 if (cvalue
&& value
)
2870 /* For C, varobj index is the same as type index. */
2871 *cvalue
= value_struct_element_index (value
, index
);
2875 *ctype
= TYPE_FIELD_TYPE (type
, index
);
2877 if (cfull_expression
)
2879 char *join
= was_ptr
? "->" : ".";
2881 *cfull_expression
= xstrprintf ("(%s)%s%s", parent_expression
, join
,
2882 TYPE_FIELD_NAME (type
, index
));
2889 *cname
= xstrprintf ("*%s", parent
->name
);
2891 if (cvalue
&& value
)
2893 int success
= gdb_value_ind (value
, cvalue
);
2899 /* Don't use get_target_type because it calls
2900 check_typedef and here, we want to show the true
2901 declared type of the variable. */
2903 *ctype
= TYPE_TARGET_TYPE (type
);
2905 if (cfull_expression
)
2906 *cfull_expression
= xstrprintf ("*(%s)", parent_expression
);
2911 /* This should not happen */
2913 *cname
= xstrdup ("???");
2914 if (cfull_expression
)
2915 *cfull_expression
= xstrdup ("???");
2916 /* Don't set value and type, we don't know then. */
2921 c_name_of_child (struct varobj
*parent
, int index
)
2925 c_describe_child (parent
, index
, &name
, NULL
, NULL
, NULL
);
2930 c_path_expr_of_child (struct varobj
*child
)
2932 c_describe_child (child
->parent
, child
->index
, NULL
, NULL
, NULL
,
2934 return child
->path_expr
;
2937 /* If frame associated with VAR can be found, switch
2938 to it and return 1. Otherwise, return 0. */
2940 check_scope (struct varobj
*var
)
2942 struct frame_info
*fi
;
2945 fi
= frame_find_by_id (var
->root
->frame
);
2950 CORE_ADDR pc
= get_frame_pc (fi
);
2952 if (pc
< BLOCK_START (var
->root
->valid_block
) ||
2953 pc
>= BLOCK_END (var
->root
->valid_block
))
2961 static struct value
*
2962 c_value_of_root (struct varobj
**var_handle
)
2964 struct value
*new_val
= NULL
;
2965 struct varobj
*var
= *var_handle
;
2966 int within_scope
= 0;
2967 struct cleanup
*back_to
;
2969 /* Only root variables can be updated... */
2970 if (!is_root_p (var
))
2971 /* Not a root var */
2974 back_to
= make_cleanup_restore_current_thread ();
2976 /* Determine whether the variable is still around. */
2977 if (var
->root
->valid_block
== NULL
|| var
->root
->floating
)
2979 else if (var
->root
->thread_id
== 0)
2981 /* The program was single-threaded when the variable object was
2982 created. Technically, it's possible that the program became
2983 multi-threaded since then, but we don't support such
2985 within_scope
= check_scope (var
);
2989 ptid_t ptid
= thread_id_to_pid (var
->root
->thread_id
);
2990 if (in_thread_list (ptid
))
2992 switch_to_thread (ptid
);
2993 within_scope
= check_scope (var
);
2999 /* We need to catch errors here, because if evaluate
3000 expression fails we want to just return NULL. */
3001 gdb_evaluate_expression (var
->root
->exp
, &new_val
);
3005 do_cleanups (back_to
);
3010 static struct value
*
3011 c_value_of_child (struct varobj
*parent
, int index
)
3013 struct value
*value
= NULL
;
3015 c_describe_child (parent
, index
, NULL
, &value
, NULL
, NULL
);
3019 static struct type
*
3020 c_type_of_child (struct varobj
*parent
, int index
)
3022 struct type
*type
= NULL
;
3024 c_describe_child (parent
, index
, NULL
, NULL
, &type
, NULL
);
3029 c_value_of_variable (struct varobj
*var
, enum varobj_display_formats format
)
3031 /* BOGUS: if val_print sees a struct/class, or a reference to one,
3032 it will print out its children instead of "{...}". So we need to
3033 catch that case explicitly. */
3034 struct type
*type
= get_type (var
);
3036 /* If we have a custom formatter, return whatever string it has
3038 if (var
->pretty_printer
&& var
->print_value
)
3039 return xstrdup (var
->print_value
);
3041 /* Strip top-level references. */
3042 while (TYPE_CODE (type
) == TYPE_CODE_REF
)
3043 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3045 switch (TYPE_CODE (type
))
3047 case TYPE_CODE_STRUCT
:
3048 case TYPE_CODE_UNION
:
3049 return xstrdup ("{...}");
3052 case TYPE_CODE_ARRAY
:
3056 number
= xstrprintf ("[%d]", var
->num_children
);
3063 if (var
->value
== NULL
)
3065 /* This can happen if we attempt to get the value of a struct
3066 member when the parent is an invalid pointer. This is an
3067 error condition, so we should tell the caller. */
3072 if (var
->not_fetched
&& value_lazy (var
->value
))
3073 /* Frozen variable and no value yet. We don't
3074 implicitly fetch the value. MI response will
3075 use empty string for the value, which is OK. */
3078 gdb_assert (varobj_value_is_changeable_p (var
));
3079 gdb_assert (!value_lazy (var
->value
));
3081 /* If the specified format is the current one,
3082 we can reuse print_value */
3083 if (format
== var
->format
)
3084 return xstrdup (var
->print_value
);
3086 return value_get_print_value (var
->value
, format
, var
);
3096 cplus_number_of_children (struct varobj
*var
)
3099 int children
, dont_know
;
3104 if (!CPLUS_FAKE_CHILD (var
))
3106 type
= get_value_type (var
);
3107 adjust_value_for_child_access (NULL
, &type
, NULL
);
3109 if (((TYPE_CODE (type
)) == TYPE_CODE_STRUCT
) ||
3110 ((TYPE_CODE (type
)) == TYPE_CODE_UNION
))
3114 cplus_class_num_children (type
, kids
);
3115 if (kids
[v_public
] != 0)
3117 if (kids
[v_private
] != 0)
3119 if (kids
[v_protected
] != 0)
3122 /* Add any baseclasses */
3123 children
+= TYPE_N_BASECLASSES (type
);
3126 /* FIXME: save children in var */
3133 type
= get_value_type (var
->parent
);
3134 adjust_value_for_child_access (NULL
, &type
, NULL
);
3136 cplus_class_num_children (type
, kids
);
3137 if (strcmp (var
->name
, "public") == 0)
3138 children
= kids
[v_public
];
3139 else if (strcmp (var
->name
, "private") == 0)
3140 children
= kids
[v_private
];
3142 children
= kids
[v_protected
];
3147 children
= c_number_of_children (var
);
3152 /* Compute # of public, private, and protected variables in this class.
3153 That means we need to descend into all baseclasses and find out
3154 how many are there, too. */
3156 cplus_class_num_children (struct type
*type
, int children
[3])
3158 int i
, vptr_fieldno
;
3159 struct type
*basetype
= NULL
;
3161 children
[v_public
] = 0;
3162 children
[v_private
] = 0;
3163 children
[v_protected
] = 0;
3165 vptr_fieldno
= get_vptr_fieldno (type
, &basetype
);
3166 for (i
= TYPE_N_BASECLASSES (type
); i
< TYPE_NFIELDS (type
); i
++)
3168 /* If we have a virtual table pointer, omit it. Even if virtual
3169 table pointers are not specifically marked in the debug info,
3170 they should be artificial. */
3171 if ((type
== basetype
&& i
== vptr_fieldno
)
3172 || TYPE_FIELD_ARTIFICIAL (type
, i
))
3175 if (TYPE_FIELD_PROTECTED (type
, i
))
3176 children
[v_protected
]++;
3177 else if (TYPE_FIELD_PRIVATE (type
, i
))
3178 children
[v_private
]++;
3180 children
[v_public
]++;
3185 cplus_name_of_variable (struct varobj
*parent
)
3187 return c_name_of_variable (parent
);
3190 enum accessibility
{ private_field
, protected_field
, public_field
};
3192 /* Check if field INDEX of TYPE has the specified accessibility.
3193 Return 0 if so and 1 otherwise. */
3195 match_accessibility (struct type
*type
, int index
, enum accessibility acc
)
3197 if (acc
== private_field
&& TYPE_FIELD_PRIVATE (type
, index
))
3199 else if (acc
== protected_field
&& TYPE_FIELD_PROTECTED (type
, index
))
3201 else if (acc
== public_field
&& !TYPE_FIELD_PRIVATE (type
, index
)
3202 && !TYPE_FIELD_PROTECTED (type
, index
))
3209 cplus_describe_child (struct varobj
*parent
, int index
,
3210 char **cname
, struct value
**cvalue
, struct type
**ctype
,
3211 char **cfull_expression
)
3213 struct value
*value
;
3216 char *parent_expression
= NULL
;
3224 if (cfull_expression
)
3225 *cfull_expression
= NULL
;
3227 if (CPLUS_FAKE_CHILD (parent
))
3229 value
= parent
->parent
->value
;
3230 type
= get_value_type (parent
->parent
);
3231 if (cfull_expression
)
3232 parent_expression
= varobj_get_path_expr (parent
->parent
);
3236 value
= parent
->value
;
3237 type
= get_value_type (parent
);
3238 if (cfull_expression
)
3239 parent_expression
= varobj_get_path_expr (parent
);
3242 adjust_value_for_child_access (&value
, &type
, &was_ptr
);
3244 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
3245 || TYPE_CODE (type
) == TYPE_CODE_UNION
)
3247 char *join
= was_ptr
? "->" : ".";
3249 if (CPLUS_FAKE_CHILD (parent
))
3251 /* The fields of the class type are ordered as they
3252 appear in the class. We are given an index for a
3253 particular access control type ("public","protected",
3254 or "private"). We must skip over fields that don't
3255 have the access control we are looking for to properly
3256 find the indexed field. */
3257 int type_index
= TYPE_N_BASECLASSES (type
);
3258 enum accessibility acc
= public_field
;
3260 struct type
*basetype
= NULL
;
3262 vptr_fieldno
= get_vptr_fieldno (type
, &basetype
);
3263 if (strcmp (parent
->name
, "private") == 0)
3264 acc
= private_field
;
3265 else if (strcmp (parent
->name
, "protected") == 0)
3266 acc
= protected_field
;
3270 if ((type
== basetype
&& type_index
== vptr_fieldno
)
3271 || TYPE_FIELD_ARTIFICIAL (type
, type_index
))
3273 else if (match_accessibility (type
, type_index
, acc
))
3280 *cname
= xstrdup (TYPE_FIELD_NAME (type
, type_index
));
3282 if (cvalue
&& value
)
3283 *cvalue
= value_struct_element_index (value
, type_index
);
3286 *ctype
= TYPE_FIELD_TYPE (type
, type_index
);
3288 if (cfull_expression
)
3289 *cfull_expression
= xstrprintf ("((%s)%s%s)", parent_expression
,
3291 TYPE_FIELD_NAME (type
, type_index
));
3293 else if (index
< TYPE_N_BASECLASSES (type
))
3295 /* This is a baseclass. */
3297 *cname
= xstrdup (TYPE_FIELD_NAME (type
, index
));
3299 if (cvalue
&& value
)
3300 *cvalue
= value_cast (TYPE_FIELD_TYPE (type
, index
), value
);
3304 *ctype
= TYPE_FIELD_TYPE (type
, index
);
3307 if (cfull_expression
)
3309 char *ptr
= was_ptr
? "*" : "";
3311 /* Cast the parent to the base' type. Note that in gdb,
3314 will create an lvalue, for all appearences, so we don't
3315 need to use more fancy:
3318 *cfull_expression
= xstrprintf ("(%s(%s%s) %s)",
3320 TYPE_FIELD_NAME (type
, index
),
3327 char *access
= NULL
;
3330 cplus_class_num_children (type
, children
);
3332 /* Everything beyond the baseclasses can
3333 only be "public", "private", or "protected"
3335 The special "fake" children are always output by varobj in
3336 this order. So if INDEX == 2, it MUST be "protected". */
3337 index
-= TYPE_N_BASECLASSES (type
);
3341 if (children
[v_public
] > 0)
3343 else if (children
[v_private
] > 0)
3346 access
= "protected";
3349 if (children
[v_public
] > 0)
3351 if (children
[v_private
] > 0)
3354 access
= "protected";
3356 else if (children
[v_private
] > 0)
3357 access
= "protected";
3360 /* Must be protected */
3361 access
= "protected";
3368 gdb_assert (access
);
3370 *cname
= xstrdup (access
);
3372 /* Value and type and full expression are null here. */
3377 c_describe_child (parent
, index
, cname
, cvalue
, ctype
, cfull_expression
);
3382 cplus_name_of_child (struct varobj
*parent
, int index
)
3386 cplus_describe_child (parent
, index
, &name
, NULL
, NULL
, NULL
);
3391 cplus_path_expr_of_child (struct varobj
*child
)
3393 cplus_describe_child (child
->parent
, child
->index
, NULL
, NULL
, NULL
,
3395 return child
->path_expr
;
3398 static struct value
*
3399 cplus_value_of_root (struct varobj
**var_handle
)
3401 return c_value_of_root (var_handle
);
3404 static struct value
*
3405 cplus_value_of_child (struct varobj
*parent
, int index
)
3407 struct value
*value
= NULL
;
3409 cplus_describe_child (parent
, index
, NULL
, &value
, NULL
, NULL
);
3413 static struct type
*
3414 cplus_type_of_child (struct varobj
*parent
, int index
)
3416 struct type
*type
= NULL
;
3418 cplus_describe_child (parent
, index
, NULL
, NULL
, &type
, NULL
);
3423 cplus_value_of_variable (struct varobj
*var
,
3424 enum varobj_display_formats format
)
3427 /* If we have one of our special types, don't print out
3429 if (CPLUS_FAKE_CHILD (var
))
3430 return xstrdup ("");
3432 return c_value_of_variable (var
, format
);
3438 java_number_of_children (struct varobj
*var
)
3440 return cplus_number_of_children (var
);
3444 java_name_of_variable (struct varobj
*parent
)
3448 name
= cplus_name_of_variable (parent
);
3449 /* If the name has "-" in it, it is because we
3450 needed to escape periods in the name... */
3453 while (*p
!= '\000')
3464 java_name_of_child (struct varobj
*parent
, int index
)
3468 name
= cplus_name_of_child (parent
, index
);
3469 /* Escape any periods in the name... */
3472 while (*p
!= '\000')
3483 java_path_expr_of_child (struct varobj
*child
)
3488 static struct value
*
3489 java_value_of_root (struct varobj
**var_handle
)
3491 return cplus_value_of_root (var_handle
);
3494 static struct value
*
3495 java_value_of_child (struct varobj
*parent
, int index
)
3497 return cplus_value_of_child (parent
, index
);
3500 static struct type
*
3501 java_type_of_child (struct varobj
*parent
, int index
)
3503 return cplus_type_of_child (parent
, index
);
3507 java_value_of_variable (struct varobj
*var
, enum varobj_display_formats format
)
3509 return cplus_value_of_variable (var
, format
);
3512 /* Iterate all the existing _root_ VAROBJs and call the FUNC callback for them
3513 with an arbitrary caller supplied DATA pointer. */
3516 all_root_varobjs (void (*func
) (struct varobj
*var
, void *data
), void *data
)
3518 struct varobj_root
*var_root
, *var_root_next
;
3520 /* Iterate "safely" - handle if the callee deletes its passed VAROBJ. */
3522 for (var_root
= rootlist
; var_root
!= NULL
; var_root
= var_root_next
)
3524 var_root_next
= var_root
->next
;
3526 (*func
) (var_root
->rootvar
, data
);
3530 extern void _initialize_varobj (void);
3532 _initialize_varobj (void)
3534 int sizeof_table
= sizeof (struct vlist
*) * VAROBJ_TABLE_SIZE
;
3536 varobj_table
= xmalloc (sizeof_table
);
3537 memset (varobj_table
, 0, sizeof_table
);
3539 add_setshow_zinteger_cmd ("debugvarobj", class_maintenance
,
3541 Set varobj debugging."), _("\
3542 Show varobj debugging."), _("\
3543 When non-zero, varobj debugging is enabled."),
3546 &setlist
, &showlist
);
3549 /* Invalidate varobj VAR if it is tied to locals and re-create it if it is
3550 defined on globals. It is a helper for varobj_invalidate. */
3553 varobj_invalidate_iter (struct varobj
*var
, void *unused
)
3555 /* Floating varobjs are reparsed on each stop, so we don't care if the
3556 presently parsed expression refers to something that's gone. */
3557 if (var
->root
->floating
)
3560 /* global var must be re-evaluated. */
3561 if (var
->root
->valid_block
== NULL
)
3563 struct varobj
*tmp_var
;
3565 /* Try to create a varobj with same expression. If we succeed
3566 replace the old varobj, otherwise invalidate it. */
3567 tmp_var
= varobj_create (NULL
, var
->name
, (CORE_ADDR
) 0,
3569 if (tmp_var
!= NULL
)
3571 tmp_var
->obj_name
= xstrdup (var
->obj_name
);
3572 varobj_delete (var
, NULL
, 0);
3573 install_variable (tmp_var
);
3576 var
->root
->is_valid
= 0;
3578 else /* locals must be invalidated. */
3579 var
->root
->is_valid
= 0;
3582 /* Invalidate the varobjs that are tied to locals and re-create the ones that
3583 are defined on globals.
3584 Invalidated varobjs will be always printed in_scope="invalid". */
3587 varobj_invalidate (void)
3589 all_root_varobjs (varobj_invalidate_iter
, NULL
);