- left = get_Add_left(node);
- right = get_Add_right(node);
-#if 0
- /* if we can do source address mode then we will never fold the add
- * into address mode */
- if((is_immediate_simple(right)) ||
- (!ia32_use_source_address_mode(get_nodes_block(node), left, right)
- && !ia32_use_source_address_mode(get_nodes_block(node), right, left)))
- {
- break;
+ /* only 1 user: AM folding is always beneficial */
+ if(get_irn_n_edges(node) <= 1)
+ break;
+
+ /* for adds and shls with multiple users we use this heuristic:
+ * we do not fold them into address mode if their operands don't live
+ * out of the block, because in this case we will reduce register
+ * pressure. Otherwise we fold them in aggressively in the hope, that
+ * the node itself doesn't exist anymore and we were able to save the
+ * register for the result */
+ block = get_nodes_block(node);
+ left = get_binop_left(node);
+ right = get_binop_right(node);
+
+ /* If both are live end not folding AM costs a register */
+ if(be_is_live_end(lv, block, left) && be_is_live_end(lv, block, right))
+ return;
+
+ /* if multiple nodes in this block use left/right values, then we
+ * can't really decide wether the values will die after node.
+ * We use aggressive mode then, since it's usually just multiple address
+ * calculations. */
+ foreach_out_edge(left, edge) {
+ ir_node *user = get_edge_src_irn(edge);
+ if(user != node && get_nodes_block(user) == block) {
+ foreach_out_edge(right, edge) {
+ ir_node *user = get_edge_src_irn(edge);
+ if(user != node && get_nodes_block(user) == block)
+ return;
+ }
+ break;
+ }