int add_irn_dep(ir_node *node, ir_node *dep) {
int res = 0;
+ /* DEP edges are only allowed in backend phase */
+ assert(get_irg_phase_state(get_irn_irg(node)) == phase_backend);
if (node->deps == NULL) {
node->deps = NEW_ARR_F(ir_node *, 1);
node->deps[0] = dep;
_set_irn_mode(node, mode);
}
-modecode get_irn_modecode(const ir_node *node) {
+ir_modecode get_irn_modecode(const ir_node *node) {
assert(node);
return node->mode->code;
}
/* Set new keep-alives from old keep-alives, skipping irn */
void remove_End_keepalive(ir_node *end, ir_node *irn) {
- int n = get_End_n_keepalives(end);
- ir_node **in;
- int i, idx;
-
- NEW_ARR_A(ir_node *, in, n);
-
- for (idx = i = 0; i < n; ++i) {
- ir_node *old_ka = get_End_keepalive(end, i);
-
- /* skip irn */
- if (old_ka != irn)
- in[idx++] = old_ka;
+ int n = get_End_n_keepalives(end);
+ int i, idx;
+ ir_graph *irg;
+
+ idx = -1;
+ for (i = n -1; i >= 0; --i) {
+ ir_node *old_ka = end->in[1 + END_KEEPALIVE_OFFSET + i];
+
+ /* find irn */
+ if (old_ka == irn) {
+ idx = i;
+ goto found;
+ }
}
-
- /* set new keep-alives */
- set_End_keepalives(end, idx, in);
+ return;
+found:
+ irg = get_irn_irg(end);
+
+ /* remove the edge */
+ edges_notify_edge(end, idx, NULL, irn, irg);
+
+ if (idx != n - 1) {
+ /* exchange with the last one */
+ ir_node *old = end->in[1 + END_KEEPALIVE_OFFSET + n - 1];
+ edges_notify_edge(end, n - 1, NULL, old, irg);
+ end->in[1 + END_KEEPALIVE_OFFSET + idx] = old;
+ edges_notify_edge(end, idx, old, NULL, irg);
+ }
+ ARR_RESIZE(ir_node *, end->in, (n - 1) + 1 + END_KEEPALIVE_OFFSET);
}
void
node->attr.callbegin.call = call;
}
+/*
+ * Returns non-zero if a Call is surely a self-recursive Call.
+ * Beware: if this functions returns 0, the call might be self-recursive!
+ */
+int is_self_recursive_Call(const ir_node *call) {
+ const ir_node *callee = get_Call_ptr(call);
+
+ if (is_SymConst_addr_ent(callee)) {
+ const ir_entity *ent = get_SymConst_entity(callee);
+ const ir_graph *irg = get_entity_irg(ent);
+ if (irg == get_irn_irg(call))
+ return 1;
+ }
+ return 0;
+}
#define BINOP(OP) \
ir_node * get_##OP##_left(const ir_node *node) { \
BINOP(Shl)
BINOP(Shr)
BINOP(Shrs)
-BINOP(Rot)
+BINOP(Rotl)
BINOP(Cmp)
UNOP(Conv)
UNOP(Cast)
#endif /* INTERPROCEDURAL_VIEW */
}
+/* Returns non-zero if a node is a routine parameter. */
+int (is_arg_Proj)(const ir_node *node) {
+ return _is_arg_Proj(node);
+}
+
ir_node **
get_Tuple_preds_arr(ir_node *node) {
assert(is_Tuple(node));
}
int
-(is_Rot)(const ir_node *node) {
- return _is_Rot(node);
+(is_Rotl)(const ir_node *node) {
+ return _is_Rotl(node);
}
int
}
#endif
-#ifdef DEBUG_libfirm
-void dump_irn(const ir_node *n) {
- int i, arity = get_irn_arity(n);
- printf("%s%s: %ld (%p)\n", get_irn_opname(n), get_mode_name(get_irn_mode(n)), get_irn_node_nr(n), (void *)n);
- if (!is_Block(n)) {
- ir_node *pred = get_irn_n(n, -1);
- printf(" block: %s%s: %ld (%p)\n", get_irn_opname(pred), get_mode_name(get_irn_mode(pred)),
- get_irn_node_nr(pred), (void *)pred);
- }
- printf(" preds: \n");
- for (i = 0; i < arity; ++i) {
- ir_node *pred = get_irn_n(n, i);
- printf(" %d: %s%s: %ld (%p)\n", i, get_irn_opname(pred), get_mode_name(get_irn_mode(pred)),
- get_irn_node_nr(pred), (void *)pred);
+/*
+ * Calculate a hash value of a node.
+ */
+unsigned firm_default_hash(const ir_node *node) {
+ unsigned h;
+ int i, irn_arity;
+
+ /* hash table value = 9*(9*(9*(9*(9*arity+in[0])+in[1])+ ...)+mode)+code */
+ h = irn_arity = get_irn_intra_arity(node);
+
+ /* consider all in nodes... except the block if not a control flow. */
+ for (i = is_cfop(node) ? -1 : 0; i < irn_arity; ++i) {
+ h = 9*h + HASH_PTR(get_irn_intra_n(node, i));
}
-}
-#else /* DEBUG_libfirm */
-void dump_irn(const ir_node *n) { (void) n; }
-#endif /* DEBUG_libfirm */
+ /* ...mode,... */
+ h = 9*h + HASH_PTR(get_irn_mode(node));
+ /* ...and code */
+ h = 9*h + HASH_PTR(get_irn_op(node));
+
+ return h;
+} /* firm_default_hash */