binutils/unwind-ia64.c

   1 /* unwind-ia64.c -- utility routines to dump IA-64 unwind info for readelf.
   2    Copyright (C) 2000-2021 Free Software Foundation, Inc.
   3
   4    Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
   5
   6    This file is part of GNU Binutils.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3, or (at your option)
  11    any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, 51 Franklin Street - Fifth Floor, Boston,
  21    MA 02110-1301, USA.  */
  22
  23 #include "config.h"
  24 #include "sysdep.h"
  25 #include "unwind-ia64.h"
  26
  27 #if __GNUC__ >= 2
  28 /* Define BFD64 here, even if our default architecture is 32 bit ELF
  29    as this will allow us to read in and parse 64bit and 32bit ELF files.
  30    Only do this if we believe that the compiler can support a 64 bit
  31    data type.  For now we only rely on GCC being able to do this.  */
  32 #define BFD64
  33 #endif
  34 #include "bfd.h"
  35
  36 static bfd_vma unw_rlen = 0;
  37
  38 static void unw_print_brmask (char *, unsigned int);
  39 static void unw_print_grmask (char *, unsigned int);
  40 static void unw_print_frmask (char *, unsigned int);
  41 static void unw_print_abreg (char *, unsigned int);
  42 static void unw_print_xyreg (char *, unsigned int, unsigned int);
  43
  44 static void
  45 unw_print_brmask (char *cp, unsigned int mask)
  46 {
  47   int sep = 0;
  48   int i;
  49
  50   for (i = 0; mask && (i < 5); ++i)
  51     {
  52       if (mask & 1)
  53         {
  54           if (sep)
  55             *cp++ = ',';
  56           *cp++ = 'b';
  57           *cp++ = i + 1 + '0';
  58           sep = 1;
  59         }
  60       mask >>= 1;
  61     }
  62   *cp = '\0';
  63 }
  64
  65 static void
  66 unw_print_grmask (char *cp, unsigned int mask)
  67 {
  68   int sep = 0;
  69   int i;
  70
  71   for (i = 0; i < 4; ++i)
  72     {
  73       if (mask & 1)
  74         {
  75           if (sep)
  76             *cp++ = ',';
  77           *cp++ = 'r';
  78           *cp++ = i + 4 + '0';
  79           sep = 1;
  80         }
  81       mask >>= 1;
  82     }
  83   *cp = '\0';
  84 }
  85
  86 static void
  87 unw_print_frmask (char *cp, unsigned int mask)
  88 {
  89   int sep = 0;
  90   int i;
  91
  92   for (i = 0; i < 20; ++i)
  93     {
  94       if (mask & 1)
  95         {
  96           if (sep)
  97             *cp++ = ',';
  98           *cp++ = 'f';
  99           if (i < 4)
 100             *cp++ = i + 2 + '0';
 101           else
 102             {
 103               *cp++ = (i + 2) / 10 + 1 + '0';
 104               *cp++ = (i + 2) % 10 + '0';
 105             }
 106           sep = 1;
 107         }
 108       mask >>= 1;
 109     }
 110   *cp = '\0';
 111 }
 112
 113 static void
 114 unw_print_abreg (char *cp, unsigned int abreg)
 115 {
 116   static const char * const special_reg[16] =
 117   {
 118     "pr", "psp", "@priunat", "rp", "ar.bsp", "ar.bspstore", "ar.rnat",
 119     "ar.unat", "ar.fpsr", "ar.pfs", "ar.lc",
 120     "Unknown11", "Unknown12", "Unknown13", "Unknown14", "Unknown15"
 121   };
 122
 123   switch ((abreg >> 5) & 0x3)
 124     {
 125     case 0: /* gr */
 126       sprintf (cp, "r%u", (abreg & 0x1f));
 127       break;
 128
 129     case 1: /* fr */
 130       sprintf (cp, "f%u", (abreg & 0x1f));
 131       break;
 132
 133     case 2: /* br */
 134       sprintf (cp, "b%u", (abreg & 0x1f));
 135       break;
 136
 137     case 3: /* special */
 138       strcpy (cp, special_reg[abreg & 0xf]);
 139       break;
 140     }
 141 }
 142
 143 static void
 144 unw_print_xyreg (char *cp, unsigned int x, unsigned int ytreg)
 145 {
 146   switch ((x << 1) | ((ytreg >> 7) & 1))
 147     {
 148     case 0: /* gr */
 149       sprintf (cp, "r%u", (ytreg & 0x1f));
 150       break;
 151
 152     case 1: /* fr */
 153       sprintf (cp, "f%u", (ytreg & 0x1f));
 154       break;
 155
 156     case 2: /* br */
 157       sprintf (cp, "b%u", (ytreg & 0x1f));
 158       break;
 159
 160     default:
 161       strcpy (cp, "invalid");
 162       break;
 163     }
 164 }
 165
 166 #define UNW_REG_BSP             "bsp"
 167 #define UNW_REG_BSPSTORE        "bspstore"
 168 #define UNW_REG_FPSR            "fpsr"
 169 #define UNW_REG_LC              "lc"
 170 #define UNW_REG_PFS             "pfs"
 171 #define UNW_REG_PR              "pr"
 172 #define UNW_REG_PSP             "psp"
 173 #define UNW_REG_RNAT            "rnat"
 174 #define UNW_REG_RP              "rp"
 175 #define UNW_REG_UNAT            "unat"
 176
 177 typedef bfd_vma unw_word;
 178
 179 #define UNW_DEC_BAD_CODE(code)                  \
 180   printf (_("Unknown code 0x%02x\n"), code)
 181
 182 #define UNW_DEC_PROLOGUE(fmt, body, rlen, arg)                                  \
 183   do                                                                            \
 184     {                                                                           \
 185       unw_rlen = rlen;                                                          \
 186       *(int *)arg = body;                                                       \
 187       printf ("    %s:%s(rlen=%lu)\n",                                          \
 188               fmt, body ? "body" : "prologue", (unsigned long) rlen);           \
 189     }                                                                           \
 190   while (0)
 191
 192 #define UNW_DEC_PROLOGUE_GR(fmt, rlen, mask, grsave, arg)                       \
 193   do                                                                            \
 194     {                                                                           \
 195       char regname[16], maskstr[64], *sep;                                      \
 196                                                                                 \
 197       unw_rlen = rlen;                                                          \
 198       *(int *)arg = 0;                                                          \
 199                                                                                 \
 200       maskstr[0] = '\0';                                                        \
 201       sep = "";                                                                 \
 202       if (mask & 0x8)                                                           \
 203         {                                                                       \
 204           strcat (maskstr, "rp");                                               \
 205           sep = ",";                                                            \
 206         }                                                                       \
 207       if (mask & 0x4)                                                           \
 208         {                                                                       \
 209           strcat (maskstr, sep);                                                \
 210           strcat (maskstr, "ar.pfs");                                           \
 211           sep = ",";                                                            \
 212         }                                                                       \
 213       if (mask & 0x2)                                                           \
 214         {                                                                       \
 215           strcat (maskstr, sep);                                                \
 216           strcat (maskstr, "psp");                                              \
 217           sep = ",";                                                            \
 218         }                                                                       \
 219       if (mask & 0x1)                                                           \
 220         {                                                                       \
 221           strcat (maskstr, sep);                                                \
 222           strcat (maskstr, "pr");                                               \
 223         }                                                                       \
 224       sprintf (regname, "r%u", grsave);                                         \
 225       printf ("    %s:prologue_gr(mask=[%s],grsave=%s,rlen=%lu)\n",             \
 226               fmt, maskstr, regname, (unsigned long) rlen);                     \
 227     }                                                                           \
 228   while (0)
 229
 230 #define UNW_DEC_FR_MEM(fmt, frmask, arg)                        \
 231   do                                                            \
 232     {                                                           \
 233       char frstr[200];                                          \
 234                                                                 \
 235       unw_print_frmask (frstr, frmask);                         \
 236       printf ("\t%s:fr_mem(frmask=[%s])\n", fmt, frstr);        \
 237     }                                                           \
 238   while (0)
 239
 240 #define UNW_DEC_GR_MEM(fmt, grmask, arg)                        \
 241   do                                                            \
 242     {                                                           \
 243       char grstr[200];                                          \
 244                                                                 \
 245       unw_print_grmask (grstr, grmask);                         \
 246       printf ("\t%s:gr_mem(grmask=[%s])\n", fmt, grstr);        \
 247     }                                                           \
 248   while (0)
 249
 250 #define UNW_DEC_FRGR_MEM(fmt, grmask, frmask, arg)                              \
 251   do                                                                            \
 252     {                                                                           \
 253       char frstr[200], grstr[20];                                               \
 254                                                                                 \
 255       unw_print_grmask (grstr, grmask);                                         \
 256       unw_print_frmask (frstr, frmask);                                         \
 257       printf ("\t%s:frgr_mem(grmask=[%s],frmask=[%s])\n", fmt, grstr, frstr);   \
 258     }                                                                           \
 259   while (0)
 260
 261 #define UNW_DEC_BR_MEM(fmt, brmask, arg)                                \
 262   do                                                                    \
 263     {                                                                   \
 264       char brstr[20];                                                   \
 265                                                                         \
 266       unw_print_brmask (brstr, brmask);                                 \
 267       printf ("\t%s:br_mem(brmask=[%s])\n", fmt, brstr);                \
 268     }                                                                   \
 269   while (0)
 270
 271 #define UNW_DEC_BR_GR(fmt, brmask, gr, arg)                             \
 272   do                                                                    \
 273     {                                                                   \
 274       char brstr[20];                                                   \
 275                                                                         \
 276       unw_print_brmask (brstr, brmask);                                 \
 277       printf ("\t%s:br_gr(brmask=[%s],gr=r%u)\n", fmt, brstr, gr);      \
 278     }                                                                   \
 279   while (0)
 280
 281 #define UNW_DEC_REG_GR(fmt, src, dst, arg)              \
 282   printf ("\t%s:%s_gr(reg=r%u)\n", fmt, src, dst)
 283
 284 #define UNW_DEC_RP_BR(fmt, dst, arg)            \
 285   printf ("\t%s:rp_br(reg=b%u)\n", fmt, dst)
 286
 287 #define UNW_DEC_REG_WHEN(fmt, reg, t, arg)                              \
 288   printf ("\t%s:%s_when(t=%lu)\n", fmt, reg, (unsigned long) t)
 289
 290 #define UNW_DEC_REG_SPREL(fmt, reg, spoff, arg)         \
 291   printf ("\t%s:%s_sprel(spoff=0x%lx)\n",               \
 292           fmt, reg, 4*(unsigned long)spoff)
 293
 294 #define UNW_DEC_REG_PSPREL(fmt, reg, pspoff, arg)               \
 295   printf ("\t%s:%s_psprel(pspoff=0x10-0x%lx)\n",                \
 296           fmt, reg, 4*(unsigned long)pspoff)
 297
 298 #define UNW_DEC_GR_GR(fmt, grmask, gr, arg)                             \
 299   do                                                                    \
 300     {                                                                   \
 301       char grstr[20];                                                   \
 302                                                                         \
 303       unw_print_grmask (grstr, grmask);                                 \
 304       printf ("\t%s:gr_gr(grmask=[%s],r%u)\n", fmt, grstr, gr);         \
 305     }                                                                   \
 306   while (0)
 307
 308 #define UNW_DEC_ABI(fmt, abi, context, arg)                     \
 309   do                                                            \
 310     {                                                           \
 311       static const char * const abiname[] =                     \
 312       {                                                         \
 313         "@svr4", "@hpux", "@nt"                                 \
 314       };                                                        \
 315       char buf[20];                                             \
 316       const char *abistr = buf;                                 \
 317                                                                 \
 318       if (abi < 3)                                              \
 319         abistr = abiname[abi];                                  \
 320       else                                                      \
 321         sprintf (buf, "0x%x", abi);                             \
 322       printf ("\t%s:unwabi(abi=%s,context=0x%02x)\n",           \
 323               fmt, abistr, context);                            \
 324     }                                                           \
 325   while (0)
 326
 327 #define UNW_DEC_PRIUNAT_GR(fmt, r, arg)         \
 328   printf ("\t%s:priunat_gr(reg=r%u)\n", fmt, r)
 329
 330 #define UNW_DEC_PRIUNAT_WHEN_GR(fmt, t, arg)                            \
 331   printf ("\t%s:priunat_when_gr(t=%lu)\n", fmt, (unsigned long) t)
 332
 333 #define UNW_DEC_PRIUNAT_WHEN_MEM(fmt, t, arg)                           \
 334   printf ("\t%s:priunat_when_mem(t=%lu)\n", fmt, (unsigned long) t)
 335
 336 #define UNW_DEC_PRIUNAT_PSPREL(fmt, pspoff, arg)                \
 337   printf ("\t%s:priunat_psprel(pspoff=0x10-0x%lx)\n",           \
 338           fmt, 4*(unsigned long)pspoff)
 339
 340 #define UNW_DEC_PRIUNAT_SPREL(fmt, spoff, arg)          \
 341   printf ("\t%s:priunat_sprel(spoff=0x%lx)\n",          \
 342           fmt, 4*(unsigned long)spoff)
 343
 344 #define UNW_DEC_MEM_STACK_F(fmt, t, size, arg)          \
 345   printf ("\t%s:mem_stack_f(t=%lu,size=%lu)\n",         \
 346           fmt, (unsigned long) t, 16*(unsigned long)size)
 347
 348 #define UNW_DEC_MEM_STACK_V(fmt, t, arg)                                \
 349   printf ("\t%s:mem_stack_v(t=%lu)\n", fmt, (unsigned long) t)
 350
 351 #define UNW_DEC_SPILL_BASE(fmt, pspoff, arg)                    \
 352   printf ("\t%s:spill_base(pspoff=0x10-0x%lx)\n",               \
 353           fmt, 4*(unsigned long)pspoff)
 354
 355 #define UNW_DEC_SPILL_MASK(fmt, dp, arg, end)                           \
 356   do                                                                    \
 357     {                                                                   \
 358       static const char *spill_type = "-frb";                           \
 359       unsigned const char *imaskp = dp;                                 \
 360       unsigned char mask = 0;                                           \
 361       bfd_vma insn = 0;                                                 \
 362                                                                         \
 363       /* PR 18420.  */                                                  \
 364       if ((dp + (unw_rlen / 4)) > end)                                  \
 365         {                                                               \
 366           printf (_("\nERROR: unwind length too long (0x%lx > 0x%lx)\n\n"), \
 367                   (long) (unw_rlen / 4), (long)(end - dp));             \
 368           /* FIXME: Should we reset unw_rlen ?  */                      \
 369           break;                                                        \
 370         }                                                               \
 371       printf ("\t%s:spill_mask(imask=[", fmt);                                  \
 372       for (insn = 0; insn < unw_rlen; ++insn)                                   \
 373         {                                                                       \
 374           if ((insn % 4) == 0)                                                  \
 375             mask = *imaskp++;                                                   \
 376           if (insn > 0 && (insn % 3) == 0)                                      \
 377             putchar (',');                                                      \
 378           putchar (spill_type[(mask >> (2 * (3 - (insn & 0x3)))) & 0x3]);       \
 379         }                                                                       \
 380       printf ("])\n");                                                          \
 381       dp = imaskp;                                                              \
 382     }                                                                           \
 383   while (0)
 384
 385 #define UNW_DEC_SPILL_SPREL(fmt, t, abreg, spoff, arg)                          \
 386   do                                                                            \
 387     {                                                                           \
 388       char regname[20];                                                         \
 389                                                                                 \
 390       unw_print_abreg (regname, abreg);                                         \
 391       printf ("\t%s:spill_sprel(reg=%s,t=%lu,spoff=0x%lx)\n",                   \
 392               fmt, regname, (unsigned long) t, 4*(unsigned long)off);           \
 393     }                                                                           \
 394   while (0)
 395
 396 #define UNW_DEC_SPILL_PSPREL(fmt, t, abreg, pspoff, arg)                        \
 397   do                                                                            \
 398     {                                                                           \
 399       char regname[20];                                                         \
 400                                                                                 \
 401       unw_print_abreg (regname, abreg);                                         \
 402       printf ("\t%s:spill_psprel(reg=%s,t=%lu,pspoff=0x10-0x%lx)\n",            \
 403               fmt, regname, (unsigned long) t, 4*(unsigned long)pspoff);        \
 404     }                                                                           \
 405   while (0)
 406
 407 #define UNW_DEC_RESTORE(fmt, t, abreg, arg)                     \
 408   do                                                            \
 409     {                                                           \
 410       char regname[20];                                         \
 411                                                                 \
 412       unw_print_abreg (regname, abreg);                         \
 413       printf ("\t%s:restore(t=%lu,reg=%s)\n",                   \
 414               fmt, (unsigned long) t, regname);                 \
 415     }                                                           \
 416   while (0)
 417
 418 #define UNW_DEC_SPILL_REG(fmt, t, abreg, x, ytreg, arg)         \
 419   do                                                            \
 420     {                                                           \
 421       char abregname[20], tregname[20];                         \
 422                                                                 \
 423       unw_print_abreg (abregname, abreg);                       \
 424       unw_print_xyreg (tregname, x, ytreg);                     \
 425       printf ("\t%s:spill_reg(t=%lu,reg=%s,treg=%s)\n",         \
 426               fmt, (unsigned long) t, abregname, tregname);     \
 427     }                                                           \
 428   while (0)
 429
 430 #define UNW_DEC_SPILL_SPREL_P(fmt, qp, t, abreg, spoff, arg)                        \
 431   do                                                                                \
 432     {                                                                               \
 433       char regname[20];                                                             \
 434                                                                                     \
 435       unw_print_abreg (regname, abreg);                                             \
 436       printf ("\t%s:spill_sprel_p(qp=p%u,t=%lu,reg=%s,spoff=0x%lx)\n",              \
 437               fmt, qp, (unsigned long) t, regname, 4 * (unsigned long)spoff);       \
 438     }                                                                               \
 439   while (0)
 440
 441 #define UNW_DEC_SPILL_PSPREL_P(fmt, qp, t, abreg, pspoff, arg)          \
 442   do                                                                    \
 443     {                                                                   \
 444       char regname[20];                                                 \
 445                                                                         \
 446       unw_print_abreg (regname, abreg);                                 \
 447       printf ("\t%s:spill_psprel_p(qp=p%u,t=%lu,reg=%s,pspoff=0x10-0x%lx)\n",\
 448               fmt, qp, (unsigned long) t, regname, 4*(unsigned long)pspoff);\
 449     }                                                                   \
 450   while (0)
 451
 452 #define UNW_DEC_RESTORE_P(fmt, qp, t, abreg, arg)                       \
 453   do                                                                    \
 454     {                                                                   \
 455       char regname[20];                                                 \
 456                                                                         \
 457       unw_print_abreg (regname, abreg);                                 \
 458       printf ("\t%s:restore_p(qp=p%u,t=%lu,reg=%s)\n",                  \
 459               fmt, qp, (unsigned long) t, regname);                     \
 460     }                                                                   \
 461   while (0)
 462
 463 #define UNW_DEC_SPILL_REG_P(fmt, qp, t, abreg, x, ytreg, arg)           \
 464   do                                                                    \
 465     {                                                                   \
 466       char regname[20], tregname[20];                                   \
 467                                                                         \
 468       unw_print_abreg (regname, abreg);                                 \
 469       unw_print_xyreg (tregname, x, ytreg);                             \
 470       printf ("\t%s:spill_reg_p(qp=p%u,t=%lu,reg=%s,treg=%s)\n",        \
 471               fmt, qp, (unsigned long) t, regname, tregname);           \
 472     }                                                                   \
 473   while (0)
 474
 475 #define UNW_DEC_LABEL_STATE(fmt, label, arg)                            \
 476   printf ("\t%s:label_state(label=%lu)\n", fmt, (unsigned long) label)
 477
 478 #define UNW_DEC_COPY_STATE(fmt, label, arg)                             \
 479   printf ("\t%s:copy_state(label=%lu)\n", fmt, (unsigned long) label)
 480
 481 #define UNW_DEC_EPILOGUE(fmt, t, ecount, arg)           \
 482   printf ("\t%s:epilogue(t=%lu,ecount=%lu)\n",          \
 483           fmt, (unsigned long) t, (unsigned long) ecount)
 484
 485 /*
 486  * Generic IA-64 unwind info decoder.
 487  *
 488  * This file is used both by the Linux kernel and objdump.  Please
 489  * keep the two copies of this file in sync (modulo differences in the
 490  * prototypes...).
 491  *
 492  * You need to customize the decoder by defining the following
 493  * macros/constants before including this file:
 494  *
 495  *  Types:
 496  *      unw_word        Unsigned integer type with at least 64 bits
 497  *
 498  *  Register names:
 499  *      UNW_REG_BSP
 500  *      UNW_REG_BSPSTORE
 501  *      UNW_REG_FPSR
 502  *      UNW_REG_LC
 503  *      UNW_REG_PFS
 504  *      UNW_REG_PR
 505  *      UNW_REG_RNAT
 506  *      UNW_REG_PSP
 507  *      UNW_REG_RP
 508  *      UNW_REG_UNAT
 509  *
 510  *  Decoder action macros:
 511  *      UNW_DEC_BAD_CODE(code)
 512  *      UNW_DEC_ABI(fmt,abi,context,arg)
 513  *      UNW_DEC_BR_GR(fmt,brmask,gr,arg)
 514  *      UNW_DEC_BR_MEM(fmt,brmask,arg)
 515  *      UNW_DEC_COPY_STATE(fmt,label,arg)
 516  *      UNW_DEC_EPILOGUE(fmt,t,ecount,arg)
 517  *      UNW_DEC_FRGR_MEM(fmt,grmask,frmask,arg)
 518  *      UNW_DEC_FR_MEM(fmt,frmask,arg)
 519  *      UNW_DEC_GR_GR(fmt,grmask,gr,arg)
 520  *      UNW_DEC_GR_MEM(fmt,grmask,arg)
 521  *      UNW_DEC_LABEL_STATE(fmt,label,arg)
 522  *      UNW_DEC_MEM_STACK_F(fmt,t,size,arg)
 523  *      UNW_DEC_MEM_STACK_V(fmt,t,arg)
 524  *      UNW_DEC_PRIUNAT_GR(fmt,r,arg)
 525  *      UNW_DEC_PRIUNAT_WHEN_GR(fmt,t,arg)
 526  *      UNW_DEC_PRIUNAT_WHEN_MEM(fmt,t,arg)
 527  *      UNW_DEC_PRIUNAT_WHEN_PSPREL(fmt,pspoff,arg)
 528  *      UNW_DEC_PRIUNAT_WHEN_SPREL(fmt,spoff,arg)
 529  *      UNW_DEC_PROLOGUE(fmt,body,rlen,arg)
 530  *      UNW_DEC_PROLOGUE_GR(fmt,rlen,mask,grsave,arg)
 531  *      UNW_DEC_REG_PSPREL(fmt,reg,pspoff,arg)
 532  *      UNW_DEC_REG_REG(fmt,src,dst,arg)
 533  *      UNW_DEC_REG_SPREL(fmt,reg,spoff,arg)
 534  *      UNW_DEC_REG_WHEN(fmt,reg,t,arg)
 535  *      UNW_DEC_RESTORE(fmt,t,abreg,arg)
 536  *      UNW_DEC_RESTORE_P(fmt,qp,t,abreg,arg)
 537  *      UNW_DEC_SPILL_BASE(fmt,pspoff,arg)
 538  *      UNW_DEC_SPILL_MASK(fmt,imaskp,arg)
 539  *      UNW_DEC_SPILL_PSPREL(fmt,t,abreg,pspoff,arg)
 540  *      UNW_DEC_SPILL_PSPREL_P(fmt,qp,t,abreg,pspoff,arg)
 541  *      UNW_DEC_SPILL_REG(fmt,t,abreg,x,ytreg,arg)
 542  *      UNW_DEC_SPILL_REG_P(fmt,qp,t,abreg,x,ytreg,arg)
 543  *      UNW_DEC_SPILL_SPREL(fmt,t,abreg,spoff,arg)
 544  *      UNW_DEC_SPILL_SPREL_P(fmt,qp,t,abreg,pspoff,arg)
 545  */
 546
 547 static unw_word
 548 unw_decode_uleb128 (const unsigned char **dpp, const unsigned char * end)
 549 {
 550   unsigned shift = 0;
 551   int status = 1;
 552   unw_word byte, result = 0;
 553   const unsigned char *bp = *dpp;
 554
 555   while (bp < end)
 556     {
 557       byte = *bp++;
 558       if (shift < sizeof (result) * 8)
 559         {
 560           result |= (byte & 0x7f) << shift;
 561           if ((result >> shift) != (byte & 0x7f))
 562             /* Overflow.  */
 563             status |= 2;
 564           shift += 7;
 565         }
 566       else if ((byte & 0x7f) != 0)
 567         status |= 2;
 568
 569       if ((byte & 0x80) == 0)
 570         {
 571           status &= ~1;
 572           break;
 573         }
 574     }
 575
 576   *dpp = bp;
 577   if (status != 0)
 578     printf (_("Bad uleb128\n"));
 579
 580   return result;
 581 }
 582
 583 static const unsigned char *
 584 unw_decode_x1 (const unsigned char *dp, unsigned int code ATTRIBUTE_UNUSED,
 585                void *arg ATTRIBUTE_UNUSED, const unsigned char * end)
 586 {
 587   unsigned char byte1, abreg;
 588   unw_word t, off;
 589
 590   if ((end - dp) < 3)
 591     {
 592       printf (_("\t<corrupt X1>\n"));
 593       return end;
 594     }
 595
 596   byte1 = *dp++;
 597   t = unw_decode_uleb128 (&dp, end);
 598   off = unw_decode_uleb128 (&dp, end);
 599   abreg = (byte1 & 0x7f);
 600   if (byte1 & 0x80)
 601     UNW_DEC_SPILL_SPREL ("X1", t, abreg, off, arg);
 602   else
 603     UNW_DEC_SPILL_PSPREL ("X1", t, abreg, off, arg);
 604   return dp;
 605 }
 606
 607 static const unsigned char *
 608 unw_decode_x2 (const unsigned char *dp, unsigned int code ATTRIBUTE_UNUSED,
 609                void *arg ATTRIBUTE_UNUSED, const unsigned char * end)
 610 {
 611   unsigned char byte1, byte2, abreg, x, ytreg;
 612   unw_word t;
 613
 614   if ((end - dp) < 3)
 615     {
 616       printf (_("\t<corrupt X2>\n"));
 617       return end;
 618     }
 619
 620   byte1 = *dp++;
 621   byte2 = *dp++;
 622   t = unw_decode_uleb128 (&dp, end);
 623   abreg = (byte1 & 0x7f);
 624   ytreg = byte2;
 625   x = (byte1 >> 7) & 1;
 626   if ((byte1 & 0x80) == 0 && ytreg == 0)
 627     UNW_DEC_RESTORE ("X2", t, abreg, arg);
 628   else
 629     UNW_DEC_SPILL_REG ("X2", t, abreg, x, ytreg, arg);
 630   return dp;
 631 }
 632
 633 static const unsigned char *
 634 unw_decode_x3 (const unsigned char *dp, unsigned int code ATTRIBUTE_UNUSED,
 635                void *arg ATTRIBUTE_UNUSED, const unsigned char * end)
 636 {
 637   unsigned char byte1, byte2, abreg, qp;
 638   unw_word t, off;
 639
 640   if ((end - dp) < 4)
 641     {
 642       printf (_("\t<corrupt X3>\n"));
 643       return end;
 644     }
 645
 646   byte1 = *dp++;
 647   byte2 = *dp++;
 648   t = unw_decode_uleb128 (&dp, end);
 649   off = unw_decode_uleb128 (&dp, end);
 650
 651   qp = (byte1 & 0x3f);
 652   abreg = (byte2 & 0x7f);
 653
 654   if (byte1 & 0x80)
 655     UNW_DEC_SPILL_SPREL_P ("X3", qp, t, abreg, off, arg);
 656   else
 657     UNW_DEC_SPILL_PSPREL_P ("X3", qp, t, abreg, off, arg);
 658   return dp;
 659 }
 660
 661 static const unsigned char *
 662 unw_decode_x4 (const unsigned char *dp, unsigned int code ATTRIBUTE_UNUSED,
 663                void *arg ATTRIBUTE_UNUSED, const unsigned char * end)
 664 {
 665   unsigned char byte1, byte2, byte3, qp, abreg, x, ytreg;
 666   unw_word t;
 667
 668   if ((end - dp) < 4)
 669     {
 670       printf (_("\t<corrupt X4>\n"));
 671       return end;
 672     }
 673
 674   byte1 = *dp++;
 675   byte2 = *dp++;
 676   byte3 = *dp++;
 677   t = unw_decode_uleb128 (&dp, end);
 678
 679   qp = (byte1 & 0x3f);
 680   abreg = (byte2 & 0x7f);
 681   x = (byte2 >> 7) & 1;
 682   ytreg = byte3;
 683
 684   if ((byte2 & 0x80) == 0 && byte3 == 0)
 685     UNW_DEC_RESTORE_P ("X4", qp, t, abreg, arg);
 686   else
 687     UNW_DEC_SPILL_REG_P ("X4", qp, t, abreg, x, ytreg, arg);
 688   return dp;
 689 }
 690
 691 static const unsigned char *
 692 unw_decode_r1 (const unsigned char *dp, unsigned int code, void *arg,
 693                const unsigned char * end ATTRIBUTE_UNUSED)
 694 {
 695   int body = (code & 0x20) != 0;
 696   unw_word rlen;
 697
 698   rlen = (code & 0x1f);
 699   UNW_DEC_PROLOGUE ("R1", body, rlen, arg);
 700   return dp;
 701 }
 702
 703 static const unsigned char *
 704 unw_decode_r2 (const unsigned char *dp, unsigned int code, void *arg,
 705                const unsigned char * end)
 706 {
 707   unsigned char byte1, mask, grsave;
 708   unw_word rlen;
 709
 710   if ((end - dp) < 2)
 711     {
 712       printf (_("\t<corrupt R2>\n"));
 713       return end;
 714     }
 715
 716   byte1 = *dp++;
 717
 718   mask = ((code & 0x7) << 1) | ((byte1 >> 7) & 1);
 719   grsave = (byte1 & 0x7f);
 720   rlen = unw_decode_uleb128 (& dp, end);
 721   UNW_DEC_PROLOGUE_GR ("R2", rlen, mask, grsave, arg);
 722   return dp;
 723 }
 724
 725 static const unsigned char *
 726 unw_decode_r3 (const unsigned char *dp, unsigned int code, void *arg,
 727                const unsigned char * end)
 728 {
 729   unw_word rlen;
 730
 731   rlen = unw_decode_uleb128 (& dp, end);
 732   UNW_DEC_PROLOGUE ("R3", ((code & 0x3) == 1), rlen, arg);
 733   return dp;
 734 }
 735
 736 static const unsigned char *
 737 unw_decode_p1 (const unsigned char *dp, unsigned int code,
 738                void *arg ATTRIBUTE_UNUSED,
 739                const unsigned char * end ATTRIBUTE_UNUSED)
 740 {
 741   unsigned char brmask = (code & 0x1f);
 742
 743   UNW_DEC_BR_MEM ("P1", brmask, arg);
 744   return dp;
 745 }
 746
 747 static const unsigned char *
 748 unw_decode_p2_p5 (const unsigned char *dp, unsigned int code,
 749                   void *arg ATTRIBUTE_UNUSED,
 750                   const unsigned char * end)
 751 {
 752   if ((code & 0x10) == 0)
 753     {
 754       unsigned char byte1;
 755
 756       if ((end - dp) < 1)
 757         {
 758           printf (_("\t<corrupt P2>\n"));
 759           return end;
 760         }
 761
 762       byte1 = *dp++;
 763
 764       UNW_DEC_BR_GR ("P2", ((code & 0xf) << 1) | ((byte1 >> 7) & 1),
 765                      (byte1 & 0x7f), arg);
 766     }
 767   else if ((code & 0x08) == 0)
 768     {
 769       unsigned char byte1, r, dst;
 770
 771       if ((end - dp) < 1)
 772         {
 773           printf (_("\t<corrupt P3>\n"));
 774           return end;
 775         }
 776
 777       byte1 = *dp++;
 778
 779       r = ((code & 0x7) << 1) | ((byte1 >> 7) & 1);
 780       dst = (byte1 & 0x7f);
 781       switch (r)
 782         {
 783         case 0:
 784           UNW_DEC_REG_GR ("P3", UNW_REG_PSP, dst, arg);
 785           break;
 786         case 1:
 787           UNW_DEC_REG_GR ("P3", UNW_REG_RP, dst, arg);
 788           break;
 789         case 2:
 790           UNW_DEC_REG_GR ("P3", UNW_REG_PFS, dst, arg);
 791           break;
 792         case 3:
 793           UNW_DEC_REG_GR ("P3", UNW_REG_PR, dst, arg);
 794           break;
 795         case 4:
 796           UNW_DEC_REG_GR ("P3", UNW_REG_UNAT, dst, arg);
 797           break;
 798         case 5:
 799           UNW_DEC_REG_GR ("P3", UNW_REG_LC, dst, arg);
 800           break;
 801         case 6:
 802           UNW_DEC_RP_BR ("P3", dst, arg);
 803           break;
 804         case 7:
 805           UNW_DEC_REG_GR ("P3", UNW_REG_RNAT, dst, arg);
 806           break;
 807         case 8:
 808           UNW_DEC_REG_GR ("P3", UNW_REG_BSP, dst, arg);
 809           break;
 810         case 9:
 811           UNW_DEC_REG_GR ("P3", UNW_REG_BSPSTORE, dst, arg);
 812           break;
 813         case 10:
 814           UNW_DEC_REG_GR ("P3", UNW_REG_FPSR, dst, arg);
 815           break;
 816         case 11:
 817           UNW_DEC_PRIUNAT_GR ("P3", dst, arg);
 818           break;
 819         default:
 820           UNW_DEC_BAD_CODE (r);
 821           break;
 822         }
 823     }
 824   else if ((code & 0x7) == 0)
 825     UNW_DEC_SPILL_MASK ("P4", dp, arg, end);
 826   else if ((code & 0x7) == 1)
 827     {
 828       unw_word grmask, frmask, byte1, byte2, byte3;
 829
 830       if ((end - dp) < 3)
 831         {
 832           printf (_("\t<corrupt P5>\n"));
 833           return end;
 834         }
 835       byte1 = *dp++;
 836       byte2 = *dp++;
 837       byte3 = *dp++;
 838       grmask = ((byte1 >> 4) & 0xf);
 839       frmask = ((byte1 & 0xf) << 16) | (byte2 << 8) | byte3;
 840       UNW_DEC_FRGR_MEM ("P5", grmask, frmask, arg);
 841     }
 842   else
 843     UNW_DEC_BAD_CODE (code);
 844
 845   return dp;
 846 }
 847
 848 static const unsigned char *
 849 unw_decode_p6 (const unsigned char *dp, unsigned int code,
 850                void *arg ATTRIBUTE_UNUSED,
 851                const unsigned char * end ATTRIBUTE_UNUSED)
 852 {
 853   int gregs = (code & 0x10) != 0;
 854   unsigned char mask = (code & 0x0f);
 855
 856   if (gregs)
 857     UNW_DEC_GR_MEM ("P6", mask, arg);
 858   else
 859     UNW_DEC_FR_MEM ("P6", mask, arg);
 860   return dp;
 861 }
 862
 863 static const unsigned char *
 864 unw_decode_p7_p10 (const unsigned char *dp, unsigned int code, void *arg,
 865                    const unsigned char * end)
 866 {
 867   unsigned char r, byte1, byte2;
 868   unw_word t, size;
 869
 870   if ((code & 0x10) == 0)
 871     {
 872       r = (code & 0xf);
 873       t = unw_decode_uleb128 (&dp, end);
 874       switch (r)
 875         {
 876         case 0:
 877           size = unw_decode_uleb128 (&dp, end);
 878           UNW_DEC_MEM_STACK_F ("P7", t, size, arg);
 879           break;
 880
 881         case 1:
 882           UNW_DEC_MEM_STACK_V ("P7", t, arg);
 883           break;
 884         case 2:
 885           UNW_DEC_SPILL_BASE ("P7", t, arg);
 886           break;
 887         case 3:
 888           UNW_DEC_REG_SPREL ("P7", UNW_REG_PSP, t, arg);
 889           break;
 890         case 4:
 891           UNW_DEC_REG_WHEN ("P7", UNW_REG_RP, t, arg);
 892           break;
 893         case 5:
 894           UNW_DEC_REG_PSPREL ("P7", UNW_REG_RP, t, arg);
 895           break;
 896         case 6:
 897           UNW_DEC_REG_WHEN ("P7", UNW_REG_PFS, t, arg);
 898           break;
 899         case 7:
 900           UNW_DEC_REG_PSPREL ("P7", UNW_REG_PFS, t, arg);
 901           break;
 902         case 8:
 903           UNW_DEC_REG_WHEN ("P7", UNW_REG_PR, t, arg);
 904           break;
 905         case 9:
 906           UNW_DEC_REG_PSPREL ("P7", UNW_REG_PR, t, arg);
 907           break;
 908         case 10:
 909           UNW_DEC_REG_WHEN ("P7", UNW_REG_LC, t, arg);
 910           break;
 911         case 11:
 912           UNW_DEC_REG_PSPREL ("P7", UNW_REG_LC, t, arg);
 913           break;
 914         case 12:
 915           UNW_DEC_REG_WHEN ("P7", UNW_REG_UNAT, t, arg);
 916           break;
 917         case 13:
 918           UNW_DEC_REG_PSPREL ("P7", UNW_REG_UNAT, t, arg);
 919           break;
 920         case 14:
 921           UNW_DEC_REG_WHEN ("P7", UNW_REG_FPSR, t, arg);
 922           break;
 923         case 15:
 924           UNW_DEC_REG_PSPREL ("P7", UNW_REG_FPSR, t, arg);
 925           break;
 926         default:
 927           UNW_DEC_BAD_CODE (r);
 928           break;
 929         }
 930     }
 931   else
 932     {
 933       switch (code & 0xf)
 934         {
 935         case 0x0:               /* p8 */
 936           {
 937             if ((end - dp) < 2)
 938               {
 939                 printf (_("\t<corrupt P8>\n"));
 940                 return end;
 941               }
 942
 943             r = *dp++;
 944             t = unw_decode_uleb128 (&dp, end);
 945             switch (r)
 946               {
 947               case 1:
 948                 UNW_DEC_REG_SPREL ("P8", UNW_REG_RP, t, arg);
 949                 break;
 950               case 2:
 951                 UNW_DEC_REG_SPREL ("P8", UNW_REG_PFS, t, arg);
 952                 break;
 953               case 3:
 954                 UNW_DEC_REG_SPREL ("P8", UNW_REG_PR, t, arg);
 955                 break;
 956               case 4:
 957                 UNW_DEC_REG_SPREL ("P8", UNW_REG_LC, t, arg);
 958                 break;
 959               case 5:
 960                 UNW_DEC_REG_SPREL ("P8", UNW_REG_UNAT, t, arg);
 961                 break;
 962               case 6:
 963                 UNW_DEC_REG_SPREL ("P8", UNW_REG_FPSR, t, arg);
 964                 break;
 965               case 7:
 966                 UNW_DEC_REG_WHEN ("P8", UNW_REG_BSP, t, arg);
 967                 break;
 968               case 8:
 969                 UNW_DEC_REG_PSPREL ("P8", UNW_REG_BSP, t, arg);
 970                 break;
 971               case 9:
 972                 UNW_DEC_REG_SPREL ("P8", UNW_REG_BSP, t, arg);
 973                 break;
 974               case 10:
 975                 UNW_DEC_REG_WHEN ("P8", UNW_REG_BSPSTORE, t, arg);
 976                 break;
 977               case 11:
 978                 UNW_DEC_REG_PSPREL ("P8", UNW_REG_BSPSTORE, t, arg);
 979                 break;
 980               case 12:
 981                 UNW_DEC_REG_SPREL ("P8", UNW_REG_BSPSTORE, t, arg);
 982                 break;
 983               case 13:
 984                 UNW_DEC_REG_WHEN ("P8", UNW_REG_RNAT, t, arg);
 985                 break;
 986               case 14:
 987                 UNW_DEC_REG_PSPREL ("P8", UNW_REG_RNAT, t, arg);
 988                 break;
 989               case 15:
 990                 UNW_DEC_REG_SPREL ("P8", UNW_REG_RNAT, t, arg);
 991                 break;
 992               case 16:
 993                 UNW_DEC_PRIUNAT_WHEN_GR ("P8", t, arg);
 994                 break;
 995               case 17:
 996                 UNW_DEC_PRIUNAT_PSPREL ("P8", t, arg);
 997                 break;
 998               case 18:
 999                 UNW_DEC_PRIUNAT_SPREL ("P8", t, arg);
1000                 break;
1001               case 19:
1002                 UNW_DEC_PRIUNAT_WHEN_MEM ("P8", t, arg);
1003                 break;
1004               default:
1005                 UNW_DEC_BAD_CODE (r);
1006                 break;
1007               }
1008           }
1009           break;
1010
1011         case 0x1:
1012           if ((end - dp) < 2)
1013             {
1014               printf (_("\t<corrupt P9>\n"));
1015               return end;
1016             }
1017
1018           byte1 = *dp++;
1019           byte2 = *dp++;
1020           UNW_DEC_GR_GR ("P9", (byte1 & 0xf), (byte2 & 0x7f), arg);
1021           break;
1022
1023         case 0xf:               /* p10 */
1024           if ((end - dp) < 2)
1025             {
1026               printf (_("\t<corrupt P10>\n"));
1027               return end;
1028             }
1029
1030           byte1 = *dp++;
1031           byte2 = *dp++;
1032           UNW_DEC_ABI ("P10", byte1, byte2, arg);
1033           break;
1034
1035         case 0x9:
1036           return unw_decode_x1 (dp, code, arg, end);
1037
1038         case 0xa:
1039           return unw_decode_x2 (dp, code, arg, end);
1040
1041         case 0xb:
1042           return unw_decode_x3 (dp, code, arg, end);
1043
1044         case 0xc:
1045           return unw_decode_x4 (dp, code, arg, end);
1046
1047         default:
1048           UNW_DEC_BAD_CODE (code);
1049           break;
1050         }
1051     }
1052   return dp;
1053 }
1054
1055 static const unsigned char *
1056 unw_decode_b1 (const unsigned char *dp, unsigned int code,
1057                void *arg ATTRIBUTE_UNUSED,
1058                const unsigned char * end ATTRIBUTE_UNUSED)
1059 {
1060   unw_word label = (code & 0x1f);
1061
1062   if ((code & 0x20) != 0)
1063     UNW_DEC_COPY_STATE ("B1", label, arg);
1064   else
1065     UNW_DEC_LABEL_STATE ("B1", label, arg);
1066   return dp;
1067 }
1068
1069 static const unsigned char *
1070 unw_decode_b2 (const unsigned char *dp, unsigned int code,
1071                void *arg ATTRIBUTE_UNUSED,
1072                const unsigned char * end)
1073 {
1074   unw_word t;
1075
1076   t = unw_decode_uleb128 (& dp, end);
1077   UNW_DEC_EPILOGUE ("B2", t, (code & 0x1f), arg);
1078   return dp;
1079 }
1080
1081 static const unsigned char *
1082 unw_decode_b3_x4 (const unsigned char *dp, unsigned int code, void *arg,
1083                   const unsigned char * end)
1084 {
1085   unw_word t, ecount, label;
1086
1087   if ((code & 0x10) == 0)
1088     {
1089       t = unw_decode_uleb128 (&dp, end);
1090       ecount = unw_decode_uleb128 (&dp, end);
1091       UNW_DEC_EPILOGUE ("B3", t, ecount, arg);
1092     }
1093   else if ((code & 0x07) == 0)
1094     {
1095       label = unw_decode_uleb128 (&dp, end);
1096       if ((code & 0x08) != 0)
1097         UNW_DEC_COPY_STATE ("B4", label, arg);
1098       else
1099         UNW_DEC_LABEL_STATE ("B4", label, arg);
1100     }
1101   else
1102     switch (code & 0x7)
1103       {
1104       case 1:
1105         return unw_decode_x1 (dp, code, arg, end);
1106       case 2:
1107         return unw_decode_x2 (dp, code, arg, end);
1108       case 3:
1109         return unw_decode_x3 (dp, code, arg, end);
1110       case 4:
1111         return unw_decode_x4 (dp, code, arg, end);
1112       default:
1113         UNW_DEC_BAD_CODE (code);
1114         break;
1115       }
1116   return dp;
1117 }
1118
1119 typedef const unsigned char *(*unw_decoder)
1120   (const unsigned char *, unsigned int, void *, const unsigned char *);
1121
1122 static const unw_decoder unw_decode_table[2][8] =
1123   {
1124     /* prologue table: */
1125     {
1126       unw_decode_r1,            /* 0 */
1127       unw_decode_r1,
1128       unw_decode_r2,
1129       unw_decode_r3,
1130       unw_decode_p1,            /* 4 */
1131       unw_decode_p2_p5,
1132       unw_decode_p6,
1133       unw_decode_p7_p10
1134     },
1135     {
1136       unw_decode_r1,            /* 0 */
1137       unw_decode_r1,
1138       unw_decode_r2,
1139       unw_decode_r3,
1140       unw_decode_b1,            /* 4 */
1141       unw_decode_b1,
1142       unw_decode_b2,
1143       unw_decode_b3_x4
1144     }
1145   };
1146
1147 /* Decode one descriptor and return address of next descriptor.  */
1148 const unsigned char *
1149 unw_decode (const unsigned char *dp, int inside_body,
1150             void *ptr_inside_body, const unsigned char * end)
1151 {
1152   unw_decoder decoder;
1153   unsigned char code;
1154
1155   if ((end - dp) < 1)
1156     {
1157       printf (_("\t<corrupt IA64 descriptor>\n"));
1158       return end;
1159     }
1160
1161   code = *dp++;
1162   decoder = unw_decode_table[inside_body][code >> 5];
1163   return (*decoder) (dp, code, ptr_inside_body, end);
1164 }