*/
#include "irnode.h"
-//#include "irnode2.h"
#include "array.h"
static char *pnc_name_arr [] = {"False", "Eq", "Lt", "Le",
static char *symconst_name_arr [] = {"type_tag", "size", "linkage_ptr_info"};
-
-
void
init_irnode (void)
{
res->kind = k_ir_node;
res->op = op;
res->mode = mode;
- res->visit = 0;
+ res->visited = 0;
res->link = NULL;
if (arity < 0) {
res->in = NEW_ARR_F (ir_node *, 1);
memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
}
res->in[0] = block;
+
+#ifdef DEBUG_libfirm
+ res->node_nr = get_irp_new_node_nr();
+#endif
+
return res;
}
return printed;
}
- XPF1 ("%I", get_irn_op(np)->name);
+ XPF1 ("%I", get_irn_opname(np));
switch (get_irn_opcode (np)) { /* node label */
case iro_Const:
return (ARR_LEN((node)->in)-1);
}
-/* returns the array with ins */
+/* Returns the array with ins. This array is shifted with respect to the
+ array accessed by get_irn_n: The block operand is at position 0 not -1.
+ (@@@ This should be changed.)
+ The order of the predecessors in this array is not guaranteed, except that
+ lists of operands as predecessors of Block or arguments of a Call are
+ consecutive. */
inline ir_node **
get_irn_in (ir_node *node)
{
/* to iterate through the predecessors without touching the array */
/* To iterate over the operands iterate from 0 to i < get_irn_arity(),
to iterate includind the Block predecessor iterate from i = -1 to
- i < get_irn_arity. */
+ i < get_irn_arity.
+ If it is a block, the entry -1 is NULL. */
+
inline ir_node *
get_irn_n (ir_node *node, int n)
{
assert (node);
- // assert (get_irn_arity (node) > n);
+ /* GL commented the assert in, 12.7.00, let's see whether it works */
+ assert (get_irn_arity (node) > n);
return skip_nop(node->in[n+1]);
}
return node->mode->code;
}
+
+inline ident *
+get_irn_modename (ir_node *node)
+{
+ assert(node);
+ return node->mode->name;
+}
+
inline ir_op *
get_irn_op (ir_node *node)
{
return node->op->code;
}
+inline ident *
+get_irn_opname (ir_node *node)
+{
+ assert(node);
+ return node->op->name;
+}
+
+inline unsigned long
+get_irn_visited (ir_node *node)
+{
+ assert (node);
+ return node->visited;
+}
+
+inline void
+set_irn_visited (ir_node *node, unsigned long visited)
+{
+ assert (node);
+ node->visited = visited;
+}
inline void
set_irn_link (ir_node *node, ir_node *link) {
assert (node);
return node->link;
}
+#ifdef DEBUG_libfirm
+/* Outputs a unique number for this node */
+inline long
+get_irn_node_nr(ir_node *node) {
+ assert(node);
+ return node->node_nr;
+}
+#endif
+
inline tarval *
get_irn_const_attr (ir_node *node)
{
set_irn_n(node, -1, block);
}
+/* Returns an array with the predecessors of the Block. Depending on
+ the implementation of the graph datastructure this can be a copy of
+ the internal representation of predecessors as well as the internal
+ array itself. Therefore writing to this array might obstruct the ir. */
+inline ir_node **
+get_Block_cfgpred_arr (ir_node *node)
+{
+ assert ((node->op == op_Block));
+ return (ir_node **)get_Block_cfgpred(node, 0);
+}
+
+
inline int
get_Block_n_cfgpreds (ir_node *node) {
assert ((node->op == op_Block));
node->attr.block.matured = matured;
}
inline unsigned long
-get_Block_block_visit (ir_node *node) {
+get_Block_block_visited (ir_node *node) {
assert (node->op == op_Block);
- return node->attr.block.block_visit;
+ return node->attr.block.block_visited;
}
inline void
-set_Block_block_visit (ir_node *node, unsigned long visit) {
+set_Block_block_visited (ir_node *node, unsigned long visit) {
assert (node->op == op_Block);
- node->attr.block.block_visit = visit;
+ node->attr.block.block_visited = visit;
}
inline ir_node *
inline ir_node *
get_Return_mem (ir_node *node) {
- assert (node->op == op_Cond);
+ assert (node->op == op_Return);
return get_irn_n(node, 0);
}
set_irn_n(node, 0, mem);
}
+inline ir_node **
+get_Return_res_arr (ir_node *node)
+{
+ assert ((node->op == op_Return));
+ if (get_Return_n_res(node) > 0)
+ return ((ir_node **)get_Return_res(node, 0));
+ else
+ return NULL;
+}
+
inline int
get_Return_n_res (ir_node *node) {
assert (node->op == op_Return);
inline ir_node *
get_Return_res (ir_node *node, int pos) {
assert (node->op == op_Return);
+ assert (get_Return_n_res(node) > pos);
return get_irn_n(node, pos+1);
}
inline void
set_Return_res (ir_node *node, int pos, ir_node *res){
- assert (node->op == op_Raise);
+ assert (node->op == op_Return);
set_irn_n(node, pos+1, res);
}
set_irn_n(node, 1, ptr);
}
+inline ir_node **
+get_Sel_index_arr (ir_node *node)
+{
+ assert ((node->op == op_Sel));
+ if (get_Sel_n_index(node) > 0)
+ return (ir_node **)get_Sel_index(node, 0);
+ else
+ return NULL;
+}
+
inline int
get_Sel_n_index (ir_node *node) {
assert (node->op == op_Sel);
set_irn_n(node, 1, ptr);
}
+inline ir_node **
+get_Call_param_arr (ir_node *node) {
+ assert (node->op == op_Call);
+ if (get_Call_arity(node) > 0)
+ return ((ir_node **)get_Call_param (node, 0));
+ else
+ return NULL;
+}
+
inline int
get_Call_arity (ir_node *node) {
assert (node->op == op_Call);
set_irn_n(node, 0, op);
}
+inline ir_node **
+get_Phi_preds_arr (ir_node *node) {
+ assert (node->op == op_Phi);
+ return ((ir_node **)get_Phi_pred(node, 0));
+}
+
inline int
get_Phi_n_preds (ir_node *node) {
assert (node->op == op_Phi);
node->attr.f = type;
}
+inline ir_node **
+get_Sync_preds_arr (ir_node *node) {
+ assert (node->op == op_Sync);
+ return ((ir_node **)get_Sync_pred(node, 0));
+}
+
inline int
get_Sync_n_preds (ir_node *node) {
assert (node->op == op_Sync);
node->attr.proj = proj;
}
+inline ir_node **
+get_Tuple_preds_arr (ir_node *node) {
+ assert (node->op == op_Tuple);
+ return ((ir_node **)get_Tuple_pred(node, 0));
+}
+
inline int
get_Tuple_n_preds (ir_node *node) {
assert (node->op == op_Tuple);
projects / libfirm / blobdiff