X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firvrfy.c;h=90a8eec5387591dc6c0931bfa3d083bf7e7639df;hb=b84d550997d07bfcc4d828e8fbb5742098e050e4;hp=bb70390a2f65f0aaff2e2ac7d9589447ef25e5b3;hpb=67499260e61f041dc855885ce8ded6ef213760d7;p=libfirm

diff --git a/ir/ir/irvrfy.c b/ir/ir/irvrfy.c
index bb70390a2..90a8eec53 100644
--- a/ir/ir/irvrfy.c
+++ b/ir/ir/irvrfy.c
@@ -14,20 +14,21 @@
 # include "config.h"
 #endif
 
-# include "irprog.h"
-# include "irop_t.h"
-# include "irgraph_t.h"
-# include "ircgcons.h"
-# include "irvrfy_t.h"
-# include "irgwalk.h"
-# include "irdump.h"
-# include "irdom_t.h"
-# include "irprintf.h"
+#include "irprog.h"
+#include "irop_t.h"
+#include "irgraph_t.h"
+#include "ircgcons.h"
+#include "irvrfy_t.h"
+#include "irgwalk.h"
+#include "irdump.h"
+#include "irdom_t.h"
+#include "irprintf.h"
+#include "irouts.h"
+#include "irflag_t.h"
 
 /** if this flag is set, verify entity types in Load & Store nodes */
 static int vrfy_entities = 0;
 
-node_verification_t opt_do_node_verification = NODE_VERIFICATION_ON;
 const char *firm_vrfy_failure_msg;
 
 /* enable verification of Load/Store entities */
@@ -44,10 +45,6 @@ static const char *get_mode_name_ex(ir_mode *mode) {
   return get_mode_name(mode);
 }
 
-void do_node_verification(node_verification_t mode) {
-  opt_do_node_verification = mode;
-}
-
 /** the last IRG, on which a verify error was found */
 static ir_graph *last_irg_error = NULL;
 
@@ -70,7 +67,7 @@ static void show_entity_failure(ir_node *node)
     entity *ent = get_irg_entity(irg);
 
     if (ent) {
-      type *ent_type = get_entity_owner(ent);
+      ir_type *ent_type = get_entity_owner(ent);
 
       if (ent_type) {
         if (ent_type == get_glob_type())
@@ -169,7 +166,7 @@ static void show_proj_failure(ir_node *n)
 /**
  * Prints a failure message for a proj from Start
  */
-static void show_proj_mode_failure(ir_node *n, type *ty)
+static void show_proj_mode_failure(ir_node *n, ir_type *ty)
 {
   long proj  = get_Proj_proj(n);
   ir_mode *m = get_type_mode(ty);
@@ -206,22 +203,13 @@ static void show_proj_failure_ent(ir_node *n, entity *ent)
  */
 static void show_node_on_graph(ir_graph *irg, ir_node *n)
 {
-  entity *ent = get_irg_entity(irg);
-
-  if (ent)
-    fprintf(stderr, "\nFIRM: irn_vrfy_irg() of entity %s, node %ld %s%s\n",
-      get_entity_name(ent),
-      get_irn_node_nr(n), get_irn_opname(n), get_irn_modename(n));
-  else
-    fprintf(stderr, "\nFIRM: irn_vrfy_irg() of graph %p, node %ld %s%s\n",
-      (void *)irg,
-      get_irn_node_nr(n), get_irn_opname(n), get_irn_modename(n));
+  ir_fprintf(stderr, "\nFIRM: irn_vrfy_irg() of %+F, node %+F\n", irg, n);
 }
 
 /**
- * Show call params
+ * Show call parameters
  */
-static void show_call_param(ir_node *n, type *mt)
+static void show_call_param(ir_node *n, ir_type *mt)
 {
   int i;
 
@@ -242,7 +230,7 @@ static void show_call_param(ir_node *n, type *mt)
 /**
  * Show return modes
  */
-static void show_return_modes(ir_graph *irg, ir_node *n, type *mt, int i)
+static void show_return_modes(ir_graph *irg, ir_node *n, ir_type *mt, int i)
 {
   entity *ent = get_irg_entity(irg);
 
@@ -257,7 +245,7 @@ static void show_return_modes(ir_graph *irg, ir_node *n, type *mt, int i)
 /**
  * Show return number of results
  */
-static void show_return_nres(ir_graph *irg, ir_node *n, type *mt)
+static void show_return_nres(ir_graph *irg, ir_node *n, ir_type *mt)
 {
   entity *ent = get_irg_entity(irg);
 
@@ -602,7 +590,7 @@ static int verify_node_Proj_Proj(ir_node *pred, ir_node *p) {
   ir_mode *mode = get_irn_mode(p);
   long proj     = get_Proj_proj(p);
   long nr       = get_Proj_proj(pred);
-  type *mt; /* A method type */
+  ir_type *mt; /* A method type */
 
   pred = skip_Id(get_Proj_pred(pred));
   ASSERT_AND_RET((get_irn_mode(pred) == mode_T), "Proj from something not a tuple", 0);
@@ -667,7 +655,8 @@ static int verify_node_Proj_Proj(ir_node *pred, ir_node *p) {
       break;
 
     default:
-      ASSERT_AND_RET(0, "Unknown opcode", 0);
+      /* ASSERT_AND_RET(0, "Unknown opcode", 0); */
+		break;
   }
   return 1;
 }
@@ -705,6 +694,47 @@ static int verify_node_Proj_EndExcept(ir_node *n, ir_node *p) {
   return 1;
 }
 
+/**
+ * verify a Proj(CopyB) node
+ */
+static int verify_node_Proj_CopyB(ir_node *n, ir_node *p) {
+  ir_mode *mode = get_irn_mode(p);
+  long proj     = get_Proj_proj(p);
+
+  ASSERT_AND_RET_DBG(
+    ((proj == pn_CopyB_M        && mode == mode_M) ||
+     (proj == pn_CopyB_X_except && mode == mode_X)),
+    "wrong Proj from CopyB", 0,
+    show_proj_failure(p);
+  );
+  if (proj == pn_CopyB_X_except)
+    ASSERT_AND_RET(
+      get_irn_pinned(n) == op_pin_state_pinned,
+      "Exception Proj from unpinned CopyB", 0);
+  return 1;
+}
+
+/**
+ * verify a Proj(Bound) node
+ */
+static int verify_node_Proj_Bound(ir_node *n, ir_node *p) {
+  ir_mode *mode = get_irn_mode(p);
+  long proj     = get_Proj_proj(p);
+
+  ASSERT_AND_RET_DBG(
+    ((proj == pn_Bound_M        && mode == mode_M) ||
+     (proj == pn_Bound_X_except && mode == mode_X) ||
+     (proj == pn_Bound_res      && mode == get_irn_mode(get_Bound_index(n)))),
+    "wrong Proj from Bound", 0,
+    show_proj_failure(p);
+  );
+  if (proj == pn_Bound_X_except)
+    ASSERT_AND_RET(
+      get_irn_pinned(n) == op_pin_state_pinned,
+      "Exception Proj from unpinned Bound", 0);
+  return 1;
+}
+
 /**
  * verify a Proj node
  */
@@ -718,8 +748,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;
@@ -746,7 +776,7 @@ static int verify_node_Block(ir_node *n, ir_graph *irg) {
       ir_node *pred =  skip_Proj(get_Block_cfgpred(n, i));
       if (is_Proj(pred) || get_irn_op(pred) == op_Tuple)
         break;   /*  We can not test properly.  How many tuples are there? */
-      ASSERT_AND_RET(((get_irn_op(pred) == op_Return) ||
+      ASSERT_AND_RET((is_Return(pred)                 ||
                       is_Bad(pred)                    ||
                       (get_irn_op(pred) == op_Raise)  ||
                       is_fragile_op(pred)               ),
@@ -828,6 +858,7 @@ static int verify_node_Cond(ir_node *n, ir_graph *irg) {
     mode_is_int(op1mode) ),  "Cond node", 0
   );
   ASSERT_AND_RET(mymode == mode_T, "Cond mode is not a tuple", 0);
+
   return 1;
 }
 
@@ -838,7 +869,7 @@ static int verify_node_Return(ir_node *n, ir_graph *irg) {
   int i;
   ir_mode *mymode   = get_irn_mode(n);
   ir_mode *mem_mode = get_irn_mode(get_Return_mem(n));
-  type *mt;
+  ir_type *mt;
 
   /* Return: BB x M x data1 x ... x datan --> X */
 
@@ -854,7 +885,7 @@ static int verify_node_Return(ir_node *n, ir_graph *irg) {
     "Number of results for Return doesn't match number of results in type.", 0,
   show_return_nres(irg, n, mt););
   for (i = get_Return_n_ress(n) - 1; i >= 0; --i) {
-    type *res_type = get_method_res_type(mt, i);
+    ir_type *res_type = get_method_res_type(mt, i);
 
     if (is_atomic_type(res_type)) {
       ASSERT_AND_RET_DBG(
@@ -902,6 +933,11 @@ static int verify_node_Const(ir_node *n, ir_graph *irg) {
     mymode == mode_b)      /* we want boolean constants for static evaluation */
     ,"Const node", 0       /* of Cmp. */
   );
+  ASSERT_AND_RET(
+    /* the modes of the constant and teh tarval must match */
+    mymode == get_tarval_mode(get_Const_tarval(n)),
+    "Const node, tarval and node mode mismatch", 0
+  );
   return 1;
 }
 
@@ -973,7 +1009,7 @@ static int verify_node_Call(ir_node *n, ir_graph *irg) {
   ir_mode *mymode  = get_irn_mode(n);
   ir_mode *op1mode = get_irn_mode(get_Call_mem(n));
   ir_mode *op2mode = get_irn_mode(get_Call_ptr(n));
-  type *mt;
+  ir_type *mt;
   int i;
 
   /* Call: BB x M x ref x data1 x ... x datan
@@ -1015,7 +1051,7 @@ static int verify_node_Call(ir_node *n, ir_graph *irg) {
   }
 
   for (i = 0; i < get_method_n_params(mt); i++) {
-    type *t = get_method_param_type(mt, i);
+    ir_type *t = get_method_param_type(mt, i);
 
     if (is_atomic_type(t)) {
       ASSERT_AND_RET_DBG(
@@ -1561,6 +1597,65 @@ 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));
+  ir_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;
+}
+
+/**
+ * verify a Bound node
+ */
+static int verify_node_Bound(ir_node *n, ir_graph *irg) {
+  ir_mode *mymode  = get_irn_mode(n);
+  ir_mode *op1mode = get_irn_mode(get_Bound_mem(n));
+  ir_mode *op2mode = get_irn_mode(get_Bound_index(n));
+  ir_mode *op3mode = get_irn_mode(get_Bound_lower(n));
+  ir_mode *op4mode = get_irn_mode(get_Bound_upper(n));
+
+  /* Bound: BB x M x ref x ref --> M x X */
+  ASSERT_AND_RET(
+    mymode == mode_T &&
+    op1mode == mode_M &&
+    op2mode == op3mode &&
+    op3mode == op4mode &&
+    mode_is_int(op3mode),
+    "Bound node", 0 );  /* operand M x int x int x int */
+
+  /* NoMem nodes are only allowed as memory input if the Bound is NOT pinned.
+     This should happen RARELY, as Bound COPIES MEMORY */
+  ASSERT_AND_RET(
+    (get_irn_op(get_Bound_mem(n)) == op_NoMem) ||
+    (get_irn_op(get_Bound_mem(n)) != op_NoMem && get_irn_pinned(n) == op_pin_state_pinned),
+    "Bound node with wrong memory input", 0 );
+  return 1;
+}
+
 /*
  * Check dominance.
  * For each usage of a node, it is checked, if the block of the
@@ -1603,13 +1698,14 @@ 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;
   ir_op *op;
 
-  if (!opt_do_node_verification)
-		return 1;
+  if (!get_node_verification_mode())
+    return 1;
 
   if (!get_interprocedural_view()) {
     /*
@@ -1634,8 +1730,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;
@@ -1665,7 +1761,7 @@ static void vrfy_wrap(ir_node *node, void *env) {
 
 /**
  * Walker to check every node including SSA property.
- * Only called if domonance info is available.
+ * Only called if dominance info is available.
  */
 static void vrfy_wrap_ssa(ir_node *node, void *env)
 {
@@ -1693,7 +1789,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);
@@ -1708,7 +1804,7 @@ int irg_verify(ir_graph *irg, unsigned flags)
 
   current_ir_graph = rem;
 
-  if (opt_do_node_verification == NODE_VERIFICATION_REPORT && ! res) {
+  if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT && ! res) {
     entity *ent = get_irg_entity(current_ir_graph);
 
     if (ent)
@@ -1724,12 +1820,15 @@ int irg_verify(ir_graph *irg, unsigned flags)
 int irn_vrfy_irg_dump(ir_node *n, ir_graph *irg, const char **bad_string)
 {
   int res;
-  node_verification_t old = opt_do_node_verification;
+  firm_verification_t old = get_node_verification_mode();
 
   firm_vrfy_failure_msg = NULL;
-  opt_do_node_verification = NODE_VERIFICATION_ERROR_ONLY;
+  do_node_verification(FIRM_VERIFICATION_ERROR_ONLY);
   res = irn_vrfy_irg(n, irg);
-  opt_do_node_verification = old;
+  if (! res && get_irg_dom_state(irg) == dom_consistent &&
+      get_irg_pinned(irg) == op_pin_state_pinned)
+    res = check_dominance_for_node(n);
+  do_node_verification(old);
   *bad_string = firm_vrfy_failure_msg;
 
   return res;
@@ -1759,10 +1858,10 @@ static void check_bads(ir_node *node, void *env)
         if (is_Bad(pred)) {
           venv->res |= BAD_CF;
 
-          if (opt_do_node_verification == NODE_VERIFICATION_REPORT) {
+          if (get_node_verification_mode() == FIRM_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) {
+          if (get_node_verification_mode() == FIRM_VERIFICATION_ON) {
             assert(0 && "Bad CF detected");
           }
         }
@@ -1776,10 +1875,10 @@ static void check_bads(ir_node *node, void *env)
       if (is_Bad(get_nodes_block(node))) {
         venv->res |= BAD_BLOCK;
 
-        if (opt_do_node_verification == NODE_VERIFICATION_REPORT) {
+        if (get_node_verification_mode() == FIRM_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) {
+        if (get_node_verification_mode() == FIRM_VERIFICATION_ON) {
           assert(0 && "Bad CF detected");
         }
       }
@@ -1789,10 +1888,10 @@ static void check_bads(ir_node *node, void *env)
       if (get_irn_op(node) == op_Tuple) {
         venv->res |= TUPLE;
 
-        if (opt_do_node_verification == NODE_VERIFICATION_REPORT) {
+        if (get_node_verification_mode() == FIRM_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) {
+        if (get_node_verification_mode() == FIRM_VERIFICATION_ON) {
           assert(0 && "Tuple detected");
         }
       }
@@ -1809,10 +1908,10 @@ static void check_bads(ir_node *node, void *env)
           else {
             venv->res |= BAD_CF;
 
-            if (opt_do_node_verification == NODE_VERIFICATION_REPORT) {
+            if (get_node_verification_mode() == FIRM_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) {
+            if (get_node_verification_mode() == FIRM_VERIFICATION_ON) {
               assert(0 && "Bad CF detected");
             }
           }
@@ -1822,10 +1921,10 @@ static void check_bads(ir_node *node, void *env)
         if ((venv->flags & BAD_DF) == 0) {
           venv->res |= BAD_DF;
 
-          if (opt_do_node_verification == NODE_VERIFICATION_REPORT) {
+          if (get_node_verification_mode() == FIRM_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) {
+          if (get_node_verification_mode() == FIRM_VERIFICATION_ON) {
             assert(0 && "Bad NON-CF detected");
           }
         }
@@ -1835,7 +1934,7 @@ static void check_bads(ir_node *node, void *env)
 }
 
 /*
- * verify occurance of bad nodes
+ * verify occurrence of bad nodes
  */
 int irg_vrfy_bads(ir_graph *irg, int flags)
 {
@@ -1852,14 +1951,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);
@@ -1903,17 +2002,19 @@ void firm_set_default_verifyer(ir_op *op)
    CASE(Sync);
    CASE(Confirm);
    CASE(Mux);
+   CASE(CopyB);
+   CASE(Bound);
    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);
@@ -1932,8 +2033,10 @@ void firm_set_default_verifyer(ir_op *op)
    CASE(CallBegin);
    CASE(EndReg);
    CASE(EndExcept);
+   CASE(CopyB);
+   CASE(Bound);
    default:
-     op->verify_proj_node = NULL;
+     /* leave NULL */;
    }
 #undef CASE
 }