static void
pp_c_pointer (c_pretty_printer *pp, tree t)
{
if (!TYPE_P (t) && TREE_CODE (t) != TYPE_DECL)
t = TREE_TYPE (t);
switch (TREE_CODE (t))
{
case POINTER_TYPE:
/* It is easier to handle C++ reference types here. */
case REFERENCE_TYPE:
if (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE)
pp_c_pointer (pp, TREE_TYPE (t));
if (TREE_CODE (t) == POINTER_TYPE)
pp_c_star (pp);
else
pp_c_ampersand (pp);
pp_c_type_qualifier_list (pp, t);
break;
/* APPLE LOCAL begin blocks */
case BLOCK_POINTER_TYPE:
pp_c_caret (pp);
pp_c_type_qualifier_list (pp, t);
break;
/* APPLE LOCAL end blocks */
/* ??? This node is now in GENERIC and so shouldn't be here. But
we'll fix that later. */
case DECL_EXPR:
pp_declaration (pp, DECL_EXPR_DECL (t));
pp_needs_newline (pp) = true;
break;
default:
pp_unsupported_tree (pp, t);
}
}
static void
pp_cxx_exception_declaration (cxx_pretty_printer *pp, tree t)
{
t = DECL_EXPR_DECL (t);
pp_cxx_type_specifier_seq (pp, t);
if (TYPE_P (t))
pp_cxx_abstract_declarator (pp, t);
else
pp_cxx_declarator (pp, t);
}
static enum gimplify_status
gimplify_compound_literal_expr (tree *expr_p, tree *pre_p)
{
tree decl_s = COMPOUND_LITERAL_EXPR_DECL_STMT (*expr_p);
tree decl = DECL_EXPR_DECL (decl_s);
/* This decl isn't mentioned in the enclosing block, so add it to the
list of temps. FIXME it seems a bit of a kludge to say that
anonymous artificial vars aren't pushed, but everything else is. */
if (DECL_NAME (decl) == NULL_TREE && !DECL_SEEN_IN_BIND_EXPR_P (decl))
gimple_add_tmp_var (decl);
gimplify_and_add (decl_s, pre_p);
*expr_p = decl;
return GS_OK;
}
tree
expand_array_notation_exprs (tree t)
{
enum tree_code code;
bool is_expr;
location_t loc = UNKNOWN_LOCATION;
if (!t)
return t;
loc = EXPR_LOCATION (t);
code = TREE_CODE (t);
is_expr = IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code));
switch (code)
{
case ERROR_MARK:
case IDENTIFIER_NODE:
case VOID_CST:
case INTEGER_CST:
case REAL_CST:
case FIXED_CST:
case STRING_CST:
case BLOCK:
case PLACEHOLDER_EXPR:
case FIELD_DECL:
case VOID_TYPE:
case REAL_TYPE:
case SSA_NAME:
case LABEL_DECL:
case RESULT_DECL:
case VAR_DECL:
case PARM_DECL:
case NON_LVALUE_EXPR:
case NOP_EXPR:
case ADDR_EXPR:
case ARRAY_REF:
case BIT_FIELD_REF:
case VECTOR_CST:
case COMPLEX_CST:
return t;
case INIT_EXPR:
case MODIFY_EXPR:
if (contains_array_notation_expr (t))
t = expand_an_in_modify_expr (loc, TREE_OPERAND (t, 0), NOP_EXPR,
TREE_OPERAND (t, 1),
tf_warning_or_error);
return t;
case MODOP_EXPR:
if (contains_array_notation_expr (t) && !processing_template_decl)
t = expand_an_in_modify_expr
(loc, TREE_OPERAND (t, 0), TREE_CODE (TREE_OPERAND (t, 1)),
TREE_OPERAND (t, 2), tf_warning_or_error);
return t;
case CONSTRUCTOR:
return t;
case BIND_EXPR:
{
BIND_EXPR_BODY (t) =
expand_array_notation_exprs (BIND_EXPR_BODY (t));
return t;
}
case DECL_EXPR:
if (contains_array_notation_expr (t))
{
tree x = DECL_EXPR_DECL (t);
if (DECL_INITIAL (x))
{
location_t loc = DECL_SOURCE_LOCATION (x);
tree lhs = x;
tree rhs = DECL_INITIAL (x);
DECL_INITIAL (x) = NULL;
tree new_modify_expr = build_modify_expr (loc, lhs,
TREE_TYPE (lhs),
NOP_EXPR,
loc, rhs,
TREE_TYPE(rhs));
t = expand_array_notation_exprs (new_modify_expr);
}
}
return t;
case STATEMENT_LIST:
{
tree_stmt_iterator i;
for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
*tsi_stmt_ptr (i) =
expand_array_notation_exprs (*tsi_stmt_ptr (i));
return t;
}
case OMP_PARALLEL:
case OMP_TASK:
case OMP_FOR:
case OMP_SINGLE:
case OMP_SECTION:
case OMP_SECTIONS:
case OMP_MASTER:
case OMP_TASKGROUP:
case OMP_ORDERED:
case OMP_CRITICAL:
case OMP_ATOMIC:
case OMP_CLAUSE:
case TARGET_EXPR:
case INTEGER_TYPE:
case ENUMERAL_TYPE:
case BOOLEAN_TYPE:
case POINTER_TYPE:
case ARRAY_TYPE:
case RECORD_TYPE:
case METHOD_TYPE:
return t;
case RETURN_EXPR:
if (contains_array_notation_expr (t))
t = expand_return_expr (t);
return t;
case PREDECREMENT_EXPR:
case PREINCREMENT_EXPR:
case POSTDECREMENT_EXPR:
case POSTINCREMENT_EXPR:
case AGGR_INIT_EXPR:
case CALL_EXPR:
t = expand_unary_array_notation_exprs (t);
return t;
case CONVERT_EXPR:
case CLEANUP_POINT_EXPR:
case EXPR_STMT:
TREE_OPERAND (t, 0) = expand_array_notation_exprs (TREE_OPERAND (t, 0));
/* It is not necessary to wrap error_mark_node in EXPR_STMT. */
if (TREE_OPERAND (t, 0) == error_mark_node)
return TREE_OPERAND (t, 0);
return t;
case TRUTH_ANDIF_EXPR:
case TRUTH_ORIF_EXPR:
case TRUTH_AND_EXPR:
case TRUTH_OR_EXPR:
case TRUTH_XOR_EXPR:
case TRUTH_NOT_EXPR:
case COND_EXPR:
t = cp_expand_cond_array_notations (t);
if (TREE_CODE (t) == COND_EXPR)
{
COND_EXPR_THEN (t) =
expand_array_notation_exprs (COND_EXPR_THEN (t));
COND_EXPR_ELSE (t) =
expand_array_notation_exprs (COND_EXPR_ELSE (t));
}
return t;
case FOR_STMT:
if (contains_array_notation_expr (FOR_COND (t)))
{
error_at (EXPR_LOCATION (FOR_COND (t)),
"array notation cannot be used in a condition for "
"a for-loop");
return error_mark_node;
}
/* FIXME: Add a check for CILK_FOR_STMT here when we add Cilk tasking
keywords. */
if (TREE_CODE (t) == FOR_STMT)
{
FOR_BODY (t) = expand_array_notation_exprs (FOR_BODY (t));
FOR_EXPR (t) = expand_array_notation_exprs (FOR_EXPR (t));
}
else
t = expand_array_notation_exprs (t);
return t;
case IF_STMT:
t = cp_expand_cond_array_notations (t);
/* If the above function added some extra instructions above the original
if statement, then we can't assume it is still IF_STMT so we have to
check again. */
if (TREE_CODE (t) == IF_STMT)
{
if (THEN_CLAUSE (t))
THEN_CLAUSE (t) = expand_array_notation_exprs (THEN_CLAUSE (t));
if (ELSE_CLAUSE (t))
ELSE_CLAUSE (t) = expand_array_notation_exprs (ELSE_CLAUSE (t));
}
else
t = expand_array_notation_exprs (t);
return t;
case SWITCH_STMT:
if (contains_array_notation_expr (SWITCH_STMT_COND (t)))
{
error_at (EXPR_LOCATION (SWITCH_STMT_COND (t)),
"array notation cannot be used as a condition for "
"switch statement");
return error_mark_node;
}
if (SWITCH_STMT_BODY (t))
SWITCH_STMT_BODY (t) =
expand_array_notation_exprs (SWITCH_STMT_BODY (t));
return t;
case WHILE_STMT:
if (contains_array_notation_expr (WHILE_COND (t)))
{
if (EXPR_LOCATION (WHILE_COND (t)) != UNKNOWN_LOCATION)
loc = EXPR_LOCATION (WHILE_COND (t));
error_at (loc, "array notation cannot be used as a condition for "
"while statement");
return error_mark_node;
}
if (WHILE_BODY (t))
WHILE_BODY (t) = expand_array_notation_exprs (WHILE_BODY (t));
return t;
case DO_STMT:
if (contains_array_notation_expr (DO_COND (t)))
{
error_at (EXPR_LOCATION (DO_COND (t)),
"array notation cannot be used as a condition for a "
"do-while statement");
return error_mark_node;
}
if (DO_BODY (t))
DO_BODY (t) = expand_array_notation_exprs (DO_BODY (t));
return t;
default:
if (is_expr)
{
int i, len;
/* Walk over all the sub-trees of this operand. */
len = TREE_CODE_LENGTH (code);
/* Go through the subtrees. We need to do this in forward order so
that the scope of a FOR_EXPR is handled properly. */
for (i = 0; i < len; ++i)
TREE_OPERAND (t, i) =
expand_array_notation_exprs (TREE_OPERAND (t, i));
}
return t;
}
return t;
}
static tree
expand_array_notations (tree *tp, int *walk_subtrees, void *)
{
if (!contains_array_notation_expr (*tp))
{
*walk_subtrees = 0;
return NULL_TREE;
}
*walk_subtrees = 1;
switch (TREE_CODE (*tp))
{
case TRUTH_ORIF_EXPR:
case TRUTH_ANDIF_EXPR:
case TRUTH_OR_EXPR:
case TRUTH_AND_EXPR:
case TRUTH_XOR_EXPR:
case TRUTH_NOT_EXPR:
case COND_EXPR:
*tp = fix_conditional_array_notations (*tp);
break;
case MODIFY_EXPR:
{
location_t loc = EXPR_HAS_LOCATION (*tp) ? EXPR_LOCATION (*tp) :
UNKNOWN_LOCATION;
tree lhs = TREE_OPERAND (*tp, 0);
tree rhs = TREE_OPERAND (*tp, 1);
location_t rhs_loc = EXPR_HAS_LOCATION (rhs) ? EXPR_LOCATION (rhs) :
UNKNOWN_LOCATION;
*tp = build_array_notation_expr (loc, lhs, TREE_TYPE (lhs), NOP_EXPR,
rhs_loc, rhs, TREE_TYPE (rhs));
}
break;
case DECL_EXPR:
{
tree x = DECL_EXPR_DECL (*tp);
if (DECL_INITIAL (x))
{
location_t loc = DECL_SOURCE_LOCATION (x);
tree lhs = x;
tree rhs = DECL_INITIAL (x);
DECL_INITIAL (x) = NULL;
tree new_modify_expr = build_modify_expr (loc, lhs,
TREE_TYPE (lhs),
NOP_EXPR,
loc, rhs,
TREE_TYPE(rhs));
expand_array_notations (&new_modify_expr, walk_subtrees, NULL);
*tp = new_modify_expr;
}
}
break;
case CALL_EXPR:
*tp = fix_array_notation_call_expr (*tp);
break;
case RETURN_EXPR:
*tp = fix_return_expr (*tp);
break;
case COMPOUND_EXPR:
if (TREE_CODE (TREE_OPERAND (*tp, 0)) == SAVE_EXPR)
{
/* In here we are calling expand_array_notations because
we need to be able to catch the return value and check if
it is an error_mark_node. */
expand_array_notations (&TREE_OPERAND (*tp, 1), walk_subtrees, NULL);
/* SAVE_EXPR cannot have an error_mark_node inside it. This check
will make sure that if there is an error in expanding of
array notations (e.g. rank mismatch) then replace the entire
SAVE_EXPR with an error_mark_node. */
if (TREE_OPERAND (*tp, 1) == error_mark_node)
*tp = error_mark_node;
}
break;
case ARRAY_NOTATION_REF:
/* If we are here, then we are dealing with cases like this:
A[:];
A[x:y:z];
A[x:y];
Replace those with just void zero node. */
*tp = void_node;
default:
break;
}
return NULL_TREE;
}
static tree
cp_genericize_r (tree *stmt_p, int *walk_subtrees, void *data)
{
tree stmt = *stmt_p;
struct cp_genericize_data *wtd = (struct cp_genericize_data *) data;
struct pointer_set_t *p_set = wtd->p_set;
if (is_invisiref_parm (stmt)
/* Don't dereference parms in a thunk, pass the references through. */
&& !(DECL_THUNK_P (current_function_decl)
&& TREE_CODE (stmt) == PARM_DECL))
{
*stmt_p = convert_from_reference (stmt);
*walk_subtrees = 0;
return NULL;
}
/* Map block scope extern declarations to visible declarations with the
same name and type in outer scopes if any. */
if (cp_function_chain->extern_decl_map
&& (TREE_CODE (stmt) == FUNCTION_DECL || TREE_CODE (stmt) == VAR_DECL)
&& DECL_EXTERNAL (stmt))
{
struct cxx_int_tree_map *h, in;
in.uid = DECL_UID (stmt);
h = (struct cxx_int_tree_map *)
htab_find_with_hash (cp_function_chain->extern_decl_map,
&in, in.uid);
if (h)
{
*stmt_p = h->to;
*walk_subtrees = 0;
return NULL;
}
}
/* Other than invisiref parms, don't walk the same tree twice. */
if (pointer_set_contains (p_set, stmt))
{
*walk_subtrees = 0;
return NULL_TREE;
}
if (TREE_CODE (stmt) == ADDR_EXPR
&& is_invisiref_parm (TREE_OPERAND (stmt, 0)))
{
*stmt_p = convert (TREE_TYPE (stmt), TREE_OPERAND (stmt, 0));
*walk_subtrees = 0;
}
else if (TREE_CODE (stmt) == RETURN_EXPR
&& TREE_OPERAND (stmt, 0)
&& is_invisiref_parm (TREE_OPERAND (stmt, 0)))
/* Don't dereference an invisiref RESULT_DECL inside a RETURN_EXPR. */
*walk_subtrees = 0;
else if (TREE_CODE (stmt) == OMP_CLAUSE)
switch (OMP_CLAUSE_CODE (stmt))
{
case OMP_CLAUSE_LASTPRIVATE:
/* Don't dereference an invisiref in OpenMP clauses. */
if (is_invisiref_parm (OMP_CLAUSE_DECL (stmt)))
{
*walk_subtrees = 0;
if (OMP_CLAUSE_LASTPRIVATE_STMT (stmt))
cp_walk_tree (&OMP_CLAUSE_LASTPRIVATE_STMT (stmt),
cp_genericize_r, data, NULL);
}
break;
case OMP_CLAUSE_PRIVATE:
case OMP_CLAUSE_SHARED:
case OMP_CLAUSE_FIRSTPRIVATE:
case OMP_CLAUSE_COPYIN:
case OMP_CLAUSE_COPYPRIVATE:
/* Don't dereference an invisiref in OpenMP clauses. */
if (is_invisiref_parm (OMP_CLAUSE_DECL (stmt)))
*walk_subtrees = 0;
break;
case OMP_CLAUSE_REDUCTION:
gcc_assert (!is_invisiref_parm (OMP_CLAUSE_DECL (stmt)));
break;
default:
break;
}
else if (IS_TYPE_OR_DECL_P (stmt))
*walk_subtrees = 0;
/* Due to the way voidify_wrapper_expr is written, we don't get a chance
to lower this construct before scanning it, so we need to lower these
before doing anything else. */
else if (TREE_CODE (stmt) == CLEANUP_STMT)
*stmt_p = build2 (CLEANUP_EH_ONLY (stmt) ? TRY_CATCH_EXPR
: TRY_FINALLY_EXPR,
void_type_node,
CLEANUP_BODY (stmt),
CLEANUP_EXPR (stmt));
else if (TREE_CODE (stmt) == IF_STMT)
{
genericize_if_stmt (stmt_p);
/* *stmt_p has changed, tail recurse to handle it again. */
return cp_genericize_r (stmt_p, walk_subtrees, data);
}
/* COND_EXPR might have incompatible types in branches if one or both
arms are bitfields.FILE *
my_dump_begin (int phase, int *flag_ptr) Fix it up now. */
else if (TREE_CODE (stmt) == COND_EXPR)
{
tree type_left
= (TREE_OPERAND (stmt, 1)
? is_bitfield_expr_with_lowered_type (TREE_OPERAND (stmt, 1))
: NULL_TREE);
tree type_right
= (TREE_OPERAND (stmt, 2)
? is_bitfield_expr_with_lowered_type (TREE_OPERAND (stmt, 2))
: NULL_TREE);
if (type_left
&& !useless_type_conversion_p (TREE_TYPE (stmt),
TREE_TYPE (TREE_OPERAND (stmt, 1))))
{
TREE_OPERAND (stmt, 1)
= fold_convert (type_left, TREE_OPERAND (stmt, 1));
gcc_assert (useless_type_conversion_p (TREE_TYPE (stmt),
type_left));
}
if (type_right
&& !useless_type_conversion_p (TREE_TYPE (stmt),
TREE_TYPE (TREE_OPERAND (stmt, 2))))
{
TREE_OPERAND (stmt, 2)
= fold_convert (type_right, TREE_OPERAND (stmt, 2));
gcc_assert (useless_type_conversion_p (TREE_TYPE (stmt),
type_right));
}
}
else if (TREE_CODE (stmt) == BIND_EXPR)
{
VEC_safe_push (tree, heap, wtd->bind_expr_stack, stmt);
cp_walk_tree (&BIND_EXPR_BODY (stmt),
cp_genericize_r, data, NULL);
VEC_pop (tree, wtd->bind_expr_stack);
}
else if (TREE_CODE (stmt) == USING_STMT)
{
tree block = NULL_TREE;
/* Get the innermost inclosing GIMPLE_BIND that has a non NULL
BLOCK, and append an IMPORTED_DECL to its
BLOCK_VARS chained list. */
if (wtd->bind_expr_stack)
{
int i;
for (i = VEC_length (tree, wtd->bind_expr_stack) - 1; i >= 0; i--)
if ((block = BIND_EXPR_BLOCK (VEC_index (tree,
wtd->bind_expr_stack, i))))
break;
}
if (block)
{
tree using_directive;
gcc_assert (TREE_OPERAND (stmt, 0));
using_directive = make_node (IMPORTED_DECL);
TREE_TYPE (using_directive) = void_type_node;
IMPORTED_DECL_ASSOCIATED_DECL (using_directive)
= TREE_OPERAND (stmt, 0);
DECL_CHAIN (using_directive) = BLOCK_VARS (block);
BLOCK_VARS (block) = using_directive;
}
/* The USING_STMT won't appear in GENERIC. */
*stmt_p = build1 (NOP_EXPR, void_type_node, integer_zero_node);
*walk_subtrees = 0;
}
else if (TREE_CODE (stmt) == DECL_EXPR
&& TREE_CODE (DECL_EXPR_DECL (stmt)) == USING_DECL)
{
/* Using decls inside DECL_EXPRs are just dropped on the floor. */
*stmt_p = build1 (NOP_EXPR, void_type_node, integer_zero_node);
*walk_subtrees = 0;
}
pointer_set_insert (p_set, *stmt_p);
return NULL;
}
static tree
cp_genericize_r (tree *stmt_p, int *walk_subtrees, void *data)
{
tree stmt = *stmt_p;
struct cp_genericize_data *wtd = (struct cp_genericize_data *) data;
struct pointer_set_t *p_set = wtd->p_set;
/* If in an OpenMP context, note var uses. */
if (__builtin_expect (wtd->omp_ctx != NULL, 0)
&& (VAR_P (stmt)
|| TREE_CODE (stmt) == PARM_DECL
|| TREE_CODE (stmt) == RESULT_DECL)
&& omp_var_to_track (stmt))
omp_cxx_notice_variable (wtd->omp_ctx, stmt);
if (is_invisiref_parm (stmt)
/* Don't dereference parms in a thunk, pass the references through. */
&& !(DECL_THUNK_P (current_function_decl)
&& TREE_CODE (stmt) == PARM_DECL))
{
*stmt_p = convert_from_reference (stmt);
*walk_subtrees = 0;
return NULL;
}
/* Map block scope extern declarations to visible declarations with the
same name and type in outer scopes if any. */
if (cp_function_chain->extern_decl_map
&& VAR_OR_FUNCTION_DECL_P (stmt)
&& DECL_EXTERNAL (stmt))
{
struct cxx_int_tree_map *h, in;
in.uid = DECL_UID (stmt);
h = (struct cxx_int_tree_map *)
htab_find_with_hash (cp_function_chain->extern_decl_map,
&in, in.uid);
if (h)
{
*stmt_p = h->to;
*walk_subtrees = 0;
return NULL;
}
}
/* Other than invisiref parms, don't walk the same tree twice. */
if (pointer_set_contains (p_set, stmt))
{
*walk_subtrees = 0;
return NULL_TREE;
}
if (TREE_CODE (stmt) == ADDR_EXPR
&& is_invisiref_parm (TREE_OPERAND (stmt, 0)))
{
/* If in an OpenMP context, note var uses. */
if (__builtin_expect (wtd->omp_ctx != NULL, 0)
&& omp_var_to_track (TREE_OPERAND (stmt, 0)))
omp_cxx_notice_variable (wtd->omp_ctx, TREE_OPERAND (stmt, 0));
*stmt_p = convert (TREE_TYPE (stmt), TREE_OPERAND (stmt, 0));
*walk_subtrees = 0;
}
else if (TREE_CODE (stmt) == RETURN_EXPR
&& TREE_OPERAND (stmt, 0)
&& is_invisiref_parm (TREE_OPERAND (stmt, 0)))
/* Don't dereference an invisiref RESULT_DECL inside a RETURN_EXPR. */
*walk_subtrees = 0;
else if (TREE_CODE (stmt) == OMP_CLAUSE)
switch (OMP_CLAUSE_CODE (stmt))
{
case OMP_CLAUSE_LASTPRIVATE:
/* Don't dereference an invisiref in OpenMP clauses. */
if (is_invisiref_parm (OMP_CLAUSE_DECL (stmt)))
{
*walk_subtrees = 0;
if (OMP_CLAUSE_LASTPRIVATE_STMT (stmt))
cp_walk_tree (&OMP_CLAUSE_LASTPRIVATE_STMT (stmt),
cp_genericize_r, data, NULL);
}
break;
case OMP_CLAUSE_PRIVATE:
/* Don't dereference an invisiref in OpenMP clauses. */
if (is_invisiref_parm (OMP_CLAUSE_DECL (stmt)))
*walk_subtrees = 0;
else if (wtd->omp_ctx != NULL)
{
/* Private clause doesn't cause any references to the
var in outer contexts, avoid calling
omp_cxx_notice_variable for it. */
struct cp_genericize_omp_taskreg *old = wtd->omp_ctx;
wtd->omp_ctx = NULL;
cp_walk_tree (&OMP_CLAUSE_DECL (stmt), cp_genericize_r,
data, NULL);
wtd->omp_ctx = old;
*walk_subtrees = 0;
}
break;
case OMP_CLAUSE_SHARED:
case OMP_CLAUSE_FIRSTPRIVATE:
case OMP_CLAUSE_COPYIN:
case OMP_CLAUSE_COPYPRIVATE:
/* Don't dereference an invisiref in OpenMP clauses. */
if (is_invisiref_parm (OMP_CLAUSE_DECL (stmt)))
*walk_subtrees = 0;
break;
case OMP_CLAUSE_REDUCTION:
/* Don't dereference an invisiref in reduction clause's
OMP_CLAUSE_DECL either. OMP_CLAUSE_REDUCTION_{INIT,MERGE}
still needs to be genericized. */
if (is_invisiref_parm (OMP_CLAUSE_DECL (stmt)))
{
*walk_subtrees = 0;
if (OMP_CLAUSE_REDUCTION_INIT (stmt))
cp_walk_tree (&OMP_CLAUSE_REDUCTION_INIT (stmt),
cp_genericize_r, data, NULL);
if (OMP_CLAUSE_REDUCTION_MERGE (stmt))
cp_walk_tree (&OMP_CLAUSE_REDUCTION_MERGE (stmt),
cp_genericize_r, data, NULL);
}
break;
default:
break;
}
else if (IS_TYPE_OR_DECL_P (stmt))
*walk_subtrees = 0;
/* Due to the way voidify_wrapper_expr is written, we don't get a chance
to lower this construct before scanning it, so we need to lower these
before doing anything else. */
else if (TREE_CODE (stmt) == CLEANUP_STMT)
*stmt_p = build2_loc (EXPR_LOCATION (stmt),
CLEANUP_EH_ONLY (stmt) ? TRY_CATCH_EXPR
: TRY_FINALLY_EXPR,
void_type_node,
CLEANUP_BODY (stmt),
CLEANUP_EXPR (stmt));
else if (TREE_CODE (stmt) == IF_STMT)
{
genericize_if_stmt (stmt_p);
/* *stmt_p has changed, tail recurse to handle it again. */
return cp_genericize_r (stmt_p, walk_subtrees, data);
}
/* COND_EXPR might have incompatible types in branches if one or both
arms are bitfields. Fix it up now. */
else if (TREE_CODE (stmt) == COND_EXPR)
{
tree type_left
= (TREE_OPERAND (stmt, 1)
? is_bitfield_expr_with_lowered_type (TREE_OPERAND (stmt, 1))
: NULL_TREE);
tree type_right
= (TREE_OPERAND (stmt, 2)
? is_bitfield_expr_with_lowered_type (TREE_OPERAND (stmt, 2))
: NULL_TREE);
if (type_left
&& !useless_type_conversion_p (TREE_TYPE (stmt),
TREE_TYPE (TREE_OPERAND (stmt, 1))))
{
TREE_OPERAND (stmt, 1)
= fold_convert (type_left, TREE_OPERAND (stmt, 1));
gcc_assert (useless_type_conversion_p (TREE_TYPE (stmt),
type_left));
}
if (type_right
&& !useless_type_conversion_p (TREE_TYPE (stmt),
TREE_TYPE (TREE_OPERAND (stmt, 2))))
{
TREE_OPERAND (stmt, 2)
= fold_convert (type_right, TREE_OPERAND (stmt, 2));
gcc_assert (useless_type_conversion_p (TREE_TYPE (stmt),
type_right));
}
}
else if (TREE_CODE (stmt) == BIND_EXPR)
{
if (__builtin_expect (wtd->omp_ctx != NULL, 0))
{
tree decl;
for (decl = BIND_EXPR_VARS (stmt); decl; decl = DECL_CHAIN (decl))
if (VAR_P (decl)
&& !DECL_EXTERNAL (decl)
&& omp_var_to_track (decl))
{
splay_tree_node n
= splay_tree_lookup (wtd->omp_ctx->variables,
(splay_tree_key) decl);
if (n == NULL)
splay_tree_insert (wtd->omp_ctx->variables,
(splay_tree_key) decl,
TREE_STATIC (decl)
? OMP_CLAUSE_DEFAULT_SHARED
: OMP_CLAUSE_DEFAULT_PRIVATE);
}
}
wtd->bind_expr_stack.safe_push (stmt);
cp_walk_tree (&BIND_EXPR_BODY (stmt),
cp_genericize_r, data, NULL);
wtd->bind_expr_stack.pop ();
}
else if (TREE_CODE (stmt) == USING_STMT)
{
tree block = NULL_TREE;
/* Get the innermost inclosing GIMPLE_BIND that has a non NULL
BLOCK, and append an IMPORTED_DECL to its
BLOCK_VARS chained list. */
if (wtd->bind_expr_stack.exists ())
{
int i;
for (i = wtd->bind_expr_stack.length () - 1; i >= 0; i--)
if ((block = BIND_EXPR_BLOCK (wtd->bind_expr_stack[i])))
break;
}
if (block)
{
tree using_directive;
gcc_assert (TREE_OPERAND (stmt, 0));
using_directive = make_node (IMPORTED_DECL);
TREE_TYPE (using_directive) = void_type_node;
IMPORTED_DECL_ASSOCIATED_DECL (using_directive)
= TREE_OPERAND (stmt, 0);
DECL_CHAIN (using_directive) = BLOCK_VARS (block);
BLOCK_VARS (block) = using_directive;
}
/* The USING_STMT won't appear in GENERIC. */
*stmt_p = build1 (NOP_EXPR, void_type_node, integer_zero_node);
*walk_subtrees = 0;
}
else if (TREE_CODE (stmt) == DECL_EXPR
&& TREE_CODE (DECL_EXPR_DECL (stmt)) == USING_DECL)
{
/* Using decls inside DECL_EXPRs are just dropped on the floor. */
*stmt_p = build1 (NOP_EXPR, void_type_node, integer_zero_node);
*walk_subtrees = 0;
}
else if (TREE_CODE (stmt) == OMP_PARALLEL || TREE_CODE (stmt) == OMP_TASK)
{
struct cp_genericize_omp_taskreg omp_ctx;
tree c, decl;
splay_tree_node n;
*walk_subtrees = 0;
cp_walk_tree (&OMP_CLAUSES (stmt), cp_genericize_r, data, NULL);
omp_ctx.is_parallel = TREE_CODE (stmt) == OMP_PARALLEL;
omp_ctx.default_shared = omp_ctx.is_parallel;
omp_ctx.outer = wtd->omp_ctx;
omp_ctx.variables = splay_tree_new (splay_tree_compare_decl_uid, 0, 0);
wtd->omp_ctx = &omp_ctx;
for (c = OMP_CLAUSES (stmt); c; c = OMP_CLAUSE_CHAIN (c))
switch (OMP_CLAUSE_CODE (c))
{
case OMP_CLAUSE_SHARED:
case OMP_CLAUSE_PRIVATE:
case OMP_CLAUSE_FIRSTPRIVATE:
case OMP_CLAUSE_LASTPRIVATE:
decl = OMP_CLAUSE_DECL (c);
if (decl == error_mark_node || !omp_var_to_track (decl))
break;
n = splay_tree_lookup (omp_ctx.variables, (splay_tree_key) decl);
if (n != NULL)
break;
splay_tree_insert (omp_ctx.variables, (splay_tree_key) decl,
OMP_CLAUSE_CODE (c) == OMP_CLAUSE_SHARED
? OMP_CLAUSE_DEFAULT_SHARED
: OMP_CLAUSE_DEFAULT_PRIVATE);
if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_PRIVATE
&& omp_ctx.outer)
omp_cxx_notice_variable (omp_ctx.outer, decl);
break;
case OMP_CLAUSE_DEFAULT:
if (OMP_CLAUSE_DEFAULT_KIND (c) == OMP_CLAUSE_DEFAULT_SHARED)
omp_ctx.default_shared = true;
default:
break;
}
cp_walk_tree (&OMP_BODY (stmt), cp_genericize_r, data, NULL);
wtd->omp_ctx = omp_ctx.outer;
splay_tree_delete (omp_ctx.variables);
}
else if (TREE_CODE (stmt) == CONVERT_EXPR)
gcc_assert (!CONVERT_EXPR_VBASE_PATH (stmt));
else if (TREE_CODE (stmt) == FOR_STMT)
genericize_for_stmt (stmt_p, walk_subtrees, data);
else if (TREE_CODE (stmt) == WHILE_STMT)
genericize_while_stmt (stmt_p, walk_subtrees, data);
else if (TREE_CODE (stmt) == DO_STMT)
genericize_do_stmt (stmt_p, walk_subtrees, data);
else if (TREE_CODE (stmt) == SWITCH_STMT)
genericize_switch_stmt (stmt_p, walk_subtrees, data);
else if (TREE_CODE (stmt) == CONTINUE_STMT)
genericize_continue_stmt (stmt_p);
else if (TREE_CODE (stmt) == BREAK_STMT)
genericize_break_stmt (stmt_p);
else if (TREE_CODE (stmt) == OMP_FOR
|| TREE_CODE (stmt) == OMP_SIMD
|| TREE_CODE (stmt) == OMP_DISTRIBUTE)
genericize_omp_for_stmt (stmt_p, walk_subtrees, data);
else if (TREE_CODE (stmt) == SIZEOF_EXPR)
{
if (SIZEOF_EXPR_TYPE_P (stmt))
*stmt_p
= cxx_sizeof_or_alignof_type (TREE_TYPE (TREE_OPERAND (stmt, 0)),
SIZEOF_EXPR, false);
else if (TYPE_P (TREE_OPERAND (stmt, 0)))
*stmt_p = cxx_sizeof_or_alignof_type (TREE_OPERAND (stmt, 0),
SIZEOF_EXPR, false);
else
*stmt_p = cxx_sizeof_or_alignof_expr (TREE_OPERAND (stmt, 0),
SIZEOF_EXPR, false);
if (*stmt_p == error_mark_node)
*stmt_p = size_one_node;
return NULL;
}
pointer_set_insert (p_set, *stmt_p);
return NULL;
}
static void
dequeue_and_dump (dump_info_p di)
{
//printf(stderr,"code name:%s",tree_code_name[
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;
//print tree code name
//printf("code name:%s\n",tree_code_name[(int) TREE_CODE(t)]);
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);
astTreeBuilder->addNode(index,code_name);
//fprintf
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));
//astTreeBuilder->addChild("type",)
if (BINFO_VIRTUAL_P (t))
gcc_dump_string_field (di, "spec", "virt");
gcc_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 ();
gcc_dump_string_field (di, "accs", string);
gcc_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. */
gcc_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. */
gcc_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 = strrchr (xloc.file, '/');
if (!filename)
filename = xloc.file;
else
/* Skip the slash. */
++filename;
dump_maybe_newline (di);
fprintf (di->stream, "srcp: %s:%-6d ", filename,
xloc.line);
char buf[32];
sprintf(buf,"%s:%-6d",filename,xloc.line);
astTreeBuilder->addStringProperty("srcp",buf);
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))
gcc_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' : ' ');
char buf[32];
sprintf (buf, "%c%c%c ",
(quals & TYPE_QUAL_CONST) ? 'c' : ' ',
(quals & TYPE_QUAL_VOLATILE) ? 'v' : ' ',
(quals & TYPE_QUAL_RESTRICT) ? 'r' : ' ');
astTreeBuilder->addStringProperty("qual",buf);
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. */
gcc_dump_int (di, "algn", TYPE_ALIGN (t));
}
else if (code_class == tcc_constant)
/* All constants can have types. */
gcc_queue_and_dump_type (di, t);
if(TREE_CODE(t)==DECL_EXPR){
//printf("found decl_expr\n");
dump_child ("op 0", DECL_EXPR_DECL (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;
if (gcc_cp_dump_tree(di,t))
goto done;
/* Now handle the various kinds of nodes. */
switch (code)
{
int i;
case IDENTIFIER_NODE:
gcc_dump_string_field (di, "strg", IDENTIFIER_POINTER (t));
gcc_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:
gcc_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:
gcc_dump_int (di, "prec", TYPE_PRECISION (t));
gcc_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:
gcc_dump_int (di, "prec", TYPE_PRECISION (t));
gcc_dump_string_field (di, "sign", TYPE_UNSIGNED (t) ? "unsigned": "signed");
gcc_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)
gcc_dump_string_field (di, "tag", "struct");
else
gcc_dump_string_field (di, "tag", "union");
dump_child ("flds", TYPE_FIELDS (t));
//add debug chain
//dump_child ("fldschan",TREE_CHAIN(TYPE_FIELDS(t)));
dump_child ("fncs", TYPE_METHODS (t));
gcc_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. */
//debug
//case DECL_EXPR:
//if(DECL_EXPR_DECL (t) != NULL){
//dump_child ("decl_obj", DECL_EXPR_DECL (t));
//}
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));
gcc_dump_int (di, "algn", DECL_ALIGN (t));
if (TREE_CODE (t) == FIELD_DECL)
{
//dump_child ("chan",TREE_CHAIN(t));
if (DECL_FIELD_OFFSET (t))
dump_child ("bpos", bit_position (t));
dump_child ("chan",TREE_CHAIN(t));
//dump_child ("chan",TREE_CHAIN(t));
}else if (TREE_CODE(t) == VAR_DECL)
{
//if (DECL_FIELD_OFFSET (t))
//dump_child ("bpos", bit_position (t));
//dump_child ("chan",TREE_CHAIN(t));
//temporary solution: if scope is of struct_decl I chain it up
tree decl_context = DECL_CONTEXT(t);
if (decl_context && TREE_CODE(DECL_CONTEXT(t))==RECORD_TYPE)
{
dump_child ("chan",TREE_CHAIN(t));
}
gcc_dump_int (di, "used", TREE_USED (t));
//dump_child ("chan",TREE_CHAIN(t));
if (DECL_REGISTER (t))
gcc_dump_string_field (di, "spec", "register");
}
//debug add
//dump_child ("chan",next);
else if (TREE_CODE (t) == PARM_DECL)
{
gcc_dump_int (di, "used", TREE_USED (t));
//dump_child ("chan",TREE_CHAIN(t));
if (DECL_REGISTER (t))
gcc_dump_string_field (di, "spec", "register");
}
break;
case FUNCTION_DECL:
dump_child ("args", DECL_ARGUMENTS (t));
if (DECL_EXTERNAL (t))
gcc_dump_string_field (di, "body", "undefined");
if (TREE_PUBLIC (t))
gcc_dump_string_field (di, "link", "extern");
else
gcc_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));
gcc_dump_int (di, "low", TREE_INT_CST_LOW (t));
break;
case STRING_CST:
fprintf (di->stream, "strg: %-7s ", TREE_STRING_POINTER (t));
gcc_dump_int (di, "lngt", TREE_STRING_LENGTH (t));
break;
case REAL_CST:
gcc_dump_real (di, "valu", TREE_REAL_CST_PTR (t));
break;
case FIXED_CST:
gcc_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:
gcc_dump_stmt (di, t);
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;
gcc_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);
}
}
