1 // SPDX-License-Identifier: GPL-2.0
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
unw_decode_uleb128(unsigned char ** dpp)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 *
unw_decode_x1(unsigned char * dp,unsigned char code,void * arg)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 *
unw_decode_x2(unsigned char * dp,unsigned char code,void * arg)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 *
unw_decode_x3(unsigned char * dp,unsigned char code,void * arg)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 *
unw_decode_x4(unsigned char * dp,unsigned char code,void * arg)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 *
unw_decode_r1(unsigned char * dp,unsigned char code,void * arg)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 *
unw_decode_r2(unsigned char * dp,unsigned char code,void * arg)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 *
unw_decode_r3(unsigned char * dp,unsigned char code,void * arg)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 *
unw_decode_p1(unsigned char * dp,unsigned char code,void * arg)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 *
unw_decode_p2_p5(unsigned char * dp,unsigned char code,void * arg)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 *
unw_decode_p6(unsigned char * dp,unsigned char code,void * arg)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 *
unw_decode_p7_p10(unsigned char * dp,unsigned char code,void * arg)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 *
unw_decode_b1(unsigned char * dp,unsigned char code,void * arg)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 *
unw_decode_b2(unsigned char * dp,unsigned char code,void * arg)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 *
unw_decode_b3_x4(unsigned char * dp,unsigned char code,void * arg)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 *
unw_decode(unsigned char * dp,int inside_body,void * arg)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 }
461