void
check_handlers (tree handlers)
{
tree_stmt_iterator i;
/* If we don't have a STATEMENT_LIST, then we've just got one
handler, and thus nothing to warn about. */
if (TREE_CODE (handlers) != STATEMENT_LIST)
return;
i = tsi_start (handlers);
if (!tsi_end_p (i))
while (1)
{
tree handler = tsi_stmt (i);
tsi_next (&i);
/* No more handlers; nothing to shadow. */
if (tsi_end_p (i))
break;
if (TREE_TYPE (handler) == NULL_TREE)
permerror (EXPR_LOCATION (handler), "%<...%>"
" handler must be the last handler for its try block");
else
check_handlers_1 (handler, i);
}
}
static void
add_expr_to_chain (tree* chain, tree expr, bool front)
{
if (expr == NULL_TREE || IS_EMPTY_STMT (expr))
return;
if (*chain)
{
if (TREE_CODE (*chain) != STATEMENT_LIST)
{
tree tmp;
tmp = *chain;
*chain = NULL_TREE;
append_to_statement_list (tmp, chain);
}
if (front)
{
tree_stmt_iterator i;
i = tsi_start (*chain);
tsi_link_before (&i, expr, TSI_CONTINUE_LINKING);
}
else
append_to_statement_list (expr, chain);
}
else
*chain = expr;
}
static void
lower_stmt_body (tree expr, struct lower_data *data)
{
tree_stmt_iterator tsi;
for (tsi = tsi_start (expr); !tsi_end_p (tsi); )
lower_stmt (&tsi, data);
}
static void
mf_decl_cache_locals (void)
{
tree t, shift_init_stmts, mask_init_stmts;
tree_stmt_iterator tsi;
/* Build the cache vars. */
mf_cache_shift_decl_l
= mf_mark (create_tmp_var (TREE_TYPE (mf_cache_shift_decl),
"__mf_lookup_shift_l"));
mf_cache_mask_decl_l
= mf_mark (create_tmp_var (TREE_TYPE (mf_cache_mask_decl),
"__mf_lookup_mask_l"));
/* Build initialization nodes for the cache vars. We just load the
globals into the cache variables. */
t = build2 (MODIFY_EXPR, TREE_TYPE (mf_cache_shift_decl_l),
mf_cache_shift_decl_l, mf_cache_shift_decl);
SET_EXPR_LOCATION (t, DECL_SOURCE_LOCATION (current_function_decl));
gimplify_to_stmt_list (&t);
shift_init_stmts = t;
t = build2 (MODIFY_EXPR, TREE_TYPE (mf_cache_mask_decl_l),
mf_cache_mask_decl_l, mf_cache_mask_decl);
SET_EXPR_LOCATION (t, DECL_SOURCE_LOCATION (current_function_decl));
gimplify_to_stmt_list (&t);
mask_init_stmts = t;
/* Anticipating multiple entry points, we insert the cache vars
initializers in each successor of the ENTRY_BLOCK_PTR. */
for (tsi = tsi_start (shift_init_stmts);
! tsi_end_p (tsi);
tsi_next (&tsi))
insert_edge_copies (tsi_stmt (tsi), ENTRY_BLOCK_PTR);
for (tsi = tsi_start (mask_init_stmts);
! tsi_end_p (tsi);
tsi_next (&tsi))
insert_edge_copies (tsi_stmt (tsi), ENTRY_BLOCK_PTR);
bsi_commit_edge_inserts ();
}
tree
fix_conditional_array_notations (tree stmt)
{
if (TREE_CODE (stmt) == STATEMENT_LIST)
{
tree_stmt_iterator tsi;
for (tsi = tsi_start (stmt); !tsi_end_p (tsi); tsi_next (&tsi))
{
tree single_stmt = *tsi_stmt_ptr (tsi);
*tsi_stmt_ptr (tsi) =
fix_conditional_array_notations_1 (single_stmt);
}
return stmt;
}
else
return fix_conditional_array_notations_1 (stmt);
}
void parseStatementListNode(StatementListNode *node)
{
fillType(node);
Log::dump(node);
if (node->parseChilds <= 0)
return;
for (tree_stmt_iterator it = tsi_start (node->gccNode);
!tsi_end_p (it);
tsi_next (&it))
{
node->statements.push_back(createParseNode(
node,
tsi_stmt (it),
"statement"));
}
}
static bool
try_catch_may_fallthru (const_tree stmt)
{
tree_stmt_iterator i;
/* If the TRY block can fall through, the whole TRY_CATCH can
fall through. */
if (block_may_fallthru (TREE_OPERAND (stmt, 0)))
return true;
i = tsi_start (TREE_OPERAND (stmt, 1));
switch (TREE_CODE (tsi_stmt (i)))
{
case CATCH_EXPR:
/* We expect to see a sequence of CATCH_EXPR trees, each with a
catch expression and a body. The whole TRY_CATCH may fall
through iff any of the catch bodies falls through. */
for (; !tsi_end_p (i); tsi_next (&i))
{
if (block_may_fallthru (CATCH_BODY (tsi_stmt (i))))
return true;
}
return false;
case EH_FILTER_EXPR:
/* The exception filter expression only matters if there is an
exception. If the exception does not match EH_FILTER_TYPES,
we will execute EH_FILTER_FAILURE, and we will fall through
if that falls through. If the exception does match
EH_FILTER_TYPES, the stack unwinder will continue up the
stack, so we will not fall through. We don't know whether we
will throw an exception which matches EH_FILTER_TYPES or not,
so we just ignore EH_FILTER_TYPES and assume that we might
throw an exception which doesn't match. */
return block_may_fallthru (EH_FILTER_FAILURE (tsi_stmt (i)));
default:
/* This case represents statements to be executed when an
exception occurs. Those statements are implicitly followed
by a RESX statement to resume execution after the exception.
So in this case the TRY_CATCH never falls through. */
return false;
}
}
tree
pop_stmt_list (tree t)
{
tree u = NULL_TREE;
/* Pop statement lists until we reach the target level. The extra
nestings will be due to outstanding cleanups. */
while (1)
{
u = stmt_list_stack->pop ();
if (!stmt_list_stack->is_empty ())
{
tree x = stmt_list_stack->last ();
STATEMENT_LIST_HAS_LABEL (x) |= STATEMENT_LIST_HAS_LABEL (u);
}
if (t == u)
break;
}
gcc_assert (u != NULL_TREE);
/* If the statement list is completely empty, just return it. This is
just as good small as build_empty_stmt, with the advantage that
statement lists are merged when they appended to one another. So
using the STATEMENT_LIST avoids pathological buildup of EMPTY_STMT_P
statements. */
if (TREE_SIDE_EFFECTS (t))
{
tree_stmt_iterator i = tsi_start (t);
/* If the statement list contained exactly one statement, then
extract it immediately. */
if (tsi_one_before_end_p (i))
{
u = tsi_stmt (i);
tsi_delink (&i);
free_stmt_list (t);
t = u;
}
}
return t;
}
static tree
build_trivial_generic_function ()
{
auto_vec <tree> param_types;
tree fndecl = make_fndecl (integer_type_node,
"test_fn",
param_types);
ASSERT_TRUE (fndecl != NULL);
/* Populate the function. */
tree retval = build_decl (UNKNOWN_LOCATION, RESULT_DECL,
NULL_TREE, integer_type_node);
DECL_ARTIFICIAL (retval) = 1;
DECL_IGNORED_P (retval) = 1;
DECL_RESULT (fndecl) = retval;
/* Create a BIND_EXPR, and within it, a statement list. */
tree stmt_list = alloc_stmt_list ();
tree_stmt_iterator stmt_iter = tsi_start (stmt_list);
tree block = make_node (BLOCK);
tree bind_expr
= build3 (BIND_EXPR, void_type_node, NULL, stmt_list, block);
tree modify_retval = build2 (MODIFY_EXPR,
integer_type_node,
retval,
build_int_cst (integer_type_node, 42));
tree return_stmt = build1 (RETURN_EXPR,
integer_type_node,
modify_retval);
tsi_link_after (&stmt_iter, return_stmt, TSI_CONTINUE_LINKING);
DECL_INITIAL (fndecl) = block;
/* how to add to function? the following appears to be how to
set the body of a fndecl: */
DECL_SAVED_TREE(fndecl) = bind_expr;
/* Ensure that locals appear in the debuginfo. */
BLOCK_VARS (block) = BIND_EXPR_VARS (bind_expr);
return fndecl;
}
bool
find_rank (location_t loc, tree orig_expr, tree expr, bool ignore_builtin_fn,
size_t *rank)
{
tree ii_tree;
size_t ii = 0, current_rank = 0;
if (TREE_CODE (expr) == ARRAY_NOTATION_REF)
{
ii_tree = expr;
while (ii_tree)
{
if (TREE_CODE (ii_tree) == ARRAY_NOTATION_REF)
{
current_rank++;
ii_tree = ARRAY_NOTATION_ARRAY (ii_tree);
}
else if (handled_component_p (ii_tree)
|| TREE_CODE (ii_tree) == INDIRECT_REF)
ii_tree = TREE_OPERAND (ii_tree, 0);
else if (TREE_CODE (ii_tree) == PARM_DECL
|| TREE_CODE (ii_tree) == VAR_DECL)
break;
else
gcc_unreachable ();
}
if (*rank == 0)
/* In this case, all the expressions this function has encountered thus
far have been scalars or expressions with zero rank. Please see
header comment for examples of such expression. */
*rank = current_rank;
else if (*rank != current_rank)
{
/* In this case, find rank is being recursed through a set of
expression of the form A <OPERATION> B, where A and B both have
array notations in them and the rank of A is not equal to rank of
B.
A simple example of such case is the following: X[:] + Y[:][:] */
*rank = current_rank;
return false;
}
}
else if (TREE_CODE (expr) == STATEMENT_LIST)
{
tree_stmt_iterator ii_tsi;
for (ii_tsi = tsi_start (expr); !tsi_end_p (ii_tsi);
tsi_next (&ii_tsi))
if (!find_rank (loc, orig_expr, *tsi_stmt_ptr (ii_tsi),
ignore_builtin_fn, rank))
return false;
}
else
{
if (TREE_CODE (expr) == CALL_EXPR)
{
tree func_name = CALL_EXPR_FN (expr);
tree prev_arg = NULL_TREE, arg;
call_expr_arg_iterator iter;
size_t prev_rank = 0;
if (TREE_CODE (func_name) == ADDR_EXPR)
if (!ignore_builtin_fn)
if (is_cilkplus_reduce_builtin (func_name))
/* If it is a built-in function, then we know it returns a
scalar. */
return true;
if (!find_rank (loc, orig_expr, func_name, ignore_builtin_fn, rank))
return false;
FOR_EACH_CALL_EXPR_ARG (arg, iter, expr)
{
if (!find_rank (loc, orig_expr, arg, ignore_builtin_fn, rank))
{
if (prev_arg && EXPR_HAS_LOCATION (prev_arg)
&& prev_rank != *rank)
error_at (EXPR_LOCATION (prev_arg),
"rank mismatch between %qE and %qE", prev_arg,
arg);
else if (prev_arg && prev_rank != *rank)
/* Here the original expression is printed as a "heads-up"
to the programmer. This is because since there is no
location information for the offending argument, the
error could be in some internally generated code that is
not visible for the programmer. Thus, the correct fix
may lie in the original expression. */
error_at (loc, "rank mismatch in expression %qE",
orig_expr);
return false;
}
prev_arg = arg;
prev_rank = *rank;
}
}
else
{
static void
dequeue_and_dump (dump_info_p di)
{
dump_queue_p dq;
splay_tree_node stn;
dump_node_info_p dni;
tree t;
unsigned int index;
enum tree_code code;
enum tree_code_class code_class;
const char* code_name;
/* Get the next node from the queue. */
dq = di->queue;
stn = dq->node;
t = (tree) stn->key;
dni = (dump_node_info_p) stn->value;
index = dni->index;
/* Remove the node from the queue, and put it on the free list. */
di->queue = dq->next;
if (!di->queue)
di->queue_end = 0;
dq->next = di->free_list;
di->free_list = dq;
/* Print the node index. */
dump_index (di, index);
/* And the type of node this is. */
if (dni->binfo_p)
code_name = "binfo";
else
code_name = tree_code_name[(int) TREE_CODE (t)];
fprintf (di->stream, "%-16s ", code_name);
di->column = 25;
/* Figure out what kind of node this is. */
code = TREE_CODE (t);
code_class = TREE_CODE_CLASS (code);
/* Although BINFOs are TREE_VECs, we dump them specially so as to be
more informative. */
if (dni->binfo_p)
{
unsigned ix;
tree base;
VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (t);
dump_child ("type", BINFO_TYPE (t));
if (BINFO_VIRTUAL_P (t))
dump_string_field (di, "spec", "virt");
dump_int (di, "bases", BINFO_N_BASE_BINFOS (t));
for (ix = 0; BINFO_BASE_ITERATE (t, ix, base); ix++)
{
tree access = (accesses ? VEC_index (tree, accesses, ix)
: access_public_node);
const char *string = NULL;
if (access == access_public_node)
string = "pub";
else if (access == access_protected_node)
string = "prot";
else if (access == access_private_node)
string = "priv";
else
gcc_unreachable ();
dump_string_field (di, "accs", string);
queue_and_dump_index (di, "binf", base, DUMP_BINFO);
}
goto done;
}
/* We can knock off a bunch of expression nodes in exactly the same
way. */
if (IS_EXPR_CODE_CLASS (code_class))
{
/* If we're dumping children, dump them now. */
queue_and_dump_type (di, t);
switch (code_class)
{
case tcc_unary:
dump_child ("op 0", TREE_OPERAND (t, 0));
break;
case tcc_binary:
case tcc_comparison:
dump_child ("op 0", TREE_OPERAND (t, 0));
dump_child ("op 1", TREE_OPERAND (t, 1));
break;
case tcc_expression:
case tcc_reference:
case tcc_statement:
case tcc_vl_exp:
/* These nodes are handled explicitly below. */
break;
default:
gcc_unreachable ();
}
}
else if (DECL_P (t))
{
expanded_location xloc;
/* All declarations have names. */
if (DECL_NAME (t))
dump_child ("name", DECL_NAME (t));
if (DECL_ASSEMBLER_NAME_SET_P (t)
&& DECL_ASSEMBLER_NAME (t) != DECL_NAME (t))
dump_child ("mngl", DECL_ASSEMBLER_NAME (t));
if (DECL_ABSTRACT_ORIGIN (t))
dump_child ("orig", DECL_ABSTRACT_ORIGIN (t));
/* And types. */
queue_and_dump_type (di, t);
dump_child ("scpe", DECL_CONTEXT (t));
/* And a source position. */
xloc = expand_location (DECL_SOURCE_LOCATION (t));
if (xloc.file)
{
const char *filename = lbasename (xloc.file);
dump_maybe_newline (di);
fprintf (di->stream, "srcp: %s:%-6d ", filename,
xloc.line);
di->column += 6 + strlen (filename) + 8;
}
/* And any declaration can be compiler-generated. */
if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_COMMON)
&& DECL_ARTIFICIAL (t))
dump_string_field (di, "note", "artificial");
if (DECL_CHAIN (t) && !dump_flag (di, TDF_SLIM, NULL))
dump_child ("chain", DECL_CHAIN (t));
}
else if (code_class == tcc_type)
{
/* All types have qualifiers. */
int quals = lang_hooks.tree_dump.type_quals (t);
if (quals != TYPE_UNQUALIFIED)
{
fprintf (di->stream, "qual: %c%c%c ",
(quals & TYPE_QUAL_CONST) ? 'c' : ' ',
(quals & TYPE_QUAL_VOLATILE) ? 'v' : ' ',
(quals & TYPE_QUAL_RESTRICT) ? 'r' : ' ');
di->column += 14;
}
/* All types have associated declarations. */
dump_child ("name", TYPE_NAME (t));
/* All types have a main variant. */
if (TYPE_MAIN_VARIANT (t) != t)
dump_child ("unql", TYPE_MAIN_VARIANT (t));
/* And sizes. */
dump_child ("size", TYPE_SIZE (t));
/* All types have alignments. */
dump_int (di, "algn", TYPE_ALIGN (t));
}
else if (code_class == tcc_constant)
/* All constants can have types. */
queue_and_dump_type (di, t);
/* Give the language-specific code a chance to print something. If
it's completely taken care of things, don't bother printing
anything more ourselves. */
if (lang_hooks.tree_dump.dump_tree (di, t))
goto done;
/* Now handle the various kinds of nodes. */
switch (code)
{
int i;
case IDENTIFIER_NODE:
dump_string_field (di, "strg", IDENTIFIER_POINTER (t));
dump_int (di, "lngt", IDENTIFIER_LENGTH (t));
break;
case TREE_LIST:
dump_child ("purp", TREE_PURPOSE (t));
dump_child ("valu", TREE_VALUE (t));
dump_child ("chan", TREE_CHAIN (t));
break;
case STATEMENT_LIST:
{
tree_stmt_iterator it;
for (i = 0, it = tsi_start (t); !tsi_end_p (it); tsi_next (&it), i++)
{
char buffer[32];
sprintf (buffer, "%u", i);
dump_child (buffer, tsi_stmt (it));
}
}
break;
case TREE_VEC:
dump_int (di, "lngt", TREE_VEC_LENGTH (t));
for (i = 0; i < TREE_VEC_LENGTH (t); ++i)
{
char buffer[32];
sprintf (buffer, "%u", i);
dump_child (buffer, TREE_VEC_ELT (t, i));
}
break;
case INTEGER_TYPE:
case ENUMERAL_TYPE:
dump_int (di, "prec", TYPE_PRECISION (t));
dump_string_field (di, "sign", TYPE_UNSIGNED (t) ? "unsigned": "signed");
dump_child ("min", TYPE_MIN_VALUE (t));
dump_child ("max", TYPE_MAX_VALUE (t));
if (code == ENUMERAL_TYPE)
dump_child ("csts", TYPE_VALUES (t));
break;
case REAL_TYPE:
dump_int (di, "prec", TYPE_PRECISION (t));
break;
case FIXED_POINT_TYPE:
dump_int (di, "prec", TYPE_PRECISION (t));
dump_string_field (di, "sign", TYPE_UNSIGNED (t) ? "unsigned": "signed");
dump_string_field (di, "saturating",
TYPE_SATURATING (t) ? "saturating": "non-saturating");
break;
case POINTER_TYPE:
dump_child ("ptd", TREE_TYPE (t));
break;
case REFERENCE_TYPE:
dump_child ("refd", TREE_TYPE (t));
break;
case METHOD_TYPE:
dump_child ("clas", TYPE_METHOD_BASETYPE (t));
/* Fall through. */
case FUNCTION_TYPE:
dump_child ("retn", TREE_TYPE (t));
dump_child ("prms", TYPE_ARG_TYPES (t));
break;
case ARRAY_TYPE:
dump_child ("elts", TREE_TYPE (t));
dump_child ("domn", TYPE_DOMAIN (t));
break;
case RECORD_TYPE:
case UNION_TYPE:
if (TREE_CODE (t) == RECORD_TYPE)
dump_string_field (di, "tag", "struct");
else
dump_string_field (di, "tag", "union");
dump_child ("flds", TYPE_FIELDS (t));
dump_child ("fncs", TYPE_METHODS (t));
queue_and_dump_index (di, "binf", TYPE_BINFO (t),
DUMP_BINFO);
break;
case CONST_DECL:
dump_child ("cnst", DECL_INITIAL (t));
break;
case DEBUG_EXPR_DECL:
dump_int (di, "-uid", DEBUG_TEMP_UID (t));
/* Fall through. */
case VAR_DECL:
case PARM_DECL:
case FIELD_DECL:
case RESULT_DECL:
if (TREE_CODE (t) == PARM_DECL)
dump_child ("argt", DECL_ARG_TYPE (t));
else
dump_child ("init", DECL_INITIAL (t));
dump_child ("size", DECL_SIZE (t));
dump_int (di, "algn", DECL_ALIGN (t));
if (TREE_CODE (t) == FIELD_DECL)
{
if (DECL_FIELD_OFFSET (t))
dump_child ("bpos", bit_position (t));
}
else if (TREE_CODE (t) == VAR_DECL
|| TREE_CODE (t) == PARM_DECL)
{
dump_int (di, "used", TREE_USED (t));
if (DECL_REGISTER (t))
dump_string_field (di, "spec", "register");
}
break;
case FUNCTION_DECL:
dump_child ("args", DECL_ARGUMENTS (t));
if (DECL_EXTERNAL (t))
dump_string_field (di, "body", "undefined");
if (TREE_PUBLIC (t))
dump_string_field (di, "link", "extern");
else
dump_string_field (di, "link", "static");
if (DECL_SAVED_TREE (t) && !dump_flag (di, TDF_SLIM, t))
dump_child ("body", DECL_SAVED_TREE (t));
break;
case INTEGER_CST:
if (TREE_INT_CST_HIGH (t))
dump_int (di, "high", TREE_INT_CST_HIGH (t));
dump_int (di, "low", TREE_INT_CST_LOW (t));
break;
case STRING_CST:
fprintf (di->stream, "strg: %-7s ", TREE_STRING_POINTER (t));
dump_int (di, "lngt", TREE_STRING_LENGTH (t));
break;
case REAL_CST:
dump_real (di, "valu", TREE_REAL_CST_PTR (t));
break;
case FIXED_CST:
dump_fixed (di, "valu", TREE_FIXED_CST_PTR (t));
break;
case TRUTH_NOT_EXPR:
case ADDR_EXPR:
case INDIRECT_REF:
case CLEANUP_POINT_EXPR:
case SAVE_EXPR:
case REALPART_EXPR:
case IMAGPART_EXPR:
/* These nodes are unary, but do not have code class `1'. */
dump_child ("op 0", TREE_OPERAND (t, 0));
break;
case TRUTH_ANDIF_EXPR:
case TRUTH_ORIF_EXPR:
case INIT_EXPR:
case MODIFY_EXPR:
case COMPOUND_EXPR:
case PREDECREMENT_EXPR:
case PREINCREMENT_EXPR:
case POSTDECREMENT_EXPR:
case POSTINCREMENT_EXPR:
/* These nodes are binary, but do not have code class `2'. */
dump_child ("op 0", TREE_OPERAND (t, 0));
dump_child ("op 1", TREE_OPERAND (t, 1));
break;
case COMPONENT_REF:
dump_child ("op 0", TREE_OPERAND (t, 0));
dump_child ("op 1", TREE_OPERAND (t, 1));
dump_child ("op 2", TREE_OPERAND (t, 2));
break;
case ARRAY_REF:
case ARRAY_RANGE_REF:
dump_child ("op 0", TREE_OPERAND (t, 0));
dump_child ("op 1", TREE_OPERAND (t, 1));
dump_child ("op 2", TREE_OPERAND (t, 2));
dump_child ("op 3", TREE_OPERAND (t, 3));
break;
case COND_EXPR:
dump_child ("op 0", TREE_OPERAND (t, 0));
dump_child ("op 1", TREE_OPERAND (t, 1));
dump_child ("op 2", TREE_OPERAND (t, 2));
break;
case TRY_FINALLY_EXPR:
dump_child ("op 0", TREE_OPERAND (t, 0));
dump_child ("op 1", TREE_OPERAND (t, 1));
break;
case CALL_EXPR:
{
int i = 0;
tree arg;
call_expr_arg_iterator iter;
dump_child ("fn", CALL_EXPR_FN (t));
FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
{
char buffer[32];
sprintf (buffer, "%u", i);
dump_child (buffer, arg);
i++;
}
}
break;
case CONSTRUCTOR:
{
unsigned HOST_WIDE_INT cnt;
tree index, value;
dump_int (di, "lngt", VEC_length (constructor_elt,
CONSTRUCTOR_ELTS (t)));
FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), cnt, index, value)
{
dump_child ("idx", index);
dump_child ("val", value);
}
}
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 void
lower_function_body (void)
{
struct lower_data data;
tree *body_p = &DECL_SAVED_TREE (current_function_decl);
tree bind = *body_p;
tree_stmt_iterator i;
tree t, x;
gcc_assert (TREE_CODE (bind) == BIND_EXPR);
data.block = DECL_INITIAL (current_function_decl);
BLOCK_SUBBLOCKS (data.block) = NULL_TREE;
BLOCK_CHAIN (data.block) = NULL_TREE;
TREE_ASM_WRITTEN (data.block) = 1;
data.return_statements = NULL_TREE;
*body_p = alloc_stmt_list ();
i = tsi_start (*body_p);
tsi_link_after (&i, bind, TSI_NEW_STMT);
lower_bind_expr (&i, &data);
i = tsi_last (*body_p);
/* If the function falls off the end, we need a null return statement.
If we've already got one in the return_statements list, we don't
need to do anything special. Otherwise build one by hand. */
if (block_may_fallthru (*body_p)
&& (data.return_statements == NULL
|| TREE_OPERAND (TREE_VALUE (data.return_statements), 0) != NULL))
{
x = build (RETURN_EXPR, void_type_node, NULL);
SET_EXPR_LOCATION (x, cfun->function_end_locus);
tsi_link_after (&i, x, TSI_CONTINUE_LINKING);
}
/* If we lowered any return statements, emit the representative
at the end of the function. */
for (t = data.return_statements ; t ; t = TREE_CHAIN (t))
{
x = build (LABEL_EXPR, void_type_node, TREE_PURPOSE (t));
tsi_link_after (&i, x, TSI_CONTINUE_LINKING);
/* Remove the line number from the representative return statement.
It now fills in for many such returns. Failure to remove this
will result in incorrect results for coverage analysis. */
x = TREE_VALUE (t);
#ifdef USE_MAPPED_LOCATION
SET_EXPR_LOCATION (x, UNKNOWN_LOCATION);
#else
SET_EXPR_LOCUS (x, NULL);
#endif
tsi_link_after (&i, x, TSI_CONTINUE_LINKING);
}
gcc_assert (data.block == DECL_INITIAL (current_function_decl));
BLOCK_SUBBLOCKS (data.block)
= blocks_nreverse (BLOCK_SUBBLOCKS (data.block));
clear_block_marks (data.block);
}
void process_stmt (tree stmt) {
tree_stmt_iterator si;
switch (TREE_CODE(stmt)) {
case STATEMENT_LIST: // this is a statement list
printf("statement_list\n");
for (si = tsi_start (stmt); !tsi_end_p (si); tsi_next (&si)) {
process_stmt(tsi_stmt(si));
}
break;
case BIND_EXPR: // this is a bind expression
printf("bind_expr\n");
process_stmt((BIND_EXPR_BODY(stmt)));
break;
case DECL_EXPR: // this is a desclare expression
printf("decl_expr\n");
num_statements++;
num_local_var++;
break;
case MODIFY_EXPR: // this is a modify expression
printf("modify_expr\n");
num_statements++;
break;
case CALL_EXPR: // this is a function call expression
printf("call_expr\n");
num_statements++;
break;
case RETURN_EXPR: // this is a return value expression
printf("return_expr\n");
num_statements++;
break;
case COND_EXPR: // this is a conditional branch expression
printf("cond_expr\n");
tree then_node = COND_EXPR_THEN(stmt);
tree else_node = COND_EXPR_ELSE(stmt);
if (!(then_node && TREE_CODE(then_node) == GOTO_EXPR && !EXPR_HAS_LOCATION(then_node)
&& else_node && TREE_CODE(else_node) == GOTO_EXPR && !EXPR_HAS_LOCATION(else_node))) {
num_statements++;
}
process_stmt(COND_EXPR_THEN(stmt));
if (COND_EXPR_ELSE(stmt))
process_stmt(COND_EXPR_ELSE(stmt));
break;
case SWITCH_EXPR: // this is a switch branch expression
printf("switch_expr\n");
num_statements++;
process_stmt(SWITCH_BODY(stmt));
break;
case CASE_LABEL_EXPR: // this is a case label expression
printf("case_label_expr\n");
break;
case GOTO_EXPR: // this is a jump expression
printf("goto_expr\n");
// if (!DECL_IS_BUILTIN(GOTO_DESTINATION (stmt)))
// num_statements++;
if (EXPR_HAS_LOCATION(stmt)) {
num_statements++;
}
break;
case LABEL_EXPR: // this is a jump destination label expression
printf("label_expr\n");
break;
default:
printf("default\n");
break;
}
// printf("number of statements: %d\n", num_statements);
}
/* Synthesize a CALL_EXPR and a TRY_FINALLY_EXPR, for this chain of
_DECLs if appropriate. Arrange to call the __mf_register function
now, and the __mf_unregister function later for each. */
static void
mx_register_decls (tree decl, tree *stmt_list)
{
tree finally_stmts = NULL_TREE;
tree_stmt_iterator initially_stmts = tsi_start (*stmt_list);
while (decl != NULL_TREE)
{
if (mf_decl_eligible_p (decl)
/* Not already processed. */
&& ! mf_marked_p (decl)
/* Automatic variable. */
&& ! DECL_EXTERNAL (decl)
&& ! TREE_STATIC (decl))
{
tree size = NULL_TREE, variable_name;
tree unregister_fncall, unregister_fncall_params;
tree register_fncall, register_fncall_params;
size = convert (size_type_node, TYPE_SIZE_UNIT (TREE_TYPE (decl)));
/* (& VARIABLE, sizeof (VARIABLE), __MF_TYPE_STACK) */
unregister_fncall_params =
tree_cons (NULL_TREE,
convert (ptr_type_node,
mf_mark (build1 (ADDR_EXPR,
build_pointer_type (TREE_TYPE (decl)),
decl))),
tree_cons (NULL_TREE,
size,
tree_cons (NULL_TREE,
/* __MF_TYPE_STACK */
build_int_cst (NULL_TREE, 3),
NULL_TREE)));
/* __mf_unregister (...) */
unregister_fncall = build_function_call_expr (mf_unregister_fndecl,
unregister_fncall_params);
/* (& VARIABLE, sizeof (VARIABLE), __MF_TYPE_STACK, "name") */
variable_name = mf_varname_tree (decl);
register_fncall_params =
tree_cons (NULL_TREE,
convert (ptr_type_node,
mf_mark (build1 (ADDR_EXPR,
build_pointer_type (TREE_TYPE (decl)),
decl))),
tree_cons (NULL_TREE,
size,
tree_cons (NULL_TREE,
/* __MF_TYPE_STACK */
build_int_cst (NULL_TREE, 3),
tree_cons (NULL_TREE,
variable_name,
NULL_TREE))));
/* __mf_register (...) */
register_fncall = build_function_call_expr (mf_register_fndecl,
register_fncall_params);
/* Accumulate the two calls. */
/* ??? Set EXPR_LOCATION. */
gimplify_stmt (®ister_fncall);
gimplify_stmt (&unregister_fncall);
/* Add the __mf_register call at the current appending point. */
if (tsi_end_p (initially_stmts))
warning (0, "mudflap cannot track %qs in stub function",
IDENTIFIER_POINTER (DECL_NAME (decl)));
else
{
tsi_link_before (&initially_stmts, register_fncall, TSI_SAME_STMT);
/* Accumulate the FINALLY piece. */
append_to_statement_list (unregister_fncall, &finally_stmts);
}
mf_mark (decl);
}
decl = TREE_CHAIN (decl);
}
/* Actually, (initially_stmts!=NULL) <=> (finally_stmts!=NULL) */
if (finally_stmts != NULL_TREE)
{
tree t = build2 (TRY_FINALLY_EXPR, void_type_node,
*stmt_list, finally_stmts);
*stmt_list = NULL;
append_to_statement_list (t, stmt_list);
}
}
static void
mf_build_check_statement_for (tree base, tree limit,
block_stmt_iterator *instr_bsi,
location_t *locus, tree dirflag)
{
tree_stmt_iterator head, tsi;
block_stmt_iterator bsi;
basic_block cond_bb, then_bb, join_bb;
edge e;
tree cond, t, u, v;
tree mf_base;
tree mf_elem;
tree mf_limit;
/* We first need to split the current basic block, and start altering
the CFG. This allows us to insert the statements we're about to
construct into the right basic blocks. */
cond_bb = bb_for_stmt (bsi_stmt (*instr_bsi));
bsi = *instr_bsi;
bsi_prev (&bsi);
if (! bsi_end_p (bsi))
e = split_block (cond_bb, bsi_stmt (bsi));
else
e = split_block_after_labels (cond_bb);
cond_bb = e->src;
join_bb = e->dest;
/* A recap at this point: join_bb is the basic block at whose head
is the gimple statement for which this check expression is being
built. cond_bb is the (possibly new, synthetic) basic block the
end of which will contain the cache-lookup code, and a
conditional that jumps to the cache-miss code or, much more
likely, over to join_bb. */
/* Create the bb that contains the cache-miss fallback block (mf_check). */
then_bb = create_empty_bb (cond_bb);
make_edge (cond_bb, then_bb, EDGE_TRUE_VALUE);
make_single_succ_edge (then_bb, join_bb, EDGE_FALLTHRU);
/* Mark the pseudo-fallthrough edge from cond_bb to join_bb. */
e = find_edge (cond_bb, join_bb);
e->flags = EDGE_FALSE_VALUE;
e->count = cond_bb->count;
e->probability = REG_BR_PROB_BASE;
/* Update dominance info. Note that bb_join's data was
updated by split_block. */
if (dom_info_available_p (CDI_DOMINATORS))
{
set_immediate_dominator (CDI_DOMINATORS, then_bb, cond_bb);
set_immediate_dominator (CDI_DOMINATORS, join_bb, cond_bb);
}
/* Build our local variables. */
mf_elem = create_tmp_var (mf_cache_structptr_type, "__mf_elem");
mf_base = create_tmp_var (mf_uintptr_type, "__mf_base");
mf_limit = create_tmp_var (mf_uintptr_type, "__mf_limit");
/* Build: __mf_base = (uintptr_t) <base address expression>. */
t = build2 (MODIFY_EXPR, void_type_node, mf_base,
convert (mf_uintptr_type, unshare_expr (base)));
SET_EXPR_LOCUS (t, locus);
gimplify_to_stmt_list (&t);
head = tsi_start (t);
tsi = tsi_last (t);
/* Build: __mf_limit = (uintptr_t) <limit address expression>. */
t = build2 (MODIFY_EXPR, void_type_node, mf_limit,
convert (mf_uintptr_type, unshare_expr (limit)));
SET_EXPR_LOCUS (t, locus);
gimplify_to_stmt_list (&t);
tsi_link_after (&tsi, t, TSI_CONTINUE_LINKING);
/* Build: __mf_elem = &__mf_lookup_cache [(__mf_base >> __mf_shift)
& __mf_mask]. */
t = build2 (RSHIFT_EXPR, mf_uintptr_type, mf_base,
(flag_mudflap_threads ? mf_cache_shift_decl : mf_cache_shift_decl_l));
t = build2 (BIT_AND_EXPR, mf_uintptr_type, t,
(flag_mudflap_threads ? mf_cache_mask_decl : mf_cache_mask_decl_l));
t = build4 (ARRAY_REF,
TREE_TYPE (TREE_TYPE (mf_cache_array_decl)),
mf_cache_array_decl, t, NULL_TREE, NULL_TREE);
t = build1 (ADDR_EXPR, mf_cache_structptr_type, t);
t = build2 (MODIFY_EXPR, void_type_node, mf_elem, t);
SET_EXPR_LOCUS (t, locus);
gimplify_to_stmt_list (&t);
tsi_link_after (&tsi, t, TSI_CONTINUE_LINKING);
/* Quick validity check.
if (__mf_elem->low > __mf_base
|| (__mf_elem_high < __mf_limit))
{
__mf_check ();
... and only if single-threaded:
__mf_lookup_shift_1 = f...;
__mf_lookup_mask_l = ...;
}
It is expected that this body of code is rarely executed so we mark
the edge to the THEN clause of the conditional jump as unlikely. */
/* Construct t <-- '__mf_elem->low > __mf_base'. */
t = build3 (COMPONENT_REF, mf_uintptr_type,
build1 (INDIRECT_REF, mf_cache_struct_type, mf_elem),
TYPE_FIELDS (mf_cache_struct_type), NULL_TREE);
t = build2 (GT_EXPR, boolean_type_node, t, mf_base);
/* Construct '__mf_elem->high < __mf_limit'.
First build:
1) u <-- '__mf_elem->high'
2) v <-- '__mf_limit'.
Then build 'u <-- (u < v). */
u = build3 (COMPONENT_REF, mf_uintptr_type,
build1 (INDIRECT_REF, mf_cache_struct_type, mf_elem),
TREE_CHAIN (TYPE_FIELDS (mf_cache_struct_type)), NULL_TREE);
v = mf_limit;
u = build2 (LT_EXPR, boolean_type_node, u, v);
/* Build the composed conditional: t <-- 't || u'. Then store the
result of the evaluation of 't' in a temporary variable which we
can use as the condition for the conditional jump. */
t = build2 (TRUTH_OR_EXPR, boolean_type_node, t, u);
cond = create_tmp_var (boolean_type_node, "__mf_unlikely_cond");
t = build2 (MODIFY_EXPR, boolean_type_node, cond, t);
gimplify_to_stmt_list (&t);
tsi_link_after (&tsi, t, TSI_CONTINUE_LINKING);
/* Build the conditional jump. 'cond' is just a temporary so we can
simply build a void COND_EXPR. We do need labels in both arms though. */
t = build3 (COND_EXPR, void_type_node, cond,
build1 (GOTO_EXPR, void_type_node, tree_block_label (then_bb)),
build1 (GOTO_EXPR, void_type_node, tree_block_label (join_bb)));
SET_EXPR_LOCUS (t, locus);
tsi_link_after (&tsi, t, TSI_CONTINUE_LINKING);
/* At this point, after so much hard work, we have only constructed
the conditional jump,
if (__mf_elem->low > __mf_base
|| (__mf_elem_high < __mf_limit))
The lowered GIMPLE tree representing this code is in the statement
list starting at 'head'.
We can insert this now in the current basic block, i.e. the one that
the statement we're instrumenting was originally in. */
bsi = bsi_last (cond_bb);
for (tsi = head; ! tsi_end_p (tsi); tsi_next (&tsi))
bsi_insert_after (&bsi, tsi_stmt (tsi), BSI_CONTINUE_LINKING);
/* Now build up the body of the cache-miss handling:
__mf_check();
refresh *_l vars.
This is the body of the conditional. */
u = tree_cons (NULL_TREE,
mf_file_function_line_tree (locus == NULL ? UNKNOWN_LOCATION
: *locus),
NULL_TREE);
u = tree_cons (NULL_TREE, dirflag, u);
/* NB: we pass the overall [base..limit] range to mf_check. */
u = tree_cons (NULL_TREE,
fold_build2 (PLUS_EXPR, integer_type_node,
fold_build2 (MINUS_EXPR, mf_uintptr_type, mf_limit, mf_base),
integer_one_node),
u);
u = tree_cons (NULL_TREE, mf_base, u);
t = build_function_call_expr (mf_check_fndecl, u);
gimplify_to_stmt_list (&t);
head = tsi_start (t);
tsi = tsi_last (t);
if (! flag_mudflap_threads)
{
t = build2 (MODIFY_EXPR, void_type_node,
mf_cache_shift_decl_l, mf_cache_shift_decl);
tsi_link_after (&tsi, t, TSI_CONTINUE_LINKING);
t = build2 (MODIFY_EXPR, void_type_node,
mf_cache_mask_decl_l, mf_cache_mask_decl);
tsi_link_after (&tsi, t, TSI_CONTINUE_LINKING);
}
/* Insert the check code in the THEN block. */
bsi = bsi_start (then_bb);
for (tsi = head; ! tsi_end_p (tsi); tsi_next (&tsi))
bsi_insert_after (&bsi, tsi_stmt (tsi), BSI_CONTINUE_LINKING);
*instr_bsi = bsi_start (join_bb);
bsi_next (instr_bsi);
}
