/* Output Go language descriptions of types.
- Copyright (C) 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
+ Copyright (C) 2008-2020 Free Software Foundation, Inc.
Written by Ian Lance Taylor <iant@google.com>.
This file is part of GCC.
#include "config.h"
#include "system.h"
#include "coretypes.h"
-#include "diagnostic-core.h"
#include "tree.h"
-#include "ggc.h"
-#include "pointer-set.h"
-#include "obstack.h"
+#include "diagnostic-core.h"
#include "debug.h"
+#include "stor-layout.h"
/* We dump this information from the debug hooks. This gives us a
stable and maintainable API to hook into. In order to work
/* A queue of decls to output. */
-static GTY(()) VEC(tree,gc) *queue;
+static GTY(()) vec<tree, va_gc> *queue;
/* A hash table of macros we have seen. */
static htab_t macro_hash;
-/* For the hash tables. */
+/* The type of a value in macro_hash. */
+
+struct macro_hash_value
+{
+ /* The name stored in the hash table. */
+ char *name;
+ /* The value of the macro. */
+ char *value;
+};
+
+/* Returns the number of units necessary to represent an integer with the given
+ PRECISION (in bits). */
+
+static inline unsigned int
+precision_to_units (unsigned int precision)
+{
+ return (precision + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
+}
+
+/* Calculate the hash value for an entry in the macro hash table. */
+
+static hashval_t
+macro_hash_hashval (const void *val)
+{
+ const struct macro_hash_value *mhval = (const struct macro_hash_value *) val;
+ return htab_hash_string (mhval->name);
+}
+
+/* Compare values in the macro hash table for equality. */
+
+static int
+macro_hash_eq (const void *v1, const void *v2)
+{
+ const struct macro_hash_value *mhv1 = (const struct macro_hash_value *) v1;
+ const struct macro_hash_value *mhv2 = (const struct macro_hash_value *) v2;
+ return strcmp (mhv1->name, mhv2->name) == 0;
+}
+
+/* Free values deleted from the macro hash table. */
+
+static void
+macro_hash_del (void *v)
+{
+ struct macro_hash_value *mhv = (struct macro_hash_value *) v;
+ XDELETEVEC (mhv->name);
+ XDELETEVEC (mhv->value);
+ XDELETE (mhv);
+}
+
+/* For the string hash tables. */
static int
string_hash_eq (const void *y1, const void *y2)
{
const char *p;
const char *name_end;
+ size_t out_len;
char *out_buffer;
char *q;
bool saw_operand;
bool need_operand;
+ struct macro_hash_value *mhval;
char *copy;
hashval_t hashval;
void **slot;
memcpy (copy, buffer, name_end - buffer);
copy[name_end - buffer] = '\0';
+ mhval = XNEW (struct macro_hash_value);
+ mhval->name = copy;
+ mhval->value = NULL;
+
hashval = htab_hash_string (copy);
- slot = htab_find_slot_with_hash (macro_hash, copy, hashval, NO_INSERT);
- if (slot != NULL)
- {
- XDELETEVEC (copy);
- return;
- }
+ slot = htab_find_slot_with_hash (macro_hash, mhval, hashval, NO_INSERT);
/* For simplicity, we force all names to be hidden by adding an
initial underscore, and let the user undo this as needed. */
- out_buffer = XNEWVEC (char, strlen (p) * 2 + 1);
+ out_len = strlen (p) * 2 + 1;
+ out_buffer = XNEWVEC (char, out_len);
q = out_buffer;
saw_operand = false;
need_operand = false;
don't worry about them. */
const char *start;
char *n;
+ struct macro_hash_value idval;
if (saw_operand)
goto unknown;
n = XALLOCAVEC (char, p - start + 1);
memcpy (n, start, p - start);
n[p - start] = '\0';
- slot = htab_find_slot (macro_hash, n, NO_INSERT);
- if (slot == NULL || *slot == NULL)
+ idval.name = n;
+ idval.value = NULL;
+ if (htab_find (macro_hash, &idval) == NULL)
{
/* This is a reference to a name which was not defined
as a macro. */
if (need_operand)
goto unknown;
+ gcc_assert ((size_t) (q - out_buffer) < out_len);
*q = '\0';
- slot = htab_find_slot_with_hash (macro_hash, copy, hashval, INSERT);
- *slot = copy;
+ mhval->value = out_buffer;
- fprintf (go_dump_file, "const _%s = %s\n", copy, out_buffer);
+ if (slot == NULL)
+ {
+ slot = htab_find_slot_with_hash (macro_hash, mhval, hashval, INSERT);
+ gcc_assert (slot != NULL && *slot == NULL);
+ }
+ else
+ {
+ if (*slot != NULL)
+ macro_hash_del (*slot);
+ }
+
+ *slot = mhval;
- XDELETEVEC (out_buffer);
return;
unknown:
fprintf (go_dump_file, "// unknowndefine %s\n", buffer);
+ if (slot != NULL)
+ htab_clear_slot (macro_hash, slot);
XDELETEVEC (out_buffer);
XDELETEVEC (copy);
}
static void
go_undef (unsigned int lineno, const char *buffer)
{
+ struct macro_hash_value mhval;
void **slot;
real_debug_hooks->undef (lineno, buffer);
- slot = htab_find_slot (macro_hash, buffer, NO_INSERT);
- if (slot == NULL)
- return;
- fprintf (go_dump_file, "// undef _%s\n", buffer);
- /* We don't delete the slot from the hash table because that will
- cause a duplicate const definition. */
+ mhval.name = CONST_CAST (char *, buffer);
+ mhval.value = NULL;
+ slot = htab_find_slot (macro_hash, &mhval, NO_INSERT);
+ if (slot != NULL)
+ htab_clear_slot (macro_hash, slot);
}
/* A function or variable decl. */
|| DECL_IS_BUILTIN (decl)
|| DECL_NAME (decl) == NULL_TREE)
return;
- VEC_safe_push (tree, gc, queue, decl);
+ vec_safe_push (queue, decl);
}
/* A function decl. */
go_decl (decl);
}
+static void
+go_early_global_decl (tree decl)
+{
+ go_decl (decl);
+ if (TREE_CODE (decl) != FUNCTION_DECL || DECL_STRUCT_FUNCTION (decl) != NULL)
+ real_debug_hooks->early_global_decl (decl);
+}
+
/* A global variable decl. */
static void
-go_global_decl (tree decl)
+go_late_global_decl (tree decl)
{
- real_debug_hooks->global_decl (decl);
- go_decl (decl);
+ real_debug_hooks->late_global_decl (decl);
}
/* A type declaration. */
|| TREE_CODE (TYPE_NAME (TREE_TYPE (decl))) != IDENTIFIER_NODE)
&& TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE)
return;
- VEC_safe_push (tree, gc, queue, decl);
+ vec_safe_push (queue, decl);
}
/* A container for the data we pass around when generating information
at the end of the compilation. */
-struct godump_container
+class godump_container
{
+public:
/* DECLs that we have already seen. */
- struct pointer_set_t *decls_seen;
+ hash_set<tree> decls_seen;
/* Types which may potentially have to be defined as dummy
types. */
- struct pointer_set_t *pot_dummy_types;
+ hash_set<const char *> pot_dummy_types;
/* Go keywords. */
htab_t keyword_hash;
obstack_grow (ob, IDENTIFIER_POINTER (id), IDENTIFIER_LENGTH (id));
}
+/* Given an integer PRECISION in bits, returns a constant string that is the
+ matching go int or uint type (depending on the IS_UNSIGNED flag). Returns a
+ NULL pointer if there is no matching go type. */
+
+static const char *
+go_get_uinttype_for_precision (unsigned int precision, bool is_unsigned)
+{
+ switch (precision)
+ {
+ case 8:
+ return is_unsigned ? "uint8" : "int8";
+ case 16:
+ return is_unsigned ? "uint16" : "int16";
+ case 32:
+ return is_unsigned ? "uint32" : "int32";
+ case 64:
+ return is_unsigned ? "uint64" : "int64";
+ default:
+ return NULL;
+ }
+}
+
+/* Append an artificial variable name with the suffix _INDEX to OB. Returns
+ INDEX + 1. */
+
+static unsigned int
+go_append_artificial_name (struct obstack *ob, unsigned int index)
+{
+ char buf[100];
+
+ /* FIXME: identifier may not be unique. */
+ obstack_grow (ob, "Godump_", 7);
+ snprintf (buf, sizeof buf, "%u", index);
+ obstack_grow (ob, buf, strlen (buf));
+
+ return index + 1;
+}
+
+/* Append the variable name from DECL to OB. If the name is in the
+ KEYWORD_HASH, prepend an '_'. */
+
+static void
+go_append_decl_name (struct obstack *ob, tree decl, htab_t keyword_hash)
+{
+ const char *var_name;
+ void **slot;
+
+ /* Start variable name with an underscore if a keyword. */
+ var_name = IDENTIFIER_POINTER (DECL_NAME (decl));
+ slot = htab_find_slot (keyword_hash, var_name, NO_INSERT);
+ if (slot != NULL)
+ obstack_1grow (ob, '_');
+ go_append_string (ob, DECL_NAME (decl));
+}
+
+/* Appends a byte array with the necessary number of elements and the name
+ "Godump_INDEX_pad" to pad from FROM_OFFSET to TO_OFFSET to OB assuming that
+ the next field is automatically aligned to ALIGN_UNITS. Returns INDEX + 1,
+ or INDEX if no padding had to be appended. The resulting offset where the
+ next field is allocated is returned through RET_OFFSET. */
+
+static unsigned int
+go_append_padding (struct obstack *ob, unsigned int from_offset,
+ unsigned int to_offset, unsigned int align_units,
+ unsigned int index, unsigned int *ret_offset)
+{
+ if (from_offset % align_units > 0)
+ from_offset += align_units - (from_offset % align_units);
+ gcc_assert (to_offset >= from_offset);
+ if (to_offset > from_offset)
+ {
+ char buf[100];
+
+ index = go_append_artificial_name (ob, index);
+ snprintf (buf, sizeof buf, "_pad [%u]byte; ", to_offset - from_offset);
+ obstack_grow (ob, buf, strlen (buf));
+ }
+ *ret_offset = to_offset;
+
+ return index;
+}
+
+/* Appends an array of type TYPE_STRING with zero elements and the name
+ "Godump_INDEX_align" to OB. If TYPE_STRING is a null pointer, ERROR_STRING
+ is appended instead of the type. Returns INDEX + 1. */
+
+static unsigned int
+go_force_record_alignment (struct obstack *ob, const char *type_string,
+ unsigned int index, const char *error_string)
+{
+ index = go_append_artificial_name (ob, index);
+ obstack_grow (ob, "_align ", 7);
+ if (type_string == NULL)
+ obstack_grow (ob, error_string, strlen (error_string));
+ else
+ {
+ obstack_grow (ob, "[0]", 3);
+ obstack_grow (ob, type_string, strlen (type_string));
+ }
+ obstack_grow (ob, "; ", 2);
+
+ return index;
+}
+
/* Write the Go version of TYPE to CONTAINER->TYPE_OBSTACK.
USE_TYPE_NAME is true if we can simply use a type name here without
needing to define it. IS_FUNC_OK is true if we can output a func
- type here; the "func" keyword will already have been added. Return
- true if the type can be represented in Go, false otherwise. */
+ type here; the "func" keyword will already have been added.
+ Return true if the type can be represented in Go, false otherwise.
+ P_ART_I is used for indexing artificial elements in nested structures and
+ should always be a NULL pointer when called, except by certain recursive
+ calls from go_format_type() itself. */
static bool
-go_format_type (struct godump_container *container, tree type,
- bool use_type_name, bool is_func_ok)
+go_format_type (class godump_container *container, tree type,
+ bool use_type_name, bool is_func_ok, unsigned int *p_art_i,
+ bool is_anon_record_or_union)
{
bool ret;
struct obstack *ob;
+ unsigned int art_i_dummy;
+ bool is_union = false;
+ if (p_art_i == NULL)
+ {
+ art_i_dummy = 0;
+ p_art_i = &art_i_dummy;
+ }
ret = true;
ob = &container->type_obstack;
if (TYPE_NAME (type) != NULL_TREE
- && (pointer_set_contains (container->decls_seen, type)
- || pointer_set_contains (container->decls_seen, TYPE_NAME (type)))
+ && (container->decls_seen.contains (type)
+ || container->decls_seen.contains (TYPE_NAME (type)))
&& (AGGREGATE_TYPE_P (type)
|| POINTER_TYPE_P (type)
|| TREE_CODE (type) == FUNCTION_TYPE))
tree name;
void **slot;
- name = TYPE_NAME (type);
- if (TREE_CODE (name) == TYPE_DECL)
- name = DECL_NAME (name);
+ name = TYPE_IDENTIFIER (type);
slot = htab_find_slot (container->invalid_hash, IDENTIFIER_POINTER (name),
NO_INSERT);
return ret;
}
- pointer_set_insert (container->decls_seen, type);
+ container->decls_seen.add (type);
switch (TREE_CODE (type))
{
- case ENUMERAL_TYPE:
- obstack_grow (ob, "int", 3);
- break;
-
case TYPE_DECL:
{
void **slot;
}
break;
+ case ENUMERAL_TYPE:
case INTEGER_TYPE:
{
const char *s;
char buf[100];
- switch (TYPE_PRECISION (type))
+ s = go_get_uinttype_for_precision (TYPE_PRECISION (type),
+ TYPE_UNSIGNED (type));
+ if (s == NULL)
{
- case 8:
- s = TYPE_UNSIGNED (type) ? "uint8" : "int8";
- break;
- case 16:
- s = TYPE_UNSIGNED (type) ? "uint16" : "int16";
- break;
- case 32:
- s = TYPE_UNSIGNED (type) ? "uint32" : "int32";
- break;
- case 64:
- s = TYPE_UNSIGNED (type) ? "uint64" : "int64";
- break;
- default:
snprintf (buf, sizeof buf, "INVALID-int-%u%s",
TYPE_PRECISION (type),
TYPE_UNSIGNED (type) ? "u" : "");
s = buf;
ret = false;
- break;
}
obstack_grow (ob, s, strlen (s));
}
}
break;
+ case COMPLEX_TYPE:
+ {
+ const char *s;
+ char buf[100];
+ tree real_type;
+
+ real_type = TREE_TYPE (type);
+ if (TREE_CODE (real_type) == REAL_TYPE)
+ {
+ switch (TYPE_PRECISION (real_type))
+ {
+ case 32:
+ s = "complex64";
+ break;
+ case 64:
+ s = "complex128";
+ break;
+ default:
+ snprintf (buf, sizeof buf, "INVALID-complex-%u",
+ 2 * TYPE_PRECISION (real_type));
+ s = buf;
+ ret = false;
+ break;
+ }
+ }
+ else
+ {
+ s = "INVALID-complex-non-real";
+ ret = false;
+ }
+ obstack_grow (ob, s, strlen (s));
+ }
+ break;
+
case BOOLEAN_TYPE:
obstack_grow (ob, "bool", 4);
break;
tree name;
void **slot;
- name = TYPE_NAME (TREE_TYPE (type));
- if (TREE_CODE (name) == TYPE_DECL)
- name = DECL_NAME (name);
+ name = TYPE_IDENTIFIER (TREE_TYPE (type));
slot = htab_find_slot (container->invalid_hash,
IDENTIFIER_POINTER (name), NO_INSERT);
definition. So this struct or union is a potential dummy
type. */
if (RECORD_OR_UNION_TYPE_P (TREE_TYPE (type)))
- pointer_set_insert (container->pot_dummy_types,
- IDENTIFIER_POINTER (name));
+ container->pot_dummy_types.add (IDENTIFIER_POINTER (name));
return ret;
}
else
{
if (!go_format_type (container, TREE_TYPE (type), use_type_name,
- true))
+ true, NULL, false))
ret = false;
}
break;
&& tree_int_cst_sgn (TYPE_MIN_VALUE (TYPE_DOMAIN (type))) == 0
&& TYPE_MAX_VALUE (TYPE_DOMAIN (type)) != NULL_TREE
&& TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) == INTEGER_CST
- && host_integerp (TYPE_MAX_VALUE (TYPE_DOMAIN (type)), 0))
+ && tree_fits_shwi_p (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
{
char buf[100];
snprintf (buf, sizeof buf, HOST_WIDE_INT_PRINT_DEC "+1",
- tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (type)), 0));
+ tree_to_shwi (TYPE_MAX_VALUE (TYPE_DOMAIN (type))));
obstack_grow (ob, buf, strlen (buf));
}
+ else
+ obstack_1grow (ob, '0');
obstack_1grow (ob, ']');
- if (!go_format_type (container, TREE_TYPE (type), use_type_name, false))
+ if (!go_format_type (container, TREE_TYPE (type), use_type_name, false,
+ NULL, false))
ret = false;
break;
case UNION_TYPE:
+ is_union = true;
+ /* Fall through to RECORD_TYPE case. */
+ gcc_fallthrough ();
case RECORD_TYPE:
{
+ unsigned int prev_field_end;
+ unsigned int known_alignment;
tree field;
- int i;
-
- obstack_grow (ob, "struct { ", 9);
- i = 0;
- for (field = TYPE_FIELDS (type);
+ bool emitted_a_field;
+
+ /* FIXME: Why is this necessary? Without it we can get a core
+ dump on the s390x headers, or from a file containing simply
+ "typedef struct S T;". */
+ layout_type (type);
+
+ prev_field_end = 0;
+ known_alignment = 1;
+ /* Anonymous records and unions are flattened, i.e. they are not put
+ into "struct { ... }". */
+ if (!is_anon_record_or_union)
+ obstack_grow (ob, "struct { ", 9);
+ for (field = TYPE_FIELDS (type), emitted_a_field = false;
field != NULL_TREE;
field = TREE_CHAIN (field))
{
- struct obstack hold_type_obstack;
- bool field_ok;
-
- if (TREE_CODE (type) == UNION_TYPE)
- {
- hold_type_obstack = container->type_obstack;
- obstack_init (&container->type_obstack);
- }
-
- field_ok = true;
-
- if (DECL_NAME (field) == NULL)
- {
- char buf[100];
-
- obstack_grow (ob, "Godump_", 7);
- snprintf (buf, sizeof buf, "%d", i);
- obstack_grow (ob, buf, strlen (buf));
- i++;
- }
- else
- {
- const char *var_name;
- void **slot;
-
- /* Start variable name with an underscore if a keyword. */
- var_name = IDENTIFIER_POINTER (DECL_NAME (field));
- slot = htab_find_slot (container->keyword_hash, var_name,
- NO_INSERT);
- if (slot != NULL)
- obstack_1grow (ob, '_');
- go_append_string (ob, DECL_NAME (field));
- }
- obstack_1grow (ob, ' ');
+ if (TREE_CODE (field) != FIELD_DECL)
+ continue;
if (DECL_BIT_FIELD (field))
+ /* Bit fields are replaced by padding. */
+ continue;
+ /* Only the first non-bitfield field is emitted for unions. */
+ if (!is_union || !emitted_a_field)
{
- obstack_grow (ob, "INVALID-bit-field", 17);
- field_ok = false;
- }
- else
- {
- /* Do not expand type if a record or union type or a
- function pointer. */
+ /* Emit the field. */
+ bool field_ok;
+ bool is_anon_substructure;
+ unsigned int decl_align_unit;
+ unsigned int decl_offset;
+
+ field_ok = true;
+ emitted_a_field = true;
+ is_anon_substructure =
+ (DECL_NAME (field) == NULL
+ && (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
+ || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE));
+ /* Keep track of the alignment of named substructures, either
+ of the whole record, or the alignment of the emitted field
+ (for unions). */
+ decl_align_unit = DECL_ALIGN_UNIT (field);
+ if (!is_anon_substructure && decl_align_unit > known_alignment)
+ known_alignment = decl_align_unit;
+ /* Pad to start of field. */
+ decl_offset =
+ TREE_INT_CST_LOW (DECL_FIELD_OFFSET (field))
+ + precision_to_units
+ (TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (field)));
+ {
+ unsigned int align_unit;
+
+ /* For anonymous records and unions there is no automatic
+ structure alignment, so use 1 as the alignment. */
+ align_unit = (is_anon_substructure) ? 1 : decl_align_unit;
+ *p_art_i = go_append_padding
+ (ob, prev_field_end, decl_offset, align_unit, *p_art_i,
+ &prev_field_end);
+ }
+ if (DECL_SIZE_UNIT (field))
+ prev_field_end +=
+ TREE_INT_CST_LOW (DECL_SIZE_UNIT (field));
+ /* Emit the field name, but not for anonymous records and
+ unions. */
+ if (!is_anon_substructure)
+ {
+ if (DECL_NAME (field) == NULL)
+ *p_art_i = go_append_artificial_name (ob, *p_art_i);
+ else
+ go_append_decl_name
+ (ob, field, container->keyword_hash);
+ obstack_1grow (ob, ' ');
+ }
+ /* Do not expand type if a record or union type or a function
+ pointer. */
if (TYPE_NAME (TREE_TYPE (field)) != NULL_TREE
&& (RECORD_OR_UNION_TYPE_P (TREE_TYPE (field))
|| (POINTER_TYPE_P (TREE_TYPE (field))
&& (TREE_CODE (TREE_TYPE (TREE_TYPE (field)))
- == FUNCTION_TYPE))))
+ == FUNCTION_TYPE))))
{
tree name;
void **slot;
- name = TYPE_NAME (TREE_TYPE (field));
- if (TREE_CODE (name) == TYPE_DECL)
- name = DECL_NAME (name);
+ name = TYPE_IDENTIFIER (TREE_TYPE (field));
slot = htab_find_slot (container->invalid_hash,
IDENTIFIER_POINTER (name),
else
{
if (!go_format_type (container, TREE_TYPE (field), true,
- false))
+ false, p_art_i, is_anon_substructure))
field_ok = false;
}
- }
- obstack_grow (ob, "; ", 2);
-
- /* Only output the first successful field of a union, and
- hope for the best. */
- if (TREE_CODE (type) == UNION_TYPE)
- {
- if (!field_ok && TREE_CHAIN (field) == NULL_TREE)
- {
- field_ok = true;
- ret = false;
- }
- if (field_ok)
- {
- unsigned int sz;
-
- sz = obstack_object_size (&container->type_obstack);
- obstack_grow (&hold_type_obstack,
- obstack_base (&container->type_obstack),
- sz);
- }
- obstack_free (&container->type_obstack, NULL);
- container->type_obstack = hold_type_obstack;
- if (field_ok)
- break;
- }
- else
- {
+ if (!is_anon_substructure)
+ obstack_grow (ob, "; ", 2);
if (!field_ok)
ret = false;
}
}
- obstack_1grow (ob, '}');
+ /* Padding. */
+ *p_art_i = go_append_padding (ob, prev_field_end,
+ TREE_INT_CST_LOW (TYPE_SIZE_UNIT (type)),
+ 1, *p_art_i, &prev_field_end);
+ /* Alignment. */
+ if (!is_anon_record_or_union
+ && known_alignment < TYPE_ALIGN_UNIT (type))
+ {
+ const char *s;
+ char buf[100];
+
+ /* Enforce proper record alignment. */
+ s = go_get_uinttype_for_precision
+ (TYPE_ALIGN (type), TYPE_UNSIGNED (type));
+ if (s == NULL)
+ {
+ snprintf (buf, sizeof buf, "INVALID-int-%u%s",
+ TYPE_ALIGN (type), TYPE_UNSIGNED (type) ? "u" : "");
+ s = buf;
+ ret = false;
+ }
+ *p_art_i = go_force_record_alignment (ob, s, *p_art_i, buf);
+ }
+ if (!is_anon_record_or_union)
+ obstack_1grow (ob, '}');
}
- break;
+ break;
case FUNCTION_TYPE:
{
break;
if (seen_arg)
obstack_grow (ob, ", ", 2);
- if (!go_format_type (container, arg_type, true, false))
+ if (!go_format_type (container, arg_type, true, false, NULL, false))
ret = false;
seen_arg = true;
}
if (!VOID_TYPE_P (result))
{
obstack_1grow (ob, ' ');
- if (!go_format_type (container, result, use_type_name, false))
+ if (!go_format_type (container, result, use_type_name, false, NULL,
+ false))
ret = false;
}
}
it. */
static void
-go_output_type (struct godump_container *container)
+go_output_type (class godump_container *container)
{
struct obstack *ob;
ob = &container->type_obstack;
obstack_1grow (ob, '\0');
- fputs (obstack_base (ob), go_dump_file);
+ fputs ((char *) obstack_base (ob), go_dump_file);
obstack_free (ob, obstack_base (ob));
}
/* Output a function declaration. */
static void
-go_output_fndecl (struct godump_container *container, tree decl)
+go_output_fndecl (class godump_container *container, tree decl)
{
- if (!go_format_type (container, TREE_TYPE (decl), false, true))
+ if (!go_format_type (container, TREE_TYPE (decl), false, true, NULL, false))
fprintf (go_dump_file, "// ");
fprintf (go_dump_file, "func _%s ",
IDENTIFIER_POINTER (DECL_NAME (decl)));
/* Output a typedef or something like a struct definition. */
static void
-go_output_typedef (struct godump_container *container, tree decl)
+go_output_typedef (class godump_container *container, tree decl)
{
/* If we have an enum type, output the enum constants
separately. */
if (TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE
&& TYPE_SIZE (TREE_TYPE (decl)) != 0
- && !pointer_set_contains (container->decls_seen, TREE_TYPE (decl))
+ && !container->decls_seen.contains (TREE_TYPE (decl))
&& (TYPE_CANONICAL (TREE_TYPE (decl)) == NULL_TREE
- || !pointer_set_contains (container->decls_seen,
- TYPE_CANONICAL (TREE_TYPE (decl)))))
+ || !container->decls_seen.contains
+ (TYPE_CANONICAL (TREE_TYPE (decl)))))
{
tree element;
element = TREE_CHAIN (element))
{
const char *name;
+ struct macro_hash_value *mhval;
void **slot;
+ char buf[WIDE_INT_PRINT_BUFFER_SIZE];
name = IDENTIFIER_POINTER (TREE_PURPOSE (element));
/* Sometimes a name will be defined as both an enum constant
and a macro. Avoid duplicate definition errors by
treating enum constants as macros. */
- slot = htab_find_slot (macro_hash, name, INSERT);
- if (*slot == NULL)
- {
- *slot = CONST_CAST (char *, name);
- fprintf (go_dump_file, "const _%s = ", name);
- if (host_integerp (TREE_VALUE (element), 0))
- fprintf (go_dump_file, HOST_WIDE_INT_PRINT_DEC,
- tree_low_cst (TREE_VALUE (element), 0));
- else if (host_integerp (TREE_VALUE (element), 1))
- fprintf (go_dump_file, HOST_WIDE_INT_PRINT_UNSIGNED,
- ((unsigned HOST_WIDE_INT)
- tree_low_cst (TREE_VALUE (element), 1)));
- else
- fprintf (go_dump_file, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
- ((unsigned HOST_WIDE_INT)
- TREE_INT_CST_HIGH (TREE_VALUE (element))),
- TREE_INT_CST_LOW (TREE_VALUE (element)));
- fprintf (go_dump_file, "\n");
- }
+ mhval = XNEW (struct macro_hash_value);
+ mhval->name = xstrdup (name);
+ mhval->value = NULL;
+ slot = htab_find_slot (macro_hash, mhval, INSERT);
+ if (*slot != NULL)
+ macro_hash_del (*slot);
+
+ if (tree_fits_shwi_p (TREE_VALUE (element)))
+ snprintf (buf, sizeof buf, HOST_WIDE_INT_PRINT_DEC,
+ tree_to_shwi (TREE_VALUE (element)));
+ else if (tree_fits_uhwi_p (TREE_VALUE (element)))
+ snprintf (buf, sizeof buf, HOST_WIDE_INT_PRINT_UNSIGNED,
+ tree_to_uhwi (TREE_VALUE (element)));
+ else
+ print_hex (wi::to_wide (element), buf);
+
+ mhval->value = xstrdup (buf);
+ *slot = mhval;
}
- pointer_set_insert (container->decls_seen, TREE_TYPE (decl));
+ container->decls_seen.add (TREE_TYPE (decl));
if (TYPE_CANONICAL (TREE_TYPE (decl)) != NULL_TREE)
- pointer_set_insert (container->decls_seen,
- TYPE_CANONICAL (TREE_TYPE (decl)));
+ container->decls_seen.add (TYPE_CANONICAL (TREE_TYPE (decl)));
}
if (DECL_NAME (decl) != NULL_TREE)
return;
*slot = CONST_CAST (void *, (const void *) type);
- if (!go_format_type (container, TREE_TYPE (decl), false, false))
+ if (!go_format_type (container, TREE_TYPE (decl), true, false, NULL,
+ false))
{
fprintf (go_dump_file, "// ");
slot = htab_find_slot (container->invalid_hash, type, INSERT);
fprintf (go_dump_file, "type _%s ",
IDENTIFIER_POINTER (DECL_NAME (decl)));
go_output_type (container);
- pointer_set_insert (container->decls_seen, decl);
+
+ if (RECORD_OR_UNION_TYPE_P (TREE_TYPE (decl)))
+ {
+ HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (decl));
+
+ if (size > 0)
+ fprintf (go_dump_file,
+ "\nconst _sizeof_%s = " HOST_WIDE_INT_PRINT_DEC,
+ IDENTIFIER_POINTER (DECL_NAME (decl)),
+ size);
+ }
+
+ container->decls_seen.add (decl);
}
else if (RECORD_OR_UNION_TYPE_P (TREE_TYPE (decl)))
{
void **slot;
const char *type;
+ HOST_WIDE_INT size;
type = IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE ((decl))));
/* If type defined already, skip. */
return;
*slot = CONST_CAST (void *, (const void *) type);
- if (!go_format_type (container, TREE_TYPE (decl), false, false))
+ if (!go_format_type (container, TREE_TYPE (decl), false, false, NULL,
+ false))
{
fprintf (go_dump_file, "// ");
slot = htab_find_slot (container->invalid_hash, type, INSERT);
fprintf (go_dump_file, "type _%s ",
IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (decl))));
go_output_type (container);
+
+ size = int_size_in_bytes (TREE_TYPE (decl));
+ if (size > 0)
+ fprintf (go_dump_file,
+ "\nconst _sizeof_%s = " HOST_WIDE_INT_PRINT_DEC,
+ IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (decl))),
+ size);
}
else
return;
/* Output a variable. */
static void
-go_output_var (struct godump_container *container, tree decl)
+go_output_var (class godump_container *container, tree decl)
{
bool is_valid;
+ tree type_name;
+ tree id;
- if (pointer_set_contains (container->decls_seen, decl)
- || pointer_set_contains (container->decls_seen, DECL_NAME (decl)))
+ if (container->decls_seen.contains (decl)
+ || container->decls_seen.contains (DECL_NAME (decl)))
return;
- pointer_set_insert (container->decls_seen, decl);
- pointer_set_insert (container->decls_seen, DECL_NAME (decl));
+ container->decls_seen.add (decl);
+ container->decls_seen.add (DECL_NAME (decl));
+
+ type_name = TYPE_NAME (TREE_TYPE (decl));
+ id = NULL_TREE;
+ if (type_name != NULL_TREE && TREE_CODE (type_name) == IDENTIFIER_NODE)
+ id = type_name;
+ else if (type_name != NULL_TREE && TREE_CODE (type_name) == TYPE_DECL
+ && DECL_SOURCE_LOCATION (type_name) != BUILTINS_LOCATION
+ && DECL_NAME (type_name))
+ id = DECL_NAME (type_name);
+ if (id != NULL_TREE
+ && (!htab_find_slot (container->type_hash, IDENTIFIER_POINTER (id),
+ NO_INSERT)
+ || htab_find_slot (container->invalid_hash, IDENTIFIER_POINTER (id),
+ NO_INSERT)))
+ id = NULL_TREE;
+ if (id != NULL_TREE)
+ {
+ struct obstack *ob;
- is_valid = go_format_type (container, TREE_TYPE (decl), true, false);
+ ob = &container->type_obstack;
+ obstack_1grow (ob, '_');
+ go_append_string (ob, id);
+ is_valid = htab_find_slot (container->type_hash, IDENTIFIER_POINTER (id),
+ NO_INSERT) != NULL;
+ }
+ else
+ is_valid = go_format_type (container, TREE_TYPE (decl), true, false, NULL,
+ false);
if (is_valid
&& htab_find_slot (container->type_hash,
IDENTIFIER_POINTER (DECL_NAME (decl)),
/* Sometimes an extern variable is declared with an unknown struct
type. */
- if (TYPE_NAME (TREE_TYPE (decl)) != NULL_TREE
- && RECORD_OR_UNION_TYPE_P (TREE_TYPE (decl)))
+ if (type_name != NULL_TREE && RECORD_OR_UNION_TYPE_P (TREE_TYPE (decl)))
{
- tree type_name = TYPE_NAME (TREE_TYPE (decl));
if (TREE_CODE (type_name) == IDENTIFIER_NODE)
- pointer_set_insert (container->pot_dummy_types,
- IDENTIFIER_POINTER (type_name));
+ container->pot_dummy_types.add (IDENTIFIER_POINTER (type_name));
else if (TREE_CODE (type_name) == TYPE_DECL)
- pointer_set_insert (container->pot_dummy_types,
- IDENTIFIER_POINTER (DECL_NAME (type_name)));
+ container->pot_dummy_types.add
+ (IDENTIFIER_POINTER (DECL_NAME (type_name)));
}
}
+/* Output the final value of a preprocessor macro or enum constant.
+ This is called via htab_traverse_noresize. */
+
+static int
+go_print_macro (void **slot, void *arg ATTRIBUTE_UNUSED)
+{
+ struct macro_hash_value *mhval = (struct macro_hash_value *) *slot;
+ fprintf (go_dump_file, "const _%s = %s\n", mhval->name, mhval->value);
+ return 1;
+}
+
/* Build a hash table with the Go keywords. */
static const char * const keywords[] = {
};
static void
-keyword_hash_init (struct godump_container *container)
+keyword_hash_init (class godump_container *container)
{
size_t i;
size_t count = sizeof (keywords) / sizeof (keywords[0]);
/* Traversing the pot_dummy_types and seeing which types are present
in the global types hash table and creating dummy definitions if
- not found. This function is invoked by pointer_set_traverse. */
+ not found. This function is invoked by hash_set::traverse. */
-static bool
-find_dummy_types (const void *ptr, void *adata)
+bool
+find_dummy_types (const char *const &ptr, godump_container *adata)
{
- struct godump_container *data = (struct godump_container *) adata;
+ class godump_container *data = (class godump_container *) adata;
const char *type = (const char *) ptr;
void **slot;
+ void **islot;
slot = htab_find_slot (data->type_hash, type, NO_INSERT);
- if (slot == NULL)
+ islot = htab_find_slot (data->invalid_hash, type, NO_INSERT);
+ if (slot == NULL || islot != NULL)
fprintf (go_dump_file, "type _%s struct {}\n", type);
return true;
}
static void
go_finish (const char *filename)
{
- struct godump_container container;
+ class godump_container container;
unsigned int ix;
tree decl;
real_debug_hooks->finish (filename);
- container.decls_seen = pointer_set_create ();
- container.pot_dummy_types = pointer_set_create ();
container.type_hash = htab_create (100, htab_hash_string,
string_hash_eq, NULL);
container.invalid_hash = htab_create (10, htab_hash_string,
keyword_hash_init (&container);
- FOR_EACH_VEC_ELT (tree, queue, ix, decl)
+ FOR_EACH_VEC_SAFE_ELT (queue, ix, decl)
{
switch (TREE_CODE (decl))
{
break;
default:
- gcc_unreachable();
+ gcc_unreachable ();
}
}
+ htab_traverse_noresize (macro_hash, go_print_macro, NULL);
+
/* To emit dummy definitions. */
- pointer_set_traverse (container.pot_dummy_types, find_dummy_types,
- (void *) &container);
+ container.pot_dummy_types.traverse<godump_container *, find_dummy_types>
+ (&container);
- pointer_set_destroy (container.decls_seen);
- pointer_set_destroy (container.pot_dummy_types);
htab_delete (container.type_hash);
htab_delete (container.invalid_hash);
htab_delete (container.keyword_hash);
obstack_free (&container.type_obstack, NULL);
- queue = NULL;
+ vec_free (queue);
if (fclose (go_dump_file) != 0)
error ("could not close Go dump file: %m");
go_debug_hooks.define = go_define;
go_debug_hooks.undef = go_undef;
go_debug_hooks.function_decl = go_function_decl;
- go_debug_hooks.global_decl = go_global_decl;
+ go_debug_hooks.early_global_decl = go_early_global_decl;
+ go_debug_hooks.late_global_decl = go_late_global_decl;
go_debug_hooks.type_decl = go_type_decl;
- macro_hash = htab_create (100, htab_hash_string, string_hash_eq, NULL);
+ macro_hash = htab_create (100, macro_hash_hashval, macro_hash_eq,
+ macro_hash_del);
return &go_debug_hooks;
}
projects / thirdparty / gcc.git / blobdiff