Assembly Simulator in Python

--D. Thiebaut (talk) 17:49, 24 November 2015 (EST)

---

Python Simulator

# assemblySimulator.py
# D. Thiebaut
# This program allows the display of the stack
# as a recursive factorial program computes the
# factorial of 3.
# The program writes the stack to a file, as well
# as the contents of the data registers to a file,
# so the best way to display them is to "watch" the
# files stack.txt and registers.txt in two separate
# terminal windows.   Make sure the "watch" linux
# command is installed on your system.

import sys, os

program="""
extern _printDec
extern _println        

;;;  -------------------------
;;;  code area
;;;  -------------------------
                section .text
                global  _start

;;; ; ---------------------------------------------------------
;;; ; main program
;;; ; ---------------------------------------------------------
_start:         mov     eax, 4  ; n = 4

                push    eax     ; TOS <-- XX
                push    eax     ; TOS <-- n
                call    fact
                pop     eax     ; get n in eax

;;;  return to OS
                mov     eax, 1
                mov     ebx, 0
                int     0x80

;;; ; ---------------------------------------------------------
fact:           push    ebp     ; TOS <-- old ebp
                mov     ebp, esp
                
;;;  test for stopping condition

                cmp     dword[ebp+8], 1    ; n==1 ?
                jg      .recurse
                mov     dword[ebp+12], 1 ; yes, then n! = 1
                pop     ebp     ; return to caller
                ret     4

;;;  recursive step

.recurse:       push    eax     ; TOS <-- old eax
                push    ebx     ; TOS <-- old ebx
                push    edx     ; TOS <-- old edx
        
                mov     eax, dword[ebp+8]  
                dec     eax     ; n-1 in eax
                push    eax     ; TOS <-- XX
                push    eax     ; TOS <-- n-1
                call    fact    ; recursive call
                pop     ebx     ; get fact(n-1) in ebx
                mov     eax, dword[ebp+8]
                mul     ebx     ; edx:eax <-- n * (n-1)!
        
                mov     dword[ebp+12], eax ; that's n!
                                ; drop edx
                pop     edx     ; restore regs
                pop     ebx
                pop     eax
        
                pop     ebp     ; return
                ret     4
"""

instructions = [ "ret", "call", "pop", "push", "dec", "mov",
                 "mul", "cmp", "jg", "int" ]
registers = {"eax":0, "ebx":0, "ecx":0, "edx":0, "esp":0, "ebp":0 }
stack = [0] * 40
flags = { "l":True, "lt":True, "e":True,
          "ne":True, "g":True, "ge":True }


class Listing:
    """The listing class.
    Initializes itself with the lines from an assembly program.
    and disassembles and executes the different instructions
    in the program.
    """
    def __init__( self, program ):
        self.lines = []
        for line in program.split( "\n" ):
            self.lines.append( line.rstrip() )
        self.stack = []
        self.lastLine = len( self.lines )-1
        
        self.ip = 0
        for i,line in enumerate( self.lines ):
            if line.find( "_start:" ) != -1:
                self.ip = i
                break

        # find all labels
        self.labelAddress = {}
        for i, line in enumerate( self.lines ):
            if line.find( ":" ) != -1:
                label = line.split( ":" )[0]
                self.labelAddress[label] = i
                
    def display( self ):
        for i, line in enumerate( self.lines ):
            if i < max( self.ip-10, 0 ): continue
            if i > min( self.lastLine+1, self.ip+10 ): continue
            line = self.lines[i]
            if i == self.ip:
                try:
                    line = line[0:9] + "-->" + line[12:]
                except:
                    print( "Error: line = ", line )
                    line = line
            print( "{0:3}: {1:1}".format(i, line ) )

    def __str__( self ):
        s = "Ip = " + str( self.ip  ) + "\n"
        s += "line[Ip] = " + str( self.lines[self.ip] ) + "\n"
        return s

    def containsInstr( self, line ):
        for instr in instructions:
            if line.lower().find( instr.lower()+" " ) != -1:
                return True
        return False

    def getDest( self, line ):
        line = line.split( ";" )[0].strip()
        dest = line.split()[-1]
        return dest

    def nextIp( self ):
        ip = self.ip
        while True:
            ip += 1
            line = self.lines[ip]
            
            if ip >= len( self.lines ):
                print( "\n\nException. IP running wild!\n\n" )
                sys.exit()
                
            if self.containsInstr( line ):
                return ip
            
    def step( self ):
        # execute the current line
        isJump = self.execute()

        if isJump:
            return
        
        # otherwise, advance ip to the next line
        # that contains an instruction
        line = self.lines[ self.ip ]
        self.ip = self.nextIp()

    def push( self, item, comment=None ):
        registers[ "esp" ] -= 1
        if comment==None:
            stack[ registers[ "esp" ] ] = item
        else:
            stack[ registers[ "esp" ] ] = \
                   "{0:1} {1:1}".format( item, comment )

    def pop( self ):
        item = stack[ registers[ "esp" ] ]
        if type( item )==type( "string" ):
            item = int( item.split()[0].strip() )
        registers[ "esp" ] += 1
        return item

        
    def execute( self ):
        line = self.lines[ self.ip ]
        
        # remove comments
        stackComment = None
        if line.find( ";" ) != -1:
            comment = line.split( ";" )[-1]
            line = line.split( ";" )[0]
            #print( "line = ", line )
            #print( "comment = ", comment )
            if comment.find( "TOS <--" ) != -1:
                stackComment = comment.split( "TOS <--" )[-1]
                #print( "Stack Comment = ", stackComment )

        line = line.lower()
        
        # remove label
        label = None
        if line.find( ":" ) != -1:
            label = line.split( ":" )[0].strip()
            line = line.split( ":" )[1]

        fields = line.split( )
        instruction = fields[0]
        if len( fields )==3:
            operand1 = fields[1].replace( ',','' ).strip()
            operand2 = fields[2].replace( ',','' ).strip()
        if len( fields )==2:
            operand1 = fields[-1].replace( ',','' ).strip()
            operand2 = None
        if len( fields )==1:
            operand1 = None
            operand2 = None
            
        #print( "label=", label, " inst=", instruction, " op1=", operand1,
        #       "op2=", operand2 )
        
        # int 0x80?
        if instruction == "int" and operand1 =="0x80":
            print( "\n\nDone!\n\n" )
            sys.exit()

        # call label?
        if instruction == "call":
            label = self.getDest( line )
            #print( "call to", label )
            self.push( self.nextIp(), "*" )
            self.ip = self.labelAddress[ label ]
            return True # is a jump

        # push
        if instruction == "push":
            if operand1 in registers.keys():
                self.push( registers[ operand1 ], stackComment )
            else:
                print( "*** Error: trying to push ", operand1 )
            return False

        # pop
        if instruction == "pop":
            if operand1 in registers.keys():
                data = self.pop()
                registers[ operand1 ] = data
            else:
                print( "*** Error: trying to pop into ", operand1 )
            return False

        # mov
        if instruction == "mov":
            #print( "mov: instr=", instruction, "op1=", operand1,
            #       "op2=", operand2 )
            if operand2 in registers.keys():                
                data = int( registers[operand2] )
            elif operand2.find( "ebp+" )!=-1:
                operand2 = operand2.replace( "]", "" )
                offset = int( operand2.split( "ebp+" )[1] )
                data = stack[ registers["ebp"] + offset//4 ]
                if type(data)==type("string"):
                    data = int( data.split()[0].strip() )
                #print( "mov operand2 = ", operand2, "offset = ", offset )
            else:
                data = int( operand2 )

            #print( "mov: data = ", data )
            
            if operand1 in registers.keys():
                registers[ operand1 ] = data
                #print( "mov: setting", operand1, "to", data )
            elif operand1.find( "ebp+" )!=-1:
                operand1 = operand1.replace( "]", "" )
                offset = int( operand1.split( "ebp+")[1] )
                stack[ registers["ebp"] + offset//4 ] = data
            return False
        
        # dec
        if instruction == "dec":
            if operand1 in registers.keys():
                registers[operand1] -= 1
            else:
                print( "*** Error *** trying to decrement", operand1 )
            return False

        # mul
        if instruction == "mul":
            if operand1 in registers.keys():
                registers["eax"] = registers[operand1] * registers["eax"]
                registers["edx"] = 0
            return False
                 
        # cmp
        if instruction == "cmp":
            if operand2 in registers.keys():
                data = int( registers[operand2] )
            elif operand2.find( "ebp+" )!=-1:
                operand2 = operand2.replace( "]", "" )
                offset = int( operand2.split( "ebp+" )[1] )
                data = stack[ registers["ebp"] + offset//4 ]
                if type(data)==type("string"):
                    data = int( data.split()[0].strip() )

            else:
                data = int( operand2 )
                            
            if operand1 in registers.keys():
                #print( "cmp: operand1 = ", operand1, "value = ",
                #       registers[ operand1 ] )
                flags["l"]  = registers[ operand1 ] < data
                flags["le"] = registers[ operand1 ] <= data
                flags["e"]  = registers[ operand1 ] == data
                flags["ne"] = registers[ operand1 ] != data
                flags["g"]  = registers[ operand1 ] > data
                flags["ge"] = registers[ operand1 ] >= data
            elif operand1.find( "ebp+" )!=-1:
                operand1 = operand1.replace( "]", "" )
                offset = int( operand1.split( "ebp+")[1] )
                operand1 = stack[ registers["ebp"] + offset//4 ]
                if type(operand1)==type("string"):
                    operand1 = int( operand1.split()[0].strip() )

                #print( "cmp: operand1 = ", operand1 )
                flags["l"]  = operand1 < data
                flags["le"] = operand1 <= data
                flags["e"]  = operand1 == data
                flags["ne"] = operand1 != data
                flags["g"]  = operand1 > data
                flags["ge"] = operand1 >= data

            print( "cmp: flags = ", flags )
            return False

        # jg
        if instruction == "jg":
            if flags["g"]:
                self.ip = self.labelAddress[ operand1 ]
                return True
            return False
        
        # ret?
        if instruction == "ret":
            self.ip = self.pop()

            # get the number after ret
            if operand1 != None:
                operand1 = int( operand1 )
                for i in range( 0, operand1, 4 ):
                    self.pop()
            return True
        
        return False

def displayStack():
    file = open( "stack.txt", "w" )
    file.write( "\n" )
    file.write( "+" + ("-"*18) + "+ \n" )
    for i in range( len(stack)-1, registers["esp"]-1, -1 ):
        file.write( "|" + "   {0:<12}   ".format( stack[i] ) + "|")
        if i==registers["esp"]:
            file.write( "<-- esp " )
        if i==registers["ebp"]:
            file.write( "<-- ebp " )
        file.write( "\n" ) 
    file.write( "+" + ("-"*18) + "+\n" )
    file.close()
    
def displayRegs():
    file = open( "registers.txt", "w" )
    for reg in ["eax", "ebx", "ecx", "edx" ]:
        file.write( reg.upper() + ": " +str( registers[reg] ) + "\n" )
    file.write( "\n" )
    file.close()
    
def main():
    # initialize the registers
    registers["esp"] = len( stack )-1

    # initialize the listing
    listing = Listing( program )

    # display the first listing
    os.system('clear')
    listing.display()

    # simulation loop.  Single step through the
    # program.
    while True:
        input( "> " )
        os.system('clear')
        listing.step()
        listing.display()
        displayStack()
        displayRegs()

main()

Factorial in Intel Assembly

;;;  -------------------------
;;;  code area
;;;  -------------------------
                section .text
                global  _start

;;; ; ---------------------------------------------------------
;;; ; main program
;;; ; ---------------------------------------------------------
_start:         mov     eax, 4  ; n = 4

                push    eax     ; TOS <-- XX
                push    eax     ; TOS <-- n
                call    fact
                pop     eax     ; get n in eax

;;;  return to OS
                mov     eax, 1
                mov     ebx, 0
                int     0x80

;;; ; ---------------------------------------------------------
fact:           push    ebp     ; TOS <-- old ebp
                mov     ebp, esp
                
;;;  test for stopping condition

                cmp     dword[ebp+8], 1    ; n==1 ?
                jg      .recurse
                mov     dword[ebp+12], 1 ; yes, then n! = 1
                pop     ebp     ; return to caller
                ret     4

;;;  recursive step

.recurse:       push    eax     ; TOS <-- old eax
                push    ebx     ; TOS <-- old ebx
                push    edx     ; TOS <-- old edx
        
                mov     eax, dword[ebp+8]  
                dec     eax     ; n-1 in eax
                push    eax     ; TOS <-- XX
                push    eax     ; TOS <-- n-1
                call    fact    ; recursive call
                pop     ebx     ; get fact(n-1) in ebx
                mov     eax, dword[ebp+8]
                mul     ebx     ; edx:eax <-- n * (n-1)!
        
                mov     dword[ebp+12], eax ; that's n!
                                ; drop edx
                pop     edx     ; restore regs
                pop     ebx
                pop     eax
        
                pop     ebp     ; return
                ret     4