Return to optestm88k_code.s CVS log

Up to [Isaki's NoNo m68k/m88k emulator] / nono / exp / optestm88k

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

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 を退避してテストコードへジャンプ
        !            20:        or      %r9, %r0, %r1
        !            21:        addu    %r12, %r3, 4
        !            22:        jsr     %r12            | test
        !            23:        or      %r1, %r0, %r9
        !            24: 
        !            25:        | r2[0] の指す先(exception_occurred) は例外が起きたら 1、起きなければ 0。
        !            26:        | これを最後に r2 はつぶして、戻り値として使う。
        !            27:        ld      %r2, %r2, 0
        !            28: 
        !            29:        | rD をチェック。
        !            30:        | 実行結果は r11 に、期待値は r3[0] に入っている。
        !            31:        | cmp 結果の bit0 は %0 なので直前の例外結果と OR できる。
        !            32:        ld      %r10, %r3, 0
        !            33:        cmp     %r10, %r10, %r11
        !            34:        or      %r2, %r2, %r10
        !            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 を退避してテストコードへジャンプ
        !            64:        or      %r9, %r0, %r1
        !            65:        addu    %r12, %r3, 8
        !            66:        jsr     %r12            | test
        !            67:        or      %r1, %r0, %r9
        !            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 をチェック。
        !            78:        | 実行結果は r11 に、期待値は r10 に入っている。
        !            79:        | cmp 結果の bit0 は %0 なので直前の例外結果と OR できる。
        !            80:        cmp     %r11, %r11, %r10
        !            81:        or      %r2, %r2, %r11
        !            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 を退避してテストコードへジャンプ
        !           110:        or      %r9, %r0, %r1
        !           111:        addu    %r12, %r3, 8
        !           112:        jsr     %r12            | test
        !           113:        or      %r1, %r0, %r9
        !           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 をチェック。
        !           124:        | 実行結果は r11 に、期待値は r10 に入っている。
        !           125:        | cmp 結果の bit0-1 は %0 なので直前の例外結果と OR できる。
        !           126:        cmp     %r11, %r11, %r10
        !           127:        or      %r2, %r2, %r11
        !           128: 
        !           129:        | ここで r2 は
        !           130:        | 例外の期待と結果が異なれば bit0-1(0x03) がセットされている、
        !           131:        | 演算の期待と結果が異なれば bit3(0x08) がセットされているので
        !           132:        | 0x0b で AND すると、全部成功すれば 0、そうでなければ非 0 になる。
        !           133:        and     %r2, %r2, 0xb
        !           134:        jmp     %r1

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