?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
daily update
[binutils.git] / binutils / unwind-ia64.c
blob803a5fa5415ee6b49e0ec3b78ace821e4b6f4f0f
1 /* unwind-ia64.c -- utility routines to dump IA-64 unwind info for readelf.
2 Copyright 2000, 2001 Free Software Foundation, Inc.
3 Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
4
5 This file is part of GNU Binutils.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20
21 #include "unwind-ia64.h"
22 #include <stdio.h>
23 #include <string.h>
24
25 #if __GNUC__ >= 2
26 /* Define BFD64 here, even if our default architecture is 32 bit ELF
27 as this will allow us to read in and parse 64bit and 32bit ELF files.
28 Only do this if we belive that the compiler can support a 64 bit
29 data type. For now we only rely on GCC being able to do this. */
30 #define BFD64
31 #endif
32 #include "bfd.h"
33
34 static bfd_vma unw_rlen = 0;
35
36 static void unw_print_brmask PARAMS ((char *, unsigned int));
37 static void unw_print_grmask PARAMS ((char *, unsigned int));
38 static void unw_print_frmask PARAMS ((char *, unsigned int));
39 static void unw_print_abreg PARAMS ((char *, unsigned int));
40 static void unw_print_xyreg PARAMS ((char *, unsigned int, unsigned int));
41
42 static void
43 unw_print_brmask (cp, mask)
44 char * cp;
45 unsigned int mask;
46 {
47 int sep = 0;
48 int i;
49
50 for (i = 0; mask && (i < 5); ++i)
51 {
52 if (mask & 1)
53 {
54 if (sep)
55 *cp++ = ',';
56 *cp++ = 'b';
57 *cp++ = i + 1 + '0';
58 sep = 1;
59 }
60 mask >>= 1;
61 }
62 *cp = '\0';
63 }
64
65 static void
66 unw_print_grmask (cp, mask)
67 char * cp;
68 unsigned int mask;
69 {
70 int sep = 0;
71 int i;
72
73 for (i = 0; i < 4; ++i)
74 {
75 if (mask & 1)
76 {
77 if (sep)
78 *cp++ = ',';
79 *cp++ = 'r';
80 *cp++ = i + 4 + '0';
81 sep = 1;
82 }
83 mask >>= 1;
84 }
85 *cp = '\0';
86 }
87
88 static void
89 unw_print_frmask (cp, mask)
90 char * cp;
91 unsigned int mask;
92 {
93 int sep = 0;
94 int i;
95
96 for (i = 0; i < 20; ++i)
97 {
98 if (mask & 1)
99 {
100 if (sep)
101 *cp++ = ',';
102 *cp++ = 'f';
103 if (i < 4)
104 *cp++ = i + 2 + '0';
105 else
106 {
107 *cp++ = (i + 2) / 10 + 1 + '0';
108 *cp++ = (i + 2) % 10 + '0';
109 }
110 sep = 1;
111 }
112 mask >>= 1;
113 }
114 *cp = '\0';
115 }
116
117 static void
118 unw_print_abreg (cp, abreg)
119 char * cp;
120 unsigned int abreg;
121 {
122 static const char *special_reg[16] =
123 {
124 "pr", "psp", "@priunat", "rp", "ar.bsp", "ar.bspstore", "ar.rnat",
125 "ar.unat", "ar.fpsr", "ar.pfs", "ar.lc",
126 "Unknown11", "Unknown12", "Unknown13", "Unknown14", "Unknown15"
127 };
128
129 switch ((abreg >> 5) & 0x3)
130 {
131 case 0: /* gr */
132 sprintf (cp, "r%u", (abreg & 0x1f));
133 break;
134
135 case 1: /* fr */
136 sprintf (cp, "f%u", (abreg & 0x1f));
137 break;
138
139 case 2: /* br */
140 sprintf (cp, "b%u", (abreg & 0x1f));
141 break;
142
143 case 3: /* special */
144 strcpy (cp, special_reg[abreg & 0xf]);
145 break;
146 }
147 }
148
149 static void
150 unw_print_xyreg (cp, x, ytreg)
151 char * cp;
152 unsigned int x;
153 unsigned int ytreg;
154 {
155 switch ((x << 1) | ((ytreg >> 7) & 1))
156 {
157 case 0: /* gr */
158 sprintf (cp, "r%u", (ytreg & 0x1f));
159 break;
160
161 case 1: /* fr */
162 sprintf (cp, "f%u", (ytreg & 0x1f));
163 break;
164
165 case 2: /* br */
166 sprintf (cp, "b%u", (ytreg & 0x1f));
167 break;
168 }
169 }
170
171 #define UNW_REG_BSP "bsp"
172 #define UNW_REG_BSPSTORE "bspstore"
173 #define UNW_REG_FPSR "fpsr"
174 #define UNW_REG_LC "lc"
175 #define UNW_REG_PFS "pfs"
176 #define UNW_REG_PR "pr"
177 #define UNW_REG_PSP "psp"
178 #define UNW_REG_RNAT "rnat"
179 #define UNW_REG_RP "rp"
180 #define UNW_REG_UNAT "unat"
181
182 typedef bfd_vma unw_word;
183
184 #define UNW_DEC_BAD_CODE(code) \
185 printf ("Unknown code 0x%02x\n", code)
186
187 #define UNW_DEC_PROLOGUE(fmt, body, rlen, arg) \
188 do \
189 { \
190 unw_rlen = rlen; \
191 *(int *)arg = body; \
192 printf (" %s:%s(rlen=%lu)\n", \
193 fmt, body ? "body" : "prologue", (unsigned long) rlen); \
194 } \
195 while (0)
196
197 #define UNW_DEC_PROLOGUE_GR(fmt, rlen, mask, grsave, arg) \
198 do \
199 { \
200 char regname[16], maskstr[64], *sep; \
201 \
202 unw_rlen = rlen; \
203 *(int *)arg = 0; \
204 \
205 maskstr[0] = '\0'; \
206 sep = ""; \
207 if (mask & 0x8) \
208 { \
209 strcat (maskstr, "rp"); \
210 sep = ","; \
211 } \
212 if (mask & 0x4) \
213 { \
214 strcat (maskstr, sep); \
215 strcat (maskstr, "ar.pfs"); \
216 sep = ","; \
217 } \
218 if (mask & 0x2) \
219 { \
220 strcat (maskstr, sep); \
221 strcat (maskstr, "psp"); \
222 sep = ","; \
223 } \
224 if (mask & 0x1) \
225 { \
226 strcat (maskstr, sep); \
227 strcat (maskstr, "pr"); \
228 } \
229 sprintf (regname, "r%u", grsave); \
230 printf (" %s:prologue_gr(mask=[%s],grsave=%s,rlen=%lu)\n", \
231 fmt, maskstr, regname, (unsigned long) rlen); \
232 } \
233 while (0)
234
235 #define UNW_DEC_FR_MEM(fmt, frmask, arg) \
236 do \
237 { \
238 char frstr[200]; \
239 \
240 unw_print_frmask (frstr, frmask); \
241 printf ("\t%s:fr_mem(frmask=[%s])\n", fmt, frstr); \
242 } \
243 while (0)
244
245 #define UNW_DEC_GR_MEM(fmt, grmask, arg) \
246 do \
247 { \
248 char grstr[200]; \
249 \
250 unw_print_grmask (grstr, grmask); \
251 printf ("\t%s:gr_mem(grmask=[%s])\n", fmt, grstr); \
252 } \
253 while (0)
254
255 #define UNW_DEC_FRGR_MEM(fmt, grmask, frmask, arg) \
256 do \
257 { \
258 char frstr[200], grstr[20]; \
259 \
260 unw_print_grmask (grstr, grmask); \
261 unw_print_frmask (frstr, frmask); \
262 printf ("\t%s:frgr_mem(grmask=[%s],frmask=[%s])\n", fmt, grstr, frstr); \
263 } \
264 while (0)
265
266 #define UNW_DEC_BR_MEM(fmt, brmask, arg) \
267 do \
268 { \
269 char brstr[20]; \
270 \
271 unw_print_brmask (brstr, brmask); \
272 printf ("\t%s:br_mem(brmask=[%s])\n", fmt, brstr); \
273 } \
274 while (0)
275
276 #define UNW_DEC_BR_GR(fmt, brmask, gr, arg) \
277 do \
278 { \
279 char brstr[20]; \
280 \
281 unw_print_brmask (brstr, brmask); \
282 printf ("\t%s:br_gr(brmask=[%s],gr=r%u)\n", fmt, brstr, gr); \
283 } \
284 while (0)
285
286 #define UNW_DEC_REG_GR(fmt, src, dst, arg) \
287 printf ("\t%s:%s_gr(reg=r%u)\n", fmt, src, dst)
288
289 #define UNW_DEC_RP_BR(fmt, dst, arg) \
290 printf ("\t%s:rp_br(reg=b%u)\n", fmt, dst)
291
292 #define UNW_DEC_REG_WHEN(fmt, reg, t, arg) \
293 printf ("\t%s:%s_when(t=%lu)\n", fmt, reg, (unsigned long) t)
294
295 #define UNW_DEC_REG_SPREL(fmt, reg, spoff, arg) \
296 printf ("\t%s:%s_sprel(spoff=0x%lx)\n", \
297 fmt, reg, 4*(unsigned long)spoff)
298
299 #define UNW_DEC_REG_PSPREL(fmt, reg, pspoff, arg) \
300 printf ("\t%s:%s_psprel(pspoff=0x10-0x%lx)\n", \
301 fmt, reg, 4*(unsigned long)pspoff)
302
303 #define UNW_DEC_GR_GR(fmt, grmask, gr, arg) \
304 do \
305 { \
306 char grstr[20]; \
307 \
308 unw_print_grmask (grstr, grmask); \
309 printf ("\t%s:gr_gr(grmask=[%s],r%u)\n", fmt, grstr, gr); \
310 } \
311 while (0)
312
313 #define UNW_DEC_ABI(fmt, abi, context, arg) \
314 do \
315 { \
316 static const char *abiname[] = \
317 { \
318 "@svr4", "@hpux", "@nt" \
319 }; \
320 char buf[20]; \
321 const char *abistr = buf; \
322 \
323 if (abi < 3) \
324 abistr = abiname[abi]; \
325 else \
326 sprintf (buf, "0x%x", abi); \
327 printf ("\t%s:unwabi(abi=%s,context=0x%02x)\n", \
328 fmt, abistr, context); \
329 } \
330 while (0)
331
332 #define UNW_DEC_PRIUNAT_GR(fmt, r, arg) \
333 printf ("\t%s:priunat_gr(reg=r%u)\n", fmt, r)
334
335 #define UNW_DEC_PRIUNAT_WHEN_GR(fmt, t, arg) \
336 printf ("\t%s:priunat_when_gr(t=%lu)\n", fmt, (unsigned long) t)
337
338 #define UNW_DEC_PRIUNAT_WHEN_MEM(fmt, t, arg) \
339 printf ("\t%s:priunat_when_mem(t=%lu)\n", fmt, (unsigned long) t)
340
341 #define UNW_DEC_PRIUNAT_PSPREL(fmt, pspoff, arg) \
342 printf ("\t%s:priunat_psprel(pspoff=0x10-0x%lx)\n", \
343 fmt, 4*(unsigned long)pspoff)
344
345 #define UNW_DEC_PRIUNAT_SPREL(fmt, spoff, arg) \
346 printf ("\t%s:priunat_sprel(spoff=0x%lx)\n", \
347 fmt, 4*(unsigned long)spoff)
348
349 #define UNW_DEC_MEM_STACK_F(fmt, t, size, arg) \
350 printf ("\t%s:mem_stack_f(t=%lu,size=%lu)\n", \
351 fmt, (unsigned long) t, 16*(unsigned long)size)
352
353 #define UNW_DEC_MEM_STACK_V(fmt, t, arg) \
354 printf ("\t%s:mem_stack_v(t=%lu)\n", fmt, (unsigned long) t)
355
356 #define UNW_DEC_SPILL_BASE(fmt, pspoff, arg) \
357 printf ("\t%s:spill_base(pspoff=0x10-0x%lx)\n", \
358 fmt, 4*(unsigned long)pspoff)
359
360 #define UNW_DEC_SPILL_MASK(fmt, dp, arg) \
361 do \
362 { \
363 static const char * spill_type = "-frb"; \
364 unsigned const char * imaskp = dp; \
365 unsigned char mask = 0; \
366 bfd_vma insn = 0; \
367 \
368 printf ("\t%s:spill_mask(imask=[", fmt); \
369 for (insn = 0; insn < unw_rlen; ++insn) \
370 { \
371 if ((insn % 4) == 0) \
372 mask = *imaskp++; \
373 if (insn > 0 && (insn % 3) == 0) \
374 putchar (','); \
375 putchar (spill_type[(mask >> (2 * (3 - (insn & 0x3)))) & 0x3]); \
376 } \
377 printf ("])\n"); \
378 dp = imaskp; \
379 } \
380 while (0)
381
382 #define UNW_DEC_SPILL_SPREL(fmt, t, abreg, spoff, arg) \
383 do \
384 { \
385 char regname[10]; \
386 \
387 unw_print_abreg (regname, abreg); \
388 printf ("\t%s:spill_sprel(reg=%s,t=%lu,spoff=0x%lx)\n", \
389 fmt, regname, (unsigned long) t, 4*(unsigned long)off); \
390 } \
391 while (0)
392
393 #define UNW_DEC_SPILL_PSPREL(fmt, t, abreg, pspoff, arg) \
394 do \
395 { \
396 char regname[10]; \
397 \
398 unw_print_abreg (regname, abreg); \
399 printf ("\t%s:spill_psprel(reg=%s,t=%lu,pspoff=0x10-0x%lx)\n", \
400 fmt, regname, (unsigned long) t, 4*(unsigned long)pspoff); \
401 } \
402 while (0)
403
404 #define UNW_DEC_RESTORE(fmt, t, abreg, arg) \
405 do \
406 { \
407 char regname[10]; \
408 \
409 unw_print_abreg (regname, abreg); \
410 printf ("\t%s:restore(t=%lu,reg=%s)\n", \
411 fmt, (unsigned long) t, regname); \
412 } \
413 while (0)
414
415 #define UNW_DEC_SPILL_REG(fmt, t, abreg, x, ytreg, arg) \
416 do \
417 { \
418 char abregname[10], tregname[10]; \
419 \
420 unw_print_abreg (abregname, abreg); \
421 unw_print_xyreg (tregname, x, ytreg); \
422 printf ("\t%s:spill_reg(t=%lu,reg=%s,treg=%s)\n", \
423 fmt, (unsigned long) t, abregname, tregname); \
424 } \
425 while (0)
426
427 #define UNW_DEC_SPILL_SPREL_P(fmt, qp, t, abreg, spoff, arg) \
428 do \
429 { \
430 char regname[20]; \
431 \
432 unw_print_abreg (regname, abreg); \
433 printf ("\t%s:spill_sprel_p(qp=p%u,t=%lu,reg=%s,spoff=0x%lx)\n", \
434 fmt, qp, (unsigned long) t, regname, 4 * (unsigned long)spoff); \
435 } \
436 while (0)
437
438 #define UNW_DEC_SPILL_PSPREL_P(fmt, qp, t, abreg, pspoff, arg) \
439 do \
440 { \
441 char regname[20]; \
442 \
443 unw_print_abreg (regname, abreg); \
444 printf ("\t%s:spill_psprel_p(qp=p%u,t=%lu,reg=%s,pspoff=0x10-0x%lx)\n",\
445 fmt, qp, (unsigned long) t, regname, 4*(unsigned long)pspoff);\
446 } \
447 while (0)
448
449 #define UNW_DEC_RESTORE_P(fmt, qp, t, abreg, arg) \
450 do \
451 { \
452 char regname[20]; \
453 \
454 unw_print_abreg (regname, abreg); \
455 printf ("\t%s:restore_p(qp=p%u,t=%lu,reg=%s)\n", \
456 fmt, qp, (unsigned long) t, regname); \
457 } \
458 while (0)
459
460 #define UNW_DEC_SPILL_REG_P(fmt, qp, t, abreg, x, ytreg, arg) \
461 do \
462 { \
463 char regname[20], tregname[20]; \
464 \
465 unw_print_abreg (regname, abreg); \
466 unw_print_xyreg (tregname, x, ytreg); \
467 printf ("\t%s:spill_reg_p(qp=p%u,t=%lu,reg=%s,treg=%s)\n", \
468 fmt, qp, (unsigned long) t, regname, tregname); \
469 } \
470 while (0)
471
472 #define UNW_DEC_LABEL_STATE(fmt, label, arg) \
473 printf ("\t%s:label_state(label=%lu)\n", fmt, (unsigned long) label)
474
475 #define UNW_DEC_COPY_STATE(fmt, label, arg) \
476 printf ("\t%s:copy_state(label=%lu)\n", fmt, (unsigned long) label)
477
478 #define UNW_DEC_EPILOGUE(fmt, t, ecount, arg) \
479 printf ("\t%s:epilogue(t=%lu,ecount=%lu)\n", \
480 fmt, (unsigned long) t, (unsigned long) ecount)
481
482 /*
483 * Generic IA-64 unwind info decoder.
484 *
485 * This file is used both by the Linux kernel and objdump. Please
486 * keep the two copies of this file in sync (modulo differences in the
487 * prototypes...).
488 *
489 * You need to customize the decoder by defining the following
490 * macros/constants before including this file:
491 *
492 * Types:
493 * unw_word Unsigned integer type with at least 64 bits
494 *
495 * Register names:
496 * UNW_REG_BSP
497 * UNW_REG_BSPSTORE
498 * UNW_REG_FPSR
499 * UNW_REG_LC
500 * UNW_REG_PFS
501 * UNW_REG_PR
502 * UNW_REG_RNAT
503 * UNW_REG_PSP
504 * UNW_REG_RP
505 * UNW_REG_UNAT
506 *
507 * Decoder action macros:
508 * UNW_DEC_BAD_CODE(code)
509 * UNW_DEC_ABI(fmt,abi,context,arg)
510 * UNW_DEC_BR_GR(fmt,brmask,gr,arg)
511 * UNW_DEC_BR_MEM(fmt,brmask,arg)
512 * UNW_DEC_COPY_STATE(fmt,label,arg)
513 * UNW_DEC_EPILOGUE(fmt,t,ecount,arg)
514 * UNW_DEC_FRGR_MEM(fmt,grmask,frmask,arg)
515 * UNW_DEC_FR_MEM(fmt,frmask,arg)
516 * UNW_DEC_GR_GR(fmt,grmask,gr,arg)
517 * UNW_DEC_GR_MEM(fmt,grmask,arg)
518 * UNW_DEC_LABEL_STATE(fmt,label,arg)
519 * UNW_DEC_MEM_STACK_F(fmt,t,size,arg)
520 * UNW_DEC_MEM_STACK_V(fmt,t,arg)
521 * UNW_DEC_PRIUNAT_GR(fmt,r,arg)
522 * UNW_DEC_PRIUNAT_WHEN_GR(fmt,t,arg)
523 * UNW_DEC_PRIUNAT_WHEN_MEM(fmt,t,arg)
524 * UNW_DEC_PRIUNAT_WHEN_PSPREL(fmt,pspoff,arg)
525 * UNW_DEC_PRIUNAT_WHEN_SPREL(fmt,spoff,arg)
526 * UNW_DEC_PROLOGUE(fmt,body,rlen,arg)
527 * UNW_DEC_PROLOGUE_GR(fmt,rlen,mask,grsave,arg)
528 * UNW_DEC_REG_PSPREL(fmt,reg,pspoff,arg)
529 * UNW_DEC_REG_REG(fmt,src,dst,arg)
530 * UNW_DEC_REG_SPREL(fmt,reg,spoff,arg)
531 * UNW_DEC_REG_WHEN(fmt,reg,t,arg)
532 * UNW_DEC_RESTORE(fmt,t,abreg,arg)
533 * UNW_DEC_RESTORE_P(fmt,qp,t,abreg,arg)
534 * UNW_DEC_SPILL_BASE(fmt,pspoff,arg)
535 * UNW_DEC_SPILL_MASK(fmt,imaskp,arg)
536 * UNW_DEC_SPILL_PSPREL(fmt,t,abreg,pspoff,arg)
537 * UNW_DEC_SPILL_PSPREL_P(fmt,qp,t,abreg,pspoff,arg)
538 * UNW_DEC_SPILL_REG(fmt,t,abreg,x,ytreg,arg)
539 * UNW_DEC_SPILL_REG_P(fmt,qp,t,abreg,x,ytreg,arg)
540 * UNW_DEC_SPILL_SPREL(fmt,t,abreg,spoff,arg)
541 * UNW_DEC_SPILL_SPREL_P(fmt,qp,t,abreg,pspoff,arg)
542 */
543
544 static unw_word unw_decode_uleb128 PARAMS ((const unsigned char **));
545 static const unsigned char *unw_decode_x1 PARAMS ((const unsigned char *,
546 unsigned int, void *));
547 static const unsigned char *unw_decode_x2 PARAMS ((const unsigned char *,
548 unsigned int, void *));
549 static const unsigned char *unw_decode_x3 PARAMS ((const unsigned char *,
550 unsigned int, void *));
551 static const unsigned char *unw_decode_x4 PARAMS ((const unsigned char *,
552 unsigned int, void *));
553 static const unsigned char *unw_decode_r1 PARAMS ((const unsigned char *,
554 unsigned int, void *));
555 static const unsigned char *unw_decode_r2 PARAMS ((const unsigned char *,
556 unsigned int, void *));
557 static const unsigned char *unw_decode_r3 PARAMS ((const unsigned char *,
558 unsigned int, void *));
559 static const unsigned char *unw_decode_p1 PARAMS ((const unsigned char *,
560 unsigned int, void *));
561 static const unsigned char *unw_decode_p2_p5 PARAMS ((const unsigned char *,
562 unsigned int, void *));
563 static const unsigned char *unw_decode_p6 PARAMS ((const unsigned char *,
564 unsigned int, void *));
565 static const unsigned char *unw_decode_p7_p10 PARAMS ((const unsigned char *,
566 unsigned int, void *));
567 static const unsigned char *unw_decode_b1 PARAMS ((const unsigned char *,
568 unsigned int, void *));
569 static const unsigned char *unw_decode_b2 PARAMS ((const unsigned char *,
570 unsigned int, void *));
571 static const unsigned char *unw_decode_b3_x4 PARAMS ((const unsigned char *,
572 unsigned int, void *));
573
574 static unw_word
575 unw_decode_uleb128 (dpp)
576 const unsigned char **dpp;
577 {
578 unsigned shift = 0;
579 unw_word byte, result = 0;
580 const unsigned char *bp = *dpp;
581
582 while (1)
583 {
584 byte = *bp++;
585 result |= (byte & 0x7f) << shift;
586
587 if ((byte & 0x80) == 0)
588 break;
589
590 shift += 7;
591 }
592
593 *dpp = bp;
594
595 return result;
596 }
597
598 static const unsigned char *
599 unw_decode_x1 (dp, code, arg)
600 const unsigned char * dp;
601 unsigned int code ATTRIBUTE_UNUSED;
602 void * arg ATTRIBUTE_UNUSED;
603 {
604 unsigned char byte1, abreg;
605 unw_word t, off;
606
607 byte1 = *dp++;
608 t = unw_decode_uleb128 (&dp);
609 off = unw_decode_uleb128 (&dp);
610 abreg = (byte1 & 0x7f);
611 if (byte1 & 0x80)
612 UNW_DEC_SPILL_SPREL ("X1", t, abreg, off, arg);
613 else
614 UNW_DEC_SPILL_PSPREL ("X1", t, abreg, off, arg);
615 return dp;
616 }
617
618 static const unsigned char *
619 unw_decode_x2 (dp, code, arg)
620 const unsigned char * dp;
621 unsigned int code ATTRIBUTE_UNUSED;
622 void * arg ATTRIBUTE_UNUSED;
623 {
624 unsigned char byte1, byte2, abreg, x, ytreg;
625 unw_word t;
626
627 byte1 = *dp++;
628 byte2 = *dp++;
629 t = unw_decode_uleb128 (&dp);
630 abreg = (byte1 & 0x7f);
631 ytreg = byte2;
632 x = (byte1 >> 7) & 1;
633 if ((byte1 & 0x80) == 0 && ytreg == 0)
634 UNW_DEC_RESTORE ("X2", t, abreg, arg);
635 else
636 UNW_DEC_SPILL_REG ("X2", t, abreg, x, ytreg, arg);
637 return dp;
638 }
639
640 static const unsigned char *
641 unw_decode_x3 (dp, code, arg)
642 const unsigned char * dp;
643 unsigned int code ATTRIBUTE_UNUSED;
644 void * arg ATTRIBUTE_UNUSED;
645 {
646 unsigned char byte1, byte2, abreg, qp;
647 unw_word t, off;
648
649 byte1 = *dp++;
650 byte2 = *dp++;
651 t = unw_decode_uleb128 (&dp);
652 off = unw_decode_uleb128 (&dp);
653
654 qp = (byte1 & 0x3f);
655 abreg = (byte2 & 0x7f);
656
657 if (byte1 & 0x80)
658 UNW_DEC_SPILL_SPREL_P ("X3", qp, t, abreg, off, arg);
659 else
660 UNW_DEC_SPILL_PSPREL_P ("X3", qp, t, abreg, off, arg);
661 return dp;
662 }
663
664 static const unsigned char *
665 unw_decode_x4 (dp, code, arg)
666 const unsigned char * dp;
667 unsigned int code ATTRIBUTE_UNUSED;
668 void * arg ATTRIBUTE_UNUSED;
669 {
670 unsigned char byte1, byte2, byte3, qp, abreg, x, ytreg;
671 unw_word t;
672
673 byte1 = *dp++;
674 byte2 = *dp++;
675 byte3 = *dp++;
676 t = unw_decode_uleb128 (&dp);
677
678 qp = (byte1 & 0x3f);
679 abreg = (byte2 & 0x7f);
680 x = (byte2 >> 7) & 1;
681 ytreg = byte3;
682
683 if ((byte2 & 0x80) == 0 && byte3 == 0)
684 UNW_DEC_RESTORE_P ("X4", qp, t, abreg, arg);
685 else
686 UNW_DEC_SPILL_REG_P ("X4", qp, t, abreg, x, ytreg, arg);
687 return dp;
688 }
689
690 static const unsigned char *
691 unw_decode_r1 (dp, code, arg)
692 const unsigned char *dp;
693 unsigned int code;
694 void *arg;
695 {
696 int body = (code & 0x20) != 0;
697 unw_word rlen;
698
699 rlen = (code & 0x1f);
700 UNW_DEC_PROLOGUE ("R1", body, rlen, arg);
701 return dp;
702 }
703
704 static const unsigned char *
705 unw_decode_r2 (dp, code, arg)
706 const unsigned char *dp;
707 unsigned int code;
708 void *arg;
709 {
710 unsigned char byte1, mask, grsave;
711 unw_word rlen;
712
713 byte1 = *dp++;
714
715 mask = ((code & 0x7) << 1) | ((byte1 >> 7) & 1);
716 grsave = (byte1 & 0x7f);
717 rlen = unw_decode_uleb128 (& dp);
718 UNW_DEC_PROLOGUE_GR ("R2", rlen, mask, grsave, arg);
719 return dp;
720 }
721
722 static const unsigned char *
723 unw_decode_r3 (dp, code, arg)
724 const unsigned char *dp;
725 unsigned int code;
726 void *arg;
727 {
728 unw_word rlen;
729
730 rlen = unw_decode_uleb128 (& dp);
731 UNW_DEC_PROLOGUE ("R3", ((code & 0x3) == 1), rlen, arg);
732 return dp;
733 }
734
735 static const unsigned char *
736 unw_decode_p1 (dp, code, arg)
737 const unsigned char * dp;
738 unsigned int code;
739 void * arg ATTRIBUTE_UNUSED;
740 {
741 unsigned char brmask = (code & 0x1f);
742
743 UNW_DEC_BR_MEM ("P1", brmask, arg);
744 return dp;
745 }
746
747 static const unsigned char *
748 unw_decode_p2_p5 (dp, code, arg)
749 const unsigned char * dp;
750 unsigned int code;
751 void * arg ATTRIBUTE_UNUSED;
752 {
753 if ((code & 0x10) == 0)
754 {
755 unsigned char byte1 = *dp++;
756
757 UNW_DEC_BR_GR ("P2", ((code & 0xf) << 1) | ((byte1 >> 7) & 1),
758 (byte1 & 0x7f), arg);
759 }
760 else if ((code & 0x08) == 0)
761 {
762 unsigned char byte1 = *dp++, r, dst;
763
764 r = ((code & 0x7) << 1) | ((byte1 >> 7) & 1);
765 dst = (byte1 & 0x7f);
766 switch (r)
767 {
768 case 0:
769 UNW_DEC_REG_GR ("P3", UNW_REG_PSP, dst, arg);
770 break;
771 case 1:
772 UNW_DEC_REG_GR ("P3", UNW_REG_RP, dst, arg);
773 break;
774 case 2:
775 UNW_DEC_REG_GR ("P3", UNW_REG_PFS, dst, arg);
776 break;
777 case 3:
778 UNW_DEC_REG_GR ("P3", UNW_REG_PR, dst, arg);
779 break;
780 case 4:
781 UNW_DEC_REG_GR ("P3", UNW_REG_UNAT, dst, arg);
782 break;
783 case 5:
784 UNW_DEC_REG_GR ("P3", UNW_REG_LC, dst, arg);
785 break;
786 case 6:
787 UNW_DEC_RP_BR ("P3", dst, arg);
788 break;
789 case 7:
790 UNW_DEC_REG_GR ("P3", UNW_REG_RNAT, dst, arg);
791 break;
792 case 8:
793 UNW_DEC_REG_GR ("P3", UNW_REG_BSP, dst, arg);
794 break;
795 case 9:
796 UNW_DEC_REG_GR ("P3", UNW_REG_BSPSTORE, dst, arg);
797 break;
798 case 10:
799 UNW_DEC_REG_GR ("P3", UNW_REG_FPSR, dst, arg);
800 break;
801 case 11:
802 UNW_DEC_PRIUNAT_GR ("P3", dst, arg);
803 break;
804 default:
805 UNW_DEC_BAD_CODE (r);
806 break;
807 }
808 }
809 else if ((code & 0x7) == 0)
810 UNW_DEC_SPILL_MASK ("P4", dp, arg);
811 else if ((code & 0x7) == 1)
812 {
813 unw_word grmask, frmask, byte1, byte2, byte3;
814
815 byte1 = *dp++;
816 byte2 = *dp++;
817 byte3 = *dp++;
818 grmask = ((byte1 >> 4) & 0xf);
819 frmask = ((byte1 & 0xf) << 16) | (byte2 << 8) | byte3;
820 UNW_DEC_FRGR_MEM ("P5", grmask, frmask, arg);
821 }
822 else
823 UNW_DEC_BAD_CODE (code);
824
825 return dp;
826 }
827
828 static const unsigned char *
829 unw_decode_p6 (dp, code, arg)
830 const unsigned char * dp;
831 unsigned int code;
832 void * arg ATTRIBUTE_UNUSED;
833 {
834 int gregs = (code & 0x10) != 0;
835 unsigned char mask = (code & 0x0f);
836
837 if (gregs)
838 UNW_DEC_GR_MEM ("P6", mask, arg);
839 else
840 UNW_DEC_FR_MEM ("P6", mask, arg);
841 return dp;
842 }
843
844 static const unsigned char *
845 unw_decode_p7_p10 (dp, code, arg)
846 const unsigned char *dp;
847 unsigned int code;
848 void *arg;
849 {
850 unsigned char r, byte1, byte2;
851 unw_word t, size;
852
853 if ((code & 0x10) == 0)
854 {
855 r = (code & 0xf);
856 t = unw_decode_uleb128 (&dp);
857 switch (r)
858 {
859 case 0:
860 size = unw_decode_uleb128 (&dp);
861 UNW_DEC_MEM_STACK_F ("P7", t, size, arg);
862 break;
863
864 case 1:
865 UNW_DEC_MEM_STACK_V ("P7", t, arg);
866 break;
867 case 2:
868 UNW_DEC_SPILL_BASE ("P7", t, arg);
869 break;
870 case 3:
871 UNW_DEC_REG_SPREL ("P7", UNW_REG_PSP, t, arg);
872 break;
873 case 4:
874 UNW_DEC_REG_WHEN ("P7", UNW_REG_RP, t, arg);
875 break;
876 case 5:
877 UNW_DEC_REG_PSPREL ("P7", UNW_REG_RP, t, arg);
878 break;
879 case 6:
880 UNW_DEC_REG_WHEN ("P7", UNW_REG_PFS, t, arg);
881 break;
882 case 7:
883 UNW_DEC_REG_PSPREL ("P7", UNW_REG_PFS, t, arg);
884 break;
885 case 8:
886 UNW_DEC_REG_WHEN ("P7", UNW_REG_PR, t, arg);
887 break;
888 case 9:
889 UNW_DEC_REG_PSPREL ("P7", UNW_REG_PR, t, arg);
890 break;
891 case 10:
892 UNW_DEC_REG_WHEN ("P7", UNW_REG_LC, t, arg);
893 break;
894 case 11:
895 UNW_DEC_REG_PSPREL ("P7", UNW_REG_LC, t, arg);
896 break;
897 case 12:
898 UNW_DEC_REG_WHEN ("P7", UNW_REG_UNAT, t, arg);
899 break;
900 case 13:
901 UNW_DEC_REG_PSPREL ("P7", UNW_REG_UNAT, t, arg);
902 break;
903 case 14:
904 UNW_DEC_REG_WHEN ("P7", UNW_REG_FPSR, t, arg);
905 break;
906 case 15:
907 UNW_DEC_REG_PSPREL ("P7", UNW_REG_FPSR, t, arg);
908 break;
909 default:
910 UNW_DEC_BAD_CODE (r);
911 break;
912 }
913 }
914 else
915 {
916 switch (code & 0xf)
917 {
918 case 0x0: /* p8 */
919 {
920 r = *dp++;
921 t = unw_decode_uleb128 (&dp);
922 switch (r)
923 {
924 case 1:
925 UNW_DEC_REG_SPREL ("P8", UNW_REG_RP, t, arg);
926 break;
927 case 2:
928 UNW_DEC_REG_SPREL ("P8", UNW_REG_PFS, t, arg);
929 break;
930 case 3:
931 UNW_DEC_REG_SPREL ("P8", UNW_REG_PR, t, arg);
932 break;
933 case 4:
934 UNW_DEC_REG_SPREL ("P8", UNW_REG_LC, t, arg);
935 break;
936 case 5:
937 UNW_DEC_REG_SPREL ("P8", UNW_REG_UNAT, t, arg);
938 break;
939 case 6:
940 UNW_DEC_REG_SPREL ("P8", UNW_REG_FPSR, t, arg);
941 break;
942 case 7:
943 UNW_DEC_REG_WHEN ("P8", UNW_REG_BSP, t, arg);
944 break;
945 case 8:
946 UNW_DEC_REG_PSPREL ("P8", UNW_REG_BSP, t, arg);
947 break;
948 case 9:
949 UNW_DEC_REG_SPREL ("P8", UNW_REG_BSP, t, arg);
950 break;
951 case 10:
952 UNW_DEC_REG_WHEN ("P8", UNW_REG_BSPSTORE, t, arg);
953 break;
954 case 11:
955 UNW_DEC_REG_PSPREL ("P8", UNW_REG_BSPSTORE, t, arg);
956 break;
957 case 12:
958 UNW_DEC_REG_SPREL ("P8", UNW_REG_BSPSTORE, t, arg);
959 break;
960 case 13:
961 UNW_DEC_REG_WHEN ("P8", UNW_REG_RNAT, t, arg);
962 break;
963 case 14:
964 UNW_DEC_REG_PSPREL ("P8", UNW_REG_RNAT, t, arg);
965 break;
966 case 15:
967 UNW_DEC_REG_SPREL ("P8", UNW_REG_RNAT, t, arg);
968 break;
969 case 16:
970 UNW_DEC_PRIUNAT_WHEN_GR ("P8", t, arg);
971 break;
972 case 17:
973 UNW_DEC_PRIUNAT_PSPREL ("P8", t, arg);
974 break;
975 case 18:
976 UNW_DEC_PRIUNAT_SPREL ("P8", t, arg);
977 break;
978 case 19:
979 UNW_DEC_PRIUNAT_WHEN_MEM ("P8", t, arg);
980 break;
981 default:
982 UNW_DEC_BAD_CODE (r);
983 break;
984 }
985 }
986 break;
987
988 case 0x1:
989 byte1 = *dp++;
990 byte2 = *dp++;
991 UNW_DEC_GR_GR ("P9", (byte1 & 0xf), (byte2 & 0x7f), arg);
992 break;
993
994 case 0xf: /* p10 */
995 byte1 = *dp++;
996 byte2 = *dp++;
997 UNW_DEC_ABI ("P10", byte1, byte2, arg);
998 break;
999
1000 case 0x9:
1001 return unw_decode_x1 (dp, code, arg);
1002
1003 case 0xa:
1004 return unw_decode_x2 (dp, code, arg);
1005
1006 case 0xb:
1007 return unw_decode_x3 (dp, code, arg);
1008
1009 case 0xc:
1010 return unw_decode_x4 (dp, code, arg);
1011
1012 default:
1013 UNW_DEC_BAD_CODE (code);
1014 break;
1015 }
1016 }
1017 return dp;
1018 }
1019
1020 static const unsigned char *
1021 unw_decode_b1 (dp, code, arg)
1022 const unsigned char * dp;
1023 unsigned int code;
1024 void * arg ATTRIBUTE_UNUSED;
1025 {
1026 unw_word label = (code & 0x1f);
1027
1028 if ((code & 0x20) != 0)
1029 UNW_DEC_COPY_STATE ("B1", label, arg);
1030 else
1031 UNW_DEC_LABEL_STATE ("B1", label, arg);
1032 return dp;
1033 }
1034
1035 static const unsigned char *
1036 unw_decode_b2 (dp, code, arg)
1037 const unsigned char * dp;
1038 unsigned int code;
1039 void * arg ATTRIBUTE_UNUSED;
1040 {
1041 unw_word t;
1042
1043 t = unw_decode_uleb128 (& dp);
1044 UNW_DEC_EPILOGUE ("B2", t, (code & 0x1f), arg);
1045 return dp;
1046 }
1047
1048 static const unsigned char *
1049 unw_decode_b3_x4 (dp, code, arg)
1050 const unsigned char *dp;
1051 unsigned int code;
1052 void *arg;
1053 {
1054 unw_word t, ecount, label;
1055
1056 if ((code & 0x10) == 0)
1057 {
1058 t = unw_decode_uleb128 (&dp);
1059 ecount = unw_decode_uleb128 (&dp);
1060 UNW_DEC_EPILOGUE ("B3", t, ecount, arg);
1061 }
1062 else if ((code & 0x07) == 0)
1063 {
1064 label = unw_decode_uleb128 (&dp);
1065 if ((code & 0x08) != 0)
1066 UNW_DEC_COPY_STATE ("B4", label, arg);
1067 else
1068 UNW_DEC_LABEL_STATE ("B4", label, arg);
1069 }
1070 else
1071 switch (code & 0x7)
1072 {
1073 case 1:
1074 return unw_decode_x1 (dp, code, arg);
1075 case 2:
1076 return unw_decode_x2 (dp, code, arg);
1077 case 3:
1078 return unw_decode_x3 (dp, code, arg);
1079 case 4:
1080 return unw_decode_x4 (dp, code, arg);
1081 default:
1082 UNW_DEC_BAD_CODE (code);
1083 break;
1084 }
1085 return dp;
1086 }
1087
1088 typedef const unsigned char *(*unw_decoder)
1089 PARAMS ((const unsigned char *, unsigned int, void *));
1090
1091 static unw_decoder unw_decode_table[2][8] =
1092 {
1093 /* prologue table: */
1094 {
1095 unw_decode_r1, /* 0 */
1096 unw_decode_r1,
1097 unw_decode_r2,
1098 unw_decode_r3,
1099 unw_decode_p1, /* 4 */
1100 unw_decode_p2_p5,
1101 unw_decode_p6,
1102 unw_decode_p7_p10
1103 },
1104 {
1105 unw_decode_r1, /* 0 */
1106 unw_decode_r1,
1107 unw_decode_r2,
1108 unw_decode_r3,
1109 unw_decode_b1, /* 4 */
1110 unw_decode_b1,
1111 unw_decode_b2,
1112 unw_decode_b3_x4
1113 }
1114 };
1115
1116 /* Decode one descriptor and return address of next descriptor. */
1117 const unsigned char *
1118 unw_decode (dp, inside_body, ptr_inside_body)
1119 const unsigned char * dp;
1120 int inside_body;
1121 void * ptr_inside_body;
1122 {
1123 unw_decoder decoder;
1124 unsigned char code;
1125
1126 code = *dp++;
1127 decoder = unw_decode_table[inside_body][code >> 5];
1128 return (*decoder) (dp, code, ptr_inside_body);
1129 }
git-cvsimport of binutils cvsroot