mirror of
https://github.com/autc04/Retro68.git
synced 2024-11-24 07:31:32 +00:00
490 lines
15 KiB
C
490 lines
15 KiB
C
/* DWARF2 EH unwinding support for SPARC Solaris.
|
|
Copyright (C) 2009, 2010, 2011, 2012 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.
|
|
|
|
Under Section 7 of GPL version 3, you are granted additional
|
|
permissions described in the GCC Runtime Library Exception, version
|
|
3.1, as published by the Free Software Foundation.
|
|
|
|
You should have received a copy of the GNU General Public License and
|
|
a copy of the GCC Runtime Library Exception along with this program;
|
|
see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
|
|
<http://www.gnu.org/licenses/>. */
|
|
|
|
/* Do code reading to identify a signal frame, and set the frame
|
|
state data appropriately. See unwind-dw2.c for the structs. */
|
|
|
|
#include <ucontext.h>
|
|
#include <sys/frame.h>
|
|
#include <sys/stack.h>
|
|
|
|
#ifdef __arch64__
|
|
|
|
#define IS_SIGHANDLER sparc64_is_sighandler
|
|
|
|
static int
|
|
sparc64_is_sighandler (unsigned int *pc, void *cfa, int *nframes)
|
|
{
|
|
if (/* Solaris 8 - single-threaded
|
|
----------------------------
|
|
<sigacthandler+24>: add %g5, %o7, %o2
|
|
<sigacthandler+28>: ldx [ %o2 + 0xfa0 ], %g5
|
|
<sigacthandler+32>: sra %i0, 0, %o0
|
|
<sigacthandler+36>: sllx %o0, 3, %g4
|
|
<sigacthandler+40>: ldx [ %g4 + %g5 ], %l0
|
|
<sigacthandler+44>: call %l0
|
|
<sigacthandler+48>: mov %i2, %o2
|
|
<sigacthandler+52>: cmp %i3, 8 <--- PC */
|
|
( pc[-7] == 0x9401400f
|
|
&& pc[-6] == 0xca5aafa0
|
|
&& pc[-5] == 0x913e2000
|
|
&& pc[-4] == 0x892a3003
|
|
&& pc[-3] == 0xe0590005
|
|
&& pc[-2] == 0x9fc40000
|
|
&& pc[-1] == 0x9410001a
|
|
&& pc[ 0] == 0x80a6e008)
|
|
|
|
|| /* Solaris 9 - single-threaded
|
|
----------------------------
|
|
The pattern changes slightly in different versions of the
|
|
operating system, so we skip the comparison against pc[-6] for
|
|
Solaris 9.
|
|
|
|
<sigacthandler+24>: sra %i0, 0, %l1
|
|
|
|
Solaris 9 5/02:
|
|
<sigacthandler+28>: ldx [ %o2 + 0xf68 ], %g5
|
|
Solaris 9 9/05:
|
|
<sigacthandler+28>: ldx [ %o2 + 0xe50 ], %g5
|
|
|
|
<sigacthandler+32>: sllx %l1, 3, %g4
|
|
<sigacthandler+36>: mov %l1, %o0
|
|
<sigacthandler+40>: ldx [ %g4 + %g5 ], %l0
|
|
<sigacthandler+44>: call %l0
|
|
<sigacthandler+48>: mov %i2, %o2
|
|
<sigacthandler+52>: cmp %l1, 8 <--- PC */
|
|
( pc[-7] == 0xa33e2000
|
|
/* skip pc[-6] */
|
|
&& pc[-5] == 0x892c7003
|
|
&& pc[-4] == 0x90100011
|
|
&& pc[-3] == 0xe0590005
|
|
&& pc[-2] == 0x9fc40000
|
|
&& pc[-1] == 0x9410001a
|
|
&& pc[ 0] == 0x80a46008))
|
|
{
|
|
/* We need to move up one frame:
|
|
|
|
<signal handler> <-- context->cfa
|
|
sigacthandler
|
|
<kernel>
|
|
*/
|
|
*nframes = 1;
|
|
return 1;
|
|
}
|
|
|
|
if (/* Solaris 8+ - multi-threaded
|
|
----------------------------
|
|
<__sighndlr>: save %sp, -176, %sp
|
|
<__sighndlr+4>: mov %i0, %o0
|
|
<__sighndlr+8>: mov %i1, %o1
|
|
<__sighndlr+12>: call %i3
|
|
<__sighndlr+16>: mov %i2, %o2
|
|
<__sighndlr+20>: ret <--- PC
|
|
<__sighndlr+24>: restore */
|
|
pc[-5] == 0x9de3bf50
|
|
&& pc[-4] == 0x90100018
|
|
&& pc[-3] == 0x92100019
|
|
&& pc[-2] == 0x9fc6c000
|
|
&& pc[-1] == 0x9410001a
|
|
&& pc[ 0] == 0x81c7e008
|
|
&& pc[ 1] == 0x81e80000)
|
|
{
|
|
/* We have observed different calling frames among different
|
|
versions of the operating system, so that we need to
|
|
discriminate using the upper frame. We look for the return
|
|
address of the caller frame (there is an offset of 15 double
|
|
words between the frame address and the place where this return
|
|
address is stored) in order to do some more pattern matching. */
|
|
unsigned int cuh_pattern
|
|
= *(unsigned int *)(*(unsigned long *)(cfa + 15*8) - 4);
|
|
|
|
if (cuh_pattern == 0x92100019)
|
|
/* This matches the call_user_handler pattern for Solaris 11.
|
|
This is the same setup as for Solaris 9, see below. */
|
|
*nframes = 3;
|
|
|
|
else if (cuh_pattern == 0xd25fa7ef)
|
|
{
|
|
/* This matches the call_user_handler pattern for Solaris 10.
|
|
There are 2 cases so we look for the return address of the
|
|
caller's caller frame in order to do more pattern matching. */
|
|
unsigned long sah_address = *(unsigned long *)(cfa + 176 + 15*8);
|
|
|
|
if (sah_address && *(unsigned int *)(sah_address - 4) == 0x92100019)
|
|
/* This is the same setup as for Solaris 9, see below. */
|
|
*nframes = 3;
|
|
else
|
|
/* The sigacthandler frame isn't present in the chain.
|
|
We need to move up two frames:
|
|
|
|
<signal handler> <-- context->cfa
|
|
__sighndlr
|
|
call_user_handler frame
|
|
<kernel>
|
|
*/
|
|
*nframes = 2;
|
|
}
|
|
|
|
else if (cuh_pattern == 0x9410001a || cuh_pattern == 0x94100013)
|
|
/* This matches the call_user_handler pattern for Solaris 9 and
|
|
for Solaris 8 running inside Solaris Containers respectively
|
|
We need to move up three frames:
|
|
|
|
<signal handler> <-- context->cfa
|
|
__sighndlr
|
|
call_user_handler
|
|
sigacthandler
|
|
<kernel>
|
|
*/
|
|
*nframes = 3;
|
|
|
|
else /* cuh_pattern == 0xe0272010 */
|
|
/* This is the default Solaris 8 case.
|
|
We need to move up two frames:
|
|
|
|
<signal handler> <-- context->cfa
|
|
__sighndlr
|
|
sigacthandler
|
|
<kernel>
|
|
*/
|
|
*nframes = 2;
|
|
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
#define MD_FALLBACK_FRAME_STATE_FOR sparc64_fallback_frame_state
|
|
|
|
#define MD_FROB_UPDATE_CONTEXT sparc64_frob_update_context
|
|
|
|
static void
|
|
sparc64_frob_update_context (struct _Unwind_Context *context,
|
|
_Unwind_FrameState *fs)
|
|
{
|
|
/* The column of %sp contains the old CFA, not the old value of %sp.
|
|
The CFA offset already comprises the stack bias so, when %sp is the
|
|
CFA register, we must avoid counting the stack bias twice. Do not
|
|
do that for signal frames as the offset is artificial for them. */
|
|
if (fs->regs.cfa_reg == __builtin_dwarf_sp_column ()
|
|
&& fs->regs.cfa_how == CFA_REG_OFFSET
|
|
&& fs->regs.cfa_offset != 0
|
|
&& !fs->signal_frame)
|
|
{
|
|
long i;
|
|
|
|
context->cfa -= STACK_BIAS;
|
|
|
|
for (i = 0; i < DWARF_FRAME_REGISTERS + 1; ++i)
|
|
if (fs->regs.reg[i].how == REG_SAVED_OFFSET)
|
|
_Unwind_SetGRPtr (context, i,
|
|
_Unwind_GetGRPtr (context, i) - STACK_BIAS);
|
|
}
|
|
}
|
|
|
|
#else
|
|
|
|
#define IS_SIGHANDLER sparc_is_sighandler
|
|
|
|
static int
|
|
sparc_is_sighandler (unsigned int *pc, void *cfa, int *nframes)
|
|
{
|
|
if (/* Solaris 8, 9 - single-threaded
|
|
-------------------------------
|
|
The pattern changes slightly in different versions of the operating
|
|
system, so we skip the comparison against pc[-6].
|
|
|
|
<sigacthandler+16>: add %o1, %o7, %o3
|
|
<sigacthandler+20>: mov %i1, %o1
|
|
|
|
<sigacthandler+24>: ld [ %o3 + <offset> ], %o2
|
|
|
|
<sigacthandler+28>: sll %i0, 2, %o0
|
|
<sigacthandler+32>: ld [ %o0 + %o2 ], %l0
|
|
<sigacthandler+36>: mov %i0, %o0
|
|
<sigacthandler+40>: call %l0
|
|
<sigacthandler+44>: mov %i2, %o2
|
|
<sigacthandler+48>: cmp %i0, 8 <--- PC */
|
|
pc[-8] == 0x9602400f
|
|
&& pc[-7] == 0x92100019
|
|
/* skip pc[-6] */
|
|
&& pc[-5] == 0x912e2002
|
|
&& pc[-4] == 0xe002000a
|
|
&& pc[-3] == 0x90100018
|
|
&& pc[-2] == 0x9fc40000
|
|
&& pc[-1] == 0x9410001a
|
|
&& pc[ 0] == 0x80a62008)
|
|
{
|
|
/* We need to move up one frame:
|
|
|
|
<signal handler> <-- context->cfa
|
|
sigacthandler
|
|
<kernel>
|
|
*/
|
|
*nframes = 1;
|
|
return 1;
|
|
}
|
|
|
|
if (/* Solaris 8 - multi-threaded
|
|
---------------------------
|
|
<__libthread_segvhdlr+212>: clr %o2
|
|
<__libthread_segvhdlr+216>: ld [ %fp + -28 ], %l0
|
|
<__libthread_segvhdlr+220>: mov %i4, %o0
|
|
<__libthread_segvhdlr+224>: mov %i1, %o1
|
|
<__libthread_segvhdlr+228>: call %l0
|
|
<__libthread_segvhdlr+232>: mov %i2, %o2
|
|
<__libthread_segvhdlr+236>: ret <--- PC
|
|
<__libthread_segvhdlr+240>: restore
|
|
<__libthread_segvhdlr+244>: cmp %o1, 0 */
|
|
pc[-6] == 0x94102000
|
|
&& pc[-5] == 0xe007bfe4
|
|
&& pc[-4] == 0x9010001c
|
|
&& pc[-3] == 0x92100019
|
|
&& pc[-2] == 0x9fc40000
|
|
&& pc[-1] == 0x9410001a
|
|
&& pc[ 0] == 0x81c7e008
|
|
&& pc[ 1] == 0x81e80000
|
|
&& pc[ 2] == 0x80a26000)
|
|
{
|
|
/* We need to move up one frame:
|
|
|
|
<signal handler> <-- context->cfa
|
|
__libthread_segvhdlr
|
|
<kernel>
|
|
*/
|
|
*nframes = 1;
|
|
return 1;
|
|
}
|
|
|
|
if(/* Solaris 8+ - multi-threaded
|
|
----------------------------
|
|
<__sighndlr>: save %sp, -96, %sp
|
|
<__sighndlr+4>: mov %i0, %o0
|
|
<__sighndlr+8>: mov %i1, %o1
|
|
<__sighndlr+12>: call %i3
|
|
<__sighndlr+16>: mov %i2, %o2
|
|
<__sighndlr+20>: ret <--- PC
|
|
<__sighndlr+24>: restore */
|
|
pc[-5] == 0x9de3bfa0
|
|
&& pc[-4] == 0x90100018
|
|
&& pc[-3] == 0x92100019
|
|
&& pc[-2] == 0x9fc6c000
|
|
&& pc[-1] == 0x9410001a
|
|
&& pc[ 0] == 0x81c7e008
|
|
&& pc[ 1] == 0x81e80000)
|
|
{
|
|
/* We have observed different calling frames among different
|
|
versions of the operating system, so that we need to
|
|
discriminate using the upper frame. We look for the return
|
|
address of the caller frame (there is an offset of 15 words
|
|
between the frame address and the place where this return
|
|
address is stored) in order to do some more pattern matching. */
|
|
unsigned int cuh_pattern
|
|
= *(unsigned int *)(*(unsigned int *)(cfa + 15*4) - 4);
|
|
|
|
if (cuh_pattern == 0x92100019)
|
|
/* This matches the call_user_handler pattern for Solaris 11.
|
|
This is the same setup as for Solaris 9, see below. */
|
|
*nframes = 3;
|
|
|
|
else if (cuh_pattern == 0xd407a04c)
|
|
{
|
|
/* This matches the call_user_handler pattern for Solaris 10.
|
|
There are 2 cases so we look for the return address of the
|
|
caller's caller frame in order to do more pattern matching. */
|
|
unsigned int sah_address = *(unsigned int *)(cfa + 96 + 15*4);
|
|
|
|
if (sah_address && *(unsigned int *)(sah_address - 4) == 0x92100019)
|
|
/* This is the same setup as for Solaris 9, see below. */
|
|
*nframes = 3;
|
|
else
|
|
/* The sigacthandler frame isn't present in the chain.
|
|
We need to move up two frames:
|
|
|
|
<signal handler> <-- context->cfa
|
|
__sighndlr
|
|
call_user_handler frame
|
|
<kernel>
|
|
*/
|
|
*nframes = 2;
|
|
}
|
|
|
|
else if (cuh_pattern == 0x9410001a || cuh_pattern == 0x9410001b)
|
|
/* This matches the call_user_handler pattern for Solaris 9 and
|
|
for Solaris 8 running inside Solaris Containers respectively.
|
|
We need to move up three frames:
|
|
|
|
<signal handler> <-- context->cfa
|
|
__sighndlr
|
|
call_user_handler
|
|
sigacthandler
|
|
<kernel>
|
|
*/
|
|
*nframes = 3;
|
|
|
|
else /* cuh_pattern == 0x90100018 */
|
|
/* This is the default Solaris 8 case.
|
|
We need to move up two frames:
|
|
|
|
<signal handler> <-- context->cfa
|
|
__sighndlr
|
|
sigacthandler
|
|
<kernel>
|
|
*/
|
|
*nframes = 2;
|
|
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
#define MD_FALLBACK_FRAME_STATE_FOR sparc_fallback_frame_state
|
|
|
|
#endif
|
|
|
|
static _Unwind_Reason_Code
|
|
MD_FALLBACK_FRAME_STATE_FOR (struct _Unwind_Context *context,
|
|
_Unwind_FrameState *fs)
|
|
{
|
|
void *pc = context->ra;
|
|
struct frame *fp = (struct frame *) context->cfa;
|
|
int nframes;
|
|
void *this_cfa = context->cfa;
|
|
long new_cfa;
|
|
void *ra_location, *shifted_ra_location;
|
|
mcontext_t *mctx;
|
|
int i;
|
|
|
|
/* Deal with frame-less function from which a signal was raised. */
|
|
if (_Unwind_IsSignalFrame (context))
|
|
{
|
|
/* The CFA is by definition unmodified in this case. */
|
|
fs->regs.cfa_how = CFA_REG_OFFSET;
|
|
fs->regs.cfa_reg = __builtin_dwarf_sp_column ();
|
|
fs->regs.cfa_offset = 0;
|
|
|
|
/* This is the canonical RA column. */
|
|
fs->retaddr_column = 15;
|
|
|
|
return _URC_NO_REASON;
|
|
}
|
|
|
|
if (IS_SIGHANDLER (pc, this_cfa, &nframes))
|
|
{
|
|
struct handler_args {
|
|
struct frame frwin;
|
|
ucontext_t ucontext;
|
|
} *handler_args;
|
|
ucontext_t *ucp;
|
|
|
|
/* context->cfa points into the frame after the saved frame pointer and
|
|
saved pc (struct frame).
|
|
|
|
The ucontext_t structure is in the kernel frame after a struct
|
|
frame. Since the frame sizes vary even within OS releases, we
|
|
need to walk the stack to get there. */
|
|
|
|
for (i = 0; i < nframes; i++)
|
|
fp = (struct frame *) ((char *)fp->fr_savfp + STACK_BIAS);
|
|
|
|
handler_args = (struct handler_args *) fp;
|
|
ucp = &handler_args->ucontext;
|
|
mctx = &ucp->uc_mcontext;
|
|
}
|
|
|
|
/* Exit if the pattern at the return address does not match the
|
|
previous three patterns. */
|
|
else
|
|
return _URC_END_OF_STACK;
|
|
|
|
new_cfa = mctx->gregs[REG_SP];
|
|
/* The frame address is %sp + STACK_BIAS in 64-bit mode. */
|
|
new_cfa += STACK_BIAS;
|
|
|
|
fs->regs.cfa_how = CFA_REG_OFFSET;
|
|
fs->regs.cfa_reg = __builtin_dwarf_sp_column ();
|
|
fs->regs.cfa_offset = new_cfa - (long) this_cfa;
|
|
|
|
/* Restore global and out registers (in this order) from the
|
|
ucontext_t structure, uc_mcontext.gregs field. */
|
|
for (i = 1; i < 16; i++)
|
|
{
|
|
/* We never restore %sp as everything is purely CFA-based. */
|
|
if ((unsigned int) i == __builtin_dwarf_sp_column ())
|
|
continue;
|
|
|
|
/* First the global registers and then the out registers. */
|
|
fs->regs.reg[i].how = REG_SAVED_OFFSET;
|
|
fs->regs.reg[i].loc.offset = (long)&mctx->gregs[REG_Y + i] - new_cfa;
|
|
}
|
|
|
|
/* Just above the stack pointer there are 16 extended words in which
|
|
the register window (in and local registers) was saved. */
|
|
for (i = 0; i < 16; i++)
|
|
{
|
|
fs->regs.reg[i + 16].how = REG_SAVED_OFFSET;
|
|
fs->regs.reg[i + 16].loc.offset = i*sizeof(long);
|
|
}
|
|
|
|
/* Check whether we need to restore FPU registers. */
|
|
if (mctx->fpregs.fpu_qcnt)
|
|
{
|
|
for (i = 0; i < 32; i++)
|
|
{
|
|
fs->regs.reg[i + 32].how = REG_SAVED_OFFSET;
|
|
fs->regs.reg[i + 32].loc.offset
|
|
= (long)&mctx->fpregs.fpu_fr.fpu_regs[i] - new_cfa;
|
|
}
|
|
|
|
#ifdef __arch64__
|
|
/* For 64-bit, fpu_fr.fpu_dregs contains 32 instead of 16 doubles. */
|
|
for (i = 32; i < 64; i++)
|
|
{
|
|
if (i > 32 && (i & 1))
|
|
continue;
|
|
|
|
fs->regs.reg[i + 32].how = REG_SAVED_OFFSET;
|
|
fs->regs.reg[i + 32].loc.offset
|
|
= (long)&mctx->fpregs.fpu_fr.fpu_dregs[i/2] - new_cfa;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/* State the rules to find the kernel's code "return address", which is
|
|
the address of the active instruction when the signal was caught.
|
|
On the SPARC, since RETURN_ADDR_OFFSET (essentially 8) is defined, we
|
|
need to preventively subtract it from the purported return address. */
|
|
ra_location = &mctx->gregs[REG_PC];
|
|
shifted_ra_location = &mctx->gregs[REG_Y];
|
|
*(void **)shifted_ra_location = *(void **)ra_location - 8;
|
|
fs->retaddr_column = 0;
|
|
fs->regs.reg[0].how = REG_SAVED_OFFSET;
|
|
fs->regs.reg[0].loc.offset = (long)shifted_ra_location - new_cfa;
|
|
fs->signal_frame = 1;
|
|
|
|
return _URC_NO_REASON;
|
|
}
|