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