Clean up turn_back_am(), panic on unknown arity.
[libfirm] / include / libfirm / iropt_dbg.h
index 3d44948..a504c1d 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1995-2007 University of Karlsruhe.  All right reserved.
+ * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
  *
  * This file is part of libFirm.
  *
@@ -19,8 +19,8 @@
 
 /**
  * @file
- * @brief   Debug makros used in iropt.
- * @author  Goetz Lindenmaier
+ * @brief   Debug macros used in iropt.
+ * @author  Goetz Lindenmaier, Michael Beck
  * @version $Id$
  */
 #ifndef FIRM_IR_IROPT_DBG_H
  * @param oldn  the block that it is eliminated
  * @param n     the new node for this block, may be equal to oldn
  */
-#define DBG_OPT_DEAD_BLOCK(oldn, n)                         \
-  do {                                                      \
-    hook_merge_nodes(&n, 1, &oldn, 1, HOOK_OPT_DEAD_BLOCK); \
-    __dbg_info_merge_pair(n, oldn, dbg_dead_code);          \
+#define DBG_OPT_DEAD_BLOCK(oldn, n)                           \
+       do {                                                      \
+         hook_merge_nodes(&n, 1, &oldn, 1, HOOK_OPT_DEAD_BLOCK); \
+         __dbg_info_merge_pair(n, oldn, dbg_dead_code);          \
        } while(0)
 
 
  * @param oldn  the old block
  * @param n     the new block the merges with oldn
  */
-#define DBG_OPT_STG(oldn, n)                                 \
-  do {                                                       \
+#define DBG_OPT_STG(oldn, n)                                   \
+       do {                                                       \
          ir_node *ons[2];                                         \
          ons[0] = oldn;                                           \
          ons[1] = get_Block_cfgpred(oldn, 0);                     \
-         hook_merge_nodes(&n, 1, ons, SIZ(ons), HOOK_OPT_STG);    \
+         hook_merge_nodes(&n, 1, ons, SIZ(ons), HOOK_OPT_STG);    \
          __dbg_info_merge_sets(&n, 1, ons, SIZ(ons), dbg_straightening); \
        } while(0)
 
@@ -73,8 +73,8 @@
  * @param proj2  the second ProjX predecessor
  * @param n      the new Block
  */
-#define DBG_OPT_IFSIM1(oldn, proj1, proj2, n)                   \
-  do {                                                          \
+#define DBG_OPT_IFSIM1(oldn, proj1, proj2, n)                     \
+       do {                                                          \
          ir_node *ons[4];                                            \
          ons[0] = oldn;                                              \
          ons[1] = proj1;                                             \
@@ -89,8 +89,8 @@
  * @param oldn   the old Cond
  * @param n      the new Jmp
  */
-#define DBG_OPT_IFSIM2(oldn, n)                            \
-  do {                                                     \
+#define DBG_OPT_IFSIM2(oldn, n)                              \
+       do {                                                     \
          hook_merge_nodes(&n, 1, &oldn, 1, HOOK_OPT_IFSIM);     \
          __dbg_info_merge_pair(n, oldn, dbg_if_simplification); \
        } while(0)
  * @param n     the new constant holding the value
  */
 #define DBG_OPT_CSTEVAL(oldn, n)                                  \
-  do {                                                                 \
-         hook_merge_nodes(&n, 1, &oldn, 1, HOOK_OPT_CONST_EVAL);         \
-    __dbg_info_merge_pair(n, oldn, dbg_const_eval);                 \
-  } while(0)
+       do {                                                          \
+         hook_merge_nodes(&n, 1, &oldn, 1, HOOK_OPT_CONST_EVAL);     \
+         __dbg_info_merge_pair(n, oldn, dbg_const_eval);             \
+       } while(0)
 
 /**
  * Merge the debug info due to an algebraic_simplification.
  * @param n     the new node replacing oldn
  * @param flag  firm statistics option
  */
-#define DBG_OPT_ALGSIM0(oldn, n, flag)                            \
-  do {                                                            \
-    hook_merge_nodes(&n, 1, &oldn, 1, flag);                           \
-    __dbg_info_merge_pair(n, oldn, dbg_algebraic_simplification); \
-  } while(0)
+#define DBG_OPT_ALGSIM0(oldn, n, flag)                              \
+       do {                                                            \
+         hook_merge_nodes(&n, 1, &oldn, 1, flag);                      \
+         __dbg_info_merge_pair(n, oldn, dbg_algebraic_simplification); \
+       } while(0)
 
 /**
  * Merge the debug info due to an algebraic_simplification.
  * @param n     the new node replacing oldn
  * @param flag  firm statistics option
  */
-#define DBG_OPT_ALGSIM1(oldn, a, b, n, flag)                    \
-  do {                                                          \
+#define DBG_OPT_ALGSIM1(oldn, a, b, n, flag)                      \
+       do {                                                          \
          ir_node *ons[3];                                            \
          ons[0] = oldn;                                              \
          ons[1] = a;                                                 \
          ons[2] = b;                                                 \
          hook_merge_nodes(&n, 1, ons, SIZ(ons), flag);               \
          __dbg_info_merge_sets(&n, 1, ons, SIZ(ons), dbg_algebraic_simplification); \
-  } while(0)
+       } while(0)
 
 /**
  * Merge the debug info due to an algebraic_simplification.
+ *
+ * @param oldn  the old node
+ * @param pred  the predecessor of oldn
+ * @param n     the new node replacing oldn
+ * @param flag  firm statistics option
  */
-#define DBG_OPT_ALGSIM2(oldn, pred, n)                          \
-  do {                                                          \
+#define DBG_OPT_ALGSIM2(oldn, pred, n, flag)                      \
+       do {                                                          \
          ir_node *ons[3];                                            \
          ons[0] = oldn;                                              \
          ons[1] = pred;                                              \
          ons[2] = n;                                                 \
-         hook_merge_nodes(&n, 1, ons, SIZ(ons), HOOK_OPT_ALGSIM);    \
+         hook_merge_nodes(&n, 1, ons, SIZ(ons), flag);               \
          __dbg_info_merge_sets(&n, 1, ons, SIZ(ons), dbg_algebraic_simplification); \
-  } while(0)
+       } while(0)
 
 /**
  * Merge the debug info due to an algebraic_simplification.
  */
-#define DBG_OPT_ALGSIM3(oldn, a, n)                             \
-  do {                                                          \
+#define DBG_OPT_ALGSIM3(oldn, a, n, flag)                         \
+       do {                                                          \
          ir_node *ons[2];                                            \
          ons[0] = oldn;                                              \
          ons[1] = a;                                                 \
-         hook_merge_nodes(&n, 1, ons, SIZ(ons), HOOK_OPT_ALGSIM);    \
+         hook_merge_nodes(&n, 1, ons, SIZ(ons), flag);               \
          __dbg_info_merge_sets(&n, 1, ons, SIZ(ons), dbg_algebraic_simplification); \
-  } while(0)
+       } while(0)
 
 /**
  * Merge the debug info due to a Phi optimization.
  * @param phi  the Phi node that will be replaced
  * @param n    in Phi Input that will replace Phi
  */
-#define DBG_OPT_PHI(phi, n)                                     \
-  do {                                                          \
-         hook_merge_nodes(&n, 1, &phi, 1, HOOK_OPT_PHI);                   \
-         __dbg_info_merge_sets(&n, 1, &phi, 1, dbg_opt_ssa);         \
-  } while(0)
+#define DBG_OPT_PHI(phi, n)                                      \
+       do {                                                         \
+         hook_merge_nodes(&n, 1, &phi, 1, HOOK_OPT_PHI);            \
+         __dbg_info_merge_sets(&n, 1, &phi, 1, dbg_opt_ssa);        \
+       } while(0)
 
 
 /**
  * @param sync  the Sync node that will be replaced
  * @param n     in Sync Input that will replace Sync
  */
-#define DBG_OPT_SYNC(sync, n)                                   \
-  do {                                                          \
-         hook_merge_nodes(&n, 1, &sync, 1, HOOK_OPT_SYNC);               \
+#define DBG_OPT_SYNC(sync, n)                                     \
+       do {                                                          \
+         hook_merge_nodes(&n, 1, &sync, 1, HOOK_OPT_SYNC);           \
          __dbg_info_merge_sets(&n, 1, &sync, 1, dbg_opt_ssa);        \
-  } while(0)
+       } while(0)
 
 
 /**
  * @param oldst  the old store that will be removed
  * @param st     the other store that overwrites oldst
  */
-#define DBG_OPT_WAW(oldst, st)                                  \
-  do {                                                          \
+#define DBG_OPT_WAW(oldst, st)                                    \
+       do {                                                          \
          ir_node *ons[2];                                            \
          ons[0] = oldst;                                             \
          ons[1] = st;                                                \
          hook_merge_nodes(&st, 1, ons, SIZ(ons), HOOK_OPT_WAW);      \
          __dbg_info_merge_sets(&st, 1, ons, SIZ(ons), dbg_write_after_write); \
-  } while(0)
+       } while(0)
 
 /**
  * Merge the debug info due to Write-after-Read optimization:
  * @param store  the store that will be removed
  * @param load   the load that produces the value that store will write back
  */
-#define DBG_OPT_WAR(store, load)                                \
-  do {                                                          \
+#define DBG_OPT_WAR(store, load)                                  \
+       do {                                                          \
          ir_node *ons[2];                                            \
          ons[0] = store;                                             \
          ons[1] = load;                                              \
          hook_merge_nodes(&load, 1, ons, SIZ(ons), HOOK_OPT_WAR);    \
          __dbg_info_merge_sets(&load, 1, ons, SIZ(ons), dbg_write_after_read); \
-  } while(0)
+       } while(0)
 
 /**
  * Merge the debug info due to Read-after-Write optimization:
  * @param load   the load that will be replaced
  * @param value  the value that will replace the load
  */
-#define DBG_OPT_RAW(load, value)                                \
-  do {                                                          \
+#define DBG_OPT_RAW(load, value)                                  \
+       do {                                                          \
          ir_node *ons[2];                                            \
          ons[0] = load;                                              \
          ons[1] = value;                                             \
          hook_merge_nodes(&value, 1, ons, SIZ(ons), HOOK_OPT_RAW);   \
          __dbg_info_merge_sets(&value, 1, ons, SIZ(ons), dbg_read_after_write); \
-  } while(0)
+       } while(0)
 
 /**
  * Merge the debug info due to Read-after-Read optimization:
  * @param oldld  the old load that can be replaced
  * @param ld     the load that produces the same values
  */
-#define DBG_OPT_RAR(oldld, ld)                                  \
-  do {                                                          \
+#define DBG_OPT_RAR(oldld, ld)                                    \
+       do {                                                          \
          ir_node *ons[2];                                            \
          ons[0] = oldld;                                             \
          ons[1] = ld;                                                \
          hook_merge_nodes(&ld, 1, ons, SIZ(ons), HOOK_OPT_RAR);      \
          __dbg_info_merge_sets(&ld, 1, ons, SIZ(ons), dbg_read_after_read); \
-  } while(0)
+       } while(0)
 
 /**
  * Merge the debug info due to Read-a-Const optimization:
  * @param ld  the load
  * @param c   the constant value that will replace the load's result
  */
-#define DBG_OPT_RC(ld, c)                                       \
-  do {                                                          \
+#define DBG_OPT_RC(ld, c)                                         \
+       do {                                                          \
          ir_node *ons[2];                                            \
          ons[0] = ld;                                                \
          ons[1] = c;                                                 \
  * @param tuple  the Tuple node
  * @param n      the Proj(Tuple) value
  */
-#define DBG_OPT_TUPLE(proj, tuple, n)                           \
-  do {                                                          \
+#define DBG_OPT_TUPLE(proj, tuple, n)                             \
+       do {                                                          \
          ir_node *ons[3];                                            \
          ons[0] = proj;                                              \
          ons[1] = tuple;                                             \
          ons[2] = n;                                                 \
          hook_merge_nodes(&n, 1, ons, SIZ(ons), HOOK_OPT_TUPLE);     \
          __dbg_info_merge_sets(&n, 1, ons, SIZ(ons), dbg_opt_auxnode);      \
-  } while(0)
+       } while(0)
 
 /**
  * Merge the debug info after an Id optimization.
  * @param id  the Id node
  * @param n   the predecessor
  */
-#define DBG_OPT_ID(id, n)                                       \
-  do {                                                          \
+#define DBG_OPT_ID(id, n)                                         \
+       do {                                                          \
          ir_node *ons[2];                                            \
          ons[0] = id;                                                \
          ons[1] = n;                                                 \
-         hook_merge_nodes(&n, 1, ons, SIZ(ons), HOOK_OPT_ID);        \
+         hook_merge_nodes(&n, 1, ons, SIZ(ons), HOOK_OPT_ID);        \
          __dbg_info_merge_sets(&n, 1, ons, SIZ(ons), dbg_opt_auxnode);      \
-  } while(0)
+       } while(0)
 
 /**
  * Merge the debug info due to common-subexpression elimination.
  * @param oldn  the old node
  * @param n     the node that replaces oldn
  */
-#define DBG_OPT_CSE(oldn, n)                                    \
-  do {                                                          \
+#define DBG_OPT_CSE(oldn, n)                                      \
+       do {                                                          \
          ir_node *ons[2];                                            \
          ons[0] = oldn;                                              \
          ons[1] = n;                                                 \
-         hook_merge_nodes(&n, 1, ons, SIZ(ons), HOOK_OPT_CSE);       \
+         hook_merge_nodes(&n, 1, ons, SIZ(ons), HOOK_OPT_CSE);       \
          __dbg_info_merge_sets(&n, 1, ons, SIZ(ons), dbg_opt_cse);   \
-  } while(0)
+       } while(0)
 
 /**
  * Merge the debug info due to polymorphic call optimization.
  * @param sel   the Sel node that will be replaced.
  * @param c     the constant node that replaces sel
  */
-#define DBG_OPT_POLY(sel, c)                                        \
-  do {                                                              \
-    ir_node *ons[3];                                                \
-    ons[0] = sel;                                                   \
-    ons[1] = skip_Proj(get_Sel_ptr(sel));                           \
-    ons[2] = c;                                                     \
-    hook_merge_nodes(&c, 1, ons, SIZ(ons), HOOK_OPT_POLY_CALL);            \
-    __dbg_info_merge_sets(&c, 1, ons, SIZ(ons), dbg_rem_poly_call); \
-  } while(0)
+#define DBG_OPT_POLY(sel, c)                                          \
+       do {                                                              \
+         ir_node *ons[3];                                                \
+         ons[0] = sel;                                                   \
+         ons[1] = skip_Proj(get_Sel_ptr(sel));                           \
+         ons[2] = c;                                                     \
+         hook_merge_nodes(&c, 1, ons, SIZ(ons), HOOK_OPT_POLY_CALL);     \
+         __dbg_info_merge_sets(&c, 1, ons, SIZ(ons), dbg_rem_poly_call); \
+       } while(0)
 
 /**
  * A node was replaced by another node due to a Confirmation.
  * @param oldn  the old node
  * @param n     the new node
  */
-#define DBG_OPT_CONFIRM(oldn, n)                                \
-  do {                                                          \
-    hook_merge_nodes(&n, 1, &oldn, 1, HOOK_OPT_CONFIRM);        \
-    __dbg_info_merge_pair(n, oldn, dbg_opt_confirm);            \
-  } while(0)
+#define DBG_OPT_CONFIRM(oldn, n)                                  \
+       do {                                                          \
+         hook_merge_nodes(&n, 1, &oldn, 1, HOOK_OPT_CONFIRM);        \
+         __dbg_info_merge_pair(n, oldn, dbg_opt_confirm);            \
+       } while(0)
 
 /**
  * A node was replaced by a constant due to a Confimation.
  * @param oldn  the old node
  * @param c     the new constant node
  */
-#define DBG_OPT_CONFIRM_C(oldn, c)                              \
-  do {                                                          \
-    hook_merge_nodes(&c, 1, &oldn, 1, HOOK_OPT_CONFIRM_C);      \
-    __dbg_info_merge_pair(c, oldn, dbg_opt_confirm);            \
-  } while(0)
+#define DBG_OPT_CONFIRM_C(oldn, c)                                \
+       do {                                                          \
+         hook_merge_nodes(&c, 1, &oldn, 1, HOOK_OPT_CONFIRM_C);      \
+         __dbg_info_merge_pair(c, oldn, dbg_opt_confirm);            \
+       } while(0)
 
 /**
  * A exception exdge was removed due to a Confirmation prove.
  *
  * @param oldn  the old node
  */
-#define DBG_OPT_EXC_REM(oldn)                                   \
-  do {                                                          \
-    hook_merge_nodes(NULL, 0, &oldn, 1, HOOK_OPT_EXC_REM);      \
-  } while(0)
+#define DBG_OPT_EXC_REM(oldn)                                     \
+       do {                                                          \
+         hook_merge_nodes(NULL, 0, &oldn, 1, HOOK_OPT_EXC_REM);      \
+       } while(0)
 
 /**
  * A node could be evaluated to a value due to a Confirm.
  *
  * @param n  the node that could be evaluated
  */
-#define DBG_EVAL_CONFIRM(n)                                  \
-  do {                                                       \
-    hook_merge_nodes(NULL, 0, &n, 1, HOOK_OPT_CONFIRM_E);    \
-  } while(0)
+#define DBG_EVAL_CONFIRM(n)                                    \
+       do {                                                       \
+         hook_merge_nodes(NULL, 0, &n, 1, HOOK_OPT_CONFIRM_E);    \
+       } while(0)
+
+/**
+ * Merge the debug info due to a GVN-PRE result.
+ *
+ * @param oldn  the old node
+ * @param n     the new node replacing oldn
+ * @param flag  firm statistics option
+ */
+#define DBG_OPT_GVN_PRE(oldn, n, flag)             \
+       do {                                           \
+         hook_merge_nodes(&n, 1, &oldn, 1, flag);     \
+         __dbg_info_merge_pair(n, oldn, dbg_gvn_pre); \
+       } while(0)
+
+/**
+ * Merge the debug info due to a combo result.
+ *
+ * @param oldn  the old node
+ * @param n     the new node replacing oldn
+ * @param flag  firm statistics option
+ */
+#define DBG_OPT_COMBO(oldn, n, flag)             \
+       do {                                         \
+         hook_merge_nodes(&n, 1, &oldn, 1, flag);   \
+         __dbg_info_merge_pair(n, oldn, dbg_combo); \
+       } while(0)
 
 #endif