Return to test_0_ops.s CVS log

Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / fpevent

Annotation of cci/d/fpevent/test_0_ops.s, revision 1.1

1.1     ! root        1: 
        !             2: 
        !             3: # ***************************************************************************
        !             4: # *
        !             5: # *            Test an instruction that has no operands
        !             6: # *
        !             7: # *  Only the 1 byte instruction and some NOPs will go into the code buffer.
        !             8: # *
        !             9: # *  30-May-85 : added pipelined tests
        !            10: # *  22-Jul-85 : don't run pipeline 2 test w/ emulated instructions
        !            11: # ***************************************************************************
        !            12:        .text
        !            13:        .align  1
        !            14:        .globl  _test_0_ops
        !            15: _test_0_ops:
        !            16:        .word   0
        !            17: /*
        !            18:  * Set the sizes for loading and for storing the accumulator
        !            19: */
        !            20:        cmpl    $SGL,_precision
        !            21:        bneq    1f
        !            22:        movl    $SGL,_acc_ld_size               /* set ACC. load size      */
        !            23:        movl    $SGL,_acc_st_size               /* set ACC. store size     */
        !            24:        jmp     2f
        !            25: 1:
        !            26:        movl    $DBL,_acc_ld_size               /* set ACC. load size      */
        !            27:        movl    $DBL,_acc_st_size               /* set ACC. store size     */
        !            28:        cmpl    _op_code,$CVDF_OP_CODE          /* "cvdf" instruction?     */
        !            29:        bneq    2f
        !            30:        movl    $SGL,_acc_st_size               /* store sgl acc. for cvdf */
        !            31: 2:
        !            32:        callf   $4,_test_0_no_pipe              /* test w/o pipelineing    */
        !            33:        callf   $4,_test_0_pipe1                /* test pipeline test #1   */
        !            34:        cmpl    _test_event,$FPM_CODE           /* Is this the FPM test?   */
        !            35:        beql    1f                              /* don't run pipe #2 w/ FPM */
        !            36:        callf   $4,_test_0_pipe2                /* test pipeline test #2   */
        !            37: 1:     ret                                     /* return                  */
        !            38: 
        !            39: 
        !            40: 
        !            41: 
        !            42: # ***************************************************************************
        !            43: # *
        !            44: # *   TEST A NO OPERAND INSTRUCTION WITH NO FPP INSTRUCTION IN FRONT OF IT
        !            45: # *
        !            46: # ***************************************************************************
        !            47:        .text
        !            48:        .align  1
        !            49:        .globl  _test_0_no_pipe
        !            50: _test_0_no_pipe:
        !            51:        .word   0
        !            52:        clrl    _pipe_test                      /* reset the pipe-test flag */
        !            53:        callf   $4,_pack_inst                   /* pack the instr's code   */
        !            54:        pushl   $_load_regs                     /* buffer for loading regs */
        !            55:        callf   $8,_fill_reg_buf                /* fill the buffer         */
        !            56:        pushl   $_exp_regs                      /* expected reg values     */
        !            57:        callf   $8,_fill_reg_buf                /* fill the buffer         */
        !            58: /*
        !            59:  * test the instruction 
        !            60: */
        !            61:        clrl    _index
        !            62: 3:
        !            63:        mull3   $4,_index,r0                    /* get longword offset     */
        !            64:        movl    *_data_ptr[r0],_dbl_ld_acc      /* get load data's MSW     */
        !            65:        incl    r0
        !            66:        movl    *_data_ptr[r0],_dbl_ld_acc+4    /* get load data's LSW     */
        !            67: 2:
        !            68:        callf   $4,_run_code                    /* execute the instruction */
        !            69:        tstl    _force_loop
        !            70:        bneq    2b                              /* loop on an error        */
        !            71:        cmpl    _index,_max_index               /* last data pattern?      */
        !            72:        bgeq    1f
        !            73:        incl    _index                          /* bump the index          */
        !            74:        jmp     3b                              /* test next data pattern  */
        !            75: 1:
        !            76:        ret                                     /* return to test_code     */
        !            77: 
        !            78: 
        !            79: 
        !            80: 
        !            81: # ***************************************************************************
        !            82: # *
        !            83: # *   TEST A NO OPERAND INSTRUCTION WITH A LOAD INSTRUCION IN FRONT OF IT
        !            84: # *
        !            85: # ***************************************************************************
        !            86:        .text
        !            87:        .align  1
        !            88:        .globl  _test_0_pipe1
        !            89: _test_0_pipe1:
        !            90:        .word   0
        !            91:        movl    $1,_pipe_test                   /* set the pipe_test flag  */
        !            92:        movl    $0x62,_addr_code_p1             /* set the addr mode       */
        !            93:        cmpl    $DBL,_acc_ld_size               /* DBL or SGL ACC?         */
        !            94:        beql    1f
        !            95:        movl    $LDF_OP_CODE,_pipe_inst1        /* pipe inst = load single */
        !            96:        brb     2f
        !            97: 1:     movl    $LDD_OP_CODE,_pipe_inst1        /* pipe inst = load double */
        !            98: 2:
        !            99:        callf   $4,_pack_inst                   /* pack the instr's code   */
        !           100:        pushl   $_load_regs                     /* buffer for loading regs */
        !           101:        callf   $8,_fill_reg_buf                /* fill the buffer         */
        !           102:        pushl   $_exp_regs                      /* expected reg values     */
        !           103:        callf   $8,_fill_reg_buf                /* fill the buffer         */
        !           104:        moval   _dbl_ld_acc,_load_regs+8        /* R2 points to the data   */
        !           105:        moval   _dbl_ld_acc,_exp_regs+8         /* R2 points to the data   */
        !           106: /*
        !           107:  * test the instruction 
        !           108: */
        !           109:        clrl    _index
        !           110: 3:
        !           111:        mull3   $4,_index,r0                    /* get longword offset     */
        !           112:        movl    *_data_ptr[r0],_dbl_ld_acc      /* get load data's MSW     */
        !           113:        incl    r0
        !           114:        movl    *_data_ptr[r0],_dbl_ld_acc+4    /* get load data's LSW     */
        !           115: 2:
        !           116:        callf   $4,_run_code                    /* execute the instruction */
        !           117:        tstl    _force_loop
        !           118:        bneq    2b                              /* loop on an error        */
        !           119:        cmpl    _index,_max_index               /* last data pattern?      */
        !           120:        bgeq    1f
        !           121:        incl    _index                          /* bump the index          */
        !           122:        jmp     3b                              /* test next data pattern  */
        !           123: 1:
        !           124:        clrl    _pipe_test                      /* reset the pipe-test flag */
        !           125:        ret                                     /* return to test_code     */
        !           126: 
        !           127: 
        !           128: 
        !           129: 
        !           130: # ***************************************************************************
        !           131: # *
        !           132: # *   TEST A NO OPERAND INSTRUCTION WITH AN ADD INSTRUCION IN FRONT OF IT
        !           133: # *
        !           134: # ***************************************************************************
        !           135:        .text
        !           136:        .align  1
        !           137:        .globl  _test_0_pipe2
        !           138: _test_0_pipe2:
        !           139:        .word   0
        !           140:        movl    $2,_pipe_test                   /* set the pipe_test flag */
        !           141:        movl    $0x62,_addr_code_p1             /* set the addr mode      */
        !           142:        cmpl    $DBL,_acc_ld_size               /* DBL or SGL ACC?        */
        !           143:        beql    1f
        !           144:        movl    $ADDF_OP_CODE,_pipe_inst1       /* pipe inst = add single */
        !           145:        brb     2f
        !           146: 1:     movl    $ADDD_OP_CODE,_pipe_inst1       /* pipe inst = add double */
        !           147: 2:
        !           148:        callf   $4,_pack_inst                   /* pack the instr's code  */
        !           149:        pushl   $_load_regs                     /* buffer for loading regs */
        !           150:        callf   $8,_fill_reg_buf                /* fill the buffer        */
        !           151:        pushl   $_exp_regs                      /* expected reg values    */
        !           152:        callf   $8,_fill_reg_buf                /* fill the buffer        */
        !           153:        moval   _dbl_ld_acc,_load_regs+8        /* R2 points to the data  */
        !           154:        moval   _dbl_ld_acc,_exp_regs+8         /* R2 points to the data  */
        !           155: /*
        !           156:  * test the instruction 
        !           157: */
        !           158:        clrl    _index
        !           159: 3:
        !           160:        mull3   $4,_index,r0                    /* get longword offset     */
        !           161:        movl    *_data_ptr[r0],_dbl_ld_acc      /* get load data's MSW     */
        !           162:        incl    r0
        !           163:        movl    *_data_ptr[r0],_dbl_ld_acc+4    /* get load data's LSW     */
        !           164: 2:
        !           165:        callf   $4,_run_code                    /* execute the instruction */
        !           166:        tstl    _force_loop
        !           167:        bneq    2b                              /* loop on an error        */
        !           168:        cmpl    _index,_max_index               /* last data pattern?      */
        !           169:        bgeq    1f
        !           170:        incl    _index                          /* bump the index          */
        !           171:        jmp     3b                              /* test next data pattern  */
        !           172: 1:
        !           173:        clrl    _pipe_test                      /* reset the pipe-test flag */
        !           174:        ret                                     /* return to test_code     */
        !           175: 
        !           176: 
        !           177: 

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