X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firnode.c;h=cfeb23bd650968623d4e929791faba65b5eebe39;hb=e570f00fb465d212dde403160e97ab45d36d1d7e;hp=42df7ee439efebba16e2969f8b30beb84e421c27;hpb=a7374702e9ec0bc04af3ffc08aa8fd4a94c5b45f;p=libfirm

diff --git a/ir/ir/irnode.c b/ir/ir/irnode.c
index 42df7ee43..cfeb23bd6 100644
--- a/ir/ir/irnode.c
+++ b/ir/ir/irnode.c
@@ -25,9 +25,10 @@
 #include "irdump.h"
 #include "irflag_t.h"
 #include "irop_t.h"
-
 #include "irprog_t.h"
 
+#include "firmstat.h"
+
 /* some constants fixing the positions of nodes predecessors
    in the in array */
 #define CALL_PARAM_OFFSET 2
@@ -53,11 +54,16 @@ static const char *pnc_name_arr [] = {
   "Ne", "True"
 };
 
+/**
+ * returns the pnc name from an pnc constant
+ */
 INLINE const char *get_pnc_string(int pnc) {
   return pnc_name_arr[pnc];
 }
 
-
+/**
+ * Calculates the negated pnc condition.
+ */
 int
 get_negated_pnc(int pnc) {
   switch (pnc) {
@@ -108,6 +114,7 @@ new_ir_node (dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mo
   ir_node *res;
   int node_size = offsetof (ir_node, attr) +  op->attr_size;
 
+  assert(irg && op && mode);
   res = (ir_node *) obstack_alloc (irg->obst, node_size);
 
   res->kind = k_ir_node;
@@ -129,6 +136,8 @@ new_ir_node (dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mo
   res->node_nr = get_irp_new_node_nr();
 #endif
 
+  stat_new_node(res);
+
   return res;
 }
 
@@ -144,7 +153,6 @@ copy_attrs (const ir_node *old_node, ir_node *new_node) {
 
 int
 is_ir_node (const void *thing) {
-  assert(thing);
   if (get_kind(thing) == k_ir_node)
     return 1;
   else
@@ -335,7 +343,6 @@ set_irn_op (ir_node *node, ir_op *op)
 INLINE opcode
 get_irn_opcode (const ir_node *node)
 {
-  assert (node);
   assert (k_ir_node == get_kind(node));
   assert (node -> op);
   return node->op->code;
@@ -456,6 +463,13 @@ get_irn_call_attr (ir_node *node)
   return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
 }
 
+INLINE type *
+get_irn_funccall_attr (ir_node *node)
+{
+  assert (node->op == op_FuncCall);
+  return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
+}
+
 INLINE sel_attr
 get_irn_sel_attr (ir_node *node)
 {
@@ -1207,115 +1221,128 @@ void  set_CallBegin_call (ir_node *node, ir_node *call) {
 }
 
 INLINE ir_node *
-get_Add_left (ir_node *node) {
-  assert (node->op == op_Add);
+get_FuncCall_ptr (ir_node *node) {
+  assert (node->op == op_FuncCall);
   return get_irn_n(node, 0);
 }
 
 INLINE void
-set_Add_left (ir_node *node, ir_node *left) {
-  assert (node->op == op_Add);
-  set_irn_n(node, 0, left);
+set_FuncCall_ptr (ir_node *node, ir_node *ptr) {
+  assert (node->op == op_FuncCall);
+  set_irn_n(node, 0, ptr);
 }
 
-INLINE ir_node *
-get_Add_right (ir_node *node) {
-  assert (node->op == op_Add);
-  return get_irn_n(node, 1);
+INLINE ir_node **
+get_FuncCall_param_arr (ir_node *node) {
+  assert (node->op == op_FuncCall);
+  return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET];
 }
 
-INLINE void
-set_Add_right (ir_node *node, ir_node *right) {
-  assert (node->op == op_Add);
-  set_irn_n(node, 1, right);
+INLINE int
+get_FuncCall_n_params (ir_node *node)  {
+  assert (node->op == op_FuncCall);
+  return (get_irn_arity(node) - CALL_PARAM_OFFSET);
 }
 
-INLINE ir_node *
-get_Sub_left (ir_node *node) {
-  assert (node->op == op_Sub);
-  return get_irn_n(node, 0);
+INLINE int
+get_FuncCall_arity (ir_node *node) {
+  assert (node->op == op_FuncCall);
+  return get_FuncCall_n_params(node);
 }
 
-INLINE void
-set_Sub_left (ir_node *node, ir_node *left) {
-  assert (node->op == op_Sub);
-  set_irn_n(node, 0, left);
+/* INLINE void
+set_FuncCall_arity (ir_node *node, ir_node *arity) {
+  assert (node->op == op_FuncCall);
 }
+*/
 
 INLINE ir_node *
-get_Sub_right (ir_node *node) {
-  assert (node->op == op_Sub);
-  return get_irn_n(node, 1);
+get_FuncCall_param (ir_node *node, int pos) {
+  assert (node->op == op_FuncCall);
+  return get_irn_n(node, pos + CALL_PARAM_OFFSET);
 }
 
 INLINE void
-set_Sub_right (ir_node *node, ir_node *right) {
-  assert (node->op == op_Sub);
-  set_irn_n(node, 1, right);
+set_FuncCall_param (ir_node *node, int pos, ir_node *param) {
+  assert (node->op == op_FuncCall);
+  set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
 }
 
-
-INLINE ir_node *
-get_Minus_op (ir_node *node) {
-  assert (node->op == op_Minus);
-  return get_irn_n(node, 0);
+INLINE type *
+get_FuncCall_type (ir_node *node) {
+  assert (node->op == op_FuncCall);
+  return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
 }
 
 INLINE void
-set_Minus_op (ir_node *node, ir_node *op) {
-  assert (node->op == op_Minus);
-  set_irn_n(node, 0, op);
+set_FuncCall_type (ir_node *node, type *tp) {
+  assert (node->op == op_FuncCall);
+  assert (is_method_type(tp));
+  node->attr.call.cld_tp = tp;
 }
 
-
-INLINE ir_node *
-get_Mul_left (ir_node *node) {
-  assert (node->op == op_Mul);
-  return get_irn_n(node, 0);
+int FuncCall_has_callees(ir_node *node) {
+  return (node->attr.call.callee_arr != NULL);
 }
 
-INLINE void
-set_Mul_left (ir_node *node, ir_node *left) {
-  assert (node->op == op_Mul);
-  set_irn_n(node, 0, left);
+int get_FuncCall_n_callees(ir_node * node) {
+  assert(node->op == op_FuncCall && node->attr.call.callee_arr);
+  return ARR_LEN(node->attr.call.callee_arr);
 }
 
-INLINE ir_node *
-get_Mul_right (ir_node *node) {
-  assert (node->op == op_Mul);
-  return get_irn_n(node, 1);
+entity * get_FuncCall_callee(ir_node * node, int pos) {
+  assert(node->op == op_FuncCall && node->attr.call.callee_arr);
+  return node->attr.call.callee_arr[pos];
 }
 
-INLINE void
-set_Mul_right (ir_node *node, ir_node *right) {
-  assert (node->op == op_Mul);
-  set_irn_n(node, 1, right);
+void set_FuncCall_callee_arr(ir_node * node, int n, entity ** arr) {
+  assert(node->op == op_FuncCall);
+  if (node->attr.call.callee_arr == NULL || get_Call_n_callees(node) != n) {
+    node->attr.call.callee_arr = NEW_ARR_D(entity *, current_ir_graph->obst, n);
+  }
+  memcpy(node->attr.call.callee_arr, arr, n * sizeof(entity *));
 }
 
-INLINE ir_node *
-get_Quot_left (ir_node *node) {
-  assert (node->op == op_Quot);
-  return get_irn_n(node, 1);
+void remove_FuncCall_callee_arr(ir_node * node) {
+  assert(node->op == op_FuncCall);
+  node->attr.call.callee_arr = NULL;
 }
 
-INLINE void
-set_Quot_left (ir_node *node, ir_node *left) {
-  assert (node->op == op_Quot);
-  set_irn_n(node, 1, left);
-}
 
-INLINE ir_node *
-get_Quot_right (ir_node *node) {
-  assert (node->op == op_Quot);
-  return get_irn_n(node, 2);
+#define BINOP(OP)					\
+ir_node * get_##OP##_left(ir_node *node) {		\
+  assert(node->op == op_##OP);				\
+  return get_irn_n(node, node->op->op_index);		\
+}							\
+void set_##OP##_left(ir_node *node, ir_node *left) {	\
+  assert(node->op == op_##OP);				\
+  set_irn_n(node, node->op->op_index, left);		\
+}							\
+ir_node *get_##OP##_right(ir_node *node) {		\
+  assert(node->op == op_##OP);				\
+  return get_irn_n(node, node->op->op_index + 1);	\
+}							\
+void set_##OP##_right(ir_node *node, ir_node *right) {	\
+  assert(node->op == op_##OP);				\
+  set_irn_n(node, node->op->op_index + 1, right);	\
 }
 
-INLINE void
-set_Quot_right (ir_node *node, ir_node *right) {
-  assert (node->op == op_Quot);
-  set_irn_n(node, 2, right);
+#define UNOP(OP)					\
+ir_node *get_##OP##_op(ir_node *node) {			\
+  assert(node->op == op_##OP);				\
+  return get_irn_n(node, node->op->op_index);		\
+}							\
+void set_##OP##_op (ir_node *node, ir_node *op) {	\
+  assert(node->op == op_##OP);				\
+  set_irn_n(node, node->op->op_index, op);		\
 }
 
+BINOP(Add)
+BINOP(Sub)
+UNOP(Minus)
+BINOP(Mul)
+BINOP(Quot)
+
 INLINE ir_node *
 get_Quot_mem (ir_node *node) {
   assert (node->op == op_Quot);
@@ -1328,29 +1355,7 @@ set_Quot_mem (ir_node *node, ir_node *mem) {
   set_irn_n(node, 0, mem);
 }
 
-INLINE ir_node *
-get_DivMod_left (ir_node *node) {
-  assert (node->op == op_DivMod);
-  return get_irn_n(node, 1);
-}
-
-INLINE void
-set_DivMod_left (ir_node *node, ir_node *left) {
-  assert (node->op == op_DivMod);
-  set_irn_n(node, 1, left);
-}
-
-INLINE ir_node *
-get_DivMod_right (ir_node *node) {
-  assert (node->op == op_DivMod);
-  return get_irn_n(node, 2);
-}
-
-INLINE void
-set_DivMod_right (ir_node *node, ir_node *right) {
-  assert (node->op == op_DivMod);
-  set_irn_n(node, 2, right);
-}
+BINOP(DivMod)
 
 INLINE ir_node *
 get_DivMod_mem (ir_node *node) {
@@ -1364,29 +1369,7 @@ set_DivMod_mem (ir_node *node, ir_node *mem) {
   set_irn_n(node, 0, mem);
 }
 
-INLINE ir_node *
-get_Div_left (ir_node *node) {
-  assert (node->op == op_Div);
-  return get_irn_n(node, 1);
-}
-
-INLINE void
-set_Div_left (ir_node *node, ir_node *left) {
-  assert (node->op == op_Div);
-  set_irn_n(node, 1, left);
-}
-
-INLINE ir_node *
-get_Div_right (ir_node *node) {
-  assert (node->op == op_Div);
-  return get_irn_n(node, 2);
-}
-
-INLINE void
-set_Div_right (ir_node *node, ir_node *right) {
-  assert (node->op == op_Div);
-  set_irn_n(node, 2, right);
-}
+BINOP(Div)
 
 INLINE ir_node *
 get_Div_mem (ir_node *node) {
@@ -1400,29 +1383,7 @@ set_Div_mem (ir_node *node, ir_node *mem) {
   set_irn_n(node, 0, mem);
 }
 
-INLINE ir_node *
-get_Mod_left (ir_node *node) {
-  assert (node->op == op_Mod);
-  return get_irn_n(node, 1);
-}
-
-INLINE void
-set_Mod_left (ir_node *node, ir_node *left) {
-  assert (node->op == op_Mod);
-  set_irn_n(node, 1, left);
-}
-
-INLINE ir_node *
-get_Mod_right (ir_node *node) {
-  assert (node->op == op_Mod);
-  return get_irn_n(node, 2);
-}
-
-INLINE void
-set_Mod_right (ir_node *node, ir_node *right) {
-  assert (node->op == op_Mod);
-  set_irn_n(node, 2, right);
-}
+BINOP(Mod)
 
 INLINE ir_node *
 get_Mod_mem (ir_node *node) {
@@ -1436,247 +1397,18 @@ set_Mod_mem (ir_node *node, ir_node *mem) {
   set_irn_n(node, 0, mem);
 }
 
-INLINE ir_node *
-get_Abs_op (ir_node *node) {
-  assert (node->op == op_Abs);
-  return get_irn_n(node, 0);
-}
-
-INLINE void
-set_Abs_op (ir_node *node, ir_node *op) {
-  assert (node->op == op_Abs);
-  set_irn_n(node, 0, op);
-}
-
-INLINE ir_node *
-get_And_left (ir_node *node) {
-  assert (node->op == op_And);
-  return get_irn_n(node, 0);
-}
-
-INLINE void
-set_And_left (ir_node *node, ir_node *left) {
-  assert (node->op == op_And);
-  set_irn_n(node, 0, left);
-}
-
-INLINE ir_node *
-get_And_right (ir_node *node) {
-  assert (node->op == op_And);
-  return get_irn_n(node, 1);
-}
-
-INLINE void
-set_And_right (ir_node *node, ir_node *right) {
-  assert (node->op == op_And);
-  set_irn_n(node, 1, right);
-}
-
-INLINE ir_node *
-get_Or_left (ir_node *node) {
-  assert (node->op == op_Or);
-  return get_irn_n(node, 0);
-}
-
-INLINE void
-set_Or_left (ir_node *node, ir_node *left) {
-  assert (node->op == op_Or);
-  set_irn_n(node, 0, left);
-}
-
-INLINE ir_node *
-get_Or_right (ir_node *node) {
-  assert (node->op == op_Or);
-  return get_irn_n(node, 1);
-}
-
-INLINE void
-set_Or_right (ir_node *node, ir_node *right) {
-  assert (node->op == op_Or);
-  set_irn_n(node, 1, right);
-}
-
-INLINE ir_node *
-get_Eor_left (ir_node *node) {
-  assert (node->op == op_Eor);
-  return get_irn_n(node, 0);
-}
-
-INLINE void
-set_Eor_left (ir_node *node, ir_node *left) {
-  assert (node->op == op_Eor);
-  set_irn_n(node, 0, left);
-}
-
-INLINE ir_node *
-get_Eor_right (ir_node *node) {
-  assert (node->op == op_Eor);
-  return get_irn_n(node, 1);
-}
-
-INLINE void
-set_Eor_right (ir_node *node, ir_node *right) {
-  assert (node->op == op_Eor);
-  set_irn_n(node, 1, right);
-}
-
-
-INLINE ir_node *
-get_Not_op (ir_node *node) {
-  assert (node->op == op_Not);
-  return get_irn_n(node, 0);
-}
-
-INLINE void
-set_Not_op (ir_node *node, ir_node *op) {
-  assert (node->op == op_Not);
-  set_irn_n(node, 0, op);
-}
-
-
-INLINE ir_node *
-get_Shl_left (ir_node *node) {
-  assert (node->op == op_Shl);
-  return get_irn_n(node, 0);
-}
-
-INLINE void
-set_Shl_left (ir_node *node, ir_node *left) {
-  assert (node->op == op_Shl);
-  set_irn_n(node, 0, left);
-}
-
-INLINE ir_node *
-get_Shl_right (ir_node *node) {
-  assert (node->op == op_Shl);
-  return get_irn_n(node, 1);
-}
-
-INLINE void
-set_Shl_right (ir_node *node, ir_node *right) {
-  assert (node->op == op_Shl);
-  set_irn_n(node, 1, right);
-}
-
-INLINE ir_node *
-get_Shr_left (ir_node *node) {
-  assert (node->op == op_Shr);
-  return get_irn_n(node, 0);
-}
-
-INLINE void
-set_Shr_left (ir_node *node, ir_node *left) {
-  assert (node->op == op_Shr);
-  set_irn_n(node, 0, left);
-}
-
-INLINE ir_node *
-get_Shr_right (ir_node *node) {
-  assert (node->op == op_Shr);
-  return get_irn_n(node, 1);
-}
-
-INLINE void
-set_Shr_right (ir_node *node, ir_node *right) {
-  assert (node->op == op_Shr);
-  set_irn_n(node, 1, right);
-}
-
-INLINE ir_node *
-get_Shrs_left (ir_node *node) {
-  assert (node->op == op_Shrs);
-  return get_irn_n(node, 0);
-}
-
-INLINE void
-set_Shrs_left (ir_node *node, ir_node *left) {
-  assert (node->op == op_Shrs);
-  set_irn_n(node, 0, left);
-}
-
-INLINE ir_node *
-get_Shrs_right (ir_node *node) {
-  assert (node->op == op_Shrs);
-  return get_irn_n(node, 1);
-}
-
-INLINE void
-set_Shrs_right (ir_node *node, ir_node *right) {
-  assert (node->op == op_Shrs);
-  set_irn_n(node, 1, right);
-}
-
-INLINE ir_node *
-get_Rot_left (ir_node *node) {
-  assert (node->op == op_Rot);
-  return get_irn_n(node, 0);
-}
-
-INLINE void
-set_Rot_left (ir_node *node, ir_node *left) {
-  assert (node->op == op_Rot);
-  set_irn_n(node, 0, left);
-}
-
-INLINE ir_node *
-get_Rot_right (ir_node *node) {
-  assert (node->op == op_Rot);
-  return get_irn_n(node, 1);
-}
-
-INLINE void
-set_Rot_right (ir_node *node, ir_node *right) {
-  assert (node->op == op_Rot);
-  set_irn_n(node, 1, right);
-}
-
-INLINE ir_node *
-get_Cmp_left (ir_node *node) {
-  assert (node->op == op_Cmp);
-  return get_irn_n(node, 0);
-}
-
-INLINE void
-set_Cmp_left (ir_node *node, ir_node *left) {
-  assert (node->op == op_Cmp);
-  set_irn_n(node, 0, left);
-}
-
-INLINE ir_node *
-get_Cmp_right (ir_node *node) {
-  assert (node->op == op_Cmp);
-  return get_irn_n(node, 1);
-}
-
-INLINE void
-set_Cmp_right (ir_node *node, ir_node *right) {
-  assert (node->op == op_Cmp);
-  set_irn_n(node, 1, right);
-}
-
-INLINE ir_node *
-get_Conv_op (ir_node *node) {
-  assert (node->op == op_Conv);
-  return get_irn_n(node, 0);
-}
-
-INLINE void
-set_Conv_op (ir_node *node, ir_node *op) {
-  assert (node->op == op_Conv);
-  set_irn_n(node, 0, op);
-}
-
-INLINE ir_node *
-get_Cast_op (ir_node *node) {
-  assert (node->op == op_Cast);
-  return get_irn_n(node, 0);
-}
-
-INLINE void
-set_Cast_op (ir_node *node, ir_node *op) {
-  assert (node->op == op_Cast);
-  set_irn_n(node, 0, op);
-}
+UNOP(Abs)
+BINOP(And)
+BINOP(Or)
+BINOP(Eor)
+UNOP(Not)
+BINOP(Shl)
+BINOP(Shr)
+BINOP(Shrs)
+BINOP(Rot)
+BINOP(Cmp)
+UNOP(Conv)
+UNOP(Cast)
 
 INLINE type *
 get_Cast_type (ir_node *node) {
@@ -1697,152 +1429,66 @@ is_unop (ir_node *node) {
 
 INLINE ir_node *
 get_unop_op (ir_node *node) {
-  assert (is_unop(node));
-  switch (get_irn_opcode (node)) {
-    case iro_Minus: return get_Minus_op(node); break;
-    case iro_Abs:   return get_Abs_op(node);   break;
-    case iro_Not:   return get_Not_op(node);   break;
-    case iro_Conv:  return get_Conv_op(node);  break;
-    case iro_Cast:  return get_Cast_op(node);  break;
-    default: return NULL;
-  }
+  if (node->op->opar == oparity_unary)
+    return get_irn_n(node, node->op->op_index);
+
+  assert(node->op->opar == oparity_unary);
+  return NULL;
 }
 
 INLINE void
 set_unop_op (ir_node *node, ir_node *op) {
-  assert (is_unop(node));
-  switch (get_irn_opcode (node)) {
-    case iro_Minus:   set_Minus_op(node, op); break;
-    case iro_Abs:     set_Abs_op(node, op);   break;
-    case iro_Not:     set_Not_op(node, op);   break;
-    case iro_Conv:    set_Conv_op(node, op);  break;
-    case iro_Cast:    set_Cast_op(node, op);  break;
-    default:  ;
-  }
+  if (node->op->opar == oparity_unary)
+    set_irn_n(node, node->op->op_index, op);
 
+  assert(node->op->opar == oparity_unary);
 }
 
 int
 is_binop (ir_node *node) {
   return (node->op->opar == oparity_binary);
-  /*  return (node->op == op_Add    ||
-          node->op == op_Cmp    ||
-          node->op == op_Sub    ||
-          node->op == op_Mul    ||
-          node->op == op_Quot   ||
-          node->op == op_DivMod ||
-          node->op == op_Div    ||
-          node->op == op_Mod    ||
-          node->op == op_And    ||
-          node->op == op_Or     ||
-          node->op == op_Eor    ||
-          node->op == op_Shl    ||
-          node->op == op_Shr    ||
-          node->op == op_Shrs   ||
-	  node->op == op_Rot      );
-  */
 }
 
 INLINE ir_node *
 get_binop_left (ir_node *node) {
-  assert (node->op->opar == oparity_binary);
+  if (node->op->opar == oparity_binary)
+    return get_irn_n(node, node->op->op_index);
 
-    switch (get_irn_opcode (node)) {
-      case iro_Add   :     return get_Add_left(node);  break;
-      case iro_Sub   :     return get_Sub_left(node);  break;
-      case iro_Mul   :     return get_Mul_left(node);  break;
-      case iro_Quot  :     return get_Quot_left(node); break;
-      case iro_DivMod:     return get_DivMod_left(node);  break;
-      case iro_Div   :     return get_Div_left(node);  break;
-      case iro_Mod   :     return get_Mod_left(node);  break;
-      case iro_And   :     return get_And_left(node);  break;
-      case iro_Or    :     return get_Or_left(node);   break;
-      case iro_Eor   :     return get_Eor_left(node);  break;
-      case iro_Shl   :     return get_Shl_left(node);  break;
-      case iro_Shr   :     return get_Shr_left(node);  break;
-      case iro_Shrs  :     return get_Shrs_left(node); break;
-      case iro_Rot   :     return get_Rot_left(node);  break;
-      case iro_Cmp   :     return get_Cmp_left(node);  break;
-    default:  return NULL;
-  };
+  assert(node->op->opar == oparity_binary);
+  return NULL;
 }
 
 INLINE void
 set_binop_left (ir_node *node, ir_node *left) {
-  assert (node->op->opar == oparity_binary);
+  if (node->op->opar == oparity_binary)
+    set_irn_n(node, node->op->op_index, left);
 
-    switch (get_irn_opcode (node)) {
-      case iro_Add   :     set_Add_left(node, left);  break;
-      case iro_Sub   :     set_Sub_left(node, left);  break;
-      case iro_Mul   :     set_Mul_left(node, left);  break;
-      case iro_Quot  :     set_Quot_left(node, left); break;
-      case iro_DivMod:     set_DivMod_left(node, left);  break;
-      case iro_Div   :     set_Div_left(node, left);  break;
-      case iro_Mod   :     set_Mod_left(node, left);  break;
-      case iro_And   :     set_And_left(node, left);  break;
-      case iro_Or    :     set_Or_left(node, left);   break;
-      case iro_Eor   :     set_Eor_left(node, left);  break;
-      case iro_Shl   :     set_Shl_left(node, left);  break;
-      case iro_Shr   :     set_Shr_left(node, left);  break;
-      case iro_Shrs  :     set_Shrs_left(node, left); break;
-      case iro_Rot   :     set_Rot_left(node, left);  break;
-      case iro_Cmp   :     set_Cmp_left(node, left);  break;
-    default:  ;
-  };
+  assert (node->op->opar == oparity_binary);
 }
 
 INLINE ir_node *
 get_binop_right (ir_node *node) {
-  assert (node->op->opar == oparity_binary);
+  if (node->op->opar == oparity_binary)
+    return get_irn_n(node, node->op->op_index + 1);
 
-    switch (get_irn_opcode (node)) {
-      case iro_Add   :     return get_Add_right(node);  break;
-      case iro_Sub   :     return get_Sub_right(node);  break;
-      case iro_Mul   :     return get_Mul_right(node);  break;
-      case iro_Quot  :     return get_Quot_right(node); break;
-      case iro_DivMod:     return get_DivMod_right(node);  break;
-      case iro_Div   :     return get_Div_right(node);  break;
-      case iro_Mod   :     return get_Mod_right(node);  break;
-      case iro_And   :     return get_And_right(node);  break;
-      case iro_Or    :     return get_Or_right(node);   break;
-      case iro_Eor   :     return get_Eor_right(node);  break;
-      case iro_Shl   :     return get_Shl_right(node);  break;
-      case iro_Shr   :     return get_Shr_right(node);  break;
-      case iro_Shrs  :     return get_Shrs_right(node); break;
-      case iro_Rot   :     return get_Rot_right(node);  break;
-      case iro_Cmp   :     return get_Cmp_right(node);  break;
-    default:  return NULL;
-  };
+  assert(node->op->opar == oparity_binary);
+  return NULL;
 }
 
 INLINE void
 set_binop_right (ir_node *node, ir_node *right) {
-  assert (node->op->opar == oparity_binary);
+  if (node->op->opar == oparity_binary)
+    set_irn_n(node, node->op->op_index + 1, right);
 
-    switch (get_irn_opcode (node)) {
-      case iro_Add   :     set_Add_right(node, right);  break;
-      case iro_Sub   :     set_Sub_right(node, right);  break;
-      case iro_Mul   :     set_Mul_right(node, right);  break;
-      case iro_Quot  :     set_Quot_right(node, right); break;
-      case iro_DivMod:     set_DivMod_right(node, right);  break;
-      case iro_Div   :     set_Div_right(node, right);  break;
-      case iro_Mod   :     set_Mod_right(node, right);  break;
-      case iro_And   :     set_And_right(node, right);  break;
-      case iro_Or    :     set_Or_right(node, right);   break;
-      case iro_Eor   :     set_Eor_right(node, right);  break;
-      case iro_Shl   :     set_Shl_right(node, right);  break;
-      case iro_Shr   :     set_Shr_right(node, right);  break;
-      case iro_Shrs  :     set_Shrs_right(node, right); break;
-      case iro_Rot   :     set_Rot_right(node, right);  break;
-      case iro_Cmp   :     set_Cmp_right(node, right);  break;
-    default: ;
-  };
+  assert (node->op->opar == oparity_binary);
 }
 
 INLINE int is_Phi (ir_node *n) {
+  ir_op *op;
+
   assert(n);
-  return ((get_irn_op(n) == op_Phi) ||
-	  (get_irn_op(n) == op_Filter && interprocedural_view));
+  op = get_irn_op(n);
+  return (op == op_Phi) || (op == op_Filter && interprocedural_view);
 }
 
 INLINE ir_node **
@@ -2224,9 +1870,9 @@ get_irn_irg(ir_node *node) {
 }
 
 
-/******************************************************************/
+/*----------------------------------------------------------------*/
 /*  Auxiliary routines                                            */
-/******************************************************************/
+/*----------------------------------------------------------------*/
 
 INLINE ir_node *
 skip_Proj (ir_node *node) {
@@ -2378,19 +2024,9 @@ ir_graph *get_ip_cfop_irg(ir_node *n) {
    of an exception. */
 int
 is_fragile_op(ir_node *node) {
-  return (   (get_irn_opcode(node) == iro_Call)
-          || (get_irn_opcode(node) == iro_Quot)
-          || (get_irn_opcode(node) == iro_DivMod)
-          || (get_irn_opcode(node) == iro_Div)
-          || (get_irn_opcode(node) == iro_Mod)
-          || (get_irn_opcode(node) == iro_Load)
-          || (get_irn_opcode(node) == iro_Store)
-          || (get_irn_opcode(node) == iro_Alloc)
-          || (get_irn_opcode(node) == iro_Bad)
-          || (get_irn_opcode(node) == iro_Unknown));
+  return is_op_fragile(get_irn_op(node));
 }
 
-
 /* Returns the memory operand of fragile operations. */
 ir_node *get_fragile_op_mem(ir_node *node) {
   assert(node && is_fragile_op(node));