~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/ia64/kernel/unwind_decoder.c

Version: ~ [ linux-5.4-rc1 ] ~ [ linux-5.3.2 ] ~ [ linux-5.2.18 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.76 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.146 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.194 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.194 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.74 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 
 65 static unw_word
 66 unw_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 
 84 static unsigned char *
 85 unw_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 
101 static unsigned char *
102 unw_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 
119 static unsigned char *
120 unw_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 
139 static unsigned char *
140 unw_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 
160 static unsigned char *
161 unw_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 
171 static unsigned char *
172 unw_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 
186 static unsigned char *
187 unw_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 
196 static unsigned char *
197 unw_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 
205 static unsigned char *
206 unw_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 
254 static unsigned char *
255 unw_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 
267 static unsigned char *
268 unw_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 
366 static unsigned char *
367 unw_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 
378 static unsigned char *
379 unw_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 
388 static unsigned char *
389 unw_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 
419 typedef unsigned char *(*unw_decoder) (unsigned char *, unsigned char, void *);
420 
421 static 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  */
449 static inline unsigned char *
450 unw_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 }
460 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp