![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe20.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 pipe20.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 000006bc * .text
4: 4 00000000 .align 1
5: 5 00000000 .globl _pipe_20
6: 6 00000000 _pipe_20:
7: 7 00033264 0000 .word L215
8: 8 00033266 # #include "fpp_defs.h"
9: 9 00033266 #
10: 10 00033266 #
11: 11 00033266 # /*****************************************************************************
12: 12 00033266 # *
13: 13 00033266 # * DBL PIPELINE TEST #20 MONITOR
14: 14 00033266 # *
15: 15 00033266 # * This test will do a series of 2, 3, 4, 5, and 6 NEGDs.
16: 16 00033266 # * The data used will be the LDD data patterns.
17: 17 00033266 # *
18: 18 00033266 # *****************************************************************************/
19: 19 00033266 # pipe_20()
20: 20 00033266 # {
21: 21 00033266 11 48 jbr L217
22: 22 00033268 L218:
23: 23 00033268 # asm(".globl _pipeline_20_t");
24: 24 00033268 .globl _pipeline_20_t
25: 25 00033268 # asm("_pipeline_20_t:"); /* entry address */
26: 26 00033268 _pipeline_20_t:
27: 27 00033268 # if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */
28: 28 00033268 1d effffffff6 01 cmpl _cycle,$1
29: 29 0003326F 21 15 jneq L219
30: 30 00033271 5d efffffffed tstl _prt_hdrs
31: 31 00033277 31 0d jeql L219
32: 32 00033279 # writes(" PIPE_20");
33: 33 00033279 .data 1
34: 34 000006bc * L221:
35: 35 000006bc * 20504950455F323000 .ascii " PIPE_20\0"
36: 36 000006c5 * .text
37: 37 00033279 dd 8f000006bc pushl $L221
38: 38 0003327F fe 08 efffffffde callf $8,_writes
39: 39 00033286 # pipe20_1(); /* 2 NOPs */
40: 40 00033286 L219:
41: 41 00033286 fe 04 ef00000025 callf $4,_pipe20_1
42: 42 0003328D # pipe20_2(); /* 3 NOPs */
43: 43 0003328D fe 04 ef000000fe callf $4,_pipe20_2
44: 44 00033294 # pipe20_3(); /* 4 NOPs */
45: 45 00033294 fe 04 ef000001eb callf $4,_pipe20_3
46: 46 0003329B # pipe20_4(); /* 5 NOPs */
47: 47 0003329B fe 04 ef000002c6 callf $4,_pipe20_4
48: 48 000332A2 # pipe20_5(); /* 6 NOPs */
49: 49 000332A2 fe 04 ef000003b5 callf $4,_pipe20_5
50: 50 000332A9 # asm("jmp *return"); /* return to the test monitor */
51: 51 000332A9 71 ffffffffb5 jmp *return
52: 52 000332AF # }
53: 53 000332AF 40 ret#2
54: 54 000332B0 .set L215,0x0
55: 55 000332B0 L217:
56: 56 000332B0 11 b6 jbr L218
57: 57 000332B2 .data
58: 58 000006bc * .text
59: 59 000332B2 .align 1
60: 60 000332B2 .globl _pipe20_1
61: 61 000332B2 _pipe20_1:
62: 62 000332B2 0000 .word L227
63: 63 000332B4 #
64: 64 000332B4 #
65: 65 000332B4 #
66: 66 000332B4 #
67: 67 000332B4 #
68: 68 000332B4 # /************************************************************************
69: 69 000332B4 # *
70: 70 000332B4 # * SUBTEST 1 : 2 NEGDs
71: 71 000332B4 # *
72: 72 000332B4 # ************************************************************************/
73: 73 000332B4 # pipe20_1()
74: 74 000332B4 # {
75: 75 000332B4 13 00d8 jbr L229
76: 76 000332B7 L230:
77: 77 000332B7 # subtest = 1;
78: 78 000332B7 0d 01 efffffffa6 movl $1,_subtest
79: 79 000332BE # force_loop = FALSE;
80: 80 000332BE 4d efffffffa0 clrl _force_loop
81: 81 000332C4 # for( index = 0; index < max_ldd_1_index; index++ )
82: 82 000332C4 4d efffffff9a clrl _index
83: 83 000332CA L233:
84: 84 000332CA 1d efffffff94 efffffff8f cmpl _index,_max_ldd_1_index
85: 85 000332D5 91 03 13 00b4 jgeq L232
86: 86 000332DA # {
87: 87 000332DA # dbl_value_1 = ldd_1_data[index].ld; /* get operand 1 */
88: 88 000332DA 48 04 efffffff83 50 shll $4,_index,r0
89: 89 000332E2 0c 8f00000000 50 addl2 $_ldd_1_data,r0
90: 90 000332E9 0d a004 efffffff77 movl 4(r0),_dbl_value_1+4
91: 91 000332F1 0d 60 efffffff6c movl (r0),_dbl_value_1
92: 92 000332F8 # dbl_expected = ldd_1_data[index].exp; /* get expected results */
93: 93 000332F8 48 04 efffffff65 50 shll $4,_index,r0
94: 94 00033300 0c 8f00000008 50 addl2 $_ldd_1_data+8,r0
95: 95 00033307 0d a004 efffffff59 movl 4(r0),_dbl_expected+4
96: 96 0003330F 0d 60 efffffff4e movl (r0),_dbl_expected
97: 97 00033316 # /*
98: 98 00033316 # * If LOOP ON ERROR is set, this is the loop for this subtest.
99: 99 00033316 # * The force loop flag is set after the first error.
100: 100 00033316 # */
101: 101 00033316 # asm("_pipe20_1_lp1:");
102: 102 00033316 _pipe20_1_lp1:
103: 103 00033316 # asm("ldd _dbl_value_1"); /* load the operand */
104: 104 00033316 07 efffffff48 ldd _dbl_value_1
105: 105 0003331C # asm("negd"); /* negate it ( twice ) */
106: 106 0003331C b7 negd
107: 107 0003331D # asm("negd");
108: 108 0003331D b7 negd
109: 109 0003331E # asm("std _dbl_st_acc"); /* store the result */
110: 110 0003331E 27 efffffff40 std _dbl_st_acc
111: 111 00033324 # if( force_loop )
112: 112 00033324 5d efffffff3a tstl _force_loop
113: 113 0003332A 31 02 jeql L234
114: 114 0003332C # asm("brb _pipe20_1_lp1"); /* loop on an error */
115: 115 0003332C 11 e8 brb _pipe20_1_lp1
116: 116 0003332E # /*
117: 117 0003332E # * verify the results
118: 118 0003332E # */
119: 119 0003332E # if( (dbl_st_acc.m != dbl_expected.m) || /* COMPARE the stored */
120: 120 0003332E L234:
121: 121 0003332E # (dbl_st_acc.l != dbl_expected.l) ) { /* to the expected */
122: 122 0003332E 1d efffffff30 efffffff2b cmpl _dbl_st_acc,_dbl_expected
123: 123 00033339 21 0d jneq L9999
124: 124 0003333B 1d efffffff27 efffffff22 cmpl _dbl_st_acc+4,_dbl_expected+4
125: 125 00033346 31 3d jeql L235
126: 126 00033348 L9999:
127: 127 00033348 # errcnt++; /* bump the error count */
128: 128 00033348 6d efffffff16 incl _errcnt
129: 129 0003334E # if( prt_error )
130: 130 0003334E 5d efffffff10 tstl _prt_error
131: 131 00033354 31 09 jeql L236
132: 132 00033356 # pipe20_print( 2 ); /* print error msg -2 NOPs */
133: 133 00033356 dd 02 pushl $2
134: 134 00033358 fe 08 ef000003e3 callf $8,_pipe20_print
135: 135 0003335F # if( halt_flg ) /* halt on error? */
136: 136 0003335F L236:
137: 137 0003335F 5d effffffeff tstl _halt_flg
138: 138 00033365 31 09 jeql L238
139: 139 00033367 # pipe20_halt( 2 ); /* error halt -2 NOPs */
140: 140 00033367 dd 02 pushl $2
141: 141 00033369 fe 08 ef0000050a callf $8,_pipe20_halt
142: 142 00033370 # if( loop_on_err ) {
143: 143 00033370 L238:
144: 144 00033370 5d effffffeee tstl _loop_on_err
145: 145 00033376 31 0d jeql L240
146: 146 00033378 # force_loop = TRUE; /* set the force loop flag */
147: 147 00033378 0d 01 effffffee5 movl $1,_force_loop
148: 148 0003337F # asm("jmp _pipe20_1_lp1"); /* and loop */
149: 149 0003337F 71 efffffff91 jmp _pipe20_1_lp1
150: 150 00033385 # }
151: 151 00033385 # }
152: 152 00033385 L240:
153: 153 00033385 # } /* end of FOR loop */
154: 154 00033385 L235:
155: 155 00033385 L231:
156: 156 00033385 6d effffffed9 incl _index
157: 157 0003338B 13 ff3c jbr L233
158: 158 0003338E L232:
159: 159 0003338E # } /* end of subtest 1 */
160: 160 0003338E 40 ret#2
161: 161 0003338F .set L227,0x0
162: 162 0003338F L229:
163: 163 0003338F 13 ff25 jbr L230
164: 164 00033392 .data
165: 165 000006bc * .text
166: 166 00033392 .align 1
167: 167 00033392 .globl _pipe20_2
168: 168 00033392 _pipe20_2:
169: 169 00033392 0000 .word L241
170: 170 00033394 #
171: 171 00033394 #
172: 172 00033394 #
173: 173 00033394 #
174: 174 00033394 #
175: 175 00033394 # /************************************************************************
176: 176 00033394 # *
177: 177 00033394 # * SUBTEST 2 : 3 NEGDs
178: 178 00033394 # *
179: 179 00033394 # ************************************************************************/
180: 180 00033394 # pipe20_2()
181: 181 00033394 # {
182: 182 00033394 13 00ec jbr L243
183: 183 00033397 L244:
184: 184 00033397 # subtest = 2;
185: 185 00033397 0d 02 effffffec6 movl $2,_subtest
186: 186 0003339E # force_loop = FALSE;
187: 187 0003339E 4d effffffec0 clrl _force_loop
188: 188 000333A4 # for( index = 0; index < max_ldd_1_index; index++ )
189: 189 000333A4 4d effffffeba clrl _index
190: 190 000333AA L247:
191: 191 000333AA 1d effffffeb4 effffffeaf cmpl _index,_max_ldd_1_index
192: 192 000333B5 91 03 13 00c8 jgeq L246
193: 193 000333BA # {
194: 194 000333BA # dbl_value_1 = ldd_1_data[index].ld; /* get operand 1 */
195: 195 000333BA 48 04 effffffea3 50 shll $4,_index,r0
196: 196 000333C2 0c 8f00000000 50 addl2 $_ldd_1_data,r0
197: 197 000333C9 0d a004 effffffe97 movl 4(r0),_dbl_value_1+4
198: 198 000333D1 0d 60 effffffe8c movl (r0),_dbl_value_1
199: 199 000333D8 # dbl_expected = ldd_1_data[index].exp; /* get expected results */
200: 200 000333D8 48 04 effffffe85 50 shll $4,_index,r0
201: 201 000333E0 0c 8f00000008 50 addl2 $_ldd_1_data+8,r0
202: 202 000333E7 0d a004 effffffe79 movl 4(r0),_dbl_expected+4
203: 203 000333EF 0d 60 effffffe6e movl (r0),_dbl_expected
204: 204 000333F6 # if( dbl_expected.m )
205: 205 000333F6 5d effffffe68 tstl _dbl_expected
206: 206 000333FC 31 0b jeql L248
207: 207 000333FE # dbl_expected.m ^= 0x80000000; /* negate exptd results */
208: 208 000333FE cc 8f80000000 effffffe5b xorl2 $-2147483648,_dbl_expected
209: 209 00033409 # /*
210: 210 00033409 # * If LOOP ON ERROR is set, this is the loop for this subtest.
211: 211 00033409 # * The force loop flag is set after the first error.
212: 212 00033409 # */
213: 213 00033409 # asm("_pipe20_2_lp1:");
214: 214 00033409 L248:
215: 215 00033409 _pipe20_2_lp1:
216: 216 00033409 # asm("ldd _dbl_value_1"); /* load the operand */
217: 217 00033409 07 effffffe55 ldd _dbl_value_1
218: 218 0003340F # asm("negd"); /* negate it ( 3 times ) */
219: 219 0003340F b7 negd
220: 220 00033410 # asm("negd");
221: 221 00033410 b7 negd
222: 222 00033411 # asm("negd");
223: 223 00033411 b7 negd
224: 224 00033412 # asm("std _dbl_st_acc"); /* store the result */
225: 225 00033412 27 effffffe4c std _dbl_st_acc
226: 226 00033418 # if( force_loop )
227: 227 00033418 5d effffffe46 tstl _force_loop
228: 228 0003341E 31 02 jeql L249
229: 229 00033420 # asm("brb _pipe20_2_lp1"); /* loop on an error */
230: 230 00033420 11 e7 brb _pipe20_2_lp1
231: 231 00033422 # /*
232: 232 00033422 # * verify the results
233: 233 00033422 # */
234: 234 00033422 # if( (dbl_st_acc.m != dbl_expected.m) || /* COMPARE the stored */
235: 235 00033422 L249:
236: 236 00033422 # (dbl_st_acc.l != dbl_expected.l) ) { /* to the expected */
237: 237 00033422 1d effffffe3c effffffe37 cmpl _dbl_st_acc,_dbl_expected
238: 238 0003342D 21 0d jneq L9998
239: 239 0003342F 1d effffffe33 effffffe2e cmpl _dbl_st_acc+4,_dbl_expected+4
240: 240 0003343A 31 3d jeql L250
241: 241 0003343C L9998:
242: 242 0003343C # errcnt++; /* bump the error count */
243: 243 0003343C 6d effffffe22 incl _errcnt
244: 244 00033442 # if( prt_error )
245: 245 00033442 5d effffffe1c tstl _prt_error
246: 246 00033448 31 09 jeql L251
247: 247 0003344A # pipe20_print( 3 ); /* print error msg -3 NOPs */
248: 248 0003344A dd 03 pushl $3
249: 249 0003344C fe 08 ef000002ef callf $8,_pipe20_print
250: 250 00033453 # if( halt_flg ) /* halt on error? */
251: 251 00033453 L251:
252: 252 00033453 5d effffffe0b tstl _halt_flg
253: 253 00033459 31 09 jeql L252
254: 254 0003345B # pipe20_halt( 3 ); /* error halt -3 NOPs */
255: 255 0003345B dd 03 pushl $3
256: 256 0003345D fe 08 ef00000416 callf $8,_pipe20_halt
257: 257 00033464 # if( loop_on_err ) {
258: 258 00033464 L252:
259: 259 00033464 5d effffffdfa tstl _loop_on_err
260: 260 0003346A 31 0d jeql L253
261: 261 0003346C # force_loop = TRUE; /* set the force loop flag */
262: 262 0003346C 0d 01 effffffdf1 movl $1,_force_loop
263: 263 00033473 # asm("jmp _pipe20_2_lp1"); /* and loop */
264: 264 00033473 71 efffffff90 jmp _pipe20_2_lp1
265: 265 00033479 # }
266: 266 00033479 # }
267: 267 00033479 L253:
268: 268 00033479 # } /* end of FOR loop */
269: 269 00033479 L250:
270: 270 00033479 L245:
271: 271 00033479 6d effffffde5 incl _index
272: 272 0003347F 13 ff28 jbr L247
273: 273 00033482 L246:
274: 274 00033482 # } /* end of subtest 2 */
275: 275 00033482 40 ret#2
276: 276 00033483 .set L241,0x0
277: 277 00033483 L243:
278: 278 00033483 13 ff11 jbr L244
279: 279 00033486 .data
280: 280 000006bc * .text
281: 281 00033486 .align 1
282: 282 00033486 .globl _pipe20_3
283: 283 00033486 _pipe20_3:
284: 284 00033486 0000 .word L254
285: 285 00033488 #
286: 286 00033488 #
287: 287 00033488 #
288: 288 00033488 #
289: 289 00033488 #
290: 290 00033488 # /************************************************************************
291: 291 00033488 # *
292: 292 00033488 # * SUBTEST 3 : 4 NEGDs
293: 293 00033488 # *
294: 294 00033488 # ************************************************************************/
295: 295 00033488 # pipe20_3()
296: 296 00033488 # {
297: 297 00033488 13 00da jbr L256
298: 298 0003348B L257:
299: 299 0003348B # subtest = 3;
300: 300 0003348B 0d 03 effffffdd2 movl $3,_subtest
301: 301 00033492 # force_loop = FALSE;
302: 302 00033492 4d effffffdcc clrl _force_loop
303: 303 00033498 # for( index = 0; index < max_ldd_1_index; index++ )
304: 304 00033498 4d effffffdc6 clrl _index
305: 305 0003349E L260:
306: 306 0003349E 1d effffffdc0 effffffdbb cmpl _index,_max_ldd_1_index
307: 307 000334A9 91 03 13 00b6 jgeq L259
308: 308 000334AE # {
309: 309 000334AE # dbl_value_1 = ldd_1_data[index].ld; /* get operand 1 */
310: 310 000334AE 48 04 effffffdaf 50 shll $4,_index,r0
311: 311 000334B6 0c 8f00000000 50 addl2 $_ldd_1_data,r0
312: 312 000334BD 0d a004 effffffda3 movl 4(r0),_dbl_value_1+4
313: 313 000334C5 0d 60 effffffd98 movl (r0),_dbl_value_1
314: 314 000334CC # dbl_expected = ldd_1_data[index].exp; /* get expected results */
315: 315 000334CC 48 04 effffffd91 50 shll $4,_index,r0
316: 316 000334D4 0c 8f00000008 50 addl2 $_ldd_1_data+8,r0
317: 317 000334DB 0d a004 effffffd85 movl 4(r0),_dbl_expected+4
318: 318 000334E3 0d 60 effffffd7a movl (r0),_dbl_expected
319: 319 000334EA # /*
320: 320 000334EA # * If LOOP ON ERROR is set, this is the loop for this subtest.
321: 321 000334EA # * The force loop flag is set after the first error.
322: 322 000334EA # */
323: 323 000334EA # asm("_pipe20_3_lp1:");
324: 324 000334EA _pipe20_3_lp1:
325: 325 000334EA # asm("ldd _dbl_value_1"); /* load the operand */
326: 326 000334EA 07 effffffd74 ldd _dbl_value_1
327: 327 000334F0 # asm("negd"); /* negate it ( 4 times ) */
328: 328 000334F0 b7 negd
329: 329 000334F1 # asm("negd");
330: 330 000334F1 b7 negd
331: 331 000334F2 # asm("negd");
332: 332 000334F2 b7 negd
333: 333 000334F3 # asm("negd");
334: 334 000334F3 b7 negd
335: 335 000334F4 # asm("std _dbl_st_acc"); /* store the result */
336: 336 000334F4 27 effffffd6a std _dbl_st_acc
337: 337 000334FA # if( force_loop )
338: 338 000334FA 5d effffffd64 tstl _force_loop
339: 339 00033500 31 02 jeql L261
340: 340 00033502 # asm("brb _pipe20_3_lp1"); /* loop on an error */
341: 341 00033502 11 e6 brb _pipe20_3_lp1
342: 342 00033504 # /*
343: 343 00033504 # * verify the results
344: 344 00033504 # */
345: 345 00033504 # if( (dbl_st_acc.m != dbl_expected.m) || /* COMPARE the stored */
346: 346 00033504 L261:
347: 347 00033504 # (dbl_st_acc.l != dbl_expected.l) ) { /* to the expected */
348: 348 00033504 1d effffffd5a effffffd55 cmpl _dbl_st_acc,_dbl_expected
349: 349 0003350F 21 0d jneq L9997
350: 350 00033511 1d effffffd51 effffffd4c cmpl _dbl_st_acc+4,_dbl_expected+4
351: 351 0003351C 31 3d jeql L262
352: 352 0003351E L9997:
353: 353 0003351E # errcnt++; /* bump the error count */
354: 354 0003351E 6d effffffd40 incl _errcnt
355: 355 00033524 # if( prt_error )
356: 356 00033524 5d effffffd3a tstl _prt_error
357: 357 0003352A 31 09 jeql L263
358: 358 0003352C # pipe20_print( 4 ); /* print error msg -4 NOPs */
359: 359 0003352C dd 04 pushl $4
360: 360 0003352E fe 08 ef0000020d callf $8,_pipe20_print
361: 361 00033535 # if( halt_flg ) /* halt on error? */
362: 362 00033535 L263:
363: 363 00033535 5d effffffd29 tstl _halt_flg
364: 364 0003353B 31 09 jeql L264
365: 365 0003353D # pipe20_halt( 4 ); /* error halt -4 NOPs */
366: 366 0003353D dd 04 pushl $4
367: 367 0003353F fe 08 ef00000334 callf $8,_pipe20_halt
368: 368 00033546 # if( loop_on_err ) {
369: 369 00033546 L264:
370: 370 00033546 5d effffffd18 tstl _loop_on_err
371: 371 0003354C 31 0d jeql L265
372: 372 0003354E # force_loop = TRUE; /* set the force loop flag */
373: 373 0003354E 0d 01 effffffd0f movl $1,_force_loop
374: 374 00033555 # asm("jmp _pipe20_3_lp1"); /* and loop */
375: 375 00033555 71 efffffff8f jmp _pipe20_3_lp1
376: 376 0003355B # }
377: 377 0003355B # }
378: 378 0003355B L265:
379: 379 0003355B # } /* end of FOR loop */
380: 380 0003355B L262:
381: 381 0003355B L258:
382: 382 0003355B 6d effffffd03 incl _index
383: 383 00033561 13 ff3a jbr L260
384: 384 00033564 L259:
385: 385 00033564 # } /* end of subtest 3 */
386: 386 00033564 40 ret#2
387: 387 00033565 .set L254,0x0
388: 388 00033565 L256:
389: 389 00033565 13 ff23 jbr L257
390: 390 00033568 .data
391: 391 000006bc * .text
392: 392 00033568 .align 1
393: 393 00033568 .globl _pipe20_4
394: 394 00033568 _pipe20_4:
395: 395 00033568 0000 .word L266
396: 396 0003356A #
397: 397 0003356A #
398: 398 0003356A #
399: 399 0003356A #
400: 400 0003356A #
401: 401 0003356A #
402: 402 0003356A # /************************************************************************
403: 403 0003356A # *
404: 404 0003356A # * SUBTEST 4 : 5 NEGDs
405: 405 0003356A # *
406: 406 0003356A # ************************************************************************/
407: 407 0003356A # pipe20_4()
408: 408 0003356A # {
409: 409 0003356A 13 00ee jbr L268
410: 410 0003356D L269:
411: 411 0003356D # subtest = 4;
412: 412 0003356D 0d 04 effffffcf0 movl $4,_subtest
413: 413 00033574 # force_loop = FALSE;
414: 414 00033574 4d effffffcea clrl _force_loop
415: 415 0003357A # for( index = 0; index < max_ldd_1_index; index++ )
416: 416 0003357A 4d effffffce4 clrl _index
417: 417 00033580 L272:
418: 418 00033580 1d effffffcde effffffcd9 cmpl _index,_max_ldd_1_index
419: 419 0003358B 91 03 13 00ca jgeq L271
420: 420 00033590 # {
421: 421 00033590 # dbl_value_1 = ldd_1_data[index].ld; /* get operand 1 */
422: 422 00033590 48 04 effffffccd 50 shll $4,_index,r0
423: 423 00033598 0c 8f00000000 50 addl2 $_ldd_1_data,r0
424: 424 0003359F 0d a004 effffffcc1 movl 4(r0),_dbl_value_1+4
425: 425 000335A7 0d 60 effffffcb6 movl (r0),_dbl_value_1
426: 426 000335AE # dbl_expected = ldd_1_data[index].exp; /* get expected results */
427: 427 000335AE 48 04 effffffcaf 50 shll $4,_index,r0
428: 428 000335B6 0c 8f00000008 50 addl2 $_ldd_1_data+8,r0
429: 429 000335BD 0d a004 effffffca3 movl 4(r0),_dbl_expected+4
430: 430 000335C5 0d 60 effffffc98 movl (r0),_dbl_expected
431: 431 000335CC # if( dbl_expected.m )
432: 432 000335CC 5d effffffc92 tstl _dbl_expected
433: 433 000335D2 31 0b jeql L273
434: 434 000335D4 # dbl_expected.m ^= 0x80000000; /* negate exptd results */
435: 435 000335D4 cc 8f80000000 effffffc85 xorl2 $-2147483648,_dbl_expected
436: 436 000335DF # /*
437: 437 000335DF # * If LOOP ON ERROR is set, this is the loop for this subtest.
438: 438 000335DF # * The force loop flag is set after the first error.
439: 439 000335DF # */
440: 440 000335DF # asm("_pipe20_4_lp1:");
441: 441 000335DF L273:
442: 442 000335DF _pipe20_4_lp1:
443: 443 000335DF # asm("ldd _dbl_value_1"); /* load the operand */
444: 444 000335DF 07 effffffc7f ldd _dbl_value_1
445: 445 000335E5 # asm("negd"); /* negate it ( 5 times ) */
446: 446 000335E5 b7 negd
447: 447 000335E6 # asm("negd");
448: 448 000335E6 b7 negd
449: 449 000335E7 # asm("negd");
450: 450 000335E7 b7 negd
451: 451 000335E8 # asm("negd");
452: 452 000335E8 b7 negd
453: 453 000335E9 # asm("negd");
454: 454 000335E9 b7 negd
455: 455 000335EA # asm("std _dbl_st_acc"); /* store the result */
456: 456 000335EA 27 effffffc74 std _dbl_st_acc
457: 457 000335F0 # if( force_loop )
458: 458 000335F0 5d effffffc6e tstl _force_loop
459: 459 000335F6 31 02 jeql L274
460: 460 000335F8 # asm("brb _pipe20_4_lp1"); /* loop on an error */
461: 461 000335F8 11 e5 brb _pipe20_4_lp1
462: 462 000335FA # /*
463: 463 000335FA # * verify the results
464: 464 000335FA # */
465: 465 000335FA # if( (dbl_st_acc.m != dbl_expected.m) || /* COMPARE the stored */
466: 466 000335FA L274:
467: 467 000335FA # (dbl_st_acc.l != dbl_expected.l) ) { /* to the expected */
468: 468 000335FA 1d effffffc64 effffffc5f cmpl _dbl_st_acc,_dbl_expected
469: 469 00033605 21 0d jneq L9996
470: 470 00033607 1d effffffc5b effffffc56 cmpl _dbl_st_acc+4,_dbl_expected+4
471: 471 00033612 31 3d jeql L275
472: 472 00033614 L9996:
473: 473 00033614 # errcnt++; /* bump the error count */
474: 474 00033614 6d effffffc4a incl _errcnt
475: 475 0003361A # if( prt_error )
476: 476 0003361A 5d effffffc44 tstl _prt_error
477: 477 00033620 31 09 jeql L276
478: 478 00033622 # pipe20_print( 5 ); /* print error msg -5 NOPs */
479: 479 00033622 dd 05 pushl $5
480: 480 00033624 fe 08 ef00000117 callf $8,_pipe20_print
481: 481 0003362B # if( halt_flg ) /* halt on error? */
482: 482 0003362B L276:
483: 483 0003362B 5d effffffc33 tstl _halt_flg
484: 484 00033631 31 09 jeql L277
485: 485 00033633 # pipe20_halt( 5 ); /* error halt -5 NOPs */
486: 486 00033633 dd 05 pushl $5
487: 487 00033635 fe 08 ef0000023e callf $8,_pipe20_halt
488: 488 0003363C # if( loop_on_err ) {
489: 489 0003363C L277:
490: 490 0003363C 5d effffffc22 tstl _loop_on_err
491: 491 00033642 31 0d jeql L278
492: 492 00033644 # force_loop = TRUE; /* set the force loop flag */
493: 493 00033644 0d 01 effffffc19 movl $1,_force_loop
494: 494 0003364B # asm("jmp _pipe20_4_lp1"); /* and loop */
495: 495 0003364B 71 efffffff8e jmp _pipe20_4_lp1
496: 496 00033651 # }
497: 497 00033651 # }
498: 498 00033651 L278:
499: 499 00033651 # } /* end of FOR loop */
500: 500 00033651 L275:
501: 501 00033651 L270:
502: 502 00033651 6d effffffc0d incl _index
503: 503 00033657 13 ff26 jbr L272
504: 504 0003365A L271:
505: 505 0003365A # } /* end of subtest 4 */
506: 506 0003365A 40 ret#2
507: 507 0003365B .set L266,0x0
508: 508 0003365B L268:
509: 509 0003365B 13 ff0f jbr L269
510: 510 0003365E .data
511: 511 000006bc * .text
512: 512 0003365E .align 1
513: 513 0003365E .globl _pipe20_5
514: 514 0003365E _pipe20_5:
515: 515 0003365E 0000 .word L279
516: 516 00033660 #
517: 517 00033660 #
518: 518 00033660 #
519: 519 00033660 #
520: 520 00033660 #
521: 521 00033660 # /************************************************************************
522: 522 00033660 # *
523: 523 00033660 # * SUBTEST 5 : 6 NEGDs
524: 524 00033660 # *
525: 525 00033660 # ************************************************************************/
526: 526 00033660 # pipe20_5()
527: 527 00033660 # {
528: 528 00033660 13 00dc jbr L281
529: 529 00033663 L282:
530: 530 00033663 # subtest = 5;
531: 531 00033663 0d 05 effffffbfa movl $5,_subtest
532: 532 0003366A # force_loop = FALSE;
533: 533 0003366A 4d effffffbf4 clrl _force_loop
534: 534 00033670 # for( index = 0; index < max_ldd_1_index; index++ )
535: 535 00033670 4d effffffbee clrl _index
536: 536 00033676 L285:
537: 537 00033676 1d effffffbe8 effffffbe3 cmpl _index,_max_ldd_1_index
538: 538 00033681 91 03 13 00b8 jgeq L284
539: 539 00033686 # {
540: 540 00033686 # dbl_value_1 = ldd_1_data[index].ld; /* get operand 1 */
541: 541 00033686 48 04 effffffbd7 50 shll $4,_index,r0
542: 542 0003368E 0c 8f00000000 50 addl2 $_ldd_1_data,r0
543: 543 00033695 0d a004 effffffbcb movl 4(r0),_dbl_value_1+4
544: 544 0003369D 0d 60 effffffbc0 movl (r0),_dbl_value_1
545: 545 000336A4 # dbl_expected = ldd_1_data[index].exp; /* get expected results */
546: 546 000336A4 48 04 effffffbb9 50 shll $4,_index,r0
547: 547 000336AC 0c 8f00000008 50 addl2 $_ldd_1_data+8,r0
548: 548 000336B3 0d a004 effffffbad movl 4(r0),_dbl_expected+4
549: 549 000336BB 0d 60 effffffba2 movl (r0),_dbl_expected
550: 550 000336C2 # /*
551: 551 000336C2 # * If LOOP ON ERROR is set, this is the loop for this subtest.
552: 552 000336C2 # * The force loop flag is set after the first error.
553: 553 000336C2 # */
554: 554 000336C2 # asm("_pipe20_5_lp1:");
555: 555 000336C2 _pipe20_5_lp1:
556: 556 000336C2 # asm("ldd _dbl_value_1"); /* load the operand */
557: 557 000336C2 07 effffffb9c ldd _dbl_value_1
558: 558 000336C8 # asm("negd"); /* negate it ( 6 times ) */
559: 559 000336C8 b7 negd
560: 560 000336C9 # asm("negd");
561: 561 000336C9 b7 negd
562: 562 000336CA # asm("negd");
563: 563 000336CA b7 negd
564: 564 000336CB # asm("negd");
565: 565 000336CB b7 negd
566: 566 000336CC # asm("negd");
567: 567 000336CC b7 negd
568: 568 000336CD # asm("negd");
569: 569 000336CD b7 negd
570: 570 000336CE # asm("std _dbl_st_acc"); /* store the result */
571: 571 000336CE 27 effffffb90 std _dbl_st_acc
572: 572 000336D4 # if( force_loop )
573: 573 000336D4 5d effffffb8a tstl _force_loop
574: 574 000336DA 31 02 jeql L286
575: 575 000336DC # asm("brb _pipe20_5_lp1"); /* loop on an error */
576: 576 000336DC 11 e4 brb _pipe20_5_lp1
577: 577 000336DE # /*
578: 578 000336DE # * verify the results
579: 579 000336DE # */
580: 580 000336DE # if( (dbl_st_acc.m != dbl_expected.m) || /* COMPARE the stored */
581: 581 000336DE L286:
582: 582 000336DE # (dbl_st_acc.l != dbl_expected.l) ) { /* to the expected */
583: 583 000336DE 1d effffffb80 effffffb7b cmpl _dbl_st_acc,_dbl_expected
584: 584 000336E9 21 0d jneq L9995
585: 585 000336EB 1d effffffb77 effffffb72 cmpl _dbl_st_acc+4,_dbl_expected+4
586: 586 000336F6 31 3d jeql L287
587: 587 000336F8 L9995:
588: 588 000336F8 # errcnt++; /* bump the error count */
589: 589 000336F8 6d effffffb66 incl _errcnt
590: 590 000336FE # if( prt_error )
591: 591 000336FE 5d effffffb60 tstl _prt_error
592: 592 00033704 31 09 jeql L288
593: 593 00033706 # pipe20_print( 6 ); /* print error msg -6 NOPs */
594: 594 00033706 dd 06 pushl $6
595: 595 00033708 fe 08 ef00000033 callf $8,_pipe20_print
596: 596 0003370F # if( halt_flg ) /* halt on error? */
597: 597 0003370F L288:
598: 598 0003370F 5d effffffb4f tstl _halt_flg
599: 599 00033715 31 09 jeql L289
600: 600 00033717 # pipe20_halt( 6 ); /* error halt -6 NOPs */
601: 601 00033717 dd 06 pushl $6
602: 602 00033719 fe 08 ef0000015a callf $8,_pipe20_halt
603: 603 00033720 # if( loop_on_err ) {
604: 604 00033720 L289:
605: 605 00033720 5d effffffb3e tstl _loop_on_err
606: 606 00033726 31 0d jeql L290
607: 607 00033728 # force_loop = TRUE; /* set the force loop flag */
608: 608 00033728 0d 01 effffffb35 movl $1,_force_loop
609: 609 0003372F # asm("jmp _pipe20_5_lp1"); /* and loop */
610: 610 0003372F 71 efffffff8d jmp _pipe20_5_lp1
611: 611 00033735 # }
612: 612 00033735 # }
613: 613 00033735 L290:
614: 614 00033735 # } /* end of FOR loop */
615: 615 00033735 L287:
616: 616 00033735 L283:
617: 617 00033735 6d effffffb29 incl _index
618: 618 0003373B 13 ff38 jbr L285
619: 619 0003373E L284:
620: 620 0003373E # } /* end of subtest 5 */
621: 621 0003373E 40 ret#2
622: 622 0003373F .set L279,0x0
623: 623 0003373F L281:
624: 624 0003373F 13 ff21 jbr L282
625: 625 00033742 .data
626: 626 000006bc * .text
627: 627 00033742 .align 1
628: 628 00033742 .globl _pipe20_print
629: 629 00033742 _pipe20_print:
630: 630 00033742 0000 .word L291
631: 631 00033744 #
632: 632 00033744 #
633: 633 00033744 #
634: 634 00033744 #
635: 635 00033744 # /****************************************************************************
636: 636 00033744 # *
637: 637 00033744 # * PRINT AN ERROR MESSAGE
638: 638 00033744 # *
639: 639 00033744 # * cycle dd PIPELINE 20, subtest dd error
640: 640 00033744 # * LDD op, {NEGD}, STD
641: 641 00033744 # * operand = xxxxxxxx xxxxxxxx, final Acc = xxxxxxxx xxxxxxxx, index = dd
642: 642 00033744 # * expected Acc = xxxxxxxx xxxxxxxx
643: 643 00033744 # *
644: 644 00033744 # ****************************************************************************/
645: 645 00033744 # pipe20_print( nop_count )
646: 646 00033744 # int nop_count; /* # of NOP instructions */
647: 647 00033744 # {
648: 648 00033744 13 0130 jbr L293
649: 649 00033747 L294:
650: 650 00033747 # writes(" \n"); /* start a new print line */
651: 651 00033747 .data 1
652: 652 000006c5 * L295:
653: 653 000006c5 * 200A00 .ascii " \12\0"
654: 654 000006c8 * .text
655: 655 00033747 dd 8f000006c5 pushl $L295
656: 656 0003374D fe 08 effffffb10 callf $8,_writes
657: 657 00033754 # writes("cycle: ");
658: 658 00033754 .data 1
659: 659 000006c8 * L296:
660: 660 000006c8 * 6379636C653A2000 .ascii "cycle: \0"
661: 661 000006d0 * .text
662: 662 00033754 dd 8f000006c8 pushl $L296
663: 663 0003375A fe 08 effffffb03 callf $8,_writes
664: 664 00033761 # writed( cycle );
665: 665 00033761 dd effffffafd pushl _cycle
666: 666 00033767 fe 08 effffffaf6 callf $8,_writed
667: 667 0003376E # writes(" PIPELINE 20, subtest ");
668: 668 0003376E .data 1
669: 669 000006d0 * L298:
670: 670 000006d0 * 2020504950454C494E4520323 .ascii " PIPELINE 20, subtest \0"
671: 02C20737562746573742000
672: 671 000006e8 * .text
673: 672 0003376E dd 8f000006d0 pushl $L298
674: 673 00033774 fe 08 effffffae9 callf $8,_writes
675: 674 0003377B # writed( subtest );
676: 675 0003377B dd effffffae3 pushl _subtest
677: 676 00033781 fe 08 effffffadc callf $8,_writed
678: 677 00033788 # writes(" error\n");
679: 678 00033788 .data 1
680: 679 000006e8 * L299:
681: 680 000006e8 * 206572726F720A00 .ascii " error\12\0"
682: 681 000006f0 * .text
683: 682 00033788 dd 8f000006e8 pushl $L299
684: 683 0003378E fe 08 effffffacf callf $8,_writes
685: 684 00033795 # writes(" LDD(op), NEGD");
686: 685 00033795 .data 1
687: 686 000006f0 * L300:
688: 687 000006f0 * 204C4444286F70292C204E454 .ascii " LDD(op), NEGD\0"
689: 74400
690: 688 000006ff * .text
691: 689 00033795 dd 8f000006f0 pushl $L300
692: 690 0003379B fe 08 effffffac2 callf $8,_writes
693: 691 000337A2 # while( --nop_count )
694: 692 000337A2 L301:
695: 693 000337A2 7d ad04 decl 4(fp)
696: 694 000337A5 31 0f jeql L302
697: 695 000337A7 # writes(", NEGD");
698: 696 000337A7 .data 1
699: 697 000006ff * L303:
700: 698 000006ff * 2C204E45474400 .ascii ", NEGD\0"
701: 699 00000706 * .text
702: 700 000337A7 dd 8f000006ff pushl $L303
703: 701 000337AD fe 08 effffffab0 callf $8,_writes
704: 702 000337B4 11 ec jbr L301
705: 703 000337B6 L302:
706: 704 000337B6 # writes(", STD\n");
707: 705 000337B6 .data 1
708: 706 00000706 * L304:
709: 707 00000706 * 2C205354440A00 .ascii ", STD\12\0"
710: 708 0000070d * .text
711: 709 000337B6 dd 8f00000706 pushl $L304
712: 710 000337BC fe 08 effffffaa1 callf $8,_writes
713: 711 000337C3 # writes("operand = ");
714: 712 000337C3 .data 1
715: 713 0000070d * L305:
716: 714 0000070d * 6F706572616E64203D2000 .ascii "operand = \0"
717: 715 00000718 * .text
718: 716 000337C3 dd 8f0000070d pushl $L305
719: 717 000337C9 fe 08 effffffa94 callf $8,_writes
720: 718 000337D0 # write32h( dbl_value_1.m );
721: 719 000337D0 dd effffffa8e pushl _dbl_value_1
722: 720 000337D6 fe 08 effffffa87 callf $8,_write32h
723: 721 000337DD # writec(' ');
724: 722 000337DD dd 20 pushl $32
725: 723 000337DF fe 08 effffffa7e callf $8,_writec
726: 724 000337E6 # write32h( dbl_value_1.l );
727: 725 000337E6 dd effffffa7c pushl _dbl_value_1+4
728: 726 000337EC fe 08 effffffa71 callf $8,_write32h
729: 727 000337F3 # writes(", final Acc = ");
730: 728 000337F3 .data 1
731: 729 00000718 * L308:
732: 730 00000718 * 2C202066696E616C204163632 .ascii ", final Acc = \0"
733: 03D2000
734: 731 00000728 * .text
735: 732 000337F3 dd 8f00000718 pushl $L308
736: 733 000337F9 fe 08 effffffa64 callf $8,_writes
737: 734 00033800 # write32h( dbl_st_acc.m );
738: 735 00033800 dd effffffa5e pushl _dbl_st_acc
739: 736 00033806 fe 08 effffffa57 callf $8,_write32h
740: 737 0003380D # writec(' ');
741: 738 0003380D dd 20 pushl $32
742: 739 0003380F fe 08 effffffa4e callf $8,_writec
743: 740 00033816 # write32h( dbl_st_acc.l );
744: 741 00033816 dd effffffa4c pushl _dbl_st_acc+4
745: 742 0003381C fe 08 effffffa41 callf $8,_write32h
746: 743 00033823 # writes(", index = ");
747: 744 00033823 .data 1
748: 745 00000728 * L309:
749: 746 00000728 * 2C202020696E646578203D200 .ascii ", index = \0"
750: 0
751: 747 00000735 * .text
752: 748 00033823 dd 8f00000728 pushl $L309
753: 749 00033829 fe 08 effffffa34 callf $8,_writes
754: 750 00033830 # writed( index );
755: 751 00033830 dd effffffa2e pushl _index
756: 752 00033836 fe 08 effffffa27 callf $8,_writed
757: 753 0003383D # writes("\n expected Acc = ");
758: 754 0003383D .data 1
759: 755 00000735 * L310:
760: 756 00000735 * 0A20202020202020202020202 .ascii "\12 expected Acc = \0"
761: 0202020202020202020202020
762: 2020206578706563746564204
763: 16363203D2000
764: 757 00000761 * .text
765: 758 0003383D dd 8f00000735 pushl $L310
766: 759 00033843 fe 08 effffffa1a callf $8,_writes
767: 760 0003384A # write32h( dbl_expected.m );
768: 761 0003384A dd effffffa14 pushl _dbl_expected
769: 762 00033850 fe 08 effffffa0d callf $8,_write32h
770: 763 00033857 # writec(' ');
771: 764 00033857 dd 20 pushl $32
772: 765 00033859 fe 08 effffffa04 callf $8,_writec
773: 766 00033860 # write32h( dbl_expected.l );
774: 767 00033860 dd effffffa02 pushl _dbl_expected+4
775: 768 00033866 fe 08 effffff9f7 callf $8,_write32h
776: 769 0003386D # writec('\n');
777: 770 0003386D dd 0a pushl $10
778: 771 0003386F fe 08 effffff9ee callf $8,_writec
779: 772 00033876 # }
780: 773 00033876 40 ret#2
781: 774 00033877 .set L291,0x0
782: 775 00033877 L293:
783: 776 00033877 13 fecd jbr L294
784: 777 0003387A .data
785: 778 000006bc * .text
786: 779 0003387A .align 1
787: 780 0003387A .globl _pipe20_halt
788: 781 0003387A _pipe20_halt:
789: 782 0003387A 0000 .word L311
790: 783 0003387C #
791: 784 0003387C #
792: 785 0003387C #
793: 786 0003387C # /****************************************************************************
794: 787 0003387C # *
795: 788 0003387C # * SET UP THE REGISTERS AND HALT
796: 789 0003387C # *
797: 790 0003387C # ****************************************************************************/
798: 791 0003387C # pipe20_halt( nop_count )
799: 792 0003387C # int nop_count; /* # of NOP instructions */
800: 793 0003387C # {
801: 794 0003387C 13 009c jbr L313
802: 795 0003387F L314:
803: 796 0003387F # sgl_dummy1 = nop_count;
804: 797 0003387F 0d ad04 effffff9dd movl 4(fp),_sgl_dummy1
805: 798 00033887 # sgl_value_1 = dbl_value_1.m;
806: 799 00033887 0d effffff9d7 effffff9d2 movl _dbl_value_1,_sgl_value_1
807: 800 00033892 # sgl_value_2 = dbl_value_1.l;
808: 801 00033892 0d effffff9d0 effffff9c7 movl _dbl_value_1+4,_sgl_value_2
809: 802 0003389D # sgl_value_3 = dbl_st_acc.m;
810: 803 0003389D 0d effffff9c1 effffff9bc movl _dbl_st_acc,_sgl_value_3
811: 804 000338A8 # sgl_value_4 = dbl_st_acc.l;
812: 805 000338A8 0d effffff9ba effffff9b1 movl _dbl_st_acc+4,_sgl_value_4
813: 806 000338B3 # sgl_value_5 = dbl_expected.m;
814: 807 000338B3 0d effffff9ab effffff9a6 movl _dbl_expected,_sgl_value_5
815: 808 000338BE # sgl_value_6 = dbl_expected.l;
816: 809 000338BE 0d effffff9a4 effffff99b movl _dbl_expected+4,_sgl_value_6
817: 810 000338C9 # asm("movl _test_no,r0"); /* r0 = test number */
818: 811 000338C9 0d effffff995 50 movl _test_no,r0
819: 812 000338D0 # asm("movl _subtest,r1"); /* r1 = subtest number */
820: 813 000338D0 0d effffff98e 51 movl _subtest,r1
821: 814 000338D7 # asm("movl $1,r2"); /* r2 = error code */
822: 815 000338D7 0d 01 52 movl $1,r2
823: 816 000338DA # asm("movl _cycle,r3"); /* r3 = cycle count */
824: 817 000338DA 0d effffff984 53 movl _cycle,r3
825: 818 000338E1 # asm("movl _sgl_dummy1,r4"); /* r4 = # of NEGDS */
826: 819 000338E1 0d effffff97d 54 movl _sgl_dummy1,r4
827: 820 000338E8 # asm("movl _sgl_value_1,r5"); /* r5 = MS operand */
828: 821 000338E8 0d effffff976 55 movl _sgl_value_1,r5
829: 822 000338EF # asm("movl _sgl_value_2,r6"); /* r6 = LS operand */
830: 823 000338EF 0d effffff96f 56 movl _sgl_value_2,r6
831: 824 000338F6 # asm("movl _sgl_value_3,r7"); /* r7 = MS stored */
832: 825 000338F6 0d effffff968 57 movl _sgl_value_3,r7
833: 826 000338FD # asm("movl _sgl_value_4,r8"); /* r8 = LS stored */
834: 827 000338FD 0d effffff961 58 movl _sgl_value_4,r8
835: 828 00033904 # asm("movl _sgl_value_5,r9"); /* r9 = MS expected */
836: 829 00033904 0d effffff95a 59 movl _sgl_value_5,r9
837: 830 0003390B # asm("movl _sgl_value_6,r10"); /* r10 = LS expected */
838: 831 0003390B 0d effffff953 5a movl _sgl_value_6,r10
839: 832 00033912 # asm("movl _index,r11"); /* r11 = data index */
840: 833 00033912 0d effffff94c 5b movl _index,r11
841: 834 00033919 # asm("halt"); /* HALT ... */
842: 835 00033919 00 halt
843: 836 0003391A # }
844: 837 0003391A 40 ret#2
845: 838 0003391B .set L311,0x0
846: 839 0003391B L313:
847: 840 0003391B 13 ff61 jbr L314
848: 841 0003391E .data
849: 841 00066B82 .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.