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
*varobj_add_child (struct varobj
*var
,
301 struct value
*value
);
303 #endif /* HAVE_PYTHON */
305 /* C implementation */
307 static int c_number_of_children (struct varobj
*var
);
309 static char *c_name_of_variable (struct varobj
*parent
);
311 static char *c_name_of_child (struct varobj
*parent
, int index
);
313 static char *c_path_expr_of_child (struct varobj
*child
);
315 static struct value
*c_value_of_root (struct varobj
**var_handle
);
317 static struct value
*c_value_of_child (struct varobj
*parent
, int index
);
319 static struct type
*c_type_of_child (struct varobj
*parent
, int index
);
321 static char *c_value_of_variable (struct varobj
*var
,
322 enum varobj_display_formats format
);
324 /* C++ implementation */
326 static int cplus_number_of_children (struct varobj
*var
);
328 static void cplus_class_num_children (struct type
*type
, int children
[3]);
330 static char *cplus_name_of_variable (struct varobj
*parent
);
332 static char *cplus_name_of_child (struct varobj
*parent
, int index
);
334 static char *cplus_path_expr_of_child (struct varobj
*child
);
336 static struct value
*cplus_value_of_root (struct varobj
**var_handle
);
338 static struct value
*cplus_value_of_child (struct varobj
*parent
, int index
);
340 static struct type
*cplus_type_of_child (struct varobj
*parent
, int index
);
342 static char *cplus_value_of_variable (struct varobj
*var
,
343 enum varobj_display_formats format
);
345 /* Java implementation */
347 static int java_number_of_children (struct varobj
*var
);
349 static char *java_name_of_variable (struct varobj
*parent
);
351 static char *java_name_of_child (struct varobj
*parent
, int index
);
353 static char *java_path_expr_of_child (struct varobj
*child
);
355 static struct value
*java_value_of_root (struct varobj
**var_handle
);
357 static struct value
*java_value_of_child (struct varobj
*parent
, int index
);
359 static struct type
*java_type_of_child (struct varobj
*parent
, int index
);
361 static char *java_value_of_variable (struct varobj
*var
,
362 enum varobj_display_formats format
);
364 /* The language specific vector */
366 struct language_specific
369 /* The language of this variable. */
370 enum varobj_languages language
;
372 /* The number of children of PARENT. */
373 int (*number_of_children
) (struct varobj
* parent
);
375 /* The name (expression) of a root varobj. */
376 char *(*name_of_variable
) (struct varobj
* parent
);
378 /* The name of the INDEX'th child of PARENT. */
379 char *(*name_of_child
) (struct varobj
* parent
, int index
);
381 /* Returns the rooted expression of CHILD, which is a variable
382 obtain that has some parent. */
383 char *(*path_expr_of_child
) (struct varobj
* child
);
385 /* The ``struct value *'' of the root variable ROOT. */
386 struct value
*(*value_of_root
) (struct varobj
** root_handle
);
388 /* The ``struct value *'' of the INDEX'th child of PARENT. */
389 struct value
*(*value_of_child
) (struct varobj
* parent
, int index
);
391 /* The type of the INDEX'th child of PARENT. */
392 struct type
*(*type_of_child
) (struct varobj
* parent
, int index
);
394 /* The current value of VAR. */
395 char *(*value_of_variable
) (struct varobj
* var
,
396 enum varobj_display_formats format
);
399 /* Array of known source language routines. */
400 static struct language_specific languages
[vlang_end
] = {
401 /* Unknown (try treating as C). */
404 c_number_of_children
,
407 c_path_expr_of_child
,
416 c_number_of_children
,
419 c_path_expr_of_child
,
428 cplus_number_of_children
,
429 cplus_name_of_variable
,
431 cplus_path_expr_of_child
,
433 cplus_value_of_child
,
435 cplus_value_of_variable
}
440 java_number_of_children
,
441 java_name_of_variable
,
443 java_path_expr_of_child
,
447 java_value_of_variable
}
450 /* A little convenience enum for dealing with C++/Java. */
453 v_public
= 0, v_private
, v_protected
458 /* Mappings of varobj_display_formats enums to gdb's format codes. */
459 static int format_code
[] = { 0, 't', 'd', 'x', 'o' };
461 /* Header of the list of root variable objects. */
462 static struct varobj_root
*rootlist
;
464 /* Prime number indicating the number of buckets in the hash table. */
465 /* A prime large enough to avoid too many colisions. */
466 #define VAROBJ_TABLE_SIZE 227
468 /* Pointer to the varobj hash table (built at run time). */
469 static struct vlist
**varobj_table
;
471 /* Is the variable X one of our "fake" children? */
472 #define CPLUS_FAKE_CHILD(x) \
473 ((x) != NULL && (x)->type == NULL && (x)->value == NULL)
476 /* API Implementation */
478 is_root_p (struct varobj
*var
)
480 return (var
->root
->rootvar
== var
);
484 /* Helper function to install a Python environment suitable for
485 use during operations on VAR. */
487 varobj_ensure_python_env (struct varobj
*var
)
489 return ensure_python_env (var
->root
->exp
->gdbarch
,
490 var
->root
->exp
->language_defn
);
494 /* Creates a varobj (not its children). */
496 /* Return the full FRAME which corresponds to the given CORE_ADDR
497 or NULL if no FRAME on the chain corresponds to CORE_ADDR. */
499 static struct frame_info
*
500 find_frame_addr_in_frame_chain (CORE_ADDR frame_addr
)
502 struct frame_info
*frame
= NULL
;
504 if (frame_addr
== (CORE_ADDR
) 0)
507 for (frame
= get_current_frame ();
509 frame
= get_prev_frame (frame
))
511 /* The CORE_ADDR we get as argument was parsed from a string GDB
512 output as $fp. This output got truncated to gdbarch_addr_bit.
513 Truncate the frame base address in the same manner before
514 comparing it against our argument. */
515 CORE_ADDR frame_base
= get_frame_base_address (frame
);
516 int addr_bit
= gdbarch_addr_bit (get_frame_arch (frame
));
518 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
519 frame_base
&= ((CORE_ADDR
) 1 << addr_bit
) - 1;
521 if (frame_base
== frame_addr
)
529 varobj_create (char *objname
,
530 char *expression
, CORE_ADDR frame
, enum varobj_type type
)
533 struct cleanup
*old_chain
;
535 /* Fill out a varobj structure for the (root) variable being constructed. */
536 var
= new_root_variable ();
537 old_chain
= make_cleanup_free_variable (var
);
539 if (expression
!= NULL
)
541 struct frame_info
*fi
;
542 struct frame_id old_id
= null_frame_id
;
545 enum varobj_languages lang
;
546 struct value
*value
= NULL
;
548 /* Parse and evaluate the expression, filling in as much of the
549 variable's data as possible. */
551 if (has_stack_frames ())
553 /* Allow creator to specify context of variable. */
554 if ((type
== USE_CURRENT_FRAME
) || (type
== USE_SELECTED_FRAME
))
555 fi
= get_selected_frame (NULL
);
557 /* FIXME: cagney/2002-11-23: This code should be doing a
558 lookup using the frame ID and not just the frame's
559 ``address''. This, of course, means an interface
560 change. However, with out that interface change ISAs,
561 such as the ia64 with its two stacks, won't work.
562 Similar goes for the case where there is a frameless
564 fi
= find_frame_addr_in_frame_chain (frame
);
569 /* frame = -2 means always use selected frame. */
570 if (type
== USE_SELECTED_FRAME
)
571 var
->root
->floating
= 1;
575 block
= get_frame_block (fi
, 0);
578 innermost_block
= NULL
;
579 /* Wrap the call to parse expression, so we can
580 return a sensible error. */
581 if (!gdb_parse_exp_1 (&p
, block
, 0, &var
->root
->exp
))
586 /* Don't allow variables to be created for types. */
587 if (var
->root
->exp
->elts
[0].opcode
== OP_TYPE
)
589 do_cleanups (old_chain
);
590 fprintf_unfiltered (gdb_stderr
, "Attempt to use a type name"
591 " as an expression.\n");
595 var
->format
= variable_default_display (var
);
596 var
->root
->valid_block
= innermost_block
;
597 var
->name
= xstrdup (expression
);
598 /* For a root var, the name and the expr are the same. */
599 var
->path_expr
= xstrdup (expression
);
601 /* When the frame is different from the current frame,
602 we must select the appropriate frame before parsing
603 the expression, otherwise the value will not be current.
604 Since select_frame is so benign, just call it for all cases. */
607 /* User could specify explicit FRAME-ADDR which was not found but
608 EXPRESSION is frame specific and we would not be able to evaluate
609 it correctly next time. With VALID_BLOCK set we must also set
610 FRAME and THREAD_ID. */
612 error (_("Failed to find the specified frame"));
614 var
->root
->frame
= get_frame_id (fi
);
615 var
->root
->thread_id
= pid_to_thread_id (inferior_ptid
);
616 old_id
= get_frame_id (get_selected_frame (NULL
));
620 /* We definitely need to catch errors here.
621 If evaluate_expression succeeds we got the value we wanted.
622 But if it fails, we still go on with a call to evaluate_type(). */
623 if (!gdb_evaluate_expression (var
->root
->exp
, &value
))
625 /* Error getting the value. Try to at least get the
627 struct value
*type_only_value
= evaluate_type (var
->root
->exp
);
629 var
->type
= value_type (type_only_value
);
632 var
->type
= value_type (value
);
634 install_new_value (var
, value
, 1 /* Initial assignment */);
636 /* Set language info */
637 lang
= variable_language (var
);
638 var
->root
->lang
= &languages
[lang
];
640 /* Set ourselves as our root. */
641 var
->root
->rootvar
= var
;
643 /* Reset the selected frame. */
644 if (frame_id_p (old_id
))
645 select_frame (frame_find_by_id (old_id
));
648 /* If the variable object name is null, that means this
649 is a temporary variable, so don't install it. */
651 if ((var
!= NULL
) && (objname
!= NULL
))
653 var
->obj_name
= xstrdup (objname
);
655 /* If a varobj name is duplicated, the install will fail so
657 if (!install_variable (var
))
659 do_cleanups (old_chain
);
664 discard_cleanups (old_chain
);
668 /* Generates an unique name that can be used for a varobj. */
671 varobj_gen_name (void)
676 /* Generate a name for this object. */
678 obj_name
= xstrprintf ("var%d", id
);
683 /* Given an OBJNAME, returns the pointer to the corresponding varobj. Call
684 error if OBJNAME cannot be found. */
687 varobj_get_handle (char *objname
)
691 unsigned int index
= 0;
694 for (chp
= objname
; *chp
; chp
++)
696 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
699 cv
= *(varobj_table
+ index
);
700 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, objname
) != 0))
704 error (_("Variable object not found"));
709 /* Given the handle, return the name of the object. */
712 varobj_get_objname (struct varobj
*var
)
714 return var
->obj_name
;
717 /* Given the handle, return the expression represented by the object. */
720 varobj_get_expression (struct varobj
*var
)
722 return name_of_variable (var
);
725 /* Deletes a varobj and all its children if only_children == 0,
726 otherwise deletes only the children; returns a malloc'ed list of
727 all the (malloc'ed) names of the variables that have been deleted
728 (NULL terminated). */
731 varobj_delete (struct varobj
*var
, char ***dellist
, int only_children
)
735 struct cpstack
*result
= NULL
;
738 /* Initialize a stack for temporary results. */
739 cppush (&result
, NULL
);
742 /* Delete only the variable children. */
743 delcount
= delete_variable (&result
, var
, 1 /* only the children */ );
745 /* Delete the variable and all its children. */
746 delcount
= delete_variable (&result
, var
, 0 /* parent+children */ );
748 /* We may have been asked to return a list of what has been deleted. */
751 *dellist
= xmalloc ((delcount
+ 1) * sizeof (char *));
755 *cp
= cppop (&result
);
756 while ((*cp
!= NULL
) && (mycount
> 0))
760 *cp
= cppop (&result
);
763 if (mycount
|| (*cp
!= NULL
))
764 warning (_("varobj_delete: assertion failed - mycount(=%d) <> 0"),
773 /* Convenience function for varobj_set_visualizer. Instantiate a
774 pretty-printer for a given value. */
776 instantiate_pretty_printer (PyObject
*constructor
, struct value
*value
)
778 PyObject
*val_obj
= NULL
;
781 val_obj
= value_to_value_object (value
);
785 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
)
1031 /* See if there was a leftover from last time. */
1032 if (var
->saved_item
)
1034 item
= var
->saved_item
;
1035 var
->saved_item
= NULL
;
1038 item
= PyIter_Next (var
->child_iter
);
1042 /* Normal end of iteration. */
1043 if (!PyErr_Occurred ())
1046 /* If we got a memory error, just use the text as the
1048 if (PyErr_ExceptionMatches (gdbpy_gdb_memory_error
))
1050 PyObject
*type
, *value
, *trace
;
1051 char *name_str
, *value_str
;
1053 PyErr_Fetch (&type
, &value
, &trace
);
1054 value_str
= gdbpy_exception_to_string (type
, value
);
1060 gdbpy_print_stack ();
1064 name_str
= xstrprintf ("<error at %d>", i
);
1065 item
= Py_BuildValue ("(ss)", name_str
, value_str
);
1070 gdbpy_print_stack ();
1078 /* Any other kind of error. */
1079 gdbpy_print_stack ();
1084 /* We don't want to push the extra child on any report list. */
1085 if (to
< 0 || i
< to
)
1090 struct cleanup
*inner
;
1091 int can_mention
= from
< 0 || i
>= from
;
1093 inner
= make_cleanup_py_decref (item
);
1095 if (!PyArg_ParseTuple (item
, "sO", &name
, &py_v
))
1097 gdbpy_print_stack ();
1098 error (_("Invalid item from the child list"));
1101 v
= convert_value_from_python (py_v
);
1103 gdbpy_print_stack ();
1104 install_dynamic_child (var
, can_mention
? changed
: NULL
,
1105 can_mention
? new : NULL
,
1106 can_mention
? unchanged
: NULL
,
1107 can_mention
? cchanged
: NULL
, i
, name
, v
);
1108 do_cleanups (inner
);
1112 Py_XDECREF (var
->saved_item
);
1113 var
->saved_item
= item
;
1115 /* We want to truncate the child list just before this
1124 if (i
< VEC_length (varobj_p
, var
->children
))
1129 for (j
= i
; j
< VEC_length (varobj_p
, var
->children
); ++j
)
1130 varobj_delete (VEC_index (varobj_p
, var
->children
, j
), NULL
, 0);
1131 VEC_truncate (varobj_p
, var
->children
, i
);
1134 /* If there are fewer children than requested, note that the list of
1135 children changed. */
1136 if (to
>= 0 && VEC_length (varobj_p
, var
->children
) < to
)
1139 var
->num_children
= VEC_length (varobj_p
, var
->children
);
1141 do_cleanups (back_to
);
1145 gdb_assert (0 && "should never be called if Python is not enabled");
1150 varobj_get_num_children (struct varobj
*var
)
1152 if (var
->num_children
== -1)
1154 if (var
->pretty_printer
)
1158 /* If we have a dynamic varobj, don't report -1 children.
1159 So, try to fetch some children first. */
1160 update_dynamic_varobj_children (var
, NULL
, NULL
, NULL
, &dummy
,
1164 var
->num_children
= number_of_children (var
);
1167 return var
->num_children
>= 0 ? var
->num_children
: 0;
1170 /* Creates a list of the immediate children of a variable object;
1171 the return code is the number of such children or -1 on error. */
1174 varobj_list_children (struct varobj
*var
, int *from
, int *to
)
1177 int i
, children_changed
;
1179 var
->children_requested
= 1;
1181 if (var
->pretty_printer
)
1183 /* This, in theory, can result in the number of children changing without
1184 frontend noticing. But well, calling -var-list-children on the same
1185 varobj twice is not something a sane frontend would do. */
1186 update_dynamic_varobj_children (var
, NULL
, NULL
, NULL
, &children_changed
,
1188 restrict_range (var
->children
, from
, to
);
1189 return var
->children
;
1192 if (var
->num_children
== -1)
1193 var
->num_children
= number_of_children (var
);
1195 /* If that failed, give up. */
1196 if (var
->num_children
== -1)
1197 return var
->children
;
1199 /* If we're called when the list of children is not yet initialized,
1200 allocate enough elements in it. */
1201 while (VEC_length (varobj_p
, var
->children
) < var
->num_children
)
1202 VEC_safe_push (varobj_p
, var
->children
, NULL
);
1204 for (i
= 0; i
< var
->num_children
; i
++)
1206 varobj_p existing
= VEC_index (varobj_p
, var
->children
, i
);
1208 if (existing
== NULL
)
1210 /* Either it's the first call to varobj_list_children for
1211 this variable object, and the child was never created,
1212 or it was explicitly deleted by the client. */
1213 name
= name_of_child (var
, i
);
1214 existing
= create_child (var
, i
, name
);
1215 VEC_replace (varobj_p
, var
->children
, i
, existing
);
1219 restrict_range (var
->children
, from
, to
);
1220 return var
->children
;
1225 static struct varobj
*
1226 varobj_add_child (struct varobj
*var
, const char *name
, struct value
*value
)
1228 varobj_p v
= create_child_with_value (var
,
1229 VEC_length (varobj_p
, var
->children
),
1232 VEC_safe_push (varobj_p
, var
->children
, v
);
1236 #endif /* HAVE_PYTHON */
1238 /* Obtain the type of an object Variable as a string similar to the one gdb
1239 prints on the console. */
1242 varobj_get_type (struct varobj
*var
)
1244 /* For the "fake" variables, do not return a type. (It's type is
1246 Do not return a type for invalid variables as well. */
1247 if (CPLUS_FAKE_CHILD (var
) || !var
->root
->is_valid
)
1250 return type_to_string (var
->type
);
1253 /* Obtain the type of an object variable. */
1256 varobj_get_gdb_type (struct varobj
*var
)
1261 /* Return a pointer to the full rooted expression of varobj VAR.
1262 If it has not been computed yet, compute it. */
1264 varobj_get_path_expr (struct varobj
*var
)
1266 if (var
->path_expr
!= NULL
)
1267 return var
->path_expr
;
1270 /* For root varobjs, we initialize path_expr
1271 when creating varobj, so here it should be
1273 gdb_assert (!is_root_p (var
));
1274 return (*var
->root
->lang
->path_expr_of_child
) (var
);
1278 enum varobj_languages
1279 varobj_get_language (struct varobj
*var
)
1281 return variable_language (var
);
1285 varobj_get_attributes (struct varobj
*var
)
1289 if (varobj_editable_p (var
))
1290 /* FIXME: define masks for attributes. */
1291 attributes
|= 0x00000001; /* Editable */
1297 varobj_pretty_printed_p (struct varobj
*var
)
1299 return var
->pretty_printer
!= NULL
;
1303 varobj_get_formatted_value (struct varobj
*var
,
1304 enum varobj_display_formats format
)
1306 return my_value_of_variable (var
, format
);
1310 varobj_get_value (struct varobj
*var
)
1312 return my_value_of_variable (var
, var
->format
);
1315 /* Set the value of an object variable (if it is editable) to the
1316 value of the given expression. */
1317 /* Note: Invokes functions that can call error(). */
1320 varobj_set_value (struct varobj
*var
, char *expression
)
1324 /* The argument "expression" contains the variable's new value.
1325 We need to first construct a legal expression for this -- ugh! */
1326 /* Does this cover all the bases? */
1327 struct expression
*exp
;
1328 struct value
*value
;
1329 int saved_input_radix
= input_radix
;
1330 char *s
= expression
;
1332 gdb_assert (varobj_editable_p (var
));
1334 input_radix
= 10; /* ALWAYS reset to decimal temporarily. */
1335 exp
= parse_exp_1 (&s
, 0, 0);
1336 if (!gdb_evaluate_expression (exp
, &value
))
1338 /* We cannot proceed without a valid expression. */
1343 /* All types that are editable must also be changeable. */
1344 gdb_assert (varobj_value_is_changeable_p (var
));
1346 /* The value of a changeable variable object must not be lazy. */
1347 gdb_assert (!value_lazy (var
->value
));
1349 /* Need to coerce the input. We want to check if the
1350 value of the variable object will be different
1351 after assignment, and the first thing value_assign
1352 does is coerce the input.
1353 For example, if we are assigning an array to a pointer variable we
1354 should compare the pointer with the array's address, not with the
1356 value
= coerce_array (value
);
1358 /* The new value may be lazy. gdb_value_assign, or
1359 rather value_contents, will take care of this.
1360 If fetching of the new value will fail, gdb_value_assign
1361 with catch the exception. */
1362 if (!gdb_value_assign (var
->value
, value
, &val
))
1365 /* If the value has changed, record it, so that next -var-update can
1366 report this change. If a variable had a value of '1', we've set it
1367 to '333' and then set again to '1', when -var-update will report this
1368 variable as changed -- because the first assignment has set the
1369 'updated' flag. There's no need to optimize that, because return value
1370 of -var-update should be considered an approximation. */
1371 var
->updated
= install_new_value (var
, val
, 0 /* Compare values. */);
1372 input_radix
= saved_input_radix
;
1378 /* A helper function to install a constructor function and visualizer
1382 install_visualizer (struct varobj
*var
, PyObject
*constructor
,
1383 PyObject
*visualizer
)
1385 Py_XDECREF (var
->constructor
);
1386 var
->constructor
= constructor
;
1388 Py_XDECREF (var
->pretty_printer
);
1389 var
->pretty_printer
= visualizer
;
1391 Py_XDECREF (var
->child_iter
);
1392 var
->child_iter
= NULL
;
1395 /* Install the default visualizer for VAR. */
1398 install_default_visualizer (struct varobj
*var
)
1400 if (pretty_printing
)
1402 PyObject
*pretty_printer
= NULL
;
1406 pretty_printer
= gdbpy_get_varobj_pretty_printer (var
->value
);
1407 if (! pretty_printer
)
1409 gdbpy_print_stack ();
1410 error (_("Cannot instantiate printer for default visualizer"));
1414 if (pretty_printer
== Py_None
)
1416 Py_DECREF (pretty_printer
);
1417 pretty_printer
= NULL
;
1420 install_visualizer (var
, NULL
, pretty_printer
);
1424 /* Instantiate and install a visualizer for VAR using CONSTRUCTOR to
1425 make a new object. */
1428 construct_visualizer (struct varobj
*var
, PyObject
*constructor
)
1430 PyObject
*pretty_printer
;
1432 Py_INCREF (constructor
);
1433 if (constructor
== Py_None
)
1434 pretty_printer
= NULL
;
1437 pretty_printer
= instantiate_pretty_printer (constructor
, var
->value
);
1438 if (! pretty_printer
)
1440 gdbpy_print_stack ();
1441 Py_DECREF (constructor
);
1442 constructor
= Py_None
;
1443 Py_INCREF (constructor
);
1446 if (pretty_printer
== Py_None
)
1448 Py_DECREF (pretty_printer
);
1449 pretty_printer
= NULL
;
1453 install_visualizer (var
, constructor
, pretty_printer
);
1456 #endif /* HAVE_PYTHON */
1458 /* A helper function for install_new_value. This creates and installs
1459 a visualizer for VAR, if appropriate. */
1462 install_new_value_visualizer (struct varobj
*var
)
1465 /* If the constructor is None, then we want the raw value. If VAR
1466 does not have a value, just skip this. */
1467 if (var
->constructor
!= Py_None
&& var
->value
)
1469 struct cleanup
*cleanup
;
1471 cleanup
= varobj_ensure_python_env (var
);
1473 if (!var
->constructor
)
1474 install_default_visualizer (var
);
1476 construct_visualizer (var
, var
->constructor
);
1478 do_cleanups (cleanup
);
1485 /* Assign a new value to a variable object. If INITIAL is non-zero,
1486 this is the first assignement after the variable object was just
1487 created, or changed type. In that case, just assign the value
1489 Otherwise, assign the new value, and return 1 if the value is
1490 different from the current one, 0 otherwise. The comparison is
1491 done on textual representation of value. Therefore, some types
1492 need not be compared. E.g. for structures the reported value is
1493 always "{...}", so no comparison is necessary here. If the old
1494 value was NULL and new one is not, or vice versa, we always return 1.
1496 The VALUE parameter should not be released -- the function will
1497 take care of releasing it when needed. */
1499 install_new_value (struct varobj
*var
, struct value
*value
, int initial
)
1504 int intentionally_not_fetched
= 0;
1505 char *print_value
= NULL
;
1507 /* We need to know the varobj's type to decide if the value should
1508 be fetched or not. C++ fake children (public/protected/private)
1509 don't have a type. */
1510 gdb_assert (var
->type
|| CPLUS_FAKE_CHILD (var
));
1511 changeable
= varobj_value_is_changeable_p (var
);
1513 /* If the type has custom visualizer, we consider it to be always
1514 changeable. FIXME: need to make sure this behaviour will not
1515 mess up read-sensitive values. */
1516 if (var
->pretty_printer
)
1519 need_to_fetch
= changeable
;
1521 /* We are not interested in the address of references, and given
1522 that in C++ a reference is not rebindable, it cannot
1523 meaningfully change. So, get hold of the real value. */
1525 value
= coerce_ref (value
);
1527 if (var
->type
&& TYPE_CODE (var
->type
) == TYPE_CODE_UNION
)
1528 /* For unions, we need to fetch the value implicitly because
1529 of implementation of union member fetch. When gdb
1530 creates a value for a field and the value of the enclosing
1531 structure is not lazy, it immediately copies the necessary
1532 bytes from the enclosing values. If the enclosing value is
1533 lazy, the call to value_fetch_lazy on the field will read
1534 the data from memory. For unions, that means we'll read the
1535 same memory more than once, which is not desirable. So
1539 /* The new value might be lazy. If the type is changeable,
1540 that is we'll be comparing values of this type, fetch the
1541 value now. Otherwise, on the next update the old value
1542 will be lazy, which means we've lost that old value. */
1543 if (need_to_fetch
&& value
&& value_lazy (value
))
1545 struct varobj
*parent
= var
->parent
;
1546 int frozen
= var
->frozen
;
1548 for (; !frozen
&& parent
; parent
= parent
->parent
)
1549 frozen
|= parent
->frozen
;
1551 if (frozen
&& initial
)
1553 /* For variables that are frozen, or are children of frozen
1554 variables, we don't do fetch on initial assignment.
1555 For non-initial assignemnt we do the fetch, since it means we're
1556 explicitly asked to compare the new value with the old one. */
1557 intentionally_not_fetched
= 1;
1559 else if (!gdb_value_fetch_lazy (value
))
1561 /* Set the value to NULL, so that for the next -var-update,
1562 we don't try to compare the new value with this value,
1563 that we couldn't even read. */
1569 /* Below, we'll be comparing string rendering of old and new
1570 values. Don't get string rendering if the value is
1571 lazy -- if it is, the code above has decided that the value
1572 should not be fetched. */
1573 if (value
&& !value_lazy (value
) && !var
->pretty_printer
)
1574 print_value
= value_get_print_value (value
, var
->format
, var
);
1576 /* If the type is changeable, compare the old and the new values.
1577 If this is the initial assignment, we don't have any old value
1579 if (!initial
&& changeable
)
1581 /* If the value of the varobj was changed by -var-set-value,
1582 then the value in the varobj and in the target is the same.
1583 However, that value is different from the value that the
1584 varobj had after the previous -var-update. So need to the
1585 varobj as changed. */
1590 else if (! var
->pretty_printer
)
1592 /* Try to compare the values. That requires that both
1593 values are non-lazy. */
1594 if (var
->not_fetched
&& value_lazy (var
->value
))
1596 /* This is a frozen varobj and the value was never read.
1597 Presumably, UI shows some "never read" indicator.
1598 Now that we've fetched the real value, we need to report
1599 this varobj as changed so that UI can show the real
1603 else if (var
->value
== NULL
&& value
== NULL
)
1606 else if (var
->value
== NULL
|| value
== NULL
)
1612 gdb_assert (!value_lazy (var
->value
));
1613 gdb_assert (!value_lazy (value
));
1615 gdb_assert (var
->print_value
!= NULL
&& print_value
!= NULL
);
1616 if (strcmp (var
->print_value
, print_value
) != 0)
1622 if (!initial
&& !changeable
)
1624 /* For values that are not changeable, we don't compare the values.
1625 However, we want to notice if a value was not NULL and now is NULL,
1626 or vise versa, so that we report when top-level varobjs come in scope
1627 and leave the scope. */
1628 changed
= (var
->value
!= NULL
) != (value
!= NULL
);
1631 /* We must always keep the new value, since children depend on it. */
1632 if (var
->value
!= NULL
&& var
->value
!= value
)
1633 value_free (var
->value
);
1636 value_incref (value
);
1637 if (value
&& value_lazy (value
) && intentionally_not_fetched
)
1638 var
->not_fetched
= 1;
1640 var
->not_fetched
= 0;
1643 install_new_value_visualizer (var
);
1645 /* If we installed a pretty-printer, re-compare the printed version
1646 to see if the variable changed. */
1647 if (var
->pretty_printer
)
1649 xfree (print_value
);
1650 print_value
= value_get_print_value (var
->value
, var
->format
, var
);
1651 if ((var
->print_value
== NULL
&& print_value
!= NULL
)
1652 || (var
->print_value
!= NULL
&& print_value
== NULL
)
1653 || (var
->print_value
!= NULL
&& print_value
!= NULL
1654 && strcmp (var
->print_value
, print_value
) != 0))
1657 if (var
->print_value
)
1658 xfree (var
->print_value
);
1659 var
->print_value
= print_value
;
1661 gdb_assert (!var
->value
|| value_type (var
->value
));
1666 /* Return the requested range for a varobj. VAR is the varobj. FROM
1667 and TO are out parameters; *FROM and *TO will be set to the
1668 selected sub-range of VAR. If no range was selected using
1669 -var-set-update-range, then both will be -1. */
1671 varobj_get_child_range (struct varobj
*var
, int *from
, int *to
)
1677 /* Set the selected sub-range of children of VAR to start at index
1678 FROM and end at index TO. If either FROM or TO is less than zero,
1679 this is interpreted as a request for all children. */
1681 varobj_set_child_range (struct varobj
*var
, int from
, int to
)
1688 varobj_set_visualizer (struct varobj
*var
, const char *visualizer
)
1691 PyObject
*mainmod
, *globals
, *constructor
;
1692 struct cleanup
*back_to
;
1694 back_to
= varobj_ensure_python_env (var
);
1696 mainmod
= PyImport_AddModule ("__main__");
1697 globals
= PyModule_GetDict (mainmod
);
1698 Py_INCREF (globals
);
1699 make_cleanup_py_decref (globals
);
1701 constructor
= PyRun_String (visualizer
, Py_eval_input
, globals
, globals
);
1705 gdbpy_print_stack ();
1706 error (_("Could not evaluate visualizer expression: %s"), visualizer
);
1709 construct_visualizer (var
, constructor
);
1710 Py_XDECREF (constructor
);
1712 /* If there are any children now, wipe them. */
1713 varobj_delete (var
, NULL
, 1 /* children only */);
1714 var
->num_children
= -1;
1716 do_cleanups (back_to
);
1718 error (_("Python support required"));
1722 /* Update the values for a variable and its children. This is a
1723 two-pronged attack. First, re-parse the value for the root's
1724 expression to see if it's changed. Then go all the way
1725 through its children, reconstructing them and noting if they've
1728 The EXPLICIT parameter specifies if this call is result
1729 of MI request to update this specific variable, or
1730 result of implicit -var-update *. For implicit request, we don't
1731 update frozen variables.
1733 NOTE: This function may delete the caller's varobj. If it
1734 returns TYPE_CHANGED, then it has done this and VARP will be modified
1735 to point to the new varobj. */
1737 VEC(varobj_update_result
) *varobj_update (struct varobj
**varp
, int explicit)
1740 int type_changed
= 0;
1743 VEC (varobj_update_result
) *stack
= NULL
;
1744 VEC (varobj_update_result
) *result
= NULL
;
1746 /* Frozen means frozen -- we don't check for any change in
1747 this varobj, including its going out of scope, or
1748 changing type. One use case for frozen varobjs is
1749 retaining previously evaluated expressions, and we don't
1750 want them to be reevaluated at all. */
1751 if (!explicit && (*varp
)->frozen
)
1754 if (!(*varp
)->root
->is_valid
)
1756 varobj_update_result r
= {0};
1759 r
.status
= VAROBJ_INVALID
;
1760 VEC_safe_push (varobj_update_result
, result
, &r
);
1764 if ((*varp
)->root
->rootvar
== *varp
)
1766 varobj_update_result r
= {0};
1769 r
.status
= VAROBJ_IN_SCOPE
;
1771 /* Update the root variable. value_of_root can return NULL
1772 if the variable is no longer around, i.e. we stepped out of
1773 the frame in which a local existed. We are letting the
1774 value_of_root variable dispose of the varobj if the type
1776 new = value_of_root (varp
, &type_changed
);
1779 r
.type_changed
= type_changed
;
1780 if (install_new_value ((*varp
), new, type_changed
))
1784 r
.status
= VAROBJ_NOT_IN_SCOPE
;
1785 r
.value_installed
= 1;
1787 if (r
.status
== VAROBJ_NOT_IN_SCOPE
)
1789 if (r
.type_changed
|| r
.changed
)
1790 VEC_safe_push (varobj_update_result
, result
, &r
);
1794 VEC_safe_push (varobj_update_result
, stack
, &r
);
1798 varobj_update_result r
= {0};
1801 VEC_safe_push (varobj_update_result
, stack
, &r
);
1804 /* Walk through the children, reconstructing them all. */
1805 while (!VEC_empty (varobj_update_result
, stack
))
1807 varobj_update_result r
= *(VEC_last (varobj_update_result
, stack
));
1808 struct varobj
*v
= r
.varobj
;
1810 VEC_pop (varobj_update_result
, stack
);
1812 /* Update this variable, unless it's a root, which is already
1814 if (!r
.value_installed
)
1816 new = value_of_child (v
->parent
, v
->index
);
1817 if (install_new_value (v
, new, 0 /* type not changed */))
1824 /* We probably should not get children of a varobj that has a
1825 pretty-printer, but for which -var-list-children was never
1827 if (v
->pretty_printer
)
1829 VEC (varobj_p
) *changed
= 0, *new = 0, *unchanged
= 0;
1830 int i
, children_changed
= 0;
1835 if (!v
->children_requested
)
1839 /* If we initially did not have potential children, but
1840 now we do, consider the varobj as changed.
1841 Otherwise, if children were never requested, consider
1842 it as unchanged -- presumably, such varobj is not yet
1843 expanded in the UI, so we need not bother getting
1845 if (!varobj_has_more (v
, 0))
1847 update_dynamic_varobj_children (v
, NULL
, NULL
, NULL
,
1849 if (varobj_has_more (v
, 0))
1854 VEC_safe_push (varobj_update_result
, result
, &r
);
1859 /* If update_dynamic_varobj_children returns 0, then we have
1860 a non-conforming pretty-printer, so we skip it. */
1861 if (update_dynamic_varobj_children (v
, &changed
, &new, &unchanged
,
1862 &children_changed
, 1,
1865 if (children_changed
|| new)
1867 r
.children_changed
= 1;
1870 /* Push in reverse order so that the first child is
1871 popped from the work stack first, and so will be
1872 added to result first. This does not affect
1873 correctness, just "nicer". */
1874 for (i
= VEC_length (varobj_p
, changed
) - 1; i
>= 0; --i
)
1876 varobj_p tmp
= VEC_index (varobj_p
, changed
, i
);
1877 varobj_update_result r
= {0};
1881 r
.value_installed
= 1;
1882 VEC_safe_push (varobj_update_result
, stack
, &r
);
1884 for (i
= VEC_length (varobj_p
, unchanged
) - 1; i
>= 0; --i
)
1886 varobj_p tmp
= VEC_index (varobj_p
, unchanged
, i
);
1890 varobj_update_result r
= {0};
1893 r
.value_installed
= 1;
1894 VEC_safe_push (varobj_update_result
, stack
, &r
);
1897 if (r
.changed
|| r
.children_changed
)
1898 VEC_safe_push (varobj_update_result
, result
, &r
);
1900 /* Free CHANGED and UNCHANGED, but not NEW, because NEW
1901 has been put into the result vector. */
1902 VEC_free (varobj_p
, changed
);
1903 VEC_free (varobj_p
, unchanged
);
1909 /* Push any children. Use reverse order so that the first
1910 child is popped from the work stack first, and so
1911 will be added to result first. This does not
1912 affect correctness, just "nicer". */
1913 for (i
= VEC_length (varobj_p
, v
->children
)-1; i
>= 0; --i
)
1915 varobj_p c
= VEC_index (varobj_p
, v
->children
, i
);
1917 /* Child may be NULL if explicitly deleted by -var-delete. */
1918 if (c
!= NULL
&& !c
->frozen
)
1920 varobj_update_result r
= {0};
1923 VEC_safe_push (varobj_update_result
, stack
, &r
);
1927 if (r
.changed
|| r
.type_changed
)
1928 VEC_safe_push (varobj_update_result
, result
, &r
);
1931 VEC_free (varobj_update_result
, stack
);
1937 /* Helper functions */
1940 * Variable object construction/destruction
1944 delete_variable (struct cpstack
**resultp
, struct varobj
*var
,
1945 int only_children_p
)
1949 delete_variable_1 (resultp
, &delcount
, var
,
1950 only_children_p
, 1 /* remove_from_parent_p */ );
1955 /* Delete the variable object VAR and its children. */
1956 /* IMPORTANT NOTE: If we delete a variable which is a child
1957 and the parent is not removed we dump core. It must be always
1958 initially called with remove_from_parent_p set. */
1960 delete_variable_1 (struct cpstack
**resultp
, int *delcountp
,
1961 struct varobj
*var
, int only_children_p
,
1962 int remove_from_parent_p
)
1966 /* Delete any children of this variable, too. */
1967 for (i
= 0; i
< VEC_length (varobj_p
, var
->children
); ++i
)
1969 varobj_p child
= VEC_index (varobj_p
, var
->children
, i
);
1973 if (!remove_from_parent_p
)
1974 child
->parent
= NULL
;
1975 delete_variable_1 (resultp
, delcountp
, child
, 0, only_children_p
);
1977 VEC_free (varobj_p
, var
->children
);
1979 /* if we were called to delete only the children we are done here. */
1980 if (only_children_p
)
1983 /* Otherwise, add it to the list of deleted ones and proceed to do so. */
1984 /* If the name is null, this is a temporary variable, that has not
1985 yet been installed, don't report it, it belongs to the caller... */
1986 if (var
->obj_name
!= NULL
)
1988 cppush (resultp
, xstrdup (var
->obj_name
));
1989 *delcountp
= *delcountp
+ 1;
1992 /* If this variable has a parent, remove it from its parent's list. */
1993 /* OPTIMIZATION: if the parent of this variable is also being deleted,
1994 (as indicated by remove_from_parent_p) we don't bother doing an
1995 expensive list search to find the element to remove when we are
1996 discarding the list afterwards. */
1997 if ((remove_from_parent_p
) && (var
->parent
!= NULL
))
1999 VEC_replace (varobj_p
, var
->parent
->children
, var
->index
, NULL
);
2002 if (var
->obj_name
!= NULL
)
2003 uninstall_variable (var
);
2005 /* Free memory associated with this variable. */
2006 free_variable (var
);
2009 /* Install the given variable VAR with the object name VAR->OBJ_NAME. */
2011 install_variable (struct varobj
*var
)
2014 struct vlist
*newvl
;
2016 unsigned int index
= 0;
2019 for (chp
= var
->obj_name
; *chp
; chp
++)
2021 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
2024 cv
= *(varobj_table
+ index
);
2025 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, var
->obj_name
) != 0))
2029 error (_("Duplicate variable object name"));
2031 /* Add varobj to hash table. */
2032 newvl
= xmalloc (sizeof (struct vlist
));
2033 newvl
->next
= *(varobj_table
+ index
);
2035 *(varobj_table
+ index
) = newvl
;
2037 /* If root, add varobj to root list. */
2038 if (is_root_p (var
))
2040 /* Add to list of root variables. */
2041 if (rootlist
== NULL
)
2042 var
->root
->next
= NULL
;
2044 var
->root
->next
= rootlist
;
2045 rootlist
= var
->root
;
2051 /* Unistall the object VAR. */
2053 uninstall_variable (struct varobj
*var
)
2057 struct varobj_root
*cr
;
2058 struct varobj_root
*prer
;
2060 unsigned int index
= 0;
2063 /* Remove varobj from hash table. */
2064 for (chp
= var
->obj_name
; *chp
; chp
++)
2066 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
2069 cv
= *(varobj_table
+ index
);
2071 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, var
->obj_name
) != 0))
2078 fprintf_unfiltered (gdb_stdlog
, "Deleting %s\n", var
->obj_name
);
2083 ("Assertion failed: Could not find variable object \"%s\" to delete",
2089 *(varobj_table
+ index
) = cv
->next
;
2091 prev
->next
= cv
->next
;
2095 /* If root, remove varobj from root list. */
2096 if (is_root_p (var
))
2098 /* Remove from list of root variables. */
2099 if (rootlist
== var
->root
)
2100 rootlist
= var
->root
->next
;
2105 while ((cr
!= NULL
) && (cr
->rootvar
!= var
))
2112 warning (_("Assertion failed: Could not find "
2113 "varobj \"%s\" in root list"),
2120 prer
->next
= cr
->next
;
2126 /* Create and install a child of the parent of the given name. */
2127 static struct varobj
*
2128 create_child (struct varobj
*parent
, int index
, char *name
)
2130 return create_child_with_value (parent
, index
, name
,
2131 value_of_child (parent
, index
));
2134 static struct varobj
*
2135 create_child_with_value (struct varobj
*parent
, int index
, const char *name
,
2136 struct value
*value
)
2138 struct varobj
*child
;
2141 child
= new_variable ();
2143 /* Name is allocated by name_of_child. */
2144 /* FIXME: xstrdup should not be here. */
2145 child
->name
= xstrdup (name
);
2146 child
->index
= index
;
2147 child
->parent
= parent
;
2148 child
->root
= parent
->root
;
2149 childs_name
= xstrprintf ("%s.%s", parent
->obj_name
, name
);
2150 child
->obj_name
= childs_name
;
2151 install_variable (child
);
2153 /* Compute the type of the child. Must do this before
2154 calling install_new_value. */
2156 /* If the child had no evaluation errors, var->value
2157 will be non-NULL and contain a valid type. */
2158 child
->type
= value_type (value
);
2160 /* Otherwise, we must compute the type. */
2161 child
->type
= (*child
->root
->lang
->type_of_child
) (child
->parent
,
2163 install_new_value (child
, value
, 1);
2170 * Miscellaneous utility functions.
2173 /* Allocate memory and initialize a new variable. */
2174 static struct varobj
*
2179 var
= (struct varobj
*) xmalloc (sizeof (struct varobj
));
2181 var
->path_expr
= NULL
;
2182 var
->obj_name
= NULL
;
2186 var
->num_children
= -1;
2188 var
->children
= NULL
;
2192 var
->print_value
= NULL
;
2194 var
->not_fetched
= 0;
2195 var
->children_requested
= 0;
2198 var
->constructor
= 0;
2199 var
->pretty_printer
= 0;
2200 var
->child_iter
= 0;
2201 var
->saved_item
= 0;
2206 /* Allocate memory and initialize a new root variable. */
2207 static struct varobj
*
2208 new_root_variable (void)
2210 struct varobj
*var
= new_variable ();
2212 var
->root
= (struct varobj_root
*) xmalloc (sizeof (struct varobj_root
));
2213 var
->root
->lang
= NULL
;
2214 var
->root
->exp
= NULL
;
2215 var
->root
->valid_block
= NULL
;
2216 var
->root
->frame
= null_frame_id
;
2217 var
->root
->floating
= 0;
2218 var
->root
->rootvar
= NULL
;
2219 var
->root
->is_valid
= 1;
2224 /* Free any allocated memory associated with VAR. */
2226 free_variable (struct varobj
*var
)
2229 if (var
->pretty_printer
)
2231 struct cleanup
*cleanup
= varobj_ensure_python_env (var
);
2232 Py_XDECREF (var
->constructor
);
2233 Py_XDECREF (var
->pretty_printer
);
2234 Py_XDECREF (var
->child_iter
);
2235 Py_XDECREF (var
->saved_item
);
2236 do_cleanups (cleanup
);
2240 value_free (var
->value
);
2242 /* Free the expression if this is a root variable. */
2243 if (is_root_p (var
))
2245 xfree (var
->root
->exp
);
2250 xfree (var
->obj_name
);
2251 xfree (var
->print_value
);
2252 xfree (var
->path_expr
);
2257 do_free_variable_cleanup (void *var
)
2259 free_variable (var
);
2262 static struct cleanup
*
2263 make_cleanup_free_variable (struct varobj
*var
)
2265 return make_cleanup (do_free_variable_cleanup
, var
);
2268 /* This returns the type of the variable. It also skips past typedefs
2269 to return the real type of the variable.
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_type (struct varobj
*var
)
2280 type
= check_typedef (type
);
2285 /* Return the type of the value that's stored in VAR,
2286 or that would have being stored there if the
2287 value were accessible.
2289 This differs from VAR->type in that VAR->type is always
2290 the true type of the expession in the source language.
2291 The return value of this function is the type we're
2292 actually storing in varobj, and using for displaying
2293 the values and for comparing previous and new values.
2295 For example, top-level references are always stripped. */
2296 static struct type
*
2297 get_value_type (struct varobj
*var
)
2302 type
= value_type (var
->value
);
2306 type
= check_typedef (type
);
2308 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
2309 type
= get_target_type (type
);
2311 type
= check_typedef (type
);
2316 /* This returns the target type (or NULL) of TYPE, also skipping
2317 past typedefs, just like get_type ().
2319 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
2320 except within get_target_type and get_type. */
2321 static struct type
*
2322 get_target_type (struct type
*type
)
2326 type
= TYPE_TARGET_TYPE (type
);
2328 type
= check_typedef (type
);
2334 /* What is the default display for this variable? We assume that
2335 everything is "natural". Any exceptions? */
2336 static enum varobj_display_formats
2337 variable_default_display (struct varobj
*var
)
2339 return FORMAT_NATURAL
;
2342 /* FIXME: The following should be generic for any pointer. */
2344 cppush (struct cpstack
**pstack
, char *name
)
2348 s
= (struct cpstack
*) xmalloc (sizeof (struct cpstack
));
2354 /* FIXME: The following should be generic for any pointer. */
2356 cppop (struct cpstack
**pstack
)
2361 if ((*pstack
)->name
== NULL
&& (*pstack
)->next
== NULL
)
2366 *pstack
= (*pstack
)->next
;
2373 * Language-dependencies
2376 /* Common entry points */
2378 /* Get the language of variable VAR. */
2379 static enum varobj_languages
2380 variable_language (struct varobj
*var
)
2382 enum varobj_languages lang
;
2384 switch (var
->root
->exp
->language_defn
->la_language
)
2390 case language_cplus
:
2401 /* Return the number of children for a given variable.
2402 The result of this function is defined by the language
2403 implementation. The number of children returned by this function
2404 is the number of children that the user will see in the variable
2407 number_of_children (struct varobj
*var
)
2409 return (*var
->root
->lang
->number_of_children
) (var
);
2412 /* What is the expression for the root varobj VAR? Returns a malloc'd
2415 name_of_variable (struct varobj
*var
)
2417 return (*var
->root
->lang
->name_of_variable
) (var
);
2420 /* What is the name of the INDEX'th child of VAR? Returns a malloc'd
2423 name_of_child (struct varobj
*var
, int index
)
2425 return (*var
->root
->lang
->name_of_child
) (var
, index
);
2428 /* What is the ``struct value *'' of the root variable VAR?
2429 For floating variable object, evaluation can get us a value
2430 of different type from what is stored in varobj already. In
2432 - *type_changed will be set to 1
2433 - old varobj will be freed, and new one will be
2434 created, with the same name.
2435 - *var_handle will be set to the new varobj
2436 Otherwise, *type_changed will be set to 0. */
2437 static struct value
*
2438 value_of_root (struct varobj
**var_handle
, int *type_changed
)
2442 if (var_handle
== NULL
)
2447 /* This should really be an exception, since this should
2448 only get called with a root variable. */
2450 if (!is_root_p (var
))
2453 if (var
->root
->floating
)
2455 struct varobj
*tmp_var
;
2456 char *old_type
, *new_type
;
2458 tmp_var
= varobj_create (NULL
, var
->name
, (CORE_ADDR
) 0,
2459 USE_SELECTED_FRAME
);
2460 if (tmp_var
== NULL
)
2464 old_type
= varobj_get_type (var
);
2465 new_type
= varobj_get_type (tmp_var
);
2466 if (strcmp (old_type
, new_type
) == 0)
2468 /* The expression presently stored inside var->root->exp
2469 remembers the locations of local variables relatively to
2470 the frame where the expression was created (in DWARF location
2471 button, for example). Naturally, those locations are not
2472 correct in other frames, so update the expression. */
2474 struct expression
*tmp_exp
= var
->root
->exp
;
2476 var
->root
->exp
= tmp_var
->root
->exp
;
2477 tmp_var
->root
->exp
= tmp_exp
;
2479 varobj_delete (tmp_var
, NULL
, 0);
2484 tmp_var
->obj_name
= xstrdup (var
->obj_name
);
2485 tmp_var
->from
= var
->from
;
2486 tmp_var
->to
= var
->to
;
2487 varobj_delete (var
, NULL
, 0);
2489 install_variable (tmp_var
);
2490 *var_handle
= tmp_var
;
2502 return (*var
->root
->lang
->value_of_root
) (var_handle
);
2505 /* What is the ``struct value *'' for the INDEX'th child of PARENT? */
2506 static struct value
*
2507 value_of_child (struct varobj
*parent
, int index
)
2509 struct value
*value
;
2511 value
= (*parent
->root
->lang
->value_of_child
) (parent
, index
);
2516 /* GDB already has a command called "value_of_variable". Sigh. */
2518 my_value_of_variable (struct varobj
*var
, enum varobj_display_formats format
)
2520 if (var
->root
->is_valid
)
2522 if (var
->pretty_printer
)
2523 return value_get_print_value (var
->value
, var
->format
, var
);
2524 return (*var
->root
->lang
->value_of_variable
) (var
, format
);
2531 value_get_print_value (struct value
*value
, enum varobj_display_formats format
,
2534 struct ui_file
*stb
;
2535 struct cleanup
*old_chain
;
2536 gdb_byte
*thevalue
= NULL
;
2537 struct value_print_options opts
;
2538 struct type
*type
= NULL
;
2540 char *encoding
= NULL
;
2541 struct gdbarch
*gdbarch
= NULL
;
2542 /* Initialize it just to avoid a GCC false warning. */
2543 CORE_ADDR str_addr
= 0;
2544 int string_print
= 0;
2549 stb
= mem_fileopen ();
2550 old_chain
= make_cleanup_ui_file_delete (stb
);
2552 gdbarch
= get_type_arch (value_type (value
));
2555 PyObject
*value_formatter
= var
->pretty_printer
;
2557 varobj_ensure_python_env (var
);
2559 if (value_formatter
)
2561 /* First check to see if we have any children at all. If so,
2562 we simply return {...}. */
2563 if (dynamic_varobj_has_child_method (var
))
2565 do_cleanups (old_chain
);
2566 return xstrdup ("{...}");
2569 if (PyObject_HasAttr (value_formatter
, gdbpy_to_string_cst
))
2572 struct value
*replacement
;
2573 PyObject
*output
= NULL
;
2575 hint
= gdbpy_get_display_hint (value_formatter
);
2578 if (!strcmp (hint
, "string"))
2583 output
= apply_varobj_pretty_printer (value_formatter
,
2588 make_cleanup_py_decref (output
);
2590 if (gdbpy_is_lazy_string (output
))
2592 gdbpy_extract_lazy_string (output
, &str_addr
, &type
,
2594 make_cleanup (free_current_contents
, &encoding
);
2600 = python_string_to_target_python_string (output
);
2604 char *s
= PyString_AsString (py_str
);
2606 len
= PyString_Size (py_str
);
2607 thevalue
= xmemdup (s
, len
+ 1, len
+ 1);
2608 type
= builtin_type (gdbarch
)->builtin_char
;
2613 do_cleanups (old_chain
);
2617 make_cleanup (xfree
, thevalue
);
2620 gdbpy_print_stack ();
2624 value
= replacement
;
2630 get_formatted_print_options (&opts
, format_code
[(int) format
]);
2634 LA_PRINT_STRING (stb
, type
, thevalue
, len
, encoding
, 0, &opts
);
2635 else if (string_print
)
2636 val_print_string (type
, encoding
, str_addr
, len
, stb
, &opts
);
2638 common_val_print (value
, stb
, 0, &opts
, current_language
);
2639 thevalue
= ui_file_xstrdup (stb
, NULL
);
2641 do_cleanups (old_chain
);
2646 varobj_editable_p (struct varobj
*var
)
2650 if (!(var
->root
->is_valid
&& var
->value
&& VALUE_LVAL (var
->value
)))
2653 type
= get_value_type (var
);
2655 switch (TYPE_CODE (type
))
2657 case TYPE_CODE_STRUCT
:
2658 case TYPE_CODE_UNION
:
2659 case TYPE_CODE_ARRAY
:
2660 case TYPE_CODE_FUNC
:
2661 case TYPE_CODE_METHOD
:
2671 /* Return non-zero if changes in value of VAR
2672 must be detected and reported by -var-update.
2673 Return zero is -var-update should never report
2674 changes of such values. This makes sense for structures
2675 (since the changes in children values will be reported separately),
2676 or for artifical objects (like 'public' pseudo-field in C++).
2678 Return value of 0 means that gdb need not call value_fetch_lazy
2679 for the value of this variable object. */
2681 varobj_value_is_changeable_p (struct varobj
*var
)
2686 if (CPLUS_FAKE_CHILD (var
))
2689 type
= get_value_type (var
);
2691 switch (TYPE_CODE (type
))
2693 case TYPE_CODE_STRUCT
:
2694 case TYPE_CODE_UNION
:
2695 case TYPE_CODE_ARRAY
:
2706 /* Return 1 if that varobj is floating, that is is always evaluated in the
2707 selected frame, and not bound to thread/frame. Such variable objects
2708 are created using '@' as frame specifier to -var-create. */
2710 varobj_floating_p (struct varobj
*var
)
2712 return var
->root
->floating
;
2715 /* Given the value and the type of a variable object,
2716 adjust the value and type to those necessary
2717 for getting children of the variable object.
2718 This includes dereferencing top-level references
2719 to all types and dereferencing pointers to
2722 Both TYPE and *TYPE should be non-null. VALUE
2723 can be null if we want to only translate type.
2724 *VALUE can be null as well -- if the parent
2727 If WAS_PTR is not NULL, set *WAS_PTR to 0 or 1
2728 depending on whether pointer was dereferenced
2729 in this function. */
2731 adjust_value_for_child_access (struct value
**value
,
2735 gdb_assert (type
&& *type
);
2740 *type
= check_typedef (*type
);
2742 /* The type of value stored in varobj, that is passed
2743 to us, is already supposed to be
2744 reference-stripped. */
2746 gdb_assert (TYPE_CODE (*type
) != TYPE_CODE_REF
);
2748 /* Pointers to structures are treated just like
2749 structures when accessing children. Don't
2750 dererences pointers to other types. */
2751 if (TYPE_CODE (*type
) == TYPE_CODE_PTR
)
2753 struct type
*target_type
= get_target_type (*type
);
2754 if (TYPE_CODE (target_type
) == TYPE_CODE_STRUCT
2755 || TYPE_CODE (target_type
) == TYPE_CODE_UNION
)
2757 if (value
&& *value
)
2759 int success
= gdb_value_ind (*value
, value
);
2764 *type
= target_type
;
2770 /* The 'get_target_type' function calls check_typedef on
2771 result, so we can immediately check type code. No
2772 need to call check_typedef here. */
2777 c_number_of_children (struct varobj
*var
)
2779 struct type
*type
= get_value_type (var
);
2781 struct type
*target
;
2783 adjust_value_for_child_access (NULL
, &type
, NULL
);
2784 target
= get_target_type (type
);
2786 switch (TYPE_CODE (type
))
2788 case TYPE_CODE_ARRAY
:
2789 if (TYPE_LENGTH (type
) > 0 && TYPE_LENGTH (target
) > 0
2790 && !TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type
))
2791 children
= TYPE_LENGTH (type
) / TYPE_LENGTH (target
);
2793 /* If we don't know how many elements there are, don't display
2798 case TYPE_CODE_STRUCT
:
2799 case TYPE_CODE_UNION
:
2800 children
= TYPE_NFIELDS (type
);
2804 /* The type here is a pointer to non-struct. Typically, pointers
2805 have one child, except for function ptrs, which have no children,
2806 and except for void*, as we don't know what to show.
2808 We can show char* so we allow it to be dereferenced. If you decide
2809 to test for it, please mind that a little magic is necessary to
2810 properly identify it: char* has TYPE_CODE == TYPE_CODE_INT and
2811 TYPE_NAME == "char". */
2812 if (TYPE_CODE (target
) == TYPE_CODE_FUNC
2813 || TYPE_CODE (target
) == TYPE_CODE_VOID
)
2820 /* Other types have no children. */
2828 c_name_of_variable (struct varobj
*parent
)
2830 return xstrdup (parent
->name
);
2833 /* Return the value of element TYPE_INDEX of a structure
2834 value VALUE. VALUE's type should be a structure,
2835 or union, or a typedef to struct/union.
2837 Returns NULL if getting the value fails. Never throws. */
2838 static struct value
*
2839 value_struct_element_index (struct value
*value
, int type_index
)
2841 struct value
*result
= NULL
;
2842 volatile struct gdb_exception e
;
2843 struct type
*type
= value_type (value
);
2845 type
= check_typedef (type
);
2847 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
2848 || TYPE_CODE (type
) == TYPE_CODE_UNION
);
2850 TRY_CATCH (e
, RETURN_MASK_ERROR
)
2852 if (field_is_static (&TYPE_FIELD (type
, type_index
)))
2853 result
= value_static_field (type
, type_index
);
2855 result
= value_primitive_field (value
, 0, type_index
, type
);
2867 /* Obtain the information about child INDEX of the variable
2869 If CNAME is not null, sets *CNAME to the name of the child relative
2871 If CVALUE is not null, sets *CVALUE to the value of the child.
2872 If CTYPE is not null, sets *CTYPE to the type of the child.
2874 If any of CNAME, CVALUE, or CTYPE is not null, but the corresponding
2875 information cannot be determined, set *CNAME, *CVALUE, or *CTYPE
2878 c_describe_child (struct varobj
*parent
, int index
,
2879 char **cname
, struct value
**cvalue
, struct type
**ctype
,
2880 char **cfull_expression
)
2882 struct value
*value
= parent
->value
;
2883 struct type
*type
= get_value_type (parent
);
2884 char *parent_expression
= NULL
;
2893 if (cfull_expression
)
2895 *cfull_expression
= NULL
;
2896 parent_expression
= varobj_get_path_expr (parent
);
2898 adjust_value_for_child_access (&value
, &type
, &was_ptr
);
2900 switch (TYPE_CODE (type
))
2902 case TYPE_CODE_ARRAY
:
2905 = xstrdup (int_string (index
2906 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
)),
2909 if (cvalue
&& value
)
2911 int real_index
= index
+ TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
));
2913 gdb_value_subscript (value
, real_index
, cvalue
);
2917 *ctype
= get_target_type (type
);
2919 if (cfull_expression
)
2921 xstrprintf ("(%s)[%s]", parent_expression
,
2923 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
)),
2929 case TYPE_CODE_STRUCT
:
2930 case TYPE_CODE_UNION
:
2932 *cname
= xstrdup (TYPE_FIELD_NAME (type
, index
));
2934 if (cvalue
&& value
)
2936 /* For C, varobj index is the same as type index. */
2937 *cvalue
= value_struct_element_index (value
, index
);
2941 *ctype
= TYPE_FIELD_TYPE (type
, index
);
2943 if (cfull_expression
)
2945 char *join
= was_ptr
? "->" : ".";
2947 *cfull_expression
= xstrprintf ("(%s)%s%s", parent_expression
, join
,
2948 TYPE_FIELD_NAME (type
, index
));
2955 *cname
= xstrprintf ("*%s", parent
->name
);
2957 if (cvalue
&& value
)
2959 int success
= gdb_value_ind (value
, cvalue
);
2965 /* Don't use get_target_type because it calls
2966 check_typedef and here, we want to show the true
2967 declared type of the variable. */
2969 *ctype
= TYPE_TARGET_TYPE (type
);
2971 if (cfull_expression
)
2972 *cfull_expression
= xstrprintf ("*(%s)", parent_expression
);
2977 /* This should not happen. */
2979 *cname
= xstrdup ("???");
2980 if (cfull_expression
)
2981 *cfull_expression
= xstrdup ("???");
2982 /* Don't set value and type, we don't know then. */
2987 c_name_of_child (struct varobj
*parent
, int index
)
2991 c_describe_child (parent
, index
, &name
, NULL
, NULL
, NULL
);
2996 c_path_expr_of_child (struct varobj
*child
)
2998 c_describe_child (child
->parent
, child
->index
, NULL
, NULL
, NULL
,
3000 return child
->path_expr
;
3003 /* If frame associated with VAR can be found, switch
3004 to it and return 1. Otherwise, return 0. */
3006 check_scope (struct varobj
*var
)
3008 struct frame_info
*fi
;
3011 fi
= frame_find_by_id (var
->root
->frame
);
3016 CORE_ADDR pc
= get_frame_pc (fi
);
3018 if (pc
< BLOCK_START (var
->root
->valid_block
) ||
3019 pc
>= BLOCK_END (var
->root
->valid_block
))
3027 static struct value
*
3028 c_value_of_root (struct varobj
**var_handle
)
3030 struct value
*new_val
= NULL
;
3031 struct varobj
*var
= *var_handle
;
3032 int within_scope
= 0;
3033 struct cleanup
*back_to
;
3035 /* Only root variables can be updated... */
3036 if (!is_root_p (var
))
3037 /* Not a root var. */
3040 back_to
= make_cleanup_restore_current_thread ();
3042 /* Determine whether the variable is still around. */
3043 if (var
->root
->valid_block
== NULL
|| var
->root
->floating
)
3045 else if (var
->root
->thread_id
== 0)
3047 /* The program was single-threaded when the variable object was
3048 created. Technically, it's possible that the program became
3049 multi-threaded since then, but we don't support such
3051 within_scope
= check_scope (var
);
3055 ptid_t ptid
= thread_id_to_pid (var
->root
->thread_id
);
3056 if (in_thread_list (ptid
))
3058 switch_to_thread (ptid
);
3059 within_scope
= check_scope (var
);
3065 /* We need to catch errors here, because if evaluate
3066 expression fails we want to just return NULL. */
3067 gdb_evaluate_expression (var
->root
->exp
, &new_val
);
3071 do_cleanups (back_to
);
3076 static struct value
*
3077 c_value_of_child (struct varobj
*parent
, int index
)
3079 struct value
*value
= NULL
;
3081 c_describe_child (parent
, index
, NULL
, &value
, NULL
, NULL
);
3085 static struct type
*
3086 c_type_of_child (struct varobj
*parent
, int index
)
3088 struct type
*type
= NULL
;
3090 c_describe_child (parent
, index
, NULL
, NULL
, &type
, NULL
);
3095 c_value_of_variable (struct varobj
*var
, enum varobj_display_formats format
)
3097 /* BOGUS: if val_print sees a struct/class, or a reference to one,
3098 it will print out its children instead of "{...}". So we need to
3099 catch that case explicitly. */
3100 struct type
*type
= get_type (var
);
3102 /* If we have a custom formatter, return whatever string it has
3104 if (var
->pretty_printer
&& var
->print_value
)
3105 return xstrdup (var
->print_value
);
3107 /* Strip top-level references. */
3108 while (TYPE_CODE (type
) == TYPE_CODE_REF
)
3109 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3111 switch (TYPE_CODE (type
))
3113 case TYPE_CODE_STRUCT
:
3114 case TYPE_CODE_UNION
:
3115 return xstrdup ("{...}");
3118 case TYPE_CODE_ARRAY
:
3122 number
= xstrprintf ("[%d]", var
->num_children
);
3129 if (var
->value
== NULL
)
3131 /* This can happen if we attempt to get the value of a struct
3132 member when the parent is an invalid pointer. This is an
3133 error condition, so we should tell the caller. */
3138 if (var
->not_fetched
&& value_lazy (var
->value
))
3139 /* Frozen variable and no value yet. We don't
3140 implicitly fetch the value. MI response will
3141 use empty string for the value, which is OK. */
3144 gdb_assert (varobj_value_is_changeable_p (var
));
3145 gdb_assert (!value_lazy (var
->value
));
3147 /* If the specified format is the current one,
3148 we can reuse print_value. */
3149 if (format
== var
->format
)
3150 return xstrdup (var
->print_value
);
3152 return value_get_print_value (var
->value
, format
, var
);
3162 cplus_number_of_children (struct varobj
*var
)
3165 int children
, dont_know
;
3170 if (!CPLUS_FAKE_CHILD (var
))
3172 type
= get_value_type (var
);
3173 adjust_value_for_child_access (NULL
, &type
, NULL
);
3175 if (((TYPE_CODE (type
)) == TYPE_CODE_STRUCT
) ||
3176 ((TYPE_CODE (type
)) == TYPE_CODE_UNION
))
3180 cplus_class_num_children (type
, kids
);
3181 if (kids
[v_public
] != 0)
3183 if (kids
[v_private
] != 0)
3185 if (kids
[v_protected
] != 0)
3188 /* Add any baseclasses. */
3189 children
+= TYPE_N_BASECLASSES (type
);
3192 /* FIXME: save children in var. */
3199 type
= get_value_type (var
->parent
);
3200 adjust_value_for_child_access (NULL
, &type
, NULL
);
3202 cplus_class_num_children (type
, kids
);
3203 if (strcmp (var
->name
, "public") == 0)
3204 children
= kids
[v_public
];
3205 else if (strcmp (var
->name
, "private") == 0)
3206 children
= kids
[v_private
];
3208 children
= kids
[v_protected
];
3213 children
= c_number_of_children (var
);
3218 /* Compute # of public, private, and protected variables in this class.
3219 That means we need to descend into all baseclasses and find out
3220 how many are there, too. */
3222 cplus_class_num_children (struct type
*type
, int children
[3])
3224 int i
, vptr_fieldno
;
3225 struct type
*basetype
= NULL
;
3227 children
[v_public
] = 0;
3228 children
[v_private
] = 0;
3229 children
[v_protected
] = 0;
3231 vptr_fieldno
= get_vptr_fieldno (type
, &basetype
);
3232 for (i
= TYPE_N_BASECLASSES (type
); i
< TYPE_NFIELDS (type
); i
++)
3234 /* If we have a virtual table pointer, omit it. Even if virtual
3235 table pointers are not specifically marked in the debug info,
3236 they should be artificial. */
3237 if ((type
== basetype
&& i
== vptr_fieldno
)
3238 || TYPE_FIELD_ARTIFICIAL (type
, i
))
3241 if (TYPE_FIELD_PROTECTED (type
, i
))
3242 children
[v_protected
]++;
3243 else if (TYPE_FIELD_PRIVATE (type
, i
))
3244 children
[v_private
]++;
3246 children
[v_public
]++;
3251 cplus_name_of_variable (struct varobj
*parent
)
3253 return c_name_of_variable (parent
);
3256 enum accessibility
{ private_field
, protected_field
, public_field
};
3258 /* Check if field INDEX of TYPE has the specified accessibility.
3259 Return 0 if so and 1 otherwise. */
3261 match_accessibility (struct type
*type
, int index
, enum accessibility acc
)
3263 if (acc
== private_field
&& TYPE_FIELD_PRIVATE (type
, index
))
3265 else if (acc
== protected_field
&& TYPE_FIELD_PROTECTED (type
, index
))
3267 else if (acc
== public_field
&& !TYPE_FIELD_PRIVATE (type
, index
)
3268 && !TYPE_FIELD_PROTECTED (type
, index
))
3275 cplus_describe_child (struct varobj
*parent
, int index
,
3276 char **cname
, struct value
**cvalue
, struct type
**ctype
,
3277 char **cfull_expression
)
3279 struct value
*value
;
3282 char *parent_expression
= NULL
;
3290 if (cfull_expression
)
3291 *cfull_expression
= NULL
;
3293 if (CPLUS_FAKE_CHILD (parent
))
3295 value
= parent
->parent
->value
;
3296 type
= get_value_type (parent
->parent
);
3297 if (cfull_expression
)
3298 parent_expression
= varobj_get_path_expr (parent
->parent
);
3302 value
= parent
->value
;
3303 type
= get_value_type (parent
);
3304 if (cfull_expression
)
3305 parent_expression
= varobj_get_path_expr (parent
);
3308 adjust_value_for_child_access (&value
, &type
, &was_ptr
);
3310 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
3311 || TYPE_CODE (type
) == TYPE_CODE_UNION
)
3313 char *join
= was_ptr
? "->" : ".";
3315 if (CPLUS_FAKE_CHILD (parent
))
3317 /* The fields of the class type are ordered as they
3318 appear in the class. We are given an index for a
3319 particular access control type ("public","protected",
3320 or "private"). We must skip over fields that don't
3321 have the access control we are looking for to properly
3322 find the indexed field. */
3323 int type_index
= TYPE_N_BASECLASSES (type
);
3324 enum accessibility acc
= public_field
;
3326 struct type
*basetype
= NULL
;
3328 vptr_fieldno
= get_vptr_fieldno (type
, &basetype
);
3329 if (strcmp (parent
->name
, "private") == 0)
3330 acc
= private_field
;
3331 else if (strcmp (parent
->name
, "protected") == 0)
3332 acc
= protected_field
;
3336 if ((type
== basetype
&& type_index
== vptr_fieldno
)
3337 || TYPE_FIELD_ARTIFICIAL (type
, type_index
))
3339 else if (match_accessibility (type
, type_index
, acc
))
3346 *cname
= xstrdup (TYPE_FIELD_NAME (type
, type_index
));
3348 if (cvalue
&& value
)
3349 *cvalue
= value_struct_element_index (value
, type_index
);
3352 *ctype
= TYPE_FIELD_TYPE (type
, type_index
);
3354 if (cfull_expression
)
3356 = xstrprintf ("((%s)%s%s)", parent_expression
,
3358 TYPE_FIELD_NAME (type
, type_index
));
3360 else if (index
< TYPE_N_BASECLASSES (type
))
3362 /* This is a baseclass. */
3364 *cname
= xstrdup (TYPE_FIELD_NAME (type
, index
));
3366 if (cvalue
&& value
)
3367 *cvalue
= value_cast (TYPE_FIELD_TYPE (type
, index
), value
);
3371 *ctype
= TYPE_FIELD_TYPE (type
, index
);
3374 if (cfull_expression
)
3376 char *ptr
= was_ptr
? "*" : "";
3378 /* Cast the parent to the base' type. Note that in gdb,
3381 will create an lvalue, for all appearences, so we don't
3382 need to use more fancy:
3385 *cfull_expression
= xstrprintf ("(%s(%s%s) %s)",
3387 TYPE_FIELD_NAME (type
, index
),
3394 char *access
= NULL
;
3397 cplus_class_num_children (type
, children
);
3399 /* Everything beyond the baseclasses can
3400 only be "public", "private", or "protected"
3402 The special "fake" children are always output by varobj in
3403 this order. So if INDEX == 2, it MUST be "protected". */
3404 index
-= TYPE_N_BASECLASSES (type
);
3408 if (children
[v_public
] > 0)
3410 else if (children
[v_private
] > 0)
3413 access
= "protected";
3416 if (children
[v_public
] > 0)
3418 if (children
[v_private
] > 0)
3421 access
= "protected";
3423 else if (children
[v_private
] > 0)
3424 access
= "protected";
3427 /* Must be protected. */
3428 access
= "protected";
3435 gdb_assert (access
);
3437 *cname
= xstrdup (access
);
3439 /* Value and type and full expression are null here. */
3444 c_describe_child (parent
, index
, cname
, cvalue
, ctype
, cfull_expression
);
3449 cplus_name_of_child (struct varobj
*parent
, int index
)
3453 cplus_describe_child (parent
, index
, &name
, NULL
, NULL
, NULL
);
3458 cplus_path_expr_of_child (struct varobj
*child
)
3460 cplus_describe_child (child
->parent
, child
->index
, NULL
, NULL
, NULL
,
3462 return child
->path_expr
;
3465 static struct value
*
3466 cplus_value_of_root (struct varobj
**var_handle
)
3468 return c_value_of_root (var_handle
);
3471 static struct value
*
3472 cplus_value_of_child (struct varobj
*parent
, int index
)
3474 struct value
*value
= NULL
;
3476 cplus_describe_child (parent
, index
, NULL
, &value
, NULL
, NULL
);
3480 static struct type
*
3481 cplus_type_of_child (struct varobj
*parent
, int index
)
3483 struct type
*type
= NULL
;
3485 cplus_describe_child (parent
, index
, NULL
, NULL
, &type
, NULL
);
3490 cplus_value_of_variable (struct varobj
*var
,
3491 enum varobj_display_formats format
)
3494 /* If we have one of our special types, don't print out
3496 if (CPLUS_FAKE_CHILD (var
))
3497 return xstrdup ("");
3499 return c_value_of_variable (var
, format
);
3505 java_number_of_children (struct varobj
*var
)
3507 return cplus_number_of_children (var
);
3511 java_name_of_variable (struct varobj
*parent
)
3515 name
= cplus_name_of_variable (parent
);
3516 /* If the name has "-" in it, it is because we
3517 needed to escape periods in the name... */
3520 while (*p
!= '\000')
3531 java_name_of_child (struct varobj
*parent
, int index
)
3535 name
= cplus_name_of_child (parent
, index
);
3536 /* Escape any periods in the name... */
3539 while (*p
!= '\000')
3550 java_path_expr_of_child (struct varobj
*child
)
3555 static struct value
*
3556 java_value_of_root (struct varobj
**var_handle
)
3558 return cplus_value_of_root (var_handle
);
3561 static struct value
*
3562 java_value_of_child (struct varobj
*parent
, int index
)
3564 return cplus_value_of_child (parent
, index
);
3567 static struct type
*
3568 java_type_of_child (struct varobj
*parent
, int index
)
3570 return cplus_type_of_child (parent
, index
);
3574 java_value_of_variable (struct varobj
*var
, enum varobj_display_formats format
)
3576 return cplus_value_of_variable (var
, format
);
3579 /* Iterate all the existing _root_ VAROBJs and call the FUNC callback for them
3580 with an arbitrary caller supplied DATA pointer. */
3583 all_root_varobjs (void (*func
) (struct varobj
*var
, void *data
), void *data
)
3585 struct varobj_root
*var_root
, *var_root_next
;
3587 /* Iterate "safely" - handle if the callee deletes its passed VAROBJ. */
3589 for (var_root
= rootlist
; var_root
!= NULL
; var_root
= var_root_next
)
3591 var_root_next
= var_root
->next
;
3593 (*func
) (var_root
->rootvar
, data
);
3597 extern void _initialize_varobj (void);
3599 _initialize_varobj (void)
3601 int sizeof_table
= sizeof (struct vlist
*) * VAROBJ_TABLE_SIZE
;
3603 varobj_table
= xmalloc (sizeof_table
);
3604 memset (varobj_table
, 0, sizeof_table
);
3606 add_setshow_zinteger_cmd ("debugvarobj", class_maintenance
,
3608 _("Set varobj debugging."),
3609 _("Show varobj debugging."),
3610 _("When non-zero, varobj debugging is enabled."),
3611 NULL
, show_varobjdebug
,
3612 &setlist
, &showlist
);
3615 /* Invalidate varobj VAR if it is tied to locals and re-create it if it is
3616 defined on globals. It is a helper for varobj_invalidate. */
3619 varobj_invalidate_iter (struct varobj
*var
, void *unused
)
3621 /* Floating varobjs are reparsed on each stop, so we don't care if the
3622 presently parsed expression refers to something that's gone. */
3623 if (var
->root
->floating
)
3626 /* global var must be re-evaluated. */
3627 if (var
->root
->valid_block
== NULL
)
3629 struct varobj
*tmp_var
;
3631 /* Try to create a varobj with same expression. If we succeed
3632 replace the old varobj, otherwise invalidate it. */
3633 tmp_var
= varobj_create (NULL
, var
->name
, (CORE_ADDR
) 0,
3635 if (tmp_var
!= NULL
)
3637 tmp_var
->obj_name
= xstrdup (var
->obj_name
);
3638 varobj_delete (var
, NULL
, 0);
3639 install_variable (tmp_var
);
3642 var
->root
->is_valid
= 0;
3644 else /* locals must be invalidated. */
3645 var
->root
->is_valid
= 0;
3648 /* Invalidate the varobjs that are tied to locals and re-create the ones that
3649 are defined on globals.
3650 Invalidated varobjs will be always printed in_scope="invalid". */
3653 varobj_invalidate (void)
3655 all_root_varobjs (varobj_invalidate_iter
, NULL
);