Change [a]sync_sighandler to [a]sync_signalhandler in comments

and in one "if (0)" VG_(printf).

diff --git a/coregrind/m_signals.c b/coregrind/m_signals.c
index 523f4d7fcbafceb2563a81f3eb6867e12823b047..a51840c0a053d36f38a58ddab25a593d9f32b1d8 100644 (file)
--- a/coregrind/m_signals.c
+++ b/coregrind/m_signals.c
@@ -178,7 +178,7 @@
 
        else
        if    thread is blocked in a syscall marked SfMayBlock
-       then  signals may be delivered to async_sighandler, since we
+       then  signals may be delivered to async_signalhandler, since we
              temporarily unblocked them for the duration of the syscall,
              by using the real (SCSS) mask for this thread
 
@@ -2999,7 +2999,7 @@ void sync_signalhandler ( Int sigNo,
    Bool from_user;
 
    if (0) 
-      VG_(printf)("sync_sighandler(%d, %p, %p)\n", sigNo, info, uc);
+      VG_(printf)("sync_signalhandler(%d, %p, %p)\n", sigNo, info, uc);
 
    vg_assert(info != NULL);
    vg_assert(info->si_signo == sigNo);

diff --git a/coregrind/m_syswrap/syswrap-main.c b/coregrind/m_syswrap/syswrap-main.c
index 1a7f038d483dff0641a41bf3a60c8cfbe32c9e1d..5919698f0efad14f99c41edf4a001154ffb2b4f2 100644 (file)
--- a/coregrind/m_syswrap/syswrap-main.c
+++ b/coregrind/m_syswrap/syswrap-main.c
@@ -2512,7 +2512,7 @@ void VG_(client_syscall) ( ThreadId tid, UInt trc )
 
          /* do_syscall_for_client may not return if the syscall was
             interrupted by a signal.  In that case, flow of control is
-            first to m_signals.async_sighandler, which calls
+            first to m_signals.async_signalhandler, which calls
             VG_(fixup_guest_state_after_syscall_interrupted), which
             fixes up the guest state, and possibly calls
             VG_(post_syscall).  Once that's done, control drops back
@@ -2723,9 +2723,9 @@ void VG_(post_syscall) (ThreadId tid)
 
    However, the syscall may get interrupted by an async-signal.  In
    that case do_syscall_for_client/VG_(do_syscall6) do not
-   return.  Instead we wind up in m_signals.async_sighandler.  We need
+   return.  Instead we wind up in m_signals.async_signalhandler.  We need
    to fix up the guest state to make it look like the syscall was
-   interrupted for guest.  So async_sighandler calls here, and this
+   interrupted for guest.  So async_signalhandler calls here, and this
    does the fixup.  Note that from here we wind up calling
    VG_(post_syscall) too.
 */