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