[BACK]Return to disasm.c CVS log [TXT] [DIR] Up to [RetroPC.NET] / np2 / i386c / ia32

Diff for /np2/i386c/ia32/disasm.c between versions 1.9 and 1.13

version 1.9, 2005/03/12 12:32:54 version 1.13, 2012/02/07 09:11:10
Line 1 Line 1
 /*      $Id$    */  
   
 /*  /*
  * Copyright (c) 2004 NONAKA Kimihiro   * Copyright (c) 2004 NONAKA Kimihiro
  * All rights reserved.   * All rights reserved.
Line 31 Line 29
   
   
 /*  /*
  * register strings  
  */  
 const char *reg8_str[8] = {  
         "al", "cl", "dl", "bl", "ah", "ch", "dh", "bh"  
 };  
   
 const char *reg16_str[8] = {   
         "ax", "cx", "dx", "bx", "sp", "bp", "si", "di"  
 };  
   
 const char *reg32_str[8] = {   
         "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi"  
 };  
   
 const char *sreg_str[6] = {  
         "es", "cs", "ss", "ds", "fs", "gs"  
 };  
   
 /*  
  * opcode strings   * opcode strings
  */   */
 static const char *opcode_1byte[2][256] = {  static const char *opcode_1byte[2][256] = {
Line 639  ea(disasm_context_t *ctx) Line 618  ea(disasm_context_t *ctx)
  * get opcode   * get opcode
  */   */
 static int  static int
 op(disasm_context_t *ctx)  get_opcode(disasm_context_t *ctx)
 {  {
         const char *opcode;          const char *opcode;
         UINT8 op[3];          UINT8 op[3];
Line 654  op(disasm_context_t *ctx) Line 633  op(disasm_context_t *ctx)
                         return rv;                          return rv;
   
                 op[0] = (UINT8)(ctx->val & 0xff);                  op[0] = (UINT8)(ctx->val & 0xff);
                 if (insttable_info[op[0]] & INST_PREFIX) {                  if (!(insttable_info[op[0]] & INST_PREFIX))
                         if (ctx->prefix == 0)                          break;
                                 ctx->prefix = ctx->next;  
                   if (ctx->prefix == 0)
                         switch (op[0]) {                          ctx->prefix = ctx->next;
                         case 0x26:      /* ES: */  
                         case 0x2e:      /* CS: */                  switch (op[0]) {
                         case 0x36:      /* SS: */                  case 0x26:      /* ES: */
                         case 0x3e:      /* DS: */                  case 0x2e:      /* CS: */
                                 ctx->useseg = TRUE;                  case 0x36:      /* SS: */
                                 ctx->seg = (op[0] >> 3) & 3;                  case 0x3e:      /* DS: */
                                 break;                          ctx->useseg = TRUE;
                           ctx->seg = (op[0] >> 3) & 3;
                         case 0x64:      /* FS: */                          break;
                         case 0x65:      /* GS: */  
                                 ctx->useseg = TRUE;                  case 0x64:      /* FS: */
                                 ctx->seg = (op[0] - 0x64) + 4;                  case 0x65:      /* GS: */
                                 break;                          ctx->useseg = TRUE;
                           ctx->seg = (op[0] - 0x64) + 4;
                         case 0x66:      /* OPSize: */                          break;
                                 ctx->op32 = !CPU_INST_OP32;  
                                 break;                  case 0x66:      /* OPSize: */
                           ctx->op32 = !CPU_STATSAVE.cpu_inst_default.op_32;
                         case 0x67:      /* AddrSize: */                          break;
                                 ctx->as32 = !CPU_INST_AS32;  
                                 break;                  case 0x67:      /* AddrSize: */
                         }                          ctx->as32 = !CPU_STATSAVE.cpu_inst_default.as_32;
                         continue;                          break;
                 }                  }
                 break;  
         }          }
         if (prefix == MAX_PREFIX)          if (prefix == MAX_PREFIX)
                 return 1;                  return 1;
Line 795  disasm(UINT32 *eip, disasm_context_t *ct Line 773  disasm(UINT32 *eip, disasm_context_t *ct
         ctx->arg[2] = 0;          ctx->arg[2] = 0;
   
         ctx->eip = *eip;          ctx->eip = *eip;
         ctx->op32 = CPU_INST_OP32;          ctx->op32 = CPU_STATSAVE.cpu_inst_default.op_32;
         ctx->as32 = CPU_INST_AS32;          ctx->as32 = CPU_STATSAVE.cpu_inst_default.as_32;
         ctx->seg = -1;          ctx->seg = -1;
   
         ctx->baseaddr = ctx->eip;          ctx->baseaddr = ctx->eip;
         ctx->pad = ' ';          ctx->pad = ' ';
   
         rv = op(ctx);          rv = get_opcode(ctx);
         if (rv) {          if (rv) {
                 memset(ctx, 0, sizeof(disasm_context_t));                  memset(ctx, 0, sizeof(disasm_context_t));
                 return rv;                  return rv;
Line 811  disasm(UINT32 *eip, disasm_context_t *ct Line 789  disasm(UINT32 *eip, disasm_context_t *ct
   
         return 0;          return 0;
 }  }
   
   char *
   cpu_disasm2str(UINT32 eip)
   {
           static char output[2048];
           disasm_context_t d;
           UINT32 eip2 = eip;
           int rv;
   
           output[0] = '\0';
           rv = disasm(&eip2, &d);
           if (rv == 0) {
                   char buf[256];
                   char tmp[32];
                   int len = d.nopbytes > 8 ? 8 : d.nopbytes;
                   int i;
   
                   buf[0] = '\0';
                   for (i = 0; i < len; i++) {
                           snprintf(tmp, sizeof(tmp), "%02x ", d.opbyte[i]);
                           milstr_ncat(buf, tmp, sizeof(buf));
                   }
                   for (; i < 8; i++) {
                           milstr_ncat(buf, "   ", sizeof(buf));
                   }
                   snprintf(output, sizeof(output), "%04x:%08x: %s%s",
                       CPU_CS, eip, buf, d.str);
   
                   if (i < d.nopbytes) {
                           char t[256];
                           buf[0] = '\0';
                           for (; i < d.nopbytes; i++) {
                                   snprintf(tmp, sizeof(tmp), "%02x ",
                                       d.opbyte[i]);
                                   milstr_ncat(buf, tmp, sizeof(buf));
                                   if ((i % 8) == 7) {
                                           snprintf(t, sizeof(t),
                                               "\n             : %s", buf);
                                           milstr_ncat(output, t, sizeof(output));
                                           buf[0] = '\0';
                                   }
                           }
                           if ((i % 8) != 0) {
                                   snprintf(t, sizeof(t),
                                       "\n             : %s", buf);
                                   milstr_ncat(output, t, sizeof(output));
                           }
                   }
           }
           return output;
   }
Removed from v.1.9  
changed lines
  Added in v.1.13

RetroPC.NET-CVS <cvs@retropc.net>