Return to asmsparcv9.h CVS log

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

Annotation of OpenXM_contrib/pari-2.2/src/kernel/sparcv9/asmsparcv9.h, Revision 1.1.1.1

1.1       noro        1: /* $Id: asmsparcv9.h,v 1.3 2000/11/03 21:00:27 karim Exp $
                      2:
                      3: Copyright (C) 2000  The PARI group.
                      4:
                      5: This file is part of the PARI/GP package.
                      6:
                      7: PARI/GP is free software; you can redistribute it and/or modify it under the
                      8: terms of the GNU General Public License as published by the Free Software
                      9: Foundation. It is distributed in the hope that it will be useful, but WITHOUT
                     10: ANY WARRANTY WHATSOEVER.
                     11:
                     12: Check the License for details. You should have received a copy of it, along
                     13: with the package; see the file 'COPYING'. If not, write to the Free Software
                     14: Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
                     15:
                     16: #ifndef __ASMSPARCV9_H__
                     17: #define __ASMSPARCV9_H__
                     18:
                     19: register ulong hiremainder asm("%g5");
                     20: register ulong overflow asm("%g6");
                     21:
                     22: #define addll(a,b) \
                     23: ({ ulong __value, __arg1 = (a), __arg2 = (b); \
                     24:    asm ( "addcc %2,%3,%0; \
                     25:           addc  %%g0,%%g0,%1" \
                     26:         : "=r" (__value), "=r" (overflow) \
                     27:         : "r" (__arg1), "r" (__arg2) \
                     28:          : "%g6","cc"); \
                     29: __value; })
                     30:
                     31: #define subll(a,b) \
                     32: ({ ulong __value, __arg1 = (a), __arg2 = (b); \
                     33:    asm ( "subcc %2,%3,%0; \
                     34:           addc  %%g0,%%g0,%1" \
                     35:         : "=r" (__value), "=r" (overflow) \
                     36:         : "r" (__arg1), "r" (__arg2) \
                     37:          : "%g6","cc"); \
                     38: __value; })
                     39:
                     40: #define addllx(a,b) \
                     41: ({ ulong __value, __arg1 = (a), __arg2 = (b); \
                     42:    asm ( "subcc %%g0,%%g6,%%g0; \
                     43:           addccc %2,%3,%0; \
                     44:           addc  %%g0,%%g0,%1" \
                     45:         : "=r" (__value), "=r" (overflow) \
                     46:         : "r" (__arg1), "r" (__arg2) \
                     47:          : "%g6","cc"); \
                     48: __value; })
                     49:
                     50: #define subllx(a,b) \
                     51: ({ ulong __value, __arg1 = (a), __arg2 = (b); \
                     52:    asm ( "subcc %%g0,%%g6,%%g0; \
                     53:           subccc %2,%3,%0; \
                     54:           addc  %%g0,%%g0,%1" \
                     55:         : "=r" (__value), "=r" (overflow) \
                     56:         : "r" (__arg1), "r" (__arg2) \
                     57:          : "%g6","cc"); \
                     58: __value; })
                     59:
                     60: #define shiftl(a,b) \
                     61: ({ ulong __value, __arg1 = (a), __arg2 = (b); \
                     62:    asm ( "neg %3,%%o4; \
                     63:           srl %2,%%o4,%1; \
                     64:           sll %2,%3,%0" \
                     65:         : "=r" (__value), "=r" (hiremainder) \
                     66:         : "r" (__arg1), "r" (__arg2) \
                     67:          : "%o4","%g5"); \
                     68: __value; })
                     69:
                     70: #define shiftl2(a,b,c) \
                     71: ({ ulong __value, __arg1 = (a), __arg2 = (b), __arg3 = (c); \
                     72:    asm ( "srl %2,%4,%1; \
                     73:           sll %2,%3,%0" \
                     74:         : "=r" (__value), "=r" (hiremainder) \
                     75:         : "r" (__arg1), "r" (__arg2), "r" (__arg3) \
                     76:          : "%g5"); \
                     77: __value; })
                     78:
                     79: #define shiftlr(a,b) \
                     80: ({ ulong __value, __arg1 = (a), __arg2 = (b); \
                     81:    asm ( "neg %3,%%o4; \
                     82:           sll %2,%%o4,%1; \
                     83:           srl %2,%3,%0" \
                     84:         : "=r" (__value), "=r" (hiremainder) \
                     85:         : "r" (__arg1), "r" (__arg2) \
                     86:          : "%o4","%g5"); \
                     87: __value; })
                     88:
                     89: #define shiftlr1(a) \
                     90: ({ ulong __value, __arg1 = (a); \
                     91:    asm ( "sll %2,31,%1; \
                     92:           srl %2,1,%0" \
                     93:         : "=r" (__value), "=r" (hiremainder) \
                     94:         : "r" (__arg1) \
                     95:          : "%g5"); \
                     96: __value; })
                     97:
                     98: #define shiftlr2(a,b,c) \
                     99: ({ ulong __value, __arg1 = (a), __arg2 = (b), __arg3 = (c); \
                    100:    asm ( "sll %2,%4,%1; \
                    101:           srl %2,%3,%0" \
                    102:         : "=r" (__value), "=r" (hiremainder) \
                    103:         : "r" (__arg1), "r" (__arg2), "r" (__arg3) \
                    104:          : "%g5"); \
                    105: __value; })
                    106:
                    107: #define mulll(a,b) \
                    108: ({ ulong __value, __arg1 = (a), __arg2 = (b); \
                    109:    asm ( "umul %2,%3,%0; \
                    110:           srlx %0,32,%1" \
                    111:         : "=r" (__value), "=r" (hiremainder) \
                    112:         : "r" (__arg1), "r" (__arg2) \
                    113:          : "%g5");     \
                    114: __value;})
                    115:
                    116: #define addmul(a,b) \
                    117: ({ ulong __value, __arg1 = (a), __arg2 = (b); \
                    118:    asm ( "umul %2,%3,%0; \
                    119:           add  %0,%%g5,%0; \
                    120:           srlx %0,32,%1" \
                    121:         : "=r" (__value), "=r" (hiremainder) \
                    122:         : "r" (__arg1), "r" (__arg2) \
                    123:          : "%g5");     \
                    124: __value;})
                    125:
                    126: #define divll(a,b) \
                    127: ({ ulong __value, __arg1 = (a), __arg2 = (b); \
                    128:    asm( "wr      %%g5,%%g0,%%y;\
                    129:          mov     %2,%%o4;\
                    130:         udivcc  %2,%3,%0;\
                    131:          bvc     1f;\
                    132:          umul    %0,%3,%%o5;\
                    133:          mov     47,%%o0;\
                    134:          call    err,1;\
                    135:          nop         ;\
                    136: 1:      sub     %%o4,%%o5,%1"\
                    137:        : "=r" (__value), "=r" (hiremainder) \
                    138:        : "r" (__arg1), "r" (__arg2) \
                    139:         : "%o4","%o5","%g5","cc");     \
                    140: __value;})
                    141:
                    142: #endif