![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe3.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 pipe3.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 00000ce8 * .text ! 4: 4 00000000 .align 1 ! 5: 5 00000000 .globl _pipe_3 ! 6: 6 00000000 _pipe_3: ! 7: 7 00027948 0000 .word L215 ! 8: 8 0002794A # #include "fpp_defs.h" ! 9: 9 0002794A # ! 10: 10 0002794A # ! 11: 11 0002794A # /***************************************************************************** ! 12: 12 0002794A # * ! 13: 13 0002794A # * PIPELINE TEST #3 MONITOR ! 14: 14 0002794A # * ! 15: 15 0002794A # * This test will do: ! 16: 16 0002794A # * ! 17: 17 0002794A # * CVLF(x), STF, MULF(1), STF ! 18: 18 0002794A # * ! 19: 19 0002794A # * where x is the fmacro1 CVLF data. This test verifies that we can keep ! 20: 20 0002794A # * using data after we store it. ! 21: 21 0002794A # *****************************************************************************/ ! 22: 22 0002794A # pipe_3() ! 23: 23 0002794A # { ! 24: 24 0002794A 13 00a8 jbr L217 ! 25: 25 0002794D L218: ! 26: 26 0002794D # asm(".globl _pipeline_3_t"); ! 27: 27 0002794D .globl _pipeline_3_t ! 28: 28 0002794D # asm("_pipeline_3_t:"); /* entry address */ ! 29: 29 0002794D _pipeline_3_t: ! 30: 30 0002794D # if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */ ! 31: 31 0002794D 1d effffffff5 01 cmpl _cycle,$1 ! 32: 32 00027954 21 15 jneq L219 ! 33: 33 00027956 5d efffffffec tstl _prt_hdrs ! 34: 34 0002795C 31 0d jeql L219 ! 35: 35 0002795E # { ! 36: 36 0002795E # writes(" PIPE_3 "); ! 37: 37 0002795E .data 1 ! 38: 38 00000ce8 * L221: ! 39: 39 00000ce8 * 20504950455F332000 .ascii " PIPE_3 \0" ! 40: 40 00000cf1 * .text ! 41: 41 0002795E dd 8f00000ce8 pushl $L221 ! 42: 42 00027964 fe 08 efffffffdd callf $8,_writes ! 43: 43 0002796B # } ! 44: 44 0002796B # subtest = 1; ! 45: 45 0002796B L219: ! 46: 46 0002796B 0d 01 efffffffd6 movl $1,_subtest ! 47: 47 00027972 # pipe3_1(); /* data in REGs, no NOPs */ ! 48: 48 00027972 fe 04 ef0000007f callf $4,_pipe3_1 ! 49: 49 00027979 # subtest++; /* increment the subtest */ ! 50: 50 00027979 6d efffffffc9 incl _subtest ! 51: 51 0002797F # pipe3_2(); /* data in REGs, 1 NOP */ ! 52: 52 0002797F fe 04 ef00000162 callf $4,_pipe3_2 ! 53: 53 00027986 # subtest++; /* increment the subtest */ ! 54: 54 00027986 6d efffffffbc incl _subtest ! 55: 55 0002798C # pipe3_3(); /* data in REGs, 2 NOPs */ ! 56: 56 0002798C fe 04 ef00000247 callf $4,_pipe3_3 ! 57: 57 00027993 # subtest++; /* increment the subtest */ ! 58: 58 00027993 6d efffffffaf incl _subtest ! 59: 59 00027999 # pipe3_4(); /* data in REGs, 3 NOPs */ ! 60: 60 00027999 fe 04 ef00000330 callf $4,_pipe3_4 ! 61: 61 000279A0 # subtest++; /* increment the subtest */ ! 62: 62 000279A0 6d efffffffa2 incl _subtest ! 63: 63 000279A6 # pipe3_5(); /* data in CACHE, no NOPs */ ! 64: 64 000279A6 fe 04 ef0000041b callf $4,_pipe3_5 ! 65: 65 000279AD # subtest++; /* increment the subtest */ ! 66: 66 000279AD 6d efffffff95 incl _subtest ! 67: 67 000279B3 # pipe3_6(); /* data in CACHE, 1 NOP */ ! 68: 68 000279B3 fe 04 ef000004f2 callf $4,_pipe3_6 ! 69: 69 000279BA # subtest++; /* increment the subtest */ ! 70: 70 000279BA 6d efffffff88 incl _subtest ! 71: 71 000279C0 # pipe3_7(); /* data in CACHE, 2 NOPs */ ! 72: 72 000279C0 fe 04 ef000005cb callf $4,_pipe3_7 ! 73: 73 000279C7 # subtest++; /* increment the subtest */ ! 74: 74 000279C7 6d efffffff7b incl _subtest ! 75: 75 000279CD # pipe3_8(); /* data in CACHE, 3 NOPs */ ! 76: 76 000279CD fe 04 ef000006a8 callf $4,_pipe3_8 ! 77: 77 000279D4 # subtest++; /* increment the subtest */ ! 78: 78 000279D4 6d efffffff6e incl _subtest ! 79: 79 000279DA # pipe3_9(); /* data on STACK, no NOPs */ ! 80: 80 000279DA fe 04 ef00000787 callf $4,_pipe3_9 ! 81: 81 000279E1 # subtest++; /* increment the subtest */ ! 82: 82 000279E1 6d efffffff61 incl _subtest ! 83: 83 000279E7 # pipe3_10(); /* data via FP no NOPs */ ! 84: 84 000279E7 fe 04 ef000008fe callf $4,_pipe3_10 ! 85: 85 000279EE # asm("jmp *return"); /* return to the test monitor */ ! 86: 86 000279EE 71 ffffffff54 jmp *return ! 87: 87 000279F4 # } ! 88: 88 000279F4 40 ret#2 ! 89: 89 000279F5 .set L215,0x0 ! 90: 90 000279F5 L217: ! 91: 91 000279F5 13 ff55 jbr L218 ! 92: 92 000279F8 .data ! 93: 93 00000ce8 * .text ! 94: 94 000279F8 .align 1 ! 95: 95 000279F8 .globl _pipe3_1 ! 96: 96 000279F8 _pipe3_1: ! 97: 97 000279F8 0000 .word L232 ! 98: 98 000279FA # ! 99: 99 000279FA # ! 100: 100 000279FA # ! 101: 101 000279FA # ! 102: 102 000279FA # ! 103: 103 000279FA # ! 104: 104 000279FA # /************************************************************************ ! 105: 105 000279FA # * ! 106: 106 000279FA # * SUBTEST 1 ! 107: 107 000279FA # * data in registers, no NO-OPs ! 108: 108 000279FA # * ! 109: 109 000279FA # ************************************************************************/ ! 110: 110 000279FA # pipe3_1() ! 111: 111 000279FA # { ! 112: 112 000279FA 13 00e7 jbr L234 ! 113: 113 000279FD L235: ! 114: 114 000279FD # force_loop = FALSE; /* clear force_loop flag */ ! 115: 115 000279FD 4d efffffff45 clrl _force_loop ! 116: 116 00027A03 # index = 0; ! 117: 117 00027A03 4d efffffff3f clrl _index ! 118: 118 00027A09 # do ! 119: 119 00027A09 L238: ! 120: 120 00027A09 # { ! 121: 121 00027A09 # sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */ ! 122: 122 00027A09 0d efffffff39 50 movl _index,r0 ! 123: 123 00027A10 48 03 50 50 shll $3,r0,r0 ! 124: 124 00027A14 0d e000000000 efffffff29 movl _cvlf_1_data(r0),_sgl_value_1 ! 125: 125 00027A1F # sgl_expected = cvlf_1_data[index].exp; /* get expected results */ ! 126: 126 00027A1F 0d efffffff23 50 movl _index,r0 ! 127: 127 00027A26 48 03 50 50 shll $3,r0,r0 ! 128: 128 00027A2A 0d e000000004 efffffff13 movl _cvlf_1_data+4(r0),_sgl_expected ! 129: 129 00027A35 # sgl_value_2 = 0x40800000; /* floating '1' */ ! 130: 130 00027A35 0d 8f40800000 efffffff08 movl $1082130432,_sgl_value_2 ! 131: 131 00027A40 # /* ! 132: 132 00027A40 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 133: 133 00027A40 # * The force loop flag is set after the first error. ! 134: 134 00027A40 # */ ! 135: 135 00027A40 # asm("_pipe3_1_lp1:"); ! 136: 136 00027A40 _pipe3_1_lp1: ! 137: 137 00027A40 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */ ! 138: 138 00027A40 0d efffffff02 54 movl _sgl_value_1,r4 ! 139: 139 00027A47 # asm("movl _sgl_value_2,r5"); /* move data to r5 */ ! 140: 140 00027A47 0d effffffefb 55 movl _sgl_value_2,r5 ! 141: 141 00027A4E # asm("cvlf r4"); /* load (negate) the data */ ! 142: 142 00027A4E 76 54 cvlf r4 ! 143: 143 00027A50 # asm("stf r7"); /* store the result */ ! 144: 144 00027A50 26 57 stf r7 ! 145: 145 00027A52 # asm("mulf r5"); /* multipy by '1' (twice) */ ! 146: 146 00027A52 e6 55 mulf r5 ! 147: 147 00027A54 # asm("stf r8"); /* store the result */ ! 148: 148 00027A54 26 58 stf r8 ! 149: 149 00027A56 # if( force_loop ) ! 150: 150 00027A56 5d effffffeec tstl _force_loop ! 151: 151 00027A5C 31 02 jeql L239 ! 152: 152 00027A5E # asm("brb _pipe3_1_lp1");; /* loop on the error */ ! 153: 153 00027A5E 11 e0 brb _pipe3_1_lp1 ! 154: 154 00027A60 L239: ! 155: 155 00027A60 # /* ! 156: 156 00027A60 # * verify the results ! 157: 157 00027A60 # */ ! 158: 158 00027A60 # asm("movl r7,_sgl_st_acc"); /* get the 1st store value */ ! 159: 159 00027A60 0d 57 effffffee1 movl r7,_sgl_st_acc ! 160: 160 00027A67 # asm("movl r8,_sgl_value_6"); /* get the 2nd store value */ ! 161: 161 00027A67 0d 58 effffffeda movl r8,_sgl_value_6 ! 162: 162 00027A6E # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */ ! 163: 163 00027A6E # (sgl_value_6 != sgl_expected) ) ! 164: 164 00027A6E 1d effffffed4 effffffecf cmpl _sgl_st_acc,_sgl_expected ! 165: 165 00027A79 21 0d jneq L9999 ! 166: 166 00027A7B 1d effffffec7 effffffec2 cmpl _sgl_value_6,_sgl_expected ! 167: 167 00027A86 31 42 jeql L240 ! 168: 168 00027A88 L9999: ! 169: 169 00027A88 # { ! 170: 170 00027A88 # errcnt++; /* bump the error count */ ! 171: 171 00027A88 6d effffffeba incl _errcnt ! 172: 172 00027A8E # if ( prt_error ) ! 173: 173 00027A8E 5d effffffeb4 tstl _prt_error ! 174: 174 00027A94 31 0d jeql L241 ! 175: 175 00027A96 # print_pipe3_er("Reg. Data, no NOPS"); ! 176: 176 00027A96 .data 1 ! 177: 177 00000cf1 * L243: ! 178: 178 00000cf1 * 5265672E20446174612C206E6 .ascii "Reg. Data, no NOPS\0" ! 179: F204E4F505300 ! 180: 179 00000d04 * .text ! 181: 180 00027A96 dd 8f00000cf1 pushl $L243 ! 182: 181 00027A9C fe 08 ef00000a13 callf $8,_print_pipe3_er ! 183: 182 00027AA3 # if ( halt_flg ) ! 184: 183 00027AA3 L241: ! 185: 184 00027AA3 5d effffffe9f tstl _halt_flg ! 186: 185 00027AA9 31 0d jeql L244 ! 187: 186 00027AAB # pipe3_er_hlt( subtest ); ! 188: 187 00027AAB dd effffffe97 pushl _subtest ! 189: 188 00027AB1 fe 08 ef00000b0a callf $8,_pipe3_er_hlt ! 190: 189 00027AB8 # if ( loop_on_err ) { ! 191: 190 00027AB8 L244: ! 192: 191 00027AB8 5d effffffe8a tstl _loop_on_err ! 193: 192 00027ABE 31 0a jeql L246 ! 194: 193 00027AC0 # force_loop = TRUE; /* set the force loop flag */ ! 195: 194 00027AC0 0d 01 effffffe81 movl $1,_force_loop ! 196: 195 00027AC7 # asm("brw _pipe3_1_lp1"); /* and loop */ ! 197: 196 00027AC7 13 ff76 brw _pipe3_1_lp1 ! 198: 197 00027ACA # } ! 199: 198 00027ACA # } /* end of compare error */ ! 200: 199 00027ACA L246: ! 201: 200 00027ACA # } while( index++ < max_cvlf_1_index ); ! 202: 201 00027ACA L240: ! 203: 202 00027ACA L237: ! 204: 203 00027ACA 0d effffffe78 50 movl _index,r0 ! 205: 204 00027AD1 6d effffffe71 incl _index ! 206: 205 00027AD7 1d 50 effffffe6a cmpl r0,_max_cvlf_1_index ! 207: 206 00027ADE 81 03 13 ff26 jlss L238 ! 208: 207 00027AE3 L236: ! 209: 208 00027AE3 # } /* end of subtest 1 */ ! 210: 209 00027AE3 40 ret#2 ! 211: 210 00027AE4 .set L232,0x0 ! 212: 211 00027AE4 L234: ! 213: 212 00027AE4 13 ff16 jbr L235 ! 214: 213 00027AE7 .data ! 215: 214 00000ce8 * .text ! 216: 215 00027AE7 00 .align 1 ! 217: 216 00027AE8 .globl _pipe3_2 ! 218: 217 00027AE8 _pipe3_2: ! 219: 218 00027AE8 0000 .word L247 ! 220: 219 00027AEA # ! 221: 220 00027AEA # ! 222: 221 00027AEA # ! 223: 222 00027AEA # ! 224: 223 00027AEA # ! 225: 224 00027AEA # ! 226: 225 00027AEA # /************************************************************************ ! 227: 226 00027AEA # * ! 228: 227 00027AEA # * SUBTEST 2 ! 229: 228 00027AEA # * data in registers, 1 NO-OP ! 230: 229 00027AEA # * ! 231: 230 00027AEA # ************************************************************************/ ! 232: 231 00027AEA # pipe3_2() ! 233: 232 00027AEA # { ! 234: 233 00027AEA 13 00ea jbr L249 ! 235: 234 00027AED L250: ! 236: 235 00027AED # force_loop = FALSE; /* clear force_loop flag */ ! 237: 236 00027AED 4d effffffe55 clrl _force_loop ! 238: 237 00027AF3 # index = 0; ! 239: 238 00027AF3 4d effffffe4f clrl _index ! 240: 239 00027AF9 # do ! 241: 240 00027AF9 L253: ! 242: 241 00027AF9 # { ! 243: 242 00027AF9 # sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */ ! 244: 243 00027AF9 0d effffffe49 50 movl _index,r0 ! 245: 244 00027B00 48 03 50 50 shll $3,r0,r0 ! 246: 245 00027B04 0d e000000000 effffffe39 movl _cvlf_1_data(r0),_sgl_value_1 ! 247: 246 00027B0F # sgl_expected = cvlf_1_data[index].exp; /* get expected results */ ! 248: 247 00027B0F 0d effffffe33 50 movl _index,r0 ! 249: 248 00027B16 48 03 50 50 shll $3,r0,r0 ! 250: 249 00027B1A 0d e000000004 effffffe23 movl _cvlf_1_data+4(r0),_sgl_expected ! 251: 250 00027B25 # sgl_value_2 = 0x40800000; /* floating '1' */ ! 252: 251 00027B25 0d 8f40800000 effffffe18 movl $1082130432,_sgl_value_2 ! 253: 252 00027B30 # /* ! 254: 253 00027B30 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 255: 254 00027B30 # * The force loop flag is set after the first error. ! 256: 255 00027B30 # */ ! 257: 256 00027B30 # asm("_pipe3_2_lp1:"); ! 258: 257 00027B30 _pipe3_2_lp1: ! 259: 258 00027B30 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */ ! 260: 259 00027B30 0d effffffe12 54 movl _sgl_value_1,r4 ! 261: 260 00027B37 # asm("movl _sgl_value_2,r5"); /* move data to r5 */ ! 262: 261 00027B37 0d effffffe0b 55 movl _sgl_value_2,r5 ! 263: 262 00027B3E # asm("cvlf r4"); /* load (negate) the data */ ! 264: 263 00027B3E 76 54 cvlf r4 ! 265: 264 00027B40 # asm("nop"); ! 266: 265 00027B40 10 nop ! 267: 266 00027B41 # asm("stf r7"); /* store the result */ ! 268: 267 00027B41 26 57 stf r7 ! 269: 268 00027B43 # asm("nop"); ! 270: 269 00027B43 10 nop ! 271: 270 00027B44 # asm("mulf r5"); /* multipy by '1' (twice) */ ! 272: 271 00027B44 e6 55 mulf r5 ! 273: 272 00027B46 # asm("nop"); ! 274: 273 00027B46 10 nop ! 275: 274 00027B47 # asm("stf r8"); /* store the result */ ! 276: 275 00027B47 26 58 stf r8 ! 277: 276 00027B49 # if( force_loop ) ! 278: 277 00027B49 5d effffffdf9 tstl _force_loop ! 279: 278 00027B4F 31 02 jeql L254 ! 280: 279 00027B51 # asm("brb _pipe3_2_lp1");; /* loop on the error */ ! 281: 280 00027B51 11 dd brb _pipe3_2_lp1 ! 282: 281 00027B53 L254: ! 283: 282 00027B53 # /* ! 284: 283 00027B53 # * verify the results ! 285: 284 00027B53 # */ ! 286: 285 00027B53 # asm("movl r7,_sgl_st_acc"); /* get the 1st store value */ ! 287: 286 00027B53 0d 57 effffffdee movl r7,_sgl_st_acc ! 288: 287 00027B5A # asm("movl r8,_sgl_value_6"); /* get the 2nd store value */ ! 289: 288 00027B5A 0d 58 effffffde7 movl r8,_sgl_value_6 ! 290: 289 00027B61 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */ ! 291: 290 00027B61 # (sgl_value_6 != sgl_expected) ) ! 292: 291 00027B61 1d effffffde1 effffffddc cmpl _sgl_st_acc,_sgl_expected ! 293: 292 00027B6C 21 0d jneq L9998 ! 294: 293 00027B6E 1d effffffdd4 effffffdcf cmpl _sgl_value_6,_sgl_expected ! 295: 294 00027B79 31 42 jeql L255 ! 296: 295 00027B7B L9998: ! 297: 296 00027B7B # { ! 298: 297 00027B7B # errcnt++; /* bump the error count */ ! 299: 298 00027B7B 6d effffffdc7 incl _errcnt ! 300: 299 00027B81 # if ( prt_error ) ! 301: 300 00027B81 5d effffffdc1 tstl _prt_error ! 302: 301 00027B87 31 0d jeql L256 ! 303: 302 00027B89 # print_pipe3_er("Reg. Data, 1 NO-OP"); ! 304: 303 00027B89 .data 1 ! 305: 304 00000d04 * L257: ! 306: 305 00000d04 * 5265672E20446174612C20312 .ascii "Reg. Data, 1 NO-OP\0" ! 307: 04E4F2D4F5000 ! 308: 306 00000d17 * .text ! 309: 307 00027B89 dd 8f00000d04 pushl $L257 ! 310: 308 00027B8F fe 08 ef00000920 callf $8,_print_pipe3_er ! 311: 309 00027B96 # if ( halt_flg ) ! 312: 310 00027B96 L256: ! 313: 311 00027B96 5d effffffdac tstl _halt_flg ! 314: 312 00027B9C 31 0d jeql L258 ! 315: 313 00027B9E # pipe3_er_hlt( subtest ); ! 316: 314 00027B9E dd effffffda4 pushl _subtest ! 317: 315 00027BA4 fe 08 ef00000a17 callf $8,_pipe3_er_hlt ! 318: 316 00027BAB # if ( loop_on_err ) { ! 319: 317 00027BAB L258: ! 320: 318 00027BAB 5d effffffd97 tstl _loop_on_err ! 321: 319 00027BB1 31 0a jeql L259 ! 322: 320 00027BB3 # force_loop = TRUE; /* set the force loop flag */ ! 323: 321 00027BB3 0d 01 effffffd8e movl $1,_force_loop ! 324: 322 00027BBA # asm("brw _pipe3_2_lp1"); /* and loop */ ! 325: 323 00027BBA 13 ff73 brw _pipe3_2_lp1 ! 326: 324 00027BBD # } ! 327: 325 00027BBD # } /* end of compare error */ ! 328: 326 00027BBD L259: ! 329: 327 00027BBD # } while( index++ < max_cvlf_1_index ); ! 330: 328 00027BBD L255: ! 331: 329 00027BBD L252: ! 332: 330 00027BBD 0d effffffd85 50 movl _index,r0 ! 333: 331 00027BC4 6d effffffd7e incl _index ! 334: 332 00027BCA 1d 50 effffffd77 cmpl r0,_max_cvlf_1_index ! 335: 333 00027BD1 81 03 13 ff23 jlss L253 ! 336: 334 00027BD6 L251: ! 337: 335 00027BD6 # } /* end of subtest 2 */ ! 338: 336 00027BD6 40 ret#2 ! 339: 337 00027BD7 .set L247,0x0 ! 340: 338 00027BD7 L249: ! 341: 339 00027BD7 13 ff13 jbr L250 ! 342: 340 00027BDA .data ! 343: 341 00000ce8 * .text ! 344: 342 00027BDA .align 1 ! 345: 343 00027BDA .globl _pipe3_3 ! 346: 344 00027BDA _pipe3_3: ! 347: 345 00027BDA 0000 .word L260 ! 348: 346 00027BDC # ! 349: 347 00027BDC # ! 350: 348 00027BDC # ! 351: 349 00027BDC # ! 352: 350 00027BDC # ! 353: 351 00027BDC # ! 354: 352 00027BDC # /************************************************************************ ! 355: 353 00027BDC # * ! 356: 354 00027BDC # * SUBTEST 3 ! 357: 355 00027BDC # * data in registers, 2 NO-OPs ! 358: 356 00027BDC # * ! 359: 357 00027BDC # ************************************************************************/ ! 360: 358 00027BDC # pipe3_3() ! 361: 359 00027BDC # { ! 362: 360 00027BDC 13 00ed jbr L262 ! 363: 361 00027BDF L263: ! 364: 362 00027BDF # force_loop = FALSE; /* clear force_loop flag */ ! 365: 363 00027BDF 4d effffffd63 clrl _force_loop ! 366: 364 00027BE5 # index = 0; ! 367: 365 00027BE5 4d effffffd5d clrl _index ! 368: 366 00027BEB # do ! 369: 367 00027BEB L266: ! 370: 368 00027BEB # { ! 371: 369 00027BEB # sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */ ! 372: 370 00027BEB 0d effffffd57 50 movl _index,r0 ! 373: 371 00027BF2 48 03 50 50 shll $3,r0,r0 ! 374: 372 00027BF6 0d e000000000 effffffd47 movl _cvlf_1_data(r0),_sgl_value_1 ! 375: 373 00027C01 # sgl_expected = cvlf_1_data[index].exp; /* get expected results */ ! 376: 374 00027C01 0d effffffd41 50 movl _index,r0 ! 377: 375 00027C08 48 03 50 50 shll $3,r0,r0 ! 378: 376 00027C0C 0d e000000004 effffffd31 movl _cvlf_1_data+4(r0),_sgl_expected ! 379: 377 00027C17 # sgl_value_2 = 0x40800000; /* floating '1' */ ! 380: 378 00027C17 0d 8f40800000 effffffd26 movl $1082130432,_sgl_value_2 ! 381: 379 00027C22 # /* ! 382: 380 00027C22 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 383: 381 00027C22 # * The force loop flag is set after the first error. ! 384: 382 00027C22 # */ ! 385: 383 00027C22 # asm("_pipe3_3_lp1:"); ! 386: 384 00027C22 _pipe3_3_lp1: ! 387: 385 00027C22 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */ ! 388: 386 00027C22 0d effffffd20 54 movl _sgl_value_1,r4 ! 389: 387 00027C29 # asm("movl _sgl_value_2,r5"); /* move data to r5 */ ! 390: 388 00027C29 0d effffffd19 55 movl _sgl_value_2,r5 ! 391: 389 00027C30 # asm("cvlf r4"); /* load (negate) the data */ ! 392: 390 00027C30 76 54 cvlf r4 ! 393: 391 00027C32 # asm("nop"); ! 394: 392 00027C32 10 nop ! 395: 393 00027C33 # asm("nop"); ! 396: 394 00027C33 10 nop ! 397: 395 00027C34 # asm("stf r7"); /* store the result */ ! 398: 396 00027C34 26 57 stf r7 ! 399: 397 00027C36 # asm("nop"); ! 400: 398 00027C36 10 nop ! 401: 399 00027C37 # asm("nop"); ! 402: 400 00027C37 10 nop ! 403: 401 00027C38 # asm("mulf r5"); /* multipy by '1' (twice) */ ! 404: 402 00027C38 e6 55 mulf r5 ! 405: 403 00027C3A # asm("nop"); ! 406: 404 00027C3A 10 nop ! 407: 405 00027C3B # asm("nop"); ! 408: 406 00027C3B 10 nop ! 409: 407 00027C3C # asm("stf r8"); /* store the result */ ! 410: 408 00027C3C 26 58 stf r8 ! 411: 409 00027C3E # if( force_loop ) ! 412: 410 00027C3E 5d effffffd04 tstl _force_loop ! 413: 411 00027C44 31 02 jeql L267 ! 414: 412 00027C46 # asm("brb _pipe3_3_lp1");; /* loop on the error */ ! 415: 413 00027C46 11 da brb _pipe3_3_lp1 ! 416: 414 00027C48 L267: ! 417: 415 00027C48 # /* ! 418: 416 00027C48 # * verify the results ! 419: 417 00027C48 # */ ! 420: 418 00027C48 # asm("movl r7,_sgl_st_acc"); /* get the 1st store value */ ! 421: 419 00027C48 0d 57 effffffcf9 movl r7,_sgl_st_acc ! 422: 420 00027C4F # asm("movl r8,_sgl_value_6"); /* get the 2nd store value */ ! 423: 421 00027C4F 0d 58 effffffcf2 movl r8,_sgl_value_6 ! 424: 422 00027C56 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */ ! 425: 423 00027C56 # (sgl_value_6 != sgl_expected) ) ! 426: 424 00027C56 1d effffffcec effffffce7 cmpl _sgl_st_acc,_sgl_expected ! 427: 425 00027C61 21 0d jneq L9997 ! 428: 426 00027C63 1d effffffcdf effffffcda cmpl _sgl_value_6,_sgl_expected ! 429: 427 00027C6E 31 42 jeql L268 ! 430: 428 00027C70 L9997: ! 431: 429 00027C70 # { ! 432: 430 00027C70 # errcnt++; /* bump the error count */ ! 433: 431 00027C70 6d effffffcd2 incl _errcnt ! 434: 432 00027C76 # if ( prt_error ) ! 435: 433 00027C76 5d effffffccc tstl _prt_error ! 436: 434 00027C7C 31 0d jeql L269 ! 437: 435 00027C7E # print_pipe3_er("Reg. Data, 2 NO-OPS"); ! 438: 436 00027C7E .data 1 ! 439: 437 00000d17 * L270: ! 440: 438 00000d17 * 5265672E20446174612C20322 .ascii "Reg. Data, 2 NO-OPS\0" ! 441: 04E4F2D4F505300 ! 442: 439 00000d2b * .text ! 443: 440 00027C7E dd 8f00000d17 pushl $L270 ! 444: 441 00027C84 fe 08 ef0000082b callf $8,_print_pipe3_er ! 445: 442 00027C8B # if ( halt_flg ) ! 446: 443 00027C8B L269: ! 447: 444 00027C8B 5d effffffcb7 tstl _halt_flg ! 448: 445 00027C91 31 0d jeql L271 ! 449: 446 00027C93 # pipe3_er_hlt( subtest ); ! 450: 447 00027C93 dd effffffcaf pushl _subtest ! 451: 448 00027C99 fe 08 ef00000922 callf $8,_pipe3_er_hlt ! 452: 449 00027CA0 # if ( loop_on_err ) { ! 453: 450 00027CA0 L271: ! 454: 451 00027CA0 5d effffffca2 tstl _loop_on_err ! 455: 452 00027CA6 31 0a jeql L272 ! 456: 453 00027CA8 # force_loop = TRUE; /* set the force loop flag */ ! 457: 454 00027CA8 0d 01 effffffc99 movl $1,_force_loop ! 458: 455 00027CAF # asm("brw _pipe3_3_lp1"); /* and loop */ ! 459: 456 00027CAF 13 ff70 brw _pipe3_3_lp1 ! 460: 457 00027CB2 # } ! 461: 458 00027CB2 # } /* end of compare error */ ! 462: 459 00027CB2 L272: ! 463: 460 00027CB2 # } while( index++ < max_cvlf_1_index ); ! 464: 461 00027CB2 L268: ! 465: 462 00027CB2 L265: ! 466: 463 00027CB2 0d effffffc90 50 movl _index,r0 ! 467: 464 00027CB9 6d effffffc89 incl _index ! 468: 465 00027CBF 1d 50 effffffc82 cmpl r0,_max_cvlf_1_index ! 469: 466 00027CC6 81 03 13 ff20 jlss L266 ! 470: 467 00027CCB L264: ! 471: 468 00027CCB # } /* end of subtest 3 */ ! 472: 469 00027CCB 40 ret#2 ! 473: 470 00027CCC .set L260,0x0 ! 474: 471 00027CCC L262: ! 475: 472 00027CCC 13 ff10 jbr L263 ! 476: 473 00027CCF .data ! 477: 474 00000ce8 * .text ! 478: 475 00027CCF 00 .align 1 ! 479: 476 00027CD0 .globl _pipe3_4 ! 480: 477 00027CD0 _pipe3_4: ! 481: 478 00027CD0 0000 .word L273 ! 482: 479 00027CD2 # ! 483: 480 00027CD2 # ! 484: 481 00027CD2 # ! 485: 482 00027CD2 # ! 486: 483 00027CD2 # ! 487: 484 00027CD2 # ! 488: 485 00027CD2 # /************************************************************************ ! 489: 486 00027CD2 # * ! 490: 487 00027CD2 # * SUBTEST 4 ! 491: 488 00027CD2 # * data in registers, 3 NO-OPs ! 492: 489 00027CD2 # * ! 493: 490 00027CD2 # ************************************************************************/ ! 494: 491 00027CD2 # pipe3_4() ! 495: 492 00027CD2 # { ! 496: 493 00027CD2 13 00f0 jbr L275 ! 497: 494 00027CD5 L276: ! 498: 495 00027CD5 # force_loop = FALSE; /* clear force_loop flag */ ! 499: 496 00027CD5 4d effffffc6d clrl _force_loop ! 500: 497 00027CDB # index = 0; ! 501: 498 00027CDB 4d effffffc67 clrl _index ! 502: 499 00027CE1 # do ! 503: 500 00027CE1 L279: ! 504: 501 00027CE1 # { ! 505: 502 00027CE1 # sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */ ! 506: 503 00027CE1 0d effffffc61 50 movl _index,r0 ! 507: 504 00027CE8 48 03 50 50 shll $3,r0,r0 ! 508: 505 00027CEC 0d e000000000 effffffc51 movl _cvlf_1_data(r0),_sgl_value_1 ! 509: 506 00027CF7 # sgl_expected = cvlf_1_data[index].exp; /* get expected results */ ! 510: 507 00027CF7 0d effffffc4b 50 movl _index,r0 ! 511: 508 00027CFE 48 03 50 50 shll $3,r0,r0 ! 512: 509 00027D02 0d e000000004 effffffc3b movl _cvlf_1_data+4(r0),_sgl_expected ! 513: 510 00027D0D # sgl_value_2 = 0x40800000; /* floating '1' */ ! 514: 511 00027D0D 0d 8f40800000 effffffc30 movl $1082130432,_sgl_value_2 ! 515: 512 00027D18 # /* ! 516: 513 00027D18 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 517: 514 00027D18 # * The force loop flag is set after the first error. ! 518: 515 00027D18 # */ ! 519: 516 00027D18 # asm("_pipe3_4_lp1:"); ! 520: 517 00027D18 _pipe3_4_lp1: ! 521: 518 00027D18 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */ ! 522: 519 00027D18 0d effffffc2a 54 movl _sgl_value_1,r4 ! 523: 520 00027D1F # asm("movl _sgl_value_2,r5"); /* move data to r5 */ ! 524: 521 00027D1F 0d effffffc23 55 movl _sgl_value_2,r5 ! 525: 522 00027D26 # asm("cvlf r4"); /* load (negate) the data */ ! 526: 523 00027D26 76 54 cvlf r4 ! 527: 524 00027D28 # asm("nop"); ! 528: 525 00027D28 10 nop ! 529: 526 00027D29 # asm("nop"); ! 530: 527 00027D29 10 nop ! 531: 528 00027D2A # asm("nop"); ! 532: 529 00027D2A 10 nop ! 533: 530 00027D2B # asm("stf r7"); /* store the result */ ! 534: 531 00027D2B 26 57 stf r7 ! 535: 532 00027D2D # asm("nop"); ! 536: 533 00027D2D 10 nop ! 537: 534 00027D2E # asm("nop"); ! 538: 535 00027D2E 10 nop ! 539: 536 00027D2F # asm("nop"); ! 540: 537 00027D2F 10 nop ! 541: 538 00027D30 # asm("mulf r5"); /* multipy by '1' (twice) */ ! 542: 539 00027D30 e6 55 mulf r5 ! 543: 540 00027D32 # asm("nop"); ! 544: 541 00027D32 10 nop ! 545: 542 00027D33 # asm("nop"); ! 546: 543 00027D33 10 nop ! 547: 544 00027D34 # asm("nop"); ! 548: 545 00027D34 10 nop ! 549: 546 00027D35 # asm("stf r8"); /* store the result */ ! 550: 547 00027D35 26 58 stf r8 ! 551: 548 00027D37 # if( force_loop ) ! 552: 549 00027D37 5d effffffc0b tstl _force_loop ! 553: 550 00027D3D 31 02 jeql L280 ! 554: 551 00027D3F # asm("brb _pipe3_4_lp1");; /* loop on the error */ ! 555: 552 00027D3F 11 d7 brb _pipe3_4_lp1 ! 556: 553 00027D41 L280: ! 557: 554 00027D41 # /* ! 558: 555 00027D41 # * verify the results ! 559: 556 00027D41 # */ ! 560: 557 00027D41 # asm("movl r7,_sgl_st_acc"); /* get the 1st store value */ ! 561: 558 00027D41 0d 57 effffffc00 movl r7,_sgl_st_acc ! 562: 559 00027D48 # asm("movl r8,_sgl_value_6"); /* get the 2nd store value */ ! 563: 560 00027D48 0d 58 effffffbf9 movl r8,_sgl_value_6 ! 564: 561 00027D4F # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */ ! 565: 562 00027D4F # (sgl_value_6 != sgl_expected) ) ! 566: 563 00027D4F 1d effffffbf3 effffffbee cmpl _sgl_st_acc,_sgl_expected ! 567: 564 00027D5A 21 0d jneq L9996 ! 568: 565 00027D5C 1d effffffbe6 effffffbe1 cmpl _sgl_value_6,_sgl_expected ! 569: 566 00027D67 31 42 jeql L281 ! 570: 567 00027D69 L9996: ! 571: 568 00027D69 # { ! 572: 569 00027D69 # errcnt++; /* bump the error count */ ! 573: 570 00027D69 6d effffffbd9 incl _errcnt ! 574: 571 00027D6F # if ( prt_error ) ! 575: 572 00027D6F 5d effffffbd3 tstl _prt_error ! 576: 573 00027D75 31 0d jeql L282 ! 577: 574 00027D77 # print_pipe3_er("Reg. Data, 3 NO-OPS"); ! 578: 575 00027D77 .data 1 ! 579: 576 00000d2b * L283: ! 580: 577 00000d2b * 5265672E20446174612C20332 .ascii "Reg. Data, 3 NO-OPS\0" ! 581: 04E4F2D4F505300 ! 582: 578 00000d3f * .text ! 583: 579 00027D77 dd 8f00000d2b pushl $L283 ! 584: 580 00027D7D fe 08 ef00000732 callf $8,_print_pipe3_er ! 585: 581 00027D84 # if ( halt_flg ) ! 586: 582 00027D84 L282: ! 587: 583 00027D84 5d effffffbbe tstl _halt_flg ! 588: 584 00027D8A 31 0d jeql L284 ! 589: 585 00027D8C # pipe3_er_hlt( subtest ); ! 590: 586 00027D8C dd effffffbb6 pushl _subtest ! 591: 587 00027D92 fe 08 ef00000829 callf $8,_pipe3_er_hlt ! 592: 588 00027D99 # if ( loop_on_err ) { ! 593: 589 00027D99 L284: ! 594: 590 00027D99 5d effffffba9 tstl _loop_on_err ! 595: 591 00027D9F 31 0a jeql L285 ! 596: 592 00027DA1 # force_loop = TRUE; /* set the force loop flag */ ! 597: 593 00027DA1 0d 01 effffffba0 movl $1,_force_loop ! 598: 594 00027DA8 # asm("brw _pipe3_4_lp1"); /* and loop */ ! 599: 595 00027DA8 13 ff6d brw _pipe3_4_lp1 ! 600: 596 00027DAB # } ! 601: 597 00027DAB # } /* end of compare error */ ! 602: 598 00027DAB L285: ! 603: 599 00027DAB # } while( index++ < max_cvlf_1_index ); ! 604: 600 00027DAB L281: ! 605: 601 00027DAB L278: ! 606: 602 00027DAB 0d effffffb97 50 movl _index,r0 ! 607: 603 00027DB2 6d effffffb90 incl _index ! 608: 604 00027DB8 1d 50 effffffb89 cmpl r0,_max_cvlf_1_index ! 609: 605 00027DBF 81 03 13 ff1d jlss L279 ! 610: 606 00027DC4 L277: ! 611: 607 00027DC4 # } /* end of subtest 4 */ ! 612: 608 00027DC4 40 ret#2 ! 613: 609 00027DC5 .set L273,0x0 ! 614: 610 00027DC5 L275: ! 615: 611 00027DC5 13 ff0d jbr L276 ! 616: 612 00027DC8 .data ! 617: 613 00000ce8 * .text ! 618: 614 00027DC8 .align 1 ! 619: 615 00027DC8 .globl _pipe3_5 ! 620: 616 00027DC8 _pipe3_5: ! 621: 617 00027DC8 0000 .word L286 ! 622: 618 00027DCA # ! 623: 619 00027DCA # ! 624: 620 00027DCA # ! 625: 621 00027DCA # ! 626: 622 00027DCA # ! 627: 623 00027DCA # ! 628: 624 00027DCA # ! 629: 625 00027DCA # /************************************************************************ ! 630: 626 00027DCA # * ! 631: 627 00027DCA # * SUBTEST 5 ! 632: 628 00027DCA # * data in Cache, no NO-OPs ! 633: 629 00027DCA # * ! 634: 630 00027DCA # ************************************************************************/ ! 635: 631 00027DCA # pipe3_5() ! 636: 632 00027DCA # { ! 637: 633 00027DCA 13 00db jbr L288 ! 638: 634 00027DCD L289: ! 639: 635 00027DCD # force_loop = FALSE; /* clear force_loop flag */ ! 640: 636 00027DCD 4d effffffb75 clrl _force_loop ! 641: 637 00027DD3 # index = 0; ! 642: 638 00027DD3 4d effffffb6f clrl _index ! 643: 639 00027DD9 # do ! 644: 640 00027DD9 L292: ! 645: 641 00027DD9 # { ! 646: 642 00027DD9 # sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */ ! 647: 643 00027DD9 0d effffffb69 50 movl _index,r0 ! 648: 644 00027DE0 48 03 50 50 shll $3,r0,r0 ! 649: 645 00027DE4 0d e000000000 effffffb59 movl _cvlf_1_data(r0),_sgl_value_1 ! 650: 646 00027DEF # sgl_expected = cvlf_1_data[index].exp; /* get expected results */ ! 651: 647 00027DEF 0d effffffb53 50 movl _index,r0 ! 652: 648 00027DF6 48 03 50 50 shll $3,r0,r0 ! 653: 649 00027DFA 0d e000000004 effffffb43 movl _cvlf_1_data+4(r0),_sgl_expected ! 654: 650 00027E05 # sgl_value_2 = 0x40800000; /* floating '1' */ ! 655: 651 00027E05 0d 8f40800000 effffffb38 movl $1082130432,_sgl_value_2 ! 656: 652 00027E10 # /* ! 657: 653 00027E10 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 658: 654 00027E10 # * The force loop flag is set after the first error. ! 659: 655 00027E10 # */ ! 660: 656 00027E10 # asm("_pipe3_5_lp1:"); ! 661: 657 00027E10 _pipe3_5_lp1: ! 662: 658 00027E10 # asm("cvlf _sgl_value_1"); /* load (negate) the data */ ! 663: 659 00027E10 76 effffffb32 cvlf _sgl_value_1 ! 664: 660 00027E16 # asm("stf _sgl_st_acc"); /* store the result */ ! 665: 661 00027E16 26 effffffb2c stf _sgl_st_acc ! 666: 662 00027E1C # asm("mulf _sgl_value_2"); /* multipy by '1' (twice) */ ! 667: 663 00027E1C e6 effffffb26 mulf _sgl_value_2 ! 668: 664 00027E22 # asm("stf _sgl_value_6"); /* store the result */ ! 669: 665 00027E22 26 effffffb20 stf _sgl_value_6 ! 670: 666 00027E28 # if( force_loop ) ! 671: 667 00027E28 5d effffffb1a tstl _force_loop ! 672: 668 00027E2E 31 02 jeql L293 ! 673: 669 00027E30 # asm("brb _pipe3_5_lp1");; /* loop on the error */ ! 674: 670 00027E30 11 de brb _pipe3_5_lp1 ! 675: 671 00027E32 L293: ! 676: 672 00027E32 # /* ! 677: 673 00027E32 # * verify the results ! 678: 674 00027E32 # */ ! 679: 675 00027E32 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */ ! 680: 676 00027E32 # (sgl_value_6 != sgl_expected) ) ! 681: 677 00027E32 1d effffffb10 effffffb0b cmpl _sgl_st_acc,_sgl_expected ! 682: 678 00027E3D 21 0d jneq L9995 ! 683: 679 00027E3F 1d effffffb03 effffffafe cmpl _sgl_value_6,_sgl_expected ! 684: 680 00027E4A 31 42 jeql L294 ! 685: 681 00027E4C L9995: ! 686: 682 00027E4C # { ! 687: 683 00027E4C # errcnt++; /* bump the error count */ ! 688: 684 00027E4C 6d effffffaf6 incl _errcnt ! 689: 685 00027E52 # if ( prt_error ) ! 690: 686 00027E52 5d effffffaf0 tstl _prt_error ! 691: 687 00027E58 31 0d jeql L295 ! 692: 688 00027E5A # print_pipe3_er("Cache Data, no NO-OPS"); ! 693: 689 00027E5A .data 1 ! 694: 690 00000d3f * L296: ! 695: 691 00000d3f * 436163686520446174612C206 .ascii "Cache Data, no NO-OPS\0" ! 696: E6F204E4F2D4F505300 ! 697: 692 00000d55 * .text ! 698: 693 00027E5A dd 8f00000d3f pushl $L296 ! 699: 694 00027E60 fe 08 ef0000064f callf $8,_print_pipe3_er ! 700: 695 00027E67 # if ( halt_flg ) ! 701: 696 00027E67 L295: ! 702: 697 00027E67 5d effffffadb tstl _halt_flg ! 703: 698 00027E6D 31 0d jeql L297 ! 704: 699 00027E6F # pipe3_er_hlt( subtest ); ! 705: 700 00027E6F dd effffffad3 pushl _subtest ! 706: 701 00027E75 fe 08 ef00000746 callf $8,_pipe3_er_hlt ! 707: 702 00027E7C # if ( loop_on_err ) { ! 708: 703 00027E7C L297: ! 709: 704 00027E7C 5d effffffac6 tstl _loop_on_err ! 710: 705 00027E82 31 0a jeql L298 ! 711: 706 00027E84 # force_loop = TRUE; /* set the force loop flag */ ! 712: 707 00027E84 0d 01 effffffabd movl $1,_force_loop ! 713: 708 00027E8B # asm("brw _pipe3_5_lp1"); /* and loop */ ! 714: 709 00027E8B 13 ff82 brw _pipe3_5_lp1 ! 715: 710 00027E8E # } ! 716: 711 00027E8E # } /* end of compare error */ ! 717: 712 00027E8E L298: ! 718: 713 00027E8E # } while( index++ < max_cvlf_1_index ); ! 719: 714 00027E8E L294: ! 720: 715 00027E8E L291: ! 721: 716 00027E8E 0d effffffab4 50 movl _index,r0 ! 722: 717 00027E95 6d effffffaad incl _index ! 723: 718 00027E9B 1d 50 effffffaa6 cmpl r0,_max_cvlf_1_index ! 724: 719 00027EA2 81 03 13 ff32 jlss L292 ! 725: 720 00027EA7 L290: ! 726: 721 00027EA7 # } /* end of subtest 5 */ ! 727: 722 00027EA7 40 ret#2 ! 728: 723 00027EA8 .set L286,0x0 ! 729: 724 00027EA8 L288: ! 730: 725 00027EA8 13 ff22 jbr L289 ! 731: 726 00027EAB .data ! 732: 727 00000ce8 * .text ! 733: 728 00027EAB 00 .align 1 ! 734: 729 00027EAC .globl _pipe3_6 ! 735: 730 00027EAC _pipe3_6: ! 736: 731 00027EAC 0000 .word L299 ! 737: 732 00027EAE # ! 738: 733 00027EAE # ! 739: 734 00027EAE # ! 740: 735 00027EAE # ! 741: 736 00027EAE # ! 742: 737 00027EAE # ! 743: 738 00027EAE # /************************************************************************ ! 744: 739 00027EAE # * ! 745: 740 00027EAE # * SUBTEST 6 ! 746: 741 00027EAE # * data in Cache, 1 NO-OP ! 747: 742 00027EAE # * ! 748: 743 00027EAE # ************************************************************************/ ! 749: 744 00027EAE # pipe3_6() ! 750: 745 00027EAE # { ! 751: 746 00027EAE 13 00de jbr L301 ! 752: 747 00027EB1 L302: ! 753: 748 00027EB1 # force_loop = FALSE; /* clear force_loop flag */ ! 754: 749 00027EB1 4d effffffa91 clrl _force_loop ! 755: 750 00027EB7 # index = 0; ! 756: 751 00027EB7 4d effffffa8b clrl _index ! 757: 752 00027EBD # do ! 758: 753 00027EBD L305: ! 759: 754 00027EBD # { ! 760: 755 00027EBD # sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */ ! 761: 756 00027EBD 0d effffffa85 50 movl _index,r0 ! 762: 757 00027EC4 48 03 50 50 shll $3,r0,r0 ! 763: 758 00027EC8 0d e000000000 effffffa75 movl _cvlf_1_data(r0),_sgl_value_1 ! 764: 759 00027ED3 # sgl_expected = cvlf_1_data[index].exp; /* get expected results */ ! 765: 760 00027ED3 0d effffffa6f 50 movl _index,r0 ! 766: 761 00027EDA 48 03 50 50 shll $3,r0,r0 ! 767: 762 00027EDE 0d e000000004 effffffa5f movl _cvlf_1_data+4(r0),_sgl_expected ! 768: 763 00027EE9 # sgl_value_2 = 0x40800000; /* floating '1' */ ! 769: 764 00027EE9 0d 8f40800000 effffffa54 movl $1082130432,_sgl_value_2 ! 770: 765 00027EF4 # /* ! 771: 766 00027EF4 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 772: 767 00027EF4 # * The force loop flag is set after the first error. ! 773: 768 00027EF4 # */ ! 774: 769 00027EF4 # asm("_pipe3_6_lp1:"); ! 775: 770 00027EF4 _pipe3_6_lp1: ! 776: 771 00027EF4 # asm("cvlf _sgl_value_1"); /* load (negate) the data */ ! 777: 772 00027EF4 76 effffffa4e cvlf _sgl_value_1 ! 778: 773 00027EFA # asm("nop"); ! 779: 774 00027EFA 10 nop ! 780: 775 00027EFB # asm("stf _sgl_st_acc"); /* store the result */ ! 781: 776 00027EFB 26 effffffa47 stf _sgl_st_acc ! 782: 777 00027F01 # asm("nop"); ! 783: 778 00027F01 10 nop ! 784: 779 00027F02 # asm("mulf _sgl_value_2"); /* multipy by '1' (twice) */ ! 785: 780 00027F02 e6 effffffa40 mulf _sgl_value_2 ! 786: 781 00027F08 # asm("nop"); ! 787: 782 00027F08 10 nop ! 788: 783 00027F09 # asm("stf _sgl_value_6"); /* store the result */ ! 789: 784 00027F09 26 effffffa39 stf _sgl_value_6 ! 790: 785 00027F0F # if( force_loop ) ! 791: 786 00027F0F 5d effffffa33 tstl _force_loop ! 792: 787 00027F15 31 02 jeql L306 ! 793: 788 00027F17 # asm("brb _pipe3_6_lp1");; /* loop on the error */ ! 794: 789 00027F17 11 db brb _pipe3_6_lp1 ! 795: 790 00027F19 L306: ! 796: 791 00027F19 # /* ! 797: 792 00027F19 # * verify the results ! 798: 793 00027F19 # */ ! 799: 794 00027F19 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */ ! 800: 795 00027F19 # (sgl_value_6 != sgl_expected) ) ! 801: 796 00027F19 1d effffffa29 effffffa24 cmpl _sgl_st_acc,_sgl_expected ! 802: 797 00027F24 21 0d jneq L9994 ! 803: 798 00027F26 1d effffffa1c effffffa17 cmpl _sgl_value_6,_sgl_expected ! 804: 799 00027F31 31 42 jeql L307 ! 805: 800 00027F33 L9994: ! 806: 801 00027F33 # { ! 807: 802 00027F33 # errcnt++; /* bump the error count */ ! 808: 803 00027F33 6d effffffa0f incl _errcnt ! 809: 804 00027F39 # if ( prt_error ) ! 810: 805 00027F39 5d effffffa09 tstl _prt_error ! 811: 806 00027F3F 31 0d jeql L308 ! 812: 807 00027F41 # print_pipe3_er("Cache Data, 1 NO-OP"); ! 813: 808 00027F41 .data 1 ! 814: 809 00000d55 * L309: ! 815: 810 00000d55 * 436163686520446174612C203 .ascii "Cache Data, 1 NO-OP\0" ! 816: 1204E4F2D4F5000 ! 817: 811 00000d69 * .text ! 818: 812 00027F41 dd 8f00000d55 pushl $L309 ! 819: 813 00027F47 fe 08 ef00000568 callf $8,_print_pipe3_er ! 820: 814 00027F4E # if ( halt_flg ) ! 821: 815 00027F4E L308: ! 822: 816 00027F4E 5d effffff9f4 tstl _halt_flg ! 823: 817 00027F54 31 0d jeql L310 ! 824: 818 00027F56 # pipe3_er_hlt( subtest ); ! 825: 819 00027F56 dd effffff9ec pushl _subtest ! 826: 820 00027F5C fe 08 ef0000065f callf $8,_pipe3_er_hlt ! 827: 821 00027F63 # if ( loop_on_err ) { ! 828: 822 00027F63 L310: ! 829: 823 00027F63 5d effffff9df tstl _loop_on_err ! 830: 824 00027F69 31 0a jeql L311 ! 831: 825 00027F6B # force_loop = TRUE; /* set the force loop flag */ ! 832: 826 00027F6B 0d 01 effffff9d6 movl $1,_force_loop ! 833: 827 00027F72 # asm("brw _pipe3_6_lp1"); /* and loop */ ! 834: 828 00027F72 13 ff7f brw _pipe3_6_lp1 ! 835: 829 00027F75 # } ! 836: 830 00027F75 # } /* end of compare error */ ! 837: 831 00027F75 L311: ! 838: 832 00027F75 # } while( index++ < max_cvlf_1_index ); ! 839: 833 00027F75 L307: ! 840: 834 00027F75 L304: ! 841: 835 00027F75 0d effffff9cd 50 movl _index,r0 ! 842: 836 00027F7C 6d effffff9c6 incl _index ! 843: 837 00027F82 1d 50 effffff9bf cmpl r0,_max_cvlf_1_index ! 844: 838 00027F89 81 03 13 ff2f jlss L305 ! 845: 839 00027F8E L303: ! 846: 840 00027F8E # } /* end of subtest 6 */ ! 847: 841 00027F8E 40 ret#2 ! 848: 842 00027F8F .set L299,0x0 ! 849: 843 00027F8F L301: ! 850: 844 00027F8F 13 ff1f jbr L302 ! 851: 845 00027F92 .data ! 852: 846 00000ce8 * .text ! 853: 847 00027F92 .align 1 ! 854: 848 00027F92 .globl _pipe3_7 ! 855: 849 00027F92 _pipe3_7: ! 856: 850 00027F92 0000 .word L312 ! 857: 851 00027F94 # ! 858: 852 00027F94 # ! 859: 853 00027F94 # ! 860: 854 00027F94 # ! 861: 855 00027F94 # ! 862: 856 00027F94 # ! 863: 857 00027F94 # /************************************************************************ ! 864: 858 00027F94 # * ! 865: 859 00027F94 # * SUBTEST 7 ! 866: 860 00027F94 # * data in Cache, 2 NO-OPs ! 867: 861 00027F94 # * ! 868: 862 00027F94 # ************************************************************************/ ! 869: 863 00027F94 # pipe3_7() ! 870: 864 00027F94 # { ! 871: 865 00027F94 13 00e1 jbr L314 ! 872: 866 00027F97 L315: ! 873: 867 00027F97 # force_loop = FALSE; /* clear force_loop flag */ ! 874: 868 00027F97 4d effffff9ab clrl _force_loop ! 875: 869 00027F9D # index = 0; ! 876: 870 00027F9D 4d effffff9a5 clrl _index ! 877: 871 00027FA3 # do ! 878: 872 00027FA3 L318: ! 879: 873 00027FA3 # { ! 880: 874 00027FA3 # sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */ ! 881: 875 00027FA3 0d effffff99f 50 movl _index,r0 ! 882: 876 00027FAA 48 03 50 50 shll $3,r0,r0 ! 883: 877 00027FAE 0d e000000000 effffff98f movl _cvlf_1_data(r0),_sgl_value_1 ! 884: 878 00027FB9 # sgl_expected = cvlf_1_data[index].exp; /* get expected results */ ! 885: 879 00027FB9 0d effffff989 50 movl _index,r0 ! 886: 880 00027FC0 48 03 50 50 shll $3,r0,r0 ! 887: 881 00027FC4 0d e000000004 effffff979 movl _cvlf_1_data+4(r0),_sgl_expected ! 888: 882 00027FCF # sgl_value_2 = 0x40800000; /* floating '1' */ ! 889: 883 00027FCF 0d 8f40800000 effffff96e movl $1082130432,_sgl_value_2 ! 890: 884 00027FDA # /* ! 891: 885 00027FDA # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 892: 886 00027FDA # * The force loop flag is set after the first error. ! 893: 887 00027FDA # */ ! 894: 888 00027FDA # asm("_pipe3_7_lp1:"); ! 895: 889 00027FDA _pipe3_7_lp1: ! 896: 890 00027FDA # asm("cvlf _sgl_value_1"); /* load (negate) the data */ ! 897: 891 00027FDA 76 effffff968 cvlf _sgl_value_1 ! 898: 892 00027FE0 # asm("nop"); ! 899: 893 00027FE0 10 nop ! 900: 894 00027FE1 # asm("nop"); ! 901: 895 00027FE1 10 nop ! 902: 896 00027FE2 # asm("stf _sgl_st_acc"); /* store the result */ ! 903: 897 00027FE2 26 effffff960 stf _sgl_st_acc ! 904: 898 00027FE8 # asm("nop"); ! 905: 899 00027FE8 10 nop ! 906: 900 00027FE9 # asm("nop"); ! 907: 901 00027FE9 10 nop ! 908: 902 00027FEA # asm("mulf _sgl_value_2"); /* multipy by '1' (twice) */ ! 909: 903 00027FEA e6 effffff958 mulf _sgl_value_2 ! 910: 904 00027FF0 # asm("nop"); ! 911: 905 00027FF0 10 nop ! 912: 906 00027FF1 # asm("nop"); ! 913: 907 00027FF1 10 nop ! 914: 908 00027FF2 # asm("stf _sgl_value_6"); /* store the result */ ! 915: 909 00027FF2 26 effffff950 stf _sgl_value_6 ! 916: 910 00027FF8 # if( force_loop ) ! 917: 911 00027FF8 5d effffff94a tstl _force_loop ! 918: 912 00027FFE 31 02 jeql L319 ! 919: 913 00028000 # asm("brb _pipe3_7_lp1");; /* loop on the error */ ! 920: 914 00028000 11 d8 brb _pipe3_7_lp1 ! 921: 915 00028002 L319: ! 922: 916 00028002 # /* ! 923: 917 00028002 # * verify the results ! 924: 918 00028002 # */ ! 925: 919 00028002 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */ ! 926: 920 00028002 # (sgl_value_6 != sgl_expected) ) ! 927: 921 00028002 1d effffff940 effffff93b cmpl _sgl_st_acc,_sgl_expected ! 928: 922 0002800D 21 0d jneq L9993 ! 929: 923 0002800F 1d effffff933 effffff92e cmpl _sgl_value_6,_sgl_expected ! 930: 924 0002801A 31 42 jeql L320 ! 931: 925 0002801C L9993: ! 932: 926 0002801C # { ! 933: 927 0002801C # errcnt++; /* bump the error count */ ! 934: 928 0002801C 6d effffff926 incl _errcnt ! 935: 929 00028022 # if ( prt_error ) ! 936: 930 00028022 5d effffff920 tstl _prt_error ! 937: 931 00028028 31 0d jeql L321 ! 938: 932 0002802A # print_pipe3_er("Cache Data, 2 NO-OPS"); ! 939: 933 0002802A .data 1 ! 940: 934 00000d69 * L322: ! 941: 935 00000d69 * 436163686520446174612C203 .ascii "Cache Data, 2 NO-OPS\0" ! 942: 2204E4F2D4F505300 ! 943: 936 00000d7e * .text ! 944: 937 0002802A dd 8f00000d69 pushl $L322 ! 945: 938 00028030 fe 08 ef0000047f callf $8,_print_pipe3_er ! 946: 939 00028037 # if ( halt_flg ) ! 947: 940 00028037 L321: ! 948: 941 00028037 5d effffff90b tstl _halt_flg ! 949: 942 0002803D 31 0d jeql L323 ! 950: 943 0002803F # pipe3_er_hlt( subtest ); ! 951: 944 0002803F dd effffff903 pushl _subtest ! 952: 945 00028045 fe 08 ef00000576 callf $8,_pipe3_er_hlt ! 953: 946 0002804C # if ( loop_on_err ) { ! 954: 947 0002804C L323: ! 955: 948 0002804C 5d effffff8f6 tstl _loop_on_err ! 956: 949 00028052 31 0a jeql L324 ! 957: 950 00028054 # force_loop = TRUE; /* set the force loop flag */ ! 958: 951 00028054 0d 01 effffff8ed movl $1,_force_loop ! 959: 952 0002805B # asm("brw _pipe3_7_lp1"); /* and loop */ ! 960: 953 0002805B 13 ff7c brw _pipe3_7_lp1 ! 961: 954 0002805E # } ! 962: 955 0002805E # } /* end of compare error */ ! 963: 956 0002805E L324: ! 964: 957 0002805E # } while( index++ < max_cvlf_1_index ); ! 965: 958 0002805E L320: ! 966: 959 0002805E L317: ! 967: 960 0002805E 0d effffff8e4 50 movl _index,r0 ! 968: 961 00028065 6d effffff8dd incl _index ! 969: 962 0002806B 1d 50 effffff8d6 cmpl r0,_max_cvlf_1_index ! 970: 963 00028072 81 03 13 ff2c jlss L318 ! 971: 964 00028077 L316: ! 972: 965 00028077 # } /* end of subtest 7 */ ! 973: 966 00028077 40 ret#2 ! 974: 967 00028078 .set L312,0x0 ! 975: 968 00028078 L314: ! 976: 969 00028078 13 ff1c jbr L315 ! 977: 970 0002807B .data ! 978: 971 00000ce8 * .text ! 979: 972 0002807B 00 .align 1 ! 980: 973 0002807C .globl _pipe3_8 ! 981: 974 0002807C _pipe3_8: ! 982: 975 0002807C 0000 .word L325 ! 983: 976 0002807E # ! 984: 977 0002807E # ! 985: 978 0002807E # ! 986: 979 0002807E # ! 987: 980 0002807E # ! 988: 981 0002807E # ! 989: 982 0002807E # /************************************************************************ ! 990: 983 0002807E # * ! 991: 984 0002807E # * SUBTEST 8 ! 992: 985 0002807E # * data in Cache, 3 NO-OPs ! 993: 986 0002807E # * ! 994: 987 0002807E # ************************************************************************/ ! 995: 988 0002807E # pipe3_8() ! 996: 989 0002807E # { ! 997: 990 0002807E 13 00e4 jbr L327 ! 998: 991 00028081 L328: ! 999: 992 00028081 # force_loop = FALSE; /* clear force_loop flag */ ! 1000: 993 00028081 4d effffff8c1 clrl _force_loop ! 1001: 994 00028087 # index = 0; ! 1002: 995 00028087 4d effffff8bb clrl _index ! 1003: 996 0002808D # do ! 1004: 997 0002808D L331: ! 1005: 998 0002808D # { ! 1006: 999 0002808D # sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */ ! 1007: 1000 0002808D 0d effffff8b5 50 movl _index,r0 ! 1008: 1001 00028094 48 03 50 50 shll $3,r0,r0 ! 1009: 1002 00028098 0d e000000000 effffff8a5 movl _cvlf_1_data(r0),_sgl_value_1 ! 1010: 1003 000280A3 # sgl_expected = cvlf_1_data[index].exp; /* get expected results */ ! 1011: 1004 000280A3 0d effffff89f 50 movl _index,r0 ! 1012: 1005 000280AA 48 03 50 50 shll $3,r0,r0 ! 1013: 1006 000280AE 0d e000000004 effffff88f movl _cvlf_1_data+4(r0),_sgl_expected ! 1014: 1007 000280B9 # sgl_value_2 = 0x40800000; /* floating '1' */ ! 1015: 1008 000280B9 0d 8f40800000 effffff884 movl $1082130432,_sgl_value_2 ! 1016: 1009 000280C4 # /* ! 1017: 1010 000280C4 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 1018: 1011 000280C4 # * The force loop flag is set after the first error. ! 1019: 1012 000280C4 # */ ! 1020: 1013 000280C4 # asm("_pipe3_8_lp1:"); ! 1021: 1014 000280C4 _pipe3_8_lp1: ! 1022: 1015 000280C4 # asm("cvlf _sgl_value_1"); /* load (negate) the data */ ! 1023: 1016 000280C4 76 effffff87e cvlf _sgl_value_1 ! 1024: 1017 000280CA # asm("nop"); ! 1025: 1018 000280CA 10 nop ! 1026: 1019 000280CB # asm("nop"); ! 1027: 1020 000280CB 10 nop ! 1028: 1021 000280CC # asm("nop"); ! 1029: 1022 000280CC 10 nop ! 1030: 1023 000280CD # asm("stf _sgl_st_acc"); /* store the result */ ! 1031: 1024 000280CD 26 effffff875 stf _sgl_st_acc ! 1032: 1025 000280D3 # asm("nop"); ! 1033: 1026 000280D3 10 nop ! 1034: 1027 000280D4 # asm("nop"); ! 1035: 1028 000280D4 10 nop ! 1036: 1029 000280D5 # asm("nop"); ! 1037: 1030 000280D5 10 nop ! 1038: 1031 000280D6 # asm("mulf _sgl_value_2"); /* multipy by '1' (twice) */ ! 1039: 1032 000280D6 e6 effffff86c mulf _sgl_value_2 ! 1040: 1033 000280DC # asm("nop"); ! 1041: 1034 000280DC 10 nop ! 1042: 1035 000280DD # asm("nop"); ! 1043: 1036 000280DD 10 nop ! 1044: 1037 000280DE # asm("nop"); ! 1045: 1038 000280DE 10 nop ! 1046: 1039 000280DF # asm("stf _sgl_value_6"); /* store the result */ ! 1047: 1040 000280DF 26 effffff863 stf _sgl_value_6 ! 1048: 1041 000280E5 # if( force_loop ) ! 1049: 1042 000280E5 5d effffff85d tstl _force_loop ! 1050: 1043 000280EB 31 02 jeql L332 ! 1051: 1044 000280ED # asm("brb _pipe3_8_lp1");; /* loop on the error */ ! 1052: 1045 000280ED 11 d5 brb _pipe3_8_lp1 ! 1053: 1046 000280EF L332: ! 1054: 1047 000280EF # /* ! 1055: 1048 000280EF # * verify the results ! 1056: 1049 000280EF # */ ! 1057: 1050 000280EF # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */ ! 1058: 1051 000280EF # (sgl_value_6 != sgl_expected) ) ! 1059: 1052 000280EF 1d effffff853 effffff84e cmpl _sgl_st_acc,_sgl_expected ! 1060: 1053 000280FA 21 0d jneq L9992 ! 1061: 1054 000280FC 1d effffff846 effffff841 cmpl _sgl_value_6,_sgl_expected ! 1062: 1055 00028107 31 42 jeql L333 ! 1063: 1056 00028109 L9992: ! 1064: 1057 00028109 # { ! 1065: 1058 00028109 # errcnt++; /* bump the error count */ ! 1066: 1059 00028109 6d effffff839 incl _errcnt ! 1067: 1060 0002810F # if ( prt_error ) ! 1068: 1061 0002810F 5d effffff833 tstl _prt_error ! 1069: 1062 00028115 31 0d jeql L334 ! 1070: 1063 00028117 # print_pipe3_er("Cache Data, 3 NO-OPS"); ! 1071: 1064 00028117 .data 1 ! 1072: 1065 00000d7e * L335: ! 1073: 1066 00000d7e * 436163686520446174612C203 .ascii "Cache Data, 3 NO-OPS\0" ! 1074: 3204E4F2D4F505300 ! 1075: 1067 00000d93 * .text ! 1076: 1068 00028117 dd 8f00000d7e pushl $L335 ! 1077: 1069 0002811D fe 08 ef00000392 callf $8,_print_pipe3_er ! 1078: 1070 00028124 # if ( halt_flg ) ! 1079: 1071 00028124 L334: ! 1080: 1072 00028124 5d effffff81e tstl _halt_flg ! 1081: 1073 0002812A 31 0d jeql L336 ! 1082: 1074 0002812C # pipe3_er_hlt( subtest ); ! 1083: 1075 0002812C dd effffff816 pushl _subtest ! 1084: 1076 00028132 fe 08 ef00000489 callf $8,_pipe3_er_hlt ! 1085: 1077 00028139 # if ( loop_on_err ) { ! 1086: 1078 00028139 L336: ! 1087: 1079 00028139 5d effffff809 tstl _loop_on_err ! 1088: 1080 0002813F 31 0a jeql L337 ! 1089: 1081 00028141 # force_loop = TRUE; /* set the force loop flag */ ! 1090: 1082 00028141 0d 01 effffff800 movl $1,_force_loop ! 1091: 1083 00028148 # asm("brw _pipe3_8_lp1"); /* and loop */ ! 1092: 1084 00028148 13 ff79 brw _pipe3_8_lp1 ! 1093: 1085 0002814B # } ! 1094: 1086 0002814B # } /* end of compare error */ ! 1095: 1087 0002814B L337: ! 1096: 1088 0002814B # } while( index++ < max_cvlf_1_index ); ! 1097: 1089 0002814B L333: ! 1098: 1090 0002814B L330: ! 1099: 1091 0002814B 0d effffff7f7 50 movl _index,r0 ! 1100: 1092 00028152 6d effffff7f0 incl _index ! 1101: 1093 00028158 1d 50 effffff7e9 cmpl r0,_max_cvlf_1_index ! 1102: 1094 0002815F 81 03 13 ff29 jlss L331 ! 1103: 1095 00028164 L329: ! 1104: 1096 00028164 # } /* end of subtest 8 */ ! 1105: 1097 00028164 40 ret#2 ! 1106: 1098 00028165 .set L325,0x0 ! 1107: 1099 00028165 L327: ! 1108: 1100 00028165 13 ff19 jbr L328 ! 1109: 1101 00028168 .data ! 1110: 1102 00000ce8 * .text ! 1111: 1103 00028168 .align 1 ! 1112: 1104 00028168 .globl _pipe3_9 ! 1113: 1105 00028168 _pipe3_9: ! 1114: 1106 00028168 0000 .word L338 ! 1115: 1107 0002816A # ! 1116: 1108 0002816A # ! 1117: 1109 0002816A # ! 1118: 1110 0002816A # ! 1119: 1111 0002816A # ! 1120: 1112 0002816A # ! 1121: 1113 0002816A # /***************************************************************************** ! 1122: 1114 0002816A # * ! 1123: 1115 0002816A # * SUBTEST 9 ! 1124: 1116 0002816A # * data on the stack, no NO-OPs ! 1125: 1117 0002816A # * ! 1126: 1118 0002816A # *****************************************************************************/ ! 1127: 1119 0002816A # pipe3_9() ! 1128: 1120 0002816A # { ! 1129: 1121 0002816A 13 017b jbr L340 ! 1130: 1122 0002816D L341: ! 1131: 1123 0002816D # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */ ! 1132: 1124 0002816D ed 6d effffff7d4 moval (r13),_pre_event_fp ! 1133: 1125 00028174 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */ ! 1134: 1126 00028174 ed 6e effffff7cd moval (r14),_pre_event_sp ! 1135: 1127 0002817B # force_loop = FALSE; /* clear force_loop flag */ ! 1136: 1128 0002817B 4d effffff7c7 clrl _force_loop ! 1137: 1129 00028181 # index = 0; ! 1138: 1130 00028181 4d effffff7c1 clrl _index ! 1139: 1131 00028187 # do ! 1140: 1132 00028187 L344: ! 1141: 1133 00028187 # { ! 1142: 1134 00028187 # sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */ ! 1143: 1135 00028187 0d effffff7bb 50 movl _index,r0 ! 1144: 1136 0002818E 48 03 50 50 shll $3,r0,r0 ! 1145: 1137 00028192 0d e000000000 effffff7ab movl _cvlf_1_data(r0),_sgl_value_1 ! 1146: 1138 0002819D # sgl_expected = cvlf_1_data[index].exp; /* get expected results */ ! 1147: 1139 0002819D 0d effffff7a5 50 movl _index,r0 ! 1148: 1140 000281A4 48 03 50 50 shll $3,r0,r0 ! 1149: 1141 000281A8 0d e000000004 effffff795 movl _cvlf_1_data+4(r0),_sgl_expected ! 1150: 1142 000281B3 # sgl_value_2 = 0x40800000; /* floating '1' */ ! 1151: 1143 000281B3 0d 8f40800000 effffff78a movl $1082130432,_sgl_value_2 ! 1152: 1144 000281BE # asm("moval _pointer_data,_sgl_value_4");/* init / final SP value */ ! 1153: 1145 000281BE ed effffff784 effffff77f moval _pointer_data,_sgl_value_4 ! 1154: 1146 000281C9 # /* ! 1155: 1147 000281C9 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 1156: 1148 000281C9 # * The force loop flag is set after the first error. ! 1157: 1149 000281C9 # */ ! 1158: 1150 000281C9 # asm("_pipe3_9_lp1:"); ! 1159: 1151 000281C9 _pipe3_9_lp1: ! 1160: 1152 000281C9 # asm("moval _pointer_data,r14"); /* set the stack pointer */ ! 1161: 1153 000281C9 ed effffff779 5e moval _pointer_data,r14 ! 1162: 1154 000281D0 # asm("movl _sgl_value_2,-(r14)"); /* push a floating '1' */ ! 1163: 1155 000281D0 0d effffff772 7e movl _sgl_value_2,-(r14) ! 1164: 1156 000281D7 # asm("movl _sgl_value_1,-(r14)"); /* push the operand */ ! 1165: 1157 000281D7 0d effffff76b 7e movl _sgl_value_1,-(r14) ! 1166: 1158 000281DE # /* ! 1167: 1159 000281DE # * now pop the data off the stack ! 1168: 1160 000281DE # */ ! 1169: 1161 000281DE # ! 1170: 1162 000281DE # asm("cvlf (r14)+"); /* load (negate) the data */ ! 1171: 1163 000281DE 76 8e cvlf (r14)+ ! 1172: 1164 000281E0 # asm("stf r5"); /* store the result */ ! 1173: 1165 000281E0 26 55 stf r5 ! 1174: 1166 000281E2 # asm("mulf (r14)+"); /* multipy by '1' */ ! 1175: 1167 000281E2 e6 8e mulf (r14)+ ! 1176: 1168 000281E4 # asm("stf r6"); /* store the result */ ! 1177: 1169 000281E4 26 56 stf r6 ! 1178: 1170 000281E6 # if( force_loop ) ! 1179: 1171 000281E6 5d effffff75c tstl _force_loop ! 1180: 1172 000281EC 31 02 jeql L345 ! 1181: 1173 000281EE # asm("brb _pipe3_9_lp1");; /* loop on the error */ ! 1182: 1174 000281EE 11 d9 brb _pipe3_9_lp1 ! 1183: 1175 000281F0 L345: ! 1184: 1176 000281F0 # /* ! 1185: 1177 000281F0 # * verify the results ! 1186: 1178 000281F0 # */ ! 1187: 1179 000281F0 # asm("movl r5,_sgl_st_acc"); /* get the 1st store value */ ! 1188: 1180 000281F0 0d 55 effffff751 movl r5,_sgl_st_acc ! 1189: 1181 000281F7 # asm("movl r6,_sgl_value_6"); /* get the 2nd store value */ ! 1190: 1182 000281F7 0d 56 effffff74a movl r6,_sgl_value_6 ! 1191: 1183 000281FE # asm("moval (r14),_sgl_value_5"); /* save the stack pointer */ ! 1192: 1184 000281FE ed 6e effffff743 moval (r14),_sgl_value_5 ! 1193: 1185 00028205 # if( (sgl_st_acc != sgl_expected) || /* verify the results... */ ! 1194: 1186 00028205 # (sgl_value_6 != sgl_expected) || ! 1195: 1187 00028205 # (sgl_value_5 != sgl_value_4) ) /* ... and the final SP */ ! 1196: 1188 00028205 1d effffff73d effffff738 cmpl _sgl_st_acc,_sgl_expected ! 1197: 1189 00028210 21 1d jneq L9991 ! 1198: 1190 00028212 1d effffff730 effffff72b cmpl _sgl_value_6,_sgl_expected ! 1199: 1191 0002821D 21 10 jneq L9991 ! 1200: 1192 0002821F 1d effffff723 effffff71e cmpl _sgl_value_5,_sgl_value_4 ! 1201: 1193 0002822A 21 03 13 0091 jeql L346 ! 1202: 1194 0002822F L9991: ! 1203: 1195 0002822F # { ! 1204: 1196 0002822F # asm("movl _pre_event_fp,r13"); /* restore frame pointer */ ! 1205: 1197 0002822F 0d effffff713 5d movl _pre_event_fp,r13 ! 1206: 1198 00028236 # asm("movl _pre_event_sp,r14"); /* restore stack pointer */ ! 1207: 1199 00028236 0d effffff70c 5e movl _pre_event_sp,r14 ! 1208: 1200 0002823D # errcnt++; /* bump the error count */ ! 1209: 1201 0002823D 6d effffff705 incl _errcnt ! 1210: 1202 00028243 # if ( prt_error ) { ! 1211: 1203 00028243 5d effffff6ff tstl _prt_error ! 1212: 1204 00028249 31 4e jeql L347 ! 1213: 1205 0002824B # print_pipe3_er("Pop data from the STACK"); ! 1214: 1206 0002824B .data 1 ! 1215: 1207 00000d93 * L348: ! 1216: 1208 00000d93 * 506F7020646174612066726F6 .ascii "Pop data from the STACK\0" ! 1217: D2074686520535441434B00 ! 1218: 1209 00000dab * .text ! 1219: 1210 0002824B dd 8f00000d93 pushl $L348 ! 1220: 1211 00028251 fe 08 ef0000025e callf $8,_print_pipe3_er ! 1221: 1212 00028258 # writes("final Stack Pointer = "); ! 1222: 1213 00028258 .data 1 ! 1223: 1214 00000dab * L349: ! 1224: 1215 00000dab * 66696E616C20537461636B205 .ascii "final Stack Pointer = \0" ! 1225: 06F696E746572203D2000 ! 1226: 1216 00000dc2 * .text ! 1227: 1217 00028258 dd 8f00000dab pushl $L349 ! 1228: 1218 0002825E fe 08 effffff6e3 callf $8,_writes ! 1229: 1219 00028265 # write32h( sgl_value_5 ); ! 1230: 1220 00028265 dd effffff6dd pushl _sgl_value_5 ! 1231: 1221 0002826B fe 08 effffff6d6 callf $8,_write32h ! 1232: 1222 00028272 # writes(", expected = "); ! 1233: 1223 00028272 .data 1 ! 1234: 1224 00000dc2 * L351: ! 1235: 1225 00000dc2 * 2C20206578706563746564203 .ascii ", expected = \0" ! 1236: D2000 ! 1237: 1226 00000dd1 * .text ! 1238: 1227 00028272 dd 8f00000dc2 pushl $L351 ! 1239: 1228 00028278 fe 08 effffff6c9 callf $8,_writes ! 1240: 1229 0002827F # write32h( sgl_value_4 ); ! 1241: 1230 0002827F dd effffff6c3 pushl _sgl_value_4 ! 1242: 1231 00028285 fe 08 effffff6bc callf $8,_write32h ! 1243: 1232 0002828C # writes(" \n"); ! 1244: 1233 0002828C .data 1 ! 1245: 1234 00000dd1 * L352: ! 1246: 1235 00000dd1 * 200A00 .ascii " \12\0" ! 1247: 1236 00000dd4 * .text ! 1248: 1237 0002828C dd 8f00000dd1 pushl $L352 ! 1249: 1238 00028292 fe 08 effffff6af callf $8,_writes ! 1250: 1239 00028299 # } ! 1251: 1240 00028299 # if ( halt_flg ) ! 1252: 1241 00028299 L347: ! 1253: 1242 00028299 5d effffff6a9 tstl _halt_flg ! 1254: 1243 0002829F 31 0d jeql L353 ! 1255: 1244 000282A1 # pipe3_er_hlt( subtest ); ! 1256: 1245 000282A1 dd effffff6a1 pushl _subtest ! 1257: 1246 000282A7 fe 08 ef00000314 callf $8,_pipe3_er_hlt ! 1258: 1247 000282AE # if ( loop_on_err ) { ! 1259: 1248 000282AE L353: ! 1260: 1249 000282AE 5d effffff694 tstl _loop_on_err ! 1261: 1250 000282B4 31 0a jeql L354 ! 1262: 1251 000282B6 # force_loop = TRUE; /* set the force loop flag */ ! 1263: 1252 000282B6 0d 01 effffff68b movl $1,_force_loop ! 1264: 1253 000282BD # asm("brw _pipe3_9_lp1"); /* and loop */ ! 1265: 1254 000282BD 13 ff09 brw _pipe3_9_lp1 ! 1266: 1255 000282C0 # } ! 1267: 1256 000282C0 # } /* end of compare error */ ! 1268: 1257 000282C0 L354: ! 1269: 1258 000282C0 # } while( index++ < max_cvlf_1_index ); ! 1270: 1259 000282C0 L346: ! 1271: 1260 000282C0 L343: ! 1272: 1261 000282C0 0d effffff682 50 movl _index,r0 ! 1273: 1262 000282C7 6d effffff67b incl _index ! 1274: 1263 000282CD 1d 50 effffff674 cmpl r0,_max_cvlf_1_index ! 1275: 1264 000282D4 81 03 13 feae jlss L344 ! 1276: 1265 000282D9 L342: ! 1277: 1266 000282D9 # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */ ! 1278: 1267 000282D9 0d effffff669 5d movl _pre_event_fp,r13 ! 1279: 1268 000282E0 # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */ ! 1280: 1269 000282E0 0d effffff662 5e movl _pre_event_sp,r14 ! 1281: 1270 000282E7 # } /* end of subtest 9 */ ! 1282: 1271 000282E7 40 ret#2 ! 1283: 1272 000282E8 .set L338,0x0 ! 1284: 1273 000282E8 L340: ! 1285: 1274 000282E8 13 fe82 jbr L341 ! 1286: 1275 000282EB .data ! 1287: 1276 00000ce8 * .text ! 1288: 1277 000282EB 00 .align 1 ! 1289: 1278 000282EC .globl _pipe3_10 ! 1290: 1279 000282EC _pipe3_10: ! 1291: 1280 000282EC 0000 .word L355 ! 1292: 1281 000282EE # ! 1293: 1282 000282EE # ! 1294: 1283 000282EE # ! 1295: 1284 000282EE # ! 1296: 1285 000282EE # ! 1297: 1286 000282EE # ! 1298: 1287 000282EE # /****************************************************************************** ! 1299: 1288 000282EE # * ! 1300: 1289 000282EE # * SUBTEST 10 ! 1301: 1290 000282EE # * get data via indexed FRAME pointer ! 1302: 1291 000282EE # * ! 1303: 1292 000282EE # * ADDR INDEX DATA ! 1304: 1293 000282EE # * pointer_data 4 <the 1st STF result goes here> ! 1305: 1294 000282EE # * pointer_data-4 3 <the 2nd STF result goes here> ! 1306: 1295 000282EE # * pointer_data-8 2 <operand data> ! 1307: 1296 000282EE # * pointer_data-12 1 <floating '1'> ! 1308: 1297 000282EE # * pointer_data-16 0 point the frame pointer here ! 1309: 1298 000282EE # * ! 1310: 1299 000282EE # ******************************************************************************/ ! 1311: 1300 000282EE # pipe3_10() ! 1312: 1301 000282EE # { ! 1313: 1302 000282EE 13 01c2 jbr L357 ! 1314: 1303 000282F1 L358: ! 1315: 1304 000282F1 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */ ! 1316: 1305 000282F1 ed 6d effffff650 moval (r13),_pre_event_fp ! 1317: 1306 000282F8 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */ ! 1318: 1307 000282F8 ed 6e effffff649 moval (r14),_pre_event_sp ! 1319: 1308 000282FF # force_loop = FALSE; /* clear force_loop flag */ ! 1320: 1309 000282FF 4d effffff643 clrl _force_loop ! 1321: 1310 00028305 # index = 0; ! 1322: 1311 00028305 4d effffff63d clrl _index ! 1323: 1312 0002830B # do ! 1324: 1313 0002830B L361: ! 1325: 1314 0002830B # { ! 1326: 1315 0002830B # sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */ ! 1327: 1316 0002830B 0d effffff637 50 movl _index,r0 ! 1328: 1317 00028312 48 03 50 50 shll $3,r0,r0 ! 1329: 1318 00028316 0d e000000000 effffff627 movl _cvlf_1_data(r0),_sgl_value_1 ! 1330: 1319 00028321 # sgl_expected = cvlf_1_data[index].exp; /* get expected results */ ! 1331: 1320 00028321 0d effffff621 50 movl _index,r0 ! 1332: 1321 00028328 48 03 50 50 shll $3,r0,r0 ! 1333: 1322 0002832C 0d e000000004 effffff611 movl _cvlf_1_data+4(r0),_sgl_expected ! 1334: 1323 00028337 # sgl_value_2 = 0x40800000; /* floating '1' */ ! 1335: 1324 00028337 0d 8f40800000 effffff606 movl $1082130432,_sgl_value_2 ! 1336: 1325 00028342 # asm("moval _pointer_data,_sgl_value_4");/* get store data's addr */ ! 1337: 1326 00028342 ed effffff600 effffff5fb moval _pointer_data,_sgl_value_4 ! 1338: 1327 0002834D # sgl_value_4 -= 8; /* decrement it by 8 (bytes)*/ ! 1339: 1328 0002834D 2c 08 effffff5f4 subl2 $8,_sgl_value_4 ! 1340: 1329 00028354 # asm("movl _sgl_value_1,*_sgl_value_4"); /* set the operand data */ ! 1341: 1330 00028354 0d effffff5ee fffffff5e9 movl _sgl_value_1,*_sgl_value_4 ! 1342: 1331 0002835F # sgl_value_4 -= 4; /* decrement it by 4 (bytes)*/ ! 1343: 1332 0002835F 2c 04 effffff5e2 subl2 $4,_sgl_value_4 ! 1344: 1333 00028366 # asm("movl _sgl_value_2,*_sgl_value_4"); /* set the floating '1' */ ! 1345: 1334 00028366 0d effffff5dc fffffff5d7 movl _sgl_value_2,*_sgl_value_4 ! 1346: 1335 00028371 # sgl_value_4 -= 4; /* get FRAME PTR address */ ! 1347: 1336 00028371 2c 04 effffff5d0 subl2 $4,_sgl_value_4 ! 1348: 1337 00028378 # /* ! 1349: 1338 00028378 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 1350: 1339 00028378 # * The force loop flag is set after the first error. ! 1351: 1340 00028378 # */ ! 1352: 1341 00028378 # asm("_pipe3_10_lp1:"); ! 1353: 1342 00028378 _pipe3_10_lp1: ! 1354: 1343 00028378 # asm("movl _sgl_value_4,r13"); /* set the FRAME POINTER */ ! 1355: 1344 00028378 0d effffff5ca 5d movl _sgl_value_4,r13 ! 1356: 1345 0002837F # asm("movl $1,r1"); /* r1 index = 1 longwords */ ! 1357: 1346 0002837F 0d 01 51 movl $1,r1 ! 1358: 1347 00028382 # asm("movl $2,r2"); /* r2 index = 2 longwords */ ! 1359: 1348 00028382 0d 02 52 movl $2,r2 ! 1360: 1349 00028385 # asm("movl $3,r3"); /* r3 index = 3 longwords */ ! 1361: 1350 00028385 0d 03 53 movl $3,r3 ! 1362: 1351 00028388 # asm("movl $4,r4"); /* r4 index = 4 longwords */ ! 1363: 1352 00028388 0d 04 54 movl $4,r4 ! 1364: 1353 0002838B # asm("cvlf (r13)[r2]"); /* load the op (indx = 2) */ ! 1365: 1354 0002838B 76 426d cvlf (r13)[r2] ! 1366: 1355 0002838E # asm("stf (r13)[r4]"); /* store -indexed by r4 */ ! 1367: 1356 0002838E 26 446d stf (r13)[r4] ! 1368: 1357 00028391 # asm("mulf (r13)[r1]"); /* multiply by '1' (indx=1) */ ! 1369: 1358 00028391 e6 416d mulf (r13)[r1] ! 1370: 1359 00028394 # asm("stf (r13)[r3]"); /* store -indexed by r3 */ ! 1371: 1360 00028394 26 436d stf (r13)[r3] ! 1372: 1361 00028397 # if( force_loop ) ! 1373: 1362 00028397 5d effffff5ab tstl _force_loop ! 1374: 1363 0002839D 31 02 jeql L362 ! 1375: 1364 0002839F # asm("brb _pipe3_10_lp1");; /* loop on the error */ ! 1376: 1365 0002839F 11 d7 brb _pipe3_10_lp1 ! 1377: 1366 000283A1 L362: ! 1378: 1367 000283A1 # /* ! 1379: 1368 000283A1 # * verify the results ! 1380: 1369 000283A1 # */ ! 1381: 1370 000283A1 # sgl_st_acc = pointer_data; /* save 1st stored value */ ! 1382: 1371 000283A1 0d effffff5a1 effffff59c movl _pointer_data,_sgl_st_acc ! 1383: 1372 000283AC # asm("moval _pointer_data,_sgl_value_5"); /* get addr of 1st stf */ ! 1384: 1373 000283AC ed effffff596 effffff591 moval _pointer_data,_sgl_value_5 ! 1385: 1374 000283B7 # sgl_value_5 -= 4; /* decrement by 4 (bytes) */ ! 1386: 1375 000283B7 2c 04 effffff58a subl2 $4,_sgl_value_5 ! 1387: 1376 000283BE # asm("movl *_sgl_value_5,_sgl_value_6"); /* save 2nd store value */ ! 1388: 1377 000283BE 0d fffffff584 effffff57f movl *_sgl_value_5,_sgl_value_6 ! 1389: 1378 000283C9 # asm("moval (r13),_sgl_value_5"); /* save the frame pointer */ ! 1390: 1379 000283C9 ed 6d effffff578 moval (r13),_sgl_value_5 ! 1391: 1380 000283D0 # if( (sgl_st_acc != sgl_expected) || /* verify the results... */ ! 1392: 1381 000283D0 # (sgl_value_6 != sgl_expected) || ! 1393: 1382 000283D0 # (sgl_value_5 != sgl_value_4) ) /* ... and the final FP */ ! 1394: 1383 000283D0 1d effffff572 effffff56d cmpl _sgl_st_acc,_sgl_expected ! 1395: 1384 000283DB 21 1d jneq L9990 ! 1396: 1385 000283DD 1d effffff565 effffff560 cmpl _sgl_value_6,_sgl_expected ! 1397: 1386 000283E8 21 10 jneq L9990 ! 1398: 1387 000283EA 1d effffff558 effffff553 cmpl _sgl_value_5,_sgl_value_4 ! 1399: 1388 000283F5 21 03 13 0091 jeql L363 ! 1400: 1389 000283FA L9990: ! 1401: 1390 000283FA # { ! 1402: 1391 000283FA # asm("movl _pre_event_fp,r13"); /* restore frame pointer */ ! 1403: 1392 000283FA 0d effffff548 5d movl _pre_event_fp,r13 ! 1404: 1393 00028401 # asm("movl _pre_event_sp,r14"); /* restore stack pointer */ ! 1405: 1394 00028401 0d effffff541 5e movl _pre_event_sp,r14 ! 1406: 1395 00028408 # errcnt++; /* bump the error count */ ! 1407: 1396 00028408 6d effffff53a incl _errcnt ! 1408: 1397 0002840E # if ( prt_error ) { ! 1409: 1398 0002840E 5d effffff534 tstl _prt_error ! 1410: 1399 00028414 31 4e jeql L364 ! 1411: 1400 00028416 # print_pipe3_er("indexed FP addressing"); ! 1412: 1401 00028416 .data 1 ! 1413: 1402 00000dd4 * L365: ! 1414: 1403 00000dd4 * 696E646578656420465020616 .ascii "indexed FP addressing\0" ! 1415: 46472657373696E6700 ! 1416: 1404 00000dea * .text ! 1417: 1405 00028416 dd 8f00000dd4 pushl $L365 ! 1418: 1406 0002841C fe 08 ef00000093 callf $8,_print_pipe3_er ! 1419: 1407 00028423 # writes("final Frame Pointer = "); ! 1420: 1408 00028423 .data 1 ! 1421: 1409 00000dea * L366: ! 1422: 1410 00000dea * 66696E616C204672616D65205 .ascii "final Frame Pointer = \0" ! 1423: 06F696E746572203D2000 ! 1424: 1411 00000e01 * .text ! 1425: 1412 00028423 dd 8f00000dea pushl $L366 ! 1426: 1413 00028429 fe 08 effffff518 callf $8,_writes ! 1427: 1414 00028430 # writeh( sgl_value_5 ); ! 1428: 1415 00028430 dd effffff512 pushl _sgl_value_5 ! 1429: 1416 00028436 fe 08 effffff50b callf $8,_writeh ! 1430: 1417 0002843D # writes(", expected FP = "); ! 1431: 1418 0002843D .data 1 ! 1432: 1419 00000e01 * L368: ! 1433: 1420 00000e01 * 2C20206578706563746564204 .ascii ", expected FP = \0" ! 1434: 650203D2000 ! 1435: 1421 00000e13 * .text ! 1436: 1422 0002843D dd 8f00000e01 pushl $L368 ! 1437: 1423 00028443 fe 08 effffff4fe callf $8,_writes ! 1438: 1424 0002844A # writeh( sgl_value_4 ); ! 1439: 1425 0002844A dd effffff4f8 pushl _sgl_value_4 ! 1440: 1426 00028450 fe 08 effffff4f1 callf $8,_writeh ! 1441: 1427 00028457 # writes(" \n"); ! 1442: 1428 00028457 .data 1 ! 1443: 1429 00000e13 * L369: ! 1444: 1430 00000e13 * 200A00 .ascii " \12\0" ! 1445: 1431 00000e16 * .text ! 1446: 1432 00028457 dd 8f00000e13 pushl $L369 ! 1447: 1433 0002845D fe 08 effffff4e4 callf $8,_writes ! 1448: 1434 00028464 # } ! 1449: 1435 00028464 # if ( halt_flg ) ! 1450: 1436 00028464 L364: ! 1451: 1437 00028464 5d effffff4de tstl _halt_flg ! 1452: 1438 0002846A 31 0d jeql L370 ! 1453: 1439 0002846C # pipe3_er_hlt( subtest ); ! 1454: 1440 0002846C dd effffff4d6 pushl _subtest ! 1455: 1441 00028472 fe 08 ef00000149 callf $8,_pipe3_er_hlt ! 1456: 1442 00028479 # if ( loop_on_err ) { ! 1457: 1443 00028479 L370: ! 1458: 1444 00028479 5d effffff4c9 tstl _loop_on_err ! 1459: 1445 0002847F 31 0a jeql L371 ! 1460: 1446 00028481 # force_loop = TRUE; /* set the force loop flag */ ! 1461: 1447 00028481 0d 01 effffff4c0 movl $1,_force_loop ! 1462: 1448 00028488 # asm("brw _pipe3_10_lp1"); /* and loop */ ! 1463: 1449 00028488 13 feed brw _pipe3_10_lp1 ! 1464: 1450 0002848B # } ! 1465: 1451 0002848B # } /* end of compare error */ ! 1466: 1452 0002848B L371: ! 1467: 1453 0002848B # } while( index++ < max_cvlf_1_index ); ! 1468: 1454 0002848B L363: ! 1469: 1455 0002848B L360: ! 1470: 1456 0002848B 0d effffff4b7 50 movl _index,r0 ! 1471: 1457 00028492 6d effffff4b0 incl _index ! 1472: 1458 00028498 1d 50 effffff4a9 cmpl r0,_max_cvlf_1_index ! 1473: 1459 0002849F 81 03 13 fe67 jlss L361 ! 1474: 1460 000284A4 L359: ! 1475: 1461 000284A4 # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */ ! 1476: 1462 000284A4 0d effffff49e 5d movl _pre_event_fp,r13 ! 1477: 1463 000284AB # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */ ! 1478: 1464 000284AB 0d effffff497 5e movl _pre_event_sp,r14 ! 1479: 1465 000284B2 # } /* end of subtest 10 */ ! 1480: 1466 000284B2 40 ret#2 ! 1481: 1467 000284B3 .set L355,0x0 ! 1482: 1468 000284B3 L357: ! 1483: 1469 000284B3 13 fe3b jbr L358 ! 1484: 1470 000284B6 .data ! 1485: 1471 00000ce8 * .text ! 1486: 1472 000284B6 .align 1 ! 1487: 1473 000284B6 .globl _print_pipe3_er ! 1488: 1474 000284B6 _print_pipe3_er: ! 1489: 1475 000284B6 0000 .word L372 ! 1490: 1476 000284B8 # ! 1491: 1477 000284B8 # ! 1492: 1478 000284B8 # /****************************************************************************** ! 1493: 1479 000284B8 # * ! 1494: 1480 000284B8 # * ! 1495: 1481 000284B8 # * print an error in the following form ! 1496: 1482 000284B8 # * ! 1497: 1483 000284B8 # * operand = xxxxxxxx, final Acc = xxxxxxxx, data index = dd ! 1498: 1484 000284B8 # * expected Acc = xxxxxxxx ! 1499: 1485 000284B8 # * ! 1500: 1486 000284B8 # ******************************************************************************/ ! 1501: 1487 000284B8 # print_pipe3_er(msg) ! 1502: 1488 000284B8 # char *msg; ! 1503: 1489 000284B8 # { ! 1504: 1490 000284B8 13 0103 jbr L374 ! 1505: 1491 000284BB L375: ! 1506: 1492 000284BB # writes(" \n"); /* start a new print line */ ! 1507: 1493 000284BB .data 1 ! 1508: 1494 00000e16 * L376: ! 1509: 1495 00000e16 * 200A00 .ascii " \12\0" ! 1510: 1496 00000e19 * .text ! 1511: 1497 000284BB dd 8f00000e16 pushl $L376 ! 1512: 1498 000284C1 fe 08 effffff480 callf $8,_writes ! 1513: 1499 000284C8 # writes("cycle: "); ! 1514: 1500 000284C8 .data 1 ! 1515: 1501 00000e19 * L377: ! 1516: 1502 00000e19 * 6379636C653A2000 .ascii "cycle: \0" ! 1517: 1503 00000e21 * .text ! 1518: 1504 000284C8 dd 8f00000e19 pushl $L377 ! 1519: 1505 000284CE fe 08 effffff473 callf $8,_writes ! 1520: 1506 000284D5 # writed( cycle ); ! 1521: 1507 000284D5 dd effffff46d pushl _cycle ! 1522: 1508 000284DB fe 08 effffff466 callf $8,_writed ! 1523: 1509 000284E2 # writes(" test "); ! 1524: 1510 000284E2 .data 1 ! 1525: 1511 00000e21 * L379: ! 1526: 1512 00000e21 * 20746573742000 .ascii " test \0" ! 1527: 1513 00000e28 * .text ! 1528: 1514 000284E2 dd 8f00000e21 pushl $L379 ! 1529: 1515 000284E8 fe 08 effffff459 callf $8,_writes ! 1530: 1516 000284EF # writed( test_no ); ! 1531: 1517 000284EF dd effffff453 pushl _test_no ! 1532: 1518 000284F5 fe 08 effffff44c callf $8,_writed ! 1533: 1519 000284FC # writes(" (Pipe 3), subtest "); ! 1534: 1520 000284FC .data 1 ! 1535: 1521 00000e28 * L380: ! 1536: 1522 00000e28 * 202028506970652033292C207 .ascii " (Pipe 3), subtest \0" ! 1537: 37562746573742000 ! 1538: 1523 00000e3d * .text ! 1539: 1524 000284FC dd 8f00000e28 pushl $L380 ! 1540: 1525 00028502 fe 08 effffff43f callf $8,_writes ! 1541: 1526 00028509 # writed( subtest ); ! 1542: 1527 00028509 dd effffff439 pushl _subtest ! 1543: 1528 0002850F fe 08 effffff432 callf $8,_writed ! 1544: 1529 00028516 # writes(" error - "); ! 1545: 1530 00028516 .data 1 ! 1546: 1531 00000e3d * L381: ! 1547: 1532 00000e3d * 206572726F72202D2000 .ascii " error - \0" ! 1548: 1533 00000e47 * .text ! 1549: 1534 00028516 dd 8f00000e3d pushl $L381 ! 1550: 1535 0002851C fe 08 effffff425 callf $8,_writes ! 1551: 1536 00028523 # writes( msg ); ! 1552: 1537 00028523 dd ad04 pushl 4(fp) ! 1553: 1538 00028526 fe 08 effffff41b callf $8,_writes ! 1554: 1539 0002852D # writec('\n'); ! 1555: 1540 0002852D dd 0a pushl $10 ! 1556: 1541 0002852F fe 08 effffff412 callf $8,_writec ! 1557: 1542 00028536 # writes(" CVLF(op), STF, MULF(1.0), STF\n"); ! 1558: 1543 00028536 .data 1 ! 1559: 1544 00000e47 * L383: ! 1560: 1545 00000e47 * 2043564C46286F70292C20535 .ascii " CVLF(op), STF, MULF(1.0), STF\12\0" ! 1561: 4462C204D554C4628312E3029 ! 1562: 2C205354460A00 ! 1563: 1546 00000e67 * .text ! 1564: 1547 00028536 dd 8f00000e47 pushl $L383 ! 1565: 1548 0002853C fe 08 effffff405 callf $8,_writes ! 1566: 1549 00028543 # writes("operand = "); ! 1567: 1550 00028543 .data 1 ! 1568: 1551 00000e67 * L384: ! 1569: 1552 00000e67 * 6F706572616E64203D2000 .ascii "operand = \0" ! 1570: 1553 00000e72 * .text ! 1571: 1554 00028543 dd 8f00000e67 pushl $L384 ! 1572: 1555 00028549 fe 08 effffff3f8 callf $8,_writes ! 1573: 1556 00028550 # write32h( sgl_value_1 ); ! 1574: 1557 00028550 dd effffff3f2 pushl _sgl_value_1 ! 1575: 1558 00028556 fe 08 effffff3eb callf $8,_write32h ! 1576: 1559 0002855D # writes(", final Acc = "); ! 1577: 1560 0002855D .data 1 ! 1578: 1561 00000e72 * L385: ! 1579: 1562 00000e72 * 2C20202066696E616C2041636 .ascii ", final Acc = \0" ! 1580: 3203D2000 ! 1581: 1563 00000e83 * .text ! 1582: 1564 0002855D dd 8f00000e72 pushl $L385 ! 1583: 1565 00028563 fe 08 effffff3de callf $8,_writes ! 1584: 1566 0002856A # write32h( sgl_st_acc ); ! 1585: 1567 0002856A dd effffff3d8 pushl _sgl_st_acc ! 1586: 1568 00028570 fe 08 effffff3d1 callf $8,_write32h ! 1587: 1569 00028577 # writes(", data index = "); ! 1588: 1570 00028577 .data 1 ! 1589: 1571 00000e83 * L386: ! 1590: 1572 00000e83 * 2C2020206461746120696E646 .ascii ", data index = \0" ! 1591: 578203D2000 ! 1592: 1573 00000e95 * .text ! 1593: 1574 00028577 dd 8f00000e83 pushl $L386 ! 1594: 1575 0002857D fe 08 effffff3c4 callf $8,_writes ! 1595: 1576 00028584 # writed( index ); ! 1596: 1577 00028584 dd effffff3be pushl _index ! 1597: 1578 0002858A fe 08 effffff3b7 callf $8,_writed ! 1598: 1579 00028591 # writec('\n'); ! 1599: 1580 00028591 dd 0a pushl $10 ! 1600: 1581 00028593 fe 08 effffff3ae callf $8,_writec ! 1601: 1582 0002859A # writes(" expected Acc = "); ! 1602: 1583 0002859A .data 1 ! 1603: 1584 00000e95 * L387: ! 1604: 1585 00000e95 * 2020202020202020202020202 .ascii " expected Acc = \0" ! 1605: 0202020202020657870656374 ! 1606: 656420416363203D2000 ! 1607: 1586 00000eb8 * .text ! 1608: 1587 0002859A dd 8f00000e95 pushl $L387 ! 1609: 1588 000285A0 fe 08 effffff3a1 callf $8,_writes ! 1610: 1589 000285A7 # write32h( sgl_expected ); ! 1611: 1590 000285A7 dd effffff39b pushl _sgl_expected ! 1612: 1591 000285AD fe 08 effffff394 callf $8,_write32h ! 1613: 1592 000285B4 # writec('\n'); ! 1614: 1593 000285B4 dd 0a pushl $10 ! 1615: 1594 000285B6 fe 08 effffff38b callf $8,_writec ! 1616: 1595 000285BD # } ! 1617: 1596 000285BD 40 ret#2 ! 1618: 1597 000285BE .set L372,0x0 ! 1619: 1598 000285BE L374: ! 1620: 1599 000285BE 13 fefa jbr L375 ! 1621: 1600 000285C1 .data ! 1622: 1601 00000ce8 * .text ! 1623: 1602 000285C1 00 .align 1 ! 1624: 1603 000285C2 .globl _pipe3_er_hlt ! 1625: 1604 000285C2 _pipe3_er_hlt: ! 1626: 1605 000285C2 0000 .word L388 ! 1627: 1606 000285C4 # ! 1628: 1607 000285C4 # ! 1629: 1608 000285C4 # ! 1630: 1609 000285C4 # ! 1631: 1610 000285C4 # ! 1632: 1611 000285C4 # /****************************************************************************** ! 1633: 1612 000285C4 # * ! 1634: 1613 000285C4 # * HALT ON ERROR ROUTINE ! 1635: 1614 000285C4 # * ! 1636: 1615 000285C4 # * halt with the necessary information saved in the registers ! 1637: 1616 000285C4 # * ! 1638: 1617 000285C4 # ******************************************************************************/ ! 1639: 1618 000285C4 # pipe3_er_hlt( subtest ) ! 1640: 1619 000285C4 # int subtest; ! 1641: 1620 000285C4 # { ! 1642: 1621 000285C4 11 67 jbr L390 ! 1643: 1622 000285C6 L391: ! 1644: 1623 000285C6 # asm("movl _test_no,r0"); /* r0 = test number */ ! 1645: 1624 000285C6 0d effffff37c 50 movl _test_no,r0 ! 1646: 1625 000285CD # asm("movl _subtest,r1"); /* r1 = subtest number */ ! 1647: 1626 000285CD 0d effffff375 51 movl _subtest,r1 ! 1648: 1627 000285D4 # asm("movl $1,r2"); /* r2 = error code */ ! 1649: 1628 000285D4 0d 01 52 movl $1,r2 ! 1650: 1629 000285D7 # asm("movl _cycle,r3"); /* r3 = cycle count */ ! 1651: 1630 000285D7 0d effffff36b 53 movl _cycle,r3 ! 1652: 1631 000285DE # asm("movl _sgl_value_1,r4"); /* r4 = sgl operand */ ! 1653: 1632 000285DE 0d effffff364 54 movl _sgl_value_1,r4 ! 1654: 1633 000285E5 # asm("movl _sgl_st_acc,r5"); /* r5 = sgl stored */ ! 1655: 1634 000285E5 0d effffff35d 55 movl _sgl_st_acc,r5 ! 1656: 1635 000285EC # asm("movl _sgl_expected,r6"); /* r6 = sgl expected */ ! 1657: 1636 000285EC 0d effffff356 56 movl _sgl_expected,r6 ! 1658: 1637 000285F3 # asm("movl _index,r7"); /* r7 = data index */ ! 1659: 1638 000285F3 0d effffff34f 57 movl _index,r7 ! 1660: 1639 000285FA # asm("movl _sgl_value_2,r8"); /* r8 = floating one */ ! 1661: 1640 000285FA 0d effffff348 58 movl _sgl_value_2,r8 ! 1662: 1641 00028601 # if( subtest == 9 ) { ! 1663: 1642 00028601 1d ad04 09 cmpl 4(fp),$9 ! 1664: 1643 00028605 21 10 jneq L392 ! 1665: 1644 00028607 # asm("movl _sgl_value_5,r9"); /* r9 = final SP value */ ! 1666: 1645 00028607 0d effffff33b 59 movl _sgl_value_5,r9 ! 1667: 1646 0002860E # asm("movl _sgl_value_4,r10"); /* r10= expected SP value */ ! 1668: 1647 0002860E 0d effffff334 5a movl _sgl_value_4,r10 ! 1669: 1648 00028615 # } else ! 1670: 1649 00028615 11 14 jbr L393 ! 1671: 1650 00028617 L392: ! 1672: 1651 00028617 # if( subtest == 10 ) { ! 1673: 1652 00028617 1d ad04 0a cmpl 4(fp),$10 ! 1674: 1653 0002861B 21 0e jneq L394 ! 1675: 1654 0002861D # asm("movl _sgl_value_5,r9"); /* r9 = final FP value */ ! 1676: 1655 0002861D 0d effffff325 59 movl _sgl_value_5,r9 ! 1677: 1656 00028624 # asm("movl _sgl_value_4,r10"); /* r10= expected FP value */ ! 1678: 1657 00028624 0d effffff31e 5a movl _sgl_value_4,r10 ! 1679: 1658 0002862B # }; ! 1680: 1659 0002862B L394: ! 1681: 1660 0002862B L393: ! 1682: 1661 0002862B # asm(".globl _pipe3_1_hlt"); ! 1683: 1662 0002862B .globl _pipe3_1_hlt ! 1684: 1663 0002862B # asm("_pipe3_1_hlt:"); /* PC after the halt */ ! 1685: 1664 0002862B _pipe3_1_hlt: ! 1686: 1665 0002862B # asm("halt"); /* HALT ... */ ! 1687: 1666 0002862B 00 halt ! 1688: 1667 0002862C # } /* end of halt on error */ ! 1689: 1668 0002862C 40 ret#2 ! 1690: 1669 0002862D .set L388,0x0 ! 1691: 1670 0002862D L390: ! 1692: 1671 0002862D 11 97 jbr L391 ! 1693: 1672 0002862F .data ! 1694: 1672 0004FF77 .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.