external/bsd/pcc/dist/pcc-libs/libpcc/quad.h

   1 /*      $NetBSD: quad.h,v 1.1 2005/12/20 20:29:40 christos Exp $        */
   2
   3 /*-
   4  * Copyright (c) 1992, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * This software was developed by the Computer Systems Engineering group
   8  * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
   9  * contributed to Berkeley.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  * 3. Neither the name of the University nor the names of its contributors
  20  *    may be used to endorse or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  *
  35  *      @(#)quad.h      8.1 (Berkeley) 6/4/93
  36  */
  37
  38 /*
  39  * Quad arithmetic.
  40  *
  41  * This library makes the following assumptions:
  42  *
  43  *  - The type long long (aka quad_t) exists.
  44  *
  45  *  - A quad variable is exactly twice as long as `int'.
  46  *
  47  *  - The machine's arithmetic is two's complement.
  48  *
  49  * This library can provide 128-bit arithmetic on a machine with 128-bit
  50  * quads and 64-bit ints, for instance, or 96-bit arithmetic on machines
  51  * with 48-bit ints.
  52  */
  53
  54 #ifndef __SunOS
  55 #include <sys/types.h>
  56 #endif
  57
  58 #include <limits.h>
  59
  60 #ifndef QUAD_MIN
  61 #define QUAD_MIN        (-0x7fffffffffffffffLL-1)
  62 #endif
  63 #ifndef QUAD_MAX
  64 #define QUAD_MAX        0x7fffffffffffffffLL
  65 #endif
  66 #ifndef UQUAD_MAX
  67 #define UQUAD_MAX       0xffffffffffffffffULL
  68 #endif
  69
  70 #ifdef WIN32
  71 typedef long long               quad_t;
  72 typedef unsigned long long      u_quad_t;
  73 #endif
  74
  75 #ifdef __SunOS
  76 typedef long long               quad_t;
  77 typedef unsigned long long      u_quad_t;
  78 #endif
  79
  80 /*
  81  * Depending on the desired operation, we view a `long long' (aka quad_t) in
  82  * one or more of the following formats.
  83  */
  84 union uu {
  85         quad_t q;               /* as a (signed) quad */
  86         u_quad_t uq;            /* as an unsigned quad */
  87         int sl[2];              /* as two signed ints */
  88         unsigned int ul[2];     /* as two unsigned ints */
  89 };
  90
  91 /*
  92  * Define high and low parts of a quad_t.
  93  */
  94 #ifdef __BIG_ENDIAN__
  95 #define H               0
  96 #define L               1
  97 #else
  98 #define H               1
  99 #define L               0
 100 #endif
 101
 102 /*
 103  * Total number of bits in a quad_t and in the pieces that make it up.
 104  * These are used for shifting, and also below for halfword extraction
 105  * and assembly.
 106  */
 107 #define QUAD_BITS       (sizeof(quad_t) * CHAR_BIT)
 108 #define INT_BITS        (sizeof(int) * CHAR_BIT)
 109 #define HALF_BITS       (sizeof(int) * CHAR_BIT / 2)
 110
 111 /*
 112  * Extract high and low shortwords from longword, and move low shortword of
 113  * longword to upper half of long, i.e., produce the upper longword of
 114  * ((quad_t)(x) << (number_of_bits_in_int/2)).  (`x' must actually be unsigned int.)
 115  *
 116  * These are used in the multiply code, to split a longword into upper
 117  * and lower halves, and to reassemble a product as a quad_t, shifted left
 118  * (sizeof(int)*CHAR_BIT/2).
 119  */
 120 #define HHALF(x)        ((unsigned int)(x) >> HALF_BITS)
 121 #define LHALF(x)        ((unsigned int)(x) & (((int)1 << HALF_BITS) - 1))
 122 #define LHUP(x)         ((unsigned int)(x) << HALF_BITS)
 123
 124 /*
 125  * XXX
 126  * Compensate for gcc 1 vs gcc 2.  Gcc 1 defines ?sh?di3's second argument
 127  * as u_quad_t, while gcc 2 correctly uses int.  Unfortunately, we still use
 128  * both compilers.
 129  */
 130 typedef unsigned int    qshift_t;
 131
 132 quad_t __adddi3(quad_t, quad_t);
 133 quad_t __anddi3(quad_t, quad_t);
 134 quad_t __ashldi3(quad_t, qshift_t);
 135 quad_t __ashrdi3(quad_t, qshift_t);
 136 int __cmpdi2(quad_t, quad_t);
 137 quad_t __divdi3(quad_t, quad_t);
 138 quad_t __fixdfdi(double);
 139 quad_t __fixsfdi(float);
 140 u_quad_t __fixunsdfdi(double);
 141 u_quad_t __fixunssfdi(float);
 142 double __floatdidf(quad_t);
 143 float __floatdisf(quad_t);
 144 double __floatunsdidf(u_quad_t);
 145 quad_t __iordi3(quad_t, quad_t);
 146 quad_t __lshldi3(quad_t, qshift_t);
 147 quad_t __lshrdi3(quad_t, qshift_t);
 148 quad_t __moddi3(quad_t, quad_t);
 149 quad_t __muldi3(quad_t, quad_t);
 150 quad_t __negdi2(quad_t);
 151 quad_t __one_cmpldi2(quad_t);
 152 u_quad_t __qdivrem(u_quad_t, u_quad_t, u_quad_t *);
 153 quad_t __subdi3(quad_t, quad_t);
 154 int __ucmpdi2(u_quad_t, u_quad_t);
 155 u_quad_t __udivdi3(u_quad_t, u_quad_t);
 156 u_quad_t __umoddi3(u_quad_t, u_quad_t);
 157 quad_t __xordi3(quad_t, quad_t);