static void
sdbout_field_types (tree type)
{
tree tail;
for (tail = TYPE_FIELDS (type); tail; tail = TREE_CHAIN (tail))
/* This condition should match the one for emitting the actual
members below. */
if (TREE_CODE (tail) == FIELD_DECL
&& DECL_NAME (tail)
&& DECL_SIZE (tail)
&& host_integerp (DECL_SIZE (tail), 1)
&& host_integerp (bit_position (tail), 0))
{
if (POINTER_TYPE_P (TREE_TYPE (tail)))
sdbout_one_type (TREE_TYPE (TREE_TYPE (tail)));
else
sdbout_one_type (TREE_TYPE (tail));
}
}
static void
dequeue_and_dump (dump_info_p di)
{
dump_queue_p dq;
splay_tree_node stn;
dump_node_info_p dni;
tree t;
unsigned int index;
enum tree_code code;
enum tree_code_class code_class;
const char* code_name;
/* Get the next node from the queue. */
dq = di->queue;
stn = dq->node;
t = (tree) stn->key;
dni = (dump_node_info_p) stn->value;
index = dni->index;
/* Remove the node from the queue, and put it on the free list. */
di->queue = dq->next;
if (!di->queue)
di->queue_end = 0;
dq->next = di->free_list;
di->free_list = dq;
/* Print the node index. */
dump_index (di, index);
/* And the type of node this is. */
if (dni->binfo_p)
code_name = "binfo";
else
code_name = tree_code_name[(int) TREE_CODE (t)];
fprintf (di->stream, "%-16s ", code_name);
di->column = 25;
/* Figure out what kind of node this is. */
code = TREE_CODE (t);
code_class = TREE_CODE_CLASS (code);
/* Although BINFOs are TREE_VECs, we dump them specially so as to be
more informative. */
if (dni->binfo_p)
{
unsigned ix;
tree base;
VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (t);
dump_child ("type", BINFO_TYPE (t));
if (BINFO_VIRTUAL_P (t))
dump_string_field (di, "spec", "virt");
dump_int (di, "bases", BINFO_N_BASE_BINFOS (t));
for (ix = 0; BINFO_BASE_ITERATE (t, ix, base); ix++)
{
tree access = (accesses ? VEC_index (tree, accesses, ix)
: access_public_node);
const char *string = NULL;
if (access == access_public_node)
string = "pub";
else if (access == access_protected_node)
string = "prot";
else if (access == access_private_node)
string = "priv";
else
gcc_unreachable ();
dump_string_field (di, "accs", string);
queue_and_dump_index (di, "binf", base, DUMP_BINFO);
}
goto done;
}
/* We can knock off a bunch of expression nodes in exactly the same
way. */
if (IS_EXPR_CODE_CLASS (code_class))
{
/* If we're dumping children, dump them now. */
queue_and_dump_type (di, t);
switch (code_class)
{
case tcc_unary:
dump_child ("op 0", TREE_OPERAND (t, 0));
break;
case tcc_binary:
case tcc_comparison:
dump_child ("op 0", TREE_OPERAND (t, 0));
dump_child ("op 1", TREE_OPERAND (t, 1));
break;
case tcc_expression:
case tcc_reference:
case tcc_statement:
case tcc_vl_exp:
/* These nodes are handled explicitly below. */
break;
default:
gcc_unreachable ();
}
}
else if (DECL_P (t))
{
expanded_location xloc;
/* All declarations have names. */
if (DECL_NAME (t))
dump_child ("name", DECL_NAME (t));
if (DECL_ASSEMBLER_NAME_SET_P (t)
&& DECL_ASSEMBLER_NAME (t) != DECL_NAME (t))
dump_child ("mngl", DECL_ASSEMBLER_NAME (t));
if (DECL_ABSTRACT_ORIGIN (t))
dump_child ("orig", DECL_ABSTRACT_ORIGIN (t));
/* And types. */
queue_and_dump_type (di, t);
dump_child ("scpe", DECL_CONTEXT (t));
/* And a source position. */
xloc = expand_location (DECL_SOURCE_LOCATION (t));
if (xloc.file)
{
const char *filename = lbasename (xloc.file);
dump_maybe_newline (di);
fprintf (di->stream, "srcp: %s:%-6d ", filename,
xloc.line);
di->column += 6 + strlen (filename) + 8;
}
/* And any declaration can be compiler-generated. */
if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_COMMON)
&& DECL_ARTIFICIAL (t))
dump_string_field (di, "note", "artificial");
if (DECL_CHAIN (t) && !dump_flag (di, TDF_SLIM, NULL))
dump_child ("chain", DECL_CHAIN (t));
}
else if (code_class == tcc_type)
{
/* All types have qualifiers. */
int quals = lang_hooks.tree_dump.type_quals (t);
if (quals != TYPE_UNQUALIFIED)
{
fprintf (di->stream, "qual: %c%c%c ",
(quals & TYPE_QUAL_CONST) ? 'c' : ' ',
(quals & TYPE_QUAL_VOLATILE) ? 'v' : ' ',
(quals & TYPE_QUAL_RESTRICT) ? 'r' : ' ');
di->column += 14;
}
/* All types have associated declarations. */
dump_child ("name", TYPE_NAME (t));
/* All types have a main variant. */
if (TYPE_MAIN_VARIANT (t) != t)
dump_child ("unql", TYPE_MAIN_VARIANT (t));
/* And sizes. */
dump_child ("size", TYPE_SIZE (t));
/* All types have alignments. */
dump_int (di, "algn", TYPE_ALIGN (t));
}
else if (code_class == tcc_constant)
/* All constants can have types. */
queue_and_dump_type (di, t);
/* Give the language-specific code a chance to print something. If
it's completely taken care of things, don't bother printing
anything more ourselves. */
if (lang_hooks.tree_dump.dump_tree (di, t))
goto done;
/* Now handle the various kinds of nodes. */
switch (code)
{
int i;
case IDENTIFIER_NODE:
dump_string_field (di, "strg", IDENTIFIER_POINTER (t));
dump_int (di, "lngt", IDENTIFIER_LENGTH (t));
break;
case TREE_LIST:
dump_child ("purp", TREE_PURPOSE (t));
dump_child ("valu", TREE_VALUE (t));
dump_child ("chan", TREE_CHAIN (t));
break;
case STATEMENT_LIST:
{
tree_stmt_iterator it;
for (i = 0, it = tsi_start (t); !tsi_end_p (it); tsi_next (&it), i++)
{
char buffer[32];
sprintf (buffer, "%u", i);
dump_child (buffer, tsi_stmt (it));
}
}
break;
case TREE_VEC:
dump_int (di, "lngt", TREE_VEC_LENGTH (t));
for (i = 0; i < TREE_VEC_LENGTH (t); ++i)
{
char buffer[32];
sprintf (buffer, "%u", i);
dump_child (buffer, TREE_VEC_ELT (t, i));
}
break;
case INTEGER_TYPE:
case ENUMERAL_TYPE:
dump_int (di, "prec", TYPE_PRECISION (t));
dump_string_field (di, "sign", TYPE_UNSIGNED (t) ? "unsigned": "signed");
dump_child ("min", TYPE_MIN_VALUE (t));
dump_child ("max", TYPE_MAX_VALUE (t));
if (code == ENUMERAL_TYPE)
dump_child ("csts", TYPE_VALUES (t));
break;
case REAL_TYPE:
dump_int (di, "prec", TYPE_PRECISION (t));
break;
case FIXED_POINT_TYPE:
dump_int (di, "prec", TYPE_PRECISION (t));
dump_string_field (di, "sign", TYPE_UNSIGNED (t) ? "unsigned": "signed");
dump_string_field (di, "saturating",
TYPE_SATURATING (t) ? "saturating": "non-saturating");
break;
case POINTER_TYPE:
dump_child ("ptd", TREE_TYPE (t));
break;
case REFERENCE_TYPE:
dump_child ("refd", TREE_TYPE (t));
break;
case METHOD_TYPE:
dump_child ("clas", TYPE_METHOD_BASETYPE (t));
/* Fall through. */
case FUNCTION_TYPE:
dump_child ("retn", TREE_TYPE (t));
dump_child ("prms", TYPE_ARG_TYPES (t));
break;
case ARRAY_TYPE:
dump_child ("elts", TREE_TYPE (t));
dump_child ("domn", TYPE_DOMAIN (t));
break;
case RECORD_TYPE:
case UNION_TYPE:
if (TREE_CODE (t) == RECORD_TYPE)
dump_string_field (di, "tag", "struct");
else
dump_string_field (di, "tag", "union");
dump_child ("flds", TYPE_FIELDS (t));
dump_child ("fncs", TYPE_METHODS (t));
queue_and_dump_index (di, "binf", TYPE_BINFO (t),
DUMP_BINFO);
break;
case CONST_DECL:
dump_child ("cnst", DECL_INITIAL (t));
break;
case DEBUG_EXPR_DECL:
dump_int (di, "-uid", DEBUG_TEMP_UID (t));
/* Fall through. */
case VAR_DECL:
case PARM_DECL:
case FIELD_DECL:
case RESULT_DECL:
if (TREE_CODE (t) == PARM_DECL)
dump_child ("argt", DECL_ARG_TYPE (t));
else
dump_child ("init", DECL_INITIAL (t));
dump_child ("size", DECL_SIZE (t));
dump_int (di, "algn", DECL_ALIGN (t));
if (TREE_CODE (t) == FIELD_DECL)
{
if (DECL_FIELD_OFFSET (t))
dump_child ("bpos", bit_position (t));
}
else if (TREE_CODE (t) == VAR_DECL
|| TREE_CODE (t) == PARM_DECL)
{
dump_int (di, "used", TREE_USED (t));
if (DECL_REGISTER (t))
dump_string_field (di, "spec", "register");
}
break;
case FUNCTION_DECL:
dump_child ("args", DECL_ARGUMENTS (t));
if (DECL_EXTERNAL (t))
dump_string_field (di, "body", "undefined");
if (TREE_PUBLIC (t))
dump_string_field (di, "link", "extern");
else
dump_string_field (di, "link", "static");
if (DECL_SAVED_TREE (t) && !dump_flag (di, TDF_SLIM, t))
dump_child ("body", DECL_SAVED_TREE (t));
break;
case INTEGER_CST:
if (TREE_INT_CST_HIGH (t))
dump_int (di, "high", TREE_INT_CST_HIGH (t));
dump_int (di, "low", TREE_INT_CST_LOW (t));
break;
case STRING_CST:
fprintf (di->stream, "strg: %-7s ", TREE_STRING_POINTER (t));
dump_int (di, "lngt", TREE_STRING_LENGTH (t));
break;
case REAL_CST:
dump_real (di, "valu", TREE_REAL_CST_PTR (t));
break;
case FIXED_CST:
dump_fixed (di, "valu", TREE_FIXED_CST_PTR (t));
break;
case TRUTH_NOT_EXPR:
case ADDR_EXPR:
case INDIRECT_REF:
case CLEANUP_POINT_EXPR:
case SAVE_EXPR:
case REALPART_EXPR:
case IMAGPART_EXPR:
/* These nodes are unary, but do not have code class `1'. */
dump_child ("op 0", TREE_OPERAND (t, 0));
break;
case TRUTH_ANDIF_EXPR:
case TRUTH_ORIF_EXPR:
case INIT_EXPR:
case MODIFY_EXPR:
case COMPOUND_EXPR:
case PREDECREMENT_EXPR:
case PREINCREMENT_EXPR:
case POSTDECREMENT_EXPR:
case POSTINCREMENT_EXPR:
/* These nodes are binary, but do not have code class `2'. */
dump_child ("op 0", TREE_OPERAND (t, 0));
dump_child ("op 1", TREE_OPERAND (t, 1));
break;
case COMPONENT_REF:
dump_child ("op 0", TREE_OPERAND (t, 0));
dump_child ("op 1", TREE_OPERAND (t, 1));
dump_child ("op 2", TREE_OPERAND (t, 2));
break;
case ARRAY_REF:
case ARRAY_RANGE_REF:
dump_child ("op 0", TREE_OPERAND (t, 0));
dump_child ("op 1", TREE_OPERAND (t, 1));
dump_child ("op 2", TREE_OPERAND (t, 2));
dump_child ("op 3", TREE_OPERAND (t, 3));
break;
case COND_EXPR:
dump_child ("op 0", TREE_OPERAND (t, 0));
dump_child ("op 1", TREE_OPERAND (t, 1));
dump_child ("op 2", TREE_OPERAND (t, 2));
break;
case TRY_FINALLY_EXPR:
dump_child ("op 0", TREE_OPERAND (t, 0));
dump_child ("op 1", TREE_OPERAND (t, 1));
break;
case CALL_EXPR:
{
int i = 0;
tree arg;
call_expr_arg_iterator iter;
dump_child ("fn", CALL_EXPR_FN (t));
FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
{
char buffer[32];
sprintf (buffer, "%u", i);
dump_child (buffer, arg);
i++;
}
}
break;
case CONSTRUCTOR:
{
unsigned HOST_WIDE_INT cnt;
tree index, value;
dump_int (di, "lngt", VEC_length (constructor_elt,
CONSTRUCTOR_ELTS (t)));
FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), cnt, index, value)
{
dump_child ("idx", index);
dump_child ("val", value);
}
}
static void
sdbout_one_type (tree type)
{
if (current_function_decl != NULL_TREE
&& DECL_SECTION_NAME (current_function_decl) != NULL_TREE)
; /* Don't change section amid function. */
else
switch_to_section (text_section);
switch (TREE_CODE (type))
{
case RECORD_TYPE:
case UNION_TYPE:
case QUAL_UNION_TYPE:
case ENUMERAL_TYPE:
type = TYPE_MAIN_VARIANT (type);
/* Don't output a type twice. */
if (TREE_ASM_WRITTEN (type))
/* James said test TREE_ASM_BEING_WRITTEN here. */
return;
/* Output nothing if type is not yet defined. */
if (!COMPLETE_TYPE_P (type))
return;
TREE_ASM_WRITTEN (type) = 1;
/* This is reputed to cause trouble with the following case,
but perhaps checking TYPE_SIZE above will fix it. */
/* Here is a testcase:
struct foo {
struct badstr *bbb;
} forwardref;
typedef struct intermediate {
int aaaa;
} intermediate_ref;
typedef struct badstr {
int ccccc;
} badtype; */
/* This change, which ought to make better output,
used to make the COFF assembler unhappy.
Changes involving KNOWN_TYPE_TAG may fix the problem. */
/* Before really doing anything, output types we want to refer to. */
/* Note that in version 1 the following two lines
are not used if forward references are in use. */
if (TREE_CODE (type) != ENUMERAL_TYPE)
sdbout_field_types (type);
/* Output a structure type. */
{
int size = int_size_in_bytes (type);
int member_scl = 0;
tree tem;
/* Record the type tag, but not in its permanent place just yet. */
sdbout_record_type_name (type);
PUT_SDB_DEF (KNOWN_TYPE_TAG (type));
switch (TREE_CODE (type))
{
case UNION_TYPE:
case QUAL_UNION_TYPE:
PUT_SDB_SCL (C_UNTAG);
PUT_SDB_TYPE (T_UNION);
member_scl = C_MOU;
break;
case RECORD_TYPE:
PUT_SDB_SCL (C_STRTAG);
PUT_SDB_TYPE (T_STRUCT);
member_scl = C_MOS;
break;
case ENUMERAL_TYPE:
PUT_SDB_SCL (C_ENTAG);
PUT_SDB_TYPE (T_ENUM);
member_scl = C_MOE;
break;
default:
break;
}
PUT_SDB_SIZE (size);
PUT_SDB_ENDEF;
/* Print out the base class information with fields
named after the types they hold. */
/* This is only relevant to aggregate types. TYPE_BINFO is used
for other purposes in an ENUMERAL_TYPE, so we must exclude that
case. */
if (TREE_CODE (type) != ENUMERAL_TYPE && TYPE_BINFO (type))
{
int i;
tree binfo, child;
for (binfo = TYPE_BINFO (type), i = 0;
BINFO_BASE_ITERATE (binfo, i, child); i++)
{
tree child_type = BINFO_TYPE (child);
tree child_type_name;
if (TYPE_NAME (child_type) == 0)
continue;
if (TREE_CODE (TYPE_NAME (child_type)) == IDENTIFIER_NODE)
child_type_name = TYPE_NAME (child_type);
else if (TREE_CODE (TYPE_NAME (child_type)) == TYPE_DECL)
{
child_type_name = DECL_NAME (TYPE_NAME (child_type));
if (child_type_name && template_name_p (child_type_name))
child_type_name
= DECL_ASSEMBLER_NAME (TYPE_NAME (child_type));
}
else
continue;
PUT_SDB_DEF (IDENTIFIER_POINTER (child_type_name));
PUT_SDB_INT_VAL (tree_low_cst (BINFO_OFFSET (child), 0));
PUT_SDB_SCL (member_scl);
sdbout_type (BINFO_TYPE (child));
PUT_SDB_ENDEF;
}
}
/* Output the individual fields. */
if (TREE_CODE (type) == ENUMERAL_TYPE)
{
for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem))
{
tree value = TREE_VALUE (tem);
if (TREE_CODE (value) == CONST_DECL)
value = DECL_INITIAL (value);
if (host_integerp (value, 0))
{
PUT_SDB_DEF (IDENTIFIER_POINTER (TREE_PURPOSE (tem)));
PUT_SDB_INT_VAL (tree_low_cst (value, 0));
PUT_SDB_SCL (C_MOE);
PUT_SDB_TYPE (T_MOE);
PUT_SDB_ENDEF;
}
}
}
else /* record or union type */
for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
/* Output the name, type, position (in bits), size (in bits)
of each field. */
/* Omit here the nameless fields that are used to skip bits.
Also omit fields with variable size or position.
Also omit non FIELD_DECL nodes that GNU C++ may put here. */
if (TREE_CODE (tem) == FIELD_DECL
&& DECL_NAME (tem)
&& DECL_SIZE (tem)
&& host_integerp (DECL_SIZE (tem), 1)
&& host_integerp (bit_position (tem), 0))
{
const char *name;
name = IDENTIFIER_POINTER (DECL_NAME (tem));
PUT_SDB_DEF (name);
if (DECL_BIT_FIELD_TYPE (tem))
{
PUT_SDB_INT_VAL (int_bit_position (tem));
PUT_SDB_SCL (C_FIELD);
sdbout_type (DECL_BIT_FIELD_TYPE (tem));
PUT_SDB_SIZE (tree_low_cst (DECL_SIZE (tem), 1));
}
else
{
PUT_SDB_INT_VAL (int_bit_position (tem) / BITS_PER_UNIT);
PUT_SDB_SCL (member_scl);
sdbout_type (TREE_TYPE (tem));
}
PUT_SDB_ENDEF;
}
/* Output end of a structure,union, or enumeral definition. */
PUT_SDB_PLAIN_DEF ("eos");
PUT_SDB_INT_VAL (size);
PUT_SDB_SCL (C_EOS);
PUT_SDB_TAG (KNOWN_TYPE_TAG (type));
PUT_SDB_SIZE (size);
PUT_SDB_ENDEF;
break;
}
default:
break;
}
}
