![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe7.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 pipe7.lst CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / macro4 |
Power 6/32 Unix version 1.21
1 00000000 LL0:
2 00000000 .data
3 00000de8 * .text
4 00000000 .align 1
5 00000000 .globl _pipe_7
6 00000000 _pipe_7:
7 0002AE6C 0000 .word L215
8 0002AE6E # #include "fpp_defs.h"
9 0002AE6E #
10 0002AE6E #
11 0002AE6E # /*****************************************************************************
12 0002AE6E # *
13 0002AE6E # * MONITOR FOR PIPELINE TEST #7 (The Trans-Siberian Pipeline test)
14 0002AE6E # *
15 0002AE6E # * This test will do:
16 0002AE6E # *
17 0002AE6E # * LDF(x), SUBF(x), ADDF(0), SUBF(x), ADDF(x), SUBF(0),
18 0002AE6E # * ADDF(x), SUBF(x), ADDF(0), SUBF(0), ADDF(x), STF
19 0002AE6E # *
20 0002AE6E # * where the x's are the fmacro1 LDF data patterns. This test is an attempt
21 0002AE6E # * to fill the instruction Queue.
22 0002AE6E # *****************************************************************************/
23 0002AE6E # pipe_7()
24 0002AE6E # {
25 0002AE6E 13 00a8 jbr L217
26 0002AE71 L218:
27 0002AE71 # asm(".globl _pipeline_7_t");
28 0002AE71 .globl _pipeline_7_t
29 0002AE71 # asm("_pipeline_7_t:"); /* entry address */
30 0002AE71 _pipeline_7_t:
31 0002AE71 # if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */
32 0002AE71 1d effffffff5 01 cmpl _cycle,$1
33 0002AE78 21 15 jneq L219
34 0002AE7A 5d efffffffec tstl _prt_hdrs
35 0002AE80 31 0d jeql L219
36 0002AE82 # {
37 0002AE82 # writes(" PIPE_7 ");
38 0002AE82 .data 1
39 00000de8 * L221:
40 00000de8 * 20504950455F372000 .ascii " PIPE_7 \0"
41 00000df1 * .text
42 0002AE82 dd 8f00000de8 pushl $L221
43 0002AE88 fe 08 efffffffdd callf $8,_writes
44 0002AE8F # }
45 0002AE8F # subtest = 1;
46 0002AE8F L219:
47 0002AE8F 0d 01 efffffffd6 movl $1,_subtest
48 0002AE96 # pipe7_1(); /* data in REGs, no NOPs */
49 0002AE96 fe 04 ef0000007f callf $4,_pipe7_1
50 0002AE9D # subtest ++; /* increment subtest num */
51 0002AE9D 6d efffffffc9 incl _subtest
52 0002AEA3 # pipe7_2(); /* data in REGs, 1 NOP */
53 0002AEA3 fe 04 ef0000015c callf $4,_pipe7_2
54 0002AEAA # subtest ++; /* increment subtest num */
55 0002AEAA 6d efffffffbc incl _subtest
56 0002AEB0 # pipe7_3(); /* data in REGs, 2 NOPs */
57 0002AEB0 fe 04 ef00000243 callf $4,_pipe7_3
58 0002AEB7 # subtest ++; /* increment subtest num */
59 0002AEB7 6d efffffffaf incl _subtest
60 0002AEBD # pipe7_4(); /* data in REGs, 3 NOPs */
61 0002AEBD fe 04 ef00000336 callf $4,_pipe7_4
62 0002AEC4 # subtest ++; /* increment subtest num */
63 0002AEC4 6d efffffffa2 incl _subtest
64 0002AECA # pipe7_5(); /* data in CACHE, no NOPs */
65 0002AECA fe 04 ef00000433 callf $4,_pipe7_5
66 0002AED1 # subtest ++; /* increment subtest num */
67 0002AED1 6d efffffff95 incl _subtest
68 0002AED7 # pipe7_6(); /* data in CACHE, 1 NOP */
69 0002AED7 fe 04 ef0000052a callf $4,_pipe7_6
70 0002AEDE # subtest ++; /* increment subtest num */
71 0002AEDE 6d efffffff88 incl _subtest
72 0002AEE4 # pipe7_7(); /* data in CACHE, 2 NOPs */
73 0002AEE4 fe 04 ef00000627 callf $4,_pipe7_7
74 0002AEEB # subtest ++; /* increment subtest num */
75 0002AEEB 6d efffffff7b incl _subtest
76 0002AEF1 # pipe7_8(); /* data in CACHE, 3 NOPs */
77 0002AEF1 fe 04 ef00000734 callf $4,_pipe7_8
78 0002AEF8 # subtest ++; /* increment subtest num */
79 0002AEF8 6d efffffff6e incl _subtest
80 0002AEFE # pipe7_9(); /* data on STACK, no NOPs */
81 0002AEFE fe 04 ef0000084d callf $4,_pipe7_9
82 0002AF05 # subtest ++; /* increment subtest num */
83 0002AF05 6d efffffff61 incl _subtest
84 0002AF0B # pipe7_10(); /* data via FP no NOPs */
85 0002AF0B fe 04 ef000009fc callf $4,_pipe7_10
86 0002AF12 # asm("jmp *return"); /* return to the test monitor */
87 0002AF12 71 ffffffff54 jmp *return
88 0002AF18 # }
89 0002AF18 40 ret#2
90 0002AF19 .set L215,0x0
91 0002AF19 L217:
92 0002AF19 13 ff55 jbr L218
93 0002AF1C .data
94 00000de8 * .text
95 0002AF1C .align 1
96 0002AF1C .globl _pipe7_1
97 0002AF1C _pipe7_1:
98 0002AF1C 0000 .word L232
99 0002AF1E #
100 0002AF1E #
101 0002AF1E #
102 0002AF1E #
103 0002AF1E #
104 0002AF1E #
105 0002AF1E # /************************************************************************
106 0002AF1E # *
107 0002AF1E # * SUBTEST 1
108 0002AF1E # * data in registers, no NO-OPs
109 0002AF1E # *
110 0002AF1E # ************************************************************************/
111 0002AF1E # pipe7_1()
112 0002AF1E # {
113 0002AF1E 13 00e1 jbr L234
114 0002AF21 L235:
115 0002AF21 # force_loop = FALSE; /* clear the force_loop flg */
116 0002AF21 4d efffffff45 clrl _force_loop
117 0002AF27 # index = 0;
118 0002AF27 4d efffffff3f clrl _index
119 0002AF2D # do
120 0002AF2D L238:
121 0002AF2D # {
122 0002AF2D # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
123 0002AF2D 0d efffffff39 50 movl _index,r0
124 0002AF34 48 03 50 50 shll $3,r0,r0
125 0002AF38 0d e000000000 efffffff29 movl _ldf_1_data(r0),_sgl_value_1
126 0002AF43 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
127 0002AF43 0d efffffff23 50 movl _index,r0
128 0002AF4A 48 03 50 50 shll $3,r0,r0
129 0002AF4E 0d e000000004 efffffff13 movl _ldf_1_data+4(r0),_sgl_expected
130 0002AF59 # sgl_value_2 = 0; /* set one operand to 0 */
131 0002AF59 4d efffffff0d clrl _sgl_value_2
132 0002AF5F # /*
133 0002AF5F # * If LOOP ON ERROR is set, this is the loop for this subtest.
134 0002AF5F # * The force loop flag is set after the first error.
135 0002AF5F # */
136 0002AF5F # asm("_pipe7_1_lp1:");
137 0002AF5F _pipe7_1_lp1:
138 0002AF5F # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
139 0002AF5F 0d efffffff07 54 movl _sgl_value_1,r4
140 0002AF66 # asm("movl _sgl_value_2,r3"); /* move the '0' to r3 */
141 0002AF66 0d efffffff00 53 movl _sgl_value_2,r3
142 0002AF6D # asm("ldf r4"); /* load the ACC (ACC = op) */
143 0002AF6D 06 54 ldf r4
144 0002AF6F # asm("subf r4"); /* sub. the op. (ACC = 0 ) */
145 0002AF6F d6 54 subf r4
146 0002AF71 # asm("addf r3"); /* add a '0' (ACC = 0 ) */
147 0002AF71 c6 53 addf r3
148 0002AF73 # asm("subf r4"); /* sub. the op. (ACC =-op) */
149 0002AF73 d6 54 subf r4
150 0002AF75 # asm("addf r4"); /* add the op. (ACC = 0 ) */
151 0002AF75 c6 54 addf r4
152 0002AF77 # asm("subf r3"); /* sub. a '0' (ACC = 0 ) */
153 0002AF77 d6 53 subf r3
154 0002AF79 # asm("addf r4"); /* add the op. (ACC = op) */
155 0002AF79 c6 54 addf r4
156 0002AF7B # asm("subf r4"); /* sub. the op. (ACC = 0 ) */
157 0002AF7B d6 54 subf r4
158 0002AF7D # asm("addf r3"); /* add a '0' (ACC = 0 ) */
159 0002AF7D c6 53 addf r3
160 0002AF7F # asm("subf r3"); /* sub. a '0' (ACC = 0 ) */
161 0002AF7F d6 53 subf r3
162 0002AF81 # asm("addf r4"); /* add the op. (ACC = op) */
163 0002AF81 c6 54 addf r4
164 0002AF83 # asm("stf r5"); /* store the ACC (s/b= op) */
165 0002AF83 26 55 stf r5
166 0002AF85 # if( force_loop )
167 0002AF85 5d effffffee1 tstl _force_loop
168 0002AF8B 31 02 jeql L239
169 0002AF8D # asm("brb _pipe7_1_lp1");; /* loop on the error */
170 0002AF8D 11 d0 brb _pipe7_1_lp1
171 0002AF8F L239:
172 0002AF8F # /*
173 0002AF8F # * verify the results
174 0002AF8F # */
175 0002AF8F # asm("movl r5,_sgl_st_acc"); /* get the result */
176 0002AF8F 0d 55 effffffed6 movl r5,_sgl_st_acc
177 0002AF96 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
178 0002AF96 1d effffffed0 effffffecb cmpl _sgl_st_acc,_sgl_expected
179 0002AFA1 31 45 jeql L240
180 0002AFA3 # {
181 0002AFA3 # errcnt++; /* bump the error count */
182 0002AFA3 6d effffffec3 incl _errcnt
183 0002AFA9 # if ( prt_error )
184 0002AFA9 5d effffffebd tstl _prt_error
185 0002AFAF 31 0d jeql L241
186 0002AFB1 # print_pipe7_er("Reg. Data, no NO-OPs");
187 0002AFB1 .data 1
188 00000df1 * L243:
189 00000df1 * 5265672E20446174612C206E6 .ascii "Reg. Data, no NO-OPs\0"
F204E4F2D4F507300
190 00000e06 * .text
191 0002AFB1 dd 8f00000df1 pushl $L243
192 0002AFB7 fe 08 ef00000b0e callf $8,_print_pipe7_er
193 0002AFBE # if ( halt_flg )
194 0002AFBE L241:
195 0002AFBE 5d effffffea8 tstl _halt_flg
196 0002AFC4 31 0d jeql L244
197 0002AFC6 # pipe7_er_hlt( subtest );
198 0002AFC6 dd effffffea0 pushl _subtest
199 0002AFCC fe 08 ef00000c11 callf $8,_pipe7_er_hlt
200 0002AFD3 # if ( loop_on_err ) {
201 0002AFD3 L244:
202 0002AFD3 5d effffffe93 tstl _loop_on_err
203 0002AFD9 31 0d jeql L246
204 0002AFDB # force_loop = TRUE; /* set the force loop flag */
205 0002AFDB 0d 01 effffffe8a movl $1,_force_loop
206 0002AFE2 # asm("jmp _pipe7_1_lp1"); /* and loop */
207 0002AFE2 71 efffffff77 jmp _pipe7_1_lp1
208 0002AFE8 # }
209 0002AFE8 # } /* end of compare error */
210 0002AFE8 L246:
211 0002AFE8 # } while( index++ < max_ldf_1_index );
212 0002AFE8 L240:
213 0002AFE8 L237:
214 0002AFE8 0d effffffe7e 50 movl _index,r0
215 0002AFEF 6d effffffe77 incl _index
216 0002AFF5 1d 50 effffffe70 cmpl r0,_max_ldf_1_index
217 0002AFFC 81 03 13 ff2c jlss L238
218 0002B001 L236:
219 0002B001 # } /* end of subtest 1 */
220 0002B001 40 ret#2
221 0002B002 .set L232,0x0
222 0002B002 L234:
223 0002B002 13 ff1c jbr L235
224 0002B005 .data
225 00000de8 * .text
226 0002B005 00 .align 1
227 0002B006 .globl _pipe7_2
228 0002B006 _pipe7_2:
229 0002B006 0000 .word L247
230 0002B008 #
231 0002B008 #
232 0002B008 #
233 0002B008 #
234 0002B008 #
235 0002B008 #
236 0002B008 # /************************************************************************
237 0002B008 # *
238 0002B008 # * SUBTEST 2
239 0002B008 # * data in registers, 1 NO-OP
240 0002B008 # *
241 0002B008 # ************************************************************************/
242 0002B008 # pipe7_2()
243 0002B008 # {
244 0002B008 13 00ec jbr L249
245 0002B00B L250:
246 0002B00B # force_loop = FALSE; /* clear force_loop flag */
247 0002B00B 4d effffffe5b clrl _force_loop
248 0002B011 # index = 0;
249 0002B011 4d effffffe55 clrl _index
250 0002B017 # do
251 0002B017 L253:
252 0002B017 # {
253 0002B017 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
254 0002B017 0d effffffe4f 50 movl _index,r0
255 0002B01E 48 03 50 50 shll $3,r0,r0
256 0002B022 0d e000000000 effffffe3f movl _ldf_1_data(r0),_sgl_value_1
257 0002B02D # sgl_expected = ldf_1_data[index].exp; /* get expected results */
258 0002B02D 0d effffffe39 50 movl _index,r0
259 0002B034 48 03 50 50 shll $3,r0,r0
260 0002B038 0d e000000004 effffffe29 movl _ldf_1_data+4(r0),_sgl_expected
261 0002B043 # sgl_value_2 = 0; /* get the '0' operand */
262 0002B043 4d effffffe23 clrl _sgl_value_2
263 0002B049 # /*
264 0002B049 # * If LOOP ON ERROR is set, this is the loop for this subtest.
265 0002B049 # * The force loop flag is set after the first error.
266 0002B049 # */
267 0002B049 # asm("_pipe7_2_lp1:");
268 0002B049 _pipe7_2_lp1:
269 0002B049 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
270 0002B049 0d effffffe1d 54 movl _sgl_value_1,r4
271 0002B050 # asm("movl _sgl_value_2,r3"); /* move the '0' to r3 */
272 0002B050 0d effffffe16 53 movl _sgl_value_2,r3
273 0002B057 # asm("ldf r4"); /* load the ACC (ACC = op) */
274 0002B057 06 54 ldf r4
275 0002B059 # asm("nop");
276 0002B059 10 nop
277 0002B05A # asm("subf r4"); /* sub. the op. (ACC = 0 ) */
278 0002B05A d6 54 subf r4
279 0002B05C # asm("nop");
280 0002B05C 10 nop
281 0002B05D # asm("addf r3"); /* add a '0' (ACC = 0 ) */
282 0002B05D c6 53 addf r3
283 0002B05F # asm("nop");
284 0002B05F 10 nop
285 0002B060 # asm("subf r4"); /* sub. the op. (ACC =-op) */
286 0002B060 d6 54 subf r4
287 0002B062 # asm("nop");
288 0002B062 10 nop
289 0002B063 # asm("addf r4"); /* add the op. (ACC = 0 ) */
290 0002B063 c6 54 addf r4
291 0002B065 # asm("nop");
292 0002B065 10 nop
293 0002B066 # asm("subf r3"); /* sub. a '0' (ACC = 0 ) */
294 0002B066 d6 53 subf r3
295 0002B068 # asm("nop");
296 0002B068 10 nop
297 0002B069 # asm("addf r4"); /* add the op. (ACC = op) */
298 0002B069 c6 54 addf r4
299 0002B06B # asm("nop");
300 0002B06B 10 nop
301 0002B06C # asm("subf r4"); /* sub. the op. (ACC = 0 ) */
302 0002B06C d6 54 subf r4
303 0002B06E # asm("nop");
304 0002B06E 10 nop
305 0002B06F # asm("addf r3"); /* add a '0' (ACC = 0 ) */
306 0002B06F c6 53 addf r3
307 0002B071 # asm("nop");
308 0002B071 10 nop
309 0002B072 # asm("subf r3"); /* sub. a '0' (ACC = 0 ) */
310 0002B072 d6 53 subf r3
311 0002B074 # asm("nop");
312 0002B074 10 nop
313 0002B075 # asm("addf r4"); /* add the op. (ACC = op) */
314 0002B075 c6 54 addf r4
315 0002B077 # asm("nop");
316 0002B077 10 nop
317 0002B078 # asm("stf r5"); /* store the ACC (s/b= op) */
318 0002B078 26 55 stf r5
319 0002B07A # if( force_loop )
320 0002B07A 5d effffffdec tstl _force_loop
321 0002B080 31 02 jeql L254
322 0002B082 # asm("brb _pipe7_2_lp1");; /* loop on the error */
323 0002B082 11 c5 brb _pipe7_2_lp1
324 0002B084 L254:
325 0002B084 # /*
326 0002B084 # * verify the results
327 0002B084 # */
328 0002B084 # asm("movl r5,_sgl_st_acc"); /* get the result */
329 0002B084 0d 55 effffffde1 movl r5,_sgl_st_acc
330 0002B08B # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
331 0002B08B 1d effffffddb effffffdd6 cmpl _sgl_st_acc,_sgl_expected
332 0002B096 31 45 jeql L255
333 0002B098 # {
334 0002B098 # errcnt++; /* bump the error count */
335 0002B098 6d effffffdce incl _errcnt
336 0002B09E # if ( prt_error )
337 0002B09E 5d effffffdc8 tstl _prt_error
338 0002B0A4 31 0d jeql L256
339 0002B0A6 # print_pipe7_er("Reg. Data, 1 NO-OP");
340 0002B0A6 .data 1
341 00000e06 * L257:
342 00000e06 * 5265672E20446174612C20312 .ascii "Reg. Data, 1 NO-OP\0"
04E4F2D4F5000
343 00000e19 * .text
344 0002B0A6 dd 8f00000e06 pushl $L257
345 0002B0AC fe 08 ef00000a19 callf $8,_print_pipe7_er
346 0002B0B3 # if ( halt_flg )
347 0002B0B3 L256:
348 0002B0B3 5d effffffdb3 tstl _halt_flg
349 0002B0B9 31 0d jeql L258
350 0002B0BB # pipe7_er_hlt( subtest );
351 0002B0BB dd effffffdab pushl _subtest
352 0002B0C1 fe 08 ef00000b1c callf $8,_pipe7_er_hlt
353 0002B0C8 # if ( loop_on_err ) {
354 0002B0C8 L258:
355 0002B0C8 5d effffffd9e tstl _loop_on_err
356 0002B0CE 31 0d jeql L259
357 0002B0D0 # force_loop = TRUE; /* set the force loop flag */
358 0002B0D0 0d 01 effffffd95 movl $1,_force_loop
359 0002B0D7 # asm("jmp _pipe7_2_lp1"); /* and loop */
360 0002B0D7 71 efffffff6c jmp _pipe7_2_lp1
361 0002B0DD # }
362 0002B0DD # } /* end of compare error */
363 0002B0DD L259:
364 0002B0DD # } while( index++ < max_ldf_1_index );
365 0002B0DD L255:
366 0002B0DD L252:
367 0002B0DD 0d effffffd89 50 movl _index,r0
368 0002B0E4 6d effffffd82 incl _index
369 0002B0EA 1d 50 effffffd7b cmpl r0,_max_ldf_1_index
370 0002B0F1 81 03 13 ff21 jlss L253
371 0002B0F6 L251:
372 0002B0F6 # } /* end of subtest 2 */
373 0002B0F6 40 ret#2
374 0002B0F7 .set L247,0x0
375 0002B0F7 L249:
376 0002B0F7 13 ff11 jbr L250
377 0002B0FA .data
378 00000de8 * .text
379 0002B0FA .align 1
380 0002B0FA .globl _pipe7_3
381 0002B0FA _pipe7_3:
382 0002B0FA 0000 .word L260
383 0002B0FC #
384 0002B0FC #
385 0002B0FC #
386 0002B0FC #
387 0002B0FC #
388 0002B0FC #
389 0002B0FC # /************************************************************************
390 0002B0FC # *
391 0002B0FC # * SUBTEST 3
392 0002B0FC # * data in registers, 2 NO-OPs
393 0002B0FC # *
394 0002B0FC # ************************************************************************/
395 0002B0FC # pipe7_3()
396 0002B0FC # {
397 0002B0FC 13 00f7 jbr L262
398 0002B0FF L263:
399 0002B0FF # force_loop = FALSE; /* clear force_loop flag */
400 0002B0FF 4d effffffd67 clrl _force_loop
401 0002B105 # index = 0;
402 0002B105 4d effffffd61 clrl _index
403 0002B10B # do
404 0002B10B L266:
405 0002B10B # {
406 0002B10B # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
407 0002B10B 0d effffffd5b 50 movl _index,r0
408 0002B112 48 03 50 50 shll $3,r0,r0
409 0002B116 0d e000000000 effffffd4b movl _ldf_1_data(r0),_sgl_value_1
410 0002B121 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
411 0002B121 0d effffffd45 50 movl _index,r0
412 0002B128 48 03 50 50 shll $3,r0,r0
413 0002B12C 0d e000000004 effffffd35 movl _ldf_1_data+4(r0),_sgl_expected
414 0002B137 # sgl_value_2 = 0; /* set the '0' operand */
415 0002B137 4d effffffd2f clrl _sgl_value_2
416 0002B13D # /*
417 0002B13D # * If LOOP ON ERROR is set, this is the loop for this subtest.
418 0002B13D # * The force loop flag is set after the first error.
419 0002B13D # */
420 0002B13D # asm("_pipe7_3_lp1:");
421 0002B13D _pipe7_3_lp1:
422 0002B13D # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
423 0002B13D 0d effffffd29 54 movl _sgl_value_1,r4
424 0002B144 # asm("movl _sgl_value_2,r3"); /* move the '0' to r3 */
425 0002B144 0d effffffd22 53 movl _sgl_value_2,r3
426 0002B14B # asm("ldf r4"); /* load the ACC (ACC = op) */
427 0002B14B 06 54 ldf r4
428 0002B14D # asm("nop");
429 0002B14D 10 nop
430 0002B14E # asm("nop");
431 0002B14E 10 nop
432 0002B14F # asm("subf r4"); /* sub. the op. (ACC = 0 ) */
433 0002B14F d6 54 subf r4
434 0002B151 # asm("nop");
435 0002B151 10 nop
436 0002B152 # asm("nop");
437 0002B152 10 nop
438 0002B153 # asm("addf r3"); /* add a '0' (ACC = 0 ) */
439 0002B153 c6 53 addf r3
440 0002B155 # asm("nop");
441 0002B155 10 nop
442 0002B156 # asm("nop");
443 0002B156 10 nop
444 0002B157 # asm("subf r4"); /* sub. the op. (ACC =-op) */
445 0002B157 d6 54 subf r4
446 0002B159 # asm("nop");
447 0002B159 10 nop
448 0002B15A # asm("nop");
449 0002B15A 10 nop
450 0002B15B # asm("addf r4"); /* add the op. (ACC = 0 ) */
451 0002B15B c6 54 addf r4
452 0002B15D # asm("nop");
453 0002B15D 10 nop
454 0002B15E # asm("nop");
455 0002B15E 10 nop
456 0002B15F # asm("subf r3"); /* sub. a '0' (ACC = 0 ) */
457 0002B15F d6 53 subf r3
458 0002B161 # asm("nop");
459 0002B161 10 nop
460 0002B162 # asm("nop");
461 0002B162 10 nop
462 0002B163 # asm("addf r4"); /* add the op. (ACC = op) */
463 0002B163 c6 54 addf r4
464 0002B165 # asm("nop");
465 0002B165 10 nop
466 0002B166 # asm("nop");
467 0002B166 10 nop
468 0002B167 # asm("subf r4"); /* sub. the op. (ACC = 0 ) */
469 0002B167 d6 54 subf r4
470 0002B169 # asm("nop");
471 0002B169 10 nop
472 0002B16A # asm("nop");
473 0002B16A 10 nop
474 0002B16B # asm("addf r3"); /* add a '0' (ACC = 0 ) */
475 0002B16B c6 53 addf r3
476 0002B16D # asm("nop");
477 0002B16D 10 nop
478 0002B16E # asm("nop");
479 0002B16E 10 nop
480 0002B16F # asm("subf r3"); /* sub. a '0' (ACC = 0 ) */
481 0002B16F d6 53 subf r3
482 0002B171 # asm("nop");
483 0002B171 10 nop
484 0002B172 # asm("nop");
485 0002B172 10 nop
486 0002B173 # asm("addf r4"); /* add the op. (ACC = op) */
487 0002B173 c6 54 addf r4
488 0002B175 # asm("nop");
489 0002B175 10 nop
490 0002B176 # asm("nop");
491 0002B176 10 nop
492 0002B177 # asm("stf r5"); /* store the ACC (s/b= op) */
493 0002B177 26 55 stf r5
494 0002B179 # if( force_loop )
495 0002B179 5d effffffced tstl _force_loop
496 0002B17F 31 02 jeql L267
497 0002B181 # asm("brb _pipe7_3_lp1");; /* loop on the error */
498 0002B181 11 ba brb _pipe7_3_lp1
499 0002B183 L267:
500 0002B183 # /*
501 0002B183 # * verify the results
502 0002B183 # */
503 0002B183 # asm("movl r5,_sgl_st_acc"); /* get the result */
504 0002B183 0d 55 effffffce2 movl r5,_sgl_st_acc
505 0002B18A # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
506 0002B18A 1d effffffcdc effffffcd7 cmpl _sgl_st_acc,_sgl_expected
507 0002B195 31 45 jeql L268
508 0002B197 # {
509 0002B197 # errcnt++; /* bump the error count */
510 0002B197 6d effffffccf incl _errcnt
511 0002B19D # if ( prt_error )
512 0002B19D 5d effffffcc9 tstl _prt_error
513 0002B1A3 31 0d jeql L269
514 0002B1A5 # print_pipe7_er("Reg. Data, 2 NO-OPs");
515 0002B1A5 .data 1
516 00000e19 * L270:
517 00000e19 * 5265672E20446174612C20322 .ascii "Reg. Data, 2 NO-OPs\0"
04E4F2D4F507300
518 00000e2d * .text
519 0002B1A5 dd 8f00000e19 pushl $L270
520 0002B1AB fe 08 ef0000091a callf $8,_print_pipe7_er
521 0002B1B2 # if ( halt_flg )
522 0002B1B2 L269:
523 0002B1B2 5d effffffcb4 tstl _halt_flg
524 0002B1B8 31 0d jeql L271
525 0002B1BA # pipe7_er_hlt( subtest );
526 0002B1BA dd effffffcac pushl _subtest
527 0002B1C0 fe 08 ef00000a1d callf $8,_pipe7_er_hlt
528 0002B1C7 # if ( loop_on_err ) {
529 0002B1C7 L271:
530 0002B1C7 5d effffffc9f tstl _loop_on_err
531 0002B1CD 31 0d jeql L272
532 0002B1CF # force_loop = TRUE; /* set the force loop flag */
533 0002B1CF 0d 01 effffffc96 movl $1,_force_loop
534 0002B1D6 # asm("jmp _pipe7_3_lp1"); /* and loop */
535 0002B1D6 71 efffffff61 jmp _pipe7_3_lp1
536 0002B1DC # }
537 0002B1DC # } /* end of compare error */
538 0002B1DC L272:
539 0002B1DC # } while( index++ < max_ldf_1_index );
540 0002B1DC L268:
541 0002B1DC L265:
542 0002B1DC 0d effffffc8a 50 movl _index,r0
543 0002B1E3 6d effffffc83 incl _index
544 0002B1E9 1d 50 effffffc7c cmpl r0,_max_ldf_1_index
545 0002B1F0 81 03 13 ff16 jlss L266
546 0002B1F5 L264:
547 0002B1F5 # } /* end of subtest 3 */
548 0002B1F5 40 ret#2
549 0002B1F6 .set L260,0x0
550 0002B1F6 L262:
551 0002B1F6 13 ff06 jbr L263
552 0002B1F9 .data
553 00000de8 * .text
554 0002B1F9 00 .align 1
555 0002B1FA .globl _pipe7_4
556 0002B1FA _pipe7_4:
557 0002B1FA 0000 .word L273
558 0002B1FC #
559 0002B1FC #
560 0002B1FC #
561 0002B1FC #
562 0002B1FC #
563 0002B1FC #
564 0002B1FC # /************************************************************************
565 0002B1FC # *
566 0002B1FC # * SUBTEST 4
567 0002B1FC # * data in registers, 3 NO-OPs
568 0002B1FC # *
569 0002B1FC # ************************************************************************/
570 0002B1FC # pipe7_4()
571 0002B1FC # {
572 0002B1FC 13 0102 jbr L275
573 0002B1FF L276:
574 0002B1FF # force_loop = FALSE; /* clear force_loop flag */
575 0002B1FF 4d effffffc67 clrl _force_loop
576 0002B205 # index = 0;
577 0002B205 4d effffffc61 clrl _index
578 0002B20B # do
579 0002B20B L279:
580 0002B20B # {
581 0002B20B # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
582 0002B20B 0d effffffc5b 50 movl _index,r0
583 0002B212 48 03 50 50 shll $3,r0,r0
584 0002B216 0d e000000000 effffffc4b movl _ldf_1_data(r0),_sgl_value_1
585 0002B221 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
586 0002B221 0d effffffc45 50 movl _index,r0
587 0002B228 48 03 50 50 shll $3,r0,r0
588 0002B22C 0d e000000004 effffffc35 movl _ldf_1_data+4(r0),_sgl_expected
589 0002B237 # sgl_value_2 = 0; /* set the '0' operand */
590 0002B237 4d effffffc2f clrl _sgl_value_2
591 0002B23D # /*
592 0002B23D # * If LOOP ON ERROR is set, this is the loop for this subtest.
593 0002B23D # * The force loop flag is set after the first error.
594 0002B23D # */
595 0002B23D # asm("_pipe7_4_lp1:");
596 0002B23D _pipe7_4_lp1:
597 0002B23D # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
598 0002B23D 0d effffffc29 54 movl _sgl_value_1,r4
599 0002B244 # asm("movl _sgl_value_2,r3"); /* move the '0' to r3 */
600 0002B244 0d effffffc22 53 movl _sgl_value_2,r3
601 0002B24B # asm("ldf r4"); /* load the ACC (ACC = op) */
602 0002B24B 06 54 ldf r4
603 0002B24D # asm("nop");
604 0002B24D 10 nop
605 0002B24E # asm("nop");
606 0002B24E 10 nop
607 0002B24F # asm("nop");
608 0002B24F 10 nop
609 0002B250 # asm("subf r4"); /* sub. the op. (ACC = 0 ) */
610 0002B250 d6 54 subf r4
611 0002B252 # asm("nop");
612 0002B252 10 nop
613 0002B253 # asm("nop");
614 0002B253 10 nop
615 0002B254 # asm("nop");
616 0002B254 10 nop
617 0002B255 # asm("addf r3"); /* add a '0' (ACC = 0 ) */
618 0002B255 c6 53 addf r3
619 0002B257 # asm("nop");
620 0002B257 10 nop
621 0002B258 # asm("nop");
622 0002B258 10 nop
623 0002B259 # asm("nop");
624 0002B259 10 nop
625 0002B25A # asm("subf r4"); /* sub. the op. (ACC =-op) */
626 0002B25A d6 54 subf r4
627 0002B25C # asm("nop");
628 0002B25C 10 nop
629 0002B25D # asm("nop");
630 0002B25D 10 nop
631 0002B25E # asm("nop");
632 0002B25E 10 nop
633 0002B25F # asm("addf r4"); /* add the op. (ACC = 0 ) */
634 0002B25F c6 54 addf r4
635 0002B261 # asm("nop");
636 0002B261 10 nop
637 0002B262 # asm("nop");
638 0002B262 10 nop
639 0002B263 # asm("nop");
640 0002B263 10 nop
641 0002B264 # asm("subf r3"); /* sub. a '0' (ACC = 0 ) */
642 0002B264 d6 53 subf r3
643 0002B266 # asm("nop");
644 0002B266 10 nop
645 0002B267 # asm("nop");
646 0002B267 10 nop
647 0002B268 # asm("nop");
648 0002B268 10 nop
649 0002B269 # asm("addf r4"); /* add the op. (ACC = op) */
650 0002B269 c6 54 addf r4
651 0002B26B # asm("nop");
652 0002B26B 10 nop
653 0002B26C # asm("nop");
654 0002B26C 10 nop
655 0002B26D # asm("nop");
656 0002B26D 10 nop
657 0002B26E # asm("subf r4"); /* sub. the op. (ACC = 0 ) */
658 0002B26E d6 54 subf r4
659 0002B270 # asm("nop");
660 0002B270 10 nop
661 0002B271 # asm("nop");
662 0002B271 10 nop
663 0002B272 # asm("nop");
664 0002B272 10 nop
665 0002B273 # asm("addf r3"); /* add a '0' (ACC = 0 ) */
666 0002B273 c6 53 addf r3
667 0002B275 # asm("nop");
668 0002B275 10 nop
669 0002B276 # asm("nop");
670 0002B276 10 nop
671 0002B277 # asm("nop");
672 0002B277 10 nop
673 0002B278 # asm("subf r3"); /* sub. a '0' (ACC = 0 ) */
674 0002B278 d6 53 subf r3
675 0002B27A # asm("nop");
676 0002B27A 10 nop
677 0002B27B # asm("nop");
678 0002B27B 10 nop
679 0002B27C # asm("nop");
680 0002B27C 10 nop
681 0002B27D # asm("addf r4"); /* add the op. (ACC = op) */
682 0002B27D c6 54 addf r4
683 0002B27F # asm("nop");
684 0002B27F 10 nop
685 0002B280 # asm("nop");
686 0002B280 10 nop
687 0002B281 # asm("nop");
688 0002B281 10 nop
689 0002B282 # asm("stf r5"); /* store the ACC (s/b= op) */
690 0002B282 26 55 stf r5
691 0002B284 # if( force_loop )
692 0002B284 5d effffffbe2 tstl _force_loop
693 0002B28A 31 02 jeql L280
694 0002B28C # asm("brb _pipe7_4_lp1");; /* loop on the error */
695 0002B28C 11 af brb _pipe7_4_lp1
696 0002B28E L280:
697 0002B28E # /*
698 0002B28E # * verify the results
699 0002B28E # */
700 0002B28E # asm("movl r5,_sgl_st_acc"); /* get the result */
701 0002B28E 0d 55 effffffbd7 movl r5,_sgl_st_acc
702 0002B295 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
703 0002B295 1d effffffbd1 effffffbcc cmpl _sgl_st_acc,_sgl_expected
704 0002B2A0 31 45 jeql L281
705 0002B2A2 # {
706 0002B2A2 # errcnt++; /* bump the error count */
707 0002B2A2 6d effffffbc4 incl _errcnt
708 0002B2A8 # if ( prt_error )
709 0002B2A8 5d effffffbbe tstl _prt_error
710 0002B2AE 31 0d jeql L282
711 0002B2B0 # print_pipe7_er("Reg. Data, 3 NO-OPs");
712 0002B2B0 .data 1
713 00000e2d * L283:
714 00000e2d * 5265672E20446174612C20332 .ascii "Reg. Data, 3 NO-OPs\0"
04E4F2D4F507300
715 00000e41 * .text
716 0002B2B0 dd 8f00000e2d pushl $L283
717 0002B2B6 fe 08 ef0000080f callf $8,_print_pipe7_er
718 0002B2BD # if ( halt_flg )
719 0002B2BD L282:
720 0002B2BD 5d effffffba9 tstl _halt_flg
721 0002B2C3 31 0d jeql L284
722 0002B2C5 # pipe7_er_hlt( subtest );
723 0002B2C5 dd effffffba1 pushl _subtest
724 0002B2CB fe 08 ef00000912 callf $8,_pipe7_er_hlt
725 0002B2D2 # if ( loop_on_err ) {
726 0002B2D2 L284:
727 0002B2D2 5d effffffb94 tstl _loop_on_err
728 0002B2D8 31 0d jeql L285
729 0002B2DA # force_loop = TRUE; /* set the force loop flag */
730 0002B2DA 0d 01 effffffb8b movl $1,_force_loop
731 0002B2E1 # asm("jmp _pipe7_4_lp1"); /* and loop */
732 0002B2E1 71 efffffff56 jmp _pipe7_4_lp1
733 0002B2E7 # }
734 0002B2E7 # } /* end of compare error */
735 0002B2E7 L285:
736 0002B2E7 # } while( index++ < max_ldf_1_index );
737 0002B2E7 L281:
738 0002B2E7 L278:
739 0002B2E7 0d effffffb7f 50 movl _index,r0
740 0002B2EE 6d effffffb78 incl _index
741 0002B2F4 1d 50 effffffb71 cmpl r0,_max_ldf_1_index
742 0002B2FB 81 03 13 ff0b jlss L279
743 0002B300 L277:
744 0002B300 # } /* end of subtest 4 */
745 0002B300 40 ret#2
746 0002B301 .set L273,0x0
747 0002B301 L275:
748 0002B301 13 fefb jbr L276
749 0002B304 .data
750 00000de8 * .text
751 0002B304 .align 1
752 0002B304 .globl _pipe7_5
753 0002B304 _pipe7_5:
754 0002B304 0000 .word L286
755 0002B306 #
756 0002B306 #
757 0002B306 #
758 0002B306 #
759 0002B306 #
760 0002B306 #
761 0002B306 #
762 0002B306 # /************************************************************************
763 0002B306 # *
764 0002B306 # * SUBTEST 5
765 0002B306 # * data in Cache, no NO-OPs
766 0002B306 # *
767 0002B306 # ************************************************************************/
768 0002B306 # pipe7_5()
769 0002B306 # {
770 0002B306 13 00fc jbr L288
771 0002B309 L289:
772 0002B309 # force_loop = FALSE; /* clear force_loop flag */
773 0002B309 4d effffffb5d clrl _force_loop
774 0002B30F # index = 0;
775 0002B30F 4d effffffb57 clrl _index
776 0002B315 # do
777 0002B315 L292:
778 0002B315 # {
779 0002B315 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
780 0002B315 0d effffffb51 50 movl _index,r0
781 0002B31C 48 03 50 50 shll $3,r0,r0
782 0002B320 0d e000000000 effffffb41 movl _ldf_1_data(r0),_sgl_value_1
783 0002B32B # sgl_expected = ldf_1_data[index].exp; /* get expected results */
784 0002B32B 0d effffffb3b 50 movl _index,r0
785 0002B332 48 03 50 50 shll $3,r0,r0
786 0002B336 0d e000000004 effffffb2b movl _ldf_1_data+4(r0),_sgl_expected
787 0002B341 # sgl_value_2 = 0; /* set the '0' operand */
788 0002B341 4d effffffb25 clrl _sgl_value_2
789 0002B347 # /*
790 0002B347 # * If LOOP ON ERROR is set, this is the loop for this subtest.
791 0002B347 # * The force loop flag is set after the first error.
792 0002B347 # */
793 0002B347 # asm("_pipe7_5_lp1:");
794 0002B347 _pipe7_5_lp1:
795 0002B347 # asm("ldf _sgl_value_1"); /* load the ACC (ACC = op) */
796 0002B347 06 effffffb1f ldf _sgl_value_1
797 0002B34D # asm("subf _sgl_value_1"); /* sub. the op. (ACC = 0 ) */
798 0002B34D d6 effffffb19 subf _sgl_value_1
799 0002B353 # asm("addf _sgl_value_2"); /* add a '0' (ACC = 0 ) */
800 0002B353 c6 effffffb13 addf _sgl_value_2
801 0002B359 # asm("subf _sgl_value_1"); /* sub. the op. (ACC =-op) */
802 0002B359 d6 effffffb0d subf _sgl_value_1
803 0002B35F # asm("addf _sgl_value_1"); /* add the op. (ACC = 0 ) */
804 0002B35F c6 effffffb07 addf _sgl_value_1
805 0002B365 # asm("subf _sgl_value_2"); /* sub. a '0' (ACC = 0 ) */
806 0002B365 d6 effffffb01 subf _sgl_value_2
807 0002B36B # asm("addf _sgl_value_1"); /* add the op. (ACC = op) */
808 0002B36B c6 effffffafb addf _sgl_value_1
809 0002B371 # asm("subf _sgl_value_1"); /* sub. the op. (ACC = 0 ) */
810 0002B371 d6 effffffaf5 subf _sgl_value_1
811 0002B377 # asm("addf _sgl_value_2"); /* add a '0' (ACC = 0 ) */
812 0002B377 c6 effffffaef addf _sgl_value_2
813 0002B37D # asm("subf _sgl_value_2"); /* sub. a '0' (ACC = 0 ) */
814 0002B37D d6 effffffae9 subf _sgl_value_2
815 0002B383 # asm("addf _sgl_value_1"); /* add the op. (ACC = op) */
816 0002B383 c6 effffffae3 addf _sgl_value_1
817 0002B389 # asm("stf _sgl_st_acc"); /* store the ACC (s/b= op) */
818 0002B389 26 effffffadd stf _sgl_st_acc
819 0002B38F # if( force_loop )
820 0002B38F 5d effffffad7 tstl _force_loop
821 0002B395 31 02 jeql L293
822 0002B397 # asm("brb _pipe7_5_lp1");; /* loop on the error */
823 0002B397 11 ae brb _pipe7_5_lp1
824 0002B399 L293:
825 0002B399 # /*
826 0002B399 # * verify the results
827 0002B399 # */
828 0002B399 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
829 0002B399 1d effffffacd effffffac8 cmpl _sgl_st_acc,_sgl_expected
830 0002B3A4 31 45 jeql L294
831 0002B3A6 # {
832 0002B3A6 # errcnt++; /* bump the error count */
833 0002B3A6 6d effffffac0 incl _errcnt
834 0002B3AC # if ( prt_error )
835 0002B3AC 5d effffffaba tstl _prt_error
836 0002B3B2 31 0d jeql L295
837 0002B3B4 # print_pipe7_er("Cache Data, no NO-OPs");
838 0002B3B4 .data 1
839 00000e41 * L296:
840 00000e41 * 436163686520446174612C206 .ascii "Cache Data, no NO-OPs\0"
E6F204E4F2D4F507300
841 00000e57 * .text
842 0002B3B4 dd 8f00000e41 pushl $L296
843 0002B3BA fe 08 ef0000070b callf $8,_print_pipe7_er
844 0002B3C1 # if ( halt_flg )
845 0002B3C1 L295:
846 0002B3C1 5d effffffaa5 tstl _halt_flg
847 0002B3C7 31 0d jeql L297
848 0002B3C9 # pipe7_er_hlt( subtest );
849 0002B3C9 dd effffffa9d pushl _subtest
850 0002B3CF fe 08 ef0000080e callf $8,_pipe7_er_hlt
851 0002B3D6 # if ( loop_on_err ) {
852 0002B3D6 L297:
853 0002B3D6 5d effffffa90 tstl _loop_on_err
854 0002B3DC 31 0d jeql L298
855 0002B3DE # force_loop = TRUE; /* set the force loop flag */
856 0002B3DE 0d 01 effffffa87 movl $1,_force_loop
857 0002B3E5 # asm("jmp _pipe7_5_lp1"); /* and loop */
858 0002B3E5 71 efffffff5c jmp _pipe7_5_lp1
859 0002B3EB # }
860 0002B3EB # } /* end of compare error */
861 0002B3EB L298:
862 0002B3EB # } while( index++ < max_ldf_1_index );
863 0002B3EB L294:
864 0002B3EB L291:
865 0002B3EB 0d effffffa7b 50 movl _index,r0
866 0002B3F2 6d effffffa74 incl _index
867 0002B3F8 1d 50 effffffa6d cmpl r0,_max_ldf_1_index
868 0002B3FF 81 03 13 ff11 jlss L292
869 0002B404 L290:
870 0002B404 # } /* end of subtest 5 */
871 0002B404 40 ret#2
872 0002B405 .set L286,0x0
873 0002B405 L288:
874 0002B405 13 ff01 jbr L289
875 0002B408 .data
876 00000de8 * .text
877 0002B408 .align 1
878 0002B408 .globl _pipe7_6
879 0002B408 _pipe7_6:
880 0002B408 0000 .word L299
881 0002B40A #
882 0002B40A #
883 0002B40A #
884 0002B40A #
885 0002B40A #
886 0002B40A #
887 0002B40A # /************************************************************************
888 0002B40A # *
889 0002B40A # * SUBTEST 6
890 0002B40A # * data in Cache, 1 NO-OP
891 0002B40A # *
892 0002B40A # ************************************************************************/
893 0002B40A # pipe7_6()
894 0002B40A # {
895 0002B40A 13 0101 jbr L301
896 0002B40D L302:
897 0002B40D # force_loop = FALSE; /* clear force_loop flag */
898 0002B40D 4d effffffa59 clrl _force_loop
899 0002B413 # index = 0;
900 0002B413 4d effffffa53 clrl _index
901 0002B419 # do
902 0002B419 L305:
903 0002B419 # {
904 0002B419 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
905 0002B419 0d effffffa4d 50 movl _index,r0
906 0002B420 48 03 50 50 shll $3,r0,r0
907 0002B424 0d e000000000 effffffa3d movl _ldf_1_data(r0),_sgl_value_1
908 0002B42F # sgl_expected = ldf_1_data[index].exp; /* get expected results */
909 0002B42F 0d effffffa37 50 movl _index,r0
910 0002B436 48 03 50 50 shll $3,r0,r0
911 0002B43A 0d e000000004 effffffa27 movl _ldf_1_data+4(r0),_sgl_expected
912 0002B445 # /*
913 0002B445 # * If LOOP ON ERROR is set, this is the loop for this subtest.
914 0002B445 # * The force loop flag is set after the first error.
915 0002B445 # */
916 0002B445 # asm("_pipe7_6_lp1:");
917 0002B445 _pipe7_6_lp1:
918 0002B445 # asm("ldf _sgl_value_1"); /* load the ACC (ACC = op) */
919 0002B445 06 effffffa21 ldf _sgl_value_1
920 0002B44B # asm("nop");
921 0002B44B 10 nop
922 0002B44C # asm("subf _sgl_value_1"); /* sub. the op. (ACC = 0 ) */
923 0002B44C d6 effffffa1a subf _sgl_value_1
924 0002B452 # asm("nop");
925 0002B452 10 nop
926 0002B453 # asm("addf _sgl_value_2"); /* add a '0' (ACC = 0 ) */
927 0002B453 c6 effffffa13 addf _sgl_value_2
928 0002B459 # asm("nop");
929 0002B459 10 nop
930 0002B45A # asm("subf _sgl_value_1"); /* sub. the op. (ACC =-op) */
931 0002B45A d6 effffffa0c subf _sgl_value_1
932 0002B460 # asm("nop");
933 0002B460 10 nop
934 0002B461 # asm("addf _sgl_value_1"); /* add the op. (ACC = 0 ) */
935 0002B461 c6 effffffa05 addf _sgl_value_1
936 0002B467 # asm("nop");
937 0002B467 10 nop
938 0002B468 # asm("subf _sgl_value_2"); /* sub. a '0' (ACC = 0 ) */
939 0002B468 d6 effffff9fe subf _sgl_value_2
940 0002B46E # asm("nop");
941 0002B46E 10 nop
942 0002B46F # asm("addf _sgl_value_1"); /* add the op. (ACC = op) */
943 0002B46F c6 effffff9f7 addf _sgl_value_1
944 0002B475 # asm("nop");
945 0002B475 10 nop
946 0002B476 # asm("subf _sgl_value_1"); /* sub. the op. (ACC = 0 ) */
947 0002B476 d6 effffff9f0 subf _sgl_value_1
948 0002B47C # asm("nop");
949 0002B47C 10 nop
950 0002B47D # asm("addf _sgl_value_2"); /* add a '0' (ACC = 0 ) */
951 0002B47D c6 effffff9e9 addf _sgl_value_2
952 0002B483 # asm("nop");
953 0002B483 10 nop
954 0002B484 # asm("subf _sgl_value_2"); /* sub. a '0' (ACC = 0 ) */
955 0002B484 d6 effffff9e2 subf _sgl_value_2
956 0002B48A # asm("nop");
957 0002B48A 10 nop
958 0002B48B # asm("addf _sgl_value_1"); /* add the op. (ACC = op) */
959 0002B48B c6 effffff9db addf _sgl_value_1
960 0002B491 # asm("nop");
961 0002B491 10 nop
962 0002B492 # asm("stf _sgl_st_acc"); /* store the ACC (s/b= op) */
963 0002B492 26 effffff9d4 stf _sgl_st_acc
964 0002B498 # if( force_loop )
965 0002B498 5d effffff9ce tstl _force_loop
966 0002B49E 31 02 jeql L306
967 0002B4A0 # asm("brb _pipe7_6_lp1");; /* loop on the error */
968 0002B4A0 11 a3 brb _pipe7_6_lp1
969 0002B4A2 L306:
970 0002B4A2 # /*
971 0002B4A2 # * verify the results
972 0002B4A2 # */
973 0002B4A2 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
974 0002B4A2 1d effffff9c4 effffff9bf cmpl _sgl_st_acc,_sgl_expected
975 0002B4AD 31 45 jeql L307
976 0002B4AF # {
977 0002B4AF # errcnt++; /* bump the error count */
978 0002B4AF 6d effffff9b7 incl _errcnt
979 0002B4B5 # if ( prt_error )
980 0002B4B5 5d effffff9b1 tstl _prt_error
981 0002B4BB 31 0d jeql L308
982 0002B4BD # print_pipe7_er("Cache Data, 1 NO-OP");
983 0002B4BD .data 1
984 00000e57 * L309:
985 00000e57 * 436163686520446174612C203 .ascii "Cache Data, 1 NO-OP\0"
1204E4F2D4F5000
986 00000e6b * .text
987 0002B4BD dd 8f00000e57 pushl $L309
988 0002B4C3 fe 08 ef00000602 callf $8,_print_pipe7_er
989 0002B4CA # if ( halt_flg )
990 0002B4CA L308:
991 0002B4CA 5d effffff99c tstl _halt_flg
992 0002B4D0 31 0d jeql L310
993 0002B4D2 # pipe7_er_hlt( subtest );
994 0002B4D2 dd effffff994 pushl _subtest
995 0002B4D8 fe 08 ef00000705 callf $8,_pipe7_er_hlt
996 0002B4DF # if ( loop_on_err ) {
997 0002B4DF L310:
998 0002B4DF 5d effffff987 tstl _loop_on_err
999 0002B4E5 31 0d jeql L311
1000 0002B4E7 # force_loop = TRUE; /* set the force loop flag */
1001 0002B4E7 0d 01 effffff97e movl $1,_force_loop
1002 0002B4EE # asm("jmp _pipe7_6_lp1"); /* and loop */
1003 0002B4EE 71 efffffff51 jmp _pipe7_6_lp1
1004 0002B4F4 # }
1005 0002B4F4 # } /* end of compare error */
1006 0002B4F4 L311:
1007 0002B4F4 # } while( index++ < max_ldf_1_index );
1008 0002B4F4 L307:
1009 0002B4F4 L304:
1010 0002B4F4 0d effffff972 50 movl _index,r0
1011 0002B4FB 6d effffff96b incl _index
1012 0002B501 1d 50 effffff964 cmpl r0,_max_ldf_1_index
1013 0002B508 81 03 13 ff0c jlss L305
1014 0002B50D L303:
1015 0002B50D # } /* end of subtest 6 */
1016 0002B50D 40 ret#2
1017 0002B50E .set L299,0x0
1018 0002B50E L301:
1019 0002B50E 13 fefc jbr L302
1020 0002B511 .data
1021 00000de8 * .text
1022 0002B511 00 .align 1
1023 0002B512 .globl _pipe7_7
1024 0002B512 _pipe7_7:
1025 0002B512 0000 .word L312
1026 0002B514 #
1027 0002B514 #
1028 0002B514 #
1029 0002B514 #
1030 0002B514 #
1031 0002B514 #
1032 0002B514 # /************************************************************************
1033 0002B514 # *
1034 0002B514 # * SUBTEST 7
1035 0002B514 # * data in Cache, 2 NO-OPs
1036 0002B514 # *
1037 0002B514 # ************************************************************************/
1038 0002B514 # pipe7_7()
1039 0002B514 # {
1040 0002B514 13 0112 jbr L314
1041 0002B517 L315:
1042 0002B517 # force_loop = FALSE; /* clear force_loop flag */
1043 0002B517 4d effffff94f clrl _force_loop
1044 0002B51D # index = 0;
1045 0002B51D 4d effffff949 clrl _index
1046 0002B523 # do
1047 0002B523 L318:
1048 0002B523 # {
1049 0002B523 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
1050 0002B523 0d effffff943 50 movl _index,r0
1051 0002B52A 48 03 50 50 shll $3,r0,r0
1052 0002B52E 0d e000000000 effffff933 movl _ldf_1_data(r0),_sgl_value_1
1053 0002B539 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
1054 0002B539 0d effffff92d 50 movl _index,r0
1055 0002B540 48 03 50 50 shll $3,r0,r0
1056 0002B544 0d e000000004 effffff91d movl _ldf_1_data+4(r0),_sgl_expected
1057 0002B54F # sgl_value_2 = 0; /* set the '0' operand */
1058 0002B54F 4d effffff917 clrl _sgl_value_2
1059 0002B555 # /*
1060 0002B555 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1061 0002B555 # * The force loop flag is set after the first error.
1062 0002B555 # */
1063 0002B555 # asm("_pipe7_7_lp1:");
1064 0002B555 _pipe7_7_lp1:
1065 0002B555 # asm("ldf _sgl_value_1"); /* load the ACC (ACC = op) */
1066 0002B555 06 effffff911 ldf _sgl_value_1
1067 0002B55B # asm("nop");
1068 0002B55B 10 nop
1069 0002B55C # asm("nop");
1070 0002B55C 10 nop
1071 0002B55D # asm("subf _sgl_value_1"); /* sub. the op. (ACC = 0 ) */
1072 0002B55D d6 effffff909 subf _sgl_value_1
1073 0002B563 # asm("nop");
1074 0002B563 10 nop
1075 0002B564 # asm("nop");
1076 0002B564 10 nop
1077 0002B565 # asm("addf _sgl_value_2"); /* add a '0' (ACC = 0 ) */
1078 0002B565 c6 effffff901 addf _sgl_value_2
1079 0002B56B # asm("nop");
1080 0002B56B 10 nop
1081 0002B56C # asm("nop");
1082 0002B56C 10 nop
1083 0002B56D # asm("subf _sgl_value_1"); /* sub. the op. (ACC =-op) */
1084 0002B56D d6 effffff8f9 subf _sgl_value_1
1085 0002B573 # asm("nop");
1086 0002B573 10 nop
1087 0002B574 # asm("nop");
1088 0002B574 10 nop
1089 0002B575 # asm("addf _sgl_value_1"); /* add the op. (ACC = 0 ) */
1090 0002B575 c6 effffff8f1 addf _sgl_value_1
1091 0002B57B # asm("nop");
1092 0002B57B 10 nop
1093 0002B57C # asm("nop");
1094 0002B57C 10 nop
1095 0002B57D # asm("subf _sgl_value_2"); /* sub. a '0' (ACC = 0 ) */
1096 0002B57D d6 effffff8e9 subf _sgl_value_2
1097 0002B583 # asm("nop");
1098 0002B583 10 nop
1099 0002B584 # asm("nop");
1100 0002B584 10 nop
1101 0002B585 # asm("addf _sgl_value_1"); /* add the op. (ACC = op) */
1102 0002B585 c6 effffff8e1 addf _sgl_value_1
1103 0002B58B # asm("nop");
1104 0002B58B 10 nop
1105 0002B58C # asm("nop");
1106 0002B58C 10 nop
1107 0002B58D # asm("subf _sgl_value_1"); /* sub. the op. (ACC = 0 ) */
1108 0002B58D d6 effffff8d9 subf _sgl_value_1
1109 0002B593 # asm("nop");
1110 0002B593 10 nop
1111 0002B594 # asm("nop");
1112 0002B594 10 nop
1113 0002B595 # asm("addf _sgl_value_2"); /* add a '0' (ACC = 0 ) */
1114 0002B595 c6 effffff8d1 addf _sgl_value_2
1115 0002B59B # asm("nop");
1116 0002B59B 10 nop
1117 0002B59C # asm("nop");
1118 0002B59C 10 nop
1119 0002B59D # asm("subf _sgl_value_2"); /* sub. a '0' (ACC = 0 ) */
1120 0002B59D d6 effffff8c9 subf _sgl_value_2
1121 0002B5A3 # asm("nop");
1122 0002B5A3 10 nop
1123 0002B5A4 # asm("nop");
1124 0002B5A4 10 nop
1125 0002B5A5 # asm("addf _sgl_value_1"); /* add the op. (ACC = op) */
1126 0002B5A5 c6 effffff8c1 addf _sgl_value_1
1127 0002B5AB # asm("nop");
1128 0002B5AB 10 nop
1129 0002B5AC # asm("nop");
1130 0002B5AC 10 nop
1131 0002B5AD # asm("stf _sgl_st_acc"); /* store the ACC (s/b= op) */
1132 0002B5AD 26 effffff8b9 stf _sgl_st_acc
1133 0002B5B3 # if( force_loop )
1134 0002B5B3 5d effffff8b3 tstl _force_loop
1135 0002B5B9 31 02 jeql L319
1136 0002B5BB # asm("brb _pipe7_7_lp1");; /* loop on the error */
1137 0002B5BB 11 98 brb _pipe7_7_lp1
1138 0002B5BD L319:
1139 0002B5BD # /*
1140 0002B5BD # * verify the results
1141 0002B5BD # */
1142 0002B5BD # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
1143 0002B5BD 1d effffff8a9 effffff8a4 cmpl _sgl_st_acc,_sgl_expected
1144 0002B5C8 31 45 jeql L320
1145 0002B5CA # {
1146 0002B5CA # errcnt++; /* bump the error count */
1147 0002B5CA 6d effffff89c incl _errcnt
1148 0002B5D0 # if ( prt_error )
1149 0002B5D0 5d effffff896 tstl _prt_error
1150 0002B5D6 31 0d jeql L321
1151 0002B5D8 # print_pipe7_er("Cache Data, 2 NO-OPs");
1152 0002B5D8 .data 1
1153 00000e6b * L322:
1154 00000e6b * 436163686520446174612C203 .ascii "Cache Data, 2 NO-OPs\0"
2204E4F2D4F507300
1155 00000e80 * .text
1156 0002B5D8 dd 8f00000e6b pushl $L322
1157 0002B5DE fe 08 ef000004e7 callf $8,_print_pipe7_er
1158 0002B5E5 # if ( halt_flg )
1159 0002B5E5 L321:
1160 0002B5E5 5d effffff881 tstl _halt_flg
1161 0002B5EB 31 0d jeql L323
1162 0002B5ED # pipe7_er_hlt( subtest );
1163 0002B5ED dd effffff879 pushl _subtest
1164 0002B5F3 fe 08 ef000005ea callf $8,_pipe7_er_hlt
1165 0002B5FA # if ( loop_on_err ) {
1166 0002B5FA L323:
1167 0002B5FA 5d effffff86c tstl _loop_on_err
1168 0002B600 31 0d jeql L324
1169 0002B602 # force_loop = TRUE; /* set the force loop flag */
1170 0002B602 0d 01 effffff863 movl $1,_force_loop
1171 0002B609 # asm("jmp _pipe7_7_lp1"); /* and loop */
1172 0002B609 71 efffffff46 jmp _pipe7_7_lp1
1173 0002B60F # }
1174 0002B60F # } /* end of compare error */
1175 0002B60F L324:
1176 0002B60F # } while( index++ < max_ldf_1_index );
1177 0002B60F L320:
1178 0002B60F L317:
1179 0002B60F 0d effffff857 50 movl _index,r0
1180 0002B616 6d effffff850 incl _index
1181 0002B61C 1d 50 effffff849 cmpl r0,_max_ldf_1_index
1182 0002B623 81 03 13 fefb jlss L318
1183 0002B628 L316:
1184 0002B628 # } /* end of subtest 7 */
1185 0002B628 40 ret#2
1186 0002B629 .set L312,0x0
1187 0002B629 L314:
1188 0002B629 13 feeb jbr L315
1189 0002B62C .data
1190 00000de8 * .text
1191 0002B62C .align 1
1192 0002B62C .globl _pipe7_8
1193 0002B62C _pipe7_8:
1194 0002B62C 0000 .word L325
1195 0002B62E #
1196 0002B62E #
1197 0002B62E #
1198 0002B62E #
1199 0002B62E #
1200 0002B62E #
1201 0002B62E # /************************************************************************
1202 0002B62E # *
1203 0002B62E # * SUBTEST 8
1204 0002B62E # * data in Cache, 3 NO-OPs
1205 0002B62E # *
1206 0002B62E # ************************************************************************/
1207 0002B62E # pipe7_8()
1208 0002B62E # {
1209 0002B62E 13 011d jbr L327
1210 0002B631 L328:
1211 0002B631 # force_loop = FALSE; /* clear force_loop flag */
1212 0002B631 4d effffff835 clrl _force_loop
1213 0002B637 # index = 0;
1214 0002B637 4d effffff82f clrl _index
1215 0002B63D # do
1216 0002B63D L331:
1217 0002B63D # {
1218 0002B63D # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
1219 0002B63D 0d effffff829 50 movl _index,r0
1220 0002B644 48 03 50 50 shll $3,r0,r0
1221 0002B648 0d e000000000 effffff819 movl _ldf_1_data(r0),_sgl_value_1
1222 0002B653 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
1223 0002B653 0d effffff813 50 movl _index,r0
1224 0002B65A 48 03 50 50 shll $3,r0,r0
1225 0002B65E 0d e000000004 effffff803 movl _ldf_1_data+4(r0),_sgl_expected
1226 0002B669 # sgl_value_2 = 0; /* set the '0' operand */
1227 0002B669 4d effffff7fd clrl _sgl_value_2
1228 0002B66F # /*
1229 0002B66F # * If LOOP ON ERROR is set, this is the loop for this subtest.
1230 0002B66F # * The force loop flag is set after the first error.
1231 0002B66F # */
1232 0002B66F # asm("_pipe7_8_lp1:");
1233 0002B66F _pipe7_8_lp1:
1234 0002B66F # asm("ldf _sgl_value_1"); /* load the ACC (ACC = op) */
1235 0002B66F 06 effffff7f7 ldf _sgl_value_1
1236 0002B675 # asm("nop");
1237 0002B675 10 nop
1238 0002B676 # asm("nop");
1239 0002B676 10 nop
1240 0002B677 # asm("nop");
1241 0002B677 10 nop
1242 0002B678 # asm("subf _sgl_value_1"); /* sub. the op. (ACC = 0 ) */
1243 0002B678 d6 effffff7ee subf _sgl_value_1
1244 0002B67E # asm("nop");
1245 0002B67E 10 nop
1246 0002B67F # asm("nop");
1247 0002B67F 10 nop
1248 0002B680 # asm("nop");
1249 0002B680 10 nop
1250 0002B681 # asm("addf _sgl_value_2"); /* add a '0' (ACC = 0 ) */
1251 0002B681 c6 effffff7e5 addf _sgl_value_2
1252 0002B687 # asm("nop");
1253 0002B687 10 nop
1254 0002B688 # asm("nop");
1255 0002B688 10 nop
1256 0002B689 # asm("nop");
1257 0002B689 10 nop
1258 0002B68A # asm("subf _sgl_value_1"); /* sub. the op. (ACC =-op) */
1259 0002B68A d6 effffff7dc subf _sgl_value_1
1260 0002B690 # asm("nop");
1261 0002B690 10 nop
1262 0002B691 # asm("nop");
1263 0002B691 10 nop
1264 0002B692 # asm("nop");
1265 0002B692 10 nop
1266 0002B693 # asm("addf _sgl_value_1"); /* add the op. (ACC = 0 ) */
1267 0002B693 c6 effffff7d3 addf _sgl_value_1
1268 0002B699 # asm("nop");
1269 0002B699 10 nop
1270 0002B69A # asm("nop");
1271 0002B69A 10 nop
1272 0002B69B # asm("nop");
1273 0002B69B 10 nop
1274 0002B69C # asm("subf _sgl_value_2"); /* sub. a '0' (ACC = 0 ) */
1275 0002B69C d6 effffff7ca subf _sgl_value_2
1276 0002B6A2 # asm("nop");
1277 0002B6A2 10 nop
1278 0002B6A3 # asm("nop");
1279 0002B6A3 10 nop
1280 0002B6A4 # asm("nop");
1281 0002B6A4 10 nop
1282 0002B6A5 # asm("addf _sgl_value_1"); /* add the op. (ACC = op) */
1283 0002B6A5 c6 effffff7c1 addf _sgl_value_1
1284 0002B6AB # asm("nop");
1285 0002B6AB 10 nop
1286 0002B6AC # asm("nop");
1287 0002B6AC 10 nop
1288 0002B6AD # asm("nop");
1289 0002B6AD 10 nop
1290 0002B6AE # asm("subf _sgl_value_1"); /* sub. the op. (ACC = 0 ) */
1291 0002B6AE d6 effffff7b8 subf _sgl_value_1
1292 0002B6B4 # asm("nop");
1293 0002B6B4 10 nop
1294 0002B6B5 # asm("nop");
1295 0002B6B5 10 nop
1296 0002B6B6 # asm("nop");
1297 0002B6B6 10 nop
1298 0002B6B7 # asm("addf _sgl_value_2"); /* add a '0' (ACC = 0 ) */
1299 0002B6B7 c6 effffff7af addf _sgl_value_2
1300 0002B6BD # asm("nop");
1301 0002B6BD 10 nop
1302 0002B6BE # asm("nop");
1303 0002B6BE 10 nop
1304 0002B6BF # asm("nop");
1305 0002B6BF 10 nop
1306 0002B6C0 # asm("subf _sgl_value_2"); /* sub. a '0' (ACC = 0 ) */
1307 0002B6C0 d6 effffff7a6 subf _sgl_value_2
1308 0002B6C6 # asm("nop");
1309 0002B6C6 10 nop
1310 0002B6C7 # asm("nop");
1311 0002B6C7 10 nop
1312 0002B6C8 # asm("nop");
1313 0002B6C8 10 nop
1314 0002B6C9 # asm("addf _sgl_value_1"); /* add the op. (ACC = op) */
1315 0002B6C9 c6 effffff79d addf _sgl_value_1
1316 0002B6CF # asm("nop");
1317 0002B6CF 10 nop
1318 0002B6D0 # asm("nop");
1319 0002B6D0 10 nop
1320 0002B6D1 # asm("nop");
1321 0002B6D1 10 nop
1322 0002B6D2 # asm("stf _sgl_st_acc"); /* store the ACC (s/b= op) */
1323 0002B6D2 26 effffff794 stf _sgl_st_acc
1324 0002B6D8 # if( force_loop )
1325 0002B6D8 5d effffff78e tstl _force_loop
1326 0002B6DE 31 02 jeql L332
1327 0002B6E0 # asm("brb _pipe7_8_lp1");; /* loop on the error */
1328 0002B6E0 11 8d brb _pipe7_8_lp1
1329 0002B6E2 L332:
1330 0002B6E2 # /*
1331 0002B6E2 # * verify the results
1332 0002B6E2 # */
1333 0002B6E2 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
1334 0002B6E2 1d effffff784 effffff77f cmpl _sgl_st_acc,_sgl_expected
1335 0002B6ED 31 45 jeql L333
1336 0002B6EF # {
1337 0002B6EF # errcnt++; /* bump the error count */
1338 0002B6EF 6d effffff777 incl _errcnt
1339 0002B6F5 # if ( prt_error )
1340 0002B6F5 5d effffff771 tstl _prt_error
1341 0002B6FB 31 0d jeql L334
1342 0002B6FD # print_pipe7_er("Cache Data, 3 NO-OPs");
1343 0002B6FD .data 1
1344 00000e80 * L335:
1345 00000e80 * 436163686520446174612C203 .ascii "Cache Data, 3 NO-OPs\0"
3204E4F2D4F507300
1346 00000e95 * .text
1347 0002B6FD dd 8f00000e80 pushl $L335
1348 0002B703 fe 08 ef000003c2 callf $8,_print_pipe7_er
1349 0002B70A # if ( halt_flg )
1350 0002B70A L334:
1351 0002B70A 5d effffff75c tstl _halt_flg
1352 0002B710 31 0d jeql L336
1353 0002B712 # pipe7_er_hlt( subtest );
1354 0002B712 dd effffff754 pushl _subtest
1355 0002B718 fe 08 ef000004c5 callf $8,_pipe7_er_hlt
1356 0002B71F # if ( loop_on_err ) {
1357 0002B71F L336:
1358 0002B71F 5d effffff747 tstl _loop_on_err
1359 0002B725 31 0d jeql L337
1360 0002B727 # force_loop = TRUE; /* set the force loop flag */
1361 0002B727 0d 01 effffff73e movl $1,_force_loop
1362 0002B72E # asm("jmp _pipe7_8_lp1"); /* and loop */
1363 0002B72E 71 efffffff3b jmp _pipe7_8_lp1
1364 0002B734 # }
1365 0002B734 # } /* end of compare error */
1366 0002B734 L337:
1367 0002B734 # } while( index++ < max_ldf_1_index );
1368 0002B734 L333:
1369 0002B734 L330:
1370 0002B734 0d effffff732 50 movl _index,r0
1371 0002B73B 6d effffff72b incl _index
1372 0002B741 1d 50 effffff724 cmpl r0,_max_ldf_1_index
1373 0002B748 81 03 13 fef0 jlss L331
1374 0002B74D L329:
1375 0002B74D # } /* end of subtest 8 */
1376 0002B74D 40 ret#2
1377 0002B74E .set L325,0x0
1378 0002B74E L327:
1379 0002B74E 13 fee0 jbr L328
1380 0002B751 .data
1381 00000de8 * .text
1382 0002B751 00 .align 1
1383 0002B752 .globl _pipe7_9
1384 0002B752 _pipe7_9:
1385 0002B752 0000 .word L338
1386 0002B754 #
1387 0002B754 #
1388 0002B754 #
1389 0002B754 #
1390 0002B754 #
1391 0002B754 #
1392 0002B754 # /*****************************************************************************
1393 0002B754 # *
1394 0002B754 # * SUBTEST 9
1395 0002B754 # * data on the stack, no NO-OPs
1396 0002B754 # *
1397 0002B754 # *****************************************************************************/
1398 0002B754 # pipe7_9()
1399 0002B754 # {
1400 0002B754 13 01b4 jbr L340
1401 0002B757 L341:
1402 0002B757 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
1403 0002B757 ed 6d effffff70e moval (r13),_pre_event_fp
1404 0002B75E # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
1405 0002B75E ed 6e effffff707 moval (r14),_pre_event_sp
1406 0002B765 # force_loop = FALSE; /* clear force_loop flag */
1407 0002B765 4d effffff701 clrl _force_loop
1408 0002B76B # index = 0;
1409 0002B76B 4d effffff6fb clrl _index
1410 0002B771 # do
1411 0002B771 L344:
1412 0002B771 # {
1413 0002B771 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
1414 0002B771 0d effffff6f5 50 movl _index,r0
1415 0002B778 48 03 50 50 shll $3,r0,r0
1416 0002B77C 0d e000000000 effffff6e5 movl _ldf_1_data(r0),_sgl_value_1
1417 0002B787 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
1418 0002B787 0d effffff6df 50 movl _index,r0
1419 0002B78E 48 03 50 50 shll $3,r0,r0
1420 0002B792 0d e000000004 effffff6cf movl _ldf_1_data+4(r0),_sgl_expected
1421 0002B79D # sgl_value_4 = 0; /* set the '0' operand */
1422 0002B79D 4d effffff6c9 clrl _sgl_value_4
1423 0002B7A3 # asm("moval _pointer_data,_sgl_value_2");/* init / final SP value */
1424 0002B7A3 ed effffff6c3 effffff6be moval _pointer_data,_sgl_value_2
1425 0002B7AE # /*
1426 0002B7AE # * If LOOP ON ERROR is set, this is the loop for this subtest.
1427 0002B7AE # * The force loop flag is set after the first error.
1428 0002B7AE # */
1429 0002B7AE # asm("_pipe7_9_lp1:");
1430 0002B7AE _pipe7_9_lp1:
1431 0002B7AE # asm("moval _pointer_data,r14"); /* set the stack pointer */
1432 0002B7AE ed effffff6b8 5e moval _pointer_data,r14
1433 0002B7B5 # asm("movl _sgl_value_1,-(r14)"); /* push operand to add */
1434 0002B7B5 0d effffff6b1 7e movl _sgl_value_1,-(r14)
1435 0002B7BC # asm("movl _sgl_value_4,-(r14)"); /* '0' to subtract */
1436 0002B7BC 0d effffff6aa 7e movl _sgl_value_4,-(r14)
1437 0002B7C3 # asm("movl _sgl_value_4,-(r14)"); /* '0' to add */
1438 0002B7C3 0d effffff6a3 7e movl _sgl_value_4,-(r14)
1439 0002B7CA # asm("movl _sgl_value_1,-(r14)"); /* op. to subtract */
1440 0002B7CA 0d effffff69c 7e movl _sgl_value_1,-(r14)
1441 0002B7D1 # asm("movl _sgl_value_1,-(r14)"); /* op. to add */
1442 0002B7D1 0d effffff695 7e movl _sgl_value_1,-(r14)
1443 0002B7D8 # asm("movl _sgl_value_4,-(r14)"); /* '0' to subtract */
1444 0002B7D8 0d effffff68e 7e movl _sgl_value_4,-(r14)
1445 0002B7DF # asm("movl _sgl_value_1,-(r14)"); /* op. to add */
1446 0002B7DF 0d effffff687 7e movl _sgl_value_1,-(r14)
1447 0002B7E6 # asm("movl _sgl_value_1,-(r14)"); /* op. to subtract */
1448 0002B7E6 0d effffff680 7e movl _sgl_value_1,-(r14)
1449 0002B7ED # asm("movl _sgl_value_4,-(r14)"); /* '0' to add */
1450 0002B7ED 0d effffff679 7e movl _sgl_value_4,-(r14)
1451 0002B7F4 # asm("movl _sgl_value_1,-(r14)"); /* op. to subtract */
1452 0002B7F4 0d effffff672 7e movl _sgl_value_1,-(r14)
1453 0002B7FB # asm("movl _sgl_value_1,-(r14)"); /* op. to load */
1454 0002B7FB 0d effffff66b 7e movl _sgl_value_1,-(r14)
1455 0002B802 # /*
1456 0002B802 # * now pop the data off the stack
1457 0002B802 # */
1458 0002B802 # asm("ldf (r14)+"); /* pop the data & load it */
1459 0002B802 06 8e ldf (r14)+
1460 0002B804 # asm("subf (r14)+"); /* sub. the op. (ACC = 0 ) */
1461 0002B804 d6 8e subf (r14)+
1462 0002B806 # asm("addf (r14)+"); /* add a '0' (ACC = 0 ) */
1463 0002B806 c6 8e addf (r14)+
1464 0002B808 # asm("subf (r14)+"); /* sub. the op. (ACC =-op) */
1465 0002B808 d6 8e subf (r14)+
1466 0002B80A # asm("addf (r14)+"); /* add the op. (ACC = 0 ) */
1467 0002B80A c6 8e addf (r14)+
1468 0002B80C # asm("subf (r14)+"); /* sub. a '0' (ACC = 0 ) */
1469 0002B80C d6 8e subf (r14)+
1470 0002B80E # asm("addf (r14)+"); /* add the op. (ACC = op) */
1471 0002B80E c6 8e addf (r14)+
1472 0002B810 # asm("subf (r14)+"); /* sub. the op. (ACC = 0 ) */
1473 0002B810 d6 8e subf (r14)+
1474 0002B812 # asm("addf (r14)+"); /* add a '0' (ACC = 0 ) */
1475 0002B812 c6 8e addf (r14)+
1476 0002B814 # asm("subf (r14)+"); /* sub. a '0' (ACC = 0 ) */
1477 0002B814 d6 8e subf (r14)+
1478 0002B816 # asm("addf (r14)+"); /* add the op. (ACC = op) */
1479 0002B816 c6 8e addf (r14)+
1480 0002B818 # asm("stf r5"); /* store the ACC (s/b= op) */
1481 0002B818 26 55 stf r5
1482 0002B81A # if( force_loop )
1483 0002B81A 5d effffff64c tstl _force_loop
1484 0002B820 31 02 jeql L345
1485 0002B822 # asm("brb _pipe7_9_lp1");; /* loop on the error */
1486 0002B822 11 8a brb _pipe7_9_lp1
1487 0002B824 L345:
1488 0002B824 # /*
1489 0002B824 # * verify the results
1490 0002B824 # */
1491 0002B824 # asm("movl r5,_sgl_st_acc"); /* get the result */
1492 0002B824 0d 55 effffff641 movl r5,_sgl_st_acc
1493 0002B82B # asm("moval (r14),_sgl_value_3"); /* save the stack pointer */
1494 0002B82B ed 6e effffff63a moval (r14),_sgl_value_3
1495 0002B832 # if( (sgl_st_acc != sgl_expected) || /* verify the result... */
1496 0002B832 # (sgl_value_3 != sgl_value_2) ) /* ... and the final SP */
1497 0002B832 1d effffff634 effffff62f cmpl _sgl_st_acc,_sgl_expected
1498 0002B83D 21 10 jneq L9999
1499 0002B83F 1d effffff627 effffff622 cmpl _sgl_value_3,_sgl_value_2
1500 0002B84A 21 03 13 0094 jeql L346
1501 0002B84F L9999:
1502 0002B84F # {
1503 0002B84F # asm("movl _pre_event_fp,r13"); /* restore frame pointer */
1504 0002B84F 0d effffff617 5d movl _pre_event_fp,r13
1505 0002B856 # asm("movl _pre_event_sp,r14"); /* restore stack pointer */
1506 0002B856 0d effffff610 5e movl _pre_event_sp,r14
1507 0002B85D # errcnt++; /* bump the error count */
1508 0002B85D 6d effffff609 incl _errcnt
1509 0002B863 # if ( prt_error ) {
1510 0002B863 5d effffff603 tstl _prt_error
1511 0002B869 31 4e jeql L347
1512 0002B86B # print_pipe7_er("POP data from the STACK");
1513 0002B86B .data 1
1514 00000e95 * L348:
1515 00000e95 * 504F5020646174612066726F6 .ascii "POP data from the STACK\0"
D2074686520535441434B00
1516 00000ead * .text
1517 0002B86B dd 8f00000e95 pushl $L348
1518 0002B871 fe 08 ef00000254 callf $8,_print_pipe7_er
1519 0002B878 # writes("final Stack Pointer = ");
1520 0002B878 .data 1
1521 00000ead * L349:
1522 00000ead * 66696E616C20537461636B205 .ascii "final Stack Pointer = \0"
06F696E746572203D2000
1523 00000ec4 * .text
1524 0002B878 dd 8f00000ead pushl $L349
1525 0002B87E fe 08 effffff5e7 callf $8,_writes
1526 0002B885 # write32h( sgl_value_5 );
1527 0002B885 dd effffff5e1 pushl _sgl_value_5
1528 0002B88B fe 08 effffff5da callf $8,_write32h
1529 0002B892 # writes(", expected SP = ");
1530 0002B892 .data 1
1531 00000ec4 * L351:
1532 00000ec4 * 2C20206578706563746564205 .ascii ", expected SP = \0"
350203D2000
1533 00000ed6 * .text
1534 0002B892 dd 8f00000ec4 pushl $L351
1535 0002B898 fe 08 effffff5cd callf $8,_writes
1536 0002B89F # write32h( sgl_value_4 );
1537 0002B89F dd effffff5c7 pushl _sgl_value_4
1538 0002B8A5 fe 08 effffff5c0 callf $8,_write32h
1539 0002B8AC # writes("\n");
1540 0002B8AC .data 1
1541 00000ed6 * L352:
1542 00000ed6 * 0A00 .ascii "\12\0"
1543 00000ed8 * .text
1544 0002B8AC dd 8f00000ed6 pushl $L352
1545 0002B8B2 fe 08 effffff5b3 callf $8,_writes
1546 0002B8B9 # }
1547 0002B8B9 # if ( halt_flg ) /* halt on error? */
1548 0002B8B9 L347:
1549 0002B8B9 5d effffff5ad tstl _halt_flg
1550 0002B8BF 31 0d jeql L353
1551 0002B8C1 # pipe7_er_hlt( subtest );
1552 0002B8C1 dd effffff5a5 pushl _subtest
1553 0002B8C7 fe 08 ef00000316 callf $8,_pipe7_er_hlt
1554 0002B8CE # if ( loop_on_err ) {
1555 0002B8CE L353:
1556 0002B8CE 5d effffff598 tstl _loop_on_err
1557 0002B8D4 31 0d jeql L354
1558 0002B8D6 # force_loop = TRUE; /* set the force loop flag */
1559 0002B8D6 0d 01 effffff58f movl $1,_force_loop
1560 0002B8DD # asm("jmp _pipe7_9_lp1"); /* and loop */
1561 0002B8DD 71 effffffecb jmp _pipe7_9_lp1
1562 0002B8E3 # }
1563 0002B8E3 # } /* end of compare error */
1564 0002B8E3 L354:
1565 0002B8E3 # } while( index++ < max_ldf_1_index );
1566 0002B8E3 L346:
1567 0002B8E3 L343:
1568 0002B8E3 0d effffff583 50 movl _index,r0
1569 0002B8EA 6d effffff57c incl _index
1570 0002B8F0 1d 50 effffff575 cmpl r0,_max_ldf_1_index
1571 0002B8F7 81 03 13 fe75 jlss L344
1572 0002B8FC L342:
1573 0002B8FC # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */
1574 0002B8FC 0d effffff56a 5d movl _pre_event_fp,r13
1575 0002B903 # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */
1576 0002B903 0d effffff563 5e movl _pre_event_sp,r14
1577 0002B90A # } /* end of subtest 9 */
1578 0002B90A 40 ret#2
1579 0002B90B .set L338,0x0
1580 0002B90B L340:
1581 0002B90B 13 fe49 jbr L341
1582 0002B90E .data
1583 00000de8 * .text
1584 0002B90E .align 1
1585 0002B90E .globl _pipe7_10
1586 0002B90E _pipe7_10:
1587 0002B90E 0000 .word L355
1588 0002B910 #
1589 0002B910 #
1590 0002B910 #
1591 0002B910 #
1592 0002B910 #
1593 0002B910 #
1594 0002B910 # /******************************************************************************
1595 0002B910 # *
1596 0002B910 # * SUBTEST 10
1597 0002B910 # * load 0, add operand 4 times -get data via indexed FRAME pointer
1598 0002B910 # *
1599 0002B910 # * ADDR INDEX DATA
1600 0002B910 # * pointer_data 4 <the STF result goes here>
1601 0002B910 # * pointer_data-4 3 <operand data>
1602 0002B910 # * pointer_data-8 2 <'0' data>
1603 0002B910 # * pointer_data-16 0 point the frame pointer here
1604 0002B910 # *
1605 0002B910 # ******************************************************************************/
1606 0002B910 # pipe7_10()
1607 0002B910 # {
1608 0002B910 13 01b6 jbr L357
1609 0002B913 L358:
1610 0002B913 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
1611 0002B913 ed 6d effffff552 moval (r13),_pre_event_fp
1612 0002B91A # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
1613 0002B91A ed 6e effffff54b moval (r14),_pre_event_sp
1614 0002B921 # force_loop = FALSE; /* clear force_loop flag */
1615 0002B921 4d effffff545 clrl _force_loop
1616 0002B927 # index = 0;
1617 0002B927 4d effffff53f clrl _index
1618 0002B92D # do
1619 0002B92D L361:
1620 0002B92D # {
1621 0002B92D # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
1622 0002B92D 0d effffff539 50 movl _index,r0
1623 0002B934 48 03 50 50 shll $3,r0,r0
1624 0002B938 0d e000000000 effffff529 movl _ldf_1_data(r0),_sgl_value_1
1625 0002B943 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
1626 0002B943 0d effffff523 50 movl _index,r0
1627 0002B94A 48 03 50 50 shll $3,r0,r0
1628 0002B94E 0d e000000004 effffff513 movl _ldf_1_data+4(r0),_sgl_expected
1629 0002B959 # sgl_value_4 = 0; /* set the '0' operand */
1630 0002B959 4d effffff50d clrl _sgl_value_4
1631 0002B95F # asm("moval _pointer_data,_sgl_value_2");/* init / final SP value */
1632 0002B95F ed effffff507 effffff502 moval _pointer_data,_sgl_value_2
1633 0002B96A # /*
1634 0002B96A # * If LOOP ON ERROR is set, this is the loop for this subtest.
1635 0002B96A # * The force loop flag is set after the first error.
1636 0002B96A # */
1637 0002B96A # asm("_pipe7_10_lp1:");
1638 0002B96A _pipe7_10_lp1:
1639 0002B96A # asm("moval _pointer_data,_sgl_value_2");/* get store data's addr */
1640 0002B96A ed effffff4fc effffff4f7 moval _pointer_data,_sgl_value_2
1641 0002B975 # sgl_value_2 -= 4; /* decrement it by 4 (bytes)*/
1642 0002B975 2c 04 effffff4f0 subl2 $4,_sgl_value_2
1643 0002B97C # asm("movl _sgl_value_1,*_sgl_value_2");/* set the operand data */
1644 0002B97C 0d effffff4ea fffffff4e5 movl _sgl_value_1,*_sgl_value_2
1645 0002B987 # sgl_value_2 -= 4; /* decrement it by 4 (bytes)*/
1646 0002B987 2c 04 effffff4de subl2 $4,_sgl_value_2
1647 0002B98E # asm("movl _sgl_value_4,*_sgl_value_2");/* set the '0' data */
1648 0002B98E 0d effffff4d8 fffffff4d3 movl _sgl_value_4,*_sgl_value_2
1649 0002B999 # sgl_value_2 -= 8; /* get the FP addr to use */
1650 0002B999 2c 08 effffff4cc subl2 $8,_sgl_value_2
1651 0002B9A0 # asm("movl _sgl_value_2,r13"); /* set the FRAME POINTER */
1652 0002B9A0 0d effffff4c6 5d movl _sgl_value_2,r13
1653 0002B9A7 # asm("movl $2,r2"); /* r2 index = 2 longwords */
1654 0002B9A7 0d 02 52 movl $2,r2
1655 0002B9AA # asm("movl $3,r5"); /* r5 index = 3 longwords */
1656 0002B9AA 0d 03 55 movl $3,r5
1657 0002B9AD # asm("movl $4,r6"); /* r6 index = 4 longwords */
1658 0002B9AD 0d 04 56 movl $4,r6
1659 0002B9B0 # asm("ldf (r13)[r5]"); /* load the operand via SP */
1660 0002B9B0 06 456d ldf (r13)[r5]
1661 0002B9B3 # asm("subf (r13)[r5]"); /* sub. the op. (ACC = 0 ) */
1662 0002B9B3 d6 456d subf (r13)[r5]
1663 0002B9B6 # asm("addf (r13)[r2]"); /* add a '0' (ACC = 0 ) */
1664 0002B9B6 c6 426d addf (r13)[r2]
1665 0002B9B9 # asm("subf (r13)[r5]"); /* sub. the op. (ACC =-op) */
1666 0002B9B9 d6 456d subf (r13)[r5]
1667 0002B9BC # asm("addf (r13)[r5]"); /* add the op. (ACC = 0 ) */
1668 0002B9BC c6 456d addf (r13)[r5]
1669 0002B9BF # asm("subf (r13)[r2]"); /* sub. a '0' (ACC = 0 ) */
1670 0002B9BF d6 426d subf (r13)[r2]
1671 0002B9C2 # asm("addf (r13)[r5]"); /* add the op. (ACC = op) */
1672 0002B9C2 c6 456d addf (r13)[r5]
1673 0002B9C5 # asm("subf (r13)[r5]"); /* sub. the op. (ACC = 0 ) */
1674 0002B9C5 d6 456d subf (r13)[r5]
1675 0002B9C8 # asm("addf (r13)[r2]"); /* add a '0' (ACC = 0 ) */
1676 0002B9C8 c6 426d addf (r13)[r2]
1677 0002B9CB # asm("subf (r13)[r2]"); /* sub. a '0' (ACC = 0 ) */
1678 0002B9CB d6 426d subf (r13)[r2]
1679 0002B9CE # asm("addf (r13)[r5]"); /* add the op. (ACC = op) */
1680 0002B9CE c6 456d addf (r13)[r5]
1681 0002B9D1 # asm("stf (r13)[r6]"); /* store -indexed by r6 */
1682 0002B9D1 26 466d stf (r13)[r6]
1683 0002B9D4 # if( force_loop )
1684 0002B9D4 5d effffff492 tstl _force_loop
1685 0002B9DA 31 02 jeql L362
1686 0002B9DC # asm("brb _pipe7_10_lp1");; /* loop on the error */
1687 0002B9DC 11 8c brb _pipe7_10_lp1
1688 0002B9DE L362:
1689 0002B9DE # /*
1690 0002B9DE # * verify the results
1691 0002B9DE # */
1692 0002B9DE # sgl_st_acc = pointer_data; /* move the stored result */
1693 0002B9DE 0d effffff488 effffff483 movl _pointer_data,_sgl_st_acc
1694 0002B9E9 # asm("moval (r13),_sgl_value_3"); /* save the frame pointer */
1695 0002B9E9 ed 6d effffff47c moval (r13),_sgl_value_3
1696 0002B9F0 # if( (sgl_st_acc != sgl_expected) || /* verify the result... */
1697 0002B9F0 # (sgl_value_3 != sgl_value_2) ) /* ... and the final FP */
1698 0002B9F0 1d effffff476 effffff471 cmpl _sgl_st_acc,_sgl_expected
1699 0002B9FB 21 10 jneq L9998
1700 0002B9FD 1d effffff469 effffff464 cmpl _sgl_value_3,_sgl_value_2
1701 0002BA08 21 03 13 0094 jeql L363
1702 0002BA0D L9998:
1703 0002BA0D # {
1704 0002BA0D # asm("movl _pre_event_fp,r13"); /* restore frame pointer */
1705 0002BA0D 0d effffff459 5d movl _pre_event_fp,r13
1706 0002BA14 # asm("movl _pre_event_sp,r14"); /* restore stack pointer */
1707 0002BA14 0d effffff452 5e movl _pre_event_sp,r14
1708 0002BA1B # errcnt++; /* bump the error count */
1709 0002BA1B 6d effffff44b incl _errcnt
1710 0002BA21 # if ( prt_error ) {
1711 0002BA21 5d effffff445 tstl _prt_error
1712 0002BA27 31 4e jeql L364
1713 0002BA29 # print_pipe7_er("indexed FP addressing");
1714 0002BA29 .data 1
1715 00000ed8 * L365:
1716 00000ed8 * 696E646578656420465020616 .ascii "indexed FP addressing\0"
46472657373696E6700
1717 00000eee * .text
1718 0002BA29 dd 8f00000ed8 pushl $L365
1719 0002BA2F fe 08 ef00000096 callf $8,_print_pipe7_er
1720 0002BA36 # writes("final Frame Pointer = ");
1721 0002BA36 .data 1
1722 00000eee * L366:
1723 00000eee * 66696E616C204672616D65205 .ascii "final Frame Pointer = \0"
06F696E746572203D2000
1724 00000f05 * .text
1725 0002BA36 dd 8f00000eee pushl $L366
1726 0002BA3C fe 08 effffff429 callf $8,_writes
1727 0002BA43 # writeh( sgl_value_5 );
1728 0002BA43 dd effffff423 pushl _sgl_value_5
1729 0002BA49 fe 08 effffff41c callf $8,_writeh
1730 0002BA50 # writes(", expected FP = ");
1731 0002BA50 .data 1
1732 00000f05 * L368:
1733 00000f05 * 2C20206578706563746564204 .ascii ", expected FP = \0"
650203D2000
1734 00000f17 * .text
1735 0002BA50 dd 8f00000f05 pushl $L368
1736 0002BA56 fe 08 effffff40f callf $8,_writes
1737 0002BA5D # writeh( sgl_value_4 );
1738 0002BA5D dd effffff409 pushl _sgl_value_4
1739 0002BA63 fe 08 effffff402 callf $8,_writeh
1740 0002BA6A # writes("\n");
1741 0002BA6A .data 1
1742 00000f17 * L369:
1743 00000f17 * 0A00 .ascii "\12\0"
1744 00000f19 * .text
1745 0002BA6A dd 8f00000f17 pushl $L369
1746 0002BA70 fe 08 effffff3f5 callf $8,_writes
1747 0002BA77 # }
1748 0002BA77 # if ( halt_flg ) /* halt on error? */
1749 0002BA77 L364:
1750 0002BA77 5d effffff3ef tstl _halt_flg
1751 0002BA7D 31 0d jeql L370
1752 0002BA7F # pipe7_er_hlt( subtest );
1753 0002BA7F dd effffff3e7 pushl _subtest
1754 0002BA85 fe 08 ef00000158 callf $8,_pipe7_er_hlt
1755 0002BA8C # if ( loop_on_err ) {
1756 0002BA8C L370:
1757 0002BA8C 5d effffff3da tstl _loop_on_err
1758 0002BA92 31 0d jeql L371
1759 0002BA94 # force_loop = TRUE; /* set the force loop flag */
1760 0002BA94 0d 01 effffff3d1 movl $1,_force_loop
1761 0002BA9B # asm("jmp _pipe7_10_lp1"); /* and loop */
1762 0002BA9B 71 effffffec9 jmp _pipe7_10_lp1
1763 0002BAA1 # }
1764 0002BAA1 # } /* end of compare error */
1765 0002BAA1 L371:
1766 0002BAA1 # } while( index++ < max_ldf_1_index );
1767 0002BAA1 L363:
1768 0002BAA1 L360:
1769 0002BAA1 0d effffff3c5 50 movl _index,r0
1770 0002BAA8 6d effffff3be incl _index
1771 0002BAAE 1d 50 effffff3b7 cmpl r0,_max_ldf_1_index
1772 0002BAB5 81 03 13 fe73 jlss L361
1773 0002BABA L359:
1774 0002BABA # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */
1775 0002BABA 0d effffff3ac 5d movl _pre_event_fp,r13
1776 0002BAC1 # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */
1777 0002BAC1 0d effffff3a5 5e movl _pre_event_sp,r14
1778 0002BAC8 # } /* end of subtest 10 */
1779 0002BAC8 40 ret#2
1780 0002BAC9 .set L355,0x0
1781 0002BAC9 L357:
1782 0002BAC9 13 fe47 jbr L358
1783 0002BACC .data
1784 00000de8 * .text
1785 0002BACC .align 1
1786 0002BACC .globl _print_pipe7_er
1787 0002BACC _print_pipe7_er:
1788 0002BACC 0000 .word L372
1789 0002BACE #
1790 0002BACE #
1791 0002BACE # /******************************************************************************
1792 0002BACE # *
1793 0002BACE # * ERROR ROUTINE
1794 0002BACE # *
1795 0002BACE # * print an error in the following form
1796 0002BACE # *
1797 0002BACE # * operand = xxxxxxxx, final Acc = xxxxxxxx, data index = dd
1798 0002BACE # * expected Acc = xxxxxxxx
1799 0002BACE # *
1800 0002BACE # ******************************************************************************/
1801 0002BACE # print_pipe7_er(msg)
1802 0002BACE # char *msg;
1803 0002BACE # {
1804 0002BACE 13 0110 jbr L374
1805 0002BAD1 L375:
1806 0002BAD1 # writes("\n"); /* start a new print line */
1807 0002BAD1 .data 1
1808 00000f19 * L376:
1809 00000f19 * 0A00 .ascii "\12\0"
1810 00000f1b * .text
1811 0002BAD1 dd 8f00000f19 pushl $L376
1812 0002BAD7 fe 08 effffff38e callf $8,_writes
1813 0002BADE # writes("cycle: ");
1814 0002BADE .data 1
1815 00000f1b * L377:
1816 00000f1b * 6379636C653A2000 .ascii "cycle: \0"
1817 00000f23 * .text
1818 0002BADE dd 8f00000f1b pushl $L377
1819 0002BAE4 fe 08 effffff381 callf $8,_writes
1820 0002BAEB # writed( cycle );
1821 0002BAEB dd effffff37b pushl _cycle
1822 0002BAF1 fe 08 effffff374 callf $8,_writed
1823 0002BAF8 # writes(" test ");
1824 0002BAF8 .data 1
1825 00000f23 * L379:
1826 00000f23 * 20746573742000 .ascii " test \0"
1827 00000f2a * .text
1828 0002BAF8 dd 8f00000f23 pushl $L379
1829 0002BAFE fe 08 effffff367 callf $8,_writes
1830 0002BB05 # writed( test_no );
1831 0002BB05 dd effffff361 pushl _test_no
1832 0002BB0B fe 08 effffff35a callf $8,_writed
1833 0002BB12 # writes(" (Pipe 7), subtest ");
1834 0002BB12 .data 1
1835 00000f2a * L380:
1836 00000f2a * 202028506970652037292C207 .ascii " (Pipe 7), subtest \0"
37562746573742000
1837 00000f3f * .text
1838 0002BB12 dd 8f00000f2a pushl $L380
1839 0002BB18 fe 08 effffff34d callf $8,_writes
1840 0002BB1F # writed( subtest );
1841 0002BB1F dd effffff347 pushl _subtest
1842 0002BB25 fe 08 effffff340 callf $8,_writed
1843 0002BB2C # writes(" error - ");
1844 0002BB2C .data 1
1845 00000f3f * L381:
1846 00000f3f * 206572726F72202D2000 .ascii " error - \0"
1847 00000f49 * .text
1848 0002BB2C dd 8f00000f3f pushl $L381
1849 0002BB32 fe 08 effffff333 callf $8,_writes
1850 0002BB39 # writes( msg );
1851 0002BB39 dd ad04 pushl 4(fp)
1852 0002BB3C fe 08 effffff329 callf $8,_writes
1853 0002BB43 # writec('\n');
1854 0002BB43 dd 0a pushl $10
1855 0002BB45 fe 08 effffff320 callf $8,_writec
1856 0002BB4C # writes(
1857 0002BB4C # "LDF(op), SUBF(op), ADDF(0.0), SUBF(op), ADDF(op), SUBF(0.0),\n");
1858 0002BB4C .data 1
1859 00000f49 * L383:
1860 00000f49 * 4C4446286F70292C205355424 .ascii "LDF(op), SUBF(op), ADDF(0.0), SUBF(op), ADDF(op), SUBF(0.0),\12\0"
6286F70292C20414444462830
2E30292C2053554246286F702
92C202041444446286F70292C
20205355424628302E30292C0
A00
1861 00000f89 * .text
1862 0002BB4C dd 8f00000f49 pushl $L383
1863 0002BB52 fe 08 effffff313 callf $8,_writes
1864 0002BB59 # writes(
1865 0002BB59 # " ADDF(op), SUBF(op), ADDF(0.0), SUBF(0.0), ADDF(op), STF\n");
1866 0002BB59 .data 1
1867 00000f89 * L384:
1868 00000f89 * 2020202020202020204144444 .ascii " ADDF(op), SUBF(op), ADDF(0.0), SUBF(0.0), ADDF(op), S"
6286F70292C2053554246286F
70292C20204144444628302E3
0292C205355424628302E3029
2C2041444446286F70292C202
053
1869 00000fc9 * 54460A00 .ascii "TF\12\0"
1870 00000fcd * .text
1871 0002BB59 dd 8f00000f89 pushl $L384
1872 0002BB5F fe 08 effffff306 callf $8,_writes
1873 0002BB66 # writes("operand = ");
1874 0002BB66 .data 1
1875 00000fcd * L385:
1876 00000fcd * 6F706572616E64203D2000 .ascii "operand = \0"
1877 00000fd8 * .text
1878 0002BB66 dd 8f00000fcd pushl $L385
1879 0002BB6C fe 08 effffff2f9 callf $8,_writes
1880 0002BB73 # write32h( sgl_value_1 );
1881 0002BB73 dd effffff2f3 pushl _sgl_value_1
1882 0002BB79 fe 08 effffff2ec callf $8,_write32h
1883 0002BB80 # writes(", final Acc = ");
1884 0002BB80 .data 1
1885 00000fd8 * L386:
1886 00000fd8 * 2C20202066696E616C2041636 .ascii ", final Acc = \0"
3203D2000
1887 00000fe9 * .text
1888 0002BB80 dd 8f00000fd8 pushl $L386
1889 0002BB86 fe 08 effffff2df callf $8,_writes
1890 0002BB8D # write32h( sgl_st_acc );
1891 0002BB8D dd effffff2d9 pushl _sgl_st_acc
1892 0002BB93 fe 08 effffff2d2 callf $8,_write32h
1893 0002BB9A # writes(", data index = ");
1894 0002BB9A .data 1
1895 00000fe9 * L387:
1896 00000fe9 * 2C2020206461746120696E646 .ascii ", data index = \0"
578203D2000
1897 00000ffb * .text
1898 0002BB9A dd 8f00000fe9 pushl $L387
1899 0002BBA0 fe 08 effffff2c5 callf $8,_writes
1900 0002BBA7 # writed( index );
1901 0002BBA7 dd effffff2bf pushl _index
1902 0002BBAD fe 08 effffff2b8 callf $8,_writed
1903 0002BBB4 # writec('\n');
1904 0002BBB4 dd 0a pushl $10
1905 0002BBB6 fe 08 effffff2af callf $8,_writec
1906 0002BBBD # writes(" expected Acc = ");
1907 0002BBBD .data 1
1908 00000ffb * L388:
1909 00000ffb * 2020202020202020202020202 .ascii " expected Acc = \0"
0202020202020657870656374
656420416363203D2000
1910 0000101e * .text
1911 0002BBBD dd 8f00000ffb pushl $L388
1912 0002BBC3 fe 08 effffff2a2 callf $8,_writes
1913 0002BBCA # write32h( sgl_expected );
1914 0002BBCA dd effffff29c pushl _sgl_expected
1915 0002BBD0 fe 08 effffff295 callf $8,_write32h
1916 0002BBD7 # writec('\n');
1917 0002BBD7 dd 0a pushl $10
1918 0002BBD9 fe 08 effffff28c callf $8,_writec
1919 0002BBE0 # }
1920 0002BBE0 40 ret#2
1921 0002BBE1 .set L372,0x0
1922 0002BBE1 L374:
1923 0002BBE1 13 feed jbr L375
1924 0002BBE4 .data
1925 00000de8 * .text
1926 0002BBE4 .align 1
1927 0002BBE4 .globl _pipe7_er_hlt
1928 0002BBE4 _pipe7_er_hlt:
1929 0002BBE4 0000 .word L389
1930 0002BBE6 #
1931 0002BBE6 #
1932 0002BBE6 #
1933 0002BBE6 #
1934 0002BBE6 #
1935 0002BBE6 # /******************************************************************************
1936 0002BBE6 # *
1937 0002BBE6 # * HALT ON ERROR ROUTINE
1938 0002BBE6 # *
1939 0002BBE6 # * halt with the necessary information saved in the registers
1940 0002BBE6 # *
1941 0002BBE6 # ******************************************************************************/
1942 0002BBE6 # pipe7_er_hlt( subtest )
1943 0002BBE6 # int subtest;
1944 0002BBE6 # {
1945 0002BBE6 11 67 jbr L391
1946 0002BBE8 L392:
1947 0002BBE8 # asm("movl _test_no,r0"); /* r0 = test number */
1948 0002BBE8 0d effffff27e 50 movl _test_no,r0
1949 0002BBEF # asm("movl _subtest,r1"); /* r1 = subtest number */
1950 0002BBEF 0d effffff277 51 movl _subtest,r1
1951 0002BBF6 # asm("movl $1,r2"); /* r2 = error code */
1952 0002BBF6 0d 01 52 movl $1,r2
1953 0002BBF9 # asm("movl _cycle,r3"); /* r3 = cycle count */
1954 0002BBF9 0d effffff26d 53 movl _cycle,r3
1955 0002BC00 # asm("movl _sgl_value_1,r4"); /* r4 = sgl operand */
1956 0002BC00 0d effffff266 54 movl _sgl_value_1,r4
1957 0002BC07 # asm("movl _sgl_st_acc,r5"); /* r5 = sgl stored */
1958 0002BC07 0d effffff25f 55 movl _sgl_st_acc,r5
1959 0002BC0E # asm("movl _sgl_expected,r6"); /* r6 = sgl expected */
1960 0002BC0E 0d effffff258 56 movl _sgl_expected,r6
1961 0002BC15 # asm("movl _index,r7"); /* r7 = data index */
1962 0002BC15 0d effffff251 57 movl _index,r7
1963 0002BC1C # asm("movl _sgl_value_2,r8"); /* r8 = floating zero */
1964 0002BC1C 0d effffff24a 58 movl _sgl_value_2,r8
1965 0002BC23 # if( subtest == 9 ) {
1966 0002BC23 1d ad04 09 cmpl 4(fp),$9
1967 0002BC27 21 10 jneq L393
1968 0002BC29 # asm("movl _sgl_value_3,r9"); /* r9 = final SP value */
1969 0002BC29 0d effffff23d 59 movl _sgl_value_3,r9
1970 0002BC30 # asm("movl _sgl_value_2,r10"); /* r10 = expected SP value */
1971 0002BC30 0d effffff236 5a movl _sgl_value_2,r10
1972 0002BC37 # } else
1973 0002BC37 11 14 jbr L394
1974 0002BC39 L393:
1975 0002BC39 # if( subtest == 10 ) {
1976 0002BC39 1d ad04 0a cmpl 4(fp),$10
1977 0002BC3D 21 0e jneq L395
1978 0002BC3F # asm("movl _sgl_value_3,r9"); /* r9 = final FP value */
1979 0002BC3F 0d effffff227 59 movl _sgl_value_3,r9
1980 0002BC46 # asm("movl _sgl_value_2,r10"); /* r10 = expected FP value */
1981 0002BC46 0d effffff220 5a movl _sgl_value_2,r10
1982 0002BC4D # };
1983 0002BC4D L395:
1984 0002BC4D L394:
1985 0002BC4D # asm(".globl _pipe7_1_hlt");
1986 0002BC4D .globl _pipe7_1_hlt
1987 0002BC4D # asm("_pipe7_1_hlt:"); /* PC after the halt */
1988 0002BC4D _pipe7_1_hlt:
1989 0002BC4D # asm("halt"); /* HALT ... */
1990 0002BC4D 00 halt
1991 0002BC4E # } /* end of halt on error */
1992 0002BC4E 40 ret#2
1993 0002BC4F .set L389,0x0
1994 0002BC4F L391:
1995 0002BC4F 11 97 jbr L392
1996 0002BC51 .data
1996 00056ABD .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.