LCOV - code coverage report
Current view: top level - gcc - godump.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 674 773 87.2 %
Date: 2020-04-04 11:58:09 Functions: 25 27 92.6 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

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

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.