in the in array */
#define CALL_PARAM_OFFSET (n_Call_max+1)
#define BUILTIN_PARAM_OFFSET (n_Builtin_max+1)
+#define ASM_PARAM_OFFSET (n_ASM_max+1)
#define SEL_INDEX_OFFSET (n_Sel_max+1)
#define RETURN_RESULT_OFFSET (n_Return_max+1)
#define END_KEEPALIVE_OFFSET 0
ir_relation code = relation & ~(ir_relation_less|ir_relation_greater);
bool less = relation & ir_relation_less;
bool greater = relation & ir_relation_greater;
- code |= (less ? ir_relation_greater : 0) | (greater ? ir_relation_less : 0);
+ code |= (less ? ir_relation_greater : ir_relation_false)
+ | (greater ? ir_relation_less : ir_relation_false);
return code;
}
-/**
- * Indicates, whether additional data can be registered to ir nodes.
- * If set to 1, this is not possible anymore.
- */
-static int forbid_new_data = 0;
-
-unsigned firm_add_node_size = 0;
-
-
-unsigned firm_register_additional_node_data(unsigned size)
-{
- assert(!forbid_new_data && "Too late to register additional node data");
-
- if (forbid_new_data)
- return 0;
-
- return firm_add_node_size += size;
-}
-
-
-void init_irnode(void)
-{
- /* Forbid the addition of new data to an ir node. */
- forbid_new_data = 1;
-}
-
-struct struct_align {
- char c;
- struct s {
- int i;
- float f;
- double d;
- } s;
-};
-
ir_node *new_ir_node(dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op,
ir_mode *mode, int arity, ir_node *const *in)
{
- ir_node *res;
- unsigned align = offsetof(struct struct_align, s) - 1;
- unsigned add_node_size = (firm_add_node_size + align) & ~align;
- size_t node_size = offsetof(ir_node, attr) + op->attr_size + add_node_size;
- char *p;
int i;
assert(irg);
assert(op);
assert(mode);
- p = (char*)obstack_alloc(irg->obst, node_size);
- memset(p, 0, node_size);
- res = (ir_node *)(p + add_node_size);
+
+ size_t const node_size = offsetof(ir_node, attr) + op->attr_size;
+ ir_node *const res = (ir_node*)OALLOCNZ(irg->obst, char, node_size);
res->kind = k_ir_node;
res->op = op;
res->in[0] = block;
set_irn_dbg_info(res, db);
- res->out = NULL;
res->node_nr = get_irp_new_node_nr();
for (i = 0; i < EDGE_KIND_LAST; ++i) {
edges_notify_edge(res, i - 1, res->in[i], NULL, irg);
hook_new_node(irg, res);
- if (get_irg_phase_state(irg) == phase_backend) {
+ if (irg_is_constrained(irg, IR_GRAPH_CONSTRAINT_BACKEND)) {
be_info_new_node(irg, res);
}
return get_irn_dep_(node, pos);
}
-void (set_irn_dep)(ir_node *node, int pos, ir_node *dep)
+void set_irn_dep(ir_node *node, int pos, ir_node *dep)
{
- set_irn_dep_(node, pos, dep);
+ ir_node *old;
+ ir_graph *irg;
+
+ assert(node->deps && "dependency array node yet allocated. use add_irn_dep()");
+ assert(pos >= 0 && pos < (int)ARR_LEN(node->deps) && "dependency index out of range");
+ assert(dep != NULL);
+ old = node->deps[pos];
+ node->deps[pos] = dep;
+ irg = get_irn_irg(node);
+ if (edges_activated_kind(irg, EDGE_KIND_DEP))
+ edges_notify_edge_kind(node, pos, dep, old, EDGE_KIND_DEP, irg);
}
-int add_irn_dep(ir_node *node, ir_node *dep)
+void 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);
+ ir_graph *irg;
+ assert(dep != NULL);
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;
+ node->deps = NEW_ARR_F(ir_node *, 0);
+ }
+ ARR_APP1(ir_node*, node->deps, dep);
+ irg = get_irn_irg(node);
+ if (edges_activated_kind(irg, EDGE_KIND_DEP))
+ edges_notify_edge_kind(node, ARR_LEN(node->deps)-1, dep, NULL, EDGE_KIND_DEP, irg);
+}
- if (node->deps[i] == dep)
- return i;
- }
+void delete_irn_dep(ir_node *node, ir_node *dep)
+{
+ size_t i;
+ size_t n_deps;
+ if (node->deps == NULL)
+ return;
- if (first_zero >= 0) {
- node->deps[first_zero] = dep;
- res = first_zero;
- } else {
- ARR_APP1(ir_node *, node->deps, dep);
- res = n;
+ n_deps = ARR_LEN(node->deps);
+ for (i = 0; i < n_deps; ++i) {
+ if (node->deps[i] == dep) {
+ set_irn_dep(node, i, node->deps[n_deps-1]);
+ edges_notify_edge(node, i, NULL, dep, get_irn_irg(node));
+ ARR_SHRINKLEN(node->deps, n_deps-1);
+ break;
}
}
-
- 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)
void set_nodes_block(ir_node *node, ir_node *block)
{
- assert(node->op != op_Block);
+ assert(!is_Block(node));
set_irn_n(node, -1, block);
}
void remove_End_keepalive(ir_node *end, ir_node *irn)
{
int n = get_End_n_keepalives(end);
- int i, idx;
ir_graph *irg;
- idx = -1;
- for (i = n -1; i >= 0; --i) {
+ int idx = -1;
+ for (int i = n;;) {
+ if (i-- == 0)
+ return;
+
ir_node *old_ka = end->in[1 + END_KEEPALIVE_OFFSET + i];
/* find irn */
if (old_ka == irn) {
idx = i;
- goto found;
+ break;
}
}
- return;
-found:
irg = get_irn_irg(end);
/* remove the edge */
return &get_irn_in(node)[CALL_PARAM_OFFSET + 1];
}
-size_t get_Call_n_params(const ir_node *node)
+int get_Call_n_params(const ir_node *node)
{
assert(is_Call(node));
- return (size_t) (get_irn_arity(node) - CALL_PARAM_OFFSET);
+ return get_irn_arity(node) - CALL_PARAM_OFFSET;
}
ir_node *get_Call_param(const ir_node *node, int pos)
set_irn_n(node, pos, pred);
}
-size_t get_ASM_n_input_constraints(const ir_node *node)
+int get_ASM_n_inputs(const ir_node *node)
{
assert(is_ASM(node));
- return ARR_LEN(node->attr.assem.input_constraints);
+ return get_irn_arity(node) - ASM_PARAM_OFFSET;
+}
+
+ir_node *get_ASM_input(const ir_node *node, int pos)
+{
+ return get_irn_n(node, ASM_PARAM_OFFSET + pos);
}
size_t get_ASM_n_output_constraints(const ir_node *node)
}
}
-int (is_strictConv)(const ir_node *node)
-{
- return is_strictConv_(node);
-}
-
int (is_SymConst_addr_ent)(const ir_node *node)
{
return is_SymConst_addr_ent_(node);
return res;
}
-unsigned firm_default_hash(const ir_node *node)
+bool only_used_by_keepalive(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_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) {
- ir_node *pred = get_irn_n(node, i);
- if (is_irn_cse_neutral(pred))
- h *= 9;
- else
- h = 9*h + hash_ptr(pred);
+ foreach_out_edge(node, edge) {
+ ir_node *succ = get_edge_src_irn(edge);
+ if (is_End(succ))
+ continue;
+ if (is_Proj(succ) && only_used_by_keepalive(succ))
+ return true;
+ /* found a real user */
+ return false;
}
-
- /* ...mode,... */
- h = 9*h + hash_ptr(get_irn_mode(node));
- /* ...and code */
- h = 9*h + hash_ptr(get_irn_op(node));
-
- return h;
+ return true;
}
/* include generated code */