libjava/include/dwarf2-signal.h

   1 // dwarf2-signal.h - Catch runtime signals and turn them into exceptions.
   2
   3 /* Copyright (C) 2000, 2001  Free Software Foundation
   4
   5    This file is part of libgcj.
   6
   7    Use this file for a target for which the dwarf2 unwinder in libgcc
   8    can unwind through signal handlers.
   9
  10 This software is copyrighted work licensed under the terms of the
  11 Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
  12 details.  */
  13
  14 #ifndef JAVA_SIGNAL_H
  15 #define JAVA_SIGNAL_H 1
  16
  17 #include <signal.h>
  18 #include <sys/syscall.h>
  19
  20 #define HANDLE_SEGV 1
  21 #undef HANDLE_FPE
  22
  23 #define SIGNAL_HANDLER(_name)   \
  24 static void _Jv_##_name (int, siginfo_t *_sip, void *_p)
  25
  26 class java::lang::Throwable;
  27
  28 // Unwind the stack to the point at which the signal was generated and
  29 // then throw an exception.  With the dwarf2 unwinder we don't usually
  30 // need to do anything, with some minor exceptions.
  31
  32 #ifdef __alpha__
  33 #define MAKE_THROW_FRAME(_exception)                                    \
  34 do                                                                      \
  35 {                                                                       \
  36   /* Alpha either leaves PC pointing at a faulting instruction or the   \
  37    following instruction, depending on the signal.  SEGV always does    \
  38    the former, so we adjust the saved PC to point to the following      \
  39    instruction; this is what the handler in libgcc expects.  */         \
  40   struct sigcontext *_sc = (struct sigcontext *)_p;                     \
  41   _sc->sc_pc += 4;                                                      \
  42 }                                                                       \
  43 while (0)
  44
  45 #elif defined(__ia64__)
  46
  47 #define MAKE_THROW_FRAME(_exception)                                    \
  48 do                                                                      \
  49 {                                                                       \
  50   /* IA-64 either leaves PC pointing at a faulting instruction or the   \
  51    following instruction, depending on the signal.  SEGV always does    \
  52    the former, so we adjust the saved PC to point to the following      \
  53    instruction; this is what the handler in libgcc expects.  */         \
  54   /* Note that we are lying to the unwinder here, which expects the     \
  55    faulting pc, not pc+1.  But we claim the unwind information can't    \
  56    be changed by such a ld or st instruction, so it doesn't matter. */  \
  57   struct sigcontext *_sc = (struct sigcontext *)_p;                     \
  58   _sc->sc_ip++;                                                         \
  59 }                                                                       \
  60 while (0)
  61 #elif defined(__sparc__)
  62 /* We could do the unwind of the signal frame quickly by hand here like
  63    sparc-signal.h does under Solaris, but that makes debugging unwind
  64    failures almost impossible.  */
  65 #if !defined(__arch64__)
  66 #define MAKE_THROW_FRAME(_exception)                                    \
  67 do                                                                      \
  68 {                                                                       \
  69   /* Sparc-32 leaves PC pointing at a faulting instruction              \
  70    always.                                                              \
  71    We advance the PC one instruction past the exception causing PC.     \
  72    This is done because FDEs are found with "context->ra - 1" in the    \
  73    unwinder.                                                            \
  74    Also, the dwarf2 unwind machinery is going to add 8 to the           \
  75    PC it uses on Sparc.  So we adjust the PC here.  We do it here       \
  76    because we run once for such an exception, however the Sparc specific\
  77    unwind can run multiple times for the same exception and it would    \
  78    adjust the PC more than once resulting in a bogus value.  */         \
  79   struct sig_regs {                                                     \
  80     unsigned int psr, pc, npc, y, u_regs[16];                           \
  81   } *regp;                                                              \
  82   unsigned int insn;                                                    \
  83   __asm__ __volatile__("ld [%%i7 + 8], %0" : "=r" (insn));              \
  84   /* mov __NR_sigaction, %g1; Old signal stack layout */                \
  85   if (insn == 0x821020d8)                                               \
  86     regp = (struct sig_regs *) _sip;                                    \
  87   else                                                                  \
  88     /* mov __NR_rt_sigaction, %g1; New signal stack layout */           \
  89     regp = (struct sig_regs *) (_sip + 1);                              \
  90   regp->pc = ((regp->pc + 4) - 8);                                      \
  91 }                                                                       \
  92 while (0)
  93 #else
  94 #define MAKE_THROW_FRAME(_exception)                                    \
  95 do                                                                      \
  96 {                                                                       \
  97   /* Sparc-64 leaves PC pointing at a faulting instruction              \
  98    always.                                                              \
  99    We advance the PC one instruction past the exception causing PC.     \
 100    This is done because FDEs are found with "context->ra - 1" in the    \
 101    unwinder.                                                            \
 102    Also, the dwarf2 unwind machinery is going to add 8 to the           \
 103    PC it uses on Sparc.  So we adjust the PC here.  We do it here       \
 104    because we run once for such an exception, however the Sparc specific\
 105    unwind can run multiple times for the same exception and it would    \
 106    adjust the PC more than once resulting in a bogus value.  */         \
 107   struct pt_regs {                                                      \
 108     unsigned long u_regs[16];                                           \
 109     unsigned long tstate, tpc, tnpc;                                    \
 110     unsigned int y, fprs;                                               \
 111   } *regp = (struct pt_regs *) (_sip + 1);                              \
 112   regp->tpc = ((regp->tpc + 4) - 8);                                    \
 113 }                                                                       \
 114 while (0)
 115 #endif
 116 #else
 117 #define MAKE_THROW_FRAME(_exception)            \
 118 do                                              \
 119 {                                               \
 120   (void)_p;                                     \
 121 }                                               \
 122 while (0)
 123 #endif
 124
 125 #if defined(__sparc__)
 126 #if defined(__arch64__)
 127 extern "C" {
 128     static void __rt_sigreturn_stub(void)
 129     {
 130       __asm__("mov %0, %%g1\n\t"
 131               "ta  0x6d\n\t"
 132               : /* no outputs */
 133               : "i" (__NR_rt_sigreturn));
 134     }
 135     struct kernel_sigaction
 136     {
 137       void (*k_sa_sigaction)(int,siginfo_t *,void *);
 138       unsigned long k_sa_flags;
 139       void (*k_sa_restorer)(void);
 140       sigset_t k_sa_mask;
 141     };
 142 }
 143 #define INIT_SEGV                                               \
 144 do                                                              \
 145   {                                                             \
 146     nullp = new java::lang::NullPointerException ();            \
 147     struct kernel_sigaction act;                                \
 148     unsigned long stub = ((unsigned long)&__rt_sigreturn_stub); \
 149     act.k_sa_sigaction = _Jv_catch_segv;                        \
 150     sigemptyset (&act.k_sa_mask);                               \
 151     act.k_sa_flags = SA_SIGINFO;                                \
 152     act.k_sa_restorer = NULL;                                   \
 153     syscall (SYS_rt_sigaction, SIGSEGV, &act, NULL,             \
 154              stub - 8, _NSIG / 8);                              \
 155   }                                                             \
 156 while (0)
 157
 158 #define INIT_FPE                                                \
 159 do                                                              \
 160   {                                                             \
 161     arithexception = new java::lang::ArithmeticException        \
 162       (JvNewStringLatin1 ("/ by zero"));                        \
 163     struct kernel_sigaction act;                                \
 164     unsigned long stub = ((unsigned long)&__rt_sigreturn_stub); \
 165     act.k_sa_sigaction = _Jv_catch_fpe;                         \
 166     sigemptyset (&act.k_sa_mask);                               \
 167     act.k_sa_flags = SA_SIGINFO;                                \
 168     act.k_sa_restorer = NULL;                                   \
 169     syscall (SYS_rt_sigaction, SIGFPE, &act, NULL,              \
 170              stub - 8, _NSIG / 8);                              \
 171   }                                                             \
 172 while (0)
 173 #else /* __arch64__ */
 174
 175 extern "C" {
 176     struct kernel_sigaction
 177     {
 178       void (*k_sa_sigaction)(int,siginfo_t *,void *);
 179       unsigned long k_sa_mask, k_sa_flags;
 180       void (*k_sa_restorer)(void);
 181     };
 182 }
 183
 184 #define INIT_SEGV                                               \
 185 do                                                              \
 186   {                                                             \
 187     struct kernel_sigaction act;                                \
 188     nullp = new java::lang::NullPointerException ();            \
 189     act.k_sa_sigaction = _Jv_catch_segv;                        \
 190     act.k_sa_mask = 0;                                          \
 191     act.k_sa_flags = SA_SIGINFO;                                \
 192     act.k_sa_restorer = NULL;                                   \
 193     syscall (SYS_sigaction, -SIGSEGV, &act, NULL);              \
 194   }                                                             \
 195 while (0)
 196
 197 #define INIT_FPE                                                \
 198 do                                                              \
 199   {                                                             \
 200     arithexception = new java::lang::ArithmeticException        \
 201       (JvNewStringLatin1 ("/ by zero"));                        \
 202     struct kernel_sigaction act;                                \
 203     act.k_sa_sigaction = _Jv_catch_fpe;                         \
 204     act.k_sa_mask = 0;                                          \
 205     act.k_sa_flags = SA_SIGINFO;                                \
 206     act.k_sa_restorer = NULL;                                   \
 207     syscall (SYS_sigaction, -SIGFPE, &act, NULL);               \
 208   }                                                             \
 209 while (0)
 210 #endif
 211 #elif !defined(__ia64__)
 212 #define INIT_SEGV                                               \
 213 do                                                              \
 214   {                                                             \
 215     nullp = new java::lang::NullPointerException ();            \
 216     struct sigaction act;                                       \
 217     act.sa_sigaction = _Jv_catch_segv;                          \
 218     sigemptyset (&act.sa_mask);                                 \
 219     act.sa_flags = SA_SIGINFO;                                  \
 220     syscall (SYS_sigaction, SIGSEGV, &act, NULL);               \
 221   }                                                             \
 222 while (0)
 223
 224 #define INIT_FPE                                                \
 225 do                                                              \
 226   {                                                             \
 227     arithexception = new java::lang::ArithmeticException        \
 228       (JvNewStringLatin1 ("/ by zero"));                        \
 229     struct sigaction act;                                       \
 230     act.sa_sigaction = _Jv_catch_fpe;                           \
 231     sigemptyset (&act.sa_mask);                                 \
 232     act.sa_flags = SA_SIGINFO;                                  \
 233     syscall (SYS_sigaction, SIGFPE, &act, NULL);                \
 234   }                                                             \
 235 while (0)
 236
 237 /* We use syscall(SYS_sigaction) in INIT_SEGV and INIT_FPE instead of
 238  * sigaction() because on some systems the pthreads wrappers for
 239  * signal handlers are not compiled with unwind information, so it's
 240  * not possible to unwind through them.  This is a problem that will
 241  * go away once all systems have pthreads libraries that are
 242  * compiled with full unwind info.  */
 243
 244 #else  /* __ia64__ */
 245
 246 // On IA64, unwind information is mandatory, so we can unwind
 247 // correctly through glibc frames.  Thus we call the ordinary
 248 // sigaction.
 249
 250 #define INIT_SEGV                                               \
 251 do                                                              \
 252   {                                                             \
 253     nullp = new java::lang::NullPointerException ();            \
 254     struct sigaction act;                                       \
 255     act.sa_sigaction = _Jv_catch_segv;                          \
 256     sigemptyset (&act.sa_mask);                                 \
 257     act.sa_flags = SA_SIGINFO;                                  \
 258     sigaction (SIGSEGV, &act, NULL);                            \
 259   }                                                             \
 260 while (0)
 261
 262 #define INIT_FPE                                                \
 263 do                                                              \
 264   {                                                             \
 265     arithexception = new java::lang::ArithmeticException        \
 266       (JvNewStringLatin1 ("/ by zero"));                        \
 267     struct sigaction act;                                       \
 268     act.sa_sigaction = _Jv_catch_fpe;                           \
 269     sigemptyset (&act.sa_mask);                                 \
 270     act.sa_flags = SA_SIGINFO;                                  \
 271     sigaction (SIGFPE, &act, NULL);                             \
 272   }                                                             \
 273 while (0)
 274 #endif /* __ia64__ || __sparc__ */
 275 #endif /* JAVA_SIGNAL_H */