1 /* This file is part of the Intel(R) Cilk(TM) Plus support
2 It contains routines to handle Array Notation expression
3 handling routines in the C++ Compiler.
4 Copyright (C) 2013-2015 Free Software Foundation, Inc.
5 Contributed by Balaji V. Iyer <balaji.v.iyer@intel.com>,
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify it
11 under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3, or (at your option)
15 GCC is distributed in the hope that it will be useful, but
16 WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
24 /* The Array Notation Transformation Technique:
26 An array notation expression has 4 major components:
29 3. Number of elements we need to access (we call it length)
32 So, if we have something like A[0:5:2], we are accessing A[0], A[2], A[4],
33 A[6] and A[8]. The user is responsible to make sure the access length does
34 not step outside the array's size.
36 In this section, I highlight the overall method on how array notations are
37 broken up into C/C++ code. Almost all the functions follows this step:
39 Let's say the user has used the array notation in a statement like this:
41 A[St1:Ln:Str1] = B[St2:Ln:Str2] + <NON ARRAY_NOT STMT>
43 where St{1,2} = Starting index, Ln = Number of elements we need to access,
44 and Str{1,2} = the stride.
45 Note: The length of both the array notation expressions must be the same.
47 The above expression is broken into the following:
49 for (Tmp_Var = 0; Tmp_Var < Ln; Tmp_Var++)
50 A[St1 + Tmp_Var * Str1] = B[St1 + Tmp_Var * Str2] + <NON_ARRAY_NOT_STMT>;
55 #include "coretypes.h"
59 #include "double-int.h"
68 #include "c-family/c-common.h"
69 #include "diagnostic.h"
70 #include "tree-iterator.h"
73 /* Creates a FOR_STMT with INIT, COND, INCR and BODY as the initializer,
74 condition, increment expression and the loop-body, respectively. */
77 create_an_loop (tree init
, tree cond
, tree incr
, tree body
)
81 finish_expr_stmt (init
);
82 for_stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
83 finish_for_init_stmt (for_stmt
);
84 finish_for_cond (cond
, for_stmt
, false);
85 finish_for_expr (incr
, for_stmt
);
86 finish_expr_stmt (body
);
87 finish_for_stmt (for_stmt
);
90 /* If *VALUE is not a constant integer, then this function replaces it with
91 a variable to make it loop invariant for array notations. */
94 make_triplet_val_inv (tree
*value
)
96 if (TREE_CODE (*value
) != INTEGER_CST
97 && TREE_CODE (*value
) != PARM_DECL
98 && TREE_CODE (*value
) != VAR_DECL
)
99 *value
= get_temp_regvar (ptrdiff_type_node
, *value
);
102 /* Returns a vector of size RANK that contains an ARRAY_REF. This vector is
103 created using array notation-triplet information stored in AN_INFO. The
104 induction var is taken from AN_LOOP_INFO.
106 For example: For an array notation A[5:10:2], the vector start will be
107 of size 1 holding '5', stride of same size as start but holding the value of
108 as 2, and is_vector as true. Let's assume VAR is 'x'
109 This function returns a vector of size 1 with the following data:
113 static vec
<tree
, va_gc
> *
114 create_array_refs (location_t loc
, vec
<vec
<an_parts
> > an_info
,
115 vec
<an_loop_parts
> an_loop_info
, size_t size
, size_t rank
)
117 tree ind_mult
, ind_incr
;
118 vec
<tree
, va_gc
> *array_operand
= NULL
;
120 for (size_t ii
= 0; ii
< size
; ii
++)
121 if (an_info
[ii
][0].is_vector
)
123 tree array_opr
= an_info
[ii
][rank
- 1].value
;
124 for (int s_jj
= rank
-1; s_jj
>= 0; s_jj
--)
126 tree start
= cp_fold_convert (ptrdiff_type_node
,
127 an_info
[ii
][s_jj
].start
);
128 tree stride
= cp_fold_convert (ptrdiff_type_node
,
129 an_info
[ii
][s_jj
].stride
);
130 tree var
= cp_fold_convert (ptrdiff_type_node
,
131 an_loop_info
[s_jj
].var
);
133 ind_mult
= build2 (MULT_EXPR
, TREE_TYPE (var
), var
, stride
);
134 ind_incr
= build2 (PLUS_EXPR
, TREE_TYPE (var
), start
, ind_mult
);
135 /* Array [ start_index + (induction_var * stride)] */
136 array_opr
= grok_array_decl (loc
, array_opr
, ind_incr
, false);
138 vec_safe_push (array_operand
, array_opr
);
141 vec_safe_push (array_operand
, integer_one_node
);
142 return array_operand
;
145 /* Populates the INCR and CMP fields in *NODE with the increment
146 (of type POSTINCREMENT) and comparison (of TYPE LT_EXPR) expressions, using
147 data from AN_INFO. */
150 create_cmp_incr (location_t loc
, vec
<an_loop_parts
> *node
, size_t rank
,
151 vec
<vec
<an_parts
> > an_info
, tsubst_flags_t complain
)
153 for (size_t ii
= 0; ii
< rank
; ii
++)
155 (*node
)[ii
].incr
= build_x_unary_op (loc
, POSTINCREMENT_EXPR
,
156 (*node
)[ii
].var
, complain
);
157 (*node
)[ii
].cmp
= build_x_binary_op (loc
, LT_EXPR
, (*node
)[ii
].var
,
158 TREE_CODE ((*node
)[ii
].var
),
159 an_info
[0][ii
].length
,
160 TREE_CODE (an_info
[0][ii
].length
),
165 /* Replaces all the scalar expressions in *NODE. Returns a STATEMENT LIST that
166 holds the NODE along with the variables that hold the results of the
167 invariant expressions. */
170 replace_invariant_exprs (tree
*node
)
173 tree node_list
= NULL_TREE
;
174 tree t
= NULL_TREE
, new_var
= NULL_TREE
;
175 struct inv_list data
;
177 data
.list_values
= NULL
;
178 data
.replacement
= NULL
;
179 data
.additional_tcodes
= NULL
;
180 cp_walk_tree (node
, find_inv_trees
, (void *) &data
, NULL
);
182 if (vec_safe_length (data
.list_values
))
184 node_list
= push_stmt_list ();
185 for (ix
= 0; vec_safe_iterate (data
.list_values
, ix
, &t
); ix
++)
187 /* Sometimes, when comma_expr has a function call in it, it will
188 typecast it to void. Find_inv_trees finds those nodes and so
189 if it void type, then don't bother creating a new var to hold
191 if (VOID_TYPE_P (TREE_TYPE (t
)))
193 finish_expr_stmt (t
);
197 new_var
= get_temp_regvar (TREE_TYPE (t
), t
);
198 vec_safe_push (data
.replacement
, new_var
);
200 cp_walk_tree (node
, replace_inv_trees
, (void *) &data
, NULL
);
201 node_list
= pop_stmt_list (node_list
);
206 /* Replace array notation's built-in function passed in AN_BUILTIN_FN with
207 the appropriate loop and computation (all stored in variable LOOP of type
208 tree node). The output of the function function is always a scalar and that
209 result is returned in *NEW_VAR. *NEW_VAR is NULL_TREE if the function is
210 __sec_reduce_mutating. */
213 expand_sec_reduce_builtin (tree an_builtin_fn
, tree
*new_var
)
215 tree new_var_type
= NULL_TREE
, func_parm
, new_yes_expr
, new_no_expr
;
216 tree array_ind_value
= NULL_TREE
, new_no_ind
, new_yes_ind
, new_no_list
;
217 tree new_yes_list
, new_cond_expr
, new_expr
= NULL_TREE
;
218 vec
<tree
, va_gc
> *array_list
= NULL
, *array_operand
= NULL
;
219 size_t list_size
= 0, rank
= 0, ii
= 0;
220 tree body
, an_init
, loop_with_init
= alloc_stmt_list ();
221 tree array_op0
, comp_node
= NULL_TREE
;
222 tree call_fn
= NULL_TREE
, identity_value
= NULL_TREE
;
223 tree init
= NULL_TREE
, cond_init
= NULL_TREE
;
224 enum tree_code code
= NOP_EXPR
;
225 location_t location
= UNKNOWN_LOCATION
;
226 vec
<vec
<an_parts
> > an_info
= vNULL
;
227 vec
<an_loop_parts
> an_loop_info
= vNULL
;
228 enum built_in_function an_type
=
229 is_cilkplus_reduce_builtin (CALL_EXPR_FN (an_builtin_fn
));
230 vec
<tree
, va_gc
> *func_args
;
232 if (an_type
== BUILT_IN_NONE
)
235 if (an_type
!= BUILT_IN_CILKPLUS_SEC_REDUCE
236 && an_type
!= BUILT_IN_CILKPLUS_SEC_REDUCE_MUTATING
)
237 func_parm
= CALL_EXPR_ARG (an_builtin_fn
, 0);
240 call_fn
= CALL_EXPR_ARG (an_builtin_fn
, 2);
242 /* We need to do this because we are "faking" the builtin function types,
243 so the compiler does a bunch of typecasts and this will get rid of
245 STRIP_NOPS (call_fn
);
246 if (TREE_CODE (call_fn
) != OVERLOAD
247 && TREE_CODE (call_fn
) != FUNCTION_DECL
)
248 call_fn
= TREE_OPERAND (call_fn
, 0);
249 identity_value
= CALL_EXPR_ARG (an_builtin_fn
, 0);
250 func_parm
= CALL_EXPR_ARG (an_builtin_fn
, 1);
251 STRIP_NOPS (identity_value
);
253 STRIP_NOPS (func_parm
);
255 location
= EXPR_LOCATION (an_builtin_fn
);
257 /* Note about using find_rank (): If find_rank returns false, then it must
258 have already reported an error, thus we just return an error_mark_node
259 without any doing any error emission. */
260 if (!find_rank (location
, an_builtin_fn
, an_builtin_fn
, true, &rank
))
261 return error_mark_node
;
264 error_at (location
, "Invalid builtin arguments");
265 return error_mark_node
;
268 && (an_type
== BUILT_IN_CILKPLUS_SEC_REDUCE_MAX_IND
269 || an_type
== BUILT_IN_CILKPLUS_SEC_REDUCE_MIN_IND
))
271 error_at (location
, "__sec_reduce_min_ind or __sec_reduce_max_ind cannot "
272 "have arrays with dimension greater than 1");
273 return error_mark_node
;
276 extract_array_notation_exprs (func_parm
, true, &array_list
);
277 list_size
= vec_safe_length (array_list
);
280 case BUILT_IN_CILKPLUS_SEC_REDUCE_ADD
:
281 case BUILT_IN_CILKPLUS_SEC_REDUCE_MUL
:
282 case BUILT_IN_CILKPLUS_SEC_REDUCE_MAX
:
283 case BUILT_IN_CILKPLUS_SEC_REDUCE_MIN
:
284 new_var_type
= TREE_TYPE ((*array_list
)[0]);
286 case BUILT_IN_CILKPLUS_SEC_REDUCE_ALL_ZERO
:
287 case BUILT_IN_CILKPLUS_SEC_REDUCE_ANY_ZERO
:
288 case BUILT_IN_CILKPLUS_SEC_REDUCE_ANY_NONZERO
:
289 case BUILT_IN_CILKPLUS_SEC_REDUCE_ALL_NONZERO
:
290 new_var_type
= boolean_type_node
;
292 case BUILT_IN_CILKPLUS_SEC_REDUCE_MAX_IND
:
293 case BUILT_IN_CILKPLUS_SEC_REDUCE_MIN_IND
:
294 new_var_type
= size_type_node
;
296 case BUILT_IN_CILKPLUS_SEC_REDUCE
:
297 if (call_fn
&& identity_value
)
298 new_var_type
= TREE_TYPE ((*array_list
)[0]);
300 case BUILT_IN_CILKPLUS_SEC_REDUCE_MUTATING
:
301 new_var_type
= NULL_TREE
;
307 if (new_var_type
&& TREE_CODE (new_var_type
) == ARRAY_TYPE
)
308 new_var_type
= TREE_TYPE (new_var_type
);
309 an_loop_info
.safe_grow_cleared (rank
);
311 an_init
= push_stmt_list ();
313 /* Assign the array notation components to variable so that they can satisfy
314 the exec-once rule. */
315 for (ii
= 0; ii
< list_size
; ii
++)
316 if (TREE_CODE ((*array_list
)[ii
]) == ARRAY_NOTATION_REF
)
318 tree anode
= (*array_list
)[ii
];
319 make_triplet_val_inv (&ARRAY_NOTATION_START (anode
));
320 make_triplet_val_inv (&ARRAY_NOTATION_LENGTH (anode
));
321 make_triplet_val_inv (&ARRAY_NOTATION_STRIDE (anode
));
323 cilkplus_extract_an_triplets (array_list
, list_size
, rank
, &an_info
);
324 for (ii
= 0; ii
< rank
; ii
++)
326 tree typ
= ptrdiff_type_node
;
328 /* In this place, we are using get_temp_regvar instead of
329 create_temporary_var if an_type is SEC_REDUCE_MAX/MIN_IND because
330 the array_ind_value depends on this value being initalized to 0. */
331 if (an_type
== BUILT_IN_CILKPLUS_SEC_REDUCE_MAX_IND
332 || an_type
== BUILT_IN_CILKPLUS_SEC_REDUCE_MIN_IND
)
333 an_loop_info
[ii
].var
= get_temp_regvar (typ
, build_zero_cst (typ
));
336 an_loop_info
[ii
].var
= create_temporary_var (typ
);
337 add_decl_expr (an_loop_info
[ii
].var
);
339 an_loop_info
[ii
].ind_init
=
340 build_x_modify_expr (location
, an_loop_info
[ii
].var
, INIT_EXPR
,
341 build_zero_cst (typ
), tf_warning_or_error
);
343 array_operand
= create_array_refs (location
, an_info
, an_loop_info
,
345 replace_array_notations (&func_parm
, true, array_list
, array_operand
);
347 if (!TREE_TYPE (func_parm
))
348 TREE_TYPE (func_parm
) = TREE_TYPE ((*array_list
)[0]);
350 create_cmp_incr (location
, &an_loop_info
, rank
, an_info
, tf_warning_or_error
);
351 if (an_type
== BUILT_IN_CILKPLUS_SEC_REDUCE_MAX_IND
352 || an_type
== BUILT_IN_CILKPLUS_SEC_REDUCE_MIN_IND
)
353 array_ind_value
= get_temp_regvar (TREE_TYPE (func_parm
), func_parm
);
355 array_op0
= (*array_operand
)[0];
356 if (TREE_CODE (array_op0
) == INDIRECT_REF
)
357 array_op0
= TREE_OPERAND (array_op0
, 0);
360 case BUILT_IN_CILKPLUS_SEC_REDUCE_ADD
:
362 init
= build_zero_cst (new_var_type
);
364 case BUILT_IN_CILKPLUS_SEC_REDUCE_MUL
:
366 init
= build_one_cst (new_var_type
);
368 case BUILT_IN_CILKPLUS_SEC_REDUCE_ANY_ZERO
:
369 case BUILT_IN_CILKPLUS_SEC_REDUCE_ANY_NONZERO
:
370 code
= ((an_type
== BUILT_IN_CILKPLUS_SEC_REDUCE_ANY_ZERO
) ? EQ_EXPR
372 init
= build_zero_cst (new_var_type
);
373 cond_init
= build_one_cst (new_var_type
);
374 comp_node
= build_zero_cst (TREE_TYPE (func_parm
));
376 case BUILT_IN_CILKPLUS_SEC_REDUCE_ALL_ZERO
:
377 case BUILT_IN_CILKPLUS_SEC_REDUCE_ALL_NONZERO
:
378 code
= ((an_type
== BUILT_IN_CILKPLUS_SEC_REDUCE_ALL_ZERO
) ? NE_EXPR
380 init
= build_one_cst (new_var_type
);
381 cond_init
= build_zero_cst (new_var_type
);
382 comp_node
= build_zero_cst (TREE_TYPE (func_parm
));
384 case BUILT_IN_CILKPLUS_SEC_REDUCE_MAX
:
386 init
= (TYPE_MIN_VALUE (new_var_type
) ? TYPE_MIN_VALUE (new_var_type
)
389 case BUILT_IN_CILKPLUS_SEC_REDUCE_MIN
:
391 init
= (TYPE_MAX_VALUE (new_var_type
) ? TYPE_MAX_VALUE (new_var_type
)
394 case BUILT_IN_CILKPLUS_SEC_REDUCE_MIN_IND
:
395 case BUILT_IN_CILKPLUS_SEC_REDUCE_MAX_IND
:
396 code
= (an_type
== BUILT_IN_CILKPLUS_SEC_REDUCE_MAX_IND
? LE_EXPR
398 init
= an_loop_info
[0].var
;
400 case BUILT_IN_CILKPLUS_SEC_REDUCE
:
401 init
= identity_value
;
403 case BUILT_IN_CILKPLUS_SEC_REDUCE_MUTATING
:
410 if (an_type
!= BUILT_IN_CILKPLUS_SEC_REDUCE_MUTATING
)
411 *new_var
= get_temp_regvar (new_var_type
, init
);
413 *new_var
= NULL_TREE
;
417 case BUILT_IN_CILKPLUS_SEC_REDUCE_ADD
:
418 case BUILT_IN_CILKPLUS_SEC_REDUCE_MUL
:
419 new_expr
= build_x_modify_expr (location
, *new_var
, code
, func_parm
,
420 tf_warning_or_error
);
422 case BUILT_IN_CILKPLUS_SEC_REDUCE_ALL_ZERO
:
423 case BUILT_IN_CILKPLUS_SEC_REDUCE_ALL_NONZERO
:
424 case BUILT_IN_CILKPLUS_SEC_REDUCE_ANY_ZERO
:
425 case BUILT_IN_CILKPLUS_SEC_REDUCE_ANY_NONZERO
:
426 /* In all these cases, assume the false case is true and as soon as
427 we find a true case, set the true flag on and latch it in. */
428 new_yes_expr
= build_x_modify_expr (location
, *new_var
, NOP_EXPR
,
429 cond_init
, tf_warning_or_error
);
430 new_no_expr
= build_x_modify_expr (location
, *new_var
, NOP_EXPR
,
431 *new_var
, tf_warning_or_error
);
432 new_cond_expr
= build_x_binary_op
433 (location
, code
, func_parm
, TREE_CODE (func_parm
), comp_node
,
434 TREE_CODE (comp_node
), NULL
, tf_warning_or_error
);
435 new_expr
= build_x_conditional_expr (location
, new_cond_expr
,
436 new_yes_expr
, new_no_expr
,
437 tf_warning_or_error
);
439 case BUILT_IN_CILKPLUS_SEC_REDUCE_MAX
:
440 case BUILT_IN_CILKPLUS_SEC_REDUCE_MIN
:
441 new_cond_expr
= build_x_binary_op
442 (location
, code
, *new_var
, TREE_CODE (*new_var
), func_parm
,
443 TREE_CODE (func_parm
), NULL
, tf_warning_or_error
);
444 new_expr
= build_x_modify_expr (location
, *new_var
, NOP_EXPR
, func_parm
,
445 tf_warning_or_error
);
447 case BUILT_IN_CILKPLUS_SEC_REDUCE_MAX_IND
:
448 case BUILT_IN_CILKPLUS_SEC_REDUCE_MIN_IND
:
449 new_yes_expr
= build_x_modify_expr (location
, array_ind_value
, NOP_EXPR
,
450 func_parm
, tf_warning_or_error
);
451 new_no_expr
= build_x_modify_expr (location
, array_ind_value
, NOP_EXPR
,
452 array_ind_value
, tf_warning_or_error
);
454 new_yes_ind
= build_x_modify_expr (location
, *new_var
, NOP_EXPR
,
456 tf_warning_or_error
);
458 new_yes_ind
= build_x_modify_expr (location
, *new_var
, NOP_EXPR
,
459 TREE_OPERAND (array_op0
, 1),
460 tf_warning_or_error
);
461 new_no_ind
= build_x_modify_expr (location
, *new_var
, NOP_EXPR
, *new_var
,
462 tf_warning_or_error
);
463 new_yes_list
= alloc_stmt_list ();
464 append_to_statement_list (new_yes_ind
, &new_yes_list
);
465 append_to_statement_list (new_yes_expr
, &new_yes_list
);
467 new_no_list
= alloc_stmt_list ();
468 append_to_statement_list (new_no_ind
, &new_no_list
);
469 append_to_statement_list (new_no_expr
, &new_no_list
);
471 new_cond_expr
= build_x_binary_op (location
, code
, array_ind_value
,
472 TREE_CODE (array_ind_value
), func_parm
,
473 TREE_CODE (func_parm
), NULL
,
474 tf_warning_or_error
);
475 new_expr
= build_x_conditional_expr (location
, new_cond_expr
,
476 new_yes_list
, new_no_list
,
477 tf_warning_or_error
);
479 case BUILT_IN_CILKPLUS_SEC_REDUCE
:
480 case BUILT_IN_CILKPLUS_SEC_REDUCE_MUTATING
:
481 func_args
= make_tree_vector ();
482 if (an_type
== BUILT_IN_CILKPLUS_SEC_REDUCE
)
483 vec_safe_push (func_args
, *new_var
);
485 vec_safe_push (func_args
, identity_value
);
486 vec_safe_push (func_args
, func_parm
);
488 new_expr
= finish_call_expr (call_fn
, &func_args
, false, true,
489 tf_warning_or_error
);
490 if (an_type
== BUILT_IN_CILKPLUS_SEC_REDUCE
)
491 new_expr
= build_x_modify_expr (location
, *new_var
, NOP_EXPR
, new_expr
,
492 tf_warning_or_error
);
493 release_tree_vector (func_args
);
498 an_init
= pop_stmt_list (an_init
);
499 append_to_statement_list (an_init
, &loop_with_init
);
502 for (ii
= 0; ii
< rank
; ii
++)
504 tree new_loop
= push_stmt_list ();
505 create_an_loop (an_loop_info
[ii
].ind_init
, an_loop_info
[ii
].cmp
,
506 an_loop_info
[ii
].incr
, body
);
507 body
= pop_stmt_list (new_loop
);
509 append_to_statement_list (body
, &loop_with_init
);
512 an_loop_info
.release ();
514 return loop_with_init
;
517 /* Returns a loop with ARRAY_REF inside it with an appropriate modify expr.
518 The LHS and/or RHS will be array notation expressions that have a
519 MODIFYCODE. The location of the variable is specified by LOCATION. */
522 expand_an_in_modify_expr (location_t location
, tree lhs
,
523 enum tree_code modifycode
, tree rhs
,
524 tsubst_flags_t complain
)
526 tree array_expr_lhs
= NULL_TREE
, array_expr_rhs
= NULL_TREE
;
527 tree array_expr
= NULL_TREE
;
528 tree body
= NULL_TREE
;
529 vec
<tree
> cond_expr
= vNULL
;
530 vec
<tree
, va_gc
> *lhs_array_operand
= NULL
, *rhs_array_operand
= NULL
;
531 size_t lhs_rank
= 0, rhs_rank
= 0, ii
= 0;
532 vec
<tree
, va_gc
> *rhs_list
= NULL
, *lhs_list
= NULL
;
533 size_t rhs_list_size
= 0, lhs_list_size
= 0;
534 tree new_modify_expr
, new_var
= NULL_TREE
, builtin_loop
, scalar_mods
;
535 bool found_builtin_fn
= false;
536 tree an_init
, loop_with_init
= alloc_stmt_list ();
537 vec
<vec
<an_parts
> > lhs_an_info
= vNULL
, rhs_an_info
= vNULL
;
538 vec
<an_loop_parts
> lhs_an_loop_info
= vNULL
, rhs_an_loop_info
= vNULL
;
540 if (!find_rank (location
, rhs
, rhs
, false, &rhs_rank
))
541 return error_mark_node
;
542 extract_array_notation_exprs (rhs
, false, &rhs_list
);
543 rhs_list_size
= vec_safe_length (rhs_list
);
544 an_init
= push_stmt_list ();
547 scalar_mods
= replace_invariant_exprs (&rhs
);
549 finish_expr_stmt (scalar_mods
);
551 for (ii
= 0; ii
< rhs_list_size
; ii
++)
553 tree rhs_node
= (*rhs_list
)[ii
];
554 if (TREE_CODE (rhs_node
) == CALL_EXPR
)
556 builtin_loop
= expand_sec_reduce_builtin (rhs_node
, &new_var
);
557 if (builtin_loop
== error_mark_node
)
558 return error_mark_node
;
559 else if (builtin_loop
)
561 finish_expr_stmt (builtin_loop
);
562 found_builtin_fn
= true;
565 vec
<tree
, va_gc
> *rhs_sub_list
= NULL
, *new_var_list
= NULL
;
566 vec_safe_push (rhs_sub_list
, rhs_node
);
567 vec_safe_push (new_var_list
, new_var
);
568 replace_array_notations (&rhs
, false, rhs_sub_list
,
576 if (!find_rank (location
, lhs
, lhs
, true, &lhs_rank
)
577 || !find_rank (location
, rhs
, rhs
, true, &rhs_rank
))
579 pop_stmt_list (an_init
);
580 return error_mark_node
;
583 /* If both are scalar, then the only reason why we will get this far is if
584 there is some array notations inside it and was using a builtin array
585 notation functions. If so, we have already broken those guys up and now
586 a simple build_x_modify_expr would do. */
587 if (lhs_rank
== 0 && rhs_rank
== 0)
589 if (found_builtin_fn
)
591 new_modify_expr
= build_x_modify_expr (location
, lhs
,
592 modifycode
, rhs
, complain
);
593 finish_expr_stmt (new_modify_expr
);
594 pop_stmt_list (an_init
);
601 /* If for some reason location is not set, then find if LHS or RHS has
602 location info. If so, then use that so we atleast have an idea. */
603 if (location
== UNKNOWN_LOCATION
)
605 if (EXPR_LOCATION (lhs
) != UNKNOWN_LOCATION
)
606 location
= EXPR_LOCATION (lhs
);
607 else if (EXPR_LOCATION (rhs
) != UNKNOWN_LOCATION
)
608 location
= EXPR_LOCATION (rhs
);
611 /* We need this when we have a scatter issue. */
612 extract_array_notation_exprs (lhs
, true, &lhs_list
);
614 extract_array_notation_exprs (rhs
, true, &rhs_list
);
615 rhs_list_size
= vec_safe_length (rhs_list
);
616 lhs_list_size
= vec_safe_length (lhs_list
);
618 if (lhs_rank
== 0 && rhs_rank
!= 0)
620 error_at (location
, "%qE cannot be scalar when %qE is not", lhs
, rhs
);
621 return error_mark_node
;
623 if (lhs_rank
!= 0 && rhs_rank
!= 0 && lhs_rank
!= rhs_rank
)
625 error_at (location
, "rank mismatch between %qE and %qE", lhs
, rhs
);
626 return error_mark_node
;
629 /* Assign the array notation components to variable so that they can satisfy
630 the execute-once rule. */
631 for (ii
= 0; ii
< lhs_list_size
; ii
++)
633 tree anode
= (*lhs_list
)[ii
];
634 make_triplet_val_inv (&ARRAY_NOTATION_START (anode
));
635 make_triplet_val_inv (&ARRAY_NOTATION_LENGTH (anode
));
636 make_triplet_val_inv (&ARRAY_NOTATION_STRIDE (anode
));
638 for (ii
= 0; ii
< rhs_list_size
; ii
++)
639 if ((*rhs_list
)[ii
] && TREE_CODE ((*rhs_list
)[ii
]) == ARRAY_NOTATION_REF
)
641 tree aa
= (*rhs_list
)[ii
];
642 make_triplet_val_inv (&ARRAY_NOTATION_START (aa
));
643 make_triplet_val_inv (&ARRAY_NOTATION_LENGTH (aa
));
644 make_triplet_val_inv (&ARRAY_NOTATION_STRIDE (aa
));
646 lhs_an_loop_info
.safe_grow_cleared (lhs_rank
);
649 rhs_an_loop_info
.safe_grow_cleared (rhs_rank
);
651 cond_expr
.safe_grow_cleared (MAX (lhs_rank
, rhs_rank
));
652 cilkplus_extract_an_triplets (lhs_list
, lhs_list_size
, lhs_rank
,
655 cilkplus_extract_an_triplets (rhs_list
, rhs_list_size
, rhs_rank
,
657 if (length_mismatch_in_expr_p (EXPR_LOCATION (lhs
), lhs_an_info
)
658 || (rhs_list
&& length_mismatch_in_expr_p (EXPR_LOCATION (rhs
),
661 pop_stmt_list (an_init
);
662 return error_mark_node
;
664 tree rhs_len
= ((rhs_list_size
> 0 && rhs_rank
> 0) ?
665 rhs_an_info
[0][0].length
: NULL_TREE
);
666 tree lhs_len
= ((lhs_list_size
> 0 && lhs_rank
> 0) ?
667 lhs_an_info
[0][0].length
: NULL_TREE
);
668 if (lhs_list_size
> 0 && rhs_list_size
> 0 && lhs_rank
> 0 && rhs_rank
> 0
669 && TREE_CODE (lhs_len
) == INTEGER_CST
&& rhs_len
670 && TREE_CODE (rhs_len
) == INTEGER_CST
671 && !tree_int_cst_equal (rhs_len
, lhs_len
))
673 error_at (location
, "length mismatch between LHS and RHS");
674 pop_stmt_list (an_init
);
675 return error_mark_node
;
677 for (ii
= 0; ii
< lhs_rank
; ii
++)
679 tree typ
= ptrdiff_type_node
;
680 lhs_an_loop_info
[ii
].var
= create_temporary_var (typ
);
681 add_decl_expr (lhs_an_loop_info
[ii
].var
);
682 lhs_an_loop_info
[ii
].ind_init
= build_x_modify_expr
683 (location
, lhs_an_loop_info
[ii
].var
, INIT_EXPR
, build_zero_cst (typ
),
687 if (rhs_list_size
> 0)
689 rhs_array_operand
= fix_sec_implicit_args (location
, rhs_list
,
690 lhs_an_loop_info
, lhs_rank
,
692 if (!rhs_array_operand
)
693 return error_mark_node
;
695 replace_array_notations (&rhs
, true, rhs_list
, rhs_array_operand
);
698 extract_array_notation_exprs (rhs
, true, &rhs_list
);
699 rhs_list_size
= vec_safe_length (rhs_list
);
701 for (ii
= 0; ii
< rhs_rank
; ii
++)
703 tree typ
= ptrdiff_type_node
;
704 rhs_an_loop_info
[ii
].var
= create_temporary_var (typ
);
705 add_decl_expr (rhs_an_loop_info
[ii
].var
);
706 rhs_an_loop_info
[ii
].ind_init
= build_x_modify_expr
707 (location
, rhs_an_loop_info
[ii
].var
, INIT_EXPR
, build_zero_cst (typ
),
714 create_array_refs (location
, lhs_an_info
, lhs_an_loop_info
,
715 lhs_list_size
, lhs_rank
);
716 replace_array_notations (&lhs
, true, lhs_list
, lhs_array_operand
);
719 if (rhs_array_operand
)
720 vec_safe_truncate (rhs_array_operand
, 0);
723 rhs_array_operand
= create_array_refs (location
, rhs_an_info
,
724 rhs_an_loop_info
, rhs_list_size
,
726 /* Replace all the array refs created by the above function because this
727 variable is blown away by the fix_sec_implicit_args function below. */
728 replace_array_notations (&rhs
, true, rhs_list
, rhs_array_operand
);
729 vec_safe_truncate (rhs_array_operand
, 0);
730 rhs_array_operand
= fix_sec_implicit_args (location
, rhs_list
,
731 rhs_an_loop_info
, rhs_rank
,
733 if (!rhs_array_operand
)
734 return error_mark_node
;
735 replace_array_notations (&rhs
, true, rhs_list
, rhs_array_operand
);
738 array_expr_rhs
= rhs
;
739 array_expr_lhs
= lhs
;
741 array_expr
= build_x_modify_expr (location
, array_expr_lhs
, modifycode
,
742 array_expr_rhs
, complain
);
743 create_cmp_incr (location
, &lhs_an_loop_info
, lhs_rank
, lhs_an_info
,
746 create_cmp_incr (location
, &rhs_an_loop_info
, rhs_rank
, rhs_an_info
,
748 for (ii
= 0; ii
< MAX (rhs_rank
, lhs_rank
); ii
++)
749 if (ii
< lhs_rank
&& ii
< rhs_rank
)
750 cond_expr
[ii
] = build_x_binary_op
751 (location
, TRUTH_ANDIF_EXPR
, lhs_an_loop_info
[ii
].cmp
,
752 TREE_CODE (lhs_an_loop_info
[ii
].cmp
), rhs_an_loop_info
[ii
].cmp
,
753 TREE_CODE (rhs_an_loop_info
[ii
].cmp
), NULL
, complain
);
754 else if (ii
< lhs_rank
&& ii
>= rhs_rank
)
755 cond_expr
[ii
] = lhs_an_loop_info
[ii
].cmp
;
757 /* No need to compare ii < rhs_rank && ii >= lhs_rank because in a valid
758 Array notation expression, rank of RHS cannot be greater than LHS. */
761 an_init
= pop_stmt_list (an_init
);
762 append_to_statement_list (an_init
, &loop_with_init
);
764 for (ii
= 0; ii
< MAX (lhs_rank
, rhs_rank
); ii
++)
766 tree incr_list
= alloc_stmt_list ();
767 tree init_list
= alloc_stmt_list ();
768 tree new_loop
= push_stmt_list ();
772 append_to_statement_list (lhs_an_loop_info
[ii
].ind_init
, &init_list
);
773 append_to_statement_list (lhs_an_loop_info
[ii
].incr
, &incr_list
);
777 append_to_statement_list (rhs_an_loop_info
[ii
].ind_init
, &init_list
);
778 append_to_statement_list (rhs_an_loop_info
[ii
].incr
, &incr_list
);
780 create_an_loop (init_list
, cond_expr
[ii
], incr_list
, body
);
781 body
= pop_stmt_list (new_loop
);
783 append_to_statement_list (body
, &loop_with_init
);
785 lhs_an_info
.release ();
786 lhs_an_loop_info
.release ();
789 rhs_an_info
.release ();
790 rhs_an_loop_info
.release ();
792 cond_expr
.release ();
794 return loop_with_init
;
797 /* Helper function for expand_conditonal_array_notations. Encloses the
798 conditional statement passed in ORIG_STMT with a loop around it and
799 replaces the condition in STMT with a ARRAY_REF tree-node to the array.
800 The condition must have a ARRAY_NOTATION_REF tree. */
803 cp_expand_cond_array_notations (tree orig_stmt
)
805 vec
<tree
, va_gc
> *array_list
= NULL
, *array_operand
= NULL
;
806 size_t list_size
= 0;
807 size_t rank
= 0, ii
= 0;
808 tree an_init
, body
, stmt
= NULL_TREE
;
809 tree builtin_loop
, new_var
= NULL_TREE
;
810 tree loop_with_init
= alloc_stmt_list ();
811 location_t location
= UNKNOWN_LOCATION
;
812 vec
<vec
<an_parts
> > an_info
= vNULL
;
813 vec
<an_loop_parts
> an_loop_info
= vNULL
;
815 if (TREE_CODE (orig_stmt
) == COND_EXPR
)
817 size_t cond_rank
= 0, yes_rank
= 0, no_rank
= 0;
818 tree yes_expr
= COND_EXPR_THEN (orig_stmt
);
819 tree no_expr
= COND_EXPR_ELSE (orig_stmt
);
820 tree cond
= COND_EXPR_COND (orig_stmt
);
821 if (!find_rank (EXPR_LOCATION (cond
), cond
, cond
, true, &cond_rank
)
822 || !find_rank (EXPR_LOCATION (yes_expr
), yes_expr
, yes_expr
, true,
824 || find_rank (EXPR_LOCATION (no_expr
), no_expr
, no_expr
, true,
826 return error_mark_node
;
827 /* If the condition has a zero rank, then handle array notations in body
831 if (cond_rank
!= yes_rank
&& yes_rank
!= 0)
833 error_at (EXPR_LOCATION (yes_expr
), "rank mismatch with controlling"
834 " expression of parent if-statement");
835 return error_mark_node
;
837 else if (cond_rank
!= no_rank
&& no_rank
!= 0)
839 error_at (EXPR_LOCATION (no_expr
), "rank mismatch with controlling "
840 "expression of parent if-statement");
841 return error_mark_node
;
844 else if (TREE_CODE (orig_stmt
) == IF_STMT
)
846 size_t cond_rank
= 0, yes_rank
= 0, no_rank
= 0;
847 tree yes_expr
= THEN_CLAUSE (orig_stmt
);
848 tree no_expr
= ELSE_CLAUSE (orig_stmt
);
849 tree cond
= IF_COND (orig_stmt
);
850 if (!find_rank (EXPR_LOCATION (cond
), cond
, cond
, true, &cond_rank
)
852 && !find_rank (EXPR_LOCATION (yes_expr
), yes_expr
, yes_expr
, true,
855 && !find_rank (EXPR_LOCATION (no_expr
), no_expr
, no_expr
, true,
857 return error_mark_node
;
859 /* Same reasoning as for COND_EXPR. */
862 else if (cond_rank
!= yes_rank
&& yes_rank
!= 0)
864 error_at (EXPR_LOCATION (yes_expr
), "rank mismatch with controlling"
865 " expression of parent if-statement");
866 return error_mark_node
;
868 else if (cond_rank
!= no_rank
&& no_rank
!= 0)
870 error_at (EXPR_LOCATION (no_expr
), "rank mismatch with controlling "
871 "expression of parent if-statement");
872 return error_mark_node
;
875 else if (truth_value_p (TREE_CODE (orig_stmt
)))
877 size_t left_rank
= 0, right_rank
= 0;
878 tree left_expr
= TREE_OPERAND (orig_stmt
, 0);
879 tree right_expr
= TREE_OPERAND (orig_stmt
, 1);
880 if (!find_rank (EXPR_LOCATION (left_expr
), left_expr
, left_expr
, true,
882 || !find_rank (EXPR_LOCATION (right_expr
), right_expr
, right_expr
,
884 return error_mark_node
;
885 if (right_rank
== 0 && left_rank
== 0)
889 if (!find_rank (EXPR_LOCATION (orig_stmt
), orig_stmt
, orig_stmt
, true,
891 return error_mark_node
;
895 extract_array_notation_exprs (orig_stmt
, false, &array_list
);
896 stmt
= alloc_stmt_list ();
897 for (ii
= 0; ii
< vec_safe_length (array_list
); ii
++)
899 tree array_node
= (*array_list
)[ii
];
900 if (TREE_CODE (array_node
) == CALL_EXPR
901 || TREE_CODE (array_node
) == AGGR_INIT_EXPR
)
903 builtin_loop
= expand_sec_reduce_builtin (array_node
, &new_var
);
904 if (builtin_loop
== error_mark_node
)
905 finish_expr_stmt (error_mark_node
);
908 vec
<tree
, va_gc
> *sub_list
= NULL
, *new_var_list
= NULL
;
909 vec_safe_push (sub_list
, array_node
);
910 vec_safe_push (new_var_list
, new_var
);
911 replace_array_notations (&orig_stmt
, false, sub_list
,
913 append_to_statement_list (builtin_loop
, &stmt
);
917 append_to_statement_list (orig_stmt
, &stmt
);
920 if (!find_rank (EXPR_LOCATION (stmt
), stmt
, stmt
, true, &rank
))
921 return error_mark_node
;
925 extract_array_notation_exprs (stmt
, true, &array_list
);
926 list_size
= vec_safe_length (array_list
);
930 location
= EXPR_LOCATION (orig_stmt
);
931 list_size
= vec_safe_length (array_list
);
932 an_loop_info
.safe_grow_cleared (rank
);
934 an_init
= push_stmt_list ();
936 /* Assign the array notation components to variable so that they can
937 satisfy the exec-once rule. */
938 for (ii
= 0; ii
< list_size
; ii
++)
940 tree anode
= (*array_list
)[ii
];
941 make_triplet_val_inv (&ARRAY_NOTATION_START (anode
));
942 make_triplet_val_inv (&ARRAY_NOTATION_LENGTH (anode
));
943 make_triplet_val_inv (&ARRAY_NOTATION_STRIDE (anode
));
945 cilkplus_extract_an_triplets (array_list
, list_size
, rank
, &an_info
);
947 for (ii
= 0; ii
< rank
; ii
++)
949 tree typ
= ptrdiff_type_node
;
950 an_loop_info
[ii
].var
= create_temporary_var (typ
);
951 add_decl_expr (an_loop_info
[ii
].var
);
952 an_loop_info
[ii
].ind_init
=
953 build_x_modify_expr (location
, an_loop_info
[ii
].var
, INIT_EXPR
,
954 build_zero_cst (typ
), tf_warning_or_error
);
956 array_operand
= create_array_refs (location
, an_info
, an_loop_info
,
958 replace_array_notations (&stmt
, true, array_list
, array_operand
);
959 create_cmp_incr (location
, &an_loop_info
, rank
, an_info
, tf_warning_or_error
);
961 an_init
= pop_stmt_list (an_init
);
962 append_to_statement_list (an_init
, &loop_with_init
);
965 for (ii
= 0; ii
< rank
; ii
++)
967 tree new_loop
= push_stmt_list ();
968 create_an_loop (an_loop_info
[ii
].ind_init
, an_loop_info
[ii
].cmp
,
969 an_loop_info
[ii
].incr
, body
);
970 body
= pop_stmt_list (new_loop
);
972 append_to_statement_list (body
, &loop_with_init
);
975 an_loop_info
.release ();
977 return loop_with_init
;
980 /* Transforms array notations inside unary expression ORIG_STMT with an
981 appropriate loop and ARRAY_REF (and returns all this as a super-tree called
985 expand_unary_array_notation_exprs (tree orig_stmt
)
987 vec
<tree
, va_gc
> *array_list
= NULL
, *array_operand
= NULL
;
988 size_t list_size
= 0, rank
= 0, ii
= 0;
990 tree builtin_loop
, stmt
= NULL_TREE
, new_var
= NULL_TREE
;
991 location_t location
= EXPR_LOCATION (orig_stmt
);
992 tree an_init
, loop_with_init
= alloc_stmt_list ();
993 vec
<vec
<an_parts
> > an_info
= vNULL
;
994 vec
<an_loop_parts
> an_loop_info
= vNULL
;
996 if (!find_rank (location
, orig_stmt
, orig_stmt
, true, &rank
))
997 return error_mark_node
;
1001 extract_array_notation_exprs (orig_stmt
, false, &array_list
);
1002 list_size
= vec_safe_length (array_list
);
1003 location
= EXPR_LOCATION (orig_stmt
);
1005 for (ii
= 0; ii
< list_size
; ii
++)
1006 if (TREE_CODE ((*array_list
)[ii
]) == CALL_EXPR
1007 || TREE_CODE ((*array_list
)[ii
]) == AGGR_INIT_EXPR
)
1009 tree list_node
= (*array_list
)[ii
];
1010 builtin_loop
= expand_sec_reduce_builtin (list_node
, &new_var
);
1011 if (builtin_loop
== error_mark_node
)
1012 return error_mark_node
;
1013 else if (builtin_loop
)
1015 vec
<tree
, va_gc
> *sub_list
= NULL
, *new_var_list
= NULL
;
1016 stmt
= alloc_stmt_list ();
1017 append_to_statement_list (builtin_loop
, &stmt
);
1018 vec_safe_push (sub_list
, list_node
);
1019 vec_safe_push (new_var_list
, new_var
);
1020 replace_array_notations (&orig_stmt
, false, sub_list
, new_var_list
);
1023 if (stmt
!= NULL_TREE
)
1024 append_to_statement_list (finish_expr_stmt (orig_stmt
), &stmt
);
1030 extract_array_notation_exprs (stmt
, true, &array_list
);
1031 list_size
= vec_safe_length (array_list
);
1033 if (!find_rank (EXPR_LOCATION (stmt
), stmt
, stmt
, true, &rank
))
1034 return error_mark_node
;
1035 if (rank
== 0 || list_size
== 0)
1037 an_loop_info
.safe_grow_cleared (rank
);
1038 an_init
= push_stmt_list ();
1039 /* Assign the array notation components to variable so that they can satisfy
1040 the exec-once rule. */
1041 for (ii
= 0; ii
< list_size
; ii
++)
1043 tree array_node
= (*array_list
)[ii
];
1044 make_triplet_val_inv (&ARRAY_NOTATION_START (array_node
));
1045 make_triplet_val_inv (&ARRAY_NOTATION_LENGTH (array_node
));
1046 make_triplet_val_inv (&ARRAY_NOTATION_STRIDE (array_node
));
1048 cilkplus_extract_an_triplets (array_list
, list_size
, rank
, &an_info
);
1050 for (ii
= 0; ii
< rank
; ii
++)
1052 tree typ
= ptrdiff_type_node
;
1053 an_loop_info
[ii
].var
= create_temporary_var (typ
);
1054 add_decl_expr (an_loop_info
[ii
].var
);
1055 an_loop_info
[ii
].ind_init
= build_x_modify_expr
1056 (location
, an_loop_info
[ii
].var
, INIT_EXPR
, build_zero_cst (typ
),
1057 tf_warning_or_error
);
1059 array_operand
= create_array_refs (location
, an_info
, an_loop_info
,
1061 replace_array_notations (&stmt
, true, array_list
, array_operand
);
1062 create_cmp_incr (location
, &an_loop_info
, rank
, an_info
, tf_warning_or_error
);
1064 an_init
= pop_stmt_list (an_init
);
1065 append_to_statement_list (an_init
, &loop_with_init
);
1068 for (ii
= 0; ii
< rank
; ii
++)
1070 tree new_loop
= push_stmt_list ();
1071 create_an_loop (an_loop_info
[ii
].ind_init
, an_loop_info
[ii
].cmp
,
1072 an_loop_info
[ii
].incr
, body
);
1073 body
= pop_stmt_list (new_loop
);
1075 append_to_statement_list (body
, &loop_with_init
);
1078 an_loop_info
.release ();
1080 return loop_with_init
;
1083 /* Expands the array notation's builtin reduction function in EXPR
1084 (of type RETURN_EXPR) and returns a STATEMENT_LIST that contains a loop
1085 with the builtin function expansion and a return statement at the end. */
1088 expand_return_expr (tree expr
)
1090 tree new_mod_list
, new_var
, new_mod
, retval_expr
;
1092 location_t loc
= EXPR_LOCATION (expr
);
1093 if (TREE_CODE (expr
) != RETURN_EXPR
)
1096 if (!find_rank (loc
, expr
, expr
, false, &rank
))
1097 return error_mark_node
;
1099 /* If the return expression contains array notations, then flag it as
1103 error_at (loc
, "array notation expression cannot be used as a return "
1105 return error_mark_node
;
1108 new_mod_list
= push_stmt_list ();
1109 retval_expr
= TREE_OPERAND (expr
, 0);
1110 new_var
= create_temporary_var (TREE_TYPE (retval_expr
));
1111 add_decl_expr (new_var
);
1112 new_mod
= expand_an_in_modify_expr (loc
, new_var
, NOP_EXPR
,
1113 TREE_OPERAND (retval_expr
, 1),
1114 tf_warning_or_error
);
1115 TREE_OPERAND (retval_expr
, 1) = new_var
;
1116 TREE_OPERAND (expr
, 0) = retval_expr
;
1119 new_mod_list
= pop_stmt_list (new_mod_list
);
1120 return new_mod_list
;
1123 /* Expands ARRAY_NOTATION_REF and builtin functions in a compound statement,
1124 STMT. Returns the STMT with expanded array notations. */
1127 expand_array_notation_exprs (tree t
)
1129 enum tree_code code
;
1131 location_t loc
= UNKNOWN_LOCATION
;
1136 loc
= EXPR_LOCATION (t
);
1138 code
= TREE_CODE (t
);
1139 is_expr
= IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code
));
1143 case IDENTIFIER_NODE
:
1150 case PLACEHOLDER_EXPR
:
1159 case NON_LVALUE_EXPR
:
1169 if (contains_array_notation_expr (t
))
1170 t
= expand_an_in_modify_expr (loc
, TREE_OPERAND (t
, 0), NOP_EXPR
,
1171 TREE_OPERAND (t
, 1),
1172 tf_warning_or_error
);
1175 if (contains_array_notation_expr (t
) && !processing_template_decl
)
1176 t
= expand_an_in_modify_expr
1177 (loc
, TREE_OPERAND (t
, 0), TREE_CODE (TREE_OPERAND (t
, 1)),
1178 TREE_OPERAND (t
, 2), tf_warning_or_error
);
1184 BIND_EXPR_BODY (t
) =
1185 expand_array_notation_exprs (BIND_EXPR_BODY (t
));
1189 if (contains_array_notation_expr (t
))
1191 tree x
= DECL_EXPR_DECL (t
);
1192 if (DECL_INITIAL (x
))
1194 location_t loc
= DECL_SOURCE_LOCATION (x
);
1196 tree rhs
= DECL_INITIAL (x
);
1197 DECL_INITIAL (x
) = NULL
;
1198 tree new_modify_expr
= build_modify_expr (loc
, lhs
,
1203 t
= expand_array_notation_exprs (new_modify_expr
);
1207 case STATEMENT_LIST
:
1209 tree_stmt_iterator i
;
1210 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
1212 expand_array_notation_exprs (*tsi_stmt_ptr (i
));
1238 if (contains_array_notation_expr (t
))
1239 t
= expand_return_expr (t
);
1241 case PREDECREMENT_EXPR
:
1242 case PREINCREMENT_EXPR
:
1243 case POSTDECREMENT_EXPR
:
1244 case POSTINCREMENT_EXPR
:
1245 case AGGR_INIT_EXPR
:
1247 t
= expand_unary_array_notation_exprs (t
);
1250 case CLEANUP_POINT_EXPR
:
1252 TREE_OPERAND (t
, 0) = expand_array_notation_exprs (TREE_OPERAND (t
, 0));
1253 /* It is not necessary to wrap error_mark_node in EXPR_STMT. */
1254 if (TREE_OPERAND (t
, 0) == error_mark_node
)
1255 return TREE_OPERAND (t
, 0);
1257 case TRUTH_ANDIF_EXPR
:
1258 case TRUTH_ORIF_EXPR
:
1259 case TRUTH_AND_EXPR
:
1261 case TRUTH_XOR_EXPR
:
1262 case TRUTH_NOT_EXPR
:
1264 t
= cp_expand_cond_array_notations (t
);
1265 if (TREE_CODE (t
) == COND_EXPR
)
1267 COND_EXPR_THEN (t
) =
1268 expand_array_notation_exprs (COND_EXPR_THEN (t
));
1269 COND_EXPR_ELSE (t
) =
1270 expand_array_notation_exprs (COND_EXPR_ELSE (t
));
1274 if (contains_array_notation_expr (FOR_COND (t
)))
1276 error_at (EXPR_LOCATION (FOR_COND (t
)),
1277 "array notation cannot be used in a condition for "
1279 return error_mark_node
;
1281 /* FIXME: Add a check for CILK_FOR_STMT here when we add Cilk tasking
1283 if (TREE_CODE (t
) == FOR_STMT
)
1285 FOR_BODY (t
) = expand_array_notation_exprs (FOR_BODY (t
));
1286 FOR_EXPR (t
) = expand_array_notation_exprs (FOR_EXPR (t
));
1289 t
= expand_array_notation_exprs (t
);
1292 t
= cp_expand_cond_array_notations (t
);
1293 /* If the above function added some extra instructions above the original
1294 if statement, then we can't assume it is still IF_STMT so we have to
1296 if (TREE_CODE (t
) == IF_STMT
)
1298 if (THEN_CLAUSE (t
))
1299 THEN_CLAUSE (t
) = expand_array_notation_exprs (THEN_CLAUSE (t
));
1300 if (ELSE_CLAUSE (t
))
1301 ELSE_CLAUSE (t
) = expand_array_notation_exprs (ELSE_CLAUSE (t
));
1304 t
= expand_array_notation_exprs (t
);
1307 if (contains_array_notation_expr (SWITCH_STMT_COND (t
)))
1309 error_at (EXPR_LOCATION (SWITCH_STMT_COND (t
)),
1310 "array notation cannot be used as a condition for "
1311 "switch statement");
1312 return error_mark_node
;
1314 if (SWITCH_STMT_BODY (t
))
1315 SWITCH_STMT_BODY (t
) =
1316 expand_array_notation_exprs (SWITCH_STMT_BODY (t
));
1319 if (contains_array_notation_expr (WHILE_COND (t
)))
1321 if (EXPR_LOCATION (WHILE_COND (t
)) != UNKNOWN_LOCATION
)
1322 loc
= EXPR_LOCATION (WHILE_COND (t
));
1323 error_at (loc
, "array notation cannot be used as a condition for "
1325 return error_mark_node
;
1328 WHILE_BODY (t
) = expand_array_notation_exprs (WHILE_BODY (t
));
1331 if (contains_array_notation_expr (DO_COND (t
)))
1333 error_at (EXPR_LOCATION (DO_COND (t
)),
1334 "array notation cannot be used as a condition for a "
1335 "do-while statement");
1336 return error_mark_node
;
1339 DO_BODY (t
) = expand_array_notation_exprs (DO_BODY (t
));
1346 /* Walk over all the sub-trees of this operand. */
1347 len
= TREE_CODE_LENGTH (code
);
1349 /* Go through the subtrees. We need to do this in forward order so
1350 that the scope of a FOR_EXPR is handled properly. */
1351 for (i
= 0; i
< len
; ++i
)
1352 TREE_OPERAND (t
, i
) =
1353 expand_array_notation_exprs (TREE_OPERAND (t
, i
));
1360 /* Given the base of an array (ARRAY), the START (start_index), the number of
1361 elements to be accessed (LENGTH) and the STRIDE, construct an
1362 ARRAY_NOTATION_REF tree of type TYPE and return it. Restrictions on START,
1363 LENGTH and STRIDE are the same as that of index field passed into ARRAY_REF.
1364 The only additional restriction is that, unlike index in ARRAY_REF, stride,
1365 length and start_index cannot contain array notations. */
1368 build_array_notation_ref (location_t loc
, tree array
, tree start
, tree length
,
1369 tree stride
, tree type
)
1371 tree array_ntn_expr
= NULL_TREE
;
1373 /* If we enter the then-case of the if-statement below, we have hit a case
1374 like this: ARRAY [:]. */
1375 if (!start
&& !length
)
1377 if (TREE_CODE (type
) != ARRAY_TYPE
)
1379 error_at (loc
, "start-index and length fields necessary for "
1380 "using array notation in pointers or records");
1381 return error_mark_node
;
1383 tree domain
= TYPE_DOMAIN (type
);
1386 error_at (loc
, "start-index and length fields necessary for "
1387 "using array notation with array of unknown bound");
1388 return error_mark_node
;
1390 start
= cp_fold_convert (ptrdiff_type_node
, TYPE_MINVAL (domain
));
1391 length
= size_binop (PLUS_EXPR
, TYPE_MAXVAL (domain
), size_one_node
);
1392 length
= cp_fold_convert (ptrdiff_type_node
, length
);
1396 stride
= build_one_cst (ptrdiff_type_node
);
1398 /* When dealing with templates, triplet type-checking will be done in pt.c
1399 after type substitution. */
1400 if (processing_template_decl
1401 && (type_dependent_expression_p (array
)
1402 || type_dependent_expression_p (length
)
1403 || type_dependent_expression_p (start
)
1404 || type_dependent_expression_p (stride
)))
1405 array_ntn_expr
= build_min_nt_loc (loc
, ARRAY_NOTATION_REF
, array
, start
,
1406 length
, stride
, NULL_TREE
);
1409 if (!cilkplus_an_triplet_types_ok_p (loc
, start
, length
, stride
, type
))
1410 return error_mark_node
;
1411 array_ntn_expr
= build4 (ARRAY_NOTATION_REF
, NULL_TREE
, array
, start
,
1414 if (TREE_CODE (type
) == ARRAY_TYPE
|| TREE_CODE (type
) == POINTER_TYPE
)
1415 TREE_TYPE (array_ntn_expr
) = TREE_TYPE (type
);
1418 error_at (loc
, "base of array section must be pointer or array type");
1419 return error_mark_node
;
1422 SET_EXPR_LOCATION (array_ntn_expr
, loc
);
1423 return array_ntn_expr
;
1426 /* Returns false if any of the Array notation triplet values: START_INDEX,
1427 LENGTH and STRIDE, are not of integral type and have a rank greater than
1431 cilkplus_an_triplet_types_ok_p (location_t loc
, tree start_index
, tree length
,
1432 tree stride
, tree type
)
1434 size_t stride_rank
= 0, length_rank
= 0, start_rank
= 0;
1435 if (!TREE_TYPE (start_index
) || !INTEGRAL_TYPE_P (TREE_TYPE (start_index
)))
1437 error_at (loc
, "start-index of array notation triplet is not an integer");
1440 if (!TREE_TYPE (length
) || !INTEGRAL_TYPE_P (TREE_TYPE (length
)))
1442 error_at (loc
, "length of array notation triplet is not an integer");
1445 if (!TREE_TYPE (stride
) || !INTEGRAL_TYPE_P (TREE_TYPE (stride
)))
1447 error_at (loc
, "stride of array notation triplet is not an integer");
1450 if (TREE_CODE (type
) == FUNCTION_TYPE
)
1452 error_at (loc
, "array notation cannot be used with function type");
1455 if (!find_rank (loc
, start_index
, start_index
, false, &start_rank
)
1456 || !find_rank (loc
, length
, length
, false, &length_rank
)
1457 || !find_rank (loc
, stride
, stride
, false, &stride_rank
))
1460 if (start_rank
!= 0)
1462 error_at (loc
, "rank of an array notation triplet%'s start-index is not "
1466 if (length_rank
!= 0)
1468 error_at (loc
, "rank of an array notation triplet%'s length is not zero");
1471 if (stride_rank
!= 0)
1473 error_at (loc
, "rank of array notation triplet%'s stride is not zero");