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