libgcc/config/sparc/sol2-unwind.h

   1 /* DWARF2 EH unwinding support for SPARC Solaris.
   2    Copyright (C) 2009-2013 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 3, or (at your option)
   9 any later version.
  10
  11 GCC is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 Under Section 7 of GPL version 3, you are granted additional
  17 permissions described in the GCC Runtime Library Exception, version
  18 3.1, as published by the Free Software Foundation.
  19
  20 You should have received a copy of the GNU General Public License and
  21 a copy of the GCC Runtime Library Exception along with this program;
  22 see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23 <http://www.gnu.org/licenses/>.  */
  24
  25 /* Do code reading to identify a signal frame, and set the frame
  26    state data appropriately.  See unwind-dw2.c for the structs.  */
  27
  28 #include <ucontext.h>
  29 #include <sys/frame.h>
  30 #include <sys/stack.h>
  31
  32 #ifdef __arch64__
  33
  34 #define IS_SIGHANDLER sparc64_is_sighandler
  35
  36 static int
  37 sparc64_is_sighandler (unsigned int *pc, void *cfa, int *nframes)
  38 {
  39   if (/* Solaris 9 - single-threaded
  40         ----------------------------
  41         The pattern changes slightly in different versions of the
  42         operating system, so we skip the comparison against pc[-6] for
  43         Solaris 9.
  44
  45         <sigacthandler+24>:  sra  %i0, 0, %l1
  46
  47         Solaris 9 5/02:
  48         <sigacthandler+28>:  ldx  [ %o2 + 0xf68 ], %g5
  49         Solaris 9 9/05:
  50         <sigacthandler+28>:  ldx  [ %o2 + 0xe50 ], %g5
  51
  52         <sigacthandler+32>:  sllx  %l1, 3, %g4
  53         <sigacthandler+36>:  mov  %l1, %o0
  54         <sigacthandler+40>:  ldx  [ %g4 + %g5 ], %l0
  55         <sigacthandler+44>:  call  %l0
  56         <sigacthandler+48>:  mov  %i2, %o2
  57         <sigacthandler+52>:  cmp  %l1, 8        <--- PC  */
  58       (   pc[-7] == 0xa33e2000
  59        /* skip pc[-6] */
  60        && pc[-5] == 0x892c7003
  61        && pc[-4] == 0x90100011
  62        && pc[-3] == 0xe0590005
  63        && pc[-2] == 0x9fc40000
  64        && pc[-1] == 0x9410001a
  65        && pc[ 0] == 0x80a46008))
  66     {
  67       /* We need to move up one frame:
  68
  69                 <signal handler>        <-- context->cfa
  70                 sigacthandler
  71                 <kernel>
  72       */
  73       *nframes = 1;
  74       return 1;
  75     }
  76
  77   if (/* Solaris 8+ - multi-threaded
  78         ----------------------------
  79         <__sighndlr>:        save  %sp, -176, %sp
  80         <__sighndlr+4>:      mov  %i0, %o0
  81         <__sighndlr+8>:      mov  %i1, %o1
  82         <__sighndlr+12>:     call  %i3
  83         <__sighndlr+16>:     mov  %i2, %o2
  84         <__sighndlr+20>:     ret                <--- PC
  85         <__sighndlr+24>:     restore  */
  86          pc[-5] == 0x9de3bf50
  87       && pc[-4] == 0x90100018
  88       && pc[-3] == 0x92100019
  89       && pc[-2] == 0x9fc6c000
  90       && pc[-1] == 0x9410001a
  91       && pc[ 0] == 0x81c7e008
  92       && pc[ 1] == 0x81e80000)
  93     {
  94       /* We have observed different calling frames among different
  95          versions of the operating system, so that we need to
  96          discriminate using the upper frame.  We look for the return
  97          address of the caller frame (there is an offset of 15 double
  98          words between the frame address and the place where this return
  99          address is stored) in order to do some more pattern matching.  */
 100       unsigned int cuh_pattern
 101         = *(unsigned int *)(*(unsigned long *)(cfa + 15*8) - 4);
 102
 103       if (cuh_pattern == 0x92100019)
 104         /* This matches the call_user_handler pattern for Solaris 11.
 105            This is the same setup as for Solaris 9, see below.  */
 106         *nframes = 3;
 107
 108       else if (cuh_pattern == 0xd25fa7ef)
 109         {
 110           /* This matches the call_user_handler pattern for Solaris 10.
 111              There are 2 cases so we look for the return address of the
 112              caller's caller frame in order to do more pattern matching.  */
 113           unsigned long sah_address = *(unsigned long *)(cfa + 176 + 15*8);
 114
 115           if (sah_address && *(unsigned int *)(sah_address - 4) == 0x92100019)
 116             /* This is the same setup as for Solaris 9, see below.  */
 117             *nframes = 3;
 118           else
 119             /* The sigacthandler frame isn't present in the chain.
 120                We need to move up two frames:
 121
 122                 <signal handler>        <-- context->cfa
 123                 __sighndlr
 124                 call_user_handler frame
 125                 <kernel>
 126             */
 127             *nframes = 2;
 128         }
 129
 130       else if (cuh_pattern == 0x9410001a || cuh_pattern == 0x94100013)
 131         /* This matches the call_user_handler pattern for Solaris 9.
 132            We need to move up three frames:
 133
 134                 <signal handler>        <-- context->cfa
 135                 __sighndlr
 136                 call_user_handler
 137                 sigacthandler
 138                 <kernel>
 139         */
 140         *nframes = 3;
 141
 142       return 1;
 143     }
 144
 145   return 0;
 146 }
 147
 148 #define MD_FALLBACK_FRAME_STATE_FOR sparc64_fallback_frame_state
 149
 150 #define MD_FROB_UPDATE_CONTEXT sparc64_frob_update_context
 151
 152 static void
 153 sparc64_frob_update_context (struct _Unwind_Context *context,
 154                              _Unwind_FrameState *fs)
 155 {
 156   /* The column of %sp contains the old CFA, not the old value of %sp.
 157      The CFA offset already comprises the stack bias so, when %sp is the
 158      CFA register, we must avoid counting the stack bias twice.  Do not
 159      do that for signal frames as the offset is artificial for them.  */
 160   if (fs->regs.cfa_reg == __builtin_dwarf_sp_column ()
 161       && fs->regs.cfa_how == CFA_REG_OFFSET
 162       && fs->regs.cfa_offset != 0
 163       && !fs->signal_frame)
 164     {
 165       long i;
 166
 167       context->cfa -= STACK_BIAS;
 168
 169       for (i = 0; i < DWARF_FRAME_REGISTERS + 1; ++i)
 170         if (fs->regs.reg[i].how == REG_SAVED_OFFSET)
 171           _Unwind_SetGRPtr (context, i,
 172                             _Unwind_GetGRPtr (context, i) - STACK_BIAS);
 173     }
 174 }
 175
 176 #else
 177
 178 #define IS_SIGHANDLER sparc_is_sighandler
 179
 180 static int
 181 sparc_is_sighandler (unsigned int *pc, void *cfa, int *nframes)
 182 {
 183   if (/* Solaris 9 - single-threaded
 184         ----------------------------
 185         The pattern changes slightly in different versions of the operating
 186         system, so we skip the comparison against pc[-6].
 187
 188         <sigacthandler+16>:  add  %o1, %o7, %o3
 189         <sigacthandler+20>:  mov  %i1, %o1
 190
 191         <sigacthandler+24>:  ld  [ %o3 + <offset> ], %o2
 192
 193         <sigacthandler+28>:  sll  %i0, 2, %o0
 194         <sigacthandler+32>:  ld  [ %o0 + %o2 ], %l0
 195         <sigacthandler+36>:  mov  %i0, %o0
 196         <sigacthandler+40>:  call  %l0
 197         <sigacthandler+44>:  mov  %i2, %o2
 198         <sigacthandler+48>:  cmp  %i0, 8        <--- PC  */
 199          pc[-8] == 0x9602400f
 200       && pc[-7] == 0x92100019
 201       /* skip pc[-6] */
 202       && pc[-5] == 0x912e2002
 203       && pc[-4] == 0xe002000a
 204       && pc[-3] == 0x90100018
 205       && pc[-2] == 0x9fc40000
 206       && pc[-1] == 0x9410001a
 207       && pc[ 0] == 0x80a62008)
 208     {
 209       /* We need to move up one frame:
 210
 211                 <signal handler>        <-- context->cfa
 212                 sigacthandler
 213                 <kernel>
 214       */
 215       *nframes = 1;
 216       return 1;
 217     }
 218
 219   if(/* Solaris 8+ - multi-threaded
 220        ----------------------------
 221        <__sighndlr>:    save  %sp, -96, %sp
 222        <__sighndlr+4>:  mov  %i0, %o0
 223        <__sighndlr+8>:  mov  %i1, %o1
 224        <__sighndlr+12>: call  %i3
 225        <__sighndlr+16>: mov  %i2, %o2
 226        <__sighndlr+20>: ret             <--- PC
 227        <__sighndlr+24>: restore  */
 228         pc[-5] == 0x9de3bfa0
 229      && pc[-4] == 0x90100018
 230      && pc[-3] == 0x92100019
 231      && pc[-2] == 0x9fc6c000
 232      && pc[-1] == 0x9410001a
 233      && pc[ 0] == 0x81c7e008
 234      && pc[ 1] == 0x81e80000)
 235     {
 236       /* We have observed different calling frames among different
 237          versions of the operating system, so that we need to
 238          discriminate using the upper frame.  We look for the return
 239          address of the caller frame (there is an offset of 15 words
 240          between the frame address and the place where this return
 241          address is stored) in order to do some more pattern matching.  */
 242       unsigned int cuh_pattern
 243         = *(unsigned int *)(*(unsigned int *)(cfa + 15*4) - 4);
 244
 245       if (cuh_pattern == 0x92100019)
 246         /* This matches the call_user_handler pattern for Solaris 11.
 247            This is the same setup as for Solaris 9, see below.  */
 248         *nframes = 3;
 249
 250       else if (cuh_pattern == 0xd407a04c)
 251         {
 252           /* This matches the call_user_handler pattern for Solaris 10.
 253              There are 2 cases so we look for the return address of the
 254              caller's caller frame in order to do more pattern matching.  */
 255           unsigned int sah_address = *(unsigned int *)(cfa + 96 + 15*4);
 256
 257           if (sah_address && *(unsigned int *)(sah_address - 4) == 0x92100019)
 258             /* This is the same setup as for Solaris 9, see below.  */
 259             *nframes = 3;
 260           else
 261             /* The sigacthandler frame isn't present in the chain.
 262                We need to move up two frames:
 263
 264                 <signal handler>        <-- context->cfa
 265                 __sighndlr
 266                 call_user_handler frame
 267                 <kernel>
 268             */
 269             *nframes = 2;
 270         }
 271
 272       else if (cuh_pattern == 0x9410001a || cuh_pattern == 0x9410001b)
 273         /* This matches the call_user_handler pattern for Solaris 9.
 274            We need to move up three frames:
 275
 276                 <signal handler>        <-- context->cfa
 277                 __sighndlr
 278                 call_user_handler
 279                 sigacthandler
 280                 <kernel>
 281         */
 282         *nframes = 3;
 283
 284       return 1;
 285     }
 286
 287   return 0;
 288 }
 289
 290 #define MD_FALLBACK_FRAME_STATE_FOR sparc_fallback_frame_state
 291
 292 #endif
 293
 294 static _Unwind_Reason_Code
 295 MD_FALLBACK_FRAME_STATE_FOR (struct _Unwind_Context *context,
 296                              _Unwind_FrameState *fs)
 297 {
 298   void *pc = context->ra;
 299   struct frame *fp = (struct frame *) context->cfa;
 300   int nframes;
 301   void *this_cfa = context->cfa;
 302   long new_cfa;
 303   void *ra_location, *shifted_ra_location;
 304   mcontext_t *mctx;
 305   int i;
 306
 307   /* Deal with frame-less function from which a signal was raised.  */
 308   if (_Unwind_IsSignalFrame (context))
 309     {
 310       /* The CFA is by definition unmodified in this case.  */
 311       fs->regs.cfa_how = CFA_REG_OFFSET;
 312       fs->regs.cfa_reg = __builtin_dwarf_sp_column ();
 313       fs->regs.cfa_offset = 0;
 314
 315       /* This is the canonical RA column.  */
 316       fs->retaddr_column = 15;
 317
 318       return _URC_NO_REASON;
 319     }
 320
 321   if (IS_SIGHANDLER (pc, this_cfa, &nframes))
 322     {
 323       struct handler_args {
 324         struct frame frwin;
 325         ucontext_t ucontext;
 326       } *handler_args;
 327       ucontext_t *ucp;
 328
 329       /* context->cfa points into the frame after the saved frame pointer and
 330          saved pc (struct frame).
 331
 332          The ucontext_t structure is in the kernel frame after a struct
 333          frame.  Since the frame sizes vary even within OS releases, we
 334          need to walk the stack to get there.  */
 335
 336       for (i = 0; i < nframes; i++)
 337         fp = (struct frame *) ((char *)fp->fr_savfp + STACK_BIAS);
 338
 339       handler_args = (struct handler_args *) fp;
 340       ucp = &handler_args->ucontext;
 341       mctx = &ucp->uc_mcontext;
 342     }
 343
 344   /* Exit if the pattern at the return address does not match the
 345      previous three patterns.  */
 346   else
 347     return _URC_END_OF_STACK;
 348
 349   new_cfa = mctx->gregs[REG_SP];
 350   /* The frame address is %sp + STACK_BIAS in 64-bit mode.  */
 351   new_cfa += STACK_BIAS;
 352
 353   fs->regs.cfa_how = CFA_REG_OFFSET;
 354   fs->regs.cfa_reg = __builtin_dwarf_sp_column ();
 355   fs->regs.cfa_offset = new_cfa - (long) this_cfa;
 356
 357   /* Restore global and out registers (in this order) from the
 358      ucontext_t structure, uc_mcontext.gregs field.  */
 359   for (i = 1; i < 16; i++)
 360     {
 361       /* We never restore %sp as everything is purely CFA-based.  */
 362       if ((unsigned int) i == __builtin_dwarf_sp_column ())
 363         continue;
 364
 365       /* First the global registers and then the out registers.  */
 366       fs->regs.reg[i].how = REG_SAVED_OFFSET;
 367       fs->regs.reg[i].loc.offset = (long)&mctx->gregs[REG_Y + i] - new_cfa;
 368     }
 369
 370   /* Just above the stack pointer there are 16 extended words in which
 371      the register window (in and local registers) was saved.  */
 372   for (i = 0; i < 16; i++)
 373     {
 374       fs->regs.reg[i + 16].how = REG_SAVED_OFFSET;
 375       fs->regs.reg[i + 16].loc.offset = i*sizeof(long);
 376     }
 377
 378   /* Check whether we need to restore FPU registers.  */
 379   if (mctx->fpregs.fpu_qcnt)
 380     {
 381       for (i = 0; i < 32; i++)
 382         {
 383           fs->regs.reg[i + 32].how = REG_SAVED_OFFSET;
 384           fs->regs.reg[i + 32].loc.offset
 385             = (long)&mctx->fpregs.fpu_fr.fpu_regs[i] - new_cfa;
 386         }
 387
 388 #ifdef __arch64__
 389       /* For 64-bit, fpu_fr.fpu_dregs contains 32 instead of 16 doubles.  */
 390       for (i = 32; i < 64; i++)
 391         {
 392           if (i > 32 && (i & 1))
 393             continue;
 394
 395           fs->regs.reg[i + 32].how = REG_SAVED_OFFSET;
 396           fs->regs.reg[i + 32].loc.offset
 397             = (long)&mctx->fpregs.fpu_fr.fpu_dregs[i/2] - new_cfa;
 398         }
 399 #endif
 400     }
 401
 402   /* State the rules to find the kernel's code "return address", which is
 403      the address of the active instruction when the signal was caught.
 404      On the SPARC, since RETURN_ADDR_OFFSET (essentially 8) is defined, we
 405      need to preventively subtract it from the purported return address.  */
 406   ra_location = &mctx->gregs[REG_PC];
 407   shifted_ra_location = &mctx->gregs[REG_Y];
 408   *(void **)shifted_ra_location = *(void **)ra_location - 8;
 409   fs->retaddr_column = 0;
 410   fs->regs.reg[0].how = REG_SAVED_OFFSET;
 411   fs->regs.reg[0].loc.offset = (long)shifted_ra_location - new_cfa;
 412   fs->signal_frame = 1;
 413
 414   return _URC_NO_REASON;
 415 }