![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe18.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 pipe18.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 00000464 * .text
4: 4 00000000 .align 1
5: 5 00000000 .globl _pipe_18
6: 6 00000000 _pipe_18:
7: 7 00032A84 0000 .word L215
8: 8 00032A86 # #include "fpp_defs.h"
9: 9 00032A86 #
10: 10 00032A86 #
11: 11 00032A86 # /*****************************************************************************
12: 12 00032A86 # *
13: 13 00032A86 # * PIPELINE TEST #18
14: 14 00032A86 # *
15: 15 00032A86 # * LDD(op1), MULD(op2), CVDL r0, SUBD operand[r0], STD
16: 16 00032A86 # *
17: 17 00032A86 # * -where the operands are the fmacro1 MULD data patterns. The SUBD operand's
18: 18 00032A86 # * address is based on the result of the CVDL.
19: 19 00032A86 # * -The load, multiply, and convert will be done twice. The first time will
20: 20 00032A86 # * be to get the index and the data to subtract. The data to subtract will
21: 21 00032A86 # * be the same as the accumulator so we'll expect a reasult of zero. The
22: 22 00032A86 # * data will be stored based on the 1st CVDL result.
23: 23 00032A86 # * -If the 2nd CVDL doesn't get done before the SUBD operand is fetched then
24: 24 00032A86 # * we won't get a final accumulator of zero.
25: 25 00032A86 # * -For size reasons, only the MULD data with a result between -100 and +100
26: 26 00032A86 # * will be used for this test.
27: 27 00032A86 # *****************************************************************************/
28: 28 00032A86 # pipe_18()
29: 29 00032A86 # {
30: 30 00032A86 13 01cc jbr L217
31: 31 00032A89 L218:
32: 32 00032A89 # asm(".globl _pipeline_18_t");
33: 33 00032A89 .globl _pipeline_18_t
34: 34 00032A89 # asm("_pipeline_18_t:");
35: 35 00032A89 _pipeline_18_t:
36: 36 00032A89 # if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */
37: 37 00032A89 1d effffffff5 01 cmpl _cycle,$1
38: 38 00032A90 21 15 jneq L219
39: 39 00032A92 5d efffffffec tstl _prt_hdrs
40: 40 00032A98 31 0d jeql L219
41: 41 00032A9A # writes(" PIPE_18");
42: 42 00032A9A .data 1
43: 43 00000464 * L221:
44: 44 00000464 * 20504950455F313800 .ascii " PIPE_18\0"
45: 45 0000046d * .text
46: 46 00032A9A dd 8f00000464 pushl $L221
47: 47 00032AA0 fe 08 efffffffdd callf $8,_writes
48: 48 00032AA7 # force_loop = FALSE; /* clear force_loop flag */
49: 49 00032AA7 L219:
50: 50 00032AA7 4d efffffffd7 clrl _force_loop
51: 51 00032AAD # for( index = 0; index <= max_muld_1_index; index++ ) {
52: 52 00032AAD 4d efffffffd1 clrl _index
53: 53 00032AB3 L224:
54: 54 00032AB3 1d efffffffcb efffffffc6 cmpl _index,_max_muld_1_index
55: 55 00032ABE 51 03 13 018b jgtr L223
56: 56 00032AC3 # dbl_value_1 = muld_1_data[index].op_1; /* get the data */
57: 57 00032AC3 5c 18 efffffffba 50 mull3 $24,_index,r0
58: 58 00032ACB 0c 8f00000000 50 addl2 $_muld_1_data,r0
59: 59 00032AD2 0d a004 efffffffae movl 4(r0),_dbl_value_1+4
60: 60 00032ADA 0d 60 efffffffa3 movl (r0),_dbl_value_1
61: 61 00032AE1 # dbl_value_2 = muld_1_data[index].op_2; /* operands */
62: 62 00032AE1 5c 18 efffffff9c 50 mull3 $24,_index,r0
63: 63 00032AE9 0c 8f00000008 50 addl2 $_muld_1_data+8,r0
64: 64 00032AF0 0d a004 efffffff90 movl 4(r0),_dbl_value_2+4
65: 65 00032AF8 0d 60 efffffff85 movl (r0),_dbl_value_2
66: 66 00032AFF # dbl_expected.m = dbl_expected.l = 0; /* result s/b 0 */
67: 67 00032AFF 4d efffffff83 clrl _dbl_expected+4
68: 68 00032B05 0d efffffff7d 50 movl _dbl_expected+4,r0
69: 69 00032B0C 0d 50 efffffff71 movl r0,_dbl_expected
70: 70 00032B13 # asm("ldd _dbl_value_1");
71: 71 00032B13 07 efffffff6b ldd _dbl_value_1
72: 72 00032B19 # asm("muld _dbl_value_2");
73: 73 00032B19 e7 efffffff65 muld _dbl_value_2
74: 74 00032B1F # asm("cvdl _index2");
75: 75 00032B1F 87 efffffff5f cvdl _index2
76: 76 00032B25 # asm("nop");
77: 77 00032B25 10 nop
78: 78 00032B26 # if( (index2 >= -99) && (index2 <= 99) ) {
79: 79 00032B26 1d efffffff58 889d cmpl _index2,$-99
80: 80 00032B2E 81 03 13 0112 jlss L225
81: 81 00032B33 1d efffffff4b 8863 cmpl _index2,$99
82: 82 00032B3B 41 f3 jgtr L225
83: 83 00032B3D # if( index2 ) {
84: 84 00032B3D 5d efffffff41 tstl _index2
85: 85 00032B43 31 35 jeql L226
86: 86 00032B45 # sgl_value_5 = 0; /* set a dummy index */
87: 87 00032B45 4d efffffff39 clrl _sgl_value_5
88: 88 00032B4B # adr_dpipe_ops[sgl_value_5].m = 0;
89: 89 00032B4B 0d efffffff33 50 movl _sgl_value_5,r0
90: 90 00032B52 48 03 50 50 shll $3,r0,r0
91: 91 00032B56 1c 50 efffffff27 50 addl3 r0,_adr_dpipe_ops,r0
92: 92 00032B5E 4d 60 clrl (r0)
93: 93 00032B60 # adr_dpipe_ops[sgl_value_5].l = 0xabadface;
94: 94 00032B60 48 03 efffffff1d 50 shll $3,_sgl_value_5,r0
95: 95 00032B68 1c 50 efffffff15 50 addl3 r0,_adr_dpipe_ops,r0
96: 96 00032B70 0d 8fabadface a004 movl $-1414661426,4(r0)
97: 97 00032B78 # } else {
98: 98 00032B78 11 39 jbr L227
99: 99 00032B7A L226:
100: 100 00032B7A # sgl_value_5 = 6; /* set a dummy index */
101: 101 00032B7A 0d 06 efffffff03 movl $6,_sgl_value_5
102: 102 00032B81 # adr_dpipe_ops[sgl_value_5].m = 0xabadbabe;
103: 103 00032B81 0d effffffefd 50 movl _sgl_value_5,r0
104: 104 00032B88 48 03 50 50 shll $3,r0,r0
105: 105 00032B8C 1c 50 effffffef1 50 addl3 r0,_adr_dpipe_ops,r0
106: 106 00032B94 0d 8fabadbabe 60 movl $-1414677826,(r0)
107: 107 00032B9B # adr_dpipe_ops[sgl_value_5].l = 0xabadface;
108: 108 00032B9B 48 03 effffffee2 50 shll $3,_sgl_value_5,r0
109: 109 00032BA3 1c 50 effffffeda 50 addl3 r0,_adr_dpipe_ops,r0
110: 110 00032BAB 0d 8fabadface a004 movl $-1414661426,4(r0)
111: 111 00032BB3 # }
112: 112 00032BB3 L227:
113: 113 00032BB3 # asm("movl _index2,r0"); /* save the index */
114: 114 00032BB3 0d effffffecb 50 movl _index2,r0
115: 115 00032BBA # asm("std _dpipe_ops[r0]"); /* save the Acc's value */
116: 116 00032BBA 27 40effffffec3 std _dpipe_ops[r0]
117: 117 00032BC1 # asm("std _dbl_value_3"); /* save this value */
118: 118 00032BC1 27 effffffebd std _dbl_value_3
119: 119 00032BC7 # /*
120: 120 00032BC7 # * This is the start of the LOOP ON ERROR section
121: 121 00032BC7 # */
122: 122 00032BC7 # asm("_pipe18_1_lp:");
123: 123 00032BC7 _pipe18_1_lp:
124: 124 00032BC7 # asm("movl _sgl_value_5,r0"); /* save the bum index */
125: 125 00032BC7 0d effffffeb7 50 movl _sgl_value_5,r0
126: 126 00032BCE # asm("ldd _dbl_value_1");
127: 127 00032BCE 07 effffffeb0 ldd _dbl_value_1
128: 128 00032BD4 # asm("muld _dbl_value_2");
129: 129 00032BD4 e7 effffffeaa muld _dbl_value_2
130: 130 00032BDA # asm("cvdl r0"); /* set up the index to use */
131: 131 00032BDA 87 50 cvdl r0
132: 132 00032BDC # asm("subd _dpipe_ops[r0]"); /* subtract saved value */
133: 133 00032BDC d7 40effffffea1 subd _dpipe_ops[r0]
134: 134 00032BE3 # asm("std _dbl_st_acc");
135: 135 00032BE3 27 effffffe9b std _dbl_st_acc
136: 136 00032BE9 # asm("movl r0,_sgl_value_6"); /* save the index used */
137: 137 00032BE9 0d 50 effffffe94 movl r0,_sgl_value_6
138: 138 00032BF0 # if( force_loop )
139: 139 00032BF0 5d effffffe8e tstl _force_loop
140: 140 00032BF6 31 02 jeql L228
141: 141 00032BF8 # asm("brb _pipe18_1_lp");; /* loop on the error */
142: 142 00032BF8 11 cd brb _pipe18_1_lp
143: 143 00032BFA L228:
144: 144 00032BFA # /*
145: 145 00032BFA # * Verify the results (the accumulator should be = 0)
146: 146 00032BFA # */
147: 147 00032BFA # if( (dbl_st_acc.m) || (dbl_st_acc.l) ) {
148: 148 00032BFA 5d effffffe84 tstl _dbl_st_acc
149: 149 00032C00 21 08 jneq L9999
150: 150 00032C02 5d effffffe80 tstl _dbl_st_acc+4
151: 151 00032C08 31 3b jeql L229
152: 152 00032C0A L9999:
153: 153 00032C0A # errcnt++; /* bump the error count */
154: 154 00032C0A 6d effffffe74 incl _errcnt
155: 155 00032C10 # if ( prt_error )
156: 156 00032C10 5d effffffe6e tstl _prt_error
157: 157 00032C16 31 07 jeql L230
158: 158 00032C18 # pipe18_print(); /* print the error mesage */
159: 159 00032C18 fe 04 ef00000039 callf $4,_pipe18_print
160: 160 00032C1F # if ( halt_flg )
161: 161 00032C1F L230:
162: 162 00032C1F 5d effffffe5f tstl _halt_flg
163: 163 00032C25 31 09 jeql L232
164: 164 00032C27 # pipe18_halt( 1 ); /* halt on the error */
165: 165 00032C27 dd 01 pushl $1
166: 166 00032C29 fe 08 ef000001dc callf $8,_pipe18_halt
167: 167 00032C30 # if ( loop_on_err ) {
168: 168 00032C30 L232:
169: 169 00032C30 5d effffffe4e tstl _loop_on_err
170: 170 00032C36 31 0d jeql L234
171: 171 00032C38 # force_loop = TRUE;
172: 172 00032C38 0d 01 effffffe45 movl $1,_force_loop
173: 173 00032C3F # asm("jmp _pipe18_1_lp");;
174: 174 00032C3F 71 efffffff82 jmp _pipe18_1_lp
175: 175 00032C45 # }
176: 176 00032C45 # }
177: 177 00032C45 L234:
178: 178 00032C45 # }
179: 179 00032C45 L229:
180: 180 00032C45 # }
181: 181 00032C45 L225:
182: 182 00032C45 L222:
183: 183 00032C45 6d effffffe39 incl _index
184: 184 00032C4B 13 fe65 jbr L224
185: 185 00032C4E L223:
186: 186 00032C4E # asm("jmp *return"); /* return to the test monitor */
187: 187 00032C4E 71 fffffffe30 jmp *return
188: 188 00032C54 # }
189: 189 00032C54 40 ret#2
190: 190 00032C55 .set L215,0x0
191: 191 00032C55 L217:
192: 192 00032C55 13 fe31 jbr L218
193: 193 00032C58 .data
194: 194 00000464 * .text
195: 195 00032C58 .align 1
196: 196 00032C58 .globl _pipe18_print
197: 197 00032C58 _pipe18_print:
198: 198 00032C58 0000 .word L235
199: 199 00032C5A #
200: 200 00032C5A #
201: 201 00032C5A #
202: 202 00032C5A #
203: 203 00032C5A # /*
204: 204 00032C5A # **************************************************************************
205: 205 00032C5A # *
206: 206 00032C5A # * print an error message of the form
207: 207 00032C5A # *
208: 208 00032C5A # * cycle: xx Test xx, Error with subtract data based on CVDL value, index = xx
209: 209 00032C5A # * test sequence = LDD(op1), MULD(op2), CVDL r0, SUBD operand[r0], STD
210: 210 00032C5A # *operand 1 = xxxxxxx xxxxxxx, final Acc = xxxxxxx xxxxxxx, index = xxxxxxx
211: 211 00032C5A # *operand 2 = xxxxxxx xxxxxxx, expected Acc = xxxxxxx xxxxxxx
212: 212 00032C5A # *operand 3 = xxxxxxx xxxxxxx, CVDL result = xxxxxxx
213: 213 00032C5A # * int expected = xxxxxxx
214: 214 00032C5A # **************************************************************************
215: 215 00032C5A # */
216: 216 00032C5A # pipe18_print()
217: 217 00032C5A # {
218: 218 00032C5A 13 01ac jbr L237
219: 219 00032C5D L238:
220: 220 00032C5D # writes(" \n"); /* start a new print line */
221: 221 00032C5D .data 1
222: 222 0000046d * L239:
223: 223 0000046d * 200A00 .ascii " \12\0"
224: 224 00000470 * .text
225: 225 00032C5D dd 8f0000046d pushl $L239
226: 226 00032C63 fe 08 effffffe1a callf $8,_writes
227: 227 00032C6A # writes("cycle: ");
228: 228 00032C6A .data 1
229: 229 00000470 * L240:
230: 230 00000470 * 6379636C653A2000 .ascii "cycle: \0"
231: 231 00000478 * .text
232: 232 00032C6A dd 8f00000470 pushl $L240
233: 233 00032C70 fe 08 effffffe0d callf $8,_writes
234: 234 00032C77 # writed( cycle );
235: 235 00032C77 dd effffffe07 pushl _cycle
236: 236 00032C7D fe 08 effffffe00 callf $8,_writed
237: 237 00032C84 # writes(" Test ");
238: 238 00032C84 .data 1
239: 239 00000478 * L242:
240: 240 00000478 * 2020546573742000 .ascii " Test \0"
241: 241 00000480 * .text
242: 242 00032C84 dd 8f00000478 pushl $L242
243: 243 00032C8A fe 08 effffffdf3 callf $8,_writes
244: 244 00032C91 # writed( test_no );
245: 245 00032C91 dd effffffded pushl _test_no
246: 246 00032C97 fe 08 effffffde6 callf $8,_writed
247: 247 00032C9E # writes(" (Pipe 18), error\n");
248: 248 00032C9E .data 1
249: 249 00000480 * L243:
250: 250 00000480 * 20202850697065203138292C2 .ascii " (Pipe 18), error\12\0"
251: 0206572726F720A00
252: 251 00000495 * .text
253: 252 00032C9E dd 8f00000480 pushl $L243
254: 253 00032CA4 fe 08 effffffdd9 callf $8,_writes
255: 254 00032CAB # writes(" LDD(op1), MULD(op2), CVDL(r0), SUBD(op3), STD\n");
256: 255 00032CAB .data 1
257: 256 00000495 * L244:
258: 257 00000495 * 204C4444286F7031292C204D5 .ascii " LDD(op1), MULD(op2), CVDL(r0), SUBD(op3), STD\12\0"
259: 54C44286F7032292C20435644
260: 4C287230292C2053554244286
261: F7033292C205354440A00
262: 258 000004c5 * .text
263: 259 00032CAB dd 8f00000495 pushl $L244
264: 260 00032CB1 fe 08 effffffdcc callf $8,_writes
265: 261 00032CB8 # writes("operand 1 = ");
266: 262 00032CB8 .data 1
267: 263 000004c5 * L245:
268: 264 000004c5 * 6F706572616E642031203D200 .ascii "operand 1 = \0"
269: 0
270: 265 000004d2 * .text
271: 266 00032CB8 dd 8f000004c5 pushl $L245
272: 267 00032CBE fe 08 effffffdbf callf $8,_writes
273: 268 00032CC5 # write32h( dbl_value_1.m );
274: 269 00032CC5 dd effffffdb9 pushl _dbl_value_1
275: 270 00032CCB fe 08 effffffdb2 callf $8,_write32h
276: 271 00032CD2 # writec(' ');
277: 272 00032CD2 dd 20 pushl $32
278: 273 00032CD4 fe 08 effffffda9 callf $8,_writec
279: 274 00032CDB # write32h( dbl_value_1.l );
280: 275 00032CDB dd effffffda7 pushl _dbl_value_1+4
281: 276 00032CE1 fe 08 effffffd9c callf $8,_write32h
282: 277 00032CE8 # writes(", final Acc = ");
283: 278 00032CE8 .data 1
284: 279 000004d2 * L248:
285: 280 000004d2 * 2C2020202066696E616C20416 .ascii ", final Acc = \0"
286: 363203D2000
287: 281 000004e4 * .text
288: 282 00032CE8 dd 8f000004d2 pushl $L248
289: 283 00032CEE fe 08 effffffd8f callf $8,_writes
290: 284 00032CF5 # write32h( dbl_st_acc.m );
291: 285 00032CF5 dd effffffd89 pushl _dbl_st_acc
292: 286 00032CFB fe 08 effffffd82 callf $8,_write32h
293: 287 00032D02 # writec(' ');
294: 288 00032D02 dd 20 pushl $32
295: 289 00032D04 fe 08 effffffd79 callf $8,_writec
296: 290 00032D0B # write32h( dbl_st_acc.l );
297: 291 00032D0B dd effffffd77 pushl _dbl_st_acc+4
298: 292 00032D11 fe 08 effffffd6c callf $8,_write32h
299: 293 00032D18 # writes(", index = ");
300: 294 00032D18 .data 1
301: 295 000004e4 * L249:
302: 296 000004e4 * 2C2020696E646578203D2000 .ascii ", index = \0"
303: 297 000004f0 * .text
304: 298 00032D18 dd 8f000004e4 pushl $L249
305: 299 00032D1E fe 08 effffffd5f callf $8,_writes
306: 300 00032D25 # writed( index );
307: 301 00032D25 dd effffffd59 pushl _index
308: 302 00032D2B fe 08 effffffd52 callf $8,_writed
309: 303 00032D32 # writes("\noperand 2 = ");
310: 304 00032D32 .data 1
311: 305 000004f0 * L250:
312: 306 000004f0 * 0A6F706572616E642032203D2 .ascii "\12operand 2 = \0"
313: 000
314: 307 000004fe * .text
315: 308 00032D32 dd 8f000004f0 pushl $L250
316: 309 00032D38 fe 08 effffffd45 callf $8,_writes
317: 310 00032D3F # write32h( dbl_value_2.m );
318: 311 00032D3F dd effffffd3f pushl _dbl_value_2
319: 312 00032D45 fe 08 effffffd38 callf $8,_write32h
320: 313 00032D4C # writec(' ');
321: 314 00032D4C dd 20 pushl $32
322: 315 00032D4E fe 08 effffffd2f callf $8,_writec
323: 316 00032D55 # write32h( dbl_value_2.l );
324: 317 00032D55 dd effffffd2d pushl _dbl_value_2+4
325: 318 00032D5B fe 08 effffffd22 callf $8,_write32h
326: 319 00032D62 # writes(", expected Acc = ");
327: 320 00032D62 .data 1
328: 321 000004fe * L251:
329: 322 000004fe * 2C20657870656374656420416 .ascii ", expected Acc = \0"
330: 363203D2000
331: 323 00000510 * .text
332: 324 00032D62 dd 8f000004fe pushl $L251
333: 325 00032D68 fe 08 effffffd15 callf $8,_writes
334: 326 00032D6F # write32h( dbl_expected.m );
335: 327 00032D6F dd effffffd0f pushl _dbl_expected
336: 328 00032D75 fe 08 effffffd08 callf $8,_write32h
337: 329 00032D7C # writec(' ');
338: 330 00032D7C dd 20 pushl $32
339: 331 00032D7E fe 08 effffffcff callf $8,_writec
340: 332 00032D85 # write32h( dbl_expected.l );
341: 333 00032D85 dd effffffcfd pushl _dbl_expected+4
342: 334 00032D8B fe 08 effffffcf2 callf $8,_write32h
343: 335 00032D92 # writes("\noperand 3 = ");
344: 336 00032D92 .data 1
345: 337 00000510 * L252:
346: 338 00000510 * 0A6F706572616E642033203D2 .ascii "\12operand 3 = \0"
347: 000
348: 339 0000051e * .text
349: 340 00032D92 dd 8f00000510 pushl $L252
350: 341 00032D98 fe 08 effffffce5 callf $8,_writes
351: 342 00032D9F # write32h( dbl_value_3.m );
352: 343 00032D9F dd effffffcdf pushl _dbl_value_3
353: 344 00032DA5 fe 08 effffffcd8 callf $8,_write32h
354: 345 00032DAC # writec(' ');
355: 346 00032DAC dd 20 pushl $32
356: 347 00032DAE fe 08 effffffccf callf $8,_writec
357: 348 00032DB5 # write32h( dbl_value_3.l );
358: 349 00032DB5 dd effffffccd pushl _dbl_value_3+4
359: 350 00032DBB fe 08 effffffcc2 callf $8,_write32h
360: 351 00032DC2 # writes(", CVDL result = ");
361: 352 00032DC2 .data 1
362: 353 0000051e * L253:
363: 354 0000051e * 2C20204356444C20726573756 .ascii ", CVDL result = \0"
364: C74203D2000
365: 355 00000530 * .text
366: 356 00032DC2 dd 8f0000051e pushl $L253
367: 357 00032DC8 fe 08 effffffcb5 callf $8,_writes
368: 358 00032DCF # write32h( sgl_value_6 );
369: 359 00032DCF dd effffffcaf pushl _sgl_value_6
370: 360 00032DD5 fe 08 effffffca8 callf $8,_write32h
371: 361 00032DDC # writec('\n');
372: 362 00032DDC dd 0a pushl $10
373: 363 00032DDE fe 08 effffffc9f callf $8,_writec
374: 364 00032DE5 # writes(" int expected = ");
375: 365 00032DE5 .data 1
376: 366 00000530 * L254:
377: 367 00000530 * 2020202020202020202020202 .ascii " int expected = \0"
378: 0202020202020202020202020
379: 202020202020696E742065787
380: 06563746564203D2000
381: 368 0000055f * .text
382: 369 00032DE5 dd 8f00000530 pushl $L254
383: 370 00032DEB fe 08 effffffc92 callf $8,_writes
384: 371 00032DF2 # write32h( index2 );
385: 372 00032DF2 dd effffffc8c pushl _index2
386: 373 00032DF8 fe 08 effffffc85 callf $8,_write32h
387: 374 00032DFF # writec('\n');
388: 375 00032DFF dd 0a pushl $10
389: 376 00032E01 fe 08 effffffc7c callf $8,_writec
390: 377 00032E08 # }
391: 378 00032E08 40 ret#2
392: 379 00032E09 .set L235,0x0
393: 380 00032E09 L237:
394: 381 00032E09 13 fe51 jbr L238
395: 382 00032E0C .data
396: 383 00000464 * .text
397: 384 00032E0C .align 1
398: 385 00032E0C .globl _pipe18_halt
399: 386 00032E0C _pipe18_halt:
400: 387 00032E0C 0000 .word L255
401: 388 00032E0E #
402: 389 00032E0E #
403: 390 00032E0E #
404: 391 00032E0E # /*
405: 392 00032E0E # **************************************************************************
406: 393 00032E0E # *
407: 394 00032E0E # * HALT ON AN ERROR
408: 395 00032E0E # *
409: 396 00032E0E # **************************************************************************
410: 397 00032E0E # */
411: 398 00032E0E # pipe18_halt()
412: 399 00032E0E # {
413: 400 00032E0E 13 00d1 jbr L257
414: 401 00032E11 L258:
415: 402 00032E11 # sgl_value_1 = dbl_value_1.m;
416: 403 00032E11 0d effffffc6d effffffc68 movl _dbl_value_1,_sgl_value_1
417: 404 00032E1C # sgl_value_2 = dbl_value_1.l;
418: 405 00032E1C 0d effffffc66 effffffc5d movl _dbl_value_1+4,_sgl_value_2
419: 406 00032E27 # sgl_value_3 = dbl_value_2.m;
420: 407 00032E27 0d effffffc57 effffffc52 movl _dbl_value_2,_sgl_value_3
421: 408 00032E32 # sgl_value_4 = dbl_value_2.l;
422: 409 00032E32 0d effffffc50 effffffc47 movl _dbl_value_2+4,_sgl_value_4
423: 410 00032E3D # asm("movl _test_no,r0"); /* r0 = test number */
424: 411 00032E3D 0d effffffc41 50 movl _test_no,r0
425: 412 00032E44 # asm("movl $1,r1"); /* r1 = subtest number */
426: 413 00032E44 0d 01 51 movl $1,r1
427: 414 00032E47 # asm("movl $1,r2"); /* r2 = error code */
428: 415 00032E47 0d 01 52 movl $1,r2
429: 416 00032E4A # asm("movl _cycle,r3"); /* r3 = cycle count */
430: 417 00032E4A 0d effffffc34 53 movl _cycle,r3
431: 418 00032E51 # asm("movl _sgl_value_1,r4"); /* r4 = MS of dbl operand #1 */
432: 419 00032E51 0d effffffc2d 54 movl _sgl_value_1,r4
433: 420 00032E58 # asm("movl _sgl_value_2,r5"); /* r5 = LS of dbl operand #1 */
434: 421 00032E58 0d effffffc26 55 movl _sgl_value_2,r5
435: 422 00032E5F # asm("movl _sgl_value_3,r6"); /* r6 = MS of dbl operand #2 */
436: 423 00032E5F 0d effffffc1f 56 movl _sgl_value_3,r6
437: 424 00032E66 # asm("movl _sgl_value_4,r7"); /* r7 = LS of dbl operand #2 */
438: 425 00032E66 0d effffffc18 57 movl _sgl_value_4,r7
439: 426 00032E6D # sgl_value_1 = dbl_st_acc.m;
440: 427 00032E6D 0d effffffc11 effffffc0c movl _dbl_st_acc,_sgl_value_1
441: 428 00032E78 # sgl_value_2 = dbl_st_acc.l;
442: 429 00032E78 0d effffffc0a effffffc01 movl _dbl_st_acc+4,_sgl_value_2
443: 430 00032E83 # sgl_value_3 = dbl_expected.m;
444: 431 00032E83 0d effffffbfb effffffbf6 movl _dbl_expected,_sgl_value_3
445: 432 00032E8E # sgl_value_4 = dbl_expected.l;
446: 433 00032E8E 0d effffffbf4 effffffbeb movl _dbl_expected+4,_sgl_value_4
447: 434 00032E99 # sgl_value_5 = dbl_value_3.m;
448: 435 00032E99 0d effffffbe5 effffffbe0 movl _dbl_value_3,_sgl_value_5
449: 436 00032EA4 # sgl_value_6 = dbl_value_3.l;
450: 437 00032EA4 0d effffffbde effffffbd5 movl _dbl_value_3+4,_sgl_value_6
451: 438 00032EAF # asm("movl _sgl_value_5,r8"); /* r8 = MS of dbl operand #3 */
452: 439 00032EAF 0d effffffbcf 58 movl _sgl_value_5,r8
453: 440 00032EB6 # asm("movl _sgl_value_6,r9"); /* r9 = LS of dbl operand #3 */
454: 441 00032EB6 0d effffffbc8 59 movl _sgl_value_6,r9
455: 442 00032EBD # asm("movl _sgl_value_1,r10"); /* r10 = MS of final result */
456: 443 00032EBD 0d effffffbc1 5a movl _sgl_value_1,r10
457: 444 00032EC4 # asm("movl _sgl_value_2,r11"); /* r11 = LS of final result */
458: 445 00032EC4 0d effffffbba 5b movl _sgl_value_2,r11
459: 446 00032ECB # asm("movl _sgl_value_3,r12"); /* r12 = MS of expected result */
460: 447 00032ECB 0d effffffbb3 5c movl _sgl_value_3,r12
461: 448 00032ED2 # asm("movl _sgl_value_4,r13"); /* r13 = LS of expected result */
462: 449 00032ED2 0d effffffbac 5d movl _sgl_value_4,r13
463: 450 00032ED9 # asm("movl _index,r14"); /* r14 = data index */
464: 451 00032ED9 0d effffffba5 5e movl _index,r14
465: 452 00032EE0 # asm("halt"); /* HALT ... */
466: 453 00032EE0 00 halt
467: 454 00032EE1 # }
468: 455 00032EE1 40 ret#2
469: 456 00032EE2 .set L255,0x0
470: 457 00032EE2 L257:
471: 458 00032EE2 13 ff2c jbr L258
472: 459 00032EE5 .data
473: 460 00000464 * #
474: 460 00000464 * #
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.