aboutsummaryrefslogtreecommitdiffstats
path: root/arch/ia64/kernel/unwind_decoder.c
diff options
context:
space:
mode:
Diffstat (limited to 'arch/ia64/kernel/unwind_decoder.c')
-rw-r--r--arch/ia64/kernel/unwind_decoder.c459
1 files changed, 459 insertions, 0 deletions
diff --git a/arch/ia64/kernel/unwind_decoder.c b/arch/ia64/kernel/unwind_decoder.c
new file mode 100644
index 000000000000..50ac2d82f9bf
--- /dev/null
+++ b/arch/ia64/kernel/unwind_decoder.c
@@ -0,0 +1,459 @@
1/*
2 * Copyright (C) 2000 Hewlett-Packard Co
3 * Copyright (C) 2000 David Mosberger-Tang <davidm@hpl.hp.com>
4 *
5 * Generic IA-64 unwind info decoder.
6 *
7 * This file is used both by the Linux kernel and objdump. Please keep
8 * the two copies of this file in sync.
9 *
10 * You need to customize the decoder by defining the following
11 * macros/constants before including this file:
12 *
13 * Types:
14 * unw_word Unsigned integer type with at least 64 bits
15 *
16 * Register names:
17 * UNW_REG_BSP
18 * UNW_REG_BSPSTORE
19 * UNW_REG_FPSR
20 * UNW_REG_LC
21 * UNW_REG_PFS
22 * UNW_REG_PR
23 * UNW_REG_RNAT
24 * UNW_REG_PSP
25 * UNW_REG_RP
26 * UNW_REG_UNAT
27 *
28 * Decoder action macros:
29 * UNW_DEC_BAD_CODE(code)
30 * UNW_DEC_ABI(fmt,abi,context,arg)
31 * UNW_DEC_BR_GR(fmt,brmask,gr,arg)
32 * UNW_DEC_BR_MEM(fmt,brmask,arg)
33 * UNW_DEC_COPY_STATE(fmt,label,arg)
34 * UNW_DEC_EPILOGUE(fmt,t,ecount,arg)
35 * UNW_DEC_FRGR_MEM(fmt,grmask,frmask,arg)
36 * UNW_DEC_FR_MEM(fmt,frmask,arg)
37 * UNW_DEC_GR_GR(fmt,grmask,gr,arg)
38 * UNW_DEC_GR_MEM(fmt,grmask,arg)
39 * UNW_DEC_LABEL_STATE(fmt,label,arg)
40 * UNW_DEC_MEM_STACK_F(fmt,t,size,arg)
41 * UNW_DEC_MEM_STACK_V(fmt,t,arg)
42 * UNW_DEC_PRIUNAT_GR(fmt,r,arg)
43 * UNW_DEC_PRIUNAT_WHEN_GR(fmt,t,arg)
44 * UNW_DEC_PRIUNAT_WHEN_MEM(fmt,t,arg)
45 * UNW_DEC_PRIUNAT_WHEN_PSPREL(fmt,pspoff,arg)
46 * UNW_DEC_PRIUNAT_WHEN_SPREL(fmt,spoff,arg)
47 * UNW_DEC_PROLOGUE(fmt,body,rlen,arg)
48 * UNW_DEC_PROLOGUE_GR(fmt,rlen,mask,grsave,arg)
49 * UNW_DEC_REG_PSPREL(fmt,reg,pspoff,arg)
50 * UNW_DEC_REG_REG(fmt,src,dst,arg)
51 * UNW_DEC_REG_SPREL(fmt,reg,spoff,arg)
52 * UNW_DEC_REG_WHEN(fmt,reg,t,arg)
53 * UNW_DEC_RESTORE(fmt,t,abreg,arg)
54 * UNW_DEC_RESTORE_P(fmt,qp,t,abreg,arg)
55 * UNW_DEC_SPILL_BASE(fmt,pspoff,arg)
56 * UNW_DEC_SPILL_MASK(fmt,imaskp,arg)
57 * UNW_DEC_SPILL_PSPREL(fmt,t,abreg,pspoff,arg)
58 * UNW_DEC_SPILL_PSPREL_P(fmt,qp,t,abreg,pspoff,arg)
59 * UNW_DEC_SPILL_REG(fmt,t,abreg,x,ytreg,arg)
60 * UNW_DEC_SPILL_REG_P(fmt,qp,t,abreg,x,ytreg,arg)
61 * UNW_DEC_SPILL_SPREL(fmt,t,abreg,spoff,arg)
62 * UNW_DEC_SPILL_SPREL_P(fmt,qp,t,abreg,pspoff,arg)
63 */
64
65static unw_word
66unw_decode_uleb128 (unsigned char **dpp)
67{
68 unsigned shift = 0;
69 unw_word byte, result = 0;
70 unsigned char *bp = *dpp;
71
72 while (1)
73 {
74 byte = *bp++;
75 result |= (byte & 0x7f) << shift;
76 if ((byte & 0x80) == 0)
77 break;
78 shift += 7;
79 }
80 *dpp = bp;
81 return result;
82}
83
84static unsigned char *
85unw_decode_x1 (unsigned char *dp, unsigned char code, void *arg)
86{
87 unsigned char byte1, abreg;
88 unw_word t, off;
89
90 byte1 = *dp++;
91 t = unw_decode_uleb128 (&dp);
92 off = unw_decode_uleb128 (&dp);
93 abreg = (byte1 & 0x7f);
94 if (byte1 & 0x80)
95 UNW_DEC_SPILL_SPREL(X1, t, abreg, off, arg);
96 else
97 UNW_DEC_SPILL_PSPREL(X1, t, abreg, off, arg);
98 return dp;
99}
100
101static unsigned char *
102unw_decode_x2 (unsigned char *dp, unsigned char code, void *arg)
103{
104 unsigned char byte1, byte2, abreg, x, ytreg;
105 unw_word t;
106
107 byte1 = *dp++; byte2 = *dp++;
108 t = unw_decode_uleb128 (&dp);
109 abreg = (byte1 & 0x7f);
110 ytreg = byte2;
111 x = (byte1 >> 7) & 1;
112 if ((byte1 & 0x80) == 0 && ytreg == 0)
113 UNW_DEC_RESTORE(X2, t, abreg, arg);
114 else
115 UNW_DEC_SPILL_REG(X2, t, abreg, x, ytreg, arg);
116 return dp;
117}
118
119static unsigned char *
120unw_decode_x3 (unsigned char *dp, unsigned char code, void *arg)
121{
122 unsigned char byte1, byte2, abreg, qp;
123 unw_word t, off;
124
125 byte1 = *dp++; byte2 = *dp++;
126 t = unw_decode_uleb128 (&dp);
127 off = unw_decode_uleb128 (&dp);
128
129 qp = (byte1 & 0x3f);
130 abreg = (byte2 & 0x7f);
131
132 if (byte1 & 0x80)
133 UNW_DEC_SPILL_SPREL_P(X3, qp, t, abreg, off, arg);
134 else
135 UNW_DEC_SPILL_PSPREL_P(X3, qp, t, abreg, off, arg);
136 return dp;
137}
138
139static unsigned char *
140unw_decode_x4 (unsigned char *dp, unsigned char code, void *arg)
141{
142 unsigned char byte1, byte2, byte3, qp, abreg, x, ytreg;
143 unw_word t;
144
145 byte1 = *dp++; byte2 = *dp++; byte3 = *dp++;
146 t = unw_decode_uleb128 (&dp);
147
148 qp = (byte1 & 0x3f);
149 abreg = (byte2 & 0x7f);
150 x = (byte2 >> 7) & 1;
151 ytreg = byte3;
152
153 if ((byte2 & 0x80) == 0 && byte3 == 0)
154 UNW_DEC_RESTORE_P(X4, qp, t, abreg, arg);
155 else
156 UNW_DEC_SPILL_REG_P(X4, qp, t, abreg, x, ytreg, arg);
157 return dp;
158}
159
160static unsigned char *
161unw_decode_r1 (unsigned char *dp, unsigned char code, void *arg)
162{
163 int body = (code & 0x20) != 0;
164 unw_word rlen;
165
166 rlen = (code & 0x1f);
167 UNW_DEC_PROLOGUE(R1, body, rlen, arg);
168 return dp;
169}
170
171static unsigned char *
172unw_decode_r2 (unsigned char *dp, unsigned char code, void *arg)
173{
174 unsigned char byte1, mask, grsave;
175 unw_word rlen;
176
177 byte1 = *dp++;
178
179 mask = ((code & 0x7) << 1) | ((byte1 >> 7) & 1);
180 grsave = (byte1 & 0x7f);
181 rlen = unw_decode_uleb128 (&dp);
182 UNW_DEC_PROLOGUE_GR(R2, rlen, mask, grsave, arg);
183 return dp;
184}
185
186static unsigned char *
187unw_decode_r3 (unsigned char *dp, unsigned char code, void *arg)
188{
189 unw_word rlen;
190
191 rlen = unw_decode_uleb128 (&dp);
192 UNW_DEC_PROLOGUE(R3, ((code & 0x3) == 1), rlen, arg);
193 return dp;
194}
195
196static unsigned char *
197unw_decode_p1 (unsigned char *dp, unsigned char code, void *arg)
198{
199 unsigned char brmask = (code & 0x1f);
200
201 UNW_DEC_BR_MEM(P1, brmask, arg);
202 return dp;
203}
204
205static unsigned char *
206unw_decode_p2_p5 (unsigned char *dp, unsigned char code, void *arg)
207{
208 if ((code & 0x10) == 0)
209 {
210 unsigned char byte1 = *dp++;
211
212 UNW_DEC_BR_GR(P2, ((code & 0xf) << 1) | ((byte1 >> 7) & 1),
213 (byte1 & 0x7f), arg);
214 }
215 else if ((code & 0x08) == 0)
216 {
217 unsigned char byte1 = *dp++, r, dst;
218
219 r = ((code & 0x7) << 1) | ((byte1 >> 7) & 1);
220 dst = (byte1 & 0x7f);
221 switch (r)
222 {
223 case 0: UNW_DEC_REG_GR(P3, UNW_REG_PSP, dst, arg); break;
224 case 1: UNW_DEC_REG_GR(P3, UNW_REG_RP, dst, arg); break;
225 case 2: UNW_DEC_REG_GR(P3, UNW_REG_PFS, dst, arg); break;
226 case 3: UNW_DEC_REG_GR(P3, UNW_REG_PR, dst, arg); break;
227 case 4: UNW_DEC_REG_GR(P3, UNW_REG_UNAT, dst, arg); break;
228 case 5: UNW_DEC_REG_GR(P3, UNW_REG_LC, dst, arg); break;
229 case 6: UNW_DEC_RP_BR(P3, dst, arg); break;
230 case 7: UNW_DEC_REG_GR(P3, UNW_REG_RNAT, dst, arg); break;
231 case 8: UNW_DEC_REG_GR(P3, UNW_REG_BSP, dst, arg); break;
232 case 9: UNW_DEC_REG_GR(P3, UNW_REG_BSPSTORE, dst, arg); break;
233 case 10: UNW_DEC_REG_GR(P3, UNW_REG_FPSR, dst, arg); break;
234 case 11: UNW_DEC_PRIUNAT_GR(P3, dst, arg); break;
235 default: UNW_DEC_BAD_CODE(r); break;
236 }
237 }
238 else if ((code & 0x7) == 0)
239 UNW_DEC_SPILL_MASK(P4, dp, arg);
240 else if ((code & 0x7) == 1)
241 {
242 unw_word grmask, frmask, byte1, byte2, byte3;
243
244 byte1 = *dp++; byte2 = *dp++; byte3 = *dp++;
245 grmask = ((byte1 >> 4) & 0xf);
246 frmask = ((byte1 & 0xf) << 16) | (byte2 << 8) | byte3;
247 UNW_DEC_FRGR_MEM(P5, grmask, frmask, arg);
248 }
249 else
250 UNW_DEC_BAD_CODE(code);
251 return dp;
252}
253
254static unsigned char *
255unw_decode_p6 (unsigned char *dp, unsigned char code, void *arg)
256{
257 int gregs = (code & 0x10) != 0;
258 unsigned char mask = (code & 0x0f);
259
260 if (gregs)
261 UNW_DEC_GR_MEM(P6, mask, arg);
262 else
263 UNW_DEC_FR_MEM(P6, mask, arg);
264 return dp;
265}
266
267static unsigned char *
268unw_decode_p7_p10 (unsigned char *dp, unsigned char code, void *arg)
269{
270 unsigned char r, byte1, byte2;
271 unw_word t, size;
272
273 if ((code & 0x10) == 0)
274 {
275 r = (code & 0xf);
276 t = unw_decode_uleb128 (&dp);
277 switch (r)
278 {
279 case 0:
280 size = unw_decode_uleb128 (&dp);
281 UNW_DEC_MEM_STACK_F(P7, t, size, arg);
282 break;
283
284 case 1: UNW_DEC_MEM_STACK_V(P7, t, arg); break;
285 case 2: UNW_DEC_SPILL_BASE(P7, t, arg); break;
286 case 3: UNW_DEC_REG_SPREL(P7, UNW_REG_PSP, t, arg); break;
287 case 4: UNW_DEC_REG_WHEN(P7, UNW_REG_RP, t, arg); break;
288 case 5: UNW_DEC_REG_PSPREL(P7, UNW_REG_RP, t, arg); break;
289 case 6: UNW_DEC_REG_WHEN(P7, UNW_REG_PFS, t, arg); break;
290 case 7: UNW_DEC_REG_PSPREL(P7, UNW_REG_PFS, t, arg); break;
291 case 8: UNW_DEC_REG_WHEN(P7, UNW_REG_PR, t, arg); break;
292 case 9: UNW_DEC_REG_PSPREL(P7, UNW_REG_PR, t, arg); break;
293 case 10: UNW_DEC_REG_WHEN(P7, UNW_REG_LC, t, arg); break;
294 case 11: UNW_DEC_REG_PSPREL(P7, UNW_REG_LC, t, arg); break;
295 case 12: UNW_DEC_REG_WHEN(P7, UNW_REG_UNAT, t, arg); break;
296 case 13: UNW_DEC_REG_PSPREL(P7, UNW_REG_UNAT, t, arg); break;
297 case 14: UNW_DEC_REG_WHEN(P7, UNW_REG_FPSR, t, arg); break;
298 case 15: UNW_DEC_REG_PSPREL(P7, UNW_REG_FPSR, t, arg); break;
299 default: UNW_DEC_BAD_CODE(r); break;
300 }
301 }
302 else
303 {
304 switch (code & 0xf)
305 {
306 case 0x0: /* p8 */
307 {
308 r = *dp++;
309 t = unw_decode_uleb128 (&dp);
310 switch (r)
311 {
312 case 1: UNW_DEC_REG_SPREL(P8, UNW_REG_RP, t, arg); break;
313 case 2: UNW_DEC_REG_SPREL(P8, UNW_REG_PFS, t, arg); break;
314 case 3: UNW_DEC_REG_SPREL(P8, UNW_REG_PR, t, arg); break;
315 case 4: UNW_DEC_REG_SPREL(P8, UNW_REG_LC, t, arg); break;
316 case 5: UNW_DEC_REG_SPREL(P8, UNW_REG_UNAT, t, arg); break;
317 case 6: UNW_DEC_REG_SPREL(P8, UNW_REG_FPSR, t, arg); break;
318 case 7: UNW_DEC_REG_WHEN(P8, UNW_REG_BSP, t, arg); break;
319 case 8: UNW_DEC_REG_PSPREL(P8, UNW_REG_BSP, t, arg); break;
320 case 9: UNW_DEC_REG_SPREL(P8, UNW_REG_BSP, t, arg); break;
321 case 10: UNW_DEC_REG_WHEN(P8, UNW_REG_BSPSTORE, t, arg); break;
322 case 11: UNW_DEC_REG_PSPREL(P8, UNW_REG_BSPSTORE, t, arg); break;
323 case 12: UNW_DEC_REG_SPREL(P8, UNW_REG_BSPSTORE, t, arg); break;
324 case 13: UNW_DEC_REG_WHEN(P8, UNW_REG_RNAT, t, arg); break;
325 case 14: UNW_DEC_REG_PSPREL(P8, UNW_REG_RNAT, t, arg); break;
326 case 15: UNW_DEC_REG_SPREL(P8, UNW_REG_RNAT, t, arg); break;
327 case 16: UNW_DEC_PRIUNAT_WHEN_GR(P8, t, arg); break;
328 case 17: UNW_DEC_PRIUNAT_PSPREL(P8, t, arg); break;
329 case 18: UNW_DEC_PRIUNAT_SPREL(P8, t, arg); break;
330 case 19: UNW_DEC_PRIUNAT_WHEN_MEM(P8, t, arg); break;
331 default: UNW_DEC_BAD_CODE(r); break;
332 }
333 }
334 break;
335
336 case 0x1:
337 byte1 = *dp++; byte2 = *dp++;
338 UNW_DEC_GR_GR(P9, (byte1 & 0xf), (byte2 & 0x7f), arg);
339 break;
340
341 case 0xf: /* p10 */
342 byte1 = *dp++; byte2 = *dp++;
343 UNW_DEC_ABI(P10, byte1, byte2, arg);
344 break;
345
346 case 0x9:
347 return unw_decode_x1 (dp, code, arg);
348
349 case 0xa:
350 return unw_decode_x2 (dp, code, arg);
351
352 case 0xb:
353 return unw_decode_x3 (dp, code, arg);
354
355 case 0xc:
356 return unw_decode_x4 (dp, code, arg);
357
358 default:
359 UNW_DEC_BAD_CODE(code);
360 break;
361 }
362 }
363 return dp;
364}
365
366static unsigned char *
367unw_decode_b1 (unsigned char *dp, unsigned char code, void *arg)
368{
369 unw_word label = (code & 0x1f);
370
371 if ((code & 0x20) != 0)
372 UNW_DEC_COPY_STATE(B1, label, arg);
373 else
374 UNW_DEC_LABEL_STATE(B1, label, arg);
375 return dp;
376}
377
378static unsigned char *
379unw_decode_b2 (unsigned char *dp, unsigned char code, void *arg)
380{
381 unw_word t;
382
383 t = unw_decode_uleb128 (&dp);
384 UNW_DEC_EPILOGUE(B2, t, (code & 0x1f), arg);
385 return dp;
386}
387
388static unsigned char *
389unw_decode_b3_x4 (unsigned char *dp, unsigned char code, void *arg)
390{
391 unw_word t, ecount, label;
392
393 if ((code & 0x10) == 0)
394 {
395 t = unw_decode_uleb128 (&dp);
396 ecount = unw_decode_uleb128 (&dp);
397 UNW_DEC_EPILOGUE(B3, t, ecount, arg);
398 }
399 else if ((code & 0x07) == 0)
400 {
401 label = unw_decode_uleb128 (&dp);
402 if ((code & 0x08) != 0)
403 UNW_DEC_COPY_STATE(B4, label, arg);
404 else
405 UNW_DEC_LABEL_STATE(B4, label, arg);
406 }
407 else
408 switch (code & 0x7)
409 {
410 case 1: return unw_decode_x1 (dp, code, arg);
411 case 2: return unw_decode_x2 (dp, code, arg);
412 case 3: return unw_decode_x3 (dp, code, arg);
413 case 4: return unw_decode_x4 (dp, code, arg);
414 default: UNW_DEC_BAD_CODE(code); break;
415 }
416 return dp;
417}
418
419typedef unsigned char *(*unw_decoder) (unsigned char *, unsigned char, void *);
420
421static unw_decoder unw_decode_table[2][8] =
422{
423 /* prologue table: */
424 {
425 unw_decode_r1, /* 0 */
426 unw_decode_r1,
427 unw_decode_r2,
428 unw_decode_r3,
429 unw_decode_p1, /* 4 */
430 unw_decode_p2_p5,
431 unw_decode_p6,
432 unw_decode_p7_p10
433 },
434 {
435 unw_decode_r1, /* 0 */
436 unw_decode_r1,
437 unw_decode_r2,
438 unw_decode_r3,
439 unw_decode_b1, /* 4 */
440 unw_decode_b1,
441 unw_decode_b2,
442 unw_decode_b3_x4
443 }
444};
445
446/*
447 * Decode one descriptor and return address of next descriptor.
448 */
449static inline unsigned char *
450unw_decode (unsigned char *dp, int inside_body, void *arg)
451{
452 unw_decoder decoder;
453 unsigned char code;
454
455 code = *dp++;
456 decoder = unw_decode_table[inside_body][code >> 5];
457 dp = (*decoder) (dp, code, arg);
458 return dp;
459}
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-26 19:37:42 -0500