binutils-gdb/sim/testsuite/ft32/basic.s

# check that basic insns work.
# mach: ft32

.include "testutils.inc"

	start

	ldk	  $r0,__PMSIZE
	EXPECT    $r0,0x00040000
	ldk       $r0,__RAMSIZE
	EXPECT    $r0,0x00010000

	ldk     $r4,10
	add     $r4,$r4,23
	EXPECT  $r4,33

# lda, sta
	.data
tmp:    .long     0
	.text

	xor.l     $r0,$r0,$r0
	EXPECT    $r0,0x00000000
	xor.l     $r0,$r0,$r0
	add.l     $r0,$r0,1
	EXPECT    $r0,0x00000001

	ldk.l     $r0,0x4567
	EXPECT    $r0,0x00004567

	lpm.l     $r0,k_12345678
	EXPECT    $r0,0x12345678

	sta.l     tmp,$r0
	lda.l     $r1,tmp
	EXPECT    $r1,0x12345678

	lda.b     $r1,tmp
	EXPECT    $r1,0x00000078

	lda.b     $r1,tmp+1
	EXPECT    $r1,0x00000056

	lda.b     $r1,tmp+2
	EXPECT    $r1,0x00000034

	lda.b     $r1,tmp+3
	EXPECT    $r1,0x00000012

	sta.b     tmp+1,$r0
	lda.l     $r1,tmp+0
	EXPECT    $r1,0x12347878

# immediate
	ldk.l     $r1,12
	add.l     $r1,$r1,4
	EXPECT    $r1,0x00000010
	add.l     $r1,$r1,0x1ff
	EXPECT    $r1,0x0000020f
	add.l     $r1,$r1,-0x200
	EXPECT    $r1,0x0000000f

# addk
	xor.l     $r1,$r0,$r0
	add.l     $r2,$r1,127
	EXPECT    $r2,0x0000007f

	add.l     $r2,$r2,127
	EXPECT    $r2,0x000000fe

	add.l     $r2,$r2,-127
	EXPECT    $r2,0x0000007f

	add.l     $r2,$r2,-128
	EXPECT    $r2,0xffffffff

	add.l     $r2,$r2,1
	EXPECT    $r2,0x00000000

# mul
	ldk.l     $r1,100
	ldk.l     $r2,77
	mul.l     $r3,$r1,$r2
	EXPECT    $r3,0x00001e14

	# 0x12345678 ** 2 = 0x14b66dc1df4d840L
	mul.l     $r3,$r0,$r0
	EXPECT    $r3,0x1df4d840
	muluh.l   $r3,$r0,$r0
	EXPECT    $r3,0x014b66dc

# push and pop
	push.l    $r0
	EXPECT    $sp,0x0000fffc
	ldi.l     $r3,$sp,0
	EXPECT    $r3,0x12345678

	pop.l     $r4
	EXPECT    $sp,0x00000000
	EXPECT    $r4,0x12345678

	ldk.l     $r1,0x1111
	push.l    $r1
	ldk.l     $r1,0x2222
	push.l    $r1
	ldk.l     $r1,0x3333
	push.l    $r1
	ldk.l     $r1,0x4444
	push.l    $r1
	EXPECT    $sp,0x0000fff0
	pop.l     $r1
	EXPECT    $r1,0x00004444
	pop.l     $r1
	EXPECT    $r1,0x00003333
	pop.l     $r1
	EXPECT    $r1,0x00002222
	pop.l     $r1
	EXPECT    $r1,0x00001111

# push and pop with $sp changes
	ldk.l     $r1,0xa111
	push.l    $r1
	sub.l     $sp,$sp,4
	ldk.l     $r1,0xa222
	push.l    $r1
	add.l     $sp,$sp,-36
	add.l     $sp,$sp,36
	pop.l     $r1
	EXPECT    $r1,0x0000a222
	add.l     $sp,$sp,4
	pop.l     $r1
	EXPECT    $r1,0x0000a111

# sti
	ldk.l     $r2,80
	EXPECT    $r2,0x00000050
	sti.l     $r2,0,$r0
	lda.l     $r1,80
	EXPECT    $r1,0x12345678

	ldk.l     $r3,0xF0
	sti.b     $r2,0,$r3
	lda.l     $r1,80
	EXPECT    $r1,0x123456f0

	add.l     $r2,$r2,1
	sti.l     $r2,0,$r0
	sti.b     $r2,0,$r3
	lda.l     $r1,80
	EXPECT    $r1,0x1234f078

	add.l     $r2,$r2,1
	sti.l     $r2,0,$r0
	sti.b     $r2,0,$r3
	lda.l     $r1,80
	EXPECT    $r1,0x12f05678

	add.l     $r2,$r2,1
	sti.l     $r2,0,$r0
	sti.b     $r2,0,$r3
	lda.l     $r1,80
	EXPECT    $r1,0xf0345678

	ldk.l     $r2,80
	sti.l     $r2,0,$r0
	ldk.s     $r3,0xbeef
	sti.s     $r2,0,$r3
	lda.l     $r1,80
	EXPECT    $r1,0x1234beef
	add.l     $r2,$r2,2
	sti.s     $r2,0,$r3
	lda.l     $r1,80
	EXPECT    $r1,0xbeefbeef

# lpmi

	ldk.l     $r1,k_12345678
	lpmi.l    $r2,$r1,0
	EXPECT    $r2,0x12345678

	lpmi.b    $r2,$r1,0
	EXPECT    $r2,0x00000078

	add.l     $r1,$r1,1
	lpmi.b    $r2,$r1,0
	EXPECT    $r2,0x00000056

	add.l     $r1,$r1,1
	lpmi.b    $r2,$r1,0
	EXPECT    $r2,0x00000034

	add.l     $r1,$r1,1
	lpmi.b    $r2,$r1,0
	EXPECT    $r2,0x00000012

	lpmi.l    $r2,$r1,4
	EXPECT    $r2,0xabcdef01

	lpmi.l    $r2,$r1,-4
	EXPECT    $r2,0x10111213

	lpmi.b    $r2,$r1,-4
	EXPECT    $r2,0x00000010

	ldk.l     $r1,k_12345678
	lpmi.s    $r2,$r1,0
	EXPECT    $r2,0x00005678
	lpmi.s    $r2,$r1,2
	EXPECT    $r2,0x00001234
	lpmi.b    $r2,$r1,6
	EXPECT    $r2,0x000000cd
	lpmi.b    $r2,$r1,7
	EXPECT    $r2,0x000000ab
	lpmi.b    $r2,$r1,-1
	EXPECT    $r2,0x00000010
	lpmi.s    $r2,$r1,-2
	EXPECT    $r2,0x00001011

	ldk.l     $r1,k_12345678-127
	lpmi.b    $r2,$r1,127
	EXPECT    $r2,0x00000078

	ldk.l     $r1,k_12345678+128
	lpmi.b    $r2,$r1,-128
	EXPECT    $r2,0x00000078

# shifts

	lpm.l     $r0,k_12345678
	ldk.l     $r2,4
	ashl.l    $r1,$r0,$r2
	EXPECT    $r1,0x23456780
	lshr.l    $r1,$r0,$r2
	EXPECT    $r1,0x01234567
	ashr.l    $r1,$r0,$r2
	EXPECT    $r1,0x01234567

	lpm.l     $r0,k_abcdef01
	ashl.l    $r1,$r0,$r2
	EXPECT    $r1,0xbcdef010
	lshr.l    $r1,$r0,$r2
	EXPECT    $r1,0x0abcdef0
	ashr.l    $r1,$r0,$r2
	EXPECT    $r1,0xfabcdef0

# rotate right

	lpm.l     $r0,k_12345678
	ror.l     $r1,$r0,0
	EXPECT    $r1,0x12345678
	ror.l     $r1,$r0,12
	EXPECT    $r1,0x67812345
	ror.l     $r1,$r0,-4
	EXPECT    $r1,0x23456781

# jmpx
	ldk       $r28,0xaaaaa
	jmpx      0,$r28,1,failcase
	jmpx      1,$r28,0,failcase
	jmpx      2,$r28,1,failcase
	jmpx      3,$r28,0,failcase
	jmpx      4,$r28,1,failcase
	jmpx      5,$r28,0,failcase
	jmpx      6,$r28,1,failcase
	jmpx      7,$r28,0,failcase
	jmpx      8,$r28,1,failcase
	jmpx      9,$r28,0,failcase
	jmpx      10,$r28,1,failcase
	jmpx      11,$r28,0,failcase
	jmpx      12,$r28,1,failcase
	jmpx      13,$r28,0,failcase
	jmpx      14,$r28,1,failcase
	jmpx      15,$r28,0,failcase
	jmpx      16,$r28,1,failcase
	jmpx      17,$r28,0,failcase
	jmpx      18,$r28,1,failcase
	jmpx      19,$r28,0,failcase

	move      $r29,$r28
	ldk       $r28,0
	jmpx      0,$r29,1,failcase
	jmpx      1,$r29,0,failcase
	jmpx      2,$r29,1,failcase
	jmpx      3,$r29,0,failcase
	jmpx      4,$r29,1,failcase
	jmpx      5,$r29,0,failcase
	jmpx      6,$r29,1,failcase
	jmpx      7,$r29,0,failcase
	jmpx      8,$r29,1,failcase
	jmpx      9,$r29,0,failcase
	jmpx      10,$r29,1,failcase
	jmpx      11,$r29,0,failcase
	jmpx      12,$r29,1,failcase
	jmpx      13,$r29,0,failcase
	jmpx      14,$r29,1,failcase
	jmpx      15,$r29,0,failcase
	jmpx      16,$r29,1,failcase
	jmpx      17,$r29,0,failcase
	jmpx      18,$r29,1,failcase
	jmpx      19,$r29,0,failcase

	move      $r30,$r29
	ldk       $r29,0
	jmpx      0,$r30,1,failcase
	jmpx      1,$r30,0,failcase
	jmpx      2,$r30,1,failcase
	jmpx      3,$r30,0,failcase
	jmpx      4,$r30,1,failcase
	jmpx      5,$r30,0,failcase
	jmpx      6,$r30,1,failcase
	jmpx      7,$r30,0,failcase
	jmpx      8,$r30,1,failcase
	jmpx      9,$r30,0,failcase
	jmpx      10,$r30,1,failcase
	jmpx      11,$r30,0,failcase
	jmpx      12,$r30,1,failcase
	jmpx      13,$r30,0,failcase
	jmpx      14,$r30,1,failcase
	jmpx      15,$r30,0,failcase
	jmpx      16,$r30,1,failcase
	jmpx      17,$r30,0,failcase
	jmpx      18,$r30,1,failcase
	jmpx      19,$r30,0,failcase

# callx
	ldk       $r30,0xaaaaa
	callx     0,$r30,0,skip1
	jmp       failcase
	callx     1,$r30,1,skip1
	jmp       failcase
	callx     2,$r30,0,skip1
	jmp       failcase
	callx     3,$r30,1,skip1
	jmp       failcase

	callx     0,$r30,1,skip1
	ldk       $r30,0x123
	EXPECT    $r30,0x123

#define BIT(N,M)  ((((N) & 15) << 5) | (M))
# bextu
	bextu.l   $r1,$r0,(0<<5)|0
	EXPECT    $r1,0x00005678
	bextu.l   $r1,$r0,(4<<5)|0
	EXPECT    $r1,0x00000008
	bextu.l   $r1,$r0,(4<<5)|4
	EXPECT    $r1,0x00000007
	bextu.l   $r1,$r0,(4<<5)|28
	EXPECT    $r1,0x00000001
	bextu.l   $r1,$r0,(8<<5)|16
	EXPECT    $r1,0x00000034
	ldk.l     $r2,-1
	bextu.l   $r1,$r2,(6<<5)|(3)
	EXPECT    $r1,0x0000003f

# bexts
	bexts.l   $r1,$r0,(8<<5)|0
	EXPECT    $r1,0x00000078
	bexts.l   $r1,$r0,(0<<5)|16
	EXPECT    $r1,0x00001234
	bexts.l   $r1,$r0,(4<<5)|0
	EXPECT    $r1,0xfffffff8
	# extract the '5' digit in widths 4-1
	bexts.l   $r1,$r0,(4<<5)|12
	EXPECT    $r1,0x00000005
	bexts.l   $r1,$r0,(3<<5)|12
	EXPECT    $r1,0xfffffffd
	bexts.l   $r1,$r0,(2<<5)|12
	EXPECT    $r1,0x00000001
	bexts.l   $r1,$r0,(1<<5)|12
	EXPECT    $r1,0xffffffff

# btst
	# low four bits should be 0,0,0,1
	btst.l    $r0,(1<<5)|0
	jmpc      nz,failcase
	btst.l    $r0,(1<<5)|1
	jmpc      nz,failcase
	btst.l    $r0,(1<<5)|2
	jmpc      nz,failcase
	btst.l    $r0,(1<<5)|3
	jmpc      z,failcase

	# the 6 bit field starting at position 24 is positive
	btst.l    $r0,(6<<5)|24
	jmpc      s,failcase
	# the 5 bit field starting at position 24 is negative
	btst.l    $r0,(5<<5)|24
	jmpc      ns,failcase

	EXPECT    $r0,0x12345678

# bins
	bins.l    $r1,$r0,(8 << 5) | (0)
	EXPECT    $r1,0x12345600

	bins.l    $r1,$r0,(0 << 5) | (8)
	EXPECT    $r1,0x12000078

	ldk.l     $r1,(0xff << 10) | (8 << 5) | (8)
	bins.l    $r1,$r0,$r1
	EXPECT    $r1,0x1234ff78

	call      litr1
	.long     (0x8dd1 << 10) | (0 << 5) | (0)
	bins.l    $r1,$r0,$r1
	EXPECT    $r1,0x12348dd1

	call      litr1
	.long     (0x8dd1 << 10) | (0 << 5) | (16)
	bins.l    $r1,$r0,$r1
	EXPECT    $r1,0x8dd15678

	ldk.l     $r1,(0xde << 10) | (8 << 5) | (0)
	bins.l    $r1,$r0,$r1
	EXPECT    $r1,0x123456de

# ldl
	ldk.l     $r0,0
	ldl.l     $r3,$r0,0
	EXPECT    $r3,0x00000000
	ldk.l     $r0,-1
	ldl.l     $r3,$r0,-1
	EXPECT    $r3,0xffffffff
	ldk.l     $r0,(0x12345678 >> 10)
	ldl.l     $r3,$r0,(0x12345678 & 0x3ff)
	EXPECT    $r3,0x12345678
	ldk.l     $r0,(0xe2345678 >> 10)
	ldl.l     $r3,$r0,(0xe2345678 & 0x3ff)
	EXPECT    $r3,0xe2345678

# flip
	ldk.l     $r0,0x0000001
	flip.l    $r1,$r0,0
	EXPECT    $r1,0x00000001

	lpm.l     $r0,k_12345678
	flip.l    $r1,$r0,0
	EXPECT    $r1,0x12345678
	flip.l    $r1,$r0,24
	EXPECT    $r1,0x78563412
	flip.l    $r1,$r0,31
	EXPECT    $r1,0x1e6a2c48

# stack push pop

	EXPECT    $sp,0x00000000
	ldk.l     $r6,0x6666
	push.l    $r6
	or.l      $r0,$r0,$r0      # xxx
	EXPECT    $sp,0x0000fffc
	ldi.l     $r1,$sp,0
	EXPECT    $r1,0x00006666
	pop.l     $r1
	EXPECT    $r1,0x00006666
	EXPECT    $sp,0x00000000

# call/return
	call      fowia
	push.l    $r1
	call      fowia
	pop.l     $r2
	sub.l     $r1,$r1,$r2
	EXPECT    $r1,0x00000008

# add,carry

	ldk.l     $r0,0
	ldk.l     $r1,0
	call      add64
	EXPECT    $r1,0x00000000
	EXPECT    $r0,0x00000000

	lpm.l     $r0,k_abcdef01
	lpm.l     $r1,k_abcdef01
	call      add64
	EXPECT    $r1,0x00000001
	EXPECT    $r0,0x579bde02

	ldk.l     $r0,4
	ldk.l     $r1,-5
	call      add64
	EXPECT    $r1,0x00000000
	EXPECT    $r0,0xffffffff

	ldk.l     $r0,5
	ldk.l     $r1,-5
	call      add64
	EXPECT    $r1,0x00000001
	EXPECT    $r0,0x00000000

	lpm.l     $r0,k_12345678
	ldk.l     $r1,-1
	call      add64
	EXPECT    $r1,0x00000001
	EXPECT    $r0,0x12345677

	ldk.l     $r0,-1
	ldk.l     $r1,-1
	call      add64
	EXPECT    $r1,0x00000001
	EXPECT    $r0,0xfffffffe

# inline literal
	call      lit
	.long     0xdecafbad
	EXPECT    $r0,0xdecafbad

	ldk.l     $r1,0xee
	call      lit
	ldk.l     $r1,0xfe
	EXPECT    $r1,0x000000ee

	call      lit
	.long     0x01020304
	EXPECT    $r0,0x01020304

	call      lit
	.long     lit
	calli     $r0
	.long     0xffaa55aa
	EXPECT    $r0,0xffaa55aa

# comparisons
	ldk.l     $r0,-100
	ldk.l     $r1,100
	cmp.l     $r0,$r1

	ldk.l     $r2,0
	jmpc      lt,.c1
	ldk.l     $r2,1
.c1:
	EXPECT    $r2,0x00000000

	ldk.l     $r2,0
	jmpc      gt,.c2
	ldk.l     $r2,1
.c2:
	EXPECT    $r2,0x00000001

	ldk.l     $r2,0
	jmpc      a,.c3
	ldk.l     $r2,1
.c3:
	EXPECT    $r2,0x00000000

	ldk.l     $r2,0
	jmpc      b,.c4
	ldk.l     $r2,1
.c4:
	EXPECT    $r2,0x00000001

	ldk.l     $r2,0
	jmpc      be,.c5
	ldk.l     $r2,1
.c5:
	EXPECT    $r2,0x00000001

# 8-bit comparisons
	ldk.l     $r0,0x8fe
	ldk.l     $r1,0x708
	cmp.b     $r0,$r1

	ldk.l     $r2,0
	jmpc      lt,.8c1
	ldk.l     $r2,1
.8c1:
	EXPECT    $r2,0x00000000

	ldk.l     $r2,0
	jmpc      gt,.8c2
	ldk.l     $r2,1
.8c2:
	EXPECT    $r2,0x00000001

	ldk.l     $r2,0
	jmpc      a,.8c3
	ldk.l     $r2,1
.8c3:
	EXPECT    $r2,0x00000000

	ldk.l     $r2,0
	jmpc      b,.8c4
	ldk.l     $r2,1
.8c4:
	EXPECT    $r2,0x00000001

	ldk.l     $r2,0
	jmpc      be,.8c5
	ldk.l     $r2,1
.8c5:
	EXPECT    $r2,0x00000001

	ldk.l     $r0,0x8aa
	ldk.l     $r1,0x7aa
	cmp.b     $r0,$r1

	ldk.l     $r2,0
	jmpc      z,.8c6
	ldk.l     $r2,1
.8c6:
	EXPECT    $r2,0x00000000

	ldk.b     $r0,1
	ldk.b     $r2,0xe0
	cmp.b     $r2,0x1c0
	jmpc      a,.8c7
	ldk.b     $r0,0
.8c7:
	EXPECT    $r0,0x00000001

# conditional call
	cmp.l     $r0,$r0
	callc     z,lit
	.long     0xccddeeff
	callc     nz,zr0
	EXPECT    $r0,0xccddeeff

# modify return address
	ldk.l     $r0,0x66
	call      skip1
	ldk.l     $r0,0xAA
	EXPECT    $r0,0x00000066

	ldk.l     $r0,0x77
	call      skip2
	ldk.l     $r0,0xBB
	EXPECT    $r0,0x00000077

# simple recursive function
	ldk.l     $r0,1
	call      factorial
	EXPECT    $r0,0x00000001
	ldk.l     $r0,2
	call      factorial
	EXPECT    $r0,0x00000002
	ldk.l     $r0,3
	call      factorial
	EXPECT    $r0,0x00000006
	ldk.l     $r0,4
	call      factorial
	EXPECT    $r0,0x00000018
	ldk.l     $r0,5
	call      factorial
	EXPECT    $r0,0x00000078
	ldk.l     $r0,6
	call      factorial
	EXPECT    $r0,0x000002d0
	ldk.l     $r0,7
	call      factorial
	EXPECT    $r0,0x000013b0
	ldk.l     $r0,12
	call      factorial
	EXPECT    $r0,0x1c8cfc00

# read sp after a call
	call      nullfunc
	EXPECT    $sp,0x00000000

# CALLI->RETURN
	ldk.l     $r4,nullfunc
	calli     $r4
	EXPECT    $sp,0x00000000

# Link/unlink
	ldk.l     $r14,0x17566

	link      $r14,48
	EXPECT    $r14,0x0000fffc
	sub.l     $sp,$sp,200
	unlink    $r14
	EXPECT    $r14,0x00017566

# LINK->UNLINK
	link      $r14,48
	unlink    $r14
	EXPECT    $r14,0x00017566

# LINK->JUMPI
	ldk.l     $r3,.here
	link      $r14,48
	jmpi      $r3
	jmp       failcase
.here:
	unlink    $r14
	EXPECT    $r14,0x00017566

# LINK->RETURN
# (This is a nonsense combination, but can still exericse it by
# using a negative parameter for the link.  "link $r14,-4" leaves
# $sp exactly unchanged.)
	ldk.l     $r0,.returnhere
	push.l    $r0
	link      $r14,0xfffc
	return
.returnhere:
	EXPECT    $sp,0x00000000

# LPMI->CALLI
	ldk.l     $r0,k_abcdef01
	ldk.l     $r1,increment
	lpmi.l    $r0,$r0,0
	calli     $r1
	EXPECT    $r0,0xabcdef02

# STRLen
	lpm.l     $r4,str3
	sta.l     tmp,$r4
	ldk.l     $r0,tmp
	strlen.b  $r1,$r0
	EXPECT    $r1,0x00000003
	strlen.s  $r1,$r0
	EXPECT    $r1,0x00000003
	strlen.l  $r1,$r0
	EXPECT    $r1,0x00000003

	ldk.l     $r4,0
	sta.b     4,$r4
	strlen.l  $r1,$r0
	EXPECT    $r1,0x00000000

	ldk.l     $r4,-1
	sta.l     4,$r4
	lpm.l     $r4,str3
	sta.l     8,$r4
	strlen.l  $r1,$r0
	EXPECT    $r1,0x00000007

# MEMSet
	ldk.l     $r0,4
	ldk.l     $r1,0xaa
	memset.s  $r0,$r1,8
	ldk.l     $r1,0x55
	memset.b  $r0,$r1,5
	lda.l     $r0,4
	EXPECT    $r0,0x55555555
	lda.l     $r0,8
	EXPECT    $r0,0xaaaaaa55

# first cycle after mispredict
	ldk.l     $r0,3
	cmp.l     $r0,$r0
	jmpc      nz,failcase
	add.l     $r0,$r0,7
	EXPECT    $r0,0x0000000a
	jmpc      nz,failcase
	push.l    $r0
	EXPECT    $sp,0x0000fffc
	pop.l     $r0

# $sp access after stall
	lpm.l     $r13,0
	push.l    $r0
	EXPECT    $sp,0x0000fffc
	pop.l     $r0

	push.l    $r0
	add.l     $sp,$sp,-484
	EXPECT    $sp,0x0000fe18
	EXPECT    $sp,0x0000fe18
	EXPECT    $sp,0x0000fe18
	add.l     $sp,$sp,484
	EXPECT    $sp,0x0000fffc
	pop.l     $r0

# atomic exchange
	lpm.l     $r0,k_12345678
	lpm.l     $r1,k_abcdef01
	sta.l     100,$r1
	exa.l     $r0,100
	EXPECT    $r0,0xabcdef01
	lda.l     $r0,100
	EXPECT    $r0,0x12345678

	lpm.l     $r0,k_12345678
	lpm.l     $r1,k_abcdef01
	sta.l     144,$r1
	ldk.l     $r7,20
	exi.l     $r0,$r7,124
	EXPECT    $r0,0xabcdef01
	lda.l     $r0,144
	EXPECT    $r0,0x12345678

	lpm.l     $r0,k_12345678
	lpm.l     $r1,k_abcdef01
	push      $r1
	exi.l     $r0,$sp,0
	EXPECT    $r0,0xabcdef01
	pop.l     $r0
	EXPECT    $r0,0x12345678

# PM write port
	.equ    PM_UNLOCK,      0x1fc80
	.equ    PM_ADDR,        0x1fc84
	.equ    PM_DATA,        0x1fc88

	lpm.l     $r0,k_12345678
	lpm.l     $r1,k_abcdef01
	EXPECT    $r0,0x12345678
	EXPECT    $r1,0xabcdef01
	ldk.l     $r3,(0x1337f7d1 >> 10)
	ldl.l     $r3,$r3,(0x1337f7d1 & 0x3ff)
	EXPECT    $r3,0x1337f7d1
	ldk	  $r4,k_12345678
	sta.l     PM_ADDR,$r4

	# write while locked does nothing
	sta.l	  PM_DATA,$r1
	sta.l	  PM_DATA,$r0
	lpm.l     $r0,k_12345678
	lpm.l     $r1,k_abcdef01
	EXPECT    $r0,0x12345678
	EXPECT    $r1,0xabcdef01

	# write while unlocked modifies program memory
	sta.l	  PM_UNLOCK,$r3
	sta.l	  PM_DATA,$r1
	sta.l	  PM_DATA,$r0
	lpm.l     $r0,k_12345678
	lpm.l     $r1,k_abcdef01
	EXPECT    $r0,0xabcdef01
	EXPECT    $r1,0x12345678

# final stack check
	EXPECT    $sp,0x00000000

	PASS

# --------------------------------------------------

skip1:          # skip the instruction after the call
	pop.l     $r1
	add.l     $r1,$r1,4
	push.l    $r1
	return

skipparent:     # skip the instruction after the caller's call
	ldi.l     $r1,$sp,4
	add.l     $r1,$r1,4
	sti.l     $sp,4,$r1
	return
skip2:
	call      skipparent
	return

add64:
	addcc.l   $r0,$r1
	add.l     $r0,$r0,$r1
	ldk.l     $r1,0
	jmpc      nc,.done
	ldk.l     $r1,1
.done:
	return

fowia:  # find out where I'm at
	ldi.l     $r1,$sp,0
	return

lit:    # load literal to $r0
	pop.l     $r14
	lpmi.l    $r0,$r14,0
	add.l     $r14,$r14,4
	jmpi      $r14
zr0:
	ldk.l     $r0,0
	return
litr1:
	ldi.l     $r1,$sp,0
	add.l     $r1,$r1,4
	sti.l     $sp,0,$r1
	lpmi.l    $r1,$r1,-4
	return

factorial:
	ldk.l     $r1,1
	cmp.l     $r0,$r1
	jmpc      z,.factdone
	push.l    $r0
	add.l     $r0,$r0,-1
	call      factorial
	pop.l     $r1
	mul.l     $r0,$r0,$r1
.factdone:
	return

nullfunc:
	return

increment:
	add.l     $r0,$r0,1
	return

	.long   0x10111213
k_12345678:
	.long   0x12345678
k_abcdef01:
	.long   0xabcdef01
str3:
	.string   "abc"