sysdeps/unix/sysv/linux/sparc/sparc32/register-dump.h

   1 /* Dump registers.
   2    Copyright (C) 1999-2014 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Contributed by Jakub Jelinek <jakub@redhat.com>, 1999.
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    The GNU C Library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the GNU C Library; if not, see
  18    <http://www.gnu.org/licenses/>.  */
  19
  20 #include <sys/uio.h>
  21 #include <_itoa.h>
  22
  23 /* We will print the register dump in this format:
  24
  25  PSR: XXXXXXXX PC: XXXXXXXX NPC: XXXXXXXX   Y: XXXXXXXX
  26  g0: 00000000  g1: XXXXXXXX  g2: XXXXXXXX  g3: XXXXXXXX
  27  g4: XXXXXXXX  g5: XXXXXXXX  g6: XXXXXXXX  g7: XXXXXXXX
  28  o0: XXXXXXXX  o1: XXXXXXXX  o2: XXXXXXXX  o3: XXXXXXXX
  29  o4: XXXXXXXX  o5: XXXXXXXX  sp: XXXXXXXX  o7: XXXXXXXX
  30  l0: XXXXXXXX  l1: XXXXXXXX  l2: XXXXXXXX  l3: XXXXXXXX
  31  l4: XXXXXXXX  l5: XXXXXXXX  l6: XXXXXXXX  l7: XXXXXXXX
  32  i0: XXXXXXXX  i1: XXXXXXXX  i2: XXXXXXXX  i3: XXXXXXXX
  33  i4: XXXXXXXX  i5: XXXXXXXX  fp: XXXXXXXX  i7: XXXXXXXX
  34
  35  followed on sun4, sun4c, sun4d, sun4m by:
  36
  37  Old mask: XXXXXXXX FSR: XXXXXXXX FPQ: XXXXXXXX
  38   f0: XXXXXXXXXXXXXXXX   f2: XXXXXXXXXXXXXXXX   f4: XXXXXXXXXXXXXXXX
  39   f6: XXXXXXXXXXXXXXXX   f8: XXXXXXXXXXXXXXXX  f10: XXXXXXXXXXXXXXXX
  40  f12: XXXXXXXXXXXXXXXX  f14: XXXXXXXXXXXXXXXX  f16: XXXXXXXXXXXXXXXX
  41  f18: XXXXXXXXXXXXXXXX  f20: XXXXXXXXXXXXXXXX  f22: XXXXXXXXXXXXXXXX
  42  f24: XXXXXXXXXXXXXXXX  f26: XXXXXXXXXXXXXXXX  f28: XXXXXXXXXXXXXXXX
  43  f30: XXXXXXXXXXXXXXXX
  44
  45  and on sun4u by:
  46
  47  Old mask: XXXXXXXX XFSR: XXXXXXXXXXXXXXXX GSR: XX FPRS: X
  48   f0: XXXXXXXXXXXXXXXX   f2: XXXXXXXXXXXXXXXX   f4: XXXXXXXXXXXXXXXX
  49   f6: XXXXXXXXXXXXXXXX   f8: XXXXXXXXXXXXXXXX  f10: XXXXXXXXXXXXXXXX
  50  f12: XXXXXXXXXXXXXXXX  f14: XXXXXXXXXXXXXXXX  f16: XXXXXXXXXXXXXXXX
  51  f18: XXXXXXXXXXXXXXXX  f20: XXXXXXXXXXXXXXXX  f22: XXXXXXXXXXXXXXXX
  52  f24: XXXXXXXXXXXXXXXX  f26: XXXXXXXXXXXXXXXX  f28: XXXXXXXXXXXXXXXX
  53  f30: XXXXXXXXXXXXXXXX  f32: XXXXXXXXXXXXXXXX  f34: XXXXXXXXXXXXXXXX
  54  f36: XXXXXXXXXXXXXXXX  f38: XXXXXXXXXXXXXXXX  f40: XXXXXXXXXXXXXXXX
  55  f42: XXXXXXXXXXXXXXXX  f44: XXXXXXXXXXXXXXXX  f46: XXXXXXXXXXXXXXXX
  56  f48: XXXXXXXXXXXXXXXX  f50: XXXXXXXXXXXXXXXX  f52: XXXXXXXXXXXXXXXX
  57  f54: XXXXXXXXXXXXXXXX  f56: XXXXXXXXXXXXXXXX  f58: XXXXXXXXXXXXXXXX
  58  f60: XXXXXXXXXXXXXXXX  f62: XXXXXXXXXXXXXXXX
  59
  60  */
  61
  62 static void
  63 hexvalue (unsigned long int value, char *buf, size_t len)
  64 {
  65   char *cp = _itoa_word (value, buf + len, 16, 0);
  66   while (cp > buf)
  67     *--cp = '0';
  68 }
  69
  70 struct __siginfo_sparc32_fpu
  71 {
  72   unsigned int si_float_regs[32];
  73   unsigned int si_fsr;
  74   unsigned int si_fpq;
  75 };
  76 struct __siginfo_sparc64_fpu
  77 {
  78   unsigned int si_float_regs[64];
  79   unsigned int si_xfsr;
  80   unsigned int si_fsr;
  81   unsigned int _pad1;
  82   unsigned int si_gsr;
  83   unsigned int _pad2;
  84   unsigned int si_fprs;
  85 };
  86
  87 static void
  88 register_dump (int fd, SIGCONTEXT ctx)
  89 {
  90   char regs[36][8];
  91   char fregs[68][8];
  92   struct iovec iov[150];
  93   size_t nr = 0;
  94   int i;
  95   unsigned int *r = (unsigned int *)
  96     ctx->si_regs.u_regs[14];
  97
  98 #define ADD_STRING(str) \
  99   iov[nr].iov_base = (char *) str;                                            \
 100   iov[nr].iov_len = strlen (str);                                             \
 101   ++nr
 102 #define ADD_MEM(str, len) \
 103   iov[nr].iov_base = str;                                                     \
 104   iov[nr].iov_len = len;                                                      \
 105   ++nr
 106
 107   /* Generate strings of register contents.  */
 108   hexvalue (ctx->si_regs.psr, regs[0], 8);
 109   hexvalue (ctx->si_regs.pc, regs[1], 8);
 110   hexvalue (ctx->si_regs.npc, regs[2], 8);
 111   hexvalue (ctx->si_regs.y, regs[3], 8);
 112   for (i = 1; i <= 15; i++)
 113     hexvalue (ctx->si_regs.u_regs[i], regs[3+i], 8);
 114   for (i = 0; i <= 15; i++)
 115     hexvalue (r[i], regs[19+i], 8);
 116   hexvalue (ctx->si_mask, regs[35], 8);
 117
 118   /* Generate the output.  */
 119   ADD_STRING ("Register dump:\n\n PSR: ");
 120   ADD_MEM (regs[0], 8);
 121   ADD_STRING (" PC: ");
 122   ADD_MEM (regs[1], 8);
 123   ADD_STRING (" NPC: ");
 124   ADD_MEM (regs[2], 8);
 125   ADD_STRING ("   Y: ");
 126   ADD_MEM (regs[3], 8);
 127   ADD_STRING ("\n g0: 00000000 g1: ");
 128   ADD_MEM (regs[4], 8);
 129   ADD_STRING ("  g2: ");
 130   ADD_MEM (regs[5], 8);
 131   ADD_STRING ("  g3: ");
 132   ADD_MEM (regs[6], 8);
 133   ADD_STRING ("\n g4: ");
 134   ADD_MEM (regs[7], 8);
 135   ADD_STRING ("  g5: ");
 136   ADD_MEM (regs[8], 8);
 137   ADD_STRING ("  g6: ");
 138   ADD_MEM (regs[9], 8);
 139   ADD_STRING ("  g7: ");
 140   ADD_MEM (regs[10], 8);
 141   ADD_STRING ("\n o0: ");
 142   ADD_MEM (regs[11], 8);
 143   ADD_STRING ("  o1: ");
 144   ADD_MEM (regs[12], 8);
 145   ADD_STRING ("  o2: ");
 146   ADD_MEM (regs[13], 8);
 147   ADD_STRING ("  o3: ");
 148   ADD_MEM (regs[14], 8);
 149   ADD_STRING ("\n o4: ");
 150   ADD_MEM (regs[15], 8);
 151   ADD_STRING ("  o5: ");
 152   ADD_MEM (regs[16], 8);
 153   ADD_STRING ("  sp: ");
 154   ADD_MEM (regs[17], 8);
 155   ADD_STRING ("  o7: ");
 156   ADD_MEM (regs[18], 8);
 157   ADD_STRING ("\n l0: ");
 158   ADD_MEM (regs[19], 8);
 159   ADD_STRING ("  l1: ");
 160   ADD_MEM (regs[20], 8);
 161   ADD_STRING ("  l2: ");
 162   ADD_MEM (regs[21], 8);
 163   ADD_STRING ("  l3: ");
 164   ADD_MEM (regs[22], 8);
 165   ADD_STRING ("\n l4: ");
 166   ADD_MEM (regs[23], 8);
 167   ADD_STRING ("  l5: ");
 168   ADD_MEM (regs[24], 8);
 169   ADD_STRING ("  l6: ");
 170   ADD_MEM (regs[25], 8);
 171   ADD_STRING ("  l7: ");
 172   ADD_MEM (regs[26], 8);
 173   ADD_STRING ("\n i0: ");
 174   ADD_MEM (regs[27], 8);
 175   ADD_STRING ("  i1: ");
 176   ADD_MEM (regs[28], 8);
 177   ADD_STRING ("  i2: ");
 178   ADD_MEM (regs[29], 8);
 179   ADD_STRING ("  i3: ");
 180   ADD_MEM (regs[30], 8);
 181   ADD_STRING ("\n i4: ");
 182   ADD_MEM (regs[31], 8);
 183   ADD_STRING ("  i5: ");
 184   ADD_MEM (regs[32], 8);
 185   ADD_STRING ("  fp: ");
 186   ADD_MEM (regs[33], 8);
 187   ADD_STRING ("  i7: ");
 188   ADD_MEM (regs[34], 8);
 189   ADD_STRING ("\n\n Old mask: ");
 190   ADD_MEM (regs[35], 8);
 191
 192   if ((ctx->si_regs.psr & 0xff000000) == 0xff000000)
 193     {
 194       struct __siginfo_sparc64_fpu *f;
 195
 196       f = *(struct __siginfo_sparc64_fpu **) (ctx + 1);
 197       if (f != NULL)
 198         {
 199           for (i = 0; i < 64; i++)
 200             hexvalue (f->si_float_regs[i], fregs[i], 8);
 201           hexvalue (f->si_xfsr, fregs[64], 8);
 202           hexvalue (f->si_fsr, fregs[65], 8);
 203           hexvalue (f->si_gsr, fregs[66], 2);
 204           hexvalue (f->si_fprs, fregs[67], 1);
 205           ADD_STRING (" XFSR: ");
 206           ADD_MEM (fregs[64], 8);
 207           ADD_MEM (fregs[65], 8);
 208           ADD_STRING (" GSR: ");
 209           ADD_MEM (fregs[66], 2);
 210           ADD_STRING (" FPRS: ");
 211           ADD_MEM (fregs[67], 1);
 212           ADD_STRING ("\n  f0: ");
 213           ADD_MEM (fregs[0], 16);
 214           ADD_STRING ("   f2: ");
 215           ADD_MEM (fregs[2], 16);
 216           ADD_STRING ("   f4: ");
 217           ADD_MEM (fregs[4], 16);
 218           ADD_STRING ("\n  f6: ");
 219           ADD_MEM (fregs[6], 16);
 220           ADD_STRING ("   f8: ");
 221           ADD_MEM (fregs[8], 16);
 222           ADD_STRING ("  f10: ");
 223           ADD_MEM (fregs[10], 16);
 224           ADD_STRING ("\n f12: ");
 225           ADD_MEM (fregs[12], 16);
 226           ADD_STRING ("  f14: ");
 227           ADD_MEM (fregs[14], 16);
 228           ADD_STRING ("  f16: ");
 229           ADD_MEM (fregs[16], 16);
 230           ADD_STRING ("\n f18: ");
 231           ADD_MEM (fregs[18], 16);
 232           ADD_STRING ("  f20: ");
 233           ADD_MEM (fregs[20], 16);
 234           ADD_STRING ("  f22: ");
 235           ADD_MEM (fregs[22], 16);
 236           ADD_STRING ("\n f24: ");
 237           ADD_MEM (fregs[24], 16);
 238           ADD_STRING ("  f26: ");
 239           ADD_MEM (fregs[26], 16);
 240           ADD_STRING ("  f28: ");
 241           ADD_MEM (fregs[28], 16);
 242           ADD_STRING ("\n f30: ");
 243           ADD_MEM (fregs[30], 16);
 244           ADD_STRING ("  f32: ");
 245           ADD_MEM (fregs[32], 16);
 246           ADD_STRING ("  f34: ");
 247           ADD_MEM (fregs[34], 16);
 248           ADD_STRING ("\n f36: ");
 249           ADD_MEM (fregs[36], 16);
 250           ADD_STRING ("  f38: ");
 251           ADD_MEM (fregs[38], 16);
 252           ADD_STRING ("  f40: ");
 253           ADD_MEM (fregs[40], 16);
 254           ADD_STRING ("\n f42: ");
 255           ADD_MEM (fregs[42], 16);
 256           ADD_STRING ("  f44: ");
 257           ADD_MEM (fregs[44], 16);
 258           ADD_STRING ("  f46: ");
 259           ADD_MEM (fregs[46], 16);
 260           ADD_STRING ("\n f48: ");
 261           ADD_MEM (fregs[48], 16);
 262           ADD_STRING ("  f50: ");
 263           ADD_MEM (fregs[50], 16);
 264           ADD_STRING ("  f52: ");
 265           ADD_MEM (fregs[52], 16);
 266           ADD_STRING ("\n f54: ");
 267           ADD_MEM (fregs[54], 16);
 268           ADD_STRING ("  f56: ");
 269           ADD_MEM (fregs[56], 16);
 270           ADD_STRING ("  f58: ");
 271           ADD_MEM (fregs[58], 16);
 272           ADD_STRING ("\n f60: ");
 273           ADD_MEM (fregs[60], 16);
 274           ADD_STRING ("  f62: ");
 275           ADD_MEM (fregs[62], 16);
 276         }
 277     }
 278   else
 279     {
 280       struct __siginfo_sparc32_fpu *f;
 281
 282       f = *(struct __siginfo_sparc32_fpu **) (ctx + 1);
 283       if (f != NULL)
 284         {
 285           for (i = 0; i < 32; i++)
 286             hexvalue (f->si_float_regs[i], fregs[i], 8);
 287           hexvalue (f->si_fsr, fregs[64], 8);
 288           hexvalue (f->si_fpq, fregs[65], 8);
 289           ADD_STRING (" FSR: ");
 290           ADD_MEM (fregs[64], 8);
 291           ADD_STRING (" FPQ: ");
 292           ADD_MEM (fregs[65], 8);
 293           ADD_STRING ("\n  f0: ");
 294           ADD_MEM (fregs[0], 16);
 295           ADD_STRING ("  f2: ");
 296           ADD_MEM (fregs[2], 16);
 297           ADD_STRING ("  f4: ");
 298           ADD_MEM (fregs[4], 16);
 299           ADD_STRING ("\n  f6: ");
 300           ADD_MEM (fregs[6], 16);
 301           ADD_STRING ("   f8: ");
 302           ADD_MEM (fregs[8], 16);
 303           ADD_STRING ("  f10: ");
 304           ADD_MEM (fregs[10], 16);
 305           ADD_STRING ("\n  f12: ");
 306           ADD_MEM (fregs[12], 16);
 307           ADD_STRING ("  f14: ");
 308           ADD_MEM (fregs[14], 16);
 309           ADD_STRING ("  f16: ");
 310           ADD_MEM (fregs[16], 16);
 311           ADD_STRING ("\n f18: ");
 312           ADD_MEM (fregs[18], 16);
 313           ADD_STRING ("  f20: ");
 314           ADD_MEM (fregs[20], 16);
 315           ADD_STRING ("  f22: ");
 316           ADD_MEM (fregs[22], 16);
 317           ADD_STRING ("\n f24: ");
 318           ADD_MEM (fregs[24], 16);
 319           ADD_STRING ("  f26: ");
 320           ADD_MEM (fregs[26], 16);
 321           ADD_STRING ("  f28: ");
 322           ADD_MEM (fregs[28], 16);
 323           ADD_STRING ("\n f30: ");
 324           ADD_MEM (fregs[30], 16);
 325         }
 326     }
 327
 328   ADD_STRING ("\n");
 329
 330   /* Write the stuff out.  */
 331   writev (fd, iov, nr);
 332 }
 333
 334
 335 #define REGISTER_DUMP register_dump (fd, ctx)