![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe16.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 pipe16.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 00000d34 * .text
4: 4 00000000 .align 1
5: 5 00000000 .globl _pipe_16
6: 6 00000000 _pipe_16:
7: 7 00031030 0000 .word L215
8: 8 00031032 # #include "fpp_defs.h"
9: 9 00031032 #
10: 10 00031032 #
11: 11 00031032 # /*****************************************************************************
12: 12 00031032 # *
13: 13 00031032 # * DBL PIPELINE TEST #16 MONITOR
14: 14 00031032 # *
15: 15 00031032 # * This test will do:
16: 16 00031032 # *
17: 17 00031032 # * LND(x) ADDD(x) SUBD(0) SUBD(x) STD
18: 18 00031032 # *
19: 19 00031032 # * where the x's are the LND data patterns.
20: 20 00031032 # *****************************************************************************/
21: 21 00031032 # pipe_16()
22: 22 00031032 # {
23: 23 00031032 13 009b jbr L217
24: 24 00031035 L218:
25: 25 00031035 # asm(".globl _pipeline_16_t");
26: 26 00031035 .globl _pipeline_16_t
27: 27 00031035 # asm("_pipeline_16_t:"); /* entry address */
28: 28 00031035 _pipeline_16_t:
29: 29 00031035 # if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */
30: 30 00031035 1d effffffff5 01 cmpl _cycle,$1
31: 31 0003103C 21 15 jneq L219
32: 32 0003103E 5d efffffffec tstl _prt_hdrs
33: 33 00031044 31 0d jeql L219
34: 34 00031046 # {
35: 35 00031046 # writes(" PIPE_16");
36: 36 00031046 .data 1
37: 37 00000d34 * L221:
38: 38 00000d34 * 20504950455F313600 .ascii " PIPE_16\0"
39: 39 00000d3d * .text
40: 40 00031046 dd 8f00000d34 pushl $L221
41: 41 0003104C fe 08 efffffffdd callf $8,_writes
42: 42 00031053 # }
43: 43 00031053 # subtest = 1;
44: 44 00031053 L219:
45: 45 00031053 0d 01 efffffffd6 movl $1,_subtest
46: 46 0003105A # pipe16_1(); /* data in REGs, no NOPs */
47: 47 0003105A fe 04 ef00000073 callf $4,_pipe16_1
48: 48 00031061 # subtest++; /* increment subtest num */
49: 49 00031061 6d efffffffc9 incl _subtest
50: 50 00031067 # pipe16_2(); /* data in REGs, 1 NOP */
51: 51 00031067 fe 04 ef00000194 callf $4,_pipe16_2
52: 52 0003106E # subtest++; /* increment subtest num */
53: 53 0003106E 6d efffffffbc incl _subtest
54: 54 00031074 # pipe16_3(); /* data in REGs, 2 NOPs */
55: 55 00031074 fe 04 ef000002b9 callf $4,_pipe16_3
56: 56 0003107B # subtest++; /* increment subtest num */
57: 57 0003107B 6d efffffffaf incl _subtest
58: 58 00031081 # pipe16_4(); /* data in REGs, 3 NOPs */
59: 59 00031081 fe 04 ef000003e2 callf $4,_pipe16_4
60: 60 00031088 # subtest++; /* increment subtest num */
61: 61 00031088 6d efffffffa2 incl _subtest
62: 62 0003108E # pipe16_5(); /* data in CACHE, no NOPs */
63: 63 0003108E fe 04 ef0000050f callf $4,_pipe16_5
64: 64 00031095 # subtest++; /* increment subtest num */
65: 65 00031095 6d efffffff95 incl _subtest
66: 66 0003109B # pipe16_6(); /* data in CACHE, 1 NOP */
67: 67 0003109B fe 04 ef000005fc callf $4,_pipe16_6
68: 68 000310A2 # subtest++; /* increment subtest num */
69: 69 000310A2 6d efffffff88 incl _subtest
70: 70 000310A8 # pipe16_7(); /* data in CACHE, 2 NOPs */
71: 71 000310A8 fe 04 ef000006ed callf $4,_pipe16_7
72: 72 000310AF # subtest++; /* increment subtest num */
73: 73 000310AF 6d efffffff7b incl _subtest
74: 74 000310B5 # pipe16_8(); /* data in CACHE, 3 NOPs */
75: 75 000310B5 fe 04 ef000007e2 callf $4,_pipe16_8
76: 76 000310BC # subtest++; /* increment subtest num */
77: 77 000310BC 6d efffffff6e incl _subtest
78: 78 000310C2 # pipe16_9(); /* data via F.P. 0 NOPs */
79: 79 000310C2 fe 04 ef000008db callf $4,_pipe16_9
80: 80 000310C9 # asm("jmp *return"); /* return to the test monitor */
81: 81 000310C9 71 ffffffff61 jmp *return
82: 82 000310CF # }
83: 83 000310CF 40 ret#2
84: 84 000310D0 .set L215,0x0
85: 85 000310D0 L217:
86: 86 000310D0 13 ff62 jbr L218
87: 87 000310D3 .data
88: 88 00000d34 * .text
89: 89 000310D3 00 .align 1
90: 90 000310D4 .globl _pipe16_1
91: 91 000310D4 _pipe16_1:
92: 92 000310D4 0000 .word L231
93: 93 000310D6 #
94: 94 000310D6 #
95: 95 000310D6 #
96: 96 000310D6 #
97: 97 000310D6 #
98: 98 000310D6 #
99: 99 000310D6 #
100: 100 000310D6 # /************************************************************************
101: 101 000310D6 # *
102: 102 000310D6 # * SUBTEST 1
103: 103 000310D6 # * data in registers, no NO-OPs
104: 104 000310D6 # *
105: 105 000310D6 # ************************************************************************/
106: 106 000310D6 # pipe16_1()
107: 107 000310D6 # {
108: 108 000310D6 13 0126 jbr L233
109: 109 000310D9 L234:
110: 110 000310D9 # force_loop = FALSE; /* clear the force_loop flg */
111: 111 000310D9 4d efffffff51 clrl _force_loop
112: 112 000310DF # index = 0;
113: 113 000310DF 4d efffffff4b clrl _index
114: 114 000310E5 # do
115: 115 000310E5 L237:
116: 116 000310E5 # {
117: 117 000310E5 # sgl_value_1 = lnd_1_data[index].ld.m; /* get the operand's MSW */
118: 118 000310E5 0d efffffff45 50 movl _index,r0
119: 119 000310EC 48 04 50 50 shll $4,r0,r0
120: 120 000310F0 0d e000000000 efffffff35 movl _lnd_1_data(r0),_sgl_value_1
121: 121 000310FB # sgl_value_2 = lnd_1_data[index].ld.l; /* get the operand's MSW */
122: 122 000310FB 0d efffffff2f 50 movl _index,r0
123: 123 00031102 48 04 50 50 shll $4,r0,r0
124: 124 00031106 0d e000000004 efffffff1f movl _lnd_1_data+4(r0),_sgl_value_2
125: 125 00031111 # sgl_value_7 = 0; /* get a '0.0' */
126: 126 00031111 4d efffffff19 clrl _sgl_value_7
127: 127 00031117 # dbl_expected = lnd_1_data[index].exp; /* get the expected results */
128: 128 00031117 48 04 efffffff12 50 shll $4,_index,r0
129: 129 0003111F 0c 8f00000008 50 addl2 $_lnd_1_data+8,r0
130: 130 00031126 0d a004 efffffff06 movl 4(r0),_dbl_expected+4
131: 131 0003112E 0d 60 effffffefb movl (r0),_dbl_expected
132: 132 00031135 # /*
133: 133 00031135 # * If LOOP ON ERROR is set, this is the loop for this subtest.
134: 134 00031135 # * The force loop flag is set after the first error.
135: 135 00031135 # */
136: 136 00031135 # asm("_pipe16_1_lp1:");
137: 137 00031135 _pipe16_1_lp1:
138: 138 00031135 # asm("movl _sgl_value_1,r4"); /* move the data to r4/r5 */
139: 139 00031135 0d effffffef5 54 movl _sgl_value_1,r4
140: 140 0003113C # asm("movl _sgl_value_2,r5");
141: 141 0003113C 0d effffffeee 55 movl _sgl_value_2,r5
142: 142 00031143 # asm("movl _sgl_value_7,r2"); /* move a '0.0' to r2/r3 */
143: 143 00031143 0d effffffee7 52 movl _sgl_value_7,r2
144: 144 0003114A # asm("movl _sgl_value_7,r3");
145: 145 0003114A 0d effffffee0 53 movl _sgl_value_7,r3
146: 146 00031151 # asm("lnd r4"); /* load the operand (-op ) */
147: 147 00031151 17 54 lnd r4
148: 148 00031153 # asm("addd r4"); /* add the operand ( 0 ) */
149: 149 00031153 c7 54 addd r4
150: 150 00031155 # asm("subd r2"); /* subtract a '0.0' ( 0 ) */
151: 151 00031155 d7 52 subd r2
152: 152 00031157 # asm("subd r4"); /* subtract the op (-op ) */
153: 153 00031157 d7 54 subd r4
154: 154 00031159 # asm("std r6"); /* store the result (-op ) */
155: 155 00031159 27 56 std r6
156: 156 0003115B # if( force_loop )
157: 157 0003115B 5d effffffecf tstl _force_loop
158: 158 00031161 31 02 jeql L238
159: 159 00031163 # asm("brb _pipe16_1_lp1");; /* run the loop again */
160: 160 00031163 11 d0 brb _pipe16_1_lp1
161: 161 00031165 L238:
162: 162 00031165 # /*
163: 163 00031165 # * verify the results
164: 164 00031165 # */
165: 165 00031165 # asm("movl r6,_sgl_value_3"); /* get the result */
166: 166 00031165 0d 56 effffffec4 movl r6,_sgl_value_3
167: 167 0003116C # asm("movl r7,_sgl_value_4");
168: 168 0003116C 0d 57 effffffebd movl r7,_sgl_value_4
169: 169 00031173 # dbl_st_acc.m = sgl_value_3;
170: 170 00031173 0d effffffeb7 effffffeb2 movl _sgl_value_3,_dbl_st_acc
171: 171 0003117E # dbl_st_acc.l = sgl_value_4;
172: 172 0003117E 0d effffffeac effffffeab movl _sgl_value_4,_dbl_st_acc+4
173: 173 00031189 # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
174: 174 00031189 # (dbl_st_acc.l != dbl_expected.l) )
175: 175 00031189 1d effffffea1 effffffe9c cmpl _dbl_st_acc,_dbl_expected
176: 176 00031194 21 0d jneq L9999
177: 177 00031196 1d effffffe98 effffffe93 cmpl _dbl_st_acc+4,_dbl_expected+4
178: 178 000311A1 31 42 jeql L239
179: 179 000311A3 L9999:
180: 180 000311A3 # {
181: 181 000311A3 # errcnt++; /* bump the error count */
182: 182 000311A3 6d effffffe87 incl _errcnt
183: 183 000311A9 # if ( prt_error )
184: 184 000311A9 5d effffffe81 tstl _prt_error
185: 185 000311AF 31 0d jeql L240
186: 186 000311B1 # print_pipe16_er("Reg. Data, no NOPs");
187: 187 000311B1 .data 1
188: 188 00000d3d * L242:
189: 189 00000d3d * 5265672E20446174612C206E6 .ascii "Reg. Data, no NOPs\0"
190: F204E4F507300
191: 190 00000d50 * .text
192: 191 000311B1 dd 8f00000d3d pushl $L242
193: 192 000311B7 fe 08 ef000009dc callf $8,_print_pipe16_er
194: 193 000311BE # if ( halt_flg ) /* halt on error? */
195: 194 000311BE L240:
196: 195 000311BE 5d effffffe6c tstl _halt_flg
197: 196 000311C4 31 0d jeql L243
198: 197 000311C6 # pipe16_er_hlt( subtest );
199: 198 000311C6 dd effffffe64 pushl _subtest
200: 199 000311CC fe 08 ef00000b15 callf $8,_pipe16_er_hlt
201: 200 000311D3 # if ( loop_on_err ) {
202: 201 000311D3 L243:
203: 202 000311D3 5d effffffe57 tstl _loop_on_err
204: 203 000311D9 31 0a jeql L245
205: 204 000311DB # force_loop = TRUE; /* set the force loop flag */
206: 205 000311DB 0d 01 effffffe4e movl $1,_force_loop
207: 206 000311E2 # asm("brw _pipe16_1_lp1"); /* and loop */
208: 207 000311E2 13 ff50 brw _pipe16_1_lp1
209: 208 000311E5 # }
210: 209 000311E5 # } /* end of compare error */
211: 210 000311E5 L245:
212: 211 000311E5 # } while( index++ < max_lnd_1_index );
213: 212 000311E5 L239:
214: 213 000311E5 L236:
215: 214 000311E5 0d effffffe45 50 movl _index,r0
216: 215 000311EC 6d effffffe3e incl _index
217: 216 000311F2 1d 50 effffffe37 cmpl r0,_max_lnd_1_index
218: 217 000311F9 81 03 13 fee7 jlss L237
219: 218 000311FE L235:
220: 219 000311FE # } /* end of subtest 1 */
221: 220 000311FE 40 ret#2
222: 221 000311FF .set L231,0x0
223: 222 000311FF L233:
224: 223 000311FF 13 fed7 jbr L234
225: 224 00031202 .data
226: 225 00000d34 * .text
227: 226 00031202 .align 1
228: 227 00031202 .globl _pipe16_2
229: 228 00031202 _pipe16_2:
230: 229 00031202 0000 .word L246
231: 230 00031204 #
232: 231 00031204 #
233: 232 00031204 #
234: 233 00031204 #
235: 234 00031204 #
236: 235 00031204 #
237: 236 00031204 #
238: 237 00031204 #
239: 238 00031204 # /************************************************************************
240: 239 00031204 # *
241: 240 00031204 # * SUBTEST 2
242: 241 00031204 # * data in registers, 1 NO-OP
243: 242 00031204 # *
244: 243 00031204 # ************************************************************************/
245: 244 00031204 # pipe16_2()
246: 245 00031204 # {
247: 246 00031204 13 012a jbr L248
248: 247 00031207 L249:
249: 248 00031207 # force_loop = FALSE; /* clear the force_loop flg */
250: 249 00031207 4d effffffe23 clrl _force_loop
251: 250 0003120D # index = 0;
252: 251 0003120D 4d effffffe1d clrl _index
253: 252 00031213 # do
254: 253 00031213 L252:
255: 254 00031213 # {
256: 255 00031213 # sgl_value_1 = lnd_1_data[index].ld.m; /* get the operand's MSW */
257: 256 00031213 0d effffffe17 50 movl _index,r0
258: 257 0003121A 48 04 50 50 shll $4,r0,r0
259: 258 0003121E 0d e000000000 effffffe07 movl _lnd_1_data(r0),_sgl_value_1
260: 259 00031229 # sgl_value_2 = lnd_1_data[index].ld.l; /* get the operand's MSW */
261: 260 00031229 0d effffffe01 50 movl _index,r0
262: 261 00031230 48 04 50 50 shll $4,r0,r0
263: 262 00031234 0d e000000004 effffffdf1 movl _lnd_1_data+4(r0),_sgl_value_2
264: 263 0003123F # sgl_value_7 = 0; /* get a '0.0' */
265: 264 0003123F 4d effffffdeb clrl _sgl_value_7
266: 265 00031245 # dbl_expected = lnd_1_data[index].exp; /* get the expected results */
267: 266 00031245 48 04 effffffde4 50 shll $4,_index,r0
268: 267 0003124D 0c 8f00000008 50 addl2 $_lnd_1_data+8,r0
269: 268 00031254 0d a004 effffffdd8 movl 4(r0),_dbl_expected+4
270: 269 0003125C 0d 60 effffffdcd movl (r0),_dbl_expected
271: 270 00031263 # /*
272: 271 00031263 # * If LOOP ON ERROR is set, this is the loop for this subtest.
273: 272 00031263 # * The force loop flag is set after the first error.
274: 273 00031263 # */
275: 274 00031263 # asm("_pipe16_2_lp1:");
276: 275 00031263 _pipe16_2_lp1:
277: 276 00031263 # asm("movl _sgl_value_1,r4"); /* move the data to r4/r5 */
278: 277 00031263 0d effffffdc7 54 movl _sgl_value_1,r4
279: 278 0003126A # asm("movl _sgl_value_2,r5");
280: 279 0003126A 0d effffffdc0 55 movl _sgl_value_2,r5
281: 280 00031271 # asm("movl _sgl_value_7,r2"); /* move a '0.0' to r2/r3 */
282: 281 00031271 0d effffffdb9 52 movl _sgl_value_7,r2
283: 282 00031278 # asm("movl _sgl_value_7,r3");
284: 283 00031278 0d effffffdb2 53 movl _sgl_value_7,r3
285: 284 0003127F # asm("lnd r4"); /* load the operand (-op ) */
286: 285 0003127F 17 54 lnd r4
287: 286 00031281 # asm("nop");
288: 287 00031281 10 nop
289: 288 00031282 # asm("addd r4"); /* add the operand ( 0 ) */
290: 289 00031282 c7 54 addd r4
291: 290 00031284 # asm("nop");
292: 291 00031284 10 nop
293: 292 00031285 # asm("subd r2"); /* subtract a '0.0' ( 0 ) */
294: 293 00031285 d7 52 subd r2
295: 294 00031287 # asm("nop");
296: 295 00031287 10 nop
297: 296 00031288 # asm("subd r4"); /* subtract the op (-op ) */
298: 297 00031288 d7 54 subd r4
299: 298 0003128A # asm("nop");
300: 299 0003128A 10 nop
301: 300 0003128B # asm("std r6"); /* store the result (-op ) */
302: 301 0003128B 27 56 std r6
303: 302 0003128D # if( force_loop )
304: 303 0003128D 5d effffffd9d tstl _force_loop
305: 304 00031293 31 02 jeql L253
306: 305 00031295 # asm("brb _pipe16_2_lp1");; /* run the loop again */
307: 306 00031295 11 cc brb _pipe16_2_lp1
308: 307 00031297 L253:
309: 308 00031297 # /*
310: 309 00031297 # * verify the results
311: 310 00031297 # */
312: 311 00031297 # asm("movl r6,_sgl_value_3"); /* get the result */
313: 312 00031297 0d 56 effffffd92 movl r6,_sgl_value_3
314: 313 0003129E # asm("movl r7,_sgl_value_4");
315: 314 0003129E 0d 57 effffffd8b movl r7,_sgl_value_4
316: 315 000312A5 # dbl_st_acc.m = sgl_value_3;
317: 316 000312A5 0d effffffd85 effffffd80 movl _sgl_value_3,_dbl_st_acc
318: 317 000312B0 # dbl_st_acc.l = sgl_value_4;
319: 318 000312B0 0d effffffd7a effffffd79 movl _sgl_value_4,_dbl_st_acc+4
320: 319 000312BB # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
321: 320 000312BB # (dbl_st_acc.l != dbl_expected.l) )
322: 321 000312BB 1d effffffd6f effffffd6a cmpl _dbl_st_acc,_dbl_expected
323: 322 000312C6 21 0d jneq L9998
324: 323 000312C8 1d effffffd66 effffffd61 cmpl _dbl_st_acc+4,_dbl_expected+4
325: 324 000312D3 31 42 jeql L254
326: 325 000312D5 L9998:
327: 326 000312D5 # {
328: 327 000312D5 # errcnt++; /* bump the error count */
329: 328 000312D5 6d effffffd55 incl _errcnt
330: 329 000312DB # if ( prt_error )
331: 330 000312DB 5d effffffd4f tstl _prt_error
332: 331 000312E1 31 0d jeql L255
333: 332 000312E3 # print_pipe16_er("Reg. Data, 1 NOP");
334: 333 000312E3 .data 1
335: 334 00000d50 * L256:
336: 335 00000d50 * 5265672E20446174612C20312 .ascii "Reg. Data, 1 NOP\0"
337: 04E4F5000
338: 336 00000d61 * .text
339: 337 000312E3 dd 8f00000d50 pushl $L256
340: 338 000312E9 fe 08 ef000008aa callf $8,_print_pipe16_er
341: 339 000312F0 # if ( halt_flg ) /* halt on error? */
342: 340 000312F0 L255:
343: 341 000312F0 5d effffffd3a tstl _halt_flg
344: 342 000312F6 31 0d jeql L257
345: 343 000312F8 # pipe16_er_hlt( subtest );
346: 344 000312F8 dd effffffd32 pushl _subtest
347: 345 000312FE fe 08 ef000009e3 callf $8,_pipe16_er_hlt
348: 346 00031305 # if ( force_loop ) { /* loop on error? */
349: 347 00031305 L257:
350: 348 00031305 5d effffffd25 tstl _force_loop
351: 349 0003130B 31 0a jeql L258
352: 350 0003130D # force_loop = TRUE; /* set the force loop flag */
353: 351 0003130D 0d 01 effffffd1c movl $1,_force_loop
354: 352 00031314 # asm("brw _pipe16_2_lp1"); /* and loop */
355: 353 00031314 13 ff4c brw _pipe16_2_lp1
356: 354 00031317 # }
357: 355 00031317 # } /* end of compare error */
358: 356 00031317 L258:
359: 357 00031317 # } while( index++ < max_lnd_1_index );
360: 358 00031317 L254:
361: 359 00031317 L251:
362: 360 00031317 0d effffffd13 50 movl _index,r0
363: 361 0003131E 6d effffffd0c incl _index
364: 362 00031324 1d 50 effffffd05 cmpl r0,_max_lnd_1_index
365: 363 0003132B 81 03 13 fee3 jlss L252
366: 364 00031330 L250:
367: 365 00031330 # } /* end of subtest 2 */
368: 366 00031330 40 ret#2
369: 367 00031331 .set L246,0x0
370: 368 00031331 L248:
371: 369 00031331 13 fed3 jbr L249
372: 370 00031334 .data
373: 371 00000d34 * .text
374: 372 00031334 .align 1
375: 373 00031334 .globl _pipe16_3
376: 374 00031334 _pipe16_3:
377: 375 00031334 0000 .word L259
378: 376 00031336 #
379: 377 00031336 #
380: 378 00031336 #
381: 379 00031336 #
382: 380 00031336 #
383: 381 00031336 #
384: 382 00031336 #
385: 383 00031336 #
386: 384 00031336 # /************************************************************************
387: 385 00031336 # *
388: 386 00031336 # * SUBTEST 3
389: 387 00031336 # * data in registers, 2 NO-OPs
390: 388 00031336 # *
391: 389 00031336 # ************************************************************************/
392: 390 00031336 # pipe16_3()
393: 391 00031336 # {
394: 392 00031336 13 012e jbr L261
395: 393 00031339 L262:
396: 394 00031339 # force_loop = FALSE; /* clear the force_loop flg */
397: 395 00031339 4d effffffcf1 clrl _force_loop
398: 396 0003133F # index = 0;
399: 397 0003133F 4d effffffceb clrl _index
400: 398 00031345 # do
401: 399 00031345 L265:
402: 400 00031345 # {
403: 401 00031345 # sgl_value_1 = lnd_1_data[index].ld.m; /* get the operand's MSW */
404: 402 00031345 0d effffffce5 50 movl _index,r0
405: 403 0003134C 48 04 50 50 shll $4,r0,r0
406: 404 00031350 0d e000000000 effffffcd5 movl _lnd_1_data(r0),_sgl_value_1
407: 405 0003135B # sgl_value_2 = lnd_1_data[index].ld.l; /* get the operand's MSW */
408: 406 0003135B 0d effffffccf 50 movl _index,r0
409: 407 00031362 48 04 50 50 shll $4,r0,r0
410: 408 00031366 0d e000000004 effffffcbf movl _lnd_1_data+4(r0),_sgl_value_2
411: 409 00031371 # sgl_value_7 = 0; /* get a '0.0' */
412: 410 00031371 4d effffffcb9 clrl _sgl_value_7
413: 411 00031377 # dbl_expected = lnd_1_data[index].exp; /* get the expected results */
414: 412 00031377 48 04 effffffcb2 50 shll $4,_index,r0
415: 413 0003137F 0c 8f00000008 50 addl2 $_lnd_1_data+8,r0
416: 414 00031386 0d a004 effffffca6 movl 4(r0),_dbl_expected+4
417: 415 0003138E 0d 60 effffffc9b movl (r0),_dbl_expected
418: 416 00031395 # /*
419: 417 00031395 # * If LOOP ON ERROR is set, this is the loop for this subtest.
420: 418 00031395 # * The force loop flag is set after the first error.
421: 419 00031395 # */
422: 420 00031395 # asm("_pipe16_3_lp1:");
423: 421 00031395 _pipe16_3_lp1:
424: 422 00031395 # asm("movl _sgl_value_1,r4"); /* move the data to r4/r5 */
425: 423 00031395 0d effffffc95 54 movl _sgl_value_1,r4
426: 424 0003139C # asm("movl _sgl_value_2,r5");
427: 425 0003139C 0d effffffc8e 55 movl _sgl_value_2,r5
428: 426 000313A3 # asm("movl _sgl_value_7,r2"); /* move a '0.0' to r2/r3 */
429: 427 000313A3 0d effffffc87 52 movl _sgl_value_7,r2
430: 428 000313AA # asm("movl _sgl_value_7,r3");
431: 429 000313AA 0d effffffc80 53 movl _sgl_value_7,r3
432: 430 000313B1 # asm("lnd r4"); /* load the operand (-op ) */
433: 431 000313B1 17 54 lnd r4
434: 432 000313B3 # asm("nop");
435: 433 000313B3 10 nop
436: 434 000313B4 # asm("nop");
437: 435 000313B4 10 nop
438: 436 000313B5 # asm("addd r4"); /* add the operand ( 0 ) */
439: 437 000313B5 c7 54 addd r4
440: 438 000313B7 # asm("nop");
441: 439 000313B7 10 nop
442: 440 000313B8 # asm("nop");
443: 441 000313B8 10 nop
444: 442 000313B9 # asm("subd r2"); /* subtract a '0.0' ( 0 ) */
445: 443 000313B9 d7 52 subd r2
446: 444 000313BB # asm("nop");
447: 445 000313BB 10 nop
448: 446 000313BC # asm("nop");
449: 447 000313BC 10 nop
450: 448 000313BD # asm("subd r4"); /* subtract the op (-op ) */
451: 449 000313BD d7 54 subd r4
452: 450 000313BF # asm("nop");
453: 451 000313BF 10 nop
454: 452 000313C0 # asm("nop");
455: 453 000313C0 10 nop
456: 454 000313C1 # asm("std r6"); /* store the result (-op ) */
457: 455 000313C1 27 56 std r6
458: 456 000313C3 # if( force_loop )
459: 457 000313C3 5d effffffc67 tstl _force_loop
460: 458 000313C9 31 02 jeql L266
461: 459 000313CB # asm("brb _pipe16_3_lp1");; /* run the loop again */
462: 460 000313CB 11 c8 brb _pipe16_3_lp1
463: 461 000313CD L266:
464: 462 000313CD # /*
465: 463 000313CD # * verify the results
466: 464 000313CD # */
467: 465 000313CD # asm("movl r6,_sgl_value_3"); /* get the result */
468: 466 000313CD 0d 56 effffffc5c movl r6,_sgl_value_3
469: 467 000313D4 # asm("movl r7,_sgl_value_4");
470: 468 000313D4 0d 57 effffffc55 movl r7,_sgl_value_4
471: 469 000313DB # dbl_st_acc.m = sgl_value_3;
472: 470 000313DB 0d effffffc4f effffffc4a movl _sgl_value_3,_dbl_st_acc
473: 471 000313E6 # dbl_st_acc.l = sgl_value_4;
474: 472 000313E6 0d effffffc44 effffffc43 movl _sgl_value_4,_dbl_st_acc+4
475: 473 000313F1 # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
476: 474 000313F1 # (dbl_st_acc.l != dbl_expected.l) )
477: 475 000313F1 1d effffffc39 effffffc34 cmpl _dbl_st_acc,_dbl_expected
478: 476 000313FC 21 0d jneq L9997
479: 477 000313FE 1d effffffc30 effffffc2b cmpl _dbl_st_acc+4,_dbl_expected+4
480: 478 00031409 31 42 jeql L267
481: 479 0003140B L9997:
482: 480 0003140B # {
483: 481 0003140B # errcnt++; /* bump the error count */
484: 482 0003140B 6d effffffc1f incl _errcnt
485: 483 00031411 # if ( prt_error )
486: 484 00031411 5d effffffc19 tstl _prt_error
487: 485 00031417 31 0d jeql L268
488: 486 00031419 # print_pipe16_er("Reg. Data, 2 NOPs");
489: 487 00031419 .data 1
490: 488 00000d61 * L269:
491: 489 00000d61 * 5265672E20446174612C20322 .ascii "Reg. Data, 2 NOPs\0"
492: 04E4F507300
493: 490 00000d73 * .text
494: 491 00031419 dd 8f00000d61 pushl $L269
495: 492 0003141F fe 08 ef00000774 callf $8,_print_pipe16_er
496: 493 00031426 # if ( halt_flg ) /* halt on error? */
497: 494 00031426 L268:
498: 495 00031426 5d effffffc04 tstl _halt_flg
499: 496 0003142C 31 0d jeql L270
500: 497 0003142E # pipe16_er_hlt( subtest );
501: 498 0003142E dd effffffbfc pushl _subtest
502: 499 00031434 fe 08 ef000008ad callf $8,_pipe16_er_hlt
503: 500 0003143B # if ( loop_on_err ) {
504: 501 0003143B L270:
505: 502 0003143B 5d effffffbef tstl _loop_on_err
506: 503 00031441 31 0a jeql L271
507: 504 00031443 # force_loop = TRUE; /* set the force loop flag */
508: 505 00031443 0d 01 effffffbe6 movl $1,_force_loop
509: 506 0003144A # asm("brw _pipe16_3_lp1"); /* and loop */
510: 507 0003144A 13 ff48 brw _pipe16_3_lp1
511: 508 0003144D # }
512: 509 0003144D # } /* end of compare error */
513: 510 0003144D L271:
514: 511 0003144D # } while( index++ < max_lnd_1_index );
515: 512 0003144D L267:
516: 513 0003144D L264:
517: 514 0003144D 0d effffffbdd 50 movl _index,r0
518: 515 00031454 6d effffffbd6 incl _index
519: 516 0003145A 1d 50 effffffbcf cmpl r0,_max_lnd_1_index
520: 517 00031461 81 03 13 fedf jlss L265
521: 518 00031466 L263:
522: 519 00031466 # } /* end of subtest 7 */
523: 520 00031466 40 ret#2
524: 521 00031467 .set L259,0x0
525: 522 00031467 L261:
526: 523 00031467 13 fecf jbr L262
527: 524 0003146A .data
528: 525 00000d34 * .text
529: 526 0003146A .align 1
530: 527 0003146A .globl _pipe16_4
531: 528 0003146A _pipe16_4:
532: 529 0003146A 0000 .word L272
533: 530 0003146C #
534: 531 0003146C #
535: 532 0003146C #
536: 533 0003146C #
537: 534 0003146C #
538: 535 0003146C #
539: 536 0003146C #
540: 537 0003146C # /************************************************************************
541: 538 0003146C # *
542: 539 0003146C # * SUBTEST 4
543: 540 0003146C # * data in registers, 3 NO-OPs
544: 541 0003146C # *
545: 542 0003146C # ************************************************************************/
546: 543 0003146C # pipe16_4()
547: 544 0003146C # {
548: 545 0003146C 13 0132 jbr L274
549: 546 0003146F L275:
550: 547 0003146F # force_loop = FALSE; /* clear the force_loop flg */
551: 548 0003146F 4d effffffbbb clrl _force_loop
552: 549 00031475 # index = 0;
553: 550 00031475 4d effffffbb5 clrl _index
554: 551 0003147B # do
555: 552 0003147B L278:
556: 553 0003147B # {
557: 554 0003147B # sgl_value_1 = lnd_1_data[index].ld.m; /* get the operand's MSW */
558: 555 0003147B 0d effffffbaf 50 movl _index,r0
559: 556 00031482 48 04 50 50 shll $4,r0,r0
560: 557 00031486 0d e000000000 effffffb9f movl _lnd_1_data(r0),_sgl_value_1
561: 558 00031491 # sgl_value_2 = lnd_1_data[index].ld.l; /* get the operand's MSW */
562: 559 00031491 0d effffffb99 50 movl _index,r0
563: 560 00031498 48 04 50 50 shll $4,r0,r0
564: 561 0003149C 0d e000000004 effffffb89 movl _lnd_1_data+4(r0),_sgl_value_2
565: 562 000314A7 # sgl_value_7 = 0; /* get a '0.0' */
566: 563 000314A7 4d effffffb83 clrl _sgl_value_7
567: 564 000314AD # dbl_expected = lnd_1_data[index].exp; /* get the expected results */
568: 565 000314AD 48 04 effffffb7c 50 shll $4,_index,r0
569: 566 000314B5 0c 8f00000008 50 addl2 $_lnd_1_data+8,r0
570: 567 000314BC 0d a004 effffffb70 movl 4(r0),_dbl_expected+4
571: 568 000314C4 0d 60 effffffb65 movl (r0),_dbl_expected
572: 569 000314CB # /*
573: 570 000314CB # * If LOOP ON ERROR is set, this is the loop for this subtest.
574: 571 000314CB # * The force loop flag is set after the first error.
575: 572 000314CB # */
576: 573 000314CB # asm("_pipe16_4_lp1:");
577: 574 000314CB _pipe16_4_lp1:
578: 575 000314CB # asm("movl _sgl_value_1,r4"); /* move the data to r4/r5 */
579: 576 000314CB 0d effffffb5f 54 movl _sgl_value_1,r4
580: 577 000314D2 # asm("movl _sgl_value_2,r5");
581: 578 000314D2 0d effffffb58 55 movl _sgl_value_2,r5
582: 579 000314D9 # asm("movl _sgl_value_7,r2"); /* move a '0.0' to r2/r3 */
583: 580 000314D9 0d effffffb51 52 movl _sgl_value_7,r2
584: 581 000314E0 # asm("movl _sgl_value_7,r3");
585: 582 000314E0 0d effffffb4a 53 movl _sgl_value_7,r3
586: 583 000314E7 # asm("lnd r4"); /* load the operand (-op ) */
587: 584 000314E7 17 54 lnd r4
588: 585 000314E9 # asm("nop");
589: 586 000314E9 10 nop
590: 587 000314EA # asm("nop");
591: 588 000314EA 10 nop
592: 589 000314EB # asm("nop");
593: 590 000314EB 10 nop
594: 591 000314EC # asm("addd r4"); /* add the operand ( 0 ) */
595: 592 000314EC c7 54 addd r4
596: 593 000314EE # asm("nop");
597: 594 000314EE 10 nop
598: 595 000314EF # asm("nop");
599: 596 000314EF 10 nop
600: 597 000314F0 # asm("nop");
601: 598 000314F0 10 nop
602: 599 000314F1 # asm("subd r2"); /* subtract a '0.0' ( 0 ) */
603: 600 000314F1 d7 52 subd r2
604: 601 000314F3 # asm("nop");
605: 602 000314F3 10 nop
606: 603 000314F4 # asm("nop");
607: 604 000314F4 10 nop
608: 605 000314F5 # asm("nop");
609: 606 000314F5 10 nop
610: 607 000314F6 # asm("subd r4"); /* subtract the op (-op ) */
611: 608 000314F6 d7 54 subd r4
612: 609 000314F8 # asm("nop");
613: 610 000314F8 10 nop
614: 611 000314F9 # asm("nop");
615: 612 000314F9 10 nop
616: 613 000314FA # asm("nop");
617: 614 000314FA 10 nop
618: 615 000314FB # asm("std r6"); /* store the result (-op ) */
619: 616 000314FB 27 56 std r6
620: 617 000314FD # if( force_loop )
621: 618 000314FD 5d effffffb2d tstl _force_loop
622: 619 00031503 31 02 jeql L279
623: 620 00031505 # asm("brb _pipe16_4_lp1");; /* run the loop again */
624: 621 00031505 11 c4 brb _pipe16_4_lp1
625: 622 00031507 L279:
626: 623 00031507 # /*
627: 624 00031507 # * verify the results
628: 625 00031507 # */
629: 626 00031507 # asm("movl r6,_sgl_value_3"); /* get the result */
630: 627 00031507 0d 56 effffffb22 movl r6,_sgl_value_3
631: 628 0003150E # asm("movl r7,_sgl_value_4");
632: 629 0003150E 0d 57 effffffb1b movl r7,_sgl_value_4
633: 630 00031515 # dbl_st_acc.m = sgl_value_3;
634: 631 00031515 0d effffffb15 effffffb10 movl _sgl_value_3,_dbl_st_acc
635: 632 00031520 # dbl_st_acc.l = sgl_value_4;
636: 633 00031520 0d effffffb0a effffffb09 movl _sgl_value_4,_dbl_st_acc+4
637: 634 0003152B # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
638: 635 0003152B # (dbl_st_acc.l != dbl_expected.l) )
639: 636 0003152B 1d effffffaff effffffafa cmpl _dbl_st_acc,_dbl_expected
640: 637 00031536 21 0d jneq L9996
641: 638 00031538 1d effffffaf6 effffffaf1 cmpl _dbl_st_acc+4,_dbl_expected+4
642: 639 00031543 31 42 jeql L280
643: 640 00031545 L9996:
644: 641 00031545 # {
645: 642 00031545 # errcnt++; /* bump the error count */
646: 643 00031545 6d effffffae5 incl _errcnt
647: 644 0003154B # if ( prt_error )
648: 645 0003154B 5d effffffadf tstl _prt_error
649: 646 00031551 31 0d jeql L281
650: 647 00031553 # print_pipe16_er("Reg. Data, 3 NOPs");
651: 648 00031553 .data 1
652: 649 00000d73 * L282:
653: 650 00000d73 * 5265672E20446174612C20332 .ascii "Reg. Data, 3 NOPs\0"
654: 04E4F507300
655: 651 00000d85 * .text
656: 652 00031553 dd 8f00000d73 pushl $L282
657: 653 00031559 fe 08 ef0000063a callf $8,_print_pipe16_er
658: 654 00031560 # if ( halt_flg ) /* halt on error? */
659: 655 00031560 L281:
660: 656 00031560 5d effffffaca tstl _halt_flg
661: 657 00031566 31 0d jeql L283
662: 658 00031568 # pipe16_er_hlt( subtest );
663: 659 00031568 dd effffffac2 pushl _subtest
664: 660 0003156E fe 08 ef00000773 callf $8,_pipe16_er_hlt
665: 661 00031575 # if ( loop_on_err ) {
666: 662 00031575 L283:
667: 663 00031575 5d effffffab5 tstl _loop_on_err
668: 664 0003157B 31 0a jeql L284
669: 665 0003157D # force_loop = TRUE; /* set the force loop flag */
670: 666 0003157D 0d 01 effffffaac movl $1,_force_loop
671: 667 00031584 # asm("brw _pipe16_4_lp1"); /* and loop */
672: 668 00031584 13 ff44 brw _pipe16_4_lp1
673: 669 00031587 # }
674: 670 00031587 # } /* end of compare error */
675: 671 00031587 L284:
676: 672 00031587 # } while( index++ < max_lnd_1_index );
677: 673 00031587 L280:
678: 674 00031587 L277:
679: 675 00031587 0d effffffaa3 50 movl _index,r0
680: 676 0003158E 6d effffffa9c incl _index
681: 677 00031594 1d 50 effffffa95 cmpl r0,_max_lnd_1_index
682: 678 0003159B 81 03 13 fedb jlss L278
683: 679 000315A0 L276:
684: 680 000315A0 # } /* end of subtest 4 */
685: 681 000315A0 40 ret#2
686: 682 000315A1 .set L272,0x0
687: 683 000315A1 L274:
688: 684 000315A1 13 fecb jbr L275
689: 685 000315A4 .data
690: 686 00000d34 * .text
691: 687 000315A4 .align 1
692: 688 000315A4 .globl _pipe16_5
693: 689 000315A4 _pipe16_5:
694: 690 000315A4 0000 .word L285
695: 691 000315A6 #
696: 692 000315A6 #
697: 693 000315A6 #
698: 694 000315A6 #
699: 695 000315A6 #
700: 696 000315A6 #
701: 697 000315A6 #
702: 698 000315A6 # /************************************************************************
703: 699 000315A6 # *
704: 700 000315A6 # * SUBTEST 5
705: 701 000315A6 # * data in cache, no NO-OPs
706: 702 000315A6 # *
707: 703 000315A6 # ************************************************************************/
708: 704 000315A6 # pipe16_5()
709: 705 000315A6 # {
710: 706 000315A6 13 00f2 jbr L287
711: 707 000315A9 L288:
712: 708 000315A9 # force_loop = FALSE; /* clear the force_loop flg */
713: 709 000315A9 4d effffffa81 clrl _force_loop
714: 710 000315AF # index = 0;
715: 711 000315AF 4d effffffa7b clrl _index
716: 712 000315B5 # do
717: 713 000315B5 L291:
718: 714 000315B5 # {
719: 715 000315B5 # dbl_value_1 = lnd_1_data[index].ld; /* get the operand */
720: 716 000315B5 48 04 effffffa74 50 shll $4,_index,r0
721: 717 000315BD 0c 8f00000000 50 addl2 $_lnd_1_data,r0
722: 718 000315C4 0d a004 effffffa68 movl 4(r0),_dbl_value_1+4
723: 719 000315CC 0d 60 effffffa5d movl (r0),_dbl_value_1
724: 720 000315D3 # dbl_value_2.m = 0; /* set the '0.0' operand */
725: 721 000315D3 4d effffffa57 clrl _dbl_value_2
726: 722 000315D9 # dbl_value_2.l = 0;
727: 723 000315D9 4d effffffa55 clrl _dbl_value_2+4
728: 724 000315DF # dbl_expected = lnd_1_data[index].exp; /* get the expected results */
729: 725 000315DF 48 04 effffffa4a 50 shll $4,_index,r0
730: 726 000315E7 0c 8f00000008 50 addl2 $_lnd_1_data+8,r0
731: 727 000315EE 0d a004 effffffa3e movl 4(r0),_dbl_expected+4
732: 728 000315F6 0d 60 effffffa33 movl (r0),_dbl_expected
733: 729 000315FD # /*
734: 730 000315FD # * If LOOP ON ERROR is set, this is the loop for this subtest.
735: 731 000315FD # * The force loop flag is set after the first error.
736: 732 000315FD # */
737: 733 000315FD # asm("_pipe16_5_lp1:");
738: 734 000315FD _pipe16_5_lp1:
739: 735 000315FD # asm("lnd _dbl_value_1"); /* load a the op (-op ) */
740: 736 000315FD 17 effffffa2d lnd _dbl_value_1
741: 737 00031603 # asm("addd _dbl_value_1"); /* add the operand ( 0 ) */
742: 738 00031603 c7 effffffa27 addd _dbl_value_1
743: 739 00031609 # asm("subd _dbl_value_2"); /* subtract a '0.0' ( 0 ) */
744: 740 00031609 d7 effffffa21 subd _dbl_value_2
745: 741 0003160F # asm("subd _dbl_value_1"); /* subtract the op. (-op ) */
746: 742 0003160F d7 effffffa1b subd _dbl_value_1
747: 743 00031615 # asm("std _dbl_st_acc"); /* store the result (-op ) */
748: 744 00031615 27 effffffa15 std _dbl_st_acc
749: 745 0003161B # if( force_loop )
750: 746 0003161B 5d effffffa0f tstl _force_loop
751: 747 00031621 31 02 jeql L292
752: 748 00031623 # asm("brb _pipe16_5_lp1");; /* run the loop again */
753: 749 00031623 11 d8 brb _pipe16_5_lp1
754: 750 00031625 L292:
755: 751 00031625 # /*
756: 752 00031625 # * verify the results
757: 753 00031625 # */
758: 754 00031625 # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
759: 755 00031625 # (dbl_st_acc.l != dbl_expected.l) )
760: 756 00031625 1d effffffa05 effffffa00 cmpl _dbl_st_acc,_dbl_expected
761: 757 00031630 21 0d jneq L9995
762: 758 00031632 1d effffff9fc effffff9f7 cmpl _dbl_st_acc+4,_dbl_expected+4
763: 759 0003163D 31 42 jeql L293
764: 760 0003163F L9995:
765: 761 0003163F # {
766: 762 0003163F # errcnt++; /* bump the error count */
767: 763 0003163F 6d effffff9eb incl _errcnt
768: 764 00031645 # if ( prt_error )
769: 765 00031645 5d effffff9e5 tstl _prt_error
770: 766 0003164B 31 0d jeql L294
771: 767 0003164D # print_pipe16_er("Cache Data, no NOPs");
772: 768 0003164D .data 1
773: 769 00000d85 * L295:
774: 770 00000d85 * 436163686520446174612C206 .ascii "Cache Data, no NOPs\0"
775: E6F204E4F507300
776: 771 00000d99 * .text
777: 772 0003164D dd 8f00000d85 pushl $L295
778: 773 00031653 fe 08 ef00000540 callf $8,_print_pipe16_er
779: 774 0003165A # if ( halt_flg ) /* halt on error? */
780: 775 0003165A L294:
781: 776 0003165A 5d effffff9d0 tstl _halt_flg
782: 777 00031660 31 0d jeql L296
783: 778 00031662 # pipe16_er_hlt( subtest );
784: 779 00031662 dd effffff9c8 pushl _subtest
785: 780 00031668 fe 08 ef00000679 callf $8,_pipe16_er_hlt
786: 781 0003166F # if ( loop_on_err ) {
787: 782 0003166F L296:
788: 783 0003166F 5d effffff9bb tstl _loop_on_err
789: 784 00031675 31 0a jeql L297
790: 785 00031677 # force_loop = TRUE; /* set the force loop flag */
791: 786 00031677 0d 01 effffff9b2 movl $1,_force_loop
792: 787 0003167E # asm("brw _pipe16_5_lp1"); /* and loop */
793: 788 0003167E 13 ff7c brw _pipe16_5_lp1
794: 789 00031681 # }
795: 790 00031681 # } /* end of compare error */
796: 791 00031681 L297:
797: 792 00031681 # } while( index++ < max_lnd_1_index );
798: 793 00031681 L293:
799: 794 00031681 L290:
800: 795 00031681 0d effffff9a9 50 movl _index,r0
801: 796 00031688 6d effffff9a2 incl _index
802: 797 0003168E 1d 50 effffff99b cmpl r0,_max_lnd_1_index
803: 798 00031695 81 03 13 ff1b jlss L291
804: 799 0003169A L289:
805: 800 0003169A # } /* end of subtest 5 */
806: 801 0003169A 40 ret#2
807: 802 0003169B .set L285,0x0
808: 803 0003169B L287:
809: 804 0003169B 13 ff0b jbr L288
810: 805 0003169E .data
811: 806 00000d34 * .text
812: 807 0003169E .align 1
813: 808 0003169E .globl _pipe16_6
814: 809 0003169E _pipe16_6:
815: 810 0003169E 0000 .word L298
816: 811 000316A0 #
817: 812 000316A0 #
818: 813 000316A0 #
819: 814 000316A0 #
820: 815 000316A0 #
821: 816 000316A0 #
822: 817 000316A0 #
823: 818 000316A0 #
824: 819 000316A0 # /************************************************************************
825: 820 000316A0 # *
826: 821 000316A0 # * SUBTEST 6
827: 822 000316A0 # * data in cache, 1 NO-OP
828: 823 000316A0 # *
829: 824 000316A0 # ************************************************************************/
830: 825 000316A0 # pipe16_6()
831: 826 000316A0 # {
832: 827 000316A0 13 00f6 jbr L300
833: 828 000316A3 L301:
834: 829 000316A3 # force_loop = FALSE; /* clear the force_loop flg */
835: 830 000316A3 4d effffff987 clrl _force_loop
836: 831 000316A9 # index = 0;
837: 832 000316A9 4d effffff981 clrl _index
838: 833 000316AF # do
839: 834 000316AF L304:
840: 835 000316AF # {
841: 836 000316AF # dbl_value_1 = lnd_1_data[index].ld; /* get the operand */
842: 837 000316AF 48 04 effffff97a 50 shll $4,_index,r0
843: 838 000316B7 0c 8f00000000 50 addl2 $_lnd_1_data,r0
844: 839 000316BE 0d a004 effffff96e movl 4(r0),_dbl_value_1+4
845: 840 000316C6 0d 60 effffff963 movl (r0),_dbl_value_1
846: 841 000316CD # dbl_value_2.m = 0; /* set the '0.0' operand */
847: 842 000316CD 4d effffff95d clrl _dbl_value_2
848: 843 000316D3 # dbl_value_2.l = 0;
849: 844 000316D3 4d effffff95b clrl _dbl_value_2+4
850: 845 000316D9 # dbl_expected = lnd_1_data[index].exp; /* get the expected results */
851: 846 000316D9 48 04 effffff950 50 shll $4,_index,r0
852: 847 000316E1 0c 8f00000008 50 addl2 $_lnd_1_data+8,r0
853: 848 000316E8 0d a004 effffff944 movl 4(r0),_dbl_expected+4
854: 849 000316F0 0d 60 effffff939 movl (r0),_dbl_expected
855: 850 000316F7 # /*
856: 851 000316F7 # * If LOOP ON ERROR is set, this is the loop for this subtest.
857: 852 000316F7 # * The force loop flag is set after the first error.
858: 853 000316F7 # */
859: 854 000316F7 # asm("_pipe16_6_lp1:");
860: 855 000316F7 _pipe16_6_lp1:
861: 856 000316F7 # asm("lnd _dbl_value_1"); /* load a the op (-op ) */
862: 857 000316F7 17 effffff933 lnd _dbl_value_1
863: 858 000316FD # asm("nop");
864: 859 000316FD 10 nop
865: 860 000316FE # asm("addd _dbl_value_1"); /* add the operand ( 0 ) */
866: 861 000316FE c7 effffff92c addd _dbl_value_1
867: 862 00031704 # asm("nop");
868: 863 00031704 10 nop
869: 864 00031705 # asm("subd _dbl_value_2"); /* subtract a '0.0' ( 0 ) */
870: 865 00031705 d7 effffff925 subd _dbl_value_2
871: 866 0003170B # asm("nop");
872: 867 0003170B 10 nop
873: 868 0003170C # asm("subd _dbl_value_1"); /* subtract the op. (-op ) */
874: 869 0003170C d7 effffff91e subd _dbl_value_1
875: 870 00031712 # asm("nop");
876: 871 00031712 10 nop
877: 872 00031713 # asm("std _dbl_st_acc"); /* store the result (-op ) */
878: 873 00031713 27 effffff917 std _dbl_st_acc
879: 874 00031719 # if( force_loop )
880: 875 00031719 5d effffff911 tstl _force_loop
881: 876 0003171F 31 02 jeql L305
882: 877 00031721 # asm("brb _pipe16_6_lp1");; /* run the loop again */
883: 878 00031721 11 d4 brb _pipe16_6_lp1
884: 879 00031723 L305:
885: 880 00031723 # /*
886: 881 00031723 # * verify the results
887: 882 00031723 # */
888: 883 00031723 # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
889: 884 00031723 # (dbl_st_acc.l != dbl_expected.l) )
890: 885 00031723 1d effffff907 effffff902 cmpl _dbl_st_acc,_dbl_expected
891: 886 0003172E 21 0d jneq L9994
892: 887 00031730 1d effffff8fe effffff8f9 cmpl _dbl_st_acc+4,_dbl_expected+4
893: 888 0003173B 31 42 jeql L306
894: 889 0003173D L9994:
895: 890 0003173D # {
896: 891 0003173D # errcnt++; /* bump the error count */
897: 892 0003173D 6d effffff8ed incl _errcnt
898: 893 00031743 # if ( prt_error )
899: 894 00031743 5d effffff8e7 tstl _prt_error
900: 895 00031749 31 0d jeql L307
901: 896 0003174B # print_pipe16_er("Cache Data, 1 NOP");
902: 897 0003174B .data 1
903: 898 00000d99 * L308:
904: 899 00000d99 * 436163686520446174612C203 .ascii "Cache Data, 1 NOP\0"
905: 1204E4F5000
906: 900 00000dab * .text
907: 901 0003174B dd 8f00000d99 pushl $L308
908: 902 00031751 fe 08 ef00000442 callf $8,_print_pipe16_er
909: 903 00031758 # if ( halt_flg ) /* halt on error? */
910: 904 00031758 L307:
911: 905 00031758 5d effffff8d2 tstl _halt_flg
912: 906 0003175E 31 0d jeql L309
913: 907 00031760 # pipe16_er_hlt( subtest );
914: 908 00031760 dd effffff8ca pushl _subtest
915: 909 00031766 fe 08 ef0000057b callf $8,_pipe16_er_hlt
916: 910 0003176D # if ( loop_on_err ) {
917: 911 0003176D L309:
918: 912 0003176D 5d effffff8bd tstl _loop_on_err
919: 913 00031773 31 0a jeql L310
920: 914 00031775 # force_loop = TRUE; /* set the force loop flag */
921: 915 00031775 0d 01 effffff8b4 movl $1,_force_loop
922: 916 0003177C # asm("brw _pipe16_6_lp1"); /* and loop */
923: 917 0003177C 13 ff78 brw _pipe16_6_lp1
924: 918 0003177F # }
925: 919 0003177F # } /* end of compare error */
926: 920 0003177F L310:
927: 921 0003177F # } while( index++ < max_lnd_1_index );
928: 922 0003177F L306:
929: 923 0003177F L303:
930: 924 0003177F 0d effffff8ab 50 movl _index,r0
931: 925 00031786 6d effffff8a4 incl _index
932: 926 0003178C 1d 50 effffff89d cmpl r0,_max_lnd_1_index
933: 927 00031793 81 03 13 ff17 jlss L304
934: 928 00031798 L302:
935: 929 00031798 # } /* end of subtest 6 */
936: 930 00031798 40 ret#2
937: 931 00031799 .set L298,0x0
938: 932 00031799 L300:
939: 933 00031799 13 ff07 jbr L301
940: 934 0003179C .data
941: 935 00000d34 * .text
942: 936 0003179C .align 1
943: 937 0003179C .globl _pipe16_7
944: 938 0003179C _pipe16_7:
945: 939 0003179C 0000 .word L311
946: 940 0003179E #
947: 941 0003179E #
948: 942 0003179E #
949: 943 0003179E #
950: 944 0003179E #
951: 945 0003179E #
952: 946 0003179E #
953: 947 0003179E #
954: 948 0003179E # /************************************************************************
955: 949 0003179E # *
956: 950 0003179E # * SUBTEST 7
957: 951 0003179E # * data in cache, 2 NO-OPs
958: 952 0003179E # *
959: 953 0003179E # ************************************************************************/
960: 954 0003179E # pipe16_7()
961: 955 0003179E # {
962: 956 0003179E 13 00fa jbr L313
963: 957 000317A1 L314:
964: 958 000317A1 # force_loop = FALSE; /* clear the force_loop flg */
965: 959 000317A1 4d effffff889 clrl _force_loop
966: 960 000317A7 # index = 0;
967: 961 000317A7 4d effffff883 clrl _index
968: 962 000317AD # do
969: 963 000317AD L317:
970: 964 000317AD # {
971: 965 000317AD # dbl_value_1 = lnd_1_data[index].ld; /* get the operand */
972: 966 000317AD 48 04 effffff87c 50 shll $4,_index,r0
973: 967 000317B5 0c 8f00000000 50 addl2 $_lnd_1_data,r0
974: 968 000317BC 0d a004 effffff870 movl 4(r0),_dbl_value_1+4
975: 969 000317C4 0d 60 effffff865 movl (r0),_dbl_value_1
976: 970 000317CB # dbl_value_2.m = 0; /* set the '0.0' operand */
977: 971 000317CB 4d effffff85f clrl _dbl_value_2
978: 972 000317D1 # dbl_value_2.l = 0;
979: 973 000317D1 4d effffff85d clrl _dbl_value_2+4
980: 974 000317D7 # dbl_expected = lnd_1_data[index].exp; /* get the expected results */
981: 975 000317D7 48 04 effffff852 50 shll $4,_index,r0
982: 976 000317DF 0c 8f00000008 50 addl2 $_lnd_1_data+8,r0
983: 977 000317E6 0d a004 effffff846 movl 4(r0),_dbl_expected+4
984: 978 000317EE 0d 60 effffff83b movl (r0),_dbl_expected
985: 979 000317F5 # /*
986: 980 000317F5 # * If LOOP ON ERROR is set, this is the loop for this subtest.
987: 981 000317F5 # * The force loop flag is set after the first error.
988: 982 000317F5 # */
989: 983 000317F5 # asm("_pipe16_7_lp1:");
990: 984 000317F5 _pipe16_7_lp1:
991: 985 000317F5 # asm("lnd _dbl_value_1"); /* load a the op (-op ) */
992: 986 000317F5 17 effffff835 lnd _dbl_value_1
993: 987 000317FB # asm("nop");
994: 988 000317FB 10 nop
995: 989 000317FC # asm("nop");
996: 990 000317FC 10 nop
997: 991 000317FD # asm("addd _dbl_value_1"); /* add the operand ( 0 ) */
998: 992 000317FD c7 effffff82d addd _dbl_value_1
999: 993 00031803 # asm("nop");
1000: 994 00031803 10 nop
1001: 995 00031804 # asm("nop");
1002: 996 00031804 10 nop
1003: 997 00031805 # asm("subd _dbl_value_2"); /* subtract a '0.0' ( 0 ) */
1004: 998 00031805 d7 effffff825 subd _dbl_value_2
1005: 999 0003180B # asm("nop");
1006: 1000 0003180B 10 nop
1007: 1001 0003180C # asm("nop");
1008: 1002 0003180C 10 nop
1009: 1003 0003180D # asm("subd _dbl_value_1"); /* subtract the op. (-op ) */
1010: 1004 0003180D d7 effffff81d subd _dbl_value_1
1011: 1005 00031813 # asm("nop");
1012: 1006 00031813 10 nop
1013: 1007 00031814 # asm("nop");
1014: 1008 00031814 10 nop
1015: 1009 00031815 # asm("std _dbl_st_acc"); /* store the result (-op ) */
1016: 1010 00031815 27 effffff815 std _dbl_st_acc
1017: 1011 0003181B # if( force_loop )
1018: 1012 0003181B 5d effffff80f tstl _force_loop
1019: 1013 00031821 31 02 jeql L318
1020: 1014 00031823 # asm("brb _pipe16_7_lp1");; /* run the loop again */
1021: 1015 00031823 11 d0 brb _pipe16_7_lp1
1022: 1016 00031825 L318:
1023: 1017 00031825 # /*
1024: 1018 00031825 # * verify the results
1025: 1019 00031825 # */
1026: 1020 00031825 # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
1027: 1021 00031825 # (dbl_st_acc.l != dbl_expected.l) )
1028: 1022 00031825 1d effffff805 effffff800 cmpl _dbl_st_acc,_dbl_expected
1029: 1023 00031830 21 0d jneq L9993
1030: 1024 00031832 1d effffff7fc effffff7f7 cmpl _dbl_st_acc+4,_dbl_expected+4
1031: 1025 0003183D 31 42 jeql L319
1032: 1026 0003183F L9993:
1033: 1027 0003183F # {
1034: 1028 0003183F # errcnt++; /* bump the error count */
1035: 1029 0003183F 6d effffff7eb incl _errcnt
1036: 1030 00031845 # if ( prt_error )
1037: 1031 00031845 5d effffff7e5 tstl _prt_error
1038: 1032 0003184B 31 0d jeql L320
1039: 1033 0003184D # print_pipe16_er("Cache Data, 2 NOPs");
1040: 1034 0003184D .data 1
1041: 1035 00000dab * L321:
1042: 1036 00000dab * 436163686520446174612C203 .ascii "Cache Data, 2 NOPs\0"
1043: 2204E4F507300
1044: 1037 00000dbe * .text
1045: 1038 0003184D dd 8f00000dab pushl $L321
1046: 1039 00031853 fe 08 ef00000340 callf $8,_print_pipe16_er
1047: 1040 0003185A # if ( halt_flg ) /* halt on error? */
1048: 1041 0003185A L320:
1049: 1042 0003185A 5d effffff7d0 tstl _halt_flg
1050: 1043 00031860 31 0d jeql L322
1051: 1044 00031862 # pipe16_er_hlt( subtest );
1052: 1045 00031862 dd effffff7c8 pushl _subtest
1053: 1046 00031868 fe 08 ef00000479 callf $8,_pipe16_er_hlt
1054: 1047 0003186F # if ( loop_on_err ) {
1055: 1048 0003186F L322:
1056: 1049 0003186F 5d effffff7bb tstl _loop_on_err
1057: 1050 00031875 31 0a jeql L323
1058: 1051 00031877 # force_loop = TRUE; /* set the force loop flag */
1059: 1052 00031877 0d 01 effffff7b2 movl $1,_force_loop
1060: 1053 0003187E # asm("brw _pipe16_7_lp1"); /* and loop */
1061: 1054 0003187E 13 ff74 brw _pipe16_7_lp1
1062: 1055 00031881 # }
1063: 1056 00031881 # } /* end of compare error */
1064: 1057 00031881 L323:
1065: 1058 00031881 # } while( index++ < max_lnd_1_index );
1066: 1059 00031881 L319:
1067: 1060 00031881 L316:
1068: 1061 00031881 0d effffff7a9 50 movl _index,r0
1069: 1062 00031888 6d effffff7a2 incl _index
1070: 1063 0003188E 1d 50 effffff79b cmpl r0,_max_lnd_1_index
1071: 1064 00031895 81 03 13 ff13 jlss L317
1072: 1065 0003189A L315:
1073: 1066 0003189A # } /* end of subtest 7 */
1074: 1067 0003189A 40 ret#2
1075: 1068 0003189B .set L311,0x0
1076: 1069 0003189B L313:
1077: 1070 0003189B 13 ff03 jbr L314
1078: 1071 0003189E .data
1079: 1072 00000d34 * .text
1080: 1073 0003189E .align 1
1081: 1074 0003189E .globl _pipe16_8
1082: 1075 0003189E _pipe16_8:
1083: 1076 0003189E 0000 .word L324
1084: 1077 000318A0 #
1085: 1078 000318A0 #
1086: 1079 000318A0 #
1087: 1080 000318A0 #
1088: 1081 000318A0 #
1089: 1082 000318A0 #
1090: 1083 000318A0 #
1091: 1084 000318A0 # /************************************************************************
1092: 1085 000318A0 # *
1093: 1086 000318A0 # * SUBTEST 8
1094: 1087 000318A0 # * data in cache, 3 NO-OPs
1095: 1088 000318A0 # *
1096: 1089 000318A0 # ************************************************************************/
1097: 1090 000318A0 # pipe16_8()
1098: 1091 000318A0 # {
1099: 1092 000318A0 13 00fe jbr L326
1100: 1093 000318A3 L327:
1101: 1094 000318A3 # force_loop = FALSE; /* clear the force_loop flg */
1102: 1095 000318A3 4d effffff787 clrl _force_loop
1103: 1096 000318A9 # index = 0;
1104: 1097 000318A9 4d effffff781 clrl _index
1105: 1098 000318AF # do
1106: 1099 000318AF L330:
1107: 1100 000318AF # {
1108: 1101 000318AF # dbl_value_1 = lnd_1_data[index].ld; /* get the operand */
1109: 1102 000318AF 48 04 effffff77a 50 shll $4,_index,r0
1110: 1103 000318B7 0c 8f00000000 50 addl2 $_lnd_1_data,r0
1111: 1104 000318BE 0d a004 effffff76e movl 4(r0),_dbl_value_1+4
1112: 1105 000318C6 0d 60 effffff763 movl (r0),_dbl_value_1
1113: 1106 000318CD # dbl_value_2.m = 0; /* set the '0.0' operand */
1114: 1107 000318CD 4d effffff75d clrl _dbl_value_2
1115: 1108 000318D3 # dbl_value_2.l = 0;
1116: 1109 000318D3 4d effffff75b clrl _dbl_value_2+4
1117: 1110 000318D9 # dbl_expected = lnd_1_data[index].exp; /* get the expected results */
1118: 1111 000318D9 48 04 effffff750 50 shll $4,_index,r0
1119: 1112 000318E1 0c 8f00000008 50 addl2 $_lnd_1_data+8,r0
1120: 1113 000318E8 0d a004 effffff744 movl 4(r0),_dbl_expected+4
1121: 1114 000318F0 0d 60 effffff739 movl (r0),_dbl_expected
1122: 1115 000318F7 # /*
1123: 1116 000318F7 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1124: 1117 000318F7 # * The force loop flag is set after the first error.
1125: 1118 000318F7 # */
1126: 1119 000318F7 # asm("_pipe16_8_lp1:");
1127: 1120 000318F7 _pipe16_8_lp1:
1128: 1121 000318F7 # asm("lnd _dbl_value_1"); /* load a the op (-op ) */
1129: 1122 000318F7 17 effffff733 lnd _dbl_value_1
1130: 1123 000318FD # asm("nop");
1131: 1124 000318FD 10 nop
1132: 1125 000318FE # asm("nop");
1133: 1126 000318FE 10 nop
1134: 1127 000318FF # asm("nop");
1135: 1128 000318FF 10 nop
1136: 1129 00031900 # asm("addd _dbl_value_1"); /* add the operand ( 0 ) */
1137: 1130 00031900 c7 effffff72a addd _dbl_value_1
1138: 1131 00031906 # asm("nop");
1139: 1132 00031906 10 nop
1140: 1133 00031907 # asm("nop");
1141: 1134 00031907 10 nop
1142: 1135 00031908 # asm("nop");
1143: 1136 00031908 10 nop
1144: 1137 00031909 # asm("subd _dbl_value_2"); /* subtract a '0.0' ( 0 ) */
1145: 1138 00031909 d7 effffff721 subd _dbl_value_2
1146: 1139 0003190F # asm("nop");
1147: 1140 0003190F 10 nop
1148: 1141 00031910 # asm("nop");
1149: 1142 00031910 10 nop
1150: 1143 00031911 # asm("nop");
1151: 1144 00031911 10 nop
1152: 1145 00031912 # asm("subd _dbl_value_1"); /* subtract the op. (-op ) */
1153: 1146 00031912 d7 effffff718 subd _dbl_value_1
1154: 1147 00031918 # asm("nop");
1155: 1148 00031918 10 nop
1156: 1149 00031919 # asm("nop");
1157: 1150 00031919 10 nop
1158: 1151 0003191A # asm("nop");
1159: 1152 0003191A 10 nop
1160: 1153 0003191B # asm("std _dbl_st_acc"); /* store the result (-op ) */
1161: 1154 0003191B 27 effffff70f std _dbl_st_acc
1162: 1155 00031921 # if( force_loop )
1163: 1156 00031921 5d effffff709 tstl _force_loop
1164: 1157 00031927 31 02 jeql L331
1165: 1158 00031929 # asm("brb _pipe16_8_lp1");; /* run the loop again */
1166: 1159 00031929 11 cc brb _pipe16_8_lp1
1167: 1160 0003192B L331:
1168: 1161 0003192B # /*
1169: 1162 0003192B # * verify the results
1170: 1163 0003192B # */
1171: 1164 0003192B # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
1172: 1165 0003192B # (dbl_st_acc.l != dbl_expected.l) )
1173: 1166 0003192B 1d effffff6ff effffff6fa cmpl _dbl_st_acc,_dbl_expected
1174: 1167 00031936 21 0d jneq L9992
1175: 1168 00031938 1d effffff6f6 effffff6f1 cmpl _dbl_st_acc+4,_dbl_expected+4
1176: 1169 00031943 31 42 jeql L332
1177: 1170 00031945 L9992:
1178: 1171 00031945 # {
1179: 1172 00031945 # errcnt++; /* bump the error count */
1180: 1173 00031945 6d effffff6e5 incl _errcnt
1181: 1174 0003194B # if ( prt_error )
1182: 1175 0003194B 5d effffff6df tstl _prt_error
1183: 1176 00031951 31 0d jeql L333
1184: 1177 00031953 # print_pipe16_er("Cache Data, 3 NOPs");
1185: 1178 00031953 .data 1
1186: 1179 00000dbe * L334:
1187: 1180 00000dbe * 436163686520446174612C203 .ascii "Cache Data, 3 NOPs\0"
1188: 3204E4F507300
1189: 1181 00000dd1 * .text
1190: 1182 00031953 dd 8f00000dbe pushl $L334
1191: 1183 00031959 fe 08 ef0000023a callf $8,_print_pipe16_er
1192: 1184 00031960 # if ( halt_flg ) /* halt on error? */
1193: 1185 00031960 L333:
1194: 1186 00031960 5d effffff6ca tstl _halt_flg
1195: 1187 00031966 31 0d jeql L335
1196: 1188 00031968 # pipe16_er_hlt( subtest );
1197: 1189 00031968 dd effffff6c2 pushl _subtest
1198: 1190 0003196E fe 08 ef00000373 callf $8,_pipe16_er_hlt
1199: 1191 00031975 # if ( loop_on_err ) {
1200: 1192 00031975 L335:
1201: 1193 00031975 5d effffff6b5 tstl _loop_on_err
1202: 1194 0003197B 31 0a jeql L336
1203: 1195 0003197D # force_loop = TRUE; /* set the force loop flag */
1204: 1196 0003197D 0d 01 effffff6ac movl $1,_force_loop
1205: 1197 00031984 # asm("brw _pipe16_8_lp1"); /* and loop */
1206: 1198 00031984 13 ff70 brw _pipe16_8_lp1
1207: 1199 00031987 # }
1208: 1200 00031987 # } /* end of compare error */
1209: 1201 00031987 L336:
1210: 1202 00031987 # } while( index++ < max_lnd_1_index );
1211: 1203 00031987 L332:
1212: 1204 00031987 L329:
1213: 1205 00031987 0d effffff6a3 50 movl _index,r0
1214: 1206 0003198E 6d effffff69c incl _index
1215: 1207 00031994 1d 50 effffff695 cmpl r0,_max_lnd_1_index
1216: 1208 0003199B 81 03 13 ff0f jlss L330
1217: 1209 000319A0 L328:
1218: 1210 000319A0 # } /* end of subtest 8 */
1219: 1211 000319A0 40 ret#2
1220: 1212 000319A1 .set L324,0x0
1221: 1213 000319A1 L326:
1222: 1214 000319A1 13 feff jbr L327
1223: 1215 000319A4 .data
1224: 1216 00000d34 * .text
1225: 1217 000319A4 .align 1
1226: 1218 000319A4 .globl _pipe16_9
1227: 1219 000319A4 _pipe16_9:
1228: 1220 000319A4 0000 .word L337
1229: 1221 000319A6 #
1230: 1222 000319A6 #
1231: 1223 000319A6 #
1232: 1224 000319A6 #
1233: 1225 000319A6 #
1234: 1226 000319A6 #
1235: 1227 000319A6 #
1236: 1228 000319A6 #
1237: 1229 000319A6 #
1238: 1230 000319A6 # /******************************************************************************
1239: 1231 000319A6 # *
1240: 1232 000319A6 # * SUBTEST 9
1241: 1233 000319A6 # *
1242: 1234 000319A6 # * Get the data via the FRAME POINTER ( quad word indexed )
1243: 1235 000319A6 # *
1244: 1236 000319A6 # * ADDRESSES OF DATA OPERANDS INDEX DATA
1245: 1237 000319A6 # * pointer_data,-4 ( FP+24 ) 3 the STF result goes here
1246: 1238 000319A6 # * pointer_data-8,-12 ( FP+16 ) 2 <operand data>
1247: 1239 000319A6 # * pointer_data-16,-20 ( FP+8 ) 1 < '0.0' data>
1248: 1240 000319A6 # * pointer_data-24,-28 ( FP ) 0 point the frame pointer here
1249: 1241 000319A6 # *
1250: 1242 000319A6 # * NOTE: The double precision instructions are using Quad Word indexing.
1251: 1243 000319A6 # ******************************************************************************/
1252: 1244 000319A6 # pipe16_9()
1253: 1245 000319A6 # {
1254: 1246 000319A6 13 01ee jbr L339
1255: 1247 000319A9 L340:
1256: 1248 000319A9 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
1257: 1249 000319A9 ed 6d effffff680 moval (r13),_pre_event_fp
1258: 1250 000319B0 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
1259: 1251 000319B0 ed 6e effffff679 moval (r14),_pre_event_sp
1260: 1252 000319B7 # force_loop = FALSE; /* clear force_loop flag */
1261: 1253 000319B7 4d effffff673 clrl _force_loop
1262: 1254 000319BD # index = 0;
1263: 1255 000319BD 4d effffff66d clrl _index
1264: 1256 000319C3 # do
1265: 1257 000319C3 L343:
1266: 1258 000319C3 # {
1267: 1259 000319C3 # sgl_value_1 = lnd_1_data[index].ld.m; /* get operand 1's MSW */
1268: 1260 000319C3 0d effffff667 50 movl _index,r0
1269: 1261 000319CA 48 04 50 50 shll $4,r0,r0
1270: 1262 000319CE 0d e000000000 effffff657 movl _lnd_1_data(r0),_sgl_value_1
1271: 1263 000319D9 # sgl_value_2 = lnd_1_data[index].ld.l; /* get operand 1's LSW */
1272: 1264 000319D9 0d effffff651 50 movl _index,r0
1273: 1265 000319E0 48 04 50 50 shll $4,r0,r0
1274: 1266 000319E4 0d e000000004 effffff641 movl _lnd_1_data+4(r0),_sgl_value_2
1275: 1267 000319EF # sgl_value_7 = 0; /* get the '0.0' data */
1276: 1268 000319EF 4d effffff63b clrl _sgl_value_7
1277: 1269 000319F5 # dbl_expected = lnd_1_data[index].exp; /* get expected results */
1278: 1270 000319F5 48 04 effffff634 50 shll $4,_index,r0
1279: 1271 000319FD 0c 8f00000008 50 addl2 $_lnd_1_data+8,r0
1280: 1272 00031A04 0d a004 effffff628 movl 4(r0),_dbl_expected+4
1281: 1273 00031A0C 0d 60 effffff61d movl (r0),_dbl_expected
1282: 1274 00031A13 # /*
1283: 1275 00031A13 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1284: 1276 00031A13 # * The force loop flag is set after the first error.
1285: 1277 00031A13 # */
1286: 1278 00031A13 # asm("_pipe16_9_lp1:");
1287: 1279 00031A13 _pipe16_9_lp1:
1288: 1280 00031A13 # asm("moval _pointer_data,_sgl_value_9");/* get store data's addr */
1289: 1281 00031A13 ed effffff617 effffff612 moval _pointer_data,_sgl_value_9
1290: 1282 00031A1E # sgl_value_9 -= 8;
1291: 1283 00031A1E 2c 08 effffff60b subl2 $8,_sgl_value_9
1292: 1284 00031A25 # asm("movl _sgl_value_2,*_sgl_value_9"); /* set the operand's LSW */
1293: 1285 00031A25 0d effffff605 fffffff600 movl _sgl_value_2,*_sgl_value_9
1294: 1286 00031A30 # sgl_value_9 -= 4;
1295: 1287 00031A30 2c 04 effffff5f9 subl2 $4,_sgl_value_9
1296: 1288 00031A37 # asm("movl _sgl_value_1,*_sgl_value_9"); /* set the operand's MSW */
1297: 1289 00031A37 0d effffff5f3 fffffff5ee movl _sgl_value_1,*_sgl_value_9
1298: 1290 00031A42 # sgl_value_9 -= 4;
1299: 1291 00031A42 2c 04 effffff5e7 subl2 $4,_sgl_value_9
1300: 1292 00031A49 # asm("movl _sgl_value_7,*_sgl_value_9"); /* set '0.0' data's LSW */
1301: 1293 00031A49 0d effffff5e1 fffffff5dc movl _sgl_value_7,*_sgl_value_9
1302: 1294 00031A54 # sgl_value_9 -= 4;
1303: 1295 00031A54 2c 04 effffff5d5 subl2 $4,_sgl_value_9
1304: 1296 00031A5B # asm("movl _sgl_value_7,*_sgl_value_9"); /* set '0.0' data's MSW */
1305: 1297 00031A5B 0d effffff5cf fffffff5ca movl _sgl_value_7,*_sgl_value_9
1306: 1298 00031A66 # sgl_value_9 -= 8; /* get the FP addr to use */
1307: 1299 00031A66 2c 08 effffff5c3 subl2 $8,_sgl_value_9
1308: 1300 00031A6D # asm("movl _sgl_value_9,r13"); /* set the FRAME POINTER */
1309: 1301 00031A6D 0d effffff5bd 5d movl _sgl_value_9,r13
1310: 1302 00031A74 # asm("movl $1,r5"); /* r5 index = 1 quadwords */
1311: 1303 00031A74 0d 01 55 movl $1,r5
1312: 1304 00031A77 # asm("movl $2,r6"); /* r6 index = 2 quadwords */
1313: 1305 00031A77 0d 02 56 movl $2,r6
1314: 1306 00031A7A # asm("movl $3,r7"); /* r7 index = 3 quadwords */
1315: 1307 00031A7A 0d 03 57 movl $3,r7
1316: 1308 00031A7D # asm("lnd (r13)[r6]"); /* load the operand ( -op ) */
1317: 1309 00031A7D 17 466d lnd (r13)[r6]
1318: 1310 00031A80 # asm("addd (r13)[r6]"); /* add the operand ( 0 ) */
1319: 1311 00031A80 c7 466d addd (r13)[r6]
1320: 1312 00031A83 # asm("subd (r13)[r5]"); /* subtract a '0.0' ( 0 ) */
1321: 1313 00031A83 d7 456d subd (r13)[r5]
1322: 1314 00031A86 # asm("subd (r13)[r6]"); /* subtract the op. ( -op ) */
1323: 1315 00031A86 d7 466d subd (r13)[r6]
1324: 1316 00031A89 # asm("std (r13)[r7]"); /* store the result ( -op ) */
1325: 1317 00031A89 27 476d std (r13)[r7]
1326: 1318 00031A8C # if( force_loop )
1327: 1319 00031A8C 5d effffff59e tstl _force_loop
1328: 1320 00031A92 31 03 jeql L344
1329: 1321 00031A94 # asm("brw _pipe16_9_lp1");; /* run the loop again */
1330: 1322 00031A94 13 ff7c brw _pipe16_9_lp1
1331: 1323 00031A97 L344:
1332: 1324 00031A97 # /*
1333: 1325 00031A97 # * verify the results
1334: 1326 00031A97 # */
1335: 1327 00031A97 # asm("moval (r13),_sgl_value_10"); /* save the frame pointer */
1336: 1328 00031A97 ed 6d effffff592 moval (r13),_sgl_value_10
1337: 1329 00031A9E # asm("movl _pointer_data,_sgl_value_4"); /* save the LSW stored */
1338: 1330 00031A9E 0d effffff58c effffff587 movl _pointer_data,_sgl_value_4
1339: 1331 00031AA9 # asm("movl _pointer_data-4,_sgl_value_3"); /* and the MSW */
1340: 1332 00031AA9 0d effffff57d effffff57c movl _pointer_data-4,_sgl_value_3
1341: 1333 00031AB4 # if( (sgl_value_3 != dbl_expected.m) || /* verify the result... */
1342: 1334 00031AB4 # (sgl_value_4 != dbl_expected.l) || /* verify the result... */
1343: 1335 00031AB4 # (sgl_value_10 != sgl_value_9) ) /* ... and the final FP */
1344: 1336 00031AB4 1d effffff576 effffff571 cmpl _sgl_value_3,_dbl_expected
1345: 1337 00031ABF 21 1d jneq L9991
1346: 1338 00031AC1 1d effffff569 effffff568 cmpl _sgl_value_4,_dbl_expected+4
1347: 1339 00031ACC 21 10 jneq L9991
1348: 1340 00031ACE 1d effffff55c effffff557 cmpl _sgl_value_10,_sgl_value_9
1349: 1341 00031AD9 21 03 13 0091 jeql L345
1350: 1342 00031ADE L9991:
1351: 1343 00031ADE # {
1352: 1344 00031ADE # asm("movl _pre_event_fp,r13"); /* restore frame pointer */
1353: 1345 00031ADE 0d effffff54c 5d movl _pre_event_fp,r13
1354: 1346 00031AE5 # asm("movl _pre_event_sp,r14"); /* restore stack pointer */
1355: 1347 00031AE5 0d effffff545 5e movl _pre_event_sp,r14
1356: 1348 00031AEC # errcnt++; /* bump the error count */
1357: 1349 00031AEC 6d effffff53e incl _errcnt
1358: 1350 00031AF2 # if ( prt_error ) {
1359: 1351 00031AF2 5d effffff538 tstl _prt_error
1360: 1352 00031AF8 31 4e jeql L346
1361: 1353 00031AFA # print_pipe16_er("indexed FP addressing");
1362: 1354 00031AFA .data 1
1363: 1355 00000dd1 * L347:
1364: 1356 00000dd1 * 696E646578656420465020616 .ascii "indexed FP addressing\0"
1365: 46472657373696E6700
1366: 1357 00000de7 * .text
1367: 1358 00031AFA dd 8f00000dd1 pushl $L347
1368: 1359 00031B00 fe 08 ef00000093 callf $8,_print_pipe16_er
1369: 1360 00031B07 # writes("final Frame Pointer = ");
1370: 1361 00031B07 .data 1
1371: 1362 00000de7 * L348:
1372: 1363 00000de7 * 66696E616C204672616D65205 .ascii "final Frame Pointer = \0"
1373: 06F696E746572203D2000
1374: 1364 00000dfe * .text
1375: 1365 00031B07 dd 8f00000de7 pushl $L348
1376: 1366 00031B0D fe 08 effffff51c callf $8,_writes
1377: 1367 00031B14 # writeh( sgl_value_10 );
1378: 1368 00031B14 dd effffff516 pushl _sgl_value_10
1379: 1369 00031B1A fe 08 effffff50f callf $8,_writeh
1380: 1370 00031B21 # writes(", expected FP = ");
1381: 1371 00031B21 .data 1
1382: 1372 00000dfe * L350:
1383: 1373 00000dfe * 2C20206578706563746564204 .ascii ", expected FP = \0"
1384: 650203D2000
1385: 1374 00000e10 * .text
1386: 1375 00031B21 dd 8f00000dfe pushl $L350
1387: 1376 00031B27 fe 08 effffff502 callf $8,_writes
1388: 1377 00031B2E # writeh( sgl_value_9 );
1389: 1378 00031B2E dd effffff4fc pushl _sgl_value_9
1390: 1379 00031B34 fe 08 effffff4f5 callf $8,_writeh
1391: 1380 00031B3B # writes("\n");
1392: 1381 00031B3B .data 1
1393: 1382 00000e10 * L351:
1394: 1383 00000e10 * 0A00 .ascii "\12\0"
1395: 1384 00000e12 * .text
1396: 1385 00031B3B dd 8f00000e10 pushl $L351
1397: 1386 00031B41 fe 08 effffff4e8 callf $8,_writes
1398: 1387 00031B48 # }
1399: 1388 00031B48 # if ( halt_flg ) /* halt on error? */
1400: 1389 00031B48 L346:
1401: 1390 00031B48 5d effffff4e2 tstl _halt_flg
1402: 1391 00031B4E 31 0d jeql L352
1403: 1392 00031B50 # pipe16_er_hlt( subtest );
1404: 1393 00031B50 dd effffff4da pushl _subtest
1405: 1394 00031B56 fe 08 ef0000018b callf $8,_pipe16_er_hlt
1406: 1395 00031B5D # if ( loop_on_err ) {
1407: 1396 00031B5D L352:
1408: 1397 00031B5D 5d effffff4cd tstl _loop_on_err
1409: 1398 00031B63 31 0a jeql L353
1410: 1399 00031B65 # force_loop = TRUE; /* set the force loop flag */
1411: 1400 00031B65 0d 01 effffff4c4 movl $1,_force_loop
1412: 1401 00031B6C # asm("brw _pipe16_9_lp1"); /* and loop */
1413: 1402 00031B6C 13 fea4 brw _pipe16_9_lp1
1414: 1403 00031B6F # }
1415: 1404 00031B6F # } /* end of compare error */
1416: 1405 00031B6F L353:
1417: 1406 00031B6F # } while( index++ < max_lnd_1_index );
1418: 1407 00031B6F L345:
1419: 1408 00031B6F L342:
1420: 1409 00031B6F 0d effffff4bb 50 movl _index,r0
1421: 1410 00031B76 6d effffff4b4 incl _index
1422: 1411 00031B7C 1d 50 effffff4ad cmpl r0,_max_lnd_1_index
1423: 1412 00031B83 81 03 13 fe3b jlss L343
1424: 1413 00031B88 L341:
1425: 1414 00031B88 # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */
1426: 1415 00031B88 0d effffff4a2 5d movl _pre_event_fp,r13
1427: 1416 00031B8F # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */
1428: 1417 00031B8F 0d effffff49b 5e movl _pre_event_sp,r14
1429: 1418 00031B96 # } /* end of subtest 9 */
1430: 1419 00031B96 40 ret#2
1431: 1420 00031B97 .set L337,0x0
1432: 1421 00031B97 L339:
1433: 1422 00031B97 13 fe0f jbr L340
1434: 1423 00031B9A .data
1435: 1424 00000d34 * .text
1436: 1425 00031B9A .align 1
1437: 1426 00031B9A .globl _print_pipe16_er
1438: 1427 00031B9A _print_pipe16_er:
1439: 1428 00031B9A 0000 .word L354
1440: 1429 00031B9C #
1441: 1430 00031B9C #
1442: 1431 00031B9C # /******************************************************************************
1443: 1432 00031B9C # *
1444: 1433 00031B9C # * ERROR ROUTINE
1445: 1434 00031B9C # *
1446: 1435 00031B9C # * print an error in the following form
1447: 1436 00031B9C # *
1448: 1437 00031B9C # *operand = xxxxxxxx xxxxxxxx, final Acc = xxxxxxxx xxxxxxxx, index = dd
1449: 1438 00031B9C # * expected Acc = xxxxxxxx xxxxxxxx
1450: 1439 00031B9C # *
1451: 1440 00031B9C # ******************************************************************************/
1452: 1441 00031B9C # print_pipe16_er(msg)
1453: 1442 00031B9C # char *msg;
1454: 1443 00031B9C # {
1455: 1444 00031B9C 13 0145 jbr L356
1456: 1445 00031B9F L357:
1457: 1446 00031B9F # writes("\n"); /* start a new print line */
1458: 1447 00031B9F .data 1
1459: 1448 00000e12 * L358:
1460: 1449 00000e12 * 0A00 .ascii "\12\0"
1461: 1450 00000e14 * .text
1462: 1451 00031B9F dd 8f00000e12 pushl $L358
1463: 1452 00031BA5 fe 08 effffff484 callf $8,_writes
1464: 1453 00031BAC # writes("cycle: ");
1465: 1454 00031BAC .data 1
1466: 1455 00000e14 * L359:
1467: 1456 00000e14 * 6379636C653A2000 .ascii "cycle: \0"
1468: 1457 00000e1c * .text
1469: 1458 00031BAC dd 8f00000e14 pushl $L359
1470: 1459 00031BB2 fe 08 effffff477 callf $8,_writes
1471: 1460 00031BB9 # writed( cycle );
1472: 1461 00031BB9 dd effffff471 pushl _cycle
1473: 1462 00031BBF fe 08 effffff46a callf $8,_writed
1474: 1463 00031BC6 # writes(" test ");
1475: 1464 00031BC6 .data 1
1476: 1465 00000e1c * L361:
1477: 1466 00000e1c * 20746573742000 .ascii " test \0"
1478: 1467 00000e23 * .text
1479: 1468 00031BC6 dd 8f00000e1c pushl $L361
1480: 1469 00031BCC fe 08 effffff45d callf $8,_writes
1481: 1470 00031BD3 # writed( test_no );
1482: 1471 00031BD3 dd effffff457 pushl _test_no
1483: 1472 00031BD9 fe 08 effffff450 callf $8,_writed
1484: 1473 00031BE0 # writes(" (Pipe 16), subtest ");
1485: 1474 00031BE0 .data 1
1486: 1475 00000e23 * L362:
1487: 1476 00000e23 * 20202850697065203136292C2 .ascii " (Pipe 16), subtest \0"
1488: 0737562746573742000
1489: 1477 00000e39 * .text
1490: 1478 00031BE0 dd 8f00000e23 pushl $L362
1491: 1479 00031BE6 fe 08 effffff443 callf $8,_writes
1492: 1480 00031BED # writed( subtest );
1493: 1481 00031BED dd effffff43d pushl _subtest
1494: 1482 00031BF3 fe 08 effffff436 callf $8,_writed
1495: 1483 00031BFA # writes(" error - ");
1496: 1484 00031BFA .data 1
1497: 1485 00000e39 * L363:
1498: 1486 00000e39 * 206572726F72202D2000 .ascii " error - \0"
1499: 1487 00000e43 * .text
1500: 1488 00031BFA dd 8f00000e39 pushl $L363
1501: 1489 00031C00 fe 08 effffff429 callf $8,_writes
1502: 1490 00031C07 # writes( msg );
1503: 1491 00031C07 dd ad04 pushl 4(fp)
1504: 1492 00031C0A fe 08 effffff41f callf $8,_writes
1505: 1493 00031C11 # writec('\n');
1506: 1494 00031C11 dd 0a pushl $10
1507: 1495 00031C13 fe 08 effffff416 callf $8,_writec
1508: 1496 00031C1A # writes(" LND(op), ADDD(op), SUBD(0.0), SUBD(op), STD\n");
1509: 1497 00031C1A .data 1
1510: 1498 00000e43 * L365:
1511: 1499 00000e43 * 204C4E44286F70292C2041444 .ascii " LND(op), ADDD(op), SUBD(0.0), SUBD(op), STD\12\0"
1512: 444286F70292C205355424428
1513: 302E30292C2053554244286F7
1514: 0292C205354440A00
1515: 1500 00000e71 * .text
1516: 1501 00031C1A dd 8f00000e43 pushl $L365
1517: 1502 00031C20 fe 08 effffff409 callf $8,_writes
1518: 1503 00031C27 # writes("operand = ");
1519: 1504 00031C27 .data 1
1520: 1505 00000e71 * L366:
1521: 1506 00000e71 * 6F706572616E64203D2000 .ascii "operand = \0"
1522: 1507 00000e7c * .text
1523: 1508 00031C27 dd 8f00000e71 pushl $L366
1524: 1509 00031C2D fe 08 effffff3fc callf $8,_writes
1525: 1510 00031C34 # write32h( dbl_ld_acc.m );
1526: 1511 00031C34 dd effffff3f6 pushl _dbl_ld_acc
1527: 1512 00031C3A fe 08 effffff3ef callf $8,_write32h
1528: 1513 00031C41 # writec(' ');
1529: 1514 00031C41 dd 20 pushl $32
1530: 1515 00031C43 fe 08 effffff3e6 callf $8,_writec
1531: 1516 00031C4A # write32h( dbl_ld_acc.l );
1532: 1517 00031C4A dd effffff3e4 pushl _dbl_ld_acc+4
1533: 1518 00031C50 fe 08 effffff3d9 callf $8,_write32h
1534: 1519 00031C57 # writes(", final Acc = ");
1535: 1520 00031C57 .data 1
1536: 1521 00000e7c * L368:
1537: 1522 00000e7c * 2C20202066696E616C2041636 .ascii ", final Acc = \0"
1538: 3203D2000
1539: 1523 00000e8d * .text
1540: 1524 00031C57 dd 8f00000e7c pushl $L368
1541: 1525 00031C5D fe 08 effffff3cc callf $8,_writes
1542: 1526 00031C64 # write32h( dbl_st_acc.m );
1543: 1527 00031C64 dd effffff3c6 pushl _dbl_st_acc
1544: 1528 00031C6A fe 08 effffff3bf callf $8,_write32h
1545: 1529 00031C71 # writec(' ');
1546: 1530 00031C71 dd 20 pushl $32
1547: 1531 00031C73 fe 08 effffff3b6 callf $8,_writec
1548: 1532 00031C7A # write32h( dbl_st_acc.l );
1549: 1533 00031C7A dd effffff3b4 pushl _dbl_st_acc+4
1550: 1534 00031C80 fe 08 effffff3a9 callf $8,_write32h
1551: 1535 00031C87 # writes(", index = ");
1552: 1536 00031C87 .data 1
1553: 1537 00000e8d * L369:
1554: 1538 00000e8d * 2C202020696E646578203D200 .ascii ", index = \0"
1555: 0
1556: 1539 00000e9a * .text
1557: 1540 00031C87 dd 8f00000e8d pushl $L369
1558: 1541 00031C8D fe 08 effffff39c callf $8,_writes
1559: 1542 00031C94 # writed( index );
1560: 1543 00031C94 dd effffff396 pushl _index
1561: 1544 00031C9A fe 08 effffff38f callf $8,_writed
1562: 1545 00031CA1 # writec('\n');
1563: 1546 00031CA1 dd 0a pushl $10
1564: 1547 00031CA3 fe 08 effffff386 callf $8,_writec
1565: 1548 00031CAA # writes(" expected Acc = ");
1566: 1549 00031CAA .data 1
1567: 1550 00000e9a * L370:
1568: 1551 00000e9a * 2020202020202020202020202 .ascii " expected Acc = \0"
1569: 0202020202020202020202020
1570: 2020206578706563746564204
1571: 16363203D2000
1572: 1552 00000ec6 * .text
1573: 1553 00031CAA dd 8f00000e9a pushl $L370
1574: 1554 00031CB0 fe 08 effffff379 callf $8,_writes
1575: 1555 00031CB7 # write32h( dbl_expected.m );
1576: 1556 00031CB7 dd effffff373 pushl _dbl_expected
1577: 1557 00031CBD fe 08 effffff36c callf $8,_write32h
1578: 1558 00031CC4 # writec(' ');
1579: 1559 00031CC4 dd 20 pushl $32
1580: 1560 00031CC6 fe 08 effffff363 callf $8,_writec
1581: 1561 00031CCD # write32h( dbl_expected.l );
1582: 1562 00031CCD dd effffff361 pushl _dbl_expected+4
1583: 1563 00031CD3 fe 08 effffff356 callf $8,_write32h
1584: 1564 00031CDA # writec('\n');
1585: 1565 00031CDA dd 0a pushl $10
1586: 1566 00031CDC fe 08 effffff34d callf $8,_writec
1587: 1567 00031CE3 # }
1588: 1568 00031CE3 40 ret#2
1589: 1569 00031CE4 .set L354,0x0
1590: 1570 00031CE4 L356:
1591: 1571 00031CE4 13 feb8 jbr L357
1592: 1572 00031CE7 .data
1593: 1573 00000d34 * .text
1594: 1574 00031CE7 00 .align 1
1595: 1575 00031CE8 .globl _pipe16_er_hlt
1596: 1576 00031CE8 _pipe16_er_hlt:
1597: 1577 00031CE8 0000 .word L371
1598: 1578 00031CEA #
1599: 1579 00031CEA #
1600: 1580 00031CEA #
1601: 1581 00031CEA #
1602: 1582 00031CEA #
1603: 1583 00031CEA # /******************************************************************************
1604: 1584 00031CEA # *
1605: 1585 00031CEA # * HALT ON ERROR ROUTINE
1606: 1586 00031CEA # *
1607: 1587 00031CEA # * halt with the necessary information saved in the registers
1608: 1588 00031CEA # *
1609: 1589 00031CEA # ******************************************************************************/
1610: 1590 00031CEA # pipe16_er_hlt( subtest )
1611: 1591 00031CEA # int subtest;
1612: 1592 00031CEA # {
1613: 1593 00031CEA 11 75 jbr L373
1614: 1594 00031CEC L374:
1615: 1595 00031CEC # sgl_value_3 = dbl_st_acc.m;
1616: 1596 00031CEC 0d effffff33e effffff339 movl _dbl_st_acc,_sgl_value_3
1617: 1597 00031CF7 # sgl_value_4 = dbl_st_acc.l;
1618: 1598 00031CF7 0d effffff337 effffff32e movl _dbl_st_acc+4,_sgl_value_4
1619: 1599 00031D02 # asm("movl _test_no,r0"); /* r0 = test number */
1620: 1600 00031D02 0d effffff328 50 movl _test_no,r0
1621: 1601 00031D09 # asm("movl _subtest,r1"); /* r1 = subtest number */
1622: 1602 00031D09 0d effffff321 51 movl _subtest,r1
1623: 1603 00031D10 # asm("movl $1,r2"); /* r2 = error code */
1624: 1604 00031D10 0d 01 52 movl $1,r2
1625: 1605 00031D13 # asm("movl _cycle,r3"); /* r3 = cycle count */
1626: 1606 00031D13 0d effffff317 53 movl _cycle,r3
1627: 1607 00031D1A # asm("movl _sgl_value_1,r4"); /* r4 = MSW operand loaded */
1628: 1608 00031D1A 0d effffff310 54 movl _sgl_value_1,r4
1629: 1609 00031D21 # asm("movl _sgl_value_2,r5"); /* r5 = LSW operand loaded */
1630: 1610 00031D21 0d effffff309 55 movl _sgl_value_2,r5
1631: 1611 00031D28 # asm("movl _sgl_value_3,r6"); /* r6 = MSW operand stored */
1632: 1612 00031D28 0d effffff302 56 movl _sgl_value_3,r6
1633: 1613 00031D2F # asm("movl _sgl_value_4,r7"); /* r7 = LSW operand stored */
1634: 1614 00031D2F 0d effffff2fb 57 movl _sgl_value_4,r7
1635: 1615 00031D36 # asm("movl _sgl_value_5,r8"); /* r8 = MSW operand expect */
1636: 1616 00031D36 0d effffff2f4 58 movl _sgl_value_5,r8
1637: 1617 00031D3D # asm("movl _sgl_value_6,r9"); /* r9 = LSW operand expect */
1638: 1618 00031D3D 0d effffff2ed 59 movl _sgl_value_6,r9
1639: 1619 00031D44 # asm("movl _index,r10"); /* r10 = data index */
1640: 1620 00031D44 0d effffff2e6 5a movl _index,r10
1641: 1621 00031D4B # if( subtest == 9 ) {
1642: 1622 00031D4B 1d ad04 09 cmpl 4(fp),$9
1643: 1623 00031D4F 21 0e jneq L375
1644: 1624 00031D51 # asm("movl _sgl_value_10,r11"); /* r11 = final FP value */
1645: 1625 00031D51 0d effffff2d9 5b movl _sgl_value_10,r11
1646: 1626 00031D58 # asm("movl _sgl_value_9,r12"); /* r12 = expected FP value */
1647: 1627 00031D58 0d effffff2d2 5c movl _sgl_value_9,r12
1648: 1628 00031D5F # };
1649: 1629 00031D5F L375:
1650: 1630 00031D5F # asm(".globl _pipe16_1_hlt");
1651: 1631 00031D5F .globl _pipe16_1_hlt
1652: 1632 00031D5F # asm("_pipe16_1_hlt:"); /* PC after the halt */
1653: 1633 00031D5F _pipe16_1_hlt:
1654: 1634 00031D5F # asm("halt"); /* HALT ... */
1655: 1635 00031D5F 00 halt
1656: 1636 00031D60 # } /* end of halt on error */
1657: 1637 00031D60 40 ret#2
1658: 1638 00031D61 .set L371,0x0
1659: 1639 00031D61 L373:
1660: 1640 00031D61 11 89 jbr L374
1661: 1641 00031D63 .data
1662: 1641 00062D93 .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.