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