#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tree.h"
#include "tm.h"
#include "tree-flow.h"
#include "tree-gimple.h"
#include "tree-iterator.h"
#include "tree-pass.h"
#include "flags.h"
static tree
gimplify_val (block_stmt_iterator *bsi, tree type, tree exp)
{
tree t, new_stmt, orig_stmt;
if (is_gimple_val (exp))
return exp;
t = make_rename_temp (type, NULL);
new_stmt = build (MODIFY_EXPR, type, t, exp);
orig_stmt = bsi_stmt (*bsi);
SET_EXPR_LOCUS (new_stmt, EXPR_LOCUS (orig_stmt));
TREE_BLOCK (new_stmt) = TREE_BLOCK (orig_stmt);
bsi_insert_before (bsi, new_stmt, BSI_SAME_STMT);
return t;
}
static tree
extract_component (block_stmt_iterator *bsi, tree t, bool imagpart_p)
{
tree ret, inner_type;
inner_type = TREE_TYPE (TREE_TYPE (t));
switch (TREE_CODE (t))
{
case COMPLEX_CST:
ret = (imagpart_p ? TREE_IMAGPART (t) : TREE_REALPART (t));
break;
case COMPLEX_EXPR:
ret = TREE_OPERAND (t, imagpart_p);
break;
case VAR_DECL:
case PARM_DECL:
ret = build1 ((imagpart_p ? IMAGPART_EXPR : REALPART_EXPR),
inner_type, t);
break;
default:
abort ();
}
return gimplify_val (bsi, inner_type, ret);
}
static tree
do_binop (block_stmt_iterator *bsi, enum tree_code code,
tree type, tree a, tree b)
{
tree ret;
ret = fold (build (code, type, a, b));
STRIP_NOPS (ret);
return gimplify_val (bsi, type, ret);
}
static tree
do_unop (block_stmt_iterator *bsi, enum tree_code code, tree type, tree a)
{
tree ret;
ret = fold (build1 (code, type, a));
STRIP_NOPS (ret);
return gimplify_val (bsi, type, ret);
}
static void
update_complex_assignment (block_stmt_iterator *bsi, tree r, tree i)
{
tree stmt = bsi_stmt (*bsi);
tree type;
modify_stmt (stmt);
if (TREE_CODE (stmt) == RETURN_EXPR)
stmt = TREE_OPERAND (stmt, 0);
type = TREE_TYPE (TREE_OPERAND (stmt, 1));
TREE_OPERAND (stmt, 1) = build (COMPLEX_EXPR, type, r, i);
}
static void
expand_complex_addition (block_stmt_iterator *bsi, tree inner_type,
tree ar, tree ai, tree br, tree bi,
enum tree_code code)
{
tree rr, ri;
rr = do_binop (bsi, code, inner_type, ar, br);
ri = do_binop (bsi, code, inner_type, ai, bi);
update_complex_assignment (bsi, rr, ri);
}
static void
expand_complex_multiplication (block_stmt_iterator *bsi, tree inner_type,
tree ar, tree ai, tree br, tree bi)
{
tree t1, t2, t3, t4, rr, ri;
t1 = do_binop (bsi, MULT_EXPR, inner_type, ar, br);
t2 = do_binop (bsi, MULT_EXPR, inner_type, ai, bi);
t3 = do_binop (bsi, MULT_EXPR, inner_type, ar, bi);
if (ar == br && ai == bi)
t4 = t3;
else
t4 = do_binop (bsi, MULT_EXPR, inner_type, ai, br);
rr = do_binop (bsi, MINUS_EXPR, inner_type, t1, t2);
ri = do_binop (bsi, PLUS_EXPR, inner_type, t3, t4);
update_complex_assignment (bsi, rr, ri);
}
static void
expand_complex_div_straight (block_stmt_iterator *bsi, tree inner_type,
tree ar, tree ai, tree br, tree bi,
enum tree_code code)
{
tree rr, ri, div, t1, t2, t3;
t1 = do_binop (bsi, MULT_EXPR, inner_type, br, br);
t2 = do_binop (bsi, MULT_EXPR, inner_type, bi, bi);
div = do_binop (bsi, PLUS_EXPR, inner_type, t1, t2);
t1 = do_binop (bsi, MULT_EXPR, inner_type, ar, br);
t2 = do_binop (bsi, MULT_EXPR, inner_type, ai, bi);
t3 = do_binop (bsi, PLUS_EXPR, inner_type, t1, t2);
rr = do_binop (bsi, code, inner_type, t3, div);
t1 = do_binop (bsi, MULT_EXPR, inner_type, ai, br);
t2 = do_binop (bsi, MULT_EXPR, inner_type, ar, bi);
t3 = do_binop (bsi, MINUS_EXPR, inner_type, t1, t2);
ri = do_binop (bsi, code, inner_type, t3, div);
update_complex_assignment (bsi, rr, ri);
}
static void
expand_complex_div_wide (block_stmt_iterator *bsi, tree inner_type,
tree ar, tree ai, tree br, tree bi,
enum tree_code code)
{
tree rr, ri, ratio, div, t1, t2, min, max, cond;
t1 = do_unop (bsi, ABS_EXPR, inner_type, br);
t2 = do_unop (bsi, ABS_EXPR, inner_type, bi);
cond = fold (build (LT_EXPR, boolean_type_node, t1, t2));
STRIP_NOPS (cond);
if (TREE_CONSTANT (cond))
{
if (integer_zerop (cond))
min = bi, max = br;
else
min = br, max = bi;
}
else
{
basic_block bb_cond, bb_true, bb_false, bb_join;
tree l1, l2, l3;
edge e;
l1 = create_artificial_label ();
t1 = build (GOTO_EXPR, void_type_node, l1);
l2 = create_artificial_label ();
t2 = build (GOTO_EXPR, void_type_node, l2);
cond = build (COND_EXPR, void_type_node, cond, t1, t2);
bsi_insert_before (bsi, cond, BSI_SAME_STMT);
min = make_rename_temp (inner_type, NULL);
max = make_rename_temp (inner_type, NULL);
l3 = create_artificial_label ();
e = split_block (bsi->bb, cond);
bb_cond = e->src;
bb_join = e->dest;
bb_true = create_empty_bb (bb_cond);
bb_false = create_empty_bb (bb_true);
e->flags = EDGE_TRUE_VALUE;
redirect_edge_succ (e, bb_true);
make_edge (bb_cond, bb_false, EDGE_FALSE_VALUE);
make_edge (bb_true, bb_join, 0);
make_edge (bb_false, bb_join, 0);
if (dom_computed[CDI_DOMINATORS] >= DOM_CONS_OK)
{
set_immediate_dominator (CDI_DOMINATORS, bb_true, bb_cond);
set_immediate_dominator (CDI_DOMINATORS, bb_false, bb_cond);
}
*bsi = bsi_start (bb_true);
t1 = build (LABEL_EXPR, void_type_node, l1);
bsi_insert_after (bsi, t1, BSI_NEW_STMT);
t1 = build (MODIFY_EXPR, inner_type, min, br);
bsi_insert_after (bsi, t1, BSI_NEW_STMT);
t1 = build (MODIFY_EXPR, inner_type, max, bi);
bsi_insert_after (bsi, t1, BSI_NEW_STMT);
*bsi = bsi_start (bb_false);
t1 = build (LABEL_EXPR, void_type_node, l2);
bsi_insert_after (bsi, t1, BSI_NEW_STMT);
t1 = build (MODIFY_EXPR, inner_type, min, bi);
bsi_insert_after (bsi, t1, BSI_NEW_STMT);
t1 = build (MODIFY_EXPR, inner_type, max, br);
bsi_insert_after (bsi, t1, BSI_NEW_STMT);
*bsi = bsi_start (bb_join);
t1 = build (LABEL_EXPR, void_type_node, l3);
bsi_insert_before (bsi, t1, BSI_SAME_STMT);
}
ratio = do_binop (bsi, code, inner_type, min, max);
t1 = do_binop (bsi, MULT_EXPR, inner_type, min, ratio);
div = do_binop (bsi, PLUS_EXPR, inner_type, t1, max);
t1 = do_binop (bsi, MULT_EXPR, inner_type, ai, ratio);
t2 = do_binop (bsi, PLUS_EXPR, inner_type, ar, t1);
rr = do_binop (bsi, code, inner_type, t2, div);
t1 = do_binop (bsi, MULT_EXPR, inner_type, ar, ratio);
t2 = do_binop (bsi, MINUS_EXPR, inner_type, ai, t1);
ri = do_binop (bsi, code, inner_type, t2, div);
update_complex_assignment (bsi, rr, ri);
}
static void
expand_complex_division (block_stmt_iterator *bsi, tree inner_type,
tree ar, tree ai, tree br, tree bi,
enum tree_code code)
{
switch (flag_complex_divide_method)
{
case 0:
expand_complex_div_straight (bsi, inner_type, ar, ai, br, bi, code);
break;
case 1:
expand_complex_div_wide (bsi, inner_type, ar, ai, br, bi, code);
break;
default:
abort ();
}
}
static void
expand_complex_negation (block_stmt_iterator *bsi, tree inner_type,
tree ar, tree ai)
{
tree rr, ri;
rr = do_unop (bsi, NEGATE_EXPR, inner_type, ar);
ri = do_unop (bsi, NEGATE_EXPR, inner_type, ai);
update_complex_assignment (bsi, rr, ri);
}
static void
expand_complex_conjugate (block_stmt_iterator *bsi, tree inner_type,
tree ar, tree ai)
{
tree ri;
ri = do_unop (bsi, NEGATE_EXPR, inner_type, ai);
update_complex_assignment (bsi, ar, ri);
}
static void
expand_complex_comparison (block_stmt_iterator *bsi, tree ar, tree ai,
tree br, tree bi, enum tree_code code)
{
tree cr, ci, cc, stmt, type;
cr = do_binop (bsi, code, boolean_type_node, ar, br);
ci = do_binop (bsi, code, boolean_type_node, ai, bi);
cc = do_binop (bsi, (code == EQ_EXPR ? TRUTH_AND_EXPR : TRUTH_OR_EXPR),
boolean_type_node, cr, ci);
stmt = bsi_stmt (*bsi);
modify_stmt (stmt);
switch (TREE_CODE (stmt))
{
case RETURN_EXPR:
stmt = TREE_OPERAND (stmt, 0);
case MODIFY_EXPR:
type = TREE_TYPE (TREE_OPERAND (stmt, 1));
TREE_OPERAND (stmt, 1) = convert (type, cc);
break;
case COND_EXPR:
TREE_OPERAND (stmt, 0) = cc;
break;
default:
abort ();
}
}
static void
expand_complex_operations_1 (block_stmt_iterator *bsi)
{
tree stmt = bsi_stmt (*bsi);
tree rhs, type, inner_type;
tree ac, ar, ai, bc, br, bi;
enum tree_code code;
switch (TREE_CODE (stmt))
{
case RETURN_EXPR:
stmt = TREE_OPERAND (stmt, 0);
if (!stmt)
return;
if (TREE_CODE (stmt) != MODIFY_EXPR)
return;
case MODIFY_EXPR:
rhs = TREE_OPERAND (stmt, 1);
break;
case COND_EXPR:
rhs = TREE_OPERAND (stmt, 0);
break;
default:
return;
}
type = TREE_TYPE (rhs);
code = TREE_CODE (rhs);
switch (code)
{
case PLUS_EXPR:
case MINUS_EXPR:
case MULT_EXPR:
case TRUNC_DIV_EXPR:
case CEIL_DIV_EXPR:
case FLOOR_DIV_EXPR:
case ROUND_DIV_EXPR:
case RDIV_EXPR:
case NEGATE_EXPR:
case CONJ_EXPR:
if (TREE_CODE (type) != COMPLEX_TYPE)
return;
inner_type = TREE_TYPE (type);
break;
case EQ_EXPR:
case NE_EXPR:
inner_type = TREE_TYPE (TREE_OPERAND (rhs, 1));
if (TREE_CODE (inner_type) != COMPLEX_TYPE)
return;
break;
default:
return;
}
ac = TREE_OPERAND (rhs, 0);
ar = extract_component (bsi, ac, 0);
ai = extract_component (bsi, ac, 1);
if (TREE_CODE_CLASS (code) == '1')
bc = br = bi = NULL;
else
{
bc = TREE_OPERAND (rhs, 1);
if (ac == bc)
br = ar, bi = ai;
else
{
br = extract_component (bsi, bc, 0);
bi = extract_component (bsi, bc, 1);
}
}
switch (code)
{
case PLUS_EXPR:
case MINUS_EXPR:
expand_complex_addition (bsi, inner_type, ar, ai, br, bi, code);
break;
case MULT_EXPR:
expand_complex_multiplication (bsi, inner_type, ar, ai, br, bi);
break;
case TRUNC_DIV_EXPR:
case CEIL_DIV_EXPR:
case FLOOR_DIV_EXPR:
case ROUND_DIV_EXPR:
case RDIV_EXPR:
expand_complex_division (bsi, inner_type, ar, ai, br, bi, code);
break;
case NEGATE_EXPR:
expand_complex_negation (bsi, inner_type, ar, ai);
break;
case CONJ_EXPR:
expand_complex_conjugate (bsi, inner_type, ar, ai);
break;
case EQ_EXPR:
case NE_EXPR:
expand_complex_comparison (bsi, ar, ai, br, bi, code);
break;
default:
abort ();
}
}
static void
expand_complex_operations (void)
{
int old_last_basic_block = last_basic_block;
block_stmt_iterator bsi;
basic_block bb;
FOR_EACH_BB (bb)
{
if (bb->index >= old_last_basic_block)
continue;
for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
expand_complex_operations_1 (&bsi);
}
}
struct tree_opt_pass pass_lower_complex =
{
"complex",
NULL,
expand_complex_operations,
NULL,
NULL,
0,
0,
PROP_cfg,
0,
0,
0,
TODO_dump_func | TODO_rename_vars
| TODO_ggc_collect | TODO_verify_ssa
| TODO_verify_stmts | TODO_verify_flow
};