![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe1.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 pipe1.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 00000c00 * .text
4 00000000 .align 1
5 00000000 .globl _pipe_1
6 00000000 _pipe_1:
7 0002603C 0000 .word L215
8 0002603E #
9 0002603E #
10 0002603E # #include "fpp_defs.h"
11 0002603E #
12 0002603E #
13 0002603E # /*****************************************************************************
14 0002603E # *
15 0002603E # * PIPELINE TEST #1 MONITOR
16 0002603E # *
17 0002603E # * This test will do:
18 0002603E # *
19 0002603E # * LDF(x), SUBF(x), SUBF(x), ADDF(x), ADDF(x), STF
20 0002603E # *
21 0002603E # * where the x's are the fmacro1 LDF data patterns.
22 0002603E # *****************************************************************************/
23 0002603E # pipe_1()
24 0002603E # {
25 0002603E 13 00a8 jbr L217
26 00026041 L218:
27 00026041 # asm(".globl _pipeline_1_t");
28 00026041 .globl _pipeline_1_t
29 00026041 # asm("_pipeline_1_t:"); /* entry address */
30 00026041 _pipeline_1_t:
31 00026041 # if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */
32 00026041 1d effffffff5 01 cmpl _cycle,$1
33 00026048 21 15 jneq L219
34 0002604A 5d efffffffec tstl _prt_hdrs
35 00026050 31 0d jeql L219
36 00026052 # {
37 00026052 # writes("\n PIPE_1 ");
38 00026052 .data 1
39 00000c00 * L221:
40 00000c00 * 0A20504950455F312000 .ascii "\12 PIPE_1 \0"
41 00000c0a * .text
42 00026052 dd 8f00000c00 pushl $L221
43 00026058 fe 08 efffffffdd callf $8,_writes
44 0002605F # }
45 0002605F # subtest = 1;
46 0002605F L219:
47 0002605F 0d 01 efffffffd6 movl $1,_subtest
48 00026066 # pipe1_1(); /* data in REGs, no NOPs */
49 00026066 fe 04 ef0000007f callf $4,_pipe1_1
50 0002606D # subtest++; /* increment subtest num */
51 0002606D 6d efffffffc9 incl _subtest
52 00026073 # pipe1_2(); /* data in REGs, 1 NOP */
53 00026073 fe 04 ef00000140 callf $4,_pipe1_2
54 0002607A # subtest++; /* increment subtest num */
55 0002607A 6d efffffffbc incl _subtest
56 00026080 # pipe1_3(); /* data in REGs, 2 NOPs */
57 00026080 fe 04 ef00000205 callf $4,_pipe1_3
58 00026087 # subtest++; /* increment subtest num */
59 00026087 6d efffffffaf incl _subtest
60 0002608D # pipe1_4(); /* data in REGs, 3 NOPs */
61 0002608D fe 04 ef000002d0 callf $4,_pipe1_4
62 00026094 # subtest++; /* increment subtest num */
63 00026094 6d efffffffa2 incl _subtest
64 0002609A # pipe1_5(); /* data in CACHE, no NOPs */
65 0002609A fe 04 ef0000039f callf $4,_pipe1_5
66 000260A1 # subtest++; /* increment subtest num */
67 000260A1 6d efffffff95 incl _subtest
68 000260A7 # pipe1_6(); /* data in CACHE, 1 NOP */
69 000260A7 fe 04 ef0000046a callf $4,_pipe1_6
70 000260AE # subtest++; /* increment subtest num */
71 000260AE 6d efffffff88 incl _subtest
72 000260B4 # pipe1_7(); /* data in CACHE, 2 NOPs */
73 000260B4 fe 04 ef00000539 callf $4,_pipe1_7
74 000260BB # subtest++; /* increment subtest num */
75 000260BB 6d efffffff7b incl _subtest
76 000260C1 # pipe1_8(); /* data in CACHE, 3 NOPs */
77 000260C1 fe 04 ef0000060e callf $4,_pipe1_8
78 000260C8 # subtest++; /* increment subtest num */
79 000260C8 6d efffffff6e incl _subtest
80 000260CE # pipe1_9(); /* data on STACK, no NOPs */
81 000260CE fe 04 ef000006e7 callf $4,_pipe1_9
82 000260D5 # subtest++; /* increment subtest num */
83 000260D5 6d efffffff61 incl _subtest
84 000260DB # pipe1_10(); /* data via FP no NOPs */
85 000260DB fe 04 ef00000858 callf $4,_pipe1_10
86 000260E2 # asm("jmp *return"); /* return to the test monitor */
87 000260E2 71 ffffffff54 jmp *return
88 000260E8 # }
89 000260E8 40 ret#2
90 000260E9 .set L215,0x0
91 000260E9 L217:
92 000260E9 13 ff55 jbr L218
93 000260EC .data
94 00000c00 * .text
95 000260EC .align 1
96 000260EC .globl _pipe1_1
97 000260EC _pipe1_1:
98 000260EC 0000 .word L232
99 000260EE #
100 000260EE #
101 000260EE #
102 000260EE #
103 000260EE #
104 000260EE #
105 000260EE # /************************************************************************
106 000260EE # *
107 000260EE # * SUBTEST 1
108 000260EE # * data in registers, no NO-OPs
109 000260EE # *
110 000260EE # ************************************************************************/
111 000260EE # pipe1_1()
112 000260EE # {
113 000260EE 13 00c5 jbr L234
114 000260F1 L235:
115 000260F1 # force_loop = FALSE; /* clear the force_loop flg */
116 000260F1 4d efffffff45 clrl _force_loop
117 000260F7 # index = 0;
118 000260F7 4d efffffff3f clrl _index
119 000260FD # do
120 000260FD L238:
121 000260FD # {
122 000260FD # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
123 000260FD 0d efffffff39 50 movl _index,r0
124 00026104 48 03 50 50 shll $3,r0,r0
125 00026108 0d e000000000 efffffff29 movl _ldf_1_data(r0),_sgl_value_1
126 00026113 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
127 00026113 0d efffffff23 50 movl _index,r0
128 0002611A 48 03 50 50 shll $3,r0,r0
129 0002611E 0d e000000004 efffffff13 movl _ldf_1_data+4(r0),_sgl_expected
130 00026129 # /*
131 00026129 # * If LOOP ON ERROR is set, this is the loop for this subtest.
132 00026129 # * The force loop flag is set after the first error.
133 00026129 # */
134 00026129 # asm("_pipe1_1_lp1:");
135 00026129 _pipe1_1_lp1:
136 00026129 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
137 00026129 0d efffffff0d 54 movl _sgl_value_1,r4
138 00026130 # asm("ldf r4"); /* load the operand */
139 00026130 06 54 ldf r4
140 00026132 # asm("subf r4"); /* subtract it (twice ) */
141 00026132 d6 54 subf r4
142 00026134 # asm("subf r4");
143 00026134 d6 54 subf r4
144 00026136 # asm("addf r4"); /* add it back (twice) */
145 00026136 c6 54 addf r4
146 00026138 # asm("addf r4");
147 00026138 c6 54 addf r4
148 0002613A # asm("stf r5"); /* store the result */
149 0002613A 26 55 stf r5
150 0002613C # if ( force_loop );
151 0002613C 5d effffffefa tstl _force_loop
152 00026142 31 00 jeql L239
153 00026144 # asm("brb _pipe1_1_lp1");; /* loop on the error */
154 00026144 L239:
155 00026144 11 e3 brb _pipe1_1_lp1
156 00026146 # /*
157 00026146 # * verify the results
158 00026146 # */
159 00026146 # asm("movl r5,_sgl_st_acc"); /* get the result */
160 00026146 0d 55 effffffeef movl r5,_sgl_st_acc
161 0002614D # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
162 0002614D 1d effffffee9 effffffee4 cmpl _sgl_st_acc,_sgl_expected
163 00026158 31 42 jeql L240
164 0002615A # {
165 0002615A # errcnt++; /* bump the error count */
166 0002615A 6d effffffedc incl _errcnt
167 00026160 # if ( prt_error )
168 00026160 5d effffffed6 tstl _prt_error
169 00026166 31 0d jeql L241
170 00026168 # print_pipe1_er("Reg. Data, no NO-OPs");
171 00026168 .data 1
172 00000c0a * L243:
173 00000c0a * 5265672E20446174612C206E6 .ascii "Reg. Data, no NO-OPs\0"
F204E4F2D4F507300
174 00000c1f * .text
175 00026168 dd 8f00000c0a pushl $L243
176 0002616E fe 08 ef00000955 callf $8,_print_pipe1_er
177 00026175 # if ( halt_flg ) /* halt on error? */
178 00026175 L241:
179 00026175 5d effffffec1 tstl _halt_flg
180 0002617B 31 0d jeql L244
181 0002617D # pipe1_er_hlt( subtest );
182 0002617D dd effffffeb9 pushl _subtest
183 00026183 fe 08 ef00000a4c callf $8,_pipe1_er_hlt
184 0002618A # if ( loop_on_err ) {
185 0002618A L244:
186 0002618A 5d effffffeac tstl _loop_on_err
187 00026190 31 0a jeql L246
188 00026192 # force_loop = TRUE; /* set the force loop flag */
189 00026192 0d 01 effffffea3 movl $1,_force_loop
190 00026199 # asm("brw _pipe1_1_lp1"); /* and loop */
191 00026199 13 ff8d brw _pipe1_1_lp1
192 0002619C # }
193 0002619C # } /* end of compare error */
194 0002619C L246:
195 0002619C # } while( index++ < max_ldf_1_index );
196 0002619C L240:
197 0002619C L237:
198 0002619C 0d effffffe9a 50 movl _index,r0
199 000261A3 6d effffffe93 incl _index
200 000261A9 1d 50 effffffe8c cmpl r0,_max_ldf_1_index
201 000261B0 81 03 13 ff48 jlss L238
202 000261B5 L236:
203 000261B5 # } /* end of subtest 1 */
204 000261B5 40 ret#2
205 000261B6 .set L232,0x0
206 000261B6 L234:
207 000261B6 13 ff38 jbr L235
208 000261B9 .data
209 00000c00 * .text
210 000261B9 00 .align 1
211 000261BA .globl _pipe1_2
212 000261BA _pipe1_2:
213 000261BA 0000 .word L247
214 000261BC #
215 000261BC #
216 000261BC #
217 000261BC #
218 000261BC #
219 000261BC #
220 000261BC # /************************************************************************
221 000261BC # *
222 000261BC # * SUBTEST 2
223 000261BC # * data in registers, 1 NO-OP
224 000261BC # *
225 000261BC # ************************************************************************/
226 000261BC # pipe1_2()
227 000261BC # {
228 000261BC 13 00ca jbr L249
229 000261BF L250:
230 000261BF # force_loop = FALSE; /* clear force_loop flag */
231 000261BF 4d effffffe77 clrl _force_loop
232 000261C5 # index = 0;
233 000261C5 4d effffffe71 clrl _index
234 000261CB # do
235 000261CB L253:
236 000261CB # {
237 000261CB # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
238 000261CB 0d effffffe6b 50 movl _index,r0
239 000261D2 48 03 50 50 shll $3,r0,r0
240 000261D6 0d e000000000 effffffe5b movl _ldf_1_data(r0),_sgl_value_1
241 000261E1 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
242 000261E1 0d effffffe55 50 movl _index,r0
243 000261E8 48 03 50 50 shll $3,r0,r0
244 000261EC 0d e000000004 effffffe45 movl _ldf_1_data+4(r0),_sgl_expected
245 000261F7 # /*
246 000261F7 # * If LOOP ON ERROR is set, this is the loop for this subtest.
247 000261F7 # * The force loop flag is set after the first error.
248 000261F7 # */
249 000261F7 # asm("_pipe1_2_lp1:");
250 000261F7 _pipe1_2_lp1:
251 000261F7 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
252 000261F7 0d effffffe3f 54 movl _sgl_value_1,r4
253 000261FE # asm("ldf r4"); /* load the data operand */
254 000261FE 06 54 ldf r4
255 00026200 # asm("nop");
256 00026200 10 nop
257 00026201 # asm("subf r4"); /* subtract the data (2xs) */
258 00026201 d6 54 subf r4
259 00026203 # asm("nop");
260 00026203 10 nop
261 00026204 # asm("subf r4");
262 00026204 d6 54 subf r4
263 00026206 # asm("nop");
264 00026206 10 nop
265 00026207 # asm("addf r4"); /* add it back (2xs) */
266 00026207 c6 54 addf r4
267 00026209 # asm("nop");
268 00026209 10 nop
269 0002620A # asm("addf r4");
270 0002620A c6 54 addf r4
271 0002620C # asm("nop");
272 0002620C 10 nop
273 0002620D # asm("stf r5"); /* store the result */
274 0002620D 26 55 stf r5
275 0002620F # if ( force_loop );
276 0002620F 5d effffffe27 tstl _force_loop
277 00026215 31 00 jeql L254
278 00026217 # asm("brb _pipe1_2_lp1");; /* loop on the error */
279 00026217 L254:
280 00026217 11 de brb _pipe1_2_lp1
281 00026219 # /*
282 00026219 # * verify the results
283 00026219 # */
284 00026219 # asm("movl r5,_sgl_st_acc"); /* get the result */
285 00026219 0d 55 effffffe1c movl r5,_sgl_st_acc
286 00026220 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
287 00026220 1d effffffe16 effffffe11 cmpl _sgl_st_acc,_sgl_expected
288 0002622B 31 42 jeql L255
289 0002622D # {
290 0002622D # errcnt++; /* bump the error count */
291 0002622D 6d effffffe09 incl _errcnt
292 00026233 # if ( prt_error )
293 00026233 5d effffffe03 tstl _prt_error
294 00026239 31 0d jeql L256
295 0002623B # print_pipe1_er("Reg. Data, 1 NO-OP");
296 0002623B .data 1
297 00000c1f * L257:
298 00000c1f * 5265672E20446174612C20312 .ascii "Reg. Data, 1 NO-OP\0"
04E4F2D4F5000
299 00000c32 * .text
300 0002623B dd 8f00000c1f pushl $L257
301 00026241 fe 08 ef00000882 callf $8,_print_pipe1_er
302 00026248 # if ( halt_flg ) /* halt on error? */
303 00026248 L256:
304 00026248 5d effffffdee tstl _halt_flg
305 0002624E 31 0d jeql L258
306 00026250 # pipe1_er_hlt( subtest );
307 00026250 dd effffffde6 pushl _subtest
308 00026256 fe 08 ef00000979 callf $8,_pipe1_er_hlt
309 0002625D # if ( loop_on_err ) {
310 0002625D L258:
311 0002625D 5d effffffdd9 tstl _loop_on_err
312 00026263 31 0a jeql L259
313 00026265 # force_loop = TRUE; /* set the force loop flag */
314 00026265 0d 01 effffffdd0 movl $1,_force_loop
315 0002626C # asm("brw _pipe1_2_lp1"); /* and loop */
316 0002626C 13 ff88 brw _pipe1_2_lp1
317 0002626F # }
318 0002626F # } /* end of compare error */
319 0002626F L259:
320 0002626F # } while( index++ < max_ldf_1_index );
321 0002626F L255:
322 0002626F L252:
323 0002626F 0d effffffdc7 50 movl _index,r0
324 00026276 6d effffffdc0 incl _index
325 0002627C 1d 50 effffffdb9 cmpl r0,_max_ldf_1_index
326 00026283 81 03 13 ff43 jlss L253
327 00026288 L251:
328 00026288 # } /* end of subtest 2 */
329 00026288 40 ret#2
330 00026289 .set L247,0x0
331 00026289 L249:
332 00026289 13 ff33 jbr L250
333 0002628C .data
334 00000c00 * .text
335 0002628C .align 1
336 0002628C .globl _pipe1_3
337 0002628C _pipe1_3:
338 0002628C 0000 .word L260
339 0002628E #
340 0002628E #
341 0002628E #
342 0002628E #
343 0002628E #
344 0002628E #
345 0002628E # /************************************************************************
346 0002628E # *
347 0002628E # * SUBTEST 3
348 0002628E # * data in registers, 2 NO-OPs
349 0002628E # *
350 0002628E # ************************************************************************/
351 0002628E # pipe1_3()
352 0002628E # {
353 0002628E 13 00cf jbr L262
354 00026291 L263:
355 00026291 # force_loop = FALSE; /* clear force_loop flag */
356 00026291 4d effffffda5 clrl _force_loop
357 00026297 # index = 0;
358 00026297 4d effffffd9f clrl _index
359 0002629D # do
360 0002629D L266:
361 0002629D # {
362 0002629D # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
363 0002629D 0d effffffd99 50 movl _index,r0
364 000262A4 48 03 50 50 shll $3,r0,r0
365 000262A8 0d e000000000 effffffd89 movl _ldf_1_data(r0),_sgl_value_1
366 000262B3 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
367 000262B3 0d effffffd83 50 movl _index,r0
368 000262BA 48 03 50 50 shll $3,r0,r0
369 000262BE 0d e000000004 effffffd73 movl _ldf_1_data+4(r0),_sgl_expected
370 000262C9 # /*
371 000262C9 # * If LOOP ON ERROR is set, this is the loop for this subtest.
372 000262C9 # * The force loop flag is set after the first error.
373 000262C9 # */
374 000262C9 # asm("_pipe1_3_lp1:");
375 000262C9 _pipe1_3_lp1:
376 000262C9 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
377 000262C9 0d effffffd6d 54 movl _sgl_value_1,r4
378 000262D0 # asm("ldf r4"); /* loadthe operand */
379 000262D0 06 54 ldf r4
380 000262D2 # asm("nop");
381 000262D2 10 nop
382 000262D3 # asm("nop");
383 000262D3 10 nop
384 000262D4 # asm("subf r4"); /* subtract the data (2xs) */
385 000262D4 d6 54 subf r4
386 000262D6 # asm("nop");
387 000262D6 10 nop
388 000262D7 # asm("nop");
389 000262D7 10 nop
390 000262D8 # asm("subf r4");
391 000262D8 d6 54 subf r4
392 000262DA # asm("nop");
393 000262DA 10 nop
394 000262DB # asm("nop");
395 000262DB 10 nop
396 000262DC # asm("addf r4"); /* add it back (2xs) */
397 000262DC c6 54 addf r4
398 000262DE # asm("nop");
399 000262DE 10 nop
400 000262DF # asm("nop");
401 000262DF 10 nop
402 000262E0 # asm("addf r4");
403 000262E0 c6 54 addf r4
404 000262E2 # asm("nop");
405 000262E2 10 nop
406 000262E3 # asm("nop");
407 000262E3 10 nop
408 000262E4 # asm("stf r5"); /* store the result */
409 000262E4 26 55 stf r5
410 000262E6 # if ( force_loop );
411 000262E6 5d effffffd50 tstl _force_loop
412 000262EC 31 00 jeql L267
413 000262EE # asm("brb _pipe1_3_lp1");; /* loop on the error */
414 000262EE L267:
415 000262EE 11 d9 brb _pipe1_3_lp1
416 000262F0 # /*
417 000262F0 # * verify the results
418 000262F0 # */
419 000262F0 # asm("movl r5,_sgl_st_acc"); /* get the result */
420 000262F0 0d 55 effffffd45 movl r5,_sgl_st_acc
421 000262F7 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
422 000262F7 1d effffffd3f effffffd3a cmpl _sgl_st_acc,_sgl_expected
423 00026302 31 42 jeql L268
424 00026304 # {
425 00026304 # errcnt++; /* bump the error count */
426 00026304 6d effffffd32 incl _errcnt
427 0002630A # if ( prt_error )
428 0002630A 5d effffffd2c tstl _prt_error
429 00026310 31 0d jeql L269
430 00026312 # print_pipe1_er("Reg. Data, 2 NO-OPs");
431 00026312 .data 1
432 00000c32 * L270:
433 00000c32 * 5265672E20446174612C20322 .ascii "Reg. Data, 2 NO-OPs\0"
04E4F2D4F507300
434 00000c46 * .text
435 00026312 dd 8f00000c32 pushl $L270
436 00026318 fe 08 ef000007ab callf $8,_print_pipe1_er
437 0002631F # if ( halt_flg ) /* halt on error? */
438 0002631F L269:
439 0002631F 5d effffffd17 tstl _halt_flg
440 00026325 31 0d jeql L271
441 00026327 # pipe1_er_hlt( subtest );
442 00026327 dd effffffd0f pushl _subtest
443 0002632D fe 08 ef000008a2 callf $8,_pipe1_er_hlt
444 00026334 # if ( loop_on_err ) {
445 00026334 L271:
446 00026334 5d effffffd02 tstl _loop_on_err
447 0002633A 31 0a jeql L272
448 0002633C # force_loop = TRUE; /* set the force loop flag */
449 0002633C 0d 01 effffffcf9 movl $1,_force_loop
450 00026343 # asm("brw _pipe1_3_lp1"); /* and loop */
451 00026343 13 ff83 brw _pipe1_3_lp1
452 00026346 # }
453 00026346 # } /* end of compare error */
454 00026346 L272:
455 00026346 # } while( index++ < max_ldf_1_index );
456 00026346 L268:
457 00026346 L265:
458 00026346 0d effffffcf0 50 movl _index,r0
459 0002634D 6d effffffce9 incl _index
460 00026353 1d 50 effffffce2 cmpl r0,_max_ldf_1_index
461 0002635A 81 03 13 ff3e jlss L266
462 0002635F L264:
463 0002635F # } /* end of subtest 3 */
464 0002635F 40 ret#2
465 00026360 .set L260,0x0
466 00026360 L262:
467 00026360 13 ff2e jbr L263
468 00026363 .data
469 00000c00 * .text
470 00026363 00 .align 1
471 00026364 .globl _pipe1_4
472 00026364 _pipe1_4:
473 00026364 0000 .word L273
474 00026366 #
475 00026366 #
476 00026366 #
477 00026366 #
478 00026366 #
479 00026366 #
480 00026366 # /************************************************************************
481 00026366 # *
482 00026366 # * SUBTEST 4
483 00026366 # * data in registers, 3 NO-OPs
484 00026366 # *
485 00026366 # ************************************************************************/
486 00026366 # pipe1_4()
487 00026366 # {
488 00026366 13 00d4 jbr L275
489 00026369 L276:
490 00026369 # force_loop = FALSE; /* clear force_loop flag */
491 00026369 4d effffffccd clrl _force_loop
492 0002636F # index = 0;
493 0002636F 4d effffffcc7 clrl _index
494 00026375 # do
495 00026375 L279:
496 00026375 # {
497 00026375 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
498 00026375 0d effffffcc1 50 movl _index,r0
499 0002637C 48 03 50 50 shll $3,r0,r0
500 00026380 0d e000000000 effffffcb1 movl _ldf_1_data(r0),_sgl_value_1
501 0002638B # sgl_expected = ldf_1_data[index].exp; /* get expected results */
502 0002638B 0d effffffcab 50 movl _index,r0
503 00026392 48 03 50 50 shll $3,r0,r0
504 00026396 0d e000000004 effffffc9b movl _ldf_1_data+4(r0),_sgl_expected
505 000263A1 # /*
506 000263A1 # * If LOOP ON ERROR is set, this is the loop for this subtest.
507 000263A1 # * The force loop flag is set after the first error.
508 000263A1 # */
509 000263A1 # asm("_pipe1_4_lp1:");
510 000263A1 _pipe1_4_lp1:
511 000263A1 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
512 000263A1 0d effffffc95 54 movl _sgl_value_1,r4
513 000263A8 # asm("ldf r4"); /* load the operand */
514 000263A8 06 54 ldf r4
515 000263AA # asm("nop");
516 000263AA 10 nop
517 000263AB # asm("nop");
518 000263AB 10 nop
519 000263AC # asm("nop");
520 000263AC 10 nop
521 000263AD # asm("subf r4"); /* subtract the data (2xs) */
522 000263AD d6 54 subf r4
523 000263AF # asm("nop");
524 000263AF 10 nop
525 000263B0 # asm("nop");
526 000263B0 10 nop
527 000263B1 # asm("nop");
528 000263B1 10 nop
529 000263B2 # asm("subf r4");
530 000263B2 d6 54 subf r4
531 000263B4 # asm("nop");
532 000263B4 10 nop
533 000263B5 # asm("nop");
534 000263B5 10 nop
535 000263B6 # asm("nop");
536 000263B6 10 nop
537 000263B7 # asm("addf r4"); /* add it back (2xs) */
538 000263B7 c6 54 addf r4
539 000263B9 # asm("nop");
540 000263B9 10 nop
541 000263BA # asm("nop");
542 000263BA 10 nop
543 000263BB # asm("nop");
544 000263BB 10 nop
545 000263BC # asm("addf r4");
546 000263BC c6 54 addf r4
547 000263BE # asm("nop");
548 000263BE 10 nop
549 000263BF # asm("nop");
550 000263BF 10 nop
551 000263C0 # asm("nop");
552 000263C0 10 nop
553 000263C1 # asm("stf r5"); /* store the result */
554 000263C1 26 55 stf r5
555 000263C3 # if ( force_loop );
556 000263C3 5d effffffc73 tstl _force_loop
557 000263C9 31 00 jeql L280
558 000263CB # asm("brb _pipe1_4_lp1");; /* loop on the error */
559 000263CB L280:
560 000263CB 11 d4 brb _pipe1_4_lp1
561 000263CD # /*
562 000263CD # * verify the results
563 000263CD # */
564 000263CD # asm("movl r5,_sgl_st_acc"); /* get the result */
565 000263CD 0d 55 effffffc68 movl r5,_sgl_st_acc
566 000263D4 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
567 000263D4 1d effffffc62 effffffc5d cmpl _sgl_st_acc,_sgl_expected
568 000263DF 31 42 jeql L281
569 000263E1 # {
570 000263E1 # errcnt++; /* bump the error count */
571 000263E1 6d effffffc55 incl _errcnt
572 000263E7 # if ( prt_error )
573 000263E7 5d effffffc4f tstl _prt_error
574 000263ED 31 0d jeql L282
575 000263EF # print_pipe1_er("Reg. Data, 3 NO-OPs");
576 000263EF .data 1
577 00000c46 * L283:
578 00000c46 * 5265672E20446174612C20332 .ascii "Reg. Data, 3 NO-OPs\0"
04E4F2D4F507300
579 00000c5a * .text
580 000263EF dd 8f00000c46 pushl $L283
581 000263F5 fe 08 ef000006ce callf $8,_print_pipe1_er
582 000263FC # if ( halt_flg ) /* halt on error? */
583 000263FC L282:
584 000263FC 5d effffffc3a tstl _halt_flg
585 00026402 31 0d jeql L284
586 00026404 # pipe1_er_hlt( subtest );
587 00026404 dd effffffc32 pushl _subtest
588 0002640A fe 08 ef000007c5 callf $8,_pipe1_er_hlt
589 00026411 # if ( loop_on_err ) {
590 00026411 L284:
591 00026411 5d effffffc25 tstl _loop_on_err
592 00026417 31 0a jeql L285
593 00026419 # force_loop = TRUE; /* set the force loop flag */
594 00026419 0d 01 effffffc1c movl $1,_force_loop
595 00026420 # asm("brw _pipe1_4_lp1"); /* and loop */
596 00026420 13 ff7e brw _pipe1_4_lp1
597 00026423 # }
598 00026423 # } /* end of compare error */
599 00026423 L285:
600 00026423 # } while( index++ < max_ldf_1_index );
601 00026423 L281:
602 00026423 L278:
603 00026423 0d effffffc13 50 movl _index,r0
604 0002642A 6d effffffc0c incl _index
605 00026430 1d 50 effffffc05 cmpl r0,_max_ldf_1_index
606 00026437 81 03 13 ff39 jlss L279
607 0002643C L277:
608 0002643C # } /* end of subtest 4 */
609 0002643C 40 ret#2
610 0002643D .set L273,0x0
611 0002643D L275:
612 0002643D 13 ff29 jbr L276
613 00026440 .data
614 00000c00 * .text
615 00026440 .align 1
616 00026440 .globl _pipe1_5
617 00026440 _pipe1_5:
618 00026440 0000 .word L286
619 00026442 #
620 00026442 #
621 00026442 #
622 00026442 #
623 00026442 #
624 00026442 #
625 00026442 #
626 00026442 # /************************************************************************
627 00026442 # *
628 00026442 # * SUBTEST 5
629 00026442 # * data in Cache, no NO-OPs
630 00026442 # *
631 00026442 # ************************************************************************/
632 00026442 # pipe1_5()
633 00026442 # {
634 00026442 13 00cf jbr L288
635 00026445 L289:
636 00026445 # force_loop = FALSE; /* clear force_loop flag */
637 00026445 4d effffffbf1 clrl _force_loop
638 0002644B # index = 0;
639 0002644B 4d effffffbeb clrl _index
640 00026451 # do
641 00026451 L292:
642 00026451 # {
643 00026451 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
644 00026451 0d effffffbe5 50 movl _index,r0
645 00026458 48 03 50 50 shll $3,r0,r0
646 0002645C 0d e000000000 effffffbd5 movl _ldf_1_data(r0),_sgl_value_1
647 00026467 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
648 00026467 0d effffffbcf 50 movl _index,r0
649 0002646E 48 03 50 50 shll $3,r0,r0
650 00026472 0d e000000004 effffffbbf movl _ldf_1_data+4(r0),_sgl_expected
651 0002647D # /*
652 0002647D # * If LOOP ON ERROR is set, this is the loop for this subtest.
653 0002647D # * The force loop flag is set after the first error.
654 0002647D # */
655 0002647D # asm("_pipe1_5_lp1:");
656 0002647D _pipe1_5_lp1:
657 0002647D # asm("ldf _sgl_value_1"); /* load the operand */
658 0002647D 06 effffffbb9 ldf _sgl_value_1
659 00026483 # asm("subf _sgl_value_1"); /* subtract it (twice) */
660 00026483 d6 effffffbb3 subf _sgl_value_1
661 00026489 # asm("subf _sgl_value_1");
662 00026489 d6 effffffbad subf _sgl_value_1
663 0002648F # asm("addf _sgl_value_1"); /* add it back (twice) */
664 0002648F c6 effffffba7 addf _sgl_value_1
665 00026495 # asm("addf _sgl_value_1");
666 00026495 c6 effffffba1 addf _sgl_value_1
667 0002649B # asm("stf _sgl_st_acc"); /* store the result */
668 0002649B 26 effffffb9b stf _sgl_st_acc
669 000264A1 # if ( force_loop );
670 000264A1 5d effffffb95 tstl _force_loop
671 000264A7 31 00 jeql L293
672 000264A9 # asm("brb _pipe1_5_lp1");; /* loop on the error */
673 000264A9 L293:
674 000264A9 11 d2 brb _pipe1_5_lp1
675 000264AB # /*
676 000264AB # * verify the results
677 000264AB # */
678 000264AB # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
679 000264AB 1d effffffb8b effffffb86 cmpl _sgl_st_acc,_sgl_expected
680 000264B6 31 42 jeql L294
681 000264B8 # {
682 000264B8 # errcnt++; /* bump the error count */
683 000264B8 6d effffffb7e incl _errcnt
684 000264BE # if ( prt_error )
685 000264BE 5d effffffb78 tstl _prt_error
686 000264C4 31 0d jeql L295
687 000264C6 # print_pipe1_er("Cache Data, no NO-OPs");
688 000264C6 .data 1
689 00000c5a * L296:
690 00000c5a * 436163686520446174612C206 .ascii "Cache Data, no NO-OPs\0"
E6F204E4F2D4F507300
691 00000c70 * .text
692 000264C6 dd 8f00000c5a pushl $L296
693 000264CC fe 08 ef000005f7 callf $8,_print_pipe1_er
694 000264D3 # if ( halt_flg ) /* halt on error? */
695 000264D3 L295:
696 000264D3 5d effffffb63 tstl _halt_flg
697 000264D9 31 0d jeql L297
698 000264DB # pipe1_er_hlt( subtest );
699 000264DB dd effffffb5b pushl _subtest
700 000264E1 fe 08 ef000006ee callf $8,_pipe1_er_hlt
701 000264E8 # if ( loop_on_err ) {
702 000264E8 L297:
703 000264E8 5d effffffb4e tstl _loop_on_err
704 000264EE 31 0a jeql L298
705 000264F0 # force_loop = TRUE; /* set the force loop flag */
706 000264F0 0d 01 effffffb45 movl $1,_force_loop
707 000264F7 # asm("brw _pipe1_5_lp1"); /* and loop */
708 000264F7 13 ff83 brw _pipe1_5_lp1
709 000264FA # }
710 000264FA # } /* end of compare error */
711 000264FA L298:
712 000264FA # } while( index++ < max_ldf_1_index );
713 000264FA L294:
714 000264FA L291:
715 000264FA 0d effffffb3c 50 movl _index,r0
716 00026501 6d effffffb35 incl _index
717 00026507 1d 50 effffffb2e cmpl r0,_max_ldf_1_index
718 0002650E 81 03 13 ff3e jlss L292
719 00026513 L290:
720 00026513 # } /* end of subtest 5 */
721 00026513 40 ret#2
722 00026514 .set L286,0x0
723 00026514 L288:
724 00026514 13 ff2e jbr L289
725 00026517 .data
726 00000c00 * .text
727 00026517 00 .align 1
728 00026518 .globl _pipe1_6
729 00026518 _pipe1_6:
730 00026518 0000 .word L299
731 0002651A #
732 0002651A #
733 0002651A #
734 0002651A #
735 0002651A #
736 0002651A #
737 0002651A # /************************************************************************
738 0002651A # *
739 0002651A # * SUBTEST 6
740 0002651A # * data in Cache, 1 NO-OP
741 0002651A # *
742 0002651A # ************************************************************************/
743 0002651A # pipe1_6()
744 0002651A # {
745 0002651A 13 00d4 jbr L301
746 0002651D L302:
747 0002651D # force_loop = FALSE; /* clear force_loop flag */
748 0002651D 4d effffffb19 clrl _force_loop
749 00026523 # index = 0;
750 00026523 4d effffffb13 clrl _index
751 00026529 # do
752 00026529 L305:
753 00026529 # {
754 00026529 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
755 00026529 0d effffffb0d 50 movl _index,r0
756 00026530 48 03 50 50 shll $3,r0,r0
757 00026534 0d e000000000 effffffafd movl _ldf_1_data(r0),_sgl_value_1
758 0002653F # sgl_expected = ldf_1_data[index].exp; /* get expected results */
759 0002653F 0d effffffaf7 50 movl _index,r0
760 00026546 48 03 50 50 shll $3,r0,r0
761 0002654A 0d e000000004 effffffae7 movl _ldf_1_data+4(r0),_sgl_expected
762 00026555 # /*
763 00026555 # * If LOOP ON ERROR is set, this is the loop for this subtest.
764 00026555 # * The force loop flag is set after the first error.
765 00026555 # */
766 00026555 # asm("_pipe1_6_lp1:");
767 00026555 _pipe1_6_lp1:
768 00026555 # asm("ldf _sgl_value_1"); /* load the operand */
769 00026555 06 effffffae1 ldf _sgl_value_1
770 0002655B # asm("nop");
771 0002655B 10 nop
772 0002655C # asm("subf _sgl_value_1"); /* subtract it (twice) */
773 0002655C d6 effffffada subf _sgl_value_1
774 00026562 # asm("nop");
775 00026562 10 nop
776 00026563 # asm("subf _sgl_value_1");
777 00026563 d6 effffffad3 subf _sgl_value_1
778 00026569 # asm("nop");
779 00026569 10 nop
780 0002656A # asm("addf _sgl_value_1"); /* add it back (twice) */
781 0002656A c6 effffffacc addf _sgl_value_1
782 00026570 # asm("nop");
783 00026570 10 nop
784 00026571 # asm("addf _sgl_value_1");
785 00026571 c6 effffffac5 addf _sgl_value_1
786 00026577 # asm("nop");
787 00026577 10 nop
788 00026578 # asm("stf _sgl_st_acc"); /* store the result */
789 00026578 26 effffffabe stf _sgl_st_acc
790 0002657E # if ( force_loop );
791 0002657E 5d effffffab8 tstl _force_loop
792 00026584 31 00 jeql L306
793 00026586 # asm("brb _pipe1_6_lp1");; /* loop on the error */
794 00026586 L306:
795 00026586 11 cd brb _pipe1_6_lp1
796 00026588 # /*
797 00026588 # * verify the results
798 00026588 # */
799 00026588 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
800 00026588 1d effffffaae effffffaa9 cmpl _sgl_st_acc,_sgl_expected
801 00026593 31 42 jeql L307
802 00026595 # {
803 00026595 # errcnt++; /* bump the error count */
804 00026595 6d effffffaa1 incl _errcnt
805 0002659B # if ( prt_error )
806 0002659B 5d effffffa9b tstl _prt_error
807 000265A1 31 0d jeql L308
808 000265A3 # print_pipe1_er("Cache Data, 1 NO-OP");
809 000265A3 .data 1
810 00000c70 * L309:
811 00000c70 * 436163686520446174612C203 .ascii "Cache Data, 1 NO-OP\0"
1204E4F2D4F5000
812 00000c84 * .text
813 000265A3 dd 8f00000c70 pushl $L309
814 000265A9 fe 08 ef0000051a callf $8,_print_pipe1_er
815 000265B0 # if ( halt_flg ) /* halt on error? */
816 000265B0 L308:
817 000265B0 5d effffffa86 tstl _halt_flg
818 000265B6 31 0d jeql L310
819 000265B8 # pipe1_er_hlt( subtest );
820 000265B8 dd effffffa7e pushl _subtest
821 000265BE fe 08 ef00000611 callf $8,_pipe1_er_hlt
822 000265C5 # if ( loop_on_err ) {
823 000265C5 L310:
824 000265C5 5d effffffa71 tstl _loop_on_err
825 000265CB 31 0a jeql L311
826 000265CD # force_loop = TRUE; /* set the force loop flag */
827 000265CD 0d 01 effffffa68 movl $1,_force_loop
828 000265D4 # asm("brw _pipe1_6_lp1"); /* and loop */
829 000265D4 13 ff7e brw _pipe1_6_lp1
830 000265D7 # }
831 000265D7 # } /* end of compare error */
832 000265D7 L311:
833 000265D7 # } while( index++ < max_ldf_1_index );
834 000265D7 L307:
835 000265D7 L304:
836 000265D7 0d effffffa5f 50 movl _index,r0
837 000265DE 6d effffffa58 incl _index
838 000265E4 1d 50 effffffa51 cmpl r0,_max_ldf_1_index
839 000265EB 81 03 13 ff39 jlss L305
840 000265F0 L303:
841 000265F0 # } /* end of subtest 6 */
842 000265F0 40 ret#2
843 000265F1 .set L299,0x0
844 000265F1 L301:
845 000265F1 13 ff29 jbr L302
846 000265F4 .data
847 00000c00 * .text
848 000265F4 .align 1
849 000265F4 .globl _pipe1_7
850 000265F4 _pipe1_7:
851 000265F4 0000 .word L312
852 000265F6 #
853 000265F6 #
854 000265F6 #
855 000265F6 #
856 000265F6 #
857 000265F6 #
858 000265F6 # /************************************************************************
859 000265F6 # *
860 000265F6 # * SUBTEST 7
861 000265F6 # * data in Cache, 2 NO-OPs
862 000265F6 # *
863 000265F6 # ************************************************************************/
864 000265F6 # pipe1_7()
865 000265F6 # {
866 000265F6 13 00d9 jbr L314
867 000265F9 L315:
868 000265F9 # force_loop = FALSE; /* clear force_loop flag */
869 000265F9 4d effffffa3d clrl _force_loop
870 000265FF # index = 0;
871 000265FF 4d effffffa37 clrl _index
872 00026605 # do
873 00026605 L318:
874 00026605 # {
875 00026605 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
876 00026605 0d effffffa31 50 movl _index,r0
877 0002660C 48 03 50 50 shll $3,r0,r0
878 00026610 0d e000000000 effffffa21 movl _ldf_1_data(r0),_sgl_value_1
879 0002661B # sgl_expected = ldf_1_data[index].exp; /* get expected results */
880 0002661B 0d effffffa1b 50 movl _index,r0
881 00026622 48 03 50 50 shll $3,r0,r0
882 00026626 0d e000000004 effffffa0b movl _ldf_1_data+4(r0),_sgl_expected
883 00026631 # /*
884 00026631 # * If LOOP ON ERROR is set, this is the loop for this subtest.
885 00026631 # * The force loop flag is set after the first error.
886 00026631 # */
887 00026631 # asm("_pipe1_7_lp1:");
888 00026631 _pipe1_7_lp1:
889 00026631 # asm("ldf _sgl_value_1"); /* load the operand */
890 00026631 06 effffffa05 ldf _sgl_value_1
891 00026637 # asm("nop");
892 00026637 10 nop
893 00026638 # asm("nop");
894 00026638 10 nop
895 00026639 # asm("subf _sgl_value_1"); /* subtract it (twice) */
896 00026639 d6 effffff9fd subf _sgl_value_1
897 0002663F # asm("nop");
898 0002663F 10 nop
899 00026640 # asm("nop");
900 00026640 10 nop
901 00026641 # asm("subf _sgl_value_1");
902 00026641 d6 effffff9f5 subf _sgl_value_1
903 00026647 # asm("nop");
904 00026647 10 nop
905 00026648 # asm("nop");
906 00026648 10 nop
907 00026649 # asm("addf _sgl_value_1"); /* add it back (twice) */
908 00026649 c6 effffff9ed addf _sgl_value_1
909 0002664F # asm("nop");
910 0002664F 10 nop
911 00026650 # asm("nop");
912 00026650 10 nop
913 00026651 # asm("addf _sgl_value_1");
914 00026651 c6 effffff9e5 addf _sgl_value_1
915 00026657 # asm("nop");
916 00026657 10 nop
917 00026658 # asm("nop");
918 00026658 10 nop
919 00026659 # asm("stf _sgl_st_acc"); /* store the result */
920 00026659 26 effffff9dd stf _sgl_st_acc
921 0002665F # if ( force_loop );
922 0002665F 5d effffff9d7 tstl _force_loop
923 00026665 31 00 jeql L319
924 00026667 # asm("brb _pipe1_7_lp1");; /* loop on the error */
925 00026667 L319:
926 00026667 11 c8 brb _pipe1_7_lp1
927 00026669 # /*
928 00026669 # * verify the results
929 00026669 # */
930 00026669 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
931 00026669 1d effffff9cd effffff9c8 cmpl _sgl_st_acc,_sgl_expected
932 00026674 31 42 jeql L320
933 00026676 # {
934 00026676 # errcnt++; /* bump the error count */
935 00026676 6d effffff9c0 incl _errcnt
936 0002667C # if ( prt_error )
937 0002667C 5d effffff9ba tstl _prt_error
938 00026682 31 0d jeql L321
939 00026684 # print_pipe1_er("Cache Data, 2 NO-OPs");
940 00026684 .data 1
941 00000c84 * L322:
942 00000c84 * 436163686520446174612C203 .ascii "Cache Data, 2 NO-OPs\0"
2204E4F2D4F507300
943 00000c99 * .text
944 00026684 dd 8f00000c84 pushl $L322
945 0002668A fe 08 ef00000439 callf $8,_print_pipe1_er
946 00026691 # if ( halt_flg ) /* halt on error? */
947 00026691 L321:
948 00026691 5d effffff9a5 tstl _halt_flg
949 00026697 31 0d jeql L323
950 00026699 # pipe1_er_hlt( subtest );
951 00026699 dd effffff99d pushl _subtest
952 0002669F fe 08 ef00000530 callf $8,_pipe1_er_hlt
953 000266A6 # if ( loop_on_err ) {
954 000266A6 L323:
955 000266A6 5d effffff990 tstl _loop_on_err
956 000266AC 31 0a jeql L324
957 000266AE # force_loop = TRUE; /* set the force loop flag */
958 000266AE 0d 01 effffff987 movl $1,_force_loop
959 000266B5 # asm("brw _pipe1_7_lp1"); /* and loop */
960 000266B5 13 ff79 brw _pipe1_7_lp1
961 000266B8 # }
962 000266B8 # } /* end of compare error */
963 000266B8 L324:
964 000266B8 # } while( index++ < max_ldf_1_index );
965 000266B8 L320:
966 000266B8 L317:
967 000266B8 0d effffff97e 50 movl _index,r0
968 000266BF 6d effffff977 incl _index
969 000266C5 1d 50 effffff970 cmpl r0,_max_ldf_1_index
970 000266CC 81 03 13 ff34 jlss L318
971 000266D1 L316:
972 000266D1 # } /* end of subtest 7 */
973 000266D1 40 ret#2
974 000266D2 .set L312,0x0
975 000266D2 L314:
976 000266D2 13 ff24 jbr L315
977 000266D5 .data
978 00000c00 * .text
979 000266D5 00 .align 1
980 000266D6 .globl _pipe1_8
981 000266D6 _pipe1_8:
982 000266D6 0000 .word L325
983 000266D8 #
984 000266D8 #
985 000266D8 #
986 000266D8 #
987 000266D8 #
988 000266D8 #
989 000266D8 # /************************************************************************
990 000266D8 # *
991 000266D8 # * SUBTEST 8
992 000266D8 # * data in Cache, 3 NO-OPs
993 000266D8 # *
994 000266D8 # ************************************************************************/
995 000266D8 # pipe1_8()
996 000266D8 # {
997 000266D8 13 00de jbr L327
998 000266DB L328:
999 000266DB # force_loop = FALSE; /* clear force_loop flag */
1000 000266DB 4d effffff95b clrl _force_loop
1001 000266E1 # index = 0;
1002 000266E1 4d effffff955 clrl _index
1003 000266E7 # do
1004 000266E7 L331:
1005 000266E7 # {
1006 000266E7 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
1007 000266E7 0d effffff94f 50 movl _index,r0
1008 000266EE 48 03 50 50 shll $3,r0,r0
1009 000266F2 0d e000000000 effffff93f movl _ldf_1_data(r0),_sgl_value_1
1010 000266FD # sgl_expected = ldf_1_data[index].exp; /* get expected results */
1011 000266FD 0d effffff939 50 movl _index,r0
1012 00026704 48 03 50 50 shll $3,r0,r0
1013 00026708 0d e000000004 effffff929 movl _ldf_1_data+4(r0),_sgl_expected
1014 00026713 # /*
1015 00026713 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1016 00026713 # * The force loop flag is set after the first error.
1017 00026713 # */
1018 00026713 # asm("_pipe1_8_lp1:");
1019 00026713 _pipe1_8_lp1:
1020 00026713 # asm("ldf _sgl_value_1"); /* load the operand */
1021 00026713 06 effffff923 ldf _sgl_value_1
1022 00026719 # asm("nop");
1023 00026719 10 nop
1024 0002671A # asm("nop");
1025 0002671A 10 nop
1026 0002671B # asm("nop");
1027 0002671B 10 nop
1028 0002671C # asm("subf _sgl_value_1"); /* subtract it (twice) */
1029 0002671C d6 effffff91a subf _sgl_value_1
1030 00026722 # asm("nop");
1031 00026722 10 nop
1032 00026723 # asm("nop");
1033 00026723 10 nop
1034 00026724 # asm("nop");
1035 00026724 10 nop
1036 00026725 # asm("subf _sgl_value_1");
1037 00026725 d6 effffff911 subf _sgl_value_1
1038 0002672B # asm("nop");
1039 0002672B 10 nop
1040 0002672C # asm("nop");
1041 0002672C 10 nop
1042 0002672D # asm("nop");
1043 0002672D 10 nop
1044 0002672E # asm("addf _sgl_value_1"); /* add it back (twice) */
1045 0002672E c6 effffff908 addf _sgl_value_1
1046 00026734 # asm("nop");
1047 00026734 10 nop
1048 00026735 # asm("nop");
1049 00026735 10 nop
1050 00026736 # asm("nop");
1051 00026736 10 nop
1052 00026737 # asm("addf _sgl_value_1");
1053 00026737 c6 effffff8ff addf _sgl_value_1
1054 0002673D # asm("nop");
1055 0002673D 10 nop
1056 0002673E # asm("nop");
1057 0002673E 10 nop
1058 0002673F # asm("nop");
1059 0002673F 10 nop
1060 00026740 # asm("stf _sgl_st_acc"); /* store the result */
1061 00026740 26 effffff8f6 stf _sgl_st_acc
1062 00026746 # if ( force_loop );
1063 00026746 5d effffff8f0 tstl _force_loop
1064 0002674C 31 00 jeql L332
1065 0002674E # asm("brb _pipe1_8_lp1");; /* loop on the error */
1066 0002674E L332:
1067 0002674E 11 c3 brb _pipe1_8_lp1
1068 00026750 # /*
1069 00026750 # * verify the results
1070 00026750 # */
1071 00026750 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
1072 00026750 1d effffff8e6 effffff8e1 cmpl _sgl_st_acc,_sgl_expected
1073 0002675B 31 42 jeql L333
1074 0002675D # {
1075 0002675D # errcnt++; /* bump the error count */
1076 0002675D 6d effffff8d9 incl _errcnt
1077 00026763 # if ( prt_error )
1078 00026763 5d effffff8d3 tstl _prt_error
1079 00026769 31 0d jeql L334
1080 0002676B # print_pipe1_er("Cache Data, 3 NO-OPs");
1081 0002676B .data 1
1082 00000c99 * L335:
1083 00000c99 * 436163686520446174612C203 .ascii "Cache Data, 3 NO-OPs\0"
3204E4F2D4F507300
1084 00000cae * .text
1085 0002676B dd 8f00000c99 pushl $L335
1086 00026771 fe 08 ef00000352 callf $8,_print_pipe1_er
1087 00026778 # if ( halt_flg ) /* halt on error? */
1088 00026778 L334:
1089 00026778 5d effffff8be tstl _halt_flg
1090 0002677E 31 0d jeql L336
1091 00026780 # pipe1_er_hlt( subtest );
1092 00026780 dd effffff8b6 pushl _subtest
1093 00026786 fe 08 ef00000449 callf $8,_pipe1_er_hlt
1094 0002678D # if ( loop_on_err ) {
1095 0002678D L336:
1096 0002678D 5d effffff8a9 tstl _loop_on_err
1097 00026793 31 0a jeql L337
1098 00026795 # force_loop = TRUE; /* set the force loop flag */
1099 00026795 0d 01 effffff8a0 movl $1,_force_loop
1100 0002679C # asm("brw _pipe1_8_lp1"); /* and loop */
1101 0002679C 13 ff74 brw _pipe1_8_lp1
1102 0002679F # }
1103 0002679F # } /* end of compare error */
1104 0002679F L337:
1105 0002679F # } while( index++ < max_ldf_1_index );
1106 0002679F L333:
1107 0002679F L330:
1108 0002679F 0d effffff897 50 movl _index,r0
1109 000267A6 6d effffff890 incl _index
1110 000267AC 1d 50 effffff889 cmpl r0,_max_ldf_1_index
1111 000267B3 81 03 13 ff2f jlss L331
1112 000267B8 L329:
1113 000267B8 # } /* end of subtest 8 */
1114 000267B8 40 ret#2
1115 000267B9 .set L325,0x0
1116 000267B9 L327:
1117 000267B9 13 ff1f jbr L328
1118 000267BC .data
1119 00000c00 * .text
1120 000267BC .align 1
1121 000267BC .globl _pipe1_9
1122 000267BC _pipe1_9:
1123 000267BC 0000 .word L338
1124 000267BE #
1125 000267BE #
1126 000267BE #
1127 000267BE #
1128 000267BE #
1129 000267BE #
1130 000267BE # /*****************************************************************************
1131 000267BE # *
1132 000267BE # * SUBTEST 9
1133 000267BE # * data on the stack, no NO-OPs
1134 000267BE # *
1135 000267BE # *****************************************************************************/
1136 000267BE # pipe1_9()
1137 000267BE # {
1138 000267BE 13 0175 jbr L340
1139 000267C1 L341:
1140 000267C1 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
1141 000267C1 ed 6d effffff874 moval (r13),_pre_event_fp
1142 000267C8 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
1143 000267C8 ed 6e effffff86d moval (r14),_pre_event_sp
1144 000267CF # force_loop = FALSE; /* clear force_loop flag */
1145 000267CF 4d effffff867 clrl _force_loop
1146 000267D5 # index = 0;
1147 000267D5 4d effffff861 clrl _index
1148 000267DB # do
1149 000267DB L344:
1150 000267DB # {
1151 000267DB # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
1152 000267DB 0d effffff85b 50 movl _index,r0
1153 000267E2 48 03 50 50 shll $3,r0,r0
1154 000267E6 0d e000000000 effffff84b movl _ldf_1_data(r0),_sgl_value_1
1155 000267F1 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
1156 000267F1 0d effffff845 50 movl _index,r0
1157 000267F8 48 03 50 50 shll $3,r0,r0
1158 000267FC 0d e000000004 effffff835 movl _ldf_1_data+4(r0),_sgl_expected
1159 00026807 # asm("moval _pointer_data,_sgl_value_2");/* init / final SP value */
1160 00026807 ed effffff82f effffff82a moval _pointer_data,_sgl_value_2
1161 00026812 # /*
1162 00026812 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1163 00026812 # * The force loop flag is set after the first error.
1164 00026812 # */
1165 00026812 # asm("_pipe1_9_lp1:");
1166 00026812 _pipe1_9_lp1:
1167 00026812 # asm("moval _pointer_data,r14"); /* set the stack pointer */
1168 00026812 ed effffff824 5e moval _pointer_data,r14
1169 00026819 # asm("movl _sgl_value_1,-(r14)"); /* push the operand 5 times */
1170 00026819 0d effffff81d 7e movl _sgl_value_1,-(r14)
1171 00026820 # asm("movl _sgl_value_1,-(r14)");
1172 00026820 0d effffff816 7e movl _sgl_value_1,-(r14)
1173 00026827 # asm("movl _sgl_value_1,-(r14)");
1174 00026827 0d effffff80f 7e movl _sgl_value_1,-(r14)
1175 0002682E # asm("movl _sgl_value_1,-(r14)");
1176 0002682E 0d effffff808 7e movl _sgl_value_1,-(r14)
1177 00026835 # asm("movl _sgl_value_1,-(r14)");
1178 00026835 0d effffff801 7e movl _sgl_value_1,-(r14)
1179 0002683C # /*
1180 0002683C # * now pop the data off the stack
1181 0002683C # */
1182 0002683C # asm("ldf (r14)+"); /* pop the data & load it */
1183 0002683C 06 8e ldf (r14)+
1184 0002683E # asm("subf (r14)+"); /* subtract it (twice) */
1185 0002683E d6 8e subf (r14)+
1186 00026840 # asm("subf (r14)+");
1187 00026840 d6 8e subf (r14)+
1188 00026842 # asm("addf (r14)+"); /* add it back (twice) */
1189 00026842 c6 8e addf (r14)+
1190 00026844 # asm("addf (r14)+");
1191 00026844 c6 8e addf (r14)+
1192 00026846 # asm("stf r5"); /* store the result */
1193 00026846 26 55 stf r5
1194 00026848 # if ( force_loop );
1195 00026848 5d effffff7ee tstl _force_loop
1196 0002684E 31 00 jeql L345
1197 00026850 # asm("brb _pipe1_9_lp1");; /* loop on the error */
1198 00026850 L345:
1199 00026850 11 c0 brb _pipe1_9_lp1
1200 00026852 # /*
1201 00026852 # * verify the results
1202 00026852 # */
1203 00026852 # asm("movl r5,_sgl_st_acc"); /* get the result */
1204 00026852 0d 55 effffff7e3 movl r5,_sgl_st_acc
1205 00026859 # asm("moval (r14),_sgl_value_3"); /* save the stack pointer */
1206 00026859 ed 6e effffff7dc moval (r14),_sgl_value_3
1207 00026860 # if( (sgl_st_acc != sgl_expected) || /* verify the result... */
1208 00026860 # (sgl_value_3 != sgl_value_2) ) /* ... and the final SP */
1209 00026860 1d effffff7d6 effffff7d1 cmpl _sgl_st_acc,_sgl_expected
1210 0002686B 21 10 jneq L9999
1211 0002686D 1d effffff7c9 effffff7c4 cmpl _sgl_value_3,_sgl_value_2
1212 00026878 21 03 13 0091 jeql L346
1213 0002687D L9999:
1214 0002687D # {
1215 0002687D # asm("movl _pre_event_fp,r13"); /* restore frame pointer */
1216 0002687D 0d effffff7b9 5d movl _pre_event_fp,r13
1217 00026884 # asm("movl _pre_event_sp,r14"); /* restore stack pointer */
1218 00026884 0d effffff7b2 5e movl _pre_event_sp,r14
1219 0002688B # errcnt++; /* bump the error count */
1220 0002688B 6d effffff7ab incl _errcnt
1221 00026891 # if ( prt_error ) {
1222 00026891 5d effffff7a5 tstl _prt_error
1223 00026897 31 4e jeql L347
1224 00026899 # print_pipe1_er("POP data from the SP");
1225 00026899 .data 1
1226 00000cae * L348:
1227 00000cae * 504F5020646174612066726F6 .ascii "POP data from the SP\0"
D2074686520535000
1228 00000cc3 * .text
1229 00026899 dd 8f00000cae pushl $L348
1230 0002689F fe 08 ef00000224 callf $8,_print_pipe1_er
1231 000268A6 # writes("final Stack Pointer = ");
1232 000268A6 .data 1
1233 00000cc3 * L349:
1234 00000cc3 * 66696E616C20537461636B205 .ascii "final Stack Pointer = \0"
06F696E746572203D2000
1235 00000cda * .text
1236 000268A6 dd 8f00000cc3 pushl $L349
1237 000268AC fe 08 effffff789 callf $8,_writes
1238 000268B3 # write32h( sgl_value_3 );
1239 000268B3 dd effffff783 pushl _sgl_value_3
1240 000268B9 fe 08 effffff77c callf $8,_write32h
1241 000268C0 # writes(", expected SP = ");
1242 000268C0 .data 1
1243 00000cda * L351:
1244 00000cda * 2C20206578706563746564205 .ascii ", expected SP = \0"
350203D2000
1245 00000cec * .text
1246 000268C0 dd 8f00000cda pushl $L351
1247 000268C6 fe 08 effffff76f callf $8,_writes
1248 000268CD # write32h( sgl_value_2 );
1249 000268CD dd effffff769 pushl _sgl_value_2
1250 000268D3 fe 08 effffff762 callf $8,_write32h
1251 000268DA # writes(" \n");
1252 000268DA .data 1
1253 00000cec * L352:
1254 00000cec * 200A00 .ascii " \12\0"
1255 00000cef * .text
1256 000268DA dd 8f00000cec pushl $L352
1257 000268E0 fe 08 effffff755 callf $8,_writes
1258 000268E7 # }
1259 000268E7 # if ( halt_flg ) /* halt on error? */
1260 000268E7 L347:
1261 000268E7 5d effffff74f tstl _halt_flg
1262 000268ED 31 0d jeql L353
1263 000268EF # pipe1_er_hlt( subtest );
1264 000268EF dd effffff747 pushl _subtest
1265 000268F5 fe 08 ef000002da callf $8,_pipe1_er_hlt
1266 000268FC # if ( loop_on_err ) {
1267 000268FC L353:
1268 000268FC 5d effffff73a tstl _loop_on_err
1269 00026902 31 0a jeql L354
1270 00026904 # force_loop = TRUE; /* set the force loop flag */
1271 00026904 0d 01 effffff731 movl $1,_force_loop
1272 0002690B # asm("brw _pipe1_9_lp1"); /* and loop */
1273 0002690B 13 ff04 brw _pipe1_9_lp1
1274 0002690E # }
1275 0002690E # } /* end of compare error */
1276 0002690E L354:
1277 0002690E # } while( index++ < max_ldf_1_index );
1278 0002690E L346:
1279 0002690E L343:
1280 0002690E 0d effffff728 50 movl _index,r0
1281 00026915 6d effffff721 incl _index
1282 0002691B 1d 50 effffff71a cmpl r0,_max_ldf_1_index
1283 00026922 81 03 13 feb4 jlss L344
1284 00026927 L342:
1285 00026927 # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */
1286 00026927 0d effffff70f 5d movl _pre_event_fp,r13
1287 0002692E # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */
1288 0002692E 0d effffff708 5e movl _pre_event_sp,r14
1289 00026935 # } /* end of subtest 9 */
1290 00026935 40 ret#2
1291 00026936 .set L338,0x0
1292 00026936 L340:
1293 00026936 13 fe88 jbr L341
1294 00026939 .data
1295 00000c00 * .text
1296 00026939 00 .align 1
1297 0002693A .globl _pipe1_10
1298 0002693A _pipe1_10:
1299 0002693A 0000 .word L355
1300 0002693C #
1301 0002693C #
1302 0002693C #
1303 0002693C #
1304 0002693C #
1305 0002693C #
1306 0002693C # /******************************************************************************
1307 0002693C # *
1308 0002693C # * SUBTEST 10
1309 0002693C # * load 0, add operand 4 times -get data via indexed FRAME pointer
1310 0002693C # *
1311 0002693C # * ADDR INDEX DATA
1312 0002693C # * pointer_data 4 <the STF result goes here>
1313 0002693C # * pointer_data-4 3 <operand data>
1314 0002693C # * pointer_data-16 0 point the frame pointer here
1315 0002693C # *
1316 0002693C # ******************************************************************************/
1317 0002693C # pipe1_10()
1318 0002693C # {
1319 0002693C 13 0187 jbr L357
1320 0002693F L358:
1321 0002693F # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
1322 0002693F ed 6d effffff6f6 moval (r13),_pre_event_fp
1323 00026946 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
1324 00026946 ed 6e effffff6ef moval (r14),_pre_event_sp
1325 0002694D # force_loop = FALSE; /* clear force_loop flag */
1326 0002694D 4d effffff6e9 clrl _force_loop
1327 00026953 # index = 0;
1328 00026953 4d effffff6e3 clrl _index
1329 00026959 # do
1330 00026959 L361:
1331 00026959 # {
1332 00026959 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
1333 00026959 0d effffff6dd 50 movl _index,r0
1334 00026960 48 03 50 50 shll $3,r0,r0
1335 00026964 0d e000000000 effffff6cd movl _ldf_1_data(r0),_sgl_value_1
1336 0002696F # sgl_expected = ldf_1_data[index].exp; /* get expected results */
1337 0002696F 0d effffff6c7 50 movl _index,r0
1338 00026976 48 03 50 50 shll $3,r0,r0
1339 0002697A 0d e000000004 effffff6b7 movl _ldf_1_data+4(r0),_sgl_expected
1340 00026985 # asm("moval _pointer_data,_sgl_value_2");/* init / final SP value */
1341 00026985 ed effffff6b1 effffff6ac moval _pointer_data,_sgl_value_2
1342 00026990 # /*
1343 00026990 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1344 00026990 # * The force loop flag is set after the first error.
1345 00026990 # */
1346 00026990 # asm("_pipe1_10_lp1:");
1347 00026990 _pipe1_10_lp1:
1348 00026990 # asm("moval _pointer_data,_sgl_value_2");/* get store data's addr */
1349 00026990 ed effffff6a6 effffff6a1 moval _pointer_data,_sgl_value_2
1350 0002699B # sgl_value_2 -= 4; /* decrement it by 4 (bytes)*/
1351 0002699B 2c 04 effffff69a subl2 $4,_sgl_value_2
1352 000269A2 # asm("movl _sgl_value_1,*_sgl_value_2");/* set the operand data */
1353 000269A2 0d effffff694 fffffff68f movl _sgl_value_1,*_sgl_value_2
1354 000269AD # sgl_value_2 -= 12; /* get the FP addr to use */
1355 000269AD 2c 0c effffff688 subl2 $12,_sgl_value_2
1356 000269B4 # asm("movl _sgl_value_2,r13"); /* set the FRAME POINTER */
1357 000269B4 0d effffff682 5d movl _sgl_value_2,r13
1358 000269BB # asm("movl $3,r5"); /* r5 index = 3 longwords */
1359 000269BB 0d 03 55 movl $3,r5
1360 000269BE # asm("movl $4,r6"); /* r6 index = 4 longwords */
1361 000269BE 0d 04 56 movl $4,r6
1362 000269C1 # asm("ldf (r13)[r5]"); /* load -indexed by r5 */
1363 000269C1 06 456d ldf (r13)[r5]
1364 000269C4 # asm("subf (r13)[r5]"); /* subtract it (twice) */
1365 000269C4 d6 456d subf (r13)[r5]
1366 000269C7 # asm("subf (r13)[r5]");
1367 000269C7 d6 456d subf (r13)[r5]
1368 000269CA # asm("addf (r13)[r5]"); /* add it back (twice) */
1369 000269CA c6 456d addf (r13)[r5]
1370 000269CD # asm("addf (r13)[r5]");
1371 000269CD c6 456d addf (r13)[r5]
1372 000269D0 # asm("stf (r13)[r6]"); /* store -indexed by r6 */
1373 000269D0 26 466d stf (r13)[r6]
1374 000269D3 # if ( force_loop );
1375 000269D3 5d effffff663 tstl _force_loop
1376 000269D9 31 00 jeql L362
1377 000269DB # asm("brw _pipe1_10_lp1");; /* loop on the error */
1378 000269DB L362:
1379 000269DB 13 ffb2 brw _pipe1_10_lp1
1380 000269DE # /*
1381 000269DE # * verify the results
1382 000269DE # */
1383 000269DE # sgl_st_acc = pointer_data; /* move the stored result */
1384 000269DE 0d effffff658 effffff653 movl _pointer_data,_sgl_st_acc
1385 000269E9 # asm("moval (r13),_sgl_value_3"); /* save the frame pointer */
1386 000269E9 ed 6d effffff64c moval (r13),_sgl_value_3
1387 000269F0 # if( (sgl_st_acc != sgl_expected) || /* verify the result... */
1388 000269F0 # (sgl_value_3 != sgl_value_2) ) /* ... and the final FP */
1389 000269F0 1d effffff646 effffff641 cmpl _sgl_st_acc,_sgl_expected
1390 000269FB 21 10 jneq L9998
1391 000269FD 1d effffff639 effffff634 cmpl _sgl_value_3,_sgl_value_2
1392 00026A08 21 03 13 0091 jeql L363
1393 00026A0D L9998:
1394 00026A0D # {
1395 00026A0D # asm("movl _pre_event_fp,r13"); /* restore frame pointer */
1396 00026A0D 0d effffff629 5d movl _pre_event_fp,r13
1397 00026A14 # asm("movl _pre_event_sp,r14"); /* restore stack pointer */
1398 00026A14 0d effffff622 5e movl _pre_event_sp,r14
1399 00026A1B # errcnt++; /* bump the error count */
1400 00026A1B 6d effffff61b incl _errcnt
1401 00026A21 # if ( prt_error ) {
1402 00026A21 5d effffff615 tstl _prt_error
1403 00026A27 31 4e jeql L364
1404 00026A29 # print_pipe1_er("indexed FP addressing");
1405 00026A29 .data 1
1406 00000cef * L365:
1407 00000cef * 696E646578656420465020616 .ascii "indexed FP addressing\0"
46472657373696E6700
1408 00000d05 * .text
1409 00026A29 dd 8f00000cef pushl $L365
1410 00026A2F fe 08 ef00000094 callf $8,_print_pipe1_er
1411 00026A36 # writes("final Frame Pointer = ");
1412 00026A36 .data 1
1413 00000d05 * L366:
1414 00000d05 * 66696E616C204672616D65205 .ascii "final Frame Pointer = \0"
06F696E746572203D2000
1415 00000d1c * .text
1416 00026A36 dd 8f00000d05 pushl $L366
1417 00026A3C fe 08 effffff5f9 callf $8,_writes
1418 00026A43 # writeh( sgl_value_3 );
1419 00026A43 dd effffff5f3 pushl _sgl_value_3
1420 00026A49 fe 08 effffff5ec callf $8,_writeh
1421 00026A50 # writes(", expected FP = ");
1422 00026A50 .data 1
1423 00000d1c * L368:
1424 00000d1c * 2C20206578706563746564204 .ascii ", expected FP = \0"
650203D2000
1425 00000d2e * .text
1426 00026A50 dd 8f00000d1c pushl $L368
1427 00026A56 fe 08 effffff5df callf $8,_writes
1428 00026A5D # writeh( sgl_value_2 );
1429 00026A5D dd effffff5d9 pushl _sgl_value_2
1430 00026A63 fe 08 effffff5d2 callf $8,_writeh
1431 00026A6A # writes(" \n");
1432 00026A6A .data 1
1433 00000d2e * L369:
1434 00000d2e * 200A00 .ascii " \12\0"
1435 00000d31 * .text
1436 00026A6A dd 8f00000d2e pushl $L369
1437 00026A70 fe 08 effffff5c5 callf $8,_writes
1438 00026A77 # }
1439 00026A77 # if ( halt_flg ) /* halt on error? */
1440 00026A77 L364:
1441 00026A77 5d effffff5bf tstl _halt_flg
1442 00026A7D 31 0d jeql L370
1443 00026A7F # pipe1_er_hlt( subtest );
1444 00026A7F dd effffff5b7 pushl _subtest
1445 00026A85 fe 08 ef0000014a callf $8,_pipe1_er_hlt
1446 00026A8C # if ( loop_on_err ) {
1447 00026A8C L370:
1448 00026A8C 5d effffff5aa tstl _loop_on_err
1449 00026A92 31 0a jeql L371
1450 00026A94 # force_loop = TRUE; /* set the force loop flag */
1451 00026A94 0d 01 effffff5a1 movl $1,_force_loop
1452 00026A9B # asm("brw _pipe1_10_lp1"); /* and loop */
1453 00026A9B 13 fef2 brw _pipe1_10_lp1
1454 00026A9E # }
1455 00026A9E # } /* end of compare error */
1456 00026A9E L371:
1457 00026A9E # } while( index++ < max_ldf_1_index );
1458 00026A9E L363:
1459 00026A9E L360:
1460 00026A9E 0d effffff598 50 movl _index,r0
1461 00026AA5 6d effffff591 incl _index
1462 00026AAB 1d 50 effffff58a cmpl r0,_max_ldf_1_index
1463 00026AB2 81 03 13 fea2 jlss L361
1464 00026AB7 L359:
1465 00026AB7 # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */
1466 00026AB7 0d effffff57f 5d movl _pre_event_fp,r13
1467 00026ABE # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */
1468 00026ABE 0d effffff578 5e movl _pre_event_sp,r14
1469 00026AC5 # } /* end of subtest 10 */
1470 00026AC5 40 ret#2
1471 00026AC6 .set L355,0x0
1472 00026AC6 L357:
1473 00026AC6 13 fe76 jbr L358
1474 00026AC9 .data
1475 00000c00 * .text
1476 00026AC9 00 .align 1
1477 00026ACA .globl _print_pipe1_er
1478 00026ACA _print_pipe1_er:
1479 00026ACA 0000 .word L372
1480 00026ACC #
1481 00026ACC #
1482 00026ACC #
1483 00026ACC #
1484 00026ACC #
1485 00026ACC # /******************************************************************************
1486 00026ACC # *
1487 00026ACC # * ERROR ROUTINE
1488 00026ACC # *
1489 00026ACC # * print an error in the following form
1490 00026ACC # *
1491 00026ACC # * operand = xxxxxxxx, final Acc = xxxxxxxx, data index = dd
1492 00026ACC # * expected Acc = xxxxxxxx
1493 00026ACC # *
1494 00026ACC # ******************************************************************************/
1495 00026ACC # print_pipe1_er(msg)
1496 00026ACC # char *msg;
1497 00026ACC # {
1498 00026ACC 13 0103 jbr L374
1499 00026ACF L375:
1500 00026ACF # writes(" \n"); /* start a new print line */
1501 00026ACF .data 1
1502 00000d31 * L376:
1503 00000d31 * 200A00 .ascii " \12\0"
1504 00000d34 * .text
1505 00026ACF dd 8f00000d31 pushl $L376
1506 00026AD5 fe 08 effffff560 callf $8,_writes
1507 00026ADC # writes("cycle: ");
1508 00026ADC .data 1
1509 00000d34 * L377:
1510 00000d34 * 6379636C653A2000 .ascii "cycle: \0"
1511 00000d3c * .text
1512 00026ADC dd 8f00000d34 pushl $L377
1513 00026AE2 fe 08 effffff553 callf $8,_writes
1514 00026AE9 # writed( cycle );
1515 00026AE9 dd effffff54d pushl _cycle
1516 00026AEF fe 08 effffff546 callf $8,_writed
1517 00026AF6 # writes(" test ");
1518 00026AF6 .data 1
1519 00000d3c * L379:
1520 00000d3c * 20746573742000 .ascii " test \0"
1521 00000d43 * .text
1522 00026AF6 dd 8f00000d3c pushl $L379
1523 00026AFC fe 08 effffff539 callf $8,_writes
1524 00026B03 # writed( test_no );
1525 00026B03 dd effffff533 pushl _test_no
1526 00026B09 fe 08 effffff52c callf $8,_writed
1527 00026B10 # writes(" (Pipe 1), subtest ");
1528 00026B10 .data 1
1529 00000d43 * L380:
1530 00000d43 * 202028506970652031292C207 .ascii " (Pipe 1), subtest \0"
37562746573742000
1531 00000d58 * .text
1532 00026B10 dd 8f00000d43 pushl $L380
1533 00026B16 fe 08 effffff51f callf $8,_writes
1534 00026B1D # writed( subtest );
1535 00026B1D dd effffff519 pushl _subtest
1536 00026B23 fe 08 effffff512 callf $8,_writed
1537 00026B2A # writes(" error - ");
1538 00026B2A .data 1
1539 00000d58 * L381:
1540 00000d58 * 206572726F72202D2000 .ascii " error - \0"
1541 00000d62 * .text
1542 00026B2A dd 8f00000d58 pushl $L381
1543 00026B30 fe 08 effffff505 callf $8,_writes
1544 00026B37 # writes( msg );
1545 00026B37 dd ad04 pushl 4(fp)
1546 00026B3A fe 08 effffff4fb callf $8,_writes
1547 00026B41 # writec('\n');
1548 00026B41 dd 0a pushl $10
1549 00026B43 fe 08 effffff4f2 callf $8,_writec
1550 00026B4A # writes(" LDF(op1), SUBF(op1), SUBF(op1), ADDF(op1), ADDF(op1), STF\n");
1551 00026B4A .data 1
1552 00000d62 * L383:
1553 00000d62 * 204C4446286F7031292C20535 .ascii " LDF(op1), SUBF(op1), SUBF(op1), ADDF(op1), ADDF(op1), STF\12\0"
54246286F7031292C20535542
46286F7031292C20414444462
86F7031292C2041444446286F
7031292C205354460A00
1554 00000d9e * .text
1555 00026B4A dd 8f00000d62 pushl $L383
1556 00026B50 fe 08 effffff4e5 callf $8,_writes
1557 00026B57 # writes("operand = ");
1558 00026B57 .data 1
1559 00000d9e * L384:
1560 00000d9e * 6F706572616E64203D2000 .ascii "operand = \0"
1561 00000da9 * .text
1562 00026B57 dd 8f00000d9e pushl $L384
1563 00026B5D fe 08 effffff4d8 callf $8,_writes
1564 00026B64 # write32h( sgl_value_1 );
1565 00026B64 dd effffff4d2 pushl _sgl_value_1
1566 00026B6A fe 08 effffff4cb callf $8,_write32h
1567 00026B71 # writes(", final Acc = ");
1568 00026B71 .data 1
1569 00000da9 * L385:
1570 00000da9 * 2C20202066696E616C2041636 .ascii ", final Acc = \0"
3203D2000
1571 00000dba * .text
1572 00026B71 dd 8f00000da9 pushl $L385
1573 00026B77 fe 08 effffff4be callf $8,_writes
1574 00026B7E # write32h( sgl_st_acc );
1575 00026B7E dd effffff4b8 pushl _sgl_st_acc
1576 00026B84 fe 08 effffff4b1 callf $8,_write32h
1577 00026B8B # writes(", data index = ");
1578 00026B8B .data 1
1579 00000dba * L386:
1580 00000dba * 2C2020206461746120696E646 .ascii ", data index = \0"
578203D2000
1581 00000dcc * .text
1582 00026B8B dd 8f00000dba pushl $L386
1583 00026B91 fe 08 effffff4a4 callf $8,_writes
1584 00026B98 # writed( index );
1585 00026B98 dd effffff49e pushl _index
1586 00026B9E fe 08 effffff497 callf $8,_writed
1587 00026BA5 # writec('\n');
1588 00026BA5 dd 0a pushl $10
1589 00026BA7 fe 08 effffff48e callf $8,_writec
1590 00026BAE # writes(" expected Acc = ");
1591 00026BAE .data 1
1592 00000dcc * L387:
1593 00000dcc * 2020202020202020202020202 .ascii " expected Acc = \0"
0202020202020657870656374
656420416363203D2000
1594 00000def * .text
1595 00026BAE dd 8f00000dcc pushl $L387
1596 00026BB4 fe 08 effffff481 callf $8,_writes
1597 00026BBB # write32h( sgl_expected );
1598 00026BBB dd effffff47b pushl _sgl_expected
1599 00026BC1 fe 08 effffff474 callf $8,_write32h
1600 00026BC8 # writec('\n');
1601 00026BC8 dd 0a pushl $10
1602 00026BCA fe 08 effffff46b callf $8,_writec
1603 00026BD1 # }
1604 00026BD1 40 ret#2
1605 00026BD2 .set L372,0x0
1606 00026BD2 L374:
1607 00026BD2 13 fefa jbr L375
1608 00026BD5 .data
1609 00000c00 * .text
1610 00026BD5 00 .align 1
1611 00026BD6 .globl _pipe1_er_hlt
1612 00026BD6 _pipe1_er_hlt:
1613 00026BD6 0000 .word L388
1614 00026BD8 #
1615 00026BD8 #
1616 00026BD8 #
1617 00026BD8 #
1618 00026BD8 #
1619 00026BD8 # /******************************************************************************
1620 00026BD8 # *
1621 00026BD8 # * HALT ON ERROR ROUTINE
1622 00026BD8 # *
1623 00026BD8 # * halt with the necessary information saved in the registers
1624 00026BD8 # *
1625 00026BD8 # ******************************************************************************/
1626 00026BD8 # pipe1_er_hlt( subtest )
1627 00026BD8 # int subtest;
1628 00026BD8 # {
1629 00026BD8 11 60 jbr L390
1630 00026BDA L391:
1631 00026BDA # asm("movl _test_no,r0"); /* r0 = test number */
1632 00026BDA 0d effffff45c 50 movl _test_no,r0
1633 00026BE1 # asm("movl _subtest,r1"); /* r1 = subtest number */
1634 00026BE1 0d effffff455 51 movl _subtest,r1
1635 00026BE8 # asm("movl $1,r2"); /* r2 = error code */
1636 00026BE8 0d 01 52 movl $1,r2
1637 00026BEB # asm("movl _cycle,r3"); /* r3 = cycle count */
1638 00026BEB 0d effffff44b 53 movl _cycle,r3
1639 00026BF2 # asm("movl _sgl_value_1,r4"); /* r4 = sgl operand */
1640 00026BF2 0d effffff444 54 movl _sgl_value_1,r4
1641 00026BF9 # asm("movl _sgl_st_acc,r5"); /* r5 = sgl stored */
1642 00026BF9 0d effffff43d 55 movl _sgl_st_acc,r5
1643 00026C00 # asm("movl _sgl_expected,r6"); /* r6 = sgl expected */
1644 00026C00 0d effffff436 56 movl _sgl_expected,r6
1645 00026C07 # asm("movl _index,r7"); /* r7 = data index */
1646 00026C07 0d effffff42f 57 movl _index,r7
1647 00026C0E # if( subtest == 9 ) {
1648 00026C0E 1d ad04 09 cmpl 4(fp),$9
1649 00026C12 21 10 jneq L392
1650 00026C14 # asm("movl _sgl_value_3,r8"); /* r8 = final SP value */
1651 00026C14 0d effffff422 58 movl _sgl_value_3,r8
1652 00026C1B # asm("movl _sgl_value_2,r9"); /* r9 = expected SP value */
1653 00026C1B 0d effffff41b 59 movl _sgl_value_2,r9
1654 00026C22 # } else
1655 00026C22 11 14 jbr L393
1656 00026C24 L392:
1657 00026C24 # if( subtest == 10 ) {
1658 00026C24 1d ad04 0a cmpl 4(fp),$10
1659 00026C28 21 0e jneq L394
1660 00026C2A # asm("movl _sgl_value_3,r8"); /* r8 = final FP value */
1661 00026C2A 0d effffff40c 58 movl _sgl_value_3,r8
1662 00026C31 # asm("movl _sgl_value_2,r9"); /* r9 = expected FP value */
1663 00026C31 0d effffff405 59 movl _sgl_value_2,r9
1664 00026C38 # };
1665 00026C38 L394:
1666 00026C38 L393:
1667 00026C38 # asm(".globl _pipe1_1_hlt");
1668 00026C38 .globl _pipe1_1_hlt
1669 00026C38 # asm("_pipe1_1_hlt:"); /* PC after the halt */
1670 00026C38 _pipe1_1_hlt:
1671 00026C38 # asm("halt"); /* HALT ... */
1672 00026C38 00 halt
1673 00026C39 # } /* end of halt on error */
1674 00026C39 40 ret#2
1675 00026C3A .set L388,0x0
1676 00026C3A L390:
1677 00026C3A 11 9e jbr L391
1678 00000c00 * .data
1678 00000c00 * .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.