![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe12.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 pipe12.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 00000504 * .text ! 4: 4 00000000 .align 1 ! 5: 5 00000000 .globl _pipe12 ! 6: 6 00000000 _pipe12: ! 7: 7 00012F00 0000 .word L381 ! 8: 8 00012F02 # ! 9: 9 00012F02 # ! 10: 10 00012F02 # #include "evt_defs.h" ! 11: 11 00012F02 # ! 12: 12 00012F02 # /* ! 13: 13 00012F02 # ********************************************************************* ! 14: 14 00012F02 # * FPP PIPELINED EVENTS TEST #12 ! 15: 15 00012F02 # * ! 16: 16 00012F02 # * This test will execute the following code: "LDD CVDF LDD" ! 17: 17 00012F02 # * with an overflow fault on the CVDF. We will make sure that: ! 18: 18 00012F02 # * 1. The fault is detected, and ! 19: 19 00012F02 # * 2. the 2nd load instruction is not executed. ! 20: 20 00012F02 # ********************************************************************* ! 21: 21 00012F02 # */ ! 22: 22 00012F02 # pipe12() ! 23: 23 00012F02 # { ! 24: 24 00012F02 13 0125 jbr L383 ! 25: 25 00012F05 L384: ! 26: 26 00012F05 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */ ! 27: 27 00012F05 ed 6d effffffff4 moval (r13),_pre_event_fp ! 28: 28 00012F0C # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */ ! 29: 29 00012F0C ed 6e efffffffed moval (r14),_pre_event_sp ! 30: 30 00012F13 # precision = DBL; ! 31: 31 00012F13 0d 02 efffffffe6 movl $2,_precision ! 32: 32 00012F1A # test_event = ARITH_CODE; /* expect an arithmetic fault */ ! 33: 33 00012F1A 0d 34 efffffffdf movl $52,_test_event ! 34: 34 00012F21 # exp_code = FLT_OVFL_CODE; /* - specificly underflow */ ! 35: 35 00012F21 0d 04 efffffffd8 movl $4,_exp_code ! 36: 36 00012F28 # exp_event = FALSE; /* ... but not yet */ ! 37: 37 00012F28 4d efffffffd2 clrl _exp_event ! 38: 38 00012F2E # asm("movab _pipe12_ret,_event_return"); /* set event return address */ ! 39: 39 00012F2E e9 ef0000009e efffffffc7 movab _pipe12_ret,_event_return ! 40: 40 00012F39 # max_index = cvdf_ov_cnt; /* set max operand index */ ! 41: 41 00012F39 0d efffffffc1 efffffffbc movl _cvdf_ov_cnt,_max_index ! 42: 42 00012F44 # for( index = 0; index < max_index; index++ ) ! 43: 43 00012F44 4d efffffffb6 clrl _index ! 44: 44 00012F4A L387: ! 45: 45 00012F4A 1d efffffffb0 efffffffab cmpl _index,_max_index ! 46: 46 00012F55 91 03 13 00cf jgeq L386 ! 47: 47 00012F5A # { ! 48: 48 00012F5A # dbl_ld_acc = cvdf_ov_dat[index].op_1; /* get the Acc data */ ! 49: 49 00012F5A 48 04 efffffff9f 50 shll $4,_index,r0 ! 50: 50 00012F62 0c 8f00000000 50 addl2 $_cvdf_ov_dat,r0 ! 51: 51 00012F69 0d a004 efffffff93 movl 4(r0),_dbl_ld_acc+4 ! 52: 52 00012F71 0d 60 efffffff88 movl (r0),_dbl_ld_acc ! 53: 53 00012F78 # dbl_value_1.m = 0x12345678; /* dummy load data */ ! 54: 54 00012F78 0d 8f12345678 efffffff7d movl $305419896,_dbl_value_1 ! 55: 55 00012F83 # dbl_value_1.l = 0xfedcba98; ! 56: 56 00012F83 0d 8ffedcba98 efffffff76 movl $-19088744,_dbl_value_1+4 ! 57: 57 00012F8E # asm(".globl _pipe12_lp1"); ! 58: 58 00012F8E .globl _pipe12_lp1 ! 59: 59 00012F8E # asm("_pipe12_lp1:"); ! 60: 60 00012F8E _pipe12_lp1: ! 61: 61 00012F8E # asm("bispsw $0x60"); /* enable ovfl&undfl */ ! 62: 62 00012F8E 8b 8860 bispsw $0x60 ! 63: 63 00012F91 # asm("ldd _dbl_ld_acc"); /* load the Acc. */ ! 64: 64 00012F91 07 efffffff69 ldd _dbl_ld_acc ! 65: 65 00012F97 # exp_event = test_event; /* expect event soon */ ! 66: 66 00012F97 0d efffffff63 efffffff5e movl _test_event,_exp_event ! 67: 67 00012FA2 # asm("cvdf"); /* trigger the event */ ! 68: 68 00012FA2 a6 cvdf ! 69: 69 00012FA3 # asm("ldd _dbl_value_1"); /* we shouldn't get to here */ ! 70: 70 00012FA3 07 efffffff57 ldd _dbl_value_1 ! 71: 71 00012FA9 # /* ! 72: 72 00012FA9 # * If we got to here then there was no event ! 73: 73 00012FA9 # */ ! 74: 74 00012FA9 # if( force_loop ) ! 75: 75 00012FA9 5d efffffff51 tstl _force_loop ! 76: 76 00012FAF 31 03 jeql L388 ! 77: 77 00012FB1 # asm("brw _pipe12_lp1");; /* loop on the error */ ! 78: Assemb0002A6C0 # asm("brw _pipe12_lp1");; /* loop on the error */ ! 79: "pipe100012F02 e 78: WARNING: brw: destination label is external ! 80: 78 00012FB1 13 ffda brw _pipe12_lp1 ! 81: 79 00012FB4 L388: ! 82: 80 00012FB4 # exp_event = FALSE; /* reset event expected flag */ ! 83: 81 00012FB4 4d efffffff46 clrl _exp_event ! 84: 82 00012FBA # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */ ! 85: 83 00012FBA 9b 8860 bicpsw $0x60 ! 86: 84 00012FBD # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */ ! 87: 85 00012FBD 0d efffffff3d 5d movl _pre_event_fp,fp ! 88: 86 00012FC4 # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */ ! 89: 87 00012FC4 0d efffffff36 5e movl _pre_event_sp,sp ! 90: 88 00012FCB # no_pipe12_evt();; /* report the error */ ! 91: 89 00012FCB fe 04 ef0000005c callf $4,_no_pipe12_evt ! 92: 90 00012FD2 # /* ! 93: 91 00012FD2 # * Come here after the event ! 94: 92 00012FD2 # */ ! 95: 93 00012FD2 # asm(".globl _pipe12_ret"); ! 96: 94 00012FD2 .globl _pipe12_ret ! 97: 95 00012FD2 # asm("_pipe12_ret:"); ! 98: 96 00012FD2 _pipe12_ret: ! 99: 97 00012FD2 # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */ ! 100: 98 00012FD2 0d efffffff28 5d movl _pre_event_fp,fp ! 101: 99 00012FD9 # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */ ! 102: 100 00012FD9 0d efffffff21 5e movl _pre_event_sp,sp ! 103: 101 00012FE0 # if( force_loop ) ! 104: 102 00012FE0 5d efffffff1a tstl _force_loop ! 105: 103 00012FE6 31 03 jeql L390 ! 106: 104 00012FE8 # asm("brw _pipe12_lp1");; /* loop on the error */ ! 107: "pipe100012F02 e 105: WARNING: brw: destination label is external ! 108: 105 00012FE8 13 ffa3 brw _pipe12_lp1 ! 109: 106 00012FEB L390: ! 110: 107 00012FEB # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */ ! 111: 108 00012FEB 9b 8860 bicpsw $0x60 ! 112: 109 00012FEE # if( (post_evt_acc.m == dbl_value_1.m) && /* was the 2nd 'LDD' */ ! 113: 110 00012FEE # (post_evt_acc.l == dbl_value_1.l) ) /* executed? */ ! 114: 111 00012FEE 1d efffffff0c efffffff07 cmpl _post_evt_acc,_dbl_value_1 ! 115: 112 00012FF9 21 16 jneq L391 ! 116: 113 00012FFB 1d efffffff03 effffffefe cmpl _post_evt_acc+4,_dbl_value_1+4 ! 117: 114 00013006 21 09 jneq L391 ! 118: 115 00013008 # pipe12_queue_er(); /* queue not cleared error */ ! 119: 116 00013008 fe 04 ef00000195 callf $4,_pipe12_queue_er ! 120: 117 0001300F # else if( post_evt_acc.m ) /* was the Acc. cleared? */ ! 121: 118 0001300F 11 0f jbr L393 ! 122: 119 00013011 L391: ! 123: 120 00013011 5d effffffee9 tstl _post_evt_acc ! 124: 121 00013017 31 07 jeql L394 ! 125: 122 00013019 # bad_pipe12_result(); /* incorrect result error */ ! 126: 123 00013019 fe 04 ef00000090 callf $4,_bad_pipe12_result ! 127: 124 00013020 # ! 128: 125 00013020 # } ! 129: 126 00013020 L394: ! 130: 127 00013020 L393: ! 131: 128 00013020 L385: ! 132: 129 00013020 6d effffffeda incl _index ! 133: 130 00013026 13 ff21 jbr L387 ! 134: 131 00013029 L386: ! 135: 132 00013029 # } ! 136: 133 00013029 40 ret#2 ! 137: 134 0001302A .set L381,0x0 ! 138: 135 0001302A L383: ! 139: 136 0001302A 13 fed8 jbr L384 ! 140: 137 0001302D .data ! 141: 138 00000504 * .text ! 142: 139 0001302D 00 .align 1 ! 143: 140 0001302E .globl _no_pipe12_evt ! 144: 141 0001302E _no_pipe12_evt: ! 145: 142 0001302E 0000 .word L396 ! 146: 143 00013030 # ! 147: 144 00013030 # ! 148: 145 00013030 # ! 149: 146 00013030 # /**************************************************************************** ! 150: 147 00013030 # * Report an "EVENT NOT DETECTED" error ! 151: 148 00013030 # * ! 152: 149 00013030 # * Cycle: xx. EVT test xx. subtest xx. No overflow fault seen. index = xx ! 153: 150 00013030 # * inst = LDD op1, CVDF, LDD op2 (overflow fault on the CVDF) ! 154: 151 00013030 # * op1 = xxxxxxxx xxxxxxxx ! 155: 152 00013030 # ****************************************************************************/ ! 156: 153 00013030 # no_pipe12_evt() ! 157: 154 00013030 # { ! 158: 155 00013030 11 7b jbr L398 ! 159: 156 00013032 L399: ! 160: 157 00013032 # errcnt++; /* bump the error count */ ! 161: 158 00013032 6d effffffec8 incl _errcnt ! 162: 159 00013038 # if ( prt_error ) ! 163: 160 00013038 5d effffffec2 tstl _prt_error ! 164: 161 0001303E 31 46 jeql L400 ! 165: 162 00013040 # { ! 166: 163 00013040 # print_pipe12_er( ". No overflow fault seen." ); ! 167: 164 00013040 .data 1 ! 168: 165 00000504 * L402: ! 169: 166 00000504 * 2E204E6F206F766572666C6F7 .ascii ". No overflow fault seen.\0" ! 170: 7206661756C74207365656E2E ! 171: 00 ! 172: 167 0000051e * .text ! 173: 168 00013040 dd 8f00000504 pushl $L402 ! 174: 169 00013046 fe 08 ef00000273 callf $8,_print_pipe12_er ! 175: 170 0001304D # writes("op1 = "); ! 176: 171 0001304D .data 1 ! 177: 172 0000051e * L404: ! 178: 173 0000051e * 6F7031203D2000 .ascii "op1 = \0" ! 179: 174 00000525 * .text ! 180: 175 0001304D dd 8f0000051e pushl $L404 ! 181: 176 00013053 fe 08 effffffea6 callf $8,_writes ! 182: 177 0001305A # write32h( dbl_ld_acc.m ); ! 183: 178 0001305A dd effffffea0 pushl _dbl_ld_acc ! 184: 179 00013060 fe 08 effffffe99 callf $8,_write32h ! 185: 180 00013067 # writec(' '); ! 186: 181 00013067 dd 20 pushl $32 ! 187: 182 00013069 fe 08 effffffe90 callf $8,_writec ! 188: 183 00013070 # write32h( dbl_ld_acc.l ); ! 189: 184 00013070 dd effffffe8e pushl _dbl_ld_acc+4 ! 190: 185 00013076 fe 08 effffffe83 callf $8,_write32h ! 191: 186 0001307D # writec('\n'); ! 192: 187 0001307D dd 0a pushl $10 ! 193: 188 0001307F fe 08 effffffe7a callf $8,_writec ! 194: 189 00013086 # } ! 195: 190 00013086 # if ( halt_flg ) /* halt on error? */ ! 196: 191 00013086 L400: ! 197: 192 00013086 5d effffffe74 tstl _halt_flg ! 198: 193 0001308C 31 09 jeql L407 ! 199: 194 0001308E # pipe12_halt( 1 ); /* halt with a code of 1 */ ! 200: 195 0001308E dd 01 pushl $1 ! 201: 196 00013090 fe 08 ef000002c7 callf $8,_pipe12_halt ! 202: 197 00013097 # if ( loop_on_err ) ! 203: 198 00013097 L407: ! 204: 199 00013097 5d effffffe63 tstl _loop_on_err ! 205: 200 0001309D 31 0d jeql L409 ! 206: 201 0001309F # { ! 207: 202 0001309F # force_loop = TRUE; /* set the force loop flag */ ! 208: 203 0001309F 0d 01 effffffe5a movl $1,_force_loop ! 209: 204 000130A6 # asm("jmp _pipe12_lp1"); /* and loop */ ! 210: 205 000130A6 71 effffffee2 jmp _pipe12_lp1 ! 211: 206 000130AC # }; ! 212: 207 000130AC L409: ! 213: 208 000130AC # } ! 214: 209 000130AC 40 ret#2 ! 215: 210 000130AD .set L396,0x0 ! 216: 211 000130AD L398: ! 217: 212 000130AD 11 83 jbr L399 ! 218: 213 000130AF .data ! 219: 214 00000504 * .text ! 220: 215 000130AF 00 .align 1 ! 221: 216 000130B0 .globl _bad_pipe12_result ! 222: 217 000130B0 _bad_pipe12_result: ! 223: 218 000130B0 0000 .word L410 ! 224: 219 000130B2 # ! 225: 220 000130B2 # ! 226: 221 000130B2 # ! 227: 222 000130B2 # ! 228: 223 000130B2 # /**************************************************************************** ! 229: 224 000130B2 # * Report an "BAD ACCUMULATOR AFTER THE EVENT" error ! 230: 225 000130B2 # * ! 231: 226 000130B2 # * Cycle: xx. EVT test xx. subtest xx. Bad final Accumulator. index = xx ! 232: 227 000130B2 # * inst = LDD op1, CVDF, LDD op2 (overflow fault on the CVDF) ! 233: 228 000130B2 # * The 2nd LOAD DOUBLE instruction should not be executed. ! 234: 229 000130B2 # * op1 = xxxxxxxx xxxxxxxx, final Acc. = xxxxxxxx ! 235: 230 000130B2 # * op2 = xxxxxxxx xxxxxxxx, expected = xxxxxxxx ! 236: 231 000130B2 # ****************************************************************************/ ! 237: 232 000130B2 # bad_pipe12_result() ! 238: 233 000130B2 # { ! 239: 234 000130B2 13 00eb jbr L412 ! 240: 235 000130B5 L413: ! 241: 236 000130B5 # errcnt++; /* bump the error count */ ! 242: 237 000130B5 6d effffffe45 incl _errcnt ! 243: 238 000130BB # if ( prt_error ) ! 244: 239 000130BB 5d effffffe3f tstl _prt_error ! 245: 240 000130C1 21 03 13 00b3 jeql L414 ! 246: 241 000130C6 # { ! 247: 242 000130C6 # print_pipe12_er( ". Bad final Accumulator" ); ! 248: 243 000130C6 .data 1 ! 249: 244 00000525 * L415: ! 250: 245 00000525 * 2E204261642066696E616C204 .ascii ". Bad final Accumulator\0" ! 251: 16363756D756C61746F7200 ! 252: 246 0000053d * .text ! 253: 247 000130C6 dd 8f00000525 pushl $L415 ! 254: 248 000130CC fe 08 ef000001ed callf $8,_print_pipe12_er ! 255: 249 000130D3 # writes( ! 256: 250 000130D3 # "The 2nd LOAD DOUBLE INSTRUCTION should not be executed\n"); ! 257: 251 000130D3 .data 1 ! 258: 252 0000053d * L416: ! 259: 253 0000053d * 54686520326E64204C4F41442 .ascii "The 2nd LOAD DOUBLE INSTRUCTION should not be executed\12\0" ! 260: 0444F55424C4520494E535452 ! 261: 554354494F4E2073686F756C6 ! 262: 4206E6F742062652065786563 ! 263: 757465640A00 ! 264: 254 00000575 * .text ! 265: 255 000130D3 dd 8f0000053d pushl $L416 ! 266: 256 000130D9 fe 08 effffffe20 callf $8,_writes ! 267: 257 000130E0 # writes("op1 = "); ! 268: 258 000130E0 .data 1 ! 269: 259 00000575 * L417: ! 270: 260 00000575 * 6F7031203D2000 .ascii "op1 = \0" ! 271: 261 0000057c * .text ! 272: 262 000130E0 dd 8f00000575 pushl $L417 ! 273: 263 000130E6 fe 08 effffffe13 callf $8,_writes ! 274: 264 000130ED # write32h( dbl_ld_acc.m ); ! 275: 265 000130ED dd effffffe0d pushl _dbl_ld_acc ! 276: 266 000130F3 fe 08 effffffe06 callf $8,_write32h ! 277: 267 000130FA # writec(' '); ! 278: 268 000130FA dd 20 pushl $32 ! 279: 269 000130FC fe 08 effffffdfd callf $8,_writec ! 280: 270 00013103 # write32h( dbl_ld_acc.l ); ! 281: 271 00013103 dd effffffdfb pushl _dbl_ld_acc+4 ! 282: 272 00013109 fe 08 effffffdf0 callf $8,_write32h ! 283: 273 00013110 # writes(", final Acc. = "); ! 284: 274 00013110 .data 1 ! 285: 275 0000057c * L418: ! 286: 276 0000057c * 2C2066696E616C204163632E2 .ascii ", final Acc. = \0" ! 287: 03D2000 ! 288: 277 0000058c * .text ! 289: 278 00013110 dd 8f0000057c pushl $L418 ! 290: 279 00013116 fe 08 effffffde3 callf $8,_writes ! 291: 280 0001311D # write32h( post_evt_acc.m ); ! 292: 281 0001311D dd effffffddd pushl _post_evt_acc ! 293: 282 00013123 fe 08 effffffdd6 callf $8,_write32h ! 294: 283 0001312A # writes("op2 = "); ! 295: 284 0001312A .data 1 ! 296: 285 0000058c * L419: ! 297: 286 0000058c * 6F7032203D2000 .ascii "op2 = \0" ! 298: 287 00000593 * .text ! 299: 288 0001312A dd 8f0000058c pushl $L419 ! 300: 289 00013130 fe 08 effffffdc9 callf $8,_writes ! 301: 290 00013137 # write32h( dbl_value_1.m ); ! 302: 291 00013137 dd effffffdc3 pushl _dbl_value_1 ! 303: 292 0001313D fe 08 effffffdbc callf $8,_write32h ! 304: 293 00013144 # writec(' '); ! 305: 294 00013144 dd 20 pushl $32 ! 306: 295 00013146 fe 08 effffffdb3 callf $8,_writec ! 307: 296 0001314D # write32h( dbl_value_1.l ); ! 308: 297 0001314D dd effffffdb1 pushl _dbl_value_1+4 ! 309: 298 00013153 fe 08 effffffda6 callf $8,_write32h ! 310: 299 0001315A # writes(", expected = "); ! 311: 300 0001315A .data 1 ! 312: 301 00000593 * L420: ! 313: 302 00000593 * 2C20202065787065637465642 .ascii ", expected = \0" ! 314: 03D2000 ! 315: 303 000005a3 * .text ! 316: 304 0001315A dd 8f00000593 pushl $L420 ! 317: 305 00013160 fe 08 effffffd99 callf $8,_writes ! 318: 306 00013167 # write32h( 0 ); /* expected = floating '0.0' */ ! 319: 307 00013167 dd 00 pushl $0 ! 320: 308 00013169 fe 08 effffffd90 callf $8,_write32h ! 321: 309 00013170 # writec('\n'); ! 322: 310 00013170 dd 0a pushl $10 ! 323: 311 00013172 fe 08 effffffd87 callf $8,_writec ! 324: 312 00013179 # } ! 325: 313 00013179 # if ( halt_flg ) /* halt on error? */ ! 326: 314 00013179 L414: ! 327: 315 00013179 5d effffffd81 tstl _halt_flg ! 328: 316 0001317F 31 09 jeql L421 ! 329: 317 00013181 # pipe12_halt( 2 ); /* halt with a code of 2 */ ! 330: 318 00013181 dd 02 pushl $2 ! 331: 319 00013183 fe 08 ef000001d4 callf $8,_pipe12_halt ! 332: 320 0001318A # if ( loop_on_err ) ! 333: 321 0001318A L421: ! 334: 322 0001318A 5d effffffd70 tstl _loop_on_err ! 335: 323 00013190 31 0d jeql L422 ! 336: 324 00013192 # { ! 337: 325 00013192 # force_loop = TRUE; /* set the force loop flag */ ! 338: 326 00013192 0d 01 effffffd67 movl $1,_force_loop ! 339: 327 00013199 # asm("jmp _pipe12_lp1"); /* and loop */ ! 340: 328 00013199 71 effffffdef jmp _pipe12_lp1 ! 341: 329 0001319F # }; ! 342: 330 0001319F L422: ! 343: 331 0001319F # } ! 344: 332 0001319F 40 ret#2 ! 345: 333 000131A0 .set L410,0x0 ! 346: 334 000131A0 L412: ! 347: 335 000131A0 13 ff12 jbr L413 ! 348: 336 000131A3 .data ! 349: 337 00000504 * .text ! 350: 338 000131A3 00 .align 1 ! 351: 339 000131A4 .globl _pipe12_queue_er ! 352: 340 000131A4 _pipe12_queue_er: ! 353: 341 000131A4 0000 .word L423 ! 354: 342 000131A6 # ! 355: 343 000131A6 # ! 356: 344 000131A6 # ! 357: 345 000131A6 # ! 358: 346 000131A6 # ! 359: 347 000131A6 # /**************************************************************************** ! 360: 348 000131A6 # * Report an "FPP queue not cleared" message ! 361: 349 000131A6 # * ! 362: 350 000131A6 # * Cycle: xx. EVT test xx. subtest xx. Fpp queue not cleared. index = xx ! 363: 351 000131A6 # * inst = LDD op1, CVDF, LDD op2 (overflow fault on the CVDF) ! 364: 352 000131A6 # * The 2nd load double instruction was apparently executed. ! 365: 353 000131A6 # * op1 = xxxxxxxx xxxxxxxx, final Acc. = xxxxxxxx xxxxxxxx ! 366: 354 000131A6 # * op2 = xxxxxxxx xxxxxxxx, expected = xxxxxxxx xxxxxxxx ! 367: 355 000131A6 # ****************************************************************************/ ! 368: 356 000131A6 # pipe12_queue_er() ! 369: 357 000131A6 # { ! 370: 358 000131A6 13 0113 jbr L425 ! 371: 359 000131A9 L426: ! 372: 360 000131A9 # errcnt++; /* bump the error count */ ! 373: 361 000131A9 6d effffffd51 incl _errcnt ! 374: 362 000131AF # if ( prt_error ) ! 375: 363 000131AF 5d effffffd4b tstl _prt_error ! 376: 364 000131B5 21 03 13 00db jeql L427 ! 377: 365 000131BA # { ! 378: 366 000131BA # print_pipe12_er( ". Fpp queue not cleared" ); ! 379: 367 000131BA .data 1 ! 380: 368 000005a3 * L428: ! 381: 369 000005a3 * 2E20467070207175657565206 .ascii ". Fpp queue not cleared\0" ! 382: E6F7420636C656172656400 ! 383: 370 000005bb * .text ! 384: 371 000131BA dd 8f000005a3 pushl $L428 ! 385: 372 000131C0 fe 08 ef000000f9 callf $8,_print_pipe12_er ! 386: 373 000131C7 # writes( ! 387: 374 000131C7 # "The 2nd load double instruction was apparently executed.\n"); ! 388: 375 000131C7 .data 1 ! 389: 376 000005bb * L429: ! 390: 377 000005bb * 54686520326E64206C6F61642 .ascii "The 2nd load double instruction was apparently executed.\12\0" ! 391: 0646F75626C6520696E737472 ! 392: 756374696F6E2077617320617 ! 393: 0706172656E746C7920657865 ! 394: 63757465642E0A00 ! 395: 378 000005f5 * .text ! 396: 379 000131C7 dd 8f000005bb pushl $L429 ! 397: 380 000131CD fe 08 effffffd2c callf $8,_writes ! 398: 381 000131D4 # writes("op1 = "); ! 399: 382 000131D4 .data 1 ! 400: 383 000005f5 * L430: ! 401: 384 000005f5 * 6F7031203D2000 .ascii "op1 = \0" ! 402: 385 000005fc * .text ! 403: 386 000131D4 dd 8f000005f5 pushl $L430 ! 404: 387 000131DA fe 08 effffffd1f callf $8,_writes ! 405: 388 000131E1 # write32h( dbl_ld_acc.m ); ! 406: 389 000131E1 dd effffffd19 pushl _dbl_ld_acc ! 407: 390 000131E7 fe 08 effffffd12 callf $8,_write32h ! 408: 391 000131EE # writec(' '); ! 409: 392 000131EE dd 20 pushl $32 ! 410: 393 000131F0 fe 08 effffffd09 callf $8,_writec ! 411: 394 000131F7 # write32h( dbl_ld_acc.l ); ! 412: 395 000131F7 dd effffffd07 pushl _dbl_ld_acc+4 ! 413: 396 000131FD fe 08 effffffcfc callf $8,_write32h ! 414: 397 00013204 # writes(", final Acc. = "); ! 415: 398 00013204 .data 1 ! 416: 399 000005fc * L431: ! 417: 400 000005fc * 2C2066696E616C204163632E2 .ascii ", final Acc. = \0" ! 418: 03D2000 ! 419: 401 0000060c * .text ! 420: 402 00013204 dd 8f000005fc pushl $L431 ! 421: 403 0001320A fe 08 effffffcef callf $8,_writes ! 422: 404 00013211 # write32h( post_evt_acc.m ); ! 423: 405 00013211 dd effffffce9 pushl _post_evt_acc ! 424: 406 00013217 fe 08 effffffce2 callf $8,_write32h ! 425: 407 0001321E # writec(' '); ! 426: 408 0001321E dd 20 pushl $32 ! 427: 409 00013220 fe 08 effffffcd9 callf $8,_writec ! 428: 410 00013227 # write32h( post_evt_acc.l ); ! 429: 411 00013227 dd effffffcd7 pushl _post_evt_acc+4 ! 430: 412 0001322D fe 08 effffffccc callf $8,_write32h ! 431: 413 00013234 # writes("\nop2 = "); ! 432: 414 00013234 .data 1 ! 433: 415 0000060c * L432: ! 434: 416 0000060c * 0A6F7032203D2000 .ascii "\12op2 = \0" ! 435: 417 00000614 * .text ! 436: 418 00013234 dd 8f0000060c pushl $L432 ! 437: 419 0001323A fe 08 effffffcbf callf $8,_writes ! 438: 420 00013241 # write32h( dbl_value_1.m ); ! 439: 421 00013241 dd effffffcb9 pushl _dbl_value_1 ! 440: 422 00013247 fe 08 effffffcb2 callf $8,_write32h ! 441: 423 0001324E # writec(' '); ! 442: 424 0001324E dd 20 pushl $32 ! 443: 425 00013250 fe 08 effffffca9 callf $8,_writec ! 444: 426 00013257 # write32h( dbl_value_1.l ); ! 445: 427 00013257 dd effffffca7 pushl _dbl_value_1+4 ! 446: 428 0001325D fe 08 effffffc9c callf $8,_write32h ! 447: 429 00013264 # writes(", expected = "); ! 448: 430 00013264 .data 1 ! 449: 431 00000614 * L433: ! 450: 432 00000614 * 2C20202065787065637465642 .ascii ", expected = \0" ! 451: 03D2000 ! 452: 433 00000624 * .text ! 453: 434 00013264 dd 8f00000614 pushl $L433 ! 454: 435 0001326A fe 08 effffffc8f callf $8,_writes ! 455: 436 00013271 # write32h( 0x ); /* expected = floating '0' */ ! 456: 437 00013271 dd 00 pushl $0 ! 457: 438 00013273 fe 08 effffffc86 callf $8,_write32h ! 458: 439 0001327A # writec(' '); ! 459: 440 0001327A dd 20 pushl $32 ! 460: 441 0001327C fe 08 effffffc7d callf $8,_writec ! 461: 442 00013283 # write32h( 0 ); ! 462: 443 00013283 dd 00 pushl $0 ! 463: 444 00013285 fe 08 effffffc74 callf $8,_write32h ! 464: 445 0001328C # writec('\n'); ! 465: 446 0001328C dd 0a pushl $10 ! 466: 447 0001328E fe 08 effffffc6b callf $8,_writec ! 467: 448 00013295 # } ! 468: 449 00013295 # if ( halt_flg ) /* halt on error? */ ! 469: 450 00013295 L427: ! 470: 451 00013295 5d effffffc65 tstl _halt_flg ! 471: 452 0001329B 31 09 jeql L434 ! 472: 453 0001329D # pipe12_halt( 3 ); /* halt with a code of 3 */ ! 473: 454 0001329D dd 03 pushl $3 ! 474: 455 0001329F fe 08 ef000000b8 callf $8,_pipe12_halt ! 475: 456 000132A6 # if ( loop_on_err ) ! 476: 457 000132A6 L434: ! 477: 458 000132A6 5d effffffc54 tstl _loop_on_err ! 478: 459 000132AC 31 0d jeql L435 ! 479: 460 000132AE # { ! 480: 461 000132AE # force_loop = TRUE; /* set the force loop flag */ ! 481: 462 000132AE 0d 01 effffffc4b movl $1,_force_loop ! 482: 463 000132B5 # asm("jmp _pipe12_lp1"); /* and loop */ ! 483: 464 000132B5 71 effffffcd3 jmp _pipe12_lp1 ! 484: 465 000132BB # }; ! 485: 466 000132BB L435: ! 486: 467 000132BB # } ! 487: 468 000132BB 40 ret#2 ! 488: 469 000132BC .set L423,0x0 ! 489: 470 000132BC L425: ! 490: 471 000132BC 13 feea jbr L426 ! 491: 472 000132BF .data ! 492: 473 00000504 * .text ! 493: 474 000132BF 00 .align 1 ! 494: 475 000132C0 .globl _print_pipe12_er ! 495: 476 000132C0 _print_pipe12_er: ! 496: 477 000132C0 0000 .word L436 ! 497: 478 000132C2 # ! 498: 479 000132C2 # ! 499: 480 000132C2 # ! 500: 481 000132C2 # ! 501: 482 000132C2 # /**************************************************************************** ! 502: 483 000132C2 # * Report an error message of the form: ! 503: 484 000132C2 # * ! 504: 485 000132C2 # * Cycle: xx. EVT test xx. subtest xx. <your message here> index = xx ! 505: 486 000132C2 # * inst = LDD op1, CVDF, LDD op2 (overflow fault on the CVDF) ! 506: 487 000132C2 # ****************************************************************************/ ! 507: 488 000132C2 # print_pipe12_er( msg ) ! 508: 489 000132C2 # char *msg; /* error message to print */ ! 509: 490 000132C2 # { ! 510: 491 000132C2 13 0096 jbr L438 ! 511: 492 000132C5 L439: ! 512: 493 000132C5 # if( errcnt == 1 ) /* 1st error? */ ! 513: 494 000132C5 1d effffffc35 01 cmpl _errcnt,$1 ! 514: 495 000132CC 21 0d jneq L440 ! 515: 496 000132CE # writes(" \n"); /* start a new print line */ ! 516: 497 000132CE .data 1 ! 517: 498 00000624 * L441: ! 518: 499 00000624 * 200A00 .ascii " \12\0" ! 519: 500 00000627 * .text ! 520: 501 000132CE dd 8f00000624 pushl $L441 ! 521: 502 000132D4 fe 08 effffffc25 callf $8,_writes ! 522: 503 000132DB # writes("Cycle: "); ! 523: 504 000132DB L440: ! 524: 505 000132DB .data 1 ! 525: 506 00000627 * L442: ! 526: 507 00000627 * 4379636C653A2000 .ascii "Cycle: \0" ! 527: 508 0000062f * .text ! 528: 509 000132DB dd 8f00000627 pushl $L442 ! 529: 510 000132E1 fe 08 effffffc18 callf $8,_writes ! 530: 511 000132E8 # writed( cycle ); ! 531: 512 000132E8 dd effffffc12 pushl _cycle ! 532: 513 000132EE fe 08 effffffc0b callf $8,_writed ! 533: 514 000132F5 # writes(" EVT test "); ! 534: 515 000132F5 .data 1 ! 535: 516 0000062f * L444: ! 536: 517 0000062f * 202045565420746573742000 .ascii " EVT test \0" ! 537: 518 0000063b * .text ! 538: 519 000132F5 dd 8f0000062f pushl $L444 ! 539: 520 000132FB fe 08 effffffbfe callf $8,_writes ! 540: 521 00013302 # writed( test_no ); ! 541: 522 00013302 dd effffffbf8 pushl _test_no ! 542: 523 00013308 fe 08 effffffbf1 callf $8,_writed ! 543: 524 0001330F # writes(". subtest "); ! 544: 525 0001330F .data 1 ! 545: 526 0000063b * L445: ! 546: 527 0000063b * 2E20737562746573742000 .ascii ". subtest \0" ! 547: 528 00000646 * .text ! 548: 529 0001330F dd 8f0000063b pushl $L445 ! 549: 530 00013315 fe 08 effffffbe4 callf $8,_writes ! 550: 531 0001331C # writed( subtest ); ! 551: 532 0001331C dd effffffbde pushl _subtest ! 552: 533 00013322 fe 08 effffffbd7 callf $8,_writed ! 553: 534 00013329 # writes( msg ); /* print the message */ ! 554: 535 00013329 dd ad04 pushl 4(fp) ! 555: 536 0001332C fe 08 effffffbcd callf $8,_writes ! 556: 537 00013333 # writes(" index = "); ! 557: 538 00013333 .data 1 ! 558: 539 00000646 * L446: ! 559: 540 00000646 * 20696E646578203D2000 .ascii " index = \0" ! 560: 541 00000650 * .text ! 561: 542 00013333 dd 8f00000646 pushl $L446 ! 562: 543 00013339 fe 08 effffffbc0 callf $8,_writes ! 563: 544 00013340 # writed( index ); ! 564: 545 00013340 dd effffffbba pushl _index ! 565: 546 00013346 fe 08 effffffbb3 callf $8,_writed ! 566: 547 0001334D # writes( ! 567: 548 0001334D # "\ninst = LDD op1, CVDF, LDD op2 (overflow fault on the CVDF)\n"); ! 568: 549 0001334D .data 1 ! 569: 550 00000650 * L447: ! 570: 551 00000650 * 0A696E7374203D204C4444206 .ascii "\12inst = LDD op1, CVDF, LDD op2 (overflow fault on the CVDF)\12\0" ! 571: F70312C20435644462C204C44 ! 572: 44206F703220202020286F766 ! 573: 572666C6F77206661756C7420 ! 574: 6F6E207468652043564446290 ! 575: A00 ! 576: 552 00000690 * .text ! 577: 553 0001334D dd 8f00000650 pushl $L447 ! 578: 554 00013353 fe 08 effffffba6 callf $8,_writes ! 579: 555 0001335A # } ! 580: 556 0001335A 40 ret#2 ! 581: 557 0001335B .set L436,0x0 ! 582: 558 0001335B L438: ! 583: 559 0001335B 13 ff67 jbr L439 ! 584: 560 0001335E .data ! 585: 561 00000504 * .text ! 586: 562 0001335E .align 1 ! 587: 563 0001335E .globl _pipe12_halt ! 588: 564 0001335E _pipe12_halt: ! 589: 565 0001335E 0000 .word L448 ! 590: 566 00013360 # ! 591: 567 00013360 # ! 592: 568 00013360 # ! 593: 569 00013360 # /**************************************************************************** ! 594: 570 00013360 # * halt on error routine ! 595: 571 00013360 # ****************************************************************************/ ! 596: 572 00013360 # pipe12_halt( code ) ! 597: 573 00013360 # int code; /* error code to halt with */ ! 598: 574 00013360 # { ! 599: 575 00013360 13 009b jbr L450 ! 600: 576 00013363 L451: ! 601: 577 00013363 # err_code = code; ! 602: 578 00013363 0d ad04 effffffb95 movl 4(fp),_err_code ! 603: 579 0001336B # sgl_value_1 = dbl_ld_acc.m; ! 604: 580 0001336B 0d effffffb8f effffffb8a movl _dbl_ld_acc,_sgl_value_1 ! 605: 581 00013376 # sgl_value_2 = dbl_ld_acc.l; ! 606: 582 00013376 0d effffffb88 effffffb7f movl _dbl_ld_acc+4,_sgl_value_2 ! 607: 583 00013381 # sgl_value_3 = dbl_value_1.m; ! 608: 584 00013381 0d effffffb79 effffffb74 movl _dbl_value_1,_sgl_value_3 ! 609: 585 0001338C # sgl_value_4 = dbl_value_1.l; ! 610: 586 0001338C 0d effffffb72 effffffb69 movl _dbl_value_1+4,_sgl_value_4 ! 611: 587 00013397 # sgl_value_5 = post_evt_acc.m; ! 612: 588 00013397 0d effffffb63 effffffb5e movl _post_evt_acc,_sgl_value_5 ! 613: 589 000133A2 # sgl_value_6 = post_evt_acc.l; ! 614: 590 000133A2 0d effffffb5c effffffb53 movl _post_evt_acc+4,_sgl_value_6 ! 615: 591 000133AD # asm("movl _test_no,r0"); /* r0 = test number */ ! 616: 592 000133AD 0d effffffb4d 50 movl _test_no,r0 ! 617: 593 000133B4 # asm("movl _subtest,r1"); /* r1 = subtest number */ ! 618: 594 000133B4 0d effffffb46 51 movl _subtest,r1 ! 619: 595 000133BB # asm("movl _err_code,r2"); /* r2 = error code */ ! 620: 596 000133BB 0d effffffb3f 52 movl _err_code,r2 ! 621: 597 000133C2 # asm("movl _cycle,r3"); /* r3 = cycle count */ ! 622: 598 000133C2 0d effffffb38 53 movl _cycle,r3 ! 623: 599 000133C9 # asm("movl _sgl_value_1,r4"); /* r4 = MSW of 1st load. */ ! 624: 600 000133C9 0d effffffb31 54 movl _sgl_value_1,r4 ! 625: 601 000133D0 # asm("movl _sgl_value_2,r5"); /* r5 = LSW of 1st load. */ ! 626: 602 000133D0 0d effffffb2a 55 movl _sgl_value_2,r5 ! 627: 603 000133D7 # asm("movl _sgl_value_3,r6"); /* r6 = MSW of 2nd load. */ ! 628: 604 000133D7 0d effffffb23 56 movl _sgl_value_3,r6 ! 629: 605 000133DE # asm("movl _sgl_value_4,r7"); /* r7 = LSW of 2nd load. */ ! 630: 606 000133DE 0d effffffb1c 57 movl _sgl_value_4,r7 ! 631: 607 000133E5 # asm("movl _sgl_value_5,r8"); /* r8 = MSW of final Acc. */ ! 632: 608 000133E5 0d effffffb15 58 movl _sgl_value_5,r8 ! 633: 609 000133EC # asm("movl _sgl_value_6,r9"); /* r9 = LSW of final Acc. */ ! 634: 610 000133EC 0d effffffb0e 59 movl _sgl_value_6,r9 ! 635: 611 000133F3 # asm("clrl r10"); /* r10 = expected ( '0' ) */ ! 636: 612 000133F3 4d 5a clrl r10 ! 637: 613 000133F5 # asm("movl _index,r11"); /* r11 = data index */ ! 638: 614 000133F5 0d effffffb05 5b movl _index,r11 ! 639: 615 000133FC # asm("halt"); /* HALT ... */ ! 640: 616 000133FC 00 halt ! 641: 617 000133FD # } ! 642: 618 000133FD 40 ret#2 ! 643: 619 000133FE .set L448,0x0 ! 644: 620 000133FE L450: ! 645: 621 000133FE 13 ff62 jbr L451 ! 646: 622 00013401 .data ! 647: 622 00026301 .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.