ucdisasm.cc

Go to the documentation of this file.

/*
 *  ucdisasm.cc - Disassembled usecode trace
 *
 *  Copyright (C) 1999  Jeffrey S. Freedman
 *  Copyright (C) 2000-2002  The Exult Team
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif


#include <cstring>
#include <cstdio>
#include <iostream>

#ifndef UNDER_CE
using std::strlen;
using std::cout;
#endif

#include "ucinternal.h"
#include "uctools.h"
#include "utils.h"
#include "useval.h"
#include "game.h"
#include "stackframe.h"

int Usecode_internal::get_opcode_length(int opcode)
{
  if (opcode >=0 &&
    opcode < (sizeof(opcode_table)/sizeof(opcode_table[0]))) {

      return opcode_table[opcode].nbytes + 1;
  } else {
    return 0;
  }
}

void Usecode_internal::uc_trace_disasm(Stack_frame* frame)
{
  uc_trace_disasm(frame->locals,
          frame->num_args + frame->num_vars,
          frame->data,
          frame->externs,
          frame->code,
          frame->ip);
}

void Usecode_internal::uc_trace_disasm(Usecode_value* locals, int num_locals,
             uint8* data, uint8* externals, uint8* code,
             uint8* ip)
{
  int func_ip = (int)(ip - code);
  int opcode = *ip++;
  uint8* param_ip = ip;
  _opcode_desc* pdesc;

  if (opcode >=0 && opcode < (sizeof(opcode_table)/sizeof(opcode_table[0])))
    pdesc = &(opcode_table[opcode]);
  signed short immed;
  unsigned short varref;
  unsigned short func;
  int immed32;
  int offset;

  std::printf("      %04X: ", func_ip);

  if (pdesc && pdesc->mnemonic) {
    std::printf("%s", pdesc->mnemonic);
    if (strlen(pdesc->mnemonic) < 4)
      std::printf("\t");
  } else {
    std::printf("<unknown>");
  }

  if (pdesc && pdesc->nbytes > 0) {
    switch( pdesc->type )
      {
      case BYTE:
        std::printf("\t%02x", *ip++);
        break;
      case IMMED:
        // Print immediate operand
        immed = Read2(ip);
        std::printf("\t%04hXH\t\t; %d", immed, immed);
        break;
      case IMMED32:
        immed32 = (sint32)Read4(ip);
        std::printf("\t%04hXH\t\t; %d", immed32, immed32);
        break;
      case DATA_STRING:
      case DATA_STRING32:
        {
          char* pstr;
          int len;
          // Print data string operand
          if (pdesc->type == DATA_STRING)
            offset = Read2(ip);
          else
            offset = (sint32)Read4(ip);

          pstr = (char*)data + offset;
          len = strlen(pstr);
          if( len > 20 )
            len = 20 - 3;
          std::printf("\tL%04X\t\t; ", offset);
          for(int i = 0; i < len; i++ )
            std::printf("%c", pstr[i]);
          if( len < strlen(pstr) )
            // String truncated
            std::printf("...");
        }
        break;
      case RELATIVE_JUMP:
        // Print jump desination
        offset = Read2(ip);
        std::printf("\t%04X",
              (offset + func_ip+1+pdesc->nbytes)&0xFFFF);
        break;
      case RELATIVE_JUMP32:
        offset = (sint32)Read4(ip);
        std::printf("\t%04X", offset + func_ip+1+pdesc->nbytes);
        break;        
      case SLOOP:
        if (pdesc->nbytes == 11)
          ip++;
        Read2(ip);
        Read2(ip);
        Read2(ip);
        varref = Read2(ip);
        offset = Read2(ip);
        std::printf("\t[%04X], %04X\t= ", varref, 
             (offset +func_ip+1+pdesc->nbytes)&0xFFFF);
        locals[varref].print(cout, true); // print value (short format)
        break;
      case SLOOP32:
        if (pdesc->nbytes == 13)
          ip++;
        Read2(ip);
        Read2(ip);
        Read2(ip);
        varref = Read2(ip);
        offset = (sint32)Read4(ip);
        std::printf("\t[%04X], %04X\t= ", varref, 
             offset +func_ip+1+pdesc->nbytes);
        locals[varref].print(cout, true); // print value (short format)
        break;
      case IMMED_AND_RELATIVE_JUMP:
        immed = Read2(ip);
        offset = Read2(ip);
        std::printf("\t%04hXH, %04X", immed, 
             (offset + func_ip+1+pdesc->nbytes)&0xFFFF);
        break;
      case IMMED_RELJUMP32:
        immed = Read2(ip);
        offset = (sint32)Read4(ip);
        std::printf("\t%04hXH, %04X", immed, 
             offset + func_ip+1+pdesc->nbytes);
        break;        
      case CALL:
        {
          func = Read2(ip);
          immed = *ip++;
          const char **func_table = bg_intrinsic_table;
          if (Game::get_game_type() == SERPENT_ISLE)
            func_table = si_intrinsic_table;
          std::printf("\t_%s@%d\t; %04X", func_table[func], immed, func);
        }
        break;
      case EXTCALL:
        {
          // Print extern call
          offset = Read2(ip);
          std::printf("\t[%04X]\t\t; %04XH", offset,
               externals[2*offset] + 256*externals[2*offset + 1]);
        }
        break;
      case VARREF:
        // Print variable reference
        varref = Read2(ip);
        std::printf("\t[%04X]\t\t= ", varref);
        locals[varref].print(cout, true); // print value (short)
        break;
      case FLGREF:
        // Print global flag reference
        offset = Read2(ip);
        std::printf("\tflag:[%04X]\t= ", offset);
        if (gflags[offset])
          std::printf("set");
        else
          std::printf("unset");
        break;
      default:
        // Unknown type
        break;
      }
  }
  ip = param_ip; //restore IP back to opcode parameters

  // special cases:
  switch (opcode) {
  case 0x05:    // JNE.
    {
      Usecode_value val;
      if (sp <= stack)
        val = Usecode_value(0);
      else
        val = *(sp - 1); 

      if (val.is_false())
        std::printf("\t\t(jump taken)");
      else
        std::printf("\t\t(jump not taken)");
      break;
    }

    /*
      maybe predict this?
  case 0x07:    // CMPS.
    {
      int cnt = Read2(ip);  // # strings.
      offset = (short) Read2(ip);
      bool matched = false;
      
      // only try to match if we haven't found an answer yet
      while (!matched && !found_answer && cnt-- > 0) {
        Usecode_value s = pop();
        const char *str = s.get_str_value();
        if (str && strcmp(str, user_choice) == 0) {
          matched = true;
          found_answer = true;
        }
      }
      while (cnt-- > 0) // Pop rest of stack.
        pop();
      if (!matched)   // Jump if no match.
        ip += offset;
    }
    break;
    */
  }

  std::printf("\n");
}

---