1 /* varobj support for C and C++.
3 Copyright (C) 1999-2020 Free Software Foundation, Inc.
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 3 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "gdbthread.h"
24 static void cplus_class_num_children (struct type
*type
, int children
[3]);
26 /* The names of varobjs representing anonymous structs or unions. */
27 #define ANONYMOUS_STRUCT_NAME _("<anonymous struct>")
28 #define ANONYMOUS_UNION_NAME _("<anonymous union>")
30 /* Does CHILD represent a child with no name? This happens when
31 the child is an anonymous struct or union and it has no field name
32 in its parent variable.
34 This has already been determined by *_describe_child. The easiest
35 thing to do is to compare the child's name with ANONYMOUS_*_NAME. */
38 varobj_is_anonymous_child (const struct varobj
*child
)
40 return (child
->name
== ANONYMOUS_STRUCT_NAME
41 || child
->name
== ANONYMOUS_UNION_NAME
);
44 /* Given the value and the type of a variable object,
45 adjust the value and type to those necessary
46 for getting children of the variable object.
47 This includes dereferencing top-level references
48 to all types and dereferencing pointers to
51 If LOOKUP_ACTUAL_TYPE is set the enclosing type of the
52 value will be fetched and if it differs from static type
53 the value will be casted to it.
55 Both TYPE and *TYPE should be non-null. VALUE
56 can be null if we want to only translate type.
57 *VALUE can be null as well -- if the parent
60 If WAS_PTR is not NULL, set *WAS_PTR to 0 or 1
61 depending on whether pointer was dereferenced
65 adjust_value_for_child_access (struct value
**value
,
68 int lookup_actual_type
)
70 gdb_assert (type
&& *type
);
75 *type
= check_typedef (*type
);
77 /* The type of value stored in varobj, that is passed
78 to us, is already supposed to be
79 reference-stripped. */
81 gdb_assert (!TYPE_IS_REFERENCE (*type
));
83 /* Pointers to structures are treated just like
84 structures when accessing children. Don't
85 dereference pointers to other types. */
86 if ((*type
)->code () == TYPE_CODE_PTR
)
88 struct type
*target_type
= get_target_type (*type
);
89 if (target_type
->code () == TYPE_CODE_STRUCT
90 || target_type
->code () == TYPE_CODE_UNION
)
97 *value
= value_ind (*value
);
100 catch (const gdb_exception_error
&except
)
111 /* The 'get_target_type' function calls check_typedef on
112 result, so we can immediately check type code. No
113 need to call check_typedef here. */
115 /* Access a real type of the value (if necessary and possible). */
116 if (value
&& *value
&& lookup_actual_type
)
118 struct type
*enclosing_type
;
119 int real_type_found
= 0;
121 enclosing_type
= value_actual_type (*value
, 1, &real_type_found
);
124 *type
= enclosing_type
;
125 *value
= value_cast (enclosing_type
, *value
);
130 /* Is VAR a path expression parent, i.e., can it be used to construct
131 a valid path expression? */
134 c_is_path_expr_parent (const struct varobj
*var
)
138 /* "Fake" children are not path_expr parents. */
139 if (CPLUS_FAKE_CHILD (var
))
142 type
= varobj_get_gdb_type (var
);
144 /* Anonymous unions and structs are also not path_expr parents. */
145 if ((type
->code () == TYPE_CODE_STRUCT
146 || type
->code () == TYPE_CODE_UNION
)
147 && type
->name () == NULL
)
149 const struct varobj
*parent
= var
->parent
;
151 while (parent
!= NULL
&& CPLUS_FAKE_CHILD (parent
))
152 parent
= parent
->parent
;
156 struct type
*parent_type
;
159 parent_type
= varobj_get_value_type (parent
);
160 adjust_value_for_child_access (NULL
, &parent_type
, &was_ptr
, 0);
162 if (parent_type
->code () == TYPE_CODE_STRUCT
163 || parent_type
->code () == TYPE_CODE_UNION
)
165 const char *field_name
;
167 gdb_assert (var
->index
< parent_type
->num_fields ());
168 field_name
= TYPE_FIELD_NAME (parent_type
, var
->index
);
169 return !(field_name
== NULL
|| *field_name
== '\0');
182 c_number_of_children (const struct varobj
*var
)
184 struct type
*type
= varobj_get_value_type (var
);
188 adjust_value_for_child_access (NULL
, &type
, NULL
, 0);
189 target
= get_target_type (type
);
191 switch (type
->code ())
193 case TYPE_CODE_ARRAY
:
194 if (TYPE_LENGTH (type
) > 0 && TYPE_LENGTH (target
) > 0
195 && !TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type
))
196 children
= TYPE_LENGTH (type
) / TYPE_LENGTH (target
);
198 /* If we don't know how many elements there are, don't display
203 case TYPE_CODE_STRUCT
:
204 case TYPE_CODE_UNION
:
205 children
= type
->num_fields ();
209 /* The type here is a pointer to non-struct. Typically, pointers
210 have one child, except for function ptrs, which have no children,
211 and except for void*, as we don't know what to show.
213 We can show char* so we allow it to be dereferenced. If you decide
214 to test for it, please mind that a little magic is necessary to
215 properly identify it: char* has TYPE_CODE == TYPE_CODE_INT and
216 TYPE_NAME == "char". */
217 if (target
->code () == TYPE_CODE_FUNC
218 || target
->code () == TYPE_CODE_VOID
)
225 /* Other types have no children. */
233 c_name_of_variable (const struct varobj
*parent
)
238 /* Return the value of element TYPE_INDEX of a structure
239 value VALUE. VALUE's type should be a structure,
240 or union, or a typedef to struct/union.
242 Returns NULL if getting the value fails. Never throws. */
244 static struct value
*
245 value_struct_element_index (struct value
*value
, int type_index
)
247 struct value
*result
= NULL
;
248 struct type
*type
= value_type (value
);
250 type
= check_typedef (type
);
252 gdb_assert (type
->code () == TYPE_CODE_STRUCT
253 || type
->code () == TYPE_CODE_UNION
);
257 if (field_is_static (&type
->field (type_index
)))
258 result
= value_static_field (type
, type_index
);
260 result
= value_primitive_field (value
, 0, type_index
, type
);
262 catch (const gdb_exception_error
&e
)
270 /* Obtain the information about child INDEX of the variable
272 If CNAME is not null, sets *CNAME to the name of the child relative
274 If CVALUE is not null, sets *CVALUE to the value of the child.
275 If CTYPE is not null, sets *CTYPE to the type of the child.
277 If any of CNAME, CVALUE, or CTYPE is not null, but the corresponding
278 information cannot be determined, set *CNAME, *CVALUE, or *CTYPE
282 c_describe_child (const struct varobj
*parent
, int index
,
283 std::string
*cname
, struct value
**cvalue
,
284 struct type
**ctype
, std::string
*cfull_expression
)
286 struct value
*value
= parent
->value
.get ();
287 struct type
*type
= varobj_get_value_type (parent
);
288 std::string parent_expression
;
292 *cname
= std::string ();
297 if (cfull_expression
)
299 *cfull_expression
= std::string ();
301 = varobj_get_path_expr (varobj_get_path_expr_parent (parent
));
303 adjust_value_for_child_access (&value
, &type
, &was_ptr
, 0);
305 switch (type
->code ())
307 case TYPE_CODE_ARRAY
:
309 *cname
= int_string (index
310 + type
->index_type ()->bounds ()->low
.const_val (),
316 = index
+ type
->index_type ()->bounds ()->low
.const_val ();
320 *cvalue
= value_subscript (value
, real_index
);
322 catch (const gdb_exception_error
&except
)
328 *ctype
= get_target_type (type
);
330 if (cfull_expression
)
331 *cfull_expression
= string_printf
332 ("(%s)[%s]", parent_expression
.c_str (),
333 int_string (index
+ type
->index_type ()->bounds ()->low
.const_val (),
338 case TYPE_CODE_STRUCT
:
339 case TYPE_CODE_UNION
:
341 const char *field_name
;
343 /* If the type is anonymous and the field has no name,
344 set an appropriate name. */
345 field_name
= TYPE_FIELD_NAME (type
, index
);
346 if (field_name
== NULL
|| *field_name
== '\0')
350 if (type
->field (index
).type ()->code ()
352 *cname
= ANONYMOUS_STRUCT_NAME
;
354 *cname
= ANONYMOUS_UNION_NAME
;
357 if (cfull_expression
)
358 *cfull_expression
= "";
365 if (cfull_expression
)
367 const char *join
= was_ptr
? "->" : ".";
369 *cfull_expression
= string_printf ("(%s)%s%s",
370 parent_expression
.c_str (),
377 /* For C, varobj index is the same as type index. */
378 *cvalue
= value_struct_element_index (value
, index
);
382 *ctype
= type
->field (index
).type ();
388 *cname
= string_printf ("*%s", parent
->name
.c_str ());
394 *cvalue
= value_ind (value
);
397 catch (const gdb_exception_error
&except
)
403 /* Don't use get_target_type because it calls
404 check_typedef and here, we want to show the true
405 declared type of the variable. */
407 *ctype
= TYPE_TARGET_TYPE (type
);
409 if (cfull_expression
)
410 *cfull_expression
= string_printf ("*(%s)", parent_expression
.c_str ());
414 /* This should not happen. */
417 if (cfull_expression
)
418 *cfull_expression
= "???";
419 /* Don't set value and type, we don't know then. */
424 c_name_of_child (const struct varobj
*parent
, int index
)
428 c_describe_child (parent
, index
, &name
, NULL
, NULL
, NULL
);
433 c_path_expr_of_child (const struct varobj
*child
)
435 std::string path_expr
;
437 c_describe_child (child
->parent
, child
->index
, NULL
, NULL
, NULL
,
442 static struct value
*
443 c_value_of_child (const struct varobj
*parent
, int index
)
445 struct value
*value
= NULL
;
447 c_describe_child (parent
, index
, NULL
, &value
, NULL
, NULL
);
452 c_type_of_child (const struct varobj
*parent
, int index
)
454 struct type
*type
= NULL
;
456 c_describe_child (parent
, index
, NULL
, NULL
, &type
, NULL
);
460 /* This returns the type of the variable. It also skips past typedefs
461 to return the real type of the variable. */
464 get_type (const struct varobj
*var
)
470 type
= check_typedef (type
);
476 c_value_of_variable (const struct varobj
*var
,
477 enum varobj_display_formats format
)
479 /* BOGUS: if val_print sees a struct/class, or a reference to one,
480 it will print out its children instead of "{...}". So we need to
481 catch that case explicitly. */
482 struct type
*type
= get_type (var
);
484 /* Strip top-level references. */
485 while (TYPE_IS_REFERENCE (type
))
486 type
= check_typedef (TYPE_TARGET_TYPE (type
));
488 switch (type
->code ())
490 case TYPE_CODE_STRUCT
:
491 case TYPE_CODE_UNION
:
495 case TYPE_CODE_ARRAY
:
496 return string_printf ("[%d]", var
->num_children
);
501 if (var
->value
== NULL
)
503 /* This can happen if we attempt to get the value of a struct
504 member when the parent is an invalid pointer. This is an
505 error condition, so we should tell the caller. */
506 return std::string ();
510 if (var
->not_fetched
&& value_lazy (var
->value
.get ()))
511 /* Frozen variable and no value yet. We don't
512 implicitly fetch the value. MI response will
513 use empty string for the value, which is OK. */
514 return std::string ();
516 gdb_assert (varobj_value_is_changeable_p (var
));
517 gdb_assert (!value_lazy (var
->value
.get ()));
519 /* If the specified format is the current one,
520 we can reuse print_value. */
521 if (format
== var
->format
)
522 return var
->print_value
;
524 return varobj_value_get_print_value (var
->value
.get (), format
,
532 /* varobj operations for c. */
534 const struct lang_varobj_ops c_varobj_ops
=
536 c_number_of_children
,
539 c_path_expr_of_child
,
543 varobj_default_value_is_changeable_p
,
544 NULL
, /* value_has_mutated */
545 c_is_path_expr_parent
/* is_path_expr_parent */
548 /* A little convenience enum for dealing with C++. */
551 v_public
= 0, v_private
, v_protected
557 cplus_number_of_children (const struct varobj
*var
)
559 struct value
*value
= NULL
;
561 int children
, dont_know
;
562 int lookup_actual_type
= 0;
563 struct value_print_options opts
;
568 get_user_print_options (&opts
);
570 if (!CPLUS_FAKE_CHILD (var
))
572 type
= varobj_get_value_type (var
);
574 /* It is necessary to access a real type (via RTTI). */
575 if (opts
.objectprint
)
577 value
= var
->value
.get ();
578 lookup_actual_type
= (TYPE_IS_REFERENCE (var
->type
)
579 || var
->type
->code () == TYPE_CODE_PTR
);
581 adjust_value_for_child_access (&value
, &type
, NULL
, lookup_actual_type
);
583 if (((type
->code ()) == TYPE_CODE_STRUCT
)
584 || ((type
->code ()) == TYPE_CODE_UNION
))
588 cplus_class_num_children (type
, kids
);
589 if (kids
[v_public
] != 0)
591 if (kids
[v_private
] != 0)
593 if (kids
[v_protected
] != 0)
596 /* Add any baseclasses. */
597 children
+= TYPE_N_BASECLASSES (type
);
600 /* FIXME: save children in var. */
607 type
= varobj_get_value_type (var
->parent
);
609 /* It is necessary to access a real type (via RTTI). */
610 if (opts
.objectprint
)
612 const struct varobj
*parent
= var
->parent
;
614 value
= parent
->value
.get ();
615 lookup_actual_type
= (TYPE_IS_REFERENCE (parent
->type
)
616 || parent
->type
->code () == TYPE_CODE_PTR
);
618 adjust_value_for_child_access (&value
, &type
, NULL
, lookup_actual_type
);
620 cplus_class_num_children (type
, kids
);
621 if (var
->name
== "public")
622 children
= kids
[v_public
];
623 else if (var
->name
== "private")
624 children
= kids
[v_private
];
626 children
= kids
[v_protected
];
631 children
= c_number_of_children (var
);
636 /* Compute # of public, private, and protected variables in this class.
637 That means we need to descend into all baseclasses and find out
638 how many are there, too. */
641 cplus_class_num_children (struct type
*type
, int children
[3])
644 struct type
*basetype
= NULL
;
646 children
[v_public
] = 0;
647 children
[v_private
] = 0;
648 children
[v_protected
] = 0;
650 vptr_fieldno
= get_vptr_fieldno (type
, &basetype
);
651 for (i
= TYPE_N_BASECLASSES (type
); i
< type
->num_fields (); i
++)
653 /* If we have a virtual table pointer, omit it. Even if virtual
654 table pointers are not specifically marked in the debug info,
655 they should be artificial. */
656 if ((type
== basetype
&& i
== vptr_fieldno
)
657 || TYPE_FIELD_ARTIFICIAL (type
, i
))
660 if (TYPE_FIELD_PROTECTED (type
, i
))
661 children
[v_protected
]++;
662 else if (TYPE_FIELD_PRIVATE (type
, i
))
663 children
[v_private
]++;
665 children
[v_public
]++;
670 cplus_name_of_variable (const struct varobj
*parent
)
672 return c_name_of_variable (parent
);
675 enum accessibility
{ private_field
, protected_field
, public_field
};
677 /* Check if field INDEX of TYPE has the specified accessibility.
678 Return 0 if so and 1 otherwise. */
681 match_accessibility (struct type
*type
, int index
, enum accessibility acc
)
683 if (acc
== private_field
&& TYPE_FIELD_PRIVATE (type
, index
))
685 else if (acc
== protected_field
&& TYPE_FIELD_PROTECTED (type
, index
))
687 else if (acc
== public_field
&& !TYPE_FIELD_PRIVATE (type
, index
)
688 && !TYPE_FIELD_PROTECTED (type
, index
))
695 cplus_describe_child (const struct varobj
*parent
, int index
,
696 std::string
*cname
, struct value
**cvalue
, struct type
**ctype
,
697 std::string
*cfull_expression
)
702 int lookup_actual_type
= 0;
703 const char *parent_expression
= NULL
;
704 const struct varobj
*var
;
705 struct value_print_options opts
;
708 *cname
= std::string ();
713 if (cfull_expression
)
714 *cfull_expression
= std::string ();
716 get_user_print_options (&opts
);
718 var
= (CPLUS_FAKE_CHILD (parent
)) ? parent
->parent
: parent
;
719 if (opts
.objectprint
)
720 lookup_actual_type
= (TYPE_IS_REFERENCE (var
->type
)
721 || var
->type
->code () == TYPE_CODE_PTR
);
722 value
= var
->value
.get ();
723 type
= varobj_get_value_type (var
);
724 if (cfull_expression
)
726 = varobj_get_path_expr (varobj_get_path_expr_parent (var
));
728 adjust_value_for_child_access (&value
, &type
, &was_ptr
, lookup_actual_type
);
730 if (type
->code () == TYPE_CODE_STRUCT
731 || type
->code () == TYPE_CODE_UNION
)
733 const char *join
= was_ptr
? "->" : ".";
735 if (CPLUS_FAKE_CHILD (parent
))
737 /* The fields of the class type are ordered as they
738 appear in the class. We are given an index for a
739 particular access control type ("public","protected",
740 or "private"). We must skip over fields that don't
741 have the access control we are looking for to properly
742 find the indexed field. */
743 int type_index
= TYPE_N_BASECLASSES (type
);
744 enum accessibility acc
= public_field
;
746 struct type
*basetype
= NULL
;
747 const char *field_name
;
749 vptr_fieldno
= get_vptr_fieldno (type
, &basetype
);
750 if (parent
->name
== "private")
752 else if (parent
->name
== "protected")
753 acc
= protected_field
;
757 if ((type
== basetype
&& type_index
== vptr_fieldno
)
758 || TYPE_FIELD_ARTIFICIAL (type
, type_index
))
760 else if (match_accessibility (type
, type_index
, acc
))
766 /* If the type is anonymous and the field has no name,
767 set an appropriate name. */
768 field_name
= TYPE_FIELD_NAME (type
, type_index
);
769 if (field_name
== NULL
|| *field_name
== '\0')
773 if (type
->field (type_index
).type ()->code ()
775 *cname
= ANONYMOUS_STRUCT_NAME
;
776 else if (type
->field (type_index
).type ()->code ()
778 *cname
= ANONYMOUS_UNION_NAME
;
781 if (cfull_expression
)
782 *cfull_expression
= std::string ();
787 *cname
= TYPE_FIELD_NAME (type
, type_index
);
789 if (cfull_expression
)
791 = string_printf ("((%s)%s%s)", parent_expression
, join
,
796 *cvalue
= value_struct_element_index (value
, type_index
);
799 *ctype
= type
->field (type_index
).type ();
801 else if (index
< TYPE_N_BASECLASSES (type
))
803 /* This is a baseclass. */
805 *cname
= TYPE_FIELD_NAME (type
, index
);
808 *cvalue
= value_cast (type
->field (index
).type (), value
);
812 *ctype
= type
->field (index
).type ();
815 if (cfull_expression
)
817 const char *ptr
= was_ptr
? "*" : "";
819 /* Cast the parent to the base' type. Note that in gdb,
822 will create an lvalue, for all appearences, so we don't
823 need to use more fancy:
827 When we are in the scope of the base class or of one
828 of its children, the type field name will be interpreted
829 as a constructor, if it exists. Therefore, we must
830 indicate that the name is a class name by using the
831 'class' keyword. See PR mi/11912 */
832 *cfull_expression
= string_printf ("(%s(class %s%s) %s)",
834 TYPE_FIELD_NAME (type
, index
),
841 const char *access
= NULL
;
844 cplus_class_num_children (type
, children
);
846 /* Everything beyond the baseclasses can
847 only be "public", "private", or "protected"
849 The special "fake" children are always output by varobj in
850 this order. So if INDEX == 2, it MUST be "protected". */
851 index
-= TYPE_N_BASECLASSES (type
);
855 if (children
[v_public
] > 0)
857 else if (children
[v_private
] > 0)
860 access
= "protected";
863 if (children
[v_public
] > 0)
865 if (children
[v_private
] > 0)
868 access
= "protected";
870 else if (children
[v_private
] > 0)
871 access
= "protected";
874 /* Must be protected. */
875 access
= "protected";
886 /* Value and type and full expression are null here. */
891 c_describe_child (parent
, index
, cname
, cvalue
, ctype
, cfull_expression
);
896 cplus_name_of_child (const struct varobj
*parent
, int index
)
900 cplus_describe_child (parent
, index
, &name
, NULL
, NULL
, NULL
);
905 cplus_path_expr_of_child (const struct varobj
*child
)
907 std::string path_expr
;
909 cplus_describe_child (child
->parent
, child
->index
, NULL
, NULL
, NULL
,
914 static struct value
*
915 cplus_value_of_child (const struct varobj
*parent
, int index
)
917 struct value
*value
= NULL
;
919 cplus_describe_child (parent
, index
, NULL
, &value
, NULL
, NULL
);
924 cplus_type_of_child (const struct varobj
*parent
, int index
)
926 struct type
*type
= NULL
;
928 cplus_describe_child (parent
, index
, NULL
, NULL
, &type
, NULL
);
933 cplus_value_of_variable (const struct varobj
*var
,
934 enum varobj_display_formats format
)
937 /* If we have one of our special types, don't print out
939 if (CPLUS_FAKE_CHILD (var
))
940 return std::string ();
942 return c_value_of_variable (var
, format
);
946 /* varobj operations for c++. */
948 const struct lang_varobj_ops cplus_varobj_ops
=
950 cplus_number_of_children
,
951 cplus_name_of_variable
,
953 cplus_path_expr_of_child
,
954 cplus_value_of_child
,
956 cplus_value_of_variable
,
957 varobj_default_value_is_changeable_p
,
958 NULL
, /* value_has_mutated */
959 c_is_path_expr_parent
/* is_path_expr_parent */