gdb/go-lang.c

   1 /* Go language support routines for GDB, the GNU debugger.
   2
   3    Copyright (C) 2012-2023 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 /* TODO:
  21    - split stacks
  22    - printing of native types
  23    - goroutines
  24    - lots more
  25    - gccgo mangling needs redoing
  26      It's too hard, for example, to know whether one is looking at a mangled
  27      Go symbol or not, and their are ambiguities, e.g., the demangler may
  28      get passed *any* symbol, including symbols from other languages
  29      and including symbols that are already demangled.
  30      One thought is to at least add an _G prefix.
  31    - 6g mangling isn't supported yet
  32 */
  33
  34 #include "defs.h"
  35 #include "gdbsupport/gdb_obstack.h"
  36 #include "block.h"
  37 #include "symtab.h"
  38 #include "language.h"
  39 #include "varobj.h"
  40 #include "go-lang.h"
  41 #include "c-lang.h"
  42 #include "parser-defs.h"
  43 #include "gdbarch.h"
  44
  45 #include <ctype.h>
  46
  47 /* The main function in the main package.  */
  48 static const char GO_MAIN_MAIN[] = "main.main";
  49
  50 /* Function returning the special symbol name used by Go for the main
  51    procedure in the main program if it is found in minimal symbol list.
  52    This function tries to find minimal symbols so that it finds them even
  53    if the program was compiled without debugging information.  */
  54
  55 const char *
  56 go_main_name (void)
  57 {
  58   struct bound_minimal_symbol msym;
  59
  60   msym = lookup_minimal_symbol (GO_MAIN_MAIN, NULL, NULL);
  61   if (msym.minsym != NULL)
  62     return GO_MAIN_MAIN;
  63
  64   /* No known entry procedure found, the main program is probably not Go.  */
  65   return NULL;
  66 }
  67
  68 /* Return non-zero if TYPE is a gccgo string.
  69    We assume CHECK_TYPEDEF has already been done.  */
  70
  71 static int
  72 gccgo_string_p (struct type *type)
  73 {
  74   /* gccgo strings don't necessarily have a name we can use.  */
  75
  76   if (type->num_fields () == 2)
  77     {
  78       struct type *type0 = type->field (0).type ();
  79       struct type *type1 = type->field (1).type ();
  80
  81       type0 = check_typedef (type0);
  82       type1 = check_typedef (type1);
  83
  84       if (type0->code () == TYPE_CODE_PTR
  85           && strcmp (type->field (0).name (), "__data") == 0
  86           && type1->code () == TYPE_CODE_INT
  87           && strcmp (type->field (1).name (), "__length") == 0)
  88         {
  89           struct type *target_type = type0->target_type ();
  90
  91           target_type = check_typedef (target_type);
  92
  93           if (target_type->code () == TYPE_CODE_INT
  94               && target_type->length () == 1
  95               && strcmp (target_type->name (), "uint8") == 0)
  96             return 1;
  97         }
  98     }
  99
 100   return 0;
 101 }
 102
 103 /* Return non-zero if TYPE is a 6g string.
 104    We assume CHECK_TYPEDEF has already been done.  */
 105
 106 static int
 107 sixg_string_p (struct type *type)
 108 {
 109   if (type->num_fields () == 2
 110       && type->name () != NULL
 111       && strcmp (type->name (), "string") == 0)
 112     return 1;
 113
 114   return 0;
 115 }
 116
 117 /* Classify the kind of Go object that TYPE is.
 118    TYPE is a TYPE_CODE_STRUCT, used to represent a Go object.  */
 119
 120 enum go_type
 121 go_classify_struct_type (struct type *type)
 122 {
 123   type = check_typedef (type);
 124
 125   /* Recognize strings as they're useful to be able to print without
 126      pretty-printers.  */
 127   if (gccgo_string_p (type)
 128       || sixg_string_p (type))
 129     return GO_TYPE_STRING;
 130
 131   return GO_TYPE_NONE;
 132 }
 133
 134 /* Subroutine of unpack_mangled_go_symbol to simplify it.
 135    Given "[foo.]bar.baz", store "bar" in *PACKAGEP and "baz" in *OBJECTP.
 136    We stomp on the last '.' to nul-terminate "bar".
 137    The caller is responsible for memory management.  */
 138
 139 static void
 140 unpack_package_and_object (char *buf,
 141                            const char **packagep, const char **objectp)
 142 {
 143   char *last_dot;
 144
 145   last_dot = strrchr (buf, '.');
 146   gdb_assert (last_dot != NULL);
 147   *objectp = last_dot + 1;
 148   *last_dot = '\0';
 149   last_dot = strrchr (buf, '.');
 150   if (last_dot != NULL)
 151     *packagep = last_dot + 1;
 152   else
 153     *packagep = buf;
 154 }
 155
 156 /* Given a mangled Go symbol, find its package name, object name, and
 157    method type (if present).
 158    E.g., for "libgo_net.textproto.String.N33_libgo_net.textproto.ProtocolError"
 159    *PACKAGEP = "textproto"
 160    *OBJECTP = "String"
 161    *METHOD_TYPE_PACKAGEP = "textproto"
 162    *METHOD_TYPE_OBJECTP = "ProtocolError"
 163
 164    Space for the resulting strings is malloc'd in one buffer.
 165    PACKAGEP,OBJECTP,METHOD_TYPE* will (typically) point into this buffer.
 166    A pointer to this buffer is returned, or NULL if symbol isn't a
 167    mangled Go symbol.
 168
 169    *METHOD_TYPE_IS_POINTERP is set to a boolean indicating if
 170    the method type is a pointer.
 171
 172    There may be value in returning the outer container,
 173    i.e., "net" in the above example, but for now it's not needed.
 174    Plus it's currently not straightforward to compute,
 175    it comes from -fgo-prefix, and there's no algorithm to compute it.
 176
 177    If we ever need to unpack the method type, this routine should work
 178    for that too.  */
 179
 180 static gdb::unique_xmalloc_ptr<char>
 181 unpack_mangled_go_symbol (const char *mangled_name,
 182                           const char **packagep,
 183                           const char **objectp,
 184                           const char **method_type_packagep,
 185                           const char **method_type_objectp,
 186                           int *method_type_is_pointerp)
 187 {
 188   char *buf;
 189   char *p;
 190   int len = strlen (mangled_name);
 191   /* Pointer to last digit in "N<digit(s)>_".  */
 192   char *saw_digit;
 193   /* Pointer to "N" if valid "N<digit(s)>_" found.  */
 194   char *method_type;
 195   /* Pointer to the first '.'.  */
 196   const char *first_dot;
 197   /* Pointer to the last '.'.  */
 198   const char *last_dot;
 199   /* Non-zero if we saw a pointer indicator.  */
 200   int saw_pointer;
 201
 202   *packagep = *objectp = NULL;
 203   *method_type_packagep = *method_type_objectp = NULL;
 204   *method_type_is_pointerp = 0;
 205
 206   /* main.init is mangled specially.  */
 207   if (strcmp (mangled_name, "__go_init_main") == 0)
 208     {
 209       gdb::unique_xmalloc_ptr<char> package
 210         = make_unique_xstrdup ("main");
 211
 212       *packagep = package.get ();
 213       *objectp = "init";
 214       return package;
 215     }
 216
 217   /* main.main is mangled specially (missing prefix).  */
 218   if (strcmp (mangled_name, "main.main") == 0)
 219     {
 220       gdb::unique_xmalloc_ptr<char> package
 221         = make_unique_xstrdup ("main");
 222
 223       *packagep = package.get ();
 224       *objectp = "main";
 225       return package;
 226     }
 227
 228   /* We may get passed, e.g., "main.T.Foo", which is *not* mangled.
 229      Alas it looks exactly like "prefix.package.object."
 230      To cope for now we only recognize the following prefixes:
 231
 232      go: the default
 233      libgo_.*: used by gccgo's runtime
 234
 235      Thus we don't support -fgo-prefix (except as used by the runtime).  */
 236   bool v3;
 237   if (startswith (mangled_name, "go_0"))
 238     /* V3 mangling detected, see
 239        https://go-review.googlesource.com/c/gofrontend/+/271726 .  */
 240     v3 = true;
 241   else if (startswith (mangled_name, "go.")
 242            || startswith (mangled_name, "libgo_"))
 243     v3 = false;
 244   else
 245     return NULL;
 246
 247   /* Quick check for whether a search may be fruitful.  */
 248   /* Ignore anything with @plt, etc. in it.  */
 249   if (strchr (mangled_name, '@') != NULL)
 250     return NULL;
 251
 252   /* It must have at least two dots.  */
 253   if (v3)
 254     first_dot = strchr (mangled_name, '0');
 255   else
 256     first_dot = strchr (mangled_name, '.');
 257
 258   if (first_dot == NULL)
 259     return NULL;
 260   /* Treat "foo.bar" as unmangled.  It can collide with lots of other
 261      languages and it's not clear what the consequences are.
 262      And except for main.main, all gccgo symbols are at least
 263      prefix.package.object.  */
 264   last_dot = strrchr (mangled_name, '.');
 265   if (last_dot == first_dot)
 266     return NULL;
 267
 268   /* More quick checks.  */
 269   if (last_dot[1] == '\0' /* foo. */
 270       || last_dot[-1] == '.') /* foo..bar */
 271     return NULL;
 272
 273   /* At this point we've decided we have a mangled Go symbol.  */
 274
 275   gdb::unique_xmalloc_ptr<char> result = make_unique_xstrdup (mangled_name);
 276   buf = result.get ();
 277
 278   if (v3)
 279     {
 280       /* Replace "go_0" with "\0go.".  */
 281       buf[0] = '\0';
 282       buf[1] = 'g';
 283       buf[2] = 'o';
 284       buf[3] = '.';
 285
 286       /* Skip the '\0'.  */
 287       buf++;
 288     }
 289
 290   /* Search backwards looking for "N<digit(s)>".  */
 291   p = buf + len;
 292   saw_digit = method_type = NULL;
 293   saw_pointer = 0;
 294   while (p > buf)
 295     {
 296       int current = *(const unsigned char *) --p;
 297       int current_is_digit = isdigit (current);
 298
 299       if (saw_digit)
 300         {
 301           if (current_is_digit)
 302             continue;
 303           if (current == 'N'
 304               && ((p > buf && p[-1] == '.')
 305                   || (p > buf + 1 && p[-1] == 'p' && p[-2] == '.')))
 306             {
 307               if (atoi (p + 1) == strlen (saw_digit + 2))
 308                 {
 309                   if (p[-1] == '.')
 310                     method_type = p - 1;
 311                   else
 312                     {
 313                       gdb_assert (p[-1] == 'p');
 314                       saw_pointer = 1;
 315                       method_type = p - 2;
 316                     }
 317                   break;
 318                 }
 319             }
 320           /* Not what we're looking for, reset and keep looking.  */
 321           saw_digit = NULL;
 322           saw_pointer = 0;
 323           continue;
 324         }
 325       if (current_is_digit && p[1] == '_')
 326         {
 327           /* Possible start of method "this" [sic] type.  */
 328           saw_digit = p;
 329           continue;
 330         }
 331     }
 332
 333   if (method_type != NULL
 334       /* Ensure not something like "..foo".  */
 335       && (method_type > buf && method_type[-1] != '.'))
 336     {
 337       unpack_package_and_object (saw_digit + 2,
 338                                  method_type_packagep, method_type_objectp);
 339       *method_type = '\0';
 340       *method_type_is_pointerp = saw_pointer;
 341     }
 342
 343   unpack_package_and_object (buf, packagep, objectp);
 344   return result;
 345 }
 346
 347 /* Implements the la_demangle language_defn routine for language Go.
 348
 349    N.B. This may get passed *any* symbol, including symbols from other
 350    languages and including symbols that are already demangled.
 351    Both of these situations are kinda unfortunate, but that's how things
 352    are today.
 353
 354    N.B. This currently only supports gccgo's mangling.
 355
 356    N.B. gccgo's mangling needs, I think, changing.
 357    This demangler can't work in all situations,
 358    thus not too much effort is currently put into it.  */
 359
 360 gdb::unique_xmalloc_ptr<char>
 361 go_language::demangle_symbol (const char *mangled_name, int options) const
 362 {
 363   const char *package_name;
 364   const char *object_name;
 365   const char *method_type_package_name;
 366   const char *method_type_object_name;
 367   int method_type_is_pointer;
 368
 369   if (mangled_name == NULL)
 370     return NULL;
 371
 372   gdb::unique_xmalloc_ptr<char> name_buf
 373     (unpack_mangled_go_symbol (mangled_name,
 374                                &package_name, &object_name,
 375                                &method_type_package_name,
 376                                &method_type_object_name,
 377                                &method_type_is_pointer));
 378   if (name_buf == NULL)
 379     return NULL;
 380
 381   auto_obstack tempbuf;
 382
 383   /* Print methods as they appear in "method expressions".  */
 384   if (method_type_package_name != NULL)
 385     {
 386       /* FIXME: Seems like we should include package_name here somewhere.  */
 387       if (method_type_is_pointer)
 388           obstack_grow_str (&tempbuf, "(*");
 389       obstack_grow_str (&tempbuf, method_type_package_name);
 390       obstack_grow_str (&tempbuf, ".");
 391       obstack_grow_str (&tempbuf, method_type_object_name);
 392       if (method_type_is_pointer)
 393         obstack_grow_str (&tempbuf, ")");
 394       obstack_grow_str (&tempbuf, ".");
 395       obstack_grow_str (&tempbuf, object_name);
 396     }
 397   else
 398     {
 399       obstack_grow_str (&tempbuf, package_name);
 400       obstack_grow_str (&tempbuf, ".");
 401       obstack_grow_str (&tempbuf, object_name);
 402     }
 403   obstack_grow_str0 (&tempbuf, "");
 404
 405   return make_unique_xstrdup ((const char *) obstack_finish (&tempbuf));
 406 }
 407
 408 /* See go-lang.h.  */
 409
 410 gdb::unique_xmalloc_ptr<char>
 411 go_symbol_package_name (const struct symbol *sym)
 412 {
 413   const char *mangled_name = sym->linkage_name ();
 414   const char *package_name;
 415   const char *object_name;
 416   const char *method_type_package_name;
 417   const char *method_type_object_name;
 418   int method_type_is_pointer;
 419   gdb::unique_xmalloc_ptr<char> name_buf;
 420
 421   if (sym->language () != language_go)
 422     return nullptr;
 423   name_buf = unpack_mangled_go_symbol (mangled_name,
 424                                        &package_name, &object_name,
 425                                        &method_type_package_name,
 426                                        &method_type_object_name,
 427                                        &method_type_is_pointer);
 428   /* Some Go symbols don't have mangled form we interpret (yet).  */
 429   if (name_buf == NULL)
 430     return NULL;
 431   return make_unique_xstrdup (package_name);
 432 }
 433
 434 /* See go-lang.h.  */
 435
 436 gdb::unique_xmalloc_ptr<char>
 437 go_block_package_name (const struct block *block)
 438 {
 439   while (block != NULL)
 440     {
 441       struct symbol *function = block->function ();
 442
 443       if (function != NULL)
 444         {
 445           gdb::unique_xmalloc_ptr<char> package_name
 446             = go_symbol_package_name (function);
 447
 448           if (package_name != NULL)
 449             return package_name;
 450
 451           /* Stop looking if we find a function without a package name.
 452              We're most likely outside of Go and thus the concept of the
 453              "current" package is gone.  */
 454           return NULL;
 455         }
 456
 457       block = block->superblock ();
 458     }
 459
 460   return NULL;
 461 }
 462
 463 /* See language.h.  */
 464
 465 void
 466 go_language::language_arch_info (struct gdbarch *gdbarch,
 467                                  struct language_arch_info *lai) const
 468 {
 469   const struct builtin_go_type *builtin = builtin_go_type (gdbarch);
 470
 471   /* Helper function to allow shorter lines below.  */
 472   auto add  = [&] (struct type * t) -> struct type *
 473   {
 474     lai->add_primitive_type (t);
 475     return t;
 476   };
 477
 478   add (builtin->builtin_void);
 479   add (builtin->builtin_char);
 480   add (builtin->builtin_bool);
 481   add (builtin->builtin_int);
 482   add (builtin->builtin_uint);
 483   add (builtin->builtin_uintptr);
 484   add (builtin->builtin_int8);
 485   add (builtin->builtin_int16);
 486   add (builtin->builtin_int32);
 487   add (builtin->builtin_int64);
 488   add (builtin->builtin_uint8);
 489   add (builtin->builtin_uint16);
 490   add (builtin->builtin_uint32);
 491   add (builtin->builtin_uint64);
 492   add (builtin->builtin_float32);
 493   add (builtin->builtin_float64);
 494   add (builtin->builtin_complex64);
 495   add (builtin->builtin_complex128);
 496
 497   lai->set_string_char_type (builtin->builtin_char);
 498   lai->set_bool_type (builtin->builtin_bool, "bool");
 499 }
 500
 501 /* Single instance of the Go language class.  */
 502
 503 static go_language go_language_defn;
 504
 505 static struct builtin_go_type *
 506 build_go_types (struct gdbarch *gdbarch)
 507 {
 508   struct builtin_go_type *builtin_go_type = new struct builtin_go_type;
 509
 510   type_allocator alloc (gdbarch);
 511   builtin_go_type->builtin_void = builtin_type (gdbarch)->builtin_void;
 512   builtin_go_type->builtin_char
 513     = init_character_type (alloc, 8, 1, "char");
 514   builtin_go_type->builtin_bool
 515     = init_boolean_type (alloc, 8, 0, "bool");
 516   builtin_go_type->builtin_int
 517     = init_integer_type (alloc, gdbarch_int_bit (gdbarch), 0, "int");
 518   builtin_go_type->builtin_uint
 519     = init_integer_type (alloc, gdbarch_int_bit (gdbarch), 1, "uint");
 520   builtin_go_type->builtin_uintptr
 521     = init_integer_type (alloc, gdbarch_ptr_bit (gdbarch), 1, "uintptr");
 522   builtin_go_type->builtin_int8
 523     = init_integer_type (alloc, 8, 0, "int8");
 524   builtin_go_type->builtin_int16
 525     = init_integer_type (alloc, 16, 0, "int16");
 526   builtin_go_type->builtin_int32
 527     = init_integer_type (alloc, 32, 0, "int32");
 528   builtin_go_type->builtin_int64
 529     = init_integer_type (alloc, 64, 0, "int64");
 530   builtin_go_type->builtin_uint8
 531     = init_integer_type (alloc, 8, 1, "uint8");
 532   builtin_go_type->builtin_uint16
 533     = init_integer_type (alloc, 16, 1, "uint16");
 534   builtin_go_type->builtin_uint32
 535     = init_integer_type (alloc, 32, 1, "uint32");
 536   builtin_go_type->builtin_uint64
 537     = init_integer_type (alloc, 64, 1, "uint64");
 538   builtin_go_type->builtin_float32
 539     = init_float_type (alloc, 32, "float32", floatformats_ieee_single);
 540   builtin_go_type->builtin_float64
 541     = init_float_type (alloc, 64, "float64", floatformats_ieee_double);
 542   builtin_go_type->builtin_complex64
 543     = init_complex_type ("complex64", builtin_go_type->builtin_float32);
 544   builtin_go_type->builtin_complex128
 545     = init_complex_type ("complex128", builtin_go_type->builtin_float64);
 546
 547   return builtin_go_type;
 548 }
 549
 550 static const registry<gdbarch>::key<struct builtin_go_type> go_type_data;
 551
 552 const struct builtin_go_type *
 553 builtin_go_type (struct gdbarch *gdbarch)
 554 {
 555   struct builtin_go_type *result = go_type_data.get (gdbarch);
 556   if (result == nullptr)
 557     {
 558       result = build_go_types (gdbarch);
 559       go_type_data.set (gdbarch, result);
 560     }
 561
 562   return result;
 563 }