![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe20.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 / macro4|
Return to pipe20.lst CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / macro4 |
1.1 ! root 1: 1 00000000 LL0: ! 2: 2 00000000 .data ! 3: 3 000006bc * .text ! 4: 4 00000000 .align 1 ! 5: 5 00000000 .globl _pipe_20 ! 6: 6 00000000 _pipe_20: ! 7: 7 00033264 0000 .word L215 ! 8: 8 00033266 # #include "fpp_defs.h" ! 9: 9 00033266 # ! 10: 10 00033266 # ! 11: 11 00033266 # /***************************************************************************** ! 12: 12 00033266 # * ! 13: 13 00033266 # * DBL PIPELINE TEST #20 MONITOR ! 14: 14 00033266 # * ! 15: 15 00033266 # * This test will do a series of 2, 3, 4, 5, and 6 NEGDs. ! 16: 16 00033266 # * The data used will be the LDD data patterns. ! 17: 17 00033266 # * ! 18: 18 00033266 # *****************************************************************************/ ! 19: 19 00033266 # pipe_20() ! 20: 20 00033266 # { ! 21: 21 00033266 11 48 jbr L217 ! 22: 22 00033268 L218: ! 23: 23 00033268 # asm(".globl _pipeline_20_t"); ! 24: 24 00033268 .globl _pipeline_20_t ! 25: 25 00033268 # asm("_pipeline_20_t:"); /* entry address */ ! 26: 26 00033268 _pipeline_20_t: ! 27: 27 00033268 # if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */ ! 28: 28 00033268 1d effffffff6 01 cmpl _cycle,$1 ! 29: 29 0003326F 21 15 jneq L219 ! 30: 30 00033271 5d efffffffed tstl _prt_hdrs ! 31: 31 00033277 31 0d jeql L219 ! 32: 32 00033279 # writes(" PIPE_20"); ! 33: 33 00033279 .data 1 ! 34: 34 000006bc * L221: ! 35: 35 000006bc * 20504950455F323000 .ascii " PIPE_20\0" ! 36: 36 000006c5 * .text ! 37: 37 00033279 dd 8f000006bc pushl $L221 ! 38: 38 0003327F fe 08 efffffffde callf $8,_writes ! 39: 39 00033286 # pipe20_1(); /* 2 NOPs */ ! 40: 40 00033286 L219: ! 41: 41 00033286 fe 04 ef00000025 callf $4,_pipe20_1 ! 42: 42 0003328D # pipe20_2(); /* 3 NOPs */ ! 43: 43 0003328D fe 04 ef000000fe callf $4,_pipe20_2 ! 44: 44 00033294 # pipe20_3(); /* 4 NOPs */ ! 45: 45 00033294 fe 04 ef000001eb callf $4,_pipe20_3 ! 46: 46 0003329B # pipe20_4(); /* 5 NOPs */ ! 47: 47 0003329B fe 04 ef000002c6 callf $4,_pipe20_4 ! 48: 48 000332A2 # pipe20_5(); /* 6 NOPs */ ! 49: 49 000332A2 fe 04 ef000003b5 callf $4,_pipe20_5 ! 50: 50 000332A9 # asm("jmp *return"); /* return to the test monitor */ ! 51: 51 000332A9 71 ffffffffb5 jmp *return ! 52: 52 000332AF # } ! 53: 53 000332AF 40 ret#2 ! 54: 54 000332B0 .set L215,0x0 ! 55: 55 000332B0 L217: ! 56: 56 000332B0 11 b6 jbr L218 ! 57: 57 000332B2 .data ! 58: 58 000006bc * .text ! 59: 59 000332B2 .align 1 ! 60: 60 000332B2 .globl _pipe20_1 ! 61: 61 000332B2 _pipe20_1: ! 62: 62 000332B2 0000 .word L227 ! 63: 63 000332B4 # ! 64: 64 000332B4 # ! 65: 65 000332B4 # ! 66: 66 000332B4 # ! 67: 67 000332B4 # ! 68: 68 000332B4 # /************************************************************************ ! 69: 69 000332B4 # * ! 70: 70 000332B4 # * SUBTEST 1 : 2 NEGDs ! 71: 71 000332B4 # * ! 72: 72 000332B4 # ************************************************************************/ ! 73: 73 000332B4 # pipe20_1() ! 74: 74 000332B4 # { ! 75: 75 000332B4 13 00d8 jbr L229 ! 76: 76 000332B7 L230: ! 77: 77 000332B7 # subtest = 1; ! 78: 78 000332B7 0d 01 efffffffa6 movl $1,_subtest ! 79: 79 000332BE # force_loop = FALSE; ! 80: 80 000332BE 4d efffffffa0 clrl _force_loop ! 81: 81 000332C4 # for( index = 0; index < max_ldd_1_index; index++ ) ! 82: 82 000332C4 4d efffffff9a clrl _index ! 83: 83 000332CA L233: ! 84: 84 000332CA 1d efffffff94 efffffff8f cmpl _index,_max_ldd_1_index ! 85: 85 000332D5 91 03 13 00b4 jgeq L232 ! 86: 86 000332DA # { ! 87: 87 000332DA # dbl_value_1 = ldd_1_data[index].ld; /* get operand 1 */ ! 88: 88 000332DA 48 04 efffffff83 50 shll $4,_index,r0 ! 89: 89 000332E2 0c 8f00000000 50 addl2 $_ldd_1_data,r0 ! 90: 90 000332E9 0d a004 efffffff77 movl 4(r0),_dbl_value_1+4 ! 91: 91 000332F1 0d 60 efffffff6c movl (r0),_dbl_value_1 ! 92: 92 000332F8 # dbl_expected = ldd_1_data[index].exp; /* get expected results */ ! 93: 93 000332F8 48 04 efffffff65 50 shll $4,_index,r0 ! 94: 94 00033300 0c 8f00000008 50 addl2 $_ldd_1_data+8,r0 ! 95: 95 00033307 0d a004 efffffff59 movl 4(r0),_dbl_expected+4 ! 96: 96 0003330F 0d 60 efffffff4e movl (r0),_dbl_expected ! 97: 97 00033316 # /* ! 98: 98 00033316 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 99: 99 00033316 # * The force loop flag is set after the first error. ! 100: 100 00033316 # */ ! 101: 101 00033316 # asm("_pipe20_1_lp1:"); ! 102: 102 00033316 _pipe20_1_lp1: ! 103: 103 00033316 # asm("ldd _dbl_value_1"); /* load the operand */ ! 104: 104 00033316 07 efffffff48 ldd _dbl_value_1 ! 105: 105 0003331C # asm("negd"); /* negate it ( twice ) */ ! 106: 106 0003331C b7 negd ! 107: 107 0003331D # asm("negd"); ! 108: 108 0003331D b7 negd ! 109: 109 0003331E # asm("std _dbl_st_acc"); /* store the result */ ! 110: 110 0003331E 27 efffffff40 std _dbl_st_acc ! 111: 111 00033324 # if( force_loop ) ! 112: 112 00033324 5d efffffff3a tstl _force_loop ! 113: 113 0003332A 31 02 jeql L234 ! 114: 114 0003332C # asm("brb _pipe20_1_lp1"); /* loop on an error */ ! 115: 115 0003332C 11 e8 brb _pipe20_1_lp1 ! 116: 116 0003332E # /* ! 117: 117 0003332E # * verify the results ! 118: 118 0003332E # */ ! 119: 119 0003332E # if( (dbl_st_acc.m != dbl_expected.m) || /* COMPARE the stored */ ! 120: 120 0003332E L234: ! 121: 121 0003332E # (dbl_st_acc.l != dbl_expected.l) ) { /* to the expected */ ! 122: 122 0003332E 1d efffffff30 efffffff2b cmpl _dbl_st_acc,_dbl_expected ! 123: 123 00033339 21 0d jneq L9999 ! 124: 124 0003333B 1d efffffff27 efffffff22 cmpl _dbl_st_acc+4,_dbl_expected+4 ! 125: 125 00033346 31 3d jeql L235 ! 126: 126 00033348 L9999: ! 127: 127 00033348 # errcnt++; /* bump the error count */ ! 128: 128 00033348 6d efffffff16 incl _errcnt ! 129: 129 0003334E # if( prt_error ) ! 130: 130 0003334E 5d efffffff10 tstl _prt_error ! 131: 131 00033354 31 09 jeql L236 ! 132: 132 00033356 # pipe20_print( 2 ); /* print error msg -2 NOPs */ ! 133: 133 00033356 dd 02 pushl $2 ! 134: 134 00033358 fe 08 ef000003e3 callf $8,_pipe20_print ! 135: 135 0003335F # if( halt_flg ) /* halt on error? */ ! 136: 136 0003335F L236: ! 137: 137 0003335F 5d effffffeff tstl _halt_flg ! 138: 138 00033365 31 09 jeql L238 ! 139: 139 00033367 # pipe20_halt( 2 ); /* error halt -2 NOPs */ ! 140: 140 00033367 dd 02 pushl $2 ! 141: 141 00033369 fe 08 ef0000050a callf $8,_pipe20_halt ! 142: 142 00033370 # if( loop_on_err ) { ! 143: 143 00033370 L238: ! 144: 144 00033370 5d effffffeee tstl _loop_on_err ! 145: 145 00033376 31 0d jeql L240 ! 146: 146 00033378 # force_loop = TRUE; /* set the force loop flag */ ! 147: 147 00033378 0d 01 effffffee5 movl $1,_force_loop ! 148: 148 0003337F # asm("jmp _pipe20_1_lp1"); /* and loop */ ! 149: 149 0003337F 71 efffffff91 jmp _pipe20_1_lp1 ! 150: 150 00033385 # } ! 151: 151 00033385 # } ! 152: 152 00033385 L240: ! 153: 153 00033385 # } /* end of FOR loop */ ! 154: 154 00033385 L235: ! 155: 155 00033385 L231: ! 156: 156 00033385 6d effffffed9 incl _index ! 157: 157 0003338B 13 ff3c jbr L233 ! 158: 158 0003338E L232: ! 159: 159 0003338E # } /* end of subtest 1 */ ! 160: 160 0003338E 40 ret#2 ! 161: 161 0003338F .set L227,0x0 ! 162: 162 0003338F L229: ! 163: 163 0003338F 13 ff25 jbr L230 ! 164: 164 00033392 .data ! 165: 165 000006bc * .text ! 166: 166 00033392 .align 1 ! 167: 167 00033392 .globl _pipe20_2 ! 168: 168 00033392 _pipe20_2: ! 169: 169 00033392 0000 .word L241 ! 170: 170 00033394 # ! 171: 171 00033394 # ! 172: 172 00033394 # ! 173: 173 00033394 # ! 174: 174 00033394 # ! 175: 175 00033394 # /************************************************************************ ! 176: 176 00033394 # * ! 177: 177 00033394 # * SUBTEST 2 : 3 NEGDs ! 178: 178 00033394 # * ! 179: 179 00033394 # ************************************************************************/ ! 180: 180 00033394 # pipe20_2() ! 181: 181 00033394 # { ! 182: 182 00033394 13 00ec jbr L243 ! 183: 183 00033397 L244: ! 184: 184 00033397 # subtest = 2; ! 185: 185 00033397 0d 02 effffffec6 movl $2,_subtest ! 186: 186 0003339E # force_loop = FALSE; ! 187: 187 0003339E 4d effffffec0 clrl _force_loop ! 188: 188 000333A4 # for( index = 0; index < max_ldd_1_index; index++ ) ! 189: 189 000333A4 4d effffffeba clrl _index ! 190: 190 000333AA L247: ! 191: 191 000333AA 1d effffffeb4 effffffeaf cmpl _index,_max_ldd_1_index ! 192: 192 000333B5 91 03 13 00c8 jgeq L246 ! 193: 193 000333BA # { ! 194: 194 000333BA # dbl_value_1 = ldd_1_data[index].ld; /* get operand 1 */ ! 195: 195 000333BA 48 04 effffffea3 50 shll $4,_index,r0 ! 196: 196 000333C2 0c 8f00000000 50 addl2 $_ldd_1_data,r0 ! 197: 197 000333C9 0d a004 effffffe97 movl 4(r0),_dbl_value_1+4 ! 198: 198 000333D1 0d 60 effffffe8c movl (r0),_dbl_value_1 ! 199: 199 000333D8 # dbl_expected = ldd_1_data[index].exp; /* get expected results */ ! 200: 200 000333D8 48 04 effffffe85 50 shll $4,_index,r0 ! 201: 201 000333E0 0c 8f00000008 50 addl2 $_ldd_1_data+8,r0 ! 202: 202 000333E7 0d a004 effffffe79 movl 4(r0),_dbl_expected+4 ! 203: 203 000333EF 0d 60 effffffe6e movl (r0),_dbl_expected ! 204: 204 000333F6 # if( dbl_expected.m ) ! 205: 205 000333F6 5d effffffe68 tstl _dbl_expected ! 206: 206 000333FC 31 0b jeql L248 ! 207: 207 000333FE # dbl_expected.m ^= 0x80000000; /* negate exptd results */ ! 208: 208 000333FE cc 8f80000000 effffffe5b xorl2 $-2147483648,_dbl_expected ! 209: 209 00033409 # /* ! 210: 210 00033409 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 211: 211 00033409 # * The force loop flag is set after the first error. ! 212: 212 00033409 # */ ! 213: 213 00033409 # asm("_pipe20_2_lp1:"); ! 214: 214 00033409 L248: ! 215: 215 00033409 _pipe20_2_lp1: ! 216: 216 00033409 # asm("ldd _dbl_value_1"); /* load the operand */ ! 217: 217 00033409 07 effffffe55 ldd _dbl_value_1 ! 218: 218 0003340F # asm("negd"); /* negate it ( 3 times ) */ ! 219: 219 0003340F b7 negd ! 220: 220 00033410 # asm("negd"); ! 221: 221 00033410 b7 negd ! 222: 222 00033411 # asm("negd"); ! 223: 223 00033411 b7 negd ! 224: 224 00033412 # asm("std _dbl_st_acc"); /* store the result */ ! 225: 225 00033412 27 effffffe4c std _dbl_st_acc ! 226: 226 00033418 # if( force_loop ) ! 227: 227 00033418 5d effffffe46 tstl _force_loop ! 228: 228 0003341E 31 02 jeql L249 ! 229: 229 00033420 # asm("brb _pipe20_2_lp1"); /* loop on an error */ ! 230: 230 00033420 11 e7 brb _pipe20_2_lp1 ! 231: 231 00033422 # /* ! 232: 232 00033422 # * verify the results ! 233: 233 00033422 # */ ! 234: 234 00033422 # if( (dbl_st_acc.m != dbl_expected.m) || /* COMPARE the stored */ ! 235: 235 00033422 L249: ! 236: 236 00033422 # (dbl_st_acc.l != dbl_expected.l) ) { /* to the expected */ ! 237: 237 00033422 1d effffffe3c effffffe37 cmpl _dbl_st_acc,_dbl_expected ! 238: 238 0003342D 21 0d jneq L9998 ! 239: 239 0003342F 1d effffffe33 effffffe2e cmpl _dbl_st_acc+4,_dbl_expected+4 ! 240: 240 0003343A 31 3d jeql L250 ! 241: 241 0003343C L9998: ! 242: 242 0003343C # errcnt++; /* bump the error count */ ! 243: 243 0003343C 6d effffffe22 incl _errcnt ! 244: 244 00033442 # if( prt_error ) ! 245: 245 00033442 5d effffffe1c tstl _prt_error ! 246: 246 00033448 31 09 jeql L251 ! 247: 247 0003344A # pipe20_print( 3 ); /* print error msg -3 NOPs */ ! 248: 248 0003344A dd 03 pushl $3 ! 249: 249 0003344C fe 08 ef000002ef callf $8,_pipe20_print ! 250: 250 00033453 # if( halt_flg ) /* halt on error? */ ! 251: 251 00033453 L251: ! 252: 252 00033453 5d effffffe0b tstl _halt_flg ! 253: 253 00033459 31 09 jeql L252 ! 254: 254 0003345B # pipe20_halt( 3 ); /* error halt -3 NOPs */ ! 255: 255 0003345B dd 03 pushl $3 ! 256: 256 0003345D fe 08 ef00000416 callf $8,_pipe20_halt ! 257: 257 00033464 # if( loop_on_err ) { ! 258: 258 00033464 L252: ! 259: 259 00033464 5d effffffdfa tstl _loop_on_err ! 260: 260 0003346A 31 0d jeql L253 ! 261: 261 0003346C # force_loop = TRUE; /* set the force loop flag */ ! 262: 262 0003346C 0d 01 effffffdf1 movl $1,_force_loop ! 263: 263 00033473 # asm("jmp _pipe20_2_lp1"); /* and loop */ ! 264: 264 00033473 71 efffffff90 jmp _pipe20_2_lp1 ! 265: 265 00033479 # } ! 266: 266 00033479 # } ! 267: 267 00033479 L253: ! 268: 268 00033479 # } /* end of FOR loop */ ! 269: 269 00033479 L250: ! 270: 270 00033479 L245: ! 271: 271 00033479 6d effffffde5 incl _index ! 272: 272 0003347F 13 ff28 jbr L247 ! 273: 273 00033482 L246: ! 274: 274 00033482 # } /* end of subtest 2 */ ! 275: 275 00033482 40 ret#2 ! 276: 276 00033483 .set L241,0x0 ! 277: 277 00033483 L243: ! 278: 278 00033483 13 ff11 jbr L244 ! 279: 279 00033486 .data ! 280: 280 000006bc * .text ! 281: 281 00033486 .align 1 ! 282: 282 00033486 .globl _pipe20_3 ! 283: 283 00033486 _pipe20_3: ! 284: 284 00033486 0000 .word L254 ! 285: 285 00033488 # ! 286: 286 00033488 # ! 287: 287 00033488 # ! 288: 288 00033488 # ! 289: 289 00033488 # ! 290: 290 00033488 # /************************************************************************ ! 291: 291 00033488 # * ! 292: 292 00033488 # * SUBTEST 3 : 4 NEGDs ! 293: 293 00033488 # * ! 294: 294 00033488 # ************************************************************************/ ! 295: 295 00033488 # pipe20_3() ! 296: 296 00033488 # { ! 297: 297 00033488 13 00da jbr L256 ! 298: 298 0003348B L257: ! 299: 299 0003348B # subtest = 3; ! 300: 300 0003348B 0d 03 effffffdd2 movl $3,_subtest ! 301: 301 00033492 # force_loop = FALSE; ! 302: 302 00033492 4d effffffdcc clrl _force_loop ! 303: 303 00033498 # for( index = 0; index < max_ldd_1_index; index++ ) ! 304: 304 00033498 4d effffffdc6 clrl _index ! 305: 305 0003349E L260: ! 306: 306 0003349E 1d effffffdc0 effffffdbb cmpl _index,_max_ldd_1_index ! 307: 307 000334A9 91 03 13 00b6 jgeq L259 ! 308: 308 000334AE # { ! 309: 309 000334AE # dbl_value_1 = ldd_1_data[index].ld; /* get operand 1 */ ! 310: 310 000334AE 48 04 effffffdaf 50 shll $4,_index,r0 ! 311: 311 000334B6 0c 8f00000000 50 addl2 $_ldd_1_data,r0 ! 312: 312 000334BD 0d a004 effffffda3 movl 4(r0),_dbl_value_1+4 ! 313: 313 000334C5 0d 60 effffffd98 movl (r0),_dbl_value_1 ! 314: 314 000334CC # dbl_expected = ldd_1_data[index].exp; /* get expected results */ ! 315: 315 000334CC 48 04 effffffd91 50 shll $4,_index,r0 ! 316: 316 000334D4 0c 8f00000008 50 addl2 $_ldd_1_data+8,r0 ! 317: 317 000334DB 0d a004 effffffd85 movl 4(r0),_dbl_expected+4 ! 318: 318 000334E3 0d 60 effffffd7a movl (r0),_dbl_expected ! 319: 319 000334EA # /* ! 320: 320 000334EA # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 321: 321 000334EA # * The force loop flag is set after the first error. ! 322: 322 000334EA # */ ! 323: 323 000334EA # asm("_pipe20_3_lp1:"); ! 324: 324 000334EA _pipe20_3_lp1: ! 325: 325 000334EA # asm("ldd _dbl_value_1"); /* load the operand */ ! 326: 326 000334EA 07 effffffd74 ldd _dbl_value_1 ! 327: 327 000334F0 # asm("negd"); /* negate it ( 4 times ) */ ! 328: 328 000334F0 b7 negd ! 329: 329 000334F1 # asm("negd"); ! 330: 330 000334F1 b7 negd ! 331: 331 000334F2 # asm("negd"); ! 332: 332 000334F2 b7 negd ! 333: 333 000334F3 # asm("negd"); ! 334: 334 000334F3 b7 negd ! 335: 335 000334F4 # asm("std _dbl_st_acc"); /* store the result */ ! 336: 336 000334F4 27 effffffd6a std _dbl_st_acc ! 337: 337 000334FA # if( force_loop ) ! 338: 338 000334FA 5d effffffd64 tstl _force_loop ! 339: 339 00033500 31 02 jeql L261 ! 340: 340 00033502 # asm("brb _pipe20_3_lp1"); /* loop on an error */ ! 341: 341 00033502 11 e6 brb _pipe20_3_lp1 ! 342: 342 00033504 # /* ! 343: 343 00033504 # * verify the results ! 344: 344 00033504 # */ ! 345: 345 00033504 # if( (dbl_st_acc.m != dbl_expected.m) || /* COMPARE the stored */ ! 346: 346 00033504 L261: ! 347: 347 00033504 # (dbl_st_acc.l != dbl_expected.l) ) { /* to the expected */ ! 348: 348 00033504 1d effffffd5a effffffd55 cmpl _dbl_st_acc,_dbl_expected ! 349: 349 0003350F 21 0d jneq L9997 ! 350: 350 00033511 1d effffffd51 effffffd4c cmpl _dbl_st_acc+4,_dbl_expected+4 ! 351: 351 0003351C 31 3d jeql L262 ! 352: 352 0003351E L9997: ! 353: 353 0003351E # errcnt++; /* bump the error count */ ! 354: 354 0003351E 6d effffffd40 incl _errcnt ! 355: 355 00033524 # if( prt_error ) ! 356: 356 00033524 5d effffffd3a tstl _prt_error ! 357: 357 0003352A 31 09 jeql L263 ! 358: 358 0003352C # pipe20_print( 4 ); /* print error msg -4 NOPs */ ! 359: 359 0003352C dd 04 pushl $4 ! 360: 360 0003352E fe 08 ef0000020d callf $8,_pipe20_print ! 361: 361 00033535 # if( halt_flg ) /* halt on error? */ ! 362: 362 00033535 L263: ! 363: 363 00033535 5d effffffd29 tstl _halt_flg ! 364: 364 0003353B 31 09 jeql L264 ! 365: 365 0003353D # pipe20_halt( 4 ); /* error halt -4 NOPs */ ! 366: 366 0003353D dd 04 pushl $4 ! 367: 367 0003353F fe 08 ef00000334 callf $8,_pipe20_halt ! 368: 368 00033546 # if( loop_on_err ) { ! 369: 369 00033546 L264: ! 370: 370 00033546 5d effffffd18 tstl _loop_on_err ! 371: 371 0003354C 31 0d jeql L265 ! 372: 372 0003354E # force_loop = TRUE; /* set the force loop flag */ ! 373: 373 0003354E 0d 01 effffffd0f movl $1,_force_loop ! 374: 374 00033555 # asm("jmp _pipe20_3_lp1"); /* and loop */ ! 375: 375 00033555 71 efffffff8f jmp _pipe20_3_lp1 ! 376: 376 0003355B # } ! 377: 377 0003355B # } ! 378: 378 0003355B L265: ! 379: 379 0003355B # } /* end of FOR loop */ ! 380: 380 0003355B L262: ! 381: 381 0003355B L258: ! 382: 382 0003355B 6d effffffd03 incl _index ! 383: 383 00033561 13 ff3a jbr L260 ! 384: 384 00033564 L259: ! 385: 385 00033564 # } /* end of subtest 3 */ ! 386: 386 00033564 40 ret#2 ! 387: 387 00033565 .set L254,0x0 ! 388: 388 00033565 L256: ! 389: 389 00033565 13 ff23 jbr L257 ! 390: 390 00033568 .data ! 391: 391 000006bc * .text ! 392: 392 00033568 .align 1 ! 393: 393 00033568 .globl _pipe20_4 ! 394: 394 00033568 _pipe20_4: ! 395: 395 00033568 0000 .word L266 ! 396: 396 0003356A # ! 397: 397 0003356A # ! 398: 398 0003356A # ! 399: 399 0003356A # ! 400: 400 0003356A # ! 401: 401 0003356A # ! 402: 402 0003356A # /************************************************************************ ! 403: 403 0003356A # * ! 404: 404 0003356A # * SUBTEST 4 : 5 NEGDs ! 405: 405 0003356A # * ! 406: 406 0003356A # ************************************************************************/ ! 407: 407 0003356A # pipe20_4() ! 408: 408 0003356A # { ! 409: 409 0003356A 13 00ee jbr L268 ! 410: 410 0003356D L269: ! 411: 411 0003356D # subtest = 4; ! 412: 412 0003356D 0d 04 effffffcf0 movl $4,_subtest ! 413: 413 00033574 # force_loop = FALSE; ! 414: 414 00033574 4d effffffcea clrl _force_loop ! 415: 415 0003357A # for( index = 0; index < max_ldd_1_index; index++ ) ! 416: 416 0003357A 4d effffffce4 clrl _index ! 417: 417 00033580 L272: ! 418: 418 00033580 1d effffffcde effffffcd9 cmpl _index,_max_ldd_1_index ! 419: 419 0003358B 91 03 13 00ca jgeq L271 ! 420: 420 00033590 # { ! 421: 421 00033590 # dbl_value_1 = ldd_1_data[index].ld; /* get operand 1 */ ! 422: 422 00033590 48 04 effffffccd 50 shll $4,_index,r0 ! 423: 423 00033598 0c 8f00000000 50 addl2 $_ldd_1_data,r0 ! 424: 424 0003359F 0d a004 effffffcc1 movl 4(r0),_dbl_value_1+4 ! 425: 425 000335A7 0d 60 effffffcb6 movl (r0),_dbl_value_1 ! 426: 426 000335AE # dbl_expected = ldd_1_data[index].exp; /* get expected results */ ! 427: 427 000335AE 48 04 effffffcaf 50 shll $4,_index,r0 ! 428: 428 000335B6 0c 8f00000008 50 addl2 $_ldd_1_data+8,r0 ! 429: 429 000335BD 0d a004 effffffca3 movl 4(r0),_dbl_expected+4 ! 430: 430 000335C5 0d 60 effffffc98 movl (r0),_dbl_expected ! 431: 431 000335CC # if( dbl_expected.m ) ! 432: 432 000335CC 5d effffffc92 tstl _dbl_expected ! 433: 433 000335D2 31 0b jeql L273 ! 434: 434 000335D4 # dbl_expected.m ^= 0x80000000; /* negate exptd results */ ! 435: 435 000335D4 cc 8f80000000 effffffc85 xorl2 $-2147483648,_dbl_expected ! 436: 436 000335DF # /* ! 437: 437 000335DF # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 438: 438 000335DF # * The force loop flag is set after the first error. ! 439: 439 000335DF # */ ! 440: 440 000335DF # asm("_pipe20_4_lp1:"); ! 441: 441 000335DF L273: ! 442: 442 000335DF _pipe20_4_lp1: ! 443: 443 000335DF # asm("ldd _dbl_value_1"); /* load the operand */ ! 444: 444 000335DF 07 effffffc7f ldd _dbl_value_1 ! 445: 445 000335E5 # asm("negd"); /* negate it ( 5 times ) */ ! 446: 446 000335E5 b7 negd ! 447: 447 000335E6 # asm("negd"); ! 448: 448 000335E6 b7 negd ! 449: 449 000335E7 # asm("negd"); ! 450: 450 000335E7 b7 negd ! 451: 451 000335E8 # asm("negd"); ! 452: 452 000335E8 b7 negd ! 453: 453 000335E9 # asm("negd"); ! 454: 454 000335E9 b7 negd ! 455: 455 000335EA # asm("std _dbl_st_acc"); /* store the result */ ! 456: 456 000335EA 27 effffffc74 std _dbl_st_acc ! 457: 457 000335F0 # if( force_loop ) ! 458: 458 000335F0 5d effffffc6e tstl _force_loop ! 459: 459 000335F6 31 02 jeql L274 ! 460: 460 000335F8 # asm("brb _pipe20_4_lp1"); /* loop on an error */ ! 461: 461 000335F8 11 e5 brb _pipe20_4_lp1 ! 462: 462 000335FA # /* ! 463: 463 000335FA # * verify the results ! 464: 464 000335FA # */ ! 465: 465 000335FA # if( (dbl_st_acc.m != dbl_expected.m) || /* COMPARE the stored */ ! 466: 466 000335FA L274: ! 467: 467 000335FA # (dbl_st_acc.l != dbl_expected.l) ) { /* to the expected */ ! 468: 468 000335FA 1d effffffc64 effffffc5f cmpl _dbl_st_acc,_dbl_expected ! 469: 469 00033605 21 0d jneq L9996 ! 470: 470 00033607 1d effffffc5b effffffc56 cmpl _dbl_st_acc+4,_dbl_expected+4 ! 471: 471 00033612 31 3d jeql L275 ! 472: 472 00033614 L9996: ! 473: 473 00033614 # errcnt++; /* bump the error count */ ! 474: 474 00033614 6d effffffc4a incl _errcnt ! 475: 475 0003361A # if( prt_error ) ! 476: 476 0003361A 5d effffffc44 tstl _prt_error ! 477: 477 00033620 31 09 jeql L276 ! 478: 478 00033622 # pipe20_print( 5 ); /* print error msg -5 NOPs */ ! 479: 479 00033622 dd 05 pushl $5 ! 480: 480 00033624 fe 08 ef00000117 callf $8,_pipe20_print ! 481: 481 0003362B # if( halt_flg ) /* halt on error? */ ! 482: 482 0003362B L276: ! 483: 483 0003362B 5d effffffc33 tstl _halt_flg ! 484: 484 00033631 31 09 jeql L277 ! 485: 485 00033633 # pipe20_halt( 5 ); /* error halt -5 NOPs */ ! 486: 486 00033633 dd 05 pushl $5 ! 487: 487 00033635 fe 08 ef0000023e callf $8,_pipe20_halt ! 488: 488 0003363C # if( loop_on_err ) { ! 489: 489 0003363C L277: ! 490: 490 0003363C 5d effffffc22 tstl _loop_on_err ! 491: 491 00033642 31 0d jeql L278 ! 492: 492 00033644 # force_loop = TRUE; /* set the force loop flag */ ! 493: 493 00033644 0d 01 effffffc19 movl $1,_force_loop ! 494: 494 0003364B # asm("jmp _pipe20_4_lp1"); /* and loop */ ! 495: 495 0003364B 71 efffffff8e jmp _pipe20_4_lp1 ! 496: 496 00033651 # } ! 497: 497 00033651 # } ! 498: 498 00033651 L278: ! 499: 499 00033651 # } /* end of FOR loop */ ! 500: 500 00033651 L275: ! 501: 501 00033651 L270: ! 502: 502 00033651 6d effffffc0d incl _index ! 503: 503 00033657 13 ff26 jbr L272 ! 504: 504 0003365A L271: ! 505: 505 0003365A # } /* end of subtest 4 */ ! 506: 506 0003365A 40 ret#2 ! 507: 507 0003365B .set L266,0x0 ! 508: 508 0003365B L268: ! 509: 509 0003365B 13 ff0f jbr L269 ! 510: 510 0003365E .data ! 511: 511 000006bc * .text ! 512: 512 0003365E .align 1 ! 513: 513 0003365E .globl _pipe20_5 ! 514: 514 0003365E _pipe20_5: ! 515: 515 0003365E 0000 .word L279 ! 516: 516 00033660 # ! 517: 517 00033660 # ! 518: 518 00033660 # ! 519: 519 00033660 # ! 520: 520 00033660 # ! 521: 521 00033660 # /************************************************************************ ! 522: 522 00033660 # * ! 523: 523 00033660 # * SUBTEST 5 : 6 NEGDs ! 524: 524 00033660 # * ! 525: 525 00033660 # ************************************************************************/ ! 526: 526 00033660 # pipe20_5() ! 527: 527 00033660 # { ! 528: 528 00033660 13 00dc jbr L281 ! 529: 529 00033663 L282: ! 530: 530 00033663 # subtest = 5; ! 531: 531 00033663 0d 05 effffffbfa movl $5,_subtest ! 532: 532 0003366A # force_loop = FALSE; ! 533: 533 0003366A 4d effffffbf4 clrl _force_loop ! 534: 534 00033670 # for( index = 0; index < max_ldd_1_index; index++ ) ! 535: 535 00033670 4d effffffbee clrl _index ! 536: 536 00033676 L285: ! 537: 537 00033676 1d effffffbe8 effffffbe3 cmpl _index,_max_ldd_1_index ! 538: 538 00033681 91 03 13 00b8 jgeq L284 ! 539: 539 00033686 # { ! 540: 540 00033686 # dbl_value_1 = ldd_1_data[index].ld; /* get operand 1 */ ! 541: 541 00033686 48 04 effffffbd7 50 shll $4,_index,r0 ! 542: 542 0003368E 0c 8f00000000 50 addl2 $_ldd_1_data,r0 ! 543: 543 00033695 0d a004 effffffbcb movl 4(r0),_dbl_value_1+4 ! 544: 544 0003369D 0d 60 effffffbc0 movl (r0),_dbl_value_1 ! 545: 545 000336A4 # dbl_expected = ldd_1_data[index].exp; /* get expected results */ ! 546: 546 000336A4 48 04 effffffbb9 50 shll $4,_index,r0 ! 547: 547 000336AC 0c 8f00000008 50 addl2 $_ldd_1_data+8,r0 ! 548: 548 000336B3 0d a004 effffffbad movl 4(r0),_dbl_expected+4 ! 549: 549 000336BB 0d 60 effffffba2 movl (r0),_dbl_expected ! 550: 550 000336C2 # /* ! 551: 551 000336C2 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 552: 552 000336C2 # * The force loop flag is set after the first error. ! 553: 553 000336C2 # */ ! 554: 554 000336C2 # asm("_pipe20_5_lp1:"); ! 555: 555 000336C2 _pipe20_5_lp1: ! 556: 556 000336C2 # asm("ldd _dbl_value_1"); /* load the operand */ ! 557: 557 000336C2 07 effffffb9c ldd _dbl_value_1 ! 558: 558 000336C8 # asm("negd"); /* negate it ( 6 times ) */ ! 559: 559 000336C8 b7 negd ! 560: 560 000336C9 # asm("negd"); ! 561: 561 000336C9 b7 negd ! 562: 562 000336CA # asm("negd"); ! 563: 563 000336CA b7 negd ! 564: 564 000336CB # asm("negd"); ! 565: 565 000336CB b7 negd ! 566: 566 000336CC # asm("negd"); ! 567: 567 000336CC b7 negd ! 568: 568 000336CD # asm("negd"); ! 569: 569 000336CD b7 negd ! 570: 570 000336CE # asm("std _dbl_st_acc"); /* store the result */ ! 571: 571 000336CE 27 effffffb90 std _dbl_st_acc ! 572: 572 000336D4 # if( force_loop ) ! 573: 573 000336D4 5d effffffb8a tstl _force_loop ! 574: 574 000336DA 31 02 jeql L286 ! 575: 575 000336DC # asm("brb _pipe20_5_lp1"); /* loop on an error */ ! 576: 576 000336DC 11 e4 brb _pipe20_5_lp1 ! 577: 577 000336DE # /* ! 578: 578 000336DE # * verify the results ! 579: 579 000336DE # */ ! 580: 580 000336DE # if( (dbl_st_acc.m != dbl_expected.m) || /* COMPARE the stored */ ! 581: 581 000336DE L286: ! 582: 582 000336DE # (dbl_st_acc.l != dbl_expected.l) ) { /* to the expected */ ! 583: 583 000336DE 1d effffffb80 effffffb7b cmpl _dbl_st_acc,_dbl_expected ! 584: 584 000336E9 21 0d jneq L9995 ! 585: 585 000336EB 1d effffffb77 effffffb72 cmpl _dbl_st_acc+4,_dbl_expected+4 ! 586: 586 000336F6 31 3d jeql L287 ! 587: 587 000336F8 L9995: ! 588: 588 000336F8 # errcnt++; /* bump the error count */ ! 589: 589 000336F8 6d effffffb66 incl _errcnt ! 590: 590 000336FE # if( prt_error ) ! 591: 591 000336FE 5d effffffb60 tstl _prt_error ! 592: 592 00033704 31 09 jeql L288 ! 593: 593 00033706 # pipe20_print( 6 ); /* print error msg -6 NOPs */ ! 594: 594 00033706 dd 06 pushl $6 ! 595: 595 00033708 fe 08 ef00000033 callf $8,_pipe20_print ! 596: 596 0003370F # if( halt_flg ) /* halt on error? */ ! 597: 597 0003370F L288: ! 598: 598 0003370F 5d effffffb4f tstl _halt_flg ! 599: 599 00033715 31 09 jeql L289 ! 600: 600 00033717 # pipe20_halt( 6 ); /* error halt -6 NOPs */ ! 601: 601 00033717 dd 06 pushl $6 ! 602: 602 00033719 fe 08 ef0000015a callf $8,_pipe20_halt ! 603: 603 00033720 # if( loop_on_err ) { ! 604: 604 00033720 L289: ! 605: 605 00033720 5d effffffb3e tstl _loop_on_err ! 606: 606 00033726 31 0d jeql L290 ! 607: 607 00033728 # force_loop = TRUE; /* set the force loop flag */ ! 608: 608 00033728 0d 01 effffffb35 movl $1,_force_loop ! 609: 609 0003372F # asm("jmp _pipe20_5_lp1"); /* and loop */ ! 610: 610 0003372F 71 efffffff8d jmp _pipe20_5_lp1 ! 611: 611 00033735 # } ! 612: 612 00033735 # } ! 613: 613 00033735 L290: ! 614: 614 00033735 # } /* end of FOR loop */ ! 615: 615 00033735 L287: ! 616: 616 00033735 L283: ! 617: 617 00033735 6d effffffb29 incl _index ! 618: 618 0003373B 13 ff38 jbr L285 ! 619: 619 0003373E L284: ! 620: 620 0003373E # } /* end of subtest 5 */ ! 621: 621 0003373E 40 ret#2 ! 622: 622 0003373F .set L279,0x0 ! 623: 623 0003373F L281: ! 624: 624 0003373F 13 ff21 jbr L282 ! 625: 625 00033742 .data ! 626: 626 000006bc * .text ! 627: 627 00033742 .align 1 ! 628: 628 00033742 .globl _pipe20_print ! 629: 629 00033742 _pipe20_print: ! 630: 630 00033742 0000 .word L291 ! 631: 631 00033744 # ! 632: 632 00033744 # ! 633: 633 00033744 # ! 634: 634 00033744 # ! 635: 635 00033744 # /**************************************************************************** ! 636: 636 00033744 # * ! 637: 637 00033744 # * PRINT AN ERROR MESSAGE ! 638: 638 00033744 # * ! 639: 639 00033744 # * cycle dd PIPELINE 20, subtest dd error ! 640: 640 00033744 # * LDD op, {NEGD}, STD ! 641: 641 00033744 # * operand = xxxxxxxx xxxxxxxx, final Acc = xxxxxxxx xxxxxxxx, index = dd ! 642: 642 00033744 # * expected Acc = xxxxxxxx xxxxxxxx ! 643: 643 00033744 # * ! 644: 644 00033744 # ****************************************************************************/ ! 645: 645 00033744 # pipe20_print( nop_count ) ! 646: 646 00033744 # int nop_count; /* # of NOP instructions */ ! 647: 647 00033744 # { ! 648: 648 00033744 13 0130 jbr L293 ! 649: 649 00033747 L294: ! 650: 650 00033747 # writes(" \n"); /* start a new print line */ ! 651: 651 00033747 .data 1 ! 652: 652 000006c5 * L295: ! 653: 653 000006c5 * 200A00 .ascii " \12\0" ! 654: 654 000006c8 * .text ! 655: 655 00033747 dd 8f000006c5 pushl $L295 ! 656: 656 0003374D fe 08 effffffb10 callf $8,_writes ! 657: 657 00033754 # writes("cycle: "); ! 658: 658 00033754 .data 1 ! 659: 659 000006c8 * L296: ! 660: 660 000006c8 * 6379636C653A2000 .ascii "cycle: \0" ! 661: 661 000006d0 * .text ! 662: 662 00033754 dd 8f000006c8 pushl $L296 ! 663: 663 0003375A fe 08 effffffb03 callf $8,_writes ! 664: 664 00033761 # writed( cycle ); ! 665: 665 00033761 dd effffffafd pushl _cycle ! 666: 666 00033767 fe 08 effffffaf6 callf $8,_writed ! 667: 667 0003376E # writes(" PIPELINE 20, subtest "); ! 668: 668 0003376E .data 1 ! 669: 669 000006d0 * L298: ! 670: 670 000006d0 * 2020504950454C494E4520323 .ascii " PIPELINE 20, subtest \0" ! 671: 02C20737562746573742000 ! 672: 671 000006e8 * .text ! 673: 672 0003376E dd 8f000006d0 pushl $L298 ! 674: 673 00033774 fe 08 effffffae9 callf $8,_writes ! 675: 674 0003377B # writed( subtest ); ! 676: 675 0003377B dd effffffae3 pushl _subtest ! 677: 676 00033781 fe 08 effffffadc callf $8,_writed ! 678: 677 00033788 # writes(" error\n"); ! 679: 678 00033788 .data 1 ! 680: 679 000006e8 * L299: ! 681: 680 000006e8 * 206572726F720A00 .ascii " error\12\0" ! 682: 681 000006f0 * .text ! 683: 682 00033788 dd 8f000006e8 pushl $L299 ! 684: 683 0003378E fe 08 effffffacf callf $8,_writes ! 685: 684 00033795 # writes(" LDD(op), NEGD"); ! 686: 685 00033795 .data 1 ! 687: 686 000006f0 * L300: ! 688: 687 000006f0 * 204C4444286F70292C204E454 .ascii " LDD(op), NEGD\0" ! 689: 74400 ! 690: 688 000006ff * .text ! 691: 689 00033795 dd 8f000006f0 pushl $L300 ! 692: 690 0003379B fe 08 effffffac2 callf $8,_writes ! 693: 691 000337A2 # while( --nop_count ) ! 694: 692 000337A2 L301: ! 695: 693 000337A2 7d ad04 decl 4(fp) ! 696: 694 000337A5 31 0f jeql L302 ! 697: 695 000337A7 # writes(", NEGD"); ! 698: 696 000337A7 .data 1 ! 699: 697 000006ff * L303: ! 700: 698 000006ff * 2C204E45474400 .ascii ", NEGD\0" ! 701: 699 00000706 * .text ! 702: 700 000337A7 dd 8f000006ff pushl $L303 ! 703: 701 000337AD fe 08 effffffab0 callf $8,_writes ! 704: 702 000337B4 11 ec jbr L301 ! 705: 703 000337B6 L302: ! 706: 704 000337B6 # writes(", STD\n"); ! 707: 705 000337B6 .data 1 ! 708: 706 00000706 * L304: ! 709: 707 00000706 * 2C205354440A00 .ascii ", STD\12\0" ! 710: 708 0000070d * .text ! 711: 709 000337B6 dd 8f00000706 pushl $L304 ! 712: 710 000337BC fe 08 effffffaa1 callf $8,_writes ! 713: 711 000337C3 # writes("operand = "); ! 714: 712 000337C3 .data 1 ! 715: 713 0000070d * L305: ! 716: 714 0000070d * 6F706572616E64203D2000 .ascii "operand = \0" ! 717: 715 00000718 * .text ! 718: 716 000337C3 dd 8f0000070d pushl $L305 ! 719: 717 000337C9 fe 08 effffffa94 callf $8,_writes ! 720: 718 000337D0 # write32h( dbl_value_1.m ); ! 721: 719 000337D0 dd effffffa8e pushl _dbl_value_1 ! 722: 720 000337D6 fe 08 effffffa87 callf $8,_write32h ! 723: 721 000337DD # writec(' '); ! 724: 722 000337DD dd 20 pushl $32 ! 725: 723 000337DF fe 08 effffffa7e callf $8,_writec ! 726: 724 000337E6 # write32h( dbl_value_1.l ); ! 727: 725 000337E6 dd effffffa7c pushl _dbl_value_1+4 ! 728: 726 000337EC fe 08 effffffa71 callf $8,_write32h ! 729: 727 000337F3 # writes(", final Acc = "); ! 730: 728 000337F3 .data 1 ! 731: 729 00000718 * L308: ! 732: 730 00000718 * 2C202066696E616C204163632 .ascii ", final Acc = \0" ! 733: 03D2000 ! 734: 731 00000728 * .text ! 735: 732 000337F3 dd 8f00000718 pushl $L308 ! 736: 733 000337F9 fe 08 effffffa64 callf $8,_writes ! 737: 734 00033800 # write32h( dbl_st_acc.m ); ! 738: 735 00033800 dd effffffa5e pushl _dbl_st_acc ! 739: 736 00033806 fe 08 effffffa57 callf $8,_write32h ! 740: 737 0003380D # writec(' '); ! 741: 738 0003380D dd 20 pushl $32 ! 742: 739 0003380F fe 08 effffffa4e callf $8,_writec ! 743: 740 00033816 # write32h( dbl_st_acc.l ); ! 744: 741 00033816 dd effffffa4c pushl _dbl_st_acc+4 ! 745: 742 0003381C fe 08 effffffa41 callf $8,_write32h ! 746: 743 00033823 # writes(", index = "); ! 747: 744 00033823 .data 1 ! 748: 745 00000728 * L309: ! 749: 746 00000728 * 2C202020696E646578203D200 .ascii ", index = \0" ! 750: 0 ! 751: 747 00000735 * .text ! 752: 748 00033823 dd 8f00000728 pushl $L309 ! 753: 749 00033829 fe 08 effffffa34 callf $8,_writes ! 754: 750 00033830 # writed( index ); ! 755: 751 00033830 dd effffffa2e pushl _index ! 756: 752 00033836 fe 08 effffffa27 callf $8,_writed ! 757: 753 0003383D # writes("\n expected Acc = "); ! 758: 754 0003383D .data 1 ! 759: 755 00000735 * L310: ! 760: 756 00000735 * 0A20202020202020202020202 .ascii "\12 expected Acc = \0" ! 761: 0202020202020202020202020 ! 762: 2020206578706563746564204 ! 763: 16363203D2000 ! 764: 757 00000761 * .text ! 765: 758 0003383D dd 8f00000735 pushl $L310 ! 766: 759 00033843 fe 08 effffffa1a callf $8,_writes ! 767: 760 0003384A # write32h( dbl_expected.m ); ! 768: 761 0003384A dd effffffa14 pushl _dbl_expected ! 769: 762 00033850 fe 08 effffffa0d callf $8,_write32h ! 770: 763 00033857 # writec(' '); ! 771: 764 00033857 dd 20 pushl $32 ! 772: 765 00033859 fe 08 effffffa04 callf $8,_writec ! 773: 766 00033860 # write32h( dbl_expected.l ); ! 774: 767 00033860 dd effffffa02 pushl _dbl_expected+4 ! 775: 768 00033866 fe 08 effffff9f7 callf $8,_write32h ! 776: 769 0003386D # writec('\n'); ! 777: 770 0003386D dd 0a pushl $10 ! 778: 771 0003386F fe 08 effffff9ee callf $8,_writec ! 779: 772 00033876 # } ! 780: 773 00033876 40 ret#2 ! 781: 774 00033877 .set L291,0x0 ! 782: 775 00033877 L293: ! 783: 776 00033877 13 fecd jbr L294 ! 784: 777 0003387A .data ! 785: 778 000006bc * .text ! 786: 779 0003387A .align 1 ! 787: 780 0003387A .globl _pipe20_halt ! 788: 781 0003387A _pipe20_halt: ! 789: 782 0003387A 0000 .word L311 ! 790: 783 0003387C # ! 791: 784 0003387C # ! 792: 785 0003387C # ! 793: 786 0003387C # /**************************************************************************** ! 794: 787 0003387C # * ! 795: 788 0003387C # * SET UP THE REGISTERS AND HALT ! 796: 789 0003387C # * ! 797: 790 0003387C # ****************************************************************************/ ! 798: 791 0003387C # pipe20_halt( nop_count ) ! 799: 792 0003387C # int nop_count; /* # of NOP instructions */ ! 800: 793 0003387C # { ! 801: 794 0003387C 13 009c jbr L313 ! 802: 795 0003387F L314: ! 803: 796 0003387F # sgl_dummy1 = nop_count; ! 804: 797 0003387F 0d ad04 effffff9dd movl 4(fp),_sgl_dummy1 ! 805: 798 00033887 # sgl_value_1 = dbl_value_1.m; ! 806: 799 00033887 0d effffff9d7 effffff9d2 movl _dbl_value_1,_sgl_value_1 ! 807: 800 00033892 # sgl_value_2 = dbl_value_1.l; ! 808: 801 00033892 0d effffff9d0 effffff9c7 movl _dbl_value_1+4,_sgl_value_2 ! 809: 802 0003389D # sgl_value_3 = dbl_st_acc.m; ! 810: 803 0003389D 0d effffff9c1 effffff9bc movl _dbl_st_acc,_sgl_value_3 ! 811: 804 000338A8 # sgl_value_4 = dbl_st_acc.l; ! 812: 805 000338A8 0d effffff9ba effffff9b1 movl _dbl_st_acc+4,_sgl_value_4 ! 813: 806 000338B3 # sgl_value_5 = dbl_expected.m; ! 814: 807 000338B3 0d effffff9ab effffff9a6 movl _dbl_expected,_sgl_value_5 ! 815: 808 000338BE # sgl_value_6 = dbl_expected.l; ! 816: 809 000338BE 0d effffff9a4 effffff99b movl _dbl_expected+4,_sgl_value_6 ! 817: 810 000338C9 # asm("movl _test_no,r0"); /* r0 = test number */ ! 818: 811 000338C9 0d effffff995 50 movl _test_no,r0 ! 819: 812 000338D0 # asm("movl _subtest,r1"); /* r1 = subtest number */ ! 820: 813 000338D0 0d effffff98e 51 movl _subtest,r1 ! 821: 814 000338D7 # asm("movl $1,r2"); /* r2 = error code */ ! 822: 815 000338D7 0d 01 52 movl $1,r2 ! 823: 816 000338DA # asm("movl _cycle,r3"); /* r3 = cycle count */ ! 824: 817 000338DA 0d effffff984 53 movl _cycle,r3 ! 825: 818 000338E1 # asm("movl _sgl_dummy1,r4"); /* r4 = # of NEGDS */ ! 826: 819 000338E1 0d effffff97d 54 movl _sgl_dummy1,r4 ! 827: 820 000338E8 # asm("movl _sgl_value_1,r5"); /* r5 = MS operand */ ! 828: 821 000338E8 0d effffff976 55 movl _sgl_value_1,r5 ! 829: 822 000338EF # asm("movl _sgl_value_2,r6"); /* r6 = LS operand */ ! 830: 823 000338EF 0d effffff96f 56 movl _sgl_value_2,r6 ! 831: 824 000338F6 # asm("movl _sgl_value_3,r7"); /* r7 = MS stored */ ! 832: 825 000338F6 0d effffff968 57 movl _sgl_value_3,r7 ! 833: 826 000338FD # asm("movl _sgl_value_4,r8"); /* r8 = LS stored */ ! 834: 827 000338FD 0d effffff961 58 movl _sgl_value_4,r8 ! 835: 828 00033904 # asm("movl _sgl_value_5,r9"); /* r9 = MS expected */ ! 836: 829 00033904 0d effffff95a 59 movl _sgl_value_5,r9 ! 837: 830 0003390B # asm("movl _sgl_value_6,r10"); /* r10 = LS expected */ ! 838: 831 0003390B 0d effffff953 5a movl _sgl_value_6,r10 ! 839: 832 00033912 # asm("movl _index,r11"); /* r11 = data index */ ! 840: 833 00033912 0d effffff94c 5b movl _index,r11 ! 841: 834 00033919 # asm("halt"); /* HALT ... */ ! 842: 835 00033919 00 halt ! 843: 836 0003391A # } ! 844: 837 0003391A 40 ret#2 ! 845: 838 0003391B .set L311,0x0 ! 846: 839 0003391B L313: ! 847: 840 0003391B 13 ff61 jbr L314 ! 848: 841 0003391E .data ! 849: 841 00066B82 .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.