 @@ -1,560 +1,15 @@
-$NetBSD: patch-revert-37d3828773e2f847bb1ed7522b0af4fb8e736fc8,v 1.1 2013/06/11 19:26:28 asau Exp $
+$NetBSD: patch-revert-37d3828773e2f847bb1ed7522b0af4fb8e736fc8,v 1.2 2013/06/15 21:17:23 asau Exp $
-Revert revision 37d3828773e2f847bb1ed7522b0af4fb8e736fc8
+Suppress test introduced by revision 37d3828773e2f847bb1ed7522b0af4fb8e736fc8
 which breaks build on NetBSD.
 diff --git a/contrib/sb-sprof/Makefile contrib/sb-sprof/Makefile
 index 7373c72..463ae52 100644
 --- contrib/sb-sprof/Makefile
 +++ contrib/sb-sprof/Makefile
 @@ -2,4 +2,4 @@ MODULE=sb-sprof
  include ../vanilla-module.mk
  test::
 -	$(SBCL) --eval '(load (format nil "SYS:CONTRIB;~:@(~A~);TEST.LISP" "$(MODULE)"))' </dev/null
 +	        true
 diff --git contrib/sb-sprof/sb-sprof.lisp contrib/sb-sprof/sb-sprof.lisp
 index 0d81649..775924a 100644
 --- contrib/sb-sprof/sb-sprof.lisp
 +++ contrib/sb-sprof/sb-sprof.lisp
@@ -792,9 +792,7 @@ The following keyword args are recognized:
                                      :mode mode))
        (enable-call-counting)
        (setf *profiled-threads* threads)
 -      (sb-sys:enable-interrupt sb-unix:sigprof
 -                               #'sigprof-handler
 -                               :synchronous t)
 +      (sb-sys:enable-interrupt sb-unix:sigprof #'sigprof-handler)
        (ecase mode
          (:alloc
           (let ((alloc-signal (1- alloc-interval)))
@@ -1407,23 +1405,6 @@ functions during statistical profiling."
    (with-profiling (:reset t :max-samples 1000 :report :graph)
      (test-0 7)))
 -(defun consalot ()
 -  (let ((junk '()))
 -    (loop repeat 10000 do
 -         (push (make-array 10) junk))
 -    junk))
 -(defun consing-test ()
 -  ;; 0.0001 chosen so that it breaks rather reliably when sprof does not
 -  ;; respect pseudo atomic.
 -  (with-profiling (:reset t :sample-interval 0.0001 :report :graph :loop nil)
 -    (let ((target (+ (get-universal-time) 15)))
 -      (princ #\.)
 -      (force-output)
 -      (loop
 -         while (< (get-universal-time) target)
 -         do (consalot)))))
  ;;; provision
  (provide 'sb-sprof)
 diff --git make-config.sh make-config.sh
 index 6b720e0..1a0a547 100644
 --- make-config.sh
 +++ make-config.sh
@@ -544,7 +544,6 @@ case "$sbcl_os" in
          # roughly-equivalent magic nevertheless:)
          printf ' :sb-dynamic-core :os-provides-dlopen' >> $ltf
          printf ' :sb-thread :sb-safepoint :sb-thruption :sb-wtimer' >> $ltf
 -        printf ' :sb-safepoint-strictly' >> $ltf
          link_or_copy Config.$sbcl_arch-win32 Config
          link_or_copy $sbcl_arch-win32-os.h target-arch-os.h
 diff --git package-data-list.lisp-expr package-data-list.lisp-expr
 index 691a040..03ab6ee 100644
 --- package-data-list.lisp-expr
 +++ package-data-list.lisp-expr
@@ -2023,8 +2023,6 @@ is a good idea, but see SB-SYS re. blurring of boundaries."
                 "THREAD-NAME"
                 "THREAD-YIELD"
                 "FOREIGN-THREAD"
 -               #!+(and sb-safepoint-strictly (not win32))
 -               "SIGNAL-HANDLING-THREAD"
                 ;; Memory barrier
                 "BARRIER"
                 ;; Mutexes
 diff --git src/code/target-signal.lisp src/code/target-signal.lisp
 index 3fd22f3..9fab9d1 100644
 --- src/code/target-signal.lisp
 +++ src/code/target-signal.lisp
@@ -117,25 +117,11 @@
  (sb!alien:define-alien-routine ("install_handler" install-handler)
                                 sb!alien:unsigned-long
    (signal sb!alien:int)
 -  (handler sb!alien:unsigned-long)
 -  (synchronous boolean))
 +  (handler sb!alien:unsigned-long))
  ;;;; interface to enabling and disabling signal handlers
 -;;; Note on the SYNCHRONOUS argument: On builds without pseudo-atomic,
 -;;; we have no way of knowing whether interrupted code was in an
 -;;; allocation sequence, and cannot delay signals until after
 -;;; allocation.  Any signal that can occur asynchronously must be
 -;;; considered unsafe for immediate execution, and the invocation of its
 -;;; lisp handler will get delayed into a newly spawned signal handler
 -;;; thread.  However, there are signals which we must handle
 -;;; immediately, because they occur synchonously (hence the boolean flag
 -;;; SYNCHRONOUS to this function), luckily implying that the signal
 -;;; happens only in specific places (illegal instructions, floating
 -;;; point instructions, certain system calls), hopefully ruling out the
 -;;; possibility that we would trigger it during allocation.
 -(defun enable-interrupt (signal handler &key synchronous)
 +(defun enable-interrupt (signal handler)
    (declare (type (or function fixnum (member :default :ignore)) handler))
    (/show0 "enable-interrupt")
    (flet ((run-handler (&rest args)
@@ -149,8 +135,7 @@
                                         (:ignore sig-ign)
                                         (t
                                          (sb!kernel:get-lisp-obj-address
 -                                         #'run-handler)))
 -                                     synchronous)))
 +                                         #'run-handler))))))
          (cond ((= result sig-dfl) :default)
                ((= result sig-ign) :ignore)
                (t (the (or function fixnum)
@@ -162,26 +147,6 @@
  (defun ignore-interrupt (signal)
    (enable-interrupt signal :ignore))
 -;;;; Support for signal handlers which aren't.
 -;;;;
 -;;;; On safepoint builds, user-defined Lisp signal handlers do not run
 -;;;; in the handler for their signal, because we have no pseudo atomic
 -;;;; mechanism to prevent handlers from hitting during allocation.
 -;;;; Rather, the signal spawns off a fresh native thread, which calls
 -;;;; into lisp with a fake context through this callback:
 -#!+(and sb-safepoint-strictly (not win32))
 -(defun signal-handler-callback (run-handler signal args)
 -  (sb!thread::initial-thread-function-trampoline
 -   (sb!thread::make-signal-handling-thread :name "signal handler"
 -                                           :signal-number signal)
 -   nil (lambda ()
 -         (let* ((info (sb!sys:sap-ref-sap args 0))
 -                (context (sb!sys:sap-ref-sap args sb!vm:n-word-bytes)))
 -           (funcall run-handler signal info context)))
 -   nil nil nil nil))
  ;;;; default LISP signal handlers
  ;;;;
  ;;;; Most of these just call ERROR to report the presence of the signal.
@@ -272,13 +237,13 @@
    "Enable all the default signals that Lisp knows how to deal with."
    (enable-interrupt sigint #'sigint-handler)
    (enable-interrupt sigterm #'sigterm-handler)
 -  (enable-interrupt sigill #'sigill-handler :synchronous t)
 +  (enable-interrupt sigill #'sigill-handler)
    #!-linux
    (enable-interrupt sigemt #'sigemt-handler)
 -  (enable-interrupt sigfpe #'sb!vm:sigfpe-handler :synchronous t)
 -  (enable-interrupt sigbus #'sigbus-handler :synchronous t)
 +  (enable-interrupt sigfpe #'sb!vm:sigfpe-handler)
 +  (enable-interrupt sigbus #'sigbus-handler)
    #!-linux
 -  (enable-interrupt sigsys #'sigsys-handler :synchronous t)
 +  (enable-interrupt sigsys #'sigsys-handler)
    #!-sb-wtimer
    (enable-interrupt sigalrm #'sigalrm-handler)
    #!-sb-thruption
 diff --git src/code/thread.lisp src/code/thread.lisp
 index 3d1ecd4..2cfd567 100644
 --- src/code/thread.lisp
 +++ src/code/thread.lisp
@@ -42,14 +42,6 @@ in future versions."
    "Type of native threads which are attached to the runtime as Lisp threads
  temporarily.")
 -#!+(and sb-safepoint-strictly (not win32))
 -(def!struct (signal-handling-thread
 -             (:include foreign-thread)
 -             (:conc-name "THREAD-"))
 -  #!+sb-doc
 -  "Asynchronous signal handling thread."
 -  (signal-number nil :type integer))
  (def!struct mutex
    #!+sb-doc
    "Mutex type."
 diff --git src/compiler/generic/objdef.lisp src/compiler/generic/objdef.lisp
 index 262f472..fda2758 100644
 --- src/compiler/generic/objdef.lisp
 +++ src/compiler/generic/objdef.lisp
@@ -434,8 +434,6 @@
    #!+sb-safepoint (csp-around-foreign-call :c-type "lispobj *")
    #!+sb-safepoint (pc-around-foreign-call :c-type "lispobj *")
    #!+win32 (synchronous-io-handle-and-flag :c-type "HANDLE" :length 1)
 -  #!+(and sb-safepoint-strictly (not win32))
 -  (sprof-alloc-region :c-type "struct alloc_region" :length 5)
    ;; KLUDGE: On alpha, until STEPPING we have been lucky and the 32
    ;; bit slots came in pairs. However the C compiler will align
    ;; interrupt_contexts on a double word boundary. This logic should
 diff --git src/compiler/generic/parms.lisp src/compiler/generic/parms.lisp
 index 4661321..ca556c2 100644
 --- src/compiler/generic/parms.lisp
 +++ src/compiler/generic/parms.lisp
@@ -124,9 +124,7 @@
      fdefinition-object
      #!+win32 sb!kernel::handle-win32-exception
      #!+sb-thruption sb!thread::run-interruption
 -    #!+sb-safepoint sb!thread::enter-foreign-callback
 -    #!+(and sb-safepoint-strictly (not win32))
 -    sb!unix::signal-handler-callback))
 +    #!+sb-safepoint sb!thread::enter-foreign-callback))
  (defparameter *common-static-symbols*
    '(t
 diff --git src/compiler/ppc/macros.lisp src/compiler/ppc/macros.lisp
 index 262cc10..2fdfb7e 100644
 --- src/compiler/ppc/macros.lisp
 +++ src/compiler/ppc/macros.lisp
@@ -336,9 +336,6 @@
  ;;; trap if ALLOC-TN's negative (handling the deferred interrupt) and
  ;;; using FLAG-TN - minus the large constant - to correct ALLOC-TN.
  (defmacro pseudo-atomic ((flag-tn) &body forms)
 -  #!+sb-safepoint-strictly
 -  `(progn ,flag-tn ,@forms (emit-safepoint))
 -  #!-sb-safepoint-strictly
    `(progn
       (without-scheduling ()
         ;; Extra debugging stuff:
 diff --git src/compiler/x86-64/macros.lisp src/compiler/x86-64/macros.lisp
 index a397573..11a06fc 100644
 --- src/compiler/x86-64/macros.lisp
 +++ src/compiler/x86-64/macros.lisp
@@ -303,9 +303,9 @@
  #!+sb-thread
  (defmacro pseudo-atomic (&rest forms)
 -  #!+sb-safepoint-strictly
 +  #!+win32
    `(progn ,@forms (emit-safepoint))
 -  #!-sb-safepoint-strictly
 +  #!-win32
    (with-unique-names (label)
      `(let ((,label (gen-label)))
         (inst mov (make-ea :qword
 diff --git src/compiler/x86/macros.lisp src/compiler/x86/macros.lisp
 index 4050640..d7b6bc2 100644
 --- src/compiler/x86/macros.lisp
 +++ src/compiler/x86/macros.lisp
@@ -408,9 +408,9 @@
  #!+sb-thread
  (defmacro pseudo-atomic (&rest forms)
 -  #!+sb-safepoint-strictly
 +  #!+win32
    `(progn ,@forms (emit-safepoint))
 -  #!-sb-safepoint-strictly
 +  #!-win32
    (with-unique-names (label)
      `(let ((,label (gen-label)))
         (inst mov (make-ea :dword :disp (* 4 thread-pseudo-atomic-bits-slot))
 diff --git src/runtime/gencgc.c src/runtime/gencgc.c
 index f4ffd2f..5829b5a 100644
 --- src/runtime/gencgc.c
 +++ src/runtime/gencgc.c
@@ -4306,7 +4306,9 @@ general_alloc(sword_t nbytes, int page_type_flag)
  lispobj AMD64_SYSV_ABI *
  alloc(long nbytes)
 -#ifdef LISP_FEATURE_SB_SAFEPOINT_STRICTLY
 +#ifdef LISP_FEATURE_WIN32
 +    /* WIN32 is currently the only platform where inline allocation is
 +     * not pseudo atomic. */
      struct thread *self = arch_os_get_current_thread();
      int was_pseudo_atomic = get_pseudo_atomic_atomic(self);
      if (!was_pseudo_atomic)
@@ -4317,7 +4319,7 @@ alloc(long nbytes)
      lispobj *result = general_alloc(nbytes, BOXED_PAGE_FLAG);
 -#ifdef LISP_FEATURE_SB_SAFEPOINT_STRICTLY
 +#ifdef LISP_FEATURE_WIN32
      if (!was_pseudo_atomic)
          clear_pseudo_atomic_atomic(self);
  #endif
@@ -4432,12 +4434,8 @@ void gc_alloc_update_all_page_tables(void)
      /* Flush the alloc regions updating the tables. */
      struct thread *th;
 -    for_each_thread(th) {
 +    for_each_thread(th)
          gc_alloc_update_page_tables(BOXED_PAGE_FLAG, &th->alloc_region);
 -#if defined(LISP_FEATURE_SB_SAFEPOINT_STRICTLY) && !defined(LISP_FEATURE_WIN32)
 -        gc_alloc_update_page_tables(BOXED_PAGE_FLAG, &th->sprof_alloc_region);
 -#endif
 -    }
      gc_alloc_update_page_tables(UNBOXED_PAGE_FLAG, &unboxed_region);
      gc_alloc_update_page_tables(BOXED_PAGE_FLAG, &boxed_region);
 diff --git src/runtime/interrupt.c src/runtime/interrupt.c
 index 882e2bb..d23dbd7 100644
 --- src/runtime/interrupt.c
 +++ src/runtime/interrupt.c
@@ -1779,89 +1779,6 @@ see_if_sigaction_nodefer_works(void)
  #undef SA_NODEFER_TEST_BLOCK_SIGNAL
  #undef SA_NODEFER_TEST_KILL_SIGNAL
 -#if defined(LISP_FEATURE_SB_SAFEPOINT_STRICTLY) && !defined(LISP_FEATURE_WIN32)
 -static void *
 -signal_thread_trampoline(void *pthread_arg)
 -{
 -    int signo = (int) pthread_arg;
 -    os_context_t fake_context;
 -    siginfo_t fake_info;
 -#ifdef LISP_FEATURE_PPC
 -    mcontext_t uc_regs;
 -#endif
 -    memset(&fake_info, 0, sizeof(fake_info));
 -    memset(&fake_context, 0, sizeof(fake_context));
 -#ifdef LISP_FEATURE_PPC
 -    memset(&uc_regs, 0, sizeof(uc_regs));
 -    fake_context.uc_mcontext.uc_regs = &uc_regs;
 -#endif
 -    *os_context_pc_addr(&fake_context) = &signal_thread_trampoline;
 -#ifdef ARCH_HAS_STACK_POINTER /* aka x86(-64) */
 -    *os_context_sp_addr(&fake_context) = __builtin_frame_address(0);
 -#endif
 -    signal_handler_callback(interrupt_handlers[signo].lisp,
 -                            signo, &fake_info, &fake_context);
 -    return 0;
 -}
 -static void
 -sigprof_handler_trampoline(int signal, siginfo_t *info, void *void_context)
 -{
 -    SAVE_ERRNO(signal,context,void_context);
 -    struct thread *self = arch_os_get_current_thread();
 -    /* alloc() is not re-entrant and still uses pseudo atomic (even though
 -     * inline allocation does not).  In this case, give up. */
 -    if (get_pseudo_atomic_atomic(self))
 -        goto cleanup;
 -    struct alloc_region tmp = self->alloc_region;
 -    self->alloc_region = self->sprof_alloc_region;
 -    self->sprof_alloc_region = tmp;
 -    interrupt_handle_now_handler(signal, info, void_context);
 -    /* And we're back.  We know that the SIGPROF handler never unwinds
 -     * non-locally, and can simply swap things back: */
 -    tmp = self->alloc_region;
 -    self->alloc_region = self->sprof_alloc_region;
 -    self->sprof_alloc_region = tmp;
 -cleanup:
 -    ; /* Dear C compiler, it's OK to have a label here. */
 -    RESTORE_ERRNO;
 -}
 -static void
 -spawn_signal_thread_handler(int signal, siginfo_t *info, void *void_context)
 -{
 -    SAVE_ERRNO(signal,context,void_context);
 -    pthread_attr_t attr;
 -    pthread_t th;
 -    if (pthread_attr_init(&attr))
 -        goto lost;
 -    if (pthread_attr_setstacksize(&attr, thread_control_stack_size))
 -        goto lost;
 -    if (pthread_create(&th, &attr, &signal_thread_trampoline, (void*) signal))
 -        goto lost;
 -    if (pthread_attr_destroy(&attr))
 -        goto lost;
 -    RESTORE_ERRNO;
 -    return;
 -lost:
 -    lose("spawn_signal_thread_handler");
 -}
 -#endif
  static void
  unblock_me_trampoline(int signal, siginfo_t *info, void *void_context)
@@ -1946,8 +1863,7 @@ undoably_install_low_level_interrupt_handler (int signal,
  /* This is called from Lisp. */
  uword_t
 -install_handler(int signal, void handler(int, siginfo_t*, os_context_t*),
 -                int synchronous)
 +install_handler(int signal, void handler(int, siginfo_t*, os_context_t*))
  #ifndef LISP_FEATURE_WIN32
      struct sigaction sa;
@@ -1964,12 +1880,6 @@ install_handler(int signal, void handler(int, siginfo_t*, os_context_t*),
          if (ARE_SAME_HANDLER(handler, SIG_DFL) ||
              ARE_SAME_HANDLER(handler, SIG_IGN))
              sa.sa_sigaction = (void (*)(int, siginfo_t*, void*))handler;
 -#ifdef LISP_FEATURE_SB_SAFEPOINT_STRICTLY
 -        else if (signal == SIGPROF)
 -            sa.sa_sigaction = sigprof_handler_trampoline;
 -        else if (!synchronous)
 -            sa.sa_sigaction = spawn_signal_thread_handler;
 -#endif
          else if (sigismember(&deferrable_sigset, signal))
              sa.sa_sigaction = maybe_now_maybe_later;
          else if (!sigaction_nodefer_works &&
 diff --git src/runtime/interrupt.h src/runtime/interrupt.h
 index 07b4a2d..a27eb08 100644
 --- src/runtime/interrupt.h
 +++ src/runtime/interrupt.h
@@ -158,8 +158,7 @@ extern void undoably_install_low_level_interrupt_handler (
                          int signal,
                          interrupt_handler_t handler);
  extern uword_t install_handler(int signal,
 -                               interrupt_handler_t handler,
 -                               int synchronous);
 +                                     interrupt_handler_t handler);
  extern union interrupt_handler interrupt_handlers[NSIG];
 diff --git src/runtime/runtime.c src/runtime/runtime.c
 index 49c007b..3bc18ee 100644
 --- src/runtime/runtime.c
 +++ src/runtime/runtime.c
@@ -95,7 +95,7 @@ void
  sigint_init(void)
      SHOW("entering sigint_init()");
 -    install_handler(SIGINT, sigint_handler, 1);
 +    install_handler(SIGINT, sigint_handler);
      SHOW("leaving sigint_init()");
 diff --git src/runtime/safepoint.c src/runtime/safepoint.c
 index 45af50e..a9e578c 100644
 --- src/runtime/safepoint.c
 +++ src/runtime/safepoint.c
@@ -966,26 +966,6 @@ handle_safepoint_violation(os_context_t *ctx, os_vm_address_t fault_address)
  #endif /* LISP_FEATURE_WIN32 */
 -#if defined(LISP_FEATURE_SB_SAFEPOINT_STRICTLY) && !defined(LISP_FEATURE_WIN32)
 -void
 -signal_handler_callback(lispobj run_handler, int signo, void *info, void *ctx)
 -{
 -    init_thread_data scribble;
 -    void *args[2];
 -    args[0] = info;
 -    args[1] = ctx;
 -    attach_os_thread(&scribble);
 -    odxprint(misc, "callback from signal handler thread for: %d\n", signo);
 -    funcall3(StaticSymbolFunction(SIGNAL_HANDLER_CALLBACK),
 -             run_handler, make_fixnum(signo), alloc_sap(args));
 -    detach_os_thread(&scribble);
 -    return;
 -}
 -#endif
  void
  callback_wrapper_trampoline(
  #if !(defined(LISP_FEATURE_X86) || defined(LISP_FEATURE_X86_64))
 diff --git src/runtime/thread.c src/runtime/thread.c
 index 46f8f7d..4d20d0f 100644
 --- src/runtime/thread.c
 +++ src/runtime/thread.c
@@ -401,9 +401,6 @@ undo_init_new_thread(struct thread *th, init_thread_data *scribble)
  #ifdef LISP_FEATURE_SB_SAFEPOINT
      block_blockable_signals(0, 0);
      gc_alloc_update_page_tables(BOXED_PAGE_FLAG, &th->alloc_region);
 -#if defined(LISP_FEATURE_SB_SAFEPOINT_STRICTLY) && !defined(LISP_FEATURE_WIN32)
 -    gc_alloc_update_page_tables(BOXED_PAGE_FLAG, &th->sprof_alloc_region);
 -#endif
      pop_gcing_safety(&scribble->safety);
      lock_ret = pthread_mutex_lock(&all_threads_lock);
      gc_assert(lock_ret == 0);
@@ -421,9 +418,6 @@ undo_init_new_thread(struct thread *th, init_thread_data *scribble)
      gc_assert(lock_ret == 0);
      gc_alloc_update_page_tables(BOXED_PAGE_FLAG, &th->alloc_region);
 -#if defined(LISP_FEATURE_SB_SAFEPOINT_STRICTLY) && !defined(LISP_FEATURE_WIN32)
 -    gc_alloc_update_page_tables(BOXED_PAGE_FLAG, &th->sprof_alloc_region);
 -#endif
      unlink_thread(th);
      pthread_mutex_unlock(&all_threads_lock);
      gc_assert(lock_ret == 0);
@@ -706,9 +700,6 @@ create_thread_struct(lispobj initial_function) {
  #endif
  #ifdef LISP_FEATURE_GENCGC
      gc_set_region_empty(&th->alloc_region);
 -# if defined(LISP_FEATURE_SB_SAFEPOINT_STRICTLY) && !defined(LISP_FEATURE_WIN32)
 -    gc_set_region_empty(&th->sprof_alloc_region);
 -# endif
  #endif
  #ifdef LISP_FEATURE_SB_THREAD
      /* This parallels the same logic in globals.c for the
 diff --git src/runtime/thread.h src/runtime/thread.h
 index 1a004c0..8bde9ba 100644
 --- src/runtime/thread.h
 +++ src/runtime/thread.h
@@ -422,11 +422,6 @@ int check_pending_thruptions(os_context_t *ctx);
  void attach_os_thread(init_thread_data *);
  void detach_os_thread(init_thread_data *);
 -# if defined(LISP_FEATURE_SB_SAFEPOINT_STRICTLY) && !defined(LISP_FEATURE_WIN32)
 -void signal_handler_callback(lispobj, int, void *, void *);
 -# endif
  #endif
  extern void create_initial_thread(lispobj);
 diff --git tests/signals.impure.lisp tests/signals.impure.lisp
 index c4f347e..716580c 100644
 --- tests/signals.impure.lisp
 +++ tests/signals.impure.lisp
@@ -70,15 +70,9 @@
                    :skipped-on :win32)
    (assert (eq :condition
                (handler-case
 -                  (progn
 -                    (sb-thread::kill-safely
 -                     (sb-thread::thread-os-thread sb-thread::*current-thread*)
 -                     sb-unix:sigint)
 -                    #+sb-safepoint-strictly
 -                    ;; In this case, the signals handler gets invoked
 -                    ;; indirectly through an INTERRUPT-THREAD.  Give it
 -                    ;; enough time to hit.
 -                    (sleep 1))
 +                  (sb-thread::kill-safely
 +                   (sb-thread::thread-os-thread sb-thread::*current-thread*)
 +                   sb-unix:sigint)
                  (sb-sys:interactive-interrupt ()
                    :condition)))))
 diff --git tests/test-util.lisp tests/test-util.lisp
 index 20b2c54..1d44174 100644
 --- tests/test-util.lisp
 +++ tests/test-util.lisp
@@ -69,10 +69,6 @@
                      (setf ,threads (union (union *threads-to-kill*
                                                   *threads-to-join*)
                                            ,threads))
 -                    #+(and sb-safepoint-strictly (not win32))
 -                    (dolist (thread (sb-thread:list-all-threads))
 -                      (when (typep thread 'sb-thread:signal-handling-thread)
 -                        (ignore-errors (sb-thread:join-thread thread))))
                      (dolist (thread (sb-thread:list-all-threads))
                        (unless (or (not (sb-thread:thread-alive-p thread))
                                    (eql thread sb-thread:*current-thread*)

 @@ -1,17 +1,18 @@
-# $NetBSD: Makefile,v 1.47 2013/06/11 19:26:28 asau Exp $
+# $NetBSD: Makefile,v 1.48 2013/06/15 21:17:23 asau Exp $
 DISTNAME=		${PKGNAME_NOREV}-source
 PKGNAME=		sbcl-1.1.8
 PKGREVISION=		1
 CATEGORIES=		lang
 MASTER_SITES=		${MASTER_SITE_SOURCEFORGE:=sbcl/}
 EXTRACT_SUFX=		.tar.bz2
 MAINTAINER=		asau@NetBSD.org
 HOMEPAGE=		http://www.sbcl.org/
 COMMENT=		SBCL, a Common Lisp implementation
 # SBCL creates a new release with minor updates and fixes every
 # month.  The maintainer of this package does not have the time
 # to build, test, update, etc. this package that often.  If you
 # would like a newer (or older) version, this works very often:
 # 1) change the PKGNAME variable above as desired

 @@ -1,9 +1,9 @@
-$NetBSD: distinfo,v 1.30 2013/06/11 19:26:28 asau Exp $
+$NetBSD: distinfo,v 1.31 2013/06/15 21:17:23 asau Exp $
 SHA1 (sbcl-1.1.8-source.tar.bz2) = 559b6d0ae455fbf42188b43f8900cba6adb0747f
 RMD160 (sbcl-1.1.8-source.tar.bz2) = cc39d5ff7b467e17cfacc3f60265f848a0bad520
 Size (sbcl-1.1.8-source.tar.bz2) = 4108784 bytes
 SHA1 (patch-ab) = 52753efa24fc03e5604f6cb4ef2a7bbd3f40b6a6
 SHA1 (patch-ad) = 4a10e7d498b686a09b067c527010981c15f0f8c8
 SHA1 (patch-ae) = da24df72525afdee0433d557bf4ebb764fee1d24
-SHA1 (patch-revert-37d3828773e2f847bb1ed7522b0af4fb8e736fc8) = b27a9dc6adf425b35456f1b2b5d8fffd7e026db9
+SHA1 (patch-revert-37d3828773e2f847bb1ed7522b0af4fb8e736fc8) = 58498d7f7e5a789fa9b2af1ec2460079ac6c05ac