#include "irhooks.h"
#include "irarch.h"
#include "hashptr.h"
-#include "opt_polymorphy.h"
#include "irtools.h"
#include "irhooks.h"
#include "array_t.h"
#include "bitfiddle.h"
#include "be.h"
-/* Make types visible to allow most efficient access */
#include "entity_t.h"
static bool is_Or_Eor_Add(const ir_node *node)
value_of_func value_of_ptr = default_value_of;
-/* * Set a new value_of function. */
void set_value_of_func(value_of_func func)
{
if (func != NULL)
return computed_value_Cmp_Confirm(cmp, left, right, relation);
}
+/**
+ * some people want to call compute_cmp directly, in this case we have to
+ * test the constant folding flag again
+ */
+static ir_tarval *compute_cmp_ext(const ir_node *cmp)
+{
+ if (!get_opt_constant_folding())
+ return tarval_bad;
+ return compute_cmp(cmp);
+}
+
/**
* Return the value of a Cmp.
*
static ir_tarval *computed_value_Cmp(const ir_node *cmp)
{
/* we can't construct Constb after lowering mode_b nodes */
- if (is_irg_state(get_irn_irg(cmp), IR_GRAPH_STATE_MODEB_LOWERED))
+ if (irg_is_constrained(get_irn_irg(cmp), IR_GRAPH_CONSTRAINT_MODEB_LOWERED))
return tarval_bad;
return compute_cmp(cmp);
if (ts == tarval_bad && is_Cmp(sel)) {
/* try again with a direct call to compute_cmp, as we don't care
* about the MODEB_LOWERED flag here */
- ts = compute_cmp(sel);
+ ts = compute_cmp_ext(sel);
}
/* Mux(true, f, t) == t */
ir_tarval *tv2;
ir_tarval *tv_bitop;
- if (!is_irg_state(irg, IR_GRAPH_STATE_NORMALISATION2))
+ if (!irg_is_constrained(irg, IR_GRAPH_CONSTRAINT_NORMALISATION2))
return n;
assert(is_And(n) || is_Or(n) || is_Eor(n) || is_Or_Eor_Add(n));
ir_graph *irg = get_irn_irg(n);
/* the following code leads to endless recursion when Mul are replaced
* by a simple instruction chain */
- if (!is_irg_state(irg, IR_GRAPH_STATE_ARCH_DEP)
+ if (!irg_is_constrained(irg, IR_GRAPH_CONSTRAINT_ARCH_DEP)
&& a == b && mode_is_int(mode)) {
ir_node *block = get_nodes_block(n);
if (ta == tarval_bad && is_Cmp(a)) {
/* try again with a direct call to compute_cmp, as we don't care
* about the MODEB_LOWERED flag here */
- ta = compute_cmp(a);
+ ta = compute_cmp_ext(a);
}
if (ta != tarval_bad && get_irn_mode(a) == mode_b) {
}
/* We might generate an endless loop, so keep it alive. */
add_End_keepalive(get_irg_end(irg), blk);
- clear_irg_state(irg, IR_GRAPH_STATE_NO_UNREACHABLE_CODE);
+ clear_irg_properties(irg, IR_GRAPH_PROPERTY_NO_UNREACHABLE_CODE);
}
return n;
}
ir_tarval *tv2;
ir_tarval *tv_shift;
- if (is_irg_state(irg, IR_GRAPH_STATE_NORMALISATION2))
+ if (irg_is_constrained(irg, IR_GRAPH_CONSTRAINT_NORMALISATION2))
return n;
assert(is_Shrs(n) || is_Shr(n) || is_Shl(n) || is_Rotl(n));
*/
static ir_node *transform_node_Proj_Load(ir_node *proj)
{
- if (get_opt_ldst_only_null_ptr_exceptions()) {
- if (get_irn_mode(proj) == mode_X) {
- ir_node *load = get_Proj_pred(proj);
+ if (get_irn_mode(proj) == mode_X) {
+ ir_node *load = get_Proj_pred(proj);
- /* get the Load address */
- const ir_node *addr = get_Load_ptr(load);
- const ir_node *confirm;
+ /* get the Load address */
+ const ir_node *addr = get_Load_ptr(load);
+ const ir_node *confirm;
- if (value_not_null(addr, &confirm)) {
- if (confirm == NULL) {
- /* this node may float if it did not depend on a Confirm */
- set_irn_pinned(load, op_pin_state_floats);
- }
- if (get_Proj_proj(proj) == pn_Load_X_except) {
- ir_graph *irg = get_irn_irg(proj);
- DBG_OPT_EXC_REM(proj);
- return new_r_Bad(irg, mode_X);
- } else {
- ir_node *blk = get_nodes_block(load);
- return new_r_Jmp(blk);
- }
+ if (value_not_null(addr, &confirm)) {
+ if (confirm == NULL) {
+ /* this node may float if it did not depend on a Confirm */
+ set_irn_pinned(load, op_pin_state_floats);
+ }
+ if (get_Proj_proj(proj) == pn_Load_X_except) {
+ ir_graph *irg = get_irn_irg(proj);
+ DBG_OPT_EXC_REM(proj);
+ return new_r_Bad(irg, mode_X);
+ } else {
+ ir_node *blk = get_nodes_block(load);
+ return new_r_Jmp(blk);
}
}
}
*/
static ir_node *transform_node_Proj_Store(ir_node *proj)
{
- if (get_opt_ldst_only_null_ptr_exceptions()) {
- if (get_irn_mode(proj) == mode_X) {
- ir_node *store = get_Proj_pred(proj);
+ if (get_irn_mode(proj) == mode_X) {
+ ir_node *store = get_Proj_pred(proj);
- /* get the load/store address */
- const ir_node *addr = get_Store_ptr(store);
- const ir_node *confirm;
+ /* get the load/store address */
+ const ir_node *addr = get_Store_ptr(store);
+ const ir_node *confirm;
- if (value_not_null(addr, &confirm)) {
- if (confirm == NULL) {
- /* this node may float if it did not depend on a Confirm */
- set_irn_pinned(store, op_pin_state_floats);
- }
- if (get_Proj_proj(proj) == pn_Store_X_except) {
- ir_graph *irg = get_irn_irg(proj);
- DBG_OPT_EXC_REM(proj);
- return new_r_Bad(irg, mode_X);
- } else {
- ir_node *blk = get_nodes_block(store);
- return new_r_Jmp(blk);
- }
+ if (value_not_null(addr, &confirm)) {
+ if (confirm == NULL) {
+ /* this node may float if it did not depend on a Confirm */
+ set_irn_pinned(store, op_pin_state_floats);
+ }
+ if (get_Proj_proj(proj) == pn_Store_X_except) {
+ ir_graph *irg = get_irn_irg(proj);
+ DBG_OPT_EXC_REM(proj);
+ return new_r_Bad(irg, mode_X);
+ } else {
+ ir_node *blk = get_nodes_block(store);
+ return new_r_Jmp(blk);
}
}
}
/**
* Test whether a block is unreachable
* Note: That this only returns true when
- * IR_GRAPH_STATE_OPTIMIZE_UNREACHABLE_CODE is set.
+ * IR_GRAPH_CONSTRAINT_OPTIMIZE_UNREACHABLE_CODE is set.
* This is important, as you easily end up producing invalid constructs in the
* unreachable code when optimizing away edges into the unreachable code.
* So only set this flag when you iterate localopts to the fixpoint.
static bool is_block_unreachable(const ir_node *block)
{
const ir_graph *irg = get_irn_irg(block);
- if (!is_irg_state(irg, IR_GRAPH_STATE_OPTIMIZE_UNREACHABLE_CODE))
+ if (!irg_is_constrained(irg, IR_GRAPH_CONSTRAINT_OPTIMIZE_UNREACHABLE_CODE))
return false;
return get_Block_dom_depth(block) < 0;
}
ir_node *bad = NULL;
int i;
- if (!is_irg_state(irg, IR_GRAPH_STATE_OPTIMIZE_UNREACHABLE_CODE))
+ if (!irg_is_constrained(irg, IR_GRAPH_CONSTRAINT_OPTIMIZE_UNREACHABLE_CODE))
return block;
for (i = 0; i < arity; ++i) {
/* the following optimisations create new mode_b nodes, so only do them
* before mode_b lowering */
- if (!is_irg_state(irg, IR_GRAPH_STATE_MODEB_LOWERED)) {
+ if (!irg_is_constrained(irg, IR_GRAPH_CONSTRAINT_MODEB_LOWERED)) {
if (is_Mux(t)) {
ir_node* block = get_nodes_block(n);
ir_node* c0 = sel;
CASE(Phi);
CASE(Proj);
CASE(Rotl);
- CASE(Sel);
CASE(Shl);
CASE(Shr);
CASE(Shrs);
/** Compares the attributes of two Phi nodes. */
static int node_cmp_attr_Phi(const ir_node *a, const ir_node *b)
{
- /* we can only enter this function if both nodes have the same number of inputs,
- hence it is enough to check if one of them is a Phi0 */
- if (is_Phi0(a)) {
- /* check the Phi0 pos attribute */
- return a->attr.phi.u.pos != b->attr.phi.u.pos;
+ (void) b;
+ /* do not CSE Phi-nodes without any inputs when building new graphs */
+ if (get_irn_arity(a) == 0 &&
+ get_irg_phase_state(get_irn_irg(a)) == phase_building) {
+ return 1;
}
return 0;
}
/** Compares the attributes of two ASM nodes. */
static int node_cmp_attr_ASM(const ir_node *a, const ir_node *b)
{
- int i, n;
+ size_t n;
+ size_t i;
const ir_asm_constraint *ca;
const ir_asm_constraint *cb;
ident **cla, **clb;
#undef CASE
}
-/*
- * Compare function for two nodes in the value table. Gets two
- * nodes as parameters. Returns 0 if the nodes are a Common Sub Expression.
- */
int identities_cmp(const void *elt, const void *key)
{
ir_node *a = (ir_node *)elt;
return 0;
}
-/*
- * Calculate a hash value of a node.
- *
- * @param node The IR-node
- */
unsigned ir_node_hash(const ir_node *node)
{
return node->op->ops.hash(node);
}
-
void new_identities(ir_graph *irg)
{
if (irg->value_table != NULL)
del_pset(irg->value_table);
}
-/* Normalize a node by putting constants (and operands with larger
- * node index) on the right (operator side). */
void ir_normalize_node(ir_node *n)
{
if (is_op_commutative(get_irn_op(n))) {
}
}
-/*
- * Return the canonical node computing the same value as n.
- * Looks up the node in a hash table, enters it in the table
- * if it isn't there yet.
- *
- * @param n the node to look up
- *
- * @return a node that computes the same value as n or n if no such
- * node could be found
- */
ir_node *identify_remember(ir_node *n)
{
ir_graph *irg = get_irn_irg(n);
return n;
}
-/* Add a node to the identities value table. */
void add_identities(ir_node *node)
{
if (!get_opt_cse())
identify_remember(node);
}
-/* Visit each node in the value table of a graph. */
void visit_all_identities(ir_graph *irg, irg_walk_func visit, void *env)
{
ir_node *node;
current_ir_graph = rem;
}
-/**
- * These optimizations deallocate nodes from the obstack.
- * It can only be called if it is guaranteed that no other nodes
- * reference this one, i.e., right after construction of a node.
- *
- * @param n The node to optimize
- */
ir_node *optimize_node(ir_node *n)
{
ir_node *oldn = n;
return n;
}
-
-/**
- * These optimizations never deallocate nodes (in place). This can cause dead
- * nodes lying on the obstack. Remove these by a dead node elimination,
- * i.e., a copying garbage collection.
- */
ir_node *optimize_in_place_2(ir_node *n)
{
if (!get_opt_optimize() && !is_Phi(n)) return n;
irn_verify(n);
/* Now we have a legal, useful node. Enter it in hash table for cse.
- * Blocks should be unique anyways. (Except the successor of start:
- * is cse with the start block!)
*
* Note: This is only necessary because some of the optimisations
* operate in-place (set_XXX_bla, turn_into_tuple, ...) which is considered
return n;
}
-/**
- * Wrapper for external use, set proper status bits after optimization.
- */
ir_node *optimize_in_place(ir_node *n)
{
ir_graph *irg = get_irn_irg(n);
/* FIXME: Maybe we could also test whether optimizing the node can
change the control graph. */
- clear_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_DOMINANCE);
+ clear_irg_properties(irg, IR_GRAPH_PROPERTY_CONSISTENT_DOMINANCE);
return optimize_in_place_2(n);
}
unsigned h;
/* special value for const, as they only differ in their tarval. */
- h = HASH_PTR(node->attr.con.tarval);
+ h = hash_ptr(node->attr.con.tarval);
return h;
}
unsigned h;
/* all others are pointers */
- h = HASH_PTR(node->attr.symc.sym.type_p);
+ h = hash_ptr(node->attr.symc.sym.type_p);
return h;
}
projects / libfirm / blobdiff