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