#include "irdump.h"
#include "irop_t.h"
#include "irprog_t.h"
+#include "iredgekinds.h"
#include "iredges_t.h"
#include "irhooks.h"
res->visited = 0;
res->node_idx = irg_register_node_idx(irg, res);
res->link = NULL;
+ res->deps = NULL;
+
if (arity < 0) {
res->in = NEW_ARR_F (ir_node *, 1); /* 1: space for block */
} else {
res->node_nr = get_irp_new_node_nr();
#endif
- INIT_LIST_HEAD(&res->edge_info.outs_head);
- is_bl = is_Block(res);
- if (is_bl)
- INIT_LIST_HEAD(&res->attr.block.succ_head);
-
+ for(i = 0; i < EDGE_KIND_LAST; ++i)
+ INIT_LIST_HEAD(&res->edge_info[i].outs_head);
+ is_bl = is_Block(res);
for (i = is_bl; i <= arity; ++i)
edges_notify_edge(res, i - 1, res->in[i], NULL, irg);
node->in[n + 1] = in;
}
+int
+(get_irn_deps)(const ir_node *node)
+{
+ return _get_irn_deps(node);
+}
+
+ir_node *
+(get_irn_dep)(const ir_node *node, int pos)
+{
+ return _get_irn_dep(node, pos);
+}
+
+void
+(set_irn_dep)(ir_node *node, int pos, ir_node *dep)
+{
+ _set_irn_dep(node, pos, dep);
+}
+
+int add_irn_dep(ir_node *node, ir_node *dep)
+{
+ int res = 0;
+
+ if (node->deps == NULL) {
+ node->deps = NEW_ARR_F(ir_node *, 1);
+ node->deps[0] = dep;
+ }
+ else {
+ int i, n;
+ int first_zero = -1;
+
+ for(i = 0, n = ARR_LEN(node->deps); i < n; ++i) {
+ if(node->deps[i] == NULL)
+ first_zero = i;
+
+ if(node->deps[i] == dep)
+ return i;
+ }
+
+ if(first_zero >= 0) {
+ node->deps[first_zero] = dep;
+ res = first_zero;
+ }
+
+ else {
+ ARR_APP1(ir_node *, node->deps, dep);
+ res = n;
+ }
+ }
+
+ edges_notify_edge_kind(node, res, dep, NULL, EDGE_KIND_DEP, get_irn_irg(node));
+
+ return res;
+}
+
+void add_irn_deps(ir_node *tgt, ir_node *src)
+{
+ int i, n;
+
+ for(i = 0, n = get_irn_deps(src); i < n; ++i)
+ add_irn_dep(tgt, get_irn_dep(src, i));
+}
+
+
ir_mode *
(get_irn_mode)(const ir_node *node) {
return _get_irn_mode(node);
edges_notify_edge(end, END_KEEPALIVE_OFFSET + i, NULL, end->in[1 + END_KEEPALIVE_OFFSET + i], irg);
}
}
+/* 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;
+ }
+
+ /* set new keep-alives */
+ set_End_keepalives(end, idx, in);
+}
void
free_End (ir_node *end) {
ident *
get_SymConst_name (ir_node *node) {
- assert( (node->op == op_SymConst)
- && (get_SymConst_kind(node) == symconst_addr_name));
+ assert(node->op == op_SymConst && SYMCONST_HAS_ID(get_SymConst_kind(node)));
return node->attr.symc.sym.ident_p;
}
void
set_SymConst_name (ir_node *node, ident *name) {
- assert( (node->op == op_SymConst)
- && (get_SymConst_kind(node) == symconst_addr_name));
+ assert(node->op == op_SymConst && SYMCONST_HAS_ID(get_SymConst_kind(node)));
node->attr.symc.sym.ident_p = name;
}
/* Only to access SymConst of kind symconst_addr_ent. Else assertion: */
entity *get_SymConst_entity (ir_node *node) {
- assert( (node->op == op_SymConst)
- && (get_SymConst_kind (node) == symconst_addr_ent));
+ assert(node->op == op_SymConst && SYMCONST_HAS_ENT(get_SymConst_kind(node)));
return node->attr.symc.sym.entity_p;
}
void set_SymConst_entity (ir_node *node, entity *ent) {
- assert( (node->op == op_SymConst)
- && (get_SymConst_kind(node) == symconst_addr_ent));
+ assert(node->op == op_SymConst && SYMCONST_HAS_ENT(get_SymConst_kind(node)));
node->attr.symc.sym.entity_p = ent;
}
ir_enum_const *get_SymConst_enum (ir_node *node) {
- assert( (node->op == op_SymConst)
- && (get_SymConst_kind (node) == symconst_enum_const));
+ assert(node->op == op_SymConst && SYMCONST_HAS_ENUM(get_SymConst_kind(node)));
return node->attr.symc.sym.enum_p;
}
void set_SymConst_enum (ir_node *node, ir_enum_const *ec) {
- assert( (node->op == op_SymConst)
- && (get_SymConst_kind(node) == symconst_enum_const));
+ assert(node->op == op_SymConst && SYMCONST_HAS_ENUM(get_SymConst_kind(node)));
node->attr.symc.sym.enum_p = ec;
}
node->attr.load.load_mode = mode;
}
-ent_volatility
+ir_volatility
get_Load_volatility (ir_node *node) {
assert(node->op == op_Load);
return node->attr.load.volatility;
}
void
-set_Load_volatility (ir_node *node, ent_volatility volatility) {
+set_Load_volatility (ir_node *node, ir_volatility volatility) {
assert(node->op == op_Load);
node->attr.load.volatility = volatility;
}
set_irn_n(node, 2, value);
}
-ent_volatility
+ir_volatility
get_Store_volatility (ir_node *node) {
assert(node->op == op_Store);
return node->attr.store.volatility;
}
void
-set_Store_volatility (ir_node *node, ent_volatility volatility) {
+set_Store_volatility (ir_node *node, ir_volatility volatility) {
assert(node->op == op_Store);
node->attr.store.volatility = volatility;
}
ir_node *
skip_Proj (ir_node *node) {
/* don't assert node !!! */
- if (node && is_Proj(node)) {
+ if (node != NULL && is_Proj(node)) {
return get_Proj_pred(node);
} else {
- return node;
+ return (ir_node*) node;
}
}
return _is_Bad(node);
}
+int
+(is_NoMem)(const ir_node *node) {
+ return _is_NoMem(node);
+}
+
+int
+(is_Mod)(const ir_node *node) {
+ return _is_Mod(node);
+}
+
+int
+(is_Div)(const ir_node *node) {
+ return _is_Div(node);
+}
+
+int
+(is_DivMod)(const ir_node *node) {
+ return _is_DivMod(node);
+}
+
+int
+(is_Start)(const ir_node *node) {
+ return _is_Start(node);
+}
+
+int
+(is_End)(const ir_node *node) {
+ return _is_End(node);
+}
+
int
(is_Const)(const ir_node *node) {
return _is_Const(node);
return _is_Confirm(node);
}
+/* returns true if node is a Pin node. */
+int
+(is_Pin)(const ir_node *node) {
+ return _is_Pin(node);
+}
+
/* returns true if node is a SymConst node. */
int
(is_SymConst)(const ir_node *node) {
return _is_Alloc(node);
}
+/* returns true if a node is a Jmp node. */
+int
+(is_Jmp)(const ir_node *node) {
+ return _is_Jmp(node);
+}
+
+/* returns true if a node is a Raise node. */
+int
+(is_Raise)(const ir_node *node) {
+ return _is_Raise(node);
+}
+
int
is_Proj (const ir_node *node) {
assert(node);
case iro_Load :
case iro_Store :
case iro_Alloc :
+ case iro_Bound :
return get_irn_n(node, 0);
case iro_Bad :
case iro_Unknown:
return _is_irn_keep(node);
}
+/*
+ * Returns non-zero for nodes that are always placed in the start block.
+ */
+int (is_irn_start_block_placed)(const ir_node *node) {
+ return _is_irn_start_block_placed(node);
+}
+
/* Returns non-zero for nodes that are machine operations. */
int (is_irn_machine_op)(const ir_node *node) {
return _is_irn_machine_op(node);
projects / libfirm / blobdiff