gdb/compile/compile-cplus-types.c

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