![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe16.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 pipe16.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 00000714 * .text ! 4: 4 00000000 .align 1 ! 5: 5 00000000 .globl _pipe16 ! 6: 6 00000000 _pipe16: ! 7: 7 00014400 0000 .word L381 ! 8: 8 00014402 # ! 9: 9 00014402 # #include "evt_defs.h" ! 10: 10 00014402 # ! 11: 11 00014402 # /* ! 12: 12 00014402 # ********************************************************************* ! 13: 13 00014402 # * FPP PIPELINED EVENTS TEST #16 ! 14: 14 00014402 # * ! 15: 15 00014402 # * This test will execute the following code: "LDD ADDD STD" ! 16: 16 00014402 # * with an overflow fault on the ADDD. We will make sure that: ! 17: 17 00014402 # * 1. The fault is detected, ! 18: 18 00014402 # * 2. the accumulator is cleared, and ! 19: 19 00014402 # * 3. that a floating '0' is stored by the STD or that there is no store. ! 20: 20 00014402 # ********************************************************************* ! 21: 21 00014402 # */ ! 22: 22 00014402 # pipe16() ! 23: 23 00014402 # { ! 24: 24 00014402 13 016d jbr L383 ! 25: 25 00014405 L384: ! 26: 26 00014405 # #define PIPE16_PAT1 0x11223344 ! 27: 27 00014405 # #define PIPE16_PAT2 0x55667788 ! 28: 28 00014405 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */ ! 29: 29 00014405 ed 6d effffffff4 moval (r13),_pre_event_fp ! 30: 30 0001440C # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */ ! 31: 31 0001440C ed 6e efffffffed moval (r14),_pre_event_sp ! 32: 32 00014413 # precision = DBL; ! 33: 33 00014413 0d 02 efffffffe6 movl $2,_precision ! 34: 34 0001441A # test_event = ARITH_CODE; /* expect an arithmetic fault */ ! 35: 35 0001441A 0d 34 efffffffdf movl $52,_test_event ! 36: 36 00014421 # exp_code = FLT_OVFL_CODE; /* - specificly overflow */ ! 37: 37 00014421 0d 04 efffffffd8 movl $4,_exp_code ! 38: 38 00014428 # exp_event = FALSE; /* ... but not yet */ ! 39: 39 00014428 4d efffffffd2 clrl _exp_event ! 40: 40 0001442E # asm("movab _pipe16_ret,_event_return"); /* set event return address */ ! 41: 41 0001442E e9 ef000000c1 efffffffc7 movab _pipe16_ret,_event_return ! 42: 42 00014439 # max_index = add_ov_cnt; /* set max operand index */ ! 43: 43 00014439 0d efffffffc1 efffffffbc movl _add_ov_cnt,_max_index ! 44: 44 00014444 # for( index = 0; index < max_index; index++ ) ! 45: 45 00014444 4d efffffffb6 clrl _index ! 46: 46 0001444A L387: ! 47: 47 0001444A 1d efffffffb0 efffffffab cmpl _index,_max_index ! 48: 48 00014455 91 03 13 0117 jgeq L386 ! 49: 49 0001445A # { ! 50: 50 0001445A # dbl_ld_acc = add_ov_dat[index].op_1; /* get the Acc data */ ! 51: 51 0001445A 48 04 efffffff9f 50 shll $4,_index,r0 ! 52: 52 00014462 0c 8f00000000 50 addl2 $_add_ov_dat,r0 ! 53: 53 00014469 0d a004 efffffff93 movl 4(r0),_dbl_ld_acc+4 ! 54: 54 00014471 0d 60 efffffff88 movl (r0),_dbl_ld_acc ! 55: 55 00014478 # dbl_value_1 = add_ov_dat[index].op_2; /* get the B operand */ ! 56: 56 00014478 48 04 efffffff81 50 shll $4,_index,r0 ! 57: 57 00014480 0c 8f00000008 50 addl2 $_add_ov_dat+8,r0 ! 58: 58 00014487 0d a004 efffffff75 movl 4(r0),_dbl_value_1+4 ! 59: 59 0001448F 0d 60 efffffff6a movl (r0),_dbl_value_1 ! 60: 60 00014496 # dbl_value_2.m = PIPE16_PAT1; /* set the initial */ ! 61: 61 00014496 0d 8f11223344 efffffff5f movl $287454020,_dbl_value_2 ! 62: 62 000144A1 # dbl_value_2.l = PIPE16_PAT2; /* STD op's contents */ ! 63: 63 000144A1 0d 8f55667788 efffffff58 movl $1432778632,_dbl_value_2+4 ! 64: 64 000144AC # asm(".globl _pipe16_lp1"); ! 65: 65 000144AC .globl _pipe16_lp1 ! 66: 66 000144AC # asm("_pipe16_lp1:"); ! 67: 67 000144AC _pipe16_lp1: ! 68: 68 000144AC # asm("bispsw $0x60"); /* enable ovfl,undfl */ ! 69: 69 000144AC 8b 8860 bispsw $0x60 ! 70: 70 000144AF # asm("ldd _dbl_ld_acc"); /* load the Acc. */ ! 71: 71 000144AF 07 efffffff4b ldd _dbl_ld_acc ! 72: 72 000144B5 # exp_event = test_event; /* expect event soon */ ! 73: 73 000144B5 0d efffffff45 efffffff40 movl _test_event,_exp_event ! 74: 74 000144C0 # asm("addd _dbl_value_1"); /* trigger the event */ ! 75: 75 000144C0 c7 efffffff3a addd _dbl_value_1 ! 76: 76 000144C6 # asm("std _dbl_value_2"); /* shouldn't get here*/ ! 77: 77 000144C6 27 efffffff34 std _dbl_value_2 ! 78: 78 000144CC # /* ! 79: 79 000144CC # * If we got to here then there was no event ! 80: 80 000144CC # */ ! 81: 81 000144CC # if( force_loop ) ! 82: 82 000144CC 5d efffffff2e tstl _force_loop ! 83: 83 000144D2 31 03 jeql L388 ! 84: 84 000144D4 # asm("brw _pipe16_lp1");; /* loop on the error */ ! 85: Assemb0002BBC0 # asm("brw _pipe16_lp1");; /* loop on the error */ ! 86: "pipe100014406 e 85: WARNING: brw: destination label is external ! 87: 85 000144D4 13 ffd5 brw _pipe16_lp1 ! 88: 86 000144D7 L388: ! 89: 87 000144D7 # exp_event = FALSE; /* reset event expected flag */ ! 90: 88 000144D7 4d efffffff23 clrl _exp_event ! 91: 89 000144DD # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */ ! 92: 90 000144DD 0d efffffff1d 5d movl _pre_event_fp,fp ! 93: 91 000144E4 # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */ ! 94: 92 000144E4 0d efffffff16 5e movl _pre_event_sp,sp ! 95: 93 000144EB # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */ ! 96: 94 000144EB 9b 8860 bicpsw $0x60 ! 97: 95 000144EE # no_pipe16_evt();; /* report the error */ ! 98: 96 000144EE fe 04 ef00000081 callf $4,_no_pipe16_evt ! 99: 97 000144F5 # /* ! 100: 98 000144F5 # * Come here after the event ! 101: 99 000144F5 # */ ! 102: 100 000144F5 # asm(".globl _pipe16_ret"); ! 103: 101 000144F5 .globl _pipe16_ret ! 104: 102 000144F5 # asm("_pipe16_ret:"); ! 105: 103 000144F5 _pipe16_ret: ! 106: 104 000144F5 # asm("movl _pre_event_fp,fp"); /* restore the frame pointer */ ! 107: 105 000144F5 0d efffffff05 5d movl _pre_event_fp,fp ! 108: 106 000144FC # asm("movl _pre_event_sp,sp"); /* restore the stack pointer */ ! 109: 107 000144FC 0d effffffefe 5e movl _pre_event_sp,sp ! 110: 108 00014503 # if( force_loop ) ! 111: 109 00014503 5d effffffef7 tstl _force_loop ! 112: 110 00014509 31 03 jeql L390 ! 113: 111 0001450B # asm("brw _pipe16_lp1");; /* loop on the error */ ! 114: "pipe100014406 e 112: WARNING: brw: destination label is external ! 115: 112 0001450B 13 ff9e brw _pipe16_lp1 ! 116: 113 0001450E L390: ! 117: 114 0001450E # asm("bicpsw $0x60"); /* disable ovfl & undfl evts */ ! 118: 115 0001450E 9b 8860 bicpsw $0x60 ! 119: 116 00014511 # if( (post_evt_acc.m) || (post_evt_acc.l) ) /* is Acc = 0? */ ! 120: 117 00014511 5d effffffee9 tstl _post_evt_acc ! 121: 118 00014517 21 08 jneq L9999 ! 122: 119 00014519 5d effffffee5 tstl _post_evt_acc+4 ! 123: 120 0001451F 31 09 jeql L391 ! 124: 121 00014521 L9999: ! 125: 122 00014521 # bad_pipe16_result(); /* incorrect result error */ ! 126: 123 00014521 fe 04 ef0000017a callf $4,_bad_pipe16_result ! 127: 124 00014528 # else if( ( (dbl_value_2.m) || ! 128: 125 00014528 11 3e jbr L393 ! 129: 126 0001452A L391: ! 130: 127 0001452A # (dbl_value_2.l) ) /* either a '0' s/b stored, */ ! 131: 128 0001452A # && (dbl_value_2.m != 0x80000000) /* or a RESERVED OP, or */ ! 132: 129 0001452A # && ( (dbl_value_2.m != PIPE16_PAT1) || /* there s/b no */ ! 133: 130 0001452A # (dbl_value_2.l != PIPE16_PAT2) ) ) /* store at all */ ! 134: 131 0001452A 5d effffffed0 tstl _dbl_value_2 ! 135: 132 00014530 21 08 jneq L9998 ! 136: 133 00014532 5d effffffecc tstl _dbl_value_2+4 ! 137: 134 00014538 31 2e jeql L394 ! 138: 135 0001453A L9998: ! 139: 136 0001453A 1d effffffec0 8f80000000 cmpl _dbl_value_2,$-2147483648 ! 140: 137 00014545 31 21 jeql L394 ! 141: 138 00014547 1d effffffeb3 8f11223344 cmpl _dbl_value_2,$287454020 ! 142: 139 00014552 21 0d jneq L9997 ! 143: 140 00014554 1d effffffeaa 8f55667788 cmpl _dbl_value_2+4,$1432778632 ! 144: 141 0001455F 31 07 jeql L394 ! 145: 142 00014561 L9997: ! 146: 143 00014561 # bad_pipe16_store(); /* incorrect store error */ ! 147: 144 00014561 fe 04 ef000002be callf $4,_bad_pipe16_store ! 148: 145 00014568 # } ! 149: 146 00014568 L394: ! 150: 147 00014568 L393: ! 151: 148 00014568 L385: ! 152: 149 00014568 6d effffffe92 incl _index ! 153: 150 0001456E 13 fed9 jbr L387 ! 154: 151 00014571 L386: ! 155: 152 00014571 # } ! 156: 153 00014571 40 ret#2 ! 157: 154 00014572 .set L381,0x0 ! 158: 155 00014572 L383: ! 159: 156 00014572 13 fe90 jbr L384 ! 160: 157 00014575 .data ! 161: 158 00000714 * .text ! 162: 159 00014575 00 .align 1 ! 163: 160 00014576 .globl _no_pipe16_evt ! 164: 161 00014576 _no_pipe16_evt: ! 165: 162 00014576 0000 .word L396 ! 166: 163 00014578 # ! 167: 164 00014578 # ! 168: 165 00014578 # ! 169: 166 00014578 # /**************************************************************************** ! 170: 167 00014578 # * Report an "EVENT NOT DETECTED" error ! 171: 168 00014578 # * ! 172: 169 00014578 # * Cycle: xx. EVT test xx. subtest xx. No overflow fault seen. index = xx ! 173: 170 00014578 # * inst = LDD op1, ADDD op2, STD op3 (overflow fault on the ADDD) ! 174: 171 00014578 # * op1 = xxxxxxxx xxxxxxxx, initial op3 = xxxxxxxx xxxxxxxx ! 175: 172 00014578 # * op2 = xxxxxxxx xxxxxxxx, final op3 = xxxxxxxx xxxxxxxx ! 176: 173 00014578 # ****************************************************************************/ ! 177: 174 00014578 # no_pipe16_evt() ! 178: 175 00014578 # { ! 179: 176 00014578 13 0124 jbr L398 ! 180: 177 0001457B L399: ! 181: 178 0001457B # errcnt++; /* bump the error count */ ! 182: 179 0001457B 6d effffffe7f incl _errcnt ! 183: 180 00014581 # if ( prt_error ) ! 184: 181 00014581 5d effffffe79 tstl _prt_error ! 185: 182 00014587 21 03 13 00ec jeql L400 ! 186: 183 0001458C # { ! 187: 184 0001458C # sgl_value_1 = PIPE16_PAT1; ! 188: 185 0001458C 0d 8f11223344 effffffe69 movl $287454020,_sgl_value_1 ! 189: 186 00014597 # sgl_value_2 = PIPE16_PAT2; ! 190: 187 00014597 0d 8f55667788 effffffe5e movl $1432778632,_sgl_value_2 ! 191: 188 000145A2 # print_pipe16_er( ". No overflow fault seen." ); ! 192: 189 000145A2 .data 1 ! 193: 190 00000714 * L402: ! 194: 191 00000714 * 2E204E6F206F766572666C6F7 .ascii ". No overflow fault seen.\0" ! 195: 7206661756C74207365656E2E ! 196: 00 ! 197: 192 0000072e * .text ! 198: 193 000145A2 dd 8f00000714 pushl $L402 ! 199: 194 000145A8 fe 08 ef000003ff callf $8,_print_pipe16_er ! 200: 195 000145AF # writes("op1 = "); ! 201: 196 000145AF .data 1 ! 202: 197 0000072e * L404: ! 203: 198 0000072e * 6F7031203D2000 .ascii "op1 = \0" ! 204: 199 00000735 * .text ! 205: 200 000145AF dd 8f0000072e pushl $L404 ! 206: 201 000145B5 fe 08 effffffe44 callf $8,_writes ! 207: 202 000145BC # write32h( dbl_ld_acc.m ); ! 208: 203 000145BC dd effffffe3e pushl _dbl_ld_acc ! 209: 204 000145C2 fe 08 effffffe37 callf $8,_write32h ! 210: 205 000145C9 # writec(' '); ! 211: 206 000145C9 dd 20 pushl $32 ! 212: 207 000145CB fe 08 effffffe2e callf $8,_writec ! 213: 208 000145D2 # write32h( dbl_ld_acc.l ); ! 214: 209 000145D2 dd effffffe2c pushl _dbl_ld_acc+4 ! 215: 210 000145D8 fe 08 effffffe21 callf $8,_write32h ! 216: 211 000145DF # writes(", initial op3 = "); ! 217: 212 000145DF .data 1 ! 218: 213 00000735 * L407: ! 219: 214 00000735 * 2C202020696E697469616C206 .ascii ", initial op3 = \0" ! 220: F7033203D2000 ! 221: 215 00000748 * .text ! 222: 216 000145DF dd 8f00000735 pushl $L407 ! 223: 217 000145E5 fe 08 effffffe14 callf $8,_writes ! 224: 218 000145EC # write32h( sgl_value_1 ); ! 225: 219 000145EC dd effffffe0e pushl _sgl_value_1 ! 226: 220 000145F2 fe 08 effffffe07 callf $8,_write32h ! 227: 221 000145F9 # writec(' '); ! 228: 222 000145F9 dd 20 pushl $32 ! 229: 223 000145FB fe 08 effffffdfe callf $8,_writec ! 230: 224 00014602 # write32h( sgl_value_2 ); ! 231: 225 00014602 dd effffffdf8 pushl _sgl_value_2 ! 232: 226 00014608 fe 08 effffffdf1 callf $8,_write32h ! 233: 227 0001460F # writes("\nop2 = "); ! 234: 228 0001460F .data 1 ! 235: 229 00000748 * L408: ! 236: 230 00000748 * 0A6F7032203D2000 .ascii "\12op2 = \0" ! 237: 231 00000750 * .text ! 238: 232 0001460F dd 8f00000748 pushl $L408 ! 239: 233 00014615 fe 08 effffffde4 callf $8,_writes ! 240: 234 0001461C # write32h( dbl_value_1.m ); ! 241: 235 0001461C dd effffffdde pushl _dbl_value_1 ! 242: 236 00014622 fe 08 effffffdd7 callf $8,_write32h ! 243: 237 00014629 # writec(' '); ! 244: 238 00014629 dd 20 pushl $32 ! 245: 239 0001462B fe 08 effffffdce callf $8,_writec ! 246: 240 00014632 # write32h( dbl_value_1.l ); ! 247: 241 00014632 dd effffffdcc pushl _dbl_value_1+4 ! 248: 242 00014638 fe 08 effffffdc1 callf $8,_write32h ! 249: 243 0001463F # writes(", final op3 = "); ! 250: 244 0001463F .data 1 ! 251: 245 00000750 * L409: ! 252: 246 00000750 * 2C202020202066696E616C206 .ascii ", final op3 = \0" ! 253: F7033203D2000 ! 254: 247 00000763 * .text ! 255: 248 0001463F dd 8f00000750 pushl $L409 ! 256: 249 00014645 fe 08 effffffdb4 callf $8,_writes ! 257: 250 0001464C # write32h( dbl_value_2.m ); ! 258: 251 0001464C dd effffffdae pushl _dbl_value_2 ! 259: 252 00014652 fe 08 effffffda7 callf $8,_write32h ! 260: 253 00014659 # writec(' '); ! 261: 254 00014659 dd 20 pushl $32 ! 262: 255 0001465B fe 08 effffffd9e callf $8,_writec ! 263: 256 00014662 # write32h( dbl_value_2.l ); ! 264: 257 00014662 dd effffffd9c pushl _dbl_value_2+4 ! 265: 258 00014668 fe 08 effffffd91 callf $8,_write32h ! 266: 259 0001466F # writec('\n'); ! 267: 260 0001466F dd 0a pushl $10 ! 268: 261 00014671 fe 08 effffffd88 callf $8,_writec ! 269: 262 00014678 # } ! 270: 263 00014678 # if ( halt_flg ) /* halt on error? */ ! 271: 264 00014678 L400: ! 272: 265 00014678 5d effffffd82 tstl _halt_flg ! 273: 266 0001467E 31 09 jeql L410 ! 274: 267 00014680 # pipe16_halt( 1 ); /* halt with a code of 1 */ ! 275: 268 00014680 dd 01 pushl $1 ! 276: 269 00014682 fe 08 ef000003c3 callf $8,_pipe16_halt ! 277: 270 00014689 # if ( loop_on_err ) ! 278: 271 00014689 L410: ! 279: 272 00014689 5d effffffd71 tstl _loop_on_err ! 280: 273 0001468F 31 0d jeql L412 ! 281: 274 00014691 # { ! 282: 275 00014691 # force_loop = TRUE; /* set the force loop flag */ ! 283: 276 00014691 0d 01 effffffd68 movl $1,_force_loop ! 284: 277 00014698 # asm("jmp _pipe16_lp1"); /* and loop */ ! 285: 278 00014698 71 effffffe0e jmp _pipe16_lp1 ! 286: 279 0001469E # }; ! 287: 280 0001469E L412: ! 288: 281 0001469E # } ! 289: 282 0001469E 40 ret#2 ! 290: 283 0001469F .set L396,0x0 ! 291: 284 0001469F L398: ! 292: 285 0001469F 13 fed9 jbr L399 ! 293: 286 000146A2 .data ! 294: 287 00000714 * .text ! 295: 288 000146A2 .align 1 ! 296: 289 000146A2 .globl _bad_pipe16_result ! 297: 290 000146A2 _bad_pipe16_result: ! 298: 291 000146A2 0000 .word L413 ! 299: 292 000146A4 # ! 300: 293 000146A4 # ! 301: 294 000146A4 # ! 302: 295 000146A4 # ! 303: 296 000146A4 # /**************************************************************************** ! 304: 297 000146A4 # * Report an "BAD ACCUMULATOR AFTER THE EVENT" error ! 305: 298 000146A4 # * ! 306: 299 000146A4 # * Cycle: xx. EVT test xx. subtest xx. Bad final Accumulator. index = xx ! 307: 300 000146A4 # * inst = LDD op1, ADDD op2, STD op3 (overflow fault on the ADDD) ! 308: 301 000146A4 # * op1 = xxxxxxxx xxxxxxxx, final Acc = xxxxxxxx xxxxxxxx ! 309: 302 000146A4 # * op2 = xxxxxxxx xxxxxxxx, expected = xxxxxxxx xxxxxxxx ! 310: 303 000146A4 # * init op3 = xxxxxxxx xxxxxxxx, final op3 = xxxxxxxx xxxxxxxx ! 311: 304 000146A4 # ****************************************************************************/ ! 312: 305 000146A4 # bad_pipe16_result() ! 313: 306 000146A4 # { ! 314: 307 000146A4 13 017c jbr L415 ! 315: 308 000146A7 L416: ! 316: 309 000146A7 # errcnt++; /* bump the error count */ ! 317: 310 000146A7 6d effffffd53 incl _errcnt ! 318: 311 000146AD # if ( prt_error ) ! 319: 312 000146AD 5d effffffd4d tstl _prt_error ! 320: 313 000146B3 21 03 13 0144 jeql L417 ! 321: 314 000146B8 # { ! 322: 315 000146B8 # sgl_value_1 = PIPE16_PAT1; ! 323: 316 000146B8 0d 8f11223344 effffffd3d movl $287454020,_sgl_value_1 ! 324: 317 000146C3 # sgl_value_2 = PIPE16_PAT2; ! 325: 318 000146C3 0d 8f55667788 effffffd32 movl $1432778632,_sgl_value_2 ! 326: 319 000146CE # print_pipe16_er( ". Bad final Accumulator" ); ! 327: 320 000146CE .data 1 ! 328: 321 00000763 * L418: ! 329: 322 00000763 * 2E204261642066696E616C204 .ascii ". Bad final Accumulator\0" ! 330: 16363756D756C61746F7200 ! 331: 323 0000077b * .text ! 332: 324 000146CE dd 8f00000763 pushl $L418 ! 333: 325 000146D4 fe 08 ef000002d3 callf $8,_print_pipe16_er ! 334: 326 000146DB # writes("op1 = "); ! 335: 327 000146DB .data 1 ! 336: 328 0000077b * L419: ! 337: 329 0000077b * 6F7031203D2000 .ascii "op1 = \0" ! 338: 330 00000782 * .text ! 339: 331 000146DB dd 8f0000077b pushl $L419 ! 340: 332 000146E1 fe 08 effffffd18 callf $8,_writes ! 341: 333 000146E8 # write32h( dbl_ld_acc.m ); ! 342: 334 000146E8 dd effffffd12 pushl _dbl_ld_acc ! 343: 335 000146EE fe 08 effffffd0b callf $8,_write32h ! 344: 336 000146F5 # writec(' '); ! 345: 337 000146F5 dd 20 pushl $32 ! 346: 338 000146F7 fe 08 effffffd02 callf $8,_writec ! 347: 339 000146FE # write32h( dbl_ld_acc.l ); ! 348: 340 000146FE dd effffffd00 pushl _dbl_ld_acc+4 ! 349: 341 00014704 fe 08 effffffcf5 callf $8,_write32h ! 350: 342 0001470B # writes(", final Acc. = "); ! 351: 343 0001470B .data 1 ! 352: 344 00000782 * L420: ! 353: 345 00000782 * 2C2066696E616C204163632E2 .ascii ", final Acc. = \0" ! 354: 03D2000 ! 355: 346 00000792 * .text ! 356: 347 0001470B dd 8f00000782 pushl $L420 ! 357: 348 00014711 fe 08 effffffce8 callf $8,_writes ! 358: 349 00014718 # write32h( post_evt_acc.l ); ! 359: 350 00014718 dd effffffce6 pushl _post_evt_acc+4 ! 360: 351 0001471E fe 08 effffffcdb callf $8,_write32h ! 361: 352 00014725 # writec(' '); ! 362: 353 00014725 dd 20 pushl $32 ! 363: 354 00014727 fe 08 effffffcd2 callf $8,_writec ! 364: 355 0001472E # write32h( post_evt_acc.l ); ! 365: 356 0001472E dd effffffcd0 pushl _post_evt_acc+4 ! 366: 357 00014734 fe 08 effffffcc5 callf $8,_write32h ! 367: 358 0001473B # writes("\nop2 = "); ! 368: 359 0001473B .data 1 ! 369: 360 00000792 * L421: ! 370: 361 00000792 * 0A6F7032203D2000 .ascii "\12op2 = \0" ! 371: 362 0000079a * .text ! 372: 363 0001473B dd 8f00000792 pushl $L421 ! 373: 364 00014741 fe 08 effffffcb8 callf $8,_writes ! 374: 365 00014748 # write32h( dbl_value_1.m ); ! 375: 366 00014748 dd effffffcb2 pushl _dbl_value_1 ! 376: 367 0001474E fe 08 effffffcab callf $8,_write32h ! 377: 368 00014755 # writec(' '); ! 378: 369 00014755 dd 20 pushl $32 ! 379: 370 00014757 fe 08 effffffca2 callf $8,_writec ! 380: 371 0001475E # write32h( dbl_value_1.l ); ! 381: 372 0001475E dd effffffca0 pushl _dbl_value_1+4 ! 382: 373 00014764 fe 08 effffffc95 callf $8,_write32h ! 383: 374 0001476B # writes(", expected = "); ! 384: 375 0001476B .data 1 ! 385: 376 0000079a * L422: ! 386: 377 0000079a * 2C20202065787065637465642 .ascii ", expected = \0" ! 387: 03D2000 ! 388: 378 000007aa * .text ! 389: 379 0001476B dd 8f0000079a pushl $L422 ! 390: 380 00014771 fe 08 effffffc88 callf $8,_writes ! 391: 381 00014778 # write32h( 0 ); /* the expected result = 0 */ ! 392: 382 00014778 dd 00 pushl $0 ! 393: 383 0001477A fe 08 effffffc7f callf $8,_write32h ! 394: 384 00014781 # writec(' '); ! 395: 385 00014781 dd 20 pushl $32 ! 396: 386 00014783 fe 08 effffffc76 callf $8,_writec ! 397: 387 0001478A # write32h( 0 ); ! 398: 388 0001478A dd 00 pushl $0 ! 399: 389 0001478C fe 08 effffffc6d callf $8,_write32h ! 400: 390 00014793 # writes("\ninit op3 = "); ! 401: 391 00014793 .data 1 ! 402: 392 000007aa * L423: ! 403: 393 000007aa * 0A696E6974206F7033203D200 .ascii "\12init op3 = \0" ! 404: 0 ! 405: 394 000007b7 * .text ! 406: 395 00014793 dd 8f000007aa pushl $L423 ! 407: 396 00014799 fe 08 effffffc60 callf $8,_writes ! 408: 397 000147A0 # write32h( sgl_value_1 ); ! 409: 398 000147A0 dd effffffc5a pushl _sgl_value_1 ! 410: 399 000147A6 fe 08 effffffc53 callf $8,_write32h ! 411: 400 000147AD # writec(' '); ! 412: 401 000147AD dd 20 pushl $32 ! 413: 402 000147AF fe 08 effffffc4a callf $8,_writec ! 414: 403 000147B6 # write32h( sgl_value_2 ); ! 415: 404 000147B6 dd effffffc44 pushl _sgl_value_2 ! 416: 405 000147BC fe 08 effffffc3d callf $8,_write32h ! 417: 406 000147C3 # writes(", final op3 = "); ! 418: 407 000147C3 .data 1 ! 419: 408 000007b7 * L424: ! 420: 409 000007b7 * 2C202066696E616C206F70332 .ascii ", final op3 = \0" ! 421: 03D2000 ! 422: 410 000007c7 * .text ! 423: 411 000147C3 dd 8f000007b7 pushl $L424 ! 424: 412 000147C9 fe 08 effffffc30 callf $8,_writes ! 425: 413 000147D0 # write32h( dbl_value_2.m ); ! 426: 414 000147D0 dd effffffc2a pushl _dbl_value_2 ! 427: 415 000147D6 fe 08 effffffc23 callf $8,_write32h ! 428: 416 000147DD # writec(' '); ! 429: 417 000147DD dd 20 pushl $32 ! 430: 418 000147DF fe 08 effffffc1a callf $8,_writec ! 431: 419 000147E6 # write32h( dbl_value_2.l ); ! 432: 420 000147E6 dd effffffc18 pushl _dbl_value_2+4 ! 433: 421 000147EC fe 08 effffffc0d callf $8,_write32h ! 434: 422 000147F3 # writec('\n'); ! 435: 423 000147F3 dd 0a pushl $10 ! 436: 424 000147F5 fe 08 effffffc04 callf $8,_writec ! 437: 425 000147FC # } ! 438: 426 000147FC # if ( halt_flg ) /* halt on error? */ ! 439: 427 000147FC L417: ! 440: 428 000147FC 5d effffffbfe tstl _halt_flg ! 441: 429 00014802 31 09 jeql L425 ! 442: 430 00014804 # pipe16_halt( 2 ); /* halt with a code of 2 */ ! 443: 431 00014804 dd 02 pushl $2 ! 444: 432 00014806 fe 08 ef0000023f callf $8,_pipe16_halt ! 445: 433 0001480D # if ( loop_on_err ) ! 446: 434 0001480D L425: ! 447: 435 0001480D 5d effffffbed tstl _loop_on_err ! 448: 436 00014813 31 0d jeql L426 ! 449: 437 00014815 # { ! 450: 438 00014815 # force_loop = TRUE; /* set the force loop flag */ ! 451: 439 00014815 0d 01 effffffbe4 movl $1,_force_loop ! 452: 440 0001481C # asm("jmp _pipe16_lp1"); /* and loop */ ! 453: 441 0001481C 71 effffffc8a jmp _pipe16_lp1 ! 454: 442 00014822 # }; ! 455: 443 00014822 L426: ! 456: 444 00014822 # } ! 457: 445 00014822 40 ret#2 ! 458: 446 00014823 .set L413,0x0 ! 459: 447 00014823 L415: ! 460: 448 00014823 13 fe81 jbr L416 ! 461: 449 00014826 .data ! 462: 450 00000714 * .text ! 463: 451 00014826 .align 1 ! 464: 452 00014826 .globl _bad_pipe16_store ! 465: 453 00014826 _bad_pipe16_store: ! 466: 454 00014826 0000 .word L427 ! 467: 455 00014828 # ! 468: 456 00014828 # ! 469: 457 00014828 # ! 470: 458 00014828 # ! 471: 459 00014828 # ! 472: 460 00014828 # /**************************************************************************** ! 473: 461 00014828 # * Report an "BAD VALUE STORED INTO OPERAND 3" error ! 474: 462 00014828 # * ! 475: 463 00014828 # * Cycle: xx. EVT test xx. subtest xx. Bad STD OP3 result. index = xx ! 476: 464 00014828 # * inst = LDD op1, ADDD op2, STD op3 (overflow fault on the ADDD) ! 477: 465 00014828 # * op1 = xxxxxxxx xxxxxxxx, final Acc = xxxxxxxx xxxxxxxx ! 478: 466 00014828 # * op2 = xxxxxxxx xxxxxxxx, expected op3 = xxxxxxxx xxxxxxxx ! 479: 467 00014828 # * init op3 = xxxxxxxx xxxxxxxx, final op3 = xxxxxxxx xxxxxxxx ! 480: 468 00014828 # ****************************************************************************/ ! 481: 469 00014828 # bad_pipe16_store() ! 482: 470 00014828 # { ! 483: 471 00014828 13 0180 jbr L429 ! 484: 472 0001482B L430: ! 485: 473 0001482B # errcnt++; /* bump the error count */ ! 486: 474 0001482B 6d effffffbcf incl _errcnt ! 487: 475 00014831 # if ( prt_error ) ! 488: 476 00014831 5d effffffbc9 tstl _prt_error ! 489: 477 00014837 21 03 13 0148 jeql L431 ! 490: 478 0001483C # { ! 491: 479 0001483C # sgl_value_1 = PIPE16_PAT1; ! 492: 480 0001483C 0d 8f11223344 effffffbb9 movl $287454020,_sgl_value_1 ! 493: 481 00014847 # sgl_value_2 = PIPE16_PAT2; ! 494: 482 00014847 0d 8f55667788 effffffbae movl $1432778632,_sgl_value_2 ! 495: 483 00014852 # print_pipe16_er( ". Bad STD OP3 result" ); ! 496: 484 00014852 .data 1 ! 497: 485 000007c7 * L432: ! 498: 486 000007c7 * 2E202042616420535444204F5 .ascii ". Bad STD OP3 result\0" ! 499: 03320726573756C7400 ! 500: 487 000007dd * .text ! 501: 488 00014852 dd 8f000007c7 pushl $L432 ! 502: 489 00014858 fe 08 ef0000014f callf $8,_print_pipe16_er ! 503: 490 0001485F # writes(" op1 = "); ! 504: 491 0001485F .data 1 ! 505: 492 000007dd * L433: ! 506: 493 000007dd * 20202020206F7031203D2000 .ascii " op1 = \0" ! 507: 494 000007e9 * .text ! 508: 495 0001485F dd 8f000007dd pushl $L433 ! 509: 496 00014865 fe 08 effffffb94 callf $8,_writes ! 510: 497 0001486C # write32h( dbl_ld_acc.m ); ! 511: 498 0001486C dd effffffb8e pushl _dbl_ld_acc ! 512: 499 00014872 fe 08 effffffb87 callf $8,_write32h ! 513: 500 00014879 # writec(' '); ! 514: 501 00014879 dd 20 pushl $32 ! 515: 502 0001487B fe 08 effffffb7e callf $8,_writec ! 516: 503 00014882 # write32h( dbl_ld_acc.l ); ! 517: 504 00014882 dd effffffb7c pushl _dbl_ld_acc+4 ! 518: 505 00014888 fe 08 effffffb71 callf $8,_write32h ! 519: 506 0001488F # writes(", final Acc. = "); ! 520: 507 0001488F .data 1 ! 521: 508 000007e9 * L434: ! 522: 509 000007e9 * 2C2020202066696E616C20416 .ascii ", final Acc. = \0" ! 523: 3632E203D2000 ! 524: 510 000007fc * .text ! 525: 511 0001488F dd 8f000007e9 pushl $L434 ! 526: 512 00014895 fe 08 effffffb64 callf $8,_writes ! 527: 513 0001489C # write32h( post_evt_acc.l ); ! 528: 514 0001489C dd effffffb62 pushl _post_evt_acc+4 ! 529: 515 000148A2 fe 08 effffffb57 callf $8,_write32h ! 530: 516 000148A9 # writec(' '); ! 531: 517 000148A9 dd 20 pushl $32 ! 532: 518 000148AB fe 08 effffffb4e callf $8,_writec ! 533: 519 000148B2 # write32h( post_evt_acc.l ); ! 534: 520 000148B2 dd effffffb4c pushl _post_evt_acc+4 ! 535: 521 000148B8 fe 08 effffffb41 callf $8,_write32h ! 536: 522 000148BF # writes("\n op2 = "); ! 537: 523 000148BF .data 1 ! 538: 524 000007fc * L435: ! 539: 525 000007fc * 0A20202020206F7032203D200 .ascii "\12 op2 = \0" ! 540: 0 ! 541: 526 00000809 * .text ! 542: 527 000148BF dd 8f000007fc pushl $L435 ! 543: 528 000148C5 fe 08 effffffb34 callf $8,_writes ! 544: 529 000148CC # write32h( dbl_value_1.m ); ! 545: 530 000148CC dd effffffb2e pushl _dbl_value_1 ! 546: 531 000148D2 fe 08 effffffb27 callf $8,_write32h ! 547: 532 000148D9 # writec(' '); ! 548: 533 000148D9 dd 20 pushl $32 ! 549: 534 000148DB fe 08 effffffb1e callf $8,_writec ! 550: 535 000148E2 # write32h( dbl_value_1.l ); ! 551: 536 000148E2 dd effffffb1c pushl _dbl_value_1+4 ! 552: 537 000148E8 fe 08 effffffb11 callf $8,_write32h ! 553: 538 000148EF # writes(", expected op3 = "); ! 554: 539 000148EF .data 1 ! 555: 540 00000809 * L436: ! 556: 541 00000809 * 2C20206578706563746564206 .ascii ", expected op3 = \0" ! 557: F7033203D2000 ! 558: 542 0000081c * .text ! 559: 543 000148EF dd 8f00000809 pushl $L436 ! 560: 544 000148F5 fe 08 effffffb04 callf $8,_writes ! 561: 545 000148FC # write32h( 0x80000000 ); /* the expected result = 0 */ ! 562: 546 000148FC dd 8f80000000 pushl $-2147483648 ! 563: 547 00014902 fe 08 effffffaf7 callf $8,_write32h ! 564: 548 00014909 # writec(' '); ! 565: 549 00014909 dd 20 pushl $32 ! 566: 550 0001490B fe 08 effffffaee callf $8,_writec ! 567: 551 00014912 # write32h( 0 ); ! 568: 552 00014912 dd 00 pushl $0 ! 569: 553 00014914 fe 08 effffffae5 callf $8,_write32h ! 570: 554 0001491B # writes("\ninit op3 = "); ! 571: 555 0001491B .data 1 ! 572: 556 0000081c * L437: ! 573: 557 0000081c * 0A696E6974206F7033203D200 .ascii "\12init op3 = \0" ! 574: 0 ! 575: 558 00000829 * .text ! 576: 559 0001491B dd 8f0000081c pushl $L437 ! 577: 560 00014921 fe 08 effffffad8 callf $8,_writes ! 578: 561 00014928 # write32h( sgl_value_1 ); ! 579: 562 00014928 dd effffffad2 pushl _sgl_value_1 ! 580: 563 0001492E fe 08 effffffacb callf $8,_write32h ! 581: 564 00014935 # writec(' '); ! 582: 565 00014935 dd 20 pushl $32 ! 583: 566 00014937 fe 08 effffffac2 callf $8,_writec ! 584: 567 0001493E # write32h( sgl_value_2 ); ! 585: 568 0001493E dd effffffabc pushl _sgl_value_2 ! 586: 569 00014944 fe 08 effffffab5 callf $8,_write32h ! 587: 570 0001494B # writes(", final op3 = "); ! 588: 571 0001494B .data 1 ! 589: 572 00000829 * L438: ! 590: 573 00000829 * 2C202020202066696E616C206 .ascii ", final op3 = \0" ! 591: F7033203D2000 ! 592: 574 0000083c * .text ! 593: 575 0001494B dd 8f00000829 pushl $L438 ! 594: 576 00014951 fe 08 effffffaa8 callf $8,_writes ! 595: 577 00014958 # write32h( dbl_value_2.m ); ! 596: 578 00014958 dd effffffaa2 pushl _dbl_value_2 ! 597: 579 0001495E fe 08 effffffa9b callf $8,_write32h ! 598: 580 00014965 # writec(' '); ! 599: 581 00014965 dd 20 pushl $32 ! 600: 582 00014967 fe 08 effffffa92 callf $8,_writec ! 601: 583 0001496E # write32h( dbl_value_2.l ); ! 602: 584 0001496E dd effffffa90 pushl _dbl_value_2+4 ! 603: 585 00014974 fe 08 effffffa85 callf $8,_write32h ! 604: 586 0001497B # writec('\n'); ! 605: 587 0001497B dd 0a pushl $10 ! 606: 588 0001497D fe 08 effffffa7c callf $8,_writec ! 607: 589 00014984 # } ! 608: 590 00014984 # if ( halt_flg ) /* halt on error? */ ! 609: 591 00014984 L431: ! 610: 592 00014984 5d effffffa76 tstl _halt_flg ! 611: 593 0001498A 31 09 jeql L439 ! 612: 594 0001498C # pipe16_halt( 3 ); /* halt with a code of 2 */ ! 613: 595 0001498C dd 03 pushl $3 ! 614: 596 0001498E fe 08 ef000000b7 callf $8,_pipe16_halt ! 615: 597 00014995 # if ( loop_on_err ) ! 616: 598 00014995 L439: ! 617: 599 00014995 5d effffffa65 tstl _loop_on_err ! 618: 600 0001499B 31 0d jeql L440 ! 619: 601 0001499D # { ! 620: 602 0001499D # force_loop = TRUE; /* set the force loop flag */ ! 621: 603 0001499D 0d 01 effffffa5c movl $1,_force_loop ! 622: 604 000149A4 # asm("jmp _pipe16_lp1"); /* and loop */ ! 623: 605 000149A4 71 effffffb02 jmp _pipe16_lp1 ! 624: 606 000149AA # }; ! 625: 607 000149AA L440: ! 626: 608 000149AA # } ! 627: 609 000149AA 40 ret#2 ! 628: 610 000149AB .set L427,0x0 ! 629: 611 000149AB L429: ! 630: 612 000149AB 13 fe7d jbr L430 ! 631: 613 000149AE .data ! 632: 614 00000714 * .text ! 633: 615 000149AE .align 1 ! 634: 616 000149AE .globl _print_pipe16_er ! 635: 617 000149AE _print_pipe16_er: ! 636: 618 000149AE 0000 .word L441 ! 637: 619 000149B0 # ! 638: 620 000149B0 # ! 639: 621 000149B0 # ! 640: 622 000149B0 # ! 641: 623 000149B0 # ! 642: 624 000149B0 # ! 643: 625 000149B0 # /**************************************************************************** ! 644: 626 000149B0 # * Report an error message of the form: ! 645: 627 000149B0 # * ! 646: 628 000149B0 # * Cycle: xx. EVT test xx. subtest xx. <your message here>. index = xx ! 647: 629 000149B0 # * inst = LDD op1, ADDD op2, STD op3 (overflow fault on the ADDD) ! 648: 630 000149B0 # ****************************************************************************/ ! 649: 631 000149B0 # print_pipe16_er( msg ) ! 650: 632 000149B0 # char *msg; /* error message to print */ ! 651: 633 000149B0 # { ! 652: 634 000149B0 13 0096 jbr L443 ! 653: 635 000149B3 L444: ! 654: 636 000149B3 # if( errcnt == 1 ) /* 1st error? */ ! 655: 637 000149B3 1d effffffa47 01 cmpl _errcnt,$1 ! 656: 638 000149BA 21 0d jneq L445 ! 657: 639 000149BC # writes(" \n"); /* start a new print line */ ! 658: 640 000149BC .data 1 ! 659: 641 0000083c * L446: ! 660: 642 0000083c * 200A00 .ascii " \12\0" ! 661: 643 0000083f * .text ! 662: 644 000149BC dd 8f0000083c pushl $L446 ! 663: 645 000149C2 fe 08 effffffa37 callf $8,_writes ! 664: 646 000149C9 # writes("Cycle: "); ! 665: 647 000149C9 L445: ! 666: 648 000149C9 .data 1 ! 667: 649 0000083f * L447: ! 668: 650 0000083f * 4379636C653A2000 .ascii "Cycle: \0" ! 669: 651 00000847 * .text ! 670: 652 000149C9 dd 8f0000083f pushl $L447 ! 671: 653 000149CF fe 08 effffffa2a callf $8,_writes ! 672: 654 000149D6 # writed( cycle ); ! 673: 655 000149D6 dd effffffa24 pushl _cycle ! 674: 656 000149DC fe 08 effffffa1d callf $8,_writed ! 675: 657 000149E3 # writes(" EVT test "); ! 676: 658 000149E3 .data 1 ! 677: 659 00000847 * L449: ! 678: 660 00000847 * 202045565420746573742000 .ascii " EVT test \0" ! 679: 661 00000853 * .text ! 680: 662 000149E3 dd 8f00000847 pushl $L449 ! 681: 663 000149E9 fe 08 effffffa10 callf $8,_writes ! 682: 664 000149F0 # writed( test_no ); ! 683: 665 000149F0 dd effffffa0a pushl _test_no ! 684: 666 000149F6 fe 08 effffffa03 callf $8,_writed ! 685: 667 000149FD # writes(". subtest "); ! 686: 668 000149FD .data 1 ! 687: 669 00000853 * L450: ! 688: 670 00000853 * 2E20737562746573742000 .ascii ". subtest \0" ! 689: 671 0000085e * .text ! 690: 672 000149FD dd 8f00000853 pushl $L450 ! 691: 673 00014A03 fe 08 effffff9f6 callf $8,_writes ! 692: 674 00014A0A # writed( subtest ); ! 693: 675 00014A0A dd effffff9f0 pushl _subtest ! 694: 676 00014A10 fe 08 effffff9e9 callf $8,_writed ! 695: 677 00014A17 # writes( msg ); /* print the message */ ! 696: 678 00014A17 dd ad04 pushl 4(fp) ! 697: 679 00014A1A fe 08 effffff9df callf $8,_writes ! 698: 680 00014A21 # writes(". index = "); ! 699: 681 00014A21 .data 1 ! 700: 682 0000085e * L451: ! 701: 683 0000085e * 2E20696E646578203D2000 .ascii ". index = \0" ! 702: 684 00000869 * .text ! 703: 685 00014A21 dd 8f0000085e pushl $L451 ! 704: 686 00014A27 fe 08 effffff9d2 callf $8,_writes ! 705: 687 00014A2E # writed( index ); ! 706: 688 00014A2E dd effffff9cc pushl _index ! 707: 689 00014A34 fe 08 effffff9c5 callf $8,_writed ! 708: 690 00014A3B # writes( ! 709: 691 00014A3B # "\ninst = LDD op1, ADDD op2, STD op3 (overflow fault on the ADDD)\n"); ! 710: 692 00014A3B .data 1 ! 711: 693 00000869 * L452: ! 712: 694 00000869 * 0A696E7374203D204C4444206 .ascii "\12inst = LDD op1, ADDD op2, STD op3 (overflow fault on the ADD" ! 713: F70312C2041444444206F7032 ! 714: 2C20535444206F70332020202 ! 715: 0286F766572666C6F77206661 ! 716: 756C74206F6E2074686520414 ! 717: 444 ! 718: 695 000008a9 * 44290A00 .ascii "D)\12\0" ! 719: 696 000008ad * .text ! 720: 697 00014A3B dd 8f00000869 pushl $L452 ! 721: 698 00014A41 fe 08 effffff9b8 callf $8,_writes ! 722: 699 00014A48 # } ! 723: 700 00014A48 40 ret#2 ! 724: 701 00014A49 .set L441,0x0 ! 725: 702 00014A49 L443: ! 726: 703 00014A49 13 ff67 jbr L444 ! 727: 704 00014A4C .data ! 728: 705 00000714 * .text ! 729: 706 00014A4C .align 1 ! 730: 707 00014A4C .globl _pipe16_halt ! 731: 708 00014A4C _pipe16_halt: ! 732: 709 00014A4C 0000 .word L453 ! 733: 710 00014A4E # ! 734: 711 00014A4E # ! 735: 712 00014A4E # ! 736: 713 00014A4E # /**************************************************************************** ! 737: 714 00014A4E # * halt on error routine ! 738: 715 00014A4E # ****************************************************************************/ ! 739: 716 00014A4E # pipe16_halt( code ) ! 740: 717 00014A4E # int code; /* error code to halt with */ ! 741: 718 00014A4E # { ! 742: 719 00014A4E 13 00bf jbr L455 ! 743: 720 00014A51 L456: ! 744: 721 00014A51 # err_code = code; ! 745: 722 00014A51 0d ad04 effffff9a7 movl 4(fp),_err_code ! 746: 723 00014A59 # sgl_value_1 = dbl_ld_acc.m; ! 747: 724 00014A59 0d effffff9a1 effffff99c movl _dbl_ld_acc,_sgl_value_1 ! 748: 725 00014A64 # sgl_value_2 = dbl_ld_acc.l; ! 749: 726 00014A64 0d effffff99a effffff991 movl _dbl_ld_acc+4,_sgl_value_2 ! 750: 727 00014A6F # sgl_value_3 = dbl_value_1.m; ! 751: 728 00014A6F 0d effffff98b effffff986 movl _dbl_value_1,_sgl_value_3 ! 752: 729 00014A7A # sgl_value_4 = dbl_value_1.l; ! 753: 730 00014A7A 0d effffff984 effffff97b movl _dbl_value_1+4,_sgl_value_4 ! 754: 731 00014A85 # sgl_value_5 = post_evt_acc.m; ! 755: 732 00014A85 0d effffff975 effffff970 movl _post_evt_acc,_sgl_value_5 ! 756: 733 00014A90 # sgl_value_6 = post_evt_acc.l; ! 757: 734 00014A90 0d effffff96e effffff965 movl _post_evt_acc+4,_sgl_value_6 ! 758: 735 00014A9B # sgl_value_7 = dbl_value_2.m; ! 759: 736 00014A9B 0d effffff95f effffff95a movl _dbl_value_2,_sgl_value_7 ! 760: 737 00014AA6 # sgl_value_8 = dbl_value_2.l; ! 761: 738 00014AA6 0d effffff958 effffff94f movl _dbl_value_2+4,_sgl_value_8 ! 762: 739 00014AB1 # asm("movl _test_no,r0"); /* r0 = test number */ ! 763: 740 00014AB1 0d effffff949 50 movl _test_no,r0 ! 764: 741 00014AB8 # asm("movl _subtest,r1"); /* r1 = subtest number */ ! 765: 742 00014AB8 0d effffff942 51 movl _subtest,r1 ! 766: 743 00014ABF # asm("movl _err_code,r2"); /* r2 = error code */ ! 767: 744 00014ABF 0d effffff93b 52 movl _err_code,r2 ! 768: 745 00014AC6 # asm("movl _cycle,r3"); /* r3 = cycle count */ ! 769: 746 00014AC6 0d effffff934 53 movl _cycle,r3 ! 770: 747 00014ACD # asm("movl _sgl_value_1,r4"); /* r4 = MSW of operand 1 */ ! 771: 748 00014ACD 0d effffff92d 54 movl _sgl_value_1,r4 ! 772: 749 00014AD4 # asm("movl _sgl_value_2,r5"); /* r5 = LSW of operand 1 */ ! 773: 750 00014AD4 0d effffff926 55 movl _sgl_value_2,r5 ! 774: 751 00014ADB # asm("movl _sgl_value_3,r6"); /* r6 = MSW of operand 2 */ ! 775: 752 00014ADB 0d effffff91f 56 movl _sgl_value_3,r6 ! 776: 753 00014AE2 # asm("movl _sgl_value_4,r7"); /* r7 = LSW of operand 2 */ ! 777: 754 00014AE2 0d effffff918 57 movl _sgl_value_4,r7 ! 778: 755 00014AE9 # asm("movl _sgl_value_5,r8"); /* r8 = MSW of final Acc. */ ! 779: 756 00014AE9 0d effffff911 58 movl _sgl_value_5,r8 ! 780: 757 00014AF0 # asm("movl _sgl_value_6,r9"); /* r9 = LSW of final Acc. */ ! 781: 758 00014AF0 0d effffff90a 59 movl _sgl_value_6,r9 ! 782: 759 00014AF7 # asm("clrl r10"); /* r10 = 0 (expected Acc.) */ ! 783: 760 00014AF7 4d 5a clrl r10 ! 784: 761 00014AF9 # asm("movl _sgl_value_7,r11"); /* r11 = MSW of store data */ ! 785: 762 00014AF9 0d effffff901 5b movl _sgl_value_7,r11 ! 786: 763 00014B00 # asm("movl _sgl_value_8,r12"); /* r12 = LSW of store data */ ! 787: 764 00014B00 0d effffff8fa 5c movl _sgl_value_8,r12 ! 788: 765 00014B07 # asm("movl _index,r13"); /* r13 = data index */ ! 789: 766 00014B07 0d effffff8f3 5d movl _index,r13 ! 790: 767 00014B0E # asm("halt"); /* HALT ... */ ! 791: 768 00014B0E 00 halt ! 792: 769 00014B0F # } ! 793: 770 00014B0F 40 ret#2 ! 794: 771 00014B10 .set L453,0x0 ! 795: 772 00014B10 L455: ! 796: 773 00014B10 13 ff3e jbr L456 ! 797: 774 00014B13 .data ! 798: 774 00028F13 .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.