[PATCH, PR63307] Fix generation of new declarations in random order

[Zamyatin, Igor]

Hi!

The following patch does fix random order for new decls generation during Cilk_spawn generation.
As Jakub suggested in the PR first we deal with vectors, then sort them and only then perform necessary generation of new decls.

Bootstrapped and regtested on trunk/4.9.
For trunk I couldn't check with COMPARE_DEBUG since building fails somewhere else.
For 4.9 COMPARE_DEBUG building is ok.

Is it ok for trunk and backport into 4.9?


c-family/Changelog:

2014-10-03 Igor Zamyatin <***@intel.com>

PR c/63307
* cilk.c: Include vec.h.
(struct cilk_decls): New structure.
(wrapper_parm_cb): Split this function to...
(fill_decls_vec): ...this...
(create_parm_list): ...and this.
(compare_decls): New function.
(for_local_cb): Remove.
(wrapper_local_cb): Ditto.
(build_wrapper_type): For now first traverse and fill vector of
declarations then sort it and then deal with sorted vector.
(cilk_outline): Ditto.
(declare_one_free_variable): Ditto.



diff --git a/gcc/c-family/cilk.c b/gcc/c-family/cilk.c
index 20b3432..e7a1c6a 100644
--- a/gcc/c-family/cilk.c
+++ b/gcc/c-family/cilk.c
@@ -35,6 +35,7 @@ along with GCC; see the file COPYING3. If not see
#include "toplev.h"
#include "cgraph.h"
#include "diagnostic.h"
+#include "vec.h"
#include "cilk.h"

enum add_variable_type {
@@ -332,17 +333,36 @@ create_cilk_helper_decl (struct wrapper_data *wd)
return fndecl;
}

-/* A function used by walk tree to find wrapper parms. */
+struct cilk_decls
+{
+ tree key;
+ tree *val;
+};
+
+/* A function used by traversal to fill vector of decls for further work. */

bool
-wrapper_parm_cb (tree const &key0, tree *val0, wrapper_data *wd)
+fill_decls_vec (tree const &key0, tree *val0, auto_vec<struct cilk_decls> *v)
+{
+ tree t1 = key0;
+ struct cilk_decls dp;
+
+ dp.key = t1;
+ dp.val = val0;
+ v->safe_push (dp);
+ return true;
+}
+
+/* Function that actually creates necessary parm lists. */
+
+static void
+create_parm_list (struct wrapper_data *wd, tree *val0, tree arg)
{
- tree arg = key0;
tree val = *val0;
tree parm;

if (val == error_mark_node || val == arg)
- return true;
+ return;

if (TREE_CODE (val) == PAREN_EXPR)
{
@@ -360,7 +380,7 @@ wrapper_parm_cb (tree const &key0, tree *val0, wrapper_data *wd)
}
else
arg = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (arg)), arg);
-
+
val = TREE_OPERAND (val, 0);
*val0 = val;
gcc_assert (TREE_CODE (val) == INDIRECT_REF);
@@ -371,9 +391,19 @@ wrapper_parm_cb (tree const &key0, tree *val0, wrapper_data *wd)
parm = val;
TREE_CHAIN (parm) = wd->parms;
wd->parms = parm;
- wd->argtypes = tree_cons (NULL_TREE, TREE_TYPE (parm), wd->argtypes);
- wd->arglist = tree_cons (NULL_TREE, arg, wd->arglist);
- return true;
+ wd->argtypes = tree_cons (NULL_TREE, TREE_TYPE (parm), wd->argtypes);
+ wd->arglist = tree_cons (NULL_TREE, arg, wd->arglist);
+}
+
+/* Sorting decls in a vector. */
+
+static int
+compare_decls (const void *a, const void *b)
+{
+ const struct cilk_decls* t1 = (const struct cilk_decls*) a;
+ const struct cilk_decls* t2 = (const struct cilk_decls*) b;
+
+ return DECL_UID (t1->key) > DECL_UID (t2->key);
}

/* This function is used to build a wrapper of a certain type. */
@@ -381,13 +411,21 @@ wrapper_parm_cb (tree const &key0, tree *val0, wrapper_data *wd)
static void
build_wrapper_type (struct wrapper_data *wd)
{
+ unsigned int j;
+ struct cilk_decls * c;
+ auto_vec<struct cilk_decls> vd;
wd->arglist = NULL_TREE;
wd->parms = NULL_TREE;
wd->argtypes = void_list_node;

- wd->decl_map->traverse<wrapper_data *, wrapper_parm_cb> (wd);
+ wd->decl_map->traverse<auto_vec<struct cilk_decls> *, fill_decls_vec> (&vd);
gcc_assert (wd->type != CILK_BLOCK_FOR);

+ vd.qsort (compare_decls);
+
+ FOR_EACH_VEC_ELT (vd, j, c)
+ create_parm_list (wd, c->val, c->key);
+
/* Now build a function.
Its return type is void (all side effects are via explicit parameters).
Its parameters are WRAPPER_PARMS with type WRAPPER_TYPES.
@@ -448,41 +486,19 @@ copy_decl_for_cilk (tree decl, copy_body_data *id)
}
}

-/* Copy all local variables. */
-
-bool
-for_local_cb (tree const &k, tree *vp, copy_body_data *id)
-{
- tree v = *vp;
-
- if (v == error_mark_node)
- *vp = copy_decl_no_change (k, id);
- return true;
-}
-
-/* Copy all local declarations from a _Cilk_spawned function's body. */
-
-bool
-wrapper_local_cb (tree const &key, tree *vp, copy_body_data *id)
-{
- tree val = *vp;
-
- if (val == error_mark_node)
- *vp = copy_decl_for_cilk (key, id);
-
- return true;
-}
-
/* Alter a tree STMT from OUTER_FN to form the body of INNER_FN. */

void
cilk_outline (tree inner_fn, tree *stmt_p, void *w)
{
struct wrapper_data *wd = (struct wrapper_data *) w;
- const tree outer_fn = wd->context;
+ const tree outer_fn = wd->context;
const bool nested = (wd->type == CILK_BLOCK_FOR);
copy_body_data id;
bool throws;
+ auto_vec<struct cilk_decls> vd;
+ unsigned int j;
+ struct cilk_decls * c;

DECL_STATIC_CHAIN (outer_fn) = 1;

@@ -508,11 +524,13 @@ cilk_outline (tree inner_fn, tree *stmt_p, void *w)

insert_decl_map (&id, wd->block, DECL_INITIAL (inner_fn));

+ wd->decl_map->traverse<auto_vec<struct cilk_decls> *, fill_decls_vec> (&vd);
+ vd.qsort (compare_decls);
/* We don't want the private variables any more. */
- if (nested)
- wd->decl_map->traverse<copy_body_data *, for_local_cb> (&id);
- else
- wd->decl_map->traverse<copy_body_data *, wrapper_local_cb> (&id);
+ FOR_EACH_VEC_ELT (vd, j, c)
+ if (*(c->val) == error_mark_node)
+ *(c->val) = nested ? copy_decl_no_change (c->key, &id)
+ : copy_decl_for_cilk (c->key, &id);

walk_tree (stmt_p, copy_tree_body_r, (void *) &id, NULL);

@@ -617,7 +635,7 @@ free_wd (struct wrapper_data *wd)
*/

bool
-declare_one_free_variable (tree const &var0, tree *map0, wrapper_data &)
+declare_one_free_variable (tree var0, tree *map0)
{
const_tree var = var0;
tree map = *map0;
@@ -690,6 +708,9 @@ create_cilk_wrapper (tree exp, tree *args_out)
{
struct wrapper_data wd;
tree fndecl;
+ unsigned int j;
+ struct cilk_decls * c;
+ auto_vec<struct cilk_decls> vd;

init_wd (&wd, CILK_BLOCK_SPAWN);

@@ -710,7 +731,11 @@ create_cilk_wrapper (tree exp, tree *args_out)
}
else
extract_free_variables (exp, &wd, ADD_READ);
- wd.decl_map->traverse<wrapper_data &, declare_one_free_variable> (wd);
+ wd.decl_map->traverse<auto_vec<struct cilk_decls> *, fill_decls_vec> (&vd);
+ vd.qsort (compare_decls);
+ FOR_EACH_VEC_ELT (vd, j, c)
+ declare_one_free_variable (c->key, c->val);
+
wd.block = TREE_BLOCK (exp);
if (!wd.block)
wd.block = DECL_INITIAL (current_function_decl);