OSDN Git Service

* config/rs6000/darwin-fallback.c: Don't include <ucontext.h>.
[pf3gnuchains/gcc-fork.git] / gcc / config / rs6000 / darwin-fallback.c
1 /* Fallback frame-state unwinder for Darwin.
2    Copyright (C) 2004, 2005 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 it
7    under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 2, or (at your option)
9    any later version.
10
11    In addition to the permissions in the GNU General Public License, the
12    Free Software Foundation gives you unlimited permission to link the
13    compiled version of this file into combinations with other programs,
14    and to distribute those combinations without any restriction coming
15    from the use of this file.  (The General Public License restrictions
16    do apply in other respects; for example, they cover modification of
17    the file, and distribution when not linked into a combined
18    executable.)
19
20    GCC is distributed in the hope that it will be useful, but WITHOUT
21    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
22    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
23    License for more details.
24
25    You should have received a copy of the GNU General Public License
26    along with GCC; see the file COPYING.  If not, write to the Free
27    Software Foundation, 59 Temple Place - Suite 330, Boston, MA
28    02111-1307, USA.  */
29
30 #include "tconfig.h"
31 #include "tsystem.h"
32 #include "coretypes.h"
33 #include "tm.h"
34 #include "dwarf2.h"
35 #include "unwind.h"
36 #include "unwind-dw2.h"
37 #include <stdint.h>
38 #include <stdbool.h>
39 #include <sys/types.h>
40 #include <signal.h>
41
42 typedef unsigned long reg_unit;
43
44 /* Place in GPRS the parameters to the first 'sc' instruction that would
45    have been executed if we were returning from this CONTEXT, or
46    return false if an unexpected instruction is encountered.  */
47
48 static bool
49 interpret_libc (reg_unit gprs[32], struct _Unwind_Context *context)
50 {
51   uint32_t *pc = (uint32_t *)_Unwind_GetIP (context);
52   uint32_t cr;
53   reg_unit lr = (reg_unit) pc;
54   reg_unit ctr = 0;
55   uint32_t *invalid_address = NULL;
56
57   int i;
58
59   for (i = 0; i < 13; i++)
60     gprs[i] = 1;
61   gprs[1] = _Unwind_GetCFA (context);
62   for (; i < 32; i++)
63     gprs[i] = _Unwind_GetGR (context, i);
64   cr = _Unwind_GetGR (context, CR2_REGNO);
65
66   /* For each supported Libc, we have to track the code flow
67      all the way back into the kernel.
68   
69      This code is believed to support all released Libc/Libsystem builds since
70      Jaguar 6C115, including all the security updates.  To be precise,
71
72      Libc       Libsystem       Build(s)
73      262~1      60~37           6C115
74      262~1      60.2~4          6D52
75      262~1      61~3            6F21-6F22
76      262~1      63~24           6G30-6G37
77      262~1      63~32           6I34-6I35
78      262~1      63~64           6L29-6L60
79      262.4.1~1  63~84           6L123-6R172
80      
81      320~1      71~101          7B85-7D28
82      320~1      71~266          7F54-7F56
83      320~1      71~288          7F112
84      320~1      71~289          7F113
85      320.1.3~1  71.1.1~29       7H60-7H105
86      320.1.3~1  71.1.1~30       7H110-7H113
87      320.1.3~1  71.1.1~31       7H114
88      
89      That's a big table!  It would be insane to try to keep track of
90      every little detail, so we just read the code itself and do what
91      it would do.
92   */
93
94   for (;;)
95     {
96       uint32_t ins = *pc++;
97       
98       if ((ins & 0xFC000003) == 0x48000000)  /* b instruction */
99         {
100           pc += ((((int32_t) ins & 0x3FFFFFC) ^ 0x2000000) - 0x2000004) / 4;
101           continue;
102         }
103       if ((ins & 0xFC600000) == 0x2C000000)  /* cmpwi */
104         {
105           int32_t val1 = (int16_t) ins;
106           int32_t val2 = gprs[ins >> 16 & 0x1F];
107           /* Only beq and bne instructions are supported, so we only
108              need to set the EQ bit.  */
109           uint32_t mask = 0xF << ((ins >> 21 & 0x1C) ^ 0x1C);
110           if (val1 == val2)
111             cr |= mask;
112           else
113             cr &= ~mask;
114           continue;
115         }
116       if ((ins & 0xFEC38003) == 0x40820000)  /* forwards beq/bne */
117         {
118           if ((cr >> ((ins >> 16 & 0x1F) ^ 0x1F) & 1) == (ins >> 24 & 1))
119             pc += (ins & 0x7FFC) / 4 - 1;
120           continue;
121         }
122       if ((ins & 0xFC0007FF) == 0x7C000378) /* or, including mr */
123         {
124           gprs [ins >> 16 & 0x1F] = (gprs [ins >> 11 & 0x1F] 
125                                      | gprs [ins >> 21 & 0x1F]);
126           continue;
127         }
128       if (ins >> 26 == 0x0E)  /* addi, including li */
129         {
130           reg_unit src = (ins >> 16 & 0x1F) == 0 ? 0 : gprs [ins >> 16 & 0x1F];
131           gprs [ins >> 21 & 0x1F] = src + (int16_t) ins;
132           continue;
133         }
134       if (ins >> 26 == 0x0F)  /* addis, including lis */
135         {
136           reg_unit src = (ins >> 16 & 0x1F) == 0 ? 0 : gprs [ins >> 16 & 0x1F];
137           gprs [ins >> 21 & 0x1F] = src + ((int16_t) ins << 16);
138           continue;
139         }
140       if (ins >> 26 == 0x20)  /* lwz */
141         {
142           reg_unit src = (ins >> 16 & 0x1F) == 0 ? 0 : gprs [ins >> 16 & 0x1F];
143           uint32_t *p = (uint32_t *)(src + (int16_t) ins);
144           if (p == invalid_address)
145             return false;
146           gprs [ins >> 21 & 0x1F] = *p;
147           continue;
148         }
149       if (ins >> 26 == 0x21)  /* lwzu */
150         {
151           uint32_t *p = (uint32_t *)(gprs [ins >> 16 & 0x1F] += (int16_t) ins);
152           if (p == invalid_address)
153             return false;
154           gprs [ins >> 21 & 0x1F] = *p;
155           continue;
156         }
157       if (ins >> 26 == 0x24)  /* stw */
158         /* What we hope this is doing is '--in_sigtramp'.  We don't want
159            to actually store to memory, so just make a note of the
160            address and refuse to load from it.  */
161         {
162           reg_unit src = (ins >> 16 & 0x1F) == 0 ? 0 : gprs [ins >> 16 & 0x1F];
163           uint32_t *p = (uint32_t *)(src + (int16_t) ins);
164           if (p == NULL || invalid_address != NULL)
165             return false;
166           invalid_address = p;
167           continue;
168         }
169       if (ins >> 26 == 0x2E) /* lmw */
170         {
171           reg_unit src = (ins >> 16 & 0x1F) == 0 ? 0 : gprs [ins >> 16 & 0x1F];
172           uint32_t *p = (uint32_t *)(src + (int16_t) ins);
173           int i;
174
175           for (i = (ins >> 21 & 0x1F); i < 32; i++)
176             {
177               if (p == invalid_address)
178                 return false;
179               gprs[i] = *p++;
180             }
181           continue;
182         }
183       if ((ins & 0xFC1FFFFF) == 0x7c0803a6)  /* mtlr */
184         {
185           lr = gprs [ins >> 21 & 0x1F];
186           continue;
187         }
188       if ((ins & 0xFC1FFFFF) == 0x7c0802a6)  /* mflr */
189         {
190           gprs [ins >> 21 & 0x1F] = lr;
191           continue;
192         }
193       if ((ins & 0xFC1FFFFF) == 0x7c0903a6)  /* mtctr */
194         {
195           ctr = gprs [ins >> 21 & 0x1F];
196           continue;
197         }
198       /* The PowerPC User's Manual says that bit 11 of the mtcrf
199          instruction is reserved and should be set to zero, but it
200          looks like the Darwin assembler doesn't do that... */
201       if ((ins & 0xFC000FFF) == 0x7c000120) /* mtcrf */
202         {
203           int i;
204           uint32_t mask = 0;
205           for (i = 0; i < 8; i++)
206             mask |= ((-(ins >> (12 + i) & 1)) & 0xF) << 4 * i;
207           cr = (cr & ~mask) | (gprs [ins >> 21 & 0x1F] & mask);
208           continue;
209         }
210       if (ins == 0x429f0005)  /* bcl- 20,4*cr7+so,.+4, loads pc into LR */
211         {
212           lr = (reg_unit) pc;
213           continue;
214         }
215       if (ins == 0x4e800420) /* bctr */
216         {
217           pc = (uint32_t *) ctr;
218           continue;
219         }
220       if (ins == 0x44000002) /* sc */
221         return true;
222
223       return false;
224     }
225 }
226
227 /* We used to include <ucontext.h> and <mach/thread_status.h>,
228    but they change so much between different Darwin system versions
229    that it's much easier to just write the structures involved here
230    directly.  */
231
232 /* These defines are from the kernel's bsd/dev/ppc/unix_signal.c.  */
233 #define UC_TRAD                 1
234 #define UC_TRAD_VEC             6
235 #define UC_TRAD64               20
236 #define UC_TRAD64_VEC           25
237 #define UC_FLAVOR               30
238 #define UC_FLAVOR_VEC           35
239 #define UC_FLAVOR64             40
240 #define UC_FLAVOR64_VEC         45
241 #define UC_DUAL                 50
242 #define UC_DUAL_VEC             55
243
244 struct gcc_ucontext 
245 {
246   int onstack;
247   sigset_t sigmask;
248   void * stack_sp;
249   size_t stack_sz;
250   int stack_flags;
251   struct gcc_ucontext *link;
252   size_t mcsize;
253   struct gcc_mcontext32 *mcontext;
254 };
255
256 struct gcc_float_vector_state 
257 {
258   double fpregs[32];
259   uint32_t fpscr_pad;
260   uint32_t fpscr;
261   uint32_t save_vr[32][4];
262   uint32_t save_vscr[4];
263 };
264
265 struct gcc_mcontext32 {
266   uint32_t dar;
267   uint32_t dsisr;
268   uint32_t exception;
269   uint32_t padding1[5];
270   uint32_t srr0;
271   uint32_t srr1;
272   uint32_t gpr[32];
273   uint32_t cr;
274   uint32_t xer;
275   uint32_t lr;
276   uint32_t ctr;
277   uint32_t mq;
278   uint32_t vrsave;
279   struct gcc_float_vector_state fvs;
280 };
281
282 /* These are based on /usr/include/ppc/ucontext.h and
283    /usr/include/mach/ppc/thread_status.h, but rewritten to be more
284    convenient, to compile on Jaguar, and to work around Radar 3712064
285    on Panther, which is that the 'es' field of 'struct mcontext64' has
286    the wrong type (doh!).  */
287
288 struct gcc_mcontext64 {
289   uint64_t dar;
290   uint32_t dsisr;
291   uint32_t exception;
292   uint32_t padding1[4];
293   uint64_t srr0;
294   uint64_t srr1;
295   uint32_t gpr[32][2];
296   uint32_t cr;
297   uint32_t xer[2];  /* These are arrays because the original structure has them misaligned.  */
298   uint32_t lr[2];
299   uint32_t ctr[2];
300   uint32_t vrsave;
301   struct gcc_float_vector_state fvs;
302 };
303
304 #define UC_FLAVOR_SIZE \
305   (sizeof (struct gcc_mcontext32) - 33*16)
306
307 #define UC_FLAVOR_VEC_SIZE (sizeof (struct gcc_mcontext32))
308
309 #define UC_FLAVOR64_SIZE \
310   (sizeof (struct gcc_mcontext64) - 33*16)
311
312 #define UC_FLAVOR64_VEC_SIZE (sizeof (struct gcc_mcontext64))
313
314 /* Given GPRS as input to a 'sc' instruction, and OLD_CFA, update FS
315    to represent the execution of a signal return; or, if not a signal
316    return, return false.  */
317
318 static bool
319 handle_syscall (_Unwind_FrameState *fs, const reg_unit gprs[32],
320                 _Unwind_Ptr old_cfa)
321 {
322   struct gcc_ucontext *uctx;
323   bool is_64, is_vector;
324   struct gcc_float_vector_state * float_vector_state;
325   _Unwind_Ptr new_cfa;
326   int i;
327   static _Unwind_Ptr return_addr;
328   
329   /* Yay!  We're in a Libc that we understand, and it's made a
330      system call.  It'll be one of two kinds: either a Jaguar-style
331      SYS_sigreturn, or a Panther-style 'syscall' call with 184, which 
332      is also SYS_sigreturn.  */
333   
334   if (gprs[0] == 0x67 /* SYS_SIGRETURN */)
335     {
336       uctx = (struct gcc_ucontext *) gprs[3];
337       is_vector = (uctx->mcsize == UC_FLAVOR64_VEC_SIZE
338                    || uctx->mcsize == UC_FLAVOR_VEC_SIZE);
339       is_64 = (uctx->mcsize == UC_FLAVOR64_VEC_SIZE
340                || uctx->mcsize == UC_FLAVOR64_SIZE);
341     }
342   else if (gprs[0] == 0 && gprs[3] == 184)
343     {
344       int ctxstyle = gprs[5];
345       uctx = (struct gcc_ucontext *) gprs[4];
346       is_vector = (ctxstyle == UC_FLAVOR_VEC || ctxstyle == UC_FLAVOR64_VEC
347                    || ctxstyle == UC_TRAD_VEC || ctxstyle == UC_TRAD64_VEC);
348       is_64 = (ctxstyle == UC_FLAVOR64_VEC || ctxstyle == UC_TRAD64_VEC
349                || ctxstyle == UC_FLAVOR64 || ctxstyle == UC_TRAD64);
350     }
351   else
352     return false;
353
354 #define set_offset(r, addr)                                     \
355   (fs->regs.reg[r].how = REG_SAVED_OFFSET,                      \
356    fs->regs.reg[r].loc.offset = (_Unwind_Ptr)(addr) - new_cfa)
357
358   /* Restore even the registers that are not call-saved, since they
359      might be being used in the prologue to save other registers,
360      for instance GPR0 is sometimes used to save LR.  */
361
362   /* Handle the GPRs, and produce the information needed to do the rest.  */
363   if (is_64)
364     {
365       /* The context is 64-bit, but it doesn't carry any extra information
366          for us because only the low 32 bits of the registers are
367          call-saved.  */
368       struct gcc_mcontext64 *m64 = (struct gcc_mcontext64 *)uctx->mcontext;
369       int i;
370
371       float_vector_state = &m64->fvs;
372
373       new_cfa = m64->gpr[1][1];
374       
375       set_offset (CR2_REGNO, &m64->cr);
376       for (i = 0; i < 32; i++)
377         set_offset (i, m64->gpr[i] + 1);
378       set_offset (XER_REGNO, m64->xer + 1);
379       set_offset (LINK_REGISTER_REGNUM, m64->lr + 1);
380       set_offset (COUNT_REGISTER_REGNUM, m64->ctr + 1);
381       if (is_vector)
382         set_offset (VRSAVE_REGNO, &m64->vrsave);
383       
384       /* Sometimes, srr0 points to the instruction that caused the exception,
385          and sometimes to the next instruction to be executed; we want
386          the latter.  */
387       if (m64->exception == 3 || m64->exception == 4
388           || m64->exception == 6
389           || (m64->exception == 7 && !(m64->srr1 & 0x10000)))
390         return_addr = m64->srr0 + 4;
391       else
392         return_addr = m64->srr0;
393     }
394   else
395     {
396       struct gcc_mcontext32 *m = uctx->mcontext;
397       int i;
398
399       float_vector_state = &m->fvs;
400       
401       new_cfa = m->gpr[1];
402
403       set_offset (CR2_REGNO, &m->cr);
404       for (i = 0; i < 32; i++)
405         set_offset (i, m->gpr + i);
406       set_offset (XER_REGNO, &m->xer);
407       set_offset (LINK_REGISTER_REGNUM, &m->lr);
408       set_offset (COUNT_REGISTER_REGNUM, &m->ctr);
409
410       if (is_vector)
411         set_offset (VRSAVE_REGNO, &m->vrsave);
412
413       /* Sometimes, srr0 points to the instruction that caused the exception,
414          and sometimes to the next instruction to be executed; we want
415          the latter.  */
416       if (m->exception == 3 || m->exception == 4
417           || m->exception == 6
418           || (m->exception == 7 && !(m->srr1 & 0x10000)))
419         return_addr = m->srr0 + 4;
420       else
421         return_addr = m->srr0;
422     }
423
424   fs->cfa_how = CFA_REG_OFFSET;
425   fs->cfa_reg = STACK_POINTER_REGNUM;
426   fs->cfa_offset = new_cfa - old_cfa;;
427   
428   /* The choice of column for the return address is somewhat tricky.
429      Fortunately, the actual choice is private to this file, and
430      the space it's reserved from is the GCC register space, not the
431      DWARF2 numbering.  So any free element of the right size is an OK
432      choice.  Thus: */
433   fs->retaddr_column = ARG_POINTER_REGNUM;
434   /* FIXME: this should really be done using a DWARF2 location expression,
435      not using a static variable.  In fact, this entire file should
436      be implemented in DWARF2 expressions.  */
437   set_offset (ARG_POINTER_REGNUM, &return_addr);
438
439   for (i = 0; i < 32; i++)
440     set_offset (32 + i, float_vector_state->fpregs + i);
441   set_offset (SPEFSCR_REGNO, &float_vector_state->fpscr);
442   
443   if (is_vector)
444     {
445       for (i = 0; i < 32; i++)
446         set_offset (FIRST_ALTIVEC_REGNO + i, float_vector_state->save_vr + i);
447       set_offset (VSCR_REGNO, float_vector_state->save_vscr);
448     }
449
450   return true;
451 }
452
453 /* This is also prototyped in rs6000/darwin.h, inside the
454    MD_FALLBACK_FRAME_STATE_FOR macro.  */
455 extern bool _Unwind_fallback_frame_state_for (struct _Unwind_Context *context,
456                                               _Unwind_FrameState *fs);
457
458 /* Implement the MD_FALLBACK_FRAME_STATE_FOR macro,
459    returning true iff the frame was a sigreturn() frame that we
460    can understand.  */
461
462 bool
463 _Unwind_fallback_frame_state_for (struct _Unwind_Context *context,
464                                   _Unwind_FrameState *fs)
465 {
466   reg_unit gprs[32];
467
468   if (!interpret_libc (gprs, context))
469     return false;
470   return handle_syscall (fs, gprs, _Unwind_GetCFA (context));
471 }