![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe5.lst 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.lst CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / macro4 |
1.1 ! root 1: 1 00000000 LL0: ! 2: 2 00000000 .data ! 3: 3 00000d0c * .text ! 4: 4 00000000 .align 1 ! 5: 5 00000000 .globl _pipe_5 ! 6: 6 00000000 _pipe_5: ! 7: 7 000293A8 0000 .word L215 ! 8: 8 000293AA # #include "fpp_defs.h" ! 9: 9 000293AA # ! 10: 10 000293AA # ! 11: 11 000293AA # /***************************************************************************** ! 12: 12 000293AA # * ! 13: 13 000293AA # * PIPELINE TEST #5 MONITOR ! 14: 14 000293AA # * ! 15: 15 000293AA # * This test will do: ! 16: 16 000293AA # * ! 17: 17 000293AA # * LNF(x) STF LNF(0) SUBF(x) STF ! 18: 18 000293AA # * ! 19: 19 000293AA # * where x is the fmacro1 LNF data. This test verifies the store after the ! 20: 20 000293AA # * LNF and the LNF after the store. ! 21: 21 000293AA # *****************************************************************************/ ! 22: 22 000293AA # pipe_5() ! 23: 23 000293AA # { ! 24: 24 000293AA 13 00a8 jbr L217 ! 25: 25 000293AD L218: ! 26: 26 000293AD # asm(".globl _pipeline_5_t"); ! 27: 27 000293AD .globl _pipeline_5_t ! 28: 28 000293AD # asm("_pipeline_5_t:"); /* entry address */ ! 29: 29 000293AD _pipeline_5_t: ! 30: 30 000293AD # if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */ ! 31: 31 000293AD 1d effffffff5 01 cmpl _cycle,$1 ! 32: 32 000293B4 21 15 jneq L219 ! 33: 33 000293B6 5d efffffffec tstl _prt_hdrs ! 34: 34 000293BC 31 0d jeql L219 ! 35: 35 000293BE # { ! 36: 36 000293BE # writes(" PIPE_5 "); ! 37: 37 000293BE .data 1 ! 38: 38 00000d0c * L221: ! 39: 39 00000d0c * 20504950455F352000 .ascii " PIPE_5 \0" ! 40: 40 00000d15 * .text ! 41: 41 000293BE dd 8f00000d0c pushl $L221 ! 42: 42 000293C4 fe 08 efffffffdd callf $8,_writes ! 43: 43 000293CB # } ! 44: 44 000293CB # subtest = 1; ! 45: 45 000293CB L219: ! 46: 46 000293CB 0d 01 efffffffd6 movl $1,_subtest ! 47: 47 000293D2 # pipe5_1(); /* data in REGs, no NOPs */ ! 48: 48 000293D2 fe 04 ef0000007f callf $4,_pipe5_1 ! 49: 49 000293D9 # subtest++; /* increment subtest num */ ! 50: 50 000293D9 6d efffffffc9 incl _subtest ! 51: 51 000293DF # pipe5_2(); /* data in REGs, 1 NOP */ ! 52: 52 000293DF fe 04 ef0000015e callf $4,_pipe5_2 ! 53: 53 000293E6 # subtest++; /* increment subtest num */ ! 54: 54 000293E6 6d efffffffbc incl _subtest ! 55: 55 000293EC # pipe5_3(); /* data in REGs, 2 NOPs */ ! 56: 56 000293EC fe 04 ef00000241 callf $4,_pipe5_3 ! 57: 57 000293F3 # subtest++; /* increment subtest num */ ! 58: 58 000293F3 6d efffffffaf incl _subtest ! 59: 59 000293F9 # pipe5_4(); /* data in REGs, 3 NOPs */ ! 60: 60 000293F9 fe 04 ef00000328 callf $4,_pipe5_4 ! 61: 61 00029400 # subtest++; /* increment subtest num */ ! 62: 62 00029400 6d efffffffa2 incl _subtest ! 63: 63 00029406 # pipe5_5(); /* data in CACHE, no NOPs */ ! 64: 64 00029406 fe 04 ef00000413 callf $4,_pipe5_5 ! 65: 65 0002940D # subtest++; /* increment subtest num */ ! 66: 66 0002940D 6d efffffff95 incl _subtest ! 67: 67 00029413 # pipe5_6(); /* data in CACHE, 1 NOP */ ! 68: 68 00029413 fe 04 ef000004ea callf $4,_pipe5_6 ! 69: 69 0002941A # subtest++; /* increment subtest num */ ! 70: 70 0002941A 6d efffffff88 incl _subtest ! 71: 71 00029420 # pipe5_7(); /* data in CACHE, 2 NOPs */ ! 72: 72 00029420 fe 04 ef000005c5 callf $4,_pipe5_7 ! 73: 73 00029427 # subtest++; /* increment subtest num */ ! 74: 74 00029427 6d efffffff7b incl _subtest ! 75: 75 0002942D # pipe5_8(); /* data in CACHE, 3 NOPs */ ! 76: 76 0002942D fe 04 ef000006a4 callf $4,_pipe5_8 ! 77: 77 00029434 # subtest++; /* increment subtest num */ ! 78: 78 00029434 6d efffffff6e incl _subtest ! 79: 79 0002943A # pipe5_9(); /* data on STACK, no NOPs */ ! 80: 80 0002943A fe 04 ef00000787 callf $4,_pipe5_9 ! 81: 81 00029441 # subtest++; /* increment subtest num */ ! 82: 82 00029441 6d efffffff61 incl _subtest ! 83: 83 00029447 # pipe5_10(); /* data via FP no NOPs */ ! 84: 84 00029447 fe 04 ef00000902 callf $4,_pipe5_10 ! 85: 85 0002944E # asm("jmp *return"); /* return to the test monitor */ ! 86: 86 0002944E 71 ffffffff54 jmp *return ! 87: 87 00029454 # } ! 88: 88 00029454 40 ret#2 ! 89: 89 00029455 .set L215,0x0 ! 90: 90 00029455 L217: ! 91: 91 00029455 13 ff55 jbr L218 ! 92: 92 00029458 .data ! 93: 93 00000d0c * .text ! 94: 94 00029458 .align 1 ! 95: 95 00029458 .globl _pipe5_1 ! 96: 96 00029458 _pipe5_1: ! 97: 97 00029458 0000 .word L232 ! 98: 98 0002945A # ! 99: 99 0002945A # ! 100: 100 0002945A # ! 101: 101 0002945A # ! 102: 102 0002945A # ! 103: 103 0002945A # ! 104: 104 0002945A # /************************************************************************ ! 105: 105 0002945A # * ! 106: 106 0002945A # * SUBTEST 1 ! 107: 107 0002945A # * data in registers, no NO-OPs ! 108: 108 0002945A # * ! 109: 109 0002945A # ************************************************************************/ ! 110: 110 0002945A # pipe5_1() ! 111: 111 0002945A # { ! 112: 112 0002945A 13 00e4 jbr L234 ! 113: 113 0002945D L235: ! 114: 114 0002945D # force_loop = FALSE; /* clear force_loop flag */ ! 115: 115 0002945D 4d efffffff45 clrl _force_loop ! 116: 116 00029463 # index = 0; ! 117: 117 00029463 4d efffffff3f clrl _index ! 118: 118 00029469 # do ! 119: 119 00029469 L238: ! 120: 120 00029469 # { ! 121: 121 00029469 # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */ ! 122: 122 00029469 0d efffffff39 50 movl _index,r0 ! 123: 123 00029470 48 03 50 50 shll $3,r0,r0 ! 124: 124 00029474 0d e000000000 efffffff29 movl _lnf_1_data(r0),_sgl_value_1 ! 125: 125 0002947F # sgl_expected = lnf_1_data[index].exp; /* get expected results */ ! 126: 126 0002947F 0d efffffff23 50 movl _index,r0 ! 127: 127 00029486 48 03 50 50 shll $3,r0,r0 ! 128: 128 0002948A 0d e000000004 efffffff13 movl _lnf_1_data+4(r0),_sgl_expected ! 129: 129 00029495 # sgl_value_2 = 0; /* floating '0' */ ! 130: 130 00029495 4d efffffff0d clrl _sgl_value_2 ! 131: 131 0002949B # /* ! 132: 132 0002949B # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 133: 133 0002949B # * The force loop flag is set after the first error. ! 134: 134 0002949B # */ ! 135: 135 0002949B # asm("_pipe5_1_lp1:"); ! 136: 136 0002949B _pipe5_1_lp1: ! 137: 137 0002949B # asm("movl _sgl_value_1,r4"); /* move the data to r4 */ ! 138: 138 0002949B 0d efffffff07 54 movl _sgl_value_1,r4 ! 139: 139 000294A2 # asm("movl _sgl_value_2,r5"); /* move data to r5 */ ! 140: 140 000294A2 0d efffffff00 55 movl _sgl_value_2,r5 ! 141: 141 000294A9 # asm("lnf r4"); /* load the operand */ ! 142: 142 000294A9 16 54 lnf r4 ! 143: 143 000294AB # asm("stf r7"); /* store the result */ ! 144: 144 000294AB 26 57 stf r7 ! 145: 145 000294AD # asm("lnf r5"); /* load a floating '0' */ ! 146: 146 000294AD 16 55 lnf r5 ! 147: 147 000294AF # asm("subf r4"); /* subtract the operand */ ! 148: 148 000294AF d6 54 subf r4 ! 149: 149 000294B1 # asm("stf r8"); /* store the result */ ! 150: 150 000294B1 26 58 stf r8 ! 151: 151 000294B3 # if( force_loop ) ! 152: 152 000294B3 5d effffffeef tstl _force_loop ! 153: 153 000294B9 31 02 jeql L239 ! 154: 154 000294BB # asm("brb _pipe5_1_lp1");; /* loop on the error */ ! 155: 155 000294BB 11 de brb _pipe5_1_lp1 ! 156: 156 000294BD L239: ! 157: 157 000294BD # /* ! 158: 158 000294BD # * verify the results ! 159: 159 000294BD # */ ! 160: 160 000294BD # asm("movl r7,_sgl_st_acc"); /* get the 1st store value */ ! 161: 161 000294BD 0d 57 effffffee4 movl r7,_sgl_st_acc ! 162: 162 000294C4 # asm("movl r8,_sgl_value_6"); /* get the 2nd store value */ ! 163: 163 000294C4 0d 58 effffffedd movl r8,_sgl_value_6 ! 164: 164 000294CB # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */ ! 165: 165 000294CB # (sgl_value_6 != sgl_expected) ) ! 166: 166 000294CB 1d effffffed7 effffffed2 cmpl _sgl_st_acc,_sgl_expected ! 167: 167 000294D6 21 0d jneq L9999 ! 168: 168 000294D8 1d effffffeca effffffec5 cmpl _sgl_value_6,_sgl_expected ! 169: 169 000294E3 31 42 jeql L240 ! 170: 170 000294E5 L9999: ! 171: 171 000294E5 # { ! 172: 172 000294E5 # errcnt++; /* bump the error count */ ! 173: 173 000294E5 6d effffffebd incl _errcnt ! 174: 174 000294EB # if ( prt_error ) ! 175: 175 000294EB 5d effffffeb7 tstl _prt_error ! 176: 176 000294F1 31 0d jeql L241 ! 177: 177 000294F3 # print_pipe5_er("Reg. Data, no NO-OPs"); ! 178: 178 000294F3 .data 1 ! 179: 179 00000d15 * L243: ! 180: 180 00000d15 * 5265672E20446174612C206E6 .ascii "Reg. Data, no NO-OPs\0" ! 181: F204E4F2D4F507300 ! 182: 181 00000d2a * .text ! 183: 182 000294F3 dd 8f00000d15 pushl $L243 ! 184: 183 000294F9 fe 08 ef00000a18 callf $8,_print_pipe5_er ! 185: 184 00029500 # if ( halt_flg ) ! 186: 185 00029500 L241: ! 187: 186 00029500 5d effffffea2 tstl _halt_flg ! 188: 187 00029506 31 0d jeql L244 ! 189: 188 00029508 # pipe5_er_hlt( subtest ); ! 190: 189 00029508 dd effffffe9a pushl _subtest ! 191: 190 0002950E fe 08 ef00000b29 callf $8,_pipe5_er_hlt ! 192: 191 00029515 # if ( loop_on_err ) { ! 193: 192 00029515 L244: ! 194: 193 00029515 5d effffffe8d tstl _loop_on_err ! 195: 194 0002951B 31 0a jeql L246 ! 196: 195 0002951D # force_loop = TRUE; /* set the force loop flag */ ! 197: 196 0002951D 0d 01 effffffe84 movl $1,_force_loop ! 198: 197 00029524 # asm("brw _pipe5_1_lp1"); /* and loop */ ! 199: 198 00029524 13 ff74 brw _pipe5_1_lp1 ! 200: 199 00029527 # } ! 201: 200 00029527 # } /* end of compare error */ ! 202: 201 00029527 L246: ! 203: 202 00029527 # } while( index++ < max_lnf_1_index ); ! 204: 203 00029527 L240: ! 205: 204 00029527 L237: ! 206: 205 00029527 0d effffffe7b 50 movl _index,r0 ! 207: 206 0002952E 6d effffffe74 incl _index ! 208: 207 00029534 1d 50 effffffe6d cmpl r0,_max_lnf_1_index ! 209: 208 0002953B 81 03 13 ff29 jlss L238 ! 210: 209 00029540 L236: ! 211: 210 00029540 # } /* end of subtest 1 */ ! 212: 211 00029540 40 ret#2 ! 213: 212 00029541 .set L232,0x0 ! 214: 213 00029541 L234: ! 215: 214 00029541 13 ff19 jbr L235 ! 216: 215 00029544 .data ! 217: 216 00000d0c * .text ! 218: 217 00029544 .align 1 ! 219: 218 00029544 .globl _pipe5_2 ! 220: 219 00029544 _pipe5_2: ! 221: 220 00029544 0000 .word L247 ! 222: 221 00029546 # ! 223: 222 00029546 # ! 224: 223 00029546 # ! 225: 224 00029546 # ! 226: 225 00029546 # ! 227: 226 00029546 # ! 228: 227 00029546 # /************************************************************************ ! 229: 228 00029546 # * ! 230: 229 00029546 # * SUBTEST 2 ! 231: 230 00029546 # * data in registers, 1 NO-OP ! 232: 231 00029546 # * ! 233: 232 00029546 # ************************************************************************/ ! 234: 233 00029546 # pipe5_2() ! 235: 234 00029546 # { ! 236: 235 00029546 13 00e8 jbr L249 ! 237: 236 00029549 L250: ! 238: 237 00029549 # force_loop = FALSE; /* clear force_loop flag */ ! 239: 238 00029549 4d effffffe59 clrl _force_loop ! 240: 239 0002954F # index = 0; ! 241: 240 0002954F 4d effffffe53 clrl _index ! 242: 241 00029555 # do ! 243: 242 00029555 L253: ! 244: 243 00029555 # { ! 245: 244 00029555 # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */ ! 246: 245 00029555 0d effffffe4d 50 movl _index,r0 ! 247: 246 0002955C 48 03 50 50 shll $3,r0,r0 ! 248: 247 00029560 0d e000000000 effffffe3d movl _lnf_1_data(r0),_sgl_value_1 ! 249: 248 0002956B # sgl_expected = lnf_1_data[index].exp; /* get expected results */ ! 250: 249 0002956B 0d effffffe37 50 movl _index,r0 ! 251: 250 00029572 48 03 50 50 shll $3,r0,r0 ! 252: 251 00029576 0d e000000004 effffffe27 movl _lnf_1_data+4(r0),_sgl_expected ! 253: 252 00029581 # sgl_value_2 = 0x00000000; /* floating '0' */ ! 254: 253 00029581 4d effffffe21 clrl _sgl_value_2 ! 255: 254 00029587 # /* ! 256: 255 00029587 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 257: 256 00029587 # * The force loop flag is set after the first error. ! 258: 257 00029587 # */ ! 259: 258 00029587 # asm("_pipe5_2_lp1:"); ! 260: 259 00029587 _pipe5_2_lp1: ! 261: 260 00029587 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */ ! 262: 261 00029587 0d effffffe1b 54 movl _sgl_value_1,r4 ! 263: 262 0002958E # asm("movl _sgl_value_2,r5"); /* move data to r5 */ ! 264: 263 0002958E 0d effffffe14 55 movl _sgl_value_2,r5 ! 265: 264 00029595 # asm("lnf r4"); /* load the operand */ ! 266: 265 00029595 16 54 lnf r4 ! 267: 266 00029597 # asm("nop"); ! 268: 267 00029597 10 nop ! 269: 268 00029598 # asm("stf r7"); /* store the result */ ! 270: 269 00029598 26 57 stf r7 ! 271: 270 0002959A # asm("nop"); ! 272: 271 0002959A 10 nop ! 273: 272 0002959B # asm("lnf r5"); /* load a floating '0' */ ! 274: 273 0002959B 16 55 lnf r5 ! 275: 274 0002959D # asm("nop"); ! 276: 275 0002959D 10 nop ! 277: 276 0002959E # asm("subf r4"); /* subtract the operand */ ! 278: 277 0002959E d6 54 subf r4 ! 279: 278 000295A0 # asm("nop"); ! 280: 279 000295A0 10 nop ! 281: 280 000295A1 # asm("stf r8"); /* store the result */ ! 282: 281 000295A1 26 58 stf r8 ! 283: 282 000295A3 # if( force_loop ) ! 284: 283 000295A3 5d effffffdff tstl _force_loop ! 285: 284 000295A9 31 02 jeql L254 ! 286: 285 000295AB # asm("brb _pipe5_2_lp1");; /* loop on the error */ ! 287: 286 000295AB 11 da brb _pipe5_2_lp1 ! 288: 287 000295AD L254: ! 289: 288 000295AD # /* ! 290: 289 000295AD # * verify the results ! 291: 290 000295AD # */ ! 292: 291 000295AD # asm("movl r7,_sgl_st_acc"); /* get the 1st store value */ ! 293: 292 000295AD 0d 57 effffffdf4 movl r7,_sgl_st_acc ! 294: 293 000295B4 # asm("movl r8,_sgl_value_6"); /* get the 2nd store value */ ! 295: 294 000295B4 0d 58 effffffded movl r8,_sgl_value_6 ! 296: 295 000295BB # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */ ! 297: 296 000295BB # (sgl_value_6 != sgl_expected) ) ! 298: 297 000295BB 1d effffffde7 effffffde2 cmpl _sgl_st_acc,_sgl_expected ! 299: 298 000295C6 21 0d jneq L9998 ! 300: 299 000295C8 1d effffffdda effffffdd5 cmpl _sgl_value_6,_sgl_expected ! 301: 300 000295D3 31 42 jeql L255 ! 302: 301 000295D5 L9998: ! 303: 302 000295D5 # { ! 304: 303 000295D5 # errcnt++; /* bump the error count */ ! 305: 304 000295D5 6d effffffdcd incl _errcnt ! 306: 305 000295DB # if ( prt_error ) ! 307: 306 000295DB 5d effffffdc7 tstl _prt_error ! 308: 307 000295E1 31 0d jeql L256 ! 309: 308 000295E3 # print_pipe5_er("Reg. Data, 1 NO-OP"); ! 310: 309 000295E3 .data 1 ! 311: 310 00000d2a * L257: ! 312: 311 00000d2a * 5265672E20446174612C20312 .ascii "Reg. Data, 1 NO-OP\0" ! 313: 04E4F2D4F5000 ! 314: 312 00000d3d * .text ! 315: 313 000295E3 dd 8f00000d2a pushl $L257 ! 316: 314 000295E9 fe 08 ef00000928 callf $8,_print_pipe5_er ! 317: 315 000295F0 # if ( halt_flg ) ! 318: 316 000295F0 L256: ! 319: 317 000295F0 5d effffffdb2 tstl _halt_flg ! 320: 318 000295F6 31 0d jeql L258 ! 321: 319 000295F8 # pipe5_er_hlt( subtest ); ! 322: 320 000295F8 dd effffffdaa pushl _subtest ! 323: 321 000295FE fe 08 ef00000a39 callf $8,_pipe5_er_hlt ! 324: 322 00029605 # if ( loop_on_err ) { ! 325: 323 00029605 L258: ! 326: 324 00029605 5d effffffd9d tstl _loop_on_err ! 327: 325 0002960B 31 0a jeql L259 ! 328: 326 0002960D # force_loop = TRUE; /* set the force loop flag */ ! 329: 327 0002960D 0d 01 effffffd94 movl $1,_force_loop ! 330: 328 00029614 # asm("brw _pipe5_2_lp1"); /* and loop */ ! 331: 329 00029614 13 ff70 brw _pipe5_2_lp1 ! 332: 330 00029617 # } ! 333: 331 00029617 # } /* end of compare error */ ! 334: 332 00029617 L259: ! 335: 333 00029617 # } while( index++ < max_lnf_1_index ); ! 336: 334 00029617 L255: ! 337: 335 00029617 L252: ! 338: 336 00029617 0d effffffd8b 50 movl _index,r0 ! 339: 337 0002961E 6d effffffd84 incl _index ! 340: 338 00029624 1d 50 effffffd7d cmpl r0,_max_lnf_1_index ! 341: 339 0002962B 81 03 13 ff25 jlss L253 ! 342: 340 00029630 L251: ! 343: 341 00029630 # } /* end of subtest 2 */ ! 344: 342 00029630 40 ret#2 ! 345: 343 00029631 .set L247,0x0 ! 346: 344 00029631 L249: ! 347: 345 00029631 13 ff15 jbr L250 ! 348: 346 00029634 .data ! 349: 347 00000d0c * .text ! 350: 348 00029634 .align 1 ! 351: 349 00029634 .globl _pipe5_3 ! 352: 350 00029634 _pipe5_3: ! 353: 351 00029634 0000 .word L260 ! 354: 352 00029636 # ! 355: 353 00029636 # ! 356: 354 00029636 # ! 357: 355 00029636 # ! 358: 356 00029636 # ! 359: 357 00029636 # ! 360: 358 00029636 # /************************************************************************ ! 361: 359 00029636 # * ! 362: 360 00029636 # * SUBTEST 3 ! 363: 361 00029636 # * data in registers, 2 NO-OPs ! 364: 362 00029636 # * ! 365: 363 00029636 # ************************************************************************/ ! 366: 364 00029636 # pipe5_3() ! 367: 365 00029636 # { ! 368: 366 00029636 13 00ec jbr L262 ! 369: 367 00029639 L263: ! 370: 368 00029639 # force_loop = FALSE; /* clear force_loop flag */ ! 371: 369 00029639 4d effffffd69 clrl _force_loop ! 372: 370 0002963F # index = 0; ! 373: 371 0002963F 4d effffffd63 clrl _index ! 374: 372 00029645 # do ! 375: 373 00029645 L266: ! 376: 374 00029645 # { ! 377: 375 00029645 # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */ ! 378: 376 00029645 0d effffffd5d 50 movl _index,r0 ! 379: 377 0002964C 48 03 50 50 shll $3,r0,r0 ! 380: 378 00029650 0d e000000000 effffffd4d movl _lnf_1_data(r0),_sgl_value_1 ! 381: 379 0002965B # sgl_expected = lnf_1_data[index].exp; /* get expected results */ ! 382: 380 0002965B 0d effffffd47 50 movl _index,r0 ! 383: 381 00029662 48 03 50 50 shll $3,r0,r0 ! 384: 382 00029666 0d e000000004 effffffd37 movl _lnf_1_data+4(r0),_sgl_expected ! 385: 383 00029671 # sgl_value_2 = 0x00000000; /* floating '0' */ ! 386: 384 00029671 4d effffffd31 clrl _sgl_value_2 ! 387: 385 00029677 # /* ! 388: 386 00029677 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 389: 387 00029677 # * The force loop flag is set after the first error. ! 390: 388 00029677 # */ ! 391: 389 00029677 # asm("_pipe5_3_lp1:"); ! 392: 390 00029677 _pipe5_3_lp1: ! 393: 391 00029677 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */ ! 394: 392 00029677 0d effffffd2b 54 movl _sgl_value_1,r4 ! 395: 393 0002967E # asm("movl _sgl_value_2,r5"); /* move data to r5 */ ! 396: 394 0002967E 0d effffffd24 55 movl _sgl_value_2,r5 ! 397: 395 00029685 # asm("lnf r4"); /* load the operand */ ! 398: 396 00029685 16 54 lnf r4 ! 399: 397 00029687 # asm("nop"); ! 400: 398 00029687 10 nop ! 401: 399 00029688 # asm("nop"); ! 402: 400 00029688 10 nop ! 403: 401 00029689 # asm("stf r7"); /* store the result */ ! 404: 402 00029689 26 57 stf r7 ! 405: 403 0002968B # asm("nop"); ! 406: 404 0002968B 10 nop ! 407: 405 0002968C # asm("nop"); ! 408: 406 0002968C 10 nop ! 409: 407 0002968D # asm("lnf r5"); /* load a floating '0' */ ! 410: 408 0002968D 16 55 lnf r5 ! 411: 409 0002968F # asm("nop"); ! 412: 410 0002968F 10 nop ! 413: 411 00029690 # asm("nop"); ! 414: 412 00029690 10 nop ! 415: 413 00029691 # asm("subf r4"); /* subtract the operand */ ! 416: 414 00029691 d6 54 subf r4 ! 417: 415 00029693 # asm("nop"); ! 418: 416 00029693 10 nop ! 419: 417 00029694 # asm("nop"); ! 420: 418 00029694 10 nop ! 421: 419 00029695 # asm("stf r8"); /* store the result */ ! 422: 420 00029695 26 58 stf r8 ! 423: 421 00029697 # if( force_loop ) ! 424: 422 00029697 5d effffffd0b tstl _force_loop ! 425: 423 0002969D 31 02 jeql L267 ! 426: 424 0002969F # asm("brb _pipe5_3_lp1");; /* loop on the error */ ! 427: 425 0002969F 11 d6 brb _pipe5_3_lp1 ! 428: 426 000296A1 L267: ! 429: 427 000296A1 # /* ! 430: 428 000296A1 # * verify the results ! 431: 429 000296A1 # */ ! 432: 430 000296A1 # asm("movl r7,_sgl_st_acc"); /* get the 1st store value */ ! 433: 431 000296A1 0d 57 effffffd00 movl r7,_sgl_st_acc ! 434: 432 000296A8 # asm("movl r8,_sgl_value_6"); /* get the 2nd store value */ ! 435: 433 000296A8 0d 58 effffffcf9 movl r8,_sgl_value_6 ! 436: 434 000296AF # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */ ! 437: 435 000296AF # (sgl_value_6 != sgl_expected) ) ! 438: 436 000296AF 1d effffffcf3 effffffcee cmpl _sgl_st_acc,_sgl_expected ! 439: 437 000296BA 21 0d jneq L9997 ! 440: 438 000296BC 1d effffffce6 effffffce1 cmpl _sgl_value_6,_sgl_expected ! 441: 439 000296C7 31 42 jeql L268 ! 442: 440 000296C9 L9997: ! 443: 441 000296C9 # { ! 444: 442 000296C9 # errcnt++; /* bump the error count */ ! 445: 443 000296C9 6d effffffcd9 incl _errcnt ! 446: 444 000296CF # if ( prt_error ) ! 447: 445 000296CF 5d effffffcd3 tstl _prt_error ! 448: 446 000296D5 31 0d jeql L269 ! 449: 447 000296D7 # print_pipe5_er("Reg. Data, 2 NO-OPs"); ! 450: 448 000296D7 .data 1 ! 451: 449 00000d3d * L270: ! 452: 450 00000d3d * 5265672E20446174612C20322 .ascii "Reg. Data, 2 NO-OPs\0" ! 453: 04E4F2D4F507300 ! 454: 451 00000d51 * .text ! 455: 452 000296D7 dd 8f00000d3d pushl $L270 ! 456: 453 000296DD fe 08 ef00000834 callf $8,_print_pipe5_er ! 457: 454 000296E4 # if ( halt_flg ) ! 458: 455 000296E4 L269: ! 459: 456 000296E4 5d effffffcbe tstl _halt_flg ! 460: 457 000296EA 31 0d jeql L271 ! 461: 458 000296EC # pipe5_er_hlt( subtest ); ! 462: 459 000296EC dd effffffcb6 pushl _subtest ! 463: 460 000296F2 fe 08 ef00000945 callf $8,_pipe5_er_hlt ! 464: 461 000296F9 # if ( loop_on_err ) { ! 465: 462 000296F9 L271: ! 466: 463 000296F9 5d effffffca9 tstl _loop_on_err ! 467: 464 000296FF 31 0a jeql L272 ! 468: 465 00029701 # force_loop = TRUE; /* set the force loop flag */ ! 469: 466 00029701 0d 01 effffffca0 movl $1,_force_loop ! 470: 467 00029708 # asm("brw _pipe5_3_lp1"); /* and loop */ ! 471: 468 00029708 13 ff6c brw _pipe5_3_lp1 ! 472: 469 0002970B # } ! 473: 470 0002970B # } /* end of compare error */ ! 474: 471 0002970B L272: ! 475: 472 0002970B # } while( index++ < max_lnf_1_index ); ! 476: 473 0002970B L268: ! 477: 474 0002970B L265: ! 478: 475 0002970B 0d effffffc97 50 movl _index,r0 ! 479: 476 00029712 6d effffffc90 incl _index ! 480: 477 00029718 1d 50 effffffc89 cmpl r0,_max_lnf_1_index ! 481: 478 0002971F 81 03 13 ff21 jlss L266 ! 482: 479 00029724 L264: ! 483: 480 00029724 # } /* end of subtest 3 */ ! 484: 481 00029724 40 ret#2 ! 485: 482 00029725 .set L260,0x0 ! 486: 483 00029725 L262: ! 487: 484 00029725 13 ff11 jbr L263 ! 488: 485 00029728 .data ! 489: 486 00000d0c * .text ! 490: 487 00029728 .align 1 ! 491: 488 00029728 .globl _pipe5_4 ! 492: 489 00029728 _pipe5_4: ! 493: 490 00029728 0000 .word L273 ! 494: 491 0002972A # ! 495: 492 0002972A # ! 496: 493 0002972A # ! 497: 494 0002972A # ! 498: 495 0002972A # ! 499: 496 0002972A # ! 500: 497 0002972A # /************************************************************************ ! 501: 498 0002972A # * ! 502: 499 0002972A # * SUBTEST 4 ! 503: 500 0002972A # * data in registers, 3 NO-OPs ! 504: 501 0002972A # * ! 505: 502 0002972A # ************************************************************************/ ! 506: 503 0002972A # pipe5_4() ! 507: 504 0002972A # { ! 508: 505 0002972A 13 00f0 jbr L275 ! 509: 506 0002972D L276: ! 510: 507 0002972D # force_loop = FALSE; /* clear force_loop flag */ ! 511: 508 0002972D 4d effffffc75 clrl _force_loop ! 512: 509 00029733 # index = 0; ! 513: 510 00029733 4d effffffc6f clrl _index ! 514: 511 00029739 # do ! 515: 512 00029739 L279: ! 516: 513 00029739 # { ! 517: 514 00029739 # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */ ! 518: 515 00029739 0d effffffc69 50 movl _index,r0 ! 519: 516 00029740 48 03 50 50 shll $3,r0,r0 ! 520: 517 00029744 0d e000000000 effffffc59 movl _lnf_1_data(r0),_sgl_value_1 ! 521: 518 0002974F # sgl_expected = lnf_1_data[index].exp; /* get expected results */ ! 522: 519 0002974F 0d effffffc53 50 movl _index,r0 ! 523: 520 00029756 48 03 50 50 shll $3,r0,r0 ! 524: 521 0002975A 0d e000000004 effffffc43 movl _lnf_1_data+4(r0),_sgl_expected ! 525: 522 00029765 # sgl_value_2 = 0x00000000; /* floating '0' */ ! 526: 523 00029765 4d effffffc3d clrl _sgl_value_2 ! 527: 524 0002976B # /* ! 528: 525 0002976B # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 529: 526 0002976B # * The force loop flag is set after the first error. ! 530: 527 0002976B # */ ! 531: 528 0002976B # asm("_pipe5_4_lp1:"); ! 532: 529 0002976B _pipe5_4_lp1: ! 533: 530 0002976B # asm("movl _sgl_value_1,r4"); /* move the data to r4 */ ! 534: 531 0002976B 0d effffffc37 54 movl _sgl_value_1,r4 ! 535: 532 00029772 # asm("movl _sgl_value_2,r5"); /* move data to r5 */ ! 536: 533 00029772 0d effffffc30 55 movl _sgl_value_2,r5 ! 537: 534 00029779 # asm("lnf r4"); /* load the operand */ ! 538: 535 00029779 16 54 lnf r4 ! 539: 536 0002977B # asm("nop"); ! 540: 537 0002977B 10 nop ! 541: 538 0002977C # asm("nop"); ! 542: 539 0002977C 10 nop ! 543: 540 0002977D # asm("nop"); ! 544: 541 0002977D 10 nop ! 545: 542 0002977E # asm("stf r7"); /* store the result */ ! 546: 543 0002977E 26 57 stf r7 ! 547: 544 00029780 # asm("nop"); ! 548: 545 00029780 10 nop ! 549: 546 00029781 # asm("nop"); ! 550: 547 00029781 10 nop ! 551: 548 00029782 # asm("nop"); ! 552: 549 00029782 10 nop ! 553: 550 00029783 # asm("lnf r5"); /* load a floating '0' */ ! 554: 551 00029783 16 55 lnf r5 ! 555: 552 00029785 # asm("nop"); ! 556: 553 00029785 10 nop ! 557: 554 00029786 # asm("nop"); ! 558: 555 00029786 10 nop ! 559: 556 00029787 # asm("nop"); ! 560: 557 00029787 10 nop ! 561: 558 00029788 # asm("subf r4"); /* subtract the operand */ ! 562: 559 00029788 d6 54 subf r4 ! 563: 560 0002978A # asm("nop"); ! 564: 561 0002978A 10 nop ! 565: 562 0002978B # asm("nop"); ! 566: 563 0002978B 10 nop ! 567: 564 0002978C # asm("nop"); ! 568: 565 0002978C 10 nop ! 569: 566 0002978D # asm("stf r8"); /* store the result */ ! 570: 567 0002978D 26 58 stf r8 ! 571: 568 0002978F # if( force_loop ) ! 572: 569 0002978F 5d effffffc13 tstl _force_loop ! 573: 570 00029795 31 02 jeql L280 ! 574: 571 00029797 # asm("brb _pipe5_4_lp1");; /* loop on the error */ ! 575: 572 00029797 11 d2 brb _pipe5_4_lp1 ! 576: 573 00029799 L280: ! 577: 574 00029799 # /* ! 578: 575 00029799 # * verify the results ! 579: 576 00029799 # */ ! 580: 577 00029799 # asm("movl r7,_sgl_st_acc"); /* get the 1st store value */ ! 581: 578 00029799 0d 57 effffffc08 movl r7,_sgl_st_acc ! 582: 579 000297A0 # asm("movl r8,_sgl_value_6"); /* get the 2nd store value */ ! 583: 580 000297A0 0d 58 effffffc01 movl r8,_sgl_value_6 ! 584: 581 000297A7 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */ ! 585: 582 000297A7 # (sgl_value_6 != sgl_expected) ) ! 586: 583 000297A7 1d effffffbfb effffffbf6 cmpl _sgl_st_acc,_sgl_expected ! 587: 584 000297B2 21 0d jneq L9996 ! 588: 585 000297B4 1d effffffbee effffffbe9 cmpl _sgl_value_6,_sgl_expected ! 589: 586 000297BF 31 42 jeql L281 ! 590: 587 000297C1 L9996: ! 591: 588 000297C1 # { ! 592: 589 000297C1 # errcnt++; /* bump the error count */ ! 593: 590 000297C1 6d effffffbe1 incl _errcnt ! 594: 591 000297C7 # if ( prt_error ) ! 595: 592 000297C7 5d effffffbdb tstl _prt_error ! 596: 593 000297CD 31 0d jeql L282 ! 597: 594 000297CF # print_pipe5_er("Reg. Data, 3 NO-OPs"); ! 598: 595 000297CF .data 1 ! 599: 596 00000d51 * L283: ! 600: 597 00000d51 * 5265672E20446174612C20332 .ascii "Reg. Data, 3 NO-OPs\0" ! 601: 04E4F2D4F507300 ! 602: 598 00000d65 * .text ! 603: 599 000297CF dd 8f00000d51 pushl $L283 ! 604: 600 000297D5 fe 08 ef0000073c callf $8,_print_pipe5_er ! 605: 601 000297DC # if ( halt_flg ) ! 606: 602 000297DC L282: ! 607: 603 000297DC 5d effffffbc6 tstl _halt_flg ! 608: 604 000297E2 31 0d jeql L284 ! 609: 605 000297E4 # pipe5_er_hlt( subtest ); ! 610: 606 000297E4 dd effffffbbe pushl _subtest ! 611: 607 000297EA fe 08 ef0000084d callf $8,_pipe5_er_hlt ! 612: 608 000297F1 # if ( loop_on_err ) { ! 613: 609 000297F1 L284: ! 614: 610 000297F1 5d effffffbb1 tstl _loop_on_err ! 615: 611 000297F7 31 0a jeql L285 ! 616: 612 000297F9 # force_loop = TRUE; /* set the force loop flag */ ! 617: 613 000297F9 0d 01 effffffba8 movl $1,_force_loop ! 618: 614 00029800 # asm("brw _pipe5_4_lp1"); /* and loop */ ! 619: 615 00029800 13 ff68 brw _pipe5_4_lp1 ! 620: 616 00029803 # } ! 621: 617 00029803 # } /* end of compare error */ ! 622: 618 00029803 L285: ! 623: 619 00029803 # } while( index++ < max_lnf_1_index ); ! 624: 620 00029803 L281: ! 625: 621 00029803 L278: ! 626: 622 00029803 0d effffffb9f 50 movl _index,r0 ! 627: 623 0002980A 6d effffffb98 incl _index ! 628: 624 00029810 1d 50 effffffb91 cmpl r0,_max_lnf_1_index ! 629: 625 00029817 81 03 13 ff1d jlss L279 ! 630: 626 0002981C L277: ! 631: 627 0002981C # } /* end of subtest 4 */ ! 632: 628 0002981C 40 ret#2 ! 633: 629 0002981D .set L273,0x0 ! 634: 630 0002981D L275: ! 635: 631 0002981D 13 ff0d jbr L276 ! 636: 632 00029820 .data ! 637: 633 00000d0c * .text ! 638: 634 00029820 .align 1 ! 639: 635 00029820 .globl _pipe5_5 ! 640: 636 00029820 _pipe5_5: ! 641: 637 00029820 0000 .word L286 ! 642: 638 00029822 # ! 643: 639 00029822 # ! 644: 640 00029822 # ! 645: 641 00029822 # ! 646: 642 00029822 # ! 647: 643 00029822 # ! 648: 644 00029822 # ! 649: 645 00029822 # /************************************************************************ ! 650: 646 00029822 # * ! 651: 647 00029822 # * SUBTEST 5 ! 652: 648 00029822 # * data in Cache, no NO-OPs ! 653: 649 00029822 # * ! 654: 650 00029822 # ************************************************************************/ ! 655: 651 00029822 # pipe5_5() ! 656: 652 00029822 # { ! 657: 653 00029822 13 00dc jbr L288 ! 658: 654 00029825 L289: ! 659: 655 00029825 # force_loop = FALSE; /* clear force_loop flag */ ! 660: 656 00029825 4d effffffb7d clrl _force_loop ! 661: 657 0002982B # index = 0; ! 662: 658 0002982B 4d effffffb77 clrl _index ! 663: 659 00029831 # do ! 664: 660 00029831 L292: ! 665: 661 00029831 # { ! 666: 662 00029831 # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */ ! 667: 663 00029831 0d effffffb71 50 movl _index,r0 ! 668: 664 00029838 48 03 50 50 shll $3,r0,r0 ! 669: 665 0002983C 0d e000000000 effffffb61 movl _lnf_1_data(r0),_sgl_value_1 ! 670: 666 00029847 # sgl_expected = lnf_1_data[index].exp; /* get expected results */ ! 671: 667 00029847 0d effffffb5b 50 movl _index,r0 ! 672: 668 0002984E 48 03 50 50 shll $3,r0,r0 ! 673: 669 00029852 0d e000000004 effffffb4b movl _lnf_1_data+4(r0),_sgl_expected ! 674: 670 0002985D # sgl_value_2 = 0x00000000; /* floating '0' */ ! 675: 671 0002985D 4d effffffb45 clrl _sgl_value_2 ! 676: 672 00029863 # /* ! 677: 673 00029863 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 678: 674 00029863 # * The force loop flag is set after the first error. ! 679: 675 00029863 # */ ! 680: 676 00029863 # asm("_pipe5_5_lp1:"); ! 681: 677 00029863 _pipe5_5_lp1: ! 682: 678 00029863 # asm("lnf _sgl_value_1"); /* load the operand */ ! 683: 679 00029863 16 effffffb3f lnf _sgl_value_1 ! 684: 680 00029869 # asm("stf _sgl_st_acc"); /* store the result */ ! 685: 681 00029869 26 effffffb39 stf _sgl_st_acc ! 686: 682 0002986F # asm("lnf _sgl_value_2"); /* load a floating '0' */ ! 687: 683 0002986F 16 effffffb33 lnf _sgl_value_2 ! 688: 684 00029875 # asm("subf _sgl_value_1"); /* subtract the operand */ ! 689: 685 00029875 d6 effffffb2d subf _sgl_value_1 ! 690: 686 0002987B # asm("stf _sgl_value_6"); /* store the result */ ! 691: 687 0002987B 26 effffffb27 stf _sgl_value_6 ! 692: 688 00029881 # if( force_loop ) ! 693: 689 00029881 5d effffffb21 tstl _force_loop ! 694: 690 00029887 31 02 jeql L293 ! 695: 691 00029889 # asm("brb _pipe5_5_lp1");; /* loop on the error */ ! 696: 692 00029889 11 d8 brb _pipe5_5_lp1 ! 697: 693 0002988B L293: ! 698: 694 0002988B # /* ! 699: 695 0002988B # * verify the results ! 700: 696 0002988B # */ ! 701: 697 0002988B # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */ ! 702: 698 0002988B # (sgl_value_6 != sgl_expected) ) ! 703: 699 0002988B 1d effffffb17 effffffb12 cmpl _sgl_st_acc,_sgl_expected ! 704: 700 00029896 21 0d jneq L9995 ! 705: 701 00029898 1d effffffb0a effffffb05 cmpl _sgl_value_6,_sgl_expected ! 706: 702 000298A3 31 42 jeql L294 ! 707: 703 000298A5 L9995: ! 708: 704 000298A5 # { ! 709: 705 000298A5 # errcnt++; /* bump the error count */ ! 710: 706 000298A5 6d effffffafd incl _errcnt ! 711: 707 000298AB # if ( prt_error ) ! 712: 708 000298AB 5d effffffaf7 tstl _prt_error ! 713: 709 000298B1 31 0d jeql L295 ! 714: 710 000298B3 # print_pipe5_er("Cache Data, no NO-OPs"); ! 715: 711 000298B3 .data 1 ! 716: 712 00000d65 * L296: ! 717: 713 00000d65 * 436163686520446174612C206 .ascii "Cache Data, no NO-OPs\0" ! 718: E6F204E4F2D4F507300 ! 719: 714 00000d7b * .text ! 720: 715 000298B3 dd 8f00000d65 pushl $L296 ! 721: 716 000298B9 fe 08 ef00000658 callf $8,_print_pipe5_er ! 722: 717 000298C0 # if ( halt_flg ) ! 723: 718 000298C0 L295: ! 724: 719 000298C0 5d effffffae2 tstl _halt_flg ! 725: 720 000298C6 31 0d jeql L297 ! 726: 721 000298C8 # pipe5_er_hlt( subtest ); ! 727: 722 000298C8 dd effffffada pushl _subtest ! 728: 723 000298CE fe 08 ef00000769 callf $8,_pipe5_er_hlt ! 729: 724 000298D5 # if ( loop_on_err ) { ! 730: 725 000298D5 L297: ! 731: 726 000298D5 5d effffffacd tstl _loop_on_err ! 732: 727 000298DB 31 0a jeql L298 ! 733: 728 000298DD # force_loop = TRUE; /* set the force loop flag */ ! 734: 729 000298DD 0d 01 effffffac4 movl $1,_force_loop ! 735: 730 000298E4 # asm("brw _pipe5_5_lp1"); /* and loop */ ! 736: 731 000298E4 13 ff7c brw _pipe5_5_lp1 ! 737: 732 000298E7 # } ! 738: 733 000298E7 # } /* end of compare error */ ! 739: 734 000298E7 L298: ! 740: 735 000298E7 # } while( index++ < max_lnf_1_index ); ! 741: 736 000298E7 L294: ! 742: 737 000298E7 L291: ! 743: 738 000298E7 0d effffffabb 50 movl _index,r0 ! 744: 739 000298EE 6d effffffab4 incl _index ! 745: 740 000298F4 1d 50 effffffaad cmpl r0,_max_lnf_1_index ! 746: 741 000298FB 81 03 13 ff31 jlss L292 ! 747: 742 00029900 L290: ! 748: 743 00029900 # } /* end of subtest 5 */ ! 749: 744 00029900 40 ret#2 ! 750: 745 00029901 .set L286,0x0 ! 751: 746 00029901 L288: ! 752: 747 00029901 13 ff21 jbr L289 ! 753: 748 00029904 .data ! 754: 749 00000d0c * .text ! 755: 750 00029904 .align 1 ! 756: 751 00029904 .globl _pipe5_6 ! 757: 752 00029904 _pipe5_6: ! 758: 753 00029904 0000 .word L299 ! 759: 754 00029906 # ! 760: 755 00029906 # ! 761: 756 00029906 # ! 762: 757 00029906 # ! 763: 758 00029906 # ! 764: 759 00029906 # ! 765: 760 00029906 # /************************************************************************ ! 766: 761 00029906 # * ! 767: 762 00029906 # * SUBTEST 6 ! 768: 763 00029906 # * data in Cache, 1 NO-OP ! 769: 764 00029906 # * ! 770: 765 00029906 # ************************************************************************/ ! 771: 766 00029906 # pipe5_6() ! 772: 767 00029906 # { ! 773: 768 00029906 13 00e0 jbr L301 ! 774: 769 00029909 L302: ! 775: 770 00029909 # force_loop = FALSE; /* clear force_loop flag */ ! 776: 771 00029909 4d effffffa99 clrl _force_loop ! 777: 772 0002990F # index = 0; ! 778: 773 0002990F 4d effffffa93 clrl _index ! 779: 774 00029915 # do ! 780: 775 00029915 L305: ! 781: 776 00029915 # { ! 782: 777 00029915 # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */ ! 783: 778 00029915 0d effffffa8d 50 movl _index,r0 ! 784: 779 0002991C 48 03 50 50 shll $3,r0,r0 ! 785: 780 00029920 0d e000000000 effffffa7d movl _lnf_1_data(r0),_sgl_value_1 ! 786: 781 0002992B # sgl_expected = lnf_1_data[index].exp; /* get expected results */ ! 787: 782 0002992B 0d effffffa77 50 movl _index,r0 ! 788: 783 00029932 48 03 50 50 shll $3,r0,r0 ! 789: 784 00029936 0d e000000004 effffffa67 movl _lnf_1_data+4(r0),_sgl_expected ! 790: 785 00029941 # sgl_value_2 = 0x00000000; /* floating '0' */ ! 791: 786 00029941 4d effffffa61 clrl _sgl_value_2 ! 792: 787 00029947 # /* ! 793: 788 00029947 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 794: 789 00029947 # * The force loop flag is set after the first error. ! 795: 790 00029947 # */ ! 796: 791 00029947 # asm("_pipe5_6_lp1:"); ! 797: 792 00029947 _pipe5_6_lp1: ! 798: 793 00029947 # asm("lnf _sgl_value_1"); /* load the operand */ ! 799: 794 00029947 16 effffffa5b lnf _sgl_value_1 ! 800: 795 0002994D # asm("nop"); ! 801: 796 0002994D 10 nop ! 802: 797 0002994E # asm("stf _sgl_st_acc"); /* store the result */ ! 803: 798 0002994E 26 effffffa54 stf _sgl_st_acc ! 804: 799 00029954 # asm("nop"); ! 805: 800 00029954 10 nop ! 806: 801 00029955 # asm("lnf _sgl_value_2"); /* load a floating '0' */ ! 807: 802 00029955 16 effffffa4d lnf _sgl_value_2 ! 808: 803 0002995B # asm("nop"); ! 809: 804 0002995B 10 nop ! 810: 805 0002995C # asm("subf _sgl_value_1"); /* subtract the operand */ ! 811: 806 0002995C d6 effffffa46 subf _sgl_value_1 ! 812: 807 00029962 # asm("nop"); ! 813: 808 00029962 10 nop ! 814: 809 00029963 # asm("stf _sgl_value_6"); /* store the result */ ! 815: 810 00029963 26 effffffa3f stf _sgl_value_6 ! 816: 811 00029969 # if( force_loop ) ! 817: 812 00029969 5d effffffa39 tstl _force_loop ! 818: 813 0002996F 31 02 jeql L306 ! 819: 814 00029971 # asm("brb _pipe5_6_lp1");; /* loop on the error */ ! 820: 815 00029971 11 d4 brb _pipe5_6_lp1 ! 821: 816 00029973 L306: ! 822: 817 00029973 # /* ! 823: 818 00029973 # * verify the results ! 824: 819 00029973 # */ ! 825: 820 00029973 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */ ! 826: 821 00029973 # (sgl_value_6 != sgl_expected) ) ! 827: 822 00029973 1d effffffa2f effffffa2a cmpl _sgl_st_acc,_sgl_expected ! 828: 823 0002997E 21 0d jneq L9994 ! 829: 824 00029980 1d effffffa22 effffffa1d cmpl _sgl_value_6,_sgl_expected ! 830: 825 0002998B 31 42 jeql L307 ! 831: 826 0002998D L9994: ! 832: 827 0002998D # { ! 833: 828 0002998D # errcnt++; /* bump the error count */ ! 834: 829 0002998D 6d effffffa15 incl _errcnt ! 835: 830 00029993 # if ( prt_error ) ! 836: 831 00029993 5d effffffa0f tstl _prt_error ! 837: 832 00029999 31 0d jeql L308 ! 838: 833 0002999B # print_pipe5_er("Cache Data, 1 NO-OP"); ! 839: 834 0002999B .data 1 ! 840: 835 00000d7b * L309: ! 841: 836 00000d7b * 436163686520446174612C203 .ascii "Cache Data, 1 NO-OP\0" ! 842: 1204E4F2D4F5000 ! 843: 837 00000d8f * .text ! 844: 838 0002999B dd 8f00000d7b pushl $L309 ! 845: 839 000299A1 fe 08 ef00000570 callf $8,_print_pipe5_er ! 846: 840 000299A8 # if ( halt_flg ) ! 847: 841 000299A8 L308: ! 848: 842 000299A8 5d effffff9fa tstl _halt_flg ! 849: 843 000299AE 31 0d jeql L310 ! 850: 844 000299B0 # pipe5_er_hlt( subtest ); ! 851: 845 000299B0 dd effffff9f2 pushl _subtest ! 852: 846 000299B6 fe 08 ef00000681 callf $8,_pipe5_er_hlt ! 853: 847 000299BD # if ( loop_on_err ) { ! 854: 848 000299BD L310: ! 855: 849 000299BD 5d effffff9e5 tstl _loop_on_err ! 856: 850 000299C3 31 0a jeql L311 ! 857: 851 000299C5 # force_loop = TRUE; /* set the force loop flag */ ! 858: 852 000299C5 0d 01 effffff9dc movl $1,_force_loop ! 859: 853 000299CC # asm("brw _pipe5_6_lp1"); /* and loop */ ! 860: 854 000299CC 13 ff78 brw _pipe5_6_lp1 ! 861: 855 000299CF # } ! 862: 856 000299CF # } /* end of compare error */ ! 863: 857 000299CF L311: ! 864: 858 000299CF # } while( index++ < max_lnf_1_index ); ! 865: 859 000299CF L307: ! 866: 860 000299CF L304: ! 867: 861 000299CF 0d effffff9d3 50 movl _index,r0 ! 868: 862 000299D6 6d effffff9cc incl _index ! 869: 863 000299DC 1d 50 effffff9c5 cmpl r0,_max_lnf_1_index ! 870: 864 000299E3 81 03 13 ff2d jlss L305 ! 871: 865 000299E8 L303: ! 872: 866 000299E8 # } /* end of subtest 6 */ ! 873: 867 000299E8 40 ret#2 ! 874: 868 000299E9 .set L299,0x0 ! 875: 869 000299E9 L301: ! 876: 870 000299E9 13 ff1d jbr L302 ! 877: 871 000299EC .data ! 878: 872 00000d0c * .text ! 879: 873 000299EC .align 1 ! 880: 874 000299EC .globl _pipe5_7 ! 881: 875 000299EC _pipe5_7: ! 882: 876 000299EC 0000 .word L312 ! 883: 877 000299EE # ! 884: 878 000299EE # ! 885: 879 000299EE # ! 886: 880 000299EE # ! 887: 881 000299EE # ! 888: 882 000299EE # ! 889: 883 000299EE # /************************************************************************ ! 890: 884 000299EE # * ! 891: 885 000299EE # * SUBTEST 7 ! 892: 886 000299EE # * data in Cache, 2 NO-OPs ! 893: 887 000299EE # * ! 894: 888 000299EE # ************************************************************************/ ! 895: 889 000299EE # pipe5_7() ! 896: 890 000299EE # { ! 897: 891 000299EE 13 00e4 jbr L314 ! 898: 892 000299F1 L315: ! 899: 893 000299F1 # force_loop = FALSE; /* clear force_loop flag */ ! 900: 894 000299F1 4d effffff9b1 clrl _force_loop ! 901: 895 000299F7 # index = 0; ! 902: 896 000299F7 4d effffff9ab clrl _index ! 903: 897 000299FD # do ! 904: 898 000299FD L318: ! 905: 899 000299FD # { ! 906: 900 000299FD # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */ ! 907: 901 000299FD 0d effffff9a5 50 movl _index,r0 ! 908: 902 00029A04 48 03 50 50 shll $3,r0,r0 ! 909: 903 00029A08 0d e000000000 effffff995 movl _lnf_1_data(r0),_sgl_value_1 ! 910: 904 00029A13 # sgl_expected = lnf_1_data[index].exp; /* get expected results */ ! 911: 905 00029A13 0d effffff98f 50 movl _index,r0 ! 912: 906 00029A1A 48 03 50 50 shll $3,r0,r0 ! 913: 907 00029A1E 0d e000000004 effffff97f movl _lnf_1_data+4(r0),_sgl_expected ! 914: 908 00029A29 # sgl_value_2 = 0x00000000; /* floating '0' */ ! 915: 909 00029A29 4d effffff979 clrl _sgl_value_2 ! 916: 910 00029A2F # /* ! 917: 911 00029A2F # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 918: 912 00029A2F # * The force loop flag is set after the first error. ! 919: 913 00029A2F # */ ! 920: 914 00029A2F # asm("_pipe5_7_lp1:"); ! 921: 915 00029A2F _pipe5_7_lp1: ! 922: 916 00029A2F # asm("lnf _sgl_value_1"); /* load the operand */ ! 923: 917 00029A2F 16 effffff973 lnf _sgl_value_1 ! 924: 918 00029A35 # asm("nop"); ! 925: 919 00029A35 10 nop ! 926: 920 00029A36 # asm("nop"); ! 927: 921 00029A36 10 nop ! 928: 922 00029A37 # asm("stf _sgl_st_acc"); /* store the result */ ! 929: 923 00029A37 26 effffff96b stf _sgl_st_acc ! 930: 924 00029A3D # asm("nop"); ! 931: 925 00029A3D 10 nop ! 932: 926 00029A3E # asm("nop"); ! 933: 927 00029A3E 10 nop ! 934: 928 00029A3F # asm("lnf _sgl_value_2"); /* load a floating '0' */ ! 935: 929 00029A3F 16 effffff963 lnf _sgl_value_2 ! 936: 930 00029A45 # asm("nop"); ! 937: 931 00029A45 10 nop ! 938: 932 00029A46 # asm("nop"); ! 939: 933 00029A46 10 nop ! 940: 934 00029A47 # asm("subf _sgl_value_1"); /* subtract the operand */ ! 941: 935 00029A47 d6 effffff95b subf _sgl_value_1 ! 942: 936 00029A4D # asm("nop"); ! 943: 937 00029A4D 10 nop ! 944: 938 00029A4E # asm("nop"); ! 945: 939 00029A4E 10 nop ! 946: 940 00029A4F # asm("stf _sgl_value_6"); /* store the result */ ! 947: 941 00029A4F 26 effffff953 stf _sgl_value_6 ! 948: 942 00029A55 # if( force_loop ) ! 949: 943 00029A55 5d effffff94d tstl _force_loop ! 950: 944 00029A5B 31 02 jeql L319 ! 951: 945 00029A5D # asm("brb _pipe5_7_lp1");; /* loop on the error */ ! 952: 946 00029A5D 11 d0 brb _pipe5_7_lp1 ! 953: 947 00029A5F L319: ! 954: 948 00029A5F # /* ! 955: 949 00029A5F # * verify the results ! 956: 950 00029A5F # */ ! 957: 951 00029A5F # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */ ! 958: 952 00029A5F # (sgl_value_6 != sgl_expected) ) ! 959: 953 00029A5F 1d effffff943 effffff93e cmpl _sgl_st_acc,_sgl_expected ! 960: 954 00029A6A 21 0d jneq L9993 ! 961: 955 00029A6C 1d effffff936 effffff931 cmpl _sgl_value_6,_sgl_expected ! 962: 956 00029A77 31 42 jeql L320 ! 963: 957 00029A79 L9993: ! 964: 958 00029A79 # { ! 965: 959 00029A79 # errcnt++; /* bump the error count */ ! 966: 960 00029A79 6d effffff929 incl _errcnt ! 967: 961 00029A7F # if ( prt_error ) ! 968: 962 00029A7F 5d effffff923 tstl _prt_error ! 969: 963 00029A85 31 0d jeql L321 ! 970: 964 00029A87 # print_pipe5_er("Cache Data, 2 NO-OPs"); ! 971: 965 00029A87 .data 1 ! 972: 966 00000d8f * L322: ! 973: 967 00000d8f * 436163686520446174612C203 .ascii "Cache Data, 2 NO-OPs\0" ! 974: 2204E4F2D4F507300 ! 975: 968 00000da4 * .text ! 976: 969 00029A87 dd 8f00000d8f pushl $L322 ! 977: 970 00029A8D fe 08 ef00000484 callf $8,_print_pipe5_er ! 978: 971 00029A94 # if ( halt_flg ) ! 979: 972 00029A94 L321: ! 980: 973 00029A94 5d effffff90e tstl _halt_flg ! 981: 974 00029A9A 31 0d jeql L323 ! 982: 975 00029A9C # pipe5_er_hlt( subtest ); ! 983: 976 00029A9C dd effffff906 pushl _subtest ! 984: 977 00029AA2 fe 08 ef00000595 callf $8,_pipe5_er_hlt ! 985: 978 00029AA9 # if ( loop_on_err ) { ! 986: 979 00029AA9 L323: ! 987: 980 00029AA9 5d effffff8f9 tstl _loop_on_err ! 988: 981 00029AAF 31 0a jeql L324 ! 989: 982 00029AB1 # force_loop = TRUE; /* set the force loop flag */ ! 990: 983 00029AB1 0d 01 effffff8f0 movl $1,_force_loop ! 991: 984 00029AB8 # asm("brw _pipe5_7_lp1"); /* and loop */ ! 992: 985 00029AB8 13 ff74 brw _pipe5_7_lp1 ! 993: 986 00029ABB # } ! 994: 987 00029ABB # } /* end of compare error */ ! 995: 988 00029ABB L324: ! 996: 989 00029ABB # } while( index++ < max_lnf_1_index ); ! 997: 990 00029ABB L320: ! 998: 991 00029ABB L317: ! 999: 992 00029ABB 0d effffff8e7 50 movl _index,r0 ! 1000: 993 00029AC2 6d effffff8e0 incl _index ! 1001: 994 00029AC8 1d 50 effffff8d9 cmpl r0,_max_lnf_1_index ! 1002: 995 00029ACF 81 03 13 ff29 jlss L318 ! 1003: 996 00029AD4 L316: ! 1004: 997 00029AD4 # } /* end of subtest 7 */ ! 1005: 998 00029AD4 40 ret#2 ! 1006: 999 00029AD5 .set L312,0x0 ! 1007: 1000 00029AD5 L314: ! 1008: 1001 00029AD5 13 ff19 jbr L315 ! 1009: 1002 00029AD8 .data ! 1010: 1003 00000d0c * .text ! 1011: 1004 00029AD8 .align 1 ! 1012: 1005 00029AD8 .globl _pipe5_8 ! 1013: 1006 00029AD8 _pipe5_8: ! 1014: 1007 00029AD8 0000 .word L325 ! 1015: 1008 00029ADA # ! 1016: 1009 00029ADA # ! 1017: 1010 00029ADA # ! 1018: 1011 00029ADA # ! 1019: 1012 00029ADA # ! 1020: 1013 00029ADA # ! 1021: 1014 00029ADA # /************************************************************************ ! 1022: 1015 00029ADA # * ! 1023: 1016 00029ADA # * SUBTEST 8 ! 1024: 1017 00029ADA # * data in Cache, 3 NO-OPs ! 1025: 1018 00029ADA # * ! 1026: 1019 00029ADA # ************************************************************************/ ! 1027: 1020 00029ADA # pipe5_8() ! 1028: 1021 00029ADA # { ! 1029: 1022 00029ADA 13 00e8 jbr L327 ! 1030: 1023 00029ADD L328: ! 1031: 1024 00029ADD # force_loop = FALSE; /* clear force_loop flag */ ! 1032: 1025 00029ADD 4d effffff8c5 clrl _force_loop ! 1033: 1026 00029AE3 # index = 0; ! 1034: 1027 00029AE3 4d effffff8bf clrl _index ! 1035: 1028 00029AE9 # do ! 1036: 1029 00029AE9 L331: ! 1037: 1030 00029AE9 # { ! 1038: 1031 00029AE9 # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */ ! 1039: 1032 00029AE9 0d effffff8b9 50 movl _index,r0 ! 1040: 1033 00029AF0 48 03 50 50 shll $3,r0,r0 ! 1041: 1034 00029AF4 0d e000000000 effffff8a9 movl _lnf_1_data(r0),_sgl_value_1 ! 1042: 1035 00029AFF # sgl_expected = lnf_1_data[index].exp; /* get expected results */ ! 1043: 1036 00029AFF 0d effffff8a3 50 movl _index,r0 ! 1044: 1037 00029B06 48 03 50 50 shll $3,r0,r0 ! 1045: 1038 00029B0A 0d e000000004 effffff893 movl _lnf_1_data+4(r0),_sgl_expected ! 1046: 1039 00029B15 # sgl_value_2 = 0x00000000; /* floating '0' */ ! 1047: 1040 00029B15 4d effffff88d clrl _sgl_value_2 ! 1048: 1041 00029B1B # /* ! 1049: 1042 00029B1B # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 1050: 1043 00029B1B # * The force loop flag is set after the first error. ! 1051: 1044 00029B1B # */ ! 1052: 1045 00029B1B # asm("_pipe5_8_lp1:"); ! 1053: 1046 00029B1B _pipe5_8_lp1: ! 1054: 1047 00029B1B # asm("lnf _sgl_value_1"); /* load the operand */ ! 1055: 1048 00029B1B 16 effffff887 lnf _sgl_value_1 ! 1056: 1049 00029B21 # asm("nop"); ! 1057: 1050 00029B21 10 nop ! 1058: 1051 00029B22 # asm("nop"); ! 1059: 1052 00029B22 10 nop ! 1060: 1053 00029B23 # asm("nop"); ! 1061: 1054 00029B23 10 nop ! 1062: 1055 00029B24 # asm("stf _sgl_st_acc"); /* store the result */ ! 1063: 1056 00029B24 26 effffff87e stf _sgl_st_acc ! 1064: 1057 00029B2A # asm("nop"); ! 1065: 1058 00029B2A 10 nop ! 1066: 1059 00029B2B # asm("nop"); ! 1067: 1060 00029B2B 10 nop ! 1068: 1061 00029B2C # asm("nop"); ! 1069: 1062 00029B2C 10 nop ! 1070: 1063 00029B2D # asm("lnf _sgl_value_2"); /* load a floating '0' */ ! 1071: 1064 00029B2D 16 effffff875 lnf _sgl_value_2 ! 1072: 1065 00029B33 # asm("nop"); ! 1073: 1066 00029B33 10 nop ! 1074: 1067 00029B34 # asm("nop"); ! 1075: 1068 00029B34 10 nop ! 1076: 1069 00029B35 # asm("nop"); ! 1077: 1070 00029B35 10 nop ! 1078: 1071 00029B36 # asm("subf _sgl_value_1"); /* subtract the operand */ ! 1079: 1072 00029B36 d6 effffff86c subf _sgl_value_1 ! 1080: 1073 00029B3C # asm("nop"); ! 1081: 1074 00029B3C 10 nop ! 1082: 1075 00029B3D # asm("nop"); ! 1083: 1076 00029B3D 10 nop ! 1084: 1077 00029B3E # asm("nop"); ! 1085: 1078 00029B3E 10 nop ! 1086: 1079 00029B3F # asm("stf _sgl_value_6"); /* store the result */ ! 1087: 1080 00029B3F 26 effffff863 stf _sgl_value_6 ! 1088: 1081 00029B45 # if( force_loop ) ! 1089: 1082 00029B45 5d effffff85d tstl _force_loop ! 1090: 1083 00029B4B 31 02 jeql L332 ! 1091: 1084 00029B4D # asm("brb _pipe5_8_lp1");; /* loop on the error */ ! 1092: 1085 00029B4D 11 cc brb _pipe5_8_lp1 ! 1093: 1086 00029B4F L332: ! 1094: 1087 00029B4F # /* ! 1095: 1088 00029B4F # * verify the results ! 1096: 1089 00029B4F # */ ! 1097: 1090 00029B4F # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */ ! 1098: 1091 00029B4F # (sgl_value_6 != sgl_expected) ) ! 1099: 1092 00029B4F 1d effffff853 effffff84e cmpl _sgl_st_acc,_sgl_expected ! 1100: 1093 00029B5A 21 0d jneq L9992 ! 1101: 1094 00029B5C 1d effffff846 effffff841 cmpl _sgl_value_6,_sgl_expected ! 1102: 1095 00029B67 31 42 jeql L333 ! 1103: 1096 00029B69 L9992: ! 1104: 1097 00029B69 # { ! 1105: 1098 00029B69 # errcnt++; /* bump the error count */ ! 1106: 1099 00029B69 6d effffff839 incl _errcnt ! 1107: 1100 00029B6F # if ( prt_error ) ! 1108: 1101 00029B6F 5d effffff833 tstl _prt_error ! 1109: 1102 00029B75 31 0d jeql L334 ! 1110: 1103 00029B77 # print_pipe5_er("Cache Data, 3 NO-OPs"); ! 1111: 1104 00029B77 .data 1 ! 1112: 1105 00000da4 * L335: ! 1113: 1106 00000da4 * 436163686520446174612C203 .ascii "Cache Data, 3 NO-OPs\0" ! 1114: 3204E4F2D4F507300 ! 1115: 1107 00000db9 * .text ! 1116: 1108 00029B77 dd 8f00000da4 pushl $L335 ! 1117: 1109 00029B7D fe 08 ef00000394 callf $8,_print_pipe5_er ! 1118: 1110 00029B84 # if ( halt_flg ) ! 1119: 1111 00029B84 L334: ! 1120: 1112 00029B84 5d effffff81e tstl _halt_flg ! 1121: 1113 00029B8A 31 0d jeql L336 ! 1122: 1114 00029B8C # pipe5_er_hlt( subtest ); ! 1123: 1115 00029B8C dd effffff816 pushl _subtest ! 1124: 1116 00029B92 fe 08 ef000004a5 callf $8,_pipe5_er_hlt ! 1125: 1117 00029B99 # if ( loop_on_err ) { ! 1126: 1118 00029B99 L336: ! 1127: 1119 00029B99 5d effffff809 tstl _loop_on_err ! 1128: 1120 00029B9F 31 0a jeql L337 ! 1129: 1121 00029BA1 # force_loop = TRUE; /* set the force loop flag */ ! 1130: 1122 00029BA1 0d 01 effffff800 movl $1,_force_loop ! 1131: 1123 00029BA8 # asm("brw _pipe5_8_lp1"); /* and loop */ ! 1132: 1124 00029BA8 13 ff70 brw _pipe5_8_lp1 ! 1133: 1125 00029BAB # } ! 1134: 1126 00029BAB # } /* end of compare error */ ! 1135: 1127 00029BAB L337: ! 1136: 1128 00029BAB # } while( index++ < max_lnf_1_index ); ! 1137: 1129 00029BAB L333: ! 1138: 1130 00029BAB L330: ! 1139: 1131 00029BAB 0d effffff7f7 50 movl _index,r0 ! 1140: 1132 00029BB2 6d effffff7f0 incl _index ! 1141: 1133 00029BB8 1d 50 effffff7e9 cmpl r0,_max_lnf_1_index ! 1142: 1134 00029BBF 81 03 13 ff25 jlss L331 ! 1143: 1135 00029BC4 L329: ! 1144: 1136 00029BC4 # } /* end of subtest 8 */ ! 1145: 1137 00029BC4 40 ret#2 ! 1146: 1138 00029BC5 .set L325,0x0 ! 1147: 1139 00029BC5 L327: ! 1148: 1140 00029BC5 13 ff15 jbr L328 ! 1149: 1141 00029BC8 .data ! 1150: 1142 00000d0c * .text ! 1151: 1143 00029BC8 .align 1 ! 1152: 1144 00029BC8 .globl _pipe5_9 ! 1153: 1145 00029BC8 _pipe5_9: ! 1154: 1146 00029BC8 0000 .word L338 ! 1155: 1147 00029BCA # ! 1156: 1148 00029BCA # ! 1157: 1149 00029BCA # ! 1158: 1150 00029BCA # ! 1159: 1151 00029BCA # ! 1160: 1152 00029BCA # ! 1161: 1153 00029BCA # /***************************************************************************** ! 1162: 1154 00029BCA # * ! 1163: 1155 00029BCA # * SUBTEST 9 ! 1164: 1156 00029BCA # * data on the stack, no NO-OPs ! 1165: 1157 00029BCA # * ! 1166: 1158 00029BCA # *****************************************************************************/ ! 1167: 1159 00029BCA # pipe5_9() ! 1168: 1160 00029BCA # { ! 1169: 1161 00029BCA 13 017f jbr L340 ! 1170: 1162 00029BCD L341: ! 1171: 1163 00029BCD # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */ ! 1172: 1164 00029BCD ed 6d effffff7d4 moval (r13),_pre_event_fp ! 1173: 1165 00029BD4 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */ ! 1174: 1166 00029BD4 ed 6e effffff7cd moval (r14),_pre_event_sp ! 1175: 1167 00029BDB # force_loop = FALSE; /* clear force_loop flag */ ! 1176: 1168 00029BDB 4d effffff7c7 clrl _force_loop ! 1177: 1169 00029BE1 # index = 0; ! 1178: 1170 00029BE1 4d effffff7c1 clrl _index ! 1179: 1171 00029BE7 # do ! 1180: 1172 00029BE7 L344: ! 1181: 1173 00029BE7 # { ! 1182: 1174 00029BE7 # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */ ! 1183: 1175 00029BE7 0d effffff7bb 50 movl _index,r0 ! 1184: 1176 00029BEE 48 03 50 50 shll $3,r0,r0 ! 1185: 1177 00029BF2 0d e000000000 effffff7ab movl _lnf_1_data(r0),_sgl_value_1 ! 1186: 1178 00029BFD # sgl_expected = lnf_1_data[index].exp; /* get expected results */ ! 1187: 1179 00029BFD 0d effffff7a5 50 movl _index,r0 ! 1188: 1180 00029C04 48 03 50 50 shll $3,r0,r0 ! 1189: 1181 00029C08 0d e000000004 effffff795 movl _lnf_1_data+4(r0),_sgl_expected ! 1190: 1182 00029C13 # sgl_value_2 = 0x00000000; /* floating '0' */ ! 1191: 1183 00029C13 4d effffff78f clrl _sgl_value_2 ! 1192: 1184 00029C19 # asm("moval _pointer_data,_sgl_value_4");/* init / final SP value */ ! 1193: 1185 00029C19 ed effffff789 effffff784 moval _pointer_data,_sgl_value_4 ! 1194: 1186 00029C24 # /* ! 1195: 1187 00029C24 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 1196: 1188 00029C24 # * The force loop flag is set after the first error. ! 1197: 1189 00029C24 # */ ! 1198: 1190 00029C24 # asm("_pipe5_9_lp1:"); ! 1199: 1191 00029C24 _pipe5_9_lp1: ! 1200: 1192 00029C24 # asm("moval _pointer_data,r14"); /* set the stack pointer */ ! 1201: 1193 00029C24 ed effffff77e 5e moval _pointer_data,r14 ! 1202: 1194 00029C2B # asm("movl _sgl_value_1,-(r14)"); /* push the operand */ ! 1203: 1195 00029C2B 0d effffff777 7e movl _sgl_value_1,-(r14) ! 1204: 1196 00029C32 # asm("movl _sgl_value_2,-(r14)"); /* push a floating '0' */ ! 1205: 1197 00029C32 0d effffff770 7e movl _sgl_value_2,-(r14) ! 1206: 1198 00029C39 # asm("movl _sgl_value_1,-(r14)"); /* push the operand again */ ! 1207: 1199 00029C39 0d effffff769 7e movl _sgl_value_1,-(r14) ! 1208: 1200 00029C40 # /* ! 1209: 1201 00029C40 # * now pop the data off the stack ! 1210: 1202 00029C40 # */ ! 1211: 1203 00029C40 # ! 1212: 1204 00029C40 # asm("lnf (r14)+"); /* load the operand */ ! 1213: 1205 00029C40 16 8e lnf (r14)+ ! 1214: 1206 00029C42 # asm("stf r5"); /* store the result */ ! 1215: 1207 00029C42 26 55 stf r5 ! 1216: 1208 00029C44 # asm("lnf (r14)+"); /* load a floating '0' */ ! 1217: 1209 00029C44 16 8e lnf (r14)+ ! 1218: 1210 00029C46 # asm("subf (r14)+"); /* subtract the operand */ ! 1219: 1211 00029C46 d6 8e subf (r14)+ ! 1220: 1212 00029C48 # asm("stf r6"); /* store the result */ ! 1221: 1213 00029C48 26 56 stf r6 ! 1222: 1214 00029C4A # if( force_loop ) ! 1223: 1215 00029C4A 5d effffff758 tstl _force_loop ! 1224: 1216 00029C50 31 02 jeql L345 ! 1225: 1217 00029C52 # asm("brb _pipe5_9_lp1");; /* loop on the error */ ! 1226: 1218 00029C52 11 d0 brb _pipe5_9_lp1 ! 1227: 1219 00029C54 L345: ! 1228: 1220 00029C54 # /* ! 1229: 1221 00029C54 # * verify the results ! 1230: 1222 00029C54 # */ ! 1231: 1223 00029C54 # asm("movl r5,_sgl_st_acc"); /* get the 1st store value */ ! 1232: 1224 00029C54 0d 55 effffff74d movl r5,_sgl_st_acc ! 1233: 1225 00029C5B # asm("movl r6,_sgl_value_6"); /* get the 2nd store value */ ! 1234: 1226 00029C5B 0d 56 effffff746 movl r6,_sgl_value_6 ! 1235: 1227 00029C62 # asm("moval (r14),_sgl_value_5"); /* save the stack pointer */ ! 1236: 1228 00029C62 ed 6e effffff73f moval (r14),_sgl_value_5 ! 1237: 1229 00029C69 # if( (sgl_st_acc != sgl_expected) || /* verify the results... */ ! 1238: 1230 00029C69 # (sgl_value_6 != sgl_expected) || ! 1239: 1231 00029C69 # (sgl_value_5 != sgl_value_4) ) /* ... and the final SP */ ! 1240: 1232 00029C69 1d effffff739 effffff734 cmpl _sgl_st_acc,_sgl_expected ! 1241: 1233 00029C74 21 1d jneq L9991 ! 1242: 1234 00029C76 1d effffff72c effffff727 cmpl _sgl_value_6,_sgl_expected ! 1243: 1235 00029C81 21 10 jneq L9991 ! 1244: 1236 00029C83 1d effffff71f effffff71a cmpl _sgl_value_5,_sgl_value_4 ! 1245: 1237 00029C8E 21 03 13 0091 jeql L346 ! 1246: 1238 00029C93 L9991: ! 1247: 1239 00029C93 # { ! 1248: 1240 00029C93 # asm("movl _pre_event_fp,r13"); /* restore frame pointer */ ! 1249: 1241 00029C93 0d effffff70f 5d movl _pre_event_fp,r13 ! 1250: 1242 00029C9A # asm("movl _pre_event_sp,r14"); /* restore stack pointer */ ! 1251: 1243 00029C9A 0d effffff708 5e movl _pre_event_sp,r14 ! 1252: 1244 00029CA1 # errcnt++; /* bump the error count */ ! 1253: 1245 00029CA1 6d effffff701 incl _errcnt ! 1254: 1246 00029CA7 # if ( prt_error ) { ! 1255: 1247 00029CA7 5d effffff6fb tstl _prt_error ! 1256: 1248 00029CAD 31 4e jeql L347 ! 1257: 1249 00029CAF # print_pipe5_er("POP data from the STACK"); ! 1258: 1250 00029CAF .data 1 ! 1259: 1251 00000db9 * L348: ! 1260: 1252 00000db9 * 504F5020646174612066726F6 .ascii "POP data from the STACK\0" ! 1261: D2074686520535441434B00 ! 1262: 1253 00000dd1 * .text ! 1263: 1254 00029CAF dd 8f00000db9 pushl $L348 ! 1264: 1255 00029CB5 fe 08 ef0000025c callf $8,_print_pipe5_er ! 1265: 1256 00029CBC # writes("final Stack Pointer = "); ! 1266: 1257 00029CBC .data 1 ! 1267: 1258 00000dd1 * L349: ! 1268: 1259 00000dd1 * 66696E616C20537461636B205 .ascii "final Stack Pointer = \0" ! 1269: 06F696E746572203D2000 ! 1270: 1260 00000de8 * .text ! 1271: 1261 00029CBC dd 8f00000dd1 pushl $L349 ! 1272: 1262 00029CC2 fe 08 effffff6df callf $8,_writes ! 1273: 1263 00029CC9 # write32h( sgl_value_5 ); ! 1274: 1264 00029CC9 dd effffff6d9 pushl _sgl_value_5 ! 1275: 1265 00029CCF fe 08 effffff6d2 callf $8,_write32h ! 1276: 1266 00029CD6 # writes(", expected SP = "); ! 1277: 1267 00029CD6 .data 1 ! 1278: 1268 00000de8 * L351: ! 1279: 1269 00000de8 * 2C20206578706563746564205 .ascii ", expected SP = \0" ! 1280: 350203D2000 ! 1281: 1270 00000dfa * .text ! 1282: 1271 00029CD6 dd 8f00000de8 pushl $L351 ! 1283: 1272 00029CDC fe 08 effffff6c5 callf $8,_writes ! 1284: 1273 00029CE3 # write32h( sgl_value_4 ); ! 1285: 1274 00029CE3 dd effffff6bf pushl _sgl_value_4 ! 1286: 1275 00029CE9 fe 08 effffff6b8 callf $8,_write32h ! 1287: 1276 00029CF0 # writes("\n"); ! 1288: 1277 00029CF0 .data 1 ! 1289: 1278 00000dfa * L352: ! 1290: 1279 00000dfa * 0A00 .ascii "\12\0" ! 1291: 1280 00000dfc * .text ! 1292: 1281 00029CF0 dd 8f00000dfa pushl $L352 ! 1293: 1282 00029CF6 fe 08 effffff6ab callf $8,_writes ! 1294: 1283 00029CFD # } ! 1295: 1284 00029CFD # if ( halt_flg ) ! 1296: 1285 00029CFD L347: ! 1297: 1286 00029CFD 5d effffff6a5 tstl _halt_flg ! 1298: 1287 00029D03 31 0d jeql L353 ! 1299: 1288 00029D05 # pipe5_er_hlt( subtest ); ! 1300: 1289 00029D05 dd effffff69d pushl _subtest ! 1301: 1290 00029D0B fe 08 ef0000032c callf $8,_pipe5_er_hlt ! 1302: 1291 00029D12 # if ( loop_on_err ) { ! 1303: 1292 00029D12 L353: ! 1304: 1293 00029D12 5d effffff690 tstl _loop_on_err ! 1305: 1294 00029D18 31 0a jeql L354 ! 1306: 1295 00029D1A # force_loop = TRUE; /* set the force loop flag */ ! 1307: 1296 00029D1A 0d 01 effffff687 movl $1,_force_loop ! 1308: 1297 00029D21 # asm("brw _pipe5_9_lp1"); /* and loop */ ! 1309: 1298 00029D21 13 ff00 brw _pipe5_9_lp1 ! 1310: 1299 00029D24 # } ! 1311: 1300 00029D24 # } /* end of compare error */ ! 1312: 1301 00029D24 L354: ! 1313: 1302 00029D24 # } while( index++ < max_lnf_1_index ); ! 1314: 1303 00029D24 L346: ! 1315: 1304 00029D24 L343: ! 1316: 1305 00029D24 0d effffff67e 50 movl _index,r0 ! 1317: 1306 00029D2B 6d effffff677 incl _index ! 1318: 1307 00029D31 1d 50 effffff670 cmpl r0,_max_lnf_1_index ! 1319: 1308 00029D38 81 03 13 feaa jlss L344 ! 1320: 1309 00029D3D L342: ! 1321: 1310 00029D3D # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */ ! 1322: 1311 00029D3D 0d effffff665 5d movl _pre_event_fp,r13 ! 1323: 1312 00029D44 # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */ ! 1324: 1313 00029D44 0d effffff65e 5e movl _pre_event_sp,r14 ! 1325: 1314 00029D4B # } /* end of subtest 9 */ ! 1326: 1315 00029D4B 40 ret#2 ! 1327: 1316 00029D4C .set L338,0x0 ! 1328: 1317 00029D4C L340: ! 1329: 1318 00029D4C 13 fe7e jbr L341 ! 1330: 1319 00029D4F .data ! 1331: 1320 00000d0c * .text ! 1332: 1321 00029D4F 00 .align 1 ! 1333: 1322 00029D50 .globl _pipe5_10 ! 1334: 1323 00029D50 _pipe5_10: ! 1335: 1324 00029D50 0000 .word L355 ! 1336: 1325 00029D52 # ! 1337: 1326 00029D52 # ! 1338: 1327 00029D52 # ! 1339: 1328 00029D52 # ! 1340: 1329 00029D52 # ! 1341: 1330 00029D52 # ! 1342: 1331 00029D52 # /****************************************************************************** ! 1343: 1332 00029D52 # * ! 1344: 1333 00029D52 # * SUBTEST 10 ! 1345: 1334 00029D52 # * get data via indexed FRAME pointer ! 1346: 1335 00029D52 # * ! 1347: 1336 00029D52 # * ADDR INDEX DATA ! 1348: 1337 00029D52 # * pointer_data 4 <the 1st STF result goes here> ! 1349: 1338 00029D52 # * pointer_data-4 3 <the 2nd STF result goes here> ! 1350: 1339 00029D52 # * pointer_data-8 2 <operand data> ! 1351: 1340 00029D52 # * pointer_data-12 1 <floating '0'> ! 1352: 1341 00029D52 # * pointer_data-16 0 point the frame pointer here ! 1353: 1342 00029D52 # * ! 1354: 1343 00029D52 # ******************************************************************************/ ! 1355: 1344 00029D52 # pipe5_10() ! 1356: 1345 00029D52 # { ! 1357: 1346 00029D52 13 01c0 jbr L357 ! 1358: 1347 00029D55 L358: ! 1359: 1348 00029D55 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */ ! 1360: 1349 00029D55 ed 6d effffff64c moval (r13),_pre_event_fp ! 1361: 1350 00029D5C # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */ ! 1362: 1351 00029D5C ed 6e effffff645 moval (r14),_pre_event_sp ! 1363: 1352 00029D63 # force_loop = FALSE; /* clear force_loop flag */ ! 1364: 1353 00029D63 4d effffff63f clrl _force_loop ! 1365: 1354 00029D69 # index = 0; ! 1366: 1355 00029D69 4d effffff639 clrl _index ! 1367: 1356 00029D6F # do ! 1368: 1357 00029D6F L361: ! 1369: 1358 00029D6F # { ! 1370: 1359 00029D6F # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */ ! 1371: 1360 00029D6F 0d effffff633 50 movl _index,r0 ! 1372: 1361 00029D76 48 03 50 50 shll $3,r0,r0 ! 1373: 1362 00029D7A 0d e000000000 effffff623 movl _lnf_1_data(r0),_sgl_value_1 ! 1374: 1363 00029D85 # sgl_expected = lnf_1_data[index].exp; /* get expected results */ ! 1375: 1364 00029D85 0d effffff61d 50 movl _index,r0 ! 1376: 1365 00029D8C 48 03 50 50 shll $3,r0,r0 ! 1377: 1366 00029D90 0d e000000004 effffff60d movl _lnf_1_data+4(r0),_sgl_expected ! 1378: 1367 00029D9B # sgl_value_2 = 0x00000000; /* floating '0' */ ! 1379: 1368 00029D9B 4d effffff607 clrl _sgl_value_2 ! 1380: 1369 00029DA1 # asm("moval _pointer_data,_sgl_value_4");/* get store data's addr */ ! 1381: 1370 00029DA1 ed effffff601 effffff5fc moval _pointer_data,_sgl_value_4 ! 1382: 1371 00029DAC # sgl_value_4 -= 8; /* decrement it by 8 (bytes)*/ ! 1383: 1372 00029DAC 2c 08 effffff5f5 subl2 $8,_sgl_value_4 ! 1384: 1373 00029DB3 # asm("movl _sgl_value_1,*_sgl_value_4"); /* set the operand data */ ! 1385: 1374 00029DB3 0d effffff5ef fffffff5ea movl _sgl_value_1,*_sgl_value_4 ! 1386: 1375 00029DBE # sgl_value_4 -= 4; /* decrement it by 4 (bytes)*/ ! 1387: 1376 00029DBE 2c 04 effffff5e3 subl2 $4,_sgl_value_4 ! 1388: 1377 00029DC5 # asm("movl _sgl_value_2,*_sgl_value_4"); /* set the floating '0' */ ! 1389: 1378 00029DC5 0d effffff5dd fffffff5d8 movl _sgl_value_2,*_sgl_value_4 ! 1390: 1379 00029DD0 # sgl_value_4 -= 4; /* get FRAME PTR address */ ! 1391: 1380 00029DD0 2c 04 effffff5d1 subl2 $4,_sgl_value_4 ! 1392: 1381 00029DD7 # /* ! 1393: 1382 00029DD7 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 1394: 1383 00029DD7 # * The force loop flag is set after the first error. ! 1395: 1384 00029DD7 # */ ! 1396: 1385 00029DD7 # asm("_pipe5_10_lp1:"); ! 1397: 1386 00029DD7 _pipe5_10_lp1: ! 1398: 1387 00029DD7 # asm("movl _sgl_value_4,r13"); /* set the FRAME POINTER */ ! 1399: 1388 00029DD7 0d effffff5cb 5d movl _sgl_value_4,r13 ! 1400: 1389 00029DDE # asm("movl $1,r1"); /* r1 index = 1 longwords */ ! 1401: 1390 00029DDE 0d 01 51 movl $1,r1 ! 1402: 1391 00029DE1 # asm("movl $2,r2"); /* r2 index = 2 longwords */ ! 1403: 1392 00029DE1 0d 02 52 movl $2,r2 ! 1404: 1393 00029DE4 # asm("movl $3,r3"); /* r3 index = 3 longwords */ ! 1405: 1394 00029DE4 0d 03 53 movl $3,r3 ! 1406: 1395 00029DE7 # asm("movl $4,r4"); /* r4 index = 4 longwords */ ! 1407: 1396 00029DE7 0d 04 54 movl $4,r4 ! 1408: 1397 00029DEA # asm("lnf (r13)[r2]"); /* load the op (indx = 2) */ ! 1409: 1398 00029DEA 16 426d lnf (r13)[r2] ! 1410: 1399 00029DED # asm("stf (r13)[r4]"); /* store -index = 4 */ ! 1411: 1400 00029DED 26 446d stf (r13)[r4] ! 1412: 1401 00029DF0 # asm("lnf (r13)[r1]"); /* load '0' (indx = 1) */ ! 1413: 1402 00029DF0 16 416d lnf (r13)[r1] ! 1414: 1403 00029DF3 # asm("subf (r13)[r2]"); /* subtract the operand */ ! 1415: 1404 00029DF3 d6 426d subf (r13)[r2] ! 1416: 1405 00029DF6 # asm("stf (r13)[r3]"); /* store -index = 3 */ ! 1417: 1406 00029DF6 26 436d stf (r13)[r3] ! 1418: 1407 00029DF9 # if( force_loop ) ! 1419: 1408 00029DF9 5d effffff5a9 tstl _force_loop ! 1420: 1409 00029DFF 31 02 jeql L362 ! 1421: 1410 00029E01 # asm("brb _pipe5_10_lp1");; /* loop on the error */ ! 1422: 1411 00029E01 11 d4 brb _pipe5_10_lp1 ! 1423: 1412 00029E03 L362: ! 1424: 1413 00029E03 # /* ! 1425: 1414 00029E03 # * verify the results ! 1426: 1415 00029E03 # */ ! 1427: 1416 00029E03 # sgl_st_acc = pointer_data; /* save 1st stored value */ ! 1428: 1417 00029E03 0d effffff59f effffff59a movl _pointer_data,_sgl_st_acc ! 1429: 1418 00029E0E # asm("moval _pointer_data,_sgl_value_5"); /* get addr of 1st stf */ ! 1430: 1419 00029E0E ed effffff594 effffff58f moval _pointer_data,_sgl_value_5 ! 1431: 1420 00029E19 # sgl_value_5 -= 4; /* decrement by 4 (bytes) */ ! 1432: 1421 00029E19 2c 04 effffff588 subl2 $4,_sgl_value_5 ! 1433: 1422 00029E20 # asm("movl *_sgl_value_5,_sgl_value_6"); /* save 2nd store value */ ! 1434: 1423 00029E20 0d fffffff582 effffff57d movl *_sgl_value_5,_sgl_value_6 ! 1435: 1424 00029E2B # asm("moval (r13),_sgl_value_5"); /* save the frame pointer */ ! 1436: 1425 00029E2B ed 6d effffff576 moval (r13),_sgl_value_5 ! 1437: 1426 00029E32 # if( (sgl_st_acc != sgl_expected) || /* verify the results... */ ! 1438: 1427 00029E32 # (sgl_value_6 != sgl_expected) || ! 1439: 1428 00029E32 # (sgl_value_5 != sgl_value_4) ) /* ... and the final FP */ ! 1440: 1429 00029E32 1d effffff570 effffff56b cmpl _sgl_st_acc,_sgl_expected ! 1441: 1430 00029E3D 21 1d jneq L9990 ! 1442: 1431 00029E3F 1d effffff563 effffff55e cmpl _sgl_value_6,_sgl_expected ! 1443: 1432 00029E4A 21 10 jneq L9990 ! 1444: 1433 00029E4C 1d effffff556 effffff551 cmpl _sgl_value_5,_sgl_value_4 ! 1445: 1434 00029E57 21 03 13 0091 jeql L363 ! 1446: 1435 00029E5C L9990: ! 1447: 1436 00029E5C # { ! 1448: 1437 00029E5C # asm("movl _pre_event_fp,r13"); /* restore frame pointer */ ! 1449: 1438 00029E5C 0d effffff546 5d movl _pre_event_fp,r13 ! 1450: 1439 00029E63 # asm("movl _pre_event_sp,r14"); /* restore stack pointer */ ! 1451: 1440 00029E63 0d effffff53f 5e movl _pre_event_sp,r14 ! 1452: 1441 00029E6A # errcnt++; /* bump the error count */ ! 1453: 1442 00029E6A 6d effffff538 incl _errcnt ! 1454: 1443 00029E70 # if ( prt_error ) { ! 1455: 1444 00029E70 5d effffff532 tstl _prt_error ! 1456: 1445 00029E76 31 4e jeql L364 ! 1457: 1446 00029E78 # print_pipe5_er("indexed FP addressing"); ! 1458: 1447 00029E78 .data 1 ! 1459: 1448 00000dfc * L365: ! 1460: 1449 00000dfc * 696E646578656420465020616 .ascii "indexed FP addressing\0" ! 1461: 46472657373696E6700 ! 1462: 1450 00000e12 * .text ! 1463: 1451 00029E78 dd 8f00000dfc pushl $L365 ! 1464: 1452 00029E7E fe 08 ef00000093 callf $8,_print_pipe5_er ! 1465: 1453 00029E85 # writes("final Frame Pointer = "); ! 1466: 1454 00029E85 .data 1 ! 1467: 1455 00000e12 * L366: ! 1468: 1456 00000e12 * 66696E616C204672616D65205 .ascii "final Frame Pointer = \0" ! 1469: 06F696E746572203D2000 ! 1470: 1457 00000e29 * .text ! 1471: 1458 00029E85 dd 8f00000e12 pushl $L366 ! 1472: 1459 00029E8B fe 08 effffff516 callf $8,_writes ! 1473: 1460 00029E92 # writeh( sgl_value_5 ); ! 1474: 1461 00029E92 dd effffff510 pushl _sgl_value_5 ! 1475: 1462 00029E98 fe 08 effffff509 callf $8,_writeh ! 1476: 1463 00029E9F # writes(", expected FP = "); ! 1477: 1464 00029E9F .data 1 ! 1478: 1465 00000e29 * L368: ! 1479: 1466 00000e29 * 2C20206578706563746564204 .ascii ", expected FP = \0" ! 1480: 650203D2000 ! 1481: 1467 00000e3b * .text ! 1482: 1468 00029E9F dd 8f00000e29 pushl $L368 ! 1483: 1469 00029EA5 fe 08 effffff4fc callf $8,_writes ! 1484: 1470 00029EAC # writeh( sgl_value_4 ); ! 1485: 1471 00029EAC dd effffff4f6 pushl _sgl_value_4 ! 1486: 1472 00029EB2 fe 08 effffff4ef callf $8,_writeh ! 1487: 1473 00029EB9 # writes("\n"); ! 1488: 1474 00029EB9 .data 1 ! 1489: 1475 00000e3b * L369: ! 1490: 1476 00000e3b * 0A00 .ascii "\12\0" ! 1491: 1477 00000e3d * .text ! 1492: 1478 00029EB9 dd 8f00000e3b pushl $L369 ! 1493: 1479 00029EBF fe 08 effffff4e2 callf $8,_writes ! 1494: 1480 00029EC6 # } ! 1495: 1481 00029EC6 # if ( halt_flg ) ! 1496: 1482 00029EC6 L364: ! 1497: 1483 00029EC6 5d effffff4dc tstl _halt_flg ! 1498: 1484 00029ECC 31 0d jeql L370 ! 1499: 1485 00029ECE # pipe5_er_hlt( subtest ); ! 1500: 1486 00029ECE dd effffff4d4 pushl _subtest ! 1501: 1487 00029ED4 fe 08 ef00000163 callf $8,_pipe5_er_hlt ! 1502: 1488 00029EDB # if ( loop_on_err ) { ! 1503: 1489 00029EDB L370: ! 1504: 1490 00029EDB 5d effffff4c7 tstl _loop_on_err ! 1505: 1491 00029EE1 31 0a jeql L371 ! 1506: 1492 00029EE3 # force_loop = TRUE; /* set the force loop flag */ ! 1507: 1493 00029EE3 0d 01 effffff4be movl $1,_force_loop ! 1508: 1494 00029EEA # asm("brw _pipe5_10_lp1"); /* and loop */ ! 1509: 1495 00029EEA 13 feea brw _pipe5_10_lp1 ! 1510: 1496 00029EED # } ! 1511: 1497 00029EED # } /* end of compare error */ ! 1512: 1498 00029EED L371: ! 1513: 1499 00029EED # } while( index++ < max_lnf_1_index ); ! 1514: 1500 00029EED L363: ! 1515: 1501 00029EED L360: ! 1516: 1502 00029EED 0d effffff4b5 50 movl _index,r0 ! 1517: 1503 00029EF4 6d effffff4ae incl _index ! 1518: 1504 00029EFA 1d 50 effffff4a7 cmpl r0,_max_lnf_1_index ! 1519: 1505 00029F01 81 03 13 fe69 jlss L361 ! 1520: 1506 00029F06 L359: ! 1521: 1507 00029F06 # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */ ! 1522: 1508 00029F06 0d effffff49c 5d movl _pre_event_fp,r13 ! 1523: 1509 00029F0D # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */ ! 1524: 1510 00029F0D 0d effffff495 5e movl _pre_event_sp,r14 ! 1525: 1511 00029F14 # } /* end of subtest 10 */ ! 1526: 1512 00029F14 40 ret#2 ! 1527: 1513 00029F15 .set L355,0x0 ! 1528: 1514 00029F15 L357: ! 1529: 1515 00029F15 13 fe3d jbr L358 ! 1530: 1516 00029F18 .data ! 1531: 1517 00000d0c * .text ! 1532: 1518 00029F18 .align 1 ! 1533: 1519 00029F18 .globl _print_pipe5_er ! 1534: 1520 00029F18 _print_pipe5_er: ! 1535: 1521 00029F18 0000 .word L372 ! 1536: 1522 00029F1A # ! 1537: 1523 00029F1A # ! 1538: 1524 00029F1A # /****************************************************************************** ! 1539: 1525 00029F1A # * ! 1540: 1526 00029F1A # * ! 1541: 1527 00029F1A # * print an error in the following form ! 1542: 1528 00029F1A # * ! 1543: 1529 00029F1A # * operand = xxxxxxxx, 1st store = xxxxxxxx, data index = dd ! 1544: 1530 00029F1A # * 2nd store = xxxxxxxx, expected Acc = xxxxxxxx ! 1545: 1531 00029F1A # * ! 1546: 1532 00029F1A # ******************************************************************************/ ! 1547: 1533 00029F1A # print_pipe5_er(msg) ! 1548: 1534 00029F1A # char *msg; ! 1549: 1535 00029F1A # { ! 1550: 1536 00029F1A 13 011d jbr L374 ! 1551: 1537 00029F1D L375: ! 1552: 1538 00029F1D # writes("\n"); /* start a new print line */ ! 1553: 1539 00029F1D .data 1 ! 1554: 1540 00000e3d * L376: ! 1555: 1541 00000e3d * 0A00 .ascii "\12\0" ! 1556: 1542 00000e3f * .text ! 1557: 1543 00029F1D dd 8f00000e3d pushl $L376 ! 1558: 1544 00029F23 fe 08 effffff47e callf $8,_writes ! 1559: 1545 00029F2A # writes("cycle: "); ! 1560: 1546 00029F2A .data 1 ! 1561: 1547 00000e3f * L377: ! 1562: 1548 00000e3f * 6379636C653A2000 .ascii "cycle: \0" ! 1563: 1549 00000e47 * .text ! 1564: 1550 00029F2A dd 8f00000e3f pushl $L377 ! 1565: 1551 00029F30 fe 08 effffff471 callf $8,_writes ! 1566: 1552 00029F37 # writed( cycle ); ! 1567: 1553 00029F37 dd effffff46b pushl _cycle ! 1568: 1554 00029F3D fe 08 effffff464 callf $8,_writed ! 1569: 1555 00029F44 # writes(" test "); ! 1570: 1556 00029F44 .data 1 ! 1571: 1557 00000e47 * L379: ! 1572: 1558 00000e47 * 20746573742000 .ascii " test \0" ! 1573: 1559 00000e4e * .text ! 1574: 1560 00029F44 dd 8f00000e47 pushl $L379 ! 1575: 1561 00029F4A fe 08 effffff457 callf $8,_writes ! 1576: 1562 00029F51 # writed( test_no ); ! 1577: 1563 00029F51 dd effffff451 pushl _test_no ! 1578: 1564 00029F57 fe 08 effffff44a callf $8,_writed ! 1579: 1565 00029F5E # writes(" (Pipe 5), subtest "); ! 1580: 1566 00029F5E .data 1 ! 1581: 1567 00000e4e * L380: ! 1582: 1568 00000e4e * 202028506970652035292C207 .ascii " (Pipe 5), subtest \0" ! 1583: 37562746573742000 ! 1584: 1569 00000e63 * .text ! 1585: 1570 00029F5E dd 8f00000e4e pushl $L380 ! 1586: 1571 00029F64 fe 08 effffff43d callf $8,_writes ! 1587: 1572 00029F6B # writed( subtest ); ! 1588: 1573 00029F6B dd effffff437 pushl _subtest ! 1589: 1574 00029F71 fe 08 effffff430 callf $8,_writed ! 1590: 1575 00029F78 # writes(" error - "); ! 1591: 1576 00029F78 .data 1 ! 1592: 1577 00000e63 * L381: ! 1593: 1578 00000e63 * 206572726F72202D2000 .ascii " error - \0" ! 1594: 1579 00000e6d * .text ! 1595: 1580 00029F78 dd 8f00000e63 pushl $L381 ! 1596: 1581 00029F7E fe 08 effffff423 callf $8,_writes ! 1597: 1582 00029F85 # writes( msg ); ! 1598: 1583 00029F85 dd ad04 pushl 4(fp) ! 1599: 1584 00029F88 fe 08 effffff419 callf $8,_writes ! 1600: 1585 00029F8F # writec('\n'); ! 1601: 1586 00029F8F dd 0a pushl $10 ! 1602: 1587 00029F91 fe 08 effffff410 callf $8,_writec ! 1603: 1588 00029F98 # writes(" LNF(op), STF, LNF(0.0), SUBF(op), STF\n"); ! 1604: 1589 00029F98 .data 1 ! 1605: 1590 00000e6d * L383: ! 1606: 1591 00000e6d * 204C4E46286F70292C2053544 .ascii " LNF(op), STF, LNF(0.0), SUBF(op), STF\12\0" ! 1607: 62C204C4E4628302E30292C20 ! 1608: 53554246286F70292C2053544 ! 1609: 60A00 ! 1610: 1592 00000e95 * .text ! 1611: 1593 00029F98 dd 8f00000e6d pushl $L383 ! 1612: 1594 00029F9E fe 08 effffff403 callf $8,_writes ! 1613: 1595 00029FA5 # writes(" operand = "); ! 1614: 1596 00029FA5 .data 1 ! 1615: 1597 00000e95 * L384: ! 1616: 1598 00000e95 * 20206F706572616E64203D200 .ascii " operand = \0" ! 1617: 0 ! 1618: 1599 00000ea2 * .text ! 1619: 1600 00029FA5 dd 8f00000e95 pushl $L384 ! 1620: 1601 00029FAB fe 08 effffff3f6 callf $8,_writes ! 1621: 1602 00029FB2 # write32h( sgl_value_1 ); ! 1622: 1603 00029FB2 dd effffff3f0 pushl _sgl_value_1 ! 1623: 1604 00029FB8 fe 08 effffff3e9 callf $8,_write32h ! 1624: 1605 00029FBF # writes(", 1st store = "); ! 1625: 1606 00029FBF .data 1 ! 1626: 1607 00000ea2 * L385: ! 1627: 1608 00000ea2 * 2C20202020203173742073746 .ascii ", 1st store = \0" ! 1628: F7265203D2000 ! 1629: 1609 00000eb5 * .text ! 1630: 1610 00029FBF dd 8f00000ea2 pushl $L385 ! 1631: 1611 00029FC5 fe 08 effffff3dc callf $8,_writes ! 1632: 1612 00029FCC # write32h( sgl_st_acc ); ! 1633: 1613 00029FCC dd effffff3d6 pushl _sgl_st_acc ! 1634: 1614 00029FD2 fe 08 effffff3cf callf $8,_write32h ! 1635: 1615 00029FD9 # writes(", data index = "); ! 1636: 1616 00029FD9 .data 1 ! 1637: 1617 00000eb5 * L386: ! 1638: 1618 00000eb5 * 2C2020206461746120696E646 .ascii ", data index = \0" ! 1639: 578203D2000 ! 1640: 1619 00000ec7 * .text ! 1641: 1620 00029FD9 dd 8f00000eb5 pushl $L386 ! 1642: 1621 00029FDF fe 08 effffff3c2 callf $8,_writes ! 1643: 1622 00029FE6 # writed( index ); ! 1644: 1623 00029FE6 dd effffff3bc pushl _index ! 1645: 1624 00029FEC fe 08 effffff3b5 callf $8,_writed ! 1646: 1625 00029FF3 # writec('\n'); ! 1647: 1626 00029FF3 dd 0a pushl $10 ! 1648: 1627 00029FF5 fe 08 effffff3ac callf $8,_writec ! 1649: 1628 00029FFC # writes("2nd store = "); ! 1650: 1629 00029FFC .data 1 ! 1651: 1630 00000ec7 * L387: ! 1652: 1631 00000ec7 * .ascii "" ! 1653: 1632 00000ec7 * 326E642073746F7265203D200 .ascii "2nd store = \0" ! 1654: 0 ! 1655: 1633 00000ed4 * .text ! 1656: 1634 00029FFC dd 8f00000ec7 pushl $L387 ! 1657: 1635 0002A002 fe 08 effffff39f callf $8,_writes ! 1658: 1636 0002A009 # write32h( sgl_value_6 ); ! 1659: 1637 0002A009 dd effffff399 pushl _sgl_value_6 ! 1660: 1638 0002A00F fe 08 effffff392 callf $8,_write32h ! 1661: 1639 0002A016 # writes(", expected Acc = "); ! 1662: 1640 0002A016 .data 1 ! 1663: 1641 00000ed4 * L388: ! 1664: 1642 00000ed4 * 2C20206578706563746564204 .ascii ", expected Acc = \0" ! 1665: 16363203D2000 ! 1666: 1643 00000ee7 * .text ! 1667: 1644 0002A016 dd 8f00000ed4 pushl $L388 ! 1668: 1645 0002A01C fe 08 effffff385 callf $8,_writes ! 1669: 1646 0002A023 # write32h( sgl_expected ); ! 1670: 1647 0002A023 dd effffff37f pushl _sgl_expected ! 1671: 1648 0002A029 fe 08 effffff378 callf $8,_write32h ! 1672: 1649 0002A030 # writec('\n'); ! 1673: 1650 0002A030 dd 0a pushl $10 ! 1674: 1651 0002A032 fe 08 effffff36f callf $8,_writec ! 1675: 1652 0002A039 # } ! 1676: 1653 0002A039 40 ret#2 ! 1677: 1654 0002A03A .set L372,0x0 ! 1678: 1655 0002A03A L374: ! 1679: 1656 0002A03A 13 fee0 jbr L375 ! 1680: 1657 0002A03D .data ! 1681: 1658 00000d0c * .text ! 1682: 1659 0002A03D 00 .align 1 ! 1683: 1660 0002A03E .globl _pipe5_er_hlt ! 1684: 1661 0002A03E _pipe5_er_hlt: ! 1685: 1662 0002A03E 0000 .word L389 ! 1686: 1663 0002A040 # ! 1687: 1664 0002A040 # ! 1688: 1665 0002A040 # ! 1689: 1666 0002A040 # ! 1690: 1667 0002A040 # ! 1691: 1668 0002A040 # /****************************************************************************** ! 1692: 1669 0002A040 # * ! 1693: 1670 0002A040 # * HALT ON ERROR ROUTINE ! 1694: 1671 0002A040 # * ! 1695: 1672 0002A040 # * halt with the necessary information saved in the registers ! 1696: 1673 0002A040 # * ! 1697: 1674 0002A040 # ******************************************************************************/ ! 1698: 1675 0002A040 # pipe5_er_hlt( subtest ) ! 1699: 1676 0002A040 # int subtest; ! 1700: 1677 0002A040 # { ! 1701: 1678 0002A040 11 6e jbr L391 ! 1702: 1679 0002A042 L392: ! 1703: 1680 0002A042 # asm("movl _test_no,r0"); /* r0 = test number */ ! 1704: 1681 0002A042 0d effffff360 50 movl _test_no,r0 ! 1705: 1682 0002A049 # asm("movl _subtest,r1"); /* r1 = subtest number */ ! 1706: 1683 0002A049 0d effffff359 51 movl _subtest,r1 ! 1707: 1684 0002A050 # asm("movl $1,r2"); /* r2 = error code */ ! 1708: 1685 0002A050 0d 01 52 movl $1,r2 ! 1709: 1686 0002A053 # asm("movl _cycle,r3"); /* r3 = cycle count */ ! 1710: 1687 0002A053 0d effffff34f 53 movl _cycle,r3 ! 1711: 1688 0002A05A # asm("movl _sgl_value_1,r4"); /* r4 = sgl operand */ ! 1712: 1689 0002A05A 0d effffff348 54 movl _sgl_value_1,r4 ! 1713: 1690 0002A061 # asm("movl _sgl_st_acc,r5"); /* r5 = 1st word stored */ ! 1714: 1691 0002A061 0d effffff341 55 movl _sgl_st_acc,r5 ! 1715: 1692 0002A068 # asm("movl _sgl_value_6,r6"); /* r6 = 2nd word stored */ ! 1716: 1693 0002A068 0d effffff33a 56 movl _sgl_value_6,r6 ! 1717: 1694 0002A06F # asm("movl _sgl_expected,r7"); /* r7 = sgl expected */ ! 1718: 1695 0002A06F 0d effffff333 57 movl _sgl_expected,r7 ! 1719: 1696 0002A076 # asm("movl _index,r8"); /* r8 = data index */ ! 1720: 1697 0002A076 0d effffff32c 58 movl _index,r8 ! 1721: 1698 0002A07D # asm("movl _sgl_value_2,r9"); /* r9 = floating zero */ ! 1722: 1699 0002A07D 0d effffff325 59 movl _sgl_value_2,r9 ! 1723: 1700 0002A084 # if( subtest == 9 ) { ! 1724: 1701 0002A084 1d ad04 09 cmpl 4(fp),$9 ! 1725: 1702 0002A088 21 10 jneq L393 ! 1726: 1703 0002A08A # asm("movl _sgl_value_5,r10"); /* r10= final SP value */ ! 1727: 1704 0002A08A 0d effffff318 5a movl _sgl_value_5,r10 ! 1728: 1705 0002A091 # asm("movl _sgl_value_4,r11"); /* r11= expected SP value */ ! 1729: 1706 0002A091 0d effffff311 5b movl _sgl_value_4,r11 ! 1730: 1707 0002A098 # } else ! 1731: 1708 0002A098 11 14 jbr L394 ! 1732: 1709 0002A09A L393: ! 1733: 1710 0002A09A # if( subtest == 10 ) { ! 1734: 1711 0002A09A 1d ad04 0a cmpl 4(fp),$10 ! 1735: 1712 0002A09E 21 0e jneq L395 ! 1736: 1713 0002A0A0 # asm("movl _sgl_value_5,r10"); /* r10= final FP value */ ! 1737: 1714 0002A0A0 0d effffff302 5a movl _sgl_value_5,r10 ! 1738: 1715 0002A0A7 # asm("movl _sgl_value_4,r11"); /* r11= expected FP value */ ! 1739: 1716 0002A0A7 0d effffff2fb 5b movl _sgl_value_4,r11 ! 1740: 1717 0002A0AE # }; ! 1741: 1718 0002A0AE L395: ! 1742: 1719 0002A0AE L394: ! 1743: 1720 0002A0AE # asm(".globl _pipe5_1_hlt"); ! 1744: 1721 0002A0AE .globl _pipe5_1_hlt ! 1745: 1722 0002A0AE # asm("_pipe5_1_hlt:"); /* PC after the halt */ ! 1746: 1723 0002A0AE _pipe5_1_hlt: ! 1747: 1724 0002A0AE # asm("halt"); /* HALT ... */ ! 1748: 1725 0002A0AE 00 halt ! 1749: 1726 0002A0AF # } /* end of halt on error */ ! 1750: 1727 0002A0AF 40 ret#2 ! 1751: 1728 0002A0B0 .set L389,0x0 ! 1752: 1729 0002A0B0 L391: ! 1753: 1730 0002A0B0 11 90 jbr L392 ! 1754: 1731 0002A0B2 .data ! 1755: 1731 0005345A .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.