X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firvrfy.c;h=dd356533f9c098ec90dedd715aed097c4fa7c9ab;hb=eda9d668d0e8c8246015b4c5e743316a6a835a23;hp=bfd39ae6f08238f163c6297f484a0e06606bd98d;hpb=40353ece0b0e2c8d7109233cde55cd942c72db2e;p=libfirm

diff --git a/ir/ir/irvrfy.c b/ir/ir/irvrfy.c
index bfd39ae6f..dd356533f 100644
--- a/ir/ir/irvrfy.c
+++ b/ir/ir/irvrfy.c
@@ -1,34 +1,47 @@
 /*
- * Project:     libFIRM
- * File name:   ir/ir/irvrfy.c
- * Purpose:     Check irnodes for correctness.
- * Author:      Christian Schaefer
- * Modified by: Goetz Lindenmaier. Till Riedel
- * Created:
- * CVS-ID:      $Id$
- * Copyright:   (c) 1998-2003 Universität Karlsruhe
- * Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
+ * Copyright (C) 1995-2007 University of Karlsruhe.  All right reserved.
+ *
+ * This file is part of libFirm.
+ *
+ * This file may be distributed and/or modified under the terms of the
+ * GNU General Public License version 2 as published by the Free Software
+ * Foundation and appearing in the file LICENSE.GPL included in the
+ * packaging of this file.
+ *
+ * Licensees holding valid libFirm Professional Edition licenses may use
+ * this file in accordance with the libFirm Commercial License.
+ * Agreement provided with the Software.
+ *
+ * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+ * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE.
+ */
+
+/**
+ * @file
+ * @brief    Check irnodes for correctness.
+ * @author   Christian Schaefer, Goetz Lindenmaier, Till Riedel, Michael Beck
+ * @version  $Id$
  */
-
 #ifdef HAVE_CONFIG_H
 # 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 "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;
 
-/* @@@ replace use of array "in" by access functions. */
-ir_node **get_irn_in(ir_node *node);
-
-node_verification_t opt_do_node_verification = NODE_VERIFICATION_ON;
 const char *firm_vrfy_failure_msg;
 
 /* enable verification of Load/Store entities */
@@ -45,10 +58,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;
 
@@ -68,10 +77,10 @@ static void show_entity_failure(ir_node *node)
     fprintf(stderr, "\nFIRM: irn_vrfy_irg() <of CONST_CODE_IRG> failed\n");
   }
   else {
-    entity *ent = get_irg_entity(irg);
+    ir_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())
@@ -170,7 +179,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);
@@ -187,7 +196,7 @@ static void show_proj_mode_failure(ir_node *n, type *ty)
 /**
  * Prints a failure message for a proj
  */
-static void show_proj_failure_ent(ir_node *n, entity *ent)
+static void show_proj_failure_ent(ir_node *n, ir_entity *ent)
 {
   ir_node *op  = get_Proj_pred(n);
   int proj     = get_Proj_proj(n);
@@ -207,22 +216,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;
 
@@ -243,9 +243,9 @@ 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);
+  ir_entity *ent = get_irg_entity(irg);
 
   show_entity_failure(n);
   fprintf(stderr, "  Return node %ld in entity \"%s\" mode %s different from type mode %s\n",
@@ -258,9 +258,9 @@ 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);
+  ir_entity *ent = get_irg_entity(irg);
 
   show_entity_failure(n);
   fprintf(stderr, "  Return node %ld in entity \"%s\" has %d results different from type %d\n",
@@ -291,7 +291,7 @@ static void show_phi_inputs(ir_node *phi, ir_node *block)
 }
 
 /** If the address is Sel or SymConst, return the entity. */
-static entity *get_ptr_entity(ir_node *ptr) {
+static ir_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)) {
@@ -313,6 +313,7 @@ static int verify_node_Proj_Start(ir_node *n, ir_node *p) {
      (proj == pn_Start_M         && mode == mode_M) ||
      (proj == pn_Start_P_frame_base && mode_is_reference(mode)) ||
      (proj == pn_Start_P_globals && mode_is_reference(mode)) ||
+     (proj == pn_Start_P_tls     && mode_is_reference(mode)) ||
      (proj == pn_Start_T_args    && mode == mode_T) ||
      (proj == pn_Start_P_value_arg_base && mode_is_reference(mode)) ||
      (proj == pn_Start_P_value_arg_base && mode == mode_T)    /* FIXME: only one of those */
@@ -524,7 +525,7 @@ static int verify_node_Proj_Load(ir_node *n, ir_node *p) {
 
   if (proj == pn_Load_res) {
     ir_node *ptr = get_Load_ptr(n);
-    entity *ent = get_ptr_entity(ptr);
+    ir_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 */
@@ -603,7 +604,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);
@@ -668,7 +669,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;
 }
@@ -706,6 +708,51 @@ 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_regular && mode == mode_M) ||
+     (proj == pn_CopyB_X_except  && mode == mode_X) ||
+     (proj == pn_CopyB_M_except  && mode == mode_M)),
+    "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);
+
+  /* ignore Bound checks of Bad */
+  if (is_Bad(get_Bound_index(n)))
+    return 1;
+  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
  */
@@ -719,8 +766,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;
@@ -742,12 +789,12 @@ static int verify_node_Block(ir_node *n, ir_graph *irg) {
   }
 
   /*  End block may only have Return, Raise or fragile ops as preds. */
-  if (n == get_irg_end_block(irg))
+  if (n == get_irg_end_block(irg) && get_irg_phase_state(irg) != phase_backend)
     for (i = get_Block_n_cfgpreds(n) - 1; i >= 0; --i) {
       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)               ),
@@ -786,6 +833,20 @@ static int verify_node_Jmp(ir_node *n, ir_graph *irg) {
   return 1;
 }
 
+/**
+ * verify an IJmp node
+ */
+static int verify_node_IJmp(ir_node *n, ir_graph *irg) {
+  ir_mode *mymode  = get_irn_mode(n);
+  ir_mode *op1mode = get_irn_mode(get_IJmp_target(n));
+
+  ASSERT_AND_RET(
+    /* IJmp: BB x ref --> X */
+    mymode == mode_X && mode_is_reference(op1mode), "IJmp node", 0
+  );
+  return 1;
+}
+
 /**
  * verify a Break node
  */
@@ -815,6 +876,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;
 }
 
@@ -825,7 +887,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 */
 
@@ -841,7 +903,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(
@@ -889,6 +951,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;
 }
 
@@ -899,7 +966,7 @@ static int verify_node_SymConst(ir_node *n, ir_graph *irg) {
   ir_mode *mymode = get_irn_mode(n);
 
   if (get_SymConst_kind(n) == symconst_addr_ent) {
-    entity *ent = get_SymConst_entity(n);
+    ir_entity *ent = get_SymConst_entity(n);
     if (is_Method_type(get_entity_type(ent)) &&
         get_irn_irg(n) != get_const_code_irg()) {
 #if 1
@@ -925,7 +992,7 @@ static int verify_node_Sel(ir_node *n, ir_graph *irg) {
   ir_mode *mymode  = get_irn_mode(n);
   ir_mode *op1mode = get_irn_mode(get_Sel_mem(n));
   ir_mode *op2mode = get_irn_mode(get_Sel_ptr(n));
-  entity *ent;
+  ir_entity *ent;
 
   ASSERT_AND_RET_DBG(
     /* Sel: BB x M x ref x int^n --> ref */
@@ -960,7 +1027,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
@@ -1002,7 +1069,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(
@@ -1224,7 +1291,7 @@ static int verify_node_Logic(ir_node *n, ir_graph *irg) {
 
   ASSERT_AND_RET_DBG(
     /* And or Or or Eor: BB x int x int --> int */
-    mode_is_int(mymode) &&
+    (mode_is_int(mymode) || mymode == mode_b) &&
     op2mode == op1mode &&
     mymode == op2mode,
     "And, Or or Eor node", 0,
@@ -1376,6 +1443,32 @@ static int verify_node_Phi(ir_node *n, ir_graph *irg) {
       );
   }
   ASSERT_AND_RET( mode_is_dataM(mymode), "Phi node", 0 );
+
+  if (mymode == mode_M) {
+    for (i = get_Phi_n_preds(n) - 1; i >= 0; --i) {
+      int j;
+      ir_node *pred_i = get_Phi_pred(n, i);
+
+      if (is_Bad(pred_i))
+        continue;
+      for (j = i - 1; j >= 0; --j) {
+        ir_node *pred_j = get_Phi_pred(n, j);
+
+        if (is_Bad(pred_j))
+          continue;
+#if 0
+        /* currently this checks fails for blocks with exception
+           outputs (and these are NOT basic blocks).  So it is disabled yet. */
+        ASSERT_AND_RET_DBG(
+          (pred_i == pred_j) || (get_irn_n(pred_i, -1) != get_irn_n(pred_j, -1)),
+          "At least two different PhiM predecessors are in the same block",
+          0,
+          ir_printf("%+F and %+F of %+F are in %+F\n", pred_i, pred_j, n, get_irn_n(pred_i, -1))
+        );
+#endif
+      }
+    }
+  }
   return 1;
 }
 
@@ -1397,11 +1490,13 @@ static int verify_node_Load(ir_node *n, ir_graph *irg) {
   ir_mode *op1mode = get_irn_mode(get_Load_mem(n));
   ir_mode *op2mode = get_irn_mode(get_Load_ptr(n));
 
-  ASSERT_AND_RET(
-    /* Load: BB x M x ref --> M x X x data */
-    op1mode == mode_M && mode_is_reference(op2mode),
-    "Load node", 0
-  );
+  ASSERT_AND_RET(op1mode == mode_M, "Load node", 0);
+  if(get_irg_phase_state(irg) != phase_backend) {
+    ASSERT_AND_RET(mode_is_reference(op2mode), "Load node", 0 );
+  } else {
+	ASSERT_AND_RET(mode_is_reference(op2mode) ||
+	               (mode_is_int(op2mode) && get_mode_size_bits(op2mode) == get_mode_size_bits(mode_P)), "Load node", 0 );
+  }
   ASSERT_AND_RET( mymode == mode_T, "Load node", 0 );
 
   /*
@@ -1414,7 +1509,7 @@ static int verify_node_Load(ir_node *n, ir_graph *irg) {
    * mode_T
    *
   {
-    entity *ent = hunt_for_entity (get_Load_ptr (n), n);
+    ir_entity *ent = hunt_for_entity (get_Load_ptr (n), n);
     assert ((NULL != ent) || (mymode != mode_T));
   }
   */
@@ -1426,18 +1521,20 @@ static int verify_node_Load(ir_node *n, ir_graph *irg) {
  * verify a Store node
  */
 static int verify_node_Store(ir_node *n, ir_graph *irg) {
-  entity *target;
+  ir_entity *target;
 
   ir_mode *mymode  = get_irn_mode(n);
   ir_mode *op1mode = get_irn_mode(get_Store_mem(n));
   ir_mode *op2mode = get_irn_mode(get_Store_ptr(n));
   ir_mode *op3mode = get_irn_mode(get_Store_value(n));
 
-  ASSERT_AND_RET(
-    /* Store: BB x M x ref x data --> M x X */
-    op1mode == mode_M && mode_is_reference(op2mode) && mode_is_data(op3mode),
-    "Store node", 0
-  );
+  ASSERT_AND_RET(op1mode == mode_M && mode_is_data(op3mode), "Store node", 0 );
+  if(get_irg_phase_state(irg) != phase_backend) {
+    ASSERT_AND_RET(mode_is_reference(op2mode), "Store node", 0 );
+  } else {
+	ASSERT_AND_RET(mode_is_reference(op2mode) ||
+	               (mode_is_int(op2mode) && get_mode_size_bits(op2mode) == get_mode_size_bits(mode_P)), "Store node", 0 );
+  }
   ASSERT_AND_RET(mymode == mode_T, "Store node", 0);
 
   target = get_ptr_entity(get_Store_ptr(n));
@@ -1548,14 +1645,123 @@ 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, "CopyB node", 0);
+  if(get_irg_phase_state(irg) != phase_backend) {
+	  ASSERT_AND_RET(mode_is_reference(op2mode) && mode_is_reference(op3mode),
+                     "CopyB node", 0 );
+  } else {
+      ASSERT_AND_RET(mode_is_reference(op2mode) ||
+			  (mode_is_int(op2mode) && get_mode_size_bits(op2mode) == get_mode_size_bits(mode_P)), "Load node", 0 );
+      ASSERT_AND_RET(mode_is_reference(op3mode) ||
+			  (mode_is_int(op3mode) && get_mode_size_bits(op3mode) == get_mode_size_bits(mode_P)), "Load node", 0 );
+  }
+
+  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
+ * node dominates the block of the usage (for phis: the predecessor
+ * block of the phi for the corresponding edge).
+ *
+ * @return non-zero on success, 0 on dominance error
+ */
+static int check_dominance_for_node(ir_node *use)
+{
+  /* This won't work for blocks and the end node */
+  if (!is_Block(use) && use != get_irg_end(current_ir_graph)) {
+    int i;
+    ir_node *bl = get_nodes_block(use);
+
+    for (i = get_irn_arity(use) - 1; i >= 0; --i) {
+      ir_node *def    = get_irn_n(use, i);
+      ir_node *def_bl = get_nodes_block(def);
+      ir_node *use_bl = bl;
+
+      /* ignore dead definition blocks, will be removed */
+      if (is_Block_dead(def_bl) || get_Block_dom_depth(def_bl) == -1)
+        continue;
+
+      if (is_Phi(use))
+        use_bl = get_Block_cfgpred_block(bl, i);
+
+      /* ignore dead use blocks, will be removed */
+      if (is_Block_dead(use_bl) || get_Block_dom_depth(use_bl) == -1)
+        continue;
+
+      ASSERT_AND_RET_DBG(
+        block_dominates(def_bl, use_bl),
+        "the definition of a value used violates the dominance property", 0,
+        ir_fprintf(stderr,
+                   "graph %+F: %+F of %+F must dominate %+F of user %+F input %d\n",
+                   current_ir_graph, def_bl, def, use_bl, use, i
+        );
+      );
+    }
+  }
+  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()) {
+  if (!get_interprocedural_view()) {
     /*
      * do NOT check placement in interprocedural view, as we don't always know
      * the "right" graph ...
@@ -1566,6 +1772,11 @@ int irn_vrfy_irg(ir_node *n, ir_graph *irg)
       show_node_on_graph(irg, n);
     );
     assert(get_irn_irg(n) == irg);
+	{
+		unsigned idx           = get_irn_idx(n);
+		ir_node *node_from_map = get_idx_irn(irg, idx);
+		ASSERT_AND_RET_DBG(node_from_map == n, "Node index and index map entry differ", 0, ir_printf("node %+F node in map %+F(%p)", n, node_from_map, node_from_map));
+	}
   }
 
   op = get_irn_op(n);
@@ -1578,8 +1789,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;
@@ -1598,15 +1809,36 @@ int irn_vrfy(ir_node *n)
 /* Verify the whole graph.                                         */
 /*-----------------------------------------------------------------*/
 
-/* This *is* used, except gcc doesn't notice that */
-static void vrfy_wrap(ir_node *node, void *env)
+#ifdef DEBUG_libfirm
+/**
+ * Walker to check every node
+ */
+static void vrfy_wrap(ir_node *node, void *env) {
+  int *res = env;
+  *res = irn_vrfy(node);
+}
+
+/**
+ * Walker to check every node including SSA property.
+ * Only called if dominance info is available.
+ */
+static void vrfy_wrap_ssa(ir_node *node, void *env)
 {
   int *res = env;
 
   *res = irn_vrfy(node);
+  if (*res)
+    *res = check_dominance_for_node(node);
 }
 
-int irg_vrfy(ir_graph *irg)
+#endif /* DEBUG_libfirm */
+
+/*
+ * Calls irn_vrfy for each node in irg.
+ * Graph must be in state "op_pin_state_pinned".
+ * If dominance info is available, check the SSA property.
+ */
+int irg_verify(ir_graph *irg, unsigned flags)
 {
   int res = 1;
 #ifdef DEBUG_libfirm
@@ -1616,34 +1848,46 @@ int irg_vrfy(ir_graph *irg)
   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");
 
-  irg_walk_graph(irg, vrfy_wrap, NULL, &res);
+  if (flags & VRFY_ENFORCE_SSA)
+    compute_doms(irg);
+
+  irg_walk_graph(
+    irg,
+    get_irg_dom_state(irg) == dom_consistent &&
+    get_irg_pinned(irg) == op_pin_state_pinned ?
+      vrfy_wrap_ssa : vrfy_wrap,
+    NULL, &res
+  );
 
   current_ir_graph = rem;
 
-  if (opt_do_node_verification == NODE_VERIFICATION_REPORT && ! res) {
-    entity *ent = get_irg_entity(current_ir_graph);
+  if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT && ! res) {
+    ir_entity *ent = get_irg_entity(current_ir_graph);
 
     if (ent)
       fprintf(stderr, "irg_verify: Verifying graph %s failed\n", get_entity_name(ent));
     else
       fprintf(stderr, "irg_verify: Verifying graph %p failed\n", (void *)current_ir_graph);
   }
+#endif /* DEBUG_libfirm */
 
-#endif
   return res;
 }
 
 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;
@@ -1655,6 +1899,9 @@ typedef struct _vrfy_bad_env_t {
   int res;
 } vrfy_bad_env_t;
 
+/**
+ * Pre-Walker: check Bad predecessors of node.
+ */
 static void check_bads(ir_node *node, void *env)
 {
   vrfy_bad_env_t *venv = env;
@@ -1670,10 +1917,11 @@ 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) {
+            dump_ir_block_graph(current_ir_graph, "-assert");
             assert(0 && "Bad CF detected");
           }
         }
@@ -1687,10 +1935,11 @@ 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) {
+          dump_ir_block_graph(current_ir_graph, "-assert");
           assert(0 && "Bad CF detected");
         }
       }
@@ -1700,10 +1949,11 @@ 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) {
+          dump_ir_block_graph(current_ir_graph, "-assert");
           assert(0 && "Tuple detected");
         }
       }
@@ -1720,10 +1970,11 @@ 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) {
+              dump_ir_block_graph(current_ir_graph, "-assert");
               assert(0 && "Bad CF detected");
             }
           }
@@ -1733,10 +1984,11 @@ 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) {
+            dump_ir_block_graph(current_ir_graph, "-assert");
             assert(0 && "Bad NON-CF detected");
           }
         }
@@ -1746,7 +1998,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)
 {
@@ -1763,18 +2015,19 @@ 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(ir_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);
    CASE(Jmp);
+   CASE(IJmp);
    CASE(Break);
    CASE(Cond);
    CASE(Return);
@@ -1813,17 +2066,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);
@@ -1842,8 +2097,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
 }