![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe17.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 pipe17.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 00000d20 * .text ! 4: 4 00000000 .align 1 ! 5: 5 00000000 .globl _pipe_17 ! 6: 6 00000000 _pipe_17: ! 7: 7 00031D64 0000 .word L215 ! 8: 8 00031D66 # #include "fpp_defs.h" ! 9: 9 00031D66 # ! 10: 10 00031D66 # ! 11: 11 00031D66 # /***************************************************************************** ! 12: 12 00031D66 # * ! 13: 13 00031D66 # * DBL PIPELINE TEST #17 MONITOR ! 14: 14 00031D66 # * ! 15: 15 00031D66 # * This test will do: ! 16: 16 00031D66 # * ! 17: 17 00031D66 # * CVLD(x) ADDD(0) MULD(1) STD ! 18: 18 00031D66 # * ! 19: 19 00031D66 # * where the x's are the CVLD data patterns. ! 20: 20 00031D66 # *****************************************************************************/ ! 21: 21 00031D66 # pipe_17() ! 22: 22 00031D66 # { ! 23: 23 00031D66 13 009b jbr L217 ! 24: 24 00031D69 L218: ! 25: 25 00031D69 # asm(".globl _pipeline_17_t"); ! 26: 26 00031D69 .globl _pipeline_17_t ! 27: 27 00031D69 # asm("_pipeline_17_t:"); /* entry address */ ! 28: 28 00031D69 _pipeline_17_t: ! 29: 29 00031D69 # if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */ ! 30: 30 00031D69 1d effffffff5 01 cmpl _cycle,$1 ! 31: 31 00031D70 21 15 jneq L219 ! 32: 32 00031D72 5d efffffffec tstl _prt_hdrs ! 33: 33 00031D78 31 0d jeql L219 ! 34: 34 00031D7A # { ! 35: 35 00031D7A # writes(" PIPE_17"); ! 36: 36 00031D7A .data 1 ! 37: 37 00000d20 * L221: ! 38: 38 00000d20 * 20504950455F313700 .ascii " PIPE_17\0" ! 39: 39 00000d29 * .text ! 40: 40 00031D7A dd 8f00000d20 pushl $L221 ! 41: 41 00031D80 fe 08 efffffffdd callf $8,_writes ! 42: 42 00031D87 # } ! 43: 43 00031D87 # subtest = 1; ! 44: 44 00031D87 L219: ! 45: 45 00031D87 0d 01 efffffffd6 movl $1,_subtest ! 46: 46 00031D8E # pipe17_1(); /* data in REGs, no NOPs */ ! 47: 47 00031D8E fe 04 ef00000073 callf $4,_pipe17_1 ! 48: 48 00031D95 # subtest++; /* increment subtest num */ ! 49: 49 00031D95 6d efffffffc9 incl _subtest ! 50: 50 00031D9B # pipe17_2(); /* data in REGs, 1 NOP */ ! 51: 51 00031D9B fe 04 ef0000018c callf $4,_pipe17_2 ! 52: 52 00031DA2 # subtest++; /* increment subtest num */ ! 53: 53 00031DA2 6d efffffffbc incl _subtest ! 54: 54 00031DA8 # pipe17_3(); /* data in REGs, 2 NOPs */ ! 55: 55 00031DA8 fe 04 ef000002a7 callf $4,_pipe17_3 ! 56: 56 00031DAF # subtest++; /* increment subtest num */ ! 57: 57 00031DAF 6d efffffffaf incl _subtest ! 58: 58 00031DB5 # pipe17_4(); /* data in REGs, 3 NOPs */ ! 59: 59 00031DB5 fe 04 ef000003c6 callf $4,_pipe17_4 ! 60: 60 00031DBC # subtest++; /* increment subtest num */ ! 61: 61 00031DBC 6d efffffffa2 incl _subtest ! 62: 62 00031DC2 # pipe17_5(); /* data in CACHE, no NOPs */ ! 63: 63 00031DC2 fe 04 ef000004e7 callf $4,_pipe17_5 ! 64: 64 00031DC9 # subtest++; /* increment subtest num */ ! 65: 65 00031DC9 6d efffffff95 incl _subtest ! 66: 66 00031DCF # pipe17_6(); /* data in CACHE, 1 NOP */ ! 67: 67 00031DCF fe 04 ef000005d4 callf $4,_pipe17_6 ! 68: 68 00031DD6 # subtest++; /* increment subtest num */ ! 69: 69 00031DD6 6d efffffff88 incl _subtest ! 70: 70 00031DDC # pipe17_7(); /* data in CACHE, 2 NOPs */ ! 71: 71 00031DDC fe 04 ef000006c5 callf $4,_pipe17_7 ! 72: 72 00031DE3 # subtest++; /* increment subtest num */ ! 73: 73 00031DE3 6d efffffff7b incl _subtest ! 74: 74 00031DE9 # pipe17_8(); /* data in CACHE, 3 NOPs */ ! 75: 75 00031DE9 fe 04 ef000007b8 callf $4,_pipe17_8 ! 76: 76 00031DF0 # subtest++; /* increment subtest num */ ! 77: 77 00031DF0 6d efffffff6e incl _subtest ! 78: 78 00031DF6 # pipe17_9(); /* data via F.P. 0 NOPs */ ! 79: 79 00031DF6 fe 04 ef000008af callf $4,_pipe17_9 ! 80: 80 00031DFD # asm("jmp *return"); /* return to the test monitor */ ! 81: 81 00031DFD 71 ffffffff61 jmp *return ! 82: 82 00031E03 # } ! 83: 83 00031E03 40 ret#2 ! 84: 84 00031E04 .set L215,0x0 ! 85: 85 00031E04 L217: ! 86: 86 00031E04 13 ff62 jbr L218 ! 87: 87 00031E07 .data ! 88: 88 00000d20 * .text ! 89: 89 00031E07 00 .align 1 ! 90: 90 00031E08 .globl _pipe17_1 ! 91: 91 00031E08 _pipe17_1: ! 92: 92 00031E08 0000 .word L231 ! 93: 93 00031E0A # ! 94: 94 00031E0A # ! 95: 95 00031E0A # ! 96: 96 00031E0A # ! 97: 97 00031E0A # ! 98: 98 00031E0A # ! 99: 99 00031E0A # ! 100: 100 00031E0A # /************************************************************************ ! 101: 101 00031E0A # * ! 102: 102 00031E0A # * SUBTEST 1 ! 103: 103 00031E0A # * data in registers, no NO-OPs ! 104: 104 00031E0A # * ! 105: 105 00031E0A # ************************************************************************/ ! 106: 106 00031E0A # pipe17_1() ! 107: 107 00031E0A # { ! 108: 108 00031E0A 13 011d jbr L233 ! 109: 109 00031E0D L234: ! 110: 110 00031E0D # force_loop = FALSE; /* clear the force_loop flg */ ! 111: 111 00031E0D 4d efffffff51 clrl _force_loop ! 112: 112 00031E13 # index = 0; ! 113: 113 00031E13 4d efffffff4b clrl _index ! 114: 114 00031E19 # do ! 115: 115 00031E19 L237: ! 116: 116 00031E19 # { ! 117: 117 00031E19 # sgl_value_1 = cvld_1_data[index].ld; /* get the integer operand */ ! 118: 118 00031E19 5c 0c efffffff44 50 mull3 $12,_index,r0 ! 119: 119 00031E21 0d e000000000 efffffff38 movl _cvld_1_data(r0),_sgl_value_1 ! 120: 120 00031E2C # sgl_value_7 = 0x40800000; /* get a '1.0' ( MSW ) */ ! 121: 121 00031E2C 0d 8f40800000 efffffff2d movl $1082130432,_sgl_value_7 ! 122: 122 00031E37 # sgl_value_8 = 0; /* get a 0 */ ! 123: 123 00031E37 4d efffffff27 clrl _sgl_value_8 ! 124: 124 00031E3D # dbl_expected = cvld_1_data[index].exp; /* get the expected results */ ! 125: 125 00031E3D 5c 0c efffffff20 50 mull3 $12,_index,r0 ! 126: 126 00031E45 0c 8f00000004 50 addl2 $_cvld_1_data+4,r0 ! 127: 127 00031E4C 0d a004 efffffff14 movl 4(r0),_dbl_expected+4 ! 128: 128 00031E54 0d 60 efffffff09 movl (r0),_dbl_expected ! 129: 129 00031E5B # /* ! 130: 130 00031E5B # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 131: 131 00031E5B # * The force loop flag is set after the first error. ! 132: 132 00031E5B # */ ! 133: 133 00031E5B # asm("_pipe17_1_lp1:"); ! 134: 134 00031E5B _pipe17_1_lp1: ! 135: 135 00031E5B # asm("movl _sgl_value_1,r1"); /* move the data to r1 */ ! 136: 136 00031E5B 0d efffffff03 51 movl _sgl_value_1,r1 ! 137: 137 00031E62 # asm("movl _sgl_value_7,r2"); /* move a '1.0' to r2/r3 */ ! 138: 138 00031E62 0d effffffefc 52 movl _sgl_value_7,r2 ! 139: 139 00031E69 # asm("movl _sgl_value_8,r3"); ! 140: 140 00031E69 0d effffffef5 53 movl _sgl_value_8,r3 ! 141: 141 00031E70 # asm("movl _sgl_value_8,r4"); /* move a '0.0' to r4/r5 */ ! 142: 142 00031E70 0d effffffeee 54 movl _sgl_value_8,r4 ! 143: 143 00031E77 # asm("movl _sgl_value_8,r5"); ! 144: 144 00031E77 0d effffffee7 55 movl _sgl_value_8,r5 ! 145: 145 00031E7E # asm("cvld r1"); /* convert the int. ( op ) */ ! 146: 146 00031E7E 77 51 cvld r1 ! 147: 147 00031E80 # asm("addd r4"); /* add a '0.0' ( op ) */ ! 148: 148 00031E80 c7 54 addd r4 ! 149: 149 00031E82 # asm("muld r2"); /* multiply by 1.0 ( op ) */ ! 150: 150 00031E82 e7 52 muld r2 ! 151: 151 00031E84 # asm("std r6"); /* store the result ( op ) */ ! 152: 152 00031E84 27 56 std r6 ! 153: 153 00031E86 # if( force_loop ) ! 154: 154 00031E86 5d effffffed8 tstl _force_loop ! 155: 155 00031E8C 31 02 jeql L238 ! 156: 156 00031E8E # asm("brb _pipe17_1_lp1");; /* run the loop again */ ! 157: 157 00031E8E 11 cb brb _pipe17_1_lp1 ! 158: 158 00031E90 L238: ! 159: 159 00031E90 # /* ! 160: 160 00031E90 # * verify the results ! 161: 161 00031E90 # */ ! 162: 162 00031E90 # asm("movl r6,_sgl_value_3"); /* get the result */ ! 163: 163 00031E90 0d 56 effffffecd movl r6,_sgl_value_3 ! 164: 164 00031E97 # asm("movl r7,_sgl_value_4"); ! 165: 165 00031E97 0d 57 effffffec6 movl r7,_sgl_value_4 ! 166: 166 00031E9E # dbl_st_acc.m = sgl_value_3; ! 167: 167 00031E9E 0d effffffec0 effffffebb movl _sgl_value_3,_dbl_st_acc ! 168: 168 00031EA9 # dbl_st_acc.l = sgl_value_4; ! 169: 169 00031EA9 0d effffffeb5 effffffeb4 movl _sgl_value_4,_dbl_st_acc+4 ! 170: 170 00031EB4 # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */ ! 171: 171 00031EB4 # (dbl_st_acc.l != dbl_expected.l) ) ! 172: 172 00031EB4 1d effffffeaa effffffea5 cmpl _dbl_st_acc,_dbl_expected ! 173: 173 00031EBF 21 0d jneq L9999 ! 174: 174 00031EC1 1d effffffea1 effffffe9c cmpl _dbl_st_acc+4,_dbl_expected+4 ! 175: 175 00031ECC 31 42 jeql L239 ! 176: 176 00031ECE L9999: ! 177: 177 00031ECE # { ! 178: 178 00031ECE # errcnt++; /* bump the error count */ ! 179: 179 00031ECE 6d effffffe90 incl _errcnt ! 180: 180 00031ED4 # if ( prt_error ) ! 181: 181 00031ED4 5d effffffe8a tstl _prt_error ! 182: 182 00031EDA 31 0d jeql L240 ! 183: 183 00031EDC # print_pipe17_er("Reg. Data, no NOPs"); ! 184: 184 00031EDC .data 1 ! 185: 185 00000d29 * L242: ! 186: 186 00000d29 * 5265672E20446174612C206E6 .ascii "Reg. Data, no NOPs\0" ! 187: F204E4F507300 ! 188: 187 00000d3c * .text ! 189: 188 00031EDC dd 8f00000d29 pushl $L242 ! 190: 189 00031EE2 fe 08 ef000009cf callf $8,_print_pipe17_er ! 191: 190 00031EE9 # if ( halt_flg ) /* halt on error? */ ! 192: 191 00031EE9 L240: ! 193: 192 00031EE9 5d effffffe75 tstl _halt_flg ! 194: 193 00031EEF 31 0d jeql L243 ! 195: 194 00031EF1 # pipe17_er_hlt( subtest ); ! 196: 195 00031EF1 dd effffffe6d pushl _subtest ! 197: 196 00031EF7 fe 08 ef00000b08 callf $8,_pipe17_er_hlt ! 198: 197 00031EFE # if ( loop_on_err ) { ! 199: 198 00031EFE L243: ! 200: 199 00031EFE 5d effffffe60 tstl _loop_on_err ! 201: 200 00031F04 31 0a jeql L245 ! 202: 201 00031F06 # force_loop = TRUE; /* set the force loop flag */ ! 203: 202 00031F06 0d 01 effffffe57 movl $1,_force_loop ! 204: 203 00031F0D # asm("brw _pipe17_1_lp1"); /* and loop */ ! 205: 204 00031F0D 13 ff4b brw _pipe17_1_lp1 ! 206: 205 00031F10 # } ! 207: 206 00031F10 # } /* end of compare error */ ! 208: 207 00031F10 L245: ! 209: 208 00031F10 # } while( index++ < max_cvld_1_index ); ! 210: 209 00031F10 L239: ! 211: 210 00031F10 L236: ! 212: 211 00031F10 0d effffffe4e 50 movl _index,r0 ! 213: 212 00031F17 6d effffffe47 incl _index ! 214: 213 00031F1D 1d 50 effffffe40 cmpl r0,_max_cvld_1_index ! 215: 214 00031F24 81 03 13 fef0 jlss L237 ! 216: 215 00031F29 L235: ! 217: 216 00031F29 # } /* end of subtest 1 */ ! 218: 217 00031F29 40 ret#2 ! 219: 218 00031F2A .set L231,0x0 ! 220: 219 00031F2A L233: ! 221: 220 00031F2A 13 fee0 jbr L234 ! 222: 221 00031F2D .data ! 223: 222 00000d20 * .text ! 224: 223 00031F2D 00 .align 1 ! 225: 224 00031F2E .globl _pipe17_2 ! 226: 225 00031F2E _pipe17_2: ! 227: 226 00031F2E 0000 .word L246 ! 228: 227 00031F30 # ! 229: 228 00031F30 # ! 230: 229 00031F30 # ! 231: 230 00031F30 # ! 232: 231 00031F30 # ! 233: 232 00031F30 # ! 234: 233 00031F30 # ! 235: 234 00031F30 # /************************************************************************ ! 236: 235 00031F30 # * ! 237: 236 00031F30 # * SUBTEST 2 ! 238: 237 00031F30 # * data in registers, 1 NO-OP ! 239: 238 00031F30 # * ! 240: 239 00031F30 # ************************************************************************/ ! 241: 240 00031F30 # pipe17_2() ! 242: 241 00031F30 # { ! 243: 242 00031F30 13 0120 jbr L248 ! 244: 243 00031F33 L249: ! 245: 244 00031F33 # force_loop = FALSE; /* clear the force_loop flg */ ! 246: 245 00031F33 4d effffffe2b clrl _force_loop ! 247: 246 00031F39 # index = 0; ! 248: 247 00031F39 4d effffffe25 clrl _index ! 249: 248 00031F3F # do ! 250: 249 00031F3F L252: ! 251: 250 00031F3F # { ! 252: 251 00031F3F # sgl_value_1 = cvld_1_data[index].ld; /* get the integer operand */ ! 253: 252 00031F3F 5c 0c effffffe1e 50 mull3 $12,_index,r0 ! 254: 253 00031F47 0d e000000000 effffffe12 movl _cvld_1_data(r0),_sgl_value_1 ! 255: 254 00031F52 # sgl_value_7 = 0x40800000; /* get a '1.0' ( MSW ) */ ! 256: 255 00031F52 0d 8f40800000 effffffe07 movl $1082130432,_sgl_value_7 ! 257: 256 00031F5D # sgl_value_8 = 0; /* get a 0 */ ! 258: 257 00031F5D 4d effffffe01 clrl _sgl_value_8 ! 259: 258 00031F63 # dbl_expected = cvld_1_data[index].exp; /* get the expected results */ ! 260: 259 00031F63 5c 0c effffffdfa 50 mull3 $12,_index,r0 ! 261: 260 00031F6B 0c 8f00000004 50 addl2 $_cvld_1_data+4,r0 ! 262: 261 00031F72 0d a004 effffffdee movl 4(r0),_dbl_expected+4 ! 263: 262 00031F7A 0d 60 effffffde3 movl (r0),_dbl_expected ! 264: 263 00031F81 # /* ! 265: 264 00031F81 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 266: 265 00031F81 # * The force loop flag is set after the first error. ! 267: 266 00031F81 # */ ! 268: 267 00031F81 # asm("_pipe17_2_lp1:"); ! 269: 268 00031F81 _pipe17_2_lp1: ! 270: 269 00031F81 # asm("movl _sgl_value_1,r1"); /* move the data to r1 */ ! 271: 270 00031F81 0d effffffddd 51 movl _sgl_value_1,r1 ! 272: 271 00031F88 # asm("movl _sgl_value_7,r2"); /* move a '1.0' to r2/r3 */ ! 273: 272 00031F88 0d effffffdd6 52 movl _sgl_value_7,r2 ! 274: 273 00031F8F # asm("movl _sgl_value_8,r3"); ! 275: 274 00031F8F 0d effffffdcf 53 movl _sgl_value_8,r3 ! 276: 275 00031F96 # asm("movl _sgl_value_8,r4"); /* move a '0.0' to r4/r5 */ ! 277: 276 00031F96 0d effffffdc8 54 movl _sgl_value_8,r4 ! 278: 277 00031F9D # asm("movl _sgl_value_8,r5"); ! 279: 278 00031F9D 0d effffffdc1 55 movl _sgl_value_8,r5 ! 280: 279 00031FA4 # asm("cvld r1"); /* convert the int. ( op ) */ ! 281: 280 00031FA4 77 51 cvld r1 ! 282: 281 00031FA6 # asm("nop"); ! 283: 282 00031FA6 10 nop ! 284: 283 00031FA7 # asm("addd r4"); /* add a '0.0' ( op ) */ ! 285: 284 00031FA7 c7 54 addd r4 ! 286: 285 00031FA9 # asm("nop"); ! 287: 286 00031FA9 10 nop ! 288: 287 00031FAA # asm("muld r2"); /* multiply by 1.0 ( op ) */ ! 289: 288 00031FAA e7 52 muld r2 ! 290: 289 00031FAC # asm("nop"); ! 291: 290 00031FAC 10 nop ! 292: 291 00031FAD # asm("std r6"); /* store the result ( op ) */ ! 293: 292 00031FAD 27 56 std r6 ! 294: 293 00031FAF # if( force_loop ) ! 295: 294 00031FAF 5d effffffdaf tstl _force_loop ! 296: 295 00031FB5 31 02 jeql L253 ! 297: 296 00031FB7 # asm("brb _pipe17_2_lp1");; /* run the loop again */ ! 298: 297 00031FB7 11 c8 brb _pipe17_2_lp1 ! 299: 298 00031FB9 L253: ! 300: 299 00031FB9 # /* ! 301: 300 00031FB9 # * verify the results ! 302: 301 00031FB9 # */ ! 303: 302 00031FB9 # asm("movl r6,_sgl_value_3"); /* get the result */ ! 304: 303 00031FB9 0d 56 effffffda4 movl r6,_sgl_value_3 ! 305: 304 00031FC0 # asm("movl r7,_sgl_value_4"); ! 306: 305 00031FC0 0d 57 effffffd9d movl r7,_sgl_value_4 ! 307: 306 00031FC7 # dbl_st_acc.m = sgl_value_3; ! 308: 307 00031FC7 0d effffffd97 effffffd92 movl _sgl_value_3,_dbl_st_acc ! 309: 308 00031FD2 # dbl_st_acc.l = sgl_value_4; ! 310: 309 00031FD2 0d effffffd8c effffffd8b movl _sgl_value_4,_dbl_st_acc+4 ! 311: 310 00031FDD # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */ ! 312: 311 00031FDD # (dbl_st_acc.l != dbl_expected.l) ) ! 313: 312 00031FDD 1d effffffd81 effffffd7c cmpl _dbl_st_acc,_dbl_expected ! 314: 313 00031FE8 21 0d jneq L9998 ! 315: 314 00031FEA 1d effffffd78 effffffd73 cmpl _dbl_st_acc+4,_dbl_expected+4 ! 316: 315 00031FF5 31 42 jeql L254 ! 317: 316 00031FF7 L9998: ! 318: 317 00031FF7 # { ! 319: 318 00031FF7 # errcnt++; /* bump the error count */ ! 320: 319 00031FF7 6d effffffd67 incl _errcnt ! 321: 320 00031FFD # if ( prt_error ) ! 322: 321 00031FFD 5d effffffd61 tstl _prt_error ! 323: 322 00032003 31 0d jeql L255 ! 324: 323 00032005 # print_pipe17_er("Reg. Data, 1 NOP"); ! 325: 324 00032005 .data 1 ! 326: 325 00000d3c * L256: ! 327: 326 00000d3c * 5265672E20446174612C20312 .ascii "Reg. Data, 1 NOP\0" ! 328: 04E4F5000 ! 329: 327 00000d4d * .text ! 330: 328 00032005 dd 8f00000d3c pushl $L256 ! 331: 329 0003200B fe 08 ef000008a6 callf $8,_print_pipe17_er ! 332: 330 00032012 # if ( halt_flg ) /* halt on error? */ ! 333: 331 00032012 L255: ! 334: 332 00032012 5d effffffd4c tstl _halt_flg ! 335: 333 00032018 31 0d jeql L257 ! 336: 334 0003201A # pipe17_er_hlt( subtest ); ! 337: 335 0003201A dd effffffd44 pushl _subtest ! 338: 336 00032020 fe 08 ef000009df callf $8,_pipe17_er_hlt ! 339: 337 00032027 # if ( loop_on_err ) { ! 340: 338 00032027 L257: ! 341: 339 00032027 5d effffffd37 tstl _loop_on_err ! 342: 340 0003202D 31 0a jeql L258 ! 343: 341 0003202F # force_loop = TRUE; /* set the force loop flag */ ! 344: 342 0003202F 0d 01 effffffd2e movl $1,_force_loop ! 345: 343 00032036 # asm("brw _pipe17_2_lp1"); /* and loop */ ! 346: 344 00032036 13 ff48 brw _pipe17_2_lp1 ! 347: 345 00032039 # } ! 348: 346 00032039 # } /* end of compare error */ ! 349: 347 00032039 L258: ! 350: 348 00032039 # } while( index++ < max_cvld_1_index ); ! 351: 349 00032039 L254: ! 352: 350 00032039 L251: ! 353: 351 00032039 0d effffffd25 50 movl _index,r0 ! 354: 352 00032040 6d effffffd1e incl _index ! 355: 353 00032046 1d 50 effffffd17 cmpl r0,_max_cvld_1_index ! 356: 354 0003204D 81 03 13 feed jlss L252 ! 357: 355 00032052 L250: ! 358: 356 00032052 # } /* end of subtest 2 */ ! 359: 357 00032052 40 ret#2 ! 360: 358 00032053 .set L246,0x0 ! 361: 359 00032053 L248: ! 362: 360 00032053 13 fedd jbr L249 ! 363: 361 00032056 .data ! 364: 362 00000d20 * .text ! 365: 363 00032056 .align 1 ! 366: 364 00032056 .globl _pipe17_3 ! 367: 365 00032056 _pipe17_3: ! 368: 366 00032056 0000 .word L259 ! 369: 367 00032058 # ! 370: 368 00032058 # ! 371: 369 00032058 # ! 372: 370 00032058 # ! 373: 371 00032058 # ! 374: 372 00032058 # ! 375: 373 00032058 # ! 376: 374 00032058 # /************************************************************************ ! 377: 375 00032058 # * ! 378: 376 00032058 # * SUBTEST 3 ! 379: 377 00032058 # * data in registers, 2 NO-OPs ! 380: 378 00032058 # * ! 381: 379 00032058 # ************************************************************************/ ! 382: 380 00032058 # pipe17_3() ! 383: 381 00032058 # { ! 384: 382 00032058 13 0123 jbr L261 ! 385: 383 0003205B L262: ! 386: 384 0003205B # force_loop = FALSE; /* clear the force_loop flg */ ! 387: 385 0003205B 4d effffffd03 clrl _force_loop ! 388: 386 00032061 # index = 0; ! 389: 387 00032061 4d effffffcfd clrl _index ! 390: 388 00032067 # do ! 391: 389 00032067 L265: ! 392: 390 00032067 # { ! 393: 391 00032067 # sgl_value_1 = cvld_1_data[index].ld; /* get the integer operand */ ! 394: 392 00032067 5c 0c effffffcf6 50 mull3 $12,_index,r0 ! 395: 393 0003206F 0d e000000000 effffffcea movl _cvld_1_data(r0),_sgl_value_1 ! 396: 394 0003207A # sgl_value_7 = 0x40800000; /* get a '1.0' ( MSW ) */ ! 397: 395 0003207A 0d 8f40800000 effffffcdf movl $1082130432,_sgl_value_7 ! 398: 396 00032085 # sgl_value_8 = 0; /* get a 0 */ ! 399: 397 00032085 4d effffffcd9 clrl _sgl_value_8 ! 400: 398 0003208B # dbl_expected = cvld_1_data[index].exp; /* get the expected results */ ! 401: 399 0003208B 5c 0c effffffcd2 50 mull3 $12,_index,r0 ! 402: 400 00032093 0c 8f00000004 50 addl2 $_cvld_1_data+4,r0 ! 403: 401 0003209A 0d a004 effffffcc6 movl 4(r0),_dbl_expected+4 ! 404: 402 000320A2 0d 60 effffffcbb movl (r0),_dbl_expected ! 405: 403 000320A9 # /* ! 406: 404 000320A9 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 407: 405 000320A9 # * The force loop flag is set after the first error. ! 408: 406 000320A9 # */ ! 409: 407 000320A9 # asm("_pipe17_3_lp1:"); ! 410: 408 000320A9 _pipe17_3_lp1: ! 411: 409 000320A9 # asm("movl _sgl_value_1,r1"); /* move the data to r1 */ ! 412: 410 000320A9 0d effffffcb5 51 movl _sgl_value_1,r1 ! 413: 411 000320B0 # asm("movl _sgl_value_7,r2"); /* move a '1.0' to r2/r3 */ ! 414: 412 000320B0 0d effffffcae 52 movl _sgl_value_7,r2 ! 415: 413 000320B7 # asm("movl _sgl_value_8,r3"); ! 416: 414 000320B7 0d effffffca7 53 movl _sgl_value_8,r3 ! 417: 415 000320BE # asm("movl _sgl_value_8,r4"); /* move a '0.0' to r4/r5 */ ! 418: 416 000320BE 0d effffffca0 54 movl _sgl_value_8,r4 ! 419: 417 000320C5 # asm("movl _sgl_value_8,r5"); ! 420: 418 000320C5 0d effffffc99 55 movl _sgl_value_8,r5 ! 421: 419 000320CC # asm("cvld r1"); /* convert the int. ( op ) */ ! 422: 420 000320CC 77 51 cvld r1 ! 423: 421 000320CE # asm("nop"); ! 424: 422 000320CE 10 nop ! 425: 423 000320CF # asm("nop"); ! 426: 424 000320CF 10 nop ! 427: 425 000320D0 # asm("addd r4"); /* add a '0.0' ( op ) */ ! 428: 426 000320D0 c7 54 addd r4 ! 429: 427 000320D2 # asm("nop"); ! 430: 428 000320D2 10 nop ! 431: 429 000320D3 # asm("nop"); ! 432: 430 000320D3 10 nop ! 433: 431 000320D4 # asm("muld r2"); /* multiply by 1.0 ( op ) */ ! 434: 432 000320D4 e7 52 muld r2 ! 435: 433 000320D6 # asm("nop"); ! 436: 434 000320D6 10 nop ! 437: 435 000320D7 # asm("nop"); ! 438: 436 000320D7 10 nop ! 439: 437 000320D8 # asm("std r6"); /* store the result ( op ) */ ! 440: 438 000320D8 27 56 std r6 ! 441: 439 000320DA # if( force_loop ) ! 442: 440 000320DA 5d effffffc84 tstl _force_loop ! 443: 441 000320E0 31 02 jeql L266 ! 444: 442 000320E2 # asm("brb _pipe17_3_lp1");; /* run the loop again */ ! 445: 443 000320E2 11 c5 brb _pipe17_3_lp1 ! 446: 444 000320E4 L266: ! 447: 445 000320E4 # /* ! 448: 446 000320E4 # * verify the results ! 449: 447 000320E4 # */ ! 450: 448 000320E4 # asm("movl r6,_sgl_value_3"); /* get the result */ ! 451: 449 000320E4 0d 56 effffffc79 movl r6,_sgl_value_3 ! 452: 450 000320EB # asm("movl r7,_sgl_value_4"); ! 453: 451 000320EB 0d 57 effffffc72 movl r7,_sgl_value_4 ! 454: 452 000320F2 # dbl_st_acc.m = sgl_value_3; ! 455: 453 000320F2 0d effffffc6c effffffc67 movl _sgl_value_3,_dbl_st_acc ! 456: 454 000320FD # dbl_st_acc.l = sgl_value_4; ! 457: 455 000320FD 0d effffffc61 effffffc60 movl _sgl_value_4,_dbl_st_acc+4 ! 458: 456 00032108 # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */ ! 459: 457 00032108 # (dbl_st_acc.l != dbl_expected.l) ) ! 460: 458 00032108 1d effffffc56 effffffc51 cmpl _dbl_st_acc,_dbl_expected ! 461: 459 00032113 21 0d jneq L9997 ! 462: 460 00032115 1d effffffc4d effffffc48 cmpl _dbl_st_acc+4,_dbl_expected+4 ! 463: 461 00032120 31 42 jeql L267 ! 464: 462 00032122 L9997: ! 465: 463 00032122 # { ! 466: 464 00032122 # errcnt++; /* bump the error count */ ! 467: 465 00032122 6d effffffc3c incl _errcnt ! 468: 466 00032128 # if ( prt_error ) ! 469: 467 00032128 5d effffffc36 tstl _prt_error ! 470: 468 0003212E 31 0d jeql L268 ! 471: 469 00032130 # print_pipe17_er("Reg. Data, 2 NOPs"); ! 472: 470 00032130 .data 1 ! 473: 471 00000d4d * L269: ! 474: 472 00000d4d * 5265672E20446174612C20322 .ascii "Reg. Data, 2 NOPs\0" ! 475: 04E4F507300 ! 476: 473 00000d5f * .text ! 477: 474 00032130 dd 8f00000d4d pushl $L269 ! 478: 475 00032136 fe 08 ef0000077b callf $8,_print_pipe17_er ! 479: 476 0003213D # if ( halt_flg ) /* halt on error? */ ! 480: 477 0003213D L268: ! 481: 478 0003213D 5d effffffc21 tstl _halt_flg ! 482: 479 00032143 31 0d jeql L270 ! 483: 480 00032145 # pipe17_er_hlt( subtest ); ! 484: 481 00032145 dd effffffc19 pushl _subtest ! 485: 482 0003214B fe 08 ef000008b4 callf $8,_pipe17_er_hlt ! 486: 483 00032152 # if ( loop_on_err ) { ! 487: 484 00032152 L270: ! 488: 485 00032152 5d effffffc0c tstl _loop_on_err ! 489: 486 00032158 31 0a jeql L271 ! 490: 487 0003215A # force_loop = TRUE; /* set the force loop flag */ ! 491: 488 0003215A 0d 01 effffffc03 movl $1,_force_loop ! 492: 489 00032161 # asm("brw _pipe17_3_lp1"); /* and loop */ ! 493: 490 00032161 13 ff45 brw _pipe17_3_lp1 ! 494: 491 00032164 # } ! 495: 492 00032164 # } /* end of compare error */ ! 496: 493 00032164 L271: ! 497: 494 00032164 # } while( index++ < max_cvld_1_index ); ! 498: 495 00032164 L267: ! 499: 496 00032164 L264: ! 500: 497 00032164 0d effffffbfa 50 movl _index,r0 ! 501: 498 0003216B 6d effffffbf3 incl _index ! 502: 499 00032171 1d 50 effffffbec cmpl r0,_max_cvld_1_index ! 503: 500 00032178 81 03 13 feea jlss L265 ! 504: 501 0003217D L263: ! 505: 502 0003217D # } /* end of subtest 3 */ ! 506: 503 0003217D 40 ret#2 ! 507: 504 0003217E .set L259,0x0 ! 508: 505 0003217E L261: ! 509: 506 0003217E 13 feda jbr L262 ! 510: 507 00032181 .data ! 511: 508 00000d20 * .text ! 512: 509 00032181 00 .align 1 ! 513: 510 00032182 .globl _pipe17_4 ! 514: 511 00032182 _pipe17_4: ! 515: 512 00032182 0000 .word L272 ! 516: 513 00032184 # ! 517: 514 00032184 # ! 518: 515 00032184 # ! 519: 516 00032184 # ! 520: 517 00032184 # ! 521: 518 00032184 # ! 522: 519 00032184 # ! 523: 520 00032184 # /************************************************************************ ! 524: 521 00032184 # * ! 525: 522 00032184 # * SUBTEST 4 ! 526: 523 00032184 # * data in registers, 3 NO-OPs ! 527: 524 00032184 # * ! 528: 525 00032184 # ************************************************************************/ ! 529: 526 00032184 # pipe17_4() ! 530: 527 00032184 # { ! 531: 528 00032184 13 0126 jbr L274 ! 532: 529 00032187 L275: ! 533: 530 00032187 # force_loop = FALSE; /* clear the force_loop flg */ ! 534: 531 00032187 4d effffffbd7 clrl _force_loop ! 535: 532 0003218D # index = 0; ! 536: 533 0003218D 4d effffffbd1 clrl _index ! 537: 534 00032193 # do ! 538: 535 00032193 L278: ! 539: 536 00032193 # { ! 540: 537 00032193 # sgl_value_1 = cvld_1_data[index].ld; /* get the integer operand */ ! 541: 538 00032193 5c 0c effffffbca 50 mull3 $12,_index,r0 ! 542: 539 0003219B 0d e000000000 effffffbbe movl _cvld_1_data(r0),_sgl_value_1 ! 543: 540 000321A6 # sgl_value_7 = 0x40800000; /* get a '1.0' ( MSW ) */ ! 544: 541 000321A6 0d 8f40800000 effffffbb3 movl $1082130432,_sgl_value_7 ! 545: 542 000321B1 # sgl_value_8 = 0; /* get a 0 */ ! 546: 543 000321B1 4d effffffbad clrl _sgl_value_8 ! 547: 544 000321B7 # dbl_expected = cvld_1_data[index].exp; /* get the expected results */ ! 548: 545 000321B7 5c 0c effffffba6 50 mull3 $12,_index,r0 ! 549: 546 000321BF 0c 8f00000004 50 addl2 $_cvld_1_data+4,r0 ! 550: 547 000321C6 0d a004 effffffb9a movl 4(r0),_dbl_expected+4 ! 551: 548 000321CE 0d 60 effffffb8f movl (r0),_dbl_expected ! 552: 549 000321D5 # /* ! 553: 550 000321D5 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 554: 551 000321D5 # * The force loop flag is set after the first error. ! 555: 552 000321D5 # */ ! 556: 553 000321D5 # asm("_pipe17_4_lp1:"); ! 557: 554 000321D5 _pipe17_4_lp1: ! 558: 555 000321D5 # asm("movl _sgl_value_1,r1"); /* move the data to r1 */ ! 559: 556 000321D5 0d effffffb89 51 movl _sgl_value_1,r1 ! 560: 557 000321DC # asm("movl _sgl_value_7,r2"); /* move a '1.0' to r2/r3 */ ! 561: 558 000321DC 0d effffffb82 52 movl _sgl_value_7,r2 ! 562: 559 000321E3 # asm("movl _sgl_value_8,r3"); ! 563: 560 000321E3 0d effffffb7b 53 movl _sgl_value_8,r3 ! 564: 561 000321EA # asm("movl _sgl_value_8,r4"); /* move a '0.0' to r4/r5 */ ! 565: 562 000321EA 0d effffffb74 54 movl _sgl_value_8,r4 ! 566: 563 000321F1 # asm("movl _sgl_value_8,r5"); ! 567: 564 000321F1 0d effffffb6d 55 movl _sgl_value_8,r5 ! 568: 565 000321F8 # asm("cvld r1"); /* convert the int. ( op ) */ ! 569: 566 000321F8 77 51 cvld r1 ! 570: 567 000321FA # asm("nop"); ! 571: 568 000321FA 10 nop ! 572: 569 000321FB # asm("nop"); ! 573: 570 000321FB 10 nop ! 574: 571 000321FC # asm("nop"); ! 575: 572 000321FC 10 nop ! 576: 573 000321FD # asm("addd r4"); /* add a '0.0' ( op ) */ ! 577: 574 000321FD c7 54 addd r4 ! 578: 575 000321FF # asm("nop"); ! 579: 576 000321FF 10 nop ! 580: 577 00032200 # asm("nop"); ! 581: 578 00032200 10 nop ! 582: 579 00032201 # asm("nop"); ! 583: 580 00032201 10 nop ! 584: 581 00032202 # asm("muld r2"); /* multiply by 1.0 ( op ) */ ! 585: 582 00032202 e7 52 muld r2 ! 586: 583 00032204 # asm("nop"); ! 587: 584 00032204 10 nop ! 588: 585 00032205 # asm("nop"); ! 589: 586 00032205 10 nop ! 590: 587 00032206 # asm("nop"); ! 591: 588 00032206 10 nop ! 592: 589 00032207 # asm("std r6"); /* store the result ( op ) */ ! 593: 590 00032207 27 56 std r6 ! 594: 591 00032209 # if( force_loop ) ! 595: 592 00032209 5d effffffb55 tstl _force_loop ! 596: 593 0003220F 31 02 jeql L279 ! 597: 594 00032211 # asm("brb _pipe17_4_lp1");; /* run the loop again */ ! 598: 595 00032211 11 c2 brb _pipe17_4_lp1 ! 599: 596 00032213 L279: ! 600: 597 00032213 # /* ! 601: 598 00032213 # * verify the results ! 602: 599 00032213 # */ ! 603: 600 00032213 # asm("movl r6,_sgl_value_3"); /* get the result */ ! 604: 601 00032213 0d 56 effffffb4a movl r6,_sgl_value_3 ! 605: 602 0003221A # asm("movl r7,_sgl_value_4"); ! 606: 603 0003221A 0d 57 effffffb43 movl r7,_sgl_value_4 ! 607: 604 00032221 # dbl_st_acc.m = sgl_value_3; ! 608: 605 00032221 0d effffffb3d effffffb38 movl _sgl_value_3,_dbl_st_acc ! 609: 606 0003222C # dbl_st_acc.l = sgl_value_4; ! 610: 607 0003222C 0d effffffb32 effffffb31 movl _sgl_value_4,_dbl_st_acc+4 ! 611: 608 00032237 # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */ ! 612: 609 00032237 # (dbl_st_acc.l != dbl_expected.l) ) ! 613: 610 00032237 1d effffffb27 effffffb22 cmpl _dbl_st_acc,_dbl_expected ! 614: 611 00032242 21 0d jneq L9996 ! 615: 612 00032244 1d effffffb1e effffffb19 cmpl _dbl_st_acc+4,_dbl_expected+4 ! 616: 613 0003224F 31 42 jeql L280 ! 617: 614 00032251 L9996: ! 618: 615 00032251 # { ! 619: 616 00032251 # errcnt++; /* bump the error count */ ! 620: 617 00032251 6d effffffb0d incl _errcnt ! 621: 618 00032257 # if ( prt_error ) ! 622: 619 00032257 5d effffffb07 tstl _prt_error ! 623: 620 0003225D 31 0d jeql L281 ! 624: 621 0003225F # print_pipe17_er("Reg. Data, 3 NOPs"); ! 625: 622 0003225F .data 1 ! 626: 623 00000d5f * L282: ! 627: 624 00000d5f * 5265672E20446174612C20332 .ascii "Reg. Data, 3 NOPs\0" ! 628: 04E4F507300 ! 629: 625 00000d71 * .text ! 630: 626 0003225F dd 8f00000d5f pushl $L282 ! 631: 627 00032265 fe 08 ef0000064c callf $8,_print_pipe17_er ! 632: 628 0003226C # if ( halt_flg ) /* halt on error? */ ! 633: 629 0003226C L281: ! 634: 630 0003226C 5d effffffaf2 tstl _halt_flg ! 635: 631 00032272 31 0d jeql L283 ! 636: 632 00032274 # pipe17_er_hlt( subtest ); ! 637: 633 00032274 dd effffffaea pushl _subtest ! 638: 634 0003227A fe 08 ef00000785 callf $8,_pipe17_er_hlt ! 639: 635 00032281 # if ( loop_on_err ) { ! 640: 636 00032281 L283: ! 641: 637 00032281 5d effffffadd tstl _loop_on_err ! 642: 638 00032287 31 0a jeql L284 ! 643: 639 00032289 # force_loop = TRUE; /* set the force loop flag */ ! 644: 640 00032289 0d 01 effffffad4 movl $1,_force_loop ! 645: 641 00032290 # asm("brw _pipe17_4_lp1"); /* and loop */ ! 646: 642 00032290 13 ff42 brw _pipe17_4_lp1 ! 647: 643 00032293 # } ! 648: 644 00032293 # } /* end of compare error */ ! 649: 645 00032293 L284: ! 650: 646 00032293 # } while( index++ < max_cvld_1_index ); ! 651: 647 00032293 L280: ! 652: 648 00032293 L277: ! 653: 649 00032293 0d effffffacb 50 movl _index,r0 ! 654: 650 0003229A 6d effffffac4 incl _index ! 655: 651 000322A0 1d 50 effffffabd cmpl r0,_max_cvld_1_index ! 656: 652 000322A7 81 03 13 fee7 jlss L278 ! 657: 653 000322AC L276: ! 658: 654 000322AC # } /* end of subtest 4 */ ! 659: 655 000322AC 40 ret#2 ! 660: 656 000322AD .set L272,0x0 ! 661: 657 000322AD L274: ! 662: 658 000322AD 13 fed7 jbr L275 ! 663: 659 000322B0 .data ! 664: 660 00000d20 * .text ! 665: 661 000322B0 .align 1 ! 666: 662 000322B0 .globl _pipe17_5 ! 667: 663 000322B0 _pipe17_5: ! 668: 664 000322B0 0000 .word L285 ! 669: 665 000322B2 # ! 670: 666 000322B2 # ! 671: 667 000322B2 # ! 672: 668 000322B2 # ! 673: 669 000322B2 # ! 674: 670 000322B2 # ! 675: 671 000322B2 # ! 676: 672 000322B2 # /************************************************************************ ! 677: 673 000322B2 # * ! 678: 674 000322B2 # * SUBTEST 5 ! 679: 675 000322B2 # * data in cache, no NO-OPs ! 680: 676 000322B2 # * ! 681: 677 000322B2 # ************************************************************************/ ! 682: 678 000322B2 # pipe17_5() ! 683: 679 000322B2 # { ! 684: 680 000322B2 13 00f2 jbr L287 ! 685: 681 000322B5 L288: ! 686: 682 000322B5 # force_loop = FALSE; /* clear the force_loop flg */ ! 687: 683 000322B5 4d effffffaa9 clrl _force_loop ! 688: 684 000322BB # index = 0; ! 689: 685 000322BB 4d effffffaa3 clrl _index ! 690: 686 000322C1 # do ! 691: 687 000322C1 L291: ! 692: 688 000322C1 # { ! 693: 689 000322C1 # sgl_value_1 = cvld_1_data[index].ld; /* get the operand */ ! 694: 690 000322C1 5c 0c effffffa9c 50 mull3 $12,_index,r0 ! 695: 691 000322C9 0d e000000000 effffffa90 movl _cvld_1_data(r0),_sgl_value_1 ! 696: 692 000322D4 # dbl_value_1.m = 0x40800000; /* set the '1.0' operand */ ! 697: 693 000322D4 0d 8f40800000 effffffa85 movl $1082130432,_dbl_value_1 ! 698: 694 000322DF # dbl_value_1.l = 0; ! 699: 695 000322DF 4d effffffa83 clrl _dbl_value_1+4 ! 700: 696 000322E5 # dbl_value_2.m = 0; /* set the '0.0' operand */ ! 701: 697 000322E5 4d effffffa79 clrl _dbl_value_2 ! 702: 698 000322EB # dbl_value_2.l = 0; ! 703: 699 000322EB 4d effffffa77 clrl _dbl_value_2+4 ! 704: 700 000322F1 # dbl_expected = cvld_1_data[index].exp; /* get the expected results */ ! 705: 701 000322F1 5c 0c effffffa6c 50 mull3 $12,_index,r0 ! 706: 702 000322F9 0c 8f00000004 50 addl2 $_cvld_1_data+4,r0 ! 707: 703 00032300 0d a004 effffffa60 movl 4(r0),_dbl_expected+4 ! 708: 704 00032308 0d 60 effffffa55 movl (r0),_dbl_expected ! 709: 705 0003230F # /* ! 710: 706 0003230F # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 711: 707 0003230F # * The force loop flag is set after the first error. ! 712: 708 0003230F # */ ! 713: 709 0003230F # asm("_pipe17_5_lp1:"); ! 714: 710 0003230F _pipe17_5_lp1: ! 715: 711 0003230F # asm("cvld _sgl_value_1"); /* convert the int. ( op ) */ ! 716: 712 0003230F 77 effffffa4f cvld _sgl_value_1 ! 717: 713 00032315 # asm("addd _dbl_value_2"); /* add a '0.0' ( 0 ) */ ! 718: 714 00032315 c7 effffffa49 addd _dbl_value_2 ! 719: 715 0003231B # asm("muld _dbl_value_1"); /* multiply by 1.0 ( 0 ) */ ! 720: 716 0003231B e7 effffffa43 muld _dbl_value_1 ! 721: 717 00032321 # asm("std _dbl_st_acc"); /* store the result (-op ) */ ! 722: 718 00032321 27 effffffa3d std _dbl_st_acc ! 723: 719 00032327 # if( force_loop ) ! 724: 720 00032327 5d effffffa37 tstl _force_loop ! 725: 721 0003232D 31 02 jeql L292 ! 726: 722 0003232F # asm("brb _pipe17_5_lp1");; /* run the loop again */ ! 727: 723 0003232F 11 de brb _pipe17_5_lp1 ! 728: 724 00032331 L292: ! 729: 725 00032331 # /* ! 730: 726 00032331 # * verify the results ! 731: 727 00032331 # */ ! 732: 728 00032331 # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */ ! 733: 729 00032331 # (dbl_st_acc.l != dbl_expected.l) ) ! 734: 730 00032331 1d effffffa2d effffffa28 cmpl _dbl_st_acc,_dbl_expected ! 735: 731 0003233C 21 0d jneq L9995 ! 736: 732 0003233E 1d effffffa24 effffffa1f cmpl _dbl_st_acc+4,_dbl_expected+4 ! 737: 733 00032349 31 42 jeql L293 ! 738: 734 0003234B L9995: ! 739: 735 0003234B # { ! 740: 736 0003234B # errcnt++; /* bump the error count */ ! 741: 737 0003234B 6d effffffa13 incl _errcnt ! 742: 738 00032351 # if ( prt_error ) ! 743: 739 00032351 5d effffffa0d tstl _prt_error ! 744: 740 00032357 31 0d jeql L294 ! 745: 741 00032359 # print_pipe17_er("Cache Data, no NOPs"); ! 746: 742 00032359 .data 1 ! 747: 743 00000d71 * L295: ! 748: 744 00000d71 * 436163686520446174612C206 .ascii "Cache Data, no NOPs\0" ! 749: E6F204E4F507300 ! 750: 745 00000d85 * .text ! 751: 746 00032359 dd 8f00000d71 pushl $L295 ! 752: 747 0003235F fe 08 ef00000552 callf $8,_print_pipe17_er ! 753: 748 00032366 # if ( halt_flg ) /* halt on error? */ ! 754: 749 00032366 L294: ! 755: 750 00032366 5d effffff9f8 tstl _halt_flg ! 756: 751 0003236C 31 0d jeql L296 ! 757: 752 0003236E # pipe17_er_hlt( subtest ); ! 758: 753 0003236E dd effffff9f0 pushl _subtest ! 759: 754 00032374 fe 08 ef0000068b callf $8,_pipe17_er_hlt ! 760: 755 0003237B # if ( loop_on_err ) { ! 761: 756 0003237B L296: ! 762: 757 0003237B 5d effffff9e3 tstl _loop_on_err ! 763: 758 00032381 31 0a jeql L297 ! 764: 759 00032383 # force_loop = TRUE; /* set the force loop flag */ ! 765: 760 00032383 0d 01 effffff9da movl $1,_force_loop ! 766: 761 0003238A # asm("brw _pipe17_5_lp1"); /* and loop */ ! 767: 762 0003238A 13 ff82 brw _pipe17_5_lp1 ! 768: 763 0003238D # } ! 769: 764 0003238D # } /* end of compare error */ ! 770: 765 0003238D L297: ! 771: 766 0003238D # } while( index++ < max_cvld_1_index ); ! 772: 767 0003238D L293: ! 773: 768 0003238D L290: ! 774: 769 0003238D 0d effffff9d1 50 movl _index,r0 ! 775: 770 00032394 6d effffff9ca incl _index ! 776: 771 0003239A 1d 50 effffff9c3 cmpl r0,_max_cvld_1_index ! 777: 772 000323A1 81 03 13 ff1b jlss L291 ! 778: 773 000323A6 L289: ! 779: 774 000323A6 # } /* end of subtest 5 */ ! 780: 775 000323A6 40 ret#2 ! 781: 776 000323A7 .set L285,0x0 ! 782: 777 000323A7 L287: ! 783: 778 000323A7 13 ff0b jbr L288 ! 784: 779 000323AA .data ! 785: 780 00000d20 * .text ! 786: 781 000323AA .align 1 ! 787: 782 000323AA .globl _pipe17_6 ! 788: 783 000323AA _pipe17_6: ! 789: 784 000323AA 0000 .word L298 ! 790: 785 000323AC # ! 791: 786 000323AC # ! 792: 787 000323AC # ! 793: 788 000323AC # ! 794: 789 000323AC # ! 795: 790 000323AC # ! 796: 791 000323AC # ! 797: 792 000323AC # ! 798: 793 000323AC # /************************************************************************ ! 799: 794 000323AC # * ! 800: 795 000323AC # * SUBTEST 6 ! 801: 796 000323AC # * data in cache, 1 NO-OP ! 802: 797 000323AC # * ! 803: 798 000323AC # ************************************************************************/ ! 804: 799 000323AC # pipe17_6() ! 805: 800 000323AC # { ! 806: 801 000323AC 13 00f5 jbr L300 ! 807: 802 000323AF L301: ! 808: 803 000323AF # force_loop = FALSE; /* clear the force_loop flg */ ! 809: 804 000323AF 4d effffff9af clrl _force_loop ! 810: 805 000323B5 # index = 0; ! 811: 806 000323B5 4d effffff9a9 clrl _index ! 812: 807 000323BB # do ! 813: 808 000323BB L304: ! 814: 809 000323BB # { ! 815: 810 000323BB # sgl_value_1 = cvld_1_data[index].ld; /* get the operand */ ! 816: 811 000323BB 5c 0c effffff9a2 50 mull3 $12,_index,r0 ! 817: 812 000323C3 0d e000000000 effffff996 movl _cvld_1_data(r0),_sgl_value_1 ! 818: 813 000323CE # dbl_value_1.m = 0x40800000; /* set the '1.0' operand */ ! 819: 814 000323CE 0d 8f40800000 effffff98b movl $1082130432,_dbl_value_1 ! 820: 815 000323D9 # dbl_value_1.l = 0; ! 821: 816 000323D9 4d effffff989 clrl _dbl_value_1+4 ! 822: 817 000323DF # dbl_value_2.m = 0; /* set the '0.0' operand */ ! 823: 818 000323DF 4d effffff97f clrl _dbl_value_2 ! 824: 819 000323E5 # dbl_value_2.l = 0; ! 825: 820 000323E5 4d effffff97d clrl _dbl_value_2+4 ! 826: 821 000323EB # dbl_expected = cvld_1_data[index].exp; /* get the expected results */ ! 827: 822 000323EB 5c 0c effffff972 50 mull3 $12,_index,r0 ! 828: 823 000323F3 0c 8f00000004 50 addl2 $_cvld_1_data+4,r0 ! 829: 824 000323FA 0d a004 effffff966 movl 4(r0),_dbl_expected+4 ! 830: 825 00032402 0d 60 effffff95b movl (r0),_dbl_expected ! 831: 826 00032409 # /* ! 832: 827 00032409 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 833: 828 00032409 # * The force loop flag is set after the first error. ! 834: 829 00032409 # */ ! 835: 830 00032409 # asm("_pipe17_6_lp1:"); ! 836: 831 00032409 _pipe17_6_lp1: ! 837: 832 00032409 # asm("cvld _sgl_value_1"); /* convert the int. ( op ) */ ! 838: 833 00032409 77 effffff955 cvld _sgl_value_1 ! 839: 834 0003240F # asm("nop"); ! 840: 835 0003240F 10 nop ! 841: 836 00032410 # asm("addd _dbl_value_2"); /* add a '0.0' ( 0 ) */ ! 842: 837 00032410 c7 effffff94e addd _dbl_value_2 ! 843: 838 00032416 # asm("nop"); ! 844: 839 00032416 10 nop ! 845: 840 00032417 # asm("muld _dbl_value_1"); /* multiply by 1.0 ( 0 ) */ ! 846: 841 00032417 e7 effffff947 muld _dbl_value_1 ! 847: 842 0003241D # asm("nop"); ! 848: 843 0003241D 10 nop ! 849: 844 0003241E # asm("std _dbl_st_acc"); /* store the result (-op ) */ ! 850: 845 0003241E 27 effffff940 std _dbl_st_acc ! 851: 846 00032424 # if( force_loop ) ! 852: 847 00032424 5d effffff93a tstl _force_loop ! 853: 848 0003242A 31 02 jeql L305 ! 854: 849 0003242C # asm("brb _pipe17_6_lp1");; /* run the loop again */ ! 855: 850 0003242C 11 db brb _pipe17_6_lp1 ! 856: 851 0003242E L305: ! 857: 852 0003242E # /* ! 858: 853 0003242E # * verify the results ! 859: 854 0003242E # */ ! 860: 855 0003242E # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */ ! 861: 856 0003242E # (dbl_st_acc.l != dbl_expected.l) ) ! 862: 857 0003242E 1d effffff930 effffff92b cmpl _dbl_st_acc,_dbl_expected ! 863: 858 00032439 21 0d jneq L9994 ! 864: 859 0003243B 1d effffff927 effffff922 cmpl _dbl_st_acc+4,_dbl_expected+4 ! 865: 860 00032446 31 42 jeql L306 ! 866: 861 00032448 L9994: ! 867: 862 00032448 # { ! 868: 863 00032448 # errcnt++; /* bump the error count */ ! 869: 864 00032448 6d effffff916 incl _errcnt ! 870: 865 0003244E # if ( prt_error ) ! 871: 866 0003244E 5d effffff910 tstl _prt_error ! 872: 867 00032454 31 0d jeql L307 ! 873: 868 00032456 # print_pipe17_er("Cache Data, 1 NOP"); ! 874: 869 00032456 .data 1 ! 875: 870 00000d85 * L308: ! 876: 871 00000d85 * 436163686520446174612C203 .ascii "Cache Data, 1 NOP\0" ! 877: 1204E4F5000 ! 878: 872 00000d97 * .text ! 879: 873 00032456 dd 8f00000d85 pushl $L308 ! 880: 874 0003245C fe 08 ef00000455 callf $8,_print_pipe17_er ! 881: 875 00032463 # if ( halt_flg ) /* halt on error? */ ! 882: 876 00032463 L307: ! 883: 877 00032463 5d effffff8fb tstl _halt_flg ! 884: 878 00032469 31 0d jeql L309 ! 885: 879 0003246B # pipe17_er_hlt( subtest ); ! 886: 880 0003246B dd effffff8f3 pushl _subtest ! 887: 881 00032471 fe 08 ef0000058e callf $8,_pipe17_er_hlt ! 888: 882 00032478 # if ( loop_on_err ) { ! 889: 883 00032478 L309: ! 890: 884 00032478 5d effffff8e6 tstl _loop_on_err ! 891: 885 0003247E 31 0a jeql L310 ! 892: 886 00032480 # force_loop = TRUE; /* set the force loop flag */ ! 893: 887 00032480 0d 01 effffff8dd movl $1,_force_loop ! 894: 888 00032487 # asm("brw _pipe17_6_lp1"); /* and loop */ ! 895: 889 00032487 13 ff7f brw _pipe17_6_lp1 ! 896: 890 0003248A # } ! 897: 891 0003248A # } /* end of compare error */ ! 898: 892 0003248A L310: ! 899: 893 0003248A # } while( index++ < max_cvld_1_index ); ! 900: 894 0003248A L306: ! 901: 895 0003248A L303: ! 902: 896 0003248A 0d effffff8d4 50 movl _index,r0 ! 903: 897 00032491 6d effffff8cd incl _index ! 904: 898 00032497 1d 50 effffff8c6 cmpl r0,_max_cvld_1_index ! 905: 899 0003249E 81 03 13 ff18 jlss L304 ! 906: 900 000324A3 L302: ! 907: 901 000324A3 # } /* end of subtest 6 */ ! 908: 902 000324A3 40 ret#2 ! 909: 903 000324A4 .set L298,0x0 ! 910: 904 000324A4 L300: ! 911: 905 000324A4 13 ff08 jbr L301 ! 912: 906 000324A7 .data ! 913: 907 00000d20 * .text ! 914: 908 000324A7 00 .align 1 ! 915: 909 000324A8 .globl _pipe17_7 ! 916: 910 000324A8 _pipe17_7: ! 917: 911 000324A8 0000 .word L311 ! 918: 912 000324AA # ! 919: 913 000324AA # ! 920: 914 000324AA # ! 921: 915 000324AA # ! 922: 916 000324AA # ! 923: 917 000324AA # ! 924: 918 000324AA # ! 925: 919 000324AA # ! 926: 920 000324AA # /************************************************************************ ! 927: 921 000324AA # * ! 928: 922 000324AA # * SUBTEST 7 ! 929: 923 000324AA # * data in cache, 2 NO-OPs ! 930: 924 000324AA # * ! 931: 925 000324AA # ************************************************************************/ ! 932: 926 000324AA # pipe17_7() ! 933: 927 000324AA # { ! 934: 928 000324AA 13 00f8 jbr L313 ! 935: 929 000324AD L314: ! 936: 930 000324AD # force_loop = FALSE; /* clear the force_loop flg */ ! 937: 931 000324AD 4d effffff8b1 clrl _force_loop ! 938: 932 000324B3 # index = 0; ! 939: 933 000324B3 4d effffff8ab clrl _index ! 940: 934 000324B9 # do ! 941: 935 000324B9 L317: ! 942: 936 000324B9 # { ! 943: 937 000324B9 # sgl_value_1 = cvld_1_data[index].ld; /* get the operand */ ! 944: 938 000324B9 5c 0c effffff8a4 50 mull3 $12,_index,r0 ! 945: 939 000324C1 0d e000000000 effffff898 movl _cvld_1_data(r0),_sgl_value_1 ! 946: 940 000324CC # dbl_value_1.m = 0x40800000; /* set the '1.0' operand */ ! 947: 941 000324CC 0d 8f40800000 effffff88d movl $1082130432,_dbl_value_1 ! 948: 942 000324D7 # dbl_value_1.l = 0; ! 949: 943 000324D7 4d effffff88b clrl _dbl_value_1+4 ! 950: 944 000324DD # dbl_value_2.m = 0; /* set the '0.0' operand */ ! 951: 945 000324DD 4d effffff881 clrl _dbl_value_2 ! 952: 946 000324E3 # dbl_value_2.l = 0; ! 953: 947 000324E3 4d effffff87f clrl _dbl_value_2+4 ! 954: 948 000324E9 # dbl_expected = cvld_1_data[index].exp; /* get the expected results */ ! 955: 949 000324E9 5c 0c effffff874 50 mull3 $12,_index,r0 ! 956: 950 000324F1 0c 8f00000004 50 addl2 $_cvld_1_data+4,r0 ! 957: 951 000324F8 0d a004 effffff868 movl 4(r0),_dbl_expected+4 ! 958: 952 00032500 0d 60 effffff85d movl (r0),_dbl_expected ! 959: 953 00032507 # /* ! 960: 954 00032507 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 961: 955 00032507 # * The force loop flag is set after the first error. ! 962: 956 00032507 # */ ! 963: 957 00032507 # asm("_pipe17_7_lp1:"); ! 964: 958 00032507 _pipe17_7_lp1: ! 965: 959 00032507 # asm("cvld _sgl_value_1"); /* convert the int. ( op ) */ ! 966: 960 00032507 77 effffff857 cvld _sgl_value_1 ! 967: 961 0003250D # asm("nop"); ! 968: 962 0003250D 10 nop ! 969: 963 0003250E # asm("nop"); ! 970: 964 0003250E 10 nop ! 971: 965 0003250F # asm("addd _dbl_value_2"); /* add a '0.0' ( 0 ) */ ! 972: 966 0003250F c7 effffff84f addd _dbl_value_2 ! 973: 967 00032515 # asm("nop"); ! 974: 968 00032515 10 nop ! 975: 969 00032516 # asm("nop"); ! 976: 970 00032516 10 nop ! 977: 971 00032517 # asm("muld _dbl_value_1"); /* multiply by 1.0 ( 0 ) */ ! 978: 972 00032517 e7 effffff847 muld _dbl_value_1 ! 979: 973 0003251D # asm("nop"); ! 980: 974 0003251D 10 nop ! 981: 975 0003251E # asm("nop"); ! 982: 976 0003251E 10 nop ! 983: 977 0003251F # asm("std _dbl_st_acc"); /* store the result (-op ) */ ! 984: 978 0003251F 27 effffff83f std _dbl_st_acc ! 985: 979 00032525 # if( force_loop ) ! 986: 980 00032525 5d effffff839 tstl _force_loop ! 987: 981 0003252B 31 02 jeql L318 ! 988: 982 0003252D # asm("brb _pipe17_7_lp1");; /* run the loop again */ ! 989: 983 0003252D 11 d8 brb _pipe17_7_lp1 ! 990: 984 0003252F L318: ! 991: 985 0003252F # /* ! 992: 986 0003252F # * verify the results ! 993: 987 0003252F # */ ! 994: 988 0003252F # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */ ! 995: 989 0003252F # (dbl_st_acc.l != dbl_expected.l) ) ! 996: 990 0003252F 1d effffff82f effffff82a cmpl _dbl_st_acc,_dbl_expected ! 997: 991 0003253A 21 0d jneq L9993 ! 998: 992 0003253C 1d effffff826 effffff821 cmpl _dbl_st_acc+4,_dbl_expected+4 ! 999: 993 00032547 31 42 jeql L319 ! 1000: 994 00032549 L9993: ! 1001: 995 00032549 # { ! 1002: 996 00032549 # errcnt++; /* bump the error count */ ! 1003: 997 00032549 6d effffff815 incl _errcnt ! 1004: 998 0003254F # if ( prt_error ) ! 1005: 999 0003254F 5d effffff80f tstl _prt_error ! 1006: 1000 00032555 31 0d jeql L320 ! 1007: 1001 00032557 # print_pipe17_er("Cache Data, 2 NOPs"); ! 1008: 1002 00032557 .data 1 ! 1009: 1003 00000d97 * L321: ! 1010: 1004 00000d97 * 436163686520446174612C203 .ascii "Cache Data, 2 NOPs\0" ! 1011: 2204E4F507300 ! 1012: 1005 00000daa * .text ! 1013: 1006 00032557 dd 8f00000d97 pushl $L321 ! 1014: 1007 0003255D fe 08 ef00000354 callf $8,_print_pipe17_er ! 1015: 1008 00032564 # if ( halt_flg ) /* halt on error? */ ! 1016: 1009 00032564 L320: ! 1017: 1010 00032564 5d effffff7fa tstl _halt_flg ! 1018: 1011 0003256A 31 0d jeql L322 ! 1019: 1012 0003256C # pipe17_er_hlt( subtest ); ! 1020: 1013 0003256C dd effffff7f2 pushl _subtest ! 1021: 1014 00032572 fe 08 ef0000048d callf $8,_pipe17_er_hlt ! 1022: 1015 00032579 # if ( loop_on_err ) { ! 1023: 1016 00032579 L322: ! 1024: 1017 00032579 5d effffff7e5 tstl _loop_on_err ! 1025: 1018 0003257F 31 0a jeql L323 ! 1026: 1019 00032581 # force_loop = TRUE; /* set the force loop flag */ ! 1027: 1020 00032581 0d 01 effffff7dc movl $1,_force_loop ! 1028: 1021 00032588 # asm("brw _pipe17_7_lp1"); /* and loop */ ! 1029: 1022 00032588 13 ff7c brw _pipe17_7_lp1 ! 1030: 1023 0003258B # } ! 1031: 1024 0003258B # } /* end of compare error */ ! 1032: 1025 0003258B L323: ! 1033: 1026 0003258B # } while( index++ < max_cvld_1_index ); ! 1034: 1027 0003258B L319: ! 1035: 1028 0003258B L316: ! 1036: 1029 0003258B 0d effffff7d3 50 movl _index,r0 ! 1037: 1030 00032592 6d effffff7cc incl _index ! 1038: 1031 00032598 1d 50 effffff7c5 cmpl r0,_max_cvld_1_index ! 1039: 1032 0003259F 81 03 13 ff15 jlss L317 ! 1040: 1033 000325A4 L315: ! 1041: 1034 000325A4 # } /* end of subtest 7 */ ! 1042: 1035 000325A4 40 ret#2 ! 1043: 1036 000325A5 .set L311,0x0 ! 1044: 1037 000325A5 L313: ! 1045: 1038 000325A5 13 ff05 jbr L314 ! 1046: 1039 000325A8 .data ! 1047: 1040 00000d20 * .text ! 1048: 1041 000325A8 .align 1 ! 1049: 1042 000325A8 .globl _pipe17_8 ! 1050: 1043 000325A8 _pipe17_8: ! 1051: 1044 000325A8 0000 .word L324 ! 1052: 1045 000325AA # ! 1053: 1046 000325AA # ! 1054: 1047 000325AA # ! 1055: 1048 000325AA # ! 1056: 1049 000325AA # ! 1057: 1050 000325AA # ! 1058: 1051 000325AA # ! 1059: 1052 000325AA # /************************************************************************ ! 1060: 1053 000325AA # * ! 1061: 1054 000325AA # * SUBTEST 8 ! 1062: 1055 000325AA # * data in cache, 3 NO-OPs ! 1063: 1056 000325AA # * ! 1064: 1057 000325AA # ************************************************************************/ ! 1065: 1058 000325AA # pipe17_8() ! 1066: 1059 000325AA # { ! 1067: 1060 000325AA 13 00fb jbr L326 ! 1068: 1061 000325AD L327: ! 1069: 1062 000325AD # force_loop = FALSE; /* clear the force_loop flg */ ! 1070: 1063 000325AD 4d effffff7b1 clrl _force_loop ! 1071: 1064 000325B3 # index = 0; ! 1072: 1065 000325B3 4d effffff7ab clrl _index ! 1073: 1066 000325B9 # do ! 1074: 1067 000325B9 L330: ! 1075: 1068 000325B9 # { ! 1076: 1069 000325B9 # sgl_value_1 = cvld_1_data[index].ld; /* get the operand */ ! 1077: 1070 000325B9 5c 0c effffff7a4 50 mull3 $12,_index,r0 ! 1078: 1071 000325C1 0d e000000000 effffff798 movl _cvld_1_data(r0),_sgl_value_1 ! 1079: 1072 000325CC # dbl_value_1.m = 0x40800000; /* set the '1.0' operand */ ! 1080: 1073 000325CC 0d 8f40800000 effffff78d movl $1082130432,_dbl_value_1 ! 1081: 1074 000325D7 # dbl_value_1.l = 0; ! 1082: 1075 000325D7 4d effffff78b clrl _dbl_value_1+4 ! 1083: 1076 000325DD # dbl_value_2.m = 0; /* set the '0.0' operand */ ! 1084: 1077 000325DD 4d effffff781 clrl _dbl_value_2 ! 1085: 1078 000325E3 # dbl_value_2.l = 0; ! 1086: 1079 000325E3 4d effffff77f clrl _dbl_value_2+4 ! 1087: 1080 000325E9 # dbl_expected = cvld_1_data[index].exp; /* get the expected results */ ! 1088: 1081 000325E9 5c 0c effffff774 50 mull3 $12,_index,r0 ! 1089: 1082 000325F1 0c 8f00000004 50 addl2 $_cvld_1_data+4,r0 ! 1090: 1083 000325F8 0d a004 effffff768 movl 4(r0),_dbl_expected+4 ! 1091: 1084 00032600 0d 60 effffff75d movl (r0),_dbl_expected ! 1092: 1085 00032607 # /* ! 1093: 1086 00032607 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 1094: 1087 00032607 # * The force loop flag is set after the first error. ! 1095: 1088 00032607 # */ ! 1096: 1089 00032607 # asm("_pipe17_8_lp1:"); ! 1097: 1090 00032607 _pipe17_8_lp1: ! 1098: 1091 00032607 # asm("cvld _sgl_value_1"); /* convert the int. ( op ) */ ! 1099: 1092 00032607 77 effffff757 cvld _sgl_value_1 ! 1100: 1093 0003260D # asm("nop"); ! 1101: 1094 0003260D 10 nop ! 1102: 1095 0003260E # asm("nop"); ! 1103: 1096 0003260E 10 nop ! 1104: 1097 0003260F # asm("nop"); ! 1105: 1098 0003260F 10 nop ! 1106: 1099 00032610 # asm("addd _dbl_value_2"); /* add a '0.0' ( 0 ) */ ! 1107: 1100 00032610 c7 effffff74e addd _dbl_value_2 ! 1108: 1101 00032616 # asm("nop"); ! 1109: 1102 00032616 10 nop ! 1110: 1103 00032617 # asm("nop"); ! 1111: 1104 00032617 10 nop ! 1112: 1105 00032618 # asm("nop"); ! 1113: 1106 00032618 10 nop ! 1114: 1107 00032619 # asm("muld _dbl_value_1"); /* multiply by 1.0 ( 0 ) */ ! 1115: 1108 00032619 e7 effffff745 muld _dbl_value_1 ! 1116: 1109 0003261F # asm("nop"); ! 1117: 1110 0003261F 10 nop ! 1118: 1111 00032620 # asm("nop"); ! 1119: 1112 00032620 10 nop ! 1120: 1113 00032621 # asm("nop"); ! 1121: 1114 00032621 10 nop ! 1122: 1115 00032622 # asm("std _dbl_st_acc"); /* store the result (-op ) */ ! 1123: 1116 00032622 27 effffff73c std _dbl_st_acc ! 1124: 1117 00032628 # if( force_loop ) ! 1125: 1118 00032628 5d effffff736 tstl _force_loop ! 1126: 1119 0003262E 31 02 jeql L331 ! 1127: 1120 00032630 # asm("brb _pipe17_8_lp1");; /* run the loop again */ ! 1128: 1121 00032630 11 d5 brb _pipe17_8_lp1 ! 1129: 1122 00032632 L331: ! 1130: 1123 00032632 # /* ! 1131: 1124 00032632 # * verify the results ! 1132: 1125 00032632 # */ ! 1133: 1126 00032632 # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */ ! 1134: 1127 00032632 # (dbl_st_acc.l != dbl_expected.l) ) ! 1135: 1128 00032632 1d effffff72c effffff727 cmpl _dbl_st_acc,_dbl_expected ! 1136: 1129 0003263D 21 0d jneq L9992 ! 1137: 1130 0003263F 1d effffff723 effffff71e cmpl _dbl_st_acc+4,_dbl_expected+4 ! 1138: 1131 0003264A 31 42 jeql L332 ! 1139: 1132 0003264C L9992: ! 1140: 1133 0003264C # { ! 1141: 1134 0003264C # errcnt++; /* bump the error count */ ! 1142: 1135 0003264C 6d effffff712 incl _errcnt ! 1143: 1136 00032652 # if ( prt_error ) ! 1144: 1137 00032652 5d effffff70c tstl _prt_error ! 1145: 1138 00032658 31 0d jeql L333 ! 1146: 1139 0003265A # print_pipe17_er("Cache Data, 3 NOPs"); ! 1147: 1140 0003265A .data 1 ! 1148: 1141 00000daa * L334: ! 1149: 1142 00000daa * 436163686520446174612C203 .ascii "Cache Data, 3 NOPs\0" ! 1150: 3204E4F507300 ! 1151: 1143 00000dbd * .text ! 1152: 1144 0003265A dd 8f00000daa pushl $L334 ! 1153: 1145 00032660 fe 08 ef00000251 callf $8,_print_pipe17_er ! 1154: 1146 00032667 # if ( halt_flg ) /* halt on error? */ ! 1155: 1147 00032667 L333: ! 1156: 1148 00032667 5d effffff6f7 tstl _halt_flg ! 1157: 1149 0003266D 31 0d jeql L335 ! 1158: 1150 0003266F # pipe17_er_hlt( subtest ); ! 1159: 1151 0003266F dd effffff6ef pushl _subtest ! 1160: 1152 00032675 fe 08 ef0000038a callf $8,_pipe17_er_hlt ! 1161: 1153 0003267C # if ( loop_on_err ) { ! 1162: 1154 0003267C L335: ! 1163: 1155 0003267C 5d effffff6e2 tstl _loop_on_err ! 1164: 1156 00032682 31 0a jeql L336 ! 1165: 1157 00032684 # force_loop = TRUE; /* set the force loop flag */ ! 1166: 1158 00032684 0d 01 effffff6d9 movl $1,_force_loop ! 1167: 1159 0003268B # asm("brw _pipe17_8_lp1"); /* and loop */ ! 1168: 1160 0003268B 13 ff79 brw _pipe17_8_lp1 ! 1169: 1161 0003268E # } ! 1170: 1162 0003268E # } /* end of compare error */ ! 1171: 1163 0003268E L336: ! 1172: 1164 0003268E # } while( index++ < max_cvld_1_index ); ! 1173: 1165 0003268E L332: ! 1174: 1166 0003268E L329: ! 1175: 1167 0003268E 0d effffff6d0 50 movl _index,r0 ! 1176: 1168 00032695 6d effffff6c9 incl _index ! 1177: 1169 0003269B 1d 50 effffff6c2 cmpl r0,_max_cvld_1_index ! 1178: 1170 000326A2 81 03 13 ff12 jlss L330 ! 1179: 1171 000326A7 L328: ! 1180: 1172 000326A7 # } /* end of subtest 8 */ ! 1181: 1173 000326A7 40 ret#2 ! 1182: 1174 000326A8 .set L324,0x0 ! 1183: 1175 000326A8 L326: ! 1184: 1176 000326A8 13 ff02 jbr L327 ! 1185: 1177 000326AB .data ! 1186: 1178 00000d20 * .text ! 1187: 1179 000326AB 00 .align 1 ! 1188: 1180 000326AC .globl _pipe17_9 ! 1189: 1181 000326AC _pipe17_9: ! 1190: 1182 000326AC 0000 .word L337 ! 1191: 1183 000326AE # ! 1192: 1184 000326AE # ! 1193: 1185 000326AE # ! 1194: 1186 000326AE # ! 1195: 1187 000326AE # ! 1196: 1188 000326AE # ! 1197: 1189 000326AE # ! 1198: 1190 000326AE # /****************************************************************************** ! 1199: 1191 000326AE # * ! 1200: 1192 000326AE # * SUBTEST 9 ! 1201: 1193 000326AE # * ! 1202: 1194 000326AE # * Get the data via the FRAME POINTER ( indexed ) ! 1203: 1195 000326AE # * ! 1204: 1196 000326AE # * ADDRESSES OF DATA OPERANDS INDEX DATA ! 1205: 1197 000326AE # * pointer_data,-4 (FP+32) 4 the STF result goes here ! 1206: 1198 000326AE # * pointer_data-8,-12 (FP+24) 3 < '0.0' data > ! 1207: 1199 000326AE # * pointer_data-16 (FP+20) 5(sgl) <operand data> ! 1208: 1200 000326AE # * pointer_data-20 (FP+16) 2 < unused > ! 1209: 1201 000326AE # * pointer_data-24,-28 (FP+8 ) 1 < '1.0' data > ! 1210: 1202 000326AE # * pointer_data-32,-36 ( FP ) 0 point the frame pointer here ! 1211: 1203 000326AE # * ! 1212: 1204 000326AE # * NOTE: The double precision instructions are using Quad Word indexing. ! 1213: 1205 000326AE # * The Convert Long To Double uses longword indexing. ! 1214: 1206 000326AE # ******************************************************************************/ ! 1215: 1207 000326AE # pipe17_9() ! 1216: 1208 000326AE # { ! 1217: 1209 000326AE 13 0204 jbr L339 ! 1218: 1210 000326B1 L340: ! 1219: 1211 000326B1 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */ ! 1220: 1212 000326B1 ed 6d effffff6ac moval (r13),_pre_event_fp ! 1221: 1213 000326B8 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */ ! 1222: 1214 000326B8 ed 6e effffff6a5 moval (r14),_pre_event_sp ! 1223: 1215 000326BF # force_loop = FALSE; /* clear force_loop flag */ ! 1224: 1216 000326BF 4d effffff69f clrl _force_loop ! 1225: 1217 000326C5 # index = 0; ! 1226: 1218 000326C5 4d effffff699 clrl _index ! 1227: 1219 000326CB # do ! 1228: 1220 000326CB L343: ! 1229: 1221 000326CB # { ! 1230: 1222 000326CB # sgl_value_1 = cvld_1_data[index].ld; /* get the integer operand */ ! 1231: 1223 000326CB 5c 0c effffff692 50 mull3 $12,_index,r0 ! 1232: 1224 000326D3 0d e000000000 effffff686 movl _cvld_1_data(r0),_sgl_value_1 ! 1233: 1225 000326DE # sgl_value_7 = 0x40800000; /* get MSW of '1.0' */ ! 1234: 1226 000326DE 0d 8f40800000 effffff67b movl $1082130432,_sgl_value_7 ! 1235: 1227 000326E9 # sgl_value_8 = 0; /* get a 0 */ ! 1236: 1228 000326E9 4d effffff675 clrl _sgl_value_8 ! 1237: 1229 000326EF # dbl_expected = cvld_1_data[index].exp; /* get expected results */ ! 1238: 1230 000326EF 5c 0c effffff66e 50 mull3 $12,_index,r0 ! 1239: 1231 000326F7 0c 8f00000004 50 addl2 $_cvld_1_data+4,r0 ! 1240: 1232 000326FE 0d a004 effffff662 movl 4(r0),_dbl_expected+4 ! 1241: 1233 00032706 0d 60 effffff657 movl (r0),_dbl_expected ! 1242: 1234 0003270D # /* ! 1243: 1235 0003270D # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 1244: 1236 0003270D # * The force loop flag is set after the first error. ! 1245: 1237 0003270D # */ ! 1246: 1238 0003270D # asm("_pipe17_9_lp1:"); ! 1247: 1239 0003270D _pipe17_9_lp1: ! 1248: 1240 0003270D # asm("moval _pointer_data,_sgl_value_9");/* get store data's addr */ ! 1249: 1241 0003270D ed effffff651 effffff64c moval _pointer_data,_sgl_value_9 ! 1250: 1242 00032718 # sgl_value_9 -= 8; ! 1251: 1243 00032718 2c 08 effffff645 subl2 $8,_sgl_value_9 ! 1252: 1244 0003271F # asm("movl _sgl_value_8,*_sgl_value_9"); /* set the '0.0's LSW */ ! 1253: 1245 0003271F 0d effffff63f fffffff63a movl _sgl_value_8,*_sgl_value_9 ! 1254: 1246 0003272A # sgl_value_9 -= 4; ! 1255: 1247 0003272A 2c 04 effffff633 subl2 $4,_sgl_value_9 ! 1256: 1248 00032731 # asm("movl _sgl_value_8,*_sgl_value_9"); /* set the '0.0's MSW */ ! 1257: 1249 00032731 0d effffff62d fffffff628 movl _sgl_value_8,*_sgl_value_9 ! 1258: 1250 0003273C # sgl_value_9 -= 4; ! 1259: 1251 0003273C 2c 04 effffff621 subl2 $4,_sgl_value_9 ! 1260: 1252 00032743 # asm("movl _sgl_value_1,*_sgl_value_9"); /* set the integer op. */ ! 1261: 1253 00032743 0d effffff61b fffffff616 movl _sgl_value_1,*_sgl_value_9 ! 1262: 1254 0003274E # sgl_value_9 -= 4; ! 1263: 1255 0003274E 2c 04 effffff60f subl2 $4,_sgl_value_9 ! 1264: 1256 00032755 # asm("movl _sgl_value_8,*_sgl_value_9"); /* < unused data addr. > */ ! 1265: 1257 00032755 0d effffff609 fffffff604 movl _sgl_value_8,*_sgl_value_9 ! 1266: 1258 00032760 # sgl_value_9 -= 4; ! 1267: 1259 00032760 2c 04 effffff5fd subl2 $4,_sgl_value_9 ! 1268: 1260 00032767 # asm("movl _sgl_value_8,*_sgl_value_9"); /* set the '1.0's LSW */ ! 1269: 1261 00032767 0d effffff5f7 fffffff5f2 movl _sgl_value_8,*_sgl_value_9 ! 1270: 1262 00032772 # sgl_value_9 -= 4; ! 1271: 1263 00032772 2c 04 effffff5eb subl2 $4,_sgl_value_9 ! 1272: 1264 00032779 # asm("movl _sgl_value_7,*_sgl_value_9"); /* set the '1.0's MSW */ ! 1273: 1265 00032779 0d effffff5e5 fffffff5e0 movl _sgl_value_7,*_sgl_value_9 ! 1274: 1266 00032784 # sgl_value_9 -= 8; /* get the FP addr to use */ ! 1275: 1267 00032784 2c 08 effffff5d9 subl2 $8,_sgl_value_9 ! 1276: 1268 0003278B # asm("movl _sgl_value_9,r13"); /* set the FRAME POINTER */ ! 1277: 1269 0003278B 0d effffff5d3 5d movl _sgl_value_9,r13 ! 1278: 1270 00032792 # asm("movl $1,r2"); /* r2 index = 1 quadwords */ ! 1279: 1271 00032792 0d 01 52 movl $1,r2 ! 1280: 1272 00032795 # asm("movl $3,r3"); /* r3 index = 3 quadwords */ ! 1281: 1273 00032795 0d 03 53 movl $3,r3 ! 1282: 1274 00032798 # asm("movl $4,r4"); /* r4 index = 4 quadwords */ ! 1283: 1275 00032798 0d 04 54 movl $4,r4 ! 1284: 1276 0003279B # asm("movl $5,r5"); /* r5 index = 5 longwords */ ! 1285: 1277 0003279B 0d 05 55 movl $5,r5 ! 1286: 1278 0003279E # asm("cvld (r13)[r5]"); /* convert the int. ( op ) */ ! 1287: 1279 0003279E 77 456d cvld (r13)[r5] ! 1288: 1280 000327A1 # asm("addd (r13)[r3]"); /* add a '0.0' ( op ) */ ! 1289: 1281 000327A1 c7 436d addd (r13)[r3] ! 1290: 1282 000327A4 # asm("muld (r13)[r2]"); /* multiply by '1.0' ( op ) */ ! 1291: 1283 000327A4 e7 426d muld (r13)[r2] ! 1292: 1284 000327A7 # asm("std (r13)[r4]"); /* store the result ( op ) */ ! 1293: 1285 000327A7 27 446d std (r13)[r4] ! 1294: 1286 000327AA # if( force_loop ) ! 1295: 1287 000327AA 5d effffff5b4 tstl _force_loop ! 1296: 1288 000327B0 31 03 jeql L344 ! 1297: 1289 000327B2 # asm("brw _pipe17_9_lp1");; /* run the loop again */ ! 1298: 1290 000327B2 13 ff58 brw _pipe17_9_lp1 ! 1299: 1291 000327B5 L344: ! 1300: 1292 000327B5 # /* ! 1301: 1293 000327B5 # * verify the results ! 1302: 1294 000327B5 # */ ! 1303: 1295 000327B5 # asm("moval (r13),_sgl_value_10"); /* save the frame pointer */ ! 1304: 1296 000327B5 ed 6d effffff5a8 moval (r13),_sgl_value_10 ! 1305: 1297 000327BC # asm("movl _pointer_data,_sgl_value_4"); /* save the LSW stored */ ! 1306: 1298 000327BC 0d effffff5a2 effffff59d movl _pointer_data,_sgl_value_4 ! 1307: 1299 000327C7 # asm("movl _pointer_data-4,_sgl_value_3"); /* and the MSW */ ! 1308: 1300 000327C7 0d effffff593 effffff592 movl _pointer_data-4,_sgl_value_3 ! 1309: 1301 000327D2 # if( (sgl_value_3 != dbl_expected.m) || /* verify the result... */ ! 1310: 1302 000327D2 # (sgl_value_4 != dbl_expected.l) || /* verify the result... */ ! 1311: 1303 000327D2 # (sgl_value_10 != sgl_value_9) ) /* ... and the final FP */ ! 1312: 1304 000327D2 1d effffff58c effffff587 cmpl _sgl_value_3,_dbl_expected ! 1313: 1305 000327DD 21 1d jneq L9991 ! 1314: 1306 000327DF 1d effffff57f effffff57e cmpl _sgl_value_4,_dbl_expected+4 ! 1315: 1307 000327EA 21 10 jneq L9991 ! 1316: 1308 000327EC 1d effffff572 effffff56d cmpl _sgl_value_10,_sgl_value_9 ! 1317: 1309 000327F7 21 03 13 0091 jeql L345 ! 1318: 1310 000327FC L9991: ! 1319: 1311 000327FC # { ! 1320: 1312 000327FC # asm("movl _pre_event_fp,r13"); /* restore frame pointer */ ! 1321: 1313 000327FC 0d effffff562 5d movl _pre_event_fp,r13 ! 1322: 1314 00032803 # asm("movl _pre_event_sp,r14"); /* restore stack pointer */ ! 1323: 1315 00032803 0d effffff55b 5e movl _pre_event_sp,r14 ! 1324: 1316 0003280A # errcnt++; /* bump the error count */ ! 1325: 1317 0003280A 6d effffff554 incl _errcnt ! 1326: 1318 00032810 # if ( prt_error ) { ! 1327: 1319 00032810 5d effffff54e tstl _prt_error ! 1328: 1320 00032816 31 4e jeql L346 ! 1329: 1321 00032818 # print_pipe17_er("indexed FP addressing"); ! 1330: 1322 00032818 .data 1 ! 1331: 1323 00000dbd * L347: ! 1332: 1324 00000dbd * 696E646578656420465020616 .ascii "indexed FP addressing\0" ! 1333: 46472657373696E6700 ! 1334: 1325 00000dd3 * .text ! 1335: 1326 00032818 dd 8f00000dbd pushl $L347 ! 1336: 1327 0003281E fe 08 ef00000093 callf $8,_print_pipe17_er ! 1337: 1328 00032825 # writes("final Frame Pointer = "); ! 1338: 1329 00032825 .data 1 ! 1339: 1330 00000dd3 * L348: ! 1340: 1331 00000dd3 * 66696E616C204672616D65205 .ascii "final Frame Pointer = \0" ! 1341: 06F696E746572203D2000 ! 1342: 1332 00000dea * .text ! 1343: 1333 00032825 dd 8f00000dd3 pushl $L348 ! 1344: 1334 0003282B fe 08 effffff532 callf $8,_writes ! 1345: 1335 00032832 # write32h( sgl_value_10 ); ! 1346: 1336 00032832 dd effffff52c pushl _sgl_value_10 ! 1347: 1337 00032838 fe 08 effffff525 callf $8,_write32h ! 1348: 1338 0003283F # writes(", expected FP = "); ! 1349: 1339 0003283F .data 1 ! 1350: 1340 00000dea * L350: ! 1351: 1341 00000dea * 2C20206578706563746564204 .ascii ", expected FP = \0" ! 1352: 650203D2000 ! 1353: 1342 00000dfc * .text ! 1354: 1343 0003283F dd 8f00000dea pushl $L350 ! 1355: 1344 00032845 fe 08 effffff518 callf $8,_writes ! 1356: 1345 0003284C # write32h( sgl_value_9 ); ! 1357: 1346 0003284C dd effffff512 pushl _sgl_value_9 ! 1358: 1347 00032852 fe 08 effffff50b callf $8,_write32h ! 1359: 1348 00032859 # writes("\n"); ! 1360: 1349 00032859 .data 1 ! 1361: 1350 00000dfc * L351: ! 1362: 1351 00000dfc * 0A00 .ascii "\12\0" ! 1363: 1352 00000dfe * .text ! 1364: 1353 00032859 dd 8f00000dfc pushl $L351 ! 1365: 1354 0003285F fe 08 effffff4fe callf $8,_writes ! 1366: 1355 00032866 # } ! 1367: 1356 00032866 # if ( halt_flg ) /* halt on error? */ ! 1368: 1357 00032866 L346: ! 1369: 1358 00032866 5d effffff4f8 tstl _halt_flg ! 1370: 1359 0003286C 31 0d jeql L352 ! 1371: 1360 0003286E # pipe17_er_hlt( subtest ); ! 1372: 1361 0003286E dd effffff4f0 pushl _subtest ! 1373: 1362 00032874 fe 08 ef0000018b callf $8,_pipe17_er_hlt ! 1374: 1363 0003287B # if ( loop_on_err ) { ! 1375: 1364 0003287B L352: ! 1376: 1365 0003287B 5d effffff4e3 tstl _loop_on_err ! 1377: 1366 00032881 31 0a jeql L353 ! 1378: 1367 00032883 # force_loop = TRUE; /* set the force loop flag */ ! 1379: 1368 00032883 0d 01 effffff4da movl $1,_force_loop ! 1380: 1369 0003288A # asm("brw _pipe17_9_lp1"); /* and loop */ ! 1381: 1370 0003288A 13 fe80 brw _pipe17_9_lp1 ! 1382: 1371 0003288D # } ! 1383: 1372 0003288D # } /* end of compare error */ ! 1384: 1373 0003288D L353: ! 1385: 1374 0003288D # } while( index++ < max_cvld_1_index ); ! 1386: 1375 0003288D L345: ! 1387: 1376 0003288D L342: ! 1388: 1377 0003288D 0d effffff4d1 50 movl _index,r0 ! 1389: 1378 00032894 6d effffff4ca incl _index ! 1390: 1379 0003289A 1d 50 effffff4c3 cmpl r0,_max_cvld_1_index ! 1391: 1380 000328A1 81 03 13 fe25 jlss L343 ! 1392: 1381 000328A6 L341: ! 1393: 1382 000328A6 # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */ ! 1394: 1383 000328A6 0d effffff4b8 5d movl _pre_event_fp,r13 ! 1395: 1384 000328AD # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */ ! 1396: 1385 000328AD 0d effffff4b1 5e movl _pre_event_sp,r14 ! 1397: 1386 000328B4 # } /* end of subtest 9 */ ! 1398: 1387 000328B4 40 ret#2 ! 1399: 1388 000328B5 .set L337,0x0 ! 1400: 1389 000328B5 L339: ! 1401: 1390 000328B5 13 fdf9 jbr L340 ! 1402: 1391 000328B8 .data ! 1403: 1392 00000d20 * .text ! 1404: 1393 000328B8 .align 1 ! 1405: 1394 000328B8 .globl _print_pipe17_er ! 1406: 1395 000328B8 _print_pipe17_er: ! 1407: 1396 000328B8 0000 .word L354 ! 1408: 1397 000328BA # ! 1409: 1398 000328BA # ! 1410: 1399 000328BA # /****************************************************************************** ! 1411: 1400 000328BA # * ! 1412: 1401 000328BA # * ERROR ROUTINE ! 1413: 1402 000328BA # * ! 1414: 1403 000328BA # * print an error in the following form ! 1415: 1404 000328BA # * ! 1416: 1405 000328BA # *operand = xxxxxxxx xxxxxxxx, final Acc = xxxxxxxx xxxxxxxx, index = dd ! 1417: 1406 000328BA # * expected Acc = xxxxxxxx xxxxxxxx ! 1418: 1407 000328BA # * ! 1419: 1408 000328BA # ******************************************************************************/ ! 1420: 1409 000328BA # print_pipe17_er(msg) ! 1421: 1410 000328BA # char *msg; ! 1422: 1411 000328BA # { ! 1423: 1412 000328BA 13 0145 jbr L356 ! 1424: 1413 000328BD L357: ! 1425: 1414 000328BD # writes("\n"); /* start a new print line */ ! 1426: 1415 000328BD .data 1 ! 1427: 1416 00000dfe * L358: ! 1428: 1417 00000dfe * 0A00 .ascii "\12\0" ! 1429: 1418 00000e00 * .text ! 1430: 1419 000328BD dd 8f00000dfe pushl $L358 ! 1431: 1420 000328C3 fe 08 effffff49a callf $8,_writes ! 1432: 1421 000328CA # writes("cycle: "); ! 1433: 1422 000328CA .data 1 ! 1434: 1423 00000e00 * L359: ! 1435: 1424 00000e00 * 6379636C653A2000 .ascii "cycle: \0" ! 1436: 1425 00000e08 * .text ! 1437: 1426 000328CA dd 8f00000e00 pushl $L359 ! 1438: 1427 000328D0 fe 08 effffff48d callf $8,_writes ! 1439: 1428 000328D7 # writed( cycle ); ! 1440: 1429 000328D7 dd effffff487 pushl _cycle ! 1441: 1430 000328DD fe 08 effffff480 callf $8,_writed ! 1442: 1431 000328E4 # writes(" test "); ! 1443: 1432 000328E4 .data 1 ! 1444: 1433 00000e08 * L361: ! 1445: 1434 00000e08 * 20746573742000 .ascii " test \0" ! 1446: 1435 00000e0f * .text ! 1447: 1436 000328E4 dd 8f00000e08 pushl $L361 ! 1448: 1437 000328EA fe 08 effffff473 callf $8,_writes ! 1449: 1438 000328F1 # writed( test_no ); ! 1450: 1439 000328F1 dd effffff46d pushl _test_no ! 1451: 1440 000328F7 fe 08 effffff466 callf $8,_writed ! 1452: 1441 000328FE # writes(" (Pipe 17), subtest "); ! 1453: 1442 000328FE .data 1 ! 1454: 1443 00000e0f * L362: ! 1455: 1444 00000e0f * 20202850697065203137292C2 .ascii " (Pipe 17), subtest \0" ! 1456: 0737562746573742000 ! 1457: 1445 00000e25 * .text ! 1458: 1446 000328FE dd 8f00000e0f pushl $L362 ! 1459: 1447 00032904 fe 08 effffff459 callf $8,_writes ! 1460: 1448 0003290B # writed( subtest ); ! 1461: 1449 0003290B dd effffff453 pushl _subtest ! 1462: 1450 00032911 fe 08 effffff44c callf $8,_writed ! 1463: 1451 00032918 # writes(" error - "); ! 1464: 1452 00032918 .data 1 ! 1465: 1453 00000e25 * L363: ! 1466: 1454 00000e25 * 206572726F72202D2000 .ascii " error - \0" ! 1467: 1455 00000e2f * .text ! 1468: 1456 00032918 dd 8f00000e25 pushl $L363 ! 1469: 1457 0003291E fe 08 effffff43f callf $8,_writes ! 1470: 1458 00032925 # writes( msg ); ! 1471: 1459 00032925 dd ad04 pushl 4(fp) ! 1472: 1460 00032928 fe 08 effffff435 callf $8,_writes ! 1473: 1461 0003292F # writec('\n'); ! 1474: 1462 0003292F dd 0a pushl $10 ! 1475: 1463 00032931 fe 08 effffff42c callf $8,_writec ! 1476: 1464 00032938 # writes(" CVLD(op), ADDD(0.0), MULD(1.0), STD\n"); ! 1477: 1465 00032938 .data 1 ! 1478: 1466 00000e2f * L365: ! 1479: 1467 00000e2f * 2043564C44286F70292C20414 .ascii " CVLD(op), ADDD(0.0), MULD(1.0), STD\12\0" ! 1480: 4444428302E30292C204D554C ! 1481: 4428312E30292C205354440A0 ! 1482: 0 ! 1483: 1468 00000e55 * .text ! 1484: 1469 00032938 dd 8f00000e2f pushl $L365 ! 1485: 1470 0003293E fe 08 effffff41f callf $8,_writes ! 1486: 1471 00032945 # writes("operand = "); ! 1487: 1472 00032945 .data 1 ! 1488: 1473 00000e55 * L366: ! 1489: 1474 00000e55 * 6F706572616E64203D2000 .ascii "operand = \0" ! 1490: 1475 00000e60 * .text ! 1491: 1476 00032945 dd 8f00000e55 pushl $L366 ! 1492: 1477 0003294B fe 08 effffff412 callf $8,_writes ! 1493: 1478 00032952 # write32h( dbl_ld_acc.m ); ! 1494: 1479 00032952 dd effffff40c pushl _dbl_ld_acc ! 1495: 1480 00032958 fe 08 effffff405 callf $8,_write32h ! 1496: 1481 0003295F # writec(' '); ! 1497: 1482 0003295F dd 20 pushl $32 ! 1498: 1483 00032961 fe 08 effffff3fc callf $8,_writec ! 1499: 1484 00032968 # write32h( dbl_ld_acc.l ); ! 1500: 1485 00032968 dd effffff3fa pushl _dbl_ld_acc+4 ! 1501: 1486 0003296E fe 08 effffff3ef callf $8,_write32h ! 1502: 1487 00032975 # writes(", final Acc = "); ! 1503: 1488 00032975 .data 1 ! 1504: 1489 00000e60 * L367: ! 1505: 1490 00000e60 * 2C20202066696E616C2041636 .ascii ", final Acc = \0" ! 1506: 3203D2000 ! 1507: 1491 00000e71 * .text ! 1508: 1492 00032975 dd 8f00000e60 pushl $L367 ! 1509: 1493 0003297B fe 08 effffff3e2 callf $8,_writes ! 1510: 1494 00032982 # write32h( dbl_st_acc.m ); ! 1511: 1495 00032982 dd effffff3dc pushl _dbl_st_acc ! 1512: 1496 00032988 fe 08 effffff3d5 callf $8,_write32h ! 1513: 1497 0003298F # writec(' '); ! 1514: 1498 0003298F dd 20 pushl $32 ! 1515: 1499 00032991 fe 08 effffff3cc callf $8,_writec ! 1516: 1500 00032998 # write32h( dbl_st_acc.l ); ! 1517: 1501 00032998 dd effffff3ca pushl _dbl_st_acc+4 ! 1518: 1502 0003299E fe 08 effffff3bf callf $8,_write32h ! 1519: 1503 000329A5 # writes(", index = "); ! 1520: 1504 000329A5 .data 1 ! 1521: 1505 00000e71 * L368: ! 1522: 1506 00000e71 * 2C202020696E646578203D200 .ascii ", index = \0" ! 1523: 0 ! 1524: 1507 00000e7e * .text ! 1525: 1508 000329A5 dd 8f00000e71 pushl $L368 ! 1526: 1509 000329AB fe 08 effffff3b2 callf $8,_writes ! 1527: 1510 000329B2 # writed( index ); ! 1528: 1511 000329B2 dd effffff3ac pushl _index ! 1529: 1512 000329B8 fe 08 effffff3a5 callf $8,_writed ! 1530: 1513 000329BF # writec('\n'); ! 1531: 1514 000329BF dd 0a pushl $10 ! 1532: 1515 000329C1 fe 08 effffff39c callf $8,_writec ! 1533: 1516 000329C8 # writes(" expected Acc = "); ! 1534: 1517 000329C8 .data 1 ! 1535: 1518 00000e7e * L369: ! 1536: 1519 00000e7e * 2020202020202020202020202 .ascii " expected Acc = \0" ! 1537: 0202020202020202020202020 ! 1538: 2020206578706563746564204 ! 1539: 16363203D2000 ! 1540: 1520 00000eaa * .text ! 1541: 1521 000329C8 dd 8f00000e7e pushl $L369 ! 1542: 1522 000329CE fe 08 effffff38f callf $8,_writes ! 1543: 1523 000329D5 # write32h( dbl_expected.m ); ! 1544: 1524 000329D5 dd effffff389 pushl _dbl_expected ! 1545: 1525 000329DB fe 08 effffff382 callf $8,_write32h ! 1546: 1526 000329E2 # writec(' '); ! 1547: 1527 000329E2 dd 20 pushl $32 ! 1548: 1528 000329E4 fe 08 effffff379 callf $8,_writec ! 1549: 1529 000329EB # write32h( dbl_expected.l ); ! 1550: 1530 000329EB dd effffff377 pushl _dbl_expected+4 ! 1551: 1531 000329F1 fe 08 effffff36c callf $8,_write32h ! 1552: 1532 000329F8 # writec('\n'); ! 1553: 1533 000329F8 dd 0a pushl $10 ! 1554: 1534 000329FA fe 08 effffff363 callf $8,_writec ! 1555: 1535 00032A01 # } ! 1556: 1536 00032A01 40 ret#2 ! 1557: 1537 00032A02 .set L354,0x0 ! 1558: 1538 00032A02 L356: ! 1559: 1539 00032A02 13 feb8 jbr L357 ! 1560: 1540 00032A05 .data ! 1561: 1541 00000d20 * .text ! 1562: 1542 00032A05 00 .align 1 ! 1563: 1543 00032A06 .globl _pipe17_er_hlt ! 1564: 1544 00032A06 _pipe17_er_hlt: ! 1565: 1545 00032A06 0000 .word L370 ! 1566: 1546 00032A08 # ! 1567: 1547 00032A08 # ! 1568: 1548 00032A08 # ! 1569: 1549 00032A08 # ! 1570: 1550 00032A08 # ! 1571: 1551 00032A08 # /****************************************************************************** ! 1572: 1552 00032A08 # * ! 1573: 1553 00032A08 # * HALT ON ERROR ROUTINE ! 1574: 1554 00032A08 # * ! 1575: 1555 00032A08 # * halt with the necessary information saved in the registers ! 1576: 1556 00032A08 # * ! 1577: 1557 00032A08 # ******************************************************************************/ ! 1578: 1558 00032A08 # pipe17_er_hlt( subtest ) ! 1579: 1559 00032A08 # int subtest; ! 1580: 1560 00032A08 # { ! 1581: 1561 00032A08 11 75 jbr L372 ! 1582: 1562 00032A0A L373: ! 1583: 1563 00032A0A # sgl_value_3 = dbl_st_acc.m; ! 1584: 1564 00032A0A 0d effffff354 effffff34f movl _dbl_st_acc,_sgl_value_3 ! 1585: 1565 00032A15 # sgl_value_4 = dbl_st_acc.l; ! 1586: 1566 00032A15 0d effffff34d effffff344 movl _dbl_st_acc+4,_sgl_value_4 ! 1587: 1567 00032A20 # asm("movl _test_no,r0"); /* r0 = test number */ ! 1588: 1568 00032A20 0d effffff33e 50 movl _test_no,r0 ! 1589: 1569 00032A27 # asm("movl _subtest,r1"); /* r1 = subtest number */ ! 1590: 1570 00032A27 0d effffff337 51 movl _subtest,r1 ! 1591: 1571 00032A2E # asm("movl $1,r2"); /* r2 = error code */ ! 1592: 1572 00032A2E 0d 01 52 movl $1,r2 ! 1593: 1573 00032A31 # asm("movl _cycle,r3"); /* r3 = cycle count */ ! 1594: 1574 00032A31 0d effffff32d 53 movl _cycle,r3 ! 1595: 1575 00032A38 # asm("movl _sgl_value_1,r4"); /* r4 = MSW operand loaded */ ! 1596: 1576 00032A38 0d effffff326 54 movl _sgl_value_1,r4 ! 1597: 1577 00032A3F # asm("movl _sgl_value_2,r5"); /* r5 = LSW operand loaded */ ! 1598: 1578 00032A3F 0d effffff31f 55 movl _sgl_value_2,r5 ! 1599: 1579 00032A46 # asm("movl _sgl_value_3,r6"); /* r6 = MSW operand stored */ ! 1600: 1580 00032A46 0d effffff318 56 movl _sgl_value_3,r6 ! 1601: 1581 00032A4D # asm("movl _sgl_value_4,r7"); /* r7 = LSW operand stored */ ! 1602: 1582 00032A4D 0d effffff311 57 movl _sgl_value_4,r7 ! 1603: 1583 00032A54 # asm("movl _sgl_value_5,r8"); /* r8 = MSW operand expect */ ! 1604: 1584 00032A54 0d effffff30a 58 movl _sgl_value_5,r8 ! 1605: 1585 00032A5B # asm("movl _sgl_value_6,r9"); /* r9 = LSW operand expect */ ! 1606: 1586 00032A5B 0d effffff303 59 movl _sgl_value_6,r9 ! 1607: 1587 00032A62 # asm("movl _index,r10"); /* r10 = data index */ ! 1608: 1588 00032A62 0d effffff2fc 5a movl _index,r10 ! 1609: 1589 00032A69 # if( subtest == 9 ) { ! 1610: 1590 00032A69 1d ad04 09 cmpl 4(fp),$9 ! 1611: 1591 00032A6D 21 0e jneq L374 ! 1612: 1592 00032A6F # asm("movl _sgl_value_10,r11"); /* r11 = final FP value */ ! 1613: 1593 00032A6F 0d effffff2ef 5b movl _sgl_value_10,r11 ! 1614: 1594 00032A76 # asm("movl _sgl_value_9,r12"); /* r12 = expected FP value */ ! 1615: 1595 00032A76 0d effffff2e8 5c movl _sgl_value_9,r12 ! 1616: 1596 00032A7D # }; ! 1617: 1597 00032A7D L374: ! 1618: 1598 00032A7D # asm(".globl _pipe17_1_hlt"); ! 1619: 1599 00032A7D .globl _pipe17_1_hlt ! 1620: 1600 00032A7D # asm("_pipe17_1_hlt:"); /* PC after the halt */ ! 1621: 1601 00032A7D _pipe17_1_hlt: ! 1622: 1602 00032A7D # asm("halt"); /* HALT ... */ ! 1623: 1603 00032A7D 00 halt ! 1624: 1604 00032A7E # } /* end of halt on error */ ! 1625: 1605 00032A7E 40 ret#2 ! 1626: 1606 00032A7F .set L370,0x0 ! 1627: 1607 00032A7F L372: ! 1628: 1608 00032A7F 11 89 jbr L373 ! 1629: 1609 00032A81 .data ! 1630: 1609 000647E5 .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.