![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe15.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 pipe15.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 0000050c * .text ! 4: 4 00000000 .align 1 ! 5: 5 00000000 .globl _pipe15 ! 6: 6 00000000 _pipe15: ! 7: 7 00013EF4 0000 .word L381 ! 8: 8 00013EF6 # ! 9: 9 00013EF6 # #include "evt_defs.h" ! 10: 10 00013EF6 # ! 11: 11 00013EF6 # /* ! 12: 12 00013EF6 # ********************************************************************* ! 13: 13 00013EF6 # * FPP PIPELINED EVENTS TEST #15 ! 14: 14 00013EF6 # * ! 15: 15 00013EF6 # * This test will execute the following code: "LDF MULF STF" ! 16: 16 00013EF6 # * with an overflow fault on the MULF. We will make sure that: ! 17: 17 00013EF6 # * 1. The fault is detected, ! 18: 18 00013EF6 # * 2. the accumulator is cleared, and ! 19: 19 00013EF6 # * 3. a floating '0' is stored if anything. ! 20: 20 00013EF6 # ********************************************************************* ! 21: 21 00013EF6 # */ ! 22: 22 00013EF6 # pipe15() ! 23: 23 00013EF6 # { ! 24: 24 00013EF6 13 014b jbr L383 ! 25: 25 00013EF9 L384: ! 26: 26 00013EF9 # #define PIPE15_PAT 0x12341234 ! 27: 27 00013EF9 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */ ! 28: 28 00013EF9 ed 6d effffffff4 moval (r13),_pre_event_fp ! 29: 29 00013F00 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */ ! 30: 30 00013F00 ed 6e efffffffed moval (r14),_pre_event_sp ! 31: 31 00013F07 # precision = SGL; ! 32: 32 00013F07 0d 01 efffffffe6 movl $1,_precision ! 33: 33 00013F0E # test_event = ARITH_CODE; /* expect an arithmetic fault */ ! 34: 34 00013F0E 0d 34 efffffffdf movl $52,_test_event ! 35: 35 00013F15 # exp_code = FLT_OVFL_CODE; /* - specificly overflow */ ! 36: 36 00013F15 0d 04 efffffffd8 movl $4,_exp_code ! 37: 37 00013F1C # exp_event = FALSE; /* ... but not yet */ ! 38: 38 00013F1C 4d efffffffd2 clrl _exp_event ! 39: 39 00013F22 # asm("movab _pipe15_ret,_event_return"); /* set event return address */ ! 40: 40 00013F22 e9 ef000000b9 efffffffc7 movab _pipe15_ret,_event_return ! 41: 41 00013F2D # max_index = muf_ov_cnt; /* set max operand index */ ! 42: 42 00013F2D 0d efffffffc1 efffffffbc movl _muf_ov_cnt,_max_index ! 43: 43 00013F38 # for( index = 0; index < max_index; index++ ) { ! 44: 44 00013F38 4d efffffffb6 clrl _index ! 45: 45 00013F3E L387: ! 46: 46 00013F3E 1d efffffffb0 efffffffab cmpl _index,_max_index ! 47: 47 00013F49 91 03 13 00f5 jgeq L386 ! 48: 48 00013F4E # dbl_ld_acc = muf_ov_dat[index].op_1; /* get the Acc data */ ! 49: 49 00013F4E 48 04 efffffff9f 50 shll $4,_index,r0 ! 50: 50 00013F56 0c 8f00000000 50 addl2 $_muf_ov_dat,r0 ! 51: 51 00013F5D 0d a004 efffffff93 movl 4(r0),_dbl_ld_acc+4 ! 52: 52 00013F65 0d 60 efffffff88 movl (r0),_dbl_ld_acc ! 53: 53 00013F6C # dbl_value_1 = muf_ov_dat[index].op_2; /* get the '0' data */ ! 54: 54 00013F6C 48 04 efffffff81 50 shll $4,_index,r0 ! 55: 55 00013F74 0c 8f00000008 50 addl2 $_muf_ov_dat+8,r0 ! 56: 56 00013F7B 0d a004 efffffff75 movl 4(r0),_dbl_value_1+4 ! 57: 57 00013F83 0d 60 efffffff6a movl (r0),_dbl_value_1 ! 58: 58 00013F8A # dbl_value_2.m = PIPE15_PAT; /* background for STF*/ ! 59: 59 00013F8A 0d 8f12341234 efffffff5f movl $305402420,_dbl_value_2 ! 60: 60 00013F95 # asm(".globl _pipe15_lp1"); ! 61: 61 00013F95 .globl _pipe15_lp1 ! 62: 62 00013F95 # asm("_pipe15_lp1:"); ! 63: 63 00013F95 _pipe15_lp1: ! 64: 64 00013F95 # asm("bispsw $0x60"); /* enable ovfl & undfl events*/ ! 65: 65 00013F95 8b 8860 bispsw $0x60 ! 66: 66 00013F98 # asm("ldf _dbl_ld_acc"); /* load the Acc. */ ! 67: 67 00013F98 06 efffffff56 ldf _dbl_ld_acc ! 68: 68 00013F9E # exp_event = test_event; /* set the expect event flag */ ! 69: 69 00013F9E 0d efffffff50 efffffff4b movl _test_event,_exp_event ! 70: 70 00013FA9 # asm("mulf _dbl_value_1"); /* trigger the event */ ! 71: 71 00013FA9 e6 efffffff45 mulf _dbl_value_1 ! 72: 72 00013FAF # asm("stf _dbl_value_2"); /* FPP stores before the evt.*/ ! 73: 73 00013FAF 26 efffffff3f stf _dbl_value_2 ! 74: 74 00013FB5 # /* ! 75: 75 00013FB5 # * If we got to here then there was no event ! 76: 76 00013FB5 # */ ! 77: 77 00013FB5 # if( force_loop ) ! 78: 78 00013FB5 5d efffffff39 tstl _force_loop ! 79: 79 00013FBB 31 06 jeql L388 ! 80: 80 00013FBD # asm("jmp _pipe15_lp1");; /* loop on the error */ ! 81: 81 00013FBD 71 efffffffd2 jmp _pipe15_lp1 ! 82: 82 00013FC3 L388: ! 83: 83 00013FC3 # exp_event = FALSE; /* reset event expected flag */ ! 84: 84 00013FC3 4d efffffff2b clrl _exp_event ! 85: 85 00013FC9 # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */ ! 86: 86 00013FC9 0d efffffff25 5d movl _pre_event_fp,fp ! 87: 87 00013FD0 # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */ ! 88: 88 00013FD0 0d efffffff1e 5e movl _pre_event_sp,sp ! 89: 89 00013FD7 # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */ ! 90: 90 00013FD7 9b 8860 bicpsw $0x60 ! 91: 91 00013FDA # no_pipe15_evt();; /* report the error */ ! 92: 92 00013FDA fe 04 ef00000067 callf $4,_no_pipe15_evt ! 93: 93 00013FE1 # /* ! 94: 94 00013FE1 # * Come here after the event ! 95: 95 00013FE1 # */ ! 96: 96 00013FE1 # asm(".globl _pipe15_ret"); ! 97: 97 00013FE1 .globl _pipe15_ret ! 98: 98 00013FE1 # asm("_pipe15_ret:"); ! 99: 99 00013FE1 _pipe15_ret: ! 100: 100 00013FE1 # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */ ! 101: 101 00013FE1 0d efffffff0d 5d movl _pre_event_fp,fp ! 102: 102 00013FE8 # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */ ! 103: 103 00013FE8 0d efffffff06 5e movl _pre_event_sp,sp ! 104: 104 00013FEF # if( force_loop ) ! 105: 105 00013FEF 5d effffffeff tstl _force_loop ! 106: 106 00013FF5 31 06 jeql L390 ! 107: 107 00013FF7 # asm("jmp _pipe15_lp1");; /* loop on the error */ ! 108: 108 00013FF7 71 efffffff98 jmp _pipe15_lp1 ! 109: 109 00013FFD L390: ! 110: 110 00013FFD # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */ ! 111: 111 00013FFD 9b 8860 bicpsw $0x60 ! 112: 112 00014000 # if( post_evt_acc.m ) /* was the Acc cleared? */ ! 113: 113 00014000 5d effffffeee tstl _post_evt_acc ! 114: 114 00014006 31 09 jeql L391 ! 115: 115 00014008 # bad_pipe15_result(); /* incorrect result error */ ! 116: 116 00014008 fe 04 ef000000f5 callf $4,_bad_pipe15_result ! 117: 117 0001400F # else if( (dbl_value_2.m ) && /* either a ZERO s/b stored, */ ! 118: 118 0001400F 11 29 jbr L393 ! 119: 119 00014011 L391: ! 120: 120 00014011 # (dbl_value_2.m != 0x80000000) && /* or a RESERVED OP, */ ! 121: 121 00014011 # (dbl_value_2.m != PIPE15_PAT) ) /* or no store at all */ ! 122: 122 00014011 5d effffffedd tstl _dbl_value_2 ! 123: 123 00014017 31 21 jeql L394 ! 124: 124 00014019 1d effffffed5 8f80000000 cmpl _dbl_value_2,$-2147483648 ! 125: 125 00014024 31 14 jeql L394 ! 126: 126 00014026 1d effffffec8 8f12341234 cmpl _dbl_value_2,$305402420 ! 127: 127 00014031 31 07 jeql L394 ! 128: 128 00014033 # bad_pipe15_store(); /* incorrect store error */ ! 129: 129 00014033 fe 04 ef000001b8 callf $4,_bad_pipe15_store ! 130: 130 0001403A # } ! 131: 131 0001403A L394: ! 132: 132 0001403A L393: ! 133: 133 0001403A L385: ! 134: 134 0001403A 6d effffffeb4 incl _index ! 135: 135 00014040 13 fefb jbr L387 ! 136: 136 00014043 L386: ! 137: 137 00014043 # } ! 138: 138 00014043 40 ret#2 ! 139: 139 00014044 .set L381,0x0 ! 140: 140 00014044 L383: ! 141: 141 00014044 13 feb2 jbr L384 ! 142: 142 00014047 .data ! 143: 143 0000050c * .text ! 144: 144 00014047 00 .align 1 ! 145: 145 00014048 .globl _no_pipe15_evt ! 146: 146 00014048 _no_pipe15_evt: ! 147: 147 00014048 0000 .word L396 ! 148: 148 0001404A # ! 149: 149 0001404A # ! 150: 150 0001404A # ! 151: 151 0001404A # /**************************************************************************** ! 152: 152 0001404A # * Report an "EVENT NOT DETECTED" error ! 153: 153 0001404A # * ! 154: 154 0001404A # * Cycle: xx. EVT test xx. subtest xx. No overflow fault seen. index = xx ! 155: 155 0001404A # * inst = LDF op1, MULF op2, STF op3 (overflow fault on the MULF) ! 156: 156 0001404A # * op1 = xxxxxxxx, op2 = xxxxxxxx, init op3 = xxxxxxxx, final op3 = xxxxxxxx ! 157: 157 0001404A # ****************************************************************************/ ! 158: 158 0001404A # no_pipe15_evt() ! 159: 159 0001404A # { ! 160: 160 0001404A 13 00b3 jbr L398 ! 161: 161 0001404D L399: ! 162: 162 0001404D # errcnt++; /* bump the error count */ ! 163: 163 0001404D 6d effffffea1 incl _errcnt ! 164: 164 00014053 # if ( prt_error ) ! 165: 165 00014053 5d effffffe9b tstl _prt_error ! 166: 166 00014059 31 7e jeql L400 ! 167: 167 0001405B # { ! 168: 168 0001405B # print_pipe15_er( ". No overflow fault seen" ); ! 169: 169 0001405B .data 1 ! 170: 170 0000050c * L402: ! 171: 171 0000050c * 2E204E6F206F766572666C6F7 .ascii ". No overflow fault seen\0" ! 172: 7206661756C74207365656E00 ! 173: 172 00000525 * .text ! 174: 173 0001405B dd 8f0000050c pushl $L402 ! 175: 174 00014061 fe 08 ef00000266 callf $8,_print_pipe15_er ! 176: 175 00014068 # writes("op1 = "); ! 177: 176 00014068 .data 1 ! 178: 177 00000525 * L404: ! 179: 178 00000525 * 6F7031203D2000 .ascii "op1 = \0" ! 180: 179 0000052c * .text ! 181: 180 00014068 dd 8f00000525 pushl $L404 ! 182: 181 0001406E fe 08 effffffe7f callf $8,_writes ! 183: 182 00014075 # write32h( dbl_ld_acc.m ); ! 184: 183 00014075 dd effffffe79 pushl _dbl_ld_acc ! 185: 184 0001407B fe 08 effffffe72 callf $8,_write32h ! 186: 185 00014082 # writes(", op2 = "); ! 187: 186 00014082 .data 1 ! 188: 187 0000052c * L406: ! 189: 188 0000052c * 2C20206F7032203D2000 .ascii ", op2 = \0" ! 190: 189 00000536 * .text ! 191: 190 00014082 dd 8f0000052c pushl $L406 ! 192: 191 00014088 fe 08 effffffe65 callf $8,_writes ! 193: 192 0001408F # write32h( dbl_value_1.m ); ! 194: 193 0001408F dd effffffe5f pushl _dbl_value_1 ! 195: 194 00014095 fe 08 effffffe58 callf $8,_write32h ! 196: 195 0001409C # writes(", init op3 = "); ! 197: 196 0001409C .data 1 ! 198: 197 00000536 * L407: ! 199: 198 00000536 * 2C2020696E6974206F7033203 .ascii ", init op3 = \0" ! 200: D2000 ! 201: 199 00000545 * .text ! 202: 200 0001409C dd 8f00000536 pushl $L407 ! 203: 201 000140A2 fe 08 effffffe4b callf $8,_writes ! 204: 202 000140A9 # write32h( PIPE15_PAT ); ! 205: 203 000140A9 dd 8f12341234 pushl $305402420 ! 206: 204 000140AF fe 08 effffffe3e callf $8,_write32h ! 207: 205 000140B6 # writes(", final op3 = "); ! 208: 206 000140B6 .data 1 ! 209: 207 00000545 * L408: ! 210: 208 00000545 * 2C202066696E616C206F70332 .ascii ", final op3 = \0" ! 211: 03D2000 ! 212: 209 00000555 * .text ! 213: 210 000140B6 dd 8f00000545 pushl $L408 ! 214: 211 000140BC fe 08 effffffe31 callf $8,_writes ! 215: 212 000140C3 # write32h( dbl_value_2.m ); ! 216: 213 000140C3 dd effffffe2b pushl _dbl_value_2 ! 217: 214 000140C9 fe 08 effffffe24 callf $8,_write32h ! 218: 215 000140D0 # writec('\n'); ! 219: 216 000140D0 dd 0a pushl $10 ! 220: 217 000140D2 fe 08 effffffe1b callf $8,_writec ! 221: 218 000140D9 # } ! 222: 219 000140D9 # if ( halt_flg ) /* halt on error? */ ! 223: 220 000140D9 L400: ! 224: 221 000140D9 5d effffffe15 tstl _halt_flg ! 225: 222 000140DF 31 09 jeql L410 ! 226: 223 000140E1 # pipe15_halt( 1 ); /* halt with a code of 1 */ ! 227: 224 000140E1 dd 01 pushl $1 ! 228: 225 000140E3 fe 08 ef00000282 callf $8,_pipe15_halt ! 229: 226 000140EA # if ( loop_on_err ) ! 230: 227 000140EA L410: ! 231: 228 000140EA 5d effffffe04 tstl _loop_on_err ! 232: 229 000140F0 31 0d jeql L412 ! 233: 230 000140F2 # { ! 234: 231 000140F2 # force_loop = TRUE; /* set the force loop flag */ ! 235: 232 000140F2 0d 01 effffffdfb movl $1,_force_loop ! 236: 233 000140F9 # asm("jmp _pipe15_lp1"); /* and loop */ ! 237: 234 000140F9 71 effffffe96 jmp _pipe15_lp1 ! 238: 235 000140FF # }; ! 239: 236 000140FF L412: ! 240: 237 000140FF # } ! 241: 238 000140FF 40 ret#2 ! 242: 239 00014100 .set L396,0x0 ! 243: 240 00014100 L398: ! 244: 241 00014100 13 ff4a jbr L399 ! 245: 242 00014103 .data ! 246: 243 0000050c * .text ! 247: 244 00014103 00 .align 1 ! 248: 245 00014104 .globl _bad_pipe15_result ! 249: 246 00014104 _bad_pipe15_result: ! 250: 247 00014104 0000 .word L413 ! 251: 248 00014106 # ! 252: 249 00014106 # ! 253: 250 00014106 # ! 254: 251 00014106 # ! 255: 252 00014106 # /**************************************************************************** ! 256: 253 00014106 # * Report an "BAD ACCUMULATOR AFTER THE EVENT" error ! 257: 254 00014106 # * ! 258: 255 00014106 # * Cycle: xx. EVT test xx. subtest xx. Bad final Accumulator. index = xx ! 259: 256 00014106 # * inst = LDF op1, MULF op2, STF op3 (overflow fault on the MULF) ! 260: 257 00014106 # * op1 = xxxxxxxx, final Acc. = xxxxxxxx, initial op3 = xxxxxxxx ! 261: 258 00014106 # * op2 = xxxxxxxx, expected = xxxxxxxx, final op3 = xxxxxxxx ! 262: 259 00014106 # ****************************************************************************/ ! 263: 260 00014106 # bad_pipe15_result() ! 264: 261 00014106 # { ! 265: 262 00014106 13 00e6 jbr L415 ! 266: 263 00014109 L416: ! 267: 264 00014109 # errcnt++; /* bump the error count */ ! 268: 265 00014109 6d effffffde5 incl _errcnt ! 269: 266 0001410F # if ( prt_error ) ! 270: 267 0001410F 5d effffffddf tstl _prt_error ! 271: 268 00014115 21 03 13 00ae jeql L417 ! 272: 269 0001411A # { ! 273: 270 0001411A # print_pipe15_er( ". Bad final Accumulator" ); ! 274: 271 0001411A .data 1 ! 275: 272 00000555 * L418: ! 276: 273 00000555 * 2E204261642066696E616C204 .ascii ". Bad final Accumulator\0" ! 277: 16363756D756C61746F7200 ! 278: 274 0000056d * .text ! 279: 275 0001411A dd 8f00000555 pushl $L418 ! 280: 276 00014120 fe 08 ef000001a7 callf $8,_print_pipe15_er ! 281: 277 00014127 # writes("op1 = "); ! 282: 278 00014127 .data 1 ! 283: 279 0000056d * L419: ! 284: 280 0000056d * 6F7031203D2000 .ascii "op1 = \0" ! 285: 281 00000574 * .text ! 286: 282 00014127 dd 8f0000056d pushl $L419 ! 287: 283 0001412D fe 08 effffffdc0 callf $8,_writes ! 288: 284 00014134 # write32h( dbl_ld_acc.m ); ! 289: 285 00014134 dd effffffdba pushl _dbl_ld_acc ! 290: 286 0001413A fe 08 effffffdb3 callf $8,_write32h ! 291: 287 00014141 # writes(", final Acc. = "); ! 292: 288 00014141 .data 1 ! 293: 289 00000574 * L420: ! 294: 290 00000574 * 2C20202066696E616C2041636 .ascii ", final Acc. = \0" ! 295: 32E203D2000 ! 296: 291 00000586 * .text ! 297: 292 00014141 dd 8f00000574 pushl $L420 ! 298: 293 00014147 fe 08 effffffda6 callf $8,_writes ! 299: 294 0001414E # write32h( post_evt_acc.m ); ! 300: 295 0001414E dd effffffda0 pushl _post_evt_acc ! 301: 296 00014154 fe 08 effffffd99 callf $8,_write32h ! 302: 297 0001415B # writes(", initial op3 = "); ! 303: 298 0001415B .data 1 ! 304: 299 00000586 * L421: ! 305: 300 00000586 * 2C202020696E697469616C206 .ascii ", initial op3 = \0" ! 306: F703320203D2000 ! 307: 301 0000059a * .text ! 308: 302 0001415B dd 8f00000586 pushl $L421 ! 309: 303 00014161 fe 08 effffffd8c callf $8,_writes ! 310: 304 00014168 # write32h( PIPE15_PAT ); ! 311: 305 00014168 dd 8f12341234 pushl $305402420 ! 312: 306 0001416E fe 08 effffffd7f callf $8,_write32h ! 313: 307 00014175 # writes("\nop2 = "); ! 314: 308 00014175 .data 1 ! 315: 309 0000059a * L422: ! 316: 310 0000059a * 0A6F7032203D2000 .ascii "\12op2 = \0" ! 317: 311 000005a2 * .text ! 318: 312 00014175 dd 8f0000059a pushl $L422 ! 319: 313 0001417B fe 08 effffffd72 callf $8,_writes ! 320: 314 00014182 # write32h( dbl_value_1.m ); ! 321: 315 00014182 dd effffffd6c pushl _dbl_value_1 ! 322: 316 00014188 fe 08 effffffd65 callf $8,_write32h ! 323: 317 0001418F # writes(", expected = "); ! 324: 318 0001418F .data 1 ! 325: 319 000005a2 * L423: ! 326: 320 000005a2 * 2C20202020206578706563746 .ascii ", expected = \0" ! 327: 564203D2000 ! 328: 321 000005b4 * .text ! 329: 322 0001418F dd 8f000005a2 pushl $L423 ! 330: 323 00014195 fe 08 effffffd58 callf $8,_writes ! 331: 324 0001419C # write32h( 0 ); /* the expected result = 0 */ ! 332: 325 0001419C dd 00 pushl $0 ! 333: 326 0001419E fe 08 effffffd4f callf $8,_write32h ! 334: 327 000141A5 # writes(", final op3 = "); ! 335: 328 000141A5 .data 1 ! 336: 329 000005b4 * L424: ! 337: 330 000005b4 * 2C202020202066696E616C206 .ascii ", final op3 = \0" ! 338: F703320203D2000 ! 339: 331 000005c8 * .text ! 340: 332 000141A5 dd 8f000005b4 pushl $L424 ! 341: 333 000141AB fe 08 effffffd42 callf $8,_writes ! 342: 334 000141B2 # write32h( dbl_value_2.m ); ! 343: 335 000141B2 dd effffffd3c pushl _dbl_value_2 ! 344: 336 000141B8 fe 08 effffffd35 callf $8,_write32h ! 345: 337 000141BF # writec('\n'); ! 346: 338 000141BF dd 0a pushl $10 ! 347: 339 000141C1 fe 08 effffffd2c callf $8,_writec ! 348: 340 000141C8 # } ! 349: 341 000141C8 # if ( halt_flg ) /* halt on error? */ ! 350: 342 000141C8 L417: ! 351: 343 000141C8 5d effffffd26 tstl _halt_flg ! 352: 344 000141CE 31 09 jeql L425 ! 353: 345 000141D0 # pipe15_halt( 2 ); /* halt with a code of 2 */ ! 354: 346 000141D0 dd 02 pushl $2 ! 355: 347 000141D2 fe 08 ef00000193 callf $8,_pipe15_halt ! 356: 348 000141D9 # if ( loop_on_err ) ! 357: 349 000141D9 L425: ! 358: 350 000141D9 5d effffffd15 tstl _loop_on_err ! 359: 351 000141DF 31 0d jeql L426 ! 360: 352 000141E1 # { ! 361: 353 000141E1 # force_loop = TRUE; /* set the force loop flag */ ! 362: 354 000141E1 0d 01 effffffd0c movl $1,_force_loop ! 363: 355 000141E8 # asm("jmp _pipe15_lp1"); /* and loop */ ! 364: 356 000141E8 71 effffffda7 jmp _pipe15_lp1 ! 365: 357 000141EE # }; ! 366: 358 000141EE L426: ! 367: 359 000141EE # } ! 368: 360 000141EE 40 ret#2 ! 369: 361 000141EF .set L413,0x0 ! 370: 362 000141EF L415: ! 371: 363 000141EF 13 ff17 jbr L416 ! 372: 364 000141F2 .data ! 373: 365 0000050c * .text ! 374: 366 000141F2 .align 1 ! 375: 367 000141F2 .globl _bad_pipe15_store ! 376: 368 000141F2 _bad_pipe15_store: ! 377: 369 000141F2 0000 .word L427 ! 378: 370 000141F4 # ! 379: 371 000141F4 # ! 380: 372 000141F4 # ! 381: 373 000141F4 # ! 382: 374 000141F4 # /**************************************************************************** ! 383: 375 000141F4 # * Report a "BAD RESULT STORED AFTER THE EVENT" error ! 384: 376 000141F4 # * ! 385: 377 000141F4 # * Cycle: xx. EVT test xx. subtest xx. Bad STF OP3 result. index = xx ! 386: 378 000141F4 # * inst = LDF op1, MULF op2, STF op3 (overflow fault on the MULF) ! 387: 379 000141F4 # * op1 = xxxxxxxx, initial op3 = xxxxxxxx, final Acc. = xxxxxxxx ! 388: 380 000141F4 # * op2 = xxxxxxxx, final op3 = xxxxxxxx, op3 expected = xxxxxxxx ! 389: 381 000141F4 # ****************************************************************************/ ! 390: 382 000141F4 # bad_pipe15_store() ! 391: 383 000141F4 # { ! 392: 384 000141F4 13 00d4 jbr L429 ! 393: 385 000141F7 L430: ! 394: 386 000141F7 # errcnt++; /* bump the error count */ ! 395: 387 000141F7 6d effffffcf7 incl _errcnt ! 396: 388 000141FD # if ( prt_error ) ! 397: 389 000141FD 5d effffffcf1 tstl _prt_error ! 398: 390 00014203 21 03 13 009c jeql L431 ! 399: 391 00014208 # { ! 400: 392 00014208 # print_pipe15_er( ". Bad STF OP3 result" ); ! 401: 393 00014208 .data 1 ! 402: 394 000005c8 * L432: ! 403: 395 000005c8 * 2E2042616420535446204F503 .ascii ". Bad STF OP3 result\0" ! 404: 320726573756C7400 ! 405: 396 000005dd * .text ! 406: 397 00014208 dd 8f000005c8 pushl $L432 ! 407: 398 0001420E fe 08 ef000000b9 callf $8,_print_pipe15_er ! 408: 399 00014215 # writes("op1 = "); ! 409: 400 00014215 .data 1 ! 410: 401 000005dd * L433: ! 411: 402 000005dd * 6F7031203D2000 .ascii "op1 = \0" ! 412: 403 000005e4 * .text ! 413: 404 00014215 dd 8f000005dd pushl $L433 ! 414: 405 0001421B fe 08 effffffcd2 callf $8,_writes ! 415: 406 00014222 # write32h( dbl_ld_acc.m ); ! 416: 407 00014222 dd effffffccc pushl _dbl_ld_acc ! 417: 408 00014228 fe 08 effffffcc5 callf $8,_write32h ! 418: 409 0001422F # writes(", initial op3 = "); ! 419: 410 0001422F .data 1 ! 420: 411 000005e4 * L434: ! 421: 412 000005e4 * 2C2020696E697469616C206F7 .ascii ", initial op3 = \0" ! 422: 03320203D2000 ! 423: 413 000005f7 * .text ! 424: 414 0001422F dd 8f000005e4 pushl $L434 ! 425: 415 00014235 fe 08 effffffcb8 callf $8,_writes ! 426: 416 0001423C # write32h( PIPE15_PAT ); ! 427: 417 0001423C dd 8f12341234 pushl $305402420 ! 428: 418 00014242 fe 08 effffffcab callf $8,_write32h ! 429: 419 00014249 # writes(", final Acc. = "); ! 430: 420 00014249 .data 1 ! 431: 421 000005f7 * L435: ! 432: 422 000005f7 * 2C2020202066696E616C20416 .ascii ", final Acc. = \0" ! 433: 3632E203D2000 ! 434: 423 0000060a * .text ! 435: 424 00014249 dd 8f000005f7 pushl $L435 ! 436: 425 0001424F fe 08 effffffc9e callf $8,_writes ! 437: 426 00014256 # write32h( post_evt_acc.m ); ! 438: 427 00014256 dd effffffc98 pushl _post_evt_acc ! 439: 428 0001425C fe 08 effffffc91 callf $8,_write32h ! 440: 429 00014263 # writes("\nop2 = "); ! 441: 430 00014263 .data 1 ! 442: 431 0000060a * L436: ! 443: 432 0000060a * 0A6F7032203D2000 .ascii "\12op2 = \0" ! 444: 433 00000612 * .text ! 445: 434 00014263 dd 8f0000060a pushl $L436 ! 446: 435 00014269 fe 08 effffffc84 callf $8,_writes ! 447: 436 00014270 # write32h( dbl_value_1.m ); ! 448: 437 00014270 dd effffffc7e pushl _dbl_value_1 ! 449: 438 00014276 fe 08 effffffc77 callf $8,_write32h ! 450: 439 0001427D # writes(", final op3 = "); ! 451: 440 0001427D .data 1 ! 452: 441 00000612 * L437: ! 453: 442 00000612 * 2C2020202066696E616C206F7 .ascii ", final op3 = \0" ! 454: 03320203D2000 ! 455: 443 00000625 * .text ! 456: 444 0001427D dd 8f00000612 pushl $L437 ! 457: 445 00014283 fe 08 effffffc6a callf $8,_writes ! 458: 446 0001428A # write32h( dbl_value_2.m ); ! 459: 447 0001428A dd effffffc64 pushl _dbl_value_2 ! 460: 448 00014290 fe 08 effffffc5d callf $8,_write32h ! 461: 449 00014297 # writes(", op3 expected = 80000000\n"); /* exp = Reserved Op */ ! 462: 450 00014297 .data 1 ! 463: 451 00000625 * L438: ! 464: 452 00000625 * 2C20206F70332065787065637 .ascii ", op3 expected = 80000000\12\0" ! 465: 46564203D2038303030303030 ! 466: 300A00 ! 467: 453 00000641 * .text ! 468: 454 00014297 dd 8f00000625 pushl $L438 ! 469: 455 0001429D fe 08 effffffc50 callf $8,_writes ! 470: 456 000142A4 # } ! 471: 457 000142A4 # if ( halt_flg ) /* halt on error? */ ! 472: 458 000142A4 L431: ! 473: 459 000142A4 5d effffffc4a tstl _halt_flg ! 474: 460 000142AA 31 09 jeql L439 ! 475: 461 000142AC # pipe15_halt( 3 ); /* halt with a code of 2 */ ! 476: 462 000142AC dd 03 pushl $3 ! 477: 463 000142AE fe 08 ef000000b7 callf $8,_pipe15_halt ! 478: 464 000142B5 # if ( loop_on_err ) ! 479: 465 000142B5 L439: ! 480: 466 000142B5 5d effffffc39 tstl _loop_on_err ! 481: 467 000142BB 31 0d jeql L440 ! 482: 468 000142BD # { ! 483: 469 000142BD # force_loop = TRUE; /* set the force loop flag */ ! 484: 470 000142BD 0d 01 effffffc30 movl $1,_force_loop ! 485: 471 000142C4 # asm("jmp _pipe15_lp1"); /* and loop */ ! 486: 472 000142C4 71 effffffccb jmp _pipe15_lp1 ! 487: 473 000142CA # }; ! 488: 474 000142CA L440: ! 489: 475 000142CA # } ! 490: 476 000142CA 40 ret#2 ! 491: 477 000142CB .set L427,0x0 ! 492: 478 000142CB L429: ! 493: 479 000142CB 13 ff29 jbr L430 ! 494: 480 000142CE .data ! 495: 481 0000050c * .text ! 496: 482 000142CE .align 1 ! 497: 483 000142CE .globl _print_pipe15_er ! 498: 484 000142CE _print_pipe15_er: ! 499: 485 000142CE 0000 .word L441 ! 500: 486 000142D0 # ! 501: 487 000142D0 # ! 502: 488 000142D0 # ! 503: 489 000142D0 # ! 504: 490 000142D0 # ! 505: 491 000142D0 # ! 506: 492 000142D0 # /**************************************************************************** ! 507: 493 000142D0 # * Report an error message of the form: ! 508: 494 000142D0 # * ! 509: 495 000142D0 # * Cycle: xx. EVT test xx. subtest xx. <your message here>. index = xx ! 510: 496 000142D0 # * inst = LDF op1, MULF op2, STF op3 (overflow fault on the MULF) ! 511: 497 000142D0 # ****************************************************************************/ ! 512: 498 000142D0 # print_pipe15_er( msg ) ! 513: 499 000142D0 # char *msg; /* error message to print */ ! 514: 500 000142D0 # { ! 515: 501 000142D0 13 0096 jbr L443 ! 516: 502 000142D3 L444: ! 517: 503 000142D3 # if( errcnt == 1 ) /* 1st error? */ ! 518: 504 000142D3 1d effffffc1b 01 cmpl _errcnt,$1 ! 519: 505 000142DA 21 0d jneq L445 ! 520: 506 000142DC # writes(" \n"); /* start a new print line */ ! 521: 507 000142DC .data 1 ! 522: 508 00000641 * L446: ! 523: 509 00000641 * 200A00 .ascii " \12\0" ! 524: 510 00000644 * .text ! 525: 511 000142DC dd 8f00000641 pushl $L446 ! 526: 512 000142E2 fe 08 effffffc0b callf $8,_writes ! 527: 513 000142E9 # writes("Cycle: "); ! 528: 514 000142E9 L445: ! 529: 515 000142E9 .data 1 ! 530: 516 00000644 * L447: ! 531: 517 00000644 * 4379636C653A2000 .ascii "Cycle: \0" ! 532: 518 0000064c * .text ! 533: 519 000142E9 dd 8f00000644 pushl $L447 ! 534: 520 000142EF fe 08 effffffbfe callf $8,_writes ! 535: 521 000142F6 # writed( cycle ); ! 536: 522 000142F6 dd effffffbf8 pushl _cycle ! 537: 523 000142FC fe 08 effffffbf1 callf $8,_writed ! 538: 524 00014303 # writes(" EVT test "); ! 539: 525 00014303 .data 1 ! 540: 526 0000064c * L449: ! 541: 527 0000064c * 202045565420746573742000 .ascii " EVT test \0" ! 542: 528 00000658 * .text ! 543: 529 00014303 dd 8f0000064c pushl $L449 ! 544: 530 00014309 fe 08 effffffbe4 callf $8,_writes ! 545: 531 00014310 # writed( test_no ); ! 546: 532 00014310 dd effffffbde pushl _test_no ! 547: 533 00014316 fe 08 effffffbd7 callf $8,_writed ! 548: 534 0001431D # writes(". subtest "); ! 549: 535 0001431D .data 1 ! 550: 536 00000658 * L450: ! 551: 537 00000658 * 2E20737562746573742000 .ascii ". subtest \0" ! 552: 538 00000663 * .text ! 553: 539 0001431D dd 8f00000658 pushl $L450 ! 554: 540 00014323 fe 08 effffffbca callf $8,_writes ! 555: 541 0001432A # writed( subtest ); ! 556: 542 0001432A dd effffffbc4 pushl _subtest ! 557: 543 00014330 fe 08 effffffbbd callf $8,_writed ! 558: 544 00014337 # writes( msg ); /* print the message */ ! 559: 545 00014337 dd ad04 pushl 4(fp) ! 560: 546 0001433A fe 08 effffffbb3 callf $8,_writes ! 561: 547 00014341 # writes(". index = "); ! 562: 548 00014341 .data 1 ! 563: 549 00000663 * L451: ! 564: 550 00000663 * 2E20696E646578203D2000 .ascii ". index = \0" ! 565: 551 0000066e * .text ! 566: 552 00014341 dd 8f00000663 pushl $L451 ! 567: 553 00014347 fe 08 effffffba6 callf $8,_writes ! 568: 554 0001434E # writed( index ); ! 569: 555 0001434E dd effffffba0 pushl _index ! 570: 556 00014354 fe 08 effffffb99 callf $8,_writed ! 571: 557 0001435B # writes( ! 572: 558 0001435B # "\ninst = LDF op1, MULF op2, STF op3 (overflow fault on the MULF)\n"); ! 573: 559 0001435B .data 1 ! 574: 560 0000066e * L452: ! 575: 561 0000066e * 0A696E7374203D204C4446206 .ascii "\12inst = LDF op1, MULF op2, STF op3 (overflow fault on the MUL" ! 576: F70312C204D554C46206F7032 ! 577: 2C20535446206F70332020202 ! 578: 0286F766572666C6F77206661 ! 579: 756C74206F6E20746865204D5 ! 580: 54C ! 581: 562 000006ae * 46290A00 .ascii "F)\12\0" ! 582: 563 000006b2 * .text ! 583: 564 0001435B dd 8f0000066e pushl $L452 ! 584: 565 00014361 fe 08 effffffb8c callf $8,_writes ! 585: 566 00014368 # } ! 586: 567 00014368 40 ret#2 ! 587: 568 00014369 .set L441,0x0 ! 588: 569 00014369 L443: ! 589: 570 00014369 13 ff67 jbr L444 ! 590: 571 0001436C .data ! 591: 572 0000050c * .text ! 592: 573 0001436C .align 1 ! 593: 574 0001436C .globl _pipe15_halt ! 594: 575 0001436C _pipe15_halt: ! 595: 576 0001436C 0000 .word L453 ! 596: 577 0001436E # ! 597: 578 0001436E # ! 598: 579 0001436E # ! 599: 580 0001436E # /**************************************************************************** ! 600: 581 0001436E # * halt on error routine ! 601: 582 0001436E # ****************************************************************************/ ! 602: 583 0001436E # pipe15_halt( code ) ! 603: 584 0001436E # int code; /* error code to halt with */ ! 604: 585 0001436E # { ! 605: 586 0001436E 13 008b jbr L455 ! 606: 587 00014371 L456: ! 607: 588 00014371 # err_code = code; ! 608: 589 00014371 0d ad04 effffffb7b movl 4(fp),_err_code ! 609: 590 00014379 # sgl_value_1 = dbl_ld_acc.m; ! 610: 591 00014379 0d effffffb75 effffffb70 movl _dbl_ld_acc,_sgl_value_1 ! 611: 592 00014384 # sgl_value_2 = dbl_value_1.m; ! 612: 593 00014384 0d effffffb6a effffffb65 movl _dbl_value_1,_sgl_value_2 ! 613: 594 0001438F # sgl_value_3 = post_evt_acc.m; ! 614: 595 0001438F 0d effffffb5f effffffb5a movl _post_evt_acc,_sgl_value_3 ! 615: 596 0001439A # sgl_value_4 = PIPE15_PAT; ! 616: 597 0001439A 0d 8f12341234 effffffb4f movl $305402420,_sgl_value_4 ! 617: 598 000143A5 # sgl_value_5 = dbl_value_2.m; ! 618: 599 000143A5 0d effffffb49 effffffb44 movl _dbl_value_2,_sgl_value_5 ! 619: 600 000143B0 # asm("movl _test_no,r0"); /* r0 = test number */ ! 620: 601 000143B0 0d effffffb3e 50 movl _test_no,r0 ! 621: 602 000143B7 # asm("movl _subtest,r1"); /* r1 = subtest number */ ! 622: 603 000143B7 0d effffffb37 51 movl _subtest,r1 ! 623: 604 000143BE # asm("movl _err_code,r2"); /* r2 = error code */ ! 624: 605 000143BE 0d effffffb30 52 movl _err_code,r2 ! 625: 606 000143C5 # asm("movl _cycle,r3"); /* r3 = cycle count */ ! 626: 607 000143C5 0d effffffb29 53 movl _cycle,r3 ! 627: 608 000143CC # asm("movl _sgl_value_1,r4"); /* r4 = initial acc. */ ! 628: 609 000143CC 0d effffffb22 54 movl _sgl_value_1,r4 ! 629: 610 000143D3 # asm("movl _sgl_value_2,r5"); /* r5 = MULF operand */ ! 630: 611 000143D3 0d effffffb1b 55 movl _sgl_value_2,r5 ! 631: 612 000143DA # asm("movl _sgl_value_3,r6"); /* r6 = final acc. */ ! 632: 613 000143DA 0d effffffb14 56 movl _sgl_value_3,r6 ! 633: 614 000143E1 # asm("clrl r7"); /* r7 = expected acc. */ ! 634: 615 000143E1 4d 57 clrl r7 ! 635: 616 000143E3 # asm("movl _sgl_value_4,r8"); /* r8 = initial op3 value */ ! 636: 617 000143E3 0d effffffb0b 58 movl _sgl_value_4,r8 ! 637: 618 000143EA # asm("movl _sgl_value_5,r9"); /* r9 = final op3 value */ ! 638: 619 000143EA 0d effffffb04 59 movl _sgl_value_5,r9 ! 639: 620 000143F1 # asm("clrl r10"); /* r10 = expected op3 value */ ! 640: 621 000143F1 4d 5a clrl r10 ! 641: 622 000143F3 # asm("movl _index,r11"); /* r11 = data index */ ! 642: 623 000143F3 0d effffffafb 5b movl _index,r11 ! 643: 624 000143FA # asm("halt"); /* HALT ... */ ! 644: 625 000143FA 00 halt ! 645: 626 000143FB # } ! 646: 627 000143FB 40 ret#2 ! 647: 628 000143FC .set L453,0x0 ! 648: 629 000143FC L455: ! 649: 630 000143FC 13 ff72 jbr L456 ! 650: 631 000143FF .data ! 651: 631 000282F3 .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.