Return to mul.c CVS log

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

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

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.