**
*/
-#include "irnode.h"
+#include "irnode_t.h"
+#include "irgraph_t.h"
+#include "ident_t.h"
+#include "irmode_t.h"
#include "array.h"
+#ifdef DEBUG_libfirm
+#include "irprog.h"
+#endif
+
+/* some constants fixing the positions of nodes predecessors
+ in the in array */
+#define CALL_PARAM_OFFSET 2
+#define SEL_INDEX_OFFSET 2
+#define RETURN_RESULT_OFFSET 1 /* mem is not a result */
+
static char *pnc_name_arr [] = {"False", "Eq", "Lt", "Le",
"Gt", "Ge", "Lg", "Leg", "Uo",
"Ue", "Ul", "Ule", "Ug", "Uge",
return res;
}
+/* Copies all attributes stored in the old node to the new node.
+ Assumes both have the same opcode and sufficient size. */
+void
+copy_attrs (ir_node *old, ir_node *new) {
+ assert (get_irn_opcode(old) == get_irn_opcode(new));
+ memcpy (&new->attr, &old->attr, get_op_attr_size(get_irn_op(old)));
+}
/* IR-Nodes with attributes */
int
return printed;
}
- XPF1 ("%I", get_irn_opname(np));
+ XPF1 ("%I", get_irn_opident(np));
switch (get_irn_opcode (np)) { /* node label */
case iro_Const:
to iterate includind the Block predecessor iterate from i = -1 to
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);
+ assert (get_irn_arity (node) > n);
return skip_nop(node->in[n+1]);
}
inline ident *
-get_irn_modename (ir_node *node)
+get_irn_modeident (ir_node *node)
{
assert(node);
return node->mode->name;
return node->op->code;
}
-inline ident *
+inline const char *
get_irn_opname (ir_node *node)
+{
+ assert(node);
+ return id_to_str(node->op->name);
+}
+
+inline ident *
+get_irn_opident (ir_node *node)
{
assert(node);
return node->op->name;
get_Block_cfgpred_arr (ir_node *node)
{
assert ((node->op == op_Block));
- return (ir_node **)get_Block_cfgpred(node, 0);
+ return (ir_node **)&(get_irn_in(node)[1]);
}
{
assert ((node->op == op_Return));
if (get_Return_n_res(node) > 0)
- return ((ir_node **)get_Return_res(node, 0));
+ return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
else
return NULL;
}
inline int
get_Return_n_res (ir_node *node) {
assert (node->op == op_Return);
- return (get_irn_arity(node) - 1);
+ return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
}
/*
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);
+ return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
}
inline void
set_Return_res (ir_node *node, int pos, ir_node *res){
assert (node->op == op_Return);
- set_irn_n(node, pos+1, res);
+ set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
}
inline ir_node *
assert ( (node->op == op_SymConst)
&& (get_SymConst_kind(node) == linkage_ptr_info));
return node->attr.i.tori.ptrinfo;
-
-
}
inline void
node->attr.i.tori.ptrinfo = ptrinfo;
}
+inline type_or_id_p
+get_SymConst_type_or_id (ir_node *node) {
+ assert (node->op == op_SymConst);
+ return &(node->attr.i.tori);
+}
+
+inline void
+set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
+ assert (node->op == op_SymConst);
+ memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
+}
+
inline ir_node *
get_Sel_mem (ir_node *node) {
assert (node->op == op_Sel);
{
assert ((node->op == op_Sel));
if (get_Sel_n_index(node) > 0)
- return (ir_node **)get_Sel_index(node, 0);
+ return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
else
return NULL;
}
inline int
get_Sel_n_index (ir_node *node) {
assert (node->op == op_Sel);
- return (get_irn_arity(node) - 2);
+ return (get_irn_arity(node) - SEL_INDEX_OFFSET);
}
/*
inline ir_node *
get_Sel_index (ir_node *node, int pos) {
assert (node->op == op_Sel);
- return get_irn_n(node, pos+2);
+ return get_irn_n(node, pos + SEL_INDEX_OFFSET);
}
inline void
set_Sel_index (ir_node *node, int pos, ir_node *index) {
assert (node->op == op_Sel);
- set_irn_n(node, pos+2, index);
+ set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
}
inline entity *
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;
+ return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
}
inline int
-get_Call_arity (ir_node *node) {
+get_Call_n_params (ir_node *node) {
assert (node->op == op_Call);
- return (get_irn_arity(node) - 2);
+ return (get_irn_arity(node) - CALL_PARAM_OFFSET);
+}
+
+inline int
+get_Call_arity (ir_node *node) {
+ return get_Call_n_params(node);
}
/* inline void
inline ir_node *
get_Call_param (ir_node *node, int pos) {
assert (node->op == op_Call);
- return get_irn_n(node, pos+1);
+ return get_irn_n(node, pos + CALL_PARAM_OFFSET);
}
inline void
set_Call_param (ir_node *node, int pos, ir_node *param) {
assert (node->op == op_Call);
- set_irn_n(node, pos+1, param);
+ set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
}
inline type_method *
inline ir_node **
get_Phi_preds_arr (ir_node *node) {
assert (node->op == op_Phi);
- return ((ir_node **)get_Phi_pred(node, 0));
+ return (ir_node **)&(get_irn_in(node)[1]);
}
inline int
}
inline void
-set_Allco_size (ir_node *node, ir_node *size) {
+set_Alloc_size (ir_node *node, ir_node *size) {
assert (node->op == op_Alloc);
set_irn_n(node, 1, size);
}
inline ir_node **
get_Sync_preds_arr (ir_node *node) {
assert (node->op == op_Sync);
- return ((ir_node **)get_Sync_pred(node, 0));
+ return (ir_node **)&(get_irn_in(node)[1]);
}
inline int
inline ir_node **
get_Tuple_preds_arr (ir_node *node) {
assert (node->op == op_Tuple);
- return ((ir_node **)get_Tuple_pred(node, 0));
+ return (ir_node **)&(get_irn_in(node)[1]);
}
inline int
inline ir_node *
skip_nop (ir_node *node) {
/* don't assert node !!! */
- if (node && (node->op == op_Id)) {
- return get_Id_pred(node);
+
+ if (node && (node->op == op_Id) && (node != get_Id_pred(node))) {
+ /* Don't use get_Id_pred: We get into an endless loop for
+ self-referencing Ids. */
+ assert (get_irn_arity (node) > 0);
+ return node->in[0+1];
} else {
return node;
}