gdb/compile/compile-cplus-types.c

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