Return to xor.c CVS log

Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / entry

Annotation of cci/d/entry/xor.c, revision 1.1

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.