regs-x86.c

It s a Linux disassemble, can set break point, disassemble ELF file.

      ws->regInfo.value = fpuState->fip;
      (*callback)(&(ws->regInfo), callbackArgs);

      ws->regInfo.size = 1;
      strcpy(ws->regInfo.name, x86Registers[REG_FOSEG].name);
      ws->regInfo.value = fpuState->foseg;
      (*callback)(&(ws->regInfo), callbackArgs);

      ws->regInfo.size = 4;
      strcpy(ws->regInfo.name, x86Registers[REG_FOOFF].name);
      ws->regInfo.value = fpuState->fooff;
      (*callback)(&(ws->regInfo), callbackArgs);

      ws->regInfo.size = 2;
      strcpy(ws->regInfo.name, x86Registers[REG_FOPCODE].name);
      ws->regInfo.value = fpuState->fopcode;
      (*callback)(&(ws->regInfo), callbackArgs);

      needbreak = 1;
    } /* if (flags & DB_REGFL_DISPLAY_FPREGS) */

    if (flags & DB_REGFL_DISPLAY_MMXREGS)
    {
      /*
       * Let the external program know there is a new batch of
       * registers coming
       */
      if (needbreak)
      {
        ws->regInfo.flags |= DB_RI_BREAK;
        (*callback)(&(ws->regInfo), callbackArgs);
        ws->regInfo.flags &= ~DB_RI_BREAK;

        needbreak = 0;
      }

      /*
       * Get and print out mmx registers
       */
      fpuState = (struct x86fpuInfo *) ws->fpuState;
      if (!x86readFPUDebug(ws, fpuState))
        return (0);

      ws->regInfo.flags |= DB_RI_MMX;
      ws->regInfo.size = 4;

      for (ii = 0; ii < MMX_NUM_REGS; ++ii)
      {
        sprintf(ws->regInfo.name, "mm%d", ii);

        bufptr = ws->regInfo.hexvalue;
        bufptr += sprintf(bufptr, "%s", "0x");

        stptr = fpuState->stptr + ((ii + 1) * FPU_DATA_REG_SIZE - 1) - 2;
        for (jj = 0; jj < MMX_REG_SIZE; ++jj)
          bufptr += sprintf(bufptr, "%02x", *stptr--);

        (*callback)(&(ws->regInfo), callbackArgs);
      } /* for (ii = 0; ii < NUM_MMX_REGS; ++ii) */

      ws->regInfo.flags &= ~DB_RI_MMX;
    } /* if (flags & DB_REGFL_DISPLAY_MMXREGS) */

    return (1);
  } /* if (regindex < 0) */

  /*
   * They want a specific register
   */

  rptr = x86Registers + regindex;

  regvalue = 0;
  regFlags = 0;

  size = x86readRegisterDebug(ws, rptr, &regVal);
  if (size == 0)
    return (0); /* something went wrong */

  if (rptr->flags & R_BITS8)
  {
    if (rptr->position == 1)
      shr = 0;
    else
    {
      assert(rptr->position == 2);
      shr = 8;
    }

    regvalue = (regVal.lvalue >> shr) & 0xFF;
  }
  else if (rptr->flags & R_BITS16)
  {
    if (rptr->position == 2)
      shr = 0;
    else
    {
      assert(rptr->position == 4);
      shr = 16;
    }

    regvalue = (regVal.lvalue >> shr) & 0xFFFF;
  }
  else if (rptr->flags & R_BITS32)
  {
    regvalue = regVal.lvalue;
  }
  else if ((rptr->flags & R_BITS64) && (rptr->flags & R_MMX))
  {
    bufptr = ws->regInfo.hexvalue;
    bufptr += sprintf(bufptr, "%s", "0x");

    stptr = regVal.stptr + FPU_DATA_REG_SIZE - 3;
    for (jj = 0; jj < MMX_REG_SIZE; ++jj)
      bufptr += sprintf(bufptr, "%02x", *stptr--);

    ws->regInfo.rawbuf = regVal.stptr;

    regFlags |= DB_RI_MMX;
  }
  else if ((rptr->flags & R_BITS80) && (rptr->flags & R_FPU_DATA))
  {
    bufptr = ws->regInfo.hexvalue;
    bufptr += sprintf(bufptr, "%s", "0x");

    stptr = regVal.stptr + FPU_DATA_REG_SIZE - 1;
    for (jj = 0; jj < FPU_DATA_REG_SIZE; ++jj)
      bufptr += sprintf(bufptr, "%02x", *stptr--);

    ws->regInfo.rawbuf = regVal.stptr;

    regFlags |= DB_RI_FPU_DATA;
  }
  else
    return (0);

  strcpy(ws->regInfo.name, rptr->name);
  ws->regInfo.value = regvalue;
  ws->regInfo.size = size;

  ws->regInfo.flags |= regFlags;

  (*callback)(&(ws->regInfo), callbackArgs);

  ws->regInfo.flags &= ~regFlags;

  return (1);
} /* x86printRegistersDebug() */

/*
x86setRegisterDebug()
  Set a register to a given value

Inputs: ws       - debug workspace
        regindex - index of x86Registers[] corresponding to the
                   register we want to modify
        value    - new value in ascii format

Return: 1 if successful
        0 if general error
        -1 if ptrace error occurs
        -2 if invalid value is given
*/

int
x86setRegisterDebug(struct debugWorkspace *ws, int regindex, char *value)

{
  struct x86RegInfo *rptr;
  unsigned int andmask; /* mask to and old register value with */
  int shl;              /* number of bits to shift new value left */
  unsigned long lval;   /* long value if general register */
  long double dval;     /* double value if fpu data register (*must* be long double) */
  unsigned long newval;
  unsigned long curval;
  size_t size;
  struct x86RegValue regVal;
  char *endptr;

  assert(ws->pid != NOPID);
  assert(regindex >= 0);

  rptr = x86Registers + regindex;

  if ((rptr->flags & R_GENERAL) ||
      ((rptr->flags & R_FPU) && !(rptr->flags & R_FPU_DATA)))
  {
    lval = strtoul(value, &endptr, 0);
    if ((endptr == value) || (*endptr != '\0'))
      return (-2); /* invalid value */

    if (rptr->flags & R_BITS8)
    {
      newval = lval & 0xff;
      if (rptr->position == 1)
      {
        /*
         * cases like al/bl/cl/dl
         */
        andmask = 0xffffff00;
        shl = 0;
      }
      else if (rptr->position == 2)
      {
        /*
         * cases like ah/bh/ch/dh
         */
        andmask = 0xffff00ff;
        shl = 8;
      }
      else
        return (0);
    }
    else if (rptr->flags & R_BITS16)
    {
      newval = lval & 0xffff;
      if (rptr->position == 2)
      {
        andmask = 0xffff0000;
        shl = 0;
      }
      else if (rptr->position == 4)
      {
        andmask = 0x0000ffff;
        shl = 8;
      }
      else
        return (0);
    }
    else if (rptr->flags & R_BITS32)
    {
      assert(rptr->position == 4);

      newval = lval;

      andmask = 0;
      shl = 0;
    }
    else
    {
      fprintf(stderr,
              "x86setRegisterDebug: invalid register flags: 0x%08X\n",
              rptr->flags);
      return (0); /* should never happen */
    }

    /* get the current value of this register */
    size = x86readRegisterDebug(ws, rptr, &regVal);
    curval = regVal.lvalue;

    /* clear space for the register we are about to set */
    curval &= andmask;

    /* set the register */
    curval |= (newval << shl);

    /* set the actual register */
    regVal.lvalue = curval;
    if (!x86writeRegisterDebug(ws, rptr, &regVal))
      return (-1); /* ptrace error */
  } /* if (rptr->flags & R_GENERAL) */
  else if (rptr->flags & R_FPU_DATA)
  {
    dval = (long double) strtod(value, &endptr);
    if ((endptr == value) || (*endptr != '\0'))
      return (-2); /* invalid value */

    /*
     * set the fpu data register
     */

    regVal.stptr = (unsigned char *) &dval;

    if (!x86writeRegisterDebug(ws, rptr, &regVal))
      return (-1); /* ptrace error */
  } /* if (rptr->flags & R_FPU_DATA) */
  else if (rptr->flags & R_MMX)
  {
    printf("setting mmx reg, value = %s\n", value);
  } /* if (rptr->flags & R_MMX) */

  return (1);
} /* x86setRegisterDebug() */

/*
x86getFlagsDebug()
  Get flags register settings

Inputs: ws    - debug workspace
        flags - where to store human readable settings

Return: 1 if successful
        0 if not
*/

int
x86getFlagsDebug(struct debugWorkspace *ws, char *flags)

{
  int ridx;
  long flval;
  size_t size;
  struct x86RegValue regVal;

  ridx = x86findRegisterDebug(ws, "eflags");
  if (ridx == (-1))
    return (0);

  size = x86readRegisterDebug(ws, x86Registers + ridx, &regVal);
  flval = regVal.lvalue;

  *flags = '\0';

  if (flval & (1 << 0))
    strcat(flags, "CF ");
  if (flval & (1 << 2))
    strcat(flags, "PF ");
  if (flval & (1 << 4))
    strcat(flags, "AF ");
  if (flval & (1 << 6))
    strcat(flags, "ZF ");
  if (flval & (1 << 7))
    strcat(flags, "SF ");
  if (flval & (1 << 8))
    strcat(flags, "TF ");
  if (flval & (1 << 9))
    strcat(flags, "IF ");
  if (flval & (1 << 10))
    strcat(flags, "DF ");
  if (flval & (1 << 11))
    strcat(flags, "OF ");
  if ((flval & (1 << 12)) && (flval & (1 << 13)))
    strcat(flags, "IOPL ");
  if (flval & (1 << 14))
    strcat(flags, "NT ");
  if (flval & (1 << 16))
    strcat(flags, "RF ");
  if (flval & (1 << 17))
    strcat(flags, "VM ");
  if (flval & (1 << 18))
    strcat(flags, "AC ");
  if (flval & (1 << 19))
    strcat(flags, "VIF ");
  if (flval & (1 << 20))
    strcat(flags, "VIP ");
  if (flval & (1 << 21))
    strcat(flags, "ID ");

  return (1);
} /* x86getFlagsDebug() */

/*
x86readRegisterDebug()
  XXX bingo XXX -- make this more general!
  This is provided for the command examine so it can access a register's contents
and use that as the memory location
*/

long
x86readIntRegisterDebug(struct debugWorkspace *ws, int regindex)

{
  struct x86RegInfo *rptr;
  struct x86RegValue regVal;

  if (regindex < 0)
    return (0);

  rptr = x86Registers + regindex;

  /*
   * Grab the process' registers
   */
  if (!x86getRegistersDebug(ws))
    return (0);

  x86readRegisterDebug(ws, rptr, &regVal);

  return (regVal.lvalue);
} /* x86readIntRegisterDebug() */