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