Back to index

glibc  2.9
Defines | Functions
register-dump.h File Reference
#include <string.h>
#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 regvalue (unsigned long int *value, char letter, int regno, char *buf)
static void register_dump (int fd, struct sigcontext *ctx)

Define Documentation

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

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


Function Documentation

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

Definition at line 51 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,
struct sigcontext ctx 
) [static]

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

{
  char gpregs[32 - 5][8 + 16];
  char fpregs[128 - 32][8 + 32];
  char bpregs[3][8 + 16];
  char spregs[8][16];
  struct iovec iov[146];
  size_t nr = 0;
  int i;

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

  /* Generate strings of register contents.  */
  for (i = 1; i < 4; ++i)
    {
      regvalue (&ctx->sc_gr[i], 'R', i, gpregs[i - 1]);
      if (ctx->sc_nat & (1L << i))
        memcpy (gpregs[i - 1] + 7, "NaT             ", 16);
    }
  for (i = 8; i < 32; ++i)
    {
      regvalue (&ctx->sc_gr[i], 'R', i, gpregs[i - 5]);
      if (ctx->sc_nat & (1L << i))
        memcpy (gpregs[i - 1] + 7, "NaT             ", 16);
    }
  memcpy (gpregs[0] + 1, "GP:", 3);
  memcpy (gpregs[7] + 1, "SP: ", 4);
  memcpy (gpregs[8] + 1, "TP: ", 4);

  regvalue (&ctx->sc_br[0], 'B', 0, bpregs[0]);
  regvalue (&ctx->sc_br[6], 'B', 6, bpregs[1]);
  regvalue (&ctx->sc_br[7], 'B', 7, bpregs[2]);
  memcpy (bpregs[0] + 1, "RP:", 3);

  if (ctx->sc_flags & IA64_SC_FLAG_FPH_VALID)
    for (i = 32; i < 128; ++i)
      regvalue (&ctx->sc_fr[i].u.bits[0], 'F', i, fpregs[i - 32]);

  hexvalue (ctx->sc_ip, spregs[0], sizeof (spregs[0]));
  hexvalue (ctx->sc_ar_rsc, spregs[1], sizeof (spregs[1]));
  hexvalue (ctx->sc_pr, spregs[2], sizeof (spregs[2]));
  hexvalue (ctx->sc_ar_pfs, spregs[3], sizeof (spregs[3]));
  hexvalue (ctx->sc_ar_unat, spregs[4], sizeof (spregs[4]));
  hexvalue (ctx->sc_cfm, spregs[5], sizeof (spregs[5]));
  hexvalue (ctx->sc_ar_ccv, spregs[6], sizeof (spregs[6]));
  hexvalue (ctx->sc_ar_fpsr, spregs[7], sizeof (spregs[7]));

  /* Generate the output.  */
  ADD_STRING ("Register dump:\n\n");

  for (i = 0; i < 32 - 5; ++i)
    ADD_MEM (gpregs[i], sizeof (gpregs[0]) - 1 + ((i % 3) == 2));
  ADD_STRING ("\n");

  for (i = 0; i < 3; ++i)
    ADD_MEM (bpregs[i], sizeof (bpregs[0]) - 1);
    
  ADD_STRING ("\n\n IP:   ");
  ADD_MEM (spregs[0], sizeof (spregs[0]));
  ADD_STRING (" RSC:  ");
  ADD_MEM (spregs[1], sizeof (spregs[0]));
  ADD_STRING (" PR:   ");
  ADD_MEM (spregs[2], sizeof (spregs[0]));
  ADD_STRING ("\n PFS:  ");
  ADD_MEM (spregs[3], sizeof (spregs[0]));
  ADD_STRING (" UNAT: ");
  ADD_MEM (spregs[4], sizeof (spregs[0]));
  ADD_STRING (" CFM:  ");
  ADD_MEM (spregs[5], sizeof (spregs[0]));
  ADD_STRING ("\n CCV:  ");
  ADD_MEM (spregs[6], sizeof (spregs[0]));
  ADD_STRING (" FPSR: ");
  ADD_MEM (spregs[7], sizeof (spregs[0]));
  ADD_STRING ("\n");

  if (ctx->sc_flags & IA64_SC_FLAG_FPH_VALID)
    {
      ADD_STRING ("\n");

      for (i = 0; i < 128 - 32; ++i)
        ADD_MEM (fpregs[i], sizeof (fpregs[0]) - 1 + (i & 1));
    }

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

Here is the call graph for this function:

static void regvalue ( unsigned long int value,
char  letter,
int  regno,
char *  buf 
) [static]

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

{
  int n = regno >= 100 ? 3 : regno >= 10 ? 2 : 1;
  buf[0] = ' ';
  buf[1] = letter;
  _itoa_word (regno, buf + 2 + n, 10, 0);
  buf[2 + n] = ':';
  for (++n; n <= 4; ++n)
    buf[2 + n] = ' ';
  hexvalue (value[0], buf + 7, 16);
  if (letter == 'F')
    {
      hexvalue (value[1], buf + 7 + 16, 16);
      buf[7 + 32] = '\n';
    }
  else
    buf[7 + 16] = '\n';
}

Here is the call graph for this function:

Here is the caller graph for this function: