root/arch/ia64/kernel/unwind_decoder.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. unw_decode_uleb128
  2. unw_decode_x1
  3. unw_decode_x2
  4. unw_decode_x3
  5. unw_decode_x4
  6. unw_decode_r1
  7. unw_decode_r2
  8. unw_decode_r3
  9. unw_decode_p1
  10. unw_decode_p2_p5
  11. unw_decode_p6
  12. unw_decode_p7_p10
  13. unw_decode_b1
  14. unw_decode_b2
  15. unw_decode_b3_x4
  16. unw_decode
   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
  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 }
/* [<][>][^][v][top][bottom][index][help] */