1 /*
2 * Large integer functions
3 *
4 * Copyright 2000 Alexandre Julliard
5 * Copyright 2003 Thomas Mertes
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include "config.h"
23 #include "wine/port.h"
24
25 #include <stdarg.h>
26
27 #include "ntstatus.h"
28 #define WIN32_NO_STATUS
29 #include "windef.h"
30 #include "winternl.h"
31
32 #ifndef _WIN64
33
34 /*
35 * Note: we use LONGLONG instead of LARGE_INTEGER, because
36 * the latter is a structure and the calling convention for
37 * returning a structure would not be binary-compatible.
38 *
39 * FIXME: for platforms that don't have a native LONGLONG type,
40 * we should define LONGLONG as a structure similar to LARGE_INTEGER
41 * and do everything by hand. You are welcome to do it...
42 */
43
44 /******************************************************************************
45 * RtlLargeIntegerAdd (NTDLL.@)
46 *
47 * Add two 64 bit integers.
48 *
49 * PARAMS
50 * a [I] Initial number.
51 * b [I] Number to add to a.
52 *
53 * RETURNS
54 * The sum of a and b.
55 */
56 LONGLONG WINAPI RtlLargeIntegerAdd( LONGLONG a, LONGLONG b )
57 {
58 return a + b;
59 }
60
61
62 /******************************************************************************
63 * RtlLargeIntegerSubtract (NTDLL.@)
64 *
65 * Subtract two 64 bit integers.
66 *
67 * PARAMS
68 * a [I] Initial number.
69 * b [I] Number to subtract from a.
70 *
71 * RETURNS
72 * The difference of a and b.
73 */
74 LONGLONG WINAPI RtlLargeIntegerSubtract( LONGLONG a, LONGLONG b )
75 {
76 return a - b;
77 }
78
79
80 /******************************************************************************
81 * RtlLargeIntegerNegate (NTDLL.@)
82 *
83 * Negate a 64 bit integer.
84 *
85 * PARAMS
86 * a [I] Initial number.
87 *
88 * RETURNS
89 * The value of a negated.
90 */
91 LONGLONG WINAPI RtlLargeIntegerNegate( LONGLONG a )
92 {
93 return -a;
94 }
95
96
97 /******************************************************************************
98 * RtlLargeIntegerShiftLeft (NTDLL.@)
99 *
100 * Perform a shift left on a 64 bit integer.
101 *
102 * PARAMS
103 * a [I] Initial number.
104 * count [I] Number of bits to shift by
105 *
106 * RETURNS
107 * The value of a following the shift.
108 */
109 LONGLONG WINAPI RtlLargeIntegerShiftLeft( LONGLONG a, INT count )
110 {
111 return a << count;
112 }
113
114
115 /******************************************************************************
116 * RtlLargeIntegerShiftRight (NTDLL.@)
117 *
118 * Perform a shift right on a 64 bit integer.
119 *
120 * PARAMS
121 * a [I] Initial number.
122 * count [I] Number of bits to shift by
123 *
124 * RETURNS
125 * The value of a following the shift.
126 */
127 LONGLONG WINAPI RtlLargeIntegerShiftRight( LONGLONG a, INT count )
128 {
129 return (ULONGLONG)a >> count;
130 }
131
132
133 /******************************************************************************
134 * RtlLargeIntegerArithmeticShift (NTDLL.@)
135 *
136 * Perform an arithmetic shift right on a 64 bit integer.
137 *
138 * PARAMS
139 * a [I] Initial number.
140 * count [I] Number of bits to shift by
141 *
142 * RETURNS
143 * The value of a following the shift.
144 */
145 LONGLONG WINAPI RtlLargeIntegerArithmeticShift( LONGLONG a, INT count )
146 {
147 /* FIXME: gcc does arithmetic shift here, but it may not be true on all platforms */
148 return a >> count;
149 }
150
151
152 /******************************************************************************
153 * RtlLargeIntegerDivide (NTDLL.@)
154 *
155 * Divide one 64 bit unsigned integer by another, with remainder.
156 *
157 * PARAMS
158 * a [I] Initial number.
159 * b [I] Number to divide a by
160 * rem [O] Destination for remainder
161 *
162 * RETURNS
163 * The dividend of a and b. If rem is non-NULL it is set to the remainder.
164 *
165 * FIXME
166 * Should it be signed division instead?
167 */
168 ULONGLONG WINAPI RtlLargeIntegerDivide( ULONGLONG a, ULONGLONG b, ULONGLONG *rem )
169 {
170 ULONGLONG ret = a / b;
171 if (rem) *rem = a - ret * b;
172 return ret;
173 }
174
175
176 /******************************************************************************
177 * RtlConvertLongToLargeInteger (NTDLL.@)
178 *
179 * Convert a 32 bit integer into 64 bits.
180 *
181 * PARAMS
182 * a [I] Number to convert
183 *
184 * RETURNS
185 * a.
186 */
187 LONGLONG WINAPI RtlConvertLongToLargeInteger( LONG a )
188 {
189 return a;
190 }
191
192
193 /******************************************************************************
194 * RtlConvertUlongToLargeInteger (NTDLL.@)
195 *
196 * Convert a 32 bit unsigned integer into 64 bits.
197 *
198 * PARAMS
199 * a [I] Number to convert
200 *
201 * RETURNS
202 * a.
203 */
204 ULONGLONG WINAPI RtlConvertUlongToLargeInteger( ULONG a )
205 {
206 return a;
207 }
208
209
210 /******************************************************************************
211 * RtlEnlargedIntegerMultiply (NTDLL.@)
212 *
213 * Multiply two integers giving a 64 bit integer result.
214 *
215 * PARAMS
216 * a [I] Initial number.
217 * b [I] Number to multiply a by.
218 *
219 * RETURNS
220 * The product of a and b.
221 */
222 LONGLONG WINAPI RtlEnlargedIntegerMultiply( INT a, INT b )
223 {
224 return (LONGLONG)a * b;
225 }
226
227
228 /******************************************************************************
229 * RtlEnlargedUnsignedMultiply (NTDLL.@)
230 *
231 * Multiply two unsigned integers giving a 64 bit unsigned integer result.
232 *
233 * PARAMS
234 * a [I] Initial number.
235 * b [I] Number to multiply a by.
236 *
237 * RETURNS
238 * The product of a and b.
239 */
240 ULONGLONG WINAPI RtlEnlargedUnsignedMultiply( UINT a, UINT b )
241 {
242 return (ULONGLONG)a * b;
243 }
244
245
246 /******************************************************************************
247 * RtlEnlargedUnsignedDivide (NTDLL.@)
248 *
249 * Divide one 64 bit unsigned integer by a 32 bit unsigned integer, with remainder.
250 *
251 * PARAMS
252 * a [I] Initial number.
253 * b [I] Number to divide a by
254 * remptr [O] Destination for remainder
255 *
256 * RETURNS
257 * The dividend of a and b. If remptr is non-NULL it is set to the remainder.
258 */
259 UINT WINAPI RtlEnlargedUnsignedDivide( ULONGLONG a, UINT b, UINT *remptr )
260 {
261 #if defined(__i386__) && defined(__GNUC__)
262 UINT ret, rem;
263
264 __asm__("divl %4"
265 : "=a" (ret), "=d" (rem)
266 : "" ((UINT)a), "1" ((UINT)(a >> 32)), "g" (b) );
267 if (remptr) *remptr = rem;
268 return ret;
269 #else
270 UINT ret = a / b;
271 if (remptr) *remptr = a % b;
272 return ret;
273 #endif
274 }
275
276
277 /******************************************************************************
278 * RtlExtendedLargeIntegerDivide (NTDLL.@)
279 *
280 * Divide one 64 bit integer by a 32 bit integer, with remainder.
281 *
282 * PARAMS
283 * a [I] Initial number.
284 * b [I] Number to divide a by
285 * rem [O] Destination for remainder
286 *
287 * RETURNS
288 * The dividend of a and b. If rem is non-NULL it is set to the remainder.
289 */
290 LONGLONG WINAPI RtlExtendedLargeIntegerDivide( LONGLONG a, INT b, INT *rem )
291 {
292 LONGLONG ret = a / b;
293 if (rem) *rem = a - b * ret;
294 return ret;
295 }
296
297
298 /******************************************************************************
299 * RtlExtendedIntegerMultiply (NTDLL.@)
300 *
301 * Multiply one 64 bit integer by another 32 bit integer.
302 *
303 * PARAMS
304 * a [I] Initial number.
305 * b [I] Number to multiply a by.
306 *
307 * RETURNS
308 * The product of a and b.
309 */
310 LONGLONG WINAPI RtlExtendedIntegerMultiply( LONGLONG a, INT b )
311 {
312 return a * b;
313 }
314
315
316 /******************************************************************************
317 * RtlExtendedMagicDivide (NTDLL.@)
318 *
319 * Allows replacing a division by a longlong constant with a multiplication by
320 * the inverse constant.
321 *
322 * RETURNS
323 * (dividend * inverse_divisor) >> (64 + shift)
324 *
325 * NOTES
326 * If the divisor of a division is constant, the constants inverse_divisor and
327 * shift must be chosen such that inverse_divisor = 2^(64 + shift) / divisor.
328 * Then we have RtlExtendedMagicDivide(dividend,inverse_divisor,shift) ==
329 * dividend * inverse_divisor / 2^(64 + shift) == dividend / divisor.
330 *
331 * The Parameter inverse_divisor although defined as LONGLONG is used as
332 * ULONGLONG.
333 */
334 #define LOWER_32(A) ((A) & 0xffffffff)
335 #define UPPER_32(A) ((A) >> 32)
336 LONGLONG WINAPI RtlExtendedMagicDivide(
337 LONGLONG dividend, /* [I] Dividend to be divided by the constant divisor */
338 LONGLONG inverse_divisor, /* [I] Constant computed manually as 2^(64+shift) / divisor */
339 INT shift) /* [I] Constant shift chosen to make inverse_divisor as big as possible for 64 bits */
340 {
341 ULONGLONG dividend_high;
342 ULONGLONG dividend_low;
343 ULONGLONG inverse_divisor_high;
344 ULONGLONG inverse_divisor_low;
345 ULONGLONG ah_bl;
346 ULONGLONG al_bh;
347 LONGLONG result;
348 int positive;
349
350 if (dividend < 0) {
351 dividend_high = UPPER_32((ULONGLONG) -dividend);
352 dividend_low = LOWER_32((ULONGLONG) -dividend);
353 positive = 0;
354 } else {
355 dividend_high = UPPER_32((ULONGLONG) dividend);
356 dividend_low = LOWER_32((ULONGLONG) dividend);
357 positive = 1;
358 } /* if */
359 inverse_divisor_high = UPPER_32((ULONGLONG) inverse_divisor);
360 inverse_divisor_low = LOWER_32((ULONGLONG) inverse_divisor);
361
362 ah_bl = dividend_high * inverse_divisor_low;
363 al_bh = dividend_low * inverse_divisor_high;
364
365 result = (LONGLONG) ((dividend_high * inverse_divisor_high +
366 UPPER_32(ah_bl) +
367 UPPER_32(al_bh) +
368 UPPER_32(LOWER_32(ah_bl) + LOWER_32(al_bh) +
369 UPPER_32(dividend_low * inverse_divisor_low))) >> shift);
370
371 if (positive) {
372 return result;
373 } else {
374 return -result;
375 } /* if */
376 }
377
378
379 /*************************************************************************
380 * RtlInterlockedCompareExchange64 (NTDLL.@)
381 */
382 LONGLONG WINAPI RtlInterlockedCompareExchange64( LONGLONG *dest, LONGLONG xchg, LONGLONG compare )
383 {
384 return interlocked_cmpxchg64( dest, xchg, compare );
385 }
386
387 #endif /* _WIN64 */
388
389 /******************************************************************************
390 * RtlLargeIntegerToChar [NTDLL.@]
391 *
392 * Convert an unsigned large integer to a character string.
393 *
394 * RETURNS
395 * Success: STATUS_SUCCESS. str contains the converted number
396 * Failure: STATUS_INVALID_PARAMETER, if base is not 0, 2, 8, 10 or 16.
397 * STATUS_BUFFER_OVERFLOW, if str would be larger than length.
398 * STATUS_ACCESS_VIOLATION, if str is NULL.
399 *
400 * NOTES
401 * Instead of base 0 it uses 10 as base.
402 * Writes at most length characters to the string str.
403 * Str is '\0' terminated when length allows it.
404 * When str fits exactly in length characters the '\0' is omitted.
405 * If value_ptr is NULL it crashes, as the native function does.
406 *
407 * DIFFERENCES
408 * - Accept base 0 as 10 instead of crashing as native function does.
409 * - The native function does produce garbage or STATUS_BUFFER_OVERFLOW for
410 * base 2, 8 and 16 when the value is larger than 0xFFFFFFFF.
411 */
412 NTSTATUS WINAPI RtlLargeIntegerToChar(
413 const ULONGLONG *value_ptr, /* [I] Pointer to the value to be converted */
414 ULONG base, /* [I] Number base for conversion (allowed 0, 2, 8, 10 or 16) */
415 ULONG length, /* [I] Length of the str buffer in bytes */
416 PCHAR str) /* [O] Destination for the converted value */
417 {
418 ULONGLONG value = *value_ptr;
419 CHAR buffer[65];
420 PCHAR pos;
421 CHAR digit;
422 ULONG len;
423
424 if (base == 0) {
425 base = 10;
426 } else if (base != 2 && base != 8 && base != 10 && base != 16) {
427 return STATUS_INVALID_PARAMETER;
428 } /* if */
429
430 pos = &buffer[64];
431 *pos = '\0';
432
433 do {
434 pos--;
435 digit = value % base;
436 value = value / base;
437 if (digit < 10) {
438 *pos = '' + digit;
439 } else {
440 *pos = 'A' + digit - 10;
441 } /* if */
442 } while (value != 0L);
443
444 len = &buffer[64] - pos;
445 if (len > length) {
446 return STATUS_BUFFER_OVERFLOW;
447 } else if (str == NULL) {
448 return STATUS_ACCESS_VIOLATION;
449 } else if (len == length) {
450 memcpy(str, pos, len);
451 } else {
452 memcpy(str, pos, len + 1);
453 } /* if */
454 return STATUS_SUCCESS;
455 }
456
457
458 /**************************************************************************
459 * RtlInt64ToUnicodeString (NTDLL.@)
460 *
461 * Convert a large unsigned integer to a '\0' terminated unicode string.
462 *
463 * RETURNS
464 * Success: STATUS_SUCCESS. str contains the converted number
465 * Failure: STATUS_INVALID_PARAMETER, if base is not 0, 2, 8, 10 or 16.
466 * STATUS_BUFFER_OVERFLOW, if str is too small to hold the string
467 * (with the '\0' termination). In this case str->Length
468 * is set to the length, the string would have (which can
469 * be larger than the MaximumLength).
470 *
471 * NOTES
472 * Instead of base 0 it uses 10 as base.
473 * If str is NULL it crashes, as the native function does.
474 *
475 * DIFFERENCES
476 * - Accept base 0 as 10 instead of crashing as native function does.
477 * - Do not return STATUS_BUFFER_OVERFLOW when the string is long enough.
478 * The native function does this when the string would be longer than 31
479 * characters even when the string parameter is long enough.
480 * - The native function does produce garbage or STATUS_BUFFER_OVERFLOW for
481 * base 2, 8 and 16 when the value is larger than 0xFFFFFFFF.
482 */
483 NTSTATUS WINAPI RtlInt64ToUnicodeString(
484 ULONGLONG value, /* [I] Value to be converted */
485 ULONG base, /* [I] Number base for conversion (allowed 0, 2, 8, 10 or 16) */
486 UNICODE_STRING *str) /* [O] Destination for the converted value */
487 {
488 WCHAR buffer[65];
489 PWCHAR pos;
490 WCHAR digit;
491
492 if (base == 0) {
493 base = 10;
494 } else if (base != 2 && base != 8 && base != 10 && base != 16) {
495 return STATUS_INVALID_PARAMETER;
496 } /* if */
497
498 pos = &buffer[64];
499 *pos = '\0';
500
501 do {
502 pos--;
503 digit = value % base;
504 value = value / base;
505 if (digit < 10) {
506 *pos = '' + digit;
507 } else {
508 *pos = 'A' + digit - 10;
509 } /* if */
510 } while (value != 0L);
511
512 str->Length = (&buffer[64] - pos) * sizeof(WCHAR);
513 if (str->Length >= str->MaximumLength) {
514 return STATUS_BUFFER_OVERFLOW;
515 } else {
516 memcpy(str->Buffer, pos, str->Length + sizeof(WCHAR));
517 } /* if */
518 return STATUS_SUCCESS;
519 }
520
521
522 #ifdef __i386__
523
524 /******************************************************************************
525 * _alldiv (NTDLL.@)
526 *
527 * Divide two 64 bit unsigned integers.
528 *
529 * PARAMS
530 * a [I] Initial number.
531 * b [I] Number to divide a by.
532 *
533 * RETURNS
534 * The dividend of a and b.
535 */
536 LONGLONG WINAPI _alldiv( LONGLONG a, LONGLONG b )
537 {
538 return a / b;
539 }
540
541
542 /******************************************************************************
543 * _allmul (NTDLL.@)
544 *
545 * Multiply two 64 bit integers.
546 *
547 * PARAMS
548 * a [I] Initial number.
549 * b [I] Number to multiply a by.
550 *
551 * RETURNS
552 * The product of a and b.
553 */
554 LONGLONG WINAPI _allmul( LONGLONG a, LONGLONG b )
555 {
556 return a * b;
557 }
558
559
560 /******************************************************************************
561 * _allrem (NTDLL.@)
562 *
563 * Calculate the remainder after dividing two 64 bit integers.
564 *
565 * PARAMS
566 * a [I] Initial number.
567 * b [I] Number to divide a by.
568 *
569 * RETURNS
570 * The remainder of a divided by b.
571 */
572 LONGLONG WINAPI _allrem( LONGLONG a, LONGLONG b )
573 {
574 return a % b;
575 }
576
577
578 /******************************************************************************
579 * _aulldiv (NTDLL.@)
580 *
581 * Divide two 64 bit unsigned integers.
582 *
583 * PARAMS
584 * a [I] Initial number.
585 * b [I] Number to divide a by.
586 *
587 * RETURNS
588 * The dividend of a and b.
589 */
590 ULONGLONG WINAPI _aulldiv( ULONGLONG a, ULONGLONG b )
591 {
592 return a / b;
593 }
594
595
596 /******************************************************************************
597 * _aullrem (NTDLL.@)
598 *
599 * Calculate the remainder after dividing two 64 bit unsigned integers.
600 *
601 * PARAMS
602 * a [I] Initial number.
603 * b [I] Number to divide a by.
604 *
605 * RETURNS
606 * The remainder of a divided by b.
607 */
608 ULONGLONG WINAPI _aullrem( ULONGLONG a, ULONGLONG b )
609 {
610 return a % b;
611 }
612
613 #endif /* __i386__ */
614
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.