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 [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
183static char *
184unpack_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
336gdb::unique_xmalloc_ptr<char>
337go_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
387char *
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
416char *
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
444void
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
483
484static struct builtin_go_type *
486{
488
490 = arch_type (gdbarch, TYPE_CODE_VOID, TARGET_CHAR_BIT, "void");
492 = arch_character_type (gdbarch, 8, 1, "char");
494 = arch_boolean_type (gdbarch, 8, 0, "bool");
502 = arch_integer_type (gdbarch, 8, 0, "int8");
504 = arch_integer_type (gdbarch, 16, 0, "int16");
506 = arch_integer_type (gdbarch, 32, 0, "int32");
508 = arch_integer_type (gdbarch, 64, 0, "int64");
510 = arch_integer_type (gdbarch, 8, 1, "uint8");
512 = arch_integer_type (gdbarch, 16, 1, "uint16");
514 = arch_integer_type (gdbarch, 32, 1, "uint32");
516 = arch_integer_type (gdbarch, 64, 1, "uint64");
525
526 return builtin_go_type;
527}
528
530
531const struct builtin_go_type *
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}
void xfree(void *)
static struct obstack tempbuf
Definition c-exp.c:4842
void language_arch_info(struct gdbarch *gdbarch, struct language_arch_info *lai) const override
Definition go-lang.c:445
gdb::unique_xmalloc_ptr< char > demangle_symbol(const char *mangled, int options) const override
Definition go-lang.c:337
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:1423
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
Definition gdbarch.c:1691
struct type * arch_type(struct gdbarch *gdbarch, enum type_code code, int bit, const char *name)
Definition gdbtypes.c:5815
struct type * arch_boolean_type(struct gdbarch *gdbarch, int bit, int unsigned_p, const char *name)
Definition gdbtypes.c:5870
const struct floatformat * floatformats_ieee_single[BFD_ENDIAN_UNKNOWN]
Definition gdbtypes.c:83
struct type * arch_float_type(struct gdbarch *gdbarch, int bit, const char *name, const struct floatformat **floatformats)
Definition gdbtypes.c:5888
struct type * arch_character_type(struct gdbarch *gdbarch, int bit, int unsigned_p, const char *name)
Definition gdbtypes.c:5853
struct type * init_complex_type(const char *name, struct type *target_type)
Definition gdbtypes.c:3566
const struct floatformat * floatformats_ieee_double[BFD_ENDIAN_UNKNOWN]
Definition gdbtypes.c:87
struct type * arch_integer_type(struct gdbarch *gdbarch, int bit, int unsigned_p, const char *name)
Definition gdbtypes.c:5836
struct type * check_typedef(struct type *type)
Definition gdbtypes.c:3010
static const registry< gdbarch >::key< struct builtin_go_type > go_type_data
Definition go-lang.c:529
static go_language go_language_defn
Definition go-lang.c:482
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
static const char GO_MAIN_MAIN[]
Definition go-lang.c:48
char * go_block_package_name(const struct block *block)
Definition go-lang.c:417
static 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:184
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:485
static int sixg_string_p(struct type *type)
Definition go-lang.c:107
char * go_symbol_package_name(const struct symbol *sym)
Definition go-lang.c:388
go_type
Definition go-lang.h:54
@ GO_TYPE_STRING
Definition go-lang.h:56
@ GO_TYPE_NONE
Definition go-lang.h:55
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:37
struct type * builtin_complex64
Definition go-lang.h:49
struct type * builtin_complex128
Definition go-lang.h:50
struct type * builtin_int64
Definition go-lang.h:42
struct type * builtin_int32
Definition go-lang.h:41
struct type * builtin_char
Definition go-lang.h:34
struct type * builtin_void
Definition go-lang.h:33
struct type * builtin_int
Definition go-lang.h:36
struct type * builtin_uint64
Definition go-lang.h:46
struct type * builtin_uintptr
Definition go-lang.h:38
struct type * builtin_float64
Definition go-lang.h:48
struct type * builtin_int16
Definition go-lang.h:40
struct type * builtin_bool
Definition go-lang.h:35
struct type * builtin_float32
Definition go-lang.h:47
struct type * builtin_uint32
Definition go-lang.h:45
struct type * builtin_uint16
Definition go-lang.h:44
struct type * builtin_int8
Definition go-lang.h:39
struct type * builtin_uint8
Definition go-lang.h:43
const char * name() const
Definition gdbtypes.h:569
struct type * type() const
Definition gdbtypes.h:559
enum language language() const
Definition symtab.h:501
const char * linkage_name() const
Definition symtab.h:459
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:1000
type_code code() const
Definition gdbtypes.h:927
ULONGEST length() const
Definition gdbtypes.h:954
struct field & field(int idx) const
Definition gdbtypes.h:983
int num_fields() const
Definition gdbtypes.h:965
const char * name() const
Definition gdbtypes.h:939