/**
* Copies a node to a new irg. The Ins of the new node point to
* the predecessors on the old irg. n->link points to the new node.
*
* @param n The node to be copied
* @param irg the new irg
*
* Does NOT copy standard nodes like Start, End etc that are fixed
* in an irg. Instead, the corresponding nodes of the new irg are returned.
* Note further, that the new nodes have no block.
*/
static void copy_irn_to_irg(ir_node *n, ir_graph *irg)
{
/* do not copy standard nodes */
ir_node *nn = NULL;
switch (get_irn_opcode(n)) {
case iro_NoMem:
nn = get_irg_no_mem(irg);
break;
case iro_Block: {
ir_graph *old_irg = get_irn_irg(n);
if (n == get_irg_start_block(old_irg))
nn = get_irg_start_block(irg);
else if (n == get_irg_end_block(old_irg))
nn = get_irg_end_block(irg);
break;
}
case iro_Start:
nn = get_irg_start(irg);
break;
case iro_End:
nn = get_irg_end(irg);
break;
case iro_Proj: {
ir_graph *old_irg = get_irn_irg(n);
if (n == get_irg_frame(old_irg))
nn = get_irg_frame(irg);
else if (n == get_irg_initial_mem(old_irg))
nn = get_irg_initial_mem(irg);
else if (n == get_irg_args(old_irg))
nn = get_irg_args(irg);
break;
}
}
if (nn) {
set_irn_link(n, nn);
return;
}
nn = new_ir_node(get_irn_dbg_info(n),
irg,
NULL, /* no block yet, will be set later */
get_irn_op(n),
get_irn_mode(n),
get_irn_arity(n),
get_irn_in(n));
/* Copy the attributes. These might point to additional data. If this
was allocated on the old obstack the pointers now are dangling. This
frees e.g. the memory of the graph_arr allocated in new_immBlock. */
copy_node_attr(irg, n, nn);
set_irn_link(n, nn);
}
/**
* implementation of create_set_func which produces a cond with control
* flow
*/
static ir_node *create_cond_set(ir_node *cond_value, ir_mode *dest_mode)
{
ir_node *lower_block = part_block_edges(cond_value);
ir_node *upper_block = get_nodes_block(cond_value);
foreach_out_edge_safe(upper_block, edge) {
/* The cached nodes might belong to the lower block, so we have
* to clear the cache for moved nodes to avoid dominance problems. */
ir_node *node = get_edge_src_irn(edge);
set_irn_link(node, NULL);
}
void Worklist::cleanUp()
{
walk_topological(functionGraph, [&] (ir_node * node, void*)
{
handler.cleanUp(Node(node));
}, NULL);
walk_topological(functionGraph, [](ir_node * node, void*)
{
set_irn_link(node, (void*)NULL);
}, NULL);
}
/**
* return an DAG entry for the node n
*/
static dag_entry_t *get_irn_dag_entry(const ir_node *n)
{
dag_entry_t *p = (dag_entry_t*)get_irn_link(n);
if (p) {
/* skip any dead links */
if (p->link) {
do {
p = p->link;
} while (p->link != NULL);
/* hacky cast to ir_node* */
set_irn_link((ir_node*)n, p);
}
}
return p;
}
/*
* Normalize the Returns of a graph by moving
* the Returns upwards as much as possible.
* This might be preferred for code generation.
*
* In pseudocode, it means:
*
* if (a)
* res = b;
* else
* res = c;
* return res;
*
* is transformed into
*
* if (a)
* return b;
* else
* return c;
*/
void normalize_n_returns(ir_graph *irg)
{
int i, j, n;
ir_node *list = NULL;
ir_node *final = NULL;
unsigned n_rets = 0;
unsigned n_finals = 0;
ir_node *endbl = get_irg_end_block(irg);
int n_ret_vals;
ir_node **in;
ir_node *end;
/*
* First, link all returns:
* These must be predecessors of the endblock.
* Place Returns that can be moved on list, all others
* on final.
*/
n = get_Block_n_cfgpreds(endbl);
for (i = 0; i < n; ++i) {
ir_node *ret = get_Block_cfgpred(endbl, i);
if (is_Bad(ret)) {
continue;
} else if (is_Return(ret) && can_move_ret(ret)) {
/*
* Ok, all conditions met, we can move this Return, put it
* on our work list.
*/
set_irn_link(ret, list);
list = ret;
++n_rets;
} else {
/* Put all nodes that are not changed on the final list. */
set_irn_link(ret, final);
final = ret;
++n_finals;
}
}
/**
* Pre-Walker: Copies blocks and nodes from the original method graph
* to the copied graph.
*
* @param n A node from the original method graph.
* @param env The copied graph.
*/
static void copy_all_nodes(ir_node *node, void *env)
{
ir_graph *irg = (ir_graph*)env;
ir_node *new_node = irn_copy_into_irg(node, irg);
set_irn_link(node, new_node);
/* fix access to entities on the stack frame */
if (is_Member(new_node)) {
ir_entity *ent = get_Member_entity(new_node);
ir_type *tp = get_entity_owner(ent);
if (is_frame_type(tp)) {
/* replace by the copied entity */
ent = (ir_entity*)get_entity_link(ent);
assert(is_entity(ent));
assert(get_entity_owner(ent) == get_irg_frame_type(irg));
set_Member_entity(new_node, ent);
}
}
}
Worklist::Worklist(ir_graph* functionGraph, GraphHandler& handler): functionGraph(functionGraph), handler(handler)
{
typedef void (*ir_func)(ir_node*, void*);
struct envMembers
{
std::queue<ir_node*>* pQueue;
std::unordered_map<ir_node*, bool>* pIsQueued;
};
envMembers envInstance;
envInstance.pQueue = &this->worklist;
envInstance.pIsQueued = &this->isQueued;
ir_func addPhis = [](ir_node * node, void* env)
{
if (is_Phi(node))
{
auto envInstance = (envMembers*)env;
set_irn_link(node, (void*)tarval_unknown);
envInstance->pQueue->push(node);
(*envInstance->pIsQueued)[node] = true;
}
};
ir_func addToWorklist = [](ir_node * node, void* env)
{
if (is_Phi(node))
return;
auto envInstance = (envMembers*)env;
ir_tarval* tarval;
auto isBadNode = [&] (Node node) -> bool
{
if (is_Call(node) || is_Load(node) || is_Start(node))
return true;
/*else if (Node(node).getChildCount() > 0)
{
for (Node child : Node(node).getChildren())
if (child.getTarval() == tarval_bad)
return true;
}*/
return false;
};
// TODO: Support other modes such as Bu, Lu
if (is_Const(node) && Node(node).getTarval().isNumeric())
tarval = get_Const_tarval(node);
else if (isBadNode(Node(node)))
tarval = tarval_bad;
else
tarval = tarval_unknown;
set_irn_link(node, (void*)tarval);
envInstance->pQueue->push(node);
(*envInstance->pIsQueued)[node] = true;
};
walk_topological(functionGraph, addPhis, (void*)&envInstance);
walk_topological(functionGraph, addToWorklist, (void*)&envInstance);
}
/**
* Walk recursive the successors of a graph argument
* with mode reference and mark if it will be read,
* written or stored.
*
* @param arg The graph argument with mode reference,
* that must be checked.
*/
static ptr_access_kind analyze_arg(ir_node *arg, ptr_access_kind bits)
{
/* We must visit a node once to avoid endless recursion.*/
mark_irn_visited(arg);
for (int i = get_irn_n_outs(arg); i-- > 0; ) {
ir_node *succ = get_irn_out(arg, i);
if (irn_visited(succ))
continue;
/* We should not walk over the memory edge.*/
if (get_irn_mode(succ) == mode_M)
continue;
/* If we reach with the recursion a Call node and our reference
isn't the address of this Call we accept that the reference will
be read and written if the graph of the method represented by
"Call" isn't computed else we analyze that graph. If our
reference is the address of this
Call node that mean the reference will be read.*/
switch (get_irn_opcode(succ)) {
case iro_Call: {
ir_node *ptr = get_Call_ptr(succ);
if (ptr == arg) {
/* Hmm: not sure what this is, most likely a read */
bits |= ptr_access_read;
} else {
ir_entity *meth_ent;
if (is_SymConst_addr_ent(ptr)) {
meth_ent = get_SymConst_entity(ptr);
for (int p = get_Call_n_params(succ); p-- > 0; ) {
if (get_Call_param(succ, p) == arg) {
/* an arg can be used more than once ! */
bits |= get_method_param_access(meth_ent, p);
}
}
} else if (is_Sel(ptr) && get_irp_callee_info_state() == irg_callee_info_consistent) {
/* is be a polymorphic call but callee information is available */
size_t n_params = get_Call_n_params(succ);
/* simply look into ALL possible callees */
for (int c = get_Call_n_callees(succ); c-- > 0; ) {
meth_ent = get_Call_callee(succ, c);
/* unknown_entity is used to signal that we don't know what is called */
if (is_unknown_entity(meth_ent)) {
bits |= ptr_access_all;
break;
}
for (size_t p = n_params; p-- > 0; ) {
if (get_Call_param(succ, p) == arg) {
/* an arg can be used more than once ! */
bits |= get_method_param_access(meth_ent, p);
}
}
}
} else /* can do anything */
bits |= ptr_access_all;
}
/* search stops here anyway */
continue;
}
case iro_Store:
/* We have reached a Store node => the reference is written or stored. */
if (get_Store_ptr(succ) == arg) {
/* written to */
bits |= ptr_access_write;
} else {
/* stored itself */
bits |= ptr_access_store;
}
/* search stops here anyway */
continue;
case iro_Load:
/* We have reached a Load node => the reference is read. */
bits |= ptr_access_read;
/* search stops here anyway */
continue;
case iro_Conv:
/* our address is casted into something unknown. Break our search. */
bits = ptr_access_all;
break;
default:
break;
}
/* If we know that, the argument will be read, write and stored, we
can break the recursion.*/
if (bits == ptr_access_all) {
bits = ptr_access_all;
break;
}
/*
* A calculation that do not lead to a reference mode ends our search.
* This is dangerous: It would allow to cast into integer and that cast back ...
* so, when we detect a Conv we go mad, see the Conv case above.
*/
if (!mode_is_reference(get_irn_mode(succ)))
continue;
/* follow further the address calculation */
bits = analyze_arg(succ, bits);
}
set_irn_link(arg, NULL);
return bits;
}
/**
* Compute the weight of a method parameter
*
* @param arg The parameter them weight muss be computed.
*/
static unsigned calc_method_param_weight(ir_node *arg)
{
/* We mark the nodes to avoid endless recursion */
mark_irn_visited(arg);
unsigned weight = null_weight;
for (int i = get_irn_n_outs(arg); i-- > 0; ) {
ir_node *succ = get_irn_out(arg, i);
if (irn_visited(succ))
continue;
/* We should not walk over the memory edge.*/
if (get_irn_mode(succ) == mode_M)
continue;
switch (get_irn_opcode(succ)) {
case iro_Call:
if (get_Call_ptr(succ) == arg) {
/* the arguments is used as an pointer input for a call,
we can probably change an indirect Call into a direct one. */
weight += indirect_call_weight;
}
break;
case iro_Cmp: {
/* We have reached a cmp and we must increase the
weight with the cmp_weight. */
ir_node *op;
if (get_Cmp_left(succ) == arg)
op = get_Cmp_right(succ);
else
op = get_Cmp_left(succ);
if (is_irn_constlike(op)) {
weight += const_cmp_weight;
} else
weight += cmp_weight;
break;
}
case iro_Cond:
/* the argument is used for a SwitchCond, a big win */
weight += const_cmp_weight * get_irn_n_outs(succ);
break;
case iro_Id:
/* when looking backward we might find Id nodes */
weight += calc_method_param_weight(succ);
break;
case iro_Tuple:
/* unoptimized tuple */
for (int j = get_Tuple_n_preds(succ); j-- > 0; ) {
ir_node *pred = get_Tuple_pred(succ, j);
if (pred == arg) {
/* look for Proj(j) */
for (int k = get_irn_n_outs(succ); k-- > 0; ) {
ir_node *succ_succ = get_irn_out(succ, k);
if (is_Proj(succ_succ)) {
if (get_Proj_proj(succ_succ) == j) {
/* found */
weight += calc_method_param_weight(succ_succ);
}
} else {
/* this should NOT happen */
}
}
}
}
break;
default:
if (is_binop(succ)) {
/* We have reached a BinOp and we must increase the
weight with the binop_weight. If the other operand of the
BinOp is a constant we increase the weight with const_binop_weight
and call the function recursive.
*/
ir_node *op;
if (get_binop_left(succ) == arg)
op = get_binop_right(succ);
else
op = get_binop_left(succ);
if (is_irn_constlike(op)) {
weight += const_binop_weight;
weight += calc_method_param_weight(succ);
} else
weight += binop_weight;
} else if (get_irn_arity(succ) == 1) {
/* We have reached a binop and we must increase the
weight with the const_binop_weight and call the function
recursive.*/
weight += const_binop_weight;
weight += calc_method_param_weight(succ);
}
break;
}
}
set_irn_link(arg, NULL);
return weight;
}
void be_set_transformed_node(ir_node *old_node, ir_node *new_node)
{
set_irn_link(old_node, new_node);
mark_irn_visited(old_node);
}
static void set_vnum(ir_node *node, unsigned vnum)
{
set_irn_link(node, INT_TO_PTR(vnum));
}
