![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe11.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 pipe11.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 000005a8 * .text
4: 4 00000000 .align 1
5: 5 00000000 .globl _pipe_11
6: 6 00000000 _pipe_11:
7: 7 0002CF54 0000 .word L215
8: 8 0002CF56 # #include "fpp_defs.h"
9: 9 0002CF56 #
10: 10 0002CF56 #
11: 11 0002CF56 # /*****************************************************************************
12: 12 0002CF56 # *
13: 13 0002CF56 # * PIPELINE TEST #11 MONITOR
14: 14 0002CF56 # *
15: 15 0002CF56 # * This test will do a series of 2, 3, 4, 5, and 6 NEGFs.
16: 16 0002CF56 # *
17: 17 0002CF56 # *****************************************************************************/
18: 18 0002CF56 # pipe_11()
19: 19 0002CF56 # {
20: 20 0002CF56 11 48 jbr L217
21: 21 0002CF58 L218:
22: 22 0002CF58 # asm(".globl _pipeline_11_t");
23: 23 0002CF58 .globl _pipeline_11_t
24: 24 0002CF58 # asm("_pipeline_11_t:"); /* entry address */
25: 25 0002CF58 _pipeline_11_t:
26: 26 0002CF58 # if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */
27: 27 0002CF58 1d effffffff6 01 cmpl _cycle,$1
28: 28 0002CF5F 21 15 jneq L219
29: 29 0002CF61 5d efffffffed tstl _prt_hdrs
30: 30 0002CF67 31 0d jeql L219
31: 31 0002CF69 # {
32: 32 0002CF69 # writes(" PIPE_11");
33: 33 0002CF69 .data 1
34: 34 000005a8 * L221:
35: 35 000005a8 * 20504950455F313100 .ascii " PIPE_11\0"
36: 36 000005b1 * .text
37: 37 0002CF69 dd 8f000005a8 pushl $L221
38: 38 0002CF6F fe 08 efffffffde callf $8,_writes
39: 39 0002CF76 # }
40: 40 0002CF76 # pipe11_1(); /* do 2 NEGFs */
41: 41 0002CF76 L219:
42: 42 0002CF76 fe 04 ef00000025 callf $4,_pipe11_1
43: 43 0002CF7D # pipe11_2(); /* do 3 NEGFs */
44: 44 0002CF7D fe 04 ef000000e2 callf $4,_pipe11_2
45: 45 0002CF84 # pipe11_3(); /* do 4 NEGFs */
46: 46 0002CF84 fe 04 ef000001b3 callf $4,_pipe11_3
47: 47 0002CF8B # pipe11_4(); /* do 5 NEGFs */
48: 48 0002CF8B fe 04 ef00000272 callf $4,_pipe11_4
49: 49 0002CF92 # pipe11_5(); /* do 6 NEGFs */
50: 50 0002CF92 fe 04 ef00000345 callf $4,_pipe11_5
51: 51 0002CF99 # asm("jmp *return"); /* return to the test monitor */
52: 52 0002CF99 71 ffffffffb5 jmp *return
53: 53 0002CF9F # }
54: 54 0002CF9F 40 ret#2
55: 55 0002CFA0 .set L215,0x0
56: 56 0002CFA0 L217:
57: 57 0002CFA0 11 b6 jbr L218
58: 58 0002CFA2 .data
59: 59 000005a8 * .text
60: 60 0002CFA2 .align 1
61: 61 0002CFA2 .globl _pipe11_1
62: 62 0002CFA2 _pipe11_1:
63: 63 0002CFA2 0000 .word L227
64: 64 0002CFA4 #
65: 65 0002CFA4 #
66: 66 0002CFA4 #
67: 67 0002CFA4 #
68: 68 0002CFA4 #
69: 69 0002CFA4 #
70: 70 0002CFA4 # /************************************************************************
71: 71 0002CFA4 # *
72: 72 0002CFA4 # * SUBTEST 1 : 2 NEGFs
73: 73 0002CFA4 # *
74: 74 0002CFA4 # ************************************************************************/
75: 75 0002CFA4 # pipe11_1()
76: 76 0002CFA4 # {
77: 77 0002CFA4 13 00bb jbr L229
78: 78 0002CFA7 L230:
79: 79 0002CFA7 # subtest = 1;
80: 80 0002CFA7 0d 01 efffffffa6 movl $1,_subtest
81: 81 0002CFAE # force_loop = FALSE;
82: 82 0002CFAE 4d efffffffa0 clrl _force_loop
83: 83 0002CFB4 # for( index = 0; index < max_ldf_1_index; index++ )
84: 84 0002CFB4 4d efffffff9a clrl _index
85: 85 0002CFBA L233:
86: 86 0002CFBA 1d efffffff94 efffffff8f cmpl _index,_max_ldf_1_index
87: 87 0002CFC5 91 03 13 0097 jgeq L232
88: 88 0002CFCA # {
89: 89 0002CFCA # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
90: 90 0002CFCA 0d efffffff84 50 movl _index,r0
91: 91 0002CFD1 48 03 50 50 shll $3,r0,r0
92: 92 0002CFD5 0d e000000000 efffffff74 movl _ldf_1_data(r0),_sgl_value_1
93: 93 0002CFE0 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
94: 94 0002CFE0 0d efffffff6e 50 movl _index,r0
95: 95 0002CFE7 48 03 50 50 shll $3,r0,r0
96: 96 0002CFEB 0d e000000004 efffffff5e movl _ldf_1_data+4(r0),_sgl_expected
97: 97 0002CFF6 # /*
98: 98 0002CFF6 # * If LOOP ON ERROR is set, this is the loop for this subtest.
99: 99 0002CFF6 # * The force loop flag is set after the first error.
100: 100 0002CFF6 # */
101: 101 0002CFF6 # asm("_pipe11_1_lp1:");
102: 102 0002CFF6 _pipe11_1_lp1:
103: 103 0002CFF6 # asm("ldf _sgl_value_1"); /* load the operand */
104: 104 0002CFF6 06 efffffff58 ldf _sgl_value_1
105: 105 0002CFFC # asm("negf"); /* negate it ( twice ) */
106: 106 0002CFFC b6 negf
107: 107 0002CFFD # asm("negf");
108: 108 0002CFFD b6 negf
109: 109 0002CFFE # asm("stf _sgl_st_acc"); /* store the result */
110: 110 0002CFFE 26 efffffff50 stf _sgl_st_acc
111: 111 0002D004 # if( force_loop )
112: 112 0002D004 5d efffffff4a tstl _force_loop
113: 113 0002D00A 31 02 jeql L234
114: 114 0002D00C # asm("brb _pipe11_1_lp1"); /* loop on an error */
115: 115 0002D00C 11 e8 brb _pipe11_1_lp1
116: 116 0002D00E # /*
117: 117 0002D00E # * verify the results
118: 118 0002D00E # */
119: 119 0002D00E # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
120: 120 0002D00E L234:
121: 121 0002D00E 1d efffffff40 efffffff3b cmpl _sgl_st_acc,_sgl_expected
122: 122 0002D019 31 3d jeql L235
123: 123 0002D01B # errcnt++; /* bump the error count */
124: 124 0002D01B 6d efffffff33 incl _errcnt
125: 125 0002D021 # if( prt_error )
126: 126 0002D021 5d efffffff2d tstl _prt_error
127: 127 0002D027 31 09 jeql L236
128: 128 0002D029 # pipe11_print( 2 ); /* print error msg -2 NEGFS*/
129: 129 0002D029 dd 02 pushl $2
130: 130 0002D02B fe 08 ef00000374 callf $8,_pipe11_print
131: 131 0002D032 # if( halt_flg ) /* halt on error? */
132: 132 0002D032 L236:
133: 133 0002D032 5d efffffff1c tstl _halt_flg
134: 134 0002D038 31 09 jeql L238
135: 135 0002D03A # pipe11_halt( 2 ); /* error halt -2 NEGFS */
136: 136 0002D03A dd 02 pushl $2
137: 137 0002D03C fe 08 ef0000046b callf $8,_pipe11_halt
138: 138 0002D043 # if( loop_on_err ) {
139: 139 0002D043 L238:
140: 140 0002D043 5d efffffff0b tstl _loop_on_err
141: 141 0002D049 31 0d jeql L240
142: 142 0002D04B # force_loop = TRUE; /* set the force loop flag */
143: 143 0002D04B 0d 01 efffffff02 movl $1,_force_loop
144: 144 0002D052 # asm("jmp _pipe11_1_lp1"); /* and loop */
145: 145 0002D052 71 efffffff9e jmp _pipe11_1_lp1
146: 146 0002D058 # }
147: 147 0002D058 # }
148: 148 0002D058 L240:
149: 149 0002D058 # } /* end of FOR loop */
150: 150 0002D058 L235:
151: 151 0002D058 L231:
152: 152 0002D058 6d effffffef6 incl _index
153: 153 0002D05E 13 ff59 jbr L233
154: 154 0002D061 L232:
155: 155 0002D061 # } /* end of subtest 1 */
156: 156 0002D061 40 ret#2
157: 157 0002D062 .set L227,0x0
158: 158 0002D062 L229:
159: 159 0002D062 13 ff42 jbr L230
160: 160 0002D065 .data
161: 161 000005a8 * .text
162: 162 0002D065 00 .align 1
163: 163 0002D066 .globl _pipe11_2
164: 164 0002D066 _pipe11_2:
165: 165 0002D066 0000 .word L241
166: 166 0002D068 #
167: 167 0002D068 #
168: 168 0002D068 #
169: 169 0002D068 #
170: 170 0002D068 #
171: 171 0002D068 # /************************************************************************
172: 172 0002D068 # *
173: 173 0002D068 # * SUBTEST 2 : 3 NEGFs
174: 174 0002D068 # *
175: 175 0002D068 # ************************************************************************/
176: 176 0002D068 # pipe11_2()
177: 177 0002D068 # {
178: 178 0002D068 13 00cf jbr L243
179: 179 0002D06B L244:
180: 180 0002D06B # subtest = 2;
181: 181 0002D06B 0d 02 effffffee2 movl $2,_subtest
182: 182 0002D072 # force_loop = FALSE;
183: 183 0002D072 4d effffffedc clrl _force_loop
184: 184 0002D078 # for( index = 0; index < max_ldf_1_index; index++ )
185: 185 0002D078 4d effffffed6 clrl _index
186: 186 0002D07E L247:
187: 187 0002D07E 1d effffffed0 effffffecb cmpl _index,_max_ldf_1_index
188: 188 0002D089 91 03 13 00ab jgeq L246
189: 189 0002D08E # {
190: 190 0002D08E # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
191: 191 0002D08E 0d effffffec0 50 movl _index,r0
192: 192 0002D095 48 03 50 50 shll $3,r0,r0
193: 193 0002D099 0d e000000000 effffffeb0 movl _ldf_1_data(r0),_sgl_value_1
194: 194 0002D0A4 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
195: 195 0002D0A4 0d effffffeaa 50 movl _index,r0
196: 196 0002D0AB 48 03 50 50 shll $3,r0,r0
197: 197 0002D0AF 0d e000000004 effffffe9a movl _ldf_1_data+4(r0),_sgl_expected
198: 198 0002D0BA # if( sgl_expected )
199: 199 0002D0BA 5d effffffe94 tstl _sgl_expected
200: 200 0002D0C0 31 0b jeql L248
201: 201 0002D0C2 # sgl_expected ^= 0x80000000; /* negate exptd results */
202: 202 0002D0C2 cc 8f80000000 effffffe87 xorl2 $-2147483648,_sgl_expected
203: 203 0002D0CD # /*
204: 204 0002D0CD # * If LOOP ON ERROR is set, this is the loop for this subtest.
205: 205 0002D0CD # * The force loop flag is set after the first error.
206: 206 0002D0CD # */
207: 207 0002D0CD # asm("_pipe11_2_lp1:");
208: 208 0002D0CD L248:
209: 209 0002D0CD _pipe11_2_lp1:
210: 210 0002D0CD # asm("ldf _sgl_value_1"); /* load the operand */
211: 211 0002D0CD 06 effffffe81 ldf _sgl_value_1
212: 212 0002D0D3 # asm("negf"); /* negate it ( 3 times ) */
213: 213 0002D0D3 b6 negf
214: 214 0002D0D4 # asm("negf");
215: 215 0002D0D4 b6 negf
216: 216 0002D0D5 # asm("negf");
217: 217 0002D0D5 b6 negf
218: 218 0002D0D6 # asm("stf _sgl_st_acc"); /* store the result */
219: 219 0002D0D6 26 effffffe78 stf _sgl_st_acc
220: 220 0002D0DC # if( force_loop )
221: 221 0002D0DC 5d effffffe72 tstl _force_loop
222: 222 0002D0E2 31 02 jeql L249
223: 223 0002D0E4 # asm("brb _pipe11_2_lp1"); /* loop on an error */
224: 224 0002D0E4 11 e7 brb _pipe11_2_lp1
225: 225 0002D0E6 # /*
226: 226 0002D0E6 # * verify the results
227: 227 0002D0E6 # */
228: 228 0002D0E6 # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
229: 229 0002D0E6 L249:
230: 230 0002D0E6 1d effffffe68 effffffe63 cmpl _sgl_st_acc,_sgl_expected
231: 231 0002D0F1 31 3d jeql L250
232: 232 0002D0F3 # errcnt++; /* bump the error count */
233: 233 0002D0F3 6d effffffe5b incl _errcnt
234: 234 0002D0F9 # if( prt_error )
235: 235 0002D0F9 5d effffffe55 tstl _prt_error
236: 236 0002D0FF 31 09 jeql L251
237: 237 0002D101 # pipe11_print( 3 ); /* print error msg -3 NEGFS*/
238: 238 0002D101 dd 03 pushl $3
239: 239 0002D103 fe 08 ef0000029c callf $8,_pipe11_print
240: 240 0002D10A # if( halt_flg ) /* halt on error? */
241: 241 0002D10A L251:
242: 242 0002D10A 5d effffffe44 tstl _halt_flg
243: 243 0002D110 31 09 jeql L252
244: 244 0002D112 # pipe11_halt( 3 ); /* error halt -3 NEGFS */
245: 245 0002D112 dd 03 pushl $3
246: 246 0002D114 fe 08 ef00000393 callf $8,_pipe11_halt
247: 247 0002D11B # if( loop_on_err ) {
248: 248 0002D11B L252:
249: 249 0002D11B 5d effffffe33 tstl _loop_on_err
250: 250 0002D121 31 0d jeql L253
251: 251 0002D123 # force_loop = TRUE; /* set the force loop flag */
252: 252 0002D123 0d 01 effffffe2a movl $1,_force_loop
253: 253 0002D12A # asm("jmp _pipe11_2_lp1"); /* and loop */
254: 254 0002D12A 71 efffffff9d jmp _pipe11_2_lp1
255: 255 0002D130 # }
256: 256 0002D130 # }
257: 257 0002D130 L253:
258: 258 0002D130 # } /* end of FOR loop */
259: 259 0002D130 L250:
260: 260 0002D130 L245:
261: 261 0002D130 6d effffffe1e incl _index
262: 262 0002D136 13 ff45 jbr L247
263: 263 0002D139 L246:
264: 264 0002D139 # } /* end of subtest 2 */
265: 265 0002D139 40 ret#2
266: 266 0002D13A .set L241,0x0
267: 267 0002D13A L243:
268: 268 0002D13A 13 ff2e jbr L244
269: 269 0002D13D .data
270: 270 000005a8 * .text
271: 271 0002D13D 00 .align 1
272: 272 0002D13E .globl _pipe11_3
273: 273 0002D13E _pipe11_3:
274: 274 0002D13E 0000 .word L254
275: 275 0002D140 #
276: 276 0002D140 #
277: 277 0002D140 #
278: 278 0002D140 #
279: 279 0002D140 #
280: 280 0002D140 # /************************************************************************
281: 281 0002D140 # *
282: 282 0002D140 # * SUBTEST 3 : 4 NEGFs
283: 283 0002D140 # *
284: 284 0002D140 # ************************************************************************/
285: 285 0002D140 # pipe11_3()
286: 286 0002D140 # {
287: 287 0002D140 13 00bd jbr L256
288: 288 0002D143 L257:
289: 289 0002D143 # subtest = 3;
290: 290 0002D143 0d 03 effffffe0a movl $3,_subtest
291: 291 0002D14A # force_loop = FALSE;
292: 292 0002D14A 4d effffffe04 clrl _force_loop
293: 293 0002D150 # for( index = 0; index < max_ldf_1_index; index++ )
294: 294 0002D150 4d effffffdfe clrl _index
295: 295 0002D156 L260:
296: 296 0002D156 1d effffffdf8 effffffdf3 cmpl _index,_max_ldf_1_index
297: 297 0002D161 91 03 13 0099 jgeq L259
298: 298 0002D166 # {
299: 299 0002D166 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
300: 300 0002D166 0d effffffde8 50 movl _index,r0
301: 301 0002D16D 48 03 50 50 shll $3,r0,r0
302: 302 0002D171 0d e000000000 effffffdd8 movl _ldf_1_data(r0),_sgl_value_1
303: 303 0002D17C # sgl_expected = ldf_1_data[index].exp; /* get expected results */
304: 304 0002D17C 0d effffffdd2 50 movl _index,r0
305: 305 0002D183 48 03 50 50 shll $3,r0,r0
306: 306 0002D187 0d e000000004 effffffdc2 movl _ldf_1_data+4(r0),_sgl_expected
307: 307 0002D192 # /*
308: 308 0002D192 # * If LOOP ON ERROR is set, this is the loop for this subtest.
309: 309 0002D192 # * The force loop flag is set after the first error.
310: 310 0002D192 # */
311: 311 0002D192 # asm("_pipe11_3_lp1:");
312: 312 0002D192 _pipe11_3_lp1:
313: 313 0002D192 # asm("ldf _sgl_value_1"); /* load the operand */
314: 314 0002D192 06 effffffdbc ldf _sgl_value_1
315: 315 0002D198 # asm("negf"); /* negate it ( 4 times ) */
316: 316 0002D198 b6 negf
317: 317 0002D199 # asm("negf");
318: 318 0002D199 b6 negf
319: 319 0002D19A # asm("negf");
320: 320 0002D19A b6 negf
321: 321 0002D19B # asm("negf");
322: 322 0002D19B b6 negf
323: 323 0002D19C # asm("stf _sgl_st_acc"); /* store the result */
324: 324 0002D19C 26 effffffdb2 stf _sgl_st_acc
325: 325 0002D1A2 # if( force_loop )
326: 326 0002D1A2 5d effffffdac tstl _force_loop
327: 327 0002D1A8 31 02 jeql L261
328: 328 0002D1AA # asm("brb _pipe11_3_lp1"); /* loop on an error */
329: 329 0002D1AA 11 e6 brb _pipe11_3_lp1
330: 330 0002D1AC # /*
331: 331 0002D1AC # * verify the results
332: 332 0002D1AC # */
333: 333 0002D1AC # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
334: 334 0002D1AC L261:
335: 335 0002D1AC 1d effffffda2 effffffd9d cmpl _sgl_st_acc,_sgl_expected
336: 336 0002D1B7 31 3d jeql L262
337: 337 0002D1B9 # errcnt++; /* bump the error count */
338: 338 0002D1B9 6d effffffd95 incl _errcnt
339: 339 0002D1BF # if( prt_error )
340: 340 0002D1BF 5d effffffd8f tstl _prt_error
341: 341 0002D1C5 31 09 jeql L263
342: 342 0002D1C7 # pipe11_print( 4 ); /* print error msg -4 NEGFS*/
343: 343 0002D1C7 dd 04 pushl $4
344: 344 0002D1C9 fe 08 ef000001d6 callf $8,_pipe11_print
345: 345 0002D1D0 # if( halt_flg ) /* halt on error? */
346: 346 0002D1D0 L263:
347: 347 0002D1D0 5d effffffd7e tstl _halt_flg
348: 348 0002D1D6 31 09 jeql L264
349: 349 0002D1D8 # pipe11_halt( 4 ); /* error halt -4 NEGFS */
350: 350 0002D1D8 dd 04 pushl $4
351: 351 0002D1DA fe 08 ef000002cd callf $8,_pipe11_halt
352: 352 0002D1E1 # if( loop_on_err ) {
353: 353 0002D1E1 L264:
354: 354 0002D1E1 5d effffffd6d tstl _loop_on_err
355: 355 0002D1E7 31 0d jeql L265
356: 356 0002D1E9 # force_loop = TRUE; /* set the force loop flag */
357: 357 0002D1E9 0d 01 effffffd64 movl $1,_force_loop
358: 358 0002D1F0 # asm("jmp _pipe11_3_lp1"); /* and loop */
359: 359 0002D1F0 71 efffffff9c jmp _pipe11_3_lp1
360: 360 0002D1F6 # }
361: 361 0002D1F6 # }
362: 362 0002D1F6 L265:
363: 363 0002D1F6 # } /* end of FOR loop */
364: 364 0002D1F6 L262:
365: 365 0002D1F6 L258:
366: 366 0002D1F6 6d effffffd58 incl _index
367: 367 0002D1FC 13 ff57 jbr L260
368: 368 0002D1FF L259:
369: 369 0002D1FF # } /* end of subtest 3 */
370: 370 0002D1FF 40 ret#2
371: 371 0002D200 .set L254,0x0
372: 372 0002D200 L256:
373: 373 0002D200 13 ff40 jbr L257
374: 374 0002D203 .data
375: 375 000005a8 * .text
376: 376 0002D203 00 .align 1
377: 377 0002D204 .globl _pipe11_4
378: 378 0002D204 _pipe11_4:
379: 379 0002D204 0000 .word L266
380: 380 0002D206 #
381: 381 0002D206 #
382: 382 0002D206 #
383: 383 0002D206 #
384: 384 0002D206 #
385: 385 0002D206 #
386: 386 0002D206 # /************************************************************************
387: 387 0002D206 # *
388: 388 0002D206 # * SUBTEST 4 : 5 NEGFs
389: 389 0002D206 # *
390: 390 0002D206 # ************************************************************************/
391: 391 0002D206 # pipe11_4()
392: 392 0002D206 # {
393: 393 0002D206 13 00d1 jbr L268
394: 394 0002D209 L269:
395: 395 0002D209 # subtest = 4;
396: 396 0002D209 0d 04 effffffd44 movl $4,_subtest
397: 397 0002D210 # force_loop = FALSE;
398: 398 0002D210 4d effffffd3e clrl _force_loop
399: 399 0002D216 # for( index = 0; index < max_ldf_1_index; index++ )
400: 400 0002D216 4d effffffd38 clrl _index
401: 401 0002D21C L272:
402: 402 0002D21C 1d effffffd32 effffffd2d cmpl _index,_max_ldf_1_index
403: 403 0002D227 91 03 13 00ad jgeq L271
404: 404 0002D22C # {
405: 405 0002D22C # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
406: 406 0002D22C 0d effffffd22 50 movl _index,r0
407: 407 0002D233 48 03 50 50 shll $3,r0,r0
408: 408 0002D237 0d e000000000 effffffd12 movl _ldf_1_data(r0),_sgl_value_1
409: 409 0002D242 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
410: 410 0002D242 0d effffffd0c 50 movl _index,r0
411: 411 0002D249 48 03 50 50 shll $3,r0,r0
412: 412 0002D24D 0d e000000004 effffffcfc movl _ldf_1_data+4(r0),_sgl_expected
413: 413 0002D258 # if( sgl_expected )
414: 414 0002D258 5d effffffcf6 tstl _sgl_expected
415: 415 0002D25E 31 0b jeql L273
416: 416 0002D260 # sgl_expected ^= 0x80000000; /* negate exptd results */
417: 417 0002D260 cc 8f80000000 effffffce9 xorl2 $-2147483648,_sgl_expected
418: 418 0002D26B # /*
419: 419 0002D26B # * If LOOP ON ERROR is set, this is the loop for this subtest.
420: 420 0002D26B # * The force loop flag is set after the first error.
421: 421 0002D26B # */
422: 422 0002D26B # asm("_pipe11_4_lp1:");
423: 423 0002D26B L273:
424: 424 0002D26B _pipe11_4_lp1:
425: 425 0002D26B # asm("ldf _sgl_value_1"); /* load the operand */
426: 426 0002D26B 06 effffffce3 ldf _sgl_value_1
427: 427 0002D271 # asm("negf"); /* negate it ( 5 times ) */
428: 428 0002D271 b6 negf
429: 429 0002D272 # asm("negf");
430: 430 0002D272 b6 negf
431: 431 0002D273 # asm("negf");
432: 432 0002D273 b6 negf
433: 433 0002D274 # asm("negf");
434: 434 0002D274 b6 negf
435: 435 0002D275 # asm("negf");
436: 436 0002D275 b6 negf
437: 437 0002D276 # asm("stf _sgl_st_acc"); /* store the result */
438: 438 0002D276 26 effffffcd8 stf _sgl_st_acc
439: 439 0002D27C # if( force_loop )
440: 440 0002D27C 5d effffffcd2 tstl _force_loop
441: 441 0002D282 31 02 jeql L274
442: 442 0002D284 # asm("brb _pipe11_4_lp1"); /* loop on an error */
443: 443 0002D284 11 e5 brb _pipe11_4_lp1
444: 444 0002D286 # /*
445: 445 0002D286 # * verify the results
446: 446 0002D286 # */
447: 447 0002D286 # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
448: 448 0002D286 L274:
449: 449 0002D286 1d effffffcc8 effffffcc3 cmpl _sgl_st_acc,_sgl_expected
450: 450 0002D291 31 3d jeql L275
451: 451 0002D293 # errcnt++; /* bump the error count */
452: 452 0002D293 6d effffffcbb incl _errcnt
453: 453 0002D299 # if( prt_error )
454: 454 0002D299 5d effffffcb5 tstl _prt_error
455: 455 0002D29F 31 09 jeql L276
456: 456 0002D2A1 # pipe11_print( 5 ); /* print error msg -5 NEGFS*/
457: 457 0002D2A1 dd 05 pushl $5
458: 458 0002D2A3 fe 08 ef000000fc callf $8,_pipe11_print
459: 459 0002D2AA # if( halt_flg ) /* halt on error? */
460: 460 0002D2AA L276:
461: 461 0002D2AA 5d effffffca4 tstl _halt_flg
462: 462 0002D2B0 31 09 jeql L277
463: 463 0002D2B2 # pipe11_halt( 5 ); /* error halt -5 NEGFS */
464: 464 0002D2B2 dd 05 pushl $5
465: 465 0002D2B4 fe 08 ef000001f3 callf $8,_pipe11_halt
466: 466 0002D2BB # if( loop_on_err ) {
467: 467 0002D2BB L277:
468: 468 0002D2BB 5d effffffc93 tstl _loop_on_err
469: 469 0002D2C1 31 0d jeql L278
470: 470 0002D2C3 # force_loop = TRUE; /* set the force loop flag */
471: 471 0002D2C3 0d 01 effffffc8a movl $1,_force_loop
472: 472 0002D2CA # asm("jmp _pipe11_4_lp1"); /* and loop */
473: 473 0002D2CA 71 efffffff9b jmp _pipe11_4_lp1
474: 474 0002D2D0 # }
475: 475 0002D2D0 # }
476: 476 0002D2D0 L278:
477: 477 0002D2D0 # } /* end of FOR loop */
478: 478 0002D2D0 L275:
479: 479 0002D2D0 L270:
480: 480 0002D2D0 6d effffffc7e incl _index
481: 481 0002D2D6 13 ff43 jbr L272
482: 482 0002D2D9 L271:
483: 483 0002D2D9 # } /* end of subtest 4 */
484: 484 0002D2D9 40 ret#2
485: 485 0002D2DA .set L266,0x0
486: 486 0002D2DA L268:
487: 487 0002D2DA 13 ff2c jbr L269
488: 488 0002D2DD .data
489: 489 000005a8 * .text
490: 490 0002D2DD 00 .align 1
491: 491 0002D2DE .globl _pipe11_5
492: 492 0002D2DE _pipe11_5:
493: 493 0002D2DE 0000 .word L279
494: 494 0002D2E0 #
495: 495 0002D2E0 #
496: 496 0002D2E0 #
497: 497 0002D2E0 #
498: 498 0002D2E0 #
499: 499 0002D2E0 # /************************************************************************
500: 500 0002D2E0 # *
501: 501 0002D2E0 # * SUBTEST 5 : 6 NEGFs
502: 502 0002D2E0 # *
503: 503 0002D2E0 # ************************************************************************/
504: 504 0002D2E0 # pipe11_5()
505: 505 0002D2E0 # {
506: 506 0002D2E0 13 00bf jbr L281
507: 507 0002D2E3 L282:
508: 508 0002D2E3 # subtest = 5;
509: 509 0002D2E3 0d 05 effffffc6a movl $5,_subtest
510: 510 0002D2EA # force_loop = FALSE;
511: 511 0002D2EA 4d effffffc64 clrl _force_loop
512: 512 0002D2F0 # for( index = 0; index < max_ldf_1_index; index++ )
513: 513 0002D2F0 4d effffffc5e clrl _index
514: 514 0002D2F6 L285:
515: 515 0002D2F6 1d effffffc58 effffffc53 cmpl _index,_max_ldf_1_index
516: 516 0002D301 91 03 13 009b jgeq L284
517: 517 0002D306 # {
518: 518 0002D306 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
519: 519 0002D306 0d effffffc48 50 movl _index,r0
520: 520 0002D30D 48 03 50 50 shll $3,r0,r0
521: 521 0002D311 0d e000000000 effffffc38 movl _ldf_1_data(r0),_sgl_value_1
522: 522 0002D31C # sgl_expected = ldf_1_data[index].exp; /* get expected results */
523: 523 0002D31C 0d effffffc32 50 movl _index,r0
524: 524 0002D323 48 03 50 50 shll $3,r0,r0
525: 525 0002D327 0d e000000004 effffffc22 movl _ldf_1_data+4(r0),_sgl_expected
526: 526 0002D332 # /*
527: 527 0002D332 # * If LOOP ON ERROR is set, this is the loop for this subtest.
528: 528 0002D332 # * The force loop flag is set after the first error.
529: 529 0002D332 # */
530: 530 0002D332 # asm("_pipe11_5_lp1:");
531: 531 0002D332 _pipe11_5_lp1:
532: 532 0002D332 # asm("ldf _sgl_value_1"); /* load the operand */
533: 533 0002D332 06 effffffc1c ldf _sgl_value_1
534: 534 0002D338 # asm("negf"); /* negate it ( 6 times ) */
535: 535 0002D338 b6 negf
536: 536 0002D339 # asm("negf");
537: 537 0002D339 b6 negf
538: 538 0002D33A # asm("negf");
539: 539 0002D33A b6 negf
540: 540 0002D33B # asm("negf");
541: 541 0002D33B b6 negf
542: 542 0002D33C # asm("negf");
543: 543 0002D33C b6 negf
544: 544 0002D33D # asm("negf");
545: 545 0002D33D b6 negf
546: 546 0002D33E # asm("stf _sgl_st_acc"); /* store the result */
547: 547 0002D33E 26 effffffc10 stf _sgl_st_acc
548: 548 0002D344 # if( force_loop )
549: 549 0002D344 5d effffffc0a tstl _force_loop
550: 550 0002D34A 31 02 jeql L286
551: 551 0002D34C # asm("brb _pipe11_5_lp1"); /* loop on an error */
552: 552 0002D34C 11 e4 brb _pipe11_5_lp1
553: 553 0002D34E # /*
554: 554 0002D34E # * verify the results
555: 555 0002D34E # */
556: 556 0002D34E # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
557: 557 0002D34E L286:
558: 558 0002D34E 1d effffffc00 effffffbfb cmpl _sgl_st_acc,_sgl_expected
559: 559 0002D359 31 3d jeql L287
560: 560 0002D35B # errcnt++; /* bump the error count */
561: 561 0002D35B 6d effffffbf3 incl _errcnt
562: 562 0002D361 # if( prt_error )
563: 563 0002D361 5d effffffbed tstl _prt_error
564: 564 0002D367 31 09 jeql L288
565: 565 0002D369 # pipe11_print( 6 ); /* print error msg -6 NEGFS*/
566: 566 0002D369 dd 06 pushl $6
567: 567 0002D36B fe 08 ef00000034 callf $8,_pipe11_print
568: 568 0002D372 # if( halt_flg ) /* halt on error? */
569: 569 0002D372 L288:
570: 570 0002D372 5d effffffbdc tstl _halt_flg
571: 571 0002D378 31 09 jeql L289
572: 572 0002D37A # pipe11_halt( 6 ); /* error halt -6 NEGFS */
573: 573 0002D37A dd 06 pushl $6
574: 574 0002D37C fe 08 ef0000012b callf $8,_pipe11_halt
575: 575 0002D383 # if( loop_on_err ) {
576: 576 0002D383 L289:
577: 577 0002D383 5d effffffbcb tstl _loop_on_err
578: 578 0002D389 31 0d jeql L290
579: 579 0002D38B # force_loop = TRUE; /* set the force loop flag */
580: 580 0002D38B 0d 01 effffffbc2 movl $1,_force_loop
581: 581 0002D392 # asm("jmp _pipe11_5_lp1"); /* and loop */
582: 582 0002D392 71 efffffff9a jmp _pipe11_5_lp1
583: 583 0002D398 # }
584: 584 0002D398 # }
585: 585 0002D398 L290:
586: 586 0002D398 # } /* end of FOR loop */
587: 587 0002D398 L287:
588: 588 0002D398 L283:
589: 589 0002D398 6d effffffbb6 incl _index
590: 590 0002D39E 13 ff55 jbr L285
591: 591 0002D3A1 L284:
592: 592 0002D3A1 # } /* end of subtest 5 */
593: 593 0002D3A1 40 ret#2
594: 594 0002D3A2 .set L279,0x0
595: 595 0002D3A2 L281:
596: 596 0002D3A2 13 ff3e jbr L282
597: 597 0002D3A5 .data
598: 598 000005a8 * .text
599: 599 0002D3A5 00 .align 1
600: 600 0002D3A6 .globl _pipe11_print
601: 601 0002D3A6 _pipe11_print:
602: 602 0002D3A6 0000 .word L291
603: 603 0002D3A8 #
604: 604 0002D3A8 #
605: 605 0002D3A8 #
606: 606 0002D3A8 #
607: 607 0002D3A8 # /****************************************************************************
608: 608 0002D3A8 # *
609: 609 0002D3A8 # * PRINT AN ERROR MESSAGE
610: 610 0002D3A8 # *
611: 611 0002D3A8 # * cycle dd PIPELINE 11, subtest dd error
612: 612 0002D3A8 # * LDF op, {NEGF}, STF
613: 613 0002D3A8 # * operand = xxxxxxxx, final Acc = xxxxxxxx, data index = xxxxxxxx
614: 614 0002D3A8 # * expected Acc = xxxxxxxx
615: 615 0002D3A8 # ****************************************************************************/
616: 616 0002D3A8 # pipe11_print( nop_count )
617: 617 0002D3A8 # int nop_count; /* # of NEGF instructions */
618: 618 0002D3A8 # {
619: 619 0002D3A8 13 0100 jbr L293
620: 620 0002D3AB L294:
621: 621 0002D3AB # writes(" \n"); /* start a new print line */
622: 622 0002D3AB .data 1
623: 623 000005b1 * L295:
624: 624 000005b1 * 200A00 .ascii " \12\0"
625: 625 000005b4 * .text
626: 626 0002D3AB dd 8f000005b1 pushl $L295
627: 627 0002D3B1 fe 08 effffffb9c callf $8,_writes
628: 628 0002D3B8 # writes("cycle: ");
629: 629 0002D3B8 .data 1
630: 630 000005b4 * L296:
631: 631 000005b4 * 6379636C653A2000 .ascii "cycle: \0"
632: 632 000005bc * .text
633: 633 0002D3B8 dd 8f000005b4 pushl $L296
634: 634 0002D3BE fe 08 effffffb8f callf $8,_writes
635: 635 0002D3C5 # writed( cycle );
636: 636 0002D3C5 dd effffffb89 pushl _cycle
637: 637 0002D3CB fe 08 effffffb82 callf $8,_writed
638: 638 0002D3D2 # writes(" (Pipe 11), subtest ");
639: 639 0002D3D2 .data 1
640: 640 000005bc * L298:
641: 641 000005bc * 20202850697065203131292C2 .ascii " (Pipe 11), subtest \0"
642: 0737562746573742000
643: 642 000005d2 * .text
644: 643 0002D3D2 dd 8f000005bc pushl $L298
645: 644 0002D3D8 fe 08 effffffb75 callf $8,_writes
646: 645 0002D3DF # writed( subtest );
647: 646 0002D3DF dd effffffb6f pushl _subtest
648: 647 0002D3E5 fe 08 effffffb68 callf $8,_writed
649: 648 0002D3EC # writes(" error\n");
650: 649 0002D3EC .data 1
651: 650 000005d2 * L299:
652: 651 000005d2 * 206572726F720A00 .ascii " error\12\0"
653: 652 000005da * .text
654: 653 0002D3EC dd 8f000005d2 pushl $L299
655: 654 0002D3F2 fe 08 effffffb5b callf $8,_writes
656: 655 0002D3F9 # writes(" LDF(op), NEGF");
657: 656 0002D3F9 .data 1
658: 657 000005da * L300:
659: 658 000005da * 204C4446286F70292C204E454 .ascii " LDF(op), NEGF\0"
660: 74600
661: 659 000005e9 * .text
662: 660 0002D3F9 dd 8f000005da pushl $L300
663: 661 0002D3FF fe 08 effffffb4e callf $8,_writes
664: 662 0002D406 # while( --nop_count )
665: 663 0002D406 L301:
666: 664 0002D406 7d ad04 decl 4(fp)
667: 665 0002D409 31 0f jeql L302
668: 666 0002D40B # writes(", NEGF");
669: 667 0002D40B .data 1
670: 668 000005e9 * L303:
671: 669 000005e9 * 2C204E45474600 .ascii ", NEGF\0"
672: 670 000005f0 * .text
673: 671 0002D40B dd 8f000005e9 pushl $L303
674: 672 0002D411 fe 08 effffffb3c callf $8,_writes
675: 673 0002D418 11 ec jbr L301
676: 674 0002D41A L302:
677: 675 0002D41A # writes(", STF\n");
678: 676 0002D41A .data 1
679: 677 000005f0 * L304:
680: 678 000005f0 * 2C205354460A00 .ascii ", STF\12\0"
681: 679 000005f7 * .text
682: 680 0002D41A dd 8f000005f0 pushl $L304
683: 681 0002D420 fe 08 effffffb2d callf $8,_writes
684: 682 0002D427 # writec('\n');
685: 683 0002D427 dd 0a pushl $10
686: 684 0002D429 fe 08 effffffb24 callf $8,_writec
687: 685 0002D430 # writes("operand = ");
688: 686 0002D430 .data 1
689: 687 000005f7 * L306:
690: 688 000005f7 * 6F706572616E64203D2000 .ascii "operand = \0"
691: 689 00000602 * .text
692: 690 0002D430 dd 8f000005f7 pushl $L306
693: 691 0002D436 fe 08 effffffb17 callf $8,_writes
694: 692 0002D43D # write32h( sgl_value_1 );
695: 693 0002D43D dd effffffb11 pushl _sgl_value_1
696: 694 0002D443 fe 08 effffffb0a callf $8,_write32h
697: 695 0002D44A # writes(", final Acc = ");
698: 696 0002D44A .data 1
699: 697 00000602 * L308:
700: 698 00000602 * 2C2020202066696E616C20416 .ascii ", final Acc = \0"
701: 363203D2000
702: 699 00000614 * .text
703: 700 0002D44A dd 8f00000602 pushl $L308
704: 701 0002D450 fe 08 effffffafd callf $8,_writes
705: 702 0002D457 # write32h( sgl_st_acc );
706: 703 0002D457 dd effffffaf7 pushl _sgl_st_acc
707: 704 0002D45D fe 08 effffffaf0 callf $8,_write32h
708: 705 0002D464 # writes(", data index = ");
709: 706 0002D464 .data 1
710: 707 00000614 * L309:
711: 708 00000614 * 2C2020206461746120696E646 .ascii ", data index = \0"
712: 578203D2000
713: 709 00000626 * .text
714: 710 0002D464 dd 8f00000614 pushl $L309
715: 711 0002D46A fe 08 effffffae3 callf $8,_writes
716: 712 0002D471 # writed( index );
717: 713 0002D471 dd effffffadd pushl _index
718: 714 0002D477 fe 08 effffffad6 callf $8,_writed
719: 715 0002D47E # writec('\n');
720: 716 0002D47E dd 0a pushl $10
721: 717 0002D480 fe 08 effffffacd callf $8,_writec
722: 718 0002D487 # writes(" expected Acc = ");
723: 719 0002D487 .data 1
724: 720 00000626 * L310:
725: 721 00000626 * 2020202020202020202020202 .ascii " expected Acc = \0"
726: 0202020202020206578706563
727: 74656420416363203D2000
728: 722 0000064a * .text
729: 723 0002D487 dd 8f00000626 pushl $L310
730: 724 0002D48D fe 08 effffffac0 callf $8,_writes
731: 725 0002D494 # write32h( sgl_expected );
732: 726 0002D494 dd effffffaba pushl _sgl_expected
733: 727 0002D49A fe 08 effffffab3 callf $8,_write32h
734: 728 0002D4A1 # writec('\n');
735: 729 0002D4A1 dd 0a pushl $10
736: 730 0002D4A3 fe 08 effffffaaa callf $8,_writec
737: 731 0002D4AA # }
738: 732 0002D4AA 40 ret#2
739: 733 0002D4AB .set L291,0x0
740: 734 0002D4AB L293:
741: 735 0002D4AB 13 fefd jbr L294
742: 736 0002D4AE .data
743: 737 000005a8 * .text
744: 738 0002D4AE .align 1
745: 739 0002D4AE .globl _pipe11_halt
746: 740 0002D4AE _pipe11_halt:
747: 741 0002D4AE 0000 .word L311
748: 742 0002D4B0 #
749: 743 0002D4B0 #
750: 744 0002D4B0 #
751: 745 0002D4B0 # /****************************************************************************
752: 746 0002D4B0 # *
753: 747 0002D4B0 # * SET UP THE REGISTERS AND HALT
754: 748 0002D4B0 # *
755: 749 0002D4B0 # ****************************************************************************/
756: 750 0002D4B0 # pipe11_halt( nop_count )
757: 751 0002D4B0 # int nop_count; /* # of NEGF instructions */
758: 752 0002D4B0 # {
759: 753 0002D4B0 11 45 jbr L313
760: 754 0002D4B2 L314:
761: 755 0002D4B2 # sgl_dummy1 = nop_count;
762: 756 0002D4B2 0d ad04 effffffa9a movl 4(fp),_sgl_dummy1
763: 757 0002D4BA # asm("movl _test_no,r0"); /* r0 = test number */
764: 758 0002D4BA 0d effffffa94 50 movl _test_no,r0
765: 759 0002D4C1 # asm("movl _subtest,r1"); /* r1 = subtest number */
766: 760 0002D4C1 0d effffffa8d 51 movl _subtest,r1
767: 761 0002D4C8 # asm("movl $1,r2"); /* r2 = error code */
768: 762 0002D4C8 0d 01 52 movl $1,r2
769: 763 0002D4CB # asm("movl _cycle,r3"); /* r3 = cycle count */
770: 764 0002D4CB 0d effffffa83 53 movl _cycle,r3
771: 765 0002D4D2 # asm("movl _sgl_dummy1,r4"); /* r4 = # of NEGFS */
772: 766 0002D4D2 0d effffffa7c 54 movl _sgl_dummy1,r4
773: 767 0002D4D9 # asm("movl _sgl_value_1,r5"); /* r5 = sgl operand */
774: 768 0002D4D9 0d effffffa75 55 movl _sgl_value_1,r5
775: 769 0002D4E0 # asm("movl _sgl_st_acc,r6"); /* r6 = sgl stored */
776: 770 0002D4E0 0d effffffa6e 56 movl _sgl_st_acc,r6
777: 771 0002D4E7 # asm("movl _sgl_expected,r7"); /* r7 = sgl expected */
778: 772 0002D4E7 0d effffffa67 57 movl _sgl_expected,r7
779: 773 0002D4EE # asm("movl _index,r8"); /* r8 = data index */
780: 774 0002D4EE 0d effffffa60 58 movl _index,r8
781: 775 0002D4F5 # asm("halt"); /* HALT ... */
782: 776 0002D4F5 00 halt
783: 777 0002D4F6 # }
784: 778 0002D4F6 40 ret#2
785: 779 0002D4F7 .set L311,0x0
786: 780 0002D4F7 L313:
787: 781 0002D4F7 11 b9 jbr L314
788: 782 0002D4F9 .data
789: 782 0005A44D .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.