added code that could check for bads

[r3868]

diff --git a/ir/ir/irvrfy.c b/ir/ir/irvrfy.c
index 5d40c32..072d439 100644 (file)
--- a/ir/ir/irvrfy.c
+++ b/ir/ir/irvrfy.c
@@ -1163,7 +1163,7 @@ int irg_vrfy(ir_graph *irg)
 
   assert(get_irg_pinned(irg) == op_pin_state_pinned);
 
-  irg_walk(irg->end, vrfy_wrap, NULL, &res);
+  irg_walk_graph(irg, vrfy_wrap, NULL, &res);
 
   current_ir_graph = rem;
 
@@ -1193,3 +1193,114 @@ int irn_vrfy_irg_dump(ir_node *n, ir_graph *irg, const char **bad_string)
 
   return res;
 }
+
+
+typedef struct _vrfy_bad_env_t {
+  int flags;
+  int res;
+} vrfy_bad_env_t;
+
+static void check_bads(ir_node *node, void *env)
+{
+  vrfy_bad_env_t *venv = env;
+  int i, arity = get_irn_arity(node);
+
+  if (is_Block(node)) {
+    if ((venv->flags & BAD_CF) == 0) {
+
+      /* check for Bad Block predecessor */
+      for (i = 0; i < arity; ++i) {
+        ir_node *pred = get_irn_n(node, i);
+
+       if (is_Bad(pred)) {
+         venv->res |= BAD_CF;
+
+         if (opt_do_node_verification == NODE_VERIFICATION_REPORT) {
+           fprintf(stderr, "irg_vrfy_bads: Block %ld has Bad predecessor\n", get_irn_node_nr(node));
+         }
+         if (opt_do_node_verification == NODE_VERIFICATION_ON) {
+           assert(0 && "Bad CF detected");
+         }
+       }
+      }
+    }
+  }
+  else {
+    if ((venv->flags & BAD_BLOCK) == 0) {
+
+      /* check for Bad Block */
+      if (is_Bad(get_nodes_block(node))) {
+       venv->res |= BAD_BLOCK;
+
+       if (opt_do_node_verification == NODE_VERIFICATION_REPORT) {
+         fprintf(stderr, "irg_vrfy_bads: node %ld has Bad Block\n", get_irn_node_nr(node));
+       }
+       if (opt_do_node_verification == NODE_VERIFICATION_ON) {
+         assert(0 && "Bad CF detected");
+       }
+      }
+    }
+
+    if ((venv->flags & TUPLE) == 0) {
+      if (get_irn_op(node) == op_Tuple) {
+       venv->res |= TUPLE;
+
+       if (opt_do_node_verification == NODE_VERIFICATION_REPORT) {
+         fprintf(stderr, "irg_vrfy_bads: node %ld is a Tuple\n", get_irn_node_nr(node));
+       }
+       if (opt_do_node_verification == NODE_VERIFICATION_ON) {
+         assert(0 && "Tuple detected");
+       }
+      }
+    }
+
+    for (i = 0; i < arity; ++i) {
+      ir_node *pred = get_irn_n(node, i);
+
+      if (is_Bad(pred)) {
+       /* check for Phi with Bad inputs */
+       if (is_Phi(node) && !is_Bad(get_nodes_block(node)) && is_Bad(get_irn_n(get_nodes_block(node), i))) {
+         if (venv->flags & BAD_CF)
+           continue;
+         else {
+           venv->res |= BAD_CF;
+
+           if (opt_do_node_verification == NODE_VERIFICATION_REPORT) {
+             fprintf(stderr, "irg_vrfy_bads: Phi %ld has Bad Input\n", get_irn_node_nr(node));
+           }
+           if (opt_do_node_verification == NODE_VERIFICATION_ON) {
+             assert(0 && "Bad CF detected");
+           }
+         }
+       }
+
+       /* Bad node input */
+       if ((venv->flags & BAD_DF) == 0) {
+         venv->res |= BAD_DF;
+
+         if (opt_do_node_verification == NODE_VERIFICATION_REPORT) {
+           fprintf(stderr, "irg_vrfy_bads: node %ld has Bad Input\n", get_irn_node_nr(node));
+         }
+         if (opt_do_node_verification == NODE_VERIFICATION_ON) {
+           assert(0 && "Bad NON-CF detected");
+         }
+       }
+      }
+    }
+  }
+}
+
+/*
+ * verify occurance of bad nodes
+ */
+int irg_vrfy_bads(ir_graph *irg, int flags)
+{
+  vrfy_bad_env_t env;
+
+  env.flags = flags;
+  env.res   = 0;
+
+  irg_walk_graph(irg, check_bads, NULL, &env);
+
+  return env.res;
+}

diff --git a/ir/ir/irvrfy.h b/ir/ir/irvrfy.h
index 46d6170..7c08056 100644 (file)
--- a/ir/ir/irvrfy.h
+++ b/ir/ir/irvrfy.h
@@ -73,4 +73,24 @@ int irn_vrfy_irg_dump(struct ir_node *checknode, ir_graph *irg, const char **bad
  */
 int irg_vrfy(ir_graph *irg);
 
+/**
+ * Possible flags for irg_vrfy_bads().
+ */
+enum verify_bad_flags_t {
+  BAD_CF      = 1,     /**< Bad nodes are allowed as predecessors of Blocks and Phis. */
+  BAD_DF      = 2,     /**< Bad nodes are allowed as dataflow predecessors. */
+  BAD_BLOCK   = 4,     /**< Bad nodes are allowed as Block input. */
+  TUPLE       = 8      /**< Tuple nodes are allowed. */
+};
+
+/**
+ * Verify occurance of bad nodes in a graph.
+ *
+ * @param irg    The graph to verify
+ * @param flags  combination of verify_bad_flags_t flags describing
+ *               which Bads are allowed
+ * @returns      a value combined of verify_bad_flags_t indicating the problems found.
+ */
+int irg_vrfy_bads(ir_graph *irg, int flags);
+
 # endif /* _IRVRFY_H_ */