Return to vlrt.c CVS log

Up to [Plan 9 NeXT] / lucent / sys / src / libc / 68020

Annotation of lucent/sys/src/libc/68020/vlrt.c, revision 1.1

1.1     ! root        1: typedef        unsigned long ulong;
        !             2: typedef        unsigned char uchar;
        !             3: typedef        unsigned short ushort;
        !             4: typedef        signed char schar;
        !             5: 
        !             6: #define        SIGN(n) (1UL<<(n-1))
        !             7: 
        !             8: typedef        struct  Vlong   Vlong;
        !             9: struct Vlong
        !            10: {
        !            11:        union
        !            12:        {
        !            13:                struct
        !            14:                {
        !            15:                        ulong   hi;
        !            16:                        ulong   lo;
        !            17:                };
        !            18:                struct
        !            19:                {
        !            20:                        ushort  hims;
        !            21:                        ushort  hils;
        !            22:                        ushort  loms;
        !            23:                        ushort  lols;
        !            24:                };
        !            25:        };
        !            26: };
        !            27: 
        !            28: void   abort(void);
        !            29: 
        !            30: void
        !            31: _addv(Vlong *r, Vlong a, Vlong b)
        !            32: {
        !            33:        ulong lo, hi;
        !            34: 
        !            35:        lo = a.lo + b.lo;
        !            36:        hi = a.hi + b.hi;
        !            37:        if(lo < a.lo)
        !            38:                hi++;
        !            39:        r->lo = lo;
        !            40:        r->hi = hi;
        !            41: }
        !            42: 
        !            43: void
        !            44: _subv(Vlong *r, Vlong a, Vlong b)
        !            45: {
        !            46:        ulong lo, hi;
        !            47: 
        !            48:        lo = a.lo - b.lo;
        !            49:        hi = a.hi - b.hi;
        !            50:        if(lo > a.lo)
        !            51:                hi--;
        !            52:        r->lo = lo;
        !            53:        r->hi = hi;
        !            54: }
        !            55: 
        !            56: void
        !            57: _d2v(Vlong *y, double d)
        !            58: {
        !            59:        union { double d; struct Vlong; } x;
        !            60:        ulong xhi, xlo, ylo, yhi;
        !            61:        int sh;
        !            62: 
        !            63:        x.d = d;
        !            64: 
        !            65:        xhi = (x.hi & 0xfffff) | 0x100000;
        !            66:        xlo = x.lo;
        !            67:        sh = 1075 - ((x.hi >> 20) & 0x7ff);
        !            68: 
        !            69:        ylo = 0;
        !            70:        yhi = 0;
        !            71:        if(sh >= 0) {
        !            72:                /* v = (hi||lo) >> sh */
        !            73:                if(sh < 32) {
        !            74:                        if(sh == 0) {
        !            75:                                ylo = xlo;
        !            76:                                yhi = xhi;
        !            77:                        } else {
        !            78:                                ylo = (xlo >> sh) | (xhi << (32-sh));
        !            79:                                yhi = xhi >> sh;
        !            80:                        }
        !            81:                } else {
        !            82:                        if(sh == 32) {
        !            83:                                ylo = xhi;
        !            84:                        } else
        !            85:                        if(sh < 64) {
        !            86:                                ylo = xhi >> (sh-32);
        !            87:                        }
        !            88:                }
        !            89:        } else {
        !            90:                /* v = (hi||lo) << -sh */
        !            91:                sh = -sh;
        !            92:                if(sh <= 10) {
        !            93:                        ylo = xlo << sh;
        !            94:                        yhi = (xhi << sh) | (xlo >> (32-sh));
        !            95:                } else {
        !            96:                        /* overflow */
        !            97:                        yhi = d;        /* causes something awful */
        !            98:                }
        !            99:        }
        !           100:        if(x.hi & 0x80000000) {
        !           101:                if(ylo != 0) {
        !           102:                        ylo = -ylo;
        !           103:                        yhi = ~yhi;
        !           104:                } else
        !           105:                        yhi = -yhi;
        !           106:        }
        !           107: 
        !           108:        y->hi = yhi;
        !           109:        y->lo = ylo;
        !           110: }
        !           111: 
        !           112: void
        !           113: _f2v(Vlong *y, float f)
        !           114: {
        !           115: 
        !           116:        _d2v(y, f);
        !           117: }
        !           118: 
        !           119: double
        !           120: _v2d(Vlong x)
        !           121: {
        !           122:        if(x.hi & 0x80000000) {
        !           123:                if(x.lo) {
        !           124:                        x.lo = -x.lo;
        !           125:                        x.hi = ~x.hi;
        !           126:                } else
        !           127:                        x.hi = -x.hi;
        !           128:                return -((long)x.hi*4294967296. + x.lo);
        !           129:        }
        !           130:        return (long)x.hi*4294967296. + x.lo;
        !           131: }
        !           132: 
        !           133: float
        !           134: _v2f(Vlong x)
        !           135: {
        !           136:        return _v2d(x);
        !           137: }
        !           138: 
        !           139: static void
        !           140: dodiv(Vlong num, Vlong den, Vlong *q, Vlong *r)
        !           141: {
        !           142:        ulong numlo, numhi, denhi, denlo, quohi, quolo, t;
        !           143:        int i;
        !           144: 
        !           145:        numhi = num.hi;
        !           146:        numlo = num.lo;
        !           147:        denhi = den.hi;
        !           148:        denlo = den.lo;
        !           149: 
        !           150:        /*
        !           151:         * get a divide by zero
        !           152:         */
        !           153:        if(denlo==0 && denhi==0) {
        !           154:                numlo = numlo / denlo;
        !           155:        }
        !           156: 
        !           157:        /*
        !           158:         * set up the divisor and find the number of iterations needed
        !           159:         */
        !           160:        if(numhi >= SIGN(32)) {
        !           161:                quohi = SIGN(32);
        !           162:                quolo = 0;
        !           163:        } else {
        !           164:                quohi = numhi;
        !           165:                quolo = numlo;
        !           166:        }
        !           167:        i = 0;
        !           168:        while(denhi < quohi || (denhi == quohi && denlo < quolo)) {
        !           169:                denhi = (denhi<<1) | (denlo>>31);
        !           170:                denlo <<= 1;
        !           171:                i++;
        !           172:        }
        !           173: 
        !           174:        quohi = 0;
        !           175:        quolo = 0;
        !           176:        for(; i >= 0; i--) {
        !           177:                quohi = (quohi<<1) | (quolo>>31);
        !           178:                quolo <<= 1;
        !           179:                if(numhi > denhi || (numhi == denhi && numlo >= denlo)) {
        !           180:                        t = numlo;
        !           181:                        numlo -= denlo;
        !           182:                        if(numlo > t)
        !           183:                                numhi--;
        !           184:                        numhi -= denhi;
        !           185:                        quolo |= 1;
        !           186:                }
        !           187:                denlo = (denlo>>1) | (denhi<<31);
        !           188:                denhi >>= 1;
        !           189:        }
        !           190: 
        !           191:        if(q) {
        !           192:                q->lo = quolo;
        !           193:                q->hi = quohi;
        !           194:        }
        !           195:        if(r) {
        !           196:                r->lo = numlo;
        !           197:                r->hi = numhi;
        !           198:        }
        !           199: }
        !           200: 
        !           201: void
        !           202: _divvu(Vlong *q, Vlong n, Vlong d)
        !           203: {
        !           204: 
        !           205:        if(n.hi == 0 && d.hi == 0) {
        !           206:                q->hi = 0;
        !           207:                q->lo = n.lo / d.lo;
        !           208:                return;
        !           209:        }
        !           210:        dodiv(n, d, q, 0);
        !           211: }
        !           212: 
        !           213: void
        !           214: _modvu(Vlong *r, Vlong n, Vlong d)
        !           215: {
        !           216: 
        !           217:        if(n.hi == 0 && d.hi == 0) {
        !           218:                r->hi = 0;
        !           219:                r->lo = n.lo % d.lo;
        !           220:                return;
        !           221:        }
        !           222:        dodiv(n, d, 0, r);
        !           223: }
        !           224: 
        !           225: static void
        !           226: vneg(Vlong *v)
        !           227: {
        !           228: 
        !           229:        if(v->lo == 0) {
        !           230:                v->hi = -v->hi;
        !           231:                return;
        !           232:        }
        !           233:        v->lo = -v->lo;
        !           234:        v->hi = ~v->hi;
        !           235: }
        !           236: 
        !           237: void
        !           238: _divv(Vlong *q, Vlong n, Vlong d)
        !           239: {
        !           240:        long nneg, dneg;
        !           241: 
        !           242:        if(n.hi == (((long)n.lo)>>31) && d.hi == (((long)d.lo)>>31)) {
        !           243:                q->lo = (long)n.lo / (long)d.lo;
        !           244:                q->hi = ((long)q->lo) >> 31;
        !           245:                return;
        !           246:        }
        !           247:        nneg = n.hi >> 31;
        !           248:        if(nneg)
        !           249:                vneg(&n);
        !           250:        dneg = d.hi >> 31;
        !           251:        if(dneg)
        !           252:                vneg(&d);
        !           253:        dodiv(n, d, q, 0);
        !           254:        if(nneg != dneg)
        !           255:                vneg(q);
        !           256: }
        !           257: 
        !           258: void
        !           259: _modv(Vlong *r, Vlong n, Vlong d)
        !           260: {
        !           261:        long nneg, dneg;
        !           262: 
        !           263:        if(n.hi == (((long)n.lo)>>31) && d.hi == (((long)d.lo)>>31)) {
        !           264:                r->lo = (long)n.lo % (long)d.lo;
        !           265:                r->hi = ((long)r->lo) >> 31;
        !           266:                return;
        !           267:        }
        !           268:        nneg = n.hi >> 31;
        !           269:        if(nneg)
        !           270:                vneg(&n);
        !           271:        dneg = d.hi >> 31;
        !           272:        if(dneg)
        !           273:                vneg(&d);
        !           274:        dodiv(n, d, 0, r);
        !           275:        if(nneg)
        !           276:                vneg(r);
        !           277: }
        !           278: 
        !           279: void
        !           280: _rshav(Vlong *r, Vlong a, int b)
        !           281: {
        !           282:        long t;
        !           283: 
        !           284:        t = a.hi;
        !           285:        if(b >= 32) {
        !           286:                r->hi = t>>31;
        !           287:                if(b >= 64) {
        !           288:                        /* this is illegal re C standard */
        !           289:                        r->lo = t>>31;
        !           290:                        return;
        !           291:                }
        !           292:                r->lo = t >> (b-32);
        !           293:                return;
        !           294:        }
        !           295:        if(b <= 0) {
        !           296:                r->hi = t;
        !           297:                r->lo = a.lo;
        !           298:                return;
        !           299:        }
        !           300:        r->hi = t >> b;
        !           301:        r->lo = (t << (32-b)) | (a.lo >> b);
        !           302: }
        !           303: 
        !           304: void
        !           305: _rshlv(Vlong *r, Vlong a, int b)
        !           306: {
        !           307:        ulong t;
        !           308: 
        !           309:        t = a.hi;
        !           310:        if(b >= 32) {
        !           311:                r->hi = 0;
        !           312:                if(b >= 64) {
        !           313:                        /* this is illegal re C standard */
        !           314:                        r->lo = 0;
        !           315:                        return;
        !           316:                }
        !           317:                r->lo = t >> (b-32);
        !           318:                return;
        !           319:        }
        !           320:        if(b <= 0) {
        !           321:                r->hi = t;
        !           322:                r->lo = a.lo;
        !           323:                return;
        !           324:        }
        !           325:        r->hi = t >> b;
        !           326:        r->lo = (t << (32-b)) | (a.lo >> b);
        !           327: }
        !           328: 
        !           329: void
        !           330: _lshv(Vlong *r, Vlong a, int b)
        !           331: {
        !           332:        ulong t;
        !           333: 
        !           334:        t = a.lo;
        !           335:        if(b >= 32) {
        !           336:                r->lo = 0;
        !           337:                if(b >= 64) {
        !           338:                        /* this is illegal re C standard */
        !           339:                        r->hi = 0;
        !           340:                        return;
        !           341:                }
        !           342:                r->hi = t << (b-32);
        !           343:                return;
        !           344:        }
        !           345:        if(b <= 0) {
        !           346:                r->lo = t;
        !           347:                r->hi = a.hi;
        !           348:                return;
        !           349:        }
        !           350:        r->lo = t << b;
        !           351:        r->hi = (t >> (32-b)) | (a.hi << b);
        !           352: }
        !           353: 
        !           354: void
        !           355: _andv(Vlong *r, Vlong a, Vlong b)
        !           356: {
        !           357:        r->hi = a.hi & b.hi;
        !           358:        r->lo = a.lo & b.lo;
        !           359: }
        !           360: 
        !           361: void
        !           362: _orv(Vlong *r, Vlong a, Vlong b)
        !           363: {
        !           364:        r->hi = a.hi | b.hi;
        !           365:        r->lo = a.lo | b.lo;
        !           366: }
        !           367: 
        !           368: void
        !           369: _xorv(Vlong *r, Vlong a, Vlong b)
        !           370: {
        !           371:        r->hi = a.hi ^ b.hi;
        !           372:        r->lo = a.lo ^ b.lo;
        !           373: }
        !           374: 
        !           375: void
        !           376: _negv(Vlong *r, Vlong a)
        !           377: {
        !           378:        if(a.lo == 0) {
        !           379:                r->hi = -a.hi;
        !           380:                r->lo = 0;
        !           381:                return;
        !           382:        }
        !           383:        r->hi = ~a.hi;
        !           384:        r->lo = -a.lo;
        !           385: }
        !           386: 
        !           387: void
        !           388: _vpp(Vlong *l, Vlong *r)
        !           389: {
        !           390: 
        !           391:        l->hi = r->hi;
        !           392:        l->lo = r->lo;
        !           393:        r->lo++;
        !           394:        if(r->lo == 0)
        !           395:                r->hi++;
        !           396: }
        !           397: 
        !           398: void
        !           399: _vmm(Vlong *l, Vlong *r)
        !           400: {
        !           401: 
        !           402:        l->hi = r->hi;
        !           403:        l->lo = r->lo;
        !           404:        if(r->lo == 0)
        !           405:                r->hi--;
        !           406:        r->lo--;
        !           407: }
        !           408: 
        !           409: void
        !           410: _ppv(Vlong *l, Vlong *r)
        !           411: {
        !           412: 
        !           413:        r->lo++;
        !           414:        if(r->lo == 0)
        !           415:                r->hi++;
        !           416:        l->hi = r->hi;
        !           417:        l->lo = r->lo;
        !           418: }
        !           419: 
        !           420: void
        !           421: _mmv(Vlong *l, Vlong *r)
        !           422: {
        !           423: 
        !           424:        if(r->lo == 0)
        !           425:                r->hi--;
        !           426:        r->lo--;
        !           427:        l->hi = r->hi;
        !           428:        l->lo = r->lo;
        !           429: }
        !           430: 
        !           431: void
        !           432: _vasop(Vlong *ret, void *lv, void fn(Vlong*, Vlong, Vlong), int type, Vlong rv)
        !           433: {
        !           434:        Vlong t;
        !           435: 
        !           436:        switch(type) {
        !           437:        default:
        !           438:                abort();
        !           439:                break;
        !           440: 
        !           441:        case 1: /* schar */
        !           442:                t.lo = *(schar*)lv;
        !           443:                t.hi = t.lo >> 31;
        !           444:                fn(ret, t, rv);
        !           445:                *(schar*)lv = ret->lo;
        !           446:                break;
        !           447: 
        !           448:        case 2: /* uchar */
        !           449:                t.lo = *(uchar*)lv;
        !           450:                t.hi = 0;
        !           451:                fn(ret, t, rv);
        !           452:                *(uchar*)lv = ret->lo;
        !           453:                break;
        !           454: 
        !           455:        case 3: /* short */
        !           456:                t.lo = *(short*)lv;
        !           457:                t.hi = t.lo >> 31;
        !           458:                fn(ret, t, rv);
        !           459:                *(short*)lv = ret->lo;
        !           460:                break;
        !           461: 
        !           462:        case 4: /* ushort */
        !           463:                t.lo = *(ushort*)lv;
        !           464:                t.hi = 0;
        !           465:                fn(ret, t, rv);
        !           466:                *(ushort*)lv = ret->lo;
        !           467:                break;
        !           468: 
        !           469:        case 5: /* long */
        !           470:                t.lo = *(long*)lv;
        !           471:                t.hi = t.lo >> 31;
        !           472:                fn(ret, t, rv);
        !           473:                *(long*)lv = ret->lo;
        !           474:                break;
        !           475: 
        !           476:        case 6: /* ulong */
        !           477:                t.lo = *(ulong*)lv;
        !           478:                t.hi = 0;
        !           479:                fn(ret, t, rv);
        !           480:                *(ulong*)lv = ret->lo;
        !           481:                break;
        !           482: 
        !           483:        case 7: /* vlong */
        !           484:        case 8: /* uvlong */
        !           485:                fn(ret, *(Vlong*)lv, rv);
        !           486:                *(Vlong*)lv = *ret;
        !           487:                break;
        !           488:        }
        !           489: }
        !           490: 
        !           491: void
        !           492: _sl2v(Vlong *ret, long sl)
        !           493: {
        !           494:        long t;
        !           495: 
        !           496:        t = sl;
        !           497:        ret->lo = t;
        !           498:        ret->hi = t >> 31;
        !           499: }
        !           500: 
        !           501: void
        !           502: _ul2v(Vlong *ret, ulong ul)
        !           503: {
        !           504:        long t;
        !           505: 
        !           506:        t = ul;
        !           507:        ret->lo = t;
        !           508:        ret->hi = 0;
        !           509: }
        !           510: 
        !           511: void
        !           512: _sh2v(Vlong *ret, long sh)
        !           513: {
        !           514:        long t;
        !           515: 
        !           516:        t = (sh << 16) >> 16;
        !           517:        ret->lo = t;
        !           518:        ret->hi = t >> 31;
        !           519: }
        !           520: 
        !           521: void
        !           522: _uh2v(Vlong *ret, ulong ul)
        !           523: {
        !           524:        long t;
        !           525: 
        !           526:        t = ul & 0xffff;
        !           527:        ret->lo = t;
        !           528:        ret->hi = 0;
        !           529: }
        !           530: 
        !           531: void
        !           532: _sc2v(Vlong *ret, long uc)
        !           533: {
        !           534:        long t;
        !           535: 
        !           536:        t = (uc << 24) >> 24;
        !           537:        ret->lo = t;
        !           538:        ret->hi = t >> 31;
        !           539: }
        !           540: 
        !           541: void
        !           542: _uc2v(Vlong *ret, ulong ul)
        !           543: {
        !           544:        long t;
        !           545: 
        !           546:        t = ul & 0xff;
        !           547:        ret->lo = t;
        !           548:        ret->hi = 0;
        !           549: }
        !           550: 
        !           551: long
        !           552: _v2sc(Vlong rv)
        !           553: {
        !           554:        long t;
        !           555: 
        !           556:        t = rv.lo & 0xff;
        !           557:        return (t << 24) >> 24;
        !           558: }
        !           559: 
        !           560: long
        !           561: _v2uc(Vlong rv)
        !           562: {
        !           563: 
        !           564:        return rv.lo & 0xff;
        !           565: }
        !           566: 
        !           567: long
        !           568: _v2sh(Vlong rv)
        !           569: {
        !           570:        long t;
        !           571: 
        !           572:        t = rv.lo & 0xffff;
        !           573:        return (t << 16) >> 16;
        !           574: }
        !           575: 
        !           576: long
        !           577: _v2uh(Vlong rv)
        !           578: {
        !           579: 
        !           580:        return rv.lo & 0xffff;
        !           581: }
        !           582: 
        !           583: long
        !           584: _v2sl(Vlong rv)
        !           585: {
        !           586: 
        !           587:        return rv.lo;
        !           588: }
        !           589: 
        !           590: long
        !           591: _v2ul(Vlong rv)
        !           592: {
        !           593: 
        !           594:        return rv.lo;
        !           595: }
        !           596: 
        !           597: int
        !           598: _testv(Vlong rv)
        !           599: {
        !           600:        return rv.lo || rv.hi;
        !           601: }
        !           602: 
        !           603: int
        !           604: _eqv(Vlong lv, Vlong rv)
        !           605: {
        !           606:        return lv.lo == rv.lo && lv.hi == rv.hi;
        !           607: }
        !           608: 
        !           609: int
        !           610: _nev(Vlong lv, Vlong rv)
        !           611: {
        !           612:        return lv.lo != rv.lo || lv.hi != rv.hi;
        !           613: }
        !           614: 
        !           615: int
        !           616: _ltv(Vlong lv, Vlong rv)
        !           617: {
        !           618:        return (long)lv.hi < (long)rv.hi || 
        !           619:                (lv.hi == rv.hi && lv.lo < rv.lo);
        !           620: }
        !           621: 
        !           622: int
        !           623: _lev(Vlong lv, Vlong rv)
        !           624: {
        !           625:        return (long)lv.hi < (long)rv.hi || 
        !           626:                (lv.hi == rv.hi && lv.lo <= rv.lo);
        !           627: }
        !           628: 
        !           629: int
        !           630: _gtv(Vlong lv, Vlong rv)
        !           631: {
        !           632:        return (long)lv.hi > (long)rv.hi || 
        !           633:                (lv.hi == rv.hi && lv.lo > rv.lo);
        !           634: }
        !           635: 
        !           636: int
        !           637: _gev(Vlong lv, Vlong rv)
        !           638: {
        !           639:        return (long)lv.hi > (long)rv.hi || 
        !           640:                (lv.hi == rv.hi && lv.lo >= rv.lo);
        !           641: }
        !           642: 
        !           643: int
        !           644: _lov(Vlong lv, Vlong rv)
        !           645: {
        !           646:        return lv.hi < rv.hi || 
        !           647:                (lv.hi == rv.hi && lv.lo < rv.lo);
        !           648: }
        !           649: 
        !           650: int
        !           651: _lsv(Vlong lv, Vlong rv)
        !           652: {
        !           653:        return lv.hi < rv.hi || 
        !           654:                (lv.hi == rv.hi && lv.lo <= rv.lo);
        !           655: }
        !           656: 
        !           657: int
        !           658: _hiv(Vlong lv, Vlong rv)
        !           659: {
        !           660:        return lv.hi > rv.hi || 
        !           661:                (lv.hi == rv.hi && lv.lo > rv.lo);
        !           662: }
        !           663: 
        !           664: int
        !           665: _hsv(Vlong lv, Vlong rv)
        !           666: {
        !           667:        return lv.hi > rv.hi || 
        !           668:                (lv.hi == rv.hi && lv.lo >= rv.lo);
        !           669: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.