scripts: Generate accessor functions for nodes with a variable/dynamic number of...

[libfirm] / ir / stat / statev.c

diff --git a/ir/stat/statev.c b/ir/stat/statev.c
index 96e20a6..972935a 100644 (file)
--- a/ir/stat/statev.c
+++ b/ir/stat/statev.c
@@ -22,7 +22,6 @@
  * @brief       Statistic events.
  * @author      Sebastian Hack
  * @date        17.06.2007
- * @version     $Id$
  */
 #include "config.h"
 
@@ -36,22 +35,20 @@
 #include "util.h"
 #include "stat_timing.h"
 #include "irprintf.h"
-#include "statev.h"
+#include "statev_t.h"
 
 #include "config.h"
 
-#ifndef DISABLE_STATEV
-
 #define MAX_TIMER 256
 
-static FILE* stat_ev_file  = NULL;
+int (stat_ev_enabled) = 0;
 
-int            stat_ev_enabled = 0;
-int            stat_ev_timer_sp = 0;
-timing_ticks_t stat_ev_timer_elapsed[MAX_TIMER];
-timing_ticks_t stat_ev_timer_start[MAX_TIMER];
+static FILE          *stat_ev_file     = NULL;
+static int            stat_ev_timer_sp = 0;
+static timing_ticks_t stat_ev_timer_elapsed[MAX_TIMER];
+static timing_ticks_t stat_ev_timer_start[MAX_TIMER];
 
-static regex_t regex;
+static regex_t  regex;
 static regex_t *filter = NULL;
 static inline int key_matches(const char *key)
 {
@@ -61,7 +58,7 @@ static inline int key_matches(const char *key)
        return regexec(filter, key, 0, NULL, 0) == 0;
 }
 
-void stat_ev_printf(char ev, const char *key, const char *fmt, ...)
+static void stat_ev_vprintf(char ev, const char *key, const char *fmt, va_list ap)
 {
        if (!key_matches(key))
                return;
@@ -69,16 +66,136 @@ void stat_ev_printf(char ev, const char *key, const char *fmt, ...)
        fprintf(stat_ev_file, "%c;%s", ev, key);
        if (fmt != NULL) {
                char buf[256];
-               va_list args;
 
-               va_start(args, fmt);
-               ir_vsnprintf(buf, sizeof(buf), fmt, args);
-               va_end(args);
+               ir_vsnprintf(buf, sizeof(buf), fmt, ap);
                fprintf(stat_ev_file, ";%s", buf);
        }
        fprintf(stat_ev_file, "\n");
 }
 
+static void stat_ev_printf(char ev, const char *key, const char *fmt, ...)
+{
+       va_list ap;
+       va_start(ap, fmt);
+       stat_ev_vprintf(ev, key, fmt, ap);
+       va_end(ap);
+}
+
+void stat_ev_tim_push(void)
+{
+       timing_ticks_t temp;
+       int sp = stat_ev_timer_sp++;
+       timing_ticks(temp);
+       if (sp == 0) {
+               timing_enter_max_prio();
+       } else {
+               timing_ticks_sub(temp, stat_ev_timer_start[sp - 1]);
+               timing_ticks_add(stat_ev_timer_elapsed[sp - 1], temp);
+       }
+       timing_ticks_init(stat_ev_timer_elapsed[sp]);
+       timing_ticks(stat_ev_timer_start[sp]);
+}
+
+void stat_ev_tim_pop(const char *name)
+{
+       int sp;
+       timing_ticks_t temp;
+       timing_ticks(temp);
+       sp = --stat_ev_timer_sp;
+       timing_ticks_sub(temp, stat_ev_timer_start[sp]);
+       timing_ticks_add(stat_ev_timer_elapsed[sp], temp);
+       if (name != NULL && stat_ev_enabled)
+               stat_ev_printf('E', name, "%g", timing_ticks_dbl(stat_ev_timer_elapsed[sp]));
+       if (sp == 0) {
+               timing_leave_max_prio();
+       } else {
+               timing_ticks(stat_ev_timer_start[sp - 1]);
+       }
+}
+
+void do_stat_ev_ctx_push_vfmt(const char *key, const char *fmt, va_list ap)
+{
+       stat_ev_tim_push();
+       stat_ev_vprintf('P', key, fmt, ap);
+       stat_ev_tim_pop(NULL);
+}
+
+void (stat_ev_ctx_push_fmt)(const char *key, const char *fmt, ...)
+{
+       if (!stat_ev_enabled)
+               return;
+
+       va_list ap;
+       va_start(ap, fmt);
+       do_stat_ev_ctx_push_vfmt(key, fmt, ap);
+       va_end(ap);
+}
+
+void (stat_ev_ctx_push_str)(const char *key, const char *str)
+{
+       stat_ev_ctx_push_str_(key, str);
+}
+
+void do_stat_ev_ctx_pop(const char *key)
+{
+       stat_ev_tim_push();
+       stat_ev_printf('O', key, NULL);
+       stat_ev_tim_pop(NULL);
+}
+
+void (stat_ev_ctx_pop)(const char *key)
+{
+       stat_ev_ctx_pop_(key);
+}
+
+void do_stat_ev_dbl(const char *name, double value)
+{
+       stat_ev_tim_push();
+       stat_ev_printf('E', name, "%g", value);
+       stat_ev_tim_pop(NULL);
+}
+
+void (stat_ev_dbl)(const char *name, double value)
+{
+       stat_ev_dbl_(name, value);
+}
+
+void do_stat_ev_int(const char *name, int value)
+{
+       stat_ev_tim_push();
+       stat_ev_printf('E', name, "%d", value);
+       stat_ev_tim_pop(NULL);
+}
+
+void (stat_ev_int)(const char *name, int value)
+{
+       stat_ev_int_(name, value);
+}
+
+void do_stat_ev_ull(const char *name, unsigned long long value)
+{
+       stat_ev_tim_push();
+       stat_ev_printf('E', name, "%llu", value);
+       stat_ev_tim_pop(NULL);
+}
+
+void (stat_ev_ull)(const char *name, unsigned long long value)
+{
+       stat_ev_ull_(name, value);
+}
+
+void do_stat_ev(const char *name)
+{
+       stat_ev_tim_push();
+       stat_ev_printf('E', name, "0.0");
+       stat_ev_tim_pop(NULL);
+}
+
+void (stat_ev)(const char *name)
+{
+       stat_ev_(name);
+}
+
 void stat_ev_begin(const char *prefix, const char *filt)
 {
        char buf[512];
@@ -102,7 +219,4 @@ void stat_ev_end(void)
        }
        if (filter != NULL)
                regfree(filter);
-       regfree(filter);
 }
-
-#endif