Commit | Line | Data |
---|---|---|
4d6ed7c8 | 1 | /* unwind-ia64.c -- utility routines to dump IA-64 unwind info for readelf. |
8c2bc687 | 2 | Copyright 2000, 2001 Free Software Foundation, Inc. |
4d6ed7c8 NC |
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 | ||
ecdadc4a JL |
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)); | |
c32144ff | 41 | |
4d6ed7c8 NC |
42 | static void |
43 | unw_print_brmask (cp, mask) | |
44 | char * cp; | |
ecdadc4a | 45 | unsigned int mask; |
4d6ed7c8 | 46 | { |
3eee1e9d | 47 | int sep = 0; |
4d6ed7c8 NC |
48 | int i; |
49 | ||
50 | for (i = 0; mask && (i < 5); ++i) | |
51 | { | |
52 | if (mask & 1) | |
53 | { | |
3eee1e9d AM |
54 | if (sep) |
55 | *cp++ = ','; | |
56 | *cp++ = 'b'; | |
57 | *cp++ = i + 1 + '0'; | |
58 | sep = 1; | |
4d6ed7c8 NC |
59 | } |
60 | mask >>= 1; | |
61 | } | |
62 | *cp = '\0'; | |
63 | } | |
64 | ||
65 | static void | |
66 | unw_print_grmask (cp, mask) | |
67 | char * cp; | |
ecdadc4a | 68 | unsigned int mask; |
4d6ed7c8 | 69 | { |
3eee1e9d | 70 | int sep = 0; |
4d6ed7c8 NC |
71 | int i; |
72 | ||
4d6ed7c8 NC |
73 | for (i = 0; i < 4; ++i) |
74 | { | |
75 | if (mask & 1) | |
76 | { | |
3eee1e9d AM |
77 | if (sep) |
78 | *cp++ = ','; | |
79 | *cp++ = 'r'; | |
80 | *cp++ = i + 4 + '0'; | |
81 | sep = 1; | |
4d6ed7c8 NC |
82 | } |
83 | mask >>= 1; | |
84 | } | |
3eee1e9d | 85 | *cp = '\0'; |
4d6ed7c8 NC |
86 | } |
87 | ||
88 | static void | |
89 | unw_print_frmask (cp, mask) | |
90 | char * cp; | |
ecdadc4a | 91 | unsigned int mask; |
4d6ed7c8 | 92 | { |
3eee1e9d | 93 | int sep = 0; |
4d6ed7c8 NC |
94 | int i; |
95 | ||
4d6ed7c8 NC |
96 | for (i = 0; i < 20; ++i) |
97 | { | |
98 | if (mask & 1) | |
99 | { | |
3eee1e9d AM |
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; | |
4d6ed7c8 NC |
111 | } |
112 | mask >>= 1; | |
113 | } | |
3eee1e9d | 114 | *cp = '\0'; |
4d6ed7c8 NC |
115 | } |
116 | ||
117 | static void | |
118 | unw_print_abreg (cp, abreg) | |
119 | char * cp; | |
ecdadc4a | 120 | unsigned int abreg; |
4d6ed7c8 NC |
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; | |
ecdadc4a JL |
152 | unsigned int x; |
153 | unsigned int ytreg; | |
4d6ed7c8 NC |
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 | ||
4d6ed7c8 NC |
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; \ | |
3c44da9a MS |
192 | printf (" %s:%s(rlen=%lu)\n", \ |
193 | fmt, body ? "body" : "prologue", (unsigned long) rlen); \ | |
4d6ed7c8 NC |
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); \ | |
3c44da9a MS |
230 | printf (" %s:prologue_gr(mask=[%s],grsave=%s,rlen=%lu)\n", \ |
231 | fmt, maskstr, regname, (unsigned long) rlen); \ | |
4d6ed7c8 NC |
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); \ | |
3c44da9a | 241 | printf ("\t%s:fr_mem(frmask=[%s])\n", fmt, frstr); \ |
4d6ed7c8 NC |
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); \ | |
3c44da9a | 251 | printf ("\t%s:gr_mem(grmask=[%s])\n", fmt, grstr); \ |
4d6ed7c8 NC |
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); \ | |
3c44da9a | 262 | printf ("\t%s:frgr_mem(grmask=[%s],frmask=[%s])\n", fmt, grstr, frstr); \ |
4d6ed7c8 NC |
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); \ | |
3c44da9a | 272 | printf ("\t%s:br_mem(brmask=[%s])\n", fmt, brstr); \ |
4d6ed7c8 NC |
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); \ | |
3c44da9a | 282 | printf ("\t%s:br_gr(brmask=[%s],gr=r%u)\n", fmt, brstr, gr); \ |
4d6ed7c8 NC |
283 | } \ |
284 | while (0) | |
285 | ||
286 | #define UNW_DEC_REG_GR(fmt, src, dst, arg) \ | |
3c44da9a | 287 | printf ("\t%s:%s_gr(reg=r%u)\n", fmt, src, dst) |
4d6ed7c8 NC |
288 | |
289 | #define UNW_DEC_RP_BR(fmt, dst, arg) \ | |
3c44da9a | 290 | printf ("\t%s:rp_br(reg=b%u)\n", fmt, dst) |
4d6ed7c8 NC |
291 | |
292 | #define UNW_DEC_REG_WHEN(fmt, reg, t, arg) \ | |
3c44da9a | 293 | printf ("\t%s:%s_when(t=%lu)\n", fmt, reg, (unsigned long) t) |
4d6ed7c8 NC |
294 | |
295 | #define UNW_DEC_REG_SPREL(fmt, reg, spoff, arg) \ | |
3c44da9a MS |
296 | printf ("\t%s:%s_sprel(spoff=0x%lx)\n", \ |
297 | fmt, reg, 4*(unsigned long)spoff) | |
4d6ed7c8 NC |
298 | |
299 | #define UNW_DEC_REG_PSPREL(fmt, reg, pspoff, arg) \ | |
3c44da9a MS |
300 | printf ("\t%s:%s_psprel(pspoff=0x10-0x%lx)\n", \ |
301 | fmt, reg, 4*(unsigned long)pspoff) | |
4d6ed7c8 NC |
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); \ | |
3c44da9a | 309 | printf ("\t%s:gr_gr(grmask=[%s],r%u)\n", fmt, grstr, gr); \ |
4d6ed7c8 NC |
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); \ | |
3c44da9a MS |
327 | printf ("\t%s:unwabi(abi=%s,context=0x%02x)\n", \ |
328 | fmt, abistr, context); \ | |
4d6ed7c8 NC |
329 | } \ |
330 | while (0) | |
331 | ||
332 | #define UNW_DEC_PRIUNAT_GR(fmt, r, arg) \ | |
3c44da9a | 333 | printf ("\t%s:priunat_gr(reg=r%u)\n", fmt, r) |
4d6ed7c8 NC |
334 | |
335 | #define UNW_DEC_PRIUNAT_WHEN_GR(fmt, t, arg) \ | |
3c44da9a | 336 | printf ("\t%s:priunat_when_gr(t=%lu)\n", fmt, (unsigned long) t) |
4d6ed7c8 NC |
337 | |
338 | #define UNW_DEC_PRIUNAT_WHEN_MEM(fmt, t, arg) \ | |
3c44da9a | 339 | printf ("\t%s:priunat_when_mem(t=%lu)\n", fmt, (unsigned long) t) |
4d6ed7c8 NC |
340 | |
341 | #define UNW_DEC_PRIUNAT_PSPREL(fmt, pspoff, arg) \ | |
3c44da9a MS |
342 | printf ("\t%s:priunat_psprel(pspoff=0x10-0x%lx)\n", \ |
343 | fmt, 4*(unsigned long)pspoff) | |
4d6ed7c8 NC |
344 | |
345 | #define UNW_DEC_PRIUNAT_SPREL(fmt, spoff, arg) \ | |
3c44da9a MS |
346 | printf ("\t%s:priunat_sprel(spoff=0x%lx)\n", \ |
347 | fmt, 4*(unsigned long)spoff) | |
4d6ed7c8 NC |
348 | |
349 | #define UNW_DEC_MEM_STACK_F(fmt, t, size, arg) \ | |
3c44da9a MS |
350 | printf ("\t%s:mem_stack_f(t=%lu,size=%lu)\n", \ |
351 | fmt, (unsigned long) t, 16*(unsigned long)size) | |
4d6ed7c8 NC |
352 | |
353 | #define UNW_DEC_MEM_STACK_V(fmt, t, arg) \ | |
3c44da9a | 354 | printf ("\t%s:mem_stack_v(t=%lu)\n", fmt, (unsigned long) t) |
4d6ed7c8 NC |
355 | |
356 | #define UNW_DEC_SPILL_BASE(fmt, pspoff, arg) \ | |
3c44da9a MS |
357 | printf ("\t%s:spill_base(pspoff=0x10-0x%lx)\n", \ |
358 | fmt, 4*(unsigned long)pspoff) | |
4d6ed7c8 NC |
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 | \ | |
3c44da9a | 368 | printf ("\t%s:spill_mask(imask=[", fmt); \ |
4d6ed7c8 NC |
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); \ | |
3c44da9a MS |
388 | printf ("\t%s:spill_sprel(reg=%s,t=%lu,spoff=0x%lx)\n", \ |
389 | fmt, regname, (unsigned long) t, 4*(unsigned long)off); \ | |
4d6ed7c8 NC |
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); \ | |
3c44da9a MS |
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); \ | |
4d6ed7c8 NC |
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); \ | |
3c44da9a MS |
410 | printf ("\t%s:restore(t=%lu,reg=%s)\n", \ |
411 | fmt, (unsigned long) t, regname); \ | |
4d6ed7c8 NC |
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); \ | |
3c44da9a MS |
422 | printf ("\t%s:spill_reg(t=%lu,reg=%s,treg=%s)\n", \ |
423 | fmt, (unsigned long) t, abregname, tregname); \ | |
4d6ed7c8 NC |
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); \ | |
3c44da9a MS |
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); \ | |
4d6ed7c8 NC |
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); \ | |
3c44da9a MS |
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);\ | |
4d6ed7c8 NC |
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); \ | |
3c44da9a MS |
455 | printf ("\t%s:restore_p(qp=p%u,t=%lu,reg=%s)\n", \ |
456 | fmt, qp, (unsigned long) t, regname); \ | |
4d6ed7c8 NC |
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); \ | |
3c44da9a MS |
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); \ | |
4d6ed7c8 NC |
469 | } \ |
470 | while (0) | |
471 | ||
472 | #define UNW_DEC_LABEL_STATE(fmt, label, arg) \ | |
3c44da9a | 473 | printf ("\t%s:label_state(label=%lu)\n", fmt, (unsigned long) label) |
4d6ed7c8 NC |
474 | |
475 | #define UNW_DEC_COPY_STATE(fmt, label, arg) \ | |
3c44da9a | 476 | printf ("\t%s:copy_state(label=%lu)\n", fmt, (unsigned long) label) |
4d6ed7c8 NC |
477 | |
478 | #define UNW_DEC_EPILOGUE(fmt, t, ecount, arg) \ | |
3c44da9a MS |
479 | printf ("\t%s:epilogue(t=%lu,ecount=%lu)\n", \ |
480 | fmt, (unsigned long) t, (unsigned long) ecount) | |
4d6ed7c8 NC |
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: | |
9f66665a | 493 | * unw_word Unsigned integer type with at least 64 bits |
4d6ed7c8 NC |
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 *, | |
ecdadc4a | 546 | unsigned int, void *)); |
4d6ed7c8 | 547 | static const unsigned char *unw_decode_x2 PARAMS ((const unsigned char *, |
ecdadc4a | 548 | unsigned int, void *)); |
4d6ed7c8 | 549 | static const unsigned char *unw_decode_x3 PARAMS ((const unsigned char *, |
ecdadc4a | 550 | unsigned int, void *)); |
4d6ed7c8 | 551 | static const unsigned char *unw_decode_x4 PARAMS ((const unsigned char *, |
ecdadc4a | 552 | unsigned int, void *)); |
4d6ed7c8 | 553 | static const unsigned char *unw_decode_r1 PARAMS ((const unsigned char *, |
ecdadc4a | 554 | unsigned int, void *)); |
4d6ed7c8 | 555 | static const unsigned char *unw_decode_r2 PARAMS ((const unsigned char *, |
ecdadc4a | 556 | unsigned int, void *)); |
4d6ed7c8 | 557 | static const unsigned char *unw_decode_r3 PARAMS ((const unsigned char *, |
ecdadc4a | 558 | unsigned int, void *)); |
4d6ed7c8 | 559 | static const unsigned char *unw_decode_p1 PARAMS ((const unsigned char *, |
ecdadc4a | 560 | unsigned int, void *)); |
4d6ed7c8 | 561 | static const unsigned char *unw_decode_p2_p5 PARAMS ((const unsigned char *, |
ecdadc4a | 562 | unsigned int, void *)); |
4d6ed7c8 | 563 | static const unsigned char *unw_decode_p6 PARAMS ((const unsigned char *, |
ecdadc4a | 564 | unsigned int, void *)); |
4d6ed7c8 | 565 | static const unsigned char *unw_decode_p7_p10 PARAMS ((const unsigned char *, |
ecdadc4a | 566 | unsigned int, void *)); |
4d6ed7c8 | 567 | static const unsigned char *unw_decode_b1 PARAMS ((const unsigned char *, |
ecdadc4a | 568 | unsigned int, void *)); |
4d6ed7c8 | 569 | static const unsigned char *unw_decode_b2 PARAMS ((const unsigned char *, |
ecdadc4a | 570 | unsigned int, void *)); |
4d6ed7c8 | 571 | static const unsigned char *unw_decode_b3_x4 PARAMS ((const unsigned char *, |
ecdadc4a | 572 | unsigned int, void *)); |
4d6ed7c8 NC |
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; | |
ecdadc4a | 601 | unsigned int code ATTRIBUTE_UNUSED; |
4d6ed7c8 NC |
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) | |
3c44da9a | 612 | UNW_DEC_SPILL_SPREL ("X1", t, abreg, off, arg); |
4d6ed7c8 | 613 | else |
3c44da9a | 614 | UNW_DEC_SPILL_PSPREL ("X1", t, abreg, off, arg); |
4d6ed7c8 NC |
615 | return dp; |
616 | } | |
617 | ||
618 | static const unsigned char * | |
619 | unw_decode_x2 (dp, code, arg) | |
620 | const unsigned char * dp; | |
ecdadc4a | 621 | unsigned int code ATTRIBUTE_UNUSED; |
4d6ed7c8 NC |
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) | |
3c44da9a | 634 | UNW_DEC_RESTORE ("X2", t, abreg, arg); |
4d6ed7c8 | 635 | else |
3c44da9a | 636 | UNW_DEC_SPILL_REG ("X2", t, abreg, x, ytreg, arg); |
4d6ed7c8 NC |
637 | return dp; |
638 | } | |
639 | ||
640 | static const unsigned char * | |
641 | unw_decode_x3 (dp, code, arg) | |
642 | const unsigned char * dp; | |
ecdadc4a | 643 | unsigned int code ATTRIBUTE_UNUSED; |
4d6ed7c8 NC |
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) | |
3c44da9a | 658 | UNW_DEC_SPILL_SPREL_P ("X3", qp, t, abreg, off, arg); |
4d6ed7c8 | 659 | else |
3c44da9a | 660 | UNW_DEC_SPILL_PSPREL_P ("X3", qp, t, abreg, off, arg); |
4d6ed7c8 NC |
661 | return dp; |
662 | } | |
663 | ||
664 | static const unsigned char * | |
665 | unw_decode_x4 (dp, code, arg) | |
666 | const unsigned char * dp; | |
ecdadc4a | 667 | unsigned int code ATTRIBUTE_UNUSED; |
4d6ed7c8 NC |
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) | |
3c44da9a | 684 | UNW_DEC_RESTORE_P ("X4", qp, t, abreg, arg); |
4d6ed7c8 | 685 | else |
3c44da9a | 686 | UNW_DEC_SPILL_REG_P ("X4", qp, t, abreg, x, ytreg, arg); |
4d6ed7c8 NC |
687 | return dp; |
688 | } | |
689 | ||
690 | static const unsigned char * | |
691 | unw_decode_r1 (dp, code, arg) | |
692 | const unsigned char *dp; | |
ecdadc4a | 693 | unsigned int code; |
4d6ed7c8 NC |
694 | void *arg; |
695 | { | |
696 | int body = (code & 0x20) != 0; | |
697 | unw_word rlen; | |
698 | ||
699 | rlen = (code & 0x1f); | |
3c44da9a | 700 | UNW_DEC_PROLOGUE ("R1", body, rlen, arg); |
4d6ed7c8 NC |
701 | return dp; |
702 | } | |
703 | ||
704 | static const unsigned char * | |
705 | unw_decode_r2 (dp, code, arg) | |
706 | const unsigned char *dp; | |
ecdadc4a | 707 | unsigned int code; |
4d6ed7c8 NC |
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); | |
3c44da9a | 718 | UNW_DEC_PROLOGUE_GR ("R2", rlen, mask, grsave, arg); |
4d6ed7c8 NC |
719 | return dp; |
720 | } | |
721 | ||
722 | static const unsigned char * | |
723 | unw_decode_r3 (dp, code, arg) | |
724 | const unsigned char *dp; | |
ecdadc4a | 725 | unsigned int code; |
4d6ed7c8 NC |
726 | void *arg; |
727 | { | |
728 | unw_word rlen; | |
729 | ||
730 | rlen = unw_decode_uleb128 (& dp); | |
3c44da9a | 731 | UNW_DEC_PROLOGUE ("R3", ((code & 0x3) == 1), rlen, arg); |
4d6ed7c8 NC |
732 | return dp; |
733 | } | |
734 | ||
735 | static const unsigned char * | |
736 | unw_decode_p1 (dp, code, arg) | |
737 | const unsigned char * dp; | |
ecdadc4a | 738 | unsigned int code; |
4d6ed7c8 NC |
739 | void * arg ATTRIBUTE_UNUSED; |
740 | { | |
741 | unsigned char brmask = (code & 0x1f); | |
742 | ||
3c44da9a | 743 | UNW_DEC_BR_MEM ("P1", brmask, arg); |
4d6ed7c8 NC |
744 | return dp; |
745 | } | |
746 | ||
747 | static const unsigned char * | |
748 | unw_decode_p2_p5 (dp, code, arg) | |
749 | const unsigned char * dp; | |
ecdadc4a | 750 | unsigned int code; |
4d6ed7c8 NC |
751 | void * arg ATTRIBUTE_UNUSED; |
752 | { | |
753 | if ((code & 0x10) == 0) | |
754 | { | |
755 | unsigned char byte1 = *dp++; | |
756 | ||
3c44da9a | 757 | UNW_DEC_BR_GR ("P2", ((code & 0xf) << 1) | ((byte1 >> 7) & 1), |
4d6ed7c8 NC |
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: | |
3c44da9a | 769 | UNW_DEC_REG_GR ("P3", UNW_REG_PSP, dst, arg); |
4d6ed7c8 NC |
770 | break; |
771 | case 1: | |
3c44da9a | 772 | UNW_DEC_REG_GR ("P3", UNW_REG_RP, dst, arg); |
4d6ed7c8 NC |
773 | break; |
774 | case 2: | |
3c44da9a | 775 | UNW_DEC_REG_GR ("P3", UNW_REG_PFS, dst, arg); |
4d6ed7c8 NC |
776 | break; |
777 | case 3: | |
3c44da9a | 778 | UNW_DEC_REG_GR ("P3", UNW_REG_PR, dst, arg); |
4d6ed7c8 NC |
779 | break; |
780 | case 4: | |
3c44da9a | 781 | UNW_DEC_REG_GR ("P3", UNW_REG_UNAT, dst, arg); |
4d6ed7c8 NC |
782 | break; |
783 | case 5: | |
3c44da9a | 784 | UNW_DEC_REG_GR ("P3", UNW_REG_LC, dst, arg); |
4d6ed7c8 NC |
785 | break; |
786 | case 6: | |
3c44da9a | 787 | UNW_DEC_RP_BR ("P3", dst, arg); |
4d6ed7c8 NC |
788 | break; |
789 | case 7: | |
3c44da9a | 790 | UNW_DEC_REG_GR ("P3", UNW_REG_RNAT, dst, arg); |
4d6ed7c8 NC |
791 | break; |
792 | case 8: | |
3c44da9a | 793 | UNW_DEC_REG_GR ("P3", UNW_REG_BSP, dst, arg); |
4d6ed7c8 NC |
794 | break; |
795 | case 9: | |
3c44da9a | 796 | UNW_DEC_REG_GR ("P3", UNW_REG_BSPSTORE, dst, arg); |
4d6ed7c8 NC |
797 | break; |
798 | case 10: | |
3c44da9a | 799 | UNW_DEC_REG_GR ("P3", UNW_REG_FPSR, dst, arg); |
4d6ed7c8 NC |
800 | break; |
801 | case 11: | |
3c44da9a | 802 | UNW_DEC_PRIUNAT_GR ("P3", dst, arg); |
4d6ed7c8 NC |
803 | break; |
804 | default: | |
805 | UNW_DEC_BAD_CODE (r); | |
806 | break; | |
807 | } | |
808 | } | |
809 | else if ((code & 0x7) == 0) | |
3c44da9a | 810 | UNW_DEC_SPILL_MASK ("P4", dp, arg); |
4d6ed7c8 NC |
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; | |
3c44da9a | 820 | UNW_DEC_FRGR_MEM ("P5", grmask, frmask, arg); |
4d6ed7c8 NC |
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; | |
ecdadc4a | 831 | unsigned int code; |
4d6ed7c8 NC |
832 | void * arg ATTRIBUTE_UNUSED; |
833 | { | |
834 | int gregs = (code & 0x10) != 0; | |
835 | unsigned char mask = (code & 0x0f); | |
836 | ||
837 | if (gregs) | |
3c44da9a | 838 | UNW_DEC_GR_MEM ("P6", mask, arg); |
4d6ed7c8 | 839 | else |
3c44da9a | 840 | UNW_DEC_FR_MEM ("P6", mask, arg); |
4d6ed7c8 NC |
841 | return dp; |
842 | } | |
843 | ||
844 | static const unsigned char * | |
845 | unw_decode_p7_p10 (dp, code, arg) | |
846 | const unsigned char *dp; | |
ecdadc4a | 847 | unsigned int code; |
4d6ed7c8 NC |
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); | |
3c44da9a | 861 | UNW_DEC_MEM_STACK_F ("P7", t, size, arg); |
4d6ed7c8 NC |
862 | break; |
863 | ||
864 | case 1: | |
3c44da9a | 865 | UNW_DEC_MEM_STACK_V ("P7", t, arg); |
4d6ed7c8 NC |
866 | break; |
867 | case 2: | |
3c44da9a | 868 | UNW_DEC_SPILL_BASE ("P7", t, arg); |
4d6ed7c8 NC |
869 | break; |
870 | case 3: | |
3c44da9a | 871 | UNW_DEC_REG_SPREL ("P7", UNW_REG_PSP, t, arg); |
4d6ed7c8 NC |
872 | break; |
873 | case 4: | |
3c44da9a | 874 | UNW_DEC_REG_WHEN ("P7", UNW_REG_RP, t, arg); |
4d6ed7c8 NC |
875 | break; |
876 | case 5: | |
3c44da9a | 877 | UNW_DEC_REG_PSPREL ("P7", UNW_REG_RP, t, arg); |
4d6ed7c8 NC |
878 | break; |
879 | case 6: | |
3c44da9a | 880 | UNW_DEC_REG_WHEN ("P7", UNW_REG_PFS, t, arg); |
4d6ed7c8 NC |
881 | break; |
882 | case 7: | |
3c44da9a | 883 | UNW_DEC_REG_PSPREL ("P7", UNW_REG_PFS, t, arg); |
4d6ed7c8 NC |
884 | break; |
885 | case 8: | |
3c44da9a | 886 | UNW_DEC_REG_WHEN ("P7", UNW_REG_PR, t, arg); |
4d6ed7c8 NC |
887 | break; |
888 | case 9: | |
3c44da9a | 889 | UNW_DEC_REG_PSPREL ("P7", UNW_REG_PR, t, arg); |
4d6ed7c8 NC |
890 | break; |
891 | case 10: | |
3c44da9a | 892 | UNW_DEC_REG_WHEN ("P7", UNW_REG_LC, t, arg); |
4d6ed7c8 NC |
893 | break; |
894 | case 11: | |
3c44da9a | 895 | UNW_DEC_REG_PSPREL ("P7", UNW_REG_LC, t, arg); |
4d6ed7c8 NC |
896 | break; |
897 | case 12: | |
3c44da9a | 898 | UNW_DEC_REG_WHEN ("P7", UNW_REG_UNAT, t, arg); |
4d6ed7c8 NC |
899 | break; |
900 | case 13: | |
3c44da9a | 901 | UNW_DEC_REG_PSPREL ("P7", UNW_REG_UNAT, t, arg); |
4d6ed7c8 NC |
902 | break; |
903 | case 14: | |
3c44da9a | 904 | UNW_DEC_REG_WHEN ("P7", UNW_REG_FPSR, t, arg); |
4d6ed7c8 NC |
905 | break; |
906 | case 15: | |
3c44da9a | 907 | UNW_DEC_REG_PSPREL ("P7", UNW_REG_FPSR, t, arg); |
4d6ed7c8 NC |
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: | |
3c44da9a | 925 | UNW_DEC_REG_SPREL ("P8", UNW_REG_RP, t, arg); |
4d6ed7c8 NC |
926 | break; |
927 | case 2: | |
3c44da9a | 928 | UNW_DEC_REG_SPREL ("P8", UNW_REG_PFS, t, arg); |
4d6ed7c8 NC |
929 | break; |
930 | case 3: | |
3c44da9a | 931 | UNW_DEC_REG_SPREL ("P8", UNW_REG_PR, t, arg); |
4d6ed7c8 NC |
932 | break; |
933 | case 4: | |
3c44da9a | 934 | UNW_DEC_REG_SPREL ("P8", UNW_REG_LC, t, arg); |
4d6ed7c8 NC |
935 | break; |
936 | case 5: | |
3c44da9a | 937 | UNW_DEC_REG_SPREL ("P8", UNW_REG_UNAT, t, arg); |
4d6ed7c8 NC |
938 | break; |
939 | case 6: | |
3c44da9a | 940 | UNW_DEC_REG_SPREL ("P8", UNW_REG_FPSR, t, arg); |
4d6ed7c8 NC |
941 | break; |
942 | case 7: | |
3c44da9a | 943 | UNW_DEC_REG_WHEN ("P8", UNW_REG_BSP, t, arg); |
4d6ed7c8 NC |
944 | break; |
945 | case 8: | |
3c44da9a | 946 | UNW_DEC_REG_PSPREL ("P8", UNW_REG_BSP, t, arg); |
4d6ed7c8 NC |
947 | break; |
948 | case 9: | |
3c44da9a | 949 | UNW_DEC_REG_SPREL ("P8", UNW_REG_BSP, t, arg); |
4d6ed7c8 NC |
950 | break; |
951 | case 10: | |
3c44da9a | 952 | UNW_DEC_REG_WHEN ("P8", UNW_REG_BSPSTORE, t, arg); |
4d6ed7c8 NC |
953 | break; |
954 | case 11: | |
3c44da9a | 955 | UNW_DEC_REG_PSPREL ("P8", UNW_REG_BSPSTORE, t, arg); |
4d6ed7c8 NC |
956 | break; |
957 | case 12: | |
3c44da9a | 958 | UNW_DEC_REG_SPREL ("P8", UNW_REG_BSPSTORE, t, arg); |
4d6ed7c8 NC |
959 | break; |
960 | case 13: | |
3c44da9a | 961 | UNW_DEC_REG_WHEN ("P8", UNW_REG_RNAT, t, arg); |
4d6ed7c8 NC |
962 | break; |
963 | case 14: | |
3c44da9a | 964 | UNW_DEC_REG_PSPREL ("P8", UNW_REG_RNAT, t, arg); |
4d6ed7c8 NC |
965 | break; |
966 | case 15: | |
3c44da9a | 967 | UNW_DEC_REG_SPREL ("P8", UNW_REG_RNAT, t, arg); |
4d6ed7c8 NC |
968 | break; |
969 | case 16: | |
3c44da9a | 970 | UNW_DEC_PRIUNAT_WHEN_GR ("P8", t, arg); |
4d6ed7c8 NC |
971 | break; |
972 | case 17: | |
3c44da9a | 973 | UNW_DEC_PRIUNAT_PSPREL ("P8", t, arg); |
4d6ed7c8 NC |
974 | break; |
975 | case 18: | |
3c44da9a | 976 | UNW_DEC_PRIUNAT_SPREL ("P8", t, arg); |
4d6ed7c8 NC |
977 | break; |
978 | case 19: | |
3c44da9a | 979 | UNW_DEC_PRIUNAT_WHEN_MEM ("P8", t, arg); |
4d6ed7c8 NC |
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++; | |
3c44da9a | 991 | UNW_DEC_GR_GR ("P9", (byte1 & 0xf), (byte2 & 0x7f), arg); |
4d6ed7c8 NC |
992 | break; |
993 | ||
994 | case 0xf: /* p10 */ | |
995 | byte1 = *dp++; | |
996 | byte2 = *dp++; | |
3c44da9a | 997 | UNW_DEC_ABI ("P10", byte1, byte2, arg); |
4d6ed7c8 NC |
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; | |
ecdadc4a | 1023 | unsigned int code; |
4d6ed7c8 NC |
1024 | void * arg ATTRIBUTE_UNUSED; |
1025 | { | |
1026 | unw_word label = (code & 0x1f); | |
1027 | ||
1028 | if ((code & 0x20) != 0) | |
3c44da9a | 1029 | UNW_DEC_COPY_STATE ("B1", label, arg); |
4d6ed7c8 | 1030 | else |
3c44da9a | 1031 | UNW_DEC_LABEL_STATE ("B1", label, arg); |
4d6ed7c8 NC |
1032 | return dp; |
1033 | } | |
1034 | ||
1035 | static const unsigned char * | |
1036 | unw_decode_b2 (dp, code, arg) | |
1037 | const unsigned char * dp; | |
ecdadc4a | 1038 | unsigned int code; |
4d6ed7c8 NC |
1039 | void * arg ATTRIBUTE_UNUSED; |
1040 | { | |
1041 | unw_word t; | |
1042 | ||
1043 | t = unw_decode_uleb128 (& dp); | |
3c44da9a | 1044 | UNW_DEC_EPILOGUE ("B2", t, (code & 0x1f), arg); |
4d6ed7c8 NC |
1045 | return dp; |
1046 | } | |
1047 | ||
1048 | static const unsigned char * | |
1049 | unw_decode_b3_x4 (dp, code, arg) | |
1050 | const unsigned char *dp; | |
ecdadc4a | 1051 | unsigned int code; |
4d6ed7c8 NC |
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); | |
3c44da9a | 1060 | UNW_DEC_EPILOGUE ("B3", t, ecount, arg); |
4d6ed7c8 NC |
1061 | } |
1062 | else if ((code & 0x07) == 0) | |
1063 | { | |
1064 | label = unw_decode_uleb128 (&dp); | |
1065 | if ((code & 0x08) != 0) | |
3c44da9a | 1066 | UNW_DEC_COPY_STATE ("B4", label, arg); |
4d6ed7c8 | 1067 | else |
3c44da9a | 1068 | UNW_DEC_LABEL_STATE ("B4", label, arg); |
4d6ed7c8 NC |
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) | |
a0e9c55f | 1089 | PARAMS ((const unsigned char *, unsigned int, void *)); |
4d6ed7c8 NC |
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 | } |