Typo fixed.

[libfirm] / ir / ir / irnode.c

diff --git a/ir/ir/irnode.c b/ir/ir/irnode.c
index bf480c1..b33fbe0 100644 (file)
--- a/ir/ir/irnode.c
+++ b/ir/ir/irnode.c
@@ -785,7 +785,7 @@ set_Return_res (ir_node *node, int pos, ir_node *res){
 
 INLINE ir_node *
 get_Raise_mem (ir_node *node) {
-  assert (node->op == op_Return);
+  assert (node->op == op_Raise);
   return get_irn_n(node, 0);
 }
 
@@ -976,7 +976,7 @@ set_InstOf_obj (ir_node *node, ir_node *obj) {
 /* For unary and binary arithmetic operations the access to the
    operands can be factored out.  Left is the first, right the
    second arithmetic value  as listed in tech report 0999-33.
-   unops are: Minus, Abs, Not, Conv
+   unops are: Minus, Abs, Not, Conv, Cast
    binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
    Shr, Shrs, Rotate, Cmp */
 
@@ -1558,44 +1558,63 @@ set_Conv_op (ir_node *node, ir_node *op) {
   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);
+}
 
-int
+INLINE type *
+get_Cast_type (ir_node *node) {
+  assert (node->op == op_Cast);
+  return node->attr.cast.totype;
+}
+
+INLINE void
+set_Cast_type (ir_node *node, type *to_tp) {
+  assert (node->op == op_Cast);
+  node->attr.cast.totype = to_tp;
+}
+
+INLINE int
 is_unop (ir_node *node) {
   return ( node->op == op_Minus ||
            node->op == op_Abs  ||
           node->op == op_Not  ||
-           node->op == op_Conv );
+           node->op == op_Conv ||
+           node->op == op_Cast );
 }
 
 INLINE ir_node *
 get_unop_op (ir_node *node) {
-  assert ( node->op == op_Minus ||
-           node->op == op_Abs  ||
-           node->op == op_Not  ||
-           node->op == op_Conv );
+  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;
   }
 }
 
 INLINE void
 set_unop_op (ir_node *node, ir_node *op) {
-    assert (node->op == op_Minus ||
-           node->op == op_Abs   ||
-           node->op == op_Not   ||
-           node->op == op_Conv    );
-    switch (get_irn_opcode (node)) {
+  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:  ;
-    }
+  }
 
 }
 
@@ -2161,24 +2180,6 @@ skip_Tuple (ir_node *node) {
   return node;
 }
 
-#if 1
-INLINE ir_node *
-skip_nop (ir_node *node) {
-  /* don't assert node !!! */
-
-  if (!get_opt_normalize()) return node;
-
-  /* Don't use get_Id_pred:  We get into an endless loop for
-     self-referencing Ids. */
-  if (node && (node->op == op_Id) && (node != node->in[0+1])) {
-    assert (get_irn_arity (node) > 0);
-    return node->in[0+1];
-  } else {
-    return node;
-  }
-}
-#else
-
 /* This should compact Id-cycles to self-cycles. It has the same (or less?) complexity
    than any other approach, as Id chains are resolved and all point to the real node, or
    all id's are self loops. */
@@ -2197,7 +2198,7 @@ skip_nop (ir_node *node) {
     assert (get_irn_arity (node) > 0);
 
     node->in[0+1] = node;
-    res = skip_nop(pred);
+    res = skip_nop(rem_pred);
     if (res->op == op_Id) /* self-loop */ return node;
 
     node->in[0+1] = res;
@@ -2207,8 +2208,6 @@ skip_nop (ir_node *node) {
   }
 }
 
-#endif
-
 INLINE ir_node *
 skip_Id (ir_node *node) {
   return skip_nop(node);