1 /* Go language support routines for GDB, the GNU debugger.
3 Copyright (C) 2012-2015 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
22 - printing of native types
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
35 #include "gdb_obstack.h"
42 #include "parser-defs.h"
46 /* The main function in the main package. */
47 static const char GO_MAIN_MAIN[] = "main.main";
49 /* Function returning the special symbol name used by Go for the main
50 procedure in the main program if it is found in minimal symbol list.
51 This function tries to find minimal symbols so that it finds them even
52 if the program was compiled without debugging information. */
57 struct bound_minimal_symbol msym;
59 msym = lookup_minimal_symbol (GO_MAIN_MAIN, NULL, NULL);
60 if (msym.minsym != NULL)
63 /* No known entry procedure found, the main program is probably not Go. */
67 /* Return non-zero if TYPE is a gccgo string.
68 We assume CHECK_TYPEDEF has already been done. */
71 gccgo_string_p (struct type *type)
73 /* gccgo strings don't necessarily have a name we can use. */
75 if (TYPE_NFIELDS (type) == 2)
77 struct type *type0 = TYPE_FIELD_TYPE (type, 0);
78 struct type *type1 = TYPE_FIELD_TYPE (type, 1);
80 CHECK_TYPEDEF (type0);
81 CHECK_TYPEDEF (type1);
83 if (TYPE_CODE (type0) == TYPE_CODE_PTR
84 && strcmp (TYPE_FIELD_NAME (type, 0), "__data") == 0
85 && TYPE_CODE (type1) == TYPE_CODE_INT
86 && strcmp (TYPE_FIELD_NAME (type, 1), "__length") == 0)
88 struct type *target_type = TYPE_TARGET_TYPE (type0);
90 CHECK_TYPEDEF (target_type);
92 if (TYPE_CODE (target_type) == TYPE_CODE_INT
93 && TYPE_LENGTH (target_type) == 1
94 && strcmp (TYPE_NAME (target_type), "uint8") == 0)
102 /* Return non-zero if TYPE is a 6g string.
103 We assume CHECK_TYPEDEF has already been done. */
106 sixg_string_p (struct type *type)
108 if (TYPE_NFIELDS (type) == 2
109 && TYPE_TAG_NAME (type) != NULL
110 && strcmp (TYPE_TAG_NAME (type), "string") == 0)
116 /* Classify the kind of Go object that TYPE is.
117 TYPE is a TYPE_CODE_STRUCT, used to represent a Go object. */
120 go_classify_struct_type (struct type *type)
122 CHECK_TYPEDEF (type);
124 /* Recognize strings as they're useful to be able to print without
126 if (gccgo_string_p (type)
127 || sixg_string_p (type))
128 return GO_TYPE_STRING;
133 /* Subroutine of unpack_mangled_go_symbol to simplify it.
134 Given "[foo.]bar.baz", store "bar" in *PACKAGEP and "baz" in *OBJECTP.
135 We stomp on the last '.' to nul-terminate "bar".
136 The caller is responsible for memory management. */
139 unpack_package_and_object (char *buf,
140 const char **packagep, const char **objectp)
144 last_dot = strrchr (buf, '.');
145 gdb_assert (last_dot != NULL);
146 *objectp = last_dot + 1;
148 last_dot = strrchr (buf, '.');
149 if (last_dot != NULL)
150 *packagep = last_dot + 1;
155 /* Given a mangled Go symbol, find its package name, object name, and
156 method type (if present).
157 E.g., for "libgo_net.textproto.String.N33_libgo_net.textproto.ProtocolError"
158 *PACKAGEP = "textproto"
160 *METHOD_TYPE_PACKAGEP = "textproto"
161 *METHOD_TYPE_OBJECTP = "ProtocolError"
163 Space for the resulting strings is malloc'd in one buffer.
164 PACKAGEP,OBJECTP,METHOD_TYPE* will (typically) point into this buffer.
165 [There are a few exceptions, but the caller is still responsible for
166 freeing the resulting pointer.]
167 A pointer to this buffer is returned, or NULL if symbol isn't a
169 The caller is responsible for freeing the result.
171 *METHOD_TYPE_IS_POINTERP is set to a boolean indicating if
172 the method type is a pointer.
174 There may be value in returning the outer container,
175 i.e., "net" in the above example, but for now it's not needed.
176 Plus it's currently not straightforward to compute,
177 it comes from -fgo-prefix, and there's no algorithm to compute it.
179 If we ever need to unpack the method type, this routine should work
183 unpack_mangled_go_symbol (const char *mangled_name,
184 const char **packagep,
185 const char **objectp,
186 const char **method_type_packagep,
187 const char **method_type_objectp,
188 int *method_type_is_pointerp)
192 int len = strlen (mangled_name);
193 /* Pointer to last digit in "N<digit(s)>_". */
195 /* Pointer to "N" if valid "N<digit(s)>_" found. */
197 /* Pointer to the first '.'. */
199 /* Pointer to the last '.'. */
201 /* Non-zero if we saw a pointer indicator. */
204 *packagep = *objectp = NULL;
205 *method_type_packagep = *method_type_objectp = NULL;
206 *method_type_is_pointerp = 0;
208 /* main.init is mangled specially. */
209 if (strcmp (mangled_name, "__go_init_main") == 0)
211 char *package = xstrdup ("main");
218 /* main.main is mangled specially (missing prefix). */
219 if (strcmp (mangled_name, "main.main") == 0)
221 char *package = xstrdup ("main");
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:
233 libgo_.*: used by gccgo's runtime
235 Thus we don't support -fgo-prefix (except as used by the runtime). */
236 if (!startswith (mangled_name, "go.")
237 && !startswith (mangled_name, "libgo_"))
240 /* Quick check for whether a search may be fruitful. */
241 /* Ignore anything with @plt, etc. in it. */
242 if (strchr (mangled_name, '@') != NULL)
244 /* It must have at least two dots. */
245 first_dot = strchr (mangled_name, '.');
246 if (first_dot == NULL)
248 /* Treat "foo.bar" as unmangled. It can collide with lots of other
249 languages and it's not clear what the consequences are.
250 And except for main.main, all gccgo symbols are at least
251 prefix.package.object. */
252 last_dot = strrchr (mangled_name, '.');
253 if (last_dot == first_dot)
256 /* More quick checks. */
257 if (last_dot[1] == '\0' /* foo. */
258 || last_dot[-1] == '.') /* foo..bar */
261 /* At this point we've decided we have a mangled Go symbol. */
263 buf = xstrdup (mangled_name);
265 /* Search backwards looking for "N<digit(s)>". */
267 saw_digit = method_type = NULL;
271 int current = *(const unsigned char *) --p;
272 int current_is_digit = isdigit (current);
276 if (current_is_digit)
279 && ((p > buf && p[-1] == '.')
280 || (p > buf + 1 && p[-1] == 'p' && p[-2] == '.')))
282 if (atoi (p + 1) == strlen (saw_digit + 2))
288 gdb_assert (p[-1] == 'p');
295 /* Not what we're looking for, reset and keep looking. */
300 if (current_is_digit && p[1] == '_')
302 /* Possible start of method "this" [sic] type. */
308 if (method_type != NULL
309 /* Ensure not something like "..foo". */
310 && (method_type > buf && method_type[-1] != '.'))
312 unpack_package_and_object (saw_digit + 2,
313 method_type_packagep, method_type_objectp);
315 *method_type_is_pointerp = saw_pointer;
318 unpack_package_and_object (buf, packagep, objectp);
322 /* Implements the la_demangle language_defn routine for language Go.
324 N.B. This may get passed *any* symbol, including symbols from other
325 languages and including symbols that are already demangled.
326 Both of these situations are kinda unfortunate, but that's how things
329 N.B. This currently only supports gccgo's mangling.
331 N.B. gccgo's mangling needs, I think, changing.
332 This demangler can't work in all situations,
333 thus not too much effort is currently put into it. */
336 go_demangle (const char *mangled_name, int options)
338 struct obstack tempbuf;
341 const char *package_name;
342 const char *object_name;
343 const char *method_type_package_name;
344 const char *method_type_object_name;
345 int method_type_is_pointer;
347 if (mangled_name == NULL)
350 name_buf = unpack_mangled_go_symbol (mangled_name,
351 &package_name, &object_name,
352 &method_type_package_name,
353 &method_type_object_name,
354 &method_type_is_pointer);
355 if (name_buf == NULL)
358 obstack_init (&tempbuf);
360 /* Print methods as they appear in "method expressions". */
361 if (method_type_package_name != NULL)
363 /* FIXME: Seems like we should include package_name here somewhere. */
364 if (method_type_is_pointer)
365 obstack_grow_str (&tempbuf, "(*");
366 obstack_grow_str (&tempbuf, method_type_package_name);
367 obstack_grow_str (&tempbuf, ".");
368 obstack_grow_str (&tempbuf, method_type_object_name);
369 if (method_type_is_pointer)
370 obstack_grow_str (&tempbuf, ")");
371 obstack_grow_str (&tempbuf, ".");
372 obstack_grow_str (&tempbuf, object_name);
376 obstack_grow_str (&tempbuf, package_name);
377 obstack_grow_str (&tempbuf, ".");
378 obstack_grow_str (&tempbuf, object_name);
380 obstack_grow_str0 (&tempbuf, "");
382 result = xstrdup (obstack_finish (&tempbuf));
383 obstack_free (&tempbuf, NULL);
388 /* Given a Go symbol, return its package or NULL if unknown.
389 Space for the result is malloc'd, caller must free. */
392 go_symbol_package_name (const struct symbol *sym)
394 const char *mangled_name = SYMBOL_LINKAGE_NAME (sym);
395 const char *package_name;
396 const char *object_name;
397 const char *method_type_package_name;
398 const char *method_type_object_name;
399 int method_type_is_pointer;
403 gdb_assert (SYMBOL_LANGUAGE (sym) == language_go);
404 name_buf = unpack_mangled_go_symbol (mangled_name,
405 &package_name, &object_name,
406 &method_type_package_name,
407 &method_type_object_name,
408 &method_type_is_pointer);
409 /* Some Go symbols don't have mangled form we interpret (yet). */
410 if (name_buf == NULL)
412 result = xstrdup (package_name);
417 /* Return the package that BLOCK is in, or NULL if there isn't one.
418 Space for the result is malloc'd, caller must free. */
421 go_block_package_name (const struct block *block)
423 while (block != NULL)
425 struct symbol *function = BLOCK_FUNCTION (block);
427 if (function != NULL)
429 char *package_name = go_symbol_package_name (function);
431 if (package_name != NULL)
434 /* Stop looking if we find a function without a package name.
435 We're most likely outside of Go and thus the concept of the
436 "current" package is gone. */
440 block = BLOCK_SUPERBLOCK (block);
446 /* Table mapping opcodes into strings for printing operators
447 and precedences of the operators.
450 static const struct op_print go_op_print_tab[] =
452 {",", BINOP_COMMA, PREC_COMMA, 0},
453 {"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
454 {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
455 {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
456 {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
457 {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
458 {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
459 {"==", BINOP_EQUAL, PREC_EQUAL, 0},
460 {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
461 {"<=", BINOP_LEQ, PREC_ORDER, 0},
462 {">=", BINOP_GEQ, PREC_ORDER, 0},
463 {">", BINOP_GTR, PREC_ORDER, 0},
464 {"<", BINOP_LESS, PREC_ORDER, 0},
465 {">>", BINOP_RSH, PREC_SHIFT, 0},
466 {"<<", BINOP_LSH, PREC_SHIFT, 0},
467 {"+", BINOP_ADD, PREC_ADD, 0},
468 {"-", BINOP_SUB, PREC_ADD, 0},
469 {"*", BINOP_MUL, PREC_MUL, 0},
470 {"/", BINOP_DIV, PREC_MUL, 0},
471 {"%", BINOP_REM, PREC_MUL, 0},
472 {"@", BINOP_REPEAT, PREC_REPEAT, 0},
473 {"-", UNOP_NEG, PREC_PREFIX, 0},
474 {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
475 {"^", UNOP_COMPLEMENT, PREC_PREFIX, 0},
476 {"*", UNOP_IND, PREC_PREFIX, 0},
477 {"&", UNOP_ADDR, PREC_PREFIX, 0},
478 {"unsafe.Sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
479 {"++", UNOP_POSTINCREMENT, PREC_SUFFIX, 0},
480 {"--", UNOP_POSTDECREMENT, PREC_SUFFIX, 0},
484 enum go_primitive_types {
485 go_primitive_type_void,
486 go_primitive_type_char,
487 go_primitive_type_bool,
488 go_primitive_type_int,
489 go_primitive_type_uint,
490 go_primitive_type_uintptr,
491 go_primitive_type_int8,
492 go_primitive_type_int16,
493 go_primitive_type_int32,
494 go_primitive_type_int64,
495 go_primitive_type_uint8,
496 go_primitive_type_uint16,
497 go_primitive_type_uint32,
498 go_primitive_type_uint64,
499 go_primitive_type_float32,
500 go_primitive_type_float64,
501 go_primitive_type_complex64,
502 go_primitive_type_complex128,
503 nr_go_primitive_types
507 go_language_arch_info (struct gdbarch *gdbarch,
508 struct language_arch_info *lai)
510 const struct builtin_go_type *builtin = builtin_go_type (gdbarch);
512 lai->string_char_type = builtin->builtin_char;
514 lai->primitive_type_vector
515 = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_go_primitive_types + 1,
518 lai->primitive_type_vector [go_primitive_type_void]
519 = builtin->builtin_void;
520 lai->primitive_type_vector [go_primitive_type_char]
521 = builtin->builtin_char;
522 lai->primitive_type_vector [go_primitive_type_bool]
523 = builtin->builtin_bool;
524 lai->primitive_type_vector [go_primitive_type_int]
525 = builtin->builtin_int;
526 lai->primitive_type_vector [go_primitive_type_uint]
527 = builtin->builtin_uint;
528 lai->primitive_type_vector [go_primitive_type_uintptr]
529 = builtin->builtin_uintptr;
530 lai->primitive_type_vector [go_primitive_type_int8]
531 = builtin->builtin_int8;
532 lai->primitive_type_vector [go_primitive_type_int16]
533 = builtin->builtin_int16;
534 lai->primitive_type_vector [go_primitive_type_int32]
535 = builtin->builtin_int32;
536 lai->primitive_type_vector [go_primitive_type_int64]
537 = builtin->builtin_int64;
538 lai->primitive_type_vector [go_primitive_type_uint8]
539 = builtin->builtin_uint8;
540 lai->primitive_type_vector [go_primitive_type_uint16]
541 = builtin->builtin_uint16;
542 lai->primitive_type_vector [go_primitive_type_uint32]
543 = builtin->builtin_uint32;
544 lai->primitive_type_vector [go_primitive_type_uint64]
545 = builtin->builtin_uint64;
546 lai->primitive_type_vector [go_primitive_type_float32]
547 = builtin->builtin_float32;
548 lai->primitive_type_vector [go_primitive_type_float64]
549 = builtin->builtin_float64;
550 lai->primitive_type_vector [go_primitive_type_complex64]
551 = builtin->builtin_complex64;
552 lai->primitive_type_vector [go_primitive_type_complex128]
553 = builtin->builtin_complex128;
555 lai->bool_type_symbol = "bool";
556 lai->bool_type_default = builtin->builtin_bool;
559 static const struct language_defn go_language_defn =
572 c_printchar, /* Print a character constant. */
573 c_printstr, /* Function to print string constant. */
574 c_emit_char, /* Print a single char. */
575 go_print_type, /* Print a type using appropriate syntax. */
576 c_print_typedef, /* Print a typedef using appropriate
578 go_val_print, /* Print a value using appropriate syntax. */
579 c_value_print, /* Print a top-level value. */
580 default_read_var_value, /* la_read_var_value */
581 NULL, /* Language specific skip_trampoline. */
582 NULL, /* name_of_this */
583 basic_lookup_symbol_nonlocal,
584 basic_lookup_transparent_type,
585 go_demangle, /* Language specific symbol demangler. */
586 NULL, /* Language specific
587 class_name_from_physname. */
588 go_op_print_tab, /* Expression operators for printing. */
589 1, /* C-style arrays. */
590 0, /* String lower bound. */
591 default_word_break_characters,
592 default_make_symbol_completion_list,
593 go_language_arch_info,
594 default_print_array_index,
595 default_pass_by_reference,
598 iterate_over_symbols,
606 build_go_types (struct gdbarch *gdbarch)
608 struct builtin_go_type *builtin_go_type
609 = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_go_type);
611 builtin_go_type->builtin_void
612 = arch_type (gdbarch, TYPE_CODE_VOID, 1, "void");
613 builtin_go_type->builtin_char
614 = arch_character_type (gdbarch, 8, 1, "char");
615 builtin_go_type->builtin_bool
616 = arch_boolean_type (gdbarch, 8, 0, "bool");
617 builtin_go_type->builtin_int
618 = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), 0, "int");
619 builtin_go_type->builtin_uint
620 = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), 1, "uint");
621 builtin_go_type->builtin_uintptr
622 = arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 1, "uintptr");
623 builtin_go_type->builtin_int8
624 = arch_integer_type (gdbarch, 8, 0, "int8");
625 builtin_go_type->builtin_int16
626 = arch_integer_type (gdbarch, 16, 0, "int16");
627 builtin_go_type->builtin_int32
628 = arch_integer_type (gdbarch, 32, 0, "int32");
629 builtin_go_type->builtin_int64
630 = arch_integer_type (gdbarch, 64, 0, "int64");
631 builtin_go_type->builtin_uint8
632 = arch_integer_type (gdbarch, 8, 1, "uint8");
633 builtin_go_type->builtin_uint16
634 = arch_integer_type (gdbarch, 16, 1, "uint16");
635 builtin_go_type->builtin_uint32
636 = arch_integer_type (gdbarch, 32, 1, "uint32");
637 builtin_go_type->builtin_uint64
638 = arch_integer_type (gdbarch, 64, 1, "uint64");
639 builtin_go_type->builtin_float32
640 = arch_float_type (gdbarch, 32, "float32", NULL);
641 builtin_go_type->builtin_float64
642 = arch_float_type (gdbarch, 64, "float64", NULL);
643 builtin_go_type->builtin_complex64
644 = arch_complex_type (gdbarch, "complex64",
645 builtin_go_type->builtin_float32);
646 builtin_go_type->builtin_complex128
647 = arch_complex_type (gdbarch, "complex128",
648 builtin_go_type->builtin_float64);
650 return builtin_go_type;
653 static struct gdbarch_data *go_type_data;
655 const struct builtin_go_type *
656 builtin_go_type (struct gdbarch *gdbarch)
658 return gdbarch_data (gdbarch, go_type_data);
661 extern initialize_file_ftype _initialize_go_language;
664 _initialize_go_language (void)
666 go_type_data = gdbarch_data_register_post_init (build_go_types);
668 add_language (&go_language_defn);