src/x86/Gos-linux.c

   1 /* libunwind - a platform-independent unwind library
   2    Copyright (C) 2002-2004 Hewlett-Packard Co
   3         Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
   4
   5 This file is part of libunwind.
   6
   7 Permission is hereby granted, free of charge, to any person obtaining
   8 a copy of this software and associated documentation files (the
   9 "Software"), to deal in the Software without restriction, including
  10 without limitation the rights to use, copy, modify, merge, publish,
  11 distribute, sublicense, and/or sell copies of the Software, and to
  12 permit persons to whom the Software is furnished to do so, subject to
  13 the following conditions:
  14
  15 The above copyright notice and this permission notice shall be
  16 included in all copies or substantial portions of the Software.
  17
  18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  19 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  21 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  22 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  23 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  24 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.  */
  25
  26 #include "unwind_i.h"
  27 #include "offsets.h"
  28
  29 #include <sys/syscall.h>
  30
  31 int
  32 unw_is_signal_frame (unw_cursor_t *cursor)
  33 {
  34   struct cursor *c = (struct cursor *) cursor;
  35   unw_word_t w0, w1, ip;
  36   unw_addr_space_t as;
  37   unw_accessors_t *a;
  38   void *arg;
  39   int ret;
  40
  41   as = c->dwarf.as;
  42   a = unw_get_accessors_int (as);
  43   arg = c->dwarf.as_arg;
  44
  45   /* Check if EIP points at sigreturn() sequence.  On Linux, this is:
  46
  47     __restore:
  48         0x58                            pop %eax
  49         0xb8 0x77 0x00 0x00 0x00        movl 0x77,%eax
  50         0xcd 0x80                       int 0x80
  51
  52      without SA_SIGINFO, and
  53
  54     __restore_rt:
  55        0xb8 0xad 0x00 0x00 0x00        movl 0xad,%eax
  56        0xcd 0x80                       int 0x80
  57        0x00
  58
  59      if SA_SIGINFO is specified.
  60   */
  61   ip = c->dwarf.ip;
  62   if ((*a->access_mem) (as, ip, &w0, 0, arg) < 0
  63       || (*a->access_mem) (as, ip + 4, &w1, 0, arg) < 0)
  64     ret = 0;
  65   else
  66     ret = ((w0 == 0x0077b858 && w1 == 0x80cd0000)
  67          || (w0 == 0x0000adb8 && (w1 & 0xffffff) == 0x80cd00));
  68   Debug (16, "returning %d\n", ret);
  69   return ret;
  70 }
  71
  72 HIDDEN int
  73 x86_handle_signal_frame (unw_cursor_t *cursor)
  74 {
  75   struct cursor *c = (struct cursor *) cursor;
  76   int ret;
  77
  78   /* c->esp points at the arguments to the handler.  Without
  79      SA_SIGINFO, the arguments consist of a signal number
  80      followed by a struct sigcontext.  With SA_SIGINFO, the
  81      arguments consist a signal number, a siginfo *, and a
  82      ucontext *. */
  83   unw_word_t sc_addr;
  84   unw_word_t siginfo_ptr_addr = c->dwarf.cfa + 4;
  85   unw_word_t sigcontext_ptr_addr = c->dwarf.cfa + 8;
  86   unw_word_t siginfo_ptr, sigcontext_ptr;
  87   struct dwarf_loc esp_loc, siginfo_ptr_loc, sigcontext_ptr_loc;
  88
  89   siginfo_ptr_loc = DWARF_LOC (siginfo_ptr_addr, 0);
  90   sigcontext_ptr_loc = DWARF_LOC (sigcontext_ptr_addr, 0);
  91   ret = (dwarf_get (&c->dwarf, siginfo_ptr_loc, &siginfo_ptr)
  92          | dwarf_get (&c->dwarf, sigcontext_ptr_loc, &sigcontext_ptr));
  93   if (ret < 0)
  94     {
  95       Debug (2, "returning 0\n");
  96       return 0;
  97     }
  98   if (siginfo_ptr < c->dwarf.cfa
  99       || siginfo_ptr > c->dwarf.cfa + 256
 100       || sigcontext_ptr < c->dwarf.cfa
 101       || sigcontext_ptr > c->dwarf.cfa + 256)
 102     {
 103       /* Not plausible for SA_SIGINFO signal */
 104       c->sigcontext_format = X86_SCF_LINUX_SIGFRAME;
 105       c->sigcontext_addr = sc_addr = c->dwarf.cfa + 4;
 106     }
 107   else
 108     {
 109       /* If SA_SIGINFO were not specified, we actually read
 110          various segment pointers instead.  We believe that at
 111          least fs and _fsh are always zero for linux, so it is
 112          not just unlikely, but impossible that we would end
 113          up here. */
 114       c->sigcontext_format = X86_SCF_LINUX_RT_SIGFRAME;
 115       c->sigcontext_addr = sigcontext_ptr;
 116       sc_addr = sigcontext_ptr + LINUX_UC_MCONTEXT_OFF;
 117     }
 118   esp_loc = DWARF_LOC (sc_addr + LINUX_SC_ESP_OFF, 0);
 119   ret = dwarf_get (&c->dwarf, esp_loc, &c->dwarf.cfa);
 120   if (ret < 0)
 121     {
 122       Debug (2, "returning 0\n");
 123       return 0;
 124     }
 125
 126   c->dwarf.loc[EAX] = DWARF_LOC (sc_addr + LINUX_SC_EAX_OFF, 0);
 127   c->dwarf.loc[ECX] = DWARF_LOC (sc_addr + LINUX_SC_ECX_OFF, 0);
 128   c->dwarf.loc[EDX] = DWARF_LOC (sc_addr + LINUX_SC_EDX_OFF, 0);
 129   c->dwarf.loc[EBX] = DWARF_LOC (sc_addr + LINUX_SC_EBX_OFF, 0);
 130   c->dwarf.loc[EBP] = DWARF_LOC (sc_addr + LINUX_SC_EBP_OFF, 0);
 131   c->dwarf.loc[ESI] = DWARF_LOC (sc_addr + LINUX_SC_ESI_OFF, 0);
 132   c->dwarf.loc[EDI] = DWARF_LOC (sc_addr + LINUX_SC_EDI_OFF, 0);
 133   c->dwarf.loc[EFLAGS] = DWARF_NULL_LOC;
 134   c->dwarf.loc[TRAPNO] = DWARF_NULL_LOC;
 135   c->dwarf.loc[ST0] = DWARF_NULL_LOC;
 136   c->dwarf.loc[EIP] = DWARF_LOC (sc_addr + LINUX_SC_EIP_OFF, 0);
 137   c->dwarf.loc[ESP] = DWARF_LOC (sc_addr + LINUX_SC_ESP_OFF, 0);
 138
 139   return 0;
 140 }
 141
 142 HIDDEN dwarf_loc_t
 143 x86_get_scratch_loc (struct cursor *c, unw_regnum_t reg)
 144 {
 145   unw_word_t addr = c->sigcontext_addr, fpstate_addr, off;
 146   int ret, is_fpstate = 0;
 147
 148   switch (c->sigcontext_format)
 149     {
 150     case X86_SCF_NONE:
 151       return DWARF_REG_LOC (&c->dwarf, reg);
 152
 153     case X86_SCF_LINUX_SIGFRAME:
 154       break;
 155
 156     case X86_SCF_LINUX_RT_SIGFRAME:
 157       addr += LINUX_UC_MCONTEXT_OFF;
 158       break;
 159
 160     default:
 161       return DWARF_NULL_LOC;
 162     }
 163
 164   switch (reg)
 165     {
 166     case UNW_X86_GS: off = LINUX_SC_GS_OFF; break;
 167     case UNW_X86_FS: off = LINUX_SC_FS_OFF; break;
 168     case UNW_X86_ES: off = LINUX_SC_ES_OFF; break;
 169     case UNW_X86_DS: off = LINUX_SC_DS_OFF; break;
 170     case UNW_X86_EDI: off = LINUX_SC_EDI_OFF; break;
 171     case UNW_X86_ESI: off = LINUX_SC_ESI_OFF; break;
 172     case UNW_X86_EBP: off = LINUX_SC_EBP_OFF; break;
 173     case UNW_X86_ESP: off = LINUX_SC_ESP_OFF; break;
 174     case UNW_X86_EBX: off = LINUX_SC_EBX_OFF; break;
 175     case UNW_X86_EDX: off = LINUX_SC_EDX_OFF; break;
 176     case UNW_X86_ECX: off = LINUX_SC_ECX_OFF; break;
 177     case UNW_X86_EAX: off = LINUX_SC_EAX_OFF; break;
 178     case UNW_X86_TRAPNO: off = LINUX_SC_TRAPNO_OFF; break;
 179     case UNW_X86_EIP: off = LINUX_SC_EIP_OFF; break;
 180     case UNW_X86_CS: off = LINUX_SC_CS_OFF; break;
 181     case UNW_X86_EFLAGS: off = LINUX_SC_EFLAGS_OFF; break;
 182     case UNW_X86_SS: off = LINUX_SC_SS_OFF; break;
 183
 184       /* The following is probably not correct for all possible cases.
 185          Somebody who understands this better should review this for
 186          correctness.  */
 187
 188     case UNW_X86_FCW: is_fpstate = 1; off = LINUX_FPSTATE_CW_OFF; break;
 189     case UNW_X86_FSW: is_fpstate = 1; off = LINUX_FPSTATE_SW_OFF; break;
 190     case UNW_X86_FTW: is_fpstate = 1; off = LINUX_FPSTATE_TAG_OFF; break;
 191     case UNW_X86_FCS: is_fpstate = 1; off = LINUX_FPSTATE_CSSEL_OFF; break;
 192     case UNW_X86_FIP: is_fpstate = 1; off = LINUX_FPSTATE_IPOFF_OFF; break;
 193     case UNW_X86_FEA: is_fpstate = 1; off = LINUX_FPSTATE_DATAOFF_OFF; break;
 194     case UNW_X86_FDS: is_fpstate = 1; off = LINUX_FPSTATE_DATASEL_OFF; break;
 195     case UNW_X86_MXCSR: is_fpstate = 1; off = LINUX_FPSTATE_MXCSR_OFF; break;
 196
 197       /* stacked fp registers */
 198     case UNW_X86_ST0: case UNW_X86_ST1: case UNW_X86_ST2: case UNW_X86_ST3:
 199     case UNW_X86_ST4: case UNW_X86_ST5: case UNW_X86_ST6: case UNW_X86_ST7:
 200       is_fpstate = 1;
 201       off = LINUX_FPSTATE_ST0_OFF + 10*(reg - UNW_X86_ST0);
 202       break;
 203
 204      /* SSE fp registers */
 205     case UNW_X86_XMM0_lo: case UNW_X86_XMM0_hi:
 206     case UNW_X86_XMM1_lo: case UNW_X86_XMM1_hi:
 207     case UNW_X86_XMM2_lo: case UNW_X86_XMM2_hi:
 208     case UNW_X86_XMM3_lo: case UNW_X86_XMM3_hi:
 209     case UNW_X86_XMM4_lo: case UNW_X86_XMM4_hi:
 210     case UNW_X86_XMM5_lo: case UNW_X86_XMM5_hi:
 211     case UNW_X86_XMM6_lo: case UNW_X86_XMM6_hi:
 212     case UNW_X86_XMM7_lo: case UNW_X86_XMM7_hi:
 213       is_fpstate = 1;
 214       off = LINUX_FPSTATE_XMM0_OFF + 8*(reg - UNW_X86_XMM0_lo);
 215       break;
 216     case UNW_X86_XMM0:
 217     case UNW_X86_XMM1:
 218     case UNW_X86_XMM2:
 219     case UNW_X86_XMM3:
 220     case UNW_X86_XMM4:
 221     case UNW_X86_XMM5:
 222     case UNW_X86_XMM6:
 223     case UNW_X86_XMM7:
 224       is_fpstate = 1;
 225       off = LINUX_FPSTATE_XMM0_OFF + 16*(reg - UNW_X86_XMM0);
 226       break;
 227
 228     case UNW_X86_FOP:
 229     case UNW_X86_TSS:
 230     case UNW_X86_LDT:
 231     default:
 232       return DWARF_REG_LOC (&c->dwarf, reg);
 233     }
 234
 235   if (is_fpstate)
 236     {
 237       if ((ret = dwarf_get (&c->dwarf,
 238                             DWARF_MEM_LOC (&c->dwarf,
 239                                            addr + LINUX_SC_FPSTATE_OFF),
 240                             &fpstate_addr)) < 0)
 241         return DWARF_NULL_LOC;
 242
 243       if (!fpstate_addr)
 244         return DWARF_NULL_LOC;
 245
 246       return DWARF_MEM_LOC (c, fpstate_addr + off);
 247     }
 248   else
 249     return DWARF_MEM_LOC (c, addr + off);
 250 }
 251
 252 #ifndef UNW_REMOTE_ONLY
 253 HIDDEN void *
 254 x86_r_uc_addr (ucontext_t *uc, int reg)
 255 {
 256   void *addr;
 257
 258   switch (reg)
 259     {
 260     case UNW_X86_GS:  addr = &uc->uc_mcontext.gregs[REG_GS]; break;
 261     case UNW_X86_FS:  addr = &uc->uc_mcontext.gregs[REG_FS]; break;
 262     case UNW_X86_ES:  addr = &uc->uc_mcontext.gregs[REG_ES]; break;
 263     case UNW_X86_DS:  addr = &uc->uc_mcontext.gregs[REG_DS]; break;
 264     case UNW_X86_EAX: addr = &uc->uc_mcontext.gregs[REG_EAX]; break;
 265     case UNW_X86_EBX: addr = &uc->uc_mcontext.gregs[REG_EBX]; break;
 266     case UNW_X86_ECX: addr = &uc->uc_mcontext.gregs[REG_ECX]; break;
 267     case UNW_X86_EDX: addr = &uc->uc_mcontext.gregs[REG_EDX]; break;
 268     case UNW_X86_ESI: addr = &uc->uc_mcontext.gregs[REG_ESI]; break;
 269     case UNW_X86_EDI: addr = &uc->uc_mcontext.gregs[REG_EDI]; break;
 270     case UNW_X86_EBP: addr = &uc->uc_mcontext.gregs[REG_EBP]; break;
 271     case UNW_X86_EIP: addr = &uc->uc_mcontext.gregs[REG_EIP]; break;
 272     case UNW_X86_ESP: addr = &uc->uc_mcontext.gregs[REG_ESP]; break;
 273     case UNW_X86_TRAPNO:  addr = &uc->uc_mcontext.gregs[REG_TRAPNO]; break;
 274     case UNW_X86_CS:  addr = &uc->uc_mcontext.gregs[REG_CS]; break;
 275     case UNW_X86_EFLAGS:  addr = &uc->uc_mcontext.gregs[REG_EFL]; break;
 276     case UNW_X86_SS:  addr = &uc->uc_mcontext.gregs[REG_SS]; break;
 277
 278     default:
 279       addr = NULL;
 280     }
 281   return addr;
 282 }
 283
 284 HIDDEN int
 285 x86_local_resume (unw_addr_space_t as, unw_cursor_t *cursor, void *arg)
 286 {
 287   struct cursor *c = (struct cursor *) cursor;
 288   ucontext_t *uc = c->uc;
 289
 290   /* Ensure c->pi is up-to-date.  On x86, it's relatively common to be
 291      missing DWARF unwind info.  We don't want to fail in that case,
 292      because the frame-chain still would let us do a backtrace at
 293      least.  */
 294   dwarf_make_proc_info (&c->dwarf);
 295
 296   if (unlikely (c->sigcontext_format != X86_SCF_NONE))
 297     {
 298       struct sigcontext *sc = (struct sigcontext *) c->sigcontext_addr;
 299
 300       Debug (8, "resuming at ip=%x via sigreturn(%p)\n", c->dwarf.ip, sc);
 301       x86_sigreturn (sc);
 302     }
 303   else
 304     {
 305       Debug (8, "resuming at ip=%x via setcontext()\n", c->dwarf.ip);
 306       setcontext (uc);
 307     }
 308   return -UNW_EINVAL;
 309 }
 310
 311 /* sigreturn() is a no-op on x86 glibc.  */
 312 HIDDEN void
 313 x86_sigreturn (unw_cursor_t *cursor)
 314 {
 315   struct cursor *c = (struct cursor *) cursor;
 316   struct sigcontext *sc = (struct sigcontext *) c->sigcontext_addr;
 317   mcontext_t *sc_mcontext = &((ucontext_t*)sc)->uc_mcontext;
 318   /* Copy in saved uc - all preserved regs are at the start of sigcontext */
 319   memcpy(sc_mcontext, &c->uc->uc_mcontext,
 320          DWARF_NUM_PRESERVED_REGS * sizeof(unw_word_t));
 321
 322   Debug (8, "resuming at ip=%llx via sigreturn(%p)\n",
 323              (unsigned long long) c->dwarf.ip, sc);
 324   __asm__ __volatile__ ("mov %0, %%esp;"
 325                         "mov %1, %%eax;"
 326                         "syscall"
 327                         :: "r"(sc), "i"(SYS_rt_sigreturn)
 328                         : "memory");
 329   abort();
 330 }
 331 #endif