1 /* Subroutines needed for unwinding IA-64 standard format stack frame
2 info for exception handling.
3 Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002
4 Free Software Foundation, Inc.
5 Contributed by Andrew MacLeod <amacleod@cygnus.com>
6 Andrew Haley <aph@cygnus.com>
7 David Mosberger-Tang <davidm@hpl.hp.com>
9 This file is part of GNU CC.
11 GNU CC is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 2, or (at your option)
16 GNU CC is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with GNU CC; see the file COPYING. If not, write to
23 the Free Software Foundation, 59 Temple Place - Suite 330,
24 Boston, MA 02111-1307, USA. */
26 /* As a special exception, if you link this library with other files,
27 some of which are compiled with GCC, to produce an executable,
28 this library does not by itself cause the resulting executable
29 to be covered by the GNU General Public License.
30 This exception does not however invalidate any other reasons why
31 the executable file might be covered by the GNU General Public License. */
36 #include "coretypes.h"
39 #include "unwind-ia64.h"
40 #include "ia64intrin.h"
42 /* This isn't thread safe, but nice for occasional tests. */
43 #undef ENABLE_MALLOC_CHECKING
45 #ifndef __USING_SJLJ_EXCEPTIONS__
46 #define UNW_VER(x) ((x) >> 48)
47 #define UNW_FLAG_MASK 0x0000ffff00000000
48 #define UNW_FLAG_OSMASK 0x0000f00000000000
49 #define UNW_FLAG_EHANDLER(x) ((x) & 0x0000000100000000L)
50 #define UNW_FLAG_UHANDLER(x) ((x) & 0x0000000200000000L)
51 #define UNW_LENGTH(x) ((x) & 0x00000000ffffffffL)
53 enum unw_application_register
67 enum unw_register_index
74 UNW_REG_PSP, /* previous memory stack pointer */
77 UNW_REG_BSP, /* register stack pointer */
79 UNW_REG_PFS, /* previous function state */
84 /* Special preserved registers. */
85 UNW_REG_UNAT, UNW_REG_PR, UNW_REG_LC, UNW_REG_FPSR,
87 /* Non-stacked general registers. */
89 UNW_REG_R4 = UNW_REG_R2 + 2,
90 UNW_REG_R7 = UNW_REG_R2 + 5,
91 UNW_REG_R31 = UNW_REG_R2 + 29,
93 /* Non-stacked floating point registers. */
95 UNW_REG_F5 = UNW_REG_F2 + 3,
96 UNW_REG_F16 = UNW_REG_F2 + 14,
97 UNW_REG_F31 = UNW_REG_F2 + 29,
99 /* Branch registers. */
100 UNW_REG_B0, UNW_REG_B1,
101 UNW_REG_B5 = UNW_REG_B1 + 4,
108 UNW_WHERE_NONE, /* register isn't saved at all */
109 UNW_WHERE_GR, /* register is saved in a general register */
110 UNW_WHERE_FR, /* register is saved in a floating-point register */
111 UNW_WHERE_BR, /* register is saved in a branch register */
112 UNW_WHERE_SPREL, /* register is saved on memstack (sp-relative) */
113 UNW_WHERE_PSPREL, /* register is saved on memstack (psp-relative) */
115 /* At the end of each prologue these locations get resolved to
116 UNW_WHERE_PSPREL and UNW_WHERE_GR, respectively. */
117 UNW_WHERE_SPILL_HOME, /* register is saved in its spill home */
118 UNW_WHERE_GR_SAVE /* register is saved in next general register */
121 #define UNW_WHEN_NEVER 0x7fffffff
125 unsigned long val; /* save location: register number or offset */
126 enum unw_where where; /* where the register gets saved */
127 int when; /* when the register gets saved */
130 struct unw_reg_state {
131 struct unw_reg_state *next; /* next (outer) element on state stack */
132 struct unw_reg_info reg[UNW_NUM_REGS]; /* register save locations */
135 struct unw_labeled_state {
136 struct unw_labeled_state *next; /* next labeled state (or NULL) */
137 unsigned long label; /* label for this state */
138 struct unw_reg_state saved_state;
141 typedef struct unw_state_record
143 unsigned int first_region : 1; /* is this the first region? */
144 unsigned int done : 1; /* are we done scanning descriptors? */
145 unsigned int any_spills : 1; /* got any register spills? */
146 unsigned int in_body : 1; /* are we inside a body? */
147 unsigned int no_reg_stack_frame : 1; /* Don't adjust bsp for i&l regs */
148 unsigned char *imask; /* imask of spill_mask record or NULL */
149 unsigned long pr_val; /* predicate values */
150 unsigned long pr_mask; /* predicate mask */
151 long spill_offset; /* psp-relative offset for spill base */
158 unsigned char gr_save_loc; /* next general register to use for saving */
159 unsigned char return_link_reg; /* branch register for return link */
161 struct unw_labeled_state *labeled_states; /* list of all labeled states */
162 struct unw_reg_state curr; /* current state */
164 _Unwind_Personality_Fn personality;
166 } _Unwind_FrameState;
170 UNW_NAT_NONE, /* NaT not represented */
171 UNW_NAT_VAL, /* NaT represented by NaT value (fp reg) */
172 UNW_NAT_MEMSTK, /* NaT value is in unat word at offset OFF */
173 UNW_NAT_REGSTK /* NaT is in rnat */
182 struct _Unwind_Context
184 /* Initial frame info. */
185 unsigned long rnat; /* rse nat collection */
186 unsigned long regstk_top; /* bsp for first frame */
188 /* Current frame info. */
189 unsigned long bsp; /* backing store pointer value
190 corresponding to psp. */
191 unsigned long sp; /* stack pointer value */
192 unsigned long psp; /* previous sp value */
193 unsigned long rp; /* return pointer */
194 unsigned long pr; /* predicate collection */
196 unsigned long region_start; /* start of unwind region */
197 unsigned long gp; /* global pointer value */
198 void *lsda; /* language specific data area */
200 /* Preserved state. */
201 unsigned long *bsp_loc; /* previous bsp save location
202 Appears to be write-only? */
203 unsigned long *bspstore_loc;
204 unsigned long *pfs_loc; /* Save location for pfs in current
205 (corr. to sp) frame. Target
206 contains cfm for caller. */
207 unsigned long *pri_unat_loc;
208 unsigned long *unat_loc;
209 unsigned long *lc_loc;
210 unsigned long *fpsr_loc;
212 unsigned long eh_data[4];
219 enum unw_nat_type type : 3;
220 signed long off : 61; /* NaT word is at loc+nat.off */
222 } ireg[32 - 2]; /* Indexed by <register number> - 2 */
224 unsigned long *br_loc[7];
225 void *fr_loc[32 - 2];
227 /* ??? We initially point pri_unat_loc here. The entire NAT bit
229 unsigned long initial_unat;
232 typedef unsigned long unw_word;
234 /* Implicit register save order. See section 11.4.2.3 Rules for Using
235 Unwind Descriptors, rule 3. */
237 static unsigned char const save_order[] =
239 UNW_REG_RP, UNW_REG_PFS, UNW_REG_PSP, UNW_REG_PR,
240 UNW_REG_UNAT, UNW_REG_LC, UNW_REG_FPSR, UNW_REG_PRI_UNAT_GR
244 #define MIN(X, Y) ((X) < (Y) ? (X) : (Y))
246 /* MASK is a bitmap describing the allocation state of emergency buffers,
247 with bit set indicating free. Return >= 0 if allocation is successful;
251 atomic_alloc (unsigned int *mask)
253 unsigned int old = *mask, ret, new;
261 new = __sync_val_compare_and_swap (mask, old, new);
267 return __builtin_ffs (ret) - 1;
270 /* Similarly, free an emergency buffer. */
273 atomic_free (unsigned int *mask, int bit)
275 __sync_xor_and_fetch (mask, 1 << bit);
279 #define SIZE(X) (sizeof(X) / sizeof(*(X)))
280 #define MASK_FOR(X) ((2U << (SIZE (X) - 1)) - 1)
281 #define PTR_IN(X, P) ((P) >= (X) && (P) < (X) + SIZE (X))
283 static struct unw_reg_state emergency_reg_state[32];
284 static int emergency_reg_state_free = MASK_FOR (emergency_reg_state);
286 static struct unw_labeled_state emergency_labeled_state[8];
287 static int emergency_labeled_state_free = MASK_FOR (emergency_labeled_state);
289 #ifdef ENABLE_MALLOC_CHECKING
290 static int reg_state_alloced;
291 static int labeled_state_alloced;
294 /* Allocation and deallocation of structures. */
296 static struct unw_reg_state *
297 alloc_reg_state (void)
299 struct unw_reg_state *rs;
301 #ifdef ENABLE_MALLOC_CHECKING
305 rs = malloc (sizeof (struct unw_reg_state));
308 int n = atomic_alloc (&emergency_reg_state_free);
310 rs = &emergency_reg_state[n];
317 free_reg_state (struct unw_reg_state *rs)
319 #ifdef ENABLE_MALLOC_CHECKING
323 if (PTR_IN (emergency_reg_state, rs))
324 atomic_free (&emergency_reg_state_free, rs - emergency_reg_state);
329 static struct unw_labeled_state *
330 alloc_label_state (void)
332 struct unw_labeled_state *ls;
334 #ifdef ENABLE_MALLOC_CHECKING
335 labeled_state_alloced++;
338 ls = malloc(sizeof(struct unw_labeled_state));
341 int n = atomic_alloc (&emergency_labeled_state_free);
343 ls = &emergency_labeled_state[n];
350 free_label_state (struct unw_labeled_state *ls)
352 #ifdef ENABLE_MALLOC_CHECKING
353 labeled_state_alloced--;
356 if (PTR_IN (emergency_labeled_state, ls))
357 atomic_free (&emergency_labeled_state_free, emergency_labeled_state - ls);
362 /* Routines to manipulate the state stack. */
365 push (struct unw_state_record *sr)
367 struct unw_reg_state *rs = alloc_reg_state ();
368 memcpy (rs, &sr->curr, sizeof (*rs));
373 pop (struct unw_state_record *sr)
375 struct unw_reg_state *rs = sr->curr.next;
379 memcpy (&sr->curr, rs, sizeof(*rs));
383 /* Make a copy of the state stack. Non-recursive to avoid stack overflows. */
385 static struct unw_reg_state *
386 dup_state_stack (struct unw_reg_state *rs)
388 struct unw_reg_state *copy, *prev = NULL, *first = NULL;
392 copy = alloc_reg_state ();
393 memcpy (copy, rs, sizeof(*copy));
405 /* Free all stacked register states (but not RS itself). */
407 free_state_stack (struct unw_reg_state *rs)
409 struct unw_reg_state *p, *next;
411 for (p = rs->next; p != NULL; p = next)
419 /* Free all labeled states. */
422 free_label_states (struct unw_labeled_state *ls)
424 struct unw_labeled_state *next;
426 for (; ls ; ls = next)
430 free_state_stack (&ls->saved_state);
431 free_label_state (ls);
435 /* Unwind decoder routines */
437 static enum unw_register_index __attribute__((const))
438 decode_abreg (unsigned char abreg, int memory)
442 case 0x04 ... 0x07: return UNW_REG_R4 + (abreg - 0x04);
443 case 0x22 ... 0x25: return UNW_REG_F2 + (abreg - 0x22);
444 case 0x30 ... 0x3f: return UNW_REG_F16 + (abreg - 0x30);
445 case 0x41 ... 0x45: return UNW_REG_B1 + (abreg - 0x41);
446 case 0x60: return UNW_REG_PR;
447 case 0x61: return UNW_REG_PSP;
448 case 0x62: return memory ? UNW_REG_PRI_UNAT_MEM : UNW_REG_PRI_UNAT_GR;
449 case 0x63: return UNW_REG_RP;
450 case 0x64: return UNW_REG_BSP;
451 case 0x65: return UNW_REG_BSPSTORE;
452 case 0x66: return UNW_REG_RNAT;
453 case 0x67: return UNW_REG_UNAT;
454 case 0x68: return UNW_REG_FPSR;
455 case 0x69: return UNW_REG_PFS;
456 case 0x6a: return UNW_REG_LC;
463 set_reg (struct unw_reg_info *reg, enum unw_where where,
464 int when, unsigned long val)
468 if (reg->when == UNW_WHEN_NEVER)
473 alloc_spill_area (unsigned long *offp, unsigned long regsize,
474 struct unw_reg_info *lo, struct unw_reg_info *hi)
476 struct unw_reg_info *reg;
478 for (reg = hi; reg >= lo; --reg)
480 if (reg->where == UNW_WHERE_SPILL_HOME)
482 reg->where = UNW_WHERE_PSPREL;
490 spill_next_when (struct unw_reg_info **regp, struct unw_reg_info *lim,
493 struct unw_reg_info *reg;
495 for (reg = *regp; reg <= lim; ++reg)
497 if (reg->where == UNW_WHERE_SPILL_HOME)
509 finish_prologue (struct unw_state_record *sr)
511 struct unw_reg_info *reg;
515 /* First, resolve implicit register save locations
516 (see Section "11.4.2.3 Rules for Using Unwind Descriptors", rule 3). */
518 for (i = 0; i < (int) sizeof (save_order); ++i)
520 reg = sr->curr.reg + save_order[i];
521 if (reg->where == UNW_WHERE_GR_SAVE)
523 reg->where = UNW_WHERE_GR;
524 reg->val = sr->gr_save_loc++;
528 /* Next, compute when the fp, general, and branch registers get saved.
529 This must come before alloc_spill_area() because we need to know
530 which registers are spilled to their home locations. */
533 static unsigned char const limit[3] = {
534 UNW_REG_F31, UNW_REG_R7, UNW_REG_B5
537 unsigned char kind, mask = 0, *cp = sr->imask;
539 struct unw_reg_info *(regs[3]);
541 regs[0] = sr->curr.reg + UNW_REG_F2;
542 regs[1] = sr->curr.reg + UNW_REG_R4;
543 regs[2] = sr->curr.reg + UNW_REG_B1;
545 for (t = 0; t < sr->region_len; ++t)
549 kind = (mask >> 2*(3-(t & 3))) & 3;
551 spill_next_when (®s[kind - 1], sr->curr.reg + limit[kind - 1],
552 sr->region_start + t);
556 /* Next, lay out the memory stack spill area. */
559 off = sr->spill_offset;
560 alloc_spill_area (&off, 16, sr->curr.reg + UNW_REG_F2,
561 sr->curr.reg + UNW_REG_F31);
562 alloc_spill_area (&off, 8, sr->curr.reg + UNW_REG_B1,
563 sr->curr.reg + UNW_REG_B5);
564 alloc_spill_area (&off, 8, sr->curr.reg + UNW_REG_R4,
565 sr->curr.reg + UNW_REG_R7);
570 * Region header descriptors.
574 desc_prologue (int body, unw_word rlen, unsigned char mask,
575 unsigned char grsave, struct unw_state_record *sr)
579 if (!(sr->in_body || sr->first_region))
580 finish_prologue (sr);
581 sr->first_region = 0;
583 /* Check if we're done. */
584 if (sr->when_target < sr->region_start + sr->region_len)
590 for (i = 0; i < sr->epilogue_count; ++i)
593 sr->epilogue_count = 0;
594 sr->epilogue_start = UNW_WHEN_NEVER;
599 sr->region_start += sr->region_len;
600 sr->region_len = rlen;
605 for (i = 0; i < 4; ++i)
608 set_reg (sr->curr.reg + save_order[i], UNW_WHERE_GR,
609 sr->region_start + sr->region_len - 1, grsave++);
612 sr->gr_save_loc = grsave;
615 sr->spill_offset = 0x10; /* default to psp+16 */
620 * Prologue descriptors.
624 desc_abi (unsigned char abi __attribute__((unused)),
625 unsigned char context __attribute__((unused)),
626 struct unw_state_record *sr __attribute__((unused)))
628 /* Anything to do? */
632 desc_br_gr (unsigned char brmask, unsigned char gr,
633 struct unw_state_record *sr)
637 for (i = 0; i < 5; ++i)
640 set_reg (sr->curr.reg + UNW_REG_B1 + i, UNW_WHERE_GR,
641 sr->region_start + sr->region_len - 1, gr++);
647 desc_br_mem (unsigned char brmask, struct unw_state_record *sr)
651 for (i = 0; i < 5; ++i)
655 set_reg (sr->curr.reg + UNW_REG_B1 + i, UNW_WHERE_SPILL_HOME,
656 sr->region_start + sr->region_len - 1, 0);
664 desc_frgr_mem (unsigned char grmask, unw_word frmask,
665 struct unw_state_record *sr)
669 for (i = 0; i < 4; ++i)
671 if ((grmask & 1) != 0)
673 set_reg (sr->curr.reg + UNW_REG_R4 + i, UNW_WHERE_SPILL_HOME,
674 sr->region_start + sr->region_len - 1, 0);
679 for (i = 0; i < 20; ++i)
681 if ((frmask & 1) != 0)
683 enum unw_register_index base = i < 4 ? UNW_REG_F2 : UNW_REG_F16 - 4;
684 set_reg (sr->curr.reg + base + i, UNW_WHERE_SPILL_HOME,
685 sr->region_start + sr->region_len - 1, 0);
693 desc_fr_mem (unsigned char frmask, struct unw_state_record *sr)
697 for (i = 0; i < 4; ++i)
699 if ((frmask & 1) != 0)
701 set_reg (sr->curr.reg + UNW_REG_F2 + i, UNW_WHERE_SPILL_HOME,
702 sr->region_start + sr->region_len - 1, 0);
710 desc_gr_gr (unsigned char grmask, unsigned char gr,
711 struct unw_state_record *sr)
715 for (i = 0; i < 4; ++i)
717 if ((grmask & 1) != 0)
718 set_reg (sr->curr.reg + UNW_REG_R4 + i, UNW_WHERE_GR,
719 sr->region_start + sr->region_len - 1, gr++);
725 desc_gr_mem (unsigned char grmask, struct unw_state_record *sr)
729 for (i = 0; i < 4; ++i)
731 if ((grmask & 1) != 0)
733 set_reg (sr->curr.reg + UNW_REG_R4 + i, UNW_WHERE_SPILL_HOME,
734 sr->region_start + sr->region_len - 1, 0);
742 desc_mem_stack_f (unw_word t, unw_word size, struct unw_state_record *sr)
744 set_reg (sr->curr.reg + UNW_REG_PSP, UNW_WHERE_NONE,
745 sr->region_start + MIN ((int)t, sr->region_len - 1), 16*size);
749 desc_mem_stack_v (unw_word t, struct unw_state_record *sr)
751 sr->curr.reg[UNW_REG_PSP].when
752 = sr->region_start + MIN ((int)t, sr->region_len - 1);
756 desc_reg_gr (unsigned char reg, unsigned char dst, struct unw_state_record *sr)
758 set_reg (sr->curr.reg + reg, UNW_WHERE_GR,
759 sr->region_start + sr->region_len - 1, dst);
763 desc_reg_psprel (unsigned char reg, unw_word pspoff,
764 struct unw_state_record *sr)
766 set_reg (sr->curr.reg + reg, UNW_WHERE_PSPREL,
767 sr->region_start + sr->region_len - 1,
772 desc_reg_sprel (unsigned char reg, unw_word spoff, struct unw_state_record *sr)
774 set_reg (sr->curr.reg + reg, UNW_WHERE_SPREL,
775 sr->region_start + sr->region_len - 1,
780 desc_rp_br (unsigned char dst, struct unw_state_record *sr)
782 sr->return_link_reg = dst;
786 desc_reg_when (unsigned char regnum, unw_word t, struct unw_state_record *sr)
788 struct unw_reg_info *reg = sr->curr.reg + regnum;
790 if (reg->where == UNW_WHERE_NONE)
791 reg->where = UNW_WHERE_GR_SAVE;
792 reg->when = sr->region_start + MIN ((int)t, sr->region_len - 1);
796 desc_spill_base (unw_word pspoff, struct unw_state_record *sr)
798 sr->spill_offset = 0x10 - 4*pspoff;
801 static inline unsigned char *
802 desc_spill_mask (unsigned char *imaskp, struct unw_state_record *sr)
805 return imaskp + (2*sr->region_len + 7)/8;
812 desc_epilogue (unw_word t, unw_word ecount, struct unw_state_record *sr)
814 sr->epilogue_start = sr->region_start + sr->region_len - 1 - t;
815 sr->epilogue_count = ecount + 1;
819 desc_copy_state (unw_word label, struct unw_state_record *sr)
821 struct unw_labeled_state *ls;
823 for (ls = sr->labeled_states; ls; ls = ls->next)
825 if (ls->label == label)
827 free_state_stack (&sr->curr);
828 memcpy (&sr->curr, &ls->saved_state, sizeof (sr->curr));
829 sr->curr.next = dup_state_stack (ls->saved_state.next);
837 desc_label_state (unw_word label, struct unw_state_record *sr)
839 struct unw_labeled_state *ls = alloc_label_state ();
842 memcpy (&ls->saved_state, &sr->curr, sizeof (ls->saved_state));
843 ls->saved_state.next = dup_state_stack (sr->curr.next);
845 /* Insert into list of labeled states. */
846 ls->next = sr->labeled_states;
847 sr->labeled_states = ls;
851 * General descriptors.
855 desc_is_active (unsigned char qp, unw_word t, struct unw_state_record *sr)
857 if (sr->when_target <= sr->region_start + MIN ((int)t, sr->region_len - 1))
861 if ((sr->pr_val & (1UL << qp)) == 0)
863 sr->pr_mask |= (1UL << qp);
869 desc_restore_p (unsigned char qp, unw_word t, unsigned char abreg,
870 struct unw_state_record *sr)
872 struct unw_reg_info *r;
874 if (! desc_is_active (qp, t, sr))
877 r = sr->curr.reg + decode_abreg (abreg, 0);
878 r->where = UNW_WHERE_NONE;
879 r->when = sr->region_start + MIN ((int)t, sr->region_len - 1);
884 desc_spill_reg_p (unsigned char qp, unw_word t, unsigned char abreg,
885 unsigned char x, unsigned char ytreg,
886 struct unw_state_record *sr)
888 enum unw_where where = UNW_WHERE_GR;
889 struct unw_reg_info *r;
891 if (! desc_is_active (qp, t, sr))
895 where = UNW_WHERE_BR;
896 else if (ytreg & 0x80)
897 where = UNW_WHERE_FR;
899 r = sr->curr.reg + decode_abreg (abreg, 0);
901 r->when = sr->region_start + MIN ((int)t, sr->region_len - 1);
902 r->val = ytreg & 0x7f;
906 desc_spill_psprel_p (unsigned char qp, unw_word t, unsigned char abreg,
907 unw_word pspoff, struct unw_state_record *sr)
909 struct unw_reg_info *r;
911 if (! desc_is_active (qp, t, sr))
914 r = sr->curr.reg + decode_abreg (abreg, 1);
915 r->where = UNW_WHERE_PSPREL;
916 r->when = sr->region_start + MIN((int)t, sr->region_len - 1);
917 r->val = 0x10 - 4*pspoff;
921 desc_spill_sprel_p (unsigned char qp, unw_word t, unsigned char abreg,
922 unw_word spoff, struct unw_state_record *sr)
924 struct unw_reg_info *r;
926 if (! desc_is_active (qp, t, sr))
929 r = sr->curr.reg + decode_abreg (abreg, 1);
930 r->where = UNW_WHERE_SPREL;
931 r->when = sr->region_start + MIN ((int)t, sr->region_len - 1);
936 #define UNW_DEC_BAD_CODE(code) abort ();
938 /* Region headers. */
939 #define UNW_DEC_PROLOGUE_GR(fmt,r,m,gr,arg) desc_prologue(0,r,m,gr,arg)
940 #define UNW_DEC_PROLOGUE(fmt,b,r,arg) desc_prologue(b,r,0,32,arg)
942 /* Prologue descriptors. */
943 #define UNW_DEC_ABI(fmt,a,c,arg) desc_abi(a,c,arg)
944 #define UNW_DEC_BR_GR(fmt,b,g,arg) desc_br_gr(b,g,arg)
945 #define UNW_DEC_BR_MEM(fmt,b,arg) desc_br_mem(b,arg)
946 #define UNW_DEC_FRGR_MEM(fmt,g,f,arg) desc_frgr_mem(g,f,arg)
947 #define UNW_DEC_FR_MEM(fmt,f,arg) desc_fr_mem(f,arg)
948 #define UNW_DEC_GR_GR(fmt,m,g,arg) desc_gr_gr(m,g,arg)
949 #define UNW_DEC_GR_MEM(fmt,m,arg) desc_gr_mem(m,arg)
950 #define UNW_DEC_MEM_STACK_F(fmt,t,s,arg) desc_mem_stack_f(t,s,arg)
951 #define UNW_DEC_MEM_STACK_V(fmt,t,arg) desc_mem_stack_v(t,arg)
952 #define UNW_DEC_REG_GR(fmt,r,d,arg) desc_reg_gr(r,d,arg)
953 #define UNW_DEC_REG_PSPREL(fmt,r,o,arg) desc_reg_psprel(r,o,arg)
954 #define UNW_DEC_REG_SPREL(fmt,r,o,arg) desc_reg_sprel(r,o,arg)
955 #define UNW_DEC_REG_WHEN(fmt,r,t,arg) desc_reg_when(r,t,arg)
956 #define UNW_DEC_PRIUNAT_WHEN_GR(fmt,t,arg) desc_reg_when(UNW_REG_PRI_UNAT_GR,t,arg)
957 #define UNW_DEC_PRIUNAT_WHEN_MEM(fmt,t,arg) desc_reg_when(UNW_REG_PRI_UNAT_MEM,t,arg)
958 #define UNW_DEC_PRIUNAT_GR(fmt,r,arg) desc_reg_gr(UNW_REG_PRI_UNAT_GR,r,arg)
959 #define UNW_DEC_PRIUNAT_PSPREL(fmt,o,arg) desc_reg_psprel(UNW_REG_PRI_UNAT_MEM,o,arg)
960 #define UNW_DEC_PRIUNAT_SPREL(fmt,o,arg) desc_reg_sprel(UNW_REG_PRI_UNAT_MEM,o,arg)
961 #define UNW_DEC_RP_BR(fmt,d,arg) desc_rp_br(d,arg)
962 #define UNW_DEC_SPILL_BASE(fmt,o,arg) desc_spill_base(o,arg)
963 #define UNW_DEC_SPILL_MASK(fmt,m,arg) (m = desc_spill_mask(m,arg))
965 /* Body descriptors. */
966 #define UNW_DEC_EPILOGUE(fmt,t,c,arg) desc_epilogue(t,c,arg)
967 #define UNW_DEC_COPY_STATE(fmt,l,arg) desc_copy_state(l,arg)
968 #define UNW_DEC_LABEL_STATE(fmt,l,arg) desc_label_state(l,arg)
970 /* General unwind descriptors. */
971 #define UNW_DEC_SPILL_REG_P(f,p,t,a,x,y,arg) desc_spill_reg_p(p,t,a,x,y,arg)
972 #define UNW_DEC_SPILL_REG(f,t,a,x,y,arg) desc_spill_reg_p(0,t,a,x,y,arg)
973 #define UNW_DEC_SPILL_PSPREL_P(f,p,t,a,o,arg) desc_spill_psprel_p(p,t,a,o,arg)
974 #define UNW_DEC_SPILL_PSPREL(f,t,a,o,arg) desc_spill_psprel_p(0,t,a,o,arg)
975 #define UNW_DEC_SPILL_SPREL_P(f,p,t,a,o,arg) desc_spill_sprel_p(p,t,a,o,arg)
976 #define UNW_DEC_SPILL_SPREL(f,t,a,o,arg) desc_spill_sprel_p(0,t,a,o,arg)
977 #define UNW_DEC_RESTORE_P(f,p,t,a,arg) desc_restore_p(p,t,a,arg)
978 #define UNW_DEC_RESTORE(f,t,a,arg) desc_restore_p(0,t,a,arg)
982 * Generic IA-64 unwind info decoder.
984 * This file is used both by the Linux kernel and objdump. Please keep
985 * the copies of this file in sync.
987 * You need to customize the decoder by defining the following
988 * macros/constants before including this file:
991 * unw_word Unsigned integer type with at least 64 bits
1005 * Decoder action macros:
1006 * UNW_DEC_BAD_CODE(code)
1007 * UNW_DEC_ABI(fmt,abi,context,arg)
1008 * UNW_DEC_BR_GR(fmt,brmask,gr,arg)
1009 * UNW_DEC_BR_MEM(fmt,brmask,arg)
1010 * UNW_DEC_COPY_STATE(fmt,label,arg)
1011 * UNW_DEC_EPILOGUE(fmt,t,ecount,arg)
1012 * UNW_DEC_FRGR_MEM(fmt,grmask,frmask,arg)
1013 * UNW_DEC_FR_MEM(fmt,frmask,arg)
1014 * UNW_DEC_GR_GR(fmt,grmask,gr,arg)
1015 * UNW_DEC_GR_MEM(fmt,grmask,arg)
1016 * UNW_DEC_LABEL_STATE(fmt,label,arg)
1017 * UNW_DEC_MEM_STACK_F(fmt,t,size,arg)
1018 * UNW_DEC_MEM_STACK_V(fmt,t,arg)
1019 * UNW_DEC_PRIUNAT_GR(fmt,r,arg)
1020 * UNW_DEC_PRIUNAT_WHEN_GR(fmt,t,arg)
1021 * UNW_DEC_PRIUNAT_WHEN_MEM(fmt,t,arg)
1022 * UNW_DEC_PRIUNAT_WHEN_PSPREL(fmt,pspoff,arg)
1023 * UNW_DEC_PRIUNAT_WHEN_SPREL(fmt,spoff,arg)
1024 * UNW_DEC_PROLOGUE(fmt,body,rlen,arg)
1025 * UNW_DEC_PROLOGUE_GR(fmt,rlen,mask,grsave,arg)
1026 * UNW_DEC_REG_PSPREL(fmt,reg,pspoff,arg)
1027 * UNW_DEC_REG_REG(fmt,src,dst,arg)
1028 * UNW_DEC_REG_SPREL(fmt,reg,spoff,arg)
1029 * UNW_DEC_REG_WHEN(fmt,reg,t,arg)
1030 * UNW_DEC_RESTORE(fmt,t,abreg,arg)
1031 * UNW_DEC_RESTORE_P(fmt,qp,t,abreg,arg)
1032 * UNW_DEC_SPILL_BASE(fmt,pspoff,arg)
1033 * UNW_DEC_SPILL_MASK(fmt,imaskp,arg)
1034 * UNW_DEC_SPILL_PSPREL(fmt,t,abreg,pspoff,arg)
1035 * UNW_DEC_SPILL_PSPREL_P(fmt,qp,t,abreg,pspoff,arg)
1036 * UNW_DEC_SPILL_REG(fmt,t,abreg,x,ytreg,arg)
1037 * UNW_DEC_SPILL_REG_P(fmt,qp,t,abreg,x,ytreg,arg)
1038 * UNW_DEC_SPILL_SPREL(fmt,t,abreg,spoff,arg)
1039 * UNW_DEC_SPILL_SPREL_P(fmt,qp,t,abreg,pspoff,arg)
1043 unw_decode_uleb128 (unsigned char **dpp)
1046 unw_word byte, result = 0;
1047 unsigned char *bp = *dpp;
1052 result |= (byte & 0x7f) << shift;
1053 if ((byte & 0x80) == 0)
1061 static unsigned char *
1062 unw_decode_x1 (unsigned char *dp,
1063 unsigned char code __attribute__((unused)),
1066 unsigned char byte1, abreg;
1070 t = unw_decode_uleb128 (&dp);
1071 off = unw_decode_uleb128 (&dp);
1072 abreg = (byte1 & 0x7f);
1074 UNW_DEC_SPILL_SPREL(X1, t, abreg, off, arg);
1076 UNW_DEC_SPILL_PSPREL(X1, t, abreg, off, arg);
1080 static unsigned char *
1081 unw_decode_x2 (unsigned char *dp,
1082 unsigned char code __attribute__((unused)),
1085 unsigned char byte1, byte2, abreg, x, ytreg;
1088 byte1 = *dp++; byte2 = *dp++;
1089 t = unw_decode_uleb128 (&dp);
1090 abreg = (byte1 & 0x7f);
1092 x = (byte1 >> 7) & 1;
1093 if ((byte1 & 0x80) == 0 && ytreg == 0)
1094 UNW_DEC_RESTORE(X2, t, abreg, arg);
1096 UNW_DEC_SPILL_REG(X2, t, abreg, x, ytreg, arg);
1100 static unsigned char *
1101 unw_decode_x3 (unsigned char *dp,
1102 unsigned char code __attribute__((unused)),
1105 unsigned char byte1, byte2, abreg, qp;
1108 byte1 = *dp++; byte2 = *dp++;
1109 t = unw_decode_uleb128 (&dp);
1110 off = unw_decode_uleb128 (&dp);
1112 qp = (byte1 & 0x3f);
1113 abreg = (byte2 & 0x7f);
1116 UNW_DEC_SPILL_SPREL_P(X3, qp, t, abreg, off, arg);
1118 UNW_DEC_SPILL_PSPREL_P(X3, qp, t, abreg, off, arg);
1122 static unsigned char *
1123 unw_decode_x4 (unsigned char *dp,
1124 unsigned char code __attribute__((unused)),
1127 unsigned char byte1, byte2, byte3, qp, abreg, x, ytreg;
1130 byte1 = *dp++; byte2 = *dp++; byte3 = *dp++;
1131 t = unw_decode_uleb128 (&dp);
1133 qp = (byte1 & 0x3f);
1134 abreg = (byte2 & 0x7f);
1135 x = (byte2 >> 7) & 1;
1138 if ((byte2 & 0x80) == 0 && byte3 == 0)
1139 UNW_DEC_RESTORE_P(X4, qp, t, abreg, arg);
1141 UNW_DEC_SPILL_REG_P(X4, qp, t, abreg, x, ytreg, arg);
1145 static unsigned char *
1146 unw_decode_r1 (unsigned char *dp, unsigned char code, void *arg)
1148 int body = (code & 0x20) != 0;
1151 rlen = (code & 0x1f);
1152 UNW_DEC_PROLOGUE(R1, body, rlen, arg);
1156 static unsigned char *
1157 unw_decode_r2 (unsigned char *dp, unsigned char code, void *arg)
1159 unsigned char byte1, mask, grsave;
1164 mask = ((code & 0x7) << 1) | ((byte1 >> 7) & 1);
1165 grsave = (byte1 & 0x7f);
1166 rlen = unw_decode_uleb128 (&dp);
1167 UNW_DEC_PROLOGUE_GR(R2, rlen, mask, grsave, arg);
1171 static unsigned char *
1172 unw_decode_r3 (unsigned char *dp, unsigned char code, void *arg)
1176 rlen = unw_decode_uleb128 (&dp);
1177 UNW_DEC_PROLOGUE(R3, ((code & 0x3) == 1), rlen, arg);
1181 static unsigned char *
1182 unw_decode_p1 (unsigned char *dp, unsigned char code, void *arg)
1184 unsigned char brmask = (code & 0x1f);
1186 UNW_DEC_BR_MEM(P1, brmask, arg);
1190 static unsigned char *
1191 unw_decode_p2_p5 (unsigned char *dp, unsigned char code, void *arg)
1193 if ((code & 0x10) == 0)
1195 unsigned char byte1 = *dp++;
1197 UNW_DEC_BR_GR(P2, ((code & 0xf) << 1) | ((byte1 >> 7) & 1),
1198 (byte1 & 0x7f), arg);
1200 else if ((code & 0x08) == 0)
1202 unsigned char byte1 = *dp++, r, dst;
1204 r = ((code & 0x7) << 1) | ((byte1 >> 7) & 1);
1205 dst = (byte1 & 0x7f);
1208 case 0: UNW_DEC_REG_GR(P3, UNW_REG_PSP, dst, arg); break;
1209 case 1: UNW_DEC_REG_GR(P3, UNW_REG_RP, dst, arg); break;
1210 case 2: UNW_DEC_REG_GR(P3, UNW_REG_PFS, dst, arg); break;
1211 case 3: UNW_DEC_REG_GR(P3, UNW_REG_PR, dst, arg); break;
1212 case 4: UNW_DEC_REG_GR(P3, UNW_REG_UNAT, dst, arg); break;
1213 case 5: UNW_DEC_REG_GR(P3, UNW_REG_LC, dst, arg); break;
1214 case 6: UNW_DEC_RP_BR(P3, dst, arg); break;
1215 case 7: UNW_DEC_REG_GR(P3, UNW_REG_RNAT, dst, arg); break;
1216 case 8: UNW_DEC_REG_GR(P3, UNW_REG_BSP, dst, arg); break;
1217 case 9: UNW_DEC_REG_GR(P3, UNW_REG_BSPSTORE, dst, arg); break;
1218 case 10: UNW_DEC_REG_GR(P3, UNW_REG_FPSR, dst, arg); break;
1219 case 11: UNW_DEC_PRIUNAT_GR(P3, dst, arg); break;
1220 default: UNW_DEC_BAD_CODE(r); break;
1223 else if ((code & 0x7) == 0)
1224 UNW_DEC_SPILL_MASK(P4, dp, arg);
1225 else if ((code & 0x7) == 1)
1227 unw_word grmask, frmask, byte1, byte2, byte3;
1229 byte1 = *dp++; byte2 = *dp++; byte3 = *dp++;
1230 grmask = ((byte1 >> 4) & 0xf);
1231 frmask = ((byte1 & 0xf) << 16) | (byte2 << 8) | byte3;
1232 UNW_DEC_FRGR_MEM(P5, grmask, frmask, arg);
1235 UNW_DEC_BAD_CODE(code);
1239 static unsigned char *
1240 unw_decode_p6 (unsigned char *dp, unsigned char code, void *arg)
1242 int gregs = (code & 0x10) != 0;
1243 unsigned char mask = (code & 0x0f);
1246 UNW_DEC_GR_MEM(P6, mask, arg);
1248 UNW_DEC_FR_MEM(P6, mask, arg);
1252 static unsigned char *
1253 unw_decode_p7_p10 (unsigned char *dp, unsigned char code, void *arg)
1255 unsigned char r, byte1, byte2;
1258 if ((code & 0x10) == 0)
1261 t = unw_decode_uleb128 (&dp);
1265 size = unw_decode_uleb128 (&dp);
1266 UNW_DEC_MEM_STACK_F(P7, t, size, arg);
1269 case 1: UNW_DEC_MEM_STACK_V(P7, t, arg); break;
1270 case 2: UNW_DEC_SPILL_BASE(P7, t, arg); break;
1271 case 3: UNW_DEC_REG_SPREL(P7, UNW_REG_PSP, t, arg); break;
1272 case 4: UNW_DEC_REG_WHEN(P7, UNW_REG_RP, t, arg); break;
1273 case 5: UNW_DEC_REG_PSPREL(P7, UNW_REG_RP, t, arg); break;
1274 case 6: UNW_DEC_REG_WHEN(P7, UNW_REG_PFS, t, arg); break;
1275 case 7: UNW_DEC_REG_PSPREL(P7, UNW_REG_PFS, t, arg); break;
1276 case 8: UNW_DEC_REG_WHEN(P7, UNW_REG_PR, t, arg); break;
1277 case 9: UNW_DEC_REG_PSPREL(P7, UNW_REG_PR, t, arg); break;
1278 case 10: UNW_DEC_REG_WHEN(P7, UNW_REG_LC, t, arg); break;
1279 case 11: UNW_DEC_REG_PSPREL(P7, UNW_REG_LC, t, arg); break;
1280 case 12: UNW_DEC_REG_WHEN(P7, UNW_REG_UNAT, t, arg); break;
1281 case 13: UNW_DEC_REG_PSPREL(P7, UNW_REG_UNAT, t, arg); break;
1282 case 14: UNW_DEC_REG_WHEN(P7, UNW_REG_FPSR, t, arg); break;
1283 case 15: UNW_DEC_REG_PSPREL(P7, UNW_REG_FPSR, t, arg); break;
1284 default: UNW_DEC_BAD_CODE(r); break;
1294 t = unw_decode_uleb128 (&dp);
1297 case 1: UNW_DEC_REG_SPREL(P8, UNW_REG_RP, t, arg); break;
1298 case 2: UNW_DEC_REG_SPREL(P8, UNW_REG_PFS, t, arg); break;
1299 case 3: UNW_DEC_REG_SPREL(P8, UNW_REG_PR, t, arg); break;
1300 case 4: UNW_DEC_REG_SPREL(P8, UNW_REG_LC, t, arg); break;
1301 case 5: UNW_DEC_REG_SPREL(P8, UNW_REG_UNAT, t, arg); break;
1302 case 6: UNW_DEC_REG_SPREL(P8, UNW_REG_FPSR, t, arg); break;
1303 case 7: UNW_DEC_REG_WHEN(P8, UNW_REG_BSP, t, arg); break;
1304 case 8: UNW_DEC_REG_PSPREL(P8, UNW_REG_BSP, t, arg); break;
1305 case 9: UNW_DEC_REG_SPREL(P8, UNW_REG_BSP, t, arg); break;
1306 case 10: UNW_DEC_REG_WHEN(P8, UNW_REG_BSPSTORE, t, arg); break;
1307 case 11: UNW_DEC_REG_PSPREL(P8, UNW_REG_BSPSTORE, t, arg); break;
1308 case 12: UNW_DEC_REG_SPREL(P8, UNW_REG_BSPSTORE, t, arg); break;
1309 case 13: UNW_DEC_REG_WHEN(P8, UNW_REG_RNAT, t, arg); break;
1310 case 14: UNW_DEC_REG_PSPREL(P8, UNW_REG_RNAT, t, arg); break;
1311 case 15: UNW_DEC_REG_SPREL(P8, UNW_REG_RNAT, t, arg); break;
1312 case 16: UNW_DEC_PRIUNAT_WHEN_GR(P8, t, arg); break;
1313 case 17: UNW_DEC_PRIUNAT_PSPREL(P8, t, arg); break;
1314 case 18: UNW_DEC_PRIUNAT_SPREL(P8, t, arg); break;
1315 case 19: UNW_DEC_PRIUNAT_WHEN_MEM(P8, t, arg); break;
1316 default: UNW_DEC_BAD_CODE(r); break;
1322 byte1 = *dp++; byte2 = *dp++;
1323 UNW_DEC_GR_GR(P9, (byte1 & 0xf), (byte2 & 0x7f), arg);
1327 byte1 = *dp++; byte2 = *dp++;
1328 UNW_DEC_ABI(P10, byte1, byte2, arg);
1332 return unw_decode_x1 (dp, code, arg);
1335 return unw_decode_x2 (dp, code, arg);
1338 return unw_decode_x3 (dp, code, arg);
1341 return unw_decode_x4 (dp, code, arg);
1344 UNW_DEC_BAD_CODE(code);
1351 static unsigned char *
1352 unw_decode_b1 (unsigned char *dp, unsigned char code, void *arg)
1354 unw_word label = (code & 0x1f);
1356 if ((code & 0x20) != 0)
1357 UNW_DEC_COPY_STATE(B1, label, arg);
1359 UNW_DEC_LABEL_STATE(B1, label, arg);
1363 static unsigned char *
1364 unw_decode_b2 (unsigned char *dp, unsigned char code, void *arg)
1368 t = unw_decode_uleb128 (&dp);
1369 UNW_DEC_EPILOGUE(B2, t, (code & 0x1f), arg);
1373 static unsigned char *
1374 unw_decode_b3_x4 (unsigned char *dp, unsigned char code, void *arg)
1376 unw_word t, ecount, label;
1378 if ((code & 0x10) == 0)
1380 t = unw_decode_uleb128 (&dp);
1381 ecount = unw_decode_uleb128 (&dp);
1382 UNW_DEC_EPILOGUE(B3, t, ecount, arg);
1384 else if ((code & 0x07) == 0)
1386 label = unw_decode_uleb128 (&dp);
1387 if ((code & 0x08) != 0)
1388 UNW_DEC_COPY_STATE(B4, label, arg);
1390 UNW_DEC_LABEL_STATE(B4, label, arg);
1395 case 1: return unw_decode_x1 (dp, code, arg);
1396 case 2: return unw_decode_x2 (dp, code, arg);
1397 case 3: return unw_decode_x3 (dp, code, arg);
1398 case 4: return unw_decode_x4 (dp, code, arg);
1399 default: UNW_DEC_BAD_CODE(code); break;
1404 typedef unsigned char *(*unw_decoder) (unsigned char *, unsigned char, void *);
1406 static const unw_decoder unw_decode_table[2][8] =
1408 /* prologue table: */
1410 unw_decode_r1, /* 0 */
1414 unw_decode_p1, /* 4 */
1420 unw_decode_r1, /* 0 */
1424 unw_decode_b1, /* 4 */
1432 * Decode one descriptor and return address of next descriptor.
1434 static inline unsigned char *
1435 unw_decode (unsigned char *dp, int inside_body, void *arg)
1437 unw_decoder decoder;
1441 decoder = unw_decode_table[inside_body][code >> 5];
1442 dp = (*decoder) (dp, code, arg);
1447 /* RSE helper functions. */
1449 static inline unsigned long
1450 ia64_rse_slot_num (unsigned long *addr)
1452 return (((unsigned long) addr) >> 3) & 0x3f;
1455 /* Return TRUE if ADDR is the address of an RNAT slot. */
1456 static inline unsigned long
1457 ia64_rse_is_rnat_slot (unsigned long *addr)
1459 return ia64_rse_slot_num (addr) == 0x3f;
1462 /* Returns the address of the RNAT slot that covers the slot at
1463 address SLOT_ADDR. */
1464 static inline unsigned long *
1465 ia64_rse_rnat_addr (unsigned long *slot_addr)
1467 return (unsigned long *) ((unsigned long) slot_addr | (0x3f << 3));
1470 /* Calculate the number of registers in the dirty partition starting at
1471 BSPSTORE with a size of DIRTY bytes. This isn't simply DIRTY
1472 divided by eight because the 64th slot is used to store ar.rnat. */
1473 static inline unsigned long
1474 ia64_rse_num_regs (unsigned long *bspstore, unsigned long *bsp)
1476 unsigned long slots = (bsp - bspstore);
1478 return slots - (ia64_rse_slot_num (bspstore) + slots)/0x40;
1481 /* The inverse of the above: given bspstore and the number of
1482 registers, calculate ar.bsp. */
1483 static inline unsigned long *
1484 ia64_rse_skip_regs (unsigned long *addr, long num_regs)
1486 long delta = ia64_rse_slot_num (addr) + num_regs;
1490 return addr + num_regs + delta/0x3f;
1494 /* Unwind accessors. */
1497 unw_access_gr (struct _Unwind_Context *info, int regnum,
1498 unsigned long *val, char *nat, int write)
1500 unsigned long *addr, *nat_addr = 0, nat_mask = 0, dummy_nat;
1501 struct unw_ireg *ireg;
1503 if ((unsigned) regnum - 1 >= 127)
1508 nat_addr = addr = &dummy_nat;
1511 else if (regnum < 32)
1513 /* Access a non-stacked register. */
1514 ireg = &info->ireg[regnum - 2];
1518 nat_addr = addr + ireg->nat.off;
1519 switch (ireg->nat.type)
1522 /* Simulate getf.sig/setf.sig. */
1527 /* Write NaTVal and be done with it. */
1534 else if (addr[0] == 0 && addr[1] == 0x1ffe)
1536 /* Return NaT and be done with it. */
1545 nat_addr = &dummy_nat;
1548 case UNW_NAT_MEMSTK:
1549 nat_mask = 1UL << ((long) addr & 0x1f8)/8;
1552 case UNW_NAT_REGSTK:
1553 nat_addr = ia64_rse_rnat_addr (addr);
1554 if ((unsigned long) nat_addr >= info->regstk_top)
1555 nat_addr = &info->rnat;
1556 nat_mask = 1UL << ia64_rse_slot_num (addr);
1563 /* Access a stacked register. */
1564 addr = ia64_rse_skip_regs ((unsigned long *) info->bsp, regnum - 32);
1565 nat_addr = ia64_rse_rnat_addr (addr);
1566 if ((unsigned long) nat_addr >= info->regstk_top)
1567 nat_addr = &info->rnat;
1568 nat_mask = 1UL << ia64_rse_slot_num (addr);
1575 *nat_addr |= nat_mask;
1577 *nat_addr &= ~nat_mask;
1582 *nat = (*nat_addr & nat_mask) != 0;
1586 /* Get the value of register REG as saved in CONTEXT. */
1589 _Unwind_GetGR (struct _Unwind_Context *context, int index)
1596 else if (index >= 15 && index <= 18)
1597 return context->eh_data[index - 15];
1599 unw_access_gr (context, index, &ret, &nat, 0);
1604 /* Overwrite the saved value for register REG in CONTEXT with VAL. */
1607 _Unwind_SetGR (struct _Unwind_Context *context, int index, _Unwind_Word val)
1613 else if (index >= 15 && index <= 18)
1614 context->eh_data[index - 15] = val;
1616 unw_access_gr (context, index, &val, &nat, 1);
1619 /* Retrieve the return address for CONTEXT. */
1622 _Unwind_GetIP (struct _Unwind_Context *context)
1627 /* Overwrite the return address for CONTEXT with VAL. */
1630 _Unwind_SetIP (struct _Unwind_Context *context, _Unwind_Ptr val)
1636 _Unwind_GetLanguageSpecificData (struct _Unwind_Context *context)
1638 return context->lsda;
1642 _Unwind_GetRegionStart (struct _Unwind_Context *context)
1644 return context->region_start;
1648 _Unwind_FindEnclosingFunction (void *pc)
1654 static _Unwind_Reason_Code
1655 uw_frame_state_for (struct _Unwind_Context *context, _Unwind_FrameState *fs)
1657 struct unw_table_entry *ent;
1658 unsigned long *unw, header, length;
1659 unsigned char *insn, *insn_end;
1660 unsigned long segment_base;
1661 struct unw_reg_info *r;
1663 memset (fs, 0, sizeof (*fs));
1664 for (r = fs->curr.reg; r < fs->curr.reg + UNW_NUM_REGS; ++r)
1665 r->when = UNW_WHEN_NEVER;
1668 ent = _Unwind_FindTableEntry ((void *) context->rp,
1669 &segment_base, &context->gp);
1672 /* Couldn't find unwind info for this function. Try an
1673 os-specific fallback mechanism. This will necessarily
1674 not provide a personality routine or LSDA. */
1675 #ifdef MD_FALLBACK_FRAME_STATE_FOR
1676 MD_FALLBACK_FRAME_STATE_FOR (context, fs, success);
1678 /* [SCRA 11.4.1] A leaf function with no memory stack, no exception
1679 handlers, and which keeps the return value in B0 does not need
1680 an unwind table entry.
1682 This can only happen in the frame after unwinding through a signal
1683 handler. Avoid infinite looping by requiring that B0 != RP. */
1684 if (context->br_loc[0] && *context->br_loc[0] != context->rp)
1686 fs->curr.reg[UNW_REG_RP].where = UNW_WHERE_BR;
1687 fs->curr.reg[UNW_REG_RP].when = -1;
1688 fs->curr.reg[UNW_REG_RP].val = 0;
1692 return _URC_END_OF_STACK;
1694 return _URC_NO_REASON;
1696 return _URC_END_OF_STACK;
1700 context->region_start = ent->start_offset + segment_base;
1701 fs->when_target = (context->rp - context->region_start) / 16 * 3;
1703 unw = (unsigned long *) (ent->info_offset + segment_base);
1705 length = UNW_LENGTH (header);
1707 /* ??? Perhaps check UNW_VER / UNW_FLAG_OSMASK. */
1709 if (UNW_FLAG_EHANDLER (header) | UNW_FLAG_UHANDLER (header))
1712 *(_Unwind_Personality_Fn *) (unw[length + 1] + context->gp);
1713 context->lsda = unw + length + 2;
1716 insn = (unsigned char *) (unw + 1);
1717 insn_end = (unsigned char *) (unw + 1 + length);
1718 while (!fs->done && insn < insn_end)
1719 insn = unw_decode (insn, fs->in_body, fs);
1721 free_label_states (fs->labeled_states);
1722 free_state_stack (&fs->curr);
1724 #ifdef ENABLE_MALLOC_CHECKING
1725 if (reg_state_alloced || labeled_state_alloced)
1729 /* If we're in the epilogue, sp has been restored and all values
1730 on the memory stack below psp also have been restored. */
1731 if (fs->when_target > fs->epilogue_start)
1733 struct unw_reg_info *r;
1735 fs->curr.reg[UNW_REG_PSP].where = UNW_WHERE_NONE;
1736 fs->curr.reg[UNW_REG_PSP].val = 0;
1737 for (r = fs->curr.reg; r < fs->curr.reg + UNW_NUM_REGS; ++r)
1738 if ((r->where == UNW_WHERE_PSPREL && r->val <= 0x10)
1739 || r->where == UNW_WHERE_SPREL)
1740 r->where = UNW_WHERE_NONE;
1743 /* If RP did't get saved, generate entry for the return link register. */
1744 if (fs->curr.reg[UNW_REG_RP].when >= fs->when_target)
1746 fs->curr.reg[UNW_REG_RP].where = UNW_WHERE_BR;
1747 fs->curr.reg[UNW_REG_RP].when = -1;
1748 fs->curr.reg[UNW_REG_RP].val = fs->return_link_reg;
1751 return _URC_NO_REASON;
1755 uw_update_reg_address (struct _Unwind_Context *context,
1756 _Unwind_FrameState *fs,
1757 enum unw_register_index regno)
1759 struct unw_reg_info *r = fs->curr.reg + regno;
1763 if (r->where == UNW_WHERE_NONE || r->when >= fs->when_target)
1771 addr = ia64_rse_skip_regs ((unsigned long *) context->bsp, rval - 32);
1773 addr = context->ireg[rval - 2].loc;
1779 if (rval >= 2 && rval < 32)
1780 addr = context->fr_loc[rval - 2];
1786 /* Note that while RVAL can only be 1-5 from normal descriptors,
1787 we can want to look at B0 due to having manually unwound a
1790 addr = context->br_loc[rval];
1795 case UNW_WHERE_SPREL:
1796 addr = (void *)(context->sp + rval);
1799 case UNW_WHERE_PSPREL:
1800 addr = (void *)(context->psp + rval);
1809 case UNW_REG_R2 ... UNW_REG_R31:
1810 context->ireg[regno - UNW_REG_R2].loc = addr;
1816 context->ireg[regno - UNW_REG_R2].nat.type = UNW_NAT_MEMSTK;
1817 context->ireg[regno - UNW_REG_R2].nat.off
1818 = context->pri_unat_loc - (unsigned long *) addr;
1822 context->ireg[regno - UNW_REG_R2].nat
1823 = context->ireg[rval - 2].nat;
1830 context->ireg[regno - UNW_REG_R2].nat.type = UNW_NAT_VAL;
1831 context->ireg[regno - UNW_REG_R2].nat.off = 0;
1835 context->ireg[regno - UNW_REG_R2].nat.type = UNW_NAT_NONE;
1836 context->ireg[regno - UNW_REG_R2].nat.off = 0;
1839 case UNW_WHERE_PSPREL:
1840 case UNW_WHERE_SPREL:
1841 context->ireg[regno - UNW_REG_R2].nat.type = UNW_NAT_MEMSTK;
1842 context->ireg[regno - UNW_REG_R2].nat.off
1843 = context->pri_unat_loc - (unsigned long *) addr;
1851 case UNW_REG_F2 ... UNW_REG_F31:
1852 context->fr_loc[regno - UNW_REG_F2] = addr;
1855 case UNW_REG_B1 ... UNW_REG_B5:
1856 context->br_loc[regno - UNW_REG_B0] = addr;
1860 context->bsp_loc = addr;
1862 case UNW_REG_BSPSTORE:
1863 context->bspstore_loc = addr;
1866 context->pfs_loc = addr;
1869 context->rp = *(unsigned long *)addr;
1872 context->unat_loc = addr;
1875 context->pr = *(unsigned long *) addr;
1878 context->lc_loc = addr;
1881 context->fpsr_loc = addr;
1885 context->psp = *(unsigned long *)addr;
1894 uw_update_context (struct _Unwind_Context *context, _Unwind_FrameState *fs)
1898 context->sp = context->psp;
1900 /* First, set PSP. Subsequent instructions may depend on this value. */
1901 if (fs->when_target > fs->curr.reg[UNW_REG_PSP].when)
1903 if (fs->curr.reg[UNW_REG_PSP].where == UNW_WHERE_NONE)
1904 context->psp = context->psp + fs->curr.reg[UNW_REG_PSP].val;
1906 uw_update_reg_address (context, fs, UNW_REG_PSP);
1909 /* Determine the location of the primary UNaT. */
1912 if (fs->when_target < fs->curr.reg[UNW_REG_PRI_UNAT_GR].when)
1913 i = UNW_REG_PRI_UNAT_MEM;
1914 else if (fs->when_target < fs->curr.reg[UNW_REG_PRI_UNAT_MEM].when)
1915 i = UNW_REG_PRI_UNAT_GR;
1916 else if (fs->curr.reg[UNW_REG_PRI_UNAT_MEM].when
1917 > fs->curr.reg[UNW_REG_PRI_UNAT_GR].when)
1918 i = UNW_REG_PRI_UNAT_MEM;
1920 i = UNW_REG_PRI_UNAT_GR;
1921 uw_update_reg_address (context, fs, i);
1924 /* Compute the addresses of all registers saved in this frame. */
1925 for (i = UNW_REG_BSP; i < UNW_NUM_REGS; ++i)
1926 uw_update_reg_address (context, fs, i);
1928 /* Unwind BSP for the local registers allocated this frame. */
1929 /* ??? What to do with stored BSP or BSPSTORE registers. */
1930 /* We assert that we are either at a call site, or we have
1931 just unwound through a signal frame. In either case
1932 pfs_loc is valid. */
1933 if (!(fs -> no_reg_stack_frame))
1935 unsigned long pfs = *context->pfs_loc;
1936 unsigned long sol = (pfs >> 7) & 0x7f;
1937 context->bsp = (unsigned long)
1938 ia64_rse_skip_regs ((unsigned long *) context->bsp, -sol);
1942 /* Fill in CONTEXT for top-of-stack. The only valid registers at this
1943 level will be the return address and the CFA. Note that CFA = SP+16. */
1945 #define uw_init_context(CONTEXT) \
1947 /* ??? There is a whole lot o code in uw_install_context that \
1948 tries to avoid spilling the entire machine state here. We \
1949 should try to make that work again. */ \
1950 __builtin_unwind_init(); \
1951 uw_init_context_1 (CONTEXT, __builtin_ia64_bsp ()); \
1955 uw_init_context_1 (struct _Unwind_Context *context, void *bsp)
1957 void *rp = __builtin_extract_return_addr (__builtin_return_address (0));
1958 /* Set psp to the caller's stack pointer. */
1959 void *psp = __builtin_dwarf_cfa () - 16;
1960 _Unwind_FrameState fs;
1962 /* Flush the register stack to memory so that we can access it. */
1963 __builtin_ia64_flushrs ();
1965 memset (context, 0, sizeof (struct _Unwind_Context));
1966 context->bsp = context->regstk_top = (unsigned long) bsp;
1967 context->psp = (unsigned long) psp;
1968 context->rp = (unsigned long) rp;
1969 asm ("mov %0 = sp" : "=r" (context->sp));
1970 asm ("mov %0 = pr" : "=r" (context->pr));
1971 context->pri_unat_loc = &context->initial_unat; /* ??? */
1972 /* ??? Get rnat. Don't we have to turn off the rse for that? */
1974 if (uw_frame_state_for (context, &fs) != _URC_NO_REASON)
1977 uw_update_context (context, &fs);
1980 /* Install (ie longjmp to) the contents of TARGET. */
1982 static void __attribute__((noreturn))
1983 uw_install_context (struct _Unwind_Context *current __attribute__((unused)),
1984 struct _Unwind_Context *target)
1986 unsigned long ireg_buf[4], ireg_nat = 0, ireg_pr = 0;
1989 /* Copy integer register data from the target context to a
1990 temporary buffer. Do this so that we can frob AR.UNAT
1991 to get the NaT bits for these registers set properly. */
1992 for (i = 4; i <= 7; ++i)
1995 void *t = target->ireg[i - 2].loc;
1998 unw_access_gr (target, i, &ireg_buf[i - 4], &nat, 0);
1999 ireg_nat |= (long)nat << (((size_t)&ireg_buf[i - 4] >> 3) & 0x3f);
2005 /* The value in uc_bsp that we've computed is that for the
2006 target function. The value that we install below will be
2007 adjusted by the BR.RET instruction based on the contents
2008 of AR.PFS. So we must unadjust that here. */
2009 target->bsp = (unsigned long)
2010 ia64_rse_skip_regs ((unsigned long *)target->bsp,
2011 (*target->pfs_loc >> 7) & 0x7f);
2013 /* Provide assembly with the offsets into the _Unwind_Context. */
2014 asm volatile ("uc_rnat = %0"
2015 : : "i"(offsetof (struct _Unwind_Context, rnat)));
2016 asm volatile ("uc_bsp = %0"
2017 : : "i"(offsetof (struct _Unwind_Context, bsp)));
2018 asm volatile ("uc_psp = %0"
2019 : : "i"(offsetof (struct _Unwind_Context, psp)));
2020 asm volatile ("uc_rp = %0"
2021 : : "i"(offsetof (struct _Unwind_Context, rp)));
2022 asm volatile ("uc_pr = %0"
2023 : : "i"(offsetof (struct _Unwind_Context, pr)));
2024 asm volatile ("uc_gp = %0"
2025 : : "i"(offsetof (struct _Unwind_Context, gp)));
2026 asm volatile ("uc_pfs_loc = %0"
2027 : : "i"(offsetof (struct _Unwind_Context, pfs_loc)));
2028 asm volatile ("uc_unat_loc = %0"
2029 : : "i"(offsetof (struct _Unwind_Context, unat_loc)));
2030 asm volatile ("uc_lc_loc = %0"
2031 : : "i"(offsetof (struct _Unwind_Context, lc_loc)));
2032 asm volatile ("uc_fpsr_loc = %0"
2033 : : "i"(offsetof (struct _Unwind_Context, fpsr_loc)));
2034 asm volatile ("uc_eh_data = %0"
2035 : : "i"(offsetof (struct _Unwind_Context, eh_data)));
2036 asm volatile ("uc_br_loc = %0"
2037 : : "i"(offsetof (struct _Unwind_Context, br_loc)));
2038 asm volatile ("uc_fr_loc = %0"
2039 : : "i"(offsetof (struct _Unwind_Context, fr_loc)));
2042 /* Load up call-saved non-window integer registers from ireg_buf. */
2043 "add r20 = 8, %1 \n\t"
2044 "mov ar.unat = %2 \n\t"
2045 "mov pr = %3, 0x3c0 \n\t"
2047 "(p6) ld8.fill r4 = [%1] \n\t"
2048 "(p7) ld8.fill r5 = [r20] \n\t"
2049 "add r21 = uc_br_loc + 8, %0 \n\t"
2050 "adds %1 = 16, %1 \n\t"
2051 "adds r20 = 16, r20 \n\t"
2053 "(p8) ld8.fill r6 = [%1] \n\t"
2054 "(p9) ld8.fill r7 = [r20] \n\t"
2055 "add r20 = uc_br_loc, %0 \n\t"
2057 /* Load up call-saved branch registers. */
2058 "ld8 r22 = [r20], 16 \n\t"
2059 "ld8 r23 = [r21], 16 \n\t"
2061 "ld8 r24 = [r20], 16 \n\t"
2062 "ld8 r25 = [r21], uc_fr_loc - (uc_br_loc + 24)\n\t"
2064 "ld8 r26 = [r20], uc_fr_loc + 8 - (uc_br_loc + 32)\n\t"
2065 "ld8 r27 = [r21], 24 \n\t"
2066 "cmp.ne p6, p0 = r0, r22 \n\t"
2068 "ld8 r28 = [r20], 8 \n\t"
2069 "(p6) ld8 r22 = [r22] \n\t"
2070 "cmp.ne p7, p0 = r0, r23 \n\t"
2072 "(p7) ld8 r23 = [r23] \n\t"
2073 "cmp.ne p8, p0 = r0, r24 \n\t"
2075 "(p8) ld8 r24 = [r24] \n\t"
2076 "(p6) mov b1 = r22 \n\t"
2077 "cmp.ne p9, p0 = r0, r25 \n\t"
2079 "(p9) ld8 r25 = [r25] \n\t"
2080 "(p7) mov b2 = r23 \n\t"
2081 "cmp.ne p6, p0 = r0, r26 \n\t"
2083 "(p6) ld8 r26 = [r26] \n\t"
2084 "(p8) mov b3 = r24 \n\t"
2085 "cmp.ne p7, p0 = r0, r27 \n\t"
2087 /* Load up call-saved fp registers. */
2088 "(p7) ldf.fill f2 = [r27] \n\t"
2089 "(p9) mov b4 = r25 \n\t"
2090 "cmp.ne p8, p0 = r0, r28 \n\t"
2092 "(p8) ldf.fill f3 = [r28] \n\t"
2093 "(p6) mov b5 = r26 \n\t"
2095 "ld8 r29 = [r20], 16*8 - 4*8 \n\t"
2096 "ld8 r30 = [r21], 17*8 - 5*8 \n\t"
2098 "ld8 r22 = [r20], 16 \n\t"
2099 "ld8 r23 = [r21], 16 \n\t"
2101 "ld8 r24 = [r20], 16 \n\t"
2102 "ld8 r25 = [r21] \n\t"
2103 "cmp.ne p6, p0 = r0, r29 \n\t"
2105 "ld8 r26 = [r20], 8 \n\t"
2106 "(p6) ldf.fill f4 = [r29] \n\t"
2107 "cmp.ne p7, p0 = r0, r30 \n\t"
2109 "ld8 r27 = [r20], 8 \n\t"
2110 "(p7) ldf.fill f5 = [r30] \n\t"
2111 "cmp.ne p6, p0 = r0, r22 \n\t"
2113 "ld8 r28 = [r20], 8 \n\t"
2114 "(p6) ldf.fill f16 = [r22] \n\t"
2115 "cmp.ne p7, p0 = r0, r23 \n\t"
2117 "ld8 r29 = [r20], 8 \n\t"
2118 "(p7) ldf.fill f17 = [r23] \n\t"
2119 "cmp.ne p6, p0 = r0, r24 \n\t"
2121 "ld8 r22 = [r20], 8 \n\t"
2122 "(p6) ldf.fill f18 = [r24] \n\t"
2123 "cmp.ne p7, p0 = r0, r25 \n\t"
2125 "ld8 r23 = [r20], 8 \n\t"
2126 "(p7) ldf.fill f19 = [r25] \n\t"
2127 "cmp.ne p6, p0 = r0, r26 \n\t"
2129 "ld8 r24 = [r20], 8 \n\t"
2130 "(p6) ldf.fill f20 = [r26] \n\t"
2131 "cmp.ne p7, p0 = r0, r27 \n\t"
2133 "ld8 r25 = [r20], 8 \n\t"
2134 "(p7) ldf.fill f21 = [r27] \n\t"
2135 "cmp.ne p6, p0 = r0, r28 \n\t"
2137 "ld8 r26 = [r20], 8 \n\t"
2138 "(p6) ldf.fill f22 = [r28] \n\t"
2139 "cmp.ne p7, p0 = r0, r29 \n\t"
2141 "ld8 r28 = [r20], 8 \n\t"
2142 "(p7) ldf.fill f23 = [r29] \n\t"
2143 "cmp.ne p6, p0 = r0, r22 \n\t"
2145 "ld8 r29 = [r20], 8 \n\t"
2146 "(p6) ldf.fill f24 = [r22] \n\t"
2147 "cmp.ne p7, p0 = r0, r23 \n\t"
2149 "(p7) ldf.fill f25 = [r23] \n\t"
2150 "cmp.ne p6, p0 = r0, r24 \n\t"
2151 "cmp.ne p7, p0 = r0, r25 \n\t"
2153 "(p6) ldf.fill f26 = [r24] \n\t"
2154 "(p7) ldf.fill f27 = [r25] \n\t"
2155 "cmp.ne p6, p0 = r0, r26 \n\t"
2157 "(p6) ldf.fill f28 = [r26] \n\t"
2158 "cmp.ne p7, p0 = r0, r27 \n\t"
2159 "cmp.ne p6, p0 = r0, r28 \n\t"
2161 "(p7) ldf.fill f29 = [r27] \n\t"
2162 "(p6) ldf.fill f30 = [r28] \n\t"
2163 "cmp.ne p7, p0 = r0, r29 \n\t"
2165 "(p7) ldf.fill f31 = [r29] \n\t"
2166 "add r20 = uc_rnat, %0 \n\t"
2167 "add r21 = uc_bsp, %0 \n\t"
2169 /* Load the balance of the thread state from the context. */
2170 "ld8 r22 = [r20], uc_psp - uc_rnat \n\t"
2171 "ld8 r23 = [r21], uc_gp - uc_bsp \n\t"
2173 "ld8 r24 = [r20], uc_pfs_loc - uc_psp \n\t"
2174 "ld8 r1 = [r21], uc_rp - uc_gp \n\t"
2176 "ld8 r25 = [r20], uc_unat_loc - uc_pfs_loc\n\t"
2177 "ld8 r26 = [r21], uc_pr - uc_rp \n\t"
2179 "ld8 r27 = [r20], uc_lc_loc - uc_unat_loc\n\t"
2180 "ld8 r28 = [r21], uc_fpsr_loc - uc_pr \n\t"
2182 "ld8 r29 = [r20], uc_eh_data - uc_lc_loc\n\t"
2183 "ld8 r30 = [r21], uc_eh_data + 8 - uc_fpsr_loc\n\t"
2185 /* Load data for the exception handler. */
2186 "ld8 r15 = [r20], 16 \n\t"
2187 "ld8 r16 = [r21], 16 \n\t"
2189 "ld8 r17 = [r20] \n\t"
2190 "ld8 r18 = [r21] \n\t"
2192 /* Install the balance of the thread state loaded above. */
2193 "cmp.ne p6, p0 = r0, r25 \n\t"
2194 "cmp.ne p7, p0 = r0, r27 \n\t"
2196 "(p6) ld8 r25 = [r25] \n\t"
2197 "(p7) ld8 r27 = [r27] \n\t"
2199 "(p7) mov.m ar.unat = r27 \n\t"
2200 "(p6) mov.i ar.pfs = r25 \n\t"
2201 "cmp.ne p9, p0 = r0, r29 \n\t"
2203 "(p9) ld8 r29 = [r29] \n\t"
2204 "cmp.ne p6, p0 = r0, r30 \n\t"
2206 "(p6) ld8 r30 = [r30] \n\t"
2207 /* Don't clobber p6-p9, which are in use at present. */
2208 "mov pr = r28, ~0x3c0 \n\t"
2209 "(p9) mov.i ar.lc = r29 \n\t"
2211 "mov.m r25 = ar.rsc \n\t"
2212 "(p6) mov.i ar.fpsr = r30 \n\t"
2214 "and r25 = 0x1c, r25 \n\t"
2217 "mov.m ar.rsc = r25 \n\t"
2219 /* This must be done before setting AR.BSPSTORE, otherwise
2220 AR.BSP will be initialized with a random displacement
2221 below the value we want, based on the current number of
2222 dirty stacked registers. */
2226 "mov.m ar.bspstore = r23 \n\t"
2228 "or r25 = 0x3, r25 \n\t"
2229 "mov.m ar.rnat = r22 \n\t"
2231 "mov.m ar.rsc = r25 \n\t"
2233 "br.ret.sptk.few b0"
2234 : : "r"(target), "r"(ireg_buf), "r"(ireg_nat), "r"(ireg_pr)
2235 : "r15", "r16", "r17", "r18", "r20", "r21", "r22",
2236 "r23", "r24", "r25", "r26", "r27", "r28", "r29",
2242 static inline _Unwind_Ptr
2243 uw_identify_context (struct _Unwind_Context *context)
2245 return _Unwind_GetIP (context);
2248 #include "unwind.inc"