projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
C++ compile support
[deliverable/binutils-gdb.git] / gdb / compile / compile-cplus-types.c
CommitLineData
078a0207
KS		 1/* Convert types from GDB to GCC
2
3 Copyright (C) 2014-2018 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20
21#include "defs.h"
22#include "common/preprocessor.h"
23#include "gdbtypes.h"
24#include "compile-internal.h"
25#include "compile-cplus.h"
26#include "gdb_assert.h"
27#include "symtab.h"
28#include "source.h"
29#include "cp-support.h"
30#include "cp-abi.h"
31#include "symtab.h"
32#include "objfiles.h"
33#include "block.h"
34#include "gdbcmd.h"
35#include "c-lang.h"
36#include "compile-c.h" /* Included for c_get_range_decl_name
37 et al. */
38#include <algorithm>
39
40/* Default compile flags for C++. */
41
42const char *compile_cplus_instance::m_default_cflags = "-std=gnu++11";
43
44/* Flag to enable internal debugging. */
45
46static int debug_compile_cplus_types = 0;
47
48/* Flag to enable internal scope switching debugging. */
49
50static int debug_compile_cplus_scopes = 0;
51
52/* Forward declarations. */
53
54static gcc_type compile_cplus_convert_func (compile_cplus_instance *instance,
55 struct type *type,
56 bool strip_artificial);
57
58/* See description in compile-cplus.h. */
59
60gdb::unique_xmalloc_ptr<char>
61compile_cplus_instance::decl_name (const char *natural)
62{
63 if (natural == nullptr)
64 return nullptr;
65
66 char *name = cp_func_name (natural);
67 if (name != nullptr)
68 return gdb::unique_xmalloc_ptr<char> (name);
69
70 return gdb::unique_xmalloc_ptr<char> (xstrdup (natural));
71}
72
73/* Get the access flag for the NUM'th field of TYPE. */
74
75static enum gcc_cp_symbol_kind
76get_field_access_flag (const struct type *type, int num)
77{
78 if (TYPE_FIELD_PROTECTED (type, num))
79 return GCC_CP_ACCESS_PROTECTED;
80 else if (TYPE_FIELD_PRIVATE (type, num))
81 return GCC_CP_ACCESS_PRIVATE;
82
83 /* GDB assumes everything else is public. */
84 return GCC_CP_ACCESS_PUBLIC;
85}
86
87/* Get the access flag for the NUM'th method of TYPE's FNI'th
88 fieldlist. */
89
90enum gcc_cp_symbol_kind
91get_method_access_flag (const struct type *type, int fni, int num)
92{
93 gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT);
94
95 /* If this type was not declared a class, everything is public. */
96 if (!TYPE_DECLARED_CLASS (type))
97 return GCC_CP_ACCESS_PUBLIC;
98
99 /* Otherwise, read accessibility from the fn_field. */
100 const struct fn_field *methods = TYPE_FN_FIELDLIST1 (type, fni);
101 if (TYPE_FN_FIELD_PROTECTED (methods, num))
102 return GCC_CP_ACCESS_PROTECTED;
103 else if (TYPE_FN_FIELD_PRIVATE (methods, num))
104 return GCC_CP_ACCESS_PRIVATE;
105 else
106 return GCC_CP_ACCESS_PUBLIC;
107}
108
109/* A useful debugging function to output the scope SCOPE to stdout. */
110
111static void __attribute__ ((used))
112debug_print_scope (const compile_scope &scope)
113{
114 for (const auto &comp: scope)
115 {
116 const char *symbol = (comp.bsymbol.symbol != nullptr
117 ? SYMBOL_NATURAL_NAME (comp.bsymbol.symbol)
118 : "<none>");
119
120 printf_unfiltered ("\tname = %s, symbol = %s\n", comp.name.c_str (),
121 symbol);
122 }
123}
124
125/* See description in compile-cplus.h. */
126
127compile_scope
128type_name_to_scope (const char *type_name, const struct block *block)
129{
130 compile_scope scope;
131
132 if (type_name == nullptr)
133 {
134 /* An anonymous type. We cannot really do much here. We simply cannot
135 look up anonymous types easily/at all. */
136 return scope;
137 }
138
139 const char *p = type_name;
140 std::string lookup_name;
141
142 while (*p != '\0')
143 {
144 /* Create a string token of the first component of TYPE_NAME. */
145 int len = cp_find_first_component (p);
146 std::string s (p, len);
147
148 /* Advance past the last token. */
149 p += len;
150
151 /* Look up the symbol and decide when to stop. */
152 if (!lookup_name.empty ())
153 lookup_name += "::";
154 lookup_name += s;
155
156 /* Look up the resulting name. */
157 struct block_symbol bsymbol
158 = lookup_symbol (lookup_name.c_str (), block, VAR_DOMAIN, nullptr);
159
160 if (bsymbol.symbol != nullptr)
161 {
162 scope_component comp = {s, bsymbol};
163
164 scope.push_back (comp);
165
166 if (TYPE_CODE (SYMBOL_TYPE (bsymbol.symbol)) != TYPE_CODE_NAMESPACE)
167 {
168 /* We're done. */
169 break;
170 }
171 }
172
173 if (*p == ':')
174 {
175 ++p;
176 if (*p == ':')
177 ++p;
178 else
179 {
180 /* This shouldn't happen since we are not attempting to
181 loop over user input. This name is generated by GDB
182 from debug info. */
183 internal_error (__FILE__, __LINE__,
184 _("malformed TYPE_NAME during parsing"));
185 }
186 }
187 }
188
189 return scope;
190}
191
192/* Compare two scope_components for equality. These are equal if the names
193 of the two components' are the same. */
194
195bool
196operator== (const scope_component &lhs, const scope_component &rhs)
197{
198 return lhs.name == rhs.name;
199}
200
201/* Compare two scope_components for inequality. These are not equal if
202 the two components' names are not equal. */
203
204bool
205operator!= (const scope_component &lhs, const scope_component &rhs)
206{
207 return lhs.name != rhs.name;
208}
209
210/* Compare two compile_scopes for equality. These are equal if they are both
211 contain the same number of components and each component is equal. */
212
213bool
214operator== (const compile_scope &lhs, const compile_scope &rhs)
215{
216 if (lhs.size () != rhs.size ())
217 return false;
218
219 for (int i = 0; i < lhs.size (); ++i)
220 {
221 if (lhs[i] != rhs[i])
222 return false;
223 }
224
225 return true;
226}
227
228/* Compare two compile_scopes for inequality. These are inequal if they
229 contain unequal number of elements or if any of the components are not
230 the same. */
231
232bool
233operator!= (const compile_scope &lhs, const compile_scope &rhs)
234{
235 if (lhs.size () != rhs.size ())
236 return true;
237
238 for (int i = 0; i < lhs.size (); ++i)
239 {
240 if (lhs[i] != rhs[i])
241 return true;
242 }
243
244 return false;
245}
246
247/* See description in compile-cplus.h. */
248
249void
250compile_cplus_instance::enter_scope (compile_scope &new_scope)
251{
252 bool must_push = m_scopes.empty () || m_scopes.back () != new_scope;
253
254 new_scope.m_pushed = must_push;
255
256 /* Save the new scope. */
257 m_scopes.push_back (new_scope);
258
259 if (must_push)
260 {
261 if (debug_compile_cplus_scopes)
262 fprintf_unfiltered (gdb_stdlog, "entering new scope %p\n", new_scope);
263
264 /* Push the global namespace. */
265 plugin ().push_namespace ("");
266
267 /* Push all other namespaces. Note that we do not push the last
268 scope_component -- that's the actual type we are converting. */
269 std::for_each
270 (new_scope.begin (), new_scope.end () - 1,
271 [this] (const scope_component &comp)
272 {
273 gdb_assert (TYPE_CODE (SYMBOL_TYPE (comp.bsymbol.symbol))
274 == TYPE_CODE_NAMESPACE);
275
276 const char *ns = (comp.name == CP_ANONYMOUS_NAMESPACE_STR ? nullptr
277 : comp.name.c_str ());
278
279 this->plugin ().push_namespace (ns);
280 });
281 }
282 else
283 {
284 if (debug_compile_cplus_scopes)
285 {
286 fprintf_unfiltered (gdb_stdlog, "staying in current scope -- "
287 "scopes are identical\n");
288 }
289 }
290}
291
292/* See description in compile-cplus.h. */
293
294void
295compile_cplus_instance::leave_scope ()
296{
297 /* Get the current scope and remove it from the internal list of
298 scopes. */
299 compile_scope current = m_scopes.back ();
300
301 m_scopes.pop_back ();
302
303 if (current.m_pushed)
304 {
305 if (debug_compile_cplus_scopes)
306 fprintf_unfiltered (gdb_stdlog, "leaving scope %p\n", current);
307
308 /* Pop namespaces. */
309 std::for_each
310 (current.begin (),current.end () - 1,
311 [this] (const scope_component &comp) {
312 gdb_assert (TYPE_CODE (SYMBOL_TYPE (comp.bsymbol.symbol))
313 == TYPE_CODE_NAMESPACE);
314 this->plugin ().pop_binding_level (comp.name.c_str ());
315 });
316
317 /* Pop global namespace. */
318 plugin ().pop_binding_level ("");
319 }
320 else
321 {
322 if (debug_compile_cplus_scopes)
323 fprintf_unfiltered (gdb_stdlog,
324 "identical scopes -- not leaving scope\n");
325 }
326}
327
328/* See description in compile-cplus.h. */
329
330compile_scope
331compile_cplus_instance::new_scope (const char *type_name, struct type *type)
332{
333 /* Break the type name into components. If TYPE was defined in some
334 superclass, we do not process TYPE but process the enclosing type
335 instead. */
336 compile_scope scope = type_name_to_scope (type_name, block ());
337
338 if (!scope.empty ())
339 {
340 /* Get the name of the last component, which should be the
341 unqualified name of the type to process. */
342 scope_component &comp = scope.back ();
343
344 if (!types_equal (type, SYMBOL_TYPE (comp.bsymbol.symbol))
345 && (m_scopes.empty ()
346 || (m_scopes.back ().back ().bsymbol.symbol
347 != comp.bsymbol.symbol)))
348 {
349 /* The type is defined inside another class(es). Convert that
350 type instead of defining this type. */
351 convert_type (SYMBOL_TYPE (comp.bsymbol.symbol));
352
353 /* If the original type (passed in to us) is defined in a nested
354 class, the previous call will give us that type's gcc_type.
355 Upper layers are expecting to get the original type's
356 gcc_type! */
357 get_cached_type (type, scope.m_nested_type);
358 return scope;
359 }
360 }
361 else
362 {
363 if (TYPE_NAME (type) == nullptr)
364 {
365 /* Anonymous type */
366
367 /* We don't have a qualified name for this to look up, but
368 we need a scope. We have to assume, then, that it is the same
369 as the current scope, if any. */
370 if (!m_scopes.empty ())
371 {
372 scope = m_scopes.back ();
373 scope.m_pushed = false;
374 }
375 else
376 scope.push_back (scope_component ());
377 }
378 else
379 {
380 scope_component comp
381 = {
382 decl_name (TYPE_NAME (type)).get (),
383 lookup_symbol (TYPE_NAME (type), block (), VAR_DOMAIN, nullptr)
384 };
385 scope.push_back (comp);
386 }
387 }
388
389 /* There must be at least one component in the compile_scope. */
390 gdb_assert (scope.size () > 0);
391 return scope;
392}
393
394/* See description in compile-cplus.h. */
395
396gcc_type
397compile_cplus_instance::convert_reference_base
398 (gcc_type base, enum gcc_cp_ref_qualifiers rquals)
399{
400 return this->plugin ().build_reference_type (base, rquals);
401}
402
403/* Convert a reference type to its gcc representation. */
404
405static gcc_type
406compile_cplus_convert_reference (compile_cplus_instance *instance,
407 struct type *type)
408{
409 gcc_type target = instance->convert_type (TYPE_TARGET_TYPE (type));
410
411 enum gcc_cp_ref_qualifiers quals = GCC_CP_REF_QUAL_NONE;
412 switch (TYPE_CODE (type))
413 {
414 case TYPE_CODE_REF:
415 quals = GCC_CP_REF_QUAL_LVALUE;
416 break;
417 case TYPE_CODE_RVALUE_REF:
418 quals = GCC_CP_REF_QUAL_RVALUE;
419 break;
420 default:
421 gdb_assert_not_reached ("unexpected type code for reference type");
422 }
423
424 return instance->convert_reference_base (target, quals);
425}
426
427/* See description in compile-cplus.h. */
428
429gcc_type
430compile_cplus_instance::convert_pointer_base(gcc_type target)
431{
432 return plugin ().build_pointer_type (target);
433}
434
435/* Convert a pointer type to its gcc representation. */
436
437static gcc_type
438compile_cplus_convert_pointer (compile_cplus_instance *instance,
439 struct type *type)
440{
441 gcc_type target = instance->convert_type (TYPE_TARGET_TYPE (type));
442
443 return instance->convert_pointer_base (target);
444}
445
446/* Convert an array type to its gcc representation. */
447
448static gcc_type
449compile_cplus_convert_array (compile_cplus_instance *instance,
450 struct type *type)
451{
452 struct type *range = TYPE_INDEX_TYPE (type);
453 gcc_type element_type = instance->convert_type (TYPE_TARGET_TYPE (type));
454
455 if (TYPE_LOW_BOUND_KIND (range) != PROP_CONST)
456 {
457 const char *s = _("array type with non-constant"
458 " lower bound is not supported");
459
460 return instance->plugin ().error (s);
461 }
462
463 if (TYPE_LOW_BOUND (range) != 0)
464 {
465 const char *s = _("cannot convert array type with "
466 "non-zero lower bound to C");
467
468 return instance->plugin ().error (s);
469 }
470
471 if (TYPE_HIGH_BOUND_KIND (range) == PROP_LOCEXPR
472 || TYPE_HIGH_BOUND_KIND (range) == PROP_LOCLIST)
473 {
474 if (TYPE_VECTOR (type))
475 {
476 const char *s = _("variably-sized vector type is not supported");
477
478 return instance->plugin ().error (s);
479 }
480
481 std::string upper_bound
482 = c_get_range_decl_name (&TYPE_RANGE_DATA (range)->high);
483 return instance->plugin ().build_vla_array_type (element_type,
484 upper_bound.c_str ());
485 }
486 else
487 {
488 LONGEST low_bound, high_bound, count;
489
490 if (get_array_bounds (type, &low_bound, &high_bound) == 0)
491 count = -1;
492 else
493 {
494 gdb_assert (low_bound == 0); /* Ensured above. */
495 count = high_bound + 1;
496 }
497
498 if (TYPE_VECTOR (type))
499 return instance->plugin ().build_vector_type (element_type, count);
500
501 return instance->plugin ().build_array_type (element_type, count);
502 }
503}
504
505/* Convert a typedef of TYPE. If not GCC_CP_ACCESS_NONE, NESTED_ACCESS
506 will define the accessibility of the typedef definition in its
507 containing class. */
508
509static gcc_type
510compile_cplus_convert_typedef (compile_cplus_instance *instance,
511 struct type *type,
512 enum gcc_cp_symbol_kind nested_access)
513{
514 compile_scope scope = instance->new_scope (TYPE_NAME (type), type);
515
516 if (scope.nested_type () != GCC_TYPE_NONE)
517 return scope.nested_type ();
518
519 gdb::unique_xmalloc_ptr<char> name
520 = compile_cplus_instance::decl_name (TYPE_NAME (type));
521
522 /* Make sure the scope for this type has been pushed. */
523 instance->enter_scope (scope);
524
525 /* Convert the typedef's real type. */
526 gcc_type typedef_type = instance->convert_type (check_typedef (type));
527
528 instance->plugin ().build_decl ("typedef", name.get (),
529 GCC_CP_SYMBOL_TYPEDEF | nested_access,
530 typedef_type, 0, 0, nullptr, 0);
531
532 /* Completed this scope. */
533 instance->leave_scope ();
534 return typedef_type;
535}
536
537/* Convert types defined in TYPE. */
538
539static void
540compile_cplus_convert_type_defns (compile_cplus_instance *instance,
541 struct type *type)
542{
543 int i;
544 enum gcc_cp_symbol_kind accessibility;
545
546 /* Convert typedefs. */
547 for (i = 0; i < TYPE_TYPEDEF_FIELD_COUNT (type); ++i)
548 {
549 if (TYPE_TYPEDEF_FIELD_PROTECTED (type, i))
550 accessibility = GCC_CP_ACCESS_PROTECTED;
551 else if (TYPE_TYPEDEF_FIELD_PRIVATE (type, i))
552 accessibility = GCC_CP_ACCESS_PRIVATE;
553 else
554 accessibility = GCC_CP_ACCESS_PUBLIC;
555 instance->convert_type (TYPE_TYPEDEF_FIELD_TYPE (type, i), accessibility);
556 }
557
558 /* Convert nested types. */
559 for (i = 0; i < TYPE_NESTED_TYPES_COUNT (type); ++i)
560 {
561 if (TYPE_NESTED_TYPES_FIELD_PROTECTED (type, i))
562 accessibility = GCC_CP_ACCESS_PROTECTED;
563 else if (TYPE_NESTED_TYPES_FIELD_PRIVATE (type, i))
564 accessibility = GCC_CP_ACCESS_PRIVATE;
565 else
566 accessibility = GCC_CP_ACCESS_PUBLIC;
567 instance->convert_type (TYPE_NESTED_TYPES_FIELD_TYPE (type, i),
568 accessibility);
569 }
570}
571
572/* Convert data members defined in TYPE, which should be struct/class/union
573 with gcc_type COMP_TYPE. */
574
575static void
576compile_cplus_convert_struct_or_union_members
577 (compile_cplus_instance *instance, struct type *type, gcc_type comp_type)
578{
579 for (int i = TYPE_N_BASECLASSES (type); i < TYPE_NFIELDS (type); ++i)
580 {
581 const char *field_name = TYPE_FIELD_NAME (type, i);
582
583 if (TYPE_FIELD_IGNORE (type, i)
584 || TYPE_FIELD_ARTIFICIAL (type, i))
585 continue;
586
587 /* GDB records unnamed/anonymous fields with empty string names. */
588 if (*field_name == '\0')
589 field_name = nullptr;
590
591 gcc_type field_type
592 = instance->convert_type (TYPE_FIELD_TYPE (type, i));
593
594 if (field_is_static (&TYPE_FIELD (type, i)))
595 {
596 CORE_ADDR physaddr;
597
598 switch (TYPE_FIELD_LOC_KIND (type, i))
599 {
600 case FIELD_LOC_KIND_PHYSADDR:
601 {
602 physaddr = TYPE_FIELD_STATIC_PHYSADDR (type, i);
603
604 instance->plugin ().build_decl
605 ("field physaddr", field_name,
606 (GCC_CP_SYMBOL_VARIABLE | get_field_access_flag (type, i)),
607 field_type, nullptr, physaddr, nullptr, 0);
608 }
609 break;
610
611 case FIELD_LOC_KIND_PHYSNAME:
612 {
613 const char *physname = TYPE_FIELD_STATIC_PHYSNAME (type, i);
614 struct block_symbol sym
615 = lookup_symbol (physname, instance->block (),
616 VAR_DOMAIN, nullptr);
617
618 if (sym.symbol == nullptr)
619 {
620 /* We didn't actually find the symbol. There's little
621 we can do but ignore this member. */
622 continue;
623 }
624 const char *filename = symbol_symtab (sym.symbol)->filename;
625 unsigned int line = SYMBOL_LINE (sym.symbol);
626
627 physaddr = SYMBOL_VALUE_ADDRESS (sym.symbol);
628 instance->plugin ().build_decl
629 ("field physname", field_name,
630 (GCC_CP_SYMBOL_VARIABLE| get_field_access_flag (type, i)),
631 field_type, nullptr, physaddr, filename, line);
632 }
633 break;
634
635 default:
636 gdb_assert_not_reached
637 ("unexpected static field location kind");
638 }
639 }
640 else
641 {
642 unsigned long bitsize = TYPE_FIELD_BITSIZE (type, i);
643 enum gcc_cp_symbol_kind field_flags = GCC_CP_SYMBOL_FIELD
644 | get_field_access_flag (type, i);
645
646 if (bitsize == 0)
647 bitsize = 8 * TYPE_LENGTH (TYPE_FIELD_TYPE (type, i));
648
649 instance->plugin ().build_field
650 (field_name, field_type, field_flags, bitsize,
651 TYPE_FIELD_BITPOS (type, i));
652 }
653 }
654}
655
656/* Convert a method type to its gcc representation. */
657
658static gcc_type
659compile_cplus_convert_method (compile_cplus_instance *instance,
660 struct type *parent_type,
661 struct type *method_type)
662{
663 /* Get the actual function type of the method, the corresponding class's
664 type and corresponding qualifier flags. */
665 gcc_type func_type = compile_cplus_convert_func (instance, method_type, true);
666 gcc_type class_type = instance->convert_type (parent_type);
667 gcc_cp_qualifiers_flags quals = (enum gcc_cp_qualifiers) 0;
668
669 if (TYPE_CONST (method_type))
670 quals |= GCC_CP_QUALIFIER_CONST;
671 if (TYPE_VOLATILE (method_type))
672 quals |= GCC_CP_QUALIFIER_VOLATILE;
673 if (TYPE_RESTRICT (method_type))
674 quals |= GCC_CP_QUALIFIER_RESTRICT;
675
676 /* Not yet implemented. */
677 gcc_cp_ref_qualifiers_flags rquals = GCC_CP_REF_QUAL_NONE;
678
679 return instance->plugin ().build_method_type
680 (class_type, func_type, quals, rquals);
681}
682
683/* Convert a member or method pointer represented by TYPE. */
684
685static gcc_type
686compile_cplus_convert_memberptr (compile_cplus_instance *instance,
687 struct type *type)
688{
689 struct type *containing_class = TYPE_SELF_TYPE (type);
690
691 if (containing_class == nullptr)
692 return GCC_TYPE_NONE;
693
694 gcc_type class_type = instance->convert_type (containing_class);
695 gcc_type member_type
696 = instance->convert_type (TYPE_TARGET_TYPE (type));
697
698 return instance->plugin ().build_pointer_to_member_type
699 (class_type, member_type);
700}
701
702/* Convert all methods defined in TYPE, which should be a class/struct/union
703 with gcc_type CLASS_TYPE. */
704
705static void
706compile_cplus_convert_struct_or_union_methods (compile_cplus_instance *instance,
707 struct type *type,
708 gcc_type class_type)
709{
710 for (int i = 0; i < TYPE_NFN_FIELDS (type); ++i)
711 {
712 struct fn_field *methods = TYPE_FN_FIELDLIST1 (type, i);
713 gdb::unique_xmalloc_ptr<char> overloaded_name
714 = compile_cplus_instance::decl_name (TYPE_FN_FIELDLIST_NAME (type, i));
715
716 /* Loop through the fieldlist, adding decls to the compiler's
717 representation of the class. */
718 for (int j = 0; j < TYPE_FN_FIELDLIST_LENGTH (type, i); ++j)
719 {
720 /* Skip artificial methods. */
721 if (TYPE_FN_FIELD_ARTIFICIAL (methods, j))
722 continue;
723
724 gcc_cp_symbol_kind_flags sym_kind = GCC_CP_SYMBOL_FUNCTION;
725 gcc_type method_type;
726 struct block_symbol sym
727 = lookup_symbol (TYPE_FN_FIELD_PHYSNAME (methods, j),
728 instance->block (), VAR_DOMAIN, nullptr);
729
730 if (sym.symbol == nullptr)
731 {
732 if (TYPE_FN_FIELD_VIRTUAL_P (methods, j))
733 {
734 /* This is beyond hacky, and is really only a workaround for
735 detecting pure virtual methods. */
736 method_type = compile_cplus_convert_method
737 (instance, type, TYPE_FN_FIELD_TYPE (methods, j));
738
739 instance->plugin ().build_decl
740 ("pure virtual method", overloaded_name.get (),
741 (sym_kind
742 | get_method_access_flag (type, i, j)
743 | GCC_CP_FLAG_VIRTUAL_FUNCTION
744 | GCC_CP_FLAG_PURE_VIRTUAL_FUNCTION),
745 method_type, nullptr, 0, nullptr, 0);
746 continue;
747 }
748
749 /* This can happen if we have a DW_AT_declaration DIE
750 for the method, but no "definition"-type DIE (with
751 DW_AT_specification referencing the decl DIE), i.e.,
752 the compiler has probably optimized the method away.
753
754 In this case, all we can hope to do is issue a warning
755 to the user letting him know. If the user has not actually
756 requested using this method, things should still work. */
757 warning (_("Method %s appears to be optimized out.\n"
758 "All references to this method will be undefined."),
759 TYPE_FN_FIELD_PHYSNAME (methods, j));
760 continue;
761 }
762
763 const char *filename = symbol_symtab (sym.symbol)->filename;
764 unsigned int line = SYMBOL_LINE (sym.symbol);
765 CORE_ADDR address = BLOCK_START (SYMBOL_BLOCK_VALUE (sym.symbol));
766 const char *kind;
767
768 if (TYPE_FN_FIELD_STATIC_P (methods, j))
769 {
770 kind = "static method";
771 method_type = compile_cplus_convert_func
772 (instance, TYPE_FN_FIELD_TYPE (methods, j), true);
773 }
774 else
775 {
776 kind = "method";
777 method_type = (compile_cplus_convert_method
778 (instance, type, TYPE_FN_FIELD_TYPE (methods, j)));
779 }
780
781 if (TYPE_FN_FIELD_VIRTUAL_P (methods, j))
782 sym_kind |= GCC_CP_FLAG_VIRTUAL_FUNCTION;
783
784 instance->plugin ().build_decl
785 (kind, overloaded_name.get (),
786 sym_kind | get_method_access_flag (type, i, j),
787 method_type, nullptr, address, filename, line);
788 }
789 }
790}
791
792/* Convert a struct or union type to its gcc representation. If this type
793 was defined in another type, NESTED_ACCESS should indicate the
794 accessibility of this type. */
795
796static gcc_type
797compile_cplus_convert_struct_or_union (compile_cplus_instance *instance,
798 struct type *type,
799 enum gcc_cp_symbol_kind nested_access)
800{
801 const char *filename = nullptr;
802 unsigned short line = 0;
803
804 /* Get the decl name of this type. */
805 gdb::unique_xmalloc_ptr<char> name
806 = compile_cplus_instance::decl_name (TYPE_NAME (type));
807
808 /* Create a new scope for TYPE. */
809 compile_scope scope = instance->new_scope (TYPE_NAME (type), type);
810
811 if (scope.nested_type () != GCC_TYPE_NONE)
812 {
813 /* The type requested was actually defined inside another type,
814 such as a nested class definition. Return that type. */
815 return scope.nested_type ();
816 }
817
818 /* Push all scopes. */
819 instance->enter_scope (scope);
820
821 /* First we create the resulting type and enter it into our hash
822 table. This lets recursive types work. */
823
824 gcc_decl resuld;
825 if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
826 {
827 const char *what = TYPE_DECLARED_CLASS (type) ? "struct" : "class";
828
829 resuld = instance->plugin ().build_decl
830 (what, name.get (), (GCC_CP_SYMBOL_CLASS | nested_access
831 | (TYPE_DECLARED_CLASS (type)
832 ? GCC_CP_FLAG_CLASS_NOFLAG
833 : GCC_CP_FLAG_CLASS_IS_STRUCT)),
834 0, nullptr, 0, filename, line);
835 }
836 else
837 {
838 gdb_assert (TYPE_CODE (type) == TYPE_CODE_UNION);
839 resuld = instance->plugin ().build_decl
840 ("union", name.get (), GCC_CP_SYMBOL_UNION | nested_access,
841 0, nullptr, 0, filename, line);
842 }
843
844 gcc_type result;
845 if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
846 {
847 struct gcc_vbase_array bases;
848 int num_baseclasses = TYPE_N_BASECLASSES (type);
849
850 memset (&bases, 0, sizeof (bases));
851
852 if (num_baseclasses > 0)
853 {
854 bases.elements = XNEWVEC (gcc_type, num_baseclasses);
855 bases.flags = XNEWVEC (enum gcc_cp_symbol_kind, num_baseclasses);
856 bases.n_elements = num_baseclasses;
857 for (int i = 0; i < num_baseclasses; ++i)
858 {
859 struct type *base_type = TYPE_BASECLASS (type, i);
860
861 bases.flags[i] = GCC_CP_SYMBOL_BASECLASS
862 | get_field_access_flag (type, i)
863 | (BASETYPE_VIA_VIRTUAL (type, i)
864 ? GCC_CP_FLAG_BASECLASS_VIRTUAL
865 : GCC_CP_FLAG_BASECLASS_NOFLAG);
866 bases.elements[i] = instance->convert_type (base_type);
867 }
868 }
869
870 result = instance->plugin ().start_class_type
871 (name.get (), resuld, &bases, filename, line);
872 xfree (bases.flags);
873 xfree (bases.elements);
874 }
875 else
876 {
877 gdb_assert (TYPE_CODE (type) == TYPE_CODE_UNION);
878 result = instance->plugin ().start_class_type
879 (name.get (), resuld, nullptr, filename, line);
880 }
881
882 instance->insert_type (type, result);
883
884 /* Add definitions. */
885 compile_cplus_convert_type_defns (instance, type);
886
887 /* Add methods. */
888 compile_cplus_convert_struct_or_union_methods (instance, type, result);
889
890 /* Add members. */
891 compile_cplus_convert_struct_or_union_members (instance, type, result);
892
893 /* All finished. */
894 instance->plugin ().finish_class_type (name.get (), TYPE_LENGTH (type));
895
896 /* Pop all scopes. */
897 instance->leave_scope ();
898 return result;
899}
900
901/* Convert an enum type to its gcc representation. If this type
902 was defined in another type, NESTED_ACCESS should indicate the
903 accessibility of this type.*/
904
905static gcc_type
906compile_cplus_convert_enum (compile_cplus_instance *instance, struct type *type,
907 enum gcc_cp_symbol_kind nested_access)
908{
909 int scoped_enum_p = FALSE;
910
911 /* Create a new scope for this type. */
912 compile_scope scope = instance->new_scope (TYPE_NAME (type), type);
913
914 if (scope.nested_type () != GCC_TYPE_NONE)
915 {
916 /* The type requested was actually defined inside another type,
917 such as a nested class definition. Return that type. */
918 return scope.nested_type ();
919 }
920
921 gdb::unique_xmalloc_ptr<char> name
922 = compile_cplus_instance::decl_name (TYPE_NAME (type));
923
924 /* Push all scopes. */
925 instance->enter_scope (scope);
926
927 gcc_type int_type
928 = instance->plugin ().get_int_type (TYPE_UNSIGNED (type),
929 TYPE_LENGTH (type), nullptr);
930 gcc_type result
931 = instance->plugin ().start_enum_type (name.get (), int_type,
932 GCC_CP_SYMBOL_ENUM | nested_access
933 | (scoped_enum_p
934 ? GCC_CP_FLAG_ENUM_SCOPED
935 : GCC_CP_FLAG_ENUM_NOFLAG),
936 nullptr, 0);
937 for (int i = 0; i < TYPE_NFIELDS (type); ++i)
938 {
939 gdb::unique_xmalloc_ptr<char> fname
940 = compile_cplus_instance::decl_name (TYPE_FIELD_NAME (type, i));
941
942 if (TYPE_FIELD_LOC_KIND (type, i) != FIELD_LOC_KIND_ENUMVAL
943 || fname == nullptr)
944 continue;
945
946 instance->plugin ().build_enum_constant (result, fname.get (),
947 TYPE_FIELD_ENUMVAL (type, i));
948 }
949
950 /* Finish enum definition and pop scopes. */
951 instance->plugin ().finish_enum_type (result);
952 instance->leave_scope ();
953 return result;
954}
955
956/* Convert a function type to its gcc representation. This function does
957 not deal with function templates. */
958
959static gcc_type
960compile_cplus_convert_func (compile_cplus_instance *instance,
961 struct type *type, bool strip_artificial)
962{
963 int is_varargs = TYPE_VARARGS (type);
964 struct type *target_type = TYPE_TARGET_TYPE (type);
965
966 /* Functions with no debug info have no return type. Ideally we'd
967 want to fallback to the type of the cast just before the
968 function, like GDB's built-in expression parser, but we don't
969 have access to that type here. For now, fallback to int, like
970 GDB's parser used to do. */
971 if (target_type == nullptr)
972 {
973 if (TYPE_OBJFILE_OWNED (type))
974 target_type = objfile_type (TYPE_OWNER (type).objfile)->builtin_int;
975 else
976 target_type = builtin_type (TYPE_OWNER (type).gdbarch)->builtin_int;
977 warning (_("function has unknown return type; assuming int"));
978 }
979
980 /* This approach means we can't make self-referential function
981 types. Those are impossible in C, though. */
982 gcc_type return_type = instance->convert_type (target_type);
983
984 struct gcc_type_array array =
985 { TYPE_NFIELDS (type), XNEWVEC (gcc_type, TYPE_NFIELDS (type)) };
986 int artificials = 0;
987 for (int i = 0; i < TYPE_NFIELDS (type); ++i)
988 {
989 if (strip_artificial && TYPE_FIELD_ARTIFICIAL (type, i))
990 {
991 --array.n_elements;
992 ++artificials;
993 }
994 else
995 {
996 array.elements[i - artificials]
997 = instance->convert_type (TYPE_FIELD_TYPE (type, i));
998 }
999 }
1000
1001 /* We omit setting the argument types to `void' to be a little flexible
1002 with some minsyms like printf (compile-cplus.exp has examples). */
1003 gcc_type result = instance->plugin ().build_function_type
1004 (return_type, &array, is_varargs);
1005 xfree (array.elements);
1006 return result;
1007}
1008
1009/* Convert an integer type to its gcc representation. */
1010
1011static gcc_type
1012compile_cplus_convert_int (compile_cplus_instance *instance, struct type *type)
1013{
1014 if (TYPE_NOSIGN (type))
1015 {
1016 gdb_assert (TYPE_LENGTH (type) == 1);
1017 return instance->plugin ().get_char_type ();
1018 }
1019
1020 return instance->plugin ().get_int_type
1021 (TYPE_UNSIGNED (type), TYPE_LENGTH (type), TYPE_NAME (type));
1022}
1023
1024/* Convert a floating-point type to its gcc representation. */
1025
1026static gcc_type
1027compile_cplus_convert_float (compile_cplus_instance *instance,
1028 struct type *type)
1029{
1030 return instance->plugin ().get_float_type
1031 (TYPE_LENGTH (type), TYPE_NAME (type));
1032}
1033
1034/* Convert the 'void' type to its gcc representation. */
1035
1036static gcc_type
1037compile_cplus_convert_void (compile_cplus_instance *instance, struct type *type)
1038{
1039 return instance->plugin ().get_void_type ();
1040}
1041
1042/* Convert a boolean type to its gcc representation. */
1043
1044static gcc_type
1045compile_cplus_convert_bool (compile_cplus_instance *instance, struct type *type)
1046{
1047 return instance->plugin ().get_bool_type ();
1048}
1049
1050/* See description in compile-cplus.h. */
1051
1052gcc_type
1053compile_cplus_instance::convert_qualified_base (gcc_type base,
1054 gcc_cp_qualifiers_flags quals)
1055{
1056 gcc_type result = base;
1057
1058 if (quals != GCC_CP_REF_QUAL_NONE)
1059 result = plugin ().build_qualified_type (base, quals);
1060
1061 return result;
1062}
1063
1064/* See description in compile-cplus.h. */
1065
1066static gcc_type
1067compile_cplus_convert_qualified (compile_cplus_instance *instance,
1068 struct type *type)
1069{
1070 struct type *unqual = make_unqualified_type (type);
1071 gcc_cp_qualifiers_flags quals = (enum gcc_cp_qualifiers) 0;
1072 gcc_type unqual_converted = instance->convert_type (unqual);
1073
1074 if (TYPE_CONST (type))
1075 quals |= GCC_CP_QUALIFIER_CONST;
1076 if (TYPE_VOLATILE (type))
1077 quals |= GCC_CP_QUALIFIER_VOLATILE;
1078 if (TYPE_RESTRICT (type))
1079 quals |= GCC_CP_QUALIFIER_RESTRICT;
1080
1081 return instance->convert_qualified_base (unqual_converted, quals);
1082}
1083
1084/* Convert a complex type to its gcc representation. */
1085
1086static gcc_type
1087compile_cplus_convert_complex (compile_cplus_instance *instance,
1088 struct type *type)
1089{
1090 gcc_type base = instance->convert_type (TYPE_TARGET_TYPE (type));
1091
1092 return instance->plugin ().build_complex_type (base);
1093}
1094
1095/* Convert a namespace of TYPE. */
1096
1097static gcc_type
1098compile_cplus_convert_namespace (compile_cplus_instance *instance,
1099 struct type *type)
1100{
1101 compile_scope scope = instance->new_scope (TYPE_NAME (type), type);
1102 gdb::unique_xmalloc_ptr<char> name
1103 = compile_cplus_instance::decl_name (TYPE_NAME (type));
1104
1105 /* Push scope. */
1106 instance->enter_scope (scope);
1107
1108 /* Convert this namespace. */
1109 instance->plugin ().push_namespace (name.get ());
1110 instance->plugin ().pop_binding_level (name.get ());
1111
1112 /* Pop scope. */
1113 instance->leave_scope ();
1114
1115 /* Namespaces are non-cacheable types. */
1116 return GCC_TYPE_NONE;
1117}
1118
1119/* A helper function which knows how to convert most types from their
1120 gdb representation to the corresponding gcc form. This examines
1121 the TYPE and dispatches to the appropriate conversion function. It
1122 returns the gcc type.
1123
1124 If the type was defined in another type, NESTED_ACCESS should indicate the
1125 accessibility of this type. */
1126
1127static gcc_type
1128convert_type_cplus_basic (compile_cplus_instance *instance,
1129 struct type *type,
1130 enum gcc_cp_symbol_kind nested_access)
1131{
1132 /* If we are converting a qualified type, first convert the
1133 unqualified type and then apply the qualifiers. */
1134 if ((TYPE_INSTANCE_FLAGS (type) & (TYPE_INSTANCE_FLAG_CONST
1135 | TYPE_INSTANCE_FLAG_VOLATILE
1136 | TYPE_INSTANCE_FLAG_RESTRICT)) != 0)
1137 return compile_cplus_convert_qualified (instance, type);
1138
1139 switch (TYPE_CODE (type))
1140 {
1141 case TYPE_CODE_REF:
1142 case TYPE_CODE_RVALUE_REF:
1143 return compile_cplus_convert_reference (instance, type);
1144
1145 case TYPE_CODE_PTR:
1146 return compile_cplus_convert_pointer (instance, type);
1147
1148 case TYPE_CODE_ARRAY:
1149 return compile_cplus_convert_array (instance, type);
1150
1151 case TYPE_CODE_STRUCT:
1152 case TYPE_CODE_UNION:
1153 return
1154 compile_cplus_convert_struct_or_union (instance, type, nested_access);
1155
1156 case TYPE_CODE_ENUM:
1157 return compile_cplus_convert_enum (instance, type, nested_access);
1158
1159 case TYPE_CODE_FUNC:
1160 return compile_cplus_convert_func (instance, type, false);
1161
1162 case TYPE_CODE_METHOD:
1163 return
1164 compile_cplus_convert_method (instance, TYPE_SELF_TYPE (type), type);
1165
1166 case TYPE_CODE_MEMBERPTR:
1167 case TYPE_CODE_METHODPTR:
1168 return compile_cplus_convert_memberptr (instance, type);
1169 break;
1170
1171 case TYPE_CODE_INT:
1172 return compile_cplus_convert_int (instance, type);
1173
1174 case TYPE_CODE_FLT:
1175 return compile_cplus_convert_float (instance, type);
1176
1177 case TYPE_CODE_VOID:
1178 return compile_cplus_convert_void (instance, type);
1179
1180 case TYPE_CODE_BOOL:
1181 return compile_cplus_convert_bool (instance, type);
1182
1183 case TYPE_CODE_COMPLEX:
1184 return compile_cplus_convert_complex (instance, type);
1185
1186 case TYPE_CODE_NAMESPACE:
1187 return compile_cplus_convert_namespace (instance, type);
1188
1189 case TYPE_CODE_TYPEDEF:
1190 return compile_cplus_convert_typedef (instance, type, nested_access);
1191
1192 default:
1193 break;
1194 }
1195
1196 std::string s = string_printf (_("unhandled TYPE_CODE %d"),
1197 TYPE_CODE (type));
1198
1199 return instance->plugin ().error (s.c_str ());
1200}
1201
1202gcc_type
1203compile_cplus_instance::convert_type (struct type *type,
1204 enum gcc_cp_symbol_kind nested_access)
1205{
1206 /* Check if TYPE has already been converted. */
1207 gcc_type result;
1208 if (get_cached_type (type, result))
1209 return result;
1210
1211 /* It is the first time this type has been seen -- convert it
1212 and cache it, if appropriate.. */
1213 result = convert_type_cplus_basic (this, type, nested_access);
1214 if (result != GCC_TYPE_NONE)
1215 insert_type (type, result);
1216 return result;
1217}
1218
1219void
1220compile_cplus_instance::gcc_cplus_enter_scope
1221 (void *datum, struct gcc_cp_context *gcc_context)
1222{
1223}
1224
1225void
1226compile_cplus_instance::gcc_cplus_leave_scope
1227 (void *datum, struct gcc_cp_context *gcc_context)
1228{
1229}
1230
1231\f
1232
1233/* Plug-in forwards. */
1234
1235/* C++ plug-in wrapper. */
1236
1237/* A result printer for plug-in calls that return a gcc_type or
1238 gcc_decl. */
1239
1240static void
1241compile_cplus_debug_output_1 (gcc_type arg)
1242{
1243 fprintf_unfiltered (gdb_stdlog, "%lld", arg);
1244}
1245
1246static void
1247compile_cplus_debug_output_1 (const char *arg)
1248{
1249 if (arg == nullptr)
1250 fputs_unfiltered ("NULL", gdb_stdlog);
1251 else
1252 fputs_unfiltered (arg, gdb_stdlog);
1253}
1254
1255static void
1256compile_cplus_debug_output ()
1257{
1258}
1259
1260template <typename T>
1261static void
1262compile_cplus_debug_output_1 (const T *arg)
1263{
1264}
1265
1266template <typename T, typename... Targs>
1267static void
1268compile_cplus_debug_output (T arg, Targs... Args)
1269{
1270 compile_cplus_debug_output_1 (arg);
1271 fputc_unfiltered (' ', gdb_stdlog);
1272 compile_cplus_debug_output (Args...);
1273}
1274
1275#define FORWARD(OP,...) m_context->cp_ops->OP(m_context, ##__VA_ARGS__)
1276#define OUTPUT_DEBUG_RESULT(R) \
1277 if (debug_compile_cplus_types) \
1278 { \
1279 fputs_unfiltered (": ", gdb_stdlog); \
1280 compile_cplus_debug_output (R); \
1281 fputc_unfiltered ('\n', gdb_stdlog); \
1282 } \
1283
1284#define GCC_METHOD0(R, N) \
1285 R gcc_cp_plugin::N () const \
1286 { \
1287 if (debug_compile_cplus_types) \
1288 compile_cplus_debug_output (STRINGIFY (N)); \
1289 auto result = FORWARD (N); \
1290 OUTPUT_DEBUG_RESULT (result); \
1291 return result; \
1292 }
1293#define GCC_METHOD1(R, N, A) \
1294 R gcc_cp_plugin::N (A a) const \
1295 { \
1296 if (debug_compile_cplus_types) \
1297 compile_cplus_debug_output (STRINGIFY (N), a); \
1298 auto result = FORWARD (N, a); \
1299 OUTPUT_DEBUG_RESULT (result); \
1300 return result; \
1301 }
1302#define GCC_METHOD2(R, N, A, B) \
1303 R gcc_cp_plugin::N (A a, B b) const \
1304 { \
1305 if (debug_compile_cplus_types) \
1306 compile_cplus_debug_output (STRINGIFY (N), a, b); \
1307 auto result = FORWARD (N, a, b); \
1308 OUTPUT_DEBUG_RESULT (result); \
1309 return result; \
1310 }
1311#define GCC_METHOD3(R, N, A, B, C) \
1312 R gcc_cp_plugin::N (A a, B b, C c) const \
1313 { \
1314 if (debug_compile_cplus_types) \
1315 compile_cplus_debug_output (STRINGIFY (N), a, b, c); \
1316 auto result = FORWARD (N, a, b, c); \
1317 OUTPUT_DEBUG_RESULT (result); \
1318 return result; \
1319 }
1320#define GCC_METHOD4(R, N, A, B, C, D) \
1321 R gcc_cp_plugin::N (A a, B b, C c, D d) const \
1322 { \
1323 if (debug_compile_cplus_types) \
1324 compile_cplus_debug_output (STRINGIFY (N), a, b, c, d); \
1325 auto result = FORWARD (N, a, b, c, d); \
1326 OUTPUT_DEBUG_RESULT (result); \
1327 return result; \
1328 }
1329#define GCC_METHOD5(R, N, A, B, C, D, E) \
1330 R gcc_cp_plugin::N (A a, B b, C c, D d, E e) const \
1331 { \
1332 if (debug_compile_cplus_types) \
1333 compile_cplus_debug_output (STRINGIFY (N), a, b, c, d, e); \
1334 auto result = FORWARD (N, a, b, c, d, e); \
1335 OUTPUT_DEBUG_RESULT (result); \
1336 return result; \
1337 }
1338#define GCC_METHOD7(R, N, A, B, C, D, E, F, G) \
1339 R gcc_cp_plugin::N (A a, B b, C c, D d, E e, F f, G g) const \
1340 { \
1341 if (debug_compile_cplus_types) \
1342 compile_cplus_debug_output (STRINGIFY (N), a, b, c, d, e, f, g); \
1343 auto result = FORWARD (N, a, b, c, d, e, f, g); \
1344 OUTPUT_DEBUG_RESULT (result); \
1345 return result; \
1346 }
1347
1348#include "gcc-cp-fe.def"
1349
1350#undef GCC_METHOD0
1351#undef GCC_METHOD1
1352#undef GCC_METHOD2
1353#undef GCC_METHOD3
1354#undef GCC_METHOD4
1355#undef GCC_METHOD5
1356#undef GCC_METHOD7
1357#undef FORWARD
1358#undef OUTPUT_DEBUG_RESULT
1359
1360gcc_expr
1361gcc_cp_plugin::build_decl (const char *debug_decltype, const char *name,
1362 enum gcc_cp_symbol_kind sym_kind, gcc_type sym_type,
1363 const char *substitution_name, gcc_address address,
1364 const char *filename, unsigned int line_number)
1365{
1366 if (debug_compile_cplus_types)
1367 fprintf_unfiltered (gdb_stdlog, "<%s> ", debug_decltype);
1368
1369 return build_decl (name, sym_kind, sym_type, substitution_name,
1370 address, filename, line_number);
1371}
1372
1373gcc_type
1374gcc_cp_plugin::start_class_type (const char *debug_name, gcc_decl typedecl,
1375 const struct gcc_vbase_array *base_classes,
1376 const char *filename, unsigned int line_number)
1377{
1378 if (debug_compile_cplus_types)
1379 fprintf_unfiltered (gdb_stdlog, "<%s> ", debug_name);
1380
1381 return start_class_type (typedecl, base_classes, filename, line_number);
1382}
1383
1384int
1385gcc_cp_plugin::finish_class_type (const char *debug_name,
1386 unsigned long size_in_bytes)
1387{
1388 if (debug_compile_cplus_types)
1389 fprintf_unfiltered (gdb_stdlog, "<%s> ", debug_name);
1390
1391 return finish_class_type (size_in_bytes);
1392}
1393
1394int
1395gcc_cp_plugin::pop_binding_level (const char *debug_name)
1396{
1397 if (debug_compile_cplus_types)
1398 fprintf_unfiltered (gdb_stdlog, "<%s> ", debug_name);
1399
1400 return pop_binding_level ();
1401}
1402
1403void
1404_initialize_compile_cplus_types ()
1405{
1406 add_setshow_boolean_cmd ("compile-cplus-types", no_class,
1407 &debug_compile_cplus_types, _("\
1408Set debugging of C++ compile type conversion."), _("\
1409Show debugging of C++ compile type conversion."), _("\
1410When enabled debugging messages are printed during C++ type conversion for\n\
1411the compile commands."),
1412 nullptr,
1413 nullptr,
1414 &setdebuglist,
1415 &showdebuglist);
1416
1417 add_setshow_boolean_cmd ("compile-cplus-scopes", no_class,
1418 &debug_compile_cplus_scopes, _("\
1419Set debugging of C++ compile scopes."), _("\
1420Show debugging of C++ compile scopes."), _("\
1421When enabled debugging messages are printed about definition scopes during\n\
1422C++ type conversion for the compile commands."),
1423 nullptr,
1424 nullptr,
1425 &setdebuglist,
1426 &showdebuglist);
1427}
GDB Binutils - Deliverables
This page took 0.07343 seconds and 4 git commands to generate.