include/minix/u64.h

   1 /*      minix/u64.h                                     Author: Kees J. Bot
   2  *                                                              7 Dec 1995
   3  * Functions to manipulate 64 bit disk addresses.
   4  */
   5 #ifndef _MINIX__U64_H
   6 #define _MINIX__U64_H
   7
   8 #ifndef _TYPES_H
   9 #include <minix/types.h>
  10 #endif
  11
  12 #include <limits.h>
  13
  14 #define is_zero64(i)    ((i) == 0)
  15 #define make_zero64(i)  ((i) = 0)
  16 #define neg64(i)        ((i) = -(i))
  17
  18 static inline u64_t add64(u64_t i, u64_t j)
  19 {
  20         return i + j;
  21 }
  22
  23 static inline u64_t add64u(u64_t i, unsigned j)
  24 {
  25         return i + j;
  26 }
  27
  28 static inline u64_t add64ul(u64_t i, unsigned long j)
  29 {
  30         return i + j;
  31 }
  32
  33 static inline int bsr64(u64_t i)
  34 {
  35         int index;
  36         u64_t mask;
  37
  38         for (index = 63, mask = 1ULL << 63; index >= 0; --index, mask >>= 1) {
  39             if (i & mask)
  40                 return index;
  41         }
  42
  43         return -1;
  44 }
  45
  46 static inline int cmp64(u64_t i, u64_t j)
  47 {
  48         if (i > j)
  49                 return 1;
  50         else if (i < j)
  51                 return -1;
  52         else /* (i == j) */
  53                 return 0;
  54 }
  55
  56 static inline int cmp64u(u64_t i, unsigned j)
  57 {
  58         if (i > j)
  59                 return 1;
  60         else if (i < j)
  61                 return -1;
  62         else /* (i == j) */
  63                 return 0;
  64 }
  65
  66 static inline int cmp64ul(u64_t i, unsigned long j)
  67 {
  68         if (i > j)
  69                 return 1;
  70         else if (i < j)
  71                 return -1;
  72         else /* (i == j) */
  73                 return 0;
  74 }
  75
  76 static inline unsigned cv64u(u64_t i)
  77 {
  78 /* return ULONG_MAX if really big */
  79     if (i>>32)
  80         return ULONG_MAX;
  81
  82     return (unsigned)i;
  83 }
  84
  85 static inline unsigned long cv64ul(u64_t i)
  86 {
  87 /* return ULONG_MAX if really big */
  88     if (i>>32)
  89         return ULONG_MAX;
  90
  91     return (unsigned long)i;
  92 }
  93
  94 static inline u64_t cvu64(unsigned i)
  95 {
  96         return i;
  97 }
  98
  99 static inline u64_t cvul64(unsigned long i)
 100 {
 101         return i;
 102 }
 103
 104 static inline unsigned diff64(u64_t i, u64_t j)
 105 {
 106         return (unsigned)(i - j);
 107 }
 108
 109 static inline u64_t div64(u64_t i, u64_t j)
 110 {
 111         return i / j;
 112 }
 113
 114 static inline u64_t rem64(u64_t i, u64_t j)
 115 {
 116         return i % j;
 117 }
 118
 119 static inline unsigned long div64u(u64_t i, unsigned j)
 120 {
 121         return (unsigned long)(i / j);
 122 }
 123
 124 static inline u64_t div64u64(u64_t i, unsigned j)
 125 {
 126         return i / j;
 127 }
 128
 129 static inline unsigned rem64u(u64_t i, unsigned j)
 130 {
 131         return (unsigned)(i % j);
 132 }
 133
 134 static inline unsigned long ex64lo(u64_t i)
 135 {
 136         return (unsigned long)i;
 137 }
 138
 139 static inline unsigned long ex64hi(u64_t i)
 140 {
 141         return (unsigned long)(i>>32);
 142 }
 143
 144 static inline u64_t make64(unsigned long lo, unsigned long hi)
 145 {
 146         return ((u64_t)hi << 32) | (u64_t)lo;
 147 }
 148
 149 static inline u64_t mul64(u64_t i, u64_t j)
 150 {
 151         return i * j;
 152 }
 153
 154 static inline u64_t mul64u(unsigned long i, unsigned j)
 155 {
 156         return (u64_t)i * j;
 157 }
 158
 159 static inline u64_t sub64(u64_t i, u64_t j)
 160 {
 161         return i - j;
 162 }
 163
 164 static inline u64_t sub64u(u64_t i, unsigned j)
 165 {
 166         return i - j;
 167 }
 168
 169 static inline u64_t sub64ul(u64_t i, unsigned long j)
 170 {
 171         return i - j;
 172 }
 173
 174 u64_t rrotate64(u64_t x, unsigned short b);
 175 u64_t rshift64(u64_t x, unsigned short b);
 176 u64_t xor64(u64_t a, u64_t b);
 177 u64_t and64(u64_t a, u64_t b);
 178 u64_t not64(u64_t a);
 179
 180 #endif /* _MINIX__U64_H */