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