1 /* Output Go language descriptions of types. 2 Copyright (C) 2008-2018 Free Software Foundation, Inc. 3 Written by Ian Lance Taylor <iant@google.com>. 4 5 This file is part of GCC. 6 7 GCC is free software; you can redistribute it and/or modify it under 8 the terms of the GNU General Public License as published by the Free 9 Software Foundation; either version 3, or (at your option) any later 10 version. 11 12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 13 WARRANTY; without even the implied warranty of MERCHANTABILITY or 14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15 for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with GCC; see the file COPYING3. If not see 19 <http://www.gnu.org/licenses/>. */ 20 21 /* This file is used during the build process to emit Go language 22 descriptions of declarations from C header files. It uses the 23 debug info hooks to emit the descriptions. The Go language 24 descriptions then become part of the Go runtime support 25 library. 26 27 All global names are output with a leading underscore, so that they 28 are all hidden in Go. */ 29 30 #include "config.h" 31 #include "system.h" 32 #include "coretypes.h" 33 #include "tree.h" 34 #include "diagnostic-core.h" 35 #include "debug.h" 36 #include "stor-layout.h" 37 38 /* We dump this information from the debug hooks. This gives us a 39 stable and maintainable API to hook into. In order to work 40 correctly when -g is used, we build our own hooks structure which 41 wraps the hooks we need to change. */ 42 43 /* Our debug hooks. This is initialized by dump_go_spec_init. */ 44 45 static struct gcc_debug_hooks go_debug_hooks; 46 47 /* The real debug hooks. */ 48 49 static const struct gcc_debug_hooks *real_debug_hooks; 50 51 /* The file where we should write information. */ 52 53 static FILE *go_dump_file; 54 55 /* A queue of decls to output. */ 56 57 static GTY(()) vec<tree, va_gc> *queue; 58 59 /* A hash table of macros we have seen. */ 60 61 static htab_t macro_hash; 62 63 /* The type of a value in macro_hash. */ 64 65 struct macro_hash_value 66 { 67 /* The name stored in the hash table. */ 68 char *name; 69 /* The value of the macro. */ 70 char *value; 71 }; 72 73 /* Returns the number of units necessary to represent an integer with the given 74 PRECISION (in bits). */ 75 76 static inline unsigned int 77 precision_to_units (unsigned int precision) 78 { 79 return (precision + BITS_PER_UNIT - 1) / BITS_PER_UNIT; 80 } 81 82 /* Calculate the hash value for an entry in the macro hash table. */ 83 84 static hashval_t 85 macro_hash_hashval (const void *val) 86 { 87 const struct macro_hash_value *mhval = (const struct macro_hash_value *) val; 88 return htab_hash_string (mhval->name); 89 } 90 91 /* Compare values in the macro hash table for equality. */ 92 93 static int 94 macro_hash_eq (const void *v1, const void *v2) 95 { 96 const struct macro_hash_value *mhv1 = (const struct macro_hash_value *) v1; 97 const struct macro_hash_value *mhv2 = (const struct macro_hash_value *) v2; 98 return strcmp (mhv1->name, mhv2->name) == 0; 99 } 100 101 /* Free values deleted from the macro hash table. */ 102 103 static void 104 macro_hash_del (void *v) 105 { 106 struct macro_hash_value *mhv = (struct macro_hash_value *) v; 107 XDELETEVEC (mhv->name); 108 XDELETEVEC (mhv->value); 109 XDELETE (mhv); 110 } 111 112 /* For the string hash tables. */ 113 114 static int 115 string_hash_eq (const void *y1, const void *y2) 116 { 117 return strcmp ((const char *) y1, (const char *) y2) == 0; 118 } 119 120 /* A macro definition. */ 121 122 static void 123 go_define (unsigned int lineno, const char *buffer) 124 { 125 const char *p; 126 const char *name_end; 127 size_t out_len; 128 char *out_buffer; 129 char *q; 130 bool saw_operand; 131 bool need_operand; 132 struct macro_hash_value *mhval; 133 char *copy; 134 hashval_t hashval; 135 void **slot; 136 137 real_debug_hooks->define (lineno, buffer); 138 139 /* Skip macro functions. */ 140 for (p = buffer; *p != '\0' && *p != ' '; ++p) 141 if (*p == '(') 142 return; 143 144 if (*p == '\0') 145 return; 146 147 name_end = p; 148 149 ++p; 150 if (*p == '\0') 151 return; 152 153 copy = XNEWVEC (char, name_end - buffer + 1); 154 memcpy (copy, buffer, name_end - buffer); 155 copy[name_end - buffer] = '\0'; 156 157 mhval = XNEW (struct macro_hash_value); 158 mhval->name = copy; 159 mhval->value = NULL; 160 161 hashval = htab_hash_string (copy); 162 slot = htab_find_slot_with_hash (macro_hash, mhval, hashval, NO_INSERT); 163 164 /* For simplicity, we force all names to be hidden by adding an 165 initial underscore, and let the user undo this as needed. */ 166 out_len = strlen (p) * 2 + 1; 167 out_buffer = XNEWVEC (char, out_len); 168 q = out_buffer; 169 saw_operand = false; 170 need_operand = false; 171 while (*p != '\0') 172 { 173 switch (*p) 174 { 175 case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': 176 case 'G': case 'H': case 'I': case 'J': case 'K': case 'L': 177 case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R': 178 case 'S': case 'T': case 'U': case 'V': case 'W': case 'X': 179 case 'Y': case 'Z': 180 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': 181 case 'g': case 'h': case 'i': case 'j': case 'k': case 'l': 182 case 'm': case 'n': case 'o': case 'p': case 'q': case 'r': 183 case 's': case 't': case 'u': case 'v': case 'w': case 'x': 184 case 'y': case 'z': 185 case '_': 186 { 187 /* The start of an identifier. Technically we should also 188 worry about UTF-8 identifiers, but they are not a 189 problem for practical uses of -fdump-go-spec so we 190 don't worry about them. */ 191 const char *start; 192 char *n; 193 struct macro_hash_value idval; 194 195 if (saw_operand) 196 goto unknown; 197 198 start = p; 199 while (ISALNUM (*p) || *p == '_') 200 ++p; 201 n = XALLOCAVEC (char, p - start + 1); 202 memcpy (n, start, p - start); 203 n[p - start] = '\0'; 204 idval.name = n; 205 idval.value = NULL; 206 if (htab_find (macro_hash, &idval) == NULL) 207 { 208 /* This is a reference to a name which was not defined 209 as a macro. */ 210 goto unknown; 211 } 212 213 *q++ = '_'; 214 memcpy (q, start, p - start); 215 q += p - start; 216 217 saw_operand = true; 218 need_operand = false; 219 } 220 break; 221 222 case '.': 223 if (!ISDIGIT (p[1])) 224 goto unknown; 225 /* Fall through. */ 226 case '0': case '1': case '2': case '3': case '4': 227 case '5': case '6': case '7': case '8': case '9': 228 { 229 const char *start; 230 bool is_hex; 231 232 start = p; 233 is_hex = false; 234 if (*p == '0' && (p[1] == 'x' || p[1] == 'X')) 235 { 236 p += 2; 237 is_hex = true; 238 } 239 while (ISDIGIT (*p) || *p == '.' || *p == 'e' || *p == 'E' 240 || (is_hex 241 && ((*p >= 'a' && *p <= 'f') 242 || (*p >= 'A' && *p <= 'F')))) 243 ++p; 244 memcpy (q, start, p - start); 245 q += p - start; 246 while (*p == 'u' || *p == 'U' || *p == 'l' || *p == 'L' 247 || *p == 'f' || *p == 'F' 248 || *p == 'd' || *p == 'D') 249 { 250 /* Go doesn't use any of these trailing type 251 modifiers. */ 252 ++p; 253 } 254 255 /* We'll pick up the exponent, if any, as an 256 expression. */ 257 258 saw_operand = true; 259 need_operand = false; 260 } 261 break; 262 263 case ' ': case '\t': 264 *q++ = *p++; 265 break; 266 267 case '(': 268 /* Always OK, not part of an operand, presumed to start an 269 operand. */ 270 *q++ = *p++; 271 saw_operand = false; 272 need_operand = false; 273 break; 274 275 case ')': 276 /* OK if we don't need an operand, and presumed to indicate 277 an operand. */ 278 if (need_operand) 279 goto unknown; 280 *q++ = *p++; 281 saw_operand = true; 282 break; 283 284 case '+': case '-': 285 /* Always OK, but not part of an operand. */ 286 *q++ = *p++; 287 saw_operand = false; 288 break; 289 290 case '*': case '/': case '%': case '|': case '&': case '^': 291 /* Must be a binary operator. */ 292 if (!saw_operand) 293 goto unknown; 294 *q++ = *p++; 295 saw_operand = false; 296 need_operand = true; 297 break; 298 299 case '=': 300 *q++ = *p++; 301 if (*p != '=') 302 goto unknown; 303 /* Must be a binary operator. */ 304 if (!saw_operand) 305 goto unknown; 306 *q++ = *p++; 307 saw_operand = false; 308 need_operand = true; 309 break; 310 311 case '!': 312 *q++ = *p++; 313 if (*p == '=') 314 { 315 /* Must be a binary operator. */ 316 if (!saw_operand) 317 goto unknown; 318 *q++ = *p++; 319 saw_operand = false; 320 need_operand = true; 321 } 322 else 323 { 324 /* Must be a unary operator. */ 325 if (saw_operand) 326 goto unknown; 327 need_operand = true; 328 } 329 break; 330 331 case '<': case '>': 332 /* Must be a binary operand, may be << or >> or <= or >=. */ 333 if (!saw_operand) 334 goto unknown; 335 *q++ = *p++; 336 if (*p == *(p - 1) || *p == '=') 337 *q++ = *p++; 338 saw_operand = false; 339 need_operand = true; 340 break; 341 342 case '~': 343 /* Must be a unary operand, must be translated for Go. */ 344 if (saw_operand) 345 goto unknown; 346 *q++ = '^'; 347 p++; 348 need_operand = true; 349 break; 350 351 case '"': 352 case '\'': 353 { 354 char quote; 355 int count; 356 357 if (saw_operand) 358 goto unknown; 359 quote = *p; 360 *q++ = *p++; 361 count = 0; 362 while (*p != quote) 363 { 364 int c; 365 366 if (*p == '\0') 367 goto unknown; 368 369 ++count; 370 371 if (*p != '\\') 372 { 373 *q++ = *p++; 374 continue; 375 } 376 377 *q++ = *p++; 378 switch (*p) 379 { 380 case '0': case '1': case '2': case '3': 381 case '4': case '5': case '6': case '7': 382 c = 0; 383 while (*p >= '0' && *p <= '7') 384 { 385 *q++ = *p++; 386 ++c; 387 } 388 /* Go octal characters are always 3 389 digits. */ 390 if (c != 3) 391 goto unknown; 392 break; 393 394 case 'x': 395 *q++ = *p++; 396 c = 0; 397 while (ISXDIGIT (*p)) 398 { 399 *q++ = *p++; 400 ++c; 401 } 402 /* Go hex characters are always 2 digits. */ 403 if (c != 2) 404 goto unknown; 405 break; 406 407 case 'a': case 'b': case 'f': case 'n': case 'r': 408 case 't': case 'v': case '\\': case '\'': case '"': 409 *q++ = *p++; 410 break; 411 412 default: 413 goto unknown; 414 } 415 } 416 417 *q++ = *p++; 418 419 if (quote == '\'' && count != 1) 420 goto unknown; 421 422 saw_operand = true; 423 need_operand = false; 424 425 break; 426 } 427 428 default: 429 goto unknown; 430 } 431 } 432 433 if (need_operand) 434 goto unknown; 435 436 gcc_assert ((size_t) (q - out_buffer) < out_len); 437 *q = '\0'; 438 439 mhval->value = out_buffer; 440 441 if (slot == NULL) 442 { 443 slot = htab_find_slot_with_hash (macro_hash, mhval, hashval, INSERT); 444 gcc_assert (slot != NULL && *slot == NULL); 445 } 446 else 447 { 448 if (*slot != NULL) 449 macro_hash_del (*slot); 450 } 451 452 *slot = mhval; 453 454 return; 455 456 unknown: 457 fprintf (go_dump_file, "// unknowndefine %s\n", buffer); 458 if (slot != NULL) 459 htab_clear_slot (macro_hash, slot); 460 XDELETEVEC (out_buffer); 461 XDELETEVEC (copy); 462 } 463 464 /* A macro undef. */ 465 466 static void 467 go_undef (unsigned int lineno, const char *buffer) 468 { 469 struct macro_hash_value mhval; 470 void **slot; 471 472 real_debug_hooks->undef (lineno, buffer); 473 474 mhval.name = CONST_CAST (char *, buffer); 475 mhval.value = NULL; 476 slot = htab_find_slot (macro_hash, &mhval, NO_INSERT); 477 if (slot != NULL) 478 htab_clear_slot (macro_hash, slot); 479 } 480 481 /* A function or variable decl. */ 482 483 static void 484 go_decl (tree decl) 485 { 486 if (!TREE_PUBLIC (decl) 487 || DECL_IS_BUILTIN (decl) 488 || DECL_NAME (decl) == NULL_TREE) 489 return; 490 vec_safe_push (queue, decl); 491 } 492 493 /* A function decl. */ 494 495 static void 496 go_function_decl (tree decl) 497 { 498 real_debug_hooks->function_decl (decl); 499 go_decl (decl); 500 } 501 502 static void 503 go_early_global_decl (tree decl) 504 { 505 go_decl (decl); 506 if (TREE_CODE (decl) != FUNCTION_DECL || DECL_STRUCT_FUNCTION (decl) != NULL) 507 real_debug_hooks->early_global_decl (decl); 508 } 509 510 /* A global variable decl. */ 511 512 static void 513 go_late_global_decl (tree decl) 514 { 515 real_debug_hooks->late_global_decl (decl); 516 } 517 518 /* A type declaration. */ 519 520 static void 521 go_type_decl (tree decl, int local) 522 { 523 real_debug_hooks->type_decl (decl, local); 524 525 if (local || DECL_IS_BUILTIN (decl)) 526 return; 527 if (DECL_NAME (decl) == NULL_TREE 528 && (TYPE_NAME (TREE_TYPE (decl)) == NULL_TREE 529 || TREE_CODE (TYPE_NAME (TREE_TYPE (decl))) != IDENTIFIER_NODE) 530 && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE) 531 return; 532 vec_safe_push (queue, decl); 533 } 534 535 /* A container for the data we pass around when generating information 536 at the end of the compilation. */ 537 538 struct godump_container 539 { 540 /* DECLs that we have already seen. */ 541 hash_set<tree> decls_seen; 542 543 /* Types which may potentially have to be defined as dummy 544 types. */ 545 hash_set<const char *> pot_dummy_types; 546 547 /* Go keywords. */ 548 htab_t keyword_hash; 549 550 /* Global type definitions. */ 551 htab_t type_hash; 552 553 /* Invalid types. */ 554 htab_t invalid_hash; 555 556 /* Obstack used to write out a type definition. */ 557 struct obstack type_obstack; 558 }; 559 560 /* Append an IDENTIFIER_NODE to OB. */ 561 562 static void 563 go_append_string (struct obstack *ob, tree id) 564 { 565 obstack_grow (ob, IDENTIFIER_POINTER (id), IDENTIFIER_LENGTH (id)); 566 } 567 568 /* Given an integer PRECISION in bits, returns a constant string that is the 569 matching go int or uint type (depending on the IS_UNSIGNED flag). Returns a 570 NULL pointer if there is no matching go type. */ 571 572 static const char * 573 go_get_uinttype_for_precision (unsigned int precision, bool is_unsigned) 574 { 575 switch (precision) 576 { 577 case 8: 578 return is_unsigned ? "uint8" : "int8"; 579 case 16: 580 return is_unsigned ? "uint16" : "int16"; 581 case 32: 582 return is_unsigned ? "uint32" : "int32"; 583 case 64: 584 return is_unsigned ? "uint64" : "int64"; 585 default: 586 return NULL; 587 } 588 } 589 590 /* Append an artificial variable name with the suffix _INDEX to OB. Returns 591 INDEX + 1. */ 592 593 static unsigned int 594 go_append_artificial_name (struct obstack *ob, unsigned int index) 595 { 596 char buf[100]; 597 598 /* FIXME: identifier may not be unique. */ 599 obstack_grow (ob, "Godump_", 7); 600 snprintf (buf, sizeof buf, "%u", index); 601 obstack_grow (ob, buf, strlen (buf)); 602 603 return index + 1; 604 } 605 606 /* Append the variable name from DECL to OB. If the name is in the 607 KEYWORD_HASH, prepend an '_'. */ 608 609 static void 610 go_append_decl_name (struct obstack *ob, tree decl, htab_t keyword_hash) 611 { 612 const char *var_name; 613 void **slot; 614 615 /* Start variable name with an underscore if a keyword. */ 616 var_name = IDENTIFIER_POINTER (DECL_NAME (decl)); 617 slot = htab_find_slot (keyword_hash, var_name, NO_INSERT); 618 if (slot != NULL) 619 obstack_1grow (ob, '_'); 620 go_append_string (ob, DECL_NAME (decl)); 621 } 622 623 /* Appends a byte array with the necessary number of elements and the name 624 "Godump_INDEX_pad" to pad from FROM_OFFSET to TO_OFFSET to OB assuming that 625 the next field is automatically aligned to ALIGN_UNITS. Returns INDEX + 1, 626 or INDEX if no padding had to be appended. The resulting offset where the 627 next field is allocated is returned through RET_OFFSET. */ 628 629 static unsigned int 630 go_append_padding (struct obstack *ob, unsigned int from_offset, 631 unsigned int to_offset, unsigned int align_units, 632 unsigned int index, unsigned int *ret_offset) 633 { 634 if (from_offset % align_units > 0) 635 from_offset += align_units - (from_offset % align_units); 636 gcc_assert (to_offset >= from_offset); 637 if (to_offset > from_offset) 638 { 639 char buf[100]; 640 641 index = go_append_artificial_name (ob, index); 642 snprintf (buf, sizeof buf, "_pad [%u]byte; ", to_offset - from_offset); 643 obstack_grow (ob, buf, strlen (buf)); 644 } 645 *ret_offset = to_offset; 646 647 return index; 648 } 649 650 /* Appends an array of type TYPE_STRING with zero elements and the name 651 "Godump_INDEX_align" to OB. If TYPE_STRING is a null pointer, ERROR_STRING 652 is appended instead of the type. Returns INDEX + 1. */ 653 654 static unsigned int 655 go_force_record_alignment (struct obstack *ob, const char *type_string, 656 unsigned int index, const char *error_string) 657 { 658 index = go_append_artificial_name (ob, index); 659 obstack_grow (ob, "_align ", 7); 660 if (type_string == NULL) 661 obstack_grow (ob, error_string, strlen (error_string)); 662 else 663 { 664 obstack_grow (ob, "[0]", 3); 665 obstack_grow (ob, type_string, strlen (type_string)); 666 } 667 obstack_grow (ob, "; ", 2); 668 669 return index; 670 } 671 672 /* Write the Go version of TYPE to CONTAINER->TYPE_OBSTACK. 673 USE_TYPE_NAME is true if we can simply use a type name here without 674 needing to define it. IS_FUNC_OK is true if we can output a func 675 type here; the "func" keyword will already have been added. 676 Return true if the type can be represented in Go, false otherwise. 677 P_ART_I is used for indexing artificial elements in nested structures and 678 should always be a NULL pointer when called, except by certain recursive 679 calls from go_format_type() itself. */ 680 681 static bool 682 go_format_type (struct godump_container *container, tree type, 683 bool use_type_name, bool is_func_ok, unsigned int *p_art_i, 684 bool is_anon_record_or_union) 685 { 686 bool ret; 687 struct obstack *ob; 688 unsigned int art_i_dummy; 689 bool is_union = false; 690 691 if (p_art_i == NULL) 692 { 693 art_i_dummy = 0; 694 p_art_i = &art_i_dummy; 695 } 696 ret = true; 697 ob = &container->type_obstack; 698 699 if (TYPE_NAME (type) != NULL_TREE 700 && (container->decls_seen.contains (type) 701 || container->decls_seen.contains (TYPE_NAME (type))) 702 && (AGGREGATE_TYPE_P (type) 703 || POINTER_TYPE_P (type) 704 || TREE_CODE (type) == FUNCTION_TYPE)) 705 { 706 tree name; 707 void **slot; 708 709 name = TYPE_IDENTIFIER (type); 710 711 slot = htab_find_slot (container->invalid_hash, IDENTIFIER_POINTER (name), 712 NO_INSERT); 713 if (slot != NULL) 714 ret = false; 715 716 obstack_1grow (ob, '_'); 717 go_append_string (ob, name); 718 return ret; 719 } 720 721 container->decls_seen.add (type); 722 723 switch (TREE_CODE (type)) 724 { 725 case TYPE_DECL: 726 { 727 void **slot; 728 729 slot = htab_find_slot (container->invalid_hash, 730 IDENTIFIER_POINTER (DECL_NAME (type)), 731 NO_INSERT); 732 if (slot != NULL) 733 ret = false; 734 735 obstack_1grow (ob, '_'); 736 go_append_string (ob, DECL_NAME (type)); 737 } 738 break; 739 740 case ENUMERAL_TYPE: 741 case INTEGER_TYPE: 742 { 743 const char *s; 744 char buf[100]; 745 746 s = go_get_uinttype_for_precision (TYPE_PRECISION (type), 747 TYPE_UNSIGNED (type)); 748 if (s == NULL) 749 { 750 snprintf (buf, sizeof buf, "INVALID-int-%u%s", 751 TYPE_PRECISION (type), 752 TYPE_UNSIGNED (type) ? "u" : ""); 753 s = buf; 754 ret = false; 755 } 756 obstack_grow (ob, s, strlen (s)); 757 } 758 break; 759 760 case REAL_TYPE: 761 { 762 const char *s; 763 char buf[100]; 764 765 switch (TYPE_PRECISION (type)) 766 { 767 case 32: 768 s = "float32"; 769 break; 770 case 64: 771 s = "float64"; 772 break; 773 default: 774 snprintf (buf, sizeof buf, "INVALID-float-%u", 775 TYPE_PRECISION (type)); 776 s = buf; 777 ret = false; 778 break; 779 } 780 obstack_grow (ob, s, strlen (s)); 781 } 782 break; 783 784 case COMPLEX_TYPE: 785 { 786 const char *s; 787 char buf[100]; 788 tree real_type; 789 790 real_type = TREE_TYPE (type); 791 if (TREE_CODE (real_type) == REAL_TYPE) 792 { 793 switch (TYPE_PRECISION (real_type)) 794 { 795 case 32: 796 s = "complex64"; 797 break; 798 case 64: 799 s = "complex128"; 800 break; 801 default: 802 snprintf (buf, sizeof buf, "INVALID-complex-%u", 803 2 * TYPE_PRECISION (real_type)); 804 s = buf; 805 ret = false; 806 break; 807 } 808 } 809 else 810 { 811 s = "INVALID-complex-non-real"; 812 ret = false; 813 } 814 obstack_grow (ob, s, strlen (s)); 815 } 816 break; 817 818 case BOOLEAN_TYPE: 819 obstack_grow (ob, "bool", 4); 820 break; 821 822 case POINTER_TYPE: 823 if (use_type_name 824 && TYPE_NAME (TREE_TYPE (type)) != NULL_TREE 825 && (RECORD_OR_UNION_TYPE_P (TREE_TYPE (type)) 826 || (POINTER_TYPE_P (TREE_TYPE (type)) 827 && (TREE_CODE (TREE_TYPE (TREE_TYPE (type))) 828 == FUNCTION_TYPE)))) 829 { 830 tree name; 831 void **slot; 832 833 name = TYPE_IDENTIFIER (TREE_TYPE (type)); 834 835 slot = htab_find_slot (container->invalid_hash, 836 IDENTIFIER_POINTER (name), NO_INSERT); 837 if (slot != NULL) 838 ret = false; 839 840 obstack_grow (ob, "*_", 2); 841 go_append_string (ob, name); 842 843 /* The pointer here can be used without the struct or union 844 definition. So this struct or union is a potential dummy 845 type. */ 846 if (RECORD_OR_UNION_TYPE_P (TREE_TYPE (type))) 847 container->pot_dummy_types.add (IDENTIFIER_POINTER (name)); 848 849 return ret; 850 } 851 if (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE) 852 obstack_grow (ob, "func", 4); 853 else 854 obstack_1grow (ob, '*'); 855 if (VOID_TYPE_P (TREE_TYPE (type))) 856 obstack_grow (ob, "byte", 4); 857 else 858 { 859 if (!go_format_type (container, TREE_TYPE (type), use_type_name, 860 true, NULL, false)) 861 ret = false; 862 } 863 break; 864 865 case ARRAY_TYPE: 866 obstack_1grow (ob, '['); 867 if (TYPE_DOMAIN (type) != NULL_TREE 868 && TREE_CODE (TYPE_DOMAIN (type)) == INTEGER_TYPE 869 && TYPE_MIN_VALUE (TYPE_DOMAIN (type)) != NULL_TREE 870 && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (type))) == INTEGER_CST 871 && tree_int_cst_sgn (TYPE_MIN_VALUE (TYPE_DOMAIN (type))) == 0 872 && TYPE_MAX_VALUE (TYPE_DOMAIN (type)) != NULL_TREE 873 && TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) == INTEGER_CST 874 && tree_fits_shwi_p (TYPE_MAX_VALUE (TYPE_DOMAIN (type)))) 875 { 876 char buf[100]; 877 878 snprintf (buf, sizeof buf, HOST_WIDE_INT_PRINT_DEC "+1", 879 tree_to_shwi (TYPE_MAX_VALUE (TYPE_DOMAIN (type)))); 880 obstack_grow (ob, buf, strlen (buf)); 881 } 882 else 883 obstack_1grow (ob, '0'); 884 obstack_1grow (ob, ']'); 885 if (!go_format_type (container, TREE_TYPE (type), use_type_name, false, 886 NULL, false)) 887 ret = false; 888 break; 889 890 case UNION_TYPE: 891 is_union = true; 892 /* Fall through to RECORD_TYPE case. */ 893 gcc_fallthrough (); 894 case RECORD_TYPE: 895 { 896 unsigned int prev_field_end; 897 unsigned int known_alignment; 898 tree field; 899 bool emitted_a_field; 900 901 /* FIXME: Why is this necessary? Without it we can get a core 902 dump on the s390x headers, or from a file containing simply 903 "typedef struct S T;". */ 904 layout_type (type); 905 906 prev_field_end = 0; 907 known_alignment = 1; 908 /* Anonymous records and unions are flattened, i.e. they are not put 909 into "struct { ... }". */ 910 if (!is_anon_record_or_union) 911 obstack_grow (ob, "struct { ", 9); 912 for (field = TYPE_FIELDS (type), emitted_a_field = false; 913 field != NULL_TREE; 914 field = TREE_CHAIN (field)) 915 { 916 if (TREE_CODE (field) != FIELD_DECL) 917 continue; 918 if (DECL_BIT_FIELD (field)) 919 /* Bit fields are replaced by padding. */ 920 continue; 921 /* Only the first non-bitfield field is emitted for unions. */ 922 if (!is_union || !emitted_a_field) 923 { 924 /* Emit the field. */ 925 bool field_ok; 926 bool is_anon_substructure; 927 unsigned int decl_align_unit; 928 unsigned int decl_offset; 929 930 field_ok = true; 931 emitted_a_field = true; 932 is_anon_substructure = 933 (DECL_NAME (field) == NULL 934 && (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE 935 || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)); 936 /* Keep track of the alignment of named substructures, either 937 of the whole record, or the alignment of the emitted field 938 (for unions). */ 939 decl_align_unit = DECL_ALIGN_UNIT (field); 940 if (!is_anon_substructure && decl_align_unit > known_alignment) 941 known_alignment = decl_align_unit; 942 /* Pad to start of field. */ 943 decl_offset = 944 TREE_INT_CST_LOW (DECL_FIELD_OFFSET (field)) 945 + precision_to_units 946 (TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (field))); 947 { 948 unsigned int align_unit; 949 950 /* For anonymous records and unions there is no automatic 951 structure alignment, so use 1 as the alignment. */ 952 align_unit = (is_anon_substructure) ? 1 : decl_align_unit; 953 *p_art_i = go_append_padding 954 (ob, prev_field_end, decl_offset, align_unit, *p_art_i, 955 &prev_field_end); 956 } 957 if (DECL_SIZE_UNIT (field)) 958 prev_field_end += 959 TREE_INT_CST_LOW (DECL_SIZE_UNIT (field)); 960 /* Emit the field name, but not for anonymous records and 961 unions. */ 962 if (!is_anon_substructure) 963 { 964 if ((DECL_NAME (field) == NULL)) 965 *p_art_i = go_append_artificial_name (ob, *p_art_i); 966 else 967 go_append_decl_name 968 (ob, field, container->keyword_hash); 969 obstack_1grow (ob, ' '); 970 } 971 /* Do not expand type if a record or union type or a function 972 pointer. */ 973 if (TYPE_NAME (TREE_TYPE (field)) != NULL_TREE 974 && (RECORD_OR_UNION_TYPE_P (TREE_TYPE (field)) 975 || (POINTER_TYPE_P (TREE_TYPE (field)) 976 && (TREE_CODE (TREE_TYPE (TREE_TYPE (field))) 977 == FUNCTION_TYPE)))) 978 { 979 tree name; 980 void **slot; 981 982 name = TYPE_IDENTIFIER (TREE_TYPE (field)); 983 984 slot = htab_find_slot (container->invalid_hash, 985 IDENTIFIER_POINTER (name), 986 NO_INSERT); 987 if (slot != NULL) 988 field_ok = false; 989 990 obstack_1grow (ob, '_'); 991 go_append_string (ob, name); 992 } 993 else 994 { 995 if (!go_format_type (container, TREE_TYPE (field), true, 996 false, p_art_i, is_anon_substructure)) 997 field_ok = false; 998 } 999 if (!is_anon_substructure) 1000 obstack_grow (ob, "; ", 2); 1001 if (!field_ok) 1002 ret = false; 1003 } 1004 } 1005 /* Padding. */ 1006 *p_art_i = go_append_padding (ob, prev_field_end, 1007 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (type)), 1008 1, *p_art_i, &prev_field_end); 1009 /* Alignment. */ 1010 if (!is_anon_record_or_union 1011 && known_alignment < TYPE_ALIGN_UNIT (type)) 1012 { 1013 const char *s; 1014 char buf[100]; 1015 1016 /* Enforce proper record alignment. */ 1017 s = go_get_uinttype_for_precision 1018 (TYPE_ALIGN (type), TYPE_UNSIGNED (type)); 1019 if (s == NULL) 1020 { 1021 snprintf (buf, sizeof buf, "INVALID-int-%u%s", 1022 TYPE_ALIGN (type), TYPE_UNSIGNED (type) ? "u" : ""); 1023 s = buf; 1024 ret = false; 1025 } 1026 *p_art_i = go_force_record_alignment (ob, s, *p_art_i, buf); 1027 } 1028 if (!is_anon_record_or_union) 1029 obstack_1grow (ob, '}'); 1030 } 1031 break; 1032 1033 case FUNCTION_TYPE: 1034 { 1035 tree arg_type; 1036 bool is_varargs; 1037 tree result; 1038 function_args_iterator iter; 1039 bool seen_arg; 1040 1041 /* Go has no way to write a type which is a function but not a 1042 pointer to a function. */ 1043 if (!is_func_ok) 1044 { 1045 obstack_grow (ob, "func*", 5); 1046 ret = false; 1047 } 1048 1049 obstack_1grow (ob, '('); 1050 is_varargs = stdarg_p (type); 1051 seen_arg = false; 1052 FOREACH_FUNCTION_ARGS (type, arg_type, iter) 1053 { 1054 if (VOID_TYPE_P (arg_type)) 1055 break; 1056 if (seen_arg) 1057 obstack_grow (ob, ", ", 2); 1058 if (!go_format_type (container, arg_type, true, false, NULL, false)) 1059 ret = false; 1060 seen_arg = true; 1061 } 1062 if (is_varargs) 1063 { 1064 if (prototype_p (type)) 1065 obstack_grow (ob, ", ", 2); 1066 obstack_grow (ob, "...interface{}", 14); 1067 } 1068 obstack_1grow (ob, ')'); 1069 1070 result = TREE_TYPE (type); 1071 if (!VOID_TYPE_P (result)) 1072 { 1073 obstack_1grow (ob, ' '); 1074 if (!go_format_type (container, result, use_type_name, false, NULL, 1075 false)) 1076 ret = false; 1077 } 1078 } 1079 break; 1080 1081 default: 1082 obstack_grow (ob, "INVALID-type", 12); 1083 ret = false; 1084 break; 1085 } 1086 1087 return ret; 1088 } 1089 1090 /* Output the type which was built on the type obstack, and then free 1091 it. */ 1092 1093 static void 1094 go_output_type (struct godump_container *container) 1095 { 1096 struct obstack *ob; 1097 1098 ob = &container->type_obstack; 1099 obstack_1grow (ob, '\0'); 1100 fputs ((char *) obstack_base (ob), go_dump_file); 1101 obstack_free (ob, obstack_base (ob)); 1102 } 1103 1104 /* Output a function declaration. */ 1105 1106 static void 1107 go_output_fndecl (struct godump_container *container, tree decl) 1108 { 1109 if (!go_format_type (container, TREE_TYPE (decl), false, true, NULL, false)) 1110 fprintf (go_dump_file, "// "); 1111 fprintf (go_dump_file, "func _%s ", 1112 IDENTIFIER_POINTER (DECL_NAME (decl))); 1113 go_output_type (container); 1114 fprintf (go_dump_file, " __asm__(\"%s\")\n", 1115 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))); 1116 } 1117 1118 /* Output a typedef or something like a struct definition. */ 1119 1120 static void 1121 go_output_typedef (struct godump_container *container, tree decl) 1122 { 1123 /* If we have an enum type, output the enum constants 1124 separately. */ 1125 if (TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE 1126 && TYPE_SIZE (TREE_TYPE (decl)) != 0 1127 && !container->decls_seen.contains (TREE_TYPE (decl)) 1128 && (TYPE_CANONICAL (TREE_TYPE (decl)) == NULL_TREE 1129 || !container->decls_seen.contains 1130 (TYPE_CANONICAL (TREE_TYPE (decl))))) 1131 { 1132 tree element; 1133 1134 for (element = TYPE_VALUES (TREE_TYPE (decl)); 1135 element != NULL_TREE; 1136 element = TREE_CHAIN (element)) 1137 { 1138 const char *name; 1139 struct macro_hash_value *mhval; 1140 void **slot; 1141 char buf[WIDE_INT_PRINT_BUFFER_SIZE]; 1142 1143 name = IDENTIFIER_POINTER (TREE_PURPOSE (element)); 1144 1145 /* Sometimes a name will be defined as both an enum constant 1146 and a macro. Avoid duplicate definition errors by 1147 treating enum constants as macros. */ 1148 mhval = XNEW (struct macro_hash_value); 1149 mhval->name = xstrdup (name); 1150 mhval->value = NULL; 1151 slot = htab_find_slot (macro_hash, mhval, INSERT); 1152 if (*slot != NULL) 1153 macro_hash_del (*slot); 1154 1155 if (tree_fits_shwi_p (TREE_VALUE (element))) 1156 snprintf (buf, sizeof buf, HOST_WIDE_INT_PRINT_DEC, 1157 tree_to_shwi (TREE_VALUE (element))); 1158 else if (tree_fits_uhwi_p (TREE_VALUE (element))) 1159 snprintf (buf, sizeof buf, HOST_WIDE_INT_PRINT_UNSIGNED, 1160 tree_to_uhwi (TREE_VALUE (element))); 1161 else 1162 print_hex (wi::to_wide (element), buf); 1163 1164 mhval->value = xstrdup (buf); 1165 *slot = mhval; 1166 } 1167 container->decls_seen.add (TREE_TYPE (decl)); 1168 if (TYPE_CANONICAL (TREE_TYPE (decl)) != NULL_TREE) 1169 container->decls_seen.add (TYPE_CANONICAL (TREE_TYPE (decl))); 1170 } 1171 1172 if (DECL_NAME (decl) != NULL_TREE) 1173 { 1174 void **slot; 1175 const char *type; 1176 1177 type = IDENTIFIER_POINTER (DECL_NAME (decl)); 1178 /* If type defined already, skip. */ 1179 slot = htab_find_slot (container->type_hash, type, INSERT); 1180 if (*slot != NULL) 1181 return; 1182 *slot = CONST_CAST (void *, (const void *) type); 1183 1184 if (!go_format_type (container, TREE_TYPE (decl), false, false, NULL, 1185 false)) 1186 { 1187 fprintf (go_dump_file, "// "); 1188 slot = htab_find_slot (container->invalid_hash, type, INSERT); 1189 *slot = CONST_CAST (void *, (const void *) type); 1190 } 1191 fprintf (go_dump_file, "type _%s ", 1192 IDENTIFIER_POINTER (DECL_NAME (decl))); 1193 go_output_type (container); 1194 1195 if (RECORD_OR_UNION_TYPE_P (TREE_TYPE (decl))) 1196 { 1197 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (decl)); 1198 1199 if (size > 0) 1200 fprintf (go_dump_file, 1201 "\nconst _sizeof_%s = " HOST_WIDE_INT_PRINT_DEC, 1202 IDENTIFIER_POINTER (DECL_NAME (decl)), 1203 size); 1204 } 1205 1206 container->decls_seen.add (decl); 1207 } 1208 else if (RECORD_OR_UNION_TYPE_P (TREE_TYPE (decl))) 1209 { 1210 void **slot; 1211 const char *type; 1212 HOST_WIDE_INT size; 1213 1214 type = IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE ((decl)))); 1215 /* If type defined already, skip. */ 1216 slot = htab_find_slot (container->type_hash, type, INSERT); 1217 if (*slot != NULL) 1218 return; 1219 *slot = CONST_CAST (void *, (const void *) type); 1220 1221 if (!go_format_type (container, TREE_TYPE (decl), false, false, NULL, 1222 false)) 1223 { 1224 fprintf (go_dump_file, "// "); 1225 slot = htab_find_slot (container->invalid_hash, type, INSERT); 1226 *slot = CONST_CAST (void *, (const void *) type); 1227 } 1228 fprintf (go_dump_file, "type _%s ", 1229 IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (decl)))); 1230 go_output_type (container); 1231 1232 size = int_size_in_bytes (TREE_TYPE (decl)); 1233 if (size > 0) 1234 fprintf (go_dump_file, 1235 "\nconst _sizeof_%s = " HOST_WIDE_INT_PRINT_DEC, 1236 IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (decl))), 1237 size); 1238 } 1239 else 1240 return; 1241 1242 fprintf (go_dump_file, "\n"); 1243 } 1244 1245 /* Output a variable. */ 1246 1247 static void 1248 go_output_var (struct godump_container *container, tree decl) 1249 { 1250 bool is_valid; 1251 tree type_name; 1252 tree id; 1253 1254 if (container->decls_seen.contains (decl) 1255 || container->decls_seen.contains (DECL_NAME (decl))) 1256 return; 1257 container->decls_seen.add (decl); 1258 container->decls_seen.add (DECL_NAME (decl)); 1259 1260 type_name = TYPE_NAME (TREE_TYPE (decl)); 1261 id = NULL_TREE; 1262 if (type_name != NULL_TREE && TREE_CODE (type_name) == IDENTIFIER_NODE) 1263 id = type_name; 1264 else if (type_name != NULL_TREE && TREE_CODE (type_name) == TYPE_DECL 1265 && DECL_SOURCE_LOCATION (type_name) != BUILTINS_LOCATION 1266 && DECL_NAME (type_name)) 1267 id = DECL_NAME (type_name); 1268 if (id != NULL_TREE 1269 && (!htab_find_slot (container->type_hash, IDENTIFIER_POINTER (id), 1270 NO_INSERT) 1271 || htab_find_slot (container->invalid_hash, IDENTIFIER_POINTER (id), 1272 NO_INSERT))) 1273 id = NULL_TREE; 1274 if (id != NULL_TREE) 1275 { 1276 struct obstack *ob; 1277 1278 ob = &container->type_obstack; 1279 obstack_1grow (ob, '_'); 1280 go_append_string (ob, id); 1281 is_valid = htab_find_slot (container->type_hash, IDENTIFIER_POINTER (id), 1282 NO_INSERT) != NULL; 1283 } 1284 else 1285 is_valid = go_format_type (container, TREE_TYPE (decl), true, false, NULL, 1286 false); 1287 if (is_valid 1288 && htab_find_slot (container->type_hash, 1289 IDENTIFIER_POINTER (DECL_NAME (decl)), 1290 NO_INSERT) != NULL) 1291 { 1292 /* There is already a type with this name, probably from a 1293 struct tag. Prefer the type to the variable. */ 1294 is_valid = false; 1295 } 1296 if (!is_valid) 1297 fprintf (go_dump_file, "// "); 1298 1299 fprintf (go_dump_file, "var _%s ", 1300 IDENTIFIER_POINTER (DECL_NAME (decl))); 1301 go_output_type (container); 1302 fprintf (go_dump_file, "\n"); 1303 1304 /* Sometimes an extern variable is declared with an unknown struct 1305 type. */ 1306 if (type_name != NULL_TREE && RECORD_OR_UNION_TYPE_P (TREE_TYPE (decl))) 1307 { 1308 if (TREE_CODE (type_name) == IDENTIFIER_NODE) 1309 container->pot_dummy_types.add (IDENTIFIER_POINTER (type_name)); 1310 else if (TREE_CODE (type_name) == TYPE_DECL) 1311 container->pot_dummy_types.add 1312 (IDENTIFIER_POINTER (DECL_NAME (type_name))); 1313 } 1314 } 1315 1316 /* Output the final value of a preprocessor macro or enum constant. 1317 This is called via htab_traverse_noresize. */ 1318 1319 static int 1320 go_print_macro (void **slot, void *arg ATTRIBUTE_UNUSED) 1321 { 1322 struct macro_hash_value *mhval = (struct macro_hash_value *) *slot; 1323 fprintf (go_dump_file, "const _%s = %s\n", mhval->name, mhval->value); 1324 return 1; 1325 } 1326 1327 /* Build a hash table with the Go keywords. */ 1328 1329 static const char * const keywords[] = { 1330 "__asm__", "break", "case", "chan", "const", "continue", "default", 1331 "defer", "else", "fallthrough", "for", "func", "go", "goto", "if", 1332 "import", "interface", "map", "package", "range", "return", "select", 1333 "struct", "switch", "type", "var" 1334 }; 1335 1336 static void 1337 keyword_hash_init (struct godump_container *container) 1338 { 1339 size_t i; 1340 size_t count = sizeof (keywords) / sizeof (keywords[0]); 1341 void **slot; 1342 1343 for (i = 0; i < count; i++) 1344 { 1345 slot = htab_find_slot (container->keyword_hash, keywords[i], INSERT); 1346 *slot = CONST_CAST (void *, (const void *) keywords[i]); 1347 } 1348 } 1349 1350 /* Traversing the pot_dummy_types and seeing which types are present 1351 in the global types hash table and creating dummy definitions if 1352 not found. This function is invoked by hash_set::traverse. */ 1353 1354 bool 1355 find_dummy_types (const char *const &ptr, godump_container *adata) 1356 { 1357 struct godump_container *data = (struct godump_container *) adata; 1358 const char *type = (const char *) ptr; 1359 void **slot; 1360 void **islot; 1361 1362 slot = htab_find_slot (data->type_hash, type, NO_INSERT); 1363 islot = htab_find_slot (data->invalid_hash, type, NO_INSERT); 1364 if (slot == NULL || islot != NULL) 1365 fprintf (go_dump_file, "type _%s struct {}\n", type); 1366 return true; 1367 } 1368 1369 /* Output symbols. */ 1370 1371 static void 1372 go_finish (const char *filename) 1373 { 1374 struct godump_container container; 1375 unsigned int ix; 1376 tree decl; 1377 1378 real_debug_hooks->finish (filename); 1379 1380 container.type_hash = htab_create (100, htab_hash_string, 1381 string_hash_eq, NULL); 1382 container.invalid_hash = htab_create (10, htab_hash_string, 1383 string_hash_eq, NULL); 1384 container.keyword_hash = htab_create (50, htab_hash_string, 1385 string_hash_eq, NULL); 1386 obstack_init (&container.type_obstack); 1387 1388 keyword_hash_init (&container); 1389 1390 FOR_EACH_VEC_SAFE_ELT (queue, ix, decl) 1391 { 1392 switch (TREE_CODE (decl)) 1393 { 1394 case FUNCTION_DECL: 1395 go_output_fndecl (&container, decl); 1396 break; 1397 1398 case TYPE_DECL: 1399 go_output_typedef (&container, decl); 1400 break; 1401 1402 case VAR_DECL: 1403 go_output_var (&container, decl); 1404 break; 1405 1406 default: 1407 gcc_unreachable (); 1408 } 1409 } 1410 1411 htab_traverse_noresize (macro_hash, go_print_macro, NULL); 1412 1413 /* To emit dummy definitions. */ 1414 container.pot_dummy_types.traverse<godump_container *, find_dummy_types> 1415 (&container); 1416 1417 htab_delete (container.type_hash); 1418 htab_delete (container.invalid_hash); 1419 htab_delete (container.keyword_hash); 1420 obstack_free (&container.type_obstack, NULL); 1421 1422 vec_free (queue); 1423 1424 if (fclose (go_dump_file) != 0) 1425 error ("could not close Go dump file: %m"); 1426 go_dump_file = NULL; 1427 } 1428 1429 /* Set up our hooks. */ 1430 1431 const struct gcc_debug_hooks * 1432 dump_go_spec_init (const char *filename, const struct gcc_debug_hooks *hooks) 1433 { 1434 go_dump_file = fopen (filename, "w"); 1435 if (go_dump_file == NULL) 1436 { 1437 error ("could not open Go dump file %qs: %m", filename); 1438 return hooks; 1439 } 1440 1441 go_debug_hooks = *hooks; 1442 real_debug_hooks = hooks; 1443 1444 go_debug_hooks.finish = go_finish; 1445 go_debug_hooks.define = go_define; 1446 go_debug_hooks.undef = go_undef; 1447 go_debug_hooks.function_decl = go_function_decl; 1448 go_debug_hooks.early_global_decl = go_early_global_decl; 1449 go_debug_hooks.late_global_decl = go_late_global_decl; 1450 go_debug_hooks.type_decl = go_type_decl; 1451 1452 macro_hash = htab_create (100, macro_hash_hashval, macro_hash_eq, 1453 macro_hash_del); 1454 1455 return &go_debug_hooks; 1456 } 1457 1458 #include "gt-godump.h" 1459