![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe19.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 pipe19.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 0000037c * .text
4: 4 00000000 .align 1
5: 5 00000000 .globl _pipe_19
6: 6 00000000 _pipe_19:
7: 7 00032EE8 0000 .word L215
8: 8 00032EEA #
9: 9 00032EEA # #include "fpp_defs.h"
10: 10 00032EEA #
11: 11 00032EEA #
12: 12 00032EEA # /*****************************************************************************
13: 13 00032EEA # *
14: 14 00032EEA # * PIPELINE TEST #19
15: 15 00032EEA # *
16: 16 00032EEA # * LDD(op1), MULD(op2), STD op3, SUBD op3, STD
17: 17 00032EEA # *
18: 18 00032EEA # * -where the operands are the fmacro1 MULD data patterns. The SUBD operand
19: 19 00032EEA # * is the stored result of the MULD.
20: 20 00032EEA # * -If the 1st STD isn't completed before the SUBD data is fetched then we
21: 21 00032EEA # * won't get a final accumulator of zero.
22: 22 00032EEA # *****************************************************************************/
23: 23 00032EEA # pipe_19()
24: 24 00032EEA # {
25: 25 00032EEA 13 0117 jbr L217
26: 26 00032EED L218:
27: 27 00032EED # asm(".globl _pipeline_19_t");
28: 28 00032EED .globl _pipeline_19_t
29: 29 00032EED # asm("_pipeline_19_t:");
30: 30 00032EED _pipeline_19_t:
31: 31 00032EED # if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */
32: 32 00032EED 1d effffffff5 01 cmpl _cycle,$1
33: 33 00032EF4 21 15 jneq L219
34: 34 00032EF6 5d efffffffec tstl _prt_hdrs
35: 35 00032EFC 31 0d jeql L219
36: 36 00032EFE # writes(" PIPE_19");
37: 37 00032EFE .data 1
38: 38 0000037c * L221:
39: 39 0000037c * 20504950455F313900 .ascii " PIPE_19\0"
40: 40 00000385 * .text
41: 41 00032EFE dd 8f0000037c pushl $L221
42: 42 00032F04 fe 08 efffffffdd callf $8,_writes
43: 43 00032F0B # force_loop = FALSE; /* clear force_loop flag */
44: 44 00032F0B L219:
45: 45 00032F0B 4d efffffffd7 clrl _force_loop
46: 46 00032F11 # for( index = 0; index <= max_muld_1_index; index++ ) {
47: 47 00032F11 4d efffffffd1 clrl _index
48: 48 00032F17 L224:
49: 49 00032F17 1d efffffffcb efffffffc6 cmpl _index,_max_muld_1_index
50: 50 00032F22 51 03 13 00d6 jgtr L223
51: 51 00032F27 # dbl_value_1 = muld_1_data[index].op_1; /* get the data */
52: 52 00032F27 5c 18 efffffffba 50 mull3 $24,_index,r0
53: 53 00032F2F 0c 8f00000000 50 addl2 $_muld_1_data,r0
54: 54 00032F36 0d a004 efffffffae movl 4(r0),_dbl_value_1+4
55: 55 00032F3E 0d 60 efffffffa3 movl (r0),_dbl_value_1
56: 56 00032F45 # dbl_value_2 = muld_1_data[index].op_2; /* operands */
57: 57 00032F45 5c 18 efffffff9c 50 mull3 $24,_index,r0
58: 58 00032F4D 0c 8f00000008 50 addl2 $_muld_1_data+8,r0
59: 59 00032F54 0d a004 efffffff90 movl 4(r0),_dbl_value_2+4
60: 60 00032F5C 0d 60 efffffff85 movl (r0),_dbl_value_2
61: 61 00032F63 # dbl_expected = muld_1_data[index].exp;
62: 62 00032F63 5c 18 efffffff7e 50 mull3 $24,_index,r0
63: 63 00032F6B 0c 8f00000010 50 addl2 $_muld_1_data+16,r0
64: 64 00032F72 0d a004 efffffff72 movl 4(r0),_dbl_expected+4
65: 65 00032F7A 0d 60 efffffff67 movl (r0),_dbl_expected
66: 66 00032F81 # /*
67: 67 00032F81 # * This is the start of the LOOP ON ERROR section
68: 68 00032F81 # */
69: 69 00032F81 # asm("_pipe19_1_lp:");
70: 70 00032F81 _pipe19_1_lp:
71: 71 00032F81 # asm("ldd _dbl_value_1"); /* get the 1st operand */
72: 72 00032F81 07 efffffff61 ldd _dbl_value_1
73: 73 00032F87 # asm("muld _dbl_value_2"); /* multiply by the 2nd op. */
74: 74 00032F87 e7 efffffff5b muld _dbl_value_2
75: 75 00032F8D # asm("std _dbl_value_3"); /* save the MULD result */
76: 76 00032F8D 27 efffffff55 std _dbl_value_3
77: 77 00032F93 # asm("subd _dbl_value_3"); /* and subtract it again */
78: 78 00032F93 d7 efffffff4f subd _dbl_value_3
79: 79 00032F99 # asm("std _dbl_st_acc"); /* save the final result */
80: 80 00032F99 27 efffffff49 std _dbl_st_acc
81: 81 00032F9F # if( force_loop )
82: 82 00032F9F 5d efffffff43 tstl _force_loop
83: 83 00032FA5 31 02 jeql L225
84: 84 00032FA7 # asm("brb _pipe19_1_lp");; /* loop on the error */
85: 85 00032FA7 11 d8 brb _pipe19_1_lp
86: 86 00032FA9 L225:
87: 87 00032FA9 # /*
88: 88 00032FA9 # * Verify the results
89: 89 00032FA9 # */
90: 90 00032FA9 # if( (dbl_st_acc.m) || (dbl_st_acc.l) ) { /* the Acc s/b = 0 */
91: 91 00032FA9 5d efffffff39 tstl _dbl_st_acc
92: 92 00032FAF 21 08 jneq L9999
93: 93 00032FB1 5d efffffff35 tstl _dbl_st_acc+4
94: 94 00032FB7 31 3b jeql L226
95: 95 00032FB9 L9999:
96: 96 00032FB9 # errcnt++; /* bump the error count */
97: 97 00032FB9 6d efffffff29 incl _errcnt
98: 98 00032FBF # if ( prt_error )
99: 99 00032FBF 5d efffffff23 tstl _prt_error
100: 100 00032FC5 31 07 jeql L227
101: 101 00032FC7 # pipe19_print(); /* print the error mesage */
102: 102 00032FC7 fe 04 ef0000003a callf $4,_pipe19_print
103: 103 00032FCE # if ( halt_flg )
104: 104 00032FCE L227:
105: 105 00032FCE 5d efffffff14 tstl _halt_flg
106: 106 00032FD4 31 09 jeql L229
107: 107 00032FD6 # pipe19_halt( 1 ); /* halt on the error */
108: 108 00032FD6 dd 01 pushl $1
109: 109 00032FD8 fe 08 ef000001c9 callf $8,_pipe19_halt
110: 110 00032FDF # if ( loop_on_err ) {
111: 111 00032FDF L229:
112: 112 00032FDF 5d efffffff03 tstl _loop_on_err
113: 113 00032FE5 31 0d jeql L231
114: 114 00032FE7 # force_loop = TRUE;
115: 115 00032FE7 0d 01 effffffefa movl $1,_force_loop
116: 116 00032FEE # asm("jmp _pipe19_1_lp");;
117: 117 00032FEE 71 efffffff8d jmp _pipe19_1_lp
118: 118 00032FF4 # }
119: 119 00032FF4 # }
120: 120 00032FF4 L231:
121: 121 00032FF4 # }
122: 122 00032FF4 L226:
123: 123 00032FF4 L222:
124: 124 00032FF4 6d effffffeee incl _index
125: 125 00032FFA 13 ff1a jbr L224
126: 126 00032FFD L223:
127: 127 00032FFD # asm("jmp *return"); /* return to the test monitor */
128: 128 00032FFD 71 fffffffee5 jmp *return
129: 129 00033003 # }
130: 130 00033003 40 ret#2
131: 131 00033004 .set L215,0x0
132: 132 00033004 L217:
133: 133 00033004 13 fee6 jbr L218
134: 134 00033007 .data
135: 135 0000037c * .text
136: 136 00033007 00 .align 1
137: 137 00033008 .globl _pipe19_print
138: 138 00033008 _pipe19_print:
139: 139 00033008 0000 .word L232
140: 140 0003300A #
141: 141 0003300A #
142: 142 0003300A #
143: 143 0003300A #
144: 144 0003300A # /*
145: 145 0003300A # **************************************************************************
146: 146 0003300A # *
147: 147 0003300A # * print an error message of the form
148: 148 0003300A # *
149: 149 0003300A # * cycle: xx Test xx (Pipe 19), error
150: 150 0003300A # * test sequence = LDD(op1), MULD(op2), STD(op3), SUBD(op3), STD
151: 151 0003300A # * operand 1 = xxxxxxxx xxxxxxxx, final Acc = xxxxxxxx xxxxxxxx, index = xx
152: 152 0003300A # * operand 2 = xxxxxxxx xxxxxxxx, expected Acc = xxxxxxxx xxxxxxxx
153: 153 0003300A # * operand 3 = xxxxxxxx xxxxxxxx, expected op3 = xxxxxxxx xxxxxxxx
154: 154 0003300A # **************************************************************************
155: 155 0003300A # */
156: 156 0003300A # pipe19_print()
157: 157 0003300A # {
158: 158 0003300A 13 0197 jbr L234
159: 159 0003300D L235:
160: 160 0003300D # writes(" \n"); /* start a new print line */
161: 161 0003300D .data 1
162: 162 00000385 * L236:
163: 163 00000385 * 200A00 .ascii " \12\0"
164: 164 00000388 * .text
165: 165 0003300D dd 8f00000385 pushl $L236
166: 166 00033013 fe 08 effffffece callf $8,_writes
167: 167 0003301A # writes("cycle: ");
168: 168 0003301A .data 1
169: 169 00000388 * L237:
170: 170 00000388 * 6379636C653A2000 .ascii "cycle: \0"
171: 171 00000390 * .text
172: 172 0003301A dd 8f00000388 pushl $L237
173: 173 00033020 fe 08 effffffec1 callf $8,_writes
174: 174 00033027 # writed( cycle );
175: 175 00033027 dd effffffebb pushl _cycle
176: 176 0003302D fe 08 effffffeb4 callf $8,_writed
177: 177 00033034 # writes(" Test ");
178: 178 00033034 .data 1
179: 179 00000390 * L239:
180: 180 00000390 * 2020546573742000 .ascii " Test \0"
181: 181 00000398 * .text
182: 182 00033034 dd 8f00000390 pushl $L239
183: 183 0003303A fe 08 effffffea7 callf $8,_writes
184: 184 00033041 # writed( test_no );
185: 185 00033041 dd effffffea1 pushl _test_no
186: 186 00033047 fe 08 effffffe9a callf $8,_writed
187: 187 0003304E # writes(" (Pipe 19), error\n");
188: 188 0003304E .data 1
189: 189 00000398 * L240:
190: 190 00000398 * 20202850697065203139292C2 .ascii " (Pipe 19), error\12\0"
191: 06572726F720A00
192: 191 000003ac * .text
193: 192 0003304E dd 8f00000398 pushl $L240
194: 193 00033054 fe 08 effffffe8d callf $8,_writes
195: 194 0003305B # writes("LDD(op1), MULD(op2), STD(op3), SUBD(op3), STD\n");
196: 195 0003305B .data 1
197: 196 000003ac * L241:
198: 197 000003ac * 4C4444286F7031292C204D554 .ascii "LDD(op1), MULD(op2), STD(op3), SUBD(op3), STD\12\0"
199: C44286F7032292C2053544428
200: 6F7033292C2053554244286F7
201: 033292C205354440A00
202: 198 000003db * .text
203: 199 0003305B dd 8f000003ac pushl $L241
204: 200 00033061 fe 08 effffffe80 callf $8,_writes
205: 201 00033068 # writes("operand 1 = ");
206: 202 00033068 .data 1
207: 203 000003db * L242:
208: 204 000003db * 6F706572616E642031203D200 .ascii "operand 1 = \0"
209: 0
210: 205 000003e8 * .text
211: 206 00033068 dd 8f000003db pushl $L242
212: 207 0003306E fe 08 effffffe73 callf $8,_writes
213: 208 00033075 # write32h( dbl_value_1.m );
214: 209 00033075 dd effffffe6d pushl _dbl_value_1
215: 210 0003307B fe 08 effffffe66 callf $8,_write32h
216: 211 00033082 # writec(' ');
217: 212 00033082 dd 20 pushl $32
218: 213 00033084 fe 08 effffffe5d callf $8,_writec
219: 214 0003308B # write32h( dbl_value_1.l );
220: 215 0003308B dd effffffe5b pushl _dbl_value_1+4
221: 216 00033091 fe 08 effffffe50 callf $8,_write32h
222: 217 00033098 # writes(", final Acc = ");
223: 218 00033098 .data 1
224: 219 000003e8 * L245:
225: 220 000003e8 * 2C2020202066696E616C20416 .ascii ", final Acc = \0"
226: 363203D2000
227: 221 000003fa * .text
228: 222 00033098 dd 8f000003e8 pushl $L245
229: 223 0003309E fe 08 effffffe43 callf $8,_writes
230: 224 000330A5 # write32h( dbl_st_acc.m );
231: 225 000330A5 dd effffffe3d pushl _dbl_st_acc
232: 226 000330AB fe 08 effffffe36 callf $8,_write32h
233: 227 000330B2 # writec(' ');
234: 228 000330B2 dd 20 pushl $32
235: 229 000330B4 fe 08 effffffe2d callf $8,_writec
236: 230 000330BB # write32h( dbl_st_acc.l );
237: 231 000330BB dd effffffe2b pushl _dbl_st_acc+4
238: 232 000330C1 fe 08 effffffe20 callf $8,_write32h
239: 233 000330C8 # writes(", index = ");
240: 234 000330C8 .data 1
241: 235 000003fa * L246:
242: 236 000003fa * 2C2020696E646578203D2000 .ascii ", index = \0"
243: 237 00000406 * .text
244: 238 000330C8 dd 8f000003fa pushl $L246
245: 239 000330CE fe 08 effffffe13 callf $8,_writes
246: 240 000330D5 # writed( index );
247: 241 000330D5 dd effffffe0d pushl _index
248: 242 000330DB fe 08 effffffe06 callf $8,_writed
249: 243 000330E2 # writes("\noperand 2 = ");
250: 244 000330E2 .data 1
251: 245 00000406 * L247:
252: 246 00000406 * 0A6F706572616E642032203D2 .ascii "\12operand 2 = \0"
253: 000
254: 247 00000414 * .text
255: 248 000330E2 dd 8f00000406 pushl $L247
256: 249 000330E8 fe 08 effffffdf9 callf $8,_writes
257: 250 000330EF # write32h( dbl_value_2.m );
258: 251 000330EF dd effffffdf3 pushl _dbl_value_2
259: 252 000330F5 fe 08 effffffdec callf $8,_write32h
260: 253 000330FC # writec(' ');
261: 254 000330FC dd 20 pushl $32
262: 255 000330FE fe 08 effffffde3 callf $8,_writec
263: 256 00033105 # write32h( dbl_value_2.l );
264: 257 00033105 dd effffffde1 pushl _dbl_value_2+4
265: 258 0003310B fe 08 effffffdd6 callf $8,_write32h
266: 259 00033112 # writes(", expected Acc = ");
267: 260 00033112 .data 1
268: 261 00000414 * L248:
269: 262 00000414 * 2C20657870656374656420416 .ascii ", expected Acc = \0"
270: 363203D2000
271: 263 00000426 * .text
272: 264 00033112 dd 8f00000414 pushl $L248
273: 265 00033118 fe 08 effffffdc9 callf $8,_writes
274: 266 0003311F # write32h( 0 );
275: 267 0003311F dd 00 pushl $0
276: 268 00033121 fe 08 effffffdc0 callf $8,_write32h
277: 269 00033128 # writec(' ');
278: 270 00033128 dd 20 pushl $32
279: 271 0003312A fe 08 effffffdb7 callf $8,_writec
280: 272 00033131 # write32h( 0 );
281: 273 00033131 dd 00 pushl $0
282: 274 00033133 fe 08 effffffdae callf $8,_write32h
283: 275 0003313A # writes("\noperand 3 = ");
284: 276 0003313A .data 1
285: 277 00000426 * L249:
286: 278 00000426 * 0A6F706572616E642033203D2 .ascii "\12operand 3 = \0"
287: 000
288: 279 00000434 * .text
289: 280 0003313A dd 8f00000426 pushl $L249
290: 281 00033140 fe 08 effffffda1 callf $8,_writes
291: 282 00033147 # write32h( dbl_value_3.m );
292: 283 00033147 dd effffffd9b pushl _dbl_value_3
293: 284 0003314D fe 08 effffffd94 callf $8,_write32h
294: 285 00033154 # writec(' ');
295: 286 00033154 dd 20 pushl $32
296: 287 00033156 fe 08 effffffd8b callf $8,_writec
297: 288 0003315D # write32h( dbl_value_3.l );
298: 289 0003315D dd effffffd89 pushl _dbl_value_3+4
299: 290 00033163 fe 08 effffffd7e callf $8,_write32h
300: 291 0003316A # writes(", expected op3 = ");
301: 292 0003316A .data 1
302: 293 00000434 * L250:
303: 294 00000434 * 2C206578706563746564206F7 .ascii ", expected op3 = \0"
304: 033203D2000
305: 295 00000446 * .text
306: 296 0003316A dd 8f00000434 pushl $L250
307: 297 00033170 fe 08 effffffd71 callf $8,_writes
308: 298 00033177 # write32h( dbl_expected.m );
309: 299 00033177 dd effffffd6b pushl _dbl_expected
310: 300 0003317D fe 08 effffffd64 callf $8,_write32h
311: 301 00033184 # writec(' ');
312: 302 00033184 dd 20 pushl $32
313: 303 00033186 fe 08 effffffd5b callf $8,_writec
314: 304 0003318D # write32h( dbl_expected.l );
315: 305 0003318D dd effffffd59 pushl _dbl_expected+4
316: 306 00033193 fe 08 effffffd4e callf $8,_write32h
317: 307 0003319A # writec('\n');
318: 308 0003319A dd 0a pushl $10
319: 309 0003319C fe 08 effffffd45 callf $8,_writec
320: 310 000331A3 # }
321: 311 000331A3 40 ret#2
322: 312 000331A4 .set L232,0x0
323: 313 000331A4 L234:
324: 314 000331A4 13 fe66 jbr L235
325: 315 000331A7 .data
326: 316 0000037c * .text
327: 317 000331A7 00 .align 1
328: 318 000331A8 .globl _pipe19_halt
329: 319 000331A8 _pipe19_halt:
330: 320 000331A8 0000 .word L251
331: 321 000331AA #
332: 322 000331AA #
333: 323 000331AA #
334: 324 000331AA # /*
335: 325 000331AA # **************************************************************************
336: 326 000331AA # *
337: 327 000331AA # * HALT ON AN ERROR
338: 328 000331AA # *
339: 329 000331AA # **************************************************************************
340: 330 000331AA # */
341: 331 000331AA # pipe19_halt()
342: 332 000331AA # {
343: 333 000331AA 13 00b1 jbr L253
344: 334 000331AD L254:
345: 335 000331AD # sgl_value_1 = dbl_value_1.m;
346: 336 000331AD 0d effffffd35 effffffd30 movl _dbl_value_1,_sgl_value_1
347: 337 000331B8 # sgl_value_2 = dbl_value_1.l;
348: 338 000331B8 0d effffffd2e effffffd25 movl _dbl_value_1+4,_sgl_value_2
349: 339 000331C3 # sgl_value_3 = dbl_value_2.m;
350: 340 000331C3 0d effffffd1f effffffd1a movl _dbl_value_2,_sgl_value_3
351: 341 000331CE # sgl_value_4 = dbl_value_2.l;
352: 342 000331CE 0d effffffd18 effffffd0f movl _dbl_value_2+4,_sgl_value_4
353: 343 000331D9 # sgl_value_5 = dbl_value_3.m;
354: 344 000331D9 0d effffffd09 effffffd04 movl _dbl_value_3,_sgl_value_5
355: 345 000331E4 # sgl_value_6 = dbl_value_3.l;
356: 346 000331E4 0d effffffd02 effffffcf9 movl _dbl_value_3+4,_sgl_value_6
357: 347 000331EF # asm("movl _test_no,r0"); /* r0 = test number */
358: 348 000331EF 0d effffffcf3 50 movl _test_no,r0
359: 349 000331F6 # asm("movl $1,r1"); /* r1 = subtest number */
360: 350 000331F6 0d 01 51 movl $1,r1
361: 351 000331F9 # asm("movl $1,r2"); /* r2 = error code */
362: 352 000331F9 0d 01 52 movl $1,r2
363: 353 000331FC # asm("movl _cycle,r3"); /* r3 = cycle count */
364: 354 000331FC 0d effffffce6 53 movl _cycle,r3
365: 355 00033203 # asm("movl _sgl_value_1,r4"); /* r4 = MS of operand #1 */
366: 356 00033203 0d effffffcdf 54 movl _sgl_value_1,r4
367: 357 0003320A # asm("movl _sgl_value_2,r5"); /* r5 = LS of operand #1 */
368: 358 0003320A 0d effffffcd8 55 movl _sgl_value_2,r5
369: 359 00033211 # asm("movl _sgl_value_3,r6"); /* r6 = MS of operand #2 */
370: 360 00033211 0d effffffcd1 56 movl _sgl_value_3,r6
371: 361 00033218 # asm("movl _sgl_value_4,r7"); /* r7 = LS of operand #2 */
372: 362 00033218 0d effffffcca 57 movl _sgl_value_4,r7
373: 363 0003321F # asm("movl _sgl_value_5,r8"); /* r8 = MS of operand #3 */
374: 364 0003321F 0d effffffcc3 58 movl _sgl_value_5,r8
375: 365 00033226 # asm("movl _sgl_value_6,r9"); /* r9 = LS of operand #3 */
376: 366 00033226 0d effffffcbc 59 movl _sgl_value_6,r9
377: 367 0003322D # sgl_value_1 = dbl_st_acc.m;
378: 368 0003322D 0d effffffcb5 effffffcb0 movl _dbl_st_acc,_sgl_value_1
379: 369 00033238 # sgl_value_2 = dbl_st_acc.l;
380: 370 00033238 0d effffffcae effffffca5 movl _dbl_st_acc+4,_sgl_value_2
381: 371 00033243 # asm("movl _sgl_value_1,r10"); /* r10 = MS of final value */
382: 372 00033243 0d effffffc9f 5a movl _sgl_value_1,r10
383: 373 0003324A # asm("movl _sgl_value_2,r11"); /* r11 = LS of final value */
384: 374 0003324A 0d effffffc98 5b movl _sgl_value_2,r11
385: 375 00033251 # asm("clrl r12"); /* r12 = MS exp value (0) */
386: 376 00033251 4d 5c clrl r12
387: 377 00033253 # asm("clrl r13"); /* r13 = LS exp value (0) */
388: 378 00033253 4d 5d clrl r13
389: 379 00033255 # asm("movl _index,r14"); /* r14 = data index */
390: 380 00033255 0d effffffc8d 5e movl _index,r14
391: 381 0003325C # asm("halt"); /* HALT ... */
392: 382 0003325C 00 halt
393: 383 0003325D # }
394: 384 0003325D 40 ret#2
395: 385 0003325E .set L251,0x0
396: 386 0003325E L253:
397: 387 0003325E 13 ff4c jbr L254
398: 388 00033261 .data
399: 389 0000037c * #
400: 389 0000037c * #
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.