1 /* Go language support routines for GDB, the GNU debugger. 2 3 Copyright (C) 2012-2017 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 const char *first_dot; 199 /* Pointer to the last '.'. */ 200 const 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 /* la_sniff_from_mangled_name for Go. */ 389 390 static int 391 go_sniff_from_mangled_name (const char *mangled, char **demangled) 392 { 393 *demangled = go_demangle (mangled, 0); 394 return *demangled != NULL; 395 } 396 397 /* Given a Go symbol, return its package or NULL if unknown. 398 Space for the result is malloc'd, caller must free. */ 399 400 char * 401 go_symbol_package_name (const struct symbol *sym) 402 { 403 const char *mangled_name = SYMBOL_LINKAGE_NAME (sym); 404 const char *package_name; 405 const char *object_name; 406 const char *method_type_package_name; 407 const char *method_type_object_name; 408 int method_type_is_pointer; 409 char *name_buf; 410 char *result; 411 412 gdb_assert (SYMBOL_LANGUAGE (sym) == language_go); 413 name_buf = unpack_mangled_go_symbol (mangled_name, 414 &package_name, &object_name, 415 &method_type_package_name, 416 &method_type_object_name, 417 &method_type_is_pointer); 418 /* Some Go symbols don't have mangled form we interpret (yet). */ 419 if (name_buf == NULL) 420 return NULL; 421 result = xstrdup (package_name); 422 xfree (name_buf); 423 return result; 424 } 425 426 /* Return the package that BLOCK is in, or NULL if there isn't one. 427 Space for the result is malloc'd, caller must free. */ 428 429 char * 430 go_block_package_name (const struct block *block) 431 { 432 while (block != NULL) 433 { 434 struct symbol *function = BLOCK_FUNCTION (block); 435 436 if (function != NULL) 437 { 438 char *package_name = go_symbol_package_name (function); 439 440 if (package_name != NULL) 441 return package_name; 442 443 /* Stop looking if we find a function without a package name. 444 We're most likely outside of Go and thus the concept of the 445 "current" package is gone. */ 446 return NULL; 447 } 448 449 block = BLOCK_SUPERBLOCK (block); 450 } 451 452 return NULL; 453 } 454 455 /* Table mapping opcodes into strings for printing operators 456 and precedences of the operators. 457 TODO(dje): &^ ? */ 458 459 static const struct op_print go_op_print_tab[] = 460 { 461 {",", BINOP_COMMA, PREC_COMMA, 0}, 462 {"=", BINOP_ASSIGN, PREC_ASSIGN, 1}, 463 {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0}, 464 {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0}, 465 {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0}, 466 {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0}, 467 {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0}, 468 {"==", BINOP_EQUAL, PREC_EQUAL, 0}, 469 {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0}, 470 {"<=", BINOP_LEQ, PREC_ORDER, 0}, 471 {">=", BINOP_GEQ, PREC_ORDER, 0}, 472 {">", BINOP_GTR, PREC_ORDER, 0}, 473 {"<", BINOP_LESS, PREC_ORDER, 0}, 474 {">>", BINOP_RSH, PREC_SHIFT, 0}, 475 {"<<", BINOP_LSH, PREC_SHIFT, 0}, 476 {"+", BINOP_ADD, PREC_ADD, 0}, 477 {"-", BINOP_SUB, PREC_ADD, 0}, 478 {"*", BINOP_MUL, PREC_MUL, 0}, 479 {"/", BINOP_DIV, PREC_MUL, 0}, 480 {"%", BINOP_REM, PREC_MUL, 0}, 481 {"@", BINOP_REPEAT, PREC_REPEAT, 0}, 482 {"-", UNOP_NEG, PREC_PREFIX, 0}, 483 {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0}, 484 {"^", UNOP_COMPLEMENT, PREC_PREFIX, 0}, 485 {"*", UNOP_IND, PREC_PREFIX, 0}, 486 {"&", UNOP_ADDR, PREC_PREFIX, 0}, 487 {"unsafe.Sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0}, 488 {"++", UNOP_POSTINCREMENT, PREC_SUFFIX, 0}, 489 {"--", UNOP_POSTDECREMENT, PREC_SUFFIX, 0}, 490 {NULL, OP_NULL, PREC_SUFFIX, 0} 491 }; 492 493 enum go_primitive_types { 494 go_primitive_type_void, 495 go_primitive_type_char, 496 go_primitive_type_bool, 497 go_primitive_type_int, 498 go_primitive_type_uint, 499 go_primitive_type_uintptr, 500 go_primitive_type_int8, 501 go_primitive_type_int16, 502 go_primitive_type_int32, 503 go_primitive_type_int64, 504 go_primitive_type_uint8, 505 go_primitive_type_uint16, 506 go_primitive_type_uint32, 507 go_primitive_type_uint64, 508 go_primitive_type_float32, 509 go_primitive_type_float64, 510 go_primitive_type_complex64, 511 go_primitive_type_complex128, 512 nr_go_primitive_types 513 }; 514 515 static void 516 go_language_arch_info (struct gdbarch *gdbarch, 517 struct language_arch_info *lai) 518 { 519 const struct builtin_go_type *builtin = builtin_go_type (gdbarch); 520 521 lai->string_char_type = builtin->builtin_char; 522 523 lai->primitive_type_vector 524 = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_go_primitive_types + 1, 525 struct type *); 526 527 lai->primitive_type_vector [go_primitive_type_void] 528 = builtin->builtin_void; 529 lai->primitive_type_vector [go_primitive_type_char] 530 = builtin->builtin_char; 531 lai->primitive_type_vector [go_primitive_type_bool] 532 = builtin->builtin_bool; 533 lai->primitive_type_vector [go_primitive_type_int] 534 = builtin->builtin_int; 535 lai->primitive_type_vector [go_primitive_type_uint] 536 = builtin->builtin_uint; 537 lai->primitive_type_vector [go_primitive_type_uintptr] 538 = builtin->builtin_uintptr; 539 lai->primitive_type_vector [go_primitive_type_int8] 540 = builtin->builtin_int8; 541 lai->primitive_type_vector [go_primitive_type_int16] 542 = builtin->builtin_int16; 543 lai->primitive_type_vector [go_primitive_type_int32] 544 = builtin->builtin_int32; 545 lai->primitive_type_vector [go_primitive_type_int64] 546 = builtin->builtin_int64; 547 lai->primitive_type_vector [go_primitive_type_uint8] 548 = builtin->builtin_uint8; 549 lai->primitive_type_vector [go_primitive_type_uint16] 550 = builtin->builtin_uint16; 551 lai->primitive_type_vector [go_primitive_type_uint32] 552 = builtin->builtin_uint32; 553 lai->primitive_type_vector [go_primitive_type_uint64] 554 = builtin->builtin_uint64; 555 lai->primitive_type_vector [go_primitive_type_float32] 556 = builtin->builtin_float32; 557 lai->primitive_type_vector [go_primitive_type_float64] 558 = builtin->builtin_float64; 559 lai->primitive_type_vector [go_primitive_type_complex64] 560 = builtin->builtin_complex64; 561 lai->primitive_type_vector [go_primitive_type_complex128] 562 = builtin->builtin_complex128; 563 564 lai->bool_type_symbol = "bool"; 565 lai->bool_type_default = builtin->builtin_bool; 566 } 567 568 static const struct language_defn go_language_defn = 569 { 570 "go", 571 "Go", 572 language_go, 573 range_check_off, 574 case_sensitive_on, 575 array_row_major, 576 macro_expansion_no, 577 NULL, 578 &exp_descriptor_c, 579 go_parse, 580 go_yyerror, 581 null_post_parser, 582 c_printchar, /* Print a character constant. */ 583 c_printstr, /* Function to print string constant. */ 584 c_emit_char, /* Print a single char. */ 585 go_print_type, /* Print a type using appropriate syntax. */ 586 c_print_typedef, /* Print a typedef using appropriate 587 syntax. */ 588 go_val_print, /* Print a value using appropriate syntax. */ 589 c_value_print, /* Print a top-level value. */ 590 default_read_var_value, /* la_read_var_value */ 591 NULL, /* Language specific skip_trampoline. */ 592 NULL, /* name_of_this */ 593 basic_lookup_symbol_nonlocal, 594 basic_lookup_transparent_type, 595 go_demangle, /* Language specific symbol demangler. */ 596 go_sniff_from_mangled_name, 597 NULL, /* Language specific 598 class_name_from_physname. */ 599 go_op_print_tab, /* Expression operators for printing. */ 600 1, /* C-style arrays. */ 601 0, /* String lower bound. */ 602 default_word_break_characters, 603 default_make_symbol_completion_list, 604 go_language_arch_info, 605 default_print_array_index, 606 default_pass_by_reference, 607 c_get_string, 608 NULL, 609 iterate_over_symbols, 610 &default_varobj_ops, 611 NULL, 612 NULL, 613 LANG_MAGIC 614 }; 615 616 static void * 617 build_go_types (struct gdbarch *gdbarch) 618 { 619 struct builtin_go_type *builtin_go_type 620 = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_go_type); 621 622 builtin_go_type->builtin_void 623 = arch_type (gdbarch, TYPE_CODE_VOID, 1, "void"); 624 builtin_go_type->builtin_char 625 = arch_character_type (gdbarch, 8, 1, "char"); 626 builtin_go_type->builtin_bool 627 = arch_boolean_type (gdbarch, 8, 0, "bool"); 628 builtin_go_type->builtin_int 629 = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), 0, "int"); 630 builtin_go_type->builtin_uint 631 = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), 1, "uint"); 632 builtin_go_type->builtin_uintptr 633 = arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 1, "uintptr"); 634 builtin_go_type->builtin_int8 635 = arch_integer_type (gdbarch, 8, 0, "int8"); 636 builtin_go_type->builtin_int16 637 = arch_integer_type (gdbarch, 16, 0, "int16"); 638 builtin_go_type->builtin_int32 639 = arch_integer_type (gdbarch, 32, 0, "int32"); 640 builtin_go_type->builtin_int64 641 = arch_integer_type (gdbarch, 64, 0, "int64"); 642 builtin_go_type->builtin_uint8 643 = arch_integer_type (gdbarch, 8, 1, "uint8"); 644 builtin_go_type->builtin_uint16 645 = arch_integer_type (gdbarch, 16, 1, "uint16"); 646 builtin_go_type->builtin_uint32 647 = arch_integer_type (gdbarch, 32, 1, "uint32"); 648 builtin_go_type->builtin_uint64 649 = arch_integer_type (gdbarch, 64, 1, "uint64"); 650 builtin_go_type->builtin_float32 651 = arch_float_type (gdbarch, 32, "float32", floatformats_ieee_single); 652 builtin_go_type->builtin_float64 653 = arch_float_type (gdbarch, 64, "float64", floatformats_ieee_double); 654 builtin_go_type->builtin_complex64 655 = arch_complex_type (gdbarch, "complex64", 656 builtin_go_type->builtin_float32); 657 builtin_go_type->builtin_complex128 658 = arch_complex_type (gdbarch, "complex128", 659 builtin_go_type->builtin_float64); 660 661 return builtin_go_type; 662 } 663 664 static struct gdbarch_data *go_type_data; 665 666 const struct builtin_go_type * 667 builtin_go_type (struct gdbarch *gdbarch) 668 { 669 return (const struct builtin_go_type *) gdbarch_data (gdbarch, go_type_data); 670 } 671 672 extern initialize_file_ftype _initialize_go_language; 673 674 void 675 _initialize_go_language (void) 676 { 677 go_type_data = gdbarch_data_register_post_init (build_go_types); 678 679 add_language (&go_language_defn); 680 } 681