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, 2004, 2005, 2006
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>
8
9 This file is part of GCC.
10
11 GCC 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)
14 any later version.
15
16 GCC 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.
20
21 You should have received a copy of the GNU General Public License
22 along with GCC; see the file COPYING. If not, write to
23 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
24 Boston, MA 02110-1301, USA. */
25
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. */
32
33
34 #include "tconfig.h"
35 #include "tsystem.h"
36 #include "coretypes.h"
37 #include "tm.h"
38 #include "unwind.h"
39 #include "unwind-ia64.h"
40 #include "unwind-compat.h"
41 #include "ia64intrin.h"
42
43 /* This isn't thread safe, but nice for occasional tests. */
44 #undef ENABLE_MALLOC_CHECKING
45
46 #ifndef __USING_SJLJ_EXCEPTIONS__
47
48 #define UNW_VER(x) ((x) >> 48)
49 #define UNW_FLAG_MASK 0x0000ffff00000000
50 #define UNW_FLAG_OSMASK 0x0000f00000000000
51 #define UNW_FLAG_EHANDLER(x) ((x) & 0x0000000100000000L)
52 #define UNW_FLAG_UHANDLER(x) ((x) & 0x0000000200000000L)
53 #define UNW_LENGTH(x) ((x) & 0x00000000ffffffffL)
54
55 enum unw_application_register
56 {
57 UNW_AR_BSP,
58 UNW_AR_BSPSTORE,
59 UNW_AR_PFS,
60 UNW_AR_RNAT,
61 UNW_AR_UNAT,
62 UNW_AR_LC,
63 UNW_AR_EC,
64 UNW_AR_FPSR,
65 UNW_AR_RSC,
66 UNW_AR_CCV
67 };
68
69 enum unw_register_index
70 {
71 /* Primary UNAT. */
72 UNW_REG_PRI_UNAT_GR,
73 UNW_REG_PRI_UNAT_MEM,
74
75 /* Memory Stack. */
76 UNW_REG_PSP, /* previous memory stack pointer */
77
78 /* Register Stack. */
79 UNW_REG_BSP, /* register stack pointer */
80 UNW_REG_BSPSTORE,
81 UNW_REG_PFS, /* previous function state */
82 UNW_REG_RNAT,
83 /* Return Pointer. */
84 UNW_REG_RP,
85
86 /* Special preserved registers. */
87 UNW_REG_UNAT, UNW_REG_PR, UNW_REG_LC, UNW_REG_FPSR,
88
89 /* Non-stacked general registers. */
90 UNW_REG_R2,
91 UNW_REG_R4 = UNW_REG_R2 + 2,
92 UNW_REG_R7 = UNW_REG_R2 + 5,
93 UNW_REG_R31 = UNW_REG_R2 + 29,
94
95 /* Non-stacked floating point registers. */
96 UNW_REG_F2,
97 UNW_REG_F5 = UNW_REG_F2 + 3,
98 UNW_REG_F16 = UNW_REG_F2 + 14,
99 UNW_REG_F31 = UNW_REG_F2 + 29,
100
101 /* Branch registers. */
102 UNW_REG_B0, UNW_REG_B1,
103 UNW_REG_B5 = UNW_REG_B1 + 4,
104
105 UNW_NUM_REGS
106 };
107
108 enum unw_where
109 {
110 UNW_WHERE_NONE, /* register isn't saved at all */
111 UNW_WHERE_GR, /* register is saved in a general register */
112 UNW_WHERE_FR, /* register is saved in a floating-point register */
113 UNW_WHERE_BR, /* register is saved in a branch register */
114 UNW_WHERE_SPREL, /* register is saved on memstack (sp-relative) */
115 UNW_WHERE_PSPREL, /* register is saved on memstack (psp-relative) */
116
117 /* At the end of each prologue these locations get resolved to
118 UNW_WHERE_PSPREL and UNW_WHERE_GR, respectively. */
119 UNW_WHERE_SPILL_HOME, /* register is saved in its spill home */
120 UNW_WHERE_GR_SAVE /* register is saved in next general register */
121 };
122
123 #define UNW_WHEN_NEVER 0x7fffffff
124
125 struct unw_reg_info
126 {
127 unsigned long val; /* save location: register number or offset */
128 enum unw_where where; /* where the register gets saved */
129 int when; /* when the register gets saved */
130 };
131
132 struct unw_reg_state {
133 struct unw_reg_state *next; /* next (outer) element on state stack */
134 struct unw_reg_info reg[UNW_NUM_REGS]; /* register save locations */
135 };
136
137 struct unw_labeled_state {
138 struct unw_labeled_state *next; /* next labeled state (or NULL) */
139 unsigned long label; /* label for this state */
140 struct unw_reg_state saved_state;
141 };
142
143 typedef struct unw_state_record
144 {
145 unsigned int first_region : 1; /* is this the first region? */
146 unsigned int done : 1; /* are we done scanning descriptors? */
147 unsigned int any_spills : 1; /* got any register spills? */
148 unsigned int in_body : 1; /* are we inside a body? */
149 unsigned int no_reg_stack_frame : 1; /* Don't adjust bsp for i&l regs */
150 unsigned char *imask; /* imask of spill_mask record or NULL */
151 unsigned long pr_val; /* predicate values */
152 unsigned long pr_mask; /* predicate mask */
153 long spill_offset; /* psp-relative offset for spill base */
154 int region_start;
155 int region_len;
156 int epilogue_start;
157 int epilogue_count;
158 int when_target;
159
160 unsigned char gr_save_loc; /* next general register to use for saving */
161 unsigned char return_link_reg; /* branch register for return link */
162 unsigned short unwabi;
163
164 struct unw_labeled_state *labeled_states; /* list of all labeled states */
165 struct unw_reg_state curr; /* current state */
166
167 _Unwind_Personality_Fn personality;
168
169 } _Unwind_FrameState;
170
171 enum unw_nat_type
172 {
173 UNW_NAT_NONE, /* NaT not represented */
174 UNW_NAT_VAL, /* NaT represented by NaT value (fp reg) */
175 UNW_NAT_MEMSTK, /* NaT value is in unat word at offset OFF */
176 UNW_NAT_REGSTK /* NaT is in rnat */
177 };
178
179 struct unw_stack
180 {
181 unsigned long limit;
182 unsigned long top;
183 };
184
185 struct _Unwind_Context
186 {
187 /* Initial frame info. */
188 unsigned long rnat; /* rse nat collection */
189 unsigned long regstk_top; /* lowest address of rbs stored register
190 which uses context->rnat collection */
191
192 /* Current frame info. */
193 unsigned long bsp; /* backing store pointer value
194 corresponding to psp. */
195 unsigned long sp; /* stack pointer value */
196 unsigned long psp; /* previous sp value */
197 unsigned long rp; /* return pointer */
198 unsigned long pr; /* predicate collection */
199
200 unsigned long region_start; /* start of unwind region */
201 unsigned long gp; /* global pointer value */
202 void *lsda; /* language specific data area */
203
204 /* Preserved state. */
205 unsigned long *bsp_loc; /* previous bsp save location
206 Appears to be write-only? */
207 unsigned long *bspstore_loc;
208 unsigned long *pfs_loc; /* Save location for pfs in current
209 (corr. to sp) frame. Target
210 contains cfm for caller. */
211 unsigned long *pri_unat_loc;
212 unsigned long *unat_loc;
213 unsigned long *lc_loc;
214 unsigned long *fpsr_loc;
215
216 unsigned long eh_data[4];
217
218 struct unw_ireg
219 {
220 unsigned long *loc;
221 struct unw_ireg_nat
222 {
223 enum unw_nat_type type : 3;
224 signed long off : 61; /* NaT word is at loc+nat.off */
225 } nat;
226 } ireg[32 - 2]; /* Indexed by <register number> - 2 */
227
228 unsigned long *br_loc[8];
229 void *fr_loc[32 - 2];
230
231 /* ??? We initially point pri_unat_loc here. The entire NAT bit
232 logic needs work. */
233 unsigned long initial_unat;
234 };
235
236 typedef unsigned long unw_word;
237
238 /* Implicit register save order. See section 11.4.2.3 Rules for Using
239 Unwind Descriptors, rule 3. */
240
241 static unsigned char const save_order[] =
242 {
243 UNW_REG_RP, UNW_REG_PFS, UNW_REG_PSP, UNW_REG_PR,
244 UNW_REG_UNAT, UNW_REG_LC, UNW_REG_FPSR, UNW_REG_PRI_UNAT_GR
245 };
246
247
248 #define MIN(X, Y) ((X) < (Y) ? (X) : (Y))
249
250 /* MASK is a bitmap describing the allocation state of emergency buffers,
251 with bit set indicating free. Return >= 0 if allocation is successful;
252 < 0 if failure. */
253
254 static inline int
atomic_alloc(unsigned int * mask)255 atomic_alloc (unsigned int *mask)
256 {
257 unsigned int old = *mask, ret, new;
258
259 while (1)
260 {
261 if (old == 0)
262 return -1;
263 ret = old & -old;
264 new = old & ~ret;
265 new = __sync_val_compare_and_swap (mask, old, new);
266 if (old == new)
267 break;
268 old = new;
269 }
270
271 return __builtin_ffs (ret) - 1;
272 }
273
274 /* Similarly, free an emergency buffer. */
275
276 static inline void
atomic_free(unsigned int * mask,int bit)277 atomic_free (unsigned int *mask, int bit)
278 {
279 __sync_xor_and_fetch (mask, 1 << bit);
280 }
281
282
283 #define SIZE(X) (sizeof(X) / sizeof(*(X)))
284 #define MASK_FOR(X) ((2U << (SIZE (X) - 1)) - 1)
285 #define PTR_IN(X, P) ((P) >= (X) && (P) < (X) + SIZE (X))
286
287 static struct unw_reg_state emergency_reg_state[32];
288 static unsigned int emergency_reg_state_free = MASK_FOR (emergency_reg_state);
289
290 static struct unw_labeled_state emergency_labeled_state[8];
291 static unsigned int emergency_labeled_state_free = MASK_FOR (emergency_labeled_state);
292
293 #ifdef ENABLE_MALLOC_CHECKING
294 static int reg_state_alloced;
295 static int labeled_state_alloced;
296 #endif
297
298 /* Allocation and deallocation of structures. */
299
300 static struct unw_reg_state *
alloc_reg_state(void)301 alloc_reg_state (void)
302 {
303 struct unw_reg_state *rs;
304
305 #ifdef ENABLE_MALLOC_CHECKING
306 reg_state_alloced++;
307 #endif
308
309 rs = malloc (sizeof (struct unw_reg_state));
310 if (!rs)
311 {
312 int n = atomic_alloc (&emergency_reg_state_free);
313 if (n >= 0)
314 rs = &emergency_reg_state[n];
315 }
316
317 return rs;
318 }
319
320 static void
free_reg_state(struct unw_reg_state * rs)321 free_reg_state (struct unw_reg_state *rs)
322 {
323 #ifdef ENABLE_MALLOC_CHECKING
324 reg_state_alloced--;
325 #endif
326
327 if (PTR_IN (emergency_reg_state, rs))
328 atomic_free (&emergency_reg_state_free, rs - emergency_reg_state);
329 else
330 free (rs);
331 }
332
333 static struct unw_labeled_state *
alloc_label_state(void)334 alloc_label_state (void)
335 {
336 struct unw_labeled_state *ls;
337
338 #ifdef ENABLE_MALLOC_CHECKING
339 labeled_state_alloced++;
340 #endif
341
342 ls = malloc(sizeof(struct unw_labeled_state));
343 if (!ls)
344 {
345 int n = atomic_alloc (&emergency_labeled_state_free);
346 if (n >= 0)
347 ls = &emergency_labeled_state[n];
348 }
349
350 return ls;
351 }
352
353 static void
free_label_state(struct unw_labeled_state * ls)354 free_label_state (struct unw_labeled_state *ls)
355 {
356 #ifdef ENABLE_MALLOC_CHECKING
357 labeled_state_alloced--;
358 #endif
359
360 if (PTR_IN (emergency_labeled_state, ls))
361 atomic_free (&emergency_labeled_state_free, emergency_labeled_state - ls);
362 else
363 free (ls);
364 }
365
366 /* Routines to manipulate the state stack. */
367
368 static void
push(struct unw_state_record * sr)369 push (struct unw_state_record *sr)
370 {
371 struct unw_reg_state *rs = alloc_reg_state ();
372 memcpy (rs, &sr->curr, sizeof (*rs));
373 sr->curr.next = rs;
374 }
375
376 static void
pop(struct unw_state_record * sr)377 pop (struct unw_state_record *sr)
378 {
379 struct unw_reg_state *rs = sr->curr.next;
380
381 if (!rs)
382 abort ();
383 memcpy (&sr->curr, rs, sizeof(*rs));
384 free_reg_state (rs);
385 }
386
387 /* Make a copy of the state stack. Non-recursive to avoid stack overflows. */
388
389 static struct unw_reg_state *
dup_state_stack(struct unw_reg_state * rs)390 dup_state_stack (struct unw_reg_state *rs)
391 {
392 struct unw_reg_state *copy, *prev = NULL, *first = NULL;
393
394 while (rs)
395 {
396 copy = alloc_reg_state ();
397 memcpy (copy, rs, sizeof(*copy));
398 if (first)
399 prev->next = copy;
400 else
401 first = copy;
402 rs = rs->next;
403 prev = copy;
404 }
405
406 return first;
407 }
408
409 /* Free all stacked register states (but not RS itself). */
410 static void
free_state_stack(struct unw_reg_state * rs)411 free_state_stack (struct unw_reg_state *rs)
412 {
413 struct unw_reg_state *p, *next;
414
415 for (p = rs->next; p != NULL; p = next)
416 {
417 next = p->next;
418 free_reg_state (p);
419 }
420 rs->next = NULL;
421 }
422
423 /* Free all labeled states. */
424
425 static void
free_label_states(struct unw_labeled_state * ls)426 free_label_states (struct unw_labeled_state *ls)
427 {
428 struct unw_labeled_state *next;
429
430 for (; ls ; ls = next)
431 {
432 next = ls->next;
433
434 free_state_stack (&ls->saved_state);
435 free_label_state (ls);
436 }
437 }
438
439 /* Unwind decoder routines */
440
441 static enum unw_register_index __attribute__((const))
decode_abreg(unsigned char abreg,int memory)442 decode_abreg (unsigned char abreg, int memory)
443 {
444 switch (abreg)
445 {
446 case 0x04 ... 0x07: return UNW_REG_R4 + (abreg - 0x04);
447 case 0x22 ... 0x25: return UNW_REG_F2 + (abreg - 0x22);
448 case 0x30 ... 0x3f: return UNW_REG_F16 + (abreg - 0x30);
449 case 0x41 ... 0x45: return UNW_REG_B1 + (abreg - 0x41);
450 case 0x60: return UNW_REG_PR;
451 case 0x61: return UNW_REG_PSP;
452 case 0x62: return memory ? UNW_REG_PRI_UNAT_MEM : UNW_REG_PRI_UNAT_GR;
453 case 0x63: return UNW_REG_RP;
454 case 0x64: return UNW_REG_BSP;
455 case 0x65: return UNW_REG_BSPSTORE;
456 case 0x66: return UNW_REG_RNAT;
457 case 0x67: return UNW_REG_UNAT;
458 case 0x68: return UNW_REG_FPSR;
459 case 0x69: return UNW_REG_PFS;
460 case 0x6a: return UNW_REG_LC;
461 default:
462 abort ();
463 }
464 }
465
466 static void
set_reg(struct unw_reg_info * reg,enum unw_where where,int when,unsigned long val)467 set_reg (struct unw_reg_info *reg, enum unw_where where,
468 int when, unsigned long val)
469 {
470 reg->val = val;
471 reg->where = where;
472 if (reg->when == UNW_WHEN_NEVER)
473 reg->when = when;
474 }
475
476 static void
alloc_spill_area(unsigned long * offp,unsigned long regsize,struct unw_reg_info * lo,struct unw_reg_info * hi)477 alloc_spill_area (unsigned long *offp, unsigned long regsize,
478 struct unw_reg_info *lo, struct unw_reg_info *hi)
479 {
480 struct unw_reg_info *reg;
481
482 for (reg = hi; reg >= lo; --reg)
483 {
484 if (reg->where == UNW_WHERE_SPILL_HOME)
485 {
486 reg->where = UNW_WHERE_PSPREL;
487 *offp -= regsize;
488 reg->val = *offp;
489 }
490 }
491 }
492
493 static inline void
spill_next_when(struct unw_reg_info ** regp,struct unw_reg_info * lim,unw_word t)494 spill_next_when (struct unw_reg_info **regp, struct unw_reg_info *lim,
495 unw_word t)
496 {
497 struct unw_reg_info *reg;
498
499 for (reg = *regp; reg <= lim; ++reg)
500 {
501 if (reg->where == UNW_WHERE_SPILL_HOME)
502 {
503 reg->when = t;
504 *regp = reg + 1;
505 return;
506 }
507 }
508 /* Excess spill. */
509 abort ();
510 }
511
512 static void
finish_prologue(struct unw_state_record * sr)513 finish_prologue (struct unw_state_record *sr)
514 {
515 struct unw_reg_info *reg;
516 unsigned long off;
517 int i;
518
519 /* First, resolve implicit register save locations
520 (see Section "11.4.2.3 Rules for Using Unwind Descriptors", rule 3). */
521
522 for (i = 0; i < (int) sizeof (save_order); ++i)
523 {
524 reg = sr->curr.reg + save_order[i];
525 if (reg->where == UNW_WHERE_GR_SAVE)
526 {
527 reg->where = UNW_WHERE_GR;
528 reg->val = sr->gr_save_loc++;
529 }
530 }
531
532 /* Next, compute when the fp, general, and branch registers get saved.
533 This must come before alloc_spill_area() because we need to know
534 which registers are spilled to their home locations. */
535 if (sr->imask)
536 {
537 static unsigned char const limit[3] = {
538 UNW_REG_F31, UNW_REG_R7, UNW_REG_B5
539 };
540
541 unsigned char kind, mask = 0, *cp = sr->imask;
542 int t;
543 struct unw_reg_info *(regs[3]);
544
545 regs[0] = sr->curr.reg + UNW_REG_F2;
546 regs[1] = sr->curr.reg + UNW_REG_R4;
547 regs[2] = sr->curr.reg + UNW_REG_B1;
548
549 for (t = 0; t < sr->region_len; ++t)
550 {
551 if ((t & 3) == 0)
552 mask = *cp++;
553 kind = (mask >> 2*(3-(t & 3))) & 3;
554 if (kind > 0)
555 spill_next_when (®s[kind - 1], sr->curr.reg + limit[kind - 1],
556 sr->region_start + t);
557 }
558 }
559
560 /* Next, lay out the memory stack spill area. */
561 if (sr->any_spills)
562 {
563 off = sr->spill_offset;
564 alloc_spill_area (&off, 16, sr->curr.reg + UNW_REG_F2,
565 sr->curr.reg + UNW_REG_F31);
566 alloc_spill_area (&off, 8, sr->curr.reg + UNW_REG_B1,
567 sr->curr.reg + UNW_REG_B5);
568 alloc_spill_area (&off, 8, sr->curr.reg + UNW_REG_R4,
569 sr->curr.reg + UNW_REG_R7);
570 }
571 }
572
573 /*
574 * Region header descriptors.
575 */
576
577 static void
desc_prologue(int body,unw_word rlen,unsigned char mask,unsigned char grsave,struct unw_state_record * sr)578 desc_prologue (int body, unw_word rlen, unsigned char mask,
579 unsigned char grsave, struct unw_state_record *sr)
580 {
581 int i;
582
583 if (!(sr->in_body || sr->first_region))
584 finish_prologue (sr);
585 sr->first_region = 0;
586
587 /* Check if we're done. */
588 if (sr->when_target < sr->region_start + sr->region_len)
589 {
590 sr->done = 1;
591 return;
592 }
593
594 for (i = 0; i < sr->epilogue_count; ++i)
595 pop (sr);
596
597 sr->epilogue_count = 0;
598 sr->epilogue_start = UNW_WHEN_NEVER;
599
600 if (!body)
601 push (sr);
602
603 sr->region_start += sr->region_len;
604 sr->region_len = rlen;
605 sr->in_body = body;
606
607 if (!body)
608 {
609 for (i = 0; i < 4; ++i)
610 {
611 if (mask & 0x8)
612 set_reg (sr->curr.reg + save_order[i], UNW_WHERE_GR,
613 sr->region_start + sr->region_len - 1, grsave++);
614 mask <<= 1;
615 }
616 sr->gr_save_loc = grsave;
617 sr->any_spills = 0;
618 sr->imask = 0;
619 sr->spill_offset = 0x10; /* default to psp+16 */
620 }
621 }
622
623 /*
624 * Prologue descriptors.
625 */
626
627 static inline void
desc_abi(unsigned char abi,unsigned char context,struct unw_state_record * sr)628 desc_abi (unsigned char abi,
629 unsigned char context,
630 struct unw_state_record *sr)
631 {
632 sr->unwabi = (abi << 8) | context;
633 }
634
635 static inline void
desc_br_gr(unsigned char brmask,unsigned char gr,struct unw_state_record * sr)636 desc_br_gr (unsigned char brmask, unsigned char gr,
637 struct unw_state_record *sr)
638 {
639 int i;
640
641 for (i = 0; i < 5; ++i)
642 {
643 if (brmask & 1)
644 set_reg (sr->curr.reg + UNW_REG_B1 + i, UNW_WHERE_GR,
645 sr->region_start + sr->region_len - 1, gr++);
646 brmask >>= 1;
647 }
648 }
649
650 static inline void
desc_br_mem(unsigned char brmask,struct unw_state_record * sr)651 desc_br_mem (unsigned char brmask, struct unw_state_record *sr)
652 {
653 int i;
654
655 for (i = 0; i < 5; ++i)
656 {
657 if (brmask & 1)
658 {
659 set_reg (sr->curr.reg + UNW_REG_B1 + i, UNW_WHERE_SPILL_HOME,
660 sr->region_start + sr->region_len - 1, 0);
661 sr->any_spills = 1;
662 }
663 brmask >>= 1;
664 }
665 }
666
667 static inline void
desc_frgr_mem(unsigned char grmask,unw_word frmask,struct unw_state_record * sr)668 desc_frgr_mem (unsigned char grmask, unw_word frmask,
669 struct unw_state_record *sr)
670 {
671 int i;
672
673 for (i = 0; i < 4; ++i)
674 {
675 if ((grmask & 1) != 0)
676 {
677 set_reg (sr->curr.reg + UNW_REG_R4 + i, UNW_WHERE_SPILL_HOME,
678 sr->region_start + sr->region_len - 1, 0);
679 sr->any_spills = 1;
680 }
681 grmask >>= 1;
682 }
683 for (i = 0; i < 20; ++i)
684 {
685 if ((frmask & 1) != 0)
686 {
687 enum unw_register_index base = i < 4 ? UNW_REG_F2 : UNW_REG_F16 - 4;
688 set_reg (sr->curr.reg + base + i, UNW_WHERE_SPILL_HOME,
689 sr->region_start + sr->region_len - 1, 0);
690 sr->any_spills = 1;
691 }
692 frmask >>= 1;
693 }
694 }
695
696 static inline void
desc_fr_mem(unsigned char frmask,struct unw_state_record * sr)697 desc_fr_mem (unsigned char frmask, struct unw_state_record *sr)
698 {
699 int i;
700
701 for (i = 0; i < 4; ++i)
702 {
703 if ((frmask & 1) != 0)
704 {
705 set_reg (sr->curr.reg + UNW_REG_F2 + i, UNW_WHERE_SPILL_HOME,
706 sr->region_start + sr->region_len - 1, 0);
707 sr->any_spills = 1;
708 }
709 frmask >>= 1;
710 }
711 }
712
713 static inline void
desc_gr_gr(unsigned char grmask,unsigned char gr,struct unw_state_record * sr)714 desc_gr_gr (unsigned char grmask, unsigned char gr,
715 struct unw_state_record *sr)
716 {
717 int i;
718
719 for (i = 0; i < 4; ++i)
720 {
721 if ((grmask & 1) != 0)
722 set_reg (sr->curr.reg + UNW_REG_R4 + i, UNW_WHERE_GR,
723 sr->region_start + sr->region_len - 1, gr++);
724 grmask >>= 1;
725 }
726 }
727
728 static inline void
desc_gr_mem(unsigned char grmask,struct unw_state_record * sr)729 desc_gr_mem (unsigned char grmask, struct unw_state_record *sr)
730 {
731 int i;
732
733 for (i = 0; i < 4; ++i)
734 {
735 if ((grmask & 1) != 0)
736 {
737 set_reg (sr->curr.reg + UNW_REG_R4 + i, UNW_WHERE_SPILL_HOME,
738 sr->region_start + sr->region_len - 1, 0);
739 sr->any_spills = 1;
740 }
741 grmask >>= 1;
742 }
743 }
744
745 static inline void
desc_mem_stack_f(unw_word t,unw_word size,struct unw_state_record * sr)746 desc_mem_stack_f (unw_word t, unw_word size, struct unw_state_record *sr)
747 {
748 set_reg (sr->curr.reg + UNW_REG_PSP, UNW_WHERE_NONE,
749 sr->region_start + MIN ((int)t, sr->region_len - 1), 16*size);
750 }
751
752 static inline void
desc_mem_stack_v(unw_word t,struct unw_state_record * sr)753 desc_mem_stack_v (unw_word t, struct unw_state_record *sr)
754 {
755 sr->curr.reg[UNW_REG_PSP].when
756 = sr->region_start + MIN ((int)t, sr->region_len - 1);
757 }
758
759 static inline void
desc_reg_gr(unsigned char reg,unsigned char dst,struct unw_state_record * sr)760 desc_reg_gr (unsigned char reg, unsigned char dst, struct unw_state_record *sr)
761 {
762 set_reg (sr->curr.reg + reg, UNW_WHERE_GR,
763 sr->region_start + sr->region_len - 1, dst);
764 }
765
766 static inline void
desc_reg_psprel(unsigned char reg,unw_word pspoff,struct unw_state_record * sr)767 desc_reg_psprel (unsigned char reg, unw_word pspoff,
768 struct unw_state_record *sr)
769 {
770 set_reg (sr->curr.reg + reg, UNW_WHERE_PSPREL,
771 sr->region_start + sr->region_len - 1,
772 0x10 - 4*pspoff);
773 }
774
775 static inline void
desc_reg_sprel(unsigned char reg,unw_word spoff,struct unw_state_record * sr)776 desc_reg_sprel (unsigned char reg, unw_word spoff, struct unw_state_record *sr)
777 {
778 set_reg (sr->curr.reg + reg, UNW_WHERE_SPREL,
779 sr->region_start + sr->region_len - 1,
780 4*spoff);
781 }
782
783 static inline void
desc_rp_br(unsigned char dst,struct unw_state_record * sr)784 desc_rp_br (unsigned char dst, struct unw_state_record *sr)
785 {
786 sr->return_link_reg = dst;
787 }
788
789 static inline void
desc_reg_when(unsigned char regnum,unw_word t,struct unw_state_record * sr)790 desc_reg_when (unsigned char regnum, unw_word t, struct unw_state_record *sr)
791 {
792 struct unw_reg_info *reg = sr->curr.reg + regnum;
793
794 if (reg->where == UNW_WHERE_NONE)
795 reg->where = UNW_WHERE_GR_SAVE;
796 reg->when = sr->region_start + MIN ((int)t, sr->region_len - 1);
797 }
798
799 static inline void
desc_spill_base(unw_word pspoff,struct unw_state_record * sr)800 desc_spill_base (unw_word pspoff, struct unw_state_record *sr)
801 {
802 sr->spill_offset = 0x10 - 4*pspoff;
803 }
804
805 static inline unsigned char *
desc_spill_mask(unsigned char * imaskp,struct unw_state_record * sr)806 desc_spill_mask (unsigned char *imaskp, struct unw_state_record *sr)
807 {
808 sr->imask = imaskp;
809 return imaskp + (2*sr->region_len + 7)/8;
810 }
811
812 /*
813 * Body descriptors.
814 */
815 static inline void
desc_epilogue(unw_word t,unw_word ecount,struct unw_state_record * sr)816 desc_epilogue (unw_word t, unw_word ecount, struct unw_state_record *sr)
817 {
818 sr->epilogue_start = sr->region_start + sr->region_len - 1 - t;
819 sr->epilogue_count = ecount + 1;
820 }
821
822 static inline void
desc_copy_state(unw_word label,struct unw_state_record * sr)823 desc_copy_state (unw_word label, struct unw_state_record *sr)
824 {
825 struct unw_labeled_state *ls;
826
827 for (ls = sr->labeled_states; ls; ls = ls->next)
828 {
829 if (ls->label == label)
830 {
831 free_state_stack (&sr->curr);
832 memcpy (&sr->curr, &ls->saved_state, sizeof (sr->curr));
833 sr->curr.next = dup_state_stack (ls->saved_state.next);
834 return;
835 }
836 }
837 abort ();
838 }
839
840 static inline void
desc_label_state(unw_word label,struct unw_state_record * sr)841 desc_label_state (unw_word label, struct unw_state_record *sr)
842 {
843 struct unw_labeled_state *ls = alloc_label_state ();
844
845 ls->label = label;
846 memcpy (&ls->saved_state, &sr->curr, sizeof (ls->saved_state));
847 ls->saved_state.next = dup_state_stack (sr->curr.next);
848
849 /* Insert into list of labeled states. */
850 ls->next = sr->labeled_states;
851 sr->labeled_states = ls;
852 }
853
854 /*
855 * General descriptors.
856 */
857
858 static inline int
desc_is_active(unsigned char qp,unw_word t,struct unw_state_record * sr)859 desc_is_active (unsigned char qp, unw_word t, struct unw_state_record *sr)
860 {
861 if (sr->when_target <= sr->region_start + MIN ((int)t, sr->region_len - 1))
862 return 0;
863 if (qp > 0)
864 {
865 if ((sr->pr_val & (1UL << qp)) == 0)
866 return 0;
867 sr->pr_mask |= (1UL << qp);
868 }
869 return 1;
870 }
871
872 static inline void
desc_restore_p(unsigned char qp,unw_word t,unsigned char abreg,struct unw_state_record * sr)873 desc_restore_p (unsigned char qp, unw_word t, unsigned char abreg,
874 struct unw_state_record *sr)
875 {
876 struct unw_reg_info *r;
877
878 if (! desc_is_active (qp, t, sr))
879 return;
880
881 r = sr->curr.reg + decode_abreg (abreg, 0);
882 r->where = UNW_WHERE_NONE;
883 r->when = sr->region_start + MIN ((int)t, sr->region_len - 1);
884 r->val = 0;
885 }
886
887 static inline void
desc_spill_reg_p(unsigned char qp,unw_word t,unsigned char abreg,unsigned char x,unsigned char ytreg,struct unw_state_record * sr)888 desc_spill_reg_p (unsigned char qp, unw_word t, unsigned char abreg,
889 unsigned char x, unsigned char ytreg,
890 struct unw_state_record *sr)
891 {
892 enum unw_where where = UNW_WHERE_GR;
893 struct unw_reg_info *r;
894
895 if (! desc_is_active (qp, t, sr))
896 return;
897
898 if (x)
899 where = UNW_WHERE_BR;
900 else if (ytreg & 0x80)
901 where = UNW_WHERE_FR;
902
903 r = sr->curr.reg + decode_abreg (abreg, 0);
904 r->where = where;
905 r->when = sr->region_start + MIN ((int)t, sr->region_len - 1);
906 r->val = ytreg & 0x7f;
907 }
908
909 static inline void
desc_spill_psprel_p(unsigned char qp,unw_word t,unsigned char abreg,unw_word pspoff,struct unw_state_record * sr)910 desc_spill_psprel_p (unsigned char qp, unw_word t, unsigned char abreg,
911 unw_word pspoff, struct unw_state_record *sr)
912 {
913 struct unw_reg_info *r;
914
915 if (! desc_is_active (qp, t, sr))
916 return;
917
918 r = sr->curr.reg + decode_abreg (abreg, 1);
919 r->where = UNW_WHERE_PSPREL;
920 r->when = sr->region_start + MIN((int)t, sr->region_len - 1);
921 r->val = 0x10 - 4*pspoff;
922 }
923
924 static inline void
desc_spill_sprel_p(unsigned char qp,unw_word t,unsigned char abreg,unw_word spoff,struct unw_state_record * sr)925 desc_spill_sprel_p (unsigned char qp, unw_word t, unsigned char abreg,
926 unw_word spoff, struct unw_state_record *sr)
927 {
928 struct unw_reg_info *r;
929
930 if (! desc_is_active (qp, t, sr))
931 return;
932
933 r = sr->curr.reg + decode_abreg (abreg, 1);
934 r->where = UNW_WHERE_SPREL;
935 r->when = sr->region_start + MIN ((int)t, sr->region_len - 1);
936 r->val = 4*spoff;
937 }
938
939
940 #define UNW_DEC_BAD_CODE(code) abort ();
941
942 /* Region headers. */
943 #define UNW_DEC_PROLOGUE_GR(fmt,r,m,gr,arg) desc_prologue(0,r,m,gr,arg)
944 #define UNW_DEC_PROLOGUE(fmt,b,r,arg) desc_prologue(b,r,0,32,arg)
945
946 /* Prologue descriptors. */
947 #define UNW_DEC_ABI(fmt,a,c,arg) desc_abi(a,c,arg)
948 #define UNW_DEC_BR_GR(fmt,b,g,arg) desc_br_gr(b,g,arg)
949 #define UNW_DEC_BR_MEM(fmt,b,arg) desc_br_mem(b,arg)
950 #define UNW_DEC_FRGR_MEM(fmt,g,f,arg) desc_frgr_mem(g,f,arg)
951 #define UNW_DEC_FR_MEM(fmt,f,arg) desc_fr_mem(f,arg)
952 #define UNW_DEC_GR_GR(fmt,m,g,arg) desc_gr_gr(m,g,arg)
953 #define UNW_DEC_GR_MEM(fmt,m,arg) desc_gr_mem(m,arg)
954 #define UNW_DEC_MEM_STACK_F(fmt,t,s,arg) desc_mem_stack_f(t,s,arg)
955 #define UNW_DEC_MEM_STACK_V(fmt,t,arg) desc_mem_stack_v(t,arg)
956 #define UNW_DEC_REG_GR(fmt,r,d,arg) desc_reg_gr(r,d,arg)
957 #define UNW_DEC_REG_PSPREL(fmt,r,o,arg) desc_reg_psprel(r,o,arg)
958 #define UNW_DEC_REG_SPREL(fmt,r,o,arg) desc_reg_sprel(r,o,arg)
959 #define UNW_DEC_REG_WHEN(fmt,r,t,arg) desc_reg_when(r,t,arg)
960 #define UNW_DEC_PRIUNAT_WHEN_GR(fmt,t,arg) desc_reg_when(UNW_REG_PRI_UNAT_GR,t,arg)
961 #define UNW_DEC_PRIUNAT_WHEN_MEM(fmt,t,arg) desc_reg_when(UNW_REG_PRI_UNAT_MEM,t,arg)
962 #define UNW_DEC_PRIUNAT_GR(fmt,r,arg) desc_reg_gr(UNW_REG_PRI_UNAT_GR,r,arg)
963 #define UNW_DEC_PRIUNAT_PSPREL(fmt,o,arg) desc_reg_psprel(UNW_REG_PRI_UNAT_MEM,o,arg)
964 #define UNW_DEC_PRIUNAT_SPREL(fmt,o,arg) desc_reg_sprel(UNW_REG_PRI_UNAT_MEM,o,arg)
965 #define UNW_DEC_RP_BR(fmt,d,arg) desc_rp_br(d,arg)
966 #define UNW_DEC_SPILL_BASE(fmt,o,arg) desc_spill_base(o,arg)
967 #define UNW_DEC_SPILL_MASK(fmt,m,arg) (m = desc_spill_mask(m,arg))
968
969 /* Body descriptors. */
970 #define UNW_DEC_EPILOGUE(fmt,t,c,arg) desc_epilogue(t,c,arg)
971 #define UNW_DEC_COPY_STATE(fmt,l,arg) desc_copy_state(l,arg)
972 #define UNW_DEC_LABEL_STATE(fmt,l,arg) desc_label_state(l,arg)
973
974 /* General unwind descriptors. */
975 #define UNW_DEC_SPILL_REG_P(f,p,t,a,x,y,arg) desc_spill_reg_p(p,t,a,x,y,arg)
976 #define UNW_DEC_SPILL_REG(f,t,a,x,y,arg) desc_spill_reg_p(0,t,a,x,y,arg)
977 #define UNW_DEC_SPILL_PSPREL_P(f,p,t,a,o,arg) desc_spill_psprel_p(p,t,a,o,arg)
978 #define UNW_DEC_SPILL_PSPREL(f,t,a,o,arg) desc_spill_psprel_p(0,t,a,o,arg)
979 #define UNW_DEC_SPILL_SPREL_P(f,p,t,a,o,arg) desc_spill_sprel_p(p,t,a,o,arg)
980 #define UNW_DEC_SPILL_SPREL(f,t,a,o,arg) desc_spill_sprel_p(0,t,a,o,arg)
981 #define UNW_DEC_RESTORE_P(f,p,t,a,arg) desc_restore_p(p,t,a,arg)
982 #define UNW_DEC_RESTORE(f,t,a,arg) desc_restore_p(0,t,a,arg)
983
984
985 /*
986 * Generic IA-64 unwind info decoder.
987 *
988 * This file is used both by the Linux kernel and objdump. Please keep
989 * the copies of this file in sync.
990 *
991 * You need to customize the decoder by defining the following
992 * macros/constants before including this file:
993 *
994 * Types:
995 * unw_word Unsigned integer type with at least 64 bits
996 *
997 * Register names:
998 * UNW_REG_BSP
999 * UNW_REG_BSPSTORE
1000 * UNW_REG_FPSR
1001 * UNW_REG_LC
1002 * UNW_REG_PFS
1003 * UNW_REG_PR
1004 * UNW_REG_RNAT
1005 * UNW_REG_PSP
1006 * UNW_REG_RP
1007 * UNW_REG_UNAT
1008 *
1009 * Decoder action macros:
1010 * UNW_DEC_BAD_CODE(code)
1011 * UNW_DEC_ABI(fmt,abi,context,arg)
1012 * UNW_DEC_BR_GR(fmt,brmask,gr,arg)
1013 * UNW_DEC_BR_MEM(fmt,brmask,arg)
1014 * UNW_DEC_COPY_STATE(fmt,label,arg)
1015 * UNW_DEC_EPILOGUE(fmt,t,ecount,arg)
1016 * UNW_DEC_FRGR_MEM(fmt,grmask,frmask,arg)
1017 * UNW_DEC_FR_MEM(fmt,frmask,arg)
1018 * UNW_DEC_GR_GR(fmt,grmask,gr,arg)
1019 * UNW_DEC_GR_MEM(fmt,grmask,arg)
1020 * UNW_DEC_LABEL_STATE(fmt,label,arg)
1021 * UNW_DEC_MEM_STACK_F(fmt,t,size,arg)
1022 * UNW_DEC_MEM_STACK_V(fmt,t,arg)
1023 * UNW_DEC_PRIUNAT_GR(fmt,r,arg)
1024 * UNW_DEC_PRIUNAT_WHEN_GR(fmt,t,arg)
1025 * UNW_DEC_PRIUNAT_WHEN_MEM(fmt,t,arg)
1026 * UNW_DEC_PRIUNAT_WHEN_PSPREL(fmt,pspoff,arg)
1027 * UNW_DEC_PRIUNAT_WHEN_SPREL(fmt,spoff,arg)
1028 * UNW_DEC_PROLOGUE(fmt,body,rlen,arg)
1029 * UNW_DEC_PROLOGUE_GR(fmt,rlen,mask,grsave,arg)
1030 * UNW_DEC_REG_PSPREL(fmt,reg,pspoff,arg)
1031 * UNW_DEC_REG_REG(fmt,src,dst,arg)
1032 * UNW_DEC_REG_SPREL(fmt,reg,spoff,arg)
1033 * UNW_DEC_REG_WHEN(fmt,reg,t,arg)
1034 * UNW_DEC_RESTORE(fmt,t,abreg,arg)
1035 * UNW_DEC_RESTORE_P(fmt,qp,t,abreg,arg)
1036 * UNW_DEC_SPILL_BASE(fmt,pspoff,arg)
1037 * UNW_DEC_SPILL_MASK(fmt,imaskp,arg)
1038 * UNW_DEC_SPILL_PSPREL(fmt,t,abreg,pspoff,arg)
1039 * UNW_DEC_SPILL_PSPREL_P(fmt,qp,t,abreg,pspoff,arg)
1040 * UNW_DEC_SPILL_REG(fmt,t,abreg,x,ytreg,arg)
1041 * UNW_DEC_SPILL_REG_P(fmt,qp,t,abreg,x,ytreg,arg)
1042 * UNW_DEC_SPILL_SPREL(fmt,t,abreg,spoff,arg)
1043 * UNW_DEC_SPILL_SPREL_P(fmt,qp,t,abreg,pspoff,arg)
1044 */
1045
1046 static unw_word
unw_decode_uleb128(unsigned char ** dpp)1047 unw_decode_uleb128 (unsigned char **dpp)
1048 {
1049 unsigned shift = 0;
1050 unw_word byte, result = 0;
1051 unsigned char *bp = *dpp;
1052
1053 while (1)
1054 {
1055 byte = *bp++;
1056 result |= (byte & 0x7f) << shift;
1057 if ((byte & 0x80) == 0)
1058 break;
1059 shift += 7;
1060 }
1061 *dpp = bp;
1062 return result;
1063 }
1064
1065 static unsigned char *
unw_decode_x1(unsigned char * dp,unsigned char code,void * arg)1066 unw_decode_x1 (unsigned char *dp,
1067 unsigned char code __attribute__((unused)),
1068 void *arg)
1069 {
1070 unsigned char byte1, abreg;
1071 unw_word t, off;
1072
1073 byte1 = *dp++;
1074 t = unw_decode_uleb128 (&dp);
1075 off = unw_decode_uleb128 (&dp);
1076 abreg = (byte1 & 0x7f);
1077 if (byte1 & 0x80)
1078 UNW_DEC_SPILL_SPREL(X1, t, abreg, off, arg);
1079 else
1080 UNW_DEC_SPILL_PSPREL(X1, t, abreg, off, arg);
1081 return dp;
1082 }
1083
1084 static unsigned char *
unw_decode_x2(unsigned char * dp,unsigned char code,void * arg)1085 unw_decode_x2 (unsigned char *dp,
1086 unsigned char code __attribute__((unused)),
1087 void *arg)
1088 {
1089 unsigned char byte1, byte2, abreg, x, ytreg;
1090 unw_word t;
1091
1092 byte1 = *dp++; byte2 = *dp++;
1093 t = unw_decode_uleb128 (&dp);
1094 abreg = (byte1 & 0x7f);
1095 ytreg = byte2;
1096 x = (byte1 >> 7) & 1;
1097 if ((byte1 & 0x80) == 0 && ytreg == 0)
1098 UNW_DEC_RESTORE(X2, t, abreg, arg);
1099 else
1100 UNW_DEC_SPILL_REG(X2, t, abreg, x, ytreg, arg);
1101 return dp;
1102 }
1103
1104 static unsigned char *
unw_decode_x3(unsigned char * dp,unsigned char code,void * arg)1105 unw_decode_x3 (unsigned char *dp,
1106 unsigned char code __attribute__((unused)),
1107 void *arg)
1108 {
1109 unsigned char byte1, byte2, abreg, qp;
1110 unw_word t, off;
1111
1112 byte1 = *dp++; byte2 = *dp++;
1113 t = unw_decode_uleb128 (&dp);
1114 off = unw_decode_uleb128 (&dp);
1115
1116 qp = (byte1 & 0x3f);
1117 abreg = (byte2 & 0x7f);
1118
1119 if (byte1 & 0x80)
1120 UNW_DEC_SPILL_SPREL_P(X3, qp, t, abreg, off, arg);
1121 else
1122 UNW_DEC_SPILL_PSPREL_P(X3, qp, t, abreg, off, arg);
1123 return dp;
1124 }
1125
1126 static unsigned char *
unw_decode_x4(unsigned char * dp,unsigned char code,void * arg)1127 unw_decode_x4 (unsigned char *dp,
1128 unsigned char code __attribute__((unused)),
1129 void *arg)
1130 {
1131 unsigned char byte1, byte2, byte3, qp, abreg, x, ytreg;
1132 unw_word t;
1133
1134 byte1 = *dp++; byte2 = *dp++; byte3 = *dp++;
1135 t = unw_decode_uleb128 (&dp);
1136
1137 qp = (byte1 & 0x3f);
1138 abreg = (byte2 & 0x7f);
1139 x = (byte2 >> 7) & 1;
1140 ytreg = byte3;
1141
1142 if ((byte2 & 0x80) == 0 && byte3 == 0)
1143 UNW_DEC_RESTORE_P(X4, qp, t, abreg, arg);
1144 else
1145 UNW_DEC_SPILL_REG_P(X4, qp, t, abreg, x, ytreg, arg);
1146 return dp;
1147 }
1148
1149 static unsigned char *
unw_decode_r1(unsigned char * dp,unsigned char code,void * arg)1150 unw_decode_r1 (unsigned char *dp, unsigned char code, void *arg)
1151 {
1152 int body = (code & 0x20) != 0;
1153 unw_word rlen;
1154
1155 rlen = (code & 0x1f);
1156 UNW_DEC_PROLOGUE(R1, body, rlen, arg);
1157 return dp;
1158 }
1159
1160 static unsigned char *
unw_decode_r2(unsigned char * dp,unsigned char code,void * arg)1161 unw_decode_r2 (unsigned char *dp, unsigned char code, void *arg)
1162 {
1163 unsigned char byte1, mask, grsave;
1164 unw_word rlen;
1165
1166 byte1 = *dp++;
1167
1168 mask = ((code & 0x7) << 1) | ((byte1 >> 7) & 1);
1169 grsave = (byte1 & 0x7f);
1170 rlen = unw_decode_uleb128 (&dp);
1171 UNW_DEC_PROLOGUE_GR(R2, rlen, mask, grsave, arg);
1172 return dp;
1173 }
1174
1175 static unsigned char *
unw_decode_r3(unsigned char * dp,unsigned char code,void * arg)1176 unw_decode_r3 (unsigned char *dp, unsigned char code, void *arg)
1177 {
1178 unw_word rlen;
1179
1180 rlen = unw_decode_uleb128 (&dp);
1181 UNW_DEC_PROLOGUE(R3, ((code & 0x3) == 1), rlen, arg);
1182 return dp;
1183 }
1184
1185 static unsigned char *
unw_decode_p1(unsigned char * dp,unsigned char code,void * arg)1186 unw_decode_p1 (unsigned char *dp, unsigned char code, void *arg)
1187 {
1188 unsigned char brmask = (code & 0x1f);
1189
1190 UNW_DEC_BR_MEM(P1, brmask, arg);
1191 return dp;
1192 }
1193
1194 static unsigned char *
unw_decode_p2_p5(unsigned char * dp,unsigned char code,void * arg)1195 unw_decode_p2_p5 (unsigned char *dp, unsigned char code, void *arg)
1196 {
1197 if ((code & 0x10) == 0)
1198 {
1199 unsigned char byte1 = *dp++;
1200
1201 UNW_DEC_BR_GR(P2, ((code & 0xf) << 1) | ((byte1 >> 7) & 1),
1202 (byte1 & 0x7f), arg);
1203 }
1204 else if ((code & 0x08) == 0)
1205 {
1206 unsigned char byte1 = *dp++, r, dst;
1207
1208 r = ((code & 0x7) << 1) | ((byte1 >> 7) & 1);
1209 dst = (byte1 & 0x7f);
1210 switch (r)
1211 {
1212 case 0: UNW_DEC_REG_GR(P3, UNW_REG_PSP, dst, arg); break;
1213 case 1: UNW_DEC_REG_GR(P3, UNW_REG_RP, dst, arg); break;
1214 case 2: UNW_DEC_REG_GR(P3, UNW_REG_PFS, dst, arg); break;
1215 case 3: UNW_DEC_REG_GR(P3, UNW_REG_PR, dst, arg); break;
1216 case 4: UNW_DEC_REG_GR(P3, UNW_REG_UNAT, dst, arg); break;
1217 case 5: UNW_DEC_REG_GR(P3, UNW_REG_LC, dst, arg); break;
1218 case 6: UNW_DEC_RP_BR(P3, dst, arg); break;
1219 case 7: UNW_DEC_REG_GR(P3, UNW_REG_RNAT, dst, arg); break;
1220 case 8: UNW_DEC_REG_GR(P3, UNW_REG_BSP, dst, arg); break;
1221 case 9: UNW_DEC_REG_GR(P3, UNW_REG_BSPSTORE, dst, arg); break;
1222 case 10: UNW_DEC_REG_GR(P3, UNW_REG_FPSR, dst, arg); break;
1223 case 11: UNW_DEC_PRIUNAT_GR(P3, dst, arg); break;
1224 default: UNW_DEC_BAD_CODE(r); break;
1225 }
1226 }
1227 else if ((code & 0x7) == 0)
1228 UNW_DEC_SPILL_MASK(P4, dp, arg);
1229 else if ((code & 0x7) == 1)
1230 {
1231 unw_word grmask, frmask, byte1, byte2, byte3;
1232
1233 byte1 = *dp++; byte2 = *dp++; byte3 = *dp++;
1234 grmask = ((byte1 >> 4) & 0xf);
1235 frmask = ((byte1 & 0xf) << 16) | (byte2 << 8) | byte3;
1236 UNW_DEC_FRGR_MEM(P5, grmask, frmask, arg);
1237 }
1238 else
1239 UNW_DEC_BAD_CODE(code);
1240 return dp;
1241 }
1242
1243 static unsigned char *
unw_decode_p6(unsigned char * dp,unsigned char code,void * arg)1244 unw_decode_p6 (unsigned char *dp, unsigned char code, void *arg)
1245 {
1246 int gregs = (code & 0x10) != 0;
1247 unsigned char mask = (code & 0x0f);
1248
1249 if (gregs)
1250 UNW_DEC_GR_MEM(P6, mask, arg);
1251 else
1252 UNW_DEC_FR_MEM(P6, mask, arg);
1253 return dp;
1254 }
1255
1256 static unsigned char *
unw_decode_p7_p10(unsigned char * dp,unsigned char code,void * arg)1257 unw_decode_p7_p10 (unsigned char *dp, unsigned char code, void *arg)
1258 {
1259 unsigned char r, byte1, byte2;
1260 unw_word t, size;
1261
1262 if ((code & 0x10) == 0)
1263 {
1264 r = (code & 0xf);
1265 t = unw_decode_uleb128 (&dp);
1266 switch (r)
1267 {
1268 case 0:
1269 size = unw_decode_uleb128 (&dp);
1270 UNW_DEC_MEM_STACK_F(P7, t, size, arg);
1271 break;
1272
1273 case 1: UNW_DEC_MEM_STACK_V(P7, t, arg); break;
1274 case 2: UNW_DEC_SPILL_BASE(P7, t, arg); break;
1275 case 3: UNW_DEC_REG_SPREL(P7, UNW_REG_PSP, t, arg); break;
1276 case 4: UNW_DEC_REG_WHEN(P7, UNW_REG_RP, t, arg); break;
1277 case 5: UNW_DEC_REG_PSPREL(P7, UNW_REG_RP, t, arg); break;
1278 case 6: UNW_DEC_REG_WHEN(P7, UNW_REG_PFS, t, arg); break;
1279 case 7: UNW_DEC_REG_PSPREL(P7, UNW_REG_PFS, t, arg); break;
1280 case 8: UNW_DEC_REG_WHEN(P7, UNW_REG_PR, t, arg); break;
1281 case 9: UNW_DEC_REG_PSPREL(P7, UNW_REG_PR, t, arg); break;
1282 case 10: UNW_DEC_REG_WHEN(P7, UNW_REG_LC, t, arg); break;
1283 case 11: UNW_DEC_REG_PSPREL(P7, UNW_REG_LC, t, arg); break;
1284 case 12: UNW_DEC_REG_WHEN(P7, UNW_REG_UNAT, t, arg); break;
1285 case 13: UNW_DEC_REG_PSPREL(P7, UNW_REG_UNAT, t, arg); break;
1286 case 14: UNW_DEC_REG_WHEN(P7, UNW_REG_FPSR, t, arg); break;
1287 case 15: UNW_DEC_REG_PSPREL(P7, UNW_REG_FPSR, t, arg); break;
1288 default: UNW_DEC_BAD_CODE(r); break;
1289 }
1290 }
1291 else
1292 {
1293 switch (code & 0xf)
1294 {
1295 case 0x0: /* p8 */
1296 {
1297 r = *dp++;
1298 t = unw_decode_uleb128 (&dp);
1299 switch (r)
1300 {
1301 case 1: UNW_DEC_REG_SPREL(P8, UNW_REG_RP, t, arg); break;
1302 case 2: UNW_DEC_REG_SPREL(P8, UNW_REG_PFS, t, arg); break;
1303 case 3: UNW_DEC_REG_SPREL(P8, UNW_REG_PR, t, arg); break;
1304 case 4: UNW_DEC_REG_SPREL(P8, UNW_REG_LC, t, arg); break;
1305 case 5: UNW_DEC_REG_SPREL(P8, UNW_REG_UNAT, t, arg); break;
1306 case 6: UNW_DEC_REG_SPREL(P8, UNW_REG_FPSR, t, arg); break;
1307 case 7: UNW_DEC_REG_WHEN(P8, UNW_REG_BSP, t, arg); break;
1308 case 8: UNW_DEC_REG_PSPREL(P8, UNW_REG_BSP, t, arg); break;
1309 case 9: UNW_DEC_REG_SPREL(P8, UNW_REG_BSP, t, arg); break;
1310 case 10: UNW_DEC_REG_WHEN(P8, UNW_REG_BSPSTORE, t, arg); break;
1311 case 11: UNW_DEC_REG_PSPREL(P8, UNW_REG_BSPSTORE, t, arg); break;
1312 case 12: UNW_DEC_REG_SPREL(P8, UNW_REG_BSPSTORE, t, arg); break;
1313 case 13: UNW_DEC_REG_WHEN(P8, UNW_REG_RNAT, t, arg); break;
1314 case 14: UNW_DEC_REG_PSPREL(P8, UNW_REG_RNAT, t, arg); break;
1315 case 15: UNW_DEC_REG_SPREL(P8, UNW_REG_RNAT, t, arg); break;
1316 case 16: UNW_DEC_PRIUNAT_WHEN_GR(P8, t, arg); break;
1317 case 17: UNW_DEC_PRIUNAT_PSPREL(P8, t, arg); break;
1318 case 18: UNW_DEC_PRIUNAT_SPREL(P8, t, arg); break;
1319 case 19: UNW_DEC_PRIUNAT_WHEN_MEM(P8, t, arg); break;
1320 default: UNW_DEC_BAD_CODE(r); break;
1321 }
1322 }
1323 break;
1324
1325 case 0x1:
1326 byte1 = *dp++; byte2 = *dp++;
1327 UNW_DEC_GR_GR(P9, (byte1 & 0xf), (byte2 & 0x7f), arg);
1328 break;
1329
1330 case 0xf: /* p10 */
1331 byte1 = *dp++; byte2 = *dp++;
1332 UNW_DEC_ABI(P10, byte1, byte2, arg);
1333 break;
1334
1335 case 0x9:
1336 return unw_decode_x1 (dp, code, arg);
1337
1338 case 0xa:
1339 return unw_decode_x2 (dp, code, arg);
1340
1341 case 0xb:
1342 return unw_decode_x3 (dp, code, arg);
1343
1344 case 0xc:
1345 return unw_decode_x4 (dp, code, arg);
1346
1347 default:
1348 UNW_DEC_BAD_CODE(code);
1349 break;
1350 }
1351 }
1352 return dp;
1353 }
1354
1355 static unsigned char *
unw_decode_b1(unsigned char * dp,unsigned char code,void * arg)1356 unw_decode_b1 (unsigned char *dp, unsigned char code, void *arg)
1357 {
1358 unw_word label = (code & 0x1f);
1359
1360 if ((code & 0x20) != 0)
1361 UNW_DEC_COPY_STATE(B1, label, arg);
1362 else
1363 UNW_DEC_LABEL_STATE(B1, label, arg);
1364 return dp;
1365 }
1366
1367 static unsigned char *
unw_decode_b2(unsigned char * dp,unsigned char code,void * arg)1368 unw_decode_b2 (unsigned char *dp, unsigned char code, void *arg)
1369 {
1370 unw_word t;
1371
1372 t = unw_decode_uleb128 (&dp);
1373 UNW_DEC_EPILOGUE(B2, t, (code & 0x1f), arg);
1374 return dp;
1375 }
1376
1377 static unsigned char *
unw_decode_b3_x4(unsigned char * dp,unsigned char code,void * arg)1378 unw_decode_b3_x4 (unsigned char *dp, unsigned char code, void *arg)
1379 {
1380 unw_word t, ecount, label;
1381
1382 if ((code & 0x10) == 0)
1383 {
1384 t = unw_decode_uleb128 (&dp);
1385 ecount = unw_decode_uleb128 (&dp);
1386 UNW_DEC_EPILOGUE(B3, t, ecount, arg);
1387 }
1388 else if ((code & 0x07) == 0)
1389 {
1390 label = unw_decode_uleb128 (&dp);
1391 if ((code & 0x08) != 0)
1392 UNW_DEC_COPY_STATE(B4, label, arg);
1393 else
1394 UNW_DEC_LABEL_STATE(B4, label, arg);
1395 }
1396 else
1397 switch (code & 0x7)
1398 {
1399 case 1: return unw_decode_x1 (dp, code, arg);
1400 case 2: return unw_decode_x2 (dp, code, arg);
1401 case 3: return unw_decode_x3 (dp, code, arg);
1402 case 4: return unw_decode_x4 (dp, code, arg);
1403 default: UNW_DEC_BAD_CODE(code); break;
1404 }
1405 return dp;
1406 }
1407
1408 typedef unsigned char *(*unw_decoder) (unsigned char *, unsigned char, void *);
1409
1410 static const unw_decoder unw_decode_table[2][8] =
1411 {
1412 /* prologue table: */
1413 {
1414 unw_decode_r1, /* 0 */
1415 unw_decode_r1,
1416 unw_decode_r2,
1417 unw_decode_r3,
1418 unw_decode_p1, /* 4 */
1419 unw_decode_p2_p5,
1420 unw_decode_p6,
1421 unw_decode_p7_p10
1422 },
1423 {
1424 unw_decode_r1, /* 0 */
1425 unw_decode_r1,
1426 unw_decode_r2,
1427 unw_decode_r3,
1428 unw_decode_b1, /* 4 */
1429 unw_decode_b1,
1430 unw_decode_b2,
1431 unw_decode_b3_x4
1432 }
1433 };
1434
1435 /*
1436 * Decode one descriptor and return address of next descriptor.
1437 */
1438 static inline unsigned char *
unw_decode(unsigned char * dp,int inside_body,void * arg)1439 unw_decode (unsigned char *dp, int inside_body, void *arg)
1440 {
1441 unw_decoder decoder;
1442 unsigned char code;
1443
1444 code = *dp++;
1445 decoder = unw_decode_table[inside_body][code >> 5];
1446 dp = (*decoder) (dp, code, arg);
1447 return dp;
1448 }
1449
1450
1451 /* RSE helper functions. */
1452
1453 static inline unsigned long
ia64_rse_slot_num(unsigned long * addr)1454 ia64_rse_slot_num (unsigned long *addr)
1455 {
1456 return (((unsigned long) addr) >> 3) & 0x3f;
1457 }
1458
1459 /* Return TRUE if ADDR is the address of an RNAT slot. */
1460 static inline unsigned long
ia64_rse_is_rnat_slot(unsigned long * addr)1461 ia64_rse_is_rnat_slot (unsigned long *addr)
1462 {
1463 return ia64_rse_slot_num (addr) == 0x3f;
1464 }
1465
1466 /* Returns the address of the RNAT slot that covers the slot at
1467 address SLOT_ADDR. */
1468 static inline unsigned long *
ia64_rse_rnat_addr(unsigned long * slot_addr)1469 ia64_rse_rnat_addr (unsigned long *slot_addr)
1470 {
1471 return (unsigned long *) ((unsigned long) slot_addr | (0x3f << 3));
1472 }
1473
1474 /* Calculate the number of registers in the dirty partition starting at
1475 BSPSTORE with a size of DIRTY bytes. This isn't simply DIRTY
1476 divided by eight because the 64th slot is used to store ar.rnat. */
1477 static inline unsigned long
ia64_rse_num_regs(unsigned long * bspstore,unsigned long * bsp)1478 ia64_rse_num_regs (unsigned long *bspstore, unsigned long *bsp)
1479 {
1480 unsigned long slots = (bsp - bspstore);
1481
1482 return slots - (ia64_rse_slot_num (bspstore) + slots)/0x40;
1483 }
1484
1485 /* The inverse of the above: given bspstore and the number of
1486 registers, calculate ar.bsp. */
1487 static inline unsigned long *
ia64_rse_skip_regs(unsigned long * addr,long num_regs)1488 ia64_rse_skip_regs (unsigned long *addr, long num_regs)
1489 {
1490 long delta = ia64_rse_slot_num (addr) + num_regs;
1491
1492 if (num_regs < 0)
1493 delta -= 0x3e;
1494 return addr + num_regs + delta/0x3f;
1495 }
1496
1497
1498 /* Copy register backing store from SRC to DST, LEN words
1499 (which include both saved registers and nat collections).
1500 DST_RNAT is a partial nat collection for DST. SRC and DST
1501 don't have to be equal modulo 64 slots, so it cannot be
1502 done with a simple memcpy as the nat collections will be
1503 at different relative offsets and need to be combined together. */
1504 static void
ia64_copy_rbs(struct _Unwind_Context * info,unsigned long dst,unsigned long src,long len,unsigned long dst_rnat)1505 ia64_copy_rbs (struct _Unwind_Context *info, unsigned long dst,
1506 unsigned long src, long len, unsigned long dst_rnat)
1507 {
1508 long count;
1509 unsigned long src_rnat;
1510 unsigned long shift1, shift2;
1511
1512 len <<= 3;
1513 dst_rnat &= (1UL << ((dst >> 3) & 0x3f)) - 1;
1514 src_rnat = src >= info->regstk_top
1515 ? info->rnat : *(unsigned long *) (src | 0x1f8);
1516 src_rnat &= ~((1UL << ((src >> 3) & 0x3f)) - 1);
1517 /* Just to make sure. */
1518 src_rnat &= ~(1UL << 63);
1519 shift1 = ((dst - src) >> 3) & 0x3f;
1520 if ((dst & 0x1f8) < (src & 0x1f8))
1521 shift1--;
1522 shift2 = 0x3f - shift1;
1523 if ((dst & 0x1f8) >= (src & 0x1f8))
1524 {
1525 count = ~dst & 0x1f8;
1526 goto first;
1527 }
1528 count = ~src & 0x1f8;
1529 goto second;
1530 while (len > 0)
1531 {
1532 src_rnat = src >= info->regstk_top
1533 ? info->rnat : *(unsigned long *) (src | 0x1f8);
1534 /* Just to make sure. */
1535 src_rnat &= ~(1UL << 63);
1536 count = shift2 << 3;
1537 first:
1538 if (count > len)
1539 count = len;
1540 memcpy ((char *) dst, (char *) src, count);
1541 dst += count;
1542 src += count;
1543 len -= count;
1544 dst_rnat |= (src_rnat << shift1) & ~(1UL << 63);
1545 if (len <= 0)
1546 break;
1547 *(long *) dst = dst_rnat;
1548 dst += 8;
1549 dst_rnat = 0;
1550 count = shift1 << 3;
1551 second:
1552 if (count > len)
1553 count = len;
1554 memcpy ((char *) dst, (char *) src, count);
1555 dst += count;
1556 src += count + 8;
1557 len -= count + 8;
1558 dst_rnat |= (src_rnat >> shift2);
1559 }
1560 if ((dst & 0x1f8) == 0x1f8)
1561 {
1562 *(long *) dst = dst_rnat;
1563 dst += 8;
1564 dst_rnat = 0;
1565 }
1566 /* Set info->regstk_top to lowest rbs address which will use
1567 info->rnat collection. */
1568 info->regstk_top = dst & ~0x1ffUL;
1569 info->rnat = dst_rnat;
1570 }
1571
1572 /* Unwind accessors. */
1573
1574 static void
unw_access_gr(struct _Unwind_Context * info,int regnum,unsigned long * val,char * nat,int write)1575 unw_access_gr (struct _Unwind_Context *info, int regnum,
1576 unsigned long *val, char *nat, int write)
1577 {
1578 unsigned long *addr, *nat_addr = 0, nat_mask = 0, dummy_nat;
1579 struct unw_ireg *ireg;
1580
1581 if ((unsigned) regnum - 1 >= 127)
1582 abort ();
1583
1584 if (regnum < 1)
1585 {
1586 nat_addr = addr = &dummy_nat;
1587 dummy_nat = 0;
1588 }
1589 else if (regnum < 32)
1590 {
1591 /* Access a non-stacked register. */
1592 ireg = &info->ireg[regnum - 2];
1593 addr = ireg->loc;
1594 if (addr)
1595 {
1596 nat_addr = addr + ireg->nat.off;
1597 switch (ireg->nat.type)
1598 {
1599 case UNW_NAT_VAL:
1600 /* Simulate getf.sig/setf.sig. */
1601 if (write)
1602 {
1603 if (*nat)
1604 {
1605 /* Write NaTVal and be done with it. */
1606 addr[0] = 0;
1607 addr[1] = 0x1fffe;
1608 return;
1609 }
1610 addr[1] = 0x1003e;
1611 }
1612 else if (addr[0] == 0 && addr[1] == 0x1ffe)
1613 {
1614 /* Return NaT and be done with it. */
1615 *val = 0;
1616 *nat = 1;
1617 return;
1618 }
1619 /* FALLTHRU */
1620
1621 case UNW_NAT_NONE:
1622 dummy_nat = 0;
1623 nat_addr = &dummy_nat;
1624 break;
1625
1626 case UNW_NAT_MEMSTK:
1627 nat_mask = 1UL << ((long) addr & 0x1f8)/8;
1628 break;
1629
1630 case UNW_NAT_REGSTK:
1631 if ((unsigned long) addr >= info->regstk_top)
1632 nat_addr = &info->rnat;
1633 else
1634 nat_addr = ia64_rse_rnat_addr (addr);
1635 nat_mask = 1UL << ia64_rse_slot_num (addr);
1636 break;
1637 }
1638 }
1639 }
1640 else
1641 {
1642 /* Access a stacked register. */
1643 addr = ia64_rse_skip_regs ((unsigned long *) info->bsp, regnum - 32);
1644 if ((unsigned long) addr >= info->regstk_top)
1645 nat_addr = &info->rnat;
1646 else
1647 nat_addr = ia64_rse_rnat_addr (addr);
1648 nat_mask = 1UL << ia64_rse_slot_num (addr);
1649 }
1650
1651 if (write)
1652 {
1653 *addr = *val;
1654 if (*nat)
1655 *nat_addr |= nat_mask;
1656 else
1657 *nat_addr &= ~nat_mask;
1658 }
1659 else
1660 {
1661 *val = *addr;
1662 *nat = (*nat_addr & nat_mask) != 0;
1663 }
1664 }
1665
1666 /* Get the value of register REG as saved in CONTEXT. */
1667
1668 _Unwind_Word
_Unwind_GetGR(struct _Unwind_Context * context,int index)1669 _Unwind_GetGR (struct _Unwind_Context *context, int index)
1670 {
1671 _Unwind_Word ret;
1672 char nat;
1673
1674 if (index == 1)
1675 return context->gp;
1676 else if (index >= 15 && index <= 18)
1677 return context->eh_data[index - 15];
1678 else
1679 unw_access_gr (context, index, &ret, &nat, 0);
1680
1681 return ret;
1682 }
1683
1684 /* Overwrite the saved value for register REG in CONTEXT with VAL. */
1685
1686 void
_Unwind_SetGR(struct _Unwind_Context * context,int index,_Unwind_Word val)1687 _Unwind_SetGR (struct _Unwind_Context *context, int index, _Unwind_Word val)
1688 {
1689 char nat = 0;
1690
1691 if (index == 1)
1692 context->gp = val;
1693 else if (index >= 15 && index <= 18)
1694 context->eh_data[index - 15] = val;
1695 else
1696 unw_access_gr (context, index, &val, &nat, 1);
1697 }
1698
1699 /* Retrieve the return address for CONTEXT. */
1700
1701 inline _Unwind_Ptr
_Unwind_GetIP(struct _Unwind_Context * context)1702 _Unwind_GetIP (struct _Unwind_Context *context)
1703 {
1704 return context->rp;
1705 }
1706
1707 inline _Unwind_Ptr
_Unwind_GetIPInfo(struct _Unwind_Context * context,int * ip_before_insn)1708 _Unwind_GetIPInfo (struct _Unwind_Context *context, int *ip_before_insn)
1709 {
1710 *ip_before_insn = 0;
1711 return context->rp;
1712 }
1713
1714 /* Overwrite the return address for CONTEXT with VAL. */
1715
1716 inline void
_Unwind_SetIP(struct _Unwind_Context * context,_Unwind_Ptr val)1717 _Unwind_SetIP (struct _Unwind_Context *context, _Unwind_Ptr val)
1718 {
1719 context->rp = val;
1720 }
1721
1722 void *
_Unwind_GetLanguageSpecificData(struct _Unwind_Context * context)1723 _Unwind_GetLanguageSpecificData (struct _Unwind_Context *context)
1724 {
1725 return context->lsda;
1726 }
1727
1728 _Unwind_Ptr
_Unwind_GetRegionStart(struct _Unwind_Context * context)1729 _Unwind_GetRegionStart (struct _Unwind_Context *context)
1730 {
1731 return context->region_start;
1732 }
1733
1734 void *
_Unwind_FindEnclosingFunction(void * pc)1735 _Unwind_FindEnclosingFunction (void *pc)
1736 {
1737 struct unw_table_entry *ent;
1738 unsigned long segment_base, gp;
1739
1740 ent = _Unwind_FindTableEntry (pc, &segment_base, &gp);
1741 if (ent == NULL)
1742 return NULL;
1743 else
1744 return (void *)(segment_base + ent->start_offset);
1745 }
1746
1747 /* Get the value of the CFA as saved in CONTEXT. In GCC/Dwarf2 parlance,
1748 the CFA is the value of the stack pointer on entry; In IA-64 unwind
1749 parlance, this is the PSP. */
1750
1751 _Unwind_Word
_Unwind_GetCFA(struct _Unwind_Context * context)1752 _Unwind_GetCFA (struct _Unwind_Context *context)
1753 {
1754 return (_Unwind_Ptr) context->psp;
1755 }
1756
1757 /* Get the value of the Backing Store Pointer as saved in CONTEXT. */
1758
1759 _Unwind_Word
_Unwind_GetBSP(struct _Unwind_Context * context)1760 _Unwind_GetBSP (struct _Unwind_Context *context)
1761 {
1762 return (_Unwind_Ptr) context->bsp;
1763 }
1764
1765 #ifdef MD_UNWIND_SUPPORT
1766 #include MD_UNWIND_SUPPORT
1767 #endif
1768
1769 static _Unwind_Reason_Code
uw_frame_state_for(struct _Unwind_Context * context,_Unwind_FrameState * fs)1770 uw_frame_state_for (struct _Unwind_Context *context, _Unwind_FrameState *fs)
1771 {
1772 struct unw_table_entry *ent;
1773 unsigned long *unw, header, length;
1774 unsigned char *insn, *insn_end;
1775 unsigned long segment_base;
1776 struct unw_reg_info *r;
1777
1778 memset (fs, 0, sizeof (*fs));
1779 for (r = fs->curr.reg; r < fs->curr.reg + UNW_NUM_REGS; ++r)
1780 r->when = UNW_WHEN_NEVER;
1781 context->lsda = 0;
1782
1783 ent = _Unwind_FindTableEntry ((void *) context->rp,
1784 &segment_base, &context->gp);
1785 if (ent == NULL)
1786 {
1787 /* Couldn't find unwind info for this function. Try an
1788 os-specific fallback mechanism. This will necessarily
1789 not provide a personality routine or LSDA. */
1790 #ifdef MD_FALLBACK_FRAME_STATE_FOR
1791 if (MD_FALLBACK_FRAME_STATE_FOR (context, fs) == _URC_NO_REASON)
1792 return _URC_NO_REASON;
1793
1794 /* [SCRA 11.4.1] A leaf function with no memory stack, no exception
1795 handlers, and which keeps the return value in B0 does not need
1796 an unwind table entry.
1797
1798 This can only happen in the frame after unwinding through a signal
1799 handler. Avoid infinite looping by requiring that B0 != RP.
1800 RP == 0 terminates the chain. */
1801 if (context->br_loc[0] && *context->br_loc[0] != context->rp
1802 && context->rp != 0)
1803 {
1804 fs->curr.reg[UNW_REG_RP].where = UNW_WHERE_BR;
1805 fs->curr.reg[UNW_REG_RP].when = -1;
1806 fs->curr.reg[UNW_REG_RP].val = 0;
1807 return _URC_NO_REASON;
1808 }
1809 #endif
1810 return _URC_END_OF_STACK;
1811 }
1812
1813 context->region_start = ent->start_offset + segment_base;
1814 fs->when_target = ((context->rp & -16) - context->region_start) / 16 * 3
1815 + (context->rp & 15);
1816
1817 unw = (unsigned long *) (ent->info_offset + segment_base);
1818 header = *unw;
1819 length = UNW_LENGTH (header);
1820
1821 /* ??? Perhaps check UNW_VER / UNW_FLAG_OSMASK. */
1822
1823 if (UNW_FLAG_EHANDLER (header) | UNW_FLAG_UHANDLER (header))
1824 {
1825 fs->personality =
1826 *(_Unwind_Personality_Fn *) (unw[length + 1] + context->gp);
1827 context->lsda = unw + length + 2;
1828 }
1829
1830 insn = (unsigned char *) (unw + 1);
1831 insn_end = (unsigned char *) (unw + 1 + length);
1832 while (!fs->done && insn < insn_end)
1833 insn = unw_decode (insn, fs->in_body, fs);
1834
1835 free_label_states (fs->labeled_states);
1836 free_state_stack (&fs->curr);
1837
1838 #ifdef ENABLE_MALLOC_CHECKING
1839 if (reg_state_alloced || labeled_state_alloced)
1840 abort ();
1841 #endif
1842
1843 /* If we're in the epilogue, sp has been restored and all values
1844 on the memory stack below psp also have been restored. */
1845 if (fs->when_target > fs->epilogue_start)
1846 {
1847 struct unw_reg_info *r;
1848
1849 fs->curr.reg[UNW_REG_PSP].where = UNW_WHERE_NONE;
1850 fs->curr.reg[UNW_REG_PSP].val = 0;
1851 for (r = fs->curr.reg; r < fs->curr.reg + UNW_NUM_REGS; ++r)
1852 if ((r->where == UNW_WHERE_PSPREL && r->val <= 0x10)
1853 || r->where == UNW_WHERE_SPREL)
1854 r->where = UNW_WHERE_NONE;
1855 }
1856
1857 /* If RP did't get saved, generate entry for the return link register. */
1858 if (fs->curr.reg[UNW_REG_RP].when >= fs->when_target)
1859 {
1860 fs->curr.reg[UNW_REG_RP].where = UNW_WHERE_BR;
1861 fs->curr.reg[UNW_REG_RP].when = -1;
1862 fs->curr.reg[UNW_REG_RP].val = fs->return_link_reg;
1863 }
1864
1865 return _URC_NO_REASON;
1866 }
1867
1868 static void
uw_update_reg_address(struct _Unwind_Context * context,_Unwind_FrameState * fs,enum unw_register_index regno)1869 uw_update_reg_address (struct _Unwind_Context *context,
1870 _Unwind_FrameState *fs,
1871 enum unw_register_index regno)
1872 {
1873 struct unw_reg_info *r = fs->curr.reg + regno;
1874 void *addr;
1875 unsigned long rval;
1876
1877 if (r->where == UNW_WHERE_NONE || r->when >= fs->when_target)
1878 return;
1879
1880 rval = r->val;
1881 switch (r->where)
1882 {
1883 case UNW_WHERE_GR:
1884 if (rval >= 32)
1885 addr = ia64_rse_skip_regs ((unsigned long *) context->bsp, rval - 32);
1886 else if (rval >= 2)
1887 addr = context->ireg[rval - 2].loc;
1888 else if (rval == 0)
1889 {
1890 static const unsigned long dummy;
1891 addr = (void *) &dummy;
1892 }
1893 else
1894 abort ();
1895 break;
1896
1897 case UNW_WHERE_FR:
1898 if (rval >= 2 && rval < 32)
1899 addr = context->fr_loc[rval - 2];
1900 else
1901 abort ();
1902 break;
1903
1904 case UNW_WHERE_BR:
1905 /* Note that while RVAL can only be 1-5 from normal descriptors,
1906 we can want to look at B0, B6 and B7 due to having manually unwound a
1907 signal frame. */
1908 if (rval < 8)
1909 addr = context->br_loc[rval];
1910 else
1911 abort ();
1912 break;
1913
1914 case UNW_WHERE_SPREL:
1915 addr = (void *)(context->sp + rval);
1916 break;
1917
1918 case UNW_WHERE_PSPREL:
1919 addr = (void *)(context->psp + rval);
1920 break;
1921
1922 default:
1923 abort ();
1924 }
1925
1926 switch (regno)
1927 {
1928 case UNW_REG_R2 ... UNW_REG_R31:
1929 context->ireg[regno - UNW_REG_R2].loc = addr;
1930 switch (r->where)
1931 {
1932 case UNW_WHERE_GR:
1933 if (rval >= 32)
1934 {
1935 context->ireg[regno - UNW_REG_R2].nat.type = UNW_NAT_MEMSTK;
1936 context->ireg[regno - UNW_REG_R2].nat.off
1937 = context->pri_unat_loc - (unsigned long *) addr;
1938 }
1939 else if (rval >= 2)
1940 {
1941 context->ireg[regno - UNW_REG_R2].nat
1942 = context->ireg[rval - 2].nat;
1943 }
1944 else if (rval == 0)
1945 {
1946 context->ireg[regno - UNW_REG_R2].nat.type = UNW_NAT_NONE;
1947 context->ireg[regno - UNW_REG_R2].nat.off = 0;
1948 }
1949 else
1950 abort ();
1951 break;
1952
1953 case UNW_WHERE_FR:
1954 context->ireg[regno - UNW_REG_R2].nat.type = UNW_NAT_VAL;
1955 context->ireg[regno - UNW_REG_R2].nat.off = 0;
1956 break;
1957
1958 case UNW_WHERE_BR:
1959 context->ireg[regno - UNW_REG_R2].nat.type = UNW_NAT_NONE;
1960 context->ireg[regno - UNW_REG_R2].nat.off = 0;
1961 break;
1962
1963 case UNW_WHERE_PSPREL:
1964 case UNW_WHERE_SPREL:
1965 context->ireg[regno - UNW_REG_R2].nat.type = UNW_NAT_MEMSTK;
1966 context->ireg[regno - UNW_REG_R2].nat.off
1967 = context->pri_unat_loc - (unsigned long *) addr;
1968 break;
1969
1970 default:
1971 abort ();
1972 }
1973 break;
1974
1975 case UNW_REG_F2 ... UNW_REG_F31:
1976 context->fr_loc[regno - UNW_REG_F2] = addr;
1977 break;
1978
1979 case UNW_REG_B1 ... UNW_REG_B5:
1980 context->br_loc[regno - UNW_REG_B0] = addr;
1981 break;
1982
1983 case UNW_REG_BSP:
1984 context->bsp_loc = addr;
1985 break;
1986 case UNW_REG_BSPSTORE:
1987 context->bspstore_loc = addr;
1988 break;
1989 case UNW_REG_PFS:
1990 context->pfs_loc = addr;
1991 break;
1992 case UNW_REG_RP:
1993 context->rp = *(unsigned long *)addr;
1994 break;
1995 case UNW_REG_UNAT:
1996 context->unat_loc = addr;
1997 break;
1998 case UNW_REG_PR:
1999 context->pr = *(unsigned long *) addr;
2000 break;
2001 case UNW_REG_LC:
2002 context->lc_loc = addr;
2003 break;
2004 case UNW_REG_FPSR:
2005 context->fpsr_loc = addr;
2006 break;
2007
2008 case UNW_REG_PSP:
2009 context->psp = *(unsigned long *)addr;
2010 break;
2011
2012 default:
2013 abort ();
2014 }
2015 }
2016
2017 static void
uw_update_context(struct _Unwind_Context * context,_Unwind_FrameState * fs)2018 uw_update_context (struct _Unwind_Context *context, _Unwind_FrameState *fs)
2019 {
2020 long i;
2021
2022 #ifdef MD_HANDLE_UNWABI
2023 MD_HANDLE_UNWABI (context, fs);
2024 #endif
2025
2026 context->sp = context->psp;
2027
2028 /* First, set PSP. Subsequent instructions may depend on this value. */
2029 if (fs->when_target > fs->curr.reg[UNW_REG_PSP].when)
2030 {
2031 if (fs->curr.reg[UNW_REG_PSP].where == UNW_WHERE_NONE)
2032 context->psp = context->psp + fs->curr.reg[UNW_REG_PSP].val;
2033 else
2034 uw_update_reg_address (context, fs, UNW_REG_PSP);
2035 }
2036
2037 /* Determine the location of the primary UNaT. */
2038 {
2039 int i;
2040 if (fs->when_target < fs->curr.reg[UNW_REG_PRI_UNAT_GR].when)
2041 i = UNW_REG_PRI_UNAT_MEM;
2042 else if (fs->when_target < fs->curr.reg[UNW_REG_PRI_UNAT_MEM].when)
2043 i = UNW_REG_PRI_UNAT_GR;
2044 else if (fs->curr.reg[UNW_REG_PRI_UNAT_MEM].when
2045 > fs->curr.reg[UNW_REG_PRI_UNAT_GR].when)
2046 i = UNW_REG_PRI_UNAT_MEM;
2047 else
2048 i = UNW_REG_PRI_UNAT_GR;
2049 uw_update_reg_address (context, fs, i);
2050 }
2051
2052 /* Compute the addresses of all registers saved in this frame. */
2053 for (i = UNW_REG_BSP; i < UNW_NUM_REGS; ++i)
2054 uw_update_reg_address (context, fs, i);
2055
2056 /* Unwind BSP for the local registers allocated this frame. */
2057 /* ??? What to do with stored BSP or BSPSTORE registers. */
2058 /* We assert that we are either at a call site, or we have
2059 just unwound through a signal frame. In either case
2060 pfs_loc is valid. */
2061 if (!(fs -> no_reg_stack_frame))
2062 {
2063 unsigned long pfs = *context->pfs_loc;
2064 unsigned long sol = (pfs >> 7) & 0x7f;
2065 context->bsp = (unsigned long)
2066 ia64_rse_skip_regs ((unsigned long *) context->bsp, -sol);
2067 }
2068 }
2069
2070 static void
uw_advance_context(struct _Unwind_Context * context,_Unwind_FrameState * fs)2071 uw_advance_context (struct _Unwind_Context *context, _Unwind_FrameState *fs)
2072 {
2073 uw_update_context (context, fs);
2074 }
2075
2076 /* Fill in CONTEXT for top-of-stack. The only valid registers at this
2077 level will be the return address and the CFA. Note that CFA = SP+16. */
2078
2079 #define uw_init_context(CONTEXT) \
2080 do { \
2081 /* ??? There is a whole lot o code in uw_install_context that \
2082 tries to avoid spilling the entire machine state here. We \
2083 should try to make that work again. */ \
2084 __builtin_unwind_init(); \
2085 uw_init_context_1 (CONTEXT, __builtin_ia64_bsp ()); \
2086 } while (0)
2087
2088 static void
uw_init_context_1(struct _Unwind_Context * context,void * bsp)2089 uw_init_context_1 (struct _Unwind_Context *context, void *bsp)
2090 {
2091 void *rp = __builtin_extract_return_addr (__builtin_return_address (0));
2092 /* Set psp to the caller's stack pointer. */
2093 void *psp = __builtin_dwarf_cfa () - 16;
2094 _Unwind_FrameState fs;
2095 unsigned long rnat, tmp1, tmp2;
2096
2097 /* Flush the register stack to memory so that we can access it.
2098 Get rse nat collection for the last incomplete rbs chunk of
2099 registers at the same time. For this RSE needs to be turned
2100 into the mandatory only mode. */
2101 asm ("mov.m %1 = ar.rsc;;\n\t"
2102 "and %2 = 0x1c, %1;;\n\t"
2103 "mov.m ar.rsc = %2;;\n\t"
2104 "flushrs;;\n\t"
2105 "mov.m %0 = ar.rnat;;\n\t"
2106 "mov.m ar.rsc = %1\n\t"
2107 : "=r" (rnat), "=r" (tmp1), "=r" (tmp2));
2108
2109 memset (context, 0, sizeof (struct _Unwind_Context));
2110 context->bsp = (unsigned long) bsp;
2111 /* Set context->regstk_top to lowest rbs address which will use
2112 context->rnat collection. */
2113 context->regstk_top = context->bsp & ~0x1ffULL;
2114 context->rnat = rnat;
2115 context->psp = (unsigned long) psp;
2116 context->rp = (unsigned long) rp;
2117 asm ("mov %0 = sp" : "=r" (context->sp));
2118 asm ("mov %0 = pr" : "=r" (context->pr));
2119 context->pri_unat_loc = &context->initial_unat; /* ??? */
2120
2121 if (uw_frame_state_for (context, &fs) != _URC_NO_REASON)
2122 abort ();
2123
2124 uw_update_context (context, &fs);
2125 }
2126
2127 /* Install (i.e. longjmp to) the contents of TARGET. */
2128
2129 static void __attribute__((noreturn))
uw_install_context(struct _Unwind_Context * current,struct _Unwind_Context * target)2130 uw_install_context (struct _Unwind_Context *current __attribute__((unused)),
2131 struct _Unwind_Context *target)
2132 {
2133 unsigned long ireg_buf[4], ireg_nat = 0, ireg_pr = 0;
2134 long i;
2135
2136 /* Copy integer register data from the target context to a
2137 temporary buffer. Do this so that we can frob AR.UNAT
2138 to get the NaT bits for these registers set properly. */
2139 for (i = 4; i <= 7; ++i)
2140 {
2141 char nat;
2142 void *t = target->ireg[i - 2].loc;
2143 if (t)
2144 {
2145 unw_access_gr (target, i, &ireg_buf[i - 4], &nat, 0);
2146 ireg_nat |= (long)nat << (((size_t)&ireg_buf[i - 4] >> 3) & 0x3f);
2147 /* Set p6 - p9. */
2148 ireg_pr |= 4L << i;
2149 }
2150 }
2151
2152 /* The value in uc_bsp that we've computed is that for the
2153 target function. The value that we install below will be
2154 adjusted by the BR.RET instruction based on the contents
2155 of AR.PFS. So we must unadjust that here. */
2156 target->bsp = (unsigned long)
2157 ia64_rse_skip_regs ((unsigned long *)target->bsp,
2158 (*target->pfs_loc >> 7) & 0x7f);
2159
2160 if (target->bsp < target->regstk_top)
2161 target->rnat = *ia64_rse_rnat_addr ((unsigned long *) target->bsp);
2162
2163 /* Provide assembly with the offsets into the _Unwind_Context. */
2164 asm volatile ("uc_rnat = %0"
2165 : : "i"(offsetof (struct _Unwind_Context, rnat)));
2166 asm volatile ("uc_bsp = %0"
2167 : : "i"(offsetof (struct _Unwind_Context, bsp)));
2168 asm volatile ("uc_psp = %0"
2169 : : "i"(offsetof (struct _Unwind_Context, psp)));
2170 asm volatile ("uc_rp = %0"
2171 : : "i"(offsetof (struct _Unwind_Context, rp)));
2172 asm volatile ("uc_pr = %0"
2173 : : "i"(offsetof (struct _Unwind_Context, pr)));
2174 asm volatile ("uc_gp = %0"
2175 : : "i"(offsetof (struct _Unwind_Context, gp)));
2176 asm volatile ("uc_pfs_loc = %0"
2177 : : "i"(offsetof (struct _Unwind_Context, pfs_loc)));
2178 asm volatile ("uc_unat_loc = %0"
2179 : : "i"(offsetof (struct _Unwind_Context, unat_loc)));
2180 asm volatile ("uc_lc_loc = %0"
2181 : : "i"(offsetof (struct _Unwind_Context, lc_loc)));
2182 asm volatile ("uc_fpsr_loc = %0"
2183 : : "i"(offsetof (struct _Unwind_Context, fpsr_loc)));
2184 asm volatile ("uc_eh_data = %0"
2185 : : "i"(offsetof (struct _Unwind_Context, eh_data)));
2186 asm volatile ("uc_br_loc = %0"
2187 : : "i"(offsetof (struct _Unwind_Context, br_loc)));
2188 asm volatile ("uc_fr_loc = %0"
2189 : : "i"(offsetof (struct _Unwind_Context, fr_loc)));
2190
2191 asm volatile (
2192 /* Load up call-saved non-window integer registers from ireg_buf. */
2193 "add r20 = 8, %1 \n\t"
2194 "mov ar.unat = %2 \n\t"
2195 "mov pr = %3, 0x3c0 \n\t"
2196 ";; \n\t"
2197 "(p6) ld8.fill r4 = [%1] \n\t"
2198 "(p7) ld8.fill r5 = [r20] \n\t"
2199 "add r21 = uc_br_loc + 16, %0 \n\t"
2200 "adds %1 = 16, %1 \n\t"
2201 "adds r20 = 16, r20 \n\t"
2202 ";; \n\t"
2203 "(p8) ld8.fill r6 = [%1] \n\t"
2204 "(p9) ld8.fill r7 = [r20] \n\t"
2205 "add r20 = uc_br_loc + 8, %0 \n\t"
2206 ";; \n\t"
2207 /* Load up call-saved branch registers. */
2208 "ld8 r22 = [r20], 16 \n\t"
2209 "ld8 r23 = [r21], 16 \n\t"
2210 ";; \n\t"
2211 "ld8 r24 = [r20], 16 \n\t"
2212 "ld8 r25 = [r21], uc_fr_loc - (uc_br_loc + 32)\n\t"
2213 ";; \n\t"
2214 "ld8 r26 = [r20], uc_fr_loc + 8 - (uc_br_loc + 40)\n\t"
2215 "ld8 r27 = [r21], 24 \n\t"
2216 "cmp.ne p6, p0 = r0, r22 \n\t"
2217 ";; \n\t"
2218 "ld8 r28 = [r20], 8 \n\t"
2219 "(p6) ld8 r22 = [r22] \n\t"
2220 "cmp.ne p7, p0 = r0, r23 \n\t"
2221 ";; \n\t"
2222 "(p7) ld8 r23 = [r23] \n\t"
2223 "cmp.ne p8, p0 = r0, r24 \n\t"
2224 ";; \n\t"
2225 "(p8) ld8 r24 = [r24] \n\t"
2226 "(p6) mov b1 = r22 \n\t"
2227 "cmp.ne p9, p0 = r0, r25 \n\t"
2228 ";; \n\t"
2229 "(p9) ld8 r25 = [r25] \n\t"
2230 "(p7) mov b2 = r23 \n\t"
2231 "cmp.ne p6, p0 = r0, r26 \n\t"
2232 ";; \n\t"
2233 "(p6) ld8 r26 = [r26] \n\t"
2234 "(p8) mov b3 = r24 \n\t"
2235 "cmp.ne p7, p0 = r0, r27 \n\t"
2236 ";; \n\t"
2237 /* Load up call-saved fp registers. */
2238 "(p7) ldf.fill f2 = [r27] \n\t"
2239 "(p9) mov b4 = r25 \n\t"
2240 "cmp.ne p8, p0 = r0, r28 \n\t"
2241 ";; \n\t"
2242 "(p8) ldf.fill f3 = [r28] \n\t"
2243 "(p6) mov b5 = r26 \n\t"
2244 ";; \n\t"
2245 "ld8 r29 = [r20], 16*8 - 4*8 \n\t"
2246 "ld8 r30 = [r21], 17*8 - 5*8 \n\t"
2247 ";; \n\t"
2248 "ld8 r22 = [r20], 16 \n\t"
2249 "ld8 r23 = [r21], 16 \n\t"
2250 ";; \n\t"
2251 "ld8 r24 = [r20], 16 \n\t"
2252 "ld8 r25 = [r21] \n\t"
2253 "cmp.ne p6, p0 = r0, r29 \n\t"
2254 ";; \n\t"
2255 "ld8 r26 = [r20], 8 \n\t"
2256 "(p6) ldf.fill f4 = [r29] \n\t"
2257 "cmp.ne p7, p0 = r0, r30 \n\t"
2258 ";; \n\t"
2259 "ld8 r27 = [r20], 8 \n\t"
2260 "(p7) ldf.fill f5 = [r30] \n\t"
2261 "cmp.ne p6, p0 = r0, r22 \n\t"
2262 ";; \n\t"
2263 "ld8 r28 = [r20], 8 \n\t"
2264 "(p6) ldf.fill f16 = [r22] \n\t"
2265 "cmp.ne p7, p0 = r0, r23 \n\t"
2266 ";; \n\t"
2267 "ld8 r29 = [r20], 8 \n\t"
2268 "(p7) ldf.fill f17 = [r23] \n\t"
2269 "cmp.ne p6, p0 = r0, r24 \n\t"
2270 ";; \n\t"
2271 "ld8 r22 = [r20], 8 \n\t"
2272 "(p6) ldf.fill f18 = [r24] \n\t"
2273 "cmp.ne p7, p0 = r0, r25 \n\t"
2274 ";; \n\t"
2275 "ld8 r23 = [r20], 8 \n\t"
2276 "(p7) ldf.fill f19 = [r25] \n\t"
2277 "cmp.ne p6, p0 = r0, r26 \n\t"
2278 ";; \n\t"
2279 "ld8 r24 = [r20], 8 \n\t"
2280 "(p6) ldf.fill f20 = [r26] \n\t"
2281 "cmp.ne p7, p0 = r0, r27 \n\t"
2282 ";; \n\t"
2283 "ld8 r25 = [r20], 8 \n\t"
2284 "(p7) ldf.fill f21 = [r27] \n\t"
2285 "cmp.ne p6, p0 = r0, r28 \n\t"
2286 ";; \n\t"
2287 "ld8 r26 = [r20], 8 \n\t"
2288 "(p6) ldf.fill f22 = [r28] \n\t"
2289 "cmp.ne p7, p0 = r0, r29 \n\t"
2290 ";; \n\t"
2291 "ld8 r27 = [r20], 8 \n\t"
2292 ";; \n\t"
2293 "ld8 r28 = [r20], 8 \n\t"
2294 "(p7) ldf.fill f23 = [r29] \n\t"
2295 "cmp.ne p6, p0 = r0, r22 \n\t"
2296 ";; \n\t"
2297 "ld8 r29 = [r20], 8 \n\t"
2298 "(p6) ldf.fill f24 = [r22] \n\t"
2299 "cmp.ne p7, p0 = r0, r23 \n\t"
2300 ";; \n\t"
2301 "(p7) ldf.fill f25 = [r23] \n\t"
2302 "cmp.ne p6, p0 = r0, r24 \n\t"
2303 "cmp.ne p7, p0 = r0, r25 \n\t"
2304 ";; \n\t"
2305 "(p6) ldf.fill f26 = [r24] \n\t"
2306 "(p7) ldf.fill f27 = [r25] \n\t"
2307 "cmp.ne p6, p0 = r0, r26 \n\t"
2308 ";; \n\t"
2309 "(p6) ldf.fill f28 = [r26] \n\t"
2310 "cmp.ne p7, p0 = r0, r27 \n\t"
2311 "cmp.ne p6, p0 = r0, r28 \n\t"
2312 ";; \n\t"
2313 "(p7) ldf.fill f29 = [r27] \n\t"
2314 "(p6) ldf.fill f30 = [r28] \n\t"
2315 "cmp.ne p7, p0 = r0, r29 \n\t"
2316 ";; \n\t"
2317 "(p7) ldf.fill f31 = [r29] \n\t"
2318 "add r20 = uc_rnat, %0 \n\t"
2319 "add r21 = uc_bsp, %0 \n\t"
2320 ";; \n\t"
2321 /* Load the balance of the thread state from the context. */
2322 "ld8 r22 = [r20], uc_psp - uc_rnat \n\t"
2323 "ld8 r23 = [r21], uc_gp - uc_bsp \n\t"
2324 ";; \n\t"
2325 "ld8 r24 = [r20], uc_pfs_loc - uc_psp \n\t"
2326 "ld8 r1 = [r21], uc_rp - uc_gp \n\t"
2327 ";; \n\t"
2328 "ld8 r25 = [r20], uc_unat_loc - uc_pfs_loc\n\t"
2329 "ld8 r26 = [r21], uc_pr - uc_rp \n\t"
2330 ";; \n\t"
2331 "ld8 r27 = [r20], uc_lc_loc - uc_unat_loc\n\t"
2332 "ld8 r28 = [r21], uc_fpsr_loc - uc_pr \n\t"
2333 ";; \n\t"
2334 "ld8 r29 = [r20], uc_eh_data - uc_lc_loc\n\t"
2335 "ld8 r30 = [r21], uc_eh_data + 8 - uc_fpsr_loc\n\t"
2336 ";; \n\t"
2337 /* Load data for the exception handler. */
2338 "ld8 r15 = [r20], 16 \n\t"
2339 "ld8 r16 = [r21], 16 \n\t"
2340 ";; \n\t"
2341 "ld8 r17 = [r20] \n\t"
2342 "ld8 r18 = [r21] \n\t"
2343 ";; \n\t"
2344 /* Install the balance of the thread state loaded above. */
2345 "cmp.ne p6, p0 = r0, r25 \n\t"
2346 "cmp.ne p7, p0 = r0, r27 \n\t"
2347 ";; \n\t"
2348 "(p6) ld8 r25 = [r25] \n\t"
2349 "(p7) ld8 r27 = [r27] \n\t"
2350 ";; \n\t"
2351 "(p7) mov.m ar.unat = r27 \n\t"
2352 "(p6) mov.i ar.pfs = r25 \n\t"
2353 "cmp.ne p9, p0 = r0, r29 \n\t"
2354 ";; \n\t"
2355 "(p9) ld8 r29 = [r29] \n\t"
2356 "cmp.ne p6, p0 = r0, r30 \n\t"
2357 ";; \n\t"
2358 "(p6) ld8 r30 = [r30] \n\t"
2359 /* Don't clobber p6-p9, which are in use at present. */
2360 "mov pr = r28, ~0x3c0 \n\t"
2361 "(p9) mov.i ar.lc = r29 \n\t"
2362 ";; \n\t"
2363 "mov.m r25 = ar.rsc \n\t"
2364 "(p6) mov.m ar.fpsr = r30 \n\t"
2365 ";; \n\t"
2366 "and r29 = 0x1c, r25 \n\t"
2367 "mov b0 = r26 \n\t"
2368 ";; \n\t"
2369 "mov.m ar.rsc = r29 \n\t"
2370 ";; \n\t"
2371 /* This must be done before setting AR.BSPSTORE, otherwise
2372 AR.BSP will be initialized with a random displacement
2373 below the value we want, based on the current number of
2374 dirty stacked registers. */
2375 "loadrs \n\t"
2376 "invala \n\t"
2377 ";; \n\t"
2378 "mov.m ar.bspstore = r23 \n\t"
2379 ";; \n\t"
2380 "mov.m ar.rnat = r22 \n\t"
2381 ";; \n\t"
2382 "mov.m ar.rsc = r25 \n\t"
2383 "mov sp = r24 \n\t"
2384 "br.ret.sptk.few b0"
2385 : : "r"(target), "r"(ireg_buf), "r"(ireg_nat), "r"(ireg_pr)
2386 : "r15", "r16", "r17", "r18", "r20", "r21", "r22",
2387 "r23", "r24", "r25", "r26", "r27", "r28", "r29",
2388 "r30", "r31");
2389 /* NOTREACHED */
2390 while (1);
2391 }
2392
2393 static inline _Unwind_Ptr
uw_identify_context(struct _Unwind_Context * context)2394 uw_identify_context (struct _Unwind_Context *context)
2395 {
2396 return _Unwind_GetIP (context);
2397 }
2398
2399 #include "unwind.inc"
2400
2401 #if defined (USE_GAS_SYMVER) && defined (SHARED) && defined (USE_LIBUNWIND_EXCEPTIONS)
2402 alias (_Unwind_Backtrace);
2403 alias (_Unwind_DeleteException);
2404 alias (_Unwind_FindEnclosingFunction);
2405 alias (_Unwind_ForcedUnwind);
2406 alias (_Unwind_GetBSP);
2407 alias (_Unwind_GetCFA);
2408 alias (_Unwind_GetGR);
2409 alias (_Unwind_GetIP);
2410 alias (_Unwind_GetLanguageSpecificData);
2411 alias (_Unwind_GetRegionStart);
2412 alias (_Unwind_RaiseException);
2413 alias (_Unwind_Resume);
2414 alias (_Unwind_Resume_or_Rethrow);
2415 alias (_Unwind_SetGR);
2416 alias (_Unwind_SetIP);
2417 #endif
2418
2419 #endif
2420