+/**
+ * Push nodes that do not need to be permed through the Perm.
+ * This is commonly a reload cascade at block ends.
+ * @note This routine needs interference.
+ * @note Probably, we can implement it a little more efficient.
+ * Especially searching the frontier lazily might be better.
+ *
+ * @param perm The perm
+ * @param env The lowerer environment
+ *
+ * @return 1, if there is something left to perm over.
+ * 0, if removed the complete perm.
+ */
+static int push_through_perm(ir_node *perm, lower_env_t *env)
+{
+ ir_graph *irg = get_irn_irg(perm);
+ ir_node *bl = get_nodes_block(perm);
+ ir_node *node;
+ int arity = get_irn_arity(perm);
+ int *map;
+ int *proj_map;
+ bitset_t *moved = bitset_alloca(arity);
+ int n_moved;
+ int new_size;
+ ir_node *frontier = bl;
+ ir_node *irn;
+ int i, n;
+
+ /* get some Proj and find out the register class of that Proj. */
+ const ir_edge_t *edge = get_irn_out_edge_first_kind(perm, EDGE_KIND_NORMAL);
+ ir_node *one_proj = get_edge_src_irn(edge);
+ const arch_register_class_t *cls = arch_get_irn_reg_class_out(one_proj);
+ assert(is_Proj(one_proj));
+
+ DB((dbg_permmove, LEVEL_1, "perm move %+F irg %+F\n", perm, irg));
+
+ /* Find the point in the schedule after which the
+ * potentially movable nodes must be defined.
+ * A Perm will only be pushed up to first instruction
+ * which lets an operand of itself die.
+ * If we would allow to move the Perm above this instruction,
+ * the former dead operand would be live now at the point of
+ * the Perm, increasing the register pressure by one.
+ */
+ sched_foreach_reverse_from(sched_prev(perm), irn) {
+ for (i = get_irn_arity(irn) - 1; i >= 0; --i) {
+ ir_node *op = get_irn_n(irn, i);
+ if (arch_irn_consider_in_reg_alloc(cls, op) &&
+ !values_interfere(env->birg, op, one_proj)) {
+ frontier = irn;
+ goto found_front;
+ }
+ }
+ }
+found_front:
+
+ DB((dbg_permmove, LEVEL_2, "\tfrontier: %+F\n", frontier));
+
+ node = sched_prev(perm);
+ n_moved = 0;
+ while (!sched_is_begin(node)) {
+ const arch_register_req_t *req;
+ int input = -1;
+ ir_node *proj;
+
+ /* search if node is a INPUT of Perm */
+ foreach_out_edge(perm, edge) {
+ ir_node *out = get_edge_src_irn(edge);
+ int pn = get_Proj_proj(out);
+ ir_node *in = get_irn_n(perm, pn);
+ if (node == in) {
+ proj = out;
+ input = pn;
+ break;
+ }
+ }
+ /* it wasn't an input to the perm, we can't do anything more */
+ if (input < 0)
+ break;
+ if (!sched_comes_after(frontier, node))
+ break;
+ if (arch_irn_is(node, modify_flags))
+ break;
+ req = arch_get_register_req_out(node);
+ if (req->type != arch_register_req_type_normal)
+ break;
+ for (i = get_irn_arity(node) - 1; i >= 0; --i) {
+ ir_node *opop = get_irn_n(node, i);
+ if (arch_irn_consider_in_reg_alloc(cls, opop)) {
+ break;
+ }
+ }
+ if (i >= 0)
+ break;
+
+ DBG((dbg_permmove, LEVEL_2, "\tmoving %+F after %+F, killing %+F\n", node, perm, proj));
+
+ /* move the movable node in front of the Perm */
+ sched_remove(node);
+ sched_add_after(perm, node);
+
+ /* give it the proj's register */
+ arch_set_irn_register(node, arch_get_irn_register(proj));
+
+ /* reroute all users of the proj to the moved node. */
+ edges_reroute(proj, node, irg);
+
+ /* and kill it */
+ set_Proj_pred(proj, new_Bad());
+ kill_node(proj);
+
+ bitset_set(moved, input);
+ n_moved++;
+
+ node = sched_prev(node);
+ }
+
+ /* well, we could not push anything through the perm */
+ if(n_moved == 0)
+ return 1;
+
+ new_size = arity - n_moved;
+ if(new_size == 0) {
+ sched_remove(perm);
+ kill_node(perm);
+ return 0;
+ }
+
+ map = ALLOCAN(int, new_size);
+ proj_map = ALLOCAN(int, arity);
+ memset(proj_map, -1, sizeof(proj_map[0]));
+ n = 0;
+ for (i = 0; i < arity; ++i) {
+ if (bitset_is_set(moved, i))
+ continue;
+ map[n] = i;
+ proj_map[i] = n;
+ n++;
+ }
+ assert(n == new_size);
+ foreach_out_edge(perm, edge) {
+ ir_node *proj = get_edge_src_irn(edge);
+ int pn = get_Proj_proj(proj);
+ pn = proj_map[pn];
+ assert(pn >= 0);
+ set_Proj_proj(proj, pn);
+ }
+
+ be_Perm_reduce(perm, new_size, map);
+ return 1;
+}