![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mul.c 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 / entry|
Return to mul.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / entry |
1.1 root 1: #define error_hdl2 error
2: #define error_hdl3 error
3:
4: #define C 0x1
5: #define V 0x2
6: #define Z 0x4
7: #define N 0x8
8:
9: extern long scoplp;
10: extern long force_lp;
11:
12: /* MUL instruction */
13:
14: /* some global variables used in ASM */
15: static long flag_msk, psl, product, mult, muld, mulp, add, prod1, prod2;
16: static long exp_reslt1, exp_reslt2;
17:
18: mul()
19: {
20: asm("movl $2,_no_opr"); /* number of operands in use */
21: mull2(); /* Test MULL2 instruction */
22: mull3(); /* Test MULL3 instruction */
23: exmul(); /* Test EMUL instruction */
24: asm("jmp *return");
25: }
26:
27: static mull2()
28: { long exp_psw , ix;
29:
30: /* multiply long with 2 operands */
31: for(ix=0;ix<2;ix++)
32: {
33: setjmp();
34: asm("m1: movab m1,_stpc");
35: flag_msk = exp_psw = C;
36: flag_msk = N|Z|V|C;
37: if (ix==0) {
38: mult = 0xabcde;
39: mulp = 0xaba; }
40: else {
41: mulp = 0xabcde;
42: mult = 0xaba; }
43: mull(2,0x732de54c,exp_psw);
44: }
45:
46: for(ix=0;ix<2;ix++)
47: {
48: asm("m2: movab m2,_stpc");
49: flag_msk = exp_psw = C;
50: flag_msk = N|Z|V|C;
51: if (ix==0) {
52: mult = -200;
53: mulp = -1000; }
54: else {
55: mulp = -200;
56: mult = -1000; }
57: mull(2,200000,exp_psw);
58: }
59:
60: for(ix=0;ix<2;ix++)
61: {
62: asm("m3: movab m3,_stpc");
63: flag_msk = exp_psw = 0;
64: flag_msk = Z|V|C; /* set all flags except N */
65: exp_psw = N | C;
66: if (ix==0) {
67: mult = 1234;
68: mulp = -500; }
69: else {
70: mulp = 1234;
71: mult = -500; }
72: mull(2,-617000,exp_psw);
73: }
74:
75: for(ix=0;ix<2;ix++)
76: {
77: asm("m4: movab m4,_stpc");
78: flag_msk = exp_psw = 0;
79: flag_msk = N|V|C; /* set all flags except Z */
80: exp_psw = Z | C;
81: if (ix==0) {
82: mult = 0x1234;
83: mulp = 0; }
84: else {
85: mulp = 0x1234;
86: mult = 0; }
87: mull(2,0,exp_psw);
88: }
89:
90: /* test V bit, Overflow */
91: for(ix=0;ix<2;ix++)
92: {
93: asm("m5: movab m5,_stpc");
94: flag_msk = exp_psw = 0;
95: exp_psw = (V); /* any other flags may be set */
96: if (ix==0) {
97: mult = 0x80000000; /* Max negative no. */
98: mulp = -1; }
99: else {
100: mulp = 0x80000000;
101: mult = -1; }
102: mull(2,0,exp_psw);
103: }
104:
105: for(ix=0;ix<2;ix++)
106: {
107: asm("m6: movab m6,_stpc");
108: flag_msk = exp_psw = 0;
109: exp_psw = (V); /* any other flags may be set */
110: if (ix==0) {
111: mult = -65646;
112: mulp = 65646; }
113: else {
114: mulp = -65646;
115: mult = 65646; }
116: mull(2,0,exp_psw);
117: }
118: }
119:
120: static mull3()
121: { long exp_psw , ix;
122:
123: /* multiply long with 3 operands */
124: for(ix=0;ix<2;ix++)
125: {
126: asm("m7: movab m7,_stpc");
127: flag_msk = exp_psw = C;
128: flag_msk = N|Z|V|C;
129: if (ix==0) {
130: mult = 0x12345;
131: mulp = 0xbff; }
132: else {
133: mulp = 0x12345;
134: mult = 0xbff; }
135: mull(3,0xda618bb,exp_psw);
136: }
137:
138: for(ix=0;ix<2;ix++)
139: {
140: asm("m8: movab m8,_stpc");
141: flag_msk = exp_psw = C;
142: flag_msk = N|Z|V|C;
143: if (ix==0) {
144: mult = -3001;
145: mulp = -300; }
146: else {
147: mulp = -3001;
148: mult = -300; }
149: mull(3,900300,exp_psw);
150: }
151:
152: for(ix=0;ix<2;ix++)
153: {
154: asm("m9: movab m9,_stpc");
155: flag_msk = exp_psw = 0;
156: flag_msk = Z|V|C; /* set all flags except N */
157: exp_psw = N | C;
158: if (ix==0) {
159: mult = 1234;
160: mulp = -500; }
161: else {
162: mulp = 1234;
163: mult = -500; }
164: mull(3,-617000,exp_psw);
165: }
166:
167: for(ix=0;ix<2;ix++)
168: {
169: asm("m10: movab m10,_stpc");
170: flag_msk = exp_psw = 0;
171: flag_msk = N|V; /* set all flags except Z,C */
172: exp_psw = Z | C;
173: if (ix==0) {
174: mult = 0x1234;
175: mulp = 0; }
176: else {
177: mulp = 0x1234;
178: mult = 0; }
179: mull(3,0,exp_psw);
180: }
181:
182: /* test V bit */
183: for(ix=0;ix<2;ix++)
184: {
185: asm("m11: movab m11,_stpc");
186: flag_msk = exp_psw = 0;
187: exp_psw = (V); /* any other flags may be set */
188: if (ix==0) {
189: mult = 0x80000000; /* Max negative no. */
190: mulp = -1; }
191: else {
192: mulp = 0x80000000; /* Max negative no. */
193: mult = -1; }
194: mull(3,0,exp_psw);
195: }
196:
197: for(ix=0;ix<2;ix++)
198: {
199: asm("m12: movab m12,_stpc");
200: flag_msk = exp_psw = 0;
201: exp_psw = (V); /* any other flags may be set */
202: if (ix==0) {
203: mult = -65646;
204: mulp = 65646; }
205: else {
206: mulp = -65646;
207: mult = 65646; }
208: mull(3,0,exp_psw);
209: }
210: }
211:
212: static exmul()
213: { long exp_psw ;
214:
215: /* extended multiply */
216:
217: asm("m13: movab m13,_stpc");
218: flag_msk = exp_psw = 0;
219: flag_msk = N|V|C; /* set N,V,C flags */
220: exp_psw = Z | C;
221: exp_reslt1 = 0;
222: exp_reslt2 = 0;
223: /* mult = -4; */
224: asm("movl $-4,_mult"); /* so not to use mnegl */
225: muld = 5;
226: add = 20;
227: emul(exp_psw);
228:
229: asm("m14: movab m14,_stpc");
230: flag_msk = exp_psw = 0;
231: flag_msk = Z|V|C; /* set Z,V,C flags */
232: exp_psw = N | C;
233: asm("movl $0xffffffff,_exp_reslt1");
234: asm("movl $0xffffffff,_exp_reslt2");
235: /* exp_reslt1 = 0xffffffff;
236: exp_reslt2 = 0xffffffff; */
237:
238: /* Expected result is a quad : 0xffffffffffffffff (-1) */
239: mult = -4000;
240: muld = 50;
241: add = 199999;
242: emul(exp_psw);
243:
244: asm("m15: movab m15,_stpc");
245: flag_msk = exp_psw = C;
246: flag_msk = N|Z|V|C; /* set all flags */
247: exp_reslt2 = 0x60000000 ;
248: exp_reslt1 = 0x01000000 ;
249:
250: /* Expected result is a quad : 0x0100000060000000 */
251: mult = 0xfffffff;
252: muld = 0xfffffff;
253: add = 0x7fffffff;
254: emul(exp_psw);
255: }
256:
257: /* ROUTINE TO EXECUTE MULL2 AND MULL3 */
258:
259: static mull(type,exp_result,exp_psw)
260: long exp_result, exp_psw, type;
261: {
262: long op1, op2, psw, ix;
263: char *msg1, *msg2;
264:
265: flag_msk = flag_msk << 16;
266: op1 = mult;
267: op2 = mulp;
268: for(;;)
269: {
270: for (ix=0;ix<8;ix++)
271: {
272: mult = op1;
273: mulp = op2;
274:
275: /* set flags */
276: if (type == 2) {
277: if (ix==0) { /* Memory to memory */
278: setjmp();
279: asm("movl $1,_subtst");
280: asm("bicpsw $0xf");
281: asm("bispsw _flag_msk"); /* set flags */
282: asm("mull2 _mult,_mulp");
283: asm("movpsl _psl"); /* save PSL */
284: product = mulp;
285: }
286: if (ix==1) { /* Register to register */
287: setjmp();
288: asm("movl $2,_subtst");
289: asm("movl _mult,r3");
290: asm("movl _mulp,r4");
291: asm("bicpsw $0xf");
292: asm("bispsw _flag_msk"); /* set flags */
293: asm("mull2 r3,r4");
294: asm("movpsl _psl"); /* save PSL */
295: asm("movl r4,_mulp");
296: product = mulp;
297: }
298: if (ix==2) { /* Memory to register */
299: setjmp();
300: asm("movl $3,_subtst");
301: asm("movl _mulp,r4");
302: asm("bicpsw $0xf");
303: asm("bispsw _flag_msk"); /* set flags */
304: asm("mull2 _mult,r4");
305: asm("movpsl _psl"); /* save PSL */
306: asm("movl r4,_mulp");
307: product = mulp;
308: }
309: if (ix==3) { /* Register to memory */
310: setjmp();
311: asm("movl $4,_subtst");
312: asm("movl _mult,r3");
313: asm("bicpsw $0xf");
314: asm("bispsw _flag_msk"); /* set flags */
315: asm("mull2 r3,_mulp");
316: asm("movpsl _psl"); /* save PSL */
317: product = mulp;
318: }
319: }
320: else {
321: if (ix==0) { /* Memory to memory to memory */
322: setjmp();
323: asm("movl $5,_subtst");
324: asm("bicpsw $0xf");
325: asm("bispsw _flag_msk"); /* set flags */
326: asm("mull3 _mult,_mulp,_product");
327: asm("movpsl _psl"); /* save PSL */
328: }
329: if (ix==1) { /* Register to register to register */
330: setjmp();
331: asm("movl $6,_subtst");
332: asm("movl _mult,r3");
333: asm("movl _mulp,r4");
334: asm("bicpsw $0xf");
335: asm("bispsw _flag_msk"); /* set flags */
336: asm("mull3 r3,r4,r6");
337: asm("movpsl _psl"); /* save PSL */
338: asm("movl r6,_product");
339: }
340: if (ix==2) { /* Memory to register to memory */
341: setjmp();
342: asm("movl $7,_subtst");
343: asm("movl _mulp,r4");
344: asm("bicpsw $0xf");
345: asm("bispsw _flag_msk"); /* set flags */
346: asm("mull3 _mult,r4,_product");
347: asm("movpsl _psl"); /* save PSL */
348: }
349: if (ix==3) { /* Register to memory to register */
350: setjmp();
351: asm("movl $8,_subtst");
352: asm("movl _mult,r3");
353: asm("bicpsw $0xf");
354: asm("bispsw _flag_msk"); /* set flags */
355: asm("mull3 r3,_mulp,r6");
356: asm("movpsl _psl"); /* save PSL */
357: asm("movl r6,_product");
358: }
359: if (ix==4) { /* Register to register to memory */
360: setjmp();
361: asm("movl $9,_subtst");
362: asm("movl _mult,r3");
363: asm("movl _mulp,r4");
364: asm("bicpsw $0xf");
365: asm("bispsw _flag_msk"); /* set flags */
366: asm("mull3 r3,r4,_product");
367: asm("movpsl _psl"); /* save PSL */
368: }
369: if (ix==5) { /* Memory to register to register */
370: setjmp();
371: asm("movl $0xa,_subtst");
372: asm("movl _mulp,r4");
373: asm("bicpsw $0xf");
374: asm("bispsw _flag_msk"); /* set flags */
375: asm("mull3 _mult,r4,r6");
376: asm("movpsl _psl"); /* save PSL */
377: asm("movl r6,_product");
378: }
379: if (ix==6) { /* Register to memory to memory */
380: setjmp();
381: asm("movl $0xb,_subtst");
382: asm("movl _mult,r3");
383: asm("bicpsw $0xf");
384: asm("bispsw _flag_msk"); /* set flags */
385: asm("mull3 r3,_mulp,_product");
386: asm("movpsl _psl"); /* save PSL */
387: }
388: if (ix==7) { /* Memory to memory to register */
389: setjmp();
390: asm("movl $0xc,_subtst");
391: asm("bicpsw $0xf");
392: asm("bispsw _flag_msk"); /* set flags */
393: asm("mull3 _mult,_mulp,r6");
394: asm("movpsl _psl"); /* save PSL */
395: asm("movl r6,_product");
396: }
397: }
398: psw = psl & 0xf; /* mask out high order word of PSL */
399:
400: /* check flags */
401:
402: if (exp_psw & V){ /* On expected overflows */
403: if( !(psw & V) ) { /* We only look at the (V) flag */
404: asm("movl $2,_ercode");
405: if (scoplp) longjmp();
406: error_hdl2(psw,exp_psw,op1,op2);
407: }
408: continue; /* skip other checks */
409: }
410: else if (psw != exp_psw)
411: {
412: asm("movl $2,_ercode");
413: if (scoplp) longjmp();
414: error_hdl2(psw,exp_psw,op1,op2);
415: }
416: if (mult != op1)
417: {
418: asm("movl $3,_ercode");
419: if (scoplp) longjmp();
420: error_hdl2(mult,op1,op1,op2);
421: }
422: if (type == 3)
423: {
424: if (mulp != op2)
425: {
426: asm("movl $3,_ercode");
427: if (scoplp) longjmp();
428: error_hdl2(mulp,op2,op1,op2);
429: }
430: }
431: if (product != exp_result)
432: { /* error in multiply operation */
433: asm("movl $1,_ercode");
434: if (scoplp) longjmp();
435: error_hdl2(product,exp_result,op1,op2);
436: }
437: if (force_lp) longjmp();
438: }
439: break;
440: }
441: }
442:
443: /* ROUTINE TO EXECUTE EMUL */
444:
445: static emul(exp_psw)
446: long exp_psw;
447: {
448: long op1, op2, op3, psw, type;
449: char *msg1, *msg2;
450:
451: flag_msk = flag_msk << 16;
452: op1 = mult;
453: op2 = muld;
454: op3 = add;
455: for(;;)
456: {
457: msg1 = "** Test EMUL **\n";
458: for(type=0;type<8;type++)
459: {
460: mult = op1;
461: muld = op2;
462: add = op3;
463:
464: if (type==0) { /* Memory memory memory memory */
465: asm("movl $0xd,_subtst");
466: asm("bicpsw $0xf"); /* clear all flags */
467: asm("bispsw _flag_msk"); /* set flags */
468: asm("emul _mult,_muld,_add,_prod1");
469: asm("movpsl _psl"); /* save PSL */
470: psw = psl & 0xf;
471: }
472: if (type==1) { /* Register,register,register register */
473: asm("movl $0xe,_subtst");
474: asm("movl _mult,r3");
475: asm("movl _muld,r4");
476: asm("movl _add,r5");
477: asm("bicpsw $0xf"); /* clear all flags */
478: asm("bispsw _flag_msk"); /* set flags */
479: asm("emul r3,r4,r5,r6");
480: asm("movpsl _psl"); /* save PSL */
481: psw = psl & 0xf;
482: asm("movl r6,_prod1");
483: asm("movl r7,_prod2");
484: }
485: if (type==2) { /* Register register Memory memory */
486: asm("movl $0xf,_subtst");
487: asm("movl _mult,r3");
488: asm("movl _muld,r4");
489: asm("bicpsw $0xf"); /* clear all flags */
490: asm("bispsw _flag_msk"); /* set flags */
491: asm("emul r3,r4,_add,_prod1");
492: asm("movpsl _psl"); /* save PSL */
493: psw = psl & 0xf;
494: }
495: if (type==3) { /* Register memory Memory register */
496: asm("movl $0x10,_subtst");
497: asm("movl _mult,r3");
498: asm("bicpsw $0xf"); /* clear all flags */
499: asm("bispsw _flag_msk"); /* set flags */
500: asm("emul r3,_muld,_add,r6");
501: asm("movpsl _psl"); /* save PSL */
502: psw = psl & 0xf;
503: asm("movl r6,_prod1");
504: asm("movl r7,_prod2");
505: }
506: if (type==4) { /* Memory memory register memory */
507: asm("movl $0x11,_subtst");
508: asm("movl _add,r5");
509: asm("bicpsw $0xf"); /* clear all flags */
510: asm("bispsw _flag_msk"); /* set flags */
511: asm("emul _mult,_muld,r5,_prod1");
512: asm("movpsl _psl"); /* save PSL */
513: psw = psl & 0xf;
514: }
515: if (type==5) { /* Register memory register memory */
516: asm("movl $0x12,_subtst");
517: asm("movl _mult,r3");
518: asm("movl _add,r5");
519: asm("bicpsw $0xf"); /* clear all flags */
520: asm("bispsw _flag_msk"); /* set flags */
521: asm("emul r3,_muld,r5,_prod1");
522: asm("movpsl _psl"); /* save PSL */
523: psw = psl & 0xf;
524: }
525: if (type==6) { /* Memory register register memory */
526: asm("movl $0x13,_subtst");
527: asm("movl _muld,r4");
528: asm("movl _add,r5");
529: asm("bicpsw $0xf"); /* clear all flags */
530: asm("bispsw _flag_msk"); /* set flags */
531: asm("emul _mult,r4,r5,_prod1");
532: asm("movpsl _psl"); /* save PSL */
533: psw = psl & 0xf;
534: }
535: if (type==7) { /* Memory register memory register */
536: asm("movl $0x14,_subtst");
537: asm("movl _muld,r4");
538: asm("bicpsw $0xf"); /* clear all flags */
539: asm("bispsw _flag_msk"); /* set flags */
540: asm("emul _mult,r4,_add,r6");
541: asm("movpsl _psl"); /* save PSL */
542: psw = psl & 0xf;
543: asm("movl r6,_prod1");
544: asm("movl r7,_prod2");
545: }
546:
547: if ( prod1 != exp_reslt1)
548: { /* error in ext. multiply operation */
549: asm("movl $1,_ercode");
550: if (scoplp) longjmp();
551: error(prod1,exp_reslt1,op1,op2);
552: }
553: if ( prod2 != exp_reslt2 )
554: { /* error in ext. multiply operation */
555: asm("movl $1,_ercode");
556: if (scoplp) longjmp();
557: error(prod2,exp_reslt2,op1,op2);
558: }
559: /* check flags */
560: if (psw!=exp_psw)
561: {
562: asm("movl $3,_no_opr");
563: asm("movl $2,_ercode");
564: if (scoplp) longjmp();
565: error_hdl3(psw,exp_psw,op1,op2,op3);
566: }
567:
568: if (mult != op1)
569: {
570: asm("movl $3,_no_opr");
571: asm("movl $3,_ercode");
572: if (scoplp) longjmp();
573: error_hdl3(mult,op1,op1,op2,op3);
574: }
575: if (muld != op2)
576: {
577: asm("movl $3,_no_opr");
578: asm("movl $3,_ercode");
579: if (scoplp) longjmp();
580: error_hdl3(muld,op2,op1,op2,op3);
581: }
582: if (add != op3)
583: {
584: asm("movl $3,_no_opr");
585: asm("movl $3,_ercode");
586: if (scoplp) longjmp();
587: error_hdl3(add,op3,op1,op2,op3);
588: }
589: if (force_lp) longjmp();
590: }
591: break;
592: }
593: }
594:
595:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.