i386-signal.h (old_i386_kernel_sigaction): New.

2002-03-18  Andrew Haley  <aph@cambridge.redhat.com>

        * include/i386-signal.h (old_i386_kernel_sigaction): New.
        INIT_SEGV: Use old_i386_kernel_sigaction.
        INIT_FP: Likewise.

From-SVN: r50980

diff --git a/libjava/ChangeLog b/libjava/ChangeLog
index 1ef79adc83d3414c17be9c0349082eecc9b15b9e..352e2d1201540486723735e4fc31a2550fac5b7e 100644 (file)
--- a/libjava/ChangeLog
+++ b/libjava/ChangeLog
@@ -1,3 +1,9 @@
+2002-03-18  Andrew Haley  <aph@cambridge.redhat.com>
+
+       * include/i386-signal.h (old_i386_kernel_sigaction): New.
+       INIT_SEGV: Use old_i386_kernel_sigaction.
+       INIT_FP: Likewise.
+
 2002-03-18  Bryce McKinlay  <bryce@waitaki.otago.ac.nz>
 
        * java/lang/natSystem.cc (init_properties): Update VM version

diff --git a/libjava/include/i386-signal.h b/libjava/include/i386-signal.h
index 737b3689d973375a878f962dabf4a297a0c61d1f..6ad496c47a4d247c13194e59ae44ea9115c33889 100644 (file)
--- a/libjava/include/i386-signal.h
+++ b/libjava/include/i386-signal.h
@@ -1,6 +1,7 @@
-// i386-signal.h - Catch runtime signals and turn them into exceptions.
+// i386-signal.h - Catch runtime signals and turn them into exceptions
+// on an i386 based Linux system.
 
-/* Copyright (C) 1998, 1999, 2001  Free Software Foundation
+/* Copyright (C) 1998, 1999, 2001, 2002  Free Software Foundation
 
    This file is part of libgcj.
 
@@ -8,10 +9,6 @@ This software is copyrighted work licensed under the terms of the
 Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
 details.  */
 
-/* This technique should work for all i386 based Unices which conform
- * to iBCS2.  This includes all versions of Linux more recent than 1.3 
- */
-
 
 #ifndef JAVA_SIGNAL_H
 #define JAVA_SIGNAL_H 1
@@ -99,28 +96,40 @@ do                                                                  \
 }                                                                      \
 while (0)
 
-#define INIT_SEGV                                              \
-do                                                             \
-  {                                                            \
-    nullp = new java::lang::NullPointerException ();           \
-    struct sigaction act;                                      \
-    act.sa_handler = catch_segv;                               \
-    sigemptyset (&act.sa_mask);                                        \
-    act.sa_flags = 0;                                          \
-    syscall (SYS_sigaction, SIGSEGV, &act, NULL);              \
-  }                                                            \
+/* We use old_kernel_sigaction here because we're calling the kernel
+   directly rather than via glibc.  The sigaction structure that the
+   syscall uses is a different shape from the one in userland and not
+   visible to us in a header file so we define it here.  */
+
+struct old_i386_kernel_sigaction {
+       void (*k_sa_handler) (int);
+       unsigned long k_sa_mask;
+       unsigned long k_sa_flags;
+       void (*sa_restorer) (void);
+};
+
+#define INIT_SEGV                                      \
+do                                                     \
+  {                                                    \
+    nullp = new java::lang::NullPointerException ();   \
+    struct old_i386_kernel_sigaction kact;             \
+    kact.k_sa_handler = catch_segv;                    \
+    kact.k_sa_mask = 0;                                        \
+    kact.k_sa_flags = 0;                               \
+    syscall (SYS_sigaction, SIGSEGV, &kact, NULL);     \
+  }                                                    \
 while (0)  
 
 #define INIT_FPE                                               \
 do                                                             \
-  {                                                            \
-    arithexception = new java::lang::ArithmeticException       \
+  {                                                            \
+    arithexception = new java::lang::ArithmeticException       \
       (JvNewStringLatin1 ("/ by zero"));                       \
-    struct sigaction act;                                      \
-    act.sa_handler = catch_fpe;                                        \
-    sigemptyset (&act.sa_mask);                                        \
-    act.sa_flags = 0;                                          \
-    syscall (SYS_sigaction, SIGFPE, &act, NULL);               \
+    struct old_i386_kernel_sigaction kact;                     \
+    kact.k_sa_handler = catch_fpe;                             \
+    kact.k_sa_mask = 0;                                                \
+    kact.k_sa_flags = 0;                                       \
+    syscall (SYS_sigaction, SIGFPE, &kact, NULL);              \
   }                                                            \
 while (0)  
 
@@ -133,9 +142,15 @@ while (0)
  * when returning from a signal handler.  If we return from our divide
  * handler to a linuxthreads wrapper, we will lose the PC adjustment
  * we made and return to the faulting instruction again.  Using
- * syscall(SYS_sigaction) causes our handler to be called directly by
- * the kernel, bypassing any wrappers.  This is a kludge, and a future
- * version of this handler will do something better.  */
+ * syscall(SYS_sigaction) causes our handler to be called directly
+ * by the kernel, bypassing any wrappers.
+
+ * Also, there is at the present time no unwind info in the
+ * linuxthreads library's signal handlers and so we can't unwind
+ * through them anyway.  
+
+ * Finally, the code that glibc uses to return from a signal handler
+ * is subject to change.  */
 
 #endif /* JAVA_SIGNAL_H */