![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe9.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 pipe9.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 00000488 * .text ! 4: 4 00000000 .align 1 ! 5: 5 00000000 .globl _pipe9 ! 6: 6 00000000 _pipe9: ! 7: 7 0001208C 0000 .word L381 ! 8: 8 0001208E # ! 9: 9 0001208E # #include "evt_defs.h" ! 10: 10 0001208E # ! 11: 11 0001208E # /* ! 12: 12 0001208E # ********************************************************************* ! 13: 13 0001208E # * FPP PIPELINED EVENTS TEST #9 ! 14: 14 0001208E # * ! 15: 15 0001208E # * This test will execute the following code: "LDF DIVF CVLF $2" ! 16: 16 0001208E # * with a divide by zero fault on the DIVF. We will make sure that: ! 17: 17 0001208E # * 1. The fault is detected, and ! 18: 18 0001208E # * 2. the convert instruction is not executed. ! 19: 19 0001208E # ********************************************************************* ! 20: 20 0001208E # */ ! 21: 21 0001208E # pipe9() ! 22: 22 0001208E # { ! 23: 23 0001208E 13 0146 jbr L383 ! 24: 24 00012091 L384: ! 25: 25 00012091 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */ ! 26: 26 00012091 ed 6d effffffff4 moval (r13),_pre_event_fp ! 27: 27 00012098 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */ ! 28: 28 00012098 ed 6e efffffffed moval (r14),_pre_event_sp ! 29: 29 0001209F # precision = SGL; ! 30: 30 0001209F 0d 01 efffffffe6 movl $1,_precision ! 31: 31 000120A6 # test_event = ARITH_CODE; /* expect an arithmetic fault */ ! 32: 32 000120A6 0d 34 efffffffdf movl $52,_test_event ! 33: 33 000120AD # exp_code = FLT_0_DIV_CODE; /* - specificly div by 0 */ ! 34: 34 000120AD 0d 03 efffffffd8 movl $3,_exp_code ! 35: 35 000120B4 # exp_event = FALSE; /* ... but not yet */ ! 36: 36 000120B4 4d efffffffd2 clrl _exp_event ! 37: 37 000120BA # asm("movab _pipe9_ret,_event_return"); /* set event return address */ ! 38: 38 000120BA e9 ef000000c7 efffffffc7 movab _pipe9_ret,_event_return ! 39: 39 000120C5 # max_index = zero_divide_cnt; /* set max operand index */ ! 40: 40 000120C5 0d efffffffc1 efffffffbc movl _zero_divide_cnt,_max_index ! 41: 41 000120D0 # for( index = 0; index < max_index; index++ ) ! 42: 42 000120D0 4d efffffffb6 clrl _index ! 43: 43 000120D6 L387: ! 44: 44 000120D6 1d efffffffb0 efffffffab cmpl _index,_max_index ! 45: 45 000120E1 91 03 13 00f0 jgeq L386 ! 46: 46 000120E6 # { ! 47: 47 000120E6 # dbl_ld_acc = zero_divide_data[index].op_1; /* get the Acc data */ ! 48: 48 000120E6 48 04 efffffff9f 50 shll $4,_index,r0 ! 49: 49 000120EE 0c 8f00000000 50 addl2 $_zero_divide_data,r0 ! 50: 50 000120F5 0d a004 efffffff93 movl 4(r0),_dbl_ld_acc+4 ! 51: 51 000120FD 0d 60 efffffff88 movl (r0),_dbl_ld_acc ! 52: 52 00012104 # dbl_value_1 = zero_divide_data[index].op_2; /* get the '0' data */ ! 53: 53 00012104 48 04 efffffff81 50 shll $4,_index,r0 ! 54: 54 0001210C 0c 8f00000008 50 addl2 $_zero_divide_data+8,r0 ! 55: 55 00012113 0d a004 efffffff75 movl 4(r0),_dbl_value_1+4 ! 56: 56 0001211B 0d 60 efffffff6a movl (r0),_dbl_value_1 ! 57: 57 00012122 # if( dbl_ld_acc.m & 0x7f800000 ) ! 58: 58 00012122 3d 8f7f800000 efffffff5f bitl $2139095040,_dbl_ld_acc ! 59: 59 0001212D 31 0d jeql L388 ! 60: 60 0001212F # dbl_expected.m = dbl_ld_acc.m; /* The final Acc s/b */ ! 61: 61 0001212F 0d efffffff57 efffffff52 movl _dbl_ld_acc,_dbl_expected ! 62: 62 0001213A # else ! 63: 63 0001213A 11 06 jbr L389 ! 64: 64 0001213C L388: ! 65: 65 0001213C # dbl_expected.m = 0; /* = the initial Acc */ ! 66: 66 0001213C 4d efffffff4a clrl _dbl_expected ! 67: 67 00012142 L389: ! 68: 68 00012142 # asm("bispsw $0x60"); /* enable ovfl,undfl */ ! 69: 69 00012142 8b 8860 bispsw $0x60 ! 70: 70 00012145 # asm(".globl _pipe9_lp1"); ! 71: 71 00012145 .globl _pipe9_lp1 ! 72: 72 00012145 # asm("_pipe9_lp1:"); ! 73: 73 00012145 _pipe9_lp1: ! 74: 74 00012145 # asm("ldf _dbl_ld_acc"); /* load the Acc. */ ! 75: 75 00012145 06 efffffff41 ldf _dbl_ld_acc ! 76: 76 0001214B # exp_event = test_event; /* expect event soon */ ! 77: 77 0001214B 0d efffffff3b efffffff36 movl _test_event,_exp_event ! 78: 78 00012156 # asm("divf _dbl_value_1"); /* trigger the event */ ! 79: 79 00012156 f6 efffffff30 divf _dbl_value_1 ! 80: 80 0001215C # asm("cvlf $2"); /* shouldn't get here*/ ! 81: 81 0001215C 76 02 cvlf $2 ! 82: 82 0001215E # /* ! 83: 83 0001215E # * If we got to here then there was no event ! 84: 84 0001215E # */ ! 85: 85 0001215E # if( force_loop ) ! 86: 86 0001215E 5d efffffff28 tstl _force_loop ! 87: 87 00012164 31 03 jeql L390 ! 88: 88 00012166 # asm("brw _pipe9_lp1");; /* loop on the error */ ! 89: Assemb0002984C # asm("brw _pipe9_lp1");; /* loop on the error */ ! 90: "pipe90002984C 89: WARNING: brw: destination label is external ! 91: 89 00012166 13 ffdc brw _pipe9_lp1 ! 92: 90 00012169 L390: ! 93: 91 00012169 # exp_event = FALSE; /* reset event expected flag */ ! 94: 92 00012169 4d efffffff1d clrl _exp_event ! 95: 93 0001216F # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */ ! 96: 94 0001216F 0d efffffff17 5d movl _pre_event_fp,fp ! 97: 95 00012176 # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */ ! 98: 96 00012176 0d efffffff10 5e movl _pre_event_sp,sp ! 99: 97 0001217D # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */ ! 100: 98 0001217D 9b 8860 bicpsw $0x60 ! 101: 99 00012180 # no_pipe9_evt();; /* report the error */ ! 102: 100 00012180 fe 04 ef00000053 callf $4,_no_pipe9_evt ! 103: 101 00012187 # /* ! 104: 102 00012187 # * Come here after the event ! 105: 103 00012187 # */ ! 106: 104 00012187 # asm(".globl _pipe9_ret"); ! 107: 105 00012187 .globl _pipe9_ret ! 108: 106 00012187 # asm("_pipe9_ret:"); ! 109: 107 00012187 _pipe9_ret: ! 110: 108 00012187 # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */ ! 111: 109 00012187 0d effffffeff 5d movl _pre_event_fp,fp ! 112: 110 0001218E # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */ ! 113: 111 0001218E 0d effffffef8 5e movl _pre_event_sp,sp ! 114: 112 00012195 # if( force_loop ) ! 115: 113 00012195 5d effffffef1 tstl _force_loop ! 116: 114 0001219B 31 03 jeql L392 ! 117: 115 0001219D # asm("brw _pipe9_lp1");; /* loop on the error */ ! 118: "pipe90002984C 116: WARNING: brw: destination label is external ! 119: 116 0001219D 13 ffa5 brw _pipe9_lp1 ! 120: 117 000121A0 L392: ! 121: 118 000121A0 # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */ ! 122: 119 000121A0 9b 8860 bicpsw $0x60 ! 123: 120 000121A3 # if( post_evt_acc.m != dbl_expected.m ) /* was the Acc modified? */ ! 124: 121 000121A3 1d effffffee3 effffffede cmpl _post_evt_acc,_dbl_expected ! 125: 122 000121AE 31 1d jeql L393 ! 126: 123 000121B0 # { ! 127: 124 000121B0 # if( post_evt_acc.m == 0x41000000 ) /* is Acc. = 2.0 ? */ ! 128: 125 000121B0 1d effffffed6 8f41000000 cmpl _post_evt_acc,$1090519040 ! 129: 126 000121BB 21 09 jneq L394 ! 130: 127 000121BD # pipe9_queue_er(); /* queue not cleared error */ ! 131: 128 000121BD fe 04 ef00000168 callf $4,_pipe9_queue_er ! 132: 129 000121C4 # else ! 133: 130 000121C4 11 07 jbr L396 ! 134: 131 000121C6 L394: ! 135: 132 000121C6 # bad_pipe9_result(); /* incorrect result error */ ! 136: 133 000121C6 fe 04 ef00000093 callf $4,_bad_pipe9_result ! 137: 134 000121CD L396: ! 138: 135 000121CD # } ! 139: 136 000121CD # } ! 140: 137 000121CD L393: ! 141: 138 000121CD L385: ! 142: 139 000121CD 6d effffffeb9 incl _index ! 143: 140 000121D3 13 ff00 jbr L387 ! 144: 141 000121D6 L386: ! 145: 142 000121D6 # } ! 146: 143 000121D6 40 ret#2 ! 147: 144 000121D7 .set L381,0x0 ! 148: 145 000121D7 L383: ! 149: 146 000121D7 13 feb7 jbr L384 ! 150: 147 000121DA .data ! 151: 148 00000488 * .text ! 152: 149 000121DA .align 1 ! 153: 150 000121DA .globl _no_pipe9_evt ! 154: 151 000121DA _no_pipe9_evt: ! 155: 152 000121DA 0000 .word L398 ! 156: 153 000121DC # ! 157: 154 000121DC # ! 158: 155 000121DC # ! 159: 156 000121DC # /**************************************************************************** ! 160: 157 000121DC # * Report an "EVENT NOT DETECTED" error ! 161: 158 000121DC # * ! 162: 159 000121DC # * Cycle: xx. EVT test xx. subtest xx. No 'divide by 0' fault seen. index = xx ! 163: 160 000121DC # * inst = LDF op1, DIVF op2, CVLF '2' ('divide by 0' fault on DIVF) ! 164: 161 000121DC # * op1 = xxxxxxxx, op2 = xxxxxxxx ! 165: 162 000121DC # ****************************************************************************/ ! 166: 163 000121DC # no_pipe9_evt() ! 167: 164 000121DC # { ! 168: 165 000121DC 11 7f jbr L400 ! 169: 166 000121DE L401: ! 170: 167 000121DE # errcnt++; /* bump the error count */ ! 171: 168 000121DE 6d effffffea8 incl _errcnt ! 172: 169 000121E4 # if ( prt_error ) ! 173: 170 000121E4 5d effffffea2 tstl _prt_error ! 174: 171 000121EA 31 4a jeql L402 ! 175: 172 000121EC # { ! 176: 173 000121EC # print_pipe9_er( ". No 'divide by 0' fault seen." ); ! 177: 174 000121EC .data 1 ! 178: 175 00000488 * L404: ! 179: 176 00000488 * 2E204E6F20276469766964652 .ascii ". No 'divide by 0' fault seen.\0" ! 180: 06279203027206661756C7420 ! 181: 7365656E2E00 ! 182: 177 000004a7 * .text ! 183: 178 000121EC dd 8f00000488 pushl $L404 ! 184: 179 000121F2 fe 08 ef000001ff callf $8,_print_pipe9_er ! 185: 180 000121F9 # writes("op1 = "); ! 186: 181 000121F9 .data 1 ! 187: 182 000004a7 * L406: ! 188: 183 000004a7 * 6F7031203D2000 .ascii "op1 = \0" ! 189: 184 000004ae * .text ! 190: 185 000121F9 dd 8f000004a7 pushl $L406 ! 191: 186 000121FF fe 08 effffffe86 callf $8,_writes ! 192: 187 00012206 # write32h( dbl_ld_acc.m ); ! 193: 188 00012206 dd effffffe80 pushl _dbl_ld_acc ! 194: 189 0001220C fe 08 effffffe79 callf $8,_write32h ! 195: 190 00012213 # writes(", op2 = "); ! 196: 191 00012213 .data 1 ! 197: 192 000004ae * L408: ! 198: 193 000004ae * 2C2020206F7032203D2000 .ascii ", op2 = \0" ! 199: 194 000004b9 * .text ! 200: 195 00012213 dd 8f000004ae pushl $L408 ! 201: 196 00012219 fe 08 effffffe6c callf $8,_writes ! 202: 197 00012220 # write32h( dbl_value_1.m ); ! 203: 198 00012220 dd effffffe66 pushl _dbl_value_1 ! 204: 199 00012226 fe 08 effffffe5f callf $8,_write32h ! 205: 200 0001222D # writec('\n'); ! 206: 201 0001222D dd 0a pushl $10 ! 207: 202 0001222F fe 08 effffffe56 callf $8,_writec ! 208: 203 00012236 # } ! 209: 204 00012236 # if ( halt_flg ) /* halt on error? */ ! 210: 205 00012236 L402: ! 211: 206 00012236 5d effffffe50 tstl _halt_flg ! 212: 207 0001223C 31 09 jeql L410 ! 213: 208 0001223E # pipe9_halt( 1 ); /* halt with a code of 1 */ ! 214: 209 0001223E dd 01 pushl $1 ! 215: 210 00012240 fe 08 ef0000025d callf $8,_pipe9_halt ! 216: 211 00012247 # if ( loop_on_err ) ! 217: 212 00012247 L410: ! 218: 213 00012247 5d effffffe3f tstl _loop_on_err ! 219: 214 0001224D 31 0d jeql L412 ! 220: 215 0001224F # { ! 221: 216 0001224F # force_loop = TRUE; /* set the force loop flag */ ! 222: 217 0001224F 0d 01 effffffe36 movl $1,_force_loop ! 223: 218 00012256 # asm("jmp _pipe9_lp1"); /* and loop */ ! 224: 219 00012256 71 effffffee9 jmp _pipe9_lp1 ! 225: 220 0001225C # }; ! 226: 221 0001225C L412: ! 227: 222 0001225C # } ! 228: 223 0001225C 40 ret#2 ! 229: 224 0001225D .set L398,0x0 ! 230: 225 0001225D L400: ! 231: 226 0001225D 13 ff7e jbr L401 ! 232: 227 00012260 .data ! 233: 228 00000488 * .text ! 234: 229 00012260 .align 1 ! 235: 230 00012260 .globl _bad_pipe9_result ! 236: 231 00012260 _bad_pipe9_result: ! 237: 232 00012260 0000 .word L413 ! 238: 233 00012262 # ! 239: 234 00012262 # ! 240: 235 00012262 # ! 241: 236 00012262 # ! 242: 237 00012262 # /**************************************************************************** ! 243: 238 00012262 # * Report an "BAD ACCUMULATOR AFTER THE EVENT" error ! 244: 239 00012262 # * ! 245: 240 00012262 # * Cycle: xx. EVT test xx. subtest xx. Bad final Accumulator. index = xx ! 246: 241 00012262 # * inst = LDF op1, DIVF op2, CVLF '2' ('divide by 0' fault on DIVF) ! 247: 242 00012262 # * The 'Convert '2' to Floating Point' should not be executed. ! 248: 243 00012262 # * op_1 = xxxxxxxx, op2 = xxxxxxxx, final Acc. = xxxxxxxx, expected = xxxxxxxx ! 249: 244 00012262 # ****************************************************************************/ ! 250: 245 00012262 # bad_pipe9_result() ! 251: 246 00012262 # { ! 252: 247 00012262 13 00c3 jbr L415 ! 253: 248 00012265 L416: ! 254: 249 00012265 # errcnt++; /* bump the error count */ ! 255: 250 00012265 6d effffffe21 incl _errcnt ! 256: 251 0001226B # if ( prt_error ) ! 257: 252 0001226B 5d effffffe1b tstl _prt_error ! 258: 253 00012271 21 03 13 008b jeql L417 ! 259: 254 00012276 # { ! 260: 255 00012276 # print_pipe9_er( ". Bad final Accumulator" ); ! 261: 256 00012276 .data 1 ! 262: 257 000004b9 * L418: ! 263: 258 000004b9 * 2E204261642066696E616C204 .ascii ". Bad final Accumulator\0" ! 264: 16363756D756C61746F7200 ! 265: 259 000004d1 * .text ! 266: 260 00012276 dd 8f000004b9 pushl $L418 ! 267: 261 0001227C fe 08 ef00000175 callf $8,_print_pipe9_er ! 268: 262 00012283 # writes( ! 269: 263 00012283 # "The 'Convert '2' to Floating Point' should not be executed\n"); ! 270: 264 00012283 .data 1 ! 271: 265 000004d1 * L419: ! 272: 266 000004d1 * 5468652027436F6E766572742 .ascii "The 'Convert '2' to Floating Point' should not be executed\12\0" ! 273: 027322720746F20466C6F6174 ! 274: 696E6720506F696E742720736 ! 275: 86F756C64206E6F7420626520 ! 276: 65786563757465640A00 ! 277: 267 0000050d * .text ! 278: 268 00012283 dd 8f000004d1 pushl $L419 ! 279: 269 00012289 fe 08 effffffdfc callf $8,_writes ! 280: 270 00012290 # writes("op1 = "); ! 281: 271 00012290 .data 1 ! 282: 272 0000050d * L420: ! 283: 273 0000050d * 6F7031203D2000 .ascii "op1 = \0" ! 284: 274 00000514 * .text ! 285: 275 00012290 dd 8f0000050d pushl $L420 ! 286: 276 00012296 fe 08 effffffdef callf $8,_writes ! 287: 277 0001229D # write32h( dbl_ld_acc.m ); ! 288: 278 0001229D dd effffffde9 pushl _dbl_ld_acc ! 289: 279 000122A3 fe 08 effffffde2 callf $8,_write32h ! 290: 280 000122AA # writes(", op1 = "); ! 291: 281 000122AA .data 1 ! 292: 282 00000514 * L421: ! 293: 283 00000514 * 2C206F7031203D2000 .ascii ", op1 = \0" ! 294: 284 0000051d * .text ! 295: 285 000122AA dd 8f00000514 pushl $L421 ! 296: 286 000122B0 fe 08 effffffdd5 callf $8,_writes ! 297: 287 000122B7 # write32h( dbl_value_1.m ); ! 298: 288 000122B7 dd effffffdcf pushl _dbl_value_1 ! 299: 289 000122BD fe 08 effffffdc8 callf $8,_write32h ! 300: 290 000122C4 # writes(", final Acc. = "); ! 301: 291 000122C4 .data 1 ! 302: 292 0000051d * L422: ! 303: 293 0000051d * 2C2066696E616C204163632E2 .ascii ", final Acc. = \0" ! 304: 03D2000 ! 305: 294 0000052d * .text ! 306: 295 000122C4 dd 8f0000051d pushl $L422 ! 307: 296 000122CA fe 08 effffffdbb callf $8,_writes ! 308: 297 000122D1 # write32h( post_evt_acc.m ); ! 309: 298 000122D1 dd effffffdb5 pushl _post_evt_acc ! 310: 299 000122D7 fe 08 effffffdae callf $8,_write32h ! 311: 300 000122DE # writes(", expected = "); ! 312: 301 000122DE .data 1 ! 313: 302 0000052d * L423: ! 314: 303 0000052d * 2C206578706563746564203D2 .ascii ", expected = \0" ! 315: 000 ! 316: 304 0000053b * .text ! 317: 305 000122DE dd 8f0000052d pushl $L423 ! 318: 306 000122E4 fe 08 effffffda1 callf $8,_writes ! 319: 307 000122EB # write32h( dbl_expected.m ); /* the expected result = 0 */ ! 320: 308 000122EB dd effffffd9b pushl _dbl_expected ! 321: 309 000122F1 fe 08 effffffd94 callf $8,_write32h ! 322: 310 000122F8 # writec('\n'); ! 323: 311 000122F8 dd 0a pushl $10 ! 324: 312 000122FA fe 08 effffffd8b callf $8,_writec ! 325: 313 00012301 # } ! 326: 314 00012301 # if ( halt_flg ) /* halt on error? */ ! 327: 315 00012301 L417: ! 328: 316 00012301 5d effffffd85 tstl _halt_flg ! 329: 317 00012307 31 09 jeql L424 ! 330: 318 00012309 # pipe9_halt( 2 ); /* halt with a code of 2 */ ! 331: 319 00012309 dd 02 pushl $2 ! 332: 320 0001230B fe 08 ef00000192 callf $8,_pipe9_halt ! 333: 321 00012312 # if ( loop_on_err ) ! 334: 322 00012312 L424: ! 335: 323 00012312 5d effffffd74 tstl _loop_on_err ! 336: 324 00012318 31 0d jeql L425 ! 337: 325 0001231A # { ! 338: 326 0001231A # force_loop = TRUE; /* set the force loop flag */ ! 339: 327 0001231A 0d 01 effffffd6b movl $1,_force_loop ! 340: 328 00012321 # asm("jmp _pipe9_lp1"); /* and loop */ ! 341: 329 00012321 71 effffffe1e jmp _pipe9_lp1 ! 342: 330 00012327 # }; ! 343: 331 00012327 L425: ! 344: 332 00012327 # } ! 345: 333 00012327 40 ret#2 ! 346: 334 00012328 .set L413,0x0 ! 347: 335 00012328 L415: ! 348: 336 00012328 13 ff3a jbr L416 ! 349: 337 0001232B .data ! 350: 338 00000488 * .text ! 351: 339 0001232B 00 .align 1 ! 352: 340 0001232C .globl _pipe9_queue_er ! 353: 341 0001232C _pipe9_queue_er: ! 354: 342 0001232C 0000 .word L426 ! 355: 343 0001232E # ! 356: 344 0001232E # ! 357: 345 0001232E # ! 358: 346 0001232E # ! 359: 347 0001232E # ! 360: 348 0001232E # /**************************************************************************** ! 361: 349 0001232E # * Report an "FPP queue not cleared" message ! 362: 350 0001232E # * ! 363: 351 0001232E # * Cycle: xx. EVT test xx. subtest xx. Fpp queue not cleared. index = xx ! 364: 352 0001232E # * inst = LDF op1, DIVF op2, CVLF '2' ('divide by 0' fault on DIVF) ! 365: 353 0001232E # * The 'Convert '2' to Floating Point' was apparently executed. ! 366: 354 0001232E # * op1 = xxxxxxxx, op2 = xxxxxxxx, final Acc. = xxxxxxxx, expected = xxxxxxxx ! 367: 355 0001232E # ****************************************************************************/ ! 368: 356 0001232E # pipe9_queue_er() ! 369: 357 0001232E # { ! 370: 358 0001232E 13 00c3 jbr L428 ! 371: 359 00012331 L429: ! 372: 360 00012331 # errcnt++; /* bump the error count */ ! 373: 361 00012331 6d effffffd55 incl _errcnt ! 374: 362 00012337 # if ( prt_error ) ! 375: 363 00012337 5d effffffd4f tstl _prt_error ! 376: 364 0001233D 21 03 13 008b jeql L430 ! 377: 365 00012342 # { ! 378: 366 00012342 # print_pipe9_er( ". Fpp queue not cleared" ); ! 379: 367 00012342 .data 1 ! 380: 368 0000053b * L431: ! 381: 369 0000053b * 2E20467070207175657565206 .ascii ". Fpp queue not cleared\0" ! 382: E6F7420636C656172656400 ! 383: 370 00000553 * .text ! 384: 371 00012342 dd 8f0000053b pushl $L431 ! 385: 372 00012348 fe 08 ef000000a9 callf $8,_print_pipe9_er ! 386: 373 0001234F # writes( ! 387: 374 0001234F # "The 'Convert '2' to Floating Point' was apparently executed.\n"); ! 388: 375 0001234F .data 1 ! 389: 376 00000553 * L432: ! 390: 377 00000553 * 5468652027436F6E766572742 .ascii "The 'Convert '2' to Floating Point' was apparently executed.\12\0" ! 391: 027322720746F20466C6F6174 ! 392: 696E6720506F696E742720776 ! 393: 173206170706172656E746C79 ! 394: 2065786563757465642E0A00 ! 395: 378 00000591 * .text ! 396: 379 0001234F dd 8f00000553 pushl $L432 ! 397: 380 00012355 fe 08 effffffd30 callf $8,_writes ! 398: 381 0001235C # writes("op1 = "); ! 399: 382 0001235C .data 1 ! 400: 383 00000591 * L433: ! 401: 384 00000591 * 6F7031203D2000 .ascii "op1 = \0" ! 402: 385 00000598 * .text ! 403: 386 0001235C dd 8f00000591 pushl $L433 ! 404: 387 00012362 fe 08 effffffd23 callf $8,_writes ! 405: 388 00012369 # write32h( dbl_ld_acc.m ); ! 406: 389 00012369 dd effffffd1d pushl _dbl_ld_acc ! 407: 390 0001236F fe 08 effffffd16 callf $8,_write32h ! 408: 391 00012376 # writes(", op1 = "); ! 409: 392 00012376 .data 1 ! 410: 393 00000598 * L434: ! 411: 394 00000598 * 2C206F7031203D2000 .ascii ", op1 = \0" ! 412: 395 000005a1 * .text ! 413: 396 00012376 dd 8f00000598 pushl $L434 ! 414: 397 0001237C fe 08 effffffd09 callf $8,_writes ! 415: 398 00012383 # write32h( dbl_value_1.m ); ! 416: 399 00012383 dd effffffd03 pushl _dbl_value_1 ! 417: 400 00012389 fe 08 effffffcfc callf $8,_write32h ! 418: 401 00012390 # writes(", final Acc. = "); ! 419: 402 00012390 .data 1 ! 420: 403 000005a1 * L435: ! 421: 404 000005a1 * 2C2066696E616C204163632E2 .ascii ", final Acc. = \0" ! 422: 03D2000 ! 423: 405 000005b1 * .text ! 424: 406 00012390 dd 8f000005a1 pushl $L435 ! 425: 407 00012396 fe 08 effffffcef callf $8,_writes ! 426: 408 0001239D # write32h( post_evt_acc.m ); ! 427: 409 0001239D dd effffffce9 pushl _post_evt_acc ! 428: 410 000123A3 fe 08 effffffce2 callf $8,_write32h ! 429: 411 000123AA # writes(", expected = "); ! 430: 412 000123AA .data 1 ! 431: 413 000005b1 * L436: ! 432: 414 000005b1 * 2C206578706563746564203D2 .ascii ", expected = \0" ! 433: 000 ! 434: 415 000005bf * .text ! 435: 416 000123AA dd 8f000005b1 pushl $L436 ! 436: 417 000123B0 fe 08 effffffcd5 callf $8,_writes ! 437: 418 000123B7 # write32h( 0x80000000 ); /* the expected result = 0 */ ! 438: 419 000123B7 dd 8f80000000 pushl $-2147483648 ! 439: 420 000123BD fe 08 effffffcc8 callf $8,_write32h ! 440: 421 000123C4 # writec('\n'); ! 441: 422 000123C4 dd 0a pushl $10 ! 442: 423 000123C6 fe 08 effffffcbf callf $8,_writec ! 443: 424 000123CD # } ! 444: 425 000123CD # if ( halt_flg ) /* halt on error? */ ! 445: 426 000123CD L430: ! 446: 427 000123CD 5d effffffcb9 tstl _halt_flg ! 447: 428 000123D3 31 09 jeql L437 ! 448: 429 000123D5 # pipe9_halt( 3 ); /* halt with a code of 3 */ ! 449: 430 000123D5 dd 03 pushl $3 ! 450: 431 000123D7 fe 08 ef000000c6 callf $8,_pipe9_halt ! 451: 432 000123DE # if ( loop_on_err ) ! 452: 433 000123DE L437: ! 453: 434 000123DE 5d effffffca8 tstl _loop_on_err ! 454: 435 000123E4 31 0d jeql L438 ! 455: 436 000123E6 # { ! 456: 437 000123E6 # force_loop = TRUE; /* set the force loop flag */ ! 457: 438 000123E6 0d 01 effffffc9f movl $1,_force_loop ! 458: 439 000123ED # asm("jmp _pipe9_lp1"); /* and loop */ ! 459: 440 000123ED 71 effffffd52 jmp _pipe9_lp1 ! 460: 441 000123F3 # }; ! 461: 442 000123F3 L438: ! 462: 443 000123F3 # } ! 463: 444 000123F3 40 ret#2 ! 464: 445 000123F4 .set L426,0x0 ! 465: 446 000123F4 L428: ! 466: 447 000123F4 13 ff3a jbr L429 ! 467: 448 000123F7 .data ! 468: 449 00000488 * .text ! 469: 450 000123F7 00 .align 1 ! 470: 451 000123F8 .globl _print_pipe9_er ! 471: 452 000123F8 _print_pipe9_er: ! 472: 453 000123F8 0000 .word L439 ! 473: 454 000123FA # ! 474: 455 000123FA # ! 475: 456 000123FA # ! 476: 457 000123FA # ! 477: 458 000123FA # /**************************************************************************** ! 478: 459 000123FA # * Report an error message of the form: ! 479: 460 000123FA # * ! 480: 461 000123FA # * Cycle: xx. EVT test xx. subtest xx. <your message here> index = xx ! 481: 462 000123FA # * inst = LDF op1, DIVF op2, CVLF '2' ('divide by 0' fault on DIVF) ! 482: 463 000123FA # ****************************************************************************/ ! 483: 464 000123FA # print_pipe9_er( msg ) ! 484: 465 000123FA # char *msg; /* error message to print */ ! 485: 466 000123FA # { ! 486: 467 000123FA 13 00a3 jbr L441 ! 487: 468 000123FD L442: ! 488: 469 000123FD # if( errcnt == 1 ) /* 1st error? */ ! 489: 470 000123FD 1d effffffc89 01 cmpl _errcnt,$1 ! 490: 471 00012404 21 0d jneq L443 ! 491: 472 00012406 # writes(" \n"); /* start a new print line */ ! 492: 473 00012406 .data 1 ! 493: 474 000005bf * L444: ! 494: 475 000005bf * 200A00 .ascii " \12\0" ! 495: 476 000005c2 * .text ! 496: 477 00012406 dd 8f000005bf pushl $L444 ! 497: 478 0001240C fe 08 effffffc79 callf $8,_writes ! 498: 479 00012413 # writes("Cycle: "); ! 499: 480 00012413 L443: ! 500: 481 00012413 .data 1 ! 501: 482 000005c2 * L445: ! 502: 483 000005c2 * 4379636C653A2000 .ascii "Cycle: \0" ! 503: 484 000005ca * .text ! 504: 485 00012413 dd 8f000005c2 pushl $L445 ! 505: 486 00012419 fe 08 effffffc6c callf $8,_writes ! 506: 487 00012420 # writed( cycle ); ! 507: 488 00012420 dd effffffc66 pushl _cycle ! 508: 489 00012426 fe 08 effffffc5f callf $8,_writed ! 509: 490 0001242D # writes(" EVT test "); ! 510: 491 0001242D .data 1 ! 511: 492 000005ca * L447: ! 512: 493 000005ca * 202045565420746573742000 .ascii " EVT test \0" ! 513: 494 000005d6 * .text ! 514: 495 0001242D dd 8f000005ca pushl $L447 ! 515: 496 00012433 fe 08 effffffc52 callf $8,_writes ! 516: 497 0001243A # writed( test_no ); ! 517: 498 0001243A dd effffffc4c pushl _test_no ! 518: 499 00012440 fe 08 effffffc45 callf $8,_writed ! 519: 500 00012447 # writes(". subtest "); ! 520: 501 00012447 .data 1 ! 521: 502 000005d6 * L448: ! 522: 503 000005d6 * 2E20737562746573742000 .ascii ". subtest \0" ! 523: 504 000005e1 * .text ! 524: 505 00012447 dd 8f000005d6 pushl $L448 ! 525: 506 0001244D fe 08 effffffc38 callf $8,_writes ! 526: 507 00012454 # writed( subtest ); ! 527: 508 00012454 dd effffffc32 pushl _subtest ! 528: 509 0001245A fe 08 effffffc2b callf $8,_writed ! 529: 510 00012461 # writes( msg ); /* print the message */ ! 530: 511 00012461 dd ad04 pushl 4(fp) ! 531: 512 00012464 fe 08 effffffc21 callf $8,_writes ! 532: 513 0001246B # writes(" index = "); ! 533: 514 0001246B .data 1 ! 534: 515 000005e1 * L449: ! 535: 516 000005e1 * 20696E646578203D2000 .ascii " index = \0" ! 536: 517 000005eb * .text ! 537: 518 0001246B dd 8f000005e1 pushl $L449 ! 538: 519 00012471 fe 08 effffffc14 callf $8,_writes ! 539: 520 00012478 # writed( index ); ! 540: 521 00012478 dd effffffc0e pushl _index ! 541: 522 0001247E fe 08 effffffc07 callf $8,_writed ! 542: 523 00012485 # writes("\ninst = LDF op1, DIVF op2, CVLF '2'"); ! 543: 524 00012485 .data 1 ! 544: 525 000005eb * L450: ! 545: 526 000005eb * 0A696E7374203D204C4446206 .ascii "\12inst = LDF op1, DIVF op2, CVLF '2'\0" ! 546: F70312C2044495646206F7032 ! 547: 2C2043564C462027322700 ! 548: 527 0000060f * .text ! 549: 528 00012485 dd 8f000005eb pushl $L450 ! 550: 529 0001248B fe 08 effffffbfa callf $8,_writes ! 551: 530 00012492 # writes(" ('divide by 0' fault on DIVF)\n"); ! 552: 531 00012492 .data 1 ! 553: 532 0000060f * L451: ! 554: 533 0000060f * 2020202028276469766964652 .ascii " ('divide by 0' fault on DIVF)\12\0" ! 555: 06279203027206661756C7420 ! 556: 6F6E2044495646290A00 ! 557: 534 00000632 * .text ! 558: 535 00012492 dd 8f0000060f pushl $L451 ! 559: 536 00012498 fe 08 effffffbed callf $8,_writes ! 560: 537 0001249F # } ! 561: 538 0001249F 40 ret#2 ! 562: 539 000124A0 .set L439,0x0 ! 563: 540 000124A0 L441: ! 564: 541 000124A0 13 ff5a jbr L442 ! 565: 542 000124A3 .data ! 566: 543 00000488 * .text ! 567: 544 000124A3 00 .align 1 ! 568: 545 000124A4 .globl _pipe9_halt ! 569: 546 000124A4 _pipe9_halt: ! 570: 547 000124A4 0000 .word L452 ! 571: 548 000124A6 # ! 572: 549 000124A6 # ! 573: 550 000124A6 # ! 574: 551 000124A6 # /**************************************************************************** ! 575: 552 000124A6 # * halt on error routine ! 576: 553 000124A6 # ****************************************************************************/ ! 577: 554 000124A6 # pipe9_halt( code ) ! 578: 555 000124A6 # int code; /* error code to halt with */ ! 579: 556 000124A6 # { ! 580: 557 000124A6 11 6a jbr L454 ! 581: 558 000124A8 L455: ! 582: 559 000124A8 # err_code = code; ! 583: 560 000124A8 0d ad04 effffffbdc movl 4(fp),_err_code ! 584: 561 000124B0 # sgl_value_1 = dbl_ld_acc.m; ! 585: 562 000124B0 0d effffffbd6 effffffbd1 movl _dbl_ld_acc,_sgl_value_1 ! 586: 563 000124BB # sgl_value_2 = dbl_value_1.m; ! 587: 564 000124BB 0d effffffbcb effffffbc6 movl _dbl_value_1,_sgl_value_2 ! 588: 565 000124C6 # sgl_value_3 = post_evt_acc.m; ! 589: 566 000124C6 0d effffffbc0 effffffbbb movl _post_evt_acc,_sgl_value_3 ! 590: 567 000124D1 # asm("movl _test_no,r0"); /* r0 = test number */ ! 591: 568 000124D1 0d effffffbb5 50 movl _test_no,r0 ! 592: 569 000124D8 # asm("movl _subtest,r1"); /* r1 = subtest number */ ! 593: 570 000124D8 0d effffffbae 51 movl _subtest,r1 ! 594: 571 000124DF # asm("movl _err_code,r2"); /* r2 = error code */ ! 595: 572 000124DF 0d effffffba7 52 movl _err_code,r2 ! 596: 573 000124E6 # asm("movl _cycle,r3"); /* r3 = cycle count */ ! 597: 574 000124E6 0d effffffba0 53 movl _cycle,r3 ! 598: 575 000124ED # asm("movl _sgl_value_1,r4"); /* r4 = initial accumulator */ ! 599: 576 000124ED 0d effffffb99 54 movl _sgl_value_1,r4 ! 600: 577 000124F4 # asm("movl _sgl_value_2,r5"); /* r5 = divide operand */ ! 601: 578 000124F4 0d effffffb92 55 movl _sgl_value_2,r5 ! 602: 579 000124FB # asm("movl _sgl_value_3,r6"); /* r6 = final accumulator */ ! 603: 580 000124FB 0d effffffb8b 56 movl _sgl_value_3,r6 ! 604: 581 00012502 # asm("movl $0x80000000,r7"); /* r7 = expected accumulator */ ! 605: 582 00012502 0d 8f80000000 57 movl $0x80000000,r7 ! 606: 583 00012509 # asm("movl _index,r8"); /* r8 = data index */ ! 607: 584 00012509 0d effffffb7d 58 movl _index,r8 ! 608: 585 00012510 # asm("halt"); /* HALT ... */ ! 609: 586 00012510 00 halt ! 610: 587 00012511 # } ! 611: 588 00012511 40 ret#2 ! 612: 589 00012512 .set L452,0x0 ! 613: 590 00012512 L454: ! 614: 591 00012512 11 94 jbr L455 ! 615: 592 00000488 * .data ! 616: 592 00000488 * .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.