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>
5 This file is part of libunwind.
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:
15 The above copyright notice and this permission notice shall be
16 included in all copies or substantial portions of the Software.
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. */
30 unw_is_signal_frame (unw_cursor_t *cursor)
32 struct cursor *c = (struct cursor *) cursor;
33 unw_word_t w0, w1, ip;
40 a = unw_get_accessors (as);
41 arg = c->dwarf.as_arg;
43 /* Check if EIP points at sigreturn() sequence. On Linux, this is:
47 0xb8 0x77 0x00 0x00 0x00 movl 0x77,%eax
50 without SA_SIGINFO, and
53 0xb8 0xad 0x00 0x00 0x00 movl 0xad,%eax
57 if SA_SIGINFO is specified.
60 if ((ret = (*a->access_mem) (as, ip, &w0, 0, arg)) < 0
61 || (ret = (*a->access_mem) (as, ip + 4, &w1, 0, arg)) < 0)
63 ret = ((w0 == 0x0077b858 && w1 == 0x80cd0000)
64 || (w0 == 0x0000adb8 && (w1 & 0xffffff) == 0x80cd00));
65 Debug (16, "returning %d\n", ret);
70 unw_handle_signal_frame (unw_cursor_t *cursor)
72 struct cursor *c = (struct cursor *) cursor;
75 /* c->esp points at the arguments to the handler. Without
76 SA_SIGINFO, the arguments consist of a signal number
77 followed by a struct sigcontext. With SA_SIGINFO, the
78 arguments consist a signal number, a siginfo *, and a
81 unw_word_t siginfo_ptr_addr = c->dwarf.cfa + 4;
82 unw_word_t sigcontext_ptr_addr = c->dwarf.cfa + 8;
83 unw_word_t siginfo_ptr, sigcontext_ptr;
84 struct dwarf_loc esp_loc, siginfo_ptr_loc, sigcontext_ptr_loc;
86 siginfo_ptr_loc = DWARF_LOC (siginfo_ptr_addr, 0);
87 sigcontext_ptr_loc = DWARF_LOC (sigcontext_ptr_addr, 0);
88 ret = (dwarf_get (&c->dwarf, siginfo_ptr_loc, &siginfo_ptr)
89 | dwarf_get (&c->dwarf, sigcontext_ptr_loc, &sigcontext_ptr));
92 Debug (2, "returning 0\n");
95 if (siginfo_ptr < c->dwarf.cfa
96 || siginfo_ptr > c->dwarf.cfa + 256
97 || sigcontext_ptr < c->dwarf.cfa
98 || sigcontext_ptr > c->dwarf.cfa + 256)
100 /* Not plausible for SA_SIGINFO signal */
101 c->sigcontext_format = X86_SCF_LINUX_SIGFRAME;
102 c->sigcontext_addr = sc_addr = c->dwarf.cfa + 4;
106 /* If SA_SIGINFO were not specified, we actually read
107 various segment pointers instead. We believe that at
108 least fs and _fsh are always zero for linux, so it is
109 not just unlikely, but impossible that we would end
111 c->sigcontext_format = X86_SCF_LINUX_RT_SIGFRAME;
112 c->sigcontext_addr = sigcontext_ptr;
113 sc_addr = sigcontext_ptr + LINUX_UC_MCONTEXT_OFF;
115 esp_loc = DWARF_LOC (sc_addr + LINUX_SC_ESP_OFF, 0);
116 ret = dwarf_get (&c->dwarf, esp_loc, &c->dwarf.cfa);
119 Debug (2, "returning 0\n");
123 c->dwarf.loc[EAX] = DWARF_LOC (sc_addr + LINUX_SC_EAX_OFF, 0);
124 c->dwarf.loc[ECX] = DWARF_LOC (sc_addr + LINUX_SC_ECX_OFF, 0);
125 c->dwarf.loc[EDX] = DWARF_LOC (sc_addr + LINUX_SC_EDX_OFF, 0);
126 c->dwarf.loc[EBX] = DWARF_LOC (sc_addr + LINUX_SC_EBX_OFF, 0);
127 c->dwarf.loc[EBP] = DWARF_LOC (sc_addr + LINUX_SC_EBP_OFF, 0);
128 c->dwarf.loc[ESI] = DWARF_LOC (sc_addr + LINUX_SC_ESI_OFF, 0);
129 c->dwarf.loc[EDI] = DWARF_LOC (sc_addr + LINUX_SC_EDI_OFF, 0);
130 c->dwarf.loc[EFLAGS] = DWARF_NULL_LOC;
131 c->dwarf.loc[TRAPNO] = DWARF_NULL_LOC;
132 c->dwarf.loc[ST0] = DWARF_NULL_LOC;
133 c->dwarf.loc[EIP] = DWARF_LOC (sc_addr + LINUX_SC_EIP_OFF, 0);
134 c->dwarf.loc[ESP] = DWARF_LOC (sc_addr + LINUX_SC_ESP_OFF, 0);
140 x86_get_scratch_loc (struct cursor *c, unw_regnum_t reg)
142 unw_word_t addr = c->sigcontext_addr, fpstate_addr, off;
143 int ret, is_fpstate = 0;
145 switch (c->sigcontext_format)
148 return DWARF_REG_LOC (&c->dwarf, reg);
150 case X86_SCF_LINUX_SIGFRAME:
153 case X86_SCF_LINUX_RT_SIGFRAME:
154 addr += LINUX_UC_MCONTEXT_OFF;
158 return DWARF_NULL_LOC;
163 case UNW_X86_GS: off = LINUX_SC_GS_OFF; break;
164 case UNW_X86_FS: off = LINUX_SC_FS_OFF; break;
165 case UNW_X86_ES: off = LINUX_SC_ES_OFF; break;
166 case UNW_X86_DS: off = LINUX_SC_DS_OFF; break;
167 case UNW_X86_EDI: off = LINUX_SC_EDI_OFF; break;
168 case UNW_X86_ESI: off = LINUX_SC_ESI_OFF; break;
169 case UNW_X86_EBP: off = LINUX_SC_EBP_OFF; break;
170 case UNW_X86_ESP: off = LINUX_SC_ESP_OFF; break;
171 case UNW_X86_EBX: off = LINUX_SC_EBX_OFF; break;
172 case UNW_X86_EDX: off = LINUX_SC_EDX_OFF; break;
173 case UNW_X86_ECX: off = LINUX_SC_ECX_OFF; break;
174 case UNW_X86_EAX: off = LINUX_SC_EAX_OFF; break;
175 case UNW_X86_TRAPNO: off = LINUX_SC_TRAPNO_OFF; break;
176 case UNW_X86_EIP: off = LINUX_SC_EIP_OFF; break;
177 case UNW_X86_CS: off = LINUX_SC_CS_OFF; break;
178 case UNW_X86_EFLAGS: off = LINUX_SC_EFLAGS_OFF; break;
179 case UNW_X86_SS: off = LINUX_SC_SS_OFF; break;
181 /* The following is probably not correct for all possible cases.
182 Somebody who understands this better should review this for
185 case UNW_X86_FCW: is_fpstate = 1; off = LINUX_FPSTATE_CW_OFF; break;
186 case UNW_X86_FSW: is_fpstate = 1; off = LINUX_FPSTATE_SW_OFF; break;
187 case UNW_X86_FTW: is_fpstate = 1; off = LINUX_FPSTATE_TAG_OFF; break;
188 case UNW_X86_FCS: is_fpstate = 1; off = LINUX_FPSTATE_CSSEL_OFF; break;
189 case UNW_X86_FIP: is_fpstate = 1; off = LINUX_FPSTATE_IPOFF_OFF; break;
190 case UNW_X86_FEA: is_fpstate = 1; off = LINUX_FPSTATE_DATAOFF_OFF; break;
191 case UNW_X86_FDS: is_fpstate = 1; off = LINUX_FPSTATE_DATASEL_OFF; break;
192 case UNW_X86_MXCSR: is_fpstate = 1; off = LINUX_FPSTATE_MXCSR_OFF; break;
194 /* stacked fp registers */
195 case UNW_X86_ST0: case UNW_X86_ST1: case UNW_X86_ST2: case UNW_X86_ST3:
196 case UNW_X86_ST4: case UNW_X86_ST5: case UNW_X86_ST6: case UNW_X86_ST7:
198 off = LINUX_FPSTATE_ST0_OFF + 10*(reg - UNW_X86_ST0);
201 /* SSE fp registers */
202 case UNW_X86_XMM0_lo: case UNW_X86_XMM0_hi:
203 case UNW_X86_XMM1_lo: case UNW_X86_XMM1_hi:
204 case UNW_X86_XMM2_lo: case UNW_X86_XMM2_hi:
205 case UNW_X86_XMM3_lo: case UNW_X86_XMM3_hi:
206 case UNW_X86_XMM4_lo: case UNW_X86_XMM4_hi:
207 case UNW_X86_XMM5_lo: case UNW_X86_XMM5_hi:
208 case UNW_X86_XMM6_lo: case UNW_X86_XMM6_hi:
209 case UNW_X86_XMM7_lo: case UNW_X86_XMM7_hi:
211 off = LINUX_FPSTATE_XMM0_OFF + 8*(reg - UNW_X86_XMM0_lo);
222 off = LINUX_FPSTATE_XMM0_OFF + 16*(reg - UNW_X86_XMM0);
229 return DWARF_REG_LOC (&c->dwarf, reg);
234 if ((ret = dwarf_get (&c->dwarf,
235 DWARF_MEM_LOC (&c->dwarf,
236 addr + LINUX_SC_FPSTATE_OFF),
238 return DWARF_NULL_LOC;
241 return DWARF_NULL_LOC;
243 return DWARF_MEM_LOC (c, fpstate_addr + off);
246 return DWARF_MEM_LOC (c, addr + off);
249 #ifndef UNW_REMOTE_ONLY
251 x86_r_uc_addr (ucontext_t *uc, int reg)
257 case UNW_X86_GS: addr = &uc->uc_mcontext.gregs[REG_GS]; break;
258 case UNW_X86_FS: addr = &uc->uc_mcontext.gregs[REG_FS]; break;
259 case UNW_X86_ES: addr = &uc->uc_mcontext.gregs[REG_ES]; break;
260 case UNW_X86_DS: addr = &uc->uc_mcontext.gregs[REG_DS]; break;
261 case UNW_X86_EAX: addr = &uc->uc_mcontext.gregs[REG_EAX]; break;
262 case UNW_X86_EBX: addr = &uc->uc_mcontext.gregs[REG_EBX]; break;
263 case UNW_X86_ECX: addr = &uc->uc_mcontext.gregs[REG_ECX]; break;
264 case UNW_X86_EDX: addr = &uc->uc_mcontext.gregs[REG_EDX]; break;
265 case UNW_X86_ESI: addr = &uc->uc_mcontext.gregs[REG_ESI]; break;
266 case UNW_X86_EDI: addr = &uc->uc_mcontext.gregs[REG_EDI]; break;
267 case UNW_X86_EBP: addr = &uc->uc_mcontext.gregs[REG_EBP]; break;
268 case UNW_X86_EIP: addr = &uc->uc_mcontext.gregs[REG_EIP]; break;
269 case UNW_X86_ESP: addr = &uc->uc_mcontext.gregs[REG_ESP]; break;
270 case UNW_X86_TRAPNO: addr = &uc->uc_mcontext.gregs[REG_TRAPNO]; break;
271 case UNW_X86_CS: addr = &uc->uc_mcontext.gregs[REG_CS]; break;
272 case UNW_X86_EFLAGS: addr = &uc->uc_mcontext.gregs[REG_EFL]; break;
273 case UNW_X86_SS: addr = &uc->uc_mcontext.gregs[REG_SS]; break;
282 x86_local_resume (unw_addr_space_t as, unw_cursor_t *cursor, void *arg)
284 struct cursor *c = (struct cursor *) cursor;
285 ucontext_t *uc = c->uc;
287 /* Ensure c->pi is up-to-date. On x86, it's relatively common to be
288 missing DWARF unwind info. We don't want to fail in that case,
289 because the frame-chain still would let us do a backtrace at
291 dwarf_make_proc_info (&c->dwarf);
293 if (unlikely (c->sigcontext_format != X86_SCF_NONE))
295 struct sigcontext *sc = (struct sigcontext *) c->sigcontext_addr;
297 Debug (8, "resuming at ip=%x via sigreturn(%p)\n", c->dwarf.ip, sc);
302 Debug (8, "resuming at ip=%x via setcontext()\n", c->dwarf.ip);