![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to xor.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 xor.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / entry |
1.1 root 1: #define error_hdl2 error
2:
3: #define C 0x1
4: #define V 0x2
5: #define Z 0x4
6: #define N 0x8
7:
8: extern long scoplp;
9: extern long force_lp;
10: extern long no_opr;
11: extern long opr;
12:
13: /* Some globals */
14: static long flag_msk, mask, src, dest, psl;
15:
16: int ix;
17:
18: /* XOR instructions */
19:
20: x_or()
21: {
22: xorb2();
23: xorb3();
24: xorw2();
25: xorw3();
26: xorl2();
27: xorl3();
28: asm("jmp *return");
29: }
30:
31: static xorb2()
32: {
33: long exp_psw, no_op;
34: char op_type;
35: for (ix = 1; ix < 7; ix ++)
36:
37: {
38: no_op = 2;
39: op_type ='b';
40: no_opr = 2;
41:
42: /* XOR 2 BYTE_OPERANDS */
43: flag_msk = exp_psw = 0;
44: flag_msk = N|V|C; /* set N,V,C flag */
45: exp_psw = Z|C;
46: mask = 123;
47: src = 123;
48: xor(op_type,no_op,0,exp_psw);
49: ix = ix + 1; /* increment ix */
50:
51: flag_msk = exp_psw = 0;
52: flag_msk = Z|V|C; /* set Z,V,C flag */
53: exp_psw = N|C;
54: mask = 0x81;
55: src = 3;
56: xor(op_type,no_op,0x82,exp_psw);
57: }
58: }
59:
60: static xorb3()
61: {
62: long exp_psw, no_op;
63: char op_type;
64: for (ix = 1; ix < 11; ix ++)
65: {
66:
67: no_op = 3;
68: no_opr = 3;
69: op_type ='b';
70:
71: /* XOR 3 BYTE_OPERANDS */
72: flag_msk = exp_psw = 0;
73: flag_msk = N|V|C; /* set N,V,C flag */
74: exp_psw = Z|C;
75: mask = 0xff;
76: src = 0xff;
77: xor(op_type,no_op,0,exp_psw);
78: ix = ix + 1; /* increment ix = execution counter */
79:
80: flag_msk = exp_psw = 0;
81: flag_msk = Z|V|C; /* set Z,V,C flag */
82: exp_psw = N|C;
83: mask = 0xaa;
84: src = 1;
85: xor(op_type,no_op,0xab,exp_psw);
86: }
87: }
88:
89: static xorw2()
90: {
91: long exp_psw, no_op;
92: char op_type;
93: for (ix = 1; ix < 7; ix ++)
94: {
95:
96: no_op = 2;
97: no_opr = 2;
98: op_type ='w';
99:
100: /* XOR 2 WORD_OPERANDS */
101: flag_msk = exp_psw = 0;
102: flag_msk = N|V|C; /* set N,V,C flag */
103: exp_psw = Z|C;
104: mask = 0xffff;
105: src = 0xffff;
106: xor(op_type,no_op,0,exp_psw);
107: ix = ix + 1; /* increment ix = execution counter */
108:
109: flag_msk = exp_psw = 0;
110: flag_msk = Z|V|C; /* set Z,V,C flag */
111: exp_psw = N|C;
112: mask = 0xbbbb;
113: src = 3;
114: xor(op_type,no_op,0xbbb8,exp_psw);
115: }
116: }
117:
118: static xorw3()
119: {
120: long exp_psw, no_op;
121: char op_type;
122: for (ix = 1; ix < 11; ix ++)
123: {
124:
125: no_op = 3;
126: no_opr = 3;
127: op_type ='w';
128:
129: /* XOR 3 WORD_OPERANDS */
130: flag_msk = exp_psw = 0;
131: flag_msk = N|V|C; /* set N,V,C flag */
132: exp_psw = Z|C;
133: mask = 0xff01;
134: src = 0xff01;
135: xor(op_type,no_op,0,exp_psw);
136: ix = ix + 1; /* increment ix = execution counter */
137:
138: flag_msk = exp_psw = 0;
139: flag_msk = Z|V|C; /* set Z,V,C flag */
140: exp_psw = N|C;
141: mask = 0xaa00;
142: src = 0x7001;
143: xor(op_type,no_op,0xda01,exp_psw);
144: }
145: }
146:
147: static xorl2()
148: {
149: long exp_psw, no_op;
150: char op_type;
151: for (ix = 1; ix < 5; ix ++)
152: {
153:
154: no_op = 2;
155: no_opr = 2;
156: op_type ='l';
157:
158: /* XOR 2 LONG_OPERANDS */
159: flag_msk = exp_psw = 0;
160: flag_msk = N|V|C; /* set N,V,C flag */
161: exp_psw = Z|C;
162: mask = 0xffffabab;
163: src = 0xffffabab;
164: xor(op_type,no_op,0,exp_psw);
165: ix = ix + 1; /* increment ix = execution counter */
166:
167: flag_msk = exp_psw = 0;
168: flag_msk = Z|V|C; /* set Z,V,C flag */
169: exp_psw = N|C;
170: mask = 0xccccbbbb;
171: src = 0x70000001;
172: xor(op_type,no_op,0xbcccbbba,exp_psw);
173: }
174: }
175:
176: static xorl3()
177: {
178: long exp_psw, no_op;
179: char op_type;
180: for (ix = 1; ix < 10; ix ++)
181: {
182:
183: no_op = 3;
184: no_opr = 3;
185: op_type ='l';
186:
187: /* XOR 3 LONG_OPERANDS */
188: flag_msk = exp_psw = 0;
189: flag_msk = N|V|C; /* set N,V,C flag */
190: exp_psw = Z|C;
191: mask = 0xffffff01;
192: src = 0xffffff01;
193: xor(op_type,no_op,0,exp_psw);
194: ix = ix + 1; /* increment ix = execution counter */
195:
196: flag_msk = exp_psw = 0;
197: flag_msk = Z|V|C; /* set Z,V,C flag */
198: exp_psw = N|C;
199: mask = 0xddddaa00;
200: src = 0x7001dddd;
201: xor(op_type,no_op,0xaddc77dd,exp_psw);
202: }
203:
204: }
205:
206: /* This routine execute XORB2,XORB3,XORW2,XORW3,XORL2,XORL3 instructions */
207:
208: static xor(op_type,no_op,exp_reslt,exp_psw)
209: long exp_reslt, exp_psw, no_op;
210: char op_type;
211: {
212: long op1, op2, psw;
213: char *msg1, *msg2;
214:
215: flag_msk = flag_msk << 16;
216: op1 = mask;
217: op2 = src;
218: for(;;)
219: {
220:
221: if (op_type == 'b')
222: {
223: if (no_op==2)
224: {
225: asm("bicpsw $0xf"); /* clear all flags */
226: asm("bispsw _flag_msk");
227:
228: asm(".globl _xorbb2");
229: asm("_xorbb2:");
230:
231: if (ix==1){
232: setjmp();
233: asm("x1: movab x1,_stpc");
234: asm("movl $1,_subtst");
235: asm("xorb2 _mask+3,_src+3"); /* mem to mem */
236: asm("movpsl _psl");
237: dest = src;
238: }
239: if (ix==2){
240: setjmp();
241: asm("x2: movab x2,_stpc");
242: asm("movl $2,_subtst");
243: exp_psw = C;
244: asm("movl _mask,r6"); /* load source reg */
245: asm("movl _src,r7"); /* load dest reg */
246: asm("xorb2 r6,r7"); /* reg to reg */
247: asm("movpsl _psl");
248: asm("movl r7,_src"); /* reload dest loc */
249: dest = src;
250: }
251: if (ix==3){
252: setjmp();
253: asm("x3: movab x3,_stpc");
254: asm("movl $3,_subtst");
255: asm("movl _mask,r6"); /* load source reg */
256: asm("xorb2 r6,_src+3"); /* reg to mem */
257: asm("movpsl _psl");
258: dest = src;
259: }
260: if (ix==4){
261: setjmp();
262: asm("x4: movab x4,_stpc");
263: asm("movl $4,_subtst");
264: asm("movl _src,r7"); /* load dest reg */
265: asm("xorb2 _mask+3,r7"); /* mem to reg */
266: asm("movpsl _psl");
267: asm("movl r7,_src"); /* reload dest loc */
268: asm("andl2 $0xff,_src");
269: dest = src;
270: }
271: if (ix==5){
272: setjmp();
273: asm("x5: movab x5,_stpc");
274: asm("movl $5,_subtst");
275: asm("xorb2 $123,_src+3"); /* data to mem */
276: asm("movpsl _psl");
277: dest = src;
278: }
279: if (ix==6){
280: setjmp();
281: asm("x6: movab x6,_stpc");
282: asm("movl $6,_subtst");
283: asm("movl _src,r7"); /* load dest reg */
284: asm("xorb2 $-0x7f,r7"); /* data to reg */
285: asm("movpsl _psl");
286: asm("movl r7,_src"); /* load dest reg */
287: asm("andl2 $0xff,_src");
288: dest = src;
289: }
290: }
291: else
292: {
293: asm("bicpsw $0xf"); /* clear all flags */
294: asm("bispsw _flag_msk");
295: asm(".globl _xorbb3");
296: asm("_xorbb3:");
297: if (ix==1){
298: setjmp();
299: asm("x7: movab x7,_stpc");
300: asm("movl $7,_subtst");
301: asm("xorb3 _mask+3,_src+3,_dest+3"); /* mem mem mem */
302: asm("movpsl _psl");
303: }
304: if (ix==2){
305: setjmp();
306: asm("x8: movab x8,_stpc");
307: asm("movl $8,_subtst");
308: asm("movb _dest,r7"); /* load dest reg */
309: asm("xorb3 _mask+3,_src+3,r7"); /* mem mem reg */
310: asm("movpsl _psl");
311: asm("movl r7,_dest"); /* load dest location */
312: asm("andl2 $0xff,_dest");
313: }
314: if (ix==3){
315: setjmp();
316: asm("x9: movab x9,_stpc");
317: asm("movl $9,_subtst");
318: exp_psw = N|C;
319: asm("movl _src,r6"); /* load src reg */
320: asm("xorb3 _mask+3,r6,_dest+3"); /* mem reg mem */
321: asm("movpsl _psl");
322: asm("movl r6,_src"); /* load src location */
323: }
324: if (ix==4){
325: setjmp();
326: asm("x10: movab x10,_stpc");
327: asm("movl $0xa,_subtst");
328: asm("xorb3 _mask+3,$0x1,_dest+3"); /* mem data mem */
329: asm("movpsl _psl");
330: }
331: if (ix==5){
332: setjmp();
333: asm("x11: movab x11,_stpc");
334: asm("movl $0xb,_subtst");
335: asm("xorb3 $-1,$-1,_dest+3"); /* data data mem */
336: asm("movpsl _psl");
337: }
338: if (ix==6){
339: setjmp();
340: asm("x12: movab x12,_stpc");
341: asm("movl $0xc,_subtst");
342: asm("movl _src,r6"); /* load src reg */
343: asm("xorb3 $-0x56,r6,_dest+3"); /* data reg mem */
344: asm("movpsl _psl");
345: asm("movl r6,_src"); /* load src location */
346: }
347: if (ix==7){
348: setjmp();
349: asm("x13: movab x13,_stpc");
350: asm("movl $0xd,_subtst");
351: exp_psw = N|C;
352: asm("movl _src,r6"); /* load src reg */
353: asm("movl _dest,r7"); /* load dest reg */
354: asm("xorb3 $-1,r6,r7"); /* data reg reg */
355: asm("movpsl _psl");
356: asm("movl r6,_src"); /* load src location */
357: asm("movl r7,_dest"); /* load dest location */
358: asm("andl2 $0xff,_dest");
359: }
360: if (ix==8){
361: setjmp();
362: asm("x14: movab x14,_stpc");
363: asm("movl $0xe,_subtst");
364: exp_psw = C;
365: asm("movl _mask,r5"); /* load mask reg */
366: asm("movl _dest,r7"); /* load dest reg */
367: asm("xorb3 r5,$0x1,r7"); /* reg data reg */
368: asm("movpsl _psl");
369: asm("movl r5,_mask"); /* load mask location */
370: asm("movl r7,_dest"); /* load dest location */
371: asm("andl2 $0xff,_dest");
372: }
373: if (ix==9){
374: setjmp();
375: asm("x15: movab x15,_stpc");
376: asm("movl $0xf,_subtst");
377: asm("movl _mask,r5"); /* load mask reg */
378: asm("movl _src,r6"); /* load src reg */
379: asm("movl _dest,r7"); /* load dest reg */
380: asm("xorb3 r5,r6,r7"); /* reg reg reg */
381: asm("movpsl _psl");
382: asm("movl r5,_mask"); /* load mask location */
383: asm("movl r6,_src"); /* load src location */
384: asm("movl r7,_dest"); /* load dest location */
385: asm("andl2 $0xff,_dest");
386: }
387: if (ix==10){
388: setjmp();
389: asm("x16: movab x16,_stpc");
390: asm("movl $0x10,_subtst");
391: exp_psw = C;
392: asm("movl _mask,r5"); /* load mask reg */
393: asm("movl _src,r6"); /* load src reg */
394: asm("xorb3 r5,r6,_dest+3"); /* reg reg mem */
395: asm("movpsl _psl");
396: asm("movl r5,_mask"); /* load mask location */
397: asm("movl r6,_src"); /* load src location */
398: }
399: }
400: }
401: else if (op_type == 'w')
402: {
403: op1 = mask;
404: op2 = src;
405: if (no_op==2)
406: {
407: asm("bicpsw $0xf"); /* clear all flags */
408: asm("bispsw _flag_msk");
409: asm(".globl _xorwd2");
410: asm("_xorwd2:");
411: if (ix==1){
412: setjmp();
413: asm("x17: movab x17,_stpc");
414: asm("movl $0x11,_subtst");
415: asm("xorw2 _mask+2,_src+2"); /* mem to mem */
416: asm("movpsl _psl");
417: dest = src;
418: }
419: if (ix==2){
420: setjmp();
421: asm("x18: movab x18,_stpc");
422: asm("movl $0x12,_subtst");
423: exp_psw = C;
424: asm("movl _mask,r6"); /* load source reg */
425: asm("movl _src,r7"); /* load dest reg */
426: asm("xorw2 r6,r7"); /* reg to reg */
427: asm("movpsl _psl");
428: asm("movl r7,_src"); /* reload dest loc */
429: asm("andl2 $0xffff,_src");
430: dest = src;
431: }
432: if (ix==3){
433: setjmp();
434: asm("x19: movab x19,_stpc");
435: asm("movl $0x13,_subtst");
436: exp_psw = N|C;
437: asm("movl _mask,r6"); /* load source reg */
438: asm("xorw2 r6,_src+2"); /* reg to mem */
439: asm("movpsl _psl");
440: dest = src;
441: }
442: if (ix==4){
443: setjmp();
444: asm("x20: movab x20,_stpc");
445: asm("movl $0x14,_subtst");
446: asm("movl _src,r7"); /* load dest reg */
447: asm("xorw2 _mask+2,r7"); /* mem to reg */
448: asm("movpsl _psl");
449: asm("movl r7,_src"); /* reload dest loc */
450: asm("andl2 $0xffff,_src");
451: dest = src;
452: }
453: if (ix==5){
454: setjmp();
455: asm("x21: movab x21,_stpc");
456: asm("movl $0x15,_subtst");
457: asm("xorw2 $-0x0001,_src+2"); /* data to mem */
458: asm("movpsl _psl");
459: dest = src;
460: }
461: if (ix==6){
462: setjmp();
463: asm("x22: movab x22,_stpc");
464: asm("movl $0x16,_subtst");
465: asm("movl _src,r7"); /* load dest reg */
466: asm("xorw2 $-0x4445,r7"); /* data to reg */
467: asm("movpsl _psl");
468: asm("movl r7,_src"); /* reload dest loc */
469: asm("andl2 $0xffff,_src");
470: dest = src;
471: }
472: }
473: else
474: {
475: asm("bicpsw $0xf"); /* clear all flags */
476: asm("bispsw _flag_msk");
477: asm(".globl _xorwd3");
478: asm("_xorwd3:");
479: if (ix==1){
480: setjmp();
481: asm("x23: movab x23,_stpc");
482: asm("movl $0x17,_subtst");
483: asm("xorw3 _mask+2,_src+2,_dest+2"); /*mem mem mem*/
484: asm("movpsl _psl");
485: }
486: if (ix==2){
487: setjmp();
488: asm("x24: movab x24,_stpc");
489: asm("movl $0x18,_subtst");
490: asm("movl _src,r6"); /* load src reg */
491: asm("xorw3 _mask+2,r6,_dest+2"); /*mem reg mem*/
492: asm("movpsl _psl");
493: asm("movl r6,_src"); /* load src location */
494: }
495: if (ix==3){
496: setjmp();
497: asm("x25: movab x25,_stpc");
498: asm("movl $0x19,_subtst");
499: asm("xorw3 _mask+2,$-0x00ff,_dest+2"); /*mem dat mem*/
500: asm("movpsl _psl");
501: }
502: if (ix==4){
503: setjmp();
504: asm("x26: movab x26,_stpc");
505: asm("movl $0x1a,_subtst");
506: asm("xorw3 $-0x5600,$0x7001,_dest+2"); /*lit dat mem*/
507: asm("movpsl _psl");
508: }
509: if (ix==5){
510: setjmp();
511: asm("x27: movab x27,_stpc");
512: asm("movl $0x1b,_subtst");
513: asm("movl _dest,r7"); /* load dest reg */
514: asm("xorw3 _mask+2,_src+2,r7"); /*mem mem reg */
515: asm("movpsl _psl");
516: asm("movl r7,_dest"); /* load dest location */
517: asm("andl2 $0xffff,_dest");
518: }
519: if (ix==6){
520: setjmp();
521: asm("x28: movab x28,_stpc");
522: asm("movl $0x1c,_subtst");
523: asm("movl _src,r6"); /* load src reg */
524: asm("xorw3 $-0x5600,r6,_dest+2"); /*lit reg mem*/
525: asm("movpsl _psl");
526: asm("movl r6,_src"); /* load src location */
527: }
528: if (ix==7){
529: setjmp();
530: asm("x29: movab x29,_stpc");
531: asm("movl $0x1d,_subtst");
532: exp_psw = N|C;
533: asm("movl _src,r6"); /* load src reg */
534: asm("movl _dest,r7"); /* load dest reg */
535: asm("xorw3 $-0x00ff,r6,r7"); /*dat reg reg*/
536: asm("movpsl _psl");
537: asm("movl r6,_src"); /* load src location */
538: asm("movl r7,_dest"); /* load dest location */
539: asm("andl2 $0xffff,_dest");
540: }
541: if (ix==8){
542: setjmp();
543: asm("x30: movab x30,_stpc");
544: asm("movl $0x1e,_subtst");
545: exp_psw = C;
546: asm("movl _mask,r5"); /* load mask reg */
547: asm("movl _dest,r7"); /* load dest reg */
548: asm("xorw3 r5,$0x7001,r7"); /*reg dat reg*/
549: asm("movpsl _psl");
550: asm("movl r5,_mask"); /* load mask location */
551: asm("movl r7,_dest"); /* load dest location */
552: asm("andl2 $0xffff,_dest");
553: }
554: if (ix==9){
555: setjmp();
556: asm("x31: movab x31,_stpc");
557: asm("movl $0x1f,_subtst");
558: asm("movl _mask,r5"); /* load mask reg */
559: asm("movl _src,r6"); /* load src reg */
560: asm("movl _dest,r7"); /* load dest reg */
561: asm("xorw3 r5,r6,r7"); /*reg reg reg*/
562: asm("movpsl _psl");
563: asm("movl r5,_mask"); /* load mask location */
564: asm("movl r6,_src"); /* load src location */
565: asm("movl r7,_dest"); /* load dest location */
566: asm("andl2 $0xffff,_dest");
567: }
568: if (ix==10){
569: setjmp();
570: asm("x32: movab x32,_stpc");
571: asm("movl $0x20,_subtst");
572: exp_psw = C;
573: asm("movl _mask,r5"); /* load mask reg */
574: asm("movl _src,r6"); /* load src reg */
575: asm("xorw3 r5,r6,_dest+2"); /*reg reg mem*/
576: asm("movpsl _psl");
577: asm("movl r5,_mask"); /* load mask location */
578: asm("movl r6,_src"); /* load src location */
579: }
580: }
581: }
582: else
583: {
584: if (no_op==2)
585: {
586: asm("bicpsw $0xf"); /* clear all flags */
587: asm("bispsw _flag_msk");
588: asm(".globl _xorlw2");
589: asm("_xorlw2:");
590: if (ix==1) {
591: setjmp();
592: asm("x33: movab x33,_stpc");
593: asm("movl $0x21,_subtst");
594: asm("xorl2 _mask,_src"); /* mem to mem */
595: asm("movpsl _psl");
596: dest = src;
597: }
598: if (ix==2) {
599: setjmp();
600: asm("x34: movab x34,_stpc");
601: asm("movl $0x22,_subtst");
602: asm("movl _mask,r5"); /* load mask reg */
603: asm("movl _src,r6"); /* load src reg */
604: asm("xorl2 r5,r6"); /* reg to reg */
605: asm("movpsl _psl");
606: asm("movl r5,_mask"); /* load mask location */
607: asm("movl r6,_src"); /* load src location */
608: dest = src;
609: }
610: if (ix==3) {
611: setjmp();
612: asm("x35: movab x35,_stpc");
613: asm("movl $0x23,_subtst");
614: asm("movl _mask,r5"); /* load mask reg */
615: asm("xorl2 r5,_src"); /* reg to mem */
616: asm("movpsl _psl");
617: asm("movl r5,_mask"); /* load mask location */
618: dest = src;
619: }
620: if (ix==4) {
621: setjmp();
622: asm("x36: movab x36,_stpc");
623: asm("movl $0x24,_subtst");
624: asm("movl _src,r6"); /* load src reg */
625: asm("xorl2 $0xccccbbbb,r6"); /* data to reg */
626: asm("movpsl _psl");
627: asm("movl r6,_src"); /* load src location */
628: dest = src;
629: }
630: }
631: else
632: {
633: asm("bicpsw $0xf"); /* clear all flags */
634: asm("bispsw _flag_msk");
635: asm(".globl _xorlw3");
636: asm("_xorlw3:");
637: if (ix==1) {
638: setjmp();
639: asm("x37: movab x37,_stpc");
640: asm("movl $0x25,_subtst");
641: asm("xorl3 _mask,_src,_dest"); /*mem mem mem*/
642: asm("movpsl _psl");
643: }
644: if (ix==2) {
645: setjmp();
646: asm("x38: movab x38,_stpc");
647: asm("movl $0x26,_subtst");
648: asm("movl _mask,r5"); /* load mask reg */
649: asm("movl _src,r6"); /* load src reg */
650: asm("movl _dest,r7"); /* load dest reg */
651: asm("xorl3 r5,r6,r7"); /* reg reg reg */
652: asm("movpsl _psl");
653: asm("movl r5,_mask"); /* load mask location */
654: asm("movl r6,_src"); /* load src location */
655: asm("movl r7,_dest"); /* load dest location */
656: }
657: if (ix==3) {
658: setjmp();
659: asm("x39: movab x39,_stpc");
660: asm("movl $0x27,_subtst");
661: asm("movl _mask,r5"); /* load mask reg */
662: asm("movl _src,r6"); /* load src reg */
663: asm("xorl3 r5,r6,_dest"); /* reg reg mem */
664: asm("movpsl _psl");
665: asm("movl r5,_mask"); /* load mask location */
666: asm("movl r6,_src"); /* load src location */
667: }
668: if (ix==4) {
669: setjmp();
670: asm("x40: movab x40,_stpc");
671: asm("movl $0x28,_subtst");
672: asm("movl _src,r6"); /* load src reg */
673: asm("xorl3 $0xddddaa00,r6,_dest"); /* dat reg mem */
674: asm("movpsl _psl");
675: asm("movl r6,_src"); /* load src location */
676: }
677: if (ix==5) {
678: setjmp();
679: asm("x41: movab x41,_stpc");
680: asm("movl $0x29,_subtst");
681: asm("movl _mask,r5"); /* load mask reg */
682: asm("xorl3 r5,$0xffffff01,_dest"); /* reg dat mem */
683: asm("movpsl _psl");
684: asm("movl r5,_mask"); /* load mask location */
685: }
686: if (ix==6) {
687: setjmp();
688: asm("x42: movab x42,_stpc");
689: asm("movl $0x2a,_subtst");
690: asm("movl _src,r6"); /* load src reg */
691: asm("movl _dest,r7"); /* load dest reg */
692: asm("xorl3 $0xddddaa00,r6,r7"); /* dat reg reg */
693: asm("movpsl _psl");
694: asm("movl r6,_src"); /* load src location */
695: asm("movl r7,_dest"); /* load dest location */
696: }
697: if (ix==7) {
698: setjmp();
699: asm("x43: movab x43,_stpc");
700: asm("movl $0x2b,_subtst");
701: asm("movl _mask,r5"); /* load mask reg */
702: asm("movl _dest,r7"); /* load dest reg */
703: asm("xorl3 r5,$0xffffff01,r7"); /* reg dat reg */
704: asm("movpsl _psl");
705: asm("movl r5,_mask"); /* load mask location */
706: asm("movl r7,_dest"); /* load dest location */
707: }
708: if (ix==8) {
709: setjmp();
710: asm("x44: movab x44,_stpc");
711: asm("movl $0x2c,_subtst");
712: asm("movl _dest,r7"); /* load dest reg */
713: asm("xorl3 $0xddddaa00,$0x7001dddd,r7"); /* dat dat reg */
714: asm("movpsl _psl");
715: asm("movl r7,_dest"); /* load dest location */
716: }
717: if (ix==9) {
718: setjmp();
719: asm("x45: movab x45,_stpc");
720: asm("movl $0x2d,_subtst");
721: asm("xorl3 $0xffffff01,$0xffffff01,_dest"); /* dat dat mem */
722: asm("movpsl _psl");
723: }
724: if (ix==10) {
725: setjmp();
726: asm("x46: movab x46,_stpc");
727: asm("movl $0x2e,_subtst");
728: asm("xorl3 _mask,_src,_dest"); /*mem mem mem*/
729: asm("movpsl _psl");
730: }
731: }
732: }
733:
734: psw = psl & 0xf;
735:
736: /* check flags */
737: if (psw != exp_psw)
738: {
739: asm("movl $2,_ercode");
740: if (scoplp) longjmp();
741: error_hdl2(psw,exp_psw,op1,op2);
742: }
743: if (mask != op1)
744: {
745: asm("movl $3,_ercode");
746: if ( scoplp) longjmp();
747: error_hdl2(mask,op1,op1,op2);
748: }
749: if (no_op==3)
750: {
751: if (src != op2)
752: {
753: asm("movl $3,_ercode");
754: if ( scoplp) longjmp();
755: error_hdl2(src,op2,op1,op2);
756: }
757: }
758: if (dest != exp_reslt)
759: {
760: asm("movl $1,_ercode");
761: if ( scoplp) longjmp();
762: error_hdl2(dest,exp_reslt,op1,op2);
763: if ( force_lp) longjmp();
764: }
765: break;
766: }
767: }
768:
769:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.