X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firvrfy.c;h=722a7f357117baf1d71f1770895857fb36463aff;hb=cb91bddc9cacdab7c28e4336847bd3dc248aa549;hp=30623d2da8e7ade9ef80a8653289d949601786da;hpb=d3e15bdfaeb58ff118ca441169217af21d4d2d00;p=libfirm

diff --git a/ir/ir/irvrfy.c b/ir/ir/irvrfy.c
index 30623d2da..722a7f357 100644
--- a/ir/ir/irvrfy.c
+++ b/ir/ir/irvrfy.c
@@ -61,12 +61,21 @@ do { \
 
 #endif
 
+/** if this flag is set, verify entity types in Load & Store nodes */
+static int vrfy_entities = 0;
+
 /* @@@ replace use of array "in" by access functions. */
 ir_node **get_irn_in(ir_node *node);
 
 static node_verification_t opt_do_node_verification = NODE_VERIFICATION_ON;
 static const char *bad_msg;
 
+/* enable verification of Load/Store entities */
+void vrfy_enable_entity_tests(int enable)
+{
+  vrfy_entities = enable;
+}
+
 /**
  * little helper for NULL modes
  */
@@ -237,6 +246,16 @@ static void show_phi_inputs(ir_node *phi, ir_node *block)
     get_irn_node_nr(block), get_irn_arity(block));
 }
 
+/* If the address is Sel or SymConst, return the entity. */
+static entity *get_ptr_entity(ir_node *ptr) {
+  if (get_irn_op(ptr) == op_Sel) {
+    return get_Sel_entity(ptr);
+  } else if ((get_irn_op(ptr) == op_SymConst) && (get_SymConst_kind(ptr) == symconst_addr_ent)) {
+    return get_SymConst_entity(ptr);
+  }
+  return NULL;
+}
+
 /**
  * verify the Proj number
  */
@@ -370,38 +389,31 @@ vrfy_Proj_proj(ir_node *p, ir_graph *irg) {
 
     case iro_Load:
       if (proj == pn_Load_res) {
-    ir_node *ptr = get_Load_ptr(pred);
-    entity *ent = NULL;
-    if (get_irn_op(ptr) == op_Sel) {
-      ent = get_Sel_entity(ptr);
-    } /*
-        We may not test this, after lowering and optimization the Const can
-        have an unexpected type.
-    else if ((get_irn_op(ptr) == op_Const) &&
-           tarval_is_entity(get_Const_tarval(ptr))) {
-      ent = get_tarval_entity(get_Const_tarval(ptr));
-    } */
-    if (ent) {
-      ASSERT_AND_RET_DBG(
-        (mode == get_type_mode(get_entity_type(ent))),
-        "wrong data Proj from Load, entity type_mode failed", 0,
-        show_proj_failure_ent(p, ent);
-      );
-    }
-    else {
-      ASSERT_AND_RET_DBG(
-        mode_is_data(mode),
-       "wrong data Proj from Load", 0,
-       show_proj_failure(p);
-     );
-    }
+	ir_node *ptr = get_Load_ptr(pred);
+	entity *ent = get_ptr_entity(ptr);
+
+	if (vrfy_entities && ent && get_irg_phase_state(current_ir_graph) == phase_high) {
+	  /* do NOT check this for lowered phases, see comment on Store */
+	  ASSERT_AND_RET_DBG(
+			     (mode == get_type_mode(get_entity_type(ent))),
+			     "wrong data Proj from Load, entity type_mode failed", 0,
+			     show_proj_failure_ent(p, ent);
+			     );
+	}
+	else {
+	  ASSERT_AND_RET_DBG(
+			     mode_is_data(mode) && mode == get_Load_mode(pred),
+			     "wrong data Proj from Load", 0,
+			     show_proj_failure(p);
+			     );
+	}
       } else {
-    ASSERT_AND_RET_DBG(
-      ((proj == pn_Load_M        && mode == mode_M) ||
-       (proj == pn_Load_X_except && mode == mode_X)),
-          "wrong Proj from Load", 0,
-      show_proj_failure(p);
-    );
+	ASSERT_AND_RET_DBG(
+			   ((proj == pn_Load_M        && mode == mode_M) ||
+			    (proj == pn_Load_X_except && mode == mode_X)),
+			   "wrong Proj from Load", 0,
+			   show_proj_failure(p);
+			   );
       }
       break;
 
@@ -410,7 +422,7 @@ vrfy_Proj_proj(ir_node *p, ir_graph *irg) {
         ((proj == pn_Store_M        && mode == mode_M) ||
          (proj == pn_Store_X_except && mode == mode_X)),
         "wrong Proj from Store", 0,
-    show_proj_failure(p);
+        show_proj_failure(p);
       );
       break;
 
@@ -1064,6 +1076,18 @@ int irn_vrfy_irg(ir_node *n, ir_graph *irg)
                      "Store node", 0
                      );
       ASSERT_AND_RET(mymode == mode_T, "Store node", 0);
+
+      entity *target = get_ptr_entity(in[2]);
+      if (vrfy_entities && target && get_irg_phase_state(current_ir_graph) == phase_high) {
+	/*
+	 * If lowered code, any Sels that add 0 may be removed, causing
+	 * an direct access to entities of array or compound type.
+	 * Prevent this by checking the phase.
+	 */
+	ASSERT_AND_RET( op3mode == get_type_mode(get_entity_type(target)),
+			"Store node", 0);
+      }
+
       break;
 
     case iro_Alloc:
@@ -1156,7 +1180,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;
 
@@ -1186,3 +1210,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;
+}