void
streamer_pack_tree_bitfields (struct output_block *ob,
struct bitpack_d *bp, tree expr)
{
enum tree_code code;
code = TREE_CODE (expr);
/* Note that all these functions are highly sensitive to changes in
the types and sizes of each of the fields being packed. */
pack_ts_base_value_fields (bp, expr);
if (CODE_CONTAINS_STRUCT (code, TS_INT_CST))
pack_ts_int_cst_value_fields (bp, expr);
if (CODE_CONTAINS_STRUCT (code, TS_REAL_CST))
pack_ts_real_cst_value_fields (bp, expr);
if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST))
pack_ts_fixed_cst_value_fields (bp, expr);
if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
stream_output_location (ob, bp, DECL_SOURCE_LOCATION (expr));
if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
pack_ts_decl_common_value_fields (bp, expr);
if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
pack_ts_decl_wrtl_value_fields (bp, expr);
if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
pack_ts_decl_with_vis_value_fields (bp, expr);
if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
pack_ts_function_decl_value_fields (bp, expr);
if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
pack_ts_type_common_value_fields (bp, expr);
if (CODE_CONTAINS_STRUCT (code, TS_EXP))
stream_output_location (ob, bp, EXPR_LOCATION (expr));
if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
pack_ts_block_value_fields (ob, bp, expr);
if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
pack_ts_translation_unit_decl_value_fields (ob, bp, expr);
if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION))
pack_ts_target_option (bp, expr);
if (CODE_CONTAINS_STRUCT (code, TS_OPTIMIZATION))
pack_ts_optimization (bp, expr);
if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
bp_pack_var_len_unsigned (bp, vec_safe_length (BINFO_BASE_ACCESSES (expr)));
if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
bp_pack_var_len_unsigned (bp, CONSTRUCTOR_NELTS (expr));
}
static void
write_ts_constructor_tree_pointers (struct output_block *ob, tree expr,
bool ref_p)
{
unsigned i;
tree index, value;
streamer_write_uhwi (ob, CONSTRUCTOR_NELTS (expr));
FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr), i, index, value)
{
stream_write_tree (ob, index, ref_p);
stream_write_tree (ob, value, ref_p);
}
static void
lto_input_ts_constructor_tree_pointers (struct lto_input_block *ib,
struct data_in *data_in, tree expr)
{
unsigned i;
for (i = 0; i < CONSTRUCTOR_NELTS (expr); i++)
{
constructor_elt e;
e.index = stream_read_tree (ib, data_in);
e.value = stream_read_tree (ib, data_in);
(*CONSTRUCTOR_ELTS (expr))[i] = e;
}
}
void xml_expr(tree expr, int indent, FILE *out)
{
size_t el;
switch (TREE_CODE(expr))
{
case REAL_CST:
case STRING_CST:
case INTEGER_CST:
fprintf(out, "%s<constant>\n", spc(indent));
/* For strings, we output the full type here. The backend should be fixed to resolve this though. */
if (TREE_CODE(expr) == STRING_CST)
xml_type_aggregate(TREE_TYPE(expr), indent + INDENT, out);
else
xml_type(TREE_TYPE(expr), NULL, indent + INDENT, out);
fprintf(out, "%s", spc(indent + INDENT));
xml_short_constant(expr, out);
fprintf(out, "\n%s</constant>\n", spc(indent));
break;
case COMPONENT_REF:
fprintf(out, "%s<member-ref>\n", spc(indent));
fprintf(out, "%s<structure>\n", spc(INDENT + indent));
xml_expr(TREE_OPERAND(expr, 0), indent + INDENT + INDENT, out);
fprintf(out, "%s</structure>\n", spc(indent + INDENT));
fprintf(out, "%s<member>\n", spc(indent + INDENT));
xml_decl_binding(TREE_OPERAND(expr, 1), indent + INDENT + INDENT, "bound", out);
fprintf(out, "%s</member>\n", spc(indent + INDENT));
fprintf(out, "%s</member-ref>\n", spc(indent));
break;
case BIT_FIELD_REF:
fprintf(out, "%s<bitfield-ref>\n", spc(indent));
fprintf(out, "%s<structure>\n", spc(INDENT + indent));
xml_expr(TREE_OPERAND(expr, 0), indent + INDENT + INDENT, out);
fprintf(out, "%s</structure>\n", spc(indent + INDENT));
assert(TREE_OPERAND(expr, 1) != NULL);
assert(TREE_OPERAND(expr, 2) != NULL);
assert(INTEGER_CST == TREE_CODE(TREE_OPERAND(expr, 1)));
assert(INTEGER_CST == TREE_CODE(TREE_OPERAND(expr, 2)));
fprintf(out, "%s<bits start='%lld' size='%lld' />", spc(indent + INDENT),
double_int_to_ll(TREE_INT_CST(TREE_OPERAND(expr, 1))),
double_int_to_ll(TREE_INT_CST(TREE_OPERAND(expr, 2))));
fprintf(out, "%s<as-type>\n", spc(INDENT + indent));
assert(TREE_TYPE(expr) != NULL);
xml_type(TREE_TYPE(expr), NULL, indent + INDENT + INDENT, out);
fprintf(out, "%s</as-type>\n", spc(indent + INDENT));
fprintf(out, "%s</bitfield-ref>\n", spc(indent));
break;
case INDIRECT_REF:
fprintf(out, "%s<indirection>\n", spc(indent));
xml_expr(TREE_OPERAND(expr, 0), indent + INDENT, out);
fprintf(out, "%s</indirection>\n", spc(indent));
break;
case RESULT_DECL:
xml_decl_binding(expr, indent, "result", out);
break;
case VAR_DECL:
xml_decl_binding(expr, indent, "bound", out);
break;
case PARM_DECL:
xml_decl_binding(expr, indent, "bound-parameter", out);
break;
case ADDR_EXPR:
fprintf(out, "%s<addr-of>\n", spc(indent));
xml_expr(TREE_OPERAND(expr, 0), indent + INDENT, out);
fprintf(out, "%s</addr-of>\n", spc(indent));
break;
case FUNCTION_DECL:
fprintf(out, "%s<function>\n", spc(indent));
xml_decl_binding(expr, indent + INDENT, "bound", out);
fprintf(out, "%s</function>\n", spc(indent));
break;
#define SIMPLE_TAG(when, tt) \
case when: \
fprintf(out, "%s<" tt " />\n", spc(indent)); \
break
#define SIMPLE_TAGS \
SIMPLE_TAG(PLUS_EXPR, "plus");\
SIMPLE_TAG(MINUS_EXPR, "minus");\
SIMPLE_TAG(MULT_EXPR, "multiply");\
SIMPLE_TAG(POINTER_PLUS_EXPR, "pointer-offset");\
\
SIMPLE_TAG(TRUNC_DIV_EXPR, "division-truncate");\
SIMPLE_TAG(CEIL_DIV_EXPR, "division-ceil");\
SIMPLE_TAG(FLOOR_DIV_EXPR, "division-floor");\
SIMPLE_TAG(ROUND_DIV_EXPR, "division-round");\
SIMPLE_TAG(EXACT_DIV_EXPR, "division-exact");\
SIMPLE_TAG(RDIV_EXPR, "division-real");\
\
SIMPLE_TAG(TRUNC_MOD_EXPR, "modulo-truncate");\
SIMPLE_TAG(CEIL_MOD_EXPR, "modulo-ceil");\
SIMPLE_TAG(FLOOR_MOD_EXPR, "modulo-floor");\
SIMPLE_TAG(ROUND_MOD_EXPR, "modulo-round");\
\
SIMPLE_TAG(FLOAT_EXPR, "float");\
SIMPLE_TAG(FIX_TRUNC_EXPR, "fixed-point-truncate");\
SIMPLE_TAG(NEGATE_EXPR, "negate");\
SIMPLE_TAG(ABS_EXPR, "absolute");\
\
SIMPLE_TAG(LSHIFT_EXPR, "shift-left");\
SIMPLE_TAG(RSHIFT_EXPR, "shift-right");\
SIMPLE_TAG(LROTATE_EXPR, "rotate-left");\
SIMPLE_TAG(RROTATE_EXPR, "rotate-right");\
\
SIMPLE_TAG(BIT_IOR_EXPR, "bitwise-or");\
SIMPLE_TAG(BIT_XOR_EXPR, "bitwise-xor");\
SIMPLE_TAG(BIT_AND_EXPR, "bitwise-and");\
SIMPLE_TAG(BIT_NOT_EXPR, "bitwise-not");\
\
SIMPLE_TAG(MIN_EXPR, "min");\
SIMPLE_TAG(MAX_EXPR, "max");\
SIMPLE_TAG(UNORDERED_EXPR, "unordered");\
SIMPLE_TAG(ORDERED_EXPR, "ordered");\
\
SIMPLE_TAG(TRUTH_ANDIF_EXPR, "logical-short-and");\
SIMPLE_TAG(TRUTH_ORIF_EXPR, "logical-short-or");\
SIMPLE_TAG(TRUTH_AND_EXPR, "logical-and");\
SIMPLE_TAG(TRUTH_OR_EXPR, "logical-or");\
SIMPLE_TAG(TRUTH_XOR_EXPR, "logical-xor");\
SIMPLE_TAG(TRUTH_NOT_EXPR, "logical-not");\
\
SIMPLE_TAG(LT_EXPR, "less-than");\
SIMPLE_TAG(LE_EXPR, "less-than-or-equal");\
SIMPLE_TAG(GT_EXPR, "greater-than");\
SIMPLE_TAG(GE_EXPR, "greater-than-or-equal");\
SIMPLE_TAG(EQ_EXPR, "equal");\
SIMPLE_TAG(NE_EXPR, "not-equal");\
SIMPLE_TAG(NOP_EXPR, "nop-convert");\
SIMPLE_TAG(CONVERT_EXPR, "convert");
SIMPLE_TAGS
#undef SIMPLE_TAG
case ARRAY_REF:
fprintf(out, "%s<item-ref>\n", spc(indent));
fprintf(out, "%s<array>\n", spc(INDENT + indent));
xml_expr(TREE_OPERAND(expr, 0), indent + INDENT + INDENT, out);
fprintf(out, "%s</array>\n", spc(INDENT + indent));
fprintf(out, "%s<index>\n", spc(indent + INDENT));
xml_expr(TREE_OPERAND(expr, 1), indent + INDENT + INDENT, out);
fprintf(out, "%s</index>\n", spc(indent + INDENT));
fprintf(out, "%s</item-ref>\n", spc(indent));
break;
case CONSTRUCTOR:
fprintf(out, "%s<constructor>\n", spc(indent));
for (el = 0; el < CONSTRUCTOR_NELTS(expr); el++)
{
xml_expr(CONSTRUCTOR_ELT(expr, el)->value, indent + INDENT, out);
}
fprintf(out, "%s</constructor>\n", spc(indent));
break;
case REFERENCE_TYPE:
fprintf(stderr, "lighthouse warning: ignoring unhandled expression tree type %s\n",
tree_code_name[TREE_CODE(expr)]);
break;
default:
fprintf(stderr, "xml_expr: unhandled expression tree type %s\n",
tree_code_name[TREE_CODE(expr)]);
assert(0);
abort();
}
}
void
streamer_write_tree_bitfields (struct output_block *ob, tree expr)
{
bitpack_d bp = bitpack_create (ob->main_stream);
enum tree_code code;
code = TREE_CODE (expr);
/* Note that all these functions are highly sensitive to changes in
the types and sizes of each of the fields being packed. */
pack_ts_base_value_fields (&bp, expr);
if (CODE_CONTAINS_STRUCT (code, TS_INT_CST))
pack_ts_int_cst_value_fields (&bp, expr);
if (CODE_CONTAINS_STRUCT (code, TS_REAL_CST))
pack_ts_real_cst_value_fields (&bp, expr);
if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST))
pack_ts_fixed_cst_value_fields (&bp, expr);
if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
stream_output_location (ob, &bp, DECL_SOURCE_LOCATION (expr));
if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
pack_ts_decl_common_value_fields (&bp, expr);
if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
pack_ts_decl_wrtl_value_fields (&bp, expr);
if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
pack_ts_decl_with_vis_value_fields (&bp, expr);
if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
pack_ts_function_decl_value_fields (&bp, expr);
if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
pack_ts_type_common_value_fields (&bp, expr);
if (CODE_CONTAINS_STRUCT (code, TS_EXP))
{
stream_output_location (ob, &bp, EXPR_LOCATION (expr));
if (code == MEM_REF
|| code == TARGET_MEM_REF)
{
bp_pack_value (&bp, MR_DEPENDENCE_CLIQUE (expr), sizeof (short) * 8);
if (MR_DEPENDENCE_CLIQUE (expr) != 0)
bp_pack_value (&bp, MR_DEPENDENCE_BASE (expr), sizeof (short) * 8);
}
}
if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
pack_ts_block_value_fields (ob, &bp, expr);
if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
pack_ts_translation_unit_decl_value_fields (ob, &bp, expr);
if (CODE_CONTAINS_STRUCT (code, TS_OPTIMIZATION))
cl_optimization_stream_out (&bp, TREE_OPTIMIZATION (expr));
if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
bp_pack_var_len_unsigned (&bp, vec_safe_length (BINFO_BASE_ACCESSES (expr)));
if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
bp_pack_var_len_unsigned (&bp, CONSTRUCTOR_NELTS (expr));
if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION)
/* Don't stream these when passing things to a different target. */
&& !lto_stream_offload_p)
cl_target_option_stream_out (ob, &bp, TREE_TARGET_OPTION (expr));
if (code == OMP_CLAUSE)
pack_ts_omp_clause_value_fields (ob, &bp, expr);
streamer_write_bitpack (&bp);
}
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", CONSTRUCTOR_NELTS (t));
FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), cnt, index, value)
{
dump_child ("idx", index);
dump_child ("val", value);
}
}
int
cp_gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
{
int saved_stmts_are_full_exprs_p = 0;
enum tree_code code = TREE_CODE (*expr_p);
enum gimplify_status ret;
if (STATEMENT_CODE_P (code))
{
saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
current_stmt_tree ()->stmts_are_full_exprs_p
= STMT_IS_FULL_EXPR_P (*expr_p);
}
switch (code)
{
case PTRMEM_CST:
*expr_p = cplus_expand_constant (*expr_p);
ret = GS_OK;
break;
case AGGR_INIT_EXPR:
simplify_aggr_init_expr (expr_p);
ret = GS_OK;
break;
case VEC_INIT_EXPR:
{
location_t loc = input_location;
tree init = VEC_INIT_EXPR_INIT (*expr_p);
int from_array = (init && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE);
gcc_assert (EXPR_HAS_LOCATION (*expr_p));
input_location = EXPR_LOCATION (*expr_p);
*expr_p = build_vec_init (VEC_INIT_EXPR_SLOT (*expr_p), NULL_TREE,
init, VEC_INIT_EXPR_VALUE_INIT (*expr_p),
from_array,
tf_warning_or_error);
cp_genericize_tree (expr_p);
ret = GS_OK;
input_location = loc;
}
break;
case THROW_EXPR:
/* FIXME communicate throw type to back end, probably by moving
THROW_EXPR into ../tree.def. */
*expr_p = TREE_OPERAND (*expr_p, 0);
ret = GS_OK;
break;
case MUST_NOT_THROW_EXPR:
ret = gimplify_must_not_throw_expr (expr_p, pre_p);
break;
/* We used to do this for MODIFY_EXPR as well, but that's unsafe; the
LHS of an assignment might also be involved in the RHS, as in bug
25979. */
case INIT_EXPR:
if (fn_contains_cilk_spawn_p (cfun)
&& cilk_detect_spawn_and_unwrap (expr_p)
&& !seen_error ())
return (enum gimplify_status) gimplify_cilk_spawn (expr_p);
cp_gimplify_init_expr (expr_p);
if (TREE_CODE (*expr_p) != INIT_EXPR)
return GS_OK;
/* Otherwise fall through. */
case MODIFY_EXPR:
{
if (fn_contains_cilk_spawn_p (cfun)
&& cilk_detect_spawn_and_unwrap (expr_p)
&& !seen_error ())
return (enum gimplify_status) gimplify_cilk_spawn (expr_p);
/* If the back end isn't clever enough to know that the lhs and rhs
types are the same, add an explicit conversion. */
tree op0 = TREE_OPERAND (*expr_p, 0);
tree op1 = TREE_OPERAND (*expr_p, 1);
if (!error_operand_p (op0)
&& !error_operand_p (op1)
&& (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (op0))
|| TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (op1)))
&& !useless_type_conversion_p (TREE_TYPE (op1), TREE_TYPE (op0)))
TREE_OPERAND (*expr_p, 1) = build1 (VIEW_CONVERT_EXPR,
TREE_TYPE (op0), op1);
else if ((is_gimple_lvalue (op1) || INDIRECT_REF_P (op1)
|| (TREE_CODE (op1) == CONSTRUCTOR
&& CONSTRUCTOR_NELTS (op1) == 0
&& !TREE_CLOBBER_P (op1))
|| (TREE_CODE (op1) == CALL_EXPR
&& !CALL_EXPR_RETURN_SLOT_OPT (op1)))
&& is_really_empty_class (TREE_TYPE (op0)))
{
/* Remove any copies of empty classes. We check that the RHS
has a simple form so that TARGET_EXPRs and non-empty
CONSTRUCTORs get reduced properly, and we leave the return
slot optimization alone because it isn't a copy (FIXME so it
shouldn't be represented as one).
Also drop volatile variables on the RHS to avoid infinite
recursion from gimplify_expr trying to load the value. */
if (!TREE_SIDE_EFFECTS (op1)
|| (DECL_P (op1) && TREE_THIS_VOLATILE (op1)))
*expr_p = op0;
else if (TREE_CODE (op1) == MEM_REF
&& TREE_THIS_VOLATILE (op1))
{
/* Similarly for volatile MEM_REFs on the RHS. */
if (!TREE_SIDE_EFFECTS (TREE_OPERAND (op1, 0)))
*expr_p = op0;
else
*expr_p = build2 (COMPOUND_EXPR, TREE_TYPE (*expr_p),
TREE_OPERAND (op1, 0), op0);
}
else
*expr_p = build2 (COMPOUND_EXPR, TREE_TYPE (*expr_p),
op0, op1);
}
}
ret = GS_OK;
break;
case EMPTY_CLASS_EXPR:
/* We create an empty CONSTRUCTOR with RECORD_TYPE. */
*expr_p = build_constructor (TREE_TYPE (*expr_p), NULL);
ret = GS_OK;
break;
case BASELINK:
*expr_p = BASELINK_FUNCTIONS (*expr_p);
ret = GS_OK;
break;
case TRY_BLOCK:
genericize_try_block (expr_p);
ret = GS_OK;
break;
case HANDLER:
genericize_catch_block (expr_p);
ret = GS_OK;
break;
case EH_SPEC_BLOCK:
genericize_eh_spec_block (expr_p);
ret = GS_OK;
break;
case USING_STMT:
gcc_unreachable ();
case FOR_STMT:
case WHILE_STMT:
case DO_STMT:
case SWITCH_STMT:
case CONTINUE_STMT:
case BREAK_STMT:
gcc_unreachable ();
case OMP_FOR:
case OMP_SIMD:
case OMP_DISTRIBUTE:
ret = cp_gimplify_omp_for (expr_p, pre_p);
break;
case EXPR_STMT:
gimplify_expr_stmt (expr_p);
ret = GS_OK;
break;
case UNARY_PLUS_EXPR:
{
tree arg = TREE_OPERAND (*expr_p, 0);
tree type = TREE_TYPE (*expr_p);
*expr_p = (TREE_TYPE (arg) != type) ? fold_convert (type, arg)
: arg;
ret = GS_OK;
}
break;
case CILK_SPAWN_STMT:
gcc_assert
(fn_contains_cilk_spawn_p (cfun)
&& cilk_detect_spawn_and_unwrap (expr_p));
/* If errors are seen, then just process it as a CALL_EXPR. */
if (!seen_error ())
return (enum gimplify_status) gimplify_cilk_spawn (expr_p);
case CALL_EXPR:
if (fn_contains_cilk_spawn_p (cfun)
&& cilk_detect_spawn_and_unwrap (expr_p)
&& !seen_error ())
return (enum gimplify_status) gimplify_cilk_spawn (expr_p);
default:
ret = (enum gimplify_status) c_gimplify_expr (expr_p, pre_p, post_p);
break;
}
/* Restore saved state. */
if (STATEMENT_CODE_P (code))
current_stmt_tree ()->stmts_are_full_exprs_p
= saved_stmts_are_full_exprs_p;
return ret;
}
