infernal-interpreter/Emulator.py

import re

import Junk
from opcodes import OPCODES

REGISTERS=["%rax", "%rbx", "%rcx", "%rdx", "%rsp", "%rbp", "%rsi", "%rdi",
            "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15"]

class CodeParseException (BaseException):

    def __init__ (self, line_nr, string):
        self.line_nr = line_nr
        self.string = string

class InternalExecutionException (BaseException):
    pass

class Emulator:

    def __init__ (self, source_text, max_stack_size=1000):
        self.source = source_text
        self.registers = {}
        for reg_name in REGISTERS:
            self.registers[reg_name] = Junk.Junk()
        self.stack = {}
        for i in range(max_stack_size):
            self.stack[i] = Junk.Junk()
        self.code = []
        self.labels = {}
        self.changes = {}
        self.status = {'i':True}
        self.last_sp = 0
        self.max_stack_size = 0
        index = 0
        for line in iter(source_text.splitlines()):
            index = self.processSourceLine(line, index)

    def setStack (self, *stack_list, **kwargs):
        """
        Sets various stack elements, starting from 0 and going up.
        Automatically sets rsp. This can be disabled by passing set_rsp=False.
        """
        i = len(self.stack)
        for element in stack_list:
            i -= 1
            self.stack[i] = element
        self.setRegs(rsp=i)
        self.last_sp = i-1

    def setRegs (self, **reg_dict):
        for reg_name, reg_val in reg_dict.iteritems():
            assert(reg_name[0] != '%')
            self.registers["%"+reg_name] = reg_val

    def getVal (self, val_text):
        if val_text[0] == "$":
            return int(val_text[1:])
        elif val_text[0] == "%":
            return self.registers[val_text]
        else:
            raise ValueError('{} is not an usable value name'.format(val_text))

    def compareVal (self, valT1, valT2):
        val1 = self.getVal(valT2)
        val2 = self.getVal(valT1)
        if isinstance(val1,Junk.Junk) or isinstance(val2,Junk.Junk):
            self.status["i"] = (True,)
            return
        self.status["g"] = val1>val2
        self.status["l"] = val1<val2
        self.status["e"] = val1==val2
        self.status["i"] = False

    def changedRegisters (self, *args):
        for reg, val in args:
            self.changes[reg] = val

    def processSourceLine(self, line_text, index):
        tokens = re.findall(r'[^\s,]+', line_text)
        if len(tokens) <= 0 or tokens[0][0] == '#':
            return index
        if tokens[0][-1] == ':':
            self.labels[tokens[0][:-1]] = index
            tokens = tokens[1:]
        for i in range(len(tokens)):
            if tokens[i][0] == "#":
                tokens = tokens[:i]
                break
        self.code.append(tokens)
        return index + 1

    def regState (self, reg_name):
        if reg_name in self.changes:
            return self.changes[reg_name]
        else:
            return "none"

    def getLineSignature (self, line_nr):
        return [ "\\"+token if token[0]=="$" or token[0]=="%" else token for token in self.code[line_nr] ]

    def pushToStack (self, new_element):
        self.registers['%rsp'] -= 1
        self.stack[self.registers['%rsp']] = new_element
        self.changedRegisters(('%rsp',"change"), ("m"+str(self.registers['%rsp']),"insert"))
        self.max_stack_size = max(self.registers['%rsp'], self.max_stack_size)

    def popFromStack (self):
        temp = self.stack[self.registers['%rsp']]
        self.changedRegisters(('%rsp',"change"),("m"+str(self.registers['%rsp']),"remove"))
        self.registers['%rsp'] += 1
        return temp

    def jump (self, label, cond_op="or", **conditions):
        if len(conditions)>0 and self.status["i"]:
            raise Junk.JunkComparisonException(*self.status['i'])
        and_, or_ = True, False
        for cnd_name, cnd_val in conditions.iteritems():
            if self.status[cnd_name] == cnd_val:
                or_ = True
            else:
                and_ = False
        if or_ if cond_op=="or" else and_:
            self.registers['%rip'] = self.labels[label]
            return True
        else:
            return False

    def iterate (self):
        old_rip = self.registers['%rip']
        self.last_sp = self.registers['%rsp']
        if self.registers['%rip'] >= len(self.code) or isinstance(self.registers['%rip'], Junk.Junk):
            return None
        if not isinstance(self.registers['%rip'], (int, long)):
            raise InternalExecutionException("Register %rip should be integer, but was "+str(self.registers['%rip']))
        instruct = self.code[self.registers['%rip']]
        opcode = instruct[0]
        self.changes = {}

        OPCODES[opcode](self, *instruct[1:])

        if self.registers['%rip'] == old_rip:
            self.registers['%rip'] += 1
        else:
            self.changedRegisters(('%rip',"jump"))

        return old_rip

    def __iter__(self):
        return self

    def next(self):
        output = self.iterate()
        if output is None:
            raise StopIteration()
        else:
            return output

    def getUsedRegisters (self):
        return [reg_name for reg_name, reg_val in self.registers.iteritems() if not isinstance(reg_val, Junk.Junk)]