ANNA.js

v0.9.10 - (Best viewed in Chrome)

Source (Please copy and paste) Load another sample!

Opcode with Source

ASM and LOAD!

Success! Assembled and Loaded to Memory!

Failure!

Machine Code 0

	BP	Addr	Code	Source

Run! Run step by step! Run until BP! Reset Regs/PC! Reset Mem! (Load) Clear BPs!

# of Instructions Executed

Output

Success! Simulation finished!

Failure!

Status (Press ENTER to apply the value change)

r0

r1

r2

r3

r4

r5

r6

r7

PC

Mem-Address

Mem-Value

Mem-Address

Mem-Value

Mem-Address

Mem-Value

Mem-Address

Mem-Value

About ANNA.js

Documentation

§ ANNA Guide

§ ANNA Programming Card

Copyright Notice

Copyright (C) 2016 SC Lee & Eric Larson

Program is currently maintained by Eric Larson at Seattle University.

Email: elarson [at] seattleu [dot] edu.

This program is part of the ANNA assembler / simulator tool suite.

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 3 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, see <http://www.gnu.org/licenses/>.

# Fibonacci sequence
# r1 <- r2 + r3
# r4 : counter
        # load values
        lli r3 1
        lli r4 10
loop:   add r1 r2 r3
        out r1
        or r2 r3 r0     # r2 <- r3
        or r3 r1 r0     # r3 <- r1
        addi r4 r4 -1   # dec r4 by 1
        bgz r4 &loop
        .halt

# Multiplication program
# Register usage:
# r2, r3: two numbers to multiply
# r4: final answer
# r5: stores sign of final answer
# (0-positive, nonzero - negative)
		# get two input numbers
		in  r2
		in  r3
		# check for negative numbers
		bgz r2 &posA
		not r5 r5			# flip sign
		sub r2 r0 r2		# negate
posA:	bgz r3 &loop
		not r5 r5			# flip sign
		sub r3 r0 r3		# negate
		# main loop: while r3 > 0
loop:	bez r3 &done
		add r4 r4 r2		# add another r2 to r4
		addi r3 r3 -1		# decrement r3
		bez r0 &loop
		# output answer with proper sign
done:	bez r5 &disp
		sub r4 r0 r4
disp:   out r4
		.halt

# branch.ac 
	lli r1 1
	lli r2 2
	lli r3 3
	lli r4 4
	lli r5 5
	bgz r0 -7
	bez r0 5
	out r3
	bez r0 0x12
	.halt
	.halt
	.halt
	out r1
	out r2
	bez r0 -8 
	.halt
	.halt
	.halt
	.halt
	.halt
	.halt
	.halt
	.halt
	.halt
	out r5
	.halt
	.halt
	out r4
	bgz r1 0xfb
	.halt

# jalr.ac
        lli r3 -1
        lli r1 1
        lli r2 &target
        lui r2 &target
        jalr r2 r2
        out r1
        .halt
target: out r3
        .halt

# logic.ac
    	lli r2 1
loop1:	bez r2 &end1
	shf r2 r2 1
	out r2
	bez r0 &loop1
end1:	lli r2 1
loop2:	bez r2 &end2
	shf r2 r2 2
	out r2
	bez r0 &loop2
end2:	lli r2 0xdc
	lui r2 0xfe
loop3:	bez r2 &end3
	shf r2 r2 -1
	out r2
	bez r0 &loop3
end3:	lli r2 0x74
	lui r2 0xbE
loop4:	bez r2 &end4
	shf r2 r2 -4
	out r2
	bez r0 &loop4
end4:	lli r1 0x53
	lui r1 0x71
	lli r2 0x9b
	lui r2 0xe5
	or  r4 r1 r2
	and r5 r1 r2
	not r6 r1
	out r4
	out r5
	out r6
	.halt

# maxArray.ac
# Example of using function calls in ANNA

# CODE SECTION

#---function: main

lli  r7 &stack		# initialize stack pointer
lui  r7 &stack

# put parameters into registers
lli  r1 &array		
lui  r1 &array		# 1st argument - address of array
lli  r2 &size
lui  r2 &size
lw   r2 r2 0		# 2nd argument - value of size

# call to maxArray
addi r7 r7 4		# update stack pointer (caller record is 4 words)
sw   r1 r7 1		# store 1st argument
sw   r2 r7 2		# store 2nd argument
lli  r5 &maxArray
lui  r5 &maxArray
jalr r5 r6		# call maxArray

# return from call to maxArray
lw   r2 r7 5		# get return value
addi r7 r7 -4		# pop activation record
out  r2
.halt

#---function: maxArray

maxArray: sw r6 r7 0	# save return address

lw   r1 r7 1			 
lw   r3 r1 0
sw   r3 r7 3		# maxVal = array[0]

lli  r1 1
sw   r1 r7 4		# j = 1

forStart: lw r2 r7 2	
lw   r4 r7 4		
sub  r5 r4 r2		# compare j >= size
bez  r5 &forEnd		# jump to forEnd
bgz  r5 &forEnd		# if j >= size

# store parameters in a register
lw   r1 r7 1
lw   r4 r7 4
add  r2 r1 r4
lw   r2 r2 0		# r2 = array[j]
lw   r3 r7 3		# r3 = maxVal
 
# call to max
addi r7 r7 6		# update stack pointer upward
sw   r2 r7 1		# store parameter 0
sw   r3 r7 2 		# store parameter 1
lli  r5 &max
lui  r5 &max
jalr r5 r6		# call max

# return from max
lw   r3 r7 3 		# get return value
addi r7 r7 -6		# update stack pointer downward
sw   r3 r7 3		# maxVal = return value from max

lw   r4 r7 4		# j = j + 1
addi r4 r4 1
sw   r4 r7 4
bez  r0 &forStart	# jump to start of loop

forEnd: lw r2 r7 3	
sw   r2 r7 5		# store return value
lw   r6 r7 0		# get return address
jalr r6 r0		# return

#--- function: max

max: sw r6 r7	0	# save return address
lw   r4 r7 1		# r4 = x
lw   r5 r7 2		# r5 = y

# if (x > y) r2 = x else r2 = y
sub  r3 r4 r5 		
bgz  r3 &returnX		
add  r2 r5 r0
bez  r0 &endIf
returnX: add r2 r4 r0

endIf: sw r2 r7 3
lw   r6 r7 0
jalr r6 r0

# DATA SECTION

array: .fill 35
.fill 287
.fill -485
.fill 3
.fill 574
.fill 109
.fill 76

size: .fill 7

# STACK SECTION

stack: .fill 0

# memory.ac
lli r2 20

lli r1 0xff
lui r1 0x7f
sw r2 r1 0
lw r3 r1 0
out r3

addi r2 r2 5
lli r1 0x00
lui r1 0x80
sw r2 r1 0
lw r3 r1 0
out r3
 
addi r2 r2 5
lli r1 0x88
lui r1 0xff
sw r2 r1 0
lw r3 r1 0
out r3

addi r2 r2 5
lli r1 0x67
lui r1 0xab
sw r2 r1 0
lw r3 r1 0
out r3

addi r2 r2 5
lli r1 0x95
lui r1 0x80
sw r2 r1 0
lw r3 r1 0
out r3

.halt

# Program: sum.ac
# Author: Eric Larson
# Description: Computes sum of first n positive integers recursively

# Global register usage:
# r7 - stack pointer (global across functions)
# All registers are caller-save. 
# Parameters and return values are passed using registers.

# code section	

# main: Asks the user for an input n (making it is less than or
# equal to the limit).  Calls sum(n) and displays result.

# Register usage:
# r1 - n, value user entered
# r2 - stores return value of sum
# r3 - stores value of limit
# r4 - holds temporary values
# r6 - return address
# r7 - stack pointer (global variable)

# main does not need to save any registers when calling sum

	# initialize stack pointer
	lli  r7 &stack	
	lui  r7 &stack

	# get the limit (r3)
	lli  r4 &limit
	lui  r4 &limit
	lw   r3 r4 0

	# get the user input, loop until it is less than or equal
	# to the limit and greater than zero
loop:	in  r1
	bgz r1 &ok
	bez r1 &ok
	bez r0 &loop
ok:	sub r4 r1 r3
	bgz r4 &loop
	
	# call sum(n)
	lli  r4 &sum
      lui  r4 &sum
	jalr r4 r6

	# display final answer (returned in r2)
	out  r2	

	# exit
	.halt	

# function sum: Adds the first n positive integers recursively.
# The stopping case is when n = 0.
#
# Input parameters:
# r1 - n
# r6 - return address
# 
# Return value:
# r2 - sum of first n integers

# Register usage:
# r3 - temporary values
# r7 - stack pointer (global)

	# check for n == 0
sum:	bez  r1 &stop  

	# store return address and n on stack, update stack pointer
	sw   r1 r7 0
	sw   r3 r7 1
	sw   r6 r7 2
	addi r7 r7 3

	# call sum(n-1)
	lli  r3 &sum
	lui  r3 &sum
      addi r1 r1 -1
      jalr r3 r6

	# update stack pointer, restore return address and n from stack
        addi r7 r7 -3
	lw   r1 r7 0
	lw   r3 r7 1
	lw   r6 r7 2
	
	# compute sum = sum(n-1) + n
	add  r2 r2 r1

	# return
	jalr r6 r0

	# stopping case - return 0
stop:	add  r2 r0 r0
	jalr r6 r0

# data section

limit:	.fill 100		# maximum input value

# stack section

stack:	.fill  0