![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe13.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 pipe13.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 00000db4 * .text
4: 4 00000000 .align 1
5: 5 00000000 .globl _pipe_13
6: 6 00000000 _pipe_13:
7: 7 0002E288 0000 .word L215
8: 8 0002E28A # #include "fpp_defs.h"
9: 9 0002E28A #
10: 10 0002E28A #
11: 11 0002E28A # /*****************************************************************************
12: 12 0002E28A # *
13: 13 0002E28A # * DBL PIPELINE TEST #13 MONITOR
14: 14 0002E28A # *
15: 15 0002E28A # * This test will do:
16: 16 0002E28A # *
17: 17 0002E28A # * LDD(1) MULD(x) MULD(1) SUBD(x) ADDD(x) STD
18: 18 0002E28A # *
19: 19 0002E28A # * where the x's are the LDD data patterns.
20: 20 0002E28A # *****************************************************************************/
21: 21 0002E28A # pipe_13()
22: 22 0002E28A # {
23: 23 0002E28A 13 009b jbr L217
24: 24 0002E28D L218:
25: 25 0002E28D # asm(".globl _pipeline_13_t");
26: 26 0002E28D .globl _pipeline_13_t
27: 27 0002E28D # asm("_pipeline_13_t:"); /* entry address */
28: 28 0002E28D _pipeline_13_t:
29: 29 0002E28D # if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */
30: 30 0002E28D 1d effffffff5 01 cmpl _cycle,$1
31: 31 0002E294 21 15 jneq L219
32: 32 0002E296 5d efffffffec tstl _prt_hdrs
33: 33 0002E29C 31 0d jeql L219
34: 34 0002E29E # {
35: 35 0002E29E # writes(" PIPE_13");
36: 36 0002E29E .data 1
37: 37 00000db4 * L221:
38: 38 00000db4 * 20504950455F313300 .ascii " PIPE_13\0"
39: 39 00000dbd * .text
40: 40 0002E29E dd 8f00000db4 pushl $L221
41: 41 0002E2A4 fe 08 efffffffdd callf $8,_writes
42: 42 0002E2AB # }
43: 43 0002E2AB # subtest = 1;
44: 44 0002E2AB L219:
45: 45 0002E2AB 0d 01 efffffffd6 movl $1,_subtest
46: 46 0002E2B2 # pipe13_1(); /* data in REGs, no NOPs */
47: 47 0002E2B2 fe 04 ef00000073 callf $4,_pipe13_1
48: 48 0002E2B9 # subtest++; /* increment subtest num */
49: 49 0002E2B9 6d efffffffc9 incl _subtest
50: 50 0002E2BF # pipe13_2(); /* data in REGs, 1 NOP */
51: 51 0002E2BF fe 04 ef000001a2 callf $4,_pipe13_2
52: 52 0002E2C6 # subtest++; /* increment subtest num */
53: 53 0002E2C6 6d efffffffbc incl _subtest
54: 54 0002E2CC # pipe13_3(); /* data in REGs, 2 NOPs */
55: 55 0002E2CC fe 04 ef000002d5 callf $4,_pipe13_3
56: 56 0002E2D3 # subtest++; /* increment subtest num */
57: 57 0002E2D3 6d efffffffaf incl _subtest
58: 58 0002E2D9 # pipe13_4(); /* data in REGs, 3 NOPs */
59: 59 0002E2D9 fe 04 ef0000040e callf $4,_pipe13_4
60: 60 0002E2E0 # subtest++; /* increment subtest num */
61: 61 0002E2E0 6d efffffffa2 incl _subtest
62: 62 0002E2E6 # pipe13_5(); /* data in CACHE, no NOPs */
63: 63 0002E2E6 fe 04 ef0000054b callf $4,_pipe13_5
64: 64 0002E2ED # subtest++; /* increment subtest num */
65: 65 0002E2ED 6d efffffff95 incl _subtest
66: 66 0002E2F3 # pipe13_6(); /* data in CACHE, 1 NOP */
67: 67 0002E2F3 fe 04 ef00000644 callf $4,_pipe13_6
68: 68 0002E2FA # subtest++; /* increment subtest num */
69: 69 0002E2FA 6d efffffff88 incl _subtest
70: 70 0002E300 # pipe13_7(); /* data in CACHE, 2 NOPs */
71: 71 0002E300 fe 04 ef00000741 callf $4,_pipe13_7
72: 72 0002E307 # subtest++; /* increment subtest num */
73: 73 0002E307 6d efffffff7b incl _subtest
74: 74 0002E30D # pipe13_8(); /* data in CACHE, 3 NOPs */
75: 75 0002E30D fe 04 ef00000844 callf $4,_pipe13_8
76: 76 0002E314 # subtest++; /* increment subtest num */
77: 77 0002E314 6d efffffff6e incl _subtest
78: 78 0002E31A # pipe13_9(); /* data via F.P. 0 NOPs */
79: 79 0002E31A fe 04 ef0000094b callf $4,_pipe13_9
80: 80 0002E321 # asm("jmp *return"); /* return to the test monitor */
81: 81 0002E321 71 ffffffff61 jmp *return
82: 82 0002E327 # }
83: 83 0002E327 40 ret#2
84: 84 0002E328 .set L215,0x0
85: 85 0002E328 L217:
86: 86 0002E328 13 ff62 jbr L218
87: 87 0002E32B .data
88: 88 00000db4 * .text
89: 89 0002E32B 00 .align 1
90: 90 0002E32C .globl _pipe13_1
91: 91 0002E32C _pipe13_1:
92: 92 0002E32C 0000 .word L231
93: 93 0002E32E #
94: 94 0002E32E #
95: 95 0002E32E #
96: 96 0002E32E #
97: 97 0002E32E #
98: 98 0002E32E #
99: 99 0002E32E #
100: 100 0002E32E # /************************************************************************
101: 101 0002E32E # *
102: 102 0002E32E # * SUBTEST 1
103: 103 0002E32E # * data in registers, no NO-OPs
104: 104 0002E32E # *
105: 105 0002E32E # ************************************************************************/
106: 106 0002E32E # pipe13_1()
107: 107 0002E32E # {
108: 108 0002E32E 13 0133 jbr L233
109: 109 0002E331 L234:
110: 110 0002E331 # force_loop = FALSE; /* clear the force_loop flg */
111: 111 0002E331 4d efffffff51 clrl _force_loop
112: 112 0002E337 # index = 0;
113: 113 0002E337 4d efffffff4b clrl _index
114: 114 0002E33D # do
115: 115 0002E33D L237:
116: 116 0002E33D # {
117: 117 0002E33D # sgl_value_1 = ldd_1_data[index].ld.m; /* get the operand's MSW */
118: 118 0002E33D 0d efffffff45 50 movl _index,r0
119: 119 0002E344 48 04 50 50 shll $4,r0,r0
120: 120 0002E348 0d e000000000 efffffff35 movl _ldd_1_data(r0),_sgl_value_1
121: 121 0002E353 # sgl_value_2 = ldd_1_data[index].ld.l; /* get the operand's MSW */
122: 122 0002E353 0d efffffff2f 50 movl _index,r0
123: 123 0002E35A 48 04 50 50 shll $4,r0,r0
124: 124 0002E35E 0d e000000004 efffffff1f movl _ldd_1_data+4(r0),_sgl_value_2
125: 125 0002E369 # sgl_value_7 = 0x40800000; /* get a dbl precision 1.0 */
126: 126 0002E369 0d 8f40800000 efffffff14 movl $1082130432,_sgl_value_7
127: 127 0002E374 # sgl_value_8 = 0;
128: 128 0002E374 4d efffffff0e clrl _sgl_value_8
129: 129 0002E37A # dbl_expected = ldd_1_data[index].exp; /* get the expected results */
130: 130 0002E37A 48 04 efffffff07 50 shll $4,_index,r0
131: 131 0002E382 0c 8f00000008 50 addl2 $_ldd_1_data+8,r0
132: 132 0002E389 0d a004 effffffefb movl 4(r0),_dbl_expected+4
133: 133 0002E391 0d 60 effffffef0 movl (r0),_dbl_expected
134: 134 0002E398 # /*
135: 135 0002E398 # * If LOOP ON ERROR is set, this is the loop for this subtest.
136: 136 0002E398 # * The force loop flag is set after the first error.
137: 137 0002E398 # */
138: 138 0002E398 # asm("_pipe13_1_lp1:");
139: 139 0002E398 _pipe13_1_lp1:
140: 140 0002E398 # asm("movl _sgl_value_1,r4"); /* move the data to r4/r5 */
141: 141 0002E398 0d effffffeea 54 movl _sgl_value_1,r4
142: 142 0002E39F # asm("movl _sgl_value_2,r5");
143: 143 0002E39F 0d effffffee3 55 movl _sgl_value_2,r5
144: 144 0002E3A6 # asm("movl _sgl_value_7,r2"); /* move a '1.0' to r2/r3 */
145: 145 0002E3A6 0d effffffedc 52 movl _sgl_value_7,r2
146: 146 0002E3AD # asm("movl _sgl_value_8,r3");
147: 147 0002E3AD 0d effffffed5 53 movl _sgl_value_8,r3
148: 148 0002E3B4 # asm("ldd r2"); /* load a '1.0' ( 1 ) */
149: 149 0002E3B4 07 52 ldd r2
150: 150 0002E3B6 # asm("muld r4"); /* multiply by op. ( op ) */
151: 151 0002E3B6 e7 54 muld r4
152: 152 0002E3B8 # asm("muld r2"); /* multiply by 1.0 ( op ) */
153: 153 0002E3B8 e7 52 muld r2
154: 154 0002E3BA # asm("subd r4"); /* subtract the op. ( 0 ) */
155: 155 0002E3BA d7 54 subd r4
156: 156 0002E3BC # asm("addd r4"); /* add the op. ( op ) */
157: 157 0002E3BC c7 54 addd r4
158: 158 0002E3BE # asm("std r6"); /* store the result ( op ) */
159: 159 0002E3BE 27 56 std r6
160: 160 0002E3C0 # if( force_loop )
161: 161 0002E3C0 5d effffffec2 tstl _force_loop
162: 162 0002E3C6 31 02 jeql L238
163: 163 0002E3C8 # asm("brb _pipe13_1_lp1");; /* run the loop again */
164: 164 0002E3C8 11 ce brb _pipe13_1_lp1
165: 165 0002E3CA L238:
166: 166 0002E3CA # /*
167: 167 0002E3CA # * verify the results
168: 168 0002E3CA # */
169: 169 0002E3CA # asm("movl r6,_sgl_value_3"); /* get the result */
170: 170 0002E3CA 0d 56 effffffeb7 movl r6,_sgl_value_3
171: 171 0002E3D1 # asm("movl r7,_sgl_value_4");
172: 172 0002E3D1 0d 57 effffffeb0 movl r7,_sgl_value_4
173: 173 0002E3D8 # dbl_st_acc.m = sgl_value_3;
174: 174 0002E3D8 0d effffffeaa effffffea5 movl _sgl_value_3,_dbl_st_acc
175: 175 0002E3E3 # dbl_st_acc.l = sgl_value_4;
176: 176 0002E3E3 0d effffffe9f effffffe9e movl _sgl_value_4,_dbl_st_acc+4
177: 177 0002E3EE # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
178: 178 0002E3EE # (dbl_st_acc.l != dbl_expected.l) )
179: 179 0002E3EE 1d effffffe94 effffffe8f cmpl _dbl_st_acc,_dbl_expected
180: 180 0002E3F9 21 0d jneq L9999
181: 181 0002E3FB 1d effffffe8b effffffe86 cmpl _dbl_st_acc+4,_dbl_expected+4
182: 182 0002E406 31 42 jeql L239
183: 183 0002E408 L9999:
184: 184 0002E408 # {
185: 185 0002E408 # errcnt++; /* bump the error count */
186: 186 0002E408 6d effffffe7a incl _errcnt
187: 187 0002E40E # if ( prt_error )
188: 188 0002E40E 5d effffffe74 tstl _prt_error
189: 189 0002E414 31 0d jeql L240
190: 190 0002E416 # print_pipe13_er("Reg. Data, no NOPs");
191: 191 0002E416 .data 1
192: 192 00000dbd * L242:
193: 193 00000dbd * 5265672E20446174612C206E6 .ascii "Reg. Data, no NOPs\0"
194: F204E4F507300
195: 194 00000dd0 * .text
196: 195 0002E416 dd 8f00000dbd pushl $L242
197: 196 0002E41C fe 08 ef00000a4d callf $8,_print_pipe13_er
198: 197 0002E423 # if ( halt_flg )
199: 198 0002E423 L240:
200: 199 0002E423 5d effffffe5f tstl _halt_flg
201: 200 0002E429 31 0d jeql L243
202: 201 0002E42B # pipe13_er_hlt( subtest );
203: 202 0002E42B dd effffffe57 pushl _subtest
204: 203 0002E431 fe 08 ef00000b86 callf $8,_pipe13_er_hlt
205: 204 0002E438 # if ( loop_on_err ) {
206: 205 0002E438 L243:
207: 206 0002E438 5d effffffe4a tstl _loop_on_err
208: 207 0002E43E 31 0a jeql L245
209: 208 0002E440 # force_loop = TRUE; /* set the force loop flag */
210: 209 0002E440 0d 01 effffffe41 movl $1,_force_loop
211: 210 0002E447 # asm("brw _pipe13_1_lp1"); /* and loop */
212: 211 0002E447 13 ff4e brw _pipe13_1_lp1
213: 212 0002E44A # }
214: 213 0002E44A # } /* end of compare error */
215: 214 0002E44A L245:
216: 215 0002E44A # } while( index++ < max_ldd_1_index );
217: 216 0002E44A L239:
218: 217 0002E44A L236:
219: 218 0002E44A 0d effffffe38 50 movl _index,r0
220: 219 0002E451 6d effffffe31 incl _index
221: 220 0002E457 1d 50 effffffe2a cmpl r0,_max_ldd_1_index
222: 221 0002E45E 81 03 13 feda jlss L237
223: 222 0002E463 L235:
224: 223 0002E463 # } /* end of subtest 1 */
225: 224 0002E463 40 ret#2
226: 225 0002E464 .set L231,0x0
227: 226 0002E464 L233:
228: 227 0002E464 13 feca jbr L234
229: 228 0002E467 .data
230: 229 00000db4 * .text
231: 230 0002E467 00 .align 1
232: 231 0002E468 .globl _pipe13_2
233: 232 0002E468 _pipe13_2:
234: 233 0002E468 0000 .word L246
235: 234 0002E46A #
236: 235 0002E46A #
237: 236 0002E46A #
238: 237 0002E46A #
239: 238 0002E46A #
240: 239 0002E46A #
241: 240 0002E46A #
242: 241 0002E46A # /************************************************************************
243: 242 0002E46A # *
244: 243 0002E46A # * SUBTEST 2
245: 244 0002E46A # * data in registers, 1 NO-OP
246: 245 0002E46A # *
247: 246 0002E46A # ************************************************************************/
248: 247 0002E46A # pipe13_2()
249: 248 0002E46A # {
250: 249 0002E46A 13 0138 jbr L248
251: 250 0002E46D L249:
252: 251 0002E46D # force_loop = FALSE; /* clear the force_loop flg */
253: 252 0002E46D 4d effffffe15 clrl _force_loop
254: 253 0002E473 # index = 0;
255: 254 0002E473 4d effffffe0f clrl _index
256: 255 0002E479 # do
257: 256 0002E479 L252:
258: 257 0002E479 # {
259: 258 0002E479 # sgl_value_1 = ldd_1_data[index].ld.m; /* get the operand's MSW */
260: 259 0002E479 0d effffffe09 50 movl _index,r0
261: 260 0002E480 48 04 50 50 shll $4,r0,r0
262: 261 0002E484 0d e000000000 effffffdf9 movl _ldd_1_data(r0),_sgl_value_1
263: 262 0002E48F # sgl_value_2 = ldd_1_data[index].ld.l; /* get the operand's MSW */
264: 263 0002E48F 0d effffffdf3 50 movl _index,r0
265: 264 0002E496 48 04 50 50 shll $4,r0,r0
266: 265 0002E49A 0d e000000004 effffffde3 movl _ldd_1_data+4(r0),_sgl_value_2
267: 266 0002E4A5 # sgl_value_7 = 0x40800000; /* get a dbl precision 1.0 */
268: 267 0002E4A5 0d 8f40800000 effffffdd8 movl $1082130432,_sgl_value_7
269: 268 0002E4B0 # sgl_value_8 = 0;
270: 269 0002E4B0 4d effffffdd2 clrl _sgl_value_8
271: 270 0002E4B6 # dbl_expected = ldd_1_data[index].exp; /* get the expected results */
272: 271 0002E4B6 48 04 effffffdcb 50 shll $4,_index,r0
273: 272 0002E4BE 0c 8f00000008 50 addl2 $_ldd_1_data+8,r0
274: 273 0002E4C5 0d a004 effffffdbf movl 4(r0),_dbl_expected+4
275: 274 0002E4CD 0d 60 effffffdb4 movl (r0),_dbl_expected
276: 275 0002E4D4 # /*
277: 276 0002E4D4 # * If LOOP ON ERROR is set, this is the loop for this subtest.
278: 277 0002E4D4 # * The force loop flag is set after the first error.
279: 278 0002E4D4 # */
280: 279 0002E4D4 # asm("_pipe13_2_lp1:");
281: 280 0002E4D4 _pipe13_2_lp1:
282: 281 0002E4D4 # asm("movl _sgl_value_1,r4"); /* move the data to r4/r5 */
283: 282 0002E4D4 0d effffffdae 54 movl _sgl_value_1,r4
284: 283 0002E4DB # asm("movl _sgl_value_2,r5");
285: 284 0002E4DB 0d effffffda7 55 movl _sgl_value_2,r5
286: 285 0002E4E2 # asm("movl _sgl_value_7,r2"); /* move a '1.0' to r4/r5 */
287: 286 0002E4E2 0d effffffda0 52 movl _sgl_value_7,r2
288: 287 0002E4E9 # asm("movl _sgl_value_8,r3");
289: 288 0002E4E9 0d effffffd99 53 movl _sgl_value_8,r3
290: 289 0002E4F0 # asm("ldd r2"); /* load a '1.0' ( 1 ) */
291: 290 0002E4F0 07 52 ldd r2
292: 291 0002E4F2 # asm("nop");
293: 292 0002E4F2 10 nop
294: 293 0002E4F3 # asm("muld r4"); /* multiply by op. ( op ) */
295: 294 0002E4F3 e7 54 muld r4
296: 295 0002E4F5 # asm("nop");
297: 296 0002E4F5 10 nop
298: 297 0002E4F6 # asm("muld r2"); /* multiply by 1.0 ( op ) */
299: 298 0002E4F6 e7 52 muld r2
300: 299 0002E4F8 # asm("nop");
301: 300 0002E4F8 10 nop
302: 301 0002E4F9 # asm("subd r4"); /* subtract the op. ( 0 ) */
303: 302 0002E4F9 d7 54 subd r4
304: 303 0002E4FB # asm("nop");
305: 304 0002E4FB 10 nop
306: 305 0002E4FC # asm("addd r4"); /* add the op. ( op ) */
307: 306 0002E4FC c7 54 addd r4
308: 307 0002E4FE # asm("nop");
309: 308 0002E4FE 10 nop
310: 309 0002E4FF # asm("std r6"); /* store the result ( op ) */
311: 310 0002E4FF 27 56 std r6
312: 311 0002E501 # if( force_loop )
313: 312 0002E501 5d effffffd81 tstl _force_loop
314: 313 0002E507 31 02 jeql L253
315: 314 0002E509 # asm("brb _pipe13_2_lp1");; /* run the loop again */
316: 315 0002E509 11 c9 brb _pipe13_2_lp1
317: 316 0002E50B L253:
318: 317 0002E50B # /*
319: 318 0002E50B # * verify the results
320: 319 0002E50B # */
321: 320 0002E50B # asm("movl r6,_sgl_value_3"); /* get the result */
322: 321 0002E50B 0d 56 effffffd76 movl r6,_sgl_value_3
323: 322 0002E512 # asm("movl r7,_sgl_value_4");
324: 323 0002E512 0d 57 effffffd6f movl r7,_sgl_value_4
325: 324 0002E519 # dbl_st_acc.m = sgl_value_3;
326: 325 0002E519 0d effffffd69 effffffd64 movl _sgl_value_3,_dbl_st_acc
327: 326 0002E524 # dbl_st_acc.l = sgl_value_4;
328: 327 0002E524 0d effffffd5e effffffd5d movl _sgl_value_4,_dbl_st_acc+4
329: 328 0002E52F # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
330: 329 0002E52F # (dbl_st_acc.l != dbl_expected.l) )
331: 330 0002E52F 1d effffffd53 effffffd4e cmpl _dbl_st_acc,_dbl_expected
332: 331 0002E53A 21 0d jneq L9998
333: 332 0002E53C 1d effffffd4a effffffd45 cmpl _dbl_st_acc+4,_dbl_expected+4
334: 333 0002E547 31 42 jeql L254
335: 334 0002E549 L9998:
336: 335 0002E549 # {
337: 336 0002E549 # errcnt++; /* bump the error count */
338: 337 0002E549 6d effffffd39 incl _errcnt
339: 338 0002E54F # if ( prt_error )
340: 339 0002E54F 5d effffffd33 tstl _prt_error
341: 340 0002E555 31 0d jeql L255
342: 341 0002E557 # print_pipe13_er("Reg. Data, 1 NOP");
343: 342 0002E557 .data 1
344: 343 00000dd0 * L256:
345: 344 00000dd0 * 5265672E20446174612C20312 .ascii "Reg. Data, 1 NOP\0"
346: 04E4F5000
347: 345 00000de1 * .text
348: 346 0002E557 dd 8f00000dd0 pushl $L256
349: 347 0002E55D fe 08 ef0000090c callf $8,_print_pipe13_er
350: 348 0002E564 # if ( halt_flg )
351: 349 0002E564 L255:
352: 350 0002E564 5d effffffd1e tstl _halt_flg
353: 351 0002E56A 31 0d jeql L257
354: 352 0002E56C # pipe13_er_hlt( subtest );
355: 353 0002E56C dd effffffd16 pushl _subtest
356: 354 0002E572 fe 08 ef00000a45 callf $8,_pipe13_er_hlt
357: 355 0002E579 # if ( loop_on_err ) {
358: 356 0002E579 L257:
359: 357 0002E579 5d effffffd09 tstl _loop_on_err
360: 358 0002E57F 31 0a jeql L258
361: 359 0002E581 # force_loop = TRUE; /* set the force loop flag */
362: 360 0002E581 0d 01 effffffd00 movl $1,_force_loop
363: 361 0002E588 # asm("brw _pipe13_2_lp1"); /* and loop */
364: 362 0002E588 13 ff49 brw _pipe13_2_lp1
365: 363 0002E58B # }
366: 364 0002E58B # } /* end of compare error */
367: 365 0002E58B L258:
368: 366 0002E58B # } while( index++ < max_ldd_1_index );
369: 367 0002E58B L254:
370: 368 0002E58B L251:
371: 369 0002E58B 0d effffffcf7 50 movl _index,r0
372: 370 0002E592 6d effffffcf0 incl _index
373: 371 0002E598 1d 50 effffffce9 cmpl r0,_max_ldd_1_index
374: 372 0002E59F 81 03 13 fed5 jlss L252
375: 373 0002E5A4 L250:
376: 374 0002E5A4 # } /* end of subtest 2 */
377: 375 0002E5A4 40 ret#2
378: 376 0002E5A5 .set L246,0x0
379: 377 0002E5A5 L248:
380: 378 0002E5A5 13 fec5 jbr L249
381: 379 0002E5A8 .data
382: 380 00000db4 * .text
383: 381 0002E5A8 .align 1
384: 382 0002E5A8 .globl _pipe13_3
385: 383 0002E5A8 _pipe13_3:
386: 384 0002E5A8 0000 .word L259
387: 385 0002E5AA #
388: 386 0002E5AA #
389: 387 0002E5AA #
390: 388 0002E5AA #
391: 389 0002E5AA #
392: 390 0002E5AA #
393: 391 0002E5AA # /************************************************************************
394: 392 0002E5AA # *
395: 393 0002E5AA # * SUBTEST 3
396: 394 0002E5AA # * data in registers, 2 NO-OPs
397: 395 0002E5AA # *
398: 396 0002E5AA # ************************************************************************/
399: 397 0002E5AA # pipe13_3()
400: 398 0002E5AA # {
401: 399 0002E5AA 13 013d jbr L261
402: 400 0002E5AD L262:
403: 401 0002E5AD # force_loop = FALSE; /* clear the force_loop flg */
404: 402 0002E5AD 4d effffffcd5 clrl _force_loop
405: 403 0002E5B3 # index = 0;
406: 404 0002E5B3 4d effffffccf clrl _index
407: 405 0002E5B9 # do
408: 406 0002E5B9 L265:
409: 407 0002E5B9 # {
410: 408 0002E5B9 # sgl_value_1 = ldd_1_data[index].ld.m; /* get the operand's MSW */
411: 409 0002E5B9 0d effffffcc9 50 movl _index,r0
412: 410 0002E5C0 48 04 50 50 shll $4,r0,r0
413: 411 0002E5C4 0d e000000000 effffffcb9 movl _ldd_1_data(r0),_sgl_value_1
414: 412 0002E5CF # sgl_value_2 = ldd_1_data[index].ld.l; /* get the operand's MSW */
415: 413 0002E5CF 0d effffffcb3 50 movl _index,r0
416: 414 0002E5D6 48 04 50 50 shll $4,r0,r0
417: 415 0002E5DA 0d e000000004 effffffca3 movl _ldd_1_data+4(r0),_sgl_value_2
418: 416 0002E5E5 # sgl_value_7 = 0x40800000; /* get a dbl precision 1.0 */
419: 417 0002E5E5 0d 8f40800000 effffffc98 movl $1082130432,_sgl_value_7
420: 418 0002E5F0 # sgl_value_8 = 0;
421: 419 0002E5F0 4d effffffc92 clrl _sgl_value_8
422: 420 0002E5F6 # dbl_expected = ldd_1_data[index].exp; /* get the expected results */
423: 421 0002E5F6 48 04 effffffc8b 50 shll $4,_index,r0
424: 422 0002E5FE 0c 8f00000008 50 addl2 $_ldd_1_data+8,r0
425: 423 0002E605 0d a004 effffffc7f movl 4(r0),_dbl_expected+4
426: 424 0002E60D 0d 60 effffffc74 movl (r0),_dbl_expected
427: 425 0002E614 # /*
428: 426 0002E614 # * If LOOP ON ERROR is set, this is the loop for this subtest.
429: 427 0002E614 # * The force loop flag is set after the first error.
430: 428 0002E614 # */
431: 429 0002E614 # asm("_pipe13_3_lp1:");
432: 430 0002E614 _pipe13_3_lp1:
433: 431 0002E614 # asm("movl _sgl_value_1,r4"); /* move the data to r4/r5 */
434: 432 0002E614 0d effffffc6e 54 movl _sgl_value_1,r4
435: 433 0002E61B # asm("movl _sgl_value_2,r5");
436: 434 0002E61B 0d effffffc67 55 movl _sgl_value_2,r5
437: 435 0002E622 # asm("movl _sgl_value_7,r2"); /* move a '1.0' to r4/r5 */
438: 436 0002E622 0d effffffc60 52 movl _sgl_value_7,r2
439: 437 0002E629 # asm("movl _sgl_value_8,r3");
440: 438 0002E629 0d effffffc59 53 movl _sgl_value_8,r3
441: 439 0002E630 # asm("ldd r2"); /* load a '1.0' ( 1 ) */
442: 440 0002E630 07 52 ldd r2
443: 441 0002E632 # asm("nop");
444: 442 0002E632 10 nop
445: 443 0002E633 # asm("nop");
446: 444 0002E633 10 nop
447: 445 0002E634 # asm("muld r4"); /* multiply by op. ( op ) */
448: 446 0002E634 e7 54 muld r4
449: 447 0002E636 # asm("nop");
450: 448 0002E636 10 nop
451: 449 0002E637 # asm("nop");
452: 450 0002E637 10 nop
453: 451 0002E638 # asm("muld r2"); /* multiply by 1.0 ( op ) */
454: 452 0002E638 e7 52 muld r2
455: 453 0002E63A # asm("nop");
456: 454 0002E63A 10 nop
457: 455 0002E63B # asm("nop");
458: 456 0002E63B 10 nop
459: 457 0002E63C # asm("subd r4"); /* subtract the op. ( 0 ) */
460: 458 0002E63C d7 54 subd r4
461: 459 0002E63E # asm("nop");
462: 460 0002E63E 10 nop
463: 461 0002E63F # asm("nop");
464: 462 0002E63F 10 nop
465: 463 0002E640 # asm("addd r4"); /* add the op. ( op ) */
466: 464 0002E640 c7 54 addd r4
467: 465 0002E642 # asm("nop");
468: 466 0002E642 10 nop
469: 467 0002E643 # asm("nop");
470: 468 0002E643 10 nop
471: 469 0002E644 # asm("std r6"); /* store the result ( op ) */
472: 470 0002E644 27 56 std r6
473: 471 0002E646 # if( force_loop )
474: 472 0002E646 5d effffffc3c tstl _force_loop
475: 473 0002E64C 31 02 jeql L266
476: 474 0002E64E # asm("brb _pipe13_3_lp1");; /* run the loop again */
477: 475 0002E64E 11 c4 brb _pipe13_3_lp1
478: 476 0002E650 L266:
479: 477 0002E650 # /*
480: 478 0002E650 # * verify the results
481: 479 0002E650 # */
482: 480 0002E650 # asm("movl r6,_sgl_value_3"); /* get the result */
483: 481 0002E650 0d 56 effffffc31 movl r6,_sgl_value_3
484: 482 0002E657 # asm("movl r7,_sgl_value_4");
485: 483 0002E657 0d 57 effffffc2a movl r7,_sgl_value_4
486: 484 0002E65E # dbl_st_acc.m = sgl_value_3;
487: 485 0002E65E 0d effffffc24 effffffc1f movl _sgl_value_3,_dbl_st_acc
488: 486 0002E669 # dbl_st_acc.l = sgl_value_4;
489: 487 0002E669 0d effffffc19 effffffc18 movl _sgl_value_4,_dbl_st_acc+4
490: 488 0002E674 # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
491: 489 0002E674 # (dbl_st_acc.l != dbl_expected.l) )
492: 490 0002E674 1d effffffc0e effffffc09 cmpl _dbl_st_acc,_dbl_expected
493: 491 0002E67F 21 0d jneq L9997
494: 492 0002E681 1d effffffc05 effffffc00 cmpl _dbl_st_acc+4,_dbl_expected+4
495: 493 0002E68C 31 42 jeql L267
496: 494 0002E68E L9997:
497: 495 0002E68E # {
498: 496 0002E68E # errcnt++; /* bump the error count */
499: 497 0002E68E 6d effffffbf4 incl _errcnt
500: 498 0002E694 # if ( prt_error )
501: 499 0002E694 5d effffffbee tstl _prt_error
502: 500 0002E69A 31 0d jeql L268
503: 501 0002E69C # print_pipe13_er("Reg. Data, 2 NOPs");
504: 502 0002E69C .data 1
505: 503 00000de1 * L269:
506: 504 00000de1 * 5265672E20446174612C20322 .ascii "Reg. Data, 2 NOPs\0"
507: 04E4F507300
508: 505 00000df3 * .text
509: 506 0002E69C dd 8f00000de1 pushl $L269
510: 507 0002E6A2 fe 08 ef000007c7 callf $8,_print_pipe13_er
511: 508 0002E6A9 # if ( halt_flg )
512: 509 0002E6A9 L268:
513: 510 0002E6A9 5d effffffbd9 tstl _halt_flg
514: 511 0002E6AF 31 0d jeql L270
515: 512 0002E6B1 # pipe13_er_hlt( subtest );
516: 513 0002E6B1 dd effffffbd1 pushl _subtest
517: 514 0002E6B7 fe 08 ef00000900 callf $8,_pipe13_er_hlt
518: 515 0002E6BE # if ( loop_on_err ) {
519: 516 0002E6BE L270:
520: 517 0002E6BE 5d effffffbc4 tstl _loop_on_err
521: 518 0002E6C4 31 0a jeql L271
522: 519 0002E6C6 # force_loop = TRUE; /* set the force loop flag */
523: 520 0002E6C6 0d 01 effffffbbb movl $1,_force_loop
524: 521 0002E6CD # asm("brw _pipe13_3_lp1"); /* and loop */
525: 522 0002E6CD 13 ff44 brw _pipe13_3_lp1
526: 523 0002E6D0 # }
527: 524 0002E6D0 # } /* end of compare error */
528: 525 0002E6D0 L271:
529: 526 0002E6D0 # } while( index++ < max_ldd_1_index );
530: 527 0002E6D0 L267:
531: 528 0002E6D0 L264:
532: 529 0002E6D0 0d effffffbb2 50 movl _index,r0
533: 530 0002E6D7 6d effffffbab incl _index
534: 531 0002E6DD 1d 50 effffffba4 cmpl r0,_max_ldd_1_index
535: 532 0002E6E4 81 03 13 fed0 jlss L265
536: 533 0002E6E9 L263:
537: 534 0002E6E9 # } /* end of subtest 3 */
538: 535 0002E6E9 40 ret#2
539: 536 0002E6EA .set L259,0x0
540: 537 0002E6EA L261:
541: 538 0002E6EA 13 fec0 jbr L262
542: 539 0002E6ED .data
543: 540 00000db4 * .text
544: 541 0002E6ED 00 .align 1
545: 542 0002E6EE .globl _pipe13_4
546: 543 0002E6EE _pipe13_4:
547: 544 0002E6EE 0000 .word L272
548: 545 0002E6F0 #
549: 546 0002E6F0 #
550: 547 0002E6F0 #
551: 548 0002E6F0 #
552: 549 0002E6F0 #
553: 550 0002E6F0 # /************************************************************************
554: 551 0002E6F0 # *
555: 552 0002E6F0 # * SUBTEST 4
556: 553 0002E6F0 # * data in registers, 3 NO-OPs
557: 554 0002E6F0 # *
558: 555 0002E6F0 # ************************************************************************/
559: 556 0002E6F0 # pipe13_4()
560: 557 0002E6F0 # {
561: 558 0002E6F0 13 0142 jbr L274
562: 559 0002E6F3 L275:
563: 560 0002E6F3 # force_loop = FALSE; /* clear the force_loop flg */
564: 561 0002E6F3 4d effffffb8f clrl _force_loop
565: 562 0002E6F9 # index = 0;
566: 563 0002E6F9 4d effffffb89 clrl _index
567: 564 0002E6FF # do
568: 565 0002E6FF L278:
569: 566 0002E6FF # {
570: 567 0002E6FF # sgl_value_1 = ldd_1_data[index].ld.m; /* get the operand's MSW */
571: 568 0002E6FF 0d effffffb83 50 movl _index,r0
572: 569 0002E706 48 04 50 50 shll $4,r0,r0
573: 570 0002E70A 0d e000000000 effffffb73 movl _ldd_1_data(r0),_sgl_value_1
574: 571 0002E715 # sgl_value_2 = ldd_1_data[index].ld.l; /* get the operand's MSW */
575: 572 0002E715 0d effffffb6d 50 movl _index,r0
576: 573 0002E71C 48 04 50 50 shll $4,r0,r0
577: 574 0002E720 0d e000000004 effffffb5d movl _ldd_1_data+4(r0),_sgl_value_2
578: 575 0002E72B # sgl_value_7 = 0x40800000; /* get a dbl precision 1.0 */
579: 576 0002E72B 0d 8f40800000 effffffb52 movl $1082130432,_sgl_value_7
580: 577 0002E736 # sgl_value_8 = 0;
581: 578 0002E736 4d effffffb4c clrl _sgl_value_8
582: 579 0002E73C # dbl_expected = ldd_1_data[index].exp; /* get the expected results */
583: 580 0002E73C 48 04 effffffb45 50 shll $4,_index,r0
584: 581 0002E744 0c 8f00000008 50 addl2 $_ldd_1_data+8,r0
585: 582 0002E74B 0d a004 effffffb39 movl 4(r0),_dbl_expected+4
586: 583 0002E753 0d 60 effffffb2e movl (r0),_dbl_expected
587: 584 0002E75A # /*
588: 585 0002E75A # * If LOOP ON ERROR is set, this is the loop for this subtest.
589: 586 0002E75A # * The force loop flag is set after the first error.
590: 587 0002E75A # */
591: 588 0002E75A # asm("_pipe13_4_lp1:");
592: 589 0002E75A _pipe13_4_lp1:
593: 590 0002E75A # asm("movl _sgl_value_1,r4"); /* move the data to r4/r5 */
594: 591 0002E75A 0d effffffb28 54 movl _sgl_value_1,r4
595: 592 0002E761 # asm("movl _sgl_value_2,r5");
596: 593 0002E761 0d effffffb21 55 movl _sgl_value_2,r5
597: 594 0002E768 # asm("movl _sgl_value_7,r2"); /* move a '1.0' to r4/r5 */
598: 595 0002E768 0d effffffb1a 52 movl _sgl_value_7,r2
599: 596 0002E76F # asm("movl _sgl_value_8,r3");
600: 597 0002E76F 0d effffffb13 53 movl _sgl_value_8,r3
601: 598 0002E776 # asm("ldd r2"); /* load a '1.0' ( 1 ) */
602: 599 0002E776 07 52 ldd r2
603: 600 0002E778 # asm("nop");
604: 601 0002E778 10 nop
605: 602 0002E779 # asm("nop");
606: 603 0002E779 10 nop
607: 604 0002E77A # asm("nop");
608: 605 0002E77A 10 nop
609: 606 0002E77B # asm("muld r4"); /* multiply by op. ( op ) */
610: 607 0002E77B e7 54 muld r4
611: 608 0002E77D # asm("nop");
612: 609 0002E77D 10 nop
613: 610 0002E77E # asm("nop");
614: 611 0002E77E 10 nop
615: 612 0002E77F # asm("nop");
616: 613 0002E77F 10 nop
617: 614 0002E780 # asm("muld r2"); /* multiply by 1.0 ( op ) */
618: 615 0002E780 e7 52 muld r2
619: 616 0002E782 # asm("nop");
620: 617 0002E782 10 nop
621: 618 0002E783 # asm("nop");
622: 619 0002E783 10 nop
623: 620 0002E784 # asm("nop");
624: 621 0002E784 10 nop
625: 622 0002E785 # asm("subd r4"); /* subtract the op. ( 0 ) */
626: 623 0002E785 d7 54 subd r4
627: 624 0002E787 # asm("nop");
628: 625 0002E787 10 nop
629: 626 0002E788 # asm("nop");
630: 627 0002E788 10 nop
631: 628 0002E789 # asm("nop");
632: 629 0002E789 10 nop
633: 630 0002E78A # asm("addd r4"); /* add the op. ( op ) */
634: 631 0002E78A c7 54 addd r4
635: 632 0002E78C # asm("nop");
636: 633 0002E78C 10 nop
637: 634 0002E78D # asm("nop");
638: 635 0002E78D 10 nop
639: 636 0002E78E # asm("nop");
640: 637 0002E78E 10 nop
641: 638 0002E78F # asm("std r6"); /* store the result ( op ) */
642: 639 0002E78F 27 56 std r6
643: 640 0002E791 # if( force_loop )
644: 641 0002E791 5d effffffaf1 tstl _force_loop
645: 642 0002E797 31 02 jeql L279
646: 643 0002E799 # asm("brb _pipe13_4_lp1");; /* run the loop again */
647: 644 0002E799 11 bf brb _pipe13_4_lp1
648: 645 0002E79B L279:
649: 646 0002E79B # /*
650: 647 0002E79B # * verify the results
651: 648 0002E79B # */
652: 649 0002E79B # asm("movl r6,_sgl_value_3"); /* get the result */
653: 650 0002E79B 0d 56 effffffae6 movl r6,_sgl_value_3
654: 651 0002E7A2 # asm("movl r7,_sgl_value_4");
655: 652 0002E7A2 0d 57 effffffadf movl r7,_sgl_value_4
656: 653 0002E7A9 # dbl_st_acc.m = sgl_value_3;
657: 654 0002E7A9 0d effffffad9 effffffad4 movl _sgl_value_3,_dbl_st_acc
658: 655 0002E7B4 # dbl_st_acc.l = sgl_value_4;
659: 656 0002E7B4 0d efffffface effffffacd movl _sgl_value_4,_dbl_st_acc+4
660: 657 0002E7BF # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
661: 658 0002E7BF # (dbl_st_acc.l != dbl_expected.l) )
662: 659 0002E7BF 1d effffffac3 effffffabe cmpl _dbl_st_acc,_dbl_expected
663: 660 0002E7CA 21 0d jneq L9996
664: 661 0002E7CC 1d effffffaba effffffab5 cmpl _dbl_st_acc+4,_dbl_expected+4
665: 662 0002E7D7 31 42 jeql L280
666: 663 0002E7D9 L9996:
667: 664 0002E7D9 # {
668: 665 0002E7D9 # errcnt++; /* bump the error count */
669: 666 0002E7D9 6d effffffaa9 incl _errcnt
670: 667 0002E7DF # if ( prt_error )
671: 668 0002E7DF 5d effffffaa3 tstl _prt_error
672: 669 0002E7E5 31 0d jeql L281
673: 670 0002E7E7 # print_pipe13_er("Reg. Data, 3 NOPs");
674: 671 0002E7E7 .data 1
675: 672 00000df3 * L282:
676: 673 00000df3 * 5265672E20446174612C20332 .ascii "Reg. Data, 3 NOPs\0"
677: 04E4F507300
678: 674 00000e05 * .text
679: 675 0002E7E7 dd 8f00000df3 pushl $L282
680: 676 0002E7ED fe 08 ef0000067c callf $8,_print_pipe13_er
681: 677 0002E7F4 # if ( halt_flg )
682: 678 0002E7F4 L281:
683: 679 0002E7F4 5d effffffa8e tstl _halt_flg
684: 680 0002E7FA 31 0d jeql L283
685: 681 0002E7FC # pipe13_er_hlt( subtest );
686: 682 0002E7FC dd effffffa86 pushl _subtest
687: 683 0002E802 fe 08 ef000007b5 callf $8,_pipe13_er_hlt
688: 684 0002E809 # if ( loop_on_err ) {
689: 685 0002E809 L283:
690: 686 0002E809 5d effffffa79 tstl _loop_on_err
691: 687 0002E80F 31 0a jeql L284
692: 688 0002E811 # force_loop = TRUE; /* set the force loop flag */
693: 689 0002E811 0d 01 effffffa70 movl $1,_force_loop
694: 690 0002E818 # asm("brw _pipe13_4_lp1"); /* and loop */
695: 691 0002E818 13 ff3f brw _pipe13_4_lp1
696: 692 0002E81B # }
697: 693 0002E81B # } /* end of compare error */
698: 694 0002E81B L284:
699: 695 0002E81B # } while( index++ < max_ldd_1_index );
700: 696 0002E81B L280:
701: 697 0002E81B L277:
702: 698 0002E81B 0d effffffa67 50 movl _index,r0
703: 699 0002E822 6d effffffa60 incl _index
704: 700 0002E828 1d 50 effffffa59 cmpl r0,_max_ldd_1_index
705: 701 0002E82F 81 03 13 fecb jlss L278
706: 702 0002E834 L276:
707: 703 0002E834 # } /* end of subtest 4 */
708: 704 0002E834 40 ret#2
709: 705 0002E835 .set L272,0x0
710: 706 0002E835 L274:
711: 707 0002E835 13 febb jbr L275
712: 708 0002E838 .data
713: 709 00000db4 * .text
714: 710 0002E838 .align 1
715: 711 0002E838 .globl _pipe13_5
716: 712 0002E838 _pipe13_5:
717: 713 0002E838 0000 .word L285
718: 714 0002E83A #
719: 715 0002E83A #
720: 716 0002E83A #
721: 717 0002E83A #
722: 718 0002E83A #
723: 719 0002E83A #
724: 720 0002E83A #
725: 721 0002E83A #
726: 722 0002E83A # /************************************************************************
727: 723 0002E83A # *
728: 724 0002E83A # * SUBTEST 5
729: 725 0002E83A # * data in cache, no NO-OPs
730: 726 0002E83A # *
731: 727 0002E83A # ************************************************************************/
732: 728 0002E83A # pipe13_5()
733: 729 0002E83A # {
734: 730 0002E83A 13 00fd jbr L287
735: 731 0002E83D L288:
736: 732 0002E83D # force_loop = FALSE; /* clear the force_loop flg */
737: 733 0002E83D 4d effffffa45 clrl _force_loop
738: 734 0002E843 # index = 0;
739: 735 0002E843 4d effffffa3f clrl _index
740: 736 0002E849 # do
741: 737 0002E849 L291:
742: 738 0002E849 # {
743: 739 0002E849 # dbl_value_1 = ldd_1_data[index].ld; /* get the operand's MSW */
744: 740 0002E849 48 04 effffffa38 50 shll $4,_index,r0
745: 741 0002E851 0c 8f00000000 50 addl2 $_ldd_1_data,r0
746: 742 0002E858 0d a004 effffffa2c movl 4(r0),_dbl_value_1+4
747: 743 0002E860 0d 60 effffffa21 movl (r0),_dbl_value_1
748: 744 0002E867 # dbl_value_2.m = 0x40800000; /* set the '1.0' operand */
749: 745 0002E867 0d 8f40800000 effffffa16 movl $1082130432,_dbl_value_2
750: 746 0002E872 # dbl_value_2.l = 0;
751: 747 0002E872 4d effffffa14 clrl _dbl_value_2+4
752: 748 0002E878 # dbl_expected = ldd_1_data[index].exp; /* get the expected results */
753: 749 0002E878 48 04 effffffa09 50 shll $4,_index,r0
754: 750 0002E880 0c 8f00000008 50 addl2 $_ldd_1_data+8,r0
755: 751 0002E887 0d a004 effffff9fd movl 4(r0),_dbl_expected+4
756: 752 0002E88F 0d 60 effffff9f2 movl (r0),_dbl_expected
757: 753 0002E896 # /*
758: 754 0002E896 # * If LOOP ON ERROR is set, this is the loop for this subtest.
759: 755 0002E896 # * The force loop flag is set after the first error.
760: 756 0002E896 # */
761: 757 0002E896 # asm("_pipe13_5_lp1:");
762: 758 0002E896 _pipe13_5_lp1:
763: 759 0002E896 # asm("ldd _dbl_value_2"); /* load a '1.0' ( 1 ) */
764: 760 0002E896 07 effffff9ec ldd _dbl_value_2
765: 761 0002E89C # asm("muld _dbl_value_1"); /* multiply by op. ( op ) */
766: 762 0002E89C e7 effffff9e6 muld _dbl_value_1
767: 763 0002E8A2 # asm("muld _dbl_value_2"); /* multiply by 1.0 ( op ) */
768: 764 0002E8A2 e7 effffff9e0 muld _dbl_value_2
769: 765 0002E8A8 # asm("subd _dbl_value_1"); /* subtract the op. ( 0 ) */
770: 766 0002E8A8 d7 effffff9da subd _dbl_value_1
771: 767 0002E8AE # asm("addd _dbl_value_1"); /* add the op. ( op ) */
772: 768 0002E8AE c7 effffff9d4 addd _dbl_value_1
773: 769 0002E8B4 # asm("std _dbl_st_acc"); /* store the result ( op ) */
774: 770 0002E8B4 27 effffff9ce std _dbl_st_acc
775: 771 0002E8BA # if( force_loop )
776: 772 0002E8BA 5d effffff9c8 tstl _force_loop
777: 773 0002E8C0 31 02 jeql L292
778: 774 0002E8C2 # asm("brb _pipe13_5_lp1");; /* run the loop again */
779: 775 0002E8C2 11 d2 brb _pipe13_5_lp1
780: 776 0002E8C4 L292:
781: 777 0002E8C4 # /*
782: 778 0002E8C4 # * verify the results
783: 779 0002E8C4 # */
784: 780 0002E8C4 # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
785: 781 0002E8C4 # (dbl_st_acc.l != dbl_expected.l) )
786: 782 0002E8C4 1d effffff9be effffff9b9 cmpl _dbl_st_acc,_dbl_expected
787: 783 0002E8CF 21 0d jneq L9995
788: 784 0002E8D1 1d effffff9b5 effffff9b0 cmpl _dbl_st_acc+4,_dbl_expected+4
789: 785 0002E8DC 31 42 jeql L293
790: 786 0002E8DE L9995:
791: 787 0002E8DE # {
792: 788 0002E8DE # errcnt++; /* bump the error count */
793: 789 0002E8DE 6d effffff9a4 incl _errcnt
794: 790 0002E8E4 # if ( prt_error )
795: 791 0002E8E4 5d effffff99e tstl _prt_error
796: 792 0002E8EA 31 0d jeql L294
797: 793 0002E8EC # print_pipe13_er("Cache Data, no NOPs");
798: 794 0002E8EC .data 1
799: 795 00000e05 * L295:
800: 796 00000e05 * 436163686520446174612C206 .ascii "Cache Data, no NOPs\0"
801: E6F204E4F507300
802: 797 00000e19 * .text
803: 798 0002E8EC dd 8f00000e05 pushl $L295
804: 799 0002E8F2 fe 08 ef00000577 callf $8,_print_pipe13_er
805: 800 0002E8F9 # if ( halt_flg )
806: 801 0002E8F9 L294:
807: 802 0002E8F9 5d effffff989 tstl _halt_flg
808: 803 0002E8FF 31 0d jeql L296
809: 804 0002E901 # pipe13_er_hlt( subtest );
810: 805 0002E901 dd effffff981 pushl _subtest
811: 806 0002E907 fe 08 ef000006b0 callf $8,_pipe13_er_hlt
812: 807 0002E90E # if ( loop_on_err ) {
813: 808 0002E90E L296:
814: 809 0002E90E 5d effffff974 tstl _loop_on_err
815: 810 0002E914 31 0a jeql L297
816: 811 0002E916 # force_loop = TRUE; /* set the force loop flag */
817: 812 0002E916 0d 01 effffff96b movl $1,_force_loop
818: 813 0002E91D # asm("brw _pipe13_5_lp1"); /* and loop */
819: 814 0002E91D 13 ff76 brw _pipe13_5_lp1
820: 815 0002E920 # }
821: 816 0002E920 # } /* end of compare error */
822: 817 0002E920 L297:
823: 818 0002E920 # } while( index++ < max_ldd_1_index );
824: 819 0002E920 L293:
825: 820 0002E920 L290:
826: 821 0002E920 0d effffff962 50 movl _index,r0
827: 822 0002E927 6d effffff95b incl _index
828: 823 0002E92D 1d 50 effffff954 cmpl r0,_max_ldd_1_index
829: 824 0002E934 81 03 13 ff10 jlss L291
830: 825 0002E939 L289:
831: 826 0002E939 # } /* end of subtest 5 */
832: 827 0002E939 40 ret#2
833: 828 0002E93A .set L285,0x0
834: 829 0002E93A L287:
835: 830 0002E93A 13 ff00 jbr L288
836: 831 0002E93D .data
837: 832 00000db4 * .text
838: 833 0002E93D 00 .align 1
839: 834 0002E93E .globl _pipe13_6
840: 835 0002E93E _pipe13_6:
841: 836 0002E93E 0000 .word L298
842: 837 0002E940 #
843: 838 0002E940 #
844: 839 0002E940 #
845: 840 0002E940 #
846: 841 0002E940 #
847: 842 0002E940 #
848: 843 0002E940 #
849: 844 0002E940 #
850: 845 0002E940 # /************************************************************************
851: 846 0002E940 # *
852: 847 0002E940 # * SUBTEST 6
853: 848 0002E940 # * data in cache, 1 NO-OP
854: 849 0002E940 # *
855: 850 0002E940 # ************************************************************************/
856: 851 0002E940 # pipe13_6()
857: 852 0002E940 # {
858: 853 0002E940 13 0102 jbr L300
859: 854 0002E943 L301:
860: 855 0002E943 # force_loop = FALSE; /* clear the force_loop flg */
861: 856 0002E943 4d effffff93f clrl _force_loop
862: 857 0002E949 # index = 0;
863: 858 0002E949 4d effffff939 clrl _index
864: 859 0002E94F # do
865: 860 0002E94F L304:
866: 861 0002E94F # {
867: 862 0002E94F # dbl_value_1 = ldd_1_data[index].ld; /* get the operand's MSW */
868: 863 0002E94F 48 04 effffff932 50 shll $4,_index,r0
869: 864 0002E957 0c 8f00000000 50 addl2 $_ldd_1_data,r0
870: 865 0002E95E 0d a004 effffff926 movl 4(r0),_dbl_value_1+4
871: 866 0002E966 0d 60 effffff91b movl (r0),_dbl_value_1
872: 867 0002E96D # dbl_value_2.m = 0x40800000; /* set the '1.0' operand */
873: 868 0002E96D 0d 8f40800000 effffff910 movl $1082130432,_dbl_value_2
874: 869 0002E978 # dbl_value_2.l = 0;
875: 870 0002E978 4d effffff90e clrl _dbl_value_2+4
876: 871 0002E97E # dbl_expected = ldd_1_data[index].exp; /* get the expected results */
877: 872 0002E97E 48 04 effffff903 50 shll $4,_index,r0
878: 873 0002E986 0c 8f00000008 50 addl2 $_ldd_1_data+8,r0
879: 874 0002E98D 0d a004 effffff8f7 movl 4(r0),_dbl_expected+4
880: 875 0002E995 0d 60 effffff8ec movl (r0),_dbl_expected
881: 876 0002E99C # /*
882: 877 0002E99C # * If LOOP ON ERROR is set, this is the loop for this subtest.
883: 878 0002E99C # * The force loop flag is set after the first error.
884: 879 0002E99C # */
885: 880 0002E99C # asm("_pipe13_6_lp1:");
886: 881 0002E99C _pipe13_6_lp1:
887: 882 0002E99C # asm("ldd _dbl_value_2"); /* load a '1.0' ( 1 ) */
888: 883 0002E99C 07 effffff8e6 ldd _dbl_value_2
889: 884 0002E9A2 # asm("nop");
890: 885 0002E9A2 10 nop
891: 886 0002E9A3 # asm("muld _dbl_value_1"); /* multiply by op. ( op ) */
892: 887 0002E9A3 e7 effffff8df muld _dbl_value_1
893: 888 0002E9A9 # asm("nop");
894: 889 0002E9A9 10 nop
895: 890 0002E9AA # asm("muld _dbl_value_2"); /* multiply by 1.0 ( op ) */
896: 891 0002E9AA e7 effffff8d8 muld _dbl_value_2
897: 892 0002E9B0 # asm("nop");
898: 893 0002E9B0 10 nop
899: 894 0002E9B1 # asm("subd _dbl_value_1"); /* subtract the op. ( 0 ) */
900: 895 0002E9B1 d7 effffff8d1 subd _dbl_value_1
901: 896 0002E9B7 # asm("nop");
902: 897 0002E9B7 10 nop
903: 898 0002E9B8 # asm("addd _dbl_value_1"); /* add the op. ( op ) */
904: 899 0002E9B8 c7 effffff8ca addd _dbl_value_1
905: 900 0002E9BE # asm("nop");
906: 901 0002E9BE 10 nop
907: 902 0002E9BF # asm("std _dbl_st_acc"); /* store the result ( op ) */
908: 903 0002E9BF 27 effffff8c3 std _dbl_st_acc
909: 904 0002E9C5 # if( force_loop )
910: 905 0002E9C5 5d effffff8bd tstl _force_loop
911: 906 0002E9CB 31 02 jeql L305
912: 907 0002E9CD # asm("brb _pipe13_6_lp1");; /* run the loop again */
913: 908 0002E9CD 11 cd brb _pipe13_6_lp1
914: 909 0002E9CF L305:
915: 910 0002E9CF # /*
916: 911 0002E9CF # * verify the results
917: 912 0002E9CF # */
918: 913 0002E9CF # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
919: 914 0002E9CF # (dbl_st_acc.l != dbl_expected.l) )
920: 915 0002E9CF 1d effffff8b3 effffff8ae cmpl _dbl_st_acc,_dbl_expected
921: 916 0002E9DA 21 0d jneq L9994
922: 917 0002E9DC 1d effffff8aa effffff8a5 cmpl _dbl_st_acc+4,_dbl_expected+4
923: 918 0002E9E7 31 42 jeql L306
924: 919 0002E9E9 L9994:
925: 920 0002E9E9 # {
926: 921 0002E9E9 # errcnt++; /* bump the error count */
927: 922 0002E9E9 6d effffff899 incl _errcnt
928: 923 0002E9EF # if ( prt_error )
929: 924 0002E9EF 5d effffff893 tstl _prt_error
930: 925 0002E9F5 31 0d jeql L307
931: 926 0002E9F7 # print_pipe13_er("Cache Data, 1 NOP");
932: 927 0002E9F7 .data 1
933: 928 00000e19 * L308:
934: 929 00000e19 * 436163686520446174612C203 .ascii "Cache Data, 1 NOP\0"
935: 1204E4F5000
936: 930 00000e2b * .text
937: 931 0002E9F7 dd 8f00000e19 pushl $L308
938: 932 0002E9FD fe 08 ef0000046c callf $8,_print_pipe13_er
939: 933 0002EA04 # if ( halt_flg )
940: 934 0002EA04 L307:
941: 935 0002EA04 5d effffff87e tstl _halt_flg
942: 936 0002EA0A 31 0d jeql L309
943: 937 0002EA0C # pipe13_er_hlt( subtest );
944: 938 0002EA0C dd effffff876 pushl _subtest
945: 939 0002EA12 fe 08 ef000005a5 callf $8,_pipe13_er_hlt
946: 940 0002EA19 # if ( loop_on_err ) {
947: 941 0002EA19 L309:
948: 942 0002EA19 5d effffff869 tstl _loop_on_err
949: 943 0002EA1F 31 0a jeql L310
950: 944 0002EA21 # force_loop = TRUE; /* set the force loop flag */
951: 945 0002EA21 0d 01 effffff860 movl $1,_force_loop
952: 946 0002EA28 # asm("brw _pipe13_6_lp1"); /* and loop */
953: 947 0002EA28 13 ff71 brw _pipe13_6_lp1
954: 948 0002EA2B # }
955: 949 0002EA2B # } /* end of compare error */
956: 950 0002EA2B L310:
957: 951 0002EA2B # } while( index++ < max_ldd_1_index );
958: 952 0002EA2B L306:
959: 953 0002EA2B L303:
960: 954 0002EA2B 0d effffff857 50 movl _index,r0
961: 955 0002EA32 6d effffff850 incl _index
962: 956 0002EA38 1d 50 effffff849 cmpl r0,_max_ldd_1_index
963: 957 0002EA3F 81 03 13 ff0b jlss L304
964: 958 0002EA44 L302:
965: 959 0002EA44 # } /* end of subtest 6 */
966: 960 0002EA44 40 ret#2
967: 961 0002EA45 .set L298,0x0
968: 962 0002EA45 L300:
969: 963 0002EA45 13 fefb jbr L301
970: 964 0002EA48 .data
971: 965 00000db4 * .text
972: 966 0002EA48 .align 1
973: 967 0002EA48 .globl _pipe13_7
974: 968 0002EA48 _pipe13_7:
975: 969 0002EA48 0000 .word L311
976: 970 0002EA4A #
977: 971 0002EA4A #
978: 972 0002EA4A #
979: 973 0002EA4A #
980: 974 0002EA4A #
981: 975 0002EA4A #
982: 976 0002EA4A #
983: 977 0002EA4A # /************************************************************************
984: 978 0002EA4A # *
985: 979 0002EA4A # * SUBTEST 7
986: 980 0002EA4A # * data in cache, 2 NO-OPs
987: 981 0002EA4A # *
988: 982 0002EA4A # ************************************************************************/
989: 983 0002EA4A # pipe13_7()
990: 984 0002EA4A # {
991: 985 0002EA4A 13 0107 jbr L313
992: 986 0002EA4D L314:
993: 987 0002EA4D # force_loop = FALSE; /* clear the force_loop flg */
994: 988 0002EA4D 4d effffff835 clrl _force_loop
995: 989 0002EA53 # index = 0;
996: 990 0002EA53 4d effffff82f clrl _index
997: 991 0002EA59 # do
998: 992 0002EA59 L317:
999: 993 0002EA59 # {
1000: 994 0002EA59 # dbl_value_1 = ldd_1_data[index].ld; /* get the operand's MSW */
1001: 995 0002EA59 48 04 effffff828 50 shll $4,_index,r0
1002: 996 0002EA61 0c 8f00000000 50 addl2 $_ldd_1_data,r0
1003: 997 0002EA68 0d a004 effffff81c movl 4(r0),_dbl_value_1+4
1004: 998 0002EA70 0d 60 effffff811 movl (r0),_dbl_value_1
1005: 999 0002EA77 # dbl_value_2.m = 0x40800000; /* set the '1.0' operand */
1006: 1000 0002EA77 0d 8f40800000 effffff806 movl $1082130432,_dbl_value_2
1007: 1001 0002EA82 # dbl_value_2.l = 0;
1008: 1002 0002EA82 4d effffff804 clrl _dbl_value_2+4
1009: 1003 0002EA88 # dbl_expected = ldd_1_data[index].exp; /* get the expected results */
1010: 1004 0002EA88 48 04 effffff7f9 50 shll $4,_index,r0
1011: 1005 0002EA90 0c 8f00000008 50 addl2 $_ldd_1_data+8,r0
1012: 1006 0002EA97 0d a004 effffff7ed movl 4(r0),_dbl_expected+4
1013: 1007 0002EA9F 0d 60 effffff7e2 movl (r0),_dbl_expected
1014: 1008 0002EAA6 # /*
1015: 1009 0002EAA6 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1016: 1010 0002EAA6 # * The force loop flag is set after the first error.
1017: 1011 0002EAA6 # */
1018: 1012 0002EAA6 # asm("_pipe13_7_lp1:");
1019: 1013 0002EAA6 _pipe13_7_lp1:
1020: 1014 0002EAA6 # asm("ldd _dbl_value_2"); /* load a '1.0' ( 1 ) */
1021: 1015 0002EAA6 07 effffff7dc ldd _dbl_value_2
1022: 1016 0002EAAC # asm("nop");
1023: 1017 0002EAAC 10 nop
1024: 1018 0002EAAD # asm("nop");
1025: 1019 0002EAAD 10 nop
1026: 1020 0002EAAE # asm("muld _dbl_value_1"); /* multiply by op. ( op ) */
1027: 1021 0002EAAE e7 effffff7d4 muld _dbl_value_1
1028: 1022 0002EAB4 # asm("nop");
1029: 1023 0002EAB4 10 nop
1030: 1024 0002EAB5 # asm("nop");
1031: 1025 0002EAB5 10 nop
1032: 1026 0002EAB6 # asm("muld _dbl_value_2"); /* multiply by 1.0 ( op ) */
1033: 1027 0002EAB6 e7 effffff7cc muld _dbl_value_2
1034: 1028 0002EABC # asm("nop");
1035: 1029 0002EABC 10 nop
1036: 1030 0002EABD # asm("nop");
1037: 1031 0002EABD 10 nop
1038: 1032 0002EABE # asm("subd _dbl_value_1"); /* subtract the op. ( 0 ) */
1039: 1033 0002EABE d7 effffff7c4 subd _dbl_value_1
1040: 1034 0002EAC4 # asm("nop");
1041: 1035 0002EAC4 10 nop
1042: 1036 0002EAC5 # asm("nop");
1043: 1037 0002EAC5 10 nop
1044: 1038 0002EAC6 # asm("addd _dbl_value_1"); /* add the op. ( op ) */
1045: 1039 0002EAC6 c7 effffff7bc addd _dbl_value_1
1046: 1040 0002EACC # asm("nop");
1047: 1041 0002EACC 10 nop
1048: 1042 0002EACD # asm("nop");
1049: 1043 0002EACD 10 nop
1050: 1044 0002EACE # asm("std _dbl_st_acc"); /* store the result ( op ) */
1051: 1045 0002EACE 27 effffff7b4 std _dbl_st_acc
1052: 1046 0002EAD4 # if( force_loop )
1053: 1047 0002EAD4 5d effffff7ae tstl _force_loop
1054: 1048 0002EADA 31 02 jeql L318
1055: 1049 0002EADC # asm("brb _pipe13_7_lp1");; /* run the loop again */
1056: 1050 0002EADC 11 c8 brb _pipe13_7_lp1
1057: 1051 0002EADE L318:
1058: 1052 0002EADE # /*
1059: 1053 0002EADE # * verify the results
1060: 1054 0002EADE # */
1061: 1055 0002EADE # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
1062: 1056 0002EADE # (dbl_st_acc.l != dbl_expected.l) )
1063: 1057 0002EADE 1d effffff7a4 effffff79f cmpl _dbl_st_acc,_dbl_expected
1064: 1058 0002EAE9 21 0d jneq L9993
1065: 1059 0002EAEB 1d effffff79b effffff796 cmpl _dbl_st_acc+4,_dbl_expected+4
1066: 1060 0002EAF6 31 42 jeql L319
1067: 1061 0002EAF8 L9993:
1068: 1062 0002EAF8 # {
1069: 1063 0002EAF8 # errcnt++; /* bump the error count */
1070: 1064 0002EAF8 6d effffff78a incl _errcnt
1071: 1065 0002EAFE # if ( prt_error )
1072: 1066 0002EAFE 5d effffff784 tstl _prt_error
1073: 1067 0002EB04 31 0d jeql L320
1074: 1068 0002EB06 # print_pipe13_er("Cache Data, 2 NOPs");
1075: 1069 0002EB06 .data 1
1076: 1070 00000e2b * L321:
1077: 1071 00000e2b * 436163686520446174612C203 .ascii "Cache Data, 2 NOPs\0"
1078: 2204E4F507300
1079: 1072 00000e3e * .text
1080: 1073 0002EB06 dd 8f00000e2b pushl $L321
1081: 1074 0002EB0C fe 08 ef0000035d callf $8,_print_pipe13_er
1082: 1075 0002EB13 # if ( halt_flg )
1083: 1076 0002EB13 L320:
1084: 1077 0002EB13 5d effffff76f tstl _halt_flg
1085: 1078 0002EB19 31 0d jeql L322
1086: 1079 0002EB1B # pipe13_er_hlt( subtest );
1087: 1080 0002EB1B dd effffff767 pushl _subtest
1088: 1081 0002EB21 fe 08 ef00000496 callf $8,_pipe13_er_hlt
1089: 1082 0002EB28 # if ( loop_on_err ) {
1090: 1083 0002EB28 L322:
1091: 1084 0002EB28 5d effffff75a tstl _loop_on_err
1092: 1085 0002EB2E 31 0a jeql L323
1093: 1086 0002EB30 # force_loop = TRUE; /* set the force loop flag */
1094: 1087 0002EB30 0d 01 effffff751 movl $1,_force_loop
1095: 1088 0002EB37 # asm("brw _pipe13_7_lp1"); /* and loop */
1096: 1089 0002EB37 13 ff6c brw _pipe13_7_lp1
1097: 1090 0002EB3A # }
1098: 1091 0002EB3A # } /* end of compare error */
1099: 1092 0002EB3A L323:
1100: 1093 0002EB3A # } while( index++ < max_ldd_1_index );
1101: 1094 0002EB3A L319:
1102: 1095 0002EB3A L316:
1103: 1096 0002EB3A 0d effffff748 50 movl _index,r0
1104: 1097 0002EB41 6d effffff741 incl _index
1105: 1098 0002EB47 1d 50 effffff73a cmpl r0,_max_ldd_1_index
1106: 1099 0002EB4E 81 03 13 ff06 jlss L317
1107: 1100 0002EB53 L315:
1108: 1101 0002EB53 # } /* end of subtest 7 */
1109: 1102 0002EB53 40 ret#2
1110: 1103 0002EB54 .set L311,0x0
1111: 1104 0002EB54 L313:
1112: 1105 0002EB54 13 fef6 jbr L314
1113: 1106 0002EB57 .data
1114: 1107 00000db4 * .text
1115: 1108 0002EB57 00 .align 1
1116: 1109 0002EB58 .globl _pipe13_8
1117: 1110 0002EB58 _pipe13_8:
1118: 1111 0002EB58 0000 .word L324
1119: 1112 0002EB5A #
1120: 1113 0002EB5A #
1121: 1114 0002EB5A #
1122: 1115 0002EB5A #
1123: 1116 0002EB5A #
1124: 1117 0002EB5A #
1125: 1118 0002EB5A #
1126: 1119 0002EB5A #
1127: 1120 0002EB5A # /************************************************************************
1128: 1121 0002EB5A # *
1129: 1122 0002EB5A # * SUBTEST 8
1130: 1123 0002EB5A # * data in cache, 3 NO-OPs
1131: 1124 0002EB5A # *
1132: 1125 0002EB5A # ************************************************************************/
1133: 1126 0002EB5A # pipe13_8()
1134: 1127 0002EB5A # {
1135: 1128 0002EB5A 13 010c jbr L326
1136: 1129 0002EB5D L327:
1137: 1130 0002EB5D # force_loop = FALSE; /* clear the force_loop flg */
1138: 1131 0002EB5D 4d effffff725 clrl _force_loop
1139: 1132 0002EB63 # index = 0;
1140: 1133 0002EB63 4d effffff71f clrl _index
1141: 1134 0002EB69 # do
1142: 1135 0002EB69 L330:
1143: 1136 0002EB69 # {
1144: 1137 0002EB69 # dbl_value_1 = ldd_1_data[index].ld; /* get the operand's MSW */
1145: 1138 0002EB69 48 04 effffff718 50 shll $4,_index,r0
1146: 1139 0002EB71 0c 8f00000000 50 addl2 $_ldd_1_data,r0
1147: 1140 0002EB78 0d a004 effffff70c movl 4(r0),_dbl_value_1+4
1148: 1141 0002EB80 0d 60 effffff701 movl (r0),_dbl_value_1
1149: 1142 0002EB87 # dbl_value_2.m = 0x40800000; /* set the '1.0' operand */
1150: 1143 0002EB87 0d 8f40800000 effffff6f6 movl $1082130432,_dbl_value_2
1151: 1144 0002EB92 # dbl_value_2.l = 0;
1152: 1145 0002EB92 4d effffff6f4 clrl _dbl_value_2+4
1153: 1146 0002EB98 # dbl_expected = ldd_1_data[index].exp; /* get the expected results */
1154: 1147 0002EB98 48 04 effffff6e9 50 shll $4,_index,r0
1155: 1148 0002EBA0 0c 8f00000008 50 addl2 $_ldd_1_data+8,r0
1156: 1149 0002EBA7 0d a004 effffff6dd movl 4(r0),_dbl_expected+4
1157: 1150 0002EBAF 0d 60 effffff6d2 movl (r0),_dbl_expected
1158: 1151 0002EBB6 # /*
1159: 1152 0002EBB6 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1160: 1153 0002EBB6 # * The force loop flag is set after the first error.
1161: 1154 0002EBB6 # */
1162: 1155 0002EBB6 # asm("_pipe13_8_lp1:");
1163: 1156 0002EBB6 _pipe13_8_lp1:
1164: 1157 0002EBB6 # asm("ldd _dbl_value_2"); /* load a '1.0' ( 1 ) */
1165: 1158 0002EBB6 07 effffff6cc ldd _dbl_value_2
1166: 1159 0002EBBC # asm("nop");
1167: 1160 0002EBBC 10 nop
1168: 1161 0002EBBD # asm("nop");
1169: 1162 0002EBBD 10 nop
1170: 1163 0002EBBE # asm("nop");
1171: 1164 0002EBBE 10 nop
1172: 1165 0002EBBF # asm("muld _dbl_value_1"); /* multiply by op. ( op ) */
1173: 1166 0002EBBF e7 effffff6c3 muld _dbl_value_1
1174: 1167 0002EBC5 # asm("nop");
1175: 1168 0002EBC5 10 nop
1176: 1169 0002EBC6 # asm("nop");
1177: 1170 0002EBC6 10 nop
1178: 1171 0002EBC7 # asm("nop");
1179: 1172 0002EBC7 10 nop
1180: 1173 0002EBC8 # asm("muld _dbl_value_2"); /* multiply by 1.0 ( op ) */
1181: 1174 0002EBC8 e7 effffff6ba muld _dbl_value_2
1182: 1175 0002EBCE # asm("nop");
1183: 1176 0002EBCE 10 nop
1184: 1177 0002EBCF # asm("nop");
1185: 1178 0002EBCF 10 nop
1186: 1179 0002EBD0 # asm("nop");
1187: 1180 0002EBD0 10 nop
1188: 1181 0002EBD1 # asm("subd _dbl_value_1"); /* subtract the op. ( 0 ) */
1189: 1182 0002EBD1 d7 effffff6b1 subd _dbl_value_1
1190: 1183 0002EBD7 # asm("nop");
1191: 1184 0002EBD7 10 nop
1192: 1185 0002EBD8 # asm("nop");
1193: 1186 0002EBD8 10 nop
1194: 1187 0002EBD9 # asm("nop");
1195: 1188 0002EBD9 10 nop
1196: 1189 0002EBDA # asm("addd _dbl_value_1"); /* add the op. ( op ) */
1197: 1190 0002EBDA c7 effffff6a8 addd _dbl_value_1
1198: 1191 0002EBE0 # asm("nop");
1199: 1192 0002EBE0 10 nop
1200: 1193 0002EBE1 # asm("nop");
1201: 1194 0002EBE1 10 nop
1202: 1195 0002EBE2 # asm("nop");
1203: 1196 0002EBE2 10 nop
1204: 1197 0002EBE3 # asm("std _dbl_st_acc"); /* store the result ( op ) */
1205: 1198 0002EBE3 27 effffff69f std _dbl_st_acc
1206: 1199 0002EBE9 # if( force_loop )
1207: 1200 0002EBE9 5d effffff699 tstl _force_loop
1208: 1201 0002EBEF 31 02 jeql L331
1209: 1202 0002EBF1 # asm("brb _pipe13_8_lp1");; /* run the loop again */
1210: 1203 0002EBF1 11 c3 brb _pipe13_8_lp1
1211: 1204 0002EBF3 L331:
1212: 1205 0002EBF3 # /*
1213: 1206 0002EBF3 # * verify the results
1214: 1207 0002EBF3 # */
1215: 1208 0002EBF3 # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
1216: 1209 0002EBF3 # (dbl_st_acc.l != dbl_expected.l) )
1217: 1210 0002EBF3 1d effffff68f effffff68a cmpl _dbl_st_acc,_dbl_expected
1218: 1211 0002EBFE 21 0d jneq L9992
1219: 1212 0002EC00 1d effffff686 effffff681 cmpl _dbl_st_acc+4,_dbl_expected+4
1220: 1213 0002EC0B 31 42 jeql L332
1221: 1214 0002EC0D L9992:
1222: 1215 0002EC0D # {
1223: 1216 0002EC0D # errcnt++; /* bump the error count */
1224: 1217 0002EC0D 6d effffff675 incl _errcnt
1225: 1218 0002EC13 # if ( prt_error )
1226: 1219 0002EC13 5d effffff66f tstl _prt_error
1227: 1220 0002EC19 31 0d jeql L333
1228: 1221 0002EC1B # print_pipe13_er("Cache Data, 3 NOPs");
1229: 1222 0002EC1B .data 1
1230: 1223 00000e3e * L334:
1231: 1224 00000e3e * 436163686520446174612C203 .ascii "Cache Data, 3 NOPs\0"
1232: 3204E4F507300
1233: 1225 00000e51 * .text
1234: 1226 0002EC1B dd 8f00000e3e pushl $L334
1235: 1227 0002EC21 fe 08 ef00000248 callf $8,_print_pipe13_er
1236: 1228 0002EC28 # if ( halt_flg )
1237: 1229 0002EC28 L333:
1238: 1230 0002EC28 5d effffff65a tstl _halt_flg
1239: 1231 0002EC2E 31 0d jeql L335
1240: 1232 0002EC30 # pipe13_er_hlt( subtest );
1241: 1233 0002EC30 dd effffff652 pushl _subtest
1242: 1234 0002EC36 fe 08 ef00000381 callf $8,_pipe13_er_hlt
1243: 1235 0002EC3D # if ( loop_on_err ) {
1244: 1236 0002EC3D L335:
1245: 1237 0002EC3D 5d effffff645 tstl _loop_on_err
1246: 1238 0002EC43 31 0a jeql L336
1247: 1239 0002EC45 # force_loop = TRUE; /* set the force loop flag */
1248: 1240 0002EC45 0d 01 effffff63c movl $1,_force_loop
1249: 1241 0002EC4C # asm("brw _pipe13_8_lp1"); /* and loop */
1250: 1242 0002EC4C 13 ff67 brw _pipe13_8_lp1
1251: 1243 0002EC4F # }
1252: 1244 0002EC4F # } /* end of compare error */
1253: 1245 0002EC4F L336:
1254: 1246 0002EC4F # } while( index++ < max_ldd_1_index );
1255: 1247 0002EC4F L332:
1256: 1248 0002EC4F L329:
1257: 1249 0002EC4F 0d effffff633 50 movl _index,r0
1258: 1250 0002EC56 6d effffff62c incl _index
1259: 1251 0002EC5C 1d 50 effffff625 cmpl r0,_max_ldd_1_index
1260: 1252 0002EC63 81 03 13 ff01 jlss L330
1261: 1253 0002EC68 L328:
1262: 1254 0002EC68 # } /* end of subtest 8 */
1263: 1255 0002EC68 40 ret#2
1264: 1256 0002EC69 .set L324,0x0
1265: 1257 0002EC69 L326:
1266: 1258 0002EC69 13 fef1 jbr L327
1267: 1259 0002EC6C .data
1268: 1260 00000db4 * .text
1269: 1261 0002EC6C .align 1
1270: 1262 0002EC6C .globl _pipe13_9
1271: 1263 0002EC6C _pipe13_9:
1272: 1264 0002EC6C 0000 .word L337
1273: 1265 0002EC6E #
1274: 1266 0002EC6E #
1275: 1267 0002EC6E #
1276: 1268 0002EC6E #
1277: 1269 0002EC6E #
1278: 1270 0002EC6E #
1279: 1271 0002EC6E #
1280: 1272 0002EC6E # /******************************************************************************
1281: 1273 0002EC6E # *
1282: 1274 0002EC6E # * SUBTEST 9
1283: 1275 0002EC6E # *
1284: 1276 0002EC6E # * Get the data via the FRAME POINTER ( quad word indexed )
1285: 1277 0002EC6E # *
1286: 1278 0002EC6E # * ADDRESSES OF DATA OPERANDS INDEX DATA
1287: 1279 0002EC6E # * pointer_data,-4 ( FP+24 ) 3 the STF result goes here
1288: 1280 0002EC6E # * pointer_data-8,-12 ( FP+16 ) 2 <operand data>
1289: 1281 0002EC6E # * pointer_data-16,-20 ( FP+8 ) 1 < '1.0' data>
1290: 1282 0002EC6E # * pointer_data-24,-28 ( FP ) 0 point the frame pointer here
1291: 1283 0002EC6E # *
1292: 1284 0002EC6E # * NOTE: The double precision instructions are using Quad Word indexing.
1293: 1285 0002EC6E # ******************************************************************************/
1294: 1286 0002EC6E # pipe13_9()
1295: 1287 0002EC6E # {
1296: 1288 0002EC6E 13 01fc jbr L339
1297: 1289 0002EC71 L340:
1298: 1290 0002EC71 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
1299: 1291 0002EC71 ed 6d effffff610 moval (r13),_pre_event_fp
1300: 1292 0002EC78 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
1301: 1293 0002EC78 ed 6e effffff609 moval (r14),_pre_event_sp
1302: 1294 0002EC7F # force_loop = FALSE; /* clear force_loop flag */
1303: 1295 0002EC7F 4d effffff603 clrl _force_loop
1304: 1296 0002EC85 # index = 0;
1305: 1297 0002EC85 4d effffff5fd clrl _index
1306: 1298 0002EC8B # do
1307: 1299 0002EC8B L343:
1308: 1300 0002EC8B # {
1309: 1301 0002EC8B # sgl_value_1 = ldd_1_data[index].ld.m; /* get operand 1's MSW */
1310: 1302 0002EC8B 0d effffff5f7 50 movl _index,r0
1311: 1303 0002EC92 48 04 50 50 shll $4,r0,r0
1312: 1304 0002EC96 0d e000000000 effffff5e7 movl _ldd_1_data(r0),_sgl_value_1
1313: 1305 0002ECA1 # sgl_value_2 = ldd_1_data[index].ld.l; /* get operand 1's LSW */
1314: 1306 0002ECA1 0d effffff5e1 50 movl _index,r0
1315: 1307 0002ECA8 48 04 50 50 shll $4,r0,r0
1316: 1308 0002ECAC 0d e000000004 effffff5d1 movl _ldd_1_data+4(r0),_sgl_value_2
1317: 1309 0002ECB7 # sgl_value_7 = 0x40800000; /* get the '1.0' data */
1318: 1310 0002ECB7 0d 8f40800000 effffff5c6 movl $1082130432,_sgl_value_7
1319: 1311 0002ECC2 # sgl_value_8 = 0;
1320: 1312 0002ECC2 4d effffff5c0 clrl _sgl_value_8
1321: 1313 0002ECC8 # dbl_expected = ldd_1_data[index].exp; /* get expected results */
1322: 1314 0002ECC8 48 04 effffff5b9 50 shll $4,_index,r0
1323: 1315 0002ECD0 0c 8f00000008 50 addl2 $_ldd_1_data+8,r0
1324: 1316 0002ECD7 0d a004 effffff5ad movl 4(r0),_dbl_expected+4
1325: 1317 0002ECDF 0d 60 effffff5a2 movl (r0),_dbl_expected
1326: 1318 0002ECE6 # /*
1327: 1319 0002ECE6 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1328: 1320 0002ECE6 # * The force loop flag is set after the first error.
1329: 1321 0002ECE6 # */
1330: 1322 0002ECE6 # asm("_pipe13_9_lp1:");
1331: 1323 0002ECE6 _pipe13_9_lp1:
1332: 1324 0002ECE6 # asm("moval _pointer_data,_sgl_value_9");/* get store data's addr */
1333: 1325 0002ECE6 ed effffff59c effffff597 moval _pointer_data,_sgl_value_9
1334: 1326 0002ECF1 # sgl_value_9 -= 8;
1335: 1327 0002ECF1 2c 08 effffff590 subl2 $8,_sgl_value_9
1336: 1328 0002ECF8 # asm("movl _sgl_value_2,*_sgl_value_9"); /* set the operand's LSW */
1337: 1329 0002ECF8 0d effffff58a fffffff585 movl _sgl_value_2,*_sgl_value_9
1338: 1330 0002ED03 # sgl_value_9 -= 4;
1339: 1331 0002ED03 2c 04 effffff57e subl2 $4,_sgl_value_9
1340: 1332 0002ED0A # asm("movl _sgl_value_1,*_sgl_value_9"); /* set the operand's MSW */
1341: 1333 0002ED0A 0d effffff578 fffffff573 movl _sgl_value_1,*_sgl_value_9
1342: 1334 0002ED15 # sgl_value_9 -= 4;
1343: 1335 0002ED15 2c 04 effffff56c subl2 $4,_sgl_value_9
1344: 1336 0002ED1C # asm("movl _sgl_value_8,*_sgl_value_9"); /* set '1.0' data's LSW */
1345: 1337 0002ED1C 0d effffff566 fffffff561 movl _sgl_value_8,*_sgl_value_9
1346: 1338 0002ED27 # sgl_value_9 -= 4;
1347: 1339 0002ED27 2c 04 effffff55a subl2 $4,_sgl_value_9
1348: 1340 0002ED2E # asm("movl _sgl_value_7,*_sgl_value_9"); /* set '1.0' data's MSW */
1349: 1341 0002ED2E 0d effffff554 fffffff54f movl _sgl_value_7,*_sgl_value_9
1350: 1342 0002ED39 # sgl_value_9 -= 8; /* get the FP addr to use */
1351: 1343 0002ED39 2c 08 effffff548 subl2 $8,_sgl_value_9
1352: 1344 0002ED40 # asm("movl _sgl_value_9,r13"); /* set the FRAME POINTER */
1353: 1345 0002ED40 0d effffff542 5d movl _sgl_value_9,r13
1354: 1346 0002ED47 # asm("movl $1,r5"); /* r5 index = 1 quadwords */
1355: 1347 0002ED47 0d 01 55 movl $1,r5
1356: 1348 0002ED4A # asm("movl $2,r6"); /* r6 index = 2 quadwords */
1357: 1349 0002ED4A 0d 02 56 movl $2,r6
1358: 1350 0002ED4D # asm("movl $3,r7"); /* r7 index = 3 quadwords */
1359: 1351 0002ED4D 0d 03 57 movl $3,r7
1360: 1352 0002ED50 # asm("ldd (r13)[r5]"); /* load a '1.0' ( 1 ) */
1361: 1353 0002ED50 07 456d ldd (r13)[r5]
1362: 1354 0002ED53 # asm("muld (r13)[r6]"); /* multiply by op. ( op ) */
1363: 1355 0002ED53 e7 466d muld (r13)[r6]
1364: 1356 0002ED56 # asm("muld (r13)[r5]"); /* multiply by 1.0 ( op ) */
1365: 1357 0002ED56 e7 456d muld (r13)[r5]
1366: 1358 0002ED59 # asm("subd (r13)[r6]"); /* subtract the op. ( 0 ) */
1367: 1359 0002ED59 d7 466d subd (r13)[r6]
1368: 1360 0002ED5C # asm("addd (r13)[r6]"); /* add the op. ( op ) */
1369: 1361 0002ED5C c7 466d addd (r13)[r6]
1370: 1362 0002ED5F # asm("std (r13)[r7]"); /* store the result ( op ) */
1371: 1363 0002ED5F 27 476d std (r13)[r7]
1372: 1364 0002ED62 # if( force_loop )
1373: 1365 0002ED62 5d effffff520 tstl _force_loop
1374: 1366 0002ED68 31 03 jeql L344
1375: 1367 0002ED6A # asm("brw _pipe13_9_lp1"); /* run the loop again */
1376: 1368 0002ED6A 13 ff79 brw _pipe13_9_lp1
1377: 1369 0002ED6D # /*
1378: 1370 0002ED6D # * verify the results
1379: 1371 0002ED6D # */
1380: 1372 0002ED6D # asm("moval (r13),_sgl_value_10"); /* save the frame pointer */
1381: 1373 0002ED6D L344:
1382: 1374 0002ED6D ed 6d effffff514 moval (r13),_sgl_value_10
1383: 1375 0002ED74 # asm("movl _pointer_data,_sgl_value_4"); /* save the LSW stored */
1384: 1376 0002ED74 0d effffff50e effffff509 movl _pointer_data,_sgl_value_4
1385: 1377 0002ED7F # asm("movl _pointer_data-4,_sgl_value_3"); /* and the MSW */
1386: 1378 0002ED7F 0d effffff4ff effffff4fe movl _pointer_data-4,_sgl_value_3
1387: 1379 0002ED8A # if( (sgl_value_3 != dbl_expected.m) || /* verify the result... */
1388: 1380 0002ED8A # (sgl_value_4 != dbl_expected.l) || /* verify the result... */
1389: 1381 0002ED8A # (sgl_value_10 != sgl_value_9) ) /* ... and the final FP */
1390: 1382 0002ED8A 1d effffff4f8 effffff4f3 cmpl _sgl_value_3,_dbl_expected
1391: 1383 0002ED95 21 1d jneq L9991
1392: 1384 0002ED97 1d effffff4eb effffff4ea cmpl _sgl_value_4,_dbl_expected+4
1393: 1385 0002EDA2 21 10 jneq L9991
1394: 1386 0002EDA4 1d effffff4de effffff4d9 cmpl _sgl_value_10,_sgl_value_9
1395: 1387 0002EDAF 21 03 13 0091 jeql L345
1396: 1388 0002EDB4 L9991:
1397: 1389 0002EDB4 # {
1398: 1390 0002EDB4 # asm("movl _pre_event_fp,r13"); /* restore frame pointer */
1399: 1391 0002EDB4 0d effffff4ce 5d movl _pre_event_fp,r13
1400: 1392 0002EDBB # asm("movl _pre_event_sp,r14"); /* restore stack pointer */
1401: 1393 0002EDBB 0d effffff4c7 5e movl _pre_event_sp,r14
1402: 1394 0002EDC2 # errcnt++; /* bump the error count */
1403: 1395 0002EDC2 6d effffff4c0 incl _errcnt
1404: 1396 0002EDC8 # if ( prt_error ) {
1405: 1397 0002EDC8 5d effffff4ba tstl _prt_error
1406: 1398 0002EDCE 31 4e jeql L346
1407: 1399 0002EDD0 # print_pipe13_er("indexed FP addressing.\n");
1408: 1400 0002EDD0 .data 1
1409: 1401 00000e51 * L347:
1410: 1402 00000e51 * 696E646578656420465020616 .ascii "indexed FP addressing.\12\0"
1411: 46472657373696E672E0A00
1412: 1403 00000e69 * .text
1413: 1404 0002EDD0 dd 8f00000e51 pushl $L347
1414: 1405 0002EDD6 fe 08 ef00000093 callf $8,_print_pipe13_er
1415: 1406 0002EDDD # writes("final Frame Pointer = ");
1416: 1407 0002EDDD .data 1
1417: 1408 00000e69 * L348:
1418: 1409 00000e69 * 66696E616C204672616D65205 .ascii "final Frame Pointer = \0"
1419: 06F696E746572203D2000
1420: 1410 00000e80 * .text
1421: 1411 0002EDDD dd 8f00000e69 pushl $L348
1422: 1412 0002EDE3 fe 08 effffff49e callf $8,_writes
1423: 1413 0002EDEA # write32h( sgl_value_10 );
1424: 1414 0002EDEA dd effffff498 pushl _sgl_value_10
1425: 1415 0002EDF0 fe 08 effffff491 callf $8,_write32h
1426: 1416 0002EDF7 # writes(", expected FP = ");
1427: 1417 0002EDF7 .data 1
1428: 1418 00000e80 * L350:
1429: 1419 00000e80 * 2C20206578706563746564204 .ascii ", expected FP = \0"
1430: 650203D2000
1431: 1420 00000e92 * .text
1432: 1421 0002EDF7 dd 8f00000e80 pushl $L350
1433: 1422 0002EDFD fe 08 effffff484 callf $8,_writes
1434: 1423 0002EE04 # write32h( sgl_value_9 );
1435: 1424 0002EE04 dd effffff47e pushl _sgl_value_9
1436: 1425 0002EE0A fe 08 effffff477 callf $8,_write32h
1437: 1426 0002EE11 # writes(" \n");
1438: 1427 0002EE11 .data 1
1439: 1428 00000e92 * L351:
1440: 1429 00000e92 * 200A00 .ascii " \12\0"
1441: 1430 00000e95 * .text
1442: 1431 0002EE11 dd 8f00000e92 pushl $L351
1443: 1432 0002EE17 fe 08 effffff46a callf $8,_writes
1444: 1433 0002EE1E # }
1445: 1434 0002EE1E # if ( halt_flg )
1446: 1435 0002EE1E L346:
1447: 1436 0002EE1E 5d effffff464 tstl _halt_flg
1448: 1437 0002EE24 31 0d jeql L352
1449: 1438 0002EE26 # pipe13_er_hlt( subtest );
1450: 1439 0002EE26 dd effffff45c pushl _subtest
1451: 1440 0002EE2C fe 08 ef0000018b callf $8,_pipe13_er_hlt
1452: 1441 0002EE33 # if ( loop_on_err ) {
1453: 1442 0002EE33 L352:
1454: 1443 0002EE33 5d effffff44f tstl _loop_on_err
1455: 1444 0002EE39 31 0a jeql L353
1456: 1445 0002EE3B # force_loop = TRUE; /* set the force loop flag */
1457: 1446 0002EE3B 0d 01 effffff446 movl $1,_force_loop
1458: 1447 0002EE42 # asm("brw _pipe13_9_lp1"); /* and loop */
1459: 1448 0002EE42 13 fea1 brw _pipe13_9_lp1
1460: 1449 0002EE45 # }
1461: 1450 0002EE45 # } /* end of compare error */
1462: 1451 0002EE45 L353:
1463: 1452 0002EE45 # } while( index++ < max_ldd_1_index );
1464: 1453 0002EE45 L345:
1465: 1454 0002EE45 L342:
1466: 1455 0002EE45 0d effffff43d 50 movl _index,r0
1467: 1456 0002EE4C 6d effffff436 incl _index
1468: 1457 0002EE52 1d 50 effffff42f cmpl r0,_max_ldd_1_index
1469: 1458 0002EE59 81 03 13 fe2d jlss L343
1470: 1459 0002EE5E L341:
1471: 1460 0002EE5E # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */
1472: 1461 0002EE5E 0d effffff424 5d movl _pre_event_fp,r13
1473: 1462 0002EE65 # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */
1474: 1463 0002EE65 0d effffff41d 5e movl _pre_event_sp,r14
1475: 1464 0002EE6C # } /* end of subtest 9 */
1476: 1465 0002EE6C 40 ret#2
1477: 1466 0002EE6D .set L337,0x0
1478: 1467 0002EE6D L339:
1479: 1468 0002EE6D 13 fe01 jbr L340
1480: 1469 0002EE70 .data
1481: 1470 00000db4 * .text
1482: 1471 0002EE70 .align 1
1483: 1472 0002EE70 .globl _print_pipe13_er
1484: 1473 0002EE70 _print_pipe13_er:
1485: 1474 0002EE70 0000 .word L354
1486: 1475 0002EE72 #
1487: 1476 0002EE72 #
1488: 1477 0002EE72 # /******************************************************************************
1489: 1478 0002EE72 # *
1490: 1479 0002EE72 # * ERROR ROUTINE
1491: 1480 0002EE72 # *
1492: 1481 0002EE72 # * print an error in the following form
1493: 1482 0002EE72 # *
1494: 1483 0002EE72 # *operand = xxxxxxxx xxxxxxxx, final Acc = xxxxxxxx xxxxxxxx, index = dd
1495: 1484 0002EE72 # * expected Acc = xxxxxxxx xxxxxxxx
1496: 1485 0002EE72 # *
1497: 1486 0002EE72 # ******************************************************************************/
1498: 1487 0002EE72 # print_pipe13_er(msg)
1499: 1488 0002EE72 # char *msg;
1500: 1489 0002EE72 # {
1501: 1490 0002EE72 13 0145 jbr L356
1502: 1491 0002EE75 L357:
1503: 1492 0002EE75 # writes(" \n"); /* start a new print line */
1504: 1493 0002EE75 .data 1
1505: 1494 00000e95 * L358:
1506: 1495 00000e95 * 200A00 .ascii " \12\0"
1507: 1496 00000e98 * .text
1508: 1497 0002EE75 dd 8f00000e95 pushl $L358
1509: 1498 0002EE7B fe 08 effffff406 callf $8,_writes
1510: 1499 0002EE82 # writes("cycle: ");
1511: 1500 0002EE82 .data 1
1512: 1501 00000e98 * L359:
1513: 1502 00000e98 * 6379636C653A2000 .ascii "cycle: \0"
1514: 1503 00000ea0 * .text
1515: 1504 0002EE82 dd 8f00000e98 pushl $L359
1516: 1505 0002EE88 fe 08 effffff3f9 callf $8,_writes
1517: 1506 0002EE8F # writed( cycle );
1518: 1507 0002EE8F dd effffff3f3 pushl _cycle
1519: 1508 0002EE95 fe 08 effffff3ec callf $8,_writed
1520: 1509 0002EE9C # writes(" test ");
1521: 1510 0002EE9C .data 1
1522: 1511 00000ea0 * L361:
1523: 1512 00000ea0 * 20746573742000 .ascii " test \0"
1524: 1513 00000ea7 * .text
1525: 1514 0002EE9C dd 8f00000ea0 pushl $L361
1526: 1515 0002EEA2 fe 08 effffff3df callf $8,_writes
1527: 1516 0002EEA9 # writed( test_no );
1528: 1517 0002EEA9 dd effffff3d9 pushl _test_no
1529: 1518 0002EEAF fe 08 effffff3d2 callf $8,_writed
1530: 1519 0002EEB6 # writes(" (Pipe 13), subtest ");
1531: 1520 0002EEB6 .data 1
1532: 1521 00000ea7 * L362:
1533: 1522 00000ea7 * 20202850697065203133292C2 .ascii " (Pipe 13), subtest \0"
1534: 0737562746573742000
1535: 1523 00000ebd * .text
1536: 1524 0002EEB6 dd 8f00000ea7 pushl $L362
1537: 1525 0002EEBC fe 08 effffff3c5 callf $8,_writes
1538: 1526 0002EEC3 # writed( subtest );
1539: 1527 0002EEC3 dd effffff3bf pushl _subtest
1540: 1528 0002EEC9 fe 08 effffff3b8 callf $8,_writed
1541: 1529 0002EED0 # writes(" error - ");
1542: 1530 0002EED0 .data 1
1543: 1531 00000ebd * L363:
1544: 1532 00000ebd * 206572726F72202D2000 .ascii " error - \0"
1545: 1533 00000ec7 * .text
1546: 1534 0002EED0 dd 8f00000ebd pushl $L363
1547: 1535 0002EED6 fe 08 effffff3ab callf $8,_writes
1548: 1536 0002EEDD # writes( msg );
1549: 1537 0002EEDD dd ad04 pushl 4(fp)
1550: 1538 0002EEE0 fe 08 effffff3a1 callf $8,_writes
1551: 1539 0002EEE7 # writec('\n');
1552: 1540 0002EEE7 dd 0a pushl $10
1553: 1541 0002EEE9 fe 08 effffff398 callf $8,_writec
1554: 1542 0002EEF0 # writes(" LDD(1.0), MULD(op), MULD(1.0), SUBD(op), ADDD(op), STD\n");
1555: 1543 0002EEF0 .data 1
1556: 1544 00000ec7 * L365:
1557: 1545 00000ec7 * 204C444428312E30292C204D5 .ascii " LDD(1.0), MULD(op), MULD(1.0), SUBD(op), ADDD(op), STD\12\0"
1558: 54C44286F70292C204D554C44
1559: 28312E30292C2053554244286
1560: F70292C2041444444286F7029
1561: 2C205354440A00
1562: 1546 00000f00 * .text
1563: 1547 0002EEF0 dd 8f00000ec7 pushl $L365
1564: 1548 0002EEF6 fe 08 effffff38b callf $8,_writes
1565: 1549 0002EEFD # writes("operand = ");
1566: 1550 0002EEFD .data 1
1567: 1551 00000f00 * L366:
1568: 1552 00000f00 * 6F706572616E64203D2000 .ascii "operand = \0"
1569: 1553 00000f0b * .text
1570: 1554 0002EEFD dd 8f00000f00 pushl $L366
1571: 1555 0002EF03 fe 08 effffff37e callf $8,_writes
1572: 1556 0002EF0A # write32h( dbl_ld_acc.m );
1573: 1557 0002EF0A dd effffff378 pushl _dbl_ld_acc
1574: 1558 0002EF10 fe 08 effffff371 callf $8,_write32h
1575: 1559 0002EF17 # writec(' ');
1576: 1560 0002EF17 dd 20 pushl $32
1577: 1561 0002EF19 fe 08 effffff368 callf $8,_writec
1578: 1562 0002EF20 # write32h( dbl_ld_acc.l );
1579: 1563 0002EF20 dd effffff366 pushl _dbl_ld_acc+4
1580: 1564 0002EF26 fe 08 effffff35b callf $8,_write32h
1581: 1565 0002EF2D # writes(", final Acc = ");
1582: 1566 0002EF2D .data 1
1583: 1567 00000f0b * L367:
1584: 1568 00000f0b * 2C20202066696E616C2041636 .ascii ", final Acc = \0"
1585: 3203D2000
1586: 1569 00000f1c * .text
1587: 1570 0002EF2D dd 8f00000f0b pushl $L367
1588: 1571 0002EF33 fe 08 effffff34e callf $8,_writes
1589: 1572 0002EF3A # write32h( dbl_st_acc.m );
1590: 1573 0002EF3A dd effffff348 pushl _dbl_st_acc
1591: 1574 0002EF40 fe 08 effffff341 callf $8,_write32h
1592: 1575 0002EF47 # writec(' ');
1593: 1576 0002EF47 dd 20 pushl $32
1594: 1577 0002EF49 fe 08 effffff338 callf $8,_writec
1595: 1578 0002EF50 # write32h( dbl_st_acc.l );
1596: 1579 0002EF50 dd effffff336 pushl _dbl_st_acc+4
1597: 1580 0002EF56 fe 08 effffff32b callf $8,_write32h
1598: 1581 0002EF5D # writes(", index = ");
1599: 1582 0002EF5D .data 1
1600: 1583 00000f1c * L368:
1601: 1584 00000f1c * 2C202020696E646578203D200 .ascii ", index = \0"
1602: 0
1603: 1585 00000f29 * .text
1604: 1586 0002EF5D dd 8f00000f1c pushl $L368
1605: 1587 0002EF63 fe 08 effffff31e callf $8,_writes
1606: 1588 0002EF6A # writed( index );
1607: 1589 0002EF6A dd effffff318 pushl _index
1608: 1590 0002EF70 fe 08 effffff311 callf $8,_writed
1609: 1591 0002EF77 # writec('\n');
1610: 1592 0002EF77 dd 0a pushl $10
1611: 1593 0002EF79 fe 08 effffff308 callf $8,_writec
1612: 1594 0002EF80 # writes(" expected Acc = ");
1613: 1595 0002EF80 .data 1
1614: 1596 00000f29 * L369:
1615: 1597 00000f29 * 2020202020202020202020202 .ascii " expected Acc = \0"
1616: 0202020202020202020202020
1617: 2020206578706563746564204
1618: 16363203D2000
1619: 1598 00000f55 * .text
1620: 1599 0002EF80 dd 8f00000f29 pushl $L369
1621: 1600 0002EF86 fe 08 effffff2fb callf $8,_writes
1622: 1601 0002EF8D # write32h( dbl_expected.m );
1623: 1602 0002EF8D dd effffff2f5 pushl _dbl_expected
1624: 1603 0002EF93 fe 08 effffff2ee callf $8,_write32h
1625: 1604 0002EF9A # writec(' ');
1626: 1605 0002EF9A dd 20 pushl $32
1627: 1606 0002EF9C fe 08 effffff2e5 callf $8,_writec
1628: 1607 0002EFA3 # write32h( dbl_expected.l );
1629: 1608 0002EFA3 dd effffff2e3 pushl _dbl_expected+4
1630: 1609 0002EFA9 fe 08 effffff2d8 callf $8,_write32h
1631: 1610 0002EFB0 # writec('\n');
1632: 1611 0002EFB0 dd 0a pushl $10
1633: 1612 0002EFB2 fe 08 effffff2cf callf $8,_writec
1634: 1613 0002EFB9 # }
1635: 1614 0002EFB9 40 ret#2
1636: 1615 0002EFBA .set L354,0x0
1637: 1616 0002EFBA L356:
1638: 1617 0002EFBA 13 feb8 jbr L357
1639: 1618 0002EFBD .data
1640: 1619 00000db4 * .text
1641: 1620 0002EFBD 00 .align 1
1642: 1621 0002EFBE .globl _pipe13_er_hlt
1643: 1622 0002EFBE _pipe13_er_hlt:
1644: 1623 0002EFBE 0000 .word L370
1645: 1624 0002EFC0 #
1646: 1625 0002EFC0 #
1647: 1626 0002EFC0 #
1648: 1627 0002EFC0 #
1649: 1628 0002EFC0 #
1650: 1629 0002EFC0 # /******************************************************************************
1651: 1630 0002EFC0 # *
1652: 1631 0002EFC0 # * HALT ON ERROR ROUTINE
1653: 1632 0002EFC0 # *
1654: 1633 0002EFC0 # * halt with the necessary information saved in the registers
1655: 1634 0002EFC0 # *
1656: 1635 0002EFC0 # ******************************************************************************/
1657: 1636 0002EFC0 # pipe13_er_hlt( subtest )
1658: 1637 0002EFC0 # int subtest;
1659: 1638 0002EFC0 # {
1660: 1639 0002EFC0 11 75 jbr L372
1661: 1640 0002EFC2 L373:
1662: 1641 0002EFC2 # sgl_value_3 = dbl_st_acc.m;
1663: 1642 0002EFC2 0d effffff2c0 effffff2bb movl _dbl_st_acc,_sgl_value_3
1664: 1643 0002EFCD # sgl_value_4 = dbl_st_acc.l;
1665: 1644 0002EFCD 0d effffff2b9 effffff2b0 movl _dbl_st_acc+4,_sgl_value_4
1666: 1645 0002EFD8 # asm("movl _test_no,r0"); /* r0 = test number */
1667: 1646 0002EFD8 0d effffff2aa 50 movl _test_no,r0
1668: 1647 0002EFDF # asm("movl _subtest,r1"); /* r1 = subtest number */
1669: 1648 0002EFDF 0d effffff2a3 51 movl _subtest,r1
1670: 1649 0002EFE6 # asm("movl $1,r2"); /* r2 = error code */
1671: 1650 0002EFE6 0d 01 52 movl $1,r2
1672: 1651 0002EFE9 # asm("movl _cycle,r3"); /* r3 = cycle count */
1673: 1652 0002EFE9 0d effffff299 53 movl _cycle,r3
1674: 1653 0002EFF0 # asm("movl _sgl_value_1,r4"); /* r4 = MSW operand loaded */
1675: 1654 0002EFF0 0d effffff292 54 movl _sgl_value_1,r4
1676: 1655 0002EFF7 # asm("movl _sgl_value_2,r5"); /* r5 = LSW operand loaded */
1677: 1656 0002EFF7 0d effffff28b 55 movl _sgl_value_2,r5
1678: 1657 0002EFFE # asm("movl _sgl_value_3,r6"); /* r6 = MSW operand stored */
1679: 1658 0002EFFE 0d effffff284 56 movl _sgl_value_3,r6
1680: 1659 0002F005 # asm("movl _sgl_value_4,r7"); /* r7 = LSW operand stored */
1681: 1660 0002F005 0d effffff27d 57 movl _sgl_value_4,r7
1682: 1661 0002F00C # asm("movl _sgl_value_5,r8"); /* r8 = MSW operand expect */
1683: 1662 0002F00C 0d effffff276 58 movl _sgl_value_5,r8
1684: 1663 0002F013 # asm("movl _sgl_value_6,r9"); /* r9 = LSW operand expect */
1685: 1664 0002F013 0d effffff26f 59 movl _sgl_value_6,r9
1686: 1665 0002F01A # asm("movl _index,r10"); /* r10 = data index */
1687: 1666 0002F01A 0d effffff268 5a movl _index,r10
1688: 1667 0002F021 # if( subtest == 9 ) {
1689: 1668 0002F021 1d ad04 09 cmpl 4(fp),$9
1690: 1669 0002F025 21 0e jneq L374
1691: 1670 0002F027 # asm("movl _sgl_value_10,r11"); /* r11 = final FP value */
1692: 1671 0002F027 0d effffff25b 5b movl _sgl_value_10,r11
1693: 1672 0002F02E # asm("movl _sgl_value_9,r12"); /* r12 = expected FP value */
1694: 1673 0002F02E 0d effffff254 5c movl _sgl_value_9,r12
1695: 1674 0002F035 # };
1696: 1675 0002F035 L374:
1697: 1676 0002F035 # asm(".globl _pipe13_1_hlt");
1698: 1677 0002F035 .globl _pipe13_1_hlt
1699: 1678 0002F035 # asm("_pipe13_1_hlt:"); /* PC after the halt */
1700: 1679 0002F035 _pipe13_1_hlt:
1701: 1680 0002F035 # asm("halt"); /* HALT ... */
1702: 1681 0002F035 00 halt
1703: 1682 0002F036 # } /* end of halt on error */
1704: 1683 0002F036 40 ret#2
1705: 1684 0002F037 .set L370,0x0
1706: 1685 0002F037 L372:
1707: 1686 0002F037 11 89 jbr L373
1708: 1687 0002F039 .data
1709: 1687 0005D2C1 .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.