GDB (xrefs)

/tmp/gdb-8.1/gdb/c-varobj.c
Go to the documentation of this file.
1 /* varobj support for C and C++.
2
3 Copyright (C) 1999-2018 Free Software Foundation, Inc.
4
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.
9
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.
14
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/>. */
17
18 #include "defs.h"
19 #include "value.h"
20 #include "varobj.h"
21 #include "gdbthread.h"
22 #include "valprint.h"
23
24 static void cplus_class_num_children (struct type *type, int children[3]);
25
26 /* The names of varobjs representing anonymous structs or unions. */
27 #define ANONYMOUS_STRUCT_NAME _("<anonymous struct>")
28 #define ANONYMOUS_UNION_NAME _("<anonymous union>")
29
30 /* Does CHILD represent a child with no name? This happens when
31 the child is an anonmous struct or union and it has no field name
32 in its parent variable.
33
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. */
36
37 bool
38 varobj_is_anonymous_child (const struct varobj *child)
39 {
40 return (child->name == ANONYMOUS_STRUCT_NAME
41 || child->name == ANONYMOUS_UNION_NAME);
42 }
43
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
49 structures.
50
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.
54
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
58 value is not known.
59
60 If WAS_PTR is not NULL, set *WAS_PTR to 0 or 1
61 depending on whether pointer was dereferenced
62 in this function. */
63
64 static void
65 adjust_value_for_child_access (struct value **value,
66 struct type **type,
67 int *was_ptr,
68 int lookup_actual_type)
69 {
70 gdb_assert (type && *type);
71
72 if (was_ptr)
73 *was_ptr = 0;
74
75 *type = check_typedef (*type);
76
77 /* The type of value stored in varobj, that is passed
78 to us, is already supposed to be
79 reference-stripped. */
80
81 gdb_assert (!TYPE_IS_REFERENCE (*type));
82
83 /* Pointers to structures are treated just like
84 structures when accessing children. Don't
85 dererences pointers to other types. */
86 if (TYPE_CODE (*type) == TYPE_CODE_PTR)
87 {
88 struct type *target_type = get_target_type (*type);
89 if (TYPE_CODE (target_type) == TYPE_CODE_STRUCT
90 || TYPE_CODE (target_type) == TYPE_CODE_UNION)
91 {
92 if (value && *value)
93 {
94
95 TRY
96 {
97 *value = value_ind (*value);
98 }
99
100 CATCH (except, RETURN_MASK_ERROR)
101 {
102 *value = NULL;
103 }
104 END_CATCH
105 }
106 *type = target_type;
107 if (was_ptr)
108 *was_ptr = 1;
109 }
110 }
111
112 /* The 'get_target_type' function calls check_typedef on
113 result, so we can immediately check type code. No
114 need to call check_typedef here. */
115
116 /* Access a real type of the value (if necessary and possible). */
117 if (value && *value && lookup_actual_type)
118 {
119 struct type *enclosing_type;
120 int real_type_found = 0;
121
122 enclosing_type = value_actual_type (*value, 1, &real_type_found);
123 if (real_type_found)
124 {
125 *type = enclosing_type;
126 *value = value_cast (enclosing_type, *value);
127 }
128 }
129 }
130
131 /* Is VAR a path expression parent, i.e., can it be used to construct
132 a valid path expression? */
133
134 static bool
135 c_is_path_expr_parent (const struct varobj *var)
136 {
137 struct type *type;
138
139 /* "Fake" children are not path_expr parents. */
140 if (CPLUS_FAKE_CHILD (var))
141 return false;
142
143 type = varobj_get_gdb_type (var);
144
145 /* Anonymous unions and structs are also not path_expr parents. */
146 if ((TYPE_CODE (type) == TYPE_CODE_STRUCT
147 || TYPE_CODE (type) == TYPE_CODE_UNION)
148 && TYPE_NAME (type) == NULL
149 && TYPE_TAG_NAME (type) == NULL)
150 {
151 const struct varobj *parent = var->parent;
152
153 while (parent != NULL && CPLUS_FAKE_CHILD (parent))
154 parent = parent->parent;
155
156 if (parent != NULL)
157 {
158 struct type *parent_type;
159 int was_ptr;
160
161 parent_type = varobj_get_value_type (parent);
162 adjust_value_for_child_access (NULL, &parent_type, &was_ptr, 0);
163
164 if (TYPE_CODE (parent_type) == TYPE_CODE_STRUCT
165 || TYPE_CODE (parent_type) == TYPE_CODE_UNION)
166 {
167 const char *field_name;
168
169 gdb_assert (var->index < TYPE_NFIELDS (parent_type));
170 field_name = TYPE_FIELD_NAME (parent_type, var->index);
171 return !(field_name == NULL || *field_name == '\0');
172 }
173 }
174
175 return false;
176 }
177
178 return true;
179 }
180
181 /* C */
182
183 static int
184 c_number_of_children (const struct varobj *var)
185 {
186 struct type *type = varobj_get_value_type (var);
187 int children = 0;
188 struct type *target;
189
190 adjust_value_for_child_access (NULL, &type, NULL, 0);
191 target = get_target_type (type);
192
193 switch (TYPE_CODE (type))
194 {
195 case TYPE_CODE_ARRAY:
196 if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (target) > 0
197 && !TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type))
198 children = TYPE_LENGTH (type) / TYPE_LENGTH (target);
199 else
200 /* If we don't know how many elements there are, don't display
201 any. */
202 children = 0;
203 break;
204
205 case TYPE_CODE_STRUCT:
206 case TYPE_CODE_UNION:
207 children = TYPE_NFIELDS (type);
208 break;
209
210 case TYPE_CODE_PTR:
211 /* The type here is a pointer to non-struct. Typically, pointers
212 have one child, except for function ptrs, which have no children,
213 and except for void*, as we don't know what to show.
214
215 We can show char* so we allow it to be dereferenced. If you decide
216 to test for it, please mind that a little magic is necessary to
217 properly identify it: char* has TYPE_CODE == TYPE_CODE_INT and
218 TYPE_NAME == "char". */
219 if (TYPE_CODE (target) == TYPE_CODE_FUNC
220 || TYPE_CODE (target) == TYPE_CODE_VOID)
221 children = 0;
222 else
223 children = 1;
224 break;
225
226 default:
227 /* Other types have no children. */
228 break;
229 }
230
231 return children;
232 }
233
234 static std::string
235 c_name_of_variable (const struct varobj *parent)
236 {
237 return parent->name;
238 }
239
240 /* Return the value of element TYPE_INDEX of a structure
241 value VALUE. VALUE's type should be a structure,
242 or union, or a typedef to struct/union.
243
244 Returns NULL if getting the value fails. Never throws. */
245
246 static struct value *
247 value_struct_element_index (struct value *value, int type_index)
248 {
249 struct value *result = NULL;
250 struct type *type = value_type (value);
251
252 type = check_typedef (type);
253
254 gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
255 || TYPE_CODE (type) == TYPE_CODE_UNION);
256
257 TRY
258 {
259 if (field_is_static (&TYPE_FIELD (type, type_index)))
260 result = value_static_field (type, type_index);
261 else
262 result = value_primitive_field (value, 0, type_index, type);
263 }
264 CATCH (e, RETURN_MASK_ERROR)
265 {
266 return NULL;
267 }
268 END_CATCH
269
270 return result;
271 }
272
273 /* Obtain the information about child INDEX of the variable
274 object PARENT.
275 If CNAME is not null, sets *CNAME to the name of the child relative
276 to the parent.
277 If CVALUE is not null, sets *CVALUE to the value of the child.
278 If CTYPE is not null, sets *CTYPE to the type of the child.
279
280 If any of CNAME, CVALUE, or CTYPE is not null, but the corresponding
281 information cannot be determined, set *CNAME, *CVALUE, or *CTYPE
282 to empty. */
283
284 static void
285 c_describe_child (const struct varobj *parent, int index,
286 std::string *cname, struct value **cvalue,
287 struct type **ctype, std::string *cfull_expression)
288 {
289 struct value *value = parent->value;
290 struct type *type = varobj_get_value_type (parent);
291 std::string parent_expression;
292 int was_ptr;
293
294 if (cname)
295 *cname = std::string ();
296 if (cvalue)
297 *cvalue = NULL;
298 if (ctype)
299 *ctype = NULL;
300 if (cfull_expression)
301 {
302 *cfull_expression = std::string ();
303 parent_expression
304 = varobj_get_path_expr (varobj_get_path_expr_parent (parent));
305 }
306 adjust_value_for_child_access (&value, &type, &was_ptr, 0);
307
308 switch (TYPE_CODE (type))
309 {
310 case TYPE_CODE_ARRAY:
311 if (cname)
312 *cname = int_string (index
313 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)),
314 10, 1, 0, 0);
315
316 if (cvalue && value)
317 {
318 int real_index = index + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type));
319
320 TRY
321 {
322 *cvalue = value_subscript (value, real_index);
323 }
324 CATCH (except, RETURN_MASK_ERROR)
325 {
326 }
327 END_CATCH
328 }
329
330 if (ctype)
331 *ctype = get_target_type (type);
332
333 if (cfull_expression)
334 *cfull_expression =
335 string_printf ("(%s)[%s]", parent_expression.c_str (),
336 int_string (index
337 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)),
338 10, 1, 0, 0));
339
340
341 break;
342
343 case TYPE_CODE_STRUCT:
344 case TYPE_CODE_UNION:
345 {
346 const char *field_name;
347
348 /* If the type is anonymous and the field has no name,
349 set an appropriate name. */
350 field_name = TYPE_FIELD_NAME (type, index);
351 if (field_name == NULL || *field_name == '\0')
352 {
353 if (cname)
354 {
355 if (TYPE_CODE (TYPE_FIELD_TYPE (type, index))
356 == TYPE_CODE_STRUCT)
357 *cname = ANONYMOUS_STRUCT_NAME;
358 else
359 *cname = ANONYMOUS_UNION_NAME;
360 }
361
362 if (cfull_expression)
363 *cfull_expression = "";
364 }
365 else
366 {
367 if (cname)
368 *cname = field_name;
369
370 if (cfull_expression)
371 {
372 const char *join = was_ptr ? "->" : ".";
373
374 *cfull_expression = string_printf ("(%s)%s%s",
375 parent_expression.c_str (),
376 join, field_name);
377 }
378 }
379
380 if (cvalue && value)
381 {
382 /* For C, varobj index is the same as type index. */
383 *cvalue = value_struct_element_index (value, index);
384 }
385
386 if (ctype)
387 *ctype = TYPE_FIELD_TYPE (type, index);
388 }
389 break;
390
391 case TYPE_CODE_PTR:
392 if (cname)
393 *cname = string_printf ("*%s", parent->name.c_str ());
394
395 if (cvalue && value)
396 {
397 TRY
398 {
399 *cvalue = value_ind (value);
400 }
401
402 CATCH (except, RETURN_MASK_ERROR)
403 {
404 *cvalue = NULL;
405 }
406 END_CATCH
407 }
408
409 /* Don't use get_target_type because it calls
410 check_typedef and here, we want to show the true
411 declared type of the variable. */
412 if (ctype)
413 *ctype = TYPE_TARGET_TYPE (type);
414
415 if (cfull_expression)
416 *cfull_expression = string_printf ("*(%s)", parent_expression.c_str ());
417 break;
418
419 default:
420 /* This should not happen. */
421 if (cname)
422 *cname = "???";
423 if (cfull_expression)
424 *cfull_expression = "???";
425 /* Don't set value and type, we don't know then. */
426 }
427 }
428
429 static std::string
430 c_name_of_child (const struct varobj *parent, int index)
431 {
432 std::string name;
433
434 c_describe_child (parent, index, &name, NULL, NULL, NULL);
435 return name;
436 }
437
438 static std::string
439 c_path_expr_of_child (const struct varobj *child)
440 {
441 std::string path_expr;
442
443 c_describe_child (child->parent, child->index, NULL, NULL, NULL,
444 &path_expr);
445 return path_expr;
446 }
447
448 static struct value *
449 c_value_of_child (const struct varobj *parent, int index)
450 {
451 struct value *value = NULL;
452
453 c_describe_child (parent, index, NULL, &value, NULL, NULL);
454 return value;
455 }
456
457 static struct type *
458 c_type_of_child (const struct varobj *parent, int index)
459 {
460 struct type *type = NULL;
461
462 c_describe_child (parent, index, NULL, NULL, &type, NULL);
463 return type;
464 }
465
466 /* This returns the type of the variable. It also skips past typedefs
467 to return the real type of the variable. */
468
469 static struct type *
470 get_type (const struct varobj *var)
471 {
472 struct type *type;
473
474 type = var->type;
475 if (type != NULL)
476 type = check_typedef (type);
477
478 return type;
479 }
480
481 static std::string
482 c_value_of_variable (const struct varobj *var,
483 enum varobj_display_formats format)
484 {
485 /* BOGUS: if val_print sees a struct/class, or a reference to one,
486 it will print out its children instead of "{...}". So we need to
487 catch that case explicitly. */
488 struct type *type = get_type (var);
489
490 /* Strip top-level references. */
491 while (TYPE_IS_REFERENCE (type))
492 type = check_typedef (TYPE_TARGET_TYPE (type));
493
494 switch (TYPE_CODE (type))
495 {
496 case TYPE_CODE_STRUCT:
497 case TYPE_CODE_UNION:
498 return "{...}";
499 /* break; */
500
501 case TYPE_CODE_ARRAY:
502 return string_printf ("[%d]", var->num_children);
503 /* break; */
504
505 default:
506 {
507 if (var->value == NULL)
508 {
509 /* This can happen if we attempt to get the value of a struct
510 member when the parent is an invalid pointer. This is an
511 error condition, so we should tell the caller. */
512 return std::string ();
513 }
514 else
515 {
516 if (var->not_fetched && value_lazy (var->value))
517 /* Frozen variable and no value yet. We don't
518 implicitly fetch the value. MI response will
519 use empty string for the value, which is OK. */
520 return std::string ();
521
522 gdb_assert (varobj_value_is_changeable_p (var));
523 gdb_assert (!value_lazy (var->value));
524
525 /* If the specified format is the current one,
526 we can reuse print_value. */
527 if (format == var->format)
528 return var->print_value;
529 else
530 return varobj_value_get_print_value (var->value, format, var);
531 }
532 }
533 }
534 }
535
536
537 /* varobj operations for c. */
538
539 const struct lang_varobj_ops c_varobj_ops =
540 {
541 c_number_of_children,
542 c_name_of_variable,
543 c_name_of_child,
544 c_path_expr_of_child,
545 c_value_of_child,
546 c_type_of_child,
547 c_value_of_variable,
548 varobj_default_value_is_changeable_p,
549 NULL, /* value_has_mutated */
550 c_is_path_expr_parent /* is_path_expr_parent */
551 };
552
553 /* A little convenience enum for dealing with C++. */
554 enum vsections
555 {
556 v_public = 0, v_private, v_protected
557 };
558
559 /* C++ */
560
561 static int
562 cplus_number_of_children (const struct varobj *var)
563 {
564 struct value *value = NULL;
565 struct type *type;
566 int children, dont_know;
567 int lookup_actual_type = 0;
568 struct value_print_options opts;
569
570 dont_know = 1;
571 children = 0;
572
573 get_user_print_options (&opts);
574
575 if (!CPLUS_FAKE_CHILD (var))
576 {
577 type = varobj_get_value_type (var);
578
579 /* It is necessary to access a real type (via RTTI). */
580 if (opts.objectprint)
581 {
582 value = var->value;
583 lookup_actual_type = (TYPE_IS_REFERENCE (var->type)
584 || TYPE_CODE (var->type) == TYPE_CODE_PTR);
585 }
586 adjust_value_for_child_access (&value, &type, NULL, lookup_actual_type);
587
588 if (((TYPE_CODE (type)) == TYPE_CODE_STRUCT)
589 || ((TYPE_CODE (type)) == TYPE_CODE_UNION))
590 {
591 int kids[3];
592
593 cplus_class_num_children (type, kids);
594 if (kids[v_public] != 0)
595 children++;
596 if (kids[v_private] != 0)
597 children++;
598 if (kids[v_protected] != 0)
599 children++;
600
601 /* Add any baseclasses. */
602 children += TYPE_N_BASECLASSES (type);
603 dont_know = 0;
604
605 /* FIXME: save children in var. */
606 }
607 }
608 else
609 {
610 int kids[3];
611
612 type = varobj_get_value_type (var->parent);
613
614 /* It is necessary to access a real type (via RTTI). */
615 if (opts.objectprint)
616 {
617 const struct varobj *parent = var->parent;
618
619 value = parent->value;
620 lookup_actual_type = (TYPE_IS_REFERENCE (parent->type)
621 || TYPE_CODE (parent->type) == TYPE_CODE_PTR);
622 }
623 adjust_value_for_child_access (&value, &type, NULL, lookup_actual_type);
624
625 cplus_class_num_children (type, kids);
626 if (var->name == "public")
627 children = kids[v_public];
628 else if (var->name == "private")
629 children = kids[v_private];
630 else
631 children = kids[v_protected];
632 dont_know = 0;
633 }
634
635 if (dont_know)
636 children = c_number_of_children (var);
637
638 return children;
639 }
640
641 /* Compute # of public, private, and protected variables in this class.
642 That means we need to descend into all baseclasses and find out
643 how many are there, too. */
644
645 static void
646 cplus_class_num_children (struct type *type, int children[3])
647 {
648 int i, vptr_fieldno;
649 struct type *basetype = NULL;
650
651 children[v_public] = 0;
652 children[v_private] = 0;
653 children[v_protected] = 0;
654
655 vptr_fieldno = get_vptr_fieldno (type, &basetype);
656 for (i = TYPE_N_BASECLASSES (type); i < TYPE_NFIELDS (type); i++)
657 {
658 /* If we have a virtual table pointer, omit it. Even if virtual
659 table pointers are not specifically marked in the debug info,
660 they should be artificial. */
661 if ((type == basetype && i == vptr_fieldno)
662 || TYPE_FIELD_ARTIFICIAL (type, i))
663 continue;
664
665 if (TYPE_FIELD_PROTECTED (type, i))
666 children[v_protected]++;
667 else if (TYPE_FIELD_PRIVATE (type, i))
668 children[v_private]++;
669 else
670 children[v_public]++;
671 }
672 }
673
674 static std::string
675 cplus_name_of_variable (const struct varobj *parent)
676 {
677 return c_name_of_variable (parent);
678 }
679
680 enum accessibility { private_field, protected_field, public_field };
681
682 /* Check if field INDEX of TYPE has the specified accessibility.
683 Return 0 if so and 1 otherwise. */
684
685 static int
686 match_accessibility (struct type *type, int index, enum accessibility acc)
687 {
688 if (acc == private_field && TYPE_FIELD_PRIVATE (type, index))
689 return 1;
690 else if (acc == protected_field && TYPE_FIELD_PROTECTED (type, index))
691 return 1;
692 else if (acc == public_field && !TYPE_FIELD_PRIVATE (type, index)
693 && !TYPE_FIELD_PROTECTED (type, index))
694 return 1;
695 else
696 return 0;
697 }
698
699 static void
700 cplus_describe_child (const struct varobj *parent, int index,
701 std::string *cname, struct value **cvalue, struct type **ctype,
702 std::string *cfull_expression)
703 {
704 struct value *value;
705 struct type *type;
706 int was_ptr;
707 int lookup_actual_type = 0;
708 const char *parent_expression = NULL;
709 const struct varobj *var;
710 struct value_print_options opts;
711
712 if (cname)
713 *cname = std::string ();
714 if (cvalue)
715 *cvalue = NULL;
716 if (ctype)
717 *ctype = NULL;
718 if (cfull_expression)
719 *cfull_expression = std::string ();
720
721 get_user_print_options (&opts);
722
723 var = (CPLUS_FAKE_CHILD (parent)) ? parent->parent : parent;
724 if (opts.objectprint)
725 lookup_actual_type = (TYPE_IS_REFERENCE (var->type)
726 || TYPE_CODE (var->type) == TYPE_CODE_PTR);
727 value = var->value;
728 type = varobj_get_value_type (var);
729 if (cfull_expression)
730 parent_expression
731 = varobj_get_path_expr (varobj_get_path_expr_parent (var));
732
733 adjust_value_for_child_access (&value, &type, &was_ptr, lookup_actual_type);
734
735 if (TYPE_CODE (type) == TYPE_CODE_STRUCT
736 || TYPE_CODE (type) == TYPE_CODE_UNION)
737 {
738 const char *join = was_ptr ? "->" : ".";
739
740 if (CPLUS_FAKE_CHILD (parent))
741 {
742 /* The fields of the class type are ordered as they
743 appear in the class. We are given an index for a
744 particular access control type ("public","protected",
745 or "private"). We must skip over fields that don't
746 have the access control we are looking for to properly
747 find the indexed field. */
748 int type_index = TYPE_N_BASECLASSES (type);
749 enum accessibility acc = public_field;
750 int vptr_fieldno;
751 struct type *basetype = NULL;
752 const char *field_name;
753
754 vptr_fieldno = get_vptr_fieldno (type, &basetype);
755 if (parent->name == "private")
756 acc = private_field;
757 else if (parent->name == "protected")
758 acc = protected_field;
759
760 while (index >= 0)
761 {
762 if ((type == basetype && type_index == vptr_fieldno)
763 || TYPE_FIELD_ARTIFICIAL (type, type_index))
764 ; /* ignore vptr */
765 else if (match_accessibility (type, type_index, acc))
766 --index;
767 ++type_index;
768 }
769 --type_index;
770
771 /* If the type is anonymous and the field has no name,
772 set an appopriate name. */
773 field_name = TYPE_FIELD_NAME (type, type_index);
774 if (field_name == NULL || *field_name == '\0')
775 {
776 if (cname)
777 {
778 if (TYPE_CODE (TYPE_FIELD_TYPE (type, type_index))
779 == TYPE_CODE_STRUCT)
780 *cname = ANONYMOUS_STRUCT_NAME;
781 else if (TYPE_CODE (TYPE_FIELD_TYPE (type, type_index))
782 == TYPE_CODE_UNION)
783 *cname = ANONYMOUS_UNION_NAME;
784 }
785
786 if (cfull_expression)
787 *cfull_expression = std::string ();
788 }
789 else
790 {
791 if (cname)
792 *cname = TYPE_FIELD_NAME (type, type_index);
793
794 if (cfull_expression)
795 *cfull_expression
796 = string_printf ("((%s)%s%s)", parent_expression, join,
797 field_name);
798 }
799
800 if (cvalue && value)
801 *cvalue = value_struct_element_index (value, type_index);
802
803 if (ctype)
804 *ctype = TYPE_FIELD_TYPE (type, type_index);
805 }
806 else if (index < TYPE_N_BASECLASSES (type))
807 {
808 /* This is a baseclass. */
809 if (cname)
810 *cname = TYPE_FIELD_NAME (type, index);
811
812 if (cvalue && value)
813 *cvalue = value_cast (TYPE_FIELD_TYPE (type, index), value);
814
815 if (ctype)
816 {
817 *ctype = TYPE_FIELD_TYPE (type, index);
818 }
819
820 if (cfull_expression)
821 {
822 const char *ptr = was_ptr ? "*" : "";
823
824 /* Cast the parent to the base' type. Note that in gdb,
825 expression like
826 (Base1)d
827 will create an lvalue, for all appearences, so we don't
828 need to use more fancy:
829 *(Base1*)(&d)
830 construct.
831
832 When we are in the scope of the base class or of one
833 of its children, the type field name will be interpreted
834 as a constructor, if it exists. Therefore, we must
835 indicate that the name is a class name by using the
836 'class' keyword. See PR mi/11912 */
837 *cfull_expression = string_printf ("(%s(class %s%s) %s)",
838 ptr,
839 TYPE_FIELD_NAME (type, index),
840 ptr,
841 parent_expression);
842 }
843 }
844 else
845 {
846 const char *access = NULL;
847 int children[3];
848
849 cplus_class_num_children (type, children);
850
851 /* Everything beyond the baseclasses can
852 only be "public", "private", or "protected"
853
854 The special "fake" children are always output by varobj in
855 this order. So if INDEX == 2, it MUST be "protected". */
856 index -= TYPE_N_BASECLASSES (type);
857 switch (index)
858 {
859 case 0:
860 if (children[v_public] > 0)
861 access = "public";
862 else if (children[v_private] > 0)
863 access = "private";
864 else
865 access = "protected";
866 break;
867 case 1:
868 if (children[v_public] > 0)
869 {
870 if (children[v_private] > 0)
871 access = "private";
872 else
873 access = "protected";
874 }
875 else if (children[v_private] > 0)
876 access = "protected";
877 break;
878 case 2:
879 /* Must be protected. */
880 access = "protected";
881 break;
882 default:
883 /* error! */
884 break;
885 }
886
887 gdb_assert (access);
888 if (cname)
889 *cname = access;
890
891 /* Value and type and full expression are null here. */
892 }
893 }
894 else
895 {
896 c_describe_child (parent, index, cname, cvalue, ctype, cfull_expression);
897 }
898 }
899
900 static std::string
901 cplus_name_of_child (const struct varobj *parent, int index)
902 {
903 std::string name;
904
905 cplus_describe_child (parent, index, &name, NULL, NULL, NULL);
906 return name;
907 }
908
909 static std::string
910 cplus_path_expr_of_child (const struct varobj *child)
911 {
912 std::string path_expr;
913
914 cplus_describe_child (child->parent, child->index, NULL, NULL, NULL,
915 &path_expr);
916 return path_expr;
917 }
918
919 static struct value *
920 cplus_value_of_child (const struct varobj *parent, int index)
921 {
922 struct value *value = NULL;
923
924 cplus_describe_child (parent, index, NULL, &value, NULL, NULL);
925 return value;
926 }
927
928 static struct type *
929 cplus_type_of_child (const struct varobj *parent, int index)
930 {
931 struct type *type = NULL;
932
933 cplus_describe_child (parent, index, NULL, NULL, &type, NULL);
934 return type;
935 }
936
937 static std::string
938 cplus_value_of_variable (const struct varobj *var,
939 enum varobj_display_formats format)
940 {
941
942 /* If we have one of our special types, don't print out
943 any value. */
944 if (CPLUS_FAKE_CHILD (var))
945 return std::string ();
946
947 return c_value_of_variable (var, format);
948 }
949
950
951 /* varobj operations for c++. */
952
953 const struct lang_varobj_ops cplus_varobj_ops =
954 {
955 cplus_number_of_children,
956 cplus_name_of_variable,
957 cplus_name_of_child,
958 cplus_path_expr_of_child,
959 cplus_value_of_child,
960 cplus_type_of_child,
961 cplus_value_of_variable,
962 varobj_default_value_is_changeable_p,
963 NULL, /* value_has_mutated */
964 c_is_path_expr_parent /* is_path_expr_parent */
965 };
966
967
string
const char * string
Definition: signals.c:50
TYPE_FIELD_PRIVATE
#define TYPE_FIELD_PRIVATE(thistype, n)
Definition: gdbtypes.h:1399
c_name_of_variable
static std::string c_name_of_variable(const struct varobj *parent)
Definition: c-varobj.c:235
TYPE_CODE_ARRAY
Definition: gdbtypes.h:104
v_public
Definition: c-varobj.c:556
varobj::name
std::string name
Definition: varobj.h:103
varobj::index
int index
Definition: varobj.h:114
varobj
Definition: varobj.h:94
cplus_value_of_variable
static std::string cplus_value_of_variable(const struct varobj *var, enum varobj_display_formats format)
Definition: c-varobj.c:938
v_private
Definition: c-varobj.c:556
value_subscript
struct value * value_subscript(struct value *array, LONGEST index)
Definition: valarith.c:142
c_describe_child
static void c_describe_child(const struct varobj *parent, int index, std::string *cname, struct value **cvalue, struct type **ctype, std::string *cfull_expression)
Definition: c-varobj.c:285
get_vptr_fieldno
int get_vptr_fieldno(struct type *type, struct type **basetypep)
Definition: gdbtypes.c:1840
TYPE_FIELD_NAME
#define TYPE_FIELD_NAME(thistype, n)
Definition: gdbtypes.h:1372
TYPE_N_BASECLASSES
#define TYPE_N_BASECLASSES(thistype)
Definition: gdbtypes.h:1331
cplus_name_of_child
static std::string cplus_name_of_child(const struct varobj *parent, int index)
Definition: c-varobj.c:901
TYPE_LOW_BOUND
#define TYPE_LOW_BOUND(range_type)
Definition: gdbtypes.h:1244
int_string
char * int_string(LONGEST val, int radix, int is_signed, int width, int use_c_format)
Definition: print-utils.c:253
if
if(!(yy_init))
Definition: ada-lex.c:1075
TYPE_NAME
#define TYPE_NAME(thistype)
Definition: gdbtypes.h:1224
TYPE_FIELD_ARTIFICIAL
#define TYPE_FIELD_ARTIFICIAL(thistype, n)
Definition: gdbtypes.h:1379
adjust_value_for_child_access
static void adjust_value_for_child_access(struct value **value, struct type **type, int *was_ptr, int lookup_actual_type)
Definition: c-varobj.c:65
RETURN_MASK_ERROR
Definition: common-exceptions.h:43
varobj.h
value_lazy
int value_lazy(const struct value *value)
Definition: value.c:1383
lang_varobj_ops
Definition: varobj.h:175
accessibility
accessibility
Definition: c-varobj.c:680
value_ind
struct value * value_ind(struct value *arg1)
Definition: valops.c:1542
CPLUS_FAKE_CHILD
#define CPLUS_FAKE_CHILD(x)
Definition: varobj.h:170
cplus_value_of_child
static struct value * cplus_value_of_child(const struct varobj *parent, int index)
Definition: c-varobj.c:920
defs.h
TYPE_FIELD
#define TYPE_FIELD(thistype, n)
Definition: gdbtypes.h:1370
c_path_expr_of_child
static std::string c_path_expr_of_child(const struct varobj *child)
Definition: c-varobj.c:439
TYPE_FIELD_TYPE
#define TYPE_FIELD_TYPE(thistype, n)
Definition: gdbtypes.h:1371
END_CATCH
#define END_CATCH
Definition: common-exceptions.h:259
c_varobj_ops
const struct lang_varobj_ops c_varobj_ops
Definition: c-varobj.c:539
cplus_class_num_children
static void cplus_class_num_children(struct type *type, int children[3])
Definition: c-varobj.c:646
varobj_default_value_is_changeable_p
bool varobj_default_value_is_changeable_p(const struct varobj *var)
Definition: varobj.c:2440
c_value_of_child
static struct value * c_value_of_child(const struct varobj *parent, int index)
Definition: c-varobj.c:449
TYPE_IS_REFERENCE
#define TYPE_IS_REFERENCE(t)
Definition: gdbtypes.h:332
TRY
#define TRY
Definition: common-exceptions.h:246
TYPE_CODE_VOID
Definition: gdbtypes.h:124
name
const char *const name
Definition: aarch64-tdep.c:76
check_typedef
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2421
public_field
Definition: c-varobj.c:680
CATCH
#define CATCH(EXCEPTION, MASK)
Definition: common-exceptions.h:254
value_print_options
Definition: valprint.h:25
field_is_static
int field_is_static(struct field *f)
Definition: gdbtypes.c:4224
value_static_field
struct value * value_static_field(struct type *type, int fieldno)
Definition: value.c:2961
varobj::print_value
std::string print_value
Definition: varobj.h:147
varobj_is_anonymous_child
bool varobj_is_anonymous_child(const struct varobj *child)
Definition: c-varobj.c:38
gdbthread.h
varobj::type
struct type * type
Definition: varobj.h:119
TYPE_CODE_UNION
Definition: gdbtypes.h:107
type
Definition: gdbtypes.h:749
vsections
vsections
Definition: c-varobj.c:554
cplus_type_of_child
static struct type * cplus_type_of_child(const struct varobj *parent, int index)
Definition: c-varobj.c:929
value::parent
struct value * parent
Definition: value.c:263
type
static const char * type
Definition: language.c:113
varobj::value
struct value * value
Definition: varobj.h:125
value_cast
struct value * value_cast(struct type *type, struct value *arg2)
Definition: valops.c:351
cplus_varobj_ops
const struct lang_varobj_ops cplus_varobj_ops
Definition: c-varobj.c:953
varobj_value_is_changeable_p
bool varobj_value_is_changeable_p(const struct varobj *var)
Definition: varobj.c:2422
c_name_of_child
static std::string c_name_of_child(const struct varobj *parent, int index)
Definition: c-varobj.c:430
TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED
#define TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED(arraytype)
Definition: gdbtypes.h:1286
cplus_describe_child
static void cplus_describe_child(const struct varobj *parent, int index, std::string *cname, struct value **cvalue, struct type **ctype, std::string *cfull_expression)
Definition: c-varobj.c:700
TYPE_CODE_STRUCT
Definition: gdbtypes.h:106
protected_field
Definition: c-varobj.c:680
TYPE_CODE_FUNC
Definition: gdbtypes.h:110
gdb_assert
#define gdb_assert(expr)
Definition: gdb_assert.h:32
value
Definition: value.c:169
get_target_type
struct type * get_target_type(struct type *type)
Definition: gdbtypes.c:245
v_protected
Definition: c-varobj.c:556
ANONYMOUS_UNION_NAME
#define ANONYMOUS_UNION_NAME
Definition: c-varobj.c:28
TYPE_FIELD_PROTECTED
#define TYPE_FIELD_PROTECTED(thistype, n)
Definition: gdbtypes.h:1402
varobj::num_children
int num_children
Definition: varobj.h:128
TYPE_CODE_PTR
Definition: gdbtypes.h:84
c_type_of_child
static struct type * c_type_of_child(const struct varobj *parent, int index)
Definition: c-varobj.c:458
value_struct_element_index
static struct value * value_struct_element_index(struct value *value, int type_index)
Definition: c-varobj.c:247
cplus_number_of_children
static int cplus_number_of_children(const struct varobj *var)
Definition: c-varobj.c:562
match_accessibility
static int match_accessibility(struct type *type, int index, enum accessibility acc)
Definition: c-varobj.c:686
TYPE_TARGET_TYPE
#define TYPE_TARGET_TYPE(thistype)
Definition: gdbtypes.h:1226
private_field
Definition: c-varobj.c:680
TYPE_CODE
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1238
TYPE_INDEX_TYPE
#define TYPE_INDEX_TYPE(type)
Definition: gdbtypes.h:1242
varobj::children
std::vector< varobj * > children
Definition: varobj.h:134
get_user_print_options
void get_user_print_options(struct value_print_options *opts)
Definition: valprint.c:120
varobj_value_get_print_value
std::string varobj_value_get_print_value(struct value *value, enum varobj_display_formats format, const struct varobj *var)
Definition: varobj.c:2279
TYPE_NFIELDS
#define TYPE_NFIELDS(thistype)
Definition: gdbtypes.h:1239
string_printf
std::string string_printf(const char *fmt,...)
Definition: common-utils.c:150
value.h
c_is_path_expr_parent
static bool c_is_path_expr_parent(const struct varobj *var)
Definition: c-varobj.c:135
TYPE_TAG_NAME
#define TYPE_TAG_NAME(type)
Definition: gdbtypes.h:1225
varobj_get_gdb_type
struct type * varobj_get_gdb_type(const struct varobj *var)
Definition: varobj.c:914
get_type
static struct type * get_type(const struct varobj *var)
Definition: c-varobj.c:470
field_name
static PyObject * field_name(struct type *type, int field)
Definition: py-type.c:267
varobj::not_fetched
bool not_fetched
Definition: varobj.h:157
value_primitive_field
struct value * value_primitive_field(struct value *arg1, LONGEST offset, int fieldno, struct type *arg_type)
Definition: value.c:3028
value_type
struct type * value_type(const struct value *value)
Definition: value.c:1095
varobj::parent
struct varobj * parent
Definition: varobj.h:131
varobj_get_value_type
struct type * varobj_get_value_type(const struct varobj *var)
Definition: varobj.c:2011
TYPE_LENGTH
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1235
cplus_name_of_variable
static std::string cplus_name_of_variable(const struct varobj *parent)
Definition: c-varobj.c:675
varobj_get_path_expr_parent
const struct varobj * varobj_get_path_expr_parent(const struct varobj *var)
Definition: varobj.c:942
valprint.h
c_value_of_variable
static std::string c_value_of_variable(const struct varobj *var, enum varobj_display_formats format)
Definition: c-varobj.c:482
varobj::format
enum varobj_display_formats format
Definition: varobj.h:141
value_print_options::objectprint
int objectprint
Definition: valprint.h:47
ANONYMOUS_STRUCT_NAME
#define ANONYMOUS_STRUCT_NAME
Definition: c-varobj.c:27
c_number_of_children
static int c_number_of_children(const struct varobj *var)
Definition: c-varobj.c:184
cplus_path_expr_of_child
static std::string cplus_path_expr_of_child(const struct varobj *child)
Definition: c-varobj.c:910
value_actual_type
struct type * value_actual_type(struct value *value, int resolve_simple_types, int *real_type_found)
Definition: value.c:1183
varobj_get_path_expr
const char * varobj_get_path_expr(const struct varobj *var)
Definition: varobj.c:956
varobj_display_formats
varobj_display_formats
Definition: varobj.h:25