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