gdb/go-lang.c - gdb

Global variables defined

Data types defined

Functions defined

Source code

  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/>.  */

  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. */

  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"

  44. #include <ctype.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.  */

  54. const char *
  55. ‌go_main_name (void)
  56. {
  57.   struct bound_minimal_symbol msym;

  59.   msym = lookup_minimal_symbol (GO_MAIN_MAIN, NULL, NULL);
  60.   if (msym.minsym != NULL)
  61.     return GO_MAIN_MAIN;

  63.   /* No known entry procedure found, the main program is probably not Go.  */
  64.   return NULL;
  65. }

  67. /* Return non-zero if TYPE is a gccgo string.
  68.    We assume CHECK_TYPEDEF has already been done.  */

  70. static int
  71. ‌gccgo_string_p (struct type *type)
  72. {
  73.   /* gccgo strings don't necessarily have a name we can use.  */

  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);

  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)
  87.         {
  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)
  95.             return 1;
  96.         }
  97.     }

  99.   return 0;
  100. }

  102. /* Return non-zero if TYPE is a 6g string.
  103.    We assume CHECK_TYPEDEF has already been done.  */

  105. static int
  106. ‌sixg_string_p (struct type *type)
  107. {
  108.   if (TYPE_NFIELDS (type) == 2
  109.       && TYPE_TAG_NAME (type) != NULL
  110.       && strcmp (TYPE_TAG_NAME (type), "string") == 0)
  111.     return 1;

  113.   return 0;
  114. }

  116. /* Classify the kind of Go object that TYPE is.
  117.    TYPE is a TYPE_CODE_STRUCT, used to represent a Go object.  */

  119. enum go_type
  120. ‌go_classify_struct_type (struct type *type)
  121. {
  122.   CHECK_TYPEDEF (type);

  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;

  130.   return GO_TYPE_NONE;
  131. }

  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.  */

  138. static void
  139. ‌unpack_package_and_object (char *buf,
  140.                            const char **packagep, const char **objectp)
  141. {
  142.   char *last_dot;

  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. }

  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"

  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.

  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
  180.    for that too.  */

  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;

  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)
  210.     {
  211.       char *package = xstrdup ("main");

  213.       *packagep = package;
  214.       *objectp = "init";
  215.       return package;
  216.     }

  218.   /* main.main is mangled specially (missing prefix).  */
  219.   if (strcmp (mangled_name, "main.main") == 0)
  220.     {
  221.       char *package = xstrdup ("main");

  223.       *packagep = package;
  224.       *objectp = "main";
  225.       return package;
  226.     }

  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:

  232.      go: the default
  233.      libgo_.*: used by gccgo's runtime

  235.      Thus we don't support -fgo-prefix (except as used by the runtime).  */
  236.   if (strncmp (mangled_name, "go.", 3) != 0
  237.       && strncmp (mangled_name, "libgo_", 6) != 0)
  238.     return NULL;

  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;

  256.   /* More quick checks.  */
  257.   if (last_dot[1] == '\0' /* foo. */
  258.       || last_dot[-1] == '.') /* foo..bar */
  259.     return NULL;

  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)>".  */
  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);

  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.     }

  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.     }

  318.   unpack_package_and_object (buf, packagep, objectp);
  319.   return buf;
  320. }

  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
  327.    are today.

  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.  */

  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;

  347.   if (mangled_name == NULL)
  348.     return 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)
  356.     return NULL;

  358.   obstack_init (&tempbuf);

  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, "");

  382.   result = xstrdup (obstack_finish (&tempbuf));
  383.   obstack_free (&tempbuf, NULL);
  384.   xfree (name_buf);
  385.   return result;
  386. }

  388. /* Given a Go symbol, return its package or NULL if unknown.
  389.    Space for the result is malloc'd, caller must free.  */

  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;

  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)
  411.     return NULL;
  412.   result = xstrdup (package_name);
  413.   xfree (name_buf);
  414.   return result;
  415. }

  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.  */

  420. char *
  421. ‌go_block_package_name (const struct block *block)
  422. {
  423.   while (block != NULL)
  424.     {
  425.       struct symbol *function = BLOCK_FUNCTION (block);

  427.       if (function != NULL)
  428.         {
  429.           char *package_name = go_symbol_package_name (function);

  431.           if (package_name != NULL)
  432.             return package_name;

  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.         }

  440.       block = BLOCK_SUPERBLOCK (block);
  441.     }

  443.   return NULL;
  444. }

  446. /* Table mapping opcodes into strings for printing operators
  447.    and precedences of the operators.
  448.    TODO(dje): &^ ?  */

  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. };

  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
  504. };

  506. static void
  507. ‌go_language_arch_info (struct gdbarch *gdbarch,
  508.                        struct language_arch_info *lai)
  509. {
  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,
  516.                               struct type *);

  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;
  557. }

  559. ‌static const struct language_defn go_language_defn =
  560. {
  561.   "go",
  562.   "Go",
  563.   language_go,
  564.   range_check_off,
  565.   case_sensitive_on,
  566.   array_row_major,
  567.   macro_expansion_no,
  568.   &exp_descriptor_c,
  569.   go_parse,
  570.   go_error,
  571.   null_post_parser,
  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 */
  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,
  596.   c_get_string,
  597.   NULL,
  598.   iterate_over_symbols,
  599.   &default_varobj_ops,
  600.   NULL,
  601.   NULL,
  602.   LANG_MAGIC
  603. };

  605. static void *
  606. ‌build_go_types (struct gdbarch *gdbarch)
  607. {
  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;
  651. }

  653. ‌static struct gdbarch_data *go_type_data;

  655. const struct builtin_go_type *
  656. ‌builtin_go_type (struct gdbarch *gdbarch)
  657. {
  658.   return gdbarch_data (gdbarch, go_type_data);
  659. }

  661. extern initialize_file_ftype _initialize_go_language;

  663. void
  664. ‌_initialize_go_language (void)
  665. {
  666.   go_type_data = gdbarch_data_register_post_init (build_go_types);

  668.   add_language (&go_language_defn);
  669. }