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