![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe4.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 pipe4.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 00000d78 * .text ! 4: 4 00000000 .align 1 ! 5: 5 00000000 .globl _pipe_4 ! 6: 6 00000000 _pipe_4: ! 7: 7 00028630 0000 .word L215 ! 8: 8 00028632 # #include "fpp_defs.h" ! 9: 9 00028632 # ! 10: 10 00028632 # ! 11: 11 00028632 # /***************************************************************************** ! 12: 12 00028632 # * ! 13: 13 00028632 # * PIPELINE TEST #4 MONITOR ! 14: 14 00028632 # * ! 15: 15 00028632 # * This test will do: ! 16: 16 00028632 # * ! 17: 17 00028632 # * LDF(x) STF LDF(1) MULF(1) MULF(x) STF ! 18: 18 00028632 # * ! 19: 19 00028632 # * where x is the fmacro1 LDF data. This test verifies the store after the ! 20: 20 00028632 # * LDF and the LDF after the store. It will also verify all of the MULF's ! 21: 21 00028632 # * B entry points. ! 22: 22 00028632 # *****************************************************************************/ ! 23: 23 00028632 # pipe_4() ! 24: 24 00028632 # { ! 25: 25 00028632 13 00a8 jbr L217 ! 26: 26 00028635 L218: ! 27: 27 00028635 # asm(".globl _pipeline_4_t"); ! 28: 28 00028635 .globl _pipeline_4_t ! 29: 29 00028635 # asm("_pipeline_4_t:"); /* entry address */ ! 30: 30 00028635 _pipeline_4_t: ! 31: 31 00028635 # if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */ ! 32: 32 00028635 1d effffffff5 01 cmpl _cycle,$1 ! 33: 33 0002863C 21 15 jneq L219 ! 34: 34 0002863E 5d efffffffec tstl _prt_hdrs ! 35: 35 00028644 31 0d jeql L219 ! 36: 36 00028646 # { ! 37: 37 00028646 # writes(" PIPE_4 "); ! 38: 38 00028646 .data 1 ! 39: 39 00000d78 * L221: ! 40: 40 00000d78 * 20504950455F342000 .ascii " PIPE_4 \0" ! 41: 41 00000d81 * .text ! 42: 42 00028646 dd 8f00000d78 pushl $L221 ! 43: 43 0002864C fe 08 efffffffdd callf $8,_writes ! 44: 44 00028653 # } ! 45: 45 00028653 # subtest = 1; ! 46: 46 00028653 L219: ! 47: 47 00028653 0d 01 efffffffd6 movl $1,_subtest ! 48: 48 0002865A # pipe4_1(); /* data in REGs, no NOPs */ ! 49: 49 0002865A fe 04 ef0000007f callf $4,_pipe4_1 ! 50: 50 00028661 # subtest++; /* increment subtest num */ ! 51: 51 00028661 6d efffffffc9 incl _subtest ! 52: 52 00028667 # pipe4_2(); /* data in REGs, 1 NOP */ ! 53: 53 00028667 fe 04 ef00000166 callf $4,_pipe4_2 ! 54: 54 0002866E # subtest++; /* increment subtest num */ ! 55: 55 0002866E 6d efffffffbc incl _subtest ! 56: 56 00028674 # pipe4_3(); /* data in REGs, 2 NOPs */ ! 57: 57 00028674 fe 04 ef00000251 callf $4,_pipe4_3 ! 58: 58 0002867B # subtest++; /* increment subtest num */ ! 59: 59 0002867B 6d efffffffaf incl _subtest ! 60: 60 00028681 # pipe4_4(); /* data in REGs, 3 NOPs */ ! 61: 61 00028681 fe 04 ef00000342 callf $4,_pipe4_4 ! 62: 62 00028688 # subtest++; /* increment subtest num */ ! 63: 63 00028688 6d efffffffa2 incl _subtest ! 64: 64 0002868E # pipe4_5(); /* data in CACHE, no NOPs */ ! 65: 65 0002868E fe 04 ef00000437 callf $4,_pipe4_5 ! 66: 66 00028695 # subtest++; /* increment subtest num */ ! 67: 67 00028695 6d efffffff95 incl _subtest ! 68: 68 0002869B # pipe4_6(); /* data in CACHE, 1 NOP */ ! 69: 69 0002869B fe 04 ef0000051a callf $4,_pipe4_6 ! 70: 70 000286A2 # subtest++; /* increment subtest num */ ! 71: 71 000286A2 6d efffffff88 incl _subtest ! 72: 72 000286A8 # pipe4_7(); /* data in CACHE, 2 NOPs */ ! 73: 73 000286A8 fe 04 ef00000601 callf $4,_pipe4_7 ! 74: 74 000286AF # subtest++; /* increment subtest num */ ! 75: 75 000286AF 6d efffffff7b incl _subtest ! 76: 76 000286B5 # pipe4_8(); /* data in CACHE, 3 NOPs */ ! 77: 77 000286B5 fe 04 ef000006ee callf $4,_pipe4_8 ! 78: 78 000286BC # subtest++; /* increment subtest num */ ! 79: 79 000286BC 6d efffffff6e incl _subtest ! 80: 80 000286C2 # pipe4_9(); /* data on STACK, no NOPs */ ! 81: 81 000286C2 fe 04 ef000007df callf $4,_pipe4_9 ! 82: 82 000286C9 # subtest++; /* increment subtest num */ ! 83: 83 000286C9 6d efffffff61 incl _subtest ! 84: 84 000286CF # pipe4_10(); /* data via FP no NOPs */ ! 85: 85 000286CF fe 04 ef00000968 callf $4,_pipe4_10 ! 86: 86 000286D6 # asm("jmp *return"); /* return to the test monitor */ ! 87: 87 000286D6 71 ffffffff54 jmp *return ! 88: 88 000286DC # } ! 89: 89 000286DC 40 ret#2 ! 90: 90 000286DD .set L215,0x0 ! 91: 91 000286DD L217: ! 92: 92 000286DD 13 ff55 jbr L218 ! 93: 93 000286E0 .data ! 94: 94 00000d78 * .text ! 95: 95 000286E0 .align 1 ! 96: 96 000286E0 .globl _pipe4_1 ! 97: 97 000286E0 _pipe4_1: ! 98: 98 000286E0 0000 .word L232 ! 99: 99 000286E2 # ! 100: 100 000286E2 # ! 101: 101 000286E2 # ! 102: 102 000286E2 # ! 103: 103 000286E2 # ! 104: 104 000286E2 # ! 105: 105 000286E2 # /************************************************************************ ! 106: 106 000286E2 # * ! 107: 107 000286E2 # * SUBTEST 1 ! 108: 108 000286E2 # * data in registers, no NO-OPs ! 109: 109 000286E2 # * ! 110: 110 000286E2 # ************************************************************************/ ! 111: 111 000286E2 # pipe4_1() ! 112: 112 000286E2 # { ! 113: 113 000286E2 13 00eb jbr L234 ! 114: 114 000286E5 L235: ! 115: 115 000286E5 # force_loop = FALSE; /* clear force_loop flag */ ! 116: 116 000286E5 4d efffffff45 clrl _force_loop ! 117: 117 000286EB # index = 0; ! 118: 118 000286EB 4d efffffff3f clrl _index ! 119: 119 000286F1 # do ! 120: 120 000286F1 L238: ! 121: 121 000286F1 # { ! 122: 122 000286F1 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */ ! 123: 123 000286F1 0d efffffff39 50 movl _index,r0 ! 124: 124 000286F8 48 03 50 50 shll $3,r0,r0 ! 125: 125 000286FC 0d e000000000 efffffff29 movl _ldf_1_data(r0),_sgl_value_1 ! 126: 126 00028707 # sgl_expected = ldf_1_data[index].exp; /* get expected results */ ! 127: 127 00028707 0d efffffff23 50 movl _index,r0 ! 128: 128 0002870E 48 03 50 50 shll $3,r0,r0 ! 129: 129 00028712 0d e000000004 efffffff13 movl _ldf_1_data+4(r0),_sgl_expected ! 130: 130 0002871D # sgl_value_2 = 0x40800000; /* floating '1' */ ! 131: 131 0002871D 0d 8f40800000 efffffff08 movl $1082130432,_sgl_value_2 ! 132: 132 00028728 # /* ! 133: 133 00028728 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 134: 134 00028728 # * The force loop flag is set after the first error. ! 135: 135 00028728 # */ ! 136: 136 00028728 # asm("_pipe4_1_lp1:"); ! 137: 137 00028728 _pipe4_1_lp1: ! 138: 138 00028728 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */ ! 139: 139 00028728 0d efffffff02 54 movl _sgl_value_1,r4 ! 140: 140 0002872F # asm("movl _sgl_value_2,r5"); /* move data to r5 */ ! 141: 141 0002872F 0d effffffefb 55 movl _sgl_value_2,r5 ! 142: 142 00028736 # asm("ldf r4"); /* load the operand */ ! 143: 143 00028736 06 54 ldf r4 ! 144: 144 00028738 # asm("stf r7"); /* store the result */ ! 145: 145 00028738 26 57 stf r7 ! 146: 146 0002873A # asm("ldf r5"); /* load a floating '1' */ ! 147: 147 0002873A 06 55 ldf r5 ! 148: 148 0002873C # asm("mulf r5"); /* multipy by a '1' */ ! 149: 149 0002873C e6 55 mulf r5 ! 150: 150 0002873E # asm("mulf r4"); /* multipy by the operand */ ! 151: 151 0002873E e6 54 mulf r4 ! 152: 152 00028740 # asm("stf r8"); /* store the result */ ! 153: 153 00028740 26 58 stf r8 ! 154: 154 00028742 # if( force_loop ); ! 155: 155 00028742 5d effffffee8 tstl _force_loop ! 156: 156 00028748 31 00 jeql L239 ! 157: 157 0002874A # asm("brb _pipe4_1_lp1");; /* loop on the error */ ! 158: 158 0002874A L239: ! 159: 159 0002874A 11 dc brb _pipe4_1_lp1 ! 160: 160 0002874C # /* ! 161: 161 0002874C # * verify the results ! 162: 162 0002874C # */ ! 163: 163 0002874C # asm("movl r7,_sgl_st_acc"); /* get the 1st store value */ ! 164: 164 0002874C 0d 57 effffffedd movl r7,_sgl_st_acc ! 165: 165 00028753 # asm("movl r8,_sgl_value_6"); /* get the 2nd store value */ ! 166: 166 00028753 0d 58 effffffed6 movl r8,_sgl_value_6 ! 167: 167 0002875A # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */ ! 168: 168 0002875A # (sgl_value_6 != sgl_expected) ) ! 169: 169 0002875A 1d effffffed0 effffffecb cmpl _sgl_st_acc,_sgl_expected ! 170: 170 00028765 21 0d jneq L9999 ! 171: 171 00028767 1d effffffec3 effffffebe cmpl _sgl_value_6,_sgl_expected ! 172: 172 00028772 31 42 jeql L240 ! 173: 173 00028774 L9999: ! 174: 174 00028774 # { ! 175: 175 00028774 # errcnt++; /* bump the error count */ ! 176: 176 00028774 6d effffffeb6 incl _errcnt ! 177: 177 0002877A # if ( prt_error ) ! 178: 178 0002877A 5d effffffeb0 tstl _prt_error ! 179: 179 00028780 31 0d jeql L241 ! 180: 180 00028782 # print_pipe4_er("Reg. Data, no NO-OPs"); ! 181: 181 00028782 .data 1 ! 182: 182 00000d81 * L243: ! 183: 183 00000d81 * 5265672E20446174612C206E6 .ascii "Reg. Data, no NO-OPs\0" ! 184: F204E4F2D4F507300 ! 185: 184 00000d96 * .text ! 186: 185 00028782 dd 8f00000d81 pushl $L243 ! 187: 186 00028788 fe 08 ef00000a7f callf $8,_print_pipe4_er ! 188: 187 0002878F # if ( halt_flg ) ! 189: 188 0002878F L241: ! 190: 189 0002878F 5d effffffe9b tstl _halt_flg ! 191: 190 00028795 31 0d jeql L244 ! 192: 191 00028797 # pipe4_er_hlt( subtest ); ! 193: 192 00028797 dd effffffe93 pushl _subtest ! 194: 193 0002879D fe 08 ef00000b90 callf $8,_pipe4_er_hlt ! 195: 194 000287A4 # if ( loop_on_err ) { ! 196: 195 000287A4 L244: ! 197: 196 000287A4 5d effffffe86 tstl _loop_on_err ! 198: 197 000287AA 31 0a jeql L246 ! 199: 198 000287AC # force_loop = TRUE; /* set the force loop flag */ ! 200: 199 000287AC 0d 01 effffffe7d movl $1,_force_loop ! 201: 200 000287B3 # asm("brw _pipe4_1_lp1"); /* and loop */ ! 202: 201 000287B3 13 ff72 brw _pipe4_1_lp1 ! 203: 202 000287B6 # } ! 204: 203 000287B6 # } /* end of compare error */ ! 205: 204 000287B6 L246: ! 206: 205 000287B6 # } while( index++ < max_ldf_1_index ); ! 207: 206 000287B6 L240: ! 208: 207 000287B6 L237: ! 209: 208 000287B6 0d effffffe74 50 movl _index,r0 ! 210: 209 000287BD 6d effffffe6d incl _index ! 211: 210 000287C3 1d 50 effffffe66 cmpl r0,_max_ldf_1_index ! 212: 211 000287CA 81 03 13 ff22 jlss L238 ! 213: 212 000287CF L236: ! 214: 213 000287CF # } /* end of subtest 1 */ ! 215: 214 000287CF 40 ret#2 ! 216: 215 000287D0 .set L232,0x0 ! 217: 216 000287D0 L234: ! 218: 217 000287D0 13 ff12 jbr L235 ! 219: 218 000287D3 .data ! 220: 219 00000d78 * .text ! 221: 220 000287D3 00 .align 1 ! 222: 221 000287D4 .globl _pipe4_2 ! 223: 222 000287D4 _pipe4_2: ! 224: 223 000287D4 0000 .word L247 ! 225: 224 000287D6 # ! 226: 225 000287D6 # ! 227: 226 000287D6 # ! 228: 227 000287D6 # ! 229: 228 000287D6 # ! 230: 229 000287D6 # ! 231: 230 000287D6 # /************************************************************************ ! 232: 231 000287D6 # * ! 233: 232 000287D6 # * SUBTEST 2 ! 234: 233 000287D6 # * data in registers, 1 NO-OP ! 235: 234 000287D6 # * ! 236: 235 000287D6 # ************************************************************************/ ! 237: 236 000287D6 # pipe4_2() ! 238: 237 000287D6 # { ! 239: 238 000287D6 13 00f0 jbr L249 ! 240: 239 000287D9 L250: ! 241: 240 000287D9 # force_loop = FALSE; /* clear force_loop flag */ ! 242: 241 000287D9 4d effffffe51 clrl _force_loop ! 243: 242 000287DF # index = 0; ! 244: 243 000287DF 4d effffffe4b clrl _index ! 245: 244 000287E5 # do ! 246: 245 000287E5 L253: ! 247: 246 000287E5 # { ! 248: 247 000287E5 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */ ! 249: 248 000287E5 0d effffffe45 50 movl _index,r0 ! 250: 249 000287EC 48 03 50 50 shll $3,r0,r0 ! 251: 250 000287F0 0d e000000000 effffffe35 movl _ldf_1_data(r0),_sgl_value_1 ! 252: 251 000287FB # sgl_expected = ldf_1_data[index].exp; /* get expected results */ ! 253: 252 000287FB 0d effffffe2f 50 movl _index,r0 ! 254: 253 00028802 48 03 50 50 shll $3,r0,r0 ! 255: 254 00028806 0d e000000004 effffffe1f movl _ldf_1_data+4(r0),_sgl_expected ! 256: 255 00028811 # sgl_value_2 = 0x40800000; /* floating '1' */ ! 257: 256 00028811 0d 8f40800000 effffffe14 movl $1082130432,_sgl_value_2 ! 258: 257 0002881C # /* ! 259: 258 0002881C # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 260: 259 0002881C # * The force loop flag is set after the first error. ! 261: 260 0002881C # */ ! 262: 261 0002881C # asm("_pipe4_2_lp1:"); ! 263: 262 0002881C _pipe4_2_lp1: ! 264: 263 0002881C # asm("movl _sgl_value_1,r4"); /* move the data to r4 */ ! 265: 264 0002881C 0d effffffe0e 54 movl _sgl_value_1,r4 ! 266: 265 00028823 # asm("movl _sgl_value_2,r5"); /* move data to r5 */ ! 267: 266 00028823 0d effffffe07 55 movl _sgl_value_2,r5 ! 268: 267 0002882A # asm("ldf r4"); /* load the operand */ ! 269: 268 0002882A 06 54 ldf r4 ! 270: 269 0002882C # asm("nop"); ! 271: 270 0002882C 10 nop ! 272: 271 0002882D # asm("stf r7"); /* store the result */ ! 273: 272 0002882D 26 57 stf r7 ! 274: 273 0002882F # asm("nop"); ! 275: 274 0002882F 10 nop ! 276: 275 00028830 # asm("ldf r5"); /* load a floating '1' */ ! 277: 276 00028830 06 55 ldf r5 ! 278: 277 00028832 # asm("nop"); ! 279: 278 00028832 10 nop ! 280: 279 00028833 # asm("mulf r5"); /* multipy by a '1' */ ! 281: 280 00028833 e6 55 mulf r5 ! 282: 281 00028835 # asm("nop"); ! 283: 282 00028835 10 nop ! 284: 283 00028836 # asm("mulf r4"); /* multipy by the operand */ ! 285: 284 00028836 e6 54 mulf r4 ! 286: 285 00028838 # asm("nop"); ! 287: 286 00028838 10 nop ! 288: 287 00028839 # asm("stf r8"); /* store the result */ ! 289: 288 00028839 26 58 stf r8 ! 290: 289 0002883B # if( force_loop ); ! 291: 290 0002883B 5d effffffdef tstl _force_loop ! 292: 291 00028841 31 00 jeql L254 ! 293: 292 00028843 # asm("brb _pipe4_2_lp1");; /* loop on the error */ ! 294: 293 00028843 L254: ! 295: 294 00028843 11 d7 brb _pipe4_2_lp1 ! 296: 295 00028845 # /* ! 297: 296 00028845 # * verify the results ! 298: 297 00028845 # */ ! 299: 298 00028845 # asm("movl r7,_sgl_st_acc"); /* get the 1st store value */ ! 300: 299 00028845 0d 57 effffffde4 movl r7,_sgl_st_acc ! 301: 300 0002884C # asm("movl r8,_sgl_value_6"); /* get the 2nd store value */ ! 302: 301 0002884C 0d 58 effffffddd movl r8,_sgl_value_6 ! 303: 302 00028853 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */ ! 304: 303 00028853 # (sgl_value_6 != sgl_expected) ) ! 305: 304 00028853 1d effffffdd7 effffffdd2 cmpl _sgl_st_acc,_sgl_expected ! 306: 305 0002885E 21 0d jneq L9998 ! 307: 306 00028860 1d effffffdca effffffdc5 cmpl _sgl_value_6,_sgl_expected ! 308: 307 0002886B 31 42 jeql L255 ! 309: 308 0002886D L9998: ! 310: 309 0002886D # { ! 311: 310 0002886D # errcnt++; /* bump the error count */ ! 312: 311 0002886D 6d effffffdbd incl _errcnt ! 313: 312 00028873 # if ( prt_error ) ! 314: 313 00028873 5d effffffdb7 tstl _prt_error ! 315: 314 00028879 31 0d jeql L256 ! 316: 315 0002887B # print_pipe4_er("Reg. Data, 1 NO-OP"); ! 317: 316 0002887B .data 1 ! 318: 317 00000d96 * L257: ! 319: 318 00000d96 * 5265672E20446174612C20312 .ascii "Reg. Data, 1 NO-OP\0" ! 320: 04E4F2D4F5000 ! 321: 319 00000da9 * .text ! 322: 320 0002887B dd 8f00000d96 pushl $L257 ! 323: 321 00028881 fe 08 ef00000986 callf $8,_print_pipe4_er ! 324: 322 00028888 # if ( halt_flg ) ! 325: 323 00028888 L256: ! 326: 324 00028888 5d effffffda2 tstl _halt_flg ! 327: 325 0002888E 31 0d jeql L258 ! 328: 326 00028890 # pipe4_er_hlt( subtest ); ! 329: 327 00028890 dd effffffd9a pushl _subtest ! 330: 328 00028896 fe 08 ef00000a97 callf $8,_pipe4_er_hlt ! 331: 329 0002889D # if ( loop_on_err ) { ! 332: 330 0002889D L258: ! 333: 331 0002889D 5d effffffd8d tstl _loop_on_err ! 334: 332 000288A3 31 0a jeql L259 ! 335: 333 000288A5 # force_loop = TRUE; /* set the force loop flag */ ! 336: 334 000288A5 0d 01 effffffd84 movl $1,_force_loop ! 337: 335 000288AC # asm("brw _pipe4_2_lp1"); /* and loop */ ! 338: 336 000288AC 13 ff6d brw _pipe4_2_lp1 ! 339: 337 000288AF # } ! 340: 338 000288AF # } /* end of compare error */ ! 341: 339 000288AF L259: ! 342: 340 000288AF # } while( index++ < max_ldf_1_index ); ! 343: 341 000288AF L255: ! 344: 342 000288AF L252: ! 345: 343 000288AF 0d effffffd7b 50 movl _index,r0 ! 346: 344 000288B6 6d effffffd74 incl _index ! 347: 345 000288BC 1d 50 effffffd6d cmpl r0,_max_ldf_1_index ! 348: 346 000288C3 81 03 13 ff1d jlss L253 ! 349: 347 000288C8 L251: ! 350: 348 000288C8 # } /* end of subtest 2 */ ! 351: 349 000288C8 40 ret#2 ! 352: 350 000288C9 .set L247,0x0 ! 353: 351 000288C9 L249: ! 354: 352 000288C9 13 ff0d jbr L250 ! 355: 353 000288CC .data ! 356: 354 00000d78 * .text ! 357: 355 000288CC .align 1 ! 358: 356 000288CC .globl _pipe4_3 ! 359: 357 000288CC _pipe4_3: ! 360: 358 000288CC 0000 .word L260 ! 361: 359 000288CE # ! 362: 360 000288CE # ! 363: 361 000288CE # ! 364: 362 000288CE # ! 365: 363 000288CE # ! 366: 364 000288CE # ! 367: 365 000288CE # /************************************************************************ ! 368: 366 000288CE # * ! 369: 367 000288CE # * SUBTEST 3 ! 370: 368 000288CE # * data in registers, 2 NO-OPs ! 371: 369 000288CE # * ! 372: 370 000288CE # ************************************************************************/ ! 373: 371 000288CE # pipe4_3() ! 374: 372 000288CE # { ! 375: 373 000288CE 13 00f5 jbr L262 ! 376: 374 000288D1 L263: ! 377: 375 000288D1 # force_loop = FALSE; /* clear force_loop flag */ ! 378: 376 000288D1 4d effffffd59 clrl _force_loop ! 379: 377 000288D7 # index = 0; ! 380: 378 000288D7 4d effffffd53 clrl _index ! 381: 379 000288DD # do ! 382: 380 000288DD L266: ! 383: 381 000288DD # { ! 384: 382 000288DD # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */ ! 385: 383 000288DD 0d effffffd4d 50 movl _index,r0 ! 386: 384 000288E4 48 03 50 50 shll $3,r0,r0 ! 387: 385 000288E8 0d e000000000 effffffd3d movl _ldf_1_data(r0),_sgl_value_1 ! 388: 386 000288F3 # sgl_expected = ldf_1_data[index].exp; /* get expected results */ ! 389: 387 000288F3 0d effffffd37 50 movl _index,r0 ! 390: 388 000288FA 48 03 50 50 shll $3,r0,r0 ! 391: 389 000288FE 0d e000000004 effffffd27 movl _ldf_1_data+4(r0),_sgl_expected ! 392: 390 00028909 # sgl_value_2 = 0x40800000; /* floating '1' */ ! 393: 391 00028909 0d 8f40800000 effffffd1c movl $1082130432,_sgl_value_2 ! 394: 392 00028914 # /* ! 395: 393 00028914 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 396: 394 00028914 # * The force loop flag is set after the first error. ! 397: 395 00028914 # */ ! 398: 396 00028914 # asm("_pipe4_3_lp1:"); ! 399: 397 00028914 _pipe4_3_lp1: ! 400: 398 00028914 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */ ! 401: 399 00028914 0d effffffd16 54 movl _sgl_value_1,r4 ! 402: 400 0002891B # asm("movl _sgl_value_2,r5"); /* move data to r5 */ ! 403: 401 0002891B 0d effffffd0f 55 movl _sgl_value_2,r5 ! 404: 402 00028922 # asm("ldf r4"); /* load the operand */ ! 405: 403 00028922 06 54 ldf r4 ! 406: 404 00028924 # asm("nop"); ! 407: 405 00028924 10 nop ! 408: 406 00028925 # asm("nop"); ! 409: 407 00028925 10 nop ! 410: 408 00028926 # asm("stf r7"); /* store the result */ ! 411: 409 00028926 26 57 stf r7 ! 412: 410 00028928 # asm("nop"); ! 413: 411 00028928 10 nop ! 414: 412 00028929 # asm("nop"); ! 415: 413 00028929 10 nop ! 416: 414 0002892A # asm("ldf r5"); /* load a floating '1' */ ! 417: 415 0002892A 06 55 ldf r5 ! 418: 416 0002892C # asm("nop"); ! 419: 417 0002892C 10 nop ! 420: 418 0002892D # asm("nop"); ! 421: 419 0002892D 10 nop ! 422: 420 0002892E # asm("mulf r5"); /* multipy by a '1' */ ! 423: 421 0002892E e6 55 mulf r5 ! 424: 422 00028930 # asm("nop"); ! 425: 423 00028930 10 nop ! 426: 424 00028931 # asm("nop"); ! 427: 425 00028931 10 nop ! 428: 426 00028932 # asm("mulf r4"); /* multipy by the operand */ ! 429: 427 00028932 e6 54 mulf r4 ! 430: 428 00028934 # asm("nop"); ! 431: 429 00028934 10 nop ! 432: 430 00028935 # asm("nop"); ! 433: 431 00028935 10 nop ! 434: 432 00028936 # asm("stf r8"); /* store the result */ ! 435: 433 00028936 26 58 stf r8 ! 436: 434 00028938 # if( force_loop ); ! 437: 435 00028938 5d effffffcf2 tstl _force_loop ! 438: 436 0002893E 31 00 jeql L267 ! 439: 437 00028940 # asm("brb _pipe4_3_lp1");; /* loop on the error */ ! 440: 438 00028940 L267: ! 441: 439 00028940 11 d2 brb _pipe4_3_lp1 ! 442: 440 00028942 # /* ! 443: 441 00028942 # * verify the results ! 444: 442 00028942 # */ ! 445: 443 00028942 # asm("movl r7,_sgl_st_acc"); /* get the 1st store value */ ! 446: 444 00028942 0d 57 effffffce7 movl r7,_sgl_st_acc ! 447: 445 00028949 # asm("movl r8,_sgl_value_6"); /* get the 2nd store value */ ! 448: 446 00028949 0d 58 effffffce0 movl r8,_sgl_value_6 ! 449: 447 00028950 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */ ! 450: 448 00028950 # (sgl_value_6 != sgl_expected) ) ! 451: 449 00028950 1d effffffcda effffffcd5 cmpl _sgl_st_acc,_sgl_expected ! 452: 450 0002895B 21 0d jneq L9997 ! 453: 451 0002895D 1d effffffccd effffffcc8 cmpl _sgl_value_6,_sgl_expected ! 454: 452 00028968 31 42 jeql L268 ! 455: 453 0002896A L9997: ! 456: 454 0002896A # { ! 457: 455 0002896A # errcnt++; /* bump the error count */ ! 458: 456 0002896A 6d effffffcc0 incl _errcnt ! 459: 457 00028970 # if ( prt_error ) ! 460: 458 00028970 5d effffffcba tstl _prt_error ! 461: 459 00028976 31 0d jeql L269 ! 462: 460 00028978 # print_pipe4_er("Reg. Data, 2 NO-OPs"); ! 463: 461 00028978 .data 1 ! 464: 462 00000da9 * L270: ! 465: 463 00000da9 * 5265672E20446174612C20322 .ascii "Reg. Data, 2 NO-OPs\0" ! 466: 04E4F2D4F507300 ! 467: 464 00000dbd * .text ! 468: 465 00028978 dd 8f00000da9 pushl $L270 ! 469: 466 0002897E fe 08 ef00000889 callf $8,_print_pipe4_er ! 470: 467 00028985 # if ( halt_flg ) ! 471: 468 00028985 L269: ! 472: 469 00028985 5d effffffca5 tstl _halt_flg ! 473: 470 0002898B 31 0d jeql L271 ! 474: 471 0002898D # pipe4_er_hlt( subtest ); ! 475: 472 0002898D dd effffffc9d pushl _subtest ! 476: 473 00028993 fe 08 ef0000099a callf $8,_pipe4_er_hlt ! 477: 474 0002899A # if ( loop_on_err ) { ! 478: 475 0002899A L271: ! 479: 476 0002899A 5d effffffc90 tstl _loop_on_err ! 480: 477 000289A0 31 0a jeql L272 ! 481: 478 000289A2 # force_loop = TRUE; /* set the force loop flag */ ! 482: 479 000289A2 0d 01 effffffc87 movl $1,_force_loop ! 483: 480 000289A9 # asm("brw _pipe4_3_lp1"); /* and loop */ ! 484: 481 000289A9 13 ff68 brw _pipe4_3_lp1 ! 485: 482 000289AC # } ! 486: 483 000289AC # } /* end of compare error */ ! 487: 484 000289AC L272: ! 488: 485 000289AC # } while( index++ < max_ldf_1_index ); ! 489: 486 000289AC L268: ! 490: 487 000289AC L265: ! 491: 488 000289AC 0d effffffc7e 50 movl _index,r0 ! 492: 489 000289B3 6d effffffc77 incl _index ! 493: 490 000289B9 1d 50 effffffc70 cmpl r0,_max_ldf_1_index ! 494: 491 000289C0 81 03 13 ff18 jlss L266 ! 495: 492 000289C5 L264: ! 496: 493 000289C5 # } /* end of subtest 3 */ ! 497: 494 000289C5 40 ret#2 ! 498: 495 000289C6 .set L260,0x0 ! 499: 496 000289C6 L262: ! 500: 497 000289C6 13 ff08 jbr L263 ! 501: 498 000289C9 .data ! 502: 499 00000d78 * .text ! 503: 500 000289C9 00 .align 1 ! 504: 501 000289CA .globl _pipe4_4 ! 505: 502 000289CA _pipe4_4: ! 506: 503 000289CA 0000 .word L273 ! 507: 504 000289CC # ! 508: 505 000289CC # ! 509: 506 000289CC # ! 510: 507 000289CC # ! 511: 508 000289CC # ! 512: 509 000289CC # ! 513: 510 000289CC # /************************************************************************ ! 514: 511 000289CC # * ! 515: 512 000289CC # * SUBTEST 4 ! 516: 513 000289CC # * data in registers, 3 NO-OPs ! 517: 514 000289CC # * ! 518: 515 000289CC # ************************************************************************/ ! 519: 516 000289CC # pipe4_4() ! 520: 517 000289CC # { ! 521: 518 000289CC 13 00fa jbr L275 ! 522: 519 000289CF L276: ! 523: 520 000289CF # force_loop = FALSE; /* clear force_loop flag */ ! 524: 521 000289CF 4d effffffc5b clrl _force_loop ! 525: 522 000289D5 # index = 0; ! 526: 523 000289D5 4d effffffc55 clrl _index ! 527: 524 000289DB # do ! 528: 525 000289DB L279: ! 529: 526 000289DB # { ! 530: 527 000289DB # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */ ! 531: 528 000289DB 0d effffffc4f 50 movl _index,r0 ! 532: 529 000289E2 48 03 50 50 shll $3,r0,r0 ! 533: 530 000289E6 0d e000000000 effffffc3f movl _ldf_1_data(r0),_sgl_value_1 ! 534: 531 000289F1 # sgl_expected = ldf_1_data[index].exp; /* get expected results */ ! 535: 532 000289F1 0d effffffc39 50 movl _index,r0 ! 536: 533 000289F8 48 03 50 50 shll $3,r0,r0 ! 537: 534 000289FC 0d e000000004 effffffc29 movl _ldf_1_data+4(r0),_sgl_expected ! 538: 535 00028A07 # sgl_value_2 = 0x40800000; /* floating '1' */ ! 539: 536 00028A07 0d 8f40800000 effffffc1e movl $1082130432,_sgl_value_2 ! 540: 537 00028A12 # /* ! 541: 538 00028A12 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 542: 539 00028A12 # * The force loop flag is set after the first error. ! 543: 540 00028A12 # */ ! 544: 541 00028A12 # asm("_pipe4_4_lp1:"); ! 545: 542 00028A12 _pipe4_4_lp1: ! 546: 543 00028A12 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */ ! 547: 544 00028A12 0d effffffc18 54 movl _sgl_value_1,r4 ! 548: 545 00028A19 # asm("movl _sgl_value_2,r5"); /* move data to r5 */ ! 549: 546 00028A19 0d effffffc11 55 movl _sgl_value_2,r5 ! 550: 547 00028A20 # asm("ldf r4"); /* load the operand */ ! 551: 548 00028A20 06 54 ldf r4 ! 552: 549 00028A22 # asm("nop"); ! 553: 550 00028A22 10 nop ! 554: 551 00028A23 # asm("nop"); ! 555: 552 00028A23 10 nop ! 556: 553 00028A24 # asm("nop"); ! 557: 554 00028A24 10 nop ! 558: 555 00028A25 # asm("stf r7"); /* store the result */ ! 559: 556 00028A25 26 57 stf r7 ! 560: 557 00028A27 # asm("nop"); ! 561: 558 00028A27 10 nop ! 562: 559 00028A28 # asm("nop"); ! 563: 560 00028A28 10 nop ! 564: 561 00028A29 # asm("nop"); ! 565: 562 00028A29 10 nop ! 566: 563 00028A2A # asm("ldf r5"); /* load a floating '1' */ ! 567: 564 00028A2A 06 55 ldf r5 ! 568: 565 00028A2C # asm("nop"); ! 569: 566 00028A2C 10 nop ! 570: 567 00028A2D # asm("nop"); ! 571: 568 00028A2D 10 nop ! 572: 569 00028A2E # asm("nop"); ! 573: 570 00028A2E 10 nop ! 574: 571 00028A2F # asm("mulf r5"); /* multipy by a '1' */ ! 575: 572 00028A2F e6 55 mulf r5 ! 576: 573 00028A31 # asm("nop"); ! 577: 574 00028A31 10 nop ! 578: 575 00028A32 # asm("nop"); ! 579: 576 00028A32 10 nop ! 580: 577 00028A33 # asm("nop"); ! 581: 578 00028A33 10 nop ! 582: 579 00028A34 # asm("mulf r4"); /* multipy by the operand */ ! 583: 580 00028A34 e6 54 mulf r4 ! 584: 581 00028A36 # asm("nop"); ! 585: 582 00028A36 10 nop ! 586: 583 00028A37 # asm("nop"); ! 587: 584 00028A37 10 nop ! 588: 585 00028A38 # asm("nop"); ! 589: 586 00028A38 10 nop ! 590: 587 00028A39 # asm("stf r8"); /* store the result */ ! 591: 588 00028A39 26 58 stf r8 ! 592: 589 00028A3B # if( force_loop ); ! 593: 590 00028A3B 5d effffffbef tstl _force_loop ! 594: 591 00028A41 31 00 jeql L280 ! 595: 592 00028A43 # asm("brb _pipe4_4_lp1");; /* loop on the error */ ! 596: 593 00028A43 L280: ! 597: 594 00028A43 11 cd brb _pipe4_4_lp1 ! 598: 595 00028A45 # /* ! 599: 596 00028A45 # * verify the results ! 600: 597 00028A45 # */ ! 601: 598 00028A45 # asm("movl r7,_sgl_st_acc"); /* get the 1st store value */ ! 602: 599 00028A45 0d 57 effffffbe4 movl r7,_sgl_st_acc ! 603: 600 00028A4C # asm("movl r8,_sgl_value_6"); /* get the 2nd store value */ ! 604: 601 00028A4C 0d 58 effffffbdd movl r8,_sgl_value_6 ! 605: 602 00028A53 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */ ! 606: 603 00028A53 # (sgl_value_6 != sgl_expected) ) ! 607: 604 00028A53 1d effffffbd7 effffffbd2 cmpl _sgl_st_acc,_sgl_expected ! 608: 605 00028A5E 21 0d jneq L9996 ! 609: 606 00028A60 1d effffffbca effffffbc5 cmpl _sgl_value_6,_sgl_expected ! 610: 607 00028A6B 31 42 jeql L281 ! 611: 608 00028A6D L9996: ! 612: 609 00028A6D # { ! 613: 610 00028A6D # errcnt++; /* bump the error count */ ! 614: 611 00028A6D 6d effffffbbd incl _errcnt ! 615: 612 00028A73 # if ( prt_error ) ! 616: 613 00028A73 5d effffffbb7 tstl _prt_error ! 617: 614 00028A79 31 0d jeql L282 ! 618: 615 00028A7B # print_pipe4_er("Reg. Data, 3 NO-OPs"); ! 619: 616 00028A7B .data 1 ! 620: 617 00000dbd * L283: ! 621: 618 00000dbd * 5265672E20446174612C20332 .ascii "Reg. Data, 3 NO-OPs\0" ! 622: 04E4F2D4F507300 ! 623: 619 00000dd1 * .text ! 624: 620 00028A7B dd 8f00000dbd pushl $L283 ! 625: 621 00028A81 fe 08 ef00000786 callf $8,_print_pipe4_er ! 626: 622 00028A88 # if ( halt_flg ) ! 627: 623 00028A88 L282: ! 628: 624 00028A88 5d effffffba2 tstl _halt_flg ! 629: 625 00028A8E 31 0d jeql L284 ! 630: 626 00028A90 # pipe4_er_hlt( subtest ); ! 631: 627 00028A90 dd effffffb9a pushl _subtest ! 632: 628 00028A96 fe 08 ef00000897 callf $8,_pipe4_er_hlt ! 633: 629 00028A9D # if ( loop_on_err ) { ! 634: 630 00028A9D L284: ! 635: 631 00028A9D 5d effffffb8d tstl _loop_on_err ! 636: 632 00028AA3 31 0a jeql L285 ! 637: 633 00028AA5 # force_loop = TRUE; /* set the force loop flag */ ! 638: 634 00028AA5 0d 01 effffffb84 movl $1,_force_loop ! 639: 635 00028AAC # asm("brw _pipe4_4_lp1"); /* and loop */ ! 640: 636 00028AAC 13 ff63 brw _pipe4_4_lp1 ! 641: 637 00028AAF # } ! 642: 638 00028AAF # } /* end of compare error */ ! 643: 639 00028AAF L285: ! 644: 640 00028AAF # } while( index++ < max_ldf_1_index ); ! 645: 641 00028AAF L281: ! 646: 642 00028AAF L278: ! 647: 643 00028AAF 0d effffffb7b 50 movl _index,r0 ! 648: 644 00028AB6 6d effffffb74 incl _index ! 649: 645 00028ABC 1d 50 effffffb6d cmpl r0,_max_ldf_1_index ! 650: 646 00028AC3 81 03 13 ff13 jlss L279 ! 651: 647 00028AC8 L277: ! 652: 648 00028AC8 # } /* end of subtest 4 */ ! 653: 649 00028AC8 40 ret#2 ! 654: 650 00028AC9 .set L273,0x0 ! 655: 651 00028AC9 L275: ! 656: 652 00028AC9 13 ff03 jbr L276 ! 657: 653 00028ACC .data ! 658: 654 00000d78 * .text ! 659: 655 00028ACC .align 1 ! 660: 656 00028ACC .globl _pipe4_5 ! 661: 657 00028ACC _pipe4_5: ! 662: 658 00028ACC 0000 .word L286 ! 663: 659 00028ACE # ! 664: 660 00028ACE # ! 665: 661 00028ACE # ! 666: 662 00028ACE # ! 667: 663 00028ACE # ! 668: 664 00028ACE # ! 669: 665 00028ACE # ! 670: 666 00028ACE # /************************************************************************ ! 671: 667 00028ACE # * ! 672: 668 00028ACE # * SUBTEST 5 ! 673: 669 00028ACE # * data in Cache, no NO-OPs ! 674: 670 00028ACE # * ! 675: 671 00028ACE # ************************************************************************/ ! 676: 672 00028ACE # pipe4_5() ! 677: 673 00028ACE # { ! 678: 674 00028ACE 13 00e7 jbr L288 ! 679: 675 00028AD1 L289: ! 680: 676 00028AD1 # force_loop = FALSE; /* clear force_loop flag */ ! 681: 677 00028AD1 4d effffffb59 clrl _force_loop ! 682: 678 00028AD7 # index = 0; ! 683: 679 00028AD7 4d effffffb53 clrl _index ! 684: 680 00028ADD # do ! 685: 681 00028ADD L292: ! 686: 682 00028ADD # { ! 687: 683 00028ADD # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */ ! 688: 684 00028ADD 0d effffffb4d 50 movl _index,r0 ! 689: 685 00028AE4 48 03 50 50 shll $3,r0,r0 ! 690: 686 00028AE8 0d e000000000 effffffb3d movl _ldf_1_data(r0),_sgl_value_1 ! 691: 687 00028AF3 # sgl_expected = ldf_1_data[index].exp; /* get expected results */ ! 692: 688 00028AF3 0d effffffb37 50 movl _index,r0 ! 693: 689 00028AFA 48 03 50 50 shll $3,r0,r0 ! 694: 690 00028AFE 0d e000000004 effffffb27 movl _ldf_1_data+4(r0),_sgl_expected ! 695: 691 00028B09 # sgl_value_2 = 0x40800000; /* floating '1' */ ! 696: 692 00028B09 0d 8f40800000 effffffb1c movl $1082130432,_sgl_value_2 ! 697: 693 00028B14 # /* ! 698: 694 00028B14 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 699: 695 00028B14 # * The force loop flag is set after the first error. ! 700: 696 00028B14 # */ ! 701: 697 00028B14 # asm("_pipe4_5_lp1:"); ! 702: 698 00028B14 _pipe4_5_lp1: ! 703: 699 00028B14 # asm("ldf _sgl_value_1"); /* load the operand */ ! 704: 700 00028B14 06 effffffb16 ldf _sgl_value_1 ! 705: 701 00028B1A # asm("stf _sgl_st_acc"); /* store the result */ ! 706: 702 00028B1A 26 effffffb10 stf _sgl_st_acc ! 707: 703 00028B20 # asm("ldf _sgl_value_2"); /* load a floating '1' */ ! 708: 704 00028B20 06 effffffb0a ldf _sgl_value_2 ! 709: 705 00028B26 # asm("mulf _sgl_value_2"); /* multipy by a '1' */ ! 710: 706 00028B26 e6 effffffb04 mulf _sgl_value_2 ! 711: 707 00028B2C # asm("mulf _sgl_value_1"); /* multipy by the operand */ ! 712: 708 00028B2C e6 effffffafe mulf _sgl_value_1 ! 713: 709 00028B32 # asm("stf _sgl_value_6"); /* store the result */ ! 714: 710 00028B32 26 effffffaf8 stf _sgl_value_6 ! 715: 711 00028B38 # if( force_loop ); ! 716: 712 00028B38 5d effffffaf2 tstl _force_loop ! 717: 713 00028B3E 31 00 jeql L293 ! 718: 714 00028B40 # asm("brb _pipe4_5_lp1");; /* loop on the error */ ! 719: 715 00028B40 L293: ! 720: 716 00028B40 11 d2 brb _pipe4_5_lp1 ! 721: 717 00028B42 # /* ! 722: 718 00028B42 # * verify the results ! 723: 719 00028B42 # */ ! 724: 720 00028B42 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */ ! 725: 721 00028B42 # (sgl_value_6 != sgl_expected) ) ! 726: 722 00028B42 1d effffffae8 effffffae3 cmpl _sgl_st_acc,_sgl_expected ! 727: 723 00028B4D 21 0d jneq L9995 ! 728: 724 00028B4F 1d effffffadb effffffad6 cmpl _sgl_value_6,_sgl_expected ! 729: 725 00028B5A 31 42 jeql L294 ! 730: 726 00028B5C L9995: ! 731: 727 00028B5C # { ! 732: 728 00028B5C # errcnt++; /* bump the error count */ ! 733: 729 00028B5C 6d efffffface incl _errcnt ! 734: 730 00028B62 # if ( prt_error ) ! 735: 731 00028B62 5d effffffac8 tstl _prt_error ! 736: 732 00028B68 31 0d jeql L295 ! 737: 733 00028B6A # print_pipe4_er("Cache Data, no NO-OPs"); ! 738: 734 00028B6A .data 1 ! 739: 735 00000dd1 * L296: ! 740: 736 00000dd1 * 436163686520446174612C206 .ascii "Cache Data, no NO-OPs\0" ! 741: E6F204E4F2D4F507300 ! 742: 737 00000de7 * .text ! 743: 738 00028B6A dd 8f00000dd1 pushl $L296 ! 744: 739 00028B70 fe 08 ef00000697 callf $8,_print_pipe4_er ! 745: 740 00028B77 # if ( halt_flg ) ! 746: 741 00028B77 L295: ! 747: 742 00028B77 5d effffffab3 tstl _halt_flg ! 748: 743 00028B7D 31 0d jeql L297 ! 749: 744 00028B7F # pipe4_er_hlt( subtest ); ! 750: 745 00028B7F dd effffffaab pushl _subtest ! 751: 746 00028B85 fe 08 ef000007a8 callf $8,_pipe4_er_hlt ! 752: 747 00028B8C # if ( loop_on_err ) { ! 753: 748 00028B8C L297: ! 754: 749 00028B8C 5d effffffa9e tstl _loop_on_err ! 755: 750 00028B92 31 0a jeql L298 ! 756: 751 00028B94 # force_loop = TRUE; /* set the force loop flag */ ! 757: 752 00028B94 0d 01 effffffa95 movl $1,_force_loop ! 758: 753 00028B9B # asm("brw _pipe4_5_lp1"); /* and loop */ ! 759: 754 00028B9B 13 ff76 brw _pipe4_5_lp1 ! 760: 755 00028B9E # } ! 761: 756 00028B9E # } /* end of compare error */ ! 762: 757 00028B9E L298: ! 763: 758 00028B9E # } while( index++ < max_ldf_1_index ); ! 764: 759 00028B9E L294: ! 765: 760 00028B9E L291: ! 766: 761 00028B9E 0d effffffa8c 50 movl _index,r0 ! 767: 762 00028BA5 6d effffffa85 incl _index ! 768: 763 00028BAB 1d 50 effffffa7e cmpl r0,_max_ldf_1_index ! 769: 764 00028BB2 81 03 13 ff26 jlss L292 ! 770: 765 00028BB7 L290: ! 771: 766 00028BB7 # } /* end of subtest 5 */ ! 772: 767 00028BB7 40 ret#2 ! 773: 768 00028BB8 .set L286,0x0 ! 774: 769 00028BB8 L288: ! 775: 770 00028BB8 13 ff16 jbr L289 ! 776: 771 00028BBB .data ! 777: 772 00000d78 * .text ! 778: 773 00028BBB 00 .align 1 ! 779: 774 00028BBC .globl _pipe4_6 ! 780: 775 00028BBC _pipe4_6: ! 781: 776 00028BBC 0000 .word L299 ! 782: 777 00028BBE # ! 783: 778 00028BBE # ! 784: 779 00028BBE # ! 785: 780 00028BBE # ! 786: 781 00028BBE # ! 787: 782 00028BBE # ! 788: 783 00028BBE # /************************************************************************ ! 789: 784 00028BBE # * ! 790: 785 00028BBE # * SUBTEST 6 ! 791: 786 00028BBE # * data in Cache, 1 NO-OP ! 792: 787 00028BBE # * ! 793: 788 00028BBE # ************************************************************************/ ! 794: 789 00028BBE # pipe4_6() ! 795: 790 00028BBE # { ! 796: 791 00028BBE 13 00ec jbr L301 ! 797: 792 00028BC1 L302: ! 798: 793 00028BC1 # force_loop = FALSE; /* clear force_loop flag */ ! 799: 794 00028BC1 4d effffffa69 clrl _force_loop ! 800: 795 00028BC7 # index = 0; ! 801: 796 00028BC7 4d effffffa63 clrl _index ! 802: 797 00028BCD # do ! 803: 798 00028BCD L305: ! 804: 799 00028BCD # { ! 805: 800 00028BCD # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */ ! 806: 801 00028BCD 0d effffffa5d 50 movl _index,r0 ! 807: 802 00028BD4 48 03 50 50 shll $3,r0,r0 ! 808: 803 00028BD8 0d e000000000 effffffa4d movl _ldf_1_data(r0),_sgl_value_1 ! 809: 804 00028BE3 # sgl_expected = ldf_1_data[index].exp; /* get expected results */ ! 810: 805 00028BE3 0d effffffa47 50 movl _index,r0 ! 811: 806 00028BEA 48 03 50 50 shll $3,r0,r0 ! 812: 807 00028BEE 0d e000000004 effffffa37 movl _ldf_1_data+4(r0),_sgl_expected ! 813: 808 00028BF9 # sgl_value_2 = 0x40800000; /* floating '1' */ ! 814: 809 00028BF9 0d 8f40800000 effffffa2c movl $1082130432,_sgl_value_2 ! 815: 810 00028C04 # /* ! 816: 811 00028C04 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 817: 812 00028C04 # * The force loop flag is set after the first error. ! 818: 813 00028C04 # */ ! 819: 814 00028C04 # asm("_pipe4_6_lp1:"); ! 820: 815 00028C04 _pipe4_6_lp1: ! 821: 816 00028C04 # asm("ldf _sgl_value_1"); /* load the operand */ ! 822: 817 00028C04 06 effffffa26 ldf _sgl_value_1 ! 823: 818 00028C0A # asm("nop"); ! 824: 819 00028C0A 10 nop ! 825: 820 00028C0B # asm("stf _sgl_st_acc"); /* store the result */ ! 826: 821 00028C0B 26 effffffa1f stf _sgl_st_acc ! 827: 822 00028C11 # asm("nop"); ! 828: 823 00028C11 10 nop ! 829: 824 00028C12 # asm("ldf _sgl_value_2"); /* load a floating '1' */ ! 830: 825 00028C12 06 effffffa18 ldf _sgl_value_2 ! 831: 826 00028C18 # asm("nop"); ! 832: 827 00028C18 10 nop ! 833: 828 00028C19 # asm("mulf _sgl_value_2"); /* multipy by a '1' */ ! 834: 829 00028C19 e6 effffffa11 mulf _sgl_value_2 ! 835: 830 00028C1F # asm("nop"); ! 836: 831 00028C1F 10 nop ! 837: 832 00028C20 # asm("mulf _sgl_value_1"); /* multipy by the operand */ ! 838: 833 00028C20 e6 effffffa0a mulf _sgl_value_1 ! 839: 834 00028C26 # asm("nop"); ! 840: 835 00028C26 10 nop ! 841: 836 00028C27 # asm("stf _sgl_value_6"); /* store the result */ ! 842: 837 00028C27 26 effffffa03 stf _sgl_value_6 ! 843: 838 00028C2D # if( force_loop ); ! 844: 839 00028C2D 5d effffff9fd tstl _force_loop ! 845: 840 00028C33 31 00 jeql L306 ! 846: 841 00028C35 # asm("brb _pipe4_6_lp1");; /* loop on the error */ ! 847: 842 00028C35 L306: ! 848: 843 00028C35 11 cd brb _pipe4_6_lp1 ! 849: 844 00028C37 # /* ! 850: 845 00028C37 # * verify the results ! 851: 846 00028C37 # */ ! 852: 847 00028C37 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */ ! 853: 848 00028C37 # (sgl_value_6 != sgl_expected) ) ! 854: 849 00028C37 1d effffff9f3 effffff9ee cmpl _sgl_st_acc,_sgl_expected ! 855: 850 00028C42 21 0d jneq L9994 ! 856: 851 00028C44 1d effffff9e6 effffff9e1 cmpl _sgl_value_6,_sgl_expected ! 857: 852 00028C4F 31 42 jeql L307 ! 858: 853 00028C51 L9994: ! 859: 854 00028C51 # { ! 860: 855 00028C51 # errcnt++; /* bump the error count */ ! 861: 856 00028C51 6d effffff9d9 incl _errcnt ! 862: 857 00028C57 # if ( prt_error ) ! 863: 858 00028C57 5d effffff9d3 tstl _prt_error ! 864: 859 00028C5D 31 0d jeql L308 ! 865: 860 00028C5F # print_pipe4_er("Cache Data, 1 NO-OP"); ! 866: 861 00028C5F .data 1 ! 867: 862 00000de7 * L309: ! 868: 863 00000de7 * 436163686520446174612C203 .ascii "Cache Data, 1 NO-OP\0" ! 869: 1204E4F2D4F5000 ! 870: 864 00000dfb * .text ! 871: 865 00028C5F dd 8f00000de7 pushl $L309 ! 872: 866 00028C65 fe 08 ef000005a2 callf $8,_print_pipe4_er ! 873: 867 00028C6C # if ( halt_flg ) ! 874: 868 00028C6C L308: ! 875: 869 00028C6C 5d effffff9be tstl _halt_flg ! 876: 870 00028C72 31 0d jeql L310 ! 877: 871 00028C74 # pipe4_er_hlt( subtest ); ! 878: 872 00028C74 dd effffff9b6 pushl _subtest ! 879: 873 00028C7A fe 08 ef000006b3 callf $8,_pipe4_er_hlt ! 880: 874 00028C81 # if ( loop_on_err ) { ! 881: 875 00028C81 L310: ! 882: 876 00028C81 5d effffff9a9 tstl _loop_on_err ! 883: 877 00028C87 31 0a jeql L311 ! 884: 878 00028C89 # force_loop = TRUE; /* set the force loop flag */ ! 885: 879 00028C89 0d 01 effffff9a0 movl $1,_force_loop ! 886: 880 00028C90 # asm("brw _pipe4_6_lp1"); /* and loop */ ! 887: 881 00028C90 13 ff71 brw _pipe4_6_lp1 ! 888: 882 00028C93 # } ! 889: 883 00028C93 # } /* end of compare error */ ! 890: 884 00028C93 L311: ! 891: 885 00028C93 # } while( index++ < max_ldf_1_index ); ! 892: 886 00028C93 L307: ! 893: 887 00028C93 L304: ! 894: 888 00028C93 0d effffff997 50 movl _index,r0 ! 895: 889 00028C9A 6d effffff990 incl _index ! 896: 890 00028CA0 1d 50 effffff989 cmpl r0,_max_ldf_1_index ! 897: 891 00028CA7 81 03 13 ff21 jlss L305 ! 898: 892 00028CAC L303: ! 899: 893 00028CAC # } /* end of subtest 6 */ ! 900: 894 00028CAC 40 ret#2 ! 901: 895 00028CAD .set L299,0x0 ! 902: 896 00028CAD L301: ! 903: 897 00028CAD 13 ff11 jbr L302 ! 904: 898 00028CB0 .data ! 905: 899 00000d78 * .text ! 906: 900 00028CB0 .align 1 ! 907: 901 00028CB0 .globl _pipe4_7 ! 908: 902 00028CB0 _pipe4_7: ! 909: 903 00028CB0 0000 .word L312 ! 910: 904 00028CB2 # ! 911: 905 00028CB2 # ! 912: 906 00028CB2 # ! 913: 907 00028CB2 # ! 914: 908 00028CB2 # ! 915: 909 00028CB2 # ! 916: 910 00028CB2 # /************************************************************************ ! 917: 911 00028CB2 # * ! 918: 912 00028CB2 # * SUBTEST 7 ! 919: 913 00028CB2 # * data in Cache, 2 NO-OPs ! 920: 914 00028CB2 # * ! 921: 915 00028CB2 # ************************************************************************/ ! 922: 916 00028CB2 # pipe4_7() ! 923: 917 00028CB2 # { ! 924: 918 00028CB2 13 00f1 jbr L314 ! 925: 919 00028CB5 L315: ! 926: 920 00028CB5 # force_loop = FALSE; /* clear force_loop flag */ ! 927: 921 00028CB5 4d effffff975 clrl _force_loop ! 928: 922 00028CBB # index = 0; ! 929: 923 00028CBB 4d effffff96f clrl _index ! 930: 924 00028CC1 # do ! 931: 925 00028CC1 L318: ! 932: 926 00028CC1 # { ! 933: 927 00028CC1 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */ ! 934: 928 00028CC1 0d effffff969 50 movl _index,r0 ! 935: 929 00028CC8 48 03 50 50 shll $3,r0,r0 ! 936: 930 00028CCC 0d e000000000 effffff959 movl _ldf_1_data(r0),_sgl_value_1 ! 937: 931 00028CD7 # sgl_expected = ldf_1_data[index].exp; /* get expected results */ ! 938: 932 00028CD7 0d effffff953 50 movl _index,r0 ! 939: 933 00028CDE 48 03 50 50 shll $3,r0,r0 ! 940: 934 00028CE2 0d e000000004 effffff943 movl _ldf_1_data+4(r0),_sgl_expected ! 941: 935 00028CED # sgl_value_2 = 0x40800000; /* floating '1' */ ! 942: 936 00028CED 0d 8f40800000 effffff938 movl $1082130432,_sgl_value_2 ! 943: 937 00028CF8 # /* ! 944: 938 00028CF8 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 945: 939 00028CF8 # * The force loop flag is set after the first error. ! 946: 940 00028CF8 # */ ! 947: 941 00028CF8 # asm("_pipe4_7_lp1:"); ! 948: 942 00028CF8 _pipe4_7_lp1: ! 949: 943 00028CF8 # asm("ldf _sgl_value_1"); /* load the operand */ ! 950: 944 00028CF8 06 effffff932 ldf _sgl_value_1 ! 951: 945 00028CFE # asm("nop"); ! 952: 946 00028CFE 10 nop ! 953: 947 00028CFF # asm("nop"); ! 954: 948 00028CFF 10 nop ! 955: 949 00028D00 # asm("stf _sgl_st_acc"); /* store the result */ ! 956: 950 00028D00 26 effffff92a stf _sgl_st_acc ! 957: 951 00028D06 # asm("nop"); ! 958: 952 00028D06 10 nop ! 959: 953 00028D07 # asm("nop"); ! 960: 954 00028D07 10 nop ! 961: 955 00028D08 # asm("ldf _sgl_value_2"); /* load a floating '1' */ ! 962: 956 00028D08 06 effffff922 ldf _sgl_value_2 ! 963: 957 00028D0E # asm("nop"); ! 964: 958 00028D0E 10 nop ! 965: 959 00028D0F # asm("nop"); ! 966: 960 00028D0F 10 nop ! 967: 961 00028D10 # asm("mulf _sgl_value_2"); /* multipy by '1' */ ! 968: 962 00028D10 e6 effffff91a mulf _sgl_value_2 ! 969: 963 00028D16 # asm("nop"); ! 970: 964 00028D16 10 nop ! 971: 965 00028D17 # asm("nop"); ! 972: 966 00028D17 10 nop ! 973: 967 00028D18 # asm("mulf _sgl_value_1"); /* multipy by the operand */ ! 974: 968 00028D18 e6 effffff912 mulf _sgl_value_1 ! 975: 969 00028D1E # asm("nop"); ! 976: 970 00028D1E 10 nop ! 977: 971 00028D1F # asm("nop"); ! 978: 972 00028D1F 10 nop ! 979: 973 00028D20 # asm("stf _sgl_value_6"); /* store the result */ ! 980: 974 00028D20 26 effffff90a stf _sgl_value_6 ! 981: 975 00028D26 # if( force_loop ); ! 982: 976 00028D26 5d effffff904 tstl _force_loop ! 983: 977 00028D2C 31 00 jeql L319 ! 984: 978 00028D2E # asm("brb _pipe4_7_lp1");; /* loop on the error */ ! 985: 979 00028D2E L319: ! 986: 980 00028D2E 11 c8 brb _pipe4_7_lp1 ! 987: 981 00028D30 # /* ! 988: 982 00028D30 # * verify the results ! 989: 983 00028D30 # */ ! 990: 984 00028D30 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */ ! 991: 985 00028D30 # (sgl_value_6 != sgl_expected) ) ! 992: 986 00028D30 1d effffff8fa effffff8f5 cmpl _sgl_st_acc,_sgl_expected ! 993: 987 00028D3B 21 0d jneq L9993 ! 994: 988 00028D3D 1d effffff8ed effffff8e8 cmpl _sgl_value_6,_sgl_expected ! 995: 989 00028D48 31 42 jeql L320 ! 996: 990 00028D4A L9993: ! 997: 991 00028D4A # { ! 998: 992 00028D4A # errcnt++; /* bump the error count */ ! 999: 993 00028D4A 6d effffff8e0 incl _errcnt ! 1000: 994 00028D50 # if ( prt_error ) ! 1001: 995 00028D50 5d effffff8da tstl _prt_error ! 1002: 996 00028D56 31 0d jeql L321 ! 1003: 997 00028D58 # print_pipe4_er("Cache Data, 2 NO-OPs"); ! 1004: 998 00028D58 .data 1 ! 1005: 999 00000dfb * L322: ! 1006: 1000 00000dfb * 436163686520446174612C203 .ascii "Cache Data, 2 NO-OPs\0" ! 1007: 2204E4F2D4F507300 ! 1008: 1001 00000e10 * .text ! 1009: 1002 00028D58 dd 8f00000dfb pushl $L322 ! 1010: 1003 00028D5E fe 08 ef000004a9 callf $8,_print_pipe4_er ! 1011: 1004 00028D65 # if ( halt_flg ) ! 1012: 1005 00028D65 L321: ! 1013: 1006 00028D65 5d effffff8c5 tstl _halt_flg ! 1014: 1007 00028D6B 31 0d jeql L323 ! 1015: 1008 00028D6D # pipe4_er_hlt( subtest ); ! 1016: 1009 00028D6D dd effffff8bd pushl _subtest ! 1017: 1010 00028D73 fe 08 ef000005ba callf $8,_pipe4_er_hlt ! 1018: 1011 00028D7A # if ( loop_on_err ) { ! 1019: 1012 00028D7A L323: ! 1020: 1013 00028D7A 5d effffff8b0 tstl _loop_on_err ! 1021: 1014 00028D80 31 0a jeql L324 ! 1022: 1015 00028D82 # force_loop = TRUE; /* set the force loop flag */ ! 1023: 1016 00028D82 0d 01 effffff8a7 movl $1,_force_loop ! 1024: 1017 00028D89 # asm("brw _pipe4_7_lp1"); /* and loop */ ! 1025: 1018 00028D89 13 ff6c brw _pipe4_7_lp1 ! 1026: 1019 00028D8C # } ! 1027: 1020 00028D8C # } /* end of compare error */ ! 1028: 1021 00028D8C L324: ! 1029: 1022 00028D8C # } while( index++ < max_ldf_1_index ); ! 1030: 1023 00028D8C L320: ! 1031: 1024 00028D8C L317: ! 1032: 1025 00028D8C 0d effffff89e 50 movl _index,r0 ! 1033: 1026 00028D93 6d effffff897 incl _index ! 1034: 1027 00028D99 1d 50 effffff890 cmpl r0,_max_ldf_1_index ! 1035: 1028 00028DA0 81 03 13 ff1c jlss L318 ! 1036: 1029 00028DA5 L316: ! 1037: 1030 00028DA5 # } /* end of subtest 7 */ ! 1038: 1031 00028DA5 40 ret#2 ! 1039: 1032 00028DA6 .set L312,0x0 ! 1040: 1033 00028DA6 L314: ! 1041: 1034 00028DA6 13 ff0c jbr L315 ! 1042: 1035 00028DA9 .data ! 1043: 1036 00000d78 * .text ! 1044: 1037 00028DA9 00 .align 1 ! 1045: 1038 00028DAA .globl _pipe4_8 ! 1046: 1039 00028DAA _pipe4_8: ! 1047: 1040 00028DAA 0000 .word L325 ! 1048: 1041 00028DAC # ! 1049: 1042 00028DAC # ! 1050: 1043 00028DAC # ! 1051: 1044 00028DAC # ! 1052: 1045 00028DAC # ! 1053: 1046 00028DAC # ! 1054: 1047 00028DAC # /************************************************************************ ! 1055: 1048 00028DAC # * ! 1056: 1049 00028DAC # * SUBTEST 8 ! 1057: 1050 00028DAC # * data in Cache, 3 NO-OPs ! 1058: 1051 00028DAC # * ! 1059: 1052 00028DAC # ************************************************************************/ ! 1060: 1053 00028DAC # pipe4_8() ! 1061: 1054 00028DAC # { ! 1062: 1055 00028DAC 13 00f6 jbr L327 ! 1063: 1056 00028DAF L328: ! 1064: 1057 00028DAF # force_loop = FALSE; /* clear force_loop flag */ ! 1065: 1058 00028DAF 4d effffff87b clrl _force_loop ! 1066: 1059 00028DB5 # index = 0; ! 1067: 1060 00028DB5 4d effffff875 clrl _index ! 1068: 1061 00028DBB # do ! 1069: 1062 00028DBB L331: ! 1070: 1063 00028DBB # { ! 1071: 1064 00028DBB # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */ ! 1072: 1065 00028DBB 0d effffff86f 50 movl _index,r0 ! 1073: 1066 00028DC2 48 03 50 50 shll $3,r0,r0 ! 1074: 1067 00028DC6 0d e000000000 effffff85f movl _ldf_1_data(r0),_sgl_value_1 ! 1075: 1068 00028DD1 # sgl_expected = ldf_1_data[index].exp; /* get expected results */ ! 1076: 1069 00028DD1 0d effffff859 50 movl _index,r0 ! 1077: 1070 00028DD8 48 03 50 50 shll $3,r0,r0 ! 1078: 1071 00028DDC 0d e000000004 effffff849 movl _ldf_1_data+4(r0),_sgl_expected ! 1079: 1072 00028DE7 # sgl_value_2 = 0x40800000; /* floating '1' */ ! 1080: 1073 00028DE7 0d 8f40800000 effffff83e movl $1082130432,_sgl_value_2 ! 1081: 1074 00028DF2 # /* ! 1082: 1075 00028DF2 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 1083: 1076 00028DF2 # * The force loop flag is set after the first error. ! 1084: 1077 00028DF2 # */ ! 1085: 1078 00028DF2 # asm("_pipe4_8_lp1:"); ! 1086: 1079 00028DF2 _pipe4_8_lp1: ! 1087: 1080 00028DF2 # asm("ldf _sgl_value_1"); /* load the operand */ ! 1088: 1081 00028DF2 06 effffff838 ldf _sgl_value_1 ! 1089: 1082 00028DF8 # asm("nop"); ! 1090: 1083 00028DF8 10 nop ! 1091: 1084 00028DF9 # asm("nop"); ! 1092: 1085 00028DF9 10 nop ! 1093: 1086 00028DFA # asm("nop"); ! 1094: 1087 00028DFA 10 nop ! 1095: 1088 00028DFB # asm("stf _sgl_st_acc"); /* store the result */ ! 1096: 1089 00028DFB 26 effffff82f stf _sgl_st_acc ! 1097: 1090 00028E01 # asm("nop"); ! 1098: 1091 00028E01 10 nop ! 1099: 1092 00028E02 # asm("nop"); ! 1100: 1093 00028E02 10 nop ! 1101: 1094 00028E03 # asm("nop"); ! 1102: 1095 00028E03 10 nop ! 1103: 1096 00028E04 # asm("ldf _sgl_value_2"); /* load a floating '1' */ ! 1104: 1097 00028E04 06 effffff826 ldf _sgl_value_2 ! 1105: 1098 00028E0A # asm("nop"); ! 1106: 1099 00028E0A 10 nop ! 1107: 1100 00028E0B # asm("nop"); ! 1108: 1101 00028E0B 10 nop ! 1109: 1102 00028E0C # asm("nop"); ! 1110: 1103 00028E0C 10 nop ! 1111: 1104 00028E0D # asm("mulf _sgl_value_2"); /* multipy by a '1' */ ! 1112: 1105 00028E0D e6 effffff81d mulf _sgl_value_2 ! 1113: 1106 00028E13 # asm("nop"); ! 1114: 1107 00028E13 10 nop ! 1115: 1108 00028E14 # asm("nop"); ! 1116: 1109 00028E14 10 nop ! 1117: 1110 00028E15 # asm("nop"); ! 1118: 1111 00028E15 10 nop ! 1119: 1112 00028E16 # asm("mulf _sgl_value_1"); /* multipy by the operand */ ! 1120: 1113 00028E16 e6 effffff814 mulf _sgl_value_1 ! 1121: 1114 00028E1C # asm("nop"); ! 1122: 1115 00028E1C 10 nop ! 1123: 1116 00028E1D # asm("nop"); ! 1124: 1117 00028E1D 10 nop ! 1125: 1118 00028E1E # asm("nop"); ! 1126: 1119 00028E1E 10 nop ! 1127: 1120 00028E1F # asm("stf _sgl_value_6"); /* store the result */ ! 1128: 1121 00028E1F 26 effffff80b stf _sgl_value_6 ! 1129: 1122 00028E25 # if( force_loop ); ! 1130: 1123 00028E25 5d effffff805 tstl _force_loop ! 1131: 1124 00028E2B 31 00 jeql L332 ! 1132: 1125 00028E2D # asm("brb _pipe4_8_lp1");; /* loop on the error */ ! 1133: 1126 00028E2D L332: ! 1134: 1127 00028E2D 11 c3 brb _pipe4_8_lp1 ! 1135: 1128 00028E2F # /* ! 1136: 1129 00028E2F # * verify the results ! 1137: 1130 00028E2F # */ ! 1138: 1131 00028E2F # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */ ! 1139: 1132 00028E2F # (sgl_value_6 != sgl_expected) ) ! 1140: 1133 00028E2F 1d effffff7fb effffff7f6 cmpl _sgl_st_acc,_sgl_expected ! 1141: 1134 00028E3A 21 0d jneq L9992 ! 1142: 1135 00028E3C 1d effffff7ee effffff7e9 cmpl _sgl_value_6,_sgl_expected ! 1143: 1136 00028E47 31 42 jeql L333 ! 1144: 1137 00028E49 L9992: ! 1145: 1138 00028E49 # { ! 1146: 1139 00028E49 # errcnt++; /* bump the error count */ ! 1147: 1140 00028E49 6d effffff7e1 incl _errcnt ! 1148: 1141 00028E4F # if ( prt_error ) ! 1149: 1142 00028E4F 5d effffff7db tstl _prt_error ! 1150: 1143 00028E55 31 0d jeql L334 ! 1151: 1144 00028E57 # print_pipe4_er("Cache Data, 3 NO-OPs"); ! 1152: 1145 00028E57 .data 1 ! 1153: 1146 00000e10 * L335: ! 1154: 1147 00000e10 * 436163686520446174612C203 .ascii "Cache Data, 3 NO-OPs\0" ! 1155: 3204E4F2D4F507300 ! 1156: 1148 00000e25 * .text ! 1157: 1149 00028E57 dd 8f00000e10 pushl $L335 ! 1158: 1150 00028E5D fe 08 ef000003aa callf $8,_print_pipe4_er ! 1159: 1151 00028E64 # if ( halt_flg ) ! 1160: 1152 00028E64 L334: ! 1161: 1153 00028E64 5d effffff7c6 tstl _halt_flg ! 1162: 1154 00028E6A 31 0d jeql L336 ! 1163: 1155 00028E6C # pipe4_er_hlt( subtest ); ! 1164: 1156 00028E6C dd effffff7be pushl _subtest ! 1165: 1157 00028E72 fe 08 ef000004bb callf $8,_pipe4_er_hlt ! 1166: 1158 00028E79 # if ( loop_on_err ) { ! 1167: 1159 00028E79 L336: ! 1168: 1160 00028E79 5d effffff7b1 tstl _loop_on_err ! 1169: 1161 00028E7F 31 0a jeql L337 ! 1170: 1162 00028E81 # force_loop = TRUE; /* set the force loop flag */ ! 1171: 1163 00028E81 0d 01 effffff7a8 movl $1,_force_loop ! 1172: 1164 00028E88 # asm("brw _pipe4_8_lp1"); /* and loop */ ! 1173: 1165 00028E88 13 ff67 brw _pipe4_8_lp1 ! 1174: 1166 00028E8B # } ! 1175: 1167 00028E8B # } /* end of compare error */ ! 1176: 1168 00028E8B L337: ! 1177: 1169 00028E8B # } while( index++ < max_ldf_1_index ); ! 1178: 1170 00028E8B L333: ! 1179: 1171 00028E8B L330: ! 1180: 1172 00028E8B 0d effffff79f 50 movl _index,r0 ! 1181: 1173 00028E92 6d effffff798 incl _index ! 1182: 1174 00028E98 1d 50 effffff791 cmpl r0,_max_ldf_1_index ! 1183: 1175 00028E9F 81 03 13 ff17 jlss L331 ! 1184: 1176 00028EA4 L329: ! 1185: 1177 00028EA4 # } /* end of subtest 8 */ ! 1186: 1178 00028EA4 40 ret#2 ! 1187: 1179 00028EA5 .set L325,0x0 ! 1188: 1180 00028EA5 L327: ! 1189: 1181 00028EA5 13 ff07 jbr L328 ! 1190: 1182 00028EA8 .data ! 1191: 1183 00000d78 * .text ! 1192: 1184 00028EA8 .align 1 ! 1193: 1185 00028EA8 .globl _pipe4_9 ! 1194: 1186 00028EA8 _pipe4_9: ! 1195: 1187 00028EA8 0000 .word L338 ! 1196: 1188 00028EAA # ! 1197: 1189 00028EAA # ! 1198: 1190 00028EAA # ! 1199: 1191 00028EAA # ! 1200: 1192 00028EAA # ! 1201: 1193 00028EAA # ! 1202: 1194 00028EAA # /***************************************************************************** ! 1203: 1195 00028EAA # * ! 1204: 1196 00028EAA # * SUBTEST 9 ! 1205: 1197 00028EAA # * data on the stack, no NO-OPs ! 1206: 1198 00028EAA # * ! 1207: 1199 00028EAA # *****************************************************************************/ ! 1208: 1200 00028EAA # pipe4_9() ! 1209: 1201 00028EAA # { ! 1210: 1202 00028EAA 13 018d jbr L340 ! 1211: 1203 00028EAD L341: ! 1212: 1204 00028EAD # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */ ! 1213: 1205 00028EAD ed 6d effffff77c moval (r13),_pre_event_fp ! 1214: 1206 00028EB4 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */ ! 1215: 1207 00028EB4 ed 6e effffff775 moval (r14),_pre_event_sp ! 1216: 1208 00028EBB # force_loop = FALSE; /* clear force_loop flag */ ! 1217: 1209 00028EBB 4d effffff76f clrl _force_loop ! 1218: 1210 00028EC1 # index = 0; ! 1219: 1211 00028EC1 4d effffff769 clrl _index ! 1220: 1212 00028EC7 # do ! 1221: 1213 00028EC7 L344: ! 1222: 1214 00028EC7 # { ! 1223: 1215 00028EC7 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */ ! 1224: 1216 00028EC7 0d effffff763 50 movl _index,r0 ! 1225: 1217 00028ECE 48 03 50 50 shll $3,r0,r0 ! 1226: 1218 00028ED2 0d e000000000 effffff753 movl _ldf_1_data(r0),_sgl_value_1 ! 1227: 1219 00028EDD # sgl_expected = ldf_1_data[index].exp; /* get expected results */ ! 1228: 1220 00028EDD 0d effffff74d 50 movl _index,r0 ! 1229: 1221 00028EE4 48 03 50 50 shll $3,r0,r0 ! 1230: 1222 00028EE8 0d e000000004 effffff73d movl _ldf_1_data+4(r0),_sgl_expected ! 1231: 1223 00028EF3 # sgl_value_2 = 0x40800000; /* floating '1' */ ! 1232: 1224 00028EF3 0d 8f40800000 effffff732 movl $1082130432,_sgl_value_2 ! 1233: 1225 00028EFE # asm("moval _pointer_data,_sgl_value_4");/* init / final SP value */ ! 1234: 1226 00028EFE ed effffff72c effffff727 moval _pointer_data,_sgl_value_4 ! 1235: 1227 00028F09 # /* ! 1236: 1228 00028F09 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 1237: 1229 00028F09 # * The force loop flag is set after the first error. ! 1238: 1230 00028F09 # */ ! 1239: 1231 00028F09 # asm("_pipe4_9_lp1:"); ! 1240: 1232 00028F09 _pipe4_9_lp1: ! 1241: 1233 00028F09 # asm("moval _pointer_data,r14"); /* set the stack pointer */ ! 1242: 1234 00028F09 ed effffff721 5e moval _pointer_data,r14 ! 1243: 1235 00028F10 # asm("movl _sgl_value_1,-(r14)"); /* push the operand */ ! 1244: 1236 00028F10 0d effffff71a 7e movl _sgl_value_1,-(r14) ! 1245: 1237 00028F17 # asm("movl _sgl_value_2,-(r14)"); /* push a floating '1' */ ! 1246: 1238 00028F17 0d effffff713 7e movl _sgl_value_2,-(r14) ! 1247: 1239 00028F1E # asm("movl _sgl_value_2,-(r14)"); /* push a '1' again */ ! 1248: 1240 00028F1E 0d effffff70c 7e movl _sgl_value_2,-(r14) ! 1249: 1241 00028F25 # asm("movl _sgl_value_1,-(r14)"); /* push the operand again */ ! 1250: 1242 00028F25 0d effffff705 7e movl _sgl_value_1,-(r14) ! 1251: 1243 00028F2C # /* ! 1252: 1244 00028F2C # * now pop the data off the stack ! 1253: 1245 00028F2C # */ ! 1254: 1246 00028F2C # ! 1255: 1247 00028F2C # asm("ldf (r14)+"); /* load the operand */ ! 1256: 1248 00028F2C 06 8e ldf (r14)+ ! 1257: 1249 00028F2E # asm("stf r5"); /* store the result */ ! 1258: 1250 00028F2E 26 55 stf r5 ! 1259: 1251 00028F30 # asm("ldf (r14)+"); /* load a floating '1' */ ! 1260: 1252 00028F30 06 8e ldf (r14)+ ! 1261: 1253 00028F32 # asm("mulf (r14)+"); /* multipy by a '1' */ ! 1262: 1254 00028F32 e6 8e mulf (r14)+ ! 1263: 1255 00028F34 # asm("mulf (r14)+"); /* multipy by the operand */ ! 1264: 1256 00028F34 e6 8e mulf (r14)+ ! 1265: 1257 00028F36 # asm("stf r6"); /* store the result */ ! 1266: 1258 00028F36 26 56 stf r6 ! 1267: 1259 00028F38 # if( force_loop ); ! 1268: 1260 00028F38 5d effffff6f2 tstl _force_loop ! 1269: 1261 00028F3E 31 00 jeql L345 ! 1270: 1262 00028F40 # asm("brb _pipe4_9_lp1");; /* loop on the error */ ! 1271: 1263 00028F40 L345: ! 1272: 1264 00028F40 11 c7 brb _pipe4_9_lp1 ! 1273: 1265 00028F42 # /* ! 1274: 1266 00028F42 # * verify the results ! 1275: 1267 00028F42 # */ ! 1276: 1268 00028F42 # asm("movl r5,_sgl_st_acc"); /* get the 1st store value */ ! 1277: 1269 00028F42 0d 55 effffff6e7 movl r5,_sgl_st_acc ! 1278: 1270 00028F49 # asm("movl r6,_sgl_value_6"); /* get the 2nd store value */ ! 1279: 1271 00028F49 0d 56 effffff6e0 movl r6,_sgl_value_6 ! 1280: 1272 00028F50 # asm("moval (r14),_sgl_value_5"); /* save the stack pointer */ ! 1281: 1273 00028F50 ed 6e effffff6d9 moval (r14),_sgl_value_5 ! 1282: 1274 00028F57 # if( (sgl_st_acc != sgl_expected) || /* verify the results... */ ! 1283: 1275 00028F57 # (sgl_value_6 != sgl_expected) || ! 1284: 1276 00028F57 # (sgl_value_5 != sgl_value_4) ) /* ... and the final SP */ ! 1285: 1277 00028F57 1d effffff6d3 effffff6ce cmpl _sgl_st_acc,_sgl_expected ! 1286: 1278 00028F62 21 1d jneq L9991 ! 1287: 1279 00028F64 1d effffff6c6 effffff6c1 cmpl _sgl_value_6,_sgl_expected ! 1288: 1280 00028F6F 21 10 jneq L9991 ! 1289: 1281 00028F71 1d effffff6b9 effffff6b4 cmpl _sgl_value_5,_sgl_value_4 ! 1290: 1282 00028F7C 21 03 13 0091 jeql L346 ! 1291: 1283 00028F81 L9991: ! 1292: 1284 00028F81 # { ! 1293: 1285 00028F81 # asm("movl _pre_event_fp,r13"); /* restore frame pointer */ ! 1294: 1286 00028F81 0d effffff6a9 5d movl _pre_event_fp,r13 ! 1295: 1287 00028F88 # asm("movl _pre_event_sp,r14"); /* restore stack pointer */ ! 1296: 1288 00028F88 0d effffff6a2 5e movl _pre_event_sp,r14 ! 1297: 1289 00028F8F # errcnt++; /* bump the error count */ ! 1298: 1290 00028F8F 6d effffff69b incl _errcnt ! 1299: 1291 00028F95 # if ( prt_error ) { ! 1300: 1292 00028F95 5d effffff695 tstl _prt_error ! 1301: 1293 00028F9B 31 4e jeql L347 ! 1302: 1294 00028F9D # print_pipe4_er("POP data from the STACK"); ! 1303: 1295 00028F9D .data 1 ! 1304: 1296 00000e25 * L348: ! 1305: 1297 00000e25 * 504F5020646174612066726F6 .ascii "POP data from the STACK\0" ! 1306: D2074686520535441434B00 ! 1307: 1298 00000e3d * .text ! 1308: 1299 00028F9D dd 8f00000e25 pushl $L348 ! 1309: 1300 00028FA3 fe 08 ef00000264 callf $8,_print_pipe4_er ! 1310: 1301 00028FAA # writes("final Stack Pointer = "); ! 1311: 1302 00028FAA .data 1 ! 1312: 1303 00000e3d * L349: ! 1313: 1304 00000e3d * 66696E616C20537461636B205 .ascii "final Stack Pointer = \0" ! 1314: 06F696E746572203D2000 ! 1315: 1305 00000e54 * .text ! 1316: 1306 00028FAA dd 8f00000e3d pushl $L349 ! 1317: 1307 00028FB0 fe 08 effffff679 callf $8,_writes ! 1318: 1308 00028FB7 # write32h( sgl_value_5 ); ! 1319: 1309 00028FB7 dd effffff673 pushl _sgl_value_5 ! 1320: 1310 00028FBD fe 08 effffff66c callf $8,_write32h ! 1321: 1311 00028FC4 # writes(", expected SP = "); ! 1322: 1312 00028FC4 .data 1 ! 1323: 1313 00000e54 * L351: ! 1324: 1314 00000e54 * 2C20206578706563746564205 .ascii ", expected SP = \0" ! 1325: 350203D2000 ! 1326: 1315 00000e66 * .text ! 1327: 1316 00028FC4 dd 8f00000e54 pushl $L351 ! 1328: 1317 00028FCA fe 08 effffff65f callf $8,_writes ! 1329: 1318 00028FD1 # write32h( sgl_value_4 ); ! 1330: 1319 00028FD1 dd effffff659 pushl _sgl_value_4 ! 1331: 1320 00028FD7 fe 08 effffff652 callf $8,_write32h ! 1332: 1321 00028FDE # writes("\n"); ! 1333: 1322 00028FDE .data 1 ! 1334: 1323 00000e66 * L352: ! 1335: 1324 00000e66 * 0A00 .ascii "\12\0" ! 1336: 1325 00000e68 * .text ! 1337: 1326 00028FDE dd 8f00000e66 pushl $L352 ! 1338: 1327 00028FE4 fe 08 effffff645 callf $8,_writes ! 1339: 1328 00028FEB # } ! 1340: 1329 00028FEB # if ( halt_flg ) ! 1341: 1330 00028FEB L347: ! 1342: 1331 00028FEB 5d effffff63f tstl _halt_flg ! 1343: 1332 00028FF1 31 0d jeql L353 ! 1344: 1333 00028FF3 # pipe4_er_hlt( subtest ); ! 1345: 1334 00028FF3 dd effffff637 pushl _subtest ! 1346: 1335 00028FF9 fe 08 ef00000334 callf $8,_pipe4_er_hlt ! 1347: 1336 00029000 # if ( loop_on_err ) { ! 1348: 1337 00029000 L353: ! 1349: 1338 00029000 5d effffff62a tstl _loop_on_err ! 1350: 1339 00029006 31 0a jeql L354 ! 1351: 1340 00029008 # force_loop = TRUE; /* set the force loop flag */ ! 1352: 1341 00029008 0d 01 effffff621 movl $1,_force_loop ! 1353: 1342 0002900F # asm("brw _pipe4_9_lp1"); /* and loop */ ! 1354: 1343 0002900F 13 fef7 brw _pipe4_9_lp1 ! 1355: 1344 00029012 # } ! 1356: 1345 00029012 # } /* end of compare error */ ! 1357: 1346 00029012 L354: ! 1358: 1347 00029012 # } while( index++ < max_ldf_1_index ); ! 1359: 1348 00029012 L346: ! 1360: 1349 00029012 L343: ! 1361: 1350 00029012 0d effffff618 50 movl _index,r0 ! 1362: 1351 00029019 6d effffff611 incl _index ! 1363: 1352 0002901F 1d 50 effffff60a cmpl r0,_max_ldf_1_index ! 1364: 1353 00029026 81 03 13 fe9c jlss L344 ! 1365: 1354 0002902B L342: ! 1366: 1355 0002902B # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */ ! 1367: 1356 0002902B 0d effffff5ff 5d movl _pre_event_fp,r13 ! 1368: 1357 00029032 # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */ ! 1369: 1358 00029032 0d effffff5f8 5e movl _pre_event_sp,r14 ! 1370: 1359 00029039 # } /* end of subtest 9 */ ! 1371: 1360 00029039 40 ret#2 ! 1372: 1361 0002903A .set L338,0x0 ! 1373: 1362 0002903A L340: ! 1374: 1363 0002903A 13 fe70 jbr L341 ! 1375: 1364 0002903D .data ! 1376: 1365 00000d78 * .text ! 1377: 1366 0002903D 00 .align 1 ! 1378: 1367 0002903E .globl _pipe4_10 ! 1379: 1368 0002903E _pipe4_10: ! 1380: 1369 0002903E 0000 .word L355 ! 1381: 1370 00029040 # ! 1382: 1371 00029040 # ! 1383: 1372 00029040 # ! 1384: 1373 00029040 # ! 1385: 1374 00029040 # ! 1386: 1375 00029040 # ! 1387: 1376 00029040 # /****************************************************************************** ! 1388: 1377 00029040 # * ! 1389: 1378 00029040 # * SUBTEST 10 ! 1390: 1379 00029040 # * get data via indexed FRAME pointer ! 1391: 1380 00029040 # * ! 1392: 1381 00029040 # * ADDR INDEX DATA ! 1393: 1382 00029040 # * pointer_data 4 <the 1st STF result goes here> ! 1394: 1383 00029040 # * pointer_data-4 3 <the 2nd STF result goes here> ! 1395: 1384 00029040 # * pointer_data-8 2 <operand data> ! 1396: 1385 00029040 # * pointer_data-12 1 <floating '1'> ! 1397: 1386 00029040 # * pointer_data-16 0 point the frame pointer here ! 1398: 1387 00029040 # * ! 1399: 1388 00029040 # ******************************************************************************/ ! 1400: 1389 00029040 # pipe4_10() ! 1401: 1390 00029040 # { ! 1402: 1391 00029040 13 01c8 jbr L357 ! 1403: 1392 00029043 L358: ! 1404: 1393 00029043 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */ ! 1405: 1394 00029043 ed 6d effffff5e6 moval (r13),_pre_event_fp ! 1406: 1395 0002904A # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */ ! 1407: 1396 0002904A ed 6e effffff5df moval (r14),_pre_event_sp ! 1408: 1397 00029051 # force_loop = FALSE; /* clear force_loop flag */ ! 1409: 1398 00029051 4d effffff5d9 clrl _force_loop ! 1410: 1399 00029057 # index = 0; ! 1411: 1400 00029057 4d effffff5d3 clrl _index ! 1412: 1401 0002905D # do ! 1413: 1402 0002905D L361: ! 1414: 1403 0002905D # { ! 1415: 1404 0002905D # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */ ! 1416: 1405 0002905D 0d effffff5cd 50 movl _index,r0 ! 1417: 1406 00029064 48 03 50 50 shll $3,r0,r0 ! 1418: 1407 00029068 0d e000000000 effffff5bd movl _ldf_1_data(r0),_sgl_value_1 ! 1419: 1408 00029073 # sgl_expected = ldf_1_data[index].exp; /* get expected results */ ! 1420: 1409 00029073 0d effffff5b7 50 movl _index,r0 ! 1421: 1410 0002907A 48 03 50 50 shll $3,r0,r0 ! 1422: 1411 0002907E 0d e000000004 effffff5a7 movl _ldf_1_data+4(r0),_sgl_expected ! 1423: 1412 00029089 # sgl_value_2 = 0x40800000; /* floating '1' */ ! 1424: 1413 00029089 0d 8f40800000 effffff59c movl $1082130432,_sgl_value_2 ! 1425: 1414 00029094 # asm("moval _pointer_data,_sgl_value_4");/* get store data's addr */ ! 1426: 1415 00029094 ed effffff596 effffff591 moval _pointer_data,_sgl_value_4 ! 1427: 1416 0002909F # sgl_value_4 -= 8; /* decrement it by 8 (bytes)*/ ! 1428: 1417 0002909F 2c 08 effffff58a subl2 $8,_sgl_value_4 ! 1429: 1418 000290A6 # asm("movl _sgl_value_1,*_sgl_value_4"); /* set the operand data */ ! 1430: 1419 000290A6 0d effffff584 fffffff57f movl _sgl_value_1,*_sgl_value_4 ! 1431: 1420 000290B1 # sgl_value_4 -= 4; /* decrement it by 4 (bytes)*/ ! 1432: 1421 000290B1 2c 04 effffff578 subl2 $4,_sgl_value_4 ! 1433: 1422 000290B8 # asm("movl _sgl_value_2,*_sgl_value_4"); /* set the floating '1' */ ! 1434: 1423 000290B8 0d effffff572 fffffff56d movl _sgl_value_2,*_sgl_value_4 ! 1435: 1424 000290C3 # sgl_value_4 -= 4; /* get FRAME PTR address */ ! 1436: 1425 000290C3 2c 04 effffff566 subl2 $4,_sgl_value_4 ! 1437: 1426 000290CA # /* ! 1438: 1427 000290CA # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 1439: 1428 000290CA # * The force loop flag is set after the first error. ! 1440: 1429 000290CA # */ ! 1441: 1430 000290CA # asm("_pipe4_10_lp1:"); ! 1442: 1431 000290CA _pipe4_10_lp1: ! 1443: 1432 000290CA # asm("movl _sgl_value_4,r13"); /* set the FRAME POINTER */ ! 1444: 1433 000290CA 0d effffff560 5d movl _sgl_value_4,r13 ! 1445: 1434 000290D1 # asm("movl $1,r1"); /* r1 index = 1 longwords */ ! 1446: 1435 000290D1 0d 01 51 movl $1,r1 ! 1447: 1436 000290D4 # asm("movl $2,r2"); /* r2 index = 2 longwords */ ! 1448: 1437 000290D4 0d 02 52 movl $2,r2 ! 1449: 1438 000290D7 # asm("movl $3,r3"); /* r3 index = 3 longwords */ ! 1450: 1439 000290D7 0d 03 53 movl $3,r3 ! 1451: 1440 000290DA # asm("movl $4,r4"); /* r4 index = 4 longwords */ ! 1452: 1441 000290DA 0d 04 54 movl $4,r4 ! 1453: 1442 000290DD # asm("ldf (r13)[r2]"); /* load the op (indx = 2) */ ! 1454: 1443 000290DD 06 426d ldf (r13)[r2] ! 1455: 1444 000290E0 # asm("stf (r13)[r4]"); /* store -index = 4 */ ! 1456: 1445 000290E0 26 446d stf (r13)[r4] ! 1457: 1446 000290E3 # asm("ldf (r13)[r1]"); /* load '1' (indx = 1) */ ! 1458: 1447 000290E3 06 416d ldf (r13)[r1] ! 1459: 1448 000290E6 # asm("mulf (r13)[r1]"); /* multiply by a '1' */ ! 1460: 1449 000290E6 e6 416d mulf (r13)[r1] ! 1461: 1450 000290E9 # asm("mulf (r13)[r2]"); /* multiply by the operand */ ! 1462: 1451 000290E9 e6 426d mulf (r13)[r2] ! 1463: 1452 000290EC # asm("stf (r13)[r3]"); /* store -index = 3 */ ! 1464: 1453 000290EC 26 436d stf (r13)[r3] ! 1465: 1454 000290EF # if( force_loop ); ! 1466: 1455 000290EF 5d effffff53b tstl _force_loop ! 1467: 1456 000290F5 31 00 jeql L362 ! 1468: 1457 000290F7 # asm("brb _pipe4_10_lp1");; /* loop on the error */ ! 1469: 1458 000290F7 L362: ! 1470: 1459 000290F7 11 d1 brb _pipe4_10_lp1 ! 1471: 1460 000290F9 # /* ! 1472: 1461 000290F9 # * verify the results ! 1473: 1462 000290F9 # */ ! 1474: 1463 000290F9 # sgl_st_acc = pointer_data; /* save 1st stored value */ ! 1475: 1464 000290F9 0d effffff531 effffff52c movl _pointer_data,_sgl_st_acc ! 1476: 1465 00029104 # asm("moval _pointer_data,_sgl_value_5"); /* get addr of 1st stf */ ! 1477: 1466 00029104 ed effffff526 effffff521 moval _pointer_data,_sgl_value_5 ! 1478: 1467 0002910F # sgl_value_5 -= 4; /* decrement by 4 (bytes) */ ! 1479: 1468 0002910F 2c 04 effffff51a subl2 $4,_sgl_value_5 ! 1480: 1469 00029116 # asm("movl *_sgl_value_5,_sgl_value_6"); /* save 2nd store value */ ! 1481: 1470 00029116 0d fffffff514 effffff50f movl *_sgl_value_5,_sgl_value_6 ! 1482: 1471 00029121 # asm("moval (r13),_sgl_value_5"); /* save the frame pointer */ ! 1483: 1472 00029121 ed 6d effffff508 moval (r13),_sgl_value_5 ! 1484: 1473 00029128 # if( (sgl_st_acc != sgl_expected) || /* verify the results... */ ! 1485: 1474 00029128 # (sgl_value_6 != sgl_expected) || ! 1486: 1475 00029128 # (sgl_value_5 != sgl_value_4) ) /* ... and the final FP */ ! 1487: 1476 00029128 1d effffff502 effffff4fd cmpl _sgl_st_acc,_sgl_expected ! 1488: 1477 00029133 21 1d jneq L9990 ! 1489: 1478 00029135 1d effffff4f5 effffff4f0 cmpl _sgl_value_6,_sgl_expected ! 1490: 1479 00029140 21 10 jneq L9990 ! 1491: 1480 00029142 1d effffff4e8 effffff4e3 cmpl _sgl_value_5,_sgl_value_4 ! 1492: 1481 0002914D 21 03 13 0091 jeql L363 ! 1493: 1482 00029152 L9990: ! 1494: 1483 00029152 # { ! 1495: 1484 00029152 # asm("movl _pre_event_fp,r13"); /* restore frame pointer */ ! 1496: 1485 00029152 0d effffff4d8 5d movl _pre_event_fp,r13 ! 1497: 1486 00029159 # asm("movl _pre_event_sp,r14"); /* restore stack pointer */ ! 1498: 1487 00029159 0d effffff4d1 5e movl _pre_event_sp,r14 ! 1499: 1488 00029160 # errcnt++; /* bump the error count */ ! 1500: 1489 00029160 6d effffff4ca incl _errcnt ! 1501: 1490 00029166 # if ( prt_error ) { ! 1502: 1491 00029166 5d effffff4c4 tstl _prt_error ! 1503: 1492 0002916C 31 4e jeql L364 ! 1504: 1493 0002916E # print_pipe4_er("indexed FP addressing"); ! 1505: 1494 0002916E .data 1 ! 1506: 1495 00000e68 * L365: ! 1507: 1496 00000e68 * 696E646578656420465020616 .ascii "indexed FP addressing\0" ! 1508: 46472657373696E6700 ! 1509: 1497 00000e7e * .text ! 1510: 1498 0002916E dd 8f00000e68 pushl $L365 ! 1511: 1499 00029174 fe 08 ef00000093 callf $8,_print_pipe4_er ! 1512: 1500 0002917B # writes("final Frame Pointer = "); ! 1513: 1501 0002917B .data 1 ! 1514: 1502 00000e7e * L366: ! 1515: 1503 00000e7e * 66696E616C204672616D65205 .ascii "final Frame Pointer = \0" ! 1516: 06F696E746572203D2000 ! 1517: 1504 00000e95 * .text ! 1518: 1505 0002917B dd 8f00000e7e pushl $L366 ! 1519: 1506 00029181 fe 08 effffff4a8 callf $8,_writes ! 1520: 1507 00029188 # writeh( sgl_value_5 ); ! 1521: 1508 00029188 dd effffff4a2 pushl _sgl_value_5 ! 1522: 1509 0002918E fe 08 effffff49b callf $8,_writeh ! 1523: 1510 00029195 # writes(", expected FP = "); ! 1524: 1511 00029195 .data 1 ! 1525: 1512 00000e95 * L368: ! 1526: 1513 00000e95 * 2C20206578706563746564204 .ascii ", expected FP = \0" ! 1527: 650203D2000 ! 1528: 1514 00000ea7 * .text ! 1529: 1515 00029195 dd 8f00000e95 pushl $L368 ! 1530: 1516 0002919B fe 08 effffff48e callf $8,_writes ! 1531: 1517 000291A2 # writeh( sgl_value_4 ); ! 1532: 1518 000291A2 dd effffff488 pushl _sgl_value_4 ! 1533: 1519 000291A8 fe 08 effffff481 callf $8,_writeh ! 1534: 1520 000291AF # writes("\n"); ! 1535: 1521 000291AF .data 1 ! 1536: 1522 00000ea7 * L369: ! 1537: 1523 00000ea7 * 0A00 .ascii "\12\0" ! 1538: 1524 00000ea9 * .text ! 1539: 1525 000291AF dd 8f00000ea7 pushl $L369 ! 1540: 1526 000291B5 fe 08 effffff474 callf $8,_writes ! 1541: 1527 000291BC # } ! 1542: 1528 000291BC # if ( halt_flg ) ! 1543: 1529 000291BC L364: ! 1544: 1530 000291BC 5d effffff46e tstl _halt_flg ! 1545: 1531 000291C2 31 0d jeql L370 ! 1546: 1532 000291C4 # pipe4_er_hlt( subtest ); ! 1547: 1533 000291C4 dd effffff466 pushl _subtest ! 1548: 1534 000291CA fe 08 ef00000163 callf $8,_pipe4_er_hlt ! 1549: 1535 000291D1 # if ( loop_on_err ) { ! 1550: 1536 000291D1 L370: ! 1551: 1537 000291D1 5d effffff459 tstl _loop_on_err ! 1552: 1538 000291D7 31 0a jeql L371 ! 1553: 1539 000291D9 # force_loop = TRUE; /* set the force loop flag */ ! 1554: 1540 000291D9 0d 01 effffff450 movl $1,_force_loop ! 1555: 1541 000291E0 # asm("brw _pipe4_10_lp1"); /* and loop */ ! 1556: 1542 000291E0 13 fee7 brw _pipe4_10_lp1 ! 1557: 1543 000291E3 # } ! 1558: 1544 000291E3 # } /* end of compare error */ ! 1559: 1545 000291E3 L371: ! 1560: 1546 000291E3 # } while( index++ < max_ldf_1_index ); ! 1561: 1547 000291E3 L363: ! 1562: 1548 000291E3 L360: ! 1563: 1549 000291E3 0d effffff447 50 movl _index,r0 ! 1564: 1550 000291EA 6d effffff440 incl _index ! 1565: 1551 000291F0 1d 50 effffff439 cmpl r0,_max_ldf_1_index ! 1566: 1552 000291F7 81 03 13 fe61 jlss L361 ! 1567: 1553 000291FC L359: ! 1568: 1554 000291FC # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */ ! 1569: 1555 000291FC 0d effffff42e 5d movl _pre_event_fp,r13 ! 1570: 1556 00029203 # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */ ! 1571: 1557 00029203 0d effffff427 5e movl _pre_event_sp,r14 ! 1572: 1558 0002920A # } /* end of subtest 10 */ ! 1573: 1559 0002920A 40 ret#2 ! 1574: 1560 0002920B .set L355,0x0 ! 1575: 1561 0002920B L357: ! 1576: 1562 0002920B 13 fe35 jbr L358 ! 1577: 1563 0002920E .data ! 1578: 1564 00000d78 * .text ! 1579: 1565 0002920E .align 1 ! 1580: 1566 0002920E .globl _print_pipe4_er ! 1581: 1567 0002920E _print_pipe4_er: ! 1582: 1568 0002920E 0000 .word L372 ! 1583: 1569 00029210 # ! 1584: 1570 00029210 # ! 1585: 1571 00029210 # /****************************************************************************** ! 1586: 1572 00029210 # * ! 1587: 1573 00029210 # * ! 1588: 1574 00029210 # * print an error in the following form ! 1589: 1575 00029210 # * ! 1590: 1576 00029210 # * operand = xxxxxxxx, 1st store = xxxxxxxx, data index = dd ! 1591: 1577 00029210 # * 2nd store = xxxxxxxx, expected Acc = xxxxxxxx ! 1592: 1578 00029210 # * ! 1593: 1579 00029210 # ******************************************************************************/ ! 1594: 1580 00029210 # print_pipe4_er(msg) ! 1595: 1581 00029210 # char *msg; ! 1596: 1582 00029210 # { ! 1597: 1583 00029210 13 011d jbr L374 ! 1598: 1584 00029213 L375: ! 1599: 1585 00029213 # writes("\n"); /* start a new print line */ ! 1600: 1586 00029213 .data 1 ! 1601: 1587 00000ea9 * L376: ! 1602: 1588 00000ea9 * 0A00 .ascii "\12\0" ! 1603: 1589 00000eab * .text ! 1604: 1590 00029213 dd 8f00000ea9 pushl $L376 ! 1605: 1591 00029219 fe 08 effffff410 callf $8,_writes ! 1606: 1592 00029220 # writes("cycle: "); ! 1607: 1593 00029220 .data 1 ! 1608: 1594 00000eab * L377: ! 1609: 1595 00000eab * 6379636C653A2000 .ascii "cycle: \0" ! 1610: 1596 00000eb3 * .text ! 1611: 1597 00029220 dd 8f00000eab pushl $L377 ! 1612: 1598 00029226 fe 08 effffff403 callf $8,_writes ! 1613: 1599 0002922D # writed( cycle ); ! 1614: 1600 0002922D dd effffff3fd pushl _cycle ! 1615: 1601 00029233 fe 08 effffff3f6 callf $8,_writed ! 1616: 1602 0002923A # writes(" test "); ! 1617: 1603 0002923A .data 1 ! 1618: 1604 00000eb3 * L379: ! 1619: 1605 00000eb3 * 20746573742000 .ascii " test \0" ! 1620: 1606 00000eba * .text ! 1621: 1607 0002923A dd 8f00000eb3 pushl $L379 ! 1622: 1608 00029240 fe 08 effffff3e9 callf $8,_writes ! 1623: 1609 00029247 # writed( test_no ); ! 1624: 1610 00029247 dd effffff3e3 pushl _test_no ! 1625: 1611 0002924D fe 08 effffff3dc callf $8,_writed ! 1626: 1612 00029254 # writes(" (Pipe 4), subtest "); ! 1627: 1613 00029254 .data 1 ! 1628: 1614 00000eba * L380: ! 1629: 1615 00000eba * 202028506970652034292C207 .ascii " (Pipe 4), subtest \0" ! 1630: 37562746573742000 ! 1631: 1616 00000ecf * .text ! 1632: 1617 00029254 dd 8f00000eba pushl $L380 ! 1633: 1618 0002925A fe 08 effffff3cf callf $8,_writes ! 1634: 1619 00029261 # writed( subtest ); ! 1635: 1620 00029261 dd effffff3c9 pushl _subtest ! 1636: 1621 00029267 fe 08 effffff3c2 callf $8,_writed ! 1637: 1622 0002926E # writes(" error - "); ! 1638: 1623 0002926E .data 1 ! 1639: 1624 00000ecf * L381: ! 1640: 1625 00000ecf * 206572726F72202D2000 .ascii " error - \0" ! 1641: 1626 00000ed9 * .text ! 1642: 1627 0002926E dd 8f00000ecf pushl $L381 ! 1643: 1628 00029274 fe 08 effffff3b5 callf $8,_writes ! 1644: 1629 0002927B # writes( msg ); ! 1645: 1630 0002927B dd ad04 pushl 4(fp) ! 1646: 1631 0002927E fe 08 effffff3ab callf $8,_writes ! 1647: 1632 00029285 # writec('\n'); ! 1648: 1633 00029285 dd 0a pushl $10 ! 1649: 1634 00029287 fe 08 effffff3a2 callf $8,_writec ! 1650: 1635 0002928E # writes(" LDF(op), STF, LDF(1.0), MULF(op), STF\n"); ! 1651: 1636 0002928E .data 1 ! 1652: 1637 00000ed9 * L383: ! 1653: 1638 00000ed9 * 204C4446286F70292C2053544 .ascii " LDF(op), STF, LDF(1.0), MULF(op), STF\12\0" ! 1654: 62C204C444628312E30292C20 ! 1655: 4D554C46286F70292C2053544 ! 1656: 60A00 ! 1657: 1639 00000f01 * .text ! 1658: 1640 0002928E dd 8f00000ed9 pushl $L383 ! 1659: 1641 00029294 fe 08 effffff395 callf $8,_writes ! 1660: 1642 0002929B # writes(" operand = "); ! 1661: 1643 0002929B .data 1 ! 1662: 1644 00000f01 * L384: ! 1663: 1645 00000f01 * 20206F706572616E64203D200 .ascii " operand = \0" ! 1664: 0 ! 1665: 1646 00000f0e * .text ! 1666: 1647 0002929B dd 8f00000f01 pushl $L384 ! 1667: 1648 000292A1 fe 08 effffff388 callf $8,_writes ! 1668: 1649 000292A8 # write32h( sgl_value_1 ); ! 1669: 1650 000292A8 dd effffff382 pushl _sgl_value_1 ! 1670: 1651 000292AE fe 08 effffff37b callf $8,_write32h ! 1671: 1652 000292B5 # writes(", 1st store = "); ! 1672: 1653 000292B5 .data 1 ! 1673: 1654 00000f0e * L385: ! 1674: 1655 00000f0e * 2C20202020203173742073746 .ascii ", 1st store = \0" ! 1675: F7265203D2000 ! 1676: 1656 00000f21 * .text ! 1677: 1657 000292B5 dd 8f00000f0e pushl $L385 ! 1678: 1658 000292BB fe 08 effffff36e callf $8,_writes ! 1679: 1659 000292C2 # write32h( sgl_st_acc ); ! 1680: 1660 000292C2 dd effffff368 pushl _sgl_st_acc ! 1681: 1661 000292C8 fe 08 effffff361 callf $8,_write32h ! 1682: 1662 000292CF # writes(", data index = "); ! 1683: 1663 000292CF .data 1 ! 1684: 1664 00000f21 * L386: ! 1685: 1665 00000f21 * 2C2020206461746120696E646 .ascii ", data index = \0" ! 1686: 578203D2000 ! 1687: 1666 00000f33 * .text ! 1688: 1667 000292CF dd 8f00000f21 pushl $L386 ! 1689: 1668 000292D5 fe 08 effffff354 callf $8,_writes ! 1690: 1669 000292DC # writed( index ); ! 1691: 1670 000292DC dd effffff34e pushl _index ! 1692: 1671 000292E2 fe 08 effffff347 callf $8,_writed ! 1693: 1672 000292E9 # writec('\n'); ! 1694: 1673 000292E9 dd 0a pushl $10 ! 1695: 1674 000292EB fe 08 effffff33e callf $8,_writec ! 1696: 1675 000292F2 # writes("2nd store = "); ! 1697: 1676 000292F2 .data 1 ! 1698: 1677 00000f33 * L387: ! 1699: 1678 00000f33 * .ascii "" ! 1700: 1679 00000f33 * 326E642073746F7265203D200 .ascii "2nd store = \0" ! 1701: 0 ! 1702: 1680 00000f40 * .text ! 1703: 1681 000292F2 dd 8f00000f33 pushl $L387 ! 1704: 1682 000292F8 fe 08 effffff331 callf $8,_writes ! 1705: 1683 000292FF # write32h( sgl_value_6 ); ! 1706: 1684 000292FF dd effffff32b pushl _sgl_value_6 ! 1707: 1685 00029305 fe 08 effffff324 callf $8,_write32h ! 1708: 1686 0002930C # writes(", expected Acc = "); ! 1709: 1687 0002930C .data 1 ! 1710: 1688 00000f40 * L388: ! 1711: 1689 00000f40 * 2C20206578706563746564204 .ascii ", expected Acc = \0" ! 1712: 16363203D2000 ! 1713: 1690 00000f53 * .text ! 1714: 1691 0002930C dd 8f00000f40 pushl $L388 ! 1715: 1692 00029312 fe 08 effffff317 callf $8,_writes ! 1716: 1693 00029319 # write32h( sgl_expected ); ! 1717: 1694 00029319 dd effffff311 pushl _sgl_expected ! 1718: 1695 0002931F fe 08 effffff30a callf $8,_write32h ! 1719: 1696 00029326 # writec('\n'); ! 1720: 1697 00029326 dd 0a pushl $10 ! 1721: 1698 00029328 fe 08 effffff301 callf $8,_writec ! 1722: 1699 0002932F # } ! 1723: 1700 0002932F 40 ret#2 ! 1724: 1701 00029330 .set L372,0x0 ! 1725: 1702 00029330 L374: ! 1726: 1703 00029330 13 fee0 jbr L375 ! 1727: 1704 00029333 .data ! 1728: 1705 00000d78 * .text ! 1729: 1706 00029333 00 .align 1 ! 1730: 1707 00029334 .globl _pipe4_er_hlt ! 1731: 1708 00029334 _pipe4_er_hlt: ! 1732: 1709 00029334 0000 .word L389 ! 1733: 1710 00029336 # ! 1734: 1711 00029336 # ! 1735: 1712 00029336 # ! 1736: 1713 00029336 # ! 1737: 1714 00029336 # ! 1738: 1715 00029336 # /****************************************************************************** ! 1739: 1716 00029336 # * ! 1740: 1717 00029336 # * HALT ON ERROR ROUTINE ! 1741: 1718 00029336 # * ! 1742: 1719 00029336 # * halt with the necessary information saved in the registers ! 1743: 1720 00029336 # * ! 1744: 1721 00029336 # ******************************************************************************/ ! 1745: 1722 00029336 # pipe4_er_hlt( subtest ) ! 1746: 1723 00029336 # int subtest; ! 1747: 1724 00029336 # { ! 1748: 1725 00029336 11 6e jbr L391 ! 1749: 1726 00029338 L392: ! 1750: 1727 00029338 # asm("movl _test_no,r0"); /* r0 = test number */ ! 1751: 1728 00029338 0d effffff2f2 50 movl _test_no,r0 ! 1752: 1729 0002933F # asm("movl _subtest,r1"); /* r1 = subtest number */ ! 1753: 1730 0002933F 0d effffff2eb 51 movl _subtest,r1 ! 1754: 1731 00029346 # asm("movl $1,r2"); /* r2 = error code */ ! 1755: 1732 00029346 0d 01 52 movl $1,r2 ! 1756: 1733 00029349 # asm("movl _cycle,r3"); /* r3 = cycle count */ ! 1757: 1734 00029349 0d effffff2e1 53 movl _cycle,r3 ! 1758: 1735 00029350 # asm("movl _sgl_value_1,r4"); /* r4 = sgl operand */ ! 1759: 1736 00029350 0d effffff2da 54 movl _sgl_value_1,r4 ! 1760: 1737 00029357 # asm("movl _sgl_st_acc,r5"); /* r5 = 1st word stored */ ! 1761: 1738 00029357 0d effffff2d3 55 movl _sgl_st_acc,r5 ! 1762: 1739 0002935E # asm("movl _sgl_value_6,r6"); /* r6 = 2nd word stored */ ! 1763: 1740 0002935E 0d effffff2cc 56 movl _sgl_value_6,r6 ! 1764: 1741 00029365 # asm("movl _sgl_expected,r7"); /* r7 = sgl expected */ ! 1765: 1742 00029365 0d effffff2c5 57 movl _sgl_expected,r7 ! 1766: 1743 0002936C # asm("movl _index,r8"); /* r8 = data index */ ! 1767: 1744 0002936C 0d effffff2be 58 movl _index,r8 ! 1768: 1745 00029373 # asm("movl _sgl_value_2,r9"); /* r9 = floating one */ ! 1769: 1746 00029373 0d effffff2b7 59 movl _sgl_value_2,r9 ! 1770: 1747 0002937A # if( subtest == 9 ) { ! 1771: 1748 0002937A 1d ad04 09 cmpl 4(fp),$9 ! 1772: 1749 0002937E 21 10 jneq L393 ! 1773: 1750 00029380 # asm("movl _sgl_value_5,r10"); /* r10= final SP value */ ! 1774: 1751 00029380 0d effffff2aa 5a movl _sgl_value_5,r10 ! 1775: 1752 00029387 # asm("movl _sgl_value_4,r11"); /* r11= expected SP value */ ! 1776: 1753 00029387 0d effffff2a3 5b movl _sgl_value_4,r11 ! 1777: 1754 0002938E # } else ! 1778: 1755 0002938E 11 14 jbr L394 ! 1779: 1756 00029390 L393: ! 1780: 1757 00029390 # if( subtest == 10 ) { ! 1781: 1758 00029390 1d ad04 0a cmpl 4(fp),$10 ! 1782: 1759 00029394 21 0e jneq L395 ! 1783: 1760 00029396 # asm("movl _sgl_value_5,r10"); /* r10= final FP value */ ! 1784: 1761 00029396 0d effffff294 5a movl _sgl_value_5,r10 ! 1785: 1762 0002939D # asm("movl _sgl_value_4,r11"); /* r11= expected FP value */ ! 1786: 1763 0002939D 0d effffff28d 5b movl _sgl_value_4,r11 ! 1787: 1764 000293A4 # }; ! 1788: 1765 000293A4 L395: ! 1789: 1766 000293A4 L394: ! 1790: 1767 000293A4 # asm(".globl _pipe4_1_hlt"); ! 1791: 1768 000293A4 .globl _pipe4_1_hlt ! 1792: 1769 000293A4 # asm("_pipe4_1_hlt:"); /* PC after the halt */ ! 1793: 1770 000293A4 _pipe4_1_hlt: ! 1794: 1771 000293A4 # asm("halt"); /* HALT ... */ ! 1795: 1772 000293A4 00 halt ! 1796: 1773 000293A5 # } /* end of halt on error */ ! 1797: 1774 000293A5 40 ret#2 ! 1798: 1775 000293A6 .set L389,0x0 ! 1799: 1776 000293A6 L391: ! 1800: 1777 000293A6 11 90 jbr L392 ! 1801: 1778 00000d78 * .data ! 1802: 1778 00000d78 * .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.