1 /* Output Go language descriptions of types.
2 Copyright (C) 2008-2021 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
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
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
27 All global names are output with a leading underscore, so that they
28 are all hidden in Go. */
32 #include "coretypes.h"
34 #include "diagnostic-core.h"
36 #include "stor-layout.h"
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. */
43 /* Our debug hooks. This is initialized by dump_go_spec_init. */
45 static struct gcc_debug_hooks go_debug_hooks
;
47 /* The real debug hooks. */
49 static const struct gcc_debug_hooks
*real_debug_hooks
;
51 /* The file where we should write information. */
53 static FILE *go_dump_file
;
55 /* A queue of decls to output. */
57 static GTY(()) vec
<tree
, va_gc
> *queue
;
59 struct godump_str_hash
: string_hash
, ggc_remove
<const char *> {};
61 /* A hash table of macros we have seen. */
63 static htab_t macro_hash
;
65 /* The type of a value in macro_hash. */
67 struct macro_hash_value
69 /* The name stored in the hash table. */
71 /* The value of the macro. */
75 /* Returns the number of units necessary to represent an integer with the given
76 PRECISION (in bits). */
78 static inline unsigned int
79 precision_to_units (unsigned int precision
)
81 return (precision
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
;
84 /* Calculate the hash value for an entry in the macro hash table. */
87 macro_hash_hashval (const void *val
)
89 const struct macro_hash_value
*mhval
= (const struct macro_hash_value
*) val
;
90 return htab_hash_string (mhval
->name
);
93 /* Compare values in the macro hash table for equality. */
96 macro_hash_eq (const void *v1
, const void *v2
)
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 (mhv1
->name
, mhv2
->name
) == 0;
103 /* Free values deleted from the macro hash table. */
106 macro_hash_del (void *v
)
108 struct macro_hash_value
*mhv
= (struct macro_hash_value
*) v
;
109 XDELETEVEC (mhv
->name
);
110 XDELETEVEC (mhv
->value
);
114 /* A macro definition. */
117 go_define (unsigned int lineno
, const char *buffer
)
120 const char *name_end
;
126 struct macro_hash_value
*mhval
;
131 real_debug_hooks
->define (lineno
, buffer
);
133 /* Skip macro functions. */
134 for (p
= buffer
; *p
!= '\0' && *p
!= ' '; ++p
)
147 copy
= XNEWVEC (char, name_end
- buffer
+ 1);
148 memcpy (copy
, buffer
, name_end
- buffer
);
149 copy
[name_end
- buffer
] = '\0';
151 mhval
= XNEW (struct macro_hash_value
);
155 hashval
= htab_hash_string (copy
);
156 slot
= htab_find_slot_with_hash (macro_hash
, mhval
, hashval
, NO_INSERT
);
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 (p
) * 2 + 1;
161 out_buffer
= XNEWVEC (char, out_len
);
164 need_operand
= false;
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':
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':
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. */
187 struct macro_hash_value idval
;
193 while (ISALNUM (*p
) || *p
== '_')
195 n
= XALLOCAVEC (char, p
- start
+ 1);
196 memcpy (n
, start
, p
- start
);
200 if (htab_find (macro_hash
, &idval
) == NULL
)
202 /* This is a reference to a name which was not defined
208 memcpy (q
, start
, p
- start
);
212 need_operand
= false;
220 case '0': case '1': case '2': case '3': case '4':
221 case '5': case '6': case '7': case '8': case '9':
228 if (*p
== '0' && (p
[1] == 'x' || p
[1] == 'X'))
233 while (ISDIGIT (*p
) || *p
== '.' || *p
== 'e' || *p
== 'E'
235 && ((*p
>= 'a' && *p
<= 'f')
236 || (*p
>= 'A' && *p
<= 'F'))))
238 memcpy (q
, start
, p
- start
);
240 while (*p
== 'u' || *p
== 'U' || *p
== 'l' || *p
== 'L'
241 || *p
== 'f' || *p
== 'F'
242 || *p
== 'd' || *p
== 'D')
244 /* Go doesn't use any of these trailing type
249 /* We'll pick up the exponent, if any, as an
253 need_operand
= false;
262 /* Always OK, not part of an operand, presumed to start an
266 need_operand
= false;
270 /* OK if we don't need an operand, and presumed to indicate
279 /* Always OK, but not part of an operand. */
284 case '*': case '/': case '%': case '|': case '&': case '^':
285 /* Must be a binary operator. */
297 /* Must be a binary operator. */
309 /* Must be a binary operator. */
318 /* Must be a unary operator. */
326 /* Must be a binary operand, may be << or >> or <= or >=. */
330 if (*p
== *(p
- 1) || *p
== '=')
337 /* Must be a unary operand, must be translated for Go. */
374 case '0': case '1': case '2': case '3':
375 case '4': case '5': case '6': case '7':
377 while (*p
>= '0' && *p
<= '7')
382 /* Go octal characters are always 3
391 while (ISXDIGIT (*p
))
396 /* Go hex characters are always 2 digits. */
401 case 'a': case 'b': case 'f': case 'n': case 'r':
402 case 't': case 'v': case '\\': case '\'': case '"':
413 if (quote
== '\'' && count
!= 1)
417 need_operand
= false;
430 gcc_assert ((size_t) (q
- out_buffer
) < out_len
);
433 mhval
->value
= out_buffer
;
437 slot
= htab_find_slot_with_hash (macro_hash
, mhval
, hashval
, INSERT
);
438 gcc_assert (slot
!= NULL
&& *slot
== NULL
);
443 macro_hash_del (*slot
);
451 fprintf (go_dump_file
, "// unknowndefine %s\n", buffer
);
453 htab_clear_slot (macro_hash
, slot
);
454 XDELETEVEC (out_buffer
);
461 go_undef (unsigned int lineno
, const char *buffer
)
463 struct macro_hash_value mhval
;
466 real_debug_hooks
->undef (lineno
, buffer
);
468 mhval
.name
= CONST_CAST (char *, buffer
);
470 slot
= htab_find_slot (macro_hash
, &mhval
, NO_INSERT
);
472 htab_clear_slot (macro_hash
, slot
);
475 /* A function or variable decl. */
480 if (!TREE_PUBLIC (decl
)
481 || DECL_IS_UNDECLARED_BUILTIN (decl
)
482 || DECL_NAME (decl
) == NULL_TREE
)
484 vec_safe_push (queue
, decl
);
487 /* A function decl. */
490 go_function_decl (tree decl
)
492 real_debug_hooks
->function_decl (decl
);
497 go_early_global_decl (tree decl
)
500 if (TREE_CODE (decl
) != FUNCTION_DECL
|| DECL_STRUCT_FUNCTION (decl
) != NULL
)
501 real_debug_hooks
->early_global_decl (decl
);
504 /* A global variable decl. */
507 go_late_global_decl (tree decl
)
509 real_debug_hooks
->late_global_decl (decl
);
512 /* A type declaration. */
515 go_type_decl (tree decl
, int local
)
517 real_debug_hooks
->type_decl (decl
, local
);
519 if (local
|| DECL_IS_UNDECLARED_BUILTIN (decl
))
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
)
526 vec_safe_push (queue
, decl
);
529 /* A container for the data we pass around when generating information
530 at the end of the compilation. */
532 class godump_container
535 /* DECLs that we have already seen. */
536 hash_set
<tree
> decls_seen
;
538 /* Types which may potentially have to be defined as dummy
540 hash_set
<const char *, false, godump_str_hash
> pot_dummy_types
;
545 /* Global type definitions. */
551 /* Obstack used to write out a type definition. */
552 struct obstack type_obstack
;
555 /* Append an IDENTIFIER_NODE to OB. */
558 go_append_string (struct obstack
*ob
, tree id
)
560 obstack_grow (ob
, IDENTIFIER_POINTER (id
), IDENTIFIER_LENGTH (id
));
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. */
568 go_get_uinttype_for_precision (unsigned int precision
, bool is_unsigned
)
573 return is_unsigned
? "uint8" : "int8";
575 return is_unsigned
? "uint16" : "int16";
577 return is_unsigned
? "uint32" : "int32";
579 return is_unsigned
? "uint64" : "int64";
585 /* Append an artificial variable name with the suffix _INDEX to OB. Returns
589 go_append_artificial_name (struct obstack
*ob
, unsigned int index
)
593 /* FIXME: identifier may not be unique. */
594 obstack_grow (ob
, "Godump_", 7);
595 snprintf (buf
, sizeof buf
, "%u", index
);
596 obstack_grow (ob
, buf
, strlen (buf
));
601 /* Append the variable name from DECL to OB. If the name is in the
602 KEYWORD_HASH, prepend an '_'. */
605 go_append_decl_name (struct obstack
*ob
, tree decl
, htab_t keyword_hash
)
607 const char *var_name
;
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
);
614 obstack_1grow (ob
, '_');
615 go_append_string (ob
, DECL_NAME (decl
));
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. */
625 go_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
)
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
)
636 index
= go_append_artificial_name (ob
, index
);
637 snprintf (buf
, sizeof buf
, "_pad [%u]byte; ", to_offset
- from_offset
);
638 obstack_grow (ob
, buf
, strlen (buf
));
640 *ret_offset
= to_offset
;
645 /* Appends an array of type TYPE_STRING with zero elements and the name
646 "Godump_INDEX_align" to OB. If TYPE_STRING is a null pointer, ERROR_STRING
647 is appended instead of the type. Returns INDEX + 1. */
650 go_force_record_alignment (struct obstack
*ob
, const char *type_string
,
651 unsigned int index
, const char *error_string
)
653 index
= go_append_artificial_name (ob
, index
);
654 obstack_grow (ob
, "_align ", 7);
655 if (type_string
== NULL
)
656 obstack_grow (ob
, error_string
, strlen (error_string
));
659 obstack_grow (ob
, "[0]", 3);
660 obstack_grow (ob
, type_string
, strlen (type_string
));
662 obstack_grow (ob
, "; ", 2);
667 /* Write the Go version of TYPE to CONTAINER->TYPE_OBSTACK.
668 USE_TYPE_NAME is true if we can simply use a type name here without
669 needing to define it. IS_FUNC_OK is true if we can output a func
670 type here; the "func" keyword will already have been added.
671 Return true if the type can be represented in Go, false otherwise.
672 P_ART_I is used for indexing artificial elements in nested structures and
673 should always be a NULL pointer when called, except by certain recursive
674 calls from go_format_type() itself. */
677 go_format_type (class godump_container
*container
, tree type
,
678 bool use_type_name
, bool is_func_ok
, unsigned int *p_art_i
,
679 bool is_anon_record_or_union
)
683 unsigned int art_i_dummy
;
684 bool is_union
= false;
689 p_art_i
= &art_i_dummy
;
692 ob
= &container
->type_obstack
;
695 && TYPE_NAME (type
) != NULL_TREE
696 && (AGGREGATE_TYPE_P (type
)
697 || POINTER_TYPE_P (type
)
698 || TREE_CODE (type
) == FUNCTION_TYPE
))
703 /* References to complex builtin types cannot be translated to
705 if (DECL_P (TYPE_NAME (type
))
706 && DECL_IS_UNDECLARED_BUILTIN (TYPE_NAME (type
)))
709 name
= TYPE_IDENTIFIER (type
);
711 slot
= htab_find_slot (container
->invalid_hash
, IDENTIFIER_POINTER (name
),
716 /* References to incomplete structs are permitted in many
717 contexts, like behind a pointer or inside of a typedef. So
718 consider any referenced struct a potential dummy type. */
719 if (RECORD_OR_UNION_TYPE_P (type
))
720 container
->pot_dummy_types
.add (IDENTIFIER_POINTER (name
));
722 obstack_1grow (ob
, '_');
723 go_append_string (ob
, name
);
727 switch (TREE_CODE (type
))
733 slot
= htab_find_slot (container
->invalid_hash
,
734 IDENTIFIER_POINTER (DECL_NAME (type
)),
739 obstack_1grow (ob
, '_');
740 go_append_string (ob
, DECL_NAME (type
));
750 s
= go_get_uinttype_for_precision (TYPE_PRECISION (type
),
751 TYPE_UNSIGNED (type
));
754 snprintf (buf
, sizeof buf
, "INVALID-int-%u%s",
755 TYPE_PRECISION (type
),
756 TYPE_UNSIGNED (type
) ? "u" : "");
760 obstack_grow (ob
, s
, strlen (s
));
769 switch (TYPE_PRECISION (type
))
778 snprintf (buf
, sizeof buf
, "INVALID-float-%u",
779 TYPE_PRECISION (type
));
784 obstack_grow (ob
, s
, strlen (s
));
794 real_type
= TREE_TYPE (type
);
795 if (TREE_CODE (real_type
) == REAL_TYPE
)
797 switch (TYPE_PRECISION (real_type
))
806 snprintf (buf
, sizeof buf
, "INVALID-complex-%u",
807 2 * TYPE_PRECISION (real_type
));
815 s
= "INVALID-complex-non-real";
818 obstack_grow (ob
, s
, strlen (s
));
823 obstack_grow (ob
, "bool", 4);
827 if (TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
828 obstack_grow (ob
, "func", 4);
830 obstack_1grow (ob
, '*');
831 if (VOID_TYPE_P (TREE_TYPE (type
)))
832 obstack_grow (ob
, "byte", 4);
835 if (!go_format_type (container
, TREE_TYPE (type
), use_type_name
,
842 obstack_1grow (ob
, '[');
843 if (TYPE_DOMAIN (type
) != NULL_TREE
844 && TREE_CODE (TYPE_DOMAIN (type
)) == INTEGER_TYPE
845 && TYPE_MIN_VALUE (TYPE_DOMAIN (type
)) != NULL_TREE
846 && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (type
))) == INTEGER_CST
847 && tree_int_cst_sgn (TYPE_MIN_VALUE (TYPE_DOMAIN (type
))) == 0
848 && TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) != NULL_TREE
849 && TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (type
))) == INTEGER_CST
850 && tree_fits_shwi_p (TYPE_MAX_VALUE (TYPE_DOMAIN (type
))))
854 snprintf (buf
, sizeof buf
, HOST_WIDE_INT_PRINT_DEC
"+1",
855 tree_to_shwi (TYPE_MAX_VALUE (TYPE_DOMAIN (type
))));
856 obstack_grow (ob
, buf
, strlen (buf
));
859 obstack_1grow (ob
, '0');
860 obstack_1grow (ob
, ']');
861 if (!go_format_type (container
, TREE_TYPE (type
), use_type_name
, false,
868 /* Fall through to RECORD_TYPE case. */
872 unsigned int prev_field_end
;
873 unsigned int known_alignment
;
875 bool emitted_a_field
;
877 /* FIXME: Why is this necessary? Without it we can get a core
878 dump on the s390x headers, or from a file containing simply
879 "typedef struct S T;". */
884 /* Anonymous records and unions are flattened, i.e. they are not put
885 into "struct { ... }". */
886 if (!is_anon_record_or_union
)
887 obstack_grow (ob
, "struct { ", 9);
888 for (field
= TYPE_FIELDS (type
), emitted_a_field
= false;
890 field
= TREE_CHAIN (field
))
892 if (TREE_CODE (field
) != FIELD_DECL
)
894 if (DECL_BIT_FIELD (field
))
895 /* Bit fields are replaced by padding. */
897 /* Only the first non-bitfield field is emitted for unions. */
898 if (!is_union
|| !emitted_a_field
)
900 /* Emit the field. */
902 bool is_anon_substructure
;
903 unsigned int decl_align_unit
;
904 unsigned int decl_offset
;
907 emitted_a_field
= true;
908 is_anon_substructure
=
909 (DECL_NAME (field
) == NULL
910 && (TREE_CODE (TREE_TYPE (field
)) == RECORD_TYPE
911 || TREE_CODE (TREE_TYPE (field
)) == UNION_TYPE
));
912 /* Keep track of the alignment of named substructures, either
913 of the whole record, or the alignment of the emitted field
915 decl_align_unit
= DECL_ALIGN_UNIT (field
);
916 if (!is_anon_substructure
&& decl_align_unit
> known_alignment
)
917 known_alignment
= decl_align_unit
;
918 /* Pad to start of field. */
920 TREE_INT_CST_LOW (DECL_FIELD_OFFSET (field
))
922 (TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (field
)));
924 unsigned int align_unit
;
926 /* For anonymous records and unions there is no automatic
927 structure alignment, so use 1 as the alignment. */
928 align_unit
= (is_anon_substructure
) ? 1 : decl_align_unit
;
929 *p_art_i
= go_append_padding
930 (ob
, prev_field_end
, decl_offset
, align_unit
, *p_art_i
,
933 if (DECL_SIZE_UNIT (field
))
935 TREE_INT_CST_LOW (DECL_SIZE_UNIT (field
));
936 /* Emit the field name, but not for anonymous records and
938 if (!is_anon_substructure
)
940 if (DECL_NAME (field
) == NULL
)
941 *p_art_i
= go_append_artificial_name (ob
, *p_art_i
);
944 (ob
, field
, container
->keyword_hash
);
945 obstack_1grow (ob
, ' ');
947 /* Do not expand type if a record or union type or a function
949 if (TYPE_NAME (TREE_TYPE (field
)) != NULL_TREE
950 && (RECORD_OR_UNION_TYPE_P (TREE_TYPE (field
))
951 || (POINTER_TYPE_P (TREE_TYPE (field
))
952 && (TREE_CODE (TREE_TYPE (TREE_TYPE (field
)))
958 name
= TYPE_IDENTIFIER (TREE_TYPE (field
));
960 slot
= htab_find_slot (container
->invalid_hash
,
961 IDENTIFIER_POINTER (name
),
966 obstack_1grow (ob
, '_');
967 go_append_string (ob
, name
);
971 if (!go_format_type (container
, TREE_TYPE (field
), true,
972 false, p_art_i
, is_anon_substructure
))
975 if (!is_anon_substructure
)
976 obstack_grow (ob
, "; ", 2);
982 *p_art_i
= go_append_padding (ob
, prev_field_end
,
983 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (type
)),
984 1, *p_art_i
, &prev_field_end
);
986 if (!is_anon_record_or_union
987 && known_alignment
< TYPE_ALIGN_UNIT (type
))
992 /* Enforce proper record alignment. */
993 s
= go_get_uinttype_for_precision
994 (TYPE_ALIGN (type
), TYPE_UNSIGNED (type
));
997 snprintf (buf
, sizeof buf
, "INVALID-int-%u%s",
998 TYPE_ALIGN (type
), TYPE_UNSIGNED (type
) ? "u" : "");
1002 *p_art_i
= go_force_record_alignment (ob
, s
, *p_art_i
, buf
);
1004 if (!is_anon_record_or_union
)
1005 obstack_1grow (ob
, '}');
1014 function_args_iterator iter
;
1017 /* Go has no way to write a type which is a function but not a
1018 pointer to a function. */
1021 obstack_grow (ob
, "func*", 5);
1025 obstack_1grow (ob
, '(');
1026 is_varargs
= stdarg_p (type
);
1028 FOREACH_FUNCTION_ARGS (type
, arg_type
, iter
)
1030 if (VOID_TYPE_P (arg_type
))
1033 obstack_grow (ob
, ", ", 2);
1034 if (!go_format_type (container
, arg_type
, true, false, NULL
, false))
1040 if (prototype_p (type
))
1041 obstack_grow (ob
, ", ", 2);
1042 obstack_grow (ob
, "...interface{}", 14);
1044 obstack_1grow (ob
, ')');
1046 result
= TREE_TYPE (type
);
1047 if (!VOID_TYPE_P (result
))
1049 obstack_1grow (ob
, ' ');
1050 if (!go_format_type (container
, result
, use_type_name
, false, NULL
,
1058 obstack_grow (ob
, "INVALID-type", 12);
1066 /* Output the type which was built on the type obstack, and then free
1070 go_output_type (class godump_container
*container
)
1074 ob
= &container
->type_obstack
;
1075 obstack_1grow (ob
, '\0');
1076 fputs ((char *) obstack_base (ob
), go_dump_file
);
1077 obstack_free (ob
, obstack_base (ob
));
1080 /* Output a function declaration. */
1083 go_output_fndecl (class godump_container
*container
, tree decl
)
1085 if (!go_format_type (container
, TREE_TYPE (decl
), true, true, NULL
, false))
1086 fprintf (go_dump_file
, "// ");
1087 fprintf (go_dump_file
, "func _%s ",
1088 IDENTIFIER_POINTER (DECL_NAME (decl
)));
1089 go_output_type (container
);
1090 fprintf (go_dump_file
, " __asm__(\"%s\")\n",
1091 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)));
1094 /* Output a typedef or something like a struct definition. */
1097 go_output_typedef (class godump_container
*container
, tree decl
)
1099 /* If we have an enum type, output the enum constants
1101 if (TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
1102 && TYPE_SIZE (TREE_TYPE (decl
)) != 0
1103 && !container
->decls_seen
.contains (TREE_TYPE (decl
))
1104 && (TYPE_CANONICAL (TREE_TYPE (decl
)) == NULL_TREE
1105 || !container
->decls_seen
.contains
1106 (TYPE_CANONICAL (TREE_TYPE (decl
)))))
1110 for (element
= TYPE_VALUES (TREE_TYPE (decl
));
1111 element
!= NULL_TREE
;
1112 element
= TREE_CHAIN (element
))
1115 struct macro_hash_value
*mhval
;
1117 char buf
[WIDE_INT_PRINT_BUFFER_SIZE
];
1119 name
= IDENTIFIER_POINTER (TREE_PURPOSE (element
));
1121 /* Sometimes a name will be defined as both an enum constant
1122 and a macro. Avoid duplicate definition errors by
1123 treating enum constants as macros. */
1124 mhval
= XNEW (struct macro_hash_value
);
1125 mhval
->name
= xstrdup (name
);
1126 mhval
->value
= NULL
;
1127 slot
= htab_find_slot (macro_hash
, mhval
, INSERT
);
1129 macro_hash_del (*slot
);
1131 if (tree_fits_shwi_p (TREE_VALUE (element
)))
1132 snprintf (buf
, sizeof buf
, HOST_WIDE_INT_PRINT_DEC
,
1133 tree_to_shwi (TREE_VALUE (element
)));
1134 else if (tree_fits_uhwi_p (TREE_VALUE (element
)))
1135 snprintf (buf
, sizeof buf
, HOST_WIDE_INT_PRINT_UNSIGNED
,
1136 tree_to_uhwi (TREE_VALUE (element
)));
1138 print_hex (wi::to_wide (element
), buf
);
1140 mhval
->value
= xstrdup (buf
);
1143 container
->decls_seen
.add (TREE_TYPE (decl
));
1144 if (TYPE_CANONICAL (TREE_TYPE (decl
)) != NULL_TREE
)
1145 container
->decls_seen
.add (TYPE_CANONICAL (TREE_TYPE (decl
)));
1148 if (DECL_NAME (decl
) != NULL_TREE
)
1154 type
= IDENTIFIER_POINTER (DECL_NAME (decl
));
1155 original_type
= DECL_ORIGINAL_TYPE (decl
);
1156 if (original_type
== NULL_TREE
)
1157 original_type
= TREE_TYPE (decl
);
1159 /* Suppress typedefs where the type name matches the underlying
1160 struct/union/enum tag. This way we'll emit the struct definition
1161 instead of an invalid recursive type. */
1162 if (TYPE_IDENTIFIER (original_type
) != NULL
1163 && IDENTIFIER_POINTER (TYPE_IDENTIFIER (original_type
)) == type
)
1166 /* If type defined already, skip. */
1167 slot
= htab_find_slot (container
->type_hash
, type
, INSERT
);
1170 *slot
= CONST_CAST (void *, (const void *) type
);
1172 if (!go_format_type (container
, original_type
, true, false,
1175 fprintf (go_dump_file
, "// ");
1176 slot
= htab_find_slot (container
->invalid_hash
, type
, INSERT
);
1177 *slot
= CONST_CAST (void *, (const void *) type
);
1179 fprintf (go_dump_file
, "type _%s ",
1180 IDENTIFIER_POINTER (DECL_NAME (decl
)));
1181 go_output_type (container
);
1183 if (RECORD_OR_UNION_TYPE_P (TREE_TYPE (decl
)))
1185 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (decl
));
1188 fprintf (go_dump_file
,
1189 "\nconst _sizeof_%s = " HOST_WIDE_INT_PRINT_DEC
,
1190 IDENTIFIER_POINTER (DECL_NAME (decl
)),
1194 container
->decls_seen
.add (decl
);
1196 else if ((RECORD_OR_UNION_TYPE_P (TREE_TYPE (decl
))
1197 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
1198 && TYPE_NAME (TREE_TYPE (decl
)) != NULL
)
1204 type
= IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE ((decl
))));
1205 /* If type defined already, skip. */
1206 slot
= htab_find_slot (container
->type_hash
, type
, INSERT
);
1209 *slot
= CONST_CAST (void *, (const void *) type
);
1211 if (!go_format_type (container
, TREE_TYPE (decl
), false, false, NULL
,
1214 fprintf (go_dump_file
, "// ");
1215 slot
= htab_find_slot (container
->invalid_hash
, type
, INSERT
);
1216 *slot
= CONST_CAST (void *, (const void *) type
);
1218 fprintf (go_dump_file
, "type _%s ",
1219 IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (decl
))));
1220 go_output_type (container
);
1222 size
= int_size_in_bytes (TREE_TYPE (decl
));
1224 fprintf (go_dump_file
,
1225 "\nconst _sizeof_%s = " HOST_WIDE_INT_PRINT_DEC
,
1226 IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (decl
))),
1232 fprintf (go_dump_file
, "\n");
1235 /* Output a variable. */
1238 go_output_var (class godump_container
*container
, tree decl
)
1244 if (container
->decls_seen
.contains (decl
)
1245 || container
->decls_seen
.contains (DECL_NAME (decl
)))
1247 container
->decls_seen
.add (decl
);
1248 container
->decls_seen
.add (DECL_NAME (decl
));
1250 type_name
= TYPE_NAME (TREE_TYPE (decl
));
1252 if (type_name
!= NULL_TREE
&& TREE_CODE (type_name
) == IDENTIFIER_NODE
)
1254 else if (type_name
!= NULL_TREE
&& TREE_CODE (type_name
) == TYPE_DECL
1255 && DECL_SOURCE_LOCATION (type_name
) != BUILTINS_LOCATION
1256 && DECL_NAME (type_name
))
1257 id
= DECL_NAME (type_name
);
1259 && (!htab_find_slot (container
->type_hash
, IDENTIFIER_POINTER (id
),
1261 || htab_find_slot (container
->invalid_hash
, IDENTIFIER_POINTER (id
),
1264 if (id
!= NULL_TREE
)
1268 ob
= &container
->type_obstack
;
1269 obstack_1grow (ob
, '_');
1270 go_append_string (ob
, id
);
1271 is_valid
= htab_find_slot (container
->type_hash
, IDENTIFIER_POINTER (id
),
1275 is_valid
= go_format_type (container
, TREE_TYPE (decl
), true, false, NULL
,
1278 && htab_find_slot (container
->type_hash
,
1279 IDENTIFIER_POINTER (DECL_NAME (decl
)),
1282 /* There is already a type with this name, probably from a
1283 struct tag. Prefer the type to the variable. */
1287 fprintf (go_dump_file
, "// ");
1289 fprintf (go_dump_file
, "var _%s ",
1290 IDENTIFIER_POINTER (DECL_NAME (decl
)));
1291 go_output_type (container
);
1292 fprintf (go_dump_file
, "\n");
1294 /* Sometimes an extern variable is declared with an unknown struct
1296 if (type_name
!= NULL_TREE
&& RECORD_OR_UNION_TYPE_P (TREE_TYPE (decl
)))
1298 if (TREE_CODE (type_name
) == IDENTIFIER_NODE
)
1299 container
->pot_dummy_types
.add (IDENTIFIER_POINTER (type_name
));
1300 else if (TREE_CODE (type_name
) == TYPE_DECL
)
1301 container
->pot_dummy_types
.add
1302 (IDENTIFIER_POINTER (DECL_NAME (type_name
)));
1306 /* Output the final value of a preprocessor macro or enum constant.
1307 This is called via htab_traverse_noresize. */
1310 go_print_macro (void **slot
, void *arg ATTRIBUTE_UNUSED
)
1312 struct macro_hash_value
*mhval
= (struct macro_hash_value
*) *slot
;
1313 fprintf (go_dump_file
, "const _%s = %s\n", mhval
->name
, mhval
->value
);
1317 /* Build a hash table with the Go keywords. */
1319 static const char * const keywords
[] = {
1320 "__asm__", "break", "case", "chan", "const", "continue", "default",
1321 "defer", "else", "fallthrough", "for", "func", "go", "goto", "if",
1322 "import", "interface", "map", "package", "range", "return", "select",
1323 "struct", "switch", "type", "var"
1327 keyword_hash_init (class godump_container
*container
)
1330 size_t count
= sizeof (keywords
) / sizeof (keywords
[0]);
1333 for (i
= 0; i
< count
; i
++)
1335 slot
= htab_find_slot (container
->keyword_hash
, keywords
[i
], INSERT
);
1336 *slot
= CONST_CAST (void *, (const void *) keywords
[i
]);
1340 /* Traversing the pot_dummy_types and seeing which types are present
1341 in the global types hash table and creating dummy definitions if
1342 not found. This function is invoked by hash_set::traverse. */
1345 find_dummy_types (const char *const &ptr
, godump_container
*adata
)
1347 class godump_container
*data
= (class godump_container
*) adata
;
1348 const char *type
= (const char *) ptr
;
1352 slot
= htab_find_slot (data
->type_hash
, type
, NO_INSERT
);
1353 islot
= htab_find_slot (data
->invalid_hash
, type
, NO_INSERT
);
1354 if (slot
== NULL
|| islot
!= NULL
)
1355 fprintf (go_dump_file
, "type _%s struct {}\n", type
);
1359 /* Output symbols. */
1362 go_finish (const char *filename
)
1364 class godump_container container
;
1368 real_debug_hooks
->finish (filename
);
1370 container
.type_hash
= htab_create (100, htab_hash_string
,
1371 htab_eq_string
, NULL
);
1372 container
.invalid_hash
= htab_create (10, htab_hash_string
,
1373 htab_eq_string
, NULL
);
1374 container
.keyword_hash
= htab_create (50, htab_hash_string
,
1375 htab_eq_string
, NULL
);
1376 obstack_init (&container
.type_obstack
);
1378 keyword_hash_init (&container
);
1380 FOR_EACH_VEC_SAFE_ELT (queue
, ix
, decl
)
1382 switch (TREE_CODE (decl
))
1385 go_output_fndecl (&container
, decl
);
1389 go_output_typedef (&container
, decl
);
1393 go_output_var (&container
, decl
);
1401 htab_traverse_noresize (macro_hash
, go_print_macro
, NULL
);
1403 /* To emit dummy definitions. */
1404 container
.pot_dummy_types
.traverse
<godump_container
*, find_dummy_types
>
1407 htab_delete (container
.type_hash
);
1408 htab_delete (container
.invalid_hash
);
1409 htab_delete (container
.keyword_hash
);
1410 obstack_free (&container
.type_obstack
, NULL
);
1414 if (fclose (go_dump_file
) != 0)
1415 error ("could not close Go dump file: %m");
1416 go_dump_file
= NULL
;
1419 /* Set up our hooks. */
1421 const struct gcc_debug_hooks
*
1422 dump_go_spec_init (const char *filename
, const struct gcc_debug_hooks
*hooks
)
1424 go_dump_file
= fopen (filename
, "w");
1425 if (go_dump_file
== NULL
)
1427 error ("could not open Go dump file %qs: %m", filename
);
1431 go_debug_hooks
= *hooks
;
1432 real_debug_hooks
= hooks
;
1434 go_debug_hooks
.finish
= go_finish
;
1435 go_debug_hooks
.define
= go_define
;
1436 go_debug_hooks
.undef
= go_undef
;
1437 go_debug_hooks
.function_decl
= go_function_decl
;
1438 go_debug_hooks
.early_global_decl
= go_early_global_decl
;
1439 go_debug_hooks
.late_global_decl
= go_late_global_decl
;
1440 go_debug_hooks
.type_decl
= go_type_decl
;
1442 macro_hash
= htab_create (100, macro_hash_hashval
, macro_hash_eq
,
1445 return &go_debug_hooks
;
1448 #include "gt-godump.h"