3 * File name: ir/ir/firmstat.c
4 * Purpose: Statistics for Firm.
8 * Copyright: (c) 2004 Universität Karlsruhe
9 * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE.
21 #ifdef FIRM_STATISTICS
25 # include "irnode_t.h"
26 # include "irgraph_t.h"
34 * just be make some things clear :-), the
37 #define HASH_MAP(type) pset_##type
39 typedef pset pset_node_entry_t;
40 typedef pset pset_graph_entry_t;
41 typedef pset pset_opt_entry_t;
42 typedef pset pset_block_entry_t;
45 * An entry for ir_nodes
47 typedef struct _node_entry_t {
48 counter_t cnt_alive; /**< amount of nodes in this entry */
49 counter_t new_node; /**< amount of new nodes for this entry */
50 counter_t into_Id; /**< amount of nodes that turned into Id's for this entry */
51 const ir_op *op; /**< the op for this entry */
55 * An entry for ir_graphs
57 typedef struct _graph_entry_t {
58 HASH_MAP(node_entry_t) *opcode_hash; /**< hash map containing the opcode counter */
59 HASH_MAP(block_entry_t) *block_hash; /**< hash map countaining the block counter */
60 counter_t cnt_walked; /**< walker walked over the graph */
61 counter_t cnt_walked_blocks; /**< walker walked over the graph blocks */
62 counter_t cnt_was_inlined; /**< number of times other graph were inlined */
63 counter_t cnt_got_inlined; /**< number of times this graph was inlined */
64 counter_t cnt_edges; /**< number of DF edges in this graph */
65 HASH_MAP(opt_entry_t) *opt_hash[STAT_OPT_MAX]; /**< hash maps containing opcode counter for optimizations */
66 ir_graph *irg; /**< the graph of this object */
67 entity *ent; /**< the entity of this graph if one exists */
68 int deleted; /**< set if this irg was deleted */
72 * An entry for optimized ir_nodes
74 typedef struct _opt_entry_t {
75 counter_t count; /**< optimization counter */
76 const ir_op *op; /**< the op for this entry */
80 * An entry for a block in a ir-graph
82 typedef struct _block_entry_t {
83 counter_t cnt_nodes; /**< the counter of nodes in this block */
84 counter_t cnt_edges; /**< the counter of edges in this block */
85 counter_t cnt_in_edges; /**< the counter of edges incoming from other blocks to this block */
86 counter_t cnt_out_edges; /**< the counter of edges outgoing from this block to other blocks */
87 long block_nr; /**< block nr */
91 typedef struct _dumper_t dumper_t;
94 * handler for dumping an IRG
96 * @param dmp the dumper
97 * @param entry the IR-graph hash map entry
99 typedef void (*dump_graph_FUNC)(dumper_t *dmp, graph_entry_t *entry);
102 * handler for dumper init
104 * @param dmp the dumper
105 * @param name name of the file to dump to
107 typedef void (*dump_init_FUNC)(dumper_t *dmp, const char *name);
110 * handler for dumper finish
112 * @param dmp the dumper
114 typedef void (*dump_finish_FUNC)(dumper_t *dmp);
118 * a dumper description
121 dump_graph_FUNC dump_graph; /**< handler for dumping an irg */
122 dump_init_FUNC init; /**< handler for init */
123 dump_finish_FUNC finish; /**< handler for finish */
124 FILE *f; /**< the file to dump to */
125 dumper_t *next; /**< link to the next dumper */
131 typedef struct _statistic_info_t {
132 struct obstack cnts; /**< obstack containing the counters */
133 HASH_MAP(graph_entry_t) *irg_hash; /**< hash map containing the counter for irgs */
134 int recursive; /**< flag for detecting recursive hook calls */
135 int in_dead_node_elim; /**< set, if dead node elimination runs */
136 ir_op *op_Phi0; /**< needed pseudo op */
137 ir_op *op_PhiM; /**< needed pseudo op */
138 dumper_t *dumper; /**< list of dumper */
139 int enable; /**< if set, statistic is enabled */
143 * names of the optimizations
145 static const char *opt_names[] = {
146 "straightening optimization",
148 "algebraic simplification",
150 "Write-After-Write optimization",
151 "Write-After-Read optimization",
152 "Read-After-Write optimization",
153 "Tuple optimization",
155 "Constant evaluation",
160 * need this to be static
162 static ir_op _op_Phi0, _op_PhiM;
164 /* ---------------------------------------------------------------------------------- */
166 #define STAT_ENTER ++status->recursive
167 #define STAT_LEAVE --status->recursive
168 #define STAT_ENTER_SINGLE do { if (status->recursive > 0) return; ++status->recursive; } while (0)
173 static stat_info_t _status, *status = &_status;
176 * compare two elements of the opcode hash
178 static int opcode_cmp(const void *elt, const void *key)
180 const node_entry_t *e1 = elt;
181 const node_entry_t *e2 = key;
183 return e1->op->code - e2->op->code;
187 * compare two elements of the graph hash
189 static int graph_cmp(const void *elt, const void *key)
191 const graph_entry_t *e1 = elt;
192 const graph_entry_t *e2 = key;
194 return e1->irg != e2->irg;
198 * compare two elements of the optimization hash
200 static int opt_cmp(const void *elt, const void *key)
202 const opt_entry_t *e1 = elt;
203 const opt_entry_t *e2 = key;
205 return e1->op->code != e2->op->code;
209 * compare two elements of the block hash
211 static int block_cmp(const void *elt, const void *key)
213 const block_entry_t *e1 = elt;
214 const block_entry_t *e2 = key;
216 return e1->block_nr != e2->block_nr;
220 * Returns the associates node_entry_t for an ir_op
222 static node_entry_t *opcode_get_entry(const ir_op *op, pset *set)
229 elem = pset_find(set, &key, op->code);
233 elem = obstack_alloc(&status->cnts, sizeof(*elem));
236 cnt_clr(&elem->cnt_alive);
237 cnt_clr(&elem->new_node);
238 cnt_clr(&elem->into_Id);
242 return pset_insert(set, elem, op->code);
246 * calculates a hash value for an irg
247 * Addresses are typically aligned at 32bit, so we ignore the lowest bits
249 static INLINE unsigned irg_hash(const ir_graph *irg)
251 return (unsigned)irg >> 3;
255 * Returns the acssociates graph_entry_t for an irg
257 static graph_entry_t *graph_get_entry(ir_graph *irg, pset *set)
265 elem = pset_find(set, &key, irg_hash(irg));
269 elem = obstack_alloc(&status->cnts, sizeof(*elem));
271 cnt_clr(&elem->cnt_walked);
272 cnt_clr(&elem->cnt_walked_blocks);
273 cnt_clr(&elem->cnt_got_inlined);
274 cnt_clr(&elem->cnt_was_inlined);
275 cnt_clr(&elem->cnt_edges);
277 /* new hash table for opcodes here */
278 elem->opcode_hash = new_pset(opcode_cmp, 5);
279 elem->block_hash = new_pset(block_cmp, 5);
282 for (i = 0; i < sizeof(elem->opt_hash)/sizeof(elem->opt_hash[0]); ++i)
283 elem->opt_hash[i] = new_pset(opt_cmp, 4);
285 return pset_insert(set, elem, irg_hash(irg));
289 * Returns the associates opt_entry_t for an ir_op
291 static opt_entry_t *opt_get_entry(const ir_op *op, pset *set)
298 elem = pset_find(set, &key, op->code);
302 elem = obstack_alloc(&status->cnts, sizeof(*elem));
304 /* clear new counter */
305 cnt_clr(&elem->count);
309 return pset_insert(set, elem, op->code);
313 * Returns the associates block_entry_t for an block
315 static block_entry_t *block_get_entry(long block_nr, pset *set)
320 key.block_nr = block_nr;
322 elem = pset_find(set, &key, block_nr);
326 elem = obstack_alloc(&status->cnts, sizeof(*elem));
328 /* clear new counter */
329 cnt_clr(&elem->cnt_nodes);
330 cnt_clr(&elem->cnt_edges);
331 cnt_clr(&elem->cnt_in_edges);
332 cnt_clr(&elem->cnt_out_edges);
334 elem->block_nr = block_nr;
336 return pset_insert(set, elem, block_nr);
341 * Returns the ir_op for an IR-node,
342 * handles special cases and return pseudo op codes
344 static ir_op *stat_get_irn_op(const ir_node *node)
346 ir_op *op = get_irn_op(node);
348 if (op->code == iro_Phi && get_irn_arity(node) == 0) {
349 /* special case, a Phi0 node, count on extra counter */
350 op = status->op_Phi0;
352 else if (op->code == iro_Phi && get_irn_mode(node) == mode_M) {
353 /* special case, a Memory Phi node, count on extra counter */
354 op = status->op_PhiM;
360 * update the block counter
362 static void count_block_info(ir_node *node, graph_entry_t *graph)
364 ir_op *op = get_irn_op(node);
366 block_entry_t *b_entry;
369 /* check for block */
370 if (op == op_Block) {
371 arity = get_irn_arity(node);
372 b_entry = block_get_entry(get_irn_node_nr(node), graph->block_hash);
374 /* count all incoming edges */
375 for (i = 0; i < arity; ++i) {
376 ir_node *pred = get_irn_n(node, i);
377 ir_node *other_block = get_nodes_Block(pred);
378 block_entry_t *b_entry_other = block_get_entry(get_irn_node_nr(other_block), graph->block_hash);
380 cnt_inc(&b_entry->cnt_in_edges); /* an edge coming from another block */
381 cnt_inc(&b_entry_other->cnt_out_edges);
385 else if (op == op_Call) {
389 block = get_nodes_Block(node);
390 b_entry = block_get_entry(get_irn_node_nr(block), graph->block_hash);
392 /* we have a new nodes */
393 cnt_inc(&b_entry->cnt_nodes);
395 arity = get_irn_arity(node);
397 for (i = 0; i < arity; ++i) {
398 ir_node *pred = get_irn_n(node, i);
399 ir_node *other_block;
401 if (get_irn_op(pred) == op_Block)
404 other_block = get_nodes_Block(pred);
406 if (other_block == block)
407 cnt_inc(&b_entry->cnt_edges); /* a in block edge */
409 block_entry_t *b_entry_other = block_get_entry(get_irn_node_nr(other_block), graph->block_hash);
411 cnt_inc(&b_entry->cnt_in_edges); /* an edge coming from another block */
412 cnt_inc(&b_entry_other->cnt_out_edges);
418 * walker for reachable nodes count
420 static void count_nodes(ir_node *node, void *env)
422 graph_entry_t *graph = env;
425 ir_op *op = stat_get_irn_op(node);
426 int arity = get_irn_arity(node);
428 entry = opcode_get_entry(op, graph->opcode_hash);
430 cnt_inc(&entry->cnt_alive);
431 cnt_add_i(&graph->cnt_edges, arity);
433 /* count block edges */
434 count_block_info(node, graph);
438 * count all alive nodes and edges in a graph
440 static void count_nodes_in_graph(graph_entry_t *global, graph_entry_t *graph)
444 irg_walk_graph(graph->irg, count_nodes, NULL, graph);
446 /* assume we walk every graph only ONCE, we could sum here the global count */
447 for (entry = pset_first(graph->opcode_hash); entry; entry = pset_next(graph->opcode_hash)) {
448 node_entry_t *g_entry = opcode_get_entry(entry->op, global->opcode_hash);
450 /* update the node counter */
451 cnt_add(&g_entry->cnt_alive, &entry->cnt_alive);
454 /* update the edge counter */
455 cnt_add(&global->cnt_edges, &graph->cnt_edges);
461 static void stat_register_dumper(dumper_t *dumper, const char *name)
463 dumper->next = status->dumper;
464 status->dumper = dumper;
467 dumper->init(dumper, name);
473 static void dump_graph(graph_entry_t *entry)
477 for (dumper = status->dumper; dumper; dumper = dumper->next) {
478 if (dumper->dump_graph)
479 dumper->dump_graph(dumper, entry);
486 static void dump_finish(void)
490 for (dumper = status->dumper; dumper; dumper = dumper->next) {
492 dumper->finish(dumper);
496 /* ---------------------------------------------------------------------- */
499 * dumps a opcode hash into human readable form
501 static void simple_dump_opcode_hash(dumper_t *dmp, pset *set)
505 counter_t f_new_node;
509 cnt_clr(&f_new_node);
512 fprintf(dmp->f, "%-16s %-8s %-8s %-8s\n", "Opcode", "alive", "created", "->Id");
513 for (entry = pset_first(set); entry; entry = pset_next(set)) {
514 fprintf(dmp->f, "%-16s %8d %8d %8d\n",
515 get_id_str(entry->op->name), entry->cnt_alive.cnt[0], entry->new_node.cnt[0], entry->into_Id.cnt[0]);
517 cnt_add(&f_alive, &entry->cnt_alive);
518 cnt_add(&f_new_node, &entry->new_node);
519 cnt_add(&f_Id, &entry->into_Id);
521 fprintf(dmp->f, "-------------------------------------------\n");
522 fprintf(dmp->f, "%-16s %8d %8d %8d\n", "Sum",
529 * dumps a optimization hash into human readable form
531 static void simple_dump_opt_hash(dumper_t *dmp, pset *set, int index)
533 opt_entry_t *entry = pset_first(set);
536 fprintf(dmp->f, "\n%s:\n", opt_names[index]);
537 fprintf(dmp->f, "%-16s %-8s\n", "Opcode", "deref");
539 for (; entry; entry = pset_next(set)) {
540 fprintf(dmp->f, "%-16s %8d\n",
541 get_id_str(entry->op->name), entry->count.cnt[0]);
547 * dumps the endges count
549 static void simple_dump_edges(dumper_t *dmp, counter_t *cnt)
551 fprintf(dmp->f, "%-16s %8d\n", "Edges", cnt->cnt[0]);
557 static void simple_dump_graph(dumper_t *dmp, graph_entry_t *entry)
560 block_entry_t *b_entry;
563 ir_graph *const_irg = get_const_code_irg();
565 if (entry->irg == const_irg) {
566 fprintf(dmp->f, "\nConst code Irg %p", (void *)entry->irg);
570 fprintf(dmp->f, "\nEntity %s, Irg %p", get_entity_name(entry->ent), (void *)entry->irg);
572 fprintf(dmp->f, "\nIrg %p", (void *)entry->irg);
575 fprintf(dmp->f, " %swalked %d over blocks %d was inlined %d got inlined %d:\n",
576 entry->deleted ? "DELETED " : "",
577 entry->cnt_walked.cnt[0], entry->cnt_walked_blocks.cnt[0],
578 entry->cnt_was_inlined.cnt[0],
579 entry->cnt_got_inlined.cnt[0]
583 fprintf(dmp->f, "\nGlobals counts:\n");
587 simple_dump_opcode_hash(dmp, entry->opcode_hash);
588 simple_dump_edges(dmp, &entry->cnt_edges);
590 /* effects of optimizations */
594 for (i = 0; i < sizeof(entry->opt_hash)/sizeof(entry->opt_hash[0]); ++i) {
595 simple_dump_opt_hash(dmp, entry->opt_hash[i], i);
599 /* dump block info */
600 fprintf(dmp->f, "\n%12s %12s %12s %12s %12s %12s\n", "Block Nr", "Nodes", "intern", "incoming", "outgoing", "quot");
601 for (b_entry = pset_first(entry->block_hash);
603 b_entry = pset_next(entry->block_hash)) {
604 fprintf(dmp->f, "%12ld %12u %12u %12u %12u %4.8f\n",
606 b_entry->cnt_nodes.cnt[0],
607 b_entry->cnt_edges.cnt[0],
608 b_entry->cnt_in_edges.cnt[0],
609 b_entry->cnt_out_edges.cnt[0],
610 (double)b_entry->cnt_edges.cnt[0] / (double)b_entry->cnt_nodes.cnt[0]
616 * initialise the simple dumper
618 static void simple_init(dumper_t *dmp, const char *name)
620 dmp->f = fopen(name, "w");
624 * finishes the simple dumper
626 static void simple_finish(dumper_t *dmp)
633 * the simple human readable dumper
635 static dumper_t simple_dumper = {
643 /* ---------------------------------------------------------------------- */
646 * count the nodes as needed:
648 * 1 normal (data) Phi's
653 static void csv_count_nodes(graph_entry_t *graph, counter_t cnt[])
658 for (i = 0; i < 4; ++i)
661 for (entry = pset_first(graph->opcode_hash); entry; entry = pset_next(graph->opcode_hash)) {
662 if (entry->op == op_Phi) {
664 cnt_add(&cnt[1], &entry->cnt_alive);
666 else if (entry->op == status->op_PhiM) {
668 cnt_add(&cnt[2], &entry->cnt_alive);
670 else if (entry->op == op_Proj) {
672 cnt_add(&cnt[3], &entry->cnt_alive);
675 /* all other nodes */
676 cnt_add(&cnt[0], &entry->cnt_alive);
684 static void csv_dump_graph(dumper_t *dmp, graph_entry_t *entry)
691 ir_graph *const_irg = get_const_code_irg();
693 if (entry->irg == const_irg) {
694 name = "<Const code Irg>";
699 name = get_entity_name(entry->ent);
701 name = "<UNKNOWN IRG>";
704 csv_count_nodes(entry, cnt);
706 fprintf(dmp->f, "%-40s, %p, %d, %d, %d, %d\n",
718 * initialise the simple dumper
720 static void csv_init(dumper_t *dmp, const char *name)
722 dmp->f = fopen(name, "a");
726 * finishes the simple dumper
728 static void csv_finish(dumper_t *dmp)
735 * the simple human readable dumper
737 static dumper_t csv_dumper = {
746 /* ---------------------------------------------------------------------- */
748 /* initialize the statistics module. */
751 #define X(a) a, sizeof(a)-1
755 /* enable statistics */
758 if (! status->enable)
761 obstack_init(&status->cnts);
763 /* build the pseudo-ops */
764 _op_Phi0.code = --pseudo_id;
765 _op_Phi0.name = id_from_str(X("Phi0"));
767 _op_PhiM.code = --pseudo_id;
768 _op_PhiM.name = id_from_str(X("PhiM"));
770 /* create the hash-tables */
771 status->irg_hash = new_pset(graph_cmp, 8);
773 status->op_Phi0 = &_op_Phi0;
774 status->op_PhiM = &_op_PhiM;
776 stat_register_dumper(&simple_dumper, "firmstat.txt");
777 stat_register_dumper(&csv_dumper, "firmstat.csv");
779 /* initialize the pattern hash */
780 stat_init_pattern_history(status->enable & 0);
784 /* A new IR op is registered. */
785 void stat_new_ir_op(const ir_op *op)
787 if (! status->enable)
792 graph_entry_t *graph = graph_get_entry(NULL, status->irg_hash);
794 /* execute for side effect :-) */
795 opcode_get_entry(op, graph->opcode_hash);
800 /* An IR op is freed. */
801 void stat_free_ir_op(const ir_op *op)
803 if (! status->enable)
812 /* A new node is created. */
813 void stat_new_node(const ir_node *node)
815 if (! status->enable)
818 /* do NOT count during dead node elimination */
819 if (status->in_dead_node_elim > 0)
825 graph_entry_t *graph;
826 ir_op *op = stat_get_irn_op(node);
828 /* increase global value */
829 graph = graph_get_entry(NULL, status->irg_hash);
830 entry = opcode_get_entry(op, graph->opcode_hash);
831 cnt_inc(&entry->new_node);
833 /* increase local value */
834 graph = graph_get_entry(current_ir_graph, status->irg_hash);
835 entry = opcode_get_entry(op, graph->opcode_hash);
836 cnt_inc(&entry->new_node);
841 /* A node is changed into a Id node */
842 void stat_turn_into_id(const ir_node *node)
844 if (! status->enable)
850 graph_entry_t *graph;
851 ir_op *op = stat_get_irn_op(node);
853 /* increase global value */
854 graph = graph_get_entry(NULL, status->irg_hash);
855 entry = opcode_get_entry(op, graph->opcode_hash);
856 cnt_inc(&entry->into_Id);
858 /* increase local value */
859 graph = graph_get_entry(current_ir_graph, status->irg_hash);
860 entry = opcode_get_entry(op, graph->opcode_hash);
861 cnt_inc(&entry->into_Id);
866 /* A new graph was created */
867 void stat_new_graph(ir_graph *irg, entity *ent)
869 if (! status->enable)
874 /* execute for side effect :-) */
875 graph_entry_t * graph = graph_get_entry(irg, status->irg_hash);
884 * A graph was deleted
886 void stat_free_graph(ir_graph *irg)
888 if (! status->enable)
893 graph_entry_t *graph = graph_get_entry(irg, status->irg_hash);
894 graph_entry_t *global = graph_get_entry(NULL, status->irg_hash);
898 /* count the nodes of the graph yet, it will be destroyed later */
899 count_nodes_in_graph(global, graph);
901 /* calculate the pattern */
902 stat_calc_pattern_history(irg);
908 * A walk over a graph is initiated. Do not count walks from statistic code.
910 void stat_irg_walk(ir_graph *irg, void *pre, void *post)
912 if (! status->enable)
917 graph_entry_t *graph = graph_get_entry(irg, status->irg_hash);
919 cnt_inc(&graph->cnt_walked);
925 * A walk over the graph's blocks is initiated. Do not count walks from statistic code.
927 void stat_irg_block_walk(ir_graph *irg, const ir_node *node, void *pre, void *post)
929 if (! status->enable)
934 graph_entry_t *graph = graph_get_entry(irg, status->irg_hash);
936 cnt_inc(&graph->cnt_walked_blocks);
942 * called for every node that is removed due to an optimization
944 static void removed_due_opt(ir_node *n, pset *set)
946 ir_op *op = get_irn_op(n);
947 opt_entry_t *entry = opt_get_entry(op, set);
949 /* increase global value */
950 cnt_inc(&entry->count);
954 * Some nodes were optimized into some others due to an optimization
956 void stat_merge_nodes(
957 ir_node **new_node_array, int new_num_entries,
958 ir_node **old_node_array, int old_num_entries,
961 if (! status->enable)
967 graph_entry_t *graph = graph_get_entry(current_ir_graph, status->irg_hash);
969 for (i = 0; i < old_num_entries; ++i) {
970 for (j = 0; j < new_num_entries; ++j)
971 if (old_node_array[i] == new_node_array[j])
974 /* nodes might be in new and old, these are NOT removed */
975 if (j >= new_num_entries) {
976 removed_due_opt(old_node_array[i], graph->opt_hash[opt]);
984 * A node was lowered into other nodes
986 void stat_lower(ir_node *node)
988 if (! status->enable)
993 graph_entry_t *graph = graph_get_entry(current_ir_graph, status->irg_hash);
995 removed_due_opt(node, graph->opt_hash[STAT_LOWERED]);
1001 * A graph was inlined
1003 void stat_inline(ir_node *call, ir_graph *called_irg)
1005 if (! status->enable)
1010 ir_graph *irg = get_irn_irg(call);
1011 graph_entry_t *i_graph = graph_get_entry(called_irg, status->irg_hash);
1012 graph_entry_t *graph = graph_get_entry(irg, status->irg_hash);
1014 cnt_inc(&graph->cnt_got_inlined);
1015 cnt_inc(&i_graph->cnt_was_inlined);
1021 * Start the dead node elimination.
1023 void stat_dead_node_elim_start(ir_graph *irg)
1025 if (! status->enable)
1028 ++status->in_dead_node_elim;
1032 * Stops the dead node elimination.
1034 void stat_dead_node_elim_stop(ir_graph *irg)
1036 if (! status->enable)
1039 --status->in_dead_node_elim;
1042 /* Finish the statistics */
1043 void stat_finish(void)
1045 if (! status->enable)
1050 graph_entry_t *entry;
1051 graph_entry_t *global = graph_get_entry(NULL, status->irg_hash);
1053 /* dump per graph */
1054 for (entry = pset_first(status->irg_hash); entry; entry = pset_next(status->irg_hash)) {
1056 if (entry->irg == NULL) {
1057 /* special entry for the global count */
1061 if (! entry->deleted) {
1062 /* the graph is still alive, count the nodes on it */
1063 count_nodes_in_graph(global, entry);
1065 /* calculate the pattern */
1066 stat_calc_pattern_history(entry->irg);
1076 stat_finish_pattern_history();
1086 /* need this for prototypes */
1087 #define FIRM_STATISTICS
1088 #include "firmstat.h"
1090 void stat_init(void) {}
1092 void stat_finish(void) {}
1094 void stat_new_ir_op(const ir_op *op) {}
1096 void stat_free_ir_op(const ir_op *op) {}
1098 void stat_new_node(const ir_node *node) {}
1100 void stat_turn_into_id(const ir_node *node) {}
1102 void stat_new_graph(ir_graph *irg, entity *ent) {}
1104 void stat_free_graph(ir_graph *irg) {}
1106 void stat_irg_walk(ir_graph *irg, void *pre, void *post) {}
1108 void stat_irg_block_walk(ir_graph *irg, const ir_node *node, void *pre, void *post) {}
1110 void stat_merge_nodes(
1111 ir_node **new_node_array, int new_num_entries,
1112 ir_node **old_node_array, int old_num_entries,
1113 stat_opt_kind opt) {}
1115 void stat_lower(ir_node *node) {}
1117 void stat_inline(ir_node *call, ir_graph *irg) {}
1119 void stat_dead_node_elim_start(ir_graph *irg) {}
1121 void stat_dead_node_elim_stop(ir_graph *irg) {}