GDB (xrefs)
/tmp/gdb-7.10/gdb/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-2015 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 "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 
44 #include <ctype.h>
45 
46 /* The main function in the main package. */
47 static const char GO_MAIN_MAIN[] = "main.main";
48 
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. */
53 
54 const char *
56 {
57  struct bound_minimal_symbol msym;
58 
59  msym = lookup_minimal_symbol (GO_MAIN_MAIN, NULL, NULL);
60  if (msym.minsym != NULL)
61  return GO_MAIN_MAIN;
62 
63  /* No known entry procedure found, the main program is probably not Go. */
64  return NULL;
65 }
66 
67 /* Return non-zero if TYPE is a gccgo string.
68  We assume CHECK_TYPEDEF has already been done. */
69 
70 static int
72 {
73  /* gccgo strings don't necessarily have a name we can use. */
74 
75  if (TYPE_NFIELDS (type) == 2)
76  {
77  struct type *type0 = TYPE_FIELD_TYPE (type, 0);
78  struct type *type1 = TYPE_FIELD_TYPE (type, 1);
79 
80  CHECK_TYPEDEF (type0);
81  CHECK_TYPEDEF (type1);
82 
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)
87  {
88  struct type *target_type = TYPE_TARGET_TYPE (type0);
89 
90  CHECK_TYPEDEF (target_type);
91 
92  if (TYPE_CODE (target_type) == TYPE_CODE_INT
93  && TYPE_LENGTH (target_type) == 1
94  && strcmp (TYPE_NAME (target_type), "uint8") == 0)
95  return 1;
96  }
97  }
98 
99  return 0;
100 }
101 
102 /* Return non-zero if TYPE is a 6g string.
103  We assume CHECK_TYPEDEF has already been done. */
104 
105 static int
107 {
108  if (TYPE_NFIELDS (type) == 2
109  && TYPE_TAG_NAME (type) != NULL
110  && strcmp (TYPE_TAG_NAME (type), "string") == 0)
111  return 1;
112 
113  return 0;
114 }
115 
116 /* Classify the kind of Go object that TYPE is.
117  TYPE is a TYPE_CODE_STRUCT, used to represent a Go object. */
118 
119 enum go_type
121 {
122  CHECK_TYPEDEF (type);
123 
124  /* Recognize strings as they're useful to be able to print without
125  pretty-printers. */
126  if (gccgo_string_p (type)
127  || sixg_string_p (type))
128  return GO_TYPE_STRING;
129 
130  return GO_TYPE_NONE;
131 }
132 
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. */
137 
138 static void
140  const char **packagep, const char **objectp)
141 {
142  char *last_dot;
143 
144  last_dot = strrchr (buf, '.');
145  gdb_assert (last_dot != NULL);
146  *objectp = last_dot + 1;
147  *last_dot = '\0';
148  last_dot = strrchr (buf, '.');
149  if (last_dot != NULL)
150  *packagep = last_dot + 1;
151  else
152  *packagep = buf;
153 }
154 
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"
159  *OBJECTP = "String"
160  *METHOD_TYPE_PACKAGEP = "textproto"
161  *METHOD_TYPE_OBJECTP = "ProtocolError"
162 
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
168  mangled Go symbol.
169  The caller is responsible for freeing the result.
170 
171  *METHOD_TYPE_IS_POINTERP is set to a boolean indicating if
172  the method type is a pointer.
173 
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.
178 
179  If we ever need to unpack the method type, this routine should work
180  for that too. */
181 
182 static char *
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)
189 {
190  char *buf;
191  char *p;
192  int len = strlen (mangled_name);
193  /* Pointer to last digit in "N<digit(s)>_". */
194  char *saw_digit;
195  /* Pointer to "N" if valid "N<digit(s)>_" found. */
196  char *method_type;
197  /* Pointer to the first '.'. */
198  char *first_dot;
199  /* Pointer to the last '.'. */
200  char *last_dot;
201  /* Non-zero if we saw a pointer indicator. */
202  int saw_pointer;
203 
204  *packagep = *objectp = NULL;
205  *method_type_packagep = *method_type_objectp = NULL;
206  *method_type_is_pointerp = 0;
207 
208  /* main.init is mangled specially. */
209  if (strcmp (mangled_name, "__go_init_main") == 0)
210  {
211  char *package = xstrdup ("main");
212 
213  *packagep = package;
214  *objectp = "init";
215  return package;
216  }
217 
218  /* main.main is mangled specially (missing prefix). */
219  if (strcmp (mangled_name, "main.main") == 0)
220  {
221  char *package = xstrdup ("main");
222 
223  *packagep = package;
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  if (!startswith (mangled_name, "go.")
237  && !startswith (mangled_name, "libgo_"))
238  return NULL;
239 
240  /* Quick check for whether a search may be fruitful. */
241  /* Ignore anything with @plt, etc. in it. */
242  if (strchr (mangled_name, '@') != NULL)
243  return NULL;
244  /* It must have at least two dots. */
245  first_dot = strchr (mangled_name, '.');
246  if (first_dot == NULL)
247  return 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)
254  return NULL;
255 
256  /* More quick checks. */
257  if (last_dot[1] == '\0' /* foo. */
258  || last_dot[-1] == '.') /* foo..bar */
259  return NULL;
260 
261  /* At this point we've decided we have a mangled Go symbol. */
262 
263  buf = xstrdup (mangled_name);
264 
265  /* Search backwards looking for "N<digit(s)>". */
266  p = buf + len;
267  saw_digit = method_type = NULL;
268  saw_pointer = 0;
269  while (p > buf)
270  {
271  int current = *(const unsigned char *) --p;
272  int current_is_digit = isdigit (current);
273 
274  if (saw_digit)
275  {
276  if (current_is_digit)
277  continue;
278  if (current == 'N'
279  && ((p > buf && p[-1] == '.')
280  || (p > buf + 1 && p[-1] == 'p' && p[-2] == '.')))
281  {
282  if (atoi (p + 1) == strlen (saw_digit + 2))
283  {
284  if (p[-1] == '.')
285  method_type = p - 1;
286  else
287  {
288  gdb_assert (p[-1] == 'p');
289  saw_pointer = 1;
290  method_type = p - 2;
291  }
292  break;
293  }
294  }
295  /* Not what we're looking for, reset and keep looking. */
296  saw_digit = NULL;
297  saw_pointer = 0;
298  continue;
299  }
300  if (current_is_digit && p[1] == '_')
301  {
302  /* Possible start of method "this" [sic] type. */
303  saw_digit = p;
304  continue;
305  }
306  }
307 
308  if (method_type != NULL
309  /* Ensure not something like "..foo". */
310  && (method_type > buf && method_type[-1] != '.'))
311  {
312  unpack_package_and_object (saw_digit + 2,
313  method_type_packagep, method_type_objectp);
314  *method_type = '\0';
315  *method_type_is_pointerp = saw_pointer;
316  }
317 
318  unpack_package_and_object (buf, packagep, objectp);
319  return buf;
320 }
321 
322 /* Implements the la_demangle language_defn routine for language Go.
323 
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
327  are today.
328 
329  N.B. This currently only supports gccgo's mangling.
330 
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. */
334 
335 char *
336 go_demangle (const char *mangled_name, int options)
337 {
338  struct obstack tempbuf;
339  char *result;
340  char *name_buf;
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;
346 
347  if (mangled_name == NULL)
348  return NULL;
349 
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)
356  return NULL;
357 
358  obstack_init (&tempbuf);
359 
360  /* Print methods as they appear in "method expressions". */
361  if (method_type_package_name != NULL)
362  {
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);
373  }
374  else
375  {
376  obstack_grow_str (&tempbuf, package_name);
377  obstack_grow_str (&tempbuf, ".");
378  obstack_grow_str (&tempbuf, object_name);
379  }
380  obstack_grow_str0 (&tempbuf, "");
381 
382  result = xstrdup (obstack_finish (&tempbuf));
383  obstack_free (&tempbuf, NULL);
384  xfree (name_buf);
385  return result;
386 }
387 
388 /* Given a Go symbol, return its package or NULL if unknown.
389  Space for the result is malloc'd, caller must free. */
390 
391 char *
392 go_symbol_package_name (const struct symbol *sym)
393 {
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;
400  char *name_buf;
401  char *result;
402 
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)
411  return NULL;
412  result = xstrdup (package_name);
413  xfree (name_buf);
414  return result;
415 }
416 
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. */
419 
420 char *
422 {
423  while (block != NULL)
424  {
425  struct symbol *function = BLOCK_FUNCTION (block);
426 
427  if (function != NULL)
428  {
429  char *package_name = go_symbol_package_name (function);
430 
431  if (package_name != NULL)
432  return package_name;
433 
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. */
437  return NULL;
438  }
439 
440  block = BLOCK_SUPERBLOCK (block);
441  }
442 
443  return NULL;
444 }
445 
446 /* Table mapping opcodes into strings for printing operators
447  and precedences of the operators.
448  TODO(dje): &^ ? */
449 
450 static const struct op_print go_op_print_tab[] =
451 {
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},
481  {NULL, 0, 0, 0}
482 };
483 
504 };
505 
506 static void
508  struct language_arch_info *lai)
509 {
510  const struct builtin_go_type *builtin = builtin_go_type (gdbarch);
511 
512  lai->string_char_type = builtin->builtin_char;
513 
516  struct type *);
517 
519  = builtin->builtin_void;
521  = builtin->builtin_char;
523  = builtin->builtin_bool;
525  = builtin->builtin_int;
527  = builtin->builtin_uint;
529  = builtin->builtin_uintptr;
531  = builtin->builtin_int8;
533  = builtin->builtin_int16;
535  = builtin->builtin_int32;
537  = builtin->builtin_int64;
539  = builtin->builtin_uint8;
541  = builtin->builtin_uint16;
543  = builtin->builtin_uint32;
545  = builtin->builtin_uint64;
547  = builtin->builtin_float32;
549  = builtin->builtin_float64;
551  = builtin->builtin_complex64;
553  = builtin->builtin_complex128;
554 
555  lai->bool_type_symbol = "bool";
556  lai->bool_type_default = builtin->builtin_bool;
557 }
558 
559 static const struct language_defn go_language_defn =
560 {
561  "go",
562  "Go",
563  language_go,
569  go_parse,
570  go_error,
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
577  syntax. */
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 */
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. */
592  default_make_symbol_completion_list,
596  c_get_string,
597  NULL,
600  NULL,
601  NULL,
602  LANG_MAGIC
603 };
604 
605 static void *
607 {
609  = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_go_type);
610 
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);
649 
650  return builtin_go_type;
651 }
652 
653 static struct gdbarch_data *go_type_data;
654 
655 const struct builtin_go_type *
657 {
658  return gdbarch_data (gdbarch, go_type_data);
659 }
660 
662 
663 void
665 {
667 
668  add_language (&go_language_defn);
669 }
struct type * builtin_uint16
Definition: go-lang.h:44
void go_print_type(struct type *type, const char *varstring, struct ui_file *stream, int show, int level, const struct type_print_options *flags)
Definition: go-typeprint.c:45
char * go_block_package_name(const struct block *block)
Definition: go-lang.c:421
static void go_language_arch_info(struct gdbarch *gdbarch, struct language_arch_info *lai)
Definition: go-lang.c:507
#define TYPE_FIELD_NAME(thistype, n)
Definition: gdbtypes.h:1369
struct type * builtin_uint32
Definition: go-lang.h:45
const char * go_main_name(void)
Definition: go-lang.c:55
void xfree(void *)
Definition: common-utils.c:97
struct type * arch_boolean_type(struct gdbarch *gdbarch, int bit, int unsigned_p, char *name)
Definition: gdbtypes.c:4588
#define GDBARCH_OBSTACK_CALLOC(GDBARCH, NR, TYPE)
Definition: gdbarch.h:1614
struct type * builtin_int16
Definition: go-lang.h:40
int gdbarch_int_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1490
struct type * builtin_complex128
Definition: go-lang.h:50
void go_error(char *)
#define TYPE_NAME(thistype)
Definition: gdbtypes.h:1227
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1690
struct type * arch_float_type(struct gdbarch *gdbarch, int bit, char *name, const struct floatformat **floatformats)
Definition: gdbtypes.c:4606
struct type * arch_complex_type(struct gdbarch *gdbarch, char *name, struct type *target_type)
Definition: gdbtypes.c:4628
void * gdbarch_data(struct gdbarch *gdbarch, struct gdbarch_data *data)
Definition: gdbarch.c:4845
initialize_file_ftype _initialize_go_language
struct type * builtin_int
Definition: go-lang.h:36
struct value * default_read_var_value(struct symbol *var, struct frame_info *frame)
Definition: findvar.c:416
struct type * builtin_int8
Definition: go-lang.h:39
static void unpack_package_and_object(char *buf, const char **packagep, const char **objectp)
Definition: go-lang.c:139
static int gccgo_string_p(struct type *type)
Definition: go-lang.c:71
struct type * string_char_type
Definition: language.h:120
char * go_symbol_package_name(const struct symbol *sym)
Definition: go-lang.c:392
#define TYPE_FIELD_TYPE(thistype, n)
Definition: gdbtypes.h:1368
void add_language(const struct language_defn *lang)
Definition: language.c:518
void c_get_string(struct value *value, gdb_byte **buffer, int *length, struct type **char_type, const char **charset)
Definition: c-lang.c:239
#define GDBARCH_OBSTACK_ZALLOC(GDBARCH, TYPE)
Definition: gdbarch.h:1615
struct type * builtin_int32
Definition: go-lang.h:41
#define BLOCK_FUNCTION(bl)
Definition: block.h:118
struct type * arch_character_type(struct gdbarch *gdbarch, int bit, int unsigned_p, char *name)
Definition: gdbtypes.c:4571
struct type * builtin_char
Definition: go-lang.h:34
char * default_word_break_characters(void)
Definition: language.c:669
const struct exp_descriptor exp_descriptor_c
Definition: c-lang.c:818
struct type * bool_type_default
Definition: language.h:125
struct type * builtin_uint8
Definition: go-lang.h:43
void null_post_parser(struct expression **exp, int void_context_p)
Definition: parse.c:1358
struct type * builtin_int64
Definition: go-lang.h:42
void initialize_file_ftype(void)
Definition: defs.h:281
void c_emit_char(int c, struct type *type, struct ui_file *stream, int quoter)
Definition: c-lang.c:146
struct type * builtin_uintptr
Definition: go-lang.h:38
void go_val_print(struct type *type, const gdb_byte *valaddr, int embedded_offset, CORE_ADDR address, struct ui_file *stream, int recurse, const struct value *val, const struct value_print_options *options)
Definition: go-valprint.c:89
const char * bool_type_symbol
Definition: language.h:123
int default_pass_by_reference(struct type *type)
Definition: language.c:659
const struct builtin_go_type * builtin_go_type(struct gdbarch *gdbarch)
Definition: go-lang.c:656
struct type * basic_lookup_transparent_type(const char *name)
Definition: symtab.c:2851
Definition: gdbtypes.h:749
static int sixg_string_p(struct type *type)
Definition: go-lang.c:106
#define BLOCK_SUPERBLOCK(bl)
Definition: block.h:119
#define gdb_assert(expr)
Definition: gdb_assert.h:33
#define SYMBOL_LINKAGE_NAME(symbol)
Definition: symtab.h:241
void iterate_over_symbols(const struct block *block, const char *name, const domain_enum domain, symbol_found_callback_ftype *callback, void *data)
Definition: symtab.c:2912
static int startswith(const char *string, const char *pattern)
Definition: common-utils.h:75
int go_parse(struct parser_state *par_state)
Definition: go-exp.c:3226
struct type * builtin_void
Definition: go-lang.h:33
void default_print_array_index(struct value *index_value, struct ui_file *stream, const struct value_print_options *options)
Definition: language.c:677
struct type * arch_integer_type(struct gdbarch *gdbarch, int bit, int unsigned_p, char *name)
Definition: gdbtypes.c:4552
enum go_type go_classify_struct_type(struct type *type)
Definition: go-lang.c:120
void c_print_typedef(struct type *, struct symbol *, struct ui_file *)
Definition: c-typeprint.c:143
struct type * builtin_uint64
Definition: go-lang.h:46
struct type * builtin_float64
Definition: go-lang.h:48
struct type * builtin_complex64
Definition: go-lang.h:49
Definition: block.h:60
void c_printstr(struct ui_file *stream, struct type *type, const gdb_byte *string, unsigned int length, const char *user_encoding, int force_ellipses, const struct value_print_options *options)
Definition: c-lang.c:189
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:183
go_type
Definition: go-lang.h:53
#define TYPE_TARGET_TYPE(thistype)
Definition: gdbtypes.h:1229
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1240
#define default_varobj_ops
Definition: varobj.h:233
#define TYPE_NFIELDS(thistype)
Definition: gdbtypes.h:1241
#define SYMBOL_LANGUAGE(symbol)
Definition: symtab.h:187
#define obstack_grow_str(OBSTACK, STRING)
Definition: gdb_obstack.h:46
#define CHECK_TYPEDEF(TYPE)
Definition: gdbtypes.h:1817
#define TYPE_TAG_NAME(type)
Definition: gdbtypes.h:1228
static const char GO_MAIN_MAIN[]
Definition: go-lang.c:47
go_primitive_types
Definition: go-lang.c:484
struct symbol * basic_lookup_symbol_nonlocal(const struct language_defn *langdef, const char *name, const struct block *block, const domain_enum domain)
Definition: symtab.c:2481
#define obstack_grow_str0(OBSTACK, STRING)
Definition: gdb_obstack.h:48
void c_printchar(int c, struct type *type, struct ui_file *stream)
Definition: c-lang.c:156
Definition: symtab.h:703
struct type * builtin_bool
Definition: go-lang.h:35
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1237
struct type * arch_type(struct gdbarch *gdbarch, enum type_code code, int length, char *name)
Definition: gdbtypes.c:4532
#define LANG_MAGIC
Definition: language.h:402
struct type ** primitive_type_vector
Definition: language.h:113
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition: minsyms.c:163
struct type * builtin_float32
Definition: go-lang.h:47
void c_value_print(struct value *, struct ui_file *, const struct value_print_options *)
Definition: c-valprint.c:459
static void * build_go_types(struct gdbarch *gdbarch)
Definition: go-lang.c:606
struct type * builtin_uint
Definition: go-lang.h:37
static const struct op_print go_op_print_tab[]
Definition: go-lang.c:450
struct gdbarch_data * gdbarch_data_register_post_init(gdbarch_data_post_init_ftype *post_init)
Definition: gdbarch.c:4812
char * go_demangle(const char *mangled_name, int options)
Definition: go-lang.c:336
static struct gdbarch_data * go_type_data
Definition: go-lang.c:653
const ULONGEST const LONGEST len
Definition: target.h:309