st20decoder.cpp

Go to the documentation of this file.

#define sign_extend(N,SIZE) (((int)((N) << (sizeof(unsigned)*8-(SIZE)))) >> (sizeof(unsigned)*8-(SIZE)))
#include <assert.h>

#line 1 "frontend/machine/st20/decoder.m"
/*
 * Copyright (C) 2005 Mike Van Emmerik
 *
 * See the file "LICENSE.TERMS" for information on usage and
 * redistribution of this file, and for a DISCLAIMER OF ALL
 * WARRANTIES.
 *
 */

/*==============================================================================
 * FILE:       decoder.m
 * OVERVIEW:   This file contains the high level decoding functionality, for matching ST-20 instructions.
 *============================================================================*/ 
/*
 * $Revision: 1.3 $ // 1.2.2.2
 *
 * 10 Mar 05 - Mike: Created.
*/

#include <assert.h>

#include "rtl.h"
#include "decoder.h"
#include "st20decoder.h"
#include "exp.h"
#include "proc.h"
#include "boomerang.h"
#include "statement.h"

/**********************************
 * ST20Decoder methods.
 **********************************/   

/*==============================================================================
 * FUNCTION:       unused
 * OVERVIEW:       A dummy function to suppress "unused local variable" messages
 * PARAMETERS:     x: integer variable to be "used"
 * RETURNS:        Nothing
 *============================================================================*/
void ST20Decoder::unused(int x)
{}

/*==============================================================================
 * FUNCTION:       ST20Decoder::decodeInstruction
 * OVERVIEW:       Decodes a machine instruction and returns an RTL instance. In all cases a single instruction is decoded.
 * PARAMETERS:     pc - the native address of the pc
 *                 delta - the difference between the above address and the host address of the pc (i.e. the address that
                    the pc is at in the loaded object file)
 *                 RTLDict - the dictionary of RTL templates used to instantiate the RTL for the instruction being decoded
 *                 proc - the enclosing procedure
 * RETURNS:        a DecodeResult structure containing all the information gathered during decoding
 *============================================================================*/
static  DecodeResult result;
DecodeResult& ST20Decoder::decodeInstruction (ADDRESS pc, int delta) {
    result.reset();                         // Clear the result structure (numBytes = 0 etc)
    ADDRESS hostPC = pc + delta;
    std::list<Statement*>* stmts = NULL;    // The actual list of instantiated Statements
    unsigned total = 0;                     // Total value from all prefixes

    while (1) {


#line 60 "frontend/machine/st20/decoder.m"
{ 
  dword MATCH_p = 
    
#line 60 "frontend/machine/st20/decoder.m"
    hostPC+result.numBytes++
    ;
  char *MATCH_name;
  static char *MATCH_name_fc_0[] = {
    (char *)0, "ldlp", (char *)0, "ldnl", "ldc", "ldnlp", (char *)0, "ldl", 
    "adc", (char *)0, (char *)0, "ajw", "eqc", "stl", "stnl", 
  };
  unsigned /* [0..255] */ MATCH_w_8_0;
  { 
    MATCH_w_8_0 = getByte(MATCH_p); 
    
      switch((MATCH_w_8_0 >> 4 & 0xf) /* fc at 0 */) {
        case 0: 
          { 
            unsigned oper = (MATCH_w_8_0 & 0xf) /* bot at 0 */;
            
#line 74 "frontend/machine/st20/decoder.m"
            

                        unconditionalJump("j", result.numBytes, hostPC+result.numBytes+total+oper, delta, pc, stmts, result);

            

            
            
            
          }
          
          break;
        case 1: case 3: case 4: case 5: case 7: case 8: case 11: case 12: 
        case 13: case 14: 
          MATCH_name = 
            MATCH_name_fc_0[(MATCH_w_8_0 >> 4 & 0xf) /* fc at 0 */]; 
          { 
            char *name = MATCH_name;
            unsigned oper = (MATCH_w_8_0 & 0xf) /* bot at 0 */;
            
#line 71 "frontend/machine/st20/decoder.m"
            

                        stmts = instantiate(pc, name, new Const(total+oper));

            

            
            
            
          }
          
          break;
        case 2: 
          { 
            unsigned oper = (MATCH_w_8_0 & 0xf) /* bot at 0 */;
            
#line 63 "frontend/machine/st20/decoder.m"
            

                        total = (total + oper) << 4;

                        continue;

                                

            
            
            
          }
          
          break;
        case 6: 
          { 
            unsigned oper = (MATCH_w_8_0 & 0xf) /* bot at 0 */;
            
#line 67 "frontend/machine/st20/decoder.m"
            

                        total = (total + ~oper) << 4;

                        continue;

            

            
            
            
          }
          
          break;
        case 9: 
          { 
            unsigned oper = (MATCH_w_8_0 & 0xf) /* bot at 0 */;
            
#line 77 "frontend/machine/st20/decoder.m"
            

                        total += oper;

                        stmts = instantiate(pc, "call" , new Const(total));

                        CallStatement* newCall = new CallStatement;

                        newCall->setIsComputed(false);

                        newCall->setDest(pc+result.numBytes+total);

                        result.rtl = new RTL(pc, stmts);

                        result.rtl->appendStmt(newCall);

            

            
            
            
          }
          
          break;
        case 10: 
          { 
            unsigned oper = (MATCH_w_8_0 & 0xf) /* bot at 0 */;
            
#line 86 "frontend/machine/st20/decoder.m"
            

                        BranchStatement* br = new BranchStatement();

                        //br->setCondType(BRANCH_JE);

                        br->setDest(pc+result.numBytes+total+oper);

                        //br->setCondExpr(dis_Reg(0));

                        br->setCondExpr(new Binary(opEquals,dis_Reg(0),new Const(0)));

                        result.rtl = new RTL(pc, stmts);

                        result.rtl->appendStmt(br);

            

            
            
            
          }
          
          break;
        case 15: 
          { 
            unsigned oper = (MATCH_w_8_0 & 0xf) /* bot at 0 */;
            
#line 95 "frontend/machine/st20/decoder.m"
            

                        total |= oper;

                        char* name = NULL;

                        bool isRet = false;

                        if (total >= 0) {

                            switch (total) {

                                case 0x00:  name = "rev";   break;

                                case 0x01: name = "lb";     break;

                                case 0x02: name = "bsub";   break;

                                case 0x03: name = "endp";   break;

                                case 0x04: name = "diff";   break;

                                case 0x05: name = "add";    break;

                                case 0x06: name = "gcall";  break;

                                case 0x07: name = "in";     break;

                                case 0x08: name = "prod";   break;

                                case 0x09: name = "gt";     break;

                                case 0x0A: name = "wsub";   break;

                                case 0x0B: name = "out";    break;

                                case 0x0C: name = "sub";    break;

                                case 0x0D: name = "startp"; break;

                                case 0x0E: name = "outbyte";break;

                                case 0x0F: name = "outword";break;

                                case 0x10: name = "seterr"; break;

                                case 0x12: name = "resetch";break;

                                case 0x13: name = "csub0";  break;

                                case 0x15: name = "stopp";  break;

                                case 0x16: name = "ladd";   break;

                                case 0x17: name = "stlb";   break;

                                case 0x18: name = "sthf";   break;

                                case 0x19: name = "norm";   break;

                                case 0x1A: name = "ldiv";   break;

                                case 0x1B: name = "ldpi";   break;

                                case 0x1C: name = "stlf";   break;

                                case 0x1D: name = "xdble";  break;

                                case 0x1E: name = "ldpri";  break;

                                case 0x1F: name = "rem";    break;

                                case 0x20: name = "ret"; isRet = true; break;

                                case 0x21: name = "lend";   break;

                                case 0x22: name = "ldtimer";break;

                                case 0x29: name = "testerr";break;

                                case 0x2A: name = "testpranal";break;

                                case 0x2B: name = "tin";    break;

                                case 0x2C: name = "div";    break;

                                case 0x2E: name = "dist";   break;

                                case 0x2F: name = "disc";   break;

                                case 0x30: name = "diss";   break;

                                case 0x31: name = "lmul";   break;

                                case 0x32: name = "not";    break;

                                case 0x33: name = "xor";    break;

                                case 0x34: name = "bcnt";   break;

                                case 0x35: name = "lshr";   break;

                                case 0x36: name = "lshl";   break;

                                case 0x37: name = "lsum";   break;

                                case 0x38: name = "lsub";   break;

                                case 0x39: name = "runp";   break;

                                case 0x3A: name = "xword";  break;

                                case 0x3B: name = "sb";     break;

                                case 0x3C: name = "gajw";   break;

                                case 0x3D: name = "savel";  break;

                                case 0x3E: name = "saveh";  break;

                                case 0x3F: name = "wcnt";   break;

                                case 0x40: name = "shr";    break;

                                case 0x41: name = "shl";    break;

                                case 0x42: name = "mint";   break;

                                case 0x43: name = "alt";    break;

                                case 0x44: name = "altwt";  break;

                                case 0x45: name = "altend"; break;

                                case 0x46: name = "and";    break;

                                case 0x47: name = "enbt";   break;

                                case 0x48: name = "enbc";   break;

                                case 0x49: name = "enbs";   break;

                                case 0x4A: name = "move";   break;

                                case 0x4B: name = "or";     break;

                                case 0x4C: name = "csngl";  break;

                                case 0x4D: name = "ccnt1";  break;

                                case 0x4E: name = "talt";   break;

                                case 0x4F: name = "ldiff";  break;

                                case 0x50: name = "sthb";   break;

                                case 0x51: name = "taltwt"; break;

                                case 0x52: name = "sum";    break;

                                case 0x53: name = "mul";    break;

                                case 0x54: name = "sttimer";break;

                                case 0x55: name = "stoperr";break;

                                case 0x56: name = "cword";  break;

                                case 0x57: name = "clrhalterr"; break;

                                case 0x58: name = "sethalterr"; break;

                                case 0x59: name = "testhalterr";break;

                                case 0x5A: name = "dup";        break;

                                case 0x5B: name = "move2dinit"; break;

                                case 0x5C: name = "move2dall";  break;

                                case 0x5D: name = "move2dnonzero";break;

                                case 0x5E: name = "move2dzero"; break;

                                case 0x5F: name = "gtu";        break;

                                case 0x63: name = "unpacksn";   break;

                                case 0x64: name = "slmul";      break;

                                case 0x65: name = "sulmul";     break;

                                case 0x68: name = "satadd";     break;

                                case 0x69: name = "satsub";     break;

                                case 0x6A: name = "satmul";     break;

                                case 0x6C: name = "postnormsn"; break;

                                case 0x6D: name = "roundsn";    break;

                                case 0x6E: name = "ldtraph";    break;

                                case 0x6F: name = "sttraph";    break;

                                case 0x71: name = "ldinf";      break;

                                case 0x72: name = "fmul";       break;

                                case 0x73: name = "cflerr";     break;

                                case 0x74: name = "crcword";    break;

                                case 0x75: name = "crcbyte";    break;

                                case 0x76: name = "bitcnt";     break;

                                case 0x77: name = "bitrevword"; break;

                                case 0x78: name = "bitrevnbits";break;

                                case 0x79: name = "pop";        break;

                                case 0x7E: name = "ldmemstartval";break;

                                case 0x81: name = "wsubdb";     break;

                                case 0x9C: name = "fptesterr";  break;

                                case 0xB0: name = "settimeslice";break;

                                case 0xB8: name = "xbword";     break;

                                case 0xB9: name = "lbx";        break;

                                case 0xBA: name = "cb";         break;

                                case 0xBB: name = "cbu";        break;

                                case 0xC1: name = "ssub";       break;

                                case 0xC4: name = "intdis";     break;

                                case 0xC5: name = "intenb";     break;

                                case 0xC6: name = "ldtrapped";  break;

                                case 0xC7: name = "cir";        break;

                                case 0xC8: name = "ss";         break;

                                case 0xCA: name = "ls";         break;

                                case 0xCB: name = "sttrapped";  break;

                                case 0xCC: name = "ciru";       break;

                                case 0xCD: name = "gintdis";    break;

                                case 0xCE: name = "gintenb";    break;

                                case 0xF0: name = "devlb";      break;

                                case 0xF1: name = "devsb";      break;

                                case 0xF2: name = "devls";      break;

                                case 0xF3: name = "devss";      break;

                                case 0xF4: name = "devlw";      break;

                                case 0xF5: name = "devsw";      break;

                                case 0xF6: name = "null";       break;

                                case 0xF7: name = "null";       break;

                                case 0xF8: name = "xsword";     break;

                                case 0xF9: name = "lsx";        break;

                                case 0xFA: name = "cs";         break;

                                case 0xFB: name = "csu";        break;

                                case 0x17C:name = "lddevid";    break;

                            }

                        } else {

                            // Total is negative, as a result of nfixes

                            total = (~total & ~0xF) | (total & 0xF);        // 1's complement the upper nibbles

                            switch (total) {

                                case 0x00: name = "swapqueue";  break;

                                case 0x01: name = "swaptimer";  break;

                                case 0x02: name = "insertqueue";break;

                                case 0x03: name = "timeslice";  break;

                                case 0x04: name = "signal";     break;

                                case 0x05: name = "wait";       break;

                                case 0x06: name = "trapdis";    break;

                                case 0x07: name = "trapenb";    break;

                                case 0x0B: name = "tret"; isRet = true; break;

                                case 0x0C: name = "ldshadow";   break;

                                case 0x0D: name = "stshadow";   break;

                                case 0x1F: name = "iret"; isRet = true; break;

                                case 0x24: name = "devmove";    break;

                                case 0x2E: name = "restart";    break;

                                case 0x2F: name = "causeerror"; break;

                                case 0x30: name = "nop";        break;

                                case 0x4C: name = "stclock";    break;

                                case 0x4D: name = "ldclock";    break;

                                case 0x4E: name = "clockdis";   break;

                                case 0x4F: name = "clockenb";   break;

                                case 0x8C: name = "ldprodid";   break;

                                case 0x8D: name = "reboot";     break;

                            }

                        }

                        if (name) {

                            stmts = instantiate(pc, name);

                            if (isRet) {

                                result.rtl = new RTL(pc, stmts);

                                result.rtl->appendStmt(new ReturnStatement);

                            }

                        } else {

                            result.valid = false;       // Invalid instruction

                            result.rtl = NULL;

                            result.numBytes = 0;

                            return result;

                        }

            

            

            
            
            
          }
          
          break;
        default: assert(0);
      } /* (MATCH_w_8_0 >> 4 & 0xf) -- fc at 0 --*/ 
    
  }goto MATCH_finished_a; 
  
  MATCH_finished_a: (void)0; /*placeholder for label*/
  
}

#line 283 "frontend/machine/st20/decoder.m"
        break;
    }

    if (result.rtl == 0)
        result.rtl = new RTL(pc, stmts);
    return result;
}

/*==============================================================================
 * These are machine specific functions used to decode instruction operands into Exp*s.
 *============================================================================*/

/**********************************
 * These are the fetch routines.
 **********************************/   

/*==============================================================================
 * FUNCTION:        getWord
 * OVERVIEW:        Returns the word starting at the given address.
 * PARAMETERS:      lc - address at which to decode the double
 * RETURNS:         the decoded double
 *============================================================================*/
Byte ST20Decoder::getByte (unsigned lc)
/* getByte - returns next byte from image pointed to by lc.  */
{
    return *(Byte *)lc;
}

/*==============================================================================
 * FUNCTION:        getWord
 * OVERVIEW:        Returns the word starting at the given address.
 * PARAMETERS:      lc - address at which to decode the double
 * RETURNS:         the decoded double
 *============================================================================*/
SWord ST20Decoder::getWord (unsigned lc)
/* get2Bytes - returns next 2-Byte from image pointed to by lc.  */
{
    return (SWord)(*(Byte *)lc + (*(Byte *)(lc+1) << 8));
}

/*==============================================================================
 * FUNCTION:        getDword
 * OVERVIEW:        Returns the double starting at the given address.
 * PARAMETERS:      lc - address at which to decode the double
 * RETURNS:         the decoded double
 *============================================================================*/
DWord ST20Decoder::getDword (unsigned lc)
/* get4Bytes - returns the next 4-Byte word from image pointed to by lc. */
{
    return (DWord)(*(Byte *)lc + (*(Byte *)(lc+1) << 8) +
        (*(Byte *)(lc+2) << 16) + (*(Byte *)(lc+3) << 24));
}


/*==============================================================================
 * FUNCTION:       ST20Decoder::ST20Decoder
 * OVERVIEW:       Constructor. The code won't work without this (not sure why the default constructor won't do...)
 * PARAMETERS:     None
 * RETURNS:        N/A
 *============================================================================*/
ST20Decoder::ST20Decoder() : NJMCDecoder(prog)
{
    std::string file = Boomerang::get()->getProgPath() + "frontend/machine/st20/st20.ssl";
    RTLDict.readSSLFile(file.c_str());
}

// For now...
int ST20Decoder::decodeAssemblyInstruction(unsigned, int)
{ return 0; }

---