gdb/go-lang.c

   1 /* Go language support routines for GDB, the GNU debugger.
   2
   3    Copyright (C) 2012-2020 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 #include "gdbarch.h"
  44
  45 #include <ctype.h>
  46
  47 /* The main function in the main package.  */
  48 static const char GO_MAIN_MAIN[] = "main.main";
  49
  50 /* Function returning the special symbol name used by Go for the main
  51    procedure in the main program if it is found in minimal symbol list.
  52    This function tries to find minimal symbols so that it finds them even
  53    if the program was compiled without debugging information.  */
  54
  55 const char *
  56 go_main_name (void)
  57 {
  58   struct bound_minimal_symbol msym;
  59
  60   msym = lookup_minimal_symbol (GO_MAIN_MAIN, NULL, NULL);
  61   if (msym.minsym != NULL)
  62     return GO_MAIN_MAIN;
  63
  64   /* No known entry procedure found, the main program is probably not Go.  */
  65   return NULL;
  66 }
  67
  68 /* Return non-zero if TYPE is a gccgo string.
  69    We assume CHECK_TYPEDEF has already been done.  */
  70
  71 static int
  72 gccgo_string_p (struct type *type)
  73 {
  74   /* gccgo strings don't necessarily have a name we can use.  */
  75
  76   if (type->num_fields () == 2)
  77     {
  78       struct type *type0 = TYPE_FIELD_TYPE (type, 0);
  79       struct type *type1 = TYPE_FIELD_TYPE (type, 1);
  80
  81       type0 = check_typedef (type0);
  82       type1 = check_typedef (type1);
  83
  84       if (type0->code () == TYPE_CODE_PTR
  85           && strcmp (TYPE_FIELD_NAME (type, 0), "__data") == 0
  86           && type1->code () == TYPE_CODE_INT
  87           && strcmp (TYPE_FIELD_NAME (type, 1), "__length") == 0)
  88         {
  89           struct type *target_type = TYPE_TARGET_TYPE (type0);
  90
  91           target_type = check_typedef (target_type);
  92
  93           if (target_type->code () == TYPE_CODE_INT
  94               && TYPE_LENGTH (target_type) == 1
  95               && strcmp (target_type->name (), "uint8") == 0)
  96             return 1;
  97         }
  98     }
  99
 100   return 0;
 101 }
 102
 103 /* Return non-zero if TYPE is a 6g string.
 104    We assume CHECK_TYPEDEF has already been done.  */
 105
 106 static int
 107 sixg_string_p (struct type *type)
 108 {
 109   if (type->num_fields () == 2
 110       && type->name () != NULL
 111       && strcmp (type->name (), "string") == 0)
 112     return 1;
 113
 114   return 0;
 115 }
 116
 117 /* Classify the kind of Go object that TYPE is.
 118    TYPE is a TYPE_CODE_STRUCT, used to represent a Go object.  */
 119
 120 enum go_type
 121 go_classify_struct_type (struct type *type)
 122 {
 123   type = check_typedef (type);
 124
 125   /* Recognize strings as they're useful to be able to print without
 126      pretty-printers.  */
 127   if (gccgo_string_p (type)
 128       || sixg_string_p (type))
 129     return GO_TYPE_STRING;
 130
 131   return GO_TYPE_NONE;
 132 }
 133
 134 /* Return true if TYPE is a string.  */
 135
 136 static bool
 137 go_is_string_type_p (struct type *type)
 138 {
 139   type = check_typedef (type);
 140   return (type->code () == TYPE_CODE_STRUCT
 141           && go_classify_struct_type (type) == GO_TYPE_STRING);
 142 }
 143
 144 /* Subroutine of unpack_mangled_go_symbol to simplify it.
 145    Given "[foo.]bar.baz", store "bar" in *PACKAGEP and "baz" in *OBJECTP.
 146    We stomp on the last '.' to nul-terminate "bar".
 147    The caller is responsible for memory management.  */
 148
 149 static void
 150 unpack_package_and_object (char *buf,
 151                            const char **packagep, const char **objectp)
 152 {
 153   char *last_dot;
 154
 155   last_dot = strrchr (buf, '.');
 156   gdb_assert (last_dot != NULL);
 157   *objectp = last_dot + 1;
 158   *last_dot = '\0';
 159   last_dot = strrchr (buf, '.');
 160   if (last_dot != NULL)
 161     *packagep = last_dot + 1;
 162   else
 163     *packagep = buf;
 164 }
 165
 166 /* Given a mangled Go symbol, find its package name, object name, and
 167    method type (if present).
 168    E.g., for "libgo_net.textproto.String.N33_libgo_net.textproto.ProtocolError"
 169    *PACKAGEP = "textproto"
 170    *OBJECTP = "String"
 171    *METHOD_TYPE_PACKAGEP = "textproto"
 172    *METHOD_TYPE_OBJECTP = "ProtocolError"
 173
 174    Space for the resulting strings is malloc'd in one buffer.
 175    PACKAGEP,OBJECTP,METHOD_TYPE* will (typically) point into this buffer.
 176    [There are a few exceptions, but the caller is still responsible for
 177    freeing the resulting pointer.]
 178    A pointer to this buffer is returned, or NULL if symbol isn't a
 179    mangled Go symbol.
 180    The caller is responsible for freeing the result.
 181
 182    *METHOD_TYPE_IS_POINTERP is set to a boolean indicating if
 183    the method type is a pointer.
 184
 185    There may be value in returning the outer container,
 186    i.e., "net" in the above example, but for now it's not needed.
 187    Plus it's currently not straightforward to compute,
 188    it comes from -fgo-prefix, and there's no algorithm to compute it.
 189
 190    If we ever need to unpack the method type, this routine should work
 191    for that too.  */
 192
 193 static char *
 194 unpack_mangled_go_symbol (const char *mangled_name,
 195                           const char **packagep,
 196                           const char **objectp,
 197                           const char **method_type_packagep,
 198                           const char **method_type_objectp,
 199                           int *method_type_is_pointerp)
 200 {
 201   char *buf;
 202   char *p;
 203   int len = strlen (mangled_name);
 204   /* Pointer to last digit in "N<digit(s)>_".  */
 205   char *saw_digit;
 206   /* Pointer to "N" if valid "N<digit(s)>_" found.  */
 207   char *method_type;
 208   /* Pointer to the first '.'.  */
 209   const char *first_dot;
 210   /* Pointer to the last '.'.  */
 211   const char *last_dot;
 212   /* Non-zero if we saw a pointer indicator.  */
 213   int saw_pointer;
 214
 215   *packagep = *objectp = NULL;
 216   *method_type_packagep = *method_type_objectp = NULL;
 217   *method_type_is_pointerp = 0;
 218
 219   /* main.init is mangled specially.  */
 220   if (strcmp (mangled_name, "__go_init_main") == 0)
 221     {
 222       char *package = xstrdup ("main");
 223
 224       *packagep = package;
 225       *objectp = "init";
 226       return package;
 227     }
 228
 229   /* main.main is mangled specially (missing prefix).  */
 230   if (strcmp (mangled_name, "main.main") == 0)
 231     {
 232       char *package = xstrdup ("main");
 233
 234       *packagep = package;
 235       *objectp = "main";
 236       return package;
 237     }
 238
 239   /* We may get passed, e.g., "main.T.Foo", which is *not* mangled.
 240      Alas it looks exactly like "prefix.package.object."
 241      To cope for now we only recognize the following prefixes:
 242
 243      go: the default
 244      libgo_.*: used by gccgo's runtime
 245
 246      Thus we don't support -fgo-prefix (except as used by the runtime).  */
 247   if (!startswith (mangled_name, "go.")
 248       && !startswith (mangled_name, "libgo_"))
 249     return NULL;
 250
 251   /* Quick check for whether a search may be fruitful.  */
 252   /* Ignore anything with @plt, etc. in it.  */
 253   if (strchr (mangled_name, '@') != NULL)
 254     return NULL;
 255   /* It must have at least two dots.  */
 256   first_dot = strchr (mangled_name, '.');
 257   if (first_dot == NULL)
 258     return NULL;
 259   /* Treat "foo.bar" as unmangled.  It can collide with lots of other
 260      languages and it's not clear what the consequences are.
 261      And except for main.main, all gccgo symbols are at least
 262      prefix.package.object.  */
 263   last_dot = strrchr (mangled_name, '.');
 264   if (last_dot == first_dot)
 265     return NULL;
 266
 267   /* More quick checks.  */
 268   if (last_dot[1] == '\0' /* foo. */
 269       || last_dot[-1] == '.') /* foo..bar */
 270     return NULL;
 271
 272   /* At this point we've decided we have a mangled Go symbol.  */
 273
 274   buf = xstrdup (mangled_name);
 275
 276   /* Search backwards looking for "N<digit(s)>".  */
 277   p = buf + len;
 278   saw_digit = method_type = NULL;
 279   saw_pointer = 0;
 280   while (p > buf)
 281     {
 282       int current = *(const unsigned char *) --p;
 283       int current_is_digit = isdigit (current);
 284
 285       if (saw_digit)
 286         {
 287           if (current_is_digit)
 288             continue;
 289           if (current == 'N'
 290               && ((p > buf && p[-1] == '.')
 291                   || (p > buf + 1 && p[-1] == 'p' && p[-2] == '.')))
 292             {
 293               if (atoi (p + 1) == strlen (saw_digit + 2))
 294                 {
 295                   if (p[-1] == '.')
 296                     method_type = p - 1;
 297                   else
 298                     {
 299                       gdb_assert (p[-1] == 'p');
 300                       saw_pointer = 1;
 301                       method_type = p - 2;
 302                     }
 303                   break;
 304                 }
 305             }
 306           /* Not what we're looking for, reset and keep looking.  */
 307           saw_digit = NULL;
 308           saw_pointer = 0;
 309           continue;
 310         }
 311       if (current_is_digit && p[1] == '_')
 312         {
 313           /* Possible start of method "this" [sic] type.  */
 314           saw_digit = p;
 315           continue;
 316         }
 317     }
 318
 319   if (method_type != NULL
 320       /* Ensure not something like "..foo".  */
 321       && (method_type > buf && method_type[-1] != '.'))
 322     {
 323       unpack_package_and_object (saw_digit + 2,
 324                                  method_type_packagep, method_type_objectp);
 325       *method_type = '\0';
 326       *method_type_is_pointerp = saw_pointer;
 327     }
 328
 329   unpack_package_and_object (buf, packagep, objectp);
 330   return buf;
 331 }
 332
 333 /* Implements the la_demangle language_defn routine for language Go.
 334
 335    N.B. This may get passed *any* symbol, including symbols from other
 336    languages and including symbols that are already demangled.
 337    Both of these situations are kinda unfortunate, but that's how things
 338    are today.
 339
 340    N.B. This currently only supports gccgo's mangling.
 341
 342    N.B. gccgo's mangling needs, I think, changing.
 343    This demangler can't work in all situations,
 344    thus not too much effort is currently put into it.  */
 345
 346 char *
 347 go_demangle (const char *mangled_name, int options)
 348 {
 349   struct obstack tempbuf;
 350   char *result;
 351   char *name_buf;
 352   const char *package_name;
 353   const char *object_name;
 354   const char *method_type_package_name;
 355   const char *method_type_object_name;
 356   int method_type_is_pointer;
 357
 358   if (mangled_name == NULL)
 359     return NULL;
 360
 361   name_buf = unpack_mangled_go_symbol (mangled_name,
 362                                        &package_name, &object_name,
 363                                        &method_type_package_name,
 364                                        &method_type_object_name,
 365                                        &method_type_is_pointer);
 366   if (name_buf == NULL)
 367     return NULL;
 368
 369   obstack_init (&tempbuf);
 370
 371   /* Print methods as they appear in "method expressions".  */
 372   if (method_type_package_name != NULL)
 373     {
 374       /* FIXME: Seems like we should include package_name here somewhere.  */
 375       if (method_type_is_pointer)
 376           obstack_grow_str (&tempbuf, "(*");
 377       obstack_grow_str (&tempbuf, method_type_package_name);
 378       obstack_grow_str (&tempbuf, ".");
 379       obstack_grow_str (&tempbuf, method_type_object_name);
 380       if (method_type_is_pointer)
 381         obstack_grow_str (&tempbuf, ")");
 382       obstack_grow_str (&tempbuf, ".");
 383       obstack_grow_str (&tempbuf, object_name);
 384     }
 385   else
 386     {
 387       obstack_grow_str (&tempbuf, package_name);
 388       obstack_grow_str (&tempbuf, ".");
 389       obstack_grow_str (&tempbuf, object_name);
 390     }
 391   obstack_grow_str0 (&tempbuf, "");
 392
 393   result = xstrdup ((const char *) obstack_finish (&tempbuf));
 394   obstack_free (&tempbuf, NULL);
 395   xfree (name_buf);
 396   return result;
 397 }
 398
 399 /* la_sniff_from_mangled_name for Go.  */
 400
 401 static int
 402 go_sniff_from_mangled_name (const char *mangled, char **demangled)
 403 {
 404   *demangled = go_demangle (mangled, 0);
 405   return *demangled != NULL;
 406 }
 407
 408 /* Given a Go symbol, return its package or NULL if unknown.
 409    Space for the result is malloc'd, caller must free.  */
 410
 411 char *
 412 go_symbol_package_name (const struct symbol *sym)
 413 {
 414   const char *mangled_name = sym->linkage_name ();
 415   const char *package_name;
 416   const char *object_name;
 417   const char *method_type_package_name;
 418   const char *method_type_object_name;
 419   int method_type_is_pointer;
 420   char *name_buf;
 421   char *result;
 422
 423   gdb_assert (sym->language () == language_go);
 424   name_buf = unpack_mangled_go_symbol (mangled_name,
 425                                        &package_name, &object_name,
 426                                        &method_type_package_name,
 427                                        &method_type_object_name,
 428                                        &method_type_is_pointer);
 429   /* Some Go symbols don't have mangled form we interpret (yet).  */
 430   if (name_buf == NULL)
 431     return NULL;
 432   result = xstrdup (package_name);
 433   xfree (name_buf);
 434   return result;
 435 }
 436
 437 /* Return the package that BLOCK is in, or NULL if there isn't one.
 438    Space for the result is malloc'd, caller must free.  */
 439
 440 char *
 441 go_block_package_name (const struct block *block)
 442 {
 443   while (block != NULL)
 444     {
 445       struct symbol *function = BLOCK_FUNCTION (block);
 446
 447       if (function != NULL)
 448         {
 449           char *package_name = go_symbol_package_name (function);
 450
 451           if (package_name != NULL)
 452             return package_name;
 453
 454           /* Stop looking if we find a function without a package name.
 455              We're most likely outside of Go and thus the concept of the
 456              "current" package is gone.  */
 457           return NULL;
 458         }
 459
 460       block = BLOCK_SUPERBLOCK (block);
 461     }
 462
 463   return NULL;
 464 }
 465
 466 /* Table mapping opcodes into strings for printing operators
 467    and precedences of the operators.
 468    TODO(dje): &^ ?  */
 469
 470 static const struct op_print go_op_print_tab[] =
 471 {
 472   {",", BINOP_COMMA, PREC_COMMA, 0},
 473   {"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
 474   {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
 475   {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
 476   {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
 477   {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
 478   {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
 479   {"==", BINOP_EQUAL, PREC_EQUAL, 0},
 480   {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
 481   {"<=", BINOP_LEQ, PREC_ORDER, 0},
 482   {">=", BINOP_GEQ, PREC_ORDER, 0},
 483   {">", BINOP_GTR, PREC_ORDER, 0},
 484   {"<", BINOP_LESS, PREC_ORDER, 0},
 485   {">>", BINOP_RSH, PREC_SHIFT, 0},
 486   {"<<", BINOP_LSH, PREC_SHIFT, 0},
 487   {"+", BINOP_ADD, PREC_ADD, 0},
 488   {"-", BINOP_SUB, PREC_ADD, 0},
 489   {"*", BINOP_MUL, PREC_MUL, 0},
 490   {"/", BINOP_DIV, PREC_MUL, 0},
 491   {"%", BINOP_REM, PREC_MUL, 0},
 492   {"@", BINOP_REPEAT, PREC_REPEAT, 0},
 493   {"-", UNOP_NEG, PREC_PREFIX, 0},
 494   {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
 495   {"^", UNOP_COMPLEMENT, PREC_PREFIX, 0},
 496   {"*", UNOP_IND, PREC_PREFIX, 0},
 497   {"&", UNOP_ADDR, PREC_PREFIX, 0},
 498   {"unsafe.Sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
 499   {"++", UNOP_POSTINCREMENT, PREC_SUFFIX, 0},
 500   {"--", UNOP_POSTDECREMENT, PREC_SUFFIX, 0},
 501   {NULL, OP_NULL, PREC_SUFFIX, 0}
 502 };
 503
 504 enum go_primitive_types {
 505   go_primitive_type_void,
 506   go_primitive_type_char,
 507   go_primitive_type_bool,
 508   go_primitive_type_int,
 509   go_primitive_type_uint,
 510   go_primitive_type_uintptr,
 511   go_primitive_type_int8,
 512   go_primitive_type_int16,
 513   go_primitive_type_int32,
 514   go_primitive_type_int64,
 515   go_primitive_type_uint8,
 516   go_primitive_type_uint16,
 517   go_primitive_type_uint32,
 518   go_primitive_type_uint64,
 519   go_primitive_type_float32,
 520   go_primitive_type_float64,
 521   go_primitive_type_complex64,
 522   go_primitive_type_complex128,
 523   nr_go_primitive_types
 524 };
 525
 526 /* Constant data that describes the Go language.  */
 527
 528 extern const struct language_data go_language_data =
 529 {
 530   "go",
 531   "Go",
 532   language_go,
 533   range_check_off,
 534   case_sensitive_on,
 535   array_row_major,
 536   macro_expansion_no,
 537   NULL,
 538   &exp_descriptor_c,
 539   go_parse,
 540   null_post_parser,
 541   c_printchar,                  /* Print a character constant.  */
 542   c_printstr,                   /* Function to print string constant.  */
 543   c_emit_char,                  /* Print a single char.  */
 544   go_print_type,                /* Print a type using appropriate syntax.  */
 545   c_print_typedef,              /* Print a typedef using appropriate
 546                                    syntax.  */
 547   go_value_print_inner,         /* la_value_print_inner */
 548   c_value_print,                /* Print a top-level value.  */
 549   NULL,                         /* Language specific skip_trampoline.  */
 550   NULL,                         /* name_of_this */
 551   false,                        /* la_store_sym_names_in_linkage_form_p */
 552   basic_lookup_symbol_nonlocal,
 553   go_demangle,                  /* Language specific symbol demangler.  */
 554   go_sniff_from_mangled_name,
 555   NULL,                         /* Language specific
 556                                    class_name_from_physname.  */
 557   go_op_print_tab,              /* Expression operators for printing.  */
 558   1,                            /* C-style arrays.  */
 559   0,                            /* String lower bound.  */
 560   default_word_break_characters,
 561   default_collect_symbol_completion_matches,
 562   c_watch_location_expression,
 563   NULL,                         /* la_get_symbol_name_matcher */
 564   iterate_over_symbols,
 565   default_search_name_hash,
 566   &default_varobj_ops,
 567   NULL,
 568   NULL,
 569   go_is_string_type_p,
 570   "{...}"                       /* la_struct_too_deep_ellipsis */
 571 };
 572
 573 /* Class representing the Go language.  */
 574
 575 class go_language : public language_defn
 576 {
 577 public:
 578   go_language ()
 579     : language_defn (language_go, go_language_data)
 580   { /* Nothing.  */ }
 581
 582   /* See language.h.  */
 583   void language_arch_info (struct gdbarch *gdbarch,
 584                            struct language_arch_info *lai) const override
 585   {
 586     const struct builtin_go_type *builtin = builtin_go_type (gdbarch);
 587
 588     lai->string_char_type = builtin->builtin_char;
 589
 590     lai->primitive_type_vector
 591       = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_go_primitive_types + 1,
 592                                 struct type *);
 593
 594     lai->primitive_type_vector [go_primitive_type_void]
 595       = builtin->builtin_void;
 596     lai->primitive_type_vector [go_primitive_type_char]
 597       = builtin->builtin_char;
 598     lai->primitive_type_vector [go_primitive_type_bool]
 599       = builtin->builtin_bool;
 600     lai->primitive_type_vector [go_primitive_type_int]
 601       = builtin->builtin_int;
 602     lai->primitive_type_vector [go_primitive_type_uint]
 603       = builtin->builtin_uint;
 604     lai->primitive_type_vector [go_primitive_type_uintptr]
 605       = builtin->builtin_uintptr;
 606     lai->primitive_type_vector [go_primitive_type_int8]
 607       = builtin->builtin_int8;
 608     lai->primitive_type_vector [go_primitive_type_int16]
 609       = builtin->builtin_int16;
 610     lai->primitive_type_vector [go_primitive_type_int32]
 611       = builtin->builtin_int32;
 612     lai->primitive_type_vector [go_primitive_type_int64]
 613       = builtin->builtin_int64;
 614     lai->primitive_type_vector [go_primitive_type_uint8]
 615       = builtin->builtin_uint8;
 616     lai->primitive_type_vector [go_primitive_type_uint16]
 617       = builtin->builtin_uint16;
 618     lai->primitive_type_vector [go_primitive_type_uint32]
 619       = builtin->builtin_uint32;
 620     lai->primitive_type_vector [go_primitive_type_uint64]
 621       = builtin->builtin_uint64;
 622     lai->primitive_type_vector [go_primitive_type_float32]
 623       = builtin->builtin_float32;
 624     lai->primitive_type_vector [go_primitive_type_float64]
 625       = builtin->builtin_float64;
 626     lai->primitive_type_vector [go_primitive_type_complex64]
 627       = builtin->builtin_complex64;
 628     lai->primitive_type_vector [go_primitive_type_complex128]
 629       = builtin->builtin_complex128;
 630
 631     lai->bool_type_symbol = "bool";
 632     lai->bool_type_default = builtin->builtin_bool;
 633   }
 634 };
 635
 636 /* Single instance of the Go language class.  */
 637
 638 static go_language go_language_defn;
 639
 640 static void *
 641 build_go_types (struct gdbarch *gdbarch)
 642 {
 643   struct builtin_go_type *builtin_go_type
 644     = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_go_type);
 645
 646   builtin_go_type->builtin_void
 647     = arch_type (gdbarch, TYPE_CODE_VOID, TARGET_CHAR_BIT, "void");
 648   builtin_go_type->builtin_char
 649     = arch_character_type (gdbarch, 8, 1, "char");
 650   builtin_go_type->builtin_bool
 651     = arch_boolean_type (gdbarch, 8, 0, "bool");
 652   builtin_go_type->builtin_int
 653     = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), 0, "int");
 654   builtin_go_type->builtin_uint
 655     = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), 1, "uint");
 656   builtin_go_type->builtin_uintptr
 657     = arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 1, "uintptr");
 658   builtin_go_type->builtin_int8
 659     = arch_integer_type (gdbarch, 8, 0, "int8");
 660   builtin_go_type->builtin_int16
 661     = arch_integer_type (gdbarch, 16, 0, "int16");
 662   builtin_go_type->builtin_int32
 663     = arch_integer_type (gdbarch, 32, 0, "int32");
 664   builtin_go_type->builtin_int64
 665     = arch_integer_type (gdbarch, 64, 0, "int64");
 666   builtin_go_type->builtin_uint8
 667     = arch_integer_type (gdbarch, 8, 1, "uint8");
 668   builtin_go_type->builtin_uint16
 669     = arch_integer_type (gdbarch, 16, 1, "uint16");
 670   builtin_go_type->builtin_uint32
 671     = arch_integer_type (gdbarch, 32, 1, "uint32");
 672   builtin_go_type->builtin_uint64
 673     = arch_integer_type (gdbarch, 64, 1, "uint64");
 674   builtin_go_type->builtin_float32
 675     = arch_float_type (gdbarch, 32, "float32", floatformats_ieee_single);
 676   builtin_go_type->builtin_float64
 677     = arch_float_type (gdbarch, 64, "float64", floatformats_ieee_double);
 678   builtin_go_type->builtin_complex64
 679     = init_complex_type ("complex64", builtin_go_type->builtin_float32);
 680   builtin_go_type->builtin_complex128
 681     = init_complex_type ("complex128", builtin_go_type->builtin_float64);
 682
 683   return builtin_go_type;
 684 }
 685
 686 static struct gdbarch_data *go_type_data;
 687
 688 const struct builtin_go_type *
 689 builtin_go_type (struct gdbarch *gdbarch)
 690 {
 691   return (const struct builtin_go_type *) gdbarch_data (gdbarch, go_type_data);
 692 }
 693
 694 void _initialize_go_language ();
 695 void
 696 _initialize_go_language ()
 697 {
 698   go_type_data = gdbarch_data_register_post_init (build_go_types);
 699 }