--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gcc/config/alpha/osf5-unwind.h	Sun Aug 21 07:07:55 2011 +0900
@@ -0,0 +1,329 @@
+/* DWARF2 EH unwinding support for Alpha Tru64.
+   Copyright (C) 2010 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 3, or (at your option) any later
+version.
+
+GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
+
+/* This file implements the MD_FALLBACK_FRAME_STATE_FOR macro, triggered when
+   the GCC table based unwinding process hits a frame for which no unwind info
+   has been registered. This typically occurs when raising an exception from a
+   signal handler, because the handler is actually called from the OS kernel.
+
+   The basic idea is to detect that we are indeed trying to unwind past a
+   signal handler and to fill out the GCC internal unwinding structures for
+   the OS kernel frame as if it had been directly called from the interrupted
+   context.
+
+   This is all assuming that the code to set the handler asked the kernel to
+   pass a pointer to such context information.  */
+
+/* --------------------------------------------------------------------------
+   -- Basic principles of operation:
+   --------------------------------------------------------------------------
+
+   1/ We first need a way to detect if we are trying to unwind past a signal
+      handler.
+
+   The typical method that is used on most platforms is to look at the code
+   around the return address we have and check if it matches the OS code
+   calling a handler.  To determine what this code is expected to be, get a
+   breakpoint into a real signal handler and look at the code around the
+   return address.  Depending on the library versions the pattern of the
+   signal handler is different; this is the reason why we check against more
+   than one pattern.
+
+   On this target, the return address is right after the call and every
+   instruction is 4 bytes long.  For the simple case of a null dereference in
+   a single-threaded app, it went like:
+
+   # Check that we indeed have something we expect: the instruction right
+   # before the return address is within a __sigtramp function and is a call.
+
+   [... run gdb and break at the signal handler entry ...]
+
+   (gdb) x /i $ra-4
+   <__sigtramp+160>: jsr     ra,(a3),0x3ff800d0ed4 <_fpdata+36468>
+
+   # Look at the code around that return address, and eventually observe a
+   # significantly large chunk of *constant* code right before the call:
+
+   (gdb) x /10i  $ra-44
+   <__sigtramp+120>: lda     gp,-27988(gp)
+   <__sigtramp+124>: ldq     at,-18968(gp)
+   <__sigtramp+128>: lda     t0,-1
+   <__sigtramp+132>: stq     t0,0(at)
+   <__sigtramp+136>: ldq     at,-18960(gp)
+   <__sigtramp+140>: ldl     t1,8(at)
+   <__sigtramp+144>: ldq     at,-18960(gp)
+   <__sigtramp+148>: stl     t1,12(at)
+   <__sigtramp+152>: ldq     at,-18960(gp)
+   <__sigtramp+156>: stl     t0,8(at)
+
+   # The hexadecimal equivalent that we will have to match is:
+
+   (gdb) x /10x  $ra-44
+   <__sigtramp+120>: 0x23bd92ac    0xa79db5e8    0x203fffff   0xb43c0000
+   <__sigtramp+136>: 0xa79db5f0    0xa05c0008    0xa79db5f0   0xb05c000c
+   <__sigtramp+152>: 0xa79db5f0    0xb03c0008
+
+   The problem observed on this target with this approach is that although
+   we found a constant set of instruction patterns there were some
+   gp-related offsets that made the machine code to differ from one
+   installation to another.  This problem could have been overcome by masking
+   these offsets, but we found that it would be simpler and more efficient to
+   check whether the return address was part of a signal handler, by comparing
+   it against some expected code offset from __sigtramp.
+
+   # Check that we indeed have something we expect: the instruction
+   # right before the return address is within a __sigtramp
+   # function and is a call. We also need to obtain the offset
+   # between the return address and the start address of __sigtramp.
+
+   [... run gdb and break at the signal handler entry ...]
+
+   (gdb) x /2i $ra-4
+   <__sigtramp+160>: jsr     ra,(a3),0x3ff800d0ed4 <_fpdata+36468>
+   <__sigtramp+164>: ldah    gp,16381(ra)
+
+   (gdb) p (long)$ra - (long)&__sigtramp
+   $2 = 164
+
+   --------------------------------------------------------------------------
+
+   2/ Once we know we are going through a signal handler, we need a way to
+      retrieve information about the interrupted run-time context.
+
+   On this platform, the third handler's argument is a pointer to a structure
+   describing this context (struct sigcontext *). We unfortunately have no
+   direct way to transfer this value here, so a couple of tricks are required
+   to compute it.
+
+   As documented at least in some header files (e.g. sys/machine/context.h),
+   the structure the handler gets a pointer to is located on the stack.  As of
+   today, while writing this macro, we have unfortunately not been able to
+   find a detailed description of the full stack layout at handler entry time,
+   so we'll have to resort to empirism :)
+
+   When unwinding here, we have the handler's CFA at hand, as part of the
+   current unwinding context which is one of our arguments.  We presume that
+   for each call to a signal handler by the same kernel routine, the context's
+   structure location on the stack is always at the same offset from the
+   handler's CFA, and we compute that offset from bare observation:
+
+   For the simple case of a bare null dereference in a single-threaded app,
+   computing the offset was done using GNAT like this:
+
+   # Break on the first handler's instruction, before the prologue to have the
+   # CFA in $sp, and get there:
+
+   (gdb) b *&__gnat_error_handler
+   Breakpoint 1 at 0x120016090: file init.c, line 378.
+
+   (gdb) r
+   Program received signal SIGSEGV, Segmentation fault.
+
+   (gdb) c
+   Breakpoint 1, __gnat_error_handler (sig=..., sip=..., context=...)
+
+   # The displayed argument value are meaningless because we stopped before
+   # their final "homing". We know they are passed through $a0, $a1 and $a2
+   # from the ABI, though, so ...
+
+   # Observe that $sp and the context pointer are in the same (stack) area,
+   # and compute the offset:
+
+   (gdb) p /x $sp
+   $2 = 0x11fffbc80
+
+   (gdb) p /x $a2
+   $3 = 0x11fffbcf8
+
+   (gdb) p /x (long)$a2 - (long)$sp
+   $4 = 0x78
+
+   --------------------------------------------------------------------------
+
+   3/ Once we know we are unwinding through a signal handler and have the
+      address of the structure describing the interrupted context at hand, we
+      have to fill the internal frame-state/unwind-context structures properly
+      to allow the unwinding process to proceed.
+
+   Roughly, we are provided with an *unwinding* CONTEXT, describing the state
+   of some point P in the call chain we are unwinding through.  The macro we
+   implement has to fill a "frame state" structure FS that describe the P's
+   caller state, by way of *rules* to compute its CFA, return address, and
+   **saved** registers *locations*. 
+
+   For the case we are going to deal with, the caller is some kernel code
+   calling a signal handler, and:
+
+   o The saved registers are all in the interrupted run-time context,
+
+   o The CFA is the stack pointer value when the kernel code is entered, that
+     is, the stack pointer value at the interruption point, also part of the
+     interrupted run-time context.
+
+   o We want the return address to appear as the address of the active
+     instruction at the interruption point, so that the unwinder proceeds as
+     if the interruption had been a regular call.  This address is also part
+     of the interrupted run-time context.
+
+   --
+
+   Also, note that there is an important difference between the return address
+   we need to claim for the kernel frame and the value of the return address
+   register at the interruption point.
+
+   The latter might be required to be able to unwind past the interrupted
+   routine, for instance if it is interrupted before saving the incoming
+   register value in its own frame, which may typically happen during stack
+   probes for stack-checking purposes.
+
+   It is then essential that the rules stated to locate the kernel frame
+   return address don't clobber the rules describing where is saved the return
+   address register at the interruption point, so some scratch register state
+   entry should be used for the former. We have DWARF_ALT_FRAME_RETURN_COLUMN
+   at hand exactly for that purpose.
+
+   --------------------------------------------------------------------------
+
+   4/ Depending on the context (single-threaded or multi-threaded app, ...),
+   the code calling the handler and the handler-cfa to interrupted-context
+   offset might change, so we use a simple generic data structure to track
+   the possible variants.  */
+
+/* This is the structure to wrap information about each possible sighandler
+   caller we may have to identify.  */
+
+typedef struct {
+  /* Expected return address when being called from a sighandler.  */
+  void *ra_value;
+
+  /* Offset to get to the sigcontext structure from the handler's CFA
+     when the pattern matches.  */
+  int cfa_to_context_offset;
+
+} sighandler_call_t;
+
+/* Helper macro for MD_FALLBACK_FRAME_STATE_FOR below.
+
+   Look at RA to see if it matches within a sighandler caller.
+   Set SIGCTX to the corresponding sigcontext structure (computed from
+   CFA) if it does, or to 0 otherwise.  */
+
+#define COMPUTE_SIGCONTEXT_FOR(RA,CFA,SIGCTX)				    \
+do {									    \
+  /* Define and register the applicable patterns.  */			    \
+  extern void __sigtramp (void);					    \
+									    \
+  sighandler_call_t sighandler_calls [] = {				    \
+    {__sigtramp + 164, 0x78}						    \
+  };									    \
+									    \
+  int n_patterns_to_match						    \
+    = sizeof (sighandler_calls) / sizeof (sighandler_call_t);		    \
+									    \
+  int pn;  /* pattern number  */					    \
+									    \
+  int match = 0;  /* Did last pattern match ?  */			    \
+									    \
+  /* Try to match each pattern in turn.  */				    \
+  for (pn = 0; !match && pn < n_patterns_to_match; pn ++)		    \
+    match = ((RA) == sighandler_calls[pn].ra_value);			    \
+									    \
+  (SIGCTX) = (struct sigcontext *)					    \
+    (match ? ((CFA) + sighandler_calls[pn - 1].cfa_to_context_offset) : 0); \
+} while (0);
+
+#include <sys/context_t.h>
+
+#define REG_SP  30  /* hard reg for stack pointer */
+#define REG_RA  26  /* hard reg for return address */
+
+#define MD_FALLBACK_FRAME_STATE_FOR alpha_fallback_frame_state
+
+static _Unwind_Reason_Code
+alpha_fallback_frame_state (struct _Unwind_Context *context,
+			    _Unwind_FrameState *fs)
+{
+  /* Return address and CFA of the frame we're attempting to unwind through,
+     possibly a signal handler.  */
+  void *ctx_ra  = (void *)context->ra;
+  void *ctx_cfa = (void *)context->cfa;
+
+  /* CFA of the intermediate abstract kernel frame between the interrupted
+     code and the signal handler, if we're indeed unwinding through a signal
+     handler.  */
+  void *k_cfa;
+
+  /* Pointer to the sigcontext structure pushed by the kernel when we're
+     unwinding through a signal handler.  */
+  struct sigcontext *sigctx;
+  int i;
+
+  COMPUTE_SIGCONTEXT_FOR (ctx_ra, ctx_cfa, sigctx);
+
+  if (sigctx == 0)
+    return _URC_END_OF_STACK;
+
+  /* The kernel frame's CFA is exactly the stack pointer value at the
+     interruption point.  */
+  k_cfa = (void *) sigctx->sc_regs [REG_SP];
+
+  /* State the rules to compute the CFA we have the value of: use the
+     previous CFA and offset by the difference between the two.  See
+     uw_update_context_1 for the supporting details.  */
+  fs->regs.cfa_how = CFA_REG_OFFSET;
+  fs->regs.cfa_reg = __builtin_dwarf_sp_column ();
+  fs->regs.cfa_offset = k_cfa - ctx_cfa;
+
+  /* Fill the internal frame_state structure with information stating
+     where each register of interest in the saved context can be found
+     from the CFA.  */
+
+  /* The general registers are in sigctx->sc_regs.  Leave out r31, which
+     is read-as-zero. It makes no sense restoring it, and we are going to
+     use the state entry for the kernel return address rule below.
+
+     This loop must cover at least all the callee-saved registers, and
+     we just don't bother specializing the set here.  */
+  for (i = 0; i <= 30; i ++)
+    {
+      fs->regs.reg[i].how = REG_SAVED_OFFSET;
+      fs->regs.reg[i].loc.offset
+	= (void *) &sigctx->sc_regs[i] - (void *) k_cfa;
+    }
+
+  /* Ditto for the floating point registers in sigctx->sc_fpregs.  */
+  for (i = 0; i <= 31; i ++)
+    {
+      fs->regs.reg[32+i].how = REG_SAVED_OFFSET;
+      fs->regs.reg[32+i].loc.offset
+	= (void *) &sigctx->sc_fpregs[i] - (void *) k_cfa;
+    }
+
+  /* State the rules to find the kernel's code "return address", which
+     is the address of the active instruction when the signal was caught,
+     in sigctx->sc_pc. Use DWARF_ALT_FRAME_RETURN_COLUMN since the return
+     address register is a general register and should be left alone.  */
+  fs->retaddr_column = DWARF_ALT_FRAME_RETURN_COLUMN;
+  fs->regs.reg[DWARF_ALT_FRAME_RETURN_COLUMN].how = REG_SAVED_OFFSET;
+  fs->regs.reg[DWARF_ALT_FRAME_RETURN_COLUMN].loc.offset
+    = (void *) &sigctx->sc_pc - (void *) k_cfa;
+  fs->signal_frame = 1;
+
+  return _URC_NO_REASON;
+}