Add odxprint, a replacement for FSHOW which can be configured at run-time

[sbcl.git] / src / runtime / runtime.h

diff --git a/src/runtime/runtime.h b/src/runtime/runtime.h
index e99d86b..4fb9539 100644 (file)
--- a/src/runtime/runtime.h
+++ b/src/runtime/runtime.h
@@ -35,8 +35,18 @@ void unmap_gc_page();
 int check_pending_interrupts();
 #endif
 
-/* Block blockable interrupts for each SHOW, if not 0. */
+/*
+ * The next few defines serve as configuration -- edit them inline if
+ * you are a developer and want to affect FSHOW behaviour.
+ */
+
+/* Block blockable interrupts for each SHOW, if not 0.
+ * (On Windows, this setting has no effect.)
+ *
+ * In principle, this is a "configuration option", but I am not aware of
+ * any reason why or when it would be advantageous to disable it. */
 #define QSHOW_SIGNAL_SAFE 1
+
 /* Enable extra-verbose low-level debugging output for signals? (You
  * probably don't want this unless you're trying to debug very early
  * cold boot on a new machine, or one where you've just messed up
@@ -46,14 +56,70 @@ int check_pending_interrupts();
  * causes output from signal handlers, and the i/o libraries aren't
  * necessarily reentrant. But it can still be very convenient for
  * figuring out what's going on when you have a signal handling
- * problem. */
-#define QSHOW_SIGNALS 0
+ * problem.
+ *
+ * Possible values are:
+ *   0 -- Never show signal-related output.  There is absolutely no
+ *        run-time overhead from FSHOW_SIGNAL in this case.
+ *
+ *   1 -- (recommended)
+ *        Show signal-related output only if selected at run-time
+ *        (otherwise almost no run-time overhead).
+ *
+ *   2 -- Unconditionally show signal-related output.
+ *        Very significant overhead.
+ *
+ * For reasons of tradition, we default to 0 on POSIX and 1 on Windows
+ * through :SB-QSHOW.
+ *
+ * With option 1, set up environment variable SBCL_DYNDEBUG to include
+ * "fshow" or "fshow_signal" before starting SBCL to enable output.
+ *
+ * There is no particular advantage to option 2 except that you do not
+ * need to set environment variables in this case.
+ */
+#ifdef LISP_FEATURE_SB_QSHOW
+# define QSHOW_SIGNALS 1
+#else
+# define QSHOW_SIGNALS 0
+#endif
+
 /* Enable low-level debugging output, if not zero. Defaults to enabled
- * if QSHOW_SIGNALS, disabled otherwise. Change it to 1 if you want
+ * if QSHOW_SIGNALS, disabled otherwise. Change it to 1 or 2 if you want
  * low-level debugging output but not the whole signal mess. */
 #define QSHOW QSHOW_SIGNALS
 
-#if QSHOW
+/*
+ * Configuration options end here -- the following defines do not
+ * generally need customization.
+ */
+
+#define odxprint(topic, fmt, ...)                       \
+    do                                                  \
+        if (dyndebug_config.dyndebug_##topic)           \
+            odxprint_fun(fmt "\n", ##__VA_ARGS__);      \
+    while (0)
+
+void odxprint_fun(const char *fmt, ...);
+void fshow_fun(void *ignored, const char *fmt, ...);
+
+/* Flags defined in a structure to avoid code duplication between
+ * declaration and definition. */
+extern struct dyndebug_config {
+    int dyndebug_fshow;
+    int dyndebug_fshow_signal;
+    int dyndebug_gencgc_verbose;
+    int dyndebug_safepoints;
+    int dyndebug_seh;
+    int dyndebug_misc;
+    int dyndebug_pagefaults;
+} dyndebug_config;
+
+#ifdef LISP_FEATURE_GENCGC
+extern int gencgc_verbose;
+#endif
+
+void dyndebug_init(void);
 
 #if QSHOW_SIGNAL_SAFE == 1 && !defined(LISP_FEATURE_WIN32)
 
@@ -62,39 +128,33 @@ extern sigset_t blockable_sigset;
 
 #define QSHOW_BLOCK                                             \
         sigset_t oldset;                                        \
-        thread_sigmask(SIG_BLOCK, &blockable_sigset, &oldset);
-#define QSHOW_UNBLOCK thread_sigmask(SIG_SETMASK,&oldset,0);
+        thread_sigmask(SIG_BLOCK, &blockable_sigset, &oldset)
+#define QSHOW_UNBLOCK thread_sigmask(SIG_SETMASK,&oldset,0)
 #else
 #define QSHOW_BLOCK
 #define QSHOW_UNBLOCK
 #endif
 
-#ifdef LISP_FEATURE_SB_THREAD
-#define QSHOW_PREFIX fprintf(stderr, "%p ", pthread_self());
-#else
-#define QSHOW_PREFIX
-#endif
-
-#define FSHOW(args)                                             \
-    do {                                                        \
-        QSHOW_BLOCK                                             \
-        QSHOW_PREFIX                                            \
-        fprintf args;                                           \
-        QSHOW_UNBLOCK                                           \
-    } while (0)
-#define SHOW(string) FSHOW((stderr, "/%s\n", string))
+/* The following macros duplicate the expansion of odxprint, because the
+ * extra level of parentheses around `args' prevents us from
+ * implementing FSHOW in terms of odxprint directly.  (They also differ
+ * in a newline.)
+ */
 
+#if QSHOW
+# define FSHOW(args) \
+    do if (dyndebug_config.dyndebug_fshow) fshow_fun args; while (0)
+# define SHOW(string) FSHOW((stderr, "/%s\n", string))
 #else
-
-#define FSHOW(args)
-#define SHOW(string)
-
+# define FSHOW(args)
+# define SHOW(string)
 #endif
 
 #if QSHOW_SIGNALS
-#define FSHOW_SIGNAL FSHOW
+# define FSHOW_SIGNAL(args)                                             \
+    do if (dyndebug_config.dyndebug_fshow_signal) fshow_fun args; while (0)
 #else
-#define FSHOW_SIGNAL(args)
+# define FSHOW_SIGNAL(args)
 #endif
 
 /* KLUDGE: These are in theory machine-dependent and OS-dependent, but