Annotation of nono/exp/optestm88k/optestm88k_code.s, revision 1.1.1.2

1.1       root        1: |
                      2: | nono
                      3: | Copyright (C) 2021 nono project
                      4: | Licensed under nono-license.txt
                      5: |
                      6: 
                      7: | アセンブラのテストコードのうち固定部分
                      8: 
                      9: | 汎用演算命令のテストベース
                     10: |
                     11: | r3 の指す先は
                     12: |  +0   = exp_rd
                     13: |  +4   ここからテストコード(可変長)
                     14: .globl test_generic
                     15: test_generic:
                     16:        | 例外は起きない
                     17:        st      %r0, %r2, 4
                     18: 
                     19:        | r1 を退避してテストコードへジャンプ
1.1.1.2 ! root       20:        or      %r5, %r0, %r1
1.1       root       21:        addu    %r12, %r3, 4
                     22:        jsr     %r12            | test
1.1.1.2 ! root       23:        or      %r1, %r0, %r5
1.1       root       24: 
                     25:        | r2[0] の指す先(exception_occurred) は例外が起きたら 1、起きなければ 0。
                     26:        | これを最後に r2 はつぶして、戻り値として使う。
                     27:        ld      %r2, %r2, 0
                     28: 
                     29:        | rD をチェック。
1.1.1.2 ! root       30:        | 実行結果は r8 に、期待値は r3[0] に入っている。
1.1       root       31:        | cmp 結果の bit0 は %0 なので直前の例外結果と OR できる。
1.1.1.2 ! root       32:        ld      %r6, %r3, 0
        !            33:        cmp     %r6, %r6, %r8
        !            34:        or      %r2, %r2, %r6
1.1       root       35: 
                     36:        | ここで r2 は
                     37:        | 例外の期待と結果が異なれば bit0(0x01) がセットされている、
                     38:        | 演算の期待と結果が異なれば bit3(0x08) がセットされているので
                     39:        | 0x09 で AND すると、全部成功すれば 0、そうでなければ非 0 になる。
                     40:        and     %r2, %r2, 0x9
                     41:        jmp     %r1
                     42: 
                     43: | add/sub 命令のテストベース
                     44: |
                     45: | r3 の指す先は
                     46: |  +0   [0] = exp_rd (rD の期待値)
                     47: |  +4.b [4] = cin    (Cy の入力値)
                     48: |  +5.b [5] = exp_cy (Cy の期待値)
                     49: |  +6.b [6] = exp_ex (例外を期待するなら 1)
                     50: |  +8   [2] ここからテストコード(可変長)
                     51: .globl test_addsub
                     52: test_addsub:
                     53:        | 例外期待の有無を _main.c の exception_expected に書き戻す
                     54:        ld.bu   %r12, %r3, 6
                     55:        st      %r12, %r2, 4
                     56: 
                     57:        | Cy の初期値をセット
                     58:        | cin == 1 ならセット、cin == 0 ならクリア
                     59:        ld.bu   %r12, %r3, 4
                     60:        or.c    %r13, %r0, %r0
                     61:        addu.co %r0, %r12, %r13
                     62: 
                     63:        | r1 を退避してテストコードへジャンプ
1.1.1.2 ! root       64:        or      %r5, %r0, %r1
1.1       root       65:        addu    %r12, %r3, 8
                     66:        jsr     %r12            | test
1.1.1.2 ! root       67:        or      %r1, %r0, %r5
1.1       root       68: 
                     69:        | r2[0] の指す先(exception_occurred) は例外が起きたら 1、起きなければ 0。
                     70:        | r3.b[6] は例外期待なら 1、例外が起きないことを期待なら 0。
                     71:        | よって r2[0] と r3[2] を XOR して 0 になれば成功。
                     72:        | これを最後に r2 はつぶして、戻り値として使う。
                     73:        ld      %r2, %r2, 0
                     74:        ld.bu   %r13, %r3, 6
                     75:        xor     %r2, %r2, %r13
                     76: 
                     77:        | rD をチェック。
1.1.1.2 ! root       78:        | 実行結果は r8 に、期待値は r6 に入っている。
1.1       root       79:        | cmp 結果の bit0 は %0 なので直前の例外結果と OR できる。
1.1.1.2 ! root       80:        cmp     %r8, %r8, %r6
        !            81:        or      %r2, %r2, %r8
1.1       root       82: 
                     83:        | Cy をチェック。
                     84:        | 実行結果は Cy に、期待値は r3.b[5] にある。
                     85:        ld.bu   %r12, %r3, 5
                     86:        add.ci  %r13, %r0, %r0  | Get Cy
                     87:        cmp     %r13, %r13, %r12
                     88:        or      %r2, %r2, %r13
                     89: 
                     90:        | ここで r2 は
                     91:        | 例外の期待と結果が異なれば bit0(0x01) がセットされている、
                     92:        | 演算の期待と結果が異なれば bit3(0x08) がセットされているので
                     93:        | 0x09 で AND すると、全部成功すれば 0、そうでなければ非 0 になる。
                     94:        and     %r2, %r2, 0x9
                     95:        jmp     %r1
                     96: 
                     97: | div 命令のテストベース
                     98: |
                     99: | r3 の指す先は
                    100: |  +0   [0] = exp_rd (rD の期待値)
                    101: |  +4   [1] = exp_ex (Integer Divide 例外を期待するなら 2)
                    102: |  +8   [3] ここからテストコード (可変長)
                    103: .globl test_div
                    104: test_div:
                    105:        | 例外期待の有無を _main.c の exception_expected に書き戻す
                    106:        ld      %r12, %r3, 4
                    107:        st      %r12, %r2, 4
                    108: 
                    109:        | r1 を退避してテストコードへジャンプ
1.1.1.2 ! root      110:        or      %r5, %r0, %r1
1.1       root      111:        addu    %r12, %r3, 8
                    112:        jsr     %r12            | test
1.1.1.2 ! root      113:        or      %r1, %r0, %r5
1.1       root      114: 
                    115:        | r2[0] の指す先(exception_occurred) は IntDiv 例外が起きたら 2。
                    116:        | r3[1] は IntDiv 例外期待なら 2、起きないことを期待なら 0。
                    117:        | よって r2[0] と r3[1] を XOR して 0 になれば成功。
                    118:        | これを最後に r2 はつぶして戻り値として使う。
                    119:        ld      %r2, %r2, 0
                    120:        ld      %r13, %r3, 4
                    121:        xor     %r2, %r2, %r13
                    122: 
                    123:        | rD をチェック。
1.1.1.2 ! root      124:        | 実行結果は r8 に、期待値は r6 に入っている。
1.1       root      125:        | cmp 結果の bit0-1 は %0 なので直前の例外結果と OR できる。
1.1.1.2 ! root      126:        cmp     %r8, %r8, %r6
        !           127:        or      %r2, %r2, %r8
1.1       root      128: 
                    129:        | ここで r2 は
                    130:        | 例外の期待と結果が異なれば bit0-1(0x03) がセットされている、
                    131:        | 演算の期待と結果が異なれば bit3(0x08) がセットされているので
                    132:        | 0x0b で AND すると、全部成功すれば 0、そうでなければ非 0 になる。
                    133:        and     %r2, %r2, 0xb
                    134:        jmp     %r1
1.1.1.2 ! root      135: 
        !           136: | flt 命令のテストベース
        !           137: |
        !           138: | r3 の指す先は
        !           139: |  +0  [0] = exp_ex (例外を期待するなら 0x1000)
        !           140: |  +4   ここからテストコード
        !           141: .globl test_flt
        !           142: test_flt:
        !           143:        | 例外期待の有無を _main.c の exception_expected に書き戻す
        !           144:        ld      %r12, %r3, 0
        !           145:        st      %r12, %r2, 4
        !           146: 
        !           147:        | r1 を退避してテストコードへジャンプ
        !           148:        or      %r5, %r0, %r1
        !           149:        addu    %r12, %r3, 4
        !           150:        jsr     %r12            | test
        !           151:        or      %r1, %r0, %r5
        !           152: 
        !           153:        | r2[0] の指す先(exception_occurred) は FltInv 例外が起きたら 8。
        !           154:        | r3[0] は FltInv 例外期待なら 0x1000、起きないことを期待なら 0。
        !           155:        | よって r2[0] と r3[0] を XOR して 0 になれば成功。 
        !           156:        | これを最後に r2 はつぶして戻り値として使う。
        !           157:        ld      %r2, %r2, 0
        !           158:        ld      %r13, %r3, 0
        !           159:        xor     %r2, %r2, %r13
        !           160: 
        !           161:        | rD, rD+1 をチェック。
        !           162:        | 実行結果は r8(,r9) に、期待値は r6(,r7) に入っている。
        !           163:        cmp     %r6, %r6, %r8
        !           164:        cmp     %r7, %r7, %r9
        !           165:        or      %r2, %r2, %r6
        !           166:        or      %r2, %r2, %r7
        !           167: 
        !           168:        | ここで r2 は
        !           169:        | 例外の期待と結果が異なれば bit12(0x1000) がセットされている、
        !           170:        | 演算の期待と結果が異なれば bit3(0x08) がセットされているので
        !           171:        | 0x1008 で AND すると、全部成功すれば 0、そうでなければ非 0 になる。
        !           172:        and     %r2, %r2, 0x1008
        !           173:        jmp     %r1

unix.superglobalmegacorp.com

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.