renamed all type * to ir_type *

[libfirm] / ir / ir / irvrfy.c

diff --git a/ir/ir/irvrfy.c b/ir/ir/irvrfy.c
index e7dcd62..5874d62 100644 (file)
--- a/ir/ir/irvrfy.c
+++ b/ir/ir/irvrfy.c
@@ -23,6 +23,7 @@
 # include "irdump.h"
 # include "irdom_t.h"
 # include "irprintf.h"
+# include "irouts.h"
 
 /** if this flag is set, verify entity types in Load & Store nodes */
 static int vrfy_entities = 0;
@@ -718,8 +719,8 @@ verify_node_Proj(ir_node *p, ir_graph *irg) {
 
   op = get_irn_op(pred);
 
-  if (op->verify_proj_node)
-    return op->verify_proj_node(pred, p);
+  if (op->ops.verify_proj_node)
+    return op->ops.verify_proj_node(pred, p);
 
   /* all went ok */
   return 1;
@@ -829,11 +830,12 @@ static int verify_node_Cond(ir_node *n, ir_graph *irg) {
   );
   ASSERT_AND_RET(mymode == mode_T, "Cond mode is not a tuple", 0);
 
-  if (op1mode == mode_b && get_irg_outs_state(irg) == outs_consistent) {
+  if (op1mode == mode_b && get_irg_outs_state(irg) == outs_consistent &&
+      !is_Block_dead(get_nodes_block(n))) {
     /* we have consistent outs, check for the right number of Proj's */
     ASSERT_AND_RET(
-      get_irn_n_outs(n) == 2,
-      "BinaryCond node must have 2 successors", 0);
+    get_irn_n_outs(n) == 2,
+   "Live binary Cond node must have 2 successors", 0);
   }
   return 1;
 }
@@ -1568,6 +1570,37 @@ static int verify_node_Mux(ir_node *n, ir_graph *irg) {
   return 1;
 }
 
+/**
+ * verify a CopyB node
+ */
+static int verify_node_CopyB(ir_node *n, ir_graph *irg) {
+  ir_mode *mymode  = get_irn_mode(n);
+  ir_mode *op1mode = get_irn_mode(get_CopyB_mem(n));
+  ir_mode *op2mode = get_irn_mode(get_CopyB_dst(n));
+  ir_mode *op3mode = get_irn_mode(get_CopyB_src(n));
+  type *t = get_CopyB_type(n);
+
+  /* CopyB: BB x M x ref x ref --> M x X */
+  ASSERT_AND_RET(
+    mymode == mode_T &&
+    op1mode == mode_M &&
+    mode_is_reference(op2mode) &&
+    mode_is_reference(op3mode),
+    "CopyB node", 0 );  /* operand M x ref x ref */
+
+  ASSERT_AND_RET(
+    is_compound_type(t),
+    "CopyB node should copy compound types only", 0 );
+
+  /* NoMem nodes are only allowed as memory input if the CopyB is NOT pinned.
+     This should happen RARELY, as CopyB COPIES MEMORY */
+  ASSERT_AND_RET(
+    (get_irn_op(get_CopyB_mem(n)) == op_NoMem) ||
+    (get_irn_op(get_CopyB_mem(n)) != op_NoMem && get_irn_pinned(n) == op_pin_state_pinned),
+    "CopyB node with wrong memory input", 0 );
+  return 1;
+}
+
 /*
  * Check dominance.
  * For each usage of a node, it is checked, if the block of the
@@ -1610,6 +1643,7 @@ static int check_dominance_for_node(ir_node *use)
   return 1;
 }
 
+/* Tests the modes of n and its predecessors. */
 int irn_vrfy_irg(ir_node *n, ir_graph *irg)
 {
   int i;
@@ -1641,8 +1675,8 @@ int irn_vrfy_irg(ir_node *n, ir_graph *irg)
         return 1;
     }
 
-  if (op->verify_node)
-    return op->verify_node(n, irg);
+  if (op->ops.verify_node)
+    return op->ops.verify_node(n, irg);
 
   /* All went ok */
   return 1;
@@ -1700,7 +1734,7 @@ int irg_verify(ir_graph *irg, unsigned flags)
   current_ir_graph = irg;
   last_irg_error = NULL;
 
-  assert(get_irg_pinned(irg) == op_pin_state_pinned);
+  assert(get_irg_pinned(irg) == op_pin_state_pinned && "Verification need pinned graph");
 
   if (flags & VRFY_ENFORCE_SSA)
     compute_doms(irg);
@@ -1862,14 +1896,14 @@ int irg_vrfy_bads(ir_graph *irg, int flags)
 /*
  * set the default verify operation
  */
-void firm_set_default_verifyer(ir_op *op)
+void firm_set_default_verifyer(opcode code, ir_op_ops *ops)
 {
-#define CASE(a)                          \
-   case iro_##a:                         \
-     op->verify_node  = verify_node_##a; \
+#define CASE(a)                           \
+   case iro_##a:                          \
+     ops->verify_node  = verify_node_##a; \
      break
 
-   switch (op->code) {
+   switch (code) {
    CASE(Proj);
    CASE(Block);
    CASE(Start);
@@ -1913,17 +1947,18 @@ void firm_set_default_verifyer(ir_op *op)
    CASE(Sync);
    CASE(Confirm);
    CASE(Mux);
+   CASE(CopyB);
    default:
-     op->verify_node = NULL;
+     /* leave NULL */;
    }
 #undef CASE
 
 #define CASE(a)                          \
    case iro_##a:                         \
-     op->verify_proj_node  = verify_node_Proj_##a; \
+     ops->verify_proj_node  = verify_node_Proj_##a; \
      break
 
-   switch (op->code) {
+   switch (code) {
    CASE(Start);
    CASE(Cond);
    CASE(Raise);
@@ -1943,7 +1978,7 @@ void firm_set_default_verifyer(ir_op *op)
    CASE(EndReg);
    CASE(EndExcept);
    default:
-     op->verify_proj_node = NULL;
+     /* leave NULL */;
    }
 #undef CASE
 }