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