/* This file is part of the Intel(R) Cilk(TM) Plus support
This file contains routines to handle Array Notation expression
handling routines in the C Compiler.
- Copyright (C) 2013-2014 Free Software Foundation, Inc.
+ Copyright (C) 2013-2017 Free Software Foundation, Inc.
Contributed by Balaji V. Iyer <balaji.v.iyer@intel.com>,
Intel Corporation.
An array notation expression has 4 major components:
1. The array name
2. Start Index
- 3. Number of elements we need to acess (we call it length)
+ 3. Number of elements we need to access (we call it length)
4. Stride
For example, A[0:5:2], implies that we are accessing A[0], A[2], A[4],
#include "config.h"
#include "system.h"
#include "coretypes.h"
-#include "tree.h"
#include "c-tree.h"
#include "gimple-expr.h"
#include "tree-iterator.h"
-#include "opts.h"
-#include "c-family/c-common.h"
/* If *VALUE is not of type INTEGER_CST, PARM_DECL or VAR_DECL, then map it
to a variable and then set *VALUE to the new variable. */
tree var, new_exp;
if (TREE_CODE (*value) != INTEGER_CST
&& TREE_CODE (*value) != PARM_DECL
- && TREE_CODE (*value) != VAR_DECL)
+ && !VAR_P (*value))
{
var = build_decl (loc, VAR_DECL, NULL_TREE, integer_type_node);
new_exp = build_modify_expr (loc, var, TREE_TYPE (var), NOP_EXPR, loc,
{
tree var = (*node)[ii].var;
tree length = an_info[0][ii].length;
- (*node)[ii].incr = build_unary_op (loc, POSTINCREMENT_EXPR, var, 0);
+ (*node)[ii].incr = build_unary_op (loc, POSTINCREMENT_EXPR, var, false);
(*node)[ii].cmp = build2 (LT_EXPR, boolean_type_node, var, length);
}
}
location_t location = UNKNOWN_LOCATION;
tree loop_with_init = alloc_stmt_list ();
vec<vec<an_parts> > an_info = vNULL;
- vec<an_loop_parts> an_loop_info = vNULL;
+ auto_vec<an_loop_parts> an_loop_info;
enum built_in_function an_type =
is_cilkplus_reduce_builtin (CALL_EXPR_FN (an_builtin_fn));
if (an_type == BUILT_IN_NONE)
array_ind_value = build_decl (location, VAR_DECL, NULL_TREE,
TREE_TYPE (func_parm));
array_op0 = (*array_operand)[0];
- if (TREE_CODE (array_op0) == INDIRECT_REF)
+ if (INDIRECT_REF_P (array_op0))
array_op0 = TREE_OPERAND (array_op0, 0);
switch (an_type)
{
new_yes_expr = build_modify_expr
(location, array_ind_value, TREE_TYPE (array_ind_value),
NOP_EXPR,
- location, func_parm, TREE_OPERAND (array_op0, 1));
+ location, func_parm, TREE_TYPE (TREE_OPERAND (array_op0, 1)));
}
new_yes_list = alloc_stmt_list ();
append_to_statement_list (new_yes_ind, &new_yes_list);
new_yes_expr = build_modify_expr
(location, array_ind_value, TREE_TYPE (array_ind_value),
NOP_EXPR,
- location, func_parm, TREE_OPERAND (array_op0, 1));
+ location, func_parm, TREE_TYPE (TREE_OPERAND (array_op0, 1)));
}
new_yes_list = alloc_stmt_list ();
append_to_statement_list (new_yes_ind, &new_yes_list);
}
append_to_statement_list_force (body, &loop_with_init);
- an_info.release ();
- an_loop_info.release ();
+ release_vec_vec (an_info);
return loop_with_init;
}
tree array_expr_lhs = NULL_TREE, array_expr_rhs = NULL_TREE;
tree array_expr = NULL_TREE;
tree an_init = NULL_TREE;
- vec<tree> cond_expr = vNULL;
+ auto_vec<tree> cond_expr;
tree body, loop_with_init = alloc_stmt_list();
tree scalar_mods = NULL_TREE;
vec<tree, va_gc> *rhs_array_operand = NULL, *lhs_array_operand = NULL;
tree new_modify_expr, new_var = NULL_TREE, builtin_loop = NULL_TREE;
size_t rhs_list_size = 0, lhs_list_size = 0;
vec<vec<an_parts> > lhs_an_info = vNULL, rhs_an_info = vNULL;
- vec<an_loop_parts> lhs_an_loop_info = vNULL, rhs_an_loop_info = vNULL;
+ auto_vec<an_loop_parts> lhs_an_loop_info, rhs_an_loop_info;
/* If either of this is true, an error message must have been send out
already. Not necessary to send out multiple error messages. */
&& length_mismatch_in_expr_p (EXPR_LOCATION (rhs), rhs_an_info)))
{
pop_stmt_list (an_init);
- return error_mark_node;
+ goto error;
}
if (lhs_list_size > 0 && rhs_list_size > 0 && lhs_rank > 0 && rhs_rank > 0
&& TREE_CODE (lhs_an_info[0][0].length) == INTEGER_CST
{
error_at (location, "length mismatch between LHS and RHS");
pop_stmt_list (an_init);
- return error_mark_node;
+ goto error;
}
}
for (ii = 0; ii < lhs_rank; ii++)
rhs_an_loop_info, rhs_rank,
rhs);
if (!rhs_array_operand)
- return error_mark_node;
+ goto error;
replace_array_notations (&rhs, true, rhs_list, rhs_array_operand);
}
else if (rhs_list_size > 0)
lhs_an_loop_info, lhs_rank,
lhs);
if (!rhs_array_operand)
- return error_mark_node;
+ goto error;
replace_array_notations (&rhs, true, rhs_list, rhs_array_operand);
}
array_expr_lhs = lhs;
}
append_to_statement_list_force (body, &loop_with_init);
- lhs_an_info.release ();
- lhs_an_loop_info.release ();
- if (rhs_rank)
- {
- rhs_an_info.release ();
- rhs_an_loop_info.release ();
- }
- cond_expr.release ();
+ release_vec_vec (lhs_an_info);
+ release_vec_vec (rhs_an_info);
return loop_with_init;
+
+error:
+ release_vec_vec (lhs_an_info);
+ release_vec_vec (rhs_an_info);
+
+ return error_mark_node;
}
/* Helper function for fix_conditional_array_notations. Encloses the
location_t location = EXPR_LOCATION (stmt);
tree body = NULL_TREE, loop_with_init = alloc_stmt_list ();
vec<vec<an_parts> > an_info = vNULL;
- vec<an_loop_parts> an_loop_info = vNULL;
+ auto_vec<an_loop_parts> an_loop_info;
if (TREE_CODE (stmt) == COND_EXPR)
cond = COND_EXPR_COND (stmt);
body = pop_stmt_list (new_loop);
}
append_to_statement_list_force (body, &loop_with_init);
-
- an_loop_info.release ();
- an_info.release ();
+ release_vec_vec (an_info);
return loop_with_init;
}
tree loop_init;
tree body, loop_with_init = alloc_stmt_list ();
vec<vec<an_parts> > an_info = vNULL;
- vec<an_loop_parts> an_loop_info = vNULL;
+ auto_vec<an_loop_parts> an_loop_info;
if (!find_rank (location, arg.value, arg.value, false, &rank))
{
arg = default_function_array_read_conversion (location, arg);
if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
- arg.value = build_unary_op (location, code, arg.value, 0);
+ arg.value = build_unary_op (location, code, arg.value, false);
else if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR)
arg = parser_build_unary_op (location, code, arg);
}
append_to_statement_list_force (body, &loop_with_init);
arg.value = loop_with_init;
- an_info.release ();
- an_loop_info.release ();
+ release_vec_vec (an_info);
return arg;
}
tree body, loop_with_init = alloc_stmt_list ();
location_t location = UNKNOWN_LOCATION;
vec<vec<an_parts> > an_info = vNULL;
- vec<an_loop_parts> an_loop_info = vNULL;
+ auto_vec<an_loop_parts> an_loop_info;
if (TREE_CODE (arg) == CALL_EXPR
&& is_cilkplus_reduce_builtin (CALL_EXPR_FN (arg)))
body = pop_stmt_list (new_loop);
}
append_to_statement_list_force (body, &loop_with_init);
- an_loop_info.release ();
- an_info.release ();
+ release_vec_vec (an_info);
return loop_with_init;
}