![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mull2.lst CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / macro4|
Return to mull2.lst CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / macro4 |
1.1 ! root 1: 1 00000000 LL0: ! 2: 2 00000000 .data ! 3: 3 00000d58 * .text ! 4: 4 00000000 .align 1 ! 5: 5 00000000 .globl _mull2 ! 6: 6 00000000 _mull2: ! 7: 7 00023F34 0000 .word L215 ! 8: 8 00023F36 # #include "fpp_defs.h" ! 9: 9 00023F36 # ! 10: 10 00023F36 # ! 11: 11 00023F36 # /*************************************************************************** ! 12: 12 00023F36 # * ! 13: 13 00023F36 # * MULL2 -MULTIPLY INTEGER 2 INSTRUCTION TEST ! 14: 14 00023F36 # * ! 15: 15 00023F36 # *****************************************************************************/ ! 16: 16 00023F36 # mull2() ! 17: 17 00023F36 # { ! 18: 18 00023F36 11 4f jbr L217 ! 19: 19 00023F38 L218: ! 20: 20 00023F38 # asm(".globl _mull2_t"); ! 21: 21 00023F38 .globl _mull2_t ! 22: 22 00023F38 # asm("_mull2_t:"); /* entry address */ ! 23: 23 00023F38 _mull2_t: ! 24: 24 00023F38 # if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */ ! 25: 25 00023F38 1d effffffff6 01 cmpl _cycle,$1 ! 26: 26 00023F3F 21 15 jneq L219 ! 27: 27 00023F41 5d efffffffed tstl _prt_hdrs ! 28: 28 00023F47 31 0d jeql L219 ! 29: 29 00023F49 # { ! 30: 30 00023F49 # writes(" MULL2"); ! 31: 31 00023F49 .data 1 ! 32: 32 00000d58 * L221: ! 33: 33 00000d58 * 204D554C4C3200 .ascii " MULL2\0" ! 34: 34 00000d5f * .text ! 35: 35 00023F49 dd 8f00000d58 pushl $L221 ! 36: 36 00023F4F fe 08 efffffffde callf $8,_writes ! 37: 37 00023F56 # } ! 38: 38 00023F56 # mull2_1(); /* register data / SGL acc. */ ! 39: 39 00023F56 L219: ! 40: 40 00023F56 fe 04 ef0000002d callf $4,_mull2_1 ! 41: 41 00023F5D # mull2_2(); /* memory data / DBL acc. */ ! 42: 42 00023F5D fe 04 ef000001d2 callf $4,_mull2_2 ! 43: 43 00023F64 # mull2_3(); /* register corruption test */ ! 44: 44 00023F64 fe 04 ef000003db callf $4,_mull2_3 ! 45: 45 00023F6B # mull2_4(); /* PSL corruption test */ ! 46: 46 00023F6B fe 04 ef0000056a callf $4,_mull2_4 ! 47: 47 00023F72 # mull2_5(); /* pipelined entry test */ ! 48: 48 00023F72 fe 04 ef0000070d callf $4,_mull2_5 ! 49: 49 00023F79 # mull2_6(); /* pipelined exit test */ ! 50: 50 00023F79 fe 04 ef000008d8 callf $4,_mull2_6 ! 51: 51 00023F80 # asm("jmp *return"); /* return to the test monitor */ ! 52: 52 00023F80 71 ffffffffae jmp *return ! 53: 53 00023F86 # } ! 54: 54 00023F86 40 ret#2 ! 55: 55 00023F87 .set L215,0x0 ! 56: 56 00023F87 L217: ! 57: 57 00023F87 11 af jbr L218 ! 58: 58 00023F89 .data ! 59: 59 00000d58 * .text ! 60: 60 00023F89 00 .align 1 ! 61: 61 00023F8A .globl _mull2_1 ! 62: 62 00023F8A _mull2_1: ! 63: 63 00023F8A 0000 .word L228 ! 64: 64 00023F8C # ! 65: 65 00023F8C # ! 66: 66 00023F8C # ! 67: 67 00023F8C # /************************************************************************ ! 68: 68 00023F8C # * ! 69: 69 00023F8C # * SUBTEST 1 - register addressing / single precsion accumulator ! 70: 70 00023F8C # * ! 71: 71 00023F8C # ************************************************************************/ ! 72: 72 00023F8C # mull2_1() ! 73: 73 00023F8C # { ! 74: 74 00023F8C 13 01a4 jbr L230 ! 75: 75 00023F8F L231: ! 76: 76 00023F8F # force_loop = FALSE; ! 77: 77 00023F8F 4d efffffff9f clrl _force_loop ! 78: 78 00023F95 # subtest = 1; ! 79: 79 00023F95 0d 01 efffffff98 movl $1,_subtest ! 80: 80 00023F9C # for( index = 0; index < max_mull_1_index; index++ ) { ! 81: 81 00023F9C 4d efffffff92 clrl _index ! 82: 82 00023FA2 L234: ! 83: 83 00023FA2 1d efffffff8c efffffff87 cmpl _index,_max_mull_1_index ! 84: 84 00023FAD 91 03 13 0180 jgeq L233 ! 85: 85 00023FB2 # sgl_value_1 = mull_1_data[index].op_1; /* get operand 1 */ ! 86: 86 00023FB2 5c 0c efffffff7b 50 mull3 $12,_index,r0 ! 87: 87 00023FBA 0d e000000000 efffffff6f movl _mull_1_data(r0),_sgl_value_1 ! 88: 88 00023FC5 # sgl_value_2 = mull_1_data[index].op_2; /* get operand 2 */ ! 89: 89 00023FC5 5c 0c efffffff68 50 mull3 $12,_index,r0 ! 90: 90 00023FCD 0d e000000004 efffffff5c movl _mull_1_data+4(r0),_sgl_value_2 ! 91: 91 00023FD8 # sgl_value_4 = mull_1_data[index].exp; /* get expected results */ ! 92: 92 00023FD8 5c 0c efffffff55 50 mull3 $12,_index,r0 ! 93: 93 00023FE0 0d e000000008 efffffff49 movl _mull_1_data+8(r0),_sgl_value_4 ! 94: 94 00023FEB # sgl_ld_acc = 0x12345678; /* set acc data pattern */ ! 95: 95 00023FEB 0d 8f12345678 efffffff3e movl $305419896,_sgl_ld_acc ! 96: 96 00023FF6 # sgl_expected = sgl_ld_acc; /* final Acc expected */ ! 97: 97 00023FF6 0d efffffff38 efffffff33 movl _sgl_ld_acc,_sgl_expected ! 98: 98 00024001 # /* ! 99: 99 00024001 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 100: 100 00024001 # */ ! 101: 101 00024001 # asm("_mull2_1_lp1:"); ! 102: 102 00024001 _mull2_1_lp1: ! 103: 103 00024001 # asm("movl _sgl_value_1,r3"); /* move the 1st data to r3 */ ! 104: 104 00024001 0d efffffff2d 53 movl _sgl_value_1,r3 ! 105: 105 00024008 # asm("movl _sgl_value_2,r4"); /* move the 2nd data to r4 */ ! 106: 106 00024008 0d efffffff26 54 movl _sgl_value_2,r4 ! 107: 107 0002400F # asm("movl _sgl_ld_acc,r5"); /* move the acc data to r5 */ ! 108: 108 0002400F 0d efffffff1f 55 movl _sgl_ld_acc,r5 ! 109: 109 00024016 # asm("ldf r5"); /* load the acc */ ! 110: 110 00024016 06 55 ldf r5 ! 111: 111 00024018 # asm("mull2 r3,r4"); /* do the multiply */ ! 112: 112 00024018 4c 53 54 mull2 r3,r4 ! 113: 113 0002401B # asm("nop"); ! 114: 114 0002401B 10 nop ! 115: 115 0002401C # asm("stf _sgl_st_acc"); /* save the acc */ ! 116: 116 0002401C 26 efffffff12 stf _sgl_st_acc ! 117: 117 00024022 # if( force_loop ) ! 118: 118 00024022 5d efffffff0c tstl _force_loop ! 119: 119 00024028 31 02 jeql L235 ! 120: 120 0002402A # asm("brb _mull2_1_lp1");; ! 121: 121 0002402A 11 d5 brb _mull2_1_lp1 ! 122: 122 0002402C L235: ! 123: 123 0002402C # asm("movl r4,_sgl_value_3"); ! 124: 124 0002402C 0d 54 efffffff01 movl r4,_sgl_value_3 ! 125: 125 00024033 # if( sgl_expected != sgl_st_acc ) { /* COMPARE the values */ ! 126: 126 00024033 1d effffffefb effffffef6 cmpl _sgl_expected,_sgl_st_acc ! 127: 127 0002403E 21 03 13 0098 jeql L236 ! 128: 128 00024043 # errcnt++; /* bump the error count */ ! 129: 129 00024043 6d effffffeeb incl _errcnt ! 130: 130 00024049 # if ( prt_error ) { ! 131: 131 00024049 5d effffffee5 tstl _prt_error ! 132: 132 0002404F 31 64 jeql L237 ! 133: 133 00024051 # print_mull2_error("(Reg. Data) -THE ACC WAS MODIFIED"); ! 134: 134 00024051 .data 1 ! 135: 135 00000d5f * L239: ! 136: 136 00000d5f * 285265672E204461746129202 .ascii "(Reg. Data) -THE ACC WAS MODIFIED\0" ! 137: D544845204143432057415320 ! 138: 4D4F44494649454400 ! 139: 137 00000d81 * .text ! 140: 138 00024051 dd 8f00000d5f pushl $L239 ! 141: 139 00024057 fe 08 ef000009cc callf $8,_print_mull2_error ! 142: 140 0002405E # writes("initial Acc = "); ! 143: 141 0002405E .data 1 ! 144: 142 00000d81 * L240: ! 145: 143 00000d81 * 696E697469616C20416363203 .ascii "initial Acc = \0" ! 146: D2000 ! 147: 144 00000d90 * .text ! 148: 145 0002405E dd 8f00000d81 pushl $L240 ! 149: 146 00024064 fe 08 effffffec9 callf $8,_writes ! 150: 147 0002406B # write32h( sgl_ld_acc ); ! 151: 148 0002406B dd effffffec3 pushl _sgl_ld_acc ! 152: 149 00024071 fe 08 effffffebc callf $8,_write32h ! 153: 150 00024078 # writes(", final Acc = "); ! 154: 151 00024078 .data 1 ! 155: 152 00000d90 * L242: ! 156: 153 00000d90 * 2C202020202066696E616C204 .ascii ", final Acc = \0" ! 157: 16363203D2000 ! 158: 154 00000da3 * .text ! 159: 155 00024078 dd 8f00000d90 pushl $L242 ! 160: 156 0002407E fe 08 effffffeaf callf $8,_writes ! 161: 157 00024085 # write32h( sgl_st_acc ); ! 162: 158 00024085 dd effffffea9 pushl _sgl_st_acc ! 163: 159 0002408B fe 08 effffffea2 callf $8,_write32h ! 164: 160 00024092 # writes("\n expected Acc = "); ! 165: 161 00024092 .data 1 ! 166: 162 00000da3 * L243: ! 167: 163 00000da3 * 0A20202020202020202020202 .ascii "\12 expected Acc = \0" ! 168: 0202020202020202020202020 ! 169: 2065787065637465642041636 ! 170: 3203D2000 ! 171: 164 00000dcd * .text ! 172: 165 00024092 dd 8f00000da3 pushl $L243 ! 173: 166 00024098 fe 08 effffffe95 callf $8,_writes ! 174: 167 0002409F # write32h( sgl_expected ); ! 175: 168 0002409F dd effffffe8f pushl _sgl_expected ! 176: 169 000240A5 fe 08 effffffe88 callf $8,_write32h ! 177: 170 000240AC # writec('\n'); ! 178: 171 000240AC dd 0a pushl $10 ! 179: 172 000240AE fe 08 effffffe7f callf $8,_writec ! 180: 173 000240B5 # } ! 181: 174 000240B5 # if ( halt_flg ) /* halt on error? */ ! 182: 175 000240B5 L237: ! 183: 176 000240B5 5d effffffe79 tstl _halt_flg ! 184: 177 000240BB 31 09 jeql L245 ! 185: 178 000240BD # mull2_halt( 4 ); ! 186: 179 000240BD dd 04 pushl $4 ! 187: 180 000240BF fe 08 ef00000a6a callf $8,_mull2_halt ! 188: 181 000240C6 # if ( loop_on_err ) { ! 189: 182 000240C6 L245: ! 190: 183 000240C6 5d effffffe68 tstl _loop_on_err ! 191: 184 000240CC 31 0d jeql L247 ! 192: 185 000240CE # force_loop = TRUE; /* set the force loop flag */ ! 193: 186 000240CE 0d 01 effffffe5f movl $1,_force_loop ! 194: 187 000240D5 # asm("jmp _mull2_1_lp1"); /* and loop */ ! 195: 188 000240D5 71 efffffff26 jmp _mull2_1_lp1 ! 196: 189 000240DB # } /* end of loop-on-error */ ! 197: 190 000240DB # } /* end of acc corr error */ ! 198: 191 000240DB L247: ! 199: 192 000240DB # if( sgl_value_4 != sgl_value_3 ) /* COMPARE the values */ ! 200: 193 000240DB L236: ! 201: 194 000240DB 1d effffffe53 effffffe4e cmpl _sgl_value_4,_sgl_value_3 ! 202: 195 000240E6 31 41 jeql L248 ! 203: 196 000240E8 # { ! 204: 197 000240E8 # errcnt++; /* bump the error count */ ! 205: 198 000240E8 6d effffffe46 incl _errcnt ! 206: 199 000240EE # if ( prt_error ) { ! 207: 200 000240EE 5d effffffe40 tstl _prt_error ! 208: 201 000240F4 31 0d jeql L249 ! 209: 202 000240F6 # print_mull2_error("(Reg. Data) -BAD MULTIPLY RESULT"); ! 210: 203 000240F6 .data 1 ! 211: 204 00000dcd * L250: ! 212: 205 00000dcd * 285265672E204461746129202 .ascii "(Reg. Data) -BAD MULTIPLY RESULT\0" ! 213: D424144204D554C5449504C59 ! 214: 20524553554C5400 ! 215: 206 00000dee * .text ! 216: 207 000240F6 dd 8f00000dcd pushl $L250 ! 217: 208 000240FC fe 08 ef00000927 callf $8,_print_mull2_error ! 218: 209 00024103 # } ! 219: 210 00024103 # if ( halt_flg ) /* halt on error? */ ! 220: 211 00024103 L249: ! 221: 212 00024103 5d effffffe2b tstl _halt_flg ! 222: 213 00024109 31 09 jeql L251 ! 223: 214 0002410B # mull2_halt( 1 ); ! 224: 215 0002410B dd 01 pushl $1 ! 225: 216 0002410D fe 08 ef00000a1c callf $8,_mull2_halt ! 226: 217 00024114 # if ( loop_on_err ) { ! 227: 218 00024114 L251: ! 228: 219 00024114 5d effffffe1a tstl _loop_on_err ! 229: 220 0002411A 31 0d jeql L252 ! 230: 221 0002411C # force_loop = TRUE; /* set the force loop flag */ ! 231: 222 0002411C 0d 01 effffffe11 movl $1,_force_loop ! 232: 223 00024123 # asm("jmp _mull2_1_lp1"); /* and loop */ ! 233: 224 00024123 71 effffffed8 jmp _mull2_1_lp1 ! 234: 225 00024129 # } /* end of loop-on-error */ ! 235: 226 00024129 # } /* end of multiply error */ ! 236: 227 00024129 L252: ! 237: 228 00024129 # } ! 238: 229 00024129 L248: ! 239: 230 00024129 L232: ! 240: 231 00024129 6d effffffe05 incl _index ! 241: 232 0002412F 13 fe70 jbr L234 ! 242: 233 00024132 L233: ! 243: 234 00024132 # } /* end of subtest 1 */ ! 244: 235 00024132 40 ret#2 ! 245: 236 00024133 .set L228,0x0 ! 246: 237 00024133 L230: ! 247: 238 00024133 13 fe59 jbr L231 ! 248: 239 00024136 .data ! 249: 240 00000d58 * .text ! 250: 241 00024136 .align 1 ! 251: 242 00024136 .globl _mull2_2 ! 252: 243 00024136 _mull2_2: ! 253: 244 00024136 0000 .word L253 ! 254: 245 00024138 # ! 255: 246 00024138 # ! 256: 247 00024138 # ! 257: 248 00024138 # /************************************************************************ ! 258: 249 00024138 # * ! 259: 250 00024138 # * SUBTEST 2 - cache addressing / double precsion accumulator ! 260: 251 00024138 # * ! 261: 252 00024138 # ************************************************************************/ ! 262: 253 00024138 # mull2_2() ! 263: 254 00024138 # { ! 264: 255 00024138 13 0207 jbr L255 ! 265: 256 0002413B L256: ! 266: 257 0002413B # force_loop = FALSE; ! 267: 258 0002413B 4d effffffdf3 clrl _force_loop ! 268: 259 00024141 # subtest = 2; ! 269: 260 00024141 0d 02 effffffdec movl $2,_subtest ! 270: 261 00024148 # for( index = 0; index < max_mull_1_index; index++ ) { ! 271: 262 00024148 4d effffffde6 clrl _index ! 272: 263 0002414E L259: ! 273: 264 0002414E 1d effffffde0 effffffddb cmpl _index,_max_mull_1_index ! 274: 265 00024159 91 03 13 01e3 jgeq L258 ! 275: 266 0002415E # sgl_value_1 = mull_1_data[index].op_1; /* get operand 1 */ ! 276: 267 0002415E 5c 0c effffffdcf 50 mull3 $12,_index,r0 ! 277: 268 00024166 0d e000000000 effffffdc3 movl _mull_1_data(r0),_sgl_value_1 ! 278: 269 00024171 # sgl_value_2 = mull_1_data[index].op_2; /* get operand 2 */ ! 279: 270 00024171 5c 0c effffffdbc 50 mull3 $12,_index,r0 ! 280: 271 00024179 0d e000000004 effffffdb0 movl _mull_1_data+4(r0),_sgl_value_2 ! 281: 272 00024184 # sgl_value_4 = mull_1_data[index].exp; /* get expected results */ ! 282: 273 00024184 5c 0c effffffda9 50 mull3 $12,_index,r0 ! 283: 274 0002418C 0d e000000008 effffffd9d movl _mull_1_data+8(r0),_sgl_value_4 ! 284: 275 00024197 # dbl_ld_acc.m = 0x12345678; /* set acc data pattern */ ! 285: 276 00024197 0d 8f12345678 effffffd92 movl $305419896,_dbl_ld_acc ! 286: 277 000241A2 # dbl_ld_acc.l = 0x9abcdef0; ! 287: 278 000241A2 0d 8f9abcdef0 effffffd8b movl $-1698898192,_dbl_ld_acc+4 ! 288: 279 000241AD # dbl_expected.m = dbl_ld_acc.m; /* final Acc expected */ ! 289: 280 000241AD 0d effffffd81 effffffd7c movl _dbl_ld_acc,_dbl_expected ! 290: 281 000241B8 # dbl_expected.l = dbl_ld_acc.l; ! 291: 282 000241B8 0d effffffd7a effffffd75 movl _dbl_ld_acc+4,_dbl_expected+4 ! 292: 283 000241C3 # /* ! 293: 284 000241C3 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 294: 285 000241C3 # */ ! 295: 286 000241C3 # asm("_mull2_2_lp1:"); ! 296: 287 000241C3 _mull2_2_lp1: ! 297: 288 000241C3 # sgl_value_3 = sgl_value_2; /* set initial op 2 data */ ! 298: 289 000241C3 0d effffffd6b effffffd66 movl _sgl_value_2,_sgl_value_3 ! 299: 290 000241CE # asm("ldd _dbl_ld_acc"); /* load the acc */ ! 300: 291 000241CE 07 effffffd60 ldd _dbl_ld_acc ! 301: 292 000241D4 # asm("mull2 _sgl_value_1,_sgl_value_3"); /* multiply the integers */ ! 302: 293 000241D4 4c effffffd5a effffffd55 mull2 _sgl_value_1,_sgl_value_3 ! 303: 294 000241DF # asm("nop"); ! 304: 295 000241DF 10 nop ! 305: 296 000241E0 # asm("std _dbl_st_acc"); /* save the acc */ ! 306: 297 000241E0 27 effffffd4e std _dbl_st_acc ! 307: 298 000241E6 # if( force_loop ) ! 308: 299 000241E6 5d effffffd48 tstl _force_loop ! 309: 300 000241EC 31 02 jeql L260 ! 310: 301 000241EE # asm("brb _mull2_2_lp1");; ! 311: 302 000241EE 11 d3 brb _mull2_2_lp1 ! 312: 303 000241F0 L260: ! 313: 304 000241F0 # if( (dbl_expected.m != dbl_st_acc.m) || /* COMPARE the Acc */ ! 314: 305 000241F0 # (dbl_expected.l != dbl_st_acc.l) ) { ! 315: 306 000241F0 1d effffffd3e effffffd39 cmpl _dbl_expected,_dbl_st_acc ! 316: 307 000241FB 21 10 jneq L9999 ! 317: 308 000241FD 1d effffffd35 effffffd30 cmpl _dbl_expected+4,_dbl_st_acc+4 ! 318: 309 00024208 21 03 13 00dd jeql L261 ! 319: 310 0002420D L9999: ! 320: 311 0002420D # errcnt++; /* bump the error count */ ! 321: 312 0002420D 6d effffffd21 incl _errcnt ! 322: 313 00024213 # if ( prt_error ) { ! 323: 314 00024213 5d effffffd1b tstl _prt_error ! 324: 315 00024219 21 03 13 00a6 jeql L262 ! 325: 316 0002421E # print_mull2_error("(Memory data) -THE ACC WAS MODIFIED"); ! 326: 317 0002421E .data 1 ! 327: 318 00000dee * L263: ! 328: 319 00000dee * 284D656D6F727920646174612 .ascii "(Memory data) -THE ACC WAS MODIFIED\0" ! 329: 9202D54484520414343205741 ! 330: 53204D4F44494649454400 ! 331: 320 00000e12 * .text ! 332: 321 0002421E dd 8f00000dee pushl $L263 ! 333: 322 00024224 fe 08 ef000007ff callf $8,_print_mull2_error ! 334: 323 0002422B # writes("initial Acc = "); ! 335: 324 0002422B .data 1 ! 336: 325 00000e12 * L264: ! 337: 326 00000e12 * 696E697469616C20416363203 .ascii "initial Acc = \0" ! 338: D2000 ! 339: 327 00000e21 * .text ! 340: 328 0002422B dd 8f00000e12 pushl $L264 ! 341: 329 00024231 fe 08 effffffcfc callf $8,_writes ! 342: 330 00024238 # write32h( dbl_ld_acc.m ); ! 343: 331 00024238 dd effffffcf6 pushl _dbl_ld_acc ! 344: 332 0002423E fe 08 effffffcef callf $8,_write32h ! 345: 333 00024245 # writec(' '); ! 346: 334 00024245 dd 20 pushl $32 ! 347: 335 00024247 fe 08 effffffce6 callf $8,_writec ! 348: 336 0002424E # write32h( dbl_ld_acc.l ); ! 349: 337 0002424E dd effffffce4 pushl _dbl_ld_acc+4 ! 350: 338 00024254 fe 08 effffffcd9 callf $8,_write32h ! 351: 339 0002425B # writes(", final Acc = "); ! 352: 340 0002425B .data 1 ! 353: 341 00000e21 * L265: ! 354: 342 00000e21 * 2C202020202066696E616C204 .ascii ", final Acc = \0" ! 355: 16363203D2000 ! 356: 343 00000e34 * .text ! 357: 344 0002425B dd 8f00000e21 pushl $L265 ! 358: 345 00024261 fe 08 effffffccc callf $8,_writes ! 359: 346 00024268 # write32h( dbl_st_acc.m ); ! 360: 347 00024268 dd effffffcc6 pushl _dbl_st_acc ! 361: 348 0002426E fe 08 effffffcbf callf $8,_write32h ! 362: 349 00024275 # writec(' '); ! 363: 350 00024275 dd 20 pushl $32 ! 364: 351 00024277 fe 08 effffffcb6 callf $8,_writec ! 365: 352 0002427E # write32h( dbl_st_acc.l ); ! 366: 353 0002427E dd effffffcb4 pushl _dbl_st_acc+4 ! 367: 354 00024284 fe 08 effffffca9 callf $8,_write32h ! 368: 355 0002428B # writes("\n expected Acc = "); ! 369: 356 0002428B .data 1 ! 370: 357 00000e34 * L266: ! 371: 358 00000e34 * 0A20202020202020202020202 .ascii "\12 expected Acc = \0" ! 372: 0202020202020202020202020 ! 373: 2020202020202020202065787 ! 374: 0656374656420416363203D20 ! 375: 00 ! 376: 359 00000e67 * .text ! 377: 360 0002428B dd 8f00000e34 pushl $L266 ! 378: 361 00024291 fe 08 effffffc9c callf $8,_writes ! 379: 362 00024298 # write32h( dbl_expected.m ); ! 380: 363 00024298 dd effffffc96 pushl _dbl_expected ! 381: 364 0002429E fe 08 effffffc8f callf $8,_write32h ! 382: 365 000242A5 # writec(' '); ! 383: 366 000242A5 dd 20 pushl $32 ! 384: 367 000242A7 fe 08 effffffc86 callf $8,_writec ! 385: 368 000242AE # write32h( dbl_expected.l ); ! 386: 369 000242AE dd effffffc84 pushl _dbl_expected+4 ! 387: 370 000242B4 fe 08 effffffc79 callf $8,_write32h ! 388: 371 000242BB # writec('\n'); ! 389: 372 000242BB dd 0a pushl $10 ! 390: 373 000242BD fe 08 effffffc70 callf $8,_writec ! 391: 374 000242C4 # } ! 392: 375 000242C4 # if ( halt_flg ) /* halt on error? */ ! 393: 376 000242C4 L262: ! 394: 377 000242C4 5d effffffc6a tstl _halt_flg ! 395: 378 000242CA 31 09 jeql L267 ! 396: 379 000242CC # mull2_halt( 4 ); ! 397: 380 000242CC dd 04 pushl $4 ! 398: 381 000242CE fe 08 ef0000085b callf $8,_mull2_halt ! 399: 382 000242D5 # if ( loop_on_err ) { ! 400: 383 000242D5 L267: ! 401: 384 000242D5 5d effffffc59 tstl _loop_on_err ! 402: 385 000242DB 31 0d jeql L268 ! 403: 386 000242DD # force_loop = TRUE; /* set the force loop flag */ ! 404: 387 000242DD 0d 01 effffffc50 movl $1,_force_loop ! 405: 388 000242E4 # asm("jmp _mull2_2_lp1"); /* and loop */ ! 406: 389 000242E4 71 effffffed9 jmp _mull2_2_lp1 ! 407: 390 000242EA # } /* end of loop-on-error */ ! 408: 391 000242EA # } /* end of acc corr error */ ! 409: 392 000242EA L268: ! 410: 393 000242EA # if( sgl_value_4 != sgl_value_3 ) /* COMPARE the values */ ! 411: 394 000242EA L261: ! 412: 395 000242EA 1d effffffc44 effffffc3f cmpl _sgl_value_4,_sgl_value_3 ! 413: 396 000242F5 31 41 jeql L269 ! 414: 397 000242F7 # { ! 415: 398 000242F7 # errcnt++; /* bump the error count */ ! 416: 399 000242F7 6d effffffc37 incl _errcnt ! 417: 400 000242FD # if ( prt_error ) { ! 418: 401 000242FD 5d effffffc31 tstl _prt_error ! 419: 402 00024303 31 0d jeql L270 ! 420: 403 00024305 # print_mull2_error("(Memory data) -BAD MULTIPLY RESULT"); ! 421: 404 00024305 .data 1 ! 422: 405 00000e67 * L271: ! 423: 406 00000e67 * 284D656D6F727920646174612 .ascii "(Memory data) -BAD MULTIPLY RESULT\0" ! 424: 9202D424144204D554C544950 ! 425: 4C5920524553554C5400 ! 426: 407 00000e8a * .text ! 427: 408 00024305 dd 8f00000e67 pushl $L271 ! 428: 409 0002430B fe 08 ef00000718 callf $8,_print_mull2_error ! 429: 410 00024312 # } ! 430: 411 00024312 # if ( halt_flg ) /* halt on error? */ ! 431: 412 00024312 L270: ! 432: 413 00024312 5d effffffc1c tstl _halt_flg ! 433: 414 00024318 31 09 jeql L272 ! 434: 415 0002431A # mull2_halt( 1 ); ! 435: 416 0002431A dd 01 pushl $1 ! 436: 417 0002431C fe 08 ef0000080d callf $8,_mull2_halt ! 437: 418 00024323 # if ( loop_on_err ) { ! 438: 419 00024323 L272: ! 439: 420 00024323 5d effffffc0b tstl _loop_on_err ! 440: 421 00024329 31 0d jeql L273 ! 441: 422 0002432B # force_loop = TRUE; /* set the force loop flag */ ! 442: 423 0002432B 0d 01 effffffc02 movl $1,_force_loop ! 443: 424 00024332 # asm("jmp _mull2_2_lp1"); /* and loop */ ! 444: 425 00024332 71 effffffe8b jmp _mull2_2_lp1 ! 445: 426 00024338 # } /* end of loop-on-error */ ! 446: 427 00024338 # } /* end of multiply error */ ! 447: 428 00024338 L273: ! 448: 429 00024338 # } ! 449: 430 00024338 L269: ! 450: 431 00024338 L257: ! 451: 432 00024338 6d effffffbf6 incl _index ! 452: 433 0002433E 13 fe0d jbr L259 ! 453: 434 00024341 L258: ! 454: 435 00024341 # } /* end of subtest 2 */ ! 455: 436 00024341 40 ret#2 ! 456: 437 00024342 .set L253,0x0 ! 457: 438 00024342 L255: ! 458: 439 00024342 13 fdf6 jbr L256 ! 459: 440 00024345 .data ! 460: 441 00000d58 * .text ! 461: 442 00024345 00 .align 1 ! 462: 443 00024346 .globl _mull2_3 ! 463: 444 00024346 _mull2_3: ! 464: 445 00024346 0000 .word L274 ! 465: 446 00024348 # ! 466: 447 00024348 # ! 467: 448 00024348 # ! 468: 449 00024348 # /************************************************************************ ! 469: 450 00024348 # * ! 470: 451 00024348 # * SUBTEST 3 - register corruption test ! 471: 452 00024348 # * ! 472: 453 00024348 # ************************************************************************/ ! 473: 454 00024348 # mull2_3() ! 474: 455 00024348 # { ! 475: 456 00024348 13 018e jbr L276 ! 476: 457 0002434B L277: ! 477: 458 0002434B # force_loop = FALSE; ! 478: 459 0002434B 4d effffffbe3 clrl _force_loop ! 479: 460 00024351 # subtest = 3; ! 480: 461 00024351 0d 03 effffffbdc movl $3,_subtest ! 481: 462 00024358 # fill_reg_buf( load_regs ); /* get pattern for registers */ ! 482: 463 00024358 dd 8f00000000 pushl $_load_regs ! 483: 464 0002435E fe 08 effffffbcf callf $8,_fill_reg_buf ! 484: 465 00024365 # for( index = 0; index < max_mull_1_index; index++ ) { ! 485: 466 00024365 4d effffffbc9 clrl _index ! 486: 467 0002436B L281: ! 487: 468 0002436B 1d effffffbc3 effffffbbe cmpl _index,_max_mull_1_index ! 488: 469 00024376 91 03 13 015d jgeq L280 ! 489: 470 0002437B # sgl_value_1 = mull_1_data[index].op_1; /* get operand 1 */ ! 490: 471 0002437B 5c 0c effffffbb2 50 mull3 $12,_index,r0 ! 491: 472 00024383 0d e000000000 effffffba6 movl _mull_1_data(r0),_sgl_value_1 ! 492: 473 0002438E # sgl_value_2 = mull_1_data[index].op_2; /* get operand 2 */ ! 493: 474 0002438E 5c 0c effffffb9f 50 mull3 $12,_index,r0 ! 494: 475 00024396 0d e000000004 effffffb93 movl _mull_1_data+4(r0),_sgl_value_2 ! 495: 476 000243A1 # sgl_value_4 = mull_1_data[index].exp; /* get expected results */ ! 496: 477 000243A1 5c 0c effffffb8c 50 mull3 $12,_index,r0 ! 497: 478 000243A9 0d e000000008 effffffb80 movl _mull_1_data+8(r0),_sgl_value_4 ! 498: 479 000243B4 # /* ! 499: 480 000243B4 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 500: 481 000243B4 # */ ! 501: 482 000243B4 # asm("_mull2_3_lp1:"); ! 502: 483 000243B4 _mull2_3_lp1: ! 503: 484 000243B4 # sgl_value_3 = sgl_value_2; /* set operand 2 */ ! 504: 485 000243B4 0d effffffb7a effffffb75 movl _sgl_value_2,_sgl_value_3 ! 505: 486 000243BF # asm("loadr $0x1fff,_load_regs"); /* load regs 0 - 12 */ ! 506: 487 000243BF ab 891fff effffffb6c loadr $0x1fff,_load_regs ! 507: 488 000243C8 # asm("mull2 _sgl_value_1,_sgl_value_3");/* do the multiply */ ! 508: 489 000243C8 4c effffffb66 effffffb61 mull2 _sgl_value_1,_sgl_value_3 ! 509: 490 000243D3 # asm("nop"); ! 510: 491 000243D3 10 nop ! 511: 492 000243D4 # asm("storer $0x1fff,_store_regs"); /* store regs 0 - 12 */ ! 512: 493 000243D4 bb 891fff effffffb57 storer $0x1fff,_store_regs ! 513: 494 000243DD # if( force_loop ) ! 514: 495 000243DD 5d effffffb51 tstl _force_loop ! 515: 496 000243E3 31 02 jeql L282 ! 516: 497 000243E5 # asm("brb _mull2_3_lp1"); ! 517: 498 000243E5 11 cd brb _mull2_3_lp1 ! 518: 499 000243E7 # /* ! 519: 500 000243E7 # * Now check the result ! 520: 501 000243E7 # */ ! 521: 502 000243E7 # index2 = 0; ! 522: 503 000243E7 L282: ! 523: 504 000243E7 4d effffffb47 clrl _index2 ! 524: 505 000243ED # while( (load_regs[index2] == store_regs[index2]) && (index2 < 13) ) ! 525: 506 000243ED L283: ! 526: 507 000243ED 0d effffffb41 50 movl _index2,r0 ! 527: 508 000243F4 0d effffffb3a 51 movl _index2,r1 ! 528: 509 000243FB 1d 40effffffb32 cmpl _load_regs[r0],_store_regs[r1] ! 529: 41effffffb2c ! 530: 510 00024408 21 11 jneq L284 ! 531: 511 0002440A 1d effffffb24 0d cmpl _index2,$13 ! 532: 512 00024411 81 08 jgeq L284 ! 533: 513 00024413 # index2++; /* check reg values */ ! 534: 514 00024413 6d effffffb1b incl _index2 ! 535: 515 00024419 11 d2 jbr L283 ! 536: 516 0002441B L284: ! 537: 517 0002441B # if( index2 < 13 ) { /* error if index2 < 13 */ ! 538: 518 0002441B 1d effffffb13 0d cmpl _index2,$13 ! 539: 519 00024422 91 03 13 00a8 jgeq L285 ! 540: 520 00024427 # errcnt++; /* bump the error count */ ! 541: 521 00024427 6d effffffb07 incl _errcnt ! 542: 522 0002442D # if ( prt_error ) { ! 543: 523 0002442D 5d effffffb01 tstl _prt_error ! 544: 524 00024433 31 74 jeql L286 ! 545: 525 00024435 # print_mull2_error(" -A REGISTER WAS MODIFIED"); ! 546: 526 00024435 .data 1 ! 547: 527 00000e8a * L287: ! 548: 528 00000e8a * 202D412052454749535445522 .ascii " -A REGISTER WAS MODIFIED\0" ! 549: 0574153204D4F444946494544 ! 550: 00 ! 551: 529 00000ea4 * .text ! 552: 530 00024435 dd 8f00000e8a pushl $L287 ! 553: 531 0002443B fe 08 ef000005e8 callf $8,_print_mull2_error ! 554: 532 00024442 # writes("register "); ! 555: 533 00024442 .data 1 ! 556: 534 00000ea4 * L288: ! 557: 535 00000ea4 * 72656769737465722000 .ascii "register \0" ! 558: 536 00000eae * .text ! 559: 537 00024442 dd 8f00000ea4 pushl $L288 ! 560: 538 00024448 fe 08 effffffae5 callf $8,_writes ! 561: 539 0002444F # writeh( index2 ); ! 562: 540 0002444F dd effffffadf pushl _index2 ! 563: 541 00024455 fe 08 effffffad8 callf $8,_writeh ! 564: 542 0002445C # writes(" = "); ! 565: 543 0002445C .data 1 ! 566: 544 00000eae * L290: ! 567: 545 00000eae * 203D2000 .ascii " = \0" ! 568: 546 00000eb2 * .text ! 569: 547 0002445C dd 8f00000eae pushl $L290 ! 570: 548 00024462 fe 08 effffffacb callf $8,_writes ! 571: 549 00024469 # write32h( store_regs[index2] ); ! 572: 550 00024469 0d effffffac5 50 movl _index2,r0 ! 573: 551 00024470 dd 40effffffabd pushl _store_regs[r0] ! 574: 552 00024477 fe 08 effffffab6 callf $8,_write32h ! 575: 553 0002447E # writes(", should be = "); ! 576: 554 0002447E .data 1 ! 577: 555 00000eb2 * L291: ! 578: 556 00000eb2 * 2C202073686F756C642062652 .ascii ", should be = \0" ! 579: 03D2000 ! 580: 557 00000ec2 * .text ! 581: 558 0002447E dd 8f00000eb2 pushl $L291 ! 582: 559 00024484 fe 08 effffffaa9 callf $8,_writes ! 583: 560 0002448B # write32h( load_regs[index2] ); ! 584: 561 0002448B 0d effffffaa3 50 movl _index2,r0 ! 585: 562 00024492 dd 40effffffa9b pushl _load_regs[r0] ! 586: 563 00024499 fe 08 effffffa94 callf $8,_write32h ! 587: 564 000244A0 # writec('\n'); ! 588: 565 000244A0 dd 0a pushl $10 ! 589: 566 000244A2 fe 08 effffffa8b callf $8,_writec ! 590: 567 000244A9 # } ! 591: 568 000244A9 # if ( halt_flg ) /* halt on error? */ ! 592: 569 000244A9 L286: ! 593: 570 000244A9 5d effffffa85 tstl _halt_flg ! 594: 571 000244AF 31 09 jeql L292 ! 595: 572 000244B1 # mull2_halt( 2 ); ! 596: 573 000244B1 dd 02 pushl $2 ! 597: 574 000244B3 fe 08 ef00000676 callf $8,_mull2_halt ! 598: 575 000244BA # if ( loop_on_err ) { ! 599: 576 000244BA L292: ! 600: 577 000244BA 5d effffffa74 tstl _loop_on_err ! 601: 578 000244C0 31 0d jeql L293 ! 602: 579 000244C2 # force_loop = TRUE; /* set the force loop flag */ ! 603: 580 000244C2 0d 01 effffffa6b movl $1,_force_loop ! 604: 581 000244C9 # asm("jmp _mull2_3_lp1"); /* and loop */ ! 605: 582 000244C9 71 effffffee5 jmp _mull2_3_lp1 ! 606: 583 000244CF # }; /* end of loop-on-error */ ! 607: 584 000244CF L293: ! 608: 585 000244CF # } /* end of multiply error */ ! 609: 586 000244CF # } ! 610: 587 000244CF L285: ! 611: 588 000244CF L279: ! 612: 589 000244CF 6d effffffa5f incl _index ! 613: 590 000244D5 13 fe93 jbr L281 ! 614: 591 000244D8 L280: ! 615: 592 000244D8 # } /* end of subtest 3 */ ! 616: 593 000244D8 40 ret#2 ! 617: 594 000244D9 .set L274,0x0 ! 618: 595 000244D9 L276: ! 619: 596 000244D9 13 fe6f jbr L277 ! 620: 597 000244DC .data ! 621: 598 00000d58 * .text ! 622: 599 000244DC .align 1 ! 623: 600 000244DC .globl _mull2_4 ! 624: 601 000244DC _mull2_4: ! 625: 602 000244DC 0000 .word L294 ! 626: 603 000244DE # ! 627: 604 000244DE # ! 628: 605 000244DE # ! 629: 606 000244DE # /************************************************************************ ! 630: 607 000244DE # * ! 631: 608 000244DE # * SUBTEST 4 - PSL corruption test ! 632: 609 000244DE # * ! 633: 610 000244DE # ************************************************************************/ ! 634: 611 000244DE # mull2_4() ! 635: 612 000244DE # { ! 636: 613 000244DE 13 01a2 jbr L296 ! 637: 614 000244E1 L297: ! 638: 615 000244E1 # force_loop = FALSE; ! 639: 616 000244E1 4d effffffa4d clrl _force_loop ! 640: 617 000244E7 # subtest = 4; ! 641: 618 000244E7 0d 04 effffffa46 movl $4,_subtest ! 642: 619 000244EE # status_index = 0; ! 643: 620 000244EE 4d effffffa40 clrl _status_index ! 644: 621 000244F4 # for( index = 0; index < max_mull_1_index; index++ ) { ! 645: 622 000244F4 4d effffffa3a clrl _index ! 646: 623 000244FA L300: ! 647: 624 000244FA 1d effffffa34 effffffa2f cmpl _index,_max_mull_1_index ! 648: 625 00024505 91 03 13 0178 jgeq L299 ! 649: 626 0002450A # sgl_value_1 = mull_1_data[index].op_1; /* get operand 1 */ ! 650: 627 0002450A 5c 0c effffffa23 50 mull3 $12,_index,r0 ! 651: 628 00024512 0d e000000000 effffffa17 movl _mull_1_data(r0),_sgl_value_1 ! 652: 629 0002451D # sgl_value_2 = mull_1_data[index].op_2; /* get operand 2 */ ! 653: 630 0002451D 5c 0c effffffa10 50 mull3 $12,_index,r0 ! 654: 631 00024525 0d e000000004 effffffa04 movl _mull_1_data+4(r0),_sgl_value_2 ! 655: 632 00024530 # sgl_value_4 = mull_1_data[index].exp; /* get expected results */ ! 656: 633 00024530 5c 0c effffff9fd 50 mull3 $12,_index,r0 ! 657: 634 00024538 0d e000000008 effffff9f1 movl _mull_1_data+8(r0),_sgl_value_4 ! 658: 635 00024543 # sgl_dummy1 = status_array[status_index]; /* status = +, -, 0 */ ! 659: 636 00024543 0d effffff9eb 50 movl _status_index,r0 ! 660: 637 0002454A 0d 40effffff9e3 movl _status_array[r0],_sgl_dummy1 ! 661: effffff9de ! 662: 638 00024556 # /* ! 663: 639 00024556 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 664: 640 00024556 # */ ! 665: 641 00024556 # asm("_mull2_4_lp1:"); ! 666: 642 00024556 _mull2_4_lp1: ! 667: 643 00024556 # sgl_value_3 = sgl_value_2; /* set operand 2 */ ! 668: 644 00024556 0d effffff9d8 effffff9d3 movl _sgl_value_2,_sgl_value_3 ! 669: 645 00024561 # asm("tstl _sgl_dummy1"); ! 670: 646 00024561 5d effffff9cd tstl _sgl_dummy1 ! 671: 647 00024567 # asm("movpsl _init_psl"); /* save the initial PSL */ ! 672: 648 00024567 cd effffff9c7 movpsl _init_psl ! 673: 649 0002456D # asm("mull2 _sgl_value_1,_sgl_value_3");/* do the multiply */ ! 674: 650 0002456D 4c effffff9c1 effffff9bc mull2 _sgl_value_1,_sgl_value_3 ! 675: 651 00024578 # asm("movpsl _psl_val"); /* save the final PSL */ ! 676: 652 00024578 cd effffff9b6 movpsl _psl_val ! 677: 653 0002457E # if( force_loop ) ! 678: 654 0002457E 5d effffff9b0 tstl _force_loop ! 679: 655 00024584 31 02 jeql L301 ! 680: 656 00024586 # asm("brb _mull2_4_lp1"); ! 681: 657 00024586 11 ce brb _mull2_4_lp1 ! 682: 658 00024588 # /* ! 683: 659 00024588 # * Now check the result ! 684: 660 00024588 # */ ! 685: 661 00024588 # exp_psl = init_psl & 0xffffff3; /* strip off the PSL status */ ! 686: 662 00024588 L301: ! 687: 663 00024588 bc 8f0ffffff3 effffff9a1 andl3 $268435443,_init_psl,r0 ! 688: 50 ! 689: 664 00024594 0d 50 effffff999 movl r0,_exp_psl ! 690: 665 0002459B # if( sgl_value_4 < 0 ) /* check the MULL result */ ! 691: 666 0002459B 5d effffff993 tstl _sgl_value_4 ! 692: 667 000245A1 81 07 jgeq L302 ! 693: 668 000245A3 # exp_psl |= PSL_N; /* set the NEGATIVE bit */ ! 694: 669 000245A3 8c 08 effffff98a orl2 $8,_exp_psl ! 695: 670 000245AA # if( !sgl_value_4 ) ! 696: 671 000245AA L302: ! 697: 672 000245AA 5d effffff984 tstl _sgl_value_4 ! 698: 673 000245B0 21 07 jneq L303 ! 699: 674 000245B2 # exp_psl |= PSL_Z; /* set the ZERO bit */ ! 700: 675 000245B2 8c 04 effffff97b orl2 $4,_exp_psl ! 701: 676 000245B9 # if( psl_val != exp_psl ) { /* was the final PSL correct */ ! 702: 677 000245B9 L303: ! 703: 678 000245B9 1d effffff975 effffff970 cmpl _psl_val,_exp_psl ! 704: 679 000245C4 21 03 13 0098 jeql L304 ! 705: 680 000245C9 # errcnt++; /* bump the error count */ ! 706: 681 000245C9 6d effffff965 incl _errcnt ! 707: 682 000245CF # if ( prt_error ) { ! 708: 683 000245CF 5d effffff95f tstl _prt_error ! 709: 684 000245D5 31 64 jeql L305 ! 710: 685 000245D7 # print_mull2_error(" -INCORRECT FINAL PSL"); ! 711: 686 000245D7 .data 1 ! 712: 687 00000ec2 * L306: ! 713: 688 00000ec2 * 202D494E434F5252454354204 .ascii " -INCORRECT FINAL PSL\0" ! 714: 6494E414C2050534C00 ! 715: 689 00000ed8 * .text ! 716: 690 000245D7 dd 8f00000ec2 pushl $L306 ! 717: 691 000245DD fe 08 ef00000446 callf $8,_print_mull2_error ! 718: 692 000245E4 # writes("initial PSL = "); ! 719: 693 000245E4 .data 1 ! 720: 694 00000ed8 * L307: ! 721: 695 00000ed8 * 696E697469616C2050534C203 .ascii "initial PSL = \0" ! 722: D2000 ! 723: 696 00000ee7 * .text ! 724: 697 000245E4 dd 8f00000ed8 pushl $L307 ! 725: 698 000245EA fe 08 effffff943 callf $8,_writes ! 726: 699 000245F1 # write32h( init_psl ); ! 727: 700 000245F1 dd effffff93d pushl _init_psl ! 728: 701 000245F7 fe 08 effffff936 callf $8,_write32h ! 729: 702 000245FE # writes(", final PSL = "); ! 730: 703 000245FE .data 1 ! 731: 704 00000ee7 * L308: ! 732: 705 00000ee7 * 2C202066696E616C2050534C2 .ascii ", final PSL = \0" ! 733: 03D2000 ! 734: 706 00000ef7 * .text ! 735: 707 000245FE dd 8f00000ee7 pushl $L308 ! 736: 708 00024604 fe 08 effffff929 callf $8,_writes ! 737: 709 0002460B # write32h( psl_val ); ! 738: 710 0002460B dd effffff923 pushl _psl_val ! 739: 711 00024611 fe 08 effffff91c callf $8,_write32h ! 740: 712 00024618 # writes(", expected PSL = "); ! 741: 713 00024618 .data 1 ! 742: 714 00000ef7 * L309: ! 743: 715 00000ef7 * 2C20206578706563746564205 .ascii ", expected PSL = \0" ! 744: 0534C203D2000 ! 745: 716 00000f0a * .text ! 746: 717 00024618 dd 8f00000ef7 pushl $L309 ! 747: 718 0002461E fe 08 effffff90f callf $8,_writes ! 748: 719 00024625 # write32h( exp_psl ); ! 749: 720 00024625 dd effffff909 pushl _exp_psl ! 750: 721 0002462B fe 08 effffff902 callf $8,_write32h ! 751: 722 00024632 # writec('\n'); ! 752: 723 00024632 dd 0a pushl $10 ! 753: 724 00024634 fe 08 effffff8f9 callf $8,_writec ! 754: 725 0002463B # } ! 755: 726 0002463B # if ( halt_flg ) /* halt on error? */ ! 756: 727 0002463B L305: ! 757: 728 0002463B 5d effffff8f3 tstl _halt_flg ! 758: 729 00024641 31 09 jeql L310 ! 759: 730 00024643 # mull2_halt( 3 ); ! 760: 731 00024643 dd 03 pushl $3 ! 761: 732 00024645 fe 08 ef000004e4 callf $8,_mull2_halt ! 762: 733 0002464C # if ( loop_on_err ) { ! 763: 734 0002464C L310: ! 764: 735 0002464C 5d effffff8e2 tstl _loop_on_err ! 765: 736 00024652 31 0d jeql L311 ! 766: 737 00024654 # force_loop = TRUE; /* set the force loop flag */ ! 767: 738 00024654 0d 01 effffff8d9 movl $1,_force_loop ! 768: 739 0002465B # asm("jmp _mull2_4_lp1"); /* and loop */ ! 769: 740 0002465B 71 effffffef5 jmp _mull2_4_lp1 ! 770: 741 00024661 # }; /* end of loop-on-error */ ! 771: 742 00024661 L311: ! 772: 743 00024661 # }; /* end of error */ ! 773: 744 00024661 L304: ! 774: 745 00024661 # if( ++status_index >= 3 ) ! 775: 746 00024661 6d effffff8cd incl _status_index ! 776: 747 00024667 0d effffff8c7 50 movl _status_index,r0 ! 777: 748 0002466E 1d 50 03 cmpl r0,$3 ! 778: 749 00024671 91 06 jlss L312 ! 779: 750 00024673 # status_index = 0; ! 780: 751 00024673 4d effffff8bb clrl _status_index ! 781: 752 00024679 # } ! 782: 753 00024679 L312: ! 783: 754 00024679 L298: ! 784: 755 00024679 6d effffff8b5 incl _index ! 785: 756 0002467F 13 fe78 jbr L300 ! 786: 757 00024682 L299: ! 787: 758 00024682 # } /* end of subtest 4 */ ! 788: 759 00024682 40 ret#2 ! 789: 760 00024683 .set L294,0x0 ! 790: 761 00024683 L296: ! 791: 762 00024683 13 fe5b jbr L297 ! 792: 763 00024686 .data ! 793: 764 00000d58 * .text ! 794: 765 00024686 .align 1 ! 795: 766 00024686 .globl _mull2_5 ! 796: 767 00024686 _mull2_5: ! 797: 768 00024686 0000 .word L313 ! 798: 769 00024688 # ! 799: 770 00024688 # ! 800: 771 00024688 # ! 801: 772 00024688 # /************************************************************************ ! 802: 773 00024688 # * ! 803: 774 00024688 # * SUBTEST 5 - Pipelined Entry test ! 804: 775 00024688 # * ! 805: 776 00024688 # ************************************************************************/ ! 806: 777 00024688 # mull2_5() ! 807: 778 00024688 # { ! 808: 779 00024688 13 01ca jbr L315 ! 809: 780 0002468B L316: ! 810: 781 0002468B # force_loop = FALSE; ! 811: 782 0002468B 4d effffff8a3 clrl _force_loop ! 812: 783 00024691 # subtest = 5; ! 813: 784 00024691 0d 05 effffff89c movl $5,_subtest ! 814: 785 00024698 # for( index = 0; index < max_mull_1_index; index++ ) { ! 815: 786 00024698 4d effffff896 clrl _index ! 816: 787 0002469E L319: ! 817: 788 0002469E 1d effffff890 effffff88b cmpl _index,_max_mull_1_index ! 818: 789 000246A9 91 03 13 01a6 jgeq L318 ! 819: 790 000246AE # sgl_value_1 = mull_1_data[index].op_1; /* get operand 1 */ ! 820: 791 000246AE 5c 0c effffff87f 50 mull3 $12,_index,r0 ! 821: 792 000246B6 0d e000000000 effffff873 movl _mull_1_data(r0),_sgl_value_1 ! 822: 793 000246C1 # sgl_value_2 = mull_1_data[index].op_2; /* get operand 2 */ ! 823: 794 000246C1 5c 0c effffff86c 50 mull3 $12,_index,r0 ! 824: 795 000246C9 0d e000000004 effffff860 movl _mull_1_data+4(r0),_sgl_value_2 ! 825: 796 000246D4 # sgl_value_4 = mull_1_data[index].exp; /* get expected results */ ! 826: 797 000246D4 5c 0c effffff859 50 mull3 $12,_index,r0 ! 827: 798 000246DC 0d e000000008 effffff84d movl _mull_1_data+8(r0),_sgl_value_4 ! 828: 799 000246E7 # sgl_ld_acc = 0x12345678; /* set acc data pattern */ ! 829: 800 000246E7 0d 8f12345678 effffff842 movl $305419896,_sgl_ld_acc ! 830: 801 000246F2 # sgl_expected = sgl_ld_acc; /* final Acc expected */ ! 831: 802 000246F2 0d effffff83c effffff837 movl _sgl_ld_acc,_sgl_expected ! 832: 803 000246FD # sgl_value_10 = 0x40800000; /* floating "1.0" */ ! 833: 804 000246FD 0d 8f40800000 effffff82c movl $1082130432,_sgl_value_10 ! 834: 805 00024708 # /* ! 835: 806 00024708 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 836: 807 00024708 # */ ! 837: 808 00024708 # asm("_mull2_5_lp1:"); ! 838: 809 00024708 _mull2_5_lp1: ! 839: 810 00024708 # sgl_value_3 = sgl_value_2; /* set integer operand 2 */ ! 840: 811 00024708 0d effffff826 effffff821 movl _sgl_value_2,_sgl_value_3 ! 841: 812 00024713 # asm("ldf _sgl_ld_acc"); /* load the acc */ ! 842: 813 00024713 06 effffff81b ldf _sgl_ld_acc ! 843: 814 00024719 # asm("mulf _sgl_value_10"); /* do a floating multiply */ ! 844: 815 00024719 e6 effffff815 mulf _sgl_value_10 ! 845: 816 0002471F # asm("mull2 _sgl_value_1,_sgl_value_3"); /* do the int. multiply */ ! 846: 817 0002471F 4c effffff80f effffff80a mull2 _sgl_value_1,_sgl_value_3 ! 847: 818 0002472A # asm("nop"); ! 848: 819 0002472A 10 nop ! 849: 820 0002472B # asm("stf _sgl_st_acc"); /* save the acc */ ! 850: 821 0002472B 26 effffff803 stf _sgl_st_acc ! 851: 822 00024731 # if( force_loop ) ! 852: 823 00024731 5d effffff7fd tstl _force_loop ! 853: 824 00024737 31 02 jeql L320 ! 854: 825 00024739 # asm("brb _mull2_5_lp1");; ! 855: 826 00024739 11 cd brb _mull2_5_lp1 ! 856: 827 0002473B L320: ! 857: 828 0002473B # if( sgl_expected != sgl_st_acc ) { /* COMPARE the values */ ! 858: 829 0002473B 1d effffff7f3 effffff7ee cmpl _sgl_expected,_sgl_st_acc ! 859: 830 00024746 21 03 13 00b2 jeql L321 ! 860: 831 0002474B # errcnt++; /* bump the error count */ ! 861: 832 0002474B 6d effffff7e3 incl _errcnt ! 862: 833 00024751 # if ( prt_error ) { ! 863: 834 00024751 5d effffff7dd tstl _prt_error ! 864: 835 00024757 31 7e jeql L322 ! 865: 836 00024759 # print_mull2_error("(Piped Entry) -BAD FINAL ACC"); ! 866: 837 00024759 .data 1 ! 867: 838 00000f0a * L323: ! 868: 839 00000f0a * 28506970656420456E7472792 .ascii "(Piped Entry) -BAD FINAL ACC\0" ! 869: 9202D4241442046494E414C20 ! 870: 41434300 ! 871: 840 00000f27 * .text ! 872: 841 00024759 dd 8f00000f0a pushl $L323 ! 873: 842 0002475F fe 08 ef000002c4 callf $8,_print_mull2_error ! 874: 843 00024766 # writes("initial Acc = "); ! 875: 844 00024766 .data 1 ! 876: 845 00000f27 * L324: ! 877: 846 00000f27 * 696E697469616C20416363203 .ascii "initial Acc = \0" ! 878: D2000 ! 879: 847 00000f36 * .text ! 880: 848 00024766 dd 8f00000f27 pushl $L324 ! 881: 849 0002476C fe 08 effffff7c1 callf $8,_writes ! 882: 850 00024773 # write32h( sgl_ld_acc ); ! 883: 851 00024773 dd effffff7bb pushl _sgl_ld_acc ! 884: 852 00024779 fe 08 effffff7b4 callf $8,_write32h ! 885: 853 00024780 # writes(", final Acc = "); ! 886: 854 00024780 .data 1 ! 887: 855 00000f36 * L325: ! 888: 856 00000f36 * 2C202020202066696E616C204 .ascii ", final Acc = \0" ! 889: 16363203D2000 ! 890: 857 00000f49 * .text ! 891: 858 00024780 dd 8f00000f36 pushl $L325 ! 892: 859 00024786 fe 08 effffff7a7 callf $8,_writes ! 893: 860 0002478D # write32h( sgl_st_acc ); ! 894: 861 0002478D dd effffff7a1 pushl _sgl_st_acc ! 895: 862 00024793 fe 08 effffff79a callf $8,_write32h ! 896: 863 0002479A # writes("\nFPP operand = "); ! 897: 864 0002479A .data 1 ! 898: 865 00000f49 * L326: ! 899: 866 00000f49 * 0A465050206F706572616E642 .ascii "\12FPP operand = \0" ! 900: 03D2000 ! 901: 867 00000f59 * .text ! 902: 868 0002479A dd 8f00000f49 pushl $L326 ! 903: 869 000247A0 fe 08 effffff78d callf $8,_writes ! 904: 870 000247A7 # write32h( sgl_value_10 ); ! 905: 871 000247A7 dd effffff787 pushl _sgl_value_10 ! 906: 872 000247AD fe 08 effffff780 callf $8,_write32h ! 907: 873 000247B4 # writes(", expected Acc = "); ! 908: 874 000247B4 .data 1 ! 909: 875 00000f59 * L327: ! 910: 876 00000f59 * 2C20206578706563746564204 .ascii ", expected Acc = \0" ! 911: 16363203D2000 ! 912: 877 00000f6c * .text ! 913: 878 000247B4 dd 8f00000f59 pushl $L327 ! 914: 879 000247BA fe 08 effffff773 callf $8,_writes ! 915: 880 000247C1 # write32h( sgl_expected ); ! 916: 881 000247C1 dd effffff76d pushl _sgl_expected ! 917: 882 000247C7 fe 08 effffff766 callf $8,_write32h ! 918: 883 000247CE # writec('\n'); ! 919: 884 000247CE dd 0a pushl $10 ! 920: 885 000247D0 fe 08 effffff75d callf $8,_writec ! 921: 886 000247D7 # } ! 922: 887 000247D7 # if ( halt_flg ) /* halt on error? */ ! 923: 888 000247D7 L322: ! 924: 889 000247D7 5d effffff757 tstl _halt_flg ! 925: 890 000247DD 31 09 jeql L328 ! 926: 891 000247DF # mull2_halt( 5 ); ! 927: 892 000247DF dd 05 pushl $5 ! 928: 893 000247E1 fe 08 ef00000348 callf $8,_mull2_halt ! 929: 894 000247E8 # if ( loop_on_err ) { ! 930: 895 000247E8 L328: ! 931: 896 000247E8 5d effffff746 tstl _loop_on_err ! 932: 897 000247EE 31 0d jeql L329 ! 933: 898 000247F0 # force_loop = TRUE; /* set the force loop flag */ ! 934: 899 000247F0 0d 01 effffff73d movl $1,_force_loop ! 935: 900 000247F7 # asm("jmp _mull2_5_lp1"); /* and loop */ ! 936: 901 000247F7 71 efffffff0b jmp _mull2_5_lp1 ! 937: 902 000247FD # } /* end of loop-on-error */ ! 938: 903 000247FD # } /* end of acc corr error */ ! 939: 904 000247FD L329: ! 940: 905 000247FD # if( sgl_value_4 != sgl_value_3 ) /* COMPARE the values */ ! 941: 906 000247FD L321: ! 942: 907 000247FD 1d effffff731 effffff72c cmpl _sgl_value_4,_sgl_value_3 ! 943: 908 00024808 31 41 jeql L330 ! 944: 909 0002480A # { ! 945: 910 0002480A # errcnt++; /* bump the error count */ ! 946: 911 0002480A 6d effffff724 incl _errcnt ! 947: 912 00024810 # if ( prt_error ) { ! 948: 913 00024810 5d effffff71e tstl _prt_error ! 949: 914 00024816 31 0d jeql L331 ! 950: 915 00024818 # print_mull2_error("(Piped Entry) -BAD MULTIPLY RESULT"); ! 951: 916 00024818 .data 1 ! 952: 917 00000f6c * L332: ! 953: 918 00000f6c * 28506970656420456E7472792 .ascii "(Piped Entry) -BAD MULTIPLY RESULT\0" ! 954: 9202D424144204D554C544950 ! 955: 4C5920524553554C5400 ! 956: 919 00000f8f * .text ! 957: 920 00024818 dd 8f00000f6c pushl $L332 ! 958: 921 0002481E fe 08 ef00000205 callf $8,_print_mull2_error ! 959: 922 00024825 # } ! 960: 923 00024825 # if ( halt_flg ) /* halt on error? */ ! 961: 924 00024825 L331: ! 962: 925 00024825 5d effffff709 tstl _halt_flg ! 963: 926 0002482B 31 09 jeql L333 ! 964: 927 0002482D # mull2_halt( 1 ); ! 965: 928 0002482D dd 01 pushl $1 ! 966: 929 0002482F fe 08 ef000002fa callf $8,_mull2_halt ! 967: 930 00024836 # if ( loop_on_err ) { ! 968: 931 00024836 L333: ! 969: 932 00024836 5d effffff6f8 tstl _loop_on_err ! 970: 933 0002483C 31 0d jeql L334 ! 971: 934 0002483E # force_loop = TRUE; /* set the force loop flag */ ! 972: 935 0002483E 0d 01 effffff6ef movl $1,_force_loop ! 973: 936 00024845 # asm("jmp _mull2_5_lp1"); /* and loop */ ! 974: 937 00024845 71 effffffebd jmp _mull2_5_lp1 ! 975: 938 0002484B # } /* end of loop-on-error */ ! 976: 939 0002484B # } /* end of multiply error */ ! 977: 940 0002484B L334: ! 978: 941 0002484B # } ! 979: 942 0002484B L330: ! 980: 943 0002484B L317: ! 981: 944 0002484B 6d effffff6e3 incl _index ! 982: 945 00024851 13 fe4a jbr L319 ! 983: 946 00024854 L318: ! 984: 947 00024854 # } /* end of subtest 5 */ ! 985: 948 00024854 40 ret#2 ! 986: 949 00024855 .set L313,0x0 ! 987: 950 00024855 L315: ! 988: 951 00024855 13 fe33 jbr L316 ! 989: 952 00024858 .data ! 990: 953 00000d58 * .text ! 991: 954 00024858 .align 1 ! 992: 955 00024858 .globl _mull2_6 ! 993: 956 00024858 _mull2_6: ! 994: 957 00024858 0000 .word L335 ! 995: 958 0002485A # ! 996: 959 0002485A # ! 997: 960 0002485A # ! 998: 961 0002485A # /************************************************************************ ! 999: 962 0002485A # * ! 1000: 963 0002485A # * SUBTEST 6 - Pipelined Exit test ! 1001: 964 0002485A # * ! 1002: 965 0002485A # ************************************************************************/ ! 1003: 966 0002485A # mull2_6() ! 1004: 967 0002485A # { ! 1005: 968 0002485A 13 01c9 jbr L337 ! 1006: 969 0002485D L338: ! 1007: 970 0002485D # force_loop = FALSE; ! 1008: 971 0002485D 4d effffff6d1 clrl _force_loop ! 1009: 972 00024863 # subtest = 6; ! 1010: 973 00024863 0d 06 effffff6ca movl $6,_subtest ! 1011: 974 0002486A # for( index = 0; index < max_mull_1_index; index++ ) { ! 1012: 975 0002486A 4d effffff6c4 clrl _index ! 1013: 976 00024870 L341: ! 1014: 977 00024870 1d effffff6be effffff6b9 cmpl _index,_max_mull_1_index ! 1015: 978 0002487B 91 03 13 01a5 jgeq L340 ! 1016: 979 00024880 # sgl_value_1 = mull_1_data[index].op_1; /* get operand 1 */ ! 1017: 980 00024880 5c 0c effffff6ad 50 mull3 $12,_index,r0 ! 1018: 981 00024888 0d e000000000 effffff6a1 movl _mull_1_data(r0),_sgl_value_1 ! 1019: 982 00024893 # sgl_value_2 = mull_1_data[index].op_2; /* get operand 2 */ ! 1020: 983 00024893 5c 0c effffff69a 50 mull3 $12,_index,r0 ! 1021: 984 0002489B 0d e000000004 effffff68e movl _mull_1_data+4(r0),_sgl_value_2 ! 1022: 985 000248A6 # sgl_value_4 = mull_1_data[index].exp; /* get expected results */ ! 1023: 986 000248A6 5c 0c effffff687 50 mull3 $12,_index,r0 ! 1024: 987 000248AE 0d e000000008 effffff67b movl _mull_1_data+8(r0),_sgl_value_4 ! 1025: 988 000248B9 # sgl_ld_acc = 0x40800000; /* floating "1.0" */ ! 1026: 989 000248B9 0d 8f40800000 effffff670 movl $1082130432,_sgl_ld_acc ! 1027: 990 000248C4 # sgl_value_10 = 0x12345678; /* set acc data pattern */ ! 1028: 991 000248C4 0d 8f12345678 effffff665 movl $305419896,_sgl_value_10 ! 1029: 992 000248CF # sgl_expected = sgl_value_10; /* final Acc expected */ ! 1030: 993 000248CF 0d effffff65f effffff65a movl _sgl_value_10,_sgl_expected ! 1031: 994 000248DA # /* ! 1032: 995 000248DA # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 1033: 996 000248DA # */ ! 1034: 997 000248DA # asm("_mull2_6_lp1:"); ! 1035: 998 000248DA _mull2_6_lp1: ! 1036: 999 000248DA # sgl_value_3 = sgl_value_2; /* set integer operand 2 */ ! 1037: 1000 000248DA 0d effffff654 effffff64f movl _sgl_value_2,_sgl_value_3 ! 1038: 1001 000248E5 # asm("ldf _sgl_ld_acc"); /* load the acc */ ! 1039: 1002 000248E5 06 effffff649 ldf _sgl_ld_acc ! 1040: 1003 000248EB # asm("mull2 _sgl_value_1,_sgl_value_3"); /* do the int. multiply */ ! 1041: 1004 000248EB 4c effffff643 effffff63e mull2 _sgl_value_1,_sgl_value_3 ! 1042: 1005 000248F6 # asm("mulf _sgl_value_10"); /* do a floating multiply */ ! 1043: 1006 000248F6 e6 effffff638 mulf _sgl_value_10 ! 1044: 1007 000248FC # asm("stf _sgl_st_acc"); /* save the acc */ ! 1045: 1008 000248FC 26 effffff632 stf _sgl_st_acc ! 1046: 1009 00024902 # if( force_loop ) ! 1047: 1010 00024902 5d effffff62c tstl _force_loop ! 1048: 1011 00024908 31 02 jeql L342 ! 1049: 1012 0002490A # asm("brb _mull2_6_lp1");; ! 1050: 1013 0002490A 11 ce brb _mull2_6_lp1 ! 1051: 1014 0002490C L342: ! 1052: 1015 0002490C # if( sgl_expected != sgl_st_acc ) { /* COMPARE the values */ ! 1053: 1016 0002490C 1d effffff622 effffff61d cmpl _sgl_expected,_sgl_st_acc ! 1054: 1017 00024917 21 03 13 00b2 jeql L343 ! 1055: 1018 0002491C # errcnt++; /* bump the error count */ ! 1056: 1019 0002491C 6d effffff612 incl _errcnt ! 1057: 1020 00024922 # if ( prt_error ) { ! 1058: 1021 00024922 5d effffff60c tstl _prt_error ! 1059: 1022 00024928 31 7e jeql L344 ! 1060: 1023 0002492A # print_mull2_error("(Piped Exit) -BAD FINAL ACC"); ! 1061: 1024 0002492A .data 1 ! 1062: 1025 00000f8f * L345: ! 1063: 1026 00000f8f * 2850697065642045786974292 .ascii "(Piped Exit) -BAD FINAL ACC\0" ! 1064: 02D4241442046494E414C2041 ! 1065: 434300 ! 1066: 1027 00000fab * .text ! 1067: 1028 0002492A dd 8f00000f8f pushl $L345 ! 1068: 1029 00024930 fe 08 ef000000f3 callf $8,_print_mull2_error ! 1069: 1030 00024937 # writes("initial Acc = "); ! 1070: 1031 00024937 .data 1 ! 1071: 1032 00000fab * L346: ! 1072: 1033 00000fab * 696E697469616C20416363203 .ascii "initial Acc = \0" ! 1073: D2000 ! 1074: 1034 00000fba * .text ! 1075: 1035 00024937 dd 8f00000fab pushl $L346 ! 1076: 1036 0002493D fe 08 effffff5f0 callf $8,_writes ! 1077: 1037 00024944 # write32h( sgl_ld_acc ); ! 1078: 1038 00024944 dd effffff5ea pushl _sgl_ld_acc ! 1079: 1039 0002494A fe 08 effffff5e3 callf $8,_write32h ! 1080: 1040 00024951 # writes(", final Acc = "); ! 1081: 1041 00024951 .data 1 ! 1082: 1042 00000fba * L347: ! 1083: 1043 00000fba * 2C202020202066696E616C204 .ascii ", final Acc = \0" ! 1084: 16363203D2000 ! 1085: 1044 00000fcd * .text ! 1086: 1045 00024951 dd 8f00000fba pushl $L347 ! 1087: 1046 00024957 fe 08 effffff5d6 callf $8,_writes ! 1088: 1047 0002495E # write32h( sgl_st_acc ); ! 1089: 1048 0002495E dd effffff5d0 pushl _sgl_st_acc ! 1090: 1049 00024964 fe 08 effffff5c9 callf $8,_write32h ! 1091: 1050 0002496B # writes("\nFPP operand = "); ! 1092: 1051 0002496B .data 1 ! 1093: 1052 00000fcd * L348: ! 1094: 1053 00000fcd * 0A465050206F706572616E642 .ascii "\12FPP operand = \0" ! 1095: 03D2000 ! 1096: 1054 00000fdd * .text ! 1097: 1055 0002496B dd 8f00000fcd pushl $L348 ! 1098: 1056 00024971 fe 08 effffff5bc callf $8,_writes ! 1099: 1057 00024978 # write32h( sgl_value_10 ); ! 1100: 1058 00024978 dd effffff5b6 pushl _sgl_value_10 ! 1101: 1059 0002497E fe 08 effffff5af callf $8,_write32h ! 1102: 1060 00024985 # writes(", expected Acc = "); ! 1103: 1061 00024985 .data 1 ! 1104: 1062 00000fdd * L349: ! 1105: 1063 00000fdd * 2C20206578706563746564204 .ascii ", expected Acc = \0" ! 1106: 16363203D2000 ! 1107: 1064 00000ff0 * .text ! 1108: 1065 00024985 dd 8f00000fdd pushl $L349 ! 1109: 1066 0002498B fe 08 effffff5a2 callf $8,_writes ! 1110: 1067 00024992 # write32h( sgl_expected ); ! 1111: 1068 00024992 dd effffff59c pushl _sgl_expected ! 1112: 1069 00024998 fe 08 effffff595 callf $8,_write32h ! 1113: 1070 0002499F # writec('\n'); ! 1114: 1071 0002499F dd 0a pushl $10 ! 1115: 1072 000249A1 fe 08 effffff58c callf $8,_writec ! 1116: 1073 000249A8 # } ! 1117: 1074 000249A8 # if ( halt_flg ) /* halt on error? */ ! 1118: 1075 000249A8 L344: ! 1119: 1076 000249A8 5d effffff586 tstl _halt_flg ! 1120: 1077 000249AE 31 09 jeql L350 ! 1121: 1078 000249B0 # mull2_halt( 5 ); ! 1122: 1079 000249B0 dd 05 pushl $5 ! 1123: 1080 000249B2 fe 08 ef00000177 callf $8,_mull2_halt ! 1124: 1081 000249B9 # if ( loop_on_err ) { ! 1125: 1082 000249B9 L350: ! 1126: 1083 000249B9 5d effffff575 tstl _loop_on_err ! 1127: 1084 000249BF 31 0d jeql L351 ! 1128: 1085 000249C1 # force_loop = TRUE; /* set the force loop flag */ ! 1129: 1086 000249C1 0d 01 effffff56c movl $1,_force_loop ! 1130: 1087 000249C8 # asm("jmp _mull2_6_lp1"); /* and loop */ ! 1131: 1088 000249C8 71 efffffff0c jmp _mull2_6_lp1 ! 1132: 1089 000249CE # } /* end of loop-on-error */ ! 1133: 1090 000249CE # } /* end of acc corr error */ ! 1134: 1091 000249CE L351: ! 1135: 1092 000249CE # if( sgl_value_4 != sgl_value_3 ) /* COMPARE the values */ ! 1136: 1093 000249CE L343: ! 1137: 1094 000249CE 1d effffff560 effffff55b cmpl _sgl_value_4,_sgl_value_3 ! 1138: 1095 000249D9 31 41 jeql L352 ! 1139: 1096 000249DB # { ! 1140: 1097 000249DB # errcnt++; /* bump the error count */ ! 1141: 1098 000249DB 6d effffff553 incl _errcnt ! 1142: 1099 000249E1 # if ( prt_error ) { ! 1143: 1100 000249E1 5d effffff54d tstl _prt_error ! 1144: 1101 000249E7 31 0d jeql L353 ! 1145: 1102 000249E9 # print_mull2_error("(Piped Exit) -BAD MULTIPLY RESULT"); ! 1146: 1103 000249E9 .data 1 ! 1147: 1104 00000ff0 * L354: ! 1148: 1105 00000ff0 * 2850697065642045786974292 .ascii "(Piped Exit) -BAD MULTIPLY RESULT\0" ! 1149: 02D424144204D554C5449504C ! 1150: 5920524553554C5400 ! 1151: 1106 00001012 * .text ! 1152: 1107 000249E9 dd 8f00000ff0 pushl $L354 ! 1153: 1108 000249EF fe 08 ef00000034 callf $8,_print_mull2_error ! 1154: 1109 000249F6 # } ! 1155: 1110 000249F6 # if ( halt_flg ) /* halt on error? */ ! 1156: 1111 000249F6 L353: ! 1157: 1112 000249F6 5d effffff538 tstl _halt_flg ! 1158: 1113 000249FC 31 09 jeql L355 ! 1159: 1114 000249FE # mull2_halt( 1 ); ! 1160: 1115 000249FE dd 01 pushl $1 ! 1161: 1116 00024A00 fe 08 ef00000129 callf $8,_mull2_halt ! 1162: 1117 00024A07 # if ( loop_on_err ) { ! 1163: 1118 00024A07 L355: ! 1164: 1119 00024A07 5d effffff527 tstl _loop_on_err ! 1165: 1120 00024A0D 31 0d jeql L356 ! 1166: 1121 00024A0F # force_loop = TRUE; /* set the force loop flag */ ! 1167: 1122 00024A0F 0d 01 effffff51e movl $1,_force_loop ! 1168: 1123 00024A16 # asm("jmp _mull2_6_lp1"); /* and loop */ ! 1169: 1124 00024A16 71 effffffebe jmp _mull2_6_lp1 ! 1170: 1125 00024A1C # } /* end of loop-on-error */ ! 1171: 1126 00024A1C # } /* end of multiply error */ ! 1172: 1127 00024A1C L356: ! 1173: 1128 00024A1C # } ! 1174: 1129 00024A1C L352: ! 1175: 1130 00024A1C L339: ! 1176: 1131 00024A1C 6d effffff512 incl _index ! 1177: 1132 00024A22 13 fe4b jbr L341 ! 1178: 1133 00024A25 L340: ! 1179: 1134 00024A25 # } /* end of subtest 6 */ ! 1180: 1135 00024A25 40 ret#2 ! 1181: 1136 00024A26 .set L335,0x0 ! 1182: 1137 00024A26 L337: ! 1183: 1138 00024A26 13 fe34 jbr L338 ! 1184: 1139 00024A29 .data ! 1185: 1140 00000d58 * .text ! 1186: 1141 00024A29 00 .align 1 ! 1187: 1142 00024A2A .globl _print_mull2_error ! 1188: 1143 00024A2A _print_mull2_error: ! 1189: 1144 00024A2A 0000 .word L357 ! 1190: 1145 00024A2C # ! 1191: 1146 00024A2C # ! 1192: 1147 00024A2C # ! 1193: 1148 00024A2C # /***************************************************************************** ! 1194: 1149 00024A2C # * ! 1195: 1150 00024A2C # * Print an error message of the form: ! 1196: 1151 00024A2C # * ! 1197: 1152 00024A2C # * cycle: xx MULL2 test xx, subtest xx <"your message here"> ! 1198: 1153 00024A2C # * operand 1 = xxxxxxxx, result = xxxxxxxx, data index = xx ! 1199: 1154 00024A2C # * operand 2 = xxxxxxxx, expected = xxxxxxxx ! 1200: 1155 00024A2C # * ! 1201: 1156 00024A2C # *****************************************************************************/ ! 1202: 1157 00024A2C # print_mull2_error(msg) ! 1203: 1158 00024A2C # char *msg; /* addressing mode msg */ ! 1204: 1159 00024A2C # { ! 1205: 1160 00024A2C 13 00fe jbr L359 ! 1206: 1161 00024A2F L360: ! 1207: 1162 00024A2F # writes(" \n"); /* start a new print line */ ! 1208: 1163 00024A2F .data 1 ! 1209: 1164 00001012 * L361: ! 1210: 1165 00001012 * 200A00 .ascii " \12\0" ! 1211: 1166 00001015 * .text ! 1212: 1167 00024A2F dd 8f00001012 pushl $L361 ! 1213: 1168 00024A35 fe 08 effffff4f8 callf $8,_writes ! 1214: 1169 00024A3C # writes("cycle: "); ! 1215: 1170 00024A3C .data 1 ! 1216: 1171 00001015 * L362: ! 1217: 1172 00001015 * 6379636C653A2000 .ascii "cycle: \0" ! 1218: 1173 0000101d * .text ! 1219: 1174 00024A3C dd 8f00001015 pushl $L362 ! 1220: 1175 00024A42 fe 08 effffff4eb callf $8,_writes ! 1221: 1176 00024A49 # writed( cycle ); ! 1222: 1177 00024A49 dd effffff4e5 pushl _cycle ! 1223: 1178 00024A4F fe 08 effffff4de callf $8,_writed ! 1224: 1179 00024A56 # writes(" MULL2 test "); ! 1225: 1180 00024A56 .data 1 ! 1226: 1181 0000101d * L364: ! 1227: 1182 0000101d * 20204D554C4C3220746573742 .ascii " MULL2 test \0" ! 1228: 000 ! 1229: 1183 0000102b * .text ! 1230: 1184 00024A56 dd 8f0000101d pushl $L364 ! 1231: 1185 00024A5C fe 08 effffff4d1 callf $8,_writes ! 1232: 1186 00024A63 # writed( test_no ); ! 1233: 1187 00024A63 dd effffff4cb pushl _test_no ! 1234: 1188 00024A69 fe 08 effffff4c4 callf $8,_writed ! 1235: 1189 00024A70 # writes(", subtest "); ! 1236: 1190 00024A70 .data 1 ! 1237: 1191 0000102b * L365: ! 1238: 1192 0000102b * 2C20737562746573742000 .ascii ", subtest \0" ! 1239: 1193 00001036 * .text ! 1240: 1194 00024A70 dd 8f0000102b pushl $L365 ! 1241: 1195 00024A76 fe 08 effffff4b7 callf $8,_writes ! 1242: 1196 00024A7D # writed( subtest ); ! 1243: 1197 00024A7D dd effffff4b1 pushl _subtest ! 1244: 1198 00024A83 fe 08 effffff4aa callf $8,_writed ! 1245: 1199 00024A8A # writes(" "); ! 1246: 1200 00024A8A .data 1 ! 1247: 1201 00001036 * L366: ! 1248: 1202 00001036 * 202000 .ascii " \0" ! 1249: 1203 00001039 * .text ! 1250: 1204 00024A8A dd 8f00001036 pushl $L366 ! 1251: 1205 00024A90 fe 08 effffff49d callf $8,_writes ! 1252: 1206 00024A97 # writes( msg ); ! 1253: 1207 00024A97 dd ad04 pushl 4(fp) ! 1254: 1208 00024A9A fe 08 effffff493 callf $8,_writes ! 1255: 1209 00024AA1 # writes("\n operand 1 = "); ! 1256: 1210 00024AA1 .data 1 ! 1257: 1211 00001039 * L367: ! 1258: 1212 00001039 * 0A20206F706572616E6420312 .ascii "\12 operand 1 = \0" ! 1259: 03D2000 ! 1260: 1213 00001049 * .text ! 1261: 1214 00024AA1 dd 8f00001039 pushl $L367 ! 1262: 1215 00024AA7 fe 08 effffff486 callf $8,_writes ! 1263: 1216 00024AAE # write32h( sgl_value_1 ); ! 1264: 1217 00024AAE dd effffff480 pushl _sgl_value_1 ! 1265: 1218 00024AB4 fe 08 effffff479 callf $8,_write32h ! 1266: 1219 00024ABB # writes(", result = "); ! 1267: 1220 00024ABB .data 1 ! 1268: 1221 00001049 * L368: ! 1269: 1222 00001049 * 2C20202020202020207265737 .ascii ", result = \0" ! 1270: 56C74203D2000 ! 1271: 1223 0000105c * .text ! 1272: 1224 00024ABB dd 8f00001049 pushl $L368 ! 1273: 1225 00024AC1 fe 08 effffff46c callf $8,_writes ! 1274: 1226 00024AC8 # write32h( sgl_value_3 ); ! 1275: 1227 00024AC8 dd effffff466 pushl _sgl_value_3 ! 1276: 1228 00024ACE fe 08 effffff45f callf $8,_write32h ! 1277: 1229 00024AD5 # writes(", data index = "); ! 1278: 1230 00024AD5 .data 1 ! 1279: 1231 0000105c * L369: ! 1280: 1232 0000105c * 2C2020206461746120696E646 .ascii ", data index = \0" ! 1281: 578203D2000 ! 1282: 1233 0000106e * .text ! 1283: 1234 00024AD5 dd 8f0000105c pushl $L369 ! 1284: 1235 00024ADB fe 08 effffff452 callf $8,_writes ! 1285: 1236 00024AE2 # writed( index ); ! 1286: 1237 00024AE2 dd effffff44c pushl _index ! 1287: 1238 00024AE8 fe 08 effffff445 callf $8,_writed ! 1288: 1239 00024AEF # writes("\n operand 2 = "); ! 1289: 1240 00024AEF .data 1 ! 1290: 1241 0000106e * L370: ! 1291: 1242 0000106e * 0A20206F706572616E6420322 .ascii "\12 operand 2 = \0" ! 1292: 03D2000 ! 1293: 1243 0000107e * .text ! 1294: 1244 00024AEF dd 8f0000106e pushl $L370 ! 1295: 1245 00024AF5 fe 08 effffff438 callf $8,_writes ! 1296: 1246 00024AFC # write32h( sgl_value_2 ); ! 1297: 1247 00024AFC dd effffff432 pushl _sgl_value_2 ! 1298: 1248 00024B02 fe 08 effffff42b callf $8,_write32h ! 1299: 1249 00024B09 # writes(", expected = "); ! 1300: 1250 00024B09 .data 1 ! 1301: 1251 0000107e * L371: ! 1302: 1252 0000107e * 2C20202020202065787065637 .ascii ", expected = \0" ! 1303: 46564203D2000 ! 1304: 1253 00001091 * .text ! 1305: 1254 00024B09 dd 8f0000107e pushl $L371 ! 1306: 1255 00024B0F fe 08 effffff41e callf $8,_writes ! 1307: 1256 00024B16 # write32h( sgl_value_4 ); ! 1308: 1257 00024B16 dd effffff418 pushl _sgl_value_4 ! 1309: 1258 00024B1C fe 08 effffff411 callf $8,_write32h ! 1310: 1259 00024B23 # writec('\n'); ! 1311: 1260 00024B23 dd 0a pushl $10 ! 1312: 1261 00024B25 fe 08 effffff408 callf $8,_writec ! 1313: 1262 00024B2C # } ! 1314: 1263 00024B2C 40 ret#2 ! 1315: 1264 00024B2D .set L357,0x0 ! 1316: 1265 00024B2D L359: ! 1317: 1266 00024B2D 13 feff jbr L360 ! 1318: 1267 00024B30 .data ! 1319: 1268 00000d58 * .text ! 1320: 1269 00024B30 .align 1 ! 1321: 1270 00024B30 .globl _mull2_halt ! 1322: 1271 00024B30 _mull2_halt: ! 1323: 1272 00024B30 0000 .word L372 ! 1324: 1273 00024B32 # ! 1325: 1274 00024B32 # ! 1326: 1275 00024B32 # ! 1327: 1276 00024B32 # /*************************************************************************** ! 1328: 1277 00024B32 # * ! 1329: 1278 00024B32 # * HALT ON AN ERROR ! 1330: 1279 00024B32 # * ! 1331: 1280 00024B32 # ***************************************************************************/ ! 1332: 1281 00024B32 # mull2_halt( code ) ! 1333: 1282 00024B32 # int code; /* error code to use */ ! 1334: 1283 00024B32 # { ! 1335: 1284 00024B32 13 0152 jbr L374 ! 1336: 1285 00024B35 L375: ! 1337: 1286 00024B35 # sgl_dummy1 = code; /* save the error code */ ! 1338: 1287 00024B35 0d ad04 effffff3f7 movl 4(fp),_sgl_dummy1 ! 1339: 1288 00024B3D # asm("movl _test_no,r0"); /* r0 = test number */ ! 1340: 1289 00024B3D 0d effffff3f1 50 movl _test_no,r0 ! 1341: 1290 00024B44 # asm("movl _subtest,r1"); /* r1 = subtest number */ ! 1342: 1291 00024B44 0d effffff3ea 51 movl _subtest,r1 ! 1343: 1292 00024B4B # asm("movl _sgl_dummy1,r2"); /* r2 = error code */ ! 1344: 1293 00024B4B 0d effffff3e3 52 movl _sgl_dummy1,r2 ! 1345: 1294 00024B52 # asm("movl _cycle,r3"); /* r3 = cycle count */ ! 1346: 1295 00024B52 0d effffff3dc 53 movl _cycle,r3 ! 1347: 1296 00024B59 # asm("movl _sgl_value_1,r4"); /* r4 = operand 1 */ ! 1348: 1297 00024B59 0d effffff3d5 54 movl _sgl_value_1,r4 ! 1349: 1298 00024B60 # asm("movl _sgl_value_2,r5"); /* r5 = operand 2 */ ! 1350: 1299 00024B60 0d effffff3ce 55 movl _sgl_value_2,r5 ! 1351: 1300 00024B67 # asm("movl _sgl_value_3,r6"); /* r6 = MULL2's result */ ! 1352: 1301 00024B67 0d effffff3c7 56 movl _sgl_value_3,r6 ! 1353: 1302 00024B6E # if( code == 1 ) { ! 1354: 1303 00024B6E 1d ad04 01 cmpl 4(fp),$1 ! 1355: 1304 00024B72 21 11 jneq L376 ! 1356: 1305 00024B74 # asm("movl _sgl_value_4,r7"); /* r7 = expected result */ ! 1357: 1306 00024B74 0d effffff3ba 57 movl _sgl_value_4,r7 ! 1358: 1307 00024B7B # asm("movl _index,r8");; /* r8 = data index */ ! 1359: 1308 00024B7B 0d effffff3b3 58 movl _index,r8 ! 1360: 1309 00024B82 # } ! 1361: 1310 00024B82 # else if( code == 2 ) { /* corrupted register */ ! 1362: 1311 00024B82 13 0100 jbr L377 ! 1363: 1312 00024B85 L376: ! 1364: 1313 00024B85 1d ad04 02 cmpl 4(fp),$2 ! 1365: 1314 00024B89 21 3e jneq L378 ! 1366: 1315 00024B8B # sgl_dummy1 = store_regs[index2]; /* get the actual reg data */ ! 1367: 1316 00024B8B 0d effffff3a3 50 movl _index2,r0 ! 1368: 1317 00024B92 0d 40effffff39b movl _store_regs[r0],_sgl_dummy1 ! 1369: effffff396 ! 1370: 1318 00024B9E # sgl_dummy2 = load_regs[index2]; /* get the data expected */ ! 1371: 1319 00024B9E 0d effffff390 50 movl _index2,r0 ! 1372: 1320 00024BA5 0d 40effffff388 movl _load_regs[r0],_sgl_dummy2 ! 1373: effffff383 ! 1374: 1321 00024BB1 # asm("movl _index2,r7"); /* r7 = register number */ ! 1375: 1322 00024BB1 0d effffff37d 57 movl _index2,r7 ! 1376: 1323 00024BB8 # asm("movl _sgl_dummy1,r8"); /* r8 = final reg value */ ! 1377: 1324 00024BB8 0d effffff376 58 movl _sgl_dummy1,r8 ! 1378: 1325 00024BBF # asm("movl _sgl_dummy2,r9"); /* r9 = expected value */ ! 1379: 1326 00024BBF 0d effffff36f 59 movl _sgl_dummy2,r9 ! 1380: 1327 00024BC6 # } ! 1381: 1328 00024BC6 # else if( code == 3 ) { /* corrupted PSL */ ! 1382: 1329 00024BC6 13 00bc jbr L379 ! 1383: 1330 00024BC9 L378: ! 1384: 1331 00024BC9 1d ad04 03 cmpl 4(fp),$3 ! 1385: 1332 00024BCD 21 18 jneq L380 ! 1386: 1333 00024BCF # asm("movl _init_psl,r7"); /* r7 = initial PSL */ ! 1387: 1334 00024BCF 0d effffff35f 57 movl _init_psl,r7 ! 1388: 1335 00024BD6 # asm("movl _psl_val,r8"); /* r8 = final PSL */ ! 1389: 1336 00024BD6 0d effffff358 58 movl _psl_val,r8 ! 1390: 1337 00024BDD # asm("movl _exp_psl,r9"); /* r9 = expected PSL */ ! 1391: 1338 00024BDD 0d effffff351 59 movl _exp_psl,r9 ! 1392: 1339 00024BE4 # } ! 1393: 1340 00024BE4 # else if( code == 4 ) { /* corrupted Acc */ ! 1394: 1341 00024BE4 13 009e jbr L381 ! 1395: 1342 00024BE7 L380: ! 1396: 1343 00024BE7 1d ad04 04 cmpl 4(fp),$4 ! 1397: 1344 00024BEB 21 6f jneq L382 ! 1398: 1345 00024BED # if( subtest == 1 ) { /* single precision */ ! 1399: 1346 00024BED 1d effffff341 01 cmpl _subtest,$1 ! 1400: 1347 00024BF4 21 33 jneq L383 ! 1401: 1348 00024BF6 # dbl_ld_acc.m = sgl_ld_acc; ! 1402: 1349 00024BF6 0d effffff338 effffff333 movl _sgl_ld_acc,_dbl_ld_acc ! 1403: 1350 00024C01 # dbl_ld_acc.l = 0; ! 1404: 1351 00024C01 4d effffff331 clrl _dbl_ld_acc+4 ! 1405: 1352 00024C07 # dbl_st_acc.m = sgl_st_acc; ! 1406: 1353 00024C07 0d effffff327 effffff322 movl _sgl_st_acc,_dbl_st_acc ! 1407: 1354 00024C12 # dbl_st_acc.l = 0; ! 1408: 1355 00024C12 4d effffff320 clrl _dbl_st_acc+4 ! 1409: 1356 00024C18 # dbl_expected.m = sgl_expected; ! 1410: 1357 00024C18 0d effffff316 effffff311 movl _sgl_expected,_dbl_expected ! 1411: 1358 00024C23 # dbl_expected.l = 0; ! 1412: 1359 00024C23 4d effffff30f clrl _dbl_expected+4 ! 1413: 1360 00024C29 # }; ! 1414: 1361 00024C29 L383: ! 1415: 1362 00024C29 # asm("movl _index,r7"); /* r7 = data index */ ! 1416: 1363 00024C29 0d effffff305 57 movl _index,r7 ! 1417: 1364 00024C30 # asm("movl _dbl_ld_acc,r8"); /* r8 = MS initial Acc. */ ! 1418: 1365 00024C30 0d effffff2fe 58 movl _dbl_ld_acc,r8 ! 1419: 1366 00024C37 # asm("movl _dbl_ld_acc+4,r9"); /* r9 = LS initial Acc. */ ! 1420: 1367 00024C37 0d effffff2fb 59 movl _dbl_ld_acc+4,r9 ! 1421: 1368 00024C3E # asm("movl _dbl_st_acc,r10"); /* r10 = MS final Acc. */ ! 1422: 1369 00024C3E 0d effffff2f0 5a movl _dbl_st_acc,r10 ! 1423: 1370 00024C45 # asm("movl _dbl_st_acc+4,r11"); /* r11 = LS final Acc. */ ! 1424: 1371 00024C45 0d effffff2ed 5b movl _dbl_st_acc+4,r11 ! 1425: 1372 00024C4C # asm("movl _dbl_expected,r12"); /* r12 = MS expected Acc. */ ! 1426: 1373 00024C4C 0d effffff2e2 5c movl _dbl_expected,r12 ! 1427: 1374 00024C53 # asm("movl _dbl_expected+4,r13"); /* r13 = LS expected Acc. */ ! 1428: 1375 00024C53 0d effffff2df 5d movl _dbl_expected+4,r13 ! 1429: 1376 00024C5A # } ! 1430: 1377 00024C5A # else if( code == 5 ) { /* bad final Acc */ ! 1431: 1378 00024C5A 11 29 jbr L384 ! 1432: 1379 00024C5C L382: ! 1433: 1380 00024C5C 1d ad04 05 cmpl 4(fp),$5 ! 1434: 1381 00024C60 21 23 jneq L385 ! 1435: 1382 00024C62 # asm("movl _index,r7"); /* r7 = data index */ ! 1436: 1383 00024C62 0d effffff2cc 57 movl _index,r7 ! 1437: 1384 00024C69 # asm("movl _sgl_ld_acc,r8"); /* r8 = initial Acc. */ ! 1438: 1385 00024C69 0d effffff2c5 58 movl _sgl_ld_acc,r8 ! 1439: 1386 00024C70 # asm("movl _sgl_value_10,r9"); /* r9 = fpp operand */ ! 1440: 1387 00024C70 0d effffff2be 59 movl _sgl_value_10,r9 ! 1441: 1388 00024C77 # asm("movl _sgl_st_acc,r10"); /* r10 = final Acc. */ ! 1442: 1389 00024C77 0d effffff2b7 5a movl _sgl_st_acc,r10 ! 1443: 1390 00024C7E # asm("movl _sgl_expected,r11"); /* r11 = expected Acc. */ ! 1444: 1391 00024C7E 0d effffff2b0 5b movl _sgl_expected,r11 ! 1445: 1392 00024C85 # }; ! 1446: 1393 00024C85 L385: ! 1447: 1394 00024C85 L384: ! 1448: 1395 00024C85 L381: ! 1449: 1396 00024C85 L379: ! 1450: 1397 00024C85 L377: ! 1451: 1398 00024C85 # asm("halt"); /* HALT ... */ ! 1452: 1399 00024C85 00 halt ! 1453: 1400 00024C86 # } ! 1454: 1401 00024C86 40 ret#2 ! 1455: 1402 00024C87 .set L372,0x0 ! 1456: 1403 00024C87 L374: ! 1457: 1404 00024C87 13 feab jbr L375 ! 1458: 1405 00024C8A .data ! 1459: 1405 00048BBE .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.