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

source code of gcc/godump.cc