disasm.c

二进制翻译的一个软件

	fprintf(F, VREG("di"));
	break;
      case reg_ESI:
	fprintf(F, VREG("si"));
	break;
      };
      break;
    }

  case ADDR_direct:
    fprintf(F, "$0x%x:$0x%x", ds->imm16,ds->immediate);
    break;
	
  case ADDR_imm:
    {
      if (arg->ainfo == w_mode)
	fprintf(F, "$0x%x", ds->imm16);
      else
	fprintf(F, "$0x%x", ds->immediate);
      break;
    }
  case ADDR_offset:
    {
      fprintf(F, "0x%x", ds->immediate);
      break;
    }
  case ADDR_jmp:
    {
      unsigned len = ds->no_of_prefixes + (ds->pInstr - ds->instr);
      unsigned eip = ds->decode_eip + len;
      eip += ds->immediate;
      fprintf(F, "%x", eip);
    }
    break;
#if 0
  case ADDR_indirE:
    fprintf(F, "*");
    /* fall through */
#endif

  case ADDR_R:
  case ADDR_E:
    show_modrm_arg(ds, a, F);
    break;

  case ADDR_G:
    {
      switch(arg->ainfo) {
      case v_mode:
	{
	  switch (ds->modrm.parts.reg) {
	  case 0u:
	    fprintf(F, VREG("ax"));
	    break;
	  case 1u:
	    fprintf(F, VREG("cx"));
	    break;
	  case 2u:
	    fprintf(F, VREG("dx"));
	    break;
	  case 3u:
	    fprintf(F, VREG("bx"));
	    break;
	  case 4u:
	    fprintf(F, VREG("sp"));
	    break;
	  case 5u:
	    fprintf(F, VREG("bp"));
	    break;
	  case 6u:
	    fprintf(F, VREG("si"));
	    break;
	  case 7u:
	    fprintf(F, VREG("di"));
	    break;
	  }
	  break;
	}
      case b_mode:
	{
	  switch (ds->modrm.parts.reg) {
	  case 0u:
	    fprintf(F, BREG("al"));
	    break;
	  case 1u:
	    fprintf(F, BREG("cl"));
	    break;
	  case 2u:
	    fprintf(F, BREG("dl"));
	    break;
	  case 3u:
	    fprintf(F, BREG("bl"));
	    break;
	  case 4u:
	    fprintf(F, BREG("ah"));
	    break;
	  case 5u:
	    fprintf(F, BREG("ch"));
	    break;
	  case 6u:
	    fprintf(F, BREG("dh"));
	    break;
	  case 7u:
	    fprintf(F, BREG("bh"));
	    break;
	  }
	  break;
	}
      case d_mode:
	{
	  switch (ds->modrm.parts.reg) {
	  case 0u:
	    fprintf(F, DREG("ax"));
	    break;
	  case 1u:
	    fprintf(F, DREG("cx"));
	    break;
	  case 2u:
	    fprintf(F, DREG("dx"));
	    break;
	  case 3u:
	    fprintf(F, DREG("bx"));
	    break;
	  case 4u:
	    fprintf(F, DREG("sp"));
	    break;
	  case 5u:
	    fprintf(F, DREG("bp"));
	    break;
	  case 6u:
	    fprintf(F, DREG("si"));
	    break;
	  case 7u:
	    fprintf(F, DREG("di"));
	    break;
	  }
	  break;
	}
      default:
	fprintf(F, "<unhandled mode %d>", arg->amode);
	break;
      }

      break;
    }

  case ADDR_seg:
    {
      switch(arg->ainfo) {
      case 0u:
	fprintf(F, SREG("es"));
	break;
      case 1u:
	fprintf(F, SREG("cs"));
	break;
      case 2u:
	fprintf(F, SREG("ss"));
	break;
      case 3u:
	fprintf(F, SREG("ds"));
	break;
      case 4u:
	fprintf(F, SREG("fs"));
	break;
      case 5u:
	fprintf(F, SREG("gs"));
	break;
      case 6u:
	fprintf(F, SREG("?seg?"));
	break;
      case 7u:
	fprintf(F, SREG("?seg?"));
	break;
      }
      break;
    }

  case ADDR_seg_reg:
    {
      switch (ds->modrm.parts.reg) {
      case 0u:
	fprintf(F, SREG("es"));
	break;
      case 1u:
	fprintf(F, SREG("cs"));
	break;
      case 2u:
	fprintf(F, SREG("ss"));
	break;
      case 3u:
	fprintf(F, SREG("ds"));
	break;
      case 4u:
	fprintf(F, SREG("fs"));
	break;
      case 5u:
	fprintf(F, SREG("gs"));
	break;
      case 6u:
	fprintf(F, SREG("?seg?"));
	break;
      case 7u:
	fprintf(F, SREG("?seg?"));
	break;
      }
      break;
    }

  case ADDR_ds:
    {
      fprintf(F, "%%ds:(");
      fprintf(F, VREG("si"));
      fprintf(F, ")");
      break;
    }
  case ADDR_es:
    {
      fprintf(F, "%%es:(");
      fprintf(F, VREG("di"));
      fprintf(F, ")");
      break;
    }
  case ADDR_C:
    fprintf(F, "%%cr%d", ds->modrm.parts.reg);
    break;
  case ADDR_D:
    fprintf(F, "%%dbg%d", ds->modrm.parts.reg);
    break;
  case ADDR_FREG:
    if (!(ds->attr & DF_BINARY))
      fprintf(F, "%%ST(%d)", ds->modrm.parts.rm);
    else if (ds->attr & DF_DIRECTION)
      fprintf(F, "%%ST(%d), %%ST(0)", ds->modrm.parts.rm);
    else
      fprintf(F, "%%ST(0), %%ST(%d)", ds->modrm.parts.rm);
    break;
  default:
    fprintf(F, "???AMODE???");
  }
}

void
do_disasm(decode_t *ds, FILE *F)
{
  int a;
  OpCode *opcode = (OpCode *)ds->pEntry;

  unsigned long eip = ds->decode_eip;
  unsigned char *instr = ds->instr;
  unsigned instrLen = ds->pInstr - ds->instr;
  unsigned outputLen = 0;
  char hexbyte[4];
  char ophex[60];
  char opname[40];
  char *pOpname;
  int endByteCount = 0;

  ophex[0] = 0;
  opname[0] = 0;

  fprintf(F, "0x%08x:\t", eip);

  /* First print out the hex encoding */
  if (ds->flags & DSFL_GROUP1_PREFIX) {
    sprintf(hexbyte, "%02x ", ds->Group1_Prefix);
    strcat(ophex, hexbyte);
    outputLen++;
  }
  if (ds->flags & DSFL_GROUP2_PREFIX) {
    sprintf(hexbyte, "%02x ", ds->Group2_Prefix);
    strcat(ophex, hexbyte);
    outputLen++;
  }
  if (ds->flags & DSFL_GROUP3_PREFIX) {
    sprintf(hexbyte, "%02x ", ds->Group3_Prefix);
    strcat(ophex, hexbyte);
    outputLen++;
  }
  if (ds->flags & DSFL_GROUP4_PREFIX) {
    sprintf(hexbyte, "%02x ", ds->Group4_Prefix);
    strcat(ophex, hexbyte);
    outputLen++;
  }

  while (outputLen < 7 && instr != ds->pInstr) {
    sprintf(hexbyte, "%02x ", *instr);
    strcat(ophex, hexbyte);
    outputLen++;
    instr++;
  }

  if (ds->flags & DSFL_GROUP1_PREFIX)
    {
      switch(ds->Group1_Prefix) {
      case PREFIX_LOCK:
	strcat(opname, "lock ");
	break;
      case PREFIX_REPZ:
	strcat(opname, "repz ");
	break;
      case PREFIX_REPNZ:
	strcat(opname, "repnz ");
	break;
      }
    }

  if (ds->flags & DSFL_GROUP2_PREFIX)
    {
      switch(ds->Group2_Prefix) {
      case PREFIX_CS:
	strcat(opname, "cs ");
	break;
      case PREFIX_DS:
	strcat(opname, "ds ");
	break;
      case PREFIX_ES:
	strcat(opname, "es ");
	break;
      case PREFIX_FS:
	strcat(opname, "fs ");
	break;
      case PREFIX_GS:
	strcat(opname, "gs ");
	break;
      case PREFIX_SS:
	strcat(opname, "ss ");
	break;
      }
    }

#if 0
  /* No need to output this, as it is implied in the opcode mnemonic */
  if (ds->flags & DSFL_GROUP3_PREFIX)
    strcat(opname, "data16 ");
#endif

  if (ds->flags & DSFL_GROUP4_PREFIX)
    {
      strcat(opname, "addr16 ");
    }

  pOpname = opname + strlen(opname);

  {
    const char *disasm;

    for (disasm = opcode->disasm; *disasm; disasm++) {
      if (isupper(*disasm)) {
	switch (*disasm) {
	  /*
	   * B -- trailing 'b' suffix
	   * L -- trailing 'w' or 'l' suffix according to mode. 
	   * Q -- trailinq 'd' or 'q' suffix according to mode
	   * W -- b or w (cbw/cwd) according to mode
	   * R -- w or d (cbw/cwd) according to mode
	   * N -- 16 or 32 according to mode (inverted -- for size prefixes)
	   */
	case 'B':
	  {
	    *pOpname++ = 'b';
	    break;
	  }
	case 'L':
	  {
	    if (ds->opstate & OPSTATE_DATA32)
	      *pOpname++ = 'l';
	    else
	      *pOpname++ = 'w';
	    break;
	  }
	case 'Q':
	  {
	    if (ds->opstate & OPSTATE_DATA32)
	      *pOpname++ = 'd';
	    else
	      *pOpname++ = 'q';
	    break;
	  }
	case 'W':
	  {
	    if (ds->opstate & OPSTATE_DATA32)
	      *pOpname++ = 'b';
	    else
	      *pOpname++ = 'w';
	    break;
	  }
	case 'R':
	  {
	    if (ds->opstate & OPSTATE_DATA32)
	      *pOpname++ = 'w';
	    else
	      *pOpname++ = 'd';
	    break;
	  }
	default:
	  {
	    *pOpname++ = *disasm;
	    break;
	  }
	}
      }
      else
	*pOpname++ = *disasm;
    }
    *pOpname= 0;
  }

  fprintf(F, "%-22s", ophex);
  fprintf(F, "%-8s ", opname);

  /* Arg display is pretty silly, because the display order does not
     match the order specified in the decode table. */

  if (opcode->args[2].amode != ADDR_none) {
    show_asm_arg(ds, 2, F);
    fprintf(F, ",");
  }

  if (opcode->args[1].amode != ADDR_none) {
    show_asm_arg(ds, 1, F);
    fprintf(F, ",");
  }
  
  if (opcode->args[0].amode != ADDR_none) {
    show_asm_arg(ds, 0, F);
  }
  
  fprintf(F, "\n");


  /* See if there are more hex bytes to print: */
  endByteCount = 0;
  while (instr != ds->pInstr) {
    outputLen = 0;
    eip += 7;
    ophex[0] = 0;

    while (outputLen < 7 && instr != ds->pInstr) {
      sprintf(hexbyte, "%02x ", *instr);
      strcat(ophex, hexbyte);
      outputLen++;
      instr++;
    }

    fprintf(F, "0x%08x:\t", eip);
    fprintf(F, "%-22s\n", ophex);

    if(endByteCount > 40) {
      fprintf(F, "....\?\?\?\n");
      break;
    }
  }
}