contrib/gcc-5.0/gcc/godump.c

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