!Emulator written by Deian Stefan
!LGP30 code written by Mohammed Billoo
	.begin  
BASE    .equ 0x3fffc0           !Starting point of the memory mapped region
COUT    .equ 0x0                !0xffff0000 Console Data Port
COSTAT  .equ 0x4                !0xffff0004 Console Status Port.
CIN     .equ 0x8                !0xffff0008 Keyboard Data Port
CICTL   .equ 0xc                !0xffff000c Keyboard Control Port

LGP_INSTRUCTIONS .equ 3500
LGP_START .equ 3600

	
	.org 2048

PROCESS_INSTRUCTION:
	!----------------------------------------------------------------------------------------
	sll %r30,2,%r1						!%r30 is PC
	ld LGP_START+%r1,%r31	 			!%r31 is IR
	srl %r31,26,%r15					
	and %r15,0xFC,%r15					!make sure that bit 12,13 are 0
	add %r15, LGP_INSTRUCTIONS-4,%r15	!SWI-like implementation parsing
	jmpl %r15+4,%r0

	B:	
		and %r31,0x7FF,%r1				!%r1=11bit MM addr
		sll %r1,2,%r1					!conver LGP to ARC "MM mode"
		add %r1,LGP_START, %r1			!add offset
		ld %r1,%r29						!ACC = %r29 = MM[addr]
		ba END_PROCESS_INSTRUCTION
	Y:
		and %r31,0x7FF,%r1				!%r1=11bit MM addr
		sll %r1,2,%r1					!conver LGP to ARC "MM mode"
		add %r1,LGP_START, %r1			!add offset
		ld %r1,%r2						!%r2 = MM[addr]
		andn %r2,0x7FF,%r2				!clear bits 0-11 of %r2=MM[addr]
		and %r29,0x7FF,%r3				!clear all but 0-11 of ACC
		or %r2,%r3,%r2						
		st %r2,%r1						!MM[addr](11 downto 0) = ACC(11 downto 0)
		ba END_PROCESS_INSTRUCTION
	R:
		and %r31,0x7FF,%r1				!%r1=11bit MM addr
		sll %r1,2,%r1					!conver LGP to ARC "MM mode"
		add %r1,LGP_START, %r1			!add offset
		add %r30,1,%r2					!%r2 = PC+1
		subcc %r2, 0xFFF, %r0			!security: PC is 12bits, but PC+1 can be > 12
		bpos END_EMULATOR				!not a good idea to start writing from 0
		st %r2,%r1						!MM[addr]=PC+1 (11 downto 0)
		ba END_PROCESS_INSTRUCTION
	I:									!ACC = input ASCII char
		sethi BASE, %r4
	I_WAIT:		ldub [%r4 + CICTL], %r1	!loop until a character
                andcc %r1, 0x80, %r1	!is received
                be I_WAIT
                ldub [%r4 + CIN], %r29	!ACC = input ASCII char
		ba END_PROCESS_INSTRUCTION
	D:										!signed restoring integer division
		and %r31,0x7FF,%r1				!%r1=11bit MM addr
		sll %r1,2,%r1					!conver LGP to ARC "MM mode"
		add %r1,LGP_START, %r1			!add offset
		ld %r1,%r3						!%r3 = MM[addr] = M
		and  %r5,%r0,%r5

		orcc %r3,%r0,%r0
		be D_ARG_INVALID
		bpos D_ARG_OK_1
		sub %r0,%r3,%r3					!2's complement if negative
		or  %r0,0x1,%r5
		D_ARG_OK_1:
			orcc %r29,%r0,%r0
			be D_ARG_ZERO
			bpos D_ARGS_OK
			sub %r0,%r29,%r29
			xor %r5,0x1,%r5
		D_ARGS_OK:	and %r0,%r0,%r1		!%r1	 = A, %r29 = Q
					or %r0,31,%r4		!%r4 = num of bits
					ba D_LOOP
		D_ARG_INVALID:
		or %r0,0xBAD,%r29
		ba END_EMULATOR
		D_ARG_ZERO:
		or %r0,0x0,%r29
		ba END_PROCESS_INSTRUCTION
	D_LOOP:	
		orcc %r1,%r0,%r1
		bpos D_A_SIGN_0
		sll %r1,1,%r1					!1<<A
		orcc %r29,%r0,%r29
		bpos D_QrolA_0
		or %r1,0x1,%r1					!if Q[31]==1 "roll" it over
		D_QrolA_0: sll %r29,1,%r29		!1<<Q
		addcc %r1,%r3,%r1				!A=A+M
		bpos D_Q0_1
		ba	 D_Q0_0

		D_A_SIGN_0:
			sll %r1,1,%r1					!1<<A
			orcc %r29,%r0,%r29
			bpos D_QrolA_0_1
			or %r1,0x1,%r1					!if Q[31]==1 "roll" it over
			D_QrolA_0_1: sll %r29,1,%r29	!1<<Q
			subcc %r1,%r3,%r1				!A=A-M
			bpos D_Q0_1
			ba	 D_Q0_0
		D_Q0_1:
			or %r29,0x1,%r29		!Q[0]=1
			subcc %r4,1,%r4
			bpos D_LOOP
			ba D_END
		D_Q0_0:
			andn %r2,0x1,%r2			!Q[0]=0
			subcc %r4,1,%r4
			bpos D_LOOP
			ba D_END
		D_END:
			andcc %r5,0x1,%r5
			be END_PROCESS_INSTRUCTION
			sub %r0,%r29,%r29
			ba END_PROCESS_INSTRUCTION
		
	N:
		and %r31,0x7FF,%r1				!%r1=11bit MM addr
		sll %r1,2,%r1					!conver LGP to ARC "MM mode"
		add %r1,LGP_START, %r1			!add offset
		ld %r1,%r1						!%r1 = MM[addr]
		and  %r0,%r0,%r16

		orcc %r1,%r0,%r0
		be N_ARG_ZERO
		bpos N_ARG_OK_1
		sub %r0,%r1,%r1					!2's complement if negative
		or  %r0,0x1,%r16
		N_ARG_OK_1:
			orcc %r29,%r0,%r0
			be N_ARG_ZERO
			bpos N_EXISTING
			sub %r0,%r29,%r29
			xor %r16,0x1,%r16
			ba N_EXISTING
			
		N_ARG_ZERO:
		or %r0,0x0,%r29
		ba END_PROCESS_INSTRUCTION
		!since we are multiplying serially, after multiplying
		!the two integers being multiplied are stored in %r26 and %r27
		!so if the instruction M or N follow with the same two 
		!integers the LSB, or MSB (depending on the instruction) 
		!are returned from %r25(LSB) for instruction N or %r28(MSB) for M
		N_EXISTING: xorcc %r1, %r26, %r0
					be N_EXISTING_2
					ba N_EXISTING_REV
		N_EXISTING_2: xorcc %r29, %r27, %r0
					be N_MULT_1
					ba N_MULT
		N_EXISTING_REV: xorcc %r1, %r26, %r0
					be N_EXISTING_REV_2
					ba N_MULT
		N_EXISTING_REV_2: xorcc %r29, %r27, %r0
					be N_MULT_1
					ba N_MULT				

		N_MULT_1:
					or %r0,%r25,%r29	!was multiplied before, return 32 LSB 
					andcc %r16,0x1,%r16
					be END_PROCESS_INSTRUCTION
					sub %r0,%r29,%r29
					ba END_PROCESS_INSTRUCTION

		N_MULT:
		or %r1,%r0,%r27	 !M
		or %r29,%r0,%r26 !Q	save in 26 for later
		or %r0,%r0,%r28	 !A clear MSB

		sethi 0x100000, %r5
		sll %r5,1,%r5			!32nd bit = 1
	
		or %r0,31,%r7	!counter
	
		N_LOOP:
		and %r0,%r0,%r6
		andcc %r29,0x1,%r0
		be N_SHIFT
		addcc %r28,%r27,%r28
		bcc N_SHIFT
		or %r0,0x1,%r6
		N_SHIFT:
			srl %r29,1,%r29
			andcc %r28,0x1,%r0		
			be N_SHIFT_CONTINUE
			or %r29,%r5,%r29	
			N_SHIFT_CONTINUE: 
					srl %r28,1,%r28	
					andcc %r6,0x1,%r0		
					be N_END_LOOP
					or %r28,%r5,%r28
		N_END_LOOP:
		subcc %r7,1,%r7
		bpos N_LOOP
		or %r29,%r0,%r25		!save for later

		andcc %r16,0x1,%r16
		be END_PROCESS_INSTRUCTION
		sub %r0,%r29,%r29
		ba END_PROCESS_INSTRUCTION
	M:
		and %r31,0x7FF,%r1				!%r1=11bit MM addr
		sll %r1,2,%r1					!conver LGP to ARC "MM mode"
		add %r1,LGP_START, %r1			!add offset
		ld %r1,%r1						!%r1 = MM[addr]
		and  %r0,%r0,%r16

		orcc %r1,%r0,%r0
		be M_ARG_ZERO
		bpos M_ARG_OK_1
		sub %r0,%r1,%r1					!2's complement if negative
		or  %r0,0x1,%r16
		M_ARG_OK_1:
			orcc %r29,%r0,%r0
			be M_ARG_ZERO
			bpos M_EXISTING
			sub %r0,%r29,%r29
			xor %r16,0x1,%r16
			ba M_EXISTING

		M_ARG_ZERO:
		or %r0,0x0,%r29
		ba END_PROCESS_INSTRUCTION
		!since we are multiplying serially, after multiplying
		!the two integers being multiplied are stored in %r26 and %r27
		!so if the instruction M or N follow with the same two 
		!integers the LSB, or MSB (depending on the instruction) 
		!are returned from %r25(LSB) for instruction N or %r28(MSB) for M
		M_EXISTING: xorcc %r1, %r26, %r0
					be M_EXISTING_2
					ba M_EXISTING_REV
		M_EXISTING_2: xorcc %r29, %r27, %r0
					be M_MULT_1
					ba M_MULT
		M_EXISTING_REV: xorcc %r1, %r26, %r0
					be M_EXISTING_REV_2
					ba M_MULT
		M_EXISTING_REV_2: xorcc %r29, %r27, %r0
					be M_MULT_1
					ba M_MULT				

		M_MULT_1:
					or %r0,%r28,%r29	!was multiplied before, return 32 MSB
					andcc %r16,0x1,%r16
					be END_PROCESS_INSTRUCTION
					add %r29,1,%r29
					sub %r0,%r29,%r29
					ba END_PROCESS_INSTRUCTION

		M_MULT:
		or %r1,%r0,%r27	 !M
		or %r29,%r0,%r26 !Q	save in 26 for later
		or %r0,%r0,%r28	 !A clear MSB

		sethi 0x100000, %r5
		sll %r5,1,%r5			!32nd bit = 1
	
		or %r0,31,%r7	!counter
	
		M_LOOP:
		and %r0,%r0,%r6
		andcc %r29,0x1,%r0
		be M_SHIFT
		addcc %r28,%r27,%r28
		bcc M_SHIFT
		or %r0,0x1,%r6
		M_SHIFT:
			srl %r29,1,%r29
			andcc %r28,0x1,%r0		
			be M_SHIFT_CONTINUE
			or %r29,%r5,%r29	
			M_SHIFT_CONTINUE: 
					srl %r28,1,%r28	
					andcc %r6,0x1,%r0		
					be M_END_LOOP
					or %r28,%r5,%r28
		M_END_LOOP:
		subcc %r7,1,%r7
		bpos M_LOOP
		or %r29,%r0,%r25		!save for later

		or %r28,%r0,%r29
		andcc %r16,0x1,%r16
		be END_PROCESS_INSTRUCTION
		add %r29,1,%r29
		sub %r0,%r29,%r29
		ba END_PROCESS_INSTRUCTION
	P:									!prints the MM[addr] ASCII char.
		and %r31,0x7FF,%r1				!%r1=11bit MM addr
		sll %r1,2,%r1					!conver LGP to ARC "MM mode"
		add %r1,LGP_START, %r1			!add offset
		ld %r1,%r1		
		addcc %r1,%r0,%r1
		be END_PROCESS_INSTRUCTION
		sethi BASE, %r4
	P_WAIT: 	ldub [%r4+COSTAT], %r3	
        		andcc %r3, 0x80, %r3	!check STATUS of device
        	    be P_WAIT 
        stb %r1, [%r4+COUT]     		!device is ready, PRINT
		ba END_PROCESS_INSTRUCTION

	E:
		and %r31,0x7FF,%r1				!%r1=11bit MM addr
		sll %r1,2,%r1					!conver LGP to ARC "MM mode"
		add %r1,LGP_START, %r1			!add offset
		ld %r1,%r1						
		and %r29,%r1,%r29				!ACC=ACC&MM[addr]
		ba END_PROCESS_INSTRUCTION
	U:
		and %r31,0x7FF,%r30				!%r30=PC=addr
		ba PROCESS_INSTRUCTION
	T:
		orcc %r29,0x0,%r0
		bneg T_NEGATIVE
		ba END_PROCESS_INSTRUCTION
	T_NEGATIVE: 	and %r31,0x7FF,%r30	!%r30=PC=addr
					ba PROCESS_INSTRUCTION
	H:
		and %r31,0x7FF,%r1				!%r1=11bit MM addr
		sll %r1,2,%r1					!conver LGP to ARC "MM mode"
		add %r1,LGP_START, %r1			!add offset
		st %r29,%r1						!MM[addr]=ACC
		ba END_PROCESS_INSTRUCTION
	C:
		and %r31,0x7FF,%r1				!%r1=11bit MM addr
		sll %r1,2,%r1					!conver LGP to ARC "MM mode"
		add %r1,LGP_START, %r1			!add offset
		st %r29,%r1						!MM[addr]=ACC
		and %r29,0x0,%r29				!ACC=0x0
		ba END_PROCESS_INSTRUCTION
	A:	
		and %r31,0x7FF,%r1				!%r1=11bit MM addr
		sll %r1,2,%r1					!conver LGP to ARC "MM mode"
		add %r1,LGP_START, %r1			!add offset
		ld %r1,%r1						
		add %r29,%r1,%r29				!ACC=ACC+MM[addr]
		ba END_PROCESS_INSTRUCTION
	S:
		and %r31,0x7FF,%r1				!%r1=11bit MM addr
		sll %r1,2,%r1					!conver LGP to ARC "MM mode"
		add %r1,LGP_START, %r1			!add offset
		ld %r1,%r1						
		subcc %r29,%r1,%r29				!ACC=ACC-MM[addr]
		ba END_PROCESS_INSTRUCTION

END_PROCESS_INSTRUCTION:
		add %r30,1,%r30
		ba PROCESS_INSTRUCTION
	!----------------------------------------------------------------------------------------
END_EMULATOR: halt

	.org LGP_INSTRUCTIONS				!branch to proper label
	ba END_EMULATOR
	ba B
	ba Y
	ba R
	ba I
	ba D
	ba N
	ba M
	ba P
	ba E
	ba U
	ba T
	ba H
	ba C
	ba A
	ba S
	.org LGP_START						!start of the LGP program
0x10000047	! B 71
0xf000004f	! S 79	; check if end of list
0xb0000004	! T 4		; if not, check and swap if needed
0xa000001e	! U 30	; if so, decrement and start again
0x10000052	! B 82
0xf0000053	! S 83	; check for swap
0xb000000d	! T 13	; if not then increment
0x10000052	! B 82	; swap
0xc000004a	! H 74	; swap
0x10000053	! B 83	; swap
0xc0000052	! H 82	; swap 
0x1000004a	! B 74	; swap
0xc0000053	! H 83	; swap
0x10000047	! B 71	; increment index
0xe000004c	! A 76	; increment index
0x20000004	! Y 4
0x20000007	! Y 7
0x2000000a	! Y 10
0xc0000047	! H 71	; increment index
0xe000004c	! A 76	; increment again
0x20000005	! Y 5
0x20000009	! Y 9
0x2000000c	! Y 12
0xa0000000	! U 0
0x00000000
0x00000000
0x00000000
0x00000000
0x00000000
0x00000000
0x1000004f	! B 79
0xf000004c	! S 76	; subtract by 1 to get neg. #
0xf000004e	! S 78	; check if at top of list
0xb0000028	! T 40	; if so, then done
0x1000004f	! B 79	; if not, decrement and start over 
0xf000004c	! S 76	; decrement list 
0xc000004f	! H 79	; store new location of end of list
0x1000004e	! B 78	; reset start of list
0xc0000047	! H 71	; reset start of list
0xa000000f	! U 15	; reset code
0x00000000	! Z		; done 
0x00000000
0x00000000
0x00000000
0x00000000
0x00000000
0x00000000
0x00000000
0x00000000
0x00000000
0x00000000
0x00000000
0x00000000
0x00000000
0x00000000
0x00000000
0x00000000
0x00000000
0x00000000
0x00000000
0x00000000
0x00000000
0x00000000
0x00000000
0x00000000
0x00000000
0x00000000
0x00000000
0x00000000
0x00000000
0x00000000
0x00000052	! temp vars
0x00000001
0x00000061
0x00000000
0x00000000
0x00000001
0x00000000
0x00000052
0x00000061
0x00000000
0x00000000
0x000002bf	! Start of list 
0x000002fd
0x000002a5
0x00000264
0x000001fd
0x0000009a
0x000001aa
0x0000028d
0x00000113
0x00000381
0x000000aa
0x0000038c
0x0000003d
0x00000200
0x00000057
0x000001f7
	.end