#include "irdump.h"
#include "irop_t.h"
#include "irprog_t.h"
+#include "iredges_t.h"
-#include "firmstat.h"
+#include "irhooks.h"
/* some constants fixing the positions of nodes predecessors
in the in array */
res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
}
+
res->in[0] = block;
set_irn_dbg_info(res, db);
res->out = NULL;
res->node_nr = get_irp_new_node_nr();
#endif
- stat_new_node(res);
+#ifdef FIRM_EDGES_INPLACE
+ {
+ int i, n;
+ int not_a_block = !is_Block(res);
+
+ INIT_LIST_HEAD(&res->edge_info.outs_head);
+
+ for(i = 0, n = arity + not_a_block; i < n; ++i)
+ edges_notify_edge(res, i - not_a_block, res->in[i], NULL, irg);
+ }
+#endif
+
+ hook_new_node(irg, res);
return res;
}
int
(is_ir_node)(const void *thing) {
- return __is_ir_node(thing);
+ return _is_ir_node(thing);
}
int
(get_irn_intra_arity)(const ir_node *node) {
- return __get_irn_intra_arity(node);
+ return _get_irn_intra_arity(node);
}
int
(get_irn_inter_arity)(const ir_node *node) {
- return __get_irn_inter_arity(node);
+ return _get_irn_inter_arity(node);
}
-int (*__get_irn_arity)(const ir_node *node) = __get_irn_intra_arity;
+int (*_get_irn_arity)(const ir_node *node) = _get_irn_intra_arity;
int
(get_irn_arity)(const ir_node *node) {
- return __get_irn_arity(node);
+ return _get_irn_arity(node);
}
/* Returns the array with ins. This array is shifted with respect to the
ir_node *
(get_irn_intra_n)(const ir_node *node, int n) {
- return __get_irn_intra_n (node, n);
+ return _get_irn_intra_n (node, n);
}
ir_node *
(get_irn_inter_n)(const ir_node *node, int n) {
- return __get_irn_inter_n (node, n);
+ return _get_irn_inter_n (node, n);
}
-ir_node *(*__get_irn_n)(const ir_node *node, int n) = __get_irn_intra_n;
+ir_node *(*_get_irn_n)(const ir_node *node, int n) = _get_irn_intra_n;
ir_node *
(get_irn_n)(const ir_node *node, int n) {
- return __get_irn_n(node, n);
+ return _get_irn_n(node, n);
}
void
set_irn_n (ir_node *node, int n, ir_node *in) {
- assert(node && node->kind == k_ir_node && -1 <= n && n < get_irn_arity(node));
+ assert(node && node->kind == k_ir_node);
+ assert(-1 <= n);
+ assert(n < get_irn_arity(node));
assert(in && in->kind == k_ir_node);
+
if ((n == -1) && (get_irn_opcode(node) == iro_Filter)) {
/* Change block pred in both views! */
node->in[n + 1] = in;
}
/* else fall through */
}
+
+ /* Call the hook */
+ hook_set_irn_n(node, n, in, node->in[n + 1]);
+
+#ifdef FIRM_EDGES_INPLACE
+ /* Here, we rely on src and tgt being in the current ir graph */
+ edges_notify_edge(node, n, in, node->in[n + 1], current_ir_graph);
+#endif
+
node->in[n + 1] = in;
}
ir_mode *
(get_irn_mode)(const ir_node *node) {
- return __get_irn_mode(node);
+ return _get_irn_mode(node);
}
void
(set_irn_mode)(ir_node *node, ir_mode *mode)
{
- __set_irn_mode(node, mode);
+ _set_irn_mode(node, mode);
}
modecode
ir_op *
(get_irn_op)(const ir_node *node)
{
- return __get_irn_op(node);
+ return _get_irn_op(node);
}
/* should be private to the library: */
opcode
(get_irn_opcode)(const ir_node *node)
{
- return __get_irn_opcode(node);
+ return _get_irn_opcode(node);
}
const char *
unsigned long
(get_irn_visited)(const ir_node *node)
{
- return __get_irn_visited(node);
+ return _get_irn_visited(node);
}
void
(set_irn_visited)(ir_node *node, unsigned long visited)
{
- __set_irn_visited(node, visited);
+ _set_irn_visited(node, visited);
}
void
(mark_irn_visited)(ir_node *node) {
- __mark_irn_visited(node);
+ _mark_irn_visited(node);
}
int
(irn_not_visited)(const ir_node *node) {
- return __irn_not_visited(node);
+ return _irn_not_visited(node);
}
int
(irn_visited)(const ir_node *node) {
- return __irn_visited(node);
+ return _irn_visited(node);
}
void
(set_irn_link)(ir_node *node, void *link) {
- __set_irn_link(node, link);
+ _set_irn_link(node, link);
}
void *
(get_irn_link)(const ir_node *node) {
- return __get_irn_link(node);
+ return _get_irn_link(node);
}
op_pin_state
(get_irn_pinned)(const ir_node *node) {
- return __get_irn_pinned(node);
+ return _get_irn_pinned(node);
}
void set_irn_pinned(ir_node *node, op_pin_state state) {
return node->attr.a;
}
-type *
+free_attr
get_irn_free_attr (ir_node *node)
{
assert (node->op == op_Free);
- return node->attr.f = skip_tid(node->attr.f);
+ return node->attr.f;
}
symconst_attr
}
ir_node *(set_Block_dead)(ir_node *block) {
- return __set_Block_dead(block);
+ return _set_Block_dead(block);
}
int (is_Block_dead)(const ir_node *block) {
- return __is_Block_dead(block);
+ return _is_Block_dead(block);
}
void
set_irn_n(node, 1, exo_ptr);
}
-tarval *get_Const_tarval (ir_node *node) {
- assert (node->op == op_Const);
- return node->attr.con.tv;
+tarval *(get_Const_tarval)(ir_node *node) {
+ return _get_Const_tarval(node);
}
void
node->attr.con.tv = con;
}
+cnst_classify_t (classify_Const)(ir_node *node)
+{
+ return _classify_Const(node);
+}
+
/* The source language type. Must be an atomic type. Mode of type must
be mode of node. For tarvals from entities type must be pointer to
void
set_Const_type (ir_node *node, type *tp) {
assert (node->op == op_Const);
- if (tp != unknown_type) {
+ if (tp != firm_unknown_type) {
assert (is_atomic_type(tp));
assert (get_type_mode(tp) == get_irn_mode(node));
}
void
set_Call_type (ir_node *node, type *tp) {
assert (node->op == op_Call);
- assert ((get_unknown_type() == tp) || is_method_type(tp));
+ assert ((get_unknown_type() == tp) || is_Method_type(tp));
node->attr.call.cld_tp = tp;
}
int
(is_unop)(const ir_node *node) {
- return __is_unop(node);
+ return _is_unop(node);
}
ir_node *
int
(is_binop)(const ir_node *node) {
- return __is_binop(node);
+ return _is_binop(node);
}
ir_node *
assert (node->op->opar == oparity_binary);
}
-int is_Phi (ir_node *n) {
+int is_Phi (const ir_node *n) {
ir_op *op;
assert(n);
return 0;
}
-int is_Phi0 (ir_node *n) {
+int is_Phi0 (const ir_node *n) {
assert(n);
return ((get_irn_op(n) == op_Phi) &&
type *
get_Free_type (ir_node *node) {
assert (node->op == op_Free);
- return node->attr.f = skip_tid(node->attr.f);
+ return node->attr.f.type = skip_tid(node->attr.f.type);
}
void
set_Free_type (ir_node *node, type *tp) {
assert (node->op == op_Free);
- node->attr.f = tp;
+ node->attr.f.type = tp;
+}
+
+where_alloc
+get_Free_where (ir_node *node) {
+ assert (node->op == op_Free);
+ return node->attr.f.where;
+}
+
+void
+set_Free_where (ir_node *node, where_alloc where) {
+ assert (node->op == op_Free);
+ node->attr.f.where = where;
}
ir_node **
return node->attr.filter.in_cg[pos + 1];
}
+/* Mux support */
+ir_node *get_Mux_sel (ir_node *node) {
+ assert(node->op == op_Mux);
+ return node->in[1];
+}
+void set_Mux_sel (ir_node *node, ir_node *sel) {
+ assert(node->op == op_Mux);
+ node->in[1] = sel;
+}
+
+ir_node *get_Mux_false (ir_node *node) {
+ assert(node->op == op_Mux);
+ return node->in[2];
+}
+void set_Mux_false (ir_node *node, ir_node *ir_false) {
+ assert(node->op == op_Mux);
+ node->in[2] = ir_false;
+}
+
+ir_node *get_Mux_true (ir_node *node) {
+ assert(node->op == op_Mux);
+ return node->in[3];
+}
+void set_Mux_true (ir_node *node, ir_node *ir_true) {
+ assert(node->op == op_Mux);
+ node->in[3] = ir_true;
+}
+
ir_graph *
-get_irn_irg(ir_node *node) {
- if (get_irn_op(node) != op_Block)
+get_irn_irg(const ir_node *node) {
+ if (! is_Block(node))
node = get_nodes_block(node);
if (is_Bad(node)) /* sometimes bad is predecessor of nodes instead of block: in case of optimization */
node = get_nodes_block(node);
int
(is_Bad)(const ir_node *node) {
- return __is_Bad(node);
+ return _is_Bad(node);
}
int
(is_no_Block)(const ir_node *node) {
- return __is_no_Block(node);
+ return _is_no_Block(node);
}
int
(is_Block)(const ir_node *node) {
- return __is_Block(node);
+ return _is_Block(node);
}
/* returns true if node is a Unknown node. */
projects / libfirm / blobdiff