static void
show_tree (tree node)
{
if (!CAN_HAVE_RANGE_P (node))
return;
gcc_rich_location richloc (EXPR_LOCATION (node));
richloc.add_expr (node);
if (richloc.get_num_locations () < 2)
{
error_at (&richloc, "range not found");
return;
}
enum tree_code code = TREE_CODE (node);
location_range *range = richloc.get_range (1);
inform (&richloc, "%s", get_tree_code_name (code));
/* Recurse. */
int min_idx = 0;
int max_idx = TREE_OPERAND_LENGTH (node);
switch (code)
{
case CALL_EXPR:
min_idx = 3;
break;
default:
break;
}
for (int i = min_idx; i < max_idx; i++)
show_tree (TREE_OPERAND (node, i));
}
const char *
lto_tag_name (enum LTO_tags tag)
{
if (lto_tag_is_tree_code_p (tag))
{
/* For tags representing tree nodes, return the name of the
associated tree code. */
return get_tree_code_name (lto_tag_to_tree_code (tag));
}
if (lto_tag_is_gimple_code_p (tag))
{
/* For tags representing gimple statements, return the name of
the associated gimple code. */
return gimple_code_name[lto_tag_to_gimple_code (tag)];
}
switch (tag)
{
case LTO_null:
return "LTO_null";
case LTO_bb0:
return "LTO_bb0";
case LTO_bb1:
return "LTO_bb1";
case LTO_eh_region:
return "LTO_eh_region";
case LTO_function:
return "LTO_function";
case LTO_eh_table:
return "LTO_eh_table";
case LTO_ert_cleanup:
return "LTO_ert_cleanup";
case LTO_ert_try:
return "LTO_ert_try";
case LTO_ert_allowed_exceptions:
return "LTO_ert_allowed_exceptions";
case LTO_ert_must_not_throw:
return "LTO_ert_must_not_throw";
case LTO_tree_pickle_reference:
return "LTO_tree_pickle_reference";
case LTO_field_decl_ref:
return "LTO_field_decl_ref";
case LTO_function_decl_ref:
return "LTO_function_decl_ref";
case LTO_label_decl_ref:
return "LTO_label_decl_ref";
case LTO_namespace_decl_ref:
return "LTO_namespace_decl_ref";
case LTO_result_decl_ref:
return "LTO_result_decl_ref";
case LTO_ssa_name_ref:
return "LTO_ssa_name_ref";
case LTO_type_decl_ref:
return "LTO_type_decl_ref";
case LTO_type_ref:
return "LTO_type_ref";
case LTO_global_decl_ref:
return "LTO_global_decl_ref";
default:
return "LTO_UNKNOWN";
}
}
void
print_lto_report (const char *s)
{
unsigned i;
fprintf (stderr, "[%s] # of input files: "
HOST_WIDE_INT_PRINT_UNSIGNED "\n", s, lto_stats.num_input_files);
fprintf (stderr, "[%s] # of input cgraph nodes: "
HOST_WIDE_INT_PRINT_UNSIGNED "\n", s,
lto_stats.num_input_cgraph_nodes);
fprintf (stderr, "[%s] # of function bodies: "
HOST_WIDE_INT_PRINT_UNSIGNED "\n", s,
lto_stats.num_function_bodies);
for (i = 0; i < NUM_TREE_CODES; i++)
if (lto_stats.num_trees[i])
fprintf (stderr, "[%s] # of '%s' objects read: "
HOST_WIDE_INT_PRINT_UNSIGNED "\n", s,
get_tree_code_name ((enum tree_code) i), lto_stats.num_trees[i]);
if (flag_lto)
{
fprintf (stderr, "[%s] Compression: "
HOST_WIDE_INT_PRINT_UNSIGNED " output bytes, "
HOST_WIDE_INT_PRINT_UNSIGNED " compressed bytes", s,
lto_stats.num_output_il_bytes,
lto_stats.num_compressed_il_bytes);
if (lto_stats.num_output_il_bytes > 0)
{
const float dividend = (float) lto_stats.num_compressed_il_bytes;
const float divisor = (float) lto_stats.num_output_il_bytes;
fprintf (stderr, " (ratio: %f)", dividend / divisor);
}
fprintf (stderr, "\n");
}
if (flag_wpa)
{
fprintf (stderr, "[%s] # of output files: "
HOST_WIDE_INT_PRINT_UNSIGNED "\n", s,
lto_stats.num_output_files);
fprintf (stderr, "[%s] # of output symtab nodes: "
HOST_WIDE_INT_PRINT_UNSIGNED "\n", s,
lto_stats.num_output_symtab_nodes);
fprintf (stderr, "[%s] # of output tree pickle references: "
HOST_WIDE_INT_PRINT_UNSIGNED "\n", s,
lto_stats.num_pickle_refs_output);
fprintf (stderr, "[%s] # of output tree bodies: "
HOST_WIDE_INT_PRINT_UNSIGNED "\n", s,
lto_stats.num_tree_bodies_output);
fprintf (stderr, "[%s] # callgraph partitions: "
HOST_WIDE_INT_PRINT_UNSIGNED "\n", s,
lto_stats.num_cgraph_partitions);
fprintf (stderr, "[%s] Compression: "
HOST_WIDE_INT_PRINT_UNSIGNED " input bytes, "
HOST_WIDE_INT_PRINT_UNSIGNED " uncompressed bytes", s,
lto_stats.num_input_il_bytes,
lto_stats.num_uncompressed_il_bytes);
if (lto_stats.num_input_il_bytes > 0)
{
const float dividend = (float) lto_stats.num_uncompressed_il_bytes;
const float divisor = (float) lto_stats.num_input_il_bytes;
fprintf (stderr, " (ratio: %f)", dividend / divisor);
}
fprintf (stderr, "\n");
}
for (i = 0; i < LTO_N_SECTION_TYPES; i++)
fprintf (stderr, "[%s] Size of mmap'd section %s: "
HOST_WIDE_INT_PRINT_UNSIGNED " bytes\n", s,
lto_section_name[i], lto_stats.section_size[i]);
}
void
print_node_brief (FILE *file, const char *prefix, const_tree node, int indent)
{
enum tree_code_class tclass;
if (node == 0)
return;
tclass = TREE_CODE_CLASS (TREE_CODE (node));
/* Always print the slot this node is in, and its code, address and
name if any. */
if (indent > 0)
fprintf (file, " ");
fprintf (file, "%s <%s", prefix, get_tree_code_name (TREE_CODE (node)));
dump_addr (file, " ", node);
if (tclass == tcc_declaration)
{
if (DECL_NAME (node))
fprintf (file, " %s", IDENTIFIER_POINTER (DECL_NAME (node)));
else if (TREE_CODE (node) == LABEL_DECL
&& LABEL_DECL_UID (node) != -1)
{
if (dump_flags & TDF_NOUID)
fprintf (file, " L.xxxx");
else
fprintf (file, " L.%d", (int) LABEL_DECL_UID (node));
}
else
{
if (dump_flags & TDF_NOUID)
fprintf (file, " %c.xxxx",
TREE_CODE (node) == CONST_DECL ? 'C' : 'D');
else
fprintf (file, " %c.%u",
TREE_CODE (node) == CONST_DECL ? 'C' : 'D',
DECL_UID (node));
}
}
else if (tclass == tcc_type)
{
if (TYPE_NAME (node))
{
if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
fprintf (file, " %s", IDENTIFIER_POINTER (TYPE_NAME (node)));
else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
&& DECL_NAME (TYPE_NAME (node)))
fprintf (file, " %s",
IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node))));
}
if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))
fprintf (file, " address-space-%d", TYPE_ADDR_SPACE (node));
}
if (TREE_CODE (node) == IDENTIFIER_NODE)
fprintf (file, " %s", IDENTIFIER_POINTER (node));
/* We might as well always print the value of an integer or real. */
if (TREE_CODE (node) == INTEGER_CST)
{
if (TREE_OVERFLOW (node))
fprintf (file, " overflow");
fprintf (file, " ");
print_dec (node, file, TYPE_SIGN (TREE_TYPE (node)));
}
if (TREE_CODE (node) == REAL_CST)
{
REAL_VALUE_TYPE d;
if (TREE_OVERFLOW (node))
fprintf (file, " overflow");
d = TREE_REAL_CST (node);
if (REAL_VALUE_ISINF (d))
fprintf (file, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf");
else if (REAL_VALUE_ISNAN (d))
fprintf (file, " Nan");
else
{
char string[60];
real_to_decimal (string, &d, sizeof (string), 0, 1);
fprintf (file, " %s", string);
}
}
if (TREE_CODE (node) == FIXED_CST)
{
FIXED_VALUE_TYPE f;
char string[60];
if (TREE_OVERFLOW (node))
fprintf (file, " overflow");
f = TREE_FIXED_CST (node);
fixed_to_decimal (string, &f, sizeof (string));
fprintf (file, " %s", string);
}
fprintf (file, ">");
}
void
print_node (FILE *file, const char *prefix, tree node, int indent)
{
int hash;
struct bucket *b;
machine_mode mode;
enum tree_code_class tclass;
int len;
int i;
expanded_location xloc;
enum tree_code code;
if (node == 0)
return;
code = TREE_CODE (node);
tclass = TREE_CODE_CLASS (code);
/* Don't get too deep in nesting. If the user wants to see deeper,
it is easy to use the address of a lowest-level node
as an argument in another call to debug_tree. */
if (indent > 24)
{
print_node_brief (file, prefix, node, indent);
return;
}
if (indent > 8 && (tclass == tcc_type || tclass == tcc_declaration))
{
print_node_brief (file, prefix, node, indent);
return;
}
/* It is unsafe to look at any other fields of an ERROR_MARK node. */
if (code == ERROR_MARK)
{
print_node_brief (file, prefix, node, indent);
return;
}
/* Allow this function to be called if the table is not there. */
if (table)
{
hash = ((uintptr_t) node) % HASH_SIZE;
/* If node is in the table, just mention its address. */
for (b = table[hash]; b; b = b->next)
if (b->node == node)
{
print_node_brief (file, prefix, node, indent);
return;
}
/* Add this node to the table. */
b = XNEW (struct bucket);
b->node = node;
b->next = table[hash];
table[hash] = b;
}
/* Indent to the specified column, since this is the long form. */
indent_to (file, indent);
/* Print the slot this node is in, and its code, and address. */
fprintf (file, "%s <%s", prefix, get_tree_code_name (code));
dump_addr (file, " ", node);
/* Print the name, if any. */
if (tclass == tcc_declaration)
{
if (DECL_NAME (node))
fprintf (file, " %s", IDENTIFIER_POINTER (DECL_NAME (node)));
else if (code == LABEL_DECL
&& LABEL_DECL_UID (node) != -1)
{
if (dump_flags & TDF_NOUID)
fprintf (file, " L.xxxx");
else
fprintf (file, " L.%d", (int) LABEL_DECL_UID (node));
}
else
{
if (dump_flags & TDF_NOUID)
fprintf (file, " %c.xxxx", code == CONST_DECL ? 'C' : 'D');
else
fprintf (file, " %c.%u", code == CONST_DECL ? 'C' : 'D',
DECL_UID (node));
}
}
else if (tclass == tcc_type)
{
if (TYPE_NAME (node))
{
if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
fprintf (file, " %s", IDENTIFIER_POINTER (TYPE_NAME (node)));
else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
&& DECL_NAME (TYPE_NAME (node)))
fprintf (file, " %s",
IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node))));
}
}
if (code == IDENTIFIER_NODE)
fprintf (file, " %s", IDENTIFIER_POINTER (node));
if (code == INTEGER_CST)
{
if (indent <= 4)
print_node_brief (file, "type", TREE_TYPE (node), indent + 4);
}
else if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
{
print_node (file, "type", TREE_TYPE (node), indent + 4);
if (TREE_TYPE (node))
indent_to (file, indent + 3);
}
if (!TYPE_P (node) && TREE_SIDE_EFFECTS (node))
fputs (" side-effects", file);
if (TYPE_P (node) ? TYPE_READONLY (node) : TREE_READONLY (node))
fputs (" readonly", file);
if (TYPE_P (node) && TYPE_ATOMIC (node))
fputs (" atomic", file);
if (!TYPE_P (node) && TREE_CONSTANT (node))
fputs (" constant", file);
else if (TYPE_P (node) && TYPE_SIZES_GIMPLIFIED (node))
fputs (" sizes-gimplified", file);
if (TYPE_P (node) && !ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))
fprintf (file, " address-space-%d", TYPE_ADDR_SPACE (node));
if (TREE_ADDRESSABLE (node))
fputs (" addressable", file);
if (TREE_THIS_VOLATILE (node))
fputs (" volatile", file);
if (TREE_ASM_WRITTEN (node))
fputs (" asm_written", file);
if (TREE_USED (node))
fputs (" used", file);
if (TREE_NOTHROW (node))
fputs (" nothrow", file);
if (TREE_PUBLIC (node))
fputs (" public", file);
if (TREE_PRIVATE (node))
fputs (" private", file);
if (TREE_PROTECTED (node))
fputs (" protected", file);
if (TREE_STATIC (node))
fputs (code == CALL_EXPR ? " must-tail-call" : " static", file);
if (TREE_DEPRECATED (node))
fputs (" deprecated", file);
if (TREE_VISITED (node))
fputs (" visited", file);
if (code != TREE_VEC && code != INTEGER_CST && code != SSA_NAME)
{
if (TREE_LANG_FLAG_0 (node))
fputs (" tree_0", file);
if (TREE_LANG_FLAG_1 (node))
fputs (" tree_1", file);
if (TREE_LANG_FLAG_2 (node))
fputs (" tree_2", file);
if (TREE_LANG_FLAG_3 (node))
fputs (" tree_3", file);
if (TREE_LANG_FLAG_4 (node))
fputs (" tree_4", file);
if (TREE_LANG_FLAG_5 (node))
fputs (" tree_5", file);
if (TREE_LANG_FLAG_6 (node))
fputs (" tree_6", file);
}
/* DECL_ nodes have additional attributes. */
switch (TREE_CODE_CLASS (code))
{
case tcc_declaration:
if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
{
if (DECL_UNSIGNED (node))
fputs (" unsigned", file);
if (DECL_IGNORED_P (node))
fputs (" ignored", file);
if (DECL_ABSTRACT_P (node))
fputs (" abstract", file);
if (DECL_EXTERNAL (node))
fputs (" external", file);
if (DECL_NONLOCAL (node))
fputs (" nonlocal", file);
}
if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
{
if (DECL_WEAK (node))
fputs (" weak", file);
if (DECL_IN_SYSTEM_HEADER (node))
fputs (" in_system_header", file);
}
if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL)
&& code != LABEL_DECL
&& code != FUNCTION_DECL
&& DECL_REGISTER (node))
fputs (" regdecl", file);
if (code == TYPE_DECL && TYPE_DECL_SUPPRESS_DEBUG (node))
fputs (" suppress-debug", file);
if (code == FUNCTION_DECL
&& DECL_FUNCTION_SPECIFIC_TARGET (node))
fputs (" function-specific-target", file);
if (code == FUNCTION_DECL
&& DECL_FUNCTION_SPECIFIC_OPTIMIZATION (node))
fputs (" function-specific-opt", file);
if (code == FUNCTION_DECL && DECL_DECLARED_INLINE_P (node))
fputs (" autoinline", file);
if (code == FUNCTION_DECL && DECL_BUILT_IN (node))
fputs (" built-in", file);
if (code == FUNCTION_DECL && DECL_STATIC_CHAIN (node))
fputs (" static-chain", file);
if (TREE_CODE (node) == FUNCTION_DECL && decl_is_tm_clone (node))
fputs (" tm-clone", file);
if (code == FIELD_DECL && DECL_PACKED (node))
fputs (" packed", file);
if (code == FIELD_DECL && DECL_BIT_FIELD (node))
fputs (" bit-field", file);
if (code == FIELD_DECL && DECL_NONADDRESSABLE_P (node))
fputs (" nonaddressable", file);
if (code == LABEL_DECL && EH_LANDING_PAD_NR (node))
fprintf (file, " landing-pad:%d", EH_LANDING_PAD_NR (node));
if (code == VAR_DECL && DECL_IN_TEXT_SECTION (node))
fputs (" in-text-section", file);
if (code == VAR_DECL && DECL_IN_CONSTANT_POOL (node))
fputs (" in-constant-pool", file);
if (code == VAR_DECL && DECL_COMMON (node))
fputs (" common", file);
if (code == VAR_DECL && DECL_THREAD_LOCAL_P (node))
{
fputs (" ", file);
fputs (tls_model_names[DECL_TLS_MODEL (node)], file);
}
if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
{
if (DECL_VIRTUAL_P (node))
fputs (" virtual", file);
if (DECL_PRESERVE_P (node))
fputs (" preserve", file);
if (DECL_LANG_FLAG_0 (node))
fputs (" decl_0", file);
if (DECL_LANG_FLAG_1 (node))
fputs (" decl_1", file);
if (DECL_LANG_FLAG_2 (node))
fputs (" decl_2", file);
if (DECL_LANG_FLAG_3 (node))
fputs (" decl_3", file);
if (DECL_LANG_FLAG_4 (node))
fputs (" decl_4", file);
if (DECL_LANG_FLAG_5 (node))
fputs (" decl_5", file);
if (DECL_LANG_FLAG_6 (node))
fputs (" decl_6", file);
if (DECL_LANG_FLAG_7 (node))
fputs (" decl_7", file);
mode = DECL_MODE (node);
fprintf (file, " %s", GET_MODE_NAME (mode));
}
if ((code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
&& DECL_BY_REFERENCE (node))
fputs (" passed-by-reference", file);
if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS) && DECL_DEFER_OUTPUT (node))
fputs (" defer-output", file);
xloc = expand_location (DECL_SOURCE_LOCATION (node));
fprintf (file, " file %s line %d col %d", xloc.file, xloc.line,
xloc.column);
if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
{
print_node (file, "size", DECL_SIZE (node), indent + 4);
print_node (file, "unit size", DECL_SIZE_UNIT (node), indent + 4);
if (code != FUNCTION_DECL || DECL_BUILT_IN (node))
indent_to (file, indent + 3);
if (DECL_USER_ALIGN (node))
fprintf (file, " user");
fprintf (file, " align %d", DECL_ALIGN (node));
if (code == FIELD_DECL)
fprintf (file, " offset_align " HOST_WIDE_INT_PRINT_UNSIGNED,
DECL_OFFSET_ALIGN (node));
if (code == FUNCTION_DECL && DECL_BUILT_IN (node))
{
if (DECL_BUILT_IN_CLASS (node) == BUILT_IN_MD)
fprintf (file, " built-in BUILT_IN_MD %d", DECL_FUNCTION_CODE (node));
else
fprintf (file, " built-in %s:%s",
built_in_class_names[(int) DECL_BUILT_IN_CLASS (node)],
built_in_names[(int) DECL_FUNCTION_CODE (node)]);
}
}
if (code == FIELD_DECL)
{
print_node (file, "offset", DECL_FIELD_OFFSET (node), indent + 4);
print_node (file, "bit offset", DECL_FIELD_BIT_OFFSET (node),
indent + 4);
if (DECL_BIT_FIELD_TYPE (node))
print_node (file, "bit_field_type", DECL_BIT_FIELD_TYPE (node),
indent + 4);
}
print_node_brief (file, "context", DECL_CONTEXT (node), indent + 4);
if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
{
print_node_brief (file, "attributes",
DECL_ATTRIBUTES (node), indent + 4);
if (code != PARM_DECL)
print_node_brief (file, "initial", DECL_INITIAL (node),
indent + 4);
}
if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
{
print_node_brief (file, "abstract_origin",
DECL_ABSTRACT_ORIGIN (node), indent + 4);
}
if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
{
print_node (file, "result", DECL_RESULT_FLD (node), indent + 4);
}
lang_hooks.print_decl (file, node, indent);
if (DECL_RTL_SET_P (node))
{
indent_to (file, indent + 4);
print_rtl (file, DECL_RTL (node));
}
if (code == PARM_DECL)
{
print_node (file, "arg-type", DECL_ARG_TYPE (node), indent + 4);
if (DECL_INCOMING_RTL (node) != 0)
{
indent_to (file, indent + 4);
fprintf (file, "incoming-rtl ");
print_rtl (file, DECL_INCOMING_RTL (node));
}
}
else if (code == FUNCTION_DECL
&& DECL_STRUCT_FUNCTION (node) != 0)
{
print_node (file, "arguments", DECL_ARGUMENTS (node), indent + 4);
indent_to (file, indent + 4);
dump_addr (file, "struct-function ", DECL_STRUCT_FUNCTION (node));
}
if ((code == VAR_DECL || code == PARM_DECL)
&& DECL_HAS_VALUE_EXPR_P (node))
print_node (file, "value-expr", DECL_VALUE_EXPR (node), indent + 4);
/* Print the decl chain only if decl is at second level. */
if (indent == 4)
print_node (file, "chain", TREE_CHAIN (node), indent + 4);
else
print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4);
break;
case tcc_type:
if (TYPE_UNSIGNED (node))
fputs (" unsigned", file);
if (TYPE_NO_FORCE_BLK (node))
fputs (" no-force-blk", file);
if (TYPE_STRING_FLAG (node))
fputs (" string-flag", file);
if (TYPE_NEEDS_CONSTRUCTING (node))
fputs (" needs-constructing", file);
if ((code == RECORD_TYPE
|| code == UNION_TYPE
|| code == QUAL_UNION_TYPE
|| code == ARRAY_TYPE)
&& TYPE_REVERSE_STORAGE_ORDER (node))
fputs (" reverse-storage-order", file);
/* The transparent-union flag is used for different things in
different nodes. */
if ((code == UNION_TYPE || code == RECORD_TYPE)
&& TYPE_TRANSPARENT_AGGR (node))
fputs (" transparent-aggr", file);
else if (code == ARRAY_TYPE
&& TYPE_NONALIASED_COMPONENT (node))
fputs (" nonaliased-component", file);
if (TYPE_PACKED (node))
fputs (" packed", file);
if (TYPE_RESTRICT (node))
fputs (" restrict", file);
if (TYPE_LANG_FLAG_0 (node))
fputs (" type_0", file);
if (TYPE_LANG_FLAG_1 (node))
fputs (" type_1", file);
if (TYPE_LANG_FLAG_2 (node))
fputs (" type_2", file);
if (TYPE_LANG_FLAG_3 (node))
fputs (" type_3", file);
if (TYPE_LANG_FLAG_4 (node))
fputs (" type_4", file);
if (TYPE_LANG_FLAG_5 (node))
fputs (" type_5", file);
if (TYPE_LANG_FLAG_6 (node))
fputs (" type_6", file);
if (TYPE_LANG_FLAG_7 (node))
fputs (" type_7", file);
mode = TYPE_MODE (node);
fprintf (file, " %s", GET_MODE_NAME (mode));
print_node (file, "size", TYPE_SIZE (node), indent + 4);
print_node (file, "unit size", TYPE_SIZE_UNIT (node), indent + 4);
indent_to (file, indent + 3);
if (TYPE_USER_ALIGN (node))
fprintf (file, " user");
fprintf (file, " align %d symtab %d alias set " HOST_WIDE_INT_PRINT_DEC,
TYPE_ALIGN (node), TYPE_SYMTAB_ADDRESS (node),
(HOST_WIDE_INT) TYPE_ALIAS_SET (node));
if (TYPE_STRUCTURAL_EQUALITY_P (node))
fprintf (file, " structural equality");
else
dump_addr (file, " canonical type ", TYPE_CANONICAL (node));
print_node (file, "attributes", TYPE_ATTRIBUTES (node), indent + 4);
if (INTEGRAL_TYPE_P (node) || code == REAL_TYPE
|| code == FIXED_POINT_TYPE)
{
fprintf (file, " precision %d", TYPE_PRECISION (node));
print_node_brief (file, "min", TYPE_MIN_VALUE (node), indent + 4);
print_node_brief (file, "max", TYPE_MAX_VALUE (node), indent + 4);
}
if (code == ENUMERAL_TYPE)
print_node (file, "values", TYPE_VALUES (node), indent + 4);
else if (code == ARRAY_TYPE)
print_node (file, "domain", TYPE_DOMAIN (node), indent + 4);
else if (code == VECTOR_TYPE)
fprintf (file, " nunits %d", (int) TYPE_VECTOR_SUBPARTS (node));
else if (code == RECORD_TYPE
|| code == UNION_TYPE
|| code == QUAL_UNION_TYPE)
print_node (file, "fields", TYPE_FIELDS (node), indent + 4);
else if (code == FUNCTION_TYPE
|| code == METHOD_TYPE)
{
if (TYPE_METHOD_BASETYPE (node))
print_node_brief (file, "method basetype",
TYPE_METHOD_BASETYPE (node), indent + 4);
print_node (file, "arg-types", TYPE_ARG_TYPES (node), indent + 4);
}
else if (code == OFFSET_TYPE)
print_node_brief (file, "basetype", TYPE_OFFSET_BASETYPE (node),
indent + 4);
if (TYPE_CONTEXT (node))
print_node_brief (file, "context", TYPE_CONTEXT (node), indent + 4);
lang_hooks.print_type (file, node, indent);
if (TYPE_POINTER_TO (node) || TREE_CHAIN (node))
indent_to (file, indent + 3);
print_node_brief (file, "pointer_to_this", TYPE_POINTER_TO (node),
indent + 4);
print_node_brief (file, "reference_to_this", TYPE_REFERENCE_TO (node),
indent + 4);
print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4);
break;
case tcc_expression:
case tcc_comparison:
case tcc_unary:
case tcc_binary:
case tcc_reference:
case tcc_statement:
case tcc_vl_exp:
if (code == BIND_EXPR)
{
print_node (file, "vars", TREE_OPERAND (node, 0), indent + 4);
print_node (file, "body", TREE_OPERAND (node, 1), indent + 4);
print_node (file, "block", TREE_OPERAND (node, 2), indent + 4);
break;
}
if (code == CALL_EXPR)
{
call_expr_arg_iterator iter;
tree arg;
print_node (file, "fn", CALL_EXPR_FN (node), indent + 4);
print_node (file, "static_chain", CALL_EXPR_STATIC_CHAIN (node),
indent + 4);
i = 0;
FOR_EACH_CALL_EXPR_ARG (arg, iter, node)
{
char temp[10];
sprintf (temp, "arg %d", i);
print_node (file, temp, arg, indent + 4);
i++;
}
}
void
expr_hash_elt::print (FILE *stream)
{
fprintf (stream, "STMT ");
if (m_lhs)
{
print_generic_expr (stream, m_lhs, 0);
fprintf (stream, " = ");
}
switch (m_expr.kind)
{
case EXPR_SINGLE:
print_generic_expr (stream, m_expr.ops.single.rhs, 0);
break;
case EXPR_UNARY:
fprintf (stream, "%s ", get_tree_code_name (m_expr.ops.unary.op));
print_generic_expr (stream, m_expr.ops.unary.opnd, 0);
break;
case EXPR_BINARY:
print_generic_expr (stream, m_expr.ops.binary.opnd0, 0);
fprintf (stream, " %s ", get_tree_code_name (m_expr.ops.binary.op));
print_generic_expr (stream, m_expr.ops.binary.opnd1, 0);
break;
case EXPR_TERNARY:
fprintf (stream, " %s <", get_tree_code_name (m_expr.ops.ternary.op));
print_generic_expr (stream, m_expr.ops.ternary.opnd0, 0);
fputs (", ", stream);
print_generic_expr (stream, m_expr.ops.ternary.opnd1, 0);
fputs (", ", stream);
print_generic_expr (stream, m_expr.ops.ternary.opnd2, 0);
fputs (">", stream);
break;
case EXPR_CALL:
{
size_t i;
size_t nargs = m_expr.ops.call.nargs;
gcall *fn_from;
fn_from = m_expr.ops.call.fn_from;
if (gimple_call_internal_p (fn_from))
fputs (internal_fn_name (gimple_call_internal_fn (fn_from)),
stream);
else
print_generic_expr (stream, gimple_call_fn (fn_from), 0);
fprintf (stream, " (");
for (i = 0; i < nargs; i++)
{
print_generic_expr (stream, m_expr.ops.call.args[i], 0);
if (i + 1 < nargs)
fprintf (stream, ", ");
}
fprintf (stream, ")");
}
break;
case EXPR_PHI:
{
size_t i;
size_t nargs = m_expr.ops.phi.nargs;
fprintf (stream, "PHI <");
for (i = 0; i < nargs; i++)
{
print_generic_expr (stream, m_expr.ops.phi.args[i], 0);
if (i + 1 < nargs)
fprintf (stream, ", ");
}
fprintf (stream, ">");
}
break;
}
if (m_vop)
{
fprintf (stream, " with ");
print_generic_expr (stream, m_vop, 0);
}
fprintf (stream, "\n");
}
template < class Context > Return call (tree t)
{
enum tree_code tc = t->typed.base.code;
switch (tc)
{
case TC_IDENTIFIER_NODE::t_code_c:
return ((Context *) this)->call_type_IDENTIFIER_NODE (t);
break;
case TC_TREE_LIST::t_code_c:
return ((Context *) this)->call_type_TREE_LIST (t);
break;
case TC_TREE_VEC::t_code_c:
return ((Context *) this)->call_type_TREE_VEC (t);
break;
case TC_BLOCK::t_code_c:
return ((Context *) this)->call_type_BLOCK (t);
break;
case TC_OFFSET_TYPE::t_code_c:
return ((Context *) this)->call_type_OFFSET_TYPE (t);
break;
case TC_ENUMERAL_TYPE::t_code_c:
return ((Context *) this)->call_type_ENUMERAL_TYPE (t);
break;
case TC_BOOLEAN_TYPE::t_code_c:
return ((Context *) this)->call_type_BOOLEAN_TYPE (t);
break;
case TC_INTEGER_TYPE::t_code_c:
return ((Context *) this)->call_type_INTEGER_TYPE (t);
break;
case TC_REAL_TYPE::t_code_c:
return ((Context *) this)->call_type_REAL_TYPE (t);
break;
case TC_POINTER_TYPE::t_code_c:
return ((Context *) this)->call_type_POINTER_TYPE (t);
break;
case TC_REFERENCE_TYPE::t_code_c:
return ((Context *) this)->call_type_REFERENCE_TYPE (t);
break;
case TC_NULLPTR_TYPE::t_code_c:
return ((Context *) this)->call_type_NULLPTR_TYPE (t);
break;
case TC_FIXED_POINT_TYPE::t_code_c:
return ((Context *) this)->call_type_FIXED_POINT_TYPE (t);
break;
case TC_COMPLEX_TYPE::t_code_c:
return ((Context *) this)->call_type_COMPLEX_TYPE (t);
break;
case TC_VECTOR_TYPE::t_code_c:
return ((Context *) this)->call_type_VECTOR_TYPE (t);
break;
case TC_ARRAY_TYPE::t_code_c:
return ((Context *) this)->call_type_ARRAY_TYPE (t);
break;
case TC_RECORD_TYPE::t_code_c:
return ((Context *) this)->call_type_RECORD_TYPE (t);
break;
case TC_UNION_TYPE::t_code_c:
return ((Context *) this)->call_type_UNION_TYPE (t);
break;
case TC_QUAL_UNION_TYPE::t_code_c:
return ((Context *) this)->call_type_QUAL_UNION_TYPE (t);
break;
case TC_VOID_TYPE::t_code_c:
return ((Context *) this)->call_type_VOID_TYPE (t);
break;
case TC_POINTER_BOUNDS_TYPE::t_code_c:
return ((Context *) this)->call_type_POINTER_BOUNDS_TYPE (t);
break;
case TC_FUNCTION_TYPE::t_code_c:
return ((Context *) this)->call_type_FUNCTION_TYPE (t);
break;
case TC_METHOD_TYPE::t_code_c:
return ((Context *) this)->call_type_METHOD_TYPE (t);
break;
case TC_LANG_TYPE::t_code_c:
return ((Context *) this)->call_type_LANG_TYPE (t);
break;
case TC_VOID_CST::t_code_c:
return ((Context *) this)->call_type_VOID_CST (t);
break;
case TC_INTEGER_CST::t_code_c:
return ((Context *) this)->call_type_INTEGER_CST (t);
break;
case TC_REAL_CST::t_code_c:
return ((Context *) this)->call_type_REAL_CST (t);
break;
case TC_FIXED_CST::t_code_c:
return ((Context *) this)->call_type_FIXED_CST (t);
break;
case TC_COMPLEX_CST::t_code_c:
return ((Context *) this)->call_type_COMPLEX_CST (t);
break;
case TC_VECTOR_CST::t_code_c:
return ((Context *) this)->call_type_VECTOR_CST (t);
break;
case TC_STRING_CST::t_code_c:
return ((Context *) this)->call_type_STRING_CST (t);
break;
case TC_FUNCTION_DECL::t_code_c:
return ((Context *) this)->call_type_FUNCTION_DECL (t);
break;
case TC_LABEL_DECL::t_code_c:
return ((Context *) this)->call_type_LABEL_DECL (t);
break;
case TC_FIELD_DECL::t_code_c:
return ((Context *) this)->call_type_FIELD_DECL (t);
break;
case TC_VAR_DECL::t_code_c:
return ((Context *) this)->call_type_VAR_DECL (t);
break;
case TC_CONST_DECL::t_code_c:
return ((Context *) this)->call_type_CONST_DECL (t);
break;
case TC_PARM_DECL::t_code_c:
return ((Context *) this)->call_type_PARM_DECL (t);
break;
case TC_TYPE_DECL::t_code_c:
return ((Context *) this)->call_type_TYPE_DECL (t);
break;
case TC_RESULT_DECL::t_code_c:
return ((Context *) this)->call_type_RESULT_DECL (t);
break;
case TC_DEBUG_EXPR_DECL::t_code_c:
return ((Context *) this)->call_type_DEBUG_EXPR_DECL (t);
break;
case TC_NAMESPACE_DECL::t_code_c:
return ((Context *) this)->call_type_NAMESPACE_DECL (t);
break;
case TC_IMPORTED_DECL::t_code_c:
return ((Context *) this)->call_type_IMPORTED_DECL (t);
break;
case TC_NAMELIST_DECL::t_code_c:
return ((Context *) this)->call_type_NAMELIST_DECL (t);
break;
case TC_TRANSLATION_UNIT_DECL::t_code_c:
return ((Context *) this)->call_type_TRANSLATION_UNIT_DECL (t);
break;
case TC_COMPONENT_REF::t_code_c:
return ((Context *) this)->call_type_COMPONENT_REF (t);
break;
case TC_BIT_FIELD_REF::t_code_c:
return ((Context *) this)->call_type_BIT_FIELD_REF (t);
break;
case TC_ARRAY_REF::t_code_c:
return ((Context *) this)->call_type_ARRAY_REF (t);
break;
case TC_ARRAY_RANGE_REF::t_code_c:
return ((Context *) this)->call_type_ARRAY_RANGE_REF (t);
break;
case TC_REALPART_EXPR::t_code_c:
return ((Context *) this)->call_type_REALPART_EXPR (t);
break;
case TC_IMAGPART_EXPR::t_code_c:
return ((Context *) this)->call_type_IMAGPART_EXPR (t);
break;
case TC_VIEW_CONVERT_EXPR::t_code_c:
return ((Context *) this)->call_type_VIEW_CONVERT_EXPR (t);
break;
case TC_INDIRECT_REF::t_code_c:
return ((Context *) this)->call_type_INDIRECT_REF (t);
break;
case TC_OBJ_TYPE_REF::t_code_c:
return ((Context *) this)->call_type_OBJ_TYPE_REF (t);
break;
case TC_CONSTRUCTOR::t_code_c:
return ((Context *) this)->call_type_CONSTRUCTOR (t);
break;
case TC_COMPOUND_EXPR::t_code_c:
return ((Context *) this)->call_type_COMPOUND_EXPR (t);
break;
case TC_MODIFY_EXPR::t_code_c:
return ((Context *) this)->call_type_MODIFY_EXPR (t);
break;
case TC_INIT_EXPR::t_code_c:
return ((Context *) this)->call_type_INIT_EXPR (t);
break;
case TC_TARGET_EXPR::t_code_c:
return ((Context *) this)->call_type_TARGET_EXPR (t);
break;
case TC_COND_EXPR::t_code_c:
return ((Context *) this)->call_type_COND_EXPR (t);
break;
case TC_VEC_COND_EXPR::t_code_c:
return ((Context *) this)->call_type_VEC_COND_EXPR (t);
break;
case TC_VEC_PERM_EXPR::t_code_c:
return ((Context *) this)->call_type_VEC_PERM_EXPR (t);
break;
case TC_BIND_EXPR::t_code_c:
return ((Context *) this)->call_type_BIND_EXPR (t);
break;
case TC_CALL_EXPR::t_code_c:
return ((Context *) this)->call_type_CALL_EXPR (t);
break;
case TC_WITH_CLEANUP_EXPR::t_code_c:
return ((Context *) this)->call_type_WITH_CLEANUP_EXPR (t);
break;
case TC_CLEANUP_POINT_EXPR::t_code_c:
return ((Context *) this)->call_type_CLEANUP_POINT_EXPR (t);
break;
case TC_PLACEHOLDER_EXPR::t_code_c:
return ((Context *) this)->call_type_PLACEHOLDER_EXPR (t);
break;
case TC_PLUS_EXPR::t_code_c:
return ((Context *) this)->call_type_PLUS_EXPR (t);
break;
case TC_MINUS_EXPR::t_code_c:
return ((Context *) this)->call_type_MINUS_EXPR (t);
break;
case TC_MULT_EXPR::t_code_c:
return ((Context *) this)->call_type_MULT_EXPR (t);
break;
case TC_POINTER_PLUS_EXPR::t_code_c:
return ((Context *) this)->call_type_POINTER_PLUS_EXPR (t);
break;
case TC_MULT_HIGHPART_EXPR::t_code_c:
return ((Context *) this)->call_type_MULT_HIGHPART_EXPR (t);
break;
case TC_TRUNC_DIV_EXPR::t_code_c:
return ((Context *) this)->call_type_TRUNC_DIV_EXPR (t);
break;
case TC_CEIL_DIV_EXPR::t_code_c:
return ((Context *) this)->call_type_CEIL_DIV_EXPR (t);
break;
case TC_FLOOR_DIV_EXPR::t_code_c:
return ((Context *) this)->call_type_FLOOR_DIV_EXPR (t);
break;
case TC_ROUND_DIV_EXPR::t_code_c:
return ((Context *) this)->call_type_ROUND_DIV_EXPR (t);
break;
case TC_TRUNC_MOD_EXPR::t_code_c:
return ((Context *) this)->call_type_TRUNC_MOD_EXPR (t);
break;
case TC_CEIL_MOD_EXPR::t_code_c:
return ((Context *) this)->call_type_CEIL_MOD_EXPR (t);
break;
case TC_FLOOR_MOD_EXPR::t_code_c:
return ((Context *) this)->call_type_FLOOR_MOD_EXPR (t);
break;
case TC_ROUND_MOD_EXPR::t_code_c:
return ((Context *) this)->call_type_ROUND_MOD_EXPR (t);
break;
case TC_RDIV_EXPR::t_code_c:
return ((Context *) this)->call_type_RDIV_EXPR (t);
break;
case TC_EXACT_DIV_EXPR::t_code_c:
return ((Context *) this)->call_type_EXACT_DIV_EXPR (t);
break;
case TC_FIX_TRUNC_EXPR::t_code_c:
return ((Context *) this)->call_type_FIX_TRUNC_EXPR (t);
break;
case TC_FLOAT_EXPR::t_code_c:
return ((Context *) this)->call_type_FLOAT_EXPR (t);
break;
case TC_NEGATE_EXPR::t_code_c:
return ((Context *) this)->call_type_NEGATE_EXPR (t);
break;
case TC_MIN_EXPR::t_code_c:
return ((Context *) this)->call_type_MIN_EXPR (t);
break;
case TC_MAX_EXPR::t_code_c:
return ((Context *) this)->call_type_MAX_EXPR (t);
break;
case TC_ABS_EXPR::t_code_c:
return ((Context *) this)->call_type_ABS_EXPR (t);
break;
case TC_LSHIFT_EXPR::t_code_c:
return ((Context *) this)->call_type_LSHIFT_EXPR (t);
break;
case TC_RSHIFT_EXPR::t_code_c:
return ((Context *) this)->call_type_RSHIFT_EXPR (t);
break;
case TC_LROTATE_EXPR::t_code_c:
return ((Context *) this)->call_type_LROTATE_EXPR (t);
break;
case TC_RROTATE_EXPR::t_code_c:
return ((Context *) this)->call_type_RROTATE_EXPR (t);
break;
case TC_BIT_IOR_EXPR::t_code_c:
return ((Context *) this)->call_type_BIT_IOR_EXPR (t);
break;
case TC_BIT_XOR_EXPR::t_code_c:
return ((Context *) this)->call_type_BIT_XOR_EXPR (t);
break;
case TC_BIT_AND_EXPR::t_code_c:
return ((Context *) this)->call_type_BIT_AND_EXPR (t);
break;
case TC_BIT_NOT_EXPR::t_code_c:
return ((Context *) this)->call_type_BIT_NOT_EXPR (t);
break;
case TC_TRUTH_ANDIF_EXPR::t_code_c:
return ((Context *) this)->call_type_TRUTH_ANDIF_EXPR (t);
break;
case TC_TRUTH_ORIF_EXPR::t_code_c:
return ((Context *) this)->call_type_TRUTH_ORIF_EXPR (t);
break;
case TC_TRUTH_AND_EXPR::t_code_c:
return ((Context *) this)->call_type_TRUTH_AND_EXPR (t);
break;
case TC_TRUTH_OR_EXPR::t_code_c:
return ((Context *) this)->call_type_TRUTH_OR_EXPR (t);
break;
case TC_TRUTH_XOR_EXPR::t_code_c:
return ((Context *) this)->call_type_TRUTH_XOR_EXPR (t);
break;
case TC_TRUTH_NOT_EXPR::t_code_c:
return ((Context *) this)->call_type_TRUTH_NOT_EXPR (t);
break;
case TC_LT_EXPR::t_code_c:
return ((Context *) this)->call_type_LT_EXPR (t);
break;
case TC_LE_EXPR::t_code_c:
return ((Context *) this)->call_type_LE_EXPR (t);
break;
case TC_GT_EXPR::t_code_c:
return ((Context *) this)->call_type_GT_EXPR (t);
break;
case TC_GE_EXPR::t_code_c:
return ((Context *) this)->call_type_GE_EXPR (t);
break;
case TC_EQ_EXPR::t_code_c:
return ((Context *) this)->call_type_EQ_EXPR (t);
break;
case TC_NE_EXPR::t_code_c:
return ((Context *) this)->call_type_NE_EXPR (t);
break;
case TC_UNORDERED_EXPR::t_code_c:
return ((Context *) this)->call_type_UNORDERED_EXPR (t);
break;
case TC_ORDERED_EXPR::t_code_c:
return ((Context *) this)->call_type_ORDERED_EXPR (t);
break;
case TC_UNLT_EXPR::t_code_c:
return ((Context *) this)->call_type_UNLT_EXPR (t);
break;
case TC_UNLE_EXPR::t_code_c:
return ((Context *) this)->call_type_UNLE_EXPR (t);
break;
case TC_UNGT_EXPR::t_code_c:
return ((Context *) this)->call_type_UNGT_EXPR (t);
break;
case TC_UNGE_EXPR::t_code_c:
return ((Context *) this)->call_type_UNGE_EXPR (t);
break;
case TC_UNEQ_EXPR::t_code_c:
return ((Context *) this)->call_type_UNEQ_EXPR (t);
break;
case TC_LTGT_EXPR::t_code_c:
return ((Context *) this)->call_type_LTGT_EXPR (t);
break;
case TC_RANGE_EXPR::t_code_c:
return ((Context *) this)->call_type_RANGE_EXPR (t);
break;
case TC_PAREN_EXPR::t_code_c:
return ((Context *) this)->call_type_PAREN_EXPR (t);
break;
case TC_CONVERT_EXPR::t_code_c:
return ((Context *) this)->call_type_CONVERT_EXPR (t);
break;
case TC_ADDR_SPACE_CONVERT_EXPR::t_code_c:
return ((Context *) this)->call_type_ADDR_SPACE_CONVERT_EXPR (t);
break;
case TC_FIXED_CONVERT_EXPR::t_code_c:
return ((Context *) this)->call_type_FIXED_CONVERT_EXPR (t);
break;
case TC_NOP_EXPR::t_code_c:
return ((Context *) this)->call_type_NOP_EXPR (t);
break;
case TC_NON_LVALUE_EXPR::t_code_c:
return ((Context *) this)->call_type_NON_LVALUE_EXPR (t);
break;
case TC_COMPOUND_LITERAL_EXPR::t_code_c:
return ((Context *) this)->call_type_COMPOUND_LITERAL_EXPR (t);
break;
case TC_SAVE_EXPR::t_code_c:
return ((Context *) this)->call_type_SAVE_EXPR (t);
break;
case TC_ADDR_EXPR::t_code_c:
return ((Context *) this)->call_type_ADDR_EXPR (t);
break;
case TC_FDESC_EXPR::t_code_c:
return ((Context *) this)->call_type_FDESC_EXPR (t);
break;
case TC_COMPLEX_EXPR::t_code_c:
return ((Context *) this)->call_type_COMPLEX_EXPR (t);
break;
case TC_CONJ_EXPR::t_code_c:
return ((Context *) this)->call_type_CONJ_EXPR (t);
break;
case TC_PREDECREMENT_EXPR::t_code_c:
return ((Context *) this)->call_type_PREDECREMENT_EXPR (t);
break;
case TC_PREINCREMENT_EXPR::t_code_c:
return ((Context *) this)->call_type_PREINCREMENT_EXPR (t);
break;
case TC_POSTDECREMENT_EXPR::t_code_c:
return ((Context *) this)->call_type_POSTDECREMENT_EXPR (t);
break;
case TC_POSTINCREMENT_EXPR::t_code_c:
return ((Context *) this)->call_type_POSTINCREMENT_EXPR (t);
break;
case TC_VA_ARG_EXPR::t_code_c:
return ((Context *) this)->call_type_VA_ARG_EXPR (t);
break;
case TC_TRY_CATCH_EXPR::t_code_c:
return ((Context *) this)->call_type_TRY_CATCH_EXPR (t);
break;
case TC_TRY_FINALLY_EXPR::t_code_c:
return ((Context *) this)->call_type_TRY_FINALLY_EXPR (t);
break;
case TC_DECL_EXPR::t_code_c:
return ((Context *) this)->call_type_DECL_EXPR (t);
break;
case TC_LABEL_EXPR::t_code_c:
return ((Context *) this)->call_type_LABEL_EXPR (t);
break;
case TC_GOTO_EXPR::t_code_c:
return ((Context *) this)->call_type_GOTO_EXPR (t);
break;
case TC_RETURN_EXPR::t_code_c:
return ((Context *) this)->call_type_RETURN_EXPR (t);
break;
case TC_EXIT_EXPR::t_code_c:
return ((Context *) this)->call_type_EXIT_EXPR (t);
break;
case TC_LOOP_EXPR::t_code_c:
return ((Context *) this)->call_type_LOOP_EXPR (t);
break;
case TC_SWITCH_EXPR::t_code_c:
return ((Context *) this)->call_type_SWITCH_EXPR (t);
break;
case TC_CASE_LABEL_EXPR::t_code_c:
return ((Context *) this)->call_type_CASE_LABEL_EXPR (t);
break;
case TC_ASM_EXPR::t_code_c:
return ((Context *) this)->call_type_ASM_EXPR (t);
break;
case TC_SSA_NAME::t_code_c:
return ((Context *) this)->call_type_SSA_NAME (t);
break;
case TC_CATCH_EXPR::t_code_c:
return ((Context *) this)->call_type_CATCH_EXPR (t);
break;
case TC_EH_FILTER_EXPR::t_code_c:
return ((Context *) this)->call_type_EH_FILTER_EXPR (t);
break;
case TC_SCEV_KNOWN::t_code_c:
return ((Context *) this)->call_type_SCEV_KNOWN (t);
break;
case TC_SCEV_NOT_KNOWN::t_code_c:
return ((Context *) this)->call_type_SCEV_NOT_KNOWN (t);
break;
case TC_POLYNOMIAL_CHREC::t_code_c:
return ((Context *) this)->call_type_POLYNOMIAL_CHREC (t);
break;
case TC_STATEMENT_LIST::t_code_c:
return ((Context *) this)->call_type_STATEMENT_LIST (t);
break;
case TC_ASSERT_EXPR::t_code_c:
return ((Context *) this)->call_type_ASSERT_EXPR (t);
break;
case TC_TREE_BINFO::t_code_c:
return ((Context *) this)->call_type_TREE_BINFO (t);
break;
case TC_WITH_SIZE_EXPR::t_code_c:
return ((Context *) this)->call_type_WITH_SIZE_EXPR (t);
break;
case TC_REALIGN_LOAD_EXPR::t_code_c:
return ((Context *) this)->call_type_REALIGN_LOAD_EXPR (t);
break;
case TC_TARGET_MEM_REF::t_code_c:
return ((Context *) this)->call_type_TARGET_MEM_REF (t);
break;
case TC_MEM_REF::t_code_c:
return ((Context *) this)->call_type_MEM_REF (t);
break;
case TC_OACC_PARALLEL::t_code_c:
return ((Context *) this)->call_type_OACC_PARALLEL (t);
break;
case TC_OACC_KERNELS::t_code_c:
return ((Context *) this)->call_type_OACC_KERNELS (t);
break;
case TC_OACC_DATA::t_code_c:
return ((Context *) this)->call_type_OACC_DATA (t);
break;
case TC_OACC_HOST_DATA::t_code_c:
return ((Context *) this)->call_type_OACC_HOST_DATA (t);
break;
case TC_OMP_PARALLEL::t_code_c:
return ((Context *) this)->call_type_OMP_PARALLEL (t);
break;
case TC_OMP_TASK::t_code_c:
return ((Context *) this)->call_type_OMP_TASK (t);
break;
case TC_OMP_FOR::t_code_c:
return ((Context *) this)->call_type_OMP_FOR (t);
break;
case TC_OMP_SIMD::t_code_c:
return ((Context *) this)->call_type_OMP_SIMD (t);
break;
case TC_CILK_SIMD::t_code_c:
return ((Context *) this)->call_type_CILK_SIMD (t);
break;
case TC_CILK_FOR::t_code_c:
return ((Context *) this)->call_type_CILK_FOR (t);
break;
case TC_OMP_DISTRIBUTE::t_code_c:
return ((Context *) this)->call_type_OMP_DISTRIBUTE (t);
break;
case TC_OACC_LOOP::t_code_c:
return ((Context *) this)->call_type_OACC_LOOP (t);
break;
case TC_OMP_TEAMS::t_code_c:
return ((Context *) this)->call_type_OMP_TEAMS (t);
break;
case TC_OMP_TARGET_DATA::t_code_c:
return ((Context *) this)->call_type_OMP_TARGET_DATA (t);
break;
case TC_OMP_TARGET::t_code_c:
return ((Context *) this)->call_type_OMP_TARGET (t);
break;
case TC_OMP_SECTIONS::t_code_c:
return ((Context *) this)->call_type_OMP_SECTIONS (t);
break;
case TC_OMP_SINGLE::t_code_c:
return ((Context *) this)->call_type_OMP_SINGLE (t);
break;
case TC_OMP_SECTION::t_code_c:
return ((Context *) this)->call_type_OMP_SECTION (t);
break;
case TC_OMP_MASTER::t_code_c:
return ((Context *) this)->call_type_OMP_MASTER (t);
break;
case TC_OMP_TASKGROUP::t_code_c:
return ((Context *) this)->call_type_OMP_TASKGROUP (t);
break;
case TC_OMP_ORDERED::t_code_c:
return ((Context *) this)->call_type_OMP_ORDERED (t);
break;
case TC_OMP_CRITICAL::t_code_c:
return ((Context *) this)->call_type_OMP_CRITICAL (t);
break;
case TC_OACC_CACHE::t_code_c:
return ((Context *) this)->call_type_OACC_CACHE (t);
break;
case TC_OACC_DECLARE::t_code_c:
return ((Context *) this)->call_type_OACC_DECLARE (t);
break;
case TC_OACC_ENTER_DATA::t_code_c:
return ((Context *) this)->call_type_OACC_ENTER_DATA (t);
break;
case TC_OACC_EXIT_DATA::t_code_c:
return ((Context *) this)->call_type_OACC_EXIT_DATA (t);
break;
case TC_OACC_UPDATE::t_code_c:
return ((Context *) this)->call_type_OACC_UPDATE (t);
break;
case TC_OMP_TARGET_UPDATE::t_code_c:
return ((Context *) this)->call_type_OMP_TARGET_UPDATE (t);
break;
case TC_OMP_ATOMIC::t_code_c:
return ((Context *) this)->call_type_OMP_ATOMIC (t);
break;
case TC_OMP_ATOMIC_READ::t_code_c:
return ((Context *) this)->call_type_OMP_ATOMIC_READ (t);
break;
case TC_OMP_ATOMIC_CAPTURE_OLD::t_code_c:
return ((Context *) this)->call_type_OMP_ATOMIC_CAPTURE_OLD (t);
break;
case TC_OMP_ATOMIC_CAPTURE_NEW::t_code_c:
return ((Context *) this)->call_type_OMP_ATOMIC_CAPTURE_NEW (t);
break;
case TC_OMP_CLAUSE::t_code_c:
return ((Context *) this)->call_type_OMP_CLAUSE (t);
break;
case TC_TRANSACTION_EXPR::t_code_c:
return ((Context *) this)->call_type_TRANSACTION_EXPR (t);
break;
case TC_REDUC_MAX_EXPR::t_code_c:
return ((Context *) this)->call_type_REDUC_MAX_EXPR (t);
break;
case TC_REDUC_MIN_EXPR::t_code_c:
return ((Context *) this)->call_type_REDUC_MIN_EXPR (t);
break;
case TC_REDUC_PLUS_EXPR::t_code_c:
return ((Context *) this)->call_type_REDUC_PLUS_EXPR (t);
break;
case TC_DOT_PROD_EXPR::t_code_c:
return ((Context *) this)->call_type_DOT_PROD_EXPR (t);
break;
case TC_WIDEN_SUM_EXPR::t_code_c:
return ((Context *) this)->call_type_WIDEN_SUM_EXPR (t);
break;
case TC_SAD_EXPR::t_code_c:
return ((Context *) this)->call_type_SAD_EXPR (t);
break;
case TC_WIDEN_MULT_EXPR::t_code_c:
return ((Context *) this)->call_type_WIDEN_MULT_EXPR (t);
break;
case TC_WIDEN_MULT_PLUS_EXPR::t_code_c:
return ((Context *) this)->call_type_WIDEN_MULT_PLUS_EXPR (t);
break;
case TC_WIDEN_MULT_MINUS_EXPR::t_code_c:
return ((Context *) this)->call_type_WIDEN_MULT_MINUS_EXPR (t);
break;
case TC_WIDEN_LSHIFT_EXPR::t_code_c:
return ((Context *) this)->call_type_WIDEN_LSHIFT_EXPR (t);
break;
case TC_FMA_EXPR::t_code_c:
return ((Context *) this)->call_type_FMA_EXPR (t);
break;
case TC_VEC_WIDEN_MULT_HI_EXPR::t_code_c:
return ((Context *) this)->call_type_VEC_WIDEN_MULT_HI_EXPR (t);
break;
case TC_VEC_WIDEN_MULT_LO_EXPR::t_code_c:
return ((Context *) this)->call_type_VEC_WIDEN_MULT_LO_EXPR (t);
break;
case TC_VEC_WIDEN_MULT_EVEN_EXPR::t_code_c:
return ((Context *) this)->call_type_VEC_WIDEN_MULT_EVEN_EXPR (t);
break;
case TC_VEC_WIDEN_MULT_ODD_EXPR::t_code_c:
return ((Context *) this)->call_type_VEC_WIDEN_MULT_ODD_EXPR (t);
break;
case TC_VEC_UNPACK_HI_EXPR::t_code_c:
return ((Context *) this)->call_type_VEC_UNPACK_HI_EXPR (t);
break;
case TC_VEC_UNPACK_LO_EXPR::t_code_c:
return ((Context *) this)->call_type_VEC_UNPACK_LO_EXPR (t);
break;
case TC_VEC_UNPACK_FLOAT_HI_EXPR::t_code_c:
return ((Context *) this)->call_type_VEC_UNPACK_FLOAT_HI_EXPR (t);
break;
case TC_VEC_UNPACK_FLOAT_LO_EXPR::t_code_c:
return ((Context *) this)->call_type_VEC_UNPACK_FLOAT_LO_EXPR (t);
break;
case TC_VEC_PACK_TRUNC_EXPR::t_code_c:
return ((Context *) this)->call_type_VEC_PACK_TRUNC_EXPR (t);
break;
case TC_VEC_PACK_SAT_EXPR::t_code_c:
return ((Context *) this)->call_type_VEC_PACK_SAT_EXPR (t);
break;
case TC_VEC_PACK_FIX_TRUNC_EXPR::t_code_c:
return ((Context *) this)->call_type_VEC_PACK_FIX_TRUNC_EXPR (t);
break;
case TC_VEC_WIDEN_LSHIFT_HI_EXPR::t_code_c:
return ((Context *) this)->call_type_VEC_WIDEN_LSHIFT_HI_EXPR (t);
break;
case TC_VEC_WIDEN_LSHIFT_LO_EXPR::t_code_c:
return ((Context *) this)->call_type_VEC_WIDEN_LSHIFT_LO_EXPR (t);
break;
case TC_PREDICT_EXPR::t_code_c:
return ((Context *) this)->call_type_PREDICT_EXPR (t);
break;
case TC_OPTIMIZATION_NODE::t_code_c:
return ((Context *) this)->call_type_OPTIMIZATION_NODE (t);
break;
case TC_TARGET_OPTION_NODE::t_code_c:
return ((Context *) this)->call_type_TARGET_OPTION_NODE (t);
break;
case TC_ANNOTATE_EXPR::t_code_c:
return ((Context *) this)->call_type_ANNOTATE_EXPR (t);
break;
case TC_CILK_SPAWN_STMT::t_code_c:
return ((Context *) this)->call_type_CILK_SPAWN_STMT (t);
break;
case TC_CILK_SYNC_STMT::t_code_c:
return ((Context *) this)->call_type_CILK_SYNC_STMT (t);
break;
default:
enum tree_code tc = t->typed.base.code;
cerr << "TODO: UKNOWN switchcall " << get_tree_code_name (tc) << endl;
break;
}
}
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 = get_tree_code_name (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, va_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 ? (*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:
fprintf (di->stream, "int: ");
print_decs (t, di->stream);
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:
case BIT_FIELD_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_safe_length (CONSTRUCTOR_ELTS (t)));
FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), cnt, index, value)
{
dump_child ("idx", index);
dump_child ("val", value);
}
}
