gdb/go-lang.c

   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 *
  55 go_main_name (void)
  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
  71 gccgo_string_p (struct type *type)
  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       type0 = check_typedef (type0);
  81       type1 = 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           target_type = 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
 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;
 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
 120 go_classify_struct_type (struct type *type)
 121 {
 122   type = 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
 139 unpack_package_and_object (char *buf,
 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 ((const char *) 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
 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 }
 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 *
 421 go_block_package_name (const struct block *block)
 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, OP_NULL, PREC_SUFFIX, 0}
 482 };
 483
 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 };
 505
 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);
 511
 512   lai->string_char_type = builtin->builtin_char;
 513
 514   lai->primitive_type_vector
 515     = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_go_primitive_types + 1,
 516                               struct type *);
 517
 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;
 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,
 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 };
 604
 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);
 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 *
 656 builtin_go_type (struct gdbarch *gdbarch)
 657 {
 658   return (const struct builtin_go_type *) gdbarch_data (gdbarch, go_type_data);
 659 }
 660
 661 extern initialize_file_ftype _initialize_go_language;
 662
 663 void
 664 _initialize_go_language (void)
 665 {
 666   go_type_data = gdbarch_data_register_post_init (build_go_types);
 667
 668   add_language (&go_language_defn);
 669 }