Return to asmsparcv9.h CVS log

Up to [local] / OpenXM_contrib / pari / src / kernel / sparcv9

Annotation of OpenXM_contrib/pari/src/kernel/sparcv9/asmsparcv9.h, Revision 1.1

1.1     ! maekawa     1: /* $Id: asmsparcv9.h,v 1.1.1.1 1999/09/16 13:47:58 karim Exp $ */
        !             2: #ifndef __ASMSPARCV9_H__
        !             3: #define __ASMSPARCV9_H__
        !             4:
        !             5: register unsigned long hiremainder asm("%g5");
        !             6: register unsigned long overflow asm("%g6");
        !             7:
        !             8: #define addll(a,b) \
        !             9: ({ unsigned long __value, __arg1 = (a), __arg2 = (b); \
        !            10:    asm ( "addcc %2,%3,%0; \
        !            11:           addc  %%g0,%%g0,%1" \
        !            12:         : "=r" (__value), "=r" (overflow) \
        !            13:         : "r" (__arg1), "r" (__arg2) \
        !            14:          : "%g6","cc"); \
        !            15: __value; })
        !            16:
        !            17: #define subll(a,b) \
        !            18: ({ unsigned long __value, __arg1 = (a), __arg2 = (b); \
        !            19:    asm ( "subcc %2,%3,%0; \
        !            20:           addc  %%g0,%%g0,%1" \
        !            21:         : "=r" (__value), "=r" (overflow) \
        !            22:         : "r" (__arg1), "r" (__arg2) \
        !            23:          : "%g6","cc"); \
        !            24: __value; })
        !            25:
        !            26: #define addllx(a,b) \
        !            27: ({ unsigned long __value, __arg1 = (a), __arg2 = (b); \
        !            28:    asm ( "subcc %%g0,%%g6,%%g0; \
        !            29:           addccc %2,%3,%0; \
        !            30:           addc  %%g0,%%g0,%1" \
        !            31:         : "=r" (__value), "=r" (overflow) \
        !            32:         : "r" (__arg1), "r" (__arg2) \
        !            33:          : "%g6","cc"); \
        !            34: __value; })
        !            35:
        !            36: #define subllx(a,b) \
        !            37: ({ unsigned long __value, __arg1 = (a), __arg2 = (b); \
        !            38:    asm ( "subcc %%g0,%%g6,%%g0; \
        !            39:           subccc %2,%3,%0; \
        !            40:           addc  %%g0,%%g0,%1" \
        !            41:         : "=r" (__value), "=r" (overflow) \
        !            42:         : "r" (__arg1), "r" (__arg2) \
        !            43:          : "%g6","cc"); \
        !            44: __value; })
        !            45:
        !            46: #define shiftl(a,b) \
        !            47: ({ unsigned long __value, __arg1 = (a), __arg2 = (b); \
        !            48:    asm ( "neg %3,%%o4; \
        !            49:           srl %2,%%o4,%1; \
        !            50:           sll %2,%3,%0" \
        !            51:         : "=r" (__value), "=r" (hiremainder) \
        !            52:         : "r" (__arg1), "r" (__arg2) \
        !            53:          : "%o4","%g5"); \
        !            54: __value; })
        !            55:
        !            56: #define shiftl2(a,b,c) \
        !            57: ({ unsigned long __value, __arg1 = (a), __arg2 = (b), __arg3 = (c); \
        !            58:    asm ( "srl %2,%4,%1; \
        !            59:           sll %2,%3,%0" \
        !            60:         : "=r" (__value), "=r" (hiremainder) \
        !            61:         : "r" (__arg1), "r" (__arg2), "r" (__arg3) \
        !            62:          : "%g5"); \
        !            63: __value; })
        !            64:
        !            65: #define shiftlr(a,b) \
        !            66: ({ unsigned long __value, __arg1 = (a), __arg2 = (b); \
        !            67:    asm ( "neg %3,%%o4; \
        !            68:           sll %2,%%o4,%1; \
        !            69:           srl %2,%3,%0" \
        !            70:         : "=r" (__value), "=r" (hiremainder) \
        !            71:         : "r" (__arg1), "r" (__arg2) \
        !            72:          : "%o4","%g5"); \
        !            73: __value; })
        !            74:
        !            75: #define shiftlr1(a) \
        !            76: ({ unsigned long __value, __arg1 = (a); \
        !            77:    asm ( "sll %2,31,%1; \
        !            78:           srl %2,1,%0" \
        !            79:         : "=r" (__value), "=r" (hiremainder) \
        !            80:         : "r" (__arg1) \
        !            81:          : "%g5"); \
        !            82: __value; })
        !            83:
        !            84: #define shiftlr2(a,b,c) \
        !            85: ({ unsigned long __value, __arg1 = (a), __arg2 = (b), __arg3 = (c); \
        !            86:    asm ( "sll %2,%4,%1; \
        !            87:           srl %2,%3,%0" \
        !            88:         : "=r" (__value), "=r" (hiremainder) \
        !            89:         : "r" (__arg1), "r" (__arg2), "r" (__arg3) \
        !            90:          : "%g5"); \
        !            91: __value; })
        !            92:
        !            93: #define mulll(a,b) \
        !            94: ({ unsigned long __value, __arg1 = (a), __arg2 = (b); \
        !            95:    asm ( "umul %2,%3,%0; \
        !            96:           srlx %0,32,%1" \
        !            97:         : "=r" (__value), "=r" (hiremainder) \
        !            98:         : "r" (__arg1), "r" (__arg2) \
        !            99:          : "%g5");     \
        !           100: __value;})
        !           101:
        !           102: #define addmul(a,b) \
        !           103: ({ unsigned long __value, __arg1 = (a), __arg2 = (b); \
        !           104:    asm ( "umul %2,%3,%0; \
        !           105:           add  %0,%%g5,%0; \
        !           106:           srlx %0,32,%1" \
        !           107:         : "=r" (__value), "=r" (hiremainder) \
        !           108:         : "r" (__arg1), "r" (__arg2) \
        !           109:          : "%g5");     \
        !           110: __value;})
        !           111:
        !           112: #define divll(a,b) \
        !           113: ({ unsigned long __value, __arg1 = (a), __arg2 = (b); \
        !           114:    asm( "wr      %%g5,%%g0,%%y;\
        !           115:          mov     %2,%%o4;\
        !           116:         udivcc  %2,%3,%0;\
        !           117:          bvc     1f;\
        !           118:          umul    %0,%3,%%o5;\
        !           119:          mov     47,%%o0;\
        !           120:          call    err,1;\
        !           121:          nop         ;\
        !           122: 1:      sub     %%o4,%%o5,%1"\
        !           123:        : "=r" (__value), "=r" (hiremainder) \
        !           124:        : "r" (__arg1), "r" (__arg2) \
        !           125:         : "%o4","%o5","%g5","cc");     \
        !           126: __value;})
        !           127:
        !           128: #endif