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 [There are a few exceptions, but the caller is still responsible for 167 freeing the resulting pointer.] 168 A pointer to this buffer is returned, or NULL if symbol isn't a 169 mangled Go symbol. 170 The caller is responsible for freeing the result. 171 172 *METHOD_TYPE_IS_POINTERP is set to a boolean indicating if 173 the method type is a pointer. 174 175 There may be value in returning the outer container, 176 i.e., "net" in the above example, but for now it's not needed. 177 Plus it's currently not straightforward to compute, 178 it comes from -fgo-prefix, and there's no algorithm to compute it. 179 180 If we ever need to unpack the method type, this routine should work 181 for that too. */ 182 183 static char * 184 unpack_mangled_go_symbol (const char *mangled_name, 185 const char **packagep, 186 const char **objectp, 187 const char **method_type_packagep, 188 const char **method_type_objectp, 189 int *method_type_is_pointerp) 190 { 191 char *buf; 192 char *p; 193 int len = strlen (mangled_name); 194 /* Pointer to last digit in "N<digit(s)>_". */ 195 char *saw_digit; 196 /* Pointer to "N" if valid "N<digit(s)>_" found. */ 197 char *method_type; 198 /* Pointer to the first '.'. */ 199 const char *first_dot; 200 /* Pointer to the last '.'. */ 201 const char *last_dot; 202 /* Non-zero if we saw a pointer indicator. */ 203 int saw_pointer; 204 205 *packagep = *objectp = NULL; 206 *method_type_packagep = *method_type_objectp = NULL; 207 *method_type_is_pointerp = 0; 208 209 /* main.init is mangled specially. */ 210 if (strcmp (mangled_name, "__go_init_main") == 0) 211 { 212 char *package = xstrdup ("main"); 213 214 *packagep = package; 215 *objectp = "init"; 216 return package; 217 } 218 219 /* main.main is mangled specially (missing prefix). */ 220 if (strcmp (mangled_name, "main.main") == 0) 221 { 222 char *package = xstrdup ("main"); 223 224 *packagep = package; 225 *objectp = "main"; 226 return package; 227 } 228 229 /* We may get passed, e.g., "main.T.Foo", which is *not* mangled. 230 Alas it looks exactly like "prefix.package.object." 231 To cope for now we only recognize the following prefixes: 232 233 go: the default 234 libgo_.*: used by gccgo's runtime 235 236 Thus we don't support -fgo-prefix (except as used by the runtime). */ 237 if (!startswith (mangled_name, "go.") 238 && !startswith (mangled_name, "libgo_")) 239 return NULL; 240 241 /* Quick check for whether a search may be fruitful. */ 242 /* Ignore anything with @plt, etc. in it. */ 243 if (strchr (mangled_name, '@') != NULL) 244 return NULL; 245 /* It must have at least two dots. */ 246 first_dot = strchr (mangled_name, '.'); 247 if (first_dot == NULL) 248 return NULL; 249 /* Treat "foo.bar" as unmangled. It can collide with lots of other 250 languages and it's not clear what the consequences are. 251 And except for main.main, all gccgo symbols are at least 252 prefix.package.object. */ 253 last_dot = strrchr (mangled_name, '.'); 254 if (last_dot == first_dot) 255 return NULL; 256 257 /* More quick checks. */ 258 if (last_dot[1] == '\0' /* foo. */ 259 || last_dot[-1] == '.') /* foo..bar */ 260 return NULL; 261 262 /* At this point we've decided we have a mangled Go symbol. */ 263 264 buf = xstrdup (mangled_name); 265 266 /* Search backwards looking for "N<digit(s)>". */ 267 p = buf + len; 268 saw_digit = method_type = NULL; 269 saw_pointer = 0; 270 while (p > buf) 271 { 272 int current = *(const unsigned char *) --p; 273 int current_is_digit = isdigit (current); 274 275 if (saw_digit) 276 { 277 if (current_is_digit) 278 continue; 279 if (current == 'N' 280 && ((p > buf && p[-1] == '.') 281 || (p > buf + 1 && p[-1] == 'p' && p[-2] == '.'))) 282 { 283 if (atoi (p + 1) == strlen (saw_digit + 2)) 284 { 285 if (p[-1] == '.') 286 method_type = p - 1; 287 else 288 { 289 gdb_assert (p[-1] == 'p'); 290 saw_pointer = 1; 291 method_type = p - 2; 292 } 293 break; 294 } 295 } 296 /* Not what we're looking for, reset and keep looking. */ 297 saw_digit = NULL; 298 saw_pointer = 0; 299 continue; 300 } 301 if (current_is_digit && p[1] == '_') 302 { 303 /* Possible start of method "this" [sic] type. */ 304 saw_digit = p; 305 continue; 306 } 307 } 308 309 if (method_type != NULL 310 /* Ensure not something like "..foo". */ 311 && (method_type > buf && method_type[-1] != '.')) 312 { 313 unpack_package_and_object (saw_digit + 2, 314 method_type_packagep, method_type_objectp); 315 *method_type = '\0'; 316 *method_type_is_pointerp = saw_pointer; 317 } 318 319 unpack_package_and_object (buf, packagep, objectp); 320 return buf; 321 } 322 323 /* Implements the la_demangle language_defn routine for language Go. 324 325 N.B. This may get passed *any* symbol, including symbols from other 326 languages and including symbols that are already demangled. 327 Both of these situations are kinda unfortunate, but that's how things 328 are today. 329 330 N.B. This currently only supports gccgo's mangling. 331 332 N.B. gccgo's mangling needs, I think, changing. 333 This demangler can't work in all situations, 334 thus not too much effort is currently put into it. */ 335 336 gdb::unique_xmalloc_ptr<char> 337 go_language::demangle_symbol (const char *mangled_name, int options) const 338 { 339 const char *package_name; 340 const char *object_name; 341 const char *method_type_package_name; 342 const char *method_type_object_name; 343 int method_type_is_pointer; 344 345 if (mangled_name == NULL) 346 return NULL; 347 348 gdb::unique_xmalloc_ptr<char> name_buf 349 (unpack_mangled_go_symbol (mangled_name, 350 &package_name, &object_name, 351 &method_type_package_name, 352 &method_type_object_name, 353 &method_type_is_pointer)); 354 if (name_buf == NULL) 355 return NULL; 356 357 auto_obstack tempbuf; 358 359 /* Print methods as they appear in "method expressions". */ 360 if (method_type_package_name != NULL) 361 { 362 /* FIXME: Seems like we should include package_name here somewhere. */ 363 if (method_type_is_pointer) 364 obstack_grow_str (&tempbuf, "(*"); 365 obstack_grow_str (&tempbuf, method_type_package_name); 366 obstack_grow_str (&tempbuf, "."); 367 obstack_grow_str (&tempbuf, method_type_object_name); 368 if (method_type_is_pointer) 369 obstack_grow_str (&tempbuf, ")"); 370 obstack_grow_str (&tempbuf, "."); 371 obstack_grow_str (&tempbuf, object_name); 372 } 373 else 374 { 375 obstack_grow_str (&tempbuf, package_name); 376 obstack_grow_str (&tempbuf, "."); 377 obstack_grow_str (&tempbuf, object_name); 378 } 379 obstack_grow_str0 (&tempbuf, ""); 380 381 return make_unique_xstrdup ((const char *) obstack_finish (&tempbuf)); 382 } 383 384 /* Given a Go symbol, return its package or NULL if unknown. 385 Space for the result is malloc'd, caller must free. */ 386 387 char * 388 go_symbol_package_name (const struct symbol *sym) 389 { 390 const char *mangled_name = sym->linkage_name (); 391 const char *package_name; 392 const char *object_name; 393 const char *method_type_package_name; 394 const char *method_type_object_name; 395 int method_type_is_pointer; 396 char *name_buf; 397 char *result; 398 399 gdb_assert (sym->language () == language_go); 400 name_buf = unpack_mangled_go_symbol (mangled_name, 401 &package_name, &object_name, 402 &method_type_package_name, 403 &method_type_object_name, 404 &method_type_is_pointer); 405 /* Some Go symbols don't have mangled form we interpret (yet). */ 406 if (name_buf == NULL) 407 return NULL; 408 result = xstrdup (package_name); 409 xfree (name_buf); 410 return result; 411 } 412 413 /* Return the package that BLOCK is in, or NULL if there isn't one. 414 Space for the result is malloc'd, caller must free. */ 415 416 char * 417 go_block_package_name (const struct block *block) 418 { 419 while (block != NULL) 420 { 421 struct symbol *function = block->function (); 422 423 if (function != NULL) 424 { 425 char *package_name = go_symbol_package_name (function); 426 427 if (package_name != NULL) 428 return package_name; 429 430 /* Stop looking if we find a function without a package name. 431 We're most likely outside of Go and thus the concept of the 432 "current" package is gone. */ 433 return NULL; 434 } 435 436 block = block->superblock (); 437 } 438 439 return NULL; 440 } 441 442 /* See language.h. */ 443 444 void 445 go_language::language_arch_info (struct gdbarch *gdbarch, 446 struct language_arch_info *lai) const 447 { 448 const struct builtin_go_type *builtin = builtin_go_type (gdbarch); 449 450 /* Helper function to allow shorter lines below. */ 451 auto add = [&] (struct type * t) -> struct type * 452 { 453 lai->add_primitive_type (t); 454 return t; 455 }; 456 457 add (builtin->builtin_void); 458 add (builtin->builtin_char); 459 add (builtin->builtin_bool); 460 add (builtin->builtin_int); 461 add (builtin->builtin_uint); 462 add (builtin->builtin_uintptr); 463 add (builtin->builtin_int8); 464 add (builtin->builtin_int16); 465 add (builtin->builtin_int32); 466 add (builtin->builtin_int64); 467 add (builtin->builtin_uint8); 468 add (builtin->builtin_uint16); 469 add (builtin->builtin_uint32); 470 add (builtin->builtin_uint64); 471 add (builtin->builtin_float32); 472 add (builtin->builtin_float64); 473 add (builtin->builtin_complex64); 474 add (builtin->builtin_complex128); 475 476 lai->set_string_char_type (builtin->builtin_char); 477 lai->set_bool_type (builtin->builtin_bool, "bool"); 478 } 479 480 /* Single instance of the Go language class. */ 481 482 static go_language go_language_defn; 483 484 static struct builtin_go_type * 485 build_go_types (struct gdbarch *gdbarch) 486 { 487 struct builtin_go_type *builtin_go_type = new struct builtin_go_type; 488 489 builtin_go_type->builtin_void 490 = arch_type (gdbarch, TYPE_CODE_VOID, TARGET_CHAR_BIT, "void"); 491 builtin_go_type->builtin_char 492 = arch_character_type (gdbarch, 8, 1, "char"); 493 builtin_go_type->builtin_bool 494 = arch_boolean_type (gdbarch, 8, 0, "bool"); 495 builtin_go_type->builtin_int 496 = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), 0, "int"); 497 builtin_go_type->builtin_uint 498 = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), 1, "uint"); 499 builtin_go_type->builtin_uintptr 500 = arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 1, "uintptr"); 501 builtin_go_type->builtin_int8 502 = arch_integer_type (gdbarch, 8, 0, "int8"); 503 builtin_go_type->builtin_int16 504 = arch_integer_type (gdbarch, 16, 0, "int16"); 505 builtin_go_type->builtin_int32 506 = arch_integer_type (gdbarch, 32, 0, "int32"); 507 builtin_go_type->builtin_int64 508 = arch_integer_type (gdbarch, 64, 0, "int64"); 509 builtin_go_type->builtin_uint8 510 = arch_integer_type (gdbarch, 8, 1, "uint8"); 511 builtin_go_type->builtin_uint16 512 = arch_integer_type (gdbarch, 16, 1, "uint16"); 513 builtin_go_type->builtin_uint32 514 = arch_integer_type (gdbarch, 32, 1, "uint32"); 515 builtin_go_type->builtin_uint64 516 = arch_integer_type (gdbarch, 64, 1, "uint64"); 517 builtin_go_type->builtin_float32 518 = arch_float_type (gdbarch, 32, "float32", floatformats_ieee_single); 519 builtin_go_type->builtin_float64 520 = arch_float_type (gdbarch, 64, "float64", floatformats_ieee_double); 521 builtin_go_type->builtin_complex64 522 = init_complex_type ("complex64", builtin_go_type->builtin_float32); 523 builtin_go_type->builtin_complex128 524 = init_complex_type ("complex128", builtin_go_type->builtin_float64); 525 526 return builtin_go_type; 527 } 528 529 static const registry<gdbarch>::key<struct builtin_go_type> go_type_data; 530 531 const struct builtin_go_type * 532 builtin_go_type (struct gdbarch *gdbarch) 533 { 534 struct builtin_go_type *result = go_type_data.get (gdbarch); 535 if (result == nullptr) 536 { 537 result = build_go_types (gdbarch); 538 go_type_data.set (gdbarch, result); 539 } 540 541 return result; 542 } 543