/*
- * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved.
+ * Copyright (C) 1995-2010 University of Karlsruhe. All right reserved.
*
* This file is part of libFirm.
*
#include "beirg.h"
#include "betranshlp.h"
#include "belive.h"
+#include "benode.h"
typedef struct be_transform_env_t {
ir_graph *irg; /**< The irg, the node should be created in */
add_irn_dep(node, get_irg_frame(irg));
}
+void be_set_transform_function(ir_op *op, be_transform_func func)
+{
+ /* shouldn't be assigned twice (except for exchanging the default
+ * be_duplicate_node entries) */
+ assert(op->ops.generic == NULL
+ || op->ops.generic == (op_func) be_duplicate_node);
+ op->ops.generic = (op_func) func;
+}
+
+void be_start_transform_setup(void)
+{
+ clear_irp_opcodes_generic_func();
+
+ be_set_transform_function(op_Bad, be_duplicate_node);
+ be_set_transform_function(op_be_Barrier, be_duplicate_node);
+ be_set_transform_function(op_be_Copy, be_duplicate_node);
+ be_set_transform_function(op_be_CopyKeep, be_duplicate_node);
+ be_set_transform_function(op_be_IncSP, be_duplicate_node);
+ be_set_transform_function(op_be_Keep, be_duplicate_node);
+ be_set_transform_function(op_be_Return, be_duplicate_node);
+ be_set_transform_function(op_be_Start, be_duplicate_node);
+ be_set_transform_function(op_NoMem, be_duplicate_node);
+ be_set_transform_function(op_Pin, be_duplicate_node);
+ be_set_transform_function(op_Start, be_duplicate_node);
+ be_set_transform_function(op_Sync, be_duplicate_node);
+}
+
ir_node *be_duplicate_node(ir_node *node)
{
ir_node *block = be_transform_node(get_nodes_block(node));
ir_node *be_transform_node(ir_node *node)
{
- ir_op *op;
- ir_node *new_node = be_get_transformed_node(node);
+ ir_op *op;
+ ir_node *new_node = be_get_transformed_node(node);
+ be_transform_func *transform;
if (new_node != NULL)
return new_node;
DEBUG_ONLY(be_set_transformed_node(node, NULL));
op = get_irn_op(node);
- if (op->ops.generic) {
- be_transform_func *transform = (be_transform_func *)op->ops.generic;
-
- new_node = transform(node);
- assert(new_node != NULL);
- } else {
- new_node = be_duplicate_node(node);
+ if (op->ops.generic == NULL) {
+ panic("No transform function registered for node %+F.", node);
}
+ transform = (be_transform_func *)op->ops.generic;
+
+ new_node = transform(node);
+ assert(new_node != NULL);
be_set_transformed_node(node, new_node);
hook_dead_node_elim_subst(current_ir_graph, node, new_node);
}
if (changed) {
- identify_remember(current_ir_graph->value_table, node);
+ identify_remember(node);
}
}
static ir_node *new_be_Anchor(ir_graph *irg)
{
- struct obstack *obst = be_get_birg_obst(irg);
+ struct obstack *obst = be_get_be_obst(irg);
backend_info_t *info;
ir_node *new_anchor;
fix_loops(anchor);
set_irn_n(new_anchor, i, anchor);
}
- set_nodes_block(new_anchor, get_irg_anchor(irg, anchor_end_block));
del_waitq(env.worklist);
free_End(old_end);
{
ir_graph *irg = current_ir_graph;
dbg_info *dbgi = get_irn_dbg_info(node);
- ir_node *macroblock = get_Block_MacroBlock(node);
ir_node *block;
block = new_ir_node(dbgi, irg, NULL, get_irn_op(node), get_irn_mode(node),
copy_node_attr(irg, node, block);
block->node_nr = node->node_nr;
- if (node == macroblock) {
- /* this node is a macroblock header */
- set_Block_MacroBlock(block, block);
- } else {
- macroblock = be_transform_node(macroblock);
- set_Block_MacroBlock(block, macroblock);
- }
-
/* put the preds in the worklist */
be_enqueue_preds(node);
return new_end;
}
-void be_transform_graph(be_irg_t *birg, arch_pretrans_nodes *func)
+void be_transform_graph(ir_graph *irg, arch_pretrans_nodes *func)
{
- ir_graph *irg = birg->irg;
ir_graph *old_current_ir_graph = current_ir_graph;
struct obstack *old_obst = NULL;
struct obstack *new_obst = NULL;
irg_invalidate_phases(irg);
/* create new value table for CSE */
- del_identities(irg->value_table);
- irg->value_table = new_identities();
+ new_identities(irg);
/* enter special helper */
op_Block->ops.generic = (op_func)gen_Block;
free_loop_information(irg);
set_irg_doms_inconsistent(irg);
- be_liveness_invalidate(be_get_birg_liveness(birg));
+ be_liveness_invalidate(be_get_irg_liveness(irg));
/* Hack for now, something is buggy with invalidate liveness... */
- birg->lv = NULL;
- be_invalidate_dom_front(birg);
+ be_birg_from_irg(irg)->lv = NULL;
+ be_invalidate_dom_front(irg);
/* recalculate edges */
edges_deactivate(irg);
edges_activate(irg);
+}
- if (birg->lv) {
- be_liveness_free(birg->lv);
- birg->lv = be_liveness(irg);
+int be_mux_is_abs(ir_node *sel, ir_node *mux_true, ir_node *mux_false)
+{
+ ir_node *cmp_left;
+ ir_node *cmp_right;
+ ir_node *cmp;
+ ir_mode *mode;
+ pn_Cmp pnc;
+
+ if (!is_Proj(sel))
+ return 0;
+ cmp = get_Proj_pred(sel);
+ if (!is_Cmp(cmp))
+ return 0;
+
+ /**
+ * Note further that these optimization work even for floating point
+ * with NaN's because -NaN == NaN.
+ * However, if +0 and -0 is handled differently, we cannot use the Abs/-Abs
+ * transformations.
+ */
+ mode = get_irn_mode(mux_true);
+ if (mode_honor_signed_zeros(mode))
+ return 0;
+
+ /* must be <, <=, >=, > */
+ pnc = get_Proj_proj(sel);
+ switch (pnc) {
+ case pn_Cmp_Ge:
+ case pn_Cmp_Gt:
+ case pn_Cmp_Le:
+ case pn_Cmp_Lt:
+ case pn_Cmp_Uge:
+ case pn_Cmp_Ug:
+ case pn_Cmp_Ul:
+ case pn_Cmp_Ule:
+ break;
+ default:
+ return 0;
}
+
+ if (!is_negated_value(mux_true, mux_false))
+ return 0;
+
+ /* must be x cmp 0 */
+ cmp_right = get_Cmp_right(cmp);
+ if (!is_Const(cmp_right) || !is_Const_null(cmp_right))
+ return 0;
+
+ cmp_left = get_Cmp_left(cmp);
+ if (cmp_left == mux_false) {
+ if (pnc & pn_Cmp_Lt) {
+ return 1;
+ } else {
+ assert(pnc & pn_Cmp_Gt);
+ return -1;
+ }
+ } else if (cmp_left == mux_true) {
+ if (pnc & pn_Cmp_Lt) {
+ return -1;
+ } else {
+ assert(pnc & pn_Cmp_Gt);
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+ir_node *be_get_abs_op(ir_node *sel)
+{
+ ir_node *cmp = get_Proj_pred(sel);
+ ir_node *cmp_left = get_Cmp_left(cmp);
+ return cmp_left;
}
projects / libfirm / blobdiff