-#else
-
-/**
- * @file ifconv.c
- * If conversion.
- * Make Mux nodes from Conds where it its possible.
- * @author Sebastian Hack
- * @date 4.2.2005
- */
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#ifdef HAVE_STDLIB_H
-#include <stdlib.h>
-#endif
-#ifdef HAVE_STRING_H
-#include <string.h>
-#endif
-#ifdef HAVE_ALLOCA_H
-#include <alloca.h>
-#endif
-
-#include "irgraph_t.h"
-#include "irnode_t.h"
-#include "irgwalk.h"
-#include "iropt_t.h"
-#include "irgmod.h"
-#include "irmode_t.h"
-#include "ircons_t.h"
-#include "irdom_t.h"
-#include "irgwalk.h"
-
-#include "ifconv.h"
-#include "irflag_t.h"
-
-#include "irprintf.h"
-#include "debug.h"
-#include "obst.h"
-#include "set.h"
-#include "bitset.h"
-#include "bitfiddle.h"
-#include "irhooks.h"
-#include "return.h"
-
-#define MAX_DEPTH 4
-
-/**
- * check, if a node is const and return its tarval or
- * return a default tarval.
- * @param cnst The node whose tarval to get.
- * @param or The alternative tarval, if the node is no Const.
- * @return The tarval of @p cnst, if the node is Const, @p otherwise.
- */
-static tarval *get_value_or(ir_node *cnst, tarval *or)
-{
- return get_irn_op(cnst) == op_Const ? get_Const_tarval(cnst) : or;
-}
-
-
-/**
- * Try to optimize nested muxes into a dis- or conjunction
- * of two muxes.
- * @param mux The parent mux, which has muxes as operands.
- * @return The replacement node for this mux. If the optimization is
- * successful, this might be an And or Or node, if not, its the mux
- * himself.
- */
-static ir_node *optimize_mux_chain(ir_node *mux)
-{
- int i;
- ir_node *res;
- ir_node *ops[2];
- ir_mode *mode = get_irn_mode(mux);
- tarval *null;
- tarval *minus_one;
-
- /*
- * If we have no mux, or its mode is not integer, we
- * can return.
- */
- if(get_irn_op(mux) != op_Mux || !mode_is_int(mode))
- return mux;
-
- res = mux;
- null = get_mode_null(mode);
- minus_one = tarval_sub(null, get_tarval_one(mode));
-
- ops[0] = get_Mux_false(mux);
- ops[1] = get_Mux_true(mux);
-
- for(i = 0; i < 2; ++i) {
- ir_node *a, *b, *d;
- tarval *tva, *tvb, *tvd;
- ir_node *child_mux;
-
- /*
- * A mux operand at the first position can be factored
- * out, if the operands fulfill several conditions:
- *
- * mux(c1, mux(c2, a, b), d)
- *
- * This can be made into:
- * 1) mux(c1, 0, d) | mux(c2, a, b)
- * if a | d == d and b | d == d
- *
- * 2) mux(c1, -1, d) & mux(c2, a, b)
- * if a & d == d and a & b == b
- */
- if(get_irn_op(ops[i]) == op_Mux) {
-
- child_mux = ops[i];
- a = get_Mux_false(child_mux);
- b = get_Mux_true(child_mux);
- d = ops[1 - i];
-
- /* Try the or stuff */
- tva = get_value_or(a, minus_one);
- tvb = get_value_or(b, minus_one);
- tvd = get_value_or(d, null);
-
- if(tarval_cmp(tarval_or(tva, tvd), tvd) == pn_Cmp_Eq
- && tarval_cmp(tarval_or(tvb, tvd), tvd) == pn_Cmp_Eq) {
-
- ops[i] = new_Const(mode, null);
- res = new_r_Or(current_ir_graph, get_nodes_block(mux),
- mux, child_mux, mode);
- break;
- }
-
- /* If the or didn't go, try the and stuff */
- tva = get_value_or(a, null);
- tvb = get_value_or(b, null);
- tvd = get_value_or(d, minus_one);
-
- if(tarval_cmp(tarval_and(tva, tvd), tvd) == pn_Cmp_Eq
- && tarval_cmp(tarval_and(tvb, tvd), tvd) == pn_Cmp_Eq) {
-
- ops[i] = new_Const(mode, minus_one);
- res = new_r_And(current_ir_graph, get_nodes_block(mux),
- mux, child_mux, mode);
- break;
- }
- }
- }
-
- /* recursively optimize nested muxes. */
- set_irn_n(mux, 1, optimize_mux_chain(ops[0]));
- set_irn_n(mux, 2, optimize_mux_chain(ops[1]));
-
- return res;
-}
-
-
-/***********************************************************
- * The If conversion itself.
- ***********************************************************/
-
-/** allow every Mux to be created. */
-static int default_allow_mux(ir_node *sel, ir_node *false_res, ir_node *true_res) {
- return 1;
-}
-
-/**
- * Default options.
- */
-static const opt_if_conv_info_t default_info = {
- MAX_DEPTH,
- default_allow_mux
-};
-
-/** The debugging module. */
-DEBUG_ONLY(static firm_dbg_module_t *dbg;)
-
-/**
- * A simple check for side effects upto an opcode of a ir node.
- * @param irn The ir node to check,
- * @return 1 if the opcode itself may produce side effects, 0 if not.
- */
-static INLINE int has_side_effects(const ir_node *irn)
-{
- ir_op *op = get_irn_op(irn);
-
- if (op == op_Cmp)
- return 0;
-
- return !mode_is_datab(get_irn_mode(irn));
-}
-
-/**
- * Possible failure reasons
- */
-enum failure_reason_t {
- SUCCESS = IF_RESULT_SUCCESS,
- TO_DEEP = IF_RESULT_TOO_DEEP,
- SIDE_EFFECTS = IF_RESULT_SIDE_EFFECT,
- PHI_FOUND = IF_RESULT_SIDE_EFFECT_PHI,
- DENIED = IF_RESULT_DENIED
-};
-
-/**
- * Decides, if a given expression and its subexpressions
- * (to certain, also given extent) can be moved to a block.
- *
- * @param expr The expression to examine.
- * @param block The block where the expression should go.
- * @param depth The current depth, passed recursively. Use 0 for
- * non-recursive calls.
- * @param info The options for createing Mux nodes.
- * examined.
- *
- * @return a failure reason
- */
-static int _can_move_to(ir_node *expr, ir_node *dest_block, int depth, const opt_if_conv_info_t *info)
-{
- int i, n;
- int res = SUCCESS;
- ir_node *expr_block = get_nodes_block(expr);
-
- /*
- * If we are forced to look too deep into the expression,
- * treat it like it could not be moved.
- */
- if(depth >= info->max_depth) {
- res = TO_DEEP;
- goto end;
- }
-
- /*
- * If the block of the expression dominates the specified
- * destination block, it does not matter if the expression
- * has side effects or anything else. It is executed on each
- * path the destination block is reached.
- */
- if (block_dominates(expr_block, dest_block))
- goto end;
-
- /*
- * We cannot move phis!
- */
- if (is_Phi(expr)) {
- res = PHI_FOUND;
- goto end;
- }
-
- /*
- * This should be superfluous and could be converted into a assertion.
- * The destination block _must_ dominate the block of the expression,
- * else the expression could be used without its definition.
- */
- if (! block_dominates(dest_block, expr_block)) {
- res = IF_RESULT_SIDE_EFFECT;
- goto end;
- }
-
- /*
- * Surely, if the expression does not have a data mode, it is not
- * movable. Perhaps one should also test the floating property of
- * the opcode/node.
- */
- if (has_side_effects(expr)) {
- res = IF_RESULT_SIDE_EFFECT;
- goto end;
- }
-
- /*
- * If the node looks alright so far, look at its operands and
- * check them out. If one of them cannot be moved, this one
- * cannot be moved either.
- */
- for (i = 0, n = get_irn_arity(expr); i < n; ++i) {
- ir_node *op = get_irn_n(expr, i);
- int new_depth = is_Proj(op) ? depth : depth + 1;
-
- res = _can_move_to(op, dest_block, new_depth, info);
-
- if (res != SUCCESS)
- goto end;
- }
-
-end:
- DBG((dbg, LEVEL_3, "\t\t\tcan move to %n: %d\n", expr, res));
-
- return res;
-}
-
-/**
- * Convenience function for _can_move_to.
- * Checks, if an expression can be moved to another block. The check can
- * be limited to a expression depth meaning if we need to crawl in
- * deeper into an expression than a given threshold to examine if
- * it can be moved, the expression is rejected and the test returns
- * false.
- *
- * @param expr The expression to check for.
- * @param dest_block The destination block you want @p expr to be.
- * @param info The options for createing Mux nodes.
- *
- * @return return a failure reason
- */
-static INLINE int can_move_to(ir_node *expr, ir_node *dest_block, const opt_if_conv_info_t *info)
-{
- return _can_move_to(expr, dest_block, 0, info);
-}
-
-/**
- * move a DAG given by a root node expr into a new block
- *
- * @param expr the root of a dag
- * @param dest_block the destination block
- */
-static void move_to(ir_node *expr, ir_node *dest_block)
-{
- int i, n;
- ir_node *expr_block = get_nodes_block(expr);
-
- /*
- * If we reached the dominator, we are done.
- * We will never put code through the dominator
- */
- if (block_dominates(expr_block, dest_block))
- return;
-
- for (i = 0, n = get_irn_arity(expr); i < n; ++i)
- move_to(get_irn_n(expr, i), dest_block);
-
- set_nodes_block(expr, dest_block);
-}
-
-/**
- * return the common dominator of two blocks
- */
-static INLINE ir_node *common_idom(ir_node *b1, ir_node *b2)
-{
- if(block_dominates(b1, b2))
- return b1;
- else if(block_dominates(b2, b1))
- return b2;
- else {
- ir_node *p;
-
- for (p = get_Block_idom(b1); !block_dominates(p, b2); p = get_Block_idom(p));
- return p;
- }
-}
-
-/**
- * Information about a cond node.
- */
-typedef struct _cond_t {
- ir_node *cond; /**< The cond node. */
- struct list_head list; /**< List head which is used for queuing this cond
- into the cond bunch it belongs to. */
- unsigned is_new : 1;
- unsigned totally_covers : 1;
- struct _cond_t *link;
- long visited_nr;
-
- /**
- * Information about the both 'branches'
- * (true and false), the cond creates.
- */
- struct {
- int pos; /**< Number of the predecessor of the
- phi block by which this branch is
- reached. It is -1, if this branch is
- only reached through another cond. */
-
- struct _cond_t *masked_by; /**< If this cond's branch is only reached
- through another cond, we store this
- cond ir_node here. */
- } cases[2];
-} cond_t;
-
-/**
- * retrieve the conditional information from a Cond node
- */
-static INLINE cond_t *get_cond(ir_node *irn, set *cond_set)
-{
- cond_t templ;
-
- templ.cond = irn;
- return set_find(cond_set, &templ, sizeof(templ), HASH_PTR(templ.cond));
-}
-
-
-typedef void (cond_walker_t)(cond_t *cond, void *env);
-
-static void _walk_conds(cond_t *cond, cond_walker_t *pre, cond_walker_t *post,
- long visited_nr, void *env)
-{
- int i;
-
- if(cond->visited_nr >= visited_nr)
- return;
-
- cond->visited_nr = visited_nr;
-
- if(pre)
- pre(cond, env);
-
- for(i = 0; i < 2; ++i) {
- cond_t *c = cond->cases[i].masked_by;
-
- if(c)
- _walk_conds(c, pre, post, visited_nr, env);
- }
-
- if(post)
- post(cond, env);
-}
-
-static long cond_visited_nr = 0;
-
-static void walk_conds(cond_t *cond, cond_walker_t *pre, cond_walker_t *post, void *env)
-{
- _walk_conds(cond, pre, post, ++cond_visited_nr, env);
-}
-
-static void link_conds(cond_t *cond, void *env)
-{
- cond_t **ptr = (cond_t **) env;
-
- cond->link = *ptr;
- *ptr = cond;
-}
-
-/**
- * Compare two conds for use in a firm set.
- * Two cond_t's are equal, if they designate the same cond node.
- * @param a A cond_t.
- * @param b Another one.
- * @param size Not used.
- * @return 0 (!) if they are equal, != 0 otherwise.
- */
-static int cond_cmp(const void *a, const void *b, size_t size)
-{
- const cond_t *x = a;
- const cond_t *y = b;
- return x->cond != y->cond;
-}
-
-/**
- * Information about conds which can be made to muxes.
- * Instances of this struct are attached to the link field of
- * blocks in which phis are located.
- */
-typedef struct _cond_info_t {
- struct list_head list; /**< Used to list all of these structs per class. */
-
- struct list_head roots; /**< A list of non-depending Conds. Two Conds are
- independent, if it's not possible not reach one from the
- other (all Conds in this list have to dominate the
- block this struct is attached to). */
-
- ir_node *first_phi; /**< The first phi node this cond info was made for. */
- set *cond_set; /**< A set of all dominating reachable Conds. */
-} cond_info_t;
-
-/**
- * @see find_conds.
- */
-static void _find_conds(ir_node *irn, unsigned long visited_nr,
- ir_node *dominator, cond_t *masked_by, int pos, int depth, cond_info_t *ci)
-{
- ir_node *block;
- int saw_select_cond = 0;
-
- block = get_nodes_block(irn);
-
- /*
- * Only check this block if it is dominated by the specified
- * dominator or it has not been visited yet.
- */
- if (block_dominates(dominator, block) && get_Block_block_visited(block) < visited_nr) {
- cond_t *res = masked_by;
- int i, n;
-
- /* check, if we're on a ProjX
- *
- * Further, the ProjX/Cond block must dominate the base block
- * (the block with the phi in it), otherwise, the Cond
- * is not affecting the phi so that a mux can be inserted.
- */
- if(is_Proj(irn) && get_irn_mode(irn) == mode_X) {
-
- int proj = get_Proj_proj(irn);
- ir_node *cond = get_Proj_pred(irn);
-
- /* true, if the mode is a mode_b cond _NO_ switch cond */
- int is_modeb_cond = get_irn_opcode(cond) == iro_Cond
- && get_irn_mode(get_Cond_selector(cond)) == mode_b;
-
- saw_select_cond = !is_modeb_cond;
-
- /* Check, if the pred of the proj is a Cond
- * with a Projb as selector.
- */
- if(is_modeb_cond) {
- cond_t c;
-
- memset(&c, 0, sizeof(c));
- c.cond = cond;
- c.is_new = 1;
- c.cases[0].pos = -1;
- c.cases[1].pos = -1;
-
- /* get or insert the cond info into the set. */
- res = set_insert(ci->cond_set, &c, sizeof(c), HASH_PTR(cond));
-
- /*
- * If this cond is already masked by the masked_by cond
- * return immediately, since we don't have anything to add.
- */
- if(masked_by && res->cases[proj].masked_by == masked_by)
- return;
-
- if(res->is_new) {
- res->is_new = 0;
- list_add(&res->list, &ci->roots);
- }
-
- /*
- * Set masked by (either NULL or another cond node.
- * If this cond is truly masked by another one, set
- * the position of the actually investigated branch
- * to -1. Since the cond is masked by another one,
- * there could be more ways from the start block
- * to this branch, so we choose -1.
- */
- res->cases[proj].masked_by = masked_by;
-
- if(!masked_by)
- res->cases[proj].pos = pos;
-
- /*
- * Since the masked_by nodes masks a cond, remove it from the
- * root list of the conf trees.
- */
- else {
- assert(res->cases[proj].pos < 0);
- list_del_init(&masked_by->list);
- }
-
- DBG((dbg, LEVEL_2, "%n (%s branch) "
- "for pos %d in block %n reached by %n\n",
- cond, proj ? "true" : "false", pos,
- block, masked_by ? masked_by->cond : NULL));
- }
- }
-
- if(get_Block_block_visited(block) < visited_nr && !saw_select_cond) {
-
- set_Block_block_visited(block, visited_nr);
-
- /* Search recursively from this cond. */
- for(i = 0, n = get_irn_arity(block); i < n; ++i) {
- ir_node *pred = get_irn_n(block, i);
-
- /*
- * If the depth is 0 (the first recursion), we set the pos to
- * the current viewed predecessor, else we adopt the position
- * as given by the caller. We also increase the depth for the
- * recursively called functions.
- */
- _find_conds(pred, visited_nr, dominator, res, pos, depth + (res != masked_by), ci);
- }
- }
- }
-}
-
-
-/**
- * A convenience function for _find_conds.
- * It sets some parameters needed for recursion to appropriate start
- * values. Always use this function.
- *
- * @param irn The node to start looking for Conds from. This might
- * be the phi node we are investigating.
- * @param conds The set to record the found Conds in.
- */
-static INLINE void find_conds(ir_node *irn, cond_info_t *ci)
-{
- int i, n;
- unsigned long visited_nr;
- ir_node *block = get_nodes_block(irn);
- ir_node *dom = get_Block_idom(block);
-
- for(i = 0, n = get_irn_arity(block); i < n; ++i) {
- ir_node *pred = get_irn_n(block, i);
-
- inc_irg_block_visited(current_ir_graph);
- visited_nr = get_irg_block_visited(current_ir_graph);
- set_Block_block_visited(block, visited_nr);
-
- DBG((dbg, LEVEL_2, "find conds at pred %d (%n) and idom %n\n", i, pred, dom));
- _find_conds(pred, visited_nr, dom, NULL, i, 0, ci);
- }
-}
-
-/**
- * Make the mux for a given cond.
- *
- * @param phi The phi node which shall be replaced by a mux.
- * @param dom The block where the muxes shall be placed.
- * @param cond The cond information.
- * @param info The options for createing Mux nodes.
- * @return The mux node made for this cond.
- */
-static ir_node *make_mux_on_demand(ir_node *phi, ir_node *dom, cond_t *cond,
- const opt_if_conv_info_t *info, ir_node **mux, bitset_t *positions,
- int *muxes_made, long visited_nr)