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