reactos/ntoskrnl/rtl/largeint.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS kernel
   4  * FILE:            kernel/rtl/largeint.c
   5  * PURPOSE:         Large integer operations
   6  * UPDATE HISTORY:
   7  *                  Created 22/05/98
   8  *   08/30/98  RJJ  Implemented several functions
   9  */
  10
  11 /* INCLUDES *****************************************************************/
  12
  13 #include <internal/ke.h>
  14 #include <internal/linkage.h>
  15 #include <ddk/ntddk.h>
  16
  17 #define NDEBUG
  18 #include <internal/debug.h>
  19
  20 typedef long long int LLI, *PLLI;
  21 typedef unsigned long long int ULLI, *PULLI;
  22
  23 #define LIFromLLI(X) (*(PLARGE_INTEGER)&(X))
  24 #define LLIFromLI(X) (*(PLLI)&(X))
  25 #define ULIFromULLI(X) (*(PULARGE_INTEGER)&(X))
  26
  27 /* FUNCTIONS *****************************************************************/
  28
  29 LARGE_INTEGER
  30 RtlConvertLongToLargeInteger(LONG SignedInteger)
  31 {
  32   LARGE_INTEGER RC;
  33
  34   RC.QuadPart = SignedInteger;
  35
  36   return RC;
  37 }
  38
  39 LARGE_INTEGER
  40 RtlConvertUlongToLargeInteger(ULONG UnsignedInteger)
  41 {
  42   LARGE_INTEGER RC;
  43
  44   RC.QuadPart = UnsignedInteger;
  45
  46   return RC;
  47 }
  48
  49 LARGE_INTEGER
  50 RtlEnlargedIntegerMultiply(LONG Multiplicand,
  51                            LONG Multiplier)
  52 {
  53   LARGE_INTEGER RC;
  54
  55   RC.QuadPart = (LONGLONG) Multiplicand * Multiplier;
  56
  57   return RC;
  58 }
  59
  60 ULONG RtlEnlargedUnsignedDivide(ULARGE_INTEGER Dividend,
  61                                 ULONG Divisor,
  62                                 PULONG Remainder)
  63 {
  64   UNIMPLEMENTED;
  65 }
  66
  67 LARGE_INTEGER RtlEnlargedUnsignedMultiply(ULONG Multiplicand,
  68                                           ULONG Multiplier)
  69 {
  70   LARGE_INTEGER RC;
  71
  72   RC.QuadPart = (ULONGLONG) Multiplicand * Multiplier;
  73
  74   return RC;
  75 }
  76
  77 LARGE_INTEGER
  78 RtlExtendedIntegerMultiply(LARGE_INTEGER Multiplicand,
  79                            LONG Multiplier)
  80 {
  81   LARGE_INTEGER RC;
  82
  83   RC.QuadPart = Multiplicand.QuadPart * Multiplier;
  84
  85   return RC;
  86 }
  87
  88 LARGE_INTEGER RtlExtendedLargeIntegerDivide(LARGE_INTEGER Dividend,
  89                                             ULONG Divisor,
  90                                             PULONG Remainder)
  91 {
  92    UNIMPLEMENTED;
  93 }
  94
  95 LARGE_INTEGER RtlExtendedMagicDivide(LARGE_INTEGER Dividend,
  96                                      LARGE_INTEGER MagicDivisor,
  97                                      CCHAR ShiftCount)
  98 {
  99    UNIMPLEMENTED;
 100 }
 101
 102 LARGE_INTEGER ExInterlockedAddLargeInteger(PLARGE_INTEGER Addend,
 103                                            LARGE_INTEGER Increment,
 104                                            PKSPIN_LOCK Lock)
 105 {
 106    UNIMPLEMENTED;
 107 }
 108
 109 LARGE_INTEGER
 110 RtlLargeIntegerAdd(LARGE_INTEGER Addend1,
 111                    LARGE_INTEGER Addend2)
 112 {
 113   LARGE_INTEGER RC;
 114
 115   RC.QuadPart = Addend1.QuadPart + Addend2.QuadPart;
 116
 117   return RC;
 118 }
 119
 120 VOID RtlLargeIntegerAnd(PLARGE_INTEGER Result,
 121                         LARGE_INTEGER Source,
 122                         LARGE_INTEGER Mask)
 123 {
 124   Result->QuadPart = Source.QuadPart & Mask.QuadPart;
 125 }
 126
 127 LARGE_INTEGER RtlLargeIntegerArithmeticShift(LARGE_INTEGER LargeInteger,
 128                                              CCHAR ShiftCount)
 129 {
 130   UNIMPLEMENTED;
 131 #if 0
 132   LARGE_INTEGER RC;
 133
 134
 135   RC.QuadPart = LargeInteger.QuadPart >> ShiftCount;
 136   asm ("movb %2, %%cl\n\t"
 137        "andb $0x3f, %%cl\n\t"
 138        "movl %3, %%eax\n\t"
 139        "movl %4,  %%edx\n\t"
 140        "shrdl %%cl, %%edx, %%eax\n\t"
 141        "sarl %%cl, %%edx\n\t"
 142        "movl %%eax, %0\n\t"
 143        "movl %%edx, %1\n\t"
 144        : "=m" (LargeInteger.LowPart),
 145          "=m" (LargeInteger.HighPart)
 146        : "m" (ShiftCount),
 147          "0" (LargeInteger.LowPart),
 148          "1" (LargeInteger.HighPart)
 149        : "eax", "ecx", "edx"
 150        );
 151
 152   return RC;
 153 #endif
 154 }
 155
 156 LARGE_INTEGER RtlLargeIntegerDivide(LARGE_INTEGER Dividend,
 157                                     LARGE_INTEGER Divisor,
 158                                     PLARGE_INTEGER Remainder)
 159 {
 160   UNIMPLEMENTED;
 161 }
 162
 163 BOOLEAN
 164 RtlLargeIntegerEqualTo(LARGE_INTEGER Operand1,
 165                        LARGE_INTEGER Operand2)
 166 {
 167   return Operand1.QuadPart == Operand2.QuadPart;
 168 #if 0
 169   return Operand1.HighPart == Operand2.HighPart &&
 170          Operand1.LowPart == Operand2.LowPart;
 171 #endif
 172 }
 173
 174 BOOLEAN
 175 RtlLargeIntegerEqualToZero(LARGE_INTEGER Operand)
 176 {
 177   return Operand.QuadPart == 0 ;
 178 }
 179
 180 BOOLEAN
 181 RtlLargeIntegerGreaterThan(LARGE_INTEGER Operand1,
 182                            LARGE_INTEGER Operand2)
 183 {
 184   return Operand1.QuadPart > Operand2.QuadPart;
 185 #if 0
 186   return Operand1.HighPart > Operand2.HighPart ||
 187          (Operand1.HighPart == Operand2.HighPart &&
 188           Operand1.LowPart > Operand2.LowPart);
 189 #endif
 190 }
 191
 192 BOOLEAN
 193 RtlLargeIntegerGreaterThanOrEqualTo(LARGE_INTEGER Operand1,
 194                                     LARGE_INTEGER Operand2)
 195 {
 196   return Operand1.QuadPart >= Operand2.QuadPart;
 197 #if 0
 198   return Operand1.HighPart > Operand2.HighPart ||
 199          (Operand1.HighPart == Operand2.HighPart &&
 200           Operand1.LowPart >= Operand2.LowPart);
 201 #endif
 202 }
 203
 204 BOOLEAN
 205 RtlLargeIntegerGreaterThanOrEqualToZero(LARGE_INTEGER Operand1)
 206 {
 207   return Operand1.QuadPart >= 0;
 208 #if 0
 209   return Operand1.HighPart >= 0;
 210 #endif
 211 }
 212
 213 BOOLEAN
 214 RtlLargeIntegerGreaterThanZero(LARGE_INTEGER Operand1)
 215 {
 216   return Operand1.QuadPart > 0;
 217 #if 0
 218   return Operand1.HighPart > 0 ||
 219          (Operand1.HighPart == 0 && Operand1.LowPart > 0);
 220 #endif
 221 }
 222
 223 BOOLEAN
 224 RtlLargeIntegerLessThan(LARGE_INTEGER Operand1,
 225                         LARGE_INTEGER Operand2)
 226 {
 227   return Operand1.QuadPart < Operand2.QuadPart;
 228 #if 0
 229   return Operand1.HighPart < Operand2.HighPart ||
 230          (Operand1.HighPart == Operand2.HighPart &&
 231           Operand1.LowPart < Operand2.LowPart);
 232 #endif
 233 }
 234
 235 BOOLEAN
 236 RtlLargeIntegerLessThanOrEqualTo(LARGE_INTEGER Operand1,
 237                                  LARGE_INTEGER Operand2)
 238 {
 239   return Operand1.QuadPart <= Operand2.QuadPart;
 240 #if 0
 241   return Operand1.HighPart < Operand2.HighPart ||
 242          (Operand1.HighPart == Operand2.HighPart &&
 243           Operand1.LowPart <= Operand2.LowPart);
 244 #endif
 245 }
 246
 247 BOOLEAN
 248 RtlLargeIntegerLessThanOrEqualToZero(LARGE_INTEGER Operand)
 249 {
 250   return Operand.QuadPart <= 0;
 251 #if 0
 252   return Operand.HighPart < 0 ||
 253          (Operand.HighPart == 0 && Operand.LowPart == 0);
 254 #endif
 255 }
 256
 257 BOOLEAN
 258 RtlLargeIntegerLessThanZero(LARGE_INTEGER Operand)
 259 {
 260   return Operand.QuadPart < 0;
 261 #if 0
 262   return Operand.HighPart < 0;
 263 #endif
 264 }
 265
 266 LARGE_INTEGER RtlLargeIntegerNegate(LARGE_INTEGER Subtrahend)
 267 {
 268   LARGE_INTEGER RC;
 269
 270   RC.QuadPart = - Subtrahend.QuadPart;
 271
 272   return RC;
 273 }
 274
 275 BOOLEAN
 276 RtlLargeIntegerNotEqualTo(LARGE_INTEGER Operand1,
 277                           LARGE_INTEGER Operand2)
 278 {
 279   return Operand1.QuadPart != Operand2.QuadPart;
 280 }
 281
 282 BOOLEAN
 283 RtlLargeIntegerNotEqualToZero(LARGE_INTEGER Operand)
 284 {
 285   return Operand.QuadPart != 0;
 286 }
 287
 288 LARGE_INTEGER RtlLargeIntegerShiftLeft(LARGE_INTEGER LargeInteger,
 289                                        CCHAR ShiftCount)
 290 {
 291   LARGE_INTEGER RC;
 292
 293   RC.QuadPart = LargeInteger.QuadPart << ShiftCount;
 294
 295   return RC;
 296 }
 297
 298 LARGE_INTEGER RtlLargeIntegerShiftRight(LARGE_INTEGER LargeInteger,
 299                                         CCHAR ShiftCount)
 300 {
 301   LARGE_INTEGER RC;
 302
 303   RC.QuadPart = LargeInteger.QuadPart >> ShiftCount;
 304
 305   return RC;
 306 }
 307
 308 LARGE_INTEGER RtlLargeIntegerSubtract(LARGE_INTEGER Minuend,
 309                                       LARGE_INTEGER Subtrahend)
 310 {
 311   LARGE_INTEGER RC;
 312
 313   RC.QuadPart = Minuend.QuadPart - Subtrahend.QuadPart;
 314
 315   return RC;
 316 }
 317