Back to index

glibc  2.9
Defines | Functions
register-dump.h File Reference
#include <sys/uio.h>
#include <stdio-common/_itoa.h>

Go to the source code of this file.

Defines

#define ADD_STRING(str)
#define ADD_MEM(str, len)
#define REGISTER_DUMP   register_dump (fd, ctx)

Functions

static void hexvalue (unsigned long int value, char *buf, size_t len)
static void register_dump (int fd, SIGCONTEXT ctx)

Define Documentation

#define ADD_MEM (   str,
  len 
)
Value:
iov[nr].iov_base = str;                                              \
  iov[nr].iov_len = len;                                             \
  ++nr
#define ADD_STRING (   str)
Value:
iov[nr].iov_base = (char *) str;                                     \
  iov[nr].iov_len = strlen (str);                                    \
  ++nr
#define REGISTER_DUMP   register_dump (fd, ctx)

Definition at line 257 of file register-dump.h.


Function Documentation

static void hexvalue ( unsigned long int  value,
char *  buf,
size_t  len 
) [static]

Definition at line 57 of file register-dump.h.

{
  char *cp = _itoa_word (value, buf + len, 16, 0);
  while (cp > buf)
    *--cp = '0';
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void register_dump ( int  fd,
SIGCONTEXT  ctx 
) [static]

Definition at line 65 of file register-dump.h.

{
  char regs[36][16];
  char fregs[68][8];
  struct iovec iov[150];
  size_t nr = 0;
  int i;
  unsigned long *r = (unsigned long *)
    (ctx->sigc_regs.u_regs[14] + STACK_BIAS);
  __siginfo_fpu_t *f;

#define ADD_STRING(str) \
  iov[nr].iov_base = (char *) str;                                   \
  iov[nr].iov_len = strlen (str);                                    \
  ++nr
#define ADD_MEM(str, len) \
  iov[nr].iov_base = str;                                            \
  iov[nr].iov_len = len;                                             \
  ++nr

  /* Generate strings of register contents.  */
  hexvalue (ctx->sigc_regs.tstate, regs[0], 16);
  hexvalue (ctx->sigc_regs.tpc,           regs[1], 16);
  hexvalue (ctx->sigc_regs.tnpc,   regs[2], 16);
  hexvalue (ctx->sigc_regs.y,             regs[3], 8);
  for (i = 1; i <= 15; i++)
    hexvalue (ctx->sigc_regs.u_regs[i], regs[3+i], 16);
  for (i = 0; i <= 15; i++)
    hexvalue (r[i],                regs[19+i], 16);
  hexvalue (ctx->sigc_mask,        regs[35], 16);

  /* Generate the output.  */
  ADD_STRING ("Register dump:\n\n TSTATE: ");
  ADD_MEM (regs[0], 16);
  ADD_STRING (" TPC: ");
  ADD_MEM (regs[1], 16);
  ADD_STRING (" TNPC: ");
  ADD_MEM (regs[2], 16);
  ADD_STRING ("\n Y: ");
  ADD_MEM (regs[3], 8);
  ADD_STRING ("\n  g0: 0000000000000000   g1: ");
  ADD_MEM (regs[4], 16);
  ADD_STRING ("  g2: ");
  ADD_MEM (regs[5], 16);
  ADD_STRING ("\n g3: ");
  ADD_MEM (regs[6], 16);
  ADD_STRING ("  g4: ");
  ADD_MEM (regs[7], 16);
  ADD_STRING ("  g5: ");
  ADD_MEM (regs[8], 16);
  ADD_STRING ("\n g6: ");
  ADD_MEM (regs[9], 16);
  ADD_STRING ("  g7: ");
  ADD_MEM (regs[10], 16);
  ADD_STRING ("\n o0: ");
  ADD_MEM (regs[11], 16);
  ADD_STRING ("  o1: ");
  ADD_MEM (regs[12], 16);
  ADD_STRING ("  o2: ");
  ADD_MEM (regs[13], 16);
  ADD_STRING ("\n o3: ");
  ADD_MEM (regs[14], 16);
  ADD_STRING ("  o4: ");
  ADD_MEM (regs[15], 16);
  ADD_STRING ("  o5: ");
  ADD_MEM (regs[16], 16);
  ADD_STRING ("\n sp: ");
  ADD_MEM (regs[17], 16);
  ADD_STRING ("  o7: ");
  ADD_MEM (regs[18], 16);
  ADD_STRING ("\n l0: ");
  ADD_MEM (regs[19], 16);
  ADD_STRING ("  l1: ");
  ADD_MEM (regs[20], 16);
  ADD_STRING ("  l2: ");
  ADD_MEM (regs[21], 16);
  ADD_STRING ("\n l3: ");
  ADD_MEM (regs[22], 16);
  ADD_STRING ("  l4: ");
  ADD_MEM (regs[23], 16);
  ADD_STRING ("  l5: ");
  ADD_MEM (regs[24], 16);
  ADD_STRING ("\n l6: ");
  ADD_MEM (regs[25], 16);
  ADD_STRING ("  l7: ");
  ADD_MEM (regs[26], 16);
  ADD_STRING ("\n i0: ");
  ADD_MEM (regs[27], 16);
  ADD_STRING ("  i1: ");
  ADD_MEM (regs[28], 16);
  ADD_STRING ("  i2: ");
  ADD_MEM (regs[29], 16);
  ADD_STRING ("\n i3: ");
  ADD_MEM (regs[30], 16);
  ADD_STRING ("  i4: ");
  ADD_MEM (regs[31], 16);
  ADD_STRING ("  i5: ");
  ADD_MEM (regs[32], 16);
  ADD_STRING ("\n fp: ");
  ADD_MEM (regs[33], 16);
  ADD_STRING ("  i7: ");
  ADD_MEM (regs[34], 16);
  ADD_STRING ("\n\n Mask: ");
  ADD_MEM (regs[35], 16);

  f = ctx->sigc_fpu_save;
  if (f != NULL)
    {
      for (i = 0; i < 64; i++)
       hexvalue (f->si_float_regs[i], fregs[i], 8);
      hexvalue (f->si_fsr, fregs[64], 16);
      hexvalue (f->si_gsr, fregs[66], 2);
      hexvalue (f->si_fprs, fregs[67], 1);
      ADD_STRING (" XFSR: ");
      ADD_MEM (fregs[64], 16);
      ADD_STRING (" GSR: ");
      ADD_MEM (fregs[66], 2);
      ADD_STRING (" FPRS: ");
      ADD_MEM (fregs[67], 1);
      ADD_STRING ("\n  f0: ");
      ADD_MEM (fregs[0], 16);
      ADD_STRING ("   f2: ");
      ADD_MEM (fregs[2], 16);
      ADD_STRING ("   f4: ");
      ADD_MEM (fregs[4], 16);
      ADD_STRING ("\n  f6: ");
      ADD_MEM (fregs[6], 16);
      ADD_STRING ("   f8: ");
      ADD_MEM (fregs[8], 16);
      ADD_STRING ("  f10: ");
      ADD_MEM (fregs[10], 16);
      ADD_STRING ("\n f12: ");
      ADD_MEM (fregs[12], 16);
      ADD_STRING ("  f14: ");
      ADD_MEM (fregs[14], 16);
      ADD_STRING ("  f16: ");
      ADD_MEM (fregs[16], 16);
      ADD_STRING ("\n f18: ");
      ADD_MEM (fregs[18], 16);
      ADD_STRING ("  f20: ");
      ADD_MEM (fregs[20], 16);
      ADD_STRING ("  f22: ");
      ADD_MEM (fregs[22], 16);
      ADD_STRING ("\n f24: ");
      ADD_MEM (fregs[24], 16);
      ADD_STRING ("  f26: ");
      ADD_MEM (fregs[26], 16);
      ADD_STRING ("  f28: ");
      ADD_MEM (fregs[28], 16);
      ADD_STRING ("\n f30: ");
      ADD_MEM (fregs[30], 16);
      ADD_STRING ("  f32: ");
      ADD_MEM (fregs[32], 16);
      ADD_STRING ("  f34: ");
      ADD_MEM (fregs[34], 16);
      ADD_STRING ("\n f36: ");
      ADD_MEM (fregs[36], 16);
      ADD_STRING ("  f38: ");
      ADD_MEM (fregs[38], 16);
      ADD_STRING ("  f40: ");
      ADD_MEM (fregs[40], 16);
      ADD_STRING ("\n f42: ");
      ADD_MEM (fregs[42], 16);
      ADD_STRING ("  f44: ");
      ADD_MEM (fregs[44], 16);
      ADD_STRING ("  f46: ");
      ADD_MEM (fregs[46], 16);
      ADD_STRING ("\n f48: ");
      ADD_MEM (fregs[48], 16);
      ADD_STRING ("  f50: ");
      ADD_MEM (fregs[50], 16);
      ADD_STRING ("  f52: ");
      ADD_MEM (fregs[52], 16);
      ADD_STRING ("\n f54: ");
      ADD_MEM (fregs[54], 16);
      ADD_STRING ("  f56: ");
      ADD_MEM (fregs[56], 16);
      ADD_STRING ("  f58: ");
      ADD_MEM (fregs[58], 16);
      ADD_STRING ("\n f60: ");
      ADD_MEM (fregs[60], 16);
      ADD_STRING ("  f62: ");
      ADD_MEM (fregs[62], 16);
    }

  ADD_STRING ("\n");

  /* Write the stuff out.  */
  writev (fd, iov, nr);
}

Here is the call graph for this function: