GDB (xrefs)
Loading...
Searching...
No Matches
go-lang.c
Go to the documentation of this file.
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. */
48static 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
55const char *
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
71static int
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
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
106static int
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
120enum go_type
122{
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
139static void
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
180static gdb::unique_xmalloc_ptr<char>
181unpack_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
360gdb::unique_xmalloc_ptr<char>
361go_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
410gdb::unique_xmalloc_ptr<char>
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
436gdb::unique_xmalloc_ptr<char>
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
465void
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
504
505static struct builtin_go_type *
507{
509
510 type_allocator alloc (gdbarch);
513 = init_character_type (alloc, 8, 1, "char");
515 = init_boolean_type (alloc, 8, 0, "bool");
517 = init_integer_type (alloc, gdbarch_int_bit (gdbarch), 0, "int");
519 = init_integer_type (alloc, gdbarch_int_bit (gdbarch), 1, "uint");
521 = init_integer_type (alloc, gdbarch_ptr_bit (gdbarch), 1, "uintptr");
523 = init_integer_type (alloc, 8, 0, "int8");
525 = init_integer_type (alloc, 16, 0, "int16");
527 = init_integer_type (alloc, 32, 0, "int32");
529 = init_integer_type (alloc, 64, 0, "int64");
531 = init_integer_type (alloc, 8, 1, "uint8");
533 = init_integer_type (alloc, 16, 1, "uint16");
535 = init_integer_type (alloc, 32, 1, "uint32");
537 = init_integer_type (alloc, 64, 1, "uint64");
539 = init_float_type (alloc, 32, "float32", floatformats_ieee_single);
541 = init_float_type (alloc, 64, "float64", floatformats_ieee_double);
546
547 return builtin_go_type;
548}
549
551
552const struct builtin_go_type *
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}
static struct obstack tempbuf
Definition c-exp.c:4839
void language_arch_info(struct gdbarch *gdbarch, struct language_arch_info *lai) const override
Definition go-lang.c:466
gdb::unique_xmalloc_ptr< char > demangle_symbol(const char *mangled, int options) const override
Definition go-lang.c:361
void set(unsigned key, void *datum)
Definition registry.h:204
void * get(unsigned key)
Definition registry.h:211
@ language_go
Definition defs.h:218
int gdbarch_int_bit(struct gdbarch *gdbarch)
Definition gdbarch.c:1449
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
Definition gdbarch.c:1722
struct type * init_character_type(type_allocator &alloc, int bit, int unsigned_p, const char *name)
Definition gdbtypes.c:3374
struct type * init_integer_type(type_allocator &alloc, int bit, int unsigned_p, const char *name)
Definition gdbtypes.c:3355
const struct floatformat * floatformats_ieee_single[BFD_ENDIAN_UNKNOWN]
Definition gdbtypes.c:85
struct type * init_float_type(type_allocator &alloc, int bit, const char *name, const struct floatformat **floatformats, enum bfd_endian byte_order)
Definition gdbtypes.c:3408
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition gdbtypes.c:6168
struct type * init_complex_type(const char *name, struct type *target_type)
Definition gdbtypes.c:3449
const struct floatformat * floatformats_ieee_double[BFD_ENDIAN_UNKNOWN]
Definition gdbtypes.c:89
struct type * init_boolean_type(type_allocator &alloc, int bit, int unsigned_p, const char *name)
Definition gdbtypes.c:3389
struct type * check_typedef(struct type *type)
Definition gdbtypes.c:2966
static const registry< gdbarch >::key< struct builtin_go_type > go_type_data
Definition go-lang.c:550
static go_language go_language_defn
Definition go-lang.c:503
enum go_type go_classify_struct_type(struct type *type)
Definition go-lang.c:121
static void unpack_package_and_object(char *buf, const char **packagep, const char **objectp)
Definition go-lang.c:140
gdb::unique_xmalloc_ptr< char > go_symbol_package_name(const struct symbol *sym)
Definition go-lang.c:411
static const char GO_MAIN_MAIN[]
Definition go-lang.c:48
const struct builtin_go_type * builtin_go_type(struct gdbarch *gdbarch)
Definition go-lang.c:553
const char * go_main_name(void)
Definition go-lang.c:56
static int gccgo_string_p(struct type *type)
Definition go-lang.c:72
static struct builtin_go_type * build_go_types(struct gdbarch *gdbarch)
Definition go-lang.c:506
static int sixg_string_p(struct type *type)
Definition go-lang.c:107
gdb::unique_xmalloc_ptr< char > go_block_package_name(const struct block *block)
Definition go-lang.c:437
static gdb::unique_xmalloc_ptr< char > unpack_mangled_go_symbol(const char *mangled_name, const char **packagep, const char **objectp, const char **method_type_packagep, const char **method_type_objectp, int *method_type_is_pointerp)
Definition go-lang.c:181
const struct builtin_go_type * builtin_go_type(struct gdbarch *)
Definition go-lang.c:553
go_type
Definition go-lang.h:55
@ GO_TYPE_STRING
Definition go-lang.h:57
@ GO_TYPE_NONE
Definition go-lang.h:56
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition minsyms.c:363
Definition block.h:109
const block * superblock() const
Definition block.h:135
symbol * function() const
Definition block.h:127
struct minimal_symbol * minsym
Definition minsyms.h:49
struct type * builtin_uint
Definition go-lang.h:38
struct type * builtin_complex64
Definition go-lang.h:50
struct type * builtin_complex128
Definition go-lang.h:51
struct type * builtin_int64
Definition go-lang.h:43
struct type * builtin_int32
Definition go-lang.h:42
struct type * builtin_char
Definition go-lang.h:35
struct type * builtin_void
Definition go-lang.h:34
struct type * builtin_int
Definition go-lang.h:37
struct type * builtin_uint64
Definition go-lang.h:47
struct type * builtin_uintptr
Definition go-lang.h:39
struct type * builtin_float64
Definition go-lang.h:49
struct type * builtin_int16
Definition go-lang.h:41
struct type * builtin_bool
Definition go-lang.h:36
struct type * builtin_float32
Definition go-lang.h:48
struct type * builtin_uint32
Definition go-lang.h:46
struct type * builtin_uint16
Definition go-lang.h:45
struct type * builtin_int8
Definition go-lang.h:40
struct type * builtin_uint8
Definition go-lang.h:44
struct type * builtin_void
Definition gdbtypes.h:2077
const char * name() const
Definition gdbtypes.h:557
struct type * type() const
Definition gdbtypes.h:547
enum language language() const
Definition symtab.h:502
const char * linkage_name() const
Definition symtab.h:460
void set_string_char_type(struct type *type)
Definition language.h:114
void add_primitive_type(struct type *type)
Definition language.h:130
void set_bool_type(struct type *type, const char *name=nullptr)
Definition language.h:102
struct type * target_type() const
Definition gdbtypes.h:1037
type_code code() const
Definition gdbtypes.h:956
ULONGEST length() const
Definition gdbtypes.h:983
struct field & field(int idx) const
Definition gdbtypes.h:1012
unsigned int num_fields() const
Definition gdbtypes.h:994
const char * name() const
Definition gdbtypes.h:968