![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe11.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 / fpevent|
Return to pipe11.lst CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / fpevent |
1.1 ! root 1: 1 00000000 LL0: ! 2: 2 00000000 .data ! 3: 3 0000048c * .text ! 4: 4 00000000 .align 1 ! 5: 5 00000000 .globl _pipe11 ! 6: 6 00000000 _pipe11: ! 7: 7 00012A74 0000 .word L381 ! 8: 8 00012A76 # ! 9: 9 00012A76 # ! 10: 10 00012A76 # #include "evt_defs.h" ! 11: 11 00012A76 # ! 12: 12 00012A76 # /* ! 13: 13 00012A76 # ********************************************************************* ! 14: 14 00012A76 # * FPP PIPELINED EVENTS TEST #11 ! 15: 15 00012A76 # * ! 16: 16 00012A76 # * This test will execute the following code: "LDF ADDF CVLF" ! 17: 17 00012A76 # * with an overflow fault on the ADDF. We will make sure that: ! 18: 18 00012A76 # * 1. The fault is detected, and ! 19: 19 00012A76 # * 2. the Convert Longword Intger to SGL Floating instruction is not executed. ! 20: 20 00012A76 # ********************************************************************* ! 21: 21 00012A76 # */ ! 22: 22 00012A76 # pipe11() ! 23: 23 00012A76 # { ! 24: 24 00012A76 13 012f jbr L383 ! 25: 25 00012A79 L384: ! 26: 26 00012A79 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */ ! 27: 27 00012A79 ed 6d effffffff4 moval (r13),_pre_event_fp ! 28: 28 00012A80 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */ ! 29: 29 00012A80 ed 6e efffffffed moval (r14),_pre_event_sp ! 30: 30 00012A87 # precision = SGL; ! 31: 31 00012A87 0d 01 efffffffe6 movl $1,_precision ! 32: 32 00012A8E # test_event = ARITH_CODE; /* expect an arithmetic fault */ ! 33: 33 00012A8E 0d 34 efffffffdf movl $52,_test_event ! 34: 34 00012A95 # exp_code = FLT_OVFL_CODE; /* - specificly overflow */ ! 35: 35 00012A95 0d 04 efffffffd8 movl $4,_exp_code ! 36: 36 00012A9C # exp_event = FALSE; /* ... but not yet */ ! 37: 37 00012A9C 4d efffffffd2 clrl _exp_event ! 38: 38 00012AA2 # asm("movab _pipe11_ret,_event_return"); /* set event return address */ ! 39: 39 00012AA2 e9 ef000000b5 efffffffc7 movab _pipe11_ret,_event_return ! 40: 40 00012AAD # dbl_value_2.m = 24; /* set the CVLF data */ ! 41: 41 00012AAD 0d 18 efffffffc0 movl $24,_dbl_value_2 ! 42: 42 00012AB4 # max_index = adf_ov_cnt; /* set max operand index */ ! 43: 43 00012AB4 0d efffffffba efffffffb5 movl _adf_ov_cnt,_max_index ! 44: 44 00012ABF # for( index = 0; index < max_index; index++ ) ! 45: 45 00012ABF 4d efffffffaf clrl _index ! 46: 46 00012AC5 L387: ! 47: 47 00012AC5 1d efffffffa9 efffffffa4 cmpl _index,_max_index ! 48: 48 00012AD0 91 03 13 00d2 jgeq L386 ! 49: 49 00012AD5 # { ! 50: 50 00012AD5 # dbl_ld_acc = adf_ov_dat[index].op_1; /* get the Acc data */ ! 51: 51 00012AD5 48 04 efffffff98 50 shll $4,_index,r0 ! 52: 52 00012ADD 0c 8f00000000 50 addl2 $_adf_ov_dat,r0 ! 53: 53 00012AE4 0d a004 efffffff8c movl 4(r0),_dbl_ld_acc+4 ! 54: 54 00012AEC 0d 60 efffffff81 movl (r0),_dbl_ld_acc ! 55: 55 00012AF3 # dbl_value_1 = adf_ov_dat[index].op_2; /* get the '0' data */ ! 56: 56 00012AF3 48 04 efffffff7a 50 shll $4,_index,r0 ! 57: 57 00012AFB 0c 8f00000008 50 addl2 $_adf_ov_dat+8,r0 ! 58: 58 00012B02 0d a004 efffffff6e movl 4(r0),_dbl_value_1+4 ! 59: 59 00012B0A 0d 60 efffffff63 movl (r0),_dbl_value_1 ! 60: 60 00012B11 # asm(".globl _pipe11_lp1"); ! 61: 61 00012B11 .globl _pipe11_lp1 ! 62: 62 00012B11 # asm("_pipe11_lp1:"); ! 63: 63 00012B11 _pipe11_lp1: ! 64: 64 00012B11 # asm("bispsw $0x60"); /* enable ovfl & undfl events*/ ! 65: 65 00012B11 8b 8860 bispsw $0x60 ! 66: 66 00012B14 # asm("movl _dbl_value_2,r4"); /* set the dummy load data */ ! 67: 67 00012B14 0d efffffff5a 54 movl _dbl_value_2,r4 ! 68: 68 00012B1B # asm("ldf _dbl_ld_acc"); /* load the Acc. */ ! 69: 69 00012B1B 06 efffffff53 ldf _dbl_ld_acc ! 70: 70 00012B21 # exp_event = test_event; /* set the expect event flag */ ! 71: 71 00012B21 0d efffffff4d efffffff48 movl _test_event,_exp_event ! 72: 72 00012B2C # asm("addf _dbl_value_1"); /* trigger the event */ ! 73: 73 00012B2C c6 efffffff42 addf _dbl_value_1 ! 74: 74 00012B32 # asm("cvlf r4"); /* we shouldn't get to here */ ! 75: 75 00012B32 76 54 cvlf r4 ! 76: 76 00012B34 # /* ! 77: 77 00012B34 # * If we got to here then there was no event ! 78: 78 00012B34 # */ ! 79: 79 00012B34 # if( force_loop ) ! 80: 80 00012B34 5d efffffff3a tstl _force_loop ! 81: 81 00012B3A 31 03 jeql L388 ! 82: 82 00012B3C # asm("brw _pipe11_lp1");; /* loop on the error */ ! 83: Assemb0002A234 # asm("brw _pipe11_lp1");; /* loop on the error */ ! 84: "pipe100012A75 e 83: WARNING: brw: destination label is external ! 85: 83 00012B3C 13 ffd2 brw _pipe11_lp1 ! 86: 84 00012B3F L388: ! 87: 85 00012B3F # exp_event = FALSE; /* reset event expected flag */ ! 88: 86 00012B3F 4d efffffff2f clrl _exp_event ! 89: 87 00012B45 # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */ ! 90: 88 00012B45 9b 8860 bicpsw $0x60 ! 91: 89 00012B48 # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */ ! 92: 90 00012B48 0d efffffff26 5d movl _pre_event_fp,fp ! 93: 91 00012B4F # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */ ! 94: 92 00012B4F 0d efffffff1f 5e movl _pre_event_sp,sp ! 95: 93 00012B56 # no_pipe11_evt();; /* report the error */ ! 96: 94 00012B56 fe 04 ef0000004f callf $4,_no_pipe11_evt ! 97: 95 00012B5D # /* ! 98: 96 00012B5D # * Come here after the event ! 99: 97 00012B5D # */ ! 100: 98 00012B5D # asm(".globl _pipe11_ret"); ! 101: 99 00012B5D .globl _pipe11_ret ! 102: 100 00012B5D # asm("_pipe11_ret:"); ! 103: 101 00012B5D _pipe11_ret: ! 104: 102 00012B5D # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */ ! 105: 103 00012B5D 0d efffffff11 5d movl _pre_event_fp,fp ! 106: 104 00012B64 # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */ ! 107: 105 00012B64 0d efffffff0a 5e movl _pre_event_sp,sp ! 108: 106 00012B6B # if( force_loop ) ! 109: 107 00012B6B 5d efffffff03 tstl _force_loop ! 110: 108 00012B71 31 03 jeql L390 ! 111: 109 00012B73 # asm("brw _pipe11_lp1");; /* loop on the error */ ! 112: "pipe100012A75 e 110: WARNING: brw: destination label is external ! 113: 110 00012B73 13 ff9b brw _pipe11_lp1 ! 114: 111 00012B76 L390: ! 115: 112 00012B76 # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */ ! 116: 113 00012B76 9b 8860 bicpsw $0x60 ! 117: 114 00012B79 # if( post_evt_acc.m == 0x42c00000 ) /* Acc = CVLF data? ( 24.0 ) */ ! 118: 115 00012B79 1d effffffef5 8f42c00000 cmpl _post_evt_acc,$1119879168 ! 119: 116 00012B84 21 09 jneq L391 ! 120: 117 00012B86 # pipe11_queue_er(); /* yes it was -error! error! */ ! 121: 118 00012B86 fe 04 ef00000187 callf $4,_pipe11_queue_er ! 122: 119 00012B8D # else if( post_evt_acc.m ) /* was the Acc cleared? */ ! 123: 120 00012B8D 11 0f jbr L393 ! 124: 121 00012B8F L391: ! 125: 122 00012B8F 5d effffffedf tstl _post_evt_acc ! 126: 123 00012B95 31 07 jeql L394 ! 127: 124 00012B97 # bad_pipe11_result(); /* incorrect result error */ ! 128: 125 00012B97 fe 04 ef00000094 callf $4,_bad_pipe11_result ! 129: 126 00012B9E # ! 130: 127 00012B9E # } ! 131: 128 00012B9E L394: ! 132: 129 00012B9E L393: ! 133: 130 00012B9E L385: ! 134: 131 00012B9E 6d effffffed0 incl _index ! 135: 132 00012BA4 13 ff1e jbr L387 ! 136: 133 00012BA7 L386: ! 137: 134 00012BA7 # } ! 138: 135 00012BA7 40 ret#2 ! 139: 136 00012BA8 .set L381,0x0 ! 140: 137 00012BA8 L383: ! 141: 138 00012BA8 13 fece jbr L384 ! 142: 139 00012BAB .data ! 143: 140 0000048c * .text ! 144: 141 00012BAB 00 .align 1 ! 145: 142 00012BAC .globl _no_pipe11_evt ! 146: 143 00012BAC _no_pipe11_evt: ! 147: 144 00012BAC 0000 .word L396 ! 148: 145 00012BAE # ! 149: 146 00012BAE # ! 150: 147 00012BAE # ! 151: 148 00012BAE # /**************************************************************************** ! 152: 149 00012BAE # * Report an "EVENT NOT DETECTED" error ! 153: 150 00012BAE # * ! 154: 151 00012BAE # * Cycle: xx. EVT test xx. subtest xx. No overflow fault seen. index = xx ! 155: 152 00012BAE # * inst = LDF op1, ADDF op2, CVLF op3 (overflow fault on the ADDF) ! 156: 153 00012BAE # * op1 = xxxxxxxx, op2 = xxxxxxxx ! 157: 154 00012BAE # ****************************************************************************/ ! 158: 155 00012BAE # no_pipe11_evt() ! 159: 156 00012BAE # { ! 160: 157 00012BAE 11 7f jbr L398 ! 161: 158 00012BB0 L399: ! 162: 159 00012BB0 # errcnt++; /* bump the error count */ ! 163: 160 00012BB0 6d effffffebe incl _errcnt ! 164: 161 00012BB6 # if ( prt_error ) ! 165: 162 00012BB6 5d effffffeb8 tstl _prt_error ! 166: 163 00012BBC 31 4a jeql L400 ! 167: 164 00012BBE # { ! 168: 165 00012BBE # print_pipe11_er( ". No overflow fault seen" ); ! 169: 166 00012BBE .data 1 ! 170: 167 0000048c * L402: ! 171: 168 0000048c * 2E204E6F206F766572666C6F7 .ascii ". No overflow fault seen\0" ! 172: 7206661756C74207365656E00 ! 173: 169 000004a5 * .text ! 174: 170 00012BBE dd 8f0000048c pushl $L402 ! 175: 171 00012BC4 fe 08 ef0000022b callf $8,_print_pipe11_er ! 176: 172 00012BCB # writes("op1 = "); ! 177: 173 00012BCB .data 1 ! 178: 174 000004a5 * L404: ! 179: 175 000004a5 * 6F7031203D2000 .ascii "op1 = \0" ! 180: 176 000004ac * .text ! 181: 177 00012BCB dd 8f000004a5 pushl $L404 ! 182: 178 00012BD1 fe 08 effffffe9c callf $8,_writes ! 183: 179 00012BD8 # write32h( dbl_ld_acc.m ); ! 184: 180 00012BD8 dd effffffe96 pushl _dbl_ld_acc ! 185: 181 00012BDE fe 08 effffffe8f callf $8,_write32h ! 186: 182 00012BE5 # writes(", op2 = "); ! 187: 183 00012BE5 .data 1 ! 188: 184 000004ac * L406: ! 189: 185 000004ac * 2C2020206F7032203D2000 .ascii ", op2 = \0" ! 190: 186 000004b7 * .text ! 191: 187 00012BE5 dd 8f000004ac pushl $L406 ! 192: 188 00012BEB fe 08 effffffe82 callf $8,_writes ! 193: 189 00012BF2 # write32h( dbl_value_1.m ); ! 194: 190 00012BF2 dd effffffe7c pushl _dbl_value_1 ! 195: 191 00012BF8 fe 08 effffffe75 callf $8,_write32h ! 196: 192 00012BFF # writec('\n'); ! 197: 193 00012BFF dd 0a pushl $10 ! 198: 194 00012C01 fe 08 effffffe6c callf $8,_writec ! 199: 195 00012C08 # } ! 200: 196 00012C08 # if ( halt_flg ) /* halt on error? */ ! 201: 197 00012C08 L400: ! 202: 198 00012C08 5d effffffe66 tstl _halt_flg ! 203: 199 00012C0E 31 09 jeql L408 ! 204: 200 00012C10 # pipe11_halt( 1 ); /* halt with a code of 1 */ ! 205: 201 00012C10 dd 01 pushl $1 ! 206: 202 00012C12 fe 08 ef0000027b callf $8,_pipe11_halt ! 207: 203 00012C19 # if ( loop_on_err ) ! 208: 204 00012C19 L408: ! 209: 205 00012C19 5d effffffe55 tstl _loop_on_err ! 210: 206 00012C1F 31 0d jeql L410 ! 211: 207 00012C21 # { ! 212: 208 00012C21 # force_loop = TRUE; /* set the force loop flag */ ! 213: 209 00012C21 0d 01 effffffe4c movl $1,_force_loop ! 214: 210 00012C28 # asm("jmp _pipe11_lp1"); /* and loop */ ! 215: 211 00012C28 71 effffffee3 jmp _pipe11_lp1 ! 216: 212 00012C2E # }; ! 217: 213 00012C2E L410: ! 218: 214 00012C2E # } ! 219: 215 00012C2E 40 ret#2 ! 220: 216 00012C2F .set L396,0x0 ! 221: 217 00012C2F L398: ! 222: 218 00012C2F 13 ff7e jbr L399 ! 223: 219 00012C32 .data ! 224: 220 0000048c * .text ! 225: 221 00012C32 .align 1 ! 226: 222 00012C32 .globl _bad_pipe11_result ! 227: 223 00012C32 _bad_pipe11_result: ! 228: 224 00012C32 0000 .word L411 ! 229: 225 00012C34 # ! 230: 226 00012C34 # ! 231: 227 00012C34 # ! 232: 228 00012C34 # ! 233: 229 00012C34 # /**************************************************************************** ! 234: 230 00012C34 # * Report an "BAD ACCUMULATOR AFTER THE EVENT" error ! 235: 231 00012C34 # * ! 236: 232 00012C34 # * Cycle: xx. EVT test xx. subtest xx. Bad final Accumulator. index = xx ! 237: 233 00012C34 # * inst = LDF op1, ADDF op2, CVLF op3 (overflow fault on the ADDF) ! 238: 234 00012C34 # * The CVLF should not be executed. ! 239: 235 00012C34 # * op1 = xxxxxxxx, final Acc. = xxxxxxxx, op3 = xxxxxxxx ! 240: 236 00012C34 # * op2 = xxxxxxxx, expected = xxxxxxxx ! 241: 237 00012C34 # ****************************************************************************/ ! 242: 238 00012C34 # bad_pipe11_result() ! 243: 239 00012C34 # { ! 244: 240 00012C34 13 00d9 jbr L413 ! 245: 241 00012C37 L414: ! 246: 242 00012C37 # errcnt++; /* bump the error count */ ! 247: 243 00012C37 6d effffffe37 incl _errcnt ! 248: 244 00012C3D # if ( prt_error ) ! 249: 245 00012C3D 5d effffffe31 tstl _prt_error ! 250: 246 00012C43 21 03 13 00a1 jeql L415 ! 251: 247 00012C48 # { ! 252: 248 00012C48 # print_pipe11_er( ". Bad final Accumulator" ); ! 253: 249 00012C48 .data 1 ! 254: 250 000004b7 * L416: ! 255: 251 000004b7 * 2E204261642066696E616C204 .ascii ". Bad final Accumulator\0" ! 256: 16363756D756C61746F7200 ! 257: 252 000004cf * .text ! 258: 253 00012C48 dd 8f000004b7 pushl $L416 ! 259: 254 00012C4E fe 08 ef000001a1 callf $8,_print_pipe11_er ! 260: 255 00012C55 # writes( ! 261: 256 00012C55 # "The CVLF should not be executed\n"); ! 262: 257 00012C55 .data 1 ! 263: 258 000004cf * L417: ! 264: 259 000004cf * 5468652043564C462073686F7 .ascii "The CVLF should not be executed\12\0" ! 265: 56C64206E6F74206265206578 ! 266: 6563757465640A00 ! 267: 260 000004f0 * .text ! 268: 261 00012C55 dd 8f000004cf pushl $L417 ! 269: 262 00012C5B fe 08 effffffe12 callf $8,_writes ! 270: 263 00012C62 # writes("op1 = "); ! 271: 264 00012C62 .data 1 ! 272: 265 000004f0 * L418: ! 273: 266 000004f0 * 6F7031203D2000 .ascii "op1 = \0" ! 274: 267 000004f7 * .text ! 275: 268 00012C62 dd 8f000004f0 pushl $L418 ! 276: 269 00012C68 fe 08 effffffe05 callf $8,_writes ! 277: 270 00012C6F # write32h( dbl_ld_acc.m ); ! 278: 271 00012C6F dd effffffdff pushl _dbl_ld_acc ! 279: 272 00012C75 fe 08 effffffdf8 callf $8,_write32h ! 280: 273 00012C7C # writes(", final Acc. = "); ! 281: 274 00012C7C .data 1 ! 282: 275 000004f7 * L419: ! 283: 276 000004f7 * 2C202066696E616C204163632 .ascii ", final Acc. = \0" ! 284: E203D2000 ! 285: 277 00000508 * .text ! 286: 278 00012C7C dd 8f000004f7 pushl $L419 ! 287: 279 00012C82 fe 08 effffffdeb callf $8,_writes ! 288: 280 00012C89 # write32h( post_evt_acc.m ); ! 289: 281 00012C89 dd effffffde5 pushl _post_evt_acc ! 290: 282 00012C8F fe 08 effffffdde callf $8,_write32h ! 291: 283 00012C96 # writes(", op3 = "); ! 292: 284 00012C96 .data 1 ! 293: 285 00000508 * L420: ! 294: 286 00000508 * 2C2020206F7033203D2000 .ascii ", op3 = \0" ! 295: 287 00000513 * .text ! 296: 288 00012C96 dd 8f00000508 pushl $L420 ! 297: 289 00012C9C fe 08 effffffdd1 callf $8,_writes ! 298: 290 00012CA3 # write32h( dbl_value_2.m ); ! 299: 291 00012CA3 dd effffffdcb pushl _dbl_value_2 ! 300: 292 00012CA9 fe 08 effffffdc4 callf $8,_write32h ! 301: 293 00012CB0 # writes("\nop2 = "); ! 302: 294 00012CB0 .data 1 ! 303: 295 00000513 * L421: ! 304: 296 00000513 * 0A6F7032203D2000 .ascii "\12op2 = \0" ! 305: 297 0000051b * .text ! 306: 298 00012CB0 dd 8f00000513 pushl $L421 ! 307: 299 00012CB6 fe 08 effffffdb7 callf $8,_writes ! 308: 300 00012CBD # write32h( dbl_value_1.m ); ! 309: 301 00012CBD dd effffffdb1 pushl _dbl_value_1 ! 310: 302 00012CC3 fe 08 effffffdaa callf $8,_write32h ! 311: 303 00012CCA # writes(", expected = "); ! 312: 304 00012CCA .data 1 ! 313: 305 0000051b * L422: ! 314: 306 0000051b * 2C20202020657870656374656 .ascii ", expected = \0" ! 315: 4203D2000 ! 316: 307 0000052c * .text ! 317: 308 00012CCA dd 8f0000051b pushl $L422 ! 318: 309 00012CD0 fe 08 effffffd9d callf $8,_writes ! 319: 310 00012CD7 # write32h( 0 ); /* the expected result = 0 */ ! 320: 311 00012CD7 dd 00 pushl $0 ! 321: 312 00012CD9 fe 08 effffffd94 callf $8,_write32h ! 322: 313 00012CE0 # writec('\n'); ! 323: 314 00012CE0 dd 0a pushl $10 ! 324: 315 00012CE2 fe 08 effffffd8b callf $8,_writec ! 325: 316 00012CE9 # } ! 326: 317 00012CE9 # if ( halt_flg ) /* halt on error? */ ! 327: 318 00012CE9 L415: ! 328: 319 00012CE9 5d effffffd85 tstl _halt_flg ! 329: 320 00012CEF 31 09 jeql L423 ! 330: 321 00012CF1 # pipe11_halt( 2 ); /* halt with a code of 2 */ ! 331: 322 00012CF1 dd 02 pushl $2 ! 332: 323 00012CF3 fe 08 ef0000019a callf $8,_pipe11_halt ! 333: 324 00012CFA # if ( loop_on_err ) ! 334: 325 00012CFA L423: ! 335: 326 00012CFA 5d effffffd74 tstl _loop_on_err ! 336: 327 00012D00 31 0d jeql L424 ! 337: 328 00012D02 # { ! 338: 329 00012D02 # force_loop = TRUE; /* set the force loop flag */ ! 339: 330 00012D02 0d 01 effffffd6b movl $1,_force_loop ! 340: 331 00012D09 # asm("jmp _pipe11_lp1"); /* and loop */ ! 341: 332 00012D09 71 effffffe02 jmp _pipe11_lp1 ! 342: 333 00012D0F # }; ! 343: 334 00012D0F L424: ! 344: 335 00012D0F # } ! 345: 336 00012D0F 40 ret#2 ! 346: 337 00012D10 .set L411,0x0 ! 347: 338 00012D10 L413: ! 348: 339 00012D10 13 ff24 jbr L414 ! 349: 340 00012D13 .data ! 350: 341 0000048c * .text ! 351: 342 00012D13 00 .align 1 ! 352: 343 00012D14 .globl _pipe11_queue_er ! 353: 344 00012D14 _pipe11_queue_er: ! 354: 345 00012D14 0000 .word L425 ! 355: 346 00012D16 # ! 356: 347 00012D16 # ! 357: 348 00012D16 # ! 358: 349 00012D16 # ! 359: 350 00012D16 # ! 360: 351 00012D16 # /**************************************************************************** ! 361: 352 00012D16 # * Report an "FPP queue not cleared" message ! 362: 353 00012D16 # * ! 363: 354 00012D16 # * Cycle: xx. EVT test xx. subtest xx. Fpp queue not cleared. index = xx ! 364: 355 00012D16 # * inst = LDF op1, ADDF op2, CVLF op3 (overflow fault on the ADDF) ! 365: 356 00012D16 # * The CVLF should not have been executed but apparently was. ! 366: 357 00012D16 # * op1 = xxxxxxxx, final Acc. = xxxxxxxx, op3 = xxxxxxxx ! 367: 358 00012D16 # * op2 = xxxxxxxx, expected = xxxxxxxx ! 368: 359 00012D16 # ****************************************************************************/ ! 369: 360 00012D16 # pipe11_queue_er() ! 370: 361 00012D16 # { ! 371: 362 00012D16 13 00d9 jbr L427 ! 372: 363 00012D19 L428: ! 373: 364 00012D19 # errcnt++; /* bump the error count */ ! 374: 365 00012D19 6d effffffd55 incl _errcnt ! 375: 366 00012D1F # if ( prt_error ) ! 376: 367 00012D1F 5d effffffd4f tstl _prt_error ! 377: 368 00012D25 21 03 13 00a1 jeql L429 ! 378: 369 00012D2A # { ! 379: 370 00012D2A # print_pipe11_er( ". Fpp queue not cleared" ); ! 380: 371 00012D2A .data 1 ! 381: 372 0000052c * L430: ! 382: 373 0000052c * 2E20467070207175657565206 .ascii ". Fpp queue not cleared\0" ! 383: E6F7420636C656172656400 ! 384: 374 00000544 * .text ! 385: 375 00012D2A dd 8f0000052c pushl $L430 ! 386: 376 00012D30 fe 08 ef000000bf callf $8,_print_pipe11_er ! 387: 377 00012D37 # writes( ! 388: 378 00012D37 # "The CVLF should not have been executed but apparently was.\n"); ! 389: 379 00012D37 .data 1 ! 390: 380 00000544 * L431: ! 391: 381 00000544 * 5468652043564C462073686F7 .ascii "The CVLF should not have been executed but apparently was.\12\0" ! 392: 56C64206E6F74206861766520 ! 393: 6265656E20657865637574656 ! 394: 420627574206170706172656E ! 395: 746C79207761732E0A00 ! 396: 382 00000580 * .text ! 397: 383 00012D37 dd 8f00000544 pushl $L431 ! 398: 384 00012D3D fe 08 effffffd30 callf $8,_writes ! 399: 385 00012D44 # writes("op1 = "); ! 400: 386 00012D44 .data 1 ! 401: 387 00000580 * L432: ! 402: 388 00000580 * 6F7031203D2000 .ascii "op1 = \0" ! 403: 389 00000587 * .text ! 404: 390 00012D44 dd 8f00000580 pushl $L432 ! 405: 391 00012D4A fe 08 effffffd23 callf $8,_writes ! 406: 392 00012D51 # write32h( dbl_ld_acc.m ); ! 407: 393 00012D51 dd effffffd1d pushl _dbl_ld_acc ! 408: 394 00012D57 fe 08 effffffd16 callf $8,_write32h ! 409: 395 00012D5E # writes(", final Acc. = "); ! 410: 396 00012D5E .data 1 ! 411: 397 00000587 * L433: ! 412: 398 00000587 * 2C202066696E616C204163632 .ascii ", final Acc. = \0" ! 413: E203D2000 ! 414: 399 00000598 * .text ! 415: 400 00012D5E dd 8f00000587 pushl $L433 ! 416: 401 00012D64 fe 08 effffffd09 callf $8,_writes ! 417: 402 00012D6B # write32h( post_evt_acc.m ); ! 418: 403 00012D6B dd effffffd03 pushl _post_evt_acc ! 419: 404 00012D71 fe 08 effffffcfc callf $8,_write32h ! 420: 405 00012D78 # writes(", op3 = "); ! 421: 406 00012D78 .data 1 ! 422: 407 00000598 * L434: ! 423: 408 00000598 * 2C20206F7033203D2000 .ascii ", op3 = \0" ! 424: 409 000005a2 * .text ! 425: 410 00012D78 dd 8f00000598 pushl $L434 ! 426: 411 00012D7E fe 08 effffffcef callf $8,_writes ! 427: 412 00012D85 # write32h( dbl_value_2.m ); ! 428: 413 00012D85 dd effffffce9 pushl _dbl_value_2 ! 429: 414 00012D8B fe 08 effffffce2 callf $8,_write32h ! 430: 415 00012D92 # writes("\nop2 = "); ! 431: 416 00012D92 .data 1 ! 432: 417 000005a2 * L435: ! 433: 418 000005a2 * 0A6F7032203D2000 .ascii "\12op2 = \0" ! 434: 419 000005aa * .text ! 435: 420 00012D92 dd 8f000005a2 pushl $L435 ! 436: 421 00012D98 fe 08 effffffcd5 callf $8,_writes ! 437: 422 00012D9F # write32h( dbl_value_1.m ); ! 438: 423 00012D9F dd effffffccf pushl _dbl_value_1 ! 439: 424 00012DA5 fe 08 effffffcc8 callf $8,_write32h ! 440: 425 00012DAC # writes(", expected = "); ! 441: 426 00012DAC .data 1 ! 442: 427 000005aa * L436: ! 443: 428 000005aa * 2C20202020657870656374656 .ascii ", expected = \0" ! 444: 4203D2000 ! 445: 429 000005bb * .text ! 446: 430 00012DAC dd 8f000005aa pushl $L436 ! 447: 431 00012DB2 fe 08 effffffcbb callf $8,_writes ! 448: 432 00012DB9 # write32h( 0 ); /* the expected result = 0 */ ! 449: 433 00012DB9 dd 00 pushl $0 ! 450: 434 00012DBB fe 08 effffffcb2 callf $8,_write32h ! 451: 435 00012DC2 # writec('\n'); ! 452: 436 00012DC2 dd 0a pushl $10 ! 453: 437 00012DC4 fe 08 effffffca9 callf $8,_writec ! 454: 438 00012DCB # } ! 455: 439 00012DCB # if ( halt_flg ) /* halt on error? */ ! 456: 440 00012DCB L429: ! 457: 441 00012DCB 5d effffffca3 tstl _halt_flg ! 458: 442 00012DD1 31 09 jeql L437 ! 459: 443 00012DD3 # pipe11_halt( 3 ); /* halt with a code of 3 */ ! 460: 444 00012DD3 dd 03 pushl $3 ! 461: 445 00012DD5 fe 08 ef000000b8 callf $8,_pipe11_halt ! 462: 446 00012DDC # if ( loop_on_err ) ! 463: 447 00012DDC L437: ! 464: 448 00012DDC 5d effffffc92 tstl _loop_on_err ! 465: 449 00012DE2 31 0d jeql L438 ! 466: 450 00012DE4 # { ! 467: 451 00012DE4 # force_loop = TRUE; /* set the force loop flag */ ! 468: 452 00012DE4 0d 01 effffffc89 movl $1,_force_loop ! 469: 453 00012DEB # asm("jmp _pipe11_lp1"); /* and loop */ ! 470: 454 00012DEB 71 effffffd20 jmp _pipe11_lp1 ! 471: 455 00012DF1 # }; ! 472: 456 00012DF1 L438: ! 473: 457 00012DF1 # } ! 474: 458 00012DF1 40 ret#2 ! 475: 459 00012DF2 .set L425,0x0 ! 476: 460 00012DF2 L427: ! 477: 461 00012DF2 13 ff24 jbr L428 ! 478: 462 00012DF5 .data ! 479: 463 0000048c * .text ! 480: 464 00012DF5 00 .align 1 ! 481: 465 00012DF6 .globl _print_pipe11_er ! 482: 466 00012DF6 _print_pipe11_er: ! 483: 467 00012DF6 0000 .word L439 ! 484: 468 00012DF8 # ! 485: 469 00012DF8 # ! 486: 470 00012DF8 # ! 487: 471 00012DF8 # ! 488: 472 00012DF8 # /**************************************************************************** ! 489: 473 00012DF8 # * Report an error message of the form: ! 490: 474 00012DF8 # * ! 491: 475 00012DF8 # * Cycle: xx. EVT test xx. subtest xx. <your message here> index = xx ! 492: 476 00012DF8 # * inst = LDF op1, ADDF op2, CVLF op3 (overflow fault on the ADDF) ! 493: 477 00012DF8 # ****************************************************************************/ ! 494: 478 00012DF8 # print_pipe11_er( msg ) ! 495: 479 00012DF8 # char *msg; /* error message to print */ ! 496: 480 00012DF8 # { ! 497: 481 00012DF8 13 0096 jbr L441 ! 498: 482 00012DFB L442: ! 499: 483 00012DFB # if( errcnt == 1 ) /* 1st error? */ ! 500: 484 00012DFB 1d effffffc73 01 cmpl _errcnt,$1 ! 501: 485 00012E02 21 0d jneq L443 ! 502: 486 00012E04 # writes(" \n"); /* start a new print line */ ! 503: 487 00012E04 .data 1 ! 504: 488 000005bb * L444: ! 505: 489 000005bb * 200A00 .ascii " \12\0" ! 506: 490 000005be * .text ! 507: 491 00012E04 dd 8f000005bb pushl $L444 ! 508: 492 00012E0A fe 08 effffffc63 callf $8,_writes ! 509: 493 00012E11 # writes("Cycle: "); ! 510: 494 00012E11 L443: ! 511: 495 00012E11 .data 1 ! 512: 496 000005be * L445: ! 513: 497 000005be * 4379636C653A2000 .ascii "Cycle: \0" ! 514: 498 000005c6 * .text ! 515: 499 00012E11 dd 8f000005be pushl $L445 ! 516: 500 00012E17 fe 08 effffffc56 callf $8,_writes ! 517: 501 00012E1E # writed( cycle ); ! 518: 502 00012E1E dd effffffc50 pushl _cycle ! 519: 503 00012E24 fe 08 effffffc49 callf $8,_writed ! 520: 504 00012E2B # writes(" EVT test "); ! 521: 505 00012E2B .data 1 ! 522: 506 000005c6 * L447: ! 523: 507 000005c6 * 202045565420746573742000 .ascii " EVT test \0" ! 524: 508 000005d2 * .text ! 525: 509 00012E2B dd 8f000005c6 pushl $L447 ! 526: 510 00012E31 fe 08 effffffc3c callf $8,_writes ! 527: 511 00012E38 # writed( test_no ); ! 528: 512 00012E38 dd effffffc36 pushl _test_no ! 529: 513 00012E3E fe 08 effffffc2f callf $8,_writed ! 530: 514 00012E45 # writes(". subtest "); ! 531: 515 00012E45 .data 1 ! 532: 516 000005d2 * L448: ! 533: 517 000005d2 * 2E20737562746573742000 .ascii ". subtest \0" ! 534: 518 000005dd * .text ! 535: 519 00012E45 dd 8f000005d2 pushl $L448 ! 536: 520 00012E4B fe 08 effffffc22 callf $8,_writes ! 537: 521 00012E52 # writed( subtest ); ! 538: 522 00012E52 dd effffffc1c pushl _subtest ! 539: 523 00012E58 fe 08 effffffc15 callf $8,_writed ! 540: 524 00012E5F # writes( msg ); /* print the message */ ! 541: 525 00012E5F dd ad04 pushl 4(fp) ! 542: 526 00012E62 fe 08 effffffc0b callf $8,_writes ! 543: 527 00012E69 # writes(". index = "); ! 544: 528 00012E69 .data 1 ! 545: 529 000005dd * L449: ! 546: 530 000005dd * 2E20696E646578203D2000 .ascii ". index = \0" ! 547: 531 000005e8 * .text ! 548: 532 00012E69 dd 8f000005dd pushl $L449 ! 549: 533 00012E6F fe 08 effffffbfe callf $8,_writes ! 550: 534 00012E76 # writed( index ); ! 551: 535 00012E76 dd effffffbf8 pushl _index ! 552: 536 00012E7C fe 08 effffffbf1 callf $8,_writed ! 553: 537 00012E83 # writes( ! 554: 538 00012E83 # "\ninst = LDF op1, ADDF op2, CVLF op3 (overflow fault on the ADDF)\n"); ! 555: 539 00012E83 .data 1 ! 556: 540 000005e8 * L450: ! 557: 541 000005e8 * 0A696E7374203D204C4446206 .ascii "\12inst = LDF op1, ADDF op2, CVLF op3 (overflow fault on the AD" ! 558: F70312C2041444446206F7032 ! 559: 2C2043564C46206F703320202 ! 560: 020286F766572666C6F772066 ! 561: 61756C74206F6E20746865204 ! 562: 144 ! 563: 542 00000628 * 4446290A00 .ascii "DF)\12\0" ! 564: 543 0000062d * .text ! 565: 544 00012E83 dd 8f000005e8 pushl $L450 ! 566: 545 00012E89 fe 08 effffffbe4 callf $8,_writes ! 567: 546 00012E90 # } ! 568: 547 00012E90 40 ret#2 ! 569: 548 00012E91 .set L439,0x0 ! 570: 549 00012E91 L441: ! 571: 550 00012E91 13 ff67 jbr L442 ! 572: 551 00012E94 .data ! 573: 552 0000048c * .text ! 574: 553 00012E94 .align 1 ! 575: 554 00012E94 .globl _pipe11_halt ! 576: 555 00012E94 _pipe11_halt: ! 577: 556 00012E94 0000 .word L451 ! 578: 557 00012E96 # ! 579: 558 00012E96 # ! 580: 559 00012E96 # ! 581: 560 00012E96 # /**************************************************************************** ! 582: 561 00012E96 # * halt on error routine ! 583: 562 00012E96 # ****************************************************************************/ ! 584: 563 00012E96 # pipe11_halt( code ) ! 585: 564 00012E96 # int code; /* error code to halt with */ ! 586: 565 00012E96 # { ! 587: 566 00012E96 11 65 jbr L453 ! 588: 567 00012E98 L454: ! 589: 568 00012E98 # err_code = code; ! 590: 569 00012E98 0d ad04 effffffbd4 movl 4(fp),_err_code ! 591: 570 00012EA0 # sgl_value_1 = dbl_ld_acc.m; ! 592: 571 00012EA0 0d effffffbce effffffbc9 movl _dbl_ld_acc,_sgl_value_1 ! 593: 572 00012EAB # sgl_value_2 = dbl_value_1.m; ! 594: 573 00012EAB 0d effffffbc3 effffffbbe movl _dbl_value_1,_sgl_value_2 ! 595: 574 00012EB6 # sgl_value_3 = post_evt_acc.m; ! 596: 575 00012EB6 0d effffffbb8 effffffbb3 movl _post_evt_acc,_sgl_value_3 ! 597: 576 00012EC1 # asm("movl _test_no,r0"); /* r0 = test number */ ! 598: 577 00012EC1 0d effffffbad 50 movl _test_no,r0 ! 599: 578 00012EC8 # asm("movl _subtest,r1"); /* r1 = subtest number */ ! 600: 579 00012EC8 0d effffffba6 51 movl _subtest,r1 ! 601: 580 00012ECF # asm("movl _err_code,r2"); /* r2 = error code */ ! 602: 581 00012ECF 0d effffffb9f 52 movl _err_code,r2 ! 603: 582 00012ED6 # asm("movl _cycle,r3"); /* r3 = cycle count */ ! 604: 583 00012ED6 0d effffffb98 53 movl _cycle,r3 ! 605: 584 00012EDD # asm("movl _sgl_value_1,r4"); /* r4 = initial accumulator */ ! 606: 585 00012EDD 0d effffffb91 54 movl _sgl_value_1,r4 ! 607: 586 00012EE4 # asm("movl _sgl_value_2,r5"); /* r5 = ADDF operand */ ! 608: 587 00012EE4 0d effffffb8a 55 movl _sgl_value_2,r5 ! 609: 588 00012EEB # asm("movl _sgl_value_3,r6"); /* r6 = final accumulator */ ! 610: 589 00012EEB 0d effffffb83 56 movl _sgl_value_3,r6 ! 611: 590 00012EF2 # asm("clrl r7"); /* r7 = expected accumulator */ ! 612: 591 00012EF2 4d 57 clrl r7 ! 613: 592 00012EF4 # asm("movl _index,r8"); /* r8 = data index */ ! 614: 593 00012EF4 0d effffffb7a 58 movl _index,r8 ! 615: 594 00012EFB # asm("halt"); /* HALT ... */ ! 616: 595 00012EFB 00 halt ! 617: 596 00012EFC # } ! 618: 597 00012EFC 40 ret#2 ! 619: 598 00012EFD .set L451,0x0 ! 620: 599 00012EFD L453: ! 621: 600 00012EFD 11 99 jbr L454 ! 622: 601 00012EFF .data ! 623: 601 00025973 .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.