| # 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" |