git.oblomov.eu Git - linux-2.6/blob - arch/ia64/kernel/unwind_decoder.c

   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 }