updated doxygen docu

persistent store for pattern added (did not work yet)

[r8418]

diff --git a/ir/stat/dags.c b/ir/stat/dags.c
index b14c990..cdece54 100644 (file)
--- a/ir/stat/dags.c
+++ b/ir/stat/dags.c
@@ -21,11 +21,11 @@
 #include "irtools.h"
 
 enum dag_counting_options_t {
 #include "irtools.h"
 
 enum dag_counting_options_t {

-  FIRMSTAT_COPY_CONSTANTS = 0x00000001,                /**< if set, constants will be treated as they are in
-                                                    the same block as its successors */
-  FIRMSTAT_LOAD_IS_LEAVE  = 0x00000002,         /**< Load nodes are always leaves */
-  FIRMSTAT_CALL_IS_LEAVE  = 0x00000004,         /**< Call nodes are always leaves */
-  FIRMSTAT_ARGS_ARE_ROOTS = 0x00000008,         /**< arguments (Proj(Proj(Start)) are roots */
+       FIRMSTAT_COPY_CONSTANTS = 0x00000001,  /**< if set, constants will be treated as they are in
+                                                   the same block as its successors */
+       FIRMSTAT_LOAD_IS_LEAVE  = 0x00000002,  /**< Load nodes are always leaves */
+       FIRMSTAT_CALL_IS_LEAVE  = 0x00000004,  /**< Call nodes are always leaves */
+       FIRMSTAT_ARGS_ARE_ROOTS = 0x00000008,  /**< arguments (Proj(Proj(Start)) are roots */

 };
 
 typedef struct _dag_entry_t dag_entry_t;
 };
 
 typedef struct _dag_entry_t dag_entry_t;


@@ -34,24 +34,24 @@ typedef struct _dag_entry_t dag_entry_t;
  * Environment for connecting DAG's
  */
 typedef struct _dag_env_t {
  * Environment for connecting DAG's
  */
 typedef struct _dag_env_t {

-  struct obstack obst;
-  unsigned       num_of_dags;
-  dag_entry_t    *list_of_dags;
-  unsigned       options;              /**< DAG counting options */
+       struct obstack obst;
+       unsigned       num_of_dags;
+       dag_entry_t    *list_of_dags;
+       unsigned       options;       /**< DAG counting options */

 } dag_env_t;
 
 /**
  * a DAG Entry
  */
 struct _dag_entry_t {
 } dag_env_t;
 
 /**
  * a DAG Entry
  */
 struct _dag_entry_t {

-  unsigned    id;                       /**< assigned ID for this DAG */
-  ir_node     *root;                    /**< one root of the DAG */
-  unsigned    num_roots;                /**< number of root nodes in the DAG */
-  unsigned    num_nodes;                /**< overall number of nodes in the DAG */
-  unsigned    num_inner_nodes;          /**< number of inner nodes in the DAG */
-  unsigned    is_dead;                  /**< marks a dead entry */
-  dag_entry_t *next;                    /**< link all entries of a DAG */
-  dag_entry_t *link;                    /**< if set, this entry is an ID */
+       unsigned    id;               /**< assigned ID for this DAG */
+       ir_node     *root;            /**< one root of the DAG */
+       unsigned    num_roots;        /**< number of root nodes in the DAG */
+       unsigned    num_nodes;        /**< overall number of nodes in the DAG */
+       unsigned    num_inner_nodes;  /**< number of inner nodes in the DAG */
+       unsigned    is_dead;          /**< marks a dead entry */
+       dag_entry_t *next;            /**< link all entries of a DAG */
+       dag_entry_t *link;            /**< if set, this entry is an ID */

 };
 
 /**
 };
 
 /**


@@ -59,20 +59,20 @@ struct _dag_entry_t {
  */
 static dag_entry_t *get_irn_dag_entry(ir_node *n)
 {
  */
 static dag_entry_t *get_irn_dag_entry(ir_node *n)
 {

-  dag_entry_t *res = get_irn_link(n);
+       dag_entry_t *res = get_irn_link(n);

 
 

-  if (res) {
-    dag_entry_t *p;
+       if (res) {
+               dag_entry_t *p;

 
 

-    for (p = res; p->link; p = p->link);
+               for (p = res; p->link; p = p->link);

 
 

-    if (p != res)
-      set_irn_link(n, p);
+               if (p != res)
+                       set_irn_link(n, p);

 
 

-    return p;
-  }
-  return NULL;
-}
+               return p;
+       }  /* if */
+       return NULL;
+}  /* get_irn_dag_entry */

 
 #define set_irn_dag_entry(n, e) set_irn_link(n, e)
 
 
 #define set_irn_dag_entry(n, e) set_irn_link(n, e)
 


@@ -81,127 +81,127 @@ static dag_entry_t *get_irn_dag_entry(ir_node *n)
  */
 static int is_arg(ir_node *node)
 {
  */
 static int is_arg(ir_node *node)
 {

-  if (! is_Proj(node))
-    return 0;
+       if (! is_Proj(node))
+               return 0;

 
 

-  node = get_Proj_pred(node);
-  if (! is_Proj(node))
-    return 0;
+       node = get_Proj_pred(node);
+       if (! is_Proj(node))
+               return 0;

 
 

-  node = get_Proj_pred(node);
-  return get_irn_op(node) == op_Start;
-}
+       node = get_Proj_pred(node);
+       return get_irn_op(node) == op_Start;
+}  /* is_arg */

 
 /**
  * walker for connecting DAGs and counting.
  */
 static void connect_dags(ir_node *node, void *env)
 {
 
 /**
  * walker for connecting DAGs and counting.
  */
 static void connect_dags(ir_node *node, void *env)
 {

-  dag_env_t   *dag_env = env;
-  int         i, arity;
-  ir_node     *block;
-  dag_entry_t *entry;
-  ir_mode     *mode;
-
-  if (is_Block(node))
-    return;
-
-  block = get_nodes_block(node);
-
-  /* ignore start end end blocks */
-  if (block == get_irg_start_block(current_ir_graph) ||
-      block == get_irg_end_block(current_ir_graph))
-    return;
-
-  if (is_Phi(node))
-    return;
-
-  if (dag_env->options & FIRMSTAT_ARGS_ARE_ROOTS && is_arg(node))
-    return;
-
-  mode = get_irn_mode(node);
-  if (mode == mode_X || mode == mode_M) {
-    /* do NOT count mode_X nodes */
-    return;
-  }
-
-  entry = get_irn_dag_entry(node);
-
-  if (! entry) {
-    /* found a not assigned node, maybe a new root */
-    entry = obstack_alloc(&dag_env->obst, sizeof(*entry));
-
-    entry->num_nodes       = 1;
-    entry->num_roots       = 1;
-    entry->num_inner_nodes = 0;
-    entry->root            = node;
-    entry->is_dead         = 0;
-    entry->next            = dag_env->list_of_dags;
-    entry->link            = NULL;
-
-    ++dag_env->num_of_dags;
-    dag_env->list_of_dags = entry;
-
-    set_irn_dag_entry(node, entry);
-  }
-
-  /* if this option is set, Loads are allways leaves */
-  if (dag_env->options & FIRMSTAT_LOAD_IS_LEAVE && get_irn_op(node) == op_Load)
-    return;
-
-  if (dag_env->options & FIRMSTAT_CALL_IS_LEAVE && get_irn_op(node) == op_Call)
-    return;
-
-  /* put the predecessors into the same DAG as the current */
-  for (i = 0, arity = get_irn_arity(node); i < arity; ++i) {
-    ir_node *prev = get_irn_n(node, i);
-    ir_mode *mode = get_irn_mode(prev);
-
-    if (is_Phi(prev))
-      continue;
-
-    if (mode == mode_X || mode == mode_M)
-      continue;
-
-    /*
-     * copy constants if requested into the DAG's
-     * beware, do NOT add a link, as this will result in
-     * wrong intersections
-     */
-    if (dag_env->options & FIRMSTAT_COPY_CONSTANTS) {
-      if (get_irn_op(prev) == op_Const || get_irn_op(prev) == op_SymConst) {
-       ++entry->num_nodes;
-       ++entry->num_inner_nodes;
-      }
-    }
-
-    /* only nodes from the same block goes into the DAG */
-    if (get_nodes_block(prev) == block) {
-      dag_entry_t *prev_entry = get_irn_dag_entry(prev);
-
-      if (! prev_entry) {
-       /* not assigned node, put it into the same DAG */
-       set_irn_dag_entry(prev, entry);
-       ++entry->num_nodes;
-       ++entry->num_inner_nodes;
-      }
-      else {
-        if (prev_entry != entry) {
-
-          /* two DAGs intersect */
-          entry->num_roots       += prev_entry->num_roots;
-          entry->num_nodes       += prev_entry->num_nodes;
-          entry->num_inner_nodes += prev_entry->num_inner_nodes;
-
-          --dag_env->num_of_dags;
-
-          prev_entry->is_dead = 1;
-          prev_entry->link    = entry;
-        }
-      }
-    }
-  }
-}
+       dag_env_t   *dag_env = env;
+       int         i, arity;
+       ir_node     *block;
+       dag_entry_t *entry;
+       ir_mode     *mode;
+
+       if (is_Block(node))
+               return;
+
+       block = get_nodes_block(node);
+
+       /* ignore start end end blocks */
+       if (block == get_irg_start_block(current_ir_graph) ||
+               block == get_irg_end_block(current_ir_graph)) {
+               return;
+       }  /* if */
+
+       if (is_Phi(node))
+               return;
+
+       if (dag_env->options & FIRMSTAT_ARGS_ARE_ROOTS && is_arg(node))
+               return;
+
+       mode = get_irn_mode(node);
+       if (mode == mode_X || mode == mode_M) {
+               /* do NOT count mode_X nodes */
+               return;
+       }  /* if */
+
+       entry = get_irn_dag_entry(node);
+
+       if (! entry) {
+               /* found a not assigned node, maybe a new root */
+               entry = obstack_alloc(&dag_env->obst, sizeof(*entry));
+
+               entry->num_nodes       = 1;
+               entry->num_roots       = 1;
+               entry->num_inner_nodes = 0;
+               entry->root            = node;
+               entry->is_dead         = 0;
+               entry->next            = dag_env->list_of_dags;
+               entry->link            = NULL;
+
+               ++dag_env->num_of_dags;
+               dag_env->list_of_dags = entry;
+
+               set_irn_dag_entry(node, entry);
+       }  /* if */
+
+       /* if this option is set, Loads are allways leaves */
+       if (dag_env->options & FIRMSTAT_LOAD_IS_LEAVE && get_irn_op(node) == op_Load)
+               return;
+
+       if (dag_env->options & FIRMSTAT_CALL_IS_LEAVE && get_irn_op(node) == op_Call)
+               return;
+
+       /* put the predecessors into the same DAG as the current */
+       for (i = 0, arity = get_irn_arity(node); i < arity; ++i) {
+               ir_node *prev = get_irn_n(node, i);
+               ir_mode *mode = get_irn_mode(prev);
+
+               if (is_Phi(prev))
+                       continue;
+
+               if (mode == mode_X || mode == mode_M)
+                       continue;
+
+               /*
+                * copy constants if requested into the DAG's
+                * beware, do NOT add a link, as this will result in
+                * wrong intersections
+                */
+               if (dag_env->options & FIRMSTAT_COPY_CONSTANTS) {
+                       if (get_irn_op(prev) == op_Const || get_irn_op(prev) == op_SymConst) {
+                               ++entry->num_nodes;
+                               ++entry->num_inner_nodes;
+                       }  /* if */
+               }  /* if */
+
+               /* only nodes from the same block goes into the DAG */
+               if (get_nodes_block(prev) == block) {
+                       dag_entry_t *prev_entry = get_irn_dag_entry(prev);
+
+                       if (! prev_entry) {
+                               /* not assigned node, put it into the same DAG */
+                               set_irn_dag_entry(prev, entry);
+                               ++entry->num_nodes;
+                               ++entry->num_inner_nodes;
+                       } else {
+                               if (prev_entry != entry) {
+
+                                       /* two DAGs intersect */
+                                       entry->num_roots       += prev_entry->num_roots;
+                                       entry->num_nodes       += prev_entry->num_nodes;
+                                       entry->num_inner_nodes += prev_entry->num_inner_nodes;
+
+                                       --dag_env->num_of_dags;
+
+                                       prev_entry->is_dead = 1;
+                                       prev_entry->link    = entry;
+                               }  /* if */
+                       }  /* if */
+               }  /* if */
+       }  /* for */
+}  /* connect_dags */

 
 #define DEFAULT_RET     1
 #define COLOR_RET       1
 
 #define DEFAULT_RET     1
 #define COLOR_RET       1


@@ -213,84 +213,84 @@ static unsigned mark_options;
  */
 static int stat_dag_mark_hook(FILE *F, ir_node *n, ir_node *l)
 {
  */
 static int stat_dag_mark_hook(FILE *F, ir_node *n, ir_node *l)
 {

-  static const char *colors[] = { "purple", "pink", "lightblue", "orange", "khaki", "orchid", "lilac", "turquoise" };
-  dag_entry_t *entry;
+       static const char *colors[] = { "purple", "pink", "lightblue", "orange", "khaki", "orchid", "lilac", "turquoise" };
+       dag_entry_t *entry;

 
 

-  /* do not count Bad / NoMem */
-  if (l) {
-    ir_op *op = get_irn_op(l);
+       /* do not count Bad / NoMem */
+       if (l) {
+               ir_op *op = get_irn_op(l);

 
 

-    if (op == op_NoMem || op == op_Bad)
-      return DEFAULT_RET;
+               if (op == op_NoMem || op == op_Bad)
+                       return DEFAULT_RET;

 
 

-    /* check for additional options */
-    op = get_irn_op(n);
+               /* check for additional options */
+               op = get_irn_op(n);

 
 

-    if (mark_options & FIRMSTAT_LOAD_IS_LEAVE && op == op_Load)
-      return DEFAULT_RET;
+               if (mark_options & FIRMSTAT_LOAD_IS_LEAVE && op == op_Load)
+                       return DEFAULT_RET;

 
 

-    if (mark_options & FIRMSTAT_CALL_IS_LEAVE && op == op_Call)
-      return DEFAULT_RET;
-  }
+               if (mark_options & FIRMSTAT_CALL_IS_LEAVE && op == op_Call)
+                       return DEFAULT_RET;
+       }  /* if */

 
 

-  entry = get_irn_dag_entry(n);
-  if (! entry)
-    return DEFAULT_RET;
+       entry = get_irn_dag_entry(n);
+       if (! entry)
+               return DEFAULT_RET;

 
 

-  fprintf(F, "color: %s info3: \"DAG id: %u\"", colors[entry->id & 7], entry->id);
+       fprintf(F, "color: %s info3: \"DAG id: %u\"", colors[entry->id & 7], entry->id);

 
 

-  /* I know the color! */
-  return COLOR_RET;
-}
+       /* I know the color! */
+       return COLOR_RET;
+}  /* stat_dag_mark_hook */

 
 /**
  * count the DAG's size of a graph
  */
 void count_dags_in_graph(graph_entry_t *global, graph_entry_t *graph)
 {
 
 /**
  * count the DAG's size of a graph
  */
 void count_dags_in_graph(graph_entry_t *global, graph_entry_t *graph)
 {

-  dag_env_t   root_env;
-  dag_entry_t *entry;
-  unsigned id;
+       dag_env_t   root_env;
+       dag_entry_t *entry;
+       unsigned id;

 
 

-  /* do NOT check the const code irg */
-  if (graph->irg == get_const_code_irg())
-    return;
+       /* do NOT check the const code irg */
+       if (graph->irg == get_const_code_irg())
+               return;

 
 

-  /* first step, clear the links */
-  irg_walk_graph(graph->irg, firm_clear_link, NULL, NULL);
+       /* first step, clear the links */
+       irg_walk_graph(graph->irg, firm_clear_link, NULL, NULL);

 
 

-  obstack_init(&root_env.obst);
-  root_env.num_of_dags  = 0;
-  root_env.list_of_dags = NULL;
-  root_env.options      = FIRMSTAT_COPY_CONSTANTS | FIRMSTAT_LOAD_IS_LEAVE | FIRMSTAT_CALL_IS_LEAVE;
+       obstack_init(&root_env.obst);
+       root_env.num_of_dags  = 0;
+       root_env.list_of_dags = NULL;
+       root_env.options      = FIRMSTAT_COPY_CONSTANTS | FIRMSTAT_LOAD_IS_LEAVE | FIRMSTAT_CALL_IS_LEAVE;

 
 

-  /* count them */
-  irg_walk_graph(graph->irg, connect_dags, NULL, &root_env);
+       /* count them */
+       irg_walk_graph(graph->irg, connect_dags, NULL, &root_env);

 
 

-  printf("Graph %p %s --- %d\n", (void *)graph->irg, get_entity_name(get_irg_entity(graph->irg)),
-      root_env.num_of_dags);
+       printf("Graph %p %s --- %d\n", (void *)graph->irg, get_entity_name(get_irg_entity(graph->irg)),
+               root_env.num_of_dags);

 
 

-  for (id = 0, entry = root_env.list_of_dags; entry; entry = entry->next) {
-    if (entry->is_dead)
-      continue;
-    entry->id = id++;
+       for (id = 0, entry = root_env.list_of_dags; entry; entry = entry->next) {
+               if (entry->is_dead)
+                       continue;
+               entry->id = id++;

 
 

-    printf("number of roots %d number of nodes %d inner %d %ld\n",
-      entry->num_roots,
-      entry->num_nodes,
-      entry->num_inner_nodes,
-      get_irn_node_nr(entry->root));
-  }
+               printf("number of roots %d number of nodes %d inner %d %ld\n",
+                       entry->num_roots,
+                       entry->num_nodes,
+                       entry->num_inner_nodes,
+                       get_irn_node_nr(entry->root));
+       }  /* for */

 
 #if 1
 
 #if 1

-  /* dump for test */
-  mark_options = root_env.options;
-  set_dump_node_vcgattr_hook(stat_dag_mark_hook);
-  dump_ir_block_graph(graph->irg, "-dag");
-  set_dump_node_vcgattr_hook(NULL);
+       /* dump for test */
+       mark_options = root_env.options;
+       set_dump_node_vcgattr_hook(stat_dag_mark_hook);
+       dump_ir_block_graph(graph->irg, "-dag");
+       set_dump_node_vcgattr_hook(NULL);

 #endif
 
 #endif
 

-  assert(id == root_env.num_of_dags);
+       assert(id == root_env.num_of_dags);

 
 

-  obstack_free(&root_env.obst, NULL);
-}
+       obstack_free(&root_env.obst, NULL);
+}  /* count_dags_in_graph */

diff --git a/ir/stat/firmstat.c b/ir/stat/firmstat.c
index a879dce..13bacd3 100644 (file)
--- a/ir/stat/firmstat.c
+++ b/ir/stat/firmstat.c
@@ -86,125 +86,125 @@ static const int status_disable = 0;
 static stat_info_t *status = (stat_info_t *)&status_disable;
 
 /**
 static stat_info_t *status = (stat_info_t *)&status_disable;
 
 /**

- * compare two elements of the opcode hash
+ * Compare two elements of the opcode hash.

  */
 static int opcode_cmp(const void *elt, const void *key)
 {
  */
 static int opcode_cmp(const void *elt, const void *key)
 {

-  const node_entry_t *e1 = elt;
-  const node_entry_t *e2 = key;
+       const node_entry_t *e1 = elt;
+       const node_entry_t *e2 = key;

 
 

-  return e1->op->code - e2->op->code;
-}
+       return e1->op->code - e2->op->code;
+} /* opcode_cmp */

 
 /**
 
 /**

- * compare two elements of the graph hash
+ * Compare two elements of the graph hash.

  */
 static int graph_cmp(const void *elt, const void *key)
 {
  */
 static int graph_cmp(const void *elt, const void *key)
 {

-  const graph_entry_t *e1 = elt;
-  const graph_entry_t *e2 = key;
+       const graph_entry_t *e1 = elt;
+       const graph_entry_t *e2 = key;

 
 

-  return e1->irg != e2->irg;
-}
+       return e1->irg != e2->irg;
+} /* graph_cmp */

 
 /**
 
 /**

- * compare two elements of the optimization hash
+ * Compare two elements of the optimization hash.

  */
 static int opt_cmp(const void *elt, const void *key)
 {
  */
 static int opt_cmp(const void *elt, const void *key)
 {

-  const opt_entry_t *e1 = elt;
-  const opt_entry_t *e2 = key;
+       const opt_entry_t *e1 = elt;
+       const opt_entry_t *e2 = key;

 
 

-  return e1->op->code != e2->op->code;
-}
+       return e1->op->code != e2->op->code;
+} /* opt_cmp */

 
 /**
 
 /**

- * compare two elements of the block/extbb hash
+ * Compare two elements of the block/extbb hash.

  */
 static int block_cmp(const void *elt, const void *key)
 {
  */
 static int block_cmp(const void *elt, const void *key)
 {

-  const block_entry_t *e1 = elt;
-  const block_entry_t *e2 = key;
+       const block_entry_t *e1 = elt;
+       const block_entry_t *e2 = key;

 
 

-  return e1->block_nr != e2->block_nr;
-}
+       return e1->block_nr != e2->block_nr;
+} /* block_cmp */

 
 /**
 
 /**

- * compare two elements of the be_block hash
+ * Compare two elements of the be_block hash.

  */
 static int be_block_cmp(const void *elt, const void *key)
 {
  */
 static int be_block_cmp(const void *elt, const void *key)
 {

-  const be_block_entry_t *e1 = elt;
-  const be_block_entry_t *e2 = key;
+       const be_block_entry_t *e1 = elt;
+       const be_block_entry_t *e2 = key;

 
 

-  return e1->block_nr != e2->block_nr;
-}
+       return e1->block_nr != e2->block_nr;
+} /* be_block_cmp */

 
 /**
 
 /**

- * compare two elements of reg pressure hash
+ * Compare two elements of reg pressure hash.

  */
 static int reg_pressure_cmp(const void *elt, const void *key)
 {
  */
 static int reg_pressure_cmp(const void *elt, const void *key)
 {

-  const reg_pressure_entry_t *e1 = elt;
-  const reg_pressure_entry_t *e2 = key;
+       const reg_pressure_entry_t *e1 = elt;
+       const reg_pressure_entry_t *e2 = key;

 
 

-  return e1->class_name != e2->class_name;
-}
+       return e1->class_name != e2->class_name;
+} /* reg_pressure_cmp */

 
 /**
 
 /**

- * compare two elements of the perm_stat hash
+ * Compare two elements of the perm_stat hash.

  */
 static int perm_stat_cmp(const void *elt, const void *key)
 {
  */
 static int perm_stat_cmp(const void *elt, const void *key)
 {

-  const perm_stat_entry_t *e1 = elt;
-  const perm_stat_entry_t *e2 = key;
+       const perm_stat_entry_t *e1 = elt;
+       const perm_stat_entry_t *e2 = key;

 
 

-  return e1->perm != e2->perm;
-}
+       return e1->perm != e2->perm;
+} /* perm_stat_cmp */

 
 /**
 
 /**

- * compare two elements of the perm_class hash
+ * Compare two elements of the perm_class hash.

  */
 static int perm_class_cmp(const void *elt, const void *key)
 {
  */
 static int perm_class_cmp(const void *elt, const void *key)
 {

-  const perm_class_entry_t *e1 = elt;
-  const perm_class_entry_t *e2 = key;
+       const perm_class_entry_t *e1 = elt;
+       const perm_class_entry_t *e2 = key;

 
 

-  return e1->class_name != e2->class_name;
-}
+       return e1->class_name != e2->class_name;
+} /* perm_class_cmp */

 
 /**
 
 /**

- * compare two elements of the ir_op hash
+ * Compare two elements of the ir_op hash.

  */
 static int opcode_cmp_2(const void *elt, const void *key)
 {
  */
 static int opcode_cmp_2(const void *elt, const void *key)
 {

-  const ir_op *e1 = elt;
-  const ir_op *e2 = key;
+       const ir_op *e1 = elt;
+       const ir_op *e2 = key;

 
 

-  return e1->code != e2->code;
-}
+       return e1->code != e2->code;
+} /* opcode_cmp_2 */

 
 /**
 
 /**

- * compare two elements of the address_mark set
+ * Compare two elements of the address_mark set.

  */
 static int address_mark_cmp(const void *elt, const void *key, size_t size)
 {
  */
 static int address_mark_cmp(const void *elt, const void *key, size_t size)
 {

-  const address_mark_entry_t *e1 = elt;
-  const address_mark_entry_t *e2 = key;
+       const address_mark_entry_t *e1 = elt;
+       const address_mark_entry_t *e2 = key;

 
 

-  /* compare only the nodes, the rest is used as data container */
-  return e1->node != e2->node;
-}
+       /* compare only the nodes, the rest is used as data container */
+       return e1->node != e2->node;
+} /* address_mark_cmp */

 
 /**
 
 /**

- * clears all counter in a node_entry_t
+ * Clear all counter in a node_entry_t.

  */
 static void opcode_clear_entry(node_entry_t *elem)
 {
  */
 static void opcode_clear_entry(node_entry_t *elem)
 {

-  cnt_clr(&elem->cnt_alive);
-  cnt_clr(&elem->new_node);
-  cnt_clr(&elem->into_Id);
-}
+       cnt_clr(&elem->cnt_alive);
+       cnt_clr(&elem->new_node);
+       cnt_clr(&elem->into_Id);
+} /* opcode_clear_entry */

 
 /**
  * Returns the associates node_entry_t for an ir_op
 
 /**
  * Returns the associates node_entry_t for an ir_op


@@ -214,25 +214,25 @@ static void opcode_clear_entry(node_entry_t *elem)
  */
 static node_entry_t *opcode_get_entry(const ir_op *op, hmap_node_entry_t *hmap)
 {
  */
 static node_entry_t *opcode_get_entry(const ir_op *op, hmap_node_entry_t *hmap)
 {

-  node_entry_t key;
-  node_entry_t *elem;
+       node_entry_t key;
+       node_entry_t *elem;

 
 

-  key.op = op;
+       key.op = op;

 
 

-  elem = pset_find(hmap, &key, op->code);
-  if (elem)
-    return elem;
+       elem = pset_find(hmap, &key, op->code);
+       if (elem)
+               return elem;

 
 

-  elem = obstack_alloc(&status->cnts, sizeof(*elem));
-  memset(elem, 0, sizeof(*elem));
+       elem = obstack_alloc(&status->cnts, sizeof(*elem));
+       memset(elem, 0, sizeof(*elem));

 
 

-  /* clear counter */
-  opcode_clear_entry(elem);
+       /* clear counter */
+       opcode_clear_entry(elem);

 
 

-  elem->op = op;
+       elem->op = op;

 
 

-  return pset_insert(hmap, elem, op->code);
-}
+       return pset_insert(hmap, elem, op->code);
+} /* opcode_get_entry */

 
 /**
  * Returns the associates ir_op for an opcode
 
 /**
  * Returns the associates ir_op for an opcode


@@ -242,43 +242,43 @@ static node_entry_t *opcode_get_entry(const ir_op *op, hmap_node_entry_t *hmap)
  */
 static ir_op *opcode_find_entry(opcode code, hmap_ir_op *hmap)
 {
  */
 static ir_op *opcode_find_entry(opcode code, hmap_ir_op *hmap)
 {

-  ir_op key;
+       ir_op key;

 
 

-  key.code = code;
-  return pset_find(hmap, &key, code);
-}
+       key.code = code;
+       return pset_find(hmap, &key, code);
+} /* opcode_find_entry */

 
 /**
  * clears all counter in a graph_entry_t
  */
 static void graph_clear_entry(graph_entry_t *elem, int all)
 {
 
 /**
  * clears all counter in a graph_entry_t
  */
 static void graph_clear_entry(graph_entry_t *elem, int all)
 {

-  if (all) {
-    cnt_clr(&elem->cnt_walked);
-    cnt_clr(&elem->cnt_walked_blocks);
-    cnt_clr(&elem->cnt_was_inlined);
-    cnt_clr(&elem->cnt_got_inlined);
-    cnt_clr(&elem->cnt_strength_red);
-    cnt_clr(&elem->cnt_real_func_call);
-  }
-  cnt_clr(&elem->cnt_edges);
-  cnt_clr(&elem->cnt_all_calls);
-  cnt_clr(&elem->cnt_call_with_cnst_arg);
-  cnt_clr(&elem->cnt_indirect_calls);
-
-  if (elem->block_hash) {
-    del_pset(elem->block_hash);
-    elem->block_hash = NULL;
-  }
-
-  if (elem->extbb_hash) {
-    del_pset(elem->extbb_hash);
-    elem->extbb_hash = NULL;
-  }
-
-  obstack_free(&elem->recalc_cnts, NULL);
-  obstack_init(&elem->recalc_cnts);
-}
+       if (all) {
+               cnt_clr(&elem->cnt_walked);
+               cnt_clr(&elem->cnt_walked_blocks);
+               cnt_clr(&elem->cnt_was_inlined);
+               cnt_clr(&elem->cnt_got_inlined);
+               cnt_clr(&elem->cnt_strength_red);
+               cnt_clr(&elem->cnt_real_func_call);
+       }  /* if */
+       cnt_clr(&elem->cnt_edges);
+       cnt_clr(&elem->cnt_all_calls);
+       cnt_clr(&elem->cnt_call_with_cnst_arg);
+       cnt_clr(&elem->cnt_indirect_calls);
+
+       if (elem->block_hash) {
+               del_pset(elem->block_hash);
+               elem->block_hash = NULL;
+       }  /* if */
+
+       if (elem->extbb_hash) {
+               del_pset(elem->extbb_hash);
+               elem->extbb_hash = NULL;
+       }  /* if */
+
+       obstack_free(&elem->recalc_cnts, NULL);
+       obstack_init(&elem->recalc_cnts);
+} /* graph_clear_entry */

 
 /**
  * Returns the associated graph_entry_t for an IR graph.
 
 /**
  * Returns the associated graph_entry_t for an IR graph.


@@ -288,52 +288,52 @@ static void graph_clear_entry(graph_entry_t *elem, int all)
  */
 static graph_entry_t *graph_get_entry(ir_graph *irg, hmap_graph_entry_t *hmap)
 {
  */
 static graph_entry_t *graph_get_entry(ir_graph *irg, hmap_graph_entry_t *hmap)
 {

-  graph_entry_t key;
-  graph_entry_t *elem;
-  int i;
+       graph_entry_t key;
+       graph_entry_t *elem;
+       int i;

 
 

-  key.irg = irg;
+       key.irg = irg;

 
 

-  elem = pset_find(hmap, &key, HASH_PTR(irg));
+       elem = pset_find(hmap, &key, HASH_PTR(irg));

 
 

-  if (elem) {
-    /* create hash map backend block information */
-    if (! elem->be_block_hash)
-      elem->be_block_hash = new_pset(be_block_cmp, 5);
+       if (elem) {
+               /* create hash map backend block information */
+               if (! elem->be_block_hash)
+                       elem->be_block_hash = new_pset(be_block_cmp, 5);

 
 

-    return elem;
-  }
+               return elem;
+       }  /* if */

 
 

-  /* allocate a new one */
-  elem = obstack_alloc(&status->cnts, sizeof(*elem));
-  memset(elem, 0, sizeof(*elem));
-  obstack_init(&elem->recalc_cnts);
+       /* allocate a new one */
+       elem = obstack_alloc(&status->cnts, sizeof(*elem));
+       memset(elem, 0, sizeof(*elem));
+       obstack_init(&elem->recalc_cnts);

 
 

-  /* clear counter */
-  graph_clear_entry(elem, 1);
+       /* clear counter */
+       graph_clear_entry(elem, 1);

 
 

-  /* new hash table for opcodes here  */
-  elem->opcode_hash   = new_pset(opcode_cmp, 5);
-  elem->address_mark  = new_set(address_mark_cmp, 5);
-  elem->irg           = irg;
+       /* new hash table for opcodes here  */
+       elem->opcode_hash   = new_pset(opcode_cmp, 5);
+       elem->address_mark  = new_set(address_mark_cmp, 5);
+       elem->irg           = irg;

 
 

-  /* these hash tables are created on demand */
-  elem->block_hash = NULL;
-  elem->extbb_hash = NULL;
+       /* these hash tables are created on demand */
+       elem->block_hash = NULL;
+       elem->extbb_hash = NULL;

 
 

-  for (i = 0; i < sizeof(elem->opt_hash)/sizeof(elem->opt_hash[0]); ++i)
-    elem->opt_hash[i] = new_pset(opt_cmp, 4);
+       for (i = 0; i < sizeof(elem->opt_hash)/sizeof(elem->opt_hash[0]); ++i)
+               elem->opt_hash[i] = new_pset(opt_cmp, 4);

 
 

-  return pset_insert(hmap, elem, HASH_PTR(irg));
-}
+       return pset_insert(hmap, elem, HASH_PTR(irg));
+} /* graph_get_entry */

 
 /**
 
 /**

- * clears all counter in an opt_entry_t
+ * Clear all counter in an opt_entry_t.

  */
 static void opt_clear_entry(opt_entry_t *elem)
 {
  */
 static void opt_clear_entry(opt_entry_t *elem)
 {

-  cnt_clr(&elem->count);
-}
+       cnt_clr(&elem->count);
+} /* opt_clear_entry */

 
 /**
  * Returns the associated opt_entry_t for an IR operation.
 
 /**
  * Returns the associated opt_entry_t for an IR operation.


@@ -343,36 +343,36 @@ static void opt_clear_entry(opt_entry_t *elem)
  */
 static opt_entry_t *opt_get_entry(const ir_op *op, hmap_opt_entry_t *hmap)
 {
  */
 static opt_entry_t *opt_get_entry(const ir_op *op, hmap_opt_entry_t *hmap)
 {

-  opt_entry_t key;
-  opt_entry_t *elem;
+       opt_entry_t key;
+       opt_entry_t *elem;

 
 

-  key.op = op;
+       key.op = op;

 
 

-  elem = pset_find(hmap, &key, op->code);
-  if (elem)
-    return elem;
+       elem = pset_find(hmap, &key, op->code);
+       if (elem)
+               return elem;

 
 

-  elem = obstack_alloc(&status->cnts, sizeof(*elem));
-  memset(elem, 0, sizeof(*elem));
+       elem = obstack_alloc(&status->cnts, sizeof(*elem));
+       memset(elem, 0, sizeof(*elem));

 
 

-  /* clear new counter */
-  opt_clear_entry(elem);
+       /* clear new counter */
+       opt_clear_entry(elem);

 
 

-  elem->op = op;
+       elem->op = op;

 
 

-  return pset_insert(hmap, elem, op->code);
-}
+       return pset_insert(hmap, elem, op->code);
+} /* opt_get_entry */

 
 /**
  * clears all counter in a block_entry_t
  */
 static void block_clear_entry(block_entry_t *elem)
 {
 
 /**
  * clears all counter in a block_entry_t
  */
 static void block_clear_entry(block_entry_t *elem)
 {

-  cnt_clr(&elem->cnt_nodes);
-  cnt_clr(&elem->cnt_edges);
-  cnt_clr(&elem->cnt_in_edges);
-  cnt_clr(&elem->cnt_out_edges);
-  cnt_clr(&elem->cnt_phi_data);
+       cnt_clr(&elem->cnt_nodes);
+       cnt_clr(&elem->cnt_edges);
+       cnt_clr(&elem->cnt_in_edges);
+       cnt_clr(&elem->cnt_out_edges);
+       cnt_clr(&elem->cnt_phi_data);

 }
 
 /**
 }
 
 /**


@@ -383,28 +383,28 @@ static void block_clear_entry(block_entry_t *elem)
  */
 static block_entry_t *block_get_entry(struct obstack *obst, long block_nr, hmap_block_entry_t *hmap)
 {
  */
 static block_entry_t *block_get_entry(struct obstack *obst, long block_nr, hmap_block_entry_t *hmap)
 {

-  block_entry_t key;
-  block_entry_t *elem;
+       block_entry_t key;
+       block_entry_t *elem;

 
 

-  key.block_nr = block_nr;
+       key.block_nr = block_nr;

 
 

-  elem = pset_find(hmap, &key, block_nr);
-  if (elem)
-    return elem;
+       elem = pset_find(hmap, &key, block_nr);
+       if (elem)
+               return elem;

 
 

-  elem = obstack_alloc(obst, sizeof(*elem));
-  memset(elem, 0, sizeof(*elem));
+       elem = obstack_alloc(obst, sizeof(*elem));
+       memset(elem, 0, sizeof(*elem));

 
 

-  /* clear new counter */
-  block_clear_entry(elem);
+       /* clear new counter */
+       block_clear_entry(elem);

 
 

-  elem->block_nr = block_nr;
+       elem->block_nr = block_nr;

 
 

-  return pset_insert(hmap, elem, block_nr);
-}
+       return pset_insert(hmap, elem, block_nr);
+} /* block_get_entry */

 
 /**
 
 /**

- * clears all sets in be_block_entry_t
+ * Clear all sets in be_block_entry_t.

  */
 static void be_block_clear_entry(be_block_entry_t *elem)
 {
  */
 static void be_block_clear_entry(be_block_entry_t *elem)
 {


@@ -420,7 +420,7 @@ static void be_block_clear_entry(be_block_entry_t *elem)
        elem->reg_pressure    = new_pset(reg_pressure_cmp, 5);
        elem->sched_ready     = stat_new_int_distrib_tbl();
        elem->perm_class_stat = new_pset(perm_class_cmp, 5);
        elem->reg_pressure    = new_pset(reg_pressure_cmp, 5);
        elem->sched_ready     = stat_new_int_distrib_tbl();
        elem->perm_class_stat = new_pset(perm_class_cmp, 5);

-}
+} /* be_block_clear_entry */

 
 /**
  * Returns the associated be_block_entry_t for an block.
 
 /**
  * Returns the associated be_block_entry_t for an block.


@@ -430,25 +430,25 @@ static void be_block_clear_entry(be_block_entry_t *elem)
  */
 static be_block_entry_t *be_block_get_entry(struct obstack *obst, long block_nr, hmap_be_block_entry_t *hmap)
 {
  */
 static be_block_entry_t *be_block_get_entry(struct obstack *obst, long block_nr, hmap_be_block_entry_t *hmap)
 {

-  be_block_entry_t key;
-  be_block_entry_t *elem;
+       be_block_entry_t key;
+       be_block_entry_t *elem;

 
 

-  key.block_nr = block_nr;
+       key.block_nr = block_nr;

 
 

-  elem = pset_find(hmap, &key, block_nr);
-  if (elem)
-    return elem;
+       elem = pset_find(hmap, &key, block_nr);
+       if (elem)
+               return elem;

 
 

-  elem = obstack_alloc(obst, sizeof(*elem));
-  memset(elem, 0, sizeof(*elem));
+       elem = obstack_alloc(obst, sizeof(*elem));
+       memset(elem, 0, sizeof(*elem));

 
 

-  /* clear new counter */
-  be_block_clear_entry(elem);
+       /* clear new counter */
+       be_block_clear_entry(elem);

 
 

-  elem->block_nr = block_nr;
+       elem->block_nr = block_nr;

 
 

-  return pset_insert(hmap, elem, block_nr);
-}
+       return pset_insert(hmap, elem, block_nr);
+} /* be_block_get_entry */

 
 /**
  * clears all sets in perm_class_entry_t
 
 /**
  * clears all sets in perm_class_entry_t


@@ -469,25 +469,25 @@ static void perm_class_clear_entry(perm_class_entry_t *elem) {
 static perm_class_entry_t *perm_class_get_entry(struct obstack *obst, const char *class_name,
                                                 hmap_perm_class_entry_t *hmap)
 {
 static perm_class_entry_t *perm_class_get_entry(struct obstack *obst, const char *class_name,
                                                 hmap_perm_class_entry_t *hmap)
 {

-  perm_class_entry_t key;
-  perm_class_entry_t *elem;
+       perm_class_entry_t key;
+       perm_class_entry_t *elem;

 
 

-  key.class_name = class_name;
+       key.class_name = class_name;

 
 

-  elem = pset_find(hmap, &key, HASH_PTR(class_name));
-  if (elem)
-    return elem;
+       elem = pset_find(hmap, &key, HASH_PTR(class_name));
+       if (elem)
+               return elem;

 
 

-  elem = obstack_alloc(obst, sizeof(*elem));
-  memset(elem, 0, sizeof(*elem));
+       elem = obstack_alloc(obst, sizeof(*elem));
+       memset(elem, 0, sizeof(*elem));

 
 

-  /* clear new counter */
-  perm_class_clear_entry(elem);
+       /* clear new counter */
+       perm_class_clear_entry(elem);

 
 

-  elem->class_name = class_name;
+       elem->class_name = class_name;

 
 

-  return pset_insert(hmap, elem, HASH_PTR(class_name));
-}
+       return pset_insert(hmap, elem, HASH_PTR(class_name));
+} /* perm_class_get_entry */

 
 /**
  * clears all sets in perm_stat_entry_t
 
 /**
  * clears all sets in perm_stat_entry_t


@@ -501,7 +501,7 @@ static void perm_stat_clear_entry(perm_stat_entry_t *elem) {
 
        elem->chains = stat_new_int_distrib_tbl();
        elem->cycles = stat_new_int_distrib_tbl();
 
        elem->chains = stat_new_int_distrib_tbl();
        elem->cycles = stat_new_int_distrib_tbl();

-}
+} /* perm_stat_clear_entry */

 
 /**
  * Returns the associated perm_stat entry for a perm.
 
 /**
  * Returns the associated perm_stat entry for a perm.


@@ -511,25 +511,25 @@ static void perm_stat_clear_entry(perm_stat_entry_t *elem) {
  */
 static perm_stat_entry_t *perm_stat_get_entry(struct obstack *obst, ir_node *perm, hmap_perm_stat_entry_t *hmap)
 {
  */
 static perm_stat_entry_t *perm_stat_get_entry(struct obstack *obst, ir_node *perm, hmap_perm_stat_entry_t *hmap)
 {

-  perm_stat_entry_t key;
-  perm_stat_entry_t *elem;
+       perm_stat_entry_t key;
+       perm_stat_entry_t *elem;

 
 

-  key.perm = perm;
+       key.perm = perm;

 
 

-  elem = pset_find(hmap, &key, HASH_PTR(perm));
-  if (elem)
-    return elem;
+       elem = pset_find(hmap, &key, HASH_PTR(perm));
+       if (elem)
+               return elem;

 
 

-  elem = obstack_alloc(obst, sizeof(*elem));
-  memset(elem, 0, sizeof(*elem));
+       elem = obstack_alloc(obst, sizeof(*elem));
+       memset(elem, 0, sizeof(*elem));

 
 

-  /* clear new counter */
-  perm_stat_clear_entry(elem);
+       /* clear new counter */
+       perm_stat_clear_entry(elem);

 
 

-  elem->perm = perm;
+       elem->perm = perm;

 
 

-  return pset_insert(hmap, elem, HASH_PTR(perm));
-}
+       return pset_insert(hmap, elem, HASH_PTR(perm));
+} /* perm_stat_get_entry */

 
 /**
  * Returns the ir_op for an IR-node,
 
 /**
  * Returns the ir_op for an IR-node,


@@ -539,379 +539,369 @@ static perm_stat_entry_t *perm_stat_get_entry(struct obstack *obst, ir_node *per
  */
 static ir_op *stat_get_irn_op(ir_node *node)
 {
  */
 static ir_op *stat_get_irn_op(ir_node *node)
 {

-  ir_op *op = get_irn_op(node);
-
-  if (op == op_Phi && get_irn_arity(node) == 0) {
-    /* special case, a Phi0 node, count on extra counter */
-    op = status->op_Phi0 ? status->op_Phi0 : op;
-  }
-  else if (op == op_Phi && get_irn_mode(node) == mode_M) {
-    /* special case, a Memory Phi node, count on extra counter */
-    op = status->op_PhiM ? status->op_PhiM : op;
-  }
-  else if (op == op_Proj && get_irn_mode(node) == mode_M) {
-    /* special case, a Memory Proj node, count on extra counter */
-    op = status->op_ProjM ? status->op_ProjM : op;
-  }
-  else if (op == op_Mul &&
-           (get_irn_op(get_Mul_left(node)) == op_Const || get_irn_op(get_Mul_right(node)) == op_Const)) {
-    /* special case, a Multiply by a const, count on extra counter */
-    op = status->op_MulC ? status->op_MulC : op;
-  }
-  else if (op == op_Div && get_irn_op(get_Div_right(node)) == op_Const) {
-    /* special case, a division by a const, count on extra counter */
-    op = status->op_DivC ? status->op_DivC : op;
-  }
-  else if (op == op_Mod && get_irn_op(get_Mod_right(node)) == op_Const) {
-    /* special case, a module by a const, count on extra counter */
-    op = status->op_ModC ? status->op_ModC : op;
-  }
-  else if (op == op_DivMod && get_irn_op(get_DivMod_right(node)) == op_Const) {
-    /* special case, a division/modulo by a const, count on extra counter */
-    op = status->op_DivModC ? status->op_DivModC : op;
-  }
-  else if (op == op_Sel && get_irn_op(get_Sel_ptr(node)) == op_Sel) {
-    /* special case, a Sel of a Sel, count on extra counter */
-    op = status->op_SelSel ? status->op_SelSel : op;
-
-    if (get_irn_op(get_Sel_ptr(get_Sel_ptr(node))) == op_Sel) {
-      /* special case, a Sel of a Sel of a Sel, count on extra counter */
-      op = status->op_SelSelSel ? status->op_SelSelSel : op;
-    }
-  }
-
-  return op;
-}
+       ir_op *op = get_irn_op(node);
+
+       if (op == op_Phi && get_irn_arity(node) == 0) {
+               /* special case, a Phi0 node, count on extra counter */
+               op = status->op_Phi0 ? status->op_Phi0 : op;
+       } else if (op == op_Phi && get_irn_mode(node) == mode_M) {
+               /* special case, a Memory Phi node, count on extra counter */
+               op = status->op_PhiM ? status->op_PhiM : op;
+       } else if (op == op_Proj && get_irn_mode(node) == mode_M) {
+               /* special case, a Memory Proj node, count on extra counter */
+               op = status->op_ProjM ? status->op_ProjM : op;
+       } else if (op == op_Mul &&
+               (get_irn_op(get_Mul_left(node)) == op_Const || get_irn_op(get_Mul_right(node)) == op_Const)) {
+               /* special case, a Multiply by a const, count on extra counter */
+               op = status->op_MulC ? status->op_MulC : op;
+       } else if (op == op_Div && get_irn_op(get_Div_right(node)) == op_Const) {
+               /* special case, a division by a const, count on extra counter */
+               op = status->op_DivC ? status->op_DivC : op;
+       } else if (op == op_Mod && get_irn_op(get_Mod_right(node)) == op_Const) {
+               /* special case, a module by a const, count on extra counter */
+               op = status->op_ModC ? status->op_ModC : op;
+       } else if (op == op_DivMod && get_irn_op(get_DivMod_right(node)) == op_Const) {
+               /* special case, a division/modulo by a const, count on extra counter */
+               op = status->op_DivModC ? status->op_DivModC : op;
+       } else if (op == op_Sel && get_irn_op(get_Sel_ptr(node)) == op_Sel) {
+               /* special case, a Sel of a Sel, count on extra counter */
+               op = status->op_SelSel ? status->op_SelSel : op;
+
+               if (get_irn_op(get_Sel_ptr(get_Sel_ptr(node))) == op_Sel) {
+                       /* special case, a Sel of a Sel of a Sel, count on extra counter */
+                       op = status->op_SelSelSel ? status->op_SelSelSel : op;
+               }  /* if */
+       }  /* if */
+
+       return op;
+} /* stat_get_irn_op */

 
 /**
  * update the block counter
  */
 static void undate_block_info(ir_node *node, graph_entry_t *graph)
 {
 
 /**
  * update the block counter
  */
 static void undate_block_info(ir_node *node, graph_entry_t *graph)
 {

-  ir_op *op = get_irn_op(node);
-  ir_node *block;
-  block_entry_t *b_entry;
-  int i, arity;
-
-  /* check for block */
-  if (op == op_Block) {
-    arity = get_irn_arity(node);
-    b_entry = block_get_entry(&graph->recalc_cnts, get_irn_node_nr(node), graph->block_hash);
-
-    /* count all incoming edges */
-    for (i = 0; i < arity; ++i) {
-      ir_node *pred = get_irn_n(node, i);
-      ir_node *other_block = get_nodes_block(pred);
-      block_entry_t *b_entry_other = block_get_entry(&graph->recalc_cnts, get_irn_node_nr(other_block), graph->block_hash);
-
-      cnt_inc(&b_entry->cnt_in_edges); /* an edge coming from another block */
-      cnt_inc(&b_entry_other->cnt_out_edges);
-    }
-    return;
-  }
+       ir_op *op = get_irn_op(node);
+       ir_node *block;
+       block_entry_t *b_entry;
+       int i, arity;
+
+       /* check for block */
+       if (op == op_Block) {
+               arity = get_irn_arity(node);
+               b_entry = block_get_entry(&graph->recalc_cnts, get_irn_node_nr(node), graph->block_hash);
+
+               /* count all incoming edges */
+               for (i = 0; i < arity; ++i) {
+                       ir_node *pred = get_irn_n(node, i);
+                       ir_node *other_block = get_nodes_block(pred);
+                       block_entry_t *b_entry_other = block_get_entry(&graph->recalc_cnts, get_irn_node_nr(other_block), graph->block_hash);
+
+                       cnt_inc(&b_entry->cnt_in_edges);        /* an edge coming from another block */
+                       cnt_inc(&b_entry_other->cnt_out_edges);
+               }  /* for */
+               return;
+       }  /* if */

 
 

-  block   = get_nodes_block(node);
-  b_entry = block_get_entry(&graph->recalc_cnts, get_irn_node_nr(block), graph->block_hash);
+       block   = get_nodes_block(node);
+       b_entry = block_get_entry(&graph->recalc_cnts, get_irn_node_nr(block), graph->block_hash);

 
 

-  if (op == op_Phi && mode_is_datab(get_irn_mode(node))) {
-    /* count data Phi per block */
-    cnt_inc(&b_entry->cnt_phi_data);
-  }
+       if (op == op_Phi && mode_is_datab(get_irn_mode(node))) {
+               /* count data Phi per block */
+               cnt_inc(&b_entry->cnt_phi_data);
+       }  /* if */

 
 

-  /* we have a new node in our block */
-  cnt_inc(&b_entry->cnt_nodes);
+       /* we have a new node in our block */
+       cnt_inc(&b_entry->cnt_nodes);

 
 

-  /* don't count keep-alive edges */
-  if (get_irn_op(node) == op_End)
-    return;
+       /* don't count keep-alive edges */
+       if (get_irn_op(node) == op_End)
+               return;

 
 

-  arity = get_irn_arity(node);
+       arity = get_irn_arity(node);

 
 

-  for (i = 0; i < arity; ++i) {
-    ir_node *pred = get_irn_n(node, i);
-    ir_node *other_block;
+       for (i = 0; i < arity; ++i) {
+               ir_node *pred = get_irn_n(node, i);
+               ir_node *other_block;

 
 

-    other_block = get_nodes_block(pred);
+               other_block = get_nodes_block(pred);

 
 

-    if (other_block == block)
-      cnt_inc(&b_entry->cnt_edges);    /* a in block edge */
-    else {
-      block_entry_t *b_entry_other = block_get_entry(&graph->recalc_cnts, get_irn_node_nr(other_block), graph->block_hash);
+               if (other_block == block)
+                       cnt_inc(&b_entry->cnt_edges);   /* a in block edge */
+               else {
+                       block_entry_t *b_entry_other = block_get_entry(&graph->recalc_cnts, get_irn_node_nr(other_block), graph->block_hash);

 
 

-      cnt_inc(&b_entry->cnt_in_edges); /* an edge coming from another block */
-      cnt_inc(&b_entry_other->cnt_out_edges);
-    }
-  }
-}
+                       cnt_inc(&b_entry->cnt_in_edges);        /* an edge coming from another block */
+                       cnt_inc(&b_entry_other->cnt_out_edges);
+               }  /* if */
+       }  /* for */
+} /* undate_block_info */

 
 /**
 
 /**

- * update the extended block counter
+ * Update the extended block counter.

  */
  */

-static void undate_extbb_info(ir_node *node, graph_entry_t *graph)
+static void update_extbb_info(ir_node *node, graph_entry_t *graph)

 {
 {

-  ir_op *op = get_irn_op(node);
-  ir_extblk *extbb;
-  extbb_entry_t *eb_entry;
-  int i, arity;
+       ir_op *op = get_irn_op(node);
+       ir_extblk *extbb;
+       extbb_entry_t *eb_entry;
+       int i, arity;

 
 

-  /* check for block */
-  if (op == op_Block) {
-    extbb = get_nodes_extbb(node);
-    arity = get_irn_arity(node);
-    eb_entry = block_get_entry(&graph->recalc_cnts, get_extbb_node_nr(extbb), graph->extbb_hash);
+       /* check for block */
+       if (op == op_Block) {
+               extbb = get_nodes_extbb(node);
+               arity = get_irn_arity(node);
+               eb_entry = block_get_entry(&graph->recalc_cnts, get_extbb_node_nr(extbb), graph->extbb_hash);

 
 

-    /* count all incoming edges */
-    for (i = 0; i < arity; ++i) {
-      ir_node *pred = get_irn_n(node, i);
-      ir_extblk *other_extbb = get_nodes_extbb(pred);
+               /* count all incoming edges */
+               for (i = 0; i < arity; ++i) {
+                       ir_node *pred = get_irn_n(node, i);
+                       ir_extblk *other_extbb = get_nodes_extbb(pred);

 
 

-      if (extbb != other_extbb) {
-        extbb_entry_t *eb_entry_other = block_get_entry(&graph->recalc_cnts, get_extbb_node_nr(other_extbb), graph->extbb_hash);
+                       if (extbb != other_extbb) {
+                               extbb_entry_t *eb_entry_other = block_get_entry(&graph->recalc_cnts, get_extbb_node_nr(other_extbb), graph->extbb_hash);

 
 

-        cnt_inc(&eb_entry->cnt_in_edges);      /* an edge coming from another extbb */
-        cnt_inc(&eb_entry_other->cnt_out_edges);
-      }
-    }
-    return;
-  }
+                               cnt_inc(&eb_entry->cnt_in_edges);       /* an edge coming from another extbb */
+                               cnt_inc(&eb_entry_other->cnt_out_edges);
+                       }  /* if */
+               }  /* for */
+               return;
+       }  /* if */

 
 

-  extbb    = get_nodes_extbb(node);
-  eb_entry = block_get_entry(&graph->recalc_cnts, get_extbb_node_nr(extbb), graph->extbb_hash);
+       extbb    = get_nodes_extbb(node);
+       eb_entry = block_get_entry(&graph->recalc_cnts, get_extbb_node_nr(extbb), graph->extbb_hash);

 
 

-  if (op == op_Phi && mode_is_datab(get_irn_mode(node))) {
-    /* count data Phi per extbb */
-    cnt_inc(&eb_entry->cnt_phi_data);
-  }
+       if (op == op_Phi && mode_is_datab(get_irn_mode(node))) {
+               /* count data Phi per extbb */
+               cnt_inc(&eb_entry->cnt_phi_data);
+       }  /* if */

 
 

-  /* we have a new node in our block */
-  cnt_inc(&eb_entry->cnt_nodes);
+       /* we have a new node in our block */
+       cnt_inc(&eb_entry->cnt_nodes);

 
 

-  /* don't count keep-alive edges */
-  if (get_irn_op(node) == op_End)
-    return;
+       /* don't count keep-alive edges */
+       if (get_irn_op(node) == op_End)
+               return;

 
 

-  arity = get_irn_arity(node);
+       arity = get_irn_arity(node);

 
 

-  for (i = 0; i < arity; ++i) {
-    ir_node *pred = get_irn_n(node, i);
-    ir_extblk *other_extbb = get_nodes_extbb(pred);
+       for (i = 0; i < arity; ++i) {
+               ir_node *pred = get_irn_n(node, i);
+               ir_extblk *other_extbb = get_nodes_extbb(pred);

 
 

-    if (other_extbb == extbb)
-      cnt_inc(&eb_entry->cnt_edges);   /* a in extbb edge */
-    else {
-      extbb_entry_t *eb_entry_other = block_get_entry(&graph->recalc_cnts, get_extbb_node_nr(other_extbb), graph->extbb_hash);
+               if (other_extbb == extbb)
+                       cnt_inc(&eb_entry->cnt_edges);  /* a in extbb edge */
+               else {
+                       extbb_entry_t *eb_entry_other = block_get_entry(&graph->recalc_cnts, get_extbb_node_nr(other_extbb), graph->extbb_hash);

 
 

-      cnt_inc(&eb_entry->cnt_in_edges);        /* an edge coming from another extbb */
-      cnt_inc(&eb_entry_other->cnt_out_edges);
-    }
-  }
-}
+                       cnt_inc(&eb_entry->cnt_in_edges);       /* an edge coming from another extbb */
+                       cnt_inc(&eb_entry_other->cnt_out_edges);
+               }  /* if */
+       }  /* for */
+} /* update_extbb_info */

 
 

-/** calculates how many arguments of the call are const */
+/** Calculates how many arguments of the call are const. */

 static int cnt_const_args(ir_node *call)
 {
 static int cnt_const_args(ir_node *call)
 {

-  int  i, res = 0;
-  int  n = get_Call_n_params(call);
+       int i, res = 0;
+       int n = get_Call_n_params(call);

 
 

-  for (i = 0; i < n; ++i) {
-    ir_node *param = get_Call_param(call, i);
-    ir_op   *op = get_irn_op(param);
+       for (i = 0; i < n; ++i) {
+               ir_node *param = get_Call_param(call, i);
+               ir_op   *op = get_irn_op(param);

 
 

-    if (op == op_Const || op == op_SymConst)
-      ++res;
-  }
-  return res;
-}
+               if (op == op_Const || op == op_SymConst)
+                       ++res;
+       }  /* for */
+       return res;
+} /* cnt_const_args */

 
 /**
 
 /**

- * update info on calls
+ * Update info on calls.

  *
  * @param call   The call
  * @param graph  The graph entry containing the call
  */
 static void stat_update_call(ir_node *call, graph_entry_t *graph)
 {
  *
  * @param call   The call
  * @param graph  The graph entry containing the call
  */
 static void stat_update_call(ir_node *call, graph_entry_t *graph)
 {

-  ir_node  *block = get_nodes_block(call);
-  ir_node  *ptr = get_Call_ptr(call);
-  entity   *ent = NULL;
-  ir_graph *callee = NULL;
-  int      num_const_args;
-
-  /*
-   * If the block is bad, the whole subgraph will collapse later
-   * so do not count this call.
-   * This happens in dead code.
-   */
-  if (is_Bad(block))
-    return;
-
-  cnt_inc(&graph->cnt_all_calls);
-
-  /* found a call, this function is not a leaf */
-  graph->is_leaf = 0;
-
-  if (get_irn_op(ptr) == op_SymConst) {
-    if (get_SymConst_kind(ptr) == symconst_addr_ent) {
-      /* ok, we seems to know the entity */
-      ent = get_SymConst_entity(ptr);
-      callee = get_entity_irg(ent);
-
-      /* it is recursive, if it calls at least once */
-      if (callee == graph->irg)
-        graph->is_recursive = 1;
-    }
-  }
-  else {
-    /* indirect call, be could not predict */
-    cnt_inc(&graph->cnt_indirect_calls);
-
-    /* NOT a leaf call */
-    graph->is_leaf_call = LCS_NON_LEAF_CALL;
-  }
-
-  /* check, if it's a chain-call: Then, the call-block
-   * must dominate the end block. */
-  {
-    ir_node *curr = get_irg_end_block(graph->irg);
-    int depth = get_Block_dom_depth(block);
-
-    for (; curr != block && get_Block_dom_depth(curr) > depth;) {
-      curr = get_Block_idom(curr);
-
-      if (! curr || is_no_Block(curr))
-        break;
-    }
-
-    if (curr != block)
-      graph->is_chain_call = 0;
-  }
-
-  /* check, if the callee is a leaf */
-  if (callee) {
-    graph_entry_t *called = graph_get_entry(callee, status->irg_hash);
-
-    if (called->is_analyzed) {
-      if (! called->is_leaf)
-        graph->is_leaf_call = LCS_NON_LEAF_CALL;
-    }
-  }
-
-  /* check, if arguments of the call are const */
-  num_const_args = cnt_const_args(call);
-
-  if (num_const_args > 0)
-    cnt_inc(&graph->cnt_call_with_cnst_arg);
-}
+       ir_node  *block = get_nodes_block(call);
+       ir_node  *ptr = get_Call_ptr(call);
+       entity   *ent = NULL;
+       ir_graph *callee = NULL;
+       int      num_const_args;
+
+       /*
+        * If the block is bad, the whole subgraph will collapse later
+        * so do not count this call.
+        * This happens in dead code.
+        */
+       if (is_Bad(block))
+               return;
+
+       cnt_inc(&graph->cnt_all_calls);
+
+       /* found a call, this function is not a leaf */
+       graph->is_leaf = 0;
+
+       if (get_irn_op(ptr) == op_SymConst) {
+               if (get_SymConst_kind(ptr) == symconst_addr_ent) {
+                       /* ok, we seems to know the entity */
+                       ent = get_SymConst_entity(ptr);
+                       callee = get_entity_irg(ent);
+
+                       /* it is recursive, if it calls at least once */
+                       if (callee == graph->irg)
+                               graph->is_recursive = 1;
+               }  /* if */
+       } else {
+               /* indirect call, be could not predict */
+               cnt_inc(&graph->cnt_indirect_calls);
+
+               /* NOT a leaf call */
+               graph->is_leaf_call = LCS_NON_LEAF_CALL;
+       }  /* if */
+
+       /* check, if it's a chain-call: Then, the call-block
+       * must dominate the end block. */
+       {
+               ir_node *curr = get_irg_end_block(graph->irg);
+               int depth = get_Block_dom_depth(block);
+
+               for (; curr != block && get_Block_dom_depth(curr) > depth;) {
+                       curr = get_Block_idom(curr);
+
+                       if (! curr || is_no_Block(curr))
+                               break;
+               }  /* for */
+
+               if (curr != block)
+                       graph->is_chain_call = 0;
+       }
+
+       /* check, if the callee is a leaf */
+       if (callee) {
+               graph_entry_t *called = graph_get_entry(callee, status->irg_hash);
+
+               if (called->is_analyzed) {
+                       if (! called->is_leaf)
+                               graph->is_leaf_call = LCS_NON_LEAF_CALL;
+               }  /* if */
+       }  /* if */
+
+       /* check, if arguments of the call are const */
+       num_const_args = cnt_const_args(call);
+
+       if (num_const_args > 0)
+               cnt_inc(&graph->cnt_call_with_cnst_arg);
+} /* stat_update_call */

 
 /**
 
 /**

- * update info on calls for graphs on the wait queue
+ * Update info on calls for graphs on the wait queue.

  */
 static void stat_update_call_2(ir_node *call, graph_entry_t *graph)
 {
  */
 static void stat_update_call_2(ir_node *call, graph_entry_t *graph)
 {

-  ir_node  *block = get_nodes_block(call);
-  ir_node  *ptr = get_Call_ptr(call);
-  entity   *ent = NULL;
-  ir_graph *callee = NULL;
-
-  /*
-   * If the block is bad, the whole subgraph will collapse later
-   * so do not count this call.
-   * This happens in dead code.
-   */
-  if (is_Bad(block))
-    return;
-
-  if (get_irn_op(ptr) == op_SymConst) {
-    if (get_SymConst_kind(ptr) == symconst_addr_ent) {
-      /* ok, we seems to know the entity */
-      ent = get_SymConst_entity(ptr);
-      callee = get_entity_irg(ent);
-    }
-  }
-
-  /* check, if the callee is a leaf */
-  if (callee) {
-    graph_entry_t *called = graph_get_entry(callee, status->irg_hash);
-
-    assert(called->is_analyzed);
-
-    if (! called->is_leaf)
-      graph->is_leaf_call = LCS_NON_LEAF_CALL;
-  }
-  else
-    graph->is_leaf_call = LCS_NON_LEAF_CALL;
-}
+       ir_node  *block = get_nodes_block(call);
+       ir_node  *ptr = get_Call_ptr(call);
+       entity   *ent = NULL;
+       ir_graph *callee = NULL;
+
+       /*
+        * If the block is bad, the whole subgraph will collapse later
+        * so do not count this call.
+        * This happens in dead code.
+        */
+       if (is_Bad(block))
+               return;
+
+       if (get_irn_op(ptr) == op_SymConst) {
+               if (get_SymConst_kind(ptr) == symconst_addr_ent) {
+                       /* ok, we seems to know the entity */
+                       ent = get_SymConst_entity(ptr);
+                       callee = get_entity_irg(ent);
+               }  /* if */
+       }  /* if */
+
+       /* check, if the callee is a leaf */
+       if (callee) {
+               graph_entry_t *called = graph_get_entry(callee, status->irg_hash);
+
+               assert(called->is_analyzed);
+
+               if (! called->is_leaf)
+                       graph->is_leaf_call = LCS_NON_LEAF_CALL;
+       } else
+               graph->is_leaf_call = LCS_NON_LEAF_CALL;
+} /* stat_update_call_2 */

 
 /**
 
 /**

- * walker for reachable nodes count
+ * Walker for reachable nodes count.

  */
 static void update_node_stat(ir_node *node, void *env)
 {
  */
 static void update_node_stat(ir_node *node, void *env)
 {

-  graph_entry_t *graph = env;
-  node_entry_t *entry;
+       graph_entry_t *graph = env;
+       node_entry_t *entry;

 
 

-  ir_op *op = stat_get_irn_op(node);
-  int arity = get_irn_arity(node);
+       ir_op *op = stat_get_irn_op(node);
+       int arity = get_irn_arity(node);

 
 

-  entry = opcode_get_entry(op, graph->opcode_hash);
+       entry = opcode_get_entry(op, graph->opcode_hash);

 
 

-  cnt_inc(&entry->cnt_alive);
-  cnt_add_i(&graph->cnt_edges, arity);
+       cnt_inc(&entry->cnt_alive);
+       cnt_add_i(&graph->cnt_edges, arity);

 
 

-  /* count block edges */
-  undate_block_info(node, graph);
+       /* count block edges */
+       undate_block_info(node, graph);

 
 

-  /* count extended block edges */
-  if (status->stat_options & FIRMSTAT_COUNT_EXTBB) {
-    if (graph->irg != get_const_code_irg())
-      undate_extbb_info(node, graph);
-  }
+       /* count extended block edges */
+       if (status->stat_options & FIRMSTAT_COUNT_EXTBB) {
+               if (graph->irg != get_const_code_irg())
+                       update_extbb_info(node, graph);
+       }  /* if */

 
 

-  /* handle statistics for special node types */
+       /* handle statistics for special node types */

 
 

-  if (op == op_Const) {
-    if (status->stat_options & FIRMSTAT_COUNT_CONSTS) {
-      /* check properties of constants */
-      stat_update_const(status, node, graph);
-    }
-  }
-  else if (op == op_Call) {
-    /* check for properties that depends on calls like recursion/leaf/indirect call */
-    stat_update_call(node, graph);
-  }
-}
+       if (op == op_Const) {
+               if (status->stat_options & FIRMSTAT_COUNT_CONSTS) {
+                       /* check properties of constants */
+                       stat_update_const(status, node, graph);
+               }  /* if */
+       } else if (op == op_Call) {
+               /* check for properties that depends on calls like recursion/leaf/indirect call */
+               stat_update_call(node, graph);
+       }  /* if */
+} /* update_node_stat */

 
 /**
 
 /**

- * walker for reachable nodes count for graphs on the wait_q
+ * Walker for reachable nodes count for graphs on the wait_q.

  */
 static void update_node_stat_2(ir_node *node, void *env)
 {
  */
 static void update_node_stat_2(ir_node *node, void *env)
 {

-  graph_entry_t *graph = env;
+       graph_entry_t *graph = env;

 
 

-  /* check for properties that depends on calls like recursion/leaf/indirect call */
-  if (is_Call(node))
-    stat_update_call_2(node, graph);
-}
+       /* check for properties that depends on calls like recursion/leaf/indirect call */
+       if (is_Call(node))
+               stat_update_call_2(node, graph);
+} /* update_node_stat_2 */

 
 /**
 
 /**

- * get the current address mark
+ * Get the current address mark.

  */
 static unsigned get_adr_mark(graph_entry_t *graph, ir_node *node)
 {
  */
 static unsigned get_adr_mark(graph_entry_t *graph, ir_node *node)
 {

-  address_mark_entry_t *value = set_find(graph->address_mark, &node, sizeof(*value), HASH_PTR(node));
+       address_mark_entry_t *value = set_find(graph->address_mark, &node, sizeof(*value), HASH_PTR(node));

 
 

-  return value ? value->mark : 0;
-}
+       return value ? value->mark : 0;
+} /* get_adr_mark */

 
 /**
 
 /**

- * set the current address mark
+ * Set the current address mark.

  */
 static void set_adr_mark(graph_entry_t *graph, ir_node *node, unsigned val)
 {
  */
 static void set_adr_mark(graph_entry_t *graph, ir_node *node, unsigned val)
 {

-  address_mark_entry_t *value = set_insert(graph->address_mark, &node, sizeof(*value), HASH_PTR(node));
+       address_mark_entry_t *value = set_insert(graph->address_mark, &node, sizeof(*value), HASH_PTR(node));

 
 

-  value->mark = val;
-}
+       value->mark = val;
+} /* set_adr_mark */

 
 #if 0
 /**
 
 #if 0
 /**


@@ -921,23 +911,23 @@ static void set_adr_mark(graph_entry_t *graph, ir_node *node, unsigned val)
  */
 static int stat_adr_mark_hook(FILE *F, ir_node *node, ir_node *local)
 {
  */
 static int stat_adr_mark_hook(FILE *F, ir_node *node, ir_node *local)
 {

-  ir_node *n           = local ? local : node;
-  ir_graph *irg        = get_irn_irg(n);
-  graph_entry_t *graph = graph_get_entry(irg, status->irg_hash);
-  unsigned mark        = get_adr_mark(graph, n);
-
-  if (mark & MARK_ADDRESS_CALC)
-    fprintf(F, "color: purple");
-  else if ((mark & (MARK_REF_ADR | MARK_REF_NON_ADR)) == MARK_REF_ADR)
-    fprintf(F, "color: pink");
-  else if ((mark & (MARK_REF_ADR | MARK_REF_NON_ADR)) == (MARK_REF_ADR|MARK_REF_NON_ADR))
-    fprintf(F, "color: lightblue");
-  else
-    return 0;
-
-  /* I know the color! */
-  return 1;
-}
+       ir_node *n           = local ? local : node;
+       ir_graph *irg        = get_irn_irg(n);
+       graph_entry_t *graph = graph_get_entry(irg, status->irg_hash);
+       unsigned mark        = get_adr_mark(graph, n);
+
+       if (mark & MARK_ADDRESS_CALC)
+               fprintf(F, "color: purple");
+       else if ((mark & (MARK_REF_ADR | MARK_REF_NON_ADR)) == MARK_REF_ADR)
+               fprintf(F, "color: pink");
+       else if ((mark & (MARK_REF_ADR | MARK_REF_NON_ADR)) == (MARK_REF_ADR|MARK_REF_NON_ADR))
+               fprintf(F, "color: lightblue");
+       else
+               return 0;
+
+       /* I know the color! */
+       return 1;
+} /* stat_adr_mark_hook */

 #endif
 
 /**
 #endif
 
 /**


@@ -949,39 +939,38 @@ static int stat_adr_mark_hook(FILE *F, ir_node *node, ir_node *local)
  */
 static void mark_address_calc(ir_node *node, void *env)
 {
  */
 static void mark_address_calc(ir_node *node, void *env)
 {

-  graph_entry_t *graph = env;
-  ir_mode *mode = get_irn_mode(node);
-  int i, n;
-  unsigned mark_preds = MARK_REF_NON_ADR;
-
-  if (! mode_is_numP(mode))
-    return;
-
-  if (mode_is_reference(mode)) {
-    /* a reference is calculated here, we are sure */
-    set_adr_mark(graph, node, MARK_ADDRESS_CALC);
-
-    mark_preds = MARK_REF_ADR;
-  }
-  else {
-    unsigned mark = get_adr_mark(graph, node);
-
-    if ((mark & (MARK_REF_ADR | MARK_REF_NON_ADR)) == MARK_REF_ADR) {
-      /*
-       * this node has not an reference mode, but is only
-       * referenced by address calculations
-       */
-      mark_preds = MARK_REF_ADR;
-    }
-  }
-
-  /* mark all predecessors */
-  for (i = 0, n = get_irn_arity(node); i < n; ++i) {
-    ir_node *pred = get_irn_n(node, i);
-
-    set_adr_mark(graph, pred, get_adr_mark(graph, pred) | mark_preds);
-  }
-}
+       graph_entry_t *graph = env;
+       ir_mode *mode = get_irn_mode(node);
+       int i, n;
+       unsigned mark_preds = MARK_REF_NON_ADR;
+
+       if (! mode_is_numP(mode))
+               return;
+
+       if (mode_is_reference(mode)) {
+               /* a reference is calculated here, we are sure */
+               set_adr_mark(graph, node, MARK_ADDRESS_CALC);
+
+               mark_preds = MARK_REF_ADR;
+       } else {
+               unsigned mark = get_adr_mark(graph, node);
+
+               if ((mark & (MARK_REF_ADR | MARK_REF_NON_ADR)) == MARK_REF_ADR) {
+               /*
+               * this node has not an reference mode, but is only
+               * referenced by address calculations
+                       */
+                       mark_preds = MARK_REF_ADR;
+               }  /* if */
+       }  /* if */
+
+       /* mark all predecessors */
+       for (i = 0, n = get_irn_arity(node); i < n; ++i) {
+               ir_node *pred = get_irn_n(node, i);
+
+               set_adr_mark(graph, pred, get_adr_mark(graph, pred) | mark_preds);
+       }  /* for */
+} /* mark_address_calc */

 
 /**
  * Called for every graph when the graph is either deleted or stat_dump_snapshot()
 
 /**
  * Called for every graph when the graph is either deleted or stat_dump_snapshot()


@@ -992,156 +981,157 @@ static void mark_address_calc(ir_node *node, void *env)
  */
 static void update_graph_stat(graph_entry_t *global, graph_entry_t *graph)
 {
  */
 static void update_graph_stat(graph_entry_t *global, graph_entry_t *graph)
 {

-  node_entry_t *entry;
+       node_entry_t *entry;

 
 

-  /* clear first the alive counter in the graph */
-  for (entry = pset_first(graph->opcode_hash); entry; entry = pset_next(graph->opcode_hash)) {
-    cnt_clr(&entry->cnt_alive);
-  }
+       /* clear first the alive counter in the graph */
+       for (entry = pset_first(graph->opcode_hash); entry; entry = pset_next(graph->opcode_hash)) {
+               cnt_clr(&entry->cnt_alive);
+       }  /* for */

 
 

-  /* set pessimistic values */
-  graph->is_leaf       = 1;
-  graph->is_leaf_call  = LCS_UNKNOWN;
-  graph->is_recursive  = 0;
-  graph->is_chain_call = 1;
+       /* set pessimistic values */
+       graph->is_leaf       = 1;
+       graph->is_leaf_call  = LCS_UNKNOWN;
+       graph->is_recursive  = 0;
+       graph->is_chain_call = 1;

 
 

-  /* create new block counter */
-  graph->block_hash = new_pset(block_cmp, 5);
+       /* create new block counter */
+       graph->block_hash = new_pset(block_cmp, 5);

 
 

-  /* we need dominator info */
-  if (graph->irg != get_const_code_irg()) {
-    assure_doms(graph->irg);
+       /* we need dominator info */
+       if (graph->irg != get_const_code_irg()) {
+               assure_doms(graph->irg);

 
 

-    if (status->stat_options & FIRMSTAT_COUNT_EXTBB) {
-      /* we need extended basic blocks */
-      compute_extbb(graph->irg);
+               if (status->stat_options & FIRMSTAT_COUNT_EXTBB) {
+                       /* we need extended basic blocks */
+                       compute_extbb(graph->irg);

 
 

-      /* create new extbb counter */
-      graph->extbb_hash = new_pset(block_cmp, 5);
-    }
-  }
+                       /* create new extbb counter */
+                       graph->extbb_hash = new_pset(block_cmp, 5);
+               }  /* if */
+       }  /* if */

 
 

-  /* count the nodes in the graph */
-  irg_walk_graph(graph->irg, update_node_stat, NULL, graph);
+       /* count the nodes in the graph */
+       irg_walk_graph(graph->irg, update_node_stat, NULL, graph);

 
 #if 0
 
 #if 0

-  /* Uncomment this code if chain-call means call exact one */
-  entry = opcode_get_entry(op_Call, graph->opcode_hash);
+       /* Uncomment this code if chain-call means call exact one */
+       entry = opcode_get_entry(op_Call, graph->opcode_hash);

 
 

-  /* check if we have more than 1 call */
-  if (cnt_gt(entry->cnt_alive, 1))
-    graph->is_chain_call = 0;
+       /* check if we have more than 1 call */
+       if (cnt_gt(entry->cnt_alive, 1))
+               graph->is_chain_call = 0;

 #endif
 
 #endif
 

-  /* recursive functions are never chain calls, leafs don't have calls */
-  if (graph->is_recursive || graph->is_leaf)
-    graph->is_chain_call = 0;
+       /* recursive functions are never chain calls, leafs don't have calls */
+       if (graph->is_recursive || graph->is_leaf)
+               graph->is_chain_call = 0;

 
 

-  /* assume we walk every graph only ONCE, we could sum here the global count */
-  for (entry = pset_first(graph->opcode_hash); entry; entry = pset_next(graph->opcode_hash)) {
-    node_entry_t *g_entry = opcode_get_entry(entry->op, global->opcode_hash);
+       /* assume we walk every graph only ONCE, we could sum here the global count */
+       for (entry = pset_first(graph->opcode_hash); entry; entry = pset_next(graph->opcode_hash)) {
+               node_entry_t *g_entry = opcode_get_entry(entry->op, global->opcode_hash);

 
 

-    /* update the node counter */
-    cnt_add(&g_entry->cnt_alive, &entry->cnt_alive);
-  }
+               /* update the node counter */
+               cnt_add(&g_entry->cnt_alive, &entry->cnt_alive);
+       }  /* for */

 
 

-  /* update the edge counter */
-  cnt_add(&global->cnt_edges, &graph->cnt_edges);
+       /* update the edge counter */
+       cnt_add(&global->cnt_edges, &graph->cnt_edges);

 
 

-  /* count the number of address calculation */
-  if (graph->irg != get_const_code_irg()) {
-    ir_graph *rem = current_ir_graph;
+       /* count the number of address calculation */
+       if (graph->irg != get_const_code_irg()) {
+               ir_graph *rem = current_ir_graph;

 
 

-    if (get_irg_outs_state(graph->irg) != outs_consistent)
-      compute_irg_outs(graph->irg);
+               if (get_irg_outs_state(graph->irg) != outs_consistent)
+                       compute_irg_outs(graph->irg);

 
 

-    /* Must be done an the outs graph */
-    current_ir_graph = graph->irg;
-    irg_out_walk(get_irg_start(graph->irg), NULL, mark_address_calc, graph);
-    current_ir_graph = rem;
+               /* Must be done an the outs graph */
+               current_ir_graph = graph->irg;
+               irg_out_walk(get_irg_start(graph->irg), NULL, mark_address_calc, graph);
+               current_ir_graph = rem;

 
 #if 0
 
 #if 0

-    set_dump_node_vcgattr_hook(stat_adr_mark_hook);
-    dump_ir_block_graph(graph->irg, "-adr");
-    set_dump_node_vcgattr_hook(NULL);
+               /* register the vcg hook and dump the graph for test */
+               set_dump_node_vcgattr_hook(stat_adr_mark_hook);
+               dump_ir_block_graph(graph->irg, "-adr");
+               set_dump_node_vcgattr_hook(NULL);

 #endif
 #endif

-  }
+       }  /* if */

 
 

-  /* count the DAG's */
-  if (status->stat_options & FIRMSTAT_COUNT_DAG)
-    count_dags_in_graph(global, graph);
+       /* count the DAG's */
+       if (status->stat_options & FIRMSTAT_COUNT_DAG)
+               count_dags_in_graph(global, graph);

 
 

-  /* calculate the patterns of this graph */
-  stat_calc_pattern_history(graph->irg);
+       /* calculate the patterns of this graph */
+       stat_calc_pattern_history(graph->irg);

 
 

-  /* leaf function did not call others */
-  if (graph->is_leaf)
-    graph->is_leaf_call = LCS_NON_LEAF_CALL;
-  else if (graph->is_leaf_call == LCS_UNKNOWN) {
-    /* we still don't know if this graph calls leaf-functions, so enqueue */
-    pdeq_putl(status->wait_q, graph);
-  }
+       /* leaf function did not call others */
+       if (graph->is_leaf)
+               graph->is_leaf_call = LCS_NON_LEAF_CALL;
+       else if (graph->is_leaf_call == LCS_UNKNOWN) {
+               /* we still don't know if this graph calls leaf-functions, so enqueue */
+               pdeq_putl(status->wait_q, graph);
+       }  /* if */

 
 

-  /* we have analyzed this graph */
-  graph->is_analyzed = 1;
-}
+       /* we have analyzed this graph */
+       graph->is_analyzed = 1;
+} /* update_graph_stat */

 
 /**
  * Called for every graph that was on the wait_q in stat_dump_snapshot()
 
 /**
  * Called for every graph that was on the wait_q in stat_dump_snapshot()

- *  must finish all statistic info calculations.
+ * must finish all statistic info calculations.

  *
  * @param global    The global entry
  * @param graph     The current entry
  */
 static void update_graph_stat_2(graph_entry_t *global, graph_entry_t *graph)
 {
  *
  * @param global    The global entry
  * @param graph     The current entry
  */
 static void update_graph_stat_2(graph_entry_t *global, graph_entry_t *graph)
 {

-  if (graph->is_deleted) {
-    /* deleted, ignore */
-    return;
-  }
+       if (graph->is_deleted) {
+               /* deleted, ignore */
+               return;
+       }

 
 

-  if (graph->irg) {
-    /* count the nodes in the graph */
-    irg_walk_graph(graph->irg, update_node_stat_2, NULL, graph);
+       if (graph->irg) {
+               /* count the nodes in the graph */
+               irg_walk_graph(graph->irg, update_node_stat_2, NULL, graph);

 
 

-    if (graph->is_leaf_call == LCS_UNKNOWN)
-      graph->is_leaf_call = LCS_LEAF_CALL;
-  }
-}
+               if (graph->is_leaf_call == LCS_UNKNOWN)
+                       graph->is_leaf_call = LCS_LEAF_CALL;
+       }  /* if */
+} /* update_graph_stat_2 */

 
 /**
 
 /**

- * register a dumper
+ * Register a dumper.

  */
 static void stat_register_dumper(const dumper_t *dumper)
 {
  */
 static void stat_register_dumper(const dumper_t *dumper)
 {

-  dumper_t *p = xmalloc(sizeof(*p));
+       dumper_t *p = xmalloc(sizeof(*p));

 
 

-  if (p) {
-    memcpy(p, dumper, sizeof(*p));
+       if (p) {
+               memcpy(p, dumper, sizeof(*p));

 
 

-    p->next        = status->dumper;
-    p->status      = status;
-    status->dumper = p;
-  }
+               p->next        = status->dumper;
+               p->status      = status;
+               status->dumper = p;
+       }

 
 

-  /* FIXME: memory leak */
-}
+       /* FIXME: memory leak */
+} /* stat_register_dumper */

 
 /**
 
 /**

- * dumps an IR graph.
+ * Dumps the statistics of an IR graph.

  */
 static void stat_dump_graph(graph_entry_t *entry)
 {
  */
 static void stat_dump_graph(graph_entry_t *entry)
 {

-  dumper_t *dumper;
+       dumper_t *dumper;

 
 

-  for (dumper = status->dumper; dumper; dumper = dumper->next) {
-    if (dumper->dump_graph)
-      dumper->dump_graph(dumper, entry);
-  }
-}
+       for (dumper = status->dumper; dumper; dumper = dumper->next) {
+               if (dumper->dump_graph)
+                       dumper->dump_graph(dumper, entry);
+       }  /* for */
+} /* stat_dump_graph */

 
 /**
 
 /**

- * calls all registered functions.
+ * Calls all registered dumper functions.

  */
 static void stat_dump_registered(graph_entry_t *entry)
 {
  */
 static void stat_dump_registered(graph_entry_t *entry)
 {


@@ -1153,114 +1143,114 @@ static void stat_dump_registered(graph_entry_t *entry)
 
                        foreach_pset(dumper->func_map, func)
                                func(dumper, entry);
 
                        foreach_pset(dumper->func_map, func)
                                func(dumper, entry);

-               }
-       }
-}
+               }  /* if */
+       }  /* for */
+} /* stat_dump_registered */

 
 /**
 
 /**

- * dumps a constant table
+ * Dumps a constant table.

  */
 static void stat_dump_consts(const constant_info_t *tbl)
 {
  */
 static void stat_dump_consts(const constant_info_t *tbl)
 {

-  dumper_t *dumper;
+       dumper_t *dumper;

 
 

-  for (dumper = status->dumper; dumper; dumper = dumper->next) {
-    if (dumper->dump_const_tbl)
-      dumper->dump_const_tbl(dumper, tbl);
-  }
-}
+       for (dumper = status->dumper; dumper; dumper = dumper->next) {
+               if (dumper->dump_const_tbl)
+                       dumper->dump_const_tbl(dumper, tbl);
+       }  /* for */
+} /* stat_dump_consts */

 
 /**
 
 /**

- * initialize the dumper
+ * Initialize the dumper.

  */
 static void stat_dump_init(const char *name)
 {
  */
 static void stat_dump_init(const char *name)
 {

-  dumper_t *dumper;
+       dumper_t *dumper;

 
 

-  for (dumper = status->dumper; dumper; dumper = dumper->next) {
-    if (dumper->init)
-      dumper->init(dumper, name);
-  }
-}
+       for (dumper = status->dumper; dumper; dumper = dumper->next) {
+               if (dumper->init)
+                       dumper->init(dumper, name);
+       }  /* for */
+} /* stat_dump_init */

 
 /**
 
 /**

- * finish the dumper
+ * Finish the dumper.

  */
 static void stat_dump_finish(void)
 {
  */
 static void stat_dump_finish(void)
 {

-  dumper_t *dumper;
+       dumper_t *dumper;

 
 

-  for (dumper = status->dumper; dumper; dumper = dumper->next) {
-    if (dumper->finish)
-      dumper->finish(dumper);
-  }
-}
+       for (dumper = status->dumper; dumper; dumper = dumper->next) {
+               if (dumper->finish)
+                       dumper->finish(dumper);
+       }  /* for */
+} /* stat_dump_finish */

 
 /**
 
 /**

- * register an additional function for all dumper
+ * Register an additional function for all dumper.

  */
 void stat_register_dumper_func(dump_graph_FUNC func) {
  */
 void stat_register_dumper_func(dump_graph_FUNC func) {

-  dumper_t *dumper;
+       dumper_t *dumper;

 
 

-  for (dumper = status->dumper; dumper; dumper = dumper->next) {
-    if (! dumper->func_map)
-      dumper->func_map = pset_new_ptr(3);
-    pset_insert_ptr(dumper->func_map, func);
-  }
-}
+       for (dumper = status->dumper; dumper; dumper = dumper->next) {
+               if (! dumper->func_map)
+                       dumper->func_map = pset_new_ptr(3);
+               pset_insert_ptr(dumper->func_map, func);
+       }  /* for */
+} /* stat_register_dumper_func */

 
 /* ---------------------------------------------------------------------- */
 
 /*
 
 /* ---------------------------------------------------------------------- */
 
 /*

- * helper: get an ir_op from an opcode
+ * Helper: get an ir_op from an opcode.

  */
 ir_op *stat_get_op_from_opcode(opcode code)
 {
  */
 ir_op *stat_get_op_from_opcode(opcode code)
 {

-  return opcode_find_entry(code, status->ir_op_hash);
-}
+       return opcode_find_entry(code, status->ir_op_hash);
+} /* stat_get_op_from_opcode */

 
 /**
 
 /**

- * A new IR op is registered.
+ * Hook: A new IR op is registered.

  *
  * @param ctx  the hook context
  * @param op   the new IR opcode that was created.
  */
 static void stat_new_ir_op(void *ctx, ir_op *op)
 {
  *
  * @param ctx  the hook context
  * @param op   the new IR opcode that was created.
  */
 static void stat_new_ir_op(void *ctx, ir_op *op)
 {

-  if (! status->stat_options)
-    return;
+       if (! status->stat_options)
+               return;

 
 

-  STAT_ENTER;
-  {
-    graph_entry_t *graph = graph_get_entry(NULL, status->irg_hash);
+       STAT_ENTER;
+       {
+               graph_entry_t *graph = graph_get_entry(NULL, status->irg_hash);

 
 

-    /* execute for side effect :-) */
-    opcode_get_entry(op, graph->opcode_hash);
+               /* execute for side effect :-) */
+               (void)opcode_get_entry(op, graph->opcode_hash);

 
 

-    pset_insert(status->ir_op_hash, op, op->code);
-  }
-  STAT_LEAVE;
-}
+               pset_insert(status->ir_op_hash, op, op->code);
+       }
+       STAT_LEAVE;
+} /* stat_new_ir_op */

 
 /**
 
 /**

- * An IR op is freed.
+ * Hook: An IR op is freed.

  *
  * @param ctx  the hook context
  * @param op   the IR opcode that is freed
  */
 static void stat_free_ir_op(void *ctx, ir_op *op)
 {
  *
  * @param ctx  the hook context
  * @param op   the IR opcode that is freed
  */
 static void stat_free_ir_op(void *ctx, ir_op *op)
 {

-  if (! status->stat_options)
-    return;
+       if (! status->stat_options)
+               return;

 
 

-  STAT_ENTER;
-  {
-  }
-  STAT_LEAVE;
-}
+       STAT_ENTER;
+       {
+       }
+       STAT_LEAVE;
+} /* stat_free_ir_op */

 
 /**
 
 /**

- * A new node is created.
+ * Hook: A new node is created.

  *
  * @param ctx   the hook context
  * @param irg   the IR graph on which the node is created
  *
  * @param ctx   the hook context
  * @param irg   the IR graph on which the node is created


@@ -1268,64 +1258,64 @@ static void stat_free_ir_op(void *ctx, ir_op *op)
  */
 static void stat_new_node(void *ctx, ir_graph *irg, ir_node *node)
 {
  */
 static void stat_new_node(void *ctx, ir_graph *irg, ir_node *node)
 {

-  if (! status->stat_options)
-    return;
-
-  /* do NOT count during dead node elimination */
-  if (status->in_dead_node_elim > 0)
-    return;
-
-  STAT_ENTER;
-  {
-    node_entry_t *entry;
-    graph_entry_t *graph;
-    ir_op *op = stat_get_irn_op(node);
-
-    /* increase global value */
-    graph = graph_get_entry(NULL, status->irg_hash);
-    entry = opcode_get_entry(op, graph->opcode_hash);
-    cnt_inc(&entry->new_node);
-
-    /* increase local value */
-    graph = graph_get_entry(current_ir_graph, status->irg_hash);
-    entry = opcode_get_entry(op, graph->opcode_hash);
-    cnt_inc(&entry->new_node);
-  }
-  STAT_LEAVE;
-}
+       if (! status->stat_options)
+               return;
+
+       /* do NOT count during dead node elimination */
+       if (status->in_dead_node_elim > 0)
+               return;
+
+       STAT_ENTER;
+       {
+               node_entry_t *entry;
+               graph_entry_t *graph;
+               ir_op *op = stat_get_irn_op(node);
+
+               /* increase global value */
+               graph = graph_get_entry(NULL, status->irg_hash);
+               entry = opcode_get_entry(op, graph->opcode_hash);
+               cnt_inc(&entry->new_node);
+
+               /* increase local value */
+               graph = graph_get_entry(current_ir_graph, status->irg_hash);
+               entry = opcode_get_entry(op, graph->opcode_hash);
+               cnt_inc(&entry->new_node);
+       }
+       STAT_LEAVE;
+} /* stat_new_node */

 
 /**
 
 /**

- * A node is changed into a Id node
+ * Hook: A node is changed into a Id node

  *
  * @param ctx   the hook context
  * @param node  the IR node that will be turned into an ID
  */
 static void stat_turn_into_id(void *ctx, ir_node *node)
 {
  *
  * @param ctx   the hook context
  * @param node  the IR node that will be turned into an ID
  */
 static void stat_turn_into_id(void *ctx, ir_node *node)
 {

-  if (! status->stat_options)
-    return;
-
-  STAT_ENTER;
-  {
-    node_entry_t *entry;
-    graph_entry_t *graph;
-    ir_op *op = stat_get_irn_op(node);
-
-    /* increase global value */
-    graph = graph_get_entry(NULL, status->irg_hash);
-    entry = opcode_get_entry(op, graph->opcode_hash);
-    cnt_inc(&entry->into_Id);
-
-    /* increase local value */
-    graph = graph_get_entry(current_ir_graph, status->irg_hash);
-    entry = opcode_get_entry(op, graph->opcode_hash);
-    cnt_inc(&entry->into_Id);
-  }
-  STAT_LEAVE;
-}
+       if (! status->stat_options)
+               return;
+
+       STAT_ENTER;
+       {
+               node_entry_t *entry;
+               graph_entry_t *graph;
+               ir_op *op = stat_get_irn_op(node);
+
+               /* increase global value */
+               graph = graph_get_entry(NULL, status->irg_hash);
+               entry = opcode_get_entry(op, graph->opcode_hash);
+               cnt_inc(&entry->into_Id);
+
+               /* increase local value */
+               graph = graph_get_entry(current_ir_graph, status->irg_hash);
+               entry = opcode_get_entry(op, graph->opcode_hash);
+               cnt_inc(&entry->into_Id);
+       }
+       STAT_LEAVE;
+} /* stat_turn_into_id */

 
 /**
 
 /**

- * A new graph was created
+ * Hook: A new graph was created

  *
  * @param ctx  the hook context
  * @param irg  the new IR graph that was created
  *
  * @param ctx  the hook context
  * @param irg  the new IR graph that was created


@@ -1333,27 +1323,27 @@ static void stat_turn_into_id(void *ctx, ir_node *node)
  */
 static void stat_new_graph(void *ctx, ir_graph *irg, entity *ent)
 {
  */
 static void stat_new_graph(void *ctx, ir_graph *irg, entity *ent)
 {

-  if (! status->stat_options)
-    return;
-
-  STAT_ENTER;
-  {
-    /* execute for side effect :-) */
-    graph_entry_t * graph = graph_get_entry(irg, status->irg_hash);
-
-    graph->ent           = ent;
-    graph->is_deleted    = 0;
-    graph->is_leaf       = 0;
-    graph->is_leaf_call  = 0;
-    graph->is_recursive  = 0;
-    graph->is_chain_call = 0;
-    graph->is_analyzed   = 0;
-  }
-  STAT_LEAVE;
-}
+       if (! status->stat_options)
+               return;
+
+       STAT_ENTER;
+       {
+               /* execute for side effect :-) */
+               graph_entry_t * graph = graph_get_entry(irg, status->irg_hash);
+
+               graph->ent           = ent;
+               graph->is_deleted    = 0;
+               graph->is_leaf       = 0;
+               graph->is_leaf_call  = 0;
+               graph->is_recursive  = 0;
+               graph->is_chain_call = 0;
+               graph->is_analyzed   = 0;
+       }
+       STAT_LEAVE;
+} /* stat_new_graph */

 
 /**
 
 /**

- * A graph will be deleted
+ * Hook: A graph will be deleted

  *
  * @param ctx  the hook context
  * @param irg  the IR graph that will be deleted
  *
  * @param ctx  the hook context
  * @param irg  the IR graph that will be deleted


@@ -1364,26 +1354,26 @@ static void stat_new_graph(void *ctx, ir_graph *irg, entity *ent)
  */
 static void stat_free_graph(void *ctx, ir_graph *irg)
 {
  */
 static void stat_free_graph(void *ctx, ir_graph *irg)
 {

-  if (! status->stat_options)
-    return;
+       if (! status->stat_options)
+               return;

 
 

-  STAT_ENTER;
-  {
-    graph_entry_t *graph  = graph_get_entry(irg, status->irg_hash);
-    graph_entry_t *global = graph_get_entry(NULL, status->irg_hash);
+       STAT_ENTER;
+       {
+               graph_entry_t *graph  = graph_get_entry(irg, status->irg_hash);
+               graph_entry_t *global = graph_get_entry(NULL, status->irg_hash);

 
 

-    graph->is_deleted = 1;
+               graph->is_deleted = 1;

 
 

-    if (status->stat_options & FIRMSTAT_COUNT_DELETED) {
-      /* count the nodes of the graph yet, it will be destroyed later */
-      update_graph_stat(global, graph);
-    }
-  }
-  STAT_LEAVE;
-}
+               if (status->stat_options & FIRMSTAT_COUNT_DELETED) {
+                       /* count the nodes of the graph yet, it will be destroyed later */
+                       update_graph_stat(global, graph);
+               }  /* if */
+       }
+       STAT_LEAVE;
+} /* stat_free_graph */

 
 /**
 
 /**

- * A walk over a graph is initiated. Do not count walks from statistic code.
+ * Hook: A walk over a graph is initiated. Do not count walks from statistic code.

  *
  * @param ctx  the hook context
  * @param irg  the IR graph that will be walked
  *
  * @param ctx  the hook context
  * @param irg  the IR graph that will be walked


@@ -1392,20 +1382,20 @@ static void stat_free_graph(void *ctx, ir_graph *irg)
  */
 static void stat_irg_walk(void *ctx, ir_graph *irg, generic_func *pre, generic_func *post)
 {
  */
 static void stat_irg_walk(void *ctx, ir_graph *irg, generic_func *pre, generic_func *post)
 {

-  if (! status->stat_options)
-    return;
+       if (! status->stat_options)
+               return;

 
 

-  STAT_ENTER_SINGLE;
-  {
-    graph_entry_t *graph = graph_get_entry(irg, status->irg_hash);
+       STAT_ENTER_SINGLE;
+       {
+               graph_entry_t *graph = graph_get_entry(irg, status->irg_hash);

 
 

-    cnt_inc(&graph->cnt_walked);
-  }
-  STAT_LEAVE;
-}
+               cnt_inc(&graph->cnt_walked);
+       }
+       STAT_LEAVE;
+} /* stat_irg_walk */

 
 /**
 
 /**

- * A walk over a graph in block-wise order is initiated. Do not count walks from statistic code.
+ * Hook: A walk over a graph in block-wise order is initiated. Do not count walks from statistic code.

  *
  * @param ctx  the hook context
  * @param irg  the IR graph that will be walked
  *
  * @param ctx  the hook context
  * @param irg  the IR graph that will be walked


@@ -1414,12 +1404,12 @@ static void stat_irg_walk(void *ctx, ir_graph *irg, generic_func *pre, generic_f
  */
 static void stat_irg_walk_blkwise(void *ctx, ir_graph *irg, generic_func *pre, generic_func *post)
 {
  */
 static void stat_irg_walk_blkwise(void *ctx, ir_graph *irg, generic_func *pre, generic_func *post)
 {

-  /* for now, do NOT differentiate between blockwise and normal */
-  stat_irg_walk(ctx, irg, pre, post);
-}
+       /* for now, do NOT differentiate between blockwise and normal */
+       stat_irg_walk(ctx, irg, pre, post);
+} /* stat_irg_walk_blkwise */

 
 /**
 
 /**

- * A walk over the graph's blocks is initiated. Do not count walks from statistic code.
+ * Hook: A walk over the graph's blocks is initiated. Do not count walks from statistic code.

  *
  * @param ctx  the hook context
  * @param irg  the IR graph that will be walked
  *
  * @param ctx  the hook context
  * @param irg  the IR graph that will be walked


@@ -1429,35 +1419,35 @@ static void stat_irg_walk_blkwise(void *ctx, ir_graph *irg, generic_func *pre, g
  */
 static void stat_irg_block_walk(void *ctx, ir_graph *irg, ir_node *node, generic_func *pre, generic_func *post)
 {
  */
 static void stat_irg_block_walk(void *ctx, ir_graph *irg, ir_node *node, generic_func *pre, generic_func *post)
 {

-  if (! status->stat_options)
-    return;
+       if (! status->stat_options)
+               return;

 
 

-  STAT_ENTER_SINGLE;
-  {
-    graph_entry_t *graph = graph_get_entry(irg, status->irg_hash);
+       STAT_ENTER_SINGLE;
+       {
+               graph_entry_t *graph = graph_get_entry(irg, status->irg_hash);

 
 

-    cnt_inc(&graph->cnt_walked_blocks);
-  }
-  STAT_LEAVE;
-}
+               cnt_inc(&graph->cnt_walked_blocks);
+       }
+       STAT_LEAVE;
+} /* stat_irg_block_walk */

 
 /**
 
 /**

- * called for every node that is removed due to an optimization.
+ * Called for every node that is removed due to an optimization.

  *
  * @param n     the IR node that will be removed
  * @param hmap  the hash map containing ir_op* -> opt_entry_t*
  */
 static void removed_due_opt(ir_node *n, hmap_opt_entry_t *hmap)
 {
  *
  * @param n     the IR node that will be removed
  * @param hmap  the hash map containing ir_op* -> opt_entry_t*
  */
 static void removed_due_opt(ir_node *n, hmap_opt_entry_t *hmap)
 {

-  ir_op *op          = stat_get_irn_op(n);
-  opt_entry_t *entry = opt_get_entry(op, hmap);
+       ir_op *op          = stat_get_irn_op(n);
+       opt_entry_t *entry = opt_get_entry(op, hmap);

 
 

-  /* increase global value */
-  cnt_inc(&entry->count);
-}
+       /* increase global value */
+       cnt_inc(&entry->count);
+} /* removed_due_opt */

 
 /**
 
 /**

- * Some nodes were optimized into some others due to an optimization.
+ * Hook: Some nodes were optimized into some others due to an optimization.

  *
  * @param ctx  the hook context
  */
  *
  * @param ctx  the hook context
  */


@@ -1467,81 +1457,82 @@ static void stat_merge_nodes(
     ir_node **old_node_array, int old_num_entries,
     hook_opt_kind opt)
 {
     ir_node **old_node_array, int old_num_entries,
     hook_opt_kind opt)
 {

-  if (! status->stat_options)
-    return;
+       if (! status->stat_options)
+               return;

 
 

-  STAT_ENTER;
-  {
-    int i, j;
-    graph_entry_t *graph = graph_get_entry(current_ir_graph, status->irg_hash);
+       STAT_ENTER;
+       {
+               int i, j;
+               graph_entry_t *graph = graph_get_entry(current_ir_graph, status->irg_hash);

 
 

-    if (status->reassoc_run)
-      opt = HOOK_OPT_REASSOC;
+               if (status->reassoc_run)
+                       opt = HOOK_OPT_REASSOC;

 
 

-    for (i = 0; i < old_num_entries; ++i) {
-      for (j = 0; j < new_num_entries; ++j)
-        if (old_node_array[i] == new_node_array[j])
-          break;
+               for (i = 0; i < old_num_entries; ++i) {
+                       for (j = 0; j < new_num_entries; ++j) {
+                               if (old_node_array[i] == new_node_array[j])
+                                       break;

 
 

-      /* nodes might be in new and old, these are NOT removed */
-      if (j >= new_num_entries) {
-        int xopt = opt;
+                               /* nodes might be in new and old, these are NOT removed */
+                               if (j >= new_num_entries) {
+                                       int xopt = opt;

 
 

-        /* sometimes we did not detect, that it is replaced by a Const */
-        if (opt == HOOK_OPT_CONFIRM && new_num_entries == 1) {
-          ir_op *op = get_irn_op(new_node_array[0]);
+                                       /* sometimes we did not detect, that it is replaced by a Const */
+                                       if (opt == HOOK_OPT_CONFIRM && new_num_entries == 1) {
+                                               ir_op *op = get_irn_op(new_node_array[0]);

 
 

-          if (op == op_Const || op == op_SymConst)
-            xopt = HOOK_OPT_CONFIRM_C;
-        }
+                                               if (op == op_Const || op == op_SymConst)
+                                                       xopt = HOOK_OPT_CONFIRM_C;
+                                       }  /* if */

 
 

-        removed_due_opt(old_node_array[i], graph->opt_hash[xopt]);
-      }
-    }
-  }
-  STAT_LEAVE;
-}
+                                       removed_due_opt(old_node_array[i], graph->opt_hash[xopt]);
+                               }  /* if */
+                       }  /* for */
+               }  /* for */
+       }
+       STAT_LEAVE;
+} /* stat_merge_nodes */

 
 /**
 
 /**

- * Reassociation is started/stopped.
+ * Hook: Reassociation is started/stopped.

  *
  * @param ctx   the hook context
  * @param flag  if non-zero, reassociation is started else stopped
  */
 static void stat_reassociate(void *ctx, int flag)
 {
  *
  * @param ctx   the hook context
  * @param flag  if non-zero, reassociation is started else stopped
  */
 static void stat_reassociate(void *ctx, int flag)
 {

-  if (! status->stat_options)
-    return;
+       if (! status->stat_options)
+               return;

 
 

-  STAT_ENTER;
-  {
-    status->reassoc_run = flag;
-  }
-  STAT_LEAVE;
-}
+       STAT_ENTER;
+       {
+               status->reassoc_run = flag;
+       }
+       STAT_LEAVE;
+} /* stat_reassociate */

 
 /**
 
 /**

- * A node was lowered into other nodes
+ * Hook: A node was lowered into other nodes

  *
  * @param ctx  the hook context
  * @param node the IR node that will be lowered
  */
 static void stat_lower(void *ctx, ir_node *node)
 {
  *
  * @param ctx  the hook context
  * @param node the IR node that will be lowered
  */
 static void stat_lower(void *ctx, ir_node *node)
 {

-  if (! status->stat_options)
-    return;
+       if (! status->stat_options)
+               return;

 
 

-  STAT_ENTER;
-  {
-    graph_entry_t *graph = graph_get_entry(current_ir_graph, status->irg_hash);
+       STAT_ENTER;
+       {
+               graph_entry_t *graph = graph_get_entry(current_ir_graph, status->irg_hash);

 
 

-    removed_due_opt(node, graph->opt_hash[HOOK_LOWERED]);
-  }
-  STAT_LEAVE;
-}
+               removed_due_opt(node, graph->opt_hash[HOOK_LOWERED]);
+       }
+       STAT_LEAVE;
+} /* stat_lower */

 
 /**
 
 /**

- * A graph was inlined.
+ * Hook: A graph was inlined.

  *
  * @param ctx  the hook context
  * @param call the IR call that will re changed into the body of
  *
  * @param ctx  the hook context
  * @param call the IR call that will re changed into the body of


@@ -1550,39 +1541,39 @@ static void stat_lower(void *ctx, ir_node *node)
  */
 static void stat_inline(void *ctx, ir_node *call, ir_graph *called_irg)
 {
  */
 static void stat_inline(void *ctx, ir_node *call, ir_graph *called_irg)
 {

-  if (! status->stat_options)
-    return;
+       if (! status->stat_options)
+               return;

 
 

-  STAT_ENTER;
-  {
-    ir_graph *irg = get_irn_irg(call);
-    graph_entry_t *i_graph = graph_get_entry(called_irg, status->irg_hash);
-    graph_entry_t *graph   = graph_get_entry(irg, status->irg_hash);
+       STAT_ENTER;
+       {
+               ir_graph *irg = get_irn_irg(call);
+               graph_entry_t *i_graph = graph_get_entry(called_irg, status->irg_hash);
+               graph_entry_t *graph   = graph_get_entry(irg, status->irg_hash);

 
 

-    cnt_inc(&graph->cnt_got_inlined);
-    cnt_inc(&i_graph->cnt_was_inlined);
-  }
-  STAT_LEAVE;
-}
+               cnt_inc(&graph->cnt_got_inlined);
+               cnt_inc(&i_graph->cnt_was_inlined);
+       }
+       STAT_LEAVE;
+} /* stat_inline */

 
 /**
 
 /**

- * A graph with tail-recursions was optimized.
+ * Hook: A graph with tail-recursions was optimized.

  *
  * @param ctx  the hook context
  */
 static void stat_tail_rec(void *ctx, ir_graph *irg, int n_calls)
 {
  *
  * @param ctx  the hook context
  */
 static void stat_tail_rec(void *ctx, ir_graph *irg, int n_calls)
 {

-  if (! status->stat_options)
-    return;
+       if (! status->stat_options)
+               return;

 
 

-  STAT_ENTER;
-  {
-    graph_entry_t *graph = graph_get_entry(irg, status->irg_hash);
+       STAT_ENTER;
+       {
+               graph_entry_t *graph = graph_get_entry(irg, status->irg_hash);

 
 

-    graph->num_tail_recursion += n_calls;
-  }
-  STAT_LEAVE;
-}
+               graph->num_tail_recursion += n_calls;
+       }
+       STAT_LEAVE;
+} /* stat_tail_rec */

 
 /**
  * Strength reduction was performed on an iteration variable.
 
 /**
  * Strength reduction was performed on an iteration variable.


@@ -1591,109 +1582,109 @@ static void stat_tail_rec(void *ctx, ir_graph *irg, int n_calls)
  */
 static void stat_strength_red(void *ctx, ir_graph *irg, ir_node *strong)
 {
  */
 static void stat_strength_red(void *ctx, ir_graph *irg, ir_node *strong)
 {

-  if (! status->stat_options)
-    return;
+       if (! status->stat_options)
+               return;

 
 

-  STAT_ENTER;
-  {
-    graph_entry_t *graph = graph_get_entry(irg, status->irg_hash);
-    cnt_inc(&graph->cnt_strength_red);
+       STAT_ENTER;
+       {
+               graph_entry_t *graph = graph_get_entry(irg, status->irg_hash);
+               cnt_inc(&graph->cnt_strength_red);

 
 

-    removed_due_opt(strong, graph->opt_hash[HOOK_OPT_STRENGTH_RED]);
-  }
-  STAT_LEAVE;
-}
+               removed_due_opt(strong, graph->opt_hash[HOOK_OPT_STRENGTH_RED]);
+       }
+       STAT_LEAVE;
+} /* stat_strength_red */

 
 /**
 
 /**

- * Start/Stop the dead node elimination.
+ * Hook: Start/Stop the dead node elimination.

  *
  * @param ctx  the hook context
  */
 static void stat_dead_node_elim(void *ctx, ir_graph *irg, int start)
 {
  *
  * @param ctx  the hook context
  */
 static void stat_dead_node_elim(void *ctx, ir_graph *irg, int start)
 {

-  if (! status->stat_options)
-    return;
+       if (! status->stat_options)
+               return;

 
 

-  if (start)
-    ++status->in_dead_node_elim;
-  else
-    --status->in_dead_node_elim;
-}
+       if (start)
+               ++status->in_dead_node_elim;
+       else
+               --status->in_dead_node_elim;
+} /* stat_dead_node_elim */

 
 /**
 
 /**

- * if-conversion was tried
+ * Hook: if-conversion was tried.

  */
 static void stat_if_conversion(void *context, ir_graph *irg, ir_node *phi,
                                int pos, ir_node *mux, if_result_t reason)
 {
  */
 static void stat_if_conversion(void *context, ir_graph *irg, ir_node *phi,
                                int pos, ir_node *mux, if_result_t reason)
 {

-  if (! status->stat_options)
-    return;
+       if (! status->stat_options)
+               return;

 
 

-  STAT_ENTER;
-  {
-    graph_entry_t *graph = graph_get_entry(irg, status->irg_hash);
+       STAT_ENTER;
+       {
+               graph_entry_t *graph = graph_get_entry(irg, status->irg_hash);

 
 

-    cnt_inc(&graph->cnt_if_conv[reason]);
-  }
-  STAT_LEAVE;
-}
+               cnt_inc(&graph->cnt_if_conv[reason]);
+       }
+       STAT_LEAVE;
+} /* stat_if_conversion */

 
 /**
 
 /**

- * real function call was optimized
+ * Hook: real function call was optimized.

  */
 static void stat_func_call(void *context, ir_graph *irg, ir_node *call)
 {
  */
 static void stat_func_call(void *context, ir_graph *irg, ir_node *call)
 {

-  if (! status->stat_options)
-    return;
+       if (! status->stat_options)
+               return;

 
 

-  STAT_ENTER;
-  {
-    graph_entry_t *graph = graph_get_entry(irg, status->irg_hash);
+       STAT_ENTER;
+       {
+               graph_entry_t *graph = graph_get_entry(irg, status->irg_hash);

 
 

-    cnt_inc(&graph->cnt_real_func_call);
-  }
-  STAT_LEAVE;
-}
+               cnt_inc(&graph->cnt_real_func_call);
+       }
+       STAT_LEAVE;
+} /* stat_func_call */

 
 /**
 
 /**

- * A multiply was replaced by a series of Shifts/Adds/Subs
+ * Hook: A multiply was replaced by a series of Shifts/Adds/Subs.

  *
  * @param ctx  the hook context
  */
 static void stat_arch_dep_replace_mul_with_shifts(void *ctx, ir_node *mul)
 {
  *
  * @param ctx  the hook context
  */
 static void stat_arch_dep_replace_mul_with_shifts(void *ctx, ir_node *mul)
 {

-  if (! status->stat_options)
-    return;
+       if (! status->stat_options)
+               return;

 
 

-  STAT_ENTER;
-  {
-    graph_entry_t *graph = graph_get_entry(current_ir_graph, status->irg_hash);
-    removed_due_opt(mul, graph->opt_hash[HOOK_OPT_ARCH_DEP]);
-  }
-  STAT_LEAVE;
-}
+       STAT_ENTER;
+       {
+               graph_entry_t *graph = graph_get_entry(current_ir_graph, status->irg_hash);
+               removed_due_opt(mul, graph->opt_hash[HOOK_OPT_ARCH_DEP]);
+       }
+       STAT_LEAVE;
+} /* stat_arch_dep_replace_mul_with_shifts */

 
 /**
 
 /**

- * A division by const was replaced
+ * Hook: A division by const was replaced.

  *
  * @param ctx   the hook context
  * @param node  the division node that will be optimized
  */
 static void stat_arch_dep_replace_division_by_const(void *ctx, ir_node *node)
 {
  *
  * @param ctx   the hook context
  * @param node  the division node that will be optimized
  */
 static void stat_arch_dep_replace_division_by_const(void *ctx, ir_node *node)
 {

-  if (! status->stat_options)
-    return;
+       if (! status->stat_options)
+               return;

 
 

-  STAT_ENTER;
-  {
-    graph_entry_t *graph = graph_get_entry(current_ir_graph, status->irg_hash);
-    removed_due_opt(node, graph->opt_hash[HOOK_OPT_ARCH_DEP]);
-  }
-  STAT_LEAVE;
-}
+       STAT_ENTER;
+       {
+               graph_entry_t *graph = graph_get_entry(current_ir_graph, status->irg_hash);
+               removed_due_opt(node, graph->opt_hash[HOOK_OPT_ARCH_DEP]);
+       }
+       STAT_LEAVE;
+} /* stat_arch_dep_replace_division_by_const */

 
 /*
 
 /*

- * Update the register pressure of a block
+ * Update the register pressure of a block.

  *
  * @param irg        the irg containing the block
  * @param block      the block for which the reg pressure should be set
  *
  * @param irg        the irg containing the block
  * @param block      the block for which the reg pressure should be set


@@ -1721,7 +1712,7 @@ void stat_be_block_regpressure(ir_graph *irg, ir_node *block, int pressure, cons
                pset_insert(block_ent->reg_pressure, rp_ent, HASH_PTR(class_name));
        }
        STAT_LEAVE;
                pset_insert(block_ent->reg_pressure, rp_ent, HASH_PTR(class_name));
        }
        STAT_LEAVE;

-}
+} /* stat_be_block_regpressure */

 
 /**
  * Update the distribution of ready nodes of a block
 
 /**
  * Update the distribution of ready nodes of a block


@@ -1732,24 +1723,24 @@ void stat_be_block_regpressure(ir_graph *irg, ir_node *block, int pressure, cons
  */
 void stat_be_block_sched_ready(ir_graph *irg, ir_node *block, int num_ready)
 {
  */
 void stat_be_block_sched_ready(ir_graph *irg, ir_node *block, int num_ready)
 {

-  if (! status->stat_options)
-    return;
+       if (! status->stat_options)
+               return;

 
 

-  STAT_ENTER;
-  {
-    graph_entry_t    *graph = graph_get_entry(irg, status->irg_hash);
-    be_block_entry_t *block_ent;
+       STAT_ENTER;
+       {
+               graph_entry_t    *graph = graph_get_entry(irg, status->irg_hash);
+               be_block_entry_t *block_ent;

 
 

-    block_ent = be_block_get_entry(&status->be_data, get_irn_node_nr(block), graph->be_block_hash);
+               block_ent = be_block_get_entry(&status->be_data, get_irn_node_nr(block), graph->be_block_hash);

 
 

-    /* increase the counter of corresponding number of ready nodes */
-       stat_inc_int_distrib_tbl(block_ent->sched_ready, num_ready);
-  }
-  STAT_LEAVE;
-}
+               /* increase the counter of corresponding number of ready nodes */
+               stat_inc_int_distrib_tbl(block_ent->sched_ready, num_ready);
+       }
+       STAT_LEAVE;
+} /* stat_be_block_sched_ready */

 
 /**
 
 /**

- * Update the permutation statistic of a block
+ * Update the permutation statistic of a block.

  *
  * @param class_name the name of the register class
  * @param n_regs     number of registers in the register class
  *
  * @param class_name the name of the register class
  * @param n_regs     number of registers in the register class


@@ -1761,31 +1752,31 @@ void stat_be_block_sched_ready(ir_graph *irg, ir_node *block, int num_ready)
 void stat_be_block_stat_perm(const char *class_name, int n_regs, ir_node *perm, ir_node *block,
                              int size, int real_size)
 {
 void stat_be_block_stat_perm(const char *class_name, int n_regs, ir_node *perm, ir_node *block,
                              int size, int real_size)
 {

-  if (! status->stat_options)
-    return;
+       if (! status->stat_options)
+               return;

 
 

-  STAT_ENTER;
-  {
-    graph_entry_t      *graph = graph_get_entry(get_irn_irg(block), status->irg_hash);
-    be_block_entry_t   *block_ent;
-    perm_class_entry_t *pc_ent;
-    perm_stat_entry_t  *ps_ent;
+       STAT_ENTER;
+       {
+               graph_entry_t      *graph = graph_get_entry(get_irn_irg(block), status->irg_hash);
+               be_block_entry_t   *block_ent;
+               perm_class_entry_t *pc_ent;
+               perm_stat_entry_t  *ps_ent;

 
 

-    block_ent = be_block_get_entry(&status->be_data, get_irn_node_nr(block), graph->be_block_hash);
-    pc_ent    = perm_class_get_entry(&status->be_data, class_name, block_ent->perm_class_stat);
-    ps_ent    = perm_stat_get_entry(&status->be_data, perm, pc_ent->perm_stat);
+               block_ent = be_block_get_entry(&status->be_data, get_irn_node_nr(block), graph->be_block_hash);
+               pc_ent    = perm_class_get_entry(&status->be_data, class_name, block_ent->perm_class_stat);
+               ps_ent    = perm_stat_get_entry(&status->be_data, perm, pc_ent->perm_stat);

 
 

-       pc_ent->n_regs = n_regs;
+               pc_ent->n_regs = n_regs;

 
 

-    /* update information */
-    ps_ent->size      = size;
-    ps_ent->real_size = real_size;
-  }
-  STAT_LEAVE;
-}
+               /* update information */
+               ps_ent->size      = size;
+               ps_ent->real_size = real_size;
+       }
+       STAT_LEAVE;
+} /* stat_be_block_stat_perm */

 
 /**
 
 /**

- * Update the permutation statistic of a single perm
+ * Update the permutation statistic of a single perm.

  *
  * @param class_name the name of the register class
  * @param perm       the perm node
  *
  * @param class_name the name of the register class
  * @param perm       the perm node


@@ -1797,154 +1788,148 @@ void stat_be_block_stat_perm(const char *class_name, int n_regs, ir_node *perm,
 void stat_be_block_stat_permcycle(const char *class_name, ir_node *perm, ir_node *block,
                                   int is_chain, int size, int n_ops)
 {
 void stat_be_block_stat_permcycle(const char *class_name, ir_node *perm, ir_node *block,
                                   int is_chain, int size, int n_ops)
 {

-  if (! status->stat_options)
-    return;
-
-  STAT_ENTER;
-  {
-    graph_entry_t      *graph = graph_get_entry(get_irn_irg(block), status->irg_hash);
-    be_block_entry_t   *block_ent;
-    perm_class_entry_t *pc_ent;
-    perm_stat_entry_t  *ps_ent;
-
-    block_ent = be_block_get_entry(&status->be_data, get_irn_node_nr(block), graph->be_block_hash);
-    pc_ent    = perm_class_get_entry(&status->be_data, class_name, block_ent->perm_class_stat);
-    ps_ent    = perm_stat_get_entry(&status->be_data, perm, pc_ent->perm_stat);
-
-    if (is_chain) {
-      ps_ent->n_copies += n_ops;
-      stat_inc_int_distrib_tbl(ps_ent->chains, size);
-    }
-    else {
-      ps_ent->n_exchg += n_ops;
-      stat_inc_int_distrib_tbl(ps_ent->cycles, size);
-    }
-  }
-  STAT_LEAVE;
-}
+       if (! status->stat_options)
+               return;

 
 

-/* Dumps a statistics snapshot */
-void stat_dump_snapshot(const char *name, const char *phase)
-{
-  char fname[2048];
-  const char *p;
-  int l;
+       STAT_ENTER;
+       {
+               graph_entry_t      *graph = graph_get_entry(get_irn_irg(block), status->irg_hash);
+               be_block_entry_t   *block_ent;
+               perm_class_entry_t *pc_ent;
+               perm_stat_entry_t  *ps_ent;

 
 

-  if (! status->stat_options)
-    return;
+               block_ent = be_block_get_entry(&status->be_data, get_irn_node_nr(block), graph->be_block_hash);
+               pc_ent    = perm_class_get_entry(&status->be_data, class_name, block_ent->perm_class_stat);
+               ps_ent    = perm_stat_get_entry(&status->be_data, perm, pc_ent->perm_stat);
+
+               if (is_chain) {
+                       ps_ent->n_copies += n_ops;
+                       stat_inc_int_distrib_tbl(ps_ent->chains, size);
+               } else {
+                       ps_ent->n_exchg += n_ops;
+                       stat_inc_int_distrib_tbl(ps_ent->cycles, size);
+               }  /* if */
+       }
+       STAT_LEAVE;
+} /* stat_be_block_stat_permcycle */

 
 

-  STAT_ENTER;
-  {
-    graph_entry_t *entry;
-    graph_entry_t *global = graph_get_entry(NULL, status->irg_hash);
+/* Dumps a statistics snapshot. */
+void stat_dump_snapshot(const char *name, const char *phase)
+{
+       char fname[2048];
+       const char *p;
+       int l;

 
 

-    /*
-     * The constant counter is only global, so we clear it here.
-     * Note that it does NOT contain the constants in DELETED
-     * graphs due to this.
-     */
-    if (status->stat_options & FIRMSTAT_COUNT_CONSTS)
-      stat_const_clear(status);
+       if (! status->stat_options)
+               return;

 
 

-    /* build the name */
-    p = strrchr(name, '/');
+       STAT_ENTER;
+       {
+               graph_entry_t *entry;
+               graph_entry_t *global = graph_get_entry(NULL, status->irg_hash);
+
+               /*
+                * The constant counter is only global, so we clear it here.
+                * Note that it does NOT contain the constants in DELETED
+                * graphs due to this.
+                */
+               if (status->stat_options & FIRMSTAT_COUNT_CONSTS)
+                       stat_const_clear(status);
+
+               /* build the name */
+               p = strrchr(name, '/');

 #ifdef _WIN32
 #ifdef _WIN32

-    {
-      const char *q;
+               {
+                       const char *q;

 
 

-      q = strrchr(name, '\\');
+                       q = strrchr(name, '\\');

 
 

-      /* NULL might be not the smallest pointer */
-      if (q && (!p || q > p))
-        p = q;
-    }
-#endif
-    if (p) {
-      ++p;
-      l = p - name;
-
-      if (l > sizeof(fname) - 1)
-        l = sizeof(fname) - 1;
-
-      memcpy(fname, name, l);
-      fname[l] = '\0';
-    }
-    else {
-      fname[0] = '\0';
-      p = name;
-    }
-    strncat(fname, "firmstat-", sizeof(fname));
-    strncat(fname, phase, sizeof(fname));
-    strncat(fname, "-", sizeof(fname));
-    strncat(fname, p, sizeof(fname));
-
-    stat_dump_init(fname);
-
-    /* calculate the graph statistics */
-    for (entry = pset_first(status->irg_hash); entry; entry = pset_next(status->irg_hash)) {
-
-      if (entry->irg == NULL) {
-        /* special entry for the global count */
-        continue;
-      }
-
-      if (! entry->is_deleted) {
-        /* the graph is still alive, count the nodes on it */
-        update_graph_stat(global, entry);
-      }
-    }
-
-    /* some calculations are dependent, we pushed them on the wait_q */
-    while (! pdeq_empty(status->wait_q)) {
-      entry = pdeq_getr(status->wait_q);
-
-      update_graph_stat_2(global, entry);
-    }
-
-
-    /* dump per graph */
-    for (entry = pset_first(status->irg_hash); entry; entry = pset_next(status->irg_hash)) {
-
-      if (entry->irg == NULL) {
-        /* special entry for the global count */
-        continue;
-      }
-
-      if (! entry->is_deleted || status->stat_options & FIRMSTAT_COUNT_DELETED) {
-        stat_dump_graph(entry);
-               stat_dump_registered(entry);
-      }
-
-      if (! entry->is_deleted) {
-        /* clear the counter that are not accumulated */
-        graph_clear_entry(entry, 0);
-      }
-    }
-
-    /* dump global */
-    stat_dump_graph(global);
-
-    /* dump the const info */
-    if (status->stat_options & FIRMSTAT_COUNT_CONSTS)
-      stat_dump_consts(&status->const_info);
-
-    stat_dump_finish();
-
-    stat_finish_pattern_history();
-
-    /* clear the global counter here */
-    {
-      node_entry_t *entry;
-
-      for (entry = pset_first(global->opcode_hash); entry; entry = pset_next(global->opcode_hash)) {
-        opcode_clear_entry(entry);
-      }
-      /* clear all global counter */
-      graph_clear_entry(global, 1);
-    }
-  }
-  STAT_LEAVE;
-}
+                       /* NULL might be not the smallest pointer */
+                       if (q && (!p || q > p))
+                               p = q;
+               }
+#endif /* _WIN32 */
+               if (p) {
+                       ++p;
+                       l = p - name;
+
+                       if (l > sizeof(fname) - 1)
+                               l = sizeof(fname) - 1;
+
+                       memcpy(fname, name, l);
+                       fname[l] = '\0';
+               } else {
+                       fname[0] = '\0';
+                       p = name;
+               }  /* if */
+               strncat(fname, "firmstat-", sizeof(fname));
+               strncat(fname, phase, sizeof(fname));
+               strncat(fname, "-", sizeof(fname));
+               strncat(fname, p, sizeof(fname));
+
+               stat_dump_init(fname);
+
+               /* calculate the graph statistics */
+               for (entry = pset_first(status->irg_hash); entry; entry = pset_next(status->irg_hash)) {
+                       if (entry->irg == NULL) {
+                               /* special entry for the global count */
+                               continue;
+                       }  /* if */
+                       if (! entry->is_deleted) {
+                               /* the graph is still alive, count the nodes on it */
+                               update_graph_stat(global, entry);
+                       }  /* if */
+               }  /* for */
+
+               /* some calculations are dependent, we pushed them on the wait_q */
+               while (! pdeq_empty(status->wait_q)) {
+                       entry = pdeq_getr(status->wait_q);
+
+                       update_graph_stat_2(global, entry);
+               }  /* while */
+
+               /* dump per graph */
+               for (entry = pset_first(status->irg_hash); entry; entry = pset_next(status->irg_hash)) {
+                       if (entry->irg == NULL) {
+                               /* special entry for the global count */
+                               continue;
+                       }  /* if */
+
+                       if (! entry->is_deleted || status->stat_options & FIRMSTAT_COUNT_DELETED) {
+                               stat_dump_graph(entry);
+                               stat_dump_registered(entry);
+                       }  /* if */
+
+                       if (! entry->is_deleted) {
+                               /* clear the counter that are not accumulated */
+                               graph_clear_entry(entry, 0);
+                       }  /* if */
+               }  /* for */
+
+               /* dump global */
+               stat_dump_graph(global);
+
+               /* dump the const info */
+               if (status->stat_options & FIRMSTAT_COUNT_CONSTS)
+                       stat_dump_consts(&status->const_info);
+
+               stat_dump_finish();
+
+               stat_finish_pattern_history();
+
+               /* clear the global counter here */
+               {
+                       node_entry_t *entry;
+
+                       for (entry = pset_first(global->opcode_hash); entry; entry = pset_next(global->opcode_hash)) {
+                               opcode_clear_entry(entry);
+                       }  /* for */
+                       /* clear all global counter */
+                       graph_clear_entry(global, 1);
+               }
+       }
+       STAT_LEAVE;
+} /* stat_dump_snapshot */

 
 /** the hook entries for the Firm statistics module */
 static hook_entry_t stat_hooks[hook_last];
 
 /** the hook entries for the Firm statistics module */
 static hook_entry_t stat_hooks[hook_last];


@@ -1954,126 +1939,125 @@ void firm_init_stat(unsigned enable_options)
 {
 #define X(a)  a, sizeof(a)-1
 #define HOOK(h, fkt) \
 {
 #define X(a)  a, sizeof(a)-1
 #define HOOK(h, fkt) \

-  stat_hooks[h].hook._##h = fkt; register_hook(h, &stat_hooks[h])
-  unsigned num = 0;
-
-  if (! (enable_options & FIRMSTAT_ENABLED))
-    return;
-
-  status = xmalloc(sizeof(*status));
-  memset(status, 0, sizeof(*status));
-
-  /* enable statistics */
-  status->stat_options = enable_options & FIRMSTAT_ENABLED ? enable_options : 0;
-
-  /* register all hooks */
-  HOOK(hook_new_ir_op,                          stat_new_ir_op);
-  HOOK(hook_free_ir_op,                         stat_free_ir_op);
-  HOOK(hook_new_node,                           stat_new_node);
-  HOOK(hook_turn_into_id,                       stat_turn_into_id);
-  HOOK(hook_new_graph,                          stat_new_graph);
-  HOOK(hook_free_graph,                         stat_free_graph);
-  HOOK(hook_irg_walk,                           stat_irg_walk);
-  HOOK(hook_irg_walk_blkwise,                   stat_irg_walk_blkwise);
-  HOOK(hook_irg_block_walk,                     stat_irg_block_walk);
-  HOOK(hook_merge_nodes,                        stat_merge_nodes);
-  HOOK(hook_reassociate,                        stat_reassociate);
-  HOOK(hook_lower,                              stat_lower);
-  HOOK(hook_inline,                             stat_inline);
-  HOOK(hook_tail_rec,                           stat_tail_rec);
-  HOOK(hook_strength_red,                       stat_strength_red);
-  HOOK(hook_dead_node_elim,                     stat_dead_node_elim);
-  HOOK(hook_if_conversion,                      stat_if_conversion);
-  HOOK(hook_func_call,                          stat_func_call);
-  HOOK(hook_arch_dep_replace_mul_with_shifts,   stat_arch_dep_replace_mul_with_shifts);
-  HOOK(hook_arch_dep_replace_division_by_const, stat_arch_dep_replace_division_by_const);
-
-  obstack_init(&status->cnts);
-  obstack_init(&status->be_data);
-
-  /* create the hash-tables */
-  status->irg_hash   = new_pset(graph_cmp, 8);
-  status->ir_op_hash = new_pset(opcode_cmp_2, 1);
-
-  /* create the wait queue */
-  status->wait_q     = new_pdeq();
-
-  if (enable_options & FIRMSTAT_COUNT_STRONG_OP) {
-    /* build the pseudo-ops */
-
-    _op_Phi0.code    = --num;
-    _op_Phi0.name    = new_id_from_chars(X("Phi0"));
-
-    _op_PhiM.code    = --num;
-    _op_PhiM.name    = new_id_from_chars(X("PhiM"));
-
-    _op_ProjM.code   = --num;
-    _op_ProjM.name   = new_id_from_chars(X("ProjM"));
-
-    _op_MulC.code    = --num;
-    _op_MulC.name    = new_id_from_chars(X("MulC"));
-
-    _op_DivC.code    = --num;
-    _op_DivC.name    = new_id_from_chars(X("DivC"));
-
-    _op_ModC.code    = --num;
-    _op_ModC.name    = new_id_from_chars(X("ModC"));
-
-    _op_DivModC.code = --num;
-    _op_DivModC.name = new_id_from_chars(X("DivModC"));
-
-    status->op_Phi0    = &_op_Phi0;
-    status->op_PhiM    = &_op_PhiM;
-    status->op_ProjM   = &_op_ProjM;
-    status->op_MulC    = &_op_MulC;
-    status->op_DivC    = &_op_DivC;
-    status->op_ModC    = &_op_ModC;
-    status->op_DivModC = &_op_DivModC;
-  }
-  else {
-    status->op_Phi0    = NULL;
-    status->op_PhiM    = NULL;
-    status->op_ProjM   = NULL;
-    status->op_MulC    = NULL;
-    status->op_DivC    = NULL;
-    status->op_ModC    = NULL;
-    status->op_DivModC = NULL;
-  }
-
-  if (enable_options & FIRMSTAT_COUNT_SELS) {
-    _op_SelSel.code    = --num;
-    _op_SelSel.name    = new_id_from_chars(X("Sel(Sel)"));
-
-    _op_SelSelSel.code = --num;
-    _op_SelSelSel.name = new_id_from_chars(X("Sel(Sel(Sel))"));
-
-    status->op_SelSel    = &_op_SelSel;
-    status->op_SelSelSel = &_op_SelSelSel;
-  }
-  else {
-    status->op_SelSel    = NULL;
-    status->op_SelSelSel = NULL;
-  }
-
-  /* register the dumper */
-  stat_register_dumper(&simple_dumper);
-
-  if (enable_options & FIRMSTAT_CSV_OUTPUT)
-    stat_register_dumper(&csv_dumper);
-
-  /* initialize the pattern hash */
-  stat_init_pattern_history(enable_options & FIRMSTAT_PATTERN_ENABLED);
-
-  /* initialize the Const options */
-  if (enable_options & FIRMSTAT_COUNT_CONSTS)
-    stat_init_const_cnt(status);
+       stat_hooks[h].hook._##h = fkt; register_hook(h, &stat_hooks[h])
+       unsigned num = 0;
+
+       if (! (enable_options & FIRMSTAT_ENABLED))
+               return;
+
+       status = xmalloc(sizeof(*status));
+       memset(status, 0, sizeof(*status));
+
+       /* enable statistics */
+       status->stat_options = enable_options & FIRMSTAT_ENABLED ? enable_options : 0;
+
+       /* register all hooks */
+       HOOK(hook_new_ir_op,                          stat_new_ir_op);
+       HOOK(hook_free_ir_op,                         stat_free_ir_op);
+       HOOK(hook_new_node,                           stat_new_node);
+       HOOK(hook_turn_into_id,                       stat_turn_into_id);
+       HOOK(hook_new_graph,                          stat_new_graph);
+       HOOK(hook_free_graph,                         stat_free_graph);
+       HOOK(hook_irg_walk,                           stat_irg_walk);
+       HOOK(hook_irg_walk_blkwise,                   stat_irg_walk_blkwise);
+       HOOK(hook_irg_block_walk,                     stat_irg_block_walk);
+       HOOK(hook_merge_nodes,                        stat_merge_nodes);
+       HOOK(hook_reassociate,                        stat_reassociate);
+       HOOK(hook_lower,                              stat_lower);
+       HOOK(hook_inline,                             stat_inline);
+       HOOK(hook_tail_rec,                           stat_tail_rec);
+       HOOK(hook_strength_red,                       stat_strength_red);
+       HOOK(hook_dead_node_elim,                     stat_dead_node_elim);
+       HOOK(hook_if_conversion,                      stat_if_conversion);
+       HOOK(hook_func_call,                          stat_func_call);
+       HOOK(hook_arch_dep_replace_mul_with_shifts,   stat_arch_dep_replace_mul_with_shifts);
+       HOOK(hook_arch_dep_replace_division_by_const, stat_arch_dep_replace_division_by_const);
+
+       obstack_init(&status->cnts);
+       obstack_init(&status->be_data);
+
+       /* create the hash-tables */
+       status->irg_hash   = new_pset(graph_cmp, 8);
+       status->ir_op_hash = new_pset(opcode_cmp_2, 1);
+
+       /* create the wait queue */
+       status->wait_q     = new_pdeq();
+
+       if (enable_options & FIRMSTAT_COUNT_STRONG_OP) {
+               /* build the pseudo-ops */
+
+               _op_Phi0.code    = --num;
+               _op_Phi0.name    = new_id_from_chars(X("Phi0"));
+
+               _op_PhiM.code    = --num;
+               _op_PhiM.name    = new_id_from_chars(X("PhiM"));
+
+               _op_ProjM.code   = --num;
+               _op_ProjM.name   = new_id_from_chars(X("ProjM"));
+
+               _op_MulC.code    = --num;
+               _op_MulC.name    = new_id_from_chars(X("MulC"));
+
+               _op_DivC.code    = --num;
+               _op_DivC.name    = new_id_from_chars(X("DivC"));
+
+               _op_ModC.code    = --num;
+               _op_ModC.name    = new_id_from_chars(X("ModC"));
+
+               _op_DivModC.code = --num;
+               _op_DivModC.name = new_id_from_chars(X("DivModC"));
+
+               status->op_Phi0    = &_op_Phi0;
+               status->op_PhiM    = &_op_PhiM;
+               status->op_ProjM   = &_op_ProjM;
+               status->op_MulC    = &_op_MulC;
+               status->op_DivC    = &_op_DivC;
+               status->op_ModC    = &_op_ModC;
+               status->op_DivModC = &_op_DivModC;
+       } else {
+               status->op_Phi0    = NULL;
+               status->op_PhiM    = NULL;
+               status->op_ProjM   = NULL;
+               status->op_MulC    = NULL;
+               status->op_DivC    = NULL;
+               status->op_ModC    = NULL;
+               status->op_DivModC = NULL;
+       }  /* if */
+
+       /* for Florian: count the Sel depth */
+       if (enable_options & FIRMSTAT_COUNT_SELS) {
+               _op_SelSel.code    = --num;
+               _op_SelSel.name    = new_id_from_chars(X("Sel(Sel)"));
+
+               _op_SelSelSel.code = --num;
+               _op_SelSelSel.name = new_id_from_chars(X("Sel(Sel(Sel))"));
+
+               status->op_SelSel    = &_op_SelSel;
+               status->op_SelSelSel = &_op_SelSelSel;
+       } else {
+               status->op_SelSel    = NULL;
+               status->op_SelSelSel = NULL;
+       }  /* if */
+
+       /* register the dumper */
+       stat_register_dumper(&simple_dumper);
+
+       if (enable_options & FIRMSTAT_CSV_OUTPUT)
+               stat_register_dumper(&csv_dumper);
+
+       /* initialize the pattern hash */
+       stat_init_pattern_history(enable_options & FIRMSTAT_PATTERN_ENABLED);
+
+       /* initialize the Const options */
+       if (enable_options & FIRMSTAT_COUNT_CONSTS)
+               stat_init_const_cnt(status);

 
 #undef HOOK
 #undef X
 
 #undef HOOK
 #undef X

-}
+} /* firm_init_stat */

 
 /**
 
 /**

- * Frees all dumper structures;
+ * Frees all dumper structures.

  */
 static void stat_term_dumper(void) {
        dumper_t *dumper, *next_dumper;
  */
 static void stat_term_dumper(void) {
        dumper_t *dumper, *next_dumper;


@@ -2085,27 +2069,27 @@ static void stat_term_dumper(void) {
                next_dumper = dumper->next;
                free(dumper);
                dumper = next_dumper;
                next_dumper = dumper->next;
                free(dumper);
                dumper = next_dumper;

-       }
-}
+       }  /* for */
+} /* stat_term_dumper */

 
 
 
 

-/* terminates the statistics module, frees all memory */
+/* Terminates the statistics module, frees all memory. */

 void stat_term(void) {
 void stat_term(void) {

-  if (status != (stat_info_t *)&status_disable) {
-    obstack_free(&status->be_data, NULL);
-       obstack_free(&status->cnts, NULL);
+       if (status != (stat_info_t *)&status_disable) {
+               obstack_free(&status->be_data, NULL);
+               obstack_free(&status->cnts, NULL);

 
 

-       stat_term_dumper();
+               stat_term_dumper();

 
 

-    xfree(status);
-    status = (stat_info_t *)&status_disable;
-  }
-}
+               xfree(status);
+               status = (stat_info_t *)&status_disable;
+       }
+} /* stat_term */

 
 /* returns 1 if statistics were initialized, 0 otherwise */
 int stat_is_active(void) {
 
 /* returns 1 if statistics were initialized, 0 otherwise */
 int stat_is_active(void) {

-  return status != (stat_info_t *)&status_disable;
-}
+       return status != (stat_info_t *)&status_disable;
+} /* stat_is_active */

 
 #else
 
 
 #else
 

diff --git a/ir/stat/pattern.c b/ir/stat/pattern.c
index 9662176..e8b6bd6 100644 (file)
--- a/ir/stat/pattern.c
+++ b/ir/stat/pattern.c
@@ -27,61 +27,62 @@ typedef unsigned char BYTE;
 
 
 /**
 
 
 /**

- * The code buffer
+ * The code buffer.

  */
 typedef struct _code_buf_t {
  */
 typedef struct _code_buf_t {

-  BYTE     *next;    /**< next byte to be written */
-  BYTE     *end;     /**< end of the buffer */
-  BYTE     *start;   /**< start of the buffer */
-  unsigned     hash;     /**< calculates the hash value */
+       BYTE     *next;    /**< Next byte address to be written. */
+       BYTE     *end;     /**< End address of the buffer. */
+       BYTE     *start;   /**< Start address of the buffer. */
+       unsigned hash;     /**< The hash value for the buffer content. */

 } CODE_BUFFER;
 
 /**
 } CODE_BUFFER;
 
 /**

- * VLC codes
+ * Reserved VLC codes.

  */
 enum vlc_code_t {
  */
 enum vlc_code_t {

-  VLC_7BIT       = 0x00,  /**< 8 bit code, carrying 7 bits payload */
-  VLC_14BIT      = 0x80,  /**< 16 bit code, carrying 14 bits payload */
-  VLC_21BIT      = 0xC0,  /**< 24 bit code, carrying 21 bits payload */
-  VLC_28BIT      = 0xE0,  /**< 32 bit code, carrying 28 bits payload */
-  VLC_32BIT      = 0xF0,  /**< 40 bit code, carrying 32 bits payload */
-
-  VLC_TAG_FIRST  = 0xF1,  /**< first possible tag value */
-  VLC_TAG_ICONST = 0xFB,  /**< encodes an integer constant */
-  VLC_TAG_EMPTY  = 0xFC,  /**< encodes an empty entity */
-  VLC_TAG_OPTION = 0xFD,  /**< options exists */
-  VLC_TAG_REF    = 0xFE,  /**< special tag, next code is an ID */
-  VLC_TAG_END    = 0xFF,  /**< end tag */
+       VLC_7BIT       = 0x00,  /**< 8 bit code, carrying 7 bits payload */
+       VLC_14BIT      = 0x80,  /**< 16 bit code, carrying 14 bits payload */
+       VLC_21BIT      = 0xC0,  /**< 24 bit code, carrying 21 bits payload */
+       VLC_28BIT      = 0xE0,  /**< 32 bit code, carrying 28 bits payload */
+       VLC_32BIT      = 0xF0,  /**< 40 bit code, carrying 32 bits payload */
+
+       VLC_TAG_FIRST  = 0xF1,  /**< First possible tag value. */
+       VLC_TAG_ICONST = 0xFB,  /**< Encodes an integer constant. */
+       VLC_TAG_EMPTY  = 0xFC,  /**< Encodes an empty entity. */
+       VLC_TAG_OPTION = 0xFD,  /**< Options exists. */
+       VLC_TAG_REF    = 0xFE,  /**< Special tag, next code is an ID. */
+       VLC_TAG_END    = 0xFF,  /**< End tag. */

 };
 
 /*
 };
 
 /*

- * An entry for patterns.
+ * An entry for holding one pattern.

  */
 typedef struct _pattern_entry_t {
  */
 typedef struct _pattern_entry_t {

-  counter_t   count;        /**< amount of pattern occurance */
-  unsigned    len;          /**< length of the VLC encoded buffer */
-  BYTE        buf[1];       /**< buffer contains the VLC encoded pattern */
+       counter_t   count;        /**< Amount of pattern occurance. */
+       unsigned    len;          /**< The length of the VLC encoded buffer. */
+       BYTE        buf[1];       /**< The buffer containing the VLC encoded pattern. */

 } pattern_entry_t;
 
 /**
 } pattern_entry_t;
 
 /**

- * current options
+ * Current options for the pattern matcher.

  */
 enum options_t {
  */
 enum options_t {

-  OPT_WITH_MODE   = 0x00000001, /**< use modes */
-  OPT_ENC_DAG     = 0x00000002, /**< encode DAGs, not terms */
-  OPT_WITH_ICONST = 0x00000004, /**< encode integer constants */
+       OPT_WITH_MODE       = 0x00000001, /**< use modes */
+       OPT_ENC_DAG         = 0x00000002, /**< encode DAGs, not terms */
+       OPT_WITH_ICONST     = 0x00000004, /**< encode integer constants */
+       OPT_PERSIST_PATTERN = 0x00000008, /**< persistant pattern hash */

 };
 
 
 /**
 };
 
 
 /**

- * pattern info
+ * Pattern info.

  */
 typedef struct _pattern_info_t {
  */
 typedef struct _pattern_info_t {

-  int                       enable;         /**< if non-zero, this module is enabled */
-  struct obstack            obst;           /**< obstack containing the counters */
-  HASH_MAP(pattern_entry_t) *pattern_hash;  /**< hash map containing the counter for pattern */
-  unsigned                  bound;          /**< lowest value for output */
-  unsigned                  options;        /**< option mask */
+       int                       enable;         /**< If non-zero, this module is enabled. */
+       struct obstack            obst;           /**< An obstack containing the counters. */
+       HASH_MAP(pattern_entry_t) *pattern_hash;  /**< A hash map containing the pattern. */
+       unsigned                  bound;          /**< Lowest value for pattern output. */
+       unsigned                  options;        /**< Current option mask. */

 } pattern_info_t;
 
 /*
 } pattern_info_t;
 
 /*


@@ -90,306 +91,347 @@ typedef struct _pattern_info_t {
 static pattern_info_t _status, *status = &_status;
 
 /**
 static pattern_info_t _status, *status = &_status;
 
 /**

- * compare two elements for counter
+ * Compare two pattern for its occurance counter.

  */
 static int pattern_count_cmp(const void *elt, const void *key)
 {
  */
 static int pattern_count_cmp(const void *elt, const void *key)
 {

-  int cmp;
+       int cmp;

 
 

-  pattern_entry_t **e1 = (pattern_entry_t **)elt;
-  pattern_entry_t **e2 = (pattern_entry_t **)key;
+       pattern_entry_t **e1 = (pattern_entry_t **)elt;
+       pattern_entry_t **e2 = (pattern_entry_t **)key;

 
 

-  /* we want it sorted in descending order */
-  cmp = cnt_cmp(&(*e2)->count, &(*e1)->count);
+       /* we want it sorted in descending order */
+       cmp = cnt_cmp(&(*e2)->count, &(*e1)->count);

 
 

-  return cmp;
-}
+       return cmp;
+}  /* pattern_count_cmp */

 
 /**
 
 /**

- * compare two elements of the pattern hash
+ * Compare two pattern for its pattern hash.

  */
 static int pattern_cmp(const void *elt, const void *key)
 {
  */
 static int pattern_cmp(const void *elt, const void *key)
 {

-  const pattern_entry_t *e1 = elt;
-  const pattern_entry_t *e2 = key;
-  int diff = e1->len - e2->len;
+       const pattern_entry_t *e1 = elt;
+       const pattern_entry_t *e2 = key;
+       int diff = e1->len - e2->len;

 
 

-  if (diff)
-    return diff;
+       if (diff)
+               return diff;

 
 

-  return memcmp(e1->buf, e2->buf, e1->len);
-}
+       return memcmp(e1->buf, e2->buf, e1->len);
+}  /* pattern_cmp */

 
 /**
 
 /**

- * initialize a code buffer
+ * Initialize a code buffer.
+ *
+ * @param buf   the code buffer
+ * @param data  a buffer address
+ * @param len   the length of the data buffer

  */
 static void init_buf(CODE_BUFFER *buf, BYTE *data, unsigned len)
 {
  */
 static void init_buf(CODE_BUFFER *buf, BYTE *data, unsigned len)
 {

-  buf->start = buf->next = data;
-  buf->end   = data + len;
-  buf->hash  = 0x2BAD4;
-}
+       buf->start = buf->next = data;
+       buf->end   = data + len;
+       buf->hash  = 0x2BAD4;      /* An arbitrary seed. */
+}  /* init_buf */

 
 /**
 
 /**

- * put a byte into the buffer
+ * Put a byte into the buffer.
+ *
+ * @param buf   the code buffer
+ * @param byte  the byte to write
+ *
+ * The hash value for the buffer content is updated.

  */
 static INLINE void put_byte(CODE_BUFFER *buf, unsigned byte)
 {
  */
 static INLINE void put_byte(CODE_BUFFER *buf, unsigned byte)
 {

-  if (buf->next < buf->end) {
-    unsigned hash = buf->hash;
+       if (buf->next < buf->end) {
+               unsigned hash = buf->hash;

 
 

-    hash = (hash * 9) ^ byte;
-    *buf->next++ = byte;
-    buf->hash    = hash;
-  }
-}
+               hash = (hash * 9) ^ byte;
+               *buf->next++ = byte;
+               buf->hash    = hash;
+       }  /* if */
+}  /* put_byte */

 
 /**
 
 /**

- * returns the current length of a buffer
+ * Returns the current length of a buffer.
+ *
+ * @param buf   the code buffer
+ *
+ * @return  the length of the buffer content

  */
 static unsigned buf_lenght(const CODE_BUFFER *buf)
 {
  */
 static unsigned buf_lenght(const CODE_BUFFER *buf)
 {

-  return buf->next - buf->start;
-}
+       return buf->next - buf->start;
+}  /* buf_lenght */

 
 /**
 
 /**

- * returns the current content of a buffer
+ * Returns the current content of a buffer.
+ *
+ * @param buf   the code buffer
+ *
+ * @return  the start address of the buffer content

  */
 static const BYTE *buf_content(const CODE_BUFFER *buf)
 {
  */
 static const BYTE *buf_content(const CODE_BUFFER *buf)
 {

-  return buf->start;
-}
+       return buf->start;
+}  /* buf_content */

 
 /**
 
 /**

- * returns the hash value of a buffer
+ * Returns the hash value of a buffer.
+ *
+ * @param buf   the code buffer
+ *
+ * @return  the hash value of the buffer content

  */
 static unsigned buf_hash(const CODE_BUFFER *buf)
 {
  */
 static unsigned buf_hash(const CODE_BUFFER *buf)
 {

-  return buf->hash;
-}
+       return buf->hash;
+}  /* buf_hash */

 
 /**
 
 /**

- * returns the next byte from the buffer WITHOUT dropping
+ * Returns the next byte from the buffer WITHOUT dropping.
+ *
+ * @param buf   the code buffer
+ *
+ * @return  the next byte from the code buffer

  */
 static INLINE BYTE look_byte(CODE_BUFFER *buf)
 {
  */
 static INLINE BYTE look_byte(CODE_BUFFER *buf)
 {

-  if (buf->next < buf->end)
-    return *buf->next;
-  return VLC_TAG_END;
-}
+       if (buf->next < buf->end)
+               return *buf->next;
+       return VLC_TAG_END;
+}  /* look_byte */

 
 /**
 
 /**

- * returns the next byte from the buffer WITH dropping
+ * Returns the next byte from the buffer WITH dropping.
+ *
+ * @param buf   the code buffer
+ *
+ * @return  the next byte from the code buffer

  */
 static INLINE BYTE get_byte(CODE_BUFFER *buf)
 {
  */
 static INLINE BYTE get_byte(CODE_BUFFER *buf)
 {

-  if (buf->next < buf->end)
-    return *buf->next++;
-  return VLC_TAG_END;
-}
+       if (buf->next < buf->end)
+               return *buf->next++;
+       return VLC_TAG_END;
+}  /* get_byte */

 
 #define BITS(n)   (1 << (n))
 
 /**
 
 #define BITS(n)   (1 << (n))
 
 /**

- * put a 32bit value into the buffer
+ * Put a 32bit value into the buffer.
+ *
+ * @param buf   the code buffer
+ * @param code  the code to be written into the buffer

  */
 static void put_code(CODE_BUFFER *buf, unsigned code)
 {
  */
 static void put_code(CODE_BUFFER *buf, unsigned code)
 {

-  if (code < BITS(7)) {
-    put_byte(buf, VLC_7BIT | code);
-  }
-  else if (code < BITS(6 + 8)) {
-    put_byte(buf, VLC_14BIT | (code >> 8));
-    put_byte(buf, code);
-  }
-  else if (code < BITS(5 + 8 + 8)) {
-    put_byte(buf, VLC_21BIT | (code >> 16));
-    put_byte(buf, code >> 8);
-    put_byte(buf, code);
-  }
-  else if (code < BITS(4 + 8 + 8 + 8)) {
-    put_byte(buf, VLC_28BIT | (code >> 24));
-    put_byte(buf, code >> 16);
-    put_byte(buf, code >> 8);
-    put_byte(buf, code);
-  }
-  else {
-    put_byte(buf, VLC_32BIT);
-    put_byte(buf, code >> 24);
-    put_byte(buf, code >> 16);
-    put_byte(buf, code >> 8);
-    put_byte(buf, code);
-  }
-}
+       if (code < BITS(7)) {
+               put_byte(buf, VLC_7BIT | code);
+       } else if (code < BITS(6 + 8)) {
+               put_byte(buf, VLC_14BIT | (code >> 8));
+               put_byte(buf, code);
+       } else if (code < BITS(5 + 8 + 8)) {
+               put_byte(buf, VLC_21BIT | (code >> 16));
+               put_byte(buf, code >> 8);
+               put_byte(buf, code);
+       } else if (code < BITS(4 + 8 + 8 + 8)) {
+               put_byte(buf, VLC_28BIT | (code >> 24));
+               put_byte(buf, code >> 16);
+               put_byte(buf, code >> 8);
+               put_byte(buf, code);
+       } else {
+               put_byte(buf, VLC_32BIT);
+               put_byte(buf, code >> 24);
+               put_byte(buf, code >> 16);
+               put_byte(buf, code >> 8);
+               put_byte(buf, code);
+       }  /* if */
+}  /* put_code */

 
 #define BIT_MASK(n) ((1 << (n)) - 1)
 
 /**
 
 #define BIT_MASK(n) ((1 << (n)) - 1)
 
 /**

- * get 32 bit from the buffer
+ * Get 32 bit from the buffer.
+ *
+ * @param buf   the code buffer
+ *
+ * @return  next 32bit value from the code buffer

  */
 static unsigned get_code(CODE_BUFFER *buf)
 {
  */
 static unsigned get_code(CODE_BUFFER *buf)
 {

-  unsigned code = get_byte(buf);
-
-  if (code < VLC_14BIT)
-    return code;
-  if (code < VLC_21BIT)
-    return ((code & BIT_MASK(6)) << 8) | get_byte(buf);
-  if (code < VLC_28BIT) {
-    code  = ((code & BIT_MASK(5)) << 16) | (get_byte(buf) << 8);
-    code |= get_byte(buf);
-    return code;
-  }
-  if (code < VLC_32BIT) {
-    code  = ((code & BIT_MASK(4)) << 24) | (get_byte(buf) << 16);
-    code |= get_byte(buf) <<  8;
-    code |= get_byte(buf);
-    return code;
-  }
-  if (code == VLC_32BIT) {
-    code  = get_byte(buf) << 24;
-    code |= get_byte(buf) << 16;
-    code |= get_byte(buf) <<  8;
-    code |= get_byte(buf);
-    return code;
-  }
-  /* should not happen */
-  assert(0 && "Wrong code in buffer");
-
-  return 0;
-}
+       unsigned code = get_byte(buf);
+
+       if (code < VLC_14BIT)
+               return code;
+       if (code < VLC_21BIT)
+               return ((code & BIT_MASK(6)) << 8) | get_byte(buf);
+       if (code < VLC_28BIT) {
+               code  = ((code & BIT_MASK(5)) << 16) | (get_byte(buf) << 8);
+               code |= get_byte(buf);
+               return code;
+       }  /* if */
+       if (code < VLC_32BIT) {
+               code  = ((code & BIT_MASK(4)) << 24) | (get_byte(buf) << 16);
+               code |= get_byte(buf) <<  8;
+               code |= get_byte(buf);
+               return code;
+       }  /* if */
+       if (code == VLC_32BIT) {
+               code  = get_byte(buf) << 24;
+               code |= get_byte(buf) << 16;
+               code |= get_byte(buf) <<  8;
+               code |= get_byte(buf);
+               return code;
+       }  /* if */
+       /* should not happen */
+       assert(0 && "Wrong code in buffer");
+
+       return 0;
+}  /* get_code */

 
 /**
 
 /**

- * put a tag into the buffer
+ * Put a tag into the buffer.
+ *
+ * @param buf   the code buffer
+ * @param tag   the tag to write to the code buffer

  */
 static void put_tag(CODE_BUFFER *buf, BYTE tag)
 {
  */
 static void put_tag(CODE_BUFFER *buf, BYTE tag)
 {

-  assert(tag >= VLC_TAG_FIRST && "invalid tag");
+       assert(tag >= VLC_TAG_FIRST && "invalid tag");

 
 

-  put_byte(buf, tag);
-}
+       put_byte(buf, tag);
+}  /* put_tag */

 
 /**
 
 /**

- * returns the next tag or zero if the next code isn't a tag
+ * Returns the next tag or zero if the next code isn't a tag.
+ *
+ * @param buf   the code buffer
+ *
+ * @return the next tag in the code buffer

  */
 static BYTE next_tag(CODE_BUFFER *buf)
 {
  */
 static BYTE next_tag(CODE_BUFFER *buf)
 {

-  BYTE b = look_byte(buf);
+       BYTE b = look_byte(buf);

 
 

-  if (b >= VLC_TAG_FIRST)
-    return get_byte(buf);
-  return 0;
-}
+       if (b >= VLC_TAG_FIRST)
+               return get_byte(buf);
+       return 0;
+}  /* next_tag */

 
 /**
 
 /**

- * environment for the pattern encoder
+ * An Environment for the pattern encoder.

  */
 typedef struct _codec_enc_t {
  */
 typedef struct _codec_enc_t {

-  CODE_BUFFER      *buf;      /**< the code buffer */
-  set              *id_set;   /**< the set containing all already seen nodes */
-  unsigned         curr_id;   /**< current node id */
-  unsigned         options;   /**< encoding options */
-  pattern_dumper_t *dmp;      /**< dumper for the decoder */
+       CODE_BUFFER      *buf;      /**< The current code buffer. */
+       set              *id_set;   /**< A set containing all already seen Firm nodes. */
+       unsigned         curr_id;   /**< The current node id. */
+       unsigned         options;   /**< The encoding options. */
+       pattern_dumper_t *dmp;      /**< The dumper for the decoder. */

 } codec_env_t;
 
 } codec_env_t;
 

+/**
+ * An address entry.
+ */

 typedef struct _addr_entry_t {
 typedef struct _addr_entry_t {

-  void *addr;     /**< the address */
-  unsigned id;    /**< associated ID */
+       void *addr;     /**< the address */
+       unsigned id;    /**< associated ID */

 } addr_entry_t;
 
 /**
 } addr_entry_t;
 
 /**

- * compare two addresses
+ * Compare two addresses.

  */
 static int addr_cmp(const void *p1, const void *p2, size_t size) {
  */
 static int addr_cmp(const void *p1, const void *p2, size_t size) {

-  const addr_entry_t *e1 = p1;
-  const addr_entry_t *e2 = p2;
+       const addr_entry_t *e1 = p1;
+       const addr_entry_t *e2 = p2;

 
 

-  return e1->addr != e2->addr;
-}
+       return e1->addr != e2->addr;
+}  /* addr_cmp */

 
 /**
 
 /**

- * encodes an IR-node, recursive worker
+ * Encodes an IR-node, recursive worker.

  *
  * @return reached depth
  */
 static int _encode_node(ir_node *node, int max_depth, codec_env_t *env)
 {
  *
  * @return reached depth
  */
 static int _encode_node(ir_node *node, int max_depth, codec_env_t *env)
 {

-  addr_entry_t entry, *r_entry;
-  set_entry *s_entry;
-  int i, preds;
-  int res, depth;
-
-  opcode code = get_irn_opcode(node);
-
-  /* insert the node into our ID map */
-  entry.addr = node;
-  entry.id   = env->curr_id;
-
-  s_entry = set_hinsert(env->id_set, &entry, sizeof(entry), HASH_PTR(node));
-  r_entry = (addr_entry_t *)s_entry->dptr;
-
-  if (r_entry->id != env->curr_id) {
-    /* already in the map, add an REF */
-    put_tag(env->buf, VLC_TAG_REF);
-    put_code(env->buf, r_entry->id);
-
-    return max_depth;
-  }
-  else {
-    /* a new entry, proceed */
-    ++env->curr_id;
-  }
-
-  put_code(env->buf, (unsigned)code);
-
-  /* do we need the mode ? */
-  if (env->options & OPT_WITH_MODE) {
-    ir_mode *mode = get_irn_mode(node);
-
-    if (mode)
-      /* FIXME: not 64bit save */
-      put_code(env->buf, (unsigned)mode);
-    else
-      put_tag(env->buf, VLC_TAG_EMPTY);
-  }
-
-  /* do we need integer constants */
-  if (env->options & OPT_WITH_ICONST) {
-    if (code == iro_Const) {
-      tarval *tv = get_Const_tarval(node);
-
-      if (tarval_is_long(tv)) {
-        long v = get_tarval_long(tv);
-
-        put_tag(env->buf, VLC_TAG_ICONST);
-        put_code(env->buf, v);
-      }
-    }
-  }
-
-  --max_depth;
-
-  if (max_depth <= 0) {
-    put_code(env->buf, 0);
-    return max_depth;
-  }
-
-  preds = get_irn_arity(node);
-  put_code(env->buf, preds);
-
-  res = INT_MAX;
-  for (i = 0; i < preds; ++i) {
-    ir_node *n = get_irn_n(node, i);
-
-    depth = _encode_node(n, max_depth, env);
-    if (depth < res)
-      res = depth;
-  }
-  return res;
-}
+       addr_entry_t entry, *r_entry;
+       set_entry *s_entry;
+       int i, preds;
+       int res, depth;
+
+       opcode code = get_irn_opcode(node);
+
+       /* insert the node into our ID map */
+       entry.addr = node;
+       entry.id   = env->curr_id;
+
+       s_entry = set_hinsert(env->id_set, &entry, sizeof(entry), HASH_PTR(node));
+       r_entry = (addr_entry_t *)s_entry->dptr;
+
+       if (r_entry->id != env->curr_id) {
+               /* already in the map, add an REF */
+               put_tag(env->buf, VLC_TAG_REF);
+               put_code(env->buf, r_entry->id);
+
+               return max_depth;
+       } else {
+               /* a new entry, proceed */
+               ++env->curr_id;
+       }  /* if */
+
+       put_code(env->buf, (unsigned)code);
+
+       /* do we need the mode ? */
+       if (env->options & OPT_WITH_MODE) {
+               ir_mode *mode = get_irn_mode(node);
+
+               if (mode)
+                       /* FIXME: not 64bit save */
+                       put_code(env->buf, (unsigned)mode);
+               else
+                       put_tag(env->buf, VLC_TAG_EMPTY);
+       }  /* if */
+
+       /* do we need integer constants */
+       if (env->options & OPT_WITH_ICONST) {
+               if (code == iro_Const) {
+                       tarval *tv = get_Const_tarval(node);
+
+                       if (tarval_is_long(tv)) {
+                               long v = get_tarval_long(tv);
+
+                               put_tag(env->buf, VLC_TAG_ICONST);
+                               put_code(env->buf, v);
+                       }  /* if */
+               }  /* if */
+       }  /* if */
+
+       --max_depth;
+
+       if (max_depth <= 0) {
+               put_code(env->buf, 0);
+               return max_depth;
+       } /* if */
+
+       preds = get_irn_arity(node);
+       put_code(env->buf, preds);
+
+       res = INT_MAX;
+       for (i = 0; i < preds; ++i) {
+               ir_node *n = get_irn_n(node, i);
+
+               depth = _encode_node(n, max_depth, env);
+               if (depth < res)
+                       res = depth;
+       }  /* for */
+       return res;
+}  /* _encode_node */

 
 /**
 
 /**

- * encode a DAG staring by the IR-node node
+ * Encode a DAG staring by the IR-node node.

  *
  * @param node       The root node of the graph
  * @param buf        The code buffer to store the bitstring in
  *
  * @param node       The root node of the graph
  * @param buf        The code buffer to store the bitstring in


@@ -399,302 +441,404 @@ static int _encode_node(ir_node *node, int max_depth, codec_env_t *env)
  */
 static int encode_node(ir_node *node, CODE_BUFFER *buf, int max_depth)
 {
  */
 static int encode_node(ir_node *node, CODE_BUFFER *buf, int max_depth)
 {

-  codec_env_t env;
-  int         res;
+       codec_env_t env;
+       int         res;

 
 

-  env.buf     = buf;
-  env.curr_id = 1;  /* 0 is used for special purpose */
-  env.options = status->options;
-  env.dmp     = NULL;
+       /* initialize the encoder environment */
+       env.buf     = buf;
+       env.curr_id = 1;  /* 0 is used for special purpose */
+       env.options = status->options;
+       env.dmp     = NULL;

 
 

-  if (env.options & OPT_ENC_DAG)
-    env.id_set = new_set(addr_cmp, 32);
-  else
-    env.id_set = NULL;
+       if (env.options & OPT_ENC_DAG)
+               env.id_set = new_set(addr_cmp, 32);
+       else
+               env.id_set = NULL;

 
 

-  /* encode options if any */
-  if (env.options) {
-    put_tag(buf, VLC_TAG_OPTION);
-    put_code(buf, env.options);
-  }
+       /* encode options if any for the decoder */
+       if (env.options) {
+               put_tag(buf, VLC_TAG_OPTION);
+               put_code(buf, env.options);
+       }  /* if */

 
 

-  res = _encode_node(node, max_depth, &env);
+       res = _encode_node(node, max_depth, &env);

 
 

-  if (env.options & OPT_ENC_DAG)
-    del_set(env.id_set);
+       if (env.id_set != NULL)
+               del_set(env.id_set);

 
 

-  return max_depth - res;
-}
+       return max_depth - res;
+}  /* encode_node */

 
 /**
 
 /**

- * decode an IR-node, recursive walker
+ * Decode an IR-node, recursive walker.

  */
 static void _decode_node(unsigned parent, int position, codec_env_t *env)
 {
  */
 static void _decode_node(unsigned parent, int position, codec_env_t *env)
 {

-  unsigned code;
-  unsigned op_code;
-  unsigned mode_code = 0;
-  long iconst;
-  void *attr = NULL;
-
-  code = next_tag(env->buf);
-  if (code == VLC_TAG_REF) { /* it's a REF */
-    code = get_code(env->buf);
-
-    /* dump the edge */
-    if (parent) {
-      int edge_mode = 0;
-      /*
-       * the mode of a Firm edge can be either computed from its target or
-       * from its source and position. We must take the second approach because
-       * we dont know the target here, it's a ref.
-       */
-      pattern_dump_edge(env->dmp, code, parent, position, edge_mode);
-    }
-
-    /* dump the node ref */
-    pattern_dump_ref(env->dmp, code);
-
-    return;
-  }
-
-  /* get the opcode */
-  op_code = get_code(env->buf);
-
-  /* get the mode if encoded */
-  if (env->options & OPT_WITH_MODE) {
-    if (next_tag(env->buf) != VLC_TAG_EMPTY) {
-      mode_code = get_code(env->buf);
-    }
-  }
-
-  /* check, if a ICONST attribute is given */
-  if (next_tag(env->buf) == VLC_TAG_ICONST) {
-    iconst = get_code(env->buf);
-    attr   = &iconst;
-  }
-
-  /* dump the edge */
-  if (parent) {
-    int edge_mode = 0;
-
-    /*
-     * the mode of a Firm edge can be either computed from its target or
-     * from its source and position. We take the second approach because
-     * we need it anyway for ref's.
-     */
-    pattern_dump_edge(env->dmp, env->curr_id, parent, position, edge_mode);
-  }
-
-  /* dump the node */
-  parent = env->curr_id;
-  pattern_dump_node(env->dmp, parent, op_code, mode_code, attr);
-
-  /* ok, we have a new ID */
-  ++env->curr_id;
-
-  code = next_tag(env->buf);
-  if (code != VLC_TAG_END) {
-    /* more info, do recursion */
-    int i, preds;
-
-    preds = get_code(env->buf);
-    if (preds > 0) {
-      pattern_start_children(env->dmp, parent);
-      for (i = 0; i < preds; ++i) {
-       _decode_node(parent, i, env);
-      }
-      pattern_finish_children(env->dmp, parent);
-    }
-  }
-}
+       unsigned code;
+       unsigned op_code;
+       unsigned mode_code = 0;
+       long iconst;
+       void *attr = NULL;
+
+       code = next_tag(env->buf);
+       if (code == VLC_TAG_REF) { /* it's a REF */
+               code = get_code(env->buf);
+
+               /* dump the edge */
+               if (parent) {
+                       int edge_mode = 0;
+                       /*
+                        * the mode of a Firm edge can be either computed from its target or
+                        * from its source and position. We must take the second approach because
+                        * we dont know the target here, it's a ref.
+                        */
+                       pattern_dump_edge(env->dmp, code, parent, position, edge_mode);
+               }  /* if */
+
+               /* dump the node ref */
+               pattern_dump_ref(env->dmp, code);
+
+               return;
+       }  /* if */
+
+       /* get the opcode */
+       op_code = get_code(env->buf);
+
+       /* get the mode if encoded */
+       if (env->options & OPT_WITH_MODE) {
+               if (next_tag(env->buf) != VLC_TAG_EMPTY) {
+                       mode_code = get_code(env->buf);
+               }  /* if */
+       }  /* if */
+
+       /* check, if a ICONST attribute is given */
+       if (next_tag(env->buf) == VLC_TAG_ICONST) {
+               iconst = get_code(env->buf);
+               attr   = &iconst;
+       }  /* if */
+
+       /* dump the edge */
+       if (parent) {
+               int edge_mode = 0;
+
+               /*
+                * the mode of a Firm edge can be either computed from its target or
+                * from its source and position. We take the second approach because
+                * we need it anyway for ref's.
+                */
+               pattern_dump_edge(env->dmp, env->curr_id, parent, position, edge_mode);
+       }  /* if */
+
+       /* dump the node */
+       parent = env->curr_id;
+       pattern_dump_node(env->dmp, parent, op_code, mode_code, attr);
+
+       /* ok, we have a new ID */
+       ++env->curr_id;
+
+       code = next_tag(env->buf);
+       if (code != VLC_TAG_END) {
+               /* more info, do recursion */
+               int i, preds;
+
+               preds = get_code(env->buf);
+               if (preds > 0) {
+                       pattern_start_children(env->dmp, parent);
+                       for (i = 0; i < preds; ++i) {
+                               _decode_node(parent, i, env);
+                       }  /* for */
+                       pattern_finish_children(env->dmp, parent);
+               }  /* if */
+       }  /* if */
+}  /* _decode_node */

 
 /**
 
 /**

- * decode an IR-node
+ * Decode an IR-node.

  */
 static void decode_node(BYTE *b, unsigned len, pattern_dumper_t *dump)
 {
  */
 static void decode_node(BYTE *b, unsigned len, pattern_dumper_t *dump)
 {

-  codec_env_t env;
-  CODE_BUFFER buf;
-  unsigned code, options = 0;
+       codec_env_t env;
+       CODE_BUFFER buf;
+       unsigned code, options = 0;

 
 

-  init_buf(&buf, b, len);
+       init_buf(&buf, b, len);

 
 

-  env.buf     = &buf;
-  env.curr_id = 1;  /* 0 is used for special purpose */
-  env.dmp     = dump;
+       env.buf     = &buf;
+       env.curr_id = 1;  /* 0 is used for special purpose */
+       env.dmp     = dump;

 
 

-  /* decode options */
-  code = next_tag(&buf);
-  if (code == VLC_TAG_OPTION) {
-    options = get_code(&buf);
-  }
-  env.options = options;
+       /* decode options */
+       code = next_tag(&buf);
+       if (code == VLC_TAG_OPTION) {
+               options = get_code(&buf);
+       }  /* if */
+       env.options = options;

 
 

-  _decode_node(0, 0, &env);
-}
+       _decode_node(0, 0, &env);
+}  /* decode_node */

 
 /**
 
 /**

- * the environment for the pattern calculation
+ * The environment for the pattern calculation.

  */
 typedef struct _pattern_env {
  */
 typedef struct _pattern_env {

-  int max_depth;    /**< maximum depth for pattern generation */
+       int max_depth;    /**< maximum depth for pattern generation. */

 } pattern_env_t;
 
 /**
 } pattern_env_t;
 
 /**

- * Returns the associates pattern_entry_t for a CODE_BUF
+ * Returns the associates pattern_entry_t for a CODE_BUF.

  *
  * @param buf  the code buffer
  * @param set  the hash table containing all pattern entries
  *
  * @param buf  the code buffer
  * @param set  the hash table containing all pattern entries

+ *
+ * @return   the associated pattern_entry_t for the given code buffer
+ *
+ * If the code content was never seen before, a new pattern_entry is created
+ * and returned.

  */
 static pattern_entry_t *pattern_get_entry(CODE_BUFFER *buf, pset *set)
 {
  */
 static pattern_entry_t *pattern_get_entry(CODE_BUFFER *buf, pset *set)
 {

-  pattern_entry_t *key, *elem;
-  unsigned len = buf_lenght(buf);
-  unsigned hash;
+       pattern_entry_t *key, *elem;
+       unsigned len = buf_lenght(buf);
+       unsigned hash;

 
 

-  key = obstack_alloc(&status->obst, sizeof(*key) + len - 1);
-  assert(key);
+       key = obstack_alloc(&status->obst, sizeof(*key) + len - 1);
+       assert(key);

 
 

-  key->len = len;
-  memcpy(key->buf, buf_content(buf), len);
+       key->len = len;
+       memcpy(key->buf, buf_content(buf), len);

 
 

-  hash = buf_hash(buf);
+       hash = buf_hash(buf);

 
 

-  elem = pset_find(set, key, hash);
-  if (elem) {
-    obstack_free(&status->obst, key);
-    return elem;
-  }
+       elem = pset_find(set, key, hash);
+       if (elem != NULL) {
+               obstack_free(&status->obst, key);
+               return elem;
+       }  /* if */

 
 

-  cnt_clr(&key->count);
-  return pset_insert(set, key, hash);
-}
+       cnt_clr(&key->count);
+       return pset_insert(set, key, hash);
+}  /* pattern_get_entry */

 
 /**
 
 /**

- * count a pattern
+ * Increase the count for a pattern.
+ *
+ * @param buf    the code buffer containing the pattern
+ * @param depth  the pattern depth
+ *
+ * @note Single node patterns are ignored

  */
 static void count_pattern(CODE_BUFFER *buf, int depth) {
  */
 static void count_pattern(CODE_BUFFER *buf, int depth) {

-  pattern_entry_t *entry;
+       pattern_entry_t *entry;

 
 

-  /* ignore single node pattern (i.e. constants) */
-  if (depth > 1) {
-    entry = pattern_get_entry(buf, status->pattern_hash);
+       /* ignore single node pattern (i.e. constants) */
+       if (depth > 1) {
+               entry = pattern_get_entry(buf, status->pattern_hash);

 
 

-    /* increase count */
-    cnt_inc(&entry->count);
-  }
-}
+               /* increase count */
+               cnt_inc(&entry->count);
+       }  /* if */
+}  /* count_pattern */

 
 /**
 
 /**

- * pre-walker for nodes pattern calculation
+ * Pre-walker for nodes pattern calculation.

  */
 static void calc_nodes_pattern(ir_node *node, void *ctx)
 {
  */
 static void calc_nodes_pattern(ir_node *node, void *ctx)
 {

-  BYTE            buffer[1024];
-  pattern_env_t   *env = ctx;
-  CODE_BUFFER     buf;
-  int             depth;
+       BYTE            buffer[1024];
+       pattern_env_t   *env = ctx;
+       CODE_BUFFER     buf;
+       int             depth;

 
 

-  init_buf(&buf, buffer, sizeof(buffer));
-  depth = encode_node(node, &buf, env->max_depth);
+       init_buf(&buf, buffer, sizeof(buffer));
+       depth = encode_node(node, &buf, env->max_depth);

 
 

-  count_pattern(&buf, depth);
-}
+       count_pattern(&buf, depth);
+}  /* calc_nodes_pattern */

 
 /**
 
 /**

- * output the collected pattern
+ * Store all collected patterns.
+ *
+ * @param fname  filename for storage

  */
  */

-static void pattern_output(void)
+static void store_pattern(const char *fname)

 {
 {

-  pattern_entry_t  *entry;
-  pattern_entry_t  **pattern_arr;
-  pattern_dumper_t *dump;
-  int i, count = pset_count(status->pattern_hash);
-
-  printf("\n%d pattern detected\n", count);
-
-  if (count <= 0)
-    return;
-
-  /* creates a dumper */
-  dump = new_vcg_dumper("pattern.vcg", 100);
-
-  pattern_arr = xmalloc(sizeof(*pattern_arr) * count);
-  for (i = 0, entry = pset_first(status->pattern_hash);
-       entry && i < count;
-       entry = pset_next(status->pattern_hash), ++i) {
-    pattern_arr[i] =  entry;
-  }
-  assert(count == i);
-  count = i;
-
-  /* sort it */
-  qsort(pattern_arr, count, sizeof(*pattern_arr), pattern_count_cmp);
-
-  for (i = 0; i < count; ++i) {
-    entry = pattern_arr[i];
-    if (cnt_to_uint(&entry->count) < status->bound)
-      continue;
-
-    /* dump a pattern */
-    pattern_dump_new_pattern(dump, &entry->count);
-    decode_node(entry->buf, entry->len, dump);
-    pattern_dump_finish_pattern(dump);
-  }
-
-  /* destroy it */
-  pattern_end(dump);
-}
+       FILE *f;
+       pattern_entry_t *entry;
+       int i, count = pset_count(status->pattern_hash);
+
+       if (count <= 0)
+               return;
+
+       f = fopen(fname, "wb");
+       if (! f) {
+               perror(fname);
+               return;
+       }  /* if */
+
+       fwrite("FPS1", 4, 1, f);
+       fwrite(&count, sizeof(count), 1, f);
+
+       for (i = 0, entry = pset_first(status->pattern_hash);
+            entry && i < count;
+            entry = pset_next(status->pattern_hash), ++i) {
+               fwrite(entry, sizeof(*entry) + (entry->len - 1), 1, f);
+       }  /* for */
+
+       fclose(f);
+}  /* store_pattern */
+
+/**
+ * Read collected patterns from a file.
+ *
+ * @param fname  filename
+ */
+static HASH_MAP(pattern_entry_t) *read_pattern(const char *fname)
+{
+       FILE *f;
+       pattern_entry_t *entry, tmp;
+       int i, count;
+       unsigned j;
+       char magic[4];
+       HASH_MAP(pattern_entry_t) *pattern_hash = new_pset(pattern_cmp, 8);
+       BYTE            buffer[1024];
+       CODE_BUFFER     buf;
+
+       f = fopen(fname, "rb");
+       if (! f) {
+               perror(fname);
+               return NULL;
+       }  /* if */
+
+       fread(magic, 4, 1, f);
+       count = 0;
+       fread(&count, sizeof(count), 1, f);
+       if (memcmp(magic, "FPS1", 4) != 0 || count <= 0) {
+               fprintf(stderr, "Error: %s is not a Firm pattern store. Ignored.\n", fname);
+               fclose(f);
+               return NULL;
+       }  /* if */
+
+
+       /* read all pattern entries and put them into the hash table. */
+       for (i = 0; i < count; ++i) {
+               init_buf(&buf, buffer, sizeof(buffer));
+               fread(&tmp, sizeof(tmp), 1, f);
+               put_byte(&buf, tmp.buf[0]);
+               for (j = 1; j < tmp.len; ++j)
+                       put_byte(&buf, fgetc(f));
+               entry = pattern_get_entry(&buf, pattern_hash);
+               memcpy(&entry->count, &tmp.count, sizeof(entry->count));
+       }  /* for */
+
+       fclose(f);
+
+       printf("Read %d pattern from %s\n", pset_count(pattern_hash), fname);
+
+       return pattern_hash;
+}  /* read_pattern */
+
+/**
+ * Write the collected patterns to a VCG file for inspection.
+ *
+ * @param fname  name of the VCG file to create
+ */
+static void pattern_output(const char *fname)
+{
+       pattern_entry_t  *entry;
+       pattern_entry_t  **pattern_arr;
+       pattern_dumper_t *dump;
+       int i, count = pset_count(status->pattern_hash);
+
+       printf("\n%d pattern detected\n", count);
+
+       if (count <= 0)
+               return;
+
+       /* creates a dumper */
+       dump = new_vcg_dumper(fname, 100);
+
+       pattern_arr = xmalloc(sizeof(*pattern_arr) * count);
+       for (i = 0, entry = pset_first(status->pattern_hash);
+            entry && i < count;
+            entry = pset_next(status->pattern_hash), ++i) {
+               pattern_arr[i] =  entry;
+       }  /* for */
+       assert(count == i);
+       count = i;
+
+       /* sort it */
+       qsort(pattern_arr, count, sizeof(*pattern_arr), pattern_count_cmp);
+
+       for (i = 0; i < count; ++i) {
+               entry = pattern_arr[i];
+               if (cnt_to_uint(&entry->count) < status->bound)
+                       continue;
+
+               /* dump a pattern */
+               pattern_dump_new_pattern(dump, &entry->count);
+               decode_node(entry->buf, entry->len, dump);
+               pattern_dump_finish_pattern(dump);
+       }  /* for */
+
+       /* destroy it */
+       pattern_end(dump);
+}  /* pattern_output */

 
 /*
 
 /*

- * calculates the pattern history
+ * Calculates the pattern history.

  */
 void stat_calc_pattern_history(ir_graph *irg)
 {
  */
 void stat_calc_pattern_history(ir_graph *irg)
 {

-  pattern_env_t env;
+       pattern_env_t env;

 
 

-  if (! status->enable)
-    return;
+       if (! status->enable)
+               return;

 
 

-  /* do NOT count the const code IRG */
-  if (irg == get_const_code_irg())
-    return;
+       /* do NOT count the const code IRG */
+       if (irg == get_const_code_irg())
+               return;

 
 

-  env.max_depth = 5;
-  irg_walk_graph(irg, calc_nodes_pattern, NULL, &env);
-}
+       env.max_depth = 5;
+       irg_walk_graph(irg, calc_nodes_pattern, NULL, &env);
+}  /* stat_calc_pattern_history */

 
 /*
 
 /*

- * initializes the pattern history
+ * Initializes the pattern history.

  */
 void stat_init_pattern_history(int enable)
 {
  */
 void stat_init_pattern_history(int enable)
 {

-  status->enable = enable;
-  if (! enable)
-    return;
+       HASH_MAP(pattern_entry_t) *pattern_hash = NULL;
+
+       status->enable = enable;
+       if (! enable)
+               return;

 
 

-  status->bound   = 10;
-  status->options = OPT_WITH_MODE | OPT_ENC_DAG | OPT_WITH_ICONST;
+       status->bound   = 10;
+       status->options = OPT_WITH_MODE | OPT_ENC_DAG | OPT_WITH_ICONST | OPT_PERSIST_PATTERN;

 
 

-  obstack_init(&status->obst);
+       obstack_init(&status->obst);

 
 

-  /* create the hash-table */
-  status->pattern_hash = new_pset(pattern_cmp, 8);
-}
+       /* create the hash-table */
+       if (status->options & OPT_PERSIST_PATTERN)
+               pattern_hash = read_pattern("pattern.fps");
+       if (pattern_hash == NULL)
+               pattern_hash = new_pset(pattern_cmp, 8);
+       status->pattern_hash = pattern_hash;
+}  /* stat_init_pattern_history */

 
 /*
 
 /*

- * finishes the pattern history
+ * Finish the pattern history.

  */
 void stat_finish_pattern_history(void)
 {
  */
 void stat_finish_pattern_history(void)
 {

-  if (! status->enable)
-    return;
+       if (! status->enable)
+               return;

 
 

-  pattern_output();
+       store_pattern("pattern.fps");
+       pattern_output("pattern.vcg");

 
 

-  del_pset(status->pattern_hash);
-  obstack_free(&status->obst, NULL);
+       del_pset(status->pattern_hash);
+       obstack_free(&status->obst, NULL);

 
 

-  status->enable = 0;
-}
+       status->enable = 0;
+}  /* stat_finish_pattern_history */

diff --git a/ir/stat/pattern.h b/ir/stat/pattern.h
index 7db8aff..eefd7a7 100644 (file)
--- a/ir/stat/pattern.h
+++ b/ir/stat/pattern.h
@@ -18,21 +18,21 @@
  */
 
 /**
  */
 
 /**

- * calculates the pattern history.
+ * Calculates the pattern history.

  *
  * @param irg    The IR-graph
  */
 void stat_calc_pattern_history(ir_graph *irg);
 
 /**
  *
  * @param irg    The IR-graph
  */
 void stat_calc_pattern_history(ir_graph *irg);
 
 /**

- * initializes the pattern history.
+ * Initializes the pattern history.

  *
  * @param enable  Enable flag.
  */
 void stat_init_pattern_history(int enable);
 
 /**
  *
  * @param enable  Enable flag.
  */
 void stat_init_pattern_history(int enable);
 
 /**

- * finishes the pattern history
+ * Finish the pattern history.

  */
 void stat_finish_pattern_history(void);
 
  */
 void stat_finish_pattern_history(void);
 

diff --git a/ir/stat/pattern_dmp.c b/ir/stat/pattern_dmp.c
index 3fb3f18..bc59452 100644 (file)
--- a/ir/stat/pattern_dmp.c
+++ b/ir/stat/pattern_dmp.c
@@ -39,370 +39,369 @@ typedef void (*DUMP_END_FUNC)(pattern_dumper_t *self);
  * the pattern dumper
  */
 struct _pattern_dumper_t {
  * the pattern dumper
  */
 struct _pattern_dumper_t {

-  DUMP_NEW_PATTERN_FUNC      dump_new_pattern;
-  DUMP_FINISH_PATTERN_FUNC   dump_finish_pattern;
-  DUMP_NODE_FUNC             dump_node;
-  DUMP_REF_FUNC              dump_ref;
-  DUMP_EDGE_FUNC             dump_edge;
-  DUMP_START_CHILDREN_FUNC   dump_start_children;
-  DUMP_FINISH_CHILDREN_FUNC  dump_finish_children;
-  DUMP_START_FUNC            dump_start;
-  DUMP_END_FUNC              dump_end;
-  void                       *data;
+       DUMP_NEW_PATTERN_FUNC      dump_new_pattern;
+       DUMP_FINISH_PATTERN_FUNC   dump_finish_pattern;
+       DUMP_NODE_FUNC             dump_node;
+       DUMP_REF_FUNC              dump_ref;
+       DUMP_EDGE_FUNC             dump_edge;
+       DUMP_START_CHILDREN_FUNC   dump_start_children;
+       DUMP_FINISH_CHILDREN_FUNC  dump_finish_children;
+       DUMP_START_FUNC            dump_start;
+       DUMP_END_FUNC              dump_end;
+       void                       *data;

 };
 
 /**
  * VCG private data
  */
 typedef struct _vcg_private_t {
 };
 
 /**
  * VCG private data
  */
 typedef struct _vcg_private_t {

-  FILE     *f;                 /**< file to dump to */
-  unsigned pattern_id;         /**< ID of the pattern */
-  unsigned max_pattern;                /**< maximum number of pattern to be dumped */
+       FILE     *f;          /**< file to dump to */
+       unsigned pattern_id;  /**< ID of the pattern */
+       unsigned max_pattern; /**< maximum number of pattern to be dumped */

 } vcg_private_t;
 
 /**
 } vcg_private_t;
 
 /**

- * starts a new VCG graph
+ * Starts a new VCG graph.

  */
 static void vcg_dump_start(pattern_dumper_t *self)
 {
  */
 static void vcg_dump_start(pattern_dumper_t *self)
 {

-  vcg_private_t *priv = self->data;
-
-  fprintf(priv->f,
-    "graph: { title: \"Most found pattern\"\n"
-    "  display_edge_labels: no\n"
-    "  layoutalgorithm: mindepth\n"
-    "  manhattan_edges: yes\n"
-    "  port_sharing: no\n"
-    "  orientation: bottom_to_top\n"
-  );
-}
+       vcg_private_t *priv = self->data;
+
+       fprintf(priv->f,
+               "graph: { title: \"Most found pattern\"\n"
+               "  display_edge_labels: no\n"
+               "  layoutalgorithm: mindepth\n"
+               "  manhattan_edges: yes\n"
+               "  port_sharing: no\n"
+               "  orientation: bottom_to_top\n"
+               );
+}  /* vcg_dump_start */

 
 /**
 
 /**

- * ends a new VCG graph
+ * Ends a new VCG graph.

  */
 static void vcg_dump_end(pattern_dumper_t *self)
 {
  */
 static void vcg_dump_end(pattern_dumper_t *self)
 {

-  vcg_private_t *priv = self->data;
+       vcg_private_t *priv = self->data;

 
 

-  fprintf(priv->f, "}\n");
-  fclose(priv->f);
-}
+       fprintf(priv->f, "}\n");
+       fclose(priv->f);
+} /* vcg_dump_end */

 
 

-/*
- * starts a new pattern
+/**
+ * Starts a new pattern.

  */
 static void vcg_dump_new_pattern(pattern_dumper_t *self, counter_t *cnt)
 {
  */
 static void vcg_dump_new_pattern(pattern_dumper_t *self, counter_t *cnt)
 {

-  vcg_private_t *priv = self->data;
-  static unsigned nr = 0;
+       vcg_private_t *priv = self->data;
+       static unsigned nr = 0;

 
 

-  if (priv->pattern_id > priv->max_pattern)
-    return;
+       if (priv->pattern_id > priv->max_pattern)
+               return;

 
 

-  fprintf(priv->f,
-    "  graph: { title: \"g%u\" label: \"pattern %u\" status:clustered color:yellow\n",
-    priv->pattern_id, priv->pattern_id );
+       fprintf(priv->f,
+               "  graph: { title: \"g%u\" label: \"pattern %u\" status:clustered color:yellow\n",
+               priv->pattern_id, priv->pattern_id );

 
 

-  /** add a pseudo node */
-  fprintf(priv->f,
-    "     node: {title: \"c%u\" label: \"cnt: %u\" color:red }\n",
-    ++nr, cnt_to_uint(cnt)
-  );
-}
+       /* add a pseudo node for the count of this pattern */
+       fprintf(priv->f,
+               "    node: {title: \"c%u\" label: \"cnt: %u\" color:red }\n",
+               ++nr, cnt_to_uint(cnt)
+       );
+}  /* vcg_dump_new_pattern */

 
 /**
 
 /**

- * Finishes current pattern
+ * Finish the current pattern.

  */
 static void vcg_dump_finish_pattern(pattern_dumper_t *self)
 {
  */
 static void vcg_dump_finish_pattern(pattern_dumper_t *self)
 {

-  vcg_private_t *priv = self->data;
+       vcg_private_t *priv = self->data;

 
 

-  if (priv->pattern_id > priv->max_pattern)
-    return;
+       if (priv->pattern_id > priv->max_pattern)
+               return;

 
 

-  fprintf(priv->f, "  }\n");
+       fprintf(priv->f, "  }\n");

 
 

-  if (priv->pattern_id > 0)
-    fprintf(priv->f, "  edge: { sourcename: \"g%u\" targetname: \"g%u\" linestyle:invisible}\n",
-      priv->pattern_id,
-      priv->pattern_id - 1);
+       if (priv->pattern_id > 0)
+               fprintf(priv->f, "  edge: { sourcename: \"g%u\" targetname: \"g%u\" linestyle:invisible}\n",
+                       priv->pattern_id,
+                       priv->pattern_id - 1);

 
 

-  ++priv->pattern_id;
-}
+       ++priv->pattern_id;
+}  /* vcg_dump_finish_pattern */

 
 /**
 
 /**

- * Dumps a node
+ * Dumps a node.

  */
 static void vcg_dump_node(pattern_dumper_t *self, unsigned id,
     unsigned op_code, unsigned mode_code, void *attr)
 {
  */
 static void vcg_dump_node(pattern_dumper_t *self, unsigned id,
     unsigned op_code, unsigned mode_code, void *attr)
 {

-  vcg_private_t *priv = self->data;
-  ir_op *op           = stat_get_op_from_opcode(op_code);
-  ir_mode *mode       = (ir_mode *)mode_code;
-  long l              = attr ? *(long *)attr : 0;
-
-  if (priv->pattern_id > priv->max_pattern)
-    return;
-
-  if (attr) {
-    fprintf(priv->f, "    node: {title: \"n%u_%u\" label: \"%s%s %ld n%u\" }\n",
-      priv->pattern_id, id, get_id_str(op->name), mode ? get_mode_name(mode) : "", l, id);
-  }
-  else {
-    fprintf(priv->f, "    node: {title: \"n%u_%u\" label: \"%s%s n%u\" }\n",
-      priv->pattern_id, id, get_id_str(op->name), mode ? get_mode_name(mode) : "", id);
-  }
-}
+       vcg_private_t *priv = self->data;
+       ir_op *op           = stat_get_op_from_opcode(op_code);
+       ir_mode *mode       = (ir_mode *)mode_code;
+       long l              = attr ? *(long *)attr : 0;
+
+       if (priv->pattern_id > priv->max_pattern)
+               return;
+
+       if (attr) {
+               fprintf(priv->f, "    node: {title: \"n%u_%u\" label: \"%s%s %ld n%u\" }\n",
+                       priv->pattern_id, id, get_id_str(op->name), mode ? get_mode_name(mode) : "", l, id);
+       } else {
+               fprintf(priv->f, "    node: {title: \"n%u_%u\" label: \"%s%s n%u\" }\n",
+                       priv->pattern_id, id, get_id_str(op->name), mode ? get_mode_name(mode) : "", id);
+       }  /* if */
+}  /* vcg_dump_node */

 
 /**
  * Dumps an edge.
  */
 static void vcg_dump_edge(pattern_dumper_t *self, unsigned tgt, unsigned src, unsigned pos, unsigned mode_code)
 {
 
 /**
  * Dumps an edge.
  */
 static void vcg_dump_edge(pattern_dumper_t *self, unsigned tgt, unsigned src, unsigned pos, unsigned mode_code)
 {

-  vcg_private_t *priv = self->data;
+       vcg_private_t *priv = self->data;

 
 

-  if (priv->pattern_id > priv->max_pattern)
-    return;
+       if (priv->pattern_id > priv->max_pattern)
+               return;

 
 

-  fprintf(priv->f, "    edge: { sourcename: \"n%u_%u\" targetname: \"n%u_%u\" label: \"%u\" }\n",
-      priv->pattern_id, src,
-      priv->pattern_id, tgt,
-      pos
-  );
-}
+       fprintf(priv->f, "    edge: { sourcename: \"n%u_%u\" targetname: \"n%u_%u\" label: \"%u\" }\n",
+               priv->pattern_id, src,
+               priv->pattern_id, tgt,
+               pos
+       );
+}  /* vcg_dump_edge */

 
 /**
  * The VCG dumper.
  */
 static pattern_dumper_t vcg_dump = {
 
 /**
  * The VCG dumper.
  */
 static pattern_dumper_t vcg_dump = {

-  vcg_dump_new_pattern,
-  vcg_dump_finish_pattern,
-  vcg_dump_node,
-  NULL,
-  vcg_dump_edge,
-  NULL,
-  NULL,
-  vcg_dump_start,
-  vcg_dump_end,
-  NULL
+       vcg_dump_new_pattern,
+       vcg_dump_finish_pattern,
+       vcg_dump_node,
+       NULL,
+       vcg_dump_edge,
+       NULL,
+       NULL,
+       vcg_dump_start,
+       vcg_dump_end,
+       NULL

 };
 
 /**
 };
 
 /**

- * starts a new pattern
+ * Starts a new pattern.

  */
 static void stdout_dump_new_pattern(pattern_dumper_t *self, counter_t *cnt)
 {
  */
 static void stdout_dump_new_pattern(pattern_dumper_t *self, counter_t *cnt)
 {

-  FILE *f = self->data;
+       FILE *f = self->data;

 
 

-  fprintf(f, "%8u ", cnt_to_uint(cnt));
-}
+       fprintf(f, "%8u ", cnt_to_uint(cnt));
+}  /* stdout_dump_new_pattern */

 
 
 /**
 
 
 /**

- * Finishes current pattern
+ * Finish the current pattern.

  */
 static void stdout_dump_finish_pattern(pattern_dumper_t *self)
 {
  */
 static void stdout_dump_finish_pattern(pattern_dumper_t *self)
 {

-  FILE *f = self->data;
+       FILE *f = self->data;

 
 

-  fprintf(f, "\n");
-}
+       fprintf(f, "\n");
+} /* stdout_dump_finish_pattern */

 
 /**
 
 /**

- * Dumps a node
+ * Dumps a node.

  */
 static void stdout_dump_node(pattern_dumper_t *self, unsigned id, unsigned op_code, unsigned mode_code, void *attr)
 {
  */
 static void stdout_dump_node(pattern_dumper_t *self, unsigned id, unsigned op_code, unsigned mode_code, void *attr)
 {

-  FILE *f       = self->data;
-  ir_op *op     = stat_get_op_from_opcode(op_code);
-  ir_mode *mode = (ir_mode *)mode_code;
+       FILE *f       = self->data;
+       ir_op *op     = stat_get_op_from_opcode(op_code);
+       ir_mode *mode = (ir_mode *)mode_code;

 
 

-  /* if (env->options & OPT_ENC_GRAPH) */
-    fprintf(f, "%u:", id);
+       /* if (env->options & OPT_ENC_GRAPH) */
+       fprintf(f, "%u:", id);

 
 

-  fprintf(f, "%s", get_id_str(op->name));
+       fprintf(f, "%s", get_id_str(op->name));

 
 

-  if (mode)
-    fprintf(f, "%s", get_mode_name(mode));
-}
+       if (mode)
+               fprintf(f, "%s", get_mode_name(mode));
+}  /* stdout_dump_node */

 
 /**
  * Dump a ref
  */
 static void stdout_dump_ref(pattern_dumper_t *self, unsigned id)
 {
 
 /**
  * Dump a ref
  */
 static void stdout_dump_ref(pattern_dumper_t *self, unsigned id)
 {

-  FILE *f = self->data;
+       FILE *f = self->data;

 
 

-  fprintf(f, "REF:%u", id);
-}
+       fprintf(f, "REF:%u", id);
+}  /* stdout_dump_ref */

 
 /**
 
 /**

- * Dump an edge
+ * Dump an edge.

  */
 static void stdout_dump_edge(pattern_dumper_t *self, unsigned tgt, unsigned src, unsigned pos, unsigned mode_code)
 {
  */
 static void stdout_dump_edge(pattern_dumper_t *self, unsigned tgt, unsigned src, unsigned pos, unsigned mode_code)
 {

-  FILE *f = self->data;
+       FILE *f = self->data;

 
 

-  if (pos > 0)
-    fprintf(f, ", ");
-}
+       if (pos > 0)
+               fprintf(f, ", ");
+}  /* stdout_dump_edge */

 
 /**
 
 /**

- * Start children dumper
+ * Start the children dumper.

  */
 static void stdout_start_children(pattern_dumper_t *self, unsigned id)
 {
  */
 static void stdout_start_children(pattern_dumper_t *self, unsigned id)
 {

-  FILE *f = self->data;
+       FILE *f = self->data;

 
 

-  fprintf(f, "(");
-}
+       fprintf(f, "(");
+}  /* stdout_start_children */

 
 /**
 
 /**

- * finishes the children dumper
+ * Finish the children dumper.

  */
 static void stdout_finish_children(pattern_dumper_t *self, unsigned id)
 {
  */
 static void stdout_finish_children(pattern_dumper_t *self, unsigned id)
 {

-  FILE *f = self->data;
+       FILE *f = self->data;

 
 

-  fprintf(f, ")");
-}
+       fprintf(f, ")");
+}  /* stdout_finish_children */

 
 /**
  * The stdout dumper.
  */
 static const pattern_dumper_t stdout_dump = {
 
 /**
  * The stdout dumper.
  */
 static const pattern_dumper_t stdout_dump = {

-  stdout_dump_new_pattern,
-  stdout_dump_finish_pattern,
-  stdout_dump_node,
-  stdout_dump_ref,
-  stdout_dump_edge,
-  stdout_start_children,
-  stdout_finish_children,
-  NULL,
-  NULL,
-  NULL
+       stdout_dump_new_pattern,
+       stdout_dump_finish_pattern,
+       stdout_dump_node,
+       stdout_dump_ref,
+       stdout_dump_edge,
+       stdout_start_children,
+       stdout_finish_children,
+       NULL,
+       NULL,
+       NULL

 };
 
 /* ------------------------------------ API ------------------------------------- */
 
 /*
 };
 
 /* ------------------------------------ API ------------------------------------- */
 
 /*

- * starts a new pattern
+ * Starts a new pattern.

  */
 void pattern_dump_new_pattern(pattern_dumper_t *self, counter_t *cnt)
 {
  */
 void pattern_dump_new_pattern(pattern_dumper_t *self, counter_t *cnt)
 {

-  if (self->dump_new_pattern)
-    self->dump_new_pattern(self, cnt);
-}
+       if (self->dump_new_pattern)
+               self->dump_new_pattern(self, cnt);
+}  /* pattern_dump_new_pattern */

 
 
 /*
 
 
 /*

- * Finishes current pattern
+ * Finish the current pattern.

  */
 void pattern_dump_finish_pattern(pattern_dumper_t *self)
 {
  */
 void pattern_dump_finish_pattern(pattern_dumper_t *self)
 {

-  if (self->dump_finish_pattern)
-    self->dump_finish_pattern(self);
-}
+       if (self->dump_finish_pattern)
+               self->dump_finish_pattern(self);
+}  /* pattern_dump_finish_pattern */

 
 
 /*
 
 
 /*

- * Dumps a node
+ * Dumps a node.

  */
 void pattern_dump_node(pattern_dumper_t *self, unsigned id, unsigned op_code, unsigned mode_code, void *attr)
 {
  */
 void pattern_dump_node(pattern_dumper_t *self, unsigned id, unsigned op_code, unsigned mode_code, void *attr)
 {

-  if (self->dump_node)
-    self->dump_node(self, id, op_code, mode_code, attr);
-}
+       if (self->dump_node)
+               self->dump_node(self, id, op_code, mode_code, attr);
+}  /* pattern_dump_node */

 
 /*
 
 /*

- * Dump a ref
+ * Dump a ref.

  */
 void pattern_dump_ref(pattern_dumper_t *self, unsigned id)
 {
  */
 void pattern_dump_ref(pattern_dumper_t *self, unsigned id)
 {

-  if (self->dump_ref)
-    self->dump_ref(self, id);
-}
+       if (self->dump_ref)
+               self->dump_ref(self, id);
+}  /* pattern_dump_ref */

 
 /*
 
 /*

- * Dump an edge
+ * Dump an edge.

  */
 void pattern_dump_edge(pattern_dumper_t *self, unsigned tgt, unsigned src, unsigned pos, unsigned mode_code)
 {
  */
 void pattern_dump_edge(pattern_dumper_t *self, unsigned tgt, unsigned src, unsigned pos, unsigned mode_code)
 {

-  if (self->dump_edge)
-    self->dump_edge(self, tgt, src, pos, mode_code);
-}
+       if (self->dump_edge)
+               self->dump_edge(self, tgt, src, pos, mode_code);
+}  /* pattern_dump_edge */

 
 /*
 
 /*

- * Start children dumper
+ * Start the children dumper.

  */
 void pattern_start_children(pattern_dumper_t *self, unsigned id)
 {
  */
 void pattern_start_children(pattern_dumper_t *self, unsigned id)
 {

-  if (self->dump_start_children)
-    self->dump_start_children(self, id);
-}
+       if (self->dump_start_children)
+               self->dump_start_children(self, id);
+}  /* pattern_start_children */

 
 /*
 
 /*

- * finishes the children dumper
+ * Finish the the children dumper.

  */
 void pattern_finish_children(pattern_dumper_t *self, unsigned id)
 {
  */
 void pattern_finish_children(pattern_dumper_t *self, unsigned id)
 {

-  if (self->dump_finish_children)
-    self->dump_finish_children(self, id);
-}
+       if (self->dump_finish_children)
+               self->dump_finish_children(self, id);
+}  /* pattern_finish_children */

 
 /*
 
 /*

- * finishes the dumper
+ * Finish the the dumper.

  */
 void pattern_end(pattern_dumper_t *self)
 {
  */
 void pattern_end(pattern_dumper_t *self)
 {

-  if (self->dump_end)
-    self->dump_end(self);
+       if (self->dump_end)
+               self->dump_end(self);

 
 

-  free(self);
-}
+       free(self);
+}  /* pattern_end */

 
 /**
  * pattern dumper factory for text dumper
  */
 pattern_dumper_t *new_text_dumper(void)
 {
 
 /**
  * pattern dumper factory for text dumper
  */
 pattern_dumper_t *new_text_dumper(void)
 {

-  pattern_dumper_t *res = malloc(sizeof(*res));
+       pattern_dumper_t *res = malloc(sizeof(*res));

 
 

-  if (res) {
-    memcpy(res, &stdout_dump, sizeof(*res));
-    res->data = stdout;
+       if (res) {
+               memcpy(res, &stdout_dump, sizeof(*res));
+               res->data = stdout;

 
 

-    if (res->dump_start)
-      res->dump_start(res);
-  }
-  return res;
-}
+               if (res->dump_start)
+                       res->dump_start(res);
+       }  /* if */
+       return res;
+}  /* new_text_dumper */

 
 /**
  * pattern dumper factory for vcg dumper
  */
 pattern_dumper_t *new_vcg_dumper(const char *vcg_name, unsigned max_pattern)
 {
 
 /**
  * pattern dumper factory for vcg dumper
  */
 pattern_dumper_t *new_vcg_dumper(const char *vcg_name, unsigned max_pattern)
 {

-  pattern_dumper_t *res = malloc(sizeof(*res) + sizeof(vcg_private_t));
-  vcg_private_t *priv;
+       pattern_dumper_t *res = malloc(sizeof(*res) + sizeof(vcg_private_t));
+       vcg_private_t *priv;

 
 

-  if (res) {
-    FILE *f;
+       if (res) {
+               FILE *f;

 
 

-    memcpy(res, &vcg_dump, sizeof(*res));
+               memcpy(res, &vcg_dump, sizeof(*res));

 
 

-    priv = (vcg_private_t *)(res + 1);
-    memset(priv, 0, sizeof(*priv));
+               priv = (vcg_private_t *)(res + 1);
+               memset(priv, 0, sizeof(*priv));

 
 

-    f = fopen(vcg_name, "w");
-    priv->f           = f;
-    priv->pattern_id  = 0;
-    priv->max_pattern = max_pattern ? max_pattern : (unsigned)-1;
-    res->data         = priv;
+               f = fopen(vcg_name, "w");
+               priv->f           = f;
+               priv->pattern_id  = 0;
+               priv->max_pattern = max_pattern ? max_pattern : (unsigned)-1;
+               res->data         = priv;

 
 

-    if (res->dump_start)
-      res->dump_start(res);
-  }
+               if (res->dump_start)
+                       res->dump_start(res);
+       }  /* if */

 
 

-  return res;
-}
+       return res;
+}  /* new_vcg_dumper */

diff --git a/ir/stat/pattern_dmp.h b/ir/stat/pattern_dmp.h
index 0077043..0c4027d 100644 (file)
--- a/ir/stat/pattern_dmp.h
+++ b/ir/stat/pattern_dmp.h
@@ -6,27 +6,27 @@
 typedef struct _pattern_dumper_t pattern_dumper_t;
 
 /**
 typedef struct _pattern_dumper_t pattern_dumper_t;
 
 /**

- * starts a new pattern
+ * Starts a new pattern.

  */
 void pattern_dump_new_pattern(pattern_dumper_t *self, counter_t *cnt);
 
 /**
  */
 void pattern_dump_new_pattern(pattern_dumper_t *self, counter_t *cnt);
 
 /**

- * Finishes current pattern
+ * Finish the current pattern.

  */
 void pattern_dump_finish_pattern(pattern_dumper_t *self);
 
 /**
  */
 void pattern_dump_finish_pattern(pattern_dumper_t *self);
 
 /**

- * Dumps a node
+ * Dumps a node.

  */
 void pattern_dump_node(pattern_dumper_t *self, unsigned id, unsigned op_code, unsigned mode_code, void *attr);
 
 /**
  */
 void pattern_dump_node(pattern_dumper_t *self, unsigned id, unsigned op_code, unsigned mode_code, void *attr);
 
 /**

- * Dump a ref
+ * Dump a ref.

  */
 void pattern_dump_ref(pattern_dumper_t *self, unsigned id);
 
 /**
  */
 void pattern_dump_ref(pattern_dumper_t *self, unsigned id);
 
 /**

- * Dump an edge
+ * Dump an edge.

  *
  * @param tgt       The target ID
  * @param src       The source ID
  *
  * @param tgt       The target ID
  * @param src       The source ID


@@ -36,27 +36,27 @@ void pattern_dump_ref(pattern_dumper_t *self, unsigned id);
 void pattern_dump_edge(pattern_dumper_t *self, unsigned tgt, unsigned src, unsigned pos, unsigned mode_code);
 
 /**
 void pattern_dump_edge(pattern_dumper_t *self, unsigned tgt, unsigned src, unsigned pos, unsigned mode_code);
 
 /**

- * Start children dumper
+ * Start the children dumper.

  */
 void pattern_start_children(pattern_dumper_t *self, unsigned id);
 
 /**
  */
 void pattern_start_children(pattern_dumper_t *self, unsigned id);
 
 /**

- * finishes the children dumper
+ * Finish the children dumper.

  */
 void pattern_finish_children(pattern_dumper_t *self, unsigned id);
 
 /**
  */
 void pattern_finish_children(pattern_dumper_t *self, unsigned id);
 
 /**

- * finishes dumper, destroys the dumper object
+ * Finish the dumper, destroys the dumper object

  */
 void pattern_end(pattern_dumper_t *self);
 
 /**
  */
 void pattern_end(pattern_dumper_t *self);
 
 /**

- * pattern dumper factory for text dumper
+ * Pattern dumper factory for text dumper.

  */
 pattern_dumper_t *new_text_dumper(void);
 
 /**
  */
 pattern_dumper_t *new_text_dumper(void);
 
 /**

- * pattern dumper factory for vcg dumper
+ * Pattern dumper factory for vcg dumper.

  *
  * @param vcg_name    name of the VCG file
  * @param max_pattern maximum number of pattern to be dumped
  *
  * @param vcg_name    name of the VCG file
  * @param max_pattern maximum number of pattern to be dumped