![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe12.c 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 pipe12.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / macro4 |
1.1 ! root 1: #include "fpp_defs.h" ! 2: ! 3: ! 4: /***************************************************************************** ! 5: * ! 6: * DBL PIPELINE TEST #12 MONITOR ! 7: * ! 8: * This test will do: ! 9: * ! 10: * LDD(x) SUBD(x) ADDD(0) SUBD(x) ADDD(x) SUBD(0) ADDD(x) STD ! 11: * ! 12: * where the x's are the LDD data patterns. ! 13: *****************************************************************************/ ! 14: pipe_12() ! 15: { ! 16: asm(".globl _pipeline_12_t"); ! 17: asm("_pipeline_12_t:"); /* entry address */ ! 18: if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */ ! 19: { ! 20: if( run_all ) ! 21: writes("\n"); ! 22: writes(" PIPE_12"); ! 23: } ! 24: subtest = 1; ! 25: pipe12_1(); /* data in REGs, no NOPs */ ! 26: subtest++; /* increment subtest num */ ! 27: pipe12_2(); /* data in REGs, 1 NOP */ ! 28: subtest++; /* increment subtest num */ ! 29: pipe12_3(); /* data in REGs, 2 NOPs */ ! 30: subtest++; /* increment subtest num */ ! 31: pipe12_4(); /* data in REGs, 3 NOPs */ ! 32: subtest++; /* increment subtest num */ ! 33: pipe12_5(); /* data in CACHE, no NOPs */ ! 34: subtest++; /* increment subtest num */ ! 35: pipe12_6(); /* data in CACHE, 1 NOP */ ! 36: subtest++; /* increment subtest num */ ! 37: pipe12_7(); /* data in CACHE, 2 NOPs */ ! 38: subtest++; /* increment subtest num */ ! 39: pipe12_8(); /* data in CACHE, 3 NOPs */ ! 40: subtest++; /* increment subtest num */ ! 41: pipe12_9(); /* data via F.P. 0 NOPs */ ! 42: asm("jmp *return"); /* return to the test monitor */ ! 43: } ! 44: ! 45: ! 46: ! 47: ! 48: ! 49: /************************************************************************ ! 50: * ! 51: * SUBTEST 1 ! 52: * data in registers, no NO-OPs ! 53: * ! 54: ************************************************************************/ ! 55: pipe12_1() ! 56: { ! 57: force_loop = FALSE; /* clear the force_loop flg */ ! 58: index = 0; ! 59: do ! 60: { ! 61: sgl_value_1 = ldd_1_data[index].ld.m; /* get the operand's MSW */ ! 62: sgl_value_2 = ldd_1_data[index].ld.l; /* get the operand's MSW */ ! 63: dbl_expected = ldd_1_data[index].exp; /* get the expected results */ ! 64: /* ! 65: * If LOOP ON ERROR is set, this is the loop for this subtest. ! 66: * The force loop flag is set after the first error. ! 67: */ ! 68: asm("_pipe12_1_lp1:"); ! 69: asm("movl _sgl_value_1,r4"); /* move the data to r4/r5 */ ! 70: asm("movl _sgl_value_2,r5"); ! 71: asm("clrl r2"); /* clear r2 / r3 */ ! 72: asm("clrl r3"); ! 73: asm("ldd r4"); /* load the op. ( op ) */ ! 74: asm("subd r4"); /* subtract the op. ( 0 ) */ ! 75: asm("addd r2"); /* add a '0' ( 0 ) */ ! 76: asm("subd r4"); /* subtract the op. (-op ) */ ! 77: asm("addd r4"); /* add the op. ( 0 ) */ ! 78: asm("subd r2"); /* subtract a '0' ( 0 ) */ ! 79: asm("addd r4"); /* add the op. ( op ) */ ! 80: asm("std r6"); /* store the result ( op ) */ ! 81: if( force_loop ) ! 82: asm("brb _pipe12_1_lp1");; /* run the loop again */ ! 83: /* ! 84: * verify the results ! 85: */ ! 86: asm("movl r6,_sgl_value_3"); /* get the result */ ! 87: asm("movl r7,_sgl_value_4"); ! 88: dbl_st_acc.m = sgl_value_3; ! 89: dbl_st_acc.l = sgl_value_4; ! 90: if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */ ! 91: (dbl_st_acc.l != dbl_expected.l) ) ! 92: { ! 93: errcnt++; /* bump the error count */ ! 94: if ( prt_error ) ! 95: print_pipe12_er("Reg. Data, 0 NO-OPs"); ! 96: if ( halt_flg ) /* halt on error? */ ! 97: pipe12_er_hlt( subtest ); ! 98: if ( loop_on_err ) { ! 99: force_loop = TRUE; /* set the force loop flag */ ! 100: asm("brw _pipe12_1_lp1"); /* and loop */ ! 101: } ! 102: } /* end of compare error */ ! 103: } while( index++ < max_ldd_1_index ); ! 104: } /* end of subtest 1 */ ! 105: ! 106: ! 107: ! 108: ! 109: ! 110: ! 111: /************************************************************************ ! 112: * ! 113: * SUBTEST 2 ! 114: * data in registers, 1 NO-OP ! 115: * ! 116: ************************************************************************/ ! 117: pipe12_2() ! 118: { ! 119: force_loop = FALSE; /* clear the force_loop flg */ ! 120: index = 0; ! 121: do ! 122: { ! 123: sgl_value_1 = ldd_1_data[index].ld.m; /* get the operand's MSW */ ! 124: sgl_value_2 = ldd_1_data[index].ld.l; /* get the operand's MSW */ ! 125: dbl_expected = ldd_1_data[index].exp; /* get the expected results */ ! 126: /* ! 127: * If LOOP ON ERROR is set, this is the loop for this subtest. ! 128: * The force loop flag is set after the first error. ! 129: */ ! 130: asm("_pipe12_2_lp1:"); ! 131: asm("movl _sgl_value_1,r4"); /* move the data to r4/r5 */ ! 132: asm("movl _sgl_value_2,r5"); ! 133: asm("clrl r2"); /* clear r2 / r3 */ ! 134: asm("clrl r3"); ! 135: asm("ldd r4"); /* load the op. ( op ) */ ! 136: asm("nop"); ! 137: asm("subd r4"); /* subtract the op. ( 0 ) */ ! 138: asm("nop"); ! 139: asm("addd r2"); /* add a '0' ( 0 ) */ ! 140: asm("nop"); ! 141: asm("subd r4"); /* subtract the op. (-op ) */ ! 142: asm("nop"); ! 143: asm("addd r4"); /* add the op. ( 0 ) */ ! 144: asm("nop"); ! 145: asm("subd r2"); /* subtract a '0' ( 0 ) */ ! 146: asm("nop"); ! 147: asm("addd r4"); /* add the op. ( op ) */ ! 148: asm("nop"); ! 149: asm("std r6"); /* store the result ( op ) */ ! 150: if( force_loop ) ! 151: asm("brb _pipe12_2_lp1");; /* run the loop again */ ! 152: /* ! 153: * verify the results ! 154: */ ! 155: asm("movl r6,_sgl_value_3"); /* get the result */ ! 156: asm("movl r7,_sgl_value_4"); ! 157: dbl_st_acc.m = sgl_value_3; ! 158: dbl_st_acc.l = sgl_value_4; ! 159: if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */ ! 160: (dbl_st_acc.l != dbl_expected.l) ) ! 161: { ! 162: errcnt++; /* bump the error count */ ! 163: if ( prt_error ) ! 164: print_pipe12_er("Reg. Data, 1 NO-OP"); ! 165: if ( halt_flg ) /* halt on error? */ ! 166: pipe12_er_hlt( subtest ); ! 167: if ( loop_on_err ) { ! 168: force_loop = TRUE; /* set the force loop flag */ ! 169: asm("brw _pipe12_2_lp1"); /* and loop */ ! 170: } ! 171: } /* end of compare error */ ! 172: } while( index++ < max_ldd_1_index ); ! 173: } /* end of subtest 2 */ ! 174: ! 175: ! 176: ! 177: ! 178: ! 179: /************************************************************************ ! 180: * ! 181: * SUBTEST 3 ! 182: * data in registers, 2 NO-OPs ! 183: * ! 184: ************************************************************************/ ! 185: pipe12_3() ! 186: { ! 187: force_loop = FALSE; /* clear the force_loop flg */ ! 188: index = 0; ! 189: do ! 190: { ! 191: sgl_value_1 = ldd_1_data[index].ld.m; /* get the operand's MSW */ ! 192: sgl_value_2 = ldd_1_data[index].ld.l; /* get the operand's MSW */ ! 193: dbl_expected = ldd_1_data[index].exp; /* get the expected results */ ! 194: /* ! 195: * If LOOP ON ERROR is set, this is the loop for this subtest. ! 196: * The force loop flag is set after the first error. ! 197: */ ! 198: asm("_pipe12_3_lp1:"); ! 199: asm("movl _sgl_value_1,r4"); /* move the data to r4/r5 */ ! 200: asm("movl _sgl_value_2,r5"); ! 201: asm("clrl r2"); /* clear r2 / r3 */ ! 202: asm("clrl r3"); ! 203: asm("ldd r4"); /* load the op. ( op ) */ ! 204: asm("nop"); ! 205: asm("nop"); ! 206: asm("subd r4"); /* subtract the op. ( 0 ) */ ! 207: asm("nop"); ! 208: asm("nop"); ! 209: asm("addd r2"); /* add a '0' ( 0 ) */ ! 210: asm("nop"); ! 211: asm("nop"); ! 212: asm("subd r4"); /* subtract the op. (-op ) */ ! 213: asm("nop"); ! 214: asm("nop"); ! 215: asm("addd r4"); /* add the op. ( 0 ) */ ! 216: asm("nop"); ! 217: asm("nop"); ! 218: asm("subd r2"); /* subtract a '0' ( 0 ) */ ! 219: asm("nop"); ! 220: asm("nop"); ! 221: asm("addd r4"); /* add the op. ( op ) */ ! 222: asm("nop"); ! 223: asm("nop"); ! 224: asm("std r6"); /* store the result ( op ) */ ! 225: if( force_loop ) ! 226: asm("brb _pipe12_3_lp1");; /* run the loop again */ ! 227: /* ! 228: * verify the results ! 229: */ ! 230: asm("movl r6,_sgl_value_3"); /* get the result */ ! 231: asm("movl r7,_sgl_value_4"); ! 232: dbl_st_acc.m = sgl_value_3; ! 233: dbl_st_acc.l = sgl_value_4; ! 234: if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */ ! 235: (dbl_st_acc.l != dbl_expected.l) ) ! 236: { ! 237: errcnt++; /* bump the error count */ ! 238: if ( prt_error ) ! 239: print_pipe12_er("Reg. Data, 2 NO-OPs"); ! 240: if ( halt_flg ) /* halt on error? */ ! 241: pipe12_er_hlt( subtest ); ! 242: if ( loop_on_err ) { ! 243: force_loop = TRUE; /* set the force loop flag */ ! 244: asm("brw _pipe12_3_lp1"); /* and loop */ ! 245: } ! 246: } /* end of compare error */ ! 247: } while( index++ < max_ldd_1_index ); ! 248: } /* end of subtest 3 */ ! 249: ! 250: ! 251: ! 252: ! 253: ! 254: /************************************************************************ ! 255: * ! 256: * SUBTEST 4 ! 257: * data in registers, 3 NO-OPs ! 258: * ! 259: ************************************************************************/ ! 260: pipe12_4() ! 261: { ! 262: force_loop = FALSE; /* clear the force_loop flg */ ! 263: index = 0; ! 264: do ! 265: { ! 266: sgl_value_1 = ldd_1_data[index].ld.m; /* get the operand's MSW */ ! 267: sgl_value_2 = ldd_1_data[index].ld.l; /* get the operand's MSW */ ! 268: dbl_expected = ldd_1_data[index].exp; /* get the expected results */ ! 269: /* ! 270: * If LOOP ON ERROR is set, this is the loop for this subtest. ! 271: * The force loop flag is set after the first error. ! 272: */ ! 273: asm("_pipe12_4_lp1:"); ! 274: asm("movl _sgl_value_1,r4"); /* move the data to r4/r5 */ ! 275: asm("movl _sgl_value_2,r5"); ! 276: asm("clrl r2"); /* clear r2 / r3 */ ! 277: asm("clrl r3"); ! 278: asm("ldd r4"); /* load the op. ( op ) */ ! 279: asm("nop"); ! 280: asm("nop"); ! 281: asm("nop"); ! 282: asm("subd r4"); /* subtract the op. ( 0 ) */ ! 283: asm("nop"); ! 284: asm("nop"); ! 285: asm("nop"); ! 286: asm("addd r2"); /* add a '0' ( 0 ) */ ! 287: asm("nop"); ! 288: asm("nop"); ! 289: asm("nop"); ! 290: asm("subd r4"); /* subtract the op. (-op ) */ ! 291: asm("nop"); ! 292: asm("nop"); ! 293: asm("nop"); ! 294: asm("addd r4"); /* add the op. ( 0 ) */ ! 295: asm("nop"); ! 296: asm("nop"); ! 297: asm("nop"); ! 298: asm("subd r2"); /* subtract a '0' ( 0 ) */ ! 299: asm("nop"); ! 300: asm("nop"); ! 301: asm("nop"); ! 302: asm("addd r4"); /* add the op. ( op ) */ ! 303: asm("nop"); ! 304: asm("nop"); ! 305: asm("nop"); ! 306: asm("std r6"); /* store the result ( op ) */ ! 307: if( force_loop ) ! 308: asm("brb _pipe12_4_lp1");; /* run the loop again */ ! 309: /* ! 310: * verify the results ! 311: */ ! 312: asm("movl r6,_sgl_value_3"); /* get the result */ ! 313: asm("movl r7,_sgl_value_4"); ! 314: dbl_st_acc.m = sgl_value_3; ! 315: dbl_st_acc.l = sgl_value_4; ! 316: if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */ ! 317: (dbl_st_acc.l != dbl_expected.l) ) ! 318: { ! 319: errcnt++; /* bump the error count */ ! 320: if ( prt_error ) ! 321: print_pipe12_er("Reg. Data, 3 NO-OPs"); ! 322: if ( halt_flg ) /* halt on error? */ ! 323: pipe12_er_hlt( subtest ); ! 324: if ( loop_on_err ) { ! 325: force_loop = TRUE; /* set the force loop flag */ ! 326: asm("brw _pipe12_4_lp1"); /* and loop */ ! 327: } ! 328: } /* end of compare error */ ! 329: } while( index++ < max_ldd_1_index ); ! 330: } /* end of subtest 4 */ ! 331: ! 332: ! 333: ! 334: ! 335: ! 336: ! 337: /************************************************************************ ! 338: * ! 339: * SUBTEST 5 ! 340: * data in cache, no NO-OPs ! 341: * ! 342: ************************************************************************/ ! 343: pipe12_5() ! 344: { ! 345: force_loop = FALSE; /* clear the force_loop flg */ ! 346: index = 0; ! 347: do ! 348: { ! 349: dbl_value_1 = ldd_1_data[index].ld; /* get the operand's MSW */ ! 350: dbl_value_2.m = 0; /* clear the '0.0' operand */ ! 351: dbl_value_2.l = 0; ! 352: dbl_expected = ldd_1_data[index].exp; /* get the expected results */ ! 353: /* ! 354: * If LOOP ON ERROR is set, this is the loop for this subtest. ! 355: * The force loop flag is set after the first error. ! 356: */ ! 357: asm("_pipe12_5_lp1:"); ! 358: asm("ldd _dbl_value_1"); /* load the op. ( op ) */ ! 359: asm("subd _dbl_value_1"); /* subtract the op. ( 0 ) */ ! 360: asm("addd _dbl_value_2"); /* add a '0' ( 0 ) */ ! 361: asm("subd _dbl_value_1"); /* subtract the op. (-op ) */ ! 362: asm("addd _dbl_value_1"); /* add the op. ( 0 ) */ ! 363: asm("subd _dbl_value_2"); /* subtract a '0' ( 0 ) */ ! 364: asm("addd _dbl_value_1"); /* add the op. ( op ) */ ! 365: asm("std _dbl_st_acc"); /* store the result ( op ) */ ! 366: if( force_loop ) ! 367: asm("brb _pipe12_5_lp1");; /* run the loop again */ ! 368: /* ! 369: * verify the results ! 370: */ ! 371: if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */ ! 372: (dbl_st_acc.l != dbl_expected.l) ) ! 373: { ! 374: errcnt++; /* bump the error count */ ! 375: if ( prt_error ) ! 376: print_pipe12_er("Cache Data, 0 NO-OPs"); ! 377: if ( halt_flg ) /* halt on error? */ ! 378: pipe12_er_hlt( subtest ); ! 379: if ( loop_on_err ) { ! 380: force_loop = TRUE; /* set the force loop flag */ ! 381: asm("brw _pipe12_5_lp1"); /* and loop */ ! 382: } ! 383: } /* end of compare error */ ! 384: } while( index++ < max_ldd_1_index ); ! 385: } /* end of subtest 5 */ ! 386: ! 387: ! 388: ! 389: ! 390: ! 391: ! 392: ! 393: /************************************************************************ ! 394: * ! 395: * SUBTEST 6 ! 396: * data in cache, 1 NO-OP ! 397: * ! 398: ************************************************************************/ ! 399: pipe12_6() ! 400: { ! 401: force_loop = FALSE; /* clear the force_loop flg */ ! 402: index = 0; ! 403: do ! 404: { ! 405: dbl_value_1 = ldd_1_data[index].ld; /* get the operand's MSW */ ! 406: dbl_value_2.m = 0; /* clear the '0.0' operand */ ! 407: dbl_value_2.l = 0; ! 408: dbl_expected = ldd_1_data[index].exp; /* get the expected results */ ! 409: /* ! 410: * If LOOP ON ERROR is set, this is the loop for this subtest. ! 411: * The force loop flag is set after the first error. ! 412: */ ! 413: asm("_pipe12_6_lp1:"); ! 414: asm("ldd _dbl_value_1"); /* load the op. ( op ) */ ! 415: asm("nop"); ! 416: asm("subd _dbl_value_1"); /* subtract the op. ( 0 ) */ ! 417: asm("nop"); ! 418: asm("addd _dbl_value_2"); /* add a '0' ( 0 ) */ ! 419: asm("nop"); ! 420: asm("subd _dbl_value_1"); /* subtract the op. (-op ) */ ! 421: asm("nop"); ! 422: asm("addd _dbl_value_1"); /* add the op. ( 0 ) */ ! 423: asm("nop"); ! 424: asm("subd _dbl_value_2"); /* subtract a '0' ( 0 ) */ ! 425: asm("nop"); ! 426: asm("addd _dbl_value_1"); /* add the op. ( op ) */ ! 427: asm("nop"); ! 428: asm("std _dbl_st_acc"); /* store the result ( op ) */ ! 429: if( force_loop ) ! 430: asm("brb _pipe12_6_lp1");; /* run the loop again */ ! 431: /* ! 432: * verify the results ! 433: */ ! 434: if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */ ! 435: (dbl_st_acc.l != dbl_expected.l) ) ! 436: { ! 437: errcnt++; /* bump the error count */ ! 438: if ( prt_error ) ! 439: print_pipe12_er("Cache Data, 1 NO-OP"); ! 440: if ( halt_flg ) /* halt on error? */ ! 441: pipe12_er_hlt( subtest ); ! 442: if ( loop_on_err ) { ! 443: force_loop = TRUE; /* set the force loop flag */ ! 444: asm("brw _pipe12_6_lp1"); /* and loop */ ! 445: } ! 446: } /* end of compare error */ ! 447: } while( index++ < max_ldd_1_index ); ! 448: } /* end of subtest 6 */ ! 449: ! 450: ! 451: ! 452: ! 453: ! 454: ! 455: ! 456: /************************************************************************ ! 457: * ! 458: * SUBTEST 7 ! 459: * data in cache, 2 NO-OPs ! 460: * ! 461: ************************************************************************/ ! 462: pipe12_7() ! 463: { ! 464: force_loop = FALSE; /* clear the force_loop flg */ ! 465: index = 0; ! 466: do ! 467: { ! 468: dbl_value_1 = ldd_1_data[index].ld; /* get the operand's MSW */ ! 469: dbl_value_2.m = 0; /* clear the '0.0' operand */ ! 470: dbl_value_2.l = 0; ! 471: dbl_expected = ldd_1_data[index].exp; /* get the expected results */ ! 472: /* ! 473: * If LOOP ON ERROR is set, this is the loop for this subtest. ! 474: * The force loop flag is set after the first error. ! 475: */ ! 476: asm("_pipe12_7_lp1:"); ! 477: asm("ldd _dbl_value_1"); /* load the op. ( op ) */ ! 478: asm("nop"); ! 479: asm("nop"); ! 480: asm("subd _dbl_value_1"); /* subtract the op. ( 0 ) */ ! 481: asm("nop"); ! 482: asm("nop"); ! 483: asm("addd _dbl_value_2"); /* add a '0' ( 0 ) */ ! 484: asm("nop"); ! 485: asm("nop"); ! 486: asm("subd _dbl_value_1"); /* subtract the op. (-op ) */ ! 487: asm("nop"); ! 488: asm("nop"); ! 489: asm("addd _dbl_value_1"); /* add the op. ( 0 ) */ ! 490: asm("nop"); ! 491: asm("nop"); ! 492: asm("subd _dbl_value_2"); /* subtract a '0' ( 0 ) */ ! 493: asm("nop"); ! 494: asm("nop"); ! 495: asm("addd _dbl_value_1"); /* add the op. ( op ) */ ! 496: asm("nop"); ! 497: asm("nop"); ! 498: asm("std _dbl_st_acc"); /* store the result ( op ) */ ! 499: if( force_loop ) ! 500: asm("brb _pipe12_7_lp1");; /* run the loop again */ ! 501: /* ! 502: * verify the results ! 503: */ ! 504: if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */ ! 505: (dbl_st_acc.l != dbl_expected.l) ) ! 506: { ! 507: errcnt++; /* bump the error count */ ! 508: if ( prt_error ) ! 509: print_pipe12_er("Cache Data, 2 NO-OPs"); ! 510: if ( halt_flg ) /* halt on error? */ ! 511: pipe12_er_hlt( subtest ); ! 512: if ( loop_on_err ) { ! 513: force_loop = TRUE; /* set the force loop flag */ ! 514: asm("brw _pipe12_7_lp1"); /* and loop */ ! 515: } ! 516: } /* end of compare error */ ! 517: } while( index++ < max_ldd_1_index ); ! 518: } /* end of subtest 7 */ ! 519: ! 520: ! 521: ! 522: ! 523: ! 524: ! 525: ! 526: /************************************************************************ ! 527: * ! 528: * SUBTEST 8 ! 529: * data in cache, 3 NO-OPs ! 530: * ! 531: ************************************************************************/ ! 532: pipe12_8() ! 533: { ! 534: force_loop = FALSE; /* clear the force_loop flg */ ! 535: index = 0; ! 536: do ! 537: { ! 538: dbl_value_1 = ldd_1_data[index].ld; /* get the operand's MSW */ ! 539: dbl_value_2.m = 0; /* clear the '0.0' operand */ ! 540: dbl_value_2.l = 0; ! 541: dbl_expected = ldd_1_data[index].exp; /* get the expected results */ ! 542: /* ! 543: * If LOOP ON ERROR is set, this is the loop for this subtest. ! 544: * The force loop flag is set after the first error. ! 545: */ ! 546: asm("_pipe12_8_lp1:"); ! 547: asm("ldd _dbl_value_1"); /* load the op. ( op ) */ ! 548: asm("nop"); ! 549: asm("nop"); ! 550: asm("nop"); ! 551: asm("subd _dbl_value_1"); /* subtract the op. ( 0 ) */ ! 552: asm("nop"); ! 553: asm("nop"); ! 554: asm("nop"); ! 555: asm("addd _dbl_value_2"); /* add a '0' ( 0 ) */ ! 556: asm("nop"); ! 557: asm("nop"); ! 558: asm("nop"); ! 559: asm("subd _dbl_value_1"); /* subtract the op. (-op ) */ ! 560: asm("nop"); ! 561: asm("nop"); ! 562: asm("nop"); ! 563: asm("addd _dbl_value_1"); /* add the op. ( 0 ) */ ! 564: asm("nop"); ! 565: asm("nop"); ! 566: asm("nop"); ! 567: asm("subd _dbl_value_2"); /* subtract a '0' ( 0 ) */ ! 568: asm("nop"); ! 569: asm("nop"); ! 570: asm("nop"); ! 571: asm("addd _dbl_value_1"); /* add the op. ( op ) */ ! 572: asm("nop"); ! 573: asm("nop"); ! 574: asm("nop"); ! 575: asm("std _dbl_st_acc"); /* store the result ( op ) */ ! 576: if( force_loop ) ! 577: asm("brb _pipe12_8_lp1");; /* run the loop again */ ! 578: /* ! 579: * verify the results ! 580: */ ! 581: if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */ ! 582: (dbl_st_acc.l != dbl_expected.l) ) ! 583: { ! 584: errcnt++; /* bump the error count */ ! 585: if ( prt_error ) ! 586: print_pipe12_er("Cache Data, 3 NO-OPs"); ! 587: if ( halt_flg ) /* halt on error? */ ! 588: pipe12_er_hlt( subtest ); ! 589: if ( loop_on_err ) { ! 590: force_loop = TRUE; /* set the force loop flag */ ! 591: asm("brw _pipe12_8_lp1"); /* and loop */ ! 592: } ! 593: } /* end of compare error */ ! 594: } while( index++ < max_ldd_1_index ); ! 595: } /* end of subtest 8 */ ! 596: ! 597: ! 598: ! 599: ! 600: ! 601: ! 602: ! 603: ! 604: /****************************************************************************** ! 605: * ! 606: * SUBTEST 9 ! 607: * ! 608: * Get the data via the FRAME POINTER ( quad word indexed ) ! 609: * ! 610: * ADDRESSES OF DATA OPERANDS INDEX DATA ! 611: * pointer_data,-4 ( FP+24 ) 3 the STF result goes here ! 612: * pointer_data-8,-12 ( FP+16 ) 2 <operand data> ! 613: * pointer_data-16,-20 ( FP+8 ) 1 < '0.0' data> ! 614: * pointer_data-24,-28 ( FP ) 0 point the frame pointer here ! 615: * ! 616: * NOTE: The double precision instructions are using Quad Word indexing. ! 617: ******************************************************************************/ ! 618: pipe12_9() ! 619: { ! 620: asm("moval (r13),_pre_event_fp"); /* save the frame pointer */ ! 621: asm("moval (r14),_pre_event_sp"); /* save the stack pointer */ ! 622: force_loop = FALSE; /* clear force_loop flag */ ! 623: index = 0; ! 624: do ! 625: { ! 626: sgl_value_1 = ldd_1_data[index].ld.m; /* get operand 1's MSW */ ! 627: sgl_value_2 = ldd_1_data[index].ld.l; /* get operand 1's LSW */ ! 628: dbl_expected = ldd_1_data[index].exp; /* get expected results */ ! 629: /* ! 630: * If LOOP ON ERROR is set, this is the loop for this subtest. ! 631: * The force loop flag is set after the first error. ! 632: */ ! 633: asm("_pipe12_9_lp1:"); ! 634: asm("moval _pointer_data,_sgl_value_9");/* get store data's addr */ ! 635: sgl_value_9 -= 8; ! 636: asm("movl _sgl_value_2,*_sgl_value_9");/* set the operand's LSW */ ! 637: sgl_value_9 -= 4; ! 638: asm("movl _sgl_value_1,*_sgl_value_9");/* set the operand's MSW */ ! 639: sgl_value_9 -= 4; ! 640: asm("clrl *_sgl_value_9"); /* set the '0' data's LSW */ ! 641: sgl_value_9 -= 4; ! 642: asm("clrl *_sgl_value_9"); /* set the '0' data's MSW */ ! 643: sgl_value_9 -= 8; /* get the FP addr to use */ ! 644: asm("movl _sgl_value_9,r13"); /* set the FRAME POINTER */ ! 645: asm("movl $1,r5"); /* r5 index = 1 quadwords */ ! 646: asm("movl $2,r6"); /* r6 index = 2 quadwords */ ! 647: asm("movl $3,r7"); /* r7 index = 3 quadwords */ ! 648: asm("ldd (r13)[r6]"); /* load the operand ( op ) */ ! 649: asm("subd (r13)[r6]"); /* subtract the op. ( 0 ) */ ! 650: asm("addd (r13)[r5]"); /* add a '0' ( 0 ) */ ! 651: asm("subd (r13)[r6]"); /* subtract the op. (-op ) */ ! 652: asm("addd (r13)[r6]"); /* add the op. ( 0 ) */ ! 653: asm("subd (r13)[r5]"); /* subtract a '0' ( 0 ) */ ! 654: asm("addd (r13)[r6]"); /* add the op. ( op ) */ ! 655: asm("std (r13)[r7]"); /* store the result ( op ) */ ! 656: if( force_loop ) ! 657: asm("brw _pipe12_9_lp1");; /* run the loop again */ ! 658: /* ! 659: * verify the results ! 660: */ ! 661: asm("moval (r13),_sgl_value_10"); /* save the frame pointer */ ! 662: asm("movl _pointer_data,_sgl_value_4"); /* save the LSW stored */ ! 663: asm("movl _pointer_data-4,_sgl_value_3"); /* and the MSW */ ! 664: if( (sgl_value_3 != dbl_expected.m) || /* verify the result... */ ! 665: (sgl_value_4 != dbl_expected.l) || /* verify the result... */ ! 666: (sgl_value_10 != sgl_value_9) ) /* ... and the final FP */ ! 667: { ! 668: asm("movl _pre_event_fp,r13"); /* restore frame pointer */ ! 669: asm("movl _pre_event_sp,r14"); /* restore stack pointer */ ! 670: errcnt++; /* bump the error count */ ! 671: if ( prt_error ) { ! 672: print_pipe12_er("indexed FP addressing"); ! 673: writes("final Frame Pointer = "); ! 674: write32h( sgl_value_10 ); ! 675: writes(", expected FP = "); ! 676: write32h( sgl_value_9 ); ! 677: writes(" \n"); ! 678: } ! 679: if ( halt_flg ) /* halt on error? */ ! 680: pipe12_er_hlt( subtest ); ! 681: if ( loop_on_err ) { ! 682: force_loop = TRUE; /* set the force loop flag */ ! 683: asm("brw _pipe12_9_lp1"); /* and loop */ ! 684: } ! 685: } /* end of compare error */ ! 686: } while( index++ < max_ldd_1_index ); ! 687: asm("movl _pre_event_fp,r13"); /* restore the frame pointer */ ! 688: asm("movl _pre_event_sp,r14"); /* restore the stack pointer */ ! 689: } /* end of subtest 9 */ ! 690: ! 691: ! 692: /****************************************************************************** ! 693: * ! 694: * ERROR ROUTINE ! 695: * ! 696: * print an error in the following form ! 697: * ! 698: *operand = xxxxxxxx xxxxxxxx, final Acc = xxxxxxxx xxxxxxxx, data index = dd ! 699: * expected Acc = xxxxxxxx xxxxxxxx ! 700: * ! 701: ******************************************************************************/ ! 702: print_pipe12_er(msg) ! 703: char *msg; ! 704: { ! 705: writes(" \n"); /* start a new print line */ ! 706: writes("cycle: "); ! 707: writed( cycle ); ! 708: writes(" test "); ! 709: writed( test_no ); ! 710: writes(" (Pipe 12), subtest "); ! 711: writed( subtest ); ! 712: writes(" error - "); ! 713: writes( msg ); ! 714: writec('\n'); ! 715: writes( ! 716: " LDD(op), SUBD(op), ADDD(0.0), SUBD(op), ADDD(op), SUBD(0.0), ADD(op), STD\n"); ! 717: writes("operand = "); ! 718: write32h( dbl_ld_acc.m ); ! 719: writec(' '); ! 720: write32h( dbl_ld_acc.l ); ! 721: writes(", final Acc = "); ! 722: write32h( dbl_st_acc.m ); ! 723: writec(' '); ! 724: write32h( dbl_st_acc.l ); ! 725: writes(", data index = "); ! 726: writed( index ); ! 727: writec('\n'); ! 728: writes(" expected Acc = "); ! 729: write32h( dbl_expected.m ); ! 730: writec(' '); ! 731: write32h( dbl_expected.l ); ! 732: writec('\n'); ! 733: } ! 734: ! 735: ! 736: ! 737: ! 738: ! 739: /****************************************************************************** ! 740: * ! 741: * HALT ON ERROR ROUTINE ! 742: * ! 743: * halt with the necessary information saved in the registers ! 744: * ! 745: ******************************************************************************/ ! 746: pipe12_er_hlt( subtest ) ! 747: int subtest; ! 748: { ! 749: sgl_value_3 = dbl_st_acc.m; ! 750: sgl_value_4 = dbl_st_acc.l; ! 751: asm("movl _test_no,r0"); /* r0 = test number */ ! 752: asm("movl _subtest,r1"); /* r1 = subtest number */ ! 753: asm("movl $1,r2"); /* r2 = error code */ ! 754: asm("movl _cycle,r3"); /* r3 = cycle count */ ! 755: asm("movl _sgl_value_1,r4"); /* r4 = MSW operand loaded */ ! 756: asm("movl _sgl_value_2,r5"); /* r5 = LSW operand loaded */ ! 757: asm("movl _sgl_value_3,r6"); /* r6 = MSW operand stored */ ! 758: asm("movl _sgl_value_4,r7"); /* r7 = LSW operand stored */ ! 759: asm("movl _sgl_value_5,r8"); /* r8 = MSW operand expect */ ! 760: asm("movl _sgl_value_6,r9"); /* r9 = LSW operand expect */ ! 761: asm("movl _index,r10"); /* r10 = data index */ ! 762: if( subtest == 9 ) { ! 763: asm("movl _sgl_value_10,r11"); /* r11 = final FP value */ ! 764: asm("movl _sgl_value_9,r12"); /* r12 = expected FP value */ ! 765: }; ! 766: asm(".globl _pipe12_1_hlt"); ! 767: asm("_pipe12_1_hlt:"); /* PC after the halt */ ! 768: asm("halt"); /* HALT ... */ ! 769: } /* end of halt on error */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.